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

  如本章引言所述，create() 僅在當前陣列的形狀或型別與指定的不同時才分配新陣列。
• 建立多維陣列

  // 建立一個 100x100x100 的 8 位陣列
  int sz[] = {100, 100, 100};
  Mat bigCube(3, sz, CV_8U, Scalar::all(0));

  它將維度數=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);

  由於附加的 datastart 和 dataend 成員，可以使用 locateROI() 計算主 *容器* 陣列中相對子陣列的位置：

  Mat A = Mat::eye(10, 10, CV_32S);
  // 提取 A 的列，從 1（包含）到 3（不包含）。
  Mat B = A(Range::all(), Range(1, 3));
  // 提取 B 的行，從 5（包含）到 9（不包含）。
  // 即，C ~ A(Range(5, 9), Range(1, 3))
  Mat C = B(Range(5, 9), Range::all());
  Size size; Point ofs;
  C.locateROI(size, ofs);
  // size 將是 (width=10,height=10)，ofs 將是 (x=1, y=5)

  與整個矩陣的情況一樣，如果需要深層副本，請使用提取的子矩陣的 clone() 方法。
• 為使用者分配的資料建立頭。這對於以下情況很有用：
  1. 使用 OpenCV 處理“外部”資料（例如，當您實現 DirectShow* 過濾器或 gstreamer 的處理模組時）。例如：

     Mat process_video_frame(const unsigned char* pixels,
                             int width, int height, int step)
     {
         // 包裝輸入緩衝區
         Mat img(height, width, CV_8UC3, (unsigned char*)pixels, step);
      
         Mat result;
         GaussianBlur(img, result, Size(7, 7), 1.5, 1.5);
      
         return result;
     }

  2. 快速初始化小型矩陣和/或獲得超快速元素訪問。

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

• 使用 MATLAB 風格的陣列初始化器，例如 zeros()、ones()、eye()：

  // 建立一個雙精度單位矩陣並將其新增到 M。
  M += Mat::eye(M.rows, M.cols, CV_64F);

• 使用逗號分隔的初始化器

  // 建立一個 3x3 雙精度單位矩陣
  Mat M = (Mat_<double>(3,3) << 1, 0, 0, 0, 1, 0, 0, 0, 1);

  使用這種方法，您首先呼叫 Mat 類的建構函式並傳入適當的引數，然後只需使用 << 運算子，後面跟著逗號分隔的值，這些值可以是常量、變數、表示式等。另外，請注意需要額外的括號以避免編譯錯誤。

陣列建立後，它透過引用計數機制自動管理。如果陣列頭是基於使用者分配的資料構建的，則應自行處理資料。當沒有引用指向陣列資料時，資料將被釋放。如果要在陣列解構函式呼叫之前釋放陣列頭指向的資料，請使用 Mat::release()。

接下來需要了解的陣列類重要內容是元素訪問。本手冊已經描述瞭如何計算每個陣列元素的地址。通常，您不需要直接在程式碼中使用該公式。如果您知道陣列元素型別（可以使用 Mat::type() 方法檢索），則可以訪問二維陣列的元素 \(M_{ij}\) 如下：

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

假設 M 是一個雙精度浮點陣列。at 方法有多種變體，適用於不同維數。

如果您需要處理二維陣列的整行，最有效的方法是首先獲取指向該行的指標，然後直接使用普通的 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 函式和方法都會為每個輸出陣列呼叫此方法。該方法使用以下演算法：

1. 如果當前陣列形狀和型別與新的匹配，則立即返回。否則，透過呼叫 Mat::release 取消引用先前的資料。
2. 初始化新頭。
3. 分配新的資料，大小為 total()*elemSize() 位元組。
4. 分配與資料關聯的新引用計數器並將其設定為 1。

這種方案使記憶體管理既健壯又高效，並有助於避免額外的輸入。這意味著通常無需顯式分配輸出陣列。也就是說，不用寫：

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

您可以簡單地寫：

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

因為 cvtColor 以及大多數 OpenCV 函式都會在內部為輸出陣列呼叫 Mat::create()。

引數

rows	新行數。
cols	新列數。
type	新矩陣型別。

示例

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

create() [4/4]

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

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

引數

size	替代新矩陣尺寸規範：Size(cols, rows)
type	新矩陣型別。

cross()

Mat cv::Mat::cross

(

InputArray

m

)

const

計算兩個 3 元素向量的叉積。

該方法計算兩個 3 元素向量的叉積。這些向量必須是形狀和大小相同的 3 元素浮點向量。結果是另一個與運算元形狀和型別相同的 3 元素向量。

引數

m

另一個叉積運算元。

示例

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

deallocate()

void cv::Mat::deallocate

(

)

內部使用的函式，考慮使用 'release' 方法代替；釋放矩陣資料

