OpenCV学习笔记之Mat

迈不过友情╰ 2023-07-10 15:45 0阅读 0赞

# 一. Mat介绍 #

在2001年刚刚出现的时候，OpenCV基于 *C* 语言接口而建。为了在内存（memory）中存放图像，当时采用名为 *IplImage* 的C语言结构体，时至今日这仍出现在大多数的旧版教程和教学材料。但这种方法必须接受C语言所有的不足，这其中最大的不足要数手动内存管理，其依据是用户要为开辟和销毁内存负责。虽然对于小型的程序来说手动管理内存不是问题，但一旦代码开始变得越来越庞大，你需要越来越多地纠缠于这个问题，而不是着力解决你的开发目标。

幸运的是，C++出现了，并且带来类的概念，这给用户带来另外一个选择：自动的内存管理（不严谨地说）。这是一个好消息，如果C++完全兼容C的话，这个变化不会带来兼容性问题。为此，OpenCV在2.0版本中引入了一个新的C++接口，利用自动内存管理给出了解决问题的新方法。使用这个方法，你不需要纠结在管理内存上，而且你的代码会变得简洁（少写多得）。但C++接口唯一的不足是当前许多嵌入式开发系统只支持C语言。所以，当目标不是这种开发平台时，没有必要使用 *旧* 方法（除非你是自找麻烦的受虐狂码农）。

关于 *Mat* ，首先要知道的是你不必再手动地（1）为其开辟空间（2）在不需要时立即将空间释放。但手动地做还是可以的：大多数OpenCV函数仍会手动地为输出数据开辟空间。当传递一个已经存在的 *Mat* 对象时，开辟好的矩阵空间会被重用。也就是说，我们每次都使用大小正好的内存来完成任务。

基本上讲 *Mat* 是一个类，由两个数据部分组成：矩阵头（包含矩阵尺寸，存储方法，存储地址等信息）和一个指向存储所有像素值的矩阵（根据所选存储方法的不同矩阵可以是不同的维数）的指针。矩阵头的尺寸是常数值，但矩阵本身的尺寸会依图像的不同而不同，通常比矩阵头的尺寸大数个数量级。因此，当在程序中传递图像并创建拷贝时，大的开销是由矩阵造成的，而不是信息头。OpenCV是一个图像处理库，囊括了大量的图像处理函数，为了解决问题通常要使用库中的多个函数，因此在函数中传递图像是家常便饭。同时不要忘了我们正在讨论的是计算量很大的图像处理算法，因此，除非万不得已，我们不应该拷贝 *大* 的图像，因为这会降低程序速度。

为了搞定这个问题，OpenCV使用引用计数机制。其思路是让每个 *Mat* 对象有自己的信息头，但共享同一个矩阵。这通过让矩阵指针指向同一地址而实现。而拷贝构造函数则 **只拷贝信息头和矩阵指针** ，而不拷贝矩阵。

#include <QCoreApplication>
    #include <iostream>
    #include <opencv2/core.hpp>
    #include <opencv2/highgui.hpp>
    #include <QDebug>
    #include <QDir>
    #include <QFile>
    
    using namespace std;
    using namespace cv;
    
    int main()
    {
        Mat A, C;                                 // 只创建信息头部分
        A = imread("C:/1.png", IMREAD_COLOR);     // 这里为矩阵开辟内存
        Mat B(A);                                 // 使用拷贝构造函数
        C = A;                                    // 赋值运算符
        imshow("A",A);
        imshow("B",B);
        waitKey(0);
    
    }

以上代码中的所有Mat对象最终都指向同一个也是唯一一个数据矩阵。虽然它们的信息头不同，但通过任何一个对象所做的改变也会影响其它对象。实际上，不同的对象只是访问相同数据的不同途径而已。这里还要提及一个比较棒的功能：你可以创建只引用部分数据的信息头。比如想要创建一个感兴趣区域（ *ROI* ），你只需要创建包含边界信息的信息头：

#include <QCoreApplication>
    #include <iostream>
    #include <opencv2/core.hpp>
    #include <opencv2/highgui.hpp>
    #include <QDebug>
    #include <QDir>
    #include <QFile>
    
    using namespace std;
    using namespace cv;
    
    int main()
    {
        Mat A, C;                                 // 只创建信息头部分
        A = imread("C:/1.png", IMREAD_COLOR);     // 这里为矩阵开辟内存
        Mat B(A);                                 // 使用拷贝构造函数
        C = A;                                    // 赋值运算符
        Mat D(A, Rect(10, 10, 100, 100) );        // using a rectangle
        Mat E = A(Range::all(), Range(1,3));      // using row and column boundaries
    
        imshow("A",A);
        imshow("B",B);
        imshow("C",C);
        imshow("D",D);
        imshow("E",E);
        waitKey(0);
    }

