配列に対する演算

詳細説明

クラス
class	cv::LDA
	線形判別分析 (Linear Discriminant Analysis)。 詳細...
class	cv::PCA
	主成分分析 (Principal Component Analysis)。 詳細...
class	cv::RNG
	乱数生成器 (Random Number Generator)。 詳細...
class	cv::RNG_MT19937
	メルセンヌ・ツイスタ乱数生成器。 詳細...
class	cv::SVD
	特異値分解 (Singular Value Decomposition)。 詳細...

列挙型
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 }
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::CovarFlags {   cv::COVAR_SCRAMBLED = 0 ,   cv::COVAR_NORMAL = 1 ,   cv::COVAR_USE_AVG = 2 ,   cv::COVAR_SCALE = 4 ,   cv::COVAR_ROWS = 8 ,   cv::COVAR_COLS = 16 }
	共分散フラグ。 続きを読む...
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::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::GemmFlags {   cv::GEMM_1_T = 1 ,   cv::GEMM_2_T = 2 ,   cv::GEMM_3_T = 4 }
	一般化行列乗算のフラグ 続きを読む...
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::ReduceTypes {   cv::REDUCE_SUM = 0 ,   cv::REDUCE_AVG = 1 ,   cv::REDUCE_MAX = 2 ,   cv::REDUCE_MIN = 3 ,   cv::REDUCE_SUM2 = 4 }
enum	cv::RotateFlags {   cv::ROTATE_90_CLOCKWISE = 0 ,   cv::ROTATE_180 = 1 ,   cv::ROTATE_90_COUNTERCLOCKWISE = 2 }

関数
void	cv::absdiff (InputArray src1, InputArray src2, OutputArray dst)
	2つの配列間、または配列とスカラ間の要素ごとの絶対差を計算する。
void	cv::add (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
	2つの配列、または配列とスカラの要素ごとの和を計算する。
void	cv::addWeighted (InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype=-1)
	2つの配列の重み付き和を計算する。
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)
	単純な最近傍探索器
void	cv::bitwise_and (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
	2つの配列のビット単位の論理積を計算する (dst = src1 & src2)。2つの配列、または配列とスカラの要素ごとのビット単位の論理積を計算する。
void	cv::bitwise_not (InputArray src, OutputArray dst, InputArray mask=noArray())
	配列の各ビットを反転する。
void	cv::bitwise_or (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
	2つの配列、または配列とスカラの要素ごとのビット単位の論理和を計算する。
void	cv::bitwise_xor (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
	2つの配列、または配列とスカラに対して要素ごとのビット単位の「排他的論理和」演算を行う。
int	cv::borderInterpolate (int p, int len, int borderType)
	外挿されたピクセルの参照元の位置を計算する。
void	cv::broadcast (InputArray src, const MatShape &shape, OutputArray dst)
	指定された Mat を指定された形状にブロードキャストする。
void	cv::broadcast (InputArray src, InputArray shape, OutputArray dst)
	指定された Mat を指定された形状にブロードキャストする。
void	cv::calcCovarMatrix (const Mat *samples, int nsamples, Mat &covar, Mat &mean, int flags, int ctype=6)
	ベクトルの集合の共分散行列を計算する。
void	cv::calcCovarMatrix (InputArray samples, OutputArray covar, InputOutputArray mean, int flags, int ctype=6)
void	cv::cartToPolar (InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false)
	2次元ベクトルの大きさと角度を計算する。
bool	cv::checkRange (InputArray a, bool quiet=true, Point *pos=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX)
	入力配列の各要素に無効な値がないかチェックする。
void	cv::compare (InputArray src1, InputArray src2, OutputArray dst, int cmpop)
	2つの配列、または配列とスカラ値の要素ごとの比較を行う。
void	cv::completeSymm (InputOutputArray m, bool lowerToUpper=false)
	正方行列の下半分または上半分を、もう一方の半分にコピーする。
void	cv::convertScaleAbs (InputArray src, OutputArray dst, double alpha=1, double beta=0)
	スケーリングと絶対値の計算を行い、結果を8ビットに変換する。
void	cv::copyMakeBorder (InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar &value=Scalar())
	画像の周囲に境界を作成する。
void	cv::copyTo (InputArray src, OutputArray dst, InputArray mask)
	これはオーバーロードされたメンバ関数であり、利便性のために提供されている (python)。行列を別の行列にコピーする。操作マスクが指定されており、上記の Mat::create 呼び出しによって行列が再確保される場合、新たに確保された行列はデータをコピーする前にすべてゼロで初期化される。
int	cv::countNonZero (InputArray src)
	非ゼロの配列要素を数える。
void	cv::dct (InputArray src, OutputArray dst, int flags=0)
	1次元または2次元配列の順方向または逆方向の離散コサイン変換を行う。
double	cv::determinant (InputArray mtx)
	正方の浮動小数点行列の行列式を返す。
void	cv::dft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
	1次元または2次元の浮動小数点配列の順方向または逆方向の離散フーリエ変換を行う。
void	cv::divide (double scale, InputArray src2, OutputArray dst, int dtype=-1)
void	cv::divide (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
	2つの配列の要素ごとの除算、またはスカラを配列で除算する。
void	cv::divSpectrums (InputArray a, InputArray b, OutputArray c, int flags, bool conjB=false)
	第1のフーリエスペクトルを第2のフーリエスペクトルで要素ごとに除算する。
bool	cv::eigen (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors=noArray())
	対称行列の固有値と固有ベクトルを計算する。
void	cv::eigenNonSymmetric (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors)
	非対称行列の固有値と固有ベクトルを計算する(実固有値のみ)。
void	cv::exp (InputArray src, OutputArray dst)
	配列の各要素の指数を計算する。
void	cv::extractChannel (InputArray src, OutputArray dst, int coi)
	src から単一のチャンネルを抽出する (coi は0始まりのインデックス)。
void	cv::findNonZero (InputArray src, OutputArray idx)
	非ゼロのピクセルの位置の一覧を返す。
void	cv::finiteMask (InputArray src, OutputArray mask)
	有限の浮動小数点値（すなわちNaNでもInfでもない値）のマスクを生成する。
void	cv::flip (InputArray src, OutputArray dst, int flipCode)
	2次元配列を垂直軸、水平軸、またはその両方を中心に反転する。
void	cv::flipND (InputArray src, OutputArray dst, int axis)
	n次元配列を指定した軸で反転する。
void	cv::gemm (InputArray src1, InputArray src2, double alpha, InputArray src3, double beta, OutputArray dst, int flags=0)
	一般化行列積を行う。
int	cv::getOptimalDFTSize (int vecsize)
	与えられたベクトルサイズに対する最適なDFTサイズを返す。
bool	cv::hasNonZero (InputArray src)
	少なくとも1つの非ゼロ配列要素が存在するかチェックする。
void	cv::hconcat (const Mat *src, size_t nsrc, OutputArray dst)
	与えられた行列に水平方向の連結を適用する。
void	cv::hconcat (InputArray src1, InputArray src2, OutputArray dst)
void	cv::hconcat (InputArrayOfArrays src, OutputArray dst)
void	cv::idct (InputArray src, OutputArray dst, int flags=0)
	1次元または2次元配列の逆離散コサイン変換を計算する。
void	cv::idft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
	1次元または2次元配列の逆離散フーリエ変換を計算する。
void	cv::inRange (InputArray src, InputArray lowerb, InputArray upperb, OutputArray dst)
	配列の各要素が、他の2つの配列の要素の間にあるかチェックする。
void	cv::insertChannel (InputArray src, InputOutputArray dst, int coi)
	dst に単一のチャンネルを挿入する (coi は0始まりのインデックス)。
double	cv::invert (InputArray src, OutputArray dst, int flags=DECOMP_LU)
	行列の逆行列または擬似逆行列を求める。
void	cv::log (InputArray src, OutputArray dst)
	配列の各要素の自然対数を計算する。
void	cv::LUT (InputArray src, InputArray lut, OutputArray dst)
	配列に対してルックアップテーブル変換を行う。
void	cv::magnitude (InputArray x, InputArray y, OutputArray magnitude)
	2次元ベクトルの大きさを計算する。
double	cv::Mahalanobis (InputArray v1, InputArray v2, InputArray icovar)
	2つのベクトル間のマハラノビス距離を計算する。
void	cv::max (const Mat &src1, const Mat &src2, Mat &dst)
void	cv::max (const UMat &src1, const UMat &src2, UMat &dst)
void	cv::max (InputArray src1, InputArray src2, OutputArray dst)
	2つの配列、または配列とスカラの要素ごとの最大値を計算する。
Scalar	cv::mean (InputArray src, InputArray mask=noArray())
	配列要素の平均 (mean) を計算する。
void	cv::meanStdDev (InputArray src, OutputArray mean, OutputArray stddev, InputArray mask=noArray())
void	cv::merge (const Mat *mv, size_t count, OutputArray dst)
	複数のシングルチャンネル配列から1つのマルチチャンネル配列を作成する。
void	cv::merge (InputArrayOfArrays mv, OutputArray dst)
void	cv::min (const Mat &src1, const Mat &src2, Mat &dst)
void	cv::min (const UMat &src1, const UMat &src2, UMat &dst)
void	cv::min (InputArray src1, InputArray src2, OutputArray dst)
	2つの配列、または配列とスカラの要素ごとの最小値を計算する。
void	cv::minMaxIdx (InputArray src, double *minVal, double *maxVal=0, int *minIdx=0, int *maxIdx=0, InputArray mask=noArray())
	配列内のグローバルな最小値と最大値を見つける。
void	cv::minMaxLoc (const SparseMat &a, double *minVal, double *maxVal, int *minIdx=0, int *maxIdx=0)
void	cv::minMaxLoc (InputArray src, double *minVal, double *maxVal=0, Point *minLoc=0, Point *maxLoc=0, InputArray mask=noArray())
	配列内のグローバルな最小値と最大値を見つける。
void	cv::mixChannels (const Mat *src, size_t nsrcs, Mat *dst, size_t ndsts, const int *fromTo, size_t npairs)
	入力配列の指定したチャンネルを、出力配列の指定したチャンネルへコピーする。
void	cv::mixChannels (InputArrayOfArrays src, InputOutputArrayOfArrays dst, const int *fromTo, size_t npairs)
void	cv::mixChannels (InputArrayOfArrays src, InputOutputArrayOfArrays dst, const std::vector< int > &fromTo)
void	cv::mulSpectrums (InputArray a, InputArray b, OutputArray c, int flags, bool conjB=false)
	2つのフーリエスペクトルの要素ごとの乗算を行う。
void	cv::multiply (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
	2つの配列の要素ごとのスケール付き積を計算する。
void	cv::mulTransposed (InputArray src, OutputArray dst, bool aTa, InputArray delta=noArray(), double scale=1, int dtype=-1)
	行列とその転置の積を計算する。
double	cv::norm (const SparseMat &src, int normType)
double	cv::norm (InputArray src1, InputArray src2, int normType=NORM_L2, InputArray mask=noArray())
	絶対差ノルムまたは相対差ノルムを計算する。
double	cv::norm (InputArray src1, int normType=NORM_L2, InputArray mask=noArray())
	配列の絶対ノルムを計算する。
void	cv::normalize (const SparseMat &src, SparseMat &dst, double alpha, int normType)
void	cv::normalize (InputArray src, InputOutputArray dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, InputArray mask=noArray())
	配列のノルムまたは値の範囲を正規化する。
void	cv::patchNaNs (InputOutputArray a, double val=0)
	行列内のNaN(非数値)を指定した値で置き換える。
void	cv::PCABackProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result)
void	cv::PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, double retainedVariance)
void	cv::PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, int maxComponents=0)
void	cv::PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, OutputArray eigenvalues, double retainedVariance)
void	cv::PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, OutputArray eigenvalues, int maxComponents=0)
void	cv::PCAProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result)
void	cv::perspectiveTransform (InputArray src, OutputArray dst, InputArray m)
	ベクトルに対して透視行列変換を行う。
void	cv::phase (InputArray x, InputArray y, OutputArray angle, bool angleInDegrees=false)
	2次元ベクトルの回転角を計算する。
void	cv::polarToCart (InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees=false)
	大きさと角度から2次元ベクトルのx座標とy座標を計算する。
void	cv::pow (InputArray src, double power, OutputArray dst)
	配列の各要素を累乗する。
double	cv::PSNR (InputArray src1, InputArray src2, double R=255.)
	ピーク信号対雑音比 (PSNR) という画質指標を計算する。
void	cv::randn (InputOutputArray dst, InputArray mean, InputArray stddev)
	正規分布に従う乱数で配列を埋める。
void	cv::randShuffle (InputOutputArray dst, double iterFactor=1., RNG *rng=0)
	配列の要素をランダムにシャッフルする。
void	cv::randu (InputOutputArray dst, InputArray low, InputArray high)
	一様分布に従う1つの乱数、または乱数の配列を生成する。
void	cv::reduce (InputArray src, OutputArray dst, int dim, int rtype, int dtype=-1)
	行列をベクトルに縮約する。
void	cv::reduceArgMax (InputArray src, OutputArray dst, int axis, bool lastIndex=false)
	指定した軸に沿って最大要素のインデックスを求める。
void	cv::reduceArgMin (InputArray src, OutputArray dst, int axis, bool lastIndex=false)
	指定した軸に沿って最小要素のインデックスを求める。
Mat	cv::repeat (const Mat &src, int ny, int nx)
void	cv::repeat (InputArray src, int ny, int nx, OutputArray dst)
	入力配列を繰り返しコピーして出力配列を埋める。
void	cv::rotate (InputArray src, OutputArray dst, int rotateCode)
	2次元配列を90度単位で回転する。関数 cv::rotate は次の3通りのいずれかの方法で配列を回転する。時計回りに90度回転（rotateCode = ROTATE_90_CLOCKWISE）。時計回りに180度回転（rotateCode = ROTATE_180）。時計回りに270度回転（rotateCode = ROTATE_90_COUNTERCLOCKWISE）。
void	cv::scaleAdd (InputArray src1, double alpha, InputArray src2, OutputArray dst)
	スケーリングした配列ともう一方の配列の和を計算する。
