cv::Mat 類參考

n維密集陣列類 更多...

#include <opencv2/core/mat.hpp>

cv::Mat 的協作圖

公開型別
enum	{   MAGIC_VAL = 0x42FF0000 ,   AUTO_STEP (自動步長) = 0 ,   CONTINUOUS_FLAG = CV_MAT_CONT_FLAG ,   SUBMATRIX_FLAG = CV_SUBMAT_FLAG }
enum	{   MAGIC_MASK = 0xFFFF0000 ,   TYPE_MASK = 0x00000FFF ,   DEPTH_MASK (深度掩碼) = 7 }

公開成員函式
	Mat () CV_NOEXCEPT
	Mat (const cuda::GpuMat &m)
	從 GpuMat 下載資料
	Mat (const Mat &m)
	Mat (const Mat &m, const Range &rowRange, const Range &colRange=Range::all())
	Mat (const Mat &m, const Range *ranges)
	Mat (const Mat &m, const Rect &roi)
	Mat (const Mat &m, const std::vector< Range > &ranges)
template<typename _Tp >
	Mat (const MatCommaInitializer_< _Tp > &commaInitializer)
template<typename _Tp , int m, int n>
	Mat (const Matx< _Tp, m, n > &mtx, bool copyData=true)
template<typename _Tp >
	Mat (const Point3_< _Tp > &pt, bool copyData=true)
template<typename _Tp >
	Mat (const Point_< _Tp > &pt, bool copyData=true)
template<typename _Tp , size_t _Nm>
	Mat (const std::array< _Tp, _Nm > &arr, bool copyData=false)
template<typename _Tp , typename = typename std::enable_if<std::is_arithmetic<_Tp>::value>::type>
	Mat (const std::initializer_list< _Tp > list)
template<typename _Tp >
	Mat (const std::initializer_list< int > sizes, const std::initializer_list< _Tp > list)
template<typename _Tp >
	Mat (const std::vector< _Tp > &vec, bool copyData=false)
	Mat (const std::vector< int > &sizes, int type)
	Mat (const std::vector< int > &sizes, int type, const Scalar &s)
	Mat (const std::vector< int > &sizes, int type, void *data, const size_t *steps=0)
template<typename _Tp , int n>
	Mat (const Vec< _Tp, n > &vec, bool copyData=true)
	Mat (int ndims, const int *sizes, int type)
	Mat (int ndims, const int *sizes, int type, const Scalar &s)
	Mat (int ndims, const int *sizes, int type, void *data, const size_t *steps=0)
	Mat (int rows, int cols, int type)
	Mat (int rows, int cols, int type, const Scalar &s)
	Mat (int rows, int cols, int type, void *data, size_t step=AUTO_STEP)
	Mat (Mat &&m) CV_NOEXCEPT
	Mat (Size size, int type)
	Mat (Size size, int type, const Scalar &s)
	Mat (Size size, int type, void *data, size_t step=AUTO_STEP)
	~Mat ()
	解構函式 - 呼叫 release()
void	addref (增加引用) ()
	增加引用計數。
Mat &	adjustROI (int dtop, int dbottom, int dleft, int dright)
	調整父矩陣中子矩陣的大小和位置。
void	assignTo (Mat &m, int type=-1) const
	提供 convertTo 的函式形式。
template<typename _Tp >
_Tp &	at (const int *idx)
template<typename _Tp >
const _Tp &	at (const int *idx) const
template<typename _Tp , int n>
_Tp &	at (const Vec< int, n > &idx)
template<typename _Tp , int n>
const _Tp &	at (const Vec< int, n > &idx) const
template<typename _Tp >
_Tp &	at (int i0, int i1, int i2)
template<typename _Tp >
const _Tp &	at (int i0, int i1, int i2) const
template<typename _Tp >
_Tp &	at (int i0=0)
	返回對指定陣列元素的引用。
template<typename _Tp >
const _Tp &	at (int i0=0) const
template<typename _Tp >
_Tp &	at (int row, int col)
template<typename _Tp >
const _Tp &	at (int row, int col) const
template<typename _Tp >
_Tp &	at (Point pt)
template<typename _Tp >
const _Tp &	at (Point pt) const
template<typename _Tp >
MatIterator_< _Tp >	begin (起始迭代器) ()
	返回矩陣迭代器並將其設定為第一個矩陣元素。
template<typename _Tp >
MatConstIterator_< _Tp >	begin () const
int	channels () const
	返回矩陣通道數。
int	checkVector (int elemChannels, int depth=-1, bool requireContinuous=true) const
CV_NODISCARD_STD Mat	clone () const
	建立陣列及其底層資料的完整副本。
Mat	col (int x) const
	為指定的矩陣列建立矩陣頭。
Mat	colRange (const Range &r) const
Mat	colRange (int startcol, int endcol) const
	為指定的列範圍建立矩陣頭。
void	convertTo (OutputArray m, int rtype, double alpha=1, double beta=0) const
	將陣列轉換為另一種資料型別，並可選擇縮放。
void	copyAt (OutputArray m) const
	覆蓋現有矩陣。
void	copyAt (OutputArray m, InputArray mask) const
void	copySize (const Mat &m)
	內部使用函式；正確地重新分配 _size, _step 陣列
void	copyTo (OutputArray m) const
	將矩陣複製到另一個矩陣。
void	copyTo (OutputArray m, InputArray mask) const
void	create (const std::vector< int > &sizes, int type)
void	create (int ndims, const int *sizes, int type)
void	create (int rows, int cols, int type)
	如果需要，分配新的陣列資料。
void	create (Size size, int type)
Mat	cross (InputArray m) const
	計算兩個 3 元素向量的叉乘。
void	deallocate (反分配) ()
	內部使用函式，建議改用 'release' 方法；釋放矩陣資料
int	depth () const
	返回矩陣元素的深度。
Mat	diag (int d=0) const
	從矩陣中提取對角線。
double	dot (InputArray m) const
	計算兩個向量的點積。
size_t	elemSize () const
	以位元組為單位返回矩陣元素大小。
size_t	elemSize1 () const
	返回矩陣每個元素通道的大小（位元組）。
bool	empty () const
	如果陣列沒有元素，則返回 true。
template<typename _Tp >
MatIterator_< _Tp >	end (結束迭代器) ()
	返回矩陣迭代器並將其設定為最後一個矩陣元素之後的位置。
template<typename _Tp >
MatConstIterator_< _Tp >	end () const
template<typename _Tp , typename Functor >
void	forEach (const Functor &operation)
	並行地對所有矩陣元素執行給定的仿函式。
template<typename _Tp , typename Functor >
void	forEach (const Functor &operation) const
UMat	getUMat (AccessFlag accessFlags, UMatUsageFlags usageFlags=USAGE_DEFAULT) const
	從 Mat 檢索 UMat
MatExpr (矩陣表示式)	inv (int method=DECOMP_LU) const
	矩陣求逆。
bool	isContinuous () const
	報告矩陣是否連續。
bool	isSubmatrix () const
	如果矩陣是另一個矩陣的子矩陣，則返回 true
void	locateROI (Size &wholeSize, Point &ofs) const
	在父矩陣中定位矩陣頭。
MatExpr (矩陣表示式)	mul (InputArray m, double scale=1) const
	執行兩個矩陣的逐元素乘法或除法。
template<typename _Tp , int m, int n>
	operator Matx< _Tp, m, n > () const
template<typename _Tp , std::size_t _Nm>
	operator std::array< _Tp, _Nm > () const
template<typename _Tp >
	operator std::vector< _Tp > () const
template<typename _Tp , int n>
	operator Vec< _Tp, n > () const
Mat	operator() (const Range *ranges) const
Mat	operator() (const Rect &roi) const
Mat	operator() (const std::vector< Range > &ranges) const
Mat	operator() (Range rowRange, Range colRange) const
	提取一個矩形子矩陣。
Mat &	operator= (const Mat &m)
	賦值運算子
Mat &	operator= (const MatExpr &expr)
Mat &	operator= (const Scalar &s)
	將所有或部分陣列元素設定為指定值。
Mat &	operator= (Mat &&m)
void	pop_back (size_t nelems=1)
	從矩陣底部移除元素。
uchar *	ptr (const int *idx)
template<typename _Tp >
_Tp *	ptr (const int *idx)
const uchar *	ptr (const int *idx) const
template<typename _Tp >
const _Tp *	ptr (const int *idx) const
template<int n>
uchar *	ptr (const Vec< int, n > &idx)
template<typename _Tp , int n>
_Tp *	ptr (const Vec< int, n > &idx)
template<int n>
const uchar *	ptr (const Vec< int, n > &idx) const
template<typename _Tp , int n>
const _Tp *	ptr (const Vec< int, n > &idx) const
uchar *	ptr (int i0, int i1, int i2)
template<typename _Tp >
_Tp *	ptr (int i0, int i1, int i2)
const uchar *	ptr (int i0, int i1, int i2) const
template<typename _Tp >
const _Tp *	ptr (int i0, int i1, int i2) const
uchar *	ptr (int i0=0)
	返回指向指定矩陣行的指標。
