配列操作

cv::AbsDiff

void cvAbsDiff(const CvArr* src1, const CvArr* src2, CvArr* dst)

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

パラメタ:

• src1 – 1 番目の入力配列
• src2 – 2 番目の入力配列
• dst – 出力配列

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

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

cv::AbsDiffS

void cvAbsDiffS(const CvArr* src, CvArr* dst, CvScalar value)

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

#define cvAbs(src, dst) cvAbsDiffS(src, dst, cvScalarAll(0))

param src:入力配列 param dst:出力配列 param value:スカラー値

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

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

cv::Add

void cvAdd(const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL)

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

パラメタ:

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

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

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

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

cv::AddS

void cvAddS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL)

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

パラメタ:

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

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

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

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

cv::AddWeighted

void cvAddWeighted(const CvArr* src1, double alpha, const CvArr* src2, double beta, double gamma, CvArr* dst)

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

パラメタ:

• src1 – 1番目の入力配列
• alpha – 1番目の配列要素に対する重み
• src2 – 2番目の入力配列
• beta – 2番目の配列要素に対する重み
• dst – 出力配列
• gamma – 各加算結果にさらに加えられるスカラー値

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

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

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

cv::And

void cvAnd(const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL)

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

パラメタ:

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

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

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

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

cv::AndS

void cvAndS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL)

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

パラメタ:

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

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

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

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

以下のサンプルでは，最上位ビットをクリアすることによって浮動小数点型配列の要素の絶対値を求める方法を示しています：

