cv::Mat 类参考

n维密集数组类 更多...

#include <opencv2/core/mat.hpp>

cv::Mat 的协作图

公开类型
enum	{   MAGIC_VAL = 0x42FF0000 ,   AUTO_STEP (自动步长) = 0 ,   CONTINUOUS_FLAG = CV_MAT_CONT_FLAG ,   SUBMATRIX_FLAG = CV_SUBMAT_FLAG }
enum	{   MAGIC_MASK = 0xFFFF0000 ,   TYPE_MASK = 0x00000FFF ,   DEPTH_MASK (深度掩码) = 7 }

公开成员函数
	Mat () CV_NOEXCEPT
	Mat (const cuda::GpuMat &m)
	从 GpuMat 下载数据
	Mat (const Mat &m)
	Mat (const Mat &m, const Range &rowRange, const Range &colRange=Range::all())
	Mat (const Mat &m, const Range *ranges)
	Mat (const Mat &m, const Rect &roi)
	Mat (const Mat &m, const std::vector< Range > &ranges)
template<typename _Tp >
	Mat (const MatCommaInitializer_< _Tp > &commaInitializer)
template<typename _Tp , int m, int n>
	Mat (const Matx< _Tp, m, n > &mtx, bool copyData=true)
template<typename _Tp >
	Mat (const Point3_< _Tp > &pt, bool copyData=true)
template<typename _Tp >
	Mat (const Point_< _Tp > &pt, bool copyData=true)
template<typename _Tp , size_t _Nm>
	Mat (const std::array< _Tp, _Nm > &arr, bool copyData=false)
template<typename _Tp , typename = typename std::enable_if<std::is_arithmetic<_Tp>::value>::type>
	Mat (const std::initializer_list< _Tp > list)
template<typename _Tp >
	Mat (const std::initializer_list< int > sizes, const std::initializer_list< _Tp > list)
template<typename _Tp >
	Mat (const std::vector< _Tp > &vec, bool copyData=false)
	Mat (const std::vector< int > &sizes, int type)
	Mat (const std::vector< int > &sizes, int type, const Scalar &s)
	Mat (const std::vector< int > &sizes, int type, void *data, const size_t *steps=0)
template<typename _Tp , int n>
	Mat (const Vec< _Tp, n > &vec, bool copyData=true)
	Mat (int ndims, const int *sizes, int type)
	Mat (int ndims, const int *sizes, int type, const Scalar &s)
	Mat (int ndims, const int *sizes, int type, void *data, const size_t *steps=0)
	Mat (int rows, int cols, int type)
	Mat (int rows, int cols, int type, const Scalar &s)
	Mat (int rows, int cols, int type, void *data, size_t step=AUTO_STEP)
	Mat (Mat &&m) CV_NOEXCEPT
	Mat (Size size, int type)
	Mat (Size size, int type, const Scalar &s)
	Mat (Size size, int type, void *data, size_t step=AUTO_STEP)
	~Mat ()
	析构函数 - 调用 release()
void	addref (增加引用) ()
	增加引用计数。
Mat &	adjustROI (int dtop, int dbottom, int dleft, int dright)
	调整父矩阵中子矩阵的大小和位置。
void	assignTo (Mat &m, int type=-1) const
	提供 convertTo 的函数形式。
template<typename _Tp >
_Tp &	at (const int *idx)
template<typename _Tp >
const _Tp &	at (const int *idx) const
template<typename _Tp , int n>
_Tp &	at (const Vec< int, n > &idx)
template<typename _Tp , int n>
const _Tp &	at (const Vec< int, n > &idx) const
template<typename _Tp >
_Tp &	at (int i0, int i1, int i2)
template<typename _Tp >
const _Tp &	at (int i0, int i1, int i2) const
template<typename _Tp >
_Tp &	at (int i0=0)
	返回对指定数组元素的引用。
template<typename _Tp >
const _Tp &	at (int i0=0) const
template<typename _Tp >
_Tp &	at (int row, int col)
template<typename _Tp >
const _Tp &	at (int row, int col) const
template<typename _Tp >
_Tp &	at (Point pt)
template<typename _Tp >
const _Tp &	at (Point pt) const
template<typename _Tp >
MatIterator_< _Tp >	begin (起始迭代器) ()
	返回矩阵迭代器并将其设置为第一个矩阵元素。
template<typename _Tp >
MatConstIterator_< _Tp >	begin () const
int	channels () const
	返回矩阵通道数。
int	checkVector (int elemChannels, int depth=-1, bool requireContinuous=true) const
CV_NODISCARD_STD Mat	clone () const
	创建数组及其底层数据的完整副本。
Mat	col (int x) const
	为指定的矩阵列创建矩阵头。
Mat	colRange (const Range &r) const
Mat	colRange (int startcol, int endcol) const
	为指定的列范围创建矩阵头。
void	convertTo (OutputArray m, int rtype, double alpha=1, double beta=0) const
	将数组转换为另一种数据类型，并可选择缩放。
void	copyAt (OutputArray m) const
	覆盖现有矩阵。
void	copyAt (OutputArray m, InputArray mask) const
void	copySize (const Mat &m)
	内部使用函数；正确地重新分配 _size, _step 数组
void	copyTo (OutputArray m) const
	将矩阵复制到另一个矩阵。
void	copyTo (OutputArray m, InputArray mask) const
void	create (const std::vector< int > &sizes, int type)
void	create (int ndims, const int *sizes, int type)
void	create (int rows, int cols, int type)
	如果需要，分配新的数组数据。
void	create (Size size, int type)
Mat	cross (InputArray m) const
	计算两个 3 元素向量的叉乘。
void	deallocate (反分配) ()
	内部使用函数，建议改用 'release' 方法；释放矩阵数据
int	depth () const
	返回矩阵元素的深度。
Mat	diag (int d=0) const
	从矩阵中提取对角线。
double	dot (InputArray m) const
	计算两个向量的点积。
size_t	elemSize () const
	以字节为单位返回矩阵元素大小。
size_t	elemSize1 () const
	返回矩阵每个元素通道的大小（字节）。
bool	empty () const
	如果数组没有元素，则返回 true。
template<typename _Tp >
MatIterator_< _Tp >	end (结束迭代器) ()
	返回矩阵迭代器并将其设置为最后一个矩阵元素之后的位置。
template<typename _Tp >
MatConstIterator_< _Tp >	end () const
template<typename _Tp , typename Functor >
void	forEach (const Functor &operation)
	并行地对所有矩阵元素运行给定的仿函数。
template<typename _Tp , typename Functor >
void	forEach (const Functor &operation) const
UMat	getUMat (AccessFlag accessFlags, UMatUsageFlags usageFlags=USAGE_DEFAULT) const
	从 Mat 检索 UMat
MatExpr (矩阵表达式)	inv (int method=DECOMP_LU) const
	矩阵求逆。
bool	isContinuous () const
	报告矩阵是否连续。
bool	isSubmatrix () const
	如果矩阵是另一个矩阵的子矩阵，则返回 true
void	locateROI (Size &wholeSize, Point &ofs) const
	在父矩阵中定位矩阵头。
MatExpr (矩阵表达式)	mul (InputArray m, double scale=1) const
	执行两个矩阵的逐元素乘法或除法。
template<typename _Tp , int m, int n>
	operator Matx< _Tp, m, n > () const
template<typename _Tp , std::size_t _Nm>
	operator std::array< _Tp, _Nm > () const
template<typename _Tp >
	operator std::vector< _Tp > () const
template<typename _Tp , int n>
	operator Vec< _Tp, n > () const
Mat	operator() (const Range *ranges) const
Mat	operator() (const Rect &roi) const
Mat	operator() (const std::vector< Range > &ranges) const
Mat	operator() (Range rowRange, Range colRange) const
	提取一个矩形子矩阵。
Mat &	operator= (const Mat &m)
	赋值操作符
Mat &	operator= (const MatExpr &expr)
Mat &	operator= (const Scalar &s)
	将所有或部分数组元素设置为指定值。
Mat &	operator= (Mat &&m)
void	pop_back (size_t nelems=1)
	从矩阵底部移除元素。
uchar *	ptr (const int *idx)
template<typename _Tp >
_Tp *	ptr (const int *idx)
const uchar *	ptr (const int *idx) const
template<typename _Tp >
const _Tp *	ptr (const int *idx) const
template<int n>
uchar *	ptr (const Vec< int, n > &idx)
template<typename _Tp , int n>
_Tp *	ptr (const Vec< int, n > &idx)
template<int n>
const uchar *	ptr (const Vec< int, n > &idx) const
template<typename _Tp , int n>
const _Tp *	ptr (const Vec< int, n > &idx) const
uchar *	ptr (int i0, int i1, int i2)
template<typename _Tp >
_Tp *	ptr (int i0, int i1, int i2)
const uchar *	ptr (int i0, int i1, int i2) const
template<typename _Tp >
const _Tp *	ptr (int i0, int i1, int i2) const
uchar *	ptr (int i0=0)
	返回指向指定矩阵行的指针。
template<typename _Tp >
_Tp *	ptr (int i0=0)
const uchar *	ptr (int i0=0) const
template<typename _Tp >
const _Tp *	ptr (int i0=0) const
uchar *	ptr (int row, int col)
template<typename _Tp >
_Tp *	ptr (int row, int col)
const uchar *	ptr (int row, int col) const
template<typename _Tp >
const _Tp *	ptr (int row, int col) const
template<typename _Tp >
void	push_back (const _Tp &elem)
	向矩阵底部添加元素。
void	push_back (const Mat &m)
template<typename _Tp >
void	push_back (const Mat_< _Tp > &elem)
template<typename _Tp >
void	push_back (const std::vector< _Tp > &elem)
void	push_back_ (const void *elem)
	内部函数
template<typename _Tp >
std::reverse_iterator< MatIterator_< _Tp > >	rbegin (反向起始迭代器) ()
	与 begin() 相同，但用于反向遍历。
template<typename _Tp >
std::reverse_iterator< MatConstIterator_< _Tp > >	rbegin () const
Mat	reinterpret (int type) const
	重置矩阵类型。
void	release (释放) ()
	递减引用计数器，如果需要，反分配矩阵。
template<typename _Tp >
std::reverse_iterator< MatIterator_< _Tp > >	rend (反向结束迭代器) ()
	与 end() 相同，但用于反向遍历。
template<typename _Tp >
std::reverse_iterator< MatConstIterator_< _Tp > >	rend () const
void	reserve (size_t sz)
	为特定数量的行预留空间。
void	reserveBuffer (size_t sz)
	为特定数量的字节预留空间。
Mat	reshape (int cn, const std::vector< int > &newshape) const
Mat	reshape (int cn, int newndims, const int *newsz) const
Mat	reshape (int cn, int rows=0) const
	在不复制数据的情况下更改 2D 矩阵的形状和/或通道数。
void	resize (size_t sz)
	更改矩阵行数。
void	resize (size_t sz, const Scalar &s)
Mat	row (int y) const
	为指定的矩阵行创建矩阵头。
