cv::Mat クラス

カンマ区切りの行列初期化子。 詳細...

#include <opencv2/core/mat.hpp>

Collaboration diagram for 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)
	Mat (const MatShape &shape, int type)
	Mat (const MatShape &shape, int type, const Scalar &s)
	Mat (const MatShape &shape, int type, void *data, const size_t *steps=0)
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 (std::initializer_list< int > shape, int type)
	Mat (std::initializer_list< int > shape, int type, const Scalar &s)
	Mat (std::initializer_list< int > shape, int type, void *data, const size_t *steps=0)
	~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 MatShape &shape, int type)
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)
void	create (std::initializer_list< int > shape, int type)
void	createSameSize (InputArray arr, int type)
	別の配列と同じサイズの行列を作成する。
Mat	cross (InputArray m) const
	2つの3要素ベクトルの外積を計算する。
void	deallocate ()
	内部用途の関数。代わりに 'release' メソッドの使用を検討すること。行列データを解放する
int	depth () const
	行列要素のビット深度を返す。
Mat	diag (int d=0) const
	行列から対角成分を抽出する。
double	dot (InputArray m) const
	2つのベクトルの内積を計算する。
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
void	fit (const MatShape &shape, int type)
void	fit (const std::vector< int > &sizes, int type)
void	fit (int ndims, const int *sizes, int type)
void	fit (int rows, int cols, int type)
	create(rows, cols, type) に似ているが、既存のバッファサイズが不足している場合にのみメモリを再割り当てする。
void	fit (Size size, int type)
void	fit (std::initializer_list< int > shape, int type)
void	fitSameSize (InputArray arr, int type)
	createSameSize(arr, type) に似ているが、既存のバッファが不足している場合にのみメモリを再割り当てする。
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
	2つの行列の要素ごとの乗算または除算を実行する。
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 MatShape &newshape) const
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
	データをコピーせずに、2次元行列の形状やチャンネル数を変更する。
Mat	reshape (int cn, std::initializer_list< int > newshape) const
void	resize (size_t sz)
	行列の行数を変更する。
void	resize (size_t sz, const Scalar &s)
Mat	row (int y) const
	指定した行に対する行列ヘッダを作成する。
Mat	rowRange (const Range &r) const
Mat	rowRange (int startrow, int endrow) const
	指定した行範囲に対する行列ヘッダを作成する。
Mat &	setTo (InputArray value, InputArray mask=noArray())
	配列の全要素または一部の要素を指定した値に設定する。
Mat &	setZero ()
	配列のすべての要素を0に設定する。
MatShape	shape () const
	形状を返す。
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 (const MatShape &shape, int type)
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 (const MatShape &shape, int type)
static CV_NODISCARD_STD MatExpr	zeros (int ndims, const int *sz, int type)
static CV_NODISCARD_STD MatExpr	zeros (int rows, int cols, int type)
	指定したサイズと型のゼロ配列を返す。
static CV_NODISCARD_STD MatExpr	zeros (Size size, int type)

公開変数類
MatAllocator *	allocator
	カスタムアロケータ
int	cols
uchar *	data
	データへのポインタ
const uchar *	dataend
const uchar *	datalimit
const uchar *	datastart
	locateROI と adjustROI で使用される補助フィールド
int	dims
	行列の次元数。>= 2
int	dummy = 153
int	flags
int	rows
	行数と列数。行列が3次元以上の場合は (-1, -1)
MatSize	size
MatStep	step
UMatData *	u
	UMat との連携

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

詳細説明

カンマ区切りの行列初期化子。

通常、このクラスのインスタンスを明示的に作成することはない。代わりに "matrix << firstValue" 演算子によって作成される。

以下の例は2x2の回転行列を初期化する:

double angle = 30, a = cos(angle*CV_PI/180), b = sin(angle*CV_PI/180);
Mat R = (Mat_<double>(2,2) << a, -b, b, a);

非推奨Deprecated

代わりにstd::initializer_listを取るコンストラクタを使用すること:

 Mat_<int> m1({1, 2, 3, 4}); // 4x1 Mat
 Mat_<uchar> m2({2, 3}, {1, 2, 3, 4, 5, 6}); // 2x3 Mat
 
 Mat_<double> R({2, 2}, {a, -b, b, a}); // from example
*/
template<typename _Tp> class MatCommaInitializer_
{
public:
        the constructor, created by "matrix << firstValue" operator, where matrix is cv::Mat
    MatCommaInitializer_(Mat_<_Tp>* _m);
        the operator that takes the next value and put it to the matrix
 template<typename T2> MatCommaInitializer_<_Tp>& operator , (T2 v);
        another form of conversion operator
 operator Mat_<_Tp>() const;
protected:
    MatIterator_<_Tp> it;
};
 
 
 
