OpenCV 4.5.3(日本語機械翻訳)
matx.hpp
1 /*M///////////////////////////////////////////////////////////////////////////////////////
2 //
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4 //
5 // By downloading, copying, installing or using the software you agree to this license.
6 // If you do not agree to this license, do not download, install,
7 // copy or use the software.
8 //
9 //
10 // License Agreement
11 // For Open Source Computer Vision Library
12 //
13 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
14 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
15 // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
16 // Third party copyrights are property of their respective owners.
17 //
18 // Redistribution and use in source and binary forms, with or without modification,
19 // are permitted provided that the following conditions are met:
20 //
21 // * Redistribution's of source code must retain the above copyright notice,
22 // this list of conditions and the following disclaimer.
23 //
24 // * Redistribution's in binary form must reproduce the above copyright notice,
25 // this list of conditions and the following disclaimer in the documentation
26 // and/or other materials provided with the distribution.
27 //
28 // * The name of the copyright holders may not be used to endorse or promote products
29 // derived from this software without specific prior written permission.
30 //
31 // This software is provided by the copyright holders and contributors "as is" and
32 // any express or implied warranties, including, but not limited to, the implied
33 // warranties of merchantability and fitness for a particular purpose are disclaimed.
34 // In no event shall the Intel Corporation or contributors be liable for any direct,
35 // indirect, incidental, special, exemplary, or consequential damages
36 // (including, but not limited to, procurement of substitute goods or services;
37 // loss of use, data, or profits; or business interruption) however caused
38 // and on any theory of liability, whether in contract, strict liability,
39 // or tort (including negligence or otherwise) arising in any way out of
40 // the use of this software, even if advised of the possibility of such damage.
41 //
42 //M*/
43
44 #ifndef OPENCV_CORE_MATX_HPP
45 #define OPENCV_CORE_MATX_HPP
46
47 #ifndef __cplusplus
48 # error matx.hpp header must be compiled as C++
49 #endif
50
51 #include "opencv2/core/cvdef.h"
52 #include "opencv2/core/base.hpp"
53 #include "opencv2/core/traits.hpp"
54 #include "opencv2/core/saturate.hpp"
55
56 #include <initializer_list>
57
58 namespace cv
59{
60
63
65
67 // FIXIT Remove this (especially CV_EXPORTS modifier)
68 struct CV_EXPORTS Matx_AddOp { Matx_AddOp() {} Matx_AddOp(const Matx_AddOp&) {} };
69 struct CV_EXPORTS Matx_SubOp { Matx_SubOp() {} Matx_SubOp(const Matx_SubOp&) {} };
70 struct CV_EXPORTS Matx_ScaleOp { Matx_ScaleOp() {} Matx_ScaleOp(const Matx_ScaleOp&) {} };
71 struct CV_EXPORTS Matx_MulOp { Matx_MulOp() {} Matx_MulOp(const Matx_MulOp&) {} };
72 struct CV_EXPORTS Matx_DivOp { Matx_DivOp() {} Matx_DivOp(const Matx_DivOp&) {} };
73 struct CV_EXPORTS Matx_MatMulOp { Matx_MatMulOp() {} Matx_MatMulOp(const Matx_MatMulOp&) {} };
74 struct CV_EXPORTS Matx_TOp { Matx_TOp() {} Matx_TOp(const Matx_TOp&) {} };
76
99 template<typename _Tp, int m, int n> class Matx
100{
101 public:
102 enum {
103 rows = m,
104 cols = n,
105 channels = rows*cols,
106 #ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
107 depth = traits::Type<_Tp>::value,
108 type = CV_MAKETYPE(depth, channels),
109 #endif
110 shortdim = (m < n ? m : n)
111 };
112
113 typedef _Tp value_type;
114 typedef Matx<_Tp, m, n> mat_type;
115 typedef Matx<_Tp, shortdim, 1> diag_type;
116
118 Matx();
119
120 explicit Matx(_Tp v0);
121 Matx(_Tp v0, _Tp v1);
122 Matx(_Tp v0, _Tp v1, _Tp v2);
123 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3);
124 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4);
125 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5);
126 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6);
127 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7);
128 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8);
129 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9);
130 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
131 _Tp v4, _Tp v5, _Tp v6, _Tp v7,
132 _Tp v8, _Tp v9, _Tp v10, _Tp v11);
133 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
134 _Tp v4, _Tp v5, _Tp v6, _Tp v7,
135 _Tp v8, _Tp v9, _Tp v10, _Tp v11,
136 _Tp v12, _Tp v13);
137 Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,
138 _Tp v4, _Tp v5, _Tp v6, _Tp v7,
139 _Tp v8, _Tp v9, _Tp v10, _Tp v11,
140 _Tp v12, _Tp v13, _Tp v14, _Tp v15);
141 explicit Matx(const _Tp* vals);
142
143 Matx(std::initializer_list<_Tp>);
144
145 static Matx all(_Tp alpha);
146 static Matx zeros();
147 static Matx ones();
148 static Matx eye();
149 static Matx diag(const diag_type& d);
155 static Matx randu(_Tp a, _Tp b);
160 static Matx randn(_Tp a, _Tp b);
161
163 _Tp dot(const Matx<_Tp, m, n>& v) const;
164
166 double ddot(const Matx<_Tp, m, n>& v) const;
167
169 template<typename T2> operator Matx<T2, m, n>() const;
170
172 template<int m1, int n1> Matx<_Tp, m1, n1> reshape() const;
173
175 template<int m1, int n1> Matx<_Tp, m1, n1> get_minor(int base_row, int base_col) const;
176
178 Matx<_Tp, 1, n> row(int i) const;
179
181 Matx<_Tp, m, 1> col(int i) const;
182
184 diag_type diag() const;
185
187 Matx<_Tp, n, m> t() const;
188
190 Matx<_Tp, n, m> inv(int method=DECOMP_LU, bool *p_is_ok = NULL) const;
191
193 template<int l> Matx<_Tp, n, l> solve(const Matx<_Tp, m, l>& rhs, int flags=DECOMP_LU) const;
194 Vec<_Tp, n> solve(const Vec<_Tp, m>& rhs, int method) const;
195
197 Matx<_Tp, m, n> mul(const Matx<_Tp, m, n>& a) const;
198
200 Matx<_Tp, m, n> div(const Matx<_Tp, m, n>& a) const;
201
203 const _Tp& operator ()(int row, int col) const;
204 _Tp& operator ()(int row, int col);
205
207 const _Tp& operator ()(int i) const;
208 _Tp& operator ()(int i);
209
210 Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_AddOp);
211 Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_SubOp);
212 template<typename _T2> Matx(const Matx<_Tp, m, n>& a, _T2 alpha, Matx_ScaleOp);
213 Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_MulOp);
214 Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_DivOp);
215 template<int l> Matx(const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b, Matx_MatMulOp);
216 Matx(const Matx<_Tp, n, m>& a, Matx_TOp);
217
218 _Tp val[m*n]; //< matrix elements
219};
220
221 typedef Matx<float, 1, 2> Matx12f;
222 typedef Matx<double, 1, 2> Matx12d;
223 typedef Matx<float, 1, 3> Matx13f;
224 typedef Matx<double, 1, 3> Matx13d;
225 typedef Matx<float, 1, 4> Matx14f;
226 typedef Matx<double, 1, 4> Matx14d;
227 typedef Matx<float, 1, 6> Matx16f;
228 typedef Matx<double, 1, 6> Matx16d;
229
230 typedef Matx<float, 2, 1> Matx21f;
231 typedef Matx<double, 2, 1> Matx21d;
232 typedef Matx<float, 3, 1> Matx31f;
233 typedef Matx<double, 3, 1> Matx31d;
234 typedef Matx<float, 4, 1> Matx41f;
235 typedef Matx<double, 4, 1> Matx41d;
236 typedef Matx<float, 6, 1> Matx61f;
237 typedef Matx<double, 6, 1> Matx61d;
238
239 typedef Matx<float, 2, 2> Matx22f;
240 typedef Matx<double, 2, 2> Matx22d;
241 typedef Matx<float, 2, 3> Matx23f;
242 typedef Matx<double, 2, 3> Matx23d;
243 typedef Matx<float, 3, 2> Matx32f;
244 typedef Matx<double, 3, 2> Matx32d;
245
246 typedef Matx<float, 3, 3> Matx33f;
247 typedef Matx<double, 3, 3> Matx33d;
248
249 typedef Matx<float, 3, 4> Matx34f;
250 typedef Matx<double, 3, 4> Matx34d;
251 typedef Matx<float, 4, 3> Matx43f;
252 typedef Matx<double, 4, 3> Matx43d;
253
254 typedef Matx<float, 4, 4> Matx44f;
255 typedef Matx<double, 4, 4> Matx44d;
256 typedef Matx<float, 6, 6> Matx66f;
257 typedef Matx<double, 6, 6> Matx66d;
258
262 template<typename _Tp, int m, int n> class DataType< Matx<_Tp, m, n> >
263{
264 public:
265 typedef Matx<_Tp, m, n> value_type;
266 typedef Matx<typename DataType<_Tp>::work_type, m, n> work_type;
267 typedef _Tp channel_type;
268 typedef value_type vec_type;
269
270 enum { generic_type = 0,
271 channels = m * n,
272 fmt = traits::SafeFmt<channel_type>::fmt + ((channels - 1) << 8)
273 #ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
274 ,depth = DataType<channel_type>::depth
275 ,type = CV_MAKETYPE(depth, channels)
276 #endif
277 };
278};
279
280 namespace traits {
281 template<typename _Tp, int m, int n>
282 struct Depth< Matx<_Tp, m, n> > { enum { value = Depth<_Tp>::value }; };
283 template<typename _Tp, int m, int n>
284 struct Type< Matx<_Tp, m, n> > { enum { value = CV_MAKETYPE(Depth<_Tp>::value, n*m) }; };
285} // namespace
286
287
290 template<typename _Tp, int m, int n> class MatxCommaInitializer
291{
292 public:
293 MatxCommaInitializer(Matx<_Tp, m, n>* _mtx);
294 template<typename T2> MatxCommaInitializer<_Tp, m, n>& operator , (T2 val);
295 Matx<_Tp, m, n> operator *() const;
296
297 Matx<_Tp, m, n>* dst;
298 int idx;
299};
300
301 /*
302 Utility methods
303 */
304 template<typename _Tp, int m> static double determinant(const Matx<_Tp, m, m>& a);
305 template<typename _Tp, int m, int n> static double trace(const Matx<_Tp, m, n>& a);
306 template<typename _Tp, int m, int n> static double norm(const Matx<_Tp, m, n>& M);
307 template<typename _Tp, int m, int n> static double norm(const Matx<_Tp, m, n>& M, int normType);
308
309
310
312
341 template<typename _Tp, int cn> class Vec : public Matx<_Tp, cn, 1>
342{
343 public:
344 typedef _Tp value_type;
345 enum {
346 channels = cn,
347 #ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
348 depth = Matx<_Tp, cn, 1>::depth,
349 type = CV_MAKETYPE(depth, channels),
350 #endif
351 _dummy_enum_finalizer = 0
352 };
353
355 Vec();
356
357 Vec(_Tp v0);
358 Vec(_Tp v0, _Tp v1);
359 Vec(_Tp v0, _Tp v1, _Tp v2);
360 Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3);
361 Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4);
362 Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5);
363 Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6);
364 Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7);
365 Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8);
366 Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9);
367 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);
368 explicit Vec(const _Tp* values);
369
370 Vec(std::initializer_list<_Tp>);
371
372 Vec(const Vec<_Tp, cn>& v);
373
374 static Vec all(_Tp alpha);
375
377 Vec mul(const Vec<_Tp, cn>& v) const;
378
380 Vec conj() const;
381
387 Vec cross(const Vec& v) const;
389 template<typename T2> operator Vec<T2, cn>() const;
390
392 const _Tp& operator [](int i) const;
393 _Tp& operator[](int i);
394 const _Tp& operator ()(int i) const;
395 _Tp& operator ()(int i);
396
397 #ifdef CV_CXX11
398 Vec<_Tp, cn>& operator=(const Vec<_Tp, cn>& rhs) = default;
399 #endif
400
401 Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_AddOp);
402 Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_SubOp);
403 template<typename _T2> Vec(const Matx<_Tp, cn, 1>& a, _T2 alpha, Matx_ScaleOp);
404};
405
409 typedef Vec<uchar, 2> Vec2b;
410 typedef Vec<uchar, 3> Vec3b;
411 typedef Vec<uchar, 4> Vec4b;
412
413 typedef Vec<short, 2> Vec2s;
414 typedef Vec<short, 3> Vec3s;
415 typedef Vec<short, 4> Vec4s;
416
417 typedef Vec<ushort, 2> Vec2w;
418 typedef Vec<ushort, 3> Vec3w;
419 typedef Vec<ushort, 4> Vec4w;
420
421 typedef Vec<int, 2> Vec2i;
422 typedef Vec<int, 3> Vec3i;
423 typedef Vec<int, 4> Vec4i;
424 typedef Vec<int, 6> Vec6i;
425 typedef Vec<int, 8> Vec8i;
426
427 typedef Vec<float, 2> Vec2f;
428 typedef Vec<float, 3> Vec3f;
429 typedef Vec<float, 4> Vec4f;
430 typedef Vec<float, 6> Vec6f;
431
432 typedef Vec<double, 2> Vec2d;
433 typedef Vec<double, 3> Vec3d;
434 typedef Vec<double, 4> Vec4d;
435 typedef Vec<double, 6> Vec6d;
441 template<typename _Tp, int cn> class DataType< Vec<_Tp, cn> >
442{
443 public:
444 typedef Vec<_Tp, cn> value_type;
445 typedef Vec<typename DataType<_Tp>::work_type, cn> work_type;
446 typedef _Tp channel_type;
447 typedef value_type vec_type;
448
449 enum { generic_type = 0,
450 channels = cn,
451 fmt = DataType<channel_type>::fmt + ((channels - 1) << 8),
452 #ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
453 depth = DataType<channel_type>::depth,
454 type = CV_MAKETYPE(depth, channels),
455 #endif
456 _dummy_enum_finalizer = 0
457 };
458};
459
460 namespace traits {
461 template<typename _Tp, int cn>
462 struct Depth< Vec<_Tp, cn> > { enum { value = Depth<_Tp>::value }; };
463 template<typename _Tp, int cn>
464 struct Type< Vec<_Tp, cn> > { enum { value = CV_MAKETYPE(Depth<_Tp>::value, cn) }; };
465} // namespace
466
467
470 template<typename _Tp, int m> class VecCommaInitializer : public MatxCommaInitializer<_Tp, m, 1>
471{
472 public:
473 VecCommaInitializer(Vec<_Tp, m>* _vec);
474 template<typename T2> VecCommaInitializer<_Tp, m>& operator , (T2 val);
475 Vec<_Tp, m> operator *() const;
476};
477
478 template<typename _Tp, int cn> static Vec<_Tp, cn> normalize(const Vec<_Tp, cn>& v);
479
481
483
485 namespace internal
486{
487
488 template<typename _Tp, int m> struct Matx_DetOp
489{
490 double operator ()(const Matx<_Tp, m, m>& a) const
491 {
492 Matx<_Tp, m, m> temp = a;
493 double p = LU(temp.val, m*sizeof(_Tp), m, 0, 0, 0);
494 if( p == 0 )
495 return p;
496 for( int i = 0; i < m; i++ )
497 p *= temp(i, i);
498 return p;
499 }
500};
501
502 template<typename _Tp> struct Matx_DetOp<_Tp, 1>
503{
504 double operator ()(const Matx<_Tp, 1, 1>& a) const
505 {
506 return a(0,0);
507 }
508};
509
510 template<typename _Tp> struct Matx_DetOp<_Tp, 2>
511{
512 double operator ()(const Matx<_Tp, 2, 2>& a) const
513 {
514 return a(0,0)*a(1,1) - a(0,1)*a(1,0);
515 }
516};
517
518 template<typename _Tp> struct Matx_DetOp<_Tp, 3>
519{
520 double operator ()(const Matx<_Tp, 3, 3>& a) const
521 {
522 return a(0,0)*(a(1,1)*a(2,2) - a(2,1)*a(1,2)) -
523 a(0,1)*(a(1,0)*a(2,2) - a(2,0)*a(1,2)) +
524 a(0,2)*(a(1,0)*a(2,1) - a(2,0)*a(1,1));
525 }
526};
527
528 template<typename _Tp> Vec<_Tp, 2> inline conjugate(const Vec<_Tp, 2>& v)
529{
530 return Vec<_Tp, 2>(v[0], -v[1]);
531}
532
533 template<typename _Tp> Vec<_Tp, 4> inline conjugate(const Vec<_Tp, 4>& v)
534{
535 return Vec<_Tp, 4>(v[0], -v[1], -v[2], -v[3]);
536}
537
538} // internal
539
540
541
543
544 template<typename _Tp, int m, int n> inline
545 Matx<_Tp, m, n>::Matx()
546{
547 for(int i = 0; i < channels; i++) val[i] = _Tp(0);
548}
549
550 template<typename _Tp, int m, int n> inline
551 Matx<_Tp, m, n>::Matx(_Tp v0)
552{
553 val[0] = v0;
554 for(int i = 1; i < channels; i++) val[i] = _Tp(0);
555}
556
557 template<typename _Tp, int m, int n> inline
558 Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1)
559{
560 CV_StaticAssert(channels >= 2, "Matx should have at least 2 elements.");
561 val[0] = v0; val[1] = v1;
562 for(int i = 2; i < channels; i++) val[i] = _Tp(0);
563}
564
565 template<typename _Tp, int m, int n> inline
566 Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2)
567{
568 CV_StaticAssert(channels >= 3, "Matx should have at least 3 elements.");
569 val[0] = v0; val[1] = v1; val[2] = v2;
570 for(int i = 3; i < channels; i++) val[i] = _Tp(0);
571}
572
573 template<typename _Tp, int m, int n> inline
574 Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3)
575{
576 CV_StaticAssert(channels >= 4, "Matx should have at least 4 elements.");
577 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
578 for(int i = 4; i < channels; i++) val[i] = _Tp(0);
579}
580
581 template<typename _Tp, int m, int n> inline
582 Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4)
583{
584 CV_StaticAssert(channels >= 5, "Matx should have at least 5 elements.");
585 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3; val[4] = v4;
586 for(int i = 5; i < channels; i++) val[i] = _Tp(0);
587}
588
589 template<typename _Tp, int m, int n> inline
590 Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5)
591{
592 CV_StaticAssert(channels >= 6, "Matx should have at least 6 elements.");
593 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
594 val[4] = v4; val[5] = v5;
595 for(int i = 6; i < channels; i++) val[i] = _Tp(0);
596}
597
598 template<typename _Tp, int m, int n> inline
599 Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6)
600{
601 CV_StaticAssert(channels >= 7, "Matx should have at least 7 elements.");
602 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
603 val[4] = v4; val[5] = v5; val[6] = v6;
604 for(int i = 7; i < channels; i++) val[i] = _Tp(0);
605}
606
607 template<typename _Tp, int m, int n> inline
608 Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7)
609{
610 CV_StaticAssert(channels >= 8, "Matx should have at least 8 elements.");
611 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
612 val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
613 for(int i = 8; i < channels; i++) val[i] = _Tp(0);
614}
615
616 template<typename _Tp, int m, int n> inline
617 Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8)
618{
619 CV_StaticAssert(channels >= 9, "Matx should have at least 9 elements.");
620 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
621 val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
622 val[8] = v8;
623 for(int i = 9; i < channels; i++) val[i] = _Tp(0);
624}
625
626 template<typename _Tp, int m, int n> inline
627 Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9)
628{
629 CV_StaticAssert(channels >= 10, "Matx should have at least 10 elements.");
630 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
631 val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
632 val[8] = v8; val[9] = v9;
633 for(int i = 10; i < channels; i++) val[i] = _Tp(0);
634}
635
636
637 template<typename _Tp, int m, int n> inline
638 Matx<_Tp,m,n>::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)
639{
640 CV_StaticAssert(channels >= 12, "Matx should have at least 12 elements.");
641 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
642 val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
643 val[8] = v8; val[9] = v9; val[10] = v10; val[11] = v11;
644 for(int i = 12; i < channels; i++) val[i] = _Tp(0);
645}
646
647 template<typename _Tp, int m, int n> inline
648 Matx<_Tp,m,n>::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)
649{
650 CV_StaticAssert(channels >= 14, "Matx should have at least 14 elements.");
651 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
652 val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
653 val[8] = v8; val[9] = v9; val[10] = v10; val[11] = v11;
654 val[12] = v12; val[13] = v13;
655 for (int i = 14; i < channels; i++) val[i] = _Tp(0);
656}
657
658
659 template<typename _Tp, int m, int n> inline
660 Matx<_Tp,m,n>::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)
661{
662 CV_StaticAssert(channels >= 16, "Matx should have at least 16 elements.");
663 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
664 val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
665 val[8] = v8; val[9] = v9; val[10] = v10; val[11] = v11;
666 val[12] = v12; val[13] = v13; val[14] = v14; val[15] = v15;
667 for(int i = 16; i < channels; i++) val[i] = _Tp(0);
668}
669
670 template<typename _Tp, int m, int n> inline
671 Matx<_Tp, m, n>::Matx(const _Tp* values)
672{
673 for( int i = 0; i < channels; i++ ) val[i] = values[i];
674}
675
676 template<typename _Tp, int m, int n> inline
677 Matx<_Tp, m, n>::Matx(std::initializer_list<_Tp> list)
678{
679 CV_DbgAssert(list.size() == channels);
680 int i = 0;
681 for(const auto& elem : list)
682 {
683 val[i++] = elem;
684 }
685}
686
687 template<typename _Tp, int m, int n> inline
688Matx<_Tp, m, n> Matx<_Tp, m, n>::all(_Tp alpha)
689{
690 Matx<_Tp, m, n> M;
691 for( int i = 0; i < m*n; i++ ) M.val[i] = alpha;
692 return M;
693}
694
695 template<typename _Tp, int m, int n> inline
696Matx<_Tp,m,n> Matx<_Tp,m,n>::zeros()
697{
698 return all(0);
699}
700
701 template<typename _Tp, int m, int n> inline
702Matx<_Tp,m,n> Matx<_Tp,m,n>::ones()
703{
704 return all(1);
705}
706
707 template<typename _Tp, int m, int n> inline
708Matx<_Tp,m,n> Matx<_Tp,m,n>::eye()
709{
710 Matx<_Tp,m,n> M;
711 for(int i = 0; i < shortdim; i++)
712 M(i,i) = 1;
713 return M;
714}
715
716 template<typename _Tp, int m, int n> inline
717_Tp Matx<_Tp, m, n>::dot(const Matx<_Tp, m, n>& M) const
718 {
719 _Tp s = 0;
720 for( int i = 0; i < channels; i++ ) s += val[i]*M.val[i];
721 return s;
722}
723
724 template<typename _Tp, int m, int n> inline
725 double Matx<_Tp, m, n>::ddot(const Matx<_Tp, m, n>& M) const
726 {
727 double s = 0;
728 for( int i = 0; i < channels; i++ ) s += (double)val[i]*M.val[i];
729 return s;
730}
731
732 template<typename _Tp, int m, int n> inline
733Matx<_Tp,m,n> Matx<_Tp,m,n>::diag(const typename Matx<_Tp,m,n>::diag_type& d)
734{
735 Matx<_Tp,m,n> M;
736 for(int i = 0; i < shortdim; i++)
737 M(i,i) = d(i, 0);
738 return M;
739}
740
741 template<typename _Tp, int m, int n> template<typename T2>
742 inline Matx<_Tp, m, n>::operator Matx<T2, m, n>() const
743 {
744 Matx<T2, m, n> M;
745 for( int i = 0; i < m*n; i++ ) M.val[i] = saturate_cast<T2>(val[i]);
746 return M;
747}
748
749 template<typename _Tp, int m, int n> template<int m1, int n1> inline
750Matx<_Tp, m1, n1> Matx<_Tp, m, n>::reshape() const
751 {
752 CV_StaticAssert(m1*n1 == m*n, "Input and destnarion matrices must have the same number of elements");
753 return (const Matx<_Tp, m1, n1>&)*this;
754}
755
756 template<typename _Tp, int m, int n>
757 template<int m1, int n1> inline
758Matx<_Tp, m1, n1> Matx<_Tp, m, n>::get_minor(int base_row, int base_col) const
759 {
760 CV_DbgAssert(0 <= base_row && base_row+m1 <= m && 0 <= base_col && base_col+n1 <= n);
761 Matx<_Tp, m1, n1> s;
762 for( int di = 0; di < m1; di++ )
763 for( int dj = 0; dj < n1; dj++ )
764 s(di, dj) = (*this)(base_row+di, base_col+dj);
765 return s;
766}
767
768 template<typename _Tp, int m, int n> inline
769Matx<_Tp, 1, n> Matx<_Tp, m, n>::row(int i) const
770 {
771 CV_DbgAssert((unsigned)i < (unsigned)m);
772 return Matx<_Tp, 1, n>(&val[i*n]);
773}
774
775 template<typename _Tp, int m, int n> inline
776Matx<_Tp, m, 1> Matx<_Tp, m, n>::col(int j) const
777 {
778 CV_DbgAssert((unsigned)j < (unsigned)n);
779 Matx<_Tp, m, 1> v;
780 for( int i = 0; i < m; i++ )
781 v.val[i] = val[i*n + j];
782 return v;
783}
784
785 template<typename _Tp, int m, int n> inline
786 typename Matx<_Tp, m, n>::diag_type Matx<_Tp, m, n>::diag() const
787 {
788 diag_type d;
789 for( int i = 0; i < shortdim; i++ )
790 d.val[i] = val[i*n + i];
791 return d;
792}
793
794 template<typename _Tp, int m, int n> inline
795 const _Tp& Matx<_Tp, m, n>::operator()(int row_idx, int col_idx) const
796 {
797 CV_DbgAssert( (unsigned)row_idx < (unsigned)m && (unsigned)col_idx < (unsigned)n );
798 return this->val[row_idx*n + col_idx];
799}
800
801 template<typename _Tp, int m, int n> inline
802_Tp& Matx<_Tp, m, n>::operator ()(int row_idx, int col_idx)
803{
804 CV_DbgAssert( (unsigned)row_idx < (unsigned)m && (unsigned)col_idx < (unsigned)n );
805 return val[row_idx*n + col_idx];
806}
807
808 template<typename _Tp, int m, int n> inline
809 const _Tp& Matx<_Tp, m, n>::operator ()(int i) const
810 {
811 CV_StaticAssert(m == 1 || n == 1, "Single index indexation requires matrix to be a column or a row");
812 CV_DbgAssert( (unsigned)i < (unsigned)(m+n-1) );
813 return val[i];
814}
815
816 template<typename _Tp, int m, int n> inline
817_Tp& Matx<_Tp, m, n>::operator ()(int i)
818{
819 CV_StaticAssert(m == 1 || n == 1, "Single index indexation requires matrix to be a column or a row");
820 CV_DbgAssert( (unsigned)i < (unsigned)(m+n-1) );
821 return val[i];
822}
823
824 template<typename _Tp, int m, int n> inline
825 Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_AddOp)
826{
827 for( int i = 0; i < channels; i++ )
828 val[i] = saturate_cast<_Tp>(a.val[i] + b.val[i]);
829}
830
831 template<typename _Tp, int m, int n> inline
832 Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_SubOp)
833{
834 for( int i = 0; i < channels; i++ )
835 val[i] = saturate_cast<_Tp>(a.val[i] - b.val[i]);
836}
837
838 template<typename _Tp, int m, int n> template<typename _T2> inline
839 Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, _T2 alpha, Matx_ScaleOp)
840{
841 for( int i = 0; i < channels; i++ )
842 val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
843}
844
845 template<typename _Tp, int m, int n> inline
846 Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_MulOp)
847{
848 for( int i = 0; i < channels; i++ )
849 val[i] = saturate_cast<_Tp>(a.val[i] * b.val[i]);
850}
851
852 template<typename _Tp, int m, int n> inline
853 Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_DivOp)
854{
855 for( int i = 0; i < channels; i++ )
856 val[i] = saturate_cast<_Tp>(a.val[i] / b.val[i]);
857}
858
859 template<typename _Tp, int m, int n> template<int l> inline
860 Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b, Matx_MatMulOp)
861{
862 for( int i = 0; i < m; i++ )
863 for( int j = 0; j < n; j++ )
864 {
865 _Tp s = 0;
866 for( int k = 0; k < l; k++ )
867 s += a(i, k) * b(k, j);
868 val[i*n + j] = s;
869 }
870}
871
872 template<typename _Tp, int m, int n> inline
873 Matx<_Tp,m,n>::Matx(const Matx<_Tp, n, m>& a, Matx_TOp)
874{
875 for( int i = 0; i < m; i++ )
876 for( int j = 0; j < n; j++ )
877 val[i*n + j] = a(j, i);
878}
879
880 template<typename _Tp, int m, int n> inline
881Matx<_Tp, m, n> Matx<_Tp, m, n>::mul(const Matx<_Tp, m, n>& a) const
882 {
883 return Matx<_Tp, m, n>(*this, a, Matx_MulOp());
884}
885
886 template<typename _Tp, int m, int n> inline
887Matx<_Tp, m, n> Matx<_Tp, m, n>::div(const Matx<_Tp, m, n>& a) const
888 {
889 return Matx<_Tp, m, n>(*this, a, Matx_DivOp());
890}
891
892 template<typename _Tp, int m, int n> inline
893Matx<_Tp, n, m> Matx<_Tp, m, n>::t() const
894 {
895 return Matx<_Tp, n, m>(*this, Matx_TOp());
896}
897
898 template<typename _Tp, int m, int n> inline
899Vec<_Tp, n> Matx<_Tp, m, n>::solve(const Vec<_Tp, m>& rhs, int method) const
900 {
901 Matx<_Tp, n, 1> x = solve((const Matx<_Tp, m, 1>&)(rhs), method);
902 return (Vec<_Tp, n>&)(x);
903}
904
905 template<typename _Tp, int m> static inline
906 double determinant(const Matx<_Tp, m, m>& a)
907{
908 return cv::internal::Matx_DetOp<_Tp, m>()(a);
909}
910
911 template<typename _Tp, int m, int n> static inline
912 double trace(const Matx<_Tp, m, n>& a)
913{
914 _Tp s = 0;
915 for( int i = 0; i < std::min(m, n); i++ )
916 s += a(i,i);
917 return s;
918}
919
920 template<typename _Tp, int m, int n> static inline
921 double norm(const Matx<_Tp, m, n>& M)
922{
923 return std::sqrt(normL2Sqr<_Tp, double>(M.val, m*n));
924}
925
926 template<typename _Tp, int m, int n> static inline
927 double norm(const Matx<_Tp, m, n>& M, int normType)
928{
929 switch(normType) {
930 case NORM_INF:
931 return (double)normInf<_Tp, typename DataType<_Tp>::work_type>(M.val, m*n);
932 case NORM_L1:
933 return (double)normL1<_Tp, typename DataType<_Tp>::work_type>(M.val, m*n);
934 case NORM_L2SQR:
935 return (double)normL2Sqr<_Tp, typename DataType<_Tp>::work_type>(M.val, m*n);
936 default:
937 case NORM_L2:
938 return std::sqrt((double)normL2Sqr<_Tp, typename DataType<_Tp>::work_type>(M.val, m*n));
939 }
940}
941
942
943
945
946 template<typename _Tp, typename _T2, int m, int n> static inline
947MatxCommaInitializer<_Tp, m, n> operator << (const Matx<_Tp, m, n>& mtx, _T2 val)
948{
949 MatxCommaInitializer<_Tp, m, n> commaInitializer((Matx<_Tp, m, n>*)&mtx);
950 return (commaInitializer, val);
951}
952
953 template<typename _Tp, int m, int n> inline
954MatxCommaInitializer<_Tp, m, n>::MatxCommaInitializer(Matx<_Tp, m, n>* _mtx)
955 : dst(_mtx), idx(0)
956{}
957
958 template<typename _Tp, int m, int n> template<typename _T2> inline
959MatxCommaInitializer<_Tp, m, n>& MatxCommaInitializer<_Tp, m, n>::operator , (_T2 value)
960{
961 CV_DbgAssert( idx < m*n );
962 dst->val[idx++] = saturate_cast<_Tp>(value);
963 return *this;
964}
965
966 template<typename _Tp, int m, int n> inline
967Matx<_Tp, m, n> MatxCommaInitializer<_Tp, m, n>::operator *() const
968 {
969 CV_DbgAssert( idx == n*m );
970 return *dst;
971}
972
973
974
976
977 template<typename _Tp, int cn> inline
978 Vec<_Tp, cn>::Vec() {}
979
980 template<typename _Tp, int cn> inline
981 Vec<_Tp, cn>::Vec(_Tp v0)
982 : Matx<_Tp, cn, 1>(v0) {}
983
984 template<typename _Tp, int cn> inline
985 Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1)
986 : Matx<_Tp, cn, 1>(v0, v1) {}
987
988 template<typename _Tp, int cn> inline
989 Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2)
990 : Matx<_Tp, cn, 1>(v0, v1, v2) {}
991
992 template<typename _Tp, int cn> inline
993 Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3)
994 : Matx<_Tp, cn, 1>(v0, v1, v2, v3) {}
995
996 template<typename _Tp, int cn> inline
997 Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4)
998 : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4) {}
999
1000 template<typename _Tp, int cn> inline
1001 Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5)
1002 : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5) {}
1003
1004 template<typename _Tp, int cn> inline
1005 Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6)
1006 : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6) {}
1007
1008 template<typename _Tp, int cn> inline
1009 Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7)
1010 : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6, v7) {}
1011
1012 template<typename _Tp, int cn> inline
1013 Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8)
1014 : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6, v7, v8) {}
1015
1016 template<typename _Tp, int cn> inline
1017 Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9)
1018 : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {}
1019
1020 template<typename _Tp, int cn> inline
1021 Vec<_Tp, cn>::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)
1022 : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) {}
1023
1024 template<typename _Tp, int cn> inline
1025 Vec<_Tp, cn>::Vec(const _Tp* values)
1026 : Matx<_Tp, cn, 1>(values) {}
1027
1028 template<typename _Tp, int cn> inline
1029 Vec<_Tp, cn>::Vec(std::initializer_list<_Tp> list)
1030 : Matx<_Tp, cn, 1>(list) {}
1031
1032 template<typename _Tp, int cn> inline
1033 Vec<_Tp, cn>::Vec(const Vec<_Tp, cn>& m)
1034 : Matx<_Tp, cn, 1>(m.val) {}
1035
1036 template<typename _Tp, int cn> inline
1037 Vec<_Tp, cn>::Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_AddOp op)
1038 : Matx<_Tp, cn, 1>(a, b, op) {}
1039
1040 template<typename _Tp, int cn> inline
1041 Vec<_Tp, cn>::Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_SubOp op)
1042 : Matx<_Tp, cn, 1>(a, b, op) {}
1043
1044 template<typename _Tp, int cn> template<typename _T2> inline
1045 Vec<_Tp, cn>::Vec(const Matx<_Tp, cn, 1>& a, _T2 alpha, Matx_ScaleOp op)
1046 : Matx<_Tp, cn, 1>(a, alpha, op) {}
1047
1048 template<typename _Tp, int cn> inline
1049Vec<_Tp, cn> Vec<_Tp, cn>::all(_Tp alpha)
1050{
1051 Vec v;
1052 for( int i = 0; i < cn; i++ ) v.val[i] = alpha;
1053 return v;
1054}
1055
1056 template<typename _Tp, int cn> inline
1057Vec<_Tp, cn> Vec<_Tp, cn>::mul(const Vec<_Tp, cn>& v) const
1058 {
1059 Vec<_Tp, cn> w;
1060 for( int i = 0; i < cn; i++ ) w.val[i] = saturate_cast<_Tp>(this->val[i]*v.val[i]);
1061 return w;
1062}
1063
1064 template<> inline
1065Vec<float, 2> Vec<float, 2>::conj() const
1066 {
1067 return cv::internal::conjugate(*this);
1068}
1069
1070 template<> inline
1071Vec<double, 2> Vec<double, 2>::conj() const
1072 {
1073 return cv::internal::conjugate(*this);
1074}
1075
1076 template<> inline
1077Vec<float, 4> Vec<float, 4>::conj() const
1078 {
1079 return cv::internal::conjugate(*this);
1080}
1081
1082 template<> inline
1083Vec<double, 4> Vec<double, 4>::conj() const
1084 {
1085 return cv::internal::conjugate(*this);
1086}
1087
1088 template<typename _Tp, int cn> inline
1089Vec<_Tp, cn> Vec<_Tp, cn>::cross(const Vec<_Tp, cn>&) const
1090 {
1091 CV_StaticAssert(cn == 3, "for arbitrary-size vector there is no cross-product defined");
1092 return Vec<_Tp, cn>();
1093}
1094
1095 template<> inline
1096Vec<float, 3> Vec<float, 3>::cross(const Vec<float, 3>& v) const
1097 {
1098 return Vec<float,3>(this->val[1]*v.val[2] - this->val[2]*v.val[1],
1099 this->val[2]*v.val[0] - this->val[0]*v.val[2],
1100 this->val[0]*v.val[1] - this->val[1]*v.val[0]);
1101}
1102
1103 template<> inline
1104Vec<double, 3> Vec<double, 3>::cross(const Vec<double, 3>& v) const
1105 {
1106 return Vec<double,3>(this->val[1]*v.val[2] - this->val[2]*v.val[1],
1107 this->val[2]*v.val[0] - this->val[0]*v.val[2],
1108 this->val[0]*v.val[1] - this->val[1]*v.val[0]);
1109}
1110
1111 template<typename _Tp, int cn> template<typename T2> inline
1112Vec<_Tp, cn>::operator Vec<T2, cn>() const
1113 {
1114 Vec<T2, cn> v;
1115 for( int i = 0; i < cn; i++ ) v.val[i] = saturate_cast<T2>(this->val[i]);
1116 return v;
1117}
1118
1119 template<typename _Tp, int cn> inline
1120 const _Tp& Vec<_Tp, cn>::operator [](int i) const
1121 {
1122 CV_DbgAssert( (unsigned)i < (unsigned)cn );
1123 return this->val[i];
1124}
1125
1126 template<typename _Tp, int cn> inline
1127_Tp& Vec<_Tp, cn>::operator [](int i)
1128{
1129 CV_DbgAssert( (unsigned)i < (unsigned)cn );
1130 return this->val[i];
1131}
1132
1133 template<typename _Tp, int cn> inline
1134 const _Tp& Vec<_Tp, cn>::operator ()(int i) const
1135 {
1136 CV_DbgAssert( (unsigned)i < (unsigned)cn );
1137 return this->val[i];
1138}
1139
1140 template<typename _Tp, int cn> inline
1141_Tp& Vec<_Tp, cn>::operator ()(int i)
1142{
1143 CV_DbgAssert( (unsigned)i < (unsigned)cn );
1144 return this->val[i];
1145}
1146
1147 template<typename _Tp, int cn> inline
1148Vec<_Tp, cn> normalize(const Vec<_Tp, cn>& v)
1149{
1150 double nv = norm(v);
1151 return v * (nv ? 1./nv : 0.);
1152}
1153
1154
1155
1157
1158
1159 template<typename _Tp, typename _T2, int cn> static inline
1160VecCommaInitializer<_Tp, cn> operator << (const Vec<_Tp, cn>& vec, _T2 val)
1161{
1162 VecCommaInitializer<_Tp, cn> commaInitializer((Vec<_Tp, cn>*)&vec);
1163 return (commaInitializer, val);
1164}
1165
1166 template<typename _Tp, int cn> inline
1167VecCommaInitializer<_Tp, cn>::VecCommaInitializer(Vec<_Tp, cn>* _vec)
1168 : MatxCommaInitializer<_Tp, cn, 1>(_vec)
1169{}
1170
1171 template<typename _Tp, int cn> template<typename _T2> inline
1172VecCommaInitializer<_Tp, cn>& VecCommaInitializer<_Tp, cn>::operator , (_T2 value)
1173{
1174 CV_DbgAssert( this->idx < cn );
1175 this->dst->val[this->idx++] = saturate_cast<_Tp>(value);
1176 return *this;
1177}
1178
1179 template<typename _Tp, int cn> inline
1180Vec<_Tp, cn> VecCommaInitializer<_Tp, cn>::operator *() const
1181 {
1182 CV_DbgAssert( this->idx == cn );
1183 return *this->dst;
1184}
1185
1187
1189
1192
1193 template<typename _Tp1, typename _Tp2, int m, int n> static inline
1194Matx<_Tp1, m, n>& operator += (Matx<_Tp1, m, n>& a, const Matx<_Tp2, m, n>& b)
1195{
1196 for( int i = 0; i < m*n; i++ )
1197 a.val[i] = saturate_cast<_Tp1>(a.val[i] + b.val[i]);
1198 return a;
1199}
1200
1201 template<typename _Tp1, typename _Tp2, int m, int n> static inline
1202Matx<_Tp1, m, n>& operator -= (Matx<_Tp1, m, n>& a, const Matx<_Tp2, m, n>& b)
1203{
1204 for( int i = 0; i < m*n; i++ )
1205 a.val[i] = saturate_cast<_Tp1>(a.val[i] - b.val[i]);
1206 return a;
1207}
1208
1209 template<typename _Tp, int m, int n> static inline
1210Matx<_Tp, m, n> operator + (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
1211{
1212 return Matx<_Tp, m, n>(a, b, Matx_AddOp());
1213}
1214
1215 template<typename _Tp, int m, int n> static inline
1216Matx<_Tp, m, n> operator - (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
1217{
1218 return Matx<_Tp, m, n>(a, b, Matx_SubOp());
1219}
1220
1221 template<typename _Tp, int m, int n> static inline
1222Matx<_Tp, m, n>& operator *= (Matx<_Tp, m, n>& a, int alpha)
1223{
1224 for( int i = 0; i < m*n; i++ )
1225 a.val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
1226 return a;
1227}
1228
1229 template<typename _Tp, int m, int n> static inline
1230Matx<_Tp, m, n>& operator *= (Matx<_Tp, m, n>& a, float alpha)
1231{
1232 for( int i = 0; i < m*n; i++ )
1233 a.val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
1234 return a;
1235}
1236
1237 template<typename _Tp, int m, int n> static inline
1238Matx<_Tp, m, n>& operator *= (Matx<_Tp, m, n>& a, double alpha)
1239{
1240 for( int i = 0; i < m*n; i++ )
1241 a.val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
1242 return a;
1243}
1244
1245 template<typename _Tp, int m, int n> static inline
1246Matx<_Tp, m, n> operator * (const Matx<_Tp, m, n>& a, int alpha)
1247{
1248 return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
1249}
1250
1251 template<typename _Tp, int m, int n> static inline
1252Matx<_Tp, m, n> operator * (const Matx<_Tp, m, n>& a, float alpha)
1253{
1254 return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
1255}
1256
1257 template<typename _Tp, int m, int n> static inline
1258Matx<_Tp, m, n> operator * (const Matx<_Tp, m, n>& a, double alpha)
1259{
1260 return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
1261}
1262
1263 template<typename _Tp, int m, int n> static inline
1264Matx<_Tp, m, n> operator * (int alpha, const Matx<_Tp, m, n>& a)
1265{
1266 return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
1267}
1268
1269 template<typename _Tp, int m, int n> static inline
1270Matx<_Tp, m, n> operator * (float alpha, const Matx<_Tp, m, n>& a)
1271{
1272 return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
1273}
1274
1275 template<typename _Tp, int m, int n> static inline
1276Matx<_Tp, m, n> operator * (double alpha, const Matx<_Tp, m, n>& a)
1277{
1278 return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
1279}
1280
1281 template<typename _Tp, int m, int n> static inline
1282Matx<_Tp, m, n>& operator /= (Matx<_Tp, m, n>& a, float alpha)
1283{
1284 for( int i = 0; i < m*n; i++ )
1285 a.val[i] = a.val[i] / alpha;
1286 return a;
1287}
1288
1289 template<typename _Tp, int m, int n> static inline
1290Matx<_Tp, m, n>& operator /= (Matx<_Tp, m, n>& a, double alpha)
1291{
1292 for( int i = 0; i < m*n; i++ )
1293 a.val[i] = a.val[i] / alpha;
1294 return a;
1295}
1296
1297 template<typename _Tp, int m, int n> static inline
1298Matx<_Tp, m, n> operator / (const Matx<_Tp, m, n>& a, float alpha)
1299{
1300 return Matx<_Tp, m, n>(a, 1.f/alpha, Matx_ScaleOp());
1301}
1302
1303 template<typename _Tp, int m, int n> static inline
1304Matx<_Tp, m, n> operator / (const Matx<_Tp, m, n>& a, double alpha)
1305{
1306 return Matx<_Tp, m, n>(a, 1./alpha, Matx_ScaleOp());
1307}
1308
1309 template<typename _Tp, int m, int n> static inline
1310Matx<_Tp, m, n> operator - (const Matx<_Tp, m, n>& a)
1311{
1312 return Matx<_Tp, m, n>(a, -1, Matx_ScaleOp());
1313}
1314
1315 template<typename _Tp, int m, int n, int l> static inline
1316Matx<_Tp, m, n> operator * (const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b)
1317{
1318 return Matx<_Tp, m, n>(a, b, Matx_MatMulOp());
1319}
1320
1321 template<typename _Tp, int m, int n> static inline
1322Vec<_Tp, m> operator * (const Matx<_Tp, m, n>& a, const Vec<_Tp, n>& b)
1323{
1324 Matx<_Tp, m, 1> c(a, b, Matx_MatMulOp());
1325 return (const Vec<_Tp, m>&)(c);
1326}
1327
1328 template<typename _Tp, int m, int n> static inline
1329 bool operator == (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
1330{
1331 for( int i = 0; i < m*n; i++ )
1332 if( a.val[i] != b.val[i] ) return false;
1333 return true;
1334}
1335
1336 template<typename _Tp, int m, int n> static inline
1337 bool operator != (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
1338{
1339 return !(a == b);
1340}
1341
1343
1345
1348
1349 template<typename _Tp1, typename _Tp2, int cn> static inline
1350Vec<_Tp1, cn>& operator += (Vec<_Tp1, cn>& a, const Vec<_Tp2, cn>& b)
1351{
1352 for( int i = 0; i < cn; i++ )
1353 a.val[i] = saturate_cast<_Tp1>(a.val[i] + b.val[i]);
1354 return a;
1355}
1356
1357 template<typename _Tp1, typename _Tp2, int cn> static inline
1358Vec<_Tp1, cn>& operator -= (Vec<_Tp1, cn>& a, const Vec<_Tp2, cn>& b)
1359{
1360 for( int i = 0; i < cn; i++ )
1361 a.val[i] = saturate_cast<_Tp1>(a.val[i] - b.val[i]);
1362 return a;
1363}
1364
1365 template<typename _Tp, int cn> static inline
1366Vec<_Tp, cn> operator + (const Vec<_Tp, cn>& a, const Vec<_Tp, cn>& b)
1367{
1368 return Vec<_Tp, cn>(a, b, Matx_AddOp());
1369}
1370
1371 template<typename _Tp, int cn> static inline
1372Vec<_Tp, cn> operator - (const Vec<_Tp, cn>& a, const Vec<_Tp, cn>& b)
1373{
1374 return Vec<_Tp, cn>(a, b, Matx_SubOp());
1375}
1376
1377 template<typename _Tp, int cn> static inline
1378Vec<_Tp, cn>& operator *= (Vec<_Tp, cn>& a, int alpha)
1379{
1380 for( int i = 0; i < cn; i++ )
1381 a[i] = saturate_cast<_Tp>(a[i]*alpha);
1382 return a;
1383}
1384
1385 template<typename _Tp, int cn> static inline
1386Vec<_Tp, cn>& operator *= (Vec<_Tp, cn>& a, float alpha)
1387{
1388 for( int i = 0; i < cn; i++ )
1389 a[i] = saturate_cast<_Tp>(a[i]*alpha);
1390 return a;
1391}
1392
1393 template<typename _Tp, int cn> static inline
1394Vec<_Tp, cn>& operator *= (Vec<_Tp, cn>& a, double alpha)
1395{
1396 for( int i = 0; i < cn; i++ )
1397 a[i] = saturate_cast<_Tp>(a[i]*alpha);
1398 return a;
1399}
1400
1401 template<typename _Tp, int cn> static inline
1402Vec<_Tp, cn>& operator /= (Vec<_Tp, cn>& a, int alpha)
1403{
1404 double ialpha = 1./alpha;
1405 for( int i = 0; i < cn; i++ )
1406 a[i] = saturate_cast<_Tp>(a[i]*ialpha);
1407 return a;
1408}
1409
1410 template<typename _Tp, int cn> static inline
1411Vec<_Tp, cn>& operator /= (Vec<_Tp, cn>& a, float alpha)
1412{
1413 float ialpha = 1.f/alpha;
1414 for( int i = 0; i < cn; i++ )
1415 a[i] = saturate_cast<_Tp>(a[i]*ialpha);
1416 return a;
1417}
1418
1419 template<typename _Tp, int cn> static inline
1420Vec<_Tp, cn>& operator /= (Vec<_Tp, cn>& a, double alpha)
1421{
1422 double ialpha = 1./alpha;
1423 for( int i = 0; i < cn; i++ )
1424 a[i] = saturate_cast<_Tp>(a[i]*ialpha);
1425 return a;
1426}
1427
1428 template<typename _Tp, int cn> static inline
1429Vec<_Tp, cn> operator * (const Vec<_Tp, cn>& a, int alpha)
1430{
1431 return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
1432}
1433
1434 template<typename _Tp, int cn> static inline
1435Vec<_Tp, cn> operator * (int alpha, const Vec<_Tp, cn>& a)
1436{
1437 return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
1438}
1439
1440 template<typename _Tp, int cn> static inline
1441Vec<_Tp, cn> operator * (const Vec<_Tp, cn>& a, float alpha)
1442{
1443 return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
1444}
1445
1446 template<typename _Tp, int cn> static inline
1447Vec<_Tp, cn> operator * (float alpha, const Vec<_Tp, cn>& a)
1448{
1449 return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
1450}
1451
1452 template<typename _Tp, int cn> static inline
1453Vec<_Tp, cn> operator * (const Vec<_Tp, cn>& a, double alpha)
1454{
1455 return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
1456}
1457
1458 template<typename _Tp, int cn> static inline
1459Vec<_Tp, cn> operator * (double alpha, const Vec<_Tp, cn>& a)
1460{
1461 return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
1462}
1463
1464 template<typename _Tp, int cn> static inline
1465Vec<_Tp, cn> operator / (const Vec<_Tp, cn>& a, int alpha)
1466{
1467 return Vec<_Tp, cn>(a, 1./alpha, Matx_ScaleOp());
1468}
1469
1470 template<typename _Tp, int cn> static inline
1471Vec<_Tp, cn> operator / (const Vec<_Tp, cn>& a, float alpha)
1472{
1473 return Vec<_Tp, cn>(a, 1.f/alpha, Matx_ScaleOp());
1474}
1475
1476 template<typename _Tp, int cn> static inline
1477Vec<_Tp, cn> operator / (const Vec<_Tp, cn>& a, double alpha)
1478{
1479 return Vec<_Tp, cn>(a, 1./alpha, Matx_ScaleOp());
1480}
1481
1482 template<typename _Tp, int cn> static inline
1483Vec<_Tp, cn> operator - (const Vec<_Tp, cn>& a)
1484{
1485 Vec<_Tp,cn> t;
1486 for( int i = 0; i < cn; i++ ) t.val[i] = saturate_cast<_Tp>(-a.val[i]);
1487 return t;
1488}
1489
1490 template<typename _Tp> inline Vec<_Tp, 4> operator * (const Vec<_Tp, 4>& v1, const Vec<_Tp, 4>& v2)
1491{
1492 return Vec<_Tp, 4>(saturate_cast<_Tp>(v1[0]*v2[0] - v1[1]*v2[1] - v1[2]*v2[2] - v1[3]*v2[3]),
1493 saturate_cast<_Tp>(v1[0]*v2[1] + v1[1]*v2[0] + v1[2]*v2[3] - v1[3]*v2[2]),
1494 saturate_cast<_Tp>(v1[0]*v2[2] - v1[1]*v2[3] + v1[2]*v2[0] + v1[3]*v2[1]),
1495 saturate_cast<_Tp>(v1[0]*v2[3] + v1[1]*v2[2] - v1[2]*v2[1] + v1[3]*v2[0]));
1496}
1497
1498 template<typename _Tp> inline Vec<_Tp, 4>& operator *= (Vec<_Tp, 4>& v1, const Vec<_Tp, 4>& v2)
1499{
1500 v1 = v1 * v2;
1501 return v1;
1502}
1503
1505
1506} // cv
1507
1508 #endif // OPENCV_CORE_MATX_HPP
cv::DataType
Template "trait" class for OpenCV primitive data types.
Definition: traits.hpp:113
cv::FileStorage::operator<<
CV_EXPORTS FileStorage & operator<<(FileStorage &fs, const String &str)
Writes string to a file storage.
cv::MatxCommaInitializer
Comma-separated Matrix Initializer
Definition: matx.hpp:291
cv::Matx
Template class for small matrices whose type and size are known at compilation time
Definition: matx.hpp:100
cv::Matx::Matx
Matx(_Tp v0, _Tp v1, _Tp v2)
1x3 or 3x1 matrix
cv::Matx::mul
Matx< _Tp, m, n > mul(const Matx< _Tp, m, n > &a) const
multiply two matrices element-wise
cv::Matx::Matx
Matx()
default constructor
cv::Matx::Matx
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
cv::Matx::Matx
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
cv::Matx::randn
static Matx randn(_Tp a, _Tp b)
Generates normally distributed random numbers
cv::Matx::t
Matx< _Tp, n, m > t() const
transpose the matrix
cv::Matx::inv
Matx< _Tp, n, m > inv(int method=DECOMP_LU, bool *p_is_ok=NULL) const
invert the matrix
cv::Matx::row
Matx< _Tp, 1, n > row(int i) const
extract the matrix row
cv::Matx::Matx
Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4)
1x5 or 5x1 matrix
cv::Matx::Matx
Matx(_Tp v0)
1x1 matrix
cv::Matx::Matx
Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6)
1x7 or 7x1 matrix
cv::Matx::Matx
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
cv::Matx::col
Matx< _Tp, m, 1 > col(int i) const
extract the matrix column
cv::Matx::Matx
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
cv::Matx::Matx
Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5)
1x6, 2x3, 3x2 or 6x1 matrix
cv::Matx::div
Matx< _Tp, m, n > div(const Matx< _Tp, m, n > &a) const
divide two matrices element-wise
cv::Matx::Matx
Matx(_Tp v0, _Tp v1)
1x2 or 2x1 matrix
cv::Matx::Matx
Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3)
1x4, 2x2 or 4x1 matrix
cv::Matx::diag
diag_type diag() const
extract the matrix diagonal
cv::Matx::Matx
Matx(const _Tp *vals)
initialize from a plain array
cv::Matx::randu
static Matx randu(_Tp a, _Tp b)
Generates uniformly distributed random numbers
cv::Matx::reshape
Matx< _Tp, m1, n1 > reshape() const
change the matrix shape
cv::Matx::operator()
const _Tp & operator()(int row, int col) const
element access
cv::Matx::Matx
Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7)
1x8, 2x4, 4x2 or 8x1 matrix
cv::Matx::solve
Matx< _Tp, n, l > solve(const Matx< _Tp, m, l > &rhs, int flags=DECOMP_LU) const
solve linear system
cv::Matx::ddot
double ddot(const Matx< _Tp, m, n > &v) const
dot product computed in double-precision arithmetics
cv::Matx::Matx
Matx(std::initializer_list< _Tp >)
initialize from an initializer list
cv::Matx::Matx
Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8)
1x9, 3x3 or 9x1 matrix
cv::Matx::get_minor
Matx< _Tp, m1, n1 > get_minor(int base_row, int base_col) const
extract part of the matrix
cv::Matx::dot
_Tp dot(const Matx< _Tp, m, n > &v) const
dot product computed with the default precision
cv::VecCommaInitializer
Comma-separated Vec Initializer
Definition: matx.hpp:471
cv::Vec
Template class for short numerical vectors, a partial case of Matx
Definition: matx.hpp:342
cv::Vec::Vec
Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8)
9-element vector constructor
cv::Vec::Vec
Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3)
4-element vector constructor
cv::Vec::Vec
Vec(_Tp v0)
1-element vector constructor
cv::Vec::Vec
Vec(_Tp v0, _Tp v1, _Tp v2)
3-element vector constructor
cv::Vec::Vec
Vec()
default constructor
cv::Vec::Vec
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
cv::Vec::Vec
Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6)
7-element vector constructor
cv::Vec::operator[]
const _Tp & operator[](int i) const
cv::Vec::Vec
Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5)
6-element vector constructor
cv::Vec::mul
Vec mul(const Vec< _Tp, cn > &v) const
per-element multiplication
cv::Vec::Vec
Vec(_Tp v0, _Tp v1)
2-element vector constructor
cv::Vec::Vec
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
cv::Vec::Vec
Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4)
5-element vector constructor
cv::Vec::cross
Vec cross(const Vec &v) const
cv::Vec::conj
Vec conj() const
conjugation (makes sense for complex numbers and quaternions)
cv::Vec::Vec
Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7)
8-element vector constructor
cv::sqrt
CV_EXPORTS_W void sqrt(InputArray src, OutputArray dst)
Calculates a square root of array elements.
cv::norm
CV_EXPORTS_W double norm(InputArray src1, int normType=NORM_L2, InputArray mask=noArray())
Calculates the absolute norm of an array.
cv::solve
CV_EXPORTS_W bool solve(InputArray src1, InputArray src2, OutputArray dst, int flags=DECOMP_LU)
Solves one or more linear systems or least-squares problems.
cv::trace
CV_EXPORTS_W Scalar trace(InputArray mtx)
Returns the trace of a matrix.
cv::min
CV_EXPORTS_W void min(InputArray src1, InputArray src2, OutputArray dst)
Calculates per-element minimum of two arrays or an array and a scalar.
cv::determinant
CV_EXPORTS_W double determinant(InputArray mtx)
Returns the determinant of a square floating-point matrix.
cv::normalize
CV_EXPORTS_W void normalize(InputArray src, InputOutputArray dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, InputArray mask=noArray())
Normalizes the norm or value range of an array.
cv::DECOMP_LU
@ DECOMP_LU
Definition: base.hpp:135
cv::NORM_L2
@ NORM_L2
Definition: base.hpp:185
cv::NORM_L1
@ NORM_L1
Definition: base.hpp:176
cv::NORM_L2SQR
@ NORM_L2SQR
Definition: base.hpp:194
cv::NORM_INF
@ NORM_INF
Definition: base.hpp:168
cv::operator/
CV_INLINE v_reg< _Tp, n > operator/(const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
Divide values
cv::LU
CV_EXPORTS int LU(float *A, size_t astep, int m, float *b, size_t bstep, int n)
CV_DbgAssert
#define CV_DbgAssert(expr)
Definition: base.hpp:375
cv
"black box" representation of the file storage associated with a file on disk.
Definition: aruco.hpp:75
cv::conjugate
DualQuat< T > conjugate(const DualQuat< T > &dq)
Definition: dualquaternion.inl.hpp:125
cv::traits::Depth
Definition: traits.hpp:382
cv::traits::SafeFmt
Definition: traits.hpp:402
cv::traits::Type
Definition: traits.hpp:386
構築: doxygen 1.9.2