template<typename _Tp >
_Tp *	ptr (int i0=0)
const uchar *	ptr (int i0=0) const
template<typename _Tp >
const _Tp *	ptr (int i0=0) const
uchar *	ptr (int row, int col)
template<typename _Tp >
_Tp *	ptr (int row, int col)
const uchar *	ptr (int row, int col) const
template<typename _Tp >
const _Tp *	ptr (int row, int col) const
template<typename _Tp >
void	push_back (const _Tp &elem)
	向矩陣底部新增元素。
void	push_back (const Mat &m)
template<typename _Tp >
void	push_back (const Mat_< _Tp > &elem)
template<typename _Tp >
void	push_back (const std::vector< _Tp > &elem)
void	push_back_ (const void *elem)
	內部函式
template<typename _Tp >
std::reverse_iterator< MatIterator_< _Tp > >	rbegin (反向起始迭代器) ()
	與 begin() 相同，但用於反向遍歷。
template<typename _Tp >
std::reverse_iterator< MatConstIterator_< _Tp > >	rbegin () const
Mat	reinterpret (int type) const
	重置矩陣型別。
void	release (釋放) ()
	遞減引用計數器，如果需要，反分配矩陣。
template<typename _Tp >
std::reverse_iterator< MatIterator_< _Tp > >	rend (反向結束迭代器) ()
	與 end() 相同，但用於反向遍歷。
template<typename _Tp >
std::reverse_iterator< MatConstIterator_< _Tp > >	rend () const
void	reserve (size_t sz)
	為特定數量的行預留空間。
void	reserveBuffer (size_t sz)
	為特定數量的位元組預留空間。
Mat	reshape (int cn, const std::vector< int > &newshape) const
Mat	reshape (int cn, int newndims, const int *newsz) const
Mat	reshape (int cn, int rows=0) const
	在不復制資料的情況下更改 2D 矩陣的形狀和/或通道數。
void	resize (size_t sz)
	更改矩陣行數。
void	resize (size_t sz, const Scalar &s)
Mat	row (int y) const
	為指定的矩陣行建立矩陣頭。
Mat	rowRange (const Range &r) const
Mat	rowRange (int startrow, int endrow) const
	為指定的行範圍建立矩陣頭。
Mat &	setTo (InputArray value, InputArray mask=noArray())
	將所有或部分陣列元素設定為指定值。
size_t	step1 (int i=0) const
	返回歸一化的步長。
MatExpr (矩陣表示式)	t () const
	矩陣轉置。
size_t	total () const
	返回陣列元素的總數。
size_t	total (int startDim, int endDim=INT_MAX) const
	返回陣列元素的總數。
int	type () const
	返回矩陣元素的型別。
void	updateContinuityFlag (更新連續性標誌) ()
	內部使用方法：更新連續性標誌

靜態公開成員函式
static CV_NODISCARD_STD Mat	diag (const Mat &d)
	建立對角矩陣
static CV_NODISCARD_STD MatExpr	eye (int rows, int cols, int type)
	返回指定大小和型別的單位矩陣。
static CV_NODISCARD_STD MatExpr	eye (Size size, int type)
static MatAllocator *	getDefaultAllocator (獲取預設分配器) ()
static MatAllocator *	getStdAllocator (獲取標準分配器) ()
	以及標準分配器
static CV_NODISCARD_STD MatExpr	ones (int ndims, const int *sz, int type)
static CV_NODISCARD_STD MatExpr	ones (int rows, int cols, int type)
	返回指定大小和型別的全1陣列。
static CV_NODISCARD_STD MatExpr	ones (Size size, int type)
static void	setDefaultAllocator (MatAllocator *allocator)
static CV_NODISCARD_STD MatExpr	zeros (int ndims, const int *sz, int type)
static CV_NODISCARD_STD MatExpr	zeros (int rows, int cols, int type)
	返回一個指定大小和型別的全 0 陣列。
static CV_NODISCARD_STD MatExpr	zeros (Size size, int type)

公開屬性
MatAllocator *	allocator
	自定義分配器
int	cols (列數)
uchar *	data (資料)
	指向資料的指標
const uchar *	dataend (資料結束)
const uchar *	datalimit (資料限制)
const uchar *	datastart (資料起始)
	在 locateROI 和 adjustROI 中使用的輔助欄位
int	dims (維度)
	矩陣維度，>= 2
int	flags (標誌)
int	rows (行數)
	行數和列數，當矩陣超過 2 維時為 (-1, -1)
MatSize	size (大小)
MatStep	step (步長)
UMatData *	u
	與 UMat 的互動

保護成員函式
template<typename _Tp , typename Functor >
void	forEach_impl (const Functor &operation)

詳細說明

n維密集陣列類

類 Mat 表示一個 n 維密集數值單通道或多通道陣列。它可以用於儲存實數或複數向量和矩陣、灰度或彩色影像、體素體積、向量場、點雲、張量、直方圖（儘管極高維的直方圖可能更適合儲存在 SparseMat 中）。陣列 M 的資料佈局由陣列 M.step[] 定義，因此元素 \((i_0,...,i_{M.dims-1})\) 的地址（其中 \(0\leq i_k<M.size[k]\)）計算如下：

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

對於二維陣列，上述公式簡化為：

\[addr(M_{i,j}) = M.data + M.step[0]*i + M.step[1]*j\]

注意 M.step[i] >= M.step[i+1]（事實上，M.step[i] >= M.step[i+1]*M.size[i+1]）。這意味著二維矩陣是逐行儲存的，三維矩陣是逐面儲存的，依此類推。M.step[M.dims-1] 是最小的，且始終等於元素大小 M.elemSize()。

因此，Mat 中的資料佈局與來自標準工具包和 SDK 的大多數密集陣列型別相容，例如 Numpy (ndarray)、Win32（裝置無關點陣圖）等，即與任何使用 steps（或 strides）來計算畫素位置的陣列相容。由於這種相容性，可以為使用者分配的資料建立一個 Mat 頭，並使用 OpenCV 函式進行就地處理。

建立 Mat 物件有許多不同的方法。最常用的選項列在下面：

• 使用 create(nrows, ncols, type) 方法或類似的 Mat(nrows, ncols, type[, fillValue]) 建構函式。系統會分配一個指定大小和型別的新陣列。type 的含義與 cvCreateMat 方法中的相同。例如，CV_8UC1 表示 8 位單通道陣列，CV_32FC2 表示 2 通道（複數）浮點陣列，依此類推。

  // 建立一個填充了 1+3j 的 7x7 複數矩陣。
  Mat M(7,7,CV_32FC2,Scalar(1,3));
  // 現在將 M 轉換為 100x60 的 15 通道 8 位矩陣。
  // 舊內容將被釋放
  M.create(100,60,CV_8UC(15));

  正如本章引言中所述，只有噹噹前陣列的形狀或型別與指定的不同時，create() 才會分配新陣列。
• 建立一個多維陣列

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

  它向 Mat 建構函式傳遞維數 =1，但建立的陣列將是二維的，列數設為 1。因此，Mat::dims 始終 >= 2（當陣列為空時也可以是 0）。
• 使用複製建構函式或賦值運算子，其右側可以是陣列或表示式（見下文）。正如引言中所述，陣列賦值是一個 O(1) 操作，因為它只複製頭並增加引用計數。當需要陣列的完整（深）複製時，可以使用 Mat::clone() 方法。
• 為另一個數組的一部分構造一個頭。它可以是單行、單列、若干行、若干列、陣列中的矩形區域（在代數中稱為 子式）或對角線。此類操作也是 O(1)，因為新頭引用相同的資料。實際上，你可以利用此功能修改陣列的一部分，例如：

  // 將第 5 行乘以 3 加到第 3 行
  M.row(3) = M.row(3) + M.row(5)*3;
  // 現在將第 7 列複製到第 1 列
  // M.col(1) = M.col(7); // 這行不通
  Mat M1 = M.col(1);
  M.col(7).copyTo(M1);
  // 建立一個新的 320x240 影像
  Mat img(Size(320,240),CV_8UC3);
  // 選擇一個 ROI (感興趣區域)
  Mat roi(img, Rect(10,10,100,100));
  // 將 ROI 填充為 (0,255,0)（在 RGB 空間中為綠色）；
  // 原始的 320x240 影像將被修改
  roi = Scalar(0,255,0);

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

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

  與整個矩陣的情況一樣，如果需要深複製，請使用提取出的子矩陣的 clone() 方法。
