【opencv4.3.0教程】03之Mat类详解
一、前言二、Mat定义1、Mat是个啥2、Mat代码定义三、常用成员及方法介绍1、常用成员2、构造函数3、其他方法四、常用方法1、构造函数2、其他方法五、Mat容器使用1、Mat创建对象2、Mat对象的简单使用3、Mat注意事项六、Mat与CVMat，IplImage1、为何引入Mat2、Mat优势3、类型转换...
·
目录
一、前言
上一篇文章，我们讲了OpenCV的基本使用，前面的基本使用，也是我们以后每次课程几乎都会涉及到的。想要真正掌握，其实就一个办法：多练！
从这节课开始，我们进入OpenCV的核心模块，来了解OpenCV中最基础，最核心的东西。这节课将带领大家一起来了解OpenCV最基本的结构Mat类。接下来就跟我一起走进Mat的世界吧！
二、Mat定义
1、你眼中的世界VS电脑眼中的世界
我们眼中的世界是什么样的呢？
我想，可能是这样：
可能是这样：
还可能是这样：
但是在计算机的眼中，这个世界是什么样的呢？
是这个样子的
到了计算机中都是一堆数字，这些数字就是图像的像素，上面这个图是一个灰度图像，数组代表像素值，0表示纯黑，255表示纯白，数字越大，颜色越浅。
2、Mat是个啥
上面我们了解到在计算机中，他们的世界就是一堆数字，那他们怎么存储呢？在OpenCV中，我们使用一个类Mat来存放图像，我们怎么理解容器呢？
大家已经学到这里，我想大家应该至少了解一门其他编程语言，大家都应该学过变量类型，变量类型可以用来声明一个变量。类也是如此，类是一组具有共同特征的物体的抽象表达。它有比变量更加丰富多样化的功能，类生成的实例我们称之为对象。类不仅有自己的数据，还有自己的方法。Mat类负责在OpenCV中声明一个图像类型的变量。用来存放图像数据。
3、Mat代码定义
在OpenCV中，Mat类的定义如下：
class CV_EXPORTS Mat
{
public:
Mat();
Mat(int rows, int cols, int type);
Mat(Size size, int type);
Mat(int rows, int cols, int type, const Scalar& s);
Mat(Size size, int type, const Scalar& s);
Mat(int ndims, const int* sizes, int type);
Mat(const std::vector<int>& sizes, int type);
Mat(int ndims, const int* sizes, int type, const Scalar& s);
Mat(const std::vector<int>& sizes, int type, const Scalar& s);
Mat(const Mat& m);
Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP);
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 std::vector<int>& sizes, int type, void* 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);
template<typename _Tp> explicit Mat(const std::vector<_Tp>& vec, bool copyData=false);
template<typename _Tp, typename = typename std::enable_if<std::is_arithmetic<_Tp>::value>::type>
explicit Mat(const std::initializer_list<_Tp> list);
template<typename _Tp> explicit Mat(const std::initializer_list<int> sizes, const std::initializer_list<_Tp> list);
template<typename _Tp, size_t _Nm> explicit Mat(const std::array<_Tp, _Nm>& arr, bool copyData=false);
template<typename _Tp, int n> explicit Mat(const Vec<_Tp, n>& vec, bool copyData=true);
template<typename _Tp, int m, int n> explicit Mat(const Matx<_Tp, m, n>& mtx, bool copyData=true);
template<typename _Tp> explicit Mat(const Point_<_Tp>& pt, bool copyData=true);
template<typename _Tp> explicit Mat(const Point3_<_Tp>& pt, bool copyData=true);
template<typename _Tp> explicit Mat(const MatCommaInitializer_<_Tp>& commaInitializer);
//! download data from GpuMat
explicit Mat(const cuda::GpuMat& m);
//! destructor - calls release()
~Mat();
Mat& operator = (const Mat& m);
Mat& operator = (const MatExpr& expr);
//! retrieve UMat from Mat
UMat getUMat(AccessFlag accessFlags, UMatUsageFlags usageFlags = USAGE_DEFAULT) const;
Mat row(int y) const;
Mat col(int x) const;
Mat rowRange(int startrow, int endrow) const;
Mat rowRange(const Range& r) const;
Mat colRange(int startcol, int endcol) const;
Mat colRange(const Range& r) const;
Mat diag(int d=0) const;
static Mat diag(const Mat& d);
Mat clone() const CV_NODISCARD;
void copyTo( OutputArray m ) const;
void copyTo( OutputArray m, InputArray mask ) const;
void convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const;
void assignTo( Mat& m, int type=-1 ) const;
Mat& operator = (const Scalar& s);
Mat& setTo(InputArray value, InputArray mask=noArray());
Mat reshape(int cn, int rows=0) const;
/** @overload */
Mat reshape(int cn, int newndims, const int* newsz) const;
/** @overload */
Mat reshape(int cn, const std::vector<int>& newshape) const;
MatExpr t() const;
MatExpr inv(int method=DECOMP_LU) const;
MatExpr mul(InputArray m, double scale=1) const;
Mat cross(InputArray m) const;
double dot(InputArray m) const;
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);
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 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);
void create(const std::vector<int>& sizes, int type);
void addref();
void release();
//! internal use function, consider to use 'release' method instead; deallocates the matrix data
void deallocate();
//! internal use function; properly re-allocates _size, _step arrays
void copySize(const Mat& m);
void reserve(size_t sz);
void reserveBuffer(size_t sz);
void resize(size_t sz);
void resize(size_t sz, const Scalar& s);
//! internal function
void push_back_(const void* elem);
template<typename _Tp> void push_back(const _Tp& elem);
template<typename _Tp> void push_back(const Mat_<_Tp>& elem);
template<typename _Tp> void push_back(const std::vector<_Tp>& elem);
void push_back(const Mat& m);
void pop_back(size_t nelems=1);
void locateROI( Size& wholeSize, Point& ofs ) const;
Mat& adjustROI( int dtop, int dbottom, int dleft, int dright );
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;
template<typename _Tp> operator std::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;
template<typename _Tp, std::size_t _Nm> operator std::array<_Tp, _Nm>() const;
bool isContinuous() const;
//! returns true if the matrix is a submatrix of another matrix
bool isSubmatrix() const;
size_t elemSize() const;
size_t elemSize1() const;
int type() const;
int depth() const;
int channels() const;
size_t step1(int i=0) const;
bool empty() const;
size_t total() const;
size_t total(int startDim, int endDim=INT_MAX) const;
int checkVector(int elemChannels, int depth=-1, bool requireContinuous=true) const;
uchar* ptr(int i0=0);
/** @overload */
const uchar* ptr(int i0=0) const;
uchar* ptr(int row, int col);
const uchar* ptr(int row, int col) const;
/** @overload */
uchar* ptr(int i0, int i1, int i2);
/** @overload */
const uchar* ptr(int i0, int i1, int i2) const;
/** @overload */
uchar* ptr(const int* idx);
/** @overload */
const uchar* ptr(const int* idx) const;
/** @overload */
template<int n> uchar* ptr(const Vec<int, n>& idx);
/** @overload */
template<int n> const uchar* ptr(const Vec<int, n>& idx) const;
/** @overload */
template<typename _Tp> _Tp* ptr(int i0=0);
/** @overload */
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;
/** @overload */
template<typename _Tp> _Tp* ptr(int i0, int i1, int i2);
/** @overload */
template<typename _Tp> const _Tp* ptr(int i0, int i1, int i2) const;
/** @overload */
template<typename _Tp> _Tp* ptr(const int* idx);
/** @overload */
template<typename _Tp> const _Tp* ptr(const int* idx) const;
/** @overload */
template<typename _Tp, int n> _Tp* ptr(const Vec<int, n>& idx);
/** @overload */
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 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;
/** @overload */
template<typename _Tp, int n> _Tp& at(const Vec<int, n>& idx);
/** @overload */
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;
template<typename _Tp> MatIterator_<_Tp> end();
template<typename _Tp> MatConstIterator_<_Tp> end() const;
template<typename _Tp, typename Functor> void forEach(const Functor& operation);
/** @overload */
template<typename _Tp, typename Functor> void forEach(const Functor& operation) const;
Mat(Mat&& m);
Mat& operator = (Mat&& m);
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 };
int flags;
//! the matrix dimensionality, >= 2
int dims;
//! the number of rows and columns or (-1, -1) when the matrix has more than 2 dimensions
int rows, cols;
//! pointer to the data
uchar* data;
//! helper fields used in locateROI and adjustROI
const uchar* datastart;
const uchar* dataend;
const uchar* datalimit;
//! custom allocator
MatAllocator* allocator;
//! and the standard allocator
static MatAllocator* getStdAllocator();
static MatAllocator* getDefaultAllocator();
static void setDefaultAllocator(MatAllocator* allocator);
//! internal use method: updates the continuity flag
void updateContinuityFlag();
//! interaction with UMat
UMatData* u;
MatSize size;
MatStep step;
protected:
template<typename _Tp, typename Functor> void forEach_impl(const Functor& operation);
};
着实有点多，接下来我们把最常用的分类给大家详细讲解，让大家有个系统认识。
三、常用成员及方法介绍
上面那个是整体，确实太多啦，所以在这里，给大家讲解一下常用的成员及方法。
1、常用成员
第一个要说的就是常用成员，主要有如下几个：
class CV_EXPORTS Mat
{
public:
/*flags指定图像的颜色空间
flags > 0 3通道的彩色图像
flags = 0 灰度图像
flags < 0 不作改变
*/
int flags;
/*数据的维数*/
int dims;
/*行和列的数量;数组超过2维时为(-1，-1)*/
int rows, cols;
uchar* data; // 图像数据
};
接下来我们详细说一下：
1.flags
flags用于指定图像的颜色空间，flags有三个类型的取值：
如果flags＞0，那么图像就是三通道的彩色图像；
如果flags=0，那么图像就是灰度图像；
如果flags<0，那么不做改变；
我们通过几个代码来看一下效果：
Mat src;
src = imread("./image/cat.jpg");
imshow("src", src);
cout << "src.flags = " << src.flags << endl;
src.flags = 0;
imshow("src.flags = 0", src);我们读取一张图像之后，显示一下图像，并查看该图像的flags：
src.flags = 1124024336
如果我们将图像的flags设为0，那么图像变为：
大家也可以自己尝试一下如果设为其他正值，图像会是什么样子，我取值为1，得到的如下：
如果设为负值，就会报异常。
2.dims
dims表示的是数据的维数，因为我们做的是二维图像，所以我们的维数是2，如果我们创建一个三维的数据，那我们得到的就是三维：
Mat src;
src = imread("./image/cat.jpg");
cout << "src.flags = " << src.flags << endl;
cout << "src.dims = " << src.dims << endl;上面我们是获取一个二维图像，那我们得到的结果应该是2：
如果我们创建一个三维的数据，那我们看一下效果。在这里，我们要使用Mat的构造方法，不用担心，后面我们会讲到常用的构造方法：
Mat src;
src = imread("./image/cat.jpg");
cout << "src.flags = " << src.flags << endl;
cout << "src.dims = " << src.dims << endl;上面我们是生成了一个三维图像，那我们得到的结果应该是3。
3.rows&cols
这两个就比较简单了，得到的是图像的行和列。而且大家不要记混了：
rows是行，cols是列。
这样，我们每次加载一个图像，就能清楚知道它的尺寸啦！代码如下：
Mat src;
src = imread("./image/cat.jpg");
cout << "src.rows = " << src.rows << endl;
cout << "src.cols = " << src.cols << endl;结果如下：
4.data
uchar类型的指针，指向Mat数据矩阵的首地址。这个指的是图像数据，在输出过程中，如果我们想输出其对应的值，我们需要使用强制类型转换为int类型，代码如下：（为了方便查看输出结果，我们截取图像的某一部分）
Mat src;
src = imread("./image/cat.jpg");
if (!src.data)
{
cout << "ERROR : could not load image.\n";
waitKey(0);
return -1;
}
src = Mat(src, Rect(280, 100, 20, 20));
cout << "src.rows = " << src.rows << endl;
cout << "src.cols = " << src.cols << endl;
cout << "src.data = " << endl;
for (int i = 0; i < src.cols*src.rows; i++) {
cout << (int)src.data[i] << " ";
if (i%src.rows == src.rows - 1) cout << endl;
}结果如下：
2、构造函数
Mat有很多构造函数，下面是Mat定义中的构造函数和析构函数：
class CV_EXPORTS Mat
{
public:
Mat();
Mat(int rows, int cols, int type);
Mat(Size size, int type);
Mat(int rows, int cols, int type, const Scalar& s);
Mat(Size size, int type, const Scalar& s);
Mat(int ndims, const int* sizes, int type);
Mat(const std::vector<int>& sizes, int type);
Mat(int ndims, const int* sizes, int type, const Scalar& s);
Mat(const std::vector<int>& sizes, int type, const Scalar& s);
Mat(const Mat& m);
Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP);
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 std::vector<int>& sizes, int type, void* 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);
template<typename _Tp> explicit Mat(const std::vector<_Tp>& vec, bool copyData=false);
template<typename _Tp, typename = typename std::enable_if<std::is_arithmetic<_Tp>::value>::type>
explicit Mat(const std::initializer_list<_Tp> list);
template<typename _Tp> explicit Mat(const std::initializer_list<int> sizes, const std::initializer_list<_Tp> list);
template<typename _Tp, size_t _Nm> explicit Mat(const std::array<_Tp, _Nm>& arr, bool copyData=false);
template<typename _Tp, int n> explicit Mat(const Vec<_Tp, n>& vec, bool copyData=true);
template<typename _Tp, int m, int n> explicit Mat(const Matx<_Tp, m, n>& mtx, bool copyData=true);
template<typename _Tp> explicit Mat(const Point_<_Tp>& pt, bool copyData=true);
template<typename _Tp> explicit Mat(const Point3_<_Tp>& pt, bool copyData=true);
template<typename _Tp> explicit Mat(const MatCommaInitializer_<_Tp>& commaInitializer);
//! download data from GpuMat
explicit Mat(const cuda::GpuMat& m);
//! destructor - calls release()
~Mat();
};
但其实我们一般能用到的并不多，主要有如下几类：
1.基本：尺寸 + 类型
第一种类型就是尺寸 + 类型，尺寸有的通过一个参数定义，比如：
Mat(Size size, int type); 有的通过多个参数定义，比如：
Mat(int rows, int cols, int type);类型定义如下：
int type;所以这一类型主要有：
class CV_EXPORTS Mat
{
public:
Mat(int rows, int cols, int type);
Mat(Size size, int type);
Mat(int ndims, const int* sizes, int type);
Mat(const std::vector<int>& sizes, int type);
};
2.基本 + 颜色
第二种类型在基本类型的基础上增加了颜色，也就是尺寸 + 类型 + 颜色，
其中表示颜色的是：
const Scalar& s;这一类型主要有：
class CV_EXPORTS Mat
{
public:
Mat(int rows, int cols, int type, const Scalar& s);
Mat(Size size, int type, const Scalar& s);
Mat(int ndims, const int* sizes, int type, const Scalar& s);
Mat(const std::vector<int>& sizes, int type, const Scalar& s);
};
3.基本+数据
第三种类型就是在基本类型中添加数据data，也就是尺寸 + 类型 + 数据，
其中表示数据的是：
void* data;这一类型主要有：
class CV_EXPORTS Mat
{
public:
Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP);
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 std::vector<int>& sizes, int type, void* data, const size_t* steps=0);
};
4.Mat+其他
第四种类型就是在Mat类型加上其他参数，也就是Mat + 其他，
这一类型主要有：
class CV_EXPORTS Mat
{
public:
Mat(const Mat& m);
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 src, src_roi;
src = imread("./image/cat.jpg");
if (!src.data)
{
cout << "ERROR : could not load image.\n";
waitKey(0);
return -1;
}
imshow("input image", src);
src_roi = Mat(src, Rect(100, 100, 300, 200));
imshow("roi image", src_roi);我们的输入图像为：
使用Mat构造函数 Mat(const Mat& m, const Rect& roi); 后的图像为：
3、其他方法
除了构造函数，Mat类还支持很多其他方法，在这里把一些常用的方法介绍给大家。
1.行与列
第一类是跟图像的行列相关，主要有：
class CV_EXPORTS Mat
{
public:
Mat row(int y) const;
Mat col(int x) const;
Mat rowRange(int startrow, int endrow) const;
Mat rowRange(const Range& r) const;
Mat colRange(int startcol, int endcol) const;
Mat colRange(const Range& r) const;
};
2.拷贝与转换
第二种类型是通过一个图像拷贝到另一个图像，或者转换后拷贝到另一个图像，主要有：
class CV_EXPORTS Mat
{
public:
Mat clone() const CV_NODISCARD;
void copyTo( OutputArray m ) const;
void copyTo( OutputArray m, InputArray mask ) const;
void convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const;
void assignTo( Mat& m, int type=-1 ) const;
Mat& setTo(InputArray value, InputArray mask=noArray());
};
3.基本运算
第三种类型是基本运算，因为我们知道，二维图像其实就是二维矩阵，对二维图像的操作包括修改形状尺寸，图像矩阵求逆，两个图像矩阵相乘等等，主要有：
class CV_EXPORTS Mat
{
public:
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;
MatExpr inv(int method=DECOMP_LU) const;
MatExpr mul(InputArray m, double scale=1) const;
Mat cross(InputArray m) const;
double dot(InputArray m) const;
void resize(size_t sz);
void resize(size_t sz, const Scalar& s);
};
4.生成图像矩阵
第四种类型是生成全一、全零、对角矩阵或者按类型生成矩阵，主要有：
class CV_EXPORTS Mat
{
public:
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);
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 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);
void create(const std::vector<int>& sizes, int type);
};
5.图像基本信息
第五种类型是获取图像基本信息，主要有：
class CV_EXPORTS Mat
{
public:
int type() const; //类型
int depth() const; //图像深度
int channels() const; //图像通道数
bool empty() const; //图像是否为空
};
当然Mat的函数不止有这些，其他的，如果大家深入学习，有可能会用到，在这里就不讲了。还是希望大家能够多多练习，多多尝试。
四、Mat使用
上面的主要是讲解，这里，我们通过几个实际的例子来使用一下，加深我们的印象。
1、Mat创建对象
1.声明对象
这个是最简单的，也是最常用的，我们使用一个图像类型，就要使用Mat进行声明：
Mat src;2.构造函数生成对象
我们可以使用Mat类型来生成对象，上面我们讲了很多构造方法，大家可以逐一尝试，在这里，我们举几个例子：
Mat src_rect, src_type, src_color;
src_rect = Mat(src, Rect(100, 100, 300, 200));
src_type = Mat(10, 10, CV_8UC1);
src_color = Mat(10, 10,CV_8UC3, Scalar(0, 0, 255));3.拷贝生成对象
这个时候，我们就涉及到两个概念：浅拷贝与深拷贝。
浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存。修改某一个对象，另一个对象就会一同被修改。
深拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象。
下面的方式是浅拷贝方式：
Mat light_copy_1(src);
Mat light_copy_2 = src;使用copyTo函数和clone函数可以实现深拷贝，下面的方式是深拷贝方式：
Mat deep_copy_1 = src.clone();
Mat deep_copy_2;
src.copyTo(deep_copy_2);
2、Mat对象的简单使用
简单使用就是说我们只考虑其类体中的方法，因为OpenCV的其他模块，都可以用Mat创建的对象调用，在后续课程我们会继续讲解。
我们可以访问常用成员获得图像的基本信息：
cout << "src.flags = " << src.flags << endl;
cout << "src.dims = " << src.dims << endl;
cout << "src.rows = " << src.rows << endl;
cout << "src.cols = " << src.cols << endl;
cout << "src.data = " << endl;
for (int i = 0; i < src.cols*src.rows; i++) {
cout << (int)src.data[i] << " ";
if (i%src.rows == src.rows - 1) cout << endl;
}我们可以使用Mat的方法获得图像的基本信息：
Mat src;
src = imread("./image/cat.jpg");
if (src.empty())
{
cout << "ERROR : could not load image.\n";
return -1;
}
cout << "src.channels() = " << src.channels() << endl;
cout << "src.type() = " << src.type() << endl;
cout << "src.depth() = " << src.depth() << endl;执行结果如下：
我们可以生成全一全零或者单位矩阵：
Mat E = Mat::eye(4, 4, CV_64F);
cout << "E = " << endl << E << endl << endl;
Mat O = Mat::ones(2, 2, CV_32F);
cout << "O = " << endl << O << endl << endl;
Mat Z = Mat::zeros(3, 3, CV_8UC1);
cout << "Z = " << endl << Z << endl << endl;执行结果如下：
3、Mat注意事项
根据我们上面讲的，我们总结一下在使用过程中的注意事项：
1.OpenCV中的内存分配是自动完成的（不是特别指定的话）
2.使用OpenCV的C++ 接口时不需要考虑内存释放问题
3.Mat的赋值运算和拷贝构造函数只会拷贝矩阵头，仍然共同同一个矩阵
4.如果要复制矩阵数据，可以使用clone和copyTo函数
五、Mat与CVMat，IplImage
1、为何引入Mat
讲到这里，Mat就基本讲的差不多了，在最后，给大家来点科普，其实在最开始，OpenCV使用的图像类型不是Mat，而是另外两个，那为什么要引入Mat呢？
1.语言的变化，OpenCV1.x版本使用C语言编写，从2.x版本引入C++之后，换用C++来写。
2.单从上面一条肯定是不行，主要还是因为这一条：C++提供了很多新特性，比如类可以在结束时自动调用析构函数，释放内存，就不需要再自己写代码释放了，但是C语言不行，申请的内存需要自己手动管理，特别是采用 lplImage 会直接暴露内存，如果忘记释放内存，就会造成内存泄漏。而Mat的内存分配和释放，由Mat类自己管理。
3.Mat相对于前两个功能更加强大，Mat既可以深拷贝也可以浅拷贝，Mat在进行浅拷贝时，只复制矩阵头，而不复制矩阵，提高效率。如果矩阵属于多个Mat对象，则通过引用计数来判断，当最后一个使用它的对象，则负责释放矩阵。
所以上面的也是Mat的优势。
2、类型转换
但是在很多时候，很多人还是会使用另外两个，那我们就要考虑他们的类型转换了，这里我将类型转换方式分享给大家：
//1. IpIImage -> CvMat
/*cvGetMat*/
CvMat matheader;
CvMat * mat = cvGetMat(img, &matheader);
/*cvConvert*/
CvMat * mat = cvCreateMat(img->height, img->width, CV_64FC3);
cvConvert(img, mat);
//2. IplImage -> Mat
Mat::Mat(const IplImage* img, bool copyData=false);/*default copyData=false,与原来的IplImage共享数据,只是创建一个矩阵头*/
//例子：
IplImage* iplImg = cvLoadImage("greatwave.jpg", 1);
Mat mtx(iplImg); /* IplImage * -> Mat,共享数据; or : Mat mtx = iplImg;*/
//3. Mat -> IplImage
Mat M
IplImage iplimage = M; /*只创建图像头，不复制数据*/
//4. CvMat -> Mat
Mat::Mat(const CvMat* m, bool copyData=false); /*类似IplImage -> Mat，可选择是否复制数据*/
//5. Mat -> CvMat
//例子(假设Mat类型的imgMat图像数据存在)：
CvMat cvMat = imgMat;/*Mat -> CvMat, 类似转换到IplImage，不复制数据只创建矩阵头
权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区
更多推荐
18
0- 0
已为社区贡献1条内容
所有评论(0)