Opencv中Matx和Vec类型介绍

Matx是一个轻量级的Mat，定义时必须先确定下来Matx是存什么类型，大小几乘几。Vec是Matx的一个派生类，是一个一维的Matx，跟C++中的veceor向量相似。

Matx是一个模板类，定义时要确定2维大小和类型。

定义一个2*3大小的矩阵，存float类型。

1	Matx<float, 2, 3> mat23f;

Matx具体定义：

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

/** @brief Template class for small matrices whose type and size are known at compilation time

If you need a more flexible type, use Mat . The elements of the matrix M are accessible using the

M(i,j) notation. Most of the common matrix operations (see also @ref MatrixExpressions ) are

available. To do an operation on Matx that is not implemented, you can easily convert the matrix to

Mat and backwards:

@code{.cpp}

Matx33f m(1, 2, 3,

4, 5, 6,

7, 8, 9);

cout << sum(Mat(m*m.t())) << endl;

@endcode

Except of the plain constructor which takes a list of elements, Matx can be initialized from a C-array:

@code{.cpp}

float values[] = { 1, 2, 3};

Matx31f m(values);

@endcode

In case if C++11 features are available, std::initializer_list can be also used to initialize Matx:

@code{.cpp}

Matx31f m = { 1, 2, 3};

@endcode

template<typename _Tp, int m, int n> class Matx

{

public:

enum {

rows = m,

cols = n,

channels = rows*cols,

#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED

depth = traits::Type<_Tp>::value,

type = CV_MAKETYPE(depth, channels),

#endif

shortdim = (m < n ? m : n)

};

typedef _Tp value_type;

typedef Matx<_Tp, m, n> mat_type;

typedef Matx<_Tp, shortdim, 1> diag_type;

//! default constructor

Matx();

explicit Matx(_Tp v0); //!< 1x1 matrix

Matx(_Tp v0, _Tp v1); //!< 1x2 or 2x1 matrix

Matx(_Tp v0, _Tp v1, _Tp v2); //!< 1x3 or 3x1 matrix

Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3); //!< 1x4, 2x2 or 4x1 matrix

Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4); //!< 1x5 or 5x1 matrix

Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5); //!< 1x6, 2x3, 3x2 or 6x1 matrix

Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6); //!< 1x7 or 7x1 matrix

Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7); //!< 1x8, 2x4, 4x2 or 8x1 matrix

Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8); //!< 1x9, 3x3 or 9x1 matrix

Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9); //!< 1x10, 2x5 or 5x2 or 10x1 matrix

Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,

_Tp v4, _Tp v5, _Tp v6, _Tp v7,

_Tp v8, _Tp v9, _Tp v10, _Tp v11); //!< 1x12, 2x6, 3x4, 4x3, 6x2 or 12x1 matrix

Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,

_Tp v4, _Tp v5, _Tp v6, _Tp v7,

_Tp v8, _Tp v9, _Tp v10, _Tp v11,

_Tp v12, _Tp v13); //!< 1x14, 2x7, 7x2 or 14x1 matrix

Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,

_Tp v4, _Tp v5, _Tp v6, _Tp v7,

_Tp v8, _Tp v9, _Tp v10, _Tp v11,

_Tp v12, _Tp v13, _Tp v14, _Tp v15); //!< 1x16, 4x4 or 16x1 matrix

explicit Matx(const _Tp* vals); //!< initialize from a plain array

#ifdef CV_CXX11

Matx(std::initializer_list<_Tp>); //!< initialize from an initializer list

#endif

static Matx all(_Tp alpha);

static Matx zeros();

static Matx ones();

static Matx eye();

static Matx diag(const diag_type& d);

static Matx randu(_Tp a, _Tp b);

static Matx randn(_Tp a, _Tp b);

//! dot product computed with the default precision

_Tp dot(const Matx<_Tp, m, n>& v) const;

//! dot product computed in double-precision arithmetics

double ddot(const Matx<_Tp, m, n>& v) const;

//! conversion to another data type

template<typename T2> operator Matx<T2, m, n>() const;

//! change the matrix shape

template<int m1, int n1> Matx<_Tp, m1, n1> reshape() const;

//! extract part of the matrix

template<int m1, int n1> Matx<_Tp, m1, n1> get_minor(int base_row, int base_col) const;

//! extract the matrix row

Matx<_Tp, 1, n> row(int i) const;

//! extract the matrix column

Matx<_Tp, m, 1> col(int i) const;

//! extract the matrix diagonal

diag_type diag() const;

//! transpose the matrix

Matx<_Tp, n, m> t() const;

//! invert the matrix

Matx<_Tp, n, m> inv(int method=DECOMP_LU, bool *p_is_ok = NULL) const;

//! solve linear system

template<int l> Matx<_Tp, n, l> solve(const Matx<_Tp, m, l>& rhs, int flags=DECOMP_LU) const;

Vec<_Tp, n> solve(const Vec<_Tp, m>& rhs, int method) const;

//! multiply two matrices element-wise

Matx<_Tp, m, n> mul(const Matx<_Tp, m, n>& a) const;

//! divide two matrices element-wise

Matx<_Tp, m, n> div(const Matx<_Tp, m, n>& a) const;

//! element access

const _Tp& operator ()(int row, int col) const;

_Tp& operator ()(int row, int col);

//! 1D element access

const _Tp& operator ()(int i) const;

_Tp& operator ()(int i);

Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_AddOp);

Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_SubOp);

template<typename _T2> Matx(const Matx<_Tp, m, n>& a, _T2 alpha, Matx_ScaleOp);

Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_MulOp);

Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_DivOp);

template<int l> Matx(const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b, Matx_MatMulOp);

Matx(const Matx<_Tp, n, m>& a, Matx_TOp);

_Tp val[m*n]; //< matrix elements

};

Opencv定义了一些Matx类型别名：

typedef Matx<float, 1, 2> Matx12f;

typedef Matx<double, 1, 2> Matx12d;

typedef Matx<float, 1, 3> Matx13f;

typedef Matx<double, 1, 3> Matx13d;

typedef Matx<float, 1, 4> Matx14f;

typedef Matx<double, 1, 4> Matx14d;

typedef Matx<float, 1, 6> Matx16f;

typedef Matx<double, 1, 6> Matx16d;

typedef Matx<float, 2, 1> Matx21f;

typedef Matx<double, 2, 1> Matx21d;

typedef Matx<float, 3, 1> Matx31f;

typedef Matx<double, 3, 1> Matx31d;

typedef Matx<float, 4, 1> Matx41f;

typedef Matx<double, 4, 1> Matx41d;

typedef Matx<float, 6, 1> Matx61f;

typedef Matx<double, 6, 1> Matx61d;

typedef Matx<float, 2, 2> Matx22f;

typedef Matx<double, 2, 2> Matx22d;

typedef Matx<float, 2, 3> Matx23f;

typedef Matx<double, 2, 3> Matx23d;

typedef Matx<float, 3, 2> Matx32f;

typedef Matx<double, 3, 2> Matx32d;

typedef Matx<float, 3, 3> Matx33f;

typedef Matx<double, 3, 3> Matx33d;

typedef Matx<float, 3, 4> Matx34f;

typedef Matx<double, 3, 4> Matx34d;

typedef Matx<float, 4, 3> Matx43f;

typedef Matx<double, 4, 3> Matx43d;

typedef Matx<float, 4, 4> Matx44f;

typedef Matx<double, 4, 4> Matx44d;

typedef Matx<float, 6, 6> Matx66f;

typedef Matx<double, 6, 6> Matx66d;

Vec类继承自Matx，Vec是一维的Matx，具体定义如下：

/////////////////////// Vec (used as element of multi-channel images /////////////////////

/** @brief Template class for short numerical vectors, a partial case of Matx

This template class represents short numerical vectors (of 1, 2, 3, 4 ... elements) on which you

can perform basic arithmetical operations, access individual elements using [] operator etc. The

vectors are allocated on stack, as opposite to std::valarray, std::vector, cv::Mat etc., which

elements are dynamically allocated in the heap.

The template takes 2 parameters:

@tparam _Tp element type

@tparam cn the number of elements

In addition to the universal notation like Vec<float, 3>, you can use shorter aliases

for the most popular specialized variants of Vec, e.g. Vec3f ~ Vec<float, 3>.

It is possible to convert Vec\<T,2\> to/from Point_, Vec\<T,3\> to/from Point3_ , and Vec\<T,4\>

to CvScalar or Scalar_. Use operator[] to access the elements of Vec.

All the expected vector operations are also implemented:

- v1 = v2 + v3

- v1 = v2 - v3

- v1 = v2 \* scale

- v1 = scale \* v2

- v1 = -v2

- v1 += v2 and other augmenting operations

- v1 == v2, v1 != v2

- norm(v1) (euclidean norm)

The Vec class is commonly used to describe pixel types of multi-channel arrays. See Mat for details.

template<typename _Tp, int cn> class Vec : public Matx<_Tp, cn, 1>

{

public:

typedef _Tp value_type;

enum {

channels = cn,

#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED

depth = Matx<_Tp, cn, 1>::depth,

type = CV_MAKETYPE(depth, channels),

#endif

_dummy_enum_finalizer = 0

};

//! default constructor

Vec();

Vec(_Tp v0); //!< 1-element vector constructor

Vec(_Tp v0, _Tp v1); //!< 2-element vector constructor

Vec(_Tp v0, _Tp v1, _Tp v2); //!< 3-element vector constructor

Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3); //!< 4-element vector constructor

Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4); //!< 5-element vector constructor

Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5); //!< 6-element vector constructor

Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6); //!< 7-element vector constructor

Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7); //!< 8-element vector constructor

Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8); //!< 9-element vector constructor

Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9); //!< 10-element vector constructor

Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9, _Tp v10, _Tp v11, _Tp v12, _Tp v13); //!< 14-element vector constructor

explicit Vec(const _Tp* values);

#ifdef CV_CXX11

Vec(std::initializer_list<_Tp>);

#endif

Vec(const Vec<_Tp, cn>& v);

static Vec all(_Tp alpha);

//! per-element multiplication

Vec mul(const Vec<_Tp, cn>& v) const;

//! conjugation (makes sense for complex numbers and quaternions)

Vec conj() const;

/*!

cross product of the two 3D vectors.

For other dimensionalities the exception is raised

Vec cross(const Vec& v) const;

//! conversion to another data type

template<typename T2> operator Vec<T2, cn>() const;

/*! element access */