• 為使用者分配的資料建立一個頭。執行以下操作可能會很有用：
  1. 使用 OpenCV 處理“外部”資料（例如，當你實現 DirectShow* 過濾器或 gstreamer 的處理模組等時）。例如：

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

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

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

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

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

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

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

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

陣列建立後，將透過引用計數機制自動管理。如果陣列頭是建立在使用者分配的資料之上的，你應該自己處理這些資料。當沒有物件指向陣列資料時，資料將被釋放。如果你想在呼叫陣列解構函式之前釋放陣列頭指向的資料，請使用 Mat::release()。

關於陣列類，下一個要學習的重要內容是元素訪問。本手冊已經介紹瞭如何計算每個陣列元素的地址。通常，你不必直接在程式碼中使用該公式。如果你知道陣列元素型別（可以使用方法 Mat::type() 檢索），你可以訪問二維陣列的元素 \(M_{ij}\)，如下所示：

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

假設 M 是一個雙精度浮點陣列。針對不同的維數，at 方法有幾種變體。

如果你需要處理 2D 陣列的整行，最有效的方法是先獲取指向該行的指標，然後直接使用普通的 C 運算子 []：

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

某些操作（如上述操作）實際上並不依賴於陣列形狀。它們只是逐個處理陣列的元素（或者來自具有相同座標的多個數組的元素，例如陣列加法）。此類操作稱為 逐元素 操作。檢查所有輸入/輸出陣列是否連續（即每行末尾沒有間隙）是有意義的。如果是，則可以將它們作為一個長單行處理：

// 計算正矩陣元素的總和，最佳化變體
double sum=0;
int cols = M.cols, rows = M.rows;
if(M.isContinuous())
{
    cols *= rows;
    rows (行數) = 1;
}
for(int i = 0; i < rows; i++)
{
    const double* Mi = M.ptr<double>(i);
    for(int j = 0; j < cols; j++)
        sum += std::max(Mi[j], 0.);
}

在連續矩陣的情況下，外層迴圈體僅執行一次。因此，開銷更小，這在小矩陣的情況下尤為明顯。

最後，還有 STL 風格的迭代器，它們足夠智慧，可以跳過連續行之間的間隙：

// 計算正矩陣元素的總和，基於迭代器的變體
double sum=0;
MatConstIterator_<double> it = M.begin<double>(), it_end = M.end<double>();
for(; it != it_end; ++it)
    sum += std::max(*it, 0.);

矩陣迭代器是隨機訪問迭代器，因此它們可以傳遞給任何 STL 演算法，包括 std::sort()。

注意

矩陣表示式和算術運算詳見 MatExpr

示例

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

成員列舉文件

匿名列舉

匿名列舉

列舉值 (Enumerator)
MAGIC_VAL
AUTO_STEP
CONTINUOUS_FLAG
SUBMATRIX_FLAG

匿名列舉

匿名列舉

列舉值 (Enumerator)
MAGIC_MASK
TYPE_MASK
DEPTH_MASK

建構函式與解構函式說明

Mat() [1/29]

cv::Mat::Mat

(

)

這些是構成矩陣的各種建構函式。正如在 AutomaticAllocation（自動分配）中所述，預設建構函式通常已經足夠，OpenCV 函式將分配適當的矩陣。構造的矩陣可以進一步賦值給另一個矩陣或矩陣表示式，或者使用 Mat::create 進行分配。在前一種情況下，舊內容將被取消引用。

Mat() [2/29]

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

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

引數

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

Mat() [3/29]

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

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

引數

size (大小)	2D 陣列大小：Size(cols, rows)。在 Size() 建構函式中，行數和列數的順序相反。
type	陣列型別。使用 CV_8UC1, ..., CV_64FC4 建立 1-4 通道矩陣，或使用 CV_8UC(n), ..., CV_64FC(n) 建立多通道（最多 CV_CN_MAX 通道）矩陣。

Mat() [4/29]

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

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

引數

rows (行數)	2D 陣列中的行數。
cols (列數)	2D 陣列中的列數。
type	陣列型別。使用 CV_8UC1, ..., CV_64FC4 建立 1-4 通道矩陣，或使用 CV_8UC(n), ..., CV_64FC(n) 建立多通道（最多 CV_CN_MAX 通道）矩陣。
s	用於初始化每個矩陣元素的可選值。要在構造後將所有矩陣元素設定為特定值，請使用賦值運算子 Mat::operator=(const Scalar& value)。

Mat() [5/29]

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

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

引數

size (大小)	2D 陣列大小：Size(cols, rows)。在 Size() 建構函式中，行數和列數的順序相反。
type	陣列型別。使用 CV_8UC1, ..., CV_64FC4 建立 1-4 通道矩陣，或使用 CV_8UC(n), ..., CV_64FC(n) 建立多通道（最多 CV_CN_MAX 通道）矩陣。
s	用於初始化每個矩陣元素的可選值。要在構造後將所有矩陣元素設定為特定值，請使用賦值運算子 Mat::operator=(const Scalar& value)。

Mat() [6/29]

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

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

引數

ndims	陣列維數。
sizes (大小列表)	指定 n 維陣列形狀的整數陣列。
type	陣列型別。使用 CV_8UC1, ..., CV_64FC4 建立 1-4 通道矩陣，或使用 CV_8UC(n), ..., CV_64FC(n) 建立多通道（最多 CV_CN_MAX 通道）矩陣。

Mat() [7/29]

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

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

引數

sizes (大小列表)	指定 n 維陣列形狀的整數陣列。
type	陣列型別。使用 CV_8UC1, ..., CV_64FC4 建立 1-4 通道矩陣，或使用 CV_8UC(n), ..., CV_64FC(n) 建立多通道（最多 CV_CN_MAX 通道）矩陣。

Mat() [8/29]

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

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

引數

ndims	陣列維數。
sizes (大小列表)	指定 n 維陣列形狀的整數陣列。
type	陣列型別。使用 CV_8UC1, ..., CV_64FC4 建立 1-4 通道矩陣，或使用 CV_8UC(n), ..., CV_64FC(n) 建立多通道（最多 CV_CN_MAX 通道）矩陣。
s	用於初始化每個矩陣元素的可選值。要在構造後將所有矩陣元素設定為特定值，請使用賦值運算子 Mat::operator=(const Scalar& value)。

Mat() [9/29]

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

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

引數

sizes (大小列表)	指定 n 維陣列形狀的整數陣列。
type	陣列型別。使用 CV_8UC1, ..., CV_64FC4 建立 1-4 通道矩陣，或使用 CV_8UC(n), ..., CV_64FC(n) 建立多通道（最多 CV_CN_MAX 通道）矩陣。
s	用於初始化每個矩陣元素的可選值。要在構造後將所有矩陣元素設定為特定值，請使用賦值運算子 Mat::operator=(const Scalar& value)。

Mat() [10/29]

cv::Mat::Mat

(

const Mat &

m

)

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

引數

m	（全部或部分）分配給構造矩陣的陣列。這些建構函式不會複製資料。相反，它會構造並關聯一個指向 m 資料或其子陣列的頭。引用計數（如果有）會遞增。因此，當你修改使用此類建構函式形成的矩陣時，你也修改了 m 的相應元素。如果你想要一個子陣列的獨立複製，請使用 Mat::clone()。

Mat() [11/29]

cv::Mat::Mat	(	int	rows (行數),
		int	cols (列數),
		int	type,
		void *	data (資料),
		size_t	step = AUTO_STEP )

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

引數

rows (行數)	2D 陣列中的行數。
cols (列數)	2D 陣列中的列數。
type	陣列型別。使用 CV_8UC1, ..., CV_64FC4 建立 1-4 通道矩陣，或使用 CV_8UC(n), ..., CV_64FC(n) 建立多通道（最多 CV_CN_MAX 通道）矩陣。
data (資料)	指向使用者資料的指標。接收 data 和 step 引數的矩陣建構函式不會分配矩陣資料。相反，它們只是初始化指向指定資料的矩陣頭，這意味著不會複製資料。此操作非常高效，可用於使用 OpenCV 函式處理外部資料。外部資料不會自動釋放，因此你應該負責處理它。
step (步長)	每個矩陣行佔用的位元組數。該值應包括每行末尾的填充位元組（如果有）。如果缺少該引數（設定為 AUTO_STEP），則假定沒有填充，實際步長計算為 cols*elemSize()。見 Mat::elemSize。

Mat() [12/29]

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

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

引數

