クラス
class	cv::PCA
	主成分分析[【詳解】（英語］

class	cv::LDA
	線形判別分析[【詳解】（英語］

class	cv::SVD
	特異値分解(Singular Value Decomposition)[【詳解】（英語］

class	cv::RNG
	乱数ジェネレータ[【詳解】（英語］

class	cv::RNG_MT19937
	Mersenne Twister乱数生成器[【詳解】（英語］

列挙型
enum	cv::ReduceTypes { cv::REDUCE_SUM = 0 , cv::REDUCE_AVG = 1 , cv::REDUCE_MAX = 2 , cv::REDUCE_MIN = 3 }

enum	cv::RotateFlags { cv::ROTATE_90_CLOCKWISE = 0 , cv::ROTATE_180 = 1 , cv::ROTATE_90_COUNTERCLOCKWISE = 2 }

enum	cv::DecompTypes { cv::DECOMP_LU = 0 , cv::DECOMP_SVD = 1 , cv::DECOMP_EIG = 2 , cv::DECOMP_CHOLESKY = 3 , cv::DECOMP_QR = 4 , cv::DECOMP_NORMAL = 16 }
	行列分解の種類[【詳解】（英語］

enum	cv::NormTypes { cv::NORM_INF = 1 , cv::NORM_L1 = 2 , cv::NORM_L2 = 4 , cv::NORM_L2SQR = 5 , cv::NORM_HAMMING = 6 , cv::NORM_HAMMING2 = 7 , cv::NORM_TYPE_MASK = 7 , cv::NORM_RELATIVE = 8 , cv::NORM_MINMAX = 32 }

enum	cv::CmpTypes { cv::CMP_EQ = 0 , cv::CMP_GT = 1 , cv::CMP_GE = 2 , cv::CMP_LT = 3 , cv::CMP_LE = 4 , cv::CMP_NE = 5 }
	比較タイプ[【詳解】（英語］

enum	cv::GemmFlags { cv::GEMM_1_T = 1 , cv::GEMM_2_T = 2 , cv::GEMM_3_T = 4 }
	一般化された行列乗算フラグ[【詳解】（英語］

enum	cv::DftFlags { cv::DFT_INVERSE = 1 , cv::DFT_SCALE = 2 , cv::DFT_ROWS = 4 , cv::DFT_COMPLEX_OUTPUT = 16 , cv::DFT_REAL_OUTPUT = 32 , cv::DFT_COMPLEX_INPUT = 64 , cv::DCT_INVERSE = DFT_INVERSE , cv::DCT_ROWS = DFT_ROWS }

enum	cv::BorderTypes { cv::BORDER_CONSTANT = 0 , cv::BORDER_REPLICATE = 1 , cv::BORDER_REFLECT = 2 , cv::BORDER_WRAP = 3 , cv::BORDER_REFLECT_101 = 4 , cv::BORDER_TRANSPARENT = 5 , cv::BORDER_REFLECT101 = BORDER_REFLECT_101 , cv::BORDER_DEFAULT = BORDER_REFLECT_101 , cv::BORDER_ISOLATED = 16 }

関数
CV_EXPORTS_W int	cv::borderInterpolate (int p, int len, int borderType)
	外挿されたピクセルのソース位置を求めます．[【詳解】（英語］

CV_EXPORTS_W void	cv::copyMakeBorder (InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar &value=Scalar())
	画像の周囲に境界線を形成します．[【詳解】（英語］

CV_EXPORTS_W void	cv::add (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
	2 つの配列，あるいは配列とスカラの要素毎の和を求めます．[【詳解】（英語］

CV_EXPORTS_W void	cv::subtract (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
	2つの配列同士，あるいは配列とスカラの要素毎の差を求めます．[【詳解】（英語］

CV_EXPORTS_W void	cv::multiply (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
	2つの配列の要素毎のスケーリングされた積を求めます．[【詳解】（英語］

CV_EXPORTS_W void	cv::divide (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
	2 つの配列，あるいはスカラを配列で割るという，要素毎の除算を行います．[【詳解】（英語］

CV_EXPORTS_W void	cv::divide (double scale, InputArray src2, OutputArray dst, int dtype=-1)

CV_EXPORTS_W void	cv::scaleAdd (InputArray src1, double alpha, InputArray src2, OutputArray dst)
	スケーリングされた配列と別の配列の和を求めます。[【詳解】（英語］

CV_EXPORTS_W void	cv::addWeighted (InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype=-1)
	2つの配列の加重和を計算します．[【詳解】（英語］

CV_EXPORTS_W void	cv::convertScaleAbs (InputArray src, OutputArray dst, double alpha=1, double beta=0)
	スケーリングを行い，絶対値を計算し，その結果を8ビットに変換します．[【詳解】（英語］

CV_EXPORTS_W void	cv::convertFp16 (InputArray src, OutputArray dst)
	配列を半精度浮動小数点に変換します。[【詳解】（英語］

CV_EXPORTS_W void	cv::LUT (InputArray src, InputArray lut, OutputArray dst)
	LUT ：配列のルックアップテーブル変換を行います。[【詳解】（英語］

	cv::CV_EXPORTS_AS (sumElems) Scalar sum(InputArray src)
	配列の要素の和を求めます．[【詳解】（英語］

CV_EXPORTS_W int	cv::countNonZero (InputArray src)
	ゼロではない配列要素を数えます。[【詳解】（英語］

CV_EXPORTS_W void	cv::findNonZero (InputArray src, OutputArray idx)
	0 ではないピクセルの位置のリストを返します[【詳解】（英語］

CV_EXPORTS_W Scalar	cv::mean (InputArray src, InputArray mask=noArray())
	配列の要素の平均（mean）を求めます．[【詳解】（英語］

CV_EXPORTS_W void	cv::meanStdDev (InputArray src, OutputArray mean, OutputArray stddev, InputArray mask=noArray())

CV_EXPORTS_W double	cv::norm (InputArray src1, int normType=NORM_L2, InputArray mask=noArray())
	配列の絶対値ノルムを計算します．[【詳解】（英語］

CV_EXPORTS_W double	cv::norm (InputArray src1, InputArray src2, int normType=NORM_L2, InputArray mask=noArray())
	絶対差分ノルムや相対差分ノルムを求めます．[【詳解】（英語］

CV_EXPORTS double	cv::norm (const SparseMat &src, int normType)

CV_EXPORTS_W double	cv::PSNR (InputArray src1, InputArray src2, double R=255.)
	画質指標であるPSNR（Peak Signal-to-Noise Ratio）を計算します。[【詳解】（英語］

CV_EXPORTS_W void	cv::batchDistance (InputArray src1, InputArray src2, OutputArray dist, int dtype, OutputArray nidx, int normType=NORM_L2, int K=0, InputArray mask=noArray(), int update=0, bool crosscheck=false)
	naive nearest neighbor finder[【詳解】（英語］

CV_EXPORTS_W void	cv::normalize (InputArray src, InputOutputArray dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, InputArray mask=noArray())
	配列のノルムや値の範囲を正規化します．[【詳解】（英語］

CV_EXPORTS void	cv::normalize (const SparseMat &src, SparseMat &dst, double alpha, int normType)

CV_EXPORTS_W void	cv::minMaxLoc (InputArray src, CV_OUT double minVal, CV_OUT double maxVal=0, CV_OUT Point minLoc=0, CV_OUT Point maxLoc=0, InputArray mask=noArray())
	配列のグローバルな最小値と最大値を求めます．[【詳解】（英語］

CV_EXPORTS void	cv::minMaxIdx (InputArray src, double minVal, double maxVal=0, int minIdx=0, int maxIdx=0, InputArray mask=noArray())
	配列のグローバルな最小値と最大値を求める[【詳解】（英語］

CV_EXPORTS void	cv::minMaxLoc (const SparseMat &a, double minVal, double maxVal, int minIdx=0, int maxIdx=0)

CV_EXPORTS_W void	cv::reduce (InputArray src, OutputArray dst, int dim, int rtype, int dtype=-1)
	行列をベクトルに変換します。[【詳解】（英語］

CV_EXPORTS void	cv::merge (const Mat *mv, size_t count, OutputArray dst)
	複数のシングルチャンネル配列から，1つのマルチチャンネル配列を作成します．[【詳解】（英語］

CV_EXPORTS_W void	cv::merge (InputArrayOfArrays mv, OutputArray dst)

CV_EXPORTS void	cv::split (const Mat &src, Mat *mvbegin)
	マルチチャンネル配列を，複数のシングルチャンネル配列に分割します．[【詳解】（英語］

CV_EXPORTS_W void	cv::split (InputArray m, OutputArrayOfArrays mv)

CV_EXPORTS void	cv::mixChannels (const Mat src, size_t nsrcs, Mat dst, size_t ndsts, const int *fromTo, size_t npairs)
	入力配列の指定されたチャンネルを，出力配列の指定されたチャンネルにコピーします．[【詳解】（英語］

CV_EXPORTS void	cv::mixChannels (InputArrayOfArrays src, InputOutputArrayOfArrays dst, const int *fromTo, size_t npairs)

CV_EXPORTS_W void	cv::mixChannels (InputArrayOfArrays src, InputOutputArrayOfArrays dst, const std::vector< int > &fromTo)

CV_EXPORTS_W void	cv::extractChannel (InputArray src, OutputArray dst, int coi)
	src から 1 つのチャンネルを抽出します（ coi は 0 ベースのインデックスです）。[【詳解】（英語］

CV_EXPORTS_W void	cv::insertChannel (InputArray src, InputOutputArray dst, int coi)
	dst に1つのチャンネルを挿入します（ coi は 0 から始まるインデックス）．[【詳解】（英語］

CV_EXPORTS_W void	cv::flip (InputArray src, OutputArray dst, int flipCode)
	2次元配列を，垂直，水平，または両軸で反転させます．[【詳解】（英語］

CV_EXPORTS_W void	cv::rotate (InputArray src, OutputArray dst, int rotateCode)
	2 次元配列を 90 度の倍数で回転させます。この関数はcv::rotateは，3つの異なる方法のうちの1つで配列を回転させます．時計回りに90度回転させる（rotateCode = ROTATE_90_CLOCKWISE）。時計回りに180度回転させる（rotateCode = ROTATE_180）。時計回りに270度回転します（rotateCode = ROTATE_90_COUNTERCLOCKWISE）。[【詳解】（英語］

CV_EXPORTS_W void	cv::repeat (InputArray src, int ny, int nx, OutputArray dst)
	出力配列を，入力配列の繰り返しコピーで埋めます．[【詳解】（英語］

CV_EXPORTS Mat	cv::repeat (const Mat &src, int ny, int nx)

CV_EXPORTS void	cv::hconcat (const Mat *src, size_t nsrc, OutputArray dst)
	与えられた行列に対して，水平方向の連結処理を行います．[【詳解】（英語］

CV_EXPORTS void	cv::hconcat (InputArray src1, InputArray src2, OutputArray dst)

CV_EXPORTS_W void	cv::hconcat (InputArrayOfArrays src, OutputArray dst)

CV_EXPORTS void	cv::vconcat (const Mat *src, size_t nsrc, OutputArray dst)
	与えられた行列に対して，垂直連結処理を行います．[【詳解】（英語］

CV_EXPORTS void	cv::vconcat (InputArray src1, InputArray src2, OutputArray dst)

CV_EXPORTS_W void	cv::vconcat (InputArrayOfArrays src, OutputArray dst)

CV_EXPORTS_W void	cv::bitwise_and (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
	2 つの配列のビット毎の論理積を計算します（dst = src1 & src2） 2 つの配列，あるいは配列とスカラの要素毎のビット毎の論理積を計算します．[【詳解】（英語］

CV_EXPORTS_W void	cv::bitwise_or (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
	2つの配列，あるいは，配列とスカラの要素ごとのビット単位の論理和を計算します．[【詳解】（英語］

CV_EXPORTS_W void	cv::bitwise_xor (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
	2 つの配列，または配列とスカラの要素毎に，ビット単位の排他的論理和を計算します．[【詳解】（英語］

CV_EXPORTS_W void	cv::bitwise_not (InputArray src, OutputArray dst, InputArray mask=noArray())
	配列の全ビットを反転させます。[【詳解】（英語］

CV_EXPORTS_W void	cv::absdiff (InputArray src1, InputArray src2, OutputArray dst)
	2つの配列、または配列とスカラの間の要素ごとの絶対値の差を計算します。[【詳解】（英語］

void CV_EXPORTS_W	cv::copyTo (InputArray src, OutputArray dst, InputArray mask)
	これはオーバーロードされたメンバ関数で，便宜上提供されています（python）行列を別の行列にコピーします．操作マスクが指定されている場合はMat::createが行列を再割り当てした場合，データをコピーする前に，新しく割り当てられた行列がすべてゼロで初期化されます．[【詳解】（英語］

CV_EXPORTS_W void	cv::inRange (InputArray src, InputArray lowerb, InputArray upperb, OutputArray dst)
	配列の要素が，他の2つの配列の要素の間にあるかどうかをチェックします．[【詳解】（英語］

CV_EXPORTS_W void	cv::compare (InputArray src1, InputArray src2, OutputArray dst, int cmpop)
	2つの配列，あるいは配列とスカラ値の要素毎の比較を行います．[【詳解】（英語］

CV_EXPORTS_W void	cv::min (InputArray src1, InputArray src2, OutputArray dst)
	2つの配列，あるいは配列とスカラの要素毎の最小値を求めます．[【詳解】（英語］

CV_EXPORTS void	cv::min (const Mat &src1, const Mat &src2, Mat &dst)

CV_EXPORTS void	cv::min (const UMat &src1, const UMat &src2, UMat &dst)

CV_EXPORTS_W void	cv::max (InputArray src1, InputArray src2, OutputArray dst)
	2つの配列、または配列とスカラの要素ごとの最大値を計算します。[【詳解】（英語］

CV_EXPORTS void	cv::max (const Mat &src1, const Mat &src2, Mat &dst)

CV_EXPORTS void	cv::max (const UMat &src1, const UMat &src2, UMat &dst)

CV_EXPORTS_W void	cv::sqrt (InputArray src, OutputArray dst)
	配列の要素の平方根を求めます．[【詳解】（英語］

CV_EXPORTS_W void	cv::pow (InputArray src, double power, OutputArray dst)
	配列の各要素をべき乗します．[【詳解】（英語］

CV_EXPORTS_W void	cv::exp (InputArray src, OutputArray dst)
	配列の各要素の指数を求めます．[【詳解】（英語］

CV_EXPORTS_W void	cv::log (InputArray src, OutputArray dst)
	配列の各要素の自然対数を求めます．[【詳解】（英語］

CV_EXPORTS_W void	cv::polarToCart (InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees=false)
	2次元ベクトルの大きさと角度から，そのx座標とy座標を求めます．[【詳解】（英語］

CV_EXPORTS_W void	cv::cartToPolar (InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false)
	2次元ベクトルの大きさと角度を計算します．[【詳解】（英語］

CV_EXPORTS_W void	cv::phase (InputArray x, InputArray y, OutputArray angle, bool angleInDegrees=false)
	2次元ベクトルの回転角度を計算します．[【詳解】（英語］

CV_EXPORTS_W void	cv::magnitude (InputArray x, InputArray y, OutputArray magnitude)
	2次元ベクトルの大きさを計算します．[【詳解】（英語］

CV_EXPORTS_W bool	cv::checkRange (InputArray a, bool quiet=true, CV_OUT Point *pos=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX)
	入力配列の各要素に不正な値がないかをチェックします．[【詳解】（英語］

CV_EXPORTS_W void	cv::patchNaNs (InputOutputArray a, double val=0)
	NaN を指定された数に変換します．[【詳解】（英語］

CV_EXPORTS_W void	cv::gemm (InputArray src1, InputArray src2, double alpha, InputArray src3, double beta, OutputArray dst, int flags=0)
	一般化された行列の乗算を行います。[【詳解】（英語］

CV_EXPORTS_W void	cv::mulTransposed (InputArray src, OutputArray dst, bool aTa, InputArray delta=noArray(), double scale=1, int dtype=-1)
	行列とその転置行列の積を計算します．[【詳解】（英語］

CV_EXPORTS_W void	cv::transpose (InputArray src, OutputArray dst)
	行列の転置を行います．[【詳解】（英語］

CV_EXPORTS_W void	cv::transform (InputArray src, OutputArray dst, InputArray m)
	配列の各要素に対して，行列変換を行います．[【詳解】（英語］

CV_EXPORTS_W void	cv::perspectiveTransform (InputArray src, OutputArray dst, InputArray m)
	ベクトルの透視行列変換を行います．[【詳解】（英語］

CV_EXPORTS_W void	cv::completeSymm (InputOutputArray m, bool lowerToUpper=false)
	正方行列の下半分または上半分を，もう一方の半分にコピーします．[【詳解】（英語］

CV_EXPORTS_W void	cv::setIdentity (InputOutputArray mtx, const Scalar &s=Scalar(1))
	スケーリングされた単位行列を初期化します．[【詳解】（英語］

CV_EXPORTS_W double	cv::determinant (InputArray mtx)
	浮動小数点型正方行列の行列式を返します．[【詳解】（英語］

CV_EXPORTS_W Scalar	cv::trace (InputArray mtx)
	行列のトレースを返します．[【詳解】（英語］

CV_EXPORTS_W double	cv::invert (InputArray src, OutputArray dst, int flags=DECOMP_LU)
	行列の逆行列，あるいは擬似逆行列を求めます．[【詳解】（英語］

CV_EXPORTS_W bool	cv::solve (InputArray src1, InputArray src2, OutputArray dst, int flags=DECOMP_LU)
	1 つ以上の連立方程式または最小二乗問題を解きます。[【詳解】（英語］

CV_EXPORTS_W void	cv::sort (InputArray src, OutputArray dst, int flags)
	行列の各行または各列をソートします．[【詳解】（英語］

CV_EXPORTS_W void	cv::sortIdx (InputArray src, OutputArray dst, int flags)
	行列の各行または各列をソートします．[【詳解】（英語］

CV_EXPORTS_W int	cv::solveCubic (InputArray coeffs, OutputArray roots)
	三次方程式の実根を求めます．[【詳解】（英語］

CV_EXPORTS_W double	cv::solvePoly (InputArray coeffs, OutputArray roots, int maxIters=300)
	多項式方程式の実根または複素根を求めます。[【詳解】（英語］

CV_EXPORTS_W bool	cv::eigen (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors=noArray())
	対称行列の固有値と固有ベクトルを計算します．[【詳解】（英語］

CV_EXPORTS_W void	cv::eigenNonSymmetric (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors)
	非対称行列の固有値と固有ベクトルを求めます（実数の固有値のみ）．[【詳解】（英語］

CV_EXPORTS void	cv::calcCovarMatrix (const Mat *samples, int nsamples, Mat &covar, Mat &mean, int flags, int ctype=CV_64F)
	ベクトルの集合の共分散行列を計算します．[【詳解】（英語］

CV_EXPORTS_W void	cv::calcCovarMatrix (InputArray samples, OutputArray covar, InputOutputArray mean, int flags, int ctype=CV_64F)

CV_EXPORTS_W void	cv::PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, int maxComponents=0)

	cv::CV_EXPORTS_AS (PCACompute2) void PCACompute(InputArray data

CV_EXPORTS_W void	cv::PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, double retainedVariance)

CV_EXPORTS_W void	cv::PCAProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result)

CV_EXPORTS_W void	cv::PCABackProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result)

CV_EXPORTS_W void	cv::SVDecomp (InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags=0)

CV_EXPORTS_W void	cv::SVBackSubst (InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst)

CV_EXPORTS_W double	cv::Mahalanobis (InputArray v1, InputArray v2, InputArray icovar)
	2 つのベクトル間のマハラノビス距離を計算します．[【詳解】（英語］

CV_EXPORTS_W void	cv::dft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
	1次元あるいは2次元の浮動小数点型配列に対して，離散フーリエ変換または逆変換を行います．[【詳解】（英語］

CV_EXPORTS_W void	cv::idft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
	1次元あるいは2次元の配列に対して，離散フーリエ変換の逆変換を行います．[【詳解】（英語］

CV_EXPORTS_W void	cv::dct (InputArray src, OutputArray dst, int flags=0)
	1次元または2次元の配列に対して，離散コサイン変換または逆変換を行います．[【詳解】（英語］

CV_EXPORTS_W void	cv::idct (InputArray src, OutputArray dst, int flags=0)
	1次元あるいは2次元配列の離散コサイン変換の逆変換を求めます．[【詳解】（英語］

CV_EXPORTS_W void	cv::mulSpectrums (InputArray a, InputArray b, OutputArray c, int flags, bool conjB=false)
	2つのフーリエ・スペクトルの要素毎の乗算を行います．[【詳解】（英語］

CV_EXPORTS_W int	cv::getOptimalDFTSize (int vecsize)
	与えられたベクトルサイズに対して，最適な DFT サイズを返します．[【詳解】（英語］

CV_EXPORTS RNG &	cv::theRNG ()
	デフォルトの乱数生成器を返します。[【詳解】（英語］

CV_EXPORTS_W void	cv::setRNGSeed (int seed)
	デフォルトの乱数生成器の状態を設定します．[【詳解】（英語］

CV_EXPORTS_W void	cv::randu (InputOutputArray dst, InputArray low, InputArray high)
	一様に分散した単一の乱数または乱数の配列を生成します。[【詳解】（英語］

CV_EXPORTS_W void	cv::randn (InputOutputArray dst, InputArray mean, InputArray stddev)
	正規分布した乱数で配列を埋めます．[【詳解】（英語］

CV_EXPORTS_W void	cv::randShuffle (InputOutputArray dst, double iterFactor=1., RNG *rng=0)
	配列の要素をランダムにシャッフルします．[【詳解】（英語］

変数
InputOutputArray	cv::mean

InputOutputArray OutputArray	cv::eigenvectors

InputOutputArray OutputArray OutputArray	cv::eigenvalues

InputOutputArray OutputArray OutputArray int	cv::maxComponents = 0)

InputOutputArray OutputArray OutputArray double	cv::retainedVariance

詳解

列挙型詳解

◆ BorderTypes

enum cv::BorderTypes

様々な種類の境界線，画像の境界線を表すには|

参照: borderInterpolate,copyMakeBorder

列挙値
border_constant	`iiiiii\|abcdefgh\|iiiiiii`で示され，いくつかの指定された`i`
border_replicate	`aaaaaa\|abcdefgh\|hhhhhhh`
ボーダーリフレクト（BORDER_REFLECT	`fedcba\|abcdefgh\|hgfedcb`
ボーダー・ワラップ	`cdefgh\|abcdefgh\|abcdefg`
ボーダー・リフレクト・101	`gfedcb\|abcdefgh\|gfedcba`
ボーダー・トランスペアレント	`uvwxyz\|abcdefgh\|ijklmno`
ボーダー_リフレクト101	BORDER_REFLECT_101と同じ
ボーダー_デフォルト	BORDER_REFLECT_101と同じ
border_isolated	ROIの外を見ない

◆ CmpTypes

enum cv::CmpTypes

比較タイプ

列挙値
CMP_EQ	src1とsrc2が等しい
CMP_GT	src1が src2よりも大きい。
CMP_GE	src1がsrc2よりも大きいか同じ。
CMP_LT	src1が src2よりも小さい。
CMP_LE	src1が src2と同等以下であること。
CMP_NE	src1がsrc2と不等間隔

◆ DecompTypes

enum cv::DecompTypes

行列分解の種類

列挙値
DECOMP_LU	最適なピボット要素を選択するガウスの消去法．
DECOMP_SVD	特異値分解 (SVD) 法．システムが過大に定義されていたり，行列 src1 が特異であったりします．
DECOMP_EIG	固有値分解：行列 src1 は対称でなければいけません．
DECOMP_CHOLESKY	コレスキー因数分解；行列 src1 は，対称かつ正定値でなければいけません．
DECOMP_QR	QR 因数分解：システムが過剰に定義されていたり，行列 src1 が特異であったりします．
DECOMP_NORMAL	これまでのフラグはすべて相互に排他的ですが，このフラグはこれまでのフラグのどれかと一緒に使うことができます． $\texttt{src1}^T\cdot\texttt{src1}\cdot\texttt{dst}=\texttt{src1}^T\texttt{src2}$ これは，元のシステムの代わりに，通常の方程式を解くことを意味します． $\texttt{src1}\cdot\texttt{dst}=\texttt{src2}$

◆ DftFlags

enum cv::DftFlags

列挙値
DFT_INVERSE	は，デフォルトの順変換の代わりに，1次元または2次元の逆変換を行います．
DFT_SCALE	結果を配列の要素数で割ることで，結果をスケーリングします．通常はDFT_INVERSEと組み合わせて使用します。
DFT_ROWS	は，入力行列の各行に対して，順変換または逆変換を行います．このフラグは，複数のベクトルを同時に変換することを可能にします．また，3次元や高次元変換などを行う際のオーバーヘッド（処理自体の数倍になることもあります）を減らすために利用することもできます．
DFT_COMPLEX_OUTPUT	は，1次元または2次元の実数配列の順変換を行います．結果は複素数配列ですが，複素共役対称(CCS詳細は後述の関数説明を参照してください）であり，このような配列は，入力と同じサイズの実数配列にパックすることができます．これが最も高速なオプションであり，この関数のデフォルトの動作です．しかし，（より簡単なスペクトル解析などのために）完全な複素数配列を得たい場合もあるでしょう．このフラグを渡すと，この関数は完全なサイズの複素数出力配列を生成します．
DFT_REAL_OUTPUT	通常，結果は同じサイズの複素数配列ですが，入力配列が共役複素数の対称性を持つ場合（例えば，DFT_COMPLEX_OUTPUTフラグを指定した順変換の結果）は，実数配列が出力されます．この関数自体は，入力が対称かどうかをチェックしませんが，フラグを渡すことで，対称性を仮定して実数の出力配列を生成します（ただし，入力が実数配列にパックされて逆変換が実行された場合，この関数は入力をパックされた複素共役対称の配列として扱い，出力も実数配列になります）．
dft_complex_input	は，入力が複素数入力であることを指定します．このフラグが設定されている場合、入力は2チャンネルでなければなりません。一方，後方互換性の理由から，入力が2チャンネルであれば，入力はすでに複素数とみなされる。
DCT_INVERSE	は，デフォルトの順変換の代わりに，1次元または2次元の逆変換を行います．
DCT_ROWS	は，入力行列の個々の行に対して，順変換または逆変換を行います．このフラグにより，複数のベクトルを同時に変換することができます．また，3次元や高次元変換などを行う際のオーバーヘッド（処理自体の数倍になることもあります）を減らすためにも利用できます．

◆ GemmFlags

enum cv::GemmFlags

一般化された行列乗算フラグ

列挙値
GEMM_1_T	src1 を転置します
GEMM_2_T	src2 を転置します
GEMM_3_T	src3 を変換します。

◆ NormTypes

enum cv::NormTypes

ノルムの種類

src1 と src2 は，入力配列を表します．

列挙値
NORM_INF	$norm = \forkthree {\\|\texttt{src1}\\|_{L_{\infty}} = \max _I \| \texttt{src1} (I)\|}{if \‍(\texttt{normType} = \texttt{NORM_INF}\‍) } {\\|\texttt{src1}-\texttt{src2}\\|_{L_{\infty}} = \max _I \| \texttt{src1} (I) - \texttt{src2} (I)\|}{if \‍(\texttt{normType} = \texttt{NORM_INF}\‍) } {\frac{\\|\texttt{src1}-\texttt{src2}\\|_{L_{\infty}} }{\\|\texttt{src2}\\|_{L_{\infty}} }}{if \‍(\texttt{normType} = \texttt{NORM_RELATIVE \| NORM_INF}\‍) }$
NORM_L1	$norm = \forkthree {\\| \texttt{src1} \\| _{L_1} = \sum _I \| \texttt{src1} (I)\|}{if \‍(\texttt{normType} = \texttt{NORM_L1}\‍)} { \\| \texttt{src1} - \texttt{src2} \\| _{L_1} = \sum _I \| \texttt{src1} (I) - \texttt{src2} (I)\|}{if \‍(\texttt{normType} = \texttt{NORM_L1}\‍) } { \frac{\\|\texttt{src1}-\texttt{src2}\\|_{L_1} }{\\|\texttt{src2}\\|_{L_1}} }{if \‍(\texttt{normType} = \texttt{NORM_RELATIVE \| NORM_L1}\‍) }$
NORM_L2	$norm = \forkthree { \\| \texttt{src1} \\| _{L_2} = \sqrt{\sum_I \texttt{src1}(I)^2} }{if \‍(\texttt{normType} = \texttt{NORM_L2}\‍) } { \\| \texttt{src1} - \texttt{src2} \\| _{L_2} = \sqrt{\sum_I (\texttt{src1}(I) - \texttt{src2}(I))^2} }{if \‍(\texttt{normType} = \texttt{NORM_L2}\‍) } { \frac{\\|\texttt{src1}-\texttt{src2}\\|_{L_2} }{\\|\texttt{src2}\\|_{L_2}} }{if \‍(\texttt{normType} = \texttt{NORM_RELATIVE \| NORM_L2}\‍) }$
NORM_L2SQR	$norm = \forkthree { \\| \texttt{src1} \\| _{L_2} ^{2} = \sum_I \texttt{src1}(I)^2} {if \‍(\texttt{normType} = \texttt{NORM_L2SQR}\‍)} { \\| \texttt{src1} - \texttt{src2} \\| _{L_2} ^{2} = \sum_I (\texttt{src1}(I) - \texttt{src2}(I))^2 }{if \‍(\texttt{normType} = \texttt{NORM_L2SQR}\‍) } { \left(\frac{\\|\texttt{src1}-\texttt{src2}\\|_{L_2} }{\\|\texttt{src2}\\|_{L_2}}\right)^2 }{if \‍(\texttt{normType} = \texttt{NORM_RELATIVE \| NORM_L2SQR}\‍) }$
NORM_HAMMING	入力配列が1つの場合，0からの距離を計算します．Hamming入力配列が1つの場合，その配列の0からの距離を計算します．Hamming配列間の距離を計算します。
ノルムハンマリング2	NORM_HAMMINGと似ていますが、計算の際に入力配列の各2ビットが加算され、NORM_HAMMINGと同じ計算に使用される1ビットとして扱われます。
NORM_TYPE_MASK	ノルムフラグからノルムタイプを分離するために使用できるビットマスクです。
NORM_RELATIVE	フラグ。
NORM_MINMAX	フラグ。

◆ ReduceTypes

enum cv::ReduceTypes

列挙値
REDUCE_SUM	は，行列のすべての行/列の合計を出力します．
REDUCE_AVG	出力は, 行列のすべての行/列の平均ベクトルです.
REDUCE_MAX	出力は，行列のすべての行/列の最大値（列/行単位）．
REDUCE_MIN	行列のすべての行/列の最小値（列/行単位）を出力します．

◆ RotateFlags

enum cv::RotateFlags

列挙値
rotate_90_clockwise	時計回りに 90 度回転します。
ローテート_180	時計回りに 180 度回転させる。
ローテート_90_カウンタークロックワイズ	時計回りに270度回転させる

関数詳解

◆ absdiff()

CV_EXPORTS_W void cv::absdiff	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst
	)

2つの配列、または配列とスカラの間の要素ごとの絶対値の差を計算します。

この関数はcv::absdiffを計算します。2つの配列のサイズと型が同じ場合の絶対差。

$\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2}(I)|)$

2 番目の配列がスカラから構成されているか，あるいは，配列のチャンネル数と同数の要素を持つ場合の，配列とスカラの絶対値の差src1:

$\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2} |)$

第1の配列がスカラから作られているか，あるいは，第2の配列のチャンネル数と同じ数の要素を持っている場合の，スカラと配列の絶対値の差src2:

$\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1} - \texttt{src2}(I) |)$

ここで I は，配列要素の多次元インデックスです．マルチチャンネル配列の場合，各チャンネルは独立して処理されます．

覚え書き: 配列のビット深度が CV_32S の場合，彩度は適用されません．また，オーバーフローした場合には，負の値を得ることもあります．

引数

src1	1 番目の入力配列またはスカラ．
src2	2番目の入力配列，あるいはスカラ．
dst	入力配列と同じサイズ，同じ型である出力配列．

参照: cv::abs(const Mat&)

◆ add()

CV_EXPORTS_W void cv::add	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		InputArray	mask = `noArray()`,
		int	dtype = `-1`
	)

2 つの配列，あるいは配列とスカラの要素毎の和を求めます．

関数 add は，次のように計算します．

両方の入力配列が同じサイズ，同じチャンネル数である場合の，2 つの配列の和．
$\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0$
src2 が Scalar から構成されるか，あるいは src2 と同じ数の要素を持つ場合の，配列とスカラの和src1.channels():
$\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0$
src1 がスカラから作成されるか，または src2 と同じ要素数を持つ場合，スカラと配列の和src2.channels():
$\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0$
ここでIは，配列要素の多次元インデックスです．マルチチャンネル配列の場合，各チャンネルは独立して処理されます．

上述のリストの最初の関数は，行列式で置き換えることができます．

dst = src1 + src2;

dst += src1; // equivalent to add(dst, src1, dst);

入力配列と出力配列は，すべて同じ深さ，あるいは異なる深さを持つことができます．例えば，8ビットの符号付き配列に16ビットの符号なし配列を加算し，その和を32ビットの浮動小数点配列として格納することができます．出力配列の深さは、dtypeパラメータで決定されます。上記の 2 番目と 3 番目のケース，そして最初のケースと同様に， src1.depth() == src2.depth() の場合， dtype をデフォルトの -1 に設定することができます。この場合，出力配列の深さは， src1，src2，またはその両方の入力配列と同じになります。

覚え書き: 出力配列のビット深度が CV_32S の場合，Saturation は適用されません．また，オーバーフローが発生した場合は，不正な符号の結果が得られる可能性があります．

引数

src1	1 番目の入力配列またはスカラ．
src2	2番目の入力配列，あるいはスカラ．
dst	入力配列と同じサイズ，同じチャンネル数の出力配列．そのビット深度は， dtype または src1/src2 によって定義されます．
mask	オプションである操作マスク - 8ビットのシングルチャンネル配列で，変更される出力配列の要素を指定します．
dtype	オプションで，出力配列のビット深度を指定します（後述の説明を参照してください）．

参照: subtract,addWeighted,scaleAdd,Mat::convertTo

◆ addWeighted()

CV_EXPORTS_W void cv::addWeighted	(	InputArray	src1,
		double	alpha,
		InputArray	src2,
		double	beta,
		double	gamma,
		OutputArray	dst,
		int	dtype = `-1`
	)

2つの配列の加重和を計算します．

関数 addWeighted は，以下のように 2 つの配列の加重和を計算します．

$\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} + \texttt{src2} (I)* \texttt{beta} + \texttt{gamma} )$

ここで I は，配列要素の多次元インデックスです．マルチチャンネル配列の場合，各チャンネルは個別に処理されます．この関数は，行列式で置き換えることができます．

dst = src1*alpha + src2*beta + gamma;

覚え書き: 出力配列のビット深度が CV_32S の場合，Saturation は適用されません．また，オーバーフローが発生した場合は，不正な符号の結果が得られる可能性があります．

引数

src1	1番目の入力配列．
alpha	最初の配列要素の重み．
src2	src1 と同じサイズ，同じチャンネル数の 2 番目の入力配列．
beta	2 番目の配列要素の重み．
gamma	それぞれの和に加えられるスカラ．
dst	入力配列と同じサイズ，同じチャンネル数の出力配列．
dtype	オプションである出力配列のビット深度．両方の入力配列のビット深度が同じ場合， dtype に -1 を設定することができ，これは src1.depth() と同じになります．

参照: add,subtract,scaleAdd,Mat::convertTo

◆ batchDistance()

CV_EXPORTS_W void cv::batchDistance	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dist,
		int	dtype,
		OutputArray	nidx,
		int	normType = `NORM_L2`,
		int	K = `0`,
		InputArray	mask = `noArray()`,
		int	update = `0`,
		bool	crosscheck = `false`
	)

naive nearest neighbor finder

見るhttp://en.wikipedia.org/wiki/Nearest_neighbor_search

todo:: ドキュメント

◆ bitwise_and()

CV_EXPORTS_W void cv::bitwise_and	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		InputArray	mask = `noArray()`
	)

2 つの配列のビット毎の論理積を計算します（dst = src1 & src2） 2 つの配列，あるいは配列とスカラの要素毎のビット毎の論理積を計算します．

この関数はcv::bitwise_andは，要素毎のビット単位の論理積を計算します．src1 と src2 が同じサイズの場合は，2つの配列．

$\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0$

src2 がスカラから構成されるか，またはスカラと同じ要素数を持つ場合の，配列とスカラ．src1.channels():

$\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} \quad \texttt{if mask} (I) \ne0$

src1 がスカラから作成されるか，または以下の要素数と同じである場合，スカラと配列．src2.channels():

$\texttt{dst} (I) = \texttt{src1} \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0$

浮動小数点型配列の場合は，マシン固有のビット表現（通常は IEEE754 準拠）が処理に利用されます．マルチチャンネル配列の場合，各チャンネルは独立して処理されます．上記の2番目と3番目のケースでは，まずスカラが配列型に変換されます．

引数

src1	1 番目の入力配列またはスカラ．
src2	2番目の入力配列，あるいはスカラ．
dst	入力配列と同じサイズ，同じ型である出力配列．
mask	オプションのオペレーションマスク．8ビットのシングルチャンネル配列で，変更する出力配列の要素を指定します．

◆ bitwise_not()

CV_EXPORTS_W void cv::bitwise_not	(	InputArray	src,
		OutputArray	dst,
		InputArray	mask = `noArray()`
	)

配列の全ビットを反転させます。

この関数はcv::bitwise_notは，入力配列の要素ごとのビット単位の反転を計算します。

$\texttt{dst} (I) = \neg \texttt{src} (I)$

浮動小数点型の入力配列の場合，マシン固有のビット表現（通常，IEEE754準拠）を用いて演算します．また，マルチチャンネル配列の場合は，各チャンネルが独立して処理されます．

引数

src	入力配列．
dst	入力配列と同じサイズ，同じ型の出力配列．
mask	オプションのオペレーションマスク．8ビットのシングルチャンネル配列で，変更する出力配列の要素を指定します．

◆ bitwise_or()

CV_EXPORTS_W void cv::bitwise_or	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		InputArray	mask = `noArray()`
	)

2つの配列，あるいは，配列とスカラの要素ごとのビット単位の論理和を計算します．

この関数はcv::bitwise_or要素毎のビット単位の論理和を計算します．src1 と src2 が同じサイズの場合の 2 つの配列．

$\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0$

src2 がスカラから構成されるか，またはスカラと同じ要素数を持つ場合の，配列とスカラ．src1.channels():

$\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} \quad \texttt{if mask} (I) \ne0$

src1 がスカラから作成されるか，または以下の要素数と同じである場合，スカラと配列．src2.channels():

$\texttt{dst} (I) = \texttt{src1} \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0$

浮動小数点型配列の場合は，マシン固有のビット表現（通常は IEEE754 準拠）が処理に利用されます．マルチチャンネル配列の場合，各チャンネルは独立して処理されます．上記の2番目と3番目のケースでは，まずスカラが配列型に変換されます．

引数

src1	1 番目の入力配列またはスカラ．
src2	2番目の入力配列，あるいはスカラ．
dst	入力配列と同じサイズ，同じ型である出力配列．
mask	オプションのオペレーションマスク．8ビットのシングルチャンネル配列で，変更する出力配列の要素を指定します．

◆ bitwise_xor()

CV_EXPORTS_W void cv::bitwise_xor	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		InputArray	mask = `noArray()`
	)

2 つの配列，または配列とスカラの要素毎に，ビット単位の排他的論理和を計算します．

この関数はcv::bitwise_xor要素毎に，ビット単位の論理和「排他的論理和」を計算します．src1 と src2 が同じサイズの場合の 2 つの配列．

$\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0$

src2 がスカラから構成されるか，またはスカラと同じ要素数を持つ場合の，配列とスカラ．src1.channels():

$\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} \quad \texttt{if mask} (I) \ne0$

src1 がスカラから作成されるか，または以下の要素数と同じである場合，スカラと配列．src2.channels():

$\texttt{dst} (I) = \texttt{src1} \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0$

浮動小数点型配列の場合は，マシン固有のビット表現（通常は IEEE754 準拠）が演算に利用されます．また，マルチチャンネル配列の場合は，各チャンネルが独立して処理されます．上記の2番目と3番目のケースでは，まずスカラが配列型に変換されます．

引数

src1	1 番目の入力配列またはスカラ．
src2	2番目の入力配列，あるいはスカラ．
dst	入力配列と同じサイズ，同じ型である出力配列．
mask	オプションのオペレーションマスク．8ビットのシングルチャンネル配列で，変更する出力配列の要素を指定します．

◆ borderInterpolate()

CV_EXPORTS_W int cv::borderInterpolate	(	int	p,
		int	len,
		int	borderType
	)

外挿されたピクセルのソース位置を求めます．

この関数は，指定された外挿分割モードを用いた場合に，指定された外挿分割ピクセルに対応するドナーピクセルの座標を計算して返します．例えば、水平方向にcv::BORDER_WRAPモードを水平方向に使用しcv::BORDER_REFLECT_101を垂直方向に使用し，浮動小数点型画像 img 内の「仮想」ピクセル Point(-5, 100) の値を計算したい場合は，次のようになります．

float val = img.at<float>(borderInterpolate(100, img.rows, cv::BORDER_REFLECT_101),

borderInterpolate(-5, img.cols, cv::BORDER_WRAP));

cv::borderInterpolate

CV_EXPORTS_W int borderInterpolate(int p, int len, int borderType)

Computes the source location of an extrapolated pixel.

cv::BORDER_WRAP

@ BORDER_WRAP

cdefgh|abcdefgh|abcdefg

Definition: base.hpp:272

cv::BORDER_REFLECT_101

@ BORDER_REFLECT_101

gfedcb|abcdefgh|gfedcba

Definition: base.hpp:273

通常，この関数は直接呼び出されることはありません．この関数は，フィルタリング関数の中や，copyMakeBorder の中で使われます．

引数

p	外挿されたピクセルの，いずれかの軸に沿った0ベースの座標，<0 or >= len
len	対応する軸に沿った配列の長さを表します．
borderType	ボーダーの種類．BorderTypesを除く。BORDER_TRANSPARENTおよびBORDER_ISOLATED. borderType==BORDER_CONSTANTの場合，この関数は p や len に関わらず常に -1 を返します．

参照: copyMakeBorder

◆ calcCovarMatrix() [1/2]

CV_EXPORTS void cv::calcCovarMatrix	(	const Mat *	samples,
		int	nsamples,
		Mat &	covar,
		Mat &	mean,
		int	flags,
		int	ctype = `CV_64F`
	)

ベクトルの集合の共分散行列を計算します．

この関数はcv::calcCovarMatrixは，入力ベクトル集合の共分散行列と，任意に平均ベクトルを計算します．

引数

samples	別々の行列として格納されたサンプル
nsamples	サンプル数
covar	ctype 型，正方形サイズの共分散行列を出力します．
mean	入力ベクトルの平均値を表す，入力または出力（フラグに依存）の配列．
flags	以下の組み合わせである操作フラグCovarFlags
ctype	matrixl の型．デフォルトでは，「CV_64F」になります．

参照: PCA,mulTransposed,Mahalanobis

todo:: InputArrayOfArrays

◆ calcCovarMatrix() [2/2]

CV_EXPORTS_W void cv::calcCovarMatrix	(	InputArray	samples,
		OutputArray	covar,
		InputOutputArray	mean,
		int	flags,
		int	ctype = `CV_64F`
	)

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

覚え書き: 使用COVAR_ROWSまたはCOVAR_COLSフラグ。

引数

samples	のサンプルは，1つの行列の行/列として格納されます．
covar	ctype 型，正方形サイズの共分散行列を出力します．
mean	入力ベクトルの平均値を表す，入力または出力（フラグに依存）の配列．
flags	以下の組み合わせである操作フラグCovarFlags
ctype	matrixl の型．デフォルトでは，「CV_64F」になります．

◆ cartToPolar()

CV_EXPORTS_W void cv::cartToPolar	(	InputArray	x,
		InputArray	y,
		OutputArray	magnitude,
		OutputArray	angle,
		bool	angleInDegrees = `false`
	)

2次元ベクトルの大きさと角度を計算します．

この関数はcv::cartToPolarこの関数は，すべての2次元ベクトル (x(I),y(I)) に対して，大きさ，角度，あるいはその両方を計算します．

$\begin{array}{l} \texttt{magnitude} (I)= \sqrt{\texttt{x}(I)^2+\texttt{y}(I)^2} , \\ \texttt{angle} (I)= \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))[ \cdot180 / \pi ] \end{array}$

角度は約0.3度の精度で計算されます。角度は約0.3度の精度で計算されます。点(0,0)の場合，角度は0に設定されます。

引数

x	x座標の配列．これは，単精度または倍精度の浮動小数点型配列でなければいけません．
y	y座標の配列．xと同じサイズ，同じ型でなければいけません．
magnitude	xと同じサイズ，同じ型の大きさの出力配列．
angle	x と同じサイズ，同じ型の角度の出力配列．角度は，ラジアン（0 から 2*Pi まで）または度（0 から 360 度）で表されます．
angleInDegrees	角度をラジアン（デフォルト）で測るか，あるいは度で測るかを示すフラグです．

参照: Sobel,Scharr

◆ checkRange()

CV_EXPORTS_W bool cv::checkRange	(	InputArray	a,
		bool	quiet = `true`,
		CV_OUT Point *	pos = `0`,
		double	minVal = `-DBL_MAX`,
		double	maxVal = `DBL_MAX`
	)

入力配列の各要素に不正な値がないかをチェックします．

この関数はcv::checkRange配列の各要素が NaN でも無限でもないことをチェックします。minVal > -DBL_MAX かつ maxVal < DBL_MAX の場合，各値が minVal と maxVal の間にあるかどうかもチェックします。マルチチャンネル配列の場合，各チャンネルは独立して処理されます．いくつかの値が範囲外である場合，最初に外れた値の位置が pos に格納されます（ pos != NULL の場合）．その後，この関数は false を返すか（ quiet=true の場合），例外を発生させます．

引数

a	入力配列．
quiet	フラグ．これは，配列要素が範囲外の場合に，関数が静かに false を返すか，例外を発生させるかを示します．
pos	オプションの出力パラメータ．NULLでない場合は， src.dims 要素の配列へのポインタでなければいけません．
minVal	有効な値の範囲の下界を含みます．
maxVal	有効な値の範囲の上側の排他的境界

◆ compare()

CV_EXPORTS_W void cv::compare	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		int	cmpop
	)

2つの配列，あるいは配列とスカラ値の要素毎の比較を行います．

この関数は，以下の比較を行います src1 と src2 のサイズが同じである場合，2つの配列の要素を比較します．

$\texttt{dst} (I) = \texttt{src1} (I) \,\texttt{cmpop}\, \texttt{src2} (I)$

src2 がスカラから構成されているか，単一の要素を持つ場合は， src1 の要素とスカラ src2 とを比較します．

$\texttt{dst} (I) = \texttt{src1}(I) \,\texttt{cmpop}\, \texttt{src2}$

src1 がスカラから構築されているか，単一の要素を持っている場合は， src2 の要素を持つ src1．

$\texttt{dst} (I) = \texttt{src1} \,\texttt{cmpop}\, \texttt{src2} (I)$

比較結果が真の場合は，出力配列の対応する要素が 255 になります．これらの比較演算は，等価な行列式で置き換えることができます．

Mat
dst1 = src1 >= src2;

Mat
dst2 = src1 < 8;
...

引数

src1	1 番目の入力配列またはスカラ；配列である場合は，単一のチャンネルを持たなければならない．
src2	2 番目の入力配列またはスカラ，それが配列の場合は単一チャンネルでなければいけません．
dst	入力配列と同じサイズ，同じチャンネル数を持つ，ref CV_8U 型の出力配列．
cmpop	配列同士の対応関係を指定するフラグ（以下）．cv::CmpTypes)

参照: checkRange,min,max,threshold

◆ completeSymm()

CV_EXPORTS_W void cv::completeSymm	(	InputOutputArray	m,
		bool	lowerToUpper = `false`
	)

正方行列の下半分または上半分を，もう一方の半分にコピーします．

この関数はcv::completeSymmは，正方行列の下半分または上半分を，もう半分にコピーします．行列の対角線は変更されません。

$\texttt{m}_{ij}=\texttt{m}_{ji}$ のためのものです。if lowerToUpper=false
$\texttt{m}_{ij}=\texttt{m}_{ji}$ のためのものです。lowerToUpper=true の場合

引数

m	入出力可能な浮動小数点型正方行列．
lowerToUpper	演算フラグ．trueの場合，下半分が上半分にコピーされます．そうでなければ，上半分が下半分にコピーされます．

参照: flip,transpose

◆ convertFp16()

CV_EXPORTS_W void cv::convertFp16	(	InputArray	src,
		OutputArray	dst
	)

配列を半精度浮動小数点に変換します。

この関数は，FP32（単精度浮動小数点）をFP16（半精度浮動小数点）と相互に変換します．CV_16S フォーマットは，FP16 データを表現するために利用されます．2つの使用モード（ src -> dst ）があります．CV_32F -> CV_16S と CV_16S -> CV_32F です．CV_32F -> CV_16S と CV_16S -> CV_32F です．ビット深度を表すためには，入力配列の型が CV_32F か CV_16S でなければいけません．入力配列がそのどちらでもない場合，この関数はエラーを発生させます．半精度浮動小数点のフォーマットは，IEEE 754-2008 で定義されています．

引数

src	入力配列．
dst	出力配列．

◆ convertScaleAbs()

CV_EXPORTS_W void cv::convertScaleAbs	(	InputArray	src,
		OutputArray	dst,
		double	alpha = `1`,
		double	beta = `0`
	)

スケーリングを行い，絶対値を計算し，その結果を8ビットに変換します．

関数 convertScaleAbs は，入力配列の各要素に対して，スケーリング，絶対値の取り方，符号なし8ビット型への変換，という3つの処理を順次行います．

$\texttt{dst} (I)= \texttt{saturate\_cast<uchar>} (| \texttt{src} (I)* \texttt{alpha} + \texttt{beta} |)$

マルチチャンネル配列の場合，この関数は各チャンネルを個別に処理します．出力が8ビットではない場合，この操作はMat::convertToメソッドを呼び出して（あるいは，行列式を使って），その結果の絶対値を計算することで，操作をエミュレートすることができます．例えば，以下のようになります．

Mat_<float>
A(30,30);

randu(A,
Scalar(-100),
Scalar(100));

Mat_<float>
B = A*5 + 3;
B =
abs(B);

// Mat_<float> B = abs(A*5+3) will also do the job,

// but it will allocate a temporary matrix

引数

src	入力配列．
dst	出力配列．
alpha	オプションのスケールファクタ．
beta	オプションで，スケーリングされた値に加えられるデルタ．

参照: Mat::convertTo, cv::abs(const Mat&)

◆ copyMakeBorder()

CV_EXPORTS_W void cv::copyMakeBorder	(	InputArray	src,
		OutputArray	dst,
		int	top,
		int	bottom,
		int	left,
		int	right,
		int	borderType,
		const Scalar &	value = `Scalar()`
	)

画像の周囲に境界線を形成します．

この関数は，入力画像を出力画像の中央にコピーします．コピーされた元画像の左，右，上，下の領域は，外挿されたピクセルで埋められます．これは，この関数を基にしたフィルタリング関数が行っていること（オンザフライでピクセルを外挿すること）とは異なりますが，あなた自身の関数を含む他のより複雑な関数が，画像の境界処理を簡単にするために行っていることもあります．

この関数は， src が既に dst の中央に位置している場合のモードをサポートします．この場合，この関数は src 自体をコピーするのではなく，例えば，境界線を単に作成します．

// let border be the same in all directions

int
border=2;

// constructs a larger image to fit both the image and the border

Mat
gray_buf(rgb.rows + border*2, rgb.cols + border*2, rgb.depth());

// select the middle part of it w/o copying data

Mat
gray(gray_canvas,
Rect(border, border, rgb.cols, rgb.rows));

// convert image from RGB to grayscale

cvtColor(rgb, gray, COLOR_RGB2GRAY);

// form a border in-place

copyMakeBorder(gray, gray_buf, border, border,

border, border,
BORDER_REPLICATE);

// now do some custom filtering ...
...

覚え書き: また，入力画像がより大きな画像の一部（ROI）である場合，この関数は ROI の外側のピクセルを利用して境界を形成しようとします．この機能を無効にして，あたかも src が ROI ではないかのように，常に外挿分割を行うには， borderType |BORDER_ISOLATED.

引数

src	元画像。
dst	src と同じタイプで，サイズが Size(src.cols+left+right, src.rows+top+bottom) である出力画像．
top	上のピクセル
bottom	下側のピクセル
left	左側のピクセル
right	ソース画像の矩形領域から、それぞれの方向に何ピクセルずつ外挿するかを指定するパラメータ。例えば， top=1, bottom=1, left=1, right=1 とすると，1ピクセル幅のボーダーを作成する必要があります．
borderType	ボーダーの種類。詳しくは borderInterpolateを参照してください。
value	borderType==BORDER_CONSTANT の場合のボーダー値。

参照: borderInterpolate

◆ copyTo()

void CV_EXPORTS_W cv::copyTo	(	InputArray	src,
		OutputArray	dst,
		InputArray	mask
	)

これはオーバーロードされたメンバ関数で，便宜上提供されています（python）行列を別の行列にコピーします．操作マスクが指定されている場合はMat::createが行列を再割り当てした場合，データをコピーする前に，新しく割り当てられた行列がすべてゼロで初期化されます．

引数

src	コピー元の行列。
dst	コピー先の行列。演算前に適切なサイズや型を持っていない場合は，再割り当てされます．
mask	this と同じサイズの演算マスク．その非0の要素は，どの行列要素をコピーする必要があるかを示します．このマスクは，CV_8U型でなければならず，1つまたは複数のチャンネルを持つことができます．

◆ countNonZero()

CV_EXPORTS_W int cv::countNonZero ( InputArray src )

ゼロではない配列要素を数えます。

この関数は， src の 0 ではない要素の数を返します．

$\sum _{I: \; \texttt{src} (I) \ne0 } 1$

引数

src	シングルチャンネル配列．

参照: の平均値を求めます．meanStdDev,norm,minMaxLoc,calcCovarMatrix

◆ CV_EXPORTS_AS() [1/2]

cv::CV_EXPORTS_AS ( PCACompute2 )

PCA::operator() をラップし，固有値の出力パラメータを追加します．

◆ CV_EXPORTS_AS() [2/2]

cv::CV_EXPORTS_AS ( sumElems )

配列の要素の和を求めます．

関数 cv::sum は，各チャンネル毎に配列要素の和を求め，それを返します．

引数

src	1 から 4 までのチャンネルを持つ入力配列．

参照: countNonZeroの平均値です．meanStdDev,norm,minMaxLoc,reduce

◆ dct()

CV_EXPORTS_W void cv::dct	(	InputArray	src,
		OutputArray	dst,
		int	flags = `0`
	)

1次元または2次元の配列に対して，離散コサイン変換または逆変換を行います．

この関数はcv::dctは，1次元または2次元の浮動小数点配列に対して，離散コサイン変換（DCT）を行います．

N個の要素を持つ1次元ベクトルのコサイン変換を行います．
$Y = C^{(N)} \cdot X$
ここで
$C^{(N)}_{jk}= \sqrt{\alpha_j/N} \cos \left ( \frac{\pi(2k+1)j}{2N} \right )$
および $\alpha_0=1$ , $\alpha_j=2$ のためのものです。j > 0.
N個の要素を持つ1次元ベクトルの逆コサイン変換。
$X = \left (C^{(N)} \right )^{-1} \cdot Y = \left (C^{(N)} \right )^T \cdot Y$
(ただし $C^{(N)}$ は直交行列なので $C^{(N)} \cdot \left(C^{(N)}\right)^T = I$ )
M x N 行列の 2 次元コサイン変換の正解
$Y = C^{(N)} \cdot X \cdot \left (C^{(N)} \right )^T$
M x N 個の行列に対する逆 2 次元コサイン変換．
$X = \left (C^{(N)} \right )^T \cdot X \cdot C^{(N)}$

この関数は，入力配列のフラグとサイズを見て，動作モードを選択します．

もし， (flags &DCT_INVERSE) == 0 の場合，この関数は 1 次元または 2 次元の順変換を行います．それ以外の場合は，1次元または2次元の逆変換を行います．
もし， (flags &DCT_ROWS) != 0 の場合，この関数は各行に対して1次元変換を行います．
配列が1列または1行の場合，この関数は1次元変換を行います。
上記のいずれでもない場合，この関数は2次元変換を行います．

覚え書き: 現在，dct は偶数サイズの配列をサポートしています（2, 4, 6 ...）．データ解析や近似のために，必要に応じて配列を埋めることができます．また，関数の性能は，配列のサイズに大きく依存し，しかも単調ではありません（ getOptimalDFTSize を参照してください）．現在の実装では，サイズ N のベクトルに対する DCT は，サイズ N/2 のベクトルに対する DFT を介して計算されます．したがって，最適なDCTサイズ N1 >= N は，以下のように計算できます．

size_t getOptimalDCTSize(size_t N) { return 2*getOptimalDFTSize((N+1)/2); }

N1 = getOptimalDCTSize(N);

cv::getOptimalDFTSize

CV_EXPORTS_W int getOptimalDFTSize(int vecsize)

Returns the optimal DFT size for a given vector size.

引数

src	入力浮動小数点配列．
dst	src と同じサイズ，同じ型の出力配列．
flags	の組み合わせである変換フラグ．cv::DftFlags(DCT_*)

参照: dft,getOptimalDFTSize,idct

◆ determinant()

CV_EXPORTS_W double cv::determinant ( InputArray mtx )

浮動小数点型正方行列の行列式を返します．

この関数はcv::determinantこの関数は，指定された行列の行列式を計算して返します．小さい行列（ mtx.cols=mtx.rows<=3 ）に対しては，直接法が用いられます．より大きな行列に対しては，部分的にピボットを用いた LU 因数分解が用いられます．

対称的な正定値行列に対しては，固有値分解を用いて行列式を計算することも可能です．

引数

mtx	CV_32FC1 または CV_64FC1 型で，サイズが正方形でなければならない入力行列．

参照: trace,invert,solve,eigen,MatrixExpressions

◆ dft()

CV_EXPORTS_W void cv::dft	(	InputArray	src,
		OutputArray	dst,
		int	flags = `0`,
		int	nonzeroRows = `0`
	)

1次元あるいは2次元の浮動小数点型配列に対して，離散フーリエ変換または逆変換を行います．

この関数はcv::dftは，以下のいずれかの処理を行います．

N 個の要素を持つ 1 次元ベクトルのフーリエ変換を行います．
$Y = F^{(N)} \cdot X,$
ここで $F^{(N)}_{jk}=\exp(-2\pi i j k/N)$ および $i=\sqrt{-1}$
N 個の要素を持つ 1 次元ベクトルのフーリエ変換の逆変換
$\begin{array}{l} X'= \left (F^{(N)} \right )^{-1} \cdot Y = \left (F^{(N)} \right )^* \cdot y \\ X = (1/N) \cdot X, \end{array}$
ここで $F^*=\left(\textrm{Re}(F^{(N)})-\textrm{Im}(F^{(N)})\right)^T$
M x N 行列の 2 次元フーリエ変換を行う．
$Y = F^{(M)} \cdot X \cdot F^{(N)}$
M x N 行列の2次元フーリエ変換の逆変換。
$\begin{array}{l} X'= \left (F^{(M)} \right )^* \cdot Y \cdot \left (F^{(N)} \right )^* \\ X = \frac{1}{M \cdot N} \cdot X' \end{array}$

実数（シングルチャンネル）のデータの場合，フーリエ変換の出力スペクトルやフーリエ変換の入力スペクトルは，次のようなパック形式で表されます。CCS(complex-conjugate-symmetrical)と呼ばれるパック形式で表されます。これはIPL(Intel* Image Processing Library)から拝借したものです。ここでは、2DCCSスペクトルはこんな感じです。

$\begin{bmatrix} Re Y_{0,0} & Re Y_{0,1} & Im Y_{0,1} & Re Y_{0,2} & Im Y_{0,2} & \cdots & Re Y_{0,N/2-1} & Im Y_{0,N/2-1} & Re Y_{0,N/2} \\ Re Y_{1,0} & Re Y_{1,1} & Im Y_{1,1} & Re Y_{1,2} & Im Y_{1,2} & \cdots & Re Y_{1,N/2-1} & Im Y_{1,N/2-1} & Re Y_{1,N/2} \\ Im Y_{1,0} & Re Y_{2,1} & Im Y_{2,1} & Re Y_{2,2} & Im Y_{2,2} & \cdots & Re Y_{2,N/2-1} & Im Y_{2,N/2-1} & Im Y_{1,N/2} \\ \hdotsfor{9} \\ Re Y_{M/2-1,0} & Re Y_{M-3,1} & Im Y_{M-3,1} & \hdotsfor{3} & Re Y_{M-3,N/2-1} & Im Y_{M-3,N/2-1}& Re Y_{M/2-1,N/2} \\ Im Y_{M/2-1,0} & Re Y_{M-2,1} & Im Y_{M-2,1} & \hdotsfor{3} & Re Y_{M-2,N/2-1} & Im Y_{M-2,N/2-1}& Im Y_{M/2-1,N/2} \\ Re Y_{M/2,0} & Re Y_{M-1,1} & Im Y_{M-1,1} & \hdotsfor{3} & Re Y_{M-1,N/2-1} & Im Y_{M-1,N/2-1}& Re Y_{M/2,N/2} \end{bmatrix}$

実数ベクトルの1次元変換の場合，出力は上の行列の1行目のようになります。

つまり，この関数は，フラグと入力配列のサイズに応じて，処理モードを選択します．

もしDFT_ROWSがセットされている場合，あるいは入力配列が1行あるいは1列の場合，この関数は行列の各行に対して1次元の順変換あるいは逆変換を行います．DFT_ROWSがセットされている場合は，行列の各行に対して1次元の順変換または逆変換を行います．それ以外の場合は，2次元の変換を行います．
入力配列が実数でDFT_INVERSEがセットされていない場合，この関数は，1次元または2次元の順変換を行います．
- となります。DFT_COMPLEX_OUTPUTがセットされている場合，出力は入力と同じサイズの複素行列になります．
- となります。DFT_COMPLEX_OUTPUTがセットされていない場合，出力は入力と同じサイズの実数行列になります．2次元変換の場合は，上記のようなパック形式が用いられます。単一の1次元変換の場合，上述の行列の最初の行のようになります。複数の1次元変換を行った場合（フラグDFT_ROWSフラグを利用した場合），出力行列の各行は，上述の行列の最初の行のようになります．
入力配列が複素数の場合でDFT_INVERSEまたはDFT_REAL_OUTPUTがセットされていない場合，出力は入力と同じサイズの複素数配列になります．この関数は，フラグ DFT_INVERSE と DFT_ROWS に依存して，入力配列全体，あるいは入力配列の各行に対して，個別に 1 次元または 2 次元の順変換，逆変換を行います．
となります。DFT_INVERSEがセットされていて，入力配列が実数である場合，あるいは複素数であるがDFT_REAL_OUTPUTがセットされている場合，出力は入力と同じサイズの実数配列となります．この関数は，フラグに応じて入力配列全体あるいは各行に対して，1次元あるいは2次元の逆変換を行います．DFT_INVERSEおよびDFT_ROWS.

もしDFT_SCALEがセットされている場合は，変換後にスケーリングが行われます．

dct とは異なり，この関数は任意のサイズの配列をサポートします．しかし，小さな素数（現在の実装では，2，3，5）の積でサイズが因数分解できるような配列だけが，効率的に処理されます．このような効率的なDFTサイズは，getOptimalDFTSizeメソッドを用いて計算できます．

以下のサンプルは，2つの2次元実数配列のDFTベースの畳み込みを計算する方法を示しています．

void
convolveDFT(InputArray A, InputArray B,
OutputArray
C)
{

// reallocate the output array if needed

C.create(abs(A.rows - B.rows)+1,
abs(A.cols - B.cols)+1, A.type());

Size
dftSize;

// calculate the size of DFT transform

dftSize.width
=
getOptimalDFTSize(A.cols + B.cols - 1);

dftSize.height
=
getOptimalDFTSize(A.rows + B.rows - 1);


// allocate temporary buffers and initialize them with 0's

Mat
tempA(dftSize, A.type(),
Scalar::all(0));

Mat
tempB(dftSize, B.type(),
Scalar::all(0));


// copy A and B to the top-left corners of tempA and tempB, respectively

Mat
roiA(tempA,
Rect(0,0,A.cols,A.rows));

A.copyTo(roiA);

Mat
roiB(tempB,
Rect(0,0,B.cols,B.rows));

B.copyTo(roiB);


// now transform the padded A & B in-place;

// use "nonzeroRows" hint for faster processing

dft(tempA, tempA, 0, A.rows);

dft(tempB, tempB, 0, B.rows);


// multiply the spectrums;

// the function handles packed spectrum representations well

mulSpectrums(tempA, tempB, tempA);


// transform the product back from the frequency domain.

// Even though all the result rows will be non-zero,

// you need only the first C.rows of them, and thus you

// pass nonzeroRows == C.rows

dft(tempA, tempA,
DFT_INVERSE
+
DFT_SCALE, C.rows);


// now copy the result back to C.

tempA(Rect(0, 0, C.cols, C.rows)).copyTo(C);


// all the temporary buffers will be deallocated automatically
}

このサンプルを最適化するために，以下のようなアプローチを検討します．

nonzeroRows != 0 が順変換の呼び出しに渡され，A と B はそれぞれ tempA と tempB の左上にコピーされるので，tempA と tempB 全体をクリアする必要はありません．tempA.cols - A.cols ( tempB.cols - B.cols ) の右端の列をクリアするだけでよいのです。
このDFTベースの畳み込みは，特にBがAよりもかなり小さい場合やその逆の場合には，大きな配列全体に適用する必要はありません．その代わりに，部分的に畳み込みを計算することができます．そのためには，出力配列Cを複数のタイルに分割する必要があります．各タイルについて、そのタイルでコンボリューションを計算するために、AとBのどの部分が必要かを推定します。Cのタイルが小さすぎると、繰り返し作業が発生するため、速度が大きく低下します。究極的には、Cの各タイルが1ピクセルの場合、このアルゴリズムは、ナイーブコンボリューションアルゴリズムと同等になる。タイルが大きすぎると、一時的な配列であるtempAとtempBが大きくなりすぎ、また、キャッシュの局所性が悪くなるため、速度が低下してしまいます。つまり、中間に最適なタイルサイズがあるのです。
Cの異なるタイルが並列に計算され、その結果、畳み込みが部分的に行われるのであれば、ループをスレッド化することができます。

上記の改良点はすべて、次のように実装されています。matchTemplateおよびfilter2D. したがって，これらを利用すれば，上記の理論的に最適な実装よりもさらに優れた性能を得ることができます。ただし，これらの2つの関数は，実際には畳み込みではなく相互相関を計算しているので，2番目の畳み込みオペランドBをflip .NETを使って縦横に反転させる必要があります．

覚え書き

離散フーリエ変換を用いた例は、opencv_source_code/samples/cpp/dft.cpp にあります。
(Python) dft 機能を使って Wiener デコンボリューションを行う例は opencv_source/samples/python/deconvolution.py にあります。
(Python) フーリエ画像の象限を並べ替える例は、opencv_source/samples/python/dft.py にあります。

引数

src	実数または複素数の入力配列。
dst	出力配列．そのサイズと型はフラグに依存します．
flags	の組み合わせを表す変換フラグ。DftFlags
nonzeroRows	このパラメータが0ではない場合，この関数は入力配列の最初の非0Rows行のみを想定します (DFT_INVERSEがセットされていない場合），あるいは出力配列の最初の nonzeroRows 行だけが非ゼロを含んでいると仮定します。DFT_INVERSEこのテクニックは，DFTを用いて配列の相互相関や畳み込みを計算する際に非常に有用です．

参照: dct,getOptimalDFTSize,mulSpectrums,filter2D,matchTemplate,flip,cartToPolar,magnitude,phase

◆ divide() [1/2]

CV_EXPORTS_W void cv::divide	(	double	scale,
		InputArray	src2,
		OutputArray	dst,
		int	dtype = `-1`
	)

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

◆ divide() [2/2]

CV_EXPORTS_W void cv::divide	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		double	scale = `1`,
		int	dtype = `-1`
	)

2 つの配列，あるいはスカラを配列で割るという，要素毎の除算を行います．

この関数はcv::divideは，ある配列を別の配列で分割します．

$\texttt{dst(I) = saturate(src1(I)*scale/src2(I))}$

src1 が存在しない場合は，スカラを配列で分割します．

$\texttt{dst(I) = saturate(scale/src2(I))}$

マルチチャンネル配列の異なるチャンネルは，独立して処理されます．

整数型の場合， src2(I) が0の時， dst(I) も0になります．

覚え書き: 浮動小数点データの場合は， src2(I) がゼロの場合の特別な動作は定義されていません．通常の浮動小数点演算が行われます。浮動小数点データの場合は，IEEE-754 の正しい振る舞いを期待しましょう（NaN, Inf の結果値を含む）．; 出力配列のビット深度が CV_32S の場合，Saturation は適用されません．また，オーバーフローが発生した場合は，不正な符号の結果が得られる可能性があります．

引数

src1	1番目の入力配列．
src2	src1 と同じサイズ，同じ型の 2 番目の入力配列．
scale	スカラー係数．
dst	src2 と同じサイズ，同じ型の出力配列．
dtype	オプションで，出力配列のビット深度を指定します． -1 の場合，dst のビット深度は src2.depth() となりますが，配列対配列の分割の場合は， src1.depth()==src2.depth() の時にのみ -1 を渡すことができます．

参照: multiply,add,subtract

◆ eigen()

CV_EXPORTS_W bool cv::eigen	(	InputArray	src,
		OutputArray	eigenvalues,
		OutputArray	eigenvectors = `noArray()`
	)

対称行列の固有値と固有ベクトルを計算します．

この関数はcv::eigenは，対称行列 src の固有値のみ，あるいは固有値と固有ベクトルを計算します．

src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()

覚え書き: を使用します。cv::eigenNonSymmetric非対称行列の実在する固有値と固有ベクトルを計算します．

引数

src	CV_32FC1 または CV_64FC1 型の入力行列．サイズは正方で，対称でなければいけません（ src ^T^ == src ）．
eigenvalues	src と同じ型の固有値の出力ベクトル．固有値は降順に格納されます．
eigenvectors	src と同じサイズ，同じ型の固有ベクトルの出力行列．固有ベクトルは，対応する固有値と同じ順番で，後続の行列の行として保存されます．

参照: eigenNonSymmetric,completeSymm,PCA

◆ eigenNonSymmetric()

CV_EXPORTS_W void cv::eigenNonSymmetric	(	InputArray	src,
		OutputArray	eigenvalues,
		OutputArray	eigenvectors
	)

非対称行列の固有値と固有ベクトルを求めます（実数の固有値のみ）．

覚え書き: 実数の固有値を仮定します。

この関数は，正方行列 src の固有値と固有ベクトル（オプション）を求めます．

src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()

引数

src	入力行列（CV_32FC1 または CV_64FC1 型）．
eigenvalues	固有値の出力ベクトル（型は src と同じです）．
eigenvectors	固有ベクトルの出力行列（型は src と同じです）．固有ベクトルは，対応する固有値と同じ順番で，後続の行列の行として保存されます．

参照: eigen

◆ exp()

CV_EXPORTS_W void cv::exp	(	InputArray	src,
		OutputArray	dst
	)

配列の各要素の指数を求めます．

この関数はcv::expは，入力配列の各要素の指数を計算します．

$\texttt{dst} [I] = e^{ src(I) }$

最大の相対誤差は，単精度入力では約7e-6，倍精度入力では1e-10未満です．現在，この関数は，非正規化された値をゼロに変換して出力します．特殊な値（NaN，Inf）は扱いません。

引数

src	入力配列．
dst	src と同じサイズ・タイプの配列を出力します。

参照: log,cartToPolar,polarToCart,phase,pow,sqrt,magnitude

◆ extractChannel()

CV_EXPORTS_W void cv::extractChannel	(	InputArray	src,
		OutputArray	dst,
		int	coi
	)

src から 1 つのチャンネルを抽出します（ coi は 0 ベースのインデックスです）。

引数

src	入力配列
dst	出力配列
coi	抽出するチャンネルのインデックス

参照: mixChannels,split

◆ findNonZero()

CV_EXPORTS_W void cv::findNonZero	(	InputArray	src,
		OutputArray	idx
	)

0 ではないピクセルの位置のリストを返します

バイナリ行列が与えられた場合（おそらく，次のような処理から返されますthreshold(),compare()のような演算から返されたものと思われます），非ゼロのインデックスのすべてをcv::Matまたは std::vector<cv::Point> (x,y) 例えば，以下のようになります．

cv::Mat
binaryImage;
// input, binary image

cv::Mat
locations;
// output, locations of non-zero pixels

cv::findNonZero(binaryImage, locations);


// access pixel coordinates

Point
pnt = locations.at<Point>(i);

または

cv::Mat
binaryImage;
// input, binary image
vector<Point> locations;
// output, locations of non-zero pixels

cv::findNonZero(binaryImage, locations);


// access pixel coordinates

Point
pnt = locations[i];

引数

src	シングルチャンネル配列
idx	出力配列で，型はcv::Matまたは std::vector<Point> であり，入力配列中の 0 ではないインデックスに対応します．

◆ flip()

CV_EXPORTS_W void cv::flip	(	InputArray	src,
		OutputArray	dst,
		int	flipCode
	)

2次元配列を，垂直，水平，または両軸で反転させます．

この関数はcv::flipは，3つの異なる方法のうちの1つで配列を反転させます（行と列のインデックスは0ベースです）．

$\texttt{dst} _{ij} = \left\{ \begin{array}{l l} \texttt{src} _{\texttt{src.rows}-i-1,j} & if\; \texttt{flipCode} = 0 \\ \texttt{src} _{i, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} > 0 \\ \texttt{src} _{ \texttt{src.rows} -i-1, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} < 0 \\ \end{array} \right.$

この関数の使用例としては，以下のようなものがあります．画像を垂直方向に反転させ（flipCode == 0）、画像の左上と左下の原点を切り替える。Microsoft Windows*での動画処理でよく見られる操作です。垂直軸方向の対称性を確認するために、水平方向に反転させた後、水平方向にシフトさせ、差分の絶対値を計算する（flipCode > 0）。水平・垂直方向に同時に反転させ、その後シフトと絶対値の差を計算して中心軸の対称性を確認する（flipCode < 0）。点配列の順序を反転させる（flipCode > 0 または flipCode == 0）．

引数

src	入力配列．
dst	src と同じサイズ・タイプの配列を出力します。
flipCode	配列の反転方法を指定するフラグ．0はX軸を中心に反転し，正の値（例えば，1）はY軸を中心に反転することを意味する．負の値（例えば，-1）は，両軸を中心に反転することを意味します。

参照: transpose,repeat,completeSymm

◆ gemm()

CV_EXPORTS_W void cv::gemm	(	InputArray	src1,
		InputArray	src2,
		double	alpha,
		InputArray	src3,
		double	beta,
		OutputArray	dst,
		int	flags = `0`
	)

一般化された行列の乗算を行います。

この関数はcv::gemmBLASレベル3のgemm関数と同様に、一般化された行列の乗算を行います。例えば、以下のようになります。gemm(src1, src2, alpha, src3, beta, dst, GEMM_1_T + GEMM_3_T)は次のようになります。

$\texttt{dst} = \texttt{alpha} \cdot \texttt{src1} ^T \cdot \texttt{src2} + \texttt{beta} \cdot \texttt{src3} ^T$

複素数（2チャンネル）のデータの場合，複素数の行列乗算を行います．

この関数は，行列式に置き換えることができます．例えば，上記の呼び出しは次のように置き換えることができます．

dst = alpha*src1.t()*src2 + beta*src3.t();

引数

src1	実数(CV_32FC1, CV_64FC1) または複素数(CV_32FC2, CV_64FC2) である入力行列を乗算した1番目の行列．
src2	src1 と同じ型の，乗算される2番目の入力行列．
alpha	行列の積の重み．
src3	src1 と src2 と同じ型の，行列積に追加されるオプションの 3 番目のデルタ行列．
beta	src3 の重み．
dst	出力行列．入力行列と同じ型で，適切なサイズの行列．
flags	演算フラグ (cv::GemmFlags)

参照: mulTransposed,transform

◆ getOptimalDFTSize()

CV_EXPORTS_W int cv::getOptimalDFTSize ( int vecsize )

与えられたベクトルサイズに対して，最適な DFT サイズを返します．

DFT の性能は，ベクトルサイズの単調な関数ではありません．したがって，2つの配列の畳み込みを計算したり，配列のスペクトル分析を行ったりする場合は，通常，入力データをゼロで埋めて，元の配列よりも高速に変換できる少し大きな配列を得ることが理にかなっています．サイズが2の累乗（2，4，8，16，32，...）である配列は，最も高速に処理できます．ただし，サイズが2の累乗，3の累乗，5の累乗である配列（例えば，300 = 5*5*3*2*2）も非常に効率的に処理されます．

この関数はcv::getOptimalDFTSizeは，サイズNのベクトルのDFTを効率的に処理できるような，vecsize以上の最小の数Nを返します．現在の実装では，N = 2 ^p^ * 3 ^q^ * 5 ^r^ for some integer p, q, r となっています。

この関数は， vecsize が大きすぎる場合（INT_MAX に非常に近い場合），負の値を返します．

この関数は，DCT変換に最適なベクトルサイズを推定するために直接利用することはできませんが（現在のDCT実装は，偶数サイズのベクトルしかサポートしていないので）， getOptimalDFTSize((vecsize+1)/2)*2 のように簡単に処理することができます．

引数

vecsize ベクトルサイズを指定します。

参照: dft,dct,idft,idct,mulSpectrums

◆ hconcat() [1/3]

CV_EXPORTS void cv::hconcat	(	const Mat *	src,
		size_t	nsrc,
		OutputArray	dst
	)

与えられた行列に対して，水平方向の連結処理を行います．

この関数は，2つ以上の（同じ数の）行列を水平方向に連結します。cv::Mat行数が同じ）行列を水平連結します。

cv::Mat
matArray[] = {
cv::Mat(4, 1, CV_8UC1,
cv::Scalar(1)),

cv::Mat(4, 1, CV_8UC1,
cv::Scalar(2)),

cv::Mat(4, 1, CV_8UC1,
cv::Scalar(3)),};


cv::Mat
out;

cv::hconcat( matArray, 3, out );

//out:

//[1, 2, 3;

// 1, 2, 3;

// 1, 2, 3;

// 1, 2, 3]

引数

src	入力行列の配列またはベクトル．すべての行列は，同じ行数，同じ深さでなければいけません．
nsrc	src に含まれる行列の数．
dst	出力配列．src と同じ行数，同じ深さ，そして src の col の合計値を持ちます．

参照: cv::vconcat(const Mat*, size_t, OutputArray),; cv::vconcat(InputArrayOfArrays, OutputArray)および; cv::vconcat(InputArray, InputArray, OutputArray)

◆ hconcat() [2/3]

CV_EXPORTS void cv::hconcat	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst
	)

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

cv::Mat_<float>
A = (cv::Mat_<float>(3, 2) << 1, 4,

2, 5,

3, 6);

cv::Mat_<float>
B = (cv::Mat_<float>(3, 2) << 7, 10,

8, 11,

9, 12);

cv::Mat
C;

cv::hconcat(A, B, C);

//C:

//[1, 4, 7, 10;

// 2, 5, 8, 11;

// 3, 6, 9, 12]

引数

src1	水平方向の連結が考慮される 1 番目の入力配列．
src2	水平方向に連結されることが考慮される 2 番目の入力配列．
dst	出力配列．src1 と src2 と同じ行数と深さ，そして src1 と src2 の col の合計値を持ちます．

◆ hconcat() [3/3]

CV_EXPORTS_W void cv::hconcat	(	InputArrayOfArrays	src,
		OutputArray	dst
	)

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

std::vector<cv::Mat> matrices = {
cv::Mat(4, 1, CV_8UC1,
cv::Scalar(1)),

cv::Mat(4, 1, CV_8UC1,
cv::Scalar(2)),

cv::Mat(4, 1, CV_8UC1,
cv::Scalar(3)),};


cv::Mat
out;

cv::hconcat( matrices, out );

//out:

//[1, 2, 3;

// 1, 2, 3;

// 1, 2, 3;

// 1, 2, 3]

引数

src	入力行列の配列またはベクトル．すべての行列は，同じ行数，同じ深さでなければいけません．
dst	出力配列．src と同じ行数と深さを持ち， src の col の合計値と同じ深さを持ちます．

◆ idct()

CV_EXPORTS_W void cv::idct	(	InputArray	src,
		OutputArray	dst,
		int	flags = `0`
	)

1次元あるいは2次元配列の離散コサイン変換の逆変換を求めます．

idct(src, dst, flags) は， dct(src, dst, flags | DCT_INVERSE) と同等です．

引数

src	入力浮動小数点型シングルチャンネル配列．
dst	src と同じサイズ・タイプの配列を出力します。
flags	操作フラグ．

参照: dct,dft,idft,getOptimalDFTSize

◆ idft()

CV_EXPORTS_W void cv::idft	(	InputArray	src,
		OutputArray	dst,
		int	flags = `0`,
		int	nonzeroRows = `0`
	)

1次元あるいは2次元の配列に対して，離散フーリエ変換の逆変換を行います．

idft(src, dst, flags) は， dft(src, dst, flags |DFT_INVERSE) .

覚え書き: dft と idft のいずれも，デフォルトでは結果をスケーリングしません．そのため，dft または idft のいずれかに次のように渡す必要がありますDFT_SCALEを明示的に dft または idft のいずれかに渡して，これらの変換を相互に逆にする必要があります．

参照: dft,dct,idct,mulSpectrums,getOptimalDFTSize

引数

src	入力浮動小数点型の実数あるいは複素数の配列．
dst	出力配列．そのサイズと型は，フラグに依存します．
flags	処理フラグ（ dft および idft を参照してください）．DftFlags).
nonzeroRows	処理するdst行の数．残りの行は，未定義の内容を持ちます（dftの説明にある畳み込みサンプルを参照してください）．

◆ inRange()

CV_EXPORTS_W void cv::inRange	(	InputArray	src,
		InputArray	lowerb,
		InputArray	upperb,
		OutputArray	dst
	)

配列の要素が，他の2つの配列の要素の間にあるかどうかをチェックします．

この関数は，次のようにして範囲をチェックします．

シングルチャンネルの入力配列の各要素に対して．
$\texttt{dst} (I)= \texttt{lowerb} (I)_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb} (I)_0$
2チャンネル配列の場合．
$\texttt{dst} (I)= \texttt{lowerb} (I)_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb} (I)_0 \land \texttt{lowerb} (I)_1 \leq \texttt{src} (I)_1 \leq \texttt{upperb} (I)_1$
といった具合です．

つまり， src (I) が指定された 1D, 2D, 3D, ... のボックス内にあれば dst (I) は 255（全てのビットが 1）にセットされ，そうでなければ 0 にセットされます．

なお，下側境界線や上側境界線のパラメータがスカラの場合は，上記の式における lowerb と upperb のインデックス（I）を省略します．

引数

src	1番目の入力配列．
lowerb	下側境界線を含む配列またはスカラー
upperb	包括的な上限値を持つ配列，またはスカラ．
dst	src と同じサイズで， CV_8U 型の出力配列．

◆ insertChannel()

CV_EXPORTS_W void cv::insertChannel	(	InputArray	src,
		InputOutputArray	dst,
		int	coi
	)

dst に1つのチャンネルを挿入します（ coi は 0 から始まるインデックス）．

引数

src	入力配列
dst	出力配列
coi	挿入するチャンネルのインデックス．

参照: mixChannels,merge

◆ invert()

CV_EXPORTS_W double cv::invert	(	InputArray	src,
		OutputArray	dst,
		int	flags = `DECOMP_LU`
	)

行列の逆行列，あるいは擬似逆行列を求めます．

この関数はcv::invertは，行列 src を逆にして，その結果を dst に格納します．行列 src が特異点または非正方である場合，この関数は， norm(src*dst - I) が最小になるように擬似逆行列（dst 行列）を求めます（I は単位行列）．

メソッドの場合はDECOMP_LUメソッドの場合，逆行列の計算に成功した場合は 0 以外の値を返し， src が特異な場合は 0 を返します．

メソッドの場合はDECOMP_SVDメソッドの場合，この関数は src の条件数の逆数（最小の特異値と最大の特異値の比）を返し， src が特異な場合は 0 を返します．このSVDメソッドは， src が特異な場合，擬似逆行列を計算します．

と同様にDECOMP_LUこのメソッドはDECOMP_CHOLESKYは，対称かつ正定値であるべき非特異な正方行列に対してのみ動作します．この場合，この関数は反転した行列を dst に格納し，0 ではない値を返します．そうでない場合は，0 を返します。

引数

src	入力浮動小数点型の M x N 行列．
dst	src と同じ型で，サイズが N x M の行列を出力します．
flags	反転法 (cv::DecompTypes)

参照: solve,SVD

◆ log()

CV_EXPORTS_W void cv::log	(	InputArray	src,
		OutputArray	dst
	)

配列の各要素の自然対数を求めます．

この関数はcv::logは，入力配列の各要素の自然対数を計算します．

$\texttt{dst} (I) = \log (\texttt{src}(I))$

ゼロ，負，特殊な値（NaN, Inf）に対する出力は不定です．

引数

src	入力配列．
dst	src と同じサイズ，同じ型の出力配列．

参照: exp,cartToPolar,polarToCart,phase,pow,sqrt,magnitude

◆ LUT()

CV_EXPORTS_W void cv::LUT	(	InputArray	src,
		InputArray	lut,
		OutputArray	dst
	)

LUT ：配列のルックアップテーブル変換を行います。

関数 LUT は，ルックアップテーブルの値で出力配列を埋めます。エントリのインデックスは，入力配列から取得します。つまり，この関数は src の各要素を以下のように処理します．

$\texttt{dst} (I) \leftarrow \texttt{lut(src(I) + d)}$

ここで

$d = \fork{0}{if \‍(\texttt{src}\‍) has depth \‍(\texttt{CV_8U}\‍)}{128}{if \‍(\texttt{src}\‍) has depth \‍(\texttt{CV_8S}\‍)}$

引数

src	8 ビット要素の入力配列．
lut	256 個の要素を持つルックアップテーブル．マルチチャンネルの入力配列の場合，テーブルはシングルチャンネル（この場合，すべてのチャンネルに同じテーブルが用いられます）か，入力配列と同じ数のチャンネルを持つ必要があります．
dst	src と同じサイズ，同じチャンネル数，そして lut と同じビット深度を持つ出力配列．

参照: convertScaleAbs,Mat::convertTo

◆ magnitude()

CV_EXPORTS_W void cv::magnitude	(	InputArray	x,
		InputArray	y,
		OutputArray	magnitude
	)

2次元ベクトルの大きさを計算します．

この関数はcv::magnitudex, y 配列の対応する要素から形成される 2 次元ベクトルの大きさを計算します．

$\texttt{dst} (I) = \sqrt{\texttt{x}(I)^2 + \texttt{y}(I)^2}$

引数

x	ベクトルのx座標の浮動小数点型配列．
y	ベクトルの y 座標を表す，浮動小数点型の配列（x と同じサイズでなければいけません）．
magnitude	x と同じサイズ，同じ型の出力配列．

参照: cartToPolar,polarToCart,phase,sqrt

◆ Mahalanobis()

CV_EXPORTS_W double cv::Mahalanobis	(	InputArray	v1,
		InputArray	v2,
		InputArray	icovar
	)

2 つのベクトル間のマハラノビス距離を計算します．

この関数はcv::Mahalanobisは，2 つのベクトル間の加重距離を計算して返します．

$d( \texttt{vec1} , \texttt{vec2} )= \sqrt{\sum_{i,j}{\texttt{icovar(i,j)}\cdot(\texttt{vec1}(I)-\texttt{vec2}(I))\cdot(\texttt{vec1(j)}-\texttt{vec2(j)})} }$

共分散行列の計算にはcalcCovarMatrix関数を使って共分散行列を計算し，invert 関数を使って反転させることができます（最も正確にはDECOMP_SVDメソッドを使用するのが最も正確です）．

引数

v1	第1の1次元入力ベクトル
v2	2番目の1次元入力ベクトル
icovar	逆共分散行列。

◆ max() [1/3]

CV_EXPORTS void cv::max	(	const Mat &	src1,
		const Mat &	src2,
		Mat &	dst
	)

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。 const _Tp& std::min(const _Tp&, const _Tp&, _Compare)との衝突を避けるために必要です。

◆ max() [2/3]

CV_EXPORTS void cv::max	(	const UMat &	src1,
		const UMat &	src2,
		UMat &	dst
	)

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。 const _Tp& std::min(const _Tp&, const _Tp&, _Compare)との衝突を避けるために必要です。

◆ max() [3/3]

CV_EXPORTS_W void cv::max	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst
	)

2つの配列、または配列とスカラの要素ごとの最大値を計算します。

この関数はcv::maxは、2つの配列の要素ごとの最大値を計算します。

$\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{src2} (I))$

または配列とスカラ。

$\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{value} )$

引数

src1	1番目の入力配列．
src2	src1 と同じサイズ，同じ型の 2 番目の入力配列．
dst	src1 と同じサイズ，同じ型の出力配列．

参照: min,compare,inRange,minMaxLoc,MatrixExpressions

◆ mean()

CV_EXPORTS_W Scalar cv::mean	(	InputArray	src,
		InputArray	mask = `noArray()`
	)

配列の要素の平均（mean）を求めます．

関数 cv::mean は，各チャンネル毎に配列要素の平均値 M を計算し，それを返します．

$\begin{array}{l} N = \sum _{I: \; \texttt{mask} (I) \ne 0} 1 \\ M_c = \left ( \sum _{I: \; \texttt{mask} (I) \ne 0}{ \texttt{mtx} (I)_c} \right )/N \end{array}$

すべてのマスク要素が 0 の場合，この関数は Scalar::all(0) を返します．

引数

src	入力配列は，1から4までのチャンネルを持ち，その結果を次のように格納します．Scalar_.
mask	任意の演算マスク．

参照: countNonZero,meanStdDev,norm,minMaxLoc

◆ meanStdDev()

CV_EXPORTS_W void cv::meanStdDev	(	InputArray	src,
		OutputArray	mean,
		OutputArray	stddev,
		InputArray	mask = `noArray()`
	)

配列要素の平均値と標準偏差を計算します．

この関数はcv::meanStdDevScalar::all(0) は，各チャンネルごとに配列要素の平均値と標準偏差 M を計算し，それを出力パラメータで返します．

$\begin{array}{l} N = \sum _{I, \texttt{mask} (I) \ne 0} 1 \\ \texttt{mean} _c = \frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \texttt{src} (I)_c}{N} \\ \texttt{stddev} _c = \sqrt{\frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \left ( \texttt{src} (I)_c - \texttt{mean} _c \right )^2}{N}} \end{array}$

すべてのマスク要素が「0」の場合，mean=stddev=Scalar::all(0)が返されます．

覚え書き: 計算された標準偏差は，完全な正規化共分散行列の対角線に過ぎません．完全な行列が必要な場合は，マルチチャンネル配列 M x N をシングルチャンネル配列 M*N x mtx.channels() に変換し（行列が連続している場合のみ可能），その行列を calcCovarMatrix に渡します．

引数

src	入力配列には，1 から 4 までのチャンネルが必要です．これにより，結果をScalar_'s.
mean	出力パラメータ：計算された平均値．
stddev	出力パラメータ：計算された標準偏差．
mask	任意の演算マスク．

参照: countNonZeroの平均値です．norm,minMaxLoc,calcCovarMatrix

◆ merge() [1/2]

CV_EXPORTS void cv::merge	(	const Mat *	mv,
		size_t	count,
		OutputArray	dst
	)

複数のシングルチャンネル配列から，1つのマルチチャンネル配列を作成します．

この関数はcv::mergeは，複数の配列をマージして1つのマルチチャンネル配列を作ります．つまり，出力配列の各要素は，入力配列の要素を結合したものになります．ここで i 番目の入力配列の要素は，mv[i].channels()要素のベクトルとして扱われます．

この関数はcv::splitは，その逆の操作を行います．もし，他の高度な方法でチャンネルをシャッフルする必要があるならば，次のようにします．cv::mixChannels.

次の例では，3つのシングルチャンネル行列を1つの3チャンネル行列に結合する方法を示します．

引数

mv	マージされる行列の入力配列．mv に含まれるすべての行列は，同じサイズ，同じビット深度でなければいけません．
count	mv がプレーンな C 言語の配列の場合は，入力行列の数；0 以上でなければいけません．
dst	mv[0]と同じサイズ，同じビット深度の出力配列；チャンネル数は，パラメータ count と等しくなります．

参照: mixChannels,split,Mat::reshape

◆ merge() [2/2]

CV_EXPORTS_W void cv::merge	(	InputArrayOfArrays	mv,
		OutputArray	dst
	)

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

引数

mv	結合される行列の入力ベクトル．mv のすべての行列は，同じサイズ，同じビット深度でなければいけません．
dst	mv[0] と同じサイズ，同じビット深度の出力配列．チャンネル数は，行列配列のチャンネル数の合計になります．

◆ min() [1/3]

CV_EXPORTS void cv::min	(	const Mat &	src1,
		const Mat &	src2,
		Mat &	dst
	)

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。 const _Tp& std::min(const _Tp&, const _Tp&, _Compare)との衝突を避けるために必要です。

◆ min() [2/3]

CV_EXPORTS void cv::min	(	const UMat &	src1,
		const UMat &	src2,
		UMat &	dst
	)

これはオーバーロードされたメンバ関数です。利便性のために用意されています。元の関数との違いは引き数のみです。 const _Tp& std::min(const _Tp&, const _Tp&, _Compare)との衝突を避けるために必要です。

◆ min() [3/3]

CV_EXPORTS_W void cv::min	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst
	)

2つの配列，あるいは配列とスカラの要素毎の最小値を求めます．

この関数はcv::minは，2つの配列の要素毎の最小値を求めます．

$\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{src2} (I))$

または配列とスカラ。

$\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{value} )$

引数

src1	1番目の入力配列．
src2	src1 と同じサイズ，同じ型の 2 番目の入力配列．
dst	src1 と同じサイズ，同じ型の出力配列．

参照: max,compare,inRange,minMaxLoc

◆ minMaxIdx()

CV_EXPORTS void cv::minMaxIdx	(	InputArray	src,
		double *	minVal,
		double *	maxVal = `0`,
		int *	minIdx = `0`,
		int *	maxIdx = `0`,
		InputArray	mask = `noArray()`
	)

配列のグローバルな最小値と最大値を求める

この関数はcv::minMaxIdx配列の要素の最小値と最大値，およびそれらの位置を求めます．極値は，配列全体，あるいは mask が空の配列でない場合は，指定された配列領域内で探索されます．この関数は，マルチチャンネル配列では動作しません．すべてのチャンネルで最小値や最大値を見つける必要がある場合は，まずMat::reshapeを利用して，配列をシングルチャンネルとして解釈し直します．あるいは， extractImageCOI や mixChannels ， split などを用いて，特定のチャンネルを抽出します．疎な行列の場合，0 ではない要素のみから最小値が求められます．

覚え書き: minIdx が NULL ではない場合，たとえ src が1行や1列の行列であっても，（ maxIdx と同様に）最低でも2つの要素を持たなければいけません．OpenCVでは（MATLABに倣って），各配列は少なくとも2次元です．つまり，1列の行列は Mx1 行列（したがって，minIdx/maxIdx は (i1,0)/(i2,0) となります），1列の行列は 1xN 行列（したがって，minIdx/maxIdx は (0,j1)/(0,j2) となります）．

引数

src	入力シングルチャンネル配列．
minVal	返される最小値へのポインタ; 必要なければ NULL が使われます．
maxVal	返される最大値へのポインタ；必要ない場合は NULL が使われます．
minIdx	返される最小値の位置へのポインタ（nDの場合）．必要なければ，NULLが用いられます．それ以外の場合は， src.dims 要素の配列を指し，各次元の最小要素の座標が順次格納されます．
maxIdx	返される最大値の位置へのポインタ（ nD の場合）．必要ない場合は，NULLが用いられます．
mask	指定された配列領域

◆ minMaxLoc() [1/2]

CV_EXPORTS void cv::minMaxLoc	(	const SparseMat &	a,
		double *	minVal,
		double *	maxVal,
		int *	minIdx = `0`,
		int *	maxIdx = `0`
	)

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

引数

a	入力シングルチャンネル配列．
minVal	返される最小値へのポインタ; 必要なければ NULL が使われます．
maxVal	返される最大値へのポインタ；必要ない場合は NULL が使われます．
minIdx	返される最小値の位置へのポインタ（nDの場合）．必要なければ，NULLが用いられます．それ以外の場合は， src.dims 要素の配列を指し，各次元の最小要素の座標が順次格納されます．
maxIdx	返される最大値の位置へのポインタ（ nD の場合）．必要ない場合は，NULLが用いられます．

◆ minMaxLoc() [2/2]

CV_EXPORTS_W void cv::minMaxLoc	(	InputArray	src,
		CV_OUT double *	minVal,
		CV_OUT double *	maxVal = `0`,
		CV_OUT Point *	minLoc = `0`,
		CV_OUT Point *	maxLoc = `0`,
		InputArray	mask = `noArray()`
	)

配列のグローバルな最小値と最大値を求めます．

この関数はcv::minMaxLocは，要素の最小値と最大値，およびそれらの位置を求めます．極値は，配列全体，あるいは mask が空の配列でない場合は，指定された配列領域内で探索されます．

この関数は，マルチチャンネル配列では動作しません．すべてのチャンネルで最小または最大の要素を見つける必要がある場合は，まずMat::reshapeを利用して，配列をシングルチャンネルとして再解釈します．あるいは， extractImageCOI や mixChannels ，split などを用いて，特定のチャンネルだけを取り出すこともできます．

引数

src	入力シングルチャンネル配列．
minVal	返される最小値へのポインタ; 必要なければ NULL が使われます．
maxVal	返される最大値へのポインタ；必要ない場合は NULL が使われます．
minLoc	2D の場合は，最小値を示すポインタ．
maxLoc	最大値を示す位置へのポインタ（2D の場合）；必要なければ NULL を使用してください．
mask	部分配列を選択するためのオプションのマスク．

参照: max,min,compare,inRangeextractImageCOI を参照してください．mixChannels,split,Mat::reshape

◆ mixChannels() [1/3]

CV_EXPORTS void cv::mixChannels	(	const Mat *	src,
		size_t	nsrcs,
		Mat *	dst,
		size_t	ndsts,
		const int *	fromTo,
		size_t	npairs
	)

入力配列の指定されたチャンネルを，出力配列の指定されたチャンネルにコピーします．

この関数はcv::mixChannelsは，画像チャンネルをシャッフルするための高度な機構を提供します．

cv::split,cv::merge,cv::extractChannel,cv::insertChannelや，いくつかの形式のcv::cvtColorの部分的なケースです．cv::mixChannels.

以下の例では，4 チャンネルの BGRA 画像を，3 チャンネルの BGR（B と R のチャンネルを入れ替えたもの）と別のアルファチャンネル画像に分割しています．

Mat
bgra( 100, 100, CV_8UC4,
Scalar(255,0,0,255) );

Mat
bgr( bgra.rows, bgra.cols, CV_8UC3 );

Mat
alpha( bgra.rows, bgra.cols, CV_8UC1 );


// forming an array of matrices is a quite efficient operation,

// because the matrix data is not copied, only the headers

Mat
out[] = { bgr, alpha };

// bgra[0] -> bgr[2], bgra[1] -> bgr[1],

// bgra[2] -> bgr[0], bgra[3] -> alpha[0]

int
from_to[] = { 0,2, 1,1, 2,0, 3,3 };

mixChannels( &bgra, 1, out, 2, from_to, 4 );

覚え書き: OpenCV の他の多くの新スタイルの C++ 関数とは異なり（導入部とMat::create),cv::mixChannelsは，関数を呼び出す前に出力配列をあらかじめ確保しておく必要があります．

引数

src	すべての行列は，同じサイズ，同じビット深度でなければいけません．
nsrcs	の行列の数．`src`.
dst	出力配列，または行列のベクトル．を割り当てる必要があります．サイズと深さが同じでなければなりません．`src[0]`.
ndsts	の行列の数．`dst`.
fromTo	どのチャンネルをどこにコピーするかを指定する，インデックスペアの配列． fromTo[k2]は，src の入力チャンネルを示す0基準のインデックス， fromTo[k2+1]は，dst の出力チャンネルを示すインデックスです．連続したチャンネル番号が用いられます： 1 番目の入力画像チャンネルは，0 から src[0] までのインデックスで表されます． channels()-1 で表されます．また，2番目の入力画像チャンネルは， src[0].channels() から src[0].channels() + src[1].channels()-1 までのインデックスで表されます．
npairs	のインデックスペアの数`fromTo`.

参照: split,merge,extractChannel,insertChannel,cvtColor

◆ mixChannels() [2/3]

CV_EXPORTS void cv::mixChannels	(	InputArrayOfArrays	src,
		InputOutputArrayOfArrays	dst,
		const int *	fromTo,
		size_t	npairs
	)

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

引数

src	すべての行列は，同じサイズ，同じビット深度でなければいけません．
dst	出力配列，または行列のベクトル．を割り当てる必要があります．これらのインデックスペアのサイズとビット深度は， src[0] と同じでなければいけません．
fromTo	どのチャンネルをどこにコピーするかを指定する，インデックスペアの配列． fromTo[k2]は，src の入力チャンネルを示す0基準のインデックス， fromTo[k2+1]は，dst の出力チャンネルを示すインデックスです．連続したチャンネル番号が用いられます： 1 番目の入力画像チャンネルは，0 から src[0] までのインデックスで表されます． channels()-1 で表されます．また，2番目の入力画像チャンネルは， src[0].channels() から src[0].channels() + src[1].channels()-1 までのインデックスで表されます．
npairs	fromTo のインデックスペアの数．

◆ mixChannels() [3/3]

CV_EXPORTS_W void cv::mixChannels	(	InputArrayOfArrays	src,
		InputOutputArrayOfArrays	dst,
		const std::vector< int > &	fromTo
	)

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

引数

src	すべての行列は，同じサイズ，同じビット深度でなければいけません．
dst	出力配列，または行列のベクトル．を割り当てる必要があります．これらのインデックスペアのサイズとビット深度は， src[0] と同じでなければいけません．
fromTo	どのチャンネルをどこにコピーするかを指定する，インデックスペアの配列． fromTo[k2]は，src の入力チャンネルを示す0基準のインデックス， fromTo[k2+1]は，dst の出力チャンネルを示すインデックスです．連続したチャンネル番号が用いられます： 1 番目の入力画像チャンネルは，0 から src[0] までのインデックスで表されます． channels()-1 で表されます．また，2番目の入力画像チャンネルは， src[0].channels() から src[0].channels() + src[1].channels()-1 までのインデックスで表されます．

◆ mulSpectrums()

CV_EXPORTS_W void cv::mulSpectrums	(	InputArray	a,
		InputArray	b,
		OutputArray	c,
		int	flags,
		bool	conjB = `false`
	)

2つのフーリエ・スペクトルの要素毎の乗算を行います．

この関数はcv::mulSpectrumsこの関数は，実数または複素数のフーリエ変換の結果である，CCSパックされた2つの行列または複素数の行列の要素毎の乗算を行います．

この関数は， dft や idft と共に，2つの配列の畳み込み（pass conjB=false）や相関（pass conjB=true）を高速に計算するために利用されます．配列が複素数の場合，単純に（要素毎に）2番目の配列要素の共役を掛け合わせます．配列が実数の場合は，CCSパックされていると仮定されます（詳細は dft を参照してください）．

引数

a	1番目の入力配列．
b	src1 と同じサイズ，同じ型の 2 番目の入力配列．
c	src1 と同じサイズ，同じ型の出力配列．
flags	操作フラグ．現在，唯一サポートされているフラグはcv::DFT_ROWSこれは， src1 と src2 の各行が独立した1次元フーリエ変換であることを表します．もしこのフラグを使いたくない場合は，単に`0`を値として追加してください。
conjB	2番目の入力配列を，乗算の前に共役にするか（true），しないか（false）を指定するオプションフラグ．

◆ multiply()

CV_EXPORTS_W void cv::multiply	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		double	scale = `1`,
		int	dtype = `-1`
	)

2つの配列の要素毎のスケーリングされた積を求めます．

関数 multiply は，2つの配列の要素毎の積を求めます．

$\texttt{dst} (I)= \texttt{saturate} ( \texttt{scale} \cdot \texttt{src1} (I) \cdot \texttt{src2} (I))$

また，この関数のMatrixExpressions-があります．参照Mat::mul.

要素毎ではない行列積については， gemm を参照してください．

覚え書き: 出力配列のビット深度が CV_32S の場合，Saturation は適用されません．また，オーバーフローが発生した場合は，不正な符号の結果が得られる可能性があります．

引数

src1	1番目の入力配列．
src2	src1 と同じサイズ，同じ型の 2 番目の入力配列．
dst	src1 と同じサイズ，同じ型の出力配列．
scale	オプションのスケールファクタ．
dtype	オプションで，出力配列の深さを指定します．

参照: add,subtract,divide,scaleAdd,addWeighted,accumulate,accumulateProduct,accumulateSquare,Mat::convertTo

◆ mulTransposed()

CV_EXPORTS_W void cv::mulTransposed	(	InputArray	src,
		OutputArray	dst,
		bool	aTa,
		InputArray	delta = `noArray()`,
		double	scale = `1`,
		int	dtype = `-1`
	)

行列とその転置行列の積を計算します．

この関数はcv::mulTransposedsrc とその転置行列の積を求めます．

$\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T ( \texttt{src} - \texttt{delta} )$

aTa=true の場合と

$\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) ( \texttt{src} - \texttt{delta} )^T$

それ以外の場合はこの関数は，共分散行列の計算に利用されます．デルタが 0 の場合は，B=A' の時に一般的な行列積 A*B の高速な代替手段として利用できます．

引数

src	入力シングルチャンネル行列．gemm とは異なり，この関数は浮動小数点数の行列だけでなく，積むこともできることに注意してください．
dst	出力正方行列．
aTa	乗算の順序を指定するフラグ．以下の説明を参照してください．
delta	オプションで，乗算の前に src から差し引かれる delta 行列．この行列が空の場合（ delta=noArray() ），ゼロであると見なされ，何も引かれません．また， src と同じサイズの場合は，単に減算されます．そうでない場合は，src 全体を覆うように「繰り返され」（ repeat を参照してください），その後に減算されます．デルタ行列が空ではない場合，そのタイプは，作成される出力行列のタイプと同じでなければいけません．以下の dtype パラメータの説明を参照してください．
scale	オプションである，行列の積に対するスケールファクタ．
dtype	オプションで，出力行列のタイプを指定します．これが負の値の場合，出力行列は src と同じ型になります．それ以外の場合は， type=CV_MAT_DEPTH(dtype) となり， CV_32F または CV_64F のどちらかになります．

参照: calcCovarMatrix,gemm,repeat,reduce

◆ norm() [1/3]

CV_EXPORTS double cv::norm	(	const SparseMat &	src,
		int	normType
	)

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

引数

src	1番目の入力配列．
normType	ノルムの型（以下を参照してくださいNormTypes).

◆ norm() [2/3]

CV_EXPORTS_W double cv::norm	(	InputArray	src1,
		InputArray	src2,
		int	normType = `NORM_L2`,
		InputArray	mask = `noArray()`
	)

絶対差分ノルムや相対差分ノルムを求めます．

このバージョンのcv::normは，配列 src1 と src2 の絶対差ノルムまたは相対差ノルムを計算します．計算するノルムの種類は，オプションの処理マスクを用いて指定します．NormTypes.

引数

src1	1番目の入力配列．
src2	src1 と同じサイズ，同じ型の 2 番目の入力配列．
normType	ノルムの型（以下を参照してくださいNormTypes).
mask	オプションの処理マスクで指定されます．これは， src1 と同じサイズで CV_8UC1 型でなければいけません．

◆ norm() [3/3]

CV_EXPORTS_W double cv::norm	(	InputArray	src1,
		int	normType = `NORM_L2`,
		InputArray	mask = `noArray()`
	)

配列の絶対値ノルムを計算します．

このバージョンのnormは， src1 の絶対値ノルムを計算します．計算するノルムの種類は，次のように指定しますNormTypes.

例として，1つの配列に対して，関数 $r(x)= \begin{pmatrix} x \\ 1-x \end{pmatrix}, x \in [-1;1]$ . という関数を考えます。 $L_{1}, L_{2}$ および $L_{\infty}$ のノルムは，サンプル値 $r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}$ のノルムは次のように計算されます．

$\begin{align*} \| r(-1) \|_{L_1} &= |-1| + |2| = 3 \\ \| r(-1) \|_{L_2} &= \sqrt{(-1)^{2} + (2)^{2}} = \sqrt{5} \\ \| r(-1) \|_{L_\infty} &= \max(|-1|,|2|) = 2 \end{align*}$

と $r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}$ 計算結果は

$\begin{align*} \| r(0.5) \|_{L_1} &= |0.5| + |0.5| = 1 \\ \| r(0.5) \|_{L_2} &= \sqrt{(0.5)^{2} + (0.5)^{2}} = \sqrt{0.5} \\ \| r(0.5) \|_{L_\infty} &= \max(|0.5|,|0.5|) = 0.5. \end{align*}$

次の図は，3つのノルム関数のすべての値を示しています． $\| r(x) \|_{L_1}, \| r(x) \|_{L_2}$ および $\| r(x) \|_{L_\infty}$ . 注目すべきは，ノルムが $L_{1}$ ノルムが上側を、そして $L_{\infty}$ 関数の例では，ノルムが上側，ノルムが下側の境界を形成していることが注目されます． $ r(x) $ . Graphs for the different norm functions from the above example

maskパラメータが指定され，それが空でない場合，ノルムは

normTypeが指定されていない場合はNORM_L2は，マスクで指定された領域に対してのみ計算されます．

マルチチャンネルの入力配列は，シングルチャンネルの配列として扱われ，すべてのチャンネルの結果が結合されます．

Hammingnorms は， CV_8U 深度分析配列でのみ計算されます．

引数

src1	1番目の入力配列．
normType	ノルムの型（以下を参照してくださいNormTypes).
mask	オプションの処理マスクで指定されます．これは， src1 と同じサイズで CV_8UC1 型でなければいけません．

◆ normalize() [1/2]

CV_EXPORTS void cv::normalize	(	const SparseMat &	src,
		SparseMat &	dst,
		double	alpha,
		int	normType
	)

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

引数

src	入力配列．
dst	src と同じサイズの出力配列．
alpha	正規化するためのノルム値，あるいは，範囲正規化を行う場合は範囲の下限値．
normType	正規化の種類（関連項目cv::NormTypes).

◆ normalize() [2/2]

CV_EXPORTS_W void cv::normalize	(	InputArray	src,
		InputOutputArray	dst,
		double	alpha = `1`,
		double	beta = `0`,
		int	norm_type = `NORM_L2`,
		int	dtype = `-1`,
		InputArray	mask = `noArray()`
	)

配列のノルムや値の範囲を正規化します．

この関数はcv::normalizenormalize は，入力配列要素を以下のようにスケーリング，シフトします

$\| \texttt{dst} \| _{L_p}= \texttt{alpha}$

(normType=NORM_INF, NORM_L1, NORM_L2 の場合は，それぞれ以下のようになります（ここで，p=Inf, 1 または 2）。

$\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}$

normType=NORM_MINMAXの場合（密な配列の場合のみ）。オプションのマスクは，正規化されるサブアレイを指定します。これは，副配列に対してノルムやmin-n-maxが計算され，その後，この副配列が正規化されるように修正されることを意味します。ノルムやミニマムを計算するためにマスクを使用するだけで，配列全体を修正したい場合は，normとMat::convertTo.

疎な行列の場合，0ではない値のみが分析され，変換されます．このため，疎な行列に対する範囲変換は，ゼロレベルをずらすことができるので，許されません。

いくつかの肯定的な例のデータで使用可能です。

vector<double> positiveData = { 2.0, 8.0, 10.0 };
vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax;

// Norm to probability (total count)

// sum(numbers) = 20.0

// 2.0      0.1     (2.0/20.0)

// 8.0      0.4     (8.0/20.0)

// 10.0     0.5     (10.0/20.0)

normalize(positiveData, normalizedData_l1, 1.0, 0.0,
NORM_L1);

// Norm to unit vector: ||positiveData|| = 1.0

// 2.0      0.15

// 8.0      0.62

// 10.0     0.77

normalize(positiveData, normalizedData_l2, 1.0, 0.0,
NORM_L2);

// Norm to max element

// 2.0      0.2     (2.0/10.0)

// 8.0      0.8     (8.0/10.0)

// 10.0     1.0     (10.0/10.0)

normalize(positiveData, normalizedData_inf, 1.0, 0.0,
NORM_INF);

// Norm to range [0.0;1.0]

// 2.0      0.0     (shift to left border)

// 8.0      0.75    (6.0/8.0)

// 10.0     1.0     (shift to right border)

normalize(positiveData, normalizedData_minmax, 1.0, 0.0,
NORM_MINMAX);

引数

src	入力配列．
dst	src と同じサイズの出力配列．
alpha	正規化するためのノルム値，あるいは，範囲正規化を行う場合は範囲の下限値．
beta	範囲正規化の場合は，範囲の上側の境界であり，ノルム正規化には使用されない．
norm_type	正規化の種類（関連項目cv::NormTypes).
dtype	負の値の場合，出力配列は src と同じ型になります．そうでない場合は， src と同じチャンネル数を持ち，ビット深度は =CV_MAT_DEPTH(dtype) となります．
mask	任意の演算マスク．

参照: norm,Mat::convertTo,SparseMat::convertTo

◆ patchNaNs()

CV_EXPORTS_W void cv::patchNaNs	(	InputOutputArray	a,
		double	val = `0`
	)

NaN を指定された数に変換します．

引数

a	入出力行列（CV_32F型）．
val	NaNsを変換する値

◆ PCABackProject()

CV_EXPORTS_W void cv::PCABackProject	(	InputArray	data,
		InputArray	mean,
		InputArray	eigenvectors,
		OutputArray	result
	)

ラップPCA::backProject

◆ PCACompute() [1/2]

CV_EXPORTS_W void cv::PCACompute	(	InputArray	data,
		InputOutputArray	mean,
		OutputArray	eigenvectors,
		double	retainedVariance
	)

ラップ PCA::operator()

◆ PCACompute() [2/2]

CV_EXPORTS_W void cv::PCACompute	(	InputArray	data,
		InputOutputArray	mean,
		OutputArray	eigenvectors,
		int	maxComponents = `0`
	)

ラップ PCA::operator()

◆ PCAProject()

CV_EXPORTS_W void cv::PCAProject	(	InputArray	data,
		InputArray	mean,
		InputArray	eigenvectors,
		OutputArray	result
	)

ラップPCA::project

◆ perspectiveTransform()

CV_EXPORTS_W void cv::perspectiveTransform	(	InputArray	src,
		OutputArray	dst,
		InputArray	m
	)

ベクトルの透視行列変換を行います．

この関数はcv::perspectiveTransformは， src の各要素を 2 次元または 3 次元のベクトルとして扱い，以下のように変換します．

$(x, y, z) \rightarrow (x'/w, y'/w, z'/w)$

ここで

$(x', y', z', w') = \texttt{mat} \cdot \begin{bmatrix} x & y & z & 1 \end{bmatrix}$

および

$w = \fork{w'}{if \‍(w' \ne 0\‍)}{\infty}{otherwise}$

ここでは，3D ベクトル変換の例を示します．2D ベクトル変換の場合，z 成分は省略されます．

覚え書き: この関数は，2D または 3D ベクトルの疎な集合を変換します．透視変換を用いて画像を変換したい場合は， warpPerspective を利用します．逆問題がある場合，つまり，対応する複数の点の組から最も確率の高い透視変換を求めたい場合は， getPerspectiveTransform や findHomography を利用できます．

引数

src	入力 2チャンネルまたは3チャンネルの浮動小数点型配列．各要素は，変換される2次元/3次元ベクトル．
dst	src と同じサイズ・タイプの配列を出力します。
m	3x3 または 4x4 の浮動小数点型変換行列．

参照: transform,warpPerspective,getPerspectiveTransform,findHomography

◆ phase()

CV_EXPORTS_W void cv::phase	(	InputArray	x,
		InputArray	y,
		OutputArray	angle,
		bool	angleInDegrees = `false`
	)

2次元ベクトルの回転角度を計算します．

この関数はcv::phasexとyの対応する要素から形成される各2Dベクトルの回転角度を計算します。

$\texttt{angle} (I) = \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))$

角度の推定精度は約0.3度です。なお，x(I)=y(I)=0のとき，対応する角度(I)は0になります。

引数

x	入力 2次元ベクトルのx座標の浮動小数点配列．
y	2次元ベクトルのy座標の入力配列．これは，xと同じサイズ，同じ型でなければいけません．
angle	x と同じサイズ，同じ型の，ベクトルの角度を表す出力配列．
angleInDegrees	この関数が真の場合，角度は度単位で計算され，そうでない場合はラジアン単位で計算されます．

◆ polarToCart()

CV_EXPORTS_W void cv::polarToCart	(	InputArray	magnitude,
		InputArray	angle,
		OutputArray	x,
		OutputArray	y,
		bool	angleInDegrees = `false`
	)

2次元ベクトルの大きさと角度から，そのx座標とy座標を求めます．

この関数はcv::polarToCartは，大きさと角度の対応する要素で表される各2次元ベクトルのデカルト座標を計算します．

$\begin{array}{l} \texttt{x} (I) = \texttt{magnitude} (I) \cos ( \texttt{angle} (I)) \\ \texttt{y} (I) = \texttt{magnitude} (I) \sin ( \texttt{angle} (I)) \\ \end{array}$

推定された座標の相対的な精度は，約 1e-6 です．

引数

magnitude	入力 2 次元ベクトルの大きさを表す，浮動小数点型の配列．これは，空の行列（=Mat()）でもよく，その場合，この関数はすべての大きさが =1 であると仮定します．
angle	入力 2次元ベクトルの角度を表す，浮動小数点型の配列．
x	angleと同じサイズ，同じ型の2次元ベクトルのx座標を表す出力配列．
y	2D ベクトルの y 座標の出力配列； angle と同じサイズ，同じ型です．
angleInDegrees	trueの場合，入力された角度は度単位で表され，そうでない場合はラジアン単位で表されます．

参照: cartToPolar,magnitude,phase,exp,log,pow,sqrt

◆ pow()

CV_EXPORTS_W void cv::pow	(	InputArray	src,
		double	power,
		OutputArray	dst
	)

配列の各要素をべき乗します．

この関数はcv::powは，入力配列の各要素をべき乗します．

$\texttt{dst} (I) = \fork{\texttt{src}(I)^{power}}{if \‍(\texttt{power}\‍) is integer}{|\texttt{src}(I)|^{power}}{otherwise}$

つまり，非整数のべき乗の指数に対しては，入力配列の要素の絶対値が使われます．ただし，いくつかの追加演算を行うことで，負の値に対する真の値を得ることができます．以下の例では，配列 src の 5 次根を計算しています．

Mat
mask = src < 0;

pow(src, 1./5, dst);

subtract(Scalar::all(0), dst, dst, mask);

0.5 や -0.5 といった整数値のような一部の累乗値に対しては，専用の高速アルゴリズムが用いられます．

特殊な値（NaN, Inf）は扱われません。

引数

src	入力配列．
power	パワーの指数
dst	src と同じサイズ・タイプの配列を出力します。

参照: sqrt,exp,log,cartToPolar,polarToCart

◆ PSNR()

CV_EXPORTS_W double cv::PSNR	(	InputArray	src1,
		InputArray	src2,
		double	R = `255.`
	)

画質指標であるPSNR（Peak Signal-to-Noise Ratio）を計算します。

この関数は，2つの入力配列 src1 と src2 の間の，デシベル（dB）単位で表されるピーク信号対雑音比（PSNR）を求めます．これらの配列は，同じ型でなければいけません．

PSNR は，以下のように計算されます．

$\texttt{PSNR} = 10 \cdot \log_{10}{\left( \frac{R^2}{MSE} \right) }$

ここで R は，深度の最大の整数値（例えば， CV_8U データの場合は 255 ），MSE は 2 つの配列間の平均2乗誤差です．

引数

src1	1番目の入力配列．
src2	src1 と同じサイズの 2 番目の入力配列．
R	最大のピクセル値（デフォルトでは 255）．

◆ randn()

CV_EXPORTS_W void cv::randn	(	InputOutputArray	dst,
		InputArray	mean,
		InputArray	stddev
	)

正規分布した乱数で配列を埋めます．

この関数はcv::randn行列 dst を，指定された平均ベクトルと標準偏差の行列を持つ正規分布乱数で埋めます．生成された乱数は，出力配列のデータ型の値域に合うようにクリップされます．

引数

dst	乱数の出力配列．この配列は，あらかじめ割り当てられており，1から4までのチャンネルを持つ必要があります．
mean	生成された乱数の平均値（期待値）．
stddev	生成された乱数の標準偏差：ベクトル（この場合，標準偏差の対角行列が想定されます）または正方行列のいずれかです．

参照: RNG,randu

◆ randShuffle()

CV_EXPORTS_W void cv::randShuffle	(	InputOutputArray	dst,
		double	iterFactor = `1.`,
		RNG *	rng = `0`
	)

配列の要素をランダムにシャッフルします．

この関数はcv::randShuffleは，指定された1次元配列の要素を無作為に選んで入れ替えるシャッフルを行います．このようなスワップ操作の回数は， dst.rows*dst.cols*iterFactor となります．

引数

dst	入力/出力数値の1次元配列.
iterFactor	ランダムな入れ替え操作の回数を決定するスケールファクター（詳細は後述）。
rng	シャッフルに使用される任意の乱数生成器．これが0の場合，代わりにRNG（）が使用されます．

参照: RNG,sort

◆ randu()

CV_EXPORTS_W void cv::randu	(	InputOutputArray	dst,
		InputArray	low,
		InputArray	high
	)

一様に分散した単一の乱数または乱数の配列を生成します。

この関数の非テンプレート版は，指定された範囲内の一様分布乱数で行列 dst を埋めます．

$\texttt{low} _c \leq \texttt{dst} (I)_c < \texttt{high} _c$

引数

dst	乱数の配列を出力します．この配列は，あらかじめ割り当てられている必要があります．
low	生成される乱数の下界を含みます．
high	生成された乱数の排他的上界

参照: RNG,randn,theRNG

◆ reduce()

CV_EXPORTS_W void cv::reduce	(	InputArray	src,
		OutputArray	dst,
		int	dim,
		int	rtype,
		int	dtype = `-1`
	)

行列をベクトルに変換します。

この関数はreduceは，行列の行/列を 1 次元ベクトルの集合として扱い，単一の行/列が得られるまで，そのベクトルに対して指定された処理を行うことで，行列をベクトルに変換します．例えば，この関数は，ラスター画像の水平・垂直方向の投影図を求めるために利用できます．の場合はREDUCE_MAXおよびREDUCE_MINの場合，出力画像は入力画像と同じ型でなければいけません．の場合はREDUCE_SUMおよびREDUCE_AVGの場合は，精度を保つために，出力の要素ビット深度を大きくすることができます．また，この2つのリダクションモードでは，マルチチャンネル配列もサポートされています．

以下のコードは，シングルチャンネルの行列に対する使用例です．

また，次のコードは，2チャンネルの行列に対する使用例です．

引数

src	入力 2D 行列．
dst	出力ベクトル．そのサイズとタイプは，パラメータ dim と dtype で定義されます．
dim	行列が縮小される次元のインデックス．0 は，行列が 1 行に縮小されることを意味します．1 は，行列が 1 列に縮小されることを意味します．
rtype	以下のいずれかの縮小操作．ReduceTypes
dtype	負の値の場合，出力ベクトルは入力行列と同じ型になり，そうでない場合は CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels()) になります．

参照: repeat

◆ repeat() [1/2]

CV_EXPORTS Mat cv::repeat	(	const Mat &	src,
		int	ny,
		int	nx
	)

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

引数

src	複製される入力配列．
ny	が縦軸に沿って何回繰り返されるかを指定するフラグ．`src`は，垂直軸に沿って繰り返されます．
nx	が縦軸に沿って何回繰り返されるかを指定するフラグ．`src`は，横軸に沿って繰り返されます．

◆ repeat() [2/2]

CV_EXPORTS_W void cv::repeat	(	InputArray	src,
		int	ny,
		int	nx,
		OutputArray	dst
	)

出力配列を，入力配列の繰り返しコピーで埋めます．

この関数はcv::repeatは，入力配列を2つの軸それぞれに沿って1回または複数回複製します．

$\texttt{dst} _{ij}= \texttt{src} _{i\mod src.rows, \; j\mod src.cols }$

この関数の 2 番目のバリエーションは，次のような場合に便利です．MatrixExpressions.

引数

src	複製される入力配列．
ny	が縦軸に沿って何回繰り返されるかを指定するフラグ．`src`は，垂直軸に沿って繰り返されます．
nx	が縦軸に沿って何回繰り返されるかを指定するフラグ．`src`は，横軸に沿って繰り返されます．
dst	と同じ型の出力配列を使用する場合に便利です．`src`.

参照: cv::reduce

◆ rotate()

CV_EXPORTS_W void cv::rotate	(	InputArray	src,
		OutputArray	dst,
		int	rotateCode
	)

2 次元配列を 90 度の倍数で回転させます。この関数はcv::rotateは，3つの異なる方法のうちの1つで配列を回転させます．時計回りに90度回転させる（rotateCode = ROTATE_90_CLOCKWISE）。時計回りに180度回転させる（rotateCode = ROTATE_180）。時計回りに270度回転します（rotateCode = ROTATE_90_COUNTERCLOCKWISE）。

引数

src	入力配列．
dst	srcと同じ型の配列を出力します。サイズはROTATE_180と同じで、ROTATE_90_CLOCKWISEとROTATE_90_COUNTERCLOCKWISEでは、行と列が入れ替わります。
rotateCode	配列の回転方法を指定するための列挙型です。RotateFlags

参照: transpose,repeat,completeSymm,flip,RotateFlags

◆ scaleAdd()

CV_EXPORTS_W void cv::scaleAdd	(	InputArray	src1,
		double	alpha,
		InputArray	src2,
		OutputArray	dst
	)

スケーリングされた配列と別の配列の和を求めます。

関数 scaleAdd は，古典的な原始的線形代数演算の1つで，BLASでは DAXPY または SAXPY として知られています。BLAS. この関数は，スケーリングされた配列と別の配列の和を求めます．

$\texttt{dst} (I)= \texttt{scale} \cdot \texttt{src1} (I) + \texttt{src2} (I)$

この関数は，行列式を用いてエミュレートすることもできます．

Mat
A(3, 3, CV_64F);
...
A.row(0) = A.row(1)*2 + A.row(2);

引数

src1	1番目の入力配列．
alpha	1 番目の配列のスケール係数．
src2	src1 と同じサイズ，同じ型の 2 番目の入力配列．
dst	src1 と同じサイズ，同じ型の出力配列．

参照: add,addWeighted,subtract,Mat::dot,Mat::convertTo

◆ setIdentity()

CV_EXPORTS_W void cv::setIdentity	(	InputOutputArray	mtx,
		const Scalar &	s = `Scalar(1)`
	)

スケーリングされた単位行列を初期化します．

この関数はcv::setIdentityスケーリングされた単位行列を初期化します．

$\texttt{mtx} (i,j)= \fork{\texttt{value}}{ if \‍(i=j\‍)}{0}{otherwise}$

この関数は，行列の初期化子や行列式を用いてエミュレートすることもできます．

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

// A will be set to [[5, 0, 0], [0, 5, 0], [0, 0, 5], [0, 0, 0]]

cv::Mat::eye

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

Returns an identity matrix of the specified size and type.

引数

mtx	初期化される行列（正方でなくても構いません）．
s	対角線の要素に割り当てる値．

参照: Mat::zeros,Mat::ones,Mat::setTo,Mat::operator=

◆ setRNGSeed()

CV_EXPORTS_W void cv::setRNGSeed ( int seed )

デフォルトの乱数生成器の状態を設定します．

この関数はcv::setRNGSeedデフォルトの乱数生成器の状態をカスタム値に設定します．

引数

seed	デフォルトの乱数生成器の新しい状態

参照: RNG,randu,randn

◆ solve()

CV_EXPORTS_W bool cv::solve	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		int	flags = `DECOMP_LU`
	)

1 つ以上の連立方程式または最小二乗問題を解きます。

この関数はcv::solveは，連立一次方程式または最小二乗問題を解きます（最小二乗問題を解くにはSVDやQRメソッド、またはフラグDECOMP_NORMAL):

$\texttt{dst} = \arg \min _X \| \texttt{src1} \cdot \texttt{X} - \texttt{src2} \|$

もしDECOMP_LUまたはDECOMP_CHOLESKYメソッドが用いられた場合， src1 (または $\texttt{src1}^T\texttt{src1}$ ) が非特異点であれば 1 を返します．後者の場合，dst は有効ではありません．その他のメソッドは，左辺が特異な場合に擬似解を求めるものです．

覚え書き: 定義されていない特異な系のユニティノルム解を求めたい場合は $\texttt{src1}\cdot\texttt{dst}=0$ のユニティノルム解を求めたい場合，関数 solve はその作業を行いません．使用するSVD::solveZ代わりに

引数

src1	系の左辺の入力行列．
src2	系の右辺に入力行列を配置します。
dst	出力解。
flags	解（行列反転）法 (DecompTypes)

参照: invert,SVD,eigen

◆ solveCubic()

CV_EXPORTS_W int cv::solveCubic	(	InputArray	coeffs,
		OutputArray	roots
	)

三次方程式の実根を求めます．

関数 solveCubic は，3 次方程式の実根を求めます．

coeffs が 4 要素のベクトルの場合。
$\texttt{coeffs} [0] x^3 + \texttt{coeffs} [1] x^2 + \texttt{coeffs} [2] x + \texttt{coeffs} [3] = 0$
coeffs が 3 要素のベクトルの場合．
$x^3 + \texttt{coeffs} [0] x^2 + \texttt{coeffs} [1] x + \texttt{coeffs} [2] = 0$

根は，配列 roots に格納されます．

引数

coeffs	equation coefficients は，3 個または 4 個の要素からなる配列です．
roots	1個または3個の要素を持つ実根の出力配列。

戻り値: 実根の数。0, 1, 2 のいずれかです。

◆ solvePoly()

CV_EXPORTS_W double cv::solvePoly	(	InputArray	coeffs,
		OutputArray	roots,
		int	maxIters = `300`
	)

多項式方程式の実根または複素根を求めます。

この関数はcv::solvePolyは，多項式の実根および複素根を求めます．

$\texttt{coeffs} [n] x^{n} + \texttt{coeffs} [n-1] x^{n-1} + ... + \texttt{coeffs} [1] x + \texttt{coeffs} [0] = 0$

引数

coeffs	多項式の係数の配列を出力します。
roots	根の出力（複素数）配列．
maxIters	アルゴリズムが行う反復の最大数．

◆ sort()

CV_EXPORTS_W void cv::sort	(	InputArray	src,
		OutputArray	dst,
		int	flags
	)

行列の各行または各列をソートします．

この関数はcv::sortは，行列の各行または各列を昇順または降順にソートします．したがって，目的の動作を得るためには，2つの処理フラグを渡す必要があります．行列の行や列を辞書的にソートしたい場合は，適切な比較述語を持つ STL の汎用関数 std::sort を利用できます．

引数

src	入力シングルチャンネル配列．
dst	src と同じサイズ・タイプの配列を出力します。
flags	操作フラグは，以下の組み合わせですSortFlags

参照: sortIdx,randShuffle

◆ sortIdx()

CV_EXPORTS_W void cv::sortIdx	(	InputArray	src,
		OutputArray	dst,
		int	flags
	)

行列の各行または各列をソートします．

この関数はcv::sortIdxは，行列の各行または各列を昇順または降順にソートします．したがって，望ましい動作を得るためには，2つの操作フラグを渡す必要があります．この関数は，要素自体を並べ替えるのではなく，並べ替えられた要素のインデックスを出力配列に格納します．例えば、以下のようになります。

Mat
A =
Mat::eye(3,3,CV_32F), B;

sortIdx(A, B,
SORT_EVERY_ROW
+
SORT_ASCENDING);

// B will probably contain

// (because of equal elements in A some permutations are possible):

// [[1, 2, 0], [0, 2, 1], [0, 1, 2]]

引数

src	入力シングルチャンネル配列．
dst	src と同じサイズの整数配列を出力します．
flags	以下のような動作フラグを組み合わせることができますcv::SortFlags

参照: sort,randShuffle

◆ split() [1/2]

CV_EXPORTS void cv::split	(	const Mat &	src,
		Mat *	mvbegin
	)

マルチチャンネル配列を，複数のシングルチャンネル配列に分割します．

この関数はcv::splitマルチチャンネル配列を，複数のシングルチャンネル配列に分割します．

$\texttt{mv} [c](I) = \texttt{src} (I)_c$

1 つのチャンネルを取り出したり，その他の高度なチャンネル順列処理を行う必要がある場合は， mixChannels を利用してください．

以下の例では，3 チャンネルの行列を 3 つのシングルチャンネルの行列に分割する方法を示します．

引数

src	入力マルチチャンネル配列．
mvbegin	出力配列．配列の個数は src.channels() と一致しなければいけません．必要ならば，配列自体が再割り当てされます．

参照: merge,mixChannels,cvtColor

◆ split() [2/2]

CV_EXPORTS_W void cv::split	(	InputArray	m,
		OutputArrayOfArrays	mv
	)

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

引数

m	入力マルチチャンネル配列．
mv	出力配列のベクトル．必要ならば，配列自体が再割り当てされます．

◆ sqrt()

CV_EXPORTS_W void cv::sqrt	(	InputArray	src,
		OutputArray	dst
	)

配列の要素の平方根を求めます．

この関数はcv::sqrt入力配列の各要素の平方根を求めます．マルチチャンネル配列の場合，各チャンネルは独立して処理されます．その精度は，組み込みの std::sqrt とほぼ同じです．

引数

src	入力浮動小数点配列．
dst	src と同じサイズ・タイプの配列を出力します。

◆ subtract()

CV_EXPORTS_W void cv::subtract	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		InputArray	mask = `noArray()`,
		int	dtype = `-1`
	)

2つの配列同士，あるいは配列とスカラの要素毎の差を求めます．

関数 subtract は，次のように計算します．

両方の入力配列が同じサイズ，同じチャンネル数である場合の，2つの配列の差．
$\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0$
src2 がスカラから構成されているか，あるいは src2 と同じ数の要素を持つ場合の，配列とスカラとの差．src1.channels():
$\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2} ) \quad \texttt{if mask}(I) \ne0$
src1 がスカラから作成されるか，あるいは同じ数の要素を持つ場合の，スカラと配列の違いsrc2.channels():
$\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} - \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0$
の場合の，スカラと配列の逆の違い．SubRS:
$\texttt{dst}(I) = \texttt{saturate} ( \texttt{src2} - \texttt{src1}(I) ) \quad \texttt{if mask}(I) \ne0$
ここで I は，配列要素の多次元インデックスです．マルチチャンネル配列の場合，各チャンネルは独立して処理されます．

上述のリストの最初の関数は，行列式で置き換えることができます．

dst = src1 - src2;

dst -= src1; // equivalent to subtract(dst, src1, dst);

入力配列と出力配列の深さは，すべて同じでも異なっていても構いません．例えば，8 ビットの符号なし配列への減算を行い，その差を 16 ビットの符号付き配列に格納することができます．出力配列の深さは，dtypeパラメータで決まります．上記の 2 番目と 3 番目のケース，そして 1 番目のケースと同様に， src1.depth() == src2.depth() の場合， dtype をデフォルトの -1 に設定することができます．この場合，出力配列の深さは， src1，src2，またはその両方の入力配列と同じになります．

覚え書き: 出力配列のビット深度が CV_32S の場合，Saturation は適用されません．また，オーバーフローが発生した場合は，不正な符号の結果が得られる可能性があります．

引数

src1	1 番目の入力配列またはスカラ．
src2	2番目の入力配列，あるいはスカラ．
dst	出力配列は，入力配列と同じサイズ，同じチャンネル数になります．
mask	オプションの処理マスク．これは 8 ビットのシングルチャンネル配列で，変更される出力配列の要素を指定します．
dtype	オプションで，出力配列の深さを指定します．

参照: add,addWeighted,scaleAdd,Mat::convertTo

◆ SVBackSubst()

CV_EXPORTS_W void cv::SVBackSubst	(	InputArray	w,
		InputArray	u,
		InputArray	vt,
		InputArray	rhs,
		OutputArray	dst
	)

ラップSVD::backSubst

◆ SVDecomp()

CV_EXPORTS_W void cv::SVDecomp	(	InputArray	src,
		OutputArray	w,
		OutputArray	u,
		OutputArray	vt,
		int	flags = `0`
	)

ラップSVD::compute

◆ theRNG()

CV_EXPORTS RNG & cv::theRNG ( )

デフォルトの乱数生成器を返します。

この関数はcv::theRNGは，デフォルトの乱数生成器を返します．各スレッドごとに独立した乱数生成器が用意されているので，この関数をマルチスレッド環境で安全に使用することができます．このジェネレータを使って1つの乱数を取得したり、配列を初期化したりするだけなら、代わりに randu や randn を使うことができます。しかし，ループ内で多数の乱数を生成する場合は，この関数を使ってジェネレータを取得し，その後 RNG::operator _Tp() を使った方がはるかに高速です．

参照: RNG,randu,randn

◆ trace()

CV_EXPORTS_W Scalar cv::trace ( InputArray mtx )

行列のトレースを返します．

この関数はcv::traceは，行列 mtx の対角線要素の和を返します．

$\mathrm{tr} ( \texttt{mtx} ) = \sum _i \texttt{mtx} (i,i)$

引数

mtx 入力行列．

◆ transform()

CV_EXPORTS_W void cv::transform	(	InputArray	src,
		OutputArray	dst,
		InputArray	m
	)

配列の各要素に対して，行列変換を行います．

この関数はcv::transform配列 src の各要素に対して行列変換を行い，その結果を dst に格納します．

$\texttt{dst} (I) = \texttt{m} \cdot \texttt{src} (I)$

(m.cols=src.channels() の場合)，または

$\texttt{dst} (I) = \texttt{m} \cdot [ \texttt{src} (I); 1]$

(m.cols=src.channels()+1 の場合)

Nチャンネル配列 src の各要素は，M x N または M x (N+1) の行列 m を用いて変換された N 個の要素を持つベクトルとして解釈され，出力配列 dst の対応する要素となります．

この関数は，N - 次元の点の幾何学的変換，任意の線形色空間変換（例えば，各種の RGB → YUV 変換），画像チャンネルの入れ替えなどに利用できます．

引数

src	m.cols または m.cols-1 と同数のチャンネル（1～4）を持つ入力配列．
dst	src と同じサイズ，同じビット深度の出力配列．m.rows と同じ数のチャンネルを持ちます．
m	変換 2x2 または 2x3 の浮動小数点型行列．

参照: perspectiveTransform,getAffineTransform,estimateAffine2D,warpAffine,warpPerspective

◆ transpose()

CV_EXPORTS_W void cv::transpose	(	InputArray	src,
		OutputArray	dst
	)

行列の転置を行います．

この関数はcv::transposeは，行列 src を転置します．

$\texttt{dst} (i,j) = \texttt{src} (j,i)$

覚え書き: 複素数行列の場合は，複素数の共役化は行われません．必要であれば，別途行う必要があります．

引数

src	入力配列．
dst	src と同じ型の配列を出力します．

◆ vconcat() [1/3]

CV_EXPORTS void cv::vconcat	(	const Mat *	src,
		size_t	nsrc,
		OutputArray	dst
	)

与えられた行列に対して，垂直連結処理を行います．

この関数は，（同じ数の）2つ以上の行列を垂直方向に連結します．cv::Mat行列を垂直方向に連結します．

cv::Mat
matArray[] = {
cv::Mat(1, 4, CV_8UC1,
cv::Scalar(1)),

cv::Mat(1, 4, CV_8UC1,
cv::Scalar(2)),

cv::Mat(1, 4, CV_8UC1,
cv::Scalar(3)),};


cv::Mat
out;

cv::vconcat( matArray, 3, out );

//out:

//[1,   1,   1,   1;

// 2,   2,   2,   2;

// 3,   3,   3,   3]

引数

src	すべての行列は，同じ cols 数と同じ depth を持っていなければいけません．
nsrc	src に含まれる行列の数．
dst	出力配列．src と同じ数の cols と depth を持ち， src の行数の合計になります．

参照: cv::hconcat(const Mat*, size_t, OutputArray),; cv::hconcat(InputArrayOfArrays, OutputArray)および; cv::hconcat(InputArray, InputArray, OutputArray)

◆ vconcat() [2/3]

CV_EXPORTS void cv::vconcat	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst
	)

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

cv::Mat_<float>
A = (cv::Mat_<float>(3, 2) << 1, 7,

2, 8,

3, 9);

cv::Mat_<float>
B = (cv::Mat_<float>(3, 2) << 4, 10,

5, 11,

6, 12);

cv::Mat
C;

cv::vconcat(A, B, C);

//C:

//[1, 7;

// 2, 8;

// 3, 9;

// 4, 10;

// 5, 11;

// 6, 12]

引数

src1	垂直連結の対象となる 1 番目の入力配列．
src2	垂直方向の連結が考慮される 2 番目の入力配列．
dst	出力配列．src1 と src2 と同じ数の cols と depth を持ち， src1 と src2 の行数の合計が出力されます．

◆ vconcat() [3/3]

CV_EXPORTS_W void cv::vconcat	(	InputArrayOfArrays	src,
		OutputArray	dst
	)

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

std::vector<cv::Mat> matrices = {
cv::Mat(1, 4, CV_8UC1,
cv::Scalar(1)),

cv::Mat(1, 4, CV_8UC1,
cv::Scalar(2)),

cv::Mat(1, 4, CV_8UC1,
cv::Scalar(3)),};


cv::Mat
out;

cv::vconcat( matrices, out );

//out:

//[1,   1,   1,   1;

// 2,   2,   2,   2;

// 3,   3,   3,   3]

引数

src	入力配列または行列のベクトル．すべての行列は，同じ数の col と同じ深さを持っていなければいけません．
dst	出力配列．src と同じ数の col と同じ深さを持ち， src と src2 の行数の合計が，同じ深さになります．

クラス

列挙型

関数

変数

詳解

列挙型詳解

◆ BorderTypes

◆ CmpTypes

◆ DecompTypes

◆ DftFlags

◆ GemmFlags

◆ NormTypes

◆ ReduceTypes

◆ RotateFlags

関数詳解

◆ absdiff()

◆ add()

◆ addWeighted()

◆ batchDistance()

◆ bitwise_and()

◆ bitwise_not()

◆ bitwise_or()

◆ bitwise_xor()

◆ borderInterpolate()

◆ calcCovarMatrix() [1/2]

◆ calcCovarMatrix() [2/2]

◆ cartToPolar()

◆ checkRange()

◆ compare()

◆ completeSymm()

◆ convertFp16()

◆ convertScaleAbs()

◆ copyMakeBorder()

◆ copyTo()

◆ countNonZero()

◆ CV_EXPORTS_AS() [1/2]

◆ CV_EXPORTS_AS() [2/2]

◆ dct()

◆ determinant()

◆ dft()

◆ divide() [1/2]

◆ divide() [2/2]

◆ eigen()

◆ eigenNonSymmetric()

◆ exp()

◆ extractChannel()

◆ findNonZero()

◆ flip()

◆ gemm()

◆ getOptimalDFTSize()

◆ hconcat() [1/3]

◆ hconcat() [2/3]

◆ hconcat() [3/3]

◆ idct()

◆ idft()

◆ inRange()

◆ insertChannel()

◆ invert()

◆ log()

◆ LUT()

◆ magnitude()

◆ Mahalanobis()

◆ max() [1/3]

◆ max() [2/3]

◆ max() [3/3]

◆ mean()

◆ meanStdDev()

◆ merge() [1/2]

◆ merge() [2/2]

◆ min() [1/3]

◆ min() [2/3]

◆ min() [3/3]

◆ minMaxIdx()

◆ minMaxLoc() [1/2]

◆ minMaxLoc() [2/2]

◆ mixChannels() [1/3]

◆ mixChannels() [2/3]

◆ mixChannels() [3/3]

◆ mulSpectrums()

◆ multiply()