n-dimensional dense array class [詳解]

#include <mat.hpp>

cv::Mat_< _Tp >に継承されています。

公開型
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 (int rows, int cols, int type)

	Mat (Size size, int type)

	Mat (int rows, int cols, int type, const Scalar &s)

	Mat (Size size, int type, const Scalar &s)

	Mat (int ndims, const int *sizes, int type)

	Mat (const std::vector< int > &sizes, int type)

	Mat (int ndims, const int *sizes, int type, const Scalar &s)

	Mat (const std::vector< int > &sizes, int type, const Scalar &s)

	Mat (const Mat &m)

	Mat (int rows, int cols, int type, void *data, size_t step=AUTO_STEP)

	Mat (Size size, int type, void *data, size_t step=AUTO_STEP)

	Mat (int ndims, const int sizes, int type, void data, const size_t *steps=0)

	Mat (const std::vector< int > &sizes, int type, void data, const size_t steps=0)

	Mat (const Mat &m, const Range &rowRange, const Range &colRange=Range::all())

	Mat (const Mat &m, const Rect &roi)

	Mat (const Mat &m, const Range *ranges)

	Mat (const Mat &m, const std::vector< Range > &ranges)

template<typename _Tp >
	Mat (const std::vector< _Tp > &vec, 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 , size_t _Nm>
	Mat (const std::array< _Tp, _Nm > &arr, bool copyData=false)

template<typename _Tp , int n>
	Mat (const Vec< _Tp, n > &vec, bool copyData=true)

template<typename _Tp , int m, int n>
	Mat (const Matx< _Tp, m, n > &mtx, bool copyData=true)

template<typename _Tp >
	Mat (const Point_< _Tp > &pt, bool copyData=true)

template<typename _Tp >
	Mat (const Point3_< _Tp > &pt, bool copyData=true)

template<typename _Tp >
	Mat (const MatCommaInitializer_< _Tp > &commaInitializer)

	Mat (const cuda::GpuMat &m)
	GpuMat からデータをダウンロード

	~Mat ()
	デストラクタ - 呼び出しrelease()

Mat &	operator= (const Mat &m)
	代入演算子[【詳解】（英語］

Mat &	operator= (const MatExpr &expr)

UMat	getUMat (AccessFlag accessFlags, UMatUsageFlags usageFlags=USAGE_DEFAULT) const
	取得UMatから最大でMat

Mat	row (int y) const
	指定された行列の行に対する行列ヘッダを作成します．[【詳解】（英語］

Mat	col (int x) const
	指定された行列列に対する行列ヘッダを作成します．[【詳解】（英語］

Mat	rowRange (int startrow, int endrow) const
	指定された行スパンの行列ヘッダを作成します．[【詳解】（英語］

Mat	rowRange (const Range &r) const

Mat	colRange (int startcol, int endcol) const
	指定された列スパンの行列のヘッダを作成します．[【詳解】（英語］

Mat	colRange (const Range &r) const

Mat	diag (int d=0) const
	行列から対角線を抽出します[【詳解】（英語］

Mat	clone () const CV_NODISCARD
	配列とその基礎となるデータの完全なコピーを作成します．[【詳解】（英語］

void	copyTo (OutputArray m) const
	行列を別の行列にコピーします．[【詳解】（英語］

void	copyTo (OutputArray m, InputArray mask) const

void	convertTo (OutputArray m, int rtype, double alpha=1, double beta=0) const
	任意のスケーリングを伴って，配列を別のデータ型に変換します．[【詳解】（英語］

void	assignTo (Mat &m, int type=-1) const
	convertTo の関数形式を提供します。[【詳解】（英語］

Mat &	operator= (const Scalar &s)
	配列の要素の全部または一部を，指定された値に設定します．[【詳解】（英語］

Mat &	setTo (InputArray value, InputArray mask=noArray())
	配列の要素の全部または一部を，指定された値に設定します．[【詳解】（英語］

Mat	reshape (int cn, int rows=0) const
	データをコピーすることなく 2D 行列の形状やチャンネル数を変更します。[【詳解】（英語］

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

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

MatExpr	t () const
	行列の転置を行います．[【詳解】（英語］

MatExpr	inv (int method=DECOMP_LU) const
	行列を反転させます。[【詳解】（英語］

MatExpr	mul (InputArray m, double scale=1) const
	2 つの行列の要素毎の乗算または除算を行います．[【詳解】（英語］

Mat	cross (InputArray m) const
	2 つの 3 要素のベクトルの外積を計算します．[【詳解】（英語］

double	dot (InputArray m) const
	2 つのベクトルの内積を計算します．[【詳解】（英語］

void	create (int rows, int cols, int type)
	必要ならば，新しい配列データを割り当てます．[【詳解】（英語］

void	create (Size size, int type)

void	create (int ndims, const int *sizes, int type)

void	create (const std::vector< int > &sizes, int type)

void	addref ()
	参照カウンタをインクリメントします。[【詳解】（英語］

void	release ()
	必要に応じて，参照カウンタをデクリメントし，行列を解放します。[【詳解】（英語］

void	deallocate ()
	内部利用関数．代わりに 'release' メソッドの利用を検討してください．

void	copySize (const Mat &m)
	内部使用関数．配列 _size, _step を適切に再割り当てします．

void	reserve (size_t sz)
	特定の行数のためにスペースを確保します。[【詳解】（英語］

void	reserveBuffer (size_t sz)
	特定のバイト数の領域を確保します。[【詳解】（英語］

void	resize (size_t sz)
	マトリックスの行数を変更します。[【詳解】（英語］

void	resize (size_t sz, const Scalar &s)

void	push_back_ (const void *elem)
	内部関数

template<typename _Tp >
void	push_back (const _Tp &elem)
	行列の最下部に要素を追加します。[【詳解】（英語］

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 Mat &m)

void	pop_back (size_t nelems=1)
	行列の最下部から要素を削除します．[【詳解】（英語］

void	locateROI (Size &wholeSize, Point &ofs) const
	行列のヘッダを親行列の中に配置します。[【詳解】（英語］

Mat &	adjustROI (int dtop, int dbottom, int dleft, int dright)
	親行列内の部分行列のサイズと位置を調整します．[【詳解】（英語］

Mat	operator() (Range rowRange, Range colRange) const
	矩形の部分行列を抽出します。[【詳解】（英語］

Mat	operator() (const Rect &roi) const

Mat	operator() (const Range *ranges) const

Mat	operator() (const std::vector< Range > &ranges) const

template<typename _Tp >
	operator std::vector< _Tp > () const

template<typename _Tp , int n>
	operator Vec< _Tp, n > () 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

bool	isContinuous () const
	行列が連続しているかどうかを報告します。[【詳解】（英語］

bool	isSubmatrix () const
	行列が別の行列の部分行列である場合は，真を返します．

size_t	elemSize () const
	行列の要素サイズをバイト単位で返します。[【詳解】（英語］

size_t	elemSize1 () const
	各行列要素のチャンネルのサイズをバイト単位で返します。[【詳解】（英語］

int	type () const
	行列要素の型を返します。[【詳解】（英語］

int	depth () const
	行列の要素の深さを返します。[【詳解】（英語］

int	channels () const
	マトリックスチャンネルの数を返す。[【詳解】（英語］

size_t	step1 (int i=0) const
	正規化されたステップを返します．[【詳解】（英語］

bool	empty () const
	配列の要素が存在しない場合は，真を返します．[【詳解】（英語］

size_t	total () const
	配列の総要素数を返します。[【詳解】（英語］

size_t	total (int startDim, int endDim=INT_MAX) const
	配列の総要素数を返します。[【詳解】（英語］

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

uchar *	ptr (int i0=0)
	指定された行列の行へのポインタを返します。[【詳解】（英語］

const uchar *	ptr (int i0=0) const

uchar *	ptr (int row, int col)

const uchar *	ptr (int row, int col) const

uchar *	ptr (int i0, int i1, int i2)

const uchar *	ptr (int i0, int i1, int i2) const

uchar *	ptr (const int *idx)

const uchar *	ptr (const int *idx) const

template<int n>
uchar *	ptr (const Vec< int, n > &idx)

template<int n>
const uchar *	ptr (const Vec< int, n > &idx) const

template<typename _Tp >
_Tp *	ptr (int i0=0)

template<typename _Tp >
const _Tp *	ptr (int i0=0) const

template<typename _Tp >
_Tp *	ptr (int row, int col)

template<typename _Tp >
const _Tp *	ptr (int row, int col) const

template<typename _Tp >
_Tp *	ptr (int i0, int i1, int i2)

template<typename _Tp >
const _Tp *	ptr (int i0, int i1, int i2) const

template<typename _Tp >
_Tp *	ptr (const int *idx)

template<typename _Tp >
const _Tp *	ptr (const int *idx) const

template<typename _Tp , int n>
_Tp *	ptr (const Vec< int, n > &idx)

template<typename _Tp , int n>
const _Tp *	ptr (const Vec< int, n > &idx) 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 (int i0, int i1, int i2)

template<typename _Tp >
const _Tp &	at (int i0, int i1, int i2) const

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 (Point pt)

template<typename _Tp >
const _Tp &	at (Point pt) const

template<typename _Tp >
MatIterator_< _Tp >	begin ()
	行列のイテレータを返し，それを行列の最初の要素に設定します．[【詳解】（英語］

template<typename _Tp >
MatConstIterator_< _Tp >	begin () const

template<typename _Tp >
std::reverse_iterator< MatIterator_< _Tp > >	rbegin ()
	と同じです．begin()と同じですが，逆方向の走査については

template<typename _Tp >
std::reverse_iterator< MatConstIterator_< _Tp > >	rbegin () const

template<typename _Tp >
MatIterator_< _Tp >	end ()
	行列のイテレータを返し，それを最後の行列要素の後に設定します．[【詳解】（英語］

template<typename _Tp >
MatConstIterator_< _Tp >	end () const

template<typename _Tp >
std::reverse_iterator< MatIterator_< _Tp > >	rend ()
	と同じです．end()と同じですが，逆方向の走査については

template<typename _Tp >
std::reverse_iterator< MatConstIterator_< _Tp > >	rend () const

template<typename _Tp , typename Functor >
void	forEach (const Functor &operation)
	与えられたファンクタを，すべての行列要素に対して並列に実行します．[【詳解】（英語］

template<typename _Tp , typename Functor >
void	forEach (const Functor &operation) const

	Mat (Mat &&m)

Mat &	operator= (Mat &&m)

void	updateContinuityFlag ()
	内部使用法：継続性フラグを更新

静的公開メンバ関数
static Mat	diag (const Mat &d)
	対角線上の行列を作成します[【詳解】（英語］

static MatExpr	zeros (int rows, int cols, int type)
	指定されたサイズと型の 0 個の配列を返します．[【詳解】（英語］

static MatExpr	zeros (Size size, int type)

static MatExpr	zeros (int ndims, const int *sz, int type)

static MatExpr	ones (int rows, int cols, int type)
	指定されたサイズと型の，すべての 1 の配列を返します．[【詳解】（英語］

static MatExpr	ones (Size size, int type)

static MatExpr	ones (int ndims, const int *sz, int type)

static MatExpr	eye (int rows, int cols, int type)
	指定されたサイズと型の単位行列を返します。[【詳解】（英語］

static MatExpr	eye (Size size, int type)

static MatAllocator *	getStdAllocator ()
	そして，標準的なアロケータ

static MatAllocator *	getDefaultAllocator ()

static void	setDefaultAllocator (MatAllocator *allocator)

公開変数類
int	flags

int	dims
	行列の次元，>= 2

int	rows
	行列の行と列の数，または，行列が 2 次元以上の場合は (-1, -1) です．

int	cols

uchar *	data
	データへのポインタ

const uchar *	datastart
	locateROIおよびadjustROIで使用されるヘルパーフィールド

const uchar *	dataend

const uchar *	datalimit

MatAllocator *	allocator
	カスタムアロケータ

UMatData *	u
	との相互作用UMat

MatSize	size

MatStep	step

限定公開メンバ関数
template<typename _Tp , typename Functor >
void	forEach_impl (const Functor &operation)

詳解

n次元の密な配列クラス

このクラスはMatは，n-dimensional dense numerical single-channel or multi-channel arrayを表します．このクラスは，実数または複素数のベクトルや行列，グレースケールやカラーの画像，ボクセルボリューム，ベクトルフィールド，点群，テンソル，ヒストグラム（ただし，非常に高次元のヒストグラムを格納するには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}$

2次元配列の場合，上の式は次のようになります．

$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]). つまり，2次元の行列は行ごとに，3次元の行列は面ごとに，それぞれ格納されているということです．M.step[M.dims-1] は最小であり，常に要素サイズ M.elemSize() と等しい．

のデータレイアウトはMatのデータレイアウトは，Numpy（ndarray），Win32（independent device bitmaps）など，標準的なツールキットやSDKで提供されている大部分の密な配列タイプと互換性があります．つまり，M.stepを使用するあらゆる配列と互換性があります．ステップ(またはストライド)を使ってピクセルの位置を計算するあらゆる配列と互換性があります。このような互換性があるため、ユーザーが割り当てたデータのMatヘッダを作成し，OpenCVの関数を用いて，その場で処理することができます．

オブジェクトを作成するには，さまざまな方法があります．Matオブジェクトを作成する方法はたくさんあります．最も一般的な方法を以下に示します．

create(nrows, ncols, type) メソッドや，同様の Mat(nrows, ncols, type[, fillValue]) コンストラクタを利用します．type は， cvCreateMat メソッドと同じ意味を持ちます．例えば， CV_8UC1 は 8 ビットのシングルチャンネル配列を意味し， CV_32FC2 は 2 チャンネル（複素数）の浮動小数点型配列を意味します．

// make a 7x7 complex matrix filled with 1+3j.

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

// and now turn M to a 100x60 15-channel 8-bit matrix.

// The old content will be deallocated

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

cv::Mat::Mat

Mat() CV_NOEXCEPT

この章の導入部で述べたようにcreate()は，現在の配列の形状や型が，指定されたものと異なる場合にのみ，新しい配列を確保します．
多次元の配列を作成します。

// create a 100x100x100 8-bit array

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

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

cv::Scalar_< double >::all

static Scalar_< double > all(double v0)

returns a scalar with all elements set to v0

コンストラクタには次元数＝1を渡しますが、作成される配列は多次元になります。Matのコンストラクタに次元数=1を渡しますが，作成される配列は列数を1とした2次元のものになります。Mat::dimsは常に >= 2 です（配列が空のときは 0 にもなります）。
右辺に配列や式が存在する可能性がある場合は、コピーコンストラクタや代入演算子を使用します（以下を参照）。冒頭で述べたように，配列の代入は，ヘッダをコピーして参照カウンタを増やすだけなので，O(1)の演算です．またMat::clone()メソッドを使用すると，必要なときに配列の完全な（深い）コピーを取得できます．
別の配列の一部のヘッダを構築します。ヘッダーには，1行，1列，複数行，複数列，配列内の矩形の領域（これをマイナー代数学ではマイナーと呼ばれる），対角線などが考えられます．このような操作も，新しいヘッダが同じデータを参照するため，O(1)となります．この機能を使って、例えば、配列の一部を実際に修正することができます。

// add the 5-th row, multiplied by 3 to the 3rd row

M.row(3) = M.row(3) + M.row(5)*3;

// now copy the 7-th column to the 1-st column

// M.col(1) = M.col(7); // this will not work

Mat M1 = M.col(1);

M.col(7).copyTo(M1);

// create a new 320x240 image

Mat img(Size(320,240),CV_8UC3);

// select a ROI

Mat roi(img, Rect(10,10,100,100));

// fill the ROI with (0,255,0) (which is green in RGB space);

// the original 320x240 image will be modified

roi = Scalar(0,255,0);

datastartおよびdataendメンバが追加されたことにより，メインのコンテナ配列を使用してlocateROI():

Mat A = Mat::eye(10, 10, CV_32S);

// extracts A columns, 1 (inclusive) to 3 (exclusive).

Mat B = A(Range::all(), Range(1, 3));

// extracts B rows, 5 (inclusive) to 9 (exclusive).

// that is, 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 will be (width=10,height=10) and the ofs will be (x=1, y=5)

cv::Mat::eye

static MatExpr eye(int rows, int cols, int type)

Returns an identity matrix of the specified size and type.

行列全体の場合と同様に，深いコピーが必要な場合は，抽出されたサブ行列のclone()メソッドを使用して，サブ行列を抽出します．
ユーザが割り当てたデータのヘッダを作成します．以下のようにすると便利です．
1. OpenCV を用いて，「外部」のデータを処理します（例えば，DirectShow* のフィルタや gstreamer の処理モジュールを実装する場合など）．例えば，以下のような場合です．
  
  Mat process_video_frame(const unsigned char* pixels,
  
  int width, int height, int step)
  
  {
  
  // wrap input buffer
  
  Mat img(height, width, CV_8UC3, (unsigned char*)pixels, step);
  
  Mat result;
  
  GaussianBlur(img, result, Size(7, 7), 1.5, 1.5);
  
  return result;
  
  }
  
  cv::GaussianBlur
  
  CV_EXPORTS_W void GaussianBlur(InputArray src, OutputArray dst, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT)
  
  Blurs an image using a Gaussian filter.
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()例えば、以下のようになります。

// create a double-precision identity matrix and add it to M.

M += Mat::eye(M.rows, M.cols, CV_64F);
コンマで区切られたイニシャライザを使用します。

// create a 3x3 double-precision identity matrix

Mat M = (Mat_<double>(3,3) << 1, 0, 0, 0, 1, 0, 0, 0, 1);

この方法では，まず適切なパラメータを指定してクラスのコンストラクタを呼び出し，次にMatクラスのコンストラクタを適切なパラメータで呼び出した後、単に<< operatorの後に、定数、変数、式などの値をコンマで区切って記述します。また、コンパイルエラーを避けるために、余分な括弧が必要であることにも注意してください。

配列が作成されると，参照カウントの仕組みによって自動的に管理されます．配列のヘッダがユーザが割り当てたデータの上に構築されている場合は，そのデータを自分で処理する必要があります．配列データは、誰からも指されなくなると解放されます。配列デストラクタが呼ばれる前に，配列ヘッダが指すデータを解放したい場合はMat::release().

配列クラスについて次に学ぶべき重要なことは，要素のアクセスです．このマニュアルでは，すでに各配列要素のアドレスを計算する方法を説明しました。通常，コードの中で直接計算式を使用する必要はありません．配列の要素の型がわかっていれば（メソッドMat::type()メソッドで取得できます），2次元配列の要素 $M_{ij}$ のように2次元配列の要素にアクセスできます。

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

と仮定するとMが倍精度浮動小数点配列であると仮定します。このメソッドには，異なる次元数に対応したいくつかのバリエーションがあります．

2次元配列の行全体を処理する必要がある場合，最も効率的な方法は，最初に行へのポインタを取得してから，C言語のプレーンな演算子 [] を使用することです．

// compute sum of positive matrix elements

// (assuming that M is a double-precision matrix)

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

上の例のように，実際には配列の形状に依存しない演算もあります．上の例のように，配列の形状によらず，配列の要素を1つずつ（あるいは，同じ座標を持つ複数の配列の要素を）処理するものがあります（例えば，配列の加算など）．このような演算を要素ワイズ. すべての入出力配列が連続しているかどうか，つまり，各行の終わりに隙間がないかどうかをチェックすることは意味があります．もしそうであれば，それらを長い1行として処理します．

// compute the sum of positive matrix elements, optimized variant

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

連続した行列の場合，外側のループ本体は一度だけ実行されます．連続した行列の場合，外側のループ本体は1回だけ実行されるので，オーバーヘッドが小さくなり，特に小さい行列の場合に顕著です．

最後に，連続した行の間のギャップをスキップすることができる，STLスタイルのイテレータがあります．

// compute sum of positive matrix elements, iterator-based variant

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

構築子と解体子

◆ Mat() [1/27]

cv::Mat::Mat ( )

これらは行列を形成する様々なコンストラクタです。AutomaticAllocation で述べたように，多くの場合，デフォルトコンストラクタで十分であり，適切な行列が OpenCV の関数によって確保されます．構築された行列は，さらに別の行列や行列式に割り当てることができ，またMat::create. 前者の場合，古い内容は参照されなくなります．

◆ Mat() [2/27]

cv::Mat::Mat	(	int	rows,
		int	cols,
		int	type
	)

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

rows	2D配列の行数。
cols	2 次元配列の列数．
type	配列の種類．1-4 チャンネルの行列を作成する場合は CV_8UC1, ..., CV_64FC4 を利用し，マルチチャンネル（最大 CV_CN_MAX チャンネル）の行列を作成する場合は CV_8UC(n), ..., CV_64FC(n) を利用します．

◆ Mat() [3/27]

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

size	2次元配列のサイズ．Size(cols, rows) ．Size() のコンストラクタでは，行数と列数が逆順になります．
type	配列の種類．1-4 チャンネルの行列を作成する場合は CV_8UC1, ..., CV_64FC4 を利用し，マルチチャンネル（最大 CV_CN_MAX チャンネル）の行列を作成する場合は CV_8UC(n), ..., CV_64FC(n) を利用します．

◆ Mat() [4/27]

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

rows	2D配列の行数。
cols	2 次元配列の列数．
type	配列の種類．1-4 チャンネルの行列を作成する場合は CV_8UC1, ..., CV_64FC4 を利用し，マルチチャンネル（最大 CV_CN_MAX チャンネル）の行列を作成する場合は CV_8UC(n), ..., CV_64FC(n) を利用します．
s	各行列要素を初期化するためのオプション値．コンストラクション後にすべての行列要素を特定の値に設定するには，代入演算子を使用します．Mat::operator=(const Scalar& value).

◆ Mat() [5/27]

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

size	2次元配列のサイズ．Size(cols, rows) ．Size() のコンストラクタでは，行数と列数が逆順になります．
type	配列の種類．1-4 チャンネルの行列を作成する場合は CV_8UC1, ..., CV_64FC4 を利用し，マルチチャンネル（最大 CV_CN_MAX チャンネル）の行列を作成する場合は CV_8UC(n), ..., CV_64FC(n) を利用します．
s	各行列要素を初期化するためのオプション値．コンストラクション後にすべての行列要素を特定の値に設定するには，代入演算子を使用します．Mat::operator=(const Scalar& value).

◆ Mat() [6/27]

cv::Mat::Mat	(	int	ndims,
		const int *	sizes,
		int	type
	)

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

ndims	配列の次元。
sizes	n次元配列の形状を指定する整数の配列。
type	配列の種類．1-4 チャンネルの行列を作成する場合は CV_8UC1, ..., CV_64FC4 を利用し，マルチチャンネル（最大 CV_CN_MAX チャンネル）の行列を作成する場合は CV_8UC(n), ..., CV_64FC(n) を利用します．

◆ Mat() [7/27]

cv::Mat::Mat	(	const std::vector< int > &	sizes,
		int	type
	)

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

sizes	n次元配列の形状を指定する整数の配列。
type	配列の種類．1-4 チャンネルの行列を作成する場合は CV_8UC1, ..., CV_64FC4 を利用し，マルチチャンネル（最大 CV_CN_MAX チャンネル）の行列を作成する場合は CV_8UC(n), ..., CV_64FC(n) を利用します．

◆ Mat() [8/27]

cv::Mat::Mat	(	int	ndims,
		const int *	sizes,
		int	type,
		const Scalar &	s
	)

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

ndims	配列の次元。
sizes	n次元配列の形状を指定する整数の配列。
type	配列の種類．1-4 チャンネルの行列を作成する場合は CV_8UC1, ..., CV_64FC4 を利用し，マルチチャンネル（最大 CV_CN_MAX チャンネル）の行列を作成する場合は CV_8UC(n), ..., CV_64FC(n) を利用します．
s	各行列要素を初期化するためのオプション値．コンストラクション後にすべての行列要素を特定の値に設定するには，代入演算子を使用します．Mat::operator=(const Scalar& value).

◆ Mat() [9/27]

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

sizes	n次元配列の形状を指定する整数の配列。
type	配列の種類．1-4 チャンネルの行列を作成する場合は CV_8UC1, ..., CV_64FC4 を利用し，マルチチャンネル（最大 CV_CN_MAX チャンネル）の行列を作成する場合は CV_8UC(n), ..., CV_64FC(n) を利用します．
s	各行列要素を初期化するためのオプション値．コンストラクション後にすべての行列要素を特定の値に設定するには，代入演算子を使用します．Mat::operator=(const Scalar& value).

◆ Mat() [10/27]

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

m	構築された行列に代入される配列（全体または一部）。これらのコンストラクタによってデータがコピーされることはありません。代わりに、m個のデータまたはそのサブアレイを指し示すヘッダが構築され、それに関連付けられます。参照カウンタがあれば，それもインクリメントされます。したがって，このようなコンストラクタを使って生成された行列を変更すると，m の対応する要素も変更されます．副配列の独立したコピーを持ちたい場合は、以下を使用します。Mat::clone().

◆ Mat() [11/27]

cv::Mat::Mat	(	int	rows,
		int	cols,
		int	type,
		void *	data,
		size_t	step = `AUTO_STEP`
	)

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

rows	2D配列の行数。
cols	2 次元配列の列数．
type	配列の種類．1-4 チャンネルの行列を作成する場合は CV_8UC1, ..., CV_64FC4 を利用し，マルチチャンネル（最大 CV_CN_MAX チャンネル）の行列を作成する場合は CV_8UC(n), ..., CV_64FC(n) を利用します．
data	ユーザデータへのポインタ．data と step パラメータを引数にとる行列コンストラクタは，行列データを確保しません．代わりに，指定されたデータを指し示す行列ヘッダを初期化するだけで，データのコピーは行われません．この操作は非常に効率的で，OpenCV の関数を用いて外部データを処理するのに利用できます．なお，外部データは自動的には解放されないので，注意が必要です．
step	行列の各行が占めるバイト数。この値には，各行の最後にパディングバイトがある場合は，それを含めなければいけません。このパラメータがない場合（AUTO_STEPに設定されている場合），パディングはないとみなされ，実際のステップは cols*elemSize() として計算されます．参照Mat::elemSize.

◆ Mat() [12/27]

cv::Mat::Mat	(	Size	size,
		int	type,
		void *	data,
		size_t	step = `AUTO_STEP`
	)

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

size	2次元配列のサイズ．Size(cols, rows) ．Size() のコンストラクタでは，行数と列数が逆順になります．
type	配列の種類．1-4 チャンネルの行列を作成する場合は CV_8UC1, ..., CV_64FC4 を利用し，マルチチャンネル（最大 CV_CN_MAX チャンネル）の行列を作成する場合は CV_8UC(n), ..., CV_64FC(n) を利用します．
data	ユーザデータへのポインタ．data と step パラメータを引数にとる行列コンストラクタは，行列データを確保しません．代わりに，指定されたデータを指し示す行列ヘッダを初期化するだけで，データのコピーは行われません．この操作は非常に効率的で，OpenCV の関数を用いて外部データを処理するのに利用できます．なお，外部データは自動的には解放されないので，注意が必要です．
step	行列の各行が占めるバイト数。この値には，各行の最後にパディングバイトがある場合は，それを含めなければいけません。このパラメータがない場合（AUTO_STEPに設定されている場合），パディングはないとみなされ，実際のステップは cols*elemSize() として計算されます．参照Mat::elemSize.

◆ Mat() [13/27]

cv::Mat::Mat	(	int	ndims,
		const int *	sizes,
		int	type,
		void *	data,
		const size_t *	steps = `0`
	)

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

ndims	配列の次元。
sizes	n次元配列の形状を指定する整数の配列。
type	配列の種類．1-4 チャンネルの行列を作成する場合は CV_8UC1, ..., CV_64FC4 を利用し，マルチチャンネル（最大 CV_CN_MAX チャンネル）の行列を作成する場合は CV_8UC(n), ..., CV_64FC(n) を利用します．
data	ユーザデータへのポインタ．data と step パラメータを引数にとる行列コンストラクタは，行列データを確保しません．代わりに，指定されたデータを指し示す行列ヘッダを初期化するだけで，データのコピーは行われません．この操作は非常に効率的で，OpenCV の関数を用いて外部データを処理するのに利用できます．なお，外部データは自動的には解放されないので，注意が必要です．
steps	多次元配列の場合の ndims-1 ステップの配列（最後のステップは，常に要素サイズに設定されます）．指定されない場合，行列は連続しているとみなされます．

◆ Mat() [14/27]

cv::Mat::Mat	(	const std::vector< int > &	sizes,
		int	type,
		void *	data,
		const size_t *	steps = `0`
	)

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

sizes	n次元配列の形状を指定する整数の配列。
type	配列の種類．1-4 チャンネルの行列を作成する場合は CV_8UC1, ..., CV_64FC4 を利用し，マルチチャンネル（最大 CV_CN_MAX チャンネル）の行列を作成する場合は CV_8UC(n), ..., CV_64FC(n) を利用します．
data	ユーザデータへのポインタ．data と step パラメータを引数にとる行列コンストラクタは，行列データを確保しません．代わりに，指定されたデータを指し示す行列ヘッダを初期化するだけで，データのコピーは行われません．この操作は非常に効率的で，OpenCV の関数を用いて外部データを処理するのに利用できます．なお，外部データは自動的には解放されないので，注意が必要です．
steps	多次元配列の場合の ndims-1 ステップの配列（最後のステップは，常に要素サイズに設定されます）．指定されない場合，行列は連続しているとみなされます．

◆ Mat() [15/27]

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/27]

cv::Mat::Mat	(	const Mat &	m,
		const Rect &	roi
	)

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

m 構築された行列に代入される配列（全体または一部）。これらのコンストラクタによってデータがコピーされることはありません。代わりに、m個のデータまたはそのサブアレイを指し示すヘッダが構築され、それに関連付けられます。参照カウンタがあれば，それもインクリメントされます。したがって，このようなコンストラクタを使って生成された行列を変更すると，m の対応する要素も変更されます．副配列の独立したコピーを持ちたい場合は、以下を使用します。Mat::clone().

roi 興味のある領域。

◆ Mat() [17/27]

cv::Mat::Mat	(	const Mat &	m,
		const Range *	ranges
	)

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

m 構築された行列に代入される配列（全体または一部）。これらのコンストラクタによってデータがコピーされることはありません。代わりに、m個のデータまたはそのサブアレイを指し示すヘッダが構築され、それに関連付けられます。参照カウンタがあれば，それもインクリメントされます。したがって，このようなコンストラクタを使って生成された行列を変更すると，m の対応する要素も変更されます．副配列の独立したコピーを持ちたい場合は、以下を使用します。Mat::clone().

ranges 各次元のm個の選択された範囲の配列．

◆ Mat() [18/27]

cv::Mat::Mat	(	const Mat &	m,
		const std::vector< Range > &	ranges
	)

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

m 構築された行列に代入される配列（全体または一部）。これらのコンストラクタによってデータがコピーされることはありません。代わりに、m個のデータまたはそのサブアレイを指し示すヘッダが構築され、それに関連付けられます。参照カウンタがあれば，それもインクリメントされます。したがって，このようなコンストラクタを使って生成された行列を変更すると，m の対応する要素も変更されます．副配列の独立したコピーを持ちたい場合は、以下を使用します。Mat::clone().

ranges 各次元のm個の選択された範囲の配列．

◆ Mat() [19/27]

template<typename _Tp >

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

explicit

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

vec 行列を構成する要素を持つ STL ベクトル．行列は 1 列で，行数はベクトルの要素数と同じです．行列の型は，ベクトル要素の型と一致します．コンストラクタは任意の型を扱うことができますが，そのためには適切に宣言されたDataType. つまり，ベクトル要素は，プリミティブな数値または単一型の数値タプルでなければなりません。混合型構造はサポートされていません。対応するコンストラクタは明示的です。STL のベクトルは，自動的にインスタンスに変換されません．Matインスタンスに自動的に変換されないので，明示的に Mat(vec) と書く必要があります．データを行列にコピーしない限り（ copyData=true ），ベクトルデータの再割り当てが発生する可能性があるため，新しい要素はベクトルに追加されず，その結果，行列データポインタは無効になります．

copyData STL vectorの基礎データを，新しく構築された行列にコピーする（true）か，共有する（false）かを指定するフラグ．データがコピーされると，割り当てられたバッファは，参照カウント機構を使って管理されます．Mat参照カウント機構を用いて管理されます。データが共有されている間は，参照カウンタは NULL であり，行列がデストラクションされない限りデータを解放してはいけません。

◆ Mat() [20/27]

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/27]

template<typename _Tp >

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

explicit

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

◆ Mat() [22/27]

template<typename _Tp , size_t _Nm>

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

explicit

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

◆ Mat() [23/27]

template<typename _Tp , int n>

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

explicit

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

◆ Mat() [24/27]

template<typename _Tp , int m, int n>

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

explicit

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

◆ Mat() [25/27]

template<typename _Tp >

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

explicit

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

◆ Mat() [26/27]

template<typename _Tp >

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

explicit

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

◆ Mat() [27/27]

template<typename _Tp >

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

explicit

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

関数詳解

◆ 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 構成でのみ行われます。

なお，1つのインデックス(i)を持つバリアントは，1行または1列の2次元配列の要素にアクセスするために使用できます。例えば，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次元のインデックス

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。2次元配列のための特別なバージョンです（特に画像のピクセルを参照するのに便利です）。

引数

pt	Point(j,i) として指定された要素の位置。

◆ at() [12/12]

template<typename _Tp >

const _Tp & cv::Mat::at ( Point pt ) const

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。2次元配列のための特別なバージョンです（特に画像のピクセルを参照するのに便利です）。

引数

pt	Point(j,i) として指定された要素の位置。

◆ begin()

template<typename _Tp >

MatIterator_< _Tp > cv::Mat::begin ( )

行列のイテレータを返し，それを行列の最初の要素に設定します．

これらのメソッドは，行列の読み取り専用あるいは読み取り/書き込み可能なイテレータを返します．マトリックスのイテレータの使い方は，双方向の STL イテレータの使い方とよく似ています．以下の例では，アルファブレンディング関数を行列イテレータを使って書き換えています．

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

}
}

◆ channels()

int cv::Mat::channels ( ) const

マトリックスチャンネルの数を返す。

このメソッドは，行列のチャンネル数を返します．

◆ checkVector()

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

引数

elemChannels	行列が持つべきチャンネル数または列数。2 次元の行列の場合，行列の列数が 1 つだけならば， elemChannels 個のチャンネルを持たなければならず，行列のチャンネル数が 1 つだけならば， elemChannels 個の列を持たなければなりません．3 次元の行列の場合は，1 つのチャンネルのみを持つ必要があります．さらに，平面の数が1ではない場合は，各平面内の行数は1でなければいけません；各平面内の行数が1ではない場合は，平面の数は1でなければいけません．
depth	行列が持つべき深さ．任意の深さでよい場合は，これを -1 に設定します．
requireContinuous	行列が連続であることを要求する場合は，これを true に設定します．

戻り値: 要求が満たされない場合は -1。それ以外の場合は，行列の要素数を返します．なお，1つの要素が複数のチャンネルを持つこともあります．

以下のコードは，2 次元の行列に対する使用例です．

次のコードは，3 次元の行列に対する使用例です．

◆ clone()

Mat cv::Mat::clone ( ) const

配列とその基礎となるデータの完全なコピーを作成します．

このメソッドは，配列の完全なコピーを作成します．元の step[] は考慮されません．そのため，配列のコピーは，以下の領域を占める連続した配列になります．total()*elemSize() バイトを占有します．

◆ col()

Mat cv::Mat::col ( int x ) const

指定された行列列に対する行列ヘッダを作成します．

このメソッドは，指定された行列列に対する新しいヘッダを作成し，それを返します．これは，行列のサイズに関わらず，O(1) の処理です．新しい行列の基礎データは，元の行列と共有されます．説明も参照してください．Mat::row説明を参照してください。

引数

x	0ベースの列インデックス．

◆ 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	オプションで，スケーリングされた値に加えられるデルタ．

◆ copyTo() [1/2]

void cv::Mat::copyTo ( OutputArray m ) const

行列を別の行列にコピーします．

このメソッドは，行列のデータを別の行列にコピーします．データをコピーする前に，このメソッドは .NET を起動します．

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

cv::Mat::type

int type() const

Returns the type of a matrix element.

を呼び出し，必要に応じてコピー先の行列が再割り当てされるようにします．m.copyTo(m); は問題なく動作しますが，この関数は，コピー元とコピー先の行列が部分的に重なっている場合には対応しません．

操作マスクが指定されている場合，上記の呼び出しではMat::createが行列を再割り当てした場合，データをコピーする前に，新しく割り当てられた行列がすべてゼロで初期化されます．

引数

m	コピー先の行列。演算前に適切なサイズや型を持っていない場合は，再割り当てされます．

◆ copyTo() [2/2]

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

m	コピー先の行列。演算前に適切なサイズや型を持っていない場合は，再割り当てされます．
mask	this と同じサイズの演算マスク．その非0の要素は，どの行列要素をコピーする必要があるかを示します．このマスクは，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
	)

必要ならば，新しい配列データを割り当てます．

これは，重要なメソッドの1つです．Matメソッドの1つです．配列を生成する新形式の OpenCV 関数やメソッドのほとんどは，各出力配列に対してこのメソッドを呼び出します．このメソッドは，以下のアルゴリズムを利用します．

現在の配列の形状と型が，新しいものと一致する場合は，直ちに戻ります．そうでない場合は，次のように呼び出して以前のデータの参照を解除しますMat::release.
新しいヘッダを初期化します。
の新しいデータを割り当てます。total()*elemSize() バイトを占有します．
データに関連付けられた新しい参照カウンタを割り当て、それを1に設定します。

このような方式は、メモリ管理を堅牢かつ効率的にすると同時に、余計なタイプミスを避けるのにも役立ちます。つまり，通常は出力配列を明示的に確保する必要はありません。つまり，:

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

cvtColor(color, gray,
COLOR_BGR2GRAY);

と書く代わりに，単に

Mat
color;
...
Mat gray;

cvtColor(color, gray,
COLOR_BGR2GRAY);

なぜなら， cvtColor や多くの OpenCV の関数は，内部で出力配列を呼び出しているからです．Mat::create()出力配列を内部的に呼び出しているからです．

引数

rows	新しい行数．
cols	新しい行数，新しい列数．
type	新しい行列の種類．

◆ create() [4/4]

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

size	代替となる新しい行列のサイズ指定．サイズ(cols, rows)
type	新しい行列の種類．

◆ cross()

Mat cv::Mat::cross ( InputArray m ) const

2 つの 3 要素のベクトルの外積を計算します．

このメソッドは，2 つの 3 要素のベクトルの外積を計算します．ベクトルは，同じ形状とサイズの 3 要素浮動小数点ベクトルでなければなりません．結果は、オペランドと同じ形と型の別の 3 要素ベクトルです。

引数

m	もう一つのクロスプロダクトのオペランドです。

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

◆ diag() [1/2]

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

static

対角線上の行列を作成します

このメソッドは，指定された主対角線から正方対角線行列を作成します．

引数

d	主対角線を表す 1 次元の行列。

◆ diag() [2/2]

Mat cv::Mat::diag ( int d = 0 ) const

行列から対角線を抽出します

このメソッドは，指定された行列の対角線に対する新しいヘッダを作成します．新しい行列は，1 列の行列として表現されます．対角線と同様に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

2 つのベクトルの内積を計算します．

このメソッドは，2つの行列のドット積を計算します．行列が1列または1行のベクトルではない場合，上から下，左から右へのスキャン順序が使用され，1次元ベクトルとして扱われます．ベクトルのサイズとタイプは同じでなければなりません。行列に複数のチャンネルがある場合は，すべてのチャンネルのドットプロダクトが合計されます．

引数

m	もう1つのドットプロダクトのオペランド。

◆ 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

配列の要素が存在しない場合は，真を返します．

このメソッドは，以下の場合に真を返しますMat::total()が 0 の場合，あるいはMat::dataが NULL の場合は真を返します．の場合は真を返します．pop_back()およびresize()メソッドM.total() == 0は，次のことを意味しません。M.data == NULL.

◆ end()

template<typename _Tp >

MatIterator_< _Tp > cv::Mat::end ( )

行列のイテレータを返し，それを最後の行列要素の後に設定します．

これらのメソッドは，行列の最後の要素の後の点に設定された，読み込み専用または読み書き可能なイテレータを返します。

◆ eye() [1/2]

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

static

指定されたサイズと型の単位行列を返します。

このメソッドは，以下と同様に Matlab スタイルの単位行列イニシャライザを返します．Mat::zeros. と同様にMat::onesと同様に，スケール操作を利用して，スケーリングされた単位行列を効率的に作成することができます．

// make a 4x4 diagonal matrix with 0.1's on the diagonal.

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

覚え書き: マルチチャンネルの場合，ID マトリックスは最初のチャンネルに対してのみ初期化され，その他のチャンネルは 0 になります．

引数

rows	行数。
cols	列の数
type	作成された行列の種類。

◆ eye() [2/2]

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

与えられたファンクタを，すべての行列要素に対して並列に実行します．

引数として渡される演算は，関数ポインタ，関数オブジェクト，ラムダ（C++11）のいずれかでなければいけません．

例 1. 以下のすべての演算は，すべての行列要素の最初のチャンネルを 0xFF にします．

Mat
image(1920, 1080, CV_8UC3);

typedef
cv::Point3_<uint8_t>
Pixel;


// first. raw pointer access.

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;

}
}


// Using MatIterator. (Simple but there are a Iterator's overhead)

for
(Pixel &p :
cv::Mat_<Pixel>(image)) {

p.x = 255;
}


// Parallel execution with function object.

struct
Operator {

void
operator ()(Pixel &pixel,
const
int
* position) {

pixel.x = 255;

}
};
image.forEach<Pixel>(Operator());


// Parallel execution using C++11 lambda.
image.forEach<Pixel>([](Pixel &p,
const
int
* position) ->
void
{

p.x = 255;
});

例 2. ピクセルの位置を利用して

// Creating 3D matrix (255 x 255 x 255) typed uint8_t

// and initialize all elements by the value which equals elements position.

// i.e. pixels (x,y,z) = (1,2,3) is (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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

◆ inv()

MatExpr cv::Mat::inv ( int method = DECOMP_LU ) const

行列を反転させます。

このメソッドは、行列式を使って行列の反転を行います。つまり，一時的な行列反転オブジェクトがこのメソッドから返され，より複雑な行列式の一部としてさらに使用したり，行列に代入したりすることができます．

引数

method 行列逆転メソッド．以下のいずれかですcv::DecompTypes

◆ isContinuous()

bool cv::Mat::isContinuous ( ) const

行列が連続しているかどうかを報告します。

このメソッドは，行列の要素が各行の終わりに隙間なく連続して格納されている場合は真を返します。そうでない場合は false を返します。明らかに，1x1 または 1xN の行列は常に連続しています。で作成された行列は，常に連続的です。Mat::createで作成された行列は，常に連続しています。しかし，行列の一部をMat::col,Mat::diagを使って行列の一部を抽出したり，外部から割り当てられたデータのために行列のヘッダを作成したりすると，そのような行列はもはやこの特性を持たないかもしれません。

連続性フラグは，フィールドMat::flagsフィールドのビットとして格納されており，行列ヘッダを構築する際に自動的に計算されます。したがって，理論的には次のようにしてもよいのですが，連続性チェックは非常に高速な処理です。

// alternative implementation of 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のかなり多くの関数で利用されています．ポイントは，要素単位の演算（算術演算や論理演算，数学関数，アルファブレンディング，色空間変換など）は，画像の形状に依存しないということです．したがって，入出力配列がすべて連続している場合，関数はそれらを非常に長い1列のベクトルとして処理することができます．下の例は，アルファブレンディング関数の実装方法を示しています．

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

// here is the idiom: check the arrays for continuity and,

// if this is the case,

// treat the arrays as 1D vectors

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

{

// when the arrays are continuous,

// the outer loop is executed only once

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パーセント向上させることができます．

この関数におけるもう1つの OpenCV のイディオム，すなわち，出力配列に対するMat::createの呼び出しで，すでに適切なサイズと型を持っている場合を除いて，出力配列を確保します．また，新しく確保された配列は常に連続していますが，出力配列をチェックする必要があります．Mat::createは常に新しい行列を割り当てるわけではありません。

◆ locateROI()

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

行列のヘッダを親行列の中に配置します。

などを使って行列から部分行列を抽出した後は，結果として得られる部分行列はMat::row,Mat::col,Mat::rowRange,Mat::colRangeなどを使って行列から部分行列を抽出した後，結果として得られる部分行列は，元の大きな行列の一部を指しています．しかし，各部分行列には，元の行列のサイズや，抽出された部分行列の元の行列内での位置を再構築するのに役立つ情報（datastart フィールドと dataend フィールドで表される）が含まれています．メソッド locateROI は，まさにそれを行います．

引数

wholeSize	を含む行列全体のサイズを含むパラメータを出力します．このを部分的に含む行列全体のサイズを含む出力パラメータ．
ofs	行列全体の中での，この部分のオフセットを含む出力パラメータ．こののオフセットを含む出力パラメータ．

◆ mul()

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

2 つの行列の要素毎の乗算または除算を行います．

このメソッドは，要素毎の配列の乗算をエンコードした一時的なオブジェクトを，オプションのスケールと共に返します．これは，より単純な "\*" 演算子に対応する行列の乗算ではないことに注意してください．

例

Mat C = A.mul(5/B); // equivalent to divide(A, B, C, 5)

引数

m	*this と同じ型，同じサイズの別の配列，または，行列式．
scale	任意のスケールファクター．

◆ ones() [1/3]

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

static

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

ndims	配列の次元。
sz	配列の形状を指定する整数の配列．
type	作成された行列の種類。

◆ ones() [2/3]

static 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; // make 100x100 matrix filled with 3.

cv::Mat::ones

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

Returns an array of all 1's of the specified size and type.

その代わり，スケールファクタ（この場合は 3）を記憶しておき，実際に行列のイニシャライザを呼び出す際にそれを利用します．

覚え書き: マルチチャンネルタイプの場合は，最初のチャンネルだけが 1 で初期化され，他のチャンネルは 0 になります．

引数

rows	行数。
cols	列の数
type	作成された行列の種類。

◆ ones() [3/3]

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

static

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

size	行列のサイズ指定に代わるもの Size(cols, rows) .
type	作成された行列の種類。

◆ 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/3]

Mat & cv::Mat::operator= ( const Mat & m )

代入演算子

以上が利用可能な代入演算子です。どれも大きく異なるので，演算子のパラメータの説明を必ず読んでください。

引数

m	代入された，右手側の行列．行列の代入は，O(1)の操作です．つまり、データはコピーされませんが、データは共有され、参照カウンタがあれば、それがインクリメントされます。新しいデータを割り当てる前に，古いデータの参照が解除されます．Mat::release.

◆ operator=() [2/3]

Mat & cv::Mat::operator= ( const MatExpr & expr )

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

expr	割り当てられた行列式オブジェクト。第 1 の形式の代入操作とは逆に、第 2 の形式では、行列式の結果に適したサイズとタイプであれば、既に割り当てられている行列を再利用することができます。これは、行列式が展開される実関数によって自動的に処理されます。例えば，C=A+B は add(A, B, C) に展開され，add は自動的に C の再割り当てを行います．

◆ operator=() [3/3]

Mat & cv::Mat::operator= ( const Scalar & s )

配列の要素の全部または一部を，指定された値に設定します．

引数

s	割り当てられたスカラは，実際の配列型に変換されます．

◆ pop_back()

void cv::Mat::pop_back ( size_t nelems = 1 )

行列の最下部から要素を削除します．

このメソッドは，行列の底から 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 ベースの行インデックス．

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

行列の最下部に要素を追加します。

このメソッドは，1 つ以上の要素を行列の底に追加します．これらのメソッドは、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 要素を追加。

◆ release()

void cv::Mat::release ( )

必要に応じて，参照カウンタをデクリメントし，行列を解放します。

このメソッドは，行列データに関連付けられた参照カウンタをデクリメントします。参照カウンタが 0 になると，行列データは解放され，データと参照カウンタのポインタが NULL に設定されます．行列のヘッダが外部のデータセットを指している場合（参考Mat::Matを参照），参照カウンタは NULL で，このメソッドはこの場合には何の効果もありません。

このメソッドを手動で呼び出して，行列データの解放を強制することもできます．しかし，このメソッドはデストラクタや，データポインタを変更するその他のメソッドで自動的に呼び出されるので，通常は必要ありません．参照カウンタのデクリメントと0のチェックは、それをサポートするプラットフォームではアトミックな操作です。したがって，同じ行列を異なるスレッドで非同期的に操作しても安全です．

◆ 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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

◆ reshape() [2/3]

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

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

◆ reshape() [3/3]

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

データをコピーすることなく 2D 行列の形状やチャンネル数を変更します。

このメソッドは， *this 要素のための新しい行列ヘッダを作成します。新しい行列は，異なるサイズや異なるチャンネル数を持つ可能性があります．以下の条件を満たせば，どのような組み合わせも可能です

新しい行列に余分な要素が含まれておらず，また要素が除外されていない。したがって，行*列*チャネル() の積は，変換後も同じでなければいけません．
データはコピーされません．つまり，これは O(1) の演算です．したがって，行数を変更したり，何らかの方法で行の要素のインデックスを変更したりしても，行列は連続していなければなりません．参照Mat::isContinuous.

例えば、STLベクトルとして格納されている3Dポイントのセットがあり、そのポイントを3xNの行列として表現したい場合は、以下のようにします。

std::vector<Point3f> vec;
...
Mat pointMat =
Mat(vec).
// convert vector to Mat, O(1) operation

reshape(1).
// make Nx3 1-channel matrix out of Nx1 3-channel.

// Also, an O(1) operation

t();
// finally, transpose the Nx3 matrix.

// This involves copying all the elements

引数

cn	新しいチャンネル数。パラメータが0の場合は、チャンネル数はそのままです。
rows	新しい行の数。パラメータが0の場合、行数は同じままです。

◆ 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) の処理です．新しい行列の基礎データは，元の行列と共有されます．ここでは，LUをはじめとする多くのアルゴリズムで使用される，古典的な基本行列処理演算の1つであるaxpyの例を示します．

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); // will not work

これは，A.row(i)が一時的なヘッダを形成し，それがさらに別のヘッダに割り当てられるために起こります．これらの操作はそれぞれO(1)、つまりデータはコピーされないことを覚えておいてください。したがって，j番目の行がi番目の行にコピーされることを期待していたかもしれない場合，上記の割り当ては真ではありません．これを実現するためには，この単純な代入を式にするか，あるいはMat::copyToメソッドを使用します。

Mat A;

...

// works, but looks a bit obscure.

A.row(i) = A.row(j) + 0;

// this is a bit longer, but the recommended method.

A.row(j).copyTo(A.row(i));

引数

y	0 ベースの行インデックス．

◆ 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 ベースの行範囲終了インデックス．

◆ setTo()

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

配列の要素の全部または一部を，指定された値に設定します．

演算子の発展型です．Mat::operator=(const Scalar& s)演算子と同じサイズのオペレーションマスクです。

引数

value	割り当てられたスカラは，実際の配列型に変換されます．
mask	thisと同じサイズの演算マスク．非0の要素は，どの行列要素をコピーする必要があるかを示します．このマスクは，CV_8U型でなければならず，1つまたは複数のチャンネルを持ちます．

◆ 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; // compute (A + lambda*I)^t * (A + lamda*I)

◆ total() [1/2]

size_t cv::Mat::total ( ) const

配列の総要素数を返します。

このメソッドは，配列の要素数（配列が画像を表す場合はピクセル数）を返します。

◆ 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 チャンネル配列，などです．

◆ zeros() [1/3]

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

static

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

ndims	配列の次元。
sz	配列の形状を指定する整数の配列．
type	作成された行列の種類。

◆ zeros() [2/3]

static 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	作成された行列の種類。

◆ zeros() [3/3]

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

static

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。

引数

size	行列のサイズ指定に代わるもの Size(cols, rows) .
type	作成された行列の種類。

メンバ詳解

◆ flags

int cv::Mat::flags

いくつかのビットフィールドを含みます。

マジックサイン
連続性フラグ
深さ
チャンネルの数

このクラス詳解は次のファイルから抽出されました:

公開型

公開メンバ関数

静的公開メンバ関数

公開変数類

限定公開メンバ関数

詳解

構築子と解体子

◆ Mat() [1/27]

◆ Mat() [2/27]

◆ Mat() [3/27]

◆ Mat() [4/27]

◆ Mat() [5/27]

◆ Mat() [6/27]

◆ Mat() [7/27]

◆ Mat() [8/27]

◆ Mat() [9/27]

◆ Mat() [10/27]

◆ Mat() [11/27]

◆ Mat() [12/27]

◆ Mat() [13/27]

◆ Mat() [14/27]

◆ Mat() [15/27]

◆ Mat() [16/27]

◆ Mat() [17/27]

◆ Mat() [18/27]

◆ Mat() [19/27]

◆ Mat() [20/27]

◆ Mat() [21/27]

◆ Mat() [22/27]

◆ Mat() [23/27]

◆ Mat() [24/27]

◆ Mat() [25/27]

◆ Mat() [26/27]

◆ Mat() [27/27]

関数詳解

◆ addref()

◆ adjustROI()

◆ assignTo()

◆ at() [1/12]

◆ at() [2/12]

◆ at() [3/12]

◆ at() [4/12]

◆ at() [5/12]

◆ at() [6/12]

◆ at() [7/12]

◆ at() [8/12]

◆ at() [9/12]

◆ at() [10/12]

◆ at() [11/12]

◆ at() [12/12]

◆ begin()

◆ channels()

◆ checkVector()

◆ clone()

◆ col()

◆ colRange() [1/2]

◆ colRange() [2/2]

◆ convertTo()

◆ copyTo() [1/2]

◆ copyTo() [2/2]

◆ create() [1/4]

◆ create() [2/4]

◆ create() [3/4]

◆ create() [4/4]

◆ cross()

◆ depth()

◆ diag() [1/2]

◆ diag() [2/2]

◆ dot()

◆ elemSize()

◆ elemSize1()

◆ empty()

◆ end()

◆ eye() [1/2]

◆ eye() [2/2]

◆ forEach() [1/2]

◆ forEach() [2/2]

◆ inv()

◆ isContinuous()

◆ locateROI()