size (大小)	2D 陣列大小：Size(cols, rows)。在 Size() 建構函式中，行數和列數的順序相反。
type	陣列型別。使用 CV_8UC1, ..., CV_64FC4 建立 1-4 通道矩陣，或使用 CV_8UC(n), ..., CV_64FC(n) 建立多通道（最多 CV_CN_MAX 通道）矩陣。
data (資料)	指向使用者資料的指標。接收 data 和 step 引數的矩陣建構函式不會分配矩陣資料。相反，它們只是初始化指向指定資料的矩陣頭，這意味著不會複製資料。此操作非常高效，可用於使用 OpenCV 函式處理外部資料。外部資料不會自動釋放，因此你應該負責處理它。
step (步長)	每個矩陣行佔用的位元組數。該值應包括每行末尾的填充位元組（如果有）。如果缺少該引數（設定為 AUTO_STEP），則假定沒有填充，實際步長計算為 cols*elemSize()。見 Mat::elemSize。

Mat() [13/29]

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

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

引數

ndims	陣列維數。
sizes (大小列表)	指定 n 維陣列形狀的整數陣列。
type	陣列型別。使用 CV_8UC1, ..., CV_64FC4 建立 1-4 通道矩陣，或使用 CV_8UC(n), ..., CV_64FC(n) 建立多通道（最多 CV_CN_MAX 通道）矩陣。
data (資料)	指向使用者資料的指標。接收 data 和 step 引數的矩陣建構函式不會分配矩陣資料。相反，它們只是初始化指向指定資料的矩陣頭，這意味著不會複製資料。此操作非常高效，可用於使用 OpenCV 函式處理外部資料。外部資料不會自動釋放，因此你應該負責處理它。
steps	多維陣列情況下 ndims-1 個步長的陣列（最後一個步長始終設定為元素大小）。如果未指定，則假定矩陣是連續的。

Mat() [14/29]

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

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

引數

sizes (大小列表)	指定 n 維陣列形狀的整數陣列。
type	陣列型別。使用 CV_8UC1, ..., CV_64FC4 建立 1-4 通道矩陣，或使用 CV_8UC(n), ..., CV_64FC(n) 建立多通道（最多 CV_CN_MAX 通道）矩陣。
data (資料)	指向使用者資料的指標。接收 data 和 step 引數的矩陣建構函式不會分配矩陣資料。相反，它們只是初始化指向指定資料的矩陣頭，這意味著不會複製資料。此操作非常高效，可用於使用 OpenCV 函式處理外部資料。外部資料不會自動釋放，因此你應該負責處理它。
steps	多維陣列情況下 ndims-1 個步長的陣列（最後一個步長始終設定為元素大小）。如果未指定，則假定矩陣是連續的。

Mat() [15/29]

cv::Mat::Mat	(	const Mat &	m,
		const Range &	rowRange (行範圍),
		const Range &	colRange = Range::all() )

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

引數

m	（全部或部分）分配給構造矩陣的陣列。這些建構函式不會複製資料。相反，它會構造並關聯一個指向 m 資料或其子陣列的頭。引用計數（如果有）會遞增。因此，當你修改使用此類建構函式形成的矩陣時，你也修改了 m 的相應元素。如果你想要一個子陣列的獨立複製，請使用 Mat::clone()。
rowRange (行範圍)	要獲取的 m 行的範圍。照例，範圍開始是包含的，範圍結束是排除的。使用 Range::all() 獲取所有行。
colRange	要獲取的 m 列的範圍。使用 Range::all() 獲取所有列。

Mat() [16/29]

cv::Mat::Mat	(	const Mat &	m,
		const Rect &	roi (感興趣區域) )

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

引數

m	（全部或部分）分配給構造矩陣的陣列。這些建構函式不會複製資料。相反，它會構造並關聯一個指向 m 資料或其子陣列的頭。引用計數（如果有）會遞增。因此，當你修改使用此類建構函式形成的矩陣時，你也修改了 m 的相應元素。如果你想要一個子陣列的獨立複製，請使用 Mat::clone()。
roi (感興趣區域)	感興趣區域。

Mat() [17/29]

cv::Mat::Mat	(	const Mat &	m,
		const Range *	ranges (範圍陣列) )

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

引數

m	（全部或部分）分配給構造矩陣的陣列。這些建構函式不會複製資料。相反，它會構造並關聯一個指向 m 資料或其子陣列的頭。引用計數（如果有）會遞增。因此，當你修改使用此類建構函式形成的矩陣時，你也修改了 m 的相應元素。如果你想要一個子陣列的獨立複製，請使用 Mat::clone()。
ranges (範圍陣列)	沿每個維度的選定 m 範圍陣列。

Mat() [18/29]

cv::Mat::Mat	(	const Mat &	m,
		const std::vector< Range > &	ranges (範圍陣列) )

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

引數

m	（全部或部分）分配給構造矩陣的陣列。這些建構函式不會複製資料。相反，它會構造並關聯一個指向 m 資料或其子陣列的頭。引用計數（如果有）會遞增。因此，當你修改使用此類建構函式形成的矩陣時，你也修改了 m 的相應元素。如果你想要一個子陣列的獨立複製，請使用 Mat::clone()。
ranges (範圍陣列)	沿每個維度的選定 m 範圍陣列。

Mat() [19/29]

template<typename _Tp >

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

explicit (顯式)

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

引數

vec	其元素構成矩陣的 STL 向量。矩陣有一列，行數等於向量元素個數。矩陣型別與向量元素型別匹配。建構函式可以處理任意型別，只要有正確宣告的 DataType。這意味著向量元素必須是原始數字或單型別數字組成的數值元組。不支援混合型別結構。相應的建構函式是顯式的。由於 STL 向量不會自動轉換為 Mat 例項，你應該顯式編寫 Mat(vec)。除非你將資料複製到矩陣中 (copyData=true)，否則不會向向量新增新元素，因為這可能會導致向量資料重新分配，從而使矩陣資料指標失效。
copyData	標誌，指定 STL 向量的基礎資料是應複製到 (true) 還是與新構造的矩陣共享 (false)。複製資料時，分配的緩衝區使用 Mat 引用計數機制管理。當資料共享時，引用計數器為 NULL，在矩陣銷燬之前不應釋放資料。

Mat() [20/29]

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

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

explicit (顯式)

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

Mat() [21/29]

template<typename _Tp >

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

explicit (顯式)

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

Mat() [22/29]

template<typename _Tp , size_t _Nm>

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

explicit (顯式)

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

Mat() [23/29]

template<typename _Tp , int n>

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

explicit (顯式)

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

Mat() [24/29]

template<typename _Tp , int m, int n>

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

explicit (顯式)

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

Mat() [25/29]

template<typename _Tp >

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

explicit (顯式)

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

Mat() [26/29]

template<typename _Tp >

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

explicit (顯式)

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

Mat() [27/29]

template<typename _Tp >

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

explicit (顯式)

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

Mat() [28/29]

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

explicit (顯式)

從 GpuMat 下載資料

~Mat()

cv::Mat::~Mat

(

)

解構函式 - 呼叫 release()

Mat() [29/29]

cv::Mat::Mat

(

Mat &&

m

)

成員函式說明

addref()

void cv::Mat::addref

(

)

增加引用計數。

該方法增加與矩陣資料關聯的引用計數。如果矩陣頭指向外部資料集（見 Mat::Mat），則引用計數器為 NULL，在這種情況下該方法無效。通常，為了避免記憶體洩漏，不應顯式呼叫該方法。它由矩陣賦值運算子隱式呼叫。在支援它的平臺上，引用計數增加是一個原子操作。因此，在不同執行緒中非同步操作相同的矩陣是安全的。

adjustROI()

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

調整父矩陣中子矩陣的大小和位置。

該方法是對 Mat::locateROI 的補充。這些函式的典型用法是確定父矩陣中的子矩陣位置，然後以某種方式偏移該位置。通常，在需要考慮 ROI 之外畫素的濾波操作中可能需要這樣做。當所有方法引數均為正數時，ROI 需要向所有方向增長指定數量，例如：

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

在此示例中，矩陣大小在每個方向上增加了 4 個元素。矩陣向左移動 2 個元素，向上移動 2 個元素，從而為 5x5 核心的濾波引入了所有必要的畫素。

adjustROI 強制調整後的 ROI 位於父矩陣內部，即調整後 ROI 的邊界受父矩陣邊界限制。例如，如果子矩陣 A 位於父矩陣的第一行，並且你呼叫了 A.adjustROI(2, 2, 2, 2)，則 A 不會向向上方向增加。

該函式由 OpenCV 濾波函式（如 filter2D）、形態學操作等在內部使用。

引數

dtop (頂部偏移)	子矩陣上邊界向上偏移量。
dbottom (底部偏移)	子矩陣下邊界向下偏移量。
dleft (左側偏移)	子矩陣左邊界向左偏移量。
dright (右側偏移)	子矩陣右邊界向右偏移量。

另請參閱

copyMakeBorder

assignTo()

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

提供 convertTo 的函式形式。

這是由 MatrixExpressions 引擎呼叫的內部使用方法。

引數

m	目標陣列。
type	所需的目標陣列深度（如果應與源型別相同，則為 -1）。

at() [1/12]

template<typename _Tp >

_Tp & cv::Mat::at

