OpenCV 4.11.0
开源计算机视觉
加载中…
搜索中…
无匹配项
公共类型 | 公共成员函数 | 静态公共成员函数 | 公共属性 | 保护成员函数 | 所有成员列表
cv::Mat 类参考
核心功能 » 基本结构

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)
 
模板<typename _Tp >
 Mat (const MatCommaInitializer_< _Tp > &commaInitializer)
 
模板<typename _Tp , int m, int n>
 Mat (const Matx< _Tp, m, n > &mtx, bool copyData=true)
 
模板<typename _Tp >
 Mat (const Point3_< _Tp > &pt, bool copyData=true)
 
模板<typename _Tp >
 Mat (const Point_< _Tp > &pt, bool copyData=true)
 
模板<typename _Tp , size_t _Nm>
 Mat (const std::array< _Tp, _Nm > &arr, bool copyData=false)
 
模板<typename _Tp , typename = typename std::enable_if<std::is_arithmetic<_Tp>::value>::type>
 Mat (const std::initializer_list< _Tp > list)
 
模板<typename _Tp >
 Mat (const std::initializer_list< int > sizes, const std::initializer_list< _Tp > list)
 
模板<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)
 
模板<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的函数形式。
 
模板<typename _Tp >
_Tp & at (const int *idx)
 
模板<typename _Tp >
const _Tp & at (const int *idx) const
 
模板<typename _Tp , int n>
_Tp & at (const Vec< int, n > &idx)
 
模板<typename _Tp , int n>
const _Tp & at (const Vec< int, n > &idx) const
 
模板<typename _Tp >
_Tp & at (int i0, int i1, int i2)
 
模板<typename _Tp >
const _Tp & at (int i0, int i1, int i2) const
 
模板<typename _Tp >
_Tp & at (int i0=0)
 返回对指定数组元素的引用。
 
模板<typename _Tp >
const _Tp & at (int i0=0) const
 
模板<typename _Tp >
_Tp & at (int row, int col)
 
模板<typename _Tp >
const _Tp & at (int row, int col) const
 
模板<typename _Tp >
_Tp & at (Point pt)
 
模板<typename _Tp >
const _Tp & at (Point pt) const
 
模板<typename _Tp >
MatIterator_< _Tp > begin ()
 返回矩阵迭代器并将其设置为第一个矩阵元素。
 
模板<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
 计算两个三元素向量的叉积。
 
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。
 
模板<typename _Tp >
MatIterator_< _Tp > end ()
 返回矩阵迭代器并将其设置为最后一个矩阵元素之后。
 
模板<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
 对两个矩阵执行逐元素乘法或除法。
 
模板<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
 
模板<typename _Tp >
 operator std::vector< _Tp > () const
 
模板<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)
 
模板<typename _Tp >
_Tp * ptr (const int *idx)
 
const uchar * ptr (const int *idx) const
 
模板<typename _Tp >
const _Tp * ptr (const int *idx) const
 
template<int n>
uchar * ptr (const Vec< int, n > &idx)
 
模板<typename _Tp , int n>
_Tp * ptr (const Vec< int, n > &idx)
 
template<int n>
const uchar * ptr (const Vec< int, n > &idx) const
 
模板<typename _Tp , int n>
const _Tp * ptr (const Vec< int, n > &idx) const
 
uchar * ptr (int i0, int i1, int i2)
 
模板<typename _Tp >
_Tp * ptr (int i0, int i1, int i2)
 
const uchar * ptr (int i0, int i1, int i2) const
 
模板<typename _Tp >
const _Tp * ptr (int i0, int i1, int i2) const
 
uchar * ptr (int i0=0)
 返回指向指定矩阵行的指针。
 
模板<typename _Tp >
_Tp * ptr (int i0=0)
 
const uchar * ptr (int i0=0) const
 
模板<typename _Tp >
const _Tp * ptr (int i0=0) const
 
