CXCORE リファレンスマニュアル


基本構造体(Basic Structures)


★★★
CvPoint

整数座標系による2次元の点

     typedef struct CvPoint
     {
	 int x; /* x 座標.通常は0が原点 */
	 int y; /* y 座標.通常は0が原点 */
     }
     CvPoint;

     /* コンストラクタ */
     inline CvPoint cvPoint( int x, int y );

     /* CvPoint2D32f からの変換 */
     inline CvPoint cvPointFrom32f( CvPoint2D32f point );
 

★★
CvPoint2D32f

浮動小数点型(単精度)座標系による2次元の点

     typedef struct CvPoint2D32f
     {
	 float x; /* x 座標.通常は0が原点 */
	 float y; /* y 座標.通常は0が原点 */
     }
     CvPoint2D32f;
 

★★
CvPoint3D32f

浮動小数点型(単精度)座標系による3次元の点

     typedef struct CvPoint3D32f
     {
	 float x; /* x 座標.通常は0が原点 */
	 float y; /* y 座標.通常は0が原点 */
	 float z; /* z 座標.通常は0が原点 */
     }
     CvPoint3D32f;
 

★★
CvPoint2D64f

浮動小数点型(倍精度)座標系による2次元の点

     typedef struct CvPoint2D64f
     {
	 double x; /* x 座標.通常は0が原点 */
	 double y; /* y 座標.通常は0が原点 */
     }
     CvPoint2D64f;
 

★★
CvPoint3D64f

浮動小数点型(倍精度)座標系による3次元の点

     typedef struct CvPoint3D64f
     {
	 double x; /* x 座標.通常は0が原点 */
	 double y; /* y 座標.通常は0が原点 */
	 double z; /* z 座標.通常は0が原点 */
     }
     CvPoint3D64f;
 

★★★
CvSize

矩形のピクセル精度でのサイズ

    typedef struct CvSize
    {
        int width; /* 矩形の幅 */
        int height; /* 矩形の高さ */
    }
    CvSize;

    /* コンストラクタ */
    inline CvSize cvSize( int width, int height );

使用例は、3.1 セピア変換を参照。


★★
CvSize2D32f

矩形のサブピクセル精度でのサイズ

     typedef struct CvSize2D32f
     {
	 float width;  /* 矩形の幅 */
	 float height; /* 矩形の高さ */
     }
     CvSize2D32f;
 

★★★
CvRect

矩形のオフセットとサイズ

    typedef struct CvRect
    {
        int x; /* 矩形の左角の x 座標 */
        int y; /* 矩形の上角(あるいは下角)の y 座標 */
        int width; /* 矩形の幅 */
        int height; /* 矩形の高さ */
    }
    CvRect;

    /* コンストラクタ */
    inline CvRect cvRect( int x, int y, int width, int height );

使用例は、4.9 物体追跡を参照。


★★★
CvScalar

4個までの数を納めるコンテナ

    typedef struct CvScalar
    {
        double val[4];
    }
    CvScalar;

    /* コンストラクタ:val[0] を val0 で初期化.val[1] を val1 で初期化.… */
    inline CvScalar cvScalar( double val0, double val1=0,
                              double val2=0, double val3=0 );
    /* コンストラクタ:val[0]...val[3] を val0123 で初期化 */
    inline CvScalar cvScalarAll( double val0123 );

    /* コンストラクタ:val[0] を val0 で初期化.val[1]...val[3] を 0 で初期化 */
    inline CvScalar cvRealScalar( double val0 );

使用例は、3.1 セピア変換を参照。


★★★
CvTermCriteria

反復アルゴリズムのための終了条件

 #define CV_TERMCRIT_ITER    1
 #define CV_TERMCRIT_NUMBER  CV_TERMCRIT_ITER
 #define CV_TERMCRIT_EPS     2

 typedef struct CvTermCriteria
 {
     int    type;  /* CV_TERMCRIT_ITER と CV_TERMCRIT_EPS の組合せ */
     int    max_iter; /* 反復数の最大値 */
     double epsilon; /* 目標精度 */
 }
 CvTermCriteria;

 /* コンストラクタ */
 inline  CvTermCriteria  cvTermCriteria( int type, int max_iter, double epsilon );

 /* 終了条件をチェックし,type=CV_TERMCRIT_ITER+CV_TERMCRIT_EPS に設定し,
    反復数の max_iterとeprilon の両方が有効になるように変換する */
 CvTermCriteria cvCheckTermCriteria( CvTermCriteria criteria,
				     double default_eps,
				     int default_max_iters );
 

使用例については、4.9 物体追跡を参照。


★★★
CvMat

多重行列

     typedef struct CvMat
     {
	 int type; /* CvMat シグネチャ (CV_MAT_MAGIC_VAL).要素の型とフラグ */
	 int step; /* 全行のバイト長 */

	 int* refcount; /* 内部的に利用されるデータ参照カウンタ */

	 union
	 {
	     uchar* ptr;
	     short* s;
	     int* i;
	     float* fl;
	     double* db;
	 } data; /* データポインタ */

     #ifdef __cplusplus
	 union
	 {
	     int rows;
	     int height;
	 };

	 union
	 {
	     int cols;
	     int width;
	 };
     #else
	 int rows; /* 行の数 */
	 int cols; /* 列の数 */
     #endif

     } CvMat;
 

★★
CvMatND

多次元、多チャンネルの密な行列

     typedef struct CvMatND
     {
	 int type; /* CvMatND シグネチャ (CV_MATND_MAGIC_VAL).要素の型とフラグ */
	 int dims; /* 配列の次元数 */

	 int* refcount; /* 内部的に利用されるデータ参照カウンタ */

	 union
	 {
	     uchar* ptr;
	     short* s;
	     int* i;
	     float* fl;
	     double* db;
	 } data; /* データポインタ */

	 /* 各次元での(要素数、要素間のバイト距離)の組 */
	 struct
	 {
	     int size;
	     int step;
	 }
	 dim[CV_MAX_DIM];

     } CvMatND;
 

★★
CvSparseMat

多次元、多チャンネルの疎な行列

     typedef struct CvSparseMat
     {
	 int type;             /* CvSparseMat シグネチャ(CV_SPARSE_MAT_MAGIC_VAL).要素の型とフラグ */
	 int dims;             /* 次元数 */
	 int* refcount;        /* 参照カウンタ - 使用されない */
	 struct CvSet* heap;   /* ハッシュテーブルノードの保存領域(プール) */
	 void** hashtable;     /* ハッシュテーブル:各エントリは,同じ「hashvalue の hashsize を法とする剰余」
				  をノードのリストとして持つ */
	 int hashsize;         /* ハッシュテーブルのサイズ */
	 int total;            /* 粗な配列ノードの総数 */
	 int valoffset;        /* 配列ノードの値のオフセット(バイト単位) */
	 int idxoffset;        /* 配列ノードのインデックスのオフセット(バイト単位) */
	 int size[CV_MAX_DIM]; /* 次元サイズの配列 */

     } CvSparseMat;
 

★★★
IplImage

IPL 画像ヘッダ

     typedef struct _IplImage
     {
	 int  nSize;         /* sizeof(IplImage) */
	 int  ID;            /* バージョン (=0)*/
	 int  nChannels;     /* OpenCV のほとんどの関数が,1,2,3および4チャンネルをサポートする */
	 int  alphaChannel;  /* OpenCV では無視される */
	 int  depth;         /* ピクセルの色深度のビット数:IPL_DEPTH_8U, IPL_DEPTH_8S, IPL_DEPTH_16U,
							    IPL_DEPTH_16S, IPL_DEPTH_32S, 
							    IPL_DEPTH_32F, IPL_DEPTH_64F がサポートされる */
	 char colorModel[4]; /* OpenCV では無視される */
	 char channelSeq[4]; /* 同上 */
	 int  dataOrder;     /* 0 - インタリーブカラーチャンネル.1 - 分離カラーチャンネル,
				cvCreateImage が作成できるのは,インタリーブ画像のみ.*/
	 int  origin;        /* 0 - 左上原点、
				1 - 左下原点(Windowsのビットマップ形式) */
	 int  align;         /* 画像の行のアライメント(4 あるいは 8).
				OpenCV はこれを無視して,代わりに widthStep を使用する. */
	 int  width;         /* 画像のピクセル幅 */
	 int  height;        /* 画像のピクセル高さ */
	 struct _IplROI *roi;/* 画像 ROI.これが NULL でない場合,この特定の領域が処理の対象となる */
	 struct _IplImage *maskROI; /* OpenCV では必ずNULL */
	 void  *imageId;     /* 同上 */
	 struct _IplTileInfo *tileInfo; /* 同上 */
	 int  imageSize;     /* 画像データのバイトサイズ
				(インタリーブデータの場合は,=image->height*image->widthStep) */
	 char *imageData;    /* アライメントが調整された画像データへのポインタ */
	 int  widthStep;     /* アライメントが調整された画像の行のバイトサイズ */
	 int  BorderMode[4]; /* 画像境界の設定.OpenCV では無視される */
	 int  BorderConst[4]; /* 同上 */
	 char *imageDataOrigin; /* オリジナル画像データへのポインタ
				   (アライメントが調整されているとは限らない)
				   - これは画像を正しく解放するために必要. */
     }
     IplImage;
 

IplImage 構造体は元々、Intel Image Processing Library 固有のものであった。 OpenCVでは IplImage フォーマットの一部のみをサポートしている。

上述の制限に加えて OpenCV では ROI の扱いが異なる。 OpenCVでは全ての入力および出力画像のサイズ、またはその ROI サイズが正確に一致する必要がある (処理に依存する。例えば cvPyrDown の出力幅(高さ)は、入力幅(高さ)の 1/2±1でなければならない)。しかしIPL では重複する領域が処理の対象となる。つまり画像のサイズ、または ROI のサイズが全ての画像において異なる可能性もある。

使用例については、3.1 セピア変換を参照。


★★★
CvArr

任意の配列

     typedef void CvArr;
 

メタ型 CvArr* は、1種類以上の配列(例えば IplImage*、CvMat*、CvSeq*など)を引数にとる関数を記述するための仮引数としてのみ利用される。 個々の配列型は、実行時にヘッダの最初の4バイトを分析することで決定される。


配列操作(Operations on Arrays)


初期化(Initialization)


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

ヘッダの作成とデータ領域の確保

size
画像の幅と高さ。
depth
画像要素のビットデプス。以下の内のいずれか。
IPL_DEPTH_8U - 符号無し 8 ビット整数
IPL_DEPTH_8S - 符号有り 8 ビット整数
IPL_DEPTH_16U - 符号無し 16 ビット整数
IPL_DEPTH_16S - 符号有り 16 ビット整数
IPL_DEPTH_32S - 符号有り 32 ビット整数
IPL_DEPTH_32F - 単精度浮動小数点数
IPL_DEPTH_64F - 倍精度浮動小数点数
channels
要素(ピクセル)毎のチャンネル数。1, 2, 3, 4 のいずれか。このチャンネルはインタリーブされる。例えば、通常のカラー画像のデータレイアウトは、
b0 g0 r0 b1 g1 r1 ...
となっている。一般的な IPL 画像フォーマットはノンインタリーブ画像を格納することができ、これを処理することができる OpenCV の関数も存在するが、この関数はインタリーブ画像しか作成できない。

cvCreateImage関数はヘッダを作成し、データ領域を確保する。これは、以下の形式を短縮したものである。

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

使用例は、2.2 チュートリアル、3.1 セピア変換を参照。


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

メモリ確保と初期化を行い、IplImage 構造体を返す

size
画像の幅と高さ。
depth
画像のカラーデプス(CreateImage を参照)。
channels
チャンネル数(CreateImage を参照)。

cvCreateImageHeader 関数は、メモリ確保と初期化を行い、 IplImage 構造体を返す。これは、

   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 の関数を用いない。


★★★
 void cvReleaseImageHeader( IplImage** image );
 

ヘッダを解放する

image
確保したヘッダへのポインタのポインタ。

cvReleaseImageHeader 関数は、ヘッダを解放する。これは、

     if( image )
     {
	 iplDeallocate( *image, IPL_IMAGE_HEADER | IPL_IMAGE_ROI );
	 *image = 0;
     }
 
と似ているが、この関数はデフォルトでは IPL の関数を用いない。


★★★
 void cvReleaseImage( IplImage** image );
 

ヘッダと画像データを解放する

image
確保した画像ヘッダへのポインタのポインタ。

cvReleaseImage関数 は、ヘッダと画像データを解放する。 これは、以下の形式を短縮したものである。

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

使用例は、2.2 チュートリアル、3.1 セピア変換を参照。



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

ユーザによって確保された画像ヘッダを初期化する


★★★
 IplImage* cvCloneImage( const IplImage* image );
 

画像の完全なコピーを作成する

image
オリジナル画像。

cvCloneImage 関数は、ヘッダ、ROI、データを含む画像の完全なコピー を作成する。


★★★
 void cvSetImageCOI( IplImage* image, int coi );
 

与えられた値を channel of interest(COI)としてセットする

image
画像ヘッダ。
coi
COI(Channel of interest)。

cvSetImageCOI 関数は、与えられた値を COI(channel of interest)としてセットする。 値 0 は全てのチャンネルが選択されている事を意味し、値 1 は最初のチャンネルが選択されている事を意味する。 もしCOI が NULL かつ、パラメータが coi != 0 の場合には、COI が確保される。 OpenCV の関数の多くは COI をサポートしていないことに注意すること。 別々の画像/行列チャンネルを処理するには、(cvCopycvSplit によって)別々の画像/行列へチャンネルをコピーし、 それを処理してから、必要ならばその結果を(cvCopycvCvtPlaneToPix によって)もう一度コピーし直して返す。


★★★
 int cvGetImageCOI( const IplImage* image );
 

COI のインデックスを戻す

image
画像ヘッダ。

cvGetImageCOI 関数は、画像の COI(channel of interest)を返す(全チャンネルが選択される場合には、0 が返される)。


★★★
 void cvSetImageROI( IplImage* image, CvRect rect );
 

与えられた矩形を画像の ROI としてセットする

image
画像ヘッダ。
rect
ROI を表す矩形。

cvSetImageROI 関数は、与えられた矩形を画像の ROI としてセットする。 もし、ROI が NULL で、パラメータ rect の値が画像全体ではない場合には、ROI が確保される。 COI とは異なり、OpenCV の関数の多くが ROI をサポートしている。 そして、ROI はある意味、別の画像として扱われる(例えば、全てのピクセル座標は ROI の左上あるいは左下(画像の原点に依存)からカウントされる)。


★★★
 void cvResetImageROI( IplImage* image );
 

画像の ROI を解放する

image
画像ヘッダ。

cvResetImageROI 関数は、画像の ROI を解放する。 解放後は全画像が選択されている状態と同じになる。 以下のようにしても、同じように全選択ができるが、この方法では image->roi は解放されない。

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


★★★
 CvRect cvGetImageROI( const IplImage* image );
 

画像の ROI 座標を返す

image
画像ヘッダ。

cvGetImageROI 関数は、画像の ROI 座標を返す。 ROI が存在しない場合には、矩形 cvRect(0,0,image->width,image->height) が返される。


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

新たな行列を作成する

rows
行列の行数。
cols
行列の列数。
type
行列要素の種類。通常、次のような指定形式になる。 CV_<bit_depth>(S|U|F)C<number_of_channels>。例えば、
CV_8UC1 は、符号無し 8 ビット 1 チャンネル行列、 CV_32SC2 は、符号有り 32 ビット 2 チャンネル行列を意味する。

cvCreateMat関数は、新たな行列とその内部データのためのヘッダを確保し、作成された行列へのポインタを返す。これは以下の省略形である。

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

行列は行単位で保存され、すべての行は4バイトでアライメントされる。

使用例については、3.3 幾何変換、3.4 行列演算を参照。


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

新たな行列のヘッダを作成する

rows
行列の行数。
cols
行列の列数。
type
行列要素の種類(cvCreateMatを参照)。

cvCreateMatHeader関数は、新たな行列のヘッダを作成し、そのポインタを返す。 さらに、cvCreateData を用いるか、cvSetData により、ユーザが確保したデータ領域を明示的にセットすることで、行列データが確保される。

使用例は、4.2 ヒストグラムを参照。


★★★
 void cvReleaseMat( CvMat** mat );
 

行列を解放する

mat
行列へのポインタのポインタ。

cvReleaseMat 関数は、行列データの参照カウンタをデクリメントして、行列ヘッダを解放する。

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


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

行列ヘッダを初期化する

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

cvInitMatHeader 関数は、既に確保された CvMat 構造体を初期化する。 これは、OpenCV の行列関数で生データを処理するために用いることもできる。


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

行列ヘッダを初期化する(軽量版)

rows
行列の行数。
cols
行列の列数。
type
行列要素の種類(CreateMat を参照)。
data
行列のヘッダで指定されるデータへのポインタ(オプション)。

cvMat 関数は、 cvInitMatHeader の高速なインライン置換である。つまり、これは以下と等価である。

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


★★★
 CvMat* cvCloneMat( const CvMat* mat );
 

行列のコピーを作成する

mat
入力行列。