// note that umatdata might be allocated together
// with the matrix data, not as a separate object.
// therefore, it does not have constructor or destructor;
// it should be explicitly initialized using init().
struct CV_EXPORTS UMatData
{
 enum MemoryFlag { COPY_ON_MAP=1, HOST_COPY_OBSOLETE=2,
        DEVICE_COPY_OBSOLETE=4, TEMP_UMAT=8, TEMP_COPIED_UMAT=24,
        USER_ALLOCATED=32, DEVICE_MEM_MAPPED=64,
        ASYNC_CLEANUP=128
    };
    UMatData(const MatAllocator* allocator);
    ~UMatData();
 
 // provide atomic access to the structure
 void lock();
 void unlock();
 
 bool hostCopyObsolete() const;
 bool deviceCopyObsolete() const;
 bool deviceMemMapped() const;
 bool copyOnMap() const;
 bool tempUMat() const;
 bool tempCopiedUMat() const;
 void markHostCopyObsolete(bool flag);
 void markDeviceCopyObsolete(bool flag);
 void markDeviceMemMapped(bool flag);
 
 const MatAllocator* prevAllocator;
 const MatAllocator* currAllocator;
 int urefcount;
 int refcount;
 uchar* data;
 uchar* origdata;
 size_t size;
 
    UMatData::MemoryFlag flags;
 void* handle;
 void* userdata;
 int allocatorFlags_;
 int mapcount;
    UMatData* originalUMatData;
    std::shared_ptr<void> allocatorContext;
};
CV_ENUM_FLAGS(UMatData::MemoryFlag)
 
typedef MatShape MatSize;
 
struct CV_EXPORTS MatStep
{
    MatStep() CV_NOEXCEPT;
    explicit MatStep(size_t s) CV_NOEXCEPT;
    const size_t& operator[](int i) const CV_NOEXCEPT;
 size_t& operator[](int i) CV_NOEXCEPT;
    operator size_t() const;
    MatStep& operator = (size_t s);
 void clear();
 
 size_t p[MatShape::MAX_DIMS];
};
 

本章の冒頭で述べたとおり、create() は、現在の配列の形状または型が指定されたものと異なる場合にのみ新しい配列を確保する。

• 多次元配列を作成する:

  // create a 100x100x100 8-bit array
  int sz[] = {100, 100, 100};
  Mat bigCube(3, sz, CV_8U, Scalar::all(0));

  ここでは次元数 =1 をMat コンストラクタに渡しているが、作成される配列は列数を1に設定した2次元配列となる。したがって、Mat::dims は常に >= 2 である(配列が空の場合は0になることもある)。
• 右辺に配列または式を置けるコピーコンストラクタや代入演算子を使う（下記参照）。冒頭で述べたとおり、配列の代入はO(1)の操作である。これはヘッダをコピーして参照カウンタを増やすだけだからである。配列の完全な（ディープな）コピーが必要な場合は、Mat::clone() メソッドを使用できる。
• 別の配列の一部に対するヘッダを構築する。これは単一の行、単一の列、複数の行、複数の列、配列内の矩形領域(代数で小行列(minor)と呼ばれる)、または対角成分でありうる。このような操作も新しいヘッダが同じデータを参照するため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)

  行列全体の場合と同様に、ディープコピーが必要なら、clone() メソッドを抽出した部分行列に対して使用すること。
• Make a header for user-allocated data. It can be useful to do the following:
  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;
     }

  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}\) には次のようにアクセスできる:

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

ここでは M が倍精度浮動小数点配列であると仮定している。at メソッドには、次元数に応じたいくつかのバリエーションがある。

2次元配列の1行全体を処理する必要がある場合、最も効率的な方法は、まずその行へのポインタを取得し、続いて単純な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つずつ処理するだけである（または、配列の加算のように、同じ座標を持つ複数の配列の要素を処理する）。このような操作は 要素ごと (element-wise) と呼ばれる。すべての入出力配列が連続しているかどうか、すなわち各行の末尾に隙間がないかどうかを確認するのは理にかなっている。もし連続していれば、それらを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.);
}

連続した行列の場合、外側ループの本体は一度だけ実行される。そのためオーバーヘッドが小さくなり、特に小さい行列の場合に顕著である。

最後に、連続する行の間の隙間を賢くスキップできる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.);

行列のイテレータはランダムアクセスイテレータなので、std::sort() を含む任意のSTLアルゴリズムに渡すことができる。

覚え書き

行列式と算術演算については MatExpr を参照

例