Mat	rowRange (const Range &r) const
Mat	rowRange (int startrow, int endrow) const
	为指定的行范围创建矩阵头。
Mat &	setTo (InputArray value, InputArray mask=noArray())
	将所有或部分数组元素设置为指定值。
size_t	step1 (int i=0) const
	返回归一化的步长。
MatExpr (矩阵表达式)	t () const
	矩阵转置。
size_t	total () const
	返回数组元素的总数。
size_t	total (int startDim, int endDim=INT_MAX) const
	返回数组元素的总数。
int	type () const
	返回矩阵元素的类型。
void	updateContinuityFlag (更新连续性标志) ()
	内部使用方法：更新连续性标志

静态公开成员函数
static CV_NODISCARD_STD Mat	diag (const Mat &d)
	创建对角矩阵
static CV_NODISCARD_STD MatExpr	eye (int rows, int cols, int type)
	返回指定大小和类型的单位矩阵。
static CV_NODISCARD_STD MatExpr	eye (Size size, int type)
static MatAllocator *	getDefaultAllocator (获取默认分配器) ()
static MatAllocator *	getStdAllocator (获取标准分配器) ()
	以及标准分配器
static CV_NODISCARD_STD MatExpr	ones (int ndims, const int *sz, int type)
static CV_NODISCARD_STD MatExpr	ones (int rows, int cols, int type)
	返回指定大小和类型的全1数组。
static CV_NODISCARD_STD MatExpr	ones (Size size, int type)
static void	setDefaultAllocator (MatAllocator *allocator)
static CV_NODISCARD_STD MatExpr	zeros (int ndims, const int *sz, int type)
static CV_NODISCARD_STD MatExpr	zeros (int rows, int cols, int type)
	返回一个指定大小和类型的全 0 数组。
static CV_NODISCARD_STD MatExpr	zeros (Size size, int type)

公开属性
MatAllocator *	allocator
	自定义分配器
int	cols (列数)
uchar *	data (数据)
	指向数据的指针
const uchar *	dataend (数据结束)
const uchar *	datalimit (数据限制)
const uchar *	datastart (数据起始)
	在 locateROI 和 adjustROI 中使用的辅助字段
int	dims (维度)
	矩阵维度，>= 2
int	flags (标志)
int	rows (行数)
	行数和列数，当矩阵超过 2 维时为 (-1, -1)
MatSize	size (大小)
MatStep	step (步长)
UMatData *	u
	与 UMat 的交互

保护成员函数
template<typename _Tp , typename Functor >
void	forEach_impl (const Functor &operation)

详细说明

n维密集数组类

类 Mat 表示一个 n 维密集数值单通道或多通道数组。它可以用于存储实数或复数向量和矩阵、灰度或彩色图像、体素体积、向量场、点云、张量、直方图（尽管极高维的直方图可能更适合存储在 SparseMat 中）。数组 M 的数据布局由数组 M.step[] 定义，因此元素 \((i_0,...,i_{M.dims-1})\) 的地址（其中 \(0\leq i_k<M.size[k]\)）计算如下：

\[addr(M_{i_0,...,i_{M.dims-1}}) = M.data + M.step[0]*i_0 + M.step[1]*i_1 + ... + M.step[M.dims-1]*i_{M.dims-1}\]

对于二维数组，上述公式简化为：

\[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]）。这意味着二维矩阵是逐行存储的，三维矩阵是逐面存储的，依此类推。M.step[M.dims-1] 是最小的，且始终等于元素大小 M.elemSize()。

因此，Mat 中的数据布局与来自标准工具包和 SDK 的大多数密集数组类型兼容，例如 Numpy (ndarray)、Win32（设备无关位图）等，即与任何使用 steps（或 strides）来计算像素位置的数组兼容。由于这种兼容性，可以为用户分配的数据创建一个 Mat 头，并使用 OpenCV 函数进行就地处理。

创建 Mat 对象有许多不同的方法。最常用的选项列在下面：

• 使用 create(nrows, ncols, type) 方法或类似的 Mat(nrows, ncols, type[, fillValue]) 构造函数。系统会分配一个指定大小和类型的新数组。type 的含义与 cvCreateMat 方法中的相同。例如，CV_8UC1 表示 8 位单通道数组，CV_32FC2 表示 2 通道（复数）浮点数组，依此类推。

  // 创建一个填充了 1+3j 的 7x7 复数矩阵。
  Mat M(7,7,CV_32FC2,Scalar(1,3));
  // 现在将 M 转换为 100x60 的 15 通道 8 位矩阵。
  // 旧内容将被释放
  M.create(100,60,CV_8UC(15));

  正如本章引言中所述，只有当当前数组的形状或类型与指定的不同时，create() 才会分配新数组。
• 创建一个多维数组

  // 创建一个 100x100x100 的 8 位数组
  int sz[] = {100, 100, 100};
  Mat bigCube(3, sz, CV_8U, Scalar::all(0));

  它向 Mat 构造函数传递维数 =1，但创建的数组将是二维的，列数设为 1。因此，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);
  // 创建一个新的 320x240 图像
  Mat img(Size(320,240),CV_8UC3);
  // 选择一个 ROI (感兴趣区域)
  Mat roi(img, Rect(10,10,100,100));
  // 将 ROI 填充为 (0,255,0)（在 RGB 空间中为绿色）；
  // 原始的 320x240 图像将被修改
  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)

  与整个矩阵的情况一样，如果需要深拷贝，请使用提取出的子矩阵的 clone() 方法。
• 为用户分配的数据创建一个头。执行以下操作可能会很有用：
  1. 使用 OpenCV 处理“外部”数据（例如，当你实现 DirectShow* 过滤器或 gstreamer 的处理模块等时）。例如：

     Mat process_video_frame(const unsigned char* pixels,
                             int width, int height, int step)
     {
         // 包装输入缓冲区
         Mat img(height, width, CV_8UC3, (unsigned char*)pixels, step);
      
         Mat result;
         GaussianBlur(img, result, Size(7, 7), 1.5, 1.5);
      
         return result;
     }

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

     double m[3][3] = {{a, b, c}, {d, e, f}, {g, h, i}};
     Mat M = Mat(3, 3, CV_64F, m).inv();

• 使用 MATLAB 风格的数组初始化器，例如 zeros(), ones(), eye()：

  // 创建一个双精度单位矩阵并将其加到 M。
  M += Mat::eye(M.rows, M.cols, CV_64F);

• 使用逗号分隔的初始化器：

  // 创建一个 3x3 双精度单位矩阵
  Mat M = (Mat_<double>(3,3) << 1, 0, 0, 0, 1, 0, 0, 0, 1);

  使用这种方法，你首先使用适当的参数调用 Mat 类的构造函数，然后紧接 << 运算符，后面跟上由逗号分隔的值，这些值可以是常量、变量、表达式等。此外，请注意需要额外的括号以避免编译错误。

数组创建后，将通过引用计数机制自动管理。如果数组头是建立在用户分配的数据之上的，你应该自己处理这些数据。当没有对象指向数组数据时，数据将被释放。如果你想在调用数组析构函数之前释放数组头指向的数据，请使用 Mat::release()。

关于数组类，下一个要学习的重要内容是元素访问。本手册已经介绍了如何计算每个数组元素的地址。通常，你不必直接在代码中使用该公式。如果你知道数组元素类型（可以使用方法 Mat::type() 检索），你可以访问二维数组的元素 \(M_{ij}\)，如下所示：

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

假设 M 是一个双精度浮点数组。针对不同的维数，at 方法有几种变体。

如果你需要处理 2D 数组的整行，最有效的方法是先获取指向该行的指针，然后直接使用普通的 C 运算符 []：

// 计算正矩阵元素的总和
// （假设 M 是双精度矩阵）
double sum=0;
for(int i = 0; i < M.rows; i++)
{
    const double* Mi = M.ptr<double>(i);
    for(int j = 0; j < M.cols; j++)
        sum += std::max(Mi[j], 0.);
}

某些操作（如上述操作）实际上并不依赖于数组形状。它们只是逐个处理数组的元素（或者来自具有相同坐标的多个数组的元素，例如数组加法）。此类操作称为 逐元素 操作。检查所有输入/输出数组是否连续（即每行末尾没有间隙）是有意义的。如果是，则可以将它们作为一个长单行处理：

// 计算正矩阵元素的总和，优化变体
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<double>(i);
    for(int j = 0; j < cols; j++)
        sum += std::max(Mi[j], 0.);
}

在连续矩阵的情况下，外层循环体仅执行一次。因此，开销更小，这在小矩阵的情况下尤为明显。

最后，还有 STL 风格的迭代器，它们足够智能，可以跳过连续行之间的间隙：

// 计算正矩阵元素的总和，基于迭代器的变体
double sum=0;
MatConstIterator_<double> it = M.begin<double>(), it_end = M.end<double>();
for(; it != it_end; ++it)
    sum += std::max(*it, 0.);

矩阵迭代器是随机访问迭代器，因此它们可以传递给任何 STL 算法，包括 std::sort()。

注意

矩阵表达式和算术运算详见 MatExpr

示例

示例文件：fld_lines.cpp, modules/shape/samples/shape_example.cpp, samples/cpp/camshiftdemo.cpp, samples/cpp/connected_components.cpp, samples/cpp/contours2.cpp, samples/cpp/convexhull.cpp, samples/cpp/cout_mat.cpp, samples/cpp/create_mask.cpp, samples/cpp/demhist.cpp, samples/cpp/distrans.cpp, samples/cpp/edge.cpp, samples/cpp/facedetect.cpp, samples/cpp/falsecolor.cpp, samples/cpp/ffilldemo.cpp, samples/cpp/fitellipse.cpp, samples/cpp/grabcut.cpp, samples/cpp/image_alignment.cpp, samples/cpp/intersectExample.cpp, samples/cpp/kalman.cpp, samples/cpp/kmeans.cpp, samples/cpp/laplace.cpp, samples/cpp/lkdemo.cpp, samples/cpp/lsd_lines.cpp, samples/cpp/minarea.cpp, samples/cpp/pca.cpp, samples/cpp/peopledetect.cpp, samples/cpp/polar_transforms.cpp, samples/cpp/segment_objects.cpp, samples/cpp/stitching.cpp, samples/cpp/stitching_detailed.cpp, samples/cpp/train_HOG.cpp, samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp, samples/cpp/tutorial_code/ImgProc/Morphology_1.cpp, samples/cpp/tutorial_code/ImgProc/Morphology_2.cpp, samples/cpp/tutorial_code/ImgProc/Pyramids/Pyramids.cpp, samples/cpp/tutorial_code/ImgProc/Smoothing/Smoothing.cpp, samples/cpp/tutorial_code/ImgProc/basic_drawing/Drawing_1.cpp, samples/cpp/tutorial_code/ImgProc/basic_drawing/Drawing_2.cpp, samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp, samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp, samples/cpp/tutorial_code/ImgTrans/houghcircles.cpp, samples/cpp/tutorial_code/ImgTrans/houghlines.cpp, samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp, samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp, samples/cpp/tutorial_code/features2D/Homography/decompose_homography.cpp, samples/cpp/tutorial_code/features2D/Homography/homography_from_camera_displacement.cpp, samples/cpp/tutorial_code/features2D/Homography/pose_from_homography.cpp, samples/cpp/tutorial_code/imgcodecs/animations.cpp, samples/cpp/tutorial_code/ml/introduction_to_pca/introduction_to_pca.cpp, samples/cpp/tutorial_code/photo/non_photorealistic_rendering/npr_demo.cpp, samples/cpp/tutorial_code/photo/seamless_cloning/cloning_demo.cpp, samples/cpp/tutorial_code/videoio/video-write/video-write.cpp, samples/cpp/videowriter_basic.cpp, samples/cpp/warpPerspective_demo.cpp, samples/cpp/watershed.cpp, samples/dnn/classification.cpp, samples/dnn/colorization.cpp, samples/dnn/object_detection.cpp, samples/dnn/openpose.cpp, samples/dnn/segmentation.cpp, 以及 samples/dnn/text_detection.cpp。