cvCloneMat 関数は、入力行列のコピーを作成し、そのポインタを返す。



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

多次元の密な配列を作成する



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

新たな行列のヘッダを作成する



 void cvReleaseMatND( CvMatND** mat );
 

多次元配列を解放する



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

多次元配列のヘッダを初期化する



 CvMatND* cvCloneMatND( const CvMatND* mat );
 

多次元配列の完全なコピーを作成する



 void cvDecRefData( CvArr* arr );
 

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



 int cvIncRefData( CvArr* arr );
 

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


★★
 void cvCreateData( CvArr* arr );
 

配列データを確保する

arr
配列ヘッダ。


★★
 void cvReleaseData( CvArr* arr );
 

配列データを解放する

arr
配列ヘッダ。


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

ユーザデータを配列ヘッダに割り当てる

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

cvSetData関数は、ユーザデータを配列のヘッダに割り当てる。 ヘッダは、cvCreate*Header関数、cvInit*Header関数 あるいは cvMat関数(行列の場合)を用いて、あらかじめ初期化されるべきである。

使用例は、4.2 ヒストグラムを参照。


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

配列の低レベル情報を取り出す

arr
配列ヘッダ。
data
出力である全画像の原点へのポインタ、あるいは ROI が設定されている場合は ROI の原点へのポインタ。
step
出力であるバイト単位で表された行の長さ。
roi_size
出力であるROI サイズ。


★★
 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次元より大きい場合)を返す。 配列は連続でなければならない。

cvGetMat 関数は、入力配列に対する行列ヘッダを返す。 入力配列になり得るものは、行列 - CvMat、画像 - IplImage あるいは、多次元の密な配列 - CvMatND*(最後の例は、allowND != 0 の場合のみ)である。 行列の場合、この関数は単に入力ポインタを返す。 IplImage* あるいは CvMatND* の場合は、 現在の画像の ROI のパラメータで header 構造体を初期化し、このテンポラリ構造体へのポインタを返す。 COI は CvMat ではサポートされないので、これは別に返される。

この関数は、同じコードで 2種類の配列 - IplImage および CvMat - を扱う簡単な方法を提供する。 cvGetImage 関数によって、CvMat から IplImage への逆変換が可能である。

入力配列は、確保あるいは添付された内部データを持たなければならず、そうでない場合は、この関数は失敗する。

入力配列が、平面(二次元)データレイアウトおよび COI を持つ IplImage の場合、 この関数は選択された平面へのポインタおよび COI = 0 を返す。 OpenCV の関数を用いて、平面データレイアウトを持つマルチチャンネル画像を平面毎に処理する事が可能である。


★★
 IplImage* cvGetImage( const CvArr* arr, IplImage* image_header );
 

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

arr
入力配列。
image_header
テンポラリバッファとして用いられる IplImage 構造体へのポインタ。


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

疎な配列を作成する

dims
配列の次元数。密な行列とは逆に、次元数は実質的には無制限である(216 まで)。
sizes
次元サイズの配列。
type
配列要素の種類。CvMat のものと同じ。


★★
 void cvReleaseSparseMat( CvSparseMat** mat );
 

疎な配列を解放する

mat
配列へのポインタのポインタ。


★★
 CvSparseMat* cvCloneSparseMat( const CvSparseMat* mat );
 

疎な配列の完全なコピーを作成する

mat
入力配列。


要素へのアクセスと部分配列(Accessing Elements and sub-Arrays)


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

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

arr
入力配列.
submat
結果として得られる部分配列のヘッダへのポインタ。
rect
着目する矩形領域の、0 を基準とした座標。

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


★★★
 CvMat* cvGetRow( const CvArr* arr, CvMat* submat, int row );
 CvMat* cvGetRows( const CvArr* arr, CvMat* submat, int start_row, int end_row, int delta_row=1 );
 

配列中の1行または、指定された範囲の行(複数行)を返す

arr
入力配列。
submat
結果として得られる部分配列のヘッダへのポインタ。
row
選択した行の、0を基準としたインデックス。
start_row
範囲の最初の(この値を含む)行の、0を基準としたインデックス。
end_row
範囲の最後の(この値を含まない)行の、0を基準としたインデックス。
delta_row
行の範囲のインデックス間隔。 この関数は、start_rowからend_row(は含まない)まで、delta_row毎に行を抽出する.

GetRow関数とGetRows関数は、入力配列中の指定した1行、あるいは範囲の複数行に相当するヘッダを返す。注釈:GetRowcvGetRowsのショートカットである。

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


★★★
 CvMat* cvGetCol( const CvArr* arr, CvMat* submat, int col );
 CvMat* cvGetCols( const CvArr* arr, CvMat* submat, int start_col, int end_col );
 

配列中の1列または、指定された範囲の列(複数列)を返す

arr
入力配列。
submat
結果として得られる部分配列のヘッダへのポインタ。
col
選択した列の、0を基準としたインデックス。
start_col
範囲の最初の(この値を含む)列の、0を基準としたインデックス
end_col
範囲の最後の(この値を含まない)列の、0を基準としたインデックス。

GetCol関数とGetCols関数は入力配列中の指定した1列、あるいは範囲の複数列に相当するヘッダを返す。注釈:GetColcvGetColsのショートカットである。

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


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

配列の対角列の一つを返す

arr
入力配列。
submat
結果として得られる部分配列のヘッダへのポインタ。
diag
対角配列。0はメインの対角列に対応し、-1はメイン対角列の一つ上の斜め列、1はメイン対角列の一つ下の斜め列、という様に対応する。


★★★
 CvSize cvGetSize( const CvArr* arr );
 

行列または画像の ROI のサイズを返す

arr
配列のヘッダ。

cvGetSize関数は、入力行列または画像の行数(CvSize::height)と列数(CvSize::width)を返す。画像の場合は ROI のサイズが返される。

使用例は、3.2 クロマキーを参照。


★★
 CvSparseNode* cvInitSparseMatIterator( const CvSparseMat* mat,
					CvSparseMatIterator* mat_iterator );
 

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

mat
入力配列。
mat_iterator
初期化されるイテレータ。


★★
 CvSparseNode* cvGetNextSparseNode( CvSparseMatIterator* mat_iterator );
 

疎な配列において次の要素のポインタを返す

mat_iterator
疎な配列のイテレータ。


★★
 int cvGetElemType( const CvArr* arr );
 

配列要素のタイプを返す

arr
入力配列。


★★
 int cvGetDims( const CvArr* arr, int* sizes=NULL );
 int cvGetDimSize( const CvArr* arr, int index );
 

配列の次元数とそれらのサイズ、または特定の次元のサイズを返す

arr
入力配列。
sizes
配列の次元の大きさを示すオプションの出力ベクトル。2次元配列の場合は1番目に行数(高さ)、次は列数(幅)を示す。
index
0を基準にした次元のインデックス(行列では0は行数、1は列数を示す。画像では0は高さ, 1は幅を示す)。


★★★
 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, const int* idx, int* type=NULL, int create_node=1, unsigned* precalc_hashval=NULL );
 

特定の配列要素へのポインタを返す

arr
入力配列。
idx0
要素インデックスの、0を基準とした第1成分。
idx1
要素インデックスの、0を基準とした第2成分。
idx2
要素インデックスの、0を基準とした第3成分。
idx
要素インデックスの配列。
type
オプションの出力パラメータ。行列要素のタイプ。
create_node
疎な行列に対するオプションの入力パラメータ。非0の場合、指定された要素が存在しないときは要素を生成する。
precalc_hashval
疎な行列に対するオプションの入力パラメータ。ポインタがNULLでないとき、関数はノードのハッシュ値を再計算せず、指定された場所から取ってくる。 これにより、ペアワイズ操作の速度が向上する。

cvPtr*D 関数は、特定の配列要素へのポインタを返す。1次元からN次元までの密な配列への連続的なアクセスに用いられるcvPtr1D 関数の場合を除いて、配列の次元数は関数の引き数として渡されるインデックスの数と一致しなければならない。

同様に、この関数は、疎な配列に対しても用いられる。指定したノードが存在しない場合、関数はそれを生成し、0をセットする。

配列要素にアクセスするその他の関数(cvGet*D, cvGetReal*D, cvSet*D, cvSetReal*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, const int* idx );
 

特定の配列要素を返す

arr
入力配列。
idx0
要素インデックスの0を基準とした第1成分。
idx1
要素インデックスの0を基準とした第2成分。
idx2
要素インデックスの0を基準とした第3成分。
idx
要素インデックスの配列。

cvGet*D 関数は、特定の配列要素を返す。疎な配列で、指定したノードが存在しない場合、この関数は0を返す(この関数によって新しいノードは生成されない)。

使用例については、4.8 形状特徴抽出を参照。


★★★
 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, const int* idx );
 

シングルチャンネルの配列の特定の要素を返す

arr
入力配列。 シングルチャンネルでなくてはならない。
idx0
要素インデックスの、0を基準とした第1成分。
idx1
要素インデックスの、0を基準とした第2成分。
idx2
要素インデックスの、0を基準とした第3成分。
idx
要素インデックスの配列。

cvGetReal*D 関数は、シングルチャンネルの配列の特定の要素を返す。配列がマルチチャンネルの場合は、ランタイムエラーが発生する。 注釈:cvGet*D 関数はシングルチャンネルとマルチチャンネルの配列に対して安全に使用することができるが、若干処理速度が遅い。

指定したノードが存在しなければ、この関数は0を返す(この関数によって新しいノードは生成されない)。

使用例については、4.8 形状特徴抽出を参照。


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

シングルチャンネル浮動小数点型行列の特定の要素を返す

mat
入力行列.
row
行の0を基準としたインデックス。
col
列の0を基準としたインデックス.

使用例は、3.4 行列演算を参照。


★★★
 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, const int* idx, CvScalar value );
 

特定の配列要素を変更する

arr
入力配列。
idx0
要素インデックスの、0を基準とした第1成分。
idx1
要素インデックスの、0を基準とした第2成分。
idx2
要素インデックスの、0を基準とした第3成分。
idx
要素インデックスの配列。
value
割り当てる値。

cvSet*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, const int* idx, double value );
 

特定の配列要素を変更する

arr
入力配列。
idx0
要素インデックスの、0を基準とした第1成分。
idx1
要素インデックスの、0を基準とした第2成分。
idx2
要素インデックスの、0を基準とした第3成分。
idx
要素インデックスの配列。
value
割り当てる値。

cvSetReal*D 関数はシングルチャンネルの配列の指定した要素に新しい値を割り当てる。 配列がマルチチャンネルのときは、ランタイムエラーが起こる。 注釈:cvSet*D 関数はシングルチャンネルとマルチチャンネルの両方に安全に使用することができるが、若干処理速度が遅い。

疎な配列の場合に、ノードが存在しなれば、この関数はノードを生成する。


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

シングルチャンネルの浮動小数点型行列の特定の要素の値を変更する

mat
行列。
row
行の、0を基準としたインデックス。
col
列の、0を基準としたインデックス。
value
行列の要素の新しい値。

使用例は、3.4 行列演算を参照。


★★
 void cvClearND( CvArr* arr, const int* idx );
 

特定の要素の値をクリアする

arr
入力配列。
idx
要素のインデックスの配列。


コピーと充填(Copying and Filling)


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

一つの配列を別の配列にコピーする

src
コピー元の配列。
dst
コピー先の配列。
mask
8 ビットシングルチャンネル配列の処理マスク。コピー先の配列の変更する要素を指定する。

cvCopy関数 は、入力配列から出力配列に選択された要素をコピーする。

mask(I)!=0 の場合、dst(I)=src(I)

引数の配列が IplImage 型の場合、その ROI と COI が利用される。 コピー元配列とコピー先配列は、同じ型、同じ次元、同じサイズでなければならない。この関数は、疎な配列もコピーできる(この場合、マスクはサポートされない)。

使用例は、3.2 クロマキーを参照。


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

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

arr
値をセットする配列。
value
配列を埋める値。
mask
8 ビットシングルチャンネル配列の処理マスク。配列の変更する要素を指定する。

cvSet関数 は、スカラー値 value を、配列の選択された各要素にコピーする。

mask(I)!=0 の場合、arr(I)=value

配列 arrIplImage 型の場合、 ROI は利用されるが、COI がセットされていてはならない。

使用例は、3.1 セピア変換、4.2 ヒストグラムを参照。


★★★
 void cvSetZero( CvArr* arr );
 #define cvZero cvSetZero
 

配列をクリアする

arr
クリアされる配列。

cvSetZero関数 は、配列をクリアする。 密な配列(CvMat, CvMatND, IplImage)に対する cvZero(array) は、cvSet(array,cvScalarAll(0),0) と等価である。 疎な配列の場合は、全ての要素が削除される。

使用例は、3.2 クロマキーを参照。


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

スカラー倍された単位行列を用いて初期化を行う

arr
初期化される行列(正方である必要はない)。
value
対角成分の値。

cvSetIdentity 関数は、スカラー倍された単位行列を用いた初期化を行う。

 i=j ならば、    arr(i,j)=value
 そうでなければ、         0
 


★★
 void cvRange( CvArr* mat, double start, double end );
 

与えられた範囲の数で行列を埋める

mat
初期化される行列。これは、整数型あるいは浮動小数点型 32 ビットシングルチャンネルでなくてはならない。
start
範囲の下限(範囲に含まれる)。
end
範囲の上限(範囲に含まれない)。


変形と置換(Transforms and Permutations)


★★
 CvMat* cvReshape( const CvArr* arr, CvMat* header, int new_cn, int new_rows=0 );
 

データのコピーなしに行列/画像の形状を変える

arr
入力配列。
header
書き込まれる出力ヘッダ。
new_cn
新しいチャンネル数 。new_cn = 0はチャンネル数が変更されていないことを意味する。
new_rows
新しい行数。 new_rows = 0は、行数がnew_cnの値に応じて変更する必要があるのにも関わらず、変更されないままであることを意味する。


★★
 CvArr* cvReshapeMatND( const CvArr* arr,
			int sizeof_header, CvArr* header,
			int new_cn, int new_dims, int* new_sizes );

 #define cvReshapeND( arr, header, new_cn, new_dims, new_sizes )   ¥
       cvReshapeMatND( (arr), sizeof(*(header)), (header),         ¥
		       (new_cn), (new_dims), (new_sizes))

 

データのコピーなしに多次元配列の形状を変える

arr
入力配列。
sizeof_header
IplImageとCvMat、CvMatNDそれぞれの出力ヘッダを区別するための出力ヘッダのサイズ。
header
書き込まれる出力ヘッダ。
new_cn
新しいチャンネル数。 new_cn = 0は、チャンネル数が変更されていないことを意味する。
new_dims
新しい次元数。 new_dims = 0は、次元数が同じままであることを意味する。
new_sizes
新しい次元サイズの配列。要素の総数は変化してはいけないので、new_dims-1の値のみ使用される。従って、new_dims = 1であればnew_sizesは使用されない。


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

出力配列を入力配列でタイル状に埋める

src
入力配列、 画像または行列。
dst
出力配列、 画像または行列。


★★
 void cvFlip( const CvArr* src, CvArr* dst=NULL, int flip_mode=0);
 #define cvMirror cvFlip
 

2次元配列を垂直、水平、または両軸で反転する

src
入力配列。
dst
出力配列。もしdst = NULLであれば、反転はインプレースモードで行われる。
flip_mode
配列の反転方法の指定。
flip_mode = 0 は、x軸周りでの反転、 flip_mode > 0(例えば、1)は、y軸周りでの反転、 flip_mode < 0(例えば、-1)は、両軸周りでの反転。 以下の式も参照。


★★★
 void cvSplit( const CvArr* src, CvArr* dst0, CvArr* dst1,
	       CvArr* dst2, CvArr* dst3 );
 #define cvCvtPixToPlane cvSplit
 

マルチチャンネルの配列を、複数のシングルチャンネルの配列に分割する。または、配列から一つのチャンネルを取り出す。

src
入力配列。
dst0...dst3
出力チャンネル。

cvSplit関数は、マルチチャンネルの配列をシングルチャンネルの配列に分割する。この操作には二つのモードがある。 入力配列がNチャンネルの場合、先頭からN番目までの出力チャンネルが NULL でなければ、それらはすべて入力配列から取り出される。 そうでなく、N個の出力チャネルのうち一つだけが NULL でない場合は、この特定のチャンネルのみを抽出する。このいずれでもない場合はエラーとなる。 N番目以降の出力チャンネルは常に NULL でなくてはならない。 IplImageでは、画像から一つのシングルチャンネルを抽出するために、COIを伴うcvCopyも利用される。

使用例は、3.1 セピア変換を参照。


★★★
 void cvMerge( const CvArr* src0, const CvArr* src1,
	       const CvArr* src2, const CvArr* src3, CvArr* dst );
 #define cvCvtPlaneToPix cvMerge
 

複数のシングルチャネルの配列からマルチチャンネル配列を構成する。または、配列に一つのシングルチャンネルを挿入する

src0... src3
入力配列。
dst
出力配列。