fld_lines.cpp、modules/shape/samples/shape_example.cpp、samples/cpp/connected_components.cpp、samples/cpp/demhist.cpp、samples/cpp/floodfill.cpp、samples/cpp/geometry.cpp、samples/cpp/grabcut.cpp、samples/cpp/image_alignment.cpp、samples/cpp/lkdemo.cpp、samples/cpp/pca.cpp、samples/cpp/snippets/camshiftdemo.cpp、samples/cpp/snippets/chromatic_aberration_correction.cpp、samples/cpp/snippets/cloning_demo.cpp、samples/cpp/snippets/create_mask.cpp、samples/cpp/snippets/detect_blob.cpp、samples/cpp/snippets/dis_opticalflow.cpp、samples/cpp/snippets/distrans.cpp、samples/cpp/snippets/edge.cpp、samples/cpp/snippets/epipolar_lines.cpp、samples/cpp/snippets/falsecolor.cpp、samples/cpp/snippets/intersectExample.cpp、samples/cpp/snippets/kalman.cpp、samples/cpp/snippets/kmeans.cpp、samples/cpp/snippets/laplace.cpp、samples/cpp/snippets/lsd_lines.cpp、samples/cpp/snippets/mask_tmpl.cpp、samples/cpp/snippets/phase_corr.cpp、samples/cpp/snippets/segment_objects.cpp、samples/cpp/snippets/stitching.cpp、samples/cpp/snippets/warpPerspective_demo.cpp、samples/cpp/snippets/watershed.cpp、samples/cpp/stitching_detailed.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/features/Homography/decompose_homography.cpp、samples/cpp/tutorial_code/features/Homography/homography_from_camera_displacement.cpp、samples/cpp/tutorial_code/features/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.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、samples/facedetect.cpp、samples/peopledetect.cpp.

列挙型メンバ詳解

anonymous enum

anonymous enum

列挙値
MAGIC_VAL
AUTO_STEP
CONTINUOUS_FLAG
SUBMATRIX_FLAG

anonymous enum

anonymous enum

列挙値
MAGIC_MASK
TYPE_MASK
DEPTH_MASK

構築子と解体子の詳解

Mat() [1/35]

cv::Mat::Mat

(

)

これらは行列を生成するさまざまなコンストラクタである。AutomaticAllocation で述べたように、多くの場合デフォルトコンストラクタで十分であり、適切な行列はOpenCVの関数によって割り当てられる。生成された行列は、さらに別の行列や行列式に代入したり、Mat::create で割り当てたりできる。前者の場合、古い内容は参照解除される。

Mat() [2/35]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

rows	2次元配列の行数。
cols	2次元配列の列数。
type	配列の型。CV_8UC1, ..., CV_64FC4を使って1～4チャンネルの行列を作成するか、CV_8UC(n), ..., CV_64FC(n)を使ってマルチチャンネル（最大CV_CN_MAXチャンネル）の行列を作成する。

Mat() [3/35]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

size	2次元配列のサイズ：Size(cols, rows) 。Size()コンストラクタでは、行数と列数が逆の順序で並ぶ。
type	配列の型。CV_8UC1, ..., CV_64FC4を使って1～4チャンネルの行列を作成するか、CV_8UC(n), ..., CV_64FC(n)を使ってマルチチャンネル（最大CV_CN_MAXチャンネル）の行列を作成する。

Mat() [4/35]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

rows	2次元配列の行数。
cols	2次元配列の列数。
type	配列の型。CV_8UC1, ..., CV_64FC4を使って1～4チャンネルの行列を作成するか、CV_8UC(n), ..., CV_64FC(n)を使ってマルチチャンネル（最大CV_CN_MAXチャンネル）の行列を作成する。
s	各行列要素を初期化するための省略可能な値。構築後にすべての行列要素を特定の値に設定するには、代入演算子Mat::operator=(const Scalar& value) を使用する。

Mat() [5/35]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

size	2次元配列のサイズ：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/35]

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

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

cv::Mat::Mat	(	const MatShape &	shape,
		int	type )

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

shape	配列の形状。
type	配列の型。CV_8UC1, ..., CV_64FC4を使って1～4チャンネルの行列を作成するか、CV_8UC(n), ..., CV_64FC(n)を使ってマルチチャンネル（最大CV_CN_MAXチャンネル）の行列を作成する。

Mat() [9/35]

cv::Mat::Mat	(	std::initializer_list< int >	shape,
		int	type )

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

shape	配列の形状。
type	配列の型。CV_8UC1, ..., CV_64FC4を使って1～4チャンネルの行列を作成するか、CV_8UC(n), ..., CV_64FC(n)を使ってマルチチャンネル（最大CV_CN_MAXチャンネル）の行列を作成する。

Mat() [10/35]

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() [11/35]

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() [12/35]

cv::Mat::Mat	(	const MatShape &	shape,
		int	type,
		const Scalar &	s )

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

shape	配列の形状。
type	配列の型。CV_8UC1, ..., CV_64FC4を使って1～4チャンネルの行列を作成するか、CV_8UC(n), ..., CV_64FC(n)を使ってマルチチャンネル（最大CV_CN_MAXチャンネル）の行列を作成する。
s	各行列要素を初期化するための省略可能な値。構築後にすべての行列要素を特定の値に設定するには、代入演算子Mat::operator=(const Scalar& value) を使用する。

Mat() [13/35]

cv::Mat::Mat	(	std::initializer_list< int >	shape,
		int	type,
		const Scalar &	s )

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

shape	配列の形状。
type	配列の型。CV_8UC1, ..., CV_64FC4を使って1～4チャンネルの行列を作成するか、CV_8UC(n), ..., CV_64FC(n)を使ってマルチチャンネル（最大CV_CN_MAXチャンネル）の行列を作成する。
s	各行列要素を初期化するための省略可能な値。構築後にすべての行列要素を特定の値に設定するには、代入演算子Mat::operator=(const Scalar& value) を使用する。