const _Tp& operator [](int i) const;

_Tp& operator[](int i);

const _Tp& operator ()(int i) const;

_Tp& operator ()(int i);

#ifdef CV_CXX11

Vec<_Tp, cn>& operator=(const Vec<_Tp, cn>& rhs) = default;

#endif

Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_AddOp);

Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_SubOp);

template<typename _T2> Vec(const Matx<_Tp, cn, 1>& a, _T2 alpha, Matx_ScaleOp);

};

Opencv定义了一些Vec类型别名：

/** @name Shorter aliases for the most popular specializations of Vec<T,n>

typedef Vec<uchar, 2> Vec2b;

typedef Vec<uchar, 3> Vec3b;

typedef Vec<uchar, 4> Vec4b;

typedef Vec<short, 2> Vec2s;

typedef Vec<short, 3> Vec3s;

typedef Vec<short, 4> Vec4s;

typedef Vec<ushort, 2> Vec2w;

typedef Vec<ushort, 3> Vec3w;

typedef Vec<ushort, 4> Vec4w;

typedef Vec<int, 2> Vec2i;

typedef Vec<int, 3> Vec3i;

typedef Vec<int, 4> Vec4i;

typedef Vec<int, 6> Vec6i;

typedef Vec<int, 8> Vec8i;

typedef Vec<float, 2> Vec2f;

typedef Vec<float, 3> Vec3f;

typedef Vec<float, 4> Vec4f;

typedef Vec<float, 6> Vec6f;

typedef Vec<double, 2> Vec2d;

typedef Vec<double, 3> Vec3d;

typedef Vec<double, 4> Vec4d;

typedef Vec<double, 6> Vec6d;

/** @} */

从以上可以看出Matx类型是一个二维的矩阵，Vec是一个维的向量，Vec继承于Matx。

相关文章: