配列操作¶

cv::AbsDiff¶

AbsDiff(src1, src2, dst) → None¶

2つの配列の要素毎に差の絶対値を求めます．

パラメタ:	src1 (`CvArr`) – 1 番目の入力配列 src2 (`CvArr`) – 2 番目の入力配列 dst (`CvArr`) – 出力配列

この関数は，2つの配列の要素毎に差の絶対値を求めます．

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

すべての入力配列は，同じデータ型，同じサイズ（または ROI サイズ）でなければいけません．

cv::AbsDiffS¶

AbsDiffS(src, value, dst) → None¶

配列の要素とスカラー値の差の絶対値を求めます．

パラメタ:	src (`CvArr`) – 入力配列 dst (`CvArr`) – 出力配列 value (`CvScalar`) – スカラー値

この関数は，入力配列の要素とスカラー値の差の絶対値を求めます．

$\texttt{dst} (i)_c = | \texttt{src} (I)_c - \texttt{value} _c|$

すべての入力配列は，同じデータ型，同じサイズ（または ROI サイズ）でなければいけません．

cv::Add¶

Add(src1, src2, dst, mask=NULL) → None¶

2つの配列を要素毎に加算する．

パラメタ:	src1 (`CvArr`) – 1 番目の入力配列 src2 (`CvArr`) – 2 番目の入力配列 dst (`CvArr`) – 出力配列 mask (`CvArr`) – 8ビットシングルチャンネル配列で表されるオプションマスク．指定された配列要素のみが変更されます

この関数は，以下のように1つの配列をもう1つの配列と足し合わせます：

dst(I)=src1(I)+src2(I) if mask(I)!=0

マスクを除くすべての入出力配列は，同じ型，同じサイズ（または ROI サイズ）でなければいけません．また，有限の範囲に値をとる型は，この処理により飽和します．

cv::AddS¶

AddS(src, value, dst, mask=NULL) → None¶

配列とスカラー値を加算します．

パラメタ:	src (`CvArr`) – 入力配列 value (`CvScalar`) – 加えられるスカラー値 dst (`CvArr`) – 出力配列 mask (`CvArr`) – 8ビットシングルチャンネル配列で表されるオプションマスク．指定された配列要素のみが変更されます

この関数は，スカラー value を入力配列 src1 の各要素に加え，その結果を dst に出力します．また，有限の範囲に値をとる型は，この処理により飽和します．

dst(I)=src(I)+value if mask(I)!=0

マスクを除くすべての入出力配列は，同じ型，同じサイズ（または ROI サイズ）でなければいけません．

cv::AddWeighted¶

AddWeighted(src1, alpha, src2, beta, gamma, dst) → None¶

2つの配列の重み付き和を求めます．

パラメタ:	src1 (`CvArr`) – 1番目の入力配列 alpha (float) – 1番目の配列要素に対する重み src2 (`CvArr`) – 2番目の入力配列 beta (float) – 2番目の配列要素に対する重み dst (`CvArr`) – 出力配列 gamma (float) – 各加算結果にさらに加えられるスカラー値

この関数は，以下のように2つの配列の重み付き和を計算します：

dst(I)=src1(I)*alpha+src2(I)*beta+gamma

マスクを除くすべての入出力配列は，同じ型，同じサイズ（または ROI サイズ）でなければいけません．また，有限の範囲に値をとる型は，この処理により飽和します．

cv::And¶

And(src1, src2, dst, mask=NULL) → None¶

2つの配列の要素毎に，ビット単位の論理積を求めます．

パラメタ:	src1 (`CvArr`) – 1番目の入力配列 src2 (`CvArr`) – 2番目の入力配列 dst (`CvArr`) – 出力配列 mask (`CvArr`) – 8ビットシングルチャンネル配列で表されるオプションマスク．指定された配列要素のみが変更されます

この関数は，2つの配列の要素ごとに，ビット単位の論理積を計算します：

dst(I)=src1(I)&src2(I) if mask(I)!=0

浮動小数点型配列の場合，それらのビット表現が処理に用いられます．マスクを除くすべての入出力配列は，同じ型，同じサイズ（または ROI サイズ）でなければいけない．

cv::AndS¶

AndS(src, value, dst, mask=NULL) → None¶

スカラー値と配列の要素毎に，ビット単位の論理積を求めます．

パラメタ:	src (`CvArr`) – 入力配列 value (`CvScalar`) – スカラー値 dst (`CvArr`) – 出力配列 mask (`CvArr`) – 8ビットシングルチャンネル配列で表されるオプションマスク．指定された配列要素のみが変更されます

この関数は，スカラー値と配列要素毎に，ビット単位の論理積を計算します：

dst(I)=src(I)&value if mask(I)!=0

実際の計算の前に，スカラー値は配列と同じ型に変換されます．また，浮動小数点型配列の場合は，それらのビット表現が処理に用いられます．マスクを除くすべての入出力配列は，同じ型，同じサイズ（または ROI サイズ）でなければいけません．

cv::Avg¶

Avg(arr, mask=NULL) → CvScalar¶

配列の要素の平均値を求めます．

パラメタ:	arr (`CvArr`) – 配列 mask (`CvArr`) – オプションである処理マスク

この関数は，各チャンネル毎に配列要素値の平均 M を求めます：

$\begin{array}{l} N = \sum _I ( \texttt{mask} (I) \ne 0) \\ M_c = \frac{\sum_{I, \, \texttt{mask}(I) \ne 0} \texttt{arr} (I)_c}{N} \end{array}$

配列が IplImage で COI が設定されている場合，この関数は指定されたチャンネルのみを処理し，その結果を戻り値の CvScalar の1番目の要素 $S_0$ に格納します．

cv::AvgSdv¶

AvgSdv(arr, mask=NULL)-> (mean, stdDev)¶

配列の要素の平均値と標準偏差を求めます．

パラメタ:	arr (`CvArr`) – 配列 mask (`CvArr`) – オプションである処理マスク mean (`CvScalar`) – 平均値，CvScalar stdDev (`CvScalar`) – 標準偏差，CvScalar

この関数は，各チャンネルごとに配列要素の平均値と標準偏差を求めます：

$\begin{array}{l} N = \sum _I ( \texttt{mask} (I) \ne 0) \\ mean_c = \frac{1}{N} \, \sum _{ I, \, \texttt{mask} (I) \ne 0} \texttt{arr} (I)_c \\ stdDev_c = \sqrt{\frac{1}{N} \, \sum_{ I, \, \texttt{mask}(I) \ne 0} ( \texttt{arr} (I)_c - mean_c)^2} \end{array}$

配列が IplImage で COI が設定されている場合，この関数は指定されたチャンネルのみを処理し，その結果（平均，標準偏差）を出力変数の1番目の要素 $mean_0$ ， $stdDev_0$ に格納します．

cv::CalcCovarMatrix¶

CalcCovarMatrix(vects, covMat, avg, flags) → None¶

ベクトル集合の分散共分散行列を求めます．

パラメタ:

vects (cvarr_count) – 入力ベクトルの配列，これらのベクトルは全て同じ型，同じサイズでなければいけません．ベクトルは1次元である必要はなく，2次元（例えば，画像）などでも構いません
covMat (CvArr) – 出力である分散共分散行列，浮動小数点型で正方な行列でなければいけません
avg (CvArr) – 入力あるいは出力（flags に依存する）配列 - 入力ベクトルの平均ベクトル
flags (int) –
処理フラグ．以下の値の組み合わせ
- CV_COVAR_SCRAMBLED 分散共分散行列が以下のように計算されます：
  
  $\texttt{scale} * [ \texttt{vects} [0]- \texttt{avg} , \texttt{vects} [1]- \texttt{avg} ,...]^T \cdot [ \texttt{vects} [0]- \texttt{avg} , \texttt{vects} [1]- \texttt{avg} ,...]$
  
  , つまり，分散共分散行列は $\texttt{count} \times \texttt{count}$ の行列となります．このような一般的ではない分散共分散行列は，非常に大きなベクトル集合に対する高速なPCAのために利用されます（例えば，顔認識のための固有顔）．この「スクランブルされた」行列の固有値は，真の分散共分散行列の固有値と一致します．また，「真の」固有ベクトルは「スクランブルされた」分散共分散行列の固有ベクトルから容易に求めることができます
- CV_COVAR_NORMAL 分散共分散行列が以下のように計算されます：
  
  $\texttt{scale} * [ \texttt{vects} [0]- \texttt{avg} , \texttt{vects} [1]- \texttt{avg} ,...] \cdot [ \texttt{vects} [0]- \texttt{avg} , \texttt{vects} [1]- \texttt{avg} ,...]^T$
  
  , つまり， covMat は各入力ベクトルの要素数と同じ次数をもつ通常の分散共分散行列となります． CV_COVAR_SCRAMBLED と CV_COVAR_NORMAL のどちらかは必ず指定される必要があります
- CV_COVAR_USE_AVG このフラグが指定された場合，平均 avg を計算せずに，代わりに avg で指定された平均ベクトルを用います．これは，平均 avg が何らかの方法で既に計算されている場合や，分散共分散行列が部分的に計算されている場合（この場合も avg は入力ベクトルの一部の平均ではなく，すべてのベクトルの平均）に役立ちます
- CV_COVAR_SCALE このフラグが指定された場合，分散共分散行列はスケーリングされます． CV_COVAR_NORMAL モードでは scale は ‘1./count’ となり， CV_COVAR_SCRAMBLED モードでは， scale は入力ベクトルの要素数の逆数となります．デフォルト（このフラグが指定されない場合）では，分散共分散行列はスケーリングされません（つまり，’scale=1’）
- CV_COVAR_ROWS すべての入力ベクトルが1つの行列 vects[0] の行として格納されている状態を表します．この場合， count は無視され， avg は適切なサイズの1チャンネル行ベクトルでなければいけません
- CV_COVAR_COLS すべての入力ベクトルが1つの行列 vects[0] の列として格納されている状態を表します．この場合， count は無視され， avg は適切なサイズの1チャンネル列ベクトルでなければいけません

この関数は，分散共分散行列を求め，必要ならば入力ベクトル集合の平均ベクトルも計算します．これは，PCA やマハラノビス距離によるベクトル同士の比較などに用いられます．

cv::CartToPolar¶

CartToPolar(x, y, magnitude, angle=NULL, angleInDegrees=0) → None¶

2次元ベクトルの大きさと角度を求めます．

パラメタ:

x (CvArr) – x 座標の配列
y (CvArr) – y 座標の配列
magnitude (CvArr) – 入力ベクトルの大きさを代入する出力配列，大きさが不要ならば NULL がセットされます
angle (CvArr) – 入力ベクトルの角度を代入する出力配列，角度が不要ならば NULL がセットされます．角度はラジアン（ $0$ から $2 \pi$ ），または度（ $0$ から $360$ ）で表されます
angleInDegrees (int) – 出力である角度をデフォルトの「ラジアン」で表現するか，あるいは「度」で表現するかを指定するフラグ

この関数は，各2次元ベクトル (x(I),y(I)) の大きさと角度を求めます：

magnitude(I)=sqrt(x(I)^2^+y(I)^2^ ),
angle(I)=atan(y(I)/x(I) )

この角度は，0.1 度の精度で計算されます．また，(0,0) の点では，角度は 0 にセットされます．

cv::Cbrt¶

Cbrt(value) → float¶

立方根を求めます．

Parameter:	value (float) – 浮動小数点型の入力値

この関数は，引数で与えられた入力値の立方根を求めます．また通常， pow(value,1./3 よりも高速であり，負の入力値も適切に扱うことができます．しかし，特別な値（ $\pm \infty$ ， NaN ）は扱うことができません．

cv::ClearND¶

ClearND(arr, idx) → None¶

指定された配列要素をクリアします．

パラメタ:	arr (`CvArr`) – 入力配列 idx (sequence of int) – 要素を指定するインデックスの配列

関数 ClearND は，密な配列および疎な配列の指定された要素をクリア（値に0をセット）します．指定された要素が存在しなければ何もしません．

cv::CloneImage¶

CloneImage(image) → copy¶

ヘッダ，データ，ROIを含む，画像の完全なコピーを作成します．

Parameter:	image (`IplImage`) – オリジナル画像

戻り値の IplImage* は，コピーされた画像へのポインタです．

cv::CloneMat¶

CloneMat(mat) → copy¶

行列の完全なコピーを作成します．

Parameter:	mat (`CvMat`) – コピーされる行列

行列の完全なコピーを作成し，そのコピーへのポインタを返します．

cv::CloneMatND¶

CloneMatND(mat) → copy¶

多次元の配列の完全なコピーを作成し，そのポインタを返します．

Parameter:	mat (`CvMatND`) – 入力配列

cv::Cmp¶

Cmp(src1, src2, dst, cmpOp) → None¶

2つの配列の要素毎の比較を行います．

パラメタ:

src1 (CvArr) – 1番目の入力配列
src2 (CvArr) – 2番目の入力配列．入力配列は，どちらもシングルチャンネルでなければいけません
dst (CvArr) – 出力配列，8u か 8s 型でなければいけません
CmpOp –
要素同士の関係を指定するフラグ
- CV_CMP_EQ src1(I) は src2(I) “と等しい”
- CV_CMP_GT src1(I) は src2(I) “より大きい”
- CV_CMP_GE src1(I) は src2(I) “以上”
- CV_CMP_LT src1(I) は src2(I) “より小さい”
- CV_CMP_LE src1(I) は src2(I) “以下”
- CV_CMP_NE src1(I) は src2(I) “と等しくない”

この関数は，2つの配列の対応する2つの要素同士を比較し，その結果に応じた値でマスク配列を埋めます：

dst(I)=src1(I) op src2(I),

比較結果が真であれば， dst(I) に 0xff（全てのビットが 1 ）がセットされ，そうでなければ 0 がセットされます．出力配列を除くすべての入力配列は，同じ型，同じサイズ（または ROI サイズ）でなければいけません．

cv::CmpS¶

CmpS(src, value, dst, cmpOp) → None¶

スカラー値と配列の要素毎の比較を行います．

パラメタ:

src (CvArr) – 入力配列，シングルチャンネルでなければいけません
value (float) – 入力配列の各要素と比較されるスカラー値
dst (CvArr) – 出力配列，8u か 8s 型でなければいけません
cmpOp (int) –
要素同士の関係を指定するフラグ
- CV_CMP_EQ src1(I) は value “と等しい”
- CV_CMP_GT src1(I) は value “より大きい”
- CV_CMP_GE src1(I) は value “以上”
- CV_CMP_LT src1(I) は value “より小さい”
- CV_CMP_LE src1(I) は value “以下”
- CV_CMP_NE src1(I) は value “と等しくない”

この関数は，配列の要素とスカラー値を比較し，その結果に応じた値でマスク配列を埋めます：

dst(I)=src(I) op scalar

ここで op は $=$ , $>$ , $\ge$ , $<$ , $\le$ , $\ne$ のいずれかです．

比較結果が真であれば， dst(I) に 0xff（全てのビットが 1 ）がセットされ，そうでなければ 0 がセットされます．出力配列を除くすべての入力配列は，同じ型，同じサイズ（または ROI サイズ）でなければいけません．

cv::Convert¶

Convert(src, dst) → None¶

ある配列を別の配列に変換します．

パラメタ:	src (`CvArr`) – 入力配列 dst (`CvArr`) – 出力配列

変換の種類には，まるめ演算を行うものと飽和演算を行うものがあります．つまり，スケーリング +　変換の結果が，出力配列要素の型で厳密に表現できない場合，最も近い実数軸上の値で代替されます．

マルチチャンネル配列のすべてのチャンネルは，個別に処理されます．

cv::ConvertScale¶

ConvertScale(src, dst, scale=1.0, shift=0.0) → None¶

配列に対して任意の線形変換を行います．

パラメタ:	src (`CvArr`) – 入力配列 dst (`CvArr`) – 出力配列 scale (float) – スケール係数 shift (float) – スケーリングされた入力配列要素に加えられる値

関数 cvConvertScale は，複数の異なる使用目的に応じた，複数の別名をもちます．この関数は，入力配列に対して任意のスケーリングと任意の変換（あるいは任意の変換のみ）を行い，結果を出力配列にコピーします：

$\texttt{dst} (I) = \texttt{scale} \texttt{src} (I) + ( \texttt{shift} _0, \texttt{shift} _1,...)$

マルチチャンネル配列のチャンネルはすべて，個別に処理されます．

変換の種類によっては，丸めや飽和を伴う場合があります．つまり，スケーリング＋変換の結果が，出力配列の要素の型で正確に表現できない場合，実軸上でもっとも近い表現可能な値が出力として用いられます．

scale=1, shift=0 の場合には，スケーリングは行われません．これは，特別に最適化されたケースであり，適切な別名 Convert を持ちます．入出力配列が同じ種類である場合も，行列や画像のスケーリングや移動を行うことができる特別なケースであり， Scale と呼ばれます．

cv::ConvertScaleAbs¶

ConvertScaleAbs(src, dst, scale=1.0, shift=0.0) → None¶

入力配列の要素を，任意の線形変換によって8ビット符号なし整数に変換します．

パラメタ:	src (`CvArr`) – 入力配列 dst (`CvArr`) – 出力配列（ビット深度は 8u） scale (float) – 絶対値スケール係数 shift (float) – スケーリングされた入力配列要素に加えられる値

この関数は， ConvertScale と似ていますが，変換結果の絶対値を保存します．

$\texttt{dst} (I) = | \texttt{scale} \texttt{src} (I) + ( \texttt{shift} _0, \texttt{shift} _1,...)|$

この関数は，8u（8-ビット，符号なし整数）型の出力配列のみをサポートします．その他の型の場合は， ConvertScale と Abs の組み合わせることで，この関数をエミュレートできます．

cv::CvtScaleAbs¶

CvtScaleAbs(src, dst, scale=1.0, shift=0.0) → None¶

入力配列の要素を，別の 8-ビット，符号なし整数に変換します．オプションで，さらに線形変換を行うこともできます．

パラメタ:	src – 入力配列 dst – 出力配列（ビット深度は 8u でなければいけません） scale – ScaleAbs ファクタ shift – スケーリングされた入力配列要素に足される値

この関数は， ConvertScale と似ていますが，変換結果の絶対値を出力します：

$\texttt{dst} (I) = | \texttt{scale} \texttt{src} (I) + ( \texttt{shift} _0, \texttt{shift} _1,...)|$

この関数は，出力配列として8u（8ビット符号なし整数）型の配列のみをサポートします．その他の型の場合は， ConvertScale と Abs を組み合わせることで，この関数と同等の結果を得られます．

cv::Copy¶

Copy(src, dst, mask=NULL) → None¶

配列をコピーします．

パラメタ:	src (`CvArr`) – コピー元の配列 dst (`CvArr`) – コピー先の配列 mask (`CvArr`) – 8ビットシングルチャンネル配列で表されるオプションマスク．指定された配列要素のみが変更されます

この関数は，入力配列の選択された要素を出力配列にコピーします：

$\texttt{dst} (I)= \texttt{src} (I) \quad \text{if} \quad \texttt{mask} (I) \ne 0.$

引数配列に IplImage が含まれる場合，その ROI と COI が利用されます．コピー元配列とコピー先配列は，同じ型，同じ次元，同じサイズでなければいけません．また，この関数は疎な配列もコピーできます（が，その場合マスクはサポートされません）．

cv::CountNonZero¶

CountNonZero(arr) → int¶

配列中の 0 ではない要素を数えます．

Parameter:	arr (`CvArr`) – シングルチャンネルの配列，あるいは COI が設定されたマルチチャンネル画像

この関数は， arr 中の 0 ではない要素数を返します：

$\sum _I ( \texttt{arr} (I) \ne 0)$

IplImage の場合は，ROI と COI がサポートされます．

cv::CreateData¶

CreateData(arr) → None¶

配列データ領域を確保します．

Parameter:	arr – 配列のヘッダ

この関数は，画像，行列あるいは多次元配列のデータを確保します．行列の場合は OpenCV の確保関数が用いられます．IplImage の場合も OpenCV の関数が用いられますが， CV_TURN_ON_IPL_COMPATIBILITY が呼ばれている場合は例外的に，IPL 関数によってデータ領域が確保されます．

cv::CreateImage¶

CreateImage(size, depth, channels) → image¶

画像ヘッダを作成し，データ領域を確保します．

パラメタ:	size – 画像の幅と高さ depth – 画像のビット深度．有効な値は， IplImage を参照してください channels – ピクセル毎のチャンネル数．詳しくは IplImage を参照してください．この関数は，インタリーブチャンネルの画像のみを作成できます

cv::CreateImageHeader¶

CreateImageHeader(size, depth, channels) → image¶

画像ヘッダを作成しますが，データ領域の確保は行いません．

パラメタ:	size – 画像の幅と高さ depth – ビット深度（ CreateImage を参照してください） channels – チャンネル数（ CreateImage を参照してください）

cv::CreateMat¶

CreateMat(rows, cols, type) → mat¶

行列のヘッダを作成し，データ領域を確保します．

パラメタ:

rows – 行列の行数
cols – 行列の列数
type – CV_<bit depth><S|U|F>C<number of channels> で表される，行列の要素の型．ここで，S=signed：符号あり，U=unsigned：符号なし，F=float：浮動小数点型，をそれぞれ表します．例えば CV _ 8UC1 は，8ビット符号なしでシングルチャンネルの要素を意味し，CV _ 32SC2 は，32ビット符号ありで2チャンネルの要素を意味します

cv::CreateMatHeader¶

CreateMatHeader(rows, cols, type) → mat¶

行列のデータ領域を確保せずに，行列のヘッダのみを作成します．

パラメタ:	rows – 行列の行数 cols – 行列の列数 type – 行列の要素の種類， CreateMat を参照してください

この関数は，新しい行列のヘッダを作成し，そのポインタを返します．行列データは， CreateData を用いて確保するか，あるいは，ユーザが確保したデータを SetData によって明示的にセットします．

cv::CreateMatND¶

CreateMatND(dims, type) → None¶

多次元の密な配列のヘッダを作成し，データ領域を確保します．

パラメタ:	dims – 長さ32以下の，配列の次元のリスト，またはタプル type – 配列の要素の種類， CreateMat を参照してください

これは，以下の形式を短縮したものです：

cv::CreateMatNDHeader¶

CreateMatNDHeader(dims, type) → None¶

行列のデータ領域を確保せずに，行列のヘッダのみを作成します．

パラメタ:	dims – 長さ32以下の，配列の次元のリスト，またはタプル type – 配列の要素の種類， CreateMat を参照してください

この関数は，多次元の密な配列のヘッダを確保します．配列データは， CreateData を用いて確保するか，あるいは，ユーザが確保したデータを SetData によって明示的にセットします．

cv::CrossProduct¶

CrossProduct(src1, src2, dst) → None¶

2つの3次元ベクトルの外積を求めます．

パラメタ:	src1 (`CvArr`) – 1番目の入力ベクトル src2 (`CvArr`) – 2番目の入力ベクトル dst (`CvArr`) – 出力ベクトル

この関数は，2つの3次元ベクトルの外積を求めます：

$\texttt{dst} = \texttt{src1} \times \texttt{src2}$

あるいは：

$\begin{array}{l} \texttt{dst} _1 = \texttt{src1} _2 \texttt{src2} _3 - \texttt{src1} _3 \texttt{src2} _2 \\ \texttt{dst} _2 = \texttt{src1} _3 \texttt{src2} _1 - \texttt{src1} _1 \texttt{src2} _3 \\ \texttt{dst} _3 = \texttt{src1} _1 \texttt{src2} _2 - \texttt{src1} _2 \texttt{src2} _1 \end{array}$

CvtPixToPlane¶

Split と同義です．

cv::DCT¶

DCT(src, dst, flags) → None¶

1次元あるいは2次元浮動小数点型配列に対して，離散コサイン変換（DCT），逆離散コサイン変換（IDCT）を行います．

パラメタ:

src (CvArr) – 入力配列，1次元配列または2次元の，実数の配列
dst (CvArr) – 出力配列，入力配列と同じサイズ，同じ型
flags (int) –
変換フラグ，以下の値の組み合わせ：
- CV_DXT_FORWARD 1次元あるいは2次元の順変換を行います
- CV_DXT_INVERSE 1次元あるいは2次元の逆変換を行います
- CV_DXT_ROWS 入力配列のそれぞれの行に対して独立に，順変換あるいは逆変換を行います．このフラグによって，複数ベクトルの同時変換が可能になります．また，オーバーヘッド（ベクトルが大量にあると，計算自体の何倍も時間がかかることもあります）を減らし，3次以上の高次元に対して変換を行うことができるようになります

この関数は，1次元あるいは 2次元浮動小数点型配列に対して，離散コサイン変換，逆離散コサイン変換を行います．

N 個の要素を持つ 1 次元ベクトルに対するコサイン変換：

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

ここで

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

および $\alpha_0=1$ , $\alpha_j=2$ for $j > 0$ です．

N 個の要素を持つ 1 次元ベクトルに対する逆コサイン変換：

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

（ $C^{(N)}$ は直行行列なので， $C^{(N)} \cdot \left(C^{(N)}\right)^T = I$ ）

$M \times N$ の2 次元行列に対するコサイン変換：

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

$M \times N$ 個の要素を持つ2 次元ベクトルに対する逆コサイン変換：

$X = \left (C^{(N)} \right )^T \cdot X \cdot C^{(N)}$

cv::DFT¶

DFT(src, dst, flags, nonzeroRows=0) → None¶

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

パラメタ:

src (CvArr) – 入力配列，実数あるいは複素数
dst (CvArr) – 出力配列，入力配列と同じサイズ，同じ型
flags (int) –
変換フラグ，以下の値の組み合わせ：
- CV_DXT_FORWARD 1次元または2次元の順変換を行います．結果のスケーリングは行われません
- CV_DXT_INVERSE 1次元または2次元の逆変換を行います．結果のスケーリングは行われません． CV_DXT_FORWARD と CV_DXT_INVERSE は，もちろん同時には指定できません
- CV_DXT_SCALE 結果を配列要素数で割ってスケーリングします．通常は CV_DXT_INVERSE と同時に用います．これのショートカットとして CV_DXT_INV_SCALE を用いても構いません
- CV_DXT_ROWS 入力配列のそれぞれの行に対して独立に，順変換あるいは逆変換を行います．このフラグによって，複数ベクトルの同時変換が可能になります．また，オーバーヘッド（ベクトルが大量にあると，計算自体の何倍も時間がかかることもあります）を減らし，3次以上の高次元に対して変換を行うことができるようになります
- CV_DXT_INVERSE_SCALE CV_DXT_INVERSE + CV_DXT_SCALE と等価
nonzeroRows (int) – 入力配列中で，0 ではない行の数（2次元順変換の場合），あるいは出力配列中の注目する行の数（2次元逆変換の場合）．値が0以下の場合，あるいは行の総数よりも大きい場合は，この引数は無視されます．このパラメータを指定すると，DFT を利用して2次元の畳み込みや相関演算を高速に行うことができます．詳しくは，以下のサンプルを参照してください

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

N 個の要素を持つ 1 次元ベクトルに対するフーリエ変換：

$y = F^{(N)} \cdot x, where F^{(N)}_{jk}=exp(-i \cdot 2 \pi \cdot j \cdot k/N)$

,

$i=sqrt(-1)$

N 個の要素を持つ 1 次元ベクトルに対する逆フーリエ変換：

$x'= (F^{(N)})^{-1} \cdot y = conj(F^(N)) \cdot y x = (1/N) \cdot x$

M $\times$ N 個の要素を持つ 2 次元ベクトルに対するフーリエ変換：

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

M $\times$ N 個の要素を持つ 2 次元ベクトルに対する逆フーリエ変換：

$X'= conj(F^{(M)}) \cdot Y \cdot conj(F^{(N)}) X = (1/(M \cdot N)) \cdot X'$

実数データ（シングルチャンネル）の場合，フーリエ変換の出力や逆変換の入力を表現するために，IPL 形式の packed フォーマットが用いられます：

$\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}$

注意： N が偶数ならば最終列が存在し， M が偶数ならば最終行が存在します．また，1次元実数データを変換する場合，その結果は上述の行列の1行目のようになります．

ここでは，DFTを用いた2次元畳み込演算の例を示します．

cv::Det¶

Det(mat) → double¶

行列式を返します．

Parameter:	mat (`CvArr`) – 入力行列

関数 cvDet は，正方行列 mat の行列式を返します．小さい行列には直接的な方法が，大きい行列にはガウスの消去法が用いられます．正定値対称行列の場合は， $U = V = 0$ として SVD を行い， $W$ の対角要素の積として行列式を計算することもできます．

cv::Div¶

Div(src1, src2, dst, scale) → None¶

2つの配列の要素毎の割り算を行います．

パラメタ:	src1 (`CvArr`) – 1 番目の入力配列．これが NULL の場合，配列は全ての要素が1であると仮定されます src2 (`CvArr`) – 2 番目の入力配列 dst (`CvArr`) – 出力配列 scale (float) – オプションであるスケール係数

この関数は，1つの配列をもう1つの配列で割ります：

$\texttt{dst} (I)= \fork{\texttt{scale} \cdot \texttt{src1}(I)/\texttt{src2}(I)}{if \texttt{src1} is not \texttt{NULL}}{\texttt{scale}/\texttt{src2}(I)}{otherwise}$

すべての入出力配列は，同じ型，同じサイズ（または ROI サイズ）でなければいけません．

cv::DotProduct¶

DotProduct(src1, src2) → double¶

2つの配列のユークリッド内積を計算します．

パラメタ:	src1 (`CvArr`) – 1 番目の入力配列 src2 (`CvArr`) – 2 番目の入力配列

この関数は，2つの配列のユークリッド内積を計算して返します．

$src1 \bullet src2 = \sum _I ( \texttt{src1} (I) \texttt{src2} (I))$

マルチチャンネル配列の場合，全てのチャンネルの結果が足し合わされます．特に， cvDotProduct(a,a) （ a は複素ベクトル）の場合は $||\texttt{a}||^2$ を返します．

この関数は，多次元配列を，行毎，レイヤー毎，に処理することができます．

cv::EigenVV¶

EigenVV(mat, evects, evals, eps, lowindex, highindex) → None¶

対称行列の固有値と固有ベクトルを求めます．

パラメタ:

mat (CvArr) – 入力となる対称行列，関数の処理中に値が変更されます
evects (CvArr) – 固有ベクトルを表す出力行列，ベクトルは連続した行として格納されます
evals (CvArr) – 固有値を表す出力ベクトル，値は降順に格納されます（もちろん，固有値と固有ベクトルの順番は一致します）
eps (float) – 対角化の精度．一般的に， DBL_EPSILON （約 $10^{-15}$ ）で十分です．このパラメータは，現在は無視されます
lowindex (int) – オプション．計算される最大の固有値/固有ベクトルのインデックス（下記を参照してください）
highindex (int) – オプション．計算される最小の固有値/固有ベクトルのインデックス（下記を参照してください）

この関数は，行列 A の固有値と固有ベクトルを求めます：

mat*evects(i,:)' = evals(i)*evects(i,:)' (in MATLAB notation)

lowindex あるいは highindex の一方が与えられると，もう片方も必要になります．また，このインデックスは，0から始まります．例えば，最大の固有値/固有ベクトルを計算する場合は， lowindex=highindex=0 をセットします．また，すべての固有値を計算する場合は， lowindex=highindex=-1 のままにしておきます．過去の経緯から，この関数は常に入力行列と同じサイズの正方行列（固有ベクトルから構成）と，入力行列と同じ長さのベクトル（固有値から構成）を返します．インデックスで選択された固有値/固有ベクトルは，常に最初の highindex - lowindex + 1 行目に格納されます．

行列 A の内容は，この関数によって破壊されます．

今のところ，この関数は SVD よりも遅く，精度も低いです．よって， A が正定値行列（例えば，分散共分散行列など）であることが既知である場合に，その固有値と固有ベクトルを計算するには（固有ベクトルが必要とされない場合は特に） SVD を用いることが推奨されます．

cv::Exp¶

Exp(src, dst) → None¶

各配列要素を指数として，自然対数の底（ネイピア数）eのべき乗を求めます．

パラメタ:	src (`CvArr`) – 入力配列 dst (`CvArr`) – 出力配列， `double` 型，あるいは入力配列と同じ型

この関数は，入力配列の各要素に対して，それを指数とする自然対数の底eのべき乗を求めます：

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

最大誤差は約 $7 \times 10^{-6}$ です．現在の実装では，指数表現されない（非正規化）浮動小数点数は 0 に変換されて出力されます．

cv::FastArctan¶

FastArctan(y, x) → float¶

2次元ベクトルの角度を求めます．

パラメタ:	x (float) – 2次元ベクトルのX座標 y (float) – 2次元ベクトルのy座標

関数 cvFastArctan は，2次元ベクトルの角度を求めます．この角度は 0 度から 360 度の間に値をとり，精度は約 0.1 度です．

cv::Flip¶

Flip(src, dst=NULL, flipMode=0) → None¶

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

パラメタ:

src (CvArr) – 入力配列
dst (CvArr) – 出力配列， $\texttt{dst} = \texttt{NULL}$ の場合は，置換モード（処理後の値が入力変数に代入される）で反転されます
flip_mode – 配列の反転軸の指定：0 は x-軸周りでの反転，正値（例えば，1）は y-軸周りでの反転，負値（例えば，-1）は両軸周りでの反転を表します．以下の式と説明も参照してください：

この関数は，3種の中から1つ選択された方法で配列を反転させます（行と列のインデックスは0が基準）：

$dst(i,j) = \forkthree{\texttt{src}(rows(\texttt{src})-i-1,j)}{if $\texttt{flipMode} = 0$}{\texttt{src}(i,cols(\texttt{src})-j-1)}{if $\texttt{flipMode} > 0$}{\texttt{src}(rows(\texttt{src})-i-1,cols(\texttt{src})-j-1)}{if $\texttt{flipMode} < 0$}$

この関数が利用されるケースとして，以下のような場合が考えられます：

左上原点画像と左下原点画像の変換をするための画像の上下反転（flip _ mode = 0）．これは，Win32 システム環境下のビデオ画像処理でよく利用されます．
垂直軸に対する線対称性を調べるための左右反転（flip _ mode $>$ 0），反転後に水平シフトして差の絶対値を計算します．
中心点に対する点対称性を調べるための上下，左右の同時反転（flip _ mode $<$ 0），反転後にシフトして差の絶対値を計算します．
1次元配列の順番を逆転（flip _ mode > 0）

cv::fromarray¶

fromarray(object, allowND = False) → CvMat¶

配列インタフェースをサポートするオブジェクトから CvMat を作成します．

パラメタ:	object – 配列インタフェースをサポートする任意のオブジェクト allowND – これが真の場合， CvMatND が返されます

オブジェクトが配列インタフェースをサポートする場合， CvMat ( allowND = False ) あるいは CvMatND ( allowND = True ) が返されます．

allowND = False の場合，オブジェクトの配列は2次元または3次元でなければいけません．2次元の場合，返される CvMat はシングルチャンネルです．3次元の場合，返される CvMat は N チャンネルであり，この N は配列の最大の次元です．この場合，N は OpenCV のチャンネル限界 CV_CN_MAX よりも大きくなることはできません．

allowND = True の場合， fromarray は，元の配列と同じ形状でシングルチャンネルの CvMatND を返します．

例えば， NumPy 配列は配列インタフェースをサポートするので，OpenCV オブジェクトに変換できます：

>>> import cv, numpy
>>> a = numpy.ones((480, 640))
>>> mat = cv.fromarray(a)
>>> print cv.GetDims(mat), cv.CV_MAT_CN(cv.GetElemType(mat))
(480, 640) 1
>>> a = numpy.ones((480, 640, 3))
>>> mat = cv.fromarray(a)
>>> print cv.GetDims(mat), cv.CV_MAT_CN(cv.GetElemType(mat))
(480, 640) 3
>>> a = numpy.ones((480, 640, 3))
>>> mat = cv.fromarray(a, allowND = True)
>>> print cv.GetDims(mat), cv.CV_MAT_CN(cv.GetElemType(mat))
(480, 640, 3) 1

cv::GEMM¶

GEMM(src1, src2, alphs, src3, beta, dst, tABC=0) → None¶

汎用的な行列の乗算を行います．

パラメタ:

src1 (CvArr) – 1 番目の入力配列
src2 (CvArr) – 2 番目の入力配列
src3 (CvArr) – 3 番目の入力配列（シフト用）．もしシフトしない場合は NULLにできます
dst (CvArr) – 出力配列
tABC (int) –
操作フラグ．0 あるいは以下の値の組み合わせ
- CV_GEMM_A_T src1 を転置
- CV_GEMM_B_T src2 を転置
- CV_GEMM_C_T src3 を転置
例えば， CV_GEMM_A_T+CV_GEMM_C_T は以下に相当します．

$\texttt{alpha} \, \texttt{src1} ^T \, \texttt{src2} + \texttt{beta} \, \texttt{src3} ^T$

この関数は，汎用的な行列の乗算を行います：

$\texttt{dst} = \texttt{alpha} \, op( \texttt{src1} ) \, op( \texttt{src2} ) + \texttt{beta} \, op( \texttt{src3} ) \quad \text{where $op(X)$ is $X$ or $X^T$}$

すべての入力行列は，同じデータ型，適切なサイズでなければいけません．実数あるいは複素数の浮動小数点型の行列がサポートされます．

cv::Get1D¶

Get1D(arr, idx) → scalar¶

特定の配列要素を返します．

パラメタ:	arr (`CvArr`) – 入力配列 idx (int) – 要素インデックス．0が基準点

特定の配列要素を返します．この配列は，1次元でなければいけません．

cv::Get2D¶

Get2D(arr, idx0, idx1) → scalar¶

特定の配列要素を返します．

パラメタ:	arr (`CvArr`) – 入力配列 idx0 (int) – 要素の行インデックス．0が基準点 idx1 (int) – 要素の列インデックス．0が基準点

特定の配列要素を返します．この配列は，2次元でなければいけません．

cv::Get3D¶

Get3D(arr, idx0, idx1, idx2) → scalar¶

特定の配列要素を返します．

パラメタ:	arr (`CvArr`) – 入力配列 idx0 (int) – 要素インデックス．0が基準点 idx1 (int) – 要素インデックス．0が基準点 idx2 (int) – 要素インデックス．0が基準点

特定の配列要素を返します．この配列は，3次元でなければいけません．

cv::GetND¶

GetND(arr, indices) → scalar¶

特定の配列要素を返します．

パラメタ:	arr (`CvArr`) – 入力配列 indices (sequence of int) – 要素インデックスのリスト．インデックスは，0が基準点

特定の配列要素を返します．インデックスリストの長さは，この配列の次元と一致していなければいけません．

cv::GetCol¶

GetCol(arr, col) → submat¶

配列の列を返します．

パラメタ:	arr (`CvArr`) – 入力配列 col (int) – 指定列のインデックス．0が基準点 submat (`CvMat`) – 結果として得られる，1列の配列

関数 GetCol は，入力配列の中から1列を返します．

cv::GetCols¶

GetCols(arr, startCol, endCol) → submat¶

配列中の，指定範囲内の複数列を返します．

パラメタ:	arr (`CvArr`) – 入力配列 startCol (int) – 指定範囲の最初の（この値を含む）列のインデックス，0が基準点 endCol (int) – 指定範囲の最後の（この値を含まない）列のインデックス，0が基準点 submat (`CvMat`) – 結果として得られる，複数列配列

関数 GetCols は，入力配列中の，指定範囲内の複数列を返します．

cv::GetDiag¶

GetDiag(arr, diag=0) → submat¶

対角要素の配列を返します．

パラメタ:	arr (`CvArr`) – 入力配列 submat (`CvMat`) – 結果として得られる部分配列へのポインタ diag (int) – 配列の対角を指定．0は主対角列に対応し，-1は主対角列の1つ上の斜め列，1は主対角列の1つ下の斜め列，という様に対応します

この関数は，入力配列中の指定された対角要素に対応するヘッダを返します．

cv::GetDims¶

GetDims(arr) → list¶

配列次元のリストを返します．

Parameter:	arr – 入力配列

この関数は，入力配列の各次元の要素数を要素とするリストを返します． IplImage や CvMat の場合は，常に長さ 2 のリストを返します．

cv::GetElemType¶

GetElemType(arr) → int¶

配列要素の種類を返します．

Parameter:	arr (`CvArr`) – 入力配列

この関数は， CreateMat の説明で述べられた配列要素の種類を返します： CV_8UC1 ... CV_64FC4 ．

cv::GetImage¶

GetImage(arr) → iplimage¶

任意の配列に対する画像ヘッダを返します．

Parameter:	arr – 入力配列

関数 cvGetImage は，入力配列を画像とみなした場合の画像ヘッダを返します．入力配列になり得るものは，行列 - CvMat と，画像 - IplImage* です．入力が画像の場合は，単に入力ポインタをそのまま返します．入力が CvMat の場合は， imageHeader 構造体を入力行列のパラメータで初期化します． ROIが設定された IplImage から CvMat への変換を行い，再び CvMat から IplImage に戻した場合，異なるヘッダが返される可能性があります．したがって，画像の長さをその幅とアライメントから計算するような IPL 関数は，この関数の結果として得られる画像に対しては失敗する可能性があります．

cv::GetImageCOI¶

GetImageCOI(image) → channel¶

COI のインデックスを返します．

Parameter:	image (`IplImage`) – 画像ヘッダへのポインタ

IplImage の COI を返します．この戻り値は， SetImageCOI の引数 coi に対応します．

cv::GetImageROI¶

GetImageROI(image) → CvRect¶

画像の ROI を返します．

Parameter:	image (`IplImage`) – 画像ヘッダへのポインタ

ROI が設定されていない場合は，画像全体を表す cvRect(0,0,image->width,image->height) が返されます．

cv::GetMat¶

GetMat(arr, allowND=0) → cvmat¶

任意の配列に対する行列ヘッダを返します．

Parameter:	arr – 入力配列

この関数は，入力配列を行列とみなした場合の行列ヘッダを返します．

入力配列になり得るものは，行列 - CvMat ，画像 - IplImage ，多次元の密な配列 CvMatND （これは allowND != 0 の場合のみ）です．入力が行列の場合は，単に入力ポインタをそのまま返します． IplImage* あるいは CvMatND の場合， header 構造体を現在の画像 ROI のパラメータで初期化し，そのテンポラリ構造体へのポインタを返します． CvMat では COI がサポートされないので，これは別のオプション出力として返されます．

この関数によって，2種類の配列（ IplImage と CvMat ）を簡単に同じコードで扱うことができます．また，関数 GetImage を用いることで， CvMat から IplImage への逆変換が可能です．

入力配列には，内部データが確保されている，あるいは関連付けられている必要があります．そうでなければ，この関数は失敗します．

入力配列が平面データレイアウト（2次元RGB画像など）を持ち，COI が設定されている IplImage である場合，この関数は，選択された平面（例えば，色平面R）へのポインタとCOI=0を返します．OpenCVの関数を用いて，マルチチャンネル画像の各チャンネル（平面）毎に処理を行う事ができるようになります．

cv::GetOptimalDFTSize¶

GetOptimalDFTSize(size0) → int¶

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

Parameter:	size0 (int) – ベクトルサイズ

この関数は，DFTサイズ N を返します．この N は，DFTを高速に実行できるサイズのうちで size0 以上の最小値です．現在の実装では，ある $p$ ， $q$ ， $r$ に対して $N=2^p \times 3^q \times 5^r$ となっています．

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

cv::GetRow¶

GetRow(arr, row) → submat¶

配列の行を返します．

パラメタ:	arr (`CvArr`) – 入力配列 row (int) – 選択された行のインデックス（0が基準点） submat (`CvMat`) – 結果として得られる，1行の配列

関数 GetRow は，入力配列の中から1行を返します．

cv::GetRows¶

GetRows(arr, startRow, endRow, deltaRow=1) → submat¶

配列中の，指定範囲内の複数行を返します．

パラメタ:	arr (`CvArr`) – 入力配列 startRow (int) – 指定範囲の最初の（この値を含む）行のインデックス，0が基準点 endRow (int) – 指定範囲の最後の（この値を含まない）行のインデックス，0が基準点 deltaRow (int) – 行インデックスの増加ステップ submat (`CvMat`) – 結果として得られる，複数行配列

関数 GetRows は，入力配列中の，指定範囲内の複数行を返します．

cv::GetSize¶

GetSize(arr) → CvSize¶

行列あるいは画像ROIのサイズを返します．

Parameter:	arr (`CvArr`) – 配列のヘッダ

この関数は，入力行列あるいは入力画像の行数（CvSize::height）および列数（CvSize::width）を返します．入力が画像の場合は，ROIのサイズが返されます．

cv::GetSubRect¶

GetSubRect(arr, rect) → cvmat¶

入力画像または行列の，矩形部分配列に相当するヘッダを返します．

パラメタ:	arr (`CvArr`) – 入力配列 rect (`CvRect`) – 0 を原点とする座標系で表現される注目矩形領域

関数 cvGetSubRect は，入力配列中の指定矩形領域に対応するヘッダを返します．つまり，入力配列の一部の矩形領域を独立した配列として扱えるようにします．この関数では ROI を考慮し，実際には ROI の部分配列が取り出されます．

cv::InRange¶

InRange(src, lower, upper, dst) → None¶

入力配列の要素値が，別の2つの配列要素で表される範囲内にあるかどうかをチェックします．

パラメタ:	src (`CvArr`) – 入力配列 lower (`CvArr`) – 下界（その値を含む）を表す配列 upper (`CvArr`) – 上界（その値は含まない）を表す配列 dst (`CvArr`) – 出力配列，8u か 8s 型でなければいけません

この関数は，入力配列の要素毎に範囲チェックを行います：

シングルチャンネル配列の場合，

$\texttt{dst} (I)= \texttt{lower} (I)_0 <= \texttt{src} (I)_0 < \texttt{upper} (I)_0$

2チャンネル配列などの場合，

$\texttt{dst} (I)= \texttt{lower} (I)_0 <= \texttt{src} (I)_0 < \texttt{upper} (I)_0 \land \texttt{lower} (I)_1 <= \texttt{src} (I)_1 < \texttt{upper} (I)_1$

src(I) が範囲内にあれば dst(I) に 0xff（全てのビットが 1 ）がセットされ，そうでなければ 0 がセットされます．出力配列を除くすべての入力配列は，同じ型，同じサイズ（または ROI サイズ）でなければいけません．

cv::InRangeS¶

InRangeS(src, lower, upper, dst) → None¶

入力配列の要素値が，2つのスカラー値で表される範囲内にあるかどうかをチェックします．

パラメタ:	src (`CvArr`) – 入力配列 lower (`CvScalar`) – 下界（その値を含む）を表す配列 upper (`CvScalar`) – 上界（その値は含まない）を表す配列 dst (`CvArr`) – 出力配列，8u か 8s 型でなければいけません

この関数は，入力配列の要素毎に範囲チェックを行います：

シングルチャンネル配列の場合，

$\texttt{dst} (I)= \texttt{lower} _0 <= \texttt{src} (I)_0 < \texttt{upper} _0$

2チャンネル配列などの場合，

$\texttt{dst} (I)= \texttt{lower} _0 <= \texttt{src} (I)_0 < \texttt{upper} _0 \land \texttt{lower} _1 <= \texttt{src} (I)_1 < \texttt{upper} _1$

src(I) が範囲内にあれば dst(I) に 0xff（全てのビットが 1 ）がセットされ，そうでなければ 0 がセットされます．出力配列を除く全ての入力配列は，同じ型，同じサイズ（または ROI サイズ）でなければいけません．

cv::InvSqrt¶

InvSqrt(value) → float¶

平方根の逆数を求めます．

Parameter:	value (float) – 浮動小数点型の入力値

この関数は，引数で与えられた入力値の平方根の逆数を求めます．この関数は，通常， 1./sqrt(value) よりも高速です．入力値が 0以下の場合の処理結果は不定です．また，特別な値（ $\pm \infty$ ， NaN ）は扱うことができません．

cv::Inv¶

Invert

cv::¶

Invert(src, dst, method=CV_LU) → double¶

逆行列，または擬似逆行列を求めます．

パラメタ:	src – 入力行列 dst – 出力行列 method – 逆行列を求める方法 CV_LU 最適ピボット選択によるガウスの消去法 CV_SVD 特異値分解法（SVD） CV_SVD_SYM 正定値対称行列用の特異値分解法

この関数は， src1 の逆行列を求め，それを src2 に格納します．

LU （ガウスの消去法）を用いた場合，この関数は src1 の行列式を返します（もちろん，src1 は正方でなければならない）．この場合の戻り値が 0 の場合，逆行列が計算できなかったという事であり， src2 の要素は 0 で埋められます．

SVD を用いた場合，この関数は src1 の条件数の逆数（最大の特異値に対する最小の特異値の比）を返します． src1 が 0 ならば，この戻り値も 0 になります．また，SVD を用いた場合， src1 が非正則な行列ならば，その擬似逆行列を求めます．