uchar * ptr (int row, int col)
 
模板<typename _Tp >
_Tp * ptr (int row, int col)
 
const uchar * ptr (int row, int col) const
 
模板<typename _Tp >
const _Tp * ptr (int row, int col) const
 
模板<typename _Tp >
void push_back (const _Tp &elem)
 在矩阵底部添加元素。
 
void push_back (const Mat &m)
 
模板<typename _Tp >
void push_back (const Mat_< _Tp > &elem)
 
模板<typename _Tp >
void push_back (const std::vector< _Tp > &elem)
 
void push_back_ (const void *elem)
 内部函数
 
模板<typename _Tp >
std::reverse_iterator< MatIterator_< _Tp > > rbegin ()
 与begin()相同，但用于逆向遍历。
 
模板<typename _Tp >
std::reverse_iterator< MatConstIterator_< _Tp > > rbegin () const
 
void 释放 ()
 递减引用计数器，如果需要则释放矩阵。
 
模板<typename _Tp >
std::reverse_iterator< MatIterator_< _Tp > > rend ()
 与end()相同，但用于逆向遍历。
 
模板<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)
 返回指定大小和类型，所有元素均为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（独立设备位图）等，即任何使用步长（或步幅）来计算像素位置的数组。由于这种兼容性，可以为用户分配的数据创建一个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));
    cv::Mat
    n维密集数组类
    定义 mat.hpp:829
    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)
    CV_8U
    #define CV_8U
    定义 interface.h:73
    它将维数=1传递给Mat构造函数，但创建的数组将是二维的，列数设置为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));
    // 用 (0,255,0)（在 RGB 空间中为绿色）填充 ROI；
    // 原始的 320x240 图像将被修改
    roi = Scalar(0,255,0);
    cv::Mat::col
    Mat col(int x) const
    为指定的矩阵列创建一个矩阵头。
    cv::Mat::copyTo
    void copyTo(OutputArray m) const
    将矩阵复制到另一个矩阵。
    cv::Rect
    Rect2i Rect
    定义 types.hpp:496
    cv::Size
    Size2i Size
    定义 types.hpp:370
    CV_8UC3
    #define CV_8UC3
    定义 interface.h:90
    由于增加了 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:2177
    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 >
    cv::Range
    指定序列的连续子序列（切片）的模板类。
    定义 types.hpp:630
    cv::Range::all
    static Range all()
    cv::Size_
    用于指定图像或矩形大小的模板类。
    定义 types.hpp:335
    CV_32S
    #define CV_32S
    定义 interface.h:77
    与整个矩阵的情况一样，如果您需要深度复制，请使用提取的子矩阵的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:2178
      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
      定义 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:2247
    使用这种方法，您首先使用正确的参数调用 Mat 类的构造函数，然后只需放置<< 运算符，后跟逗号分隔的值，这些值可以是常量、变量、表达式等等。另外，请注意避免编译错误所需的额外括号。

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

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

M.at<double>(i,j) += 1.f;
cv::Mat::at
_Tp & at(int i0=0)
返回对指定数组元素的引用。

假设M是一个双精度浮点数数组。该方法针对不同维数有多个变体。

如果需要处理二维数组的一整行，最有效的方法是首先获取该行的指针，然后直接使用普通的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.);
}
cv::Mat::ptr
uchar * ptr(int i0=0)
返回指向指定矩阵行的指针。
cv::Mat::cols
int cols
定义 mat.hpp:2155
cv::Mat::rows
int rows
行和列的数量，或者当矩阵的维数大于2时为(-1, -1)
定义 mat.hpp:2155
cv::sum
Scalar sum(InputArray src)
计算数组元素的和。

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

// 计算正矩阵元素的和，优化后的版本
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.);
}
cv::Mat::isContinuous
bool isContinuous() const
报告矩阵是否连续。