成员枚举文档

匿名枚举

匿名枚举

枚举值 (Enumerator)
MAGIC_VAL
AUTO_STEP
CONTINUOUS_FLAG
SUBMATRIX_FLAG

匿名枚举

匿名枚举

枚举值 (Enumerator)
MAGIC_MASK
TYPE_MASK
DEPTH_MASK

构造函数与析构函数说明

Mat() [1/29]

cv::Mat::Mat

(

)

这些是构成矩阵的各种构造函数。正如在 AutomaticAllocation（自动分配）中所述，默认构造函数通常已经足够，OpenCV 函数将分配适当的矩阵。构造的矩阵可以进一步赋值给另一个矩阵或矩阵表达式，或者使用 Mat::create 进行分配。在前一种情况下，旧内容将被取消引用。

Mat() [2/29]

cv::Mat::Mat	(	int	rows (行数),
		int	cols (列数),
		int	type )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

rows (行数)	2D 数组中的行数。
cols (列数)	2D 数组中的列数。
type	数组类型。使用 CV_8UC1, ..., CV_64FC4 创建 1-4 通道矩阵，或使用 CV_8UC(n), ..., CV_64FC(n) 创建多通道（最多 CV_CN_MAX 通道）矩阵。

Mat() [3/29]

cv::Mat::Mat	(	Size	size (大小),
		int	type )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

size (大小)	2D 数组大小：Size(cols, rows)。在 Size() 构造函数中，行数和列数的顺序相反。
type	数组类型。使用 CV_8UC1, ..., CV_64FC4 创建 1-4 通道矩阵，或使用 CV_8UC(n), ..., CV_64FC(n) 创建多通道（最多 CV_CN_MAX 通道）矩阵。

Mat() [4/29]

cv::Mat::Mat	(	int	rows (行数),
		int	cols (列数),
		int	type,
		const Scalar &	s )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

rows (行数)	2D 数组中的行数。
cols (列数)	2D 数组中的列数。
type	数组类型。使用 CV_8UC1, ..., CV_64FC4 创建 1-4 通道矩阵，或使用 CV_8UC(n), ..., CV_64FC(n) 创建多通道（最多 CV_CN_MAX 通道）矩阵。
s	用于初始化每个矩阵元素的可选值。要在构造后将所有矩阵元素设置为特定值，请使用赋值运算符 Mat::operator=(const Scalar& value)。

Mat() [5/29]

cv::Mat::Mat	(	Size	size (大小),
		int	type,
		const Scalar &	s )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

size (大小)	2D 数组大小：Size(cols, rows)。在 Size() 构造函数中，行数和列数的顺序相反。
type	数组类型。使用 CV_8UC1, ..., CV_64FC4 创建 1-4 通道矩阵，或使用 CV_8UC(n), ..., CV_64FC(n) 创建多通道（最多 CV_CN_MAX 通道）矩阵。
s	用于初始化每个矩阵元素的可选值。要在构造后将所有矩阵元素设置为特定值，请使用赋值运算符 Mat::operator=(const Scalar& value)。

Mat() [6/29]

cv::Mat::Mat	(	int	ndims,
		const int *	sizes (大小列表),
		int	type )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

ndims	数组维数。
sizes (大小列表)	指定 n 维数组形状的整数数组。
type	数组类型。使用 CV_8UC1, ..., CV_64FC4 创建 1-4 通道矩阵，或使用 CV_8UC(n), ..., CV_64FC(n) 创建多通道（最多 CV_CN_MAX 通道）矩阵。

Mat() [7/29]

cv::Mat::Mat	(	const std::vector< int > &	sizes (大小列表),
		int	type )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

sizes (大小列表)	指定 n 维数组形状的整数数组。
type	数组类型。使用 CV_8UC1, ..., CV_64FC4 创建 1-4 通道矩阵，或使用 CV_8UC(n), ..., CV_64FC(n) 创建多通道（最多 CV_CN_MAX 通道）矩阵。

Mat() [8/29]

cv::Mat::Mat	(	int	ndims,
		const int *	sizes (大小列表),
		int	type,
		const Scalar &	s )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

ndims	数组维数。
sizes (大小列表)	指定 n 维数组形状的整数数组。
type	数组类型。使用 CV_8UC1, ..., CV_64FC4 创建 1-4 通道矩阵，或使用 CV_8UC(n), ..., CV_64FC(n) 创建多通道（最多 CV_CN_MAX 通道）矩阵。
s	用于初始化每个矩阵元素的可选值。要在构造后将所有矩阵元素设置为特定值，请使用赋值运算符 Mat::operator=(const Scalar& value)。

Mat() [9/29]

cv::Mat::Mat	(	const std::vector< int > &	sizes (大小列表),
		int	type,
		const Scalar &	s )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

sizes (大小列表)	指定 n 维数组形状的整数数组。
type	数组类型。使用 CV_8UC1, ..., CV_64FC4 创建 1-4 通道矩阵，或使用 CV_8UC(n), ..., CV_64FC(n) 创建多通道（最多 CV_CN_MAX 通道）矩阵。
s	用于初始化每个矩阵元素的可选值。要在构造后将所有矩阵元素设置为特定值，请使用赋值运算符 Mat::operator=(const Scalar& value)。

Mat() [10/29]

cv::Mat::Mat

(

const Mat &

m

)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

m	（全部或部分）分配给构造矩阵的数组。这些构造函数不会拷贝数据。相反，它会构造并关联一个指向 m 数据或其子数组的头。引用计数（如果有）会递增。因此，当你修改使用此类构造函数形成的矩阵时，你也修改了 m 的相应元素。如果你想要一个子数组的独立拷贝，请使用 Mat::clone()。

Mat() [11/29]

cv::Mat::Mat	(	int	rows (行数),
		int	cols (列数),
		int	type,
		void *	data (数据),
		size_t	step = AUTO_STEP )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

rows (行数)	2D 数组中的行数。
cols (列数)	2D 数组中的列数。
type	数组类型。使用 CV_8UC1, ..., CV_64FC4 创建 1-4 通道矩阵，或使用 CV_8UC(n), ..., CV_64FC(n) 创建多通道（最多 CV_CN_MAX 通道）矩阵。
data (数据)	指向用户数据的指针。接收 data 和 step 参数的矩阵构造函数不会分配矩阵数据。相反，它们只是初始化指向指定数据的矩阵头，这意味着不会拷贝数据。此操作非常高效，可用于使用 OpenCV 函数处理外部数据。外部数据不会自动释放，因此你应该负责处理它。
step (步长)	每个矩阵行占用的字节数。该值应包括每行末尾的填充字节（如果有）。如果缺少该参数（设置为 AUTO_STEP），则假定没有填充，实际步长计算为 cols*elemSize()。见 Mat::elemSize。

Mat() [12/29]

cv::Mat::Mat	(	Size	size (大小),
		int	type,
		void *	data (数据),
		size_t	step = AUTO_STEP )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

size (大小)	2D 数组大小：Size(cols, rows)。在 Size() 构造函数中，行数和列数的顺序相反。
type	数组类型。使用 CV_8UC1, ..., CV_64FC4 创建 1-4 通道矩阵，或使用 CV_8UC(n), ..., CV_64FC(n) 创建多通道（最多 CV_CN_MAX 通道）矩阵。
data (数据)	指向用户数据的指针。接收 data 和 step 参数的矩阵构造函数不会分配矩阵数据。相反，它们只是初始化指向指定数据的矩阵头，这意味着不会拷贝数据。此操作非常高效，可用于使用 OpenCV 函数处理外部数据。外部数据不会自动释放，因此你应该负责处理它。
step (步长)	每个矩阵行占用的字节数。该值应包括每行末尾的填充字节（如果有）。如果缺少该参数（设置为 AUTO_STEP），则假定没有填充，实际步长计算为 cols*elemSize()。见 Mat::elemSize。

Mat() [13/29]

cv::Mat::Mat	(	int	ndims,
		const int *	sizes (大小列表),
		int	type,
		void *	data (数据),
		const size_t *	steps = 0 )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

ndims	数组维数。
sizes (大小列表)	指定 n 维数组形状的整数数组。
type	数组类型。使用 CV_8UC1, ..., CV_64FC4 创建 1-4 通道矩阵，或使用 CV_8UC(n), ..., CV_64FC(n) 创建多通道（最多 CV_CN_MAX 通道）矩阵。
data (数据)	指向用户数据的指针。接收 data 和 step 参数的矩阵构造函数不会分配矩阵数据。相反，它们只是初始化指向指定数据的矩阵头，这意味着不会拷贝数据。此操作非常高效，可用于使用 OpenCV 函数处理外部数据。外部数据不会自动释放，因此你应该负责处理它。
steps	多维数组情况下 ndims-1 个步长的数组（最后一个步长始终设置为元素大小）。如果未指定，则假定矩阵是连续的。

Mat() [14/29]

cv::Mat::Mat	(	const std::vector< int > &	sizes (大小列表),
		int	type,
		void *	data (数据),
		const size_t *	steps = 0 )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

sizes (大小列表)	指定 n 维数组形状的整数数组。
type	数组类型。使用 CV_8UC1, ..., CV_64FC4 创建 1-4 通道矩阵，或使用 CV_8UC(n), ..., CV_64FC(n) 创建多通道（最多 CV_CN_MAX 通道）矩阵。
data (数据)	指向用户数据的指针。接收 data 和 step 参数的矩阵构造函数不会分配矩阵数据。相反，它们只是初始化指向指定数据的矩阵头，这意味着不会拷贝数据。此操作非常高效，可用于使用 OpenCV 函数处理外部数据。外部数据不会自动释放，因此你应该负责处理它。
steps	多维数组情况下 ndims-1 个步长的数组（最后一个步长始终设置为元素大小）。如果未指定，则假定矩阵是连续的。

Mat() [15/29]

cv::Mat::Mat	(	const Mat &	m,
		const Range &	rowRange (行范围),
		const Range &	colRange = Range::all() )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