float a[] = { -1, 2, -3, 4, -5, 6, -7, 8, -9 };
CvMat A = cvMat(3, 3, CV_32F, &a);
int i, absMask = 0x7fffffff;
cvAndS(&A, cvRealScalar(*(float*)&absMask), &A, 0);
for(i = 0; i < 9; i++ )
    printf("

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

1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0

cv::Avg

CvScalar cvAvg(const CvArr* arr, const CvArr* mask=NULL)

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

パラメタ:

• arr – 配列
• mask – オプションである処理マスク

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

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

cv::AvgSdv

void cvAvgSdv(const CvArr* arr, CvScalar* mean, CvScalar* stdDev, const CvArr* mask=NULL)

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

パラメタ:

• arr – 配列
• mean – 平均値を出力する変数へのポインタ．必要なければ NULL でも構いません
• stdDev – 標準偏差を出力する変数へのポインタ
• mask – オプションである処理マスク

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

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

cv::CalcCovarMatrix

void cvCalcCovarMatrix(const CvArr** vects, int count, CvArr* covMat, CvArr* avg, int flags)

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

パラメタ:

• vects – 入力ベクトルの配列，これらのベクトルは全て同じ型，同じサイズでなければいけません．ベクトルは1次元である必要はなく，2次元（例えば，画像）などでも構いません
• count – 入力ベクトルの個数
• covMat – 出力である分散共分散行列，浮動小数点型で正方な行列でなければいけません
• avg – 入力あるいは出力（flags に依存する）配列 - 入力ベクトルの平均ベクトル
• flags –

  処理フラグ．以下の値の組み合わせ

  • CV_COVAR_SCRAMBLED 分散共分散行列が以下のように計算されます：

    

    , つまり，分散共分散行列は の行列となります．このような一般的ではない分散共分散行列は，非常に大きなベクトル集合に対する高速なPCAのために利用されます（例えば，顔認識のための固有顔）．この「スクランブルされた」行列の固有値は，真の分散共分散行列の固有値と一致します．また，「真の」固有ベクトルは「スクランブルされた」分散共分散行列の固有ベクトルから容易に求めることができます

  • CV_COVAR_NORMAL 分散共分散行列が以下のように計算されます：

    

    , つまり， 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

void cvCartToPolar(const CvArr* x, const CvArr* y, CvArr* magnitude, CvArr* angle=NULL, int angleInDegrees=0)

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

パラメタ:

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

この関数は，各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

float cvCbrt(float value)

立方根を求めます．

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

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

cv::ClearND

void cvClearND(CvArr* arr, int* idx)

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

パラメタ:

• arr – 入力配列
• idx – 要素を指定するインデックスの配列

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

cv::CloneImage

IplImage* cvCloneImage(const IplImage* image)

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

Parameter:image – オリジナル画像

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

cv::CloneMat

CvMat* cvCloneMat(const CvMat* mat)

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

Parameter:mat – コピーされる行列

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

cv::CloneMatND

CvMatND* cvCloneMatND(const CvMatND* mat)

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

Parameter:mat – 入力配列

cv::CloneSparseMat

CvSparseMat* cvCloneSparseMat(const CvSparseMat* mat)

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

Parameter:mat – 入力配列

この関数は，入力配列のコピーを作成しそのポインタを返します．

cv::Cmp

void cvCmp(const CvArr* src1, const CvArr* src2, CvArr* dst, int cmpOp)

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

パラメタ:

• src1 – 1番目の入力配列
• src2 – 2番目の入力配列．入力配列は，どちらもシングルチャンネルでなければいけません
• dst – 出力配列，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

void cvCmpS(const CvArr* src, double value, CvArr* dst, int cmpOp)

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

パラメタ:

• src – 入力配列，シングルチャンネルでなければいけません
• value – 入力配列の各要素と比較されるスカラー値
• dst – 出力配列，8u か 8s 型でなければいけません
• cmpOp –

  要素同士の関係を指定するフラグ

  • 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 は , , , , , のいずれかです．

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

cv::ConvertScale

void cvConvertScale(const CvArr* src, CvArr* dst, double scale=1, double shift=0)

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

#define cvCvtScale cvConvertScale
#define cvScale  cvConvertScale
#define cvConvert(src, dst )  cvConvertScale((src), (dst), 1, 0 )

param src:入力配列 param dst:出力配列 param scale:スケール係数 param shift:スケーリングされた入力配列要素に加えられる値

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

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

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

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

cv::ConvertScaleAbs

void cvConvertScaleAbs(const CvArr* src, CvArr* dst, double scale=1, double shift=0)

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

パラメタ:

• src – 入力配列
• dst – 出力配列（ビット深度は 8u）
• scale – 絶対値スケール係数
• shift – スケーリングされた入力配列要素に加えられる値

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

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

cv::CvtScaleAbs

void cvCvtScaleAbs(const CvArr* src, CvArr* dst, double scale=1, double shift=0)

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

パラメタ:

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

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

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

cv::Copy

void cvCopy(const CvArr* src, CvArr* dst, const CvArr* mask=NULL)

配列をコピーします．

パラメタ:

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

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

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

cv::CountNonZero

int cvCountNonZero(const CvArr* arr)

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

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

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

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

cv::CreateData

void cvCreateData(CvArr* arr)

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

Parameter:arr – 配列のヘッダ

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

cv::CreateImage

IplImage* cvCreateImage(CvSize size, int depth, int channels)

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

パラメタ:

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

この関数呼び出しは，以下の形式を短縮したものです．

header = cvCreateImageHeader(size, depth, channels);
cvCreateData(header);

cv::CreateImageHeader

IplImage* cvCreateImageHeader(CvSize size, int depth, int channels)

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

パラメタ:

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

この関数呼び出しは，以下の形式に似ています．

hdr=iplCreateImageHeader(channels, 0, depth,
                      channels == 1 ? "GRAY" : "RGB",
                      channels == 1 ? "GRAY" : channels == 3 ? "BGR" :
                      channels == 4 ? "BGRA" : "",
                      IPL_DATA_ORDER_PIXEL, IPL_ORIGIN_TL, 4,
                      size.width, size.height,
                      0,0,0,0);

しかし，この関数はデフォルトでは IPL の関数を用いません（マクロ CV_TURN_ON_IPL_COMPATIBILITY を参照してください）．

cv::CreateMat

CvMat* cvCreateMat(int rows, int cols, int type)

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

パラメタ:

• 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チャンネルの要素を意味します

これは，以下の形式の簡略形と言えます：

CvMat* mat = cvCreateMatHeader(rows, cols, type);
cvCreateData(mat);

cv::CreateMatHeader

CvMat* cvCreateMatHeader(int rows, int cols, int type)

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

パラメタ:

• rows – 行列の行数
• cols – 行列の列数
• type – 行列の要素の種類， CreateMat を参照してください

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

cv::CreateMatND

CvMatND* cvCreateMatND(int dims, const int* sizes, int type)

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

パラメタ:

• dims – 配列の次元数．この値は， CV _ MAX _ DIM （デフォルトでは32ですが，ビルド時に変更される可能性もあります）を越えてはいけません
• sizes – 各次元のサイズを表す配列
• type – 配列の要素の種類， CreateMat を参照してください

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

CvMatND* mat = cvCreateMatNDHeader(dims, sizes, type);
cvCreateData(mat);

cv::CreateMatNDHeader

CvMatND* cvCreateMatNDHeader(int dims, const int* sizes, int type)

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

パラメタ:

• dims – 配列の次元数
• sizes – 各次元のサイズを表す配列
• type – 配列の要素の種類， CreateMat を参照してください

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

cv::CreateSparseMat

CvSparseMat* cvCreateSparseMat(int dims, const int* sizes, int type)

疎な配列を作成します．

パラメタ:

• dims – 配列の次元数．密行列の場合とは逆に，次元数は実質的に無制限（ まで）です
• sizes – 各次元のサイズを表す配列
• type – 配列の要素の種類．CvMat の場合と同じです

この関数は，多次元の疎な配列を確保します．この配列は，初期状態では要素を持ちません．つまり， Get GetReal は，全インデックスに対して 0 を返します．

cv::CrossProduct

void cvCrossProduct(const CvArr* src1, const CvArr* src2, CvArr* dst)

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

パラメタ:

• src1 – 1番目の入力ベクトル
• src2 – 2番目の入力ベクトル
• dst – 出力ベクトル

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

あるいは：

CvtPixToPlane

Split と同義です．

cv::DCT

void cvDCT(const CvArr* src, CvArr* dst, int flags)

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

パラメタ:

• src – 入力配列，1次元配列または2次元の，実数の配列
• dst – 出力配列，入力配列と同じサイズ，同じ型
• flags –

  変換フラグ，以下の値の組み合わせ：

  • CV_DXT_FORWARD 1次元あるいは2次元の順変換を行います
  • CV_DXT_INVERSE 1次元あるいは2次元の逆変換を行います
  • CV_DXT_ROWS 入力配列のそれぞれの行に対して独立に，順変換あるいは逆変換を行います．このフラグによって，複数ベクトルの同時変換が可能になります．また，オーバーヘッド（ベクトルが大量にあると，計算自体の何倍も時間がかかることもあります）を減らし，3次以上の高次元に対して変換を行うことができるようになります

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

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

ここで

および , for です．

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

（ は直行行列なので， ）

の2 次元行列に対するコサイン変換：

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

cv::DFT

void cvDFT(const CvArr* src, CvArr* dst, int flags, int nonzeroRows=0)

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

パラメタ:

• src – 入力配列，実数あるいは複素数
• dst – 出力配列，入力配列と同じサイズ，同じ型
• flags –

  変換フラグ，以下の値の組み合わせ：

  • 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 – 入力配列中で，0 ではない行の数（2次元順変換の場合），あるいは出力配列中の注目する行の数（2次元逆変換の場合）．値が0以下の場合，あるいは行の総数よりも大きい場合は，この引数は無視されます．このパラメータを指定すると，DFT を利用して2次元の畳み込みや相関演算を高速に行うことができます．詳しくは，以下のサンプルを参照してください

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

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

,

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

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

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

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

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

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

CvMat* A = cvCreateMat(M1, N1, CVg32F);
CvMat* B = cvCreateMat(M2, N2, A->type);

// 畳み込み結果の一部（abs(M2-M1)+1 * abs(N2-N1)+1）
// だけになる可能性もあります．
CvMat* conv = cvCreateMat(A->rows + B->rows - 1, A->cols + B->cols - 1,
                           A->type);

// 行列 A と行列 B を初期化します．
...

int dftgM = cvGetOptimalDFTSize(A->rows + B->rows - 1);
int dftgN = cvGetOptimalDFTSize(A->cols + B->cols - 1);

CvMat* dftgA = cvCreateMat(dft_M, dft_N, A->type);
CvMat* dftgB = cvCreateMat(dft_M, dft_N, B->type);
CvMat tmp;

// A を dft_A にコピーし，dft_A の残り部分を 0 で埋めます．
cvGetSubRect(dftgA, &tmp, cvRect(0,0,A->cols,A->rows));
cvCopy(A, &tmp);
cvGetSubRect(dftgA, &tmp, cvRect(A->cols,0,dft_A->cols - A->cols,A->rows));
cvZero(&tmp);
// 以下の cvDFT() では，パラメータ nonzero_rows を利用しているので，
// dft_A の下部を 0 で埋める必要はありません．

cvDFT(dftgA, dft_A, CV_DXT_FORWARD, A->rows);

// 2 番目の配列に対しても同様に繰り返します．
cvGetSubRect(dftgB, &tmp, cvRect(0,0,B->cols,B->rows));
cvCopy(B, &tmp);
cvGetSubRect(dftgB, &tmp, cvRect(B->cols,0,dft_B->cols - B->cols,B->rows));
cvZero(&tmp);
// 以下の cvDFT() では，パラメータ nonzero_rows を利用しているので，
// dft_B の下部を 0 で埋める必要はありません．

cvDFT(dftgB, dft_B, CV_DXT_FORWARD, B->rows);

cvMulSpectrums( dftgA, dft_B, dft_A, 0 /* 畳み込みではなく相関を得るためには
                                            CV_DXT_MUL_CONJ を指定します */ );

cvDFT( dftgA, dft_A, CV_DXT_INV_SCALE, conv->rows ); // 上部のみを計算します．
cvGetSubRect(dftgA, &tmp, cvRect(0,0,conv->cols,conv->rows));

cvCopy(&tmp, conv);

cv::DecRefData

void cvDecRefData(CvArr* arr)

配列データの参照カウンタをデクリメントします．

Parameter:arr – 配列のヘッダへのポインタ

この関数は， CvMat や CvMatND のデータの参照カウンタをデクリメントします．カウンタが 0 になった場合，そのデータは解放されます．現在の実装では，参照カウンタが NULL 以外の値をとるのは，データが関数 CreateData によって確保された場合のみです．カウンタがNULL になる他のケースには，以下の場合があります： SetData によって外部データがヘッダに割り当てられた場合，行列のヘッダがより大きな画像や行列の一部になっている場合，ヘッダが画像や n-次元の行列ヘッダから変換された場合．

cv::Det

double cvDet(const CvArr* mat)

行列式を返します．

Parameter:mat – 入力行列

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

cv::Div

void cvDiv(const CvArr* src1, const CvArr* src2, CvArr* dst, double scale=1)

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

パラメタ:

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

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

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

cv::DotProduct

double cvDotProduct(const CvArr* src1, const CvArr* src2)

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

パラメタ:

• src1 – 1 番目の入力配列
• src2 – 2 番目の入力配列

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

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

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

cv::EigenVV

void cvEigenVV(CvArr* mat, CvArr* evects, CvArr* evals, double eps=0, int lowindex = -1, int highindex = -1)

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

パラメタ:

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

この関数は，行列 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

void cvExp(const CvArr* src, CvArr* dst)

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

パラメタ:

• src – 入力配列
• dst – 出力配列， double 型，あるいは入力配列と同じ型

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

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

cv::FastArctan

float cvFastArctan(float y, float x)

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

パラメタ:

• x – 2次元ベクトルのX座標
• y – 2次元ベクトルのy座標

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

cv::Flip

void cvFlip(const CvArr* src, CvArr* dst=NULL, int flipMode=0)

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

パラメタ:

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

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

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

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

cv::GEMM

void cvGEMM(const CvArr* src1, const CvArr* src2, double alpha, const CvArr* src3, double beta, CvArr* dst, int tABC=0)

#define cvMatMulAdd(src1, src2, src3, dst ) cvGEMM(src1, src2, 1, src3, 1, dst, 0 )#define cvMatMul(src1, src2, dst ) cvMatMulAdd(src1, src2, 0, dst)

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

パラメタ:

• src1 – 1 番目の入力配列
• src2 – 2 番目の入力配列
• src3 – 3 番目の入力配列（シフト用）．もしシフトしない場合は NULLにできます
• dst – 出力配列
• tABC –

  操作フラグ．0 あるいは 以下の値の組み合わせ

  • CV_GEMM_A_T src1 を転置
  • CV_GEMM_B_T src2 を転置
  • CV_GEMM_C_T src3 を転置

  例えば， CV_GEMM_A_T+CV_GEMM_C_T は以下に相当します．

  

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

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

cv::Get?D

CvScalar cvGet1D(const CvArr* arr, int idx0) CvScalar cvGet2D(const CvArr* arr, int idx0, int idx1) CvScalar cvGet3D(const CvArr* arr, int idx0, int idx1, int idx2) CvScalar cvGetND(const CvArr* arr, int* idx)

インデックスで指定された配列要素を返します．

パラメタ:

• arr – 入力配列
• idx0 – 要素を指定するインデックスの第 1 成分，0が基準点
• idx1 – 要素を指定するインデックスの第 2 成分，0が基準点
• idx2 – 要素を指定するインデックスの第 3 成分，0が基準点
• idx – 要素を指定するインデックスの配列

この関数は，指定された配列要素の値を返します．疎な配列で，指定したノードが存在しない場合，この関数は 0 を返します（この関数によって新しいノードは生成されません）．

cv::GetCol(s)

CvMat* cvGetCol(const CvArr* arr, CvMat* submat, int col)

配列中のある1列，または指定範囲内の複数列を返します．

CvMat* cvGetCols(const CvArr* arr, CvMat* submat, int startCol, int endCol)

パラメタ:

• arr – 入力配列
• submat – 結果として得られる部分配列へのポインタ
• col – 選択された列のインデックス，0が基準点
• startCol – 指定範囲の最初の（この値を含む）列のインデックス，0が基準点
• endCol – 指定範囲の最後の（この値を含まない）列のインデックス，0が基準点

関数 GetCol と GetCols は，入力配列中の指定した1列，あるいは指定した範囲内の複数列に対応するヘッダを返します． GetCol は， GetCols のショートカットであることに注意してください：

cvGetCol(arr, submat, col); // ~ cvGetCols(arr, submat, col, col + 1);

cv::GetDiag

CvMat* cvGetDiag(const CvArr* arr, CvMat* submat, int diag=0)

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

パラメタ:

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

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

cvGetDims, cvGetDimSize

配列の次元数と各次元のサイズ，または指定された次元のサイズを返します．

int cvGetDims(const CvArr* arr, int* sizes=NULL)

int cvGetDimSize(const CvArr* arr, int index)

パラメタ:

• arr – 入力配列
• sizes – オプション出力．配列の各次元のサイズを表すベクトル．2次元配列の場合，最初の値は行数（高さ），次の値は列数（幅）を表します
• index – 次元のインデックス指定，0 が基準点（行列では 0 は行数，1 は列数を表します．画像では 0 は高さ, 1 は幅を表します）

関数 cvGetDims は，配列の次元数と各次元のサイズを返します． IplImage や CvMat の場合は，画像や行列の幅に関係なく常に 2 が戻り値になります． 関数 cvGetDimSize は，指定された次元のサイズ（その次元にいくつの要素が含まれるか）を返します．以下のコードでは，配列の要素数を計算する 2 種類の方法を示します：

// cvGetDims() を用いる方法
int sizes[CV_MAX_DIM];
int i, total = 1;
int dims = cvGetDims(arr, size);
for(i = 0; i < dims; i++ )
    total *= sizes[i];

// cvGetDims() と cvGetDimSize() を用いる方法
int i, total = 1;
int dims = cvGetDims(arr);
for(i = 0; i < dims; i++ )
    total *= cvGetDimsSize(arr, i);

cv::GetElemType

int cvGetElemType(const CvArr* arr)

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

Parameter:arr – 入力配列

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

cv::GetImage

IplImage* cvGetImage(const CvArr* arr, IplImage* imageHeader)

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

パラメタ:

• arr – 入力配列
• imageHeader – テンポラリバッファとして利用される IplImage 構造体へのポインタ

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

cv::GetImageCOI

int cvGetImageCOI(const IplImage* image)

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

Parameter:image – 画像ヘッダへのポインタ

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

cv::GetImageROI

CvRect cvGetImageROI(const IplImage* image)

画像の ROI を返します．

Parameter:image – 画像ヘッダへのポインタ

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

cv::GetMat

CvMat* cvGetMat(const CvArr* arr, CvMat* header, int* coi=NULL, int allowND=0)

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

パラメタ:

• arr – 入力配列
• header – テンポラリバッファとして利用される CvMat 構造体へのポインタ
• coi – オプション出力．COIが格納されます
• allowND – これが 0 でない場合，この関数は多次元の密な配列（CvMatND*）を扱うことが可能で，その場合，2次元行列（CvMatND が2次元の場合）あるいは 1次元行列（CvMatNDが 1次元，あるいは 2次元より大きい場合）を返します．配列は連続でなければいけません

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

入力配列になり得るものは，行列 - 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::GetNextSparseNode

CvSparseNode* cvGetNextSparseNode(CvSparseMatIterator* matIterator)

疎な配列の，次の要素へのポインタを返します．

Parameter:matIterator – 疎な配列のイテレータ

この関数は，イテレータを次の要素へ動かし，そこへのポインタを返します．現在のバージョンでは，個々の要素はハッシュテーブルに保存されているので，それらに特別な順番はありません．以下のサンプルで，疎行列内を繰り返し処理する様子を示します：

InitSparseMatIterator と GetNextSparseNode を用いた，浮動小数点型疎行列の総和演算．

double sum;
int i, dims = cvGetDims(array);
CvSparseMatIterator mat_iterator;
CvSparseNode* node = cvInitSparseMatIterator(array, &mat_iterator);

for(; node != 0; node = cvGetNextSparseNode(&mat_iterator ))
{
    /* 要素インデックスへのポインタを取得します． */
    int* idx = CV_NODE_IDX(array, node);
    /* 要素値を取得します（要素の種類が CV_32FC1 であると仮定） */
    float val = *(float*)CV_NODE_VAL(array, node);
    printf("(");
    for(i = 0; i < dims; i++ )
        printf("
    printf("

    sum += val;
}

printf("nTotal sum =

cv::GetOptimalDFTSize

int cvGetOptimalDFTSize(int size0)

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

Parameter:size0 – ベクトルサイズ

この関数は，DFTサイズ N を返します．この N は，DFTを高速に実行できるサイズのうちで size0 以上の最小値です．現在の実装では，ある ， ， に対して となっています．

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

cv::GetRawData

void cvGetRawData(const CvArr* arr, uchar** data, int* step=NULL, CvSize* roiSize=NULL)

配列に関する低レベルの情報を取得します．

パラメタ:

• arr – 配列のヘッダ
• data – 出力．画像全体の原点へのポインタ，ROI が設定されている場合には ROI 原点へのポインタ
• step – 出力．バイト単位で表される行の長さ
• roiSize – 出力．ROI のサイズ

この関数は，配列データに関する低レベル情報を変数に出力します．すべての出力パラメータは任意であり，あるポインタを NULL にセットしても構いません．配列が ROI をもつ IplImage である場合，ROI のパラメータが返されます．

以下に，この関数を用いて配列の要素にアクセスする例を示します． cvGetRawData を用いて，シングルチャンネル，float型配列の要素の絶対値を計算します．

float* data;
int step;

CvSize size;
int x, y;

cvGetRawData(array, (uchar**)&data, &step, &size);
step /= sizeof(data[0]);

for(y = 0; y < size.height; y++, data += step )
    for(x = 0; x < size.width; x++ )
        data[x] = (float)fabs(data[x]);

cv::GetReal?D

double cvGetReal1D(const CvArr* arr, int idx0)

double cvGetReal2D(const CvArr* arr, int idx0, int idx1)

double cvGetReal3D(const CvArr* arr, int idx0, int idx1, int idx2)

double cvGetRealND(const CvArr* arr, int* idx)

インデックスで指定された シングルチャンネル配列の要素を返します．

パラメタ:

• arr – 入力配列，シングルチャンネルでなければいけません
• idx0 – 要素を指定するインデックスの第 1 成分，0が基準点
• idx1 – 要素を指定するインデックスの第 2 成分，0が基準点
• idx2 – 要素を指定するインデックスの第 3 成分，0が基準点
• idx – 要素を指定するインデックスの配列

関数 cvGetReal*D は，シングルチャンネル配列の指定された要素を返します．配列がマルチチャンネルの場合は，ランタイムエラーが発生します．関数 Get は，シングルチャンネルとマルチチャンネルの配列に対して安全に使用することができますが，若干処理速度が遅いことに注意してください．

疎な配列で，指定したノードが存在しない場合，この関数は 0 を返します（この関数によって新しいノードは生成されません）．

cv::GetRow(s)

CvMat* cvGetRow(const CvArr* arr, CvMat* submat, int row)

配列中のある1行，または指定範囲内の複数行を返します．

CvMat* cvGetRows(const CvArr* arr, CvMat* submat, int startRow, int endRow, int deltaRow=1)

パラメタ:

• arr – 入力配列
• submat – 結果として得られる部分配列へのポインタ
• row – 選択された行のインデックス，0が基準点
• startRow – 指定範囲の最初の（この値を含む）行のインデックス，0が基準点
• endRow – 指定範囲の最後の（この値を含まない）行のインデックス，0が基準点
• deltaRow – 行を範囲指定する際のインデックスの間隔，つまりこの関数は， start_row から end_row （この値は含まない）までの範囲で delta_row 毎に行を抽出します

これらの関数は，入力配列中の指定した1行，あるいは指定した範囲内の複数行に対応するヘッダを返します． GetRow は， GetRows のショートカットであることに注意してください：

cvGetRow(arr, submat, row ) ~ cvGetRows(arr, submat, row, row + 1, 1);

cv::GetSize

CvSize cvGetSize(const CvArr* arr)

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

Parameter:arr – 配列のヘッダ

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

cv::GetSubRect

CvMat* cvGetSubRect(const CvArr* arr, CvMat* submat, CvRect rect)

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

パラメタ:

• arr – 入力配列
• submat – 結果として得られる部分配列へのポインタ
• rect – 0 を原点とする座標系で表現される注目矩形領域

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

cv::InRange

void cvInRange(const CvArr* src, const CvArr* lower, const CvArr* upper, CvArr* dst)

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

パラメタ:

• src – 入力配列
• lower – 下界（その値を含む）を表す配列
• upper – 上界（その値は含まない）を表す配列
• dst – 出力配列，8u か 8s 型でなければいけません

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

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

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

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

cv::InRangeS

void cvInRangeS(const CvArr* src, CvScalar lower, CvScalar upper, CvArr* dst)

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

パラメタ:

• src – 入力配列
• lower – 下界（その値を含む）を表す配列
• upper – 上界（その値は含まない）を表す配列
• dst – 出力配列，8u か 8s 型でなければいけません

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

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

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

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

cv::IncRefData

int cvIncRefData(CvArr* arr)

配列のデータ参照カウンタをインクリメントします．

Parameter:arr – 配列のヘッダ

関数 cvIncRefData は， CvMat や CvMatND のデータ参照カウンタをインクリメントし，新しいカウンタの値を返します．参照カウンタポインタが NULL の場合は 0 を返します．

cv::InitImageHeader

IplImage* cvInitImageHeader(IplImage* image, CvSize size, int depth, int channels, int origin=0, int align=4)

あらかじめ確保された画像ヘッダを初期化します．

パラメタ:

• image – 初期化される画像ヘッダ
• size – 画像の幅と高さ
• depth – ビット深度（ CreateImage を参照してください）
• channels – チャンネル数（ CreateImage を参照してください）
• origin – 左上原点 IPL_ORIGIN_TL あるいは，左下原点 IPL_ORIGIN_BL
• align – 画像の行のアラインメント．通常は4，あるいは 8 バイト

戻り値の IplImage* は，初期化されたヘッダへのポインタです．

cv::InitMatHeader

CvMat* cvInitMatHeader(CvMat* mat, int rows, int cols, int type, void* data=NULL, int step=CV_AUTOSTEP)

あらかじめ確保された行列のヘッダを初期化する．

パラメタ:

• mat – 初期化される行列のヘッダへのポインタ
• rows – 行列の行数
• cols – 行列の列数
• type – 行列の要素の種類， CreateMat を参照してください
• data – オプション．行列のヘッダに割り当てられるデータポインタ
• step – オプション．割り当てられたデータの行の長さをバイト単位で表します．デフォルトでは，step には可能な限り小さい値が用いられます．つまり，行列の連続する行間にギャップが存在しません

この関数は，OpenCV の行列関数において raw データ を扱うためによく利用されます．例えば，以下のコードは2つの行列の積を計算し，通常の配列として格納します：

double a[] = { 1, 2, 3, 4,
               5, 6, 7, 8,
               9, 10, 11, 12 };

double b[] = { 1, 5, 9,
               2, 6, 10,
               3, 7, 11,
               4, 8, 12 };

double c[9];
CvMat Ma, Mb, Mc ;

cvInitMatHeader(&Ma, 3, 4, CV_64FC1, a);
cvInitMatHeader(&Mb, 4, 3, CV_64FC1, b);
cvInitMatHeader(&Mc, 3, 3, CV_64FC1, c);

cvMatMulAdd(&Ma, &Mb, 0, &Mc);
// この行列 c には，行列 a(3x4) と 行列 b(4x3) の積が入っている

cv::InitMatNDHeader

CvMatND* cvInitMatNDHeader(CvMatND* mat, int dims, const int* sizes, int type, void* data=NULL)

あらかじめ確保された多次元配列のヘッダを初期化します．

パラメタ:

• mat – 初期化される配列のヘッダへのポインタ
• dims – 配列の次元数
• sizes – 各次元のサイズを表す配列
• type – 配列の要素の種類， CreateMat を参照してください
• data – オプション．配列のヘッダに割り当てられるデータへのポインタ

cv::InitSparseMatIterator

CvSparseNode* cvInitSparseMatIterator(const CvSparseMat* mat, CvSparseMatIterator* matIterator)

疎な配列要素のイテレータを初期化します．

パラメタ:

• mat – 入力配列
• matIterator – 初期化されるイテレータ

この関数は，疎な配列要素のイテレータを初期化し先頭要素へのポインタを返します．配列が空の場合は NULL を返します.

cv::InvSqrt

float cvInvSqrt(float value)

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

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

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

cv::Inv

Invert

cv::

double cvInvert(const CvArr* src, CvArr* dst, int method=CV_LU)

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

パラメタ:

• 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

int cvIsInf(double value)

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

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

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

cv::IsNaN

int cvIsNaN(double value)

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

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

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

cv::LUT

void cvLUT(const CvArr* src, CvArr* dst, const CvArr* lut)

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

パラメタ:

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

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

ここで，

です．

cv::Log

void cvLog(const CvArr* src, CvArr* dst)

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

パラメタ:

• src – 入力配列
• dst – 出力配列， double 型，あるいは入力配列と同じ型

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

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

cv::Mahalonobis

double cvMahalanobis(const CvArr* vec1, const CvArr* vec2, CvArr* mat)

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

パラメタ:

• vec1 – 1番目の1次元入力ベクトル
• vec2 – 2番目の1次元入力ベクトル
• mat – 分散共分散行列の逆行列

この関数は，2つのベクトル間の重み付き距離を計算して返します：

共分散行列は，関数 CalcCovarMatrix によって求められ，その逆行列は，関数 Invert （行列は非正則であるかもしれないので CV _ SVD フラグの指定が望ましい）によって求められます．

cv::Mat

CvMat cvMat(int rows, int cols, int type, void* data=NULL)

行列のヘッダを初期化します（軽量版）．

パラメタ:

• rows – 行列の行数
• cols – 行列の列数
• type – 行列の要素の種類， CreateMat を参照してください
• data – オプション．行列のヘッダに割り当てられるデータポインタ

行列のヘッダを初期化し，それにデータを割り当てます．行列は， row -ワイズ （データ先頭から cols 個の要素が，行列の最初の行に入ります）で埋められます．

この関数は， InitMatHeader の高速なインライン展開であり，以下と等価です：

CvMat mat;
cvInitMatHeader(&mat, rows, cols, type, data, CV_AUTOSTEP);

cv::Max

void cvMax(const CvArr* src1, const CvArr* src2, CvArr* dst)

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

パラメタ:

• src1 – 1 番目の入力配列
• src2 – 2 番目の入力配列
• dst – 出力配列

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

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

cv::MaxS

void cvMaxS(const CvArr* src, double value, CvArr* dst)

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

パラメタ:

• src – 入力配列
• value – スカラー値
• dst – 出力配列

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

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

cv::Merge

void cvMerge(const CvArr* src0, const CvArr* src1, const CvArr* src2, const CvArr* src3, CvArr* dst)

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

#define cvCvtPlaneToPix cvMerge

param src0:入力チャンネル 0 param src1:入力チャンネル 1 param src2:入力チャンネル 2 param src3:入力チャンネル 3 param dst:最終的に作成される出力配列

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

cv::Min

void cvMin(const CvArr* src1, const CvArr* src2, CvArr* dst)

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

パラメタ:

• src1 – 1 番目の入力配列
• src2 – 2 番目の入力配列
• dst – 出力配列

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

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

cv::MinMaxLoc

void cvMinMaxLoc(const CvArr* arr, double* minVal, double* maxVal, CvPoint* minLoc=NULL, CvPoint* maxLoc=NULL, const CvArr* mask=NULL)

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

パラメタ:

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

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

cv::MinS

void cvMinS(const CvArr* src, double value, CvArr* dst)

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

パラメタ:

• src – 1番目の入力配列
• value – スカラー値
• dst – 出力配列

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

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

Mirror

Flip と同義です．

cv::MixChannels

void cvMixChannels(const CvArr** src, int srcCount, CvArr** dst, int dstCount, const int* fromTo, int pairCount)

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

パラメタ:

• src – 入力配列（の配列）
• srcCount – 入力配列の個数
• dst – 出力配列（の配列）
• dstCount – 出力配列の個数
• from_to – コピーされる平面を示すインデックスのペア（入出力）の配列． from_to[k*2] は，0から始まるインデックスであり src の入力チャンネルを表します． また， from_to[k*2+1] は， dst の出力チャンネルを表すインデックスです．ここでは，連続したチャンネル番号が用いられます． つまり，1番目の入力画像チャンネルは， 0 から channels(src[0])-1 までのインデックスで表され， 2番目の入力画像チャンネルは， channels(src[0]) から channels(src[0]) + channels(src[1])-1 までのインデックスで表されます．また，出力画像チャンネルも同様です． 特別なケースとして， from_to[k*2] が負の値の場合，対応する出力チャンネルが0で埋められます

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

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

CvMat* rgba = cvCreateMat(100, 100, CV_8UC4);
CvMat* bgr = cvCreateMat(rgba->rows, rgba->cols, CV_8UC3);
CvMat* alpha = cvCreateMat(rgba->rows, rgba->cols, CV_8UC1);
cvSet(rgba, cvScalar(1,2,3,4));

CvArr* out[] = { bgr, alpha };
int from_to[] = { 0,2,  1,1,  2,0,  3,3 };
cvMixChannels(&bgra, 1, out, 2, from_to, 4);

MulAddS

ScaleAdd と同義です．

cv::Mul

void cvMul(const CvArr* src1, const CvArr* src2, CvArr* dst, double scale=1)

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

パラメタ:

• src1 – 1 番目の入力配列
• src2 – 2 番目の入力配列
• dst – 出力配列
• scale – オプションであるスケール係数

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

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

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

cv::MulSpectrums

void cvMulSpectrums(const CvArr* src1, const CvArr* src2, CvArr* dst, int flags)

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

パラメタ:

• src1 – 1 番目の入力配列
• src2 – 2 番目の入力配列
• dst – 入力配列と同じサイズ，同じ型である出力配列
• flags –

  以下の値の組み合わせ：

  • CV_DXT_ROWS 配列の各行を個別のスペクトルとして扱います（ DFT のパラメータ説明を参照してください）
  • CV_DXT_MUL_CONJ 積を計算する前に，2 番目の入力配列の共役を求めます

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

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

cv::MulTransposed

void cvMulTransposed(const CvArr* src, CvArr* dst, int order, const CvArr* delta=NULL, double scale=1.0)

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

パラメタ:

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

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

この関数は，以下のように計算を行います．もし の場合は，

そうでない場合は，

cv::Norm

double cvNorm(const CvArr* arr1, const CvArr* arr2=NULL, int normType=CV_L2, const CvArr* mask=NULL)

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

パラメタ:

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

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

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

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

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

cv::Not

void cvNot(const CvArr* src, CvArr* dst)

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

パラメタ:

• src – 入力配列
• dst – 出力配列

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

dst(I)=~src(I)

cv::Or

void cvOr(const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL)

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

パラメタ:

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

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

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

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

cv::OrS

void cvOrS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL)

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

パラメタ:

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

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

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

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

cv::PerspectiveTransform

void cvPerspectiveTransform(const CvArr* src, CvArr* dst, const CvMat* mat)

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

パラメタ:

• src – 3チャンネル，浮動小数点型の入力配列
• dst – 3チャンネル，浮動小数点型の出力配列
• mat – あるいは の変換行列

この関数は，配列 src の各要素（2次元，あるいは3次元のベクトルとして扱われます）を以下のように変換します：

ここで，

また，

となります．

cv::PolarToCart

void cvPolarToCart(const CvArr* magnitude, const CvArr* angle, CvArr* x, CvArr* y, int angleInDegrees=0)

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

パラメタ:

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

この関数は，各ベクトル 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

void cvPow(const CvArr* src, CvArr* dst, double power)

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

パラメタ:

• src – 入力配列
• dst – 出力配列，入力と同じ型である必要があります
• power – 累乗の指数

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

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

CvSize size = cvGetSize(src);
CvMat* mask = cvCreateMat(size.height, size.width, CV_8UC1);
cvCmpS( src, 0, mask, CV_CMP_LT ); /* 負の配列要素を見つけます． */
cvPow(src, dst, 1./3);
cvSubRS( dst, cvScalarAll(0), dst, mask ); /* 負の入力値に対する結果の正負を反転します． */
cvReleaseMat(&mask);

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

cv::Ptr?D

uchar* cvPtr1D(const CvArr* arr, int idx0, int* type=NULL)

uchar* cvPtr2D(const CvArr* arr, int idx0, int idx1, int* type=NULL)

uchar* cvPtr3D(const CvArr* arr, int idx0, int idx1, int idx2, int* type=NULL)

uchar* cvPtrND(const CvArr* arr, int* idx, int* type=NULL, int createNode=1, unsigned* precalcHashval=NULL)

インデックスで指定された配列要素へのポインタを返します．

パラメタ:

• arr – 入力配列
• idx0 – 要素を指定するインデックスの第 1 成分，0が基準点
• idx1 – 要素を指定するインデックスの第 2 成分，0が基準点
• idx2 – 要素を指定するインデックスの第 3 成分，0が基準点
• idx – 要素を指定するインデックスの配列
• type – オプション出力．行列要素の種類
• createNode – オプション入力．疎な行列に対するパラメータ．これが 0 でない場合，指定されたインデックスに値が存在しなければ新たに要素を作成します
• precalcHashval – オプション入力．このポインタが NULL でない場合，ノードのハッシュ値を再計算せずに，このハッシュ値で指定された場所の値を取得します．これにより，pair-ワイズ操作が高速化されます

この関数は，指定された配列要素へのポインタを返します．配列の次元数は，関数に渡されるインデックスの個数と一致していなければいけません．ただし，関数 cvPtr1D は，1次元，2次元，...，N次元の密な配列に対しても（シーケンシャルアクセスするために）利用できます．

この関数は，疎な配列に対しても同様に利用できます．指定したノードが存在しない場合，新たにノードを生成し 0 をセットします．

また，配列要素にアクセスする他の関数（ Get , GetReal , Set , SetReal ）と同様に，要素インデックスが範囲外であればエラーになります．

cv::RNG

CvRNG cvRNG(int64 seed=-1)

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

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

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

cv::RandArr

void cvRandArr(CvRNG* rng, CvArr* arr, int distType, CvScalar param1, CvScalar param2)

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

パラメタ:

• rng – RNG によって初期化された RNG 状態構造体へのポインタ
• arr – 出力配列
• distType –

  乱数分布の種類

  • CV_RAND_UNI 一様分布
  • CV_RAND_NORMAL 正規分布（ガウス分布）
• param1 – 1番目の分布パラメータ．一様分布の場合，発生する乱数の下界（この値を含みます）を表します．正規分布の場合，分布の平均値を表します
• param2 – 2番目の分布パラメータ．一様分布の場合，発生する乱数の上界（この値を含みません）を表します．正規分布の場合，分布の標準偏差を表します

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

以下の例では，この関数を利用して，正規分布した浮動小数点の値を，2次元配列内のランダム位置にある値に足し合わせています．

/* noisy_screenは，「めやくちゃな」値の浮動小数点型2次元配列とします */
CvRNG rng_state = cvRNG(0xffffffff);
int i, pointCount = 1000;
/* 2次元点の座標の配列を確保します */
CvMat* locations = cvCreateMat(pointCount, 1, CV_32SC2);
/* 2次元点のランダム値の配列を確保します */
CvMat* values = cvCreateMat(pointCount, 1, CV_32FC1);
CvSize size = cvGetSize(noisy_screen);

/* 座標配列を初期化します */
cvRandArr(&rng_state, locations, CV_RAND_UNI, cvScalar(0,0,0,0),
           cvScalar(size.width,size.height,0,0));

/* 値を生成します */
cvRandArr(&rng_state, values, CV_RAND_NORMAL,
          cvRealScalar(100), // 輝度値の平均
          cvRealScalar(30) // 輝度値の標準偏差
          );

/* 2次元点をセット */
for(i = 0; i < pointCount; i++ )
{
    CvPoint pt = *(CvPoint*)cvPtr1D(locations, i, 0);
    float value = *(float*)cvPtr1D(values, i, 0);
    *((float*)cvPtr2D(noisy_screen, pt.y, pt.x, 0 )) += value;
}

/* テンポラリ配列を忘れずに解放します */
cvReleaseMat(&locations);
cvReleaseMat(&values);

/* RNG 状態構造体は解放する必要がありません */

cv::RandInt

unsigned cvRandInt(CvRNG* rng)

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

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

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

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

RandInt を利用して，前述の例を書き直したものを以下に示します：

/* 入力値と内容は以前のサンプルと同じです */
CvRNG rnggstate = cvRNG(0xffffffff);
int i, pointCount = 1000;
/* ... - ここでは配列の確保を行いません */
CvSize size = cvGetSize(noisygscreen);
/* 呼び出しのオーバヘッドを減らすために正規分布に従う値のバッファを生成します */
#define bufferSize 16
float normalValueBuffer[bufferSize];
CvMat normalValueMat = cvMat(bufferSize, 1, CVg32F, normalValueBuffer);
int valuesLeft = 0;

for(i = 0; i < pointCount; i++ )
{
    CvPoint pt;
    /* ランダムな座標を生成します */
    pt.x = cvRandInt(&rnggstate )
    pt.y = cvRandInt(&rnggstate )

    if(valuesLeft <= 0 )
    {
        /* バッファが空の場合，正規分布に従う値でバッファを埋めます */
        cvRandArr(&rnggstate, &normalValueMat, CV_RAND_NORMAL,
                   cvRealScalar(100), cvRealScalar(30));
        valuesLeft = bufferSize;
    }
    *((float*)cvPtr2D(noisygscreen, pt.y, pt.x, 0 ) =
                                normalValueBuffer[--valuesLeft];
}

/* 行列のヘッダとデータはスタック上に存在するため，normalValueMat を
   解放する必要はありません．これは小さい固定サイズの行列を扱う際の，
   効果的で有名な手法です */

cv::RandReal

double cvRandReal(CvRNG* rng)

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

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

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

cv::Reduce

void cvReduce(const CvArr* src, CvArr* dst, int dim = -1, int op=CV_REDUCE_SUM)

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

パラメタ:

• src – 入力行列
• dst – 入力行列の全ての行または列を指定された方法で累積する，1行または1列の出力ベクトル
• dim – 配列の縮小方法を示す次元インデックス．0 の場合は，行列を 1行ベクトルに変換する．1 の場合は，行列を 1 列ベクトルに変換します．-1の場合は， dst サイズを解析して自動的に次元を選択します
• op –

  変換処理．以下の値をとる：

  • CV_REDUCE_SUM 出力ベクトルは，各行（あるいは各列）の総和
  • CV_REDUCE_AVG 出力ベクトルは，各行（あるいは各列）の平均
  • CV_REDUCE_MAX 出力ベクトルは，各行（あるいは各列）の最大値
  • CV_REDUCE_MIN 出力ベクトルは，各行（あるいは各列）の最小値

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

cv::ReleaseData

void cvReleaseData(CvArr* arr)

配列データを解放します．

Parameter:arr – 配列のヘッダ

この関数は，配列データを解放します．配列が CvMat や CvMatND の場合は，単に cvDecRefData() が呼ばれます．つまり，この関数は外部のデータを解放することはできません． CreateData の注意事項も参照してください．

cv::ReleaseImage

void cvReleaseImage(IplImage** image)

画像ヘッダとデータを解放します．

Parameter:image – 画像ヘッダへのダブルポインタ

この関数呼び出しは，以下の形式を短縮したものです．

if(*image )
{
    cvReleaseData(*image);
    cvReleaseImageHeader(image);
}

cv::ReleaseImageHeader

void cvReleaseImageHeader(IplImage** image)

画像ヘッダを解放します．

Parameter:image – 画像ヘッダへのダブルポインタ

この関数呼び出しは，以下の形式に似ています．

if(image )
{
    iplDeallocate(*image, IPL_IMAGE_HEADER | IPL_IMAGE_ROI);
    *image = 0;
}

しかし，この関数はデフォルトでは IPL の関数を利用しません（マクロ CV_TURN_ON_IPL_COMPATIBILITY を参照してください）．

cv::ReleaseMat

void cvReleaseMat(CvMat** mat)

行列を解放します．

Parameter:mat – 行列へのダブルポインタ

この関数は，行列データの参照カウンタをデクリメントし，行列ヘッダを解放します．データの参照カウンタが 0 になった場合は，そのデータも解放されます．

if(*mat )
    cvDecRefData(*mat);
cvFree((void**)mat);

cv::ReleaseMatND

void cvReleaseMatND(CvMatND** mat)

多次元の配列を解放します．

Parameter:mat – 配列へのダブルポインタ

この関数は，配列データの参照カウンタをデクリメントし，配列ヘッダを解放します．データの参照カウンタが 0 になった場合は，そのデータも解放されます．

if(*mat )
    cvDecRefData(*mat);
cvFree((void**)mat);

cv::ReleaseSparseMat

void cvReleaseSparseMat(CvSparseMat** mat)

疎な配列を解放します．

Parameter:mat – 配列へのダブルポインタ

この関数は，疎な配列を解放し，関数の終了時に配列ポインタをクリアします．

cv::Repeat

void cvRepeat(const CvArr* src, CvArr* dst)

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

パラメタ:

• src – コピー元配列，画像または行列
• dst – コピー先配列，画像または行列

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

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

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

cv::ResetImageROI

void cvResetImageROI(IplImage* image)

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

Parameter:image – 画像ヘッダへのポインタ

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

しかし，この関数ではさらに ROI 構造体を解放することができます．

cvSetImageROI(image, cvRect(0, 0, image->width, image->height ));
cvSetImageCOI(image, 0);

cv::Reshape

CvMat* cvReshape(const CvArr* arr, CvMat* header, int newCn, int newRows=0)

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

パラメタ:

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

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

例えば，次のコードでは，1つの画像とそれに対する2つの画像ヘッダ（320x240x3，960x240x1）を作成します：

IplImage* color_img = cvCreateImage(cvSize(320,240), IPL_DEPTH_8U, 3);
CvMat gray_mat_hdr;
IplImage gray_img_hdr, *gray_img;
cvReshape(color_img, &gray_mat_hdr, 1);
gray_img = cvGetImage(&gray_mat_hdr, &gray_img_hdr);

そして，次の例では，3x3 の行列を 1x9 のベクトルに変換しています：

CvMat* mat = cvCreateMat(3, 3, CV_32F);
CvMat row_header, *row;
row = cvReshape(mat, &row_header, 0, 1);

cv::ReshapeMatND

CvArr* cvReshapeMatND(const CvArr* arr, int sizeofHeader, CvArr* header, int newCn, int newDims, int* newSizes)

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

#define cvReshapeND(arr, header, newCn, newDims, newSizes )   \
      cvReshapeMatND((arr), sizeof(*(header)), (header),         \
                      (newCn), (newDims), (newSizes))

param arr:入力配列 param sizeofHeader:  出力されるヘッダのサイズ，IplImage，CvMat， CvMatND を区別するために用いられます param header:出力される新しいヘッダ param newCn:新しいチャンネル数． ‘new _ cn = 0’ の場合は，チャンネル数は変更されません param newDims:新しい次元数． の場合は，次元数は変更されません param newSizes:新しい次元数，を要素とする配列．要素の総数は変化してはいけないので， 個の値のみが利用されます．したがって， の場合は，配列 newSizes は利用されません

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

Reshape の項で説明した2つのサンプルを， ReshapeMatND を用いて書き直すと次のようになります：

IplImage* color_img = cvCreateImage(cvSize(320,240), IPL_DEPTH_8U, 3);
IplImage gray_img_hdr, *gray_img;
gray_img = (IplImage*)cvReshapeND(color_img, &gray_img_hdr, 1, 0, 0);

...

/* 2 番目例 は 2x2x2 の配列を 8x1 のベクトルに変換する例に変更します */
int size[] = { 2, 2, 2 };
CvMatND* mat = cvCreateMatND(3, size, CV_32F);
CvMat row_header, *row;
row = (CvMat*)cvReshapeND(mat, &row_header, 0, 1, 0);

cv::cvRound, cvFloor, cvCeil

int cvRound(double value) int cvFloor(double value) int cvCeil(double value)

浮動小数点型の値を整数型の値に変換します．

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

関数 cvRound ， cvFloor ， cvCeil は，それぞれの丸め方を用いて，浮動小数点型の入力値を整数型に変換します． cvRound は，入力値に最も近い整数値を返します． cvFloor は，入力値より大きくない最大の整数値を返します． cvCeil は，入力値より小さくない最小の整数値を返します． これらの関数は，（処理系によっては）C言語の標準キャスト関数よりも大幅に高速に動作します． 入力値の絶対値が よりも大きければ，処理結果は不定です．また，特別な値（ ， NaN ）は扱うことができません．

cv::ScaleAdd

void cvScaleAdd(const CvArr* src1, CvScalar scale, const CvArr* src2, CvArr* dst)

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

パラメタ:

• src1 – 1 番目の入力配列
• scale – 1 番目の入力配列を定数倍するスケール係数
• src2 – 2 番目の入力配列
• dst – 出力配列

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

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

cv::Set

void cvSet(CvArr* arr, CvScalar value, const CvArr* mask=NULL)

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

パラメタ:

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

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

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

cv::Set?D

void cvSet1D(CvArr* arr, int idx0, CvScalar value)

void cvSet2D(CvArr* arr, int idx0, int idx1, CvScalar value)

void cvSet3D(CvArr* arr, int idx0, int idx1, int idx2, CvScalar value)

void cvSetND(CvArr* arr, int* idx, CvScalar value)

インデックスで指定された配列要素を変更します．

パラメタ:

• arr – 入力配列
• idx0 – 要素を指定するインデックスの第 1 成分，0が基準点
• idx1 – 要素を指定するインデックスの第 2 成分，0が基準点
• idx2 – 要素を指定するインデックスの第 3 成分，0が基準点
• idx – 要素を指定するインデックスの配列
• value – 新しい値

これらの関数は，指定した配列要素に新しい値を割り当てて変更します．疎な配列の場合に指定ノードが存在しなければ，新たにノードを生成します．

cv::SetData

void cvSetData(CvArr* arr, void* data, int step)

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

パラメタ:

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

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

cv::SetIdentity

void cvSetIdentity(CvArr* mat, CvScalar value=cvRealScalar(1))

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

パラメタ:

• mat – 初期化される行列（正方である必要はありません）
• value – 対角要素に割り当てられる値

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

cv::SetImageCOI

void cvSetImageCOI(IplImage* image, int coi)

IplImage に COI を設定します．

パラメタ:

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

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

cv::SetImageROI

void cvSetImageROI(IplImage* image, CvRect rect)

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

パラメタ:

• image – 画像ヘッダへのポインタ
• rect – ROI を表す矩形領域

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

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

cv::SetReal?D

void cvSetReal1D(CvArr* arr, int idx0, double value)

void cvSetReal2D(CvArr* arr, int idx0, int idx1, double value)

void cvSetReal3D(CvArr* arr, int idx0, int idx1, int idx2, double value)

void cvSetRealND(CvArr* arr, int* idx, double value)

インデックスで指定された配列要素を変更します．

パラメタ:

• arr – 入力配列
• idx0 – 要素を指定するインデックスの第 1 成分，0が基準点
• idx1 – 要素を指定するインデックスの第 2 成分，0が基準点
• idx2 – 要素を指定するインデックスの第 3 成分，0が基準点
• idx – 要素を指定するインデックスの配列
• value – 新しい値

この関数は，シングルチャンネル配列の指定した要素に新しい値を割り当てて変更します．配列がマルチチャンネルのときは，ランタイムエラーが発生します．関数 Set*D は，シングルチャンネルとマルチチャンネルの配列に対して安全に使用することができますが，若干処理速度が遅いことに注意してください．

疎な配列の場合に指定ノードが存在しなければ，新たにノードを生成します．

cv::SetZero

void cvSetZero(CvArr* arr)

配列をクリアします．

#define cvZero cvSetZero

param arr:クリアされる配列

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

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

cv::Solve

int cvSolve(const CvArr* src1, const CvArr* src2, CvArr* dst, int method=CV_LU)

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

パラメタ:

• A – 入力行列
• B – 連立一次方程式の右辺
• X – 出力解
• method –

  逆行列を求める方法

  • CV_LU 最適ピボット選択によるガウスの消去法
  • CV_SVD 特異値分解法（SVD）
  • CV_SVD_SYM 正定値対称行列用の特異値分解法

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

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

cv::SolveCubic

void cvSolveCubic(const CvArr* coeffs, CvArr* roots)

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

パラメタ:

• coeffs – 3個あるいは4個の値をもつ，方程式の係数配列
• roots – 実根の出力配列．3個の要素をもちます

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

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

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

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

cv::Split

void cvSplit(const CvArr* src, CvArr* dst0, CvArr* dst1, CvArr* dst2, CvArr* dst3)

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

パラメタ:

• src – 入力配列
• dst0 – 出力チャンネル 0
• dst1 – 出力チャンネル 1
• dst2 – 出力チャンネル 2
• dst3 – 出力チャンネル 3

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

cv::Sqrt

float cvSqrt(float value)

平方根を求めます．

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

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

cv::Sub

void cvSub(const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL)

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

パラメタ:

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

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

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

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

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

cv::SubRS

void cvSubRS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL)

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

パラメタ:

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

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

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

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

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

cv::SubS

void cvSubS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL)

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

パラメタ:

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

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

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

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

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

cv::Sum

CvScalar cvSum(const CvArr* arr)

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

Parameter:arr – 配列

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

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

cv::SVBkSb

void cvSVBkSb(const CvArr* W, const CvArr* U, const CvArr* V, const CvArr* B, CvArr* X, int flags)

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

パラメタ:

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

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

ここで，

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

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

cv::SVD

void cvSVD(CvArr* A, CvArr* W, CvArr* U=NULL, CvArr* V=NULL, int flags=0)

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

パラメタ:

• A – の入力行列
• W – 特異値分解の結果得られる対角行列（ または ) あるいは，特異値のベクトル（ ）
• U – オプション．（左）直交行列 （ CV_SVD_U_T が設定されていない場合），または （ CV_SVD_U_T が指定されている場合），または （ CV_SVD_U_T フラグには無関係）
• V – オプション．（右）直交行列（ ）
• V – オプション．（右）直行行列 （ CV_SVD_V_T が設定されてない場合），または （ CV_SVD_V_T が設定されている場合），または （ CV_SVD_V_T フラグには無関係）
• flags –

  処理フラグ，0 あるいは以下の値の組み合わせ：

  • CV_SVD_MODIFY_A 計算中に A の値を変更できるようになり，計算が高速化されます
  • CV_SVD_U_T U の転置行列が返されるようになり，計算が高速化されます
  • CV_SVD_V_T V の転置行列が返されるようになり，計算が高速化されます

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

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

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

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

cv::Trace

CvScalar cvTrace(const CvArr* mat)

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

Parameter:mat – 入力行列

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

cv::Transform

void cvTransform(const CvArr* src, CvArr* dst, const CvMat* transmat, const CvMat* shiftvec=NULL)

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

パラメタ:

• src – 1 番目の入力配列
• dst – 出力配列
• transmat – 変換行列
• shiftvec – オプションである並進ベクトル

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

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

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

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

cv::Transpose

void cvTranspose(const CvArr* src, CvArr* dst)

行列を転置します．

パラメタ:

• src – 入力行列
• dst – 出力行列

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

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

cv::Xor

void cvXor(const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL)

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

パラメタ:

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

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

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

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

cv::XorS

void cvXorS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL)

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

パラメタ:

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

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

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

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

以下のサンプルは，虚部の最上位ビットを反転することで共役複素ベクトルを求める方法を示しています：

float a[] = { 1, 0, 0, 1, -1, 0, 0, -1 }; /* 1, j, -1, -j */
CvMat A = cvMat(4, 1, CV_32FC2, &a);
int i, negMask = 0x80000000;
cvXorS(&A, cvScalar(0, *(float*)&negMask, 0, 0 ), &A, 0);
for(i = 0; i < 4; i++ )
    printf("(%.1f, %.1f) ", a[i*2], a[i*2+1]);

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

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

cv::mGet

double cvmGet(const CvMat* mat, int row, int col)

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

パラメタ:

• mat – 入力行列
• row – 行を指定するインデックス，0 が基準点
• col – 列を指定するインデックス，0 が基準点

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

cv::mSet

void cvmSet(CvMat* mat, int row, int col, double value)

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

パラメタ:

• mat – 行列
• row – 行を指定するインデックス，0 が基準点
• col – 列を指定するインデックス，0 が基準点
• value – 行列の要素に指定する新しい値

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