|
| | Mat () |
| | default constructor More...
|
| |
| | Mat (int rows, int cols, int type) |
| | constructs 2D matrix of the specified size and type More...
|
| |
| | Mat (Size size, int type) |
| |
| | Mat (int rows, int cols, int type, const Scalar &s) |
| | constucts 2D matrix and fills it with the specified value _s. More...
|
| |
| | Mat (Size size, int type, const Scalar &s) |
| |
| | Mat (int ndims, const int *sizes, int type) |
| | constructs n-dimensional matrix More...
|
| |
| | Mat (int ndims, const int *sizes, int type, const Scalar &s) |
| |
| | Mat (const Mat &m) |
| | copy constructor More...
|
| |
| | Mat (int rows, int cols, int type, void *data, size_t step=AUTO_STEP) |
| | constructor for matrix headers pointing to user-allocated data More...
|
| |
| | Mat (Size size, int type, void *data, size_t step=AUTO_STEP) |
| |
| | Mat (int ndims, const int *sizes, int type, void *data, const size_t *steps=0) |
| |
| | Mat (const Mat &m, const Range &rowRange, const Range &colRange=Range::all()) |
| | creates a matrix header for a part of the bigger matrix More...
|
| |
| | Mat (const Mat &m, const Rect &roi) |
| |
| | Mat (const Mat &m, const Range *ranges) |
| |
| | Mat (const CvMat *m, bool copyData=false) |
| | converts old-style CvMat to the new matrix; the data is not copied by default More...
|
| |
| | Mat (const CvMatND *m, bool copyData=false) |
| | converts old-style CvMatND to the new matrix; the data is not copied by default More...
|
| |
| | Mat (const IplImage *img, bool copyData=false) |
| | converts old-style IplImage to the new matrix; the data is not copied by default More...
|
| |
| template<typename _Tp > |
| | Mat (const vector< _Tp > &vec, bool copyData=false) |
| | builds matrix from std::vector with or without copying the data More...
|
| |
| template<typename _Tp , int n> |
| | Mat (const Vec< _Tp, n > &vec, bool copyData=true) |
| | builds matrix from cv::Vec; the data is copied by default More...
|
| |
| template<typename _Tp , int m, int n> |
| | Mat (const Matx< _Tp, m, n > &mtx, bool copyData=true) |
| | builds matrix from cv::Matx; the data is copied by default More...
|
| |
| template<typename _Tp > |
| | Mat (const Point_< _Tp > &pt, bool copyData=true) |
| | builds matrix from a 2D point More...
|
| |
| template<typename _Tp > |
| | Mat (const Point3_< _Tp > &pt, bool copyData=true) |
| | builds matrix from a 3D point More...
|
| |
| template<typename _Tp > |
| | Mat (const MatCommaInitializer_< _Tp > &commaInitializer) |
| | builds matrix from comma initializer More...
|
| |
| | Mat (const gpu::GpuMat &m) |
| | download data from GpuMat More...
|
| |
| | ~Mat () |
| | destructor - calls release() More...
|
| |
| Mat & | operator= (const Mat &m) |
| | assignment operators More...
|
| |
| Mat & | operator= (const MatExpr &expr) |
| |
| Mat | row (int y) const |
| | returns a new matrix header for the specified row More...
|
| |
| Mat | col (int x) const |
| | returns a new matrix header for the specified column More...
|
| |
| Mat | rowRange (int startrow, int endrow) const |
| | ... for the specified row span More...
|
| |
| Mat | rowRange (const Range &r) const |
| |
| Mat | colRange (int startcol, int endcol) const |
| | ... for the specified column span More...
|
| |
| Mat | colRange (const Range &r) const |
| |
| Mat | diag (int d=0) const |
| | ... for the specified diagonal More...
|
| |
| Mat | clone () const |
| | returns deep copy of the matrix, i.e. the data is copied More...
|
| |
| void | copyTo (OutputArray m) const |
| | copies the matrix content to "m". More...
|
| |
| void | copyTo (OutputArray m, InputArray mask) const |
| | copies those matrix elements to "m" that are marked with non-zero mask elements. More...
|
| |
| void | convertTo (OutputArray m, int rtype, double alpha=1, double beta=0) const |
| | converts matrix to another datatype with optional scalng. See cvConvertScale. More...
|
| |
| void | assignTo (Mat &m, int type=-1) const |
| |
| Mat & | operator= (const Scalar &s) |
| | sets every matrix element to s More...
|
| |
| Mat & | setTo (InputArray value, InputArray mask=noArray()) |
| | sets some of the matrix elements to s, according to the mask More...
|
| |
| Mat | reshape (int cn, int rows=0) const |
| | creates alternative matrix header for the same data, with different More...
|
| |
| Mat | reshape (int cn, int newndims, const int *newsz) const |
| |
| MatExpr | t () const |
| | matrix transposition by means of matrix expressions More...
|
| |
| MatExpr | inv (int method=DECOMP_LU) const |
| | matrix inversion by means of matrix expressions More...
|
| |
| MatExpr | mul (InputArray m, double scale=1) const |
| | per-element matrix multiplication by means of matrix expressions More...
|
| |
| Mat | cross (InputArray m) const |
| | computes cross-product of 2 3D vectors More...
|
| |
| double | dot (InputArray m) const |
| | computes dot-product More...
|
| |
| void | create (int rows, int cols, int type) |
| | allocates new matrix data unless the matrix already has specified size and type. More...
|
| |
| void | create (Size size, int type) |
| |
| void | create (int ndims, const int *sizes, int type) |
| |
| void | addref () |
| | increases the reference counter; use with care to avoid memleaks More...
|
| |
| void | release () |
| | decreases reference counter; More...
|
| |
| void | deallocate () |
| | deallocates the matrix data More...
|
| |
| void | copySize (const Mat &m) |
| | internal use function; properly re-allocates _size, _step arrays More...
|
| |
| void | reserve (size_t sz) |
| | reserves enough space to fit sz hyper-planes More...
|
| |
| void | resize (size_t sz) |
| | resizes matrix to the specified number of hyper-planes More...
|
| |
| void | resize (size_t sz, const Scalar &s) |
| | resizes matrix to the specified number of hyper-planes; initializes the newly added elements More...
|
| |
| void | push_back_ (const void *elem) |
| | internal function More...
|
| |
| template<typename _Tp > |
| void | push_back (const _Tp &elem) |
| | adds element to the end of 1d matrix (or possibly multiple elements when _Tp=Mat) More...
|
| |
| template<typename _Tp > |
| void | push_back (const Mat_< _Tp > &elem) |
| |
| void | push_back (const Mat &m) |
| |
| void | pop_back (size_t nelems=1) |
| | removes several hyper-planes from bottom of the matrix More...
|
| |
| void | locateROI (Size &wholeSize, Point &ofs) const |
| | locates matrix header within a parent matrix. See below More...
|
| |
| Mat & | adjustROI (int dtop, int dbottom, int dleft, int dright) |
| | moves/resizes the current matrix ROI inside the parent matrix. More...
|
| |
| Mat | operator() (Range rowRange, Range colRange) const |
| | extracts a rectangular sub-matrix More...
|
| |
| Mat | operator() (const Rect &roi) const |
| |
| Mat | operator() (const Range *ranges) const |
| |
| | operator CvMat () const |
| | converts header to CvMat; no data is copied More...
|
| |
| | operator CvMatND () const |
| | converts header to CvMatND; no data is copied More...
|
| |
| | operator IplImage () const |
| | converts header to IplImage; no data is copied More...
|
| |
| template<typename _Tp > |
| | operator vector< _Tp > () const |
| |
| template<typename _Tp , int n> |
| | operator Vec< _Tp, n > () const |
| |
| template<typename _Tp , int m, int n> |
| | operator Matx< _Tp, m, n > () const |
| |
| bool | isContinuous () const |
| | returns true iff the matrix data is continuous More...
|
| |
| bool | isSubmatrix () const |
| | returns true if the matrix is a submatrix of another matrix More...
|
| |
| size_t | elemSize () const |
| | returns element size in bytes, More...
|
| |
| size_t | elemSize1 () const |
| | returns the size of element channel in bytes. More...
|
| |
| int | type () const |
| | returns element type, similar to CV_MAT_TYPE(cvmat->type) More...
|
| |
| int | depth () const |
| | returns element type, similar to CV_MAT_DEPTH(cvmat->type) More...
|
| |
| int | channels () const |
| | returns element type, similar to CV_MAT_CN(cvmat->type) More...
|
| |
| size_t | step1 (int i=0) const |
| | returns step/elemSize1() More...
|
| |
| bool | empty () const |
| | returns true if matrix data is NULL More...
|
| |
| size_t | total () const |
| | returns the total number of matrix elements More...
|
| |
| int | checkVector (int elemChannels, int depth=-1, bool requireContinuous=true) const |
| | returns N if the matrix is 1-channel (N x ptdim) or ptdim-channel (1 x N) or (N x 1); negative number otherwise More...
|
| |
| uchar * | ptr (int i0=0) |
| | returns pointer to i0-th submatrix along the dimension #0 More...
|
| |
| const uchar * | ptr (int i0=0) const |
| |
| uchar * | ptr (int i0, int i1) |
| | returns pointer to (i0,i1) submatrix along the dimensions #0 and #1 More...
|
| |
| const uchar * | ptr (int i0, int i1) const |
| |
| uchar * | ptr (int i0, int i1, int i2) |
| | returns pointer to (i0,i1,i3) submatrix along the dimensions #0, #1, #2 More...
|
| |
| const uchar * | ptr (int i0, int i1, int i2) const |
| |
| uchar * | ptr (const int *idx) |
| | returns pointer to the matrix element More...
|
| |
| const uchar * | ptr (const int *idx) const |
| | returns read-only pointer to the matrix element More...
|
| |
| template<int n> |
| uchar * | ptr (const Vec< int, n > &idx) |
| |
| template<int n> |
| const uchar * | ptr (const Vec< int, n > &idx) const |
| |
| template<typename _Tp > |
| _Tp * | ptr (int i0=0) |
| | template version of the above method More...
|
| |
| template<typename _Tp > |
| const _Tp * | ptr (int i0=0) const |
| |
| template<typename _Tp > |
| _Tp * | ptr (int i0, int i1) |
| |
| template<typename _Tp > |
| const _Tp * | ptr (int i0, int i1) const |
| |
| template<typename _Tp > |
| _Tp * | ptr (int i0, int i1, int i2) |
| |
| template<typename _Tp > |
| const _Tp * | ptr (int i0, int i1, int i2) const |
| |
| template<typename _Tp > |
| _Tp * | ptr (const int *idx) |
| |
| template<typename _Tp > |
| const _Tp * | ptr (const int *idx) const |
| |
| template<typename _Tp , int n> |
| _Tp * | ptr (const Vec< int, n > &idx) |
| |
| template<typename _Tp , int n> |
| const _Tp * | ptr (const Vec< int, n > &idx) const |
| |
| template<typename _Tp > |
| _Tp & | at (int i0=0) |
| | the same as above, with the pointer dereferencing More...
|
| |
| template<typename _Tp > |
| const _Tp & | at (int i0=0) const |
| |
| template<typename _Tp > |
| _Tp & | at (int i0, int i1) |
| |
| template<typename _Tp > |
| const _Tp & | at (int i0, int i1) const |
| |
| template<typename _Tp > |
| _Tp & | at (int i0, int i1, int i2) |
| |
| template<typename _Tp > |
| const _Tp & | at (int i0, int i1, int i2) const |
| |
| template<typename _Tp > |
| _Tp & | at (const int *idx) |
| |
| template<typename _Tp > |
| const _Tp & | at (const int *idx) const |
| |
| template<typename _Tp , int n> |
| _Tp & | at (const Vec< int, n > &idx) |
| |
| template<typename _Tp , int n> |
| const _Tp & | at (const Vec< int, n > &idx) const |
| |
| template<typename _Tp > |
| _Tp & | at (Point pt) |
| | special versions for 2D arrays (especially convenient for referencing image pixels) More...
|
| |
| template<typename _Tp > |
| const _Tp & | at (Point pt) const |
| |
| template<typename _Tp > |
| MatIterator_< _Tp > | begin () |
| | template methods for iteration over matrix elements. More...
|
| |
| template<typename _Tp > |
| MatIterator_< _Tp > | end () |
| |
| template<typename _Tp > |
| MatConstIterator_< _Tp > | begin () const |
| |
| template<typename _Tp > |
| MatConstIterator_< _Tp > | end () const |
| |
The n-dimensional matrix class.
The class represents an n-dimensional dense numerical array that can act as a matrix, image, optical flow map, 3-focal tensor etc. It is very similar to CvMat and CvMatND types from earlier versions of OpenCV, and similarly to those types, the matrix can be multi-channel. It also fully supports ROI mechanism.
There are many different ways to create cv::Mat object. Here are the some popular ones:
-
using cv::Mat::create(nrows, ncols, type) method or the similar constructor cv::Mat::Mat(nrows, ncols, type[, fill_value]) constructor. A new matrix of the specified size and specifed type will be allocated. "type" has the same meaning as in cvCreateMat function, e.g. CV_8UC1 means 8-bit single-channel matrix, CV_32FC2 means 2-channel (i.e. complex) floating-point matrix etc:
As noted in the introduction of this chapter, Mat::create() will only allocate a new matrix when the current matrix dimensionality or type are different from the specified.
-
by using a copy constructor or assignment operator, where on the right side it can be a matrix or expression, see below. Again, as noted in the introduction, matrix assignment is O(1) operation because it only copies the header and increases the reference counter. cv::Mat::clone() method can be used to get a full (a.k.a. deep) copy of the matrix when you need it.
-
by constructing a header for a part of another matrix. It can be a single row, single column, several rows, several columns, rectangular region in the matrix (called a minor in algebra) or a diagonal. Such operations are also O(1), because the new header will reference the same data. You can actually modify a part of the matrix using this feature, e.g.
M.row(3) = M.row(3) + M.row(5)*3;
M.col(7).copyTo(M1);
Thanks to the additional cv::Mat::datastart and cv::Mat::dataend members, it is possible to compute the relative sub-matrix position in the main "container" matrix using cv::Mat::locateROI():
As in the case of whole matrices, if you need a deep copy, use cv::Mat::clone() method of the extracted sub-matrices.
-
by making a header for user-allocated-data. It can be useful for
-
processing "foreign" data using OpenCV (e.g. when you implement a DirectShow filter or a processing module for gstreamer etc.), e.g.
void process_video_frame(const unsigned char* pixels,
int width,
int height,
int step)
{
}
-
for quick initialization of small matrices and/or super-fast element access
double m[3][3] = {{a, b, c}, {d, e, f}, {g, h, i}};
partial yet very common cases of this "user-allocated data" case are conversions from CvMat and IplImage to cv::Mat. For this purpose there are special constructors taking pointers to CvMat or IplImage and the optional flag indicating whether to copy the data or not.
Backward conversion from cv::Mat to CvMat or IplImage is provided via cast operators cv::Mat::operator CvMat() an cv::Mat::operator IplImage(). The operators do not copy the data.
-
by using MATLAB-style matrix initializers, cv::Mat::zeros(), cv::Mat::ones(), cv::Mat::eye(), e.g.:
-
by using comma-separated initializer:
Mat M = (Mat_<double>(3,3) << 1, 0, 0, 0, 1, 0, 0, 0, 1);
here we first call constructor of cv::Mat_ class (that we describe further) with the proper matrix, and then we just put "<<" operator followed by comma-separated values that can be constants, variables, expressions etc. Also, note the extra parentheses that are needed to avoid compiler errors.
Once matrix is created, it will be automatically managed by using reference-counting mechanism (unless the matrix header is built on top of user-allocated data, in which case you should handle the data by yourself). The matrix data will be deallocated when no one points to it; if you want to release the data pointed by a matrix header before the matrix destructor is called, use cv::Mat::release().
The next important thing to learn about the matrix class is element access. Here is how the matrix is stored. 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, cv::Mat::rows contains the number of matrix rows and cv::Mat::cols - the number of matrix columns. There is yet another member, cv::Mat::step that is used to actually compute address of a matrix element. cv::Mat::step is needed because the matrix can be a part of another matrix or because there can some padding space in the end of each row for a proper alignment.
Given these parameters, address of the matrix element M_{ij} is computed as following:
addr(M_{ij})=M.data + M.step*i + j*M.elemSize()
if you know the matrix element type, e.g. it is float, then you can use cv::Mat::at() method:
addr(M_{ij})=&M.at<float>(i,j)
(where & is used to convert the reference returned by cv::Mat::at() to a pointer). if you need to process a whole row of matrix, the most efficient way is to get the pointer to the row first, and then just use plain C operator []:
for(int i = 0; i < M.rows; i++)
{
const double* Mi = M.ptr<double>(i);
for(int j = 0; j < M.cols; j++)
}
Some operations, like the above one, do not actually depend on the matrix shape, they just process elements of a matrix one by one (or elements from multiple matrices that are sitting in the same place, e.g. matrix addition). Such operations are called element-wise and it makes sense to check whether all the input/output matrices are continuous, i.e. have no gaps in the end of each row, and if yes, process them as a single long row:
double sum=0;
if(M.isContinuous())
{
}
for(
int i = 0; i <
rows; i++)
{
const double* Mi = M.ptr<double>(i);
for(
int j = 0; j <
cols; j++)
}
in the case of continuous matrix the outer loop body will be executed just once, so the overhead will be smaller, which will be especially noticeable in the case of small matrices.
Finally, there are STL-style iterators that are smart enough to skip gaps between successive rows:
double sum=0;
MatConstIterator_<double> it = M.begin<double>(), it_end = M.end<double>();
for(; it != it_end; ++it)
The matrix iterators are random-access iterators, so they can be passed to any STL algorithm, including std::sort().
1.8.11