1 /*M///////////////////////////////////////////////////////////////////////////////////////
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
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.
11 // For Open Source Computer Vision Library
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.
18 // Redistribution and use in source and binary forms, with or without modification,
19 // are permitted provided that the following conditions are met:
21 // * Redistribution's of source code must retain the above copyright notice,
22 // this list of conditions and the following disclaimer.
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.
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.
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.
44 #ifndef __OPENCV_CORE_MAT_HPP__
45 #define __OPENCV_CORE_MAT_HPP__
48 # error mat.hpp header must be compiled as C++
51 #include "opencv2/core/matx.hpp"
52 #include "opencv2/core/types.hpp"
54 #include "opencv2/core/bufferpool.hpp"
59 enum { ACCESS_READ=1<<24, ACCESS_WRITE=1<<25,
60 ACCESS_RW=3<<24, ACCESS_MASK=ACCESS_RW, ACCESS_FAST=1<<26 };
62 class CV_EXPORTS _OutputArray;
64 //////////////////////// Input/Output Array Arguments /////////////////////////////////
67 Proxy datatype for passing Mat's and vector<>'s as input parameters
69 class CV_EXPORTS _InputArray
74 FIXED_TYPE = 0x8000 << KIND_SHIFT,
75 FIXED_SIZE = 0x4000 << KIND_SHIFT,
76 KIND_MASK = 31 << KIND_SHIFT,
78 NONE = 0 << KIND_SHIFT,
79 MAT = 1 << KIND_SHIFT,
80 MATX = 2 << KIND_SHIFT,
81 STD_VECTOR = 3 << KIND_SHIFT,
82 STD_VECTOR_VECTOR = 4 << KIND_SHIFT,
83 STD_VECTOR_MAT = 5 << KIND_SHIFT,
84 EXPR = 6 << KIND_SHIFT,
85 OPENGL_BUFFER = 7 << KIND_SHIFT,
86 CUDA_MEM = 8 << KIND_SHIFT,
87 GPU_MAT = 9 << KIND_SHIFT,
88 UMAT =10 << KIND_SHIFT,
89 STD_VECTOR_UMAT =11 << KIND_SHIFT
93 _InputArray(int _flags, void* _obj);
94 _InputArray(const Mat& m);
95 _InputArray(const MatExpr& expr);
96 _InputArray(const std::vector<Mat>& vec);
97 template<typename _Tp> _InputArray(const Mat_<_Tp>& m);
98 template<typename _Tp> _InputArray(const std::vector<_Tp>& vec);
99 template<typename _Tp> _InputArray(const std::vector<std::vector<_Tp> >& vec);
100 template<typename _Tp> _InputArray(const std::vector<Mat_<_Tp> >& vec);
101 template<typename _Tp> _InputArray(const _Tp* vec, int n);
102 template<typename _Tp, int m, int n> _InputArray(const Matx<_Tp, m, n>& matx);
103 _InputArray(const double& val);
104 _InputArray(const cuda::GpuMat& d_mat);
105 _InputArray(const ogl::Buffer& buf);
106 _InputArray(const cuda::CudaMem& cuda_mem);
107 template<typename _Tp> _InputArray(const cudev::GpuMat_<_Tp>& m);
108 _InputArray(const UMat& um);
109 _InputArray(const std::vector<UMat>& umv);
111 virtual Mat getMat(int idx=-1) const;
112 virtual UMat getUMat(int idx=-1) const;
113 virtual void getMatVector(std::vector<Mat>& mv) const;
114 virtual void getUMatVector(std::vector<UMat>& umv) const;
115 virtual cuda::GpuMat getGpuMat() const;
116 virtual ogl::Buffer getOGlBuffer() const;
117 void* getObj() const;
119 virtual int kind() const;
120 virtual int dims(int i=-1) const;
121 virtual int cols(int i=-1) const;
122 virtual int rows(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 void copyTo(const _OutputArray& arr, const _InputArray & mask) const;
135 virtual size_t offset(int i=-1) const;
136 virtual size_t step(int i=-1) const;
139 bool isMatVector() const;
140 bool isUMatVector() const;
143 virtual ~_InputArray();
150 void init(int _flags, const void* _obj);
151 void init(int _flags, const void* _obj, Size _sz);
156 Proxy datatype for passing Mat's and vector<>'s as input parameters
158 class CV_EXPORTS _OutputArray : public _InputArray
163 DEPTH_MASK_8U = 1 << CV_8U,
164 DEPTH_MASK_8S = 1 << CV_8S,
165 DEPTH_MASK_16U = 1 << CV_16U,
166 DEPTH_MASK_16S = 1 << CV_16S,
167 DEPTH_MASK_32S = 1 << CV_32S,
168 DEPTH_MASK_32F = 1 << CV_32F,
169 DEPTH_MASK_64F = 1 << CV_64F,
170 DEPTH_MASK_ALL = (DEPTH_MASK_64F<<1)-1,
171 DEPTH_MASK_ALL_BUT_8S = DEPTH_MASK_ALL & ~DEPTH_MASK_8S,
172 DEPTH_MASK_FLT = DEPTH_MASK_32F + DEPTH_MASK_64F
176 _OutputArray(int _flags, void* _obj);
177 _OutputArray(Mat& m);
178 _OutputArray(std::vector<Mat>& vec);
179 _OutputArray(cuda::GpuMat& d_mat);
180 _OutputArray(ogl::Buffer& buf);
181 _OutputArray(cuda::CudaMem& cuda_mem);
182 template<typename _Tp> _OutputArray(cudev::GpuMat_<_Tp>& m);
183 template<typename _Tp> _OutputArray(std::vector<_Tp>& vec);
184 template<typename _Tp> _OutputArray(std::vector<std::vector<_Tp> >& vec);
185 template<typename _Tp> _OutputArray(std::vector<Mat_<_Tp> >& vec);
186 template<typename _Tp> _OutputArray(Mat_<_Tp>& m);
187 template<typename _Tp> _OutputArray(_Tp* vec, int n);
188 template<typename _Tp, int m, int n> _OutputArray(Matx<_Tp, m, n>& matx);
189 _OutputArray(UMat& m);
190 _OutputArray(std::vector<UMat>& vec);
192 _OutputArray(const Mat& m);
193 _OutputArray(const std::vector<Mat>& vec);
194 _OutputArray(const cuda::GpuMat& d_mat);
195 _OutputArray(const ogl::Buffer& buf);
196 _OutputArray(const cuda::CudaMem& cuda_mem);
197 template<typename _Tp> _OutputArray(const cudev::GpuMat_<_Tp>& m);
198 template<typename _Tp> _OutputArray(const std::vector<_Tp>& vec);
199 template<typename _Tp> _OutputArray(const std::vector<std::vector<_Tp> >& vec);
200 template<typename _Tp> _OutputArray(const std::vector<Mat_<_Tp> >& vec);
201 template<typename _Tp> _OutputArray(const Mat_<_Tp>& m);
202 template<typename _Tp> _OutputArray(const _Tp* vec, int n);
203 template<typename _Tp, int m, int n> _OutputArray(const Matx<_Tp, m, n>& matx);
204 _OutputArray(const UMat& m);
205 _OutputArray(const std::vector<UMat>& vec);
207 virtual bool fixedSize() const;
208 virtual bool fixedType() const;
209 virtual bool needed() const;
210 virtual Mat& getMatRef(int i=-1) const;
211 virtual UMat& getUMatRef(int i=-1) const;
212 virtual cuda::GpuMat& getGpuMatRef() const;
213 virtual ogl::Buffer& getOGlBufferRef() const;
214 virtual cuda::CudaMem& getCudaMemRef() const;
215 virtual void create(Size sz, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
216 virtual void create(int rows, int cols, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
217 virtual void create(int dims, const int* size, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
218 virtual void createSameSize(const _InputArray& arr, int mtype) const;
219 virtual void release() const;
220 virtual void clear() const;
221 virtual void setTo(const _InputArray& value, const _InputArray & mask = _InputArray()) const;
223 void assign(const UMat& u) const;
224 void assign(const Mat& m) const;
228 class CV_EXPORTS _InputOutputArray : public _OutputArray
232 _InputOutputArray(int _flags, void* _obj);
233 _InputOutputArray(Mat& m);
234 _InputOutputArray(std::vector<Mat>& vec);
235 _InputOutputArray(cuda::GpuMat& d_mat);
236 _InputOutputArray(ogl::Buffer& buf);
237 _InputOutputArray(cuda::CudaMem& cuda_mem);
238 template<typename _Tp> _InputOutputArray(cudev::GpuMat_<_Tp>& m);
239 template<typename _Tp> _InputOutputArray(std::vector<_Tp>& vec);
240 template<typename _Tp> _InputOutputArray(std::vector<std::vector<_Tp> >& vec);
241 template<typename _Tp> _InputOutputArray(std::vector<Mat_<_Tp> >& vec);
242 template<typename _Tp> _InputOutputArray(Mat_<_Tp>& m);
243 template<typename _Tp> _InputOutputArray(_Tp* vec, int n);
244 template<typename _Tp, int m, int n> _InputOutputArray(Matx<_Tp, m, n>& matx);
245 _InputOutputArray(UMat& m);
246 _InputOutputArray(std::vector<UMat>& vec);
248 _InputOutputArray(const Mat& m);
249 _InputOutputArray(const std::vector<Mat>& vec);
250 _InputOutputArray(const cuda::GpuMat& d_mat);
251 _InputOutputArray(const ogl::Buffer& buf);
252 _InputOutputArray(const cuda::CudaMem& cuda_mem);
253 template<typename _Tp> _InputOutputArray(const cudev::GpuMat_<_Tp>& m);
254 template<typename _Tp> _InputOutputArray(const std::vector<_Tp>& vec);
255 template<typename _Tp> _InputOutputArray(const std::vector<std::vector<_Tp> >& vec);
256 template<typename _Tp> _InputOutputArray(const std::vector<Mat_<_Tp> >& vec);
257 template<typename _Tp> _InputOutputArray(const Mat_<_Tp>& m);
258 template<typename _Tp> _InputOutputArray(const _Tp* vec, int n);
259 template<typename _Tp, int m, int n> _InputOutputArray(const Matx<_Tp, m, n>& matx);
260 _InputOutputArray(const UMat& m);
261 _InputOutputArray(const std::vector<UMat>& vec);
264 typedef const _InputArray& InputArray;
265 typedef InputArray InputArrayOfArrays;
266 typedef const _OutputArray& OutputArray;
267 typedef OutputArray OutputArrayOfArrays;
268 typedef const _InputOutputArray& InputOutputArray;
269 typedef InputOutputArray InputOutputArrayOfArrays;
271 CV_EXPORTS InputOutputArray noArray();
273 /////////////////////////////////// MatAllocator //////////////////////////////////////
275 //! Usage flags for allocator
280 // default allocation policy is platform and usage specific
281 USAGE_ALLOCATE_HOST_MEMORY = 1 << 0,
282 USAGE_ALLOCATE_DEVICE_MEMORY = 1 << 1,
284 __UMAT_USAGE_FLAGS_32BIT = 0x7fffffff // Binary compatibility hint
287 struct CV_EXPORTS UMatData;
290 Custom array allocator
293 class CV_EXPORTS MatAllocator
297 virtual ~MatAllocator() {}
299 // let's comment it off for now to detect and fix all the uses of allocator
300 //virtual void allocate(int dims, const int* sizes, int type, int*& refcount,
301 // uchar*& datastart, uchar*& data, size_t* step) = 0;
302 //virtual void deallocate(int* refcount, uchar* datastart, uchar* data) = 0;
303 virtual UMatData* allocate(int dims, const int* sizes, int type,
304 void* data, size_t* step, int flags, UMatUsageFlags usageFlags) const = 0;
305 virtual bool allocate(UMatData* data, int accessflags, UMatUsageFlags usageFlags) const = 0;
306 virtual void deallocate(UMatData* data) const = 0;
307 virtual void map(UMatData* data, int accessflags) const;
308 virtual void unmap(UMatData* data) const;
309 virtual void download(UMatData* data, void* dst, int dims, const size_t sz[],
310 const size_t srcofs[], const size_t srcstep[],
311 const size_t dststep[]) const;
312 virtual void upload(UMatData* data, const void* src, int dims, const size_t sz[],
313 const size_t dstofs[], const size_t dststep[],
314 const size_t srcstep[]) const;
315 virtual void copy(UMatData* srcdata, UMatData* dstdata, int dims, const size_t sz[],
316 const size_t srcofs[], const size_t srcstep[],
317 const size_t dstofs[], const size_t dststep[], bool sync) const;
319 // default implementation returns DummyBufferPoolController
320 virtual BufferPoolController* getBufferPoolController() const;
324 //////////////////////////////// MatCommaInitializer //////////////////////////////////
327 Comma-separated Matrix Initializer
329 The class instances are usually not created explicitly.
330 Instead, they are created on "matrix << firstValue" operator.
332 The sample below initializes 2x2 rotation matrix:
335 double angle = 30, a = cos(angle*CV_PI/180), b = sin(angle*CV_PI/180);
336 Mat R = (Mat_<double>(2,2) << a, -b, b, a);
339 template<typename _Tp> class MatCommaInitializer_
342 //! the constructor, created by "matrix << firstValue" operator, where matrix is cv::Mat
343 MatCommaInitializer_(Mat_<_Tp>* _m);
344 //! the operator that takes the next value and put it to the matrix
345 template<typename T2> MatCommaInitializer_<_Tp>& operator , (T2 v);
346 //! another form of conversion operator
347 operator Mat_<_Tp>() const;
349 MatIterator_<_Tp> it;
353 /////////////////////////////////////// Mat ///////////////////////////////////////////
355 // note that umatdata might be allocated together
356 // with the matrix data, not as a separate object.
357 // therefore, it does not have constructor or destructor;
358 // it should be explicitly initialized using init().
359 struct CV_EXPORTS UMatData
361 enum { COPY_ON_MAP=1, HOST_COPY_OBSOLETE=2,
362 DEVICE_COPY_OBSOLETE=4, TEMP_UMAT=8, TEMP_COPIED_UMAT=24,
363 USER_ALLOCATED=32, DEVICE_MEM_MAPPED=64};
364 UMatData(const MatAllocator* allocator);
367 // provide atomic access to the structure
371 bool hostCopyObsolete() const;
372 bool deviceCopyObsolete() const;
373 bool deviceMemMapped() const;
374 bool copyOnMap() const;
375 bool tempUMat() const;
376 bool tempCopiedUMat() const;
377 void markHostCopyObsolete(bool flag);
378 void markDeviceCopyObsolete(bool flag);
379 void markDeviceMemMapped(bool flag);
381 const MatAllocator* prevAllocator;
382 const MatAllocator* currAllocator;
387 size_t size, capacity;
396 struct CV_EXPORTS UMatDataAutoLock
398 explicit UMatDataAutoLock(UMatData* u);
404 struct CV_EXPORTS MatSize
406 explicit MatSize(int* _p);
407 Size operator()() const;
408 const int& operator[](int i) const;
409 int& operator[](int i);
410 operator const int*() const;
411 bool operator == (const MatSize& sz) const;
412 bool operator != (const MatSize& sz) const;
417 struct CV_EXPORTS MatStep
420 explicit MatStep(size_t s);
421 const size_t& operator[](int i) const;
422 size_t& operator[](int i);
423 operator size_t() const;
424 MatStep& operator = (size_t s);
429 MatStep& operator = (const MatStep&);
433 The n-dimensional matrix class.
435 The class represents an n-dimensional dense numerical array that can act as
436 a matrix, image, optical flow map, 3-focal tensor etc.
437 It is very similar to CvMat and CvMatND types from earlier versions of OpenCV,
438 and similarly to those types, the matrix can be multi-channel. It also fully supports ROI mechanism.
440 There are many different ways to create cv::Mat object. Here are the some popular ones:
442 <li> using cv::Mat::create(nrows, ncols, type) method or
443 the similar constructor cv::Mat::Mat(nrows, ncols, type[, fill_value]) constructor.
444 A new matrix of the specified size and specifed type will be allocated.
445 "type" has the same meaning as in cvCreateMat function,
446 e.g. CV_8UC1 means 8-bit single-channel matrix, CV_32FC2 means 2-channel (i.e. complex)
447 floating-point matrix etc:
450 // make 7x7 complex matrix filled with 1+3j.
451 cv::Mat M(7,7,CV_32FC2,Scalar(1,3));
452 // and now turn M to 100x60 15-channel 8-bit matrix.
453 // The old content will be deallocated
454 M.create(100,60,CV_8UC(15));
457 As noted in the introduction of this chapter, Mat::create()
458 will only allocate a new matrix when the current matrix dimensionality
459 or type are different from the specified.
461 <li> by using a copy constructor or assignment operator, where on the right side it can
462 be a matrix or expression, see below. Again, as noted in the introduction,
463 matrix assignment is O(1) operation because it only copies the header
464 and increases the reference counter. cv::Mat::clone() method can be used to get a full
465 (a.k.a. deep) copy of the matrix when you need it.
467 <li> by constructing a header for a part of another matrix. It can be a single row, single column,
468 several rows, several columns, rectangular region in the matrix (called a minor in algebra) or
469 a diagonal. Such operations are also O(1), because the new header will reference the same data.
470 You can actually modify a part of the matrix using this feature, e.g.
473 // add 5-th row, multiplied by 3 to the 3rd row
474 M.row(3) = M.row(3) + M.row(5)*3;
476 // now copy 7-th column to the 1-st column
477 // M.col(1) = M.col(7); // this will not work
481 // create new 320x240 image
482 cv::Mat img(Size(320,240),CV_8UC3);
484 cv::Mat roi(img, Rect(10,10,100,100));
485 // fill the ROI with (0,255,0) (which is green in RGB space);
486 // the original 320x240 image will be modified
487 roi = Scalar(0,255,0);
490 Thanks to the additional cv::Mat::datastart and cv::Mat::dataend members, it is possible to
491 compute the relative sub-matrix position in the main "container" matrix using cv::Mat::locateROI():
494 Mat A = Mat::eye(10, 10, CV_32S);
495 // extracts A columns, 1 (inclusive) to 3 (exclusive).
496 Mat B = A(Range::all(), Range(1, 3));
497 // extracts B rows, 5 (inclusive) to 9 (exclusive).
498 // that is, C ~ A(Range(5, 9), Range(1, 3))
499 Mat C = B(Range(5, 9), Range::all());
500 Size size; Point ofs;
501 C.locateROI(size, ofs);
502 // size will be (width=10,height=10) and the ofs will be (x=1, y=5)
505 As in the case of whole matrices, if you need a deep copy, use cv::Mat::clone() method
506 of the extracted sub-matrices.
508 <li> by making a header for user-allocated-data. It can be useful for
510 <li> processing "foreign" data using OpenCV (e.g. when you implement
511 a DirectShow filter or a processing module for gstreamer etc.), e.g.
514 void process_video_frame(const unsigned char* pixels,
515 int width, int height, int step)
517 cv::Mat img(height, width, CV_8UC3, pixels, step);
518 cv::GaussianBlur(img, img, cv::Size(7,7), 1.5, 1.5);
522 <li> for quick initialization of small matrices and/or super-fast element access
525 double m[3][3] = {{a, b, c}, {d, e, f}, {g, h, i}};
526 cv::Mat M = cv::Mat(3, 3, CV_64F, m).inv();
530 partial yet very common cases of this "user-allocated data" case are conversions
531 from CvMat and IplImage to cv::Mat. For this purpose there are special constructors
532 taking pointers to CvMat or IplImage and the optional
533 flag indicating whether to copy the data or not.
535 Backward conversion from cv::Mat to CvMat or IplImage is provided via cast operators
536 cv::Mat::operator CvMat() an cv::Mat::operator IplImage().
537 The operators do not copy the data.
541 IplImage* img = cvLoadImage("greatwave.jpg", 1);
542 Mat mtx(img); // convert IplImage* -> cv::Mat
543 CvMat oldmat = mtx; // convert cv::Mat -> CvMat
544 CV_Assert(oldmat.cols == img->width && oldmat.rows == img->height &&
545 oldmat.data.ptr == (uchar*)img->imageData && oldmat.step == img->widthStep);
548 <li> by using MATLAB-style matrix initializers, cv::Mat::zeros(), cv::Mat::ones(), cv::Mat::eye(), e.g.:
551 // create a double-precision identity martix and add it to M.
552 M += Mat::eye(M.rows, M.cols, CV_64F);
555 <li> by using comma-separated initializer:
558 // create 3x3 double-precision identity matrix
559 Mat M = (Mat_<double>(3,3) << 1, 0, 0, 0, 1, 0, 0, 0, 1);
562 here we first call constructor of cv::Mat_ class (that we describe further) with the proper matrix,
563 and then we just put "<<" operator followed by comma-separated values that can be constants,
564 variables, expressions etc. Also, note the extra parentheses that are needed to avoid compiler errors.
568 Once matrix is created, it will be automatically managed by using reference-counting mechanism
569 (unless the matrix header is built on top of user-allocated data,
570 in which case you should handle the data by yourself).
571 The matrix data will be deallocated when no one points to it;
572 if you want to release the data pointed by a matrix header before the matrix destructor is called,
573 use cv::Mat::release().
575 The next important thing to learn about the matrix class is element access. Here is how the matrix is stored.
576 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,
577 cv::Mat::rows contains the number of matrix rows and cv::Mat::cols - the number of matrix columns. There is yet another member,
578 cv::Mat::step that is used to actually compute address of a matrix element. cv::Mat::step is needed because the matrix can be
579 a part of another matrix or because there can some padding space in the end of each row for a proper alignment.
581 Given these parameters, address of the matrix element M_{ij} is computed as following:
583 addr(M_{ij})=M.data + M.step*i + j*M.elemSize()
585 if you know the matrix element type, e.g. it is float, then you can use cv::Mat::at() method:
587 addr(M_{ij})=&M.at<float>(i,j)
589 (where & is used to convert the reference returned by cv::Mat::at() to a pointer).
590 if you need to process a whole row of matrix, the most efficient way is to get
591 the pointer to the row first, and then just use plain C operator []:
594 // compute sum of positive matrix elements
595 // (assuming that M is double-precision matrix)
597 for(int i = 0; i < M.rows; i++)
599 const double* Mi = M.ptr<double>(i);
600 for(int j = 0; j < M.cols; j++)
601 sum += std::max(Mi[j], 0.);
605 Some operations, like the above one, do not actually depend on the matrix shape,
606 they just process elements of a matrix one by one (or elements from multiple matrices
607 that are sitting in the same place, e.g. matrix addition). Such operations are called
608 element-wise and it makes sense to check whether all the input/output matrices are continuous,
609 i.e. have no gaps in the end of each row, and if yes, process them as a single long row:
612 // compute sum of positive matrix elements, optimized variant
614 int cols = M.cols, rows = M.rows;
620 for(int i = 0; i < rows; i++)
622 const double* Mi = M.ptr<double>(i);
623 for(int j = 0; j < cols; j++)
624 sum += std::max(Mi[j], 0.);
627 in the case of continuous matrix the outer loop body will be executed just once,
628 so the overhead will be smaller, which will be especially noticeable in the case of small matrices.
630 Finally, there are STL-style iterators that are smart enough to skip gaps between successive rows:
632 // compute sum of positive matrix elements, iterator-based variant
634 MatConstIterator_<double> it = M.begin<double>(), it_end = M.end<double>();
635 for(; it != it_end; ++it)
636 sum += std::max(*it, 0.);
639 The matrix iterators are random-access iterators, so they can be passed
640 to any STL algorithm, including std::sort().
645 //! default constructor
647 //! constructs 2D matrix of the specified size and type
648 // (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
649 Mat(int rows, int cols, int type);
650 Mat(Size size, int type);
651 //! constucts 2D matrix and fills it with the specified value _s.
652 Mat(int rows, int cols, int type, const Scalar& s);
653 Mat(Size size, int type, const Scalar& s);
655 //! constructs n-dimensional matrix
656 Mat(int ndims, const int* sizes, int type);
657 Mat(int ndims, const int* sizes, int type, const Scalar& s);
661 //! constructor for matrix headers pointing to user-allocated data
662 Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP);
663 Mat(Size size, int type, void* data, size_t step=AUTO_STEP);
664 Mat(int ndims, const int* sizes, int type, void* data, const size_t* steps=0);
666 //! creates a matrix header for a part of the bigger matrix
667 Mat(const Mat& m, const Range& rowRange, const Range& colRange=Range::all());
668 Mat(const Mat& m, const Rect& roi);
669 Mat(const Mat& m, const Range* ranges);
670 //! builds matrix from std::vector with or without copying the data
671 template<typename _Tp> explicit Mat(const std::vector<_Tp>& vec, bool copyData=false);
672 //! builds matrix from cv::Vec; the data is copied by default
673 template<typename _Tp, int n> explicit Mat(const Vec<_Tp, n>& vec, bool copyData=true);
674 //! builds matrix from cv::Matx; the data is copied by default
675 template<typename _Tp, int m, int n> explicit Mat(const Matx<_Tp, m, n>& mtx, bool copyData=true);
676 //! builds matrix from a 2D point
677 template<typename _Tp> explicit Mat(const Point_<_Tp>& pt, bool copyData=true);
678 //! builds matrix from a 3D point
679 template<typename _Tp> explicit Mat(const Point3_<_Tp>& pt, bool copyData=true);
680 //! builds matrix from comma initializer
681 template<typename _Tp> explicit Mat(const MatCommaInitializer_<_Tp>& commaInitializer);
683 //! download data from GpuMat
684 explicit Mat(const cuda::GpuMat& m);
686 //! destructor - calls release()
688 //! assignment operators
689 Mat& operator = (const Mat& m);
690 Mat& operator = (const MatExpr& expr);
692 //! retrieve UMat from Mat
693 UMat getUMat(int accessFlags, UMatUsageFlags usageFlags = USAGE_DEFAULT) const;
695 //! returns a new matrix header for the specified row
696 Mat row(int y) const;
697 //! returns a new matrix header for the specified column
698 Mat col(int x) const;
699 //! ... for the specified row span
700 Mat rowRange(int startrow, int endrow) const;
701 Mat rowRange(const Range& r) const;
702 //! ... for the specified column span
703 Mat colRange(int startcol, int endcol) const;
704 Mat colRange(const Range& r) const;
705 //! ... for the specified diagonal
706 // (d=0 - the main diagonal,
707 // >0 - a diagonal from the lower half,
708 // <0 - a diagonal from the upper half)
709 Mat diag(int d=0) const;
710 //! constructs a square diagonal matrix which main diagonal is vector "d"
711 static Mat diag(const Mat& d);
713 //! returns deep copy of the matrix, i.e. the data is copied
715 //! copies the matrix content to "m".
716 // It calls m.create(this->size(), this->type()).
717 void copyTo( OutputArray m ) const;
718 //! copies those matrix elements to "m" that are marked with non-zero mask elements.
719 void copyTo( OutputArray m, InputArray mask ) const;
720 //! converts matrix to another datatype with optional scalng. See cvConvertScale.
721 void convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const;
723 void assignTo( Mat& m, int type=-1 ) const;
725 //! sets every matrix element to s
726 Mat& operator = (const Scalar& s);
727 //! sets some of the matrix elements to s, according to the mask
728 Mat& setTo(InputArray value, InputArray mask=noArray());
729 //! creates alternative matrix header for the same data, with different
730 // number of channels and/or different number of rows. see cvReshape.
731 Mat reshape(int cn, int rows=0) const;
732 Mat reshape(int cn, int newndims, const int* newsz) const;
734 //! matrix transposition by means of matrix expressions
736 //! matrix inversion by means of matrix expressions
737 MatExpr inv(int method=DECOMP_LU) const;
738 //! per-element matrix multiplication by means of matrix expressions
739 MatExpr mul(InputArray m, double scale=1) const;
741 //! computes cross-product of 2 3D vectors
742 Mat cross(InputArray m) const;
743 //! computes dot-product
744 double dot(InputArray m) const;
746 //! Matlab-style matrix initialization
747 static MatExpr zeros(int rows, int cols, int type);
748 static MatExpr zeros(Size size, int type);
749 static MatExpr zeros(int ndims, const int* sz, int type);
750 static MatExpr ones(int rows, int cols, int type);
751 static MatExpr ones(Size size, int type);
752 static MatExpr ones(int ndims, const int* sz, int type);
753 static MatExpr eye(int rows, int cols, int type);
754 static MatExpr eye(Size size, int type);
756 //! allocates new matrix data unless the matrix already has specified size and type.
757 // previous data is unreferenced if needed.
758 void create(int rows, int cols, int type);
759 void create(Size size, int type);
760 void create(int ndims, const int* sizes, int type);
762 //! increases the reference counter; use with care to avoid memleaks
764 //! decreases reference counter;
765 // deallocates the data when reference counter reaches 0.
768 //! deallocates the matrix data
770 //! internal use function; properly re-allocates _size, _step arrays
771 void copySize(const Mat& m);
773 //! reserves enough space to fit sz hyper-planes
774 void reserve(size_t sz);
775 //! resizes matrix to the specified number of hyper-planes
776 void resize(size_t sz);
777 //! resizes matrix to the specified number of hyper-planes; initializes the newly added elements
778 void resize(size_t sz, const Scalar& s);
779 //! internal function
780 void push_back_(const void* elem);
781 //! adds element to the end of 1d matrix (or possibly multiple elements when _Tp=Mat)
782 template<typename _Tp> void push_back(const _Tp& elem);
783 template<typename _Tp> void push_back(const Mat_<_Tp>& elem);
784 void push_back(const Mat& m);
785 //! removes several hyper-planes from bottom of the matrix
786 void pop_back(size_t nelems=1);
788 //! locates matrix header within a parent matrix. See below
789 void locateROI( Size& wholeSize, Point& ofs ) const;
790 //! moves/resizes the current matrix ROI inside the parent matrix.
791 Mat& adjustROI( int dtop, int dbottom, int dleft, int dright );
792 //! extracts a rectangular sub-matrix
793 // (this is a generalized form of row, rowRange etc.)
794 Mat operator()( Range rowRange, Range colRange ) const;
795 Mat operator()( const Rect& roi ) const;
796 Mat operator()( const Range* ranges ) const;
798 // //! converts header to CvMat; no data is copied
799 // operator CvMat() const;
800 // //! converts header to CvMatND; no data is copied
801 // operator CvMatND() const;
802 // //! converts header to IplImage; no data is copied
803 // operator IplImage() const;
805 template<typename _Tp> operator std::vector<_Tp>() const;
806 template<typename _Tp, int n> operator Vec<_Tp, n>() const;
807 template<typename _Tp, int m, int n> operator Matx<_Tp, m, n>() const;
809 //! returns true iff the matrix data is continuous
810 // (i.e. when there are no gaps between successive rows).
811 // similar to CV_IS_MAT_CONT(cvmat->type)
812 bool isContinuous() const;
814 //! returns true if the matrix is a submatrix of another matrix
815 bool isSubmatrix() const;
817 //! returns element size in bytes,
818 // similar to CV_ELEM_SIZE(cvmat->type)
819 size_t elemSize() const;
820 //! returns the size of element channel in bytes.
821 size_t elemSize1() const;
822 //! returns element type, similar to CV_MAT_TYPE(cvmat->type)
824 //! returns element type, similar to CV_MAT_DEPTH(cvmat->type)
826 //! returns element type, similar to CV_MAT_CN(cvmat->type)
827 int channels() const;
828 //! returns step/elemSize1()
829 size_t step1(int i=0) const;
830 //! returns true if matrix data is NULL
832 //! returns the total number of matrix elements
833 size_t total() const;
835 //! returns N if the matrix is 1-channel (N x ptdim) or ptdim-channel (1 x N) or (N x 1); negative number otherwise
836 int checkVector(int elemChannels, int depth=-1, bool requireContinuous=true) const;
838 //! returns pointer to i0-th submatrix along the dimension #0
839 uchar* ptr(int i0=0);
840 const uchar* ptr(int i0=0) const;
842 //! returns pointer to (i0,i1) submatrix along the dimensions #0 and #1
843 uchar* ptr(int i0, int i1);
844 const uchar* ptr(int i0, int i1) const;
846 //! returns pointer to (i0,i1,i3) submatrix along the dimensions #0, #1, #2
847 uchar* ptr(int i0, int i1, int i2);
848 const uchar* ptr(int i0, int i1, int i2) const;
850 //! returns pointer to the matrix element
851 uchar* ptr(const int* idx);
852 //! returns read-only pointer to the matrix element
853 const uchar* ptr(const int* idx) const;
855 template<int n> uchar* ptr(const Vec<int, n>& idx);
856 template<int n> const uchar* ptr(const Vec<int, n>& idx) const;
858 //! template version of the above method
859 template<typename _Tp> _Tp* ptr(int i0=0);
860 template<typename _Tp> const _Tp* ptr(int i0=0) const;
862 template<typename _Tp> _Tp* ptr(int i0, int i1);
863 template<typename _Tp> const _Tp* ptr(int i0, int i1) const;
865 template<typename _Tp> _Tp* ptr(int i0, int i1, int i2);
866 template<typename _Tp> const _Tp* ptr(int i0, int i1, int i2) const;
868 template<typename _Tp> _Tp* ptr(const int* idx);
869 template<typename _Tp> const _Tp* ptr(const int* idx) const;
871 template<typename _Tp, int n> _Tp* ptr(const Vec<int, n>& idx);
872 template<typename _Tp, int n> const _Tp* ptr(const Vec<int, n>& idx) const;
874 //! the same as above, with the pointer dereferencing
875 template<typename _Tp> _Tp& at(int i0=0);
876 template<typename _Tp> const _Tp& at(int i0=0) const;
878 template<typename _Tp> _Tp& at(int i0, int i1);
879 template<typename _Tp> const _Tp& at(int i0, int i1) const;
881 template<typename _Tp> _Tp& at(int i0, int i1, int i2);
882 template<typename _Tp> const _Tp& at(int i0, int i1, int i2) const;
884 template<typename _Tp> _Tp& at(const int* idx);
885 template<typename _Tp> const _Tp& at(const int* idx) const;
887 template<typename _Tp, int n> _Tp& at(const Vec<int, n>& idx);
888 template<typename _Tp, int n> const _Tp& at(const Vec<int, n>& idx) const;
890 //! special versions for 2D arrays (especially convenient for referencing image pixels)
891 template<typename _Tp> _Tp& at(Point pt);
892 template<typename _Tp> const _Tp& at(Point pt) const;
894 //! template methods for iteration over matrix elements.
895 // the iterators take care of skipping gaps in the end of rows (if any)
896 template<typename _Tp> MatIterator_<_Tp> begin();
897 template<typename _Tp> MatIterator_<_Tp> end();
898 template<typename _Tp> MatConstIterator_<_Tp> begin() const;
899 template<typename _Tp> MatConstIterator_<_Tp> end() const;
901 //! template methods for for operation over all matrix elements.
902 // the operations take care of skipping gaps in the end of rows (if any)
903 template<typename _Tp, typename Functor> void forEach(const Functor& operation);
904 template<typename _Tp, typename Functor> void forEach(const Functor& operation) const;
906 enum { MAGIC_VAL = 0x42FF0000, AUTO_STEP = 0, CONTINUOUS_FLAG = CV_MAT_CONT_FLAG, SUBMATRIX_FLAG = CV_SUBMAT_FLAG };
907 enum { MAGIC_MASK = 0xFFFF0000, TYPE_MASK = 0x00000FFF, DEPTH_MASK = 7 };
909 /*! includes several bit-fields:
910 - the magic signature
916 //! the matrix dimensionality, >= 2
918 //! the number of rows and columns or (-1, -1) when the matrix has more than 2 dimensions
920 //! pointer to the data
923 //! helper fields used in locateROI and adjustROI
924 const uchar* datastart;
925 const uchar* dataend;
926 const uchar* datalimit;
929 MatAllocator* allocator;
930 //! and the standard allocator
931 static MatAllocator* getStdAllocator();
933 //! interaction with UMat
940 template<typename _Tp, typename Functor> void forEach_impl(const Functor& operation);
944 ///////////////////////////////// Mat_<_Tp> ////////////////////////////////////
947 Template matrix class derived from Mat
949 The class Mat_ is a "thin" template wrapper on top of cv::Mat. It does not have any extra data fields,
950 nor it or cv::Mat have any virtual methods and thus references or pointers to these two classes
951 can be safely converted one to another. But do it with care, for example:
954 // create 100x100 8-bit matrix
955 Mat M(100,100,CV_8U);
956 // this will compile fine. no any data conversion will be done.
957 Mat_<float>& M1 = (Mat_<float>&)M;
958 // the program will likely crash at the statement below
962 While cv::Mat is sufficient in most cases, cv::Mat_ can be more convenient if you use a lot of element
963 access operations and if you know matrix type at compile time. Note that cv::Mat::at and
964 cv::Mat::operator() do absolutely the same thing and run at the same speed, but the latter is certainly shorter:
967 Mat_<double> M(20,20);
968 for(int i = 0; i < M.rows; i++)
969 for(int j = 0; j < M.cols; j++)
973 cout << E.at<double>(0,0)/E.at<double>(M.rows-1,0);
976 It is easy to use Mat_ for multi-channel images/matrices - just pass cv::Vec as cv::Mat_ template parameter:
979 // allocate 320x240 color image and fill it with green (in RGB space)
980 Mat_<Vec3b> img(240, 320, Vec3b(0,255,0));
981 // now draw a diagonal white line
982 for(int i = 0; i < 100; i++)
983 img(i,i)=Vec3b(255,255,255);
984 // and now modify the 2nd (red) channel of each pixel
985 for(int i = 0; i < img.rows; i++)
986 for(int j = 0; j < img.cols; j++)
987 img(i,j)[2] ^= (uchar)(i ^ j); // img(y,x)[c] accesses c-th channel of the pixel (x,y)
990 template<typename _Tp> class Mat_ : public Mat
993 typedef _Tp value_type;
994 typedef typename DataType<_Tp>::channel_type channel_type;
995 typedef MatIterator_<_Tp> iterator;
996 typedef MatConstIterator_<_Tp> const_iterator;
998 //! default constructor
1000 //! equivalent to Mat(_rows, _cols, DataType<_Tp>::type)
1001 Mat_(int _rows, int _cols);
1002 //! constructor that sets each matrix element to specified value
1003 Mat_(int _rows, int _cols, const _Tp& value);
1004 //! equivalent to Mat(_size, DataType<_Tp>::type)
1005 explicit Mat_(Size _size);
1006 //! constructor that sets each matrix element to specified value
1007 Mat_(Size _size, const _Tp& value);
1008 //! n-dim array constructor
1009 Mat_(int _ndims, const int* _sizes);
1010 //! n-dim array constructor that sets each matrix element to specified value
1011 Mat_(int _ndims, const int* _sizes, const _Tp& value);
1012 //! copy/conversion contructor. If m is of different type, it's converted
1014 //! copy constructor
1015 Mat_(const Mat_& m);
1016 //! constructs a matrix on top of user-allocated data. step is in bytes(!!!), regardless of the type
1017 Mat_(int _rows, int _cols, _Tp* _data, size_t _step=AUTO_STEP);
1018 //! constructs n-dim matrix on top of user-allocated data. steps are in bytes(!!!), regardless of the type
1019 Mat_(int _ndims, const int* _sizes, _Tp* _data, const size_t* _steps=0);
1020 //! selects a submatrix
1021 Mat_(const Mat_& m, const Range& rowRange, const Range& colRange=Range::all());
1022 //! selects a submatrix
1023 Mat_(const Mat_& m, const Rect& roi);
1024 //! selects a submatrix, n-dim version
1025 Mat_(const Mat_& m, const Range* ranges);
1026 //! from a matrix expression
1027 explicit Mat_(const MatExpr& e);
1028 //! makes a matrix out of Vec, std::vector, Point_ or Point3_. The matrix will have a single column
1029 explicit Mat_(const std::vector<_Tp>& vec, bool copyData=false);
1030 template<int n> explicit Mat_(const Vec<typename DataType<_Tp>::channel_type, n>& vec, bool copyData=true);
1031 template<int m, int n> explicit Mat_(const Matx<typename DataType<_Tp>::channel_type, m, n>& mtx, bool copyData=true);
1032 explicit Mat_(const Point_<typename DataType<_Tp>::channel_type>& pt, bool copyData=true);
1033 explicit Mat_(const Point3_<typename DataType<_Tp>::channel_type>& pt, bool copyData=true);
1034 explicit Mat_(const MatCommaInitializer_<_Tp>& commaInitializer);
1036 Mat_& operator = (const Mat& m);
1037 Mat_& operator = (const Mat_& m);
1038 //! set all the elements to s.
1039 Mat_& operator = (const _Tp& s);
1040 //! assign a matrix expression
1041 Mat_& operator = (const MatExpr& e);
1043 //! iterators; they are smart enough to skip gaps in the end of rows
1046 const_iterator begin() const;
1047 const_iterator end() const;
1049 //! template methods for for operation over all matrix elements.
1050 // the operations take care of skipping gaps in the end of rows (if any)
1051 template<typename Functor> void forEach(const Functor& operation);
1052 template<typename Functor> void forEach(const Functor& operation) const;
1054 //! equivalent to Mat::create(_rows, _cols, DataType<_Tp>::type)
1055 void create(int _rows, int _cols);
1056 //! equivalent to Mat::create(_size, DataType<_Tp>::type)
1057 void create(Size _size);
1058 //! equivalent to Mat::create(_ndims, _sizes, DatType<_Tp>::type)
1059 void create(int _ndims, const int* _sizes);
1061 Mat_ cross(const Mat_& m) const;
1062 //! data type conversion
1063 template<typename T2> operator Mat_<T2>() const;
1064 //! overridden forms of Mat::row() etc.
1065 Mat_ row(int y) const;
1066 Mat_ col(int x) const;
1067 Mat_ diag(int d=0) const;
1070 //! overridden forms of Mat::elemSize() etc.
1071 size_t elemSize() const;
1072 size_t elemSize1() const;
1075 int channels() const;
1076 size_t step1(int i=0) const;
1077 //! returns step()/sizeof(_Tp)
1078 size_t stepT(int i=0) const;
1080 //! overridden forms of Mat::zeros() etc. Data type is omitted, of course
1081 static MatExpr zeros(int rows, int cols);
1082 static MatExpr zeros(Size size);
1083 static MatExpr zeros(int _ndims, const int* _sizes);
1084 static MatExpr ones(int rows, int cols);
1085 static MatExpr ones(Size size);
1086 static MatExpr ones(int _ndims, const int* _sizes);
1087 static MatExpr eye(int rows, int cols);
1088 static MatExpr eye(Size size);
1090 //! some more overriden methods
1091 Mat_& adjustROI( int dtop, int dbottom, int dleft, int dright );
1092 Mat_ operator()( const Range& rowRange, const Range& colRange ) const;
1093 Mat_ operator()( const Rect& roi ) const;
1094 Mat_ operator()( const Range* ranges ) const;
1096 //! more convenient forms of row and element access operators
1097 _Tp* operator [](int y);
1098 const _Tp* operator [](int y) const;
1100 //! returns reference to the specified element
1101 _Tp& operator ()(const int* idx);
1102 //! returns read-only reference to the specified element
1103 const _Tp& operator ()(const int* idx) const;
1105 //! returns reference to the specified element
1106 template<int n> _Tp& operator ()(const Vec<int, n>& idx);
1107 //! returns read-only reference to the specified element
1108 template<int n> const _Tp& operator ()(const Vec<int, n>& idx) const;
1110 //! returns reference to the specified element (1D case)
1111 _Tp& operator ()(int idx0);
1112 //! returns read-only reference to the specified element (1D case)
1113 const _Tp& operator ()(int idx0) const;
1114 //! returns reference to the specified element (2D case)
1115 _Tp& operator ()(int idx0, int idx1);
1116 //! returns read-only reference to the specified element (2D case)
1117 const _Tp& operator ()(int idx0, int idx1) const;
1118 //! returns reference to the specified element (3D case)
1119 _Tp& operator ()(int idx0, int idx1, int idx2);
1120 //! returns read-only reference to the specified element (3D case)
1121 const _Tp& operator ()(int idx0, int idx1, int idx2) const;
1123 _Tp& operator ()(Point pt);
1124 const _Tp& operator ()(Point pt) const;
1126 //! conversion to vector.
1127 operator std::vector<_Tp>() const;
1128 //! conversion to Vec
1129 template<int n> operator Vec<typename DataType<_Tp>::channel_type, n>() const;
1130 //! conversion to Matx
1131 template<int m, int n> operator Matx<typename DataType<_Tp>::channel_type, m, n>() const;
1134 typedef Mat_<uchar> Mat1b;
1135 typedef Mat_<Vec2b> Mat2b;
1136 typedef Mat_<Vec3b> Mat3b;
1137 typedef Mat_<Vec4b> Mat4b;
1139 typedef Mat_<short> Mat1s;
1140 typedef Mat_<Vec2s> Mat2s;
1141 typedef Mat_<Vec3s> Mat3s;
1142 typedef Mat_<Vec4s> Mat4s;
1144 typedef Mat_<ushort> Mat1w;
1145 typedef Mat_<Vec2w> Mat2w;
1146 typedef Mat_<Vec3w> Mat3w;
1147 typedef Mat_<Vec4w> Mat4w;
1149 typedef Mat_<int> Mat1i;
1150 typedef Mat_<Vec2i> Mat2i;
1151 typedef Mat_<Vec3i> Mat3i;
1152 typedef Mat_<Vec4i> Mat4i;
1154 typedef Mat_<float> Mat1f;
1155 typedef Mat_<Vec2f> Mat2f;
1156 typedef Mat_<Vec3f> Mat3f;
1157 typedef Mat_<Vec4f> Mat4f;
1159 typedef Mat_<double> Mat1d;
1160 typedef Mat_<Vec2d> Mat2d;
1161 typedef Mat_<Vec3d> Mat3d;
1162 typedef Mat_<Vec4d> Mat4d;
1164 class CV_EXPORTS UMat
1167 //! default constructor
1168 UMat(UMatUsageFlags usageFlags = USAGE_DEFAULT);
1169 //! constructs 2D matrix of the specified size and type
1170 // (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
1171 UMat(int rows, int cols, int type, UMatUsageFlags usageFlags = USAGE_DEFAULT);
1172 UMat(Size size, int type, UMatUsageFlags usageFlags = USAGE_DEFAULT);
1173 //! constucts 2D matrix and fills it with the specified value _s.
1174 UMat(int rows, int cols, int type, const Scalar& s, UMatUsageFlags usageFlags = USAGE_DEFAULT);
1175 UMat(Size size, int type, const Scalar& s, UMatUsageFlags usageFlags = USAGE_DEFAULT);
1177 //! constructs n-dimensional matrix
1178 UMat(int ndims, const int* sizes, int type, UMatUsageFlags usageFlags = USAGE_DEFAULT);
1179 UMat(int ndims, const int* sizes, int type, const Scalar& s, UMatUsageFlags usageFlags = USAGE_DEFAULT);
1181 //! copy constructor
1182 UMat(const UMat& m);
1184 //! creates a matrix header for a part of the bigger matrix
1185 UMat(const UMat& m, const Range& rowRange, const Range& colRange=Range::all());
1186 UMat(const UMat& m, const Rect& roi);
1187 UMat(const UMat& m, const Range* ranges);
1188 //! builds matrix from std::vector with or without copying the data
1189 template<typename _Tp> explicit UMat(const std::vector<_Tp>& vec, bool copyData=false);
1190 //! builds matrix from cv::Vec; the data is copied by default
1191 template<typename _Tp, int n> explicit UMat(const Vec<_Tp, n>& vec, bool copyData=true);
1192 //! builds matrix from cv::Matx; the data is copied by default
1193 template<typename _Tp, int m, int n> explicit UMat(const Matx<_Tp, m, n>& mtx, bool copyData=true);
1194 //! builds matrix from a 2D point
1195 template<typename _Tp> explicit UMat(const Point_<_Tp>& pt, bool copyData=true);
1196 //! builds matrix from a 3D point
1197 template<typename _Tp> explicit UMat(const Point3_<_Tp>& pt, bool copyData=true);
1198 //! builds matrix from comma initializer
1199 template<typename _Tp> explicit UMat(const MatCommaInitializer_<_Tp>& commaInitializer);
1201 //! destructor - calls release()
1203 //! assignment operators
1204 UMat& operator = (const UMat& m);
1206 Mat getMat(int flags) const;
1208 //! returns a new matrix header for the specified row
1209 UMat row(int y) const;
1210 //! returns a new matrix header for the specified column
1211 UMat col(int x) const;
1212 //! ... for the specified row span
1213 UMat rowRange(int startrow, int endrow) const;
1214 UMat rowRange(const Range& r) const;
1215 //! ... for the specified column span
1216 UMat colRange(int startcol, int endcol) const;
1217 UMat colRange(const Range& r) const;
1218 //! ... for the specified diagonal
1219 // (d=0 - the main diagonal,
1220 // >0 - a diagonal from the lower half,
1221 // <0 - a diagonal from the upper half)
1222 UMat diag(int d=0) const;
1223 //! constructs a square diagonal matrix which main diagonal is vector "d"
1224 static UMat diag(const UMat& d);
1226 //! returns deep copy of the matrix, i.e. the data is copied
1228 //! copies the matrix content to "m".
1229 // It calls m.create(this->size(), this->type()).
1230 void copyTo( OutputArray m ) const;
1231 //! copies those matrix elements to "m" that are marked with non-zero mask elements.
1232 void copyTo( OutputArray m, InputArray mask ) const;
1233 //! converts matrix to another datatype with optional scalng. See cvConvertScale.
1234 void convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const;
1236 void assignTo( UMat& m, int type=-1 ) const;
1238 //! sets every matrix element to s
1239 UMat& operator = (const Scalar& s);
1240 //! sets some of the matrix elements to s, according to the mask
1241 UMat& setTo(InputArray value, InputArray mask=noArray());
1242 //! creates alternative matrix header for the same data, with different
1243 // number of channels and/or different number of rows. see cvReshape.
1244 UMat reshape(int cn, int rows=0) const;
1245 UMat reshape(int cn, int newndims, const int* newsz) const;
1247 //! matrix transposition by means of matrix expressions
1249 //! matrix inversion by means of matrix expressions
1250 UMat inv(int method=DECOMP_LU) const;
1251 //! per-element matrix multiplication by means of matrix expressions
1252 UMat mul(InputArray m, double scale=1) const;
1254 //! computes dot-product
1255 double dot(InputArray m) const;
1257 //! Matlab-style matrix initialization
1258 static UMat zeros(int rows, int cols, int type);
1259 static UMat zeros(Size size, int type);
1260 static UMat zeros(int ndims, const int* sz, int type);
1261 static UMat ones(int rows, int cols, int type);
1262 static UMat ones(Size size, int type);
1263 static UMat ones(int ndims, const int* sz, int type);
1264 static UMat eye(int rows, int cols, int type);
1265 static UMat eye(Size size, int type);
1267 //! allocates new matrix data unless the matrix already has specified size and type.
1268 // previous data is unreferenced if needed.
1269 void create(int rows, int cols, int type, UMatUsageFlags usageFlags = USAGE_DEFAULT);
1270 void create(Size size, int type, UMatUsageFlags usageFlags = USAGE_DEFAULT);
1271 void create(int ndims, const int* sizes, int type, UMatUsageFlags usageFlags = USAGE_DEFAULT);
1273 //! increases the reference counter; use with care to avoid memleaks
1275 //! decreases reference counter;
1276 // deallocates the data when reference counter reaches 0.
1279 //! deallocates the matrix data
1281 //! internal use function; properly re-allocates _size, _step arrays
1282 void copySize(const UMat& m);
1284 //! locates matrix header within a parent matrix. See below
1285 void locateROI( Size& wholeSize, Point& ofs ) const;
1286 //! moves/resizes the current matrix ROI inside the parent matrix.
1287 UMat& adjustROI( int dtop, int dbottom, int dleft, int dright );
1288 //! extracts a rectangular sub-matrix
1289 // (this is a generalized form of row, rowRange etc.)
1290 UMat operator()( Range rowRange, Range colRange ) const;
1291 UMat operator()( const Rect& roi ) const;
1292 UMat operator()( const Range* ranges ) const;
1294 //! returns true iff the matrix data is continuous
1295 // (i.e. when there are no gaps between successive rows).
1296 // similar to CV_IS_MAT_CONT(cvmat->type)
1297 bool isContinuous() const;
1299 //! returns true if the matrix is a submatrix of another matrix
1300 bool isSubmatrix() const;
1302 //! returns element size in bytes,
1303 // similar to CV_ELEM_SIZE(cvmat->type)
1304 size_t elemSize() const;
1305 //! returns the size of element channel in bytes.
1306 size_t elemSize1() const;
1307 //! returns element type, similar to CV_MAT_TYPE(cvmat->type)
1309 //! returns element type, similar to CV_MAT_DEPTH(cvmat->type)
1311 //! returns element type, similar to CV_MAT_CN(cvmat->type)
1312 int channels() const;
1313 //! returns step/elemSize1()
1314 size_t step1(int i=0) const;
1315 //! returns true if matrix data is NULL
1317 //! returns the total number of matrix elements
1318 size_t total() const;
1320 //! returns N if the matrix is 1-channel (N x ptdim) or ptdim-channel (1 x N) or (N x 1); negative number otherwise
1321 int checkVector(int elemChannels, int depth=-1, bool requireContinuous=true) const;
1323 void* handle(int accessFlags) const;
1324 void ndoffset(size_t* ofs) const;
1326 enum { MAGIC_VAL = 0x42FF0000, AUTO_STEP = 0, CONTINUOUS_FLAG = CV_MAT_CONT_FLAG, SUBMATRIX_FLAG = CV_SUBMAT_FLAG };
1327 enum { MAGIC_MASK = 0xFFFF0000, TYPE_MASK = 0x00000FFF, DEPTH_MASK = 7 };
1329 /*! includes several bit-fields:
1330 - the magic signature
1333 - number of channels
1336 //! the matrix dimensionality, >= 2
1338 //! the number of rows and columns or (-1, -1) when the matrix has more than 2 dimensions
1341 //! custom allocator
1342 MatAllocator* allocator;
1343 UMatUsageFlags usageFlags; // usage flags for allocator
1344 //! and the standard allocator
1345 static MatAllocator* getStdAllocator();
1347 // black-box container of UMat data
1350 // offset of the submatrix (or 0)
1360 /////////////////////////// multi-dimensional sparse matrix //////////////////////////
1363 Sparse matrix class.
1365 The class represents multi-dimensional sparse numerical arrays. Such a sparse array can store elements
1366 of any type that cv::Mat is able to store. "Sparse" means that only non-zero elements
1367 are stored (though, as a result of some operations on a sparse matrix, some of its stored elements
1368 can actually become 0. It's user responsibility to detect such elements and delete them using cv::SparseMat::erase().
1369 The non-zero elements are stored in a hash table that grows when it's filled enough,
1370 so that the search time remains O(1) in average. Elements can be accessed using the following methods:
1373 <li>Query operations: cv::SparseMat::ptr() and the higher-level cv::SparseMat::ref(),
1374 cv::SparseMat::value() and cv::SparseMat::find, for example:
1377 int size[] = {10, 10, 10, 10, 10};
1378 SparseMat sparse_mat(dims, size, CV_32F);
1379 for(int i = 0; i < 1000; i++)
1382 for(int k = 0; k < dims; k++)
1383 idx[k] = rand()%sparse_mat.size(k);
1384 sparse_mat.ref<float>(idx) += 1.f;
1388 <li>Sparse matrix iterators. Like cv::Mat iterators and unlike cv::Mat iterators, the sparse matrix iterators are STL-style,
1389 that is, the iteration is done as following:
1391 // prints elements of a sparse floating-point matrix and the sum of elements.
1392 SparseMatConstIterator_<float>
1393 it = sparse_mat.begin<float>(),
1394 it_end = sparse_mat.end<float>();
1396 int dims = sparse_mat.dims();
1397 for(; it != it_end; ++it)
1399 // print element indices and the element value
1400 const Node* n = it.node();
1402 for(int i = 0; i < dims; i++)
1403 printf("%3d%c", n->idx[i], i < dims-1 ? ',' : ')');
1404 printf(": %f\n", *it);
1407 printf("Element sum is %g\n", s);
1409 If you run this loop, you will notice that elements are enumerated
1410 in no any logical order (lexicographical etc.),
1411 they come in the same order as they stored in the hash table, i.e. semi-randomly.
1413 You may collect pointers to the nodes and sort them to get the proper ordering.
1414 Note, however, that pointers to the nodes may become invalid when you add more
1415 elements to the matrix; this is because of possible buffer reallocation.
1417 <li>A combination of the above 2 methods when you need to process 2 or more sparse
1418 matrices simultaneously, e.g. this is how you can compute unnormalized
1419 cross-correlation of the 2 floating-point sparse matrices:
1421 double crossCorr(const SparseMat& a, const SparseMat& b)
1423 const SparseMat *_a = &a, *_b = &b;
1424 // if b contains less elements than a,
1425 // it's faster to iterate through b
1426 if(_a->nzcount() > _b->nzcount())
1428 SparseMatConstIterator_<float> it = _a->begin<float>(),
1429 it_end = _a->end<float>();
1431 for(; it != it_end; ++it)
1433 // take the next element from the first matrix
1435 const Node* anode = it.node();
1436 // and try to find element with the same index in the second matrix.
1437 // since the hash value depends only on the element index,
1438 // we reuse hashvalue stored in the node
1439 float bvalue = _b->value<float>(anode->idx,&anode->hashval);
1440 ccorr += avalue*bvalue;
1447 class CV_EXPORTS SparseMat
1450 typedef SparseMatIterator iterator;
1451 typedef SparseMatConstIterator const_iterator;
1453 enum { MAGIC_VAL=0x42FD0000, MAX_DIM=32, HASH_SCALE=0x5bd1e995, HASH_BIT=0x80000000 };
1455 //! the sparse matrix header
1456 struct CV_EXPORTS Hdr
1458 Hdr(int _dims, const int* _sizes, int _type);
1466 std::vector<uchar> pool;
1467 std::vector<size_t> hashtab;
1471 //! sparse matrix node - element of a hash table
1472 struct CV_EXPORTS Node
1476 //! index of the next node in the same hash table entry
1478 //! index of the matrix element
1482 //! default constructor
1484 //! creates matrix of the specified size and type
1485 SparseMat(int dims, const int* _sizes, int _type);
1486 //! copy constructor
1487 SparseMat(const SparseMat& m);
1488 //! converts dense 2d matrix to the sparse form
1490 \param m the input matrix
1492 explicit SparseMat(const Mat& m);
1493 //! converts old-style sparse matrix to the new-style. All the data is copied
1494 //SparseMat(const CvSparseMat* m);
1498 //! assignment operator. This is O(1) operation, i.e. no data is copied
1499 SparseMat& operator = (const SparseMat& m);
1500 //! equivalent to the corresponding constructor
1501 SparseMat& operator = (const Mat& m);
1503 //! creates full copy of the matrix
1504 SparseMat clone() const;
1506 //! copies all the data to the destination matrix. All the previous content of m is erased
1507 void copyTo( SparseMat& m ) const;
1508 //! converts sparse matrix to dense matrix.
1509 void copyTo( Mat& m ) const;
1510 //! multiplies all the matrix elements by the specified scale factor alpha and converts the results to the specified data type
1511 void convertTo( SparseMat& m, int rtype, double alpha=1 ) const;
1512 //! converts sparse matrix to dense n-dim matrix with optional type conversion and scaling.
1514 @param [out] m - output matrix; if it does not have a proper size or type before the operation,
1516 @param [in] rtype – desired output matrix type or, rather, the depth since the number of channels
1517 are the same as the input has; if rtype is negative, the output matrix will have the
1518 same type as the input.
1519 @param [in] alpha – optional scale factor
1520 @param [in] beta – optional delta added to the scaled values
1522 void convertTo( Mat& m, int rtype, double alpha=1, double beta=0 ) const;
1525 void assignTo( SparseMat& m, int type=-1 ) const;
1527 //! reallocates sparse matrix.
1529 If the matrix already had the proper size and type,
1530 it is simply cleared with clear(), otherwise,
1531 the old matrix is released (using release()) and the new one is allocated.
1533 void create(int dims, const int* _sizes, int _type);
1534 //! sets all the sparse matrix elements to 0, which means clearing the hash table.
1536 //! manually increments the reference counter to the header.
1538 // decrements the header reference counter. When the counter reaches 0, the header and all the underlying data are deallocated.
1541 //! converts sparse matrix to the old-style representation; all the elements are copied.
1542 //operator CvSparseMat*() const;
1543 //! returns the size of each element in bytes (not including the overhead - the space occupied by SparseMat::Node elements)
1544 size_t elemSize() const;
1545 //! returns elemSize()/channels()
1546 size_t elemSize1() const;
1548 //! returns type of sparse matrix elements
1550 //! returns the depth of sparse matrix elements
1552 //! returns the number of channels
1553 int channels() const;
1555 //! returns the array of sizes, or NULL if the matrix is not allocated
1556 const int* size() const;
1557 //! returns the size of i-th matrix dimension (or 0)
1558 int size(int i) const;
1559 //! returns the matrix dimensionality
1561 //! returns the number of non-zero elements (=the number of hash table nodes)
1562 size_t nzcount() const;
1564 //! computes the element hash value (1D case)
1565 size_t hash(int i0) const;
1566 //! computes the element hash value (2D case)
1567 size_t hash(int i0, int i1) const;
1568 //! computes the element hash value (3D case)
1569 size_t hash(int i0, int i1, int i2) const;
1570 //! computes the element hash value (nD case)
1571 size_t hash(const int* idx) const;
1575 specialized variants for 1D, 2D, 3D cases and the generic_type one for n-D case.
1577 return pointer to the matrix element.
1579 <li>if the element is there (it's non-zero), the pointer to it is returned
1580 <li>if it's not there and createMissing=false, NULL pointer is returned
1581 <li>if it's not there and createMissing=true, then the new element
1582 is created and initialized with 0. Pointer to it is returned
1583 <li>if the optional hashval pointer is not NULL, the element hash value is
1584 not computed, but *hashval is taken instead.
1587 //! returns pointer to the specified element (1D case)
1588 uchar* ptr(int i0, bool createMissing, size_t* hashval=0);
1589 //! returns pointer to the specified element (2D case)
1590 uchar* ptr(int i0, int i1, bool createMissing, size_t* hashval=0);
1591 //! returns pointer to the specified element (3D case)
1592 uchar* ptr(int i0, int i1, int i2, bool createMissing, size_t* hashval=0);
1593 //! returns pointer to the specified element (nD case)
1594 uchar* ptr(const int* idx, bool createMissing, size_t* hashval=0);
1599 return read-write reference to the specified sparse matrix element.
1601 ref<_Tp>(i0,...[,hashval]) is equivalent to *(_Tp*)ptr(i0,...,true[,hashval]).
1602 The methods always return a valid reference.
1603 If the element did not exist, it is created and initialiazed with 0.
1605 //! returns reference to the specified element (1D case)
1606 template<typename _Tp> _Tp& ref(int i0, size_t* hashval=0);
1607 //! returns reference to the specified element (2D case)
1608 template<typename _Tp> _Tp& ref(int i0, int i1, size_t* hashval=0);
1609 //! returns reference to the specified element (3D case)
1610 template<typename _Tp> _Tp& ref(int i0, int i1, int i2, size_t* hashval=0);
1611 //! returns reference to the specified element (nD case)
1612 template<typename _Tp> _Tp& ref(const int* idx, size_t* hashval=0);
1617 return value of the specified sparse matrix element.
1619 value<_Tp>(i0,...[,hashval]) is equivalent
1622 { const _Tp* p = find<_Tp>(i0,...[,hashval]); return p ? *p : _Tp(); }
1625 That is, if the element did not exist, the methods return 0.
1627 //! returns value of the specified element (1D case)
1628 template<typename _Tp> _Tp value(int i0, size_t* hashval=0) const;
1629 //! returns value of the specified element (2D case)
1630 template<typename _Tp> _Tp value(int i0, int i1, size_t* hashval=0) const;
1631 //! returns value of the specified element (3D case)
1632 template<typename _Tp> _Tp value(int i0, int i1, int i2, size_t* hashval=0) const;
1633 //! returns value of the specified element (nD case)
1634 template<typename _Tp> _Tp value(const int* idx, size_t* hashval=0) const;
1639 Return pointer to the specified sparse matrix element if it exists
1641 find<_Tp>(i0,...[,hashval]) is equivalent to (_const Tp*)ptr(i0,...false[,hashval]).
1643 If the specified element does not exist, the methods return NULL.
1645 //! returns pointer to the specified element (1D case)
1646 template<typename _Tp> const _Tp* find(int i0, size_t* hashval=0) const;
1647 //! returns pointer to the specified element (2D case)
1648 template<typename _Tp> const _Tp* find(int i0, int i1, size_t* hashval=0) const;
1649 //! returns pointer to the specified element (3D case)
1650 template<typename _Tp> const _Tp* find(int i0, int i1, int i2, size_t* hashval=0) const;
1651 //! returns pointer to the specified element (nD case)
1652 template<typename _Tp> const _Tp* find(const int* idx, size_t* hashval=0) const;
1654 //! erases the specified element (2D case)
1655 void erase(int i0, int i1, size_t* hashval=0);
1656 //! erases the specified element (3D case)
1657 void erase(int i0, int i1, int i2, size_t* hashval=0);
1658 //! erases the specified element (nD case)
1659 void erase(const int* idx, size_t* hashval=0);
1663 return the sparse matrix iterator pointing to the first sparse matrix element
1665 //! returns the sparse matrix iterator at the matrix beginning
1666 SparseMatIterator begin();
1667 //! returns the sparse matrix iterator at the matrix beginning
1668 template<typename _Tp> SparseMatIterator_<_Tp> begin();
1669 //! returns the read-only sparse matrix iterator at the matrix beginning
1670 SparseMatConstIterator begin() const;
1671 //! returns the read-only sparse matrix iterator at the matrix beginning
1672 template<typename _Tp> SparseMatConstIterator_<_Tp> begin() const;
1675 return the sparse matrix iterator pointing to the element following the last sparse matrix element
1677 //! returns the sparse matrix iterator at the matrix end
1678 SparseMatIterator end();
1679 //! returns the read-only sparse matrix iterator at the matrix end
1680 SparseMatConstIterator end() const;
1681 //! returns the typed sparse matrix iterator at the matrix end
1682 template<typename _Tp> SparseMatIterator_<_Tp> end();
1683 //! returns the typed read-only sparse matrix iterator at the matrix end
1684 template<typename _Tp> SparseMatConstIterator_<_Tp> end() const;
1686 //! returns the value stored in the sparse martix node
1687 template<typename _Tp> _Tp& value(Node* n);
1688 //! returns the value stored in the sparse martix node
1689 template<typename _Tp> const _Tp& value(const Node* n) const;
1691 ////////////// some internal-use methods ///////////////
1692 Node* node(size_t nidx);
1693 const Node* node(size_t nidx) const;
1695 uchar* newNode(const int* idx, size_t hashval);
1696 void removeNode(size_t hidx, size_t nidx, size_t previdx);
1697 void resizeHashTab(size_t newsize);
1705 ///////////////////////////////// SparseMat_<_Tp> ////////////////////////////////////
1708 The Template Sparse Matrix class derived from cv::SparseMat
1710 The class provides slightly more convenient operations for accessing elements.
1715 SparseMat_<int> m_ = (SparseMat_<int>&)m;
1716 m_.ref(1)++; // equivalent to m.ref<int>(1)++;
1717 m_.ref(2) += m_(3); // equivalent to m.ref<int>(2) += m.value<int>(3);
1720 template<typename _Tp> class SparseMat_ : public SparseMat
1723 typedef SparseMatIterator_<_Tp> iterator;
1724 typedef SparseMatConstIterator_<_Tp> const_iterator;
1726 //! the default constructor
1728 //! the full constructor equivelent to SparseMat(dims, _sizes, DataType<_Tp>::type)
1729 SparseMat_(int dims, const int* _sizes);
1730 //! the copy constructor. If DataType<_Tp>.type != m.type(), the m elements are converted
1731 SparseMat_(const SparseMat& m);
1732 //! the copy constructor. This is O(1) operation - no data is copied
1733 SparseMat_(const SparseMat_& m);
1734 //! converts dense matrix to the sparse form
1735 SparseMat_(const Mat& m);
1736 //! converts the old-style sparse matrix to the C++ class. All the elements are copied
1737 //SparseMat_(const CvSparseMat* m);
1738 //! the assignment operator. If DataType<_Tp>.type != m.type(), the m elements are converted
1739 SparseMat_& operator = (const SparseMat& m);
1740 //! the assignment operator. This is O(1) operation - no data is copied
1741 SparseMat_& operator = (const SparseMat_& m);
1742 //! converts dense matrix to the sparse form
1743 SparseMat_& operator = (const Mat& m);
1745 //! makes full copy of the matrix. All the elements are duplicated
1746 SparseMat_ clone() const;
1747 //! equivalent to cv::SparseMat::create(dims, _sizes, DataType<_Tp>::type)
1748 void create(int dims, const int* _sizes);
1749 //! converts sparse matrix to the old-style CvSparseMat. All the elements are copied
1750 //operator CvSparseMat*() const;
1752 //! returns type of the matrix elements
1754 //! returns depth of the matrix elements
1756 //! returns the number of channels in each matrix element
1757 int channels() const;
1759 //! equivalent to SparseMat::ref<_Tp>(i0, hashval)
1760 _Tp& ref(int i0, size_t* hashval=0);
1761 //! equivalent to SparseMat::ref<_Tp>(i0, i1, hashval)
1762 _Tp& ref(int i0, int i1, size_t* hashval=0);
1763 //! equivalent to SparseMat::ref<_Tp>(i0, i1, i2, hashval)
1764 _Tp& ref(int i0, int i1, int i2, size_t* hashval=0);
1765 //! equivalent to SparseMat::ref<_Tp>(idx, hashval)
1766 _Tp& ref(const int* idx, size_t* hashval=0);
1768 //! equivalent to SparseMat::value<_Tp>(i0, hashval)
1769 _Tp operator()(int i0, size_t* hashval=0) const;
1770 //! equivalent to SparseMat::value<_Tp>(i0, i1, hashval)
1771 _Tp operator()(int i0, int i1, size_t* hashval=0) const;
1772 //! equivalent to SparseMat::value<_Tp>(i0, i1, i2, hashval)
1773 _Tp operator()(int i0, int i1, int i2, size_t* hashval=0) const;
1774 //! equivalent to SparseMat::value<_Tp>(idx, hashval)
1775 _Tp operator()(const int* idx, size_t* hashval=0) const;
1777 //! returns sparse matrix iterator pointing to the first sparse matrix element
1778 SparseMatIterator_<_Tp> begin();
1779 //! returns read-only sparse matrix iterator pointing to the first sparse matrix element
1780 SparseMatConstIterator_<_Tp> begin() const;
1781 //! returns sparse matrix iterator pointing to the element following the last sparse matrix element
1782 SparseMatIterator_<_Tp> end();
1783 //! returns read-only sparse matrix iterator pointing to the element following the last sparse matrix element
1784 SparseMatConstIterator_<_Tp> end() const;
1789 ////////////////////////////////// MatConstIterator //////////////////////////////////
1791 class CV_EXPORTS MatConstIterator
1794 typedef uchar* value_type;
1795 typedef ptrdiff_t difference_type;
1796 typedef const uchar** pointer;
1797 typedef uchar* reference;
1799 #ifndef OPENCV_NOSTL
1800 typedef std::random_access_iterator_tag iterator_category;
1803 //! default constructor
1805 //! constructor that sets the iterator to the beginning of the matrix
1806 MatConstIterator(const Mat* _m);
1807 //! constructor that sets the iterator to the specified element of the matrix
1808 MatConstIterator(const Mat* _m, int _row, int _col=0);
1809 //! constructor that sets the iterator to the specified element of the matrix
1810 MatConstIterator(const Mat* _m, Point _pt);
1811 //! constructor that sets the iterator to the specified element of the matrix
1812 MatConstIterator(const Mat* _m, const int* _idx);
1813 //! copy constructor
1814 MatConstIterator(const MatConstIterator& it);
1817 MatConstIterator& operator = (const MatConstIterator& it);
1818 //! returns the current matrix element
1819 const uchar* operator *() const;
1820 //! returns the i-th matrix element, relative to the current
1821 const uchar* operator [](ptrdiff_t i) const;
1823 //! shifts the iterator forward by the specified number of elements
1824 MatConstIterator& operator += (ptrdiff_t ofs);
1825 //! shifts the iterator backward by the specified number of elements
1826 MatConstIterator& operator -= (ptrdiff_t ofs);
1827 //! decrements the iterator
1828 MatConstIterator& operator --();
1829 //! decrements the iterator
1830 MatConstIterator operator --(int);
1831 //! increments the iterator
1832 MatConstIterator& operator ++();
1833 //! increments the iterator
1834 MatConstIterator operator ++(int);
1835 //! returns the current iterator position
1837 //! returns the current iterator position
1838 void pos(int* _idx) const;
1840 ptrdiff_t lpos() const;
1841 void seek(ptrdiff_t ofs, bool relative = false);
1842 void seek(const int* _idx, bool relative = false);
1847 const uchar* sliceStart;
1848 const uchar* sliceEnd;
1853 ////////////////////////////////// MatConstIterator_ /////////////////////////////////
1856 Matrix read-only iterator
1858 template<typename _Tp>
1859 class MatConstIterator_ : public MatConstIterator
1862 typedef _Tp value_type;
1863 typedef ptrdiff_t difference_type;
1864 typedef const _Tp* pointer;
1865 typedef const _Tp& reference;
1867 #ifndef OPENCV_NOSTL
1868 typedef std::random_access_iterator_tag iterator_category;
1871 //! default constructor
1872 MatConstIterator_();
1873 //! constructor that sets the iterator to the beginning of the matrix
1874 MatConstIterator_(const Mat_<_Tp>* _m);
1875 //! constructor that sets the iterator to the specified element of the matrix
1876 MatConstIterator_(const Mat_<_Tp>* _m, int _row, int _col=0);
1877 //! constructor that sets the iterator to the specified element of the matrix
1878 MatConstIterator_(const Mat_<_Tp>* _m, Point _pt);
1879 //! constructor that sets the iterator to the specified element of the matrix
1880 MatConstIterator_(const Mat_<_Tp>* _m, const int* _idx);
1881 //! copy constructor
1882 MatConstIterator_(const MatConstIterator_& it);
1885 MatConstIterator_& operator = (const MatConstIterator_& it);
1886 //! returns the current matrix element
1887 _Tp operator *() const;
1888 //! returns the i-th matrix element, relative to the current
1889 _Tp operator [](ptrdiff_t i) const;
1891 //! shifts the iterator forward by the specified number of elements
1892 MatConstIterator_& operator += (ptrdiff_t ofs);
1893 //! shifts the iterator backward by the specified number of elements
1894 MatConstIterator_& operator -= (ptrdiff_t ofs);
1895 //! decrements the iterator
1896 MatConstIterator_& operator --();
1897 //! decrements the iterator
1898 MatConstIterator_ operator --(int);
1899 //! increments the iterator
1900 MatConstIterator_& operator ++();
1901 //! increments the iterator
1902 MatConstIterator_ operator ++(int);
1903 //! returns the current iterator position
1909 //////////////////////////////////// MatIterator_ ////////////////////////////////////
1912 Matrix read-write iterator
1914 template<typename _Tp>
1915 class MatIterator_ : public MatConstIterator_<_Tp>
1918 typedef _Tp* pointer;
1919 typedef _Tp& reference;
1921 #ifndef OPENCV_NOSTL
1922 typedef std::random_access_iterator_tag iterator_category;
1925 //! the default constructor
1927 //! constructor that sets the iterator to the beginning of the matrix
1928 MatIterator_(Mat_<_Tp>* _m);
1929 //! constructor that sets the iterator to the specified element of the matrix
1930 MatIterator_(Mat_<_Tp>* _m, int _row, int _col=0);
1931 //! constructor that sets the iterator to the specified element of the matrix
1932 MatIterator_(Mat_<_Tp>* _m, Point _pt);
1933 //! constructor that sets the iterator to the specified element of the matrix
1934 MatIterator_(Mat_<_Tp>* _m, const int* _idx);
1935 //! copy constructor
1936 MatIterator_(const MatIterator_& it);
1938 MatIterator_& operator = (const MatIterator_<_Tp>& it );
1940 //! returns the current matrix element
1941 _Tp& operator *() const;
1942 //! returns the i-th matrix element, relative to the current
1943 _Tp& operator [](ptrdiff_t i) const;
1945 //! shifts the iterator forward by the specified number of elements
1946 MatIterator_& operator += (ptrdiff_t ofs);
1947 //! shifts the iterator backward by the specified number of elements
1948 MatIterator_& operator -= (ptrdiff_t ofs);
1949 //! decrements the iterator
1950 MatIterator_& operator --();
1951 //! decrements the iterator
1952 MatIterator_ operator --(int);
1953 //! increments the iterator
1954 MatIterator_& operator ++();
1955 //! increments the iterator
1956 MatIterator_ operator ++(int);
1961 /////////////////////////////// SparseMatConstIterator ///////////////////////////////
1964 Read-Only Sparse Matrix Iterator.
1965 Here is how to use the iterator to compute the sum of floating-point sparse matrix elements:
1968 SparseMatConstIterator it = m.begin(), it_end = m.end();
1970 CV_Assert( m.type() == CV_32F );
1971 for( ; it != it_end; ++it )
1972 s += it.value<float>();
1975 class CV_EXPORTS SparseMatConstIterator
1978 //! the default constructor
1979 SparseMatConstIterator();
1980 //! the full constructor setting the iterator to the first sparse matrix element
1981 SparseMatConstIterator(const SparseMat* _m);
1982 //! the copy constructor
1983 SparseMatConstIterator(const SparseMatConstIterator& it);
1985 //! the assignment operator
1986 SparseMatConstIterator& operator = (const SparseMatConstIterator& it);
1988 //! template method returning the current matrix element
1989 template<typename _Tp> const _Tp& value() const;
1990 //! returns the current node of the sparse matrix. it.node->idx is the current element index
1991 const SparseMat::Node* node() const;
1993 //! moves iterator to the previous element
1994 SparseMatConstIterator& operator --();
1995 //! moves iterator to the previous element
1996 SparseMatConstIterator operator --(int);
1997 //! moves iterator to the next element
1998 SparseMatConstIterator& operator ++();
1999 //! moves iterator to the next element
2000 SparseMatConstIterator operator ++(int);
2002 //! moves iterator to the element after the last element
2012 ////////////////////////////////// SparseMatIterator /////////////////////////////////
2015 Read-write Sparse Matrix Iterator
2017 The class is similar to cv::SparseMatConstIterator,
2018 but can be used for in-place modification of the matrix elements.
2020 class CV_EXPORTS SparseMatIterator : public SparseMatConstIterator
2023 //! the default constructor
2024 SparseMatIterator();
2025 //! the full constructor setting the iterator to the first sparse matrix element
2026 SparseMatIterator(SparseMat* _m);
2027 //! the full constructor setting the iterator to the specified sparse matrix element
2028 SparseMatIterator(SparseMat* _m, const int* idx);
2029 //! the copy constructor
2030 SparseMatIterator(const SparseMatIterator& it);
2032 //! the assignment operator
2033 SparseMatIterator& operator = (const SparseMatIterator& it);
2034 //! returns read-write reference to the current sparse matrix element
2035 template<typename _Tp> _Tp& value() const;
2036 //! returns pointer to the current sparse matrix node. it.node->idx is the index of the current element (do not modify it!)
2037 SparseMat::Node* node() const;
2039 //! moves iterator to the next element
2040 SparseMatIterator& operator ++();
2041 //! moves iterator to the next element
2042 SparseMatIterator operator ++(int);
2047 /////////////////////////////// SparseMatConstIterator_ //////////////////////////////
2050 Template Read-Only Sparse Matrix Iterator Class.
2052 This is the derived from SparseMatConstIterator class that
2053 introduces more convenient operator *() for accessing the current element.
2055 template<typename _Tp> class SparseMatConstIterator_ : public SparseMatConstIterator
2059 #ifndef OPENCV_NOSTL
2060 typedef std::forward_iterator_tag iterator_category;
2063 //! the default constructor
2064 SparseMatConstIterator_();
2065 //! the full constructor setting the iterator to the first sparse matrix element
2066 SparseMatConstIterator_(const SparseMat_<_Tp>* _m);
2067 SparseMatConstIterator_(const SparseMat* _m);
2068 //! the copy constructor
2069 SparseMatConstIterator_(const SparseMatConstIterator_& it);
2071 //! the assignment operator
2072 SparseMatConstIterator_& operator = (const SparseMatConstIterator_& it);
2073 //! the element access operator
2074 const _Tp& operator *() const;
2076 //! moves iterator to the next element
2077 SparseMatConstIterator_& operator ++();
2078 //! moves iterator to the next element
2079 SparseMatConstIterator_ operator ++(int);
2084 ///////////////////////////////// SparseMatIterator_ /////////////////////////////////
2087 Template Read-Write Sparse Matrix Iterator Class.
2089 This is the derived from cv::SparseMatConstIterator_ class that
2090 introduces more convenient operator *() for accessing the current element.
2092 template<typename _Tp> class SparseMatIterator_ : public SparseMatConstIterator_<_Tp>
2096 #ifndef OPENCV_NOSTL
2097 typedef std::forward_iterator_tag iterator_category;
2100 //! the default constructor
2101 SparseMatIterator_();
2102 //! the full constructor setting the iterator to the first sparse matrix element
2103 SparseMatIterator_(SparseMat_<_Tp>* _m);
2104 SparseMatIterator_(SparseMat* _m);
2105 //! the copy constructor
2106 SparseMatIterator_(const SparseMatIterator_& it);
2108 //! the assignment operator
2109 SparseMatIterator_& operator = (const SparseMatIterator_& it);
2110 //! returns the reference to the current element
2111 _Tp& operator *() const;
2113 //! moves the iterator to the next element
2114 SparseMatIterator_& operator ++();
2115 //! moves the iterator to the next element
2116 SparseMatIterator_ operator ++(int);
2121 /////////////////////////////////// NAryMatIterator //////////////////////////////////
2124 n-Dimensional Dense Matrix Iterator Class.
2126 The class cv::NAryMatIterator is used for iterating over one or more n-dimensional dense arrays (cv::Mat's).
2128 The iterator is completely different from cv::Mat_ and cv::SparseMat_ iterators.
2129 It iterates through the slices (or planes), not the elements, where "slice" is a continuous part of the arrays.
2131 Here is the example on how the iterator can be used to normalize 3D histogram:
2134 void normalizeColorHist(Mat& hist)
2137 // intialize iterator (the style is different from STL).
2138 // after initialization the iterator will contain
2139 // the number of slices or planes
2140 // the iterator will go through
2141 Mat* arrays[] = { &hist, 0 };
2143 NAryMatIterator it(arrays, planes);
2145 // iterate through the matrix. on each iteration
2146 // it.planes[i] (of type Mat) will be set to the current plane of
2147 // i-th n-dim matrix passed to the iterator constructor.
2148 for(int p = 0; p < it.nplanes; p++, ++it)
2149 s += sum(it.planes[0])[0];
2150 it = NAryMatIterator(hist);
2152 for(int p = 0; p < it.nplanes; p++, ++it)
2155 // this is a shorter implementation of the above
2156 // using built-in operations on Mat
2157 double s = sum(hist)[0];
2158 hist.convertTo(hist, hist.type(), 1./s, 0);
2160 // and this is even shorter one
2161 // (assuming that the histogram elements are non-negative)
2162 normalize(hist, hist, 1, 0, NORM_L1);
2167 You can iterate through several matrices simultaneously as long as they have the same geometry
2168 (dimensionality and all the dimension sizes are the same), which is useful for binary
2169 and n-ary operations on such matrices. Just pass those matrices to cv::MatNDIterator.
2170 Then, during the iteration it.planes[0], it.planes[1], ... will
2171 be the slices of the corresponding matrices
2173 class CV_EXPORTS NAryMatIterator
2176 //! the default constructor
2178 //! the full constructor taking arbitrary number of n-dim matrices
2179 NAryMatIterator(const Mat** arrays, uchar** ptrs, int narrays=-1);
2180 //! the full constructor taking arbitrary number of n-dim matrices
2181 NAryMatIterator(const Mat** arrays, Mat* planes, int narrays=-1);
2182 //! the separate iterator initialization method
2183 void init(const Mat** arrays, Mat* planes, uchar** ptrs, int narrays=-1);
2185 //! proceeds to the next plane of every iterated matrix
2186 NAryMatIterator& operator ++();
2187 //! proceeds to the next plane of every iterated matrix (postfix increment operator)
2188 NAryMatIterator operator ++(int);
2190 //! the iterated arrays
2192 //! the current planes
2196 //! the number of arrays
2198 //! the number of hyper-planes that the iterator steps through
2200 //! the size of each segment (in elements)
2209 ///////////////////////////////// Matrix Expressions /////////////////////////////////
2211 class CV_EXPORTS MatOp
2217 virtual bool elementWise(const MatExpr& expr) const;
2218 virtual void assign(const MatExpr& expr, Mat& m, int type=-1) const = 0;
2219 virtual void roi(const MatExpr& expr, const Range& rowRange,
2220 const Range& colRange, MatExpr& res) const;
2221 virtual void diag(const MatExpr& expr, int d, MatExpr& res) const;
2222 virtual void augAssignAdd(const MatExpr& expr, Mat& m) const;
2223 virtual void augAssignSubtract(const MatExpr& expr, Mat& m) const;
2224 virtual void augAssignMultiply(const MatExpr& expr, Mat& m) const;
2225 virtual void augAssignDivide(const MatExpr& expr, Mat& m) const;
2226 virtual void augAssignAnd(const MatExpr& expr, Mat& m) const;
2227 virtual void augAssignOr(const MatExpr& expr, Mat& m) const;
2228 virtual void augAssignXor(const MatExpr& expr, Mat& m) const;
2230 virtual void add(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
2231 virtual void add(const MatExpr& expr1, const Scalar& s, MatExpr& res) const;
2233 virtual void subtract(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
2234 virtual void subtract(const Scalar& s, const MatExpr& expr, MatExpr& res) const;
2236 virtual void multiply(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res, double scale=1) const;
2237 virtual void multiply(const MatExpr& expr1, double s, MatExpr& res) const;
2239 virtual void divide(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res, double scale=1) const;
2240 virtual void divide(double s, const MatExpr& expr, MatExpr& res) const;
2242 virtual void abs(const MatExpr& expr, MatExpr& res) const;
2244 virtual void transpose(const MatExpr& expr, MatExpr& res) const;
2245 virtual void matmul(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
2246 virtual void invert(const MatExpr& expr, int method, MatExpr& res) const;
2248 virtual Size size(const MatExpr& expr) const;
2249 virtual int type(const MatExpr& expr) const;
2253 class CV_EXPORTS MatExpr
2257 explicit MatExpr(const Mat& m);
2259 MatExpr(const MatOp* _op, int _flags, const Mat& _a = Mat(), const Mat& _b = Mat(),
2260 const Mat& _c = Mat(), double _alpha = 1, double _beta = 1, const Scalar& _s = Scalar());
2262 operator Mat() const;
2263 template<typename _Tp> operator Mat_<_Tp>() const;
2268 MatExpr row(int y) const;
2269 MatExpr col(int x) const;
2270 MatExpr diag(int d = 0) const;
2271 MatExpr operator()( const Range& rowRange, const Range& colRange ) const;
2272 MatExpr operator()( const Rect& roi ) const;
2275 MatExpr inv(int method = DECOMP_LU) const;
2276 MatExpr mul(const MatExpr& e, double scale=1) const;
2277 MatExpr mul(const Mat& m, double scale=1) const;
2279 Mat cross(const Mat& m) const;
2280 double dot(const Mat& m) const;
2291 CV_EXPORTS MatExpr operator + (const Mat& a, const Mat& b);
2292 CV_EXPORTS MatExpr operator + (const Mat& a, const Scalar& s);
2293 CV_EXPORTS MatExpr operator + (const Scalar& s, const Mat& a);
2294 CV_EXPORTS MatExpr operator + (const MatExpr& e, const Mat& m);
2295 CV_EXPORTS MatExpr operator + (const Mat& m, const MatExpr& e);
2296 CV_EXPORTS MatExpr operator + (const MatExpr& e, const Scalar& s);
2297 CV_EXPORTS MatExpr operator + (const Scalar& s, const MatExpr& e);
2298 CV_EXPORTS MatExpr operator + (const MatExpr& e1, const MatExpr& e2);
2300 CV_EXPORTS MatExpr operator - (const Mat& a, const Mat& b);
2301 CV_EXPORTS MatExpr operator - (const Mat& a, const Scalar& s);
2302 CV_EXPORTS MatExpr operator - (const Scalar& s, const Mat& a);
2303 CV_EXPORTS MatExpr operator - (const MatExpr& e, const Mat& m);
2304 CV_EXPORTS MatExpr operator - (const Mat& m, const MatExpr& e);
2305 CV_EXPORTS MatExpr operator - (const MatExpr& e, const Scalar& s);
2306 CV_EXPORTS MatExpr operator - (const Scalar& s, const MatExpr& e);
2307 CV_EXPORTS MatExpr operator - (const MatExpr& e1, const MatExpr& e2);
2309 CV_EXPORTS MatExpr operator - (const Mat& m);
2310 CV_EXPORTS MatExpr operator - (const MatExpr& e);
2312 CV_EXPORTS MatExpr operator * (const Mat& a, const Mat& b);
2313 CV_EXPORTS MatExpr operator * (const Mat& a, double s);
2314 CV_EXPORTS MatExpr operator * (double s, const Mat& a);
2315 CV_EXPORTS MatExpr operator * (const MatExpr& e, const Mat& m);
2316 CV_EXPORTS MatExpr operator * (const Mat& m, const MatExpr& e);
2317 CV_EXPORTS MatExpr operator * (const MatExpr& e, double s);
2318 CV_EXPORTS MatExpr operator * (double s, const MatExpr& e);
2319 CV_EXPORTS MatExpr operator * (const MatExpr& e1, const MatExpr& e2);
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 CV_EXPORTS MatExpr operator / (const MatExpr& e, const Mat& m);
2325 CV_EXPORTS MatExpr operator / (const Mat& m, const MatExpr& e);
2326 CV_EXPORTS MatExpr operator / (const MatExpr& e, double s);
2327 CV_EXPORTS MatExpr operator / (double s, const MatExpr& e);
2328 CV_EXPORTS MatExpr operator / (const MatExpr& e1, const MatExpr& e2);
2330 CV_EXPORTS MatExpr operator < (const Mat& a, const Mat& b);
2331 CV_EXPORTS MatExpr operator < (const Mat& a, double s);
2332 CV_EXPORTS MatExpr operator < (double s, const Mat& a);
2334 CV_EXPORTS MatExpr operator <= (const Mat& a, const Mat& b);
2335 CV_EXPORTS MatExpr operator <= (const Mat& a, double s);
2336 CV_EXPORTS MatExpr operator <= (double s, const Mat& a);
2338 CV_EXPORTS MatExpr operator == (const Mat& a, const Mat& b);
2339 CV_EXPORTS MatExpr operator == (const Mat& a, double s);
2340 CV_EXPORTS MatExpr operator == (double s, const Mat& a);
2342 CV_EXPORTS MatExpr operator != (const Mat& a, const Mat& b);
2343 CV_EXPORTS MatExpr operator != (const Mat& a, double s);
2344 CV_EXPORTS MatExpr operator != (double s, const Mat& a);
2346 CV_EXPORTS MatExpr operator >= (const Mat& a, const Mat& b);
2347 CV_EXPORTS MatExpr operator >= (const Mat& a, double s);
2348 CV_EXPORTS MatExpr operator >= (double s, const Mat& a);
2350 CV_EXPORTS MatExpr operator > (const Mat& a, const Mat& b);
2351 CV_EXPORTS MatExpr operator > (const Mat& a, double s);
2352 CV_EXPORTS MatExpr operator > (double s, const Mat& a);
2354 CV_EXPORTS MatExpr operator & (const Mat& a, const Mat& b);
2355 CV_EXPORTS MatExpr operator & (const Mat& a, const Scalar& s);
2356 CV_EXPORTS MatExpr operator & (const Scalar& s, const Mat& a);
2358 CV_EXPORTS MatExpr operator | (const Mat& a, const Mat& b);
2359 CV_EXPORTS MatExpr operator | (const Mat& a, const Scalar& s);
2360 CV_EXPORTS MatExpr operator | (const Scalar& s, const Mat& a);
2362 CV_EXPORTS MatExpr operator ^ (const Mat& a, const Mat& b);
2363 CV_EXPORTS MatExpr operator ^ (const Mat& a, const Scalar& s);
2364 CV_EXPORTS MatExpr operator ^ (const Scalar& s, const Mat& a);
2366 CV_EXPORTS MatExpr operator ~(const Mat& m);
2368 CV_EXPORTS MatExpr min(const Mat& a, const Mat& b);
2369 CV_EXPORTS MatExpr min(const Mat& a, double s);
2370 CV_EXPORTS MatExpr min(double s, const Mat& a);
2372 CV_EXPORTS MatExpr max(const Mat& a, const Mat& b);
2373 CV_EXPORTS MatExpr max(const Mat& a, double s);
2374 CV_EXPORTS MatExpr max(double s, const Mat& a);
2376 CV_EXPORTS MatExpr abs(const Mat& m);
2377 CV_EXPORTS MatExpr abs(const MatExpr& e);
2381 #include "opencv2/core/mat.inl.hpp"
2383 #endif // __OPENCV_CORE_MAT_HPP__