OpenCV Mat类详解和用法

「爱情、让人受尽委屈。」 2022-06-17 02:17 422阅读 0赞

# OpenCV Mat类详解和用法 #

我们有多种方法可以获得从现实世界的数字图像：数码相机、扫描仪、计算机体层摄影或磁共振成像就是其中的几种。在每种情况下我们（人类）看到了什么是图像。但是，转换图像到我们的数字设备时我们的记录是图像的每个点的数值。

![0_1330856598Rylz.gif][]

例如在上图中你可以看到车的镜子只是一个包含所有强度值的像素点矩阵。现在，我们如何获取和存储像素值可能根据最适合我们的需要而变化，最终可能减少计算机世界内的所有图像数值矩阵和一些其他的信息的描述基质本身。OpenCV 是一个计算机视觉库，其主要的工作是处理和操作，进一步了解这些信息。因此，你需要学习和开始熟悉它的第一件事是理解OpenCV 是如何存储和处理图像。

# **Mat** #

OpenCV 自 2001 年出现以来。在那些日子里库是围绕C接口构建的。在那些日子里，他们使用名为IplImage C 的结构在内存中存储图像。这是您将在大多数较旧的教程和教材中看到的那个。使用这个结构的问题是将 C 语言的所有负面效果都摆到了桌面上。最大的问题是手动管理。它是建立在用户来负责处理内存分配和解除分配的假设之上的。当程序规模较小时，这是没有问题的，一旦代码基开始变得越来越大它将会越来越挣扎着处理所有这一切而不是着眼于实际解决自己的开发目标。

幸运的是 c + + 出现了，并引入了类的概念，使得为用户开辟另一条路成为可能：

自动内存管理 （或多或少）。好消息是，c + +，如果完全兼容 C 所以进行更改时没有兼容性问题产生。因此， OpenCV其2.0 版本引入一个新的c + + 接口，通过利用这些优点将为你的工作提供新的方法。某种程度上，在其中您不需要拨弄内存管理让你的代码简洁 （写得更少，实现的更多）。C + + 接口的唯一主要缺点在于，目前许多嵌入式的开发系统支持仅 C.因此，除非您的目标是这一平台，否则就没有理由再使用旧的方法（除非你是个受虐狂程序员和喜欢自讨苦吃）。

你需要知道的关于Mat的第一件事是你不再需要手动分配其大小并且当你不需要它的时候你不再需要手动释放它。虽然这样做仍然是可能的，大多数 OpenCV 函数将手动分配其输出数据。还有一个额外的好处是如果传递一个已存在Mat对象，它已经为矩阵分配所需的空间，这段空间将被重用。也就是说我们在任何时候只使用与我们执行任务时所必须多的内存一样多的内存。

Mat本质上是由两个数据部分组成的类： （包含信息有矩阵的大小，用于存储的方法，矩阵存储的地址等） 的矩阵头和一个指针，指向包含了像素值的矩阵（可根据选择用于存储的方法采用任何维度存储数据）。矩阵头部的大小是恒定的。然而，矩阵本身的大小因图像的不同而不同，通常是较大的数量级。因此，当你在您的程序中传递图像并在有些时候创建图像副本您需要花费很大的代价生成图像矩阵本身，而不是图像的头部。OpenCV 是图像处理库，它包含大量的图像处理函数。若要解决的计算挑战，最终大部分时间你会使用库中的多个函数。由于这一原因图像传给库中的函数是一种常见的做法。我们不应忘记我们正在谈论往往是计算量相当大的图像处理算法。我们想要做的最后一件事是通过制作不必要的可能很大的图像的拷贝进一步降低您的程序的速度。

为了解决这一问题 OpenCV 使用引用计数系统。其思想是Mat的每个对象具有其自己的头，但可能他们通过让他们矩阵指针指向同一地址的两个实例之间共享该矩阵。此外，拷贝运算符将只能复制矩阵头部，也还将复制指针到大型矩阵，但不是矩阵本身。

Mat A, C; //仅创建了头部
            A = imread(argv[1], CV_LOAD_IMAGE_COLOR); //在此我们知道使用的方法（分配矩阵）
            Mat B(A); //使用拷贝构造函数
            C = A; //赋值运算符

上文中的所有对象，以相同的单个数据矩阵的结束点。他们头不同，但是使用的其中任何一个对矩阵进行任何修改，也将影响所有其他的。在实践中的不同对象只是提供相同的底层数据不同的访问方法，然而，它们的头部是不同的。真正有趣的部分是您可以创建仅指向完整数据的一小部分的头。例如，要在图像中创建兴趣区域 ( ROI) 您只需创建一个新头设置新边界：

Mat D (A, Rect(10, 10, 100, 100) ); // 用矩形界定
    
    Mat E = A(Range:all(), Range(1,3)); // 用行和列来界定

现在，你可能会问是否矩阵的本身可以属于多个Mat对象在不再需要时负责清理数据。简短的回答是：最后一个使用它的对象。这对于使用引用计数的机制，每当有人复制Mat对象的头，矩阵的计数器被增加。每当一个头被清除，此计数器被下调。当该计数器变为零，矩阵也就被释放了。因为有时会仍然也要复制矩阵的本身，存在着 clone() 或 copyTo() 函数。

Mat F = A.clone();
    Mat G;
    A.copyTo(G);

现在 modifyingForGwill 不会影响由 theMatheader 指出的矩阵。你要记得从所有的是：

>          • 输出图像分配 OpenCV 功能是自动 （除非另行指定，否则）。
> 
>          • 用c + + OpenCV的接口就无需考虑内存释放。
> 
>          • 赋值运算符和复制构造函数 （构造函数）只复制头。
> 
>          • 使用clone () 或copyTo () 函数将复制的图像的基础矩阵。

### **存储方法** ###

这是关于你是如何存储的像素值。您可以选择的颜色空间和使用的数据类型。色彩空间是指我们如何结合为了代码指定的颜色的颜色分量。最简单的是灰色的规模。在这里我们所掌握的颜色是黑色和白色。组合的这些让我们能创造很多的灰度级。

对于彩色的方法，我们有很多方法可供选择。不过，每一就是将他们拆解成三个或四个基本组成部分，这些部分就会组合给所有其他的方法。最受欢迎的这一个 RGB，主要是因为这也是我们的眼睛如何建立中我们的眼睛的颜色。其基准的颜色是红、 绿、 蓝。编写代码的一种颜色的透明度有时第四个元素： 添加 alpha (A)。但是，它们很多颜色系统每个具有自身的优势：