cvMerge関数は、前述の関数と反対の操作である。もし出力配列がNチャンネルで、N個の入力チャンネルが NULL でないとき、これらのすべては出力配列にコピーされる。そうでなく、一つの入力配列のみが NULL でなければ、この特定のチャンネルが出力配列にコピーされ、このいずれもでない場合はエラーとなる。N番目以降の入力チャンネルは常に NULL でなくてはならない。 IplImageでは、画像に一つのシングルチャンネルを挿入するために、COIを伴うcvCopyも利用される。

使用例は、3.1 セピア変換を参照。


★★
 void cvMixChannels( const CvArr** src, int src_count,
		     CvArr** dst, int dst_count,
		     const int* from_to, int pair_count );
 

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

src
入力配列の配列。
src_count
入力配列の数。
dst
出力配列の配列。
dst_count
出力配列の数。
from_to
コピーされる平面(チャンネル)のインデックスのペア配列。 from_to[k*2]は入力平面の0を基準としたインデックスで、from_to[k*2+1]は出力平面のインデックス。ここで、入力及び出力配列すべてについて、各平面への連続的な番号付けが行われる。from_to[k*2]が負のとき、対応する出力平面は0で埋められる。
pair_count
from_toのペア数、またはコピーされた平面の数。



 void cvRandShuffle( CvArr* mat, CvRNG* rng, double iter_factor=1. );
 

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


四則演算,論理演算,比較演算(Arithmetic, Logic and Comparison)


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

配列のルックアップテーブルによる変換

src
入力配列(各要素は8ビットデータ)。
dst
出力配列(任意のデプス、入力配列と同じチャンネル数)。
lut
要素数が256であるルックアップテーブル(出力配列と同じデプスでなければならない)。 マルチチャンネルの入力/出力配列の場合、テーブルはシングルチャンネル(この場合すべてのチャンネル対して、同じテーブルを使う)か、入力/出力配列と同じチャンネル数でなければならない。

使用例は、4.2 ヒストグラムを参照。


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

任意の線形変換によって配列の値を変換する

src
入力配列。
dst
出力配列。
scale
スケーリング係数。
shift
スケーリングした入力配列の要素に加える値。

cvConvertScale関数 は、様々な目的を持つため、違う名前での関数(マクロ)としても定義されている。 この関数は、入力配列をスケーリングしてコピーし、さらに以下のような変換を行う(あるいは変換のみを行う)。

dst(I)=src(I)*scale + (shift,shift,...)

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

異なる型への変換では、丸めや飽和を伴う。すなわち、スケーリング+変換の結果が出力先のデータタイプで表現できない値になる場合には、表現できる最も近い実軸上の値で表現する。

scale=1, shift=0 の場合は、何も行わない。これは特別なケースであり、cvConvert と同じ意味である。 入力配列と出力配列が同じタイプの場合、行列や画像のスケーリングと移動を行うことができ、cvScale に相当する。

使用例は、4.2 ヒストグラムを参照。


★★★
 void cvConvertScaleAbs( const CvArr* src, CvArr* dst, double scale=1, double shift=0 );
 #define cvCvtScaleAbs cvConvertScaleAbs
 

任意の線形変換によって、入力配列の要素を8ビット符号無し整数型の配列に変換する。

src
入力配列。
dst
出力配列(デプスは 8u)。
scale
ScaleAbs 係数。
shift
スケーリングした入力配列の要素に加える値。

cvConvertScaleAbs 関数は前述の関数と類似しているが、以下に示すように、変換結果の絶対値を出力する。

dst(I)=abs(src(I)*scale + (shift,shift,...))

この関数は、出力配列のタイプとして 8u(8ビット符号無し整数)のみをサポートしている。その他の型の場合は、cvConvertScalecvAbs を組み合わせることで同様の効果が得られる。


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

二つの配列を要素ごとに加算する

src1
1番目の入力配列。
src2
2番目の入力配列。
dst
出力配列。
mask
処理マスク。8ビットシングルチャンネル配列(出力配列のどの要素が変更されるかを指定する)。

cvAdd関数 は、以下のようにsrc1の各要素にsrc2の各要素を加える。

dst(I)=src1(I)+src2(I) (mask(I)!=0の場合)

すべての配列(マスクを除く)は同じタイプで<、配列のサイズ(またはROIのサイズ)も同じでなければならない。

使用例は、3.2 クロマキーを参照。


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

スカラーと配列を加算する

src
入力配列。
value
加算するスカラー。
dst
出力配列。
mask
処理マスク。8ビットシングルチャンネル配列(出力配列のどの要素が変更されるかを指定する)。


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

二つの配列の重み付き和を計算する

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


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

二つの配列の要素ごとの減算を行う

src1
1番目の入力配列。
src2
2番目の入力配列。
dst
出力配列。
mask
処理マスク。8ビットシングルチャンネル配列(出力配列のどの要素が変更されるかを指定する)。

cvSub 関数は、以下のようにsrc1の各要素からsrc2の各要素を引く。

dst(I)=src1(I)-src2(I) (mask(I)!=0 の場合 )

すべての配列(マスクを除く)は同じタイプで、配列のサイズ(またはROIのサイズ)も同じでなければならない。


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

配列要素からスカラーを減算する

src
入力配列。
value
減算するスカラー
dst
出力配列。
mask
処理マスク。8ビットシングルチャンネル配列(出力配列のどの要素が変更されるかを指定する)。


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

スカラーから配列要素を減算する

src
入力配列。
value
減算されるスカラー。
dst
出力配列。
mask
処理マスク。8ビットシングルチャンネル配列(出力配列のどの要素が変更されるかを指定する)。


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

二つの配列の要素同士を乗算する

src1
1番目の入力配列。
src2
2番目の入力配列。
dst
出力配列。
scale
任意のスケーリング係数。

cvMul 関数は、以下のように二つの配列の要素同士の乗算を行う。

dst(I)=scale•src1(I)•src2(I)

すべての配列(マスクを除く)は同じタイプで、配列のサイズ(またはROIのサイズ)も同じでなければならない。

使用例については、3.4 行列演算を参照。


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

二つの配列の要素同士を除算する

src1
1番目の入力配列。ポインタが NULL の場合は、すべての要素が 1であると仮定する。
src2
2番目の入力配列。
dst
出力配列。
scale
オプションのスケーリング係数。

cvDiv 関数は、以下のように1番目の入力配列の各要素を2番目の入力配列の各要素で割る。

 dst(I)=scale•src1(I)/src2(I), (src1!=NULLの場合)
 dst(I)=scale/src2(I),      (src1=NULLの場合)
 

すべての配列(マスクを除く)は同じタイプで、配列のサイズ(またはROIのサイズ)も同じでなければならない。


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

ビット単位の論理積を計算する

src1
1番目の入力配列。
src2
2番目の入力配列。
dst
出力配列。
mask
処理マスク。8ビットシングルチャンネル配列(出力配列のどの要素が変更されるかを指定する)。

cvAnd 関数は、以下のように二つの配列の要素ごとの論理積(AND)を計算する。

dst(I)=src1(I)&src2(I) (mask(I)!=0 の場合)

浮動小数点型配列の場合、それらのビット表現が処理に使われる。すべての配列(マスクを除く)は同じタイプで、配列のサイズ(またはROIのサイズ)も同じでなければならない。


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

配列の各要素とスカラーとのビット単位の論理積を計算する

src
入力配列。
value
処理に用いるスカラー。
dst
出力配列。
mask
処理マスク。8ビットシングルチャンネル配列(出力配列のどの要素が変更されるかを指定する)。


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

二つの配列要素のビット単位の論理和を計算する

src1
1番目の入力配列。
src2
2番目の入力配列。
dst
出力配列。
mask
処理マスク。8ビットシングルチャンネル配列(出力配列のどの要素が変更されるかを指定する)。

cvOr 関数は、以下のように二つの配列の要素ごとの論理和(OR)を計算する。

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

浮動小数点型配列の場合、それらのビット表現が処理に使われる。すべての配列(マスクを除く)は同じタイプで、配列のサイズ(またはROIのサイズ)も同じでなければならない。


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

配列の各要素とスカラーとのビット単位の論理和を計算する

src1
入力配列。
value
処理に用いるスカラー。
dst
出力配列。
mask
処理マスク。8ビットシングルチャンネル配列(出力配列のどの要素が変更されるかを指定する)。


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

二つの配列要素のビット単位の排他的論理和を計算する

src1
1番目の入力配列。
src2
2番目の入力配列。
dst
出力配列。
mask
処理マスク。8ビットシングルチャンネル配列(出力配列のどの要素が変更されるかを指定する)。

cvXor 関数は、以下のように二つの配列の要素ごとの排他的論理和(XOR)を計算する。

dst(I)=src1(I)^src2(I) (mask(I)!=0の場合)

浮動小数点型配列の場合、それらのビット表現が処理に使われる。すべての配列(マスクを除く)は同じタイプで、配列のサイズ(またはROIのサイズ)も同じでなければならない。


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

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

src
入力配列。
value
処理に用いるスカラー。
dst
出力配列。
mask
処理マスク。8ビットシングルチャンネル配列(出力配列のどの要素が変更されるかを指定する)。


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

各配列要素のビット単位の反転を行う

src1
入力配列。
dst
出力配列。

使用例は、3.2 クロマキーを参照。


★★★
 void cvCmp( const CvArr* src1, const CvArr* src2, CvArr* dst, int cmp_op );
 

二つの配列の各要素ごとの比較を行う

src1
1番目の入力配列。
src2
2番目の入力配列。どちらの入力配列もシングルチャンネルでなければならない。
dst
出力配列(タイプは 8u か 8s でないといけない)。
cmp_op
比較方法を示すフラグ。
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) は等しくない

cvCmp 関数は、以下のように二つの配列の対応する要素を比較し、出力配列の値にセットする。

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

ここで op は '=', '>', '>=', '<', '<=' or '!=' のいずれか。

比較結果が真(TRUE)であれば dst(I) には 0xff(要素すべてのビットが 1 )をセットし、それ以外の場合(FALSE)であれば 0 をセットする。すべての配列(出力配列を除く)は同じタイプで、配列のサイズ(またはROIのサイズ)も同じでなければならない。


★★
 void cvCmpS( const CvArr* src, double value, CvArr* dst, int cmp_op );
 

配列要素とスカラーを比較する

src
入力配列(シングルチャンネル)。
value
それぞれの配列要素と比較されるスカラー。
dst
出力配列(タイプは8u または8s)。
cmp_op
比較方法を示すフラグ。
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 は等しくない


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

配列の要素値が他の二つの配列要素で表される範囲内に位置するかをチェックする

src
入力配列。
lower
下限値(その値を含む)を表す配列。
upper
上限値(その値は含まない)を表す配列。
dst
出力配列(タイプは8u または 8s)。

cvInRange関数 は以下のように、入力配列のすべての要素について範囲チェックを行う。

dst(I)=lower(I)0 <= src(I)0 < upper(I)0

(シングルチャンネル配列の場合)、

dst(I)=lower(I)0 <= src(I)0 < upper(I)0 &&
       lower(I)1 <= src(I)1 < upper(I)1

(2チャンネルなどの場合)。

src(I) が範囲内であれば dst(I) には 0xff(要素すべてのビットが '1')をセットし、それ以外の場合は 0 をセットする。すべての配列(出力配列を除く)は同じタイプで、配列のサイズ(またはROIのサイズ)も同じでなければならない。

使用例は、3.2 クロマキーを参照。


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

配列の要素値が二つのスカラーの間に位置するかをチェックする

src
入力配列。
lower
下限値(その値を含む)。
upper
上限値(その値は含まない)。
dst
出力配列(タイプは8u または 8s)。


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

二つの配列の各要素についての最大値を求める

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

cvMax 関数は、以下のように二つの配列の要素ごとの最大値を計算する。

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

すべての配列はシングルチャンネルで、タイプ、配列のサイズ(またはROIのサイズ)は同じでなければならない。


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

配列の各要素とスカラーについての最大値を求める

src
入力配列。
value
スカラー。
dst
出力配列。


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

二つの配列の各要素についての最小値を求める

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

cvMin 関数は、以下のように二つの配列の要素ごとの最小値を計算する。

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

すべての配列はシングルチャンネルで、タイプ、配列のサイズ(またはROIのサイズ)は同じでなければならない。


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

配列の各要素とスカラーについての最小値を求める

src
入力配列。
value
スカラー。
dst
出力配列。


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

二つの配列の要素ごとの差の絶対値を計算する

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

cvAbsDiff関数 は以下のように、src1 の各要素と src2 の差の絶対値を計算する。

dst(I)c = abs(src1(I)c - src2(I)c).

すべての配列は同じタイプ、同じサイズ(または同じROIサイズ)でなければならない。

使用例は、2.2 チュートリアルを参照。


★★
 void cvAbsDiffS( const CvArr* src, CvArr* dst, CvScalar value );
 #define cvAbs(src, dst) cvAbsDiffS(src, dst, cvScalarAll(0))
 

配列の要素と定数との差の絶対値を計算する

src
入力配列。
dst
出力配列。
value
スカラー。


統計(Statistics)


★★
 int cvCountNonZero( const CvArr* arr );
 

配列要素において 0 ではない要素をカウントする

arr
配列(シングルチャンネルまたはCOIがセットされたマルチチャンネルの画像)。


★★
 CvScalar cvSum( const CvArr* arr );
 

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

arr
配列。


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

配列要素の平均値を計算する

arr
配列。
mask
オプションの処理マスク。

cvAvg 関数は、配列要素の平均値 M を各チャンネルで独立に計算する。

 N = sumI mask(I)!=0

 Mc = 1/N • sumI,mask(I)!=0 arr(I)c
 

配列のタイプが IplImage で COI がセットされている場合、指定されたチャンネルのみを処理し、平均値を1番目のスカラー値(M0)として保存する。


★★
 void cvAvgSdv( const CvArr* arr, CvScalar* mean, CvScalar* std_dev, const CvArr* mask=NULL );
 

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

arr
配列。
mean
計算結果の平均値へのポインタ。必要でない場合は NULL。
std_dev
計算結果の標準偏差へのポインタ。
mask
オプションの処理マスク。


★★★
 void cvMinMaxLoc( const CvArr* arr, double* min_val, double* max_val,
		   CvPoint* min_loc=NULL, CvPoint* max_loc=NULL, const CvArr* mask=NULL );
 

配列あるいは部分配列内の最小値と最大値を求める

arr
入力配列(シングルチャンネルまたはCOIがセットされたマルチチャンネル)。
min_val
戻り値の最小値へのポインタ。
max_val
戻り値の最大値へのポインタ。
min_loc
戻り値の最小値を持つ位置へのポインタ。
max_loc
戻り値の最大値を持つ位置へのポインタ。
mask
部分配列を指定するためのオプションのマスク。

MinMaxLoc関数 は、配列要素の中から最小値・最大値とその位置を求める。 各極値は配列全体または選択されたROI(IplImageの場合)をスキャンして求める。 maskNULL でない場合は、指定された領域のみをスキャンする。 マルチチャンネル配列の場合、入力は COI がセットされた IplImage データタイプでなければならない。 多次元配列の場合は、min_loc->xmax_loc->yには、極値の座標がそのまま入る。

使用例は、4.6 対応領域探索を参照。


★★★
 double cvNorm( const CvArr* arr1, const CvArr* arr2=NULL, int norm_type=CV_L2, const CvArr* mask=NULL );
 

配列の絶対値ノルム(absolute array norm)、絶対値差分ノルム(absolute difference norm)、相対値差分ノルム(relative difference norm)を計算する

arr1
1番目の入力画像。
arr2
2番目の入力画像。NULL の場合、arr1の絶対値ノルムが計算され、そうでない場合は、arr1-arr2 の絶対値あるいは相対値ノルムが計算される。
normType
ノルムのタイプ(以下の説明を参照)。
mask
オプションの処理マスク。

cvNorm 関数は arr2 が NULL の場合、以下のように arr1 の絶対値ノルムを計算する。

 norm = ||arr1||C = maxI abs(arr1(I)),  (normType = CV_Cの場合)

 norm = ||arr1||L1 = sumI abs(arr1(I)),  (normType = CV_L1の場合)

 norm = ||arr1||L2 = sqrt( sumI arr1(I)2),  (normType = CV_L2の場合)

 

この関数は、arr2 が NULL でない場合、以下のように絶対値あるいは相対値ノルムを計算する。

 norm = ||arr1-arr2||C = maxI abs(arr1(I)-arr2(I)),  (normType = CV_Cの場合)

 norm = ||arr1-arr2||L1 = sumI abs(arr1(I)-arr2(I)),  (normType = CV_L1の場合)

 norm = ||arr1-arr2||L2 = sqrt( sumI (arr1(I)-arr2(I))2 ),  (normType = CV_L2の場合)

 もしくは

 norm = ||arr1-arr2||C/||arr2||C, (normType = CV_RELATIVE_Cの場合)

 norm = ||arr1-arr2||L1/||arr2||L1, (normType = CV_RELATIVE_L1の場合)

 norm = ||arr1-arr2||L2/||arr2||L2, (normType = CV_RELATIVE_L2の場合)

 

Norm 関数は計算したノルムを返す。マルチチャンネル配列はシングルチャンネルとして取り扱う。すなわち、すべてのチャンネルの結果が統合される。