void	cv::setIdentity (InputOutputArray mtx, const Scalar &s=Scalar(1))
	スケーリングした単位行列を初期化する。
void	cv::setRNGSeed (int seed)
	デフォルトの乱数生成器の状態を設定する。
bool	cv::solve (InputArray src1, InputArray src2, OutputArray dst, int flags=DECOMP_LU)
	1つ以上の線形方程式系または最小二乗問題を解く。
int	cv::solveCubic (InputArray coeffs, OutputArray roots)
	3次方程式の実数解を求める。
double	cv::solvePoly (InputArray coeffs, OutputArray roots, int maxIters=300)
	多項式方程式の実数解または複素数解を求める。
void	cv::sort (InputArray src, OutputArray dst, int flags)
	行列の各行または各列をソートする。
void	cv::sortIdx (InputArray src, OutputArray dst, int flags)
	行列の各行または各列をソートする。
void	cv::split (const Mat &src, Mat *mvbegin)
	マルチチャンネル配列を複数のシングルチャンネル配列に分割する。
void	cv::split (InputArray m, OutputArrayOfArrays mv)
void	cv::sqrt (InputArray src, OutputArray dst)
	配列要素の平方根を計算する。
void	cv::subtract (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
	2つの配列、または配列とスカラの要素ごとの差を計算する。
Scalar	cv::sum (InputArray src)
	配列要素の総和を計算する。
void	cv::SVBackSubst (InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst)
void	cv::SVDecomp (InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags=0)
void	cv::swap (Mat &a, Mat &b)
	2つの行列を入れ替える。
void	cv::swap (UMat &a, UMat &b)
RNG &	cv::theRNG ()
	デフォルトの乱数生成器を返す。
Scalar	cv::trace (InputArray mtx)
	行列のトレースを返す。
void	cv::transform (InputArray src, OutputArray dst, InputArray m)
	すべての配列要素に対して行列変換を行う。
void	cv::transpose (InputArray src, OutputArray dst)
	行列を転置する。
void	cv::transposeND (InputArray src, const std::vector< int > &order, OutputArray dst)
	n次元行列の転置。
void	cv::vconcat (const Mat *src, size_t nsrc, OutputArray dst)
	指定した行列を垂直方向に連結する。
void	cv::vconcat (InputArray src1, InputArray src2, OutputArray dst)
void	cv::vconcat (InputArrayOfArrays src, OutputArray dst)

列挙型詳解

BorderTypes

enum cv::BorderTypes

#include <opencv2/core/base.hpp>

さまざまな境界種別。各手法を説明する下表では、画像の境界を | 文字で示す。

次の例は、さまざまな手法に応じた copyMakeBorder 呼び出しの結果を示す。入力画像は 6x4（幅×高さ）サイズで、copyMakeBorder 関数を各方向2ピクセルの境界サイズで使用しており、結果として 10x8 解像度の画像が得られる。

Input image:
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
 
Border type: BORDER_CONSTANT (a constant value of 255 is used)
[[255 255 255 255 255 255 255 255 255 255]
 [255 255 255 255 255 255 255 255 255 255]
 [255 255   0   1   2   3   4   5 255 255]
 [255 255   6   7   8   9  10  11 255 255]
 [255 255  12  13  14  15  16  17 255 255]
 [255 255  18  19  20  21  22  23 255 255]
 [255 255 255 255 255 255 255 255 255 255]
 [255 255 255 255 255 255 255 255 255 255]]
 
Border type: BORDER_REPLICATE
[[ 0  0  0  1  2  3  4  5  5  5]
 [ 0  0  0  1  2  3  4  5  5  5]
 [ 0  0  0  1  2  3  4  5  5  5]
 [ 6  6  6  7  8  9 10 11 11 11]
 [12 12 12 13 14 15 16 17 17 17]
 [18 18 18 19 20 21 22 23 23 23]
 [18 18 18 19 20 21 22 23 23 23]
 [18 18 18 19 20 21 22 23 23 23]]
 
Border type: BORDER_REFLECT
[[ 7  6  6  7  8  9 10 11 11 10]
 [ 1  0  0  1  2  3  4  5  5  4]
 [ 1  0  0  1  2  3  4  5  5  4]
 [ 7  6  6  7  8  9 10 11 11 10]
 [13 12 12 13 14 15 16 17 17 16]
 [19 18 18 19 20 21 22 23 23 22]
 [19 18 18 19 20 21 22 23 23 22]
 [13 12 12 13 14 15 16 17 17 16]]
 
Border type: BORDER_WRAP
[[16 17 12 13 14 15 16 17 12 13]
 [22 23 18 19 20 21 22 23 18 19]
 [ 4  5  0  1  2  3  4  5  0  1]
 [10 11  6  7  8  9 10 11  6  7]
 [16 17 12 13 14 15 16 17 12 13]
 [22 23 18 19 20 21 22 23 18 19]
 [ 4  5  0  1  2  3  4  5  0  1]
 [10 11  6  7  8  9 10 11  6  7]]
 
Border type: BORDER_REFLECT_101
[[14 13 12 13 14 15 16 17 16 15]
 [ 8  7  6  7  8  9 10 11 10  9]
 [ 2  1  0  1  2  3  4  5  4  3]
 [ 8  7  6  7  8  9 10 11 10  9]
 [14 13 12 13 14 15 16 17 16 15]
 [20 19 18 19 20 21 22 23 22 21]
 [14 13 12 13 14 15 16 17 16 15]
 [ 8  7  6  7  8  9 10 11 10  9]]

参照

borderInterpolate, copyMakeBorder

列挙値
BORDER_CONSTANT  Python: cv.BORDER_CONSTANT	指定したiを用いたiiiiii|abcdefgh|iiiiiii
BORDER_REPLICATE  Python: cv.BORDER_REPLICATE	aaaaaa|abcdefgh|hhhhhhh
BORDER_REFLECT  Python: cv.BORDER_REFLECT	fedcba|abcdefgh|hgfedcb
BORDER_WRAP  Python: cv.BORDER_WRAP	cdefgh|abcdefgh|abcdefg
BORDER_REFLECT_101  Python: cv.BORDER_REFLECT_101	gfedcb|abcdefgh|gfedcba
BORDER_TRANSPARENT  Python: cv.BORDER_TRANSPARENT	uvwxyz|abcdefgh|ijklmno - 外側の値を透過的に扱う。
BORDER_REFLECT101  Python: cv.BORDER_REFLECT101	BORDER_REFLECT_101と同じ
BORDER_DEFAULT  Python: cv.BORDER_DEFAULT	BORDER_REFLECT_101と同じ
BORDER_ISOLATED  Python: cv.BORDER_ISOLATED	ROIの境界内に制限された補間。

CmpTypes

enum cv::CmpTypes

#include <opencv2/core/base.hpp>

比較種別

列挙値
CMP_EQ  Python: cv.CMP_EQ	src1がsrc2と等しい。
CMP_GT  Python: cv.CMP_GT	src1がsrc2より大きい。
CMP_GE  Python: cv.CMP_GE	src1がsrc2以上である。
CMP_LT  Python: cv.CMP_LT	src1がsrc2より小さい。
CMP_LE  Python: cv.CMP_LE	src1がsrc2以下である。
CMP_NE  Python: cv.CMP_NE	src1がsrc2と等しくない。

CovarFlags

enum cv::CovarFlags

#include <opencv2/core.hpp>

共分散フラグ。

列挙値
COVAR_SCRAMBLED  Python: cv.COVAR_SCRAMBLED	出力される共分散行列は次のように計算される: \[\texttt{scale} \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...]^T \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...],\] 共分散行列はnsamples x nsamplesになる。このような通常とは異なる共分散行列は、非常に大きなベクトルの集合の高速なPCA(主成分分析)に用いられる(例として顔認識のEigenFaces手法を参照)。この「スクランブルされた」行列の固有値は、真の共分散行列の固有値と一致する。「真の」固有ベクトルは、「スクランブルされた」共分散行列の固有ベクトルから容易に計算できる。
COVAR_NORMAL  Python: cv.COVAR_NORMAL	出力される共分散行列は次のように計算される: \[\texttt{scale} \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...] \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...]^T,\] covarは、各入力ベクトルの要素の総数と同じサイズの正方行列になる。COVAR_SCRAMBLEDとCOVAR_NORMALのうち、必ずいずれか一方のみを指定しなければならない。
COVAR_USE_AVG  Python: cv.COVAR_USE_AVG	このフラグが指定された場合、関数は入力ベクトルから平均を計算せず、代わりに渡された平均ベクトルを使用する。これは平均が事前に計算済みもしくは既知である場合、または共分散行列を部分ごとに計算する場合に有用である。この場合、meanは入力ベクトルの部分集合の平均ベクトルではなく、集合全体の平均ベクトルである。
COVAR_SCALE  Python: cv.COVAR_SCALE	このフラグが指定された場合、共分散行列はスケーリングされる。「normal」モードでは、scaleは1./nsamplesである。「scrambled」モードでは、scaleは各入力ベクトルの要素の総数の逆数である。デフォルト(フラグが指定されない場合)では、共分散行列はスケーリングされない(scale=1)。
COVAR_ROWS  Python: cv.COVAR_ROWS	このフラグが指定された場合、すべての入力ベクトルはサンプル行列の行として格納される。この場合、meanは1行のベクトルでなければならない。
COVAR_COLS  Python: cv.COVAR_COLS	このフラグが指定された場合、すべての入力ベクトルはサンプル行列の列として格納される。この場合、meanは1列のベクトルでなければならない。

DecompTypes

enum cv::DecompTypes

#include <opencv2/core/base.hpp>

行列分解の種別

列挙値
DECOMP_LU  Python: cv.DECOMP_LU	最適なピボット要素を選択するガウスの消去法。
DECOMP_SVD  Python: cv.DECOMP_SVD	特異値分解(SVD)法。連立方程式は過剰決定であってもよく、行列src1が特異であってもよい
DECOMP_EIG  Python: cv.DECOMP_EIG	固有値分解。行列src1は対称でなければならない
DECOMP_CHOLESKY  Python: cv.DECOMP_CHOLESKY	コレスキー \(LL^T\) 分解。行列src1は対称かつ正定値でなければならない
DECOMP_QR  Python: cv.DECOMP_QR	QR分解。連立方程式は過剰決定であってもよく、行列src1が特異であってもよい
DECOMP_NORMAL  Python: cv.DECOMP_NORMAL	これまでのフラグはすべて互いに排他的だが、このフラグは前述のいずれとも併用できる。これは、元の連立方程式 \(\texttt{src1}\cdot\texttt{dst}=\texttt{src2}\) の代わりに、正規方程式 \(\texttt{src1}^T\cdot\texttt{src1}\cdot\texttt{dst}=\texttt{src1}^T\texttt{src2}\) を解くことを意味する

DftFlags

enum cv::DftFlags

#include <opencv2/core/base.hpp>

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

GemmFlags

enum cv::GemmFlags

#include <opencv2/core/base.hpp>

一般化行列乗算のフラグ

列挙値
GEMM_1_T  Python: cv.GEMM_1_T	src1 を転置する
GEMM_2_T  Python: cv.GEMM_2_T	src2 を転置する
GEMM_3_T  Python: cv.GEMM_3_T	src3 を転置する

NormTypes

enum cv::NormTypes

#include <opencv2/core/base.hpp>

ノルム種別

src1 と src2 は入力配列を表す。

列挙値
NORM_INF  Python: cv.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  Python: cv.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  Python: cv.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  Python: cv.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  Python: cv.NORM_HAMMING	入力配列が1つの場合は、配列のゼロからのHamming距離を計算する。入力配列が2つの場合は、それらの配列間のHamming距離を計算する。
NORM_HAMMING2  Python: cv.NORM_HAMMING2	NORM_HAMMING と似ているが、計算では入力シーケンスの2ビットごとを加算して1ビットとして扱い、NORM_HAMMING と同じ計算に用いる。
NORM_TYPE_MASK  Python: cv.NORM_TYPE_MASK	ノルム種別をノルムフラグから分離するために使用できるビットマスク
NORM_RELATIVE  Python: cv.NORM_RELATIVE	フラグ
NORM_MINMAX  Python: cv.NORM_MINMAX	フラグ

ReduceTypes

enum cv::ReduceTypes

#include <opencv2/core.hpp>

列挙値
REDUCE_SUM  Python: cv.REDUCE_SUM	出力は行列のすべての行/列の総和となる。
REDUCE_AVG  Python: cv.REDUCE_AVG	出力は行列のすべての行/列の平均ベクトルとなる。
REDUCE_MAX  Python: cv.REDUCE_MAX	出力は行列のすべての行/列の最大値（列方向/行方向）となる。
REDUCE_MIN  Python: cv.REDUCE_MIN	出力は行列のすべての行/列の最小値（列方向/行方向）となる。
REDUCE_SUM2  Python: cv.REDUCE_SUM2	出力は行列のすべての行/列の二乗の総和となる。

RotateFlags

enum cv::RotateFlags

#include <opencv2/core.hpp>

列挙値
ROTATE_90_CLOCKWISE  Python: cv.ROTATE_90_CLOCKWISE	時計回りに90度回転する。
ROTATE_180  Python: cv.ROTATE_180	時計回りに180度回転する。
ROTATE_90_COUNTERCLOCKWISE  Python: cv.ROTATE_90_COUNTERCLOCKWISE	時計回りに270度回転する。

関数詳解

absdiff()

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

