一、基础数据类型
1.(基础)固定大小矩阵类 matx
说明：
① 基础矩阵是我个人增加的描述，相对于Mat矩阵类(存储图像信息的大矩阵)而言。
② 固定大小矩阵类必须在编译期间就知晓其维度(矩阵大小)和类型(矩阵元素类型)，用于某些特定的矩阵运算。数据存储也在栈上。
③ 机器视觉领域，通常这些矩阵一般是2x2或3x3维度，较少有4x4维矩阵用于大量的转换工作。故Matx.hpp头文件被专门设计来容纳这类操作。
④ 实际运用中单纯的运算matx矩阵操作是不执行的，通常都是将其转换为Mat矩阵或反向矩阵，使用上重命名机制(通过typedef关键字)：Matx{1,2,3,4,6}{1,2,3,4,6}{f,d}
例如：Matx33f 表示一个数据类型是float类型的3x3矩阵，类似地，Matx24d；
初始化两种方式：
Ⅰ初始化元素列表：如源码中示例：求3x3矩阵的对称矩阵的每个元素之和(将Matx转换为Mat矩阵进行运算);
1 //Ⅰ初始化列表方式进行初始化
2 #include "opencv2/opencv.hpp"
3 #include "iostream"
4
5 using namespace cv;
6 using namespace std;
7
8 int main()
9 {
10 Matx33f m0(1, 2, 3,
11 4, 5, 6,
12 7, 8, 9);
13 cout << "A = " << endl; //原矩阵
14 cout << m0 << endl;
15 cout << "AT = " << endl;
16 cout << m0.t() << endl; //原矩阵的转置
17 cout << "Mat(AT) = " << endl;
18 cout << Mat(m0.t()) << endl; //转换到Mat类数组，便于其他操作
19
20 cout << "Rank(A) = " << endl;
21 cout << Mat(m0*m0.t()) << endl; //求原矩阵的对称矩阵 = 原矩阵 X 原矩阵的转置矩阵
22
23 cout << "The sum of rank(A)'s elemente is = " << endl;
24 cout << sum(Mat(m0*m0.t())) << endl; //Mat类通道未指定默认为1，sum()函数是依据通道数来计算矩阵数据的和
25 return 0;
26 }
ⅡC原生数组方式进行初始化：
1 //Ⅱ C原生数组方式进行初始化
2 #include "opencv2/opencv.hpp"
3 #include "iostream"
4
5 using namespace cv;
6 using namespace std;
7
8 int main()
9 {
10 float vals[] ={1, 2, 3,
11 4, 5, 6,
12 7, 8, 9};
13 Matx33f m0(vals);
14 cout << "A = " << endl; //原矩阵
15 cout << m0 << endl;
16 cout << "AT = " << endl;
17 cout << m0.t() << endl; //原矩阵的转置
18 cout << "Mat(AT) = " << endl;
19 cout << Mat(m0.t()) << endl; //转换到Mat类数组，便于其他操作
20
21 cout << "Rank(A) = " << endl;
22 cout << Mat(m0*m0.t()) << endl; //求原矩阵的对称矩阵 = 原矩阵 X 原矩阵的转置矩阵
23
24 cout << "The sum of rank(A)'s elemente is = " << endl;
25 cout << sum(Mat(m0*m0.t())) << endl; //Mat类通道未指定默认为1，sum()函数是依据通道数来计算矩阵数据的和
26 return 0;
27 }
⑤ 矩阵运算：加、减、缩放、乘、除、(矩阵)乘、转置
2.固定大小向量类 vector
说明：
① 图像处理方面固定大小向量类(直接使用基础数据类型利用模板技术(template class Vec<>)定义)用来描述多通道图像的像素类型信息的类。使用模板技术这允许特别高效的代码处理小的通用操作，例如基本的算数操作，通过[]操作符读取元素数据等。
②
OpenCV与C++ STL中的向量类比对 |
||
Item |
OpenCV |
C++ STL |
数据存储 |
栈 加快程序的运行效率(节省动态申请的时间) |
堆 动态申请内存 |
容器类型 |
1.固定大小向量类在编译期间就知道维度的向量且维度相对小 2.通常情况下仅用来装载C语言中原生的int或float基本类型 |
可以装载任何类型甚至包含自定义的类类型。 |
④ 向量运算：加，减，缩放，求负，两向量间比较③ 在OpenCV中继承自Matx类，常用的单向量使用上重命名机制(通过typedef关键字)：Vec{2, 3, 4, 6}{b, w, s, i, f, d};
例如：Vec2i 表示一个列向量，向量元素有两个整型类型的数值，即2维列向量。
1 #include "opencv2/opencv.hpp"
2 #include "iostream"
3
4 using namespace cv;
5 using namespace std;
6
7 int main()
8 {
9 Vec2i t(2, 5);
10 cout << t << endl;
11 return 0;
12 }
二、源代码剖析
1 /*
2 * This program is free software; and the content, which just do a change in the order and text,
3 * comes from offical documents. Only permission is hereby granted to learn and communication.
4 *
5 * Document: D:\Qt\opencvbuild3.40\install\include\opencv2\core\matx.hpp
6 * Environment: QT 5.10.0 + OpenCV 3.4.0
7 * place: Library, Wj 2018.03.17
8 */
9
10 #ifndef OPENCV_CORE_MATX_HPP
11 #define OPENCV_CORE_MATX_HPP
12
13 #ifndef __cplusplus
14 # error matx.hpp header must be compiled as C++
15 #endif
16
17 #include "opencv2/core/cvdef.h"
18 #include "opencv2/core/base.hpp"
19 #include "opencv2/core/traits.hpp"
20 #include "opencv2/core/saturate.hpp"
21
22 #ifdef CV_CXX11
23 #include <initializer_list>
24 #endif
25
26 namespace cv
27 {
28
29 ////////////////////////////// Small Matrix ///////////////////////////
30 //矩阵基本运算：加、减、缩放、乘、除、(矩阵)乘、转置
31
32 struct CV_EXPORTS Matx_AddOp {};
33 struct CV_EXPORTS Matx_SubOp {};
34 struct CV_EXPORTS Matx_ScaleOp {};
35 struct CV_EXPORTS Matx_MulOp {};
36 struct CV_EXPORTS Matx_DivOp {};
37 struct CV_EXPORTS Matx_MatMulOp {};
38 struct CV_EXPORTS Matx_TOp {};
39
40 template<typename _Tp, int m, int n>
41 class Matx
42 {
43 public:
44 //枚举类型实质上是整数的别名，这里结合模板技术在构建对象时，矩阵的维度是只读的变量；
45 enum {
46 rows = m, //行
47 cols = n, //列
48 channels = rows*cols, //元素数量
49 shortdim = (m < n ? m : n) //维度较小的那个变量，用于矩阵的秩
50 };
51 //Matx 成员变量仅是一个mxn数组
52 _Tp val[m*n]; //< matrix elements
53
54 typedef _Tp value_type;
55 typedef Matx<_Tp, m, n> mat_type;
56 typedef Matx<_Tp, shortdim, 1> diag_type;
57
58 // default constructor 构造函数
59 // 直接使用参数列表目前最多16维度(16x1 or 4x4)，再多考虑是否应该使用Mat类
60
61 Matx()
62 {
63 for(int i = 0; i < channels; i++) val[i] = _Tp(0);
64 }
65
66 Matx(_Tp v0) //!< 1x1 matrix
67 {
68 val[0] = v0;
69 for(int i = 1; i < channels; i++) val[i] = _Tp(0);
70 }
71 Matx(_Tp v0, _Tp v1) //!< 1x2 or 2x1 matrix
72 {
73 CV_StaticAssert(channels >= 2, "Matx should have at least 2 elements.");
74 val[0] = v0; val[1] = v1;
75 for(int i = 2; i < channels; i++) val[i] = _Tp(0);
76 }
77 Matx(_Tp v0, _Tp v1, _Tp v2); //!< 1x3 or 3x1 matrix
78 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3); //!< 1x4, 2x2 or 4x1 matrix
79 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4); //!< 1x5 or 5x1 matrix
80 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5);
81 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6);
82 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7);
83 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8);
84 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9);
85 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
86 _Tp v4, _Tp v5, _Tp v6, _Tp v7,
87 _Tp v8, _Tp v9, _Tp v10, _Tp v11); //!< 1x12, 2x6, 3x4, 4x3, 6x2 or 12x1 matrix
88 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
89 _Tp v4, _Tp v5, _Tp v6, _Tp v7,
90 _Tp v8, _Tp v9, _Tp v10, _Tp v11,
91 _Tp v12, _Tp v13); //!< 1x14, 2x7, 7x2 or 14x1 matrix
92 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
93 _Tp v4, _Tp v5, _Tp v6, _Tp v7,
94 _Tp v8, _Tp v9, _Tp v10, _Tp v11,
95 _Tp v12, _Tp v13, _Tp v14, _Tp v15); //!< 1x16, 4x4 or 16x1 matrix
96
97 // C语言中的普通数组形式进行构造对象
98 explicit Matx(const _Tp* vals); //!< initialize from a plain array
99 // C11 初始化列表新特性
100 #ifdef CV_CXX11
101 Matx(std::initializer_list<_Tp>); //!< initialize from an initializer list
102 #endif
103
104 //静态类成员函数，用于生成特殊的矩阵，便于矩阵的运算操作
105 static Matx all(_Tp alpha) // 将矩阵中的所有元素全都替换成alpha数值
106 {
107 Matx<_Tp, m, n> M;
108 for( int i = 0; i < m*n; i++ )
109 M.val[i] = alpha;
110 return M;
111 }
112 static Matx zeros() // 生成固定大小的零矩阵，Matx<int, 3, 3> t; t.zeros();
113 {
114 return all(0);
115 }
116
117 static Matx ones() // 生成固定大小的数据元素全是1的矩阵
118 {
119 return all(1);
120 }
121 static Matx eye() // 生成固定大小的单位矩阵
122 {
123 Matx<_Tp,m,n> M;
124 for(int i = 0; i < shortdim; i++)
125 M(i,i) = 1;
126 return M;
127 }
128 static Matx diag(const diag_type& d) // 生成固定大小的对角阵
129 {
130 Matx<_Tp,m,n> M;
131 for(int i = 0; i < shortdim; i++)
132 M(i,i) = d(i, 0);
133 return M;
134 }
135 static Matx randu(_Tp a, _Tp b); // 随机阵但源码没有找到相关定义
136 static Matx randn(_Tp a, _Tp b); // 随机阵但源码没有找到相关定义
137
138
139
140
141 //! dot product computed with the default precision
142 //矩阵的点积运算
143 _Tp dot(const Matx<_Tp, m, n>& M) const;
144 {
145 _Tp s = 0;
146 for( int i = 0; i < channels; i++ )
147 s += val[i]*M.val[i];
148 return s;
149 }
150
151 //! dot product computed in double-precision arithmetics
152 double ddot(const Matx<_Tp, m, n>& M) const
153 {
154 double s = 0;
155 for( int i = 0; i < channels; i++ )
156 s += (double)val[i]*M.val[i];
157 return s;
158 }
159
160
161 //! conversion to another data type
162 // saturate_cast用于防止数据溢出，后续有专文讨论。
163 template<typename T2> operator Matx<T2, m, n>()
164 {
165 Matx<T2, m, n> M;
166 for( int i = 0; i < m*n; i++ )
167 M.val[i] = saturate_cast<T2>(val[i]);
168 return M;
169 }
170
171
172 //! change the matrix shape
173 template<int m1, int n1> Matx<_Tp, m1, n1> reshape() const
174 {
175 CV_StaticAssert(m1*n1 == m*n, "Input and destnarion matrices must have the same number of elements");
176 return (const Matx<_Tp, m1, n1>&)*this;
177 }
178 //! extract part of the matrix
179 template<int m1, int n1> Matx<_Tp, m1, n1> get_minor(int i, int j) const
180 {
181 CV_DbgAssert(0 <= i && i+m1 <= m && 0 <= j && j+n1 <= n);
182 Matx<_Tp, m1, n1> s;
183 for( int di = 0; di < m1; di++ )
184 for( int dj = 0; dj < n1; dj++ )
185 s(di, dj) = (*this)(i+di, j+dj);
186 return s;
187 }
188
189 //! extract the matrix row
190 Matx<_Tp, 1, n> row(int i) const
191 {
192 CV_DbgAssert((unsigned)i < (unsigned)m);
193 return Matx<_Tp, 1, n>(&val[i*n]);
194 }
195
196
197 //! extract the matrix column
198 Matx<_Tp, m, 1> col(int i) const
199 {
200 CV_DbgAssert((unsigned)j < (unsigned)n);
201 Matx<_Tp, m, 1> v;
202 for( int i = 0; i < m; i++ )
203 v.val[i] = val[i*n + j];
204 return v;
205 }
206
207 //! extract the matrix diagonal
208 diag_type diag() const
209 {
210 diag_type d;
211 for( int i = 0; i < shortdim; i++ )
212 d.val[i] = val[i*n + i];
213 return d;
214 }
215 //! transpose the matrix
216 Matx<_Tp, n, m> t() const
217 {
218 return Matx<_Tp, n, m>(*this, Matx_TOp());
219 }
220
221 //! multiply two matrices element-wise
222 Matx<_Tp, m, n> mul(const Matx<_Tp, m, n>& a) const
223 {
224 return Matx<_Tp, m, n>(*this, a, Matx_MulOp());
225 }
226
227 //! divide two matrices element-wise
228 Matx<_Tp, m, n> div(const Matx<_Tp, m, n>& a) const
229 {
230 return Matx<_Tp, m, n>(*this, a, Matx_DivOp());
231 }
232
233 //! element access
234 const _Tp& operator ()(int i, int j) const
235 {
236 CV_DbgAssert( (unsigned)i < (unsigned)m && (unsigned)j < (unsigned)n );
237 return this->val[i*n + j];
238 }
239
240 _Tp& operator ()(int i, int j);
241 {
242 CV_DbgAssert( (unsigned)i < (unsigned)m && (unsigned)j < (unsigned)n );
243 return val[i*n + j];
244 }
245 //! 1D element access
246 const _Tp& operator ()(int i) const
247 {
248 CV_StaticAssert(m == 1 || n == 1, "Single index indexation requires matrix to be a column or a row");
249 CV_DbgAssert( (unsigned)i < (unsigned)(m+n-1) );
250 return val[i];
251 }
252
253 _Tp& operator ()(int i);
254 {
255 CV_StaticAssert(m == 1 || n == 1, "Single index indexation requires matrix to be a column or a row");
256 CV_DbgAssert( (unsigned)i < (unsigned)(m+n-1) );
257 return val[i];
258 }
259
260 //矩阵运算
261 Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_AddOp)
262 {
263 for( int i = 0; i < channels; i++ )
264 val[i] = saturate_cast<_Tp>(a.val[i] + b.val[i]);
265 }
266
267 Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_SubOp);
268 {
269 for( int i = 0; i < channels; i++ )
270 val[i] = saturate_cast<_Tp>(a.val[i] - b.val[i]);
271 }
272
273 template<typename _T2> Matx(const Matx<_Tp, m, n>& a, _T2 alpha, Matx_ScaleOp)
274 {
275 for( int i = 0; i < channels; i++ )
276 val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
277 }
278
279 Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_MulOp)
280 {
281 for( int i = 0; i < channels; i++ )
282 val[i] = saturate_cast<_Tp>(a.val[i] * b.val[i]);
283 }
284
285 Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_DivOp)
286 {
287 for( int i = 0; i < channels; i++ )
288 val[i] = saturate_cast<_Tp>(a.val[i] / b.val[i]);
289 }
290
291 template<int l> Matx(const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b, Matx_MatMulOp)
292 {
293 for( int i = 0; i < m; i++ )
294 for( int j = 0; j < n; j++ )
295 {
296 _Tp s = 0;
297 for( int k = 0; k < l; k++ )
298 s += a(i, k) * b(k, j);
299 val[i*n + j] = s;
300 }
301 }
302 Matx(const Matx<_Tp, n, m>& a, Matx_TOp)
303 {
304 for( int i = 0; i < m; i++ )
305 for( int j = 0; j < n; j++ )
306 val[i*n + j] = a(j, i);
307 }
308
309
310 //! invert the matrix 求逆
311 Matx<_Tp, n, m> inv(int method=DECOMP_LU, bool *p_is_ok = NULL) const;
312
313 //! solve linear system 求线性方程
314 template<int l> Matx<_Tp, n, l> solve(const Matx<_Tp, m, l>& rhs, int flags=DECOMP_LU) const;
315 Vec<_Tp, n> solve(const Vec<_Tp, m>& rhs, int method) const
316 {
317 Matx<_Tp, n, 1> x = solve((const Matx<_Tp, m, 1>&)(rhs), method);
318 return (Vec<_Tp, n>&)(x);
319 }
320
321 };
322
323 typedef Matx<float, 1, 2> Matx12f;
324 typedef Matx<double, 1, 2> Matx12d;
325 typedef Matx<float, 1, 3> Matx13f;
326 typedef Matx<double, 1, 3> Matx13d;
327 typedef Matx<float, 1, 4> Matx14f;
328 typedef Matx<double, 1, 4> Matx14d;
329 typedef Matx<float, 1, 6> Matx16f;
330 typedef Matx<double, 1, 6> Matx16d;
331
332 typedef Matx<float, 2, 1> Matx21f;
333 typedef Matx<double, 2, 1> Matx21d;
334 typedef Matx<float, 3, 1> Matx31f;
335 typedef Matx<double, 3, 1> Matx31d;
336 typedef Matx<float, 4, 1> Matx41f;
337 typedef Matx<double, 4, 1> Matx41d;
338 typedef Matx<float, 6, 1> Matx61f;
339 typedef Matx<double, 6, 1> Matx61d;
340
341 typedef Matx<float, 2, 2> Matx22f;
342 typedef Matx<double, 2, 2> Matx22d;
343 typedef Matx<float, 2, 3> Matx23f;
344 typedef Matx<double, 2, 3> Matx23d;
345 typedef Matx<float, 3, 2> Matx32f;
346 typedef Matx<double, 3, 2> Matx32d;
347
348 typedef Matx<float, 3, 3> Matx33f;
349 typedef Matx<double, 3, 3> Matx33d;
350
351 typedef Matx<float, 3, 4> Matx34f;
352 typedef Matx<double, 3, 4> Matx34d;
353 typedef Matx<float, 4, 3> Matx43f;
354 typedef Matx<double, 4, 3> Matx43d;
355
356 typedef Matx<float, 4, 4> Matx44f;
357 typedef Matx<double, 4, 4> Matx44d;
358 typedef Matx<float, 6, 6> Matx66f;
359 typedef Matx<double, 6, 6> Matx66d;
360
361 #endif // OPENCV_CORE_MATX_HPP