00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043 #ifndef __OPENCV_CORE_MATRIX_OPERATIONS_HPP__
00044 #define __OPENCV_CORE_MATRIX_OPERATIONS_HPP__
00045
00046 #ifndef SKIP_INCLUDES
00047 #include <limits.h>
00048 #include <string.h>
00049 #endif // SKIP_INCLUDES
00050
00051 #ifdef __cplusplus
00052
00053 namespace cv
00054 {
00055
00057
00058 inline Mat::Mat()
00059 : flags(0), dims(0), rows(0), cols(0), data(0), refcount(0),
00060 datastart(0), dataend(0), datalimit(0), allocator(0), size(&rows)
00061 {
00062 }
00063
00064 inline Mat::Mat(int _rows, int _cols, int _type)
00065 : flags(0), dims(0), rows(0), cols(0), data(0), refcount(0),
00066 datastart(0), dataend(0), datalimit(0), allocator(0), size(&rows)
00067 {
00068 create(_rows, _cols, _type);
00069 }
00070
00071 inline Mat::Mat(int _rows, int _cols, int _type, const Scalar& _s)
00072 : flags(0), dims(0), rows(0), cols(0), data(0), refcount(0),
00073 datastart(0), dataend(0), datalimit(0), allocator(0), size(&rows)
00074 {
00075 create(_rows, _cols, _type);
00076 *this = _s;
00077 }
00078
00079 inline Mat::Mat(Size _sz, int _type)
00080 : flags(0), dims(0), rows(0), cols(0), data(0), refcount(0),
00081 datastart(0), dataend(0), datalimit(0), allocator(0), size(&rows)
00082 {
00083 create( _sz.height, _sz.width, _type );
00084 }
00085
00086 inline Mat::Mat(Size _sz, int _type, const Scalar& _s)
00087 : flags(0), dims(0), rows(0), cols(0), data(0), refcount(0),
00088 datastart(0), dataend(0), datalimit(0), allocator(0), size(&rows)
00089 {
00090 create(_sz.height, _sz.width, _type);
00091 *this = _s;
00092 }
00093
00094 inline Mat::Mat(int _dims, const int* _sz, int _type)
00095 : flags(0), dims(0), rows(0), cols(0), data(0), refcount(0),
00096 datastart(0), dataend(0), datalimit(0), allocator(0), size(&rows)
00097 {
00098 create(_dims, _sz, _type);
00099 }
00100
00101 inline Mat::Mat(int _dims, const int* _sz, int _type, const Scalar& _s)
00102 : flags(0), dims(0), rows(0), cols(0), data(0), refcount(0),
00103 datastart(0), dataend(0), datalimit(0), allocator(0), size(&rows)
00104 {
00105 create(_dims, _sz, _type);
00106 *this = _s;
00107 }
00108
00109 inline Mat::Mat(const Mat& m)
00110 : flags(m.flags), dims(m.dims), rows(m.rows), cols(m.cols), data(m.data),
00111 refcount(m.refcount), datastart(m.datastart), dataend(m.dataend),
00112 datalimit(m.datalimit), allocator(m.allocator), size(&rows)
00113 {
00114 if( refcount )
00115 CV_XADD(refcount, 1);
00116 if( m.dims <= 2 )
00117 {
00118 step[0] = m.step[0]; step[1] = m.step[1];
00119 }
00120 else
00121 {
00122 dims = 0;
00123 copySize(m);
00124 }
00125 }
00126
00127 inline Mat::Mat(int _rows, int _cols, int _type, void* _data, size_t _step)
00128 : flags(MAGIC_VAL + (_type & TYPE_MASK)), dims(2), rows(_rows), cols(_cols),
00129 data((uchar*)_data), refcount(0), datastart((uchar*)_data), dataend(0),
00130 datalimit(0), allocator(0), size(&rows)
00131 {
00132 size_t esz = CV_ELEM_SIZE(_type), minstep = cols*esz;
00133 if( _step == AUTO_STEP )
00134 {
00135 _step = minstep;
00136 flags |= CONTINUOUS_FLAG;
00137 }
00138 else
00139 {
00140 if( rows == 1 ) _step = minstep;
00141 CV_DbgAssert( _step >= minstep );
00142 flags |= _step == minstep ? CONTINUOUS_FLAG : 0;
00143 }
00144 step[0] = _step; step[1] = esz;
00145 datalimit = datastart + _step*rows;
00146 dataend = datalimit - _step + minstep;
00147 }
00148
00149 inline Mat::Mat(Size _sz, int _type, void* _data, size_t _step)
00150 : flags(MAGIC_VAL + (_type & TYPE_MASK)), dims(2), rows(_sz.height), cols(_sz.width),
00151 data((uchar*)_data), refcount(0), datastart((uchar*)_data), dataend(0),
00152 datalimit(0), allocator(0), size(&rows)
00153 {
00154 size_t esz = CV_ELEM_SIZE(_type), minstep = cols*esz;
00155 if( _step == AUTO_STEP )
00156 {
00157 _step = minstep;
00158 flags |= CONTINUOUS_FLAG;
00159 }
00160 else
00161 {
00162 if( rows == 1 ) _step = minstep;
00163 CV_DbgAssert( _step >= minstep );
00164 flags |= _step == minstep ? CONTINUOUS_FLAG : 0;
00165 }
00166 step[0] = _step; step[1] = esz;
00167 datalimit = datastart + _step*rows;
00168 dataend = datalimit - _step + minstep;
00169 }
00170
00171
00172 inline Mat::Mat(const CvMat* m, bool copyData)
00173 : flags(MAGIC_VAL + (m->type & (CV_MAT_TYPE_MASK|CV_MAT_CONT_FLAG))),
00174 dims(2), rows(m->rows), cols(m->cols), data(m->data.ptr), refcount(0),
00175 datastart(m->data.ptr), allocator(0), size(&rows)
00176 {
00177 if( !copyData )
00178 {
00179 size_t esz = CV_ELEM_SIZE(m->type), minstep = cols*esz, _step = m->step;
00180 if( _step == 0 )
00181 _step = minstep;
00182 datalimit = datastart + _step*rows;
00183 dataend = datalimit - _step + minstep;
00184 step[0] = _step; step[1] = esz;
00185 }
00186 else
00187 {
00188 data = datastart = dataend = 0;
00189 Mat(m->rows, m->cols, m->type, m->data.ptr, m->step).copyTo(*this);
00190 }
00191 }
00192
00193 template<typename _Tp> inline Mat::Mat(const vector<_Tp>& vec, bool copyData)
00194 : flags(MAGIC_VAL | DataType<_Tp>::type | CV_MAT_CONT_FLAG),
00195 dims(2), rows((int)vec.size()), cols(1), data(0), refcount(0),
00196 datastart(0), dataend(0), allocator(0), size(&rows)
00197 {
00198 if(vec.empty())
00199 return;
00200 if( !copyData )
00201 {
00202 step[0] = step[1] = sizeof(_Tp);
00203 data = datastart = (uchar*)&vec[0];
00204 datalimit = dataend = datastart + rows*step[0];
00205 }
00206 else
00207 Mat((int)vec.size(), 1, DataType<_Tp>::type, (uchar*)&vec[0]).copyTo(*this);
00208 }
00209
00210
00211 template<typename _Tp, int n> inline Mat::Mat(const Vec<_Tp, n>& vec, bool copyData)
00212 : flags(MAGIC_VAL | DataType<_Tp>::type | CV_MAT_CONT_FLAG),
00213 dims(2), rows(n), cols(1), data(0), refcount(0),
00214 datastart(0), dataend(0), allocator(0), size(&rows)
00215 {
00216 if( !copyData )
00217 {
00218 step[0] = step[1] = sizeof(_Tp);
00219 data = datastart = (uchar*)vec.val;
00220 datalimit = dataend = datastart + rows*step[0];
00221 }
00222 else
00223 Mat(n, 1, DataType<_Tp>::type, (void*)vec.val).copyTo(*this);
00224 }
00225
00226
00227 template<typename _Tp, int m, int n> inline Mat::Mat(const Matx<_Tp,m,n>& M, bool copyData)
00228 : flags(MAGIC_VAL | DataType<_Tp>::type | CV_MAT_CONT_FLAG),
00229 dims(2), rows(m), cols(n), data(0), refcount(0),
00230 datastart(0), dataend(0), allocator(0), size(&rows)
00231 {
00232 if( !copyData )
00233 {
00234 step[0] = cols*sizeof(_Tp);
00235 step[1] = sizeof(_Tp);
00236 data = datastart = (uchar*)M.val;
00237 datalimit = dataend = datastart + rows*step[0];
00238 }
00239 else
00240 Mat(m, n, DataType<_Tp>::type, (uchar*)M.val).copyTo(*this);
00241 }
00242
00243
00244 template<typename _Tp> inline Mat::Mat(const Point_<_Tp>& pt, bool copyData)
00245 : flags(MAGIC_VAL | DataType<_Tp>::type | CV_MAT_CONT_FLAG),
00246 dims(2), rows(2), cols(1), data(0), refcount(0),
00247 datastart(0), dataend(0), allocator(0), size(&rows)
00248 {
00249 if( !copyData )
00250 {
00251 step[0] = step[1] = sizeof(_Tp);
00252 data = datastart = (uchar*)&pt.x;
00253 datalimit = dataend = datastart + rows*step[0];
00254 }
00255 else
00256 {
00257 create(2, 1, DataType<_Tp>::type);
00258 ((_Tp*)data)[0] = pt.x;
00259 ((_Tp*)data)[1] = pt.y;
00260 }
00261 }
00262
00263
00264 template<typename _Tp> inline Mat::Mat(const Point3_<_Tp>& pt, bool copyData)
00265 : flags(MAGIC_VAL | DataType<_Tp>::type | CV_MAT_CONT_FLAG),
00266 dims(2), rows(3), cols(1), data(0), refcount(0),
00267 datastart(0), dataend(0), allocator(0), size(&rows)
00268 {
00269 if( !copyData )
00270 {
00271 step[0] = step[1] = sizeof(_Tp);
00272 data = datastart = (uchar*)&pt.x;
00273 datalimit = dataend = datastart + rows*step[0];
00274 }
00275 else
00276 {
00277 create(3, 1, DataType<_Tp>::type);
00278 ((_Tp*)data)[0] = pt.x;
00279 ((_Tp*)data)[1] = pt.y;
00280 ((_Tp*)data)[2] = pt.z;
00281 }
00282 }
00283
00284
00285 template<typename _Tp> inline Mat::Mat(const MatCommaInitializer_<_Tp>& commaInitializer)
00286 : flags(MAGIC_VAL | DataType<_Tp>::type | CV_MAT_CONT_FLAG),
00287 dims(0), rows(0), cols(0), data(0), refcount(0),
00288 datastart(0), dataend(0), allocator(0), size(&rows)
00289 {
00290 *this = *commaInitializer;
00291 }
00292
00293 inline Mat::~Mat()
00294 {
00295 release();
00296 if( step.p != step.buf )
00297 fastFree(step.p);
00298 }
00299
00300 inline Mat& Mat::operator = (const Mat& m)
00301 {
00302 if( this != &m )
00303 {
00304 if( m.refcount )
00305 CV_XADD(m.refcount, 1);
00306 release();
00307 flags = m.flags;
00308 if( dims <= 2 && m.dims <= 2 )
00309 {
00310 dims = m.dims;
00311 rows = m.rows;
00312 cols = m.cols;
00313 step[0] = m.step[0];
00314 step[1] = m.step[1];
00315 }
00316 else
00317 copySize(m);
00318 data = m.data;
00319 datastart = m.datastart;
00320 dataend = m.dataend;
00321 datalimit = m.datalimit;
00322 refcount = m.refcount;
00323 allocator = m.allocator;
00324 }
00325 return *this;
00326 }
00327
00328 inline Mat Mat::row(int y) const { return Mat(*this, Range(y, y+1), Range::all()); }
00329 inline Mat Mat::col(int x) const { return Mat(*this, Range::all(), Range(x, x+1)); }
00330 inline Mat Mat::rowRange(int startrow, int endrow) const
00331 { return Mat(*this, Range(startrow, endrow), Range::all()); }
00332 inline Mat Mat::rowRange(const Range& r) const
00333 { return Mat(*this, r, Range::all()); }
00334 inline Mat Mat::colRange(int startcol, int endcol) const
00335 { return Mat(*this, Range::all(), Range(startcol, endcol)); }
00336 inline Mat Mat::colRange(const Range& r) const
00337 { return Mat(*this, Range::all(), r); }
00338
00339 inline Mat Mat::diag(const Mat& d)
00340 {
00341 Mat m(d.rows, d.rows, d.type(), Scalar(0)), md = m.diag();
00342 d.copyTo(md);
00343 return m;
00344 }
00345
00346 inline Mat Mat::clone() const
00347 {
00348 Mat m;
00349 copyTo(m);
00350 return m;
00351 }
00352
00353 inline void Mat::assignTo( Mat& m, int type ) const
00354 {
00355 if( type < 0 )
00356 m = *this;
00357 else
00358 convertTo(m, type);
00359 }
00360
00361 inline void Mat::create(int _rows, int _cols, int _type)
00362 {
00363 _type &= TYPE_MASK;
00364 if( dims <= 2 && rows == _rows && cols == _cols && type() == _type && data )
00365 return;
00366 int sz[] = {_rows, _cols};
00367 create(2, sz, _type);
00368 }
00369
00370 inline void Mat::create(Size _sz, int _type)
00371 {
00372 create(_sz.height, _sz.width, _type);
00373 }
00374
00375 inline void Mat::addref()
00376 { if( refcount ) CV_XADD(refcount, 1); }
00377
00378 inline void Mat::release()
00379 {
00380 if( refcount && CV_XADD(refcount, -1) == 1 )
00381 deallocate();
00382 data = datastart = dataend = datalimit = 0;
00383 size.p[0] = 0;
00384 refcount = 0;
00385 }
00386
00387 inline Mat Mat::operator()( Range rowRange, Range colRange ) const
00388 {
00389 return Mat(*this, rowRange, colRange);
00390 }
00391
00392 inline Mat Mat::operator()( const Rect& roi ) const
00393 { return Mat(*this, roi); }
00394
00395 inline Mat Mat::operator()(const Range* ranges) const
00396 {
00397 return Mat(*this, ranges);
00398 }
00399
00400 inline Mat::operator CvMat() const
00401 {
00402 CV_DbgAssert(dims <= 2);
00403 CvMat m = cvMat(rows, dims == 1 ? 1 : cols, type(), data);
00404 m.step = (int)step[0];
00405 m.type = (m.type & ~CONTINUOUS_FLAG) | (flags & CONTINUOUS_FLAG);
00406 return m;
00407 }
00408
00409 inline bool Mat::isContinuous() const { return (flags & CONTINUOUS_FLAG) != 0; }
00410 inline bool Mat::isSubmatrix() const { return (flags & SUBMATRIX_FLAG) != 0; }
00411 inline size_t Mat::elemSize() const { return dims > 0 ? step.p[dims-1] : 0; }
00412 inline size_t Mat::elemSize1() const { return CV_ELEM_SIZE1(flags); }
00413 inline int Mat::type() const { return CV_MAT_TYPE(flags); }
00414 inline int Mat::depth() const { return CV_MAT_DEPTH(flags); }
00415 inline int Mat::channels() const { return CV_MAT_CN(flags); }
00416 inline size_t Mat::step1(int i) const { return step.p[i]/elemSize1(); }
00417 inline bool Mat::empty() const { return data == 0 || total() == 0; }
00418 inline size_t Mat::total() const
00419 {
00420 if( dims <= 2 )
00421 return rows*cols;
00422 size_t p = 1;
00423 for( int i = 0; i < dims; i++ )
00424 p *= size[i];
00425 return p;
00426 }
00427
00428 inline uchar* Mat::ptr(int y)
00429 {
00430 CV_DbgAssert( y == 0 || (data && dims >= 1 && (unsigned)y < (unsigned)size.p[0]) );
00431 return data + step.p[0]*y;
00432 }
00433
00434 inline const uchar* Mat::ptr(int y) const
00435 {
00436 CV_DbgAssert( y == 0 || (data && dims >= 1 && (unsigned)y < (unsigned)size.p[0]) );
00437 return data + step.p[0]*y;
00438 }
00439
00440 template<typename _Tp> inline _Tp* Mat::ptr(int y)
00441 {
00442 CV_DbgAssert( y == 0 || (data && dims >= 1 && (unsigned)y < (unsigned)size.p[0]) );
00443 return (_Tp*)(data + step.p[0]*y);
00444 }
00445
00446 template<typename _Tp> inline const _Tp* Mat::ptr(int y) const
00447 {
00448 CV_DbgAssert( y == 0 || (data && dims >= 1 && data && (unsigned)y < (unsigned)size.p[0]) );
00449 return (const _Tp*)(data + step.p[0]*y);
00450 }
00451
00452
00453 inline uchar* Mat::ptr(int i0, int i1)
00454 {
00455 CV_DbgAssert( dims >= 2 && data &&
00456 (unsigned)i0 < (unsigned)size.p[0] &&
00457 (unsigned)i1 < (unsigned)size.p[1] );
00458 return data + i0*step.p[0] + i1*step.p[1];
00459 }
00460
00461 inline const uchar* Mat::ptr(int i0, int i1) const
00462 {
00463 CV_DbgAssert( dims >= 2 && data &&
00464 (unsigned)i0 < (unsigned)size.p[0] &&
00465 (unsigned)i1 < (unsigned)size.p[1] );
00466 return data + i0*step.p[0] + i1*step.p[1];
00467 }
00468
00469 template<typename _Tp> inline _Tp* Mat::ptr(int i0, int i1)
00470 {
00471 CV_DbgAssert( dims >= 2 && data &&
00472 (unsigned)i0 < (unsigned)size.p[0] &&
00473 (unsigned)i1 < (unsigned)size.p[1] );
00474 return (_Tp*)(data + i0*step.p[0] + i1*step.p[1]);
00475 }
00476
00477 template<typename _Tp> inline const _Tp* Mat::ptr(int i0, int i1) const
00478 {
00479 CV_DbgAssert( dims >= 2 && data &&
00480 (unsigned)i0 < (unsigned)size.p[0] &&
00481 (unsigned)i1 < (unsigned)size.p[1] );
00482 return (const _Tp*)(data + i0*step.p[0] + i1*step.p[1]);
00483 }
00484
00485 inline uchar* Mat::ptr(int i0, int i1, int i2)
00486 {
00487 CV_DbgAssert( dims >= 3 && data &&
00488 (unsigned)i0 < (unsigned)size.p[0] &&
00489 (unsigned)i1 < (unsigned)size.p[1] &&
00490 (unsigned)i2 < (unsigned)size.p[2] );
00491 return data + i0*step.p[0] + i1*step.p[1] + i2*step.p[2];
00492 }
00493
00494 inline const uchar* Mat::ptr(int i0, int i1, int i2) const
00495 {
00496 CV_DbgAssert( dims >= 3 && data &&
00497 (unsigned)i0 < (unsigned)size.p[0] &&
00498 (unsigned)i1 < (unsigned)size.p[1] &&
00499 (unsigned)i2 < (unsigned)size.p[2] );
00500 return data + i0*step.p[0] + i1*step.p[1] + i2*step.p[2];
00501 }
00502
00503 template<typename _Tp> inline _Tp* Mat::ptr(int i0, int i1, int i2)
00504 {
00505 CV_DbgAssert( dims >= 3 && data &&
00506 (unsigned)i0 < (unsigned)size.p[0] &&
00507 (unsigned)i1 < (unsigned)size.p[1] &&
00508 (unsigned)i2 < (unsigned)size.p[2] );
00509 return (_Tp*)(data + i0*step.p[0] + i1*step.p[1] + i2*step.p[2]);
00510 }
00511
00512 template<typename _Tp> inline const _Tp* Mat::ptr(int i0, int i1, int i2) const
00513 {
00514 CV_DbgAssert( dims >= 3 && data &&
00515 (unsigned)i0 < (unsigned)size.p[0] &&
00516 (unsigned)i1 < (unsigned)size.p[1] &&
00517 (unsigned)i2 < (unsigned)size.p[2] );
00518 return (const _Tp*)(data + i0*step.p[0] + i1*step.p[1] + i2*step.p[2]);
00519 }
00520
00521 inline uchar* Mat::ptr(const int* idx)
00522 {
00523 int i, d = dims;
00524 uchar* p = data;
00525 CV_DbgAssert( d >= 1 && p );
00526 for( i = 0; i < d; i++ )
00527 {
00528 CV_DbgAssert( (unsigned)idx[i] < (unsigned)size.p[i] );
00529 p += idx[i]*step.p[i];
00530 }
00531 return p;
00532 }
00533
00534 inline const uchar* Mat::ptr(const int* idx) const
00535 {
00536 int i, d = dims;
00537 uchar* p = data;
00538 CV_DbgAssert( d >= 1 && p );
00539 for( i = 0; i < d; i++ )
00540 {
00541 CV_DbgAssert( (unsigned)idx[i] < (unsigned)size.p[i] );
00542 p += idx[i]*step.p[i];
00543 }
00544 return p;
00545 }
00546
00547 template<typename _Tp> inline _Tp& Mat::at(int i0, int i1)
00548 {
00549 CV_DbgAssert( dims <= 2 && data && (unsigned)i0 < (unsigned)size.p[0] &&
00550 (unsigned)(i1*DataType<_Tp>::channels) < (unsigned)(size.p[1]*channels()) &&
00551 CV_ELEM_SIZE1(DataType<_Tp>::depth) == elemSize1());
00552 return ((_Tp*)(data + step.p[0]*i0))[i1];
00553 }
00554
00555 template<typename _Tp> inline const _Tp& Mat::at(int i0, int i1) const
00556 {
00557 CV_DbgAssert( dims <= 2 && data && (unsigned)i0 < (unsigned)size.p[0] &&
00558 (unsigned)(i1*DataType<_Tp>::channels) < (unsigned)(size.p[1]*channels()) &&
00559 CV_ELEM_SIZE1(DataType<_Tp>::depth) == elemSize1());
00560 return ((const _Tp*)(data + step.p[0]*i0))[i1];
00561 }
00562
00563 template<typename _Tp> inline _Tp& Mat::at(Point pt)
00564 {
00565 CV_DbgAssert( dims <= 2 && data && (unsigned)pt.y < (unsigned)size.p[0] &&
00566 (unsigned)(pt.x*DataType<_Tp>::channels) < (unsigned)(size.p[1]*channels()) &&
00567 CV_ELEM_SIZE1(DataType<_Tp>::depth) == elemSize1());
00568 return ((_Tp*)(data + step.p[0]*pt.y))[pt.x];
00569 }
00570
00571 template<typename _Tp> inline const _Tp& Mat::at(Point pt) const
00572 {
00573 CV_DbgAssert( dims <= 2 && data && (unsigned)pt.y < (unsigned)size.p[0] &&
00574 (unsigned)(pt.x*DataType<_Tp>::channels) < (unsigned)(size.p[1]*channels()) &&
00575 CV_ELEM_SIZE1(DataType<_Tp>::depth) == elemSize1());
00576 return ((const _Tp*)(data + step.p[0]*pt.y))[pt.x];
00577 }
00578
00579 template<typename _Tp> inline _Tp& Mat::at(int i0)
00580 {
00581 CV_DbgAssert( dims <= 2 && data && (size.p[0] == 1 || size.p[1] == 1) &&
00582 (unsigned)i0 < (unsigned)(size.p[0] + size.p[1] - 1) &&
00583 elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
00584 return *(_Tp*)(data + step.p[size.p[0]==1]*i0);
00585 }
00586
00587 template<typename _Tp> inline const _Tp& Mat::at(int i0) const
00588 {
00589 CV_DbgAssert( dims <= 2 && data && (size.p[0] == 1 || size.p[1] == 1) &&
00590 (unsigned)i0 < (unsigned)(size.p[0] + size.p[1] - 1) &&
00591 elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
00592 return *(_Tp*)(data + step.p[size.p[0]==1]*i0);
00593 }
00594
00595 template<typename _Tp> inline _Tp& Mat::at(int i0, int i1, int i2)
00596 {
00597 CV_DbgAssert( elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
00598 return *(_Tp*)ptr(i0, i1, i2);
00599 }
00600 template<typename _Tp> inline const _Tp& Mat::at(int i0, int i1, int i2) const
00601 {
00602 CV_DbgAssert( elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
00603 return *(const _Tp*)ptr(i0, i1, i2);
00604 }
00605 template<typename _Tp> inline _Tp& Mat::at(const int* idx)
00606 {
00607 CV_DbgAssert( elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
00608 return *(_Tp*)ptr(idx);
00609 }
00610 template<typename _Tp> inline const _Tp& Mat::at(const int* idx) const
00611 {
00612 CV_DbgAssert( elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
00613 return *(const _Tp*)ptr(idx);
00614 }
00615
00616
00617 template<typename _Tp> inline MatConstIterator_<_Tp> Mat::begin() const
00618 {
00619 CV_DbgAssert( elemSize() == sizeof(_Tp) );
00620 return MatConstIterator_<_Tp>((const Mat_<_Tp>*)this);
00621 }
00622
00623 template<typename _Tp> inline MatConstIterator_<_Tp> Mat::end() const
00624 {
00625 CV_DbgAssert( elemSize() == sizeof(_Tp) );
00626 MatConstIterator_<_Tp> it((const Mat_<_Tp>*)this);
00627 it += total();
00628 return it;
00629 }
00630
00631 template<typename _Tp> inline MatIterator_<_Tp> Mat::begin()
00632 {
00633 CV_DbgAssert( elemSize() == sizeof(_Tp) );
00634 return MatIterator_<_Tp>((Mat_<_Tp>*)this);
00635 }
00636
00637 template<typename _Tp> inline MatIterator_<_Tp> Mat::end()
00638 {
00639 CV_DbgAssert( elemSize() == sizeof(_Tp) );
00640 MatIterator_<_Tp> it((Mat_<_Tp>*)this);
00641 it += total();
00642 return it;
00643 }
00644
00645 template<typename _Tp> inline Mat::operator vector<_Tp>() const
00646 {
00647 vector<_Tp> v;
00648 copyTo(v);
00649 return v;
00650 }
00651
00652 template<typename _Tp, int n> inline Mat::operator Vec<_Tp, n>() const
00653 {
00654 CV_Assert( data && dims <= 2 && (rows == 1 || cols == 1) &&
00655 rows + cols - 1 == n && channels() == 1 );
00656
00657 if( isContinuous() && type() == DataType<_Tp>::type )
00658 return Vec<_Tp, n>((_Tp*)data);
00659 Vec<_Tp, n> v; Mat tmp(rows, cols, DataType<_Tp>::type, v.val);
00660 convertTo(tmp, tmp.type());
00661 return v;
00662 }
00663
00664 template<typename _Tp, int m, int n> inline Mat::operator Matx<_Tp, m, n>() const
00665 {
00666 CV_Assert( data && dims <= 2 && rows == m && cols == n && channels() == 1 );
00667
00668 if( isContinuous() && type() == DataType<_Tp>::type )
00669 return Matx<_Tp, m, n>((_Tp*)data);
00670 Matx<_Tp, m, n> mtx; Mat tmp(rows, cols, DataType<_Tp>::type, mtx.val);
00671 convertTo(tmp, tmp.type());
00672 return mtx;
00673 }
00674
00675
00676 template<typename _Tp> inline void Mat::push_back(const _Tp& elem)
00677 {
00678 CV_Assert(DataType<_Tp>::type == type() && cols == 1
00679 );
00680 uchar* tmp = dataend + step[0];
00681 if( !isSubmatrix() && isContinuous() && tmp <= datalimit )
00682 {
00683 *(_Tp*)(data + (size.p[0]++)*step.p[0]) = elem;
00684 dataend = tmp;
00685 }
00686 else
00687 push_back_(&elem);
00688 }
00689
00690 template<typename _Tp> inline void Mat::push_back(const Mat_<_Tp>& m)
00691 {
00692 push_back((const Mat&)m);
00693 }
00694
00695 inline Mat::MSize::MSize(int* _p) : p(_p) {}
00696 inline Size Mat::MSize::operator()() const
00697 {
00698 CV_DbgAssert(p[-1] <= 2);
00699 return Size(p[1], p[0]);
00700 }
00701 inline const int& Mat::MSize::operator[](int i) const { return p[i]; }
00702 inline int& Mat::MSize::operator[](int i) { return p[i]; }
00703 inline Mat::MSize::operator const int*() const { return p; }
00704
00705 inline bool Mat::MSize::operator == (const MSize& sz) const
00706 {
00707 int d = p[-1], dsz = sz.p[-1];
00708 if( d != dsz )
00709 return false;
00710 if( d == 2 )
00711 return p[0] == sz.p[0] && p[1] == sz.p[1];
00712
00713 for( int i = 0; i < d; i++ )
00714 if( p[i] != sz.p[i] )
00715 return false;
00716 return true;
00717 }
00718
00719 inline bool Mat::MSize::operator != (const MSize& sz) const
00720 {
00721 return !(*this == sz);
00722 }
00723
00724 inline Mat::MStep::MStep() { p = buf; p[0] = p[1] = 0; }
00725 inline Mat::MStep::MStep(size_t s) { p = buf; p[0] = s; p[1] = 0; }
00726 inline const size_t& Mat::MStep::operator[](int i) const { return p[i]; }
00727 inline size_t& Mat::MStep::operator[](int i) { return p[i]; }
00728 inline Mat::MStep::operator size_t() const
00729 {
00730 CV_DbgAssert( p == buf );
00731 return buf[0];
00732 }
00733 inline Mat::MStep& Mat::MStep::operator = (size_t s)
00734 {
00735 CV_DbgAssert( p == buf );
00736 buf[0] = s;
00737 return *this;
00738 }
00739
00740 static inline Mat cvarrToMatND(const CvArr* arr, bool copyData=false, int coiMode=0)
00741 {
00742 return cvarrToMat(arr, copyData, true, coiMode);
00743 }
00744
00746
00747 inline SVD::SVD() {}
00748 inline SVD::SVD( InputArray m, int flags ) { operator ()(m, flags); }
00749 inline void SVD::solveZ( InputArray m, OutputArray _dst )
00750 {
00751 SVD svd(m);
00752 _dst.create(svd.vt.cols, 1, svd.vt.type());
00753 Mat dst = _dst.getMat();
00754 svd.vt.row(svd.vt.rows-1).reshape(1,svd.vt.cols).copyTo(dst);
00755 }
00756
00757 template<typename _Tp, int m, int n, int nm> inline void
00758 SVD::compute( const Matx<_Tp, m, n>& a, Matx<_Tp, nm, 1>& w, Matx<_Tp, m, nm>& u, Matx<_Tp, n, nm>& vt )
00759 {
00760 assert( nm == MIN(m, n));
00761 Mat _a(a, false), _u(u, false), _w(w, false), _vt(vt, false);
00762 SVD::compute(_a, _w, _u, _vt);
00763 CV_Assert(_w.data == (uchar*)&w.val[0] && _u.data == (uchar*)&u.val[0] && _vt.data == (uchar*)&vt.val[0]);
00764 }
00765
00766 template<typename _Tp, int m, int n, int nm> inline void
00767 SVD::compute( const Matx<_Tp, m, n>& a, Matx<_Tp, nm, 1>& w )
00768 {
00769 assert( nm == MIN(m, n));
00770 Mat _a(a, false), _w(w, false);
00771 SVD::compute(_a, _w);
00772 CV_Assert(_w.data == (uchar*)&w.val[0]);
00773 }
00774
00775 template<typename _Tp, int m, int n, int nm, int nb> inline void
00776 SVD::backSubst( const Matx<_Tp, nm, 1>& w, const Matx<_Tp, m, nm>& u,
00777 const Matx<_Tp, n, nm>& vt, const Matx<_Tp, m, nb>& rhs,
00778 Matx<_Tp, n, nb>& dst )
00779 {
00780 assert( nm == MIN(m, n));
00781 Mat _u(u, false), _w(w, false), _vt(vt, false), _rhs(rhs, false), _dst(dst, false);
00782 SVD::backSubst(_w, _u, _vt, _rhs, _dst);
00783 CV_Assert(_dst.data == (uchar*)&dst.val[0]);
00784 }
00785
00787
00788 template<typename _Tp> inline Mat_<_Tp>::Mat_()
00789 : Mat() { flags = (flags & ~CV_MAT_TYPE_MASK) | DataType<_Tp>::type; }
00790
00791 template<typename _Tp> inline Mat_<_Tp>::Mat_(int _rows, int _cols)
00792 : Mat(_rows, _cols, DataType<_Tp>::type) {}
00793
00794 template<typename _Tp> inline Mat_<_Tp>::Mat_(int _rows, int _cols, const _Tp& value)
00795 : Mat(_rows, _cols, DataType<_Tp>::type) { *this = value; }
00796
00797 template<typename _Tp> inline Mat_<_Tp>::Mat_(Size _sz)
00798 : Mat(_sz.height, _sz.width, DataType<_Tp>::type) {}
00799
00800 template<typename _Tp> inline Mat_<_Tp>::Mat_(Size _sz, const _Tp& value)
00801 : Mat(_sz.height, _sz.width, DataType<_Tp>::type) { *this = value; }
00802
00803 template<typename _Tp> inline Mat_<_Tp>::Mat_(int _dims, const int* _sz)
00804 : Mat(_dims, _sz, DataType<_Tp>::type) {}
00805
00806 template<typename _Tp> inline Mat_<_Tp>::Mat_(int _dims, const int* _sz, const _Tp& _s)
00807 : Mat(_dims, _sz, DataType<_Tp>::type, Scalar(_s)) {}
00808
00809 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_<_Tp>& m, const Range* ranges)
00810 : Mat(m, ranges) {}
00811
00812 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat& m)
00813 : Mat() { flags = (flags & ~CV_MAT_TYPE_MASK) | DataType<_Tp>::type; *this = m; }
00814
00815 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_& m)
00816 : Mat(m) {}
00817
00818 template<typename _Tp> inline Mat_<_Tp>::Mat_(int _rows, int _cols, _Tp* _data, size_t steps)
00819 : Mat(_rows, _cols, DataType<_Tp>::type, _data, steps) {}
00820
00821 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_& m, const Range& rowRange, const Range& colRange)
00822 : Mat(m, rowRange, colRange) {}
00823
00824 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_& m, const Rect& roi)
00825 : Mat(m, roi) {}
00826
00827 template<typename _Tp> template<int n> inline
00828 Mat_<_Tp>::Mat_(const Vec<typename DataType<_Tp>::channel_type, n>& vec, bool copyData)
00829 : Mat(n/DataType<_Tp>::channels, 1, DataType<_Tp>::type, (void*)&vec)
00830 {
00831 CV_Assert(n%DataType<_Tp>::channels == 0);
00832 if( copyData )
00833 *this = clone();
00834 }
00835
00836 template<typename _Tp> template<int m, int n> inline
00837 Mat_<_Tp>::Mat_(const Matx<typename DataType<_Tp>::channel_type,m,n>& M, bool copyData)
00838 : Mat(m, n/DataType<_Tp>::channels, DataType<_Tp>::type, (void*)&M)
00839 {
00840 CV_Assert(n % DataType<_Tp>::channels == 0);
00841 if( copyData )
00842 *this = clone();
00843 }
00844
00845 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Point_<typename DataType<_Tp>::channel_type>& pt, bool copyData)
00846 : Mat(2/DataType<_Tp>::channels, 1, DataType<_Tp>::type, (void*)&pt)
00847 {
00848 CV_Assert(2 % DataType<_Tp>::channels == 0);
00849 if( copyData )
00850 *this = clone();
00851 }
00852
00853 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Point3_<typename DataType<_Tp>::channel_type>& pt, bool copyData)
00854 : Mat(3/DataType<_Tp>::channels, 1, DataType<_Tp>::type, (void*)&pt)
00855 {
00856 CV_Assert(3 % DataType<_Tp>::channels == 0);
00857 if( copyData )
00858 *this = clone();
00859 }
00860
00861 template<typename _Tp> inline Mat_<_Tp>::Mat_(const MatCommaInitializer_<_Tp>& commaInitializer)
00862 : Mat(commaInitializer) {}
00863
00864 template<typename _Tp> inline Mat_<_Tp>::Mat_(const vector<_Tp>& vec, bool copyData)
00865 : Mat(vec, copyData) {}
00866
00867 template<typename _Tp> inline Mat_<_Tp>& Mat_<_Tp>::operator = (const Mat& m)
00868 {
00869 if( DataType<_Tp>::type == m.type() )
00870 {
00871 Mat::operator = (m);
00872 return *this;
00873 }
00874 if( DataType<_Tp>::depth == m.depth() )
00875 {
00876 return (*this = m.reshape(DataType<_Tp>::channels, m.dims, 0));
00877 }
00878 CV_DbgAssert(DataType<_Tp>::channels == m.channels());
00879 m.convertTo(*this, type());
00880 return *this;
00881 }
00882
00883 template<typename _Tp> inline Mat_<_Tp>& Mat_<_Tp>::operator = (const Mat_& m)
00884 {
00885 Mat::operator=(m);
00886 return *this;
00887 }
00888
00889 template<typename _Tp> inline Mat_<_Tp>& Mat_<_Tp>::operator = (const _Tp& s)
00890 {
00891 typedef typename DataType<_Tp>::vec_type VT;
00892 Mat::operator=(Scalar((const VT&)s));
00893 return *this;
00894 }
00895
00896 template<typename _Tp> inline void Mat_<_Tp>::create(int _rows, int _cols)
00897 {
00898 Mat::create(_rows, _cols, DataType<_Tp>::type);
00899 }
00900
00901 template<typename _Tp> inline void Mat_<_Tp>::create(Size _sz)
00902 {
00903 Mat::create(_sz, DataType<_Tp>::type);
00904 }
00905
00906 template<typename _Tp> inline void Mat_<_Tp>::create(int _dims, const int* _sz)
00907 {
00908 Mat::create(_dims, _sz, DataType<_Tp>::type);
00909 }
00910
00911
00912 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::cross(const Mat_& m) const
00913 { return Mat_<_Tp>(Mat::cross(m)); }
00914
00915 template<typename _Tp> template<typename T2> inline Mat_<_Tp>::operator Mat_<T2>() const
00916 { return Mat_<T2>(*this); }
00917
00918 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::row(int y) const
00919 { return Mat_(*this, Range(y, y+1), Range::all()); }
00920 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::col(int x) const
00921 { return Mat_(*this, Range::all(), Range(x, x+1)); }
00922 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::diag(int d) const
00923 { return Mat_(Mat::diag(d)); }
00924 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::clone() const
00925 { return Mat_(Mat::clone()); }
00926
00927 template<typename _Tp> inline size_t Mat_<_Tp>::elemSize() const
00928 {
00929 CV_DbgAssert( Mat::elemSize() == sizeof(_Tp) );
00930 return sizeof(_Tp);
00931 }
00932
00933 template<typename _Tp> inline size_t Mat_<_Tp>::elemSize1() const
00934 {
00935 CV_DbgAssert( Mat::elemSize1() == sizeof(_Tp)/DataType<_Tp>::channels );
00936 return sizeof(_Tp)/DataType<_Tp>::channels;
00937 }
00938 template<typename _Tp> inline int Mat_<_Tp>::type() const
00939 {
00940 CV_DbgAssert( Mat::type() == DataType<_Tp>::type );
00941 return DataType<_Tp>::type;
00942 }
00943 template<typename _Tp> inline int Mat_<_Tp>::depth() const
00944 {
00945 CV_DbgAssert( Mat::depth() == DataType<_Tp>::depth );
00946 return DataType<_Tp>::depth;
00947 }
00948 template<typename _Tp> inline int Mat_<_Tp>::channels() const
00949 {
00950 CV_DbgAssert( Mat::channels() == DataType<_Tp>::channels );
00951 return DataType<_Tp>::channels;
00952 }
00953 template<typename _Tp> inline size_t Mat_<_Tp>::stepT(int i) const { return step.p[i]/elemSize(); }
00954 template<typename _Tp> inline size_t Mat_<_Tp>::step1(int i) const { return step.p[i]/elemSize1(); }
00955
00956 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::reshape(int _rows) const
00957 { return Mat_<_Tp>(Mat::reshape(0,_rows)); }
00958
00959 template<typename _Tp> inline Mat_<_Tp>& Mat_<_Tp>::adjustROI( int dtop, int dbottom, int dleft, int dright )
00960 { return (Mat_<_Tp>&)(Mat::adjustROI(dtop, dbottom, dleft, dright)); }
00961
00962 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::operator()( const Range& rowRange, const Range& colRange ) const
00963 { return Mat_<_Tp>(*this, rowRange, colRange); }
00964
00965 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::operator()( const Rect& roi ) const
00966 { return Mat_<_Tp>(*this, roi); }
00967
00968 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::operator()( const Range* ranges ) const
00969 { return Mat_<_Tp>(*this, ranges); }
00970
00971 template<typename _Tp> inline _Tp* Mat_<_Tp>::operator [](int y)
00972 { return (_Tp*)ptr(y); }
00973 template<typename _Tp> inline const _Tp* Mat_<_Tp>::operator [](int y) const
00974 { return (const _Tp*)ptr(y); }
00975
00976 template<typename _Tp> inline _Tp& Mat_<_Tp>::operator ()(int i0, int i1)
00977 {
00978 CV_DbgAssert( dims <= 2 && data &&
00979 (unsigned)i0 < (unsigned)size.p[0] &&
00980 (unsigned)i1 < (unsigned)size.p[1] &&
00981 type() == DataType<_Tp>::type );
00982 return ((_Tp*)(data + step.p[0]*i0))[i1];
00983 }
00984
00985 template<typename _Tp> inline const _Tp& Mat_<_Tp>::operator ()(int i0, int i1) const
00986 {
00987 CV_DbgAssert( dims <= 2 && data &&
00988 (unsigned)i0 < (unsigned)size.p[0] &&
00989 (unsigned)i1 < (unsigned)size.p[1] &&
00990 type() == DataType<_Tp>::type );
00991 return ((const _Tp*)(data + step.p[0]*i0))[i1];
00992 }
00993
00994 template<typename _Tp> inline _Tp& Mat_<_Tp>::operator ()(Point pt)
00995 {
00996 CV_DbgAssert( dims <= 2 && data &&
00997 (unsigned)pt.y < (unsigned)size.p[0] &&
00998 (unsigned)pt.x < (unsigned)size.p[1] &&
00999 type() == DataType<_Tp>::type );
01000 return ((_Tp*)(data + step.p[0]*pt.y))[pt.x];
01001 }
01002
01003 template<typename _Tp> inline const _Tp& Mat_<_Tp>::operator ()(Point pt) const
01004 {
01005 CV_DbgAssert( dims <= 2 && data &&
01006 (unsigned)pt.y < (unsigned)size.p[0] &&
01007 (unsigned)pt.x < (unsigned)size.p[1] &&
01008 type() == DataType<_Tp>::type );
01009 return ((const _Tp*)(data + step.p[0]*pt.y))[pt.x];
01010 }
01011
01012 template<typename _Tp> inline _Tp& Mat_<_Tp>::operator ()(const int* idx)
01013 {
01014 return Mat::at<_Tp>(idx);
01015 }
01016
01017 template<typename _Tp> inline const _Tp& Mat_<_Tp>::operator ()(const int* idx) const
01018 {
01019 return Mat::at<_Tp>(idx);
01020 }
01021
01022 template<typename _Tp> inline _Tp& Mat_<_Tp>::operator ()(int i0)
01023 {
01024 return this->at<_Tp>(i0);
01025 }
01026
01027 template<typename _Tp> inline const _Tp& Mat_<_Tp>::operator ()(int i0) const
01028 {
01029 return this->at<_Tp>(i0);
01030 }
01031
01032 template<typename _Tp> inline _Tp& Mat_<_Tp>::operator ()(int i0, int i1, int i2)
01033 {
01034 return this->at<_Tp>(i0, i1, i2);
01035 }
01036
01037 template<typename _Tp> inline const _Tp& Mat_<_Tp>::operator ()(int i0, int i1, int i2) const
01038 {
01039 return this->at<_Tp>(i0, i1, i2);
01040 }
01041
01042
01043 template<typename _Tp> inline Mat_<_Tp>::operator vector<_Tp>() const
01044 {
01045 vector<_Tp> v;
01046 copyTo(v);
01047 return v;
01048 }
01049
01050 template<typename _Tp> template<int n> inline Mat_<_Tp>::operator Vec<typename DataType<_Tp>::channel_type, n>() const
01051 {
01052 CV_Assert(n % DataType<_Tp>::channels == 0);
01053 return this->Mat::operator Vec<typename DataType<_Tp>::channel_type, n>();
01054 }
01055
01056 template<typename _Tp> template<int m, int n> inline Mat_<_Tp>::operator Matx<typename DataType<_Tp>::channel_type, m, n>() const
01057 {
01058 CV_Assert(n % DataType<_Tp>::channels == 0);
01059 return this->Mat::operator Matx<typename DataType<_Tp>::channel_type, m, n>();
01060 }
01061
01062 template<typename T1, typename T2, typename Op> inline void
01063 process( const Mat_<T1>& m1, Mat_<T2>& m2, Op op )
01064 {
01065 int y, x, rows = m1.rows, cols = m1.cols;
01066 int c1 = m1.channels(), c2 = m2.channels();
01067
01068 CV_DbgAssert( m1.size() == m2.size() );
01069
01070 for( y = 0; y < rows; y++ )
01071 {
01072 const T1* src = m1[y];
01073 T2* dst = m2[y];
01074
01075 for( x = 0; x < cols; x++ )
01076 dst[x] = op(src[x]);
01077 }
01078 }
01079
01080 template<typename T1, typename T2, typename T3, typename Op> inline void
01081 process( const Mat_<T1>& m1, const Mat_<T2>& m2, Mat_<T3>& m3, Op op )
01082 {
01083 int y, x, rows = m1.rows, cols = m1.cols;
01084
01085 CV_DbgAssert( m1.size() == m2.size() );
01086
01087 for( y = 0; y < rows; y++ )
01088 {
01089 const T1* src1 = m1[y];
01090 const T2* src2 = m2[y];
01091 T3* dst = m3[y];
01092
01093 for( x = 0; x < cols; x++ )
01094 dst[x] = op( src1[x], src2[x] );
01095 }
01096 }
01097
01098
01100
01101 template<typename _Tp> _InputArray::_InputArray(const vector<_Tp>& vec)
01102 : flags(STD_VECTOR + DataType<_Tp>::type), obj((void*)&vec) {}
01103
01104 template<typename _Tp> _InputArray::_InputArray(const vector<vector<_Tp> >& vec)
01105 : flags(STD_VECTOR_VECTOR + DataType<_Tp>::type), obj((void*)&vec) {}
01106
01107 template<typename _Tp, int m, int n> _InputArray::_InputArray(const Matx<_Tp, m, n>& mtx)
01108 : flags(MATX + DataType<_Tp>::type), obj((void*)&mtx), sz(n, m) {}
01109
01110 template<typename _Tp> _OutputArray::_OutputArray(vector<_Tp>& vec) : _InputArray(vec) {}
01111 template<typename _Tp> _OutputArray::_OutputArray(vector<vector<_Tp> >& vec) : _InputArray(vec) {}
01112 template<typename _Tp, int m, int n> _OutputArray::_OutputArray(Matx<_Tp, m, n>& mtx) : _InputArray(mtx) {}
01113
01115
01116 class CV_EXPORTS MatOp
01117 {
01118 public:
01119 MatOp() {};
01120 virtual ~MatOp() {};
01121
01122 virtual bool elementWise(const MatExpr& expr) const;
01123 virtual void assign(const MatExpr& expr, Mat& m, int type=-1) const = 0;
01124 virtual void roi(const MatExpr& expr, const Range& rowRange,
01125 const Range& colRange, MatExpr& res) const;
01126 virtual void diag(const MatExpr& expr, int d, MatExpr& res) const;
01127 virtual void augAssignAdd(const MatExpr& expr, Mat& m) const;
01128 virtual void augAssignSubtract(const MatExpr& expr, Mat& m) const;
01129 virtual void augAssignMultiply(const MatExpr& expr, Mat& m) const;
01130 virtual void augAssignDivide(const MatExpr& expr, Mat& m) const;
01131 virtual void augAssignAnd(const MatExpr& expr, Mat& m) const;
01132 virtual void augAssignOr(const MatExpr& expr, Mat& m) const;
01133 virtual void augAssignXor(const MatExpr& expr, Mat& m) const;
01134
01135 virtual void add(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
01136 virtual void add(const MatExpr& expr1, const Scalar& s, MatExpr& res) const;
01137
01138 virtual void subtract(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
01139 virtual void subtract(const Scalar& s, const MatExpr& expr, MatExpr& res) const;
01140
01141 virtual void multiply(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res, double scale=1) const;
01142 virtual void multiply(const MatExpr& expr1, double s, MatExpr& res) const;
01143
01144 virtual void divide(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res, double scale=1) const;
01145 virtual void divide(double s, const MatExpr& expr, MatExpr& res) const;
01146
01147 virtual void abs(const MatExpr& expr, MatExpr& res) const;
01148
01149 virtual void transpose(const MatExpr& expr, MatExpr& res) const;
01150 virtual void matmul(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
01151 virtual void invert(const MatExpr& expr, int method, MatExpr& res) const;
01152
01153 virtual Size size(const MatExpr& expr) const;
01154 virtual int type(const MatExpr& expr) const;
01155 };
01156
01157
01158 class CV_EXPORTS MatExpr
01159 {
01160 public:
01161 MatExpr() : op(0), flags(0), a(Mat()), b(Mat()), c(Mat()), alpha(0), beta(0), s(Scalar()) {}
01162 MatExpr(const MatOp* _op, int _flags, const Mat& _a=Mat(), const Mat& _b=Mat(),
01163 const Mat& _c=Mat(), double _alpha=1, double _beta=1, const Scalar& _s=Scalar())
01164 : op(_op), flags(_flags), a(_a), b(_b), c(_c), alpha(_alpha), beta(_beta), s(_s) {}
01165 explicit MatExpr(const Mat& m);
01166 operator Mat() const
01167 {
01168 Mat m;
01169 op->assign(*this, m);
01170 return m;
01171 }
01172
01173 template<typename _Tp> operator Mat_<_Tp>() const
01174 {
01175 Mat_<_Tp> m;
01176 op->assign(*this, m, DataType<_Tp>::type);
01177 return m;
01178 }
01179
01180 MatExpr row(int y) const;
01181 MatExpr col(int x) const;
01182 MatExpr diag(int d=0) const;
01183 MatExpr operator()( const Range& rowRange, const Range& colRange ) const;
01184 MatExpr operator()( const Rect& roi ) const;
01185
01186 Mat cross(const Mat& m) const;
01187 double dot(const Mat& m) const;
01188
01189 MatExpr t() const;
01190 MatExpr inv(int method = DECOMP_LU) const;
01191 MatExpr mul(const MatExpr& e, double scale=1) const;
01192 MatExpr mul(const Mat& m, double scale=1) const;
01193
01194 Size size() const;
01195 int type() const;
01196
01197 const MatOp* op;
01198 int flags;
01199
01200 Mat a, b, c;
01201 double alpha, beta;
01202 Scalar s;
01203 };
01204
01205
01206 CV_EXPORTS MatExpr operator + (const Mat& a, const Mat& b);
01207 CV_EXPORTS MatExpr operator + (const Mat& a, const Scalar& s);
01208 CV_EXPORTS MatExpr operator + (const Scalar& s, const Mat& a);
01209 CV_EXPORTS MatExpr operator + (const MatExpr& e, const Mat& m);
01210 CV_EXPORTS MatExpr operator + (const Mat& m, const MatExpr& e);
01211 CV_EXPORTS MatExpr operator + (const MatExpr& e, const Scalar& s);
01212 CV_EXPORTS MatExpr operator + (const Scalar& s, const MatExpr& e);
01213 CV_EXPORTS MatExpr operator + (const MatExpr& e1, const MatExpr& e2);
01214
01215 CV_EXPORTS MatExpr operator - (const Mat& a, const Mat& b);
01216 CV_EXPORTS MatExpr operator - (const Mat& a, const Scalar& s);
01217 CV_EXPORTS MatExpr operator - (const Scalar& s, const Mat& a);
01218 CV_EXPORTS MatExpr operator - (const MatExpr& e, const Mat& m);
01219 CV_EXPORTS MatExpr operator - (const Mat& m, const MatExpr& e);
01220 CV_EXPORTS MatExpr operator - (const MatExpr& e, const Scalar& s);
01221 CV_EXPORTS MatExpr operator - (const Scalar& s, const MatExpr& e);
01222 CV_EXPORTS MatExpr operator - (const MatExpr& e1, const MatExpr& e2);
01223
01224 CV_EXPORTS MatExpr operator - (const Mat& m);
01225 CV_EXPORTS MatExpr operator - (const MatExpr& e);
01226
01227 CV_EXPORTS MatExpr operator * (const Mat& a, const Mat& b);
01228 CV_EXPORTS MatExpr operator * (const Mat& a, double s);
01229 CV_EXPORTS MatExpr operator * (double s, const Mat& a);
01230 CV_EXPORTS MatExpr operator * (const MatExpr& e, const Mat& m);
01231 CV_EXPORTS MatExpr operator * (const Mat& m, const MatExpr& e);
01232 CV_EXPORTS MatExpr operator * (const MatExpr& e, double s);
01233 CV_EXPORTS MatExpr operator * (double s, const MatExpr& e);
01234 CV_EXPORTS MatExpr operator * (const MatExpr& e1, const MatExpr& e2);
01235
01236 CV_EXPORTS MatExpr operator / (const Mat& a, const Mat& b);
01237 CV_EXPORTS MatExpr operator / (const Mat& a, double s);
01238 CV_EXPORTS MatExpr operator / (double s, const Mat& a);
01239 CV_EXPORTS MatExpr operator / (const MatExpr& e, const Mat& m);
01240 CV_EXPORTS MatExpr operator / (const Mat& m, const MatExpr& e);
01241 CV_EXPORTS MatExpr operator / (const MatExpr& e, double s);
01242 CV_EXPORTS MatExpr operator / (double s, const MatExpr& e);
01243 CV_EXPORTS MatExpr operator / (const MatExpr& e1, const MatExpr& e2);
01244
01245 CV_EXPORTS MatExpr operator < (const Mat& a, const Mat& b);
01246 CV_EXPORTS MatExpr operator < (const Mat& a, double s);
01247 CV_EXPORTS MatExpr operator < (double s, const Mat& a);
01248
01249 CV_EXPORTS MatExpr operator <= (const Mat& a, const Mat& b);
01250 CV_EXPORTS MatExpr operator <= (const Mat& a, double s);
01251 CV_EXPORTS MatExpr operator <= (double s, const Mat& a);
01252
01253 CV_EXPORTS MatExpr operator == (const Mat& a, const Mat& b);
01254 CV_EXPORTS MatExpr operator == (const Mat& a, double s);
01255 CV_EXPORTS MatExpr operator == (double s, const Mat& a);
01256
01257 CV_EXPORTS MatExpr operator != (const Mat& a, const Mat& b);
01258 CV_EXPORTS MatExpr operator != (const Mat& a, double s);
01259 CV_EXPORTS MatExpr operator != (double s, const Mat& a);
01260
01261 CV_EXPORTS MatExpr operator >= (const Mat& a, const Mat& b);
01262 CV_EXPORTS MatExpr operator >= (const Mat& a, double s);
01263 CV_EXPORTS MatExpr operator >= (double s, const Mat& a);
01264
01265 CV_EXPORTS MatExpr operator > (const Mat& a, const Mat& b);
01266 CV_EXPORTS MatExpr operator > (const Mat& a, double s);
01267 CV_EXPORTS MatExpr operator > (double s, const Mat& a);
01268
01269 CV_EXPORTS MatExpr min(const Mat& a, const Mat& b);
01270 CV_EXPORTS MatExpr min(const Mat& a, double s);
01271 CV_EXPORTS MatExpr min(double s, const Mat& a);
01272
01273 CV_EXPORTS MatExpr max(const Mat& a, const Mat& b);
01274 CV_EXPORTS MatExpr max(const Mat& a, double s);
01275 CV_EXPORTS MatExpr max(double s, const Mat& a);
01276
01277 template<typename _Tp> static inline MatExpr min(const Mat_<_Tp>& a, const Mat_<_Tp>& b)
01278 {
01279 return cv::min((const Mat&)a, (const Mat&)b);
01280 }
01281
01282 template<typename _Tp> static inline MatExpr min(const Mat_<_Tp>& a, double s)
01283 {
01284 return cv::min((const Mat&)a, s);
01285 }
01286
01287 template<typename _Tp> static inline MatExpr min(double s, const Mat_<_Tp>& a)
01288 {
01289 return cv::min((const Mat&)a, s);
01290 }
01291
01292 template<typename _Tp> static inline MatExpr max(const Mat_<_Tp>& a, const Mat_<_Tp>& b)
01293 {
01294 return cv::max((const Mat&)a, (const Mat&)b);
01295 }
01296
01297 template<typename _Tp> static inline MatExpr max(const Mat_<_Tp>& a, double s)
01298 {
01299 return cv::max((const Mat&)a, s);
01300 }
01301
01302 template<typename _Tp> static inline MatExpr max(double s, const Mat_<_Tp>& a)
01303 {
01304 return cv::max((const Mat&)a, s);
01305 }
01306
01307 CV_EXPORTS MatExpr operator & (const Mat& a, const Mat& b);
01308 CV_EXPORTS MatExpr operator & (const Mat& a, const Scalar& s);
01309 CV_EXPORTS MatExpr operator & (const Scalar& s, const Mat& a);
01310
01311 CV_EXPORTS MatExpr operator | (const Mat& a, const Mat& b);
01312 CV_EXPORTS MatExpr operator | (const Mat& a, const Scalar& s);
01313 CV_EXPORTS MatExpr operator | (const Scalar& s, const Mat& a);
01314
01315 CV_EXPORTS MatExpr operator ^ (const Mat& a, const Mat& b);
01316 CV_EXPORTS MatExpr operator ^ (const Mat& a, const Scalar& s);
01317 CV_EXPORTS MatExpr operator ^ (const Scalar& s, const Mat& a);
01318
01319 CV_EXPORTS MatExpr operator ~(const Mat& m);
01320
01321 CV_EXPORTS MatExpr abs(const Mat& m);
01322 CV_EXPORTS MatExpr abs(const MatExpr& e);
01323
01324 template<typename _Tp> static inline MatExpr abs(const Mat_<_Tp>& m)
01325 {
01326 return cv::abs((const Mat&)m);
01327 }
01328
01330
01331 inline Mat& Mat::operator = (const MatExpr& e)
01332 {
01333 e.op->assign(e, *this);
01334 return *this;
01335 }
01336
01337 template<typename _Tp> inline Mat_<_Tp>::Mat_(const MatExpr& e)
01338 {
01339 e.op->assign(e, *this, DataType<_Tp>::type);
01340 }
01341
01342 template<typename _Tp> Mat_<_Tp>& Mat_<_Tp>::operator = (const MatExpr& e)
01343 {
01344 e.op->assign(e, *this, DataType<_Tp>::type);
01345 return *this;
01346 }
01347
01348 static inline Mat& operator += (const Mat& a, const Mat& b)
01349 {
01350 add(a, b, (Mat&)a);
01351 return (Mat&)a;
01352 }
01353
01354 static inline Mat& operator += (const Mat& a, const Scalar& s)
01355 {
01356 add(a, s, (Mat&)a);
01357 return (Mat&)a;
01358 }
01359
01360 template<typename _Tp> static inline
01361 Mat_<_Tp>& operator += (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
01362 {
01363 add(a, b, (Mat&)a);
01364 return (Mat_<_Tp>&)a;
01365 }
01366
01367 template<typename _Tp> static inline
01368 Mat_<_Tp>& operator += (const Mat_<_Tp>& a, const Scalar& s)
01369 {
01370 add(a, s, (Mat&)a);
01371 return (Mat_<_Tp>&)a;
01372 }
01373
01374 static inline Mat& operator += (const Mat& a, const MatExpr& b)
01375 {
01376 b.op->augAssignAdd(b, (Mat&)a);
01377 return (Mat&)a;
01378 }
01379
01380 template<typename _Tp> static inline
01381 Mat_<_Tp>& operator += (const Mat_<_Tp>& a, const MatExpr& b)
01382 {
01383 b.op->augAssignAdd(b, (Mat&)a);
01384 return (Mat_<_Tp>&)a;
01385 }
01386
01387 static inline Mat& operator -= (const Mat& a, const Mat& b)
01388 {
01389 subtract(a, b, (Mat&)a);
01390 return (Mat&)a;
01391 }
01392
01393 static inline Mat& operator -= (const Mat& a, const Scalar& s)
01394 {
01395 subtract(a, s, (Mat&)a);
01396 return (Mat&)a;
01397 }
01398
01399 template<typename _Tp> static inline
01400 Mat_<_Tp>& operator -= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
01401 {
01402 subtract(a, b, (Mat&)a);
01403 return (Mat_<_Tp>&)a;
01404 }
01405
01406 template<typename _Tp> static inline
01407 Mat_<_Tp>& operator -= (const Mat_<_Tp>& a, const Scalar& s)
01408 {
01409 subtract(a, s, (Mat&)a);
01410 return (Mat_<_Tp>&)a;
01411 }
01412
01413 static inline Mat& operator -= (const Mat& a, const MatExpr& b)
01414 {
01415 b.op->augAssignSubtract(b, (Mat&)a);
01416 return (Mat&)a;
01417 }
01418
01419 template<typename _Tp> static inline
01420 Mat_<_Tp>& operator -= (const Mat_<_Tp>& a, const MatExpr& b)
01421 {
01422 b.op->augAssignSubtract(b, (Mat&)a);
01423 return (Mat_<_Tp>&)a;
01424 }
01425
01426 static inline Mat& operator *= (const Mat& a, const Mat& b)
01427 {
01428 gemm(a, b, 1, Mat(), 0, (Mat&)a, 0);
01429 return (Mat&)a;
01430 }
01431
01432 static inline Mat& operator *= (const Mat& a, double s)
01433 {
01434 a.convertTo((Mat&)a, -1, s);
01435 return (Mat&)a;
01436 }
01437
01438 template<typename _Tp> static inline
01439 Mat_<_Tp>& operator *= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
01440 {
01441 gemm(a, b, 1, Mat(), 0, (Mat&)a, 0);
01442 return (Mat_<_Tp>&)a;
01443 }
01444
01445 template<typename _Tp> static inline
01446 Mat_<_Tp>& operator *= (const Mat_<_Tp>& a, double s)
01447 {
01448 a.convertTo((Mat&)a, -1, s);
01449 return (Mat_<_Tp>&)a;
01450 }
01451
01452 static inline Mat& operator *= (const Mat& a, const MatExpr& b)
01453 {
01454 b.op->augAssignMultiply(b, (Mat&)a);
01455 return (Mat&)a;
01456 }
01457
01458 template<typename _Tp> static inline
01459 Mat_<_Tp>& operator *= (const Mat_<_Tp>& a, const MatExpr& b)
01460 {
01461 b.op->augAssignMultiply(b, (Mat&)a);
01462 return (Mat_<_Tp>&)a;
01463 }
01464
01465 static inline Mat& operator /= (const Mat& a, const Mat& b)
01466 {
01467 divide(a, b, (Mat&)a);
01468 return (Mat&)a;
01469 }
01470
01471 static inline Mat& operator /= (const Mat& a, double s)
01472 {
01473 a.convertTo((Mat&)a, -1, 1./s);
01474 return (Mat&)a;
01475 }
01476
01477 template<typename _Tp> static inline
01478 Mat_<_Tp>& operator /= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
01479 {
01480 divide(a, b, (Mat&)a);
01481 return (Mat_<_Tp>&)a;
01482 }
01483
01484 template<typename _Tp> static inline
01485 Mat_<_Tp>& operator /= (const Mat_<_Tp>& a, double s)
01486 {
01487 a.convertTo((Mat&)a, -1, 1./s);
01488 return (Mat_<_Tp>&)a;
01489 }
01490
01491 static inline Mat& operator /= (const Mat& a, const MatExpr& b)
01492 {
01493 b.op->augAssignDivide(b, (Mat&)a);
01494 return (Mat&)a;
01495 }
01496
01497 template<typename _Tp> static inline
01498 Mat_<_Tp>& operator /= (const Mat_<_Tp>& a, const MatExpr& b)
01499 {
01500 b.op->augAssignDivide(b, (Mat&)a);
01501 return (Mat_<_Tp>&)a;
01502 }
01503
01505
01506 static inline Mat& operator &= (const Mat& a, const Mat& b)
01507 {
01508 bitwise_and(a, b, (Mat&)a);
01509 return (Mat&)a;
01510 }
01511
01512 static inline Mat& operator &= (const Mat& a, const Scalar& s)
01513 {
01514 bitwise_and(a, s, (Mat&)a);
01515 return (Mat&)a;
01516 }
01517
01518 template<typename _Tp> static inline Mat_<_Tp>&
01519 operator &= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
01520 {
01521 bitwise_and(a, b, (Mat&)a);
01522 return (Mat_<_Tp>&)a;
01523 }
01524
01525 template<typename _Tp> static inline Mat_<_Tp>&
01526 operator &= (const Mat_<_Tp>& a, const Scalar& s)
01527 {
01528 bitwise_and(a, s, (Mat&)a);
01529 return (Mat_<_Tp>&)a;
01530 }
01531
01532 static inline Mat& operator |= (const Mat& a, const Mat& b)
01533 {
01534 bitwise_or(a, b, (Mat&)a);
01535 return (Mat&)a;
01536 }
01537
01538 static inline Mat& operator |= (const Mat& a, const Scalar& s)
01539 {
01540 bitwise_or(a, s, (Mat&)a);
01541 return (Mat&)a;
01542 }
01543
01544 template<typename _Tp> static inline Mat_<_Tp>&
01545 operator |= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
01546 {
01547 bitwise_or(a, b, (Mat&)a);
01548 return (Mat_<_Tp>&)a;
01549 }
01550
01551 template<typename _Tp> static inline Mat_<_Tp>&
01552 operator |= (const Mat_<_Tp>& a, const Scalar& s)
01553 {
01554 bitwise_or(a, s, (Mat&)a);
01555 return (Mat_<_Tp>&)a;
01556 }
01557
01558 static inline Mat& operator ^= (const Mat& a, const Mat& b)
01559 {
01560 bitwise_xor(a, b, (Mat&)a);
01561 return (Mat&)a;
01562 }
01563
01564 static inline Mat& operator ^= (const Mat& a, const Scalar& s)
01565 {
01566 bitwise_xor(a, s, (Mat&)a);
01567 return (Mat&)a;
01568 }
01569
01570 template<typename _Tp> static inline Mat_<_Tp>&
01571 operator ^= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
01572 {
01573 bitwise_xor(a, b, (Mat&)a);
01574 return (Mat_<_Tp>&)a;
01575 }
01576
01577 template<typename _Tp> static inline Mat_<_Tp>&
01578 operator ^= (const Mat_<_Tp>& a, const Scalar& s)
01579 {
01580 bitwise_xor(a, s, (Mat&)a);
01581 return (Mat_<_Tp>&)a;
01582 }
01583
01585
01586 template<typename _Tp> void split(const Mat& src, vector<Mat_<_Tp> >& mv)
01587 { split(src, (vector<Mat>&)mv ); }
01588
01590
01591 template<typename _Tp> inline MatExpr Mat_<_Tp>::zeros(int rows, int cols)
01592 {
01593 return Mat::zeros(rows, cols, DataType<_Tp>::type);
01594 }
01595
01596 template<typename _Tp> inline MatExpr Mat_<_Tp>::zeros(Size sz)
01597 {
01598 return Mat::zeros(sz, DataType<_Tp>::type);
01599 }
01600
01601 template<typename _Tp> inline MatExpr Mat_<_Tp>::ones(int rows, int cols)
01602 {
01603 return Mat::ones(rows, cols, DataType<_Tp>::type);
01604 }
01605
01606 template<typename _Tp> inline MatExpr Mat_<_Tp>::ones(Size sz)
01607 {
01608 return Mat::ones(sz, DataType<_Tp>::type);
01609 }
01610
01611 template<typename _Tp> inline MatExpr Mat_<_Tp>::eye(int rows, int cols)
01612 {
01613 return Mat::eye(rows, cols, DataType<_Tp>::type);
01614 }
01615
01616 template<typename _Tp> inline MatExpr Mat_<_Tp>::eye(Size sz)
01617 {
01618 return Mat::eye(sz, DataType<_Tp>::type);
01619 }
01620
01622
01623 inline MatConstIterator::MatConstIterator()
01624 : m(0), elemSize(0), ptr(0), sliceStart(0), sliceEnd(0) {}
01625
01626 inline MatConstIterator::MatConstIterator(const Mat* _m)
01627 : m(_m), elemSize(_m->elemSize()), ptr(0), sliceStart(0), sliceEnd(0)
01628 {
01629 if( m && m->isContinuous() )
01630 {
01631 sliceStart = m->data;
01632 sliceEnd = sliceStart + m->total()*elemSize;
01633 }
01634 seek((const int*)0);
01635 }
01636
01637 inline MatConstIterator::MatConstIterator(const Mat* _m, int _row, int _col)
01638 : m(_m), elemSize(_m->elemSize()), ptr(0), sliceStart(0), sliceEnd(0)
01639 {
01640 CV_Assert(m && m->dims <= 2);
01641 if( m->isContinuous() )
01642 {
01643 sliceStart = m->data;
01644 sliceEnd = sliceStart + m->total()*elemSize;
01645 }
01646 int idx[]={_row, _col};
01647 seek(idx);
01648 }
01649
01650 inline MatConstIterator::MatConstIterator(const Mat* _m, Point _pt)
01651 : m(_m), elemSize(_m->elemSize()), ptr(0), sliceStart(0), sliceEnd(0)
01652 {
01653 CV_Assert(m && m->dims <= 2);
01654 if( m->isContinuous() )
01655 {
01656 sliceStart = m->data;
01657 sliceEnd = sliceStart + m->total()*elemSize;
01658 }
01659 int idx[]={_pt.y, _pt.x};
01660 seek(idx);
01661 }
01662
01663 inline MatConstIterator::MatConstIterator(const MatConstIterator& it)
01664 : m(it.m), elemSize(it.elemSize), ptr(it.ptr), sliceStart(it.sliceStart), sliceEnd(it.sliceEnd)
01665 {}
01666
01667 inline MatConstIterator& MatConstIterator::operator = (const MatConstIterator& it )
01668 {
01669 m = it.m; elemSize = it.elemSize; ptr = it.ptr;
01670 sliceStart = it.sliceStart; sliceEnd = it.sliceEnd;
01671 return *this;
01672 }
01673
01674 inline uchar* MatConstIterator::operator *() const { return ptr; }
01675
01676 inline MatConstIterator& MatConstIterator::operator += (ptrdiff_t ofs)
01677 {
01678 if( !m || ofs == 0 )
01679 return *this;
01680 ptrdiff_t ofsb = ofs*elemSize;
01681 ptr += ofsb;
01682 if( ptr < sliceStart || sliceEnd <= ptr )
01683 {
01684 ptr -= ofsb;
01685 seek(ofs, true);
01686 }
01687 return *this;
01688 }
01689
01690 inline MatConstIterator& MatConstIterator::operator -= (ptrdiff_t ofs)
01691 { return (*this += -ofs); }
01692
01693 inline MatConstIterator& MatConstIterator::operator --()
01694 {
01695 if( m && (ptr -= elemSize) < sliceStart )
01696 {
01697 ptr += elemSize;
01698 seek(-1, true);
01699 }
01700 return *this;
01701 }
01702
01703 inline MatConstIterator MatConstIterator::operator --(int)
01704 {
01705 MatConstIterator b = *this;
01706 *this += -1;
01707 return b;
01708 }
01709
01710 inline MatConstIterator& MatConstIterator::operator ++()
01711 {
01712 if( m && (ptr += elemSize) >= sliceEnd )
01713 {
01714 ptr -= elemSize;
01715 seek(1, true);
01716 }
01717 return *this;
01718 }
01719
01720 inline MatConstIterator MatConstIterator::operator ++(int)
01721 {
01722 MatConstIterator b = *this;
01723 *this += 1;
01724 return b;
01725 }
01726
01727 template<typename _Tp> inline MatConstIterator_<_Tp>::MatConstIterator_() {}
01728
01729 template<typename _Tp> inline MatConstIterator_<_Tp>::MatConstIterator_(const Mat_<_Tp>* _m)
01730 : MatConstIterator(_m) {}
01731
01732 template<typename _Tp> inline MatConstIterator_<_Tp>::
01733 MatConstIterator_(const Mat_<_Tp>* _m, int _row, int _col)
01734 : MatConstIterator(_m, _row, _col) {}
01735
01736 template<typename _Tp> inline MatConstIterator_<_Tp>::
01737 MatConstIterator_(const Mat_<_Tp>* _m, Point _pt)
01738 : MatConstIterator(_m, _pt) {}
01739
01740 template<typename _Tp> inline MatConstIterator_<_Tp>::
01741 MatConstIterator_(const MatConstIterator_& it)
01742 : MatConstIterator(it) {}
01743
01744 template<typename _Tp> inline MatConstIterator_<_Tp>&
01745 MatConstIterator_<_Tp>::operator = (const MatConstIterator_& it )
01746 {
01747 MatConstIterator::operator = (it);
01748 return *this;
01749 }
01750
01751 template<typename _Tp> inline _Tp MatConstIterator_<_Tp>::operator *() const { return *(_Tp*)(this->ptr); }
01752
01753 template<typename _Tp> inline MatConstIterator_<_Tp>& MatConstIterator_<_Tp>::operator += (ptrdiff_t ofs)
01754 {
01755 MatConstIterator::operator += (ofs);
01756 return *this;
01757 }
01758
01759 template<typename _Tp> inline MatConstIterator_<_Tp>& MatConstIterator_<_Tp>::operator -= (ptrdiff_t ofs)
01760 { return (*this += -ofs); }
01761
01762 template<typename _Tp> inline MatConstIterator_<_Tp>& MatConstIterator_<_Tp>::operator --()
01763 {
01764 MatConstIterator::operator --();
01765 return *this;
01766 }
01767
01768 template<typename _Tp> inline MatConstIterator_<_Tp> MatConstIterator_<_Tp>::operator --(int)
01769 {
01770 MatConstIterator_ b = *this;
01771 MatConstIterator::operator --();
01772 return b;
01773 }
01774
01775 template<typename _Tp> inline MatConstIterator_<_Tp>& MatConstIterator_<_Tp>::operator ++()
01776 {
01777 MatConstIterator::operator ++();
01778 return *this;
01779 }
01780
01781 template<typename _Tp> inline MatConstIterator_<_Tp> MatConstIterator_<_Tp>::operator ++(int)
01782 {
01783 MatConstIterator_ b = *this;
01784 MatConstIterator::operator ++();
01785 return b;
01786 }
01787
01788 template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_() : MatConstIterator_<_Tp>() {}
01789
01790 template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(Mat_<_Tp>* _m)
01791 : MatConstIterator_<_Tp>(_m) {}
01792
01793 template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(Mat_<_Tp>* _m, int _row, int _col)
01794 : MatConstIterator_<_Tp>(_m, _row, _col) {}
01795
01796 template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(const Mat_<_Tp>* _m, Point _pt)
01797 : MatConstIterator_<_Tp>(_m, _pt) {}
01798
01799 template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(const Mat_<_Tp>* _m, const int* _idx)
01800 : MatConstIterator_<_Tp>(_m, _idx) {}
01801
01802 template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(const MatIterator_& it)
01803 : MatConstIterator_<_Tp>(it) {}
01804
01805 template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator = (const MatIterator_<_Tp>& it )
01806 {
01807 MatConstIterator::operator = (it);
01808 return *this;
01809 }
01810
01811 template<typename _Tp> inline _Tp& MatIterator_<_Tp>::operator *() const { return *(_Tp*)(this->ptr); }
01812
01813 template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator += (ptrdiff_t ofs)
01814 {
01815 MatConstIterator::operator += (ofs);
01816 return *this;
01817 }
01818
01819 template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator -= (ptrdiff_t ofs)
01820 {
01821 MatConstIterator::operator += (-ofs);
01822 return *this;
01823 }
01824
01825 template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator --()
01826 {
01827 MatConstIterator::operator --();
01828 return *this;
01829 }
01830
01831 template<typename _Tp> inline MatIterator_<_Tp> MatIterator_<_Tp>::operator --(int)
01832 {
01833 MatIterator_ b = *this;
01834 MatConstIterator::operator --();
01835 return b;
01836 }
01837
01838 template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator ++()
01839 {
01840 MatConstIterator::operator ++();
01841 return *this;
01842 }
01843
01844 template<typename _Tp> inline MatIterator_<_Tp> MatIterator_<_Tp>::operator ++(int)
01845 {
01846 MatIterator_ b = *this;
01847 MatConstIterator::operator ++();
01848 return b;
01849 }
01850
01851 template<typename _Tp> inline Point MatConstIterator_<_Tp>::pos() const
01852 {
01853 if( !m )
01854 return Point();
01855 CV_DbgAssert( m->dims <= 2 );
01856 if( m->isContinuous() )
01857 {
01858 ptrdiff_t ofs = (const _Tp*)ptr - (const _Tp*)m->data;
01859 int y = (int)(ofs / m->cols), x = (int)(ofs - (ptrdiff_t)y*m->cols);
01860 return Point(x, y);
01861 }
01862 else
01863 {
01864 ptrdiff_t ofs = (uchar*)ptr - m->data;
01865 int y = (int)(ofs / m->step), x = (int)((ofs - y*m->step)/sizeof(_Tp));
01866 return Point(x, y);
01867 }
01868 }
01869
01870 static inline bool
01871 operator == (const MatConstIterator& a, const MatConstIterator& b)
01872 { return a.m == b.m && a.ptr == b.ptr; }
01873
01874 template<typename _Tp> static inline bool
01875 operator != (const MatConstIterator& a, const MatConstIterator& b)
01876 { return !(a == b); }
01877
01878 template<typename _Tp> static inline bool
01879 operator == (const MatConstIterator_<_Tp>& a, const MatConstIterator_<_Tp>& b)
01880 { return a.m == b.m && a.ptr == b.ptr; }
01881
01882 template<typename _Tp> static inline bool
01883 operator != (const MatConstIterator_<_Tp>& a, const MatConstIterator_<_Tp>& b)
01884 { return a.m != b.m || a.ptr != b.ptr; }
01885
01886 template<typename _Tp> static inline bool
01887 operator == (const MatIterator_<_Tp>& a, const MatIterator_<_Tp>& b)
01888 { return a.m == b.m && a.ptr == b.ptr; }
01889
01890 template<typename _Tp> static inline bool
01891 operator != (const MatIterator_<_Tp>& a, const MatIterator_<_Tp>& b)
01892 { return a.m != b.m || a.ptr != b.ptr; }
01893
01894 static inline bool
01895 operator < (const MatConstIterator& a, const MatConstIterator& b)
01896 { return a.ptr < b.ptr; }
01897
01898 static inline bool
01899 operator > (const MatConstIterator& a, const MatConstIterator& b)
01900 { return a.ptr > b.ptr; }
01901
01902 static inline bool
01903 operator <= (const MatConstIterator& a, const MatConstIterator& b)
01904 { return a.ptr <= b.ptr; }
01905
01906 static inline bool
01907 operator >= (const MatConstIterator& a, const MatConstIterator& b)
01908 { return a.ptr >= b.ptr; }
01909
01910 CV_EXPORTS ptrdiff_t operator - (const MatConstIterator& b, const MatConstIterator& a);
01911
01912 static inline MatConstIterator operator + (const MatConstIterator& a, ptrdiff_t ofs)
01913 { MatConstIterator b = a; return b += ofs; }
01914
01915 static inline MatConstIterator operator + (ptrdiff_t ofs, const MatConstIterator& a)
01916 { MatConstIterator b = a; return b += ofs; }
01917
01918 static inline MatConstIterator operator - (const MatConstIterator& a, ptrdiff_t ofs)
01919 { MatConstIterator b = a; return b += -ofs; }
01920
01921 template<typename _Tp> static inline MatConstIterator_<_Tp>
01922 operator + (const MatConstIterator_<_Tp>& a, ptrdiff_t ofs)
01923 { MatConstIterator t = (const MatConstIterator&)a + ofs; return (MatConstIterator_<_Tp>&)t; }
01924
01925 template<typename _Tp> static inline MatConstIterator_<_Tp>
01926 operator + (ptrdiff_t ofs, const MatConstIterator_<_Tp>& a)
01927 { MatConstIterator t = (const MatConstIterator&)a + ofs; return (MatConstIterator_<_Tp>&)t; }
01928
01929 template<typename _Tp> static inline MatConstIterator_<_Tp>
01930 operator - (const MatConstIterator_<_Tp>& a, ptrdiff_t ofs)
01931 { MatConstIterator t = (const MatConstIterator&)a - ofs; return (MatConstIterator_<_Tp>&)t; }
01932
01933 inline uchar* MatConstIterator::operator [](ptrdiff_t i) const
01934 { return *(*this + i); }
01935
01936 template<typename _Tp> inline _Tp MatConstIterator_<_Tp>::operator [](ptrdiff_t i) const
01937 { return *(_Tp*)MatConstIterator::operator [](i); }
01938
01939 template<typename _Tp> static inline MatIterator_<_Tp>
01940 operator + (const MatIterator_<_Tp>& a, ptrdiff_t ofs)
01941 { MatConstIterator t = (const MatConstIterator&)a + ofs; return (MatIterator_<_Tp>&)t; }
01942
01943 template<typename _Tp> static inline MatIterator_<_Tp>
01944 operator + (ptrdiff_t ofs, const MatIterator_<_Tp>& a)
01945 { MatConstIterator t = (const MatConstIterator&)a + ofs; return (MatIterator_<_Tp>&)t; }
01946
01947 template<typename _Tp> static inline MatIterator_<_Tp>
01948 operator - (const MatIterator_<_Tp>& a, ptrdiff_t ofs)
01949 { MatConstIterator t = (const MatConstIterator&)a - ofs; return (MatIterator_<_Tp>&)t; }
01950
01951 template<typename _Tp> inline _Tp& MatIterator_<_Tp>::operator [](ptrdiff_t i) const
01952 { return *(*this + i); }
01953
01954 template<typename _Tp> inline MatConstIterator_<_Tp> Mat_<_Tp>::begin() const
01955 { return Mat::begin<_Tp>(); }
01956
01957 template<typename _Tp> inline MatConstIterator_<_Tp> Mat_<_Tp>::end() const
01958 { return Mat::end<_Tp>(); }
01959
01960 template<typename _Tp> inline MatIterator_<_Tp> Mat_<_Tp>::begin()
01961 { return Mat::begin<_Tp>(); }
01962
01963 template<typename _Tp> inline MatIterator_<_Tp> Mat_<_Tp>::end()
01964 { return Mat::end<_Tp>(); }
01965
01966 template<typename _Tp> inline MatCommaInitializer_<_Tp>::MatCommaInitializer_(Mat_<_Tp>* _m) : it(_m) {}
01967
01968 template<typename _Tp> template<typename T2> inline MatCommaInitializer_<_Tp>&
01969 MatCommaInitializer_<_Tp>::operator , (T2 v)
01970 {
01971 CV_DbgAssert( this->it < ((const Mat_<_Tp>*)this->it.m)->end() );
01972 *this->it = _Tp(v); ++this->it;
01973 return *this;
01974 }
01975
01976 template<typename _Tp> inline Mat_<_Tp> MatCommaInitializer_<_Tp>::operator *() const
01977 {
01978 CV_DbgAssert( this->it == ((const Mat_<_Tp>*)this->it.m)->end() );
01979 return Mat_<_Tp>(*this->it.m);
01980 }
01981
01982 template<typename _Tp> inline MatCommaInitializer_<_Tp>::operator Mat_<_Tp>() const
01983 {
01984 CV_DbgAssert( this->it == ((const Mat_<_Tp>*)this->it.m)->end() );
01985 return Mat_<_Tp>(*this->it.m);
01986 }
01987
01988 template<typename _Tp, typename T2> static inline MatCommaInitializer_<_Tp>
01989 operator << (const Mat_<_Tp>& m, T2 val)
01990 {
01991 MatCommaInitializer_<_Tp> commaInitializer((Mat_<_Tp>*)&m);
01992 return (commaInitializer, val);
01993 }
01994
01996
01997 inline SparseMat::SparseMat()
01998 : flags(MAGIC_VAL), hdr(0)
01999 {
02000 }
02001
02002 inline SparseMat::SparseMat(int _dims, const int* _sizes, int _type)
02003 : flags(MAGIC_VAL), hdr(0)
02004 {
02005 create(_dims, _sizes, _type);
02006 }
02007
02008 inline SparseMat::SparseMat(const SparseMat& m)
02009 : flags(m.flags), hdr(m.hdr)
02010 {
02011 addref();
02012 }
02013
02014 inline SparseMat::~SparseMat()
02015 {
02016 release();
02017 }
02018
02019 inline SparseMat& SparseMat::operator = (const SparseMat& m)
02020 {
02021 if( this != &m )
02022 {
02023 if( m.hdr )
02024 CV_XADD(&m.hdr->refcount, 1);
02025 release();
02026 flags = m.flags;
02027 hdr = m.hdr;
02028 }
02029 return *this;
02030 }
02031
02032 inline SparseMat& SparseMat::operator = (const Mat& m)
02033 { return (*this = SparseMat(m)); }
02034
02035 inline SparseMat SparseMat::clone() const
02036 {
02037 SparseMat temp;
02038 this->copyTo(temp);
02039 return temp;
02040 }
02041
02042
02043 inline void SparseMat::assignTo( SparseMat& m, int type ) const
02044 {
02045 if( type < 0 )
02046 m = *this;
02047 else
02048 convertTo(m, type);
02049 }
02050
02051 inline void SparseMat::addref()
02052 { if( hdr ) CV_XADD(&hdr->refcount, 1); }
02053
02054 inline void SparseMat::release()
02055 {
02056 if( hdr && CV_XADD(&hdr->refcount, -1) == 1 )
02057 delete hdr;
02058 hdr = 0;
02059 }
02060
02061 inline size_t SparseMat::elemSize() const
02062 { return CV_ELEM_SIZE(flags); }
02063
02064 inline size_t SparseMat::elemSize1() const
02065 { return CV_ELEM_SIZE1(flags); }
02066
02067 inline int SparseMat::type() const
02068 { return CV_MAT_TYPE(flags); }
02069
02070 inline int SparseMat::depth() const
02071 { return CV_MAT_DEPTH(flags); }
02072
02073 inline int SparseMat::channels() const
02074 { return CV_MAT_CN(flags); }
02075
02076 inline const int* SparseMat::size() const
02077 {
02078 return hdr ? hdr->size : 0;
02079 }
02080
02081 inline int SparseMat::size(int i) const
02082 {
02083 if( hdr )
02084 {
02085 CV_DbgAssert((unsigned)i < (unsigned)hdr->dims);
02086 return hdr->size[i];
02087 }
02088 return 0;
02089 }
02090
02091 inline int SparseMat::dims() const
02092 {
02093 return hdr ? hdr->dims : 0;
02094 }
02095
02096 inline size_t SparseMat::nzcount() const
02097 {
02098 return hdr ? hdr->nodeCount : 0;
02099 }
02100
02101 inline size_t SparseMat::hash(int i0) const
02102 {
02103 return (size_t)i0;
02104 }
02105
02106 inline size_t SparseMat::hash(int i0, int i1) const
02107 {
02108 return (size_t)(unsigned)i0*HASH_SCALE + (unsigned)i1;
02109 }
02110
02111 inline size_t SparseMat::hash(int i0, int i1, int i2) const
02112 {
02113 return ((size_t)(unsigned)i0*HASH_SCALE + (unsigned)i1)*HASH_SCALE + (unsigned)i2;
02114 }
02115
02116 inline size_t SparseMat::hash(const int* idx) const
02117 {
02118 size_t h = (unsigned)idx[0];
02119 if( !hdr )
02120 return 0;
02121 int i, d = hdr->dims;
02122 for( i = 1; i < d; i++ )
02123 h = h*HASH_SCALE + (unsigned)idx[i];
02124 return h;
02125 }
02126
02127 template<typename _Tp> inline _Tp& SparseMat::ref(int i0, size_t* hashval)
02128 { return *(_Tp*)((SparseMat*)this)->ptr(i0, true, hashval); }
02129
02130 template<typename _Tp> inline _Tp& SparseMat::ref(int i0, int i1, size_t* hashval)
02131 { return *(_Tp*)((SparseMat*)this)->ptr(i0, i1, true, hashval); }
02132
02133 template<typename _Tp> inline _Tp& SparseMat::ref(int i0, int i1, int i2, size_t* hashval)
02134 { return *(_Tp*)((SparseMat*)this)->ptr(i0, i1, i2, true, hashval); }
02135
02136 template<typename _Tp> inline _Tp& SparseMat::ref(const int* idx, size_t* hashval)
02137 { return *(_Tp*)((SparseMat*)this)->ptr(idx, true, hashval); }
02138
02139 template<typename _Tp> inline _Tp SparseMat::value(int i0, size_t* hashval) const
02140 {
02141 const _Tp* p = (const _Tp*)((SparseMat*)this)->ptr(i0, false, hashval);
02142 return p ? *p : _Tp();
02143 }
02144
02145 template<typename _Tp> inline _Tp SparseMat::value(int i0, int i1, size_t* hashval) const
02146 {
02147 const _Tp* p = (const _Tp*)((SparseMat*)this)->ptr(i0, i1, false, hashval);
02148 return p ? *p : _Tp();
02149 }
02150
02151 template<typename _Tp> inline _Tp SparseMat::value(int i0, int i1, int i2, size_t* hashval) const
02152 {
02153 const _Tp* p = (const _Tp*)((SparseMat*)this)->ptr(i0, i1, i2, false, hashval);
02154 return p ? *p : _Tp();
02155 }
02156
02157 template<typename _Tp> inline _Tp SparseMat::value(const int* idx, size_t* hashval) const
02158 {
02159 const _Tp* p = (const _Tp*)((SparseMat*)this)->ptr(idx, false, hashval);
02160 return p ? *p : _Tp();
02161 }
02162
02163 template<typename _Tp> inline const _Tp* SparseMat::find(int i0, size_t* hashval) const
02164 { return (const _Tp*)((SparseMat*)this)->ptr(i0, false, hashval); }
02165
02166 template<typename _Tp> inline const _Tp* SparseMat::find(int i0, int i1, size_t* hashval) const
02167 { return (const _Tp*)((SparseMat*)this)->ptr(i0, i1, false, hashval); }
02168
02169 template<typename _Tp> inline const _Tp* SparseMat::find(int i0, int i1, int i2, size_t* hashval) const
02170 { return (const _Tp*)((SparseMat*)this)->ptr(i0, i1, i2, false, hashval); }
02171
02172 template<typename _Tp> inline const _Tp* SparseMat::find(const int* idx, size_t* hashval) const
02173 { return (const _Tp*)((SparseMat*)this)->ptr(idx, false, hashval); }
02174
02175 template<typename _Tp> inline _Tp& SparseMat::value(Node* n)
02176 { return *(_Tp*)((uchar*)n + hdr->valueOffset); }
02177
02178 template<typename _Tp> inline const _Tp& SparseMat::value(const Node* n) const
02179 { return *(const _Tp*)((const uchar*)n + hdr->valueOffset); }
02180
02181 inline SparseMat::Node* SparseMat::node(size_t nidx)
02182 { return (Node*)&hdr->pool[nidx]; }
02183
02184 inline const SparseMat::Node* SparseMat::node(size_t nidx) const
02185 { return (const Node*)&hdr->pool[nidx]; }
02186
02187 inline SparseMatIterator SparseMat::begin()
02188 { return SparseMatIterator(this); }
02189
02190 inline SparseMatConstIterator SparseMat::begin() const
02191 { return SparseMatConstIterator(this); }
02192
02193 inline SparseMatIterator SparseMat::end()
02194 { SparseMatIterator it(this); it.seekEnd(); return it; }
02195
02196 inline SparseMatConstIterator SparseMat::end() const
02197 { SparseMatConstIterator it(this); it.seekEnd(); return it; }
02198
02199 template<typename _Tp> inline SparseMatIterator_<_Tp> SparseMat::begin()
02200 { return SparseMatIterator_<_Tp>(this); }
02201
02202 template<typename _Tp> inline SparseMatConstIterator_<_Tp> SparseMat::begin() const
02203 { return SparseMatConstIterator_<_Tp>(this); }
02204
02205 template<typename _Tp> inline SparseMatIterator_<_Tp> SparseMat::end()
02206 { SparseMatIterator_<_Tp> it(this); it.seekEnd(); return it; }
02207
02208 template<typename _Tp> inline SparseMatConstIterator_<_Tp> SparseMat::end() const
02209 { SparseMatConstIterator_<_Tp> it(this); it.seekEnd(); return it; }
02210
02211
02212 inline SparseMatConstIterator::SparseMatConstIterator()
02213 : m(0), hashidx(0), ptr(0)
02214 {
02215 }
02216
02217 inline SparseMatConstIterator::SparseMatConstIterator(const SparseMatConstIterator& it)
02218 : m(it.m), hashidx(it.hashidx), ptr(it.ptr)
02219 {
02220 }
02221
02222 static inline bool operator == (const SparseMatConstIterator& it1, const SparseMatConstIterator& it2)
02223 { return it1.m == it2.m && it1.hashidx == it2.hashidx && it1.ptr == it2.ptr; }
02224
02225 static inline bool operator != (const SparseMatConstIterator& it1, const SparseMatConstIterator& it2)
02226 { return !(it1 == it2); }
02227
02228
02229 inline SparseMatConstIterator& SparseMatConstIterator::operator = (const SparseMatConstIterator& it)
02230 {
02231 if( this != &it )
02232 {
02233 m = it.m;
02234 hashidx = it.hashidx;
02235 ptr = it.ptr;
02236 }
02237 return *this;
02238 }
02239
02240 template<typename _Tp> inline const _Tp& SparseMatConstIterator::value() const
02241 { return *(_Tp*)ptr; }
02242
02243 inline const SparseMat::Node* SparseMatConstIterator::node() const
02244 {
02245 return ptr && m && m->hdr ?
02246 (const SparseMat::Node*)(ptr - m->hdr->valueOffset) : 0;
02247 }
02248
02249 inline SparseMatConstIterator SparseMatConstIterator::operator ++(int)
02250 {
02251 SparseMatConstIterator it = *this;
02252 ++*this;
02253 return it;
02254 }
02255
02256
02257 inline void SparseMatConstIterator::seekEnd()
02258 {
02259 if( m && m->hdr )
02260 {
02261 hashidx = m->hdr->hashtab.size();
02262 ptr = 0;
02263 }
02264 }
02265
02266 inline SparseMatIterator::SparseMatIterator()
02267 {}
02268
02269 inline SparseMatIterator::SparseMatIterator(SparseMat* _m)
02270 : SparseMatConstIterator(_m)
02271 {}
02272
02273 inline SparseMatIterator::SparseMatIterator(const SparseMatIterator& it)
02274 : SparseMatConstIterator(it)
02275 {
02276 }
02277
02278 inline SparseMatIterator& SparseMatIterator::operator = (const SparseMatIterator& it)
02279 {
02280 (SparseMatConstIterator&)*this = it;
02281 return *this;
02282 }
02283
02284 template<typename _Tp> inline _Tp& SparseMatIterator::value() const
02285 { return *(_Tp*)ptr; }
02286
02287 inline SparseMat::Node* SparseMatIterator::node() const
02288 {
02289 return (SparseMat::Node*)SparseMatConstIterator::node();
02290 }
02291
02292 inline SparseMatIterator& SparseMatIterator::operator ++()
02293 {
02294 SparseMatConstIterator::operator ++();
02295 return *this;
02296 }
02297
02298 inline SparseMatIterator SparseMatIterator::operator ++(int)
02299 {
02300 SparseMatIterator it = *this;
02301 ++*this;
02302 return it;
02303 }
02304
02305
02306 template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_()
02307 { flags = MAGIC_VAL | DataType<_Tp>::type; }
02308
02309 template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(int _dims, const int* _sizes)
02310 : SparseMat(_dims, _sizes, DataType<_Tp>::type)
02311 {}
02312
02313 template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const SparseMat& m)
02314 {
02315 if( m.type() == DataType<_Tp>::type )
02316 *this = (const SparseMat_<_Tp>&)m;
02317 else
02318 m.convertTo(this, DataType<_Tp>::type);
02319 }
02320
02321 template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const SparseMat_<_Tp>& m)
02322 {
02323 this->flags = m.flags;
02324 this->hdr = m.hdr;
02325 if( this->hdr )
02326 CV_XADD(&this->hdr->refcount, 1);
02327 }
02328
02329 template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const Mat& m)
02330 {
02331 SparseMat sm(m);
02332 *this = sm;
02333 }
02334
02335 template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const CvSparseMat* m)
02336 {
02337 SparseMat sm(m);
02338 *this = sm;
02339 }
02340
02341 template<typename _Tp> inline SparseMat_<_Tp>&
02342 SparseMat_<_Tp>::operator = (const SparseMat_<_Tp>& m)
02343 {
02344 if( this != &m )
02345 {
02346 if( m.hdr ) CV_XADD(&m.hdr->refcount, 1);
02347 release();
02348 flags = m.flags;
02349 hdr = m.hdr;
02350 }
02351 return *this;
02352 }
02353
02354 template<typename _Tp> inline SparseMat_<_Tp>&
02355 SparseMat_<_Tp>::operator = (const SparseMat& m)
02356 {
02357 if( m.type() == DataType<_Tp>::type )
02358 return (*this = (const SparseMat_<_Tp>&)m);
02359 m.convertTo(*this, DataType<_Tp>::type);
02360 return *this;
02361 }
02362
02363 template<typename _Tp> inline SparseMat_<_Tp>&
02364 SparseMat_<_Tp>::operator = (const Mat& m)
02365 { return (*this = SparseMat(m)); }
02366
02367 template<typename _Tp> inline SparseMat_<_Tp>
02368 SparseMat_<_Tp>::clone() const
02369 {
02370 SparseMat_<_Tp> m;
02371 this->copyTo(m);
02372 return m;
02373 }
02374
02375 template<typename _Tp> inline void
02376 SparseMat_<_Tp>::create(int _dims, const int* _sizes)
02377 {
02378 SparseMat::create(_dims, _sizes, DataType<_Tp>::type);
02379 }
02380
02381 template<typename _Tp> inline
02382 SparseMat_<_Tp>::operator CvSparseMat*() const
02383 {
02384 return SparseMat::operator CvSparseMat*();
02385 }
02386
02387 template<typename _Tp> inline int SparseMat_<_Tp>::type() const
02388 { return DataType<_Tp>::type; }
02389
02390 template<typename _Tp> inline int SparseMat_<_Tp>::depth() const
02391 { return DataType<_Tp>::depth; }
02392
02393 template<typename _Tp> inline int SparseMat_<_Tp>::channels() const
02394 { return DataType<_Tp>::channels; }
02395
02396 template<typename _Tp> inline _Tp&
02397 SparseMat_<_Tp>::ref(int i0, size_t* hashval)
02398 { return SparseMat::ref<_Tp>(i0, hashval); }
02399
02400 template<typename _Tp> inline _Tp
02401 SparseMat_<_Tp>::operator()(int i0, size_t* hashval) const
02402 { return SparseMat::value<_Tp>(i0, hashval); }
02403
02404 template<typename _Tp> inline _Tp&
02405 SparseMat_<_Tp>::ref(int i0, int i1, size_t* hashval)
02406 { return SparseMat::ref<_Tp>(i0, i1, hashval); }
02407
02408 template<typename _Tp> inline _Tp
02409 SparseMat_<_Tp>::operator()(int i0, int i1, size_t* hashval) const
02410 { return SparseMat::value<_Tp>(i0, i1, hashval); }
02411
02412 template<typename _Tp> inline _Tp&
02413 SparseMat_<_Tp>::ref(int i0, int i1, int i2, size_t* hashval)
02414 { return SparseMat::ref<_Tp>(i0, i1, i2, hashval); }
02415
02416 template<typename _Tp> inline _Tp
02417 SparseMat_<_Tp>::operator()(int i0, int i1, int i2, size_t* hashval) const
02418 { return SparseMat::value<_Tp>(i0, i1, i2, hashval); }
02419
02420 template<typename _Tp> inline _Tp&
02421 SparseMat_<_Tp>::ref(const int* idx, size_t* hashval)
02422 { return SparseMat::ref<_Tp>(idx, hashval); }
02423
02424 template<typename _Tp> inline _Tp
02425 SparseMat_<_Tp>::operator()(const int* idx, size_t* hashval) const
02426 { return SparseMat::value<_Tp>(idx, hashval); }
02427
02428 template<typename _Tp> inline SparseMatIterator_<_Tp> SparseMat_<_Tp>::begin()
02429 { return SparseMatIterator_<_Tp>(this); }
02430
02431 template<typename _Tp> inline SparseMatConstIterator_<_Tp> SparseMat_<_Tp>::begin() const
02432 { return SparseMatConstIterator_<_Tp>(this); }
02433
02434 template<typename _Tp> inline SparseMatIterator_<_Tp> SparseMat_<_Tp>::end()
02435 { SparseMatIterator_<_Tp> it(this); it.seekEnd(); return it; }
02436
02437 template<typename _Tp> inline SparseMatConstIterator_<_Tp> SparseMat_<_Tp>::end() const
02438 { SparseMatConstIterator_<_Tp> it(this); it.seekEnd(); return it; }
02439
02440 template<typename _Tp> inline
02441 SparseMatConstIterator_<_Tp>::SparseMatConstIterator_()
02442 {}
02443
02444 template<typename _Tp> inline
02445 SparseMatConstIterator_<_Tp>::SparseMatConstIterator_(const SparseMat_<_Tp>* _m)
02446 : SparseMatConstIterator(_m)
02447 {}
02448
02449 template<typename _Tp> inline
02450 SparseMatConstIterator_<_Tp>::SparseMatConstIterator_(const SparseMatConstIterator_<_Tp>& it)
02451 : SparseMatConstIterator(it)
02452 {}
02453
02454 template<typename _Tp> inline SparseMatConstIterator_<_Tp>&
02455 SparseMatConstIterator_<_Tp>::operator = (const SparseMatConstIterator_<_Tp>& it)
02456 { return ((SparseMatConstIterator&)*this = it); }
02457
02458 template<typename _Tp> inline const _Tp&
02459 SparseMatConstIterator_<_Tp>::operator *() const
02460 { return *(const _Tp*)this->ptr; }
02461
02462 template<typename _Tp> inline SparseMatConstIterator_<_Tp>&
02463 SparseMatConstIterator_<_Tp>::operator ++()
02464 {
02465 SparseMatConstIterator::operator ++();
02466 return *this;
02467 }
02468
02469 template<typename _Tp> inline SparseMatConstIterator_<_Tp>
02470 SparseMatConstIterator_<_Tp>::operator ++(int)
02471 {
02472 SparseMatConstIterator it = *this;
02473 SparseMatConstIterator::operator ++();
02474 return it;
02475 }
02476
02477 template<typename _Tp> inline
02478 SparseMatIterator_<_Tp>::SparseMatIterator_()
02479 {}
02480
02481 template<typename _Tp> inline
02482 SparseMatIterator_<_Tp>::SparseMatIterator_(SparseMat_<_Tp>* _m)
02483 : SparseMatConstIterator_<_Tp>(_m)
02484 {}
02485
02486 template<typename _Tp> inline
02487 SparseMatIterator_<_Tp>::SparseMatIterator_(const SparseMatIterator_<_Tp>& it)
02488 : SparseMatConstIterator_<_Tp>(it)
02489 {}
02490
02491 template<typename _Tp> inline SparseMatIterator_<_Tp>&
02492 SparseMatIterator_<_Tp>::operator = (const SparseMatIterator_<_Tp>& it)
02493 { return ((SparseMatIterator&)*this = it); }
02494
02495 template<typename _Tp> inline _Tp&
02496 SparseMatIterator_<_Tp>::operator *() const
02497 { return *(_Tp*)this->ptr; }
02498
02499 template<typename _Tp> inline SparseMatIterator_<_Tp>&
02500 SparseMatIterator_<_Tp>::operator ++()
02501 {
02502 SparseMatConstIterator::operator ++();
02503 return *this;
02504 }
02505
02506 template<typename _Tp> inline SparseMatIterator_<_Tp>
02507 SparseMatIterator_<_Tp>::operator ++(int)
02508 {
02509 SparseMatIterator it = *this;
02510 SparseMatConstIterator::operator ++();
02511 return it;
02512 }
02513
02514 }
02515
02516 #endif
02517 #endif