modules/core/include/opencv2/core/mat.hpp

   1 /*M///////////////////////////////////////////////////////////////////////////////////////
   2 //
   3 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
   4 //
   5 //  By downloading, copying, installing or using the software you agree to this license.
   6 //  If you do not agree to this license, do not download, install,
   7 //  copy or use the software.
   8 //
   9 //
  10 //                          License Agreement
  11 //                For Open Source Computer Vision Library
  12 //
  13 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
  14 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
  15 // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
  16 // Third party copyrights are property of their respective owners.
  17 //
  18 // Redistribution and use in source and binary forms, with or without modification,
  19 // are permitted provided that the following conditions are met:
  20 //
  21 //   * Redistribution's of source code must retain the above copyright notice,
  22 //     this list of conditions and the following disclaimer.
  23 //
  24 //   * Redistribution's in binary form must reproduce the above copyright notice,
  25 //     this list of conditions and the following disclaimer in the documentation
  26 //     and/or other materials provided with the distribution.
  27 //
  28 //   * The name of the copyright holders may not be used to endorse or promote products
  29 //     derived from this software without specific prior written permission.
  30 //
  31 // This software is provided by the copyright holders and contributors "as is" and
  32 // any express or implied warranties, including, but not limited to, the implied
  33 // warranties of merchantability and fitness for a particular purpose are disclaimed.
  34 // In no event shall the Intel Corporation or contributors be liable for any direct,
  35 // indirect, incidental, special, exemplary, or consequential damages
  36 // (including, but not limited to, procurement of substitute goods or services;
  37 // loss of use, data, or profits; or business interruption) however caused
  38 // and on any theory of liability, whether in contract, strict liability,
  39 // or tort (including negligence or otherwise) arising in any way out of
  40 // the use of this software, even if advised of the possibility of such damage.
  41 //
  42 //M*/
  43
  44 #ifndef __OPENCV_CORE_MAT_HPP__
  45 #define __OPENCV_CORE_MAT_HPP__
  46
  47 #ifndef __cplusplus
  48 #  error mat.hpp header must be compiled as C++
  49 #endif
  50
  51 #include "opencv2/core/matx.hpp"
  52 #include "opencv2/core/types.hpp"
  53
  54 #include "opencv2/core/bufferpool.hpp"
  55
  56 namespace cv
  57 {
  58
  59 enum { ACCESS_READ=1<<24, ACCESS_WRITE=1<<25,
  60     ACCESS_RW=3<<24, ACCESS_MASK=ACCESS_RW, ACCESS_FAST=1<<26 };
  61
  62 class CV_EXPORTS _OutputArray;
  63
  64 //////////////////////// Input/Output Array Arguments /////////////////////////////////
  65
  66 /*!
  67  Proxy datatype for passing Mat's and vector<>'s as input parameters
  68  */
  69 class CV_EXPORTS _InputArray
  70 {
  71 public:
  72     enum {
  73         KIND_SHIFT = 16,
  74         FIXED_TYPE = 0x8000 << KIND_SHIFT,
  75         FIXED_SIZE = 0x4000 << KIND_SHIFT,
  76         KIND_MASK = 31 << KIND_SHIFT,
  77
  78         NONE              = 0 << KIND_SHIFT,
  79         MAT               = 1 << KIND_SHIFT,
  80         MATX              = 2 << KIND_SHIFT,
  81         STD_VECTOR        = 3 << KIND_SHIFT,
  82         STD_VECTOR_VECTOR = 4 << KIND_SHIFT,
  83         STD_VECTOR_MAT    = 5 << KIND_SHIFT,
  84         EXPR              = 6 << KIND_SHIFT,
  85         OPENGL_BUFFER     = 7 << KIND_SHIFT,
  86         CUDA_MEM          = 8 << KIND_SHIFT,
  87         GPU_MAT           = 9 << KIND_SHIFT,
  88         UMAT              =10 << KIND_SHIFT,
  89         STD_VECTOR_UMAT   =11 << KIND_SHIFT,
  90         UEXPR             =12 << KIND_SHIFT
  91     };
  92
  93     _InputArray();
  94     _InputArray(int _flags, void* _obj);
  95     _InputArray(const Mat& m);
  96     _InputArray(const MatExpr& expr);
  97     _InputArray(const std::vector<Mat>& vec);
  98     template<typename _Tp> _InputArray(const Mat_<_Tp>& m);
  99     template<typename _Tp> _InputArray(const std::vector<_Tp>& vec);
 100     template<typename _Tp> _InputArray(const std::vector<std::vector<_Tp> >& vec);
 101     template<typename _Tp> _InputArray(const std::vector<Mat_<_Tp> >& vec);
 102     template<typename _Tp> _InputArray(const _Tp* vec, int n);
 103     template<typename _Tp, int m, int n> _InputArray(const Matx<_Tp, m, n>& matx);
 104     _InputArray(const double& val);
 105     _InputArray(const cuda::GpuMat& d_mat);
 106     _InputArray(const ogl::Buffer& buf);
 107     _InputArray(const cuda::CudaMem& cuda_mem);
 108     template<typename _Tp> _InputArray(const cudev::GpuMat_<_Tp>& m);
 109     _InputArray(const UMat& um);
 110     _InputArray(const std::vector<UMat>& umv);
 111     _InputArray(const UMatExpr& uexpr);
 112
 113     virtual Mat getMat(int idx=-1) const;
 114     virtual UMat getUMat(int idx=-1) const;
 115     virtual void getMatVector(std::vector<Mat>& mv) const;
 116     virtual void getUMatVector(std::vector<UMat>& umv) const;
 117     virtual cuda::GpuMat getGpuMat() const;
 118     virtual ogl::Buffer getOGlBuffer() const;
 119     void* getObj() const;
 120
 121     virtual int kind() const;
 122     virtual int dims(int i=-1) const;
 123     virtual Size size(int i=-1) const;
 124     virtual int sizend(int* sz, int i=-1) const;
 125     virtual bool sameSize(const _InputArray& arr) const;
 126     virtual size_t total(int i=-1) const;
 127     virtual int type(int i=-1) const;
 128     virtual int depth(int i=-1) const;
 129     virtual int channels(int i=-1) const;
 130     virtual bool isContinuous(int i=-1) const;
 131     virtual bool isSubmatrix(int i=-1) const;
 132     virtual bool empty() const;
 133     virtual void copyTo(const _OutputArray& arr) const;
 134     virtual size_t offset(int i=-1) const;
 135     virtual size_t step(int i=-1) const;
 136     bool isMat() const;
 137     bool isUMat() const;
 138     bool isMatVector() const;
 139     bool isUMatVector() const;
 140     bool isMatx();
 141
 142     virtual ~_InputArray();
 143
 144 protected:
 145     int flags;
 146     void* obj;
 147     Size sz;
 148
 149     void init(int _flags, const void* _obj);
 150     void init(int _flags, const void* _obj, Size _sz);
 151 };
 152
 153
 154 /*!
 155  Proxy datatype for passing Mat's and vector<>'s as input parameters
 156  */
 157 class CV_EXPORTS _OutputArray : public _InputArray
 158 {
 159 public:
 160     enum
 161     {
 162         DEPTH_MASK_8U = 1 << CV_8U,
 163         DEPTH_MASK_8S = 1 << CV_8S,
 164         DEPTH_MASK_16U = 1 << CV_16U,
 165         DEPTH_MASK_16S = 1 << CV_16S,
 166         DEPTH_MASK_32S = 1 << CV_32S,
 167         DEPTH_MASK_32F = 1 << CV_32F,
 168         DEPTH_MASK_64F = 1 << CV_64F,
 169         DEPTH_MASK_ALL = (DEPTH_MASK_64F<<1)-1,
 170         DEPTH_MASK_ALL_BUT_8S = DEPTH_MASK_ALL & ~DEPTH_MASK_8S,
 171         DEPTH_MASK_FLT = DEPTH_MASK_32F + DEPTH_MASK_64F
 172     };
 173
 174     _OutputArray();
 175     _OutputArray(int _flags, void* _obj);
 176     _OutputArray(Mat& m);
 177     _OutputArray(std::vector<Mat>& vec);
 178     _OutputArray(cuda::GpuMat& d_mat);
 179     _OutputArray(ogl::Buffer& buf);
 180     _OutputArray(cuda::CudaMem& cuda_mem);
 181     template<typename _Tp> _OutputArray(cudev::GpuMat_<_Tp>& m);
 182     template<typename _Tp> _OutputArray(std::vector<_Tp>& vec);
 183     template<typename _Tp> _OutputArray(std::vector<std::vector<_Tp> >& vec);
 184     template<typename _Tp> _OutputArray(std::vector<Mat_<_Tp> >& vec);
 185     template<typename _Tp> _OutputArray(Mat_<_Tp>& m);
 186     template<typename _Tp> _OutputArray(_Tp* vec, int n);
 187     template<typename _Tp, int m, int n> _OutputArray(Matx<_Tp, m, n>& matx);
 188     _OutputArray(UMat& m);
 189     _OutputArray(std::vector<UMat>& vec);
 190
 191     _OutputArray(const Mat& m);
 192     _OutputArray(const std::vector<Mat>& vec);
 193     _OutputArray(const cuda::GpuMat& d_mat);
 194     _OutputArray(const ogl::Buffer& buf);
 195     _OutputArray(const cuda::CudaMem& cuda_mem);
 196     template<typename _Tp> _OutputArray(const cudev::GpuMat_<_Tp>& m);
 197     template<typename _Tp> _OutputArray(const std::vector<_Tp>& vec);
 198     template<typename _Tp> _OutputArray(const std::vector<std::vector<_Tp> >& vec);
 199     template<typename _Tp> _OutputArray(const std::vector<Mat_<_Tp> >& vec);
 200     template<typename _Tp> _OutputArray(const Mat_<_Tp>& m);
 201     template<typename _Tp> _OutputArray(const _Tp* vec, int n);
 202     template<typename _Tp, int m, int n> _OutputArray(const Matx<_Tp, m, n>& matx);
 203     _OutputArray(const UMat& m);
 204     _OutputArray(const std::vector<UMat>& vec);
 205
 206     virtual bool fixedSize() const;
 207     virtual bool fixedType() const;
 208     virtual bool needed() const;
 209     virtual Mat& getMatRef(int i=-1) const;
 210     virtual UMat& getUMatRef(int i=-1) const;
 211     virtual cuda::GpuMat& getGpuMatRef() const;
 212     virtual ogl::Buffer& getOGlBufferRef() const;
 213     virtual cuda::CudaMem& getCudaMemRef() const;
 214     virtual void create(Size sz, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
 215     virtual void create(int rows, int cols, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
 216     virtual void create(int dims, const int* size, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
 217     virtual void createSameSize(const _InputArray& arr, int mtype) const;
 218     virtual void release() const;
 219     virtual void clear() const;
 220     virtual void setTo(const _InputArray& value, const _InputArray & mask = _InputArray()) const;
 221 };
 222
 223
 224 class CV_EXPORTS _InputOutputArray : public _OutputArray
 225 {
 226 public:
 227     _InputOutputArray();
 228     _InputOutputArray(int _flags, void* _obj);
 229     _InputOutputArray(Mat& m);
 230     _InputOutputArray(std::vector<Mat>& vec);
 231     _InputOutputArray(cuda::GpuMat& d_mat);
 232     _InputOutputArray(ogl::Buffer& buf);
 233     _InputOutputArray(cuda::CudaMem& cuda_mem);
 234     template<typename _Tp> _InputOutputArray(cudev::GpuMat_<_Tp>& m);
 235     template<typename _Tp> _InputOutputArray(std::vector<_Tp>& vec);
 236     template<typename _Tp> _InputOutputArray(std::vector<std::vector<_Tp> >& vec);
 237     template<typename _Tp> _InputOutputArray(std::vector<Mat_<_Tp> >& vec);
 238     template<typename _Tp> _InputOutputArray(Mat_<_Tp>& m);
 239     template<typename _Tp> _InputOutputArray(_Tp* vec, int n);
 240     template<typename _Tp, int m, int n> _InputOutputArray(Matx<_Tp, m, n>& matx);
 241     _InputOutputArray(UMat& m);
 242     _InputOutputArray(std::vector<UMat>& vec);
 243
 244     _InputOutputArray(const Mat& m);
 245     _InputOutputArray(const std::vector<Mat>& vec);
 246     _InputOutputArray(const cuda::GpuMat& d_mat);
 247     _InputOutputArray(const ogl::Buffer& buf);
 248     _InputOutputArray(const cuda::CudaMem& cuda_mem);
 249     template<typename _Tp> _InputOutputArray(const cudev::GpuMat_<_Tp>& m);
 250     template<typename _Tp> _InputOutputArray(const std::vector<_Tp>& vec);
 251     template<typename _Tp> _InputOutputArray(const std::vector<std::vector<_Tp> >& vec);
 252     template<typename _Tp> _InputOutputArray(const std::vector<Mat_<_Tp> >& vec);
 253     template<typename _Tp> _InputOutputArray(const Mat_<_Tp>& m);
 254     template<typename _Tp> _InputOutputArray(const _Tp* vec, int n);
 255     template<typename _Tp, int m, int n> _InputOutputArray(const Matx<_Tp, m, n>& matx);
 256     _InputOutputArray(const UMat& m);
 257     _InputOutputArray(const std::vector<UMat>& vec);
 258 };
 259
 260 typedef const _InputArray& InputArray;
 261 typedef InputArray InputArrayOfArrays;
 262 typedef const _OutputArray& OutputArray;
 263 typedef OutputArray OutputArrayOfArrays;
 264 typedef const _InputOutputArray& InputOutputArray;
 265 typedef InputOutputArray InputOutputArrayOfArrays;
 266
 267 CV_EXPORTS InputOutputArray noArray();
 268
 269 /////////////////////////////////// MatAllocator //////////////////////////////////////
 270
 271 struct CV_EXPORTS UMatData;
 272
 273 /*!
 274    Custom array allocator
 275
 276 */
 277 class CV_EXPORTS MatAllocator
 278 {
 279 public:
 280     MatAllocator() {}
 281     virtual ~MatAllocator() {}
 282
 283     // let's comment it off for now to detect and fix all the uses of allocator
 284     //virtual void allocate(int dims, const int* sizes, int type, int*& refcount,
 285     //                      uchar*& datastart, uchar*& data, size_t* step) = 0;
 286     //virtual void deallocate(int* refcount, uchar* datastart, uchar* data) = 0;
 287     virtual UMatData* allocate(int dims, const int* sizes, int type,
 288                                void* data, size_t* step, int flags) const = 0;
 289     virtual bool allocate(UMatData* data, int accessflags) const = 0;
 290     virtual void deallocate(UMatData* data) const = 0;
 291     virtual void map(UMatData* data, int accessflags) const;
 292     virtual void unmap(UMatData* data) const;
 293     virtual void download(UMatData* data, void* dst, int dims, const size_t sz[],
 294                           const size_t srcofs[], const size_t srcstep[],
 295                           const size_t dststep[]) const;
 296     virtual void upload(UMatData* data, const void* src, int dims, const size_t sz[],
 297                         const size_t dstofs[], const size_t dststep[],
 298                         const size_t srcstep[]) const;
 299     virtual void copy(UMatData* srcdata, UMatData* dstdata, int dims, const size_t sz[],
 300                       const size_t srcofs[], const size_t srcstep[],
 301                       const size_t dstofs[], const size_t dststep[], bool sync) const;
 302
 303     // default implementation returns DummyBufferPoolController
 304     virtual BufferPoolController* getBufferPoolController() const;
 305 };
 306
 307
 308 //////////////////////////////// MatCommaInitializer //////////////////////////////////
 309
 310 /*!
 311  Comma-separated Matrix Initializer
 312
 313  The class instances are usually not created explicitly.
 314  Instead, they are created on "matrix << firstValue" operator.
 315
 316  The sample below initializes 2x2 rotation matrix:
 317
 318  \code
 319  double angle = 30, a = cos(angle*CV_PI/180), b = sin(angle*CV_PI/180);
 320  Mat R = (Mat_<double>(2,2) << a, -b, b, a);
 321  \endcode
 322 */
 323 template<typename _Tp> class MatCommaInitializer_
 324 {
 325 public:
 326     //! the constructor, created by "matrix << firstValue" operator, where matrix is cv::Mat
 327     MatCommaInitializer_(Mat_<_Tp>* _m);
 328     //! the operator that takes the next value and put it to the matrix
 329     template<typename T2> MatCommaInitializer_<_Tp>& operator , (T2 v);
 330     //! another form of conversion operator
 331     operator Mat_<_Tp>() const;
 332 protected:
 333     MatIterator_<_Tp> it;
 334 };
 335
 336
 337 /////////////////////////////////////// Mat ///////////////////////////////////////////
 338
 339 // note that umatdata might be allocated together
 340 // with the matrix data, not as a separate object.
 341 // therefore, it does not have constructor or destructor;
 342 // it should be explicitly initialized using init().
 343 struct CV_EXPORTS UMatData
 344 {
 345     enum { COPY_ON_MAP=1, HOST_COPY_OBSOLETE=2,
 346         DEVICE_COPY_OBSOLETE=4, TEMP_UMAT=8, TEMP_COPIED_UMAT=24,
 347         USER_ALLOCATED=32 };
 348     UMatData(const MatAllocator* allocator);
 349     ~UMatData();
 350
 351     // provide atomic access to the structure
 352     void lock();
 353     void unlock();
 354
 355     bool hostCopyObsolete() const;
 356     bool deviceCopyObsolete() const;
 357     bool copyOnMap() const;
 358     bool tempUMat() const;
 359     bool tempCopiedUMat() const;
 360     void markHostCopyObsolete(bool flag);
 361     void markDeviceCopyObsolete(bool flag);
 362
 363     const MatAllocator* prevAllocator;
 364     const MatAllocator* currAllocator;
 365     int urefcount;
 366     int refcount;
 367     uchar* data;
 368     uchar* origdata;
 369     size_t size, capacity;
 370
 371     int flags;
 372     void* handle;
 373     void* userdata;
 374 };
 375
 376
 377 struct CV_EXPORTS UMatDataAutoLock
 378 {
 379     UMatDataAutoLock(UMatData* u);
 380     ~UMatDataAutoLock();
 381     UMatData* u;
 382 };
 383
 384
 385 struct CV_EXPORTS MatSize
 386 {
 387     MatSize(int* _p);
 388     Size operator()() const;
 389     const int& operator[](int i) const;
 390     int& operator[](int i);
 391     operator const int*() const;
 392     bool operator == (const MatSize& sz) const;
 393     bool operator != (const MatSize& sz) const;
 394
 395     int* p;
 396 };
 397
 398 struct CV_EXPORTS MatStep
 399 {
 400     MatStep();
 401     MatStep(size_t s);
 402     const size_t& operator[](int i) const;
 403     size_t& operator[](int i);
 404     operator size_t() const;
 405     MatStep& operator = (size_t s);
 406
 407     size_t* p;
 408     size_t buf[2];
 409 protected:
 410     MatStep& operator = (const MatStep&);
 411 };
 412
 413  /*!
 414    The n-dimensional matrix class.
 415
 416    The class represents an n-dimensional dense numerical array that can act as
 417    a matrix, image, optical flow map, 3-focal tensor etc.
 418    It is very similar to CvMat and CvMatND types from earlier versions of OpenCV,
 419    and similarly to those types, the matrix can be multi-channel. It also fully supports ROI mechanism.
 420
 421    There are many different ways to create cv::Mat object. Here are the some popular ones:
 422    <ul>
 423    <li> using cv::Mat::create(nrows, ncols, type) method or
 424      the similar constructor cv::Mat::Mat(nrows, ncols, type[, fill_value]) constructor.
 425      A new matrix of the specified size and specifed type will be allocated.
 426      "type" has the same meaning as in cvCreateMat function,
 427      e.g. CV_8UC1 means 8-bit single-channel matrix, CV_32FC2 means 2-channel (i.e. complex)
 428      floating-point matrix etc:
 429
 430      \code
 431      // make 7x7 complex matrix filled with 1+3j.
 432      cv::Mat M(7,7,CV_32FC2,Scalar(1,3));
 433      // and now turn M to 100x60 15-channel 8-bit matrix.
 434      // The old content will be deallocated
 435      M.create(100,60,CV_8UC(15));
 436      \endcode
 437
 438      As noted in the introduction of this chapter, Mat::create()
 439      will only allocate a new matrix when the current matrix dimensionality
 440      or type are different from the specified.
 441
 442    <li> by using a copy constructor or assignment operator, where on the right side it can
 443      be a matrix or expression, see below. Again, as noted in the introduction,
 444      matrix assignment is O(1) operation because it only copies the header
 445      and increases the reference counter. cv::Mat::clone() method can be used to get a full
 446      (a.k.a. deep) copy of the matrix when you need it.
 447
 448    <li> by constructing a header for a part of another matrix. It can be a single row, single column,
 449      several rows, several columns, rectangular region in the matrix (called a minor in algebra) or
 450      a diagonal. Such operations are also O(1), because the new header will reference the same data.
 451      You can actually modify a part of the matrix using this feature, e.g.
 452
 453      \code
 454      // add 5-th row, multiplied by 3 to the 3rd row
 455      M.row(3) = M.row(3) + M.row(5)*3;
 456
 457      // now copy 7-th column to the 1-st column
 458      // M.col(1) = M.col(7); // this will not work
 459      Mat M1 = M.col(1);
 460      M.col(7).copyTo(M1);
 461
 462      // create new 320x240 image
 463      cv::Mat img(Size(320,240),CV_8UC3);
 464      // select a roi
 465      cv::Mat roi(img, Rect(10,10,100,100));
 466      // fill the ROI with (0,255,0) (which is green in RGB space);
 467      // the original 320x240 image will be modified
 468      roi = Scalar(0,255,0);
 469      \endcode
 470
 471      Thanks to the additional cv::Mat::datastart and cv::Mat::dataend members, it is possible to
 472      compute the relative sub-matrix position in the main "container" matrix using cv::Mat::locateROI():
 473
 474      \code
 475      Mat A = Mat::eye(10, 10, CV_32S);
 476      // extracts A columns, 1 (inclusive) to 3 (exclusive).
 477      Mat B = A(Range::all(), Range(1, 3));
 478      // extracts B rows, 5 (inclusive) to 9 (exclusive).
 479      // that is, C ~ A(Range(5, 9), Range(1, 3))
 480      Mat C = B(Range(5, 9), Range::all());
 481      Size size; Point ofs;
 482      C.locateROI(size, ofs);
 483      // size will be (width=10,height=10) and the ofs will be (x=1, y=5)
 484      \endcode
 485
 486      As in the case of whole matrices, if you need a deep copy, use cv::Mat::clone() method
 487      of the extracted sub-matrices.
 488
 489    <li> by making a header for user-allocated-data. It can be useful for
 490       <ol>
 491       <li> processing "foreign" data using OpenCV (e.g. when you implement
 492          a DirectShow filter or a processing module for gstreamer etc.), e.g.
 493
 494          \code
 495          void process_video_frame(const unsigned char* pixels,
 496                                   int width, int height, int step)
 497          {
 498             cv::Mat img(height, width, CV_8UC3, pixels, step);
 499             cv::GaussianBlur(img, img, cv::Size(7,7), 1.5, 1.5);
 500          }
 501          \endcode
 502
 503       <li> for quick initialization of small matrices and/or super-fast element access
 504
 505          \code
 506          double m[3][3] = {{a, b, c}, {d, e, f}, {g, h, i}};
 507          cv::Mat M = cv::Mat(3, 3, CV_64F, m).inv();
 508          \endcode
 509       </ol>
 510
 511        partial yet very common cases of this "user-allocated data" case are conversions
 512        from CvMat and IplImage to cv::Mat. For this purpose there are special constructors
 513        taking pointers to CvMat or IplImage and the optional
 514        flag indicating whether to copy the data or not.
 515
 516        Backward conversion from cv::Mat to CvMat or IplImage is provided via cast operators
 517        cv::Mat::operator CvMat() an cv::Mat::operator IplImage().
 518        The operators do not copy the data.
 519
 520
 521        \code
 522        IplImage* img = cvLoadImage("greatwave.jpg", 1);
 523        Mat mtx(img); // convert IplImage* -> cv::Mat
 524        CvMat oldmat = mtx; // convert cv::Mat -> CvMat
 525        CV_Assert(oldmat.cols == img->width && oldmat.rows == img->height &&
 526            oldmat.data.ptr == (uchar*)img->imageData && oldmat.step == img->widthStep);
 527        \endcode
 528
 529    <li> by using MATLAB-style matrix initializers, cv::Mat::zeros(), cv::Mat::ones(), cv::Mat::eye(), e.g.:
 530
 531    \code
 532    // create a double-precision identity martix and add it to M.
 533    M += Mat::eye(M.rows, M.cols, CV_64F);
 534    \endcode
 535
 536    <li> by using comma-separated initializer:
 537
 538    \code
 539    // create 3x3 double-precision identity matrix
 540    Mat M = (Mat_<double>(3,3) << 1, 0, 0, 0, 1, 0, 0, 0, 1);
 541    \endcode
 542
 543    here we first call constructor of cv::Mat_ class (that we describe further) with the proper matrix,
 544    and then we just put "<<" operator followed by comma-separated values that can be constants,
 545    variables, expressions etc. Also, note the extra parentheses that are needed to avoid compiler errors.
 546
 547    </ul>
 548
 549    Once matrix is created, it will be automatically managed by using reference-counting mechanism
 550    (unless the matrix header is built on top of user-allocated data,
 551    in which case you should handle the data by yourself).
 552    The matrix data will be deallocated when no one points to it;
 553    if you want to release the data pointed by a matrix header before the matrix destructor is called,
 554    use cv::Mat::release().
 555
 556    The next important thing to learn about the matrix class is element access. Here is how the matrix is stored.
 557    The elements are stored in row-major order (row by row). The cv::Mat::data member points to the first element of the first row,
 558    cv::Mat::rows contains the number of matrix rows and cv::Mat::cols - the number of matrix columns. There is yet another member,
 559    cv::Mat::step that is used to actually compute address of a matrix element. cv::Mat::step is needed because the matrix can be
 560    a part of another matrix or because there can some padding space in the end of each row for a proper alignment.
 561
 562    \image html roi.png
 563
 564    Given these parameters, address of the matrix element M_{ij} is computed as following:
 565
 566    addr(M_{ij})=M.data + M.step*i + j*M.elemSize()
 567
 568    if you know the matrix element type, e.g. it is float, then you can use cv::Mat::at() method:
 569
 570    addr(M_{ij})=&M.at<float>(i,j)
 571
 572    (where & is used to convert the reference returned by cv::Mat::at() to a pointer).
 573    if you need to process a whole row of matrix, the most efficient way is to get
 574    the pointer to the row first, and then just use plain C operator []:
 575
 576    \code
 577    // compute sum of positive matrix elements
 578    // (assuming that M is double-precision matrix)
 579    double sum=0;
 580    for(int i = 0; i < M.rows; i++)
 581    {
 582        const double* Mi = M.ptr<double>(i);
 583        for(int j = 0; j < M.cols; j++)
 584            sum += std::max(Mi[j], 0.);
 585    }
 586    \endcode
 587
 588    Some operations, like the above one, do not actually depend on the matrix shape,
 589    they just process elements of a matrix one by one (or elements from multiple matrices
 590    that are sitting in the same place, e.g. matrix addition). Such operations are called
 591    element-wise and it makes sense to check whether all the input/output matrices are continuous,
 592    i.e. have no gaps in the end of each row, and if yes, process them as a single long row:
 593
 594    \code
 595    // compute sum of positive matrix elements, optimized variant
 596    double sum=0;
 597    int cols = M.cols, rows = M.rows;
 598    if(M.isContinuous())
 599    {
 600        cols *= rows;
 601        rows = 1;
 602    }
 603    for(int i = 0; i < rows; i++)
 604    {
 605        const double* Mi = M.ptr<double>(i);
 606        for(int j = 0; j < cols; j++)
 607            sum += std::max(Mi[j], 0.);
 608    }
 609    \endcode
 610    in the case of continuous matrix the outer loop body will be executed just once,
 611    so the overhead will be smaller, which will be especially noticeable in the case of small matrices.
 612
 613    Finally, there are STL-style iterators that are smart enough to skip gaps between successive rows:
 614    \code
 615    // compute sum of positive matrix elements, iterator-based variant
 616    double sum=0;
 617    MatConstIterator_<double> it = M.begin<double>(), it_end = M.end<double>();
 618    for(; it != it_end; ++it)
 619        sum += std::max(*it, 0.);
 620    \endcode
 621
 622    The matrix iterators are random-access iterators, so they can be passed
 623    to any STL algorithm, including std::sort().
 624 */
 625 class CV_EXPORTS Mat
 626 {
 627 public:
 628     //! default constructor
 629     Mat();
 630     //! constructs 2D matrix of the specified size and type
 631     // (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
 632     Mat(int rows, int cols, int type);
 633     Mat(Size size, int type);
 634     //! constucts 2D matrix and fills it with the specified value _s.
 635     Mat(int rows, int cols, int type, const Scalar& s);
 636     Mat(Size size, int type, const Scalar& s);
 637
 638     //! constructs n-dimensional matrix
 639     Mat(int ndims, const int* sizes, int type);
 640     Mat(int ndims, const int* sizes, int type, const Scalar& s);
 641
 642     //! copy constructor
 643     Mat(const Mat& m);
 644     //! constructor for matrix headers pointing to user-allocated data
 645     Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP);
 646     Mat(Size size, int type, void* data, size_t step=AUTO_STEP);
 647     Mat(int ndims, const int* sizes, int type, void* data, const size_t* steps=0);
 648
 649     //! creates a matrix header for a part of the bigger matrix
 650     Mat(const Mat& m, const Range& rowRange, const Range& colRange=Range::all());
 651     Mat(const Mat& m, const Rect& roi);
 652     Mat(const Mat& m, const Range* ranges);
 653     //! builds matrix from std::vector with or without copying the data
 654     template<typename _Tp> explicit Mat(const std::vector<_Tp>& vec, bool copyData=false);
 655     //! builds matrix from cv::Vec; the data is copied by default
 656     template<typename _Tp, int n> explicit Mat(const Vec<_Tp, n>& vec, bool copyData=true);
 657     //! builds matrix from cv::Matx; the data is copied by default
 658     template<typename _Tp, int m, int n> explicit Mat(const Matx<_Tp, m, n>& mtx, bool copyData=true);
 659     //! builds matrix from a 2D point
 660     template<typename _Tp> explicit Mat(const Point_<_Tp>& pt, bool copyData=true);
 661     //! builds matrix from a 3D point
 662     template<typename _Tp> explicit Mat(const Point3_<_Tp>& pt, bool copyData=true);
 663     //! builds matrix from comma initializer
 664     template<typename _Tp> explicit Mat(const MatCommaInitializer_<_Tp>& commaInitializer);
 665
 666     //! download data from GpuMat
 667     explicit Mat(const cuda::GpuMat& m);
 668
 669     //! destructor - calls release()
 670     ~Mat();
 671     //! assignment operators
 672     Mat& operator = (const Mat& m);
 673     Mat& operator = (const MatExpr& expr);
 674
 675     //! retrieve UMat from Mat
 676     UMat getUMat(int accessFlags) const;
 677
 678     //! returns a new matrix header for the specified row
 679     Mat row(int y) const;
 680     //! returns a new matrix header for the specified column
 681     Mat col(int x) const;
 682     //! ... for the specified row span
 683     Mat rowRange(int startrow, int endrow) const;
 684     Mat rowRange(const Range& r) const;
 685     //! ... for the specified column span
 686     Mat colRange(int startcol, int endcol) const;
 687     Mat colRange(const Range& r) const;
 688     //! ... for the specified diagonal
 689     // (d=0 - the main diagonal,
 690     //  >0 - a diagonal from the lower half,
 691     //  <0 - a diagonal from the upper half)
 692     Mat diag(int d=0) const;
 693     //! constructs a square diagonal matrix which main diagonal is vector "d"
 694     static Mat diag(const Mat& d);
 695
 696     //! returns deep copy of the matrix, i.e. the data is copied
 697     Mat clone() const;
 698     //! copies the matrix content to "m".
 699     // It calls m.create(this->size(), this->type()).
 700     void copyTo( OutputArray m ) const;
 701     //! copies those matrix elements to "m" that are marked with non-zero mask elements.
 702     void copyTo( OutputArray m, InputArray mask ) const;
 703     //! converts matrix to another datatype with optional scalng. See cvConvertScale.
 704     void convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const;
 705
 706     void assignTo( Mat& m, int type=-1 ) const;
 707
 708     //! sets every matrix element to s
 709     Mat& operator = (const Scalar& s);
 710     //! sets some of the matrix elements to s, according to the mask
 711     Mat& setTo(InputArray value, InputArray mask=noArray());
 712     //! creates alternative matrix header for the same data, with different
 713     // number of channels and/or different number of rows. see cvReshape.
 714     Mat reshape(int cn, int rows=0) const;
 715     Mat reshape(int cn, int newndims, const int* newsz) const;
 716
 717     //! matrix transposition by means of matrix expressions
 718     MatExpr t() const;
 719     //! matrix inversion by means of matrix expressions
 720     MatExpr inv(int method=DECOMP_LU) const;
 721     //! per-element matrix multiplication by means of matrix expressions
 722     MatExpr mul(InputArray m, double scale=1) const;
 723
 724     //! computes cross-product of 2 3D vectors
 725     Mat cross(InputArray m) const;
 726     //! computes dot-product
 727     double dot(InputArray m) const;
 728
 729     //! Matlab-style matrix initialization
 730     static MatExpr zeros(int rows, int cols, int type);
 731     static MatExpr zeros(Size size, int type);
 732     static MatExpr zeros(int ndims, const int* sz, int type);
 733     static MatExpr ones(int rows, int cols, int type);
 734     static MatExpr ones(Size size, int type);
 735     static MatExpr ones(int ndims, const int* sz, int type);
 736     static MatExpr eye(int rows, int cols, int type);
 737     static MatExpr eye(Size size, int type);
 738
 739     //! allocates new matrix data unless the matrix already has specified size and type.
 740     // previous data is unreferenced if needed.
 741     void create(int rows, int cols, int type);
 742     void create(Size size, int type);
 743     void create(int ndims, const int* sizes, int type);
 744
 745     //! increases the reference counter; use with care to avoid memleaks
 746     void addref();
 747     //! decreases reference counter;
 748     // deallocates the data when reference counter reaches 0.
 749     void release();
 750
 751     //! deallocates the matrix data
 752     void deallocate();
 753     //! internal use function; properly re-allocates _size, _step arrays
 754     void copySize(const Mat& m);
 755
 756     //! reserves enough space to fit sz hyper-planes
 757     void reserve(size_t sz);
 758     //! resizes matrix to the specified number of hyper-planes
 759     void resize(size_t sz);
 760     //! resizes matrix to the specified number of hyper-planes; initializes the newly added elements
 761     void resize(size_t sz, const Scalar& s);
 762     //! internal function
 763     void push_back_(const void* elem);
 764     //! adds element to the end of 1d matrix (or possibly multiple elements when _Tp=Mat)
 765     template<typename _Tp> void push_back(const _Tp& elem);
 766     template<typename _Tp> void push_back(const Mat_<_Tp>& elem);
 767     void push_back(const Mat& m);
 768     //! removes several hyper-planes from bottom of the matrix
 769     void pop_back(size_t nelems=1);
 770
 771     //! locates matrix header within a parent matrix. See below
 772     void locateROI( Size& wholeSize, Point& ofs ) const;
 773     //! moves/resizes the current matrix ROI inside the parent matrix.
 774     Mat& adjustROI( int dtop, int dbottom, int dleft, int dright );
 775     //! extracts a rectangular sub-matrix
 776     // (this is a generalized form of row, rowRange etc.)
 777     Mat operator()( Range rowRange, Range colRange ) const;
 778     Mat operator()( const Rect& roi ) const;
 779     Mat operator()( const Range* ranges ) const;
 780
 781     // //! converts header to CvMat; no data is copied
 782     // operator CvMat() const;
 783     // //! converts header to CvMatND; no data is copied
 784     // operator CvMatND() const;
 785     // //! converts header to IplImage; no data is copied
 786     // operator IplImage() const;
 787
 788     template<typename _Tp> operator std::vector<_Tp>() const;
 789     template<typename _Tp, int n> operator Vec<_Tp, n>() const;
 790     template<typename _Tp, int m, int n> operator Matx<_Tp, m, n>() const;
 791
 792     //! returns true iff the matrix data is continuous
 793     // (i.e. when there are no gaps between successive rows).
 794     // similar to CV_IS_MAT_CONT(cvmat->type)
 795     bool isContinuous() const;
 796
 797     //! returns true if the matrix is a submatrix of another matrix
 798     bool isSubmatrix() const;
 799
 800     //! returns element size in bytes,
 801     // similar to CV_ELEM_SIZE(cvmat->type)
 802     size_t elemSize() const;
 803     //! returns the size of element channel in bytes.
 804     size_t elemSize1() const;
 805     //! returns element type, similar to CV_MAT_TYPE(cvmat->type)
 806     int type() const;
 807     //! returns element type, similar to CV_MAT_DEPTH(cvmat->type)
 808     int depth() const;
 809     //! returns element type, similar to CV_MAT_CN(cvmat->type)
 810     int channels() const;
 811     //! returns step/elemSize1()
 812     size_t step1(int i=0) const;
 813     //! returns true if matrix data is NULL
 814     bool empty() const;
 815     //! returns the total number of matrix elements
 816     size_t total() const;
 817
 818     //! returns N if the matrix is 1-channel (N x ptdim) or ptdim-channel (1 x N) or (N x 1); negative number otherwise
 819     int checkVector(int elemChannels, int depth=-1, bool requireContinuous=true) const;
 820
 821     //! returns pointer to i0-th submatrix along the dimension #0
 822     uchar* ptr(int i0=0);
 823     const uchar* ptr(int i0=0) const;
 824
 825     //! returns pointer to (i0,i1) submatrix along the dimensions #0 and #1
 826     uchar* ptr(int i0, int i1);
 827     const uchar* ptr(int i0, int i1) const;
 828
 829     //! returns pointer to (i0,i1,i3) submatrix along the dimensions #0, #1, #2
 830     uchar* ptr(int i0, int i1, int i2);
 831     const uchar* ptr(int i0, int i1, int i2) const;
 832
 833     //! returns pointer to the matrix element
 834     uchar* ptr(const int* idx);
 835     //! returns read-only pointer to the matrix element
 836     const uchar* ptr(const int* idx) const;
 837
 838     template<int n> uchar* ptr(const Vec<int, n>& idx);
 839     template<int n> const uchar* ptr(const Vec<int, n>& idx) const;
 840
 841     //! template version of the above method
 842     template<typename _Tp> _Tp* ptr(int i0=0);
 843     template<typename _Tp> const _Tp* ptr(int i0=0) const;
 844
 845     template<typename _Tp> _Tp* ptr(int i0, int i1);
 846     template<typename _Tp> const _Tp* ptr(int i0, int i1) const;
 847
 848     template<typename _Tp> _Tp* ptr(int i0, int i1, int i2);
 849     template<typename _Tp> const _Tp* ptr(int i0, int i1, int i2) const;
 850
 851     template<typename _Tp> _Tp* ptr(const int* idx);
 852     template<typename _Tp> const _Tp* ptr(const int* idx) const;
 853
 854     template<typename _Tp, int n> _Tp* ptr(const Vec<int, n>& idx);
 855     template<typename _Tp, int n> const _Tp* ptr(const Vec<int, n>& idx) const;
 856
 857     //! the same as above, with the pointer dereferencing
 858     template<typename _Tp> _Tp& at(int i0=0);
 859     template<typename _Tp> const _Tp& at(int i0=0) const;
 860
 861     template<typename _Tp> _Tp& at(int i0, int i1);
 862     template<typename _Tp> const _Tp& at(int i0, int i1) const;
 863
 864     template<typename _Tp> _Tp& at(int i0, int i1, int i2);
 865     template<typename _Tp> const _Tp& at(int i0, int i1, int i2) const;
 866
 867     template<typename _Tp> _Tp& at(const int* idx);
 868     template<typename _Tp> const _Tp& at(const int* idx) const;
 869
 870     template<typename _Tp, int n> _Tp& at(const Vec<int, n>& idx);
 871     template<typename _Tp, int n> const _Tp& at(const Vec<int, n>& idx) const;
 872
 873     //! special versions for 2D arrays (especially convenient for referencing image pixels)
 874     template<typename _Tp> _Tp& at(Point pt);
 875     template<typename _Tp> const _Tp& at(Point pt) const;
 876
 877     //! template methods for iteration over matrix elements.
 878     // the iterators take care of skipping gaps in the end of rows (if any)
 879     template<typename _Tp> MatIterator_<_Tp> begin();
 880     template<typename _Tp> MatIterator_<_Tp> end();
 881     template<typename _Tp> MatConstIterator_<_Tp> begin() const;
 882     template<typename _Tp> MatConstIterator_<_Tp> end() const;
 883
 884     enum { MAGIC_VAL  = 0x42FF0000, AUTO_STEP = 0, CONTINUOUS_FLAG = CV_MAT_CONT_FLAG, SUBMATRIX_FLAG = CV_SUBMAT_FLAG };
 885     enum { MAGIC_MASK = 0xFFFF0000, TYPE_MASK = 0x00000FFF, DEPTH_MASK = 7 };
 886
 887     /*! includes several bit-fields:
 888          - the magic signature
 889          - continuity flag
 890          - depth
 891          - number of channels
 892      */
 893     int flags;
 894     //! the matrix dimensionality, >= 2
 895     int dims;
 896     //! the number of rows and columns or (-1, -1) when the matrix has more than 2 dimensions
 897     int rows, cols;
 898     //! pointer to the data
 899     uchar* data;
 900
 901     //! helper fields used in locateROI and adjustROI
 902     uchar* datastart;
 903     uchar* dataend;
 904     uchar* datalimit;
 905
 906     //! custom allocator
 907     MatAllocator* allocator;
 908     //! and the standard allocator
 909     static MatAllocator* getStdAllocator();
 910
 911     //! interaction with UMat
 912     UMatData* u;
 913
 914     MatSize size;
 915     MatStep step;
 916
 917 protected:
 918 };
 919
 920
 921 ///////////////////////////////// Mat_<_Tp> ////////////////////////////////////
 922
 923 /*!
 924  Template matrix class derived from Mat
 925
 926  The class Mat_ is a "thin" template wrapper on top of cv::Mat. It does not have any extra data fields,
 927  nor it or cv::Mat have any virtual methods and thus references or pointers to these two classes
 928  can be safely converted one to another. But do it with care, for example:
 929
 930  \code
 931  // create 100x100 8-bit matrix
 932  Mat M(100,100,CV_8U);
 933  // this will compile fine. no any data conversion will be done.
 934  Mat_<float>& M1 = (Mat_<float>&)M;
 935  // the program will likely crash at the statement below
 936  M1(99,99) = 1.f;
 937  \endcode
 938
 939  While cv::Mat is sufficient in most cases, cv::Mat_ can be more convenient if you use a lot of element
 940  access operations and if you know matrix type at compile time.
 941  Note that cv::Mat::at<_Tp>(int y, int x) and cv::Mat_<_Tp>::operator ()(int y, int x) do absolutely the
 942  same thing and run at the same speed, but the latter is certainly shorter:
 943
 944  \code
 945  Mat_<double> M(20,20);
 946  for(int i = 0; i < M.rows; i++)
 947     for(int j = 0; j < M.cols; j++)
 948        M(i,j) = 1./(i+j+1);
 949  Mat E, V;
 950  eigen(M,E,V);
 951  cout << E.at<double>(0,0)/E.at<double>(M.rows-1,0);
 952  \endcode
 953
 954  It is easy to use Mat_ for multi-channel images/matrices - just pass cv::Vec as cv::Mat_ template parameter:
 955
 956  \code
 957  // allocate 320x240 color image and fill it with green (in RGB space)
 958  Mat_<Vec3b> img(240, 320, Vec3b(0,255,0));
 959  // now draw a diagonal white line
 960  for(int i = 0; i < 100; i++)
 961      img(i,i)=Vec3b(255,255,255);
 962  // and now modify the 2nd (red) channel of each pixel
 963  for(int i = 0; i < img.rows; i++)
 964     for(int j = 0; j < img.cols; j++)
 965        img(i,j)[2] ^= (uchar)(i ^ j); // img(y,x)[c] accesses c-th channel of the pixel (x,y)
 966  \endcode
 967 */
 968 template<typename _Tp> class Mat_ : public Mat
 969 {
 970 public:
 971     typedef _Tp value_type;
 972     typedef typename DataType<_Tp>::channel_type channel_type;
 973     typedef MatIterator_<_Tp> iterator;
 974     typedef MatConstIterator_<_Tp> const_iterator;
 975
 976     //! default constructor
 977     Mat_();
 978     //! equivalent to Mat(_rows, _cols, DataType<_Tp>::type)
 979     Mat_(int _rows, int _cols);
 980     //! constructor that sets each matrix element to specified value
 981     Mat_(int _rows, int _cols, const _Tp& value);
 982     //! equivalent to Mat(_size, DataType<_Tp>::type)
 983     explicit Mat_(Size _size);
 984     //! constructor that sets each matrix element to specified value
 985     Mat_(Size _size, const _Tp& value);
 986     //! n-dim array constructor
 987     Mat_(int _ndims, const int* _sizes);
 988     //! n-dim array constructor that sets each matrix element to specified value
 989     Mat_(int _ndims, const int* _sizes, const _Tp& value);
 990     //! copy/conversion contructor. If m is of different type, it's converted
 991     Mat_(const Mat& m);
 992     //! copy constructor
 993     Mat_(const Mat_& m);
 994     //! constructs a matrix on top of user-allocated data. step is in bytes(!!!), regardless of the type
 995     Mat_(int _rows, int _cols, _Tp* _data, size_t _step=AUTO_STEP);
 996     //! constructs n-dim matrix on top of user-allocated data. steps are in bytes(!!!), regardless of the type
 997     Mat_(int _ndims, const int* _sizes, _Tp* _data, const size_t* _steps=0);
 998     //! selects a submatrix
 999     Mat_(const Mat_& m, const Range& rowRange, const Range& colRange=Range::all());
1000     //! selects a submatrix
1001     Mat_(const Mat_& m, const Rect& roi);
1002     //! selects a submatrix, n-dim version
1003     Mat_(const Mat_& m, const Range* ranges);
1004     //! from a matrix expression
1005     explicit Mat_(const MatExpr& e);
1006     //! makes a matrix out of Vec, std::vector, Point_ or Point3_. The matrix will have a single column
1007     explicit Mat_(const std::vector<_Tp>& vec, bool copyData=false);
1008     template<int n> explicit Mat_(const Vec<typename DataType<_Tp>::channel_type, n>& vec, bool copyData=true);
1009     template<int m, int n> explicit Mat_(const Matx<typename DataType<_Tp>::channel_type, m, n>& mtx, bool copyData=true);
1010     explicit Mat_(const Point_<typename DataType<_Tp>::channel_type>& pt, bool copyData=true);
1011     explicit Mat_(const Point3_<typename DataType<_Tp>::channel_type>& pt, bool copyData=true);
1012     explicit Mat_(const MatCommaInitializer_<_Tp>& commaInitializer);
1013
1014     Mat_& operator = (const Mat& m);
1015     Mat_& operator = (const Mat_& m);
1016     //! set all the elements to s.
1017     Mat_& operator = (const _Tp& s);
1018     //! assign a matrix expression
1019     Mat_& operator = (const MatExpr& e);
1020
1021     //! iterators; they are smart enough to skip gaps in the end of rows
1022     iterator begin();
1023     iterator end();
1024     const_iterator begin() const;
1025     const_iterator end() const;
1026
1027     //! equivalent to Mat::create(_rows, _cols, DataType<_Tp>::type)
1028     void create(int _rows, int _cols);
1029     //! equivalent to Mat::create(_size, DataType<_Tp>::type)
1030     void create(Size _size);
1031     //! equivalent to Mat::create(_ndims, _sizes, DatType<_Tp>::type)
1032     void create(int _ndims, const int* _sizes);
1033     //! cross-product
1034     Mat_ cross(const Mat_& m) const;
1035     //! data type conversion
1036     template<typename T2> operator Mat_<T2>() const;
1037     //! overridden forms of Mat::row() etc.
1038     Mat_ row(int y) const;
1039     Mat_ col(int x) const;
1040     Mat_ diag(int d=0) const;
1041     Mat_ clone() const;
1042
1043     //! overridden forms of Mat::elemSize() etc.
1044     size_t elemSize() const;
1045     size_t elemSize1() const;
1046     int type() const;
1047     int depth() const;
1048     int channels() const;
1049     size_t step1(int i=0) const;
1050     //! returns step()/sizeof(_Tp)
1051     size_t stepT(int i=0) const;
1052
1053     //! overridden forms of Mat::zeros() etc. Data type is omitted, of course
1054     static MatExpr zeros(int rows, int cols);
1055     static MatExpr zeros(Size size);
1056     static MatExpr zeros(int _ndims, const int* _sizes);
1057     static MatExpr ones(int rows, int cols);
1058     static MatExpr ones(Size size);
1059     static MatExpr ones(int _ndims, const int* _sizes);
1060     static MatExpr eye(int rows, int cols);
1061     static MatExpr eye(Size size);
1062
1063     //! some more overriden methods
1064     Mat_& adjustROI( int dtop, int dbottom, int dleft, int dright );
1065     Mat_ operator()( const Range& rowRange, const Range& colRange ) const;
1066     Mat_ operator()( const Rect& roi ) const;
1067     Mat_ operator()( const Range* ranges ) const;
1068
1069     //! more convenient forms of row and element access operators
1070     _Tp* operator [](int y);
1071     const _Tp* operator [](int y) const;
1072
1073     //! returns reference to the specified element
1074     _Tp& operator ()(const int* idx);
1075     //! returns read-only reference to the specified element
1076     const _Tp& operator ()(const int* idx) const;
1077
1078     //! returns reference to the specified element
1079     template<int n> _Tp& operator ()(const Vec<int, n>& idx);
1080     //! returns read-only reference to the specified element
1081     template<int n> const _Tp& operator ()(const Vec<int, n>& idx) const;
1082
1083     //! returns reference to the specified element (1D case)
1084     _Tp& operator ()(int idx0);
1085     //! returns read-only reference to the specified element (1D case)
1086     const _Tp& operator ()(int idx0) const;
1087     //! returns reference to the specified element (2D case)
1088     _Tp& operator ()(int idx0, int idx1);
1089     //! returns read-only reference to the specified element (2D case)
1090     const _Tp& operator ()(int idx0, int idx1) const;
1091     //! returns reference to the specified element (3D case)
1092     _Tp& operator ()(int idx0, int idx1, int idx2);
1093     //! returns read-only reference to the specified element (3D case)
1094     const _Tp& operator ()(int idx0, int idx1, int idx2) const;
1095
1096     _Tp& operator ()(Point pt);
1097     const _Tp& operator ()(Point pt) const;
1098
1099     //! conversion to vector.
1100     operator std::vector<_Tp>() const;
1101     //! conversion to Vec
1102     template<int n> operator Vec<typename DataType<_Tp>::channel_type, n>() const;
1103     //! conversion to Matx
1104     template<int m, int n> operator Matx<typename DataType<_Tp>::channel_type, m, n>() const;
1105 };
1106
1107 typedef Mat_<uchar> Mat1b;
1108 typedef Mat_<Vec2b> Mat2b;
1109 typedef Mat_<Vec3b> Mat3b;
1110 typedef Mat_<Vec4b> Mat4b;
1111
1112 typedef Mat_<short> Mat1s;
1113 typedef Mat_<Vec2s> Mat2s;
1114 typedef Mat_<Vec3s> Mat3s;
1115 typedef Mat_<Vec4s> Mat4s;
1116
1117 typedef Mat_<ushort> Mat1w;
1118 typedef Mat_<Vec2w> Mat2w;
1119 typedef Mat_<Vec3w> Mat3w;
1120 typedef Mat_<Vec4w> Mat4w;
1121
1122 typedef Mat_<int>   Mat1i;
1123 typedef Mat_<Vec2i> Mat2i;
1124 typedef Mat_<Vec3i> Mat3i;
1125 typedef Mat_<Vec4i> Mat4i;
1126
1127 typedef Mat_<float> Mat1f;
1128 typedef Mat_<Vec2f> Mat2f;
1129 typedef Mat_<Vec3f> Mat3f;
1130 typedef Mat_<Vec4f> Mat4f;
1131
1132 typedef Mat_<double> Mat1d;
1133 typedef Mat_<Vec2d> Mat2d;
1134 typedef Mat_<Vec3d> Mat3d;
1135 typedef Mat_<Vec4d> Mat4d;
1136
1137
1138 class CV_EXPORTS UMatExpr;
1139
1140 class CV_EXPORTS UMat
1141 {
1142 public:
1143     //! default constructor
1144     UMat();
1145     //! constructs 2D matrix of the specified size and type
1146     // (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
1147     UMat(int rows, int cols, int type);
1148     UMat(Size size, int type);
1149     //! constucts 2D matrix and fills it with the specified value _s.
1150     UMat(int rows, int cols, int type, const Scalar& s);
1151     UMat(Size size, int type, const Scalar& s);
1152
1153     //! constructs n-dimensional matrix
1154     UMat(int ndims, const int* sizes, int type);
1155     UMat(int ndims, const int* sizes, int type, const Scalar& s);
1156
1157     //! copy constructor
1158     UMat(const UMat& m);
1159
1160     //! creates a matrix header for a part of the bigger matrix
1161     UMat(const UMat& m, const Range& rowRange, const Range& colRange=Range::all());
1162     UMat(const UMat& m, const Rect& roi);
1163     UMat(const UMat& m, const Range* ranges);
1164     //! builds matrix from std::vector with or without copying the data
1165     template<typename _Tp> explicit UMat(const std::vector<_Tp>& vec, bool copyData=false);
1166     //! builds matrix from cv::Vec; the data is copied by default
1167     template<typename _Tp, int n> explicit UMat(const Vec<_Tp, n>& vec, bool copyData=true);
1168     //! builds matrix from cv::Matx; the data is copied by default
1169     template<typename _Tp, int m, int n> explicit UMat(const Matx<_Tp, m, n>& mtx, bool copyData=true);
1170     //! builds matrix from a 2D point
1171     template<typename _Tp> explicit UMat(const Point_<_Tp>& pt, bool copyData=true);
1172     //! builds matrix from a 3D point
1173     template<typename _Tp> explicit UMat(const Point3_<_Tp>& pt, bool copyData=true);
1174     //! builds matrix from comma initializer
1175     template<typename _Tp> explicit UMat(const MatCommaInitializer_<_Tp>& commaInitializer);
1176
1177     //! destructor - calls release()
1178     ~UMat();
1179     //! assignment operators
1180     UMat& operator = (const UMat& m);
1181     UMat& operator = (const UMatExpr& expr);
1182
1183     Mat getMat(int flags) const;
1184
1185     //! returns a new matrix header for the specified row
1186     UMat row(int y) const;
1187     //! returns a new matrix header for the specified column
1188     UMat col(int x) const;
1189     //! ... for the specified row span
1190     UMat rowRange(int startrow, int endrow) const;
1191     UMat rowRange(const Range& r) const;
1192     //! ... for the specified column span
1193     UMat colRange(int startcol, int endcol) const;
1194     UMat colRange(const Range& r) const;
1195     //! ... for the specified diagonal
1196     // (d=0 - the main diagonal,
1197     //  >0 - a diagonal from the lower half,
1198     //  <0 - a diagonal from the upper half)
1199     UMat diag(int d=0) const;
1200     //! constructs a square diagonal matrix which main diagonal is vector "d"
1201     static UMat diag(const UMat& d);
1202
1203     //! returns deep copy of the matrix, i.e. the data is copied
1204     UMat clone() const;
1205     //! copies the matrix content to "m".
1206     // It calls m.create(this->size(), this->type()).
1207     void copyTo( OutputArray m ) const;
1208     //! copies those matrix elements to "m" that are marked with non-zero mask elements.
1209     void copyTo( OutputArray m, InputArray mask ) const;
1210     //! converts matrix to another datatype with optional scalng. See cvConvertScale.
1211     void convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const;
1212
1213     void assignTo( UMat& m, int type=-1 ) const;
1214
1215     //! sets every matrix element to s
1216     UMat& operator = (const Scalar& s);
1217     //! sets some of the matrix elements to s, according to the mask
1218     UMat& setTo(InputArray value, InputArray mask=noArray());
1219     //! creates alternative matrix header for the same data, with different
1220     // number of channels and/or different number of rows. see cvReshape.
1221     UMat reshape(int cn, int rows=0) const;
1222     UMat reshape(int cn, int newndims, const int* newsz) const;
1223
1224     //! matrix transposition by means of matrix expressions
1225     UMatExpr t() const;
1226     //! matrix inversion by means of matrix expressions
1227     UMatExpr inv(int method=DECOMP_LU) const;
1228     //! per-element matrix multiplication by means of matrix expressions
1229     UMatExpr mul(InputArray m, double scale=1) const;
1230
1231     //! computes cross-product of 2 3D vectors
1232     UMat cross(InputArray m) const;
1233     //! computes dot-product
1234     double dot(InputArray m) const;
1235
1236     //! Matlab-style matrix initialization
1237     static UMatExpr zeros(int rows, int cols, int type);
1238     static UMatExpr zeros(Size size, int type);
1239     static UMatExpr zeros(int ndims, const int* sz, int type);
1240     static UMatExpr ones(int rows, int cols, int type);
1241     static UMatExpr ones(Size size, int type);
1242     static UMatExpr ones(int ndims, const int* sz, int type);
1243     static UMatExpr eye(int rows, int cols, int type);
1244     static UMatExpr eye(Size size, int type);
1245
1246     //! allocates new matrix data unless the matrix already has specified size and type.
1247     // previous data is unreferenced if needed.
1248     void create(int rows, int cols, int type);
1249     void create(Size size, int type);
1250     void create(int ndims, const int* sizes, int type);
1251
1252     //! increases the reference counter; use with care to avoid memleaks
1253     void addref();
1254     //! decreases reference counter;
1255     // deallocates the data when reference counter reaches 0.
1256     void release();
1257
1258     //! deallocates the matrix data
1259     void deallocate();
1260     //! internal use function; properly re-allocates _size, _step arrays
1261     void copySize(const UMat& m);
1262
1263     //! locates matrix header within a parent matrix. See below
1264     void locateROI( Size& wholeSize, Point& ofs ) const;
1265     //! moves/resizes the current matrix ROI inside the parent matrix.
1266     UMat& adjustROI( int dtop, int dbottom, int dleft, int dright );
1267     //! extracts a rectangular sub-matrix
1268     // (this is a generalized form of row, rowRange etc.)
1269     UMat operator()( Range rowRange, Range colRange ) const;
1270     UMat operator()( const Rect& roi ) const;
1271     UMat operator()( const Range* ranges ) const;
1272
1273     //! returns true iff the matrix data is continuous
1274     // (i.e. when there are no gaps between successive rows).
1275     // similar to CV_IS_MAT_CONT(cvmat->type)
1276     bool isContinuous() const;
1277
1278     //! returns true if the matrix is a submatrix of another matrix
1279     bool isSubmatrix() const;
1280
1281     //! returns element size in bytes,
1282     // similar to CV_ELEM_SIZE(cvmat->type)
1283     size_t elemSize() const;
1284     //! returns the size of element channel in bytes.
1285     size_t elemSize1() const;
1286     //! returns element type, similar to CV_MAT_TYPE(cvmat->type)
1287     int type() const;
1288     //! returns element type, similar to CV_MAT_DEPTH(cvmat->type)
1289     int depth() const;
1290     //! returns element type, similar to CV_MAT_CN(cvmat->type)
1291     int channels() const;
1292     //! returns step/elemSize1()
1293     size_t step1(int i=0) const;
1294     //! returns true if matrix data is NULL
1295     bool empty() const;
1296     //! returns the total number of matrix elements
1297     size_t total() const;
1298
1299     //! returns N if the matrix is 1-channel (N x ptdim) or ptdim-channel (1 x N) or (N x 1); negative number otherwise
1300     int checkVector(int elemChannels, int depth=-1, bool requireContinuous=true) const;
1301
1302     void* handle(int accessFlags) const;
1303     void ndoffset(size_t* ofs) const;
1304
1305     enum { MAGIC_VAL  = 0x42FF0000, AUTO_STEP = 0, CONTINUOUS_FLAG = CV_MAT_CONT_FLAG, SUBMATRIX_FLAG = CV_SUBMAT_FLAG };
1306     enum { MAGIC_MASK = 0xFFFF0000, TYPE_MASK = 0x00000FFF, DEPTH_MASK = 7 };
1307
1308     /*! includes several bit-fields:
1309          - the magic signature
1310          - continuity flag
1311          - depth
1312          - number of channels
1313      */
1314     int flags;
1315     //! the matrix dimensionality, >= 2
1316     int dims;
1317     //! the number of rows and columns or (-1, -1) when the matrix has more than 2 dimensions
1318     int rows, cols;
1319
1320     //! custom allocator
1321     MatAllocator* allocator;
1322     //! and the standard allocator
1323     static MatAllocator* getStdAllocator();
1324
1325     // black-box container of UMat data
1326     UMatData* u;
1327
1328     // offset of the submatrix (or 0)
1329     size_t offset;
1330
1331     MatSize size;
1332     MatStep step;
1333
1334 protected:
1335 };
1336
1337
1338 /////////////////////////// multi-dimensional sparse matrix //////////////////////////
1339
1340 /*!
1341  Sparse matrix class.
1342
1343  The class represents multi-dimensional sparse numerical arrays. Such a sparse array can store elements
1344  of any type that cv::Mat is able to store. "Sparse" means that only non-zero elements
1345  are stored (though, as a result of some operations on a sparse matrix, some of its stored elements
1346  can actually become 0. It's user responsibility to detect such elements and delete them using cv::SparseMat::erase().
1347  The non-zero elements are stored in a hash table that grows when it's filled enough,
1348  so that the search time remains O(1) in average. Elements can be accessed using the following methods:
1349
1350  <ol>
1351  <li>Query operations: cv::SparseMat::ptr() and the higher-level cv::SparseMat::ref(),
1352       cv::SparseMat::value() and cv::SparseMat::find, for example:
1353  \code
1354  const int dims = 5;
1355  int size[] = {10, 10, 10, 10, 10};
1356  SparseMat sparse_mat(dims, size, CV_32F);
1357  for(int i = 0; i < 1000; i++)
1358  {
1359      int idx[dims];
1360      for(int k = 0; k < dims; k++)
1361         idx[k] = rand()%sparse_mat.size(k);
1362      sparse_mat.ref<float>(idx) += 1.f;
1363  }
1364  \endcode
1365
1366  <li>Sparse matrix iterators. Like cv::Mat iterators and unlike cv::Mat iterators, the sparse matrix iterators are STL-style,
1367  that is, the iteration is done as following:
1368  \code
1369  // prints elements of a sparse floating-point matrix and the sum of elements.
1370  SparseMatConstIterator_<float>
1371         it = sparse_mat.begin<float>(),
1372         it_end = sparse_mat.end<float>();
1373  double s = 0;
1374  int dims = sparse_mat.dims();
1375  for(; it != it_end; ++it)
1376  {
1377      // print element indices and the element value
1378      const Node* n = it.node();
1379      printf("(")
1380      for(int i = 0; i < dims; i++)
1381         printf("%3d%c", n->idx[i], i < dims-1 ? ',' : ')');
1382      printf(": %f\n", *it);
1383      s += *it;
1384  }
1385  printf("Element sum is %g\n", s);
1386  \endcode
1387  If you run this loop, you will notice that elements are enumerated
1388  in no any logical order (lexicographical etc.),
1389  they come in the same order as they stored in the hash table, i.e. semi-randomly.
1390
1391  You may collect pointers to the nodes and sort them to get the proper ordering.
1392  Note, however, that pointers to the nodes may become invalid when you add more
1393  elements to the matrix; this is because of possible buffer reallocation.
1394
1395  <li>A combination of the above 2 methods when you need to process 2 or more sparse
1396  matrices simultaneously, e.g. this is how you can compute unnormalized
1397  cross-correlation of the 2 floating-point sparse matrices:
1398  \code
1399  double crossCorr(const SparseMat& a, const SparseMat& b)
1400  {
1401      const SparseMat *_a = &a, *_b = &b;
1402      // if b contains less elements than a,
1403      // it's faster to iterate through b
1404      if(_a->nzcount() > _b->nzcount())
1405         std::swap(_a, _b);
1406      SparseMatConstIterator_<float> it = _a->begin<float>(),
1407                                     it_end = _a->end<float>();
1408      double ccorr = 0;
1409      for(; it != it_end; ++it)
1410      {
1411          // take the next element from the first matrix
1412          float avalue = *it;
1413          const Node* anode = it.node();
1414          // and try to find element with the same index in the second matrix.
1415          // since the hash value depends only on the element index,
1416          // we reuse hashvalue stored in the node
1417          float bvalue = _b->value<float>(anode->idx,&anode->hashval);
1418          ccorr += avalue*bvalue;
1419      }
1420      return ccorr;
1421  }
1422  \endcode
1423  </ol>
1424 */
1425 class CV_EXPORTS SparseMat
1426 {
1427 public:
1428     typedef SparseMatIterator iterator;
1429     typedef SparseMatConstIterator const_iterator;
1430
1431     enum { MAGIC_VAL=0x42FD0000, MAX_DIM=32, HASH_SCALE=0x5bd1e995, HASH_BIT=0x80000000 };
1432
1433     //! the sparse matrix header
1434     struct CV_EXPORTS Hdr
1435     {
1436         Hdr(int _dims, const int* _sizes, int _type);
1437         void clear();
1438         int refcount;
1439         int dims;
1440         int valueOffset;
1441         size_t nodeSize;
1442         size_t nodeCount;
1443         size_t freeList;
1444         std::vector<uchar> pool;
1445         std::vector<size_t> hashtab;
1446         int size[MAX_DIM];
1447     };
1448
1449     //! sparse matrix node - element of a hash table
1450     struct CV_EXPORTS Node
1451     {
1452         //! hash value
1453         size_t hashval;
1454         //! index of the next node in the same hash table entry
1455         size_t next;
1456         //! index of the matrix element
1457         int idx[MAX_DIM];
1458     };
1459
1460     //! default constructor
1461     SparseMat();
1462     //! creates matrix of the specified size and type
1463     SparseMat(int dims, const int* _sizes, int _type);
1464     //! copy constructor
1465     SparseMat(const SparseMat& m);
1466     //! converts dense 2d matrix to the sparse form
1467     /*!
1468      \param m the input matrix
1469     */
1470     explicit SparseMat(const Mat& m);
1471     //! converts old-style sparse matrix to the new-style. All the data is copied
1472     //SparseMat(const CvSparseMat* m);
1473     //! the destructor
1474     ~SparseMat();
1475
1476     //! assignment operator. This is O(1) operation, i.e. no data is copied
1477     SparseMat& operator = (const SparseMat& m);
1478     //! equivalent to the corresponding constructor
1479     SparseMat& operator = (const Mat& m);
1480
1481     //! creates full copy of the matrix
1482     SparseMat clone() const;
1483
1484     //! copies all the data to the destination matrix. All the previous content of m is erased
1485     void copyTo( SparseMat& m ) const;
1486     //! converts sparse matrix to dense matrix.
1487     void copyTo( Mat& m ) const;
1488     //! multiplies all the matrix elements by the specified scale factor alpha and converts the results to the specified data type
1489     void convertTo( SparseMat& m, int rtype, double alpha=1 ) const;
1490     //! converts sparse matrix to dense n-dim matrix with optional type conversion and scaling.
1491     /*!
1492       \param rtype The output matrix data type. When it is =-1, the output array will have the same data type as (*this)
1493       \param alpha The scale factor
1494       \param beta The optional delta added to the scaled values before the conversion
1495     */
1496     void convertTo( Mat& m, int rtype, double alpha=1, double beta=0 ) const;
1497
1498     // not used now
1499     void assignTo( SparseMat& m, int type=-1 ) const;
1500
1501     //! reallocates sparse matrix.
1502     /*!
1503         If the matrix already had the proper size and type,
1504         it is simply cleared with clear(), otherwise,
1505         the old matrix is released (using release()) and the new one is allocated.
1506     */
1507     void create(int dims, const int* _sizes, int _type);
1508     //! sets all the sparse matrix elements to 0, which means clearing the hash table.
1509     void clear();
1510     //! manually increments the reference counter to the header.
1511     void addref();
1512     // decrements the header reference counter. When the counter reaches 0, the header and all the underlying data are deallocated.
1513     void release();
1514
1515     //! converts sparse matrix to the old-style representation; all the elements are copied.
1516     //operator CvSparseMat*() const;
1517     //! returns the size of each element in bytes (not including the overhead - the space occupied by SparseMat::Node elements)
1518     size_t elemSize() const;
1519     //! returns elemSize()/channels()
1520     size_t elemSize1() const;
1521
1522     //! returns type of sparse matrix elements
1523     int type() const;
1524     //! returns the depth of sparse matrix elements
1525     int depth() const;
1526     //! returns the number of channels
1527     int channels() const;
1528
1529     //! returns the array of sizes, or NULL if the matrix is not allocated
1530     const int* size() const;
1531     //! returns the size of i-th matrix dimension (or 0)
1532     int size(int i) const;
1533     //! returns the matrix dimensionality
1534     int dims() const;
1535     //! returns the number of non-zero elements (=the number of hash table nodes)
1536     size_t nzcount() const;
1537
1538     //! computes the element hash value (1D case)
1539     size_t hash(int i0) const;
1540     //! computes the element hash value (2D case)
1541     size_t hash(int i0, int i1) const;
1542     //! computes the element hash value (3D case)
1543     size_t hash(int i0, int i1, int i2) const;
1544     //! computes the element hash value (nD case)
1545     size_t hash(const int* idx) const;
1546
1547     //@{
1548     /*!
1549      specialized variants for 1D, 2D, 3D cases and the generic_type one for n-D case.
1550
1551      return pointer to the matrix element.
1552      <ul>
1553       <li>if the element is there (it's non-zero), the pointer to it is returned
1554       <li>if it's not there and createMissing=false, NULL pointer is returned
1555       <li>if it's not there and createMissing=true, then the new element
1556         is created and initialized with 0. Pointer to it is returned
1557       <li>if the optional hashval pointer is not NULL, the element hash value is
1558       not computed, but *hashval is taken instead.
1559      </ul>
1560     */
1561     //! returns pointer to the specified element (1D case)
1562     uchar* ptr(int i0, bool createMissing, size_t* hashval=0);
1563     //! returns pointer to the specified element (2D case)
1564     uchar* ptr(int i0, int i1, bool createMissing, size_t* hashval=0);
1565     //! returns pointer to the specified element (3D case)
1566     uchar* ptr(int i0, int i1, int i2, bool createMissing, size_t* hashval=0);
1567     //! returns pointer to the specified element (nD case)
1568     uchar* ptr(const int* idx, bool createMissing, size_t* hashval=0);
1569     //@}
1570
1571     //@{
1572     /*!
1573      return read-write reference to the specified sparse matrix element.
1574
1575      ref<_Tp>(i0,...[,hashval]) is equivalent to *(_Tp*)ptr(i0,...,true[,hashval]).
1576      The methods always return a valid reference.
1577      If the element did not exist, it is created and initialiazed with 0.
1578     */
1579     //! returns reference to the specified element (1D case)
1580     template<typename _Tp> _Tp& ref(int i0, size_t* hashval=0);
1581     //! returns reference to the specified element (2D case)
1582     template<typename _Tp> _Tp& ref(int i0, int i1, size_t* hashval=0);
1583     //! returns reference to the specified element (3D case)
1584     template<typename _Tp> _Tp& ref(int i0, int i1, int i2, size_t* hashval=0);
1585     //! returns reference to the specified element (nD case)
1586     template<typename _Tp> _Tp& ref(const int* idx, size_t* hashval=0);
1587     //@}
1588
1589     //@{
1590     /*!
1591      return value of the specified sparse matrix element.
1592
1593      value<_Tp>(i0,...[,hashval]) is equivalent
1594
1595      \code
1596      { const _Tp* p = find<_Tp>(i0,...[,hashval]); return p ? *p : _Tp(); }
1597      \endcode
1598
1599      That is, if the element did not exist, the methods return 0.
1600      */
1601     //! returns value of the specified element (1D case)
1602     template<typename _Tp> _Tp value(int i0, size_t* hashval=0) const;
1603     //! returns value of the specified element (2D case)
1604     template<typename _Tp> _Tp value(int i0, int i1, size_t* hashval=0) const;
1605     //! returns value of the specified element (3D case)
1606     template<typename _Tp> _Tp value(int i0, int i1, int i2, size_t* hashval=0) const;
1607     //! returns value of the specified element (nD case)
1608     template<typename _Tp> _Tp value(const int* idx, size_t* hashval=0) const;
1609     //@}
1610
1611     //@{
1612     /*!
1613      Return pointer to the specified sparse matrix element if it exists
1614
1615      find<_Tp>(i0,...[,hashval]) is equivalent to (_const Tp*)ptr(i0,...false[,hashval]).
1616
1617      If the specified element does not exist, the methods return NULL.
1618     */
1619     //! returns pointer to the specified element (1D case)
1620     template<typename _Tp> const _Tp* find(int i0, size_t* hashval=0) const;
1621     //! returns pointer to the specified element (2D case)
1622     template<typename _Tp> const _Tp* find(int i0, int i1, size_t* hashval=0) const;
1623     //! returns pointer to the specified element (3D case)
1624     template<typename _Tp> const _Tp* find(int i0, int i1, int i2, size_t* hashval=0) const;
1625     //! returns pointer to the specified element (nD case)
1626     template<typename _Tp> const _Tp* find(const int* idx, size_t* hashval=0) const;
1627
1628     //! erases the specified element (2D case)
1629     void erase(int i0, int i1, size_t* hashval=0);
1630     //! erases the specified element (3D case)
1631     void erase(int i0, int i1, int i2, size_t* hashval=0);
1632     //! erases the specified element (nD case)
1633     void erase(const int* idx, size_t* hashval=0);
1634
1635     //@{
1636     /*!
1637        return the sparse matrix iterator pointing to the first sparse matrix element
1638     */
1639     //! returns the sparse matrix iterator at the matrix beginning
1640     SparseMatIterator begin();
1641     //! returns the sparse matrix iterator at the matrix beginning
1642     template<typename _Tp> SparseMatIterator_<_Tp> begin();
1643     //! returns the read-only sparse matrix iterator at the matrix beginning
1644     SparseMatConstIterator begin() const;
1645     //! returns the read-only sparse matrix iterator at the matrix beginning
1646     template<typename _Tp> SparseMatConstIterator_<_Tp> begin() const;
1647     //@}
1648     /*!
1649        return the sparse matrix iterator pointing to the element following the last sparse matrix element
1650     */
1651     //! returns the sparse matrix iterator at the matrix end
1652     SparseMatIterator end();
1653     //! returns the read-only sparse matrix iterator at the matrix end
1654     SparseMatConstIterator end() const;
1655     //! returns the typed sparse matrix iterator at the matrix end
1656     template<typename _Tp> SparseMatIterator_<_Tp> end();
1657     //! returns the typed read-only sparse matrix iterator at the matrix end
1658     template<typename _Tp> SparseMatConstIterator_<_Tp> end() const;
1659
1660     //! returns the value stored in the sparse martix node
1661     template<typename _Tp> _Tp& value(Node* n);
1662     //! returns the value stored in the sparse martix node
1663     template<typename _Tp> const _Tp& value(const Node* n) const;
1664
1665     ////////////// some internal-use methods ///////////////
1666     Node* node(size_t nidx);
1667     const Node* node(size_t nidx) const;
1668
1669     uchar* newNode(const int* idx, size_t hashval);
1670     void removeNode(size_t hidx, size_t nidx, size_t previdx);
1671     void resizeHashTab(size_t newsize);
1672
1673     int flags;
1674     Hdr* hdr;
1675 };
1676
1677
1678
1679 ///////////////////////////////// SparseMat_<_Tp> ////////////////////////////////////
1680
1681 /*!
1682  The Template Sparse Matrix class derived from cv::SparseMat
1683
1684  The class provides slightly more convenient operations for accessing elements.
1685
1686  \code
1687  SparseMat m;
1688  ...
1689  SparseMat_<int> m_ = (SparseMat_<int>&)m;
1690  m_.ref(1)++; // equivalent to m.ref<int>(1)++;
1691  m_.ref(2) += m_(3); // equivalent to m.ref<int>(2) += m.value<int>(3);
1692  \endcode
1693 */
1694 template<typename _Tp> class SparseMat_ : public SparseMat
1695 {
1696 public:
1697     typedef SparseMatIterator_<_Tp> iterator;
1698     typedef SparseMatConstIterator_<_Tp> const_iterator;
1699
1700     //! the default constructor
1701     SparseMat_();
1702     //! the full constructor equivelent to SparseMat(dims, _sizes, DataType<_Tp>::type)
1703     SparseMat_(int dims, const int* _sizes);
1704     //! the copy constructor. If DataType<_Tp>.type != m.type(), the m elements are converted
1705     SparseMat_(const SparseMat& m);
1706     //! the copy constructor. This is O(1) operation - no data is copied
1707     SparseMat_(const SparseMat_& m);
1708     //! converts dense matrix to the sparse form
1709     SparseMat_(const Mat& m);
1710     //! converts the old-style sparse matrix to the C++ class. All the elements are copied
1711     //SparseMat_(const CvSparseMat* m);
1712     //! the assignment operator. If DataType<_Tp>.type != m.type(), the m elements are converted
1713     SparseMat_& operator = (const SparseMat& m);
1714     //! the assignment operator. This is O(1) operation - no data is copied
1715     SparseMat_& operator = (const SparseMat_& m);
1716     //! converts dense matrix to the sparse form
1717     SparseMat_& operator = (const Mat& m);
1718
1719     //! makes full copy of the matrix. All the elements are duplicated
1720     SparseMat_ clone() const;
1721     //! equivalent to cv::SparseMat::create(dims, _sizes, DataType<_Tp>::type)
1722     void create(int dims, const int* _sizes);
1723     //! converts sparse matrix to the old-style CvSparseMat. All the elements are copied
1724     //operator CvSparseMat*() const;
1725
1726     //! returns type of the matrix elements
1727     int type() const;
1728     //! returns depth of the matrix elements
1729     int depth() const;
1730     //! returns the number of channels in each matrix element
1731     int channels() const;
1732
1733     //! equivalent to SparseMat::ref<_Tp>(i0, hashval)
1734     _Tp& ref(int i0, size_t* hashval=0);
1735     //! equivalent to SparseMat::ref<_Tp>(i0, i1, hashval)
1736     _Tp& ref(int i0, int i1, size_t* hashval=0);
1737     //! equivalent to SparseMat::ref<_Tp>(i0, i1, i2, hashval)
1738     _Tp& ref(int i0, int i1, int i2, size_t* hashval=0);
1739     //! equivalent to SparseMat::ref<_Tp>(idx, hashval)
1740     _Tp& ref(const int* idx, size_t* hashval=0);
1741
1742     //! equivalent to SparseMat::value<_Tp>(i0, hashval)
1743     _Tp operator()(int i0, size_t* hashval=0) const;
1744     //! equivalent to SparseMat::value<_Tp>(i0, i1, hashval)
1745     _Tp operator()(int i0, int i1, size_t* hashval=0) const;
1746     //! equivalent to SparseMat::value<_Tp>(i0, i1, i2, hashval)
1747     _Tp operator()(int i0, int i1, int i2, size_t* hashval=0) const;
1748     //! equivalent to SparseMat::value<_Tp>(idx, hashval)
1749     _Tp operator()(const int* idx, size_t* hashval=0) const;
1750
1751     //! returns sparse matrix iterator pointing to the first sparse matrix element
1752     SparseMatIterator_<_Tp> begin();
1753     //! returns read-only sparse matrix iterator pointing to the first sparse matrix element
1754     SparseMatConstIterator_<_Tp> begin() const;
1755     //! returns sparse matrix iterator pointing to the element following the last sparse matrix element
1756     SparseMatIterator_<_Tp> end();
1757     //! returns read-only sparse matrix iterator pointing to the element following the last sparse matrix element
1758     SparseMatConstIterator_<_Tp> end() const;
1759 };
1760
1761
1762
1763 ////////////////////////////////// MatConstIterator //////////////////////////////////
1764
1765 class CV_EXPORTS MatConstIterator
1766 {
1767 public:
1768     typedef uchar* value_type;
1769     typedef ptrdiff_t difference_type;
1770     typedef const uchar** pointer;
1771     typedef uchar* reference;
1772
1773 #ifndef OPENCV_NOSTL
1774     typedef std::random_access_iterator_tag iterator_category;
1775 #endif
1776
1777     //! default constructor
1778     MatConstIterator();
1779     //! constructor that sets the iterator to the beginning of the matrix
1780     MatConstIterator(const Mat* _m);
1781     //! constructor that sets the iterator to the specified element of the matrix
1782     MatConstIterator(const Mat* _m, int _row, int _col=0);
1783     //! constructor that sets the iterator to the specified element of the matrix
1784     MatConstIterator(const Mat* _m, Point _pt);
1785     //! constructor that sets the iterator to the specified element of the matrix
1786     MatConstIterator(const Mat* _m, const int* _idx);
1787     //! copy constructor
1788     MatConstIterator(const MatConstIterator& it);
1789
1790     //! copy operator
1791     MatConstIterator& operator = (const MatConstIterator& it);
1792     //! returns the current matrix element
1793     uchar* operator *() const;
1794     //! returns the i-th matrix element, relative to the current
1795     uchar* operator [](ptrdiff_t i) const;
1796
1797     //! shifts the iterator forward by the specified number of elements
1798     MatConstIterator& operator += (ptrdiff_t ofs);
1799     //! shifts the iterator backward by the specified number of elements
1800     MatConstIterator& operator -= (ptrdiff_t ofs);
1801     //! decrements the iterator
1802     MatConstIterator& operator --();
1803     //! decrements the iterator
1804     MatConstIterator operator --(int);
1805     //! increments the iterator
1806     MatConstIterator& operator ++();
1807     //! increments the iterator
1808     MatConstIterator operator ++(int);
1809     //! returns the current iterator position
1810     Point pos() const;
1811     //! returns the current iterator position
1812     void pos(int* _idx) const;
1813
1814     ptrdiff_t lpos() const;
1815     void seek(ptrdiff_t ofs, bool relative = false);
1816     void seek(const int* _idx, bool relative = false);
1817
1818     const Mat* m;
1819     size_t elemSize;
1820     uchar* ptr;
1821     uchar* sliceStart;
1822     uchar* sliceEnd;
1823 };
1824
1825
1826
1827 ////////////////////////////////// MatConstIterator_ /////////////////////////////////
1828
1829 /*!
1830  Matrix read-only iterator
1831  */
1832 template<typename _Tp>
1833 class MatConstIterator_ : public MatConstIterator
1834 {
1835 public:
1836     typedef _Tp value_type;
1837     typedef ptrdiff_t difference_type;
1838     typedef const _Tp* pointer;
1839     typedef const _Tp& reference;
1840
1841 #ifndef OPENCV_NOSTL
1842     typedef std::random_access_iterator_tag iterator_category;
1843 #endif
1844
1845     //! default constructor
1846     MatConstIterator_();
1847     //! constructor that sets the iterator to the beginning of the matrix
1848     MatConstIterator_(const Mat_<_Tp>* _m);
1849     //! constructor that sets the iterator to the specified element of the matrix
1850     MatConstIterator_(const Mat_<_Tp>* _m, int _row, int _col=0);
1851     //! constructor that sets the iterator to the specified element of the matrix
1852     MatConstIterator_(const Mat_<_Tp>* _m, Point _pt);
1853     //! constructor that sets the iterator to the specified element of the matrix
1854     MatConstIterator_(const Mat_<_Tp>* _m, const int* _idx);
1855     //! copy constructor
1856     MatConstIterator_(const MatConstIterator_& it);
1857
1858     //! copy operator
1859     MatConstIterator_& operator = (const MatConstIterator_& it);
1860     //! returns the current matrix element
1861     _Tp operator *() const;
1862     //! returns the i-th matrix element, relative to the current
1863     _Tp operator [](ptrdiff_t i) const;
1864
1865     //! shifts the iterator forward by the specified number of elements
1866     MatConstIterator_& operator += (ptrdiff_t ofs);
1867     //! shifts the iterator backward by the specified number of elements
1868     MatConstIterator_& operator -= (ptrdiff_t ofs);
1869     //! decrements the iterator
1870     MatConstIterator_& operator --();
1871     //! decrements the iterator
1872     MatConstIterator_ operator --(int);
1873     //! increments the iterator
1874     MatConstIterator_& operator ++();
1875     //! increments the iterator
1876     MatConstIterator_ operator ++(int);
1877     //! returns the current iterator position
1878     Point pos() const;
1879 };
1880
1881
1882
1883 //////////////////////////////////// MatIterator_ ////////////////////////////////////
1884
1885 /*!
1886  Matrix read-write iterator
1887 */
1888 template<typename _Tp>
1889 class MatIterator_ : public MatConstIterator_<_Tp>
1890 {
1891 public:
1892     typedef _Tp* pointer;
1893     typedef _Tp& reference;
1894
1895 #ifndef OPENCV_NOSTL
1896     typedef std::random_access_iterator_tag iterator_category;
1897 #endif
1898
1899     //! the default constructor
1900     MatIterator_();
1901     //! constructor that sets the iterator to the beginning of the matrix
1902     MatIterator_(Mat_<_Tp>* _m);
1903     //! constructor that sets the iterator to the specified element of the matrix
1904     MatIterator_(Mat_<_Tp>* _m, int _row, int _col=0);
1905     //! constructor that sets the iterator to the specified element of the matrix
1906     MatIterator_(const Mat_<_Tp>* _m, Point _pt);
1907     //! constructor that sets the iterator to the specified element of the matrix
1908     MatIterator_(const Mat_<_Tp>* _m, const int* _idx);
1909     //! copy constructor
1910     MatIterator_(const MatIterator_& it);
1911     //! copy operator
1912     MatIterator_& operator = (const MatIterator_<_Tp>& it );
1913
1914     //! returns the current matrix element
1915     _Tp& operator *() const;
1916     //! returns the i-th matrix element, relative to the current
1917     _Tp& operator [](ptrdiff_t i) const;
1918
1919     //! shifts the iterator forward by the specified number of elements
1920     MatIterator_& operator += (ptrdiff_t ofs);
1921     //! shifts the iterator backward by the specified number of elements
1922     MatIterator_& operator -= (ptrdiff_t ofs);
1923     //! decrements the iterator
1924     MatIterator_& operator --();
1925     //! decrements the iterator
1926     MatIterator_ operator --(int);
1927     //! increments the iterator
1928     MatIterator_& operator ++();
1929     //! increments the iterator
1930     MatIterator_ operator ++(int);
1931 };
1932
1933
1934
1935 /////////////////////////////// SparseMatConstIterator ///////////////////////////////
1936
1937 /*!
1938  Read-Only Sparse Matrix Iterator.
1939  Here is how to use the iterator to compute the sum of floating-point sparse matrix elements:
1940
1941  \code
1942  SparseMatConstIterator it = m.begin(), it_end = m.end();
1943  double s = 0;
1944  CV_Assert( m.type() == CV_32F );
1945  for( ; it != it_end; ++it )
1946     s += it.value<float>();
1947  \endcode
1948 */
1949 class CV_EXPORTS SparseMatConstIterator
1950 {
1951 public:
1952     //! the default constructor
1953     SparseMatConstIterator();
1954     //! the full constructor setting the iterator to the first sparse matrix element
1955     SparseMatConstIterator(const SparseMat* _m);
1956     //! the copy constructor
1957     SparseMatConstIterator(const SparseMatConstIterator& it);
1958
1959     //! the assignment operator
1960     SparseMatConstIterator& operator = (const SparseMatConstIterator& it);
1961
1962     //! template method returning the current matrix element
1963     template<typename _Tp> const _Tp& value() const;
1964     //! returns the current node of the sparse matrix. it.node->idx is the current element index
1965     const SparseMat::Node* node() const;
1966
1967     //! moves iterator to the previous element
1968     SparseMatConstIterator& operator --();
1969     //! moves iterator to the previous element
1970     SparseMatConstIterator operator --(int);
1971     //! moves iterator to the next element
1972     SparseMatConstIterator& operator ++();
1973     //! moves iterator to the next element
1974     SparseMatConstIterator operator ++(int);
1975
1976     //! moves iterator to the element after the last element
1977     void seekEnd();
1978
1979     const SparseMat* m;
1980     size_t hashidx;
1981     uchar* ptr;
1982 };
1983
1984
1985
1986 ////////////////////////////////// SparseMatIterator /////////////////////////////////
1987
1988 /*!
1989  Read-write Sparse Matrix Iterator
1990
1991  The class is similar to cv::SparseMatConstIterator,
1992  but can be used for in-place modification of the matrix elements.
1993 */
1994 class CV_EXPORTS SparseMatIterator : public SparseMatConstIterator
1995 {
1996 public:
1997     //! the default constructor
1998     SparseMatIterator();
1999     //! the full constructor setting the iterator to the first sparse matrix element
2000     SparseMatIterator(SparseMat* _m);
2001     //! the full constructor setting the iterator to the specified sparse matrix element
2002     SparseMatIterator(SparseMat* _m, const int* idx);
2003     //! the copy constructor
2004     SparseMatIterator(const SparseMatIterator& it);
2005
2006     //! the assignment operator
2007     SparseMatIterator& operator = (const SparseMatIterator& it);
2008     //! returns read-write reference to the current sparse matrix element
2009     template<typename _Tp> _Tp& value() const;
2010     //! returns pointer to the current sparse matrix node. it.node->idx is the index of the current element (do not modify it!)
2011     SparseMat::Node* node() const;
2012
2013     //! moves iterator to the next element
2014     SparseMatIterator& operator ++();
2015     //! moves iterator to the next element
2016     SparseMatIterator operator ++(int);
2017 };
2018
2019
2020
2021 /////////////////////////////// SparseMatConstIterator_ //////////////////////////////
2022
2023 /*!
2024  Template Read-Only Sparse Matrix Iterator Class.
2025
2026  This is the derived from SparseMatConstIterator class that
2027  introduces more convenient operator *() for accessing the current element.
2028 */
2029 template<typename _Tp> class SparseMatConstIterator_ : public SparseMatConstIterator
2030 {
2031 public:
2032
2033 #ifndef OPENCV_NOSTL
2034     typedef std::forward_iterator_tag iterator_category;
2035 #endif
2036
2037     //! the default constructor
2038     SparseMatConstIterator_();
2039     //! the full constructor setting the iterator to the first sparse matrix element
2040     SparseMatConstIterator_(const SparseMat_<_Tp>* _m);
2041     SparseMatConstIterator_(const SparseMat* _m);
2042     //! the copy constructor
2043     SparseMatConstIterator_(const SparseMatConstIterator_& it);
2044
2045     //! the assignment operator
2046     SparseMatConstIterator_& operator = (const SparseMatConstIterator_& it);
2047     //! the element access operator
2048     const _Tp& operator *() const;
2049
2050     //! moves iterator to the next element
2051     SparseMatConstIterator_& operator ++();
2052     //! moves iterator to the next element
2053     SparseMatConstIterator_ operator ++(int);
2054 };
2055
2056
2057
2058 ///////////////////////////////// SparseMatIterator_ /////////////////////////////////
2059
2060 /*!
2061  Template Read-Write Sparse Matrix Iterator Class.
2062
2063  This is the derived from cv::SparseMatConstIterator_ class that
2064  introduces more convenient operator *() for accessing the current element.
2065 */
2066 template<typename _Tp> class SparseMatIterator_ : public SparseMatConstIterator_<_Tp>
2067 {
2068 public:
2069
2070 #ifndef OPENCV_NOSTL
2071     typedef std::forward_iterator_tag iterator_category;
2072 #endif
2073
2074     //! the default constructor
2075     SparseMatIterator_();
2076     //! the full constructor setting the iterator to the first sparse matrix element
2077     SparseMatIterator_(SparseMat_<_Tp>* _m);
2078     SparseMatIterator_(SparseMat* _m);
2079     //! the copy constructor
2080     SparseMatIterator_(const SparseMatIterator_& it);
2081
2082     //! the assignment operator
2083     SparseMatIterator_& operator = (const SparseMatIterator_& it);
2084     //! returns the reference to the current element
2085     _Tp& operator *() const;
2086
2087     //! moves the iterator to the next element
2088     SparseMatIterator_& operator ++();
2089     //! moves the iterator to the next element
2090     SparseMatIterator_ operator ++(int);
2091 };
2092
2093
2094
2095 /////////////////////////////////// NAryMatIterator //////////////////////////////////
2096
2097 /*!
2098  n-Dimensional Dense Matrix Iterator Class.
2099
2100  The class cv::NAryMatIterator is used for iterating over one or more n-dimensional dense arrays (cv::Mat's).
2101
2102  The iterator is completely different from cv::Mat_ and cv::SparseMat_ iterators.
2103  It iterates through the slices (or planes), not the elements, where "slice" is a continuous part of the arrays.
2104
2105  Here is the example on how the iterator can be used to normalize 3D histogram:
2106
2107  \code
2108  void normalizeColorHist(Mat& hist)
2109  {
2110  #if 1
2111      // intialize iterator (the style is different from STL).
2112      // after initialization the iterator will contain
2113      // the number of slices or planes
2114      // the iterator will go through
2115      Mat* arrays[] = { &hist, 0 };
2116      Mat planes[1];
2117      NAryMatIterator it(arrays, planes);
2118      double s = 0;
2119      // iterate through the matrix. on each iteration
2120      // it.planes[i] (of type Mat) will be set to the current plane of
2121      // i-th n-dim matrix passed to the iterator constructor.
2122      for(int p = 0; p < it.nplanes; p++, ++it)
2123         s += sum(it.planes[0])[0];
2124      it = NAryMatIterator(hist);
2125      s = 1./s;
2126      for(int p = 0; p < it.nplanes; p++, ++it)
2127         it.planes[0] *= s;
2128  #elif 1
2129      // this is a shorter implementation of the above
2130      // using built-in operations on Mat
2131      double s = sum(hist)[0];
2132      hist.convertTo(hist, hist.type(), 1./s, 0);
2133  #else
2134      // and this is even shorter one
2135      // (assuming that the histogram elements are non-negative)
2136      normalize(hist, hist, 1, 0, NORM_L1);
2137  #endif
2138  }
2139  \endcode
2140
2141  You can iterate through several matrices simultaneously as long as they have the same geometry
2142  (dimensionality and all the dimension sizes are the same), which is useful for binary
2143  and n-ary operations on such matrices. Just pass those matrices to cv::MatNDIterator.
2144  Then, during the iteration it.planes[0], it.planes[1], ... will
2145  be the slices of the corresponding matrices
2146 */
2147 class CV_EXPORTS NAryMatIterator
2148 {
2149 public:
2150     //! the default constructor
2151     NAryMatIterator();
2152     //! the full constructor taking arbitrary number of n-dim matrices
2153     NAryMatIterator(const Mat** arrays, uchar** ptrs, int narrays=-1);
2154     //! the full constructor taking arbitrary number of n-dim matrices
2155     NAryMatIterator(const Mat** arrays, Mat* planes, int narrays=-1);
2156     //! the separate iterator initialization method
2157     void init(const Mat** arrays, Mat* planes, uchar** ptrs, int narrays=-1);
2158
2159     //! proceeds to the next plane of every iterated matrix
2160     NAryMatIterator& operator ++();
2161     //! proceeds to the next plane of every iterated matrix (postfix increment operator)
2162     NAryMatIterator operator ++(int);
2163
2164     //! the iterated arrays
2165     const Mat** arrays;
2166     //! the current planes
2167     Mat* planes;
2168     //! data pointers
2169     uchar** ptrs;
2170     //! the number of arrays
2171     int narrays;
2172     //! the number of hyper-planes that the iterator steps through
2173     size_t nplanes;
2174     //! the size of each segment (in elements)
2175     size_t size;
2176 protected:
2177     int iterdepth;
2178     size_t idx;
2179 };
2180
2181
2182
2183 ///////////////////////////////// Matrix Expressions /////////////////////////////////
2184
2185 class CV_EXPORTS MatOp
2186 {
2187 public:
2188     MatOp();
2189     virtual ~MatOp();
2190
2191     virtual bool elementWise(const MatExpr& expr) const;
2192     virtual void assign(const MatExpr& expr, Mat& m, int type=-1) const = 0;
2193     virtual void roi(const MatExpr& expr, const Range& rowRange,
2194                      const Range& colRange, MatExpr& res) const;
2195     virtual void diag(const MatExpr& expr, int d, MatExpr& res) const;
2196     virtual void augAssignAdd(const MatExpr& expr, Mat& m) const;
2197     virtual void augAssignSubtract(const MatExpr& expr, Mat& m) const;
2198     virtual void augAssignMultiply(const MatExpr& expr, Mat& m) const;
2199     virtual void augAssignDivide(const MatExpr& expr, Mat& m) const;
2200     virtual void augAssignAnd(const MatExpr& expr, Mat& m) const;
2201     virtual void augAssignOr(const MatExpr& expr, Mat& m) const;
2202     virtual void augAssignXor(const MatExpr& expr, Mat& m) const;
2203
2204     virtual void add(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
2205     virtual void add(const MatExpr& expr1, const Scalar& s, MatExpr& res) const;
2206
2207     virtual void subtract(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
2208     virtual void subtract(const Scalar& s, const MatExpr& expr, MatExpr& res) const;
2209
2210     virtual void multiply(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res, double scale=1) const;
2211     virtual void multiply(const MatExpr& expr1, double s, MatExpr& res) const;
2212
2213     virtual void divide(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res, double scale=1) const;
2214     virtual void divide(double s, const MatExpr& expr, MatExpr& res) const;
2215
2216     virtual void abs(const MatExpr& expr, MatExpr& res) const;
2217
2218     virtual void transpose(const MatExpr& expr, MatExpr& res) const;
2219     virtual void matmul(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
2220     virtual void invert(const MatExpr& expr, int method, MatExpr& res) const;
2221
2222     virtual Size size(const MatExpr& expr) const;
2223     virtual int type(const MatExpr& expr) const;
2224 };
2225
2226
2227 class CV_EXPORTS MatExpr
2228 {
2229 public:
2230     MatExpr();
2231     explicit MatExpr(const Mat& m);
2232
2233     MatExpr(const MatOp* _op, int _flags, const Mat& _a = Mat(), const Mat& _b = Mat(),
2234             const Mat& _c = Mat(), double _alpha = 1, double _beta = 1, const Scalar& _s = Scalar());
2235
2236     operator Mat() const;
2237     template<typename _Tp> operator Mat_<_Tp>() const;
2238
2239     Size size() const;
2240     int type() const;
2241
2242     MatExpr row(int y) const;
2243     MatExpr col(int x) const;
2244     MatExpr diag(int d = 0) const;
2245     MatExpr operator()( const Range& rowRange, const Range& colRange ) const;
2246     MatExpr operator()( const Rect& roi ) const;
2247
2248     MatExpr t() const;
2249     MatExpr inv(int method = DECOMP_LU) const;
2250     MatExpr mul(const MatExpr& e, double scale=1) const;
2251     MatExpr mul(const Mat& m, double scale=1) const;
2252
2253     Mat cross(const Mat& m) const;
2254     double dot(const Mat& m) const;
2255
2256     const MatOp* op;
2257     int flags;
2258
2259     Mat a, b, c;
2260     double alpha, beta;
2261     Scalar s;
2262 };
2263
2264
2265 CV_EXPORTS MatExpr operator + (const Mat& a, const Mat& b);
2266 CV_EXPORTS MatExpr operator + (const Mat& a, const Scalar& s);
2267 CV_EXPORTS MatExpr operator + (const Scalar& s, const Mat& a);
2268 CV_EXPORTS MatExpr operator + (const MatExpr& e, const Mat& m);
2269 CV_EXPORTS MatExpr operator + (const Mat& m, const MatExpr& e);
2270 CV_EXPORTS MatExpr operator + (const MatExpr& e, const Scalar& s);
2271 CV_EXPORTS MatExpr operator + (const Scalar& s, const MatExpr& e);
2272 CV_EXPORTS MatExpr operator + (const MatExpr& e1, const MatExpr& e2);
2273
2274 CV_EXPORTS MatExpr operator - (const Mat& a, const Mat& b);
2275 CV_EXPORTS MatExpr operator - (const Mat& a, const Scalar& s);
2276 CV_EXPORTS MatExpr operator - (const Scalar& s, const Mat& a);
2277 CV_EXPORTS MatExpr operator - (const MatExpr& e, const Mat& m);
2278 CV_EXPORTS MatExpr operator - (const Mat& m, const MatExpr& e);
2279 CV_EXPORTS MatExpr operator - (const MatExpr& e, const Scalar& s);
2280 CV_EXPORTS MatExpr operator - (const Scalar& s, const MatExpr& e);
2281 CV_EXPORTS MatExpr operator - (const MatExpr& e1, const MatExpr& e2);
2282
2283 CV_EXPORTS MatExpr operator - (const Mat& m);
2284 CV_EXPORTS MatExpr operator - (const MatExpr& e);
2285
2286 CV_EXPORTS MatExpr operator * (const Mat& a, const Mat& b);
2287 CV_EXPORTS MatExpr operator * (const Mat& a, double s);
2288 CV_EXPORTS MatExpr operator * (double s, const Mat& a);
2289 CV_EXPORTS MatExpr operator * (const MatExpr& e, const Mat& m);
2290 CV_EXPORTS MatExpr operator * (const Mat& m, const MatExpr& e);
2291 CV_EXPORTS MatExpr operator * (const MatExpr& e, double s);
2292 CV_EXPORTS MatExpr operator * (double s, const MatExpr& e);
2293 CV_EXPORTS MatExpr operator * (const MatExpr& e1, const MatExpr& e2);
2294
2295 CV_EXPORTS MatExpr operator / (const Mat& a, const Mat& b);
2296 CV_EXPORTS MatExpr operator / (const Mat& a, double s);
2297 CV_EXPORTS MatExpr operator / (double s, const Mat& a);
2298 CV_EXPORTS MatExpr operator / (const MatExpr& e, const Mat& m);
2299 CV_EXPORTS MatExpr operator / (const Mat& m, const MatExpr& e);
2300 CV_EXPORTS MatExpr operator / (const MatExpr& e, double s);
2301 CV_EXPORTS MatExpr operator / (double s, const MatExpr& e);
2302 CV_EXPORTS MatExpr operator / (const MatExpr& e1, const MatExpr& e2);
2303
2304 CV_EXPORTS MatExpr operator < (const Mat& a, const Mat& b);
2305 CV_EXPORTS MatExpr operator < (const Mat& a, double s);
2306 CV_EXPORTS MatExpr operator < (double s, const Mat& a);
2307
2308 CV_EXPORTS MatExpr operator <= (const Mat& a, const Mat& b);
2309 CV_EXPORTS MatExpr operator <= (const Mat& a, double s);
2310 CV_EXPORTS MatExpr operator <= (double s, const Mat& a);
2311
2312 CV_EXPORTS MatExpr operator == (const Mat& a, const Mat& b);
2313 CV_EXPORTS MatExpr operator == (const Mat& a, double s);
2314 CV_EXPORTS MatExpr operator == (double s, const Mat& a);
2315
2316 CV_EXPORTS MatExpr operator != (const Mat& a, const Mat& b);
2317 CV_EXPORTS MatExpr operator != (const Mat& a, double s);
2318 CV_EXPORTS MatExpr operator != (double s, const Mat& a);
2319
2320 CV_EXPORTS MatExpr operator >= (const Mat& a, const Mat& b);
2321 CV_EXPORTS MatExpr operator >= (const Mat& a, double s);
2322 CV_EXPORTS MatExpr operator >= (double s, const Mat& a);
2323
2324 CV_EXPORTS MatExpr operator > (const Mat& a, const Mat& b);
2325 CV_EXPORTS MatExpr operator > (const Mat& a, double s);
2326 CV_EXPORTS MatExpr operator > (double s, const Mat& a);
2327
2328 CV_EXPORTS MatExpr operator & (const Mat& a, const Mat& b);
2329 CV_EXPORTS MatExpr operator & (const Mat& a, const Scalar& s);
2330 CV_EXPORTS MatExpr operator & (const Scalar& s, const Mat& a);
2331
2332 CV_EXPORTS MatExpr operator | (const Mat& a, const Mat& b);
2333 CV_EXPORTS MatExpr operator | (const Mat& a, const Scalar& s);
2334 CV_EXPORTS MatExpr operator | (const Scalar& s, const Mat& a);
2335
2336 CV_EXPORTS MatExpr operator ^ (const Mat& a, const Mat& b);
2337 CV_EXPORTS MatExpr operator ^ (const Mat& a, const Scalar& s);
2338 CV_EXPORTS MatExpr operator ^ (const Scalar& s, const Mat& a);
2339
2340 CV_EXPORTS MatExpr operator ~(const Mat& m);
2341
2342 CV_EXPORTS MatExpr min(const Mat& a, const Mat& b);
2343 CV_EXPORTS MatExpr min(const Mat& a, double s);
2344 CV_EXPORTS MatExpr min(double s, const Mat& a);
2345
2346 CV_EXPORTS MatExpr max(const Mat& a, const Mat& b);
2347 CV_EXPORTS MatExpr max(const Mat& a, double s);
2348 CV_EXPORTS MatExpr max(double s, const Mat& a);
2349
2350 CV_EXPORTS MatExpr abs(const Mat& m);
2351 CV_EXPORTS MatExpr abs(const MatExpr& e);
2352
2353 } // cv
2354
2355 #include "opencv2/core/mat.inl.hpp"
2356
2357 #endif // __OPENCV_CORE_MAT_HPP__