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

#include <opencv2/core/mat.hpp>

cv::Mat 的协作图

公共类型
枚举	{ MAGIC_VAL = 0x42FF0000 , AUTO_STEP = 0 , CONTINUOUS_FLAG = CV_MAT_CONT_FLAG , SUBMATRIX_FLAG = CV_SUBMAT_FLAG }

枚举	{ 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	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
	double getTickFrequency()

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
	在不复制数据的情况下更改二维矩阵的形状和/或通道数。

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)
	返回指定大小和类型的全零数组。

static CV_NODISCARD_STD MatExpr	zeros (Size size, int type)

公共属性
MatAllocator *	分配器
	自定义分配器

int	cols

uchar *	data
	指向数据的指针

const uchar *	dataend

const uchar *	数据限制

const uchar *	datastart
	用于 locateROI 和 adjustROI 的辅助字段

int	dims
	矩阵维度，>= 2

int	flags

int	rows
	行数和列数或 (-1, -1) (当矩阵维度超过 2 时)

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 (独立设备位图) 等）中的稠密数组类型兼容，也就是说，与任何使用 *步长* (或 *跨距*) 来计算像素位置的数组兼容。由于这种兼容性，可以为用户分配的数据创建 Mat 头，并使用 OpenCV 函数原地处理它。

创建 Mat 对象有许多不同的方法。最常见的选项如下所示：

使用 create(nrows, ncols, type) 方法或类似的 Mat(nrows, ncols, type[, fillValue]) 构造函数。分配指定大小和类型的新数组。type 的含义与 cvCreateMat 方法中的相同。例如，CV_8UC1 表示 8 位单通道数组，CV_32FC2 表示 2 通道（复数）浮点数组，等等。
// 创建一个 7x7 复数矩阵，填充 1+3j。

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

// 现在将 M 转换为 100x60 15 通道 8 位矩阵。

// 旧内容将被释放

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

cv::Mat
n 维密集数组类
定义 mat.hpp:830

cv::Scalar
Scalar_< double > Scalar
定义 types.hpp:709

CV_32FC2
#define CV_32FC2
定义 interface.h:119

CV_8UC
#define CV_8UC(n)
定义 interface.h:92

如本章引言所述，create() 仅在当前数组的形状或类型与指定的不同时才分配新数组。
创建多维数组
// 创建一个 100x100x100 的 8 位数组

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

Mat bigCube(3, sz, CV_8U, Scalar::all(0));

cv::Scalar_< double >::all
static Scalar_< double > all(double v0)

Definition interface.h:74
CV_8U
#define CV_8U

它将维度数=1 传递给 Mat 构造函数，但创建的数组将是二维的，列数设置为 1。因此，Mat::dims 始终 >= 2（当数组为空时也可以为 0）。
使用拷贝构造函数或赋值运算符，其中右侧可以是数组或表达式（参见下文）。如引言所述，数组赋值是 O(1) 操作，因为它只复制头并增加引用计数。Mat::clone() 方法可用于在需要时获取数组的完整（深层）副本。
为另一个数组的一部分构建一个头。它可以是单行、单列、多行、多列、数组中的矩形区域（在代数中称为 *minor*）或对角线。此类操作也是 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));

// 用 (0,255,0) 填充 ROI（在 RGB 空间中为绿色）；

// 原始的 320x240 图像将被修改

roi = Scalar(0,255,0);

cv::Mat::col
Mat col(int x) const
为指定的矩阵列创建矩阵头。

cv::Mat::copyTo
void copyTo(OutputArray m) const
将矩阵复制到另一个矩阵。

typedef Rect_< double >
Rect2i Rect
定义 types.hpp:496

cv::Size
Size2i Size
定义 types.hpp:370

// 相同的通道类型。
CV_8UC3
#define CV_8UC3

由于附加的 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)

cv::Mat::size
MatSize size
定义 mat.hpp:2187

cv::Mat::locateROI
void locateROI(Size &wholeSize, Point &ofs) const
在父矩阵中定位矩阵头。

cv::Mat::eye
static CV_NODISCARD_STD MatExpr eye(int rows, int cols, int type)
返回指定大小和类型的单位矩阵。

cv::Point_< int >

指定序列的连续子序列（切片）的模板类。更多...
指定序列连续子序列（切片）的模板类。
定义 types.hpp:630

cv::Range::all
static Range all()

cv::Size_
用于指定图像或矩形大小的模板类。
Definition types.hpp:335

Definition interface.h:73
CV_32S
#define CV_32S

与整个矩阵的情况一样，如果需要深层副本，请使用提取的子矩阵的 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;
  
  }
  
  cv::Mat::step
  MatStep step
  定义 mat.hpp:2188
  
  cv::GaussianBlur
  void GaussianBlur(InputArray src, OutputArray dst, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT, AlgorithmHint hint=cv::ALGO_HINT_DEFAULT)
  使用高斯滤波器模糊图像。
