mat.hpp
Go to the documentation of this file.
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 // Third party copyrights are property of their respective owners.
16 //
17 // Redistribution and use in source and binary forms, with or without modification,
18 // are permitted provided that the following conditions are met:
19 //
20 // * Redistribution's of source code must retain the above copyright notice,
21 // this list of conditions and the following disclaimer.
22 //
23 // * Redistribution's in binary form must reproduce the above copyright notice,
24 // this list of conditions and the following disclaimer in the documentation
25 // and/or other materials provided with the distribution.
26 //
27 // * The name of the copyright holders may not be used to endorse or promote products
28 // derived from this software without specific prior written permission.
29 //
30 // This software is provided by the copyright holders and contributors "as is" and
31 // any express or implied warranties, including, but not limited to, the implied
32 // warranties of merchantability and fitness for a particular purpose are disclaimed.
33 // In no event shall the Intel Corporation or contributors be liable for any direct,
34 // indirect, incidental, special, exemplary, or consequential damages
35 // (including, but not limited to, procurement of substitute goods or services;
36 // loss of use, data, or profits; or business interruption) however caused
37 // and on any theory of liability, whether in contract, strict liability,
38 // or tort (including negligence or otherwise) arising in any way out of
39 // the use of this software, even if advised of the possibility of such damage.
40 //
41 //M*/
42 
43 #ifndef __OPENCV_CORE_MATRIX_OPERATIONS_HPP__
44 #define __OPENCV_CORE_MATRIX_OPERATIONS_HPP__
45 
46 #ifndef SKIP_INCLUDES
47 #include <limits.h>
48 #include <string.h>
49 #endif // SKIP_INCLUDES
50 
51 #ifdef __cplusplus
52 
53 namespace cv
54 {
55 
57 
58 inline void Mat::initEmpty()
59 {
60  flags = MAGIC_VAL;
61  dims = rows = cols = 0;
62  data = datastart = dataend = datalimit = 0;
63  refcount = 0;
64  allocator = 0;
65 }
66 
67 inline Mat::Mat() : size(&rows)
68 {
69  initEmpty();
70 }
71 
72 inline Mat::Mat(int _rows, int _cols, int _type) : size(&rows)
73 {
74  initEmpty();
75  create(_rows, _cols, _type);
76 }
77 
78 inline Mat::Mat(int _rows, int _cols, int _type, const Scalar& _s) : size(&rows)
79 {
80  initEmpty();
81  create(_rows, _cols, _type);
82  *this = _s;
83 }
84 
85 inline Mat::Mat(Size _sz, int _type) : size(&rows)
86 {
87  initEmpty();
88  create( _sz.height, _sz.width, _type );
89 }
90 
91 inline Mat::Mat(Size _sz, int _type, const Scalar& _s) : size(&rows)
92 {
93  initEmpty();
94  create(_sz.height, _sz.width, _type);
95  *this = _s;
96 }
97 
98 inline Mat::Mat(int _dims, const int* _sz, int _type) : size(&rows)
99 {
100  initEmpty();
101  create(_dims, _sz, _type);
102 }
103 
104 inline Mat::Mat(int _dims, const int* _sz, int _type, const Scalar& _s) : size(&rows)
105 {
106  initEmpty();
107  create(_dims, _sz, _type);
108  *this = _s;
109 }
110 
111 inline Mat::Mat(const Mat& m)
112  : flags(m.flags), dims(m.dims), rows(m.rows), cols(m.cols), data(m.data),
113  refcount(m.refcount), datastart(m.datastart), dataend(m.dataend),
114  datalimit(m.datalimit), allocator(m.allocator), size(&rows)
115 {
116  if( refcount )
117  CV_XADD(refcount, 1);
118  if( m.dims <= 2 )
119  {
120  step[0] = m.step[0]; step[1] = m.step[1];
121  }
122  else
123  {
124  dims = 0;
125  copySize(m);
126  }
127 }
128 
129 inline Mat::Mat(int _rows, int _cols, int _type, void* _data, size_t _step)
130  : flags(MAGIC_VAL + (_type & TYPE_MASK)), dims(2), rows(_rows), cols(_cols),
131  data((uchar*)_data), refcount(0), datastart((uchar*)_data), dataend(0),
132  datalimit(0), allocator(0), size(&rows)
133 {
134  size_t esz = CV_ELEM_SIZE(_type), minstep = cols*esz;
135  if( _step == AUTO_STEP )
136  {
137  _step = minstep;
139  }
140  else
141  {
142  if( rows == 1 ) _step = minstep;
143  CV_DbgAssert( _step >= minstep );
144  flags |= _step == minstep ? CONTINUOUS_FLAG : 0;
145  }
146  step[0] = _step; step[1] = esz;
147  datalimit = datastart + _step*rows;
148  dataend = datalimit - _step + minstep;
149 }
150 
151 inline Mat::Mat(Size _sz, int _type, void* _data, size_t _step)
152  : flags(MAGIC_VAL + (_type & TYPE_MASK)), dims(2), rows(_sz.height), cols(_sz.width),
153  data((uchar*)_data), refcount(0), datastart((uchar*)_data), dataend(0),
154  datalimit(0), allocator(0), size(&rows)
155 {
156  size_t esz = CV_ELEM_SIZE(_type), minstep = cols*esz;
157  if( _step == AUTO_STEP )
158  {
159  _step = minstep;
161  }
162  else
163  {
164  if( rows == 1 ) _step = minstep;
165  CV_DbgAssert( _step >= minstep );
166  flags |= _step == minstep ? CONTINUOUS_FLAG : 0;
167  }
168  step[0] = _step; step[1] = esz;
169  datalimit = datastart + _step*rows;
170  dataend = datalimit - _step + minstep;
171 }
172 
173 
174 template<typename _Tp> inline Mat::Mat(const vector<_Tp>& vec, bool copyData)
175  : flags(MAGIC_VAL | DataType<_Tp>::type | CV_MAT_CONT_FLAG),
176  dims(2), rows((int)vec.size()), cols(1), data(0), refcount(0),
177  datastart(0), dataend(0), allocator(0), size(&rows)
178 {
179  if(vec.empty())
180  return;
181  if( !copyData )
182  {
183  step[0] = step[1] = sizeof(_Tp);
184  data = datastart = (uchar*)&vec[0];
186  }
187  else
188  Mat((int)vec.size(), 1, DataType<_Tp>::type, (uchar*)&vec[0]).copyTo(*this);
189 }
190 
191 
192 template<typename _Tp, int n> inline Mat::Mat(const Vec<_Tp, n>& vec, bool copyData)
193  : flags(MAGIC_VAL | DataType<_Tp>::type | CV_MAT_CONT_FLAG),
194  dims(2), rows(n), cols(1), data(0), refcount(0),
195  datastart(0), dataend(0), allocator(0), size(&rows)
196 {
197  if( !copyData )
198  {
199  step[0] = step[1] = sizeof(_Tp);
200  data = datastart = (uchar*)vec.val;
202  }
203  else
204  Mat(n, 1, DataType<_Tp>::type, (void*)vec.val).copyTo(*this);
205 }
206 
207 
208 template<typename _Tp, int m, int n> inline Mat::Mat(const Matx<_Tp,m,n>& M, bool copyData)
209  : flags(MAGIC_VAL | DataType<_Tp>::type | CV_MAT_CONT_FLAG),
210  dims(2), rows(m), cols(n), data(0), refcount(0),
211  datastart(0), dataend(0), allocator(0), size(&rows)
212 {
213  if( !copyData )
214  {
215  step[0] = cols*sizeof(_Tp);
216  step[1] = sizeof(_Tp);
217  data = datastart = (uchar*)M.val;
218  datalimit = dataend = datastart + rows*step[0];
219  }
220  else
221  Mat(m, n, DataType<_Tp>::type, (uchar*)M.val).copyTo(*this);
222 }
223 
224 
225 template<typename _Tp> inline Mat::Mat(const Point_<_Tp>& pt, bool copyData)
226  : flags(MAGIC_VAL | DataType<_Tp>::type | CV_MAT_CONT_FLAG),
227  dims(2), rows(2), cols(1), data(0), refcount(0),
228  datastart(0), dataend(0), allocator(0), size(&rows)
229 {
230  if( !copyData )
231  {
232  step[0] = step[1] = sizeof(_Tp);
233  data = datastart = (uchar*)&pt.x;
235  }
236  else
237  {
239  ((_Tp*)data)[0] = pt.x;
240  ((_Tp*)data)[1] = pt.y;
241  }
242 }
243 
244 
245 template<typename _Tp> inline Mat::Mat(const Point3_<_Tp>& pt, bool copyData)
246  : flags(MAGIC_VAL | DataType<_Tp>::type | CV_MAT_CONT_FLAG),
247  dims(2), rows(3), cols(1), data(0), refcount(0),
248  datastart(0), dataend(0), allocator(0), size(&rows)
249 {
250  if( !copyData )
251  {
252  step[0] = step[1] = sizeof(_Tp);
253  data = datastart = (uchar*)&pt.x;
255  }
256  else
257  {
259  ((_Tp*)data)[0] = pt.x;
260  ((_Tp*)data)[1] = pt.y;
261  ((_Tp*)data)[2] = pt.z;
262  }
263 }
264 
265 
266 template<typename _Tp> inline Mat::Mat(const MatCommaInitializer_<_Tp>& commaInitializer)
267  : flags(MAGIC_VAL | DataType<_Tp>::type | CV_MAT_CONT_FLAG),
268  dims(0), rows(0), cols(0), data(0), refcount(0),
269  datastart(0), dataend(0), allocator(0), size(&rows)
270 {
271  *this = *commaInitializer;
272 }
273 
274 inline Mat::~Mat()
275 {
276  release();
277  if( step.p != step.buf )
278  fastFree(step.p);
279 }
280 
281 inline Mat& Mat::operator = (const Mat& m)
282 {
283  if( this != &m )
284  {
285  if( m.refcount )
286  CV_XADD(m.refcount, 1);
287  release();
288  flags = m.flags;
289  if( dims <= 2 && m.dims <= 2 )
290  {
291  dims = m.dims;
292  rows = m.rows;
293  cols = m.cols;
294  step[0] = m.step[0];
295  step[1] = m.step[1];
296  }
297  else
298  copySize(m);
299  data = m.data;
300  datastart = m.datastart;
301  dataend = m.dataend;
302  datalimit = m.datalimit;
303  refcount = m.refcount;
304  allocator = m.allocator;
305  }
306  return *this;
307 }
308 
309 inline Mat Mat::row(int y) const { return Mat(*this, Range(y, y+1), Range::all()); }
310 inline Mat Mat::col(int x) const { return Mat(*this, Range::all(), Range(x, x+1)); }
311 inline Mat Mat::rowRange(int startrow, int endrow) const
312  { return Mat(*this, Range(startrow, endrow), Range::all()); }
313 inline Mat Mat::rowRange(const Range& r) const
314  { return Mat(*this, r, Range::all()); }
315 inline Mat Mat::colRange(int startcol, int endcol) const
316  { return Mat(*this, Range::all(), Range(startcol, endcol)); }
317 inline Mat Mat::colRange(const Range& r) const
318  { return Mat(*this, Range::all(), r); }
319 
320 inline Mat Mat::diag(const Mat& d)
321 {
322  CV_Assert( d.cols == 1 || d.rows == 1 );
323  int len = d.rows + d.cols - 1;
324  Mat m(len, len, d.type(), Scalar(0)), md = m.diag();
325  if( d.cols == 1 )
326  d.copyTo(md);
327  else
328  transpose(d, md);
329  return m;
330 }
331 
332 inline Mat Mat::clone() const
333 {
334  Mat m;
335  copyTo(m);
336  return m;
337 }
338 
339 inline void Mat::assignTo( Mat& m, int _type ) const
340 {
341  if( _type < 0 )
342  m = *this;
343  else
344  convertTo(m, _type);
345 }
346 
347 inline void Mat::create(int _rows, int _cols, int _type)
348 {
349  _type &= TYPE_MASK;
350  if( dims <= 2 && rows == _rows && cols == _cols && type() == _type && data )
351  return;
352  int sz[] = {_rows, _cols};
353  create(2, sz, _type);
354 }
355 
356 inline void Mat::create(Size _sz, int _type)
357 {
358  create(_sz.height, _sz.width, _type);
359 }
360 
361 inline void Mat::addref()
362 { if( refcount ) CV_XADD(refcount, 1); }
363 
364 inline void Mat::release()
365 {
366  if( refcount && CV_XADD(refcount, -1) == 1 )
367  deallocate();
368  data = datastart = dataend = datalimit = 0;
369  size.p[0] = 0;
370  refcount = 0;
371 }
372 
373 inline Mat Mat::operator()( Range _rowRange, Range _colRange ) const
374 {
375  return Mat(*this, _rowRange, _colRange);
376 }
377 
378 inline Mat Mat::operator()( const Rect& roi ) const
379 { return Mat(*this, roi); }
380 
381 inline Mat Mat::operator()(const Range* ranges) const
382 {
383  return Mat(*this, ranges);
384 }
385 
386 inline Mat::operator CvMat() const
387 {
388  CV_DbgAssert(dims <= 2);
389  CvMat m = cvMat(rows, dims == 1 ? 1 : cols, type(), data);
390  m.step = (int)step[0];
391  m.type = (m.type & ~CONTINUOUS_FLAG) | (flags & CONTINUOUS_FLAG);
392  return m;
393 }
394 
395 inline bool Mat::isContinuous() const { return (flags & CONTINUOUS_FLAG) != 0; }
396 inline bool Mat::isSubmatrix() const { return (flags & SUBMATRIX_FLAG) != 0; }
397 inline size_t Mat::elemSize() const { return dims > 0 ? step.p[dims-1] : 0; }
398 inline size_t Mat::elemSize1() const { return CV_ELEM_SIZE1(flags); }
399 inline int Mat::type() const { return CV_MAT_TYPE(flags); }
400 inline int Mat::depth() const { return CV_MAT_DEPTH(flags); }
401 inline int Mat::channels() const { return CV_MAT_CN(flags); }
402 inline size_t Mat::step1(int i) const { return step.p[i]/elemSize1(); }
403 inline bool Mat::empty() const { return data == 0 || total() == 0; }
404 inline size_t Mat::total() const
405 {
406  if( dims <= 2 )
407  return (size_t)rows*cols;
408  size_t p = 1;
409  for( int i = 0; i < dims; i++ )
410  p *= size[i];
411  return p;
412 }
413 
414 inline uchar* Mat::ptr(int y)
415 {
416  CV_DbgAssert( y == 0 || (data && dims >= 1 && (unsigned)y < (unsigned)size.p[0]) );
417  return data + step.p[0]*y;
418 }
419 
420 inline const uchar* Mat::ptr(int y) const
421 {
422  CV_DbgAssert( y == 0 || (data && dims >= 1 && (unsigned)y < (unsigned)size.p[0]) );
423  return data + step.p[0]*y;
424 }
425 
426 template<typename _Tp> inline _Tp* Mat::ptr(int y)
427 {
428  CV_DbgAssert( y == 0 || (data && dims >= 1 && (unsigned)y < (unsigned)size.p[0]) );
429  return (_Tp*)(data + step.p[0]*y);
430 }
431 
432 template<typename _Tp> inline const _Tp* Mat::ptr(int y) const
433 {
434  CV_DbgAssert( y == 0 || (data && dims >= 1 && (unsigned)y < (unsigned)size.p[0]) );
435  return (const _Tp*)(data + step.p[0]*y);
436 }
437 
438 
439 inline uchar* Mat::ptr(int i0, int i1)
440 {
441  CV_DbgAssert( dims >= 2 && data &&
442  (unsigned)i0 < (unsigned)size.p[0] &&
443  (unsigned)i1 < (unsigned)size.p[1] );
444  return data + i0*step.p[0] + i1*step.p[1];
445 }
446 
447 inline const uchar* Mat::ptr(int i0, int i1) const
448 {
449  CV_DbgAssert( dims >= 2 && data &&
450  (unsigned)i0 < (unsigned)size.p[0] &&
451  (unsigned)i1 < (unsigned)size.p[1] );
452  return data + i0*step.p[0] + i1*step.p[1];
453 }
454 
455 template<typename _Tp> inline _Tp* Mat::ptr(int i0, int i1)
456 {
457  CV_DbgAssert( dims >= 2 && data &&
458  (unsigned)i0 < (unsigned)size.p[0] &&
459  (unsigned)i1 < (unsigned)size.p[1] );
460  return (_Tp*)(data + i0*step.p[0] + i1*step.p[1]);
461 }
462 
463 template<typename _Tp> inline const _Tp* Mat::ptr(int i0, int i1) const
464 {
465  CV_DbgAssert( dims >= 2 && data &&
466  (unsigned)i0 < (unsigned)size.p[0] &&
467  (unsigned)i1 < (unsigned)size.p[1] );
468  return (const _Tp*)(data + i0*step.p[0] + i1*step.p[1]);
469 }
470 
471 inline uchar* Mat::ptr(int i0, int i1, int i2)
472 {
473  CV_DbgAssert( dims >= 3 && data &&
474  (unsigned)i0 < (unsigned)size.p[0] &&
475  (unsigned)i1 < (unsigned)size.p[1] &&
476  (unsigned)i2 < (unsigned)size.p[2] );
477  return data + i0*step.p[0] + i1*step.p[1] + i2*step.p[2];
478 }
479 
480 inline const uchar* Mat::ptr(int i0, int i1, int i2) const
481 {
482  CV_DbgAssert( dims >= 3 && data &&
483  (unsigned)i0 < (unsigned)size.p[0] &&
484  (unsigned)i1 < (unsigned)size.p[1] &&
485  (unsigned)i2 < (unsigned)size.p[2] );
486  return data + i0*step.p[0] + i1*step.p[1] + i2*step.p[2];
487 }
488 
489 template<typename _Tp> inline _Tp* Mat::ptr(int i0, int i1, int i2)
490 {
491  CV_DbgAssert( dims >= 3 && data &&
492  (unsigned)i0 < (unsigned)size.p[0] &&
493  (unsigned)i1 < (unsigned)size.p[1] &&
494  (unsigned)i2 < (unsigned)size.p[2] );
495  return (_Tp*)(data + i0*step.p[0] + i1*step.p[1] + i2*step.p[2]);
496 }
497 
498 template<typename _Tp> inline const _Tp* Mat::ptr(int i0, int i1, int i2) const
499 {
500  CV_DbgAssert( dims >= 3 && data &&
501  (unsigned)i0 < (unsigned)size.p[0] &&
502  (unsigned)i1 < (unsigned)size.p[1] &&
503  (unsigned)i2 < (unsigned)size.p[2] );
504  return (const _Tp*)(data + i0*step.p[0] + i1*step.p[1] + i2*step.p[2]);
505 }
506 
507 inline uchar* Mat::ptr(const int* idx)
508 {
509  int i, d = dims;
510  uchar* p = data;
511  CV_DbgAssert( d >= 1 && p );
512  for( i = 0; i < d; i++ )
513  {
514  CV_DbgAssert( (unsigned)idx[i] < (unsigned)size.p[i] );
515  p += idx[i]*step.p[i];
516  }
517  return p;
518 }
519 
520 inline const uchar* Mat::ptr(const int* idx) const
521 {
522  int i, d = dims;
523  uchar* p = data;
524  CV_DbgAssert( d >= 1 && p );
525  for( i = 0; i < d; i++ )
526  {
527  CV_DbgAssert( (unsigned)idx[i] < (unsigned)size.p[i] );
528  p += idx[i]*step.p[i];
529  }
530  return p;
531 }
532 
533 template<typename _Tp> inline _Tp& Mat::at(int i0, int i1)
534 {
535  CV_DbgAssert( dims <= 2 && data && (unsigned)i0 < (unsigned)size.p[0] &&
536  (unsigned)(i1*DataType<_Tp>::channels) < (unsigned)(size.p[1]*channels()) &&
537  CV_ELEM_SIZE1(DataType<_Tp>::depth) == elemSize1());
538  return ((_Tp*)(data + step.p[0]*i0))[i1];
539 }
540 
541 template<typename _Tp> inline const _Tp& Mat::at(int i0, int i1) const
542 {
543  CV_DbgAssert( dims <= 2 && data && (unsigned)i0 < (unsigned)size.p[0] &&
544  (unsigned)(i1*DataType<_Tp>::channels) < (unsigned)(size.p[1]*channels()) &&
545  CV_ELEM_SIZE1(DataType<_Tp>::depth) == elemSize1());
546  return ((const _Tp*)(data + step.p[0]*i0))[i1];
547 }
548 
549 template<typename _Tp> inline _Tp& Mat::at(Point pt)
550 {
551  CV_DbgAssert( dims <= 2 && data && (unsigned)pt.y < (unsigned)size.p[0] &&
552  (unsigned)(pt.x*DataType<_Tp>::channels) < (unsigned)(size.p[1]*channels()) &&
553  CV_ELEM_SIZE1(DataType<_Tp>::depth) == elemSize1());
554  return ((_Tp*)(data + step.p[0]*pt.y))[pt.x];
555 }
556 
557 template<typename _Tp> inline const _Tp& Mat::at(Point pt) const
558 {
559  CV_DbgAssert( dims <= 2 && data && (unsigned)pt.y < (unsigned)size.p[0] &&
560  (unsigned)(pt.x*DataType<_Tp>::channels) < (unsigned)(size.p[1]*channels()) &&
561  CV_ELEM_SIZE1(DataType<_Tp>::depth) == elemSize1());
562  return ((const _Tp*)(data + step.p[0]*pt.y))[pt.x];
563 }
564 
565 template<typename _Tp> inline _Tp& Mat::at(int i0)
566 {
567  CV_DbgAssert( dims <= 2 && data &&
568  (unsigned)i0 < (unsigned)(size.p[0]*size.p[1]) &&
569  elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
570  if( isContinuous() || size.p[0] == 1 )
571  return ((_Tp*)data)[i0];
572  if( size.p[1] == 1 )
573  return *(_Tp*)(data + step.p[0]*i0);
574  int i = i0/cols, j = i0 - i*cols;
575  return ((_Tp*)(data + step.p[0]*i))[j];
576 }
577 
578 template<typename _Tp> inline const _Tp& Mat::at(int i0) const
579 {
580  CV_DbgAssert( dims <= 2 && data &&
581  (unsigned)i0 < (unsigned)(size.p[0]*size.p[1]) &&
582  elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
583  if( isContinuous() || size.p[0] == 1 )
584  return ((const _Tp*)data)[i0];
585  if( size.p[1] == 1 )
586  return *(const _Tp*)(data + step.p[0]*i0);
587  int i = i0/cols, j = i0 - i*cols;
588  return ((const _Tp*)(data + step.p[0]*i))[j];
589 }
590 
591 template<typename _Tp> inline _Tp& Mat::at(int i0, int i1, int i2)
592 {
593  CV_DbgAssert( elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
594  return *(_Tp*)ptr(i0, i1, i2);
595 }
596 template<typename _Tp> inline const _Tp& Mat::at(int i0, int i1, int i2) const
597 {
598  CV_DbgAssert( elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
599  return *(const _Tp*)ptr(i0, i1, i2);
600 }
601 template<typename _Tp> inline _Tp& Mat::at(const int* idx)
602 {
603  CV_DbgAssert( elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
604  return *(_Tp*)ptr(idx);
605 }
606 template<typename _Tp> inline const _Tp& Mat::at(const int* idx) const
607 {
608  CV_DbgAssert( elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
609  return *(const _Tp*)ptr(idx);
610 }
611 template<typename _Tp, int n> _Tp& Mat::at(const Vec<int, n>& idx)
612 {
613  CV_DbgAssert( elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
614  return *(_Tp*)ptr(idx.val);
615 }
616 template<typename _Tp, int n> inline const _Tp& Mat::at(const Vec<int, n>& idx) const
617 {
618  CV_DbgAssert( elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
619  return *(const _Tp*)ptr(idx.val);
620 }
621 
622 
623 template<typename _Tp> inline MatConstIterator_<_Tp> Mat::begin() const
624 {
625  CV_DbgAssert( elemSize() == sizeof(_Tp) );
626  return MatConstIterator_<_Tp>((const Mat_<_Tp>*)this);
627 }
628 
629 template<typename _Tp> inline MatConstIterator_<_Tp> Mat::end() const
630 {
631  CV_DbgAssert( elemSize() == sizeof(_Tp) );
632  MatConstIterator_<_Tp> it((const Mat_<_Tp>*)this);
633  it += total();
634  return it;
635 }
636 
637 template<typename _Tp> inline MatIterator_<_Tp> Mat::begin()
638 {
639  CV_DbgAssert( elemSize() == sizeof(_Tp) );
640  return MatIterator_<_Tp>((Mat_<_Tp>*)this);
641 }
642 
643 template<typename _Tp> inline MatIterator_<_Tp> Mat::end()
644 {
645  CV_DbgAssert( elemSize() == sizeof(_Tp) );
646  MatIterator_<_Tp> it((Mat_<_Tp>*)this);
647  it += total();
648  return it;
649 }
650 
651 template<typename _Tp> inline Mat::operator vector<_Tp>() const
652 {
653  vector<_Tp> v;
654  copyTo(v);
655  return v;
656 }
657 
658 template<typename _Tp, int n> inline Mat::operator Vec<_Tp, n>() const
659 {
660  CV_Assert( data && dims <= 2 && (rows == 1 || cols == 1) &&
661  rows + cols - 1 == n && channels() == 1 );
662 
663  if( isContinuous() && type() == DataType<_Tp>::type )
664  return Vec<_Tp, n>((_Tp*)data);
666  convertTo(tmp, tmp.type());
667  return v;
668 }
669 
670 template<typename _Tp, int m, int n> inline Mat::operator Matx<_Tp, m, n>() const
671 {
672  CV_Assert( data && dims <= 2 && rows == m && cols == n && channels() == 1 );
673 
674  if( isContinuous() && type() == DataType<_Tp>::type )
675  return Matx<_Tp, m, n>((_Tp*)data);
677  convertTo(tmp, tmp.type());
678  return mtx;
679 }
680 
681 
682 template<typename _Tp> inline void Mat::push_back(const _Tp& elem)
683 {
684  if( !data )
685  {
686  *this = Mat(1, 1, DataType<_Tp>::type, (void*)&elem).clone();
687  return;
688  }
689  CV_Assert(DataType<_Tp>::type == type() && cols == 1
690  /* && dims == 2 (cols == 1 implies dims == 2) */);
691  uchar* tmp = dataend + step[0];
692  if( !isSubmatrix() && isContinuous() && tmp <= datalimit )
693  {
694  *(_Tp*)(data + (size.p[0]++)*step.p[0]) = elem;
695  dataend = tmp;
696  }
697  else
698  push_back_(&elem);
699 }
700 
701 template<typename _Tp> inline void Mat::push_back(const Mat_<_Tp>& m)
702 {
703  push_back((const Mat&)m);
704 }
705 
706 inline Mat::MSize::MSize(int* _p) : p(_p) {}
708 {
709  CV_DbgAssert(p[-1] <= 2);
710  return Size(p[1], p[0]);
711 }
712 inline const int& Mat::MSize::operator[](int i) const { return p[i]; }
713 inline int& Mat::MSize::operator[](int i) { return p[i]; }
714 inline Mat::MSize::operator const int*() const { return p; }
715 
716 inline bool Mat::MSize::operator == (const MSize& sz) const
717 {
718  int d = p[-1], dsz = sz.p[-1];
719  if( d != dsz )
720  return false;
721  if( d == 2 )
722  return p[0] == sz.p[0] && p[1] == sz.p[1];
723 
724  for( int i = 0; i < d; i++ )
725  if( p[i] != sz.p[i] )
726  return false;
727  return true;
728 }
729 
730 inline bool Mat::MSize::operator != (const MSize& sz) const
731 {
732  return !(*this == sz);
733 }
734 
735 inline Mat::MStep::MStep() { p = buf; p[0] = p[1] = 0; }
736 inline Mat::MStep::MStep(size_t s) { p = buf; p[0] = s; p[1] = 0; }
737 inline const size_t& Mat::MStep::operator[](int i) const { return p[i]; }
738 inline size_t& Mat::MStep::operator[](int i) { return p[i]; }
739 inline Mat::MStep::operator size_t() const
740 {
741  CV_DbgAssert( p == buf );
742  return buf[0];
743 }
745 {
746  CV_DbgAssert( p == buf );
747  buf[0] = s;
748  return *this;
749 }
750 
751 static inline Mat cvarrToMatND(const CvArr* arr, bool copyData=false, int coiMode=0)
752 {
753  return cvarrToMat(arr, copyData, true, coiMode);
754 }
755 
757 
758 inline SVD::SVD() {}
759 inline SVD::SVD( InputArray m, int flags ) { operator ()(m, flags); }
760 inline void SVD::solveZ( InputArray m, OutputArray _dst )
761 {
762  Mat mtx = m.getMat();
763  SVD svd(mtx, (mtx.rows >= mtx.cols ? 0 : SVD::FULL_UV));
764  _dst.create(svd.vt.cols, 1, svd.vt.type());
765  Mat dst = _dst.getMat();
766  svd.vt.row(svd.vt.rows-1).reshape(1,svd.vt.cols).copyTo(dst);
767 }
768 
769 template<typename _Tp, int m, int n, int nm> inline void
771 {
772  assert( nm == MIN(m, n));
773  Mat _a(a, false), _u(u, false), _w(w, false), _vt(vt, false);
774  SVD::compute(_a, _w, _u, _vt);
775  CV_Assert(_w.data == (uchar*)&w.val[0] && _u.data == (uchar*)&u.val[0] && _vt.data == (uchar*)&vt.val[0]);
776 }
777 
778 template<typename _Tp, int m, int n, int nm> inline void
780 {
781  assert( nm == MIN(m, n));
782  Mat _a(a, false), _w(w, false);
783  SVD::compute(_a, _w);
784  CV_Assert(_w.data == (uchar*)&w.val[0]);
785 }
786 
787 template<typename _Tp, int m, int n, int nm, int nb> inline void
789  const Matx<_Tp, n, nm>& vt, const Matx<_Tp, m, nb>& rhs,
791 {
792  assert( nm == MIN(m, n));
793  Mat _u(u, false), _w(w, false), _vt(vt, false), _rhs(rhs, false), _dst(dst, false);
794  SVD::backSubst(_w, _u, _vt, _rhs, _dst);
795  CV_Assert(_dst.data == (uchar*)&dst.val[0]);
796 }
797 
799 
800 template<typename _Tp> inline Mat_<_Tp>::Mat_()
801  : Mat() { flags = (flags & ~CV_MAT_TYPE_MASK) | DataType<_Tp>::type; }
802 
803 template<typename _Tp> inline Mat_<_Tp>::Mat_(int _rows, int _cols)
804  : Mat(_rows, _cols, DataType<_Tp>::type) {}
805 
806 template<typename _Tp> inline Mat_<_Tp>::Mat_(int _rows, int _cols, const _Tp& value)
807  : Mat(_rows, _cols, DataType<_Tp>::type) { *this = value; }
808 
809 template<typename _Tp> inline Mat_<_Tp>::Mat_(Size _sz)
810  : Mat(_sz.height, _sz.width, DataType<_Tp>::type) {}
811 
812 template<typename _Tp> inline Mat_<_Tp>::Mat_(Size _sz, const _Tp& value)
813  : Mat(_sz.height, _sz.width, DataType<_Tp>::type) { *this = value; }
814 
815 template<typename _Tp> inline Mat_<_Tp>::Mat_(int _dims, const int* _sz)
816  : Mat(_dims, _sz, DataType<_Tp>::type) {}
817 
818 template<typename _Tp> inline Mat_<_Tp>::Mat_(int _dims, const int* _sz, const _Tp& _s)
819  : Mat(_dims, _sz, DataType<_Tp>::type, Scalar(_s)) {}
820 
821 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_<_Tp>& m, const Range* ranges)
822  : Mat(m, ranges) {}
823 
824 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat& m)
825  : Mat() { flags = (flags & ~CV_MAT_TYPE_MASK) | DataType<_Tp>::type; *this = m; }
826 
827 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_& m)
828  : Mat(m) {}
829 
830 template<typename _Tp> inline Mat_<_Tp>::Mat_(int _rows, int _cols, _Tp* _data, size_t steps)
831  : Mat(_rows, _cols, DataType<_Tp>::type, _data, steps) {}
832 
833 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_& m, const Range& _rowRange, const Range& _colRange)
834  : Mat(m, _rowRange, _colRange) {}
835 
836 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_& m, const Rect& roi)
837  : Mat(m, roi) {}
838 
839 template<typename _Tp> template<int n> inline
840  Mat_<_Tp>::Mat_(const Vec<typename DataType<_Tp>::channel_type, n>& vec, bool copyData)
841  : Mat(n/DataType<_Tp>::channels, 1, DataType<_Tp>::type, (void*)&vec)
842 {
843  CV_Assert(n%DataType<_Tp>::channels == 0);
844  if( copyData )
845  *this = clone();
846 }
847 
848 template<typename _Tp> template<int m, int n> inline
849  Mat_<_Tp>::Mat_(const Matx<typename DataType<_Tp>::channel_type,m,n>& M, bool copyData)
850  : Mat(m, n/DataType<_Tp>::channels, DataType<_Tp>::type, (void*)&M)
851 {
852  CV_Assert(n % DataType<_Tp>::channels == 0);
853  if( copyData )
854  *this = clone();
855 }
856 
857 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Point_<typename DataType<_Tp>::channel_type>& pt, bool copyData)
858  : Mat(2/DataType<_Tp>::channels, 1, DataType<_Tp>::type, (void*)&pt)
859 {
860  CV_Assert(2 % DataType<_Tp>::channels == 0);
861  if( copyData )
862  *this = clone();
863 }
864 
865 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Point3_<typename DataType<_Tp>::channel_type>& pt, bool copyData)
866  : Mat(3/DataType<_Tp>::channels, 1, DataType<_Tp>::type, (void*)&pt)
867 {
868  CV_Assert(3 % DataType<_Tp>::channels == 0);
869  if( copyData )
870  *this = clone();
871 }
872 
873 template<typename _Tp> inline Mat_<_Tp>::Mat_(const MatCommaInitializer_<_Tp>& commaInitializer)
874  : Mat(commaInitializer) {}
875 
876 template<typename _Tp> inline Mat_<_Tp>::Mat_(const vector<_Tp>& vec, bool copyData)
877  : Mat(vec, copyData) {}
878 
879 template<typename _Tp> inline Mat_<_Tp>& Mat_<_Tp>::operator = (const Mat& m)
880 {
881  if( DataType<_Tp>::type == m.type() )
882  {
883  Mat::operator = (m);
884  return *this;
885  }
886  if( DataType<_Tp>::depth == m.depth() )
887  {
888  return (*this = m.reshape(DataType<_Tp>::channels, m.dims, 0));
889  }
890  CV_DbgAssert(DataType<_Tp>::channels == m.channels());
891  m.convertTo(*this, type());
892  return *this;
893 }
894 
895 template<typename _Tp> inline Mat_<_Tp>& Mat_<_Tp>::operator = (const Mat_& m)
896 {
897  Mat::operator=(m);
898  return *this;
899 }
900 
901 template<typename _Tp> inline Mat_<_Tp>& Mat_<_Tp>::operator = (const _Tp& s)
902 {
903  typedef typename DataType<_Tp>::vec_type VT;
904  Mat::operator=(Scalar((const VT&)s));
905  return *this;
906 }
907 
908 template<typename _Tp> inline void Mat_<_Tp>::create(int _rows, int _cols)
909 {
910  Mat::create(_rows, _cols, DataType<_Tp>::type);
911 }
912 
913 template<typename _Tp> inline void Mat_<_Tp>::create(Size _sz)
914 {
916 }
917 
918 template<typename _Tp> inline void Mat_<_Tp>::create(int _dims, const int* _sz)
919 {
920  Mat::create(_dims, _sz, DataType<_Tp>::type);
921 }
922 
923 
924 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::cross(const Mat_& m) const
925 { return Mat_<_Tp>(Mat::cross(m)); }
926 
927 template<typename _Tp> template<typename T2> inline Mat_<_Tp>::operator Mat_<T2>() const
928 { return Mat_<T2>(*this); }
929 
930 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::row(int y) const
931 { return Mat_(*this, Range(y, y+1), Range::all()); }
932 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::col(int x) const
933 { return Mat_(*this, Range::all(), Range(x, x+1)); }
934 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::diag(int d) const
935 { return Mat_(Mat::diag(d)); }
936 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::clone() const
937 { return Mat_(Mat::clone()); }
938 
939 template<typename _Tp> inline size_t Mat_<_Tp>::elemSize() const
940 {
941  CV_DbgAssert( Mat::elemSize() == sizeof(_Tp) );
942  return sizeof(_Tp);
943 }
944 
945 template<typename _Tp> inline size_t Mat_<_Tp>::elemSize1() const
946 {
947  CV_DbgAssert( Mat::elemSize1() == sizeof(_Tp)/DataType<_Tp>::channels );
948  return sizeof(_Tp)/DataType<_Tp>::channels;
949 }
950 template<typename _Tp> inline int Mat_<_Tp>::type() const
951 {
952  CV_DbgAssert( Mat::type() == DataType<_Tp>::type );
953  return DataType<_Tp>::type;
954 }
955 template<typename _Tp> inline int Mat_<_Tp>::depth() const
956 {
957  CV_DbgAssert( Mat::depth() == DataType<_Tp>::depth );
958  return DataType<_Tp>::depth;
959 }
960 template<typename _Tp> inline int Mat_<_Tp>::channels() const
961 {
962  CV_DbgAssert( Mat::channels() == DataType<_Tp>::channels );
964 }
965 template<typename _Tp> inline size_t Mat_<_Tp>::stepT(int i) const { return step.p[i]/elemSize(); }
966 template<typename _Tp> inline size_t Mat_<_Tp>::step1(int i) const { return step.p[i]/elemSize1(); }
967 
968 template<typename _Tp> inline Mat_<_Tp>& Mat_<_Tp>::adjustROI( int dtop, int dbottom, int dleft, int dright )
969 { return (Mat_<_Tp>&)(Mat::adjustROI(dtop, dbottom, dleft, dright)); }
970 
971 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::operator()( const Range& _rowRange, const Range& _colRange ) const
972 { return Mat_<_Tp>(*this, _rowRange, _colRange); }
973 
974 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::operator()( const Rect& roi ) const
975 { return Mat_<_Tp>(*this, roi); }
976 
977 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::operator()( const Range* ranges ) const
978 { return Mat_<_Tp>(*this, ranges); }
979 
980 template<typename _Tp> inline _Tp* Mat_<_Tp>::operator [](int y)
981 { return (_Tp*)ptr(y); }
982 template<typename _Tp> inline const _Tp* Mat_<_Tp>::operator [](int y) const
983 { return (const _Tp*)ptr(y); }
984 
985 template<typename _Tp> inline _Tp& Mat_<_Tp>::operator ()(int i0, int i1)
986 {
987  CV_DbgAssert( dims <= 2 && data &&
988  (unsigned)i0 < (unsigned)size.p[0] &&
989  (unsigned)i1 < (unsigned)size.p[1] &&
990  type() == DataType<_Tp>::type );
991  return ((_Tp*)(data + step.p[0]*i0))[i1];
992 }
993 
994 template<typename _Tp> inline const _Tp& Mat_<_Tp>::operator ()(int i0, int i1) const
995 {
996  CV_DbgAssert( dims <= 2 && data &&
997  (unsigned)i0 < (unsigned)size.p[0] &&
998  (unsigned)i1 < (unsigned)size.p[1] &&
999  type() == DataType<_Tp>::type );
1000  return ((const _Tp*)(data + step.p[0]*i0))[i1];
1001 }
1002 
1003 template<typename _Tp> inline _Tp& Mat_<_Tp>::operator ()(Point pt)
1004 {
1005  CV_DbgAssert( dims <= 2 && data &&
1006  (unsigned)pt.y < (unsigned)size.p[0] &&
1007  (unsigned)pt.x < (unsigned)size.p[1] &&
1008  type() == DataType<_Tp>::type );
1009  return ((_Tp*)(data + step.p[0]*pt.y))[pt.x];
1010 }
1011 
1012 template<typename _Tp> inline const _Tp& Mat_<_Tp>::operator ()(Point pt) const
1013 {
1014  CV_DbgAssert( dims <= 2 && data &&
1015  (unsigned)pt.y < (unsigned)size.p[0] &&
1016  (unsigned)pt.x < (unsigned)size.p[1] &&
1017  type() == DataType<_Tp>::type );
1018  return ((const _Tp*)(data + step.p[0]*pt.y))[pt.x];
1019 }
1020 
1021 template<typename _Tp> inline _Tp& Mat_<_Tp>::operator ()(const int* idx)
1022 {
1023  return Mat::at<_Tp>(idx);
1024 }
1025 
1026 template<typename _Tp> inline const _Tp& Mat_<_Tp>::operator ()(const int* idx) const
1027 {
1028  return Mat::at<_Tp>(idx);
1029 }
1030 
1031 template<typename _Tp> template<int n> inline _Tp& Mat_<_Tp>::operator ()(const Vec<int, n>& idx)
1032 {
1033  return Mat::at<_Tp>(idx);
1034 }
1035 
1036 template<typename _Tp> template<int n> inline const _Tp& Mat_<_Tp>::operator ()(const Vec<int, n>& idx) const
1037 {
1038  return Mat::at<_Tp>(idx);
1039 }
1040 
1041 template<typename _Tp> inline _Tp& Mat_<_Tp>::operator ()(int i0)
1042 {
1043  return this->at<_Tp>(i0);
1044 }
1045 
1046 template<typename _Tp> inline const _Tp& Mat_<_Tp>::operator ()(int i0) const
1047 {
1048  return this->at<_Tp>(i0);
1049 }
1050 
1051 template<typename _Tp> inline _Tp& Mat_<_Tp>::operator ()(int i0, int i1, int i2)
1052 {
1053  return this->at<_Tp>(i0, i1, i2);
1054 }
1055 
1056 template<typename _Tp> inline const _Tp& Mat_<_Tp>::operator ()(int i0, int i1, int i2) const
1057 {
1058  return this->at<_Tp>(i0, i1, i2);
1059 }
1060 
1061 
1062 template<typename _Tp> inline Mat_<_Tp>::operator vector<_Tp>() const
1063 {
1064  vector<_Tp> v;
1065  copyTo(v);
1066  return v;
1067 }
1068 
1069 template<typename _Tp> template<int n> inline Mat_<_Tp>::operator Vec<typename DataType<_Tp>::channel_type, n>() const
1070 {
1071  CV_Assert(n % DataType<_Tp>::channels == 0);
1072  return this->Mat::operator Vec<typename DataType<_Tp>::channel_type, n>();
1073 }
1074 
1075 template<typename _Tp> template<int m, int n> inline Mat_<_Tp>::operator Matx<typename DataType<_Tp>::channel_type, m, n>() const
1076 {
1077  CV_Assert(n % DataType<_Tp>::channels == 0);
1078 
1080  return res;
1081 }
1082 
1083 template<typename T1, typename T2, typename Op> inline void
1084 process( const Mat_<T1>& m1, Mat_<T2>& m2, Op op )
1085 {
1086  int y, x, rows = m1.rows, cols = m1.cols;
1087 
1088  CV_DbgAssert( m1.size() == m2.size() );
1089 
1090  for( y = 0; y < rows; y++ )
1091  {
1092  const T1* src = m1[y];
1093  T2* dst = m2[y];
1094 
1095  for( x = 0; x < cols; x++ )
1096  dst[x] = op(src[x]);
1097  }
1098 }
1099 
1100 template<typename T1, typename T2, typename T3, typename Op> inline void
1101 process( const Mat_<T1>& m1, const Mat_<T2>& m2, Mat_<T3>& m3, Op op )
1102 {
1103  int y, x, rows = m1.rows, cols = m1.cols;
1104 
1105  CV_DbgAssert( m1.size() == m2.size() );
1106 
1107  for( y = 0; y < rows; y++ )
1108  {
1109  const T1* src1 = m1[y];
1110  const T2* src2 = m2[y];
1111  T3* dst = m3[y];
1112 
1113  for( x = 0; x < cols; x++ )
1114  dst[x] = op( src1[x], src2[x] );
1115  }
1116 }
1117 
1118 
1120 
1121 template<typename _Tp> inline _InputArray::_InputArray(const vector<_Tp>& vec)
1122  : flags(FIXED_TYPE + STD_VECTOR + DataType<_Tp>::type), obj((void*)&vec) {}
1123 
1124 template<typename _Tp> inline _InputArray::_InputArray(const vector<vector<_Tp> >& vec)
1125  : flags(FIXED_TYPE + STD_VECTOR_VECTOR + DataType<_Tp>::type), obj((void*)&vec) {}
1126 
1127 template<typename _Tp> inline _InputArray::_InputArray(const vector<Mat_<_Tp> >& vec)
1128  : flags(FIXED_TYPE + STD_VECTOR_MAT + DataType<_Tp>::type), obj((void*)&vec) {}
1129 
1130 template<typename _Tp, int m, int n> inline _InputArray::_InputArray(const Matx<_Tp, m, n>& mtx)
1131  : flags(FIXED_TYPE + FIXED_SIZE + MATX + DataType<_Tp>::type), obj((void*)&mtx), sz(n, m) {}
1132 
1133 template<typename _Tp> inline _InputArray::_InputArray(const _Tp* vec, int n)
1134  : flags(FIXED_TYPE + FIXED_SIZE + MATX + DataType<_Tp>::type), obj((void*)vec), sz(n, 1) {}
1135 
1137  : flags(FIXED_TYPE + FIXED_SIZE + MATX + CV_64F), obj((void*)&s), sz(1, 4) {}
1138 
1139 template<typename _Tp> inline _InputArray::_InputArray(const Mat_<_Tp>& m)
1140  : flags(FIXED_TYPE + MAT + DataType<_Tp>::type), obj((void*)&m) {}
1141 
1142 template<typename _Tp> inline _OutputArray::_OutputArray(vector<_Tp>& vec)
1143  : _InputArray(vec) {}
1144 template<typename _Tp> inline _OutputArray::_OutputArray(vector<vector<_Tp> >& vec)
1145  : _InputArray(vec) {}
1146 template<typename _Tp> inline _OutputArray::_OutputArray(vector<Mat_<_Tp> >& vec)
1147  : _InputArray(vec) {}
1148 template<typename _Tp> inline _OutputArray::_OutputArray(Mat_<_Tp>& m)
1149  : _InputArray(m) {}
1150 template<typename _Tp, int m, int n> inline _OutputArray::_OutputArray(Matx<_Tp, m, n>& mtx)
1151  : _InputArray(mtx) {}
1152 template<typename _Tp> inline _OutputArray::_OutputArray(_Tp* vec, int n)
1153  : _InputArray(vec, n) {}
1154 
1155 template<typename _Tp> inline _OutputArray::_OutputArray(const vector<_Tp>& vec)
1156  : _InputArray(vec) {flags |= FIXED_SIZE;}
1157 template<typename _Tp> inline _OutputArray::_OutputArray(const vector<vector<_Tp> >& vec)
1158  : _InputArray(vec) {flags |= FIXED_SIZE;}
1159 template<typename _Tp> inline _OutputArray::_OutputArray(const vector<Mat_<_Tp> >& vec)
1160  : _InputArray(vec) {flags |= FIXED_SIZE;}
1161 
1162 template<typename _Tp> inline _OutputArray::_OutputArray(const Mat_<_Tp>& m)
1163  : _InputArray(m) {flags |= FIXED_SIZE;}
1164 template<typename _Tp, int m, int n> inline _OutputArray::_OutputArray(const Matx<_Tp, m, n>& mtx)
1165  : _InputArray(mtx) {}
1166 template<typename _Tp> inline _OutputArray::_OutputArray(const _Tp* vec, int n)
1167  : _InputArray(vec, n) {}
1168 
1170 
1171 class CV_EXPORTS MatOp
1172 {
1173 public:
1174  MatOp() {};
1175  virtual ~MatOp() {};
1176 
1177  virtual bool elementWise(const MatExpr& expr) const;
1178  virtual void assign(const MatExpr& expr, Mat& m, int type=-1) const = 0;
1179  virtual void roi(const MatExpr& expr, const Range& rowRange,
1180  const Range& colRange, MatExpr& res) const;
1181  virtual void diag(const MatExpr& expr, int d, MatExpr& res) const;
1182  virtual void augAssignAdd(const MatExpr& expr, Mat& m) const;
1183  virtual void augAssignSubtract(const MatExpr& expr, Mat& m) const;
1184  virtual void augAssignMultiply(const MatExpr& expr, Mat& m) const;
1185  virtual void augAssignDivide(const MatExpr& expr, Mat& m) const;
1186  virtual void augAssignAnd(const MatExpr& expr, Mat& m) const;
1187  virtual void augAssignOr(const MatExpr& expr, Mat& m) const;
1188  virtual void augAssignXor(const MatExpr& expr, Mat& m) const;
1189 
1190  virtual void add(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
1191  virtual void add(const MatExpr& expr1, const Scalar& s, MatExpr& res) const;
1192 
1193  virtual void subtract(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
1194  virtual void subtract(const Scalar& s, const MatExpr& expr, MatExpr& res) const;
1195 
1196  virtual void multiply(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res, double scale=1) const;
1197  virtual void multiply(const MatExpr& expr1, double s, MatExpr& res) const;
1198 
1199  virtual void divide(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res, double scale=1) const;
1200  virtual void divide(double s, const MatExpr& expr, MatExpr& res) const;
1201 
1202  virtual void abs(const MatExpr& expr, MatExpr& res) const;
1203 
1204  virtual void transpose(const MatExpr& expr, MatExpr& res) const;
1205  virtual void matmul(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
1206  virtual void invert(const MatExpr& expr, int method, MatExpr& res) const;
1207 
1208  virtual Size size(const MatExpr& expr) const;
1209  virtual int type(const MatExpr& expr) const;
1210 };
1211 
1212 
1213 class CV_EXPORTS MatExpr
1214 {
1215 public:
1216  MatExpr() : op(0), flags(0), a(Mat()), b(Mat()), c(Mat()), alpha(0), beta(0), s(Scalar()) {}
1217  MatExpr(const MatOp* _op, int _flags, const Mat& _a=Mat(), const Mat& _b=Mat(),
1218  const Mat& _c=Mat(), double _alpha=1, double _beta=1, const Scalar& _s=Scalar())
1219  : op(_op), flags(_flags), a(_a), b(_b), c(_c), alpha(_alpha), beta(_beta), s(_s) {}
1220  explicit MatExpr(const Mat& m);
1221  operator Mat() const
1222  {
1223  Mat m;
1224  op->assign(*this, m);
1225  return m;
1226  }
1227 
1228  template<typename _Tp> operator Mat_<_Tp>() const
1229  {
1230  Mat_<_Tp> m;
1231  op->assign(*this, m, DataType<_Tp>::type);
1232  return m;
1233  }
1234 
1235  MatExpr row(int y) const;
1236  MatExpr col(int x) const;
1237  MatExpr diag(int d=0) const;
1238  MatExpr operator()( const Range& rowRange, const Range& colRange ) const;
1239  MatExpr operator()( const Rect& roi ) const;
1240 
1241  Mat cross(const Mat& m) const;
1242  double dot(const Mat& m) const;
1243 
1244  MatExpr t() const;
1245  MatExpr inv(int method = DECOMP_LU) const;
1246  MatExpr mul(const MatExpr& e, double scale=1) const;
1247  MatExpr mul(const Mat& m, double scale=1) const;
1248 
1249  Size size() const;
1250  int type() const;
1251 
1252  const MatOp* op;
1253  int flags;
1254 
1255  Mat a, b, c;
1256  double alpha, beta;
1258 };
1259 
1260 
1261 CV_EXPORTS MatExpr operator + (const Mat& a, const Mat& b);
1262 CV_EXPORTS MatExpr operator + (const Mat& a, const Scalar& s);
1263 CV_EXPORTS MatExpr operator + (const Scalar& s, const Mat& a);
1264 CV_EXPORTS MatExpr operator + (const MatExpr& e, const Mat& m);
1265 CV_EXPORTS MatExpr operator + (const Mat& m, const MatExpr& e);
1266 CV_EXPORTS MatExpr operator + (const MatExpr& e, const Scalar& s);
1267 CV_EXPORTS MatExpr operator + (const Scalar& s, const MatExpr& e);
1268 CV_EXPORTS MatExpr operator + (const MatExpr& e1, const MatExpr& e2);
1269 
1270 CV_EXPORTS MatExpr operator - (const Mat& a, const Mat& b);
1271 CV_EXPORTS MatExpr operator - (const Mat& a, const Scalar& s);
1272 CV_EXPORTS MatExpr operator - (const Scalar& s, const Mat& a);
1273 CV_EXPORTS MatExpr operator - (const MatExpr& e, const Mat& m);
1274 CV_EXPORTS MatExpr operator - (const Mat& m, const MatExpr& e);
1275 CV_EXPORTS MatExpr operator - (const MatExpr& e, const Scalar& s);
1276 CV_EXPORTS MatExpr operator - (const Scalar& s, const MatExpr& e);
1277 CV_EXPORTS MatExpr operator - (const MatExpr& e1, const MatExpr& e2);
1278 
1279 CV_EXPORTS MatExpr operator - (const Mat& m);
1280 CV_EXPORTS MatExpr operator - (const MatExpr& e);
1281 
1282 CV_EXPORTS MatExpr operator * (const Mat& a, const Mat& b);
1283 CV_EXPORTS MatExpr operator * (const Mat& a, double s);
1284 CV_EXPORTS MatExpr operator * (double s, const Mat& a);
1285 CV_EXPORTS MatExpr operator * (const MatExpr& e, const Mat& m);
1286 CV_EXPORTS MatExpr operator * (const Mat& m, const MatExpr& e);
1287 CV_EXPORTS MatExpr operator * (const MatExpr& e, double s);
1288 CV_EXPORTS MatExpr operator * (double s, const MatExpr& e);
1289 CV_EXPORTS MatExpr operator * (const MatExpr& e1, const MatExpr& e2);
1290 
1291 CV_EXPORTS MatExpr operator / (const Mat& a, const Mat& b);
1292 CV_EXPORTS MatExpr operator / (const Mat& a, double s);
1293 CV_EXPORTS MatExpr operator / (double s, const Mat& a);
1294 CV_EXPORTS MatExpr operator / (const MatExpr& e, const Mat& m);
1295 CV_EXPORTS MatExpr operator / (const Mat& m, const MatExpr& e);
1296 CV_EXPORTS MatExpr operator / (const MatExpr& e, double s);
1297 CV_EXPORTS MatExpr operator / (double s, const MatExpr& e);
1298 CV_EXPORTS MatExpr operator / (const MatExpr& e1, const MatExpr& e2);
1299 
1300 CV_EXPORTS MatExpr operator < (const Mat& a, const Mat& b);
1301 CV_EXPORTS MatExpr operator < (const Mat& a, double s);
1302 CV_EXPORTS MatExpr operator < (double s, const Mat& a);
1303 
1304 CV_EXPORTS MatExpr operator <= (const Mat& a, const Mat& b);
1305 CV_EXPORTS MatExpr operator <= (const Mat& a, double s);
1306 CV_EXPORTS MatExpr operator <= (double s, const Mat& a);
1307 
1308 CV_EXPORTS MatExpr operator == (const Mat& a, const Mat& b);
1309 CV_EXPORTS MatExpr operator == (const Mat& a, double s);
1310 CV_EXPORTS MatExpr operator == (double s, const Mat& a);
1311 
1312 CV_EXPORTS MatExpr operator != (const Mat& a, const Mat& b);
1313 CV_EXPORTS MatExpr operator != (const Mat& a, double s);
1314 CV_EXPORTS MatExpr operator != (double s, const Mat& a);
1315 
1316 CV_EXPORTS MatExpr operator >= (const Mat& a, const Mat& b);
1317 CV_EXPORTS MatExpr operator >= (const Mat& a, double s);
1318 CV_EXPORTS MatExpr operator >= (double s, const Mat& a);
1319 
1320 CV_EXPORTS MatExpr operator > (const Mat& a, const Mat& b);
1321 CV_EXPORTS MatExpr operator > (const Mat& a, double s);
1322 CV_EXPORTS MatExpr operator > (double s, const Mat& a);
1323 
1324 CV_EXPORTS MatExpr min(const Mat& a, const Mat& b);
1325 CV_EXPORTS MatExpr min(const Mat& a, double s);
1326 CV_EXPORTS MatExpr min(double s, const Mat& a);
1327 
1328 CV_EXPORTS MatExpr max(const Mat& a, const Mat& b);
1329 CV_EXPORTS MatExpr max(const Mat& a, double s);
1330 CV_EXPORTS MatExpr max(double s, const Mat& a);
1331 
1332 template<typename _Tp> static inline MatExpr min(const Mat_<_Tp>& a, const Mat_<_Tp>& b)
1333 {
1334  return cv::min((const Mat&)a, (const Mat&)b);
1335 }
1336 
1337 template<typename _Tp> static inline MatExpr min(const Mat_<_Tp>& a, double s)
1338 {
1339  return cv::min((const Mat&)a, s);
1340 }
1341 
1342 template<typename _Tp> static inline MatExpr min(double s, const Mat_<_Tp>& a)
1343 {
1344  return cv::min((const Mat&)a, s);
1345 }
1346 
1347 template<typename _Tp> static inline MatExpr max(const Mat_<_Tp>& a, const Mat_<_Tp>& b)
1348 {
1349  return cv::max((const Mat&)a, (const Mat&)b);
1350 }
1351 
1352 template<typename _Tp> static inline MatExpr max(const Mat_<_Tp>& a, double s)
1353 {
1354  return cv::max((const Mat&)a, s);
1355 }
1356 
1357 template<typename _Tp> static inline MatExpr max(double s, const Mat_<_Tp>& a)
1358 {
1359  return cv::max((const Mat&)a, s);
1360 }
1361 
1362 template<typename _Tp> static inline void min(const Mat_<_Tp>& a, const Mat_<_Tp>& b, Mat_<_Tp>& c)
1363 {
1364  cv::min((const Mat&)a, (const Mat&)b, (Mat&)c);
1365 }
1366 
1367 template<typename _Tp> static inline void min(const Mat_<_Tp>& a, double s, Mat_<_Tp>& c)
1368 {
1369  cv::min((const Mat&)a, s, (Mat&)c);
1370 }
1371 
1372 template<typename _Tp> static inline void min(double s, const Mat_<_Tp>& a, Mat_<_Tp>& c)
1373 {
1374  cv::min((const Mat&)a, s, (Mat&)c);
1375 }
1376 
1377 template<typename _Tp> static inline void max(const Mat_<_Tp>& a, const Mat_<_Tp>& b, Mat_<_Tp>& c)
1378 {
1379  cv::max((const Mat&)a, (const Mat&)b, (Mat&)c);
1380 }
1381 
1382 template<typename _Tp> static inline void max(const Mat_<_Tp>& a, double s, Mat_<_Tp>& c)
1383 {
1384  cv::max((const Mat&)a, s, (Mat&)c);
1385 }
1386 
1387 template<typename _Tp> static inline void max(double s, const Mat_<_Tp>& a, Mat_<_Tp>& c)
1388 {
1389  cv::max((const Mat&)a, s, (Mat&)c);
1390 }
1391 
1392 
1393 CV_EXPORTS MatExpr operator & (const Mat& a, const Mat& b);
1394 CV_EXPORTS MatExpr operator & (const Mat& a, const Scalar& s);
1395 CV_EXPORTS MatExpr operator & (const Scalar& s, const Mat& a);
1396 
1397 CV_EXPORTS MatExpr operator | (const Mat& a, const Mat& b);
1398 CV_EXPORTS MatExpr operator | (const Mat& a, const Scalar& s);
1399 CV_EXPORTS MatExpr operator | (const Scalar& s, const Mat& a);
1400 
1401 CV_EXPORTS MatExpr operator ^ (const Mat& a, const Mat& b);
1402 CV_EXPORTS MatExpr operator ^ (const Mat& a, const Scalar& s);
1403 CV_EXPORTS MatExpr operator ^ (const Scalar& s, const Mat& a);
1404 
1405 CV_EXPORTS MatExpr operator ~(const Mat& m);
1406 
1407 CV_EXPORTS MatExpr abs(const Mat& m);
1408 CV_EXPORTS MatExpr abs(const MatExpr& e);
1409 
1410 template<typename _Tp> static inline MatExpr abs(const Mat_<_Tp>& m)
1411 {
1412  return cv::abs((const Mat&)m);
1413 }
1414 
1416 
1417 inline Mat& Mat::operator = (const MatExpr& e)
1418 {
1419  e.op->assign(e, *this);
1420  return *this;
1421 }
1422 
1423 template<typename _Tp> inline Mat_<_Tp>::Mat_(const MatExpr& e)
1424 {
1425  e.op->assign(e, *this, DataType<_Tp>::type);
1426 }
1427 
1428 template<typename _Tp> Mat_<_Tp>& Mat_<_Tp>::operator = (const MatExpr& e)
1429 {
1430  e.op->assign(e, *this, DataType<_Tp>::type);
1431  return *this;
1432 }
1433 
1434 static inline Mat& operator += (const Mat& a, const Mat& b)
1435 {
1436  add(a, b, (Mat&)a);
1437  return (Mat&)a;
1438 }
1439 
1440 static inline Mat& operator += (const Mat& a, const Scalar& s)
1441 {
1442  add(a, s, (Mat&)a);
1443  return (Mat&)a;
1444 }
1445 
1446 template<typename _Tp> static inline
1447 Mat_<_Tp>& operator += (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
1448 {
1449  add(a, b, (Mat&)a);
1450  return (Mat_<_Tp>&)a;
1451 }
1452 
1453 template<typename _Tp> static inline
1454 Mat_<_Tp>& operator += (const Mat_<_Tp>& a, const Scalar& s)
1455 {
1456  add(a, s, (Mat&)a);
1457  return (Mat_<_Tp>&)a;
1458 }
1459 
1460 static inline Mat& operator += (const Mat& a, const MatExpr& b)
1461 {
1462  b.op->augAssignAdd(b, (Mat&)a);
1463  return (Mat&)a;
1464 }
1465 
1466 template<typename _Tp> static inline
1467 Mat_<_Tp>& operator += (const Mat_<_Tp>& a, const MatExpr& b)
1468 {
1469  b.op->augAssignAdd(b, (Mat&)a);
1470  return (Mat_<_Tp>&)a;
1471 }
1472 
1473 static inline Mat& operator -= (const Mat& a, const Mat& b)
1474 {
1475  subtract(a, b, (Mat&)a);
1476  return (Mat&)a;
1477 }
1478 
1479 static inline Mat& operator -= (const Mat& a, const Scalar& s)
1480 {
1481  subtract(a, s, (Mat&)a);
1482  return (Mat&)a;
1483 }
1484 
1485 template<typename _Tp> static inline
1486 Mat_<_Tp>& operator -= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
1487 {
1488  subtract(a, b, (Mat&)a);
1489  return (Mat_<_Tp>&)a;
1490 }
1491 
1492 template<typename _Tp> static inline
1493 Mat_<_Tp>& operator -= (const Mat_<_Tp>& a, const Scalar& s)
1494 {
1495  subtract(a, s, (Mat&)a);
1496  return (Mat_<_Tp>&)a;
1497 }
1498 
1499 static inline Mat& operator -= (const Mat& a, const MatExpr& b)
1500 {
1501  b.op->augAssignSubtract(b, (Mat&)a);
1502  return (Mat&)a;
1503 }
1504 
1505 template<typename _Tp> static inline
1506 Mat_<_Tp>& operator -= (const Mat_<_Tp>& a, const MatExpr& b)
1507 {
1508  b.op->augAssignSubtract(b, (Mat&)a);
1509  return (Mat_<_Tp>&)a;
1510 }
1511 
1512 static inline Mat& operator *= (const Mat& a, const Mat& b)
1513 {
1514  gemm(a, b, 1, Mat(), 0, (Mat&)a, 0);
1515  return (Mat&)a;
1516 }
1517 
1518 static inline Mat& operator *= (const Mat& a, double s)
1519 {
1520  a.convertTo((Mat&)a, -1, s);
1521  return (Mat&)a;
1522 }
1523 
1524 template<typename _Tp> static inline
1525 Mat_<_Tp>& operator *= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
1526 {
1527  gemm(a, b, 1, Mat(), 0, (Mat&)a, 0);
1528  return (Mat_<_Tp>&)a;
1529 }
1530 
1531 template<typename _Tp> static inline
1532 Mat_<_Tp>& operator *= (const Mat_<_Tp>& a, double s)
1533 {
1534  a.convertTo((Mat&)a, -1, s);
1535  return (Mat_<_Tp>&)a;
1536 }
1537 
1538 static inline Mat& operator *= (const Mat& a, const MatExpr& b)
1539 {
1540  b.op->augAssignMultiply(b, (Mat&)a);
1541  return (Mat&)a;
1542 }
1543 
1544 template<typename _Tp> static inline
1545 Mat_<_Tp>& operator *= (const Mat_<_Tp>& a, const MatExpr& b)
1546 {
1547  b.op->augAssignMultiply(b, (Mat&)a);
1548  return (Mat_<_Tp>&)a;
1549 }
1550 
1551 static inline Mat& operator /= (const Mat& a, const Mat& b)
1552 {
1553  divide(a, b, (Mat&)a);
1554  return (Mat&)a;
1555 }
1556 
1557 static inline Mat& operator /= (const Mat& a, double s)
1558 {
1559  a.convertTo((Mat&)a, -1, 1./s);
1560  return (Mat&)a;
1561 }
1562 
1563 template<typename _Tp> static inline
1564 Mat_<_Tp>& operator /= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
1565 {
1566  divide(a, b, (Mat&)a);
1567  return (Mat_<_Tp>&)a;
1568 }
1569 
1570 template<typename _Tp> static inline
1571 Mat_<_Tp>& operator /= (const Mat_<_Tp>& a, double s)
1572 {
1573  a.convertTo((Mat&)a, -1, 1./s);
1574  return (Mat_<_Tp>&)a;
1575 }
1576 
1577 static inline Mat& operator /= (const Mat& a, const MatExpr& b)
1578 {
1579  b.op->augAssignDivide(b, (Mat&)a);
1580  return (Mat&)a;
1581 }
1582 
1583 template<typename _Tp> static inline
1584 Mat_<_Tp>& operator /= (const Mat_<_Tp>& a, const MatExpr& b)
1585 {
1586  b.op->augAssignDivide(b, (Mat&)a);
1587  return (Mat_<_Tp>&)a;
1588 }
1589 
1591 
1592 static inline Mat& operator &= (const Mat& a, const Mat& b)
1593 {
1594  bitwise_and(a, b, (Mat&)a);
1595  return (Mat&)a;
1596 }
1597 
1598 static inline Mat& operator &= (const Mat& a, const Scalar& s)
1599 {
1600  bitwise_and(a, s, (Mat&)a);
1601  return (Mat&)a;
1602 }
1603 
1604 template<typename _Tp> static inline Mat_<_Tp>&
1605 operator &= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
1606 {
1607  bitwise_and(a, b, (Mat&)a);
1608  return (Mat_<_Tp>&)a;
1609 }
1610 
1611 template<typename _Tp> static inline Mat_<_Tp>&
1612 operator &= (const Mat_<_Tp>& a, const Scalar& s)
1613 {
1614  bitwise_and(a, s, (Mat&)a);
1615  return (Mat_<_Tp>&)a;
1616 }
1617 
1618 static inline Mat& operator |= (const Mat& a, const Mat& b)
1619 {
1620  bitwise_or(a, b, (Mat&)a);
1621  return (Mat&)a;
1622 }
1623 
1624 static inline Mat& operator |= (const Mat& a, const Scalar& s)
1625 {
1626  bitwise_or(a, s, (Mat&)a);
1627  return (Mat&)a;
1628 }
1629 
1630 template<typename _Tp> static inline Mat_<_Tp>&
1631 operator |= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
1632 {
1633  bitwise_or(a, b, (Mat&)a);
1634  return (Mat_<_Tp>&)a;
1635 }
1636 
1637 template<typename _Tp> static inline Mat_<_Tp>&
1638 operator |= (const Mat_<_Tp>& a, const Scalar& s)
1639 {
1640  bitwise_or(a, s, (Mat&)a);
1641  return (Mat_<_Tp>&)a;
1642 }
1643 
1644 static inline Mat& operator ^= (const Mat& a, const Mat& b)
1645 {
1646  bitwise_xor(a, b, (Mat&)a);
1647  return (Mat&)a;
1648 }
1649 
1650 static inline Mat& operator ^= (const Mat& a, const Scalar& s)
1651 {
1652  bitwise_xor(a, s, (Mat&)a);
1653  return (Mat&)a;
1654 }
1655 
1656 template<typename _Tp> static inline Mat_<_Tp>&
1657 operator ^= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
1658 {
1659  bitwise_xor(a, b, (Mat&)a);
1660  return (Mat_<_Tp>&)a;
1661 }
1662 
1663 template<typename _Tp> static inline Mat_<_Tp>&
1664 operator ^= (const Mat_<_Tp>& a, const Scalar& s)
1665 {
1666  bitwise_xor(a, s, (Mat&)a);
1667  return (Mat_<_Tp>&)a;
1668 }
1669 
1671 
1672 template<typename _Tp> void split(const Mat& src, vector<Mat_<_Tp> >& mv)
1673 { split(src, (vector<Mat>&)mv ); }
1674 
1676 
1677 template<typename _Tp> inline MatExpr Mat_<_Tp>::zeros(int rows, int cols)
1678 {
1679  return Mat::zeros(rows, cols, DataType<_Tp>::type);
1680 }
1681 
1682 template<typename _Tp> inline MatExpr Mat_<_Tp>::zeros(Size sz)
1683 {
1684  return Mat::zeros(sz, DataType<_Tp>::type);
1685 }
1686 
1687 template<typename _Tp> inline MatExpr Mat_<_Tp>::ones(int rows, int cols)
1688 {
1689  return Mat::ones(rows, cols, DataType<_Tp>::type);
1690 }
1691 
1692 template<typename _Tp> inline MatExpr Mat_<_Tp>::ones(Size sz)
1693 {
1694  return Mat::ones(sz, DataType<_Tp>::type);
1695 }
1696 
1697 template<typename _Tp> inline MatExpr Mat_<_Tp>::eye(int rows, int cols)
1698 {
1699  return Mat::eye(rows, cols, DataType<_Tp>::type);
1700 }
1701 
1702 template<typename _Tp> inline MatExpr Mat_<_Tp>::eye(Size sz)
1703 {
1704  return Mat::eye(sz, DataType<_Tp>::type);
1705 }
1706 
1708 
1710  : m(0), elemSize(0), ptr(0), sliceStart(0), sliceEnd(0) {}
1711 
1713  : m(_m), elemSize(_m->elemSize()), ptr(0), sliceStart(0), sliceEnd(0)
1714 {
1715  if( m && m->isContinuous() )
1716  {
1717  sliceStart = m->data;
1718  sliceEnd = sliceStart + m->total()*elemSize;
1719  }
1720  seek((const int*)0);
1721 }
1722 
1723 inline MatConstIterator::MatConstIterator(const Mat* _m, int _row, int _col)
1724  : m(_m), elemSize(_m->elemSize()), ptr(0), sliceStart(0), sliceEnd(0)
1725 {
1726  CV_Assert(m && m->dims <= 2);
1727  if( m->isContinuous() )
1728  {
1729  sliceStart = m->data;
1730  sliceEnd = sliceStart + m->total()*elemSize;
1731  }
1732  int idx[]={_row, _col};
1733  seek(idx);
1734 }
1735 
1737  : m(_m), elemSize(_m->elemSize()), ptr(0), sliceStart(0), sliceEnd(0)
1738 {
1739  CV_Assert(m && m->dims <= 2);
1740  if( m->isContinuous() )
1741  {
1742  sliceStart = m->data;
1743  sliceEnd = sliceStart + m->total()*elemSize;
1744  }
1745  int idx[]={_pt.y, _pt.x};
1746  seek(idx);
1747 }
1748 
1750  : m(it.m), elemSize(it.elemSize), ptr(it.ptr), sliceStart(it.sliceStart), sliceEnd(it.sliceEnd)
1751 {}
1752 
1754 {
1755  m = it.m; elemSize = it.elemSize; ptr = it.ptr;
1757  return *this;
1758 }
1759 
1760 inline uchar* MatConstIterator::operator *() const { return ptr; }
1761 
1763 {
1764  if( !m || ofs == 0 )
1765  return *this;
1766  ptrdiff_t ofsb = ofs*elemSize;
1767  ptr += ofsb;
1768  if( ptr < sliceStart || sliceEnd <= ptr )
1769  {
1770  ptr -= ofsb;
1771  seek(ofs, true);
1772  }
1773  return *this;
1774 }
1775 
1777 { return (*this += -ofs); }
1778 
1780 {
1781  if( m && (ptr -= elemSize) < sliceStart )
1782  {
1783  ptr += elemSize;
1784  seek(-1, true);
1785  }
1786  return *this;
1787 }
1788 
1790 {
1791  MatConstIterator b = *this;
1792  *this += -1;
1793  return b;
1794 }
1795 
1797 {
1798  if( m && (ptr += elemSize) >= sliceEnd )
1799  {
1800  ptr -= elemSize;
1801  seek(1, true);
1802  }
1803  return *this;
1804 }
1805 
1807 {
1808  MatConstIterator b = *this;
1809  *this += 1;
1810  return b;
1811 }
1812 
1813 template<typename _Tp> inline MatConstIterator_<_Tp>::MatConstIterator_() {}
1814 
1815 template<typename _Tp> inline MatConstIterator_<_Tp>::MatConstIterator_(const Mat_<_Tp>* _m)
1816  : MatConstIterator(_m) {}
1817 
1818 template<typename _Tp> inline MatConstIterator_<_Tp>::
1819  MatConstIterator_(const Mat_<_Tp>* _m, int _row, int _col)
1820  : MatConstIterator(_m, _row, _col) {}
1821 
1822 template<typename _Tp> inline MatConstIterator_<_Tp>::
1824  : MatConstIterator(_m, _pt) {}
1825 
1826 template<typename _Tp> inline MatConstIterator_<_Tp>::
1828  : MatConstIterator(it) {}
1829 
1830 template<typename _Tp> inline MatConstIterator_<_Tp>&
1832 {
1834  return *this;
1835 }
1836 
1837 template<typename _Tp> inline _Tp MatConstIterator_<_Tp>::operator *() const { return *(_Tp*)(this->ptr); }
1838 
1839 template<typename _Tp> inline MatConstIterator_<_Tp>& MatConstIterator_<_Tp>::operator += (ptrdiff_t ofs)
1840 {
1842  return *this;
1843 }
1844 
1845 template<typename _Tp> inline MatConstIterator_<_Tp>& MatConstIterator_<_Tp>::operator -= (ptrdiff_t ofs)
1846 { return (*this += -ofs); }
1847 
1849 {
1851  return *this;
1852 }
1853 
1855 {
1856  MatConstIterator_ b = *this;
1858  return b;
1859 }
1860 
1862 {
1864  return *this;
1865 }
1866 
1868 {
1869  MatConstIterator_ b = *this;
1871  return b;
1872 }
1873 
1874 template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_() : MatConstIterator_<_Tp>() {}
1875 
1876 template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(Mat_<_Tp>* _m)
1877  : MatConstIterator_<_Tp>(_m) {}
1878 
1879 template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(Mat_<_Tp>* _m, int _row, int _col)
1880  : MatConstIterator_<_Tp>(_m, _row, _col) {}
1881 
1882 template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(const Mat_<_Tp>* _m, Point _pt)
1883  : MatConstIterator_<_Tp>(_m, _pt) {}
1884 
1885 template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(const Mat_<_Tp>* _m, const int* _idx)
1886  : MatConstIterator_<_Tp>(_m, _idx) {}
1887 
1888 template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(const MatIterator_& it)
1889  : MatConstIterator_<_Tp>(it) {}
1890 
1891 template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator = (const MatIterator_<_Tp>& it )
1892 {
1894  return *this;
1895 }
1896 
1897 template<typename _Tp> inline _Tp& MatIterator_<_Tp>::operator *() const { return *(_Tp*)(this->ptr); }
1898 
1899 template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator += (ptrdiff_t ofs)
1900 {
1902  return *this;
1903 }
1904 
1905 template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator -= (ptrdiff_t ofs)
1906 {
1908  return *this;
1909 }
1910 
1911 template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator --()
1912 {
1914  return *this;
1915 }
1916 
1917 template<typename _Tp> inline MatIterator_<_Tp> MatIterator_<_Tp>::operator --(int)
1918 {
1919  MatIterator_ b = *this;
1921  return b;
1922 }
1923 
1924 template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator ++()
1925 {
1927  return *this;
1928 }
1929 
1930 template<typename _Tp> inline MatIterator_<_Tp> MatIterator_<_Tp>::operator ++(int)
1931 {
1932  MatIterator_ b = *this;
1934  return b;
1935 }
1936 
1937 template<typename _Tp> inline Point MatConstIterator_<_Tp>::pos() const
1938 {
1939  if( !m )
1940  return Point();
1941  CV_DbgAssert( m->dims <= 2 );
1942  if( m->isContinuous() )
1943  {
1944  ptrdiff_t ofs = (const _Tp*)ptr - (const _Tp*)m->data;
1945  int y = (int)(ofs / m->cols), x = (int)(ofs - (ptrdiff_t)y*m->cols);
1946  return Point(x, y);
1947  }
1948  else
1949  {
1950  ptrdiff_t ofs = (uchar*)ptr - m->data;
1951  int y = (int)(ofs / m->step), x = (int)((ofs - y*m->step)/sizeof(_Tp));
1952  return Point(x, y);
1953  }
1954 }
1955 
1956 static inline bool
1958 { return a.m == b.m && a.ptr == b.ptr; }
1959 
1960 template<typename _Tp> static inline bool
1962 { return !(a == b); }
1963 
1964 template<typename _Tp> static inline bool
1965 operator == (const MatConstIterator_<_Tp>& a, const MatConstIterator_<_Tp>& b)
1966 { return a.m == b.m && a.ptr == b.ptr; }
1967 
1968 template<typename _Tp> static inline bool
1969 operator != (const MatConstIterator_<_Tp>& a, const MatConstIterator_<_Tp>& b)
1970 { return a.m != b.m || a.ptr != b.ptr; }
1971 
1972 template<typename _Tp> static inline bool
1973 operator == (const MatIterator_<_Tp>& a, const MatIterator_<_Tp>& b)
1974 { return a.m == b.m && a.ptr == b.ptr; }
1975 
1976 template<typename _Tp> static inline bool
1977 operator != (const MatIterator_<_Tp>& a, const MatIterator_<_Tp>& b)
1978 { return a.m != b.m || a.ptr != b.ptr; }
1979 
1980 static inline bool
1981 operator < (const MatConstIterator& a, const MatConstIterator& b)
1982 { return a.ptr < b.ptr; }
1983 
1984 static inline bool
1985 operator > (const MatConstIterator& a, const MatConstIterator& b)
1986 { return a.ptr > b.ptr; }
1987 
1988 static inline bool
1990 { return a.ptr <= b.ptr; }
1991 
1992 static inline bool
1994 { return a.ptr >= b.ptr; }
1995 
1996 CV_EXPORTS ptrdiff_t operator - (const MatConstIterator& b, const MatConstIterator& a);
1997 
1998 static inline MatConstIterator operator + (const MatConstIterator& a, ptrdiff_t ofs)
1999 { MatConstIterator b = a; return b += ofs; }
2000 
2001 static inline MatConstIterator operator + (ptrdiff_t ofs, const MatConstIterator& a)
2002 { MatConstIterator b = a; return b += ofs; }
2003 
2004 static inline MatConstIterator operator - (const MatConstIterator& a, ptrdiff_t ofs)
2005 { MatConstIterator b = a; return b += -ofs; }
2006 
2007 template<typename _Tp> static inline MatConstIterator_<_Tp>
2008 operator + (const MatConstIterator_<_Tp>& a, ptrdiff_t ofs)
2009 { MatConstIterator t = (const MatConstIterator&)a + ofs; return (MatConstIterator_<_Tp>&)t; }
2010 
2011 template<typename _Tp> static inline MatConstIterator_<_Tp>
2012 operator + (ptrdiff_t ofs, const MatConstIterator_<_Tp>& a)
2013 { MatConstIterator t = (const MatConstIterator&)a + ofs; return (MatConstIterator_<_Tp>&)t; }
2014 
2015 template<typename _Tp> static inline MatConstIterator_<_Tp>
2016 operator - (const MatConstIterator_<_Tp>& a, ptrdiff_t ofs)
2017 { MatConstIterator t = (const MatConstIterator&)a - ofs; return (MatConstIterator_<_Tp>&)t; }
2018 
2019 inline uchar* MatConstIterator::operator [](ptrdiff_t i) const
2020 { return *(*this + i); }
2021 
2022 template<typename _Tp> inline _Tp MatConstIterator_<_Tp>::operator [](ptrdiff_t i) const
2023 { return *(_Tp*)MatConstIterator::operator [](i); }
2024 
2025 template<typename _Tp> static inline MatIterator_<_Tp>
2026 operator + (const MatIterator_<_Tp>& a, ptrdiff_t ofs)
2027 { MatConstIterator t = (const MatConstIterator&)a + ofs; return (MatIterator_<_Tp>&)t; }
2028 
2029 template<typename _Tp> static inline MatIterator_<_Tp>
2030 operator + (ptrdiff_t ofs, const MatIterator_<_Tp>& a)
2031 { MatConstIterator t = (const MatConstIterator&)a + ofs; return (MatIterator_<_Tp>&)t; }
2032 
2033 template<typename _Tp> static inline MatIterator_<_Tp>
2034 operator - (const MatIterator_<_Tp>& a, ptrdiff_t ofs)
2035 { MatConstIterator t = (const MatConstIterator&)a - ofs; return (MatIterator_<_Tp>&)t; }
2036 
2037 template<typename _Tp> inline _Tp& MatIterator_<_Tp>::operator [](ptrdiff_t i) const
2038 { return *(*this + i); }
2039 
2040 template<typename _Tp> inline MatConstIterator_<_Tp> Mat_<_Tp>::begin() const
2041 { return Mat::begin<_Tp>(); }
2042 
2043 template<typename _Tp> inline MatConstIterator_<_Tp> Mat_<_Tp>::end() const
2044 { return Mat::end<_Tp>(); }
2045 
2046 template<typename _Tp> inline MatIterator_<_Tp> Mat_<_Tp>::begin()
2047 { return Mat::begin<_Tp>(); }
2048 
2049 template<typename _Tp> inline MatIterator_<_Tp> Mat_<_Tp>::end()
2050 { return Mat::end<_Tp>(); }
2051 
2052 template<typename _Tp> inline MatCommaInitializer_<_Tp>::MatCommaInitializer_(Mat_<_Tp>* _m) : it(_m) {}
2053 
2054 template<typename _Tp> template<typename T2> inline MatCommaInitializer_<_Tp>&
2056 {
2057  CV_DbgAssert( this->it < ((const Mat_<_Tp>*)this->it.m)->end() );
2058  *this->it = _Tp(v); ++this->it;
2059  return *this;
2060 }
2061 
2062 template<typename _Tp> inline Mat_<_Tp> MatCommaInitializer_<_Tp>::operator *() const
2063 {
2064  CV_DbgAssert( this->it == ((const Mat_<_Tp>*)this->it.m)->end() );
2065  return Mat_<_Tp>(*this->it.m);
2066 }
2067 
2068 template<typename _Tp> inline MatCommaInitializer_<_Tp>::operator Mat_<_Tp>() const
2069 {
2070  CV_DbgAssert( this->it == ((const Mat_<_Tp>*)this->it.m)->end() );
2071  return Mat_<_Tp>(*this->it.m);
2072 }
2073 
2074 template<typename _Tp, typename T2> static inline MatCommaInitializer_<_Tp>
2075 operator << (const Mat_<_Tp>& m, T2 val)
2076 {
2077  MatCommaInitializer_<_Tp> commaInitializer((Mat_<_Tp>*)&m);
2078  return (commaInitializer, val);
2079 }
2080 
2082 
2084 : flags(MAGIC_VAL), hdr(0)
2085 {
2086 }
2087 
2088 inline SparseMat::SparseMat(int _dims, const int* _sizes, int _type)
2089 : flags(MAGIC_VAL), hdr(0)
2090 {
2091  create(_dims, _sizes, _type);
2092 }
2093 
2095 : flags(m.flags), hdr(m.hdr)
2096 {
2097  addref();
2098 }
2099 
2101 {
2102  release();
2103 }
2104 
2106 {
2107  if( this != &m )
2108  {
2109  if( m.hdr )
2110  CV_XADD(&m.hdr->refcount, 1);
2111  release();
2112  flags = m.flags;
2113  hdr = m.hdr;
2114  }
2115  return *this;
2116 }
2117 
2119 { return (*this = SparseMat(m)); }
2120 
2122 {
2123  SparseMat temp;
2124  this->copyTo(temp);
2125  return temp;
2126 }
2127 
2128 
2129 inline void SparseMat::assignTo( SparseMat& m, int _type ) const
2130 {
2131  if( _type < 0 )
2132  m = *this;
2133  else
2134  convertTo(m, _type);
2135 }
2136 
2137 inline void SparseMat::addref()
2138 { if( hdr ) CV_XADD(&hdr->refcount, 1); }
2139 
2140 inline void SparseMat::release()
2141 {
2142  if( hdr && CV_XADD(&hdr->refcount, -1) == 1 )
2143  delete hdr;
2144  hdr = 0;
2145 }
2146 
2147 inline size_t SparseMat::elemSize() const
2148 { return CV_ELEM_SIZE(flags); }
2149 
2150 inline size_t SparseMat::elemSize1() const
2151 { return CV_ELEM_SIZE1(flags); }
2152 
2153 inline int SparseMat::type() const
2154 { return CV_MAT_TYPE(flags); }
2155 
2156 inline int SparseMat::depth() const
2157 { return CV_MAT_DEPTH(flags); }
2158 
2159 inline int SparseMat::channels() const
2160 { return CV_MAT_CN(flags); }
2161 
2162 inline const int* SparseMat::size() const
2163 {
2164  return hdr ? hdr->size : 0;
2165 }
2166 
2167 inline int SparseMat::size(int i) const
2168 {
2169  if( hdr )
2170  {
2171  CV_DbgAssert((unsigned)i < (unsigned)hdr->dims);
2172  return hdr->size[i];
2173  }
2174  return 0;
2175 }
2176 
2177 inline int SparseMat::dims() const
2178 {
2179  return hdr ? hdr->dims : 0;
2180 }
2181 
2182 inline size_t SparseMat::nzcount() const
2183 {
2184  return hdr ? hdr->nodeCount : 0;
2185 }
2186 
2187 inline size_t SparseMat::hash(int i0) const
2188 {
2189  return (size_t)i0;
2190 }
2191 
2192 inline size_t SparseMat::hash(int i0, int i1) const
2193 {
2194  return (size_t)(unsigned)i0*HASH_SCALE + (unsigned)i1;
2195 }
2196 
2197 inline size_t SparseMat::hash(int i0, int i1, int i2) const
2198 {
2199  return ((size_t)(unsigned)i0*HASH_SCALE + (unsigned)i1)*HASH_SCALE + (unsigned)i2;
2200 }
2201 
2202 inline size_t SparseMat::hash(const int* idx) const
2203 {
2204  size_t h = (unsigned)idx[0];
2205  if( !hdr )
2206  return 0;
2207  int i, d = hdr->dims;
2208  for( i = 1; i < d; i++ )
2209  h = h*HASH_SCALE + (unsigned)idx[i];
2210  return h;
2211 }
2212 
2213 template<typename _Tp> inline _Tp& SparseMat::ref(int i0, size_t* hashval)
2214 { return *(_Tp*)((SparseMat*)this)->ptr(i0, true, hashval); }
2215 
2216 template<typename _Tp> inline _Tp& SparseMat::ref(int i0, int i1, size_t* hashval)
2217 { return *(_Tp*)((SparseMat*)this)->ptr(i0, i1, true, hashval); }
2218 
2219 template<typename _Tp> inline _Tp& SparseMat::ref(int i0, int i1, int i2, size_t* hashval)
2220 { return *(_Tp*)((SparseMat*)this)->ptr(i0, i1, i2, true, hashval); }
2221 
2222 template<typename _Tp> inline _Tp& SparseMat::ref(const int* idx, size_t* hashval)
2223 { return *(_Tp*)((SparseMat*)this)->ptr(idx, true, hashval); }
2224 
2225 template<typename _Tp> inline _Tp SparseMat::value(int i0, size_t* hashval) const
2226 {
2227  const _Tp* p = (const _Tp*)((SparseMat*)this)->ptr(i0, false, hashval);
2228  return p ? *p : _Tp();
2229 }
2230 
2231 template<typename _Tp> inline _Tp SparseMat::value(int i0, int i1, size_t* hashval) const
2232 {
2233  const _Tp* p = (const _Tp*)((SparseMat*)this)->ptr(i0, i1, false, hashval);
2234  return p ? *p : _Tp();
2235 }
2236 
2237 template<typename _Tp> inline _Tp SparseMat::value(int i0, int i1, int i2, size_t* hashval) const
2238 {
2239  const _Tp* p = (const _Tp*)((SparseMat*)this)->ptr(i0, i1, i2, false, hashval);
2240  return p ? *p : _Tp();
2241 }
2242 
2243 template<typename _Tp> inline _Tp SparseMat::value(const int* idx, size_t* hashval) const
2244 {
2245  const _Tp* p = (const _Tp*)((SparseMat*)this)->ptr(idx, false, hashval);
2246  return p ? *p : _Tp();
2247 }
2248 
2249 template<typename _Tp> inline const _Tp* SparseMat::find(int i0, size_t* hashval) const
2250 { return (const _Tp*)((SparseMat*)this)->ptr(i0, false, hashval); }
2251 
2252 template<typename _Tp> inline const _Tp* SparseMat::find(int i0, int i1, size_t* hashval) const
2253 { return (const _Tp*)((SparseMat*)this)->ptr(i0, i1, false, hashval); }
2254 
2255 template<typename _Tp> inline const _Tp* SparseMat::find(int i0, int i1, int i2, size_t* hashval) const
2256 { return (const _Tp*)((SparseMat*)this)->ptr(i0, i1, i2, false, hashval); }
2257 
2258 template<typename _Tp> inline const _Tp* SparseMat::find(const int* idx, size_t* hashval) const
2259 { return (const _Tp*)((SparseMat*)this)->ptr(idx, false, hashval); }
2260 
2261 template<typename _Tp> inline _Tp& SparseMat::value(Node* n)
2262 { return *(_Tp*)((uchar*)n + hdr->valueOffset); }
2263 
2264 template<typename _Tp> inline const _Tp& SparseMat::value(const Node* n) const
2265 { return *(const _Tp*)((const uchar*)n + hdr->valueOffset); }
2266 
2267 inline SparseMat::Node* SparseMat::node(size_t nidx)
2268 { return (Node*)(void*)&hdr->pool[nidx]; }
2269 
2270 inline const SparseMat::Node* SparseMat::node(size_t nidx) const
2271 { return (const Node*)(void*)&hdr->pool[nidx]; }
2272 
2274 { return SparseMatIterator(this); }
2275 
2277 { return SparseMatConstIterator(this); }
2278 
2280 { SparseMatIterator it(this); it.seekEnd(); return it; }
2281 
2283 { SparseMatConstIterator it(this); it.seekEnd(); return it; }
2284 
2285 template<typename _Tp> inline SparseMatIterator_<_Tp> SparseMat::begin()
2286 { return SparseMatIterator_<_Tp>(this); }
2287 
2288 template<typename _Tp> inline SparseMatConstIterator_<_Tp> SparseMat::begin() const
2289 { return SparseMatConstIterator_<_Tp>(this); }
2290 
2291 template<typename _Tp> inline SparseMatIterator_<_Tp> SparseMat::end()
2292 { SparseMatIterator_<_Tp> it(this); it.seekEnd(); return it; }
2293 
2294 template<typename _Tp> inline SparseMatConstIterator_<_Tp> SparseMat::end() const
2295 { SparseMatConstIterator_<_Tp> it(this); it.seekEnd(); return it; }
2296 
2297 
2299 : m(0), hashidx(0), ptr(0)
2300 {
2301 }
2302 
2304 : m(it.m), hashidx(it.hashidx), ptr(it.ptr)
2305 {
2306 }
2307 
2308 static inline bool operator == (const SparseMatConstIterator& it1, const SparseMatConstIterator& it2)
2309 { return it1.m == it2.m && it1.ptr == it2.ptr; }
2310 
2311 static inline bool operator != (const SparseMatConstIterator& it1, const SparseMatConstIterator& it2)
2312 { return !(it1 == it2); }
2313 
2314 
2316 {
2317  if( this != &it )
2318  {
2319  m = it.m;
2320  hashidx = it.hashidx;
2321  ptr = it.ptr;
2322  }
2323  return *this;
2324 }
2325 
2326 template<typename _Tp> inline const _Tp& SparseMatConstIterator::value() const
2327 { return *(_Tp*)ptr; }
2328 
2330 {
2331  return ptr && m && m->hdr ?
2332  (const SparseMat::Node*)(void*)(ptr - m->hdr->valueOffset) : 0;
2333 }
2334 
2336 {
2337  SparseMatConstIterator it = *this;
2338  ++*this;
2339  return it;
2340 }
2341 
2342 
2344 {
2345  if( m && m->hdr )
2346  {
2347  hashidx = m->hdr->hashtab.size();
2348  ptr = 0;
2349  }
2350 }
2351 
2353 {}
2354 
2357 {}
2358 
2361 {
2362 }
2363 
2365 {
2366  (SparseMatConstIterator&)*this = it;
2367  return *this;
2368 }
2369 
2370 template<typename _Tp> inline _Tp& SparseMatIterator::value() const
2371 { return *(_Tp*)ptr; }
2372 
2374 {
2376 }
2377 
2379 {
2381  return *this;
2382 }
2383 
2385 {
2386  SparseMatIterator it = *this;
2387  ++*this;
2388  return it;
2389 }
2390 
2391 
2392 template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_()
2393 { flags = MAGIC_VAL | DataType<_Tp>::type; }
2394 
2395 template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(int _dims, const int* _sizes)
2396 : SparseMat(_dims, _sizes, DataType<_Tp>::type)
2397 {}
2398 
2399 template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const SparseMat& m)
2400 {
2401  if( m.type() == DataType<_Tp>::type )
2402  *this = (const SparseMat_<_Tp>&)m;
2403  else
2404  m.convertTo(*this, DataType<_Tp>::type);
2405 }
2406 
2407 template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const SparseMat_<_Tp>& m)
2408 {
2409  this->flags = m.flags;
2410  this->hdr = m.hdr;
2411  if( this->hdr )
2412  CV_XADD(&this->hdr->refcount, 1);
2413 }
2414 
2415 template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const Mat& m)
2416 {
2417  SparseMat sm(m);
2418  *this = sm;
2419 }
2420 
2421 template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const CvSparseMat* m)
2422 {
2423  SparseMat sm(m);
2424  *this = sm;
2425 }
2426 
2427 template<typename _Tp> inline SparseMat_<_Tp>&
2429 {
2430  if( this != &m )
2431  {
2432  if( m.hdr ) CV_XADD(&m.hdr->refcount, 1);
2433  release();
2434  flags = m.flags;
2435  hdr = m.hdr;
2436  }
2437  return *this;
2438 }
2439 
2440 template<typename _Tp> inline SparseMat_<_Tp>&
2442 {
2443  if( m.type() == DataType<_Tp>::type )
2444  return (*this = (const SparseMat_<_Tp>&)m);
2445  m.convertTo(*this, DataType<_Tp>::type);
2446  return *this;
2447 }
2448 
2449 template<typename _Tp> inline SparseMat_<_Tp>&
2451 { return (*this = SparseMat(m)); }
2452 
2453 template<typename _Tp> inline SparseMat_<_Tp>
2455 {
2456  SparseMat_<_Tp> m;
2457  this->copyTo(m);
2458  return m;
2459 }
2460 
2461 template<typename _Tp> inline void
2462 SparseMat_<_Tp>::create(int _dims, const int* _sizes)
2463 {
2464  SparseMat::create(_dims, _sizes, DataType<_Tp>::type);
2465 }
2466 
2467 template<typename _Tp> inline
2469 {
2470  return SparseMat::operator CvSparseMat*();
2471 }
2472 
2473 template<typename _Tp> inline int SparseMat_<_Tp>::type() const
2474 { return DataType<_Tp>::type; }
2475 
2476 template<typename _Tp> inline int SparseMat_<_Tp>::depth() const
2477 { return DataType<_Tp>::depth; }
2478 
2479 template<typename _Tp> inline int SparseMat_<_Tp>::channels() const
2480 { return DataType<_Tp>::channels; }
2481 
2482 template<typename _Tp> inline _Tp&
2483 SparseMat_<_Tp>::ref(int i0, size_t* hashval)
2484 { return SparseMat::ref<_Tp>(i0, hashval); }
2485 
2486 template<typename _Tp> inline _Tp
2487 SparseMat_<_Tp>::operator()(int i0, size_t* hashval) const
2488 { return SparseMat::value<_Tp>(i0, hashval); }
2489 
2490 template<typename _Tp> inline _Tp&
2491 SparseMat_<_Tp>::ref(int i0, int i1, size_t* hashval)
2492 { return SparseMat::ref<_Tp>(i0, i1, hashval); }
2493 
2494 template<typename _Tp> inline _Tp
2495 SparseMat_<_Tp>::operator()(int i0, int i1, size_t* hashval) const
2496 { return SparseMat::value<_Tp>(i0, i1, hashval); }
2497 
2498 template<typename _Tp> inline _Tp&
2499 SparseMat_<_Tp>::ref(int i0, int i1, int i2, size_t* hashval)
2500 { return SparseMat::ref<_Tp>(i0, i1, i2, hashval); }
2501 
2502 template<typename _Tp> inline _Tp
2503 SparseMat_<_Tp>::operator()(int i0, int i1, int i2, size_t* hashval) const
2504 { return SparseMat::value<_Tp>(i0, i1, i2, hashval); }
2505 
2506 template<typename _Tp> inline _Tp&
2507 SparseMat_<_Tp>::ref(const int* idx, size_t* hashval)
2508 { return SparseMat::ref<_Tp>(idx, hashval); }
2509 
2510 template<typename _Tp> inline _Tp
2511 SparseMat_<_Tp>::operator()(const int* idx, size_t* hashval) const
2512 { return SparseMat::value<_Tp>(idx, hashval); }
2513 
2514 template<typename _Tp> inline SparseMatIterator_<_Tp> SparseMat_<_Tp>::begin()
2515 { return SparseMatIterator_<_Tp>(this); }
2516 
2517 template<typename _Tp> inline SparseMatConstIterator_<_Tp> SparseMat_<_Tp>::begin() const
2518 { return SparseMatConstIterator_<_Tp>(this); }
2519 
2520 template<typename _Tp> inline SparseMatIterator_<_Tp> SparseMat_<_Tp>::end()
2521 { SparseMatIterator_<_Tp> it(this); it.seekEnd(); return it; }
2522 
2523 template<typename _Tp> inline SparseMatConstIterator_<_Tp> SparseMat_<_Tp>::end() const
2524 { SparseMatConstIterator_<_Tp> it(this); it.seekEnd(); return it; }
2525 
2526 template<typename _Tp> inline
2528 {}
2529 
2530 template<typename _Tp> inline
2533 {}
2534 
2535 template<typename _Tp> inline
2538 {
2539  CV_Assert( _m->type() == DataType<_Tp>::type );
2540 }
2541 
2542 template<typename _Tp> inline
2545 {}
2546 
2547 template<typename _Tp> inline SparseMatConstIterator_<_Tp>&
2549 { return reinterpret_cast<SparseMatConstIterator_<_Tp>&>
2550  (*reinterpret_cast<SparseMatConstIterator*>(this) =
2551  reinterpret_cast<const SparseMatConstIterator&>(it)); }
2552 
2553 template<typename _Tp> inline const _Tp&
2555 { return *(const _Tp*)this->ptr; }
2556 
2557 template<typename _Tp> inline SparseMatConstIterator_<_Tp>&
2559 {
2561  return *this;
2562 }
2563 
2564 template<typename _Tp> inline SparseMatConstIterator_<_Tp>
2566 {
2567  SparseMatConstIterator it = *this;
2569  return it;
2570 }
2571 
2572 template<typename _Tp> inline
2574 {}
2575 
2576 template<typename _Tp> inline
2578 : SparseMatConstIterator_<_Tp>(_m)
2579 {}
2580 
2581 template<typename _Tp> inline
2583 : SparseMatConstIterator_<_Tp>(_m)
2584 {}
2585 
2586 template<typename _Tp> inline
2588 : SparseMatConstIterator_<_Tp>(it)
2589 {}
2590 
2591 template<typename _Tp> inline SparseMatIterator_<_Tp>&
2593 { return reinterpret_cast<SparseMatIterator_<_Tp>&>
2594  (*reinterpret_cast<SparseMatConstIterator*>(this) =
2595  reinterpret_cast<const SparseMatConstIterator&>(it)); }
2596 
2597 template<typename _Tp> inline _Tp&
2599 { return *(_Tp*)this->ptr; }
2600 
2601 template<typename _Tp> inline SparseMatIterator_<_Tp>&
2603 {
2605  return *this;
2606 }
2607 
2608 template<typename _Tp> inline SparseMatIterator_<_Tp>
2610 {
2611  SparseMatIterator it = *this;
2613  return it;
2614 }
2615 
2616 }
2617 
2618 #endif
2619 #endif
int dims
Definition: core_c.h:218
Mat_ diag(int d=0) const
Definition: mat.hpp:934
CvArr CvPoint2D32f double M
Definition: imgproc_c.h:186
GLdouble GLdouble GLdouble r
MatAllocator * allocator
custom allocator
Definition: core.hpp:1976
Definition: core.hpp:1950
Point2i Point
Definition: core.hpp:893
static MatExpr ones(int rows, int cols, int type)
MatIterator_ & operator=(const MatIterator_< _Tp > &it)
copy operator
Definition: mat.hpp:1891
int rows
the number of rows and columns or (-1, -1) when the matrix has more than 2 dimensions ...
Definition: core.hpp:1962
MStep()
Definition: mat.hpp:735
CvPoint2D32f pt[4]
Definition: imgproc_c.h:410
int * p
Definition: core.hpp:1988
uchar * ptr(int i0=0)
returns pointer to i0-th submatrix along the dimension #0
Definition: mat.hpp:414
GLenum GLint GLint y
Definition: core_c.h:613
Mat_ clone() const
Definition: mat.hpp:936
bool empty() const
returns true if matrix data is NULL
Definition: mat.hpp:403
void create(int _rows, int _cols)
equivalent to Mat::create(_rows, _cols, DataType<_Tp>::type)
Definition: mat.hpp:908
MatIterator_ & operator--()
decrements the iterator
Definition: mat.hpp:1911
int depth() const
returns depth of the matrix elements
Definition: mat.hpp:2476
Mat reshape(int cn, int rows=0) const
creates alternative matrix header for the same data, with different
IplImage CvRect * roi
Definition: legacy.hpp:234
value_type channel_type
Definition: core.hpp:1011
const _Tp & operator*() const
the element access operator
Definition: mat.hpp:2554
CV_EXPORTS MatExpr operator~(const Mat &m)
MatExpr()
Definition: mat.hpp:1216
int CvScalar value
Definition: core_c.h:340
A short numerical vector.
Definition: core.hpp:84
_Tp y
Definition: core.hpp:805
Read-write Sparse Matrix Iterator.
Definition: core.hpp:3689
CV_EXPORTS MatExpr operator!=(const Mat &a, const Mat &b)
const void * elem
Definition: core_c.h:1075
SparseMatConstIterator_ & operator++()
moves iterator to the next element
Definition: mat.hpp:2558
int channels() const
Definition: mat.hpp:960
MatIterator_< _Tp > end()
Definition: mat.hpp:643
_Tp & operator*() const
returns the reference to the current element
Definition: mat.hpp:2598
SparseMat_()
the default constructor
Definition: mat.hpp:2392
static void solveZ(InputArray src, OutputArray dst)
finds dst = arg min_{|dst|=1} |m*dst|
Definition: mat.hpp:760
Matrix read-write iterator.
Definition: core.hpp:116
size_t elemSize1() const
returns the size of element channel in bytes.
Definition: mat.hpp:398
SparseMatIterator end()
return the sparse matrix iterator pointing to the element following the last sparse matrix element ...
Definition: mat.hpp:2279
bool isSubmatrix() const
returns true if the matrix is a submatrix of another matrix
Definition: mat.hpp:396
SparseMatIterator begin()
return the sparse matrix iterator pointing to the first sparse matrix element
Definition: mat.hpp:2273
_Tp z
Definition: core.hpp:805
bool operator==(const MSize &sz) const
Definition: mat.hpp:716
int channels() const
returns the number of channels in each matrix element
Definition: mat.hpp:2479
Mat clone() const
returns deep copy of the matrix, i.e. the data is copied
Definition: mat.hpp:332
MatConstIterator_ & operator-=(ptrdiff_t ofs)
shifts the iterator backward by the specified number of elements
Definition: mat.hpp:1845
MatConstIterator & operator++()
increments the iterator
Definition: mat.hpp:1796
CV_EXPORTS_W void bitwise_and(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
computes bitwise conjunction of the two arrays (dst = src1 & src2)
SparseMatIterator_()
the default constructor
Definition: mat.hpp:2573
SparseMat()
default constructor
Definition: mat.hpp:2083
Size2i Size
Definition: core.hpp:896
MatConstIterator & operator-=(ptrdiff_t ofs)
shifts the iterator backward by the specified number of elements
Definition: mat.hpp:1776
CV_EXPORTS_W double invert(InputArray src, OutputArray dst, int flags=DECOMP_LU)
computes inverse or pseudo-inverse matrix
int channels() const
returns element type, similar to CV_MAT_CN(cvmat->type)
Definition: mat.hpp:401
uchar * datalimit
Definition: core.hpp:1973
void create(int dims, const int *_sizes)
equivalent to cv::SparseMat::create(dims, _sizes, DataType<_Tp>::type)
Definition: mat.hpp:2462
class CV_EXPORTS MatConstIterator
Definition: core.hpp:113
uchar * data
pointer to the data
Definition: core.hpp:1964
CvPoint2D32f float float b
Definition: legacy.hpp:578
void copyTo(OutputArray m) const
copies the matrix content to "m".
const int * idx
Definition: core_c.h:323
Mat_ & adjustROI(int dtop, int dbottom, int dleft, int dright)
some more overriden methods
Definition: mat.hpp:968
int depth() const
Definition: mat.hpp:955
int type() const
Definition: mat.hpp:950
_Tp operator[](ptrdiff_t i) const
returns the i-th matrix element, relative to the current
Definition: mat.hpp:2022
void push_back(const _Tp &elem)
adds element to the end of 1d matrix (or possibly multiple elements when _Tp=Mat) ...
Definition: mat.hpp:682
static Range all()
Definition: operations.hpp:2219
const CvArr * src1
Definition: core_c.h:436
Mat c
Definition: mat.hpp:1255
void convertTo(OutputArray m, int rtype, double alpha=1, double beta=0) const
converts matrix to another datatype with optional scalng. See cvConvertScale.
SparseMatConstIterator_()
the default constructor
Definition: mat.hpp:2527
CvSize size
Definition: calib3d.hpp:212
void addref()
increases the reference counter; use with care to avoid memleaks
Definition: mat.hpp:361
The 2D range class.
Definition: core.hpp:979
GLenum GLsizei width
uchar * ptr(int i0, bool createMissing, size_t *hashval=0)
specialized variants for 1D, 2D, 3D cases and the generic_type one for n-D case.
static MatExpr eye(int rows, int cols, int type)
GLsizei GLsizei GLuint * obj
GLuint src
Definition: core_c.h:1650
CV_EXPORTS_W void divide(InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
computes element-wise weighted quotient of the two arrays (dst = scale*src1/src2) ...
int int int flags
Definition: highgui_c.h:186
~SparseMat()
the destructor
Definition: mat.hpp:2100
MatConstIterator()
default constructor
Definition: mat.hpp:1709
Definition: core.hpp:85
CV_EXPORTS_W void bitwise_or(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
computes bitwise disjunction of the two arrays (dst = src1 | src2)
GLsizei GLsizei GLenum GLenum const GLvoid * data
Definition: core_c.h:403
Definition: types_c.h:858
int d
Definition: legacy.hpp:3064
CV_EXPORTS MatExpr operator>(const Mat &a, const Mat &b)
_Tp x
Definition: core.hpp:766
MatConstIterator & operator--()
decrements the iterator
Definition: mat.hpp:1779
_Tp & ref(int i0, size_t *hashval=0)
return read-write reference to the specified sparse matrix element.
Definition: mat.hpp:2213
iterator end()
Definition: mat.hpp:2049
Hdr * hdr
Definition: core.hpp:3625
Definition: mat.hpp:1171
virtual void create(Size sz, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const
int depth() const
returns the depth of sparse matrix elements
Definition: mat.hpp:2156
int * refcount
pointer to the reference counter;
Definition: core.hpp:1968
void copySize(const Mat &m)
internal use function; properly re-allocates _size, _step arrays
CV_EXPORTS MatExpr operator-(const Mat &a, const Mat &b)
int depth() const
returns element type, similar to CV_MAT_DEPTH(cvmat->type)
Definition: mat.hpp:400
size_t elemSize() const
returns element size in bytes,
Definition: mat.hpp:397
internal::ParamGenerator< T > Range(T start, T end, IncrementT step)
Definition: ts_gtest.h:15869
uchar * sliceStart
Definition: core.hpp:2979
GLuint res
static void backSubst(InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst)
performs back substitution
size_t elemSize() const
overridden forms of Mat::elemSize() etc.
Definition: mat.hpp:939
int dims() const
returns the matrix dimensionality
Definition: mat.hpp:2177
int flags
Definition: mat.hpp:1253
void process(const Mat_< T1 > &m1, Mat_< T2 > &m2, Op op)
Definition: mat.hpp:1084
void int step
Definition: core_c.h:403
const CvArr CvArr int method
Definition: imgproc_c.h:281
SparseMat::Node * node() const
returns pointer to the current sparse matrix node. it.node->idx is the index of the current element (...
Definition: mat.hpp:2373
Proxy datatype for passing Mat's and vector<>'s as input parameters.
Definition: core.hpp:1312
double beta
Definition: mat.hpp:1256
uchar * datastart
helper fields used in locateROI and adjustROI
Definition: core.hpp:1971
CV_EXPORTS MatExpr operator^(const Mat &a, const Mat &b)
virtual void assign(const MatExpr &expr, Mat &m, int type=-1) const =0
SparseMat_ & operator=(const SparseMat &m)
the assignment operator. If DataType<_Tp>.type != m.type(), the m elements are converted ...
Definition: mat.hpp:2441
void assignTo(SparseMat &m, int type=-1) const
Definition: mat.hpp:2129
The 2D size class.
Definition: core.hpp:81
_Tp operator*() const
returns the current matrix element
Definition: mat.hpp:1837
Mat_ col(int x) const
Definition: mat.hpp:932
typedef void(CV_CDECL *CvMouseCallback)(int event
Definition: mat.hpp:1213
int cols
Definition: core.hpp:1962
Mat colRange(int startcol, int endcol) const
... for the specified column span
Definition: mat.hpp:315
int type() const
returns element type, similar to CV_MAT_TYPE(cvmat->type)
Definition: mat.hpp:399
void push_back_(const void *elem)
internal function
size_t elemSize
Definition: core.hpp:2977
static MatExpr zeros(int rows, int cols, int type)
Matlab-style matrix initialization.
int step
Definition: types_c.h:648
size_t nzcount() const
returns the number of non-zero elements (=the number of hash table nodes)
Definition: mat.hpp:2182
uchar * ptr
Definition: core.hpp:2978
Mat & adjustROI(int dtop, int dbottom, int dleft, int dright)
moves/resizes the current matrix ROI inside the parent matrix.
int channels() const
returns the number of channels
Definition: mat.hpp:2159
GLenum GLenum GLvoid * row
SparseMat & operator=(const SparseMat &m)
assignment operator. This is O(1) operation, i.e. no data is copied
Definition: mat.hpp:2105
size_t buf[2]
Definition: core.hpp:2001
~Mat()
destructor - calls release()
Definition: mat.hpp:274
size_t elemSize() const
returns the size of each element in bytes (not including the overhead - the space occupied by SparseM...
Definition: mat.hpp:2147
struct CvMat CvMat
Scalar s
Definition: mat.hpp:1257
void seekEnd()
moves iterator to the element after the last element
Definition: mat.hpp:2343
GLuint GLfloat * val
uchar * sliceEnd
Definition: core.hpp:2980
int refcount
Definition: core.hpp:3387
Mat()
default constructor
Definition: mat.hpp:67
int type
Definition: types_c.h:647
Definition: core.hpp:2499
SVD()
the default constructor
Definition: mat.hpp:758
MatIterator_< _Tp > begin()
template methods for iteration over matrix elements.
Definition: mat.hpp:637
template 3D point class.
Definition: core.hpp:777
SparseMatIterator()
the default constructor
Definition: mat.hpp:2352
const _Tp * find(int i0, size_t *hashval=0) const
Return pointer to the specified sparse matrix element if it exists.
Definition: mat.hpp:2249
int dims
Definition: core.hpp:3388
CV_EXPORTS void split(const Mat &src, Mat *mvbegin)
copies each plane of a multi-channel array to a dedicated array
SparseMatConstIterator_ & operator=(const SparseMatConstIterator_ &it)
the assignment operator
Definition: mat.hpp:2548
CV_EXPORTS MatExpr operator==(const Mat &a, const Mat &b)
GLenum GLsizei GLsizei height
GLclampf GLclampf GLclampf alpha
Definition: core_c.h:687
int flags
includes several bit-fields:
Definition: core.hpp:1958
size_t step1(int i=0) const
returns step/elemSize1()
Definition: mat.hpp:402
Definition: core.hpp:131
void copyTo(SparseMat &m) const
copies all the data to the destination matrix. All the previous content of m is erased ...
MatConstIterator_ & operator+=(ptrdiff_t ofs)
shifts the iterator forward by the specified number of elements
Definition: mat.hpp:1839
_Tp & operator*() const
returns the current matrix element
Definition: mat.hpp:1897
CV_EXPORTS_W void min(InputArray src1, InputArray src2, OutputArray dst)
computes per-element minimum of two arrays (dst = min(src1, src2))
SparseMat_ clone() const
makes full copy of the matrix. All the elements are duplicated
Definition: mat.hpp:2454
sparse matrix node - element of a hash table
Definition: core.hpp:3399
SparseMatIterator_< _Tp > end()
returns sparse matrix iterator pointing to the element following the last sparse matrix element ...
Definition: mat.hpp:2520
Definition: core.hpp:1950
Sparse matrix class.
Definition: core.hpp:3376
void convertTo(SparseMat &m, int rtype, double alpha=1) const
multiplies all the matrix elements by the specified scale factor alpha and converts the results to th...
MatExpr(const MatOp *_op, int _flags, const Mat &_a=Mat(), const Mat &_b=Mat(), const Mat &_c=Mat(), double _alpha=1, double _beta=1, const Scalar &_s=Scalar())
Definition: mat.hpp:1217
Definition: core.hpp:1991
void release()
Definition: mat.hpp:2140
GLenum GLint x
Definition: core_c.h:632
CV_EXPORTS_W void transpose(InputArray src, OutputArray dst)
transposes the matrix
void CvArr
Definition: types_c.h:196
void mul(const float *array, float scalar, float *result, size_t length)
CV_EXPORTS MatExpr abs(const Mat &m)
Comma-separated Matrix Initializer.
Definition: core.hpp:118
GLenum GLsizei n
const Mat * m
Definition: core.hpp:2976
MatIterator_ & operator-=(ptrdiff_t ofs)
shifts the iterator backward by the specified number of elements
Definition: mat.hpp:1905
Informative template class for OpenCV "scalars".
Definition: core.hpp:1006
MatConstIterator_ & operator++()
increments the iterator
Definition: mat.hpp:1861
size_t step1(int i=0) const
Definition: mat.hpp:966
Mat_ row(int y) const
overridden forms of Mat::row() etc.
Definition: mat.hpp:930
Mat rowRange(int startrow, int endrow) const
... for the specified row span
Definition: mat.hpp:311
int type() const
returns type of the matrix elements
Definition: mat.hpp:2473
uchar * ptr
Definition: core.hpp:3680
static MatExpr eye(int rows, int cols)
Definition: mat.hpp:1697
_Tp value(int i0, size_t *hashval=0) const
return value of the specified sparse matrix element.
Definition: mat.hpp:2225
CV_EXPORTS MatExpr operator<(const Mat &a, const Mat &b)
MatOp()
Definition: mat.hpp:1174
_Tp x
Definition: core.hpp:805
SparseMatIterator_ & operator++()
moves the iterator to the next element
Definition: mat.hpp:2602
const SparseMat * m
Definition: core.hpp:3678
Template Read-Only Sparse Matrix Iterator Class.
Definition: core.hpp:3289
Definition: types_c.h:645
const GLdouble * v
const int * size() const
returns the array of sizes, or NULL if the matrix is not allocated
Definition: mat.hpp:2162
Mat_ cross(const Mat_ &m) const
cross-product
Definition: mat.hpp:924
double const CvArr double beta
Definition: core_c.h:523
Mat & operator=(const Mat &m)
assignment operators
Definition: mat.hpp:281
MatIterator_ & operator+=(ptrdiff_t ofs)
shifts the iterator forward by the specified number of elements
Definition: mat.hpp:1899
MatConstIterator_ & operator=(const MatConstIterator_ &it)
copy operator
Definition: mat.hpp:1831
virtual Mat getMat(int i=-1) const
SparseMatIterator & operator++()
moves iterator to the next element
Definition: mat.hpp:2378
GLboolean GLboolean GLboolean b
Definition: legacy.hpp:633
static MatExpr ones(int rows, int cols)
Definition: mat.hpp:1687
The n-dimensional matrix class.
Definition: core.hpp:1688
static MatExpr zeros(int rows, int cols)
overridden forms of Mat::zeros() etc. Data type is omitted, of course
Definition: mat.hpp:1677
Singular Value Decomposition class.
Definition: core.hpp:2496
MatCommaInitializer_(Mat_< _Tp > *_m)
the constructor, created by "matrix << firstValue" operator, where matrix is cv::Mat ...
Definition: mat.hpp:2052
int rows
Definition: core_c.h:114
static void compute(InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags=0)
decomposes matrix and stores the results to user-provided matrices
Template matrix class derived from Mat.
Definition: core.hpp:115
Definition: core.hpp:2927
CV_EXPORTS_W void subtract(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
subtracts one matrix from another (dst = src1 - src2)
CV_EXPORTS_W void gemm(InputArray src1, InputArray src2, double alpha, InputArray src3, double gamma, OutputArray dst, int flags=0)
implements generalized matrix product algorithm GEMM from BLAS
int int y
Definition: highgui_c.h:186
Size operator()() const
Definition: mat.hpp:707
SparseMatIterator_ & operator=(const SparseMatIterator_ &it)
the assignment operator
Definition: mat.hpp:2592
GLsizei const GLfloat * value
Definition: core_c.h:341
void release()
decreases reference counter;
Definition: mat.hpp:364
const MatOp * op
Definition: mat.hpp:1252
int type() const
returns type of sparse matrix elements
Definition: mat.hpp:2153
size_t elemSize1() const
returns elemSize()/channels()
Definition: mat.hpp:2150
MatCommaInitializer_< _Tp > & operator,(T2 v)
the operator that takes the next value and put it to the matrix
Definition: mat.hpp:2055
CV_EXPORTS_W void bitwise_xor(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2)
int cols
Definition: core_c.h:109
Node * node(size_t nidx)
Definition: mat.hpp:2267
_Tp val[m *n]
Definition: core.hpp:544
The Template Sparse Matrix class derived from cv::SparseMat.
Definition: core.hpp:3727
GLfloat GLfloat p
GLuint GLuint GLsizei GLenum type
Definition: core_c.h:114
SparseMat clone() const
creates full copy of the matrix
Definition: mat.hpp:2121
Mat row(int y) const
returns a new matrix header for the specified row
Definition: mat.hpp:309
virtual ~MatOp()
Definition: mat.hpp:1175
const GLubyte * c
Definition: legacy.hpp:633
int int type
Definition: core_c.h:109
const SparseMat::Node * node() const
returns the current node of the sparse matrix. it.node->idx is the current element index ...
Definition: mat.hpp:2329
int int int int int int h
CV_EXPORTS MatExpr operator|(const Mat &a, const Mat &b)
float ** ranges
Definition: imgproc_c.h:435
size_t hashidx
Definition: core.hpp:3679
int int channels
Definition: core_c.h:73
int size[CV_MAX_DIM]
Definition: core.hpp:3395
SparseMatConstIterator & operator++()
moves iterator to the next element
template 2D point class.
Definition: core.hpp:82
_Tp & operator[](ptrdiff_t i) const
returns the i-th matrix element, relative to the current
Definition: mat.hpp:2037
CvPoint2D32f CvPoint2D32f CvPoint2D32f CvPoint2D32f * cross
Definition: legacy.hpp:577
SparseMatIterator_< _Tp > begin()
returns sparse matrix iterator pointing to the first sparse matrix element
Definition: mat.hpp:2514
SparseMatConstIterator()
the default constructor
Definition: mat.hpp:2298
_Tp width
Definition: core.hpp:840
MSize(int *_p)
Definition: mat.hpp:706
_Tp & value() const
returns read-write reference to the current sparse matrix element
Definition: mat.hpp:2370
Definition: core.hpp:1318
size_t elemSize1() const
Definition: mat.hpp:945
Read-Only Sparse Matrix Iterator.
Definition: core.hpp:3648
CV_EXPORTS MatExpr operator<=(const Mat &a, const Mat &b)
const char * ptr
Definition: core_c.h:942
CV_EXPORTS MatExpr operator/(const Mat &a, const Mat &b)
GLboolean GLboolean GLboolean GLboolean a
Definition: legacy.hpp:633
CV_EXPORTS void fastFree(void *ptr)
Frees the memory allocated with cv::fastMalloc.
class CV_EXPORTS MatExpr
Definition: core.hpp:110
MatConstIterator & operator+=(ptrdiff_t ofs)
shifts the iterator forward by the specified number of elements
Definition: mat.hpp:1762
Definition: core.hpp:3622
size_t stepT(int i=0) const
returns step()/sizeof(_Tp)
Definition: mat.hpp:965
void deallocate()
deallocates the matrix data
Mat_ & operator=(const Mat &m)
Definition: mat.hpp:879
const size_t & operator[](int i) const
Definition: mat.hpp:737
bool operator!=(const MSize &sz) const
Definition: mat.hpp:730
MatConstIterator_ & operator--()
decrements the iterator
Definition: mat.hpp:1848
Mat_()
default constructor
Definition: mat.hpp:800
void create(int rows, int cols, int type)
allocates new matrix data unless the matrix already has specified size and type.
Definition: mat.hpp:347
const _Tp & value() const
template method returning the current matrix element
Definition: mat.hpp:2326
CvArr * arr
Definition: core_c.h:649
_Tp y
Definition: core.hpp:766
unsigned char uchar
Definition: types_c.h:170
CV_EXPORTS MatExpr operator+(const Mat &a, const Mat &b)
Mat_< _Tp > operator*() const
another form of conversion operator
Definition: mat.hpp:2062
GLuint dst
Definition: calib3d.hpp:134
Definition: core.hpp:1950
int flags
Definition: core.hpp:3624
iterator begin()
iterators; they are smart enough to skip gaps in the end of rows
Definition: mat.hpp:2046
void addref()
manually increments the reference counter to the header.
Definition: mat.hpp:2137
Mat operator()(Range rowRange, Range colRange) const
extracts a rectangular sub-matrix
Definition: mat.hpp:373
GLenum GLsizei len
::max::max int
Definition: functional.hpp:324
uchar * operator[](ptrdiff_t i) const
returns the i-th matrix element, relative to the current
Definition: mat.hpp:2019
GLubyte GLubyte GLubyte GLubyte w
Mat diag(int d=0) const
... for the specified diagonal
CvPoint2D32f float a
Definition: legacy.hpp:578
size_t nodeCount
Definition: core.hpp:3391
int x
Definition: highgui_c.h:186
uchar * operator*() const
returns the current matrix element
Definition: mat.hpp:1760
CV_EXPORTS_W void add(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
adds one matrix to another (dst = src1 + src2)
SparseMatConstIterator & operator=(const SparseMatConstIterator &it)
the assignment operator
Definition: mat.hpp:2315
MatConstIterator & operator=(const MatConstIterator &it)
copy operator
Definition: mat.hpp:1753
int valueOffset
Definition: core.hpp:3389
const GLfloat * m
size_t * p
Definition: core.hpp:2000
_Tp height
Definition: core.hpp:840
CvArr CvArr * temp
Definition: imgproc_c.h:242
MSize size
Definition: core.hpp:2006
Template Read-Write Sparse Matrix Iterator Class.
Definition: core.hpp:3288
GLenum GLenum GLenum GLenum GLenum scale
GLdouble GLdouble t
_Tp & ref(int i0, size_t *hashval=0)
equivalent to SparseMat::ref<_Tp>(i0, hashval)
Definition: mat.hpp:2483
Mat cross(InputArray m) const
computes cross-product of 2 3D vectors
Point pos() const
returns the current iterator position
Definition: mat.hpp:1937
size_t hash(int i0) const
computes the element hash value (1D case)
Definition: mat.hpp:2187
GLdouble s
Definition: core.hpp:1458
const CvMat CvSize double alpha
Definition: calib3d.hpp:126
const CvArr const CvArr * src2
Definition: core_c.h:436
Definition: core.hpp:1978
void seek(ptrdiff_t ofs, bool relative=false)
CV_EXPORTS MatExpr operator>=(const Mat &a, const Mat &b)
value_type vec_type
Definition: core.hpp:1012
Mat_ operator()(const Range &rowRange, const Range &colRange) const
Definition: mat.hpp:971
Mat col(int x) const
returns a new matrix header for the specified column
Definition: mat.hpp:310
CV_EXPORTS_W void multiply(InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
computes element-wise weighted product of the two arrays (dst = scale*src1*src2)
DataType< _Tp >::work_type dot(const Vector< _Tp > &v1, const Vector< _Tp > &v2)
Definition: operations.hpp:2465
bool isContinuous() const
returns true iff the matrix data is continuous
Definition: mat.hpp:395
SparseMatIterator & operator=(const SparseMatIterator &it)
the assignment operator
Definition: mat.hpp:2364
CV_EXPORTS MatExpr operator&(const Mat &a, const Mat &b)
Mat vt
Definition: core.hpp:2529
_Tp operator()(int i0, size_t *hashval=0) const
equivalent to SparseMat::value<_Tp>(i0, hashval)
Definition: mat.hpp:2487
MatConstIterator_()
default constructor
Definition: mat.hpp:1813
int dims
the matrix dimensionality, >= 2
Definition: core.hpp:1960
Matrix read-only iterator.
Definition: core.hpp:117
_Tp * operator[](int y)
more convenient forms of row and element access operators
Definition: mat.hpp:980
size_t total() const
returns the total number of matrix elements
Definition: mat.hpp:404
void assignTo(Mat &m, int type=-1) const
Definition: mat.hpp:339
CV_INLINE CvMat cvMat(int rows, int cols, int type, void *data CV_DEFAULT(NULL))
Definition: types_c.h:733
GLsizeiptr size
Definition: core_c.h:939
MStep & operator=(size_t s)
Definition: mat.hpp:744
CV_EXPORTS Mat cvarrToMat(const CvArr *arr, bool copyData=false, bool allowND=true, int coiMode=0)
converts array (CvMat or IplImage) to cv::Mat
Scalar_< double > Scalar
Definition: core.hpp:968
_Tp & at(int i0=0)
the same as above, with the pointer dereferencing
Definition: mat.hpp:565
Proxy datatype for passing Mat's and vector<>'s as input parameters.
Definition: core.hpp:1400
MStep step
Definition: core.hpp:2007
const int & operator[](int i) const
Definition: mat.hpp:712
vector< uchar > pool
Definition: core.hpp:3393
void initEmpty()
Definition: mat.hpp:58
void create(int dims, const int *_sizes, int _type)
reallocates sparse matrix.
MatIterator_ & operator++()
increments the iterator
Definition: mat.hpp:1924
Definition: core.hpp:1950
CV_EXPORTS_W void max(InputArray src1, InputArray src2, OutputArray dst)
computes per-element maximum of two arrays (dst = max(src1, src2))
uchar * dataend
Definition: core.hpp:1972
MatIterator_()
the default constructor
Definition: mat.hpp:1874