*  **RGB 是最常见的是我们的眼睛使用类似的事情，我们显示系统还撰写使用这些颜色。**

单纯疱疹和合肥分解颜色到他们的色相、 饱和度和亮度值/组件，这是我们来描述颜色更自然的方式。您使用，例如可驳回的最后一个组件，使你不那么明智的输入图像的光照条件的算法。

*  **YCrCb 使用流行的 JPEG 图像格式。**
 *  **CIE L \*b\*a 是均匀颜色空间，它是非常方便的如果您需要测量给定的颜色，以另一种颜色的距离。**

现在，每个建筑构件都自己有效的域。这会导致使用的数据类型。我们如何存储组件的定义只是如何精细的控制，我们已于其域。最小的数据类型可能是 char 类型，这意味着一个字节或 8 位。这可能是有符号（值-127 到 + 127）或无符号（以便可以存储从 0 到 255 之间的值）。虽然这三个组件的情况下已经给 16 万可能的颜色来表示 （如 RGB 的情况下） 我们可能通过使用浮点数 （4 字节 = 32 位） 或double（8 字节 = 64 位） 数据类型的每个组件获得甚至更精细的控制。然而，请记住增加组件的大小也会增加在内存中的整张图片的大小。

**显式创建Mat对象**

在Load, Modify and Save an Image 教程中，你已经可以看到如何使用readWriteImageVideo： 'imwrite() <imwrite>' 函数将一个矩阵写到一个图像文件中。然而，出于调试目的显示的实际值就方便得多。您可以实现此通过Mat的 <<运算符。不过，请注意这仅适用于二维矩阵。

虽然Mat是一个伟大的图像容器类，它也是一般矩阵类。因此，利用Mat创建和操作多维矩阵是可能的。您可以通过多种方式创建Mat的对象：

### **• Mat()构造函数** ###

Mat M(2,2, CV_8UC3, Scalar(0,0,255));

![0_1330856718K3Fi.gif][]

> cout << "M = " << endl << " " << M << endl << endl;

对于二维的和多通道的图像，我们首先定义它们的大小：按行和列计数。

然后我们需要指定的数据类型，用于存储元素和每个矩阵点通道的数量。为此，我们根据以下的约定可以作出多个定义：

CV\_ \[每一项的位数\] \[有符号或无符号\] \[类型前缀\] C \[通道数\]

例如，CV\_8UC3 意味着我们使用那些长的 8 位无符号的 char 类型和每个像素都有三个项目的这三个通道的形成。这是预定义的四个通道数字。Scalar 是四个元素短向量。指定此和可以初始化所有矩阵点与自定义的值。但是如果你需要更多您可以创建与上部宏和频道号码放在括号中，您可以看到下面的类型。

使用 C\\C++ 数组和通过构造函数来初始化

int sz[3] = {2,2,2};
    Mat L(3,sz,CV_8UC(1),Scalar::all(0));

![0_1330856786g3zj.gif][]

上例为我们展示了如何创建一个二维以上的矩阵。首先指定其维度数，然后传入一个包含了尺寸每个维度信息的指针，其他都保持不变。

*  **为一个已经存在的IplImage创建一个头：**

IplImage* img = cvLoadImage("greatwave.png", 1);
                 Mat mtx(img); // 转换 IplImage*-> Mat

![0_1330856884BYww.gif][]

*  **Create()函数:**

M.create(4,4, CV_8UC(2));
    cout << "M = "<< endl << " " << M << endl << endl;

![0_1330856939QWEY.gif][]

你不能通过这个构造来初始化矩阵中的数值。它只会在新的居住尺寸与旧的矩阵尺寸不合时重新分配矩阵的数据空间。

*  **MATLAB风格的初始化函数：zeros()， ones()，eyes().指定使用的尺寸和数据类型**

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 C = (Mat_<double>(3,3) << 0, -1, 0, -1, 5, -1, 0, -1, 0);
    cout << "C = " << endl << " " << C << endl << endl;

*  **为一个已有的Mat对象创建一个新的头然后clone()或者copyTo()这个头.**

Mat RowClone = C.row(1).clone();
    cout << "RowClone = " << endl << " " << RowClone << endl << endl;

![0_13308569919F83.gif][]

### 打印格式 ###

注意：你可以通过用randu()函数产生的随机值来填充矩阵。你需要给定一个上限和下限来确保随机值在你期望的范围内：

Mat R = Mat(3, 2, CV_8UC3);
    randu(R, Scalar::all(0), Scalar::all(255));

在上一个例子中你可以看到默认的格式选项。尽管如此，OpenCV允许你在符合以下规则的同时格式化你的输出：

*  **默认**

cout << "R (default) = " << endl << R << endl << endl;

![0_1330857038cTxC.gif][]

*  **Python**

cout << "R (python) = " << endl << format(R,"python") << endl << endl;

![0_1330857091Ppf8.gif][]

*  **Comma separated values (CSV)**

cout << "R (csv) = " << endl << format(R,"csv" ) << endl << endl;

![0_13308571511a4l.gif][]

*  **Numpy**

cout << "R (numpy) = " << endl << format(R,"numpy" ) << endl << endl;

![0_13308572004nb4.gif][]

*  **C**

cout << "R (c) = " << endl << format(R,"C" ) << endl << endl;

![0_1330857246cmJy.gif][]

*  **打印出其它常见数据项**

OpenCV 通过<<操作符也为其他常用OpenCV数据结构提供打印输出的支持，如：

*  **2D 点**

Point2f P(5, 1);
    cout << "Point (2D) = " << P << endl << endl;

![0_1330857287d6Jp.gif][]

*  **3D 点**

Point3f  P3f(2, 6, 7);
    cout << "Point (3D) = " << P3f << endl << endl;

![0_1330857327Aa11.gif][]

*  **std::vector通过 cv::Mat**

vector<float> v;
    v.push_back( (float)CV_PI); v.push_back(2); v.push_back(3.01f);
    cout << "Vector of floats via Mat = " << Mat(v) << endl << endl;

![0_1330857370a0AH.gif][]

*  **点的std::vector**

