OpenCV学习笔记之Mat

迈不过友情╰ 2023-07-10 15:45 69阅读 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 对象有自己的信息头，但共享同一个矩阵。这通过让矩阵指针指向同一地址而实现。而拷贝构造函数则 只拷贝信息头和矩阵指针 ，而不拷贝矩阵。

  1. #include <QCoreApplication>
  2. #include <iostream>
  3. #include <opencv2/core.hpp>
  4. #include <opencv2/highgui.hpp>
  5. #include <QDebug>
  6. #include <QDir>
  7. #include <QFile>
  9. using namespace std;
  10. using namespace cv;
  12. int main()
  13. {
  14.     Mat A, C;                                 // 只创建信息头部分
  15.     A = imread("C:/1.png", IMREAD_COLOR);     // 这里为矩阵开辟内存
  16.     Mat B(A);                                 // 使用拷贝构造函数
  17.     C = A;                                    // 赋值运算符
  18.     imshow("A",A);
  19.     imshow("B",B);
  20.     waitKey(0);
  22. }

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

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

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

  1. #include <QCoreApplication>
  2. #include <iostream>
  3. #include <opencv2/core.hpp>
  4. #include <opencv2/highgui.hpp>
  5. #include <QDebug>
  6. #include <QDir>
  7. #include <QFile>
  9. using namespace std;
  10. using namespace cv;
  12. int main()
  13. {
  14.     Mat A, C;                                 // 只创建信息头部分
  15.     A = imread("C:/1.png", IMREAD_COLOR);     // 这里为矩阵开辟内存
  16.     Mat B(A);                                 // 使用拷贝构造函数
  17.     C = A;                                    // 赋值运算符
  18.     Mat D(A, Rect(10, 10, 100, 100) );        // using a rectangle
  19.     Mat E = A(Range::all(), Range(1,3));      // using row and column boundaries
  20.     Mat F = A.clone();
  21.     Mat G;
  22.     A.copyTo(G);
  23.     imshow("A",A);
  24.     imshow("B",B);
  25.     imshow("C",C);
  26.     imshow("D",D);
  27.     imshow("E",E);
  28.     imshow("F",F);
  29.     imshow("G",G);
  30.     waitKey(0);
  31. }

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

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

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

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

  1. //! default constructor
  2.     Mat();
  3.     //! constructs 2D matrix of the specified size and type
  4.     // (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
  5.     Mat(int rows, int cols, int type);
  6.     Mat(Size size, int type);
  7.     //! constucts 2D matrix and fills it with the specified value _s.
  8.     Mat(int rows, int cols, int type, const Scalar& s);
  9.     Mat(Size size, int type, const Scalar& s);
  11.     //! constructs n-dimensional matrix
  12.     Mat(int ndims, const int* sizes, int type);
  13.     Mat(int ndims, const int* sizes, int type, const Scalar& s);
  15. //! Matlab-style matrix initialization
  16.     static MatExpr zeros(int rows, int cols, int type);
  17.     static MatExpr zeros(Size size, int type);
  18.     static MatExpr zeros(int ndims, const int* sz, int type);
  19.     static MatExpr ones(int rows, int cols, int type);
  20.     static MatExpr ones(Size size, int type);
  21.     static MatExpr ones(int ndims, const int* sz, int type);
  22.     static MatExpr eye(int rows, int cols, int type);
  23.     static MatExpr eye(Size size, int type);