2. 快速初始化小型矩阵和/或获得超快速元素访问。
  double m[3][3] = {{a, b, c}, {d, e, f}, {g, h, i}};
  
  Mat M = Mat(3, 3, CV_64F, m).inv();
  
  cv::Mat::Mat
  Mat() CV_NOEXCEPT
  
  CV_64F
  #define CV_64F
  Definition interface.h:79
使用 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);

cv::Mat_
从 Mat 派生的模板矩阵类。
定义 mat.hpp:2257

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

数组创建后，它通过引用计数机制自动管理。如果数组头是基于用户分配的数据构建的，则应自行处理数据。当没有引用指向数组数据时，数据将被释放。如果要在数组析构函数调用之前释放数组头指向的数据，请使用 Mat::release()。

接下来需要了解的数组类重要内容是元素访问。本手册已经描述了如何计算每个数组元素的地址。通常，您不需要直接在代码中使用该公式。如果您知道数组元素类型（可以使用 Mat::type() 方法检索），则可以访问二维数组的元素 \(M_{ij}\) 如下：

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

cv::Mat::at

_Tp & at(int i0=0)

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

假设 M 是一个双精度浮点数组。at 方法有多种变体，适用于不同维数。

如果您需要处理二维数组的整行，最有效的方法是首先获取指向该行的指针，然后直接使用普通的 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。

成员枚举文档

◆ 匿名枚举

匿名枚举

枚举器
MAGIC_VAL
AUTO_STEP
CONTINUOUS_FLAG
SUBMATRIX_FLAG

◆ 匿名枚举

匿名枚举

枚举器
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	二维数组中的行数。
cols	二维数组中的列数。
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	二维数组大小： 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	二维数组中的行数。
cols	二维数组中的列数。
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	二维数组大小： 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	二维数组中的行数。
cols	二维数组中的列数。
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	二维数组大小： 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	Range 表示 m 中要取用的行。通常，范围开始是包含的，范围结束是排他的。使用 Range::all() 来取用所有行。
colRange	Range 表示 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 )

显式

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

参数

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 )

显式

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

◆ Mat() [21/29]

template<typename _Tp >

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

显式

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

◆ Mat() [22/29]

template<typename _Tp , size_t _Nm>

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

显式

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

◆ Mat() [23/29]

template<typename _Tp , int n>

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

显式

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

◆ Mat() [24/29]

template<typename _Tp , int m, int n>

cv::Mat::Mat	(	const Matx< _Tp, m, n > &	◆ makePtr(),
		bool	copyData = true )

显式

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

◆ Mat() [25/29]

template<typename _Tp >

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

显式

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

◆ Mat() [26/29]

template<typename _Tp >

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

显式

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

◆ Mat() [27/29]

template<typename _Tp >

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

显式

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

◆ Mat() [28/29]

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

显式

从 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	矩阵应具有的通道数或列数。对于 2D 矩阵，当矩阵只有 1 列时，它应该有 elemChannels 个通道；当矩阵只有 1 个通道时，它应该有 elemChannels 列。对于 3D 矩阵，它应该只有 1 个通道。此外，如果平面数不为 1，则每个平面内的行数必须为 1；如果每个平面内的行数不为 1，则平面数必须为 1。
深度	矩阵应具有的深度。当任何深度都可接受时，将其设置为 -1。
requireContinuous	将其设置为 true 以要求矩阵是连续的

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

以下代码演示了其用于 2D 矩阵的用法：

    cv::Mat mat(20, 1, CV_32FC2);
    int n = mat.checkVector(2);
    CV_Assert(n == 20); // mat has 20 elements
 
mat.create(20, 2, CV_32FC1);
n = mat.checkVector(1);
    CV_Assert(n == -1); // mat is neither a column nor a row vector
 
n = mat.checkVector(2);
    CV_Assert(n == 20); // the 2 columns are considered as 1 element

以下代码演示了其用于 3D 矩阵的用法：

    int dims[] = {1, 3, 5}; // 1 plane, every plane has 3 rows and 5 columns
mat.create(3, dims, CV_32FC1); // for 3-d mat, it MUST have only 1 channel
n = mat.checkVector(5); // the 5 columns are considered as 1 element
    CV_Assert(n == 3);
 
    int dims2[] = {3, 1, 5}; // 3 planes, every plane has 1 row and 5 columns
mat.create(3, dims2, CV_32FC1);
n = mat.checkVector(5); // the 5 columns are considered as 1 element
    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。

◆ 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 调用重新分配了矩阵，则在新分配的矩阵在复制数据之前会用所有零初始化。

参数

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

示例: 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 类型，并且可以有一个或多个通道。

◆ 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 函数和方法都会为每个输出数组调用此方法。该方法使用以下算法：