Mat() [14/35]

cv::Mat::Mat

(

const Mat &

m

)

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

m	（全体または一部が）構築される行列に割り当てられる配列。これらのコンストラクタではデータはコピーされない。代わりに、mのデータまたはその部分配列を指すヘッダが構築され、それと関連付けられる。参照カウンタがあれば、それがインクリメントされる。したがって、このようなコンストラクタで作成した行列を変更すると、mの対応する要素も変更される。部分配列の独立したコピーが必要な場合は、Mat::clone() を使用する。

Mat() [15/35]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

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

Mat() [16/35]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

size	2次元配列のサイズ：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に設定された場合）、パディングはないものとみなされ、実際のstepはcols*elemSize()として計算される。Mat::elemSizeを参照。

Mat() [17/35]

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個のstepの配列（最後のstepは常に要素サイズに設定される）。指定されない場合、行列は連続しているものとみなされる。

Mat() [18/35]

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個のstepの配列（最後のstepは常に要素サイズに設定される）。指定されない場合、行列は連続しているものとみなされる。

Mat() [19/35]

cv::Mat::Mat	(	const MatShape &	shape,
		int	type,
		void *	data,
		const size_t *	steps = 0 )

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

shape	配列の形状。
type	配列の型。CV_8UC1, ..., CV_64FC4を使って1～4チャンネルの行列を作成するか、CV_8UC(n), ..., CV_64FC(n)を使ってマルチチャンネル（最大CV_CN_MAXチャンネル）の行列を作成する。
data	ユーザーデータへのポインタ。dataおよびstep引数を取る行列コンストラクタは行列データを確保しない。代わりに、指定されたデータを指す行列ヘッダを初期化するだけであり、データはコピーされない。この操作は非常に効率的で、OpenCVの関数を使って外部データを処理するために利用できる。外部データは自動的には解放されないため、自分で管理する必要がある。
steps	多次元配列の場合の、ndims-1個のstepの配列（最後のstepは常に要素サイズに設定される）。指定されない場合、行列は連続しているものとみなされる。

Mat() [20/35]

cv::Mat::Mat	(	std::initializer_list< int >	shape,
		int	type,
		void *	data,
		const size_t *	steps = 0 )

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

shape	配列の形状。
type	配列の型。CV_8UC1, ..., CV_64FC4を使って1～4チャンネルの行列を作成するか、CV_8UC(n), ..., CV_64FC(n)を使ってマルチチャンネル（最大CV_CN_MAXチャンネル）の行列を作成する。
data	ユーザーデータへのポインタ。dataおよびstep引数を取る行列コンストラクタは行列データを確保しない。代わりに、指定されたデータを指す行列ヘッダを初期化するだけであり、データはコピーされない。この操作は非常に効率的で、OpenCVの関数を使って外部データを処理するために利用できる。外部データは自動的には解放されないため、自分で管理する必要がある。
steps	多次元配列の場合の、ndims-1個のstepの配列（最後のstepは常に要素サイズに設定される）。指定されない場合、行列は連続しているものとみなされる。

Mat() [21/35]

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() [22/35]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

m	（全体または一部が）構築される行列に割り当てられる配列。これらのコンストラクタではデータはコピーされない。代わりに、mのデータまたはその部分配列を指すヘッダが構築され、それと関連付けられる。参照カウンタがあれば、それがインクリメントされる。したがって、このようなコンストラクタで作成した行列を変更すると、mの対応する要素も変更される。部分配列の独立したコピーが必要な場合は、Mat::clone() を使用する。
roi	関心領域。

Mat() [23/35]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

m	（全体または一部が）構築される行列に割り当てられる配列。これらのコンストラクタではデータはコピーされない。代わりに、mのデータまたはその部分配列を指すヘッダが構築され、それと関連付けられる。参照カウンタがあれば、それがインクリメントされる。したがって、このようなコンストラクタで作成した行列を変更すると、mの対応する要素も変更される。部分配列の独立したコピーが必要な場合は、Mat::clone() を使用する。
ranges	各次元に沿ったmの選択範囲の配列。

Mat() [24/35]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

m	（全体または一部が）構築される行列に割り当てられる配列。これらのコンストラクタではデータはコピーされない。代わりに、mのデータまたはその部分配列を指すヘッダが構築され、それと関連付けられる。参照カウンタがあれば、それがインクリメントされる。したがって、このようなコンストラクタで作成した行列を変更すると、mの対応する要素も変更される。部分配列の独立したコピーが必要な場合は、Mat::clone() を使用する。
ranges	各次元に沿ったmの選択範囲の配列。

Mat() [25/35]

template<typename _Tp >

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

explicit

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

