opencv新版中最重要的一个类…

原文地址：opencv新版中最重要的一个类，Mat类详解作者：zlingh

http://docs.opencv.org/modules/core/doc/basic_structures.html?highlight=mat#Mat

类 Mat导言

OpenCV c + + n 维稠密数组类

类CV_EXPORTS Mat

{

public：

/ / … …很多的方法...

...

 

int flags;（Note：目前还不知道flags做什么用的）

//!数组的维数，> = 2

int dims ;

//!行和列的数量或(-1，-1) 此时数组已超过2 维

int rows,cols;

//!指向数据的指针

uchar *data ;

//!指针的引用计数器；

/ / 阵列指向用户分配的数据时，当指针为NULL

int * refcount ;

/ / 其他成员

...

};

Mat类表示一个n 维的密集数值单通道或多通道数组。它可以用于存储实数或复数值的向量和矩阵、灰度或彩色图像、体素、向量场、点云、张量、直方图（尽管较高维的直方图存储在SparseMat可能更好）。M 数组的数据布局是由阵列  M.step[]定义的，使元素的地址（i₀,。。。。i_M.dims-1),其中 0<=i_k < M.size[k]，可以计算为：

addr(Mi₀ ;:::;i_M.dims-1)= M.data+ M.step[ 0]*i₀ +M.step[ 1] *i₁ + .…+M.step[ M:dims- 1] i_{M:dims- 1}

2维的数组的情况下根据上述公式被减至：

addr( M_i,j)= M.data+ M.step[ 0]*i+ M.step[ 1]*j

请注意，M.step[i] > =M.step[i+1]（事实上，M.step[i] >=M.step[i+1]*M.size[i+1]）。这意味着2维矩阵是按行存储的，3 维矩阵是由平面存储，以此类推。M.step[M.dims-1] 是最小的而且总是等于元素大小M.elemSize()。因此，Mat中的数据布局完全兼容OpenCV 1.x 中CvMat、IplImage、CvMatND类型。它也和标准工具包和SDK，如Numpy（ndarray），Win32(独立设备位图)等主流的密集数组类型相兼容，也就是说，与任何使用步进（或步长）来计算像素位置的阵列相兼容。由于这种兼容性，使用户分配的数据创建Mat头以及用OpenCV函数实时处理该头成为可能。有很多不同的方法，创建一个Mat的对象。下面列出了最常见的选项：

使用 create（nrows,ncols,type）方法或类似的Mat（nrows,ncols,type [,fillValue])

构造函数。一个新的指定了大小和类型的数组被分配。type和cvCreateMat 方法中的type参数具有相同的含义。例如，CV_8UC1 是指一个8 位单通道阵列，CV_32FC2 指2 通道

(复)浮点阵列，以此类推。

//创建一个用1+3j填充的7 x 7 复矩阵。

Mat  M(7,7,CV_32FC2,Scalar(1,3));

/ /现在将M转换为100 x 60的CV_8UC(15)的矩阵。

/ / 旧内容将会被释放

M.create(100,60,CV_8UC(15)) ;

这一章导言中指出，当当前的数组与指定的数组的形状或类型create() 分配唯一的新数组时的形状或类型。

创建多维数组：

/ / 创建100 x 100 x 100 8 位数组

int sz[] = {100, 100, 100};