vector<Point2f> vPoints(20);
    for (size_t E = 0; E < vPoints.size(); ++E)
    vPoints[E] = Point2f((float)(E*5), (float)(E % 7));
    cout << "A vector of 2D Points = " << vPoints << endl << endl;

![0_1330855890ppPq.gif][]

这里大多数的例程都是在一个小控制台程序里运行。你可以在这里下载或是在cpp示例文件夹下找到。

你可以在YouTube.上找到一个快速的实例演示。

--------------------

## Mat成员函数 ##

### Mat::~Mat：Mat的析构函数。 ###

> **C++: Mat::~Mat()**

析构函数调用Mat::release()。

### Mat::operator =：提供矩阵赋值操作。 ###

> C++: Mat& Mat::operator=(const Mat& m)
> 
> C++: Mat& Mat::operator=(const MatExpr\_Base& expr)
> 
> C++: Mat& Mat::operator=(const Scalar& s)

> **参数：**
> 
> **m** – 被赋值的右侧的矩阵。 矩阵的赋值是一个复杂度为O(1) 的操作。 这就意味着没有数据段复制并且有数量的递增两矩阵将使用同一引用计数器。在给矩阵赋新数据之前先由Mat::release()释放引用。
> 
> **expr** –被赋值的矩阵表达式对象。 作为第一种赋值方式的逆操作第二种形式可以被重新用到具有适当大小和尺寸的已分配空间的矩阵上以适应表达式的结果。矩阵表达式扩展得到的实函数将自动处理这个分配过程。例如：
> 
> C=A+B 扩展成add(A, B, C) , andadd() 要当心C重新分配数据的操作。.
> 
> **s** – 标量赋值给每一个矩阵元，矩阵的大小和类型将不会改变。有现成的赋值运算符。由于他们各不相同请阅读运算符参数说明。

### Mat::operator MatExpr ###

提供一种Mat-to-MatExpr转换运算符

> **C++: Mat::operator MatExpr\_<Mat, Mat>() const**

转换运算符不能显示调用而是由矩阵表达式引擎（Matrix Expression engine）内部调用The cast operator should not be called explicitly. It is used internally by the Matrix Expressions engine.

### Mat::row ###

创建一个指定行数的矩阵头。.

> **C++: Mat Mat::row(int i) const**
> 
> **参数：**
> 
> **i – **一个0基的行索引.

该方法创建一个具有指定了行数的新矩阵头的矩阵并返回它。这是一个复杂度为O(1) 的操作，无须考虑矩阵的尺寸。新矩阵和原矩阵共享一份基础数据。这是一个典型基本矩阵处理操作的例子, axpy是LU和许多其它算法都使用的一个函数

inline void matrix_axpy(Mat& A, int i, int j, double alpha)
    {
    
        A.row(i) += A.row(j)*alpha;
    }

**Note：**在当前实现中，下面的代码不会无法按预期的效果工作：

Mat A ;
    
    ...
    
    A.row(i) = A.row(j) ；/ /不起作用

发生这种情况是因为 A.row(i) 形成临时矩阵头进一步分配给另一个矩阵头。请记住，每个操作复杂度为O（1），即没有复制任何数据。因此，如果你预期第 j行被复制到第 i行，那么上述赋值不成立。要做到这一点，应该把这种简单的赋值转换到表达式中或使用 ***Mat::copyTo()*** 方法：

Mat A ;
    
    ...
    
    // 可行，但看上去有点目的不明确。
    
    A.row(i) = A.row(j) + 0;
    
    // 这是有点儿长，但这是推荐的方法。
    
    A.row(j).copyTo(A.row(i)) ;

### Mat::col ###

创建一个具有指定了矩阵头中列数这个参数的矩阵

> **C++: Mat Mat::col(int j) const**
> 
> **参数：**
> 
> **j** –一个0基（从0开始）的列索引

该方法创建一个具有指定了矩阵头中列数这个参数的新矩阵并作为函数返回值。这是一种复杂度为O(1)的操作，不用考虑矩阵的尺寸大小。新矩阵和原始矩阵共享一份基础数据。参看*Mat::row()*说明信息。

### Mat::rowRange ###

为指定的行span创建一个新的矩阵头。

> **C++: Mat Mat::rowRange(int startrow, int endrow) const**
> 
> **C++: Mat Mat::rowRange(const Range& r) const**
> 
> **参数：**
> 
> **startrow** – 一个包容性的0基（从0开始）的行span起始索引.。
> 
> **endrow **– 一个0基的独占性的行span.终止索引。
> 
> **r** – Range 结构包含着起始和终止的索引值。该方法给矩阵指定的行span创建了新的头。 与Mat::row() 和 Mat::col()相类似这是一个复杂度为O(1)的操作。

### Mat::colRange ###

为指定的行span创建一个矩阵头。

> **C++: Mat Mat::colRange(int startcol, int endcol) const**
> 
> **C++: Mat Mat::colRange(const Range& r) const**
> 
> **参数：**
> 
> **startcol** – 一个包容性的0基（从0开始）的span列起始索引。
> 
> **endcol** –一个0基的独占性的列span.终止索引。
> 
> **r** –Range 结构包含着起始和终止的索引值。该方法给矩阵指定的列span创建了新的头。 与Mat::row() 和 Mat::col()相类似这是一个复杂度为O(1)的操作。

### Mat::diag ###

提取或创建矩阵对角线。

> **C++: Mat Mat::diag(int d) const**
> 
> **C++: static Mat Mat::diag(const Mat& matD)**
> 
> **参数：**
> 
> **d** – 对角线的索引值，可以是以下的值：
> 
> – d=0 是主对角线
> 
> – d>0表示下半部的对角线。例如：d=1对角线是紧挨着住对角线并位于矩阵下方。
> 
> – d<0表示来自矩阵上半部的对角线。例如：d= 1表示对角线被设置在对角线的上方并紧挨着。
> 
> **matD **– 单列用于形成矩阵对角线的列。

该方法为指定的矩阵创建一个新的头。然后新矩阵被分割为单独的列矩阵。类似于Mat::row() 和Mat::col() ,它是复杂度为O(1)操作。

### Mat::clone ###

创建一个数组及其基础数据的完整副本。

> **C++: Mat Mat::clone() const**

该方法创建了一个完整的数组副本。原始的step\[\]不会被考虑在内的。因此数组的副本是一占用total（）\*elemSize（）字节的连续阵列。