vec	要素が行列を構成するSTLベクトル。生成される行列は単一の列を持ち、行数はベクトルの要素数に等しい。行列の型はベクトル要素の型と一致する。このコンストラクタは、DataType が適切に宣言されている任意の型を扱える。すなわち、ベクトルの要素はプリミティブな数値型か、同一型の数値タプルでなければならない。混在型の構造体はサポートされない。対応するコンストラクタはexplicitである。STLベクトルはMat インスタンスへ自動的には変換されないため、Mat(vec) と明示的に記述する必要がある。データを行列にコピーする ( copyData=true ) のでない限り、ベクトルに新しい要素が追加されることはない。追加するとベクトルデータの再割り当てが起こりうるため、行列のデータポインタが無効になってしまうからである。
copyData	STLベクトルの内部データを新たに構築される行列へコピーする (true) か、共有する (false) かを指定するフラグ。データをコピーする場合、確保したバッファはMat の参照カウント機構で管理される。データを共有する場合は参照カウンタがNULLとなり、行列が破棄されるまでデータを解放してはならない。

Mat() [26/35]

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() [27/35]

template<typename _Tp >

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

explicit

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

Mat() [28/35]

template<typename _Tp , size_t _Nm>

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

explicit

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

Mat() [29/35]

template<typename _Tp , int n>

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

explicit

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

Mat() [30/35]

template<typename _Tp , int m, int n>

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

explicit

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

Mat() [31/35]

template<typename _Tp >

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

explicit

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

Mat() [32/35]

template<typename _Tp >

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

explicit

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

Mat() [33/35]

template<typename _Tp >

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

explicit

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

Mat() [34/35]

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

explicit

GpuMat からデータをダウンロードする

~Mat()

cv::Mat::~Mat

(

)

デストラクタ - release() を呼び出す

Mat() [35/35]

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 は上方向には拡大されない。

この関数は、filter2D やモルフォロジー操作などのOpenCVのフィルタリング関数によって内部的に使用される。

引数

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) を持つ形式は、単一行または単一列の2次元配列の要素にアクセスするのに使用できることに注意。つまり、たとえば A が 1 x N の浮動小数点行列で B が M x 1 の整数行列の場合、それぞれ A.at<float>(0,k+4) と B.at<int>(2*i+1,0) の代わりに、単純に A.at<float>(k+4) と B.at<int>(2*i+1) と書くことができる。

以下の例はヒルベルト行列を初期化する:

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/connected_components.cpp、samples/cpp/demhist.cpp、samples/cpp/image_alignment.cpp、samples/cpp/snippets/camshiftdemo.cpp、samples/cpp/snippets/epipolar_lines.cpp、samples/cpp/snippets/kalman.cpp、samples/cpp/snippets/kmeans.cpp、samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp、samples/cpp/tutorial_code/features/Homography/decompose_homography.cpp、samples/cpp/tutorial_code/features/Homography/homography_from_camera_displacement.cpp、samples/cpp/tutorial_code/features/Homography/pose_from_homography.cpp、samples/cpp/tutorial_code/ml/introduction_to_pca/introduction_to_pca.cpp、samples/dnn/classification.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イテレータの使い方と非常に似ている。以下の例では、アルファブレンディング関数が行列イテレータを使って書き直されている:

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.

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次元行列の場合、行列が1列のみのときはelemChannelsチャンネルを持つ必要があり、行列が1チャンネルのみのときはelemChannels列を持つ必要がある。3次元行列の場合は1チャンネルのみでなければならない。さらに、プレーン数が1でない場合は各プレーン内の行数が1でなければならず、各プレーン内の行数が1でない場合はプレーン数が1でなければならない。
depth	行列が持つべきビット深度。任意のビット深度でよい場合は-1に設定する。
requireContinuous	行列が連続していることを要求する場合はtrueに設定する。

戻り値

要件を満たさない場合は -1。それ以外の場合は行列の要素数を返す。要素は複数のチャンネルを持つ場合があることに注意。

次のコードは2次元行列での使用例を示す:

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

次のコードは3次元行列での使用例を示す:

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

clone()

CV_NODISCARD_STD Mat cv::Mat::clone

(

)

const

配列とその基になるデータの完全なコピーを作成する。

このメソッドは配列の完全なコピーを作成する。元の step[] は考慮されない。そのため、コピーされた配列は total()*elemSize() バイトを占める連続した配列となる。

例

samples/cpp/snippets/create_mask.cpp、samples/cpp/snippets/phase_corr.cpp、samples/cpp/stitching_detailed.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/features/Homography/homography_from_camera_displacement.cpp、samples/cpp/tutorial_code/features/Homography/pose_from_homography.cpp、samples/cpp/tutorial_code/imgcodecs/animations.cpp、samples/facedetect.cpp.

col()

Mat cv::Mat::col

(

int

x

)

const

指定した行列の列に対する行列ヘッダを作成する。

このメソッドは指定した行列の列に対する新しいヘッダを作成して返す。これは行列のサイズに関係なく O(1) の操作である。新しい行列の基になるデータは元の行列と共有される。Mat::row の説明も参照。

引数

x	0始まりの列インデックス。

例

samples/cpp/snippets/epipolar_lines.cpp、samples/cpp/tutorial_code/features/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/pca.cpp、samples/cpp/snippets/distrans.cpp、samples/cpp/snippets/phase_corr.cpp、samples/cpp/stitching_detailed.cpp、samples/dnn/colorization.cpp、samples/dnn/segmentation.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/grabcut.cpp、samples/cpp/image_alignment.cpp、samples/cpp/lkdemo.cpp、samples/cpp/snippets/edge.cpp、samples/cpp/snippets/watershed.cpp、samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp、samples/hog_tapi.cpp.