Mat. bigCube (3,sz,CV_8U,Scalar::all(0));它将维度数（= 1）传递给Mat的构造函数，但列数设置为 1时，创建数组将是2 维的。因此，Mat::dims 始终是>=2的(该数组为空时，也可以是0）。

使用的复制构造函数或赋值运算符可以是一个数组或右侧的表达式（请参阅

下图）。正像在导言中指出的，数组赋值运算复杂度是O(1)因为当你需要它的时候，它仅复制头和增加引用计数。Mat::clone() 方法可用于获取全（深）的副本数组。

为另一个数组的一部分构建头。它可以是单个行、单个列，几个行，几个列，矩形区域（代数中称为较小值）的数组或对角线。这种操作也是复杂度为O(1)，因为，新头引用相同的数据。实际上，您可以使用此特性修改该数组的一部分例如：

/ /第5行，乘以3，加到第3 行，

M.row(3) = M.row(3) + M.row (5) * 3 ;

/ / 现在将第7列复制到第1列

/ / M.col(1) = M.col(7) ;/ / 这个不能实现。

Mat  M1= M.col(1) ;

M.col(7).copyTo(M1) ;

/ / 创建一种新的320 x 240 图像

Mat img(Size(320,240),CV_8UC3) ;

/ / 选择ROI(region of interest)

Mat roi(img,Rect(10,10,100,100)) ;

/ / 填充（0,255,0）的ROI （这是RGB 空间中的绿色）；

/ / 320 x 240 原始图像将被修改。

roi = Scalar(0,255,0) ;

由于额外的datastart 和dataend 的成员，它们使得用locateROI() 计算子数组在主容器数组中的相对的位置成为可能：

Mat A = Mat::eye ( 10, 10, CV_32S）;

/ / 提取A 的1 （含）到3 （不包含）列。

Mat B = A(Range::all(),Range（1,3））;

/ / 提取B 的5 （含）到9 （不包含）行。

/ /即C ~ A（Range（5,9）,Range （1,3））

Mat C = B（Range（5,9）,Range::all()) ;

Size size;Point ofs;

C.locateROI （size,ofs）;

/ / size将变为(width= 10，height= 10），ofs会变为(x = 1，y = 5)

考虑到整个矩阵，如果您需要深层副本，使用子矩阵的sclone() 方法的提取。

为用户分配数据创建矩阵头。有利于执行下列操作：

1. 使用OpenCV处理"外来"的数据（例如，当您执行DirectShow *filter 或gstreamer的pro-cessing 模块，等等)。例如：

void process_video_frame (const unsignedchar *pixels,

int width,int height,int step)

{

Mat img (width,height, CV_8UC3,pixels,step);

GaussianBlur （img,img ,Size(7,7),1.5,1.5）;

}

2.快速初始化小矩阵和/或获取超快的元素的访问。

double m[3] [3] = {{a,b,c},{d,e,f} {g, h, i}}};

Mat M = Mat（3,3,CV_64F,m).inv() ;

本例中用户分配数据的一些很常见情况是从CvMat 和 IplImage 转换到Mat。为达到此目的，有些特殊的构造函数以指向CvMat 或 IplImage 和flag可选参数指示是否数据复制。从Mat到CvMat 或IplImage 的后台转换是通过类型转换运算符Mat::operator CvMat() const 和Mat::operator IplImage()实现的。operators不要复制数据。