(

const int *

idx (索引)

)

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

引數

idx (索引)

包含 Mat::dims 個索引的陣列。

at() [2/12]

template<typename _Tp >

const _Tp & cv::Mat::at

(

const int *

idx (索引)

)

const

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

引數

idx (索引)

包含 Mat::dims 個索引的陣列。

at() [3/12]

template<typename _Tp , int n>

_Tp & cv::Mat::at

(

const Vec< int, n > &

idx (索引)

)

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

at() [4/12]

template<typename _Tp , int n>

const _Tp & cv::Mat::at

(

const Vec< int, n > &

idx (索引)

)

const

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

at() [5/12]

template<typename _Tp >

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

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

引數

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

at() [6/12]

template<typename _Tp >

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

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

引數

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

at() [7/12]

template<typename _Tp >

_Tp & cv::Mat::at

(

int

i0 = 0

)

返回對指定陣列元素的引用。

模板方法返回對指定陣列元素的引用。為了提高效能，索引範圍檢查僅在 Debug 配置中執行。

請注意，具有單個索引 (i) 的變體可用於訪問單行或單列二維陣列的元素。也就是說，例如，如果 A 是 1 x N 浮點矩陣，而 B 是 M x 1 整數矩陣，你可以簡單地寫 A.at<float>(k+4) 和 B.at<int>(2*i+1)，而不用分別寫 A.at<float>(0,k+4) 和 B.at<int>(2*i+1,0)。

下面的示例初始化了一個希爾伯特矩陣：

Mat H(100, 100, CV_64F);
for(int i = 0; i < H.rows; i++)
    for(int j = 0; j < H.cols; j++)
H.at<double>(i,j)=1./(i+j+1);

請記住，at 運算子中使用的型別識別符號不能隨機選擇。它取決於你嘗試從中檢索資料的影像。下表提供了更深入的瞭解：

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

引數

i0

維度 0 的索引

示例

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

at() [8/12]

template<typename _Tp >

const _Tp & cv::Mat::at

(

int

i0 = 0

)

const

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

引數

i0

維度 0 的索引

at() [9/12]

template<typename _Tp >

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

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

引數

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

at() [10/12]

template<typename _Tp >

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

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

引數

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

at() [11/12]

template<typename _Tp >

_Tp & cv::Mat::at

(

點 (Point)

pt (點)

)

這是一個過載的成員函式，為了方便而提供。它與上述函式的區別僅在於它接受的引數不同。針對2D陣列的特殊版本（對於引用影像畫素特別方便）

引數

pt (點)

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

at() [12/12]

template<typename _Tp >

const _Tp & cv::Mat::at

(

點 (Point)

pt (點)

)

const

這是一個過載的成員函式，為了方便而提供。它與上述函式的區別僅在於它接受的引數不同。針對2D陣列的特殊版本（對於引用影像畫素特別方便）

引數

pt (點)

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

begin() [1/2]

template<typename _Tp >

MatIterator_< _Tp > cv::Mat::begin

(

)

返回矩陣迭代器並將其設定為第一個矩陣元素。

這些方法返回矩陣的只讀或讀寫迭代器。矩陣迭代器的使用與 STL 雙向迭代器的使用非常相似。在下面的示例中，使用矩陣迭代器重寫了 Alpha 混合函式

template<typename T>
void alphaBlendRGBA(const Mat& src1, const Mat& src2, Mat& dst)
{
    typedef Vec<T, 4> VT;
 
    const float alpha_scale = (float)std::numeric_limits<T>::max(),
inv_scale = 1.f/alpha_scale;
 
    CV_Assert( src1.type() == src2.type() &&
src1.type() == traits::Type<VT>::value &&
src1.size() == src2.size());
    Size size = src1.size();
dst.create(size, src1.type());
 
    MatConstIterator_<VT> it1 = src1.begin<VT>(), it1_end = src1.end<VT>();
    MatConstIterator_<VT> it2 = src2.begin<VT>();
    MatIterator_<VT> dst_it = dst.begin<VT>();
 
    for( ; it1 != it1_end; ++it1, ++it2, ++dst_it )
    {
VT pix1 = *it1, pix2 = *it2;
        float alpha = pix1[3]*inv_scale, beta = pix2[3]*inv_scale;
*dst_it = VT(saturate_cast<T>(pix1[0]*alpha + pix2[0]*beta),
                     saturate_cast<T>(pix1[1]*alpha + pix2[1]*beta),
                     saturate_cast<T>(pix1[2]*alpha + pix2[2]*beta),
                     saturate_cast<T>((1 - (1-alpha)*(1-beta))*alpha_scale));
    }
}

示例

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

begin() [2/2]

template<typename _Tp >

MatConstIterator_< _Tp > cv::Mat::begin

(

)

const

channels()

int cv::Mat::channels

(

)

const

返回矩陣通道數。

該方法返回矩陣通道數。

示例

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

checkVector()

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

引數

elemChannels	矩陣應具有的通道數或列數。對於 2-D 矩陣，當矩陣只有 1 列時，它應具有 elemChannels 個通道；當矩陣只有 1 個通道時，它應具有 elemChannels 列。對於 3-D 矩陣，它應只有 1 個通道。此外，如果平面（plane）數量不為 1，則每個平面內的行數必須為 1；如果每個平面內的行數不為 1，則平面數量必須為 1。
depth	矩陣應具有的深度。當任何深度都可以時，將其設定為 -1。
requireContinuous	設定為 true 以要求矩陣是連續的

返回

如果不滿足要求，則返回 -1。否則，返回矩陣中的元素數。請注意，一個元素可能具有多個通道。

以下程式碼演示了它在 2-d 矩陣中的用法

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

以下程式碼演示了它在 3-d 矩陣中的用法

    int dims[] = {1, 3, 5}; // 1 個平面，每個平面有 3 行 5 列
mat.create(3, dims, CV_32FC1); // 對於 3-d 矩陣，它必須只有 1 個通道
n = mat.checkVector(5); // 5 列被視為 1 個元素
    CV_Assert(n == 3);
 
    int dims2[] = {3, 1, 5}; // 3 個平面，每個平面有 1 行 5 列
mat.create(3, dims2, CV_32FC1);
n = mat.checkVector(5); // 5 列被視為 1 個元素
    CV_Assert(n == 3);

clone()

CV_NODISCARD_STD Mat cv::Mat::clone

(

)

const

建立陣列及其底層資料的完整副本。

該方法建立陣列的完整副本。原始的 step[] 不被考慮在內。因此，陣列副本是一個連續陣列，佔用 total()*elemSize() 位元組。

示例

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

col()

Mat cv::Mat::col

(

int

x

)

const

為指定的矩陣列建立矩陣頭。

該方法為指定的矩陣列建立一個新頭並返回它。無論矩陣大小如何，這都是一個 O(1) 操作。新矩陣的基礎資料與原始矩陣共享。另請參閱 Mat::row 的描述。

引數

x	從 0 開始的列索引。

示例

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

colRange() [1/2]

Mat cv::Mat::colRange

(

const Range &

r

)

const

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

引數

r	包含起始和結束索引的 Range 結構。

colRange() [2/2]

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

為指定的列範圍建立矩陣頭。

該方法為矩陣指定的列跨度建立一個新頭。類似於 Mat::row 和 Mat::col，這是一個 O(1) 操作。

引數

startcol	列跨度從 0 開始的起始索引（包含）。
endcol	列跨度從 0 開始的結束索引（不包含）。

convertTo()

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

將陣列轉換為另一種資料型別，並可選擇縮放。

該方法將源畫素值轉換為目標資料型別。最後應用 saturate_cast<> 以避免可能的溢位

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

引數

m	輸出矩陣；如果在操作前沒有合適的尺寸或型別，它將被重新分配。
rtype	所需的輸出矩陣型別，或者更確切地說是深度，因為通道數與輸入相同；如果 rtype 為負數，則輸出矩陣將具有與輸入相同的型別。
alpha	可選的縮放因子。
beta	新增到縮放值中的可選增量。

示例

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

copyAt() [1/2]

void cv::Mat::copyAt

(

OutputArray

m

)

const

覆蓋現有矩陣。

此方法寫入現有的矩陣資料，就像 copyTo() 一樣。但如果它在操作前沒有合適的尺寸或型別，則會丟擲異常。此函式有助於更新現有矩陣中的 ROI。

如果需要（重新）分配目標記憶體，請使用 copyTo()。

引數

m	目標矩陣。如果它在操作前沒有合適的尺寸或型別，則會丟擲異常。

另請參閱

copyTo

copyAt() [2/2]

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

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

引數

m	目標矩陣。如果它在操作前沒有合適的尺寸或型別，則會丟擲異常。
mask	與 *this 尺寸相同的操作掩碼。其非零元素指示需要複製哪些矩陣元素。掩碼必須是 CV_8U 型別，並且可以具有 1 個或多個通道。