如果当前数组形状和类型与新的匹配，则立即返回。否则，通过调用 Mat::release 取消引用先前的数据。
初始化新头。
分配新的数据，大小为 total()*elemSize() 字节。
分配与数据关联的新引用计数器并将其设置为 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);

cv::Mat::diag
Mat diag(int d=0) const
从矩阵中提取对角线。

结果矩阵为：
d0 =

[1;

5;

9]

d1 =

[2;

6]

d_1 =

[4;

8]

◆ dot()

double cv::Mat::dot ( InputArray m ) const

计算两个向量的点积。

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

参数

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

double getTickFrequency()

如果 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，您可以使用比例操作有效地创建缩放的单位矩阵：

// 创建一个对角线上均为 0.1 的 4x4 对角矩阵。

Mat A = Mat::eye(4, 4, CV_32F)*0.1;

CV_32F

#define CV_32F

Definition interface.h:78

注意: 如果是多通道类型，则仅初始化第一个通道的单位矩阵，其他通道将设置为 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 & 操作 )

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

作为参数传递的操作必须是函数指针、函数对象或 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. 使用像素位置

// 创建 3D 矩阵 (255 x 255 x 255) 类型 uint8_t
// 并将所有元素初始化为等于元素位置的值。
// 即像素 (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 & 操作 ) 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

反转矩阵。

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

参数

方法	矩阵求逆方法。是 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());
 
    // 这是惯用法：检查数组的连续性，并且，
    // 如果是这种情况，
    // 将数组视为一维向量
    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 + pix2[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)

cv::Mat::mul

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

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

参数

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 矩阵。

cv::Mat::ones

static CV_NODISCARD_STD MatExpr ones(int rows, int cols, int type)

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

上述操作不会形成一个 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 向量类的相应方法。当 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

重置矩阵类型。

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

参数

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 向量类的相应方法。

参数

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

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

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

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

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

std::vector<Point3f> vec;
...
Mat pointMat = Mat(vec). // 将向量转换为 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 向量类的相应方法。

参数

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 * 分配器 )

static

◆ setTo()

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

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

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

参数

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

示例: 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 + lambda*I)

示例: samples/cpp/tutorial_code/features2D/Homography/decompose_homography.cpp, and 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, and 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

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

此方法返回一个 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, and 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

包含多个位字段

魔术签名
连续性标志
深度
通道数

◆ rows

int cv::Mat::rows

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

示例: 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, and 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, and samples/dnn/text_detection.cpp.

◆ step

MatStep cv::Mat::step

◆ u

UMatData* cv::Mat::u

与 UMat 的交互

此类的文档由以下文件生成

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

公共类型

公共成员函数

静态公共成员函数

公共属性

保护成员函数

详细描述

成员枚举文档

◆ 匿名枚举

◆ 匿名枚举

构造函数 & 析构函数文档

◆ Mat() [1/29]

◆ Mat() [2/29]

◆ Mat() [3/29]

◆ Mat() [4/29]

◆ Mat() [5/29]

◆ Mat() [6/29]

◆ Mat() [7/29]

◆ Mat() [8/29]

◆ Mat() [9/29]

◆ Mat() [10/29]

◆ Mat() [11/29]

◆ Mat() [12/29]

◆ Mat() [13/29]

◆ Mat() [14/29]

◆ Mat() [15/29]

◆ Mat() [16/29]

◆ Mat() [17/29]

◆ Mat() [18/29]

◆ Mat() [19/29]

◆ Mat() [20/29]

◆ Mat() [21/29]

◆ Mat() [22/29]

◆ Mat() [23/29]

◆ Mat() [24/29]

◆ Mat() [25/29]

◆ Mat() [26/29]

◆ Mat() [27/29]

◆ Mat() [28/29]

◆ ~Mat()

◆ Mat() [29/29]

成员函数文档

◆ addref()

◆ adjustROI()

◆ assignTo()

◆ at() [1/12]

◆ at() [2/12]

◆ at() [3/12]

◆ at() [4/12]

◆ at() [5/12]

◆ at() [6/12]

◆ at() [7/12]

◆ at() [8/12]

◆ at() [9/12]

◆ at() [10/12]

◆ at() [11/12]

◆ at() [12/12]

◆ begin() [1/2]

◆ begin() [2/2]

◆ channels()

◆ checkVector()

◆ clone()

◆ col()

◆ colRange() [1/2]

◆ colRange() [2/2]

◆ convertTo()

◆ copySize()

◆ copyTo() [1/2]

◆ copyTo() [2/2]

◆ create() [1/4]

◆ create() [2/4]

◆ create() [3/4]

◆ create() [4/4]

◆ cross()

◆ deallocate()

◆ depth()

◆ diag() [1/2]

◆ diag() [2/2]

◆ dot()

◆ elemSize()

◆ elemSize1()