OpenCV笔记(3) CV::Mat

1. 创建一个数组

1.1 使用构造函数

    cv::Mat a;     //默认构造函数                                                       
    cv::Mat b = cv::Mat();  //默认构造函数
    cv::Mat c = cv::Mat(3, 3, CV_8UC1);  //指定类型的二维数组
    cv::Mat d = cv::Mat(cv::Size(3, 3),CV_8UC1); //指定类型的二维数组
    cv::Mat e = cv::Mat(cv::Size(3, 3), CV_32FC2, cv::Scalar(1, 2));   //指定初始化值
    cv::Mat f = cv::Mat(cv::Size(3, 3), CV_8UC3, cv::Scalar(1, 2, 3)); //指定初始化值

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;
    cout << "d = " << d << endl;
    cout << "e = " << e << endl;
    cout << "f = " << f << endl;

下表列举了cv::Mat的基本构造函数。除了默认构造函数，它们主要分为如下几个类型：

要求输入行数和列数来构造二位数组的
使用cv::Size对象来构造二维数组
构造n维数组并且要求你通过一个整型的序列来确定每一位数据维度的

构造函数	说明
cv::Mat()	默认构造函数
cv::Mat(int rows, int cols, int type);	指定类型的二维数组
cv::Mat(cv::Size size, int type);	指定类型的二维数组（大小由size指定）
cv::Mat(int rows, int cols, int type, const Scalar& s);	指定类型的二维数组，并指定初始化值
cv::Mat(cv::Size size, int type, const Scalar& s);	指定类型的二维数组，并指定初始化值（大小由size指定）
cv::Mat(int ndims, const int* sizes, int type);	指定类型的多维数组
Mat(int ndims, const int* sizes, int type, const Scalar& s);	指定类型的多维数组，并指定初始化值
Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP)	指定类型的多维数组，并指定预先存储的数据

1.2 从其他cv::Mat复制数据

方法主要有：

从一个数组创建另一个数组
从已存在的数组子区域创建数组

　　　1）输入行列范围（只在二维矩阵的情况下有效）

　　　2）使用cv::Rect来指定一个矩形的子区域（只在二维矩阵的情况下有效）

