opencv: /usr/ports/pobj/OpenCV-2.2.0/OpenCV-2.2.0/modules/core/include/opencv2/core/mat.hpp Source File

- Main Page
- Related Pages
- Namespaces
- Classes
- Files

- File List
- File Members

# /usr/ports/pobj/OpenCV-2.2.0/OpenCV-2.2.0/modules/core/include/opencv2/core/mat.hpp

Go to the documentation of this file.

    00001 /*M///////////////////////////////////////////////////////////////////////////////////////
    00002 //
    00003 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
    00004 //
    00005 //  By downloading, copying, installing or using the software you agree to this license.
    00006 //  If you do not agree to this license, do not download, install,
    00007 //  copy or use the software.
    00008 //
    00009 //
    00010 //                           License Agreement
    00011 //                For Open Source Computer Vision Library
    00012 //
    00013 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
    00014 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
    00015 // Third party copyrights are property of their respective owners.
    00016 //
    00017 // Redistribution and use in source and binary forms, with or without modification,
    00018 // are permitted provided that the following conditions are met:
    00019 //
    00020 //   * Redistribution's of source code must retain the above copyright notice,
    00021 //     this list of conditions and the following disclaimer.
    00022 //
    00023 //   * Redistribution's in binary form must reproduce the above copyright notice,
    00024 //     this list of conditions and the following disclaimer in the documentation
    00025 //     and/or other materials provided with the distribution.
    00026 //
    00027 //   * The name of the copyright holders may not be used to endorse or promote products
    00028 //     derived from this software without specific prior written permission.
    00029 //
    00030 // This software is provided by the copyright holders and contributors "as is" and
    00031 // any express or implied warranties, including, but not limited to, the implied
    00032 // warranties of merchantability and fitness for a particular purpose are disclaimed.
    00033 // In no event shall the Intel Corporation or contributors be liable for any direct,
    00034 // indirect, incidental, special, exemplary, or consequential damages
    00035 // (including, but not limited to, procurement of substitute goods or services;
    00036 // loss of use, data, or profits; or business interruption) however caused
    00037 // and on any theory of liability, whether in contract, strict liability,
    00038 // or tort (including negligence or otherwise) arising in any way out of
    00039 // the use of this software, even if advised of the possibility of such damage.
    00040 //
    00041 //M*/
    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( 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( 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( 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( 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 inline uchar* Mat::ptr(int i0, int i1, int i2)
    00470 {
    00471     CV_DbgAssert( dims >= 3 && data &&
    00472                   (unsigned)i0 < (unsigned)size.p[0] &&
    00473                   (unsigned)i1 < (unsigned)size.p[1] &&
    00474                   (unsigned)i2 < (unsigned)size.p[2] );
    00475     return data + i0*step.p[0] + i1*step.p[1] + i2*step.p[2];
    00476 }
    00477
    00478 inline const uchar* Mat::ptr(int i0, int i1, int i2) const
    00479 {
    00480     CV_DbgAssert( dims >= 3 && data &&
    00481                   (unsigned)i0 < (unsigned)size.p[0] &&
    00482                   (unsigned)i1 < (unsigned)size.p[1] &&
    00483                   (unsigned)i2 < (unsigned)size.p[2] );
    00484     return data + i0*step.p[0] + i1*step.p[1] + i2*step.p[2];
    00485 }
    00486
    00487 inline uchar* Mat::ptr(const int* idx)
    00488 {
    00489     int i, d = dims;
    00490     uchar* p = data;
    00491     CV_DbgAssert( d >= 1 && p );
    00492     for( i = 0; i < d; i++ )
    00493     {
    00494         CV_DbgAssert( (unsigned)idx[i] < (unsigned)size.p[i] );
    00495         p += idx[i]*step.p[i];
    00496     }
    00497     return p;
    00498 }
    00499
    00500 inline const uchar* Mat::ptr(const int* idx) const
    00501 {
    00502     int i, d = dims;
    00503     uchar* p = data;
    00504     CV_DbgAssert( d >= 1 && p );
    00505     for( i = 0; i < d; i++ )
    00506     {
    00507         CV_DbgAssert( (unsigned)idx[i] < (unsigned)size.p[i] );
    00508         p += idx[i]*step.p[i];
    00509     }
    00510     return p;
    00511 }
    00512
    00513 template<typename _Tp> inline _Tp& Mat::at(int i0, int i1)
    00514 {
    00515     CV_DbgAssert( dims <= 2 && data && (unsigned)i0 < (unsigned)size.p[0] &&
    00516         (unsigned)(i1*DataType<_Tp>::channels) < (unsigned)(size.p[1]*channels()) &&
    00517         CV_ELEM_SIZE1(DataType<_Tp>::depth) == elemSize1());
    00518     return ((_Tp*)(data + step.p[0]*i0))[i1];
    00519 }
    00520
    00521 template<typename _Tp> inline const _Tp& Mat::at(int i0, int i1) const
    00522 {
    00523     CV_DbgAssert( dims <= 2 && data && (unsigned)i0 < (unsigned)size.p[0] &&
    00524         (unsigned)(i1*DataType<_Tp>::channels) < (unsigned)(size.p[1]*channels()) &&
    00525         CV_ELEM_SIZE1(DataType<_Tp>::depth) == elemSize1());
    00526     return ((const _Tp*)(data + step.p[0]*i0))[i1];
    00527 }
    00528
    00529 template<typename _Tp> inline _Tp& Mat::at(Point pt)
    00530 {
    00531     CV_DbgAssert( dims <= 2 && data && (unsigned)pt.y < (unsigned)size.p[0] &&
    00532         (unsigned)(pt.x*DataType<_Tp>::channels) < (unsigned)(size.p[1]*channels()) &&
    00533         CV_ELEM_SIZE1(DataType<_Tp>::depth) == elemSize1());
    00534     return ((_Tp*)(data + step.p[0]*pt.y))[pt.x];
    00535 }
    00536
    00537 template<typename _Tp> inline const _Tp& Mat::at(Point pt) const
    00538 {
    00539     CV_DbgAssert( dims <= 2 && data && (unsigned)pt.y < (unsigned)size.p[0] &&
    00540         (unsigned)(pt.x*DataType<_Tp>::channels) < (unsigned)(size.p[1]*channels()) &&
    00541         CV_ELEM_SIZE1(DataType<_Tp>::depth) == elemSize1());
    00542     return ((const _Tp*)(data + step.p[0]*pt.y))[pt.x];
    00543 }
    00544
    00545 template<typename _Tp> inline _Tp& Mat::at(int i0)
    00546 {
    00547     CV_DbgAssert( dims <= 2 && data && (size.p[0] == 1 || size.p[1] == 1) &&
    00548                  (unsigned)i0 < (unsigned)(size.p[0] + size.p[1] - 1) &&
    00549                  elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
    00550     return *(_Tp*)(data + step.p[size.p[0]==1]*i0);
    00551 }
    00552
    00553 template<typename _Tp> inline const _Tp& Mat::at(int i0) const
    00554 {
    00555     CV_DbgAssert( dims <= 2 && data && (size.p[0] == 1 || size.p[1] == 1) &&
    00556                  (unsigned)i0 < (unsigned)(size.p[0] + size.p[1] - 1) &&
    00557                  elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
    00558     return *(_Tp*)(data + step.p[size.p[0]==1]*i0);
    00559 }
    00560
    00561 template<typename _Tp> inline _Tp& Mat::at(int i0, int i1, int i2)
    00562 {
    00563     CV_DbgAssert( elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
    00564     return *(_Tp*)ptr(i0, i1, i2);
    00565 }
    00566 template<typename _Tp> inline const _Tp& Mat::at(int i0, int i1, int i2) const
    00567 {
    00568     CV_DbgAssert( elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
    00569     return *(const _Tp*)ptr(i0, i1, i2);
    00570 }
    00571 template<typename _Tp> inline _Tp& Mat::at(const int* idx)
    00572 {
    00573     CV_DbgAssert( elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
    00574     return *(_Tp*)ptr(idx);
    00575 }
    00576 template<typename _Tp> inline const _Tp& Mat::at(const int* idx) const
    00577 {
    00578     CV_DbgAssert( elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
    00579     return *(const _Tp*)ptr(idx);
    00580 }
    00581
    00582
    00583 template<typename _Tp> inline MatConstIterator_<_Tp> Mat::begin() const
    00584 {
    00585     CV_DbgAssert( elemSize() == sizeof(_Tp) );
    00586     return MatConstIterator_<_Tp>((const Mat_<_Tp>*)this);
    00587 }
    00588
    00589 template<typename _Tp> inline MatConstIterator_<_Tp> Mat::end() const
    00590 {
    00591     CV_DbgAssert( elemSize() == sizeof(_Tp) );
    00592     MatConstIterator_<_Tp> it((const Mat_<_Tp>*)this);
    00593     it += total();
    00594     return it;
    00595 }
    00596
    00597 template<typename _Tp> inline MatIterator_<_Tp> Mat::begin()
    00598 {
    00599     CV_DbgAssert( elemSize() == sizeof(_Tp) );
    00600     return MatIterator_<_Tp>((Mat_<_Tp>*)this);
    00601 }
    00602
    00603 template<typename _Tp> inline MatIterator_<_Tp> Mat::end()
    00604 {
    00605     CV_DbgAssert( elemSize() == sizeof(_Tp) );
    00606     MatIterator_<_Tp> it((Mat_<_Tp>*)this);
    00607     it += total();
    00608     return it;
    00609 }
    00610
    00611
    00612 template<typename _Tp> inline void Mat::copyTo(vector<_Tp>& v) const
    00613 {
    00614     int n = checkVector(DataType<_Tp>::channels);
    00615     if( empty() || n == 0 )
    00616     {
    00617         v.clear();
    00618         return;
    00619     }
    00620     CV_Assert( n > 0 );
    00621     v.resize(n);
    00622     Mat temp(dims, size.p, DataType<_Tp>::type, &v[0]);
    00623     convertTo(temp, DataType<_Tp>::type);
    00624 }
    00625
    00626 template<typename _Tp> inline Mat::operator vector<_Tp>() const
    00627 {
    00628     vector<_Tp> v;
    00629     copyTo(v);
    00630     return v;
    00631 }
    00632
    00633 template<typename _Tp, int n> inline Mat::operator Vec<_Tp, n>() const
    00634 {
    00635     CV_Assert( data && dims <= 2 && (rows == 1 || cols == 1) &&
    00636                rows + cols - 1 == n && channels() == 1 );
    00637
    00638     if( isContinuous() && type() == DataType<_Tp>::type )
    00639         return Vec<_Tp, n>((_Tp*)data);
    00640     Vec<_Tp, n> v; Mat tmp(rows, cols, DataType<_Tp>::type, v.val);
    00641     convertTo(tmp, tmp.type());
    00642     return v;
    00643 }
    00644
    00645 template<typename _Tp, int m, int n> inline Mat::operator Matx<_Tp, m, n>() const
    00646 {
    00647     CV_Assert( data && dims <= 2 && rows == m && cols == n && channels() == 1 );
    00648
    00649     if( isContinuous() && type() == DataType<_Tp>::type )
    00650         return Matx<_Tp, m, n>((_Tp*)data);
    00651     Matx<_Tp, m, n> mtx; Mat tmp(rows, cols, DataType<_Tp>::type, mtx.val);
    00652     convertTo(tmp, tmp.type());
    00653     return mtx;
    00654 }
    00655
    00656
    00657 template<typename _Tp> inline void Mat::push_back(const _Tp& elem)
    00658 {
    00659     CV_Assert(DataType<_Tp>::type == type() && cols == 1
    00660               /* && dims == 2 (cols == 1 implies dims == 2) */);
    00661     uchar* tmp = dataend + step[0];
    00662     if( !isSubmatrix() && isContinuous() && tmp <= datalimit )
    00663     {
    00664         *(_Tp*)(data + (size.p[0]++)*step.p[0]) = elem;
    00665         dataend = tmp;
    00666     }
    00667     else
    00668         push_back_(&elem);
    00669 }
    00670
    00671 template<typename _Tp> inline void Mat::push_back(const Mat_<_Tp>& m)
    00672 {
    00673     push_back((const Mat&)m);
    00674 }
    00675
    00676 inline Mat::MSize::MSize(int* _p) : p(_p) {}
    00677 inline Size Mat::MSize::operator()() const
    00678 {
    00679     CV_DbgAssert(p[-1] <= 2);
    00680     return Size(p[1], p[0]);
    00681 }
    00682 inline int Mat::MSize::operator[](int i) const { return p[i]; }
    00683 inline int& Mat::MSize::operator[](int i) { return p[i]; }
    00684 inline Mat::MSize::operator const int*() const { return p; }
    00685
    00686 inline bool Mat::MSize::operator == (const MSize& sz) const
    00687 {
    00688     int d = p[-1], dsz = sz.p[-1];
    00689     if( d != dsz )
    00690         return false;
    00691     if( d == 2 )
    00692         return p[0] == sz.p[0] && p[1] == sz.p[1];
    00693
    00694     for( int i = 0; i < d; i++ )
    00695         if( p[i] != sz.p[i] )
    00696             return false;
    00697     return true;
    00698 }
    00699
    00700 inline bool Mat::MSize::operator != (const MSize& sz) const
    00701 {
    00702     return !(*this == sz);
    00703 }
    00704
    00705 inline Mat::MStep::MStep() { p = buf; p[0] = p[1] = 0; }
    00706 inline Mat::MStep::MStep(size_t s) { p = buf; p[0] = s; p[1] = 0; }
    00707 inline size_t Mat::MStep::operator[](int i) const { return p[i]; }
    00708 inline size_t& Mat::MStep::operator[](int i) { return p[i]; }
    00709 inline Mat::MStep::operator size_t() const
    00710 {
    00711     CV_DbgAssert( p == buf );
    00712     return buf[0];
    00713 }
    00714 inline Mat::MStep& Mat::MStep::operator = (size_t s)
    00715 {
    00716     CV_DbgAssert( p == buf );
    00717     buf[0] = s;
    00718     return *this;
    00719 }
    00720
    00721 static inline Mat cvarrToMatND(const CvArr* arr, bool copyData=false, int coiMode=0)
    00722 {
    00723     return cvarrToMat(arr, copyData, true, coiMode);
    00724 }
    00725
    00727
    00728 inline SVD::SVD() {}
    00729 inline SVD::SVD( const Mat& m, int flags ) { operator ()(m, flags); }
    00730 inline void SVD::solveZ( const Mat& m, Mat& dst )
    00731 {
    00732     SVD svd(m);
    00733     svd.vt.row(svd.vt.rows-1).reshape(1,svd.vt.cols).copyTo(dst);
    00734 }
    00735
    00736 template<typename _Tp, int m, int n, int nm> inline void
    00737     SVD::compute( const Matx<_Tp, m, n>& a, Matx<_Tp, nm, 1>& w, Matx<_Tp, m, nm>& u, Matx<_Tp, n, nm>& vt )
    00738 {
    00739     assert( nm == MIN(m, n));
    00740     Mat _a(a, false), _u(u, false), _w(w, false), _vt(vt, false);
    00741     SVD::compute(_a, _w, _u, _vt);
    00742     CV_Assert(_w.data == (uchar*)&w.val[0] && _u.data == (uchar*)&u.val[0] && _vt.data == (uchar*)&vt.val[0]);
    00743 }
    00744
    00745 template<typename _Tp, int m, int n, int nm> inline void
    00746 SVD::compute( const Matx<_Tp, m, n>& a, Matx<_Tp, nm, 1>& w )
    00747 {
    00748     assert( nm == MIN(m, n));
    00749     Mat _a(a, false), _w(w, false);
    00750     SVD::compute(_a, _w);
    00751     CV_Assert(_w.data == (uchar*)&w.val[0]);
    00752 }
    00753
    00754 template<typename _Tp, int m, int n, int nm, int nb> inline void
    00755 SVD::backSubst( const Matx<_Tp, nm, 1>& w, const Matx<_Tp, m, nm>& u,
    00756                 const Matx<_Tp, n, nm>& vt, const Matx<_Tp, m, nb>& rhs,
    00757                 Matx<_Tp, n, nb>& dst )
    00758 {
    00759     assert( nm == MIN(m, n));
    00760     Mat _u(u, false), _w(w, false), _vt(vt, false), _rhs(rhs, false), _dst(dst, false);
    00761     SVD::backSubst(_w, _u, _vt, _rhs, _dst);
    00762     CV_Assert(_dst.data == (uchar*)&dst.val[0]);
    00763 }
    00764
    00766
    00767 template<typename _Tp> inline Mat_<_Tp>::Mat_()
    00768     : Mat() { flags = (flags & ~CV_MAT_TYPE_MASK) | DataType<_Tp>::type; }
    00769
    00770 template<typename _Tp> inline Mat_<_Tp>::Mat_(int _rows, int _cols)
    00771     : Mat(_rows, _cols, DataType<_Tp>::type) {}
    00772
    00773 template<typename _Tp> inline Mat_<_Tp>::Mat_(int _rows, int _cols, const _Tp& value)
    00774     : Mat(_rows, _cols, DataType<_Tp>::type) { *this = value; }
    00775
    00776 template<typename _Tp> inline Mat_<_Tp>::Mat_(Size _sz)
    00777     : Mat(_sz.height, _sz.width, DataType<_Tp>::type) {}
    00778
    00779 template<typename _Tp> inline Mat_<_Tp>::Mat_(Size _sz, const _Tp& value)
    00780     : Mat(_sz.height, _sz.width, DataType<_Tp>::type) { *this = value; }
    00781
    00782 template<typename _Tp> inline Mat_<_Tp>::Mat_(int _dims, const int* _sz)
    00783     : Mat(_dims, _sz, DataType<_Tp>::type) {}
    00784
    00785 template<typename _Tp> inline Mat_<_Tp>::Mat_(int _dims, const int* _sz, const _Tp& _s)
    00786     : Mat(_dims, _sz, DataType<_Tp>::type, Scalar(_s)) {}
    00787
    00788 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_<_Tp>& m, const Range* ranges)
    00789     : Mat(m, ranges) {}
    00790
    00791 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat& m)
    00792     : Mat() { flags = (flags & ~CV_MAT_TYPE_MASK) | DataType<_Tp>::type; *this = m; }
    00793
    00794 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_& m)
    00795     : Mat(m) {}
    00796
    00797 template<typename _Tp> inline Mat_<_Tp>::Mat_(int _rows, int _cols, _Tp* _data, size_t steps)
    00798     : Mat(_rows, _cols, DataType<_Tp>::type, _data, steps) {}
    00799
    00800 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_& m, const Range& rowRange, const Range& colRange)
    00801     : Mat(m, rowRange, colRange) {}
    00802
    00803 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_& m, const Rect& roi)
    00804     : Mat(m, roi) {}
    00805
    00806 template<typename _Tp> template<int n> inline
    00807     Mat_<_Tp>::Mat_(const Vec<typename DataType<_Tp>::channel_type, n>& vec, bool copyData)
    00808     : Mat(n/DataType<_Tp>::channels, 1, DataType<_Tp>::type, &vec)
    00809 {
    00810     CV_Assert(n%DataType<_Tp>::channels == 0);
    00811     if( copyData )
    00812         *this = clone();
    00813 }
    00814
    00815 template<typename _Tp> template<int m, int n> inline
    00816     Mat_<_Tp>::Mat_(const Matx<typename DataType<_Tp>::channel_type,m,n>& M, bool copyData)
    00817     : Mat(m, n/DataType<_Tp>::channels, DataType<_Tp>::type, &M)
    00818 {
    00819     CV_Assert(n % DataType<_Tp>::channels == 0);
    00820     if( copyData )
    00821         *this = clone();
    00822 }
    00823
    00824 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Point_<typename DataType<_Tp>::channel_type>& pt, bool copyData)
    00825     : Mat(2/DataType<_Tp>::channels, 1, DataType<_Tp>::type, &pt)
    00826 {
    00827     CV_Assert(2 % DataType<_Tp>::channels == 0);
    00828     if( copyData )
    00829         *this = clone();
    00830 }
    00831
    00832 template<typename _Tp> inline Mat_<_Tp>::Mat_(const Point3_<typename DataType<_Tp>::channel_type>& pt, bool copyData)
    00833     : Mat(3/DataType<_Tp>::channels, 1, DataType<_Tp>::type, &pt)
    00834 {
    00835     CV_Assert(3 % DataType<_Tp>::channels == 0);
    00836     if( copyData )
    00837         *this = clone();
    00838 }
    00839
    00840 template<typename _Tp> inline Mat_<_Tp>::Mat_(const MatCommaInitializer_<_Tp>& commaInitializer)
    00841     : Mat(commaInitializer) {}
    00842
    00843 template<typename _Tp> inline Mat_<_Tp>::Mat_(const vector<_Tp>& vec, bool copyData)
    00844     : Mat(vec, copyData) {}
    00845
    00846 template<typename _Tp> inline Mat_<_Tp>& Mat_<_Tp>::operator = (const Mat& m)
    00847 {
    00848     if( DataType<_Tp>::type == m.type() )
    00849     {
    00850         Mat::operator = (m);
    00851         return *this;
    00852     }
    00853     if( DataType<_Tp>::depth == m.depth() )
    00854     {
    00855         return (*this = m.reshape(DataType<_Tp>::channels, m.dims, 0));
    00856     }
    00857     CV_DbgAssert(DataType<_Tp>::channels == m.channels());
    00858     m.convertTo(*this, type());
    00859     return *this;
    00860 }
    00861
    00862 template<typename _Tp> inline Mat_<_Tp>& Mat_<_Tp>::operator = (const Mat_& m)
    00863 {
    00864     Mat::operator=(m);
    00865     return *this;
    00866 }
    00867
    00868 template<typename _Tp> inline Mat_<_Tp>& Mat_<_Tp>::operator = (const _Tp& s)
    00869 {
    00870     typedef typename DataType<_Tp>::vec_type VT;
    00871     Mat::operator=(Scalar((const VT&)s));
    00872     return *this;
    00873 }
    00874
    00875
    00876 template<typename _Tp> inline void Mat_<_Tp>::create(int _rows, int _cols)
    00877 {
    00878     Mat::create(_rows, _cols, DataType<_Tp>::type);
    00879 }
    00880
    00881 template<typename _Tp> inline void Mat_<_Tp>::create(Size _sz)
    00882 {
    00883     Mat::create(_sz, DataType<_Tp>::type);
    00884 }
    00885
    00886 template<typename _Tp> inline void Mat_<_Tp>::create(int _dims, const int* _sz)
    00887 {
    00888     Mat::create(_dims, _sz, DataType<_Tp>::type);
    00889 }
    00890
    00891
    00892 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::cross(const Mat_& m) const
    00893 { return Mat_<_Tp>(Mat::cross(m)); }
    00894
    00895 template<typename _Tp> template<typename T2> inline Mat_<_Tp>::operator Mat_<T2>() const
    00896 { return Mat_<T2>(*this); }
    00897
    00898 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::row(int y) const
    00899 { return Mat_(*this, Range(y, y+1), Range::all()); }
    00900 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::col(int x) const
    00901 { return Mat_(*this, Range::all(), Range(x, x+1)); }
    00902 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::diag(int d) const
    00903 { return Mat_(Mat::diag(d)); }
    00904 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::clone() const
    00905 { return Mat_(Mat::clone()); }
    00906
    00907 template<typename _Tp> inline size_t Mat_<_Tp>::elemSize() const
    00908 {
    00909     CV_DbgAssert( Mat::elemSize() == sizeof(_Tp) );
    00910     return sizeof(_Tp);
    00911 }
    00912
    00913 template<typename _Tp> inline size_t Mat_<_Tp>::elemSize1() const
    00914 {
    00915     CV_DbgAssert( Mat::elemSize1() == sizeof(_Tp)/DataType<_Tp>::channels );
    00916     return sizeof(_Tp)/DataType<_Tp>::channels;
    00917 }
    00918 template<typename _Tp> inline int Mat_<_Tp>::type() const
    00919 {
    00920     CV_DbgAssert( Mat::type() == DataType<_Tp>::type );
    00921     return DataType<_Tp>::type;
    00922 }
    00923 template<typename _Tp> inline int Mat_<_Tp>::depth() const
    00924 {
    00925     CV_DbgAssert( Mat::depth() == DataType<_Tp>::depth );
    00926     return DataType<_Tp>::depth;
    00927 }
    00928 template<typename _Tp> inline int Mat_<_Tp>::channels() const
    00929 {
    00930     CV_DbgAssert( Mat::channels() == DataType<_Tp>::channels );
    00931     return DataType<_Tp>::channels;
    00932 }
    00933 template<typename _Tp> inline size_t Mat_<_Tp>::stepT(int i) const { return step.p[i]/elemSize(); }
    00934 template<typename _Tp> inline size_t Mat_<_Tp>::step1(int i) const { return step.p[i]/elemSize1(); }
    00935
    00936 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::reshape(int _rows) const
    00937 { return Mat_<_Tp>(Mat::reshape(0,_rows)); }
    00938
    00939 template<typename _Tp> inline Mat_<_Tp>& Mat_<_Tp>::adjustROI( int dtop, int dbottom, int dleft, int dright )
    00940 { return (Mat_<_Tp>&)(Mat::adjustROI(dtop, dbottom, dleft, dright));  }
    00941
    00942 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::operator()( const Range& rowRange, const Range& colRange ) const
    00943 { return Mat_<_Tp>(*this, rowRange, colRange); }
    00944
    00945 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::operator()( const Rect& roi ) const
    00946 { return Mat_<_Tp>(*this, roi); }
    00947
    00948 template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::operator()( const Range* ranges ) const
    00949 { return Mat_<_Tp>(*this, ranges); }
    00950
    00951 template<typename _Tp> inline _Tp* Mat_<_Tp>::operator [](int y)
    00952 { return (_Tp*)ptr(y); }
    00953 template<typename _Tp> inline const _Tp* Mat_<_Tp>::operator [](int y) const
    00954 { return (const _Tp*)ptr(y); }
    00955
    00956 template<typename _Tp> inline _Tp& Mat_<_Tp>::operator ()(int i0, int i1)
    00957 {
    00958     CV_DbgAssert( dims <= 2 && data &&
    00959                   (unsigned)i0 < (unsigned)size.p[0] &&
    00960                   (unsigned)i1 < (unsigned)size.p[1] &&
    00961                   type() == DataType<_Tp>::type );
    00962     return ((_Tp*)(data + step.p[0]*i0))[i1];
    00963 }
    00964
    00965 template<typename _Tp> inline const _Tp& Mat_<_Tp>::operator ()(int i0, int i1) const
    00966 {
    00967     CV_DbgAssert( dims <= 2 && data &&
    00968                   (unsigned)i0 < (unsigned)size.p[0] &&
    00969                   (unsigned)i1 < (unsigned)size.p[1] &&
    00970                   type() == DataType<_Tp>::type );
    00971     return ((const _Tp*)(data + step.p[0]*i0))[i1];
    00972 }
    00973
    00974 template<typename _Tp> inline _Tp& Mat_<_Tp>::operator ()(Point pt)
    00975 {
    00976     CV_DbgAssert( dims <= 2 && data &&
    00977                   (unsigned)pt.y < (unsigned)size.p[0] &&
    00978                   (unsigned)pt.x < (unsigned)size.p[1] &&
    00979                   type() == DataType<_Tp>::type );
    00980     return ((_Tp*)(data + step.p[0]*pt.y))[pt.x];
    00981 }
    00982
    00983 template<typename _Tp> inline const _Tp& Mat_<_Tp>::operator ()(Point pt) const
    00984 {
    00985     CV_DbgAssert( dims <= 2 && data &&
    00986                   (unsigned)pt.y < (unsigned)size.p[0] &&
    00987                   (unsigned)pt.x < (unsigned)size.p[1] &&
    00988                  type() == DataType<_Tp>::type );
    00989     return ((const _Tp*)(data + step.p[0]*pt.y))[pt.x];
    00990 }
    00991
    00992 template<typename _Tp> inline _Tp& Mat_<_Tp>::operator ()(const int* idx)
    00993 {
    00994     return Mat::at<_Tp>(idx);
    00995 }
    00996
    00997 template<typename _Tp> inline const _Tp& Mat_<_Tp>::operator ()(const int* idx) const
    00998 {
    00999     return Mat::at<_Tp>(idx);
    01000 }
    01001
    01002 template<typename _Tp> inline _Tp& Mat_<_Tp>::operator ()(int i0)
    01003 {
    01004     return this->at<_Tp>(i0);
    01005 }
    01006
    01007 template<typename _Tp> inline const _Tp& Mat_<_Tp>::operator ()(int i0) const
    01008 {
    01009     return this->at<_Tp>(i0);
    01010 }
    01011
    01012 template<typename _Tp> inline _Tp& Mat_<_Tp>::operator ()(int i0, int i1, int i2)
    01013 {
    01014     return this->at<_Tp>(i0, i1, i2);
    01015 }
    01016
    01017 template<typename _Tp> inline const _Tp& Mat_<_Tp>::operator ()(int i0, int i1, int i2) const
    01018 {
    01019     return this->at<_Tp>(i0, i1, i2);
    01020 }
    01021
    01022
    01023 template<typename _Tp> inline Mat_<_Tp>::operator vector<_Tp>() const
    01024 {
    01025     vector<_Tp> v;
    01026     copyTo(v);
    01027     return v;
    01028 }
    01029
    01030 template<typename _Tp> template<int n> inline Mat_<_Tp>::operator Vec<typename DataType<_Tp>::channel_type, n>() const
    01031 {
    01032     CV_Assert(n % DataType<_Tp>::channels == 0);
    01033     return this->Mat::operator Vec<typename DataType<_Tp>::channel_type, n>();
    01034 }
    01035
    01036 template<typename _Tp> template<int m, int n> inline Mat_<_Tp>::operator Matx<typename DataType<_Tp>::channel_type, m, n>() const
    01037 {
    01038     CV_Assert(n % DataType<_Tp>::channels == 0);
    01039     return this->Mat::operator Matx<typename DataType<_Tp>::channel_type, m, n>();
    01040 }
    01041
    01042 template<typename T1, typename T2, typename Op> inline void
    01043 process( const Mat_<T1>& m1, Mat_<T2>& m2, Op op )
    01044 {
    01045     int y, x, rows = m1.rows, cols = m1.cols;
    01046     int c1 = m1.channels(), c2 = m2.channels();
    01047
    01048     CV_DbgAssert( m1.size() == m2.size() );
    01049
    01050     for( y = 0; y < rows; y++ )
    01051     {
    01052         const T1* src = m1[y];
    01053         T2* dst = m2[y];
    01054
    01055         for( x = 0; x < cols; x++ )
    01056             dst[x] = op(src[x]);
    01057     }
    01058 }
    01059
    01060 template<typename T1, typename T2, typename T3, typename Op> inline void
    01061 process( const Mat_<T1>& m1, const Mat_<T2>& m2, Mat_<T3>& m3, Op op )
    01062 {
    01063     int y, x, rows = m1.rows, cols = m1.cols;
    01064
    01065     CV_DbgAssert( m1.size() == m2.size() );
    01066
    01067     for( y = 0; y < rows; y++ )
    01068     {
    01069         const T1* src1 = m1[y];
    01070         const T2* src2 = m2[y];
    01071         T3* dst = m3[y];
    01072
    01073         for( x = 0; x < cols; x++ )
    01074             dst[x] = op( src1[x], src2[x] );
    01075     }
    01076 }
    01077
    01079
    01080 class CV_EXPORTS MatOp
    01081 {
    01082 public:
    01083     MatOp() {};
    01084     virtual ~MatOp() {};
    01085
    01086     virtual bool elementWise(const MatExpr& expr) const;
    01087     virtual void assign(const MatExpr& expr, Mat& m, int type=-1) const = 0;
    01088     virtual void roi(const MatExpr& expr, const Range& rowRange,
    01089                      const Range& colRange, MatExpr& res) const;
    01090     virtual void diag(const MatExpr& expr, int d, MatExpr& res) const;
    01091     virtual void augAssignAdd(const MatExpr& expr, Mat& m) const;
    01092     virtual void augAssignSubtract(const MatExpr& expr, Mat& m) const;
    01093     virtual void augAssignMultiply(const MatExpr& expr, Mat& m) const;
    01094     virtual void augAssignDivide(const MatExpr& expr, Mat& m) const;
    01095     virtual void augAssignAnd(const MatExpr& expr, Mat& m) const;
    01096     virtual void augAssignOr(const MatExpr& expr, Mat& m) const;
    01097     virtual void augAssignXor(const MatExpr& expr, Mat& m) const;
    01098
    01099     virtual void add(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
    01100     virtual void add(const MatExpr& expr1, const Scalar& s, MatExpr& res) const;
    01101
    01102     virtual void subtract(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
    01103     virtual void subtract(const Scalar& s, const MatExpr& expr, MatExpr& res) const;
    01104
    01105     virtual void multiply(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res, double scale=1) const;
    01106     virtual void multiply(const MatExpr& expr1, double s, MatExpr& res) const;
    01107
    01108     virtual void divide(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res, double scale=1) const;
    01109     virtual void divide(double s, const MatExpr& expr, MatExpr& res) const;
    01110
    01111     virtual void abs(const MatExpr& expr, MatExpr& res) const;
    01112
    01113     virtual void transpose(const MatExpr& expr, MatExpr& res) const;
    01114     virtual void matmul(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
    01115     virtual void invert(const MatExpr& expr, int method, MatExpr& res) const;
    01116 };
    01117
    01118
    01119 class CV_EXPORTS MatExpr
    01120 {
    01121 public:
    01122     MatExpr() : op(0), flags(0), a(Mat()), b(Mat()), c(Mat()), alpha(0), beta(0), s(Scalar()) {}
    01123     MatExpr(const MatOp* _op, int _flags, const Mat& _a=Mat(), const Mat& _b=Mat(),
    01124             const Mat& _c=Mat(), double _alpha=1, double _beta=1, const Scalar& _s=Scalar())
    01125         : op(_op), flags(_flags), a(_a), b(_b), c(_c), alpha(_alpha), beta(_beta), s(_s) {}
    01126     explicit MatExpr(const Mat& m);
    01127     operator Mat() const
    01128     {
    01129         Mat m;
    01130         op->assign(*this, m);
    01131         return m;
    01132     }
    01133
    01134     template<typename _Tp> operator Mat_<_Tp>() const
    01135     {
    01136         Mat_<_Tp> m;
    01137         op->assign(*this, m, DataType<_Tp>::type);
    01138         return m;
    01139     }
    01140
    01141     MatExpr row(int y) const;
    01142     MatExpr col(int x) const;
    01143     MatExpr diag(int d=0) const;
    01144     MatExpr operator()( const Range& rowRange, const Range& colRange ) const;
    01145     MatExpr operator()( const Rect& roi ) const;
    01146
    01147     Mat cross(const Mat& m) const;
    01148     double dot(const Mat& m) const;
    01149
    01150     MatExpr t() const;
    01151     MatExpr inv(int method = DECOMP_LU) const;
    01152     MatExpr mul(const MatExpr& e, double scale=1) const;
    01153     MatExpr mul(const Mat& m, double scale=1) const;
    01154
    01155     const MatOp* op;
    01156     int flags;
    01157
    01158     Mat a, b, c;
    01159     double alpha, beta;
    01160     Scalar s;
    01161 };
    01162
    01163
    01164 CV_EXPORTS MatExpr operator + (const Mat& a, const Mat& b);
    01165 CV_EXPORTS MatExpr operator + (const Mat& a, const Scalar& s);
    01166 CV_EXPORTS MatExpr operator + (const Scalar& s, const Mat& a);
    01167 CV_EXPORTS MatExpr operator + (const MatExpr& e, const Mat& m);
    01168 CV_EXPORTS MatExpr operator + (const Mat& m, const MatExpr& e);
    01169 CV_EXPORTS MatExpr operator + (const MatExpr& e, const Scalar& s);
    01170 CV_EXPORTS MatExpr operator + (const Scalar& s, const MatExpr& e);
    01171 CV_EXPORTS MatExpr operator + (const MatExpr& e1, const MatExpr& e2);
    01172
    01173 CV_EXPORTS MatExpr operator - (const Mat& a, const Mat& b);
    01174 CV_EXPORTS MatExpr operator - (const Mat& a, const Scalar& s);
    01175 CV_EXPORTS MatExpr operator - (const Scalar& s, const Mat& a);
    01176 CV_EXPORTS MatExpr operator - (const MatExpr& e, const Mat& m);
    01177 CV_EXPORTS MatExpr operator - (const Mat& m, const MatExpr& e);
    01178 CV_EXPORTS MatExpr operator - (const MatExpr& e, const Scalar& s);
    01179 CV_EXPORTS MatExpr operator - (const Scalar& s, const MatExpr& e);
    01180 CV_EXPORTS MatExpr operator - (const MatExpr& e1, const MatExpr& e2);
    01181
    01182 CV_EXPORTS MatExpr operator - (const Mat& m);
    01183 CV_EXPORTS MatExpr operator - (const MatExpr& e);
    01184
    01185 CV_EXPORTS MatExpr operator * (const Mat& a, const Mat& b);
    01186 CV_EXPORTS MatExpr operator * (const Mat& a, double s);
    01187 CV_EXPORTS MatExpr operator * (double s, const Mat& a);
    01188 CV_EXPORTS MatExpr operator * (const MatExpr& e, const Mat& m);
    01189 CV_EXPORTS MatExpr operator * (const Mat& m, const MatExpr& e);
    01190 CV_EXPORTS MatExpr operator * (const MatExpr& e, double s);
    01191 CV_EXPORTS MatExpr operator * (double s, const MatExpr& e);
    01192 CV_EXPORTS MatExpr operator * (const MatExpr& e1, const MatExpr& e2);
    01193
    01194 CV_EXPORTS MatExpr operator / (const Mat& a, const Mat& b);
    01195 CV_EXPORTS MatExpr operator / (const Mat& a, double s);
    01196 CV_EXPORTS MatExpr operator / (double s, const Mat& a);
    01197 CV_EXPORTS MatExpr operator / (const MatExpr& e, const Mat& m);
    01198 CV_EXPORTS MatExpr operator / (const Mat& m, const MatExpr& e);
    01199 CV_EXPORTS MatExpr operator / (const MatExpr& e, double s);
    01200 CV_EXPORTS MatExpr operator / (double s, const MatExpr& e);
    01201 CV_EXPORTS MatExpr operator / (const MatExpr& e1, const MatExpr& e2);
    01202
    01203 CV_EXPORTS MatExpr operator < (const Mat& a, const Mat& b);
    01204 CV_EXPORTS MatExpr operator < (const Mat& a, double s);
    01205 CV_EXPORTS MatExpr operator < (double s, const Mat& a);
    01206
    01207 CV_EXPORTS MatExpr operator <= (const Mat& a, const Mat& b);
    01208 CV_EXPORTS MatExpr operator <= (const Mat& a, double s);
    01209 CV_EXPORTS MatExpr operator <= (double s, const Mat& a);
    01210
    01211 CV_EXPORTS MatExpr operator == (const Mat& a, const Mat& b);
    01212 CV_EXPORTS MatExpr operator == (const Mat& a, double s);
    01213 CV_EXPORTS MatExpr operator == (double s, const Mat& a);
    01214
    01215 CV_EXPORTS MatExpr operator != (const Mat& a, const Mat& b);
    01216 CV_EXPORTS MatExpr operator != (const Mat& a, double s);
    01217 CV_EXPORTS MatExpr operator != (double s, const Mat& a);
    01218
    01219 CV_EXPORTS MatExpr operator >= (const Mat& a, const Mat& b);
    01220 CV_EXPORTS MatExpr operator >= (const Mat& a, double s);
    01221 CV_EXPORTS MatExpr operator >= (double s, const Mat& a);
    01222
    01223 CV_EXPORTS MatExpr operator > (const Mat& a, const Mat& b);
    01224 CV_EXPORTS MatExpr operator > (const Mat& a, double s);
    01225 CV_EXPORTS MatExpr operator > (double s, const Mat& a);
    01226
    01227 CV_EXPORTS MatExpr min(const Mat& a, const Mat& b);
    01228 CV_EXPORTS MatExpr min(const Mat& a, double s);
    01229 CV_EXPORTS MatExpr min(double s, const Mat& a);
    01230
    01231 CV_EXPORTS MatExpr max(const Mat& a, const Mat& b);
    01232 CV_EXPORTS MatExpr max(const Mat& a, double s);
    01233 CV_EXPORTS MatExpr max(double s, const Mat& a);
    01234
    01235 template<typename _Tp> static inline MatExpr min(const Mat_<_Tp>& a, const Mat_<_Tp>& b)
    01236 {
    01237     return cv::min((const Mat&)a, (const Mat&)b);
    01238 }
    01239
    01240 template<typename _Tp> static inline MatExpr min(const Mat_<_Tp>& a, double s)
    01241 {
    01242     return cv::min((const Mat&)a, s);
    01243 }
    01244
    01245 template<typename _Tp> static inline MatExpr min(double s, const Mat_<_Tp>& a)
    01246 {
    01247     return cv::min((const Mat&)a, s);
    01248 }
    01249
    01250 template<typename _Tp> static inline MatExpr max(const Mat_<_Tp>& a, const Mat_<_Tp>& b)
    01251 {
    01252     return cv::max((const Mat&)a, (const Mat&)b);
    01253 }
    01254
    01255 template<typename _Tp> static inline MatExpr max(const Mat_<_Tp>& a, double s)
    01256 {
    01257     return cv::max((const Mat&)a, s);
    01258 }
    01259
    01260 template<typename _Tp> static inline MatExpr max(double s, const Mat_<_Tp>& a)
    01261 {
    01262     return cv::max((const Mat&)a, s);
    01263 }
    01264
    01265 CV_EXPORTS MatExpr operator & (const Mat& a, const Mat& b);
    01266 CV_EXPORTS MatExpr operator & (const Mat& a, const Scalar& s);
    01267 CV_EXPORTS MatExpr operator & (const Scalar& s, const Mat& a);
    01268
    01269 CV_EXPORTS MatExpr operator | (const Mat& a, const Mat& b);
    01270 CV_EXPORTS MatExpr operator | (const Mat& a, const Scalar& s);
    01271 CV_EXPORTS MatExpr operator | (const Scalar& s, const Mat& a);
    01272
    01273 CV_EXPORTS MatExpr operator ^ (const Mat& a, const Mat& b);
    01274 CV_EXPORTS MatExpr operator ^ (const Mat& a, const Scalar& s);
    01275 CV_EXPORTS MatExpr operator ^ (const Scalar& s, const Mat& a);
    01276
    01277 CV_EXPORTS MatExpr operator ~(const Mat& m);
    01278
    01279 CV_EXPORTS MatExpr abs(const Mat& m);
    01280 CV_EXPORTS MatExpr abs(const MatExpr& e);
    01281
    01282 template<typename _Tp> static inline MatExpr abs(const Mat_<_Tp>& m)
    01283 {
    01284     return cv::abs((const Mat&)m);
    01285 }
    01286
    01288
    01289 inline Mat& Mat::operator = (const MatExpr& e)
    01290 {
    01291     e.op->assign(e, *this);
    01292     return *this;
    01293 }
    01294
    01295 template<typename _Tp> Mat_<_Tp>& Mat_<_Tp>::operator = (const MatExpr& e)
    01296 {
    01297     e.op->assign(e, *this, DataType<_Tp>::type);
    01298     return *this;
    01299 }
    01300
    01301 static inline Mat& operator += (const Mat& a, const Mat& b)
    01302 {
    01303     add(a, b, (Mat&)a);
    01304     return (Mat&)a;
    01305 }
    01306
    01307 static inline Mat& operator += (const Mat& a, const Scalar& s)
    01308 {
    01309     add(a, s, (Mat&)a);
    01310     return (Mat&)a;
    01311 }
    01312
    01313 template<typename _Tp> static inline
    01314 Mat_<_Tp>& operator += (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
    01315 {
    01316     add(a, b, (Mat&)a);
    01317     return (Mat_<_Tp>&)a;
    01318 }
    01319
    01320 template<typename _Tp> static inline
    01321 Mat_<_Tp>& operator += (const Mat_<_Tp>& a, const Scalar& s)
    01322 {
    01323     add(a, s, (Mat&)a);
    01324     return (Mat_<_Tp>&)a;
    01325 }
    01326
    01327 static inline Mat& operator += (const Mat& a, const MatExpr& b)
    01328 {
    01329     b.op->augAssignAdd(b, (Mat&)a);
    01330     return (Mat&)a;
    01331 }
    01332
    01333 template<typename _Tp> static inline
    01334 Mat_<_Tp>& operator += (const Mat_<_Tp>& a, const MatExpr& b)
    01335 {
    01336     b.op->augAssignAdd(b, (Mat&)a);
    01337     return (Mat_<_Tp>&)a;
    01338 }
    01339
    01340 static inline Mat& operator -= (const Mat& a, const Mat& b)
    01341 {
    01342     subtract(a, b, (Mat&)a);
    01343     return (Mat&)a;
    01344 }
    01345
    01346 static inline Mat& operator -= (const Mat& a, const Scalar& s)
    01347 {
    01348     subtract(a, s, (Mat&)a);
    01349     return (Mat&)a;
    01350 }
    01351
    01352 template<typename _Tp> static inline
    01353 Mat_<_Tp>& operator -= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
    01354 {
    01355     subtract(a, b, (Mat&)a);
    01356     return (Mat_<_Tp>&)a;
    01357 }
    01358
    01359 template<typename _Tp> static inline
    01360 Mat_<_Tp>& operator -= (const Mat_<_Tp>& a, const Scalar& s)
    01361 {
    01362     subtract(a, s, (Mat&)a);
    01363     return (Mat_<_Tp>&)a;
    01364 }
    01365
    01366 static inline Mat& operator -= (const Mat& a, const MatExpr& b)
    01367 {
    01368     b.op->augAssignSubtract(b, (Mat&)a);
    01369     return (Mat&)a;
    01370 }
    01371
    01372 template<typename _Tp> static inline
    01373 Mat_<_Tp>& operator -= (const Mat_<_Tp>& a, const MatExpr& b)
    01374 {
    01375     b.op->augAssignSubtract(b, (Mat&)a);
    01376     return (Mat_<_Tp>&)a;
    01377 }
    01378
    01379 static inline Mat& operator *= (const Mat& a, const Mat& b)
    01380 {
    01381     gemm(a, b, 1, Mat(), 0, (Mat&)a, 0);
    01382     return (Mat&)a;
    01383 }
    01384
    01385 static inline Mat& operator *= (const Mat& a, double s)
    01386 {
    01387     a.convertTo((Mat&)a, -1, s);
    01388     return (Mat&)a;
    01389 }
    01390
    01391 template<typename _Tp> static inline
    01392 Mat_<_Tp>& operator *= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
    01393 {
    01394     gemm(a, b, 1, Mat(), 0, (Mat&)a, 0);
    01395     return (Mat_<_Tp>&)a;
    01396 }
    01397
    01398 template<typename _Tp> static inline
    01399 Mat_<_Tp>& operator *= (const Mat_<_Tp>& a, double s)
    01400 {
    01401     a.convertTo((Mat&)a, -1, s);
    01402     return (Mat_<_Tp>&)a;
    01403 }
    01404
    01405 static inline Mat& operator *= (const Mat& a, const MatExpr& b)
    01406 {
    01407     b.op->augAssignMultiply(b, (Mat&)a);
    01408     return (Mat&)a;
    01409 }
    01410
    01411 template<typename _Tp> static inline
    01412 Mat_<_Tp>& operator *= (const Mat_<_Tp>& a, const MatExpr& b)
    01413 {
    01414     b.op->augAssignMultiply(b, (Mat&)a);
    01415     return (Mat_<_Tp>&)a;
    01416 }
    01417
    01418 static inline Mat& operator /= (const Mat& a, const Mat& b)
    01419 {
    01420     divide(a, b, (Mat&)a);
    01421     return (Mat&)a;
    01422 }
    01423
    01424 static inline Mat& operator /= (const Mat& a, double s)
    01425 {
    01426     a.convertTo((Mat&)a, -1, 1./s);
    01427     return (Mat&)a;
    01428 }
    01429
    01430 template<typename _Tp> static inline
    01431 Mat_<_Tp>& operator /= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
    01432 {
    01433     divide(a, b, (Mat&)a);
    01434     return (Mat_<_Tp>&)a;
    01435 }
    01436
    01437 template<typename _Tp> static inline
    01438 Mat_<_Tp>& operator /= (const Mat_<_Tp>& a, double s)
    01439 {
    01440     a.convertTo((Mat&)a, -1, 1./s);
    01441     return (Mat_<_Tp>&)a;
    01442 }
    01443
    01444 static inline Mat& operator /= (const Mat& a, const MatExpr& b)
    01445 {
    01446     b.op->augAssignDivide(b, (Mat&)a);
    01447     return (Mat&)a;
    01448 }
    01449
    01450 template<typename _Tp> static inline
    01451 Mat_<_Tp>& operator /= (const Mat_<_Tp>& a, const MatExpr& b)
    01452 {
    01453     b.op->augAssignDivide(b, (Mat&)a);
    01454     return (Mat_<_Tp>&)a;
    01455 }
    01456
    01458
    01459 static inline Mat& operator &= (const Mat& a, const Mat& b)
    01460 {
    01461     bitwise_and(a, b, (Mat&)a);
    01462     return (Mat&)a;
    01463 }
    01464
    01465 static inline Mat& operator &= (const Mat& a, const Scalar& s)
    01466 {
    01467     bitwise_and(a, s, (Mat&)a);
    01468     return (Mat&)a;
    01469 }
    01470
    01471 template<typename _Tp> static inline Mat_<_Tp>&
    01472 operator &= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
    01473 {
    01474     bitwise_and(a, b, (Mat&)a);
    01475     return (Mat_<_Tp>&)a;
    01476 }
    01477
    01478 template<typename _Tp> static inline Mat_<_Tp>&
    01479 operator &= (const Mat_<_Tp>& a, const Scalar& s)
    01480 {
    01481     bitwise_and(a, s, (Mat&)a);
    01482     return (Mat_<_Tp>&)a;
    01483 }
    01484
    01485 static inline Mat& operator |= (const Mat& a, const Mat& b)
    01486 {
    01487     bitwise_or(a, b, (Mat&)a);
    01488     return (Mat&)a;
    01489 }
    01490
    01491 static inline Mat& operator |= (const Mat& a, const Scalar& s)
    01492 {
    01493     bitwise_or(a, s, (Mat&)a);
    01494     return (Mat&)a;
    01495 }
    01496
    01497 template<typename _Tp> static inline Mat_<_Tp>&
    01498 operator |= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
    01499 {
    01500     bitwise_or(a, b, (Mat&)a);
    01501     return (Mat_<_Tp>&)a;
    01502 }
    01503
    01504 template<typename _Tp> static inline Mat_<_Tp>&
    01505 operator |= (const Mat_<_Tp>& a, const Scalar& s)
    01506 {
    01507     bitwise_or(a, s, (Mat&)a);
    01508     return (Mat_<_Tp>&)a;
    01509 }
    01510
    01511 static inline Mat& operator ^= (const Mat& a, const Mat& b)
    01512 {
    01513     bitwise_xor(a, b, (Mat&)a);
    01514     return (Mat&)a;
    01515 }
    01516
    01517 static inline Mat& operator ^= (const Mat& a, const Scalar& s)
    01518 {
    01519     bitwise_xor(a, s, (Mat&)a);
    01520     return (Mat&)a;
    01521 }
    01522
    01523 template<typename _Tp> static inline Mat_<_Tp>&
    01524 operator ^= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
    01525 {
    01526     bitwise_xor(a, b, (Mat&)a);
    01527     return (Mat_<_Tp>&)a;
    01528 }
    01529
    01530 template<typename _Tp> static inline Mat_<_Tp>&
    01531 operator ^= (const Mat_<_Tp>& a, const Scalar& s)
    01532 {
    01533     bitwise_xor(a, s, (Mat&)a);
    01534     return (Mat_<_Tp>&)a;
    01535 }
    01536
    01538
    01539 template<typename _Tp> void split(const Mat& src, vector<Mat_<_Tp> >& mv)
    01540 { split(src, (vector<Mat>&)mv ); }
    01541
    01543
    01544 template<typename _Tp> inline MatExpr Mat_<_Tp>::zeros(int rows, int cols)
    01545 {
    01546     return Mat::zeros(rows, cols, DataType<_Tp>::type);
    01547 }
    01548
    01549 template<typename _Tp> inline MatExpr Mat_<_Tp>::zeros(Size sz)
    01550 {
    01551     return Mat::zeros(sz, DataType<_Tp>::type);
    01552 }
    01553
    01554 template<typename _Tp> inline MatExpr Mat_<_Tp>::ones(int rows, int cols)
    01555 {
    01556     return Mat::ones(rows, cols, DataType<_Tp>::type);
    01557 }
    01558
    01559 template<typename _Tp> inline MatExpr Mat_<_Tp>::ones(Size sz)
    01560 {
    01561     return Mat::ones(sz, DataType<_Tp>::type);
    01562 }
    01563
    01564 template<typename _Tp> inline MatExpr Mat_<_Tp>::eye(int rows, int cols)
    01565 {
    01566     return Mat::eye(rows, cols, DataType<_Tp>::type);
    01567 }
    01568
    01569 template<typename _Tp> inline MatExpr Mat_<_Tp>::eye(Size sz)
    01570 {
    01571     return Mat::eye(sz, DataType<_Tp>::type);
    01572 }
    01573
    01575
    01576 inline MatConstIterator::MatConstIterator()
    01577     : m(0), elemSize(0), ptr(0), sliceStart(0), sliceEnd(0) {}
    01578
    01579 inline MatConstIterator::MatConstIterator(const Mat* _m)
    01580     : m(_m), elemSize(_m->elemSize()), ptr(0), sliceStart(0), sliceEnd(0)
    01581 {
    01582     if( m && m->isContinuous() )
    01583     {
    01584         sliceStart = m->data;
    01585         sliceEnd = sliceStart + m->total()*elemSize;
    01586     }
    01587     seek((const int*)0);
    01588 }
    01589
    01590 inline MatConstIterator::MatConstIterator(const Mat* _m, int _row, int _col)
    01591     : m(_m), elemSize(_m->elemSize()), ptr(0), sliceStart(0), sliceEnd(0)
    01592 {
    01593     CV_Assert(m && m->dims <= 2);
    01594     if( m->isContinuous() )
    01595     {
    01596         sliceStart = m->data;
    01597         sliceEnd = sliceStart + m->total()*elemSize;
    01598     }
    01599     int idx[]={_row, _col};
    01600     seek(idx);
    01601 }
    01602
    01603 inline MatConstIterator::MatConstIterator(const Mat* _m, Point _pt)
    01604     : m(_m), elemSize(_m->elemSize()), ptr(0), sliceStart(0), sliceEnd(0)
    01605 {
    01606     CV_Assert(m && m->dims <= 2);
    01607     if( m->isContinuous() )
    01608     {
    01609         sliceStart = m->data;
    01610         sliceEnd = sliceStart + m->total()*elemSize;
    01611     }
    01612     int idx[]={_pt.y, _pt.x};
    01613     seek(idx);
    01614 }
    01615
    01616 inline MatConstIterator::MatConstIterator(const MatConstIterator& it)
    01617     : m(it.m), elemSize(it.elemSize), ptr(it.ptr), sliceStart(it.sliceStart), sliceEnd(it.sliceEnd)
    01618 {}
    01619
    01620 inline MatConstIterator& MatConstIterator::operator = (const MatConstIterator& it )
    01621 {
    01622     m = it.m; elemSize = it.elemSize; ptr = it.ptr;
    01623     sliceStart = it.sliceStart; sliceEnd = it.sliceEnd;
    01624     return *this;
    01625 }
    01626
    01627 inline uchar* MatConstIterator::operator *() const { return ptr; }
    01628
    01629 inline MatConstIterator& MatConstIterator::operator += (ptrdiff_t ofs)
    01630 {
    01631     if( !m || ofs == 0 )
    01632         return *this;
    01633     ptrdiff_t ofsb = ofs*elemSize;
    01634     ptr += ofsb;
    01635     if( ptr < sliceStart || sliceEnd <= ptr )
    01636     {
    01637         ptr -= ofsb;
    01638         seek(ofs, true);
    01639     }
    01640     return *this;
    01641 }
    01642
    01643 inline MatConstIterator& MatConstIterator::operator -= (ptrdiff_t ofs)
    01644 { return (*this += -ofs); }
    01645
    01646 inline MatConstIterator& MatConstIterator::operator --()
    01647 {
    01648     if( m && (ptr -= elemSize) < sliceStart )
    01649     {
    01650         ptr += elemSize;
    01651         seek(-1, true);
    01652     }
    01653     return *this;
    01654 }
    01655
    01656 inline MatConstIterator MatConstIterator::operator --(int)
    01657 {
    01658     MatConstIterator b = *this;
    01659     *this += -1;
    01660     return b;
    01661 }
    01662
    01663 inline MatConstIterator& MatConstIterator::operator ++()
    01664 {
    01665     if( m && (ptr += elemSize) >= sliceEnd )
    01666     {
    01667         ptr -= elemSize;
    01668         seek(1, true);
    01669     }
    01670     return *this;
    01671 }
    01672
    01673 inline MatConstIterator MatConstIterator::operator ++(int)
    01674 {
    01675     MatConstIterator b = *this;
    01676     *this += 1;
    01677     return b;
    01678 }
    01679
    01680 template<typename _Tp> inline MatConstIterator_<_Tp>::MatConstIterator_() {}
    01681
    01682 template<typename _Tp> inline MatConstIterator_<_Tp>::MatConstIterator_(const Mat_<_Tp>* _m)
    01683     : MatConstIterator(_m) {}
    01684
    01685 template<typename _Tp> inline MatConstIterator_<_Tp>::
    01686     MatConstIterator_(const Mat_<_Tp>* _m, int _row, int _col)
    01687     : MatConstIterator(_m, _row, _col) {}
    01688
    01689 template<typename _Tp> inline MatConstIterator_<_Tp>::
    01690     MatConstIterator_(const Mat_<_Tp>* _m, Point _pt)
    01691     : MatConstIterator(_m, _pt) {}
    01692
    01693 template<typename _Tp> inline MatConstIterator_<_Tp>::
    01694     MatConstIterator_(const MatConstIterator_& it)
    01695     : MatConstIterator(it) {}
    01696
    01697 template<typename _Tp> inline MatConstIterator_<_Tp>&
    01698     MatConstIterator_<_Tp>::operator = (const MatConstIterator_& it )
    01699 {
    01700     MatConstIterator::operator = (it);
    01701     return *this;
    01702 }
    01703
    01704 template<typename _Tp> inline _Tp MatConstIterator_<_Tp>::operator *() const { return *(_Tp*)(this->ptr); }
    01705
    01706 template<typename _Tp> inline MatConstIterator_<_Tp>& MatConstIterator_<_Tp>::operator += (ptrdiff_t ofs)
    01707 {
    01708     MatConstIterator::operator += (ofs);
    01709     return *this;
    01710 }
    01711
    01712 template<typename _Tp> inline MatConstIterator_<_Tp>& MatConstIterator_<_Tp>::operator -= (ptrdiff_t ofs)
    01713 { return (*this += -ofs); }
    01714
    01715 template<typename _Tp> inline MatConstIterator_<_Tp>& MatConstIterator_<_Tp>::operator --()
    01716 {
    01717     MatConstIterator::operator --();
    01718     return *this;
    01719 }
    01720
    01721 template<typename _Tp> inline MatConstIterator_<_Tp> MatConstIterator_<_Tp>::operator --(int)
    01722 {
    01723     MatConstIterator_ b = *this;
    01724     MatConstIterator::operator --();
    01725     return b;
    01726 }
    01727
    01728 template<typename _Tp> inline MatConstIterator_<_Tp>& MatConstIterator_<_Tp>::operator ++()
    01729 {
    01730     MatConstIterator::operator ++();
    01731     return *this;
    01732 }
    01733
    01734 template<typename _Tp> inline MatConstIterator_<_Tp> MatConstIterator_<_Tp>::operator ++(int)
    01735 {
    01736     MatConstIterator_ b = *this;
    01737     MatConstIterator::operator ++();
    01738     return b;
    01739 }
    01740
    01741 template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_() : MatConstIterator_<_Tp>() {}
    01742
    01743 template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(Mat_<_Tp>* _m)
    01744     : MatConstIterator_<_Tp>(_m) {}
    01745
    01746 template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(Mat_<_Tp>* _m, int _row, int _col)
    01747     : MatConstIterator_<_Tp>(_m, _row, _col) {}
    01748
    01749 template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(const Mat_<_Tp>* _m, Point _pt)
    01750     : MatConstIterator_<_Tp>(_m, _pt) {}
    01751
    01752 template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(const Mat_<_Tp>* _m, const int* _idx)
    01753     : MatConstIterator_<_Tp>(_m, _idx) {}
    01754
    01755 template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(const MatIterator_& it)
    01756     : MatConstIterator_<_Tp>(it) {}
    01757
    01758 template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator = (const MatIterator_<_Tp>& it )
    01759 {
    01760     MatConstIterator::operator = (it);
    01761     return *this;
    01762 }
    01763
    01764 template<typename _Tp> inline _Tp& MatIterator_<_Tp>::operator *() const { return *(_Tp*)(this->ptr); }
    01765
    01766 template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator += (ptrdiff_t ofs)
    01767 {
    01768     MatConstIterator::operator += (ofs);
    01769     return *this;
    01770 }
    01771
    01772 template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator -= (ptrdiff_t ofs)
    01773 {
    01774     MatConstIterator::operator += (-ofs);
    01775     return *this;
    01776 }
    01777
    01778 template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator --()
    01779 {
    01780     MatConstIterator::operator --();
    01781     return *this;
    01782 }
    01783
    01784 template<typename _Tp> inline MatIterator_<_Tp> MatIterator_<_Tp>::operator --(int)
    01785 {
    01786     MatIterator_ b = *this;
    01787     MatConstIterator::operator --();
    01788     return b;
    01789 }
    01790
    01791 template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator ++()
    01792 {
    01793     MatConstIterator::operator ++();
    01794     return *this;
    01795 }
    01796
    01797 template<typename _Tp> inline MatIterator_<_Tp> MatIterator_<_Tp>::operator ++(int)
    01798 {
    01799     MatIterator_ b = *this;
    01800     MatConstIterator::operator ++();
    01801     return b;
    01802 }
    01803
    01804 template<typename _Tp> inline Point MatConstIterator_<_Tp>::pos() const
    01805 {
    01806     if( !m )
    01807         return Point();
    01808     CV_DbgAssert( m->dims <= 2 );
    01809     if( m->isContinuous() )
    01810     {
    01811         ptrdiff_t ofs = ptr - (_Tp*)m->data;
    01812         int y = (int)(ofs / m->cols), x = (int)(ofs - (ptrdiff_t)y*m->cols);
    01813         return Point(x, y);
    01814     }
    01815     else
    01816     {
    01817         ptrdiff_t ofs = (uchar*)ptr - m->data;
    01818         int y = (int)(ofs / m->step), x = (int)((ofs - y*m->step)/sizeof(_Tp));
    01819         return Point(x, y);
    01820     }
    01821 }
    01822
    01823 static inline bool
    01824 operator == (const MatConstIterator& a, const MatConstIterator& b)
    01825 { return a.m == b.m && a.ptr == b.ptr; }
    01826
    01827 template<typename _Tp> static inline bool
    01828 operator != (const MatConstIterator& a, const MatConstIterator& b)
    01829 { return !(a == b); }
    01830
    01831 template<typename _Tp> static inline bool
    01832 operator == (const MatConstIterator_<_Tp>& a, const MatConstIterator_<_Tp>& b)
    01833 { return a.m == b.m && a.ptr == b.ptr; }
    01834
    01835 template<typename _Tp> static inline bool
    01836 operator != (const MatConstIterator_<_Tp>& a, const MatConstIterator_<_Tp>& b)
    01837 { return a.m != b.m || a.ptr != b.ptr; }
    01838
    01839 template<typename _Tp> static inline bool
    01840 operator == (const MatIterator_<_Tp>& a, const MatIterator_<_Tp>& b)
    01841 { return a.m == b.m && a.ptr == b.ptr; }
    01842
    01843 template<typename _Tp> static inline bool
    01844 operator != (const MatIterator_<_Tp>& a, const MatIterator_<_Tp>& b)
    01845 { return a.m != b.m || a.ptr != b.ptr; }
    01846
    01847 static inline bool
    01848 operator < (const MatConstIterator& a, const MatConstIterator& b)
    01849 { return a.ptr < b.ptr; }
    01850
    01851 static inline bool
    01852 operator > (const MatConstIterator& a, const MatConstIterator& b)
    01853 { return a.ptr > b.ptr; }
    01854
    01855 static inline bool
    01856 operator <= (const MatConstIterator& a, const MatConstIterator& b)
    01857 { return a.ptr <= b.ptr; }
    01858
    01859 static inline bool
    01860 operator >= (const MatConstIterator& a, const MatConstIterator& b)
    01861 { return a.ptr >= b.ptr; }
    01862
    01863 CV_EXPORTS ptrdiff_t operator - (const MatConstIterator& b, const MatConstIterator& a);
    01864
    01865 static inline MatConstIterator operator + (const MatConstIterator& a, ptrdiff_t ofs)
    01866 { MatConstIterator b = a; return b += ofs; }
    01867
    01868 static inline MatConstIterator operator + (ptrdiff_t ofs, const MatConstIterator& a)
    01869 { MatConstIterator b = a; return b += ofs; }
    01870
    01871 static inline MatConstIterator operator - (const MatConstIterator& a, ptrdiff_t ofs)
    01872 { MatConstIterator b = a; return b += -ofs; }
    01873
    01874 template<typename _Tp> static inline MatConstIterator_<_Tp>
    01875 operator + (const MatConstIterator_<_Tp>& a, ptrdiff_t ofs)
    01876 { MatConstIterator t = (const MatConstIterator&)a + ofs; return (MatConstIterator_<_Tp>&)t; }
    01877
    01878 template<typename _Tp> static inline MatConstIterator_<_Tp>
    01879 operator + (ptrdiff_t ofs, const MatConstIterator_<_Tp>& a)
    01880 { MatConstIterator t = (const MatConstIterator&)a + ofs; return (MatConstIterator_<_Tp>&)t; }
    01881
    01882 template<typename _Tp> static inline MatConstIterator_<_Tp>
    01883 operator - (const MatConstIterator_<_Tp>& a, ptrdiff_t ofs)
    01884 { MatConstIterator t = (const MatConstIterator&)a - ofs; return (MatConstIterator_<_Tp>&)t; }
    01885
    01886 inline uchar* MatConstIterator::operator [](ptrdiff_t i) const
    01887 { return *(*this + i); }
    01888
    01889 template<typename _Tp> inline _Tp MatConstIterator_<_Tp>::operator [](ptrdiff_t i) const
    01890 { return *(_Tp*)MatConstIterator::operator [](i); }
    01891
    01892 template<typename _Tp> static inline MatIterator_<_Tp>
    01893 operator + (const MatIterator_<_Tp>& a, ptrdiff_t ofs)
    01894 { MatConstIterator t = (const MatConstIterator&)a + ofs; return (MatIterator_<_Tp>&)t; }
    01895
    01896 template<typename _Tp> static inline MatIterator_<_Tp>
    01897 operator + (ptrdiff_t ofs, const MatIterator_<_Tp>& a)
    01898 { MatConstIterator t = (const MatConstIterator&)a + ofs; return (MatIterator_<_Tp>&)t; }
    01899
    01900 template<typename _Tp> static inline MatIterator_<_Tp>
    01901 operator - (const MatIterator_<_Tp>& a, ptrdiff_t ofs)
    01902 { MatConstIterator t = (const MatConstIterator&)a - ofs; return (MatIterator_<_Tp>&)t; }
    01903
    01904 template<typename _Tp> inline _Tp& MatIterator_<_Tp>::operator [](ptrdiff_t i) const
    01905 { return *(*this + i); }
    01906
    01907 template<typename _Tp> inline MatConstIterator_<_Tp> Mat_<_Tp>::begin() const
    01908 { return Mat::begin<_Tp>(); }
    01909
    01910 template<typename _Tp> inline MatConstIterator_<_Tp> Mat_<_Tp>::end() const
    01911 { return Mat::end<_Tp>(); }
    01912
    01913 template<typename _Tp> inline MatIterator_<_Tp> Mat_<_Tp>::begin()
    01914 { return Mat::begin<_Tp>(); }
    01915
    01916 template<typename _Tp> inline MatIterator_<_Tp> Mat_<_Tp>::end()
    01917 { return Mat::end<_Tp>(); }
    01918
    01919 template<typename _Tp> inline MatCommaInitializer_<_Tp>::MatCommaInitializer_(Mat_<_Tp>* _m) : it(_m) {}
    01920
    01921 template<typename _Tp> template<typename T2> inline MatCommaInitializer_<_Tp>&
    01922 MatCommaInitializer_<_Tp>::operator , (T2 v)
    01923 {
    01924     CV_DbgAssert( this->it < ((const Mat_<_Tp>*)this->it.m)->end() );
    01925     *this->it = _Tp(v); ++this->it;
    01926     return *this;
    01927 }
    01928
    01929 template<typename _Tp> inline Mat_<_Tp> MatCommaInitializer_<_Tp>::operator *() const
    01930 {
    01931     CV_DbgAssert( this->it == ((const Mat_<_Tp>*)this->it.m)->end() );
    01932     return Mat_<_Tp>(*this->it.m);
    01933 }
    01934
    01935 template<typename _Tp> inline MatCommaInitializer_<_Tp>::operator Mat_<_Tp>() const
    01936 {
    01937     CV_DbgAssert( this->it == ((const Mat_<_Tp>*)this->it.m)->end() );
    01938     return Mat_<_Tp>(*this->it.m);
    01939 }
    01940
    01941 template<typename _Tp, typename T2> static inline MatCommaInitializer_<_Tp>
    01942 operator << (const Mat_<_Tp>& m, T2 val)
    01943 {
    01944     MatCommaInitializer_<_Tp> commaInitializer((Mat_<_Tp>*)&m);
    01945     return (commaInitializer, val);
    01946 }
    01947
    01949
    01950 inline SparseMat::SparseMat()
    01951 : flags(MAGIC_VAL), hdr(0)
    01952 {
    01953 }
    01954
    01955 inline SparseMat::SparseMat(int _dims, const int* _sizes, int _type)
    01956 : flags(MAGIC_VAL), hdr(0)
    01957 {
    01958     create(_dims, _sizes, _type);
    01959 }
    01960
    01961 inline SparseMat::SparseMat(const SparseMat& m)
    01962 : flags(m.flags), hdr(m.hdr)
    01963 {
    01964     addref();
    01965 }
    01966
    01967 inline SparseMat::~SparseMat()
    01968 {
    01969     release();
    01970 }
    01971
    01972 inline SparseMat& SparseMat::operator = (const SparseMat& m)
    01973 {
    01974     if( this != &m )
    01975     {
    01976         if( m.hdr )
    01977             CV_XADD(&m.hdr->refcount, 1);
    01978         release();
    01979         flags = m.flags;
    01980         hdr = m.hdr;
    01981     }
    01982     return *this;
    01983 }
    01984
    01985 inline SparseMat& SparseMat::operator = (const Mat& m)
    01986 { return (*this = SparseMat(m)); }
    01987
    01988 inline SparseMat SparseMat::clone() const
    01989 {
    01990     SparseMat temp;
    01991     this->copyTo(temp);
    01992     return temp;
    01993 }
    01994
    01995
    01996 inline void SparseMat::assignTo( SparseMat& m, int type ) const
    01997 {
    01998     if( type < 0 )
    01999         m = *this;
    02000     else
    02001         convertTo(m, type);
    02002 }
    02003
    02004 inline void SparseMat::addref()
    02005 { if( hdr ) CV_XADD(&hdr->refcount, 1); }
    02006
    02007 inline void SparseMat::release()
    02008 {
    02009     if( hdr && CV_XADD(&hdr->refcount, -1) == 1 )
    02010         delete hdr;
    02011     hdr = 0;
    02012 }
    02013
    02014 inline size_t SparseMat::elemSize() const
    02015 { return CV_ELEM_SIZE(flags); }
    02016
    02017 inline size_t SparseMat::elemSize1() const
    02018 { return CV_ELEM_SIZE1(flags); }
    02019
    02020 inline int SparseMat::type() const
    02021 { return CV_MAT_TYPE(flags); }
    02022
    02023 inline int SparseMat::depth() const
    02024 { return CV_MAT_DEPTH(flags); }
    02025
    02026 inline int SparseMat::channels() const
    02027 { return CV_MAT_CN(flags); }
    02028
    02029 inline const int* SparseMat::size() const
    02030 {
    02031     return hdr ? hdr->size : 0;
    02032 }
    02033
    02034 inline int SparseMat::size(int i) const
    02035 {
    02036     if( hdr )
    02037     {
    02038         CV_DbgAssert((unsigned)i < (unsigned)hdr->dims);
    02039         return hdr->size[i];
    02040     }
    02041     return 0;
    02042 }
    02043
    02044 inline int SparseMat::dims() const
    02045 {
    02046     return hdr ? hdr->dims : 0;
    02047 }
    02048
    02049 inline size_t SparseMat::nzcount() const
    02050 {
    02051     return hdr ? hdr->nodeCount : 0;
    02052 }
    02053
    02054 inline size_t SparseMat::hash(int i0) const
    02055 {
    02056     return (size_t)i0;
    02057 }
    02058
    02059 inline size_t SparseMat::hash(int i0, int i1) const
    02060 {
    02061     return (size_t)(unsigned)i0*HASH_SCALE + (unsigned)i1;
    02062 }
    02063
    02064 inline size_t SparseMat::hash(int i0, int i1, int i2) const
    02065 {
    02066     return ((size_t)(unsigned)i0*HASH_SCALE + (unsigned)i1)*HASH_SCALE + (unsigned)i2;
    02067 }
    02068
    02069 inline size_t SparseMat::hash(const int* idx) const
    02070 {
    02071     size_t h = (unsigned)idx[0];
    02072     if( !hdr )
    02073         return 0;
    02074     int i, d = hdr->dims;
    02075     for( i = 1; i < d; i++ )
    02076         h = h*HASH_SCALE + (unsigned)idx[i];
    02077     return h;
    02078 }
    02079
    02080 template<typename _Tp> inline _Tp& SparseMat::ref(int i0, size_t* hashval)
    02081 { return *(_Tp*)((SparseMat*)this)->ptr(i0, true, hashval); }
    02082
    02083 template<typename _Tp> inline _Tp& SparseMat::ref(int i0, int i1, size_t* hashval)
    02084 { return *(_Tp*)((SparseMat*)this)->ptr(i0, i1, true, hashval); }
    02085
    02086 template<typename _Tp> inline _Tp& SparseMat::ref(int i0, int i1, int i2, size_t* hashval)
    02087 { return *(_Tp*)((SparseMat*)this)->ptr(i0, i1, i2, true, hashval); }
    02088
    02089 template<typename _Tp> inline _Tp& SparseMat::ref(const int* idx, size_t* hashval)
    02090 { return *(_Tp*)((SparseMat*)this)->ptr(idx, true, hashval); }
    02091
    02092 template<typename _Tp> inline _Tp SparseMat::value(int i0, size_t* hashval) const
    02093 {
    02094     const _Tp* p = (const _Tp*)((SparseMat*)this)->ptr(i0, false, hashval);
    02095     return p ? *p : _Tp();
    02096 }
    02097
    02098 template<typename _Tp> inline _Tp SparseMat::value(int i0, int i1, size_t* hashval) const
    02099 {
    02100     const _Tp* p = (const _Tp*)((SparseMat*)this)->ptr(i0, i1, false, hashval);
    02101     return p ? *p : _Tp();
    02102 }
    02103
    02104 template<typename _Tp> inline _Tp SparseMat::value(int i0, int i1, int i2, size_t* hashval) const
    02105 {
    02106     const _Tp* p = (const _Tp*)((SparseMat*)this)->ptr(i0, i1, i2, false, hashval);
    02107     return p ? *p : _Tp();
    02108 }
    02109
    02110 template<typename _Tp> inline _Tp SparseMat::value(const int* idx, size_t* hashval) const
    02111 {
    02112     const _Tp* p = (const _Tp*)((SparseMat*)this)->ptr(idx, false, hashval);
    02113     return p ? *p : _Tp();
    02114 }
    02115
    02116 template<typename _Tp> inline const _Tp* SparseMat::find(int i0, size_t* hashval) const
    02117 { return (const _Tp*)((SparseMat*)this)->ptr(i0, false, hashval); }
    02118
    02119 template<typename _Tp> inline const _Tp* SparseMat::find(int i0, int i1, size_t* hashval) const
    02120 { return (const _Tp*)((SparseMat*)this)->ptr(i0, i1, false, hashval); }
    02121
    02122 template<typename _Tp> inline const _Tp* SparseMat::find(int i0, int i1, int i2, size_t* hashval) const
    02123 { return (const _Tp*)((SparseMat*)this)->ptr(i0, i1, i2, false, hashval); }
    02124
    02125 template<typename _Tp> inline const _Tp* SparseMat::find(const int* idx, size_t* hashval) const
    02126 { return (const _Tp*)((SparseMat*)this)->ptr(idx, false, hashval); }
    02127
    02128 template<typename _Tp> inline _Tp& SparseMat::value(Node* n)
    02129 { return *(_Tp*)((uchar*)n + hdr->valueOffset); }
    02130
    02131 template<typename _Tp> inline const _Tp& SparseMat::value(const Node* n) const
    02132 { return *(const _Tp*)((const uchar*)n + hdr->valueOffset); }
    02133
    02134 inline SparseMat::Node* SparseMat::node(size_t nidx)
    02135 { return (Node*)&hdr->pool[nidx]; }
    02136
    02137 inline const SparseMat::Node* SparseMat::node(size_t nidx) const
    02138 { return (const Node*)&hdr->pool[nidx]; }
    02139
    02140 inline SparseMatIterator SparseMat::begin()
    02141 { return SparseMatIterator(this); }
    02142
    02143 inline SparseMatConstIterator SparseMat::begin() const
    02144 { return SparseMatConstIterator(this); }
    02145
    02146 inline SparseMatIterator SparseMat::end()
    02147 { SparseMatIterator it(this); it.seekEnd(); return it; }
    02148
    02149 inline SparseMatConstIterator SparseMat::end() const
    02150 { SparseMatConstIterator it(this); it.seekEnd(); return it; }
    02151
    02152 template<typename _Tp> inline SparseMatIterator_<_Tp> SparseMat::begin()
    02153 { return SparseMatIterator_<_Tp>(this); }
    02154
    02155 template<typename _Tp> inline SparseMatConstIterator_<_Tp> SparseMat::begin() const
    02156 { return SparseMatConstIterator_<_Tp>(this); }
    02157
    02158 template<typename _Tp> inline SparseMatIterator_<_Tp> SparseMat::end()
    02159 { SparseMatIterator_<_Tp> it(this); it.seekEnd(); return it; }
    02160
    02161 template<typename _Tp> inline SparseMatConstIterator_<_Tp> SparseMat::end() const
    02162 { SparseMatConstIterator_<_Tp> it(this); it.seekEnd(); return it; }
    02163
    02164
    02165 inline SparseMatConstIterator::SparseMatConstIterator()
    02166 : m(0), hashidx(0), ptr(0)
    02167 {
    02168 }
    02169
    02170 inline SparseMatConstIterator::SparseMatConstIterator(const SparseMatConstIterator& it)
    02171 : m(it.m), hashidx(it.hashidx), ptr(it.ptr)
    02172 {
    02173 }
    02174
    02175 static inline bool operator == (const SparseMatConstIterator& it1, const SparseMatConstIterator& it2)
    02176 { return it1.m == it2.m && it1.hashidx == it2.hashidx && it1.ptr == it2.ptr; }
    02177
    02178 static inline bool operator != (const SparseMatConstIterator& it1, const SparseMatConstIterator& it2)
    02179 { return !(it1 == it2); }
    02180
    02181
    02182 inline SparseMatConstIterator& SparseMatConstIterator::operator = (const SparseMatConstIterator& it)
    02183 {
    02184     if( this != &it )
    02185     {
    02186         m = it.m;
    02187         hashidx = it.hashidx;
    02188         ptr = it.ptr;
    02189     }
    02190     return *this;
    02191 }
    02192
    02193 template<typename _Tp> inline const _Tp& SparseMatConstIterator::value() const
    02194 { return *(_Tp*)ptr; }
    02195
    02196 inline const SparseMat::Node* SparseMatConstIterator::node() const
    02197 {
    02198     return ptr && m && m->hdr ?
    02199         (const SparseMat::Node*)(ptr - m->hdr->valueOffset) : 0;
    02200 }
    02201
    02202 inline SparseMatConstIterator SparseMatConstIterator::operator ++(int)
    02203 {
    02204     SparseMatConstIterator it = *this;
    02205     ++*this;
    02206     return it;
    02207 }
    02208
    02209
    02210 inline void SparseMatConstIterator::seekEnd()
    02211 {
    02212     if( m && m->hdr )
    02213     {
    02214         hashidx = m->hdr->hashtab.size();
    02215         ptr = 0;
    02216     }
    02217 }
    02218
    02219 inline SparseMatIterator::SparseMatIterator()
    02220 {}
    02221
    02222 inline SparseMatIterator::SparseMatIterator(SparseMat* _m)
    02223 : SparseMatConstIterator(_m)
    02224 {}
    02225
    02226 inline SparseMatIterator::SparseMatIterator(const SparseMatIterator& it)
    02227 : SparseMatConstIterator(it)
    02228 {
    02229 }
    02230
    02231 inline SparseMatIterator& SparseMatIterator::operator = (const SparseMatIterator& it)
    02232 {
    02233     (SparseMatConstIterator&)*this = it;
    02234     return *this;
    02235 }
    02236
    02237 template<typename _Tp> inline _Tp& SparseMatIterator::value() const
    02238 { return *(_Tp*)ptr; }
    02239
    02240 inline SparseMat::Node* SparseMatIterator::node() const
    02241 {
    02242     return (SparseMat::Node*)SparseMatConstIterator::node();
    02243 }
    02244
    02245 inline SparseMatIterator& SparseMatIterator::operator ++()
    02246 {
    02247     SparseMatConstIterator::operator ++();
    02248     return *this;
    02249 }
    02250
    02251 inline SparseMatIterator SparseMatIterator::operator ++(int)
    02252 {
    02253     SparseMatIterator it = *this;
    02254     ++*this;
    02255     return it;
    02256 }
    02257
    02258
    02259 template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_()
    02260 { flags = MAGIC_VAL | DataType<_Tp>::type; }
    02261
    02262 template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(int _dims, const int* _sizes)
    02263 : SparseMat(_dims, _sizes, DataType<_Tp>::type)
    02264 {}
    02265
    02266 template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const SparseMat& m)
    02267 {
    02268     if( m.type() == DataType<_Tp>::type )
    02269         *this = (const SparseMat_<_Tp>&)m;
    02270     else
    02271         m.convertTo(this, DataType<_Tp>::type);
    02272 }
    02273
    02274 template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const SparseMat_<_Tp>& m)
    02275 {
    02276     this->flags = m.flags;
    02277     this->hdr = m.hdr;
    02278     if( this->hdr )
    02279         CV_XADD(&this->hdr->refcount, 1);
    02280 }
    02281
    02282 template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const Mat& m)
    02283 {
    02284     SparseMat sm(m);
    02285     *this = sm;
    02286 }
    02287
    02288 template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const CvSparseMat* m)
    02289 {
    02290     SparseMat sm(m);
    02291     *this = sm;
    02292 }
    02293
    02294 template<typename _Tp> inline SparseMat_<_Tp>&
    02295 SparseMat_<_Tp>::operator = (const SparseMat_<_Tp>& m)
    02296 {
    02297     if( this != &m )
    02298     {
    02299         if( m.hdr ) CV_XADD(&m.hdr->refcount, 1);
    02300         release();
    02301         flags = m.flags;
    02302         hdr = m.hdr;
    02303     }
    02304     return *this;
    02305 }
    02306
    02307 template<typename _Tp> inline SparseMat_<_Tp>&
    02308 SparseMat_<_Tp>::operator = (const SparseMat& m)
    02309 {
    02310     if( m.type() == DataType<_Tp>::type )
    02311         return (*this = (const SparseMat_<_Tp>&)m);
    02312     m.convertTo(*this, DataType<_Tp>::type);
    02313     return *this;
    02314 }
    02315
    02316 template<typename _Tp> inline SparseMat_<_Tp>&
    02317 SparseMat_<_Tp>::operator = (const Mat& m)
    02318 { return (*this = SparseMat(m)); }
    02319
    02320 template<typename _Tp> inline SparseMat_<_Tp>
    02321 SparseMat_<_Tp>::clone() const
    02322 {
    02323     SparseMat_<_Tp> m;
    02324     this->copyTo(m);
    02325     return m;
    02326 }
    02327
    02328 template<typename _Tp> inline void
    02329 SparseMat_<_Tp>::create(int _dims, const int* _sizes)
    02330 {
    02331     SparseMat::create(_dims, _sizes, DataType<_Tp>::type);
    02332 }
    02333
    02334 template<typename _Tp> inline
    02335 SparseMat_<_Tp>::operator CvSparseMat*() const
    02336 {
    02337     return SparseMat::operator CvSparseMat*();
    02338 }
    02339
    02340 template<typename _Tp> inline int SparseMat_<_Tp>::type() const
    02341 { return DataType<_Tp>::type; }
    02342
    02343 template<typename _Tp> inline int SparseMat_<_Tp>::depth() const
    02344 { return DataType<_Tp>::depth; }
    02345
    02346 template<typename _Tp> inline int SparseMat_<_Tp>::channels() const
    02347 { return DataType<_Tp>::channels; }
    02348
    02349 template<typename _Tp> inline _Tp&
    02350 SparseMat_<_Tp>::ref(int i0, size_t* hashval)
    02351 { return SparseMat::ref<_Tp>(i0, hashval); }
    02352
    02353 template<typename _Tp> inline _Tp
    02354 SparseMat_<_Tp>::operator()(int i0, size_t* hashval) const
    02355 { return SparseMat::value<_Tp>(i0, hashval); }
    02356
    02357 template<typename _Tp> inline _Tp&
    02358 SparseMat_<_Tp>::ref(int i0, int i1, size_t* hashval)
    02359 { return SparseMat::ref<_Tp>(i0, i1, hashval); }
    02360
    02361 template<typename _Tp> inline _Tp
    02362 SparseMat_<_Tp>::operator()(int i0, int i1, size_t* hashval) const
    02363 { return SparseMat::value<_Tp>(i0, i1, hashval); }
    02364
    02365 template<typename _Tp> inline _Tp&
    02366 SparseMat_<_Tp>::ref(int i0, int i1, int i2, size_t* hashval)
    02367 { return SparseMat::ref<_Tp>(i0, i1, i2, hashval); }
    02368
    02369 template<typename _Tp> inline _Tp
    02370 SparseMat_<_Tp>::operator()(int i0, int i1, int i2, size_t* hashval) const
    02371 { return SparseMat::value<_Tp>(i0, i1, i2, hashval); }
    02372
    02373 template<typename _Tp> inline _Tp&
    02374 SparseMat_<_Tp>::ref(const int* idx, size_t* hashval)
    02375 { return SparseMat::ref<_Tp>(idx, hashval); }
    02376
    02377 template<typename _Tp> inline _Tp
    02378 SparseMat_<_Tp>::operator()(const int* idx, size_t* hashval) const
    02379 { return SparseMat::value<_Tp>(idx, hashval); }
    02380
    02381 template<typename _Tp> inline SparseMatIterator_<_Tp> SparseMat_<_Tp>::begin()
    02382 { return SparseMatIterator_<_Tp>(this); }
    02383
    02384 template<typename _Tp> inline SparseMatConstIterator_<_Tp> SparseMat_<_Tp>::begin() const
    02385 { return SparseMatConstIterator_<_Tp>(this); }
    02386
    02387 template<typename _Tp> inline SparseMatIterator_<_Tp> SparseMat_<_Tp>::end()
    02388 { SparseMatIterator_<_Tp> it(this); it.seekEnd(); return it; }
    02389
    02390 template<typename _Tp> inline SparseMatConstIterator_<_Tp> SparseMat_<_Tp>::end() const
    02391 { SparseMatConstIterator_<_Tp> it(this); it.seekEnd(); return it; }
    02392
    02393 template<typename _Tp> inline
    02394 SparseMatConstIterator_<_Tp>::SparseMatConstIterator_()
    02395 {}
    02396
    02397 template<typename _Tp> inline
    02398 SparseMatConstIterator_<_Tp>::SparseMatConstIterator_(const SparseMat_<_Tp>* _m)
    02399 : SparseMatConstIterator(_m)
    02400 {}
    02401
    02402 template<typename _Tp> inline
    02403 SparseMatConstIterator_<_Tp>::SparseMatConstIterator_(const SparseMatConstIterator_<_Tp>& it)
    02404 : SparseMatConstIterator(it)
    02405 {}
    02406
    02407 template<typename _Tp> inline SparseMatConstIterator_<_Tp>&
    02408 SparseMatConstIterator_<_Tp>::operator = (const SparseMatConstIterator_<_Tp>& it)
    02409 { return ((SparseMatConstIterator&)*this = it); }
    02410
    02411 template<typename _Tp> inline const _Tp&
    02412 SparseMatConstIterator_<_Tp>::operator *() const
    02413 { return *(const _Tp*)this->ptr; }
    02414
    02415 template<typename _Tp> inline SparseMatConstIterator_<_Tp>&
    02416 SparseMatConstIterator_<_Tp>::operator ++()
    02417 {
    02418     SparseMatConstIterator::operator ++();
    02419     return *this;
    02420 }
    02421
    02422 template<typename _Tp> inline SparseMatConstIterator_<_Tp>
    02423 SparseMatConstIterator_<_Tp>::operator ++(int)
    02424 {
    02425     SparseMatConstIterator it = *this;
    02426     SparseMatConstIterator::operator ++();
    02427     return it;
    02428 }
    02429
    02430 template<typename _Tp> inline
    02431 SparseMatIterator_<_Tp>::SparseMatIterator_()
    02432 {}
    02433
    02434 template<typename _Tp> inline
    02435 SparseMatIterator_<_Tp>::SparseMatIterator_(SparseMat_<_Tp>* _m)
    02436 : SparseMatConstIterator_<_Tp>(_m)
    02437 {}
    02438
    02439 template<typename _Tp> inline
    02440 SparseMatIterator_<_Tp>::SparseMatIterator_(const SparseMatIterator_<_Tp>& it)
    02441 : SparseMatConstIterator_<_Tp>(it)
    02442 {}
    02443
    02444 template<typename _Tp> inline SparseMatIterator_<_Tp>&
    02445 SparseMatIterator_<_Tp>::operator = (const SparseMatIterator_<_Tp>& it)
    02446 { return ((SparseMatIterator&)*this = it); }
    02447
    02448 template<typename _Tp> inline _Tp&
    02449 SparseMatIterator_<_Tp>::operator *() const
    02450 { return *(_Tp*)this->ptr; }
    02451
    02452 template<typename _Tp> inline SparseMatIterator_<_Tp>&
    02453 SparseMatIterator_<_Tp>::operator ++()
    02454 {
    02455     SparseMatConstIterator::operator ++();
    02456     return *this;
    02457 }
    02458
    02459 template<typename _Tp> inline SparseMatIterator_<_Tp>
    02460 SparseMatIterator_<_Tp>::operator ++(int)
    02461 {
    02462     SparseMatIterator it = *this;
    02463     SparseMatConstIterator::operator ++();
    02464     return it;
    02465 }
    02466
    02467 }
    02468
    02469 #endif
    02470 #endif

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines