OpenCV学习笔记之Mat

最新推荐文章于 2023-02-16 11:30:53 发布

浩瀚之水_csdn

最新推荐文章于 2023-02-16 11:30:53 发布

阅读量1k

点赞数

分类专栏： # OpenCV学习之路

本文链接：https://blog.csdn.net/a8039974/article/details/104635660

版权

OpenCV学习之路专栏收录该内容

39 篇文章 9 订阅

订阅专栏

一. 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() 或者 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() 或者 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 方法的数据类型如下表所示：

类型	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

#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;

#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_8UC1, Scalar(255));
    uchar vec1b = M.at<uchar>(0,0);
    qDebug()<<vec1b;
    waitKey(0);
}

参考资料：

1. Mat - 基本图像容器

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

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

浩瀚之水_csdn

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
OpenCV学习笔记之Mat

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

扫一扫