copyTo() [2/2]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

m	出力先の行列。操作前に適切なサイズや型を持っていない場合は再確保される。
mask	*this と同じサイズの操作マスク。その非ゼロ要素は、どの行列要素をコピーする必要があるかを示す。マスクの型は CV_8U、CV_8S または CV_Bool でなければならず、1個または複数のチャンネルを持つことができる。

create() [1/6]

void cv::Mat::create	(	const MatShape &	shape,
		int	type )

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

shape	新しい形状。
type	新しい行列の型。

create() [2/6]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

sizes	新しい配列の形状を指定する整数の配列。
type	新しい行列の型。

create() [3/6]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

ndims	新しい配列の次元数。
sizes	新しい配列の形状を指定する整数の配列。
type	新しい行列の型。

create() [4/6]

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/grabcut.cpp、samples/cpp/snippets/camshiftdemo.cpp、samples/cpp/snippets/edge.cpp、samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp、samples/dnn/segmentation.cpp.

create() [5/6]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

size	新しい行列サイズの別の指定方法：Size(cols, rows)
type	新しい行列の型。

create() [6/6]

void cv::Mat::create	(	std::initializer_list< int >	shape,
		int	type )

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

shape	新しい形状。
type	新しい行列の型。

createSameSize()

void cv::Mat::createSameSize	(	InputArray	arr,
		int	type )

別の配列と同じサイズの行列を作成する。

このメソッドは _OutputArray::createSameSize(arr, type) に似ているが、Mat に適用される。

引数

arr	もう一方の配列。
type	新しい行列の型。

cross()

Mat cv::Mat::cross

(

InputArray

m

)

const

2つの3要素ベクトルの外積を計算する。

このメソッドは2つの3要素ベクトルの外積を計算する。ベクトルは同じ形状とサイズの3要素浮動小数点ベクトルでなければならない。結果はオペランドと同じ形状および型の別の3要素ベクトルとなる。

引数

m	もう一方の外積のオペランド。

例

samples/cpp/tutorial_code/features/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/snippets/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	主対角を表す1次元行列。

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

2つのベクトルの内積を計算する。

このメソッドは2つの行列の内積を計算する。行列が単一列または単一行のベクトルでない場合、上から下、左から右へのスキャン順序で1次元ベクトルとして扱われる。ベクトルは同じサイズと型でなければならない。行列が複数のチャンネルを持つ場合、すべてのチャンネルの内積が合算される。

引数

m	もう一方の内積のオペランド。

例

samples/cpp/snippets/epipolar_lines.cpp、samples/cpp/tutorial_code/features/Homography/decompose_homography.cpp、samples/cpp/tutorial_code/features/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/grabcut.cpp、samples/cpp/image_alignment.cpp、samples/cpp/lkdemo.cpp、samples/cpp/snippets/chromatic_aberration_correction.cpp、samples/cpp/snippets/cloning_demo.cpp、samples/cpp/snippets/dis_opticalflow.cpp、samples/cpp/snippets/laplace.cpp、samples/cpp/snippets/mask_tmpl.cpp、samples/cpp/snippets/phase_corr.cpp、samples/cpp/snippets/segment_objects.cpp、samples/cpp/snippets/stitching.cpp、samples/cpp/snippets/watershed.cpp、samples/cpp/stitching_detailed.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.cpp、samples/dnn/classification.cpp、samples/dnn/colorization.cpp、samples/dnn/object_detection.cpp、samples/dnn/openpose.cpp、samples/dnn/segmentation.cpp、samples/facedetect.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.

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

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

このメソッドは Mat::zeros と同様に、Matlab形式の単位行列の初期化子を返す。Mat::ones と同様に、スケール操作を用いてスケーリングされた単位行列を効率的に生成できる:

// make a 4x4 diagonal matrix with 0.1's on the diagonal.
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	生成される行列の型。

fit() [1/6]

void cv::Mat::fit	(	const MatShape &	shape,
		int	type )

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

shape	新しい形状。
type	新しい行列の型。

fit() [2/6]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

sizes	新しい配列の形状を指定する整数の配列。
type	新しい行列の型。

fit() [3/6]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

ndims	新しい配列の次元数。
sizes	新しい配列の形状を指定する整数の配列。
type	新しい行列の型。

fit() [4/6]

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

create(rows, cols, type) に似ているが、既存のバッファサイズが不足している場合にのみメモリを再割り当てする。

引数

rows	新しい行数。
cols	新しい列数。
type	新しい行列の型。

fit() [5/6]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

size	新しい行列サイズの別の指定方法：Size(cols, rows)
type	新しい行列の型。

fit() [6/6]

void cv::Mat::fit	(	std::initializer_list< int >	shape,
		int	type )

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

shape	新しい形状。
type	新しい行列の型。

fitSameSize()