★★
 void cvReduce( const CvArr* src, CvArr* dst, 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 - 出力は各行(または各列)における最小値


線形代数(Linear Algebra)


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

ユークリッド距離に基づく2つの配列の内積を計算する

src1
1番目の入力配列。
src2
2番目の入力配列。

cvDotProduct 関数はユークリッド幾何学における内積を計算し、その結果を返す。

src1•src2 = sumI(src1(I)*src2(I))
 

マルチチャンネル配列の場合、全てのチャンネルの結果が累算される。特にaを複素ベクトルとすると, cvDotProduct(a,a)||a||2を返す。この関数は、多次元配列を1行、1レイヤーずつ処理することもできる。

使用例については、3.4 行列演算を参照。


★★★
 void cvNormalize( const CvArr* src, CvArr* dst,
		   double a=1, double b=0, int norm_type=CV_L2,
		   const CvArr* mask=NULL );
 

指定のノルムになるように、あるいは値が指定の範囲になるように、配列を正規化する

src
入力配列。
dst
出力配列。インプレース処理が可能。
a
出力配列の最小値または最大値、あるいは出力配列のノルム。
b
出力配列の最大値または最小値。
norm_type
正規化のタイプ。以下のうち一つを用いることができる。
CV_C - 配列のC-norm(絶対値の最大値)を正規化
CV_L1 - 配列のL1-norm(絶対値の合計)を正規化
CV_L2 - 配列のL2-norm(ユークリッド距離)を正規化
CV_MINMAX - 配列の値が指定の範囲に収まるようにスケーリングとシフトを行う。
mask
操作マスク。特定の配列要素のみを正規化するためのマスク。

cvNormalize 関数は、入力配列をそのノルム、または値が特定の値や範囲になるように正規化する。

norm_type==CV_MINMAXのとき、

     dst(i,j)=(src(i,j)-min(src))*(b'-a')/(max(src)-min(src)) + a',  (mask(i,j)!=0 の場合)
     dst(i,j)=src(i,j)  (それ以外の場合)
 
ここで b'=MAX(a,b)a'=MIN(a,b)min(src)max(src) はそれぞれ入力配列の全体、または指定された部分集合について計算した全体の最小値と最大値である。

norm_type!=CV_MINMAXのとき、

     dst(i,j)=src(i,j)*a/cvNorm(src,0,norm_type,mask), (mask(i,j)!=0 の場合)
     dst(i,j)=src(i,j)  (それ以外の場合)
 


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

二つの3次元ベクトルの外積を計算する

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

使用例については、3.4 行列演算を参照。


★★
 void cvScaleAdd( const CvArr* src1, CvScalar scale, const CvArr* src2, CvArr* dst );
 #define cvMulAddS cvScaleAdd
 

スケーリングされた配列ともう一つの配列の和を計算する

src1
1番目の入力配列
scale
1番目の配列のためのスケールファクタ。
src2
2番目の入力配列。
dst
出力配列。


★★
 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番目の入力配列。
alpha
乗算結果に対するスケーリング係数。以下の説明を参照。
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は、 alpha*src1T*src2 + beta*src3Tに対応する。


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

すべての配列要素を行列により変換する

src
1番目の入力配列。
dst
出力配列。
transmat
変換行列。
shiftvec
オプションのシフトベクトル。


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

ベクトルの透視投影変換を行う

src
3チャンネルの浮動小数点型入力配列。
dst
3チャンネルの浮動小数点型出力配列。
mat
3×3 または 4×4 の変換行列。


★★
 void cvMulTransposed( const CvArr* src, CvArr* dst, int order, const CvArr* delta=NULL );
 

行列と転置行列の乗算を行う

src
入力行列。
dst
出力行列。
order
転置した行列をかける順番。
delta
オプション配列、乗算する前にsrcから引かれる。


★★
 CvScalar cvTrace( const CvArr* mat );
 

行列のトレースを返す

mat
入力行列。


★★
 void cvTranspose( const CvArr* src, CvArr* dst );
 #define cvT cvTranspose
 

行列の転置を行う

src
入力行列。
dst
出力行列。

使用例については、3.4 行列演算を参照。


★★
 double cvDet( const CvArr* mat );
 

行列式を返す

mat
入力行列。

使用例については、3.4 行列演算を参照。


★★
 double cvInvert( const CvArr* src, CvArr* dst, int method=CV_LU );
 #define cvInv cvInvert
 

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

src
入力行列。
dst
出力行列。
method
逆行列を求める手法。
CV_LU - 最適なピボット選択によるガウスの消去法
CV_SVD - 特異値分解(SVD)
CV_SVD_SYM - 対称正定値行列のための特異値分解

使用例については、3.4 行列演算を参照。


★★
 int cvSolve( const CvArr* A, const CvArr* B, CvArr* X, int method=CV_LU );
 

線形問題または最小二乗法問題を解く

A
入力行列。
B
線形システムの右辺。
X
出力解。
method
逆行列の解法。
CV_LU - 最適なピボット選択によるガウスの消去法
CV_SVD - 特異値分解
CV_SVD_SYM - 対称正定値行列のための特異値分解。


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

浮動小数点型の実数行列の特異値分解を行う

A
入力M×N行列。
W
特異値行列の結果 (M×N または N×N)または ベクトル(N×1)。
U
任意の左直交行列 (M×M または M×N)。 もしCV_SVD_U_Tが指定された場合、上で述べた、行と列の数は入れ替わる。
V
任意の右直交行列(N×N)。
flags
操作フラグ。0または以下の値の組み合わせ。
  • CV_SVD_MODIFY_A を指定すると、計算中に行列Aの変更を行うことができる。 このフラグの指定は処理速度を向上させる。
  • CV_SVD_U_T means that the tranposed matrix U is returned. Specifying the flag はUの転置行列を返すことを意味する。このフラグの指定は処理速度を向上させる。
  • CV_SVD_V_TVの転置行列を返すことを意味する。このフラグの指定は処理速度を向上させる。


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

特異値の後退代入を行う

W
特異値の行列またはベクトル。
U
左直交行列(転置されているかもしれない)
V
右直交行列(転置されているかもしれない)
B
行列Aの擬似逆行列に乗ずるための行列。オプションのパラメータ。 省略されている場合、それは適切なサイズの単位行列であると仮定される(そのためXAの再構成された擬似逆行列となる)。
X
出力行列。後退代入の結果。
flags
操作フラグ。cvSVDでのflagsと一致していなければならない。


★★
 void cvEigenVV( CvArr* mat, CvArr* evects, CvArr* evals, double eps=0 );
 

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

mat
入力対称正方行列。処理中に変更される。
evects
固有ベクトルの出力行列。連続した行として保存される。
evals
固有値ベクトルの出力ベクトル。降順に保存される(もちろん固有値と固有ベクトルの順番は一致する)。
eps
対角化の精度(一般的に、DBL_EPSILON=≈10-15 で十分である)。


★★
 void cvCalcCovarMatrix( const CvArr** vects, int count, CvArr* cov_mat, CvArr* avg, int flags );
 

ベクトル集合の共変動行列を計算する

vects
入力ベクトル。これらはすべて同じタイプで同じサイズでなくてはならない。 ベクトルは1次元である必要はなく、2次元(例えば、画像)などでも構わない。
count
入力ベクトルの数。
cov_mat
浮動小数点型の正方な出力共変動行列。
avg
入力または出力配列(フラグに依存する) - 入力ベクトルの平均ベクトル。
flags
操作フラグ。以下の値の組み合わせ。
CV_COVAR_SCRAMBLED - 出力共変動行列は次のように計算される。
scale*[vects[0]-avg,vects[1]-avg,...]T*[vects[0]-avg,vects[1]-avg,...]
すなわち、共変動行列はcount×countである。 そのような一般的でない共変動行列は、非常に大きなベクトル集合に対する高速な主成分分析のために使用される(例えば、顔認識のための固有顔)。 この「スクランブルされた」行列の固有値は、真共変動行列の固有値と一致し、 そして「真の」固有ベクトルは「スクランブルされた」共変動行列の固有ベクトルから容易に計算できる。
CV_COVAR_NORMAL - 出力共変動行列は次のように計算される。
scale*[vects[0]-avg,vects[1]-avg,...]*[vects[0]-avg,vects[1]-avg,...]T
つまり、cov_matはすべての入力ベクトルの要素の合計と同じサイズの一般的な共変動行列となる。 CV_COVAR_SCRAMBLEDCV_COVAR_NORMALのどちらか一つは必ず指定されなくてはならない。
CV_COVAR_USE_AVG - このフラグが指定された場合、関数は入力ベクトルから平均を計算せず、引数で指定された平均ベクトルを使用する。 平均が何らかの方法で既に計算されている場合、または共変動行列が部分的に計算されている場合 (この場合、avgは入力ベクトルの一部の平均ではなく、全ての平均ベクトルである)に有用である。
CV_COVAR_SCALE - このフラグが指定された場合、 共変動行列は入力ベクトルの数によってスケーリングされる。
CV_COVAR_ROWS - 全ての入力ベクトルは単一の行列(vects[0])の行として保存されることを意味する。 この場合、countは無視される。そしてavgは適切な大きさの1行のベクトルでなければならない。
CV_COVAR_COLS - 全ての入力ベクトルは単一の行列(vects[0])の列として保存されることを意味する。 この場合、countは無視される。そしてavgは適切な大きさの1列のベクトルでなければならない。


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

2つのベクトルのマハラノビス距離を計算する

vec1
1番目の1次元入力ベクトル。
vec2
2番目の1次元入力ベクトル。
mat
逆共変動行列。


★★
 void cvCalcPCA( const CvArr* data, CvArr* avg,
		 CvArr* eigenvalues, CvArr* eigenvectors, int flags );
 

ベクトル集合の主成分分析を行う

data
入力データ。それぞれのベクトルは単一行(CV_PCA_DATA_AS_ROW)か、単一列(CV_PCA_DATA_AS_COL)である。
avg
平均ベクトル。関数内で計算されるか、ユーザによって与えられる。
eigenvalues
出力である共変動行列の固有値。
eigenvectors
出力である共変動行列の固有ベクトル(つまり、主成分)。一つの行が一つのベクトルを意味する。
flags
操作フラグ。以下の値の組み合わせ。
CV_PCA_DATA_AS_ROW - 行としてベクトルが保存される(つまり、あるベクトルすべての要素は連続的に保存される)
CV_PCA_DATA_AS_COL - 列としてベクトルが保存される(つまり、あるベクトル成分に属する値は連続的に保存される)
(上の2つのフラグは互いに排他的である)
CV_PCA_USE_AVG - 事前に計算された平均ベクトルを用いる


★★
 void cvProjectPCA( const CvArr* data, const CvArr* avg,
 const CvArr* eigenvectors, CvArr* result );

指定された部分空間にベクトルを投影する

data
入力データ。それぞれのベクトルは単一行か、単一列である。
avg
平均ベクトル。単一行ベクトルの場合、それはdataの行として入力ベクトルが保存されていることを意味する。 そうでない場合は、単一列ベクトルであり、そのときのベクトルはdataの列として保存されている。
eigenvectors
固有ベクトル(主成分)。一つの行が一つのベクトルを意味する。
result
出力である分解係数の行列。行の数はベクトルの数と同じでなくてはならない。 列の数はeigenvectorsの列の数より小さいか同じでなくてはならない。 列の数が少ない場合、入力ベクトルは、第cols(result)主成分までを基底とする部分空間に投影される。


★★
void cvBackProjectPCA( const CvArr* proj, const CvArr* avg,
                       const CvArr* eigenvects, CvArr* result );

投影係数から元のベクトルを再構築する

proj
入力データ。cvProjectPCAresultと同様のフォーマット。
avg
平均ベクトル。もし単一行ベクトルの場合、出力ベクトルがresultの行として保存されていることを意味する。 そうでない場合は、単一列ベクトルであり、そのときはresultの列として保存される。
eigenvectors
固有ベクトル(主成分)。一つの行が一つのベクトルを意味する。
result
出力である再構築されたベクトルの行列。


数学関数(Math Functions)



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

浮動小数点型の変数を整数型に変換する



float cvSqrt( float value );

平方根を計算する



float cvInvSqrt( float value );

平方根の逆数を計算する



float cvCbrt( float value );

立方根を計算する



float cvFastArctan( float y, float x );

2次元のベクトルの角度を計算する



int cvIsNaN( double value );

引数が数値でないかどうかを確認する



int cvIsInf( double value );

引数が無限大であるかどうかを確認する



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

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



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

極座標形式で表現された2次元ベクトルのデカルト座標を計算する



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

すべての配列要素を累乗する



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

すべての配列要素について自然対数の底(ネイピア数)eのべき乗を求める



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

すべての配列要素の絶対値の自然対数を計算する



int cvSolveCubic( const CvMat* coeffs, CvMat* roots );

3次方程式の実根を求める


乱数生成(Random Number Generation)



CvRNG cvRNG( int64 seed=-1 );

乱数生成器の状態を初期化する



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

配列を乱数で埋め、RNGの状態を更新する



unsigned cvRandInt( CvRNG* rng );

32ビット符号なし整数を返し、RNGを更新する



double cvRandReal( CvRNG* rng );

浮動小数点型の乱数を返し、RNGを更新する


離散変換(Discrete Transforms)


★★
void cvDFT( const CvArr* src, CvArr* dst, int flags, int nonzero_rows=0 );

#define CV_DXT_FORWARD  0
#define CV_DXT_INVERSE  1
#define CV_DXT_SCALE    2
#define CV_DXT_ROWS     4
#define CV_DXT_INV_SCALE (CV_DXT_SCALE|CV_DXT_INVERSE)
#define CV_DXT_INVERSE_SCALE CV_DXT_INV_SCALE

1次元あるいは2次元浮動小数点型配列に対して離散フーリエ変換(DFT)、逆離散フーリエ変換(IDFT)を行う

src
入力配列(実数または複素数)。
dst
入力配列と同じサイズ・タイプの出力配列。
flags
変換フラグ。以下の値の組み合わせ。
CV_DXT_FORWARD - 1次元または2次元の順変換を行う。結果のスケーリングは行わない。
CV_DXT_INVERSE - 1次元または2次元の逆変換を行う。結果のスケーリングは行わない。 CV_DXT_FORWARDCV_DXT_INVERSE は、もちろん同時には指定できない。
CV_DXT_SCALE - 結果を配列要素数で割り、スケーリングする。通常は CV_DXT_INVERSE と同時に用いる。ショートカットとして CV_DXT_INV_SCALE を用いても良い。
CV_DXT_ROWS - 入力配列のそれぞれの行に対して独立に、順変換あるいは逆変換を行う。 このフラグは複数のベクトルの同時変換を許可し、オーバーヘッド(一つの計算の何倍も大きくなることもある)を減らすためや、3次元以上の高次元に対して変換を行うために使用される。
nonzero_rows
入力配列の非0である行の数(2次元順変換の場合)、あるいは出力配列で注目する行の数(2次元逆変換の場合)。 この値が負、0、あるいは行の数より大きい場合は無視される。 このパラメータにより、DFTを用いて2次元の畳み込みや相関演算を行う際の計算速度が向上する。


★★
int cvGetOptimalDFTSize( int size0 );

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

size0
ベクトルのサイズ。


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

二つのフーリエスペクトラムの要素ごとの乗算を行う

src1
1番目の入力配列。
src2
2番目の入力配列。
dst
入力配列と同じタイプ・サイズの出力配列。
flags
以下の値の組み合わせ。
CV_DXT_ROWS - 配列の各行を個別のスペクトラムとして扱う (cvDFT のパラメータを参照)。
CV_DXT_MUL_CONJ - 乗算の前に2番目の入力配列の共役を計算する


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

#define CV_DXT_FORWARD  0
#define CV_DXT_INVERSE  1
#define CV_DXT_ROWS     4

1次元あるいは2次元浮動小数点型配列の順方向・逆方向離散コサイン変換を行う

src
入力配列(実数の1次元あるいは2次元配列)。
dst
入力と同じサイズ・タイプの出力配列。
flags
変換フラグ。以下の値の組み合わせ。
CV_DXT_FORWARD - 1次元あるいは2次元の順変換。
CV_DXT_INVERSE - 1次元あるいは2次元の逆変換。
CV_DXT_ROWS - 入力配列のそれぞれの行に対して、独立に順変換あるいは逆変換を行う。 このフラグは複数ベクトルの同時変換を許可し、 オーバーヘッド(一つの計算の何倍も大きくなることもある)を減らすためや、3次元以上の高次元に対して変換を行うために使用される。


動的構造体(Dynamic Structures)


メモリストレージ(Memory Storages)


★★★
CvMemStorage

動的に拡張可能なメモリストレージ

typedef struct CvMemStorage
{
    struct CvMemBlock* bottom;/* 最初に確保されたブロック */
    struct CvMemBlock* top; /* 新たなブロックを確保する場所 */
    struct CvMemStorage* parent; /* 現在のメモリブロック − スタックの先頭 */
    int block_size; /* ブロックの大きさ */
    int free_space; /* topブロック内の自由領域(バイト単位) */
} CvMemStorage;

メモリストレージは低レベルの構造体で、動的に拡張可能なデータ構造を持ち、シーケンスや輪郭、グラフ、細分化などに使われる。 これは同じサイズのメモリブロックのリストとして編成されている。 bottomフィールドはブロックのリストの先頭、topは現在使われているブロックを意味するが、 リストの最後のブロックは必ずしも必要ではない。後者(ここではtop)以外のbottomからtopまでのブロックは全て占有されている。 topを除くtopから最後までのすべてのブロックは空き領域で、topブロック自体は部分的に占有されている。 free_spaceは、topの後ろに残されているバイト単位で示された自由領域を意味する。

cvMemStorageAlloc 関数で明示的に、 もしくはcvSeqPushcvGraphAddEdge などの高レベル関数によって間接的に確保された新たなメモリ領域は、そこに納まる場合には常に現在のブロックの最後に確保される。 確保後free_spaceは、適切なアライメントを保持するために、確保したバッファサイズにパディングを加えた分ずつ減らされる。 確保されたバッファがtopの利用可能な領域に納まらない場合、 リストの次のストレージブロックがtopとして用いられ、 free_spaceは確保前の全ブロックサイズにリセットされる。

もし空きブロックがない場合、新しいブロックが確保され (または親から借りて、cvCreateChildMemStorageを参照)、 リストの最後に追加される。このようにこのストレージはスタックとして振る舞い、 bottomがスタックの底、 topfree_spaceのペアがスタックの先頭を示す。 スタックの先頭はcvSaveMemStoragePosで保存、 cvRestoreMemStoragePosで復元、 cvClearStorageでリセットされる。



CvMemBlock

メモリストレージブロック



CvMemBlockPos

メモリストレージの位置


★★
CvMemStorage* cvCreateMemStorage( int block_size=0 );

メモリストレージを生成する

block_size
ストレージブロックのバイト単位のサイズ。0の場合、デフォルト値(現在は≈64K)が使われる。



CvMemStorage* cvCreateChildMemStorage( CvMemStorage* parent );

子メモリストレージを生成する



void cvReleaseMemStorage( CvMemStorage** storage );

メモリストレージを解放する



void cvClearMemStorage( CvMemStorage* storage );

メモリストレージをクリアする



void* cvMemStorageAlloc( CvMemStorage* storage, size_t size );

ストレージ内にメモリバッファを確保する



CvString cvMemStorageAllocString( CvMemStorage* storage, const char* ptr, int len=-1 );
typedef struct CvString
{
    int len;
    char* ptr;
}
CvString;

ストレージ内にテキスト文字列を確保する



void cvSaveMemStoragePos( const CvMemStorage* storage, CvMemStoragePos* pos );

メモリストレージの位置を保存する



void cvRestoreMemStoragePos( CvMemStorage* storage, CvMemStoragePos* pos );

メモリストレージの位置を復元する


シーケンス(Sequences)


★★★
CvSeq

拡張可能な要素のシーケンス

#define CV_SEQUENCE_FIELDS() ¥
    int flags; /* 様々なフラグ */ ¥
    int header_size; /* シーケンスのヘッダサイズ */ ¥
    struct CvSeq* h_prev; /* 一つ前のシーケンスへのポインタ */ ¥
    struct CvSeq* h_next; /* 一つ後のシーケンスへのポインタ */ ¥
    struct CvSeq* v_prev; /* 一つ前のシーケンス(セカンダリ、構造によって意味が異なる) */ ¥
    struct CvSeq* v_next; /* 一つ後のシーケンス(セカンダリ、構造によって意味が異なる) */ ¥
    int total; /* 要素の総数 */ ¥
    int elem_size;/* シーケンス要素のサイズ(バイト単位) */ ¥
    char* block_max;/* 最新のブロックの最大値 */ ¥
    char* ptr; /* 現在の書き込みポインタ */ ¥
    int delta_elems; /* シーケンスを拡張させる際に、領域確保する要素数(シーケンスの粒度) */ ¥
    CvMemStorage* storage; /* seqが保存される領域 */ ¥
    CvSeqBlock* free_blocks; /* 空きブロックリスト */ ¥
    CvSeqBlock* first; /* 先頭シーケンスブロックへのポインタ */


typedef struct CvSeq
{
    CV_SEQUENCE_FIELDS()
} CvSeq;

CvSeq 構造体は、OpenCVの動的データ構造すべての基本となるものである。

上記の補助マクロを介した特殊な定義により、追加パラメータを伴う CvSeq 構造体の拡張が容易に行える。 CvSeq を拡張するために、新しい構造体を定義し、マクロCV_SEQUENCE_FIELDS()によって列挙される CvSeq のフィールドの後にユーザー定義フィールドをおいてもよい。

シーケンスには、密なシーケンスと疎なシーケンスの2種類が存在する。 密なシーケンスの基本タイプは CvSeq であり、このシーケンスは拡張可能な1次元配列 (ベクトル(vectors)、スタック(stacks)、キュー(queues)、デック(deques))を表現するのに用いられる。 これらのタイプにはデータの中間部分に空白部がない。すなわち、シーケンスの中間部分における要素の削除や追加の際には、最も近い終端の要素からシフトされる。 疎なシーケンスは、CvSetをその基本クラスとして持つ。詳細は後述する。 それらは、ノードフラグによって「データがある」か「空き」かが示されているノードシーケンスである。 このタイプのシーケンスは、要素の集合(sets)、グラフ(graph)、ハッシュテーブル(hash tables)等の順序のないデータ構造に用いられる。

フィールド header_size は、シーケンスヘッダの実サイズが入っており、 そのサイズは、sizeof(CvSeq)より大きいか等しくなけらばならない。

フィールド h_prev, h_next, v_prev, v_next は、別々のシーケンス群から階層構造を生成するために使用できる。 フィールド h_prevh_next は、同一階層での前後のシーケンスを指し、 さらに、フィールド v_prevv_next は縦方向での前後のシーケンス(自分の親と最初の子)を指す。 しかし、これらは単に名前にすぎず、これらのポインタを異なる意味で使用することが可能である。

フィールド first は、ブロックの先頭シーケンスを指す。この構造については以下で述べる。

フィールド total は、密なシーケンスでは実要素数、疎なシーケンスでは領域確保されたノード数を示す。

フィールド flags は、上位16ビットで個々の動的特性 (密なシーケンスではCV_SEQ_MAGIC_VAL 、疎なシーケンスではCV_SET_MAGIC_VAL)と、 シーケンスに関するその他の雑多な情報を持つ。 下位 CV_SEQ_ELTYPE_BITS ビットは、要素タイプのIDを示す。 ほとんどのシーケンス処理関数は要素タイプではなく、elem_sizeに保存された要素サイズを使用する。 シーケンスがCvMatタイプの一つであるような数値データからなる場合、 シーケンスの要素タイプは対応するCvMatの要素タイプと一致する (例えば、2次元の点データのシーケンスではCV_32SC2が、浮動小数点型のシーケンスにはCV_32FC1が用いられるなど)。 マクロ CV_SEQ_ELTYPE(seq_header_ptr) は、シーケンスの要素のタイプを取り出す。 数値シーケンスを扱う関数では elem_size が、その要素タイプから計算されたものと等しいかどうかがチェックされる。 さらに、CvMat に準拠したタイプでは、ヘッダcvtypes.hで定義された以下の追加要素タイプが存在する:

標準的なシーケンス要素の種類

    #define CV_SEQ_ELTYPE_POINT          CV_32SC2  /* (x,y) */
    #define CV_SEQ_ELTYPE_CODE           CV_8UC1   /* フリーマンコード: 0..7 */
    #define CV_SEQ_ELTYPE_GENERIC        0 /* 一般的なシーケンス要素タイプ */
    #define CV_SEQ_ELTYPE_PTR            CV_USRTYPE1 /* =6 */
    #define CV_SEQ_ELTYPE_PPOINT         CV_SEQ_ELTYPE_PTR  /* &elem: 他のシーケンス要素へのポインタ */
    #define CV_SEQ_ELTYPE_INDEX          CV_32SC1  /* #elem: 他のシーケンス要素のインデックス */
    #define CV_SEQ_ELTYPE_GRAPH_EDGE     CV_SEQ_ELTYPE_GENERIC  /* &next_o, &next_d, &vtx_o, &vtx_d */
    #define CV_SEQ_ELTYPE_GRAPH_VERTEX   CV_SEQ_ELTYPE_GENERIC  /* 先頭の辺, &(x,y) */
    #define CV_SEQ_ELTYPE_TRIAN_ATR      CV_SEQ_ELTYPE_GENERIC  /* 二分木の頂点(ノード)   */
    #define CV_SEQ_ELTYPE_CONNECTED_COMP CV_SEQ_ELTYPE_GENERIC  /* 接続されたコンポーネント  */
    #define CV_SEQ_ELTYPE_POINT3D        CV_32FC3  /* (x,y,z)  */

次の、CV_SEQ_KIND_BITS ビットは、シーケンスの種類を指定する。

標準的なシーケンスの種類

    /* 一般的な(特別な指定無しの)シーケンスの種類 */
    #define CV_SEQ_KIND_GENERIC     (0 << CV_SEQ_ELTYPE_BITS)

    /* 密なシーケンスのサブタイプ */
    #define CV_SEQ_KIND_CURVE       (1 << CV_SEQ_ELTYPE_BITS)
    #define CV_SEQ_KIND_BIN_TREE    (2 << CV_SEQ_ELTYPE_BITS)

    /* 疎なシーケンス(または集合)のサブタイプ */
    #define CV_SEQ_KIND_GRAPH       (3 << CV_SEQ_ELTYPE_BITS)
    #define CV_SEQ_KIND_SUBDIV2D    (4 << CV_SEQ_ELTYPE_BITS)

残りのビットは、これ以外のシーケンスの種類や要素タイプを指定するために用いられる。 例えば、点(CV_SEQ_KIND_CURVE|CV_SEQ_ELTYPE_POINT )から構成される曲線では、タイプ CV_SEQ_POLYGON に属するフラグCV_SEQ_FLAG_CLOSED や、他のフラグがそのサブタイプを表現するために用いられる。 多くの輪郭処理関数は、入力シーケンスのタイプをチェックし、そのタイプがサポート外である場合はエラーを発生する。 ファイル cvtypes.h には、サポートされている定義済みシーケンスタイプやその他の属性を取得する補助マクロの全リストが記述されている。 以下はシーケンスを構成するための基本要素の定義である。



CvSeqBlock

連続したシーケンスブロックのための構造体


★★
CvSlice

シーケンススライスのための構造体

typedef struct CvSlice
{
    int start_index;
    int end_index;
} CvSlice;

★★
CvSeq* cvCreateSeq( int seq_flags, int header_size,
                    int elem_size, CvMemStorage* storage );

シーケンスを生成する

seq_flags
生成されたシーケンスのフラグ。生成されたシーケンスが、特定のシーケンスタイプを引数にとるような関数に一切渡されない場合は、この値に0を指定してもかまわない。そうでない場合は、定義済みのシーケンスタイプのリストから適切なタイプが選択されなければならない。
header_size
シーケンスのヘッダサイズ。sizeof(CvSeq)以上でなければならない。 また、特別なタイプかその拡張が指示されている場合、そのタイプは基本タイプのヘッダと合致していなければならない。
elem_size
シーケンスの要素サイズ(バイト単位)。サイズはシーケンスタイプと合致しなければならない。例えば、点群のシーケンスを作成する場合、要素タイプにCV_SEQ_ELTYPE_POINTを指定し、パラメータ elem_sizesizeof(CvPoint) と等しくなければならない。
storage
シーケンスが保存される場所。



void cvSetSeqBlockSize( CvSeq* seq, int delta_elems );

シーケンスのブロックサイズを設定する



char* cvSeqPush( CvSeq* seq, void* element=NULL );

シーケンスの末尾に要素を追加する



void cvSeqPop( CvSeq* seq, void* element=NULL );

シーケンスの末尾から要素を削除する



char* cvSeqPushFront( CvSeq* seq, void* element=NULL );

シーケンスの先頭に要素を追加する。



void cvSeqPopFront( CvSeq* seq, void* element=NULL );

シーケンスの先頭から要素を削除する



void cvSeqPushMulti( CvSeq* seq, void* elements, int count, int in_front=0 );

複数の要素をシーケンスのどちらかの端(先頭か末尾)に追加する



void cvSeqPopMulti( CvSeq* seq, void* elements, int count, int in_front=0 );

複数の要素をシーケンスのどちらかの端(先頭か末尾)から削除する



char* cvSeqInsert( CvSeq* seq, int before_index, void* element=NULL );

シーケンスの中に要素を挿入する



void cvSeqRemove( CvSeq* seq, int index );

シーケンスの中から要素を削除する



void cvClearSeq( CvSeq* seq );

シーケンスをクリアする


★★
char* cvGetSeqElem( const CvSeq* seq, int index );
#define CV_GET_SEQ_ELEM( TYPE, seq, index )  (TYPE*)cvGetSeqElem( (CvSeq*)(seq), (index) )

インデックスで指定されたシーケンス要素のポインタを返す

seq
シーケンス。
index
要素のインデックス。



int cvSeqElemIdx( const CvSeq* seq, const void* element, CvSeqBlock** block=NULL );

ポインタで指定されたシーケンスの要素のインデックスを返す



void* cvCvtSeqToArray( const CvSeq* seq, void* elements, CvSlice slice=CV_WHOLE_SEQ );

シーケンスをメモリ内の連続した一つのブロックにコピーする



CvSeq* cvMakeSeqHeaderForArray( int seq_type, int header_size, int elem_size,
                                void* elements, int total,
                                CvSeq* seq, CvSeqBlock* block );

配列からシーケンスを生成する



CvSeq* cvSeqSlice( const CvSeq* seq, CvSlice slice,
                   CvMemStorage* storage=NULL, int copy_data=0 );

シーケンススライスのための別のヘッダを作成する



CvSeq* cvCloneSeq( const CvSeq* seq, CvMemStorage* storage=NULL );

シーケンスのコピーを作成する



void cvSeqRemoveSlice( CvSeq* seq, CvSlice slice );

シーケンススライスを削除する



void cvSeqInsertSlice( CvSeq* seq, int before_index, const CvArr* from_arr );

シーケンス内に配列を挿入する



void cvSeqInvert( CvSeq* seq );

シーケンス要素の順序を反転させる



void cvSeqSort( CvSeq* seq, CvCmpFunc func, void* userdata=NULL );
/* a < b ? -1 : a > b ? 1 : 0 */
typedef int (CV_CDECL* CvCmpFunc)(const void* a, const void* b, void* userdata);

シーケンスの要素を、指定した比較関数を用いてソートする



char* cvSeqSearch( CvSeq* seq, const void* elem, CvCmpFunc func,
                   int is_sorted, int* elem_idx, void* userdata=NULL );
/* a < b ? -1 : a > b ? 1 : 0 */
typedef int (CV_CDECL* CvCmpFunc)(const void* a, const void* b, void* userdata);

シーケンスから指定要素を検索する



void cvStartAppendToSeq( CvSeq* seq, CvSeqWriter* writer );

シーケンスへのデータ書き込み処理を初期化する



void cvStartWriteSeq( int seq_flags, int header_size, int elem_size,
                      CvMemStorage* storage, CvSeqWriter* writer );

新しいシーケンスを作成し、ライタ(writer)を初期化する



CvSeq* cvEndWriteSeq( CvSeqWriter* writer );

シーケンス書き込み処理を終了する



void cvFlushSeqWriter( CvSeqWriter* writer );

ライタの状態からシーケンスヘッダを更新する



void cvStartReadSeq( const CvSeq* seq, CvSeqReader* reader, int reverse=0 );

シーケンスからの連続読み出し処理を初期化する



int cvGetSeqReaderPos( CvSeqReader* reader );

現在のリーダの位置を返す



void cvSetSeqReaderPos( CvSeqReader* reader, int index, int is_relative=0 );

リーダを指定の位置に移動する


セット(Sets)


★★★
CvSet

ノードの集合

    typedef struct CvSetElem
    {
        int flags; /* 空きノードなら負,他の場合0か正の値 */
        struct CvSetElem* next_free; /* 空きノードの場合,次の空きノードへのポインタ */
    }
    CvSetElem;

    #define CV_SET_FIELDS()    ¥
        CV_SEQUENCE_FIELDS()   /* CvSeqから継承する */ ¥
        struct CvSetElem* free_elems; /* 空きノードのリスト */

    typedef struct CvSet
    {
        CV_SET_FIELDS()
    } CvSet;

CvSet 構造体は、OpenCVの疎なデータ構造の基本である。

上述の宣言のとおり、CvSetCvSeqを継承し、 それにfree_elems(空きノードリスト)を加えたものである。 空きかそうでないかが記述されたセットの各ノードは、内部的なシーケンスの要素である。 密なシーケンスの要素に対するような制限はないが、セット(と、ここから派生する構造体)の要素は整数型のフィールドで始める必要があり、 CvSetElem 構造体に合致させる事ができなければならない。 なぜなら、これら二つのフィールド(整数とそれに続くポインタ)は、空きノードリストを持つノードセットの構成に必要だからである。 空きノードの場合、flags フィールドは負の値となる(フィールドの最上位ビット(MSB)がセットされている)。 そしてnext_freeは、次の空きノードを指す(先頭の空きノードは、CvSetfree_elemsフィールドから参照される)。ノードが使用されている場合、flags フィールドは0以上の値で、(set_elem->flags & CV_SET_ELEM_IDX_MASK) の式を用いて取り出されるようなノードインデックスを持つ。ノードの残り部分(next_free)はユーザによって決められる。 特に、使用されているノードは空きノードのようにリンクされていないので、2番目のフィールド(next_free)は、 このようなリンクや他の目的のために用いることができる。 マクロCV_IS_SET_ELEM(set_elem_ptr)は、指定したノードが使用されているかどうかを判断するために利用することができる。

最初、セットとリストは空である。セットから新しいノード要求があった場合、空きノードリストからノードが取り出され、その後リストは更新される。 空きノードリストが空の場合は、新しいシーケンスブロックが確保され、ブロック内のすべてのノードが空きノードリストに追加される。 従って、セットの total フィールドには、使用されているノード数と空きノードの数の合計が入る。 使用されていたノードが解放されたときには、空きノードリストに加えられる。最後に解放されるノードは、最初に使用されたものである。

OpenCVにおいて CvSet は、グラフ(CvGraph)、 疎な多次元配列(CvSparseMat)、 平面の再分割(CvSubdiv2D)などを表現するために使用される。



CvSet* cvCreateSet( int set_flags, int header_size,
                    int elem_size, CvMemStorage* storage );

空のセットを生成する



int cvSetAdd( CvSet* set_header, CvSetElem* elem=NULL, CvSetElem** inserted_elem=NULL );

セットに新しいノード(要素)を追加する



void cvSetRemove( CvSet* set_header, int index );

セットから要素を削除する



CvSetElem* cvSetNew( CvSet* set_header );

セットに要素を加える(高速版)



void cvSetRemoveByPtr( CvSet* set_header, void* elem );

ポインタで指定したセットの要素を削除する



CvSetElem* cvGetSetElem( const CvSet* set_header, int index );

インデックスによってセットの要素を検索する



void cvClearSet( CvSet* set_header );

セットをクリアする


グラフ(Graphs)


★★★
CvGraph

重み付きの有向または無向グラフ

    #define CV_GRAPH_VERTEX_FIELDS()    ¥
        int flags; /* 頂点フラグ */   ¥
        struct CvGraphEdge* first; /* 最初の辺 */ 

    typedef struct CvGraphVtx
    {
        CV_GRAPH_VERTEX_FIELDS()
    }
    CvGraphVtx;

    #define CV_GRAPH_EDGE_FIELDS()      ¥
        int flags; /* 辺フラグ */     ¥
        float weight; /* 辺の重み */ ¥
        struct CvGraphEdge* next[2]; /* 辺リストにおける次の辺.始点(0),終点(1) */ ¥
        struct CvGraphVtx* vtx[2]; /* 始点(0),終点(1) */

    typedef struct CvGraphEdge
    {
        CV_GRAPH_EDGE_FIELDS()
    }
    CvGraphEdge;

    #define  CV_GRAPH_FIELDS()                  ¥
        CV_SET_FIELDS() /* 頂点のセット */   ¥
        CvSet* edges;   /* 辺のセット*/

    typedef struct CvGraph
    {
        CV_GRAPH_FIELDS()
    }
    CvGraph;

CvGraph 構造体は、OpenCVで使用されるグラフの基本構造である。

グラフ構造体は、CvSet(一般的なグラフの特性とグラフ頂点を記述)を継承し、 さらにメンバーとしてもう一つのセット(グラフの辺を記述)を含んでいる。

頂点、辺、グラフヘッダの構造体は、他の拡張可能なOpenCVの構造体と同じ方法(構造体の拡張やカスタマイズをシンプルにするマクロを用いて)で宣言される。 頂点と辺の構造体は明示的には CvSetElem を継承していないが、 それらはセットの要素の二つの条件(先頭に整数フィールドflagsを持ち、CvSetElem 構造体と合致する)を満足している。 フィールド flags は、頂点と辺が存在していることを示すだけでなく、他の目的 (例えば、グラフの走査(cvCreateGraphScanner 等を参照))にも用いられるので、 このフィールドを直接使用しないほうが良い。

グラフは辺のセットとして表現され、各辺はそこに接続する辺のリストを持つ。情報の重複をできる限り避けるために、違う頂点への接続リストが交互に配置される。

グラフは有向か無向かのいずれかである。無向グラフの場合、頂点AからBへの接続と、頂点BからAへの接続の区別はなく、 グラフ上にはどちらか一方しか同時に存在できない。これらの接続はそれぞれ辺 <A, B> 、<B, A> と表現される。



CvGraph* cvCreateGraph( int graph_flags, int header_size, int vtx_size,
                        int edge_size, CvMemStorage* storage );

空のグラフを生成する



int cvGraphAddVtx( CvGraph* graph, const CvGraphVtx* vtx=NULL,
                   CvGraphVtx** inserted_vtx=NULL );

グラフに頂点を追加する



int cvGraphRemoveVtx( CvGraph* graph, int index );

グラフから頂点を削除する(インデックス指定)



int cvGraphRemoveVtxByPtr( CvGraph* graph, CvGraphVtx* vtx );

グラフから頂点を削除する(ポインタ指定)



CvGraphVtx* cvGetGraphVtx( CvGraph* graph, int vtx_idx );

インデックスを用いてグラフの頂点を検索する



int cvGraphVtxIdx( CvGraph* graph, CvGraphVtx* vtx );

グラフ頂点のインデックスを返す



int cvGraphAddEdge( CvGraph* graph, int start_idx, int end_idx,
                    const CvGraphEdge* edge=NULL, CvGraphEdge** inserted_edge=NULL );

グラフに辺を追加する(インデックス指定)



int cvGraphAddEdgeByPtr( CvGraph* graph, CvGraphVtx* start_vtx, CvGraphVtx* end_vtx,
                         const CvGraphEdge* edge=NULL, CvGraphEdge** inserted_edge=NULL );

グラフに辺を追加する(ポインタ指定)



void cvGraphRemoveEdge( CvGraph* graph, int start_idx, int end_idx );

グラフから辺を削除する(インデックス指定)



void cvGraphRemoveEdgeByPtr( CvGraph* graph, CvGraphVtx* start_vtx, CvGraphVtx* end_vtx );

グラフから辺を削除する(ポインタ指定)



CvGraphEdge* cvFindGraphEdge( const CvGraph* graph, int start_idx, int end_idx );
#define cvGraphFindEdge cvFindGraphEdge

グラフから辺を検出する(インデックス指定)



CvGraphEdge* cvFindGraphEdgeByPtr( const CvGraph* graph, const CvGraphVtx* start_vtx,
                                   const CvGraphVtx* end_vtx );
#define cvGraphFindEdgeByPtr cvFindGraphEdgeByPtr

グラフから辺を検出する(ポインタ指定)



int cvGraphEdgeIdx( CvGraph* graph, CvGraphEdge* edge );

グラフの辺のインデックスを返す



int cvGraphVtxDegree( const CvGraph* graph, int vtx_idx );

頂点に接続している辺の数を数える



int cvGraphVtxDegreeByPtr( const CvGraph* graph, const CvGraphVtx* vtx );

頂点に接続している辺の数を数える



void cvClearGraph( CvGraph* graph );

グラフをクリアする



CvGraph* cvCloneGraph( const CvGraph* graph, CvMemStorage* storage );

グラフをコピーする



CvGraphScanner

グラフ走査状態のための構造体



CvGraphScanner* cvCreateGraphScanner( CvGraph* graph, CvGraphVtx* vtx=NULL,
                                       int mask=CV_GRAPH_ALL_ITEMS );

グラフの深さ優先走査のための構造体を生成する



int cvNextGraphItem( CvGraphScanner* scanner );

グラフ走査処理を1ステップ、あるいは数ステップ進める



void cvReleaseGraphScanner( CvGraphScanner** scanner );

グラフの走査処理を終了する


木(Trees)


★★★
CV_TREE_NODE_FIELDS

ツリーノードの種類を宣言するための補助マクロ

#define CV_TREE_NODE_FIELDS(node_type)                          ¥
    int       flags;         /* 様々なフラグ */          ¥
    int       header_size;   /* シーケンスヘッダのサイズ */      ¥
    struct    node_type* h_prev; /* 一つ前のシーケンス */        ¥
    struct    node_type* h_next; /* 一つ後のシーケンス */            ¥
    struct    node_type* v_prev; /* 一つ前のシーケンス(セカンダリ,構造によって意味が異なる) */    ¥
    struct    node_type* v_next; /* 一つ後のシーケンス(セカンダリ,構造によって意味が異なる) */

マクロCV_TREE_NODE_FIELDS()は、すべての動的構造の基本タイプである CvSeqのように、 階層構造(ツリー)として組織化できるデータ構造を宣言するために使用される。 このマクロを用いて宣言されたノードから構成されるツリーは、このセクションで述べる各関数を用いて処理することができる。



CvTreeNodeIterator

ツリーノードのイテレータのための構造体



void cvInitTreeNodeIterator( CvTreeNodeIterator* tree_iterator,
                             const void* first, int max_level );

ツリーノードのイテレータを初期化する



void* cvNextTreeNode( CvTreeNodeIterator* tree_iterator );

現在のノードを返し、イテレータを次のノードに移動させる。



void* cvPrevTreeNode( CvTreeNodeIterator* tree_iterator );

現在のノードを返し、イテレータを前のノードに移動させる。



CvSeq* cvTreeToNodeSeq( const void* first, int header_size, CvMemStorage* storage );

すべてのノードへのポインタを一つのシーケンスに集める



void cvInsertNodeIntoTree( void* node, void* parent, void* frame );

ツリーに新しいノードを追加する



void cvRemoveNodeFromTree( void* node, void* frame );

ツリーからノードを削除する


描画関数(Drawing Functions)

描画関数は行列や画像、任意のカラーデプスで使われる。 アンチエイリアス処理は8ビット画像にのみ実装されている。 すべての関数はパラメータcolor(CV_RGBマクロか、関数cvScalarを用いて作成される)を持ち、 これはカラー画像ではrgb値、グレースケール画像では輝度を意味する。

描く図の一部、もしくは全てが画像の領域外にある場合には、その部分は切り取られる。 カラー画像の場合、チャンネルの順番は...である。 順番を変更したい場合は、cvScalarを用いて順番を指定するか、cvCvtColor あるいは cvTransformを用いて、描画前、もしくは描画後に画像を変換すればよい。


曲線と形状(Curves and Shapes)


★★★
CV_RGB

カラー値を作成する

#define CV_RGB( r, g, b )  cvScalar( (b), (g), (r) )

★★★
void cvLine( CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color,
             int thickness=1, int line_type=8, int shift=0 );

2点を結ぶ線分を描画する

img
画像。
pt1
線分の1番目の端点。
pt2
線分の2番目の端点。
color
線分の色。
thickness
線分の太さ。
line_type
線分の種類。
8 (または0) - 8連結による線分。
4 - 4連結による線分。
CV_AA - アンチエイリアスされた線分。
shift
座標の小数点以下の桁を表すビット数。

cvLine関数は、点pt1と点pt2を結ぶ線分を画像上に描画する。 描画される線分は画像やROIにより切り取られる。 整数値座標でアンチエイリアスされていない線分では、8連結、または4連結のブレゼンハム(Bresenham)アルゴリズムが使われる。 太い線分の端は丸く描画される。アンチエイリアスされた線分は、ガウシアン(Gaussian)フィルタを用いて描かれる。 線分の色を指定するには、マクロCV_RGB(r, g, b)を用いる。

使用例は、4.5 ハフ変換を参照。


★★★
void cvRectangle( CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color,
                  int thickness=1, int line_type=8, int shift=0 );

枠のみ、もしくは塗りつぶされた矩形を描画する

img
矩形が描画される画像。
pt1
矩形の一つの頂点。
pt2
矩形の反対側の頂点。
color
線の色(RGB)、もしくは輝度(グレースケール画像)。
thickness
矩形を描く線の太さ。負の値、例えばCV_FILLEDを指定した場合は塗りつぶされる。
line_type
線の種類、詳細はcvLineを参照。
shift
座標の小数点以下の桁を表すビット数。

cvRectangle関数は、点pt1と点pt2を対角とする矩形を描画する。

使用例は、4.2 ヒストグラム、 4.6 対応領域探索を参照。


★★★
void cvCircle( CvArr* img, CvPoint center, int radius, CvScalar color,
               int thickness=1, int line_type=8, int shift=0 );

円を描画する

img
円が描画される画像。
center
円の中心。
radius
円の半径。
color
円の色。
thickness
線の幅。負の値を指定した場合は塗りつぶされる。
line_type
線の種類、詳細はcvLineを参照。
shift
中心座標と半径の小数点以下の桁を表すビット数。

cvCircle 関数は、与えた中心と半径に応じて枠だけ、もしくは塗りつぶされた円を描く。描画される円はROIによって切り取られる。 円の色はマクロCV_RGB ( r, g, b )で指定できる。


★★★
void cvEllipse( CvArr* img, CvPoint center, CvSize axes, double angle,
                double start_angle, double end_angle, CvScalar color,
                int thickness=1, int line_type=8, int shift=0 );

枠だけの楕円、楕円弧、もしくは塗りつぶされた扇形の楕円を描画する

img
楕円が描画される画像。
center
楕円の中心。
axes
楕円の軸の長さ。
angle
回転角度。
start_angle
楕円弧の開始角度。
end_angle
楕円弧の終了角度。
color
楕円の色。
thickness
楕円弧の線の幅。
line_type
楕円弧の線の種類。詳細はcvLineを参照。
shift
中心座標と軸の長さの小数点以下の桁を表すビット数。

cvEllipse 関数は、枠だけの楕円、楕円弧、もしくは塗りつぶした楕円を描画する。 描画される楕円はROIによって切り取られる。 アンチエイリアスされた線や太い線を指定した場合には、線形近似が用いられる。角度は度で指定する。


★★
void cvEllipseBox( CvArr* img, CvBox2D box, CvScalar color,
                   int thickness=1, int line_type=8, int shift=0 );

枠だけの楕円、もしくは塗りつぶされた楕円を描画する

img
楕円が描かれる画像。
box
描画したい楕円を囲む矩形領域。
thickness
楕円境界線の幅。
line_type
楕円境界線の種類。詳細はcvLineを参照。
shift
矩形領域の頂点座標の小数点以下の桁を表すビット数。


★★
void cvFillPoly( CvArr* img, CvPoint** pts, int* npts, int contours,
                 CvScalar color, int line_type=8, int shift=0 );

ポリゴン内部を塗りつぶす

img
ポリゴンが描かれる画像。
pts
ポリゴンへのポインタ配列。
npts
ポリゴン頂点数の配列。
contours
塗りつぶされた領域を区切る輪郭の数。
color
ポリゴンの色。
line_type
線の種類。詳細はcvLineを参照。
shift
頂点座標の小数点以下の桁を表すビット数。


★★
void cvFillConvexPoly( CvArr* img, CvPoint* pts, int npts,
                       CvScalar color, int line_type=8, int shift=0 );

凸ポリゴンを塗りつぶす

img
ポリゴンが描かれる画像。
pts
一つのポリゴンへのポインタの配列。
npts
ポリゴンの頂点数。
color
ポリゴンの色。
line_type
線の種類。詳細はcvLineを参照。
shift
頂点座標の小数点以下の桁を表すビット数。


★★
void cvPolyLine( CvArr* img, CvPoint** pts, int* npts, int contours, int is_closed,
                 CvScalar color, int thickness=1, int line_type=8, int shift=0 );

ポリライン(枠だけのポリゴン)を描画する

img
ポリラインが描かれる画像。
pts
ポリラインへのポインタの配列。
npts
ポリラインの頂点数の配列。
contours
ポリラインの個数。
is_closed
ポリラインを閉じるかどうかを指定する。閉じる場合、それぞれの領域の最後の頂点と最初の頂点を結ぶ線分を描画する。
color
線の色。
thickness
線の太さ。
line_type
線の種類。詳細はcvLineを参照。
shift
頂点座標の小数点以下の桁を表すビット数。


テキスト(Text)


★★
void cvInitFont( CvFont* font, int font_face, double hscale,
                 double vscale, double shear=0,
                 int thickness=1, int line_type=8 );

フォント構造体を初期化する

font
この関数で初期化されるフォント構造体へのポインタ
font_face
フォント名の識別子。現在は、Hershey fonts (http://sources.isc.org/utils/misc/hershey-font.txt) の一部のみサポートされている。
CV_FONT_HERSHEY_SIMPLEX - 普通サイズのsans-serif フォント
CV_FONT_HERSHEY_PLAIN - 小さいサイズのsans-serif フォント
CV_FONT_HERSHEY_DUPLEX - 普通サイズのsans-serif フォント (CV_FONT_HERSHEY_SIMPLEX よりも複雑)
CV_FONT_HERSHEY_COMPLEX - 普通サイズのserif フォント
CV_FONT_HERSHEY_TRIPLEX - 普通サイズのserif フォント (CV_FONT_HERSHEY_COMPLEX よりも複雑)
CV_FONT_HERSHEY_COMPLEX_SMALL - CV_FONT_HERSHEY_COMPLEX の小さいバージョン
CV_FONT_HERSHEY_SCRIPT_SIMPLEX - 手書きスタイルのフォント
CV_FONT_HERSHEY_SCRIPT_COMPLEX - CV_FONT_HERSHEY_SCRIPT_SIMPLEX の複雑なバージョン
パラメータは上記の値と、イタリックもしくは斜字を意味するオプションCV_FONT_ITALICフラグを合成することができる。
hscale
幅の比率。1.0fにした場合、文字はそれぞれのフォントに依存する元々の幅で表示される。 0.5fにした場合, 文字は元々の半分の幅で表示される。
vscale
高さの比率。1.0fにした場合、文字はそれぞれのフォントに依存する元々の高さで表示される。 0.5fにした場合, 文字は元々の半分の高さで表示される。
shear
垂直線からの文字の相対的な角度。ゼロの場合は非イタリックフォントで、例えば、1.0f≈45°を意味する。
thickness
文字の太さ。
line_type
線の種類。詳細はcvLineを参照。


★★
void cvPutText( CvArr* img, const char* text, CvPoint org, const CvFont* font, CvScalar color );

文字列を描画する

img
入力画像。
text
描画する文字列。
org
最初の文字の左下の座標。
font
フォント構造体へのポインタ。
color
文字の色。


★★
void cvGetTextSize( const char* text_string, const CvFont* font, CvSize* text_size, int* baseline );

文字列の幅と高さを取得する

text_string
入力文字列。
font
フォント構造体へのポインタ。
text_size
結果として得られる文字列のサイズ。文字の高さには、ベースラインより下の部分の高さは含まれない。
baseline
文字の最下点から見たベースラインのy座標。


点集合と輪郭(Point Sets and Contours)


★★
void cvDrawContours( CvArr *img, CvSeq* contour,
                     CvScalar external_color, CvScalar hole_color,
                     int max_level, int thickness=1,
                     int line_type=8, CvPoint offset=cvPoint(0,0) );

画像の外側輪郭線、または内側輪郭線を描画する

img
輪郭を描画する元画像。輪郭はROIで切り取られる。
contour
最初の輪郭へのポインタ。
external_color
外側輪郭線の色。
hole_color
内側輪郭線(穴)の色。
max_level
描画される輪郭の最大レベル。 0にした場合、contourのみが描画される。 1にした場合、先頭の輪郭と、同レベルのすべての輪郭が描画される。 2にした場合、先頭の輪郭と同レベルのすべての輪郭と、先頭の輪郭の一つ下のレベルのすべての輪郭が描画される。以下同様。 負の値にした場合、この関数はcontourの後に続く同レベルの輪郭を描画しないが、 contourの子の輪郭をabs(max_level)-1のレベルまで描画する。
thickness
描画される輪郭線の太さ。負(例えば=CV_FILLED)にした場合には、内部を塗りつぶす。
line_type
線の種類。詳細はcvLineを参照。
offset
全ての座標を指定した値だけシフトする。これは、輪郭をROI内の画像から生成して、ROIのオフセットを考慮する必要がある場合に便利である。

使用例は、4.3 輪郭抽出を参照。


★★
int cvInitLineIterator( const CvArr* image, CvPoint pt1, CvPoint pt2,
                        CvLineIterator* line_iterator, int connectivity=8,
                        int left_to_right=0 );

ラインイテレータを初期化する

image
対象画像。
pt1
線分の一つ目の端点。
pt2
線分のニつ目の端点。
line_iterator
ラインイテレータ状態構造体へのポインタ。
connectivity
走査した線分の接続性。4または8。
left_to_right
pt1pt2とは無関係に線分をいつも左から右に走査する(left_to_right≠0)か、 pt1からpt2への決まった方向で走査するか(left_to_right=0)を指定するフラグ.


★★
int cvClipLine( CvSize img_size, CvPoint* pt1, CvPoint* pt2 );

線分を画像領域で切り取る

img_size
画像の大きさ。
pt1
線分の1番目の端点。この値はこの関数によって変更される。
pt2
線分の2番目の端点。この値はこの関数によって変更される。


★★
int cvEllipse2Poly( CvPoint center, CvSize axes,
                    int angle, int arc_start,
                    int arc_end, CvPoint* pts, int delta );

楕円弧をポリラインで近似する

center
弧の中心。
axes
楕円の軸の長さ。cvEllipseを参照。
angle
楕円の回転角度。cvEllipseを参照。
start_angle
楕円弧の開始角度。
end_angle
楕円弧の終了角度。
pts
この関数で塗りつぶされる点の配列。
delta
ポリラインの連続した頂点間の角度、近似精度。出力される点の総数は最大で ceil((end_angle - start_angle)/delta) + 1。


データ永続性と実行時型情報(Data Persistence and RTTI)


ファイルストレージ(File Storage)



CvFileStorage

ファイルストレージ



CvFileNode

ファイルストレージノード



CvAttrList

属性のリスト



CvFileStorage* cvOpenFileStorage( const char* filename, CvMemStorage* memstorage, int flags );

データ読み書きのためのファイルをオープンする



void cvReleaseFileStorage( CvFileStorage** fs );

ファイルストレージの解放


データの書き込み(Writing Data)



void cvStartWriteStruct( CvFileStorage* fs, const char* name,
                          int struct_flags, const char* type_name=NULL,
                          CvAttrList attributes=cvAttrList());

新しい構造体の書き込みを開始する



void cvEndWriteStruct( CvFileStorage* fs );

構造体の書き込みを終了する



void cvWriteInt( CvFileStorage* fs, const char* name, int value );

整数型の値を書き込む



void cvWriteReal( CvFileStorage* fs, const char* name, double value );

浮動小数点型の値を書き込む



void cvWriteString( CvFileStorage* fs, const char* name,
                     const char* str, int quote=0 );

文字列を書き込む



void cvStartNextStream( CvFileStorage* fs );

次のストリームを開始する



void cvWrite( CvFileStorage* fs, const char* name,
               const void* ptr, CvAttrList attributes=cvAttrList() );

ユーザオブジェクトを書き込む



void cvWriteRawData( CvFileStorage* fs, const void* src,
                      int len, const char* dt );

複数の数値を書き込む



void cvWriteFileNode( CvFileStorage* fs, const char* new_node_name,
                      const CvFileNode* node, int embed );

ファイルノードを他のファイルストレージに書き込む


データの読み込み(Reading Data)

データはファイルストレージから二つの段階を経て取り込まれる。まず要求されたデータを含むファイルノードを探索し、 その後にそのノードから手動、もしくは特別なreadメソッドを用いて取り込む。



CvFileNode* cvGetRootFileNode( const CvFileStorage* fs, int stream_index=0 );

ファイルストレージのトップレベルノードの一つを取り込む



CvFileNode* cvGetFileNodeByName( const CvFileStorage* fs,
                                 const CvFileNode* map,
                                 const char* name );

マップ内またはファイルストレージ内からノードを探索する



CvStringHashNode* cvGetHashedKey( CvFileStorage* fs, const char* name,
                                  int len=-1, int create_missing=0 );

与えた名前に対するユニークなポインタを返す



CvFileNode* cvGetFileNode( CvFileStorage* fs, CvFileNode* map,
                           const CvStringHashNode* key, int create_missing=0 );

マップまたはファイルストレージ内のノードを見つける



const char* cvGetFileNodeName( const CvFileNode* node );

ファイルノードの名前を返す



int cvReadInt( const CvFileNode* node, int default_value=0 );

ファイルノードから整数値を読み込む



int cvReadIntByName( const CvFileStorage* fs, const CvFileNode* map,
                     const char* name, int default_value=0 );

ファイルノードを探索し、その値を返す



double cvReadReal( const CvFileNode* node, double default_value=0. );

ファイルノードから浮動小数点型の値を取り込む



double cvReadRealByName( const CvFileStorage* fs, const CvFileNode* map,
                          const char* name, double default_value=0. );

ファイルノードを探してその値を返す



const char* cvReadString( const CvFileNode* node, const char* default_value=NULL );

ファイルノードから文字列を取り出す



const char* cvReadStringByName( const CvFileStorage* fs, const CvFileNode* map,
                                const char* name, const char* default_value=NULL );

ファイルノードを探索して、その値を返す



void* cvRead( CvFileStorage* fs, CvFileNode* node,
              CvAttrList* attributes=NULL );

オブジェクトをデコードし、そのポインタを返す



void* cvReadByName( CvFileStorage* fs, const CvFileNode* map,
                    const char* name, CvAttrList* attributes=NULL );

オブジェクトを探索し、デコードする



void cvReadRawData( const CvFileStorage* fs, const CvFileNode* src,
                    void* dst, const char* dt );

複数の数値を読み込む



void cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src,
                         CvSeqReader* reader );

ファイルノードのシーケンスリーダの初期化



void cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader,
                         int count, void* dst, const char* dt );