举例：

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

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

  1. #define CV_8U   0
  2. #define CV_8S   1
  3. #define CV_16U  2
  4. #define CV_16S  3
  5. #define CV_32S  4
  6. #define CV_32F  5
  7. #define CV_64F  6
  8. #define CV_16F  7
  10. #define CV_MAT_DEPTH_MASK       (CV_DEPTH_MAX - 1)
  11. #define CV_MAT_DEPTH(flags)     ((flags) & CV_MAT_DEPTH_MASK)
  13. #define CV_MAKETYPE(depth,cn) (CV_MAT_DEPTH(depth) + (((cn)-1) << CV_CN_SHIFT))
  14. #define CV_MAKE_TYPE CV_MAKETYPE
  16. #define CV_8UC1 CV_MAKETYPE(CV_8U,1)
  17. #define CV_8UC2 CV_MAKETYPE(CV_8U,2)
  18. #define CV_8UC3 CV_MAKETYPE(CV_8U,3)
  19. #define CV_8UC4 CV_MAKETYPE(CV_8U,4)
  20. #define CV_8UC(n) CV_MAKETYPE(CV_8U,(n))
  22. #define CV_8SC1 CV_MAKETYPE(CV_8S,1)
  23. #define CV_8SC2 CV_MAKETYPE(CV_8S,2)
  24. #define CV_8SC3 CV_MAKETYPE(CV_8S,3)
  25. #define CV_8SC4 CV_MAKETYPE(CV_8S,4)
  26. #define CV_8SC(n) CV_MAKETYPE(CV_8S,(n))
  28. #define CV_16UC1 CV_MAKETYPE(CV_16U,1)
  29. #define CV_16UC2 CV_MAKETYPE(CV_16U,2)
  30. #define CV_16UC3 CV_MAKETYPE(CV_16U,3)
  31. #define CV_16UC4 CV_MAKETYPE(CV_16U,4)
  32. #define CV_16UC(n) CV_MAKETYPE(CV_16U,(n))
  34. #define CV_16SC1 CV_MAKETYPE(CV_16S,1)
  35. #define CV_16SC2 CV_MAKETYPE(CV_16S,2)
  36. #define CV_16SC3 CV_MAKETYPE(CV_16S,3)
  37. #define CV_16SC4 CV_MAKETYPE(CV_16S,4)
  38. #define CV_16SC(n) CV_MAKETYPE(CV_16S,(n))
  40. #define CV_32SC1 CV_MAKETYPE(CV_32S,1)
  41. #define CV_32SC2 CV_MAKETYPE(CV_32S,2)
  42. #define CV_32SC3 CV_MAKETYPE(CV_32S,3)
  43. #define CV_32SC4 CV_MAKETYPE(CV_32S,4)
  44. #define CV_32SC(n) CV_MAKETYPE(CV_32S,(n))
  46. #define CV_32FC1 CV_MAKETYPE(CV_32F,1)
  47. #define CV_32FC2 CV_MAKETYPE(CV_32F,2)
  48. #define CV_32FC3 CV_MAKETYPE(CV_32F,3)
  49. #define CV_32FC4 CV_MAKETYPE(CV_32F,4)
  50. #define CV_32FC(n) CV_MAKETYPE(CV_32F,(n))
  52. #define CV_64FC1 CV_MAKETYPE(CV_64F,1)
  53. #define CV_64FC2 CV_MAKETYPE(CV_64F,2)
  54. #define CV_64FC3 CV_MAKETYPE(CV_64F,3)
  55. #define CV_64FC4 CV_MAKETYPE(CV_64F,4)
  56. #define CV_64FC(n) CV_MAKETYPE(CV_64F,(n))
  58. #define CV_16FC1 CV_MAKETYPE(CV_16F,1)
  59. #define CV_16FC2 CV_MAKETYPE(CV_16F,2)
  60. #define CV_16FC3 CV_MAKETYPE(CV_16F,3)
  61. #define CV_16FC4 CV_MAKETYPE(CV_16F,4)
  62. #define CV_16FC(n) CV_MAKETYPE(CV_16F,(n))
  64. 这里的type可以是任何的预定义类型，预定义类型的结构如下所示:
  65.     CV_<bit_depth>(S|U|F)C<number_of_channels>
  66.      1--bit_depth---比特数---代表8bite,16bites,32bites,64bites-
  67.      2--S|U|F--S--代表---signed int---有符号整形
  68.                U--代表--unsigned int--无符号整形
  69.                F--代表--float---------单精度浮点型
  70.      3--C<number_of_channels>----代表---一张图片的通道数

显示创建Mat矩阵

  1. #include <QCoreApplication>
  2. #include <iostream>
  3. #include <opencv2/core.hpp>
  4. #include <opencv2/highgui.hpp>
  5. #include <QDebug>
  6. #include <QDir>
  7. #include <QFile>
  9. using namespace std;
  10. using namespace cv;
  12. int main()
  13. {
  14.     Mat M(2,2, CV_8UC3, Scalar(0,0,255));
  15.     cout << "M = " << endl << " " << M << endl << endl;
  16.     M.create(4,4, CV_8UC(2));
  17.     cout << "M = "<< endl << " "  << M << endl << endl;
  18.     Mat E = Mat::eye(4, 4, CV_64F);
  19.     cout << "E = " << endl << " " << E << endl << endl;
  20.     Mat O = Mat::ones(2, 2, CV_32F);
  21.     cout << "O = " << endl << " " << O << endl << endl;
  22.     Mat Z = Mat::zeros(3,3, CV_8UC1);
  23.     cout << "Z = " << endl << " " << Z << endl << endl;
  24.     Mat RowClone = Z.row(1).clone();
  25.     cout << "RowClone = " << endl << " " << RowClone << endl << endl;
  26.     waitKey(0);
  27. }
  29. 输出：
  30. M = 
  31.  [  0,   0, 255,   0,   0, 255;
  32.    0,   0, 255,   0,   0, 255]
  34. M = 
  35.  [205, 205, 205, 205, 205, 205, 205, 205;
  36.  205, 205, 205, 205, 205, 205, 205, 205;
  37.  205, 205, 205, 205, 205, 205, 205, 205;
  38.  205, 205, 205, 205, 205, 205, 205, 205]
  40. E = 
  41.  [1, 0, 0, 0;
  42.  0, 1, 0, 0;
  43.  0, 0, 1, 0;
  44.  0, 0, 0, 1]
  46. O = 
  47.  [1, 1;
  48.  1, 1]
  50. Z = 
  51.  [  0,   0,   0;
  52.    0,   0,   0;
  53.    0,   0,   0]
  55. RowClone = 
  56.  [  0,   0,   0]

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




















