Python:
	cv.absdiff(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

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

関数 cv::absdiff は次を計算する。2つの配列が同じサイズと型を持つ場合、それらの間の絶対差を求める。

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

2つ目の配列が Scalar から構成されるか、src1 のチャンネル数と同じ数の要素を持つ場合、配列とスカラ間の絶対差を求める。

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

1つ目の配列が Scalar から構成されるか、src2 のチャンネル数と同じ数の要素を持つ場合、スカラと配列間の絶対差を求める。

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

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

覚え書き

配列のビット深度が CV_32S の場合、飽和処理は適用されない。オーバーフローした場合には負の値が得られることさえある。

(Python) src1/src2 が単一の数値である場合とタプル/配列である場合とで挙動が異なる点に注意すること。absdiff(src,X) は absdiff(src,(X,X,X,X)) を意味する。absdiff(src,(X,)) は absdiff(src,(X,0,0,0)) を意味する。

引数

src1	1番目の入力配列、またはスカラー。
src2	2番目の入力配列、またはスカラー。
dst	入力配列と同じサイズ・型を持つ出力配列。

参照

cv::abs(const Mat&)

add()

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

Python:
	cv.add(	src1, src2[, dst[, mask[, dtype]]]	) ->	dst

#include <opencv2/core.hpp>

2つの配列、または配列とスカラの要素ごとの和を計算する。

関数 add は次を計算する。

• Sum of two arrays when both input arrays have the same size and the same number of channels:

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\]

• Sum of an array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels():

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\]

• Sum of a scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels():

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\]

  where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently.

上記リストの最初の関数は、行列式（matrix expression）で置き換えることができる。

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

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

覚え書き

出力配列のビット深度が CV_32S の場合、飽和処理は適用されない。オーバーフローした場合には符号が誤った結果が得られることさえある。

(Python) src1/src2 が単一の数値である場合とタプル/配列である場合とで挙動が異なる点に注意すること。add(src,X) は add(src,(X,X,X,X)) を意味する。add(src,(X,)) は add(src,(X,0,0,0)) を意味する。

引数

src1	1番目の入力配列、またはスカラー。
src2	2番目の入力配列、またはスカラー。
dst	入力配列と同じサイズ・チャンネル数を持つ出力配列。ビット深度は dtype または src1/src2 によって定義される。
mask	省略可能な操作マスク - CV_8U、CV_8S または CV_Bool のシングルチャンネル配列で、出力配列のうち変更される要素を指定する。
dtype	出力配列の省略可能なビット深度(後述の説明を参照)。

参照

subtract, addWeighted, scaleAdd, Mat::convertTo

addWeighted()

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

Python:
	cv.addWeighted(	src1, alpha, src2, beta, gamma[, dst[, dtype]]	) ->	dst

#include <opencv2/core.hpp>

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 の場合、飽和処理は適用されない。オーバーフローした場合には符号が誤った結果が得られることさえある。

引数

src1	1番目の入力配列。
alpha	1番目の配列要素の重み。
src2	src1 と同じサイズ・チャンネル数の2番目の入力配列。
beta	2番目の配列要素の重み。
gamma	各合計に加算されるスカラー。
dst	入力配列と同じサイズ・チャンネル数を持つ出力配列。
dtype	出力配列の省略可能なビット深度。両方の入力配列が同じビット深度の場合、dtype は -1 に設定でき、これは src1.depth() と同等になる。

参照

add, subtract, scaleAdd, Mat::convertTo

batchDistance()

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 )

Python:
	cv.batchDistance(	src1, src2, dtype[, dist[, nidx[, normType[, K[, mask[, update[, crosscheck]]]]]]]	) ->	dist, nidx

#include <opencv2/core.hpp>

単純な最近傍探索器

http://en.wikipedia.org/wiki/Nearest_neighbor_search を参照

TODOTodo

ドキュメント

bitwise_and()

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

Python:
	cv.bitwise_and(	src1, src2[, dst[, mask]]	) ->	dst

#include <opencv2/core.hpp>

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 が Scalar から構成されるか、src1.channels() と同じ数の要素を持つ場合の、配列とスカラ。

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

src1 が Scalar から構成されるか、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	省略可能な操作マスク。CV_8U、CV_8S または CV_Bool のシングルチャンネル配列で、出力配列のうち変更される要素を指定する。

bitwise_not()

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

Python:
	cv.bitwise_not(	src[, dst[, mask]]	) ->	dst

#include <opencv2/core.hpp>

配列のすべてのビットを反転する。

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

\[\texttt{dst} (I) = \neg \texttt{src} (I)\]

浮動小数点の入力配列の場合、演算にはそのマシン固有のビット表現（通常は IEEE754 準拠）が使用される。マルチチャンネル配列の場合、各チャンネルは独立して処理される。

引数

src	入力配列。
dst	入力配列と同じサイズ・型を持つ出力配列。
mask	省略可能な操作マスク。CV_8U、CV_8S または CV_Bool のシングルチャンネル配列で、出力配列のうち変更される要素を指定する。

bitwise_or()

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

Python:
	cv.bitwise_or(	src1, src2[, dst[, mask]]	) ->	dst

#include <opencv2/core.hpp>

2つの配列、または配列とスカラの要素ごとのビット単位論理和を計算する。

関数 cv::bitwise_or は次に対して要素ごとのビット単位論理和を計算する。src1 と src2 が同じサイズを持つ2つの配列の場合。

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

src2 が Scalar から構成されるか、src1.channels() と同じ数の要素を持つ場合の、配列とスカラ。

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

src1 が Scalar から構成されるか、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	省略可能な操作マスク。CV_8U、CV_8S または CV_Bool のシングルチャンネル配列で、出力配列のうち変更される要素を指定する。

bitwise_xor()

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

Python:
	cv.bitwise_xor(	src1, src2[, dst[, mask]]	) ->	dst

#include <opencv2/core.hpp>

2つの配列、または配列とスカラに対して要素ごとのビット単位「排他的論理和」演算を計算する。

関数 cv::bitwise_xor は次に対して要素ごとのビット単位「排他的論理和」演算を計算する。src1 と src2 が同じサイズを持つ2つの配列の場合。

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

src2 が Scalar から構成されるか、src1.channels() と同じ数の要素を持つ場合の、配列とスカラ。

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

src1 が Scalar から構成されるか、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	省略可能な操作マスク。CV_8U、CV_8S または CV_Bool のシングルチャンネル配列で、出力配列のうち変更される要素を指定する。

borderInterpolate()

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

Python:
	cv.borderInterpolate(	p, len, borderType	) ->	retval

#include <opencv2/core.hpp>

外挿されたピクセルの元の位置を計算する。

この関数は、指定した外挿境界モードを使用したときに、指定した外挿ピクセルに対応する供与元ピクセルの座標を計算して返す。例えば、水平方向に 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));

通常、この関数は直接呼び出されない。フィルタリング関数の内部や copyMakeBorder の内部で使用される。

引数

p	いずれかの軸に沿った外挿ピクセルの0始まりの座標。おそらく <0 または >= len となる
len	対応する軸に沿った配列の長さ。
borderType	境界の種類。BorderTypes のいずれか。ただし BORDER_TRANSPARENT と BORDER_ISOLATED を除く。borderType==BORDER_CONSTANT の場合、関数は p と len によらず常に -1 を返す。

参照

copyMakeBorder

broadcast() [1/2]

void cv::broadcast	(	InputArray	src,
		const MatShape &	shape,
		OutputArray	dst )

Python:
	cv.broadcast(	src, shape[, dst]	) ->	dst

#include <opencv2/core.hpp>

指定された Mat を指定された形状にブロードキャストする。

引数

src	入力配列
shape	ターゲット形状。負の値はサポートされていないことに注意。
dst	指定された形状を持つ出力配列

broadcast() [2/2]

void cv::broadcast	(	InputArray	src,
		InputArray	shape,
		OutputArray	dst )

Python:
	cv.broadcast(	src, shape[, dst]	) ->	dst

#include <opencv2/core.hpp>

指定された Mat を指定された形状にブロードキャストする。

引数

src	入力配列
shape	対象とする形状。CV_32S の数値のリストでなければならない。負の値はサポートされていないことに注意。
dst	指定された形状を持つ出力配列

calcCovarMatrix() [1/2]

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

Python:
	cv.calcCovarMatrix(	samples, mean, flags[, covar[, ctype]]	) ->	covar, mean

#include <opencv2/core.hpp>

ベクトル集合の共分散行列を計算する。

関数 cv::calcCovarMatrix は、入力ベクトル集合の共分散行列、および必要に応じて平均ベクトルを計算する。

引数

samples	別々の行列として格納されたサンプル
nsamples	サンプル数
covar	型がctypeで正方サイズの出力共分散行列。
mean	入力ベクトルの平均値としての入力または出力（フラグに依存）配列。
flags	CovarFlags の組み合わせとしての演算フラグ
ctype	行列の型。デフォルトでは 'CV_64F' に等しい。

参照

PCA, mulTransposed, Mahalanobis

TODOTodo

InputArrayOfArrays

calcCovarMatrix() [2/2]

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

Python:
	cv.calcCovarMatrix(	samples, mean, flags[, covar[, ctype]]	) ->	covar, mean

#include <opencv2/core.hpp>

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

覚え書き

COVAR_ROWS または COVAR_COLS フラグを使用する

引数

samples	単一の行列の行／列として格納されたサンプル。
covar	型がctypeで正方サイズの出力共分散行列。
mean	入力ベクトルの平均値としての入力または出力（フラグに依存）配列。
flags	CovarFlags の組み合わせとしての演算フラグ
ctype	行列の型。デフォルトでは 'CV_64F' に等しい。

cartToPolar()

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

Python:
	cv.cartToPolar(	x, y[, magnitude[, angle[, angleInDegrees]]]	) ->	magnitude, angle

#include <opencv2/core.hpp>

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,0) については、角度は0に設定される。

引数

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

参照

Sobel, Scharr

checkRange()

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

Python:
	cv.checkRange(	a[, quiet[, minVal[, maxVal]]]	) ->	retval, pos

#include <opencv2/core.hpp>

入力配列の各要素が不正な値でないかをチェックする。

関数 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()

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

Python:
	cv.compare(	src1, src2, cmpop[, dst]	) ->	dst

#include <opencv2/core.hpp>

2つの配列、または配列とスカラ値の要素ごとの比較を行う。

この関数は次を比較する。src1 と src2 が同じサイズを持つ2つの配列の要素の場合。

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

src2 が Scalar から構成されるか単一の要素を持つ場合の、src1 の要素とスカラ src2。

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

src1 が Scalar から構成されるか単一の要素を持つ場合の、src1 と src2 の要素。