copySize()

void cv::Mat::copySize

(

const Mat &

m

)

內部使用函式；正確地重新分配 _size, _step 陣列

copyTo() [1/2]

void cv::Mat::copyTo

(

OutputArray

m

)

const

將矩陣複製到另一個矩陣。

該方法將矩陣資料複製到另一個矩陣。在複製資料之前，該方法會呼叫

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

以便在需要時重新分配目標矩陣。雖然 m.copyTo(m); 可以完美執行，但該函式不處理源矩陣和目標矩陣之間部分重疊的情況。

當指定了操作掩碼時，如果上面顯示的 Mat::create 呼叫重新分配了矩陣，則新分配的矩陣在複製資料之前會初始化為全零。

如果不需要（重新）分配目標記憶體（例如更新 ROI），請使用 copyAt()。

引數

m	目標矩陣。如果它在操作前沒有合適的尺寸或型別，它將被重新分配。

另請參閱

copyAt

示例

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

copyTo() [2/2]

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

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

引數

m	目標矩陣。如果它在操作前沒有合適的尺寸或型別，它將被重新分配。
mask	與 *this 尺寸相同的操作掩碼。其非零元素指示需要複製哪些矩陣元素。掩碼必須是 CV_8U 型別，並且可以具有 1 個或多個通道。

create() [1/4]

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

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

引數

sizes (大小列表)	指定新陣列形狀的整數陣列。
type	新矩陣型別。

create() [2/4]

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

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

引數

ndims	新陣列維度。
sizes (大小列表)	指定新陣列形狀的整數陣列。
type	新矩陣型別。

create() [3/4]

void cv::Mat::create	(	int	rows (行數),
		int	cols (列數),
		int	type )

如果需要，分配新的陣列資料。

這是 Mat 的關鍵方法之一。大多數產生陣列的新式 OpenCV 函式和方法都會為每個輸出陣列呼叫此方法。該方法使用以下演算法：

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

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

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

您可以直接編寫

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

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

引數

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

示例

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

create() [4/4]

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

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

引數

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

cross()

Mat cv::Mat::cross

(

InputArray

m

)

const

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

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

引數

m

另一個叉積運算元。

示例

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

deallocate()

void cv::Mat::deallocate

(

)

內部使用函式，建議改用 'release' 方法；釋放矩陣資料

depth()

int cv::Mat::depth

(

)

const

返回矩陣元素的深度。

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

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

示例

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

diag() [1/2]

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

static (靜態)

建立對角矩陣

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

引數

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

diag() [2/2]

Mat cv::Mat::diag

(

int

d = 0

)

const

從矩陣中提取對角線。

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

引數

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

dot()

double cv::Mat::dot

(

InputArray

m

)

const

計算兩個向量的點積。

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

引數

m

另一個點積運算元。

示例

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

elemSize()

size_t cv::Mat::elemSize

(

)

const

以位元組為單位返回矩陣元素大小。

該方法以位元組為單位返回矩陣元素大小。例如，如果矩陣型別為 CV_16SC3，則該方法返回 3*sizeof(short) 或 6。

elemSize1()

size_t cv::Mat::elemSize1

(

)

const

返回矩陣每個元素通道的大小（位元組）。

該方法以位元組為單位返回矩陣元素通道大小，即它忽略通道數。例如，如果矩陣型別為 CV_16SC3，則該方法返回 sizeof(short) 或 2。

empty()

bool cv::Mat::empty

(

)

const

如果陣列沒有元素，則返回 true。

如果 Mat::total() 為 0 或 Mat::data 為 NULL，則該方法返回 true。由於 pop_back() 和 resize() 方法，M.total() == 0 並不意味著 M.data == NULL。

示例

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

end() [1/2]

template<typename _Tp >

MatIterator_< _Tp > cv::Mat::end

(

)

返回矩陣迭代器並將其設定為最後一個矩陣元素之後的位置。

該方法返回矩陣的只讀或讀寫迭代器，設定為指向最後一個矩陣元素之後的點。

示例

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

end() [2/2]

template<typename _Tp >

MatConstIterator_< _Tp > cv::Mat::end

(

)

const

eye() [1/2]

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

static (靜態)

返回指定大小和型別的單位矩陣。

該方法返回一個 Matlab 風格的單位矩陣初始化器，類似於 Mat::zeros。與 Mat::ones 類似，您可以使用縮放操作有效地建立縮放後的單位矩陣：

// 建立一個 4x4 對角線元素為 0.1 的對角矩陣。
Mat A = Mat::eye(4, 4, CV_32F)*0.1;

注意

在多通道型別的情況下，僅為第一個通道初始化單位矩陣，其他通道將設定為 0

引數

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

eye() [2/2]

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

static (靜態)

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

引數

size (大小)	另一種矩陣尺寸指定方式為 Size(cols, rows)。
type	建立的矩陣型別。

forEach() [1/2]

template<typename _Tp , typename Functor >

void cv::Mat::forEach

(

const Functor &

operation (操作)

)

並行地對所有矩陣元素執行給定的仿函式。

作為引數傳遞的操作必須是函式指標、函式物件或 lambda(C++11)。

示例 1。以下所有操作都會將所有矩陣元素的第一個通道置為 0xFF

Mat image(1920, 1080, CV_8UC3);
typedef cv::Point3_<uint8_t> Pixel;
 
// 首先。原始指標訪問。
for (int r = 0; r < image.rows; ++r) {
Pixel* ptr = image.ptr<Pixel>(r, 0);
    const Pixel* ptr_end = ptr + image.cols;
    for (; ptr != ptr_end; ++ptr) {
        ptr->x = 255;
    }
}
 
// 使用 MatIterator。（簡單，但會有迭代器的開銷）
for (Pixel &p : cv::Mat_<Pixel>(image)) {
p.x = 255;
}
 
// 使用函式物件並行執行。
struct Operator {
    void operator ()(Pixel &pixel, const int * position) {
pixel.x = 255;
    }
};
image.forEach<Pixel>(Operator());
 
// 使用 C++11 lambda 並行執行。
image.forEach<Pixel>([](Pixel &p, const int * position) -> void {
p.x = 255;
});

示例 2. 使用畫素位置

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

forEach() [2/2]

template<typename _Tp , typename Functor >

void cv::Mat::forEach

(

const Functor &

operation (操作)

)

const

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

getDefaultAllocator()

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

static (靜態)

getStdAllocator()

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

static (靜態)

以及標準分配器

getUMat()

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

從 Mat 檢索 UMat

inv()

MatExpr cv::Mat::inv

(

int

method = DECOMP_LU

)

const

矩陣求逆。

該方法透過矩陣表示式執行矩陣求逆。這意味著該方法會返回一個臨時矩陣逆物件，它可以進一步用作更復雜矩陣表示式的一部分，或者可以分配給矩陣。

引數

method

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

示例

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

isContinuous()

bool cv::Mat::isContinuous

(

)

const

報告矩陣是否連續。

如果矩陣元素連續儲存且每行末尾沒有間隙，則該方法返回 true。否則，它返回 false。顯然，1x1 或 1xN 矩陣總是連續的。使用 Mat::create 建立的矩陣總是連續的。但是如果您使用 Mat::col, Mat::diag 等提取矩陣的一部分，或者為外部分配的資料構造矩陣頭，此類矩陣可能不再具有此屬性。

連續性標誌作為一位儲存在 Mat::flags 欄位中，並在您構造矩陣頭時自動計算。因此，連續性檢查是一項非常快速的操作，儘管從理論上講它可以按如下方式完成：

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

該方法在相當多的 OpenCV 函式中使用。關鍵點在於，逐元素操作（如算術和邏輯操作、數學函式、Alpha 混合、顏色空間變換等）不依賴於影像幾何形狀。因此，如果所有輸入和輸出陣列都是連續的，則函式可以將它們作為非常長的單行向量處理。下面的示例說明了如何實現 Alpha 混合函式：

template<typename T>
void alphaBlendRGBA(const Mat& src1, const Mat& src2, Mat& dst)
{
    const float alpha_scale = (float)std::numeric_limits<T>::max(),
inv_scale = 1.f/alpha_scale;
 
    CV_Assert( src1.type() == src2.type() &&
src1.type() == CV_MAKETYPE(traits::Depth<T>::value, 4) &&
src1.size() == src2.size());
    Size size = src1.size();
dst.create(size, src1.type());
 
    // 這是一個習慣用法：檢查陣列的連續性，
    // 如果是連續的，
    // 則將陣列視為 1D 向量
    if( src1.isContinuous() && src2.isContinuous() && dst.isContinuous() )
    {
        size.width *= size.height;
        size.height = 1;
    }
    size.width *= 4;
 
    for( int i = 0; i < size.height; i++ )
    {
        // 當陣列連續時，
        // 外層迴圈僅執行一次
        const T* ptr1 = src1.ptr<T>(i);
        const T* ptr2 = src2.ptr<T>(i);
T* dptr = dst.ptr<T>(i);
 
        for( int j = 0; j < size.width; j += 4 )
        {
            float alpha = ptr1[j+3]*inv_scale, beta = ptr2[j+3]*inv_scale;
dptr[j] = saturate_cast<T>(ptr1[j]*alpha + ptr2[j]*beta);
dptr[j+1] = saturate_cast<T>(ptr1[j+1]*alpha + ptr2[j+1]*beta);
dptr[j+2] = saturate_cast<T>(ptr1[j+2]*alpha + ptr2[j+2]*beta);
dptr[j+3] = saturate_cast<T>((1 - (1-alpha)*(1-beta))*alpha_scale);
        }
    }
}