cv::IsInf¶

IsInf(value) → int¶

無限大であるか否かを判定します．

Parameter:	value (float) – 浮動小数点型の入力値

この関数は，引数で与えられた入力値が $\pm \infty$ （無限大；IEEE754 で定義されている）の場合は 1 を返し，そうでなければ 0 を返します．

cv::IsNaN¶

IsNaN(value) → int¶

NaN であるか否かを判定します．

Parameter:	value (float) – 浮動小数点型の入力値

この関数は，引数で与えられた入力値が NaN（非数値；IEEE754 で定義されている）の場合は 1 を返し，そうでなければ 0 を返します．

cv::LUT¶

LUT(src, dst, lut) → None¶

ルックアップテーブルを用いて配列を変換します．

パラメタ:

src (CvArr) – 各要素が8ビットの入力配列
dst (CvArr) – 任意のビット深度，入力配列と等しいチャンネル数の出力配列
lut (CvArr) – 出力配列と等しいビット深度の256要素で構成されるルックアップテーブル．入出力配列がマルチチャンネルの場合，ルックアップテーブルは，シングルチャンネル（この場合は，各チャンネルに対して同じテーブルを使います），あるいは入出力配列と同じチャンネル数である必要があります

この関数は，ルックアップテーブルから取り出した値で出力配列を埋めます．テーブルの要素を指定するインデックスには，入力配列の値が用いられます．つまり，この関数は src の各要素を以下のように処理します：

$\texttt{dst} _i \leftarrow \texttt{lut} _{ \texttt{src} _i + d}$

ここで，

$d = \fork{0}{if \texttt{src} has depth \texttt{CV\_8U}}{128}{if \texttt{src} has depth \texttt{CV\_8S}}$

です．

cv::Log¶

Log(src, dst) → None¶

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

パラメタ:	src (`CvArr`) – 入力配列 dst (`CvArr`) – 出力配列， `double` 型，あるいは入力配列と同じ型

この関数は，入力配列の各要素に対して自然対数を求めます：

$\texttt{dst} [I] = \fork{\log{|\texttt{src}(I)}}{if $\texttt{src}[I] \ne 0$ }{\texttt{C}}{otherwise}$

ここで C は，大きな負の値です（現在の実装では，およそ -700）．

cv::Mahalonobis¶

Mahalonobis(vec1, vec2, mat) → None¶

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

パラメタ:	vec1 (`CvArr`) – 1番目の1次元入力ベクトル vec2 (`CvArr`) – 2番目の1次元入力ベクトル mat (`CvArr`) – 分散共分散行列の逆行列

この関数は，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 （行列は非正則であるかもしれないので CV _ SVD フラグの指定が望ましい）によって求められます．

cv::Max¶

Max(src1, src2, dst) → None¶

2つの配列の要素同士で大きい方を求めます．

パラメタ:	src1 (`CvArr`) – 1 番目の入力配列 src2 (`CvArr`) – 2 番目の入力配列 dst (`CvArr`) – 出力配列

この関数は，2つの配列の各要素を比較して大きい方を求めます：

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

すべての入力配列はシングルチャンネルで，同じデータ型，同じサイズ（または ROI サイズ）でなければいけません．

cv::MaxS¶

MaxS(src, value, dst) → None¶

配列の各要素とスカラー値を比較して大きい方を求めます．

パラメタ:	src (`CvArr`) – 入力配列 value (float) – スカラー値 dst (`CvArr`) – 出力配列

この関数は，配列の各要素とスカラー値を比較して大きい方を求めます：

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

すべての入力配列はシングルチャンネルで，同じデータ型，同じサイズ（または ROI サイズ）でなければいけません．

cv::Merge¶

Merge(src0, src1, src2, src3, dst) → None¶

複数のシングルチャンネル配列を用いて1つのマルチチャンネル配列を構成します．または，配列に1つのチャンネルを挿入します．

パラメタ:	src0 (`CvArr`) – 入力チャンネル 0 src1 (`CvArr`) – 入力チャンネル 1 src2 (`CvArr`) – 入力チャンネル 2 src3 (`CvArr`) – 入力チャンネル 3 dst (`CvArr`) – 最終的に作成される出力配列

関数 cvMerge は， Split とは逆の操作を行います．出力配列が N チャンネルを持ち，引数の最初の N 個のチャンネルが NULL ではない場合，全てのチャンネルがコピーされます．引数の最初の N 個のチャンネルのうち1つだけが NULL ではない場合，そのチャンネルだけが出力配列にコピーされます．そのどちらでもない場合（[NULL,NULL,NULL,NULL]，[NULL,notNULL,notNULL,NULL]など），エラーとなります．残りの（N 番目以降の）入力チャンネルは，常に NULL でなければいけません．COI を設定した IplImage 画像に1つのチャンネルを挿入するためには， Copy を利用することもできます．

cv::Min¶

Min(src1, src2, dst) → None¶

2つの配列の要素同士で小さい方を求めます．

パラメタ:	src1 (`CvArr`) – 1 番目の入力配列 src2 (`CvArr`) – 2 番目の入力配列 dst (`CvArr`) – 出力配列

この関数は，2つの配列の各要素を比較して小さい方を求めます：

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

すべての入力配列はシングルチャンネルで，同じデータ型，同じサイズ（または ROI サイズ）でなければいけません．

cv::MinMaxLoc¶

MinMaxLoc(arr, mask=NULL)-> (minVal, maxVal, minLoc, maxLoc)¶

配列（部分配列）の要素の最大値と最小値を求めます．

パラメタ:

arr (CvArr) – シングルチャンネルの配列，あるいは COI が設定されたマルチチャンネル画像
minVal (float) – 最小値が出力される変数へのポインタ
maxVal (float) – 最大値が出力される変数へのポインタ
minLoc (CvPoint) – 最小値の位置が出力される変数へのポインタ
maxLoc (CvPoint) – 最大値の位置が出力される変数へのポインタ
mask (CvArr) – 部分配列を選択するためのオプションマスク

この関数は，配列の要素の最大・最小値とその位置を求めます．それぞれの値を求めるためにスキャンされる領域は，画像全体あるいはセットされた ROI （ IplImage の場合），また mask が NULL ではない場合は，指定された部分配列領域です．もし，入力がマルチチャンネル配列ならば，それは COI が設定された IplImage 型でなければいけません．入力が2次元配列の場合，極値の座標が min_loc->x と max_loc->x に格納されます．

cv::MinS¶

MinS(src, value, dst) → None¶

配列の各要素とスカラー値を比較して小さい方を求めます．

パラメタ:	src (`CvArr`) – 1番目の入力配列 value (float) – スカラー値 dst (`CvArr`) – 出力配列

この関数は，配列の各要素とスカラー値を比較して大きい方を求めます：

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

すべての入力配列はシングルチャンネルで，同じデータ型，同じサイズ（または ROI サイズ）でなければいけません．

Mirror¶

Flip と同義です．

cv::MixChannels¶

MixChannels(src, dst, fromTo) → None¶

入力配列から出力配列へ，指定された（複数の）チャンネルをコピーします．

パラメタ:

src (cvarr_count) – 入力配列（の配列）
dst (cvarr_count) – 出力配列（の配列）
from_to – コピーされる平面を示すインデックスのペア（入出力）の配列．それぞれの組み合わせ from_to[k]=(i,j) は， src の i番目の平面が dst の j番目の平面にコピーされることを意味します．また，入力配列リストおよび出力配列リストでは，連続した平面番号が用いられます．特別なケースととして， from_to[k][0] が負の値の場合，対応する出力平面 j が0で埋められます

この関数は， Split ， Merge および CvtColor のある形式を一般化したものです．色平面の順番の変更，アルファチャンネルの追加や削除，1つあるいは複数の色平面の挿入や抽出，などに用いることができます．

例として，4チャンネル RGBA 画像を，3チャンネル BGR 画像（つまり，R と B の交換）とアルファチャンネル画像の2つに分離するコードを示します：

rgba = cv.CreateMat(100, 100, cv.CV_8UC4)
bgr =  cv.CreateMat(100, 100, cv.CV_8UC3)
alpha = cv.CreateMat(100, 100, cv.CV_8UC1)
cv.Set(rgba, (1,2,3,4))
cv.MixChannels([rgba], [bgr, alpha], [
   (0, 2),    # rgba[0] -> bgr[2]
   (1, 1),    # rgba[1] -> bgr[1]
   (2, 0),    # rgba[2] -> bgr[0]
   (3, 3)     # rgba[3] -> alpha[0]
])

MulAddS¶

ScaleAdd と同義です．

cv::Mul¶

Mul(src1, src2, dst, scale) → None¶

2つの配列の要素毎の積を求めます．

パラメタ:	src1 (`CvArr`) – 1 番目の入力配列 src2 (`CvArr`) – 2 番目の入力配列 dst (`CvArr`) – 出力配列 scale (float) – オプションであるスケール係数

この関数は，2つの配列要素ごとの積を計算します：

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

すべての入出力配列は，同じ型，同じサイズ（または ROI サイズ）でなければいけません．

また，有限の範囲に値をとる型は，この処理により飽和します．

cv::MulSpectrums¶

MulSpectrums(src1, src2, dst, flags) → None¶

2つのフーリエ・スペクトルの，要素毎の積を求めます．

パラメタ:

src1 (CvArr) – 1 番目の入力配列
src2 (CvArr) – 2 番目の入力配列
dst (CvArr) – 入力配列と同じサイズ，同じ型である出力配列
flags (int) –
以下の値の組み合わせ：
- CV_DXT_ROWS 配列の各行を個別のスペクトルとして扱います（ DFT のパラメータ説明を参照してください）
- CV_DXT_MUL_CONJ 積を計算する前に，2 番目の入力配列の共役を求めます

この関数は，2つの CCS-packed 形式の配列または複素行列において，その要素毎の掛け算を行います．この2つの行列は，実数あるいは複素数のフーリエ変換の結果です．

この関数と関数 DFT を利用することで，2つの配列の畳み込みを高速に計算することができます．

cv::MulTransposed¶

MulTransposed(src, dst, order, delta=NULL, scale) → None¶

行列とその行列の転置行列の積を求めます．

パラメタ:	src (`CvArr`) – 入力行列 dst (`CvArr`) – 出力行列． `CV_32F` あるいは `CV_64F` でなければいけません order (int) – 転置した行列をかける順番 delta (`CvArr`) – オプション．乗算の前に行列 `src` から差し引かれる行列 scale (float) – オプション．スケール係数

この関数は，src とその転置行列の積を求めます：

この関数は，以下のように計算を行います．もし $\texttt{order}=0$ の場合は，

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

そうでない場合は，

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

cv::Norm¶

Norm(arr1, arr2, normType=CV_L2, mask=NULL) → double¶

配列の絶対値ノルム，絶対値差分ノルム，相対値差分ノルムを求めます．

パラメタ:

arr1 (CvArr) – 1 番目の入力画像
arr2 (CvArr) – 2 番目の入力画像．NULLの場合は arr1 の絶対値ノルムが求められ，そうでなければ arr1 - arr2 の絶対値ノルムあるいは相対値ノルムが求められます
normType (int) – ノルムの種類，以下の説明を参照してください
mask (CvArr) – オプションである処理マスク

この関数は， arr2 が NULL の場合は arr1 の絶対値ノルムを計算します：

$norm = \forkthree{||\texttt{arr1}||_C = \max_I |\texttt{arr1}(I)|}{if $\texttt{normType} = \texttt{CV\_C}$}{||\texttt{arr1}||_{L1} = \sum_I |\texttt{arr1}(I)|}{if $\texttt{normType} = \texttt{CV\_L1}$}{||\texttt{arr1}||_{L2} = \sqrt{\sum_I \texttt{arr1}(I)^2}}{if $\texttt{normType} = \texttt{CV\_L2}$}$

arr2 が NULL でない場合は，絶対値差分ノルムが計算されます：

$norm = \forkthree{||\texttt{arr1}-\texttt{arr2}||_C = \max_I |\texttt{arr1}(I) - \texttt{arr2}(I)|}{if $\texttt{normType} = \texttt{CV\_C}$}{||\texttt{arr1}-\texttt{arr2}||_{L1} = \sum_I |\texttt{arr1}(I) - \texttt{arr2}(I)|}{if $\texttt{normType} = \texttt{CV\_L1}$}{||\texttt{arr1}-\texttt{arr2}||_{L2} = \sqrt{\sum_I (\texttt{arr1}(I) - \texttt{arr2}(I))^2}}{if $\texttt{normType} = \texttt{CV\_L2}$}$

または， arr2 が NULL でなく，かつ (normType & CV_RELATIVE) != 0 である場合は相対値差分ノルムが計算されます：

$norm = \forkthree{\frac{||\texttt{arr1}-\texttt{arr2}||_C }{||\texttt{arr2}||_C }}{if $\texttt{normType} = \texttt{CV\_RELATIVE\_C}$}{\frac{||\texttt{arr1}-\texttt{arr2}||_{L1} }{||\texttt{arr2}||_{L1}}}{if $\texttt{normType} = \texttt{CV\_RELATIVE\_L1}$}{\frac{||\texttt{arr1}-\texttt{arr2}||_{L2} }{||\texttt{arr2}||_{L2}}}{if $\texttt{normType} = \texttt{CV\_RELATIVE\_L2}$}$

この関数は，求めたノルムを返します．マルチチャンネル配列は，シングルチャンネル配列として扱われます．つまり，全てのチャンネルに対する処理結果が合計されます．

cv::Not¶

Not(src, dst) → None¶

配列の各要素をビット単位で反転します．

パラメタ:	src (`CvArr`) – 入力配列 dst (`CvArr`) – 出力配列

この関数は，配列の各要素の各ビットを反転します：

dst(I)=~src(I)

cv::Or¶

Or(src1, src2, dst, mask=NULL) → None¶

2つの配列の要素毎に，ビット単位の論理和を計算します．

パラメタ:	src1 (`CvArr`) – 1 番目の入力配列 src2 (`CvArr`) – 2 番目の入力配列 dst (`CvArr`) – 出力配列 mask (`CvArr`) – 8ビットシングルチャンネル配列で表されるオプションマスク．指定された配列要素のみが変更されます

この関数は，2つの配列の要素毎にビット単位の論理和を計算します：

dst(I)=src1(I)|src2(I)

浮動小数点型配列の場合は，それらのビット表現が処理に用いられます．マスクを除くすべての入出力配列は，同じ種類，同じサイズ（または ROI サイズ）でなければいけません．

cv::OrS¶

OrS(src, value, dst, mask=NULL) → None¶

スカラー値と配列の要素毎に，ビット単位の論理和を計算します．

パラメタ:	src (`CvArr`) – 入力配列 value (`CvScalar`) – スカラー値 dst (`CvArr`) – 出力配列 mask (`CvArr`) – 8ビットシングルチャンネル配列で表されるオプションマスク．指定された配列要素のみが変更されます

この関数は，スカラー値と配列要素ごとに，ビット単位の論理和を計算します：

dst(I)=src(I)|value if mask(I)!=0

実際の計算の前に，スカラー値は配列と同じ型に変換されます．また，浮動小数点型配列の場合は，それらのビット表現が処理に用いられます．マスクを除くすべての入出力配列は，同じ種類，同じサイズ（または ROI サイズ）でなければいけません．

cv::PerspectiveTransform¶

PerspectiveTransform(src, dst, mat) → None¶

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

パラメタ:	src (`CvArr`) – 3チャンネル，浮動小数点型の入力配列 dst (`CvArr`) – 3チャンネル，浮動小数点型の出力配列 mat (`CvMat`) – $3\times 3$ あるいは $4 \times 4$ の変換行列

この関数は，配列 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}$

となります．

cv::PolarToCart¶

PolarToCart(magnitude, angle, x, y, angleInDegrees=0) → None¶

極座標系で表現された2次元ベクトルを，カーテシアン座標系表現に変換します．

パラメタ:

magnitude (CvArr) – 各2次元ベクトル大きさを表す配列．NULL ならば，すべてのベクトルの大きさが 1 と見なされます
angle (CvArr) – 各2次元ベクトルの角度を表す配列．単位は，ラジアンあるいは度です
x (CvArr) – 変換後の x 座標を表す出力配列．結果が必要なければ，NULLでも構いません
y (CvArr) – 変換後の y 座標を表す出力配列．結果が必要なければ，NULLでも構いません
angleInDegrees (int) – 出力である角度をデフォルトの「ラジアン」で表現するか，あるいは「度」で表現するかを指定するフラグ

この関数は，各ベクトル magnitude(I)*exp(angle(I)*j), j=sqrt(-1) の x-座標，y-座標を求めます：

x(I)=magnitude(I)*cos(angle(I)),
y(I)=magnitude(I)*sin(angle(I))

cv::Pow¶

Pow(src, dst, power) → None¶

各配列要素をそれぞれ指定された値で累乗します．

パラメタ:	src (`CvArr`) – 入力配列 dst (`CvArr`) – 出力配列，入力と同じ型である必要があります power (float) – 累乗の指数

この関数は，入力配列の各要素を power 乗します：

$\texttt{dst} [I] = \fork{\texttt{src}(I)^p}{if \texttt{p} is integer}{|\texttt{src}(I)^p|}{otherwise}$

つまり，指数 power が整数ではない場合は，入力配列要素の絶対値が計算に用いられます．しかし，入力要素が負の場合でも，いくつか処理を追加すると正しい結果を得ることができます．以下に，配列要素それぞれの立方根を求めるサンプルを示します：

>>> import cv
>>> src = cv.CreateMat(1, 10, cv.CV_32FC1)
>>> mask = cv.CreateMat(src.rows, src.cols, cv.CV_8UC1)
>>> dst = cv.CreateMat(src.rows, src.cols, cv.CV_32FC1)
>>> cv.CmpS(src, 0, mask, cv.CV_CMP_LT)         # 負の要素を見つけます．
>>> cv.Pow(src, dst, 1. / 3)
>>> cv.SubRS(dst, cv.ScalarAll(0), dst, mask)   # 負の入力値に対する結果の正負を反転します．

power が整数値や 0.5，-0.5 などの特別な値の場合は，より高速なアルゴリズムが用いられます．

cv::RNG¶

RNG(seed=-1LL) → CvRNG¶

乱数生成器を初期化します．

Parameter:	seed (`int64`) – 乱数列を初期化するための64ビットの数値

この関数は乱数生成器を初期化し，その状態を表す構造体を返します．その状態構造体へのポインタが，関数 RandInt ， RandReal ， RandArr に渡されます．現在の実装では，繰り上げ付き乗算アルゴリズム（multiply-with-carry）が利用されています．

cv::RandArr¶

RandArr(rng, arr, distType, param1, param2) → None¶

配列を乱数で埋め，RNG の状態を更新します．

パラメタ:

rng (CvRNG) – RNG によって初期化された RNG 状態構造体へのポインタ
arr (CvArr) – 出力配列
distType (int) –
乱数分布の種類
- CV_RAND_UNI 一様分布
- CV_RAND_NORMAL 正規分布（ガウス分布）
param1 (CvScalar) – 1番目の分布パラメータ．一様分布の場合，発生する乱数の下界（この値を含みます）を表します．正規分布の場合，分布の平均値を表します
param2 (CvScalar) – 2番目の分布パラメータ．一様分布の場合，発生する乱数の上界（この値を含みません）を表します．正規分布の場合，分布の標準偏差を表します

この関数は，一様分布した乱数，あるいは正規分布した乱数を用いて出力配列を埋めます．

cv::RandInt¶

RandInt(rng) → unsigned¶

32ビット符号なし整数型の乱数を返し，RNG の状態を更新します．

Parameter:	rng (`CvRNG`) – `RandInit` によって初期化され，オプションで `RandSetRange` によってカスタマイズされるRNG状態構造体へのポインタ（後者の関数は，この関数の結果に影響しません）

この関数は，一様分布に従う 32 ビット符号なし整数型の乱数を返し，RNG の状態を更新します．これは，C言語のランタイムライブラリの rand() 関数に類似しています．しかし，rand() が 0 から RAND_MAX （ $2^{16}$ または $2^{32}$ ，プラットホームに依存）までの値を返すの対して，この関数では常に32ビットの値を生成します．

この関数は，点座標，領域サイズ，テーブルインデックスなどの乱数値を生成するのに用いることができます．特定範囲内の整数は剰余演算によって生成でき，特定範囲内の浮動小数点数は，値の範囲を 0...1 にスケーリングするように割算することで生成できます．

cv::RandReal¶

RandReal(rng) → double¶

浮動小数点型の乱数を返し，RNG の状態を更新します．

Parameter:	rng (`CvRNG`) – RNG によって初期化された RNG 状態構造体へのポインタ

この関数は，0 から 1 の範囲（1自身は含まれない）の一様分布に従う浮動小数点型の乱数を返します．

cv::Reduce¶

Reduce(src, dst, dim=-1, op=CV_REDUCE_SUM) → None¶

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

パラメタ:

src (CvArr) – 入力行列
dst (CvArr) – 入力行列の全ての行または列を指定された方法で累積する，1行または1列の出力ベクトル
dim (int) – 配列の縮小方法を示す次元インデックス．0 の場合は，行列を 1行ベクトルに変換する．1 の場合は，行列を 1 列ベクトルに変換します．-1の場合は， dst サイズを解析して自動的に次元を選択します
op (int) –
変換処理．以下の値をとる：
- CV_REDUCE_SUM 出力ベクトルは，各行（あるいは各列）の総和
- CV_REDUCE_AVG 出力ベクトルは，各行（あるいは各列）の平均
- CV_REDUCE_MAX 出力ベクトルは，各行（あるいは各列）の最大値
- CV_REDUCE_MIN 出力ベクトルは，各行（あるいは各列）の最小値

この関数は，入力行列の各行（あるいは各列）を 1 次元ベクトルの集合として扱い，その集合に対して指定された処理を行うことで行列をベクトルに変換します．例えば，ラスタ画像の水平，垂直方向への射影を計算することができます． CV_REDUCE_SUM や CV_REDUCE_AVG の場合は，計算精度を保つために（桁溢れしないように）出力ベクトル要素のビット深度を入力よりも大きくとるべきです．また，これらの2つのモードの場合は，マルチチャンネル画像を扱うこともできます．

cv::Repeat¶

Repeat(src, dst) → None¶

コピー元配列を用いて，コピー先配列をタイル状に埋めます．

パラメタ:	src (`CvArr`) – コピー元配列，画像または行列 dst (`CvArr`) – コピー先配列，画像または行列

この関数は，コピー元配列を繰り返しコピーして，コピー先配列を埋めます：

dst(i,j)=src(i mod rows(src), j mod cols(src))

コピー先配列は，コピー元配配列より大きくても小さくても構いません．

cv::ResetImageROI¶

ResetImageROI(image) → None¶

画像全体が操作対象となるように ROI をリセットして，ROI 構造体を解放します．

Parameter:	image (`IplImage`) – 画像ヘッダへのポインタ

これは，以下の操作に似ています．

cv.SetImageROI(image, (0, 0, image.width, image.height))
cv.SetImageCOI(image, 0)

cv::Reshape¶

Reshape(arr, newCn, newRows=0) → cvmat¶

データをコピーせずに行列/画像の形状を変更します．

パラメタ:	arr – 入力配列 newCn – 新しいチャンネル数． ‘new _ cn = 0’ の場合は，チャンネル数は変更されません newRows – 新しい行数． ‘new _ rows = 0’ の場合は， `newCn` の値によって変更の必要がでてくる場合を除いて，行数は変更されない

この関数は，与えられた配列を元に CvMat ヘッダを初期化します．これは，元の配列とは異なる形状（チャンネル数や行数が異なる）で，元の配列と同じデータへのポインタを持つ新しい配列ヘッダとなります．

cv::ReshapeMatND¶

ReshapeMatND(arr, newCn, newDims) → cvmat¶

データをコピーせずに多次元配列の形状を変更します．

パラメタ:	arr – 入力配列 newCn – 新しいチャンネル数． $\texttt{newCn} = 0$ の場合は，チャンネル数が変更されていないことを示します newDims – 新しい次元を表すリスト

この関数は， Reshape の拡張バージョンです．この関数は，多次元配列を扱うことができ（普通の画像と行列も扱えます），次元数を変更する事も可能です．

arr として同じデータを共有するものの，異なる次元または異なるチャンネル数の，新しい CvMatND を返します．唯一の要件は，データの総長が変化しないことです．

>>> import cv
>>> mat = cv.CreateMatND([24], cv.CV_32FC1)
>>> print cv.GetDims(cv.ReshapeMatND(mat, 0, [8, 3]))
(8, 3)
>>> m2 = cv.ReshapeMatND(mat, 4, [3, 2])
>>> print cv.GetDims(m2)
(3, 2)
>>> print m2.channels
4