类型 C1 C2 C3 C4 C6
uchar uchar cv::Vec2b cv::Vec3b cv::Vec4b  
short short cv::Vec2s cv::Vec3s cv::Vec4b  
int int cv::Vec2i cv::Vec3i cv::Vec4i  
float float cv::Vec2f cv::Vec3f cv::Vec4f cv::Vec6f
double double cv::Vec2d cv::Vec3d cv::Vec4d cv::Vec6f 
  1. #include <QCoreApplication>
  2. #include <iostream>
  3. #include <opencv2/core.hpp>
  4. #include <opencv2/highgui.hpp>
  5. #include <QDebug>
  6. #include <QDir>
  7. #include <QFile>
  9. using namespace std;
  10. using namespace cv;
  12. int main()
  13. {
  14.     Mat M(2,2, CV_8UC3, Scalar(0,0,255));
  15.     Vec3b vec3b = M.at<Vec3b>(0,0);
  16.     uchar vec3b0 = vec3b[0];
  17.     uchar vec3b1 = vec3b[1];
  18.     uchar vec3b2 = vec3b[2];
  19.     qDebug()<<vec3b0<<vec3b1<<vec3b2;
  20.     waitKey(0);
  21. }
  22. 输出：
  23. 0 0 255
  25. /** @name Shorter aliases for the most popular specializations of Vec<T,n>
  26.   @{
  27. */
  28. typedef Vec<uchar, 2> Vec2b;
  29. typedef Vec<uchar, 3> Vec3b;
  30. typedef Vec<uchar, 4> Vec4b;
  32. typedef Vec<short, 2> Vec2s;
  33. typedef Vec<short, 3> Vec3s;
  34. typedef Vec<short, 4> Vec4s;
  36. typedef Vec<ushort, 2> Vec2w;
  37. typedef Vec<ushort, 3> Vec3w;
  38. typedef Vec<ushort, 4> Vec4w;
  40. typedef Vec<int, 2> Vec2i;
  41. typedef Vec<int, 3> Vec3i;
  42. typedef Vec<int, 4> Vec4i;
  43. typedef Vec<int, 6> Vec6i;
  44. typedef Vec<int, 8> Vec8i;
  46. typedef Vec<float, 2> Vec2f;
  47. typedef Vec<float, 3> Vec3f;
  48. typedef Vec<float, 4> Vec4f;
  49. typedef Vec<float, 6> Vec6f;
  51. typedef Vec<double, 2> Vec2d;
  52. typedef Vec<double, 3> Vec3d;
  53. typedef Vec<double, 4> Vec4d;
  54. typedef Vec<double, 6> Vec6d;
  56. #include <QCoreApplication>
  57. #include <iostream>
  58. #include <opencv2/core.hpp>
  59. #include <opencv2/highgui.hpp>
  60. #include <QDebug>
  61. #include <QDir>
  62. #include <QFile>
  64. using namespace std;
  65. using namespace cv;
  67. int main()
  68. {
  69.     Mat M(2,2, CV_8UC1, Scalar(255));
  70.     uchar vec1b = M.at<uchar>(0,0);
  71.     qDebug()<<vec1b;
  72.     waitKey(0);
  73. }

参考资料：

  1. Mat - 基本图像容器

  2. OpenCv学习笔记(二)—Mat矩阵(图像容器)的创建及CV_8UC1,CV_8UC2等参数详解

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

发表评论

表情：
评论列表 （有 0 条评论，69人围观）

还没有评论，来说两句吧...

相关阅读