### Mat::copyTo ###

把矩阵复制到另一个矩阵中。

> **C++: void Mat::copyTo(OutputArray m) const**
> 
> **C++: void Mat::copyTo(OutputArray m, InputArray mask) const**
> 
> **参数：**
> 
> **m** – 目标矩阵。如果它的尺寸和类型不正确，在操作之前会重新分配。
> 
> **mask** – 操作掩码。它的非零元素表示矩阵中某个要被复制。

该方法把矩阵的复制到另一个新的矩阵中在复制之前该方法会调用

> m.create(this->size(), this->type);

因此，目标矩阵会在必要的情况下重新分配

尽管m.copyTo(m) works ﬂawlessly,该函数并不处理源矩阵和目标矩阵之间有重叠的部分的情况。当操作掩码指定以及上述的Mat::create重新分配矩阵，新分配的矩阵在数据复制到里面之前全都被初始化为０。

### Mat::convertTo ###

在缩放或不缩放的情况下转换为另一种数据类型。

> **C++:**
> 
> **void Mat::convertTo(OutputArray m,int rtype,double alpha=1,double beta=0)const**
> 
> **参数：**
> 
> **m** – 目标矩阵。如果它的尺寸和类型不正确，在操作之前会重新分配。
> 
> **rtype** – 要求是目标矩阵的类型，或者在当前通道数与源矩阵通道数相同的情况下的depth。如果rtype 为负，目标矩阵与源矩阵类型相同。
> 
> **beta** – 可选的delta加到缩放值中去。

该方法将源像素值转化为目标类型saturate\_cast<> 要放在最后以避免溢出

> m( x;y) = saturate\_cast < rType > ( α\*( \*this)( x;y) +β)

### Mat::assignTo ###

提供了一个convertTo的功能形式。

> **C++: void Mat::assignTo(Mat& m, int type=-1 ) const**
> 
> **Parameters**
> 
> **m** – 目标阵列。
> 
> **type** – 要求是目标阵列depth或－１（如果阵列的类型和源矩阵类型相同）

这是一个 internally 使用的由 Matrix Expressions引擎调用的方法。

### Mat::setTo ###

将阵列中所有的或部分的元素设置为指定的值。

> **C++: Mat& Mat::setTo(const Scalar& s, InputArray mask=noArray())**
> 
> **参数：**
> 
> **s** – 把标量赋给阵列并转化到阵列的实际类型。
> 
> **mask** – 与 \*this尺寸相同的操作掩码。这是Mat::operator=(const Scalar& s)运算符的一个高级变量。

### Mat::reshape ###

在无需复制数据的前提下改变2D矩阵的形状和通道数或其中之一。

> **C++: Mat Mat::reshape(int cn, int rows=0) const**
> 
> **参数：**
> 
> **cn** – 新的通道数。若cn=0，那么通道数就保持不变。
> 
> **rows** –新的行数。 若rows = 0, 那么行数保持不变。

该方法为\*this元素创建新的矩阵头。这新的矩阵头尺寸和通道数或其中之一发生改变，在以下的情况任意组合都是有可能的：

>  *  新的矩阵没有新增或减少元素。通常，rows\*cols\*channels()在转换过程中保持一致。.
>  *  无数据的复制。也就是说，这是一个复杂度为 O(1)的操作。通常，如果该操作改变行数或透过其他方式改变元素行索引，那么矩阵必定是连续的。参见Mat::isContinuous()。

例如，有一存储了STL向量的三维点集，你想用3xN的矩阵来完成下面的操作：

std::vector<Point3f> vec;
    
    ...
    
    Mat pointMat = Mat(vec). //把向量转化成Mat, 复杂度为O(1)的运算
    
    reshape(1). // 从Nx1的3通道矩阵得出Nx3 的单通道矩阵
    
    //同样是复杂度为O(1)的运算
    
    t(); // 最后转置Nx3 的矩阵
    
    //这个过程要复制所有的元素

### Mat::t ###

转置矩阵。.

> **C++: MatExpr Mat::t() const**

该方法通过矩阵表达式（matrix expression）实现矩阵的转置The method performs matrix transposition by means of matrix expressions. 它并未真正完成了转置但却返回一个临时的可以进一步用在更复杂的矩阵表达式中或赋给一个矩阵的转置矩阵对象：

Mat A1 = A + Mat::eye(A.size(), A.type)*lambda;
    
    Mat C = A1.t()*A1; //计算(A + lambda*I)^t * (A + lamda*I).

### Mat::inv ###

反转矩阵

> **C++: MatExpr Mat::inv(int method=DECOMP\_LU) const**
> 
> **参数:**
> 
> **method** – 反转矩阵的方法。有以下几种可能的值：
> 
> – DECOMP\_LU是 LU 分解一定不能是单数的。
> 
> – DECOMP\_CHOLESKY 是 Cholesky LLT只适用于对称正矩阵的分解。该类型在处理大的矩阵时的速度是LU的两倍左右。
> 
> – DECOMP\_SVD是 SVD 分解。如果矩阵是单数或甚至不是2维，函数就会计算伪反转矩阵。

该方法执行矩阵的反转矩阵表达。这意味着该方法返回一个临时矩阵反转对象并可进一步用于更复杂的矩阵表达式的中或分配给一个矩阵。

### Mat::mul ###

执行两个矩阵按元素相乘或这两个矩阵的除法。

> **C++: MatExpr Mat::mul(InputArray m, double scale=1) const**
> 
> **参数：**
> 
> **m** – 与\*this具有相同类型和大小的矩阵,或矩阵表达式。
> 
> **scale** – 可选缩放系数。

该方法返回一个用可选的缩放比率编码了每个元素的数组乘法的临时的对象。 注意：这不是一个对应“\*”运算符的简单的矩阵乘法。.

例：:

Mat C = A.mul(5/B); // 等价于divide(A, B, C, 5)

### Mat::cross ###

计算3元素向量的一个叉乘积。

> **C++: Mat Mat::cross(InputArray m) const**
> 
> **参数：**
> 
> **m **–另一个叉乘操作对象。

该方法计算了两个３元素向量的叉乘的积被操作向量必须是３元素浮点型的具有相同形状和尺寸的向量。结果也是一语被操作对象的具有相同形状和大小的浮点型３元素向量。