对于连续矩阵，外循环体只执行一次。因此，开销更小，在小型矩阵的情况下尤其明显。

最后，还有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.);
cv::MatConstIterator_
矩阵只读迭代器。
定义 mat.hpp:3166
cv::Mat::end
MatIterator_< _Tp > end()
返回矩阵迭代器并将其设置为最后一个矩阵元素之后。
cv::Mat::begin
MatIterator_< _Tp > begin()
返回矩阵迭代器并将其设置为第一个矩阵元素。

矩阵迭代器是随机访问迭代器，因此可以传递给任何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 ( )

这些是构成矩阵的各种构造函数。如自动分配中所述，默认构造函数通常就足够了，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指向用户数据的指针。获取数据和步长参数的矩阵构造函数不会分配矩阵数据。相反，它们只初始化指向指定数据的矩阵头，这意味着没有数据被复制。此操作非常高效，可用于使用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指向用户数据的指针。获取数据和步长参数的矩阵构造函数不会分配矩阵数据。相反，它们只初始化指向指定数据的矩阵头，这意味着没有数据被复制。此操作非常高效，可用于使用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指向用户数据的指针。获取数据和步长参数的矩阵构造函数不会分配矩阵数据。相反，它们只初始化指向指定数据的矩阵头，这意味着没有数据被复制。此操作非常高效，可用于使用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指向用户数据的指针。获取数据和步长参数的矩阵构造函数不会分配矩阵数据。相反，它们只初始化指向指定数据的矩阵头，这意味着没有数据被复制。此操作非常高效，可用于使用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。通常，范围起始值包含在内，范围结束值不包含在内。使用 Range::all() 获取所有行。
colRange要获取的m列的Range。使用 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]

模板<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]

模板<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]

模板<typename _Tp >
cv::Mat::Mat ( const std::initializer_list< int > sizes,
const std::initializer_list< _Tp > list )
explicit

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

◆ Mat() [22/29]

模板<typename _Tp , size_t _Nm>
cv::Mat::Mat ( const std::array< _Tp, _Nm > & arr,
bool copyData = false )
explicit

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

◆ Mat() [23/29]

模板<typename _Tp , int n>
cv::Mat::Mat ( const Vec< _Tp, n > & vec,
bool copyData = true )
explicit

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

◆ Mat() [24/29]

模板<typename _Tp , int m, int n>
cv::Mat::Mat ( const Matx< _Tp, m, n > & mtx,
bool copyData = true )
explicit

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

◆ Mat() [25/29]

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

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

◆ Mat() [26/29]

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

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

◆ Mat() [27/29]

模板<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 顶部偏移量,
int 底部偏移量,
int 左边偏移量,
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、形态学运算等）内部使用。

参数
顶部偏移量向上移动顶部子矩阵边界。
底部偏移量向下移动底部子矩阵边界。
左边偏移量向左移动左侧子矩阵边界。
dright向右移动右侧子矩阵边界。
另请参见
copyMakeBorder

◆ assignTo()

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

提供convertTo的函数形式。

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

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

◆ at() [1/12]

模板<typename _Tp >
_Tp & cv::Mat::at ( const int * idx)

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

参数
idx包含Mat::dims索引的数组。

◆ at() [2/12]

模板<typename _Tp >
const _Tp & cv::Mat::at ( const int * idx) const

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

参数
idx包含Mat::dims索引的数组。

◆ at() [3/12]

模板<typename _Tp , int n>
_Tp & cv::Mat::at ( const Vec< int, n > & idx)

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

◆ at() [4/12]

模板<typename _Tp , int n>
const _Tp & cv::Mat::at ( const Vec< int, n > & idx) const

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

◆ at() [5/12]

模板<typename _Tp >
_Tp & cv::Mat::at ( int i0,
int i1,
int i2 )

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

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

◆ at() [6/12]

模板<typename _Tp >
const _Tp & cv::Mat::at ( int i0,
int i1,
int i2 ) const

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

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