m	（全部或部分）分配给构造矩阵的数组。这些构造函数不会拷贝数据。相反，它会构造并关联一个指向 m 数据或其子数组的头。引用计数（如果有）会递增。因此，当你修改使用此类构造函数形成的矩阵时，你也修改了 m 的相应元素。如果你想要一个子数组的独立拷贝，请使用 Mat::clone()。
rowRange (行范围)	要获取的 m 行的范围。照例，范围开始是包含的，范围结束是排除的。使用 Range::all() 获取所有行。
colRange	要获取的 m 列的范围。使用 Range::all() 获取所有列。

Mat() [16/29]

cv::Mat::Mat	(	const Mat &	m,
		const Rect &	roi (感兴趣区域) )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

m	（全部或部分）分配给构造矩阵的数组。这些构造函数不会拷贝数据。相反，它会构造并关联一个指向 m 数据或其子数组的头。引用计数（如果有）会递增。因此，当你修改使用此类构造函数形成的矩阵时，你也修改了 m 的相应元素。如果你想要一个子数组的独立拷贝，请使用 Mat::clone()。
roi (感兴趣区域)	感兴趣区域。

Mat() [17/29]

cv::Mat::Mat	(	const Mat &	m,
		const Range *	ranges (范围数组) )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

m	（全部或部分）分配给构造矩阵的数组。这些构造函数不会拷贝数据。相反，它会构造并关联一个指向 m 数据或其子数组的头。引用计数（如果有）会递增。因此，当你修改使用此类构造函数形成的矩阵时，你也修改了 m 的相应元素。如果你想要一个子数组的独立拷贝，请使用 Mat::clone()。
ranges (范围数组)	沿每个维度的选定 m 范围数组。

Mat() [18/29]

cv::Mat::Mat	(	const Mat &	m,
		const std::vector< Range > &	ranges (范围数组) )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

m	（全部或部分）分配给构造矩阵的数组。这些构造函数不会拷贝数据。相反，它会构造并关联一个指向 m 数据或其子数组的头。引用计数（如果有）会递增。因此，当你修改使用此类构造函数形成的矩阵时，你也修改了 m 的相应元素。如果你想要一个子数组的独立拷贝，请使用 Mat::clone()。
ranges (范围数组)	沿每个维度的选定 m 范围数组。

Mat() [19/29]

template<typename _Tp >

cv::Mat::Mat ( const std::vector< _Tp > & vec, bool copyData = false )

explicit (显式)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

vec	其元素构成矩阵的 STL 向量。矩阵有一列，行数等于向量元素个数。矩阵类型与向量元素类型匹配。构造函数可以处理任意类型，只要有正确声明的 DataType。这意味着向量元素必须是原始数字或单类型数字组成的数值元组。不支持混合类型结构。相应的构造函数是显式的。由于 STL 向量不会自动转换为 Mat 实例，你应该显式编写 Mat(vec)。除非你将数据拷贝到矩阵中 (copyData=true)，否则不会向向量添加新元素，因为这可能会导致向量数据重新分配，从而使矩阵数据指针失效。
copyData	标志，指定 STL 向量的基础数据是应拷贝到 (true) 还是与新构造的矩阵共享 (false)。拷贝数据时，分配的缓冲区使用 Mat 引用计数机制管理。当数据共享时，引用计数器为 NULL，在矩阵销毁之前不应释放数据。

Mat() [20/29]

template<typename _Tp , typename = typename std::enable_if<std::is_arithmetic<_Tp>::value>::type>

cv::Mat::Mat ( const std::initializer_list< _Tp > list )

explicit (显式)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

Mat() [21/29]

template<typename _Tp >

cv::Mat::Mat ( const std::initializer_list< int > sizes (大小列表), const std::initializer_list< _Tp > list )

explicit (显式)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

Mat() [22/29]

template<typename _Tp , size_t _Nm>

cv::Mat::Mat ( const std::array< _Tp, _Nm > & arr (数组), bool copyData = false )

explicit (显式)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

Mat() [23/29]

template<typename _Tp , int n>

cv::Mat::Mat ( const Vec< _Tp, n > & vec, bool copyData = true )

explicit (显式)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

Mat() [24/29]

template<typename _Tp , int m, int n>

cv::Mat::Mat ( const Matx< _Tp, m, n > & mtx (矩阵), bool copyData = true )

explicit (显式)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

Mat() [25/29]

template<typename _Tp >

cv::Mat::Mat ( const Point_< _Tp > & pt (点), bool copyData = true )

explicit (显式)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

Mat() [26/29]

template<typename _Tp >

cv::Mat::Mat ( const Point3_< _Tp > & pt (点), bool copyData = true )

explicit (显式)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

Mat() [27/29]

template<typename _Tp >

cv::Mat::Mat ( const MatCommaInitializer_< _Tp > & commaInitializer )

explicit (显式)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

Mat() [28/29]

cv::Mat::Mat ( const cuda::GpuMat & m )

explicit (显式)

从 GpuMat 下载数据

~Mat()

cv::Mat::~Mat

(

)

析构函数 - 调用 release()

Mat() [29/29]

cv::Mat::Mat

(

Mat &&

m

)

成员函数说明

addref()

void cv::Mat::addref

(

)

增加引用计数。

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

adjustROI()

Mat & cv::Mat::adjustROI	(	int	dtop (顶部偏移),
		int	dbottom (底部偏移),
		int	dleft (左侧偏移),
		int	dright (右侧偏移) )

调整父矩阵中子矩阵的大小和位置。

该方法是对 Mat::locateROI 的补充。这些函数的典型用法是确定父矩阵中的子矩阵位置，然后以某种方式偏移该位置。通常，在需要考虑 ROI 之外像素的滤波操作中可能需要这样做。当所有方法参数均为正数时，ROI 需要向所有方向增长指定数量，例如：

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

在此示例中，矩阵大小在每个方向上增加了 4 个元素。矩阵向左移动 2 个元素，向上移动 2 个元素，从而为 5x5 内核的滤波引入了所有必要的像素。

adjustROI 强制调整后的 ROI 位于父矩阵内部，即调整后 ROI 的边界受父矩阵边界限制。例如，如果子矩阵 A 位于父矩阵的第一行，并且你调用了 A.adjustROI(2, 2, 2, 2)，则 A 不会向向上方向增加。

该函数由 OpenCV 滤波函数（如 filter2D）、形态学操作等在内部使用。

参数

dtop (顶部偏移)	子矩阵上边界向上偏移量。
dbottom (底部偏移)	子矩阵下边界向下偏移量。
dleft (左侧偏移)	子矩阵左边界向左偏移量。
dright (右侧偏移)	子矩阵右边界向右偏移量。

另请参阅

copyMakeBorder

assignTo()

void cv::Mat::assignTo	(	Mat &	m,
		int	type = -1 ) const

提供 convertTo 的函数形式。

这是由 MatrixExpressions 引擎调用的内部使用方法。

参数

m	目标数组。
type	所需的目标数组深度（如果应与源类型相同，则为 -1）。

at() [1/12]

template<typename _Tp >

_Tp & cv::Mat::at

(

const int *

idx (索引)

)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

idx (索引)

包含 Mat::dims 个索引的数组。

at() [2/12]

template<typename _Tp >

const _Tp & cv::Mat::at

(

const int *

idx (索引)

)

const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

idx (索引)

包含 Mat::dims 个索引的数组。

at() [3/12]

template<typename _Tp , int n>

_Tp & cv::Mat::at

(

const Vec< int, n > &

idx (索引)

)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

at() [4/12]

template<typename _Tp , int n>

const _Tp & cv::Mat::at

(

const Vec< int, n > &

idx (索引)

)

const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

at() [5/12]

template<typename _Tp >

_Tp & cv::Mat::at	(	int	i0,
		int	i1,
		int	i2 )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

i0	维度 0 的索引
i1	维度 1 的索引
i2	维度 2 的索引

at() [6/12]

template<typename _Tp >

const _Tp & cv::Mat::at	(	int	i0,
		int	i1,
		int	i2 ) const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

i0	维度 0 的索引
i1	维度 1 的索引
i2	维度 2 的索引

at() [7/12]

template<typename _Tp >

_Tp & cv::Mat::at

(

int

i0 = 0

)

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

模板方法返回对指定数组元素的引用。为了提高性能，索引范围检查仅在 Debug 配置中执行。

请注意，具有单个索引 (i) 的变体可用于访问单行或单列二维数组的元素。也就是说，例如，如果 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(int i = 0; i < H.rows; i++)
    for(int j = 0; j < H.cols; j++)
H.at<double>(i,j)=1./(i+j+1);

请记住，at 运算符中使用的类型标识符不能随机选择。它取决于你尝试从中检索数据的图像。下表提供了更深入的了解：

• 如果矩阵类型为 CV_8U，请使用 Mat.at<uchar>(y,x)。
• 如果矩阵类型为 CV_8S，请使用 Mat.at<schar>(y,x)。
• 如果矩阵类型为 CV_16U，请使用 Mat.at<ushort>(y,x)。
• 如果矩阵类型为 CV_16S，请使用 Mat.at<short>(y,x)。
• 如果矩阵类型为 CV_32S，请使用 Mat.at<int>(y,x)。
• 如果矩阵类型为 CV_32F，请使用 Mat.at<float>(y,x)。
• 如果矩阵类型为 CV_64F，请使用 Mat.at<double>(y,x)。

参数

i0

维度 0 的索引

示例

samples/cpp/camshiftdemo.cpp, samples/cpp/connected_components.cpp, samples/cpp/cout_mat.cpp, samples/cpp/demhist.cpp, samples/cpp/fitellipse.cpp, samples/cpp/image_alignment.cpp, samples/cpp/kalman.cpp, samples/cpp/kmeans.cpp, samples/cpp/train_HOG.cpp, samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp, samples/cpp/tutorial_code/features2D/Homography/decompose_homography.cpp, samples/cpp/tutorial_code/features2D/Homography/homography_from_camera_displacement.cpp, samples/cpp/tutorial_code/features2D/Homography/pose_from_homography.cpp, 以及 samples/cpp/tutorial_code/ml/introduction_to_pca/introduction_to_pca.cpp。

at() [8/12]

template<typename _Tp >

const _Tp & cv::Mat::at

(

int

i0 = 0

)

const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

i0

维度 0 的索引

at() [9/12]

template<typename _Tp >

_Tp & cv::Mat::at	(	int	行 (row),
		int	列 (col) )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

行 (row)	维度 0 的索引
列 (col)	维度 1 的索引

at() [10/12]

template<typename _Tp >

const _Tp & cv::Mat::at	(	int	行 (row),
		int	col ) const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

行 (row)	维度 0 的索引
列 (col)	维度 1 的索引

at() [11/12]

template<typename _Tp >

_Tp & cv::Mat::at

(

点 (Point)

pt (点)

)

这是一个重载的成员函数，为了方便而提供。它与上述函数的区别仅在于它接受的参数不同。针对2D数组的特殊版本（对于引用图像像素特别方便）

参数

pt (点)

指定为 Point(j,i) 的元素位置。

at() [12/12]

template<typename _Tp >

const _Tp & cv::Mat::at

