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