◆ at() [7/12]

模板<typename _Tp >
_Tp & cv::Mat::at ( int i0 = 0)

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

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

请注意，具有单个索引 (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]

模板<typename _Tp >
const _Tp & cv::Mat::at ( int i0 = 0) const

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

参数
i0维度 0 的索引

◆ at() [9/12]

模板<typename _Tp >
_Tp & cv::Mat::at ( int row,
int col )

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

参数
row维度 0 的索引
col维度 1 的索引

◆ at() [10/12]

模板<typename _Tp >
const _Tp & cv::Mat::at ( int row,
int col ) const

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

参数
row维度 0 的索引
col维度 1 的索引

◆ at() [11/12]

模板<typename _Tp >
_Tp & cv::Mat::at ( Point pt)

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。二维数组的特殊版本（尤其方便引用图像像素）。

参数
pt元素位置指定为 Point(j,i)。

◆ at() [12/12]

模板<typename _Tp >
const _Tp & cv::Mat::at ( Point pt) const

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。二维数组的特殊版本（尤其方便引用图像像素）。

参数
pt元素位置指定为 Point(j,i)。

◆ begin() [1/2]

模板<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));
}
}
cv::MatIterator_
矩阵读写迭代器。
定义 mat.hpp:3219
cv::Mat::create
void create(int rows, int cols, int type)
根据需要分配新的数组数据。
cv::Mat::type
int type() const
返回矩阵元素的类型。
cv::Vec
短数值向量的模板类，是Matx的部分特例。
定义 matx.hpp:369
cv::saturate_cast
static _Tp saturate_cast(uchar v)
用于在一种基本类型和另一种基本类型之间进行精确转换的模板函数。
定义 saturate.hpp:81
CV_Assert
#define CV_Assert(expr)
在运行时检查条件，如果失败则抛出异常。
定义 base.hpp:359
示例
samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp 和 samples/dnn/classification.cpp。

◆ begin() [2/2]

模板<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矩阵应具有的通道数或列数。对于二维矩阵，当矩阵只有一列时，它应具有elemChannels通道；当矩阵只有一个通道时，它应具有elemChannels列。对于三维矩阵，它应该只有一个通道。此外，如果平面的数量不是1，则每个平面内的行数必须为1；如果每个平面内的行数不是1，则平面的数量必须为1。
depth矩阵应具有的深度。如果任何深度都可以，则将其设置为-1。
requireContinuous将其设置为true以要求矩阵是连续的。
返回值
如果条件不满足，则返回 -1。否则，返回矩阵中元素的数量。请注意，一个元素可能有多个通道。

以下代码演示了其在二维矩阵中的用法

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 个元素

以下代码演示了其在三维矩阵中的用法

int dims[] = {1, 3, 5}; // 1 个平面，每个平面有 3 行 5 列
mat.create(3, dims, CV_32FC1); // 对于三维矩阵，它必须只有一个通道
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

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

参数
rRange 结构体，包含起始和结束索引。

◆ 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 类型，并且可以有 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);
cv::Mat::depth
int depth() const
返回矩阵元素的深度。
cv::cvtColor
void cvtColor(InputArray src, OutputArray dst, int code, int dstCn=0, AlgorithmHint hint=cv::ALGO_HINT_DEFAULT)
将图像从一个颜色空间转换为另一个颜色空间。
cv::COLOR_BGR2GRAY
@ COLOR_BGR2GRAY
在RGB/BGR和灰度之间转换，颜色转换
**定义** imgproc.hpp:555

您可以简单地编写

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元素向量。

参数
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

如果数组没有元素，则返回 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]

模板<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]

模板<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
定义 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 & 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;
});
cv::Point3_
用于由其坐标 x、y 和 z 指定的 3D 点的模板类。
定义 types.hpp:255
cv::Point3_::x
_Tp x
3D 点的 x 坐标
定义 types.hpp:284