现在你也许会问，如果矩阵属于多个 *Mat* 对象，那么当不再需要它时谁来负责清理？简单的回答是：最后一个使用它的对象。通过引用计数机制来实现。无论什么时候有人拷贝了一个 *Mat* 对象的信息头，都会增加矩阵的引用次数；反之当一个头被释放之后，这个计数被减一；当计数值为零，矩阵会被清理。但某些时候你仍会想拷贝矩阵本身(不只是信息头和矩阵指针)，这时可以使用函数 [clone()][clone] 或者 [copyTo()][copyTo] 。

#include <QCoreApplication>
    #include <iostream>
    #include <opencv2/core.hpp>
    #include <opencv2/highgui.hpp>
    #include <QDebug>
    #include <QDir>
    #include <QFile>
    
    using namespace std;
    using namespace cv;
    
    int main()
    {
        Mat A, C;                                 // 只创建信息头部分
        A = imread("C:/1.png", IMREAD_COLOR);     // 这里为矩阵开辟内存
        Mat B(A);                                 // 使用拷贝构造函数
        C = A;                                    // 赋值运算符
        Mat D(A, Rect(10, 10, 100, 100) );        // using a rectangle
        Mat E = A(Range::all(), Range(1,3));      // using row and column boundaries
        Mat F = A.clone();
        Mat G;
        A.copyTo(G);
        imshow("A",A);
        imshow("B",B);
        imshow("C",C);
        imshow("D",D);
        imshow("E",E);
        imshow("F",F);
        imshow("G",G);
        waitKey(0);
    }

现在改变 *F* 或者 *G* 就不会影响 *Mat* 信息头所指向的矩阵。总结一下，你需要记住的是

*  OpenCV函数中输出图像的内存分配是自动完成的（如果不特别指定的话）。
 *  使用OpenCV的C++接口时不需要考虑内存释放问题。
 *  赋值运算符和拷贝构造函数（ *ctor* ）只拷贝信息头。
 *  使用函数 [clone()][clone] 或者 [copyTo()][copyTo] 来拷贝一副图像的矩阵。

# 二、Mat矩阵创建时参数详解 #

Mat不但是一个非常有用的图像容器类,同时也是一个通用的矩阵类，创建一个Mat对象的方法很多,我们现在先看一下Mat矩阵/图像容器类在OpenCv中的有关源代码:。

//! default constructor
        Mat();
        //! constructs 2D matrix of the specified size and type
        // (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
        Mat(int rows, int cols, int type);
        Mat(Size size, int type);
        //! constucts 2D matrix and fills it with the specified value _s.
        Mat(int rows, int cols, int type, const Scalar& s);
        Mat(Size size, int type, const Scalar& s);
    
        //! constructs n-dimensional matrix
        Mat(int ndims, const int* sizes, int type);
        Mat(int ndims, const int* sizes, int type, const Scalar& s);
    
    //! Matlab-style matrix initialization
        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);

举例：

Mat H(320,640,CV_8UC3,Scalar(255,255,255));

针对OpenCV创建矩阵时的type（CV\_8UC3），其他格式在OpenCV里详细列举如下：