### Mat::dot ###

计算两向量的点乘。

> **C++: double Mat::dot(InputArray m) const**
> 
> **参数：**
> 
> **m **–另一个点积操作对象。

方法计算两个矩阵的点积。如果矩阵不单列或单行的向量，用顶部到底部从左到右扫描次序将它们视为 1 D向量。这些向量必须具有相同的大小和类型。如果矩阵有多个通道，从所有通道得到的点积会被加在一起。

### Mat::zeros ###

返回指定的大小和类型的零数组。

> **C++: static MatExpr Mat::zeros(int rows, int cols, int type)**
> 
> **C++: static MatExpr Mat::zeros(Size size, int type)**
> 
> **C++: static MatExpr Mat::zeros(int ndims, const int\* sizes, int type)**
> 
> **参数**
> 
> **ndims **– 数组的维数。
> 
> **rows**–行数。
> 
> **cols  **–列数。
> 
> **size**–替代矩阵大小规格Size(cols, rows)的方法。
> 
> **sizes**– 指定数组的形状的整数数组。
> 
> **type**– 创建的矩阵的类型。

该方法返回一个 Matlab 式的零数组初始值设定项。它可以用于快速形成一个常数数组作为函数参数，作为矩阵的表达式或矩阵初始值设定项的一部分。

Mat A；
    
    A = Mat::zeros （3，3，CV_32F）；

在上面的示例中，只要A不是 3 x 3浮点矩阵它就会被分配新的矩阵。否则为现有的矩阵 A填充零。

### Mat::ones ###

返回一个指定的大小和类型的全为1的数组。

> **C++: static MatExpr Mat::ones(int rows, int cols, int type)**
> 
> **C++: static MatExpr Mat::ones(Size size, int type)**
> 
> **C++: static MatExpr Mat::ones(int ndims, const int\* sizes, int type)**
> 
> **参数：**
> 
> **ndims** –数组的维数。
> 
> **rows** –行数。.
> 
> **cols** –列数。
> 
> **size** –替代矩阵大小规格Size(cols, rows)的方法。
> 
> **sizes** –指定数组的形状的整数数组。
> 
> **type** –创建的矩阵的类型。

该方法返回一个 Matlab 样式 1 的数组初始值设定项，类似Mat::zeros()。请注意，这种方法中你可以使用任意一个值和Matlab 语法初始化数组如下：

Mat A = Mat::ones (100，100，CV_8U) * 3 ；/ / 使100 x 100 矩阵里充满 3。

上述操作不会形成一个 100 x 100 1 的矩阵，然后乘以 3。相反，它只是记住缩放因子（在本例中 3）在实际调用矩阵初始值设定项时使用它。

### Mat::eye ###

返回一个恒等指定大小和类型矩阵。

> **C++: static MatExpr Mat::eye(int rows, int cols, inttype)**
> 
> **C++: static MatExpr Mat::eye(Size size, int type)**
> 
> **参数**
> 
> **rows** –的行数。
> 
> **cols**– 的列数。
> 
> **size **–替代矩阵大小规格Size(cols, rows)的方法。
> 
> **type** – 创建的矩阵的类型。

该方法返回 Matlab 式恒等矩阵初始值设定项，类似 Mat::zeros()和 Mat::ones()，你可以用缩放操作高效地创建缩放的恒等矩阵：

/ / 创建4 x 4 的对角矩阵并在对角线上以0.1的比率缩小。
    
    Mat A = Mat::eye(4, 4, CV_32F)*0.1;

### Mat::create ###

分配新的阵列数据 （如果需要）。

> **C++: void Mat::create(int rows, int cols, int type)**
> 
> **C++: void Mat::create(Size size, int type)**
> 
> **C++: void Mat::create(int ndims, const int\* sizes, inttype)**
> 
> **参数**
> 
> **ndims** – 新数组的维数。
> 
> **rows** –新的行数。
> 
> **cols** – 新的列数。
> 
> **size** – 替代新矩阵大小规格：Size(cols, rows)。
> 
> **sizes** – 指定一个新的阵列形状的整数数组。
> 
> **type** – 新矩阵的类型。

这是关键的Mat方法之一。大多数新样式 OpenCV 函数和产生阵列的方法每个输出数组都调用这个方法。此方法使用如下算法：

>  *  1.如果当前数组形状和类型匹配新的请立即返回。否则，通过调用 Mat::release()取消引用以前的数据。
>  *  2.初始化新矩阵头。
>  *  3.分配新的 total()\*elemSize() 个字节的数据空间。
>  *  4.分配新的关联数据的引用计数并将其设置为 1。

这项计划使内存管理强大高效同时还为用户减少了额外输入。这意味着通常不需要显式分配输出数组。也就是说，可以不写成：

Mat color;
    
    ...
    
    Mat gray(color.rows, color.cols,color.depth());
    
    cvtColor(color, gray, CV_BGR2GRAY);

而写成：

Mat color;
    
    ...
    
    Mat gray;
    
    cvtColor(color, gray, CV_BGR2GRAY);

因为 cvtColor，与大多数 OpenCV 函数相同，在输出数组时内部调用Mat::create()。

### Mat::addref ###

计数器参考。

> **C++: void Mat::addref()**

该方法递增与矩阵数据关联的引用计数。如果矩阵头指向外部的数据集（见 Mat::Mat()），则引用计数为 NULL，并且该方法在这种情况下不起作用。通常情况下，为避免内存泄漏，不应显式调用该方法。它是由该矩阵赋值运算符隐式调用。在支持的它平台上，引用计数器递增是一个原子操作。因此，对相同的矩阵，在不同的线程异步操作是安全的。

### Mat::release ###

在必要的情况下，递减引用计数并释放该矩阵。

> **C++: void Mat::release()**

该方法递减与矩阵的数据关联的引用计数。当引用计数减为0时，矩阵的数据将被释放，数据和引用计数器指针设置为 NULL。如果矩阵头指向外部数据集 （见 Mat::Mat()）， 引用计数为 NULL，并且该方法在这种情况下无效。

可以手动调用此方法强制矩阵数据释放。但由于这种方法在析构函数中是自动调用的，或以更改数据指针的其他方法，因此通常不需要调用这个函数。在支持它的平台上，引用计数器递减并检查是否为0 是一个原子操作。因此，在不同的线程异步调用相同的矩阵是安全的操作。