cv::Round¶

Round(value) → int¶

浮動小数点数を，最も近い整数値に変換します．

Parameter:	value (float) – 入力される浮動小数点値

アーキテクチャによっては，この関数は，標準のキャスト操作よりもかなり速い場合があります．引数の絶対値が $2^{31}$ よりも大きい場合の結果は不定です．また，特別な値（ $\pm \infty$ ， NaN ）は扱うことができません．

cv::Floor¶

Floor(value) → int¶

浮動小数点数を，その値以下の最も近い整数値に変換します．

Parameter:	value (float) – 入力される浮動小数点値

アーキテクチャによっては，この関数は，標準のキャスト操作よりもかなり速い場合があります．引数の絶対値が $2^{31}$ よりも大きい場合の結果は不定です．また，特別な値（ $\pm \infty$ ， NaN ）は扱うことができません．

cv::Ceil¶

Ceil(value) → int¶

浮動小数点数を，その値以上の最も近い整数値に変換します．

Parameter:	value (float) – 入力される浮動小数点値

アーキテクチャによっては，この関数は，標準のキャスト操作よりもかなり速い場合があります．引数の絶対値が $2^{31}$ よりも大きい場合の結果は不定です．また，特別な値（ $\pm \infty$ ， NaN ）は扱うことができません．

cv::ScaleAdd¶

ScaleAdd(src1, scale, src2, dst) → None¶

スケーリングされた配列ともう1つの配列の和を求めます．

パラメタ:	src1 (`CvArr`) – 1 番目の入力配列 scale (`CvScalar`) – 1 番目の入力配列を定数倍するスケール係数 src2 (`CvArr`) – 2 番目の入力配列 dst (`CvArr`) – 出力配列

この関数は，スケーリングされた配列ともう1つの配列の和を求めます：

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

すべての入出力配列は，同じ型，同じサイズでなければいけません．

cv::Set¶

Set(arr, value, mask=NULL) → None¶

配列の各要素に与えられた値をセットします．

パラメタ:	arr (`CvArr`) – 値をセットする配列 value (`CvScalar`) – セットされる値 mask (`CvArr`) – 8ビットシングルチャンネル配列で表されるオプションマスク．指定された配列要素のみが変更されます

この関数は，スカラー値 value を，配列の指定された要素すべてにコピーします：

$\texttt{arr} (I)= \texttt{value} \quad \text{if} \quad \texttt{mask} (I) \ne 0$

配列 arr が， IplImage 型である場合，ROI は利用されますが COI を設定してはいけません．

cv::Set1D¶

Set1D(arr, idx, value) → None¶

特定の配列要素をセットします．

パラメタ:	arr (`CvArr`) – 入力配列 idx (int) – 要素インデックス．0が基準点 value (`CvScalar`) – 要素に割り当てられる値

特定の配列要素をセットします．この配列は，1次元でなければいけません．

cv::Set2D¶

Set2D(arr, idx0, idx1, value) → None¶

特定の配列要素をセットします．

パラメタ:	arr (`CvArr`) – 入力配列 idx0 (int) – 要素の行インデックス．0が基準点 idx1 (int) – 要素の列インデックス．0が基準点 value (`CvScalar`) – 要素に割り当てられる値

特定の配列要素をセットします．この配列は，2次元でなければいけません．

cv::Set3D¶

Set3D(arr, idx0, idx1, idx2, value) → None¶

特定の配列要素をセットします．

パラメタ:	arr (`CvArr`) – 入力配列 idx0 (int) – 要素のインデックス．0が基準点 idx1 (int) – 要素のインデックス．0が基準点 idx2 (int) – 要素のインデックス．0が基準点 value (`CvScalar`) – 要素に割り当てられる値

特定の配列要素をセットします．この配列は，3次元でなければいけません．

cv::SetND¶

SetND(arr, indices, value) → None¶

特定の配列要素をセットします．

パラメタ:	arr (`CvArr`) – 入力配列 indices (sequence of int) – 要素インデックスのリスト．0が基準点 value (`CvScalar`) – 要素に割り当てられる値

特定の配列要素をセットします．インデックスリストの長さは，この配列の次元と一致していなければいけません．

cv::SetData¶

SetData(arr, data, step) → None¶

ユーザデータを配列のヘッダに割り当てます．

パラメタ:	arr – 配列のヘッダ data – ユーザデータ step – バイト単位で表される行の長さ

この関数は，ユーザデータを配列のヘッダに割り当てます．このヘッダは，関数 cvCreate*Header ， cvInit*Header あるいは Mat （行列の場合）を用いて，あらかじめ初期化しておく必要があります．

cv::SetIdentity¶

SetIdentity(mat, value=1) → None¶

行列をスカラー倍された単位行列として初期化します．

パラメタ:	mat (`CvArr`) – 初期化される行列（正方である必要はありません） value (`CvScalar`) – 対角要素に割り当てられる値

この関数は，行列をスカラー倍された単位行列として初期化します：

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

cv::SetImageCOI¶

SetImageCOI(image, coi) → None¶

IplImage に COI を設定します．

パラメタ:	image (`IplImage`) – 画像ヘッダへのポインタ coi (int) – 注目チャンネル．0 - 全てのチャンネルを選択，1 - 1番目のチャンネルを選択，2以下も同様．チャンネルは，1から始まることに注意してください

ROI が NULL に設定されており，COI が 0 ではない 場合，COIが確保されます．ほとんどの OpenCV の関数は，COI をサポート しません ．よって，画像や行列のそれぞれのチャンネルを処理する場合，チャンネルを（ Copy や Split によって）別々の画像や行列にコピーしてから処理を行い，必要ならばその結果を（ Copy や Merge によって）再びコピーして戻します．

cv::SetImageROI¶

SetImageROI(image, rect) → None¶

与えられた矩形領域を，画像の ROI として設定します．

パラメタ:	image (`IplImage`) – 画像ヘッダへのポインタ rect (`CvRect`) – ROI を表す矩形領域

元の画像の ROI が NULL であり rect が画像全体ではない場合，ROI 構造体が確保されます.

ほとんどの OpenCV の関数が ROI をサポートしており，矩形の部分画像を別の画像として扱うことができます．例えば，全てのピクセル座標は，元画像の原点からではなく，ROI の原点（左上あるいは左下）からカウントされます．

cv::SetReal1D¶

SetReal1D(arr, idx, value) → None¶

特定の配列要素をセットします．

パラメタ:	arr (`CvArr`) – 入力配列 idx (int) – 要素インデックス．0が基準点 value (float) – 要素に割り当てられる値

特定の配列要素をセットします．この配列は，1次元でなければいけません．

cv::SetReal2D¶

SetReal2D(arr, idx0, idx1, value) → None¶

特定の配列要素をセットします．

パラメタ:	arr (`CvArr`) – 入力配列 idx0 (int) – 要素の行インデックス．0が基準点 idx1 (int) – 要素の列インデックス．0が基準点 value (float) – 要素に割り当てられる値

特定の配列要素をセットします．この配列は，2次元でなければいけません．

cv::SetReal3D¶

SetReal3D(arr, idx0, idx1, idx2, value) → None¶

特定の配列要素をセットします．

パラメタ:	arr (`CvArr`) – 入力配列 idx0 (int) – 要素インデックス．0が基準点 idx1 (int) – 要素インデックス．0が基準点 idx2 (int) – 要素インデックス．0が基準点 value (float) – 要素に割り当てられる値

特定の配列要素をセットします．この配列は，3次元でなければいけません．

cv::SetRealND¶

SetRealND(arr, indices, value) → None¶

特定の配列要素をセットします．

パラメタ:	arr (`CvArr`) – 入力配列 indices (sequence of int) – 要素インデックスのリスト．0が基準点 value (float) – 要素に割り当てられる値

特定の配列要素をセットします．インデックスリストの長さは，この配列の次元と一致していなければいけません．

cv::SetZero¶

SetZero(arr) → None¶

配列をクリアします．

Parameter:	arr (`CvArr`) – クリアされる配列

この関数は，配列をクリアします．密な配列（CvMat，CvMatND，IplImage）に対する cvZero(array) は，cvSet(array,cvScalarAll(0),0) と等価です．

疎な配列の場合は，全ての要素が削除されます．

cv::Solve¶

Solve(A, B, X, method=CV_LU) → None¶

連立1次方程式，あるいは最小2乗問題を解きます．

パラメタ:	A (`CvArr`) – 入力行列 B (`CvArr`) – 連立一次方程式の右辺 X (`CvArr`) – 出力解 method (int) – 逆行列を求める方法 CV_LU 最適ピボット選択によるガウスの消去法 CV_SVD 特異値分解法（SVD） CV_SVD_SYM 正定値対称行列用の特異値分解法

この関数は，連立1次方程式あるいは最小2乗問題を解きます（後者は，SVD によって求められます）：

$\texttt{dst} = argmin_X|| \texttt{src1} \, \texttt{X} - \texttt{src2} ||$

CV_LU の手法が用いられる場合， src1 が正則行列であれば 1 を返し，そうでなければ 0 を返します．後者の場合， dst の値は有効なものではありません．

cv::SolveCubic¶

SolveCubic(coeffs, roots) → None¶

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

パラメタ:	coeffs (`CvMat`) – 3個あるいは4個の値をもつ，方程式の係数配列 roots (`CvMat`) – 実根の出力配列．3個の要素をもちます

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

coeffs が4要素のベクトルである場合：

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

coeffs が3要素のベクトルである場合：

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

この関数は，求めた実根の個数を返し，その実根は root 配列に格納されます．．実根が1つだけの場合，配列の残りの要素は 0 で埋められます．

cv::Split¶

Split(src, dst0, dst1, dst2, dst3) → None¶

マルチチャンネル配列を複数のシングルチャンネル配列に分割します．または，配列から1つのチャンネルだけを抜き出します．

パラメタ:	src (`CvArr`) – 入力配列 dst0 (`CvArr`) – 出力チャンネル 0 dst1 (`CvArr`) – 出力チャンネル 1 dst2 (`CvArr`) – 出力チャンネル 2 dst3 (`CvArr`) – 出力チャンネル 3

この関数は，マルチチャンネル配列を複数のシングルチャンネル配列に分割します．この操作には2つのモードが存在します．入力配列が N チャンネルで，引数の最初の N 個のチャンネルが NULL ではない場合，全てのチャンネルが抜き出されます．引数の最初の N 個のチャンネルのうち1つだけが NULL ではない場合，そのチャンネルだけが抜き出されます．そのどちらでもない場合（[NULL,NULL,NULL,NULL]，[NULL,notNULL,notNULL,NULL]など），エラーとなります．残りの出力チャンネル（最初のN個より後ろ）は，常にNULLでなければいけません． COI を設定した IplImage 画像から1つのチャンネルを抜き出すためには， Copy を利用することもできます．

cv::Sqrt¶

Sqrt(value) → float¶

平方根を求めます．

Parameter:	value (float) – 浮動小数点型の入力値

この関数は，引数で与えられた入力値の平方根を求めます．入力値が負の場合は，処理結果は不定です．

cv::Sub¶

Sub(src1, src2, dst, mask=NULL) → None¶

2つの配列の要素毎の差を求めます．

パラメタ:	src1 (`CvArr`) – 1 番目の入力配列 src2 (`CvArr`) – 2 番目の入力配列 dst (`CvArr`) – 出力配列 mask (`CvArr`) – 8ビットシングルチャンネル配列で表されるオプションマスク．指定された配列要素のみが変更されます

この関数は，1つの配列からもう1つの配列を引きます：

dst(I)=src1(I)-src2(I) if mask(I)!=0

マスクを除くすべての入出力配列は，同じ型，同じサイズ（または ROI サイズ）でなければいけません．

また，有限の範囲に値をとる型は，この処理により飽和します．

cv::SubRS¶

SubRS(src, value, dst, mask=NULL) → None¶

スカラー値から配列要素を引きます．

パラメタ:	src (`CvArr`) – 入力配列 value (`CvScalar`) – 引き算されるスカラー dst (`CvArr`) – 出力配列 mask (`CvArr`) – 8ビットシングルチャンネル配列で表されるオプションマスク．指定された配列要素のみが変更されます

この関数は，スカラー値から入力配列の各要素を引きます：

dst(I)=value-src(I) if mask(I)!=0

マスクを除くすべての入出力配列は，同じ型，同じサイズ（または ROI サイズ）でなければいけません．