複数の数値のシーケンスを読み込む


実行時型情報と汎用関数(RTTI and Generic Functions)



CvTypeInfo

型情報



void cvRegisterType( const CvTypeInfo* info );

新しい型を登録する



void cvUnregisterType( const char* type_name );

型の登録を取り消す



CvTypeInfo* cvFirstType( void );

型リストの先頭を返す



CvTypeInfo* cvFindType( const char* type_name );

名前から型を見つける



CvTypeInfo* cvTypeOf( const void* struct_ptr );

オブジェクトの型を返す


★★★
void cvRelease( void** struct_ptr );

オブジェクトを解放する

struct_ptr
オブジェクトのポインタのポインタ。

cvRelease 関数は、与えられたオブジェクトの型を見つけ、与えられたポインタのポインタを引数にreleaseを呼ぶ。


★★★
void* cvClone( const void* struct_ptr );

オブジェクトのコピーを作成する

struct_ptr
コピーするオブジェクト。

cvClone 関数は、与えたオブジェクトの型を見つけ、渡されたオブジェクトを引数にcloneを呼ぶ。



void cvSave( const char* filename, const void* struct_ptr,
             const char* name=NULL,
             const char* comment=NULL,
             CvAttrList attributes=cvAttrList());

オブジェクトをファイルに保存する