#define CV_8U   0
    #define CV_8S   1
    #define CV_16U  2
    #define CV_16S  3
    #define CV_32S  4
    #define CV_32F  5
    #define CV_64F  6
    #define CV_16F  7
    
    #define CV_MAT_DEPTH_MASK       (CV_DEPTH_MAX - 1)
    #define CV_MAT_DEPTH(flags)     ((flags) & CV_MAT_DEPTH_MASK)
    
    #define CV_MAKETYPE(depth,cn) (CV_MAT_DEPTH(depth) + (((cn)-1) << CV_CN_SHIFT))
    #define CV_MAKE_TYPE CV_MAKETYPE
    
    #define CV_8UC1 CV_MAKETYPE(CV_8U,1)
    #define CV_8UC2 CV_MAKETYPE(CV_8U,2)
    #define CV_8UC3 CV_MAKETYPE(CV_8U,3)
    #define CV_8UC4 CV_MAKETYPE(CV_8U,4)
    #define CV_8UC(n) CV_MAKETYPE(CV_8U,(n))
    
    #define CV_8SC1 CV_MAKETYPE(CV_8S,1)
    #define CV_8SC2 CV_MAKETYPE(CV_8S,2)
    #define CV_8SC3 CV_MAKETYPE(CV_8S,3)
    #define CV_8SC4 CV_MAKETYPE(CV_8S,4)
    #define CV_8SC(n) CV_MAKETYPE(CV_8S,(n))
    
    #define CV_16UC1 CV_MAKETYPE(CV_16U,1)
    #define CV_16UC2 CV_MAKETYPE(CV_16U,2)
    #define CV_16UC3 CV_MAKETYPE(CV_16U,3)
    #define CV_16UC4 CV_MAKETYPE(CV_16U,4)
    #define CV_16UC(n) CV_MAKETYPE(CV_16U,(n))
    
    #define CV_16SC1 CV_MAKETYPE(CV_16S,1)
    #define CV_16SC2 CV_MAKETYPE(CV_16S,2)
    #define CV_16SC3 CV_MAKETYPE(CV_16S,3)
    #define CV_16SC4 CV_MAKETYPE(CV_16S,4)
    #define CV_16SC(n) CV_MAKETYPE(CV_16S,(n))
    
    #define CV_32SC1 CV_MAKETYPE(CV_32S,1)
    #define CV_32SC2 CV_MAKETYPE(CV_32S,2)
    #define CV_32SC3 CV_MAKETYPE(CV_32S,3)
    #define CV_32SC4 CV_MAKETYPE(CV_32S,4)
    #define CV_32SC(n) CV_MAKETYPE(CV_32S,(n))
    
    #define CV_32FC1 CV_MAKETYPE(CV_32F,1)
    #define CV_32FC2 CV_MAKETYPE(CV_32F,2)
    #define CV_32FC3 CV_MAKETYPE(CV_32F,3)
    #define CV_32FC4 CV_MAKETYPE(CV_32F,4)
    #define CV_32FC(n) CV_MAKETYPE(CV_32F,(n))
    
    #define CV_64FC1 CV_MAKETYPE(CV_64F,1)
    #define CV_64FC2 CV_MAKETYPE(CV_64F,2)
    #define CV_64FC3 CV_MAKETYPE(CV_64F,3)
    #define CV_64FC4 CV_MAKETYPE(CV_64F,4)
    #define CV_64FC(n) CV_MAKETYPE(CV_64F,(n))
    
    #define CV_16FC1 CV_MAKETYPE(CV_16F,1)
    #define CV_16FC2 CV_MAKETYPE(CV_16F,2)
    #define CV_16FC3 CV_MAKETYPE(CV_16F,3)
    #define CV_16FC4 CV_MAKETYPE(CV_16F,4)
    #define CV_16FC(n) CV_MAKETYPE(CV_16F,(n))
    
    这里的type可以是任何的预定义类型，预定义类型的结构如下所示:
        CV_<bit_depth>(S|U|F)C<number_of_channels>
         1--bit_depth---比特数---代表8bite,16bites,32bites,64bites-
         2--S|U|F--S--代表---signed int---有符号整形
                   U--代表--unsigned int--无符号整形
                   F--代表--float---------单精度浮点型
         3--C<number_of_channels>----代表---一张图片的通道数

显示创建Mat矩阵

#include <QCoreApplication>
    #include <iostream>
    #include <opencv2/core.hpp>
    #include <opencv2/highgui.hpp>
    #include <QDebug>
    #include <QDir>
    #include <QFile>
    
    using namespace std;
    using namespace cv;
    
    int main()
    {
        Mat M(2,2, CV_8UC3, Scalar(0,0,255));
        cout << "M = " << endl << " " << M << endl << endl;
        M.create(4,4, CV_8UC(2));
        cout << "M = "<< endl << " "  << M << endl << 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;
        Mat RowClone = Z.row(1).clone();
        cout << "RowClone = " << endl << " " << RowClone << endl << endl;
        waitKey(0);
    }
    
    输出：
    M = 
     [  0,   0, 255,   0,   0, 255;
       0,   0, 255,   0,   0, 255]
    
    M = 
     [205, 205, 205, 205, 205, 205, 205, 205;
     205, 205, 205, 205, 205, 205, 205, 205;
     205, 205, 205, 205, 205, 205, 205, 205;
     205, 205, 205, 205, 205, 205, 205, 205]
    
    E = 
     [1, 0, 0, 0;
     0, 1, 0, 0;
     0, 0, 1, 0;
     0, 0, 0, 1]
    
    O = 
     [1, 1;
     1, 1]
    
    Z = 
     [  0,   0,   0;
       0,   0,   0;
       0,   0,   0]
    
    RowClone = 
     [  0,   0,   0]