void cv::Mat::fitSameSize	(	InputArray	arr,
		int	type )

createSameSize(arr, type) に似ているが、既存のバッファが不足している場合にのみメモリを再割り当てする。

引数

arr	もう一方の配列。
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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

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/features/Homography/decompose_homography.cpp、samples/cpp/tutorial_code/features/Homography/homography_from_camera_displacement.cpp.

isContinuous()

bool cv::Mat::isContinuous

(

)

const

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

このメソッドは、行列要素が各行の終わりに隙間なく連続して格納されている場合に true を返す。そうでない場合は 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のかなり多くの関数で使用されている。要点は、要素ごとの操作(算術演算や論理演算、数学関数、アルファブレンディング、色空間変換など)が画像の幾何形状に依存しないということである。したがって、すべての入力配列と出力配列が連続していれば、関数はそれらを非常に長い単一行のベクトルとして処理できる。以下の例は、アルファブレンディング関数をどのように実装できるかを示している:

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 は常に新しい行列を確保するとは限らないため、出力配列をチェックする必要がある。

例

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

2つの行列の要素ごとの乗算または除算を実行する。

このメソッドは、省略可能なスケール付きで要素ごとの配列乗算を表す一時オブジェクトを返す。これはより単純な「\*」演算子に対応する行列乗算ではないことに注意。

例:

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

引数

m	*this と同じ型・同じサイズの別の配列、または行列式。
scale	省略可能なスケール係数。

ones() [1/4]

static CV_NODISCARD_STD MatExpr cv::Mat::ones ( const MatShape & shape, int type )

static

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

shape	配列の形状。
type	生成される行列の型。

ones() [2/4]

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

static

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

ndims	配列の次元数。
sz	配列の形状を指定する整数の配列。
type	生成される行列の型。

ones() [3/4]

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

static

指定されたサイズと型のすべての要素が1の配列を返す。

このメソッドは Mat::zeros と同様に、Matlab形式の1の配列の初期化子を返す。このメソッドを用いると、次のMatlabイディオムを使って配列を任意の値で初期化できることに注意:

Mat A = Mat::ones(100, 100, CV_8U)*3; // make 100x100 matrix filled with 3.

上記の操作は、すべての要素が1の100x100行列を作成してから3を掛けるわけではない。代わりにスケール係数(この場合は3)を記憶しておき、実際に行列初期化子を呼び出すときにそれを使用する。

覚え書き

マルチチャンネル型の場合、最初のチャンネルのみが1で初期化され、他のチャンネルは0に設定される。

引数

rows	行数。
cols	列数。
type	生成される行列の型。

ones() [4/4]

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	代入される行列式オブジェクト。代入操作の第1の形式とは異なり、第2の形式では、行列式の結果を収めるのに適切なサイズと型を持っていれば、すでに割り当て済みの行列を再利用できる。これは行列式が展開される実際の関数によって自動的に処理される。たとえば 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

)

行列の末尾から要素を削除する。

このメソッドは、行列の末尾から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/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp、samples/dnn/colorization.cpp、samples/dnn/object_detection.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

)

行列の末尾に要素を追加する。

これらのメソッドは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

追加される要素。

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

Mat cv::Mat::reshape	(	int	cn,
		const MatShape &	newshape ) const

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

cn	新しいチャンネル数。引数が0の場合、チャンネル数は変更されない。
newshape	MatShape の形式で与える新しい形状。

reshape() [2/5]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

cn	新しいチャンネル数。引数が0の場合、チャンネル数は変更されない。
newshape	全次元にわたる新しい行列サイズを表すベクトル。一部のサイズが0の場合、それらの次元では元のサイズが使われる。

reshape() [3/5]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

cn	新しいチャンネル数。引数が0の場合、チャンネル数は変更されない。
newndims	新しい次元数。
newsz	全次元にわたる新しい行列サイズを表す配列。一部のサイズが0の場合、それらの次元では元のサイズが使われる。

reshape() [4/5]

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

データをコピーせずに、2次元行列の形状やチャンネル数を変更する。

このメソッドは、*this の要素に対する新しい行列ヘッダを作成する。新しい行列は、異なるサイズや異なるチャンネル数を持つことができる。以下の条件を満たせば、任意の組み合わせが可能である。

• 新しい行列に余分な要素が追加されず、また要素が除外されないこと。したがって、変換後も rows*cols*channels() の積は同じでなければならない。
• データはコピーされない。つまりこれは O(1) の操作である。したがって、行数を変更する場合や、要素の行のインデックスを別の形で変える操作の場合、行列は連続でなければならない。Mat::isContinuous を参照のこと。

たとえば、STL の vector として格納された3次元点の集合があり、それらの点を 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

3チャンネルの 2x2 行列を1チャンネルの 4x3 行列に reshape したもの。各列は元のいずれかのチャンネルの値を持つ。

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/object_detection.cpp.

reshape() [5/5]

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

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

cn	新しいチャンネル数。引数が0の場合、チャンネル数は変更されない。
newshape	初期化子リストの形式で与える新しい形状。

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 など多くのアルゴリズムで使われる古典的な基本行列処理操作 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始まりの行インデックス。