(

点 (Point)

pt (点)

)

const

这是一个重载的成员函数，为了方便而提供。它与上述函数的区别仅在于它接受的参数不同。针对2D数组的特殊版本（对于引用图像像素特别方便）

参数

pt (点)

指定为 Point(j,i) 的元素位置。

begin() [1/2]

template<typename _Tp >

MatIterator_< _Tp > cv::Mat::begin

(

)

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

这些方法返回矩阵的只读或读写迭代器。矩阵迭代器的使用与 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() == traits::Type<VT>::value &&
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));
    }
}

示例

samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp, 以及 samples/dnn/classification.cpp。

begin() [2/2]

template<typename _Tp >

MatConstIterator_< _Tp > cv::Mat::begin

(

)

const

channels()

int cv::Mat::channels

(

)

const

返回矩阵通道数。

该方法返回矩阵通道数。

示例

samples/cpp/pca.cpp, 以及 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp。

checkVector()

int cv::Mat::checkVector	(	int	elemChannels,
		int	depth = -1,
		bool	requireContinuous = true ) const

参数

elemChannels	矩阵应具有的通道数或列数。对于 2-D 矩阵，当矩阵只有 1 列时，它应具有 elemChannels 个通道；当矩阵只有 1 个通道时，它应具有 elemChannels 列。对于 3-D 矩阵，它应只有 1 个通道。此外，如果平面（plane）数量不为 1，则每个平面内的行数必须为 1；如果每个平面内的行数不为 1，则平面数量必须为 1。
depth	矩阵应具有的深度。当任何深度都可以时，将其设置为 -1。
requireContinuous	设置为 true 以要求矩阵是连续的

返回

如果不满足要求，则返回 -1。否则，返回矩阵中的元素数。请注意，一个元素可能具有多个通道。

以下代码演示了它在 2-d 矩阵中的用法

    cv::Mat mat(20, 1, CV_32FC2);
    int n = mat.checkVector(2);
    CV_Assert(n == 20); // mat 有 20 个元素
 
mat.create(20, 2, CV_32FC1);
n = mat.checkVector(1);
    CV_Assert(n == -1); // mat 既不是列向量也不是行向量
 
n = mat.checkVector(2);
    CV_Assert(n == 20); // 这 2 列被视为 1 个元素

以下代码演示了它在 3-d 矩阵中的用法

    int dims[] = {1, 3, 5}; // 1 个平面，每个平面有 3 行 5 列
mat.create(3, dims, CV_32FC1); // 对于 3-d 矩阵，它必须只有 1 个通道
n = mat.checkVector(5); // 5 列被视为 1 个元素
    CV_Assert(n == 3);
 
    int dims2[] = {3, 1, 5}; // 3 个平面，每个平面有 1 行 5 列
mat.create(3, dims2, CV_32FC1);
n = mat.checkVector(5); // 5 列被视为 1 个元素
    CV_Assert(n == 3);

clone()

CV_NODISCARD_STD Mat cv::Mat::clone

(

)

const

创建数组及其底层数据的完整副本。

该方法创建数组的完整副本。原始的 step[] 不被考虑在内。因此，数组副本是一个连续数组，占用 total()*elemSize() 字节。

示例

samples/cpp/create_mask.cpp, samples/cpp/facedetect.cpp, samples/cpp/stitching_detailed.cpp, samples/cpp/train_HOG.cpp, samples/cpp/tutorial_code/ImgProc/Smoothing/Smoothing.cpp, samples/cpp/tutorial_code/ImgTrans/houghlines.cpp, samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp, samples/cpp/tutorial_code/features2D/Homography/homography_from_camera_displacement.cpp, samples/cpp/tutorial_code/features2D/Homography/pose_from_homography.cpp, samples/cpp/tutorial_code/imgcodecs/animations.cpp, 以及 samples/dnn/text_detection.cpp。

col()

Mat cv::Mat::col

(

int

x

)

const

为指定的矩阵列创建矩阵头。

该方法为指定的矩阵列创建一个新头并返回它。无论矩阵大小如何，这都是一个 O(1) 操作。新矩阵的基础数据与原始矩阵共享。另请参阅 Mat::row 的描述。

参数

x	从 0 开始的列索引。

示例

samples/cpp/tutorial_code/features2D/Homography/pose_from_homography.cpp.

colRange() [1/2]

Mat cv::Mat::colRange

(

const Range &

r

)

const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

r	包含起始和结束索引的 Range 结构。

colRange() [2/2]

Mat cv::Mat::colRange	(	int	startcol,
		int	endcol ) const

为指定的列范围创建矩阵头。

该方法为矩阵指定的列跨度创建一个新头。类似于 Mat::row 和 Mat::col，这是一个 O(1) 操作。

参数

startcol	列跨度从 0 开始的起始索引（包含）。
endcol	列跨度从 0 开始的结束索引（不包含）。

convertTo()

void cv::Mat::convertTo	(	OutputArray	m,
		int	rtype,
		double	alpha = 1,
		double	beta = 0 ) const

将数组转换为另一种数据类型，并可选择缩放。

该方法将源像素值转换为目标数据类型。最后应用 saturate_cast<> 以避免可能的溢出

\[m(x,y) = saturate \_ cast<rType>( \alpha (*this)(x,y) + \beta )\]

参数

m	输出矩阵；如果在操作前没有合适的尺寸或类型，它将被重新分配。
rtype	所需的输出矩阵类型，或者更确切地说是深度，因为通道数与输入相同；如果 rtype 为负数，则输出矩阵将具有与输入相同的类型。
alpha	可选的缩放因子。
beta	添加到缩放值中的可选增量。

示例

samples/cpp/demhist.cpp, samples/cpp/distrans.cpp, samples/cpp/fitellipse.cpp, samples/cpp/pca.cpp, samples/cpp/stitching_detailed.cpp, 以及 samples/dnn/colorization.cpp。

copyAt() [1/2]

void cv::Mat::copyAt

(

OutputArray

m

)

const

覆盖现有矩阵。

此方法写入现有的矩阵数据，就像 copyTo() 一样。但如果它在操作前没有合适的尺寸或类型，则会抛出异常。此函数有助于更新现有矩阵中的 ROI。

如果需要（重新）分配目标内存，请使用 copyTo()。

参数

m	目标矩阵。如果它在操作前没有合适的尺寸或类型，则会抛出异常。

另请参阅

copyTo

copyAt() [2/2]

void cv::Mat::copyAt	(	OutputArray	m,
		InputArray	mask ) const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

m	目标矩阵。如果它在操作前没有合适的尺寸或类型，则会抛出异常。
mask	与 *this 尺寸相同的操作掩码。其非零元素指示需要复制哪些矩阵元素。掩码必须是 CV_8U 类型，并且可以具有 1 个或多个通道。

copySize()

void cv::Mat::copySize

(

const Mat &

m

)

内部使用函数；正确地重新分配 _size, _step 数组

copyTo() [1/2]

void cv::Mat::copyTo

(

OutputArray

m

)

const

将矩阵复制到另一个矩阵。

该方法将矩阵数据复制到另一个矩阵。在复制数据之前，该方法会调用

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

以便在需要时重新分配目标矩阵。虽然 m.copyTo(m); 可以完美运行，但该函数不处理源矩阵和目标矩阵之间部分重叠的情况。

当指定了操作掩码时，如果上面显示的 Mat::create 调用重新分配了矩阵，则新分配的矩阵在复制数据之前会初始化为全零。

如果不需要（重新）分配目标内存（例如更新 ROI），请使用 copyAt()。

参数

m	目标矩阵。如果它在操作前没有合适的尺寸或类型，它将被重新分配。

另请参阅

copyAt

示例

samples/cpp/edge.cpp, samples/cpp/grabcut.cpp, samples/cpp/image_alignment.cpp, samples/cpp/lkdemo.cpp, samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp, samples/cpp/watershed.cpp, 以及 samples/tapi/hog.cpp。

copyTo() [2/2]

void cv::Mat::copyTo	(	OutputArray	m,
		InputArray	mask ) const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

m	目标矩阵。如果它在操作前没有合适的尺寸或类型，它将被重新分配。
mask	与 *this 尺寸相同的操作掩码。其非零元素指示需要复制哪些矩阵元素。掩码必须是 CV_8U 类型，并且可以具有 1 个或多个通道。

create() [1/4]

void cv::Mat::create	(	const std::vector< int > &	sizes (大小列表),
		int	type )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

sizes (大小列表)	指定新数组形状的整数数组。
type	新矩阵类型。

create() [2/4]

void cv::Mat::create	(	int	ndims,
		const int *	sizes (大小列表),
		int	type )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

ndims	新数组维度。
sizes (大小列表)	指定新数组形状的整数数组。
type	新矩阵类型。

create() [3/4]

void cv::Mat::create	(	int	rows (行数),
		int	cols (列数),
		int	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, COLOR_BGR2GRAY);

您可以直接编写

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

因为 cvtColor 以及大多数 OpenCV 函数内部都会为输出数组调用 Mat::create()。

参数

rows (行数)	新行数。
cols (列数)	新列数。
type	新矩阵类型。

示例

samples/cpp/camshiftdemo.cpp, samples/cpp/edge.cpp, samples/cpp/grabcut.cpp, samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp, 以及 samples/dnn/segmentation.cpp。

create() [4/4]

void cv::Mat::create	(	Size	size (大小),
		int	type )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

size (大小)	另一种新的矩阵尺寸指定方式：Size(cols, rows)
type	新矩阵类型。

cross()

Mat cv::Mat::cross

(

InputArray

m

)

const

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

该方法计算两个 3 元素向量的叉积。向量必须是具有相同形状和大小的 3 元素浮点向量。结果是另一个具有与操作数相同形状和类型的 3 元素向量。

参数

m

另一个叉积操作数。

示例

samples/cpp/tutorial_code/features2D/Homography/pose_from_homography.cpp.

deallocate()

void cv::Mat::deallocate

(

)

内部使用函数，建议改用 'release' 方法；释放矩阵数据

depth()

int cv::Mat::depth

(

)

const

返回矩阵元素的深度。

该方法返回矩阵元素深度的标识符（每个单独通道的类型）。例如，对于 16 位有符号元素数组，该方法返回 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 )

示例

samples/cpp/camshiftdemo.cpp, 以及 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp。

diag() [1/2]

static CV_NODISCARD_STD Mat cv::Mat::diag ( const Mat & d )

static (静态)

创建对角矩阵

该方法从指定的主对角线创建一个方阵对角矩阵。

参数

d	表示主对角线的一维矩阵。

diag() [2/2]

Mat cv::Mat::diag

(

int

d = 0

)

const

从矩阵中提取对角线。

该方法为指定的矩阵对角线创建一个新头。新矩阵表示为单列矩阵。类似于 Mat::row 和 Mat::col，这是一个 O(1) 操作。

参数