這種方法雖然非常簡單，但可以將簡單元素操作的效能提高 10-20%，尤其是當影像相當小且操作非常簡單時。

此函式中的另一個 OpenCV 習慣用法是為目標陣列呼叫 Mat::create，它會分配目標陣列，除非它已經具有合適的尺寸和型別。雖然新分配的陣列總是連續的，但您仍然需要檢查目標陣列，因為 Mat::create 並不總是分配新矩陣。

示例

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

isSubmatrix()

bool cv::Mat::isSubmatrix

(

)

const

如果矩陣是另一個矩陣的子矩陣，則返回 true

locateROI()

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

在父矩陣中定位矩陣頭。

在您使用 Mat::row, Mat::col, Mat::rowRange, Mat::colRange 等從矩陣中提取子矩陣後，生成的子矩陣僅指向原始大矩陣的一部分。但是，每個子矩陣都包含資訊（由 datastart 和 dataend 欄位表示），這些資訊有助於重建原始矩陣尺寸以及提取的子矩陣在原始矩陣中的位置。方法 locateROI 正是用於此目的。

引數

wholeSize	輸出引數，包含以 this 為一部分的整個矩陣的大小。
ofs	輸出引數，包含 this 在整個矩陣中的偏移量。

mul()

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

執行兩個矩陣的逐元素乘法或除法。

該方法返回一個對陣列逐元素乘法的臨時編碼物件，帶有可選的縮放。請注意，這不符合更簡單的 "\*" 運算子對應的矩陣乘法。

示例

Mat C = A.mul(5/B); // 相當於 divide(A, B, C, 5)

引數

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

ones() [1/3]

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

static (靜態)

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

引數

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

ones() [2/3]

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

static (靜態)

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

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

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

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

注意

在多通道型別的情況下，只有第一個通道會被初始化為全 1，其他通道將被設定為 0。

引數

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

ones() [3/3]

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

static (靜態)

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

引數

size (大小)	另一種矩陣尺寸指定方式 Size(cols, rows)。
type	建立的矩陣型別。

operator Matx< _Tp, m, n >()

template<typename _Tp , int m, int n>

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

(

)

const

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

template<typename _Tp , std::size_t _Nm>

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

(

)

const

operator std::vector< _Tp >()

template<typename _Tp >

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

(

)

const

operator Vec< _Tp, n >()

template<typename _Tp , int n>

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

(

)

const

operator()() [1/4]

Mat cv::Mat::operator()

(

const Range *

ranges (範圍陣列)

)

const

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

引數

ranges (範圍陣列)

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

operator()() [2/4]

Mat cv::Mat::operator()

(

const Rect &

roi (感興趣區域)

)

const

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

引數

roi (感興趣區域)

指定為矩形的提取出的子矩陣。

operator()() [3/4]

Mat cv::Mat::operator()

(

const std::vector< Range > &

ranges (範圍陣列)

)

const

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

引數

ranges (範圍陣列)

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

operator()() [4/4]

Mat cv::Mat::operator()	(	Range	rowRange (行範圍),
		Range	colRange ) const

提取一個矩形子矩陣。

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

引數

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

operator=() [1/4]

Mat & cv::Mat::operator=

(

const Mat &

m

)

賦值運算子

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

引數

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

operator=() [2/4]

Mat & cv::Mat::operator=

(

const MatExpr &

expr

)

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

引數

expr	被賦值的矩陣表示式物件。與賦值操作的第一種形式相反，如果已分配的矩陣具有正確的尺寸和型別以適應矩陣表示式的結果，則第二種形式可以重用該矩陣。它由矩陣表示式展開成的實際函式自動處理。例如，C=A+B 展開為 add(A, B, C)，而 add 負責自動重新分配 C。

operator=() [3/4]

Mat & cv::Mat::operator=

(

const Scalar &

s

)

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

引數

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

operator=() [4/4]

Mat & cv::Mat::operator=

(

Mat &&

m

)

pop_back()

void cv::Mat::pop_back

(

size_t

nelems = 1

)

從矩陣底部移除元素。

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

引數

nelems

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

ptr() [1/20]

uchar * cv::Mat::ptr

(

const int *

idx (索引)

)

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

ptr() [2/20]

template<typename _Tp >

_Tp * cv::Mat::ptr

(

const int *

idx (索引)

)

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

ptr() [3/20]

const uchar * cv::Mat::ptr

(

const int *

idx (索引)

)

const

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

ptr() [4/20]

template<typename _Tp >

const _Tp * cv::Mat::ptr

(

const int *

idx (索引)

)

const

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

ptr() [5/20]

template<int n>

uchar * cv::Mat::ptr

(

const Vec< int, n > &

idx (索引)

)

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

ptr() [6/20]

template<typename _Tp , int n>

_Tp * cv::Mat::ptr

(

const Vec< int, n > &

idx (索引)

)

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

ptr() [7/20]

template<int n>

const uchar * cv::Mat::ptr

(

const Vec< int, n > &

idx (索引)

)

const

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

ptr() [8/20]

template<typename _Tp , int n>

const _Tp * cv::Mat::ptr

(

const Vec< int, n > &

idx (索引)

)

const

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

ptr() [9/20]

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

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

ptr() [10/20]

template<typename _Tp >

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

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

ptr() [11/20]

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

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

ptr() [12/20]

template<typename _Tp >

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

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

ptr() [13/20]

uchar * cv::Mat::ptr

(

int

i0 = 0

)

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

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

引數

i0	從 0 開始的行索引。

示例

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

ptr() [14/20]

template<typename _Tp >

_Tp * cv::Mat::ptr

(

int

i0 = 0

)

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

ptr() [15/20]

const uchar * cv::Mat::ptr

(

int

i0 = 0

)

const

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

ptr() [16/20]

template<typename _Tp >

const _Tp * cv::Mat::ptr

(

int

i0 = 0

)

const

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

ptr() [17/20]

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

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

引數

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

ptr() [18/20]

template<typename _Tp >

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

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

引數

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

ptr() [19/20]

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

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

引數

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

ptr() [20/20]

template<typename _Tp >

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

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

引數

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

push_back() [1/4]

template<typename _Tp >

void cv::Mat::push_back

(

const _Tp &

elem

)

向矩陣底部新增元素。

這些方法在矩陣底部新增一個或多個元素。它們模仿 STL vector 類的相應方法。當 elem 是 Mat 時，它的型別和列數必須與容器矩陣中的相同。

引數

elem

新增的元素。

push_back() [2/4]

void cv::Mat::push_back

(

const Mat &

m

)

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

引數

m

新增的行。

push_back() [3/4]

template<typename _Tp >

void cv::Mat::push_back

(

const Mat_< _Tp > &

elem

)

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

引數

elem

新增的元素。

push_back() [4/4]

template<typename _Tp >

void cv::Mat::push_back

(

const std::vector< _Tp > &

elem

)

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

引數

elem

新增的元素。

push_back_()

void cv::Mat::push_back_

(

const void *

elem

)

內部函式

rbegin() [1/2]

template<typename _Tp >

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

(

)

與 begin() 相同，但用於反向遍歷。

rbegin() [2/2]

template<typename _Tp >

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

(

)

const

reinterpret()

Mat cv::Mat::reinterpret

(

int

type

)

const

重置矩陣型別。

這些方法重置矩陣的資料型別。如果矩陣的新型別和舊型別具有相同的元素大小，則可以重用當前的緩衝區。該方法需要考慮當前的 mat 是否為子矩陣或是否有任何引用。

引數

type

新資料型別。

release()

void cv::Mat::release

(

)

遞減引用計數器，如果需要，反分配矩陣。

該方法遞減與矩陣資料關聯的引用計數器。當引用計數器達到 0 時，矩陣資料將被釋放，並且資料和引用計數器指標將被設定為 NULL。如果矩陣頭指向外部資料集（參見 Mat::Mat），則引用計數器為 NULL，在這種情況下該方法不起作用。