在已知通道数和每个通道数据类型的情况下，指定给 at 方法的数据类型如下表所示：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <th>类型</th> 
   <th>C1</th> 
   <th>C2</th> 
   <th>C3</th> 
   <th>C4</th> 
   <th>C6</th> 
  </tr> 
  <tr> 
   <td>uchar</td> 
   <td>uchar</td> 
   <td>cv::Vec2b</td> 
   <td>cv::Vec3b</td> 
   <td>cv::Vec4b</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>short</td> 
   <td>cv::Vec2s</td> 
   <td>cv::Vec3s</td> 
   <td>cv::Vec4b</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>int</td> 
   <td>cv::Vec2i</td> 
   <td>cv::Vec3i</td> 
   <td>cv::Vec4i</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>float</td> 
   <td>cv::Vec2f</td> 
   <td>cv::Vec3f</td> 
   <td>cv::Vec4f</td> 
   <td>cv::Vec6f</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>double</td> 
   <td>cv::Vec2d</td> 
   <td>cv::Vec3d</td> 
   <td>cv::Vec4d</td> 
   <td>cv::Vec6f</td> 
  </tr> 
 </tbody> 
</table>

#include <QCoreApplication>
    #include <iostream>
    #include <opencv2/core.hpp>
    #include <opencv2/highgui.hpp>
    #include <QDebug>
    #include <QDir>
    #include <QFile>
    
    using namespace std;
    using namespace cv;
    
    int main()
    {
        Mat M(2,2, CV_8UC3, Scalar(0,0,255));
        Vec3b vec3b = M.at<Vec3b>(0,0);
        uchar vec3b0 = vec3b[0];
        uchar vec3b1 = vec3b[1];
        uchar vec3b2 = vec3b[2];
        qDebug()<<vec3b0<<vec3b1<<vec3b2;
        waitKey(0);
    }
    输出：
    0 0 255

/** @name Shorter aliases for the most popular specializations of Vec<T,n>
      @{
    */
    typedef Vec<uchar, 2> Vec2b;
    typedef Vec<uchar, 3> Vec3b;
    typedef Vec<uchar, 4> Vec4b;
    
    typedef Vec<short, 2> Vec2s;
    typedef Vec<short, 3> Vec3s;
    typedef Vec<short, 4> Vec4s;
    
    typedef Vec<ushort, 2> Vec2w;
    typedef Vec<ushort, 3> Vec3w;
    typedef Vec<ushort, 4> Vec4w;
    
    typedef Vec<int, 2> Vec2i;
    typedef Vec<int, 3> Vec3i;
    typedef Vec<int, 4> Vec4i;
    typedef Vec<int, 6> Vec6i;
    typedef Vec<int, 8> Vec8i;
    
    typedef Vec<float, 2> Vec2f;
    typedef Vec<float, 3> Vec3f;
    typedef Vec<float, 4> Vec4f;
    typedef Vec<float, 6> Vec6f;
    
    typedef Vec<double, 2> Vec2d;
    typedef Vec<double, 3> Vec3d;
    typedef Vec<double, 4> Vec4d;
    typedef Vec<double, 6> Vec6d;

# 参考资料： #

1. [Mat - 基本图像容器][Mat -]

2. [OpenCv学习笔记(二)--Mat矩阵(图像容器)的创建及CV\_8UC1,CV\_8UC2等参数详解][OpenCv_--Mat_CV_8UC1_CV_8UC2]

3. [opencv cv::Mat数据类型总结][opencv cv_Mat]

[clone]: http://opencv.itseez.com/modules/core/doc/basic_structures.html#mat-clone
[copyTo]: http://opencv.itseez.com/modules/core/doc/basic_structures.html#mat-copyto
[Mat -]: http://www.opencv.org.cn/opencvdoc/2.3.2/html/doc/tutorials/core/mat%20-%20the%20basic%20image%20container/mat%20-%20the%20basic%20image%20container.html#matthebasicimagecontainer
[OpenCv_--Mat_CV_8UC1_CV_8UC2]: https://blog.csdn.net/maweifei/article/details/51221259
[opencv cv_Mat]: https://blog.csdn.net/weixin_35695879/article/details/85948011