d	对角线的索引，具有以下值： d=0 是主对角线。 d<0 是下半部分的对角线。例如，d=-1 表示紧位于主对角线下方的对角线。 d>0 是上半部分的对角线。例如，d=1 表示紧位于主对角线上方的对角线。例如： Mat m = (Mat_<int>(3,3) << 1,2,3, 4,5,6, 7,8,9); Mat d0 = m.diag(0); Mat d1 = m.diag(1); Mat d_1 = m.diag(-1); 生成的矩阵为 d0 = [1; 5; 9] d1 = [2; 6] d_1 = [4; 8]

dot()

double cv::Mat::dot

(

InputArray

m

)

const

计算两个向量的点积。

该方法计算两个矩阵的点积。如果矩阵不是单列或单行向量，则使用从上到下、从左到右的扫描顺序将它们视为 1D 向量。向量必须具有相同的大小和类型。如果矩阵具有多个通道，则将所有通道的点积相加。

参数

m

另一个点积操作数。

示例

samples/cpp/tutorial_code/features2D/Homography/decompose_homography.cpp, 以及 samples/cpp/tutorial_code/features2D/Homography/homography_from_camera_displacement.cpp。

elemSize()

size_t cv::Mat::elemSize

(

)

const

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

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

elemSize1()

size_t cv::Mat::elemSize1

(

)

const

返回矩阵每个元素通道的大小（字节）。

该方法以字节为单位返回矩阵元素通道大小，即它忽略通道数。例如，如果矩阵类型为 CV_16SC3，则该方法返回 sizeof(short) 或 2。

empty()

bool cv::Mat::empty

(

)

const

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

如果 Mat::total() 为 0 或 Mat::data 为 NULL，则该方法返回 true。由于 pop_back() 和 resize() 方法，M.total() == 0 并不意味着 M.data == NULL。

示例

fld_lines.cpp, samples/cpp/facedetect.cpp, samples/cpp/fitellipse.cpp, samples/cpp/grabcut.cpp, samples/cpp/image_alignment.cpp, samples/cpp/laplace.cpp, samples/cpp/lkdemo.cpp, samples/cpp/segment_objects.cpp, samples/cpp/stitching.cpp, samples/cpp/stitching_detailed.cpp, samples/cpp/train_HOG.cpp, samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp, samples/cpp/tutorial_code/ImgProc/Morphology_1.cpp, samples/cpp/tutorial_code/ImgProc/Morphology_2.cpp, samples/cpp/tutorial_code/ImgProc/Pyramids/Pyramids.cpp, samples/cpp/tutorial_code/ImgProc/Smoothing/Smoothing.cpp, samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp, samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp, samples/cpp/tutorial_code/ImgTrans/houghcircles.cpp, samples/cpp/tutorial_code/ImgTrans/houghlines.cpp, samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp, samples/cpp/tutorial_code/ml/introduction_to_pca/introduction_to_pca.cpp, samples/cpp/tutorial_code/photo/non_photorealistic_rendering/npr_demo.cpp, samples/cpp/tutorial_code/photo/seamless_cloning/cloning_demo.cpp, samples/cpp/videowriter_basic.cpp, samples/cpp/watershed.cpp, samples/dnn/colorization.cpp, samples/dnn/object_detection.cpp, samples/dnn/openpose.cpp, 以及 samples/dnn/segmentation.cpp。

end() [1/2]

template<typename _Tp >

MatIterator_< _Tp > cv::Mat::end

(

)

返回矩阵迭代器并将其设置为最后一个矩阵元素之后的位置。

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

示例

samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp, 以及 samples/dnn/classification.cpp。

end() [2/2]

template<typename _Tp >

MatConstIterator_< _Tp > cv::Mat::end

(

)

const

eye() [1/2]

static CV_NODISCARD_STD MatExpr cv::Mat::eye ( int rows (行数), int cols (列数), int type )

static (静态)

返回指定大小和类型的单位矩阵。

该方法返回一个 Matlab 风格的单位矩阵初始化器，类似于 Mat::zeros。与 Mat::ones 类似，您可以使用缩放操作有效地创建缩放后的单位矩阵：

// 创建一个 4x4 对角线元素为 0.1 的对角矩阵。
Mat A = Mat::eye(4, 4, CV_32F)*0.1;

注意

在多通道类型的情况下，仅为第一个通道初始化单位矩阵，其他通道将设置为 0

参数

rows (行数)	行数。
cols (列数)	列数。
type	创建的矩阵类型。

eye() [2/2]

static CV_NODISCARD_STD MatExpr cv::Mat::eye ( Size size (大小), int type )

static (静态)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

size (大小)	另一种矩阵尺寸指定方式为 Size(cols, rows)。
type	创建的矩阵类型。

forEach() [1/2]

template<typename _Tp , typename Functor >

void cv::Mat::forEach

(

const Functor &

operation (操作)

)

并行地对所有矩阵元素运行给定的仿函数。

作为参数传递的操作必须是函数指针、函数对象或 lambda(C++11)。

示例 1。以下所有操作都会将所有矩阵元素的第一个通道置为 0xFF

Mat image(1920, 1080, CV_8UC3);
typedef cv::Point3_<uint8_t> Pixel;
 
// 首先。原始指针访问。
for (int r = 0; r < image.rows; ++r) {
Pixel* ptr = image.ptr<Pixel>(r, 0);
    const Pixel* ptr_end = ptr + image.cols;
    for (; ptr != ptr_end; ++ptr) {
        ptr->x = 255;
    }
}
 
// 使用 MatIterator。（简单，但会有迭代器的开销）
for (Pixel &p : cv::Mat_<Pixel>(image)) {
p.x = 255;
}
 
// 使用函数对象并行执行。
struct Operator {
    void operator ()(Pixel &pixel, const int * position) {
pixel.x = 255;
    }
};
image.forEach<Pixel>(Operator());
 
// 使用 C++11 lambda 并行执行。
image.forEach<Pixel>([](Pixel &p, const int * position) -> void {
p.x = 255;
});

示例 2. 使用像素位置

// 创建 uint8_t 类型的 3D 矩阵 (255 x 255 x 255)
// 并使用等于元素位置的值初始化所有元素。
// 即像素 (x,y,z) = (1,2,3) 的值 (b,g,r) = (1,2,3)。
 
int sizes[] = { 255, 255, 255 };
typedef cv::Point3_<uint8_t> Pixel;
 
Mat_<Pixel> image = Mat::zeros(3, sizes, CV_8UC3);
 
image.forEach<Pixel>([](Pixel& pixel, const int position[]) -> void {
pixel.x = position[0];
pixel.y = position[1];
pixel.z = position[2];
});

forEach() [2/2]

template<typename _Tp , typename Functor >

void cv::Mat::forEach

(

const Functor &

operation (操作)

)

const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

getDefaultAllocator()

static MatAllocator * cv::Mat::getDefaultAllocator ( )

static (静态)

getStdAllocator()

static MatAllocator * cv::Mat::getStdAllocator ( )

static (静态)

以及标准分配器

getUMat()

UMat cv::Mat::getUMat	(	AccessFlag	accessFlags,
		UMatUsageFlags	usageFlags = USAGE_DEFAULT ) const

从 Mat 检索 UMat

inv()

MatExpr cv::Mat::inv

(

int

method = DECOMP_LU

)

const

矩阵求逆。

该方法通过矩阵表达式执行矩阵求逆。这意味着该方法会返回一个临时矩阵逆对象，它可以进一步用作更复杂矩阵表达式的一部分，或者可以分配给矩阵。

参数

method

矩阵求逆方法。 cv::DecompTypes 之一

示例

samples/cpp/tutorial_code/features2D/Homography/decompose_homography.cpp, 以及 samples/cpp/tutorial_code/features2D/Homography/homography_from_camera_displacement.cpp。

isContinuous()

bool cv::Mat::isContinuous

(

)

const

报告矩阵是否连续。

如果矩阵元素连续存储且每行末尾没有间隙，则该方法返回 true。否则，它返回 false。显然，1x1 或 1xN 矩阵总是连续的。使用 Mat::create 创建的矩阵总是连续的。但是如果您使用 Mat::col, Mat::diag 等提取矩阵的一部分，或者为外部分配的数据构造矩阵头，此类矩阵可能不再具有此属性。

连续性标志作为一位存储在 Mat::flags 字段中，并在您构造矩阵头时自动计算。因此，连续性检查是一项非常快速的操作，尽管从理论上讲它可以按如下方式完成：

// Mat::isContinuous() 的另一种实现方式
bool myCheckMatContinuity(const Mat& m)
{
    //return (m.flags & Mat::CONTINUOUS_FLAG) != 0;
    return m.rows == 1 || m.step == m.cols*m.elemSize();
}

该方法在相当多的 OpenCV 函数中使用。关键点在于，逐元素操作（如算术和逻辑操作、数学函数、Alpha 混合、颜色空间变换等）不依赖于图像几何形状。因此，如果所有输入和输出数组都是连续的，则函数可以将它们作为非常长的单行向量处理。下面的示例说明了如何实现 Alpha 混合函数：

template<typename T>
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(traits::Depth<T>::value, 4) &&
src1.size() == src2.size());
    Size size = src1.size();
dst.create(size, src1.type());
 
    // 这是一个习惯用法：检查数组的连续性，
    // 如果是连续的，
    // 则将数组视为 1D 向量
    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 并不总是分配新矩阵。

示例

samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp.

isSubmatrix()

bool cv::Mat::isSubmatrix

(

)

const

如果矩阵是另一个矩阵的子矩阵，则返回 true

locateROI()

void cv::Mat::locateROI	(	Size &	wholeSize,
		点 (Point) &	ofs ) const

在父矩阵中定位矩阵头。

在您使用 Mat::row, Mat::col, Mat::rowRange, Mat::colRange 等从矩阵中提取子矩阵后，生成的子矩阵仅指向原始大矩阵的一部分。但是，每个子矩阵都包含信息（由 datastart 和 dataend 字段表示），这些信息有助于重建原始矩阵尺寸以及提取的子矩阵在原始矩阵中的位置。方法 locateROI 正是用于此目的。

参数

wholeSize	输出参数，包含以 this 为一部分的整个矩阵的大小。
ofs	输出参数，包含 this 在整个矩阵中的偏移量。

mul()

MatExpr cv::Mat::mul	(	InputArray	m,
		double	scale = 1 ) const

执行两个矩阵的逐元素乘法或除法。

该方法返回一个对数组逐元素乘法的临时编码对象，带有可选的缩放。请注意，这不符合更简单的 "\*" 运算符对应的矩阵乘法。

示例

Mat C = A.mul(5/B); // 相当于 divide(A, B, C, 5)

参数

m	另一个与 *this 具有相同类型和大小的数组，或矩阵表达式。
scale	可选的比例因子。

ones() [1/3]

static CV_NODISCARD_STD MatExpr cv::Mat::ones ( int ndims, const int * sz, int type )

static (静态)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

ndims	数组维数。
sz	指定数组形状的整数数组。
type	创建的矩阵类型。

ones() [2/3]

static CV_NODISCARD_STD MatExpr cv::Mat::ones ( int rows (行数), int cols (列数), int type )

static (静态)

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

