EstervQrCode 2.0.0
Library for qr code manipulation
Loading...
Searching...
No Matches
matx.inl.hpp
1// This file is part of OpenCV project.
2// It is subject to the license terms in the LICENSE file found in the top-level directory
3// of this distribution and at http://opencv.org/license.html.
4
5#ifndef OPENCV_CORE_MATX_INL_HPP
6#define OPENCV_CORE_MATX_INL_HPP
7
8#ifndef __cplusplus
9# error matx.inl.hpp header must be compiled as C++
10#endif
11
12#include "opencv2/core/matx.hpp"
13
14namespace cv
15{
16
17//==============================================================================
18// Helpers
19
20namespace internal
21{
22
23template<typename _Tp, int m> struct Matx_DetOp
24{
25 double operator ()(const Matx<_Tp, m, m>& a) const
26 {
27 Matx<_Tp, m, m> temp = a;
28 double p = LU(temp.val, m*sizeof(_Tp), m, 0, 0, 0);
29 if( p == 0 )
30 return p;
31 for( int i = 0; i < m; i++ )
32 p *= temp(i, i);
33 return p;
34 }
35};
36
37template<typename _Tp> struct Matx_DetOp<_Tp, 1>
38{
39 double operator ()(const Matx<_Tp, 1, 1>& a) const
40 {
41 return a(0,0);
42 }
43};
44
45template<typename _Tp> struct Matx_DetOp<_Tp, 2>
46{
47 double operator ()(const Matx<_Tp, 2, 2>& a) const
48 {
49 return a(0,0)*a(1,1) - a(0,1)*a(1,0);
50 }
51};
52
53template<typename _Tp> struct Matx_DetOp<_Tp, 3>
54{
55 double operator ()(const Matx<_Tp, 3, 3>& a) const
56 {
57 return a(0,0)*(a(1,1)*a(2,2) - a(2,1)*a(1,2)) -
58 a(0,1)*(a(1,0)*a(2,2) - a(2,0)*a(1,2)) +
59 a(0,2)*(a(1,0)*a(2,1) - a(2,0)*a(1,1));
60 }
61};
62
63template<typename _Tp> Vec<_Tp, 2> inline conjugate(const Vec<_Tp, 2>& v)
64{
65 return Vec<_Tp, 2>(v[0], -v[1]);
66}
67
68template<typename _Tp> Vec<_Tp, 4> inline conjugate(const Vec<_Tp, 4>& v)
69{
70 return Vec<_Tp, 4>(v[0], -v[1], -v[2], -v[3]);
71}
72
73} // internal::
74
75
76//==============================================================================
77// Matx
78
79template<typename _Tp, int m, int n> class DataType< Matx<_Tp, m, n> >
80{
81public:
82 typedef Matx<_Tp, m, n> value_type;
83 typedef Matx<typename DataType<_Tp>::work_type, m, n> work_type;
84 typedef _Tp channel_type;
85 typedef value_type vec_type;
86
87 enum { generic_type = 0,
88 channels = m * n,
89 fmt = traits::SafeFmt<channel_type>::fmt + ((channels - 1) << 8)
90#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
91 ,depth = DataType<channel_type>::depth
92 ,type = CV_MAKETYPE(depth, channels)
93#endif
94 };
95};
96
97
98namespace traits {
99template<typename _Tp, int m, int n>
100struct Depth< Matx<_Tp, m, n> > { enum { value = Depth<_Tp>::value }; };
101template<typename _Tp, int m, int n>
102struct Type< Matx<_Tp, m, n> > { enum { value = CV_MAKETYPE(Depth<_Tp>::value, n*m) }; };
103} // namespace
104
105
107template<typename _Tp, int m, int n> class MatxCommaInitializer
108{
109public:
110 MatxCommaInitializer(Matx<_Tp, m, n>* _mtx);
111 template<typename T2> MatxCommaInitializer<_Tp, m, n>& operator , (T2 val);
112 Matx<_Tp, m, n> operator *() const;
113
114 Matx<_Tp, m, n>* dst;
115 int idx;
116};
117
118template<typename _Tp, typename _T2, int m, int n> static inline
119MatxCommaInitializer<_Tp, m, n> operator << (const Matx<_Tp, m, n>& mtx, _T2 val)
120{
121 MatxCommaInitializer<_Tp, m, n> commaInitializer((Matx<_Tp, m, n>*)&mtx);
122 return (commaInitializer, val);
123}
124
125template<typename _Tp, int m, int n> inline
126MatxCommaInitializer<_Tp, m, n>::MatxCommaInitializer(Matx<_Tp, m, n>* _mtx)
127 : dst(_mtx), idx(0)
128{}
129
130template<typename _Tp, int m, int n> template<typename _T2> inline
131MatxCommaInitializer<_Tp, m, n>& MatxCommaInitializer<_Tp, m, n>::operator , (_T2 value)
132{
133 CV_DbgAssert( idx < m*n );
134 dst->val[idx++] = saturate_cast<_Tp>(value);
135 return *this;
136}
137
138template<typename _Tp, int m, int n> inline
139Matx<_Tp, m, n> MatxCommaInitializer<_Tp, m, n>::operator *() const
140{
141 CV_DbgAssert( idx == n*m );
142 return *dst;
143}
144
146
147template<typename _Tp, int m, int n> inline
148Matx<_Tp, m, n>::Matx()
149{
150 for(int i = 0; i < channels; i++) val[i] = _Tp(0);
151}
152
153template<typename _Tp, int m, int n> inline
154Matx<_Tp, m, n>::Matx(_Tp v0)
155{
156 val[0] = v0;
157 for(int i = 1; i < channels; i++) val[i] = _Tp(0);
158}
159
160template<typename _Tp, int m, int n> inline
161Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1)
162{
163 CV_StaticAssert(channels >= 2, "Matx should have at least 2 elements.");
164 val[0] = v0; val[1] = v1;
165 for(int i = 2; i < channels; i++) val[i] = _Tp(0);
166}
167
168template<typename _Tp, int m, int n> inline
169Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2)
170{
171 CV_StaticAssert(channels >= 3, "Matx should have at least 3 elements.");
172 val[0] = v0; val[1] = v1; val[2] = v2;
173 for(int i = 3; i < channels; i++) val[i] = _Tp(0);
174}
175
176template<typename _Tp, int m, int n> inline
177Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3)
178{
179 CV_StaticAssert(channels >= 4, "Matx should have at least 4 elements.");
180 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
181 for(int i = 4; i < channels; i++) val[i] = _Tp(0);
182}
183
184template<typename _Tp, int m, int n> inline
185Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4)
186{
187 CV_StaticAssert(channels >= 5, "Matx should have at least 5 elements.");
188 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3; val[4] = v4;
189 for(int i = 5; i < channels; i++) val[i] = _Tp(0);
190}
191
192template<typename _Tp, int m, int n> inline
193Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5)
194{
195 CV_StaticAssert(channels >= 6, "Matx should have at least 6 elements.");
196 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
197 val[4] = v4; val[5] = v5;
198 for(int i = 6; i < channels; i++) val[i] = _Tp(0);
199}
200
201template<typename _Tp, int m, int n> inline
202Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6)
203{
204 CV_StaticAssert(channels >= 7, "Matx should have at least 7 elements.");
205 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
206 val[4] = v4; val[5] = v5; val[6] = v6;
207 for(int i = 7; i < channels; i++) val[i] = _Tp(0);
208}
209
210template<typename _Tp, int m, int n> inline
211Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7)
212{
213 CV_StaticAssert(channels >= 8, "Matx should have at least 8 elements.");
214 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
215 val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
216 for(int i = 8; i < channels; i++) val[i] = _Tp(0);
217}
218
219template<typename _Tp, int m, int n> inline
220Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8)
221{
222 CV_StaticAssert(channels >= 9, "Matx should have at least 9 elements.");
223 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
224 val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
225 val[8] = v8;
226 for(int i = 9; i < channels; i++) val[i] = _Tp(0);
227}
228
229template<typename _Tp, int m, int n> inline
230Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9)
231{
232 CV_StaticAssert(channels >= 10, "Matx should have at least 10 elements.");
233 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
234 val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
235 val[8] = v8; val[9] = v9;
236 for(int i = 10; i < channels; i++) val[i] = _Tp(0);
237}
238
239
240template<typename _Tp, int m, int n> inline
241Matx<_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)
242{
243 CV_StaticAssert(channels >= 12, "Matx should have at least 12 elements.");
244 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
245 val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
246 val[8] = v8; val[9] = v9; val[10] = v10; val[11] = v11;
247 for(int i = 12; i < channels; i++) val[i] = _Tp(0);
248}
249
250template<typename _Tp, int m, int n> inline
251Matx<_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)
252{
253 CV_StaticAssert(channels >= 14, "Matx should have at least 14 elements.");
254 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
255 val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
256 val[8] = v8; val[9] = v9; val[10] = v10; val[11] = v11;
257 val[12] = v12; val[13] = v13;
258 for (int i = 14; i < channels; i++) val[i] = _Tp(0);
259}
260
261
262template<typename _Tp, int m, int n> inline
263Matx<_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)
264{
265 CV_StaticAssert(channels >= 16, "Matx should have at least 16 elements.");
266 val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
267 val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
268 val[8] = v8; val[9] = v9; val[10] = v10; val[11] = v11;
269 val[12] = v12; val[13] = v13; val[14] = v14; val[15] = v15;
270 for(int i = 16; i < channels; i++) val[i] = _Tp(0);
271}
272
273// WARNING: unreachable code using Ninja
274#if defined _MSC_VER && _MSC_VER >= 1920
275#pragma warning(push)
276#pragma warning(disable: 4702)
277#endif
278template<typename _Tp, int m, int n> inline
279Matx<_Tp, m, n>::Matx(const _Tp* values)
280{
281 for( int i = 0; i < channels; i++ ) val[i] = values[i];
282}
283#if defined _MSC_VER && _MSC_VER >= 1920
284#pragma warning(pop)
285#endif
286
287template<typename _Tp, int m, int n> inline
288Matx<_Tp, m, n>::Matx(std::initializer_list<_Tp> list)
289{
290 CV_DbgAssert(list.size() == channels);
291 int i = 0;
292 for(const auto& elem : list)
293 {
294 val[i++] = elem;
295 }
296}
297
298template<typename _Tp, int m, int n> inline
299Matx<_Tp, m, n> Matx<_Tp, m, n>::all(_Tp alpha)
300{
301 Matx<_Tp, m, n> M;
302 for( int i = 0; i < m*n; i++ ) M.val[i] = alpha;
303 return M;
304}
305
306template<typename _Tp, int m, int n> inline
307Matx<_Tp,m,n> Matx<_Tp,m,n>::zeros()
308{
309 return all(0);
310}
311
312template<typename _Tp, int m, int n> inline
313Matx<_Tp,m,n> Matx<_Tp,m,n>::ones()
314{
315 return all(1);
316}
317
318template<typename _Tp, int m, int n> inline
319Matx<_Tp,m,n> Matx<_Tp,m,n>::eye()
320{
321 Matx<_Tp,m,n> M;
322 for(int i = 0; i < shortdim; i++)
323 M(i,i) = 1;
324 return M;
325}
326
327template<typename _Tp, int m, int n> inline
328_Tp Matx<_Tp, m, n>::dot(const Matx<_Tp, m, n>& M) const
329{
330 _Tp s = 0;
331 for( int i = 0; i < channels; i++ ) s += val[i]*M.val[i];
332 return s;
333}
334
335template<typename _Tp, int m, int n> inline
336double Matx<_Tp, m, n>::ddot(const Matx<_Tp, m, n>& M) const
337{
338 double s = 0;
339 for( int i = 0; i < channels; i++ ) s += (double)val[i]*M.val[i];
340 return s;
341}
342
343template<typename _Tp, int m, int n> inline
344Matx<_Tp,m,n> Matx<_Tp,m,n>::diag(const typename Matx<_Tp,m,n>::diag_type& d)
345{
346 Matx<_Tp,m,n> M;
347 for(int i = 0; i < shortdim; i++)
348 M(i,i) = d(i, 0);
349 return M;
350}
351
352template<typename _Tp, int m, int n> template<typename T2>
353inline Matx<_Tp, m, n>::operator Matx<T2, m, n>() const
354{
355 Matx<T2, m, n> M;
356 for( int i = 0; i < m*n; i++ ) M.val[i] = saturate_cast<T2>(val[i]);
357 return M;
358}
359
360template<typename _Tp, int m, int n> template<int m1, int n1> inline
361Matx<_Tp, m1, n1> Matx<_Tp, m, n>::reshape() const
362{
363 CV_StaticAssert(m1*n1 == m*n, "Input and destination matrices must have the same number of elements");
364 return (const Matx<_Tp, m1, n1>&)*this;
365}
366
367template<typename _Tp, int m, int n>
368template<int m1, int n1> inline
369Matx<_Tp, m1, n1> Matx<_Tp, m, n>::get_minor(int base_row, int base_col) const
370{
371 CV_DbgAssert(0 <= base_row && base_row+m1 <= m && 0 <= base_col && base_col+n1 <= n);
372 Matx<_Tp, m1, n1> s;
373 for( int di = 0; di < m1; di++ )
374 for( int dj = 0; dj < n1; dj++ )
375 s(di, dj) = (*this)(base_row+di, base_col+dj);
376 return s;
377}
378
379template<typename _Tp, int m, int n> inline
380Matx<_Tp, 1, n> Matx<_Tp, m, n>::row(int i) const
381{
382 CV_DbgAssert((unsigned)i < (unsigned)m);
383 return Matx<_Tp, 1, n>(&val[i*n]);
384}
385
386template<typename _Tp, int m, int n> inline
387Matx<_Tp, m, 1> Matx<_Tp, m, n>::col(int j) const
388{
389 CV_DbgAssert((unsigned)j < (unsigned)n);
390 Matx<_Tp, m, 1> v;
391 for( int i = 0; i < m; i++ )
392 v.val[i] = val[i*n + j];
393 return v;
394}
395
396template<typename _Tp, int m, int n> inline
397typename Matx<_Tp, m, n>::diag_type Matx<_Tp, m, n>::diag() const
398{
399 diag_type d;
400 for( int i = 0; i < shortdim; i++ )
401 d.val[i] = val[i*n + i];
402 return d;
403}
404
405template<typename _Tp, int m, int n> inline
406const _Tp& Matx<_Tp, m, n>::operator()(int row_idx, int col_idx) const
407{
408 CV_DbgAssert( (unsigned)row_idx < (unsigned)m && (unsigned)col_idx < (unsigned)n );
409 return this->val[row_idx*n + col_idx];
410}
411
412template<typename _Tp, int m, int n> inline
413_Tp& Matx<_Tp, m, n>::operator ()(int row_idx, int col_idx)
414{
415 CV_DbgAssert( (unsigned)row_idx < (unsigned)m && (unsigned)col_idx < (unsigned)n );
416 return val[row_idx*n + col_idx];
417}
418
419template<typename _Tp, int m, int n> inline
420const _Tp& Matx<_Tp, m, n>::operator ()(int i) const
421{
422 CV_StaticAssert(m == 1 || n == 1, "Single index indexation requires matrix to be a column or a row");
423 CV_DbgAssert( (unsigned)i < (unsigned)(m+n-1) );
424 return val[i];
425}
426
427template<typename _Tp, int m, int n> inline
428_Tp& Matx<_Tp, m, n>::operator ()(int i)
429{
430 CV_StaticAssert(m == 1 || n == 1, "Single index indexation requires matrix to be a column or a row");
431 CV_DbgAssert( (unsigned)i < (unsigned)(m+n-1) );
432 return val[i];
433}
434
435template<typename _Tp, int m, int n> inline
436Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_AddOp)
437{
438 for( int i = 0; i < channels; i++ )
439 val[i] = saturate_cast<_Tp>(a.val[i] + b.val[i]);
440}
441
442template<typename _Tp, int m, int n> inline
443Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_SubOp)
444{
445 for( int i = 0; i < channels; i++ )
446 val[i] = saturate_cast<_Tp>(a.val[i] - b.val[i]);
447}
448
449template<typename _Tp, int m, int n> template<typename _T2> inline
450Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, _T2 alpha, Matx_ScaleOp)
451{
452 for( int i = 0; i < channels; i++ )
453 val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
454}
455
456template<typename _Tp, int m, int n> inline
457Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_MulOp)
458{
459 for( int i = 0; i < channels; i++ )
460 val[i] = saturate_cast<_Tp>(a.val[i] * b.val[i]);
461}
462
463template<typename _Tp, int m, int n> inline
464Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_DivOp)
465{
466 for( int i = 0; i < channels; i++ )
467 val[i] = saturate_cast<_Tp>(a.val[i] / b.val[i]);
468}
469
470template<typename _Tp, int m, int n> template<int l> inline
471Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b, Matx_MatMulOp)
472{
473 for( int i = 0; i < m; i++ )
474 for( int j = 0; j < n; j++ )
475 {
476 _Tp s = 0;
477 for( int k = 0; k < l; k++ )
478 s += a(i, k) * b(k, j);
479 val[i*n + j] = s;
480 }
481}
482
483template<typename _Tp, int m, int n> inline
484Matx<_Tp,m,n>::Matx(const Matx<_Tp, n, m>& a, Matx_TOp)
485{
486 for( int i = 0; i < m; i++ )
487 for( int j = 0; j < n; j++ )
488 val[i*n + j] = a(j, i);
489}
490
491template<typename _Tp, int m, int n> inline
492Matx<_Tp, m, n> Matx<_Tp, m, n>::mul(const Matx<_Tp, m, n>& a) const
493{
494 return Matx<_Tp, m, n>(*this, a, Matx_MulOp());
495}
496
497template<typename _Tp, int m, int n> inline
498Matx<_Tp, m, n> Matx<_Tp, m, n>::div(const Matx<_Tp, m, n>& a) const
499{
500 return Matx<_Tp, m, n>(*this, a, Matx_DivOp());
501}
502
503template<typename _Tp, int m, int n> inline
504Matx<_Tp, n, m> Matx<_Tp, m, n>::t() const
505{
506 return Matx<_Tp, n, m>(*this, Matx_TOp());
507}
508
509template<typename _Tp, int m, int n> inline
510Vec<_Tp, n> Matx<_Tp, m, n>::solve(const Vec<_Tp, m>& rhs, int method) const
511{
512 Matx<_Tp, n, 1> x = solve((const Matx<_Tp, m, 1>&)(rhs), method);
513 return (Vec<_Tp, n>&)(x);
514}
515
516template<typename _Tp, int m> static inline
517double determinant(const Matx<_Tp, m, m>& a)
518{
519 return cv::internal::Matx_DetOp<_Tp, m>()(a);
520}
521
522template<typename _Tp, int m, int n> static inline
523double trace(const Matx<_Tp, m, n>& a)
524{
525 _Tp s = 0;
526 for( int i = 0; i < std::min(m, n); i++ )
527 s += a(i,i);
528 return s;
529}
530
531template<typename _Tp, int m, int n> static inline
532double norm(const Matx<_Tp, m, n>& M)
533{
534 return std::sqrt(normL2Sqr<_Tp, double>(M.val, m*n));
535}
536
537template<typename _Tp, int m, int n> static inline
538double norm(const Matx<_Tp, m, n>& M, int normType)
539{
540 switch(normType) {
541 case NORM_INF:
542 return (double)normInf<_Tp, typename DataType<_Tp>::work_type>(M.val, m*n);
543 case NORM_L1:
544 return (double)normL1<_Tp, typename DataType<_Tp>::work_type>(M.val, m*n);
545 case NORM_L2SQR:
546 return (double)normL2Sqr<_Tp, typename DataType<_Tp>::work_type>(M.val, m*n);
547 default:
548 case NORM_L2:
549 return std::sqrt((double)normL2Sqr<_Tp, typename DataType<_Tp>::work_type>(M.val, m*n));
550 }
551}
552
553template<typename _Tp1, typename _Tp2, int m, int n> static inline
554Matx<_Tp1, m, n>& operator += (Matx<_Tp1, m, n>& a, const Matx<_Tp2, m, n>& b)
555{
556 for( int i = 0; i < m*n; i++ )
557 a.val[i] = saturate_cast<_Tp1>(a.val[i] + b.val[i]);
558 return a;
559}
560
561template<typename _Tp1, typename _Tp2, int m, int n> static inline
562Matx<_Tp1, m, n>& operator -= (Matx<_Tp1, m, n>& a, const Matx<_Tp2, m, n>& b)
563{
564 for( int i = 0; i < m*n; i++ )
565 a.val[i] = saturate_cast<_Tp1>(a.val[i] - b.val[i]);
566 return a;
567}
568
569template<typename _Tp, int m, int n> static inline
570Matx<_Tp, m, n> operator + (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
571{
572 return Matx<_Tp, m, n>(a, b, Matx_AddOp());
573}
574
575template<typename _Tp, int m, int n> static inline
576Matx<_Tp, m, n> operator - (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
577{
578 return Matx<_Tp, m, n>(a, b, Matx_SubOp());
579}
580
581template<typename _Tp, int m, int n> static inline
582Matx<_Tp, m, n>& operator *= (Matx<_Tp, m, n>& a, int alpha)
583{
584 for( int i = 0; i < m*n; i++ )
585 a.val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
586 return a;
587}
588
589template<typename _Tp, int m, int n> static inline
590Matx<_Tp, m, n>& operator *= (Matx<_Tp, m, n>& a, float alpha)
591{
592 for( int i = 0; i < m*n; i++ )
593 a.val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
594 return a;
595}
596
597template<typename _Tp, int m, int n> static inline
598Matx<_Tp, m, n>& operator *= (Matx<_Tp, m, n>& a, double alpha)
599{
600 for( int i = 0; i < m*n; i++ )
601 a.val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
602 return a;
603}
604
605template<typename _Tp, int m, int n> static inline
606Matx<_Tp, m, n> operator * (const Matx<_Tp, m, n>& a, int alpha)
607{
608 return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
609}
610
611template<typename _Tp, int m, int n> static inline
612Matx<_Tp, m, n> operator * (const Matx<_Tp, m, n>& a, float alpha)
613{
614 return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
615}
616
617template<typename _Tp, int m, int n> static inline
618Matx<_Tp, m, n> operator * (const Matx<_Tp, m, n>& a, double alpha)
619{
620 return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
621}
622
623template<typename _Tp, int m, int n> static inline
624Matx<_Tp, m, n> operator * (int alpha, const Matx<_Tp, m, n>& a)
625{
626 return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
627}
628
629template<typename _Tp, int m, int n> static inline
630Matx<_Tp, m, n> operator * (float alpha, const Matx<_Tp, m, n>& a)
631{
632 return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
633}
634
635template<typename _Tp, int m, int n> static inline
636Matx<_Tp, m, n> operator * (double alpha, const Matx<_Tp, m, n>& a)
637{
638 return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
639}
640
641template<typename _Tp, int m, int n> static inline
642Matx<_Tp, m, n>& operator /= (Matx<_Tp, m, n>& a, float alpha)
643{
644 for( int i = 0; i < m*n; i++ )
645 a.val[i] = a.val[i] / alpha;
646 return a;
647}
648
649template<typename _Tp, int m, int n> static inline
650Matx<_Tp, m, n>& operator /= (Matx<_Tp, m, n>& a, double alpha)
651{
652 for( int i = 0; i < m*n; i++ )
653 a.val[i] = a.val[i] / alpha;
654 return a;
655}
656
657template<typename _Tp, int m, int n> static inline
658Matx<_Tp, m, n> operator / (const Matx<_Tp, m, n>& a, float alpha)
659{
660 return Matx<_Tp, m, n>(a, 1.f/alpha, Matx_ScaleOp());
661}
662
663template<typename _Tp, int m, int n> static inline
664Matx<_Tp, m, n> operator / (const Matx<_Tp, m, n>& a, double alpha)
665{
666 return Matx<_Tp, m, n>(a, 1./alpha, Matx_ScaleOp());
667}
668
669template<typename _Tp, int m, int n> static inline
670Matx<_Tp, m, n> operator - (const Matx<_Tp, m, n>& a)
671{
672 return Matx<_Tp, m, n>(a, -1, Matx_ScaleOp());
673}
674
675template<typename _Tp, int m, int n, int l> static inline
676Matx<_Tp, m, n> operator * (const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b)
677{
678 return Matx<_Tp, m, n>(a, b, Matx_MatMulOp());
679}
680
681template<typename _Tp, int m, int n> static inline
682Vec<_Tp, m> operator * (const Matx<_Tp, m, n>& a, const Vec<_Tp, n>& b)
683{
684 Matx<_Tp, m, 1> c(a, b, Matx_MatMulOp());
685 return (const Vec<_Tp, m>&)(c);
686}
687
688template<typename _Tp, int m, int n> static inline
689bool operator == (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
690{
691 for( int i = 0; i < m*n; i++ )
692 if( a.val[i] != b.val[i] ) return false;
693 return true;
694}
695
696template<typename _Tp, int m, int n> static inline
697bool operator != (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
698{
699 return !(a == b);
700}
701
702//==============================================================================
703// Vec
704
705template<typename _Tp, int cn> class DataType< Vec<_Tp, cn> >
706{
707public:
708 typedef Vec<_Tp, cn> value_type;
709 typedef Vec<typename DataType<_Tp>::work_type, cn> work_type;
710 typedef _Tp channel_type;
711 typedef value_type vec_type;
712
713 enum { generic_type = 0,
714 channels = cn,
715 fmt = DataType<channel_type>::fmt + ((channels - 1) << 8),
716#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
717 depth = DataType<channel_type>::depth,
718 type = CV_MAKETYPE(depth, channels),
719#endif
720 _dummy_enum_finalizer = 0
721 };
722};
723
724namespace traits {
725template<typename _Tp, int cn>
726struct Depth< Vec<_Tp, cn> > { enum { value = Depth<_Tp>::value }; };
727template<typename _Tp, int cn>
728struct Type< Vec<_Tp, cn> > { enum { value = CV_MAKETYPE(Depth<_Tp>::value, cn) }; };
729} // namespace
730
733template<typename _Tp, int m> class VecCommaInitializer : public MatxCommaInitializer<_Tp, m, 1>
734{
735public:
736 VecCommaInitializer(Vec<_Tp, m>* _vec);
737 template<typename T2> VecCommaInitializer<_Tp, m>& operator , (T2 val);
738 Vec<_Tp, m> operator *() const;
739};
740
741template<typename _Tp, typename _T2, int cn> static inline
742VecCommaInitializer<_Tp, cn> operator << (const Vec<_Tp, cn>& vec, _T2 val)
743{
744 VecCommaInitializer<_Tp, cn> commaInitializer((Vec<_Tp, cn>*)&vec);
745 return (commaInitializer, val);
746}
747
748template<typename _Tp, int cn> inline
752
753template<typename _Tp, int cn> template<typename _T2> inline
754VecCommaInitializer<_Tp, cn>& VecCommaInitializer<_Tp, cn>::operator , (_T2 value)
755{
756 CV_DbgAssert( this->idx < cn );
757 this->dst->val[this->idx++] = saturate_cast<_Tp>(value);
758 return *this;
759}
760
761template<typename _Tp, int cn> inline
762Vec<_Tp, cn> VecCommaInitializer<_Tp, cn>::operator *() const
763{
764 CV_DbgAssert( this->idx == cn );
765 return *this->dst;
766}
767
768
769template<typename _Tp, int cn> inline
770Vec<_Tp, cn>::Vec() {}
771
772template<typename _Tp, int cn> inline
773Vec<_Tp, cn>::Vec(_Tp v0)
774 : Matx<_Tp, cn, 1>(v0) {}
775
776template<typename _Tp, int cn> inline
777Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1)
778 : Matx<_Tp, cn, 1>(v0, v1) {}
779
780template<typename _Tp, int cn> inline
781Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2)
782 : Matx<_Tp, cn, 1>(v0, v1, v2) {}
783
784template<typename _Tp, int cn> inline
785Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3)
786 : Matx<_Tp, cn, 1>(v0, v1, v2, v3) {}
787
788template<typename _Tp, int cn> inline
789Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4)
790 : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4) {}
791
792template<typename _Tp, int cn> inline
793Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5)
794 : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5) {}
795
796template<typename _Tp, int cn> inline
797Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6)
798 : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6) {}
799
800template<typename _Tp, int cn> inline
801Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7)
802 : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6, v7) {}
803
804template<typename _Tp, int cn> inline
805Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8)
806 : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6, v7, v8) {}
807
808template<typename _Tp, int cn> inline
809Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9)
810 : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {}
811
812template<typename _Tp, int cn> inline
813Vec<_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)
814 : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) {}
815
816template<typename _Tp, int cn> inline
817Vec<_Tp, cn>::Vec(const _Tp* values)
818 : Matx<_Tp, cn, 1>(values) {}
819
820template<typename _Tp, int cn> inline
821Vec<_Tp, cn>::Vec(std::initializer_list<_Tp> list)
822 : Matx<_Tp, cn, 1>(list) {}
823
824template<typename _Tp, int cn> inline
825Vec<_Tp, cn>::Vec(const Vec<_Tp, cn>& m)
826 : Matx<_Tp, cn, 1>(m.val) {}
827
828template<typename _Tp, int cn> inline
829Vec<_Tp, cn>::Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_AddOp op)
830 : Matx<_Tp, cn, 1>(a, b, op) {}
831
832template<typename _Tp, int cn> inline
833Vec<_Tp, cn>::Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_SubOp op)
834 : Matx<_Tp, cn, 1>(a, b, op) {}
835
836template<typename _Tp, int cn> template<typename _T2> inline
837Vec<_Tp, cn>::Vec(const Matx<_Tp, cn, 1>& a, _T2 alpha, Matx_ScaleOp op)
838 : Matx<_Tp, cn, 1>(a, alpha, op) {}
839
840template<typename _Tp, int cn> inline
841Vec<_Tp, cn> Vec<_Tp, cn>::all(_Tp alpha)
842{
843 Vec v;
844 for( int i = 0; i < cn; i++ ) v.val[i] = alpha;
845 return v;
846}
847
848template<typename _Tp, int cn> inline
849Vec<_Tp, cn> Vec<_Tp, cn>::ones()
850{
851 return Vec::all(1);
852}
853
854template<typename _Tp, int cn> inline
855Vec<_Tp, cn> Vec<_Tp, cn>::zeros()
856{
857 return Vec::all(0);
858}
859
860template<typename _Tp, int cn> inline
861Vec<_Tp, cn> Vec<_Tp, cn>::mul(const Vec<_Tp, cn>& v) const
862{
863 Vec<_Tp, cn> w;
864 for( int i = 0; i < cn; i++ ) w.val[i] = saturate_cast<_Tp>(this->val[i]*v.val[i]);
865 return w;
866}
867
868template<> inline
869Vec<float, 2> Vec<float, 2>::conj() const
870{
871 return cv::internal::conjugate(*this);
872}
873
874template<> inline
879
880template<> inline
881Vec<float, 4> Vec<float, 4>::conj() const
882{
883 return cv::internal::conjugate(*this);
884}
885
886template<> inline
891
892template<typename _Tp, int cn> inline
893Vec<_Tp, cn> Vec<_Tp, cn>::cross(const Vec<_Tp, cn>&) const
894{
895 CV_StaticAssert(cn == 3, "for arbitrary-size vector there is no cross-product defined");
896 return Vec<_Tp, cn>();
897}
898
899template<> inline
900Vec<float, 3> Vec<float, 3>::cross(const Vec<float, 3>& v) const
901{
902 return Vec<float,3>(this->val[1]*v.val[2] - this->val[2]*v.val[1],
903 this->val[2]*v.val[0] - this->val[0]*v.val[2],
904 this->val[0]*v.val[1] - this->val[1]*v.val[0]);
905}
906
907template<> inline
908Vec<double, 3> Vec<double, 3>::cross(const Vec<double, 3>& v) const
909{
910 return Vec<double,3>(this->val[1]*v.val[2] - this->val[2]*v.val[1],
911 this->val[2]*v.val[0] - this->val[0]*v.val[2],
912 this->val[0]*v.val[1] - this->val[1]*v.val[0]);
913}
914
915template<typename _Tp, int cn> template<typename T2> inline
916Vec<_Tp, cn>::operator Vec<T2, cn>() const
917{
918 Vec<T2, cn> v;
919 for( int i = 0; i < cn; i++ ) v.val[i] = saturate_cast<T2>(this->val[i]);
920 return v;
921}
922
923template<typename _Tp, int cn> inline
924const _Tp& Vec<_Tp, cn>::operator [](int i) const
925{
926 CV_DbgAssert( (unsigned)i < (unsigned)cn );
927 return this->val[i];
928}
929
930template<typename _Tp, int cn> inline
931_Tp& Vec<_Tp, cn>::operator [](int i)
932{
933 CV_DbgAssert( (unsigned)i < (unsigned)cn );
934 return this->val[i];
935}
936
937template<typename _Tp, int cn> inline
938const _Tp& Vec<_Tp, cn>::operator ()(int i) const
939{
940 CV_DbgAssert( (unsigned)i < (unsigned)cn );
941 return this->val[i];
942}
943
944template<typename _Tp, int cn> inline
945_Tp& Vec<_Tp, cn>::operator ()(int i)
946{
947 CV_DbgAssert( (unsigned)i < (unsigned)cn );
948 return this->val[i];
949}
950
951template<typename _Tp, int cn> inline
952Vec<_Tp, cn> normalize(const Vec<_Tp, cn>& v)
953{
954 double nv = norm(v);
955 return v * (nv ? 1./nv : 0.);
956}
957
958template<typename _Tp1, typename _Tp2, int cn> static inline
959Vec<_Tp1, cn>& operator += (Vec<_Tp1, cn>& a, const Vec<_Tp2, cn>& b)
960{
961 for( int i = 0; i < cn; i++ )
962 a.val[i] = saturate_cast<_Tp1>(a.val[i] + b.val[i]);
963 return a;
964}
965
966template<typename _Tp1, typename _Tp2, int cn> static inline
967Vec<_Tp1, cn>& operator -= (Vec<_Tp1, cn>& a, const Vec<_Tp2, cn>& b)
968{
969 for( int i = 0; i < cn; i++ )
970 a.val[i] = saturate_cast<_Tp1>(a.val[i] - b.val[i]);
971 return a;
972}
973
974template<typename _Tp, int cn> static inline
975Vec<_Tp, cn> operator + (const Vec<_Tp, cn>& a, const Vec<_Tp, cn>& b)
976{
977 return Vec<_Tp, cn>(a, b, Matx_AddOp());
978}
979
980template<typename _Tp, int cn> static inline
981Vec<_Tp, cn> operator - (const Vec<_Tp, cn>& a, const Vec<_Tp, cn>& b)
982{
983 return Vec<_Tp, cn>(a, b, Matx_SubOp());
984}
985
986template<typename _Tp, int cn> static inline
987Vec<_Tp, cn>& operator *= (Vec<_Tp, cn>& a, int alpha)
988{
989 for( int i = 0; i < cn; i++ )
990 a[i] = saturate_cast<_Tp>(a[i]*alpha);
991 return a;
992}
993
994template<typename _Tp, int cn> static inline
995Vec<_Tp, cn>& operator *= (Vec<_Tp, cn>& a, float alpha)
996{
997 for( int i = 0; i < cn; i++ )
998 a[i] = saturate_cast<_Tp>(a[i]*alpha);
999 return a;
1000}
1001
1002template<typename _Tp, int cn> static inline
1003Vec<_Tp, cn>& operator *= (Vec<_Tp, cn>& a, double alpha)
1004{
1005 for( int i = 0; i < cn; i++ )
1006 a[i] = saturate_cast<_Tp>(a[i]*alpha);
1007 return a;
1008}
1009
1010template<typename _Tp, int cn> static inline
1011Vec<_Tp, cn>& operator /= (Vec<_Tp, cn>& a, int alpha)
1012{
1013 double ialpha = 1./alpha;
1014 for( int i = 0; i < cn; i++ )
1015 a[i] = saturate_cast<_Tp>(a[i]*ialpha);
1016 return a;
1017}
1018
1019template<typename _Tp, int cn> static inline
1020Vec<_Tp, cn>& operator /= (Vec<_Tp, cn>& a, float alpha)
1021{
1022 float ialpha = 1.f/alpha;
1023 for( int i = 0; i < cn; i++ )
1024 a[i] = saturate_cast<_Tp>(a[i]*ialpha);
1025 return a;
1026}
1027
1028template<typename _Tp, int cn> static inline
1029Vec<_Tp, cn>& operator /= (Vec<_Tp, cn>& a, double alpha)
1030{
1031 double ialpha = 1./alpha;
1032 for( int i = 0; i < cn; i++ )
1033 a[i] = saturate_cast<_Tp>(a[i]*ialpha);
1034 return a;
1035}
1036
1037template<typename _Tp, int cn> static inline
1038Vec<_Tp, cn> operator * (const Vec<_Tp, cn>& a, int alpha)
1039{
1040 return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
1041}
1042
1043template<typename _Tp, int cn> static inline
1044Vec<_Tp, cn> operator * (int alpha, const Vec<_Tp, cn>& a)
1045{
1046 return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
1047}
1048
1049template<typename _Tp, int cn> static inline
1050Vec<_Tp, cn> operator * (const Vec<_Tp, cn>& a, float alpha)
1051{
1052 return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
1053}
1054
1055template<typename _Tp, int cn> static inline
1056Vec<_Tp, cn> operator * (float alpha, const Vec<_Tp, cn>& a)
1057{
1058 return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
1059}
1060
1061template<typename _Tp, int cn> static inline
1062Vec<_Tp, cn> operator * (const Vec<_Tp, cn>& a, double alpha)
1063{
1064 return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
1065}
1066
1067template<typename _Tp, int cn> static inline
1068Vec<_Tp, cn> operator * (double alpha, const Vec<_Tp, cn>& a)
1069{
1070 return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
1071}
1072
1073template<typename _Tp, int cn> static inline
1074Vec<_Tp, cn> operator / (const Vec<_Tp, cn>& a, int alpha)
1075{
1076 return Vec<_Tp, cn>(a, 1./alpha, Matx_ScaleOp());
1077}
1078
1079template<typename _Tp, int cn> static inline
1080Vec<_Tp, cn> operator / (const Vec<_Tp, cn>& a, float alpha)
1081{
1082 return Vec<_Tp, cn>(a, 1.f/alpha, Matx_ScaleOp());
1083}
1084
1085template<typename _Tp, int cn> static inline
1086Vec<_Tp, cn> operator / (const Vec<_Tp, cn>& a, double alpha)
1087{
1088 return Vec<_Tp, cn>(a, 1./alpha, Matx_ScaleOp());
1089}
1090
1091template<typename _Tp, int cn> static inline
1092Vec<_Tp, cn> operator - (const Vec<_Tp, cn>& a)
1093{
1094 Vec<_Tp,cn> t;
1095 for( int i = 0; i < cn; i++ ) t.val[i] = saturate_cast<_Tp>(-a.val[i]);
1096 return t;
1097}
1098
1099template<typename _Tp> inline Vec<_Tp, 4> operator * (const Vec<_Tp, 4>& v1, const Vec<_Tp, 4>& v2)
1100{
1101 return Vec<_Tp, 4>(saturate_cast<_Tp>(v1[0]*v2[0] - v1[1]*v2[1] - v1[2]*v2[2] - v1[3]*v2[3]),
1102 saturate_cast<_Tp>(v1[0]*v2[1] + v1[1]*v2[0] + v1[2]*v2[3] - v1[3]*v2[2]),
1103 saturate_cast<_Tp>(v1[0]*v2[2] - v1[1]*v2[3] + v1[2]*v2[0] + v1[3]*v2[1]),
1104 saturate_cast<_Tp>(v1[0]*v2[3] + v1[1]*v2[2] - v1[2]*v2[1] + v1[3]*v2[0]));
1105}
1106
1107template<typename _Tp> inline Vec<_Tp, 4>& operator *= (Vec<_Tp, 4>& v1, const Vec<_Tp, 4>& v2)
1108{
1109 v1 = v1 * v2;
1110 return v1;
1111}
1112
1113} // cv::
1114
1115#endif // OPENCV_CORE_MATX_INL_HPP
cv::DataType< Matx< _Tp, m, n > >::channel_type
_Tp channel_type
Definition matx.inl.hpp:84
cv::DataType< Matx< _Tp, m, n > >::work_type
Matx< typename DataType< _Tp >::work_type, m, n > work_type
Definition matx.inl.hpp:83
cv::DataType< Matx< _Tp, m, n > >::vec_type
value_type vec_type
Definition matx.inl.hpp:85
cv::DataType< Matx< _Tp, m, n > >::value_type
Matx< _Tp, m, n > value_type
Definition matx.inl.hpp:82
cv::DataType< Vec< _Tp, cn > >::channel_type
_Tp channel_type
Definition matx.inl.hpp:710
cv::DataType< Vec< _Tp, cn > >::work_type
Vec< typename DataType< _Tp >::work_type, cn > work_type
Definition matx.inl.hpp:709
cv::DataType< Vec< _Tp, cn > >::value_type
Vec< _Tp, cn > value_type
Definition matx.inl.hpp:708
cv::DataType< Vec< _Tp, cn > >::vec_type
value_type vec_type
Definition matx.inl.hpp:711
cv::DataType
Template "trait" class for OpenCV primitive data types.
Definition traits.hpp:113
cv::MatxCommaInitializer
Comma-separated Matrix Initializer.
Definition matx.inl.hpp:108
cv::MatxCommaInitializer::idx
int idx
Definition matx.inl.hpp:115
cv::MatxCommaInitializer::dst
Matx< _Tp, m, n > * dst
Definition matx.inl.hpp:114
cv::MatxCommaInitializer::operator,
MatxCommaInitializer< _Tp, m, n > & operator,(T2 val)
cv::MatxCommaInitializer::operator*
Matx< _Tp, m, n > operator*() const
Definition matx.inl.hpp:139
cv::MatxCommaInitializer::MatxCommaInitializer
MatxCommaInitializer(Matx< _Tp, m, n > *_mtx)
Definition matx.inl.hpp:126
cv::Matx
Template class for small matrices whose type and size are known at compilation time.
Definition matx.hpp:100
cv::Matx::mul
Matx< _Tp, m, n > mul(const Matx< _Tp, m, n > &a) const
multiply two matrices element-wise
Definition matx.inl.hpp:492
cv::Matx::Matx
Matx()
default constructor
Definition matx.inl.hpp:148
cv::Matx::t
Matx< _Tp, n, m > t() const
transpose the matrix
Definition matx.inl.hpp:504
cv::Matx::ones
static CV_NODISCARD_STD Matx ones()
Definition matx.inl.hpp:313
cv::Matx::row
Matx< _Tp, 1, n > row(int i) const
extract the matrix row
Definition matx.inl.hpp:380
cv::Matx::col
Matx< _Tp, m, 1 > col(int i) const
extract the matrix column
Definition matx.inl.hpp:387
cv::Matx::eye
static CV_NODISCARD_STD Matx eye()
Definition matx.inl.hpp:319
cv::Matx::div
Matx< _Tp, m, n > div(const Matx< _Tp, m, n > &a) const
divide two matrices element-wise
Definition matx.inl.hpp:498
cv::Matx::reshape
Matx< _Tp, m1, n1 > reshape() const
change the matrix shape
Definition matx.inl.hpp:361
cv::Matx::zeros
static CV_NODISCARD_STD Matx zeros()
Definition matx.inl.hpp:307
cv::Matx::operator()
const _Tp & operator()(int row, int col) const
element access
Definition matx.inl.hpp:406
cv::Matx::all
static CV_NODISCARD_STD Matx all(_Tp alpha)
Definition matx.inl.hpp:299
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
Definition matx.inl.hpp:336
cv::Matx::diag
diag_type diag() const
extract the matrix diagonal
Definition matx.inl.hpp:397
cv::Matx::val
_Tp val[m *n]
matrix elements
Definition matx.hpp:218
cv::Matx::get_minor
Matx< _Tp, m1, n1 > get_minor(int base_row, int base_col) const
extract part of the matrix
Definition matx.inl.hpp:369
cv::Matx::dot
_Tp dot(const Matx< _Tp, m, n > &v) const
dot product computed with the default precision
Definition matx.inl.hpp:328
cv::VecCommaInitializer
Comma-separated Vec Initializer.
Definition matx.inl.hpp:734
cv::VecCommaInitializer::operator,
VecCommaInitializer< _Tp, m > & operator,(T2 val)
cv::VecCommaInitializer::operator*
Vec< _Tp, m > operator*() const
Definition matx.inl.hpp:762
cv::VecCommaInitializer::VecCommaInitializer
VecCommaInitializer(Vec< _Tp, m > *_vec)
Definition matx.inl.hpp:749
cv::Vec
Template class for short numerical vectors, a partial case of Matx.
Definition matx.hpp:369
cv::Vec::zeros
static Vec zeros()
Definition matx.inl.hpp:855
cv::Vec::all
static Vec all(_Tp alpha)
Definition matx.inl.hpp:841
cv::Vec::mul
Vec mul(const Vec< _Tp, cn > &v) const
per-element multiplication
Definition matx.inl.hpp:861
cv::Vec::Vec
Vec()
default constructor
Definition matx.inl.hpp:770
cv::Vec::operator[]
const _Tp & operator[](int i) const
Definition matx.inl.hpp:924
cv::Vec::cross
Vec cross(const Vec &v) const
Definition matx.inl.hpp:893
cv::Vec::ones
static Vec ones()
Definition matx.inl.hpp:849
cv::Vec::operator()
const _Tp & operator()(int i) const
Definition matx.inl.hpp:938
cv::Vec::conj
Vec conj() const
conjugation (makes sense for complex numbers and quaternions)
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::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::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<<
static String & operator<<(String &out, Ptr< Formatted > fmtd)
Definition core.hpp:3164
cv::operator!=
static bool operator!=(const Matx< _Tp, m, n > &a, const Matx< _Tp, m, n > &b)
cv::operator==
static bool operator==(const Matx< _Tp, m, n > &a, const Matx< _Tp, m, n > &b)
value
int CvScalar value
Definition core_c.h:720
channels
int int channels
Definition core_c.h:100
elem
const void * elem
Definition core_c.h:1715
idx
const int * idx
Definition core_c.h:668
type
int int type
Definition core_c.h:221
depth
int depth
Definition core_c.h:100
x
const CvArr CvArr * x
Definition core_c.h:1195
alpha
double alpha
Definition core_c.h:1093
CV_MAKETYPE
#define CV_MAKETYPE(depth, cn)
Definition interface.h:85
cv::operator/=
CV_INLINE v_reg< _Tp, n > & operator/=(v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
cv::operator/
CV_INLINE v_reg< _Tp, n > operator/(const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
Divide values.
cv::operator-=
CV_INLINE v_reg< _Tp, n > & operator-=(v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
cv::operator+=
CV_INLINE v_reg< _Tp, n > & operator+=(v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
cv::operator*=
CV_INLINE v_reg< _Tp, n > & operator*=(v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
cv::LU
CV_EXPORTS int LU(float *A, size_t astep, int m, float *b, size_t bstep, int n)
cv::normL2Sqr
static _AccTp normL2Sqr(const _Tp *a, int n)
Definition base.hpp:404
CV_DbgAssert
#define CV_DbgAssert(expr)
Definition base.hpp:375
M
CvArr CvPoint2D32f double M
Definition imgproc_c.h:270
method
const CvArr CvArr int method
Definition imgproc_c.h:384
temp
CvArr CvArr * temp
Definition imgproc_c.h:329
cv::k
CV_EXPORTS OutputArray int double double InputArray OutputArray int int bool double k
Definition imgproc.hpp:2133
cv::dst
OutputArray dst
Definition imgproc.hpp:3564
std::min
T min(T... args)
cv::internal::conjugate
Vec< _Tp, 2 > conjugate(const Vec< _Tp, 2 > &v)
Definition matx.inl.hpp:63
cv
"black box" representation of the file storage associated with a file on disk.
Definition calib3d.hpp:441
cv::operator-
DualQuat< T > operator-(const DualQuat< T > &q, const T a)
Definition dualquaternion.inl.hpp:255
cv::operator+
DualQuat< T > operator+(const T a, const DualQuat< T > &q)
Definition dualquaternion.inl.hpp:243
cv::operator*
DualQuat< T > operator*(const T a, const DualQuat< T > &q)
Definition dualquaternion.inl.hpp:274
std::sqrt
T sqrt(T... args)
cv::internal::Matx_DetOp
Definition matx.inl.hpp:24
cv::internal::Matx_DetOp::operator()
double operator()(const Matx< _Tp, m, m > &a) const
Definition matx.inl.hpp:25
cv::traits::Depth
Definition traits.hpp:382
cv::traits::Depth::value
@ value
Definition traits.hpp:382
cv::traits::SafeFmt
Definition traits.hpp:402
cv::traits::Type
Definition traits.hpp:386
cv::traits::Type::value
@ value
Definition traits.hpp:386