### Mat::resize ###

更改矩阵的行数。

> **C++: void Mat::resize(size\_t sz)**
> 
> **C++: void Mat::resize(size\_t sz, const Scalar& s)**
> 
> **参数**
> 
> **sz** –新的行数。
> 
> **s** –分配给新添加的元素的值。

该方法更改矩阵的行数。如果矩阵重新分配，第一最少(Mat::rows，sz) 行数要保留下来。该方法模拟相应的 STL 向量类的方法。

### Mat::reserve ###

保留一定数量的行的空间。

> **C++: void Mat::reserve(size\_t sz)**
> 
> **参数**
> 
> **sz** –的行数。

该方法sz行存储空间。如果矩阵已经有足够的空间来存储sz行，没有任何异常发生。如果矩阵重新分配，保留前（Mat::rows） 行。该方法模拟了相应的STL 向量类的方法。

### Mat::push\_back ###

将元素添加到矩阵的底部。

> **C++: template<typename T> voidMat::push\_back(const T& elem)**
> 
> **C++: void Mat::push\_back(const Mat& elem)**
> 
> **参数**
> 
> **elem** –增加的一个或多个元素。

该方法将一个或多个元素添加到矩阵的底部。他们是模拟相应的 STL 向量类的方法。元素为Mat时，其类型和列的数目必须和矩阵容器是相同的。

### Mat::pop\_back ###

从底部的列表中删除元素。

> **C++: template<typename T> voidMat::pop\_back(size\_t nelems=1)**
> 
> **参数**
> 
> **nelems** –删除的行的数目。如果它大于总的行数，则会引发异常。

该方法从底部的列表中删除一行或多行。

### Mat::locateROI ###

父矩阵内定位矩阵头。

> **C++: void Mat::locateROI(Size& wholeSize,Point& ofs) const**
> 
> **参数**
> 
> **wholeSize**–输出参数，其中包含的整个矩阵包含大小 \* 这是其中一部分。
> 
> **ofs** –输出参数包含\*this在整个的矩阵里面的偏移量。你使用Mat::row()、 Mat::col()、 Mat::rowRange()、Mat::colRange()以及其他的方法从矩阵中提取子阵后该结果子阵只指向原始大矩阵的一部分。然而，每个子阵包含有助于重建的最初矩阵大小和提取子阵在原始矩阵中的位置信息（由 datastart 和 dataend ﬁelds表示）。locateROI方法正是这样做的。

### Mat::adjustROI ###

调整子阵大小及其在父矩阵中的位置。

> **C++: Mat& Mat::adjustROI(int dtop, int dbottom,int dleft, int dright)**
> 
> **参数**
> 
> **dtop** –顶部子阵边界向上的平移量。
> 
> **dbottom** –底部子阵边界向下的平移量。
> 
> **dleft** –左子阵边界向左的平移量。
> 
> **dright** –右子阵边界向右的平移量。

该方法是 Mat::locateROI() 的互补性方法。这些函数的典型应用是确定父矩阵中子阵的位置，然后以某种方式改变位置。尤其典型的是，当滤镜操作中要考虑ROI外的像素时就需要它。当方法的所有参数都是正的时候，ROI需要以指定量全方位增长，例如：

> A.adjustROI(2, 2, 2,2);

在此示例中，每个方向 4 元素增加矩阵大小。矩阵向左侧和上侧分别平移2 个元素，这会产生5 x 5 内核的滤镜所需的所有像素。你的责任是确保 adjustROI 不超出父矩阵边界。如果超出，该函数发出错误提示。OpenCV的滤镜函数在内部调用该函数，像filter2D()，形态学的操作，等等。

copyMakeBorder()

### Mat::operator() ###

提取矩形子阵。

> **C++: Mat Mat::operator()(Range rowRange, RangecolRange) const**
> 
> **C++: Mat Mat::operator()(const Rect& roi) const**
> 
> **C++: Mat Mat::operator()(const Ranges\* ranges) const**
> 
> **参数：**
> 
> **rowRange** –提取的子阵的开始和结束的行。不包括的上限。若要选择的所有行，请使用 Range::all()。
> 
> **colRange** –提取的子阵的开始和结束的列。不包括的上限。若要选择的所有列，请使用 Range::all()。
> 
> roi – 抽出子阵 speciﬁed 作为一个矩形。
> 
> ranges – 选定范围沿每个数组维度的数组。

该运算符为\*this的子数组创建新的头。他们是Mat::row()、 Mat::col()、 Mat::rowRange()，和Mat::colRange()最普遍的形式。例如，A(Range(0, 10),Range::all()) 是相当于A.rowRange(0, 10)。与上述所有操作相同，该操作运算符是复杂度为O(1)的操作，就是没有矩阵数据将被复制。

### Mat::operator CvMat ###

创建矩阵 CvMat 头。

> **C++: Mat::operator CvMat() const**

该运算符创建矩阵 CvMat 的头，而不复制的基础数据。引用计数未被考虑到此操作中。因此，您应该确保CvMat 头在使用的时候不释放原始矩阵。该运算符对于新旧OpenCV API混用是有用的，例如：

Mat img(Size(320, 240), CV_8UC3);
    
    ...
    
    CvMat cvimg = img;
    
    mycvOldFunc( &cvimg, ...);

其中 mycvOldFunc 是用于OpenCV 1.x 数据结构的函数。

### Mat::operator IplImage ###

创建IplImage矩阵头。

> **C++: Mat::operator IplImage() const**

运算符创建矩阵 IplImage 头，而不复制的基础数据。您应该确保使用IplImage头时不释放原矩阵。与Mat::operatorCvMat类似，该运算符在OpenCV新旧API混用中很有用。

### Mat::total ###

返回数组元素的总数。

> **C++: size\_t Mat::total() const**

该方法返回数组元素（如果该数组表示图像的像素数）的数目。

### Mat::isContinuous ###

返回矩阵是否连续。

> **C++: bool Mat::isContinuous() const**

如果在每一行的结尾无间隙连续存储矩阵的元素，该方法返回 true。否则，它将返回 false。很明显，1 x 1 或 1xN 矩阵始终是连续的。使用 Mat::create() 创建矩阵是始终是连续的。但是，如果您提取的矩阵，使用 Mat::col()、 Mat::diag()，等等，或外部已分配的数据构造的矩阵头的一部分，那么这种矩阵可能不再具有此属性。连续性标记在Mat::flags域内用一个位存储，构造矩阵头时可以自动计算出来。因此，连续性检查是非常快速的操作，虽然理论上可以做，如下所示：