示例 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];
});
cv::Mat_::forEach
void forEach(const Functor &operation)
模板方法，用于对所有矩阵元素进行操作。
cv::Mat::zeros
static CV_NODISCARD_STD MatExpr zeros(int rows, int cols, int type)
返回指定大小和类型，所有元素均为0的数组。

◆ 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 ( 访问标志 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();
}
cv::Mat::elemSize
size_t elemSize() const
返回矩阵元素的大小（以字节为单位）。

该方法在相当多的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 + ptr2[j+2]*beta);
dptr[j+3] = saturate_cast<T>((1 - (1-alpha)*(1-beta))*alpha_scale);
}
}
}
CV_MAKETYPE
#define CV_MAKETYPE(depth, cn)
定义 interface.h:85

这种方法虽然非常简单，但可以将简单的元素操作的性能提高 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 >()

模板<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 >()

模板<typename _Tp >
cv::Mat::operator std::vector< _Tp > ( ) const

◆ operator Vec< _Tp, n >()

模板<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() ( 范围 rowRange,
范围 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]

模板<typename _Tp >
_Tp * cv::Mat::ptr ( const int * idx)

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

◆ ptr() [3/20]

const uchar * cv::Mat::ptr ( const int * idx) const

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

◆ ptr() [4/20]

模板<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]

模板<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]

模板<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]

模板<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]

模板<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]

模板<typename _Tp >
_Tp * cv::Mat::ptr ( int i0 = 0)

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

◆ ptr() [15/20]

const uchar * cv::Mat::ptr ( int i0 = 0) const

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

◆ ptr() [16/20]

模板<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]

模板<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]

模板<typename _Tp >
const _Tp * cv::Mat::ptr ( int row,
int col ) const

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

参数
row维度 0 的索引
col维度 1 的索引

◆ push_back() [1/4]

模板<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]

模板<typename _Tp >
void cv::Mat::push_back ( const Mat_< _Tp > & elem)

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

参数
elem添加的元素。

◆ push_back() [4/4]

模板<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]

模板<typename _Tp >
std::reverse_iterator< MatIterator_< _Tp > > cv::Mat::rbegin ( )

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

◆ rbegin() [2/2]

模板<typename _Tp >
std::reverse_iterator< MatConstIterator_< _Tp > > cv::Mat::rbegin ( ) const

◆ release()

void cv::Mat::release ( )

递减引用计数器，如果需要则释放矩阵。

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

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

示例
samples/cpp/stitching_detailed.cpp.

◆ rend() [1/2]

模板<typename _Tp >
std::reverse_iterator< MatIterator_< _Tp > > cv::Mat::rend ( )

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

◆ rend() [2/2]

模板<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

更改二维矩阵的形状和/或通道数，无需复制数据。

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

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

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

std::vector<Point3f> vec;
...
Mat pointMat = Mat(vec). // 将向量转换为Mat，O(1)操作
reshape(1). // 将Nx1 3通道矩阵转换为Nx3 1通道矩阵。
// 同样，这是一个O(1)操作
t(); // 最后，转置Nx3矩阵。
// 这涉及复制所有元素
cv::Mat::reshape
Mat reshape(int cn, int rows=0) const
更改二维矩阵的形状和/或通道数，无需复制数据。
cv::Mat::t
MatExpr t() const
转置矩阵。

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;
}
cv::Mat::row
Mat row(int y) const
为指定的矩阵行创建矩阵头。
注意
在当前实现中，以下代码无法按预期工作：
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

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

参数
rRange 结构体，包含起始和结束索引。

◆ 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

包含多个位域

  • 魔数签名
  • 连续性标志
  • depth
  • 通道数

◆ 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
示例
fld_lines.cpp，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 的交互

此类的文档是从以下文件生成的
由 doxygen 1.12.0 于 2025年1月8日星期三16:06:37 为OpenCV生成