depth()

int cv::Mat::depth

(

)

const

返回矩陣元素的深度。

該方法返回矩陣元素深度的識別符號（每個單獨通道的型別）。例如，對於 16 位有符號元素陣列，該方法返回 CV_16S。完整的矩陣型別列表包含以下值：

• CV_8U - 8 位無符號整數 (0..255)
• CV_8S - 8 位有符號整數 (-128..127)
• CV_16U - 16 位無符號整數 (0..65535)
• CV_16S - 16 位有符號整數 (-32768..32767)
• CV_32S - 32 位有符號整數 (-2147483648..2147483647)
• CV_32F - 32 位浮點數 (-FLT_MAX..FLT_MAX, INF, NAN)
• CV_64F - 64 位浮點數 (-DBL_MAX..DBL_MAX, INF, NAN)

示例

samples/cpp/camshiftdemo.cpp, 和 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp。

diag() [1/2]

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

static

建立對角矩陣

該方法從指定主對角線建立方對角矩陣。

引數

d	表示主對角線的一維矩陣。

diag() [2/2]

Mat cv::Mat::diag

(

int

d = 0

)

const

從矩陣中提取對角線。

該方法為指定矩陣對角線建立一個新頭部。新矩陣表示為單列矩陣。與 Mat::row 和 Mat::col 類似，這是一個 O(1) 操作。

引數

d	對角線索引，具有以下值： d=0 是主對角線。 d<0 是下半部分的對角線。例如，d=-1 表示對角線緊鄰主對角線下方。 d>0 是上半部分的對角線。例如，d=1 表示對角線緊鄰主對角線上方。例如： Mat m = (Mat_<int>(3,3) << 1,2,3, 4,5,6, 7,8,9); Mat d0 = m.diag(0); Mat d1 = m.diag(1); Mat d_1 = m.diag(-1); 結果矩陣為： d0 = [1; 5; 9] d1 = [2; 6] d_1 = [4; 8]

dot()

double cv::Mat::dot

(

InputArray

m

)

const

計算兩個向量的點積。

該方法計算兩個矩陣的點積。如果矩陣不是單列或單行向量，則使用從上到下、從左到右的掃描順序將它們視為一維向量。向量必須具有相同的大小和型別。如果矩陣有多個通道，則將所有通道的點積相加。

引數

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;

注意

如果是多通道型別，則僅初始化第一個通道的單位矩陣，其他通道將設定為 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)

引數

m	另一個與 *this 具有相同型別和大小的陣列，或一個矩陣表示式。
scale	可選的比例因子。

ones() [1/3]

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

static

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

引數

ndims	陣列維度。
sz	指定陣列形狀的整數陣列。
type	建立的矩陣型別。

ones() [2/3]

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

static

返回指定大小和型別的全1陣列。

該方法返回 Matlab 風格的全 1 陣列初始化器，類似於 Mat::zeros。請注意，使用此方法，您可以使用以下 Matlab 習語初始化一個具有任意值的陣列：

Mat A = Mat::ones(100, 100, CV_8U)*3; // 建立一個填充了 3 的 100x100 矩陣。

上述操作不會形成一個 100x100 的全 1 矩陣，然後將其乘以 3。相反，它只是記住比例因子（本例中為 3），並在實際呼叫矩陣初始化器時使用它。

注意

如果是多通道型別，則只有第一個通道將用 1 初始化，其他通道將設定為 0。

引數

rows	行數。
cols	列數。
type	建立的矩陣型別。

ones() [3/3]

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

static

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

引數

size	矩陣大小規範的替代方案 Size(cols, rows)。
type	建立的矩陣型別。

operator Matx< _Tp, m, n >()

template<typename _Tp , int m, int n>

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

(

)

const

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

template<typename _Tp , std::size_t _Nm>

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

(

)

const

operator std::vector< _Tp >()

template<typename _Tp >

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

(

)

const

operator Vec< _Tp, n >()

template<typename _Tp , int n>

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

(

)

const

operator()() [1/4]

Mat cv::Mat::operator()

(

const Range *

ranges

)

const

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

引數

ranges

沿每個陣列維度選擇的範圍陣列。

operator()() [2/4]

Mat cv::Mat::operator()

(

const Rect &

roi

)

const

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

引數

roi	作為矩形指定的提取子矩陣。

operator()() [3/4]

Mat cv::Mat::operator()

(

const std::vector< Range > &

ranges

)

const

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

引數

ranges

沿每個陣列維度選擇的範圍陣列。

operator()() [4/4]

Mat cv::Mat::operator()	(	Range	rowRange,
		Range	colRange ) const

提取一個矩形子矩陣。