void* cvLoad( const char* filename, CvMemStorage* memstorage=NULL,
              const char* name=NULL, const char** real_name=NULL );

オブジェクトをファイルから読み込む


その他の関数(Miscellaneous Functions)



int cvCheckArr( const CvArr* arr, int flags=0,
                 double min_val=0, double max_val=0);
#define cvCheckArray cvCheckArr

入力配列のすべての要素について、無効な値が存在しないかをチェックする


★★
void cvKMeans2( const CvArr* samples, int cluster_count,
                CvArr* labels, CvTermCriteria termcrit );

ベクトル集合を、与えられたクラスタ数に分割する

samples
浮動小数点型の入力サンプル行列。1行あたり一つのサンプル。
cluster_count
集合を分割するクラスタ数。
labels
出力の整数ベクトル。すべてのサンプルについて、それぞれがどのクラスタに属しているかが保存されている。
termcrit
最大繰り返し数と(または)、精度(1ループでの各クラスタ中心位置移動距離)の指定。


★★
int cvSeqPartition( const CvSeq* seq, CvMemStorage* storage, CvSeq** labels,
                    CvCmpFunc is_equal, void* userdata );
typedef int (CV_CDECL* CvCmpFunc)(const void* a, const void* b, void* userdata);

データシーケンスを同値類(同じクラスに属すると定義されたデータ群)に分割する