　　　3）输入一个range数组 （range所指向的有效范围必须和mat的维度相等，如果你的mat时多维(>2）的数组，必须使用第三种）

从矩阵表达中生成新的矩阵

构造函数	说明
cv::Mat(const Mat& m)	复制构造函数
cv::Mat(const Mat& m, const cv::Range& rows, const cv::Range& cols);	只从指定的行列中复制数据的复制构造函数
cv::Mat(const Mat& m, const cv::Rect& roi);	只从感兴趣区域中复制数据的复制构造函数
*cv::Mat(const Mat& m, const cv::Range ranges);**	服务于n维数组的，从泛化的ROI中复制数据的复制构造函数
cv::Mat(const cv::MatExpr& expr);	从其他矩阵的线性代数表述中生成新矩阵的复制构造函数

示例：

cv::Mat R = (cv::Mat_<double>(3, 3) <<
        1, 2, 3,
        4, 5, 6,
        7, 8, 9);

cv::Mat temp = R({ 0,0,2,2 });

1.3 通过create函数来创建数组

cv::Mat m;//数组没有大小和数据类型
m.create(4, 4, CV_8UC1);//再次使用成员函数create()来申请一个内存区域
cout << "m = " << m << endl;

1.4 通过opencv提供的类matlab的函数创建

    cv::Mat Me = cv::Mat::eye(4, 4, CV_64F);
    cout << "Me = " << Me << endl;

    cv::Mat Mo = cv::Mat::ones(4, 4, CV_64F);
    cout << "Mo = " << Mo << endl;

    cv::Mat Mz = cv::Mat::zeros(4, 4, CV_64F);
    cout << "Mz = " << Mz << endl;

1.5 数据自定义矩阵创建

    cv::Mat m = (cv::Mat_<int>(3, 3) <<
        1, 2, 3,
        4, 5, 6,
        7, 8, 9);

2. 访问数组元素

2.1 访问一个元素

通过模板函数at<>()来实现。

这个函数有很多变体，对不同维度的数组有不同的参数要求。这个函数的工作方式是先将at<>()特化到矩阵所包含的数据类型，然后使用你想要的数据的行和列的位置访问该元素。

　cv::Mat m1 = cv::Mat::eye(10, 10, CV_32FC1);  //单通道数组
　printf("Element(3,3) is %f\n", m1.at<float>(3, 3));

　　cv::Mat m2 = cv::Mat::eye(10, 10, CV_32FC2); //多通道数组
　　printf("Element(3,3) is (%f, %f)\n",m2.at<cv::Vec2f>(3, 3)[0], m2.at<cv::Vec2f>(3, 3)[1]);

输出结果为：

Element(3,3) is 1.000000
Element(3,3) is (1.000000, 0.000000)

通过模板函数ptr<>()来实现。

首先需要一个类型名来实例化。然后接受一个整型参数来指示希望指针指向的行，函数将返回一个和矩阵原始数据类型相同的数据指针（比如说，如果数组的类型是CV_32FC3，它将会返回一个float*）。因此给定一个类型为float三通道的矩阵mtx，结构体mtx.ptr<Vec3f>(3)将会返回mtx对应行指向第一个元素第一个（浮点）通道的指针，这通常是访问数组组块的一种方式。因为一旦你拥有指针，就可以向指定的位置写入数据。

cv::Mat m = cv::Mat::eye(4, 4, CV_32FC1);
cout << *m.ptr<float>(0) << endl;    

cv::Mat m1 = cv::Mat::eye(4, 4, CV_32FC2);
cout << *m1.ptr<cv::Vec2f>(0) << endl;

输出结果为

1
[1,0]

使用cv::Mat内嵌的迭代器机制

这种机制在某种程度上是基于STL容器所提供的机制。基础想法是OpenCV提供一对迭代器模板

cv::MatConstIterator<> 用于只读（const）数组
cv::MatIterator<> 用于非只读（ono-const）数组

cv::Mat的成员函数begin()和end()会返回这种类型的对象，因为迭代器具有足够的智能来处理连续的内存区域和非连续的内存区域，所以这种方法很方便。

所有迭代器都必须在数组建立的时候声明并且指定一个对象类型。下面有一个简单的使用迭代器来极端三通道三维数组中“最长”元素（一个三位向量域）的例子：

    cv::Mat m;
    m.create(cv::Size(3, 3), CV_32FC3);
    cv::randu(m, -1.0f, 1.0f);
    float max = 0.0f; 
    cv::MatConstIterator_<cv::Vec3f> it = m.begin<cv::Vec3f>();//书上的例子此处编译错误，使用了迭代器和begin模板类就ok了
    　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//使用MatConstIterator类，编译没问题，输出会乱码
    while (it != m.end<cv::Vec3f>()) {
        float len2 = (*it)[0] * (*it)[0] + (*it)[1] * (*it)[1] + (*it)[2] * (*it)[2];    
        if (len2 > max) max = len2;
        it++;
    }
    cout << max << endl;

2.2 通过面访问数组元素

还有另一种形式的迭代器，cv::NAryMatIterator。它只要求被迭代的数组有相同的几何结构（维度以及每个维度的范围）。该迭代器不会返回一个用于迭代的单独元素，而通过返回一堆数组进行N-ary迭代器操作，这些返回的数组也称为“面”（plane）。

2.3 通过块访问数组元素

你可能需要将一个数组的子集作为另一个数组访问。这个子集可能是一行或者一列，也可能是原始数组的一个子集。

最简单的方法是row()和col()，他将一个整型变量作为参数并返回这个变量所索引的行或者列。注意：表达式m2=m.row(3)，这个表达式将创建一个新的数组头，并且分配它的data指针、step数组以及其他一写东西，这样它将可以访问m中的第三行数据。如果修改了m2中得到的数据，也会修改m中的数据，应使用真正的拷贝数据方法copyTo()。

还有rowRange()和colRange()，可以从多个连续的行（列）中提取数组。你可以1）指定开始和结束的行（列）；2）传递指明想要的行（列）的cv::Range对象。在输入两个整数的情况下，数据范围会包括开始的索引但不包括结束的索引所指向的行（列）。在使用cv::Range的时候，也会受到类似的处理。

函数成员diag()返回的数组指向矩阵m的对角元素，调用m.diag()的时候，需要输入一个整型参数来说明哪一个对角需要被提取。如果参数为0，那么将会是主对角；如果是正数，相对于主对角向数组上部分偏移；如果是负的，反之。

最后一种提取子矩阵的方式是运算符（）。通过这个运算符，你可以传递一对范围（指示行和列范围的cv::Range）或者一个cv::Rect来指定你想要的区域。

cv::Mat a = (cv::Mat_<int>(3, 3) <<
        1, 2, 3,
        4, 5, 6,
        7, 8, 9);

cout << a.diag() << endl;     //输出[1;5;9]
cout << a.diag(1) << endl;　　//输出[2;6]

cv::Mat b = a.rowRange(0, 1); 
cv::Mat c = a.colRange(0, 1); 
cout << a(cv::Range(0, 1), cv::Range(1, 2)) << endl;//输出[2]
cout << a(cv::Rect(0,0,2,2)) << endl;//输出[1,2;4,5]

3. 矩阵运算

3.1 矩阵的加减乘除

操作m2=m1，m2只是对于m1的一个引用。相比而言，m2=m1+m0表达的意思则完全不一样。因为m1+m0是矩阵表达式，者会被计算并且将结果的指针指向m2。结果将处于一个新的内存区域中。

示例	说明
m0 + m1; m0 - m1;
m0 + s; m0 - s; s + m0; s - m0;	矩阵和单个元素的加减
-m0;
s * m0; m0 * s;
m0.mul(m1); m0/m1;	对应元素相乘/除
m0*m1	矩阵乘法