例

samples/cpp/pca.cpp、samples/dnn/object_detection.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/snippets/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、CV_8S または CV_Bool でなければならず、1個または複数のチャンネルを持つことができる。

例

samples/dnn/segmentation.cpp.

setZero()

Mat & cv::Mat::setZero

(

)

配列のすべての要素を0に設定する。

shape()

MatShape cv::Mat::shape

(

)

const

形状を返す。

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)

例

samples/cpp/snippets/epipolar_lines.cpp、samples/cpp/tutorial_code/features/Homography/decompose_homography.cpp、samples/cpp/tutorial_code/features/Homography/homography_from_camera_displacement.cpp.

total() [1/2]

size_t cv::Mat::total

(

)

const

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

このメソッドは配列の要素数(配列が画像を表す場合はピクセル数)を返す。

例

samples/dnn/classification.cpp、samples/dnn/object_detection.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/snippets/dis_opticalflow.cpp、samples/cpp/snippets/epipolar_lines.cpp、samples/cpp/tutorial_code/ImgProc/Smoothing/Smoothing.cpp、samples/dnn/text_detection.cpp.

updateContinuityFlag()

void cv::Mat::updateContinuityFlag

(

)

内部使用メソッド: 連続性フラグを更新する

zeros() [1/4]

static CV_NODISCARD_STD MatExpr cv::Mat::zeros ( const MatShape & shape, int type )

static

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

shape	配列の形状。
type	生成される行列の型。

zeros() [2/4]

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

static

これは利便性のために提供されているオーバーロードされたメンバ関数である。上記の関数とは、受け取る引数のみが異なる。

引数

ndims	配列の次元数。
sz	配列の形状を指定する整数の配列。
type	生成される行列の型。

zeros() [3/4]

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

static

指定したサイズと型のゼロ配列を返す。

このメソッドは Matlab スタイルのゼロ配列初期化子を返す。定数配列を素早く生成して、関数の引数、行列式の一部、あるいは行列初期化子として使うのに利用できる:

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

上記の例では、A が 3x3 の浮動小数点行列でない場合にのみ新しい行列が確保される。それ以外の場合は、既存の行列 A がゼロで埋められる。

引数

rows	行数。
cols	列数。
type	生成される行列の型。

zeros() [4/4]

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/connected_components.cpp、samples/cpp/demhist.cpp、samples/cpp/geometry.cpp、samples/cpp/grabcut.cpp、samples/cpp/image_alignment.cpp、samples/cpp/snippets/camshiftdemo.cpp、samples/cpp/snippets/epipolar_lines.cpp、samples/cpp/snippets/falsecolor.cpp、samples/cpp/snippets/kmeans.cpp、samples/cpp/snippets/phase_corr.cpp、samples/cpp/snippets/stitching.cpp、samples/cpp/snippets/warpPerspective_demo.cpp、samples/cpp/snippets/watershed.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/dnn/classification.cpp、samples/dnn/object_detection.cpp、samples/dnn/openpose.cpp、samples/dnn/text_detection.cpp、samples/facedetect.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

dummy

int cv::Mat::dummy = 153

flags

int cv::Mat::flags

いくつかのビットフィールドを含む:

• マジックシグネチャ
• 連続性フラグ
• ビット深度
• チャンネル数

rows

int cv::Mat::rows

行数と列数。行列が3次元以上の場合は (-1, -1)

例

samples/cpp/connected_components.cpp、samples/cpp/demhist.cpp、samples/cpp/grabcut.cpp、samples/cpp/image_alignment.cpp、samples/cpp/snippets/camshiftdemo.cpp、samples/cpp/snippets/epipolar_lines.cpp、samples/cpp/snippets/falsecolor.cpp、samples/cpp/snippets/kmeans.cpp、samples/cpp/snippets/phase_corr.cpp、samples/cpp/snippets/stitching.cpp、samples/cpp/snippets/watershed.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/dnn/classification.cpp、samples/dnn/object_detection.cpp、samples/dnn/openpose.cpp、samples/dnn/text_detection.cpp.

size

MatSize cv::Mat::size

例

samples/cpp/connected_components.cpp、samples/cpp/grabcut.cpp、samples/cpp/image_alignment.cpp、samples/cpp/snippets/camshiftdemo.cpp、samples/cpp/snippets/cloning_demo.cpp、samples/cpp/snippets/create_mask.cpp、samples/cpp/snippets/dis_opticalflow.cpp、samples/cpp/snippets/mask_tmpl.cpp、samples/cpp/snippets/phase_corr.cpp、samples/cpp/snippets/segment_objects.cpp、samples/cpp/snippets/watershed.cpp、samples/cpp/stitching_detailed.cpp、samples/cpp/tutorial_code/ImgProc/Smoothing/Smoothing.cpp、samples/cpp/tutorial_code/features/Homography/homography_from_camera_displacement.cpp、samples/cpp/tutorial_code/photo/seamless_cloning/cloning_demo.cpp、samples/dnn/colorization.cpp、samples/dnn/object_detection.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