seq
分割対象のシーケンス。
storage
同値類として分割されたシーケンスの保存領域。NULLの場合は、seq->storage を使用する。
labels
出力パラメータ。入力シーケンスの各要素に割り振られた(分割結果を表す)0から始まるラベルシーケンスへのポインタのポインタ。
is_equal
2つのシーケンス要素が同じクラスである場合、関係関数は 0以外を返す。 そうでなければ0を返す。分割アルゴリズムは、同値基準として関係関数の推移閉包を用いる。
userdata
is_equal 関数の引数として渡すデータへのポインタ。


エラーハンドリングとシステム関数(Error Handling and System Functions)


エラーハンドリング(Error Handling)

OpenCV におけるエラーハンドリングは、IPL(Image Processing Library)と似ている。 エラーが発生した場合でも、関数はエラーコードを返さない。 その代わり、エラーステータスをcvSetErrStatusを用いてセットし、 標準またはユーザ定義のエラーハンドラ(メッセージボックスの表示や、ログに書き込む、など。 cvRedirectErrorcvNulDevReport, cvStdErrReport, cvGuiBoxReportを参照) を呼び出すcvError関数を呼ぶマクロCV_ERROR を用いてエラーの通知を行う。 各プログラムスレッドについて、それぞれ一つずつ、現在のエラーステータス(一つの整数値)を持つグローバル変数が存在する。 このエラーステータスは、 cvGetErrStatus 関数を用いて取り出すことが可能である。

エラーハンドリングには、以下の三つのモードが存在する(cvSetErrModecvGetErrMode を参照)。

Leaf
プログラムはエラーハンドラを呼び出した後、途中終了する。デフォルト。エラー発生後、直ちに通知されるので、デバッグ時に有効。 しかし、製品(完成版の)システムでは、他の二つのモードの使用が制御しやすいので好ましい。
Parent
プログラムは途中終了しないが、エラーハンドラが呼び出される。スタックは解放されない(C++の例外処理を用いないため)。 ユーザはCxCoreのcvGetErrStatus関数を呼び出し、エラーコードをチェックし、対処を行わなければならない。
Silent
Parentモードとほぼ同じだが、エラーハンドラは呼び出されない。

実際は、モードLeafParent の動作はエラーハンドラによって実装される。 上記の説明はcvNulDevReport, cvStdErrReport に関しては正しい。 cvGuiBoxReport は多少異なった動作をし、さらに、 カスタマイズされたエラーハンドラは、全く違う動作の実装になる可能性がある。


ERROR Handling Macros

エラー表示やチェックなどの機能をもつマクロ群

/* 関数内の処理ステートメントを挟み、それらをプロローグ(リソースの初期化部)とエピローグ
   (確保されたリソースの解放部)に分離する特別なマクロ */
#define __BEGIN__       {
#define __END__         goto exit; exit: ; }
/* 「リソース解放ステージ」へ進む */
#define EXIT            goto exit

/* CV_ERROR() で使用する関数名をローカルに定義する */
#define CV_FUNCNAME( Name )  ¥
    static char cvFuncName[] = Name

/* 現状のエラーを報告する */
#define CV_ERROR( Code, Msg )                                       ¥
{                                                                   ¥
     cvError( (Code), cvFuncName, Msg, __FILE__, __LINE__ );        ¥
     EXIT;                                                          ¥
}

/* CXCOREの関数呼び出しの後の状態をチェックする */
#define CV_CHECK()                                                  ¥
{                                                                   ¥
    if( cvGetErrStatus() < 0 )                                   ¥
        CV_ERROR( CV_StsBackTrace, "Inner function failed." );      ¥
}

/* CXCOREの関数呼び出しとCV_CHECK()呼び出しの簡略表現 */
#define CV_CALL( Statement )                                        ¥
{                                                                   ¥
    Statement;                                                      ¥
    CV_CHECK();                                                     ¥
}