IplImage * img =cvLoadImage("greatwave.jpg",1） ;

Mat mtx(img) ;/ / IplImage *->Mat

CvMat oldmat = mtx ;/ / Mat->CvMat

CV_Assert (oldmat.cols = = img->width&& oldmat.rows = =img-> height &&

oldmat.data.ptr = = (uchar *) img->imageData& & oldmat.step = =img-> widthStep）;

使用 MATLAB 样式数组初始值设定项zeros()、ones()、eye()，例如：

/ / 创建具双精度标识矩阵并将其添加到M。

M + = Mat::eye （M.rows,M.cols,CV_64F）;

使用逗号分隔的初始值设定项：

/ / 创建3 x 3 双精度恒等矩阵

Mat M = (Mat_ (3,3)<<1，0,0,0,1,0,0,0,1） ;

使用此方法，您首先调用具有适当的参数的Mat_类构造函数，然后只要把<< 运算符后面的值用逗号分隔，这些值可以是常量、变量、 表达式，等等。此外请注意所需的额外的圆括号（(Mat_(3，3)<< 1，0，0，0，1，0，0，0，1））以免出现编译错误。

数组一旦创建起来，它可以自动通过引用计数的机制被管理。如果数组头是在用户分配的数据的基础上构建的，您应该自己处理这些数据。当没有指向它的引用时，数组中的数据将被释放。如果在数组的析构函被调用之前要释放一个由矩阵头指向的数据，请使用Mat::release()。

掌握Array类的另一个重要的环节是元素的访问。本手册已经描述了如何计算每个数组元素的地址。通常情况下，不需要在代码中直接使用的公式。如果你知道数组元素类型（它可以使用Mat::type() 方法检索得到），您可以用以下方式访问二维数组的元素M_ij：

M.at (i,j)  + = 1.f ;

假定 M 一个双精度浮点型数组。有几个变体的不同方法来针对不同的维度数进行处理。

如果您要处理整行的二维数组，最有效的方式是获取该行的头指针然后只需使用普通的C运算符[]：

/ / 正矩阵元素之和计算

/ / （假定M 是一个双精度矩阵）

double sum = 0;

for (int i = 0 ;i < M.rows ; i ++)

{

const double *Mi = M.ptr (i) ;

    for (int j = 0; j < M.cols ; j + +)

sum + = std::max(Mi [j],0.）;

}

以上的操作中，某些操作实际上不依赖该数组的形状。他们只是一个接一个（或多个具有相同的坐标的多个数组中的元素，例如，数组相加）地处理数组元素。这种操作称为元素指向（element-wise）。检查是否所有的输入/输出阵列是连续的，即有没有间断在每行的结尾，是有意义的。如果是的话，将它们（这些数组）作为单独的一个长行来处理：

/ / 计算正矩阵元素，优化的变量的总和

double sum = 0;

int cols =M.cols,rows = M.rows ;

if(M.isContinuous())

{

    cols* = rows ;

    rows= 1 ;

}

for (int i = 0 ;i < rows; i + +)

{

const double * Mi = M.ptr (i) ;

for (int j = 0; j < cols ; j ++)

   sum += std::max (Mi [j],0.）;

}

对于连续的矩阵来说，外部循环体只需一次执行。所以，开销是规模较小，

小型矩阵的情况下尤其明显。

最后，还有足以成功跳过连续的行之间的间隔智能的STL 样式迭代器：

/ / 计算正矩阵元素和基于迭代器类型的变量之和

double sum = 0;

Mat Const Iterator_ it =M.begin (),it_end = M.end ();

for(; it! = it_end ; ++it）

sum+ = std::max (*it,0.）；

矩阵迭代器是随机存取的迭代器，所以他们可以被传递给任何STL 算法，包括std::sort()。

矩阵表达式

这是已经实现的可以组合在任意复杂的表达式中的矩阵运算操作，（此处 A 、B 的表示矩阵(Mat)、s表示标量（Scalar），alpha为实数标量（双精度型）：

  加法、减法、求反： A + B + A-B、A + s、A-s、s + A、s-A、-A；

  缩放： A * 阿尔法

  每个元素乘法和除法: A.mul (B)、A / B，alpha/A

  矩阵相乘： A * B

  大动脉转位： A.t() (指在)

 矩阵反演和伪反演，求解线性系统和最小二乘问题：

A.inv([method]) (~ A-1) , A.inv([method])*B (~ X:AX=B)

  比较： cmpop B、cmpop alpha、alpha cmpop A，其中cmpop 是以下几种运算符之一：>，> =，= =，! =，< =，<</span>。比较的结果是其元素设置为255的8 位单通道掩码（如果特殊元素对满足条件） 或 0。

  按位逻辑运算： logicop B、logicop s slogicop A、~ A，其中logicop 是以下运算符之一： &,|, ^.

  元素的最小值和最大值：分 （A、B）、民 （，alpha），最大值(A，B)，最大（，alpha）

  元素的绝对价值： abs(A)

  叉乘，点乘：A.cross(B) A.dot(B)

  任何标量与矩阵或矩阵的函数，返回一个矩阵或标量（scalar），如norm、, mean、sum、countNonZero、trace、determinant、repeat和其他。

  矩阵初始值设定项（Mat::eye()，Mat::zeros()，Mat::ones()）、矩阵以逗号分隔的初始值设定项、可提取sub-matrices的m atrix构造函数和运算符，（请参见Mat的说明）。

  Mat_ () 构造函数将结果强制转换为适当的类型。

Note：有些逗号分隔初始值设定项和一些其他的运算符可能需要显示调用Mat();或Mat_();的构造函数来解决可能产生的歧义。

        以下是一些矩阵表达式的例子：

//计算矩阵A的伪反演等价于A.inv(DECOMP_SVD)

SVD svd(A);

Mat pinvA=svd.vt.t()*Mat::diag(1./svd.w)*svd.u.t();

//计算莱文伯格-马夸特算法中的参数的新向量

x -= (A.t()*A+lambda*Mat::eye(A.cols,A.cols,A.type())).inv(DECOMP_CHOLESKY)*(A.t()*err);

//用“Unsharp Mask”算法锐化图像

Mat blurred; double sigma = 1, threshold =5, amount =1;

GaussianBlur(img, blurred, Size(), sigma,sigma);

Mat lowConstrastMask = abs(img - blurred)<threshold;

Mat sharpened = img*(1+amount)+blurred*(-amount);

img.copyTo(sharpened, lowContrastMask);

下面正式讲解Mat的各种方法。

Mat::Mat

各种Mat构造函数。

C++: Mat::Mat()

C++: Mat::Mat(int rows, int cols, int type)

C++: Mat::Mat(Size size, int type)

C++: Mat::Mat(int rows, int cols, int type,constScalar& s)

C++: Mat::Mat(Size size, int type,constScalar& s)

C++: Mat::Mat(const Mat& m)

C++: Mat::Mat(int rows, int cols, int type,void* data,size_t step=AUTO_STEP)

C++: Mat::Mat(Size size, int type, void*data, size_tstep=AUTO_STEP)

C++: Mat::Mat(const Mat& m,constRange& rowRange, const Range&colRange)

C++: Mat::Mat(const Mat& m,constRect& roi)

C++: Mat::Mat(const CvMat* m,boolcopyData=false)

C++: Mat::Mat(const IplImage* img,boolcopyData=false)

C++: templateexplicit Mat::Mat(const Vec&vec, bool copyData=true)

C++: template explicit Mat::Mat(const Matx&vec, bool copyData=true)

C++: template explicitMat::Mat(constvector& vec, bool copyData=false)

C++: Mat::Mat(const MatExpr&expr)

C++: Mat::Mat(int ndims, const int* sizes,inttype)

C++: Mat::Mat(int ndims, const int* sizes,int type, constScalar& s)

C++: Mat::Mat(int ndims, const int* sizes,int type, void*data, const size_t* steps=0)

C++: Mat::Mat(const Mat& m, constRange*ranges)

         参数

                            ndims–数组的维数.

rows – 2维数组中行行数

cols – Number of columnsin a 2D array.

size – 2维数组的尺寸Size(cols, rows) .在Size()构造函数中行数和列数在次序上刚好反转过来了。

sizes–指定n 维数组形状的整数数组。

type–数组的类型。使用CV_8UC1，… …，创建1-4 通道的矩阵，CV_64FC4 或CV_8UC(n)，… …，CV_64FC(n)可以创建多通道 （高达CV_MAX_CN 通道）矩阵。

s–一个可选的初始化每个矩阵元素的参数。要在矩阵建成后将所有元素设置为特定值可以用Mat的赋值运算符Mat:operator=(constScala&value)。

data–指向用户数据的指针。矩阵构造函数传入data和step参数不分配矩阵数据。相反，它们只是初始化矩阵头指向指定的数据，这意味着没有数据的复制。此操作是很高效的，可以用来处理使用OpenCV 函数的外部数据。外部数据不会自动释放，所以你应该小心处理它。

step–每个矩阵行占用的字节数。如果任何值应包括每行末尾的填充字节。如果缺少此参数（设置为AUTO_STEP），假定没有填充和实际的步长用cols*elemSize()计算。请参阅Mat::elemSize()。

steps–多维数组（最后一步始终设置为元素大小） 的情况下的 ndims-1个步长的数组。如果没有指定的话，该矩阵假定为连续。

m–分配给构造出来的矩阵的阵列（作为一个整体或部分）。这些构造函数没有复制数据。相反，指向m 的数据或它的子数组的头被构造并被关联到m上。引用计数器中无论如何都将递增。所以，当您修改矩阵的时候，自然而然就使用了这种构造函数，您还修改m 中的对应元素。如果你想要独立的子数组的副本，请使用Mat::clone()。

img –指向老版本的IplImage图像结构的指针。默认情况下，原始图像和新矩阵之间共享数据。但当copyData 被设置时，完整的图像数据副本就创建起来了。

vec–矩阵的元素构成的STL 向量。矩阵可以取出单独一列并且该列上的行数和矢量元素的数目相同。矩阵的类型匹配的向量元素的类型。构造函数可以处理任意的有正确声明的DataType类型。这意味着矢量元素不支持的混合型结构，它们必须是数据（numbers）原始数字或单型数值元组。对应的构造函数是显式的。由于STL 向量不会自动转换为Mat实例，您应显式编写Mat(vec)。除非您将数据复制到矩阵 （copyData = true），没有新的元素被添加到向量中，因为这样可能会造成矢量数据重新分配，并且因此使得矩阵的数据指针无效。

copyData –指定STL 向量或旧型CvMat 或IplImage是应复制到 (true)新构造的矩阵中 还是 (false) 与之共享基础数据的标志，复制数据时，使用Mat引用计数机制管理所分配的缓冲区。虽然数据共享的引用计数为NULL，但是分配数据必须在矩阵被析构之后才可以释放。

rowRange – m 的行数的取值范围。正常情况下，范围开始端具有包容性和范围结束端是独占的。使用Range::all() 来取所有的行。

colRange –m 列数的取值范围。使用Range::all() 来取所有的列。

ranges –表示M沿每个维度选定的区域的数组。

expr – 矩阵表达式。请参见矩阵表达式。

以上这些都是Mat形成一个矩阵的各类构造函数。如输出数据的自动分配中所提到的，往往默认构造函数就足够了，不同的矩阵可以由OpenCV 函数来分配数据空间。构造的矩阵可以进一步分配给另一个矩阵或矩阵表达或通过Mat::create()获配。在前一种情况，旧的内容是间接引用的。

Mat::~Mat

Mat的析构函数。

C++: Mat::~Mat()

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

Mat::operator =

提供矩阵赋值操作。

C++: Mat& Mat::operator=(constMat& m)

C++: Mat& Mat::operator=(constMatExpr_Base& expr)

C++: Mat& Mat::operator=(constScalar& 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_() const

转换运算符不能显示调用而是由矩阵表达式引擎（MatrixExpression engine）内部调用The castoperator should not be called explicitly. It is used internally bythe 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(constRange& 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(constRange& 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(constMat& 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, InputArraymask) const

参数：

m – 目标矩阵。如果它的尺寸和类型不正确，在操作之前会重新分配。

mask – 操作掩码。它的非零元素表示矩阵中某个要被复制。

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

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

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

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

Mat::convertTo

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

C++:

void Mat::convertTo(OutputArray m,int rtype,doublealpha=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 使用的由 MatrixExpressions引擎调用的方法。

Mat::setTo

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

C++: Mat& Mat::setTo(constScalar& s, InputArraymask=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 vec;

...

Mat pointMat = Mat(vec). //把向量转化成Mat,复杂度为O(1)的运算

reshape(1). // 从Nx1的3通道矩阵得出Nx3的单通道矩阵

//同样是复杂度为O(1)的运算

t(); // 最后转置Nx3的矩阵

//这个过程要复制所有的元素

Mat::t

转置矩阵。.

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

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

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 是 CholeskyLLT只适用于对称正矩阵的分解。该类型在处理大的矩阵时的速度是LU的两倍左右。

– DECOMP_SVD是 SVD分解。如果矩阵是单数或甚至不是2维，函数就会计算伪反转矩阵。

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

Mat::mul

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

C++: MatExpr Mat::mul(InputArray m, doublescale=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, inttype)

C++: static MatExpr Mat::zeros(int ndims, constint* 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, inttype)

C++: static MatExpr Mat::ones(int ndims, constint* 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 1001 的矩阵，然后乘以 3。相反，它只是记住

缩放因子（在本例中 3）在实际调用矩阵初始值设定项时使用它。