template class cv::Mat_
Overview
Template matrix class derived from Mat. More…
#include <mat.hpp> template <typename _Tp> class Mat_: public cv::Mat { public: // typedefs typedef DataType<_Tp>::channel_type channel_type; typedef MatConstIterator_<_Tp> const_iterator; typedef MatIterator_<_Tp> iterator; typedef _Tp value_type; // construction Mat_(); Mat_( int _rows, int _cols ); Mat_( int _rows, int _cols, const _Tp& value ); Mat_(Size _size); Mat_( Size _size, const _Tp& value ); Mat_( int _ndims, const int* _sizes ); Mat_( int _ndims, const int* _sizes, const _Tp& value ); Mat_(const Mat& m); Mat_(const Mat_& m); Mat_( int _rows, int _cols, _Tp* _data, size_t _step = AUTO_STEP ); Mat_( int _ndims, const int* _sizes, _Tp* _data, const size_t* _steps = 0 ); Mat_( const Mat_& m, const Range& rowRange, const Range& colRange = Range::all() ); Mat_( const Mat_& m, const Rect& roi ); Mat_( const Mat_& m, const Range* ranges ); Mat_( const Mat_& m, const std::vector<Range>& ranges ); Mat_(const MatExpr& e); Mat_( const std::vector<_Tp>& vec, bool copyData = false ); template <int n> Mat_( const Vec<typename DataType<_Tp>::channel_type, n>& vec, bool copyData = true ); template < int m, int n > Mat_( const Matx<typename DataType<_Tp>::channel_type, m, n>& mtx, bool copyData = true ); Mat_( const Point_<typename DataType<_Tp>::channel_type>& pt, bool copyData = true ); Mat_( const Point3_<typename DataType<_Tp>::channel_type>& pt, bool copyData = true ); Mat_(const MatCommaInitializer_<_Tp>& commaInitializer); // methods Mat_& adjustROI( int dtop, int dbottom, int dleft, int dright ); iterator begin(); const_iterator begin() const; int channels() const; Mat_ clone() const; Mat_ col(int x) const; void create( int _rows, int _cols ); void create(Size _size); void create( int _ndims, const int* _sizes ); Mat_ cross(const Mat_& m) const; int depth() const; Mat_ diag(int d = 0) const; size_t elemSize() const; size_t elemSize1() const; iterator end(); const_iterator end() const; template <typename Functor> void forEach(const Functor& operation); template <typename Functor> void forEach(const Functor& operation) const; template <typename T2> operator Mat_< T2 >() const; template < int m, int n > operator Matx< typename DataType< _Tp >::channel_type, m, n >() const; operator std::vector< _Tp >() const; template <int n> operator Vec< typename DataType< _Tp >::channel_type, n >() const; Mat_ operator()( const Range& rowRange, const Range& colRange ) const; Mat_ operator()(const Rect& roi) const; Mat_ operator()(const Range* ranges) const; Mat_ operator()(const std::vector<Range>& ranges) const; _Tp& operator()(const int* idx); const _Tp& operator()(const int* idx) const; template <int n> _Tp& operator()(const Vec<int, n>& idx); template <int n> const _Tp& operator()(const Vec<int, n>& idx) const; _Tp& operator()(int idx0); const _Tp& operator()(int idx0) const; _Tp& operator()( int row, int col ); const _Tp& operator()( int row, int col ) const; _Tp& operator()( int idx0, int idx1, int idx2 ); const _Tp& operator()( int idx0, int idx1, int idx2 ) const; _Tp& operator()(Point pt); const _Tp& operator()(Point pt) const; Mat_& operator=(const Mat& m); Mat_& operator=(const Mat_& m); Mat_& operator=(const _Tp& s); Mat_& operator=(const MatExpr& e); _Tp* operator[](int y); const _Tp* operator[](int y) const; void release(); Mat_ row(int y) const; size_t step1(int i = 0) const; size_t stepT(int i = 0) const; int type() const; static MatExpr eye( int rows, int cols ); static MatExpr eye(Size size); static MatExpr ones( int rows, int cols ); static MatExpr ones(Size size); static MatExpr ones( int _ndims, const int* _sizes ); static MatExpr zeros( int rows, int cols ); static MatExpr zeros(Size size); static MatExpr zeros( int _ndims, const int* _sizes ); };
Inherited Members
public: // enums enum { MAGIC_VAL = 0x42FF0000, AUTO_STEP = 0, CONTINUOUS_FLAG = CV_MAT_CONT_FLAG, SUBMATRIX_FLAG = CV_SUBMAT_FLAG, }; enum { MAGIC_MASK = 0xFFFF0000, TYPE_MASK = 0x00000FFF, DEPTH_MASK = 7, }; // fields MatAllocator* allocator; int cols; uchar* data; const uchar* dataend; const uchar* datalimit; const uchar* datastart; int dims; int flags; int rows; MatSize size; MatStep step; UMatData* u; // methods void addref(); Mat& adjustROI( int dtop, int dbottom, int dleft, int dright ); void assignTo( Mat& m, int type = -1 ) const; template <typename _Tp> _Tp& at(int i0 = 0); template <typename _Tp> const _Tp& at(int i0 = 0) const; template <typename _Tp> _Tp& at( int row, int col ); template <typename _Tp> const _Tp& at( int row, int col ) 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); template <typename _Tp> const _Tp& at(Point pt) const; template <typename _Tp> MatIterator_<_Tp> begin(); template <typename _Tp> MatConstIterator_<_Tp> begin() const; int channels() const; int checkVector( int elemChannels, int depth = -1, bool requireContinuous = true ) const; Mat clone() const; Mat col(int x) const; Mat colRange( int startcol, int endcol ) const; Mat colRange(const Range& r) const; void convertTo( OutputArray m, int rtype, double alpha = 1, double beta = 0 ) const; void copySize(const Mat& m); void copyTo(OutputArray m) const; void copyTo( OutputArray m, InputArray mask ) const; void create( int rows, int cols, int type ); void create( Size size, int type ); void create( int ndims, const int* sizes, int type ); void create( const std::vector<int>& sizes, int type ); Mat cross(InputArray m) const; void deallocate(); int depth() const; Mat diag(int d = 0) const; double dot(InputArray m) const; size_t elemSize() const; size_t elemSize1() const; bool empty() const; template <typename _Tp> MatIterator_<_Tp> end(); template <typename _Tp> MatConstIterator_<_Tp> end() const; template < typename _Tp, typename Functor > void forEach(const Functor& operation); template < typename _Tp, typename Functor > void forEach(const Functor& operation) const; UMat getUMat( int accessFlags, UMatUsageFlags usageFlags = USAGE_DEFAULT ) const; MatExpr inv(int method = DECOMP_LU) const; bool isContinuous() const; bool isSubmatrix() const; void locateROI( Size& wholeSize, Point& ofs ) const; MatExpr mul( InputArray m, double scale = 1 ) const; template < typename _Tp, int m, int n > operator Matx< _Tp, m, n >() const; template <typename _Tp> operator std::vector< _Tp >() const; template < typename _Tp, int n > operator Vec< _Tp, n >() const; Mat operator()( Range rowRange, Range colRange ) const; Mat operator()(const Rect& roi) const; Mat operator()(const Range* ranges) const; Mat operator()(const std::vector<Range>& ranges) const; Mat& operator=(const Mat& m); Mat& operator=(const MatExpr& expr); Mat& operator=(const Scalar& s); void pop_back(size_t nelems = 1); uchar* ptr(int i0 = 0); const uchar* ptr(int i0 = 0) const; uchar* ptr( int row, int col ); const uchar* ptr( int row, int col ) const; uchar* ptr( int i0, int i1, int i2 ); const uchar* ptr( int i0, int i1, int i2 ) const; uchar* ptr(const int* idx); const uchar* ptr(const int* idx) const; 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 <typename _Tp> const _Tp* ptr(int i0 = 0) const; template <typename _Tp> _Tp* ptr( int row, int col ); template <typename _Tp> const _Tp* ptr( int row, int col ) 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> void push_back(const _Tp& elem); template <typename _Tp> void push_back(const Mat_<_Tp>& elem); void push_back(const Mat& m); void push_back_(const void* elem); void release(); void reserve(size_t sz); void reserveBuffer(size_t sz); Mat reshape( int cn, int rows = 0 ) const; Mat reshape( int cn, int newndims, const int* newsz ) const; Mat reshape( int cn, const std::vector<int>& newshape ) const; void resize(size_t sz); void resize( size_t sz, const Scalar& s ); Mat row(int y) const; Mat rowRange( int startrow, int endrow ) const; Mat rowRange(const Range& r) const; Mat& setTo( InputArray value, InputArray mask = noArray() ); size_t step1(int i = 0) const; MatExpr t() const; size_t total() const; size_t total( int startDim, int endDim = INT_MAX ) const; int type() const; static Mat diag(const Mat& d); static MatExpr eye( int rows, int cols, int type ); static MatExpr eye( Size size, int type ); static MatAllocator* getDefaultAllocator(); static MatAllocator* getStdAllocator(); static MatExpr ones( int rows, int cols, int type ); static MatExpr ones( Size size, int type ); static MatExpr ones( int ndims, const int* sz, int type ); static void setDefaultAllocator(MatAllocator* allocator); static MatExpr zeros( int rows, int cols, int type ); static MatExpr zeros( Size size, int type ); static MatExpr zeros( int ndims, const int* sz, int type ); protected: // methods template < typename _Tp, typename Functor > void forEach_impl(const Functor& operation);
Detailed Documentation
Template matrix class derived from Mat.
template<typename _Tp> class Mat_ : public Mat { public: // ... some specific methods // and // no new extra fields };
The class Mat_<_Tp> is a thin template wrapper on top of the Mat class. It does not have any extra data fields. Nor this class nor Mat has any virtual methods. Thus, references or pointers to these two classes can be freely but carefully converted one to another. For example:
// create a 100x100 8-bit matrix Mat M(100,100,CV_8U); // this will be compiled fine. no any data conversion will be done. Mat_<float>& M1 = (Mat_<float>&)M; // the program is likely to crash at the statement below M1(99,99) = 1.f;
While Mat is sufficient in most cases, Mat_ can be more convenient if you use a lot of element access operations and if you know matrix type at the compilation time. Note that Mat::at(int y,int x) and Mat_::operator()(int y,int x) do absolutely the same and run at the same speed, but the latter is certainly shorter:
Mat_<double> M(20,20); for(int i = 0; i < M.rows; i++) for(int j = 0; j < M.cols; j++) M(i,j) = 1./(i+j+1); Mat E, V; eigen(M,E,V); cout << E.at<double>(0,0)/E.at<double>(M.rows-1,0);
To use Mat_ for multi-channel images/matrices, pass Vec as a Mat_ parameter:
// allocate a 320x240 color image and fill it with green (in RGB space) Mat_<Vec3b> img(240, 320, Vec3b(0,255,0)); // now draw a diagonal white line for(int i = 0; i < 100; i++) img(i,i)=Vec3b(255,255,255); // and now scramble the 2nd (red) channel of each pixel for(int i = 0; i < img.rows; i++) for(int j = 0; j < img.cols; j++) img(i,j)[2] ^= (uchar)(i ^ j);
Construction
Mat_()
default constructor
Mat_( int _rows, int _cols )
equivalent to Mat(_rows, _cols, DataType<_Tp>::type)
Mat_( int _rows, int _cols, const _Tp& value )
constructor that sets each matrix element to specified value
Mat_(Size _size)
equivalent to Mat(_size, DataType<_Tp>::type)
Mat_( Size _size, const _Tp& value )
constructor that sets each matrix element to specified value
Mat_( int _ndims, const int* _sizes )
n-dim array constructor
Mat_( int _ndims, const int* _sizes, const _Tp& value )
n-dim array constructor that sets each matrix element to specified value
Mat_(const Mat& m)
copy/conversion contructor. If m is of different type, it’s converted
Mat_(const Mat_& m)
copy constructor
Mat_( int _rows, int _cols, _Tp* _data, size_t _step = AUTO_STEP )
constructs a matrix on top of user-allocated data. step is in bytes(!!!), regardless of the type
Mat_( int _ndims, const int* _sizes, _Tp* _data, const size_t* _steps = 0 )
constructs n-dim matrix on top of user-allocated data. steps are in bytes(!!!), regardless of the type
Mat_( const Mat_& m, const Range& rowRange, const Range& colRange = Range::all() )
selects a submatrix
Mat_( const Mat_& m, const Rect& roi )
selects a submatrix
Mat_( const Mat_& m, const Range* ranges )
selects a submatrix, n-dim version
Mat_( const Mat_& m, const std::vector<Range>& ranges )
selects a submatrix, n-dim version
Mat_(const MatExpr& e)
from a matrix expression
Mat_( const std::vector<_Tp>& vec, bool copyData = false )
makes a matrix out of Vec, std::vector, Point_ or Point3_. The matrix will have a single column
Methods
Mat_& adjustROI( int dtop, int dbottom, int dleft, int dright )
some more overriden methods
iterator begin()
iterators; they are smart enough to skip gaps in the end of rows
void create( int _rows, int _cols )
equivalent to Mat::create(_rows, _cols, DataType<_Tp>::type)
void create(Size _size)
equivalent to Mat::create(_size, DataType<_Tp>::type)
void create( int _ndims, const int* _sizes )
equivalent to Mat::create(_ndims, _sizes, DatType<_Tp>::type)
Mat_ cross(const Mat_& m) const
cross-product
size_t elemSize() const
overridden forms of Mat::elemSize() etc.
template <typename Functor> void forEach(const Functor& operation)
template methods for for operation over all matrix elements.
template <typename T2> operator Mat_< T2 >() const
data type conversion
template < int m, int n > operator Matx< typename DataType< _Tp >::channel_type, m, n >() const
conversion to Matx
operator std::vector< _Tp >() const
conversion to vector.
template <int n> operator Vec< typename DataType< _Tp >::channel_type, n >() const
conversion to Vec
_Tp& operator()(const int* idx)
returns reference to the specified element
const _Tp& operator()(const int* idx) const
returns read-only reference to the specified element
template <int n> _Tp& operator()(const Vec<int, n>& idx)
returns reference to the specified element
template <int n> const _Tp& operator()(const Vec<int, n>& idx) const
returns read-only reference to the specified element
_Tp& operator()(int idx0)
returns reference to the specified element (1D case)
const _Tp& operator()(int idx0) const
returns read-only reference to the specified element (1D case)
_Tp& operator()( int row, int col )
returns reference to the specified element (2D case)
const _Tp& operator()( int row, int col ) const
returns read-only reference to the specified element (2D case)
_Tp& operator()( int idx0, int idx1, int idx2 )
returns reference to the specified element (3D case)
const _Tp& operator()( int idx0, int idx1, int idx2 ) const
returns read-only reference to the specified element (3D case)
Mat_& operator=(const _Tp& s)
set all the elements to s.
Mat_& operator=(const MatExpr& e)
assign a matrix expression
_Tp* operator[](int y)
more convenient forms of row and element access operators
void release()
equivalent to Mat::release()
Mat_ row(int y) const
overridden forms of Mat::row() etc.
size_t stepT(int i = 0) const
returns step() /sizeof(_Tp)
static MatExpr zeros( int rows, int cols )
overridden forms of Mat::zeros() etc. Data type is omitted, of course