// 等价的Mat::isContinuous() 的执行情况
    
    boolmyCheckMatContinuity(const Mat& m)
    
    {
    
    //返回 (m.flags & Mat::CONTINUOUS_FLAG) != 0;
    
    return m.rows ==1 || m.step == m.cols*m.elemSize();
    
    }

很多的OpenCV 函数中使用该方法。关键在于按元素操作（如算术和逻辑运算、 数学函数、 alpha 融合、颜色空间转换，以及其他） 不依赖于图像的几何形状。因此，如果所有的输入和输出的阵列是连续的，该函数可以它们作为很长的单行的向量处理。下面的示例阐释了如何实现 alpha 融合功能。

void alphaBlendRGBA(const Mat& src1, const Mat& src2, Mat& dst)
    
    {
    
    	const float alpha_scale = (float)std::numeric_limits<T>::max(),
    
    		inv_scale = 1.f / alpha_scale;
    
    	CV_Assert(src1.type() == src2.type() &&
    
    		src1.type() == CV_MAKETYPE(DataType<T>::depth, 4) &&
    
    		src1.size() == src2.size());
    
    	Size size = src1.size();
    
    	dst.create(size, src1.type());
    
    	// 规定如下： 检查阵列的连续性
    
    	//如果的确如此，阵列连续
    
    	// 把阵列看做一维的向量。
    
    	if (src1.isContinuous() && src2.isContinuous() && dst.isContinuous())
    
    	{
    
    		size.width *= size.height;
    
    		size.height = 1;
    
    	}
    
    	size.width *= 4;
    
    	for (int i = 0; i < size.height; i++)
    
    	{// 当阵列连续,
    
    	 // 外循环只执行一次
    
    		const T* ptr1 = src1.ptr<T>(i);
    
    		const T* ptr2 = src2.ptr<T>(i);
    
    		T* dptr = dst.ptr<T>(i);
    
    		for (int j = 0; j < size.width; j += 4)
    
    		{
    
    			float alpha = ptr1[j + 3] * inv_scale, beta = ptr2[j + 3] * inv_scale;
    
    			dptr[j] = saturate_cast<T>(ptr1[j] * alpha + ptr2[j] * beta);
    
    			dptr[j + 1] = saturate_cast<T>(ptr1[j + 1] * alpha + ptr2[j + 1] * beta);
    
    			dptr[j + 2] = saturate_cast<T>(ptr1[j + 2] * alpha + ptr2[j + 2] * beta);
    
    			dptr[j + 3] = saturate_cast<T>((1 - (1 - alpha)*(1 - beta))*alpha_scale);
    
    		}
    
    	}
    
    }

这种方法，不仅很简单，而且在简单的元素的操作中可以提高10-20%性能，尤其在图像很小且操作非常简单的时候。

在此函数中另一个 OpenCV 语法，目标数组中Mat::create() 的调用会对没有适当大小和类型的目标数组分配空间。虽然新分配的数组始终是连续的，但您仍需要检查目标数组，因为 Mat::create()不是总会分配一个新的矩阵。

### Mat::elemSize ###

返回矩阵元素大小 （以字节为单位）。

> **C++: size\_t Mat::elemSize() const**

该方法返回以字节为单位的矩阵元素大小。例如，如果矩阵类型是 CV\_16SC3，该方法返回3\*sizeof(short)或 6。

### Mat::elemSize1 ###

以字节为单位返回每个矩阵元素通道的大小。

> **C++: size\_t Mat::elemSize1() const**

该方法返回以字节为单位的矩阵元素通道大小，也就是忽略通道的数量。例如， 如果矩阵类型是 CV\_16SC3，该方法返回 sizeof(short) 或 2。

### Mat::type ###

返回一个矩阵元素的类型。

> **C++: int Mat::type() const**

该方法返回一个矩阵的元素类型。这是兼容CvMat 类型系统，像 CV\_16SC3标识符或 16 位有符号的3 通道阵列，等等。

### Mat::depth ###

返回一个矩阵元素的深度。

> **C++: int Mat::depth() const**

该方法返回矩阵元素深度（每个单独的通道类型）的标识符。例如，对于16位有符号的3通道数组，该方法返回CV\_16S。矩阵类型的完整列表包含以下内容值：

>  *  • CV\_8U-8 位无符号整数 （0…..255）
>  *  • CV\_8S-8 位符号整数 （-128…..127）
>  *  • CV\_16U-16 位无符号整数 （0……65535）
>  *  • CV\_16S-16 位符号整数 （-32768…..32767）
>  *  • CV\_32S-32 位符号整数 （-2147483648……2147483647）
>  *  • CV\_32F-32 位浮点数 （-FLT\_MAX ………FLT\_MAX，INF，NAN)
>  *  • CV\_64F-64 位浮点数（-DBL\_MAX ……….DBL\_MAX，INF，NAN)

### Mat::channels ###

返回矩阵通道的数目。

> **C++: int Mat::channels() const**

该方法返回矩阵通道的数目。

### Mat::step1 ###

返回矩阵归一化迈出的一步。

> **C + +： size\_t const Mat::step1()**

该方法返回以矩阵的step除以Mat::elemSize1()。它对快速访问任意矩阵元素很有用。

### Mat::size ###

返回一个矩阵大小。

> **C++: Size Mat::size() const**

该方法返回一个矩阵大小：Size(cols, rows)。矩阵超过 2 维时返回大小为（-1，-1）。

### Mat::empty ###

如果数组有没有 elemens，则返回 true。

> **C++: bool Mat::empty() const**

如果 Mat::total() 是 0 或 Mat::data 为 NULL，则方法返回 true。因为pop\_back() 和 resize()方法M.total()= = 0，并不意味着M.data = =NULL。

### Mat::ptr ###

返回指定矩阵行的指针。

> **C++: uchar\* Mat::ptr(int i=0)**
> 
> **C++: const uchar\* Mat::ptr(int i=0) const**
> 
> **C++: template<typename \_Tp> \_Tp\* Mat::ptr(inti=0)**
> 
> **C++: template<typename \_Tp> const \_Tp\*Mat::ptr(int i=0) const**
> 
> **参数：**
> 
> **i** –一个基于0的行索引。