また，有限の範囲に値をとる型は，この処理により飽和します．

cv::SubS¶

SubS(src, value, dst, mask=NULL) → None¶

配列からスカラー値を引きます．

パラメタ:	src (`CvArr`) – 入力配列 value (`CvScalar`) – 引き算するスカラー dst (`CvArr`) – 出力配列 mask (`CvArr`) – 8ビットシングルチャンネル配列で表されるオプションマスク．指定された配列要素のみが変更されます

この関数は，入力配列の各要素からスカラー値を引きます：

dst(I)=src(I)-value if mask(I)!=0

マスクを除くすべての入出力配列は，同じ型，同じサイズ（または ROI サイズ）でなければいけません．

また，有限の範囲に値をとる型は，この処理により飽和します．

cv::Sum¶

Sum(arr) → CvScalar¶

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

Parameter:	arr (`CvArr`) – 配列

関数 cvSum は，各チャンネルごとに配列要素値の総和 S を求めます：

$\sum _I \texttt{arr} (I)_c$

配列が IplImage で COI が設定されている場合，この関数は指定されたチャンネルのみを処理し，その結果を戻り値の CvScalar の1番目の要素 $S_0$ に格納します．

cv::SVBkSb¶

SVBkSb(W, U, V, B, X, flags) → None¶

特異値の後退代入を行います．

パラメタ:

W (CvArr) – 特異値を対角要素とする行列，あるいは要素とするベクトル
U (CvArr) – （左）直交行列（転置されている場合もあります）
V (CvArr) – （右）直交行列（転置されている場合もあります）
B (CvArr) – 元の行列 A の擬似逆行列に乗ずるための行列．これは，オプションです．これが省略された場合，適切なサイズの単位行列であると見なされます（その場合は， X は A の擬似逆行列となります）
X (CvArr) – 出力行列．後退代入の結果
flags (int) – オプションである処理フラグ． SVD に渡された flags と一致していなければいけません

この関数は，特異値分解された行列 A （ SVD の説明を参照してください）と行列 B に対して後退代入を行います：

$\texttt{X} = \texttt{V} \texttt{W} ^{-1} \texttt{U} ^T \texttt{B}$

ここで，

$W^{-1}_{(i,i)}= \fork{1/W_{(i,i)}}{if $W_{(i,i)} > \epsilon \sum_i{W_{(i,i)}}$ }{0}{otherwise}$

なお， $\epsilon$ は，行列のデータ型に依存する微小な値です．

この関数は， Invert や Solve の内部で SVD と共に用いられます．これらの「低レベルな」関数（ SVD と SVBkSb ）を用いる状況があるとすれば，これらに対応する高レベルな関数（ Invert と Solve ）内部でのテンポラリな行列の確保を避けるためでしょう．

cv::SVD¶

SVD(A, W, U = None, V = None, flags=0) → None¶

浮動小数点型の実数行列の特異値分解を行います．

パラメタ:

A (CvArr) – $\texttt{M} \times \texttt{N}$ の入力行列
W (CvArr) – 特異値分解の結果得られる対角行列（ $\texttt{M} \times \texttt{N}$ または $\min(\texttt{M}, \texttt{N}) \times \min(\texttt{M}, \texttt{N})$ ) あるいは，特異値のベクトル（ $\min(\texttt{M},\texttt{N}) \times 1$ ）
U (CvArr) – オプション．（左）直交行列 $\texttt{M} \times \min(\texttt{M}, \texttt{N})$ （ CV_SVD_U_T が設定されていない場合），または $\min(\texttt{M},\texttt{N}) \times \texttt{M}$ （ CV_SVD_U_T が指定されている場合），または $\texttt{M} \times \texttt{M}$ （ CV_SVD_U_T フラグには無関係）
V – オプション．（右）直交行列（ $\texttt{N} \times \texttt{N}$ ）
V (CvArr) – オプション．（右）直行行列 $\texttt{N} \times \min(\texttt{M}, \texttt{N})$ （ CV_SVD_V_T が設定されてない場合），または $\min(\texttt{M},\texttt{N}) \times \texttt{N}$ （ CV_SVD_V_T が設定されている場合），または $\texttt{N} \times \texttt{N}$ （ CV_SVD_V_T フラグには無関係）
flags (int) –
処理フラグ，0 あるいは以下の値の組み合わせ：
- CV_SVD_MODIFY_A 計算中に A の値を変更できるようになり，計算が高速化されます
- CV_SVD_U_T U の転置行列が返されるようになり，計算が高速化されます
- CV_SVD_V_T V の転置行列が返されるようになり，計算が高速化されます

この関数は，行列 A を1つの対角行列と2つの直交行列の積に分解します：

$A=U \, W \, V^T$

ここで $W$ は，特異値を対角要素にもつ対角行列であり，特異値を要素とする1次元ベクトルとして表現する事もできます．すべての特異値は非負であり，（ $U$ と $V$ の列と共に）降順にソートされます．

SVD アルゴリズムは，数値的に安定しており，その典型的な応用例には以下のものがあります：

行列 A が正方かつ正定値対称である場合（例えば，分散共分散行列など）の固有値問題の厳密な解法．この場合の $W$ は，固有値を要素とするベクトル/行列となり， $U = V$ は固有ベクトルの行列となります．
劣決定（方程式よりも未知数が多い）連立1次方程式における厳密な解法．
優決定（未知数よりも方程式が多い）連立1次方程式における最小2乗法による解法．これらの場合は， CV_SVD フラグが指定された Solve が実行される．
行列のランク（0 ではない特異値の個数），条件数（最大の特異値と最小の特異値との比），行列式（行列式の絶対値は特異値の直積に等しい）などの様々な特徴量の高精度な計算．

cv::Trace¶

Trace(mat) → CvScalar¶

行列のトレースを求めます．

Parameter:	mat (`CvArr`) – 入力行列

この関数は，入力行列 src1 の対角要素の和を返します．

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

cv::Transform¶

Transform(src, dst, transmat, shiftvec=NULL) → None¶

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

パラメタ:	src (`CvArr`) – 1 番目の入力配列 dst (`CvArr`) – 出力配列 transmat (`CvMat`) – 変換行列 shiftvec (`CvMat`) – オプションである並進ベクトル

この関数は，配列 src の各要素に行列変換を施し，その結果を dst に代入します：

$dst(I) = transmat \cdot src(I) + shiftvec$

つまり， N チャンネル配列 src の各要素を N 個の要素を持つベクトルとして扱い， $\texttt{M} \times \texttt{N}$ の変換行列 transmat と並進ベクトル shiftvec によって変換した結果を， M チャンネル配列 dst の要素に格納します．同次座標系の場合， transmat は $\texttt{M} \times (N+1)$ の行列であり，最右列は並進ベクトルとして扱われます．

入出力配列は共に，同じビット深度，同じサイズ（同じ ROI サイズ）でなければいけません．また， transmat と shiftvec は，浮動小数点型実数を要素にもつ行列でなくていけません．

この関数は，n-次元の点群の幾何学変換，色空間における任意の線形変換，チャンネルの入れ替えなどに利用できます．

cv::Transpose¶

Transpose(src, dst) → None¶

行列を転置します．

パラメタ:	src (`CvArr`) – 入力行列 dst (`CvArr`) – 出力行列

この関数は，入力行列 src1 を転置します：

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

複素行列の場合，複素数の共役化は行われないので，これとは別に行う必要があることに注意してください：この例として， XorS のサンプルコードを参照してください．

cv::Xor¶

Xor(src1, src2, dst, mask=NULL) → None¶

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

パラメタ:	src1 (`CvArr`) – 1 番目の入力配列 src2 (`CvArr`) – 2 番目の入力配列 dst (`CvArr`) – 出力配列 mask (`CvArr`) – 8ビットシングルチャンネル配列で表されるオプションマスク．指定された配列要素のみが変更されます

この関数は，2つの配列の要素毎にビット単位の排他的論理和を計算します：

dst(I)=src1(I)^src2(I) if mask(I)!=0

実際の計算の前に，スカラー値は配列と同じ型に変換されます．また，浮動小数点型配列の場合は，それらのビット表現が処理に用いられます．マスクを除くすべての入出力配列は，同じ型，同じサイズ（または ROI サイズ）でなければいけません．

cv::XorS¶

XorS(src, value, dst, mask=NULL) → None¶

スカラー値と配列の要素毎に，ビット単位の排他的論理和を計算する．

パラメタ:	src (`CvArr`) – 入力配列 value (`CvScalar`) – スカラー値 dst (`CvArr`) – 出力配列 mask (`CvArr`) – 8ビットシングルチャンネル配列で表されるオプションマスク．指定された配列要素のみが変更されます

この関数は，スカラー値と配列要素毎に，ビット単位の論理和を計算します：

dst(I)=src(I)^value if mask(I)!=0

実際の計算の前に，スカラー値は配列と同じ型に変換されます．また，浮動小数点型配列の場合は，それらのビット表現が処理に用いられます．マスクを除くすべての入出力配列は，同じ型，同じサイズ（または ROI サイズ）でなければいけません．

このコードは，次のような結果を出力します：

(1.0,0.0) (0.0,-1.0) (-1.0,0.0) (0.0,1.0)

cv::mGet¶

mGet(mat, row, col) → double¶

シングルチャンネルの浮動小数点型行列の指定された要素を返します．

パラメタ:	mat (`CvMat`) – 入力行列 row (int) – 行を指定するインデックス，0 が基準点 col (int) – 列を指定するインデックス，0 が基準点

この関数は， GetReal2D の高速バージョンで，シングルチャンネルの浮動小数点型行列に対してのみ利用できます．これは，インライン展開，配列や要素の種類チェックが最小限，行と列の範囲チェックはデバックモード時のみ，といった理由で高速に動作します．

cv::mSet¶

mSet(mat, row, col, value) → None¶

シングルチャンネル，浮動小数点型行列の指定された要素を変更します．

パラメタ:	mat (`CvMat`) – 行列 row (int) – 行を指定するインデックス，0 が基準点 col (int) – 列を指定するインデックス，0 が基準点 value (float) – 行列の要素に指定する新しい値

この関数は， SetReal2D の高速バージョンで，シングルチャンネルの浮動小数点型行列に対してのみ利用できます．これは，インライン展開，配列や要素の種類チェックが最小限，行と列の範囲チェックはデバックモード時のみ，といった理由で高速に動作します．

ナビゲーション

配列操作¶

cv::AbsDiff¶

cv::AbsDiffS¶

cv::Add¶

cv::AddS¶

cv::AddWeighted¶

cv::And¶

cv::AndS¶

cv::Avg¶

cv::AvgSdv¶

cv::CalcCovarMatrix¶

cv::CartToPolar¶

cv::Cbrt¶

cv::ClearND¶

cv::CloneImage¶

cv::CloneMat¶

cv::CloneMatND¶

cv::Cmp¶

cv::CmpS¶

cv::Convert¶

cv::ConvertScale¶

cv::ConvertScaleAbs¶

cv::CvtScaleAbs¶

cv::Copy¶

cv::CountNonZero¶

cv::CreateData¶

cv::CreateImage¶

cv::CreateImageHeader¶

cv::CreateMat¶

cv::CreateMatHeader¶

cv::CreateMatND¶

cv::CreateMatNDHeader¶

cv::CrossProduct¶

CvtPixToPlane¶

cv::DCT¶

cv::DFT¶

cv::Det¶

cv::Div¶

cv::DotProduct¶

cv::EigenVV¶

cv::Exp¶

cv::FastArctan¶

cv::Flip¶

cv::fromarray¶

cv::GEMM¶

cv::Get1D¶

cv::Get2D¶

cv::Get3D¶

cv::GetND¶

cv::GetCol¶

cv::GetCols¶

cv::GetDiag¶

cv::GetDims¶

cv::GetElemType¶

cv::GetImage¶

cv::GetImageCOI¶

cv::GetImageROI¶

cv::GetMat¶

cv::GetOptimalDFTSize¶

cv::GetRow¶

cv::GetRows¶

cv::GetSize¶

cv::GetSubRect¶

cv::InRange¶

cv::InRangeS¶

cv::InvSqrt¶

cv::Inv¶

cv::¶

cv::IsInf¶

cv::IsNaN¶

cv::LUT¶

cv::Log¶

cv::Mahalonobis¶

cv::Max¶

cv::MaxS¶

cv::Merge¶

cv::Min¶

cv::MinMaxLoc¶

cv::MinS¶