可以手動呼叫此方法以強制釋放矩陣資料。但由於此方法在解構函式中或由更改資料指標的任何其他方法自動呼叫，因此通常不需要這樣做。在支援它的平臺上，引用計數器的遞減和 0 檢查是一項原子操作。因此，在不同執行緒中非同步操作相同的矩陣是安全的。

示例

samples/cpp/stitching_detailed.cpp.

rend() [1/2]

template<typename _Tp >

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

(

)

與 end() 相同，但用於反向遍歷。

rend() [2/2]

template<typename _Tp >

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

(

)

const

reserve()

void cv::Mat::reserve

(

size_t

sz

)

為特定數量的行預留空間。

該方法為 sz 行預留空間。如果矩陣已經有足夠的空間儲存 sz 行，則不執行任何操作。如果矩陣被重新分配，前 Mat::rows 行將被保留。該方法模仿了 STL vector 類的相應方法。

引數

sz

行數。

reserveBuffer()

void cv::Mat::reserveBuffer

(

size_t

sz

)

為特定數量的位元組預留空間。

該方法預留 sz 位元組的空間。如果矩陣已經有足夠的空間儲存 sz 位元組，則不執行任何操作。如果必須重新分配矩陣，其先前的內容可能會丟失。

引數

sz

位元組數。

reshape() [1/3]

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

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

引數

cn	新的通道數。如果引數為 0，則通道數保持不變。
newshape	包含所有維度新矩陣尺寸的向量。如果某些尺寸為零，則假定這些維度使用原始尺寸。

reshape() [2/3]

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

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

引數

cn	新的通道數。如果引數為 0，則通道數保持不變。
newndims	新的維度數。
newsz	包含所有維度新矩陣尺寸的陣列。如果某些尺寸為零，則假定這些維度使用原始尺寸。

reshape() [3/3]

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

在不復制資料的情況下更改 2D 矩陣的形狀和/或通道數。

該方法為 *this 的元素建立一個新的矩陣頭。新矩陣可以具有不同的尺寸和/或不同的通道數。任何組合都是可能的，只要：

• 新矩陣中沒有包含額外的元素，也沒有排除任何元素。因此，變換後 rows*cols*channels() 的乘積必須保持不變。
• 不復制資料。也就是說，這是一個 O(1) 操作。因此，如果您更改行數，或者該操作以某種其他方式更改了元素行的索引，則矩陣必須是連續的。請參閱 Mat::isContinuous。

例如，如果有一組儲存為 STL vector 的 3D 點，並且您想將這些點表示為 3xN 矩陣，請執行以下操作：

std::vector<Point3f> vec;
...
Mat pointMat = Mat(vec); // 將 vector 轉換為 Mat，O(1) 操作
                  reshape(1); // 將 Nx1 的 3 通道矩陣轉換為 Nx3 的 1 通道矩陣。
                              // 同樣是 O(1) 操作
                     t(); // 最後，轉置 Nx3 矩陣。
                          // 這涉及複製所有元素

將 3 通道 2x2 矩陣重塑為 1 通道 4x3 矩陣，每一列包含來自原始通道之一的值

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

或者

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

引數

cn	新的通道數。如果引數為 0，則通道數保持不變。
rows (行數)	新的行數。如果引數為 0，則行數保持不變。

示例

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

resize() [1/2]

void cv::Mat::resize

(

size_t

sz

)

更改矩陣行數。

這些方法用於更改矩陣行數。如果矩陣被重新分配記憶體，則保留前 min(Mat::rows, sz) 行。這些方法模擬了 STL vector 類的相應方法。

引數

sz

新行數。

resize() [2/2]

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

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

引數

sz	新行數。
s	分配給新新增元素的值。

row()

Mat cv::Mat::row

(

int

y

)

const

為指定的矩陣行建立矩陣頭。

該方法為指定的矩陣行建立一個新頭並將其返回。無論矩陣大小如何，這都是一個 O(1) 操作。新矩陣的基礎資料與原始矩陣共享。以下是一個經典的矩陣基礎處理操作 axpy 的示例，該操作被 LU 分解和許多其他演算法使用：

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

注意

在當前的實現中，以下程式碼無法按預期工作：

Mat A;
...
A.row(i) = A.row(j); // 將不起作用

這是因為 A.row(i) 形成了一個臨時頭，隨後該臨時頭被賦值給另一個頭。請記住，這些操作中的每一個都是 O(1)，也就是說，沒有資料被複制。因此，如果您期望將第 j 行復制到第 i 行，上述賦值是不成立的。要實現這一點，您應該將這個簡單的賦值變成一個表示式，或者使用 Mat::copyTo 方法：

Mat A;
...
// 可行，但看起來有點晦澀。
A.row(i) = A.row(j) + 0;
// 這雖然長一點，但是推薦的方法。
A.row(j).copyTo(A.row(i));

引數

y	從 0 開始的行索引。

示例

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

rowRange() [1/2]

Mat cv::Mat::rowRange

(

const Range &

r

)

const

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

引數

r	包含起始和結束索引的 Range 結構。

rowRange() [2/2]

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

為指定的行範圍建立矩陣頭。

該方法為矩陣的指定行範圍建立一個新頭。類似於 Mat::row 和 Mat::col，這是一個 O(1) 操作。

引數

startrow	行範圍的起始索引（包含，從 0 開始）。
endrow	行範圍的結束索引（不包含，從 0 開始）。

示例

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

setDefaultAllocator()

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

static (靜態)

setTo()

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

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

這是 Mat::operator=(const Scalar& s) 運算子的高階變體。

引數

value (值)	轉換為實際陣列型別的被賦值的標量。
mask	與 *this 尺寸相同的操作掩碼。其非零元素表示需要複製哪些矩陣元素。掩碼必須是 CV_8U 型別，並且可以具有 1 個或多個通道

示例

samples/dnn/segmentation.cpp.

step1()

size_t cv::Mat::step1

(

int

i = 0

)

const

返回歸一化的步長。

該方法返回矩陣步長除以 Mat::elemSize1()。它可以用於快速訪問任意矩陣元素。

t()

MatExpr cv::Mat::t

(

)

const

矩陣轉置。

該方法透過矩陣表示式執行矩陣轉置。它不執行實際的轉置，而是返回一個臨時的矩陣轉置物件，該物件可以進一步用作更復雜的矩陣表示式的一部分，或者可以賦值給一個矩陣

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

示例

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

total() [1/2]

size_t cv::Mat::total

(

)

const

返回陣列元素的總數。

該方法返回陣列元素的數量（如果陣列代表影像，則為畫素數）。

示例

samples/cpp/train_HOG.cpp.

total() [2/2]

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

返回陣列元素的總數。

該方法返回符合 startDim <= dim < endDim 的特定子陣列切片中的元素數量

type()

int cv::Mat::type

(

)

const

返回矩陣元素的型別。

該方法返回矩陣元素型別。這是一個與 CvMat 型別系統相容的識別符號，如 CV_16SC3 或 16 位有符號 3 通道陣列等。

示例

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

updateContinuityFlag()

void cv::Mat::updateContinuityFlag

(

)

內部使用方法：更新連續性標誌

zeros() [1/3]

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

static (靜態)

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

引數

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

zeros() [2/3]

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

static (靜態)

返回一個指定大小和型別的全 0 陣列。

該方法返回一個 Matlab 風格的全零陣列初始化器。它可以用於快速形成一個常數陣列作為函式引數、矩陣表示式的一部分或作為矩陣初始化器

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

在上面的例子中，只有當 A 不是 3x3 浮點矩陣時，才會分配一個新矩陣。否則，現有的矩陣 A 將被填滿零。

引數

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

示例

samples/cpp/fitellipse.cpp.

zeros() [3/3]

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

static (靜態)

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

引數

size (大小)	另一種矩陣尺寸指定方式 Size(cols, rows)。
type	建立的矩陣型別。

成員資料文件

allocator

MatAllocator* cv::Mat::allocator

自定義分配器

cols

int cv::Mat::cols

示例

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

data

uchar* cv::Mat::data

指向資料的指標

示例

samples/dnn/segmentation.cpp.

dataend

const uchar* cv::Mat::dataend

datalimit

const uchar* cv::Mat::datalimit

datastart

const uchar* cv::Mat::datastart

在 locateROI 和 adjustROI 中使用的輔助欄位

dims

int cv::Mat::dims

矩陣維度，>= 2

flags

int cv::Mat::flags

包含幾個位域：

• 魔術簽名 (magic signature)
• 連續性標誌 (continuity flag)
• depth
• 通道數 (number of channels)

rows

int cv::Mat::rows

行數和列數，當矩陣超過 2 維時為 (-1, -1)

示例

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

size

MatSize cv::Mat::size

示例

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

step

MatStep cv::Mat::step

u

UMatData* cv::Mat::u

與 UMat 的互動

---

該類的文件是由以下檔案生成的

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