该方法返回uchar\*，或指向由输入指定矩阵行的指针。参看Mat::isContinuous()的中示例了解如何使用这些方法。

### Mat::at ###

返回对指定数组元素的引用。

> **C++: template<typename T> T& Mat::at(int i)const**
> 
> **C++: template<typename T> const T&Mat::at(int i) const**
> 
> **C++: template<typename T> T& Mat::at(int i,int j)**
> 
> **C++: template<typename T> const T&Mat::at(int i, int j) const**
> 
> **C++: template<typename T> T& Mat::at(Pointpt)**
> 
> **C++: template<typename T> const T&Mat::at(Point pt) const**
> 
> **C++: template<typename T> T& Mat::at(int i,int j, int k)**
> 
> **C++: template<typename T> const T&Mat::at(int i, int j, int k) const**
> 
> **C++: template<typename T> T& Mat::at(constint\* idx)**
> 
> **C++: template<typename T> const T&Mat::at(const int\* idx) const**
> 
> **参数**
> 
> **i** –索引 0 维度
> 
> **j** – 1 维度的索引
> 
> **k** – 沿 2 维度的索引
> 
> **pt** – Point(j,i) 作为指定元素的位置。
> 
> **idx** – Mat::dims 数组的索引。

该模板方法返回指定数组元素的引用。为了具有更高的性能，索引范围检查只在调试配置下执行。请注意使用具有单个索引 (i) 的变量可以访问的单行或单列的2 维的数组元素。也就是比方说，如果A是1 x N 浮点矩阵和B是M x 1的整数矩阵，您只需编写

A.at<float>(k+4) 和 B.at<int>(2*i+1) 分别代替A.at<float>(0,k+4)和
    
    B.at<int>(2*i+1,0)。

下面的示例将初始化希尔伯特矩阵：

Mat H(100, 100, CV_64F);
    for (inti = 0; i < H.rows; i++)
    	for (intj = 0; j < H.cols; j++)
    		H.at<double>(i, j) = 1. / (i + j + 1);

### Mat::begin ###

返回矩阵迭代器，并将其设置为第一矩阵元。

> **C++: template<typename \_Tp>MatIterator\_<\_Tp> Mat::begin()**
> 
> **C++: template<typename \_Tp>MatConstIterator\_<\_Tp> Mat::begin() const**

该方法返回矩阵的只读或读写的迭代器。矩阵迭代器的使用和双向 STL 迭代器的使用是非常相似的。在下面的示例中，alpha融合函数是使用矩阵迭代器重写：

template<typename T>
    void alphaBlendRGBA(const Mat& src1, const Mat& src2, Mat& dst)
    
    {
    
    	typedef Vec<T, 4> VT;
    
    	const float alpha_scale = (float)std::numeric_limits<T>::max(),
    
    		inv_scale = 1.f / alpha_scale;
    
    	CV_Assert(src1.type() == src2.type() &&
    
    		src1.type() == DataType<VT>::type&&
    
    		src1.size() == src2.size());
    
    	Size size = src1.size();
    
    	dst.create(size, src1.type());
    
    	MatConstIterator_<VT> it1 = src1.begin<VT>(), it1_end = src1.end<VT>();
    
    	MatConstIterator_<VT> it2 = src2.begin<VT>();
    
    	MatIterator_<VT> dst_it = dst.begin<VT>();
    
    	for (; it1 != it1_end; ++it1, ++it2, ++dst_it)
    
    	{
    
    		VT pix1 = *it1, pix2 = *it2;
    
    		float alpha = pix1[3] * inv_scale, beta = pix2[3] * inv_scale;
    
    		*dst_it = VT(saturate_cast<T>(pix1[0] * alpha + pix2[0] * beta),
    
    			saturate_cast<T>(pix1[1] * alpha + pix2[1] * beta),
    
    			saturate_cast<T>(pix1[2] * alpha + pix2[2] * beta),
    
    			saturate_cast<T>((1 - (1 - alpha)*(1 - beta))*alpha_scale));
    
    	}
    
    }

### Mat::end ###

返回矩阵迭代器，并将其设置为 最后元素之后（after-last）的矩阵元。

> **C++: template<typename \_Tp>MatIterator\_<\_Tp> Mat::end()**
> 
> **C++: template<typename \_Tp>MatConstIterator\_<\_Tp> Mat::end() const**

该方法返回矩阵只读或读写的迭代器，设置为紧随最后一个矩阵元素的点。

[0_1330856598Rylz.gif]: /images/20220617/bddde29cab294590bc356573eca8db3f.png
[0_1330856718K3Fi.gif]: /images/20220617/9556d092f4ee4b7182087e18047bb4e5.png
[0_1330856786g3zj.gif]: /images/20220617/fe7f2a7585da4f6497dd8908b9738389.png
[0_1330856884BYww.gif]: /images/20220617/619e4c7a270d41678ed2bc7c5ef87c52.png
[0_1330856939QWEY.gif]: /images/20220617/ad56583694f54a6c97eaecb42f4783d6.png
[0_13308569919F83.gif]: /images/20220617/18e3d86a60524491a3e0d62a08c09169.png
[0_1330857038cTxC.gif]: /images/20220617/c9d30b18b2244f7aa07e09ea8d3a5805.png
[0_1330857091Ppf8.gif]: /images/20220617/c421df1fa9b64e6d887e32a7e11f1869.png
[0_13308571511a4l.gif]: /images/20220617/af60d36270bb432eac01f283def8fa33.png
[0_13308572004nb4.gif]: /images/20220617/4578f0e97bdf40dcb7d9b9565f7c4f7c.png
[0_1330857246cmJy.gif]: /images/20220617/f894b4c83555401fa149db29313179d7.png
[0_1330857287d6Jp.gif]: /images/20220617/deae577025af4425baf2eccfdf01ba9a.png
[0_1330857327Aa11.gif]: /images/20220617/500eebcc2d6b4daa97ad35a28d14cce5.png
[0_1330857370a0AH.gif]: /images/20220617/db90bb39a342457d8337cd93c2bd7d7e.png
[0_1330855890ppPq.gif]: /images/20220617/263fd3b183c8463280bcb41af1efa551.png