/* デバッグモードとリリースモード両方に対応した状態チェック */
#define CV_ASSERT( Condition )                                          ¥
{                                                                       ¥
    if( !(Condition) )                                                  ¥
        CV_ERROR( CV_StsInternal, "Assertion: " #Condition " failed" ); ¥
}

/* これらのマクロは、それぞれ対応するマクロCV_... と似ているが、
   終了ラベルも定義用のcvFuncNameも必要としない */
#define OPENCV_ERROR(status,func_name,err_msg) ...
#define OPENCV_ERRCHK(func_name,err_msg) ...
#define OPENCV_ASSERT(condition,func_name,err_msg) ...
#define OPENCV_CALL(statement) ...


int cvGetErrStatus( void );

現在のエラーステータスを返す



void cvSetErrStatus( int status );

エラーステータスをセットする



int cvGetErrMode( void );

現在のエラーモードを返す



int cvSetErrMode( int mode );

#define CV_ErrModeLeaf    0
#define CV_ErrModeParent  1
#define CV_ErrModeSilent  2

エラーモードをセットする


★★
int cvError( int status, const char* func_name,
             const char* err_msg, const char* file_name, int line );

エラーを発生させる

status
エラーステータス。
func_name
エラーが発生した関数名。
err_msg
エラーについての追加情報/診断結果。
file_name
エラーが発生したファイル名。
line
エラーが発生した行番号。


★★
const char* cvErrorStr( int status );

エラーステータスのコードのテキスト情報を返す

status
エラーステータス。



CvErrorCallback cvRedirectError( CvErrorCallback error_handler,
                                 void* userdata=NULL, void** prev_userdata=NULL );

typedef int (CV_CDECL *CvErrorCallback)( int status, const char* func_name,
                    const char* err_msg, const char* file_name, int line );

新しいエラーハンドラをセットする


★★
int cvNulDevReport( int status, const char* func_name,
                    const char* err_msg, const char* file_name,
                    int line, void* userdata );

int cvStdErrReport( int status, const char* func_name,
                    const char* err_msg, const char* file_name,
                    int line, void* userdata );

int cvGuiBoxReport( int status, const char* func_name,
                    const char* err_msg, const char* file_name,
                    int line, void* userdata );

標準のエラーハンドリングを提供する

status
エラーステータス。
func_name
エラーが発生した関数名。
err_msg
エラーについての追加情報/診断結果。
file_name
エラーが発生したファイル名。
line
エラーが発生した行番号。
userdata
ユーザーデータへのポインタ。標準ハンドラでは無視される。


システム関数(System Functions)


★★
void* cvAlloc( size_t size );

メモリバッファの領域を確保する

size
バッファサイズ(バイト単位)。


★★
void cvFree( T** ptr );

メモリバッファの領域を解放する

buffer
解放する領域へのポインタのポインタ。



int64 cvGetTickCount( void );

tics数を返す



double cvGetTickFrequency( void );

1ミリ秒あたりのtics数を返す



int cvRegisterModule( const CvModuleInfo* module_info );

typedef struct CvPluginFuncInfo
{
    void** func_addr;
    void* default_func_addr;
    const char* func_names;
    int search_modules;
    int loaded_from;
}
CvPluginFuncInfo;

typedef struct CvModuleInfo
{
    struct CvModuleInfo* next;
    const char* name;
    const char* version;
    CvPluginFuncInfo* func_tab;
}
CvModuleInfo;

他のモジュールを登録する



void cvGetModuleInfo( const char* module_name,
                       const char** version,
                       const char** loaded_addon_plugins );

登録されたモジュールとプラグインの情報を取り出す



int cvUseOptimized( int on_off );

最適化モード/非最適化モードを切り替える



void cvSetMemoryManager( CvAllocFunc alloc_func=NULL,
                         CvFreeFunc free_func=NULL,
                         void* userdata=NULL );

typedef void* (CV_CDECL *CvAllocFunc)(size_t size, void* userdata);
typedef int (CV_CDECL *CvFreeFunc)(void* pptr, void* userdata);

カスタムあるいはデフォルトのメモリ管理関数を指定する



void cvSetIPLAllocators( Cv_iplCreateImageHeader create_header,
                         Cv_iplAllocateImageData allocate_data,
                         Cv_iplDeallocate deallocate,
                         Cv_iplCreateROI create_roi,
                         Cv_iplCloneImage clone_image );

typedef IplImage* (CV_STDCALL* Cv_iplCreateImageHeader)
                            (int,int,int,char*,char*,int,int,int,int,int,
                            IplROI*,IplImage*,void*,IplTileInfo*);
typedef void (CV_STDCALL* Cv_iplAllocateImageData)(IplImage*,int,int);
typedef void (CV_STDCALL* Cv_iplDeallocate)(IplImage*,int);
typedef IplROI* (CV_STDCALL* Cv_iplCreateROI)(int,int,int,int,int);
typedef IplImage* (CV_STDCALL* Cv_iplCloneImage)(const IplImage*);

#define CV_TURN_ON_IPL_COMPATIBILITY()                                  ¥
    cvSetIPLAllocators( iplCreateImageHeader, iplAllocateImage,         ¥
                        iplDeallocate, iplCreateROI, iplCloneImage )

画像領域の確保と解放のためのIPL関数に切り替える



int cvGetNumThreads( void);

現在使われているスレッド数を返す



void cvSetNumThreads( int threads=0 );

スレッド数をセットする



int cvGetThreadNum( void );

現在のスレッドのインデックスを返す

OpenCVリファレンスマニュアル


CV_RGB
CV_TREE_NODE_FIELDS
CvANN_MLP
CvANN_MLP_TrainParams
CvANN_MLP::create
CvANN_MLP::train
CvArr
CvAttrList
CvBoost
CvBoostParams
CvBoostTree
CvBoost::get_weak_predictors
CvBoost::predict
CvBoost::prune
CvBoost::train
CvBox2D
CvCapture
CvConnectedComp
CvConvexityDefect
CvDTree
CvDTreeNode
CvDTreeParams
CvDTreeSplit
CvDTreeTrainData
CvDTree::predict
CvDTree::train
CvEM
CvEMParams
CvEM::train
CvFileNode
CvFileStorage
CvGraph
CvGraphScanner
CvHaarClassifier
CvHaarClassifierCascade
CvHaarFeature
CvHaarStageClassifier
CvHistogram
CvKNearest
CvKNearest::find_nearest
CvKNearest_train
CvKalman
CvMat
CvMatND
CvMemBlock
CvMemStorage
CvMemStoragePos
CvNormalBayesClassifier
CvNormalBayesClassifier::predict
CvNormalBayesClassifier::train
CvPoint
CvPoint2D32f
CvPoint2D64f
CvPoint3D32f
CvPoint3D64f
CvQuadEdge2D
CvRTParams
CvRTrees
CvRTrees::get_proximity
CvRTrees::get_var_importance
CvRTrees::predict
CvRTrees::train
CvRect
CvSVM
CvSVMParams
CvSVM::get_support_vector
CvSVM::train
CvScalar
CvSeq
CvSeqBlock
CvSet
CvSize
CvSize2D32f
CvSlice
CvSparseMat
CvStatModel
CvStatModel::CvStatModel
CvStatModel::clear
CvStatModel::CvStatModel(data)
CvStatModel::~CvStatModel
CvStatModel::load
CvStatModel::predict
CvStatModel::read
CvStatModel::save
CvStatModel::train
CvStatModel::write
CvSubdiv2D
CvSubdiv2DPoint
CvTermCriteria
CvTreeNodeIterator
CvTypeInfo
IplImage
RTreesOOBerror
cv2DRotationMatrix
cvAbsDiff
cvAbsDiffS
cvAcc
cvAdaptiveThreshold
cvAdd
cvAddS
cvAddWeighted
cvAlloc
cvAnd
cvAndS
cvApproxChains
cvApproxPoly
cvArcLength
cvAvg
cvAvgSdv
cvBackProjectPCA
cvBoundingRect
cvBoxPoints
cvCalcBackProject
cvCalcBackProjectPatch
cvCalcCovarMatrix
cvCalcEMD2
cvCalcGlobalOrientation
cvCalcHist
cvCalcImageHomography
cvCalcMotionGradient
cvCalcOpticalFlowBM
cvCalcOpticalFlowHS
cvCalcOpticalFlowLK
cvCalcOpticalFlowPyrLK
cvCalcPCA
cvCalcPGH
cvCalcProbDensity
cvCalcSubdivVoronoi2D
cvCalibrateCamera2
cvCamShift
cvCanny
cvCartToPolar
cvCbrt
cvCheckArr
cvCheckContourConvexity
cvCircle
cvClearGraph
cvClearHist
cvClearMemStorage
cvClearND
cvClearSeq
cvClearSet
cvClearSubdivVoronoi2D
cvClipLine
cvClone
cvCloneGraph
cvCloneImage
cvCloneMat
cvCloneMatND
cvCloneSeq
cvCloneSparseMat
cvCmp
cvCmpS
cvCompareHist
cvComputeCorrespondEpilines
cvConDensInitSampleSet
cvConDensUpdateByTime
cvContourArea
cvContourFromContourTree
cvConvert
cvConvertImage
cvConvertPointsHomogenious
cvConvertScale
cvConvertScaleAbs
cvConvexHull2
cvConvexityDefects
cvCopy
cvCopyHist
cvCopyMakeBorder
cvCornerEigenValsAndVecs
cvCornerHarris
cvCornerMinEigenVal
cvCountNonZero
cvCreateCameraCapture
cvCreateChildMemStorage
cvCreateConDensation
cvCreateContourTree
cvCreateData
cvCreateFileCapture
cvCreateGraph
cvCreateGraphScanner
cvCreateHist
cvCreateImage
cvCreateImageHeader
cvCreateKalman
cvCreateMat
cvCreateMatHeader
cvCreateMatND
cvCreateMatNDHeader
cvCreateMemStorage
cvCreatePOSITObject
cvCreateSeq
cvCreateSet
cvCreateSparseMat
cvCreateStructuringElementEx
cvCreateSubdivDelaunay2D
cvCreateTrackbar
cvCreateVideoWriter
cvCrossProduct
cvCvtColor
cvCvtScale
cvCvtSeqToArray
cvDCT
cvDFT
cvDecRefData
cvDestroyAllWindows
cvDestroyWindow
cvDet
cvDilate
cvDistTransform
cvDiv
cvDotProduct
cvDrawChessBoardCorners
cvDrawContours
cvEigenVV
cvEllipse
cvEllipse2Poly
cvEllipseBox
cvEndFindContours
cvEndWriteSeq
cvEndWriteStruct
cvEqualizeHist
cvErode
cvError
cvErrorStr
cvExp
cvFastArctan
cvFillConvexPoly
cvFillPoly
cvFilter2D
cvFindChessboardCorners
cvFindContours
cvFindCornerSubPix
cvFindExtrinsicCameraParams2
cvFindFundamentalMat
cvFindGraphEdge
cvFindGraphEdgeByPtr
cvFindHomography
cvFindNearestPoint2D
cvFindNextContour
cvFindType
cvFirstType
cvFitEllipse2
cvFitLine2D
cvFlip
cvFloodFill
cvFlushSeqWriter
cvFree
cvGEMM
cvGet1D
cvGet2D
cvGet3D
cvGetND
cvGetAffineTransform
cvGetCaptureProperty
cvGetCentralMoment
cvGetCol
cvGetDiag
cvGetDims
cvGetElemType
cvGetErrMode
cvGetErrStatus
cvGetFileNode
cvGetFileNodeByName
cvGetFileNodeName
cvGetGraphVtx
cvGetHashedKey
cvGetHistValue_1D
cvGetHistValue_2D
cvGetHistValue_3D
cvGetHistValue_nD
cvGetHuMoments
cvGetImage
cvGetImageCOI
cvGetImageROI
cvGetMat
cvGetMinMaxHistValue
cvGetModuleInfo
cvGetNextSparseNode
cvGetNormalizedCentralMoment
cvGetNumThreads
cvGetOptimalDFTSize
cvGetPerspectiveTransform
cvGetQuadrangleSubPix
cvGetRawData
cvGetReal1D
cvGetReal2D
cvGetReal3D
cvGetRealND
cvGetRectSubPix
cvGetRootFileNode
cvGetRow
cvGetSeqElem
cvGetSeqReaderPos
cvGetSetElem
cvGetSize
cvGetSpatialMoment
cvGetSubRect
cvGetTextSize
cvGetThreadNum
cvGetTickCount
cvGetTickFrequency
cvGetTrackbarPos
cvGetWindowHandle
cvGetWindowName
cvGoodFeaturesToTrack
cvGrabFrame
cvGraphAddEdge
cvGraphAddEdgeByPtr
cvGraphAddVtx
cvGraphEdgeIdx
cvGraphRemoveEdge
cvGraphRemoveEdgeByPtr
cvGraphRemoveVtx
cvGraphRemoveVtxByPtr
cvGraphVtxDegree
cvGraphVtxDegreeByPtr
cvGraphVtxIdx
cvGuiBoxReport
cvHaarDetectObjects
cvHoughCircles
cvHoughLines2
cvInRange
cvInRangeS
cvIncRefData
cvInitFont
cvInitImageHeader
cvInitLineIterator
cvInitMatHeader
cvInitMatNDHeader
cvInitSparseMatIterator
cvInitSystem
cvInitTreeNodeIterator
cvInitUndistortMap
cvInpaint
cvInsertNodeIntoTree
cvIntegral
cvInvSqrt
cvInvert
cvIsInf
cvIsNaN
cvKMeans2
cvKalmanCorrect
cvKalmanPredict
cvLUT
cvLaplace
cvLine
cvLoad
cvLoadHaarClassifierCascade
cvLoadImage
cvLog
cvLogPolar
cvMahalonobis
cvMakeHistHeaderForArray
cvMakeSeqHeaderForArray
cvMat
cvMatchContourTrees
cvMatchShapes
cvMatchTemplate
cvMax
cvMaxRect
cvMaxS
cvMeanShift
cvMemStorageAlloc
cvMemStorageAllocString
cvMerge
cvMin
cvMinAreaRect2
cvMinEnclosingCircle
cvMinMaxLoc
cvMinS
cvMixChannels
cvMoments
cvMorphologyEx
cvMoveWindow
cvMul
cvMulSpectrums
cvMulTransposed
cvMultiplyAcc
cvNamedWindow
cvNextGraphItem
cvNextTreeNode
cvNorm
cvNormalize
cvNormalizeHist
cvNot
cvNulDevReport
cvOpenFileStorage
cvOr
cvOrS
cvPOSIT
cvPerspectiveTransform
cvPointPolygonTest
cvPointSeqFromMat
cvPolarToCart
cvPolyLine
cvPow
cvPreCornerDetect
cvPrevTreeNode
cvProjectPCA
cvProjectPoints2
cvPtr1D
cvPtr2D
cvPtr3D
cvPtrND
cvPutText
cvPyrDown
cvPyrMeanShiftFiltering
cvPyrSegmentation
cvPyrUp
cvQueryFrame
cvQueryHistValue_1D
cvQueryHistValue_2D
cvQueryHistValue_3D
cvQueryHistValue_nD
cvRNG
cvRandArr
cvRandInt
cvRandReal
cvRandShuffle
cvRange
cvRead
cvReadByName
cvReadChainPoint
cvReadInt
cvReadIntByName
cvReadRawData
cvReadRawDataSlice
cvReadReal
cvReadRealByName
cvReadString
cvReadStringByName
cvRectangle
cvRedirectError
cvReduce
cvRegisterModule
cvRegisterType
cvRelease
cvReleaseCapture
cvReleaseConDensation
cvReleaseData
cvReleaseFileStorage
cvReleaseGraphScanner
cvReleaseHaarClassifierCascade
cvReleaseHist
cvReleaseImage
cvReleaseImageHeader
cvReleaseKalman
cvReleaseMat
cvReleaseMatND
cvReleaseMemStorage
cvReleasePOSITObject
cvReleaseSparseMat
cvReleaseStructuringElement
cvReleaseVideoWriter
cvRemap
cvRemoveNodeFromTree
cvRepeat
cvResetImageROI
cvReshape
cvReshapeMatND
cvResize
cvResizeWindow
cvRestoreMemStoragePos
cvRetrieveFrame
cvRodrigues2
cvRound
cvRunHaarClassifierCascade
cvRunningAvg
cvSVBkSb
cvSVD
cvSampleLine
cvSave
cvSaveImage
cvSaveMemStoragePos
cvScale
cvScaleAdd
cvSegmentMotion
cvSeqElemIdx
cvSeqInsert
cvSeqInsertSlice
cvSeqInvert
cvSeqPartition
cvSeqPop
cvSeqPopFront
cvSeqPopMulti
cvSeqPush
cvSeqPushFront
cvSeqPushMulti
cvSeqRemove
cvSeqRemoveSlice
cvSeqSearch
cvSeqSlice
cvSeqSort
cvSet
cvSet1D
cvSet2D
cvSet3D
cvSetND
cvSetAdd
cvSetCaptureProperty
cvSetData
cvSetErrMode
cvSetErrStatus
cvSetHistBinRanges
cvSetIPLAllocators
cvSetIdentity
cvSetImageCOI
cvSetImageROI
cvSetImagesForHaarClassifierCascade
cvSetMemoryManager
cvSetMouseCallback
cvSetNew
cvSetNumThreads
cvSetReal1D
cvSetReal2D
cvSetReal3D
cvSetRealND
cvSetRemove
cvSetRemoveByPtr
cvSetSeqBlockSize
cvSetSeqReaderPos
cvSetTrackbarPos
cvSetZero
cvShowImage
cvSmooth
cvSnakeImage
cvSobel
cvSolveCubic
cvSplit
cvSqrt
cvSquareAcc
cvStartAppendToSeq
cvStartFindContours
cvStartNextStream
cvStartReadChainPoints
cvStartReadRawData
cvStartReadSeq
cvStartWriteSeq
cvStartWriteStruct
cvStdErrReport
cvSub
cvSubRS
cvSubS
cvSubdiv2DEdgeDst
cvSubdiv2DEdgeOrg
cvSubdiv2DGetEdge
cvSubdiv2DLocate
cvSubdiv2DRotateEdge
cvSubdivDelaunay2DInsert
cvSubstituteContour
cvSum
cvThreshHist
cvThreshold
cvTrace
cvTransform
cvTranspose
cvTreeToNodeSeq
cvTypeOf
cvUndistort2
cvUnregisterType
cvUpdateMotionHistory
cvUseOptimized
cvWaitKey
cvWarpAffine
cvWarpPerspective
cvWatershed
cvWrite
cvWriteComment
cvWriteFileNode
cvWriteFrame
cvWriteInt
cvWriteRawData
cvWriteReal
cvWriteString
cvXor
cvXorS
cvmGet
cvmSet
error_handling_sample
error_macros