這些運算子為 *this 的指定子陣列建立新的頭部。它們是 Mat::row、Mat::col、Mat::rowRange 和 Mat::colRange 最通用的形式。例如，A(Range(0, 10), Range::all()) 等價於 A.rowRange(0, 10)。與上述所有操作類似，這些運算子是 O(1) 操作，即不復制任何矩陣資料。

引數

rowRange	提取子矩陣的起始行和結束行。不包含上限。要選擇所有行，請使用 Range::all()。
colRange	提取子矩陣的起始列和結束列。不包含上限。要選擇所有列，請使用 Range::all()。

operator=() [1/4]

Mat & cv::Mat::operator=

(

const Mat &

m

)

賦值運算子

這些是可用的賦值運算子。由於它們都非常不同，請務必閱讀運算子引數說明。

引數

m	被賦值的右側矩陣。矩陣賦值是一個 O(1) 操作。這意味著不復制資料，而是共享資料，並且引用計數器（如果有）遞增。在分配新資料之前，透過 Mat::release 解除舊資料的引用。

operator=() [2/4]

Mat & cv::Mat::operator=

(

const MatExpr &

expr

)

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

引數

expr	被賦值的矩陣表示式物件。與賦值操作的第一種形式相反，第二種形式可以重用已分配的矩陣，如果其大小和型別適合矩陣表示式的結果。這由矩陣表示式擴充套件到的實際函式自動處理。例如，C=A+B 擴充套件為 add(A, B, C)，add 負責自動重新分配 C。

operator=() [3/4]

Mat & cv::Mat::operator=

(

const Scalar &

s

)

將所有或部分陣列元素設定為指定值。

引數

s	轉換為實際陣列型別的賦值標量。

operator=() [4/4]

Mat & cv::Mat::operator=

(

Mat &&

m

)

pop_back()

void cv::Mat::pop_back

(

size_t

nelems = 1

)

從矩陣底部移除元素。

該方法從矩陣底部刪除一行或多行。

引數

nelems

刪除的行數。如果大於總行數，則丟擲異常。

ptr() [1/20]

uchar * cv::Mat::ptr

(

const int *

idx

)

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

ptr() [2/20]

template<typename _Tp >

_Tp * cv::Mat::ptr

(

const int *

idx

)

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

ptr() [3/20]

const uchar * cv::Mat::ptr

(

const int *

idx

)

const

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

ptr() [4/20]

template<typename _Tp >

const _Tp * cv::Mat::ptr

(

const int *

idx

)

const

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

ptr() [5/20]

template<int n>

uchar * cv::Mat::ptr

(

const Vec< int, n > &

idx

)

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

ptr() [6/20]

template<typename _Tp , int n>

_Tp * cv::Mat::ptr

(

const Vec< int, n > &

idx

)

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

ptr() [7/20]

template<int n>

const uchar * cv::Mat::ptr

(

const Vec< int, n > &

idx

)

const

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

ptr() [8/20]

template<typename _Tp , int n>

const _Tp * cv::Mat::ptr

(

const Vec< int, n > &

idx

)

const

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

ptr() [9/20]

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

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

ptr() [10/20]

template<typename _Tp >

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

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

ptr() [11/20]

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

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

ptr() [12/20]

template<typename _Tp >

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

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

ptr() [13/20]

uchar * cv::Mat::ptr

(

int

i0 = 0

)

返回指向指定矩陣行的指標。

這些方法返回 uchar* 或指向指定矩陣行的型別化指標。請參閱 Mat::isContinuous 中的示例，瞭解如何使用這些方法。

引數

i0	一個從 0 開始的行索引。

示例

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

ptr() [14/20]

template<typename _Tp >

_Tp * cv::Mat::ptr

(

int

i0 = 0

)

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

ptr() [15/20]

const uchar * cv::Mat::ptr

(

int

i0 = 0

)

const

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

ptr() [16/20]

template<typename _Tp >

const _Tp * cv::Mat::ptr

(

int

i0 = 0

)

const

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

ptr() [17/20]

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

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

引數

row	沿維度 0 的索引
col	沿維度 1 的索引

ptr() [18/20]

template<typename _Tp >

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

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

引數

row	沿維度 0 的索引
col	沿維度 1 的索引

ptr() [19/20]

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

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

引數

row	沿維度 0 的索引
col	沿維度 1 的索引

ptr() [20/20]

template<typename _Tp >

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

這是一個過載的成員函式，為方便起見而提供。它與上述函式唯一的區別在於它接受的引數。

引數

row	沿維度 0 的索引
col	沿維度 1 的索引

push_back() [1/4]

template<typename _Tp >

void cv::Mat::push_back

(

const _Tp &

elem

)

向矩陣底部新增元素。

這些方法向矩陣底部新增一個或多個元素。它們模仿 STL 向量類的相應方法。當 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