OpenCv学习笔记(九)再谈OpenCv中Mat类源码的详细解读

/***********************************************************************************************************************************
文件说明:
        1）OpenCv2.X系列，cv::Mat类源码解读
		2）相似的数据类型：OpenCv1.x中的IplImage,CvMat
时间地点:
        陕西师范大学 2017.4.13
作     者:
        九月
************************************************************************************************************************************/

class CV_EXPORTS Mat
{
public:
	/*****************************************************************************************************************************
	模块说明:
	         基础图像容器类Mat类的----构造函数
	具体说明:
	         1)我们可以通过图像矩阵容器类Mat的构造函数，在实例化Mat类的类对象的时候，初始化相关的图像属性
			 2)可以显式的使用Mat类的构造函数创建Mat类的类对象
	******************************************************************************************************************************/
    Mat();                                      //【1】图像容器类Mat的默认构造函数
    Mat(int rows, int cols, int type);         //【2】有参构造函数,实例化一个二维的图像容器类，指定Mat的行数和列数，以及存储元素的数据
	                                            //类型和图像的通道数;具体的图像像素点数据元素类型和通道数有：CV_8UC1、CV_64FC3、CV_32SC
    Mat(Size size, int type);                   //【3】同上，只不过这个是通过Size类来指定图像的高度和宽度(rows*cols)
	                                            //【4】构造一个指定大小(高*宽==rows*cols),指定类型(每一个像素点的数据类型和图像通道数)，
	                                            //     并且使用指定数据初始化的图像矩阵
    Mat(int rows, int cols, int type, const Scalar& s);
    Mat(Size size, int type, const Scalar& s); //【5】同上
    Mat(int ndims, const int* sizes, int type);//【6】构造一个指定大小和指定类型的N维图像矩阵
	                                             //【7】构造一个指定大小，指定类型，并且对矩阵使用指定数值进行初始化的N维矩阵
    Mat(int ndims, const int* sizes, int type, const Scalar& s);
    Mat(const Mat& m);                          //【8】复制构造函数
	                                             //【9】为用户使用的矩阵体构造一个矩阵头
    Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP);
	                                             //【10】构造矩阵头----create a matrix header
    Mat(Size size, int type, void* data, size_t step=AUTO_STEP);
	                                             //【11】创建矩阵头
    Mat(int ndims, const int* sizes, int type, void* data, const size_t* steps=0);
	                                             //【12】为一个大矩阵体的一部分创建一个矩阵头
    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);
	                                             //【13】将旧式风格的矩阵CvMat*转换为一个新式的矩阵Mat，但是默认的并没有拷贝矩阵体
    Mat(const CvMat* m, bool copyData=false);
	                                             //【14】将旧式风格的N维矩阵CvMatND*转换为新式矩阵Mat，矩阵体没有复制
    Mat(const CvMatND* m, bool copyData=false);
	                                             //【15】将旧式风格的图像容器IplImage*转换为Mat类型,矩阵体没有被复制
    Mat(const IplImage* img, bool copyData=false);
	                                              //【16】从std::vector构件矩阵，矩阵体被复制或者没有被复制
    template<typename _Tp> explicit Mat(const vector<_Tp>& vec, bool copyData=false);
	                                              //【17】从cv::Vec构件矩阵，矩阵体被默认的一起复制过来
    template<typename _Tp, int n> explicit Mat(const Vec<_Tp, n>& vec, bool copyData=true);
	                                              //【18】从cv::Matx构件矩阵，矩阵体被默认的一起复制过来
    template<typename _Tp, int m, int n> explicit Mat(const Matx<_Tp, m, n>& mtx, bool copyData=true);
                                                  //【19】从二维点构建矩阵
    template<typename _Tp> explicit Mat(const Point_<_Tp>& pt, bool copyData=true);
                                                  //【20】从三维点构建矩阵
    template<typename _Tp> explicit Mat(const Point3_<_Tp>& pt, bool copyData=true);
                                                  //【21】builds matrix from comma initializer
    template<typename _Tp> explicit Mat(const MatCommaInitializer_<_Tp>& commaInitializer);
	                                              //【22】从GpuMat下载数据
    explicit Mat(const gpu::GpuMat& m);          
                                                  //【23】图像容器类Mat的析构函数
    ~Mat();
    Mat& operator = (const Mat& m);
    Mat& operator = (const MatExpr& expr);

    //! returns a new matrix header for the specified row
    Mat row(int y) const;
    //! returns a new matrix header for the specified column
    Mat col(int x) const;
    //! ... for the specified row span
    Mat rowRange(int startrow, int endrow) const;
    Mat rowRange(const Range& r) const;
    //! ... for the specified column span
    Mat colRange(int startcol, int endcol) const;
    Mat colRange(const Range& r) const;
    //! ... for the specified diagonal
    // (d=0 - the main diagonal,
    //  >0 - a diagonal from the lower half,
    //  <0 - a diagonal from the upper half)
    Mat diag(int d=0) const;
    //! constructs a square diagonal matrix which main diagonal is vector "d"
    static Mat diag(const Mat& d);
	                                                //【24】返回一个深复制的矩阵
    Mat clone() const;                              
	                                                //【25】复制一个矩阵到m,调用之前先调用m.create(this->size(), this->type())
    void copyTo( OutputArray m ) const;
	                                                //【26】复制复制矩阵的元素到m,并且这些m矩阵的原始的元素被非零的掩膜元素标记
    void copyTo( OutputArray m, InputArray mask ) const;
	                                                //【27】将矩阵转换为另一种数据类型的矩阵(图像元素的数据类型可选)
    void convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const;
    void assignTo( Mat& m, int type=-1 ) const;
	                                                //【28】将每一个矩阵的元素设置为s
    Mat& operator = (const Scalar& s);
    //! sets some of the matrix elements to s, according to the mask
    Mat& setTo(InputArray value, InputArray mask=noArray());
    //! creates alternative matrix header for the same data, with different
    // number of channels and/or different number of rows. see cvReshape.
    Mat reshape(int cn, int rows=0) const;
    Mat reshape(int cn, int newndims, const int* newsz) const;

    //! matrix transposition by means of matrix expressions
    MatExpr t() const;
    //! matrix inversion by means of matrix expressions
    MatExpr inv(int method=DECOMP_LU) const;
    //! per-element matrix multiplication by means of matrix expressions
    MatExpr mul(InputArray m, double scale=1) const;

    //! computes cross-product of 2 3D vectors
    Mat cross(InputArray m) const;
    //! computes dot-product
    double dot(InputArray m) const;
	/*****************************************************************************************************************************
	模块说明:
	         Matlab风格，矩阵的初始化
	******************************************************************************************************************************/
	                                                          //【29】实例化一个指定大小，指定类型、初始值为0的矩阵对象
    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);
	                                                          //【30】实例化一个指定大小，指定类型、初始值为1的矩阵
    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);
	                                                           //【31】实例化一个指定大小，指定类型的单位矩阵
    static MatExpr eye(int rows, int cols, int type);
    static MatExpr eye(Size size, int type);
	/*****************************************************************************************************************************
	模块说明:
	         创建一个新的矩阵体
	******************************************************************************************************************************/                                                           
    void create(int rows, int cols, int type);
    void create(Size size, int type);
    void create(int ndims, const int* sizes, int type);

    //! increases the reference counter; use with care to avoid memleaks
    void addref();
    //! decreases reference counter;
    // deallocates the data when reference counter reaches 0.
    void release();

    //! deallocates the matrix data
    void deallocate();
    //! internal use function; properly re-allocates _size, _step arrays
    void copySize(const Mat& m);

    //! reserves enough space to fit sz hyper-planes
    void reserve(size_t sz);
    //! resizes matrix to the specified number of hyper-planes
    void resize(size_t sz);
    //! resizes matrix to the specified number of hyper-planes; initializes the newly added elements
    void resize(size_t sz, const Scalar& s);
    //! internal function
    void push_back_(const void* elem);
    //! adds element to the end of 1d matrix (or possibly multiple elements when _Tp=Mat)
    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);
    //! removes several hyper-planes from bottom of the matrix
    void pop_back(size_t nelems=1);

    //! locates matrix header within a parent matrix. See below
    void locateROI( Size& wholeSize, Point& ofs ) const;
    //! moves/resizes the current matrix ROI inside the parent matrix.
    Mat& adjustROI( int dtop, int dbottom, int dleft, int dright );
    //! extracts a rectangular sub-matrix
    // (this is a generalized form of row, rowRange etc.)
    Mat operator()( Range rowRange, Range colRange ) const;
    Mat operator()( const Rect& roi ) const;
    Mat operator()( const Range* ranges ) const;

    //! converts header to CvMat; no data is copied
	                                                           //【32】将Mat的矩阵头转换为CvMat类型
    operator CvMat() const;                 
    operator CvMatND() const;
	                                                           //【33】将Mat的矩阵头转换为IplImage类型
    operator IplImage() const;

    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;

    //! returns true iff the matrix data is continuous
    // (i.e. when there are no gaps between successive rows).
    // similar to CV_IS_MAT_CONT(cvmat->type)
    bool isContinuous() const;

    //! returns true if the matrix is a submatrix of another matrix
    bool isSubmatrix() const;

    //! returns element size in bytes,
    // similar to CV_ELEM_SIZE(cvmat->type)
	                                                             //【34】返回图像中，每一个图像元素的大小(单位是字节，比如，int---4)
    size_t elemSize() const;
    //! returns the size of element channel in bytes.
    size_t elemSize1() const;
	                                                             //【35】返回元素的类型，类似CV_MAT_TYPE()
    int type() const;
	                                                             //【36】返回元素的深度，类似CV_MAT_DEPTH()
    int depth() const;
	                                                             //【37】返回元素的通道数，类此CV_MAT_CN()
    int channels() const;
	                                                             //【38】返回图像中每一行指针移动的个数step/elemSize1()
    size_t step1(int i=0) const; 
                                                                 //【39】判断矩阵是否为空，如果为空，则返回True
    bool empty() const;
                                                                 //【40】返回矩阵图像中，元素点的个数
    size_t total() 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
    int checkVector(int elemChannels, int depth=-1, bool requireContinuous=true) const;
	                                                             //【41】返回图像矩阵中，指定行的首地址
    uchar* ptr(int i0=0);
    const uchar* ptr(int i0=0) const;
	                                                             //【42】返回矩阵图像中，指定点的首地址
    uchar* ptr(int i0, int i1);
    const uchar* ptr(int i0, int i1) const;
    uchar* ptr(int i0, int i1, int i2);
    const uchar* ptr(int i0, int i1, int i2) const;

    //! returns pointer to the matrix element
    uchar* ptr(const int* idx);
    //! returns read-only pointer to the matrix element
    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 version of the above method
    template<typename _Tp> _Tp* ptr(int i0=0);
    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);
    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;

    //! special versions for 2D arrays (especially convenient for referencing image pixels)
    template<typename _Tp> _Tp& at(Point pt);
    template<typename _Tp> const _Tp& at(Point pt) const;

    //! template methods for iteration over matrix elements.
    // the iterators take care of skipping gaps in the end of rows (if any)
    template<typename _Tp> MatIterator_<_Tp> begin();
    template<typename _Tp> MatIterator_<_Tp> end();
    template<typename _Tp> MatConstIterator_<_Tp> begin() const;
    template<typename _Tp> MatConstIterator_<_Tp> end() const;

    enum { MAGIC_VAL=0x42FF0000, AUTO_STEP=0, CONTINUOUS_FLAG=CV_MAT_CONT_FLAG, SUBMATRIX_FLAG=CV_SUBMAT_FLAG };
   	/*****************************************************************************************************************************
	模块说明:
	         图像矩阵的属性
	******************************************************************************************************************************/ 
    int flags;                                           //【43】图像矩阵是否连续
    int dims;                                            //【44】图像矩阵的维数dims>=2
    int rows, cols;                                      //【45】图像矩阵的行和列数
                                                          //【46】指向图像矩阵矩阵体的指针
    uchar* data;

    //! pointer to the reference counter;
    // when matrix points to user-allocated data, the pointer is NULL
    int* refcount;

    //! helper fields used in locateROI and adjustROI
    uchar* datastart;
    uchar* dataend;
    uchar* datalimit;

    //! custom allocator
    MatAllocator* allocator;

    struct CV_EXPORTS MSize
    {
        MSize(int* _p);
        Size operator()() const;
        const int& operator[](int i) const;
        int& operator[](int i);
        operator const int*() const;
        bool operator == (const MSize& sz) const;
        bool operator != (const MSize& sz) const;

        int* p;
    };

    struct CV_EXPORTS MStep
    {
        MStep();
        MStep(size_t s);
        const size_t& operator[](int i) const;
        size_t& operator[](int i);
        operator size_t() const;
        MStep& operator = (size_t s);

        size_t* p;
        size_t buf[2];
    protected:
        MStep& operator = (const MStep&);
    };

    MSize size;
    MStep step;

protected:
    void initEmpty();
};