该方法返回一个 Matlab 风格的全 1 数组初始化器，类似于 Mat::zeros。请注意，使用此方法，您可以使用以下 Matlab 习惯用法，以任意值初始化数组：

Mat A = Mat::ones(100, 100, CV_8U)*3; // 创建一个填充为 3 的 100x100 矩阵。

上述操作不会先形成一个 100x100 的全 1 矩阵，然后再乘以 3。相反，它只是记住比例因子（在本例中为 3），并在实际调用矩阵初始化器时使用它。

注意

在多通道类型的情况下，只有第一个通道会被初始化为全 1，其他通道将被设置为 0。

参数

rows (行数)	行数。
cols (列数)	列数。
type	创建的矩阵类型。

ones() [3/3]

static CV_NODISCARD_STD MatExpr cv::Mat::ones ( Size size (大小), int type )

static (静态)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

size (大小)	另一种矩阵尺寸指定方式 Size(cols, rows)。
type	创建的矩阵类型。

operator Matx< _Tp, m, n >()

template<typename _Tp , int m, int n>

cv::Mat::operator Matx< _Tp, m, n >

(

)

const

operator std::array< _Tp, _Nm >()

template<typename _Tp , std::size_t _Nm>

cv::Mat::operator std::array< _Tp, _Nm >

(

)

const

operator std::vector< _Tp >()

template<typename _Tp >

cv::Mat::operator std::vector< _Tp >

(

)

const

operator Vec< _Tp, n >()

template<typename _Tp , int n>

cv::Mat::operator Vec< _Tp, n >

(

)

const

operator()() [1/4]

Mat cv::Mat::operator()

(

const Range *

ranges (范围数组)

)

const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

ranges (范围数组)

沿每个数组维度的选定范围数组。

operator()() [2/4]

Mat cv::Mat::operator()

(

const Rect &

roi (感兴趣区域)

)

const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

roi (感兴趣区域)

指定为矩形的提取出的子矩阵。

operator()() [3/4]

Mat cv::Mat::operator()

(

const std::vector< Range > &

ranges (范围数组)

)

const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

ranges (范围数组)

沿每个数组维度的选定范围数组。

operator()() [4/4]

Mat cv::Mat::operator()	(	Range	rowRange (行范围),
		Range	colRange ) const

提取一个矩形子矩阵。

运算符为 *this 指定的子数组创建一个新头。它们是 Mat::row, Mat::col, Mat::rowRange, 和 Mat::colRange 最通用的形式。例如，A(Range(0, 10), Range::all()) 相当于 A.rowRange(0, 10)。与上述所有情况类似，运算符都是 O(1) 操作，即不复制矩阵数据。

参数

rowRange (行范围)	提取子矩阵的起始和结束行。不包含上边界。要选择所有行，请使用 Range::all()。
colRange	提取子矩阵的起始和结束列。不包含上边界。要选择所有列，请使用 Range::all()。

operator=() [1/4]

Mat & cv::Mat::operator=

(

const Mat &

m

)

赋值操作符

这些是可用的赋值运算符。由于它们都非常不同，请务必阅读运算符参数说明。

参数

m	被赋值的右侧矩阵。矩阵赋值是 O(1) 操作。这意味着不复制数据，而是共享数据，并且引用计数器（如果有）会递增。在分配新数据之前，旧数据会通过 Mat::release 被取消引用。

operator=() [2/4]

Mat & cv::Mat::operator=

(

const MatExpr &

expr

)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

expr	被赋值的矩阵表达式对象。与赋值操作的第一种形式相反，如果已分配的矩阵具有正确的尺寸和类型以适应矩阵表达式的结果，则第二种形式可以重用该矩阵。它由矩阵表达式展开成的实际函数自动处理。例如，C=A+B 展开为 add(A, B, C)，而 add 负责自动重新分配 C。

operator=() [3/4]

Mat & cv::Mat::operator=

(

const Scalar &

s

)

将所有或部分数组元素设置为指定值。

参数

s	转换为实际数组类型的被赋值的标量。

operator=() [4/4]

Mat & cv::Mat::operator=

(

Mat &&

m

)

pop_back()

void cv::Mat::pop_back

(

size_t

nelems = 1

)

从矩阵底部移除元素。

该方法从矩阵底部移除一行或多行。

参数

nelems

移除的行数。如果它大于总行数，则抛出异常。

ptr() [1/20]

uchar * cv::Mat::ptr

(

const int *

idx (索引)

)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

ptr() [2/20]

template<typename _Tp >

_Tp * cv::Mat::ptr

(

const int *

idx (索引)

)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

ptr() [3/20]

const uchar * cv::Mat::ptr

(

const int *

idx (索引)

)

const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

ptr() [4/20]

template<typename _Tp >

const _Tp * cv::Mat::ptr

(

const int *

idx (索引)

)

const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

ptr() [5/20]

template<int n>

uchar * cv::Mat::ptr

(

const Vec< int, n > &

idx (索引)

)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

ptr() [6/20]

template<typename _Tp , int n>

_Tp * cv::Mat::ptr

(

const Vec< int, n > &

idx (索引)

)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

ptr() [7/20]

template<int n>

const uchar * cv::Mat::ptr

(

const Vec< int, n > &

idx (索引)

)

const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

ptr() [8/20]

template<typename _Tp , int n>

const _Tp * cv::Mat::ptr

(

const Vec< int, n > &

idx (索引)

)

const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

ptr() [9/20]

uchar * cv::Mat::ptr	(	int	i0,
		int	i1,
		int	i2 )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

ptr() [10/20]

template<typename _Tp >

_Tp * cv::Mat::ptr	(	int	i0,
		int	i1,
		int	i2 )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

ptr() [11/20]

const uchar * cv::Mat::ptr	(	int	i0,
		int	i1,
		int	i2 ) const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

ptr() [12/20]

template<typename _Tp >

const _Tp * cv::Mat::ptr	(	int	i0,
		int	i1,
		int	i2 ) const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

ptr() [13/20]

uchar * cv::Mat::ptr

(

int

i0 = 0

)

返回指向指定矩阵行的指针。

这些方法返回指向指定矩阵行的 uchar* 或类型指针。请参阅 Mat::isContinuous 中的示例，了解如何使用这些方法。

参数

i0	从 0 开始的行索引。

示例

samples/cpp/image_alignment.cpp, samples/cpp/train_HOG.cpp, samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp, samples/dnn/colorization.cpp, samples/dnn/openpose.cpp, 以及 samples/dnn/segmentation.cpp。

ptr() [14/20]

template<typename _Tp >

_Tp * cv::Mat::ptr

(

int

i0 = 0

)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

ptr() [15/20]

const uchar * cv::Mat::ptr

(

int

i0 = 0

)

const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

ptr() [16/20]

template<typename _Tp >

const _Tp * cv::Mat::ptr

(

int

i0 = 0

)

const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

ptr() [17/20]

uchar * cv::Mat::ptr	(	int	行 (row),
		int	列 (col) )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

行 (row)	维度 0 的索引
列 (col)	维度 1 的索引

ptr() [18/20]

template<typename _Tp >

_Tp * cv::Mat::ptr	(	int	行 (row),
		int	列 (col) )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

行 (row)	维度 0 的索引
列 (col)	维度 1 的索引

ptr() [19/20]

const uchar * cv::Mat::ptr	(	int	行 (row),
		int	col ) const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

行 (row)	维度 0 的索引
列 (col)	维度 1 的索引

ptr() [20/20]

template<typename _Tp >

const _Tp * cv::Mat::ptr	(	int	行 (row),
		int	col ) const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

行 (row)	维度 0 的索引
列 (col)	维度 1 的索引

push_back() [1/4]

template<typename _Tp >

void cv::Mat::push_back

(

const _Tp &

elem

)

向矩阵底部添加元素。

这些方法在矩阵底部添加一个或多个元素。它们模仿 STL vector 类的相应方法。当 elem 是 Mat 时，它的类型和列数必须与容器矩阵中的相同。

参数

elem

添加的元素。

push_back() [2/4]

void cv::Mat::push_back

(

const Mat &

m

)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

m

添加的行。

push_back() [3/4]

template<typename _Tp >

void cv::Mat::push_back

(

const Mat_< _Tp > &

elem

)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

elem

添加的元素。

push_back() [4/4]

template<typename _Tp >

void cv::Mat::push_back

(

const std::vector< _Tp > &

elem

)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

elem

添加的元素。

push_back_()

void cv::Mat::push_back_

(

const void *

elem

)

内部函数

rbegin() [1/2]

template<typename _Tp >

std::reverse_iterator< MatIterator_< _Tp > > cv::Mat::rbegin

(

)

与 begin() 相同，但用于反向遍历。

rbegin() [2/2]

template<typename _Tp >

std::reverse_iterator< MatConstIterator_< _Tp > > cv::Mat::rbegin

(

)

const

reinterpret()

Mat cv::Mat::reinterpret

(

int

type

)

const

重置矩阵类型。

这些方法重置矩阵的数据类型。如果矩阵的新类型和旧类型具有相同的元素大小，则可以重用当前的缓冲区。该方法需要考虑当前的 mat 是否为子矩阵或是否有任何引用。

参数

type

新数据类型。

release()

void cv::Mat::release

(

)

递减引用计数器，如果需要，反分配矩阵。

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

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

示例

samples/cpp/stitching_detailed.cpp.

rend() [1/2]

template<typename _Tp >

std::reverse_iterator< MatIterator_< _Tp > > cv::Mat::rend

(

)

与 end() 相同，但用于反向遍历。

rend() [2/2]

template<typename _Tp >

std::reverse_iterator< MatConstIterator_< _Tp > > cv::Mat::rend

(

)

const

reserve()

void cv::Mat::reserve

(

size_t

sz

)

为特定数量的行预留空间。

该方法为 sz 行预留空间。如果矩阵已经有足够的空间存储 sz 行，则不执行任何操作。如果矩阵被重新分配，前 Mat::rows 行将被保留。该方法模仿了 STL vector 类的相应方法。

参数

sz

行数。

reserveBuffer()

void cv::Mat::reserveBuffer

(

size_t

sz

)

为特定数量的字节预留空间。

该方法预留 sz 字节的空间。如果矩阵已经有足够的空间存储 sz 字节，则不执行任何操作。如果必须重新分配矩阵，其先前的内容可能会丢失。

参数

sz

字节数。

reshape() [1/3]

Mat cv::Mat::reshape	(	int	cn,
		const std::vector< int > &	newshape ) const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

cn	新的通道数。如果参数为 0，则通道数保持不变。
newshape	包含所有维度新矩阵尺寸的向量。如果某些尺寸为零，则假定这些维度使用原始尺寸。

reshape() [2/3]

Mat cv::Mat::reshape	(	int	cn,
		int	newndims,
		const int *	newsz ) const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

cn	新的通道数。如果参数为 0，则通道数保持不变。
newndims	新的维度数。
newsz	包含所有维度新矩阵尺寸的数组。如果某些尺寸为零，则假定这些维度使用原始尺寸。

reshape() [3/3]

Mat cv::Mat::reshape	(	int	cn,
		int	rows = 0 ) const