\[\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()

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

Python:
	cv.completeSymm(	m[, lowerToUpper]	) ->	m

#include <opencv2/core.hpp>

正方行列の下半分または上半分を、そのもう一方の半分にコピーする。

関数 cv::completeSymm は、正方行列の下半分または上半分を、そのもう一方の半分にコピーする。行列の対角成分は変更されない。

• lowerToUpper=false の場合、\(i > j\) について \(\texttt{m}_{ij}=\texttt{m}_{ji}\)
• lowerToUpper=true の場合、\(i < j\) について \(\texttt{m}_{ij}=\texttt{m}_{ji}\)

引数

m	入出力の浮動小数点正方行列。
lowerToUpper	演算フラグ。trueの場合、下半分が上半分にコピーされる。それ以外の場合、上半分が下半分にコピーされる。

参照

flip, transpose

convertScaleAbs()

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

Python:
	cv.convertScaleAbs(	src[, dst[, alpha[, beta]]]	) ->	dst

#include <opencv2/core.hpp>

スケーリングし、絶対値を計算し、結果を8ビットに変換する。

入力配列の各要素に対して、関数convertScaleAbsは次の3つの演算を順に実行する。スケーリング、絶対値の取得、符号なし8ビット型への変換である。

\[\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()

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

Python:
	cv.copyMakeBorder(	src, top, bottom, left, right, borderType[, dst[, value]]	) ->	dst

#include <opencv2/core.hpp>

画像の周囲に境界を作成する。

この関数は入力画像を出力画像の中央にコピーする。コピーされた入力画像の左、右、上、下の領域は外挿されたピクセルで埋められる。これは、これを基にしたフィルタリング関数が行うこと(これらはピクセルをその場で外挿する)ではなく、自作のものを含むより複雑な他の関数が画像の境界処理を簡略化するために行う場合があることである。

この関数は、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::copyTo	(	InputArray	src,
		OutputArray	dst,
		InputArray	mask )

Python:
	cv.copyTo(	src, mask[, dst]	) ->	dst

#include <opencv2/core.hpp>

これはオーバーロードされたメンバ関数で、利便性のために(python向けに)提供されている。行列を別の行列にコピーする。演算マスクが指定されている場合、上で示した Mat::create の呼び出しによって行列が再割り当てされると、新たに割り当てられた行列はデータをコピーする前にすべてゼロで初期化される。

引数

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

countNonZero()

int cv::countNonZero

(

InputArray

src

)

Python:
	cv.countNonZero(	src	) ->	retval

#include <opencv2/core.hpp>

配列の非ゼロ要素を数える。

この関数は src 内の非ゼロ要素の個数を返す:

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

この関数はマルチチャンネル配列では機能しない。すべてのチャンネルにわたって非ゼロの配列要素を数える必要がある場合は、まず Mat::reshape を使って配列をシングルチャンネルとして再解釈する。あるいは、extractImageCOI、mixChannels、splitのいずれかを使って特定のチャンネルを抽出してもよい。

覚え書き

• CV_16F/CV_16BF/CV_Bool/CV_64U/CV_64S/CV_32U は src ではサポートされていない。
• 非ゼロ要素が存在するかどうかだけが重要な場合は、hasNonZero が役立つ。
• 非ゼロの配列要素の位置が重要な場合は、findNonZero が役立つ。

引数

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

参照

mean, meanStdDev, norm, minMaxLoc, calcCovarMatrix

findNonZero, hasNonZero

dct()

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

Python:
	cv.dct(	src[, dst[, flags]]	) ->	dst

#include <opencv2/core.hpp>

1次元または2次元配列の順方向または逆方向の離散コサイン変換を実行する。

関数 cv::dct は、1次元または2次元の浮動小数点配列の順方向または逆方向の離散コサイン変換(DCT)を実行する。

• Forward Cosine transform of a 1D vector of N elements:

  \[Y = C^{(N)} \cdot X\]

  where

  \[C^{(N)}_{jk}= \sqrt{\alpha_j/N} \cos \left ( \frac{\pi(2k+1)j}{2N} \right )\]

  and \(\alpha_0=1\), \(\alpha_j=2\) for j > 0.
• Inverse Cosine transform of a 1D vector of N elements:

  \[X = \left (C^{(N)} \right )^{-1} \cdot Y = \left (C^{(N)} \right )^T \cdot Y\]

  (since \(C^{(N)}\) is an orthogonal matrix, \(C^{(N)} \cdot \left(C^{(N)}\right)^T = I\) )
• Forward 2D Cosine transform of M x N matrix:

  \[Y = C^{(N)} \cdot X \cdot \left (C^{(N)} \right )^T\]

• Inverse 2D Cosine transform of M x N matrix:

  \[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次元変換を実行する。
• 上記のいずれにも当てはまらない場合、関数は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);

引数

src	入力の浮動小数点配列。
dst	srcと同じサイズかつ同じ型の出力配列。
flags	cv::DftFlags（DCT_*）の組み合わせとしての変換フラグ

参照

dft, getOptimalDFTSize, idct

determinant()

double cv::determinant

(

InputArray

mtx

)

Python:
	cv.determinant(	mtx	) ->	retval

#include <opencv2/core.hpp>

正方形の浮動小数点行列の行列式を返す。

関数 cv::determinant は、指定された行列の行列式を計算して返す。小さな行列( mtx.cols=mtx.rows<=3 )の場合は直接法が使われる。より大きな行列の場合、関数は部分ピボット選択付きのLU分解を使う。

対称正定値行列の場合、固有値分解を使って行列式を計算することも可能である。

引数

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

参照

trace, invert, solve, eigen, MatrixExpressions

dft()

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

Python:
	cv.dft(	src[, dst[, flags[, nonzeroRows]]]	) ->	dst

#include <opencv2/core.hpp>

1次元または2次元の浮動小数点配列の順方向または逆方向の離散フーリエ変換を実行する。

関数 cv::dft は次のいずれかを実行する。

• Forward the Fourier transform of a 1D vector of N elements:

  \[Y = F^{(N)} \cdot X,\]

  where \(F^{(N)}_{jk}=\exp(-2\pi i j k/N)\) and \(i=\sqrt{-1}\)
• Inverse the Fourier transform of a 1D vector of N elements:

  \[\begin{array}{l} X'= \left (F^{(N)} \right )^{-1} \cdot Y = \left (F^{(N)} \right )^* \cdot y \\ X = (1/N) \cdot X, \end{array}\]

  where \(F^*=\left(\textrm{Re}(F^{(N)})-\textrm{Im}(F^{(N)})\right)^T\)
• Forward the 2D Fourier transform of a M x N matrix:

  \[Y = F^{(M)} \cdot X \cdot F^{(N)}\]

• Inverse the 2D Fourier transform of a M x N matrix:

  \[\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)から借用したものである。2次元の CCS スペクトルは次のようになる。

\[\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次元変換の場合、出力は上記の行列の最初の行のようになる。

このように、関数は入力配列のフラグとサイズに応じて演算モードを選択する。

• DFT_ROWS が設定されているか、入力配列が単一行または単一列の場合、DFT_ROWS が設定されているときは、関数は行列の各行に対して1次元の順方向または逆方向変換を実行する。そうでない場合は2次元変換を実行する。
• If the input array is real and DFT_INVERSE is not set, the function performs a forward 1D or 2D transform:
  • 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 が設定されている場合、出力は入力と同じサイズの実数配列となる。関数は、フラグ DFT_INVERSE および DFT_ROWS に応じて、入力配列全体または各行を1次元または2次元の逆変換する。

DFT_SCALE が設定されている場合、スケーリングは変換後に行われる。

dctとは異なり、この関数は任意のサイズの配列をサポートする。ただし、効率的に処理されるのは、サイズが小さな素数(現在の実装では2, 3, 5)の積に因数分解できる配列のみである。そのような効率的なDFTサイズはgetOptimalDFTSizeメソッドを使って計算できる。

以下のサンプルは、2つの2次元実数配列のDFTベースの畳み込みを計算する方法を示す。

#include "opencv2/core.hpp"
#include "opencv2/core/utility.hpp"
#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui.hpp"
#include <iostream>
#include <stdio.h>
 
using namespace cv;
using namespace std;
 
static void convolveDFT(InputArray A, InputArray B, OutputArray C) {
 // Calculate the size of the output array
 int outputRows = A.rows() + B.rows() - 1;
 int outputCols = A.cols() + B.cols() - 1;
 
 // Reallocate the output array if needed
    C.create(outputRows, outputCols, 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, 0);
 
 // 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
}
static void help(const char ** argv)
{
    printf("\nThis program demonstrates the use of convolution using discrete Fourier transform (DFT)\n"
 "An image is convolved with kernel filter using DFT.\n"
 "Usage:\n %s [input -- default lena.jpg]\n", argv[0]);
}
 
const char* keys =
{
 "{help h||}{@input|lena.jpg|input image file}"
};
 
int main(int argc, const char** argv) {
 // Load the image in grayscale
    help(argv);
 CommandLineParser parser(argc, argv, keys);
 if (parser.has("help"))
    {
        help(argv);
 return 0;
    }
 string filename = parser.get<string>(0);
 Mat img = imread(samples::findFile(filename), IMREAD_GRAYSCALE);
 
 // Check if the image is loaded successfully
 if (img.empty()) {
        std::cerr << "Error: Image not loaded!" << std::endl;
 return -1;
    }
 
 // Convert the image to CV_32F
 Mat img_32f;
    img.convertTo(img_32f, CV_32F);
 
 float kernelData[9] = { 1.0f/9, 1.0f/9, 1.0f/9, 1.0f/9, 1.0f/9, 1.0f/9, 1.0f/9, 1.0f/9, 1.0f/9 }; // example of blur filter, can be changed to other filter as well.
 Mat kernel(3, 3, CV_32F, kernelData);
 
 // Perform convolution of the image with the sharpening kernel
 Mat result;
    convolveDFT(img_32f, kernel, result);
 
 // Normalize the result for better visualization
 normalize(result, result, 0, 255, NORM_MINMAX);
 
 // Convert result back to 8-bit for display
 Mat result_8u;
    result.convertTo(result_8u, CV_8U);
 
 // Display the images
 imshow("Original Image", img);
 imshow("Output Image", result_8u);
 
 waitKey(0); // Wait for a key press to close the windows
 return 0;
}

DFTベースの畳み込みの例

このサンプルを最適化するには、以下の手法を検討するとよい。

• 順方向変換の呼び出しに nonzeroRows != 0 が渡され、かつAとBがそれぞれtempAとtempBの左上隅にコピーされるため、tempAとtempB全体をクリアする必要はない。tempA.cols - A.cols ( tempB.cols - B.cols) の右端の列をクリアするだけでよい。
• このDFTベースの畳み込みは、特にBがAより著しく小さい場合やその逆の場合、大きな配列全体に適用する必要はない。代わりに、部分ごとに畳み込みを計算できる。これを行うには、出力配列Cを複数のタイルに分割する必要がある。各タイルについて、そのタイルの畳み込みを計算するためにAとBのどの部分が必要かを推定する。Cのタイルが小さすぎると、重複した処理のために速度が大幅に低下する。極端な場合、Cの各タイルが単一ピクセルになると、アルゴリズムは素朴な畳み込みアルゴリズムと等価になる。タイルが大きすぎると、一時配列tempAとtempBが大きくなりすぎ、キャッシュ局所性の悪化によっても速度低下が生じる。したがって、最適なタイルサイズはその中間のどこかにある。
• Cの異なるタイルを並列に計算でき、それによって畳み込みを部分ごとに行う場合、そのループはスレッド化できる。

上記の改善はすべて matchTemplate および filter2D に実装されている。したがって、これらを使えば、上記の理論的に最適な実装よりもさらに良い性能が得られる。ただし、これら2つの関数は実際には畳み込みではなく相互相関を計算するため、2番目の畳み込みオペランドBをflipを使って垂直方向および水平方向に「反転」させる必要がある。

覚え書き

• 離散フーリエ変換を使った例は opencv_source_code/samples/cpp/dft.cpp にある。
• (Python) dft機能を使ってウィーナー逆畳み込みを実行する例は opencv_source/samples/python/deconvolution.py にある。
• (Python) フーリエ画像の象限を並べ替える例は opencv_source/samples/python/dft.py にある。

引数

src	実数または複素数の入力配列。
dst	サイズと型がフラグに依存する出力配列。
flags	DftFlags の組み合わせを表す変換フラグ
nonzeroRows	このパラメータが0でない場合、関数は入力配列の最初のnonzeroRows行のみ（DFT_INVERSE が設定されていない場合）、または出力配列の最初のnonzeroRowsのみ（DFT_INVERSE が設定されている場合）が非ゼロを含むと仮定する。これにより、残りの行をより効率的に処理して時間を節約できる。この手法はDFTを用いた配列の相互相関や畳み込みの計算に非常に有用である。

参照

dct, getOptimalDFTSize, mulSpectrums, filter2D, matchTemplate, flip, cartToPolar, magnitude, phase

divide() [1/2]

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

Python:
	cv.divide(	src1, src2[, dst[, scale[, dtype]]]	) ->	dst
	cv.divide(	scale, src2[, dst[, dtype]]	) ->	dst

#include <opencv2/core.hpp>

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

divide() [2/2]

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

Python:
	cv.divide(	src1, src2[, dst[, scale[, dtype]]]	) ->	dst
	cv.divide(	scale, src2[, dst[, dtype]]	) ->	dst

#include <opencv2/core.hpp>

2つの配列、またはスカラーを配列で、要素ごとに除算する。

関数 cv::divide は、一方の配列を他方の配列で除算する。

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

あるいは src1 がない場合は、スカラーを配列で除算する。

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

マルチチャンネル配列の各チャンネルは独立に処理される。

整数型の場合、src2(I)がゼロのとき、dst(I)もゼロになる。

覚え書き

浮動小数点データの場合、src2(I)がゼロのときの特別な定義済み動作はない。通常の浮動小数点除算が使われる。浮動小数点データに対しては正しいIEEE-754の挙動(NaN、Infの結果値を含む)が期待される。

出力配列のビット深度が CV_32S の場合、飽和処理は適用されない。オーバーフローした場合には符号が誤った結果が得られることさえある。

(Python) src1/src2が単一の数値である場合とタプル/配列である場合で挙動が異なる点に注意すること。divide(src,X) は divide(src,(X,X,X,X)) を意味する。divide(src,(X,)) は divide(src,(X,0,0,0)) を意味する。

引数

src1	1番目の入力配列。
src2	src1と同じサイズかつ同じ型の2番目の入力配列。
scale	スカラ係数。
dst	src2と同じサイズかつ同じ型の出力配列。
dtype	出力配列の省略可能なビット深度。-1の場合、dstのビット深度は src2.depth() になる。ただし配列同士の除算の場合、-1を渡せるのは src1.depth()==src2.depth() のときのみである。

参照

multiply, add, subtract

divSpectrums()

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

Python:
	cv.divSpectrums(	a, b, flags[, c[, conjB]]	) ->	c

#include <opencv2/core.hpp>

1番目のフーリエスペクトルを2番目のフーリエスペクトルで要素ごとに除算する。

関数 cv::divSpectrums は、1番目の配列を2番目の配列で要素ごとに除算する。これらの配列は、実数または複素数のフーリエ変換の結果であるCCSパック形式または複素行列である。

引数

a	1番目の入力配列。
b	src1 と同じサイズおよび型の2番目の入力配列。
c	src1 と同じサイズおよび型の出力配列。
flags	演算フラグ。現在サポートされている唯一のフラグは cv::DFT_ROWS で、これは src1 と src2 の各行が独立した1次元フーリエスペクトルであることを示す。このフラグを使いたくない場合は、単に値として 0 を加える。
conjB	乗算の前に2番目の入力配列を共役にするか（true）しないか（false）を指定する省略可能なフラグ。

eigen()

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

Python:
	cv.eigen(	src[, eigenvalues[, eigenvectors]]	) ->	retval, eigenvalues, eigenvectors

#include <opencv2/core.hpp>

対称行列の固有値と固有ベクトルを計算する。

関数 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()

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

Python:
	cv.eigenNonSymmetric(	src[, eigenvalues[, eigenvectors]]	) ->	eigenvalues, eigenvectors

#include <opencv2/core.hpp>

非対称行列の固有値と固有ベクトルを計算する(実固有値のみ)。

覚え書き

実固有値を仮定する。

関数は、正方行列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()

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

Python:
	cv.exp(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

配列の各要素の指数を計算する。

関数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()

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

Python:
	cv.extractChannel(	src, coi[, dst]	) ->	dst

#include <opencv2/core.hpp>

srcから単一のチャンネルを抽出する(coiは0始まりのインデックス)。

引数

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

参照

mixChannels, split

findNonZero()

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

Python:
	cv.findNonZero(	src[, idx]	) ->	idx

#include <opencv2/core.hpp>

非ゼロピクセルの位置のリストを返す。

二値行列（おそらく 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];

この関数はマルチチャンネル配列では動作しない。全チャンネルにわたって非ゼロ要素を見つける必要がある場合は、まず Mat::reshape を使って配列をシングルチャンネルとして再解釈する。あるいは、extractImageCOI、mixChannels、split のいずれかを使って特定のチャンネルを抽出してもよい。

覚え書き

• CV_16F/CV_16BF/CV_Bool/CV_64U/CV_64S/CV_32U は src ではサポートされていない。
• 非ゼロ配列要素の個数だけが重要な場合は、countNonZero が役立つ。
• 非ゼロ要素が存在するかどうかだけが重要な場合は、hasNonZero が役立つ。

引数

src	シングルチャンネル配列
idx	出力配列。型は cv::Mat または std::vector<Point> で、入力中の非ゼロインデックスに対応する

参照

countNonZero, hasNonZero

finiteMask()

void cv::finiteMask	(	InputArray	src,
		OutputArray	mask )

Python:
	cv.finiteMask(	src[, mask]	) ->	mask

#include <opencv2/core.hpp>

有限の浮動小数点値（すなわち NaN でも Inf でもない値）のマスクを生成する。

すべてのチャンネルが有限である場合、要素は 255（すべてのビットが1）に設定される。

引数

src	入力行列。1～4チャンネルのfloatまたはdouble要素を含む必要がある
mask	入力と同じサイズで型 CV_8UC1 の出力行列

flip()

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

Python:
	cv.flip(	src, flipCode[, dst]	) ->	dst

#include <opencv2/core.hpp>

2次元配列を垂直軸、水平軸、またはその両方の軸を中心に反転する。

関数 cv::flip は、配列を3種類のいずれかの方法で反転する（行と列のインデックスは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* OS 上での動画処理における典型的な操作である。画像の水平反転に続けて水平方向のシフトと絶対差分の計算を行い、垂直軸に対する対称性を調べる（flipCode > 0）。画像の水平・垂直の同時反転に続けてシフトと絶対差分の計算を行い、中心対称性を調べる（flipCode < 0）。点配列の順序を逆転する（flipCode > 0 または flipCode == 0）。

引数

src	入力配列。
dst	srcと同じサイズかつ同じ型の出力配列。
flipCode	配列を反転する方法を指定するフラグ。0はx軸まわりの反転を意味し、正の値（例えば1）はy軸まわりの反転を意味する。負の値（例えば-1）は両軸まわりの反転を意味する。

参照

transpose, repeat, completeSymm

flipND()

void cv::flipND	(	InputArray	src,
		OutputArray	dst,
		int	axis )

Python:
	cv.flipND(	src, axis[, dst]	) ->	dst

#include <opencv2/core.hpp>

n次元配列を指定した軸を中心に反転する。

引数

src	入力配列
dst	srcと同じ形状を持つ出力配列
axis	反転を行う軸。0 <= axis < src.dims。

gemm()

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

Python:
	cv.gemm(	src1, src2, alpha, src3, beta[, dst[, flags]]	) ->	dst

#include <opencv2/core.hpp>

一般化行列乗算を実行する。

関数 cv::gemm は、BLAS レベル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チャンネル）データの場合は、複素行列乗算を実行する。

この関数は行列式（matrix expression）で置き換えられる。例えば、上記の呼び出しは次のように置き換えられる。

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

引数

src1	乗算される1番目の入力行列。実数（CV_32FC1, CV_64FC1）または複素数（CV_32FC2, CV_64FC2）が可能。
src2	src1と同じ型の、乗算される2番目の入力行列。
alpha	行列積の重み。
src3	行列積に加算される3番目の省略可能なデルタ行列。src1およびsrc2と同じ型でなければならない。
beta	src3の重み。
dst	出力行列。適切なサイズを持ち、入力行列と同じ型である。
flags	演算フラグ（cv::GemmFlags）

参照

mulTransposed, transform

getOptimalDFTSize()

int cv::getOptimalDFTSize

(

int

vecsize

)

Python:
	cv.getOptimalDFTSize(	vecsize	) ->	retval

#include <opencv2/core.hpp>

指定したベクトルサイズに対する最適なDFTサイズを返す。

DFTの性能はベクトルサイズに対して単調な関数ではない。したがって、2つの配列の畳み込みを計算したり、配列のスペクトル解析を行ったりする際には、入力データをゼロでパディングして、元のものよりはるかに高速に変換できる少し大きめの配列にするのが一般的に有効である。サイズが2のべき乗（2, 4, 8, 16, 32, ...）の配列が最も高速に処理できる。ただし、サイズが2と3と5の積になっている配列（例えば 300 = 5*5*3*2*2）も、かなり効率的に処理される。

関数 cv::getOptimalDFTSize は、vecsize 以上の最小の数 N であって、サイズ N のベクトルのDFTが効率的に処理できるようなものを返す。現在の実装では、ある整数 p, q, r に対して N = 2 ^p^ * 3 ^q^ * 5 ^r^ となる。

vecsize が大きすぎる場合（INT_MAX に非常に近い場合）、この関数は負の数を返す。

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

引数

vecsize

ベクトルのサイズ。

参照

dft, dct, idft, idct, mulSpectrums

hasNonZero()

bool cv::hasNonZero

(

InputArray

src

)

Python:
	cv.hasNonZero(	src	) ->	retval

#include <opencv2/core.hpp>

少なくとも1つの非ゼロ配列要素が存在するかどうかを調べる。

この関数は src に非ゼロ要素が存在するかどうかを返す。

この関数はマルチチャンネル配列では動作しない。全チャンネルにわたって非ゼロ配列要素を調べる必要がある場合は、まず Mat::reshape を使って配列をシングルチャンネルとして再解釈する。あるいは、extractImageCOI、mixChannels、split のいずれかを使って特定のチャンネルを抽出してもよい。

覚え書き

• CV_16F/CV_16BF/CV_Bool/CV_64U/CV_64S/CV_32U は src ではサポートされていない。
• 非ゼロの配列要素の位置が重要な場合は、findNonZero が役立つ。
• 非ゼロ配列要素の個数が重要な場合は、countNonZero が役立つ。

引数

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

参照

mean, meanStdDev, norm, minMaxLoc, calcCovarMatrix

findNonZero, countNonZero

hconcat() [1/3]

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

Python:
	cv.hconcat(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

指定した行列に対して水平方向の連結を適用する。

この関数は、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の列数の合計となる。

参照

cv::vconcat(const Mat*, size_t, OutputArray),

cv::vconcat(InputArrayOfArrays, OutputArray) および

cv::vconcat(InputArray, InputArray, OutputArray)

hconcat() [2/3]

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

Python:
	cv.hconcat(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

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

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の列数の合計となる。

hconcat() [3/3]

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

Python:
	cv.hconcat(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

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

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の列数の合計となる。ビット深度も同じである。

idct()

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

Python:
	cv.idct(	src[, dst[, flags]]	) ->	dst

#include <opencv2/core.hpp>

1次元または2次元配列の逆離散コサイン変換を計算する。

idct(src, dst, flags) は dct(src, dst, flags | DCT_INVERSE) と等価である。

引数

src	入力の浮動小数点シングルチャンネル配列。
dst	srcと同じサイズかつ同じ型の出力配列。
flags	演算フラグ。

参照

dct, dft, idft, getOptimalDFTSize

idft()

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

Python:
	cv.idft(	src[, dst[, flags[, nonzeroRows]]]	) ->	dst

#include <opencv2/core.hpp>

1次元または2次元配列の逆離散フーリエ変換を計算する。

idft(src, dst, flags) は dft(src, dst, flags | DFT_INVERSE) と等価である。

覚え書き

dft と idft はいずれもデフォルトでは結果をスケーリングしない。したがって、これらの変換を相互に逆変換となるようにするには、dft または idft のいずれか一方に DFT_SCALE を明示的に渡す必要がある。

参照

dft, dct, idct, mulSpectrums, getOptimalDFTSize

引数

src	入力の浮動小数点実数または複素数配列。
dst	サイズと型がフラグに依存する出力配列。
flags	演算フラグ（dftおよび DftFlags を参照）。
nonzeroRows	処理するdstの行数。残りの行の内容は未定義である（dftの説明にある畳み込みのサンプルを参照）。

inRange()

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

Python:
	cv.inRange(	src, lowerb, upperb[, dst]	) ->	dst

#include <opencv2/core.hpp>

配列の要素が、他の2つの配列の要素の間に収まっているかどうかを調べる。

この関数は次のように範囲を調べる。

• For every element of a single-channel input array:

  \[\texttt{dst} (I)= \texttt{lowerb} (I)_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb} (I)_0\]

• For two-channel arrays:

  \[\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) が指定された1次元、2次元、3次元、... のボックス内にある場合、dst (I) は255（すべて 1 のビット）に設定され、そうでない場合は0に設定される。

下限・上限の引数がスカラーの場合、上記の式中の lowerb と upperb のインデックス (I) は省略すべきである。

引数

src	1番目の入力配列。
lowerb	下限の境界配列またはスカラ（この値を含む）。
upperb	上限（この値を含む）を表す配列またはスカラ。
dst	src と同じサイズで CV_8U 型の出力配列。

insertChannel()

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

Python:
	cv.insertChannel(	src, dst, coi	) ->	dst

#include <opencv2/core.hpp>

単一のチャンネルを dst に挿入する（coi は0始まりのインデックス）。

引数

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

参照

mixChannels, merge

invert()

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

Python:
	cv.invert(	src[, dst[, flags]]	) ->	retval, dst

#include <opencv2/core.hpp>

行列の逆行列または擬似逆行列を求める。

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

DECOMP_LU 法の場合、逆行列が正常に計算されたときは非ゼロ値を返し、src が特異のときは0を返す。

DECOMP_SVD 法の場合、src の逆条件数（最小の特異値と最大の特異値の比）を返し、src が特異のときは0を返す。SVD 法は、src が特異の場合は擬似逆行列を計算する。

DECOMP_LU と同様に、DECOMP_CHOLESKY 法は、対称かつ正定値でもある非特異の正方行列に対してのみ動作する。この場合、関数は反転した行列を dst に格納して非ゼロを返す。それ以外の場合は0を返す。

引数

src	入力の浮動小数点 M x N 行列。
dst	サイズが N x M で src と同じ型の出力行列。
flags	逆行列の計算方法（cv::DecompTypes）

参照

solve, SVD

log()

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

Python:
	cv.log(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

配列の各要素の自然対数を計算する。

関数 cv::log は、入力配列の各要素の自然対数を計算する。

\[\texttt{dst} (I) = \log (\texttt{src}(I)) \]

ゼロ、負の値、および特殊な値（NaN, Inf）に対する出力は未定義である。

引数

src	入力配列。
dst	srcと同じサイズかつ同じ型の出力配列。

参照

exp, cartToPolar, polarToCart, phase, pow, sqrt, magnitude

LUT()

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

Python:
	cv.LUT(	src, lut[, dst]	) ->	dst

#include <opencv2/core.hpp>

配列のルックアップテーブル変換を実行する。

関数 LUT は、ルックアップテーブルの値で出力配列を埋める。各エントリのインデックスは入力配列から取られる。すなわち、この関数は src の各要素を次のように処理する。

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

ここで

\[d = \forkthree{0}{if \(\texttt{src}\) has depth \(\texttt{CV_8U}\) or \(\texttt{CV_16U}\)}{128}{if \(\texttt{src}\) has depth \(\texttt{CV_8S}\)}{32768}{if \(\texttt{src}\) has depth \(\texttt{CV_16S}\)}\]

引数

src	8ビットまたは16ビット整数要素の入力配列。
lut	256要素（src のビット深度が CV_8U または CV_8S の場合）または 65536 要素（src のビット深度が CV_16U または CV_16S の場合）のルックアップテーブル。マルチチャンネルの入力配列の場合、テーブルはシングルチャンネル（この場合は全チャンネルで同じテーブルが使われる）か、入力配列と同じチャンネル数を持つ必要がある。
dst	src と同じサイズおよびチャンネル数で、lut と同じビット深度の出力配列。

参照

convertScaleAbs, Mat::convertTo

magnitude()

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

Python:
	cv.magnitude(	x, y[, magnitude]	) ->	magnitude

#include <opencv2/core.hpp>

2次元ベクトルの大きさを計算する。

関数 cv::magnitude は、x 配列と 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()

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

Python:
	cv.Mahalanobis(	v1, v2, icovar	) ->	retval

#include <opencv2/core.hpp>

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]

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

Python:
	cv.max(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

これはオーバーロードされたメンバ関数であり、利便性のために提供されている。受け取る引数のみが上記の関数と異なる。const _Tp& std::min(const _Tp&, const _Tp&, _Compare) との競合を避けるために必要である。

max() [2/3]

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

Python:
	cv.max(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

これはオーバーロードされたメンバ関数であり、利便性のために提供されている。受け取る引数のみが上記の関数と異なる。const _Tp& std::min(const _Tp&, const _Tp&, _Compare) との競合を避けるために必要である。

max() [3/3]

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

Python:
	cv.max(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

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

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

Python:
	cv.mean(	src[, mask]	) ->	retval

#include <opencv2/core.hpp>

配列要素の平均値（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	結果を Scalar_ に格納できるよう、チャンネル数が1から4の入力配列。
mask	型 CV_8U、CV_8S または CV_Bool の省略可能な操作マスク。

参照

countNonZero, meanStdDev, norm, minMaxLoc

meanStdDev()

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

Python:
	cv.meanStdDev(	src[, mean[, stddev[, mask]]]	) ->	mean, stddev

#include <opencv2/core.hpp>

配列要素の平均と標準偏差を計算する。

関数 cv::meanStdDev は、配列要素の平均と標準偏差 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() に reshape し（行列が連続である場合のみ可能）、その行列を calcCovarMatrix に渡せばよい。

引数

src	結果を Scalar_ に格納できるよう、チャンネル数が1から4の入力配列。
mean	出力引数: 計算された平均値。
stddev	出力引数: 計算された標準偏差。
mask	型 CV_8U、CV_8S または CV_Bool の省略可能な操作マスク。

参照

countNonZero, mean, norm, minMaxLoc, calcCovarMatrix

merge() [1/2]

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

Python:
	cv.merge(	mv[, dst]	) ->	dst

#include <opencv2/core.hpp>

複数のシングルチャンネル配列から1つのマルチチャンネル配列を作成する。

関数 cv::merge は、複数の配列をマージして1つのマルチチャンネル配列を作る。すなわち、出力配列の各要素は入力配列の要素の連結となり、i 番目の入力配列の要素は mv[i].channels() 要素のベクトルとして扱われる。

関数 cv::split は逆の操作を行う。チャンネルをほかのより高度な方法で並べ替える必要がある場合は、cv::mixChannels を使う。

次の例は、3つのシングルチャンネル行列を1つの3チャンネル行列にマージする方法を示している。

 Mat m1 = Mat_<uchar>({2,2}, {1,4,7,10});
 Mat m2 = Mat_<uchar>({2,2}, {2,5,8,11});
 Mat m3 = Mat_<uchar>({2,2}, {3,6,9,12});
 
 Mat channels[3] = {m1, m2, m3};
 Mat m;
 merge(channels, 3, m);
 /*
    m =
    [  1,   2,   3,   4,   5,   6;
       7,   8,   9,  10,  11,  12]
    m.channels() = 3
    */

引数

mv	結合する行列の入力配列。mv 内のすべての行列は同じサイズおよび同じビット深度である必要がある。
count	mv が単純なC配列の場合の入力行列の数。0より大きい必要がある。
dst	mv[0] と同じサイズおよび同じビット深度の出力配列。チャンネル数は count 引数と等しくなる。

参照

mixChannels, split, Mat::reshape

merge() [2/2]

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

Python:
	cv.merge(	mv[, dst]	) ->	dst

#include <opencv2/core.hpp>

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

引数

mv	結合する行列の入力ベクトル。mv 内のすべての行列は同じサイズおよび同じビット深度である必要がある。
dst	mv[0] と同じサイズおよび同じビット深度の出力配列。チャンネル数は行列配列の総チャンネル数になる。

min() [1/3]

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

Python:
	cv.min(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

これはオーバーロードされたメンバ関数であり、利便性のために提供されている。受け取る引数のみが上記の関数と異なる。const _Tp& std::min(const _Tp&, const _Tp&, _Compare) との競合を避けるために必要である。

min() [2/3]

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

Python:
	cv.min(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

これはオーバーロードされたメンバ関数であり、利便性のために提供されている。受け取る引数のみが上記の関数と異なる。const _Tp& std::min(const _Tp&, const _Tp&, _Compare) との競合を避けるために必要である。

min() [3/3]

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

Python:
	cv.min(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

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

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

#include <opencv2/core.hpp>

配列内の大域的な最小値と最大値を求める。

関数 cv::minMaxIdx は最小要素値と最大要素値、およびそれらの位置を求める。極値は配列全体にわたって探索される。ただし mask が空配列でない場合は、指定された配列領域内で探索される。疎行列の場合、最小値は非ゼロ要素のみの中から求められる。マルチチャンネル入力は、mask と極値インデックス（nullptr とする必要がある）を指定しない場合にサポートされる。

覚え書き

minIdx が NULL でない場合、src が単一行または単一列の行列であっても、少なくとも2要素を持たなければならない（maxIdx も同様）。OpenCV では（MATLAB に倣って）各配列は少なくとも2次元を持つ。すなわち単一列の行列は Mx1 行列（したがって minIdx/maxIdx は (i1,0)/(i2,0) となる）であり、単一行の行列は 1xN 行列（したがって minIdx/maxIdx は (0,j1)/(0,j2) となる）である。

CV_16F/CV_16BF/CV_Bool/CV_64U/CV_64S/CV_32U は src ではサポートされていない。

引数

src	シングルチャンネルの入力配列。
minVal	返される最小値へのポインタ。不要な場合は NULL を指定する。
maxVal	返される最大値へのポインタ。不要な場合は NULL を指定する。
minIdx	返される最小値の位置へのポインタ（nD の場合）。不要な場合は NULL を指定する。指定する場合は src.dims 個の要素を持つ配列を指す必要があり、各次元における最小要素の座標がそこに順に格納される。
maxIdx	返される最大値の位置へのポインタ（nD の場合）。不要な場合は NULL を指定する。
mask	指定された配列領域

minMaxLoc() [1/2]

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

Python:
	cv.minMaxLoc(	src[, mask]	) ->	minVal, maxVal, minLoc, maxLoc

#include <opencv2/core.hpp>

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

引数

a	シングルチャンネルの入力配列。
minVal	返される最小値へのポインタ。不要な場合は NULL を指定する。
maxVal	返される最大値へのポインタ。不要な場合は NULL を指定する。
minIdx	返される最小値の位置へのポインタ（nD の場合）。不要な場合は NULL を指定する。指定する場合は src.dims 個の要素を持つ配列を指す必要があり、各次元における最小要素の座標がそこに順に格納される。
maxIdx	返される最大値の位置へのポインタ（nD の場合）。不要な場合は NULL を指定する。

minMaxLoc() [2/2]

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

Python:
	cv.minMaxLoc(	src[, mask]	) ->	minVal, maxVal, minLoc, maxLoc

#include <opencv2/core.hpp>

配列内の大域的な最小値と最大値を求める。

関数 cv::minMaxLoc は、最小および最大の要素値とその位置を求める。極値は配列全体にわたって探索されるが、mask が空の配列でない場合は、指定された配列領域内で探索される。

C++ では、入力がマルチチャンネルの場合、minLoc、maxLoc、mask の引数は省略すべきである（すなわち、それぞれ NULL、NULL、noArray() のままにする）。これらの引数はマルチチャンネル入力配列ではサポートされない。マルチチャンネル入力を扱う際に minLoc、maxLoc、または mask の引数が必要な場合は、まず Mat::reshape を使って配列をシングルチャンネルとして再解釈する。あるいは、extractImageCOI、mixChannels、または split のいずれかを使って特定のチャンネルを取り出すこともできる。

Python では、バインディング生成プロセスの制約により（minLoc と maxLoc を NULL に設定する方法がない）、マルチチャンネル入力は一切サポートされない。回避策として、各チャンネルを個別に処理するか、NumPy を使って同等の機能を実現する。

覚え書き

CV_16F/CV_16BF/CV_Bool/CV_64U/CV_64S/CV_32U は src ではサポートされていない。

引数

src	シングルチャンネルの入力配列。
minVal	返される最小値へのポインタ。不要な場合は NULL を指定する。
maxVal	返される最大値へのポインタ。不要な場合は NULL を指定する。
minLoc	返される最小値の位置へのポインタ（2D の場合）。不要な場合は NULL を指定する。
maxLoc	返される最大値の位置へのポインタ（2D の場合）。不要な場合は NULL を指定する。
mask	型 CV_8U、CV_8S または CV_Bool の部分配列を選択するために用いる省略可能なマスク。

参照

max, min, reduceArgMin, reduceArgMax, compare, inRange, extractImageCOI, mixChannels, split, Mat::reshape

mixChannels() [1/3]

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

Python:
	cv.mixChannels(	src, dst, fromTo	) ->	dst

#include <opencv2/core.hpp>

入力配列の指定したチャンネルを出力配列の指定したチャンネルにコピーする。

関数 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[k*2] は src 内の入力チャンネルの0始まりのインデックス、fromTo[k*2+1] は dst 内の出力チャンネルのインデックスである。チャンネルの連続した番号付けが使われ、1番目の入力画像のチャンネルは 0 から src[0].channels()-1 までインデックス付けされ、2番目の入力画像のチャンネルは src[0].channels() から src[0].channels() + src[1].channels()-1 までインデックス付けされる（以下同様）。同じ方式が出力画像のチャンネルにも使われる。特別なケースとして、fromTo[k*2] が負の場合、対応する出力チャンネルはゼロで埋められる。
npairs	fromTo 内のインデックスペアの数。

参照

split, merge, extractChannel, insertChannel, cvtColor

mixChannels() [2/3]

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

Python:
	cv.mixChannels(	src, dst, fromTo	) ->	dst

#include <opencv2/core.hpp>

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

引数

src	入力配列または行列のベクトル。すべての行列は同じサイズおよび同じビット深度である必要がある。
dst	出力配列または行列のベクトル。すべての行列は あらかじめ確保されている必要がある。そのサイズとビット深度は src[0] と同じである必要がある。
fromTo	どのチャンネルをどこへコピーするかを指定するインデックスペアの配列。fromTo[k*2] は src 内の入力チャンネルの0始まりのインデックス、fromTo[k*2+1] は dst 内の出力チャンネルのインデックスである。チャンネルの連続した番号付けが使われ、1番目の入力画像のチャンネルは 0 から src[0].channels()-1 までインデックス付けされ、2番目の入力画像のチャンネルは src[0].channels() から src[0].channels() + src[1].channels()-1 までインデックス付けされる（以下同様）。同じ方式が出力画像のチャンネルにも使われる。特別なケースとして、fromTo[k*2] が負の場合、対応する出力チャンネルはゼロで埋められる。
npairs	fromTo 内のインデックスペアの数。

mixChannels() [3/3]

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

Python:
	cv.mixChannels(	src, dst, fromTo	) ->	dst

#include <opencv2/core.hpp>

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

引数

src	入力配列または行列のベクトル。すべての行列は同じサイズおよび同じビット深度である必要がある。
dst	出力配列または行列のベクトル。すべての行列は あらかじめ確保されている必要がある。そのサイズとビット深度は src[0] と同じである必要がある。
fromTo	どのチャンネルをどこへコピーするかを指定するインデックスペアの配列。fromTo[k*2] は src 内の入力チャンネルの0始まりのインデックス、fromTo[k*2+1] は dst 内の出力チャンネルのインデックスである。チャンネルの連続した番号付けが使われ、1番目の入力画像のチャンネルは 0 から src[0].channels()-1 までインデックス付けされ、2番目の入力画像のチャンネルは src[0].channels() から src[0].channels() + src[1].channels()-1 までインデックス付けされる（以下同様）。同じ方式が出力画像のチャンネルにも使われる。特別なケースとして、fromTo[k*2] が負の場合、対応する出力チャンネルはゼロで埋められる。

mulSpectrums()

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

Python:
	cv.mulSpectrums(	a, b, flags[, c[, conjB]]	) ->	c

#include <opencv2/core.hpp>

2つのフーリエスペクトルの要素ごとの乗算を行う。

関数 cv::mulSpectrums は、実数または複素数のフーリエ変換の結果である2つの CCS パック行列または複素行列の要素ごとの乗算を行う。

この関数は dft および idft と組み合わせて、2つの配列の畳み込み（conjB=false を渡す）または相関（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()

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

Python:
	cv.multiply(	src1, src2[, dst[, scale[, dtype]]]	) ->	dst

#include <opencv2/core.hpp>

2つの配列の要素ごとのスケーリングされた積を計算する。

関数 multiply は、2つの配列の要素ごとの積を計算する。

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

最初の関数には、MatrixExpressions 向けのバリアントも存在する。Mat::mul を参照。

要素ごとではない行列積については、gemm を参照。

覚え書き

出力配列のビット深度が CV_32S の場合、飽和処理は適用されない。オーバーフローした場合には符号が誤った結果が得られることさえある。

（Python）src1/src2 が単一の数値である場合と、タプル/配列である場合とで挙動が異なる点に注意。multiply(src,X) は multiply(src,(X,X,X,X)) を意味する。multiply(src,(X,)) は multiply(src,(X,0,0,0)) を意味する。

引数

src1	1番目の入力配列。
src2	src1 と同じサイズおよび同じ型の2番目の入力配列。
dst	src1 と同じサイズおよび型の出力配列。
scale	省略可能なスケール係数。
dtype	出力配列の省略可能なビット深度

参照

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

mulTransposed()

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

Python:
	cv.mulTransposed(	src, aTa[, dst[, delta[, scale[, dtype]]]]	) ->	dst

#include <opencv2/core.hpp>

行列とその転置との積を計算する。

関数 cv::mulTransposed は、src とその転置との積を計算する。

\[\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\]

それ以外の場合。この関数は共分散行列の計算に使用される。delta がゼロの場合、B=A' のときに一般的な行列積 A*B のより高速な代替手段として使用できる。

引数

src	シングルチャンネルの入力行列。gemm と異なり、この関数は浮動小数点行列以外も乗算できることに注意。
dst	出力の正方行列。
aTa	乗算の順序を指定するフラグ。下記の説明を参照。
delta	乗算の前に src から減算される省略可能な delta 行列。行列が空（delta=noArray()）の場合はゼロとみなされ、何も減算されない。src と同じサイズの場合は、そのまま減算される。それ以外の場合は、src 全体を覆うように「繰り返し」（repeat を参照）てから減算される。delta 行列が空でない場合、その型は生成される出力行列の型と同じである必要がある。下記の dtype 引数の説明を参照。
scale	行列積に対する省略可能なスケール係数。
dtype	出力行列の省略可能な型。負の場合、出力行列は src と同じ型になる。それ以外の場合は type=CV_MAT_DEPTH(dtype) となり、CV_32F または CV_64F のいずれかである必要がある。

参照

calcCovarMatrix, gemm, repeat, reduce

norm() [1/3]

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

Python:
	cv.norm(	src1[, normType[, mask]]	) ->	retval
	cv.norm(	src1, src2[, normType[, mask]]	) ->	retval

#include <opencv2/core.hpp>

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

引数

src	1番目の入力配列。
normType	ノルムの種類（NormTypes を参照）。

norm() [2/3]

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

Python:
	cv.norm(	src1[, normType[, mask]]	) ->	retval
	cv.norm(	src1, src2[, normType[, mask]]	) ->	retval

#include <opencv2/core.hpp>

絶対差分ノルムまたは相対差分ノルムを計算する。

このバージョンの cv::norm は、配列 src1 と src2 の絶対差分ノルムまたは相対差分ノルムを計算する。計算するノルムの種類は NormTypes を用いて指定する。

引数

src1	1番目の入力配列。
src2	src1 と同じサイズおよび同じ型の2番目の入力配列。
normType	ノルムの種類（NormTypes を参照）。
mask	省略可能な操作マスク。src1 と同じサイズで、型 CV_8UC1、CV_8S1 または CV_BoolC1 でなければならない。

norm() [3/3]

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

Python:
	cv.norm(	src1[, normType[, mask]]	) ->	retval
	cv.norm(	src1, src2[, normType[, mask]]	) ->	retval

#include <opencv2/core.hpp>

配列の絶対ノルムを計算する。

このバージョンの norm は、src1 の絶対ノルムを計算する。計算するノルムの種類は NormTypes を用いて指定する。

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

\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}\) のすべての値を示している。注目すべき点として、この例の関数 \( r(x) \) について、\( L_{1} \) ノルムが上限を、\( L_{\infty} \) ノルムが下限を形成している。

mask 引数が指定され、かつ空でない場合、ノルムは

normType が指定されない場合は NORM_L2 が使用される。mask によって指定された領域内でのみ計算される。

マルチチャンネル入力配列はシングルチャンネル配列として扱われる。すなわち、すべてのチャンネルの結果が結合される。

Hamming ノルムは、CV_8U のビット深度を持つ配列でのみ計算できる。

引数

src1	1番目の入力配列。
normType	ノルムの種類（NormTypes を参照）。
mask	省略可能な操作マスク。src1 と同じサイズで、型 CV_8UC1、CV_8SC1 または CV_BoolC1 でなければならない。

normalize() [1/2]

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

Python:
	cv.normalize(	src, dst[, alpha[, beta[, norm_type[, dtype[, mask]]]]]	) ->	dst

#include <opencv2/core.hpp>

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

引数

src	入力配列。
dst	src と同じサイズの出力配列。
alpha	正規化先のノルム値、またはレンジ正規化の場合は範囲の下限。
normType	正規化の種類（cv::NormTypes を参照）。

normalize() [2/2]

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

Python:
	cv.normalize(	src, dst[, alpha[, beta[, norm_type[, dtype[, mask]]]]]	) ->	dst

#include <opencv2/core.hpp>

配列のノルムまたは値の範囲を正規化する。

関数 cv::normalize は、入力配列の要素をスケーリングおよびシフトすることで、次のように正規化する。

\[\| \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 のとき（密な配列のみ）。省略可能な mask は、正規化する部分配列を指定する。これは、ノルムまたは最小値・最大値が部分配列にわたって計算され、その後この部分配列が正規化されるように変更されることを意味する。ノルムまたは最小値・最大値の計算にのみ mask を使用しつつ配列全体を変更したい場合は、norm と Mat::convertTo を使用できる。

疎行列の場合、非ゼロの値のみが解析および変換される。このため、疎行列に対する範囲変換は、ゼロレベルをシフトさせる可能性があるため許可されない。

いくつかの正の値を持つ例のデータでの使用例：

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

覚え書き

Due to rounding issues, min-max normalization can result in values outside provided boundaries. If exact range conformity is needed, following workarounds can be used:

• 倍精度浮動小数点（dtype = CV_64F）を使用する
• 値を手動でクリップする（cv::max(res, left_bound, res)、cv::min(res, right_bound, res)、または np.clip）

引数

src	入力配列。
dst	src と同じサイズの出力配列。
alpha	正規化先のノルム値、またはレンジ正規化の場合は範囲の下限。
beta	レンジ正規化の場合の範囲の上限。ノルム正規化では使われない。
norm_type	正規化の種類（cv::NormTypes を参照）。
dtype	負の場合、出力配列は src と同じ型になる。それ以外の場合は src と同じチャンネル数で、ビット深度は depth=CV_MAT_DEPTH(dtype) となる。
mask	型 CV_8U、CV_8S または CV_Bool の省略可能な操作マスク。

参照

norm, Mat::convertTo, SparseMat::convertTo

例

samples/cpp/pca.cpp.

patchNaNs()

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

Python:
	cv.patchNaNs(	a[, val]	) ->	a

#include <opencv2/core.hpp>

行列内の NaN（非数値）を指定した値で置き換える。

この関数は入力行列をインプレースで変更する。入力行列は CV_32F または CV_64F 型でなければならない。他の型はサポートされない。

引数

a	入出力行列（CV_32F または CV_64F 型）。
val	NaN を置き換えるために使う値（デフォルトは 0）。

PCABackProject()

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

Python:
	cv.PCABackProject(	data, mean, eigenvectors[, result]	) ->	result

#include <opencv2/core.hpp>

PCA::backProject のラッパー

PCACompute() [1/4]

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

Python:
	cv.PCACompute(	data, mean[, eigenvectors[, maxComponents]]	) ->	mean, eigenvectors
	cv.PCACompute(	data, mean, retainedVariance[, eigenvectors]	) ->	mean, eigenvectors
	cv.PCACompute2(	data, mean[, eigenvectors[, eigenvalues[, maxComponents]]]	) ->	mean, eigenvectors, eigenvalues
	cv.PCACompute2(	data, mean, retainedVariance[, eigenvectors[, eigenvalues]]	) ->	mean, eigenvectors, eigenvalues

#include <opencv2/core.hpp>

PCA::operator() のラッパー

PCACompute() [2/4]

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

Python:
	cv.PCACompute(	data, mean[, eigenvectors[, maxComponents]]	) ->	mean, eigenvectors
	cv.PCACompute(	data, mean, retainedVariance[, eigenvectors]	) ->	mean, eigenvectors
	cv.PCACompute2(	data, mean[, eigenvectors[, eigenvalues[, maxComponents]]]	) ->	mean, eigenvectors, eigenvalues
	cv.PCACompute2(	data, mean, retainedVariance[, eigenvectors[, eigenvalues]]	) ->	mean, eigenvectors, eigenvalues

#include <opencv2/core.hpp>

PCA::operator() のラッパー

PCACompute() [3/4]

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

Python:
	cv.PCACompute(	data, mean[, eigenvectors[, maxComponents]]	) ->	mean, eigenvectors
	cv.PCACompute(	data, mean, retainedVariance[, eigenvectors]	) ->	mean, eigenvectors
	cv.PCACompute2(	data, mean[, eigenvectors[, eigenvalues[, maxComponents]]]	) ->	mean, eigenvectors, eigenvalues
	cv.PCACompute2(	data, mean, retainedVariance[, eigenvectors[, eigenvalues]]	) ->	mean, eigenvectors, eigenvalues

#include <opencv2/core.hpp>

PCA::operator() のラッパーで、固有値の出力引数を追加したもの

PCACompute() [4/4]

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

Python:
	cv.PCACompute(	data, mean[, eigenvectors[, maxComponents]]	) ->	mean, eigenvectors
	cv.PCACompute(	data, mean, retainedVariance[, eigenvectors]	) ->	mean, eigenvectors
	cv.PCACompute2(	data, mean[, eigenvectors[, eigenvalues[, maxComponents]]]	) ->	mean, eigenvectors, eigenvalues
	cv.PCACompute2(	data, mean, retainedVariance[, eigenvectors[, eigenvalues]]	) ->	mean, eigenvectors, eigenvalues

#include <opencv2/core.hpp>

PCA::operator() のラッパーで、固有値の出力引数を追加したもの

PCAProject()

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

Python:
	cv.PCAProject(	data, mean, eigenvectors[, result]	) ->	result

#include <opencv2/core.hpp>

PCA::project のラッパー

perspectiveTransform()

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

Python:
	cv.perspectiveTransform(	src, m[, dst]	) ->	dst

#include <opencv2/core.hpp>

ベクトルの透視行列変換を行う。

関数 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}\]

ここでは3次元ベクトル変換を示している。2次元ベクトル変換の場合、z 成分は省略される。

覚え書き

この関数は、2次元または3次元ベクトルの疎な集合を変換する。透視変換を使って画像を変換したい場合は、warpPerspective を使用する。逆問題、すなわち対応する点の複数のペアから最も確からしい透視変換を計算したい場合は、getPerspectiveTransform または findHomography を使用できる。

引数

src	2チャンネルまたは3チャンネルの浮動小数点入力配列。各要素は変換対象の2D/3Dベクトルである。
dst	srcと同じサイズかつ同じ型の出力配列。
m	3x3 または 4x4 の浮動小数点変換行列。

参照

transform, warpPerspective, getPerspectiveTransform, findHomography

phase()

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

Python:
	cv.phase(	x, y[, angle[, angleInDegrees]]	) ->	angle

#include <opencv2/core.hpp>

2次元ベクトルの回転角を計算する。

関数 cv::phase は、x と y の対応する要素から構成される各2次元ベクトルの回転角を計算する。

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

角度推定の精度は約0.3度である。x(I)=y(I)=0 のとき、対応する angle(I) は0に設定される。

引数

x	2Dベクトルの x 座標からなる入力浮動小数点配列。
y	2Dベクトルの y 座標からなる入力配列。x と同じサイズおよび同じ型である必要がある。
angle	ベクトルの角度の出力配列。x と同じサイズおよび同じ型を持つ。
angleInDegrees	true の場合、関数は角度を度単位で計算する。それ以外の場合はラジアン単位で計算される。

polarToCart()

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

Python:
	cv.polarToCart(	magnitude, angle[, x[, y[, angleInDegrees]]]	) ->	x, y

#include <opencv2/core.hpp>

2次元ベクトルの大きさと角度から、その x 座標と y 座標を計算する。

関数 cv::polarToCart は、magnitude と angle の対応する要素で表される各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	2Dベクトルの大きさからなる入力浮動小数点配列。空の行列（=Mat()）でもよく、その場合は関数はすべての大きさが =1 であると仮定する。空でない場合は angle と同じサイズおよび型である必要がある。
angle	2Dベクトルの角度からなる入力浮動小数点配列。
x	2Dベクトルの x 座標の出力配列。angle と同じサイズおよび型を持つ。
y	2Dベクトルの y 座標の出力配列。angle と同じサイズおよび型を持つ。
angleInDegrees	true の場合、入力角度は度単位で測定される。それ以外の場合はラジアン単位で測定される。

参照

cartToPolar, magnitude, phase, exp, log, pow, sqrt

pow()

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

Python:
	cv.pow(	src, power[, dst]	) ->	dst

#include <opencv2/core.hpp>

配列の各要素をべき乗する。

関数 cv::pow は、入力配列の各要素を power でべき乗する。

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

power の値によっては、たとえば整数値、0.5、-0.5 などの場合、専用のより高速なアルゴリズムが使用される。

特殊な値（NaN、Inf）は処理されない。

引数

src	入力配列。
power	べき乗の指数。
dst	srcと同じサイズかつ同じ型の出力配列。

参照

sqrt, exp, log, cartToPolar, polarToCart

PSNR()

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

Python:
	cv.PSNR(	src1, src2[, R]	) ->	retval

#include <opencv2/core.hpp>

ピーク信号対雑音比 (PSNR) という画質指標を計算する。

この関数は、2つの入力配列 src1 と src2 の間のピーク信号対雑音比 (PSNR) という画質指標をデシベル (dB) 単位で計算する。これらの配列は同じ型でなければならない。

PSNR は次のように計算される。

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

ここで R はビット深度がとりうる最大の整数値（例えば CV_8U データの場合は 255）であり、MSE は2つの配列間の平均二乗誤差である。

引数

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

randn()

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

Python:
	cv.randn(	dst, mean, stddev	) ->	dst

#include <opencv2/core.hpp>

配列を正規分布に従う乱数で埋める。

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

引数

dst	乱数の出力配列。配列はあらかじめ確保されており、チャンネル数が1から4である必要がある。
mean	生成される乱数の平均値（期待値）。
stddev	生成する乱数の標準偏差。ベクトル(この場合は対角な標準偏差行列とみなされる)か、正方行列のいずれかを指定できる。

参照

RNG, randu

randShuffle()

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

Python:
	cv.randShuffle(	dst[, iterFactor]	) ->	dst

#include <opencv2/core.hpp>

配列要素をランダムにシャッフルする。

関数 cv::randShuffle は、要素のペアをランダムに選んで入れ替えることで、指定した1次元配列をシャッフルする。この入れ替え操作の回数は dst.rows*dst.cols*iterFactor となる。

引数

dst	入出力の数値1次元配列。
iterFactor	ランダムな入れ替え操作の回数を決定するスケール係数(詳細は後述)。
rng	シャッフルに用いる省略可能な乱数生成器。0の場合はtheRNG ()が代わりに使用される。

参照

RNG, sort

例

modules/shape/samples/shape_example.cpp.

randu()

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

Python:
	cv.randu(	dst, low, high	) ->	dst

#include <opencv2/core.hpp>

一様分布に従う単一の乱数、または乱数の配列を生成する。

この関数の非テンプレート版は、指定した範囲の一様分布に従う乱数で行列 dst を埋める。

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

引数

dst	乱数の出力配列。配列は事前に確保しておく必要がある。
low	生成する乱数の下限(この値を含む)。
high	生成する乱数の上限(この値を含まない)。

参照

RNG, randn, theRNG

reduce()

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

Python:
	cv.reduce(	src, dim, rtype[, dst[, dtype]]	) ->	dst

#include <opencv2/core.hpp>

行列をベクトルに縮約する。

関数 reduce は、行列の行/列を1次元ベクトルの集合とみなし、単一の行/列が得られるまでベクトルに対して指定した演算を行うことで、行列をベクトルに縮約する。例えば、この関数はラスタ画像の水平方向および垂直方向の射影を計算するのに使える。REDUCE_MAX および REDUCE_MIN の場合、出力画像は入力と同じ型でなければならない。REDUCE_SUM、REDUCE_SUM2、REDUCE_AVG の場合は、精度を保つために出力の要素のビット深度がより大きくなることがある。また、これら2つの縮約モードではマルチチャンネル配列もサポートされている。

次のコードは、シングルチャンネル行列に対する使い方を示している。

 Mat m = Mat_<uchar>({3,2}, {1,2,3,4,5,6});
 Mat col_sum, row_sum;
 
 reduce(m, col_sum, 0, REDUCE_SUM, CV_32F);
 reduce(m, row_sum, 1, REDUCE_SUM, CV_32F);
 /*
        m =
        [  1,   2;
           3,   4;
           5,   6]
        col_sum =
        [9, 12]
        row_sum =
        [3;
         7;
         11]
         */

また、次のコードは、2チャンネル行列に対する使い方を示している。

 // two channels
 char d[] = {1,2,3,4,5,6};
 Mat m(3, 1, CV_8UC2, d);
 Mat col_sum_per_channel;
 reduce(m, col_sum_per_channel, 0, REDUCE_SUM, CV_32F);
 /*
        col_sum_per_channel =
        [9, 12]
        */

引数

src	入力2次元行列。
dst	出力ベクトル。サイズと型はdimおよびdtypeパラメータで定義される。
dim	行列を縮約する次元のインデックス。0は行列を1行に縮約することを意味する。1は行列を1列に縮約することを意味する。
rtype	縮約処理。ReduceTypesのいずれかを指定できる
dtype	負の場合、出力ベクトルは入力行列と同じ型になる。それ以外の場合、型はCV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels())になる。

参照

repeat, reduceArgMin, reduceArgMax

reduceArgMax()

void cv::reduceArgMax	(	InputArray	src,
		OutputArray	dst,
		int	axis,
		bool	lastIndex = false )

Python:
	cv.reduceArgMax(	src, axis[, dst[, lastIndex]]	) ->	dst

#include <opencv2/core.hpp>

指定した軸に沿って最大要素のインデックスを求める。

覚え書き

• 入力配列または出力配列が連続でない場合、この関数は内部でコピーを作成する。
• NaN の扱いは未規定である。patchNaNs() を参照のこと。
• 返されるインデックスは常に入力行列の範囲内に収まる。

引数

src	シングルチャンネルの入力配列。
dst	CV_32SC1型の出力配列。srcと同じ次元数を持つが、縮約される軸については1に設定される。
lastIndex	最大値の最初の出現位置と最後の出現位置のどちらのインデックスを取得するか。
axis	縮約する軸。

参照

reduceArgMin, minMaxLoc, min, max, compare, reduce

reduceArgMin()

void cv::reduceArgMin	(	InputArray	src,
		OutputArray	dst,
		int	axis,
		bool	lastIndex = false )

Python:
	cv.reduceArgMin(	src, axis[, dst[, lastIndex]]	) ->	dst

#include <opencv2/core.hpp>

指定した軸に沿って最小要素のインデックスを求める。

覚え書き

• 入力配列または出力配列が連続でない場合、この関数は内部でコピーを作成する。
• NaN の扱いは未規定である。patchNaNs() を参照のこと。
• 返されるインデックスは常に入力行列の範囲内に収まる。

引数

src	シングルチャンネルの入力配列。
dst	CV_32SC1型の出力配列。srcと同じ次元数を持つが、縮約される軸については1に設定される。
lastIndex	最小値の最初の出現位置と最後の出現位置のどちらのインデックスを取得するか。
axis	縮約する軸。

参照

reduceArgMax, minMaxLoc, min, max, compare, reduce

repeat() [1/2]

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

Python:
	cv.repeat(	src, ny, nx[, dst]	) ->	dst

#include <opencv2/core.hpp>

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

引数

src	複製する入力配列。
ny	srcを垂直方向に何回繰り返すかを指定するフラグ。
nx	srcを水平方向に何回繰り返すかを指定するフラグ。

repeat() [2/2]

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

Python:
	cv.repeat(	src, ny, nx[, dst]	) ->	dst

#include <opencv2/core.hpp>

入力配列のコピーを繰り返し並べて出力配列を埋める。

関数 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()

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

Python:
	cv.rotate(	src, rotateCode[, dst]	) ->	dst

#include <opencv2/core.hpp>

2次元配列を90度の倍数だけ回転させる。関数 cv::rotate は、次の3つのいずれかの方法で配列を回転させる。時計回りに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()

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

Python:
	cv.scaleAdd(	src1, alpha, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

スケーリングした配列と別の配列の和を計算する。

関数 scaleAdd は、BLAS で DAXPY または SAXPY として知られる、古典的で基本的な線形代数演算の1つである。スケーリングした配列と別の配列の和を計算する。

\[\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()

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

Python:
	cv.setIdentity(	mtx[, s]	) ->	mtx

#include <opencv2/core.hpp>

スケーリングした単位行列を初期化する。

関数 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]]

引数

mtx	初期化する行列(必ずしも正方行列でなくてよい)。
s	対角要素に代入する値。

参照

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

setRNGSeed()

void cv::setRNGSeed

(

int

seed

)

Python:
	cv.setRNGSeed(	seed	) ->	None

#include <opencv2/core.hpp>

デフォルトの乱数生成器の状態を設定する。

関数 cv::setRNGSeed は、デフォルトの乱数生成器の状態を任意の値に設定する。

引数

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

参照

RNG, randu, randn

solve()

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

Python:
	cv.solve(	src1, src2[, dst[, flags]]	) ->	retval, dst

#include <opencv2/core.hpp>

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 を返す。そうでなければ 0 を返す。後者の場合、dst は有効でない。その他の手法では、左辺が特異な場合に擬似解を求める。

覚え書き

未定の特異系 \(\texttt{src1}\cdot\texttt{dst}=0\) について単位ノルム解を求めたい場合、関数 solve では目的を達成できない。代わりに SVD::solveZ を使うこと。

引数

src1	連立方程式の左辺の入力行列。
src2	連立方程式の右辺の入力行列。
dst	出力される解。
flags	解法(逆行列の計算)の手法(DecompTypes)

参照

invert, SVD, eigen

solveCubic()

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

Python:
	cv.solveCubic(	coeffs[, roots]	) ->	retval, roots

#include <opencv2/core.hpp>

3次方程式の実数解を求める。

関数 solveCubic は、3次方程式の実数解を求める。

• if coeffs is a 4-element vector:

  \[\texttt{coeffs} [0] x^3 + \texttt{coeffs} [1] x^2 + \texttt{coeffs} [2] x + \texttt{coeffs} [3] = 0\]

• if coeffs is a 3-element vector:

  \[x^3 + \texttt{coeffs} [0] x^2 + \texttt{coeffs} [1] x + \texttt{coeffs} [2] = 0\]

解は roots 配列に格納される。

引数

coeffs	方程式の係数。3個または4個の要素からなる配列。
roots	実数解の出力配列。0個、1個、2個または3個の要素を持つ。

戻り値

実数解の個数。-1（すべての実数）、0、1、2、3 のいずれかとなる。

solvePoly()

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

Python:
	cv.solvePoly(	coeffs[, roots[, maxIters]]	) ->	retval, roots

#include <opencv2/core.hpp>

多項式方程式の実数解または複素数解を求める。

関数 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()

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

Python:
	cv.sort(	src, flags[, dst]	) ->	dst

#include <opencv2/core.hpp>

行列の各行または各列をソートする。

関数 cv::sort は、行列の各行または各列を昇順または降順にソートする。したがって、目的の動作を得るには2つの操作フラグを渡す必要がある。行列の行または列を辞書順にソートしたい場合は、適切な比較述語を指定して STL の std::sort 汎用関数を使うとよい。

引数

src	シングルチャンネルの入力配列。
dst	srcと同じサイズかつ同じ型の出力配列。
flags	SortFlagsの組み合わせからなる操作フラグ

参照

sortIdx, randShuffle

sortIdx()

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

Python:
	cv.sortIdx(	src, flags[, dst]	) ->	dst

#include <opencv2/core.hpp>

行列の各行または各列をソートする。

関数 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]

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

Python:
	cv.split(	m[, mv]	) ->	mv

#include <opencv2/core.hpp>

マルチチャンネル配列を複数のシングルチャンネル配列に分割する。

関数 cv::split は、マルチチャンネル配列を個別のシングルチャンネル配列に分割する。

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

単一チャンネルを抽出したり、その他の高度なチャンネルの並べ替えを行いたい場合は、mixChannels を使うこと。

次の例は、3チャンネル行列を3つのシングルチャンネル行列に分割する方法を示している。

 char d[] = {1,2,3,4,5,6,7,8,9,10,11,12};
 Mat m(2, 2, CV_8UC3, d);
 Mat channels[3];
 split(m, channels);
 
 /*
    channels[0] =
    [  1,   4;
       7,  10]
    channels[1] =
    [  2,   5;
       8,  11]
    channels[2] =
    [  3,   6;
       9,  12]
    */

引数

src	入力マルチチャンネル配列。
mvbegin	出力配列。配列の数はsrc.channels()と一致しなければならない。必要に応じて各配列は再確保される。

参照

merge, mixChannels, cvtColor

split() [2/2]

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

Python:
	cv.split(	m[, mv]	) ->	mv

#include <opencv2/core.hpp>

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

引数

m	入力マルチチャンネル配列。
mv	配列の出力ベクトル。必要に応じて各配列は再確保される。

sqrt()

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

Python:
	cv.sqrt(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

配列要素の平方根を計算する。

関数 cv::sqrt は、入力配列の各要素の平方根を計算する。マルチチャンネル配列の場合、各チャンネルは独立して処理される。精度は組み込みの std::sqrt とほぼ同じである。

引数

src	入力の浮動小数点配列。
dst	srcと同じサイズかつ同じ型の出力配列。

subtract()

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

Python:
	cv.subtract(	src1, src2[, dst[, mask[, dtype]]]	) ->	dst

#include <opencv2/core.hpp>

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

関数 subtract は次を計算する。

• Difference between two arrays, when both input arrays have the same size and the same number of channels:

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\]

• Difference between an array and a scalar, when src2 is constructed from Scalar or has the same number of elements as src1.channels():

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\]

• Difference between a scalar and an array, when src1 is constructed from Scalar or has the same number of elements as src2.channels():

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} - \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\]

• The reverse difference between a scalar and an array in the case of SubRS:

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src2} - \texttt{src1}(I) ) \quad \texttt{if mask}(I) \ne0\]

  where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently.

上記リストの最初の関数は、行列式（matrix expression）で置き換えることができる。

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

入力配列と出力配列はすべて同じビット深度でも異なるビット深度でもよい。例えば、2つの8ビット符号なし配列を減算し、その差を16ビット符号付き配列に格納できる。出力配列のビット深度は dtype 引数によって決まる。上記の2番目と3番目のケース、および src1.depth() == src2.depth() のときの1番目のケースでは、dtype をデフォルトの -1 に設定できる。この場合、出力配列は入力配列（src1、src2、またはその両方）と同じビット深度を持つ。

覚え書き

出力配列のビット深度が CV_32S の場合、飽和処理は適用されない。オーバーフローした場合には符号が誤った結果が得られることさえある。

(Python) src1/src2 が単一の数値の場合と、タプル/配列の場合とで挙動が異なる点に注意すること。subtract(src,X) は subtract(src,(X,X,X,X)) を意味する。subtract(src,(X,)) は subtract(src,(X,0,0,0)) を意味する。

引数

src1	1番目の入力配列、またはスカラー。
src2	2番目の入力配列、またはスカラー。
dst	入力配列と同じサイズかつ同じチャンネル数を持つ出力配列。
mask	省略可能な操作マスク。これは CV_8U、CV8S または CV_Bool のシングルチャンネル配列で、出力配列のうち変更される要素を指定する。
dtype	出力配列の省略可能なビット深度

参照

add, addWeighted, scaleAdd, Mat::convertTo

sum()

Scalar cv::sum

(

InputArray

src

)

Python:
	cv.sumElems(	src	) ->	retval

#include <opencv2/core.hpp>

配列要素の総和を計算する。

関数 cv::sum は、チャンネルごとに独立して配列要素の総和を計算して返す。

引数

src	1～4チャンネルを持たなければならない入力配列。

参照

countNonZero, mean, meanStdDev, norm, minMaxLoc, reduce

SVBackSubst()

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

Python:
	cv.SVBackSubst(	w, u, vt, rhs[, dst]	) ->	dst

#include <opencv2/core.hpp>

SVD::backSubst のラッパー。

SVDecomp()

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

Python:
	cv.SVDecomp(	src[, w[, u[, vt[, flags]]]]	) ->	w, u, vt

#include <opencv2/core.hpp>

SVD::compute のラッパー。

swap() [1/2]

void cv::swap	(	Mat &	a,
		Mat &	b )

#include <opencv2/core.hpp>

2つの行列を入れ替える。

例

samples/cpp/lkdemo.cpp.

swap() [2/2]

void cv::swap	(	UMat &	a,
		UMat &	b )

#include <opencv2/core.hpp>

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

theRNG()

RNG & cv::theRNG

(

)

#include <opencv2/core.hpp>

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

関数 cv::theRNG は、デフォルトの乱数生成器を返す。スレッドごとに別々の乱数生成器があるため、マルチスレッド環境でもこの関数を安全に使える。この生成器を使って単一の乱数を得たり、配列を初期化したりするだけなら、代わりに randu または randn を使える。ただし、ループ内で多数の乱数を生成する場合は、この関数で生成器を取得してから RNG::operator _Tp() を使う方がはるかに高速である。

参照

RNG, randu, randn

trace()

Scalar cv::trace

(

InputArray

mtx

)

Python:
	cv.trace(	mtx	) ->	retval

#include <opencv2/core.hpp>

行列のトレースを返す。

関数 cv::trace は、行列 mtx の対角要素の総和を返す。

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

引数

mtx

入力行列。

transform()

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

Python:
	cv.transform(	src, m[, dst]	) ->	dst

#include <opencv2/core.hpp>

配列の各要素に対して行列変換を行う。

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 の各要素は N 要素のベクトルとして解釈され、M x N または M x (N+1) の行列 m を用いて M 要素のベクトル（出力配列 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()

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

Python:
	cv.transpose(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

行列を転置する。

cv::transpose 関数は行列 src を転置する：

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

覚え書き

複素行列の場合でも複素共役は行われない。必要であれば別途行うこと。

引数

src	入力配列。
dst	srcと同じ型の出力配列。

transposeND()

void cv::transposeND	(	InputArray	src,
		const std::vector< int > &	order,
		OutputArray	dst )

Python:
	cv.transposeND(	src, order[, dst]	) ->	dst

#include <opencv2/core.hpp>

n 次元行列の転置。

覚え書き

入力は連続したシングルチャンネル行列でなければならない。

引数

src	入力配列。
order	[0,1,..,N-1]の置換。ここでNはsrcの軸の数である。dstのi番目の軸は、入力の番号order[i]の軸に対応する。
dst	srcと同じ型の出力配列。

vconcat() [1/3]

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

Python:
	cv.vconcat(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

与えられた行列に対して垂直方向の連結を適用する。

この関数は、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	入力配列または行列のベクトル。すべての行列は同じ列数かつ同じビット深度を持たなければならない。
nsrc	src内の行列の数。
dst	出力配列。srcと同じ列数およびビット深度を持ち、行数はsrcの行数の合計となる。

参照

cv::hconcat(const Mat*, size_t, OutputArray),

cv::hconcat(InputArrayOfArrays, OutputArray) および

cv::hconcat(InputArray, InputArray, OutputArray)

vconcat() [2/3]

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

Python:
	cv.vconcat(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

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

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と同じ列数およびビット深度を持ち、行数はsrc1とsrc2の行数の合計となる。

vconcat() [3/3]

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

Python:
	cv.vconcat(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

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

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	入力配列または行列のベクトル。すべての行列は同じ列数かつ同じビット深度を持たなければならない
dst	出力配列。srcと同じ列数およびビット深度を持ち、行数はsrcの行数の合計となる。ビット深度は同じである。