在不复制数据的情况下更改 2D 矩阵的形状和/或通道数。

该方法为 *this 的元素创建一个新的矩阵头。新矩阵可以具有不同的尺寸和/或不同的通道数。任何组合都是可能的，只要：

• 新矩阵中没有包含额外的元素，也没有排除任何元素。因此，变换后 rows*cols*channels() 的乘积必须保持不变。
• 不复制数据。也就是说，这是一个 O(1) 操作。因此，如果您更改行数，或者该操作以某种其他方式更改了元素行的索引，则矩阵必须是连续的。请参阅 Mat::isContinuous。

例如，如果有一组存储为 STL vector 的 3D 点，并且您想将这些点表示为 3xN 矩阵，请执行以下操作：

std::vector<Point3f> vec;
...
Mat pointMat = Mat(vec); // 将 vector 转换为 Mat，O(1) 操作
                  reshape(1); // 将 Nx1 的 3 通道矩阵转换为 Nx3 的 1 通道矩阵。
                              // 同样是 O(1) 操作
                     t(); // 最后，转置 Nx3 矩阵。
                          // 这涉及复制所有元素

将 3 通道 2x2 矩阵重塑为 1 通道 4x3 矩阵，每一列包含来自原始通道之一的值

Mat m(Size(2, 2), CV_8UC3, Scalar(1, 2, 3));
vector<int> new_shape {4, 3};
m = m.reshape(1, new_shape);

或者

Mat m(Size(2, 2), CV_8UC3, Scalar(1, 2, 3));
const int new_shape[] = {4, 3};
m = m.reshape(1, 2, new_shape);

参数

cn	新的通道数。如果参数为 0，则通道数保持不变。
rows (行数)	新的行数。如果参数为 0，则行数保持不变。

示例

samples/cpp/pca.cpp 和 samples/dnn/classification.cpp。

resize() [1/2]

void cv::Mat::resize

(

size_t

sz

)

更改矩阵行数。

这些方法用于更改矩阵行数。如果矩阵被重新分配内存，则保留前 min(Mat::rows, sz) 行。这些方法模拟了 STL vector 类的相应方法。

参数

sz

新行数。

resize() [2/2]

void cv::Mat::resize	(	size_t	sz,
		const Scalar &	s )

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

sz	新行数。
s	分配给新添加元素的值。

row()

Mat cv::Mat::row

(

int

y

)

const

为指定的矩阵行创建矩阵头。

该方法为指定的矩阵行创建一个新头并将其返回。无论矩阵大小如何，这都是一个 O(1) 操作。新矩阵的基础数据与原始矩阵共享。以下是一个经典的矩阵基础处理操作 axpy 的示例，该操作被 LU 分解和许多其他算法使用：

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

注意

在当前的实现中，以下代码无法按预期工作：

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

参数

y	从 0 开始的行索引。

示例

samples/cpp/pca.cpp 和 samples/cpp/train_HOG.cpp。

rowRange() [1/2]

Mat cv::Mat::rowRange

(

const Range &

r

)

const

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

r	包含起始和结束索引的 Range 结构。

rowRange() [2/2]

Mat cv::Mat::rowRange	(	int	startrow,
		int	endrow ) const

为指定的行范围创建矩阵头。

该方法为矩阵的指定行范围创建一个新头。类似于 Mat::row 和 Mat::col，这是一个 O(1) 操作。

参数

startrow	行范围的起始索引（包含，从 0 开始）。
endrow	行范围的结束索引（不包含，从 0 开始）。

示例

samples/cpp/kmeans.cpp 和 samples/dnn/segmentation.cpp。

setDefaultAllocator()

static void cv::Mat::setDefaultAllocator ( MatAllocator * allocator )

static (静态)

setTo()

Mat & cv::Mat::setTo	(	InputArray	value (值),
		InputArray	mask = noArray() )

将所有或部分数组元素设置为指定值。

这是 Mat::operator=(const Scalar& s) 运算符的高级变体。

参数

value (值)	转换为实际数组类型的被赋值的标量。
mask	与 *this 尺寸相同的操作掩码。其非零元素表示需要复制哪些矩阵元素。掩码必须是 CV_8U 类型，并且可以具有 1 个或多个通道

示例

samples/dnn/segmentation.cpp.

step1()

size_t cv::Mat::step1

(

int

i = 0

)

const

返回归一化的步长。

该方法返回矩阵步长除以 Mat::elemSize1()。它可以用于快速访问任意矩阵元素。

t()

MatExpr cv::Mat::t

(

)

const

矩阵转置。

该方法通过矩阵表达式执行矩阵转置。它不执行实际的转置，而是返回一个临时的矩阵转置对象，该对象可以进一步用作更复杂的矩阵表达式的一部分，或者可以赋值给一个矩阵

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

示例

samples/cpp/tutorial_code/features2D/Homography/decompose_homography.cpp 和 samples/cpp/tutorial_code/features2D/Homography/homography_from_camera_displacement.cpp。

total() [1/2]

size_t cv::Mat::total

(

)

const

返回数组元素的总数。

该方法返回数组元素的数量（如果数组代表图像，则为像素数）。

示例

samples/cpp/train_HOG.cpp.

total() [2/2]

size_t cv::Mat::total	(	int	startDim,
		int	endDim = INT_MAX ) const

返回数组元素的总数。

该方法返回符合 startDim <= dim < endDim 的特定子数组切片中的元素数量

type()

int cv::Mat::type

(

)

const

返回矩阵元素的类型。

该方法返回矩阵元素类型。这是一个与 CvMat 类型系统兼容的标识符，如 CV_16SC3 或 16 位有符号 3 通道数组等。

示例

samples/cpp/grabcut.cpp, samples/cpp/image_alignment.cpp, samples/cpp/train_HOG.cpp, samples/cpp/tutorial_code/ImgProc/Smoothing/Smoothing.cpp, 以及 samples/cpp/videowriter_basic.cpp。

updateContinuityFlag()

void cv::Mat::updateContinuityFlag

(

)

内部使用方法：更新连续性标志

zeros() [1/3]

static CV_NODISCARD_STD MatExpr cv::Mat::zeros ( int ndims, const int * sz, int type )

static (静态)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

ndims	数组维数。
sz	指定数组形状的整数数组。
type	创建的矩阵类型。

zeros() [2/3]

static CV_NODISCARD_STD MatExpr cv::Mat::zeros ( int rows (行数), int cols (列数), int type )

static (静态)

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

该方法返回一个 Matlab 风格的全零数组初始化器。它可以用于快速形成一个常数数组作为函数参数、矩阵表达式的一部分或作为矩阵初始化器

Mat A;
A = Mat::zeros(3, 3, CV_32F);

在上面的例子中，只有当 A 不是 3x3 浮点矩阵时，才会分配一个新矩阵。否则，现有的矩阵 A 将被填满零。

参数

rows (行数)	行数。
cols (列数)	列数。
type	创建的矩阵类型。

示例

samples/cpp/fitellipse.cpp.

zeros() [3/3]

static CV_NODISCARD_STD MatExpr cv::Mat::zeros ( Size size (大小), int type )

static (静态)

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

size (大小)	另一种矩阵尺寸指定方式 Size(cols, rows)。
type	创建的矩阵类型。

成员数据文档

allocator

MatAllocator* cv::Mat::allocator

自定义分配器

cols

int cv::Mat::cols

示例

samples/cpp/camshiftdemo.cpp, samples/cpp/connected_components.cpp, samples/cpp/demhist.cpp, samples/cpp/facedetect.cpp, samples/cpp/falsecolor.cpp, samples/cpp/fitellipse.cpp, samples/cpp/grabcut.cpp, samples/cpp/image_alignment.cpp, samples/cpp/kmeans.cpp, samples/cpp/polar_transforms.cpp, samples/cpp/stitching.cpp, samples/cpp/train_HOG.cpp, samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp, samples/cpp/tutorial_code/ImgProc/Morphology_1.cpp, samples/cpp/tutorial_code/ImgProc/Pyramids/Pyramids.cpp, samples/cpp/tutorial_code/ImgProc/Smoothing/Smoothing.cpp, samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp, samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp, samples/cpp/warpPerspective_demo.cpp, samples/cpp/watershed.cpp, samples/dnn/object_detection.cpp, 以及 samples/dnn/openpose.cpp。

data

uchar* cv::Mat::data

指向数据的指针

示例

samples/dnn/segmentation.cpp.

dataend

const uchar* cv::Mat::dataend

datalimit

const uchar* cv::Mat::datalimit

datastart

const uchar* cv::Mat::datastart

在 locateROI 和 adjustROI 中使用的辅助字段

dims

int cv::Mat::dims

矩阵维度，>= 2

flags

int cv::Mat::flags

包含几个位域：

• 魔术签名 (magic signature)
• 连续性标志 (continuity flag)
• depth
• 通道数 (number of channels)

rows

int cv::Mat::rows

行数和列数，当矩阵超过 2 维时为 (-1, -1)

示例

samples/cpp/camshiftdemo.cpp, samples/cpp/connected_components.cpp, samples/cpp/demhist.cpp, samples/cpp/falsecolor.cpp, samples/cpp/fitellipse.cpp, samples/cpp/grabcut.cpp, samples/cpp/image_alignment.cpp, samples/cpp/kmeans.cpp, samples/cpp/polar_transforms.cpp, samples/cpp/stitching.cpp, samples/cpp/train_HOG.cpp, samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp, samples/cpp/tutorial_code/ImgProc/Pyramids/Pyramids.cpp, samples/cpp/tutorial_code/ImgProc/Smoothing/Smoothing.cpp, samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp, samples/cpp/tutorial_code/ImgTrans/houghcircles.cpp, samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp, samples/cpp/tutorial_code/ml/introduction_to_pca/introduction_to_pca.cpp, samples/cpp/watershed.cpp, samples/dnn/object_detection.cpp, 以及 samples/dnn/openpose.cpp。

size

MatSize cv::Mat::size

示例

samples/cpp/camshiftdemo.cpp, samples/cpp/connected_components.cpp, samples/cpp/create_mask.cpp, samples/cpp/grabcut.cpp, samples/cpp/image_alignment.cpp, samples/cpp/polar_transforms.cpp, samples/cpp/segment_objects.cpp, samples/cpp/stitching_detailed.cpp, samples/cpp/tutorial_code/ImgProc/Smoothing/Smoothing.cpp, samples/cpp/tutorial_code/features2D/Homography/homography_from_camera_displacement.cpp, samples/cpp/tutorial_code/photo/seamless_cloning/cloning_demo.cpp, samples/cpp/videowriter_basic.cpp, samples/cpp/watershed.cpp, samples/dnn/colorization.cpp, samples/dnn/openpose.cpp, samples/dnn/segmentation.cpp, 以及 samples/dnn/text_detection.cpp。

step

MatStep cv::Mat::step

u

UMatData* cv::Mat::u

与 UMat 的交互

---

该类的文档是由以下文件生成的

• opencv2/core/mat.hpp
• opencv2/core/utility.hpp