wode0239

CV 参考手册

HUNNISH 注：
本翻译是直接根据 OpenCV Beta 4.0 版本的用户手册翻译的，原文件是：
/doc/ref/opencvref_cv.htm, 可以从 SOURCEFORG 上面的
OpenCV 项目下载，也可以直接从阿须数码中下载：
http://www.assuredigit.com/incoming/sourcecode/opencv/chinese_docs/ref/open
cvref_cv.htm。
翻译中肯定有不少错误，另外也有些术语和原文语义理解不透导致翻译不准确或者错
误，也请有心人赐教。
图像处理、结构分析、运动分析和对象跟踪部分由 R.Z.LIU 翻译，模式识别、照相机定
标与三维重建部分由 H.M.ZHANG 翻译，全文由 Y.C.WEI 统一修改校正。

• 图像处理
o 梯度, 边缘和角点
o 采样差值和几何变换
o 形态学操作
o 滤波和彩色变换
o 金字塔及其应用
o 连接组件
o 图像和轮廓矩
o 特殊图像变换
o 直方图
o 匹配
• 结构分析
o 轮廓处理
o 计算几何
o 平面划分
• 运动分析和对象跟踪
o 背景统计量的累积
o 运动模板
o 对象跟踪
o 光流
o 预估器
• 模式识别
o 目标检测
• 照相机定标和三维重建
o 照相机定标
o 姿态估计
o 极线几何
• 函数列表
• 参考

图像处理
注意:
本章描述图像处理和分析的一些函数。其中大多数函数都是针对两维象素数组的，这里，
我们称这些数组为“图像”，但是它们不一定非得是 IplImage 结构，也可以是 CvMat
或者 CvMatND 结构。

梯度、边缘和角点

Sobel
使用扩展
Sobel
算子计算一阶、二阶、三阶或混合图像差分

void cvSobel( const CvArr* src, CvArr* dst, int xorder, int yorder, int
aperture_size=3 );
src
输入图像.
dst
输出图像.
xorder
x 方向上的差分阶数
yorder
y 方向上的差分阶数
aperture_size
扩展 Sobel 核的大小，必须是 1, 3, 5 或 7。除了尺寸为 1，其它情况下， aperture_size
×aperture_size 可分离内核将用来计算差分。对 aperture_size=1 的情况，使用 3x1 或 1x3
内核（不进行高斯平滑操作）。这里有一个特殊变量 CV_SCHARR (=-1)，对应 3x3 Scharr
滤波器，可以给出比 3x3 Sobel 滤波更精确的结果。Scharr 滤波器系数是：
| -3 0 3|
|-10 0 10|
| -3 0 3|
对 x-方向以及转置矩阵对 y-方向。
函数 cvSobel 通过对图像用相应的内核进行卷积操作来计算图像差分：
dst(x,y) = d xorder+yoder src/dx xorder •dy yorder | (x,y)
由于 Sobel 算子结合了 Gaussian 平滑和微分，所以，其结果或多或少对噪声有一定的鲁棒性。通
常情况，函数调用采用如下参数 (xorder=1, yorder=0, aperture_size=3) 或 (xorder=0, yorder=1,
aperture_size=3) 来计算一阶 x- 或 y- 方向的图像差分。第一种情况对应：
|-1 0 1|
|-2 0 2|
|-1 0 1|
核。第二种对应
|-1 -2 -1|
| 0 0 0|
| 1 2 1|
or
| 1 2 1|
| 0 0 0|
|-1 -2 -1|
核的选则依赖于图像原点的定义 (origin 来自 IplImage 结构的定义)。由于该函数不进行图像尺
度变换，所以和输入图像(数组)相比，输出图像(数组)的元素通常具有更大的绝对数值（译者注：即
象素的深度）。为防止溢出，当输入图像是 8 位的，要求输出图像是 16 位的。当然可以用函数函
数 cvConvertScale 或 cvConvertScaleAbs 转换为 8 位的。除了 8-比特图像，函数也接受 32-位浮
点数图像。所有输入和输出图像都必须是单通道的，并且具有相同的图像尺寸或者 ROI 尺寸。

Laplace
计算图像的
Laplacian
变换

void cvLaplace( const CvArr* src, CvArr* dst, int aperture_size=3 );
src
输入图像.
dst
输出图像.
aperture_size
核大小 (与 cvSobel 中定义一样).
函数 cvLaplace 计算输入图像的 Laplacian 变换，方法是先用 sobel 算子计算二阶
x- 和 y- 差分，再求和:
dst(x,y) = d 2 src/dx 2 + d 2 src/dy 2
对 aperture_size=1 则给出最快计算结果，相当于对图像采用如下内核做卷积：
|0 1 0|
|1 -4 1|
|0 1 0|
类似于 cvSobel 函数，该函数也不作图像的尺度变换，所支持的输入、输出图像类型
的组合和 cvSobel 一致。

Canny
采用
Canny
算法做边缘检测

void cvCanny( const CvArr* image, CvArr* edges, double threshold1,
double threshold2, int aperture_size=3 );
image
输入图像.
edges
输出的边缘图像
threshold1
第一个阈值
threshold2
第二个阈值
aperture_size
Sobel 算子内核大小 (见 cvSobel).
函数 cvCanny 采用 CANNY 算法发现输入图像的边缘而且在输出图像中标识这些边缘。
threshold1 和 threshold2 当中的小阈值用来控制边缘连接，大的阈值用来控制强边缘
的初始分割。

PreCornerDetect
计算用于角点检测的特征图，

void cvPreCornerDetect( const CvArr* image, CvArr* corners, int
aperture_size=3 );
image
输入图像.
corners
保存候选角点的特征图
aperture_size
Sobel 算子的核大小(见 cvSobel).
函数 cvPreCornerDetect 计算函数 D x
2 D yy +D y
2 D xx - 2D x D y D xy 其中 D ? 表示一阶图像差分，
D ?? 表示二阶图像差分。角点被认为是函数的局部最大值：
// 假设图像格式为浮点数
IplImage* corners = cvCloneImage(image);
IplImage* dilated_corners = cvCloneImage(image);
IplImage* corner_mask = cvCreateImage( cvGetSize(image), 8, 1 );
cvPreCornerDetect( image, corners, 3 );
cvDilate( corners, dilated_corners, 0, 1 );
cvSubS( corners, dilated_corners, corners );
cvCmpS( corners, 0, corner_mask, CV_CMP_GE );
cvReleaseImage( &corners );
cvReleaseImage( &dilated_corners );

CornerEigenValsAndVecs
计算图像块的特征值和特征向量，用于角点检测

void cvCornerEigenValsAndVecs( const CvArr* image, CvArr* eigenvv,
int block_size, int aperture_size=3 );
image
输入图像.
eigenvv
保存结果的数组。必须比输入图像宽 6 倍。
block_size
邻域大小 (见讨论).
aperture_size
Sobel 算子的核尺寸(见 cvSobel).
对每个象素，函数 cvCornerEigenValsAndVecs 考虑 block_size × block_size 大小
的邻域 S(p)，然后在邻域上计算图像差分的相关矩阵：
| sum S(p) (dI/dx) 2 sum S(p) (dI/dx•dI/dy)|
M = | |
| sum S(p) (dI/dx•dI/dy) sum S(p) (dI/dy) 2 |
然后它计算矩阵的特征值和特征向量，并且按如下方式(λ 1 , λ 2 , x 1 , y 1 , x 2 , y 2 )存储
这些值到输出图像中，其中

λ 1 , λ 2 - M 的特征值，没有排序
(x 1 , y 1 ) - 特征向量，对 λ 1
(x 2 , y 2 ) - 特征向量，对 λ 2

CornerMinEigenVal
计算梯度矩阵的最小特征值，用于角点检测

void cvCornerMinEigenVal( const CvArr* image, CvArr* eigenval, int block_size,
int aperture_size=3 );
image
输入图像.
eigenval
保存最小特征值的图像. 与输入图像大小一致
block_size
邻域大小 (见讨论 cvCornerEigenValsAndVecs).
aperture_size
Sobel 算子的核尺寸(见 cvSobel). 当输入图像是浮点数格式时，该参数表示用来计算差分固
定的浮点滤波器的个数.
函数 cvCornerMinEigenVal 与 cvCornerEigenValsAndVecs 类似，但是它仅仅计算和
存储每个象素点差分相关矩阵的最小特征值，即前一个函数的 min(λ 1 , λ 2 )

FindCornerSubPix
精确角点位置

void cvFindCornerSubPix( const CvArr* image, CvPoint2D32f* corners,
int count, CvSize win, CvSize zero_zone,
CvTermCriteria criteria );
image
输入图像.
corners
输入角点的初始坐标，也存储精确的输出坐标
count
角点数目
win
搜索窗口的一半尺寸。如果 win=(5,5) 那么使用 5*2+1 × 5*2+1 = 11 × 11 大小的搜索窗口
zero_zone
死区的一半尺寸，死区为不对搜索区的中央位置做求和运算的区域。它是用来避免自相关矩
阵出现的某些可能的奇异性。当值为 (-1,-1) 表示没有死区。
criteria
求角点的迭代过程的终止条件。即角点位置的确定，要么迭代数大于某个设定值，或者是精
确度达到某个设定值。 criteria 可以是最大迭代数目，或者是设定的精确度，也可以是
它们的组合。
函数 cvFindCornerSubPix 通过迭代来发现具有子象素精度的角点位置，或如图所示的
放射鞍点（radial saddle points）。

子象素级角点定位的实现是基于对向量正交性的观测而实现的，即从中央点 q 到其邻域
点 p 的向量和 p 点处的图像梯度正交（服从图像和测量噪声）。考虑以下的表达式：
ε i =DI pi
T •(q-p i )
其中，DI pi 表示在 q 的一个邻域点 p i 处的图像梯度，q 的值通过最小化 ε i 得到。通过将 ε i 设为 0，
可以建立系统方程如下：
sum i (DI pi •DI pi
T )•q - sum i (DI pi •DI pi
T •p i ) = 0
其中 q 的邻域（搜索窗）中的梯度被累加。调用第一个梯度参数 G 和第二个梯度参数 b，
得到：
q=G -1 •b
该算法将搜索窗的中心设为新的中心 q，然后迭代，直到找到低于某个阈值点的中心位
置。

GoodFeaturesToTrack
确定图像的强角点

void cvGoodFeaturesToTrack( const CvArr* image, CvArr* eig_image, CvArr*
temp_image,
CvPoint2D32f* corners, int* corner_count,
double quality_level, double min_distance,
const CvArr* mask=NULL );
image
输入图像，8-位或浮点 32-比特，单通道
eig_image
临时浮点 32-位图像，尺寸与输入图像一致
temp_image
另外一个临时图像，格式与尺寸与 eig_image 一致
corners
输出参数，检测到的角点
corner_count
输出参数，检测到的角点数目
quality_level
最大最小特征值的乘法因子。定义可接受图像角点的最小质量因子。
min_distance
限制因子。得到的角点的最小距离。使用 Euclidian 距离
mask
ROI:感兴趣区域。函数在 ROI 中计算角点，如果 mask 为 NULL，则选择整个图像。
函数 cvGoodFeaturesToTrack 在图像中寻找具有大特征值的角点。该函数，首先用
cvCornerMinEigenVal 计算输入图像的每一个象素点的最小特征值，并将结果存储到变
量 eig_image 中。然后进行非最大值抑制（仅保留 3x3 邻域中的局部最大值）。下一
步将最小特征值小于 quality_level•max(eig_image(x,y)) 排除掉。最后，函数确保
所有发现的角点之间具有足够的距离，（最强的角点第一个保留，然后检查新的角点与
已有角点之间的距离大于 min_distance ）。

采样、差值和几何变换

InitLineIterator
初始化线段迭代器

int cvInitLineIterator( const CvArr* image, CvPoint pt1, CvPoint pt2,
CvLineIterator* line_iterator, int connectivity=8 );
image
带采线段的输入图像.
pt1
线段起始点
pt2
线段结束点
line_iterator
指向线段迭代器状态结构的指针
connectivity
被扫描线段的连通数，4 或 8.
函数 cvInitLineIterator 初始化线段迭代器，并返回两点之间的象素点数目。两个点
必须在图像内。当迭代器初始化后，连接两点的光栅线上所有点，都可以连续通过调用
CV_NEXT_LINE_POINT 来得到。线段上的点是使用 4－连通或 8－连通利用 Bresenham
算法逐点计算的。
例子：使用线段迭代器计算彩色线上象素值的和
CvScalar sum_line_pixels( IplImage* image, CvPoint pt1, CvPoint pt2 )
{
CvLineIterator iterator;
int blue_sum = 0, green_sum = 0, red_sum = 0;
int count = cvInitLineIterator( image, pt1, pt2, &iterator, 8 );

for( int i = 0; i < count; i++ ){
blue_sum += iterator.ptr[0];
green_sum += iterator.ptr[1];
red_sum += iterator.ptr[2];
CV_NEXT_LINE_POINT(iterator);

/* print the pixel coordinates: demonstrates how to calculate the
coordinates */
{
int offset, x, y;
/* assume that ROI is not set, otherwise need to take it into account.
*/
offset = iterator.ptr - (uchar*)(image->imageData);
y = offset/image->widthStep;
x = (offset - y*image->widthStep)/(3*sizeof(uchar) /* size of pixel
*/);
printf("(%d,%d)\n", x, y );
}
}
return cvScalar( blue_sum, green_sum, red_sum );
}

SampleLine
将光栅线读入缓冲区

int cvSampleLine( const CvArr* image, CvPoint pt1, CvPoint pt2,
void* buffer, int connectivity=8 );
image
带采线段的输入图像
pt1
起点
pt2
终点
buffer
存储线段点的缓存区，必须有足够大小来存储点 max( |pt2.x-pt1.x|+1,
|pt2.y-pt1.y|+1 ) ：8－连通情况下，或者 |pt2.x-pt1.x|+|pt2.y-pt1.y|+1 ： 4－连通
情况下.
connectivity
线段的连通方式, 4 or 8.
函数 cvSampleLine 实现了线段迭代器的一个特殊应用。它读取由两点 pt1 和 pt2 确
定的线段上的所有图像点，包括终点，并存储到缓存中。

GetRectSubPix
从图像中提取象素矩形，使用子象素精度

void cvGetRectSubPix( const CvArr* src, CvArr* dst, CvPoint2D32f center );
src
输入图像.
dst
提取的矩形.
center
提取的象素矩形的中心，浮点数坐标。中心必须位于图像内部.
函数 cvGetRectSubPix 从图像 src 中提取矩形:
dst(x, y) = src(x + center.x - (width(dst)-1)*0.5, y + center.y -
(height(dst)-1)*0.5)
其中非整数象素点坐标采用双线性差值提取。对多通道图像，每个通道独立单独完成提
取。尽管函数要求矩形的中心一定要在输入图像之中，但是有可能出现矩形的一部分超
出图像边界的情况，这时，该函数复制边界的模识（hunnish:即用于矩形相交的图像边
界线段的象素来代替矩形超越部分的象素）。

GetQuadrangleSubPix
提取象素四边形，使用子象素精度

void cvGetQuadrangleSubPix( const CvArr* src, CvArr* dst, const CvMat*
map_matrix,
int fill_outliers=0, CvScalar
fill_value=cvScalarAll(0) );
src
输入图像.
dst
提取的四边形.
map_matrix
3 × 2 变换矩阵 [A|b] （见讨论）.
fill_outliers
该标志位指定是否对原始图像边界外面的象素点使用复制模式(fill_outliers=0)进行差
值或者将其设置为指定值(fill_outliers=1)。
fill_value
对超出图像边界的矩形象素设定的值(当 fill_outliers=1 时的情况).
函数 cvGetQuadrangleSubPix 以子象素精度从图像 src 中提取四边形，使用子象素精
度，并且将结果存储于 dst ,计算公式是：
dst(x+width(dst)/2, y+height(dst)/2)= src( A 11 x+A 12 y+b 1 , A 21 x+A 22 y+b 2 ),

w 其中 A 和 b 均来自映射矩阵(译者注：A, b 为几何形变参数) map_matrix
| A 11 A 12 b 1 |
map_matrix = | |
| A 21 A 22 b 2 |
其中在非整数坐标 A•(x,y) T +b 的象素点值通过双线性变换得到。多通道图像的每一个
通道都单独计算.
例子：使用 cvGetQuadrangleSubPix 进行图像旋转
#include "cv.h"
#include "highgui.h"
#include "math.h"

int main( int argc, char** argv )
{
IplImage* src;
/* the first command line parameter must be image file name */
if( argc==2 && (src = cvLoadImage(argv[1], -1))!=0)
{
IplImage* dst = cvCloneImage( src );
int delta = 1;
int angle = 0;

cvNamedWindow( "src", 1 );
cvShowImage( "src", src );

for(;;)
{
float m[6];
double factor = (cos(angle*CV_PI/180.) + 1.1)*3;
CvMat M = cvMat( 2, 3, CV_32F, m );
int w = src->width;
int h = src->height;

m[0] = (float)(factor*cos(-angle*2*CV_PI/180.));
m[1] = (float)(factor*sin(-angle*2*CV_PI/180.));
m[2] = w*0.5f;
m[3] = -m[1];
m[4] = m[0];
m[5] = h*0.5f;

cvGetQuadrangleSubPix( src, dst, &M, 1, cvScalarAll(0));

cvNamedWindow( "dst", 1 );
cvShowImage( "dst", dst );

if( cvWaitKey(5) == 27 )
break;

angle = (angle + delta) % 360;
}
}
return 0;
}

Resize
图像大小变换

void cvResize( const CvArr* src, CvArr* dst, int
interpolation=CV_INTER_LINEAR );
src
输入图像.
dst
输出图像.
interpolation
差值方法:
• CV_INTER_NN - 最近邻差值,
• CV_INTER_LINEAR - 双线性差值 (缺省使用)
• CV_INTER_AREA - 使用象素关系重采样。当图像缩小时候，该方法可以避免波纹出
现。当图像放大时，类似于 CV_INTER_NN 方法..
• CV_INTER_CUBIC - 立方差值.
函数 cvResize 将图像 src 改变尺寸得到与 dst 同样大小。若设定 ROI，函数将按常
规支持 ROI.

WarpAffine
对图像做仿射变换

void cvWarpAffine( const CvArr* src, CvArr* dst, const CvMat* map_matrix,
int flags=CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS,
CvScalar fillval=cvScalarAll(0) );
src
输入图像.
dst
输出图像.
map_matrix
2×3 变换矩阵
flags
插值方法和以下开关选项的组合：
• CV_WARP_FILL_OUTLIERS - 填充所有缩小图像的象素。如果部分象素落在输入图
像的边界外，那么它们的值设定为 fillval.
• CV_WARP_INVERSE_MAP - 指定 matrix 是输出图像到输入图像的反变换，因此可
以直接用来做象素差值。否则, 函数从 map_matrix 得到反变换。
fillval
用来填充边界外面的值
函数 cvWarpAffine 利用下面指定的矩阵变换输入图像：
dst(x',y')<-src(x,y)
如果没有指定 CV_WARP_INVERSE_MAP ， (x',y') T =map_matrix•(x,y,1) T +b ,
否则， (x, y) T =map_matrix•(x',y&apos,1) T +b
函数与 cvGetQuadrangleSubPix 类似，但是不完全相同。 cvWarpAffine 要求输入和
输出图像具有同样的数据类型，有更大的资源开销（因此对小图像不太合适）而且输出
图像的部分可以保留不变。而 cvGetQuadrangleSubPix 可以精确地从 8 位图像中提取
四边形到浮点数缓存区中，具有比较小的系统开销，而且总是全部改变输出图像的内容。
要变换稀疏矩阵，使用 cxcore 中的函数 cvTransform 。

2DRotationMatrix
计算二维旋转的仿射变换矩阵

CvMat* cv2DRotationMatrix( CvPoint2D32f center, double angle,
double scale, CvMat* map_matrix );
center
输入图像的旋转中心坐标
angle
旋转角度（度）。正值表示逆时针旋转(坐标原点假设在左上角).
scale
各项同性的尺度因子
map_matrix
输出 2×3 矩阵的指针
函数 cv2DRotationMatrix 计算矩阵:
[ α β | (1-α)*center.x - β*center.y ]
[ -β α | β*center.x + (1-α)*center.y ]

where α=scale*cos(angle), β=scale*sin(angle)
该变换并不改变原始旋转中心点的坐标，如果这不是操作目的，则可以通过调整平移量
改变其坐标(译者注：通过简单的推导可知，放射变换的实现是首先将旋转中心置为坐
标原点，再进行旋转和尺度变换，最后重新将坐标原点设定为输入图像的左上角，这里
的平移量是 center.x, center.y).

WarpPerspective
对图像进行透视变换

void cvWarpPerspective( const CvArr* src, CvArr* dst, const CvMat* map_matrix,
int flags=CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS,
CvScalar fillval=cvScalarAll(0) );
src
输入图像.
dst
输出图像.
map_matrix
3×3 变换矩阵
flags
插值方法和以下开关选项的组合:
• CV_WARP_FILL_OUTLIERS - 填充所有缩小图像的象素。如果部分象素落在输入图
像的边界外，那么它们的值设定为 fillval.
• CV_WARP_INVERSE_MAP - 指定 matrix 是输出图像到输入图像的反变换，因此可
以直接用来做象素差值。否则, 函数从 map_matrix 得到反变换。
fillval
用来填充边界外面的值
函数 cvWarpPerspective 利用下面指定矩阵变换输入图像：
dst(x',y')<-src(x,y)
若指定 CV_WARP_INVERSE_MAP， (tx',ty',t) T =map_matrix•(x,y,1) T +b
否则， (tx, ty, t) T =map_matrix•(x',y&apos,1) T +b
要变换稀疏矩阵，使用 cxcore 中的函数 cvTransform 。

WarpPerspectiveQMatrix
用
4个对应点计算透视变换矩阵

CvMat* cvWarpPerspectiveQMatrix( const CvPoint2D32f* src,
const CvPoint2D32f* dst,
CvMat* map_matrix );
src
输入图像的四边形的 4 个点坐标
dst
输出图像的对应四边形的 4 个点坐标
map_matrix
输出的 3×3 矩阵
函数 cvWarpPerspectiveQMatrix 计算透视变换矩阵，使得：
(t i x' i ,t i y' i ,t i ) T =matrix•(x i ,y i ,1) T
其中 dst(i)=(x' i ,y' i ), src(i)=(x i ,y i ), i=0..3.

形态学操作

CreateStructuringElementEx
创建结构元素

IplConvKernel* cvCreateStructuringElementEx( int cols, int rows, int anchor_x,
int anchor_y,
int shape, int* values=NULL );
cols
结构元素的列数目
rows
结构元素的行数目
anchor_x
锚点的相对水平偏移量
anchor_y
锚点的相对垂直便宜量
shape
结构元素的形状，可以是下列值：
• CV_SHAPE_RECT, 长方形元素;
• CV_SHAPE_CROSS, 交错元素 a cross-shaped element;
• CV_SHAPE_ELLIPSE, 椭圆元素;
• CV_SHAPE_CUSTOM, 用户自定义元素。这种情况下参数 values 定义了 mask,即象素
的那个邻域必须考虑。
values
指向结构元素的指针，它是一个平面数组，表示对元素矩阵逐行扫描。(非零点表示该点属
于结构元)。如果指针为空，则表示平面数组中的所有元素都是非零的，即结构元是一个长
方形(该参数仅仅当 shape 参数是 CV_SHAPE_CUSTOM 时才予以考虑)。
函数 cv CreateStructuringElementEx 分配和填充结构 IplConvKernel, 它可作为形
态操作中的结构元素。

ReleaseStructuringElement
删除结构元素

void cvReleaseStructuringElement( IplConvKernel** element );
element
被删除的结构元素的指针
函数 cvReleaseStructuringElement 释放结构 IplConvKernel 。如果 *element 为
NULL, 则函数不作用。

Erode
使用任意结构元素腐蚀图像

void cvErode( const CvArr* src, CvArr* dst, IplConvKernel* element=NULL, int
iterations=1 );
src
输入图像.
dst
输出图像.
element
用于腐蚀的结构元素。若为 NULL, 则使用 3×3 长方形的结构元素
iterations
腐蚀的次数
函数 cvErode 对输入图像使用指定的结构元素进行腐蚀，该结构元素决定每个具有最
小值象素点的邻域形状：
dst=erode(src,element): dst(x,y)=min ((x',y') in element) )src(x+x',y+y')
函数可能是本地操作，不需另外开辟存储空间的意思。腐蚀可以重复进行 (iterations)
次. 对彩色图像，每个彩色通道单独处理。

Dilate
使用任意结构元素膨胀图像

void cvDilate( const CvArr* src, CvArr* dst, IplConvKernel* element=NULL, int
iterations=1 );
src
输入图像.
dst
输出图像.
element
用于膨胀的结构元素。若为 NULL, 则使用 3×3 长方形的结构元素
iterations
膨胀的次数
函数 cvDilate 对输入图像使用指定的结构元进行膨胀，该结构决定每个具有最小值象
素点的邻域形状：
dst=dilate(src,element): dst(x,y)=max ((x',y') in element) )src(x+x',y+y')
函数支持（in-place）模式。膨胀可以重复进行 (iterations) 次. 对彩色图像，每个
彩色通道单独处理。

MorphologyEx
高级形态学变换

void cvMorphologyEx( const CvArr* src, CvArr* dst, CvArr* temp,
IplConvKernel* element, int operation, int
iterations=1 );
src
输入图像.
dst
输出图像.
temp
临时图像，某些情况下需要
element
结构元素
operation
形态操作的类型:
CV_MOP_OPEN - 开运算
CV_MOP_CLOSE - 闭运算
CV_MOP_GRADIENT - 形态梯度
CV_MOP_TOPHAT - "顶帽"
CV_MOP_BLACKHAT - "黑帽"
iterations
膨胀和腐蚀次数.
函数 cvMorphologyEx 在膨胀和腐蚀基本操作的基础上，完成一些高级的形态变换：
开运算:
dst=open(src,element)=dilate(erode(src,element),element)

闭运算:
dst=close(src,element)=erode(dilate(src,element),element)

形态梯度
dst=morph_grad(src,element)=dilate(src,element)-erode(src,element)

"顶帽":
dst=tophat(src,element)=src-open(src,element)

"黑帽":
dst=blackhat(src,element)=close(src,element)-src
临时图像 temp 在形态梯度以及对“顶帽”和“黑帽”操作时的 in-place 模式下需
要。

滤波器与彩色变换

Smooth
各种方法的图像平滑

void cvSmooth( const CvArr* src, CvArr* dst,
int smoothtype=CV_GAUSSIAN,
int param1=3, int param2=0, double param3=0 );
src
输入图像.
dst
输出图像.
smoothtype
平滑方法:
• CV_BLUR_NO_SCALE (简单不带尺度变换的模糊) - 对每个象素的 param1×param2
领域求和。如果邻域大小是变化的，可以事先利用函数 cvIntegral 计算积分图像。
• CV_BLUR (simple blur) - 对每个象素 param1×param2 邻域求和并做尺度变换
1/(param1•param2).
• CV_GAUSSIAN (gaussian blur) - 对图像进行核大小为 param1×param2 的高斯卷积
• CV_MEDIAN (median blur) - 对图像进行核大小为 param1×param1 的中值滤波 (i.e.
邻域是方的).
• CV_BILATERAL (双向滤波) - 应用双向 3x3 滤波，彩色 sigma=param1，空间
sigma=param2. 关于双向滤波，可参考
http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.ht
ml
param1
平滑操作的第一个参数.
param2
平滑操作的第二个参数. 对于简单/非尺度变换的高斯模糊的情况，如果 param2 的值为零，
则表示其被设定为 param1。
param3
对应高斯参数的 Gaussian sigma (标准差). 如果为零，则标准差由下面的核尺寸计算：
sigma = (n/2 - 1)*0.3 + 0.8, 其中 n=param1 对应水平核,
n=param2 对应垂直核.

对小的卷积核 (3×3 to 7×7) 使用如上公式所示的标准 sigma 速度会快。如果 param3 不为
零，而 param1 和 param2 为零，则核大小有 sigma 计算 (以保证足够精确的操作).
函数 cvSmooth 可使用上面任何一种方法平滑图像。每一种方法都有自己的特点以及局
限。
没有缩放的图像平滑仅支持单通道图像，并且支持 8 位到 16 位的转换(与 cvSobel 和
cvaplace 相似)和 32 位浮点数到 32 位浮点数的变换格式。
简单模糊和高斯模糊支持 1- 或 3-通道, 8-比特和 32-比特浮点图像。这两种方法
可以（in-place）方式处理图像。
中值和双向滤波工作于 1- 或 3-通道， 8-位图像，但是不能以 in-place 方式处理图
像.

Filter2D
对图像做卷积

void cvFilter2D( const CvArr* src, CvArr* dst,
const CvMat* kernel,
CvPoint anchor=cvPoint(-1,-1));
#define cvConvolve2D cvFilter2D
src
输入图像.
dst
输出图像.
kernel
卷积核, 单通道浮点矩阵. 如果想要应用不同的核于不同的通道，先用 cvSplit 函数分解图
像到单个色彩通道上，然后单独处理。
anchor
核的锚点表示一个被滤波的点在核内的位置。锚点应该处于核内部。缺省值 (-1,-1) 表示锚
点在核中心。
函数 cvFilter2D 对图像进行线性滤波，支持 In-place 操作。当核运算部分超出输入
图像时，函数从最近邻的图像内部象素差值得到边界外面的象素值。

Integral
计算积分图像

void cvIntegral( const CvArr* image, CvArr* sum, CvArr* sqsum=NULL, CvArr*
tilted_sum=NULL );
image
输入图像, W×H, 单通道，8 位或浮点 (32f 或 64f).
sum
积分图像, W+1×H+1(译者注：原文的公式应该写成(W+1)×(H+1),避免误会), 单通道，
32 位整数或 double 精度的浮点数(64f).
sqsum
对象素值平方的积分图像，W+1×H+1(译者注：原文的公式应该写成(W+1)×(H+1),避
免误会), 单通道，32 位整数或 double 精度的浮点数 (64f).
tilted_sum
旋转 45 度的积分图像，单通道，32 位整数或 double 精度的浮点数 (64f).
函数 cvIntegral 计算一次或高次积分图像：
sum(X,Y)=sum x
sqsum(X,Y)=sum x
tilted_sum(X,Y)=sum y 利用积分图像，可以计算在某象素的上－右方的或者旋转的矩形区域中进行求和、求均
值以及标准方差的计算，并且保证运算的复杂度为 O(1)。例如：

sum x1<=x 因此可以在变化的窗口内做快速平滑或窗口相关等操作。

CvtColor
色彩空间转换

void cvCvtColor( const CvArr* src, CvArr* dst, int code );
src
输入的 8-比特或浮点图像.
dst
输出的 8-比特或浮点图像.
code
色彩空间转换，通过定义 CV_2 常数 (见下面).
函数 cvCvtColor 将输入图像从一个色彩空间转换为另外一个色彩空间。函数忽略
IplImage 头中定义的 colorModel 和 channelSeq 域，所以输入图像的色彩空间应该
正确指定 (包括通道的顺序，对 RGB 空间而言，BGR 意味着布局为 B 0 G 0 R 0 B 1 G 1 R 1 ...
层叠的 24-位格式，而 RGB 意味着布局为 R 0 G 0 B 0 R 1 G 1 B 1 ... 层叠的 24-位格式. 函
数做如下变换：
• RGB 空间内部的变换，如增加/删除 alpha 通道，反相通道顺序，到 16 位 RGB 彩色或者
15 位 RGB 彩色的正逆转换(Rx5:Gx6:Rx5),以及到灰度图像的正逆转换，使用：
• RGB[A]->Gray: Y=0.212671*R + 0.715160*G + 0.072169*B + 0*A
• Gray->RGB[A]: R=Y G=Y B=Y A=0
所有可能的图像色彩空间的相互变换公式列举如下：
• RGB<=>XYZ (CV_BGR2XYZ, CV_RGB2XYZ, CV_XYZ2BGR, CV_XYZ2RGB):
• |X| |0.412411 0.357585 0.180454| |R|
• |Y| = |0.212649 0.715169 0.072182|*|G|
• |Z| |0.019332 0.119195 0.950390| |B|
•
• |R| | 3.240479 -1.53715 -0.498535| |X|
• |G| = |-0.969256 1.875991 0.041556|*|Y|
• |B| | 0.055648 -0.204043 1.057311| |Z|
• RGB<=>YCrCb (CV_BGR2YCrCb, CV_RGB2YCrCb, CV_YCrCb2BGR, CV_YCrCb2RGB)
• Y=0.299*R + 0.587*G + 0.114*B
• Cr=(R-Y)*0.713 + 128
• Cb=(B-Y)*0.564 + 128
•
• R=Y + 1.403*(Cr - 128)
• G=Y - 0.344*(Cr - 128) - 0.714*(Cb - 128)
• B=Y + 1.773*(Cb - 128)
• RGB=>HSV (CV_BGR2HSV,CV_RGB2HSV)
• V=max(R,G,B)
• S=(V-min(R,G,B))*255/V if V!=0, 0 otherwise
•
• (G - B)*60/S, if V=R
• H= 180+(B - R)*60/S, if V=G
• 240+(R - G)*60/S, if V=B
•
• if H<0 then H=H+360
使用上面从 0° 到 360° 变化的公式计算色调（hue）值，确保它们被 2 除后
能适用于 8 位。
• RGB=>Lab (CV_BGR2Lab, CV_RGB2Lab)
• |X| |0.433910 0.376220 0.189860| |R/255|
• |Y| = |0.212649 0.715169 0.072182|*|G/255|
• |Z| |0.017756 0.109478 0.872915| |B/255|
•
• L = 116*Y 1/3 for Y>0.008856
• L = 903.3*Y for Y<=0.008856
•
• a = 500*(f(X)-f(Y))
• b = 200*(f(Y)-f(Z))
• where f(t)=t 1/3 for t>0.008856
• f(t)=7.787*t+16/116 for t<=0.008856
上面的公式可以参考 http://www.cica.indiana.edu/cica/faq/color_spaces/color.spaces.html
• Bayer=>RGB (CV_BayerBG2BGR, CV_BayerGB2BGR, CV_BayerRG2BGR,
CV_BayerGR2BGR,
CV_BayerBG2RGB, CV_BayerRG2BGR, CV_BayerGB2RGB, CV_BayerGR2BGR,
CV_BayerRG2RGB, CV_BayerBG2BGR, CV_BayerGR2RGB, CV_BayerGB2BGR)
Bayer 模式被广泛应用于 CCD 和 CMOS 摄像头. 它允许从一个单独平面中得到
彩色图像，该平面中的 R/G/B 象素点被安排如下：
R G R G R
G B G B G
R G R G R
G B G B G
R G R G R
G B G B G
对象素输出的 RGB 分量由该象素的 1、2 或者 4 邻域中具有相同颜色的点插值得
到。以上的模式可以通过向左或者向上平移一个像素点来作一些修改。转换常量
CV_BayerC1C22{RGB|RGB}中的两个字母 C1 和 C2 表示特定的模式类型：颜色分量
分别来自于第二行，第二和第三列。比如说，上述的模式具有很流行的"BG"类型。

Threshold
对数组元素进行固定阈值操作

void cvThreshold( const CvArr* src, CvArr* dst, double threshold,
double max_value, int threshold_type );
src
原始数组 (单通道, 8-比特 of 32-比特浮点数).
dst
输出数组，必须与 src 的类型一致，或者为 8-比特.
threshold
阈值
max_value
使用 CV_THRESH_BINARY 和 CV_THRESH_BINARY_INV 的最大值.
threshold_type
阈值类型 (见讨论)
函数 cvThreshold 对单通道数组应用固定阈值操作。该函数的典型应用是对灰度图像
进行阈值操作得到二值图像。(cvCmpS 也可以达到此目的) 或者是去掉噪声，例如过滤
很小或很大象素值的图像点。本函数支持的对图像取阈值的方法由 threshold_type 确
定:
threshold_type=CV_THRESH_BINARY:
dst(x,y) = max_value, if src(x,y)>threshold
0, otherwise

threshold_type=CV_THRESH_BINARY_INV:
dst(x,y) = 0, if src(x,y)>threshold
max_value, otherwise

threshold_type=CV_THRESH_TRUNC:
dst(x,y) = threshold, if src(x,y)>threshold
src(x,y), otherwise

threshold_type=CV_THRESH_TOZERO:
dst(x,y) = src(x,y), if (x,y)>threshold
0, otherwise

threshold_type=CV_THRESH_TOZERO_INV:
dst(x,y) = 0, if src(x,y)>threshold
src(x,y), otherwise
下面是图形化的阈值描述：

AdaptiveThreshold
自适应阈值方法

void cvAdaptiveThreshold( const CvArr* src, CvArr* dst, double max_value,
int adaptive_method=CV_ADAPTIVE_THRESH_MEAN_C,
int threshold_type=CV_THRESH_BINARY,
int block_size=3, double param1=5 );
src
输入图像.
dst
输出图像.
max_value
使用 CV_THRESH_BINARY 和 CV_THRESH_BINARY_INV 的最大值.
adaptive_method
自适应阈值算法使用： CV_ADAPTIVE_THRESH_MEAN_C 或
CV_ADAPTIVE_THRESH_GAUSSIAN_C （见讨论）.
threshold_type
取阈值类型：必须是下者之一
• CV_THRESH_BINARY,
• CV_THRESH_BINARY_INV
block_size
用来计算阈值的象素邻域大小: 3, 5, 7, ...
param1
与方法有关的参数。对方法 CV_ADAPTIVE_THRESH_MEAN_C 和
CV_ADAPTIVE_THRESH_GAUSSIAN_C，它是一个从均值或加权均值提取的常数（见讨论）,
尽管它可以是负数。
函数 cvAdaptiveThreshold 将灰度图像变换到二值图像，采用下面公式：
threshold_type=CV_THRESH_BINARY:
dst(x,y) = max_value, if src(x,y)>T(x,y)
0, otherwise

threshold_type=CV_THRESH_BINARY_INV:
dst(x,y) = 0, if src(x,y)>T(x,y)
max_value, otherwise
其中 T I 是为每一个象素点单独计算的阈值
对方法 CV_ADAPTIVE_THRESH_MEAN_C，先求出块中的均值，再减掉 param1。
对方法 CV_ADAPTIVE_THRESH_GAUSSIAN_C ，先求出块中的加权和(gaussian)，再减掉
param1。

金字塔及其应用

PyrDown
图像的下采样

void cvPyrDown( const CvArr* src, CvArr* dst, int filter=CV_GAUSSIAN_5x5 );
src
输入图像.
dst
输出图像, 宽度和高度应是输入图像的一半
filter
卷积滤波器的类型，目前仅支持 CV_GAUSSIAN_5x5
函数 cvPyrDown 使用 Gaussian 金字塔分解对输入图像向下采样。首先它对输入图像
用指定滤波器进行卷积，然后通过拒绝偶数的行与列来下采样图像。

PyrUp
图像的上采样

void cvPyrUp( const CvArr* src, CvArr* dst, int filter=CV_GAUSSIAN_5x5 );
src
输入图像.
dst
输出图像, 宽度和高度应是输入图像的 2 倍
filter
卷积滤波器的类型，目前仅支持 CV_GAUSSIAN_5x5
函数 cvPyrUp 使用 Gaussian 金字塔分解对输入图像向上采样。首先通过在图像中插入
0 偶数行和偶数列，然后对得到的图像用指定的滤波器进行高斯卷积，其中滤波器乘以
4 做差值。所以输出图像是输入图像的 4 倍大小。（hunnish: 原理不清楚，尚待探讨）

PyrSegmentation
用金字塔实现图像分割

void cvPyrSegmentation( IplImage* src, IplImage* dst,
CvMemStorage* storage, CvSeq** comp,
int level, double threshold1, double threshold2 );
src
输入图像.
dst
输出图像.
storage
Storage: 存储连通部件的序列结果
comp
分割部件的输出序列指针 components.
level
建立金字塔的最大层数
threshold1
建立连接的错误阈值
threshold2
分割簇的错误阈值
函数 cvPyrSegmentation 实现了金字塔方法的图像分割。金字塔建立到 level 指定的
最大层数。如果 p(c(a),c(b)) 亲象素 b 之间的连接被建立起来，
定义好连接部件后，它们被加入到某些簇中。如果 p(c(A),c(B)) 两个分割 A 和 B 属于同一簇。
如果输入图像只有一个通道，那么
p(c¹,c²)=|c¹-c²|.
如果输入图像有单个通道（红、绿、兰），那么
p(c¹,c²)=0,3·(c¹ r -c² r )+0,59·(c¹ g -c² g )+0,11·(c¹ b -c² b ) .
每一个簇可以有多个连接部件。
图像 src 和 dst 应该是 8-比特、单通道或 3-通道图像，且大小一样

连接部件

CvConnectedComp
连接部件

typedef struct CvConnectedComp
{
double area; /* 连通域的面积 */
float value; /* 分割域的灰度缩放值 */
CvRect rect; /* 分割域的 ROI */
} CvConnectedComp;

FloodFill
用指定颜色填充一个连接域

void cvFloodFill( CvArr* image, CvPoint seed_point, CvScalar new_val,
CvScalar lo_diff=cvScalarAll(0), CvScalar
up_diff=cvScalarAll(0),
CvConnectedComp* comp=NULL, int flags=4, CvArr* mask=NULL );
#define CV_FLOODFILL_FIXED_RANGE (1 << 16)
#define CV_FLOODFILL_MASK_ONLY (1 << 17)
image
输入的 1- 或 3-通道, 8-比特或浮点数图像。输入的图像将被函数的操作所改变，除非你选
则 CV_FLOODFILL_MASK_ONLY 选项 (见下面).
seed_point
开始的种子点.
new_val
新的重新绘制的象素值
lo_diff
当前观察象素值与其部件领域象素或者待加入该部件的种子象素之负差(Lower
difference)的最大值。对 8-比特彩色图像，它是一个 packed value.
up_diff
当前观察象素值与其部件领域象素或者待加入该部件的种子象素之正差(upper difference)的
最大值。对 8-比特彩色图像，它是一个 packed value.
comp
指向部件结构体的指针，该结构体的内容由函数用重绘区域的信息填充。
flags
操作选项. 低位比特包含连通值, 4 (缺省) 或 8, 在函数执行连通过程中确定使用哪种邻域
方式。高位比特可以是 0 或下面的开关选项的组合：
• CV_FLOODFILL_FIXED_RANGE - 如果设置，则考虑当前象素与种子象素之间的差，
否则考虑当前象素与其相邻象素的差。(范围是浮点数).
• CV_FLOODFILL_MASK_ONLY - 如果设置，函数不填充原始图像 (忽略 new_val),
但填充面具图像 (这种情况下 MASK 必须是非空的).
mask
运算面具, 应该是单通道、8-比特图像, 长和宽上都比输入图像 image 大两个象素点。若非
空，则函数使用且更新面具, 所以使用者需对 mask 内容的初始化负责。填充不会经过
MASK 的非零象素, 例如，一个边缘检测子的输出可以用来作为 MASK 来阻止填充边缘。
或者有可能在多次的函数调用中使用同一个 MASK，以保证填充的区域不会重叠。
注意
: 因
为 MASK 比欲填充图像大，所以 mask 中与输入图像(x,y)像素点相对应的点具有
(x+1,y+1)坐标。
函数 cvFloodFill 用指定颜色，从种子点开始填充一个连通域。连通性有象素值的接
近程度来衡量。在点 (x, y) 的象素被认为是属于重新绘制的区域，如果：
src(x',y')-lo_diff<=src(x,y)<=src(x',y')+up_diff, 灰度图像，浮动范围
src(seed.x,seed.y)-lo<=src(x,y)<=src(seed.x,seed.y)+up_diff, 灰度图像，固定
范围

src(x',y') r -lo_diff r <=src(x,y) r <=src(x',y') r +up_diff r 和
src(x',y') g -lo_diff g <=src(x,y) g <=src(x',y') g +up_diff g 和
src(x',y') b -lo_diff b <=src(x,y) b <=src(x',y') b +up_diff b , 彩色图像，浮动范围

src(seed.x,seed.y) r -lo_diff r <=src(x,y) r <=src(seed.x,seed.y) r +up_diff r 和
src(seed.x,seed.y) g -lo_diff g <=src(x,y) g <=src(seed.x,seed.y) g +up_diff g 和
src(seed.x,seed.y) b -lo_diff b <=src(x,y) b <=src(seed.x,seed.y) b +up_diff b , 彩色图
像，固定范围
其中 src(x',y') 是象素邻域点的值。也就是说，为了被加入到连通域中，一个象素的彩色/亮度
应该足够接近于：
• 它的邻域象素的彩色/亮度值，当该邻域点已经被认为属于浮动范围情况下的连通域。
• 固定范围情况下的种子点的彩色/亮度值

FindContours
在二值图像中寻找轮廓

int cvFindContours( CvArr* image, CvMemStorage* storage, CvSeq** first_contour,
int header_size=sizeof(CvContour), int mode=CV_RETR_LIST,
int method=CV_CHAIN_APPROX_SIMPLE, CvPoint
offset=cvPoint(0,0) );
image
输入的 8-比特、单通道图像. 非零元素被当成 1， 0 象素值保留为 0 - 从而图像被看成二
值的。为了从灰度图像中得到这样的二值图像，可以使用 cvThreshold, cvAdaptiveThreshold
或 cvCanny. 本函数改变输入图像内容。
storage
得到的轮廓的存储容器
first_contour
输出参数：包含第一个输出轮廓的指针
header_size
如果 method=CV_CHAIN_CODE ，则序列头的大小 >=sizeof(CvChain) ，否则
>=sizeof(CvContour) .
mode
提取模式.
• CV_RETR_EXTERNAL - 只提取最外层的轮廓
• CV_RETR_LIST - 提取所有轮廓，并且放置在 list 中
• CV_RETR_CCOMP - 提取所有轮廓，并且将其组织为两层的 hierarchy: 顶层为连通域的
外围边界，次层为洞的内层边界。
• CV_RETR_TREE - 提取所有轮廓，并且重构嵌套轮廓的全部 hierarchy
method
逼近方法 (对所有节点, 不包括使用内部逼近的 CV_RETR_RUNS).
• CV_CHAIN_CODE - Freeman 链码的输出轮廓. 其它方法输出多边形(定点序列).
• CV_CHAIN_APPROX_NONE - 将所有点由链码形式翻译为点序列形式
• CV_CHAIN_APPROX_SIMPLE - 压缩水平、垂直和对角分割，即函数只保留末端的象素
点;
• CV_CHAIN_APPROX_TC89_L1,
CV_CHAIN_APPROX_TC89_KCOS - 应用 Teh-Chin 链逼近算法.
• CV_LINK_RUNS - 通过连接为 1 的水平碎片使用完全不同的轮廓提取算法。仅有
CV_RETR_LIST 提取模式可以在本方法中应用.
offset
每一个轮廓点的偏移量. 当轮廓是从图像 ROI 中提取出来的时候，使用偏移量有用，因为
可以从整个图像上下文来对轮廓做分析.
函数 cvFindContours 从二值图像中提取轮廓，并且返回提取轮廓的数目。指针
first_contour 的内容由函数填写。它包含第一个最外层轮廓的指针，如果指针
为 NULL，则没有检测到轮廓（比如图像是全黑的）。其它轮廓可以从
first_contour 利用 h_next 和 v_next 链接访问到。在 cvDrawContours 的
样例显示如何使用轮廓来进行连通域的检测。轮廓也可以用来做形状分析和对象
识别 - 见 CVPR2001 教程中的 squares 样例。该教程可以在 SourceForge 网
站上找到。

StartFindContours
初始化轮廓的扫描过程

CvContourScanner cvStartFindContours( CvArr* image, CvMemStorage*
storage,
int
header_size=sizeof(CvContour),
int mode=CV_RETR_LIST,
int
method=CV_CHAIN_APPROX_SIMPLE,
CvPoint offset=cvPoint(0,0) );
image
输入的 8-比特、单通道二值图像
storage
提取到的轮廓容器
header_size
序列头的尺寸 >=sizeof(CvChain) 若 method=CV_CHAIN_CODE ，否则尺寸
>=sizeof(CvContour) .
mode
提取模式，见 cvFindContours.
method
逼近方法。它与 cvFindContours 里的定义一样，但是 CV_LINK_RUNS 不能使用。
offset
ROI 偏移量，见 cvFindContours.
函数 cvStartFindContours 初始化并且返回轮廓扫描器的指针。扫描器在
cvFindNextContour 使用以提取其余的轮廓。

FindNextContour
Finds next contour in the image
CvSeq* cvFindNextContour( CvContourScanner scanner );
scanner
被函数 cvStartFindContours 初始化的轮廓扫描器.
函数 cvFindNextContour 确定和提取图像的下一个轮廓，并且返回它的指针。
若没有更多的轮廓，则函数返回 NULL.

SubstituteContour
替换提取的轮廓

void cvSubstituteContour( CvContourScanner scanner, CvSeq*
new_contour );
scanner
被函数 cvStartFindContours 初始化的轮廓扫描器 ..
new_contour
替换的轮廓
函数 cvSubstituteContour 把用户自定义的轮廓替换前一次的函数
cvFindNextContour 调用所提取的轮廓，该轮廓以用户定义的模式存储在边缘扫
描状态之中。轮廓，根据提取状态，被插入到生成的结构，List，二层 hierarchy,
或 tree 中。如果参数 new_contour=NULL, 则提取的轮廓不被包含入生成结构
中，它的所有后代以后也不会被加入到接口中。

EndFindContours
结束扫描过程

CvSeq* cvEndFindContours( CvContourScanner* scanner );
scanner
轮廓扫描的指针.
函数 cvEndFindContours 结束扫描过程，并且返回最高层的第一个轮廓的指针。

图像与轮廓矩

Moments
计算多边形和光栅形状的最高达三阶的所有矩

void cvMoments( const CvArr* arr, CvMoments* moments, int binary=0 );
arr
图像 (1-通道或 3-通道，有 ROI 设置) 或多边形(点的 CvSeq 或一族点的向量).
moments
返回的矩状态接口的指针
binary
(仅对图像) 如果标识为非零，则所有零象素点被当成零，其它的被看成 1.
函数 cvMoments 计算最高达三阶的空间和中心矩，并且将结果存在结构
moments 中。矩用来计算形状的重心，面积，主轴和其它的形状特征，如 7 Hu
不变量等。

GetSpatialMoment
从矩状态结构中提取空间矩

double cvGetSpatialMoment( CvMoments* moments, int x_order, int
y_order );
moments
矩状态，由 cvMoments 计算
x_order
提取的 x 次矩, x_order >= 0.
y_order
提取的 y 次矩, y_order >= 0 并且 x_order + y_order <= 3.
函数 cvGetSpatialMoment 提取空间矩，当图像矩被定义为：
M x_order,y_order =sum x,y (I(x,y)•x x_order •y y_order )
其中 I(x,y) 是象素点 (x, y) 的亮度值.

GetCentralMoment
从矩状态结构中提取中心矩

double cvGetCentralMoment( CvMoments* moments, int x_order, int
y_order );
moments
矩状态结构指针
x_order
提取的 x 阶矩, x_order >= 0.
y_order
提取的 y 阶矩， y_order >= 0 且 x_order + y_order <= 3.
函数 cvGetCentralMoment 提取中心矩，其中图像矩的定义是：
μ x_order,y_order =sum x,y (I(x,y)•(x-x c ) x_order •(y-y c ) y_order ),
其中 x c =M 10 /M 00 , y c =M 01 /M 00 - 重心坐标

GetNormalizedCentralMoment
从矩状态结构中提取归一化的中心矩

double cvGetNormalizedCentralMoment( CvMoments* moments, int x_order,
int y_order );
moments
矩状态结构指针
x_order
提取的 x 阶矩, x_order >= 0.
y_order
提取的 y 阶矩， y_order >= 0 且 x_order + y_order <= 3.
函数 cvGetNormalizedCentralMoment 提取归一化中心矩：
η x_order,y_order = μ x_order,y_order /M 00
((y_order+x_order)/2+1)

GetHuMoments
计算
7 Hu
不变量

void cvGetHuMoments( CvMoments* moments, CvHuMoments* hu_moments );
moments
矩状态结构的指针
hu_moments
Hu 矩结构的指针.
函数 cvGetHuMoments 计算 7 个 Hu 不变量，它们的定义是：
h 1 =η 20 +η 02

h 2 =(η 20 -η 02 )²+4η 11 ²

h 3 =(η 30 -3η 12 )²+ (3η 21 -η 03 )²

h 4 =(η 30 +η 12 )²+ (η 21 +η 03 )²

h 5 =(η 30 -3η 12 )(η 30 +η 12 )[(η 30 +η 12 )²-3(η 21 +η 03 )²]+(3η 21 -η 03 )(η 21 +η 03 )[3(
η 30 +η 12 )²-(η 21 +η 03 )²]

h 6 =(η 20 -η 02 )[(η 30 +η 12 )²- (η 21 +η 03 )²]+4η 11 (η 30 +η 12 )(η 21 +η 03 )

h 7 =(3η 21 -η 03 )(η 21 +η 03 )[3(η 30 +η 12 )²-(η 21 +η 03 )²]-(η 30 -3η 12 )(η 21 +η 03 )[3(
η 30 +η 12 )²-(η 21 +η 03 )²]
这些值被证明为对图像缩放、旋转和反射的不变量。对反射，第 7 个除外，因为
它的符合会因为反射而改变。

特殊图像变换

HoughLines
利用
Hough
变换在二值图像中找到直线

CvSeq* cvHoughLines2( CvArr* image, void* line_storage, int method,
double rho, double theta, int threshold,
double param1=0, double param2=0 );
image
输入 8-比特、单通道 (二值) 图像，其内容可能被函数所改变
line_storage
检测到的线段存储仓. 可以是内存存储仓 (此种情况下，一个线段序列在存储仓中被创建，
并且由函数返回），或者是包含线段参数的特殊类型（见下面）的具有单行/单列的矩阵
(CvMat*)。矩阵头为函数所修改，使得它的 cols/rows 将包含一组检测到的线段。如果
line_storage 是矩阵，而实际线段的数目超过矩阵尺寸，那么最大可能数目的线段被返
回(线段没有按照长度、可信度或其它指标排序).
method
Hough 变换变量，是下面变量的其中之一：
• CV_HOUGH_STANDARD - 传统或标准 Hough 变换. 每一个线段由两个浮点数 (ρ, θ)
表示，其中 ρ 是点与原点 (0,0) 之间的距离，θ 线段与 x-轴之间的夹角。因此，矩
阵类型必须是 CV_32FC2 type.
• CV_HOUGH_PROBABILISTIC - 概率 Hough 变换(如果图像包含一些长的线性分割，
则效率更高). 它返回线段分割而不是整个线段。每个分割用起点和终点来表示，所
以矩阵（或创建的序列）类型是 CV_32SC4.
• CV_HOUGH_MULTI_SCALE - 传统 Hough 变换的多尺度变种。线段的编码方式与
CV_HOUGH_STANDARD 的一致。
rho
与象素相关单位的距离精度
theta
弧度测量的角度精度
threshold
阈值参数。如果相应的累计值大于 threshold，则函数返回的这个线段.
param1
第一个方法相关的参数:
• 对传统 Hough 变换，不使用(0).
• 对概率 Hough 变换，它是最小线段长度.
• 对多尺度 Hough 变换，它是距离精度 rho 的分母 (大致的距离精度是 rho 而精确
的应该是 rho / param1 ).
param2
第二个方法相关参数:
• 对传统 Hough 变换，不使用 (0).
• 对概率 Hough 变换，这个参数表示在同一条直线上进行碎线段连接的最大间隔值
(gap), 即当同一条直线上的两条碎线段之间的间隔小于 param2 时，将其合二为一。
• 对多尺度 Hough 变换，它是角度精度 theta 的分母 (大致的角度精度是 theta 而
精确的角度应该是 theta / param2).
函数 cvHoughLines2 实现了用于线段检测的不同 Hough 变换方法.
Example. 用 Hough transform 检测线段
/* This is a standalone program. Pass an image name as a first parameter
of the program.
Switch between standard and probabilistic Hough transform by changing
"#if 1" to "#if 0" and back */
#include
#include
#include

int main(int argc, char** argv)
{
IplImage* src;
if( argc == 2 && (src=cvLoadImage(argv[1], 0))!= 0)
{
IplImage* dst = cvCreateImage( cvGetSize(src), 8, 1 );
IplImage* color_dst = cvCreateImage( cvGetSize(src), 8, 3 );
CvMemStorage* storage = cvCreateMemStorage(0);
CvSeq* lines = 0;
int i;
cvCanny( src, dst, 50, 200, 3 );
cvCvtColor( dst, color_dst, CV_GRAY2BGR );
#if 1
lines = cvHoughLines2( dst, storage, CV_HOUGH_STANDARD, 1,
CV_PI/180, 150, 0, 0 );

for( i = 0; i < lines->total; i++ )
{
float* line = (float*)cvGetSeqElem(lines,i);
float rho = line[0];
float theta = line[1];
CvPoint pt1, pt2;
double a = cos(theta), b = sin(theta);
if( fabs(a) < 0.001 )
{
pt1.x = pt2.x = cvRound(rho);
pt1.y = 0;
pt2.y = color_dst->height;
}
else if( fabs(b) < 0.001 )
{
pt1.y = pt2.y = cvRound(rho);
pt1.x = 0;
pt2.x = color_dst->width;
}
else
{
pt1.x = 0;
pt1.y = cvRound(rho/b);
pt2.x = cvRound(rho/a);
pt2.y = 0;
}
cvLine( color_dst, pt1, pt2, CV_RGB(255,0,0), 3, 8 );
}
#else
lines = cvHoughLines2( dst, storage, CV_HOUGH_PROBABILISTIC, 1,
CV_PI/180, 80, 30, 10 );
for( i = 0; i < lines->total; i++ )
{
CvPoint* line = (CvPoint*)cvGetSeqElem(lines,i);
cvLine( color_dst, line[0], line[1], CV_RGB(255,0,0), 3, 8 );
}
#endif
cvNamedWindow( "Source", 1 );
cvShowImage( "Source", src );

cvNamedWindow( "Hough", 1 );
cvShowImage( "Hough", color_dst );

cvWaitKey(0);
}
}
这是函数所用的样本图像：

下面是程序的输出，采用概率 Hough transform ("#if 0" 的部分):

DistTransform
计算输入图像的所有非零元素对其最近零元素的距离

void cvDistTransform( const CvArr* src, CvArr* dst, int
distance_type=CV_DIST_L2,
int mask_size=3, const float* mask=NULL );
src
输入 8-比特、单通道 (二值) 图像.
dst
含计算出的距离的输出图像(32-比特、浮点数、单通道).
distance_type
距离类型; 可以是 CV_DIST_L1, CV_DIST_L2, CV_DIST_C 或 CV_DIST_USER.
mask_size
距离变换掩模的大小，可以是 3 或 5. 对 CV_DIST_L1 或 CV_DIST_C 的情况，参数值被
强制设定为 3, 因为 3×3 mask 给出 5×5 mask 一样的结果，而且速度还更快。
mask
用户自定义距离距离情况下的 mask。在 3×3 mask 下它由两个数(水平/垂直位量，对角线
位移量）组成， 5×5 mask 下由三个数组成(水平/垂直位移量，对角位移和国际象棋里的马
步(马走日))
函数 cvDistTransform 二值图像每一个象素点到它最邻近零象素点的距离。对
零象素，函数设置 0 距离，对其它象素，它寻找由基本位移（水平、垂直、对
角线或 knight's move，最后一项对 5×5 mask 有用）构成的最短路径。全部
的距离被认为是基本距离的和。由于距离函数是对称的，所有水平和垂直位移具
有同样的代价 (表示为 a ), 所有的对角位移具有同样的代价 (表示为 b), 所
有的 knight's 移动具有同样的代价 (表示为 c). 对类型 CV_DIST_C 和
CV_DIST_L1，距离的计算是精确的，而类型 CV_DIST_L2 (欧式距离) 距离的计
算有某些相对误差 (5×5 mask 给出更精确的结果), OpenCV 使用
[Borgefors86] 推荐的值：
CV_DIST_C (3×3):
a=1, b=1

CV_DIST_L1 (3×3):
a=1, b=2

CV_DIST_L2 (3×3):
a=0.955, b=1.3693

CV_DIST_L2 (5×5):
a=1, b=1.4, c=2.1969
下面用户自定义距离的的距离域示例 (黑点 (0) 在白色方块中间）:
用户自定义 3×3 mask (a=1, b=1.5)
4.5 4 3.5 3 3.5 4 4.5
4 3 2.5 2 2.5 3 4
3.5 2.5 1.5 1 1.5 2.5 3.5
3 2 1 0 1 2 3
3.5 2.5 1.5 1 1.5 2.5 3.5
4 3 2.5 2 2.5 3 4
4.5 4 3.5 3 3.5 4 4.5
用户自定义 5×5 mask (a=1, b=1.5, c=2)
4.5 3.5 3 3 3 3.5 4.5
3.5 3 2 2 2 3 3.5
3 2 1.5 1 1.5 2 3
3 2 1 0 1 2 3
3 2 1.5 1 1.5 2 3
3.5 3 2 2 2 3 3.5
4 3.5 3 3 3 3.5 4
典型的使用快速粗略距离估计 CV_DIST_L2, 3×3 mask , 如果要更精确的距离
估计，使用 CV_DIST_L2, 5×5 mask。

直方图

CvHistogram
多维直方图

typedef struct CvHistogram
{
int header_size; /* 头尺寸 */
CvHistType type; /* 直方图类型 */
int flags; /* 直方图标识 */
int c_dims; /* 直方图维数 */
int dims[CV_HIST_MAX_DIM]; /* 每一维的尺寸 */
int mdims[CV_HIST_MAX_DIM]; /* 快速访问元素的系数 */
/* &m[a,b,c] = m + a*mdims[0] + b*mdims[1] + c*mdims[2] */
float* thresh[CV_HIST_MAX_DIM]; /* 每一维的直方块边界数组 */
float* array; /* 所有的直方图数据，扩展为单行 */
struct CvNode* root; /* 存储直方块的平衡树的根结点 */
CvSet* set; /* 内存存储仓的指针 (对平衡树而言) */
int* chdims[CV_HIST_MAX_DIM]; /* 快速计算的缓存 */
} CvHistogram;

CreateHist
创建直方图

CvHistogram* cvCreateHist( int dims, int* sizes, int type,
float** ranges=NULL, int uniform=1 );
dims
直方图维数的数目
sizes
直方图维数尺寸的数组
type
直方图的表示格式: CV_HIST_ARRAY 意味着直方图数据表示为多维密集数组 CvMatND;
CV_HIST_TREE 意味着直方图数据表示为多维稀疏数组 CvSparseMat.
ranges
图中方块范围的数组. 它的内容取决于参数 uniform 的值。这个范围的用处是确定何时计
算直方图或决定反向映射（backprojected ），每个方块对应于输入图像的哪个/哪组值。
uniform
归一化标识。如果不为 0，则 ranges[i]（0<=i 数，对于灰度图为 1，彩色图为 3）是包含两个元素的范围数组，包括直方图第 i 维的上界
和下界。在第 i 维上的整个区域 [lower,upper]被分割成 dims[i] 个相等的块（译者注：
dims[i]表示直方图第 i 维的块数），这些块用来确定输入象素的第 i 个值（译者注：对于
彩色图像，i 确定 R, G,或者 B）的对应的块；如果为 0，则 ranges[i]是包含 dims[i]+1
个元素的范围数组，包括 lower 0 , upper 0 , lower 1 , upper 1 == lower 2 , ..., upper dims[i]-1 ,
其中 lower j 和 upper j 分别是直方图第 i 维上第 j 个方块的上下界（针对输入象素的第 i
个值）。任何情况下，输入值如果超出了一个直方块所指定的范围外，都不会被 cvCalcHist 计
数，而且会被函数 cvCalcBackProject 置零。
函数 cvCreateHist 创建一个指定尺寸的直方图，并且返回创建的直方图的指
针。如果数组的 ranges 是 0, 则直方块的范围必须由函数
cvSetHistBinRanges 稍后指定。虽然 cvCalcHist 和 cvCalcBackProject 可以
处理 8-比特图像而无需设置任何直方块的范围，但它们都被假设等分 0..255
之间的空间。

SetHistBinRanges
设置直方块的区间

void cvSetHistBinRanges( CvHistogram* hist, float** ranges, int
uniform=1 );
hist
直方图.
ranges
直方块范围数组的数组，见 cvCreateHist.
uniform
归一化标识，见 cvCreateHist.
函数 cvSetHistBinRanges 是一个独立的函数，完成直方块的区间设置。更多详
细的关于参数 ranges 和 uniform 的描述，请参考函数 cvCalcHist , 该函数
也可以初始化区间。直方块的区间的设置必须在计算直方图之前，或在计算直
方图的反射图之前。

ReleaseHist
释放直方图结构

void cvReleaseHist( CvHistogram** hist );
hist
被释放的直方图结构的双指针.
函数 cvReleaseHist 释放直方图 (头和数据). 指向直方图的指针被函数所清
空。如果 *hist 指针已经为 NULL, 则函数不做任何事情。

ClearHist
清除直方图

void cvClearHist( CvHistogram* hist );
hist
直方图.
函数 cvClearHist 当直方图是稠密数组时将所有直方块设置为 0，当直方图是
稀疏数组时，除去所有的直方块。

MakeHistHeaderForArray
从数组中创建直方图

CvHistogram* cvMakeHistHeaderForArray( int dims, int* sizes,
CvHistogram* hist,
float* data, float**
ranges=NULL, int uniform=1 );
dims
直方图维数.
sizes
直方图维数尺寸的数组
hist
为函数所初始化的直方图头
data
用来存储直方块的数组
ranges
直方块范围，见 cvCreateHist.
uniform
归一化标识，见 cvCreateHist.
函数 cvMakeHistHeaderForArray 初始化直方图，其中头和直方块为用户所分
配。以后不需要调用 cvReleaseHist 只有稠密直方图可以采用这种方法，函数
返回 hist.

QueryHistValue_1D
查询直方块的值

#define cvQueryHistValue_1D( hist, idx0 ) \
cvGetReal1D( (hist)->bins, (idx0) )
#define cvQueryHistValue_2D( hist, idx0, idx1 ) \
cvGetReal2D( (hist)->bins, (idx0), (idx1) )
#define cvQueryHistValue_3D( hist, idx0, idx1, idx2 ) \
cvGetReal3D( (hist)->bins, (idx0), (idx1), (idx2) )
#define cvQueryHistValue_nD( hist, idx ) \
cvGetRealND( (hist)->bins, (idx) )
hist
直方图
idx0, idx1, idx2, idx3
直方块的下标索引
idx
下标数组
宏 cvQueryHistValue_*D 返回 1D, 2D, 3D 或 N-D 直方图的指定直方块的值。
对稀疏直方图，如果方块在直方图中不存在，函数返回 0, 而且不创建新的直方
块。

GetHistValue_1D
返回直方块的指针

#define cvGetHistValue_1D( hist, idx0 ) \
((float*)(cvPtr1D( (hist)->bins, (idx0), 0 ))
#define cvGetHistValue_2D( hist, idx0, idx1 ) \
((float*)(cvPtr2D( (hist)->bins, (idx0), (idx1), 0 ))
#define cvGetHistValue_3D( hist, idx0, idx1, idx2 ) \
((float*)(cvPtr3D( (hist)->bins, (idx0), (idx1), (idx2), 0 ))
#define cvGetHistValue_nD( hist, idx ) \
((float*)(cvPtrND( (hist)->bins, (idx), 0 ))
hist
直方图.
idx0, idx1, idx2, idx3
直方块的下标索引.
idx
下标数组
宏 cvGetHistValue_*D 返回 1D, 2D, 3D 或 N-D 直方图的指定直方块的指针。
对稀疏直方图，函数创建一个新的直方块，且设置其为 0，除非它已经存在。

GetMinMaxHistValue
发现最大和最小直方块

void cvGetMinMaxHistValue( const CvHistogram* hist,
float* min_value, float* max_value,
int* min_idx=NULL, int* max_idx=NULL );
hist
直方图
min_value
直方图最小值的指针
max_value
直方图最大值的指针
min_idx
数组中最小坐标的指针
max_idx
数组中最大坐标的指针
函数 cvGetMinMaxHistValue 发现最大和最小直方块以及它们的位置。任何输出
变量都是可选的。在具有同样值几个极值中，返回具有最小下标索引（以字母排
列顺序定）的那一个。

NormalizeHist
归一化直方图

void cvNormalizeHist( CvHistogram* hist, double factor );
hist
直方图的指针.
factor
归一化因子
函数 cvNormalizeHist 通过缩放来归一化直方块，使得所有块的和等于
factor.

ThreshHist
对直方图取阈值

void cvThreshHist( CvHistogram* hist, double threshold );
hist
直方图的指针.
threshold
阈值大小
函数 cvThreshHist 清除那些小于指定阈值得直方块

CompareHist
比较两个稠密直方图

double cvCompareHist( const CvHistogram* hist1, const CvHistogram* hist2,
int method );
hist1
第一个稠密直方图
hist2
第二个稠密直方图
method
比较方法，采用其中之一：
• CV_COMP_CORREL
• CV_COMP_CHISQR
• CV_COMP_INTERSECT
函数 cvCompareHist 采用下面指定的方法比较两个稠密直方图(H 1 表示第一个，
H 2 - 第二个):
相关 (method=CV_COMP_CORREL):
d(H 1 ,H 2 )=sum I (H' 1 (I)•H' 2 (I))/sqrt(sum I [H' 1 (I) 2 ]•sum I [H' 2 (I) 2 ])
其中
H' k (I)=H k (I)-1/N•sum J H k (J) (N=number of histogram bins)

Chi-square(method=CV_COMP_CHISQR):
d(H 1 ,H 2 )=sum I [(H 1 (I)-H 2 (I))/(H 1 (I)+H 2 (I))]

交叉 (method=CV_COMP_INTERSECT):
d(H 1 ,H 2 )=sum I max(H 1 (I),H 2 (I))
函数返回 d(H 1 ,H 2 ) 的值。
为了比较稀疏直方图或更一般的加权稀疏点集(译者注：直方图匹配是图像检索
中的常用方法)，考虑使用函数 cvCalcEMD 。

CopyHist
拷贝直方图

void cvCopyHist( const CvHistogram* src, CvHistogram** dst );
src
输入的直方图
dst
输出的直方图指针
函数 cvCopyHist 对直方图作拷贝。如果第二个直方图指针 *dst 是 NULL, 则
创建一个与 src 同样大小的直方图。否则，两个直方图必须大小和类型一致。
然后函数将输入的直方块的值复制到输出的直方图中，并且设置取值范围与 src
的一致。

CalcHist
计算图像
image(s)
的直方图

void cvCalcHist( IplImage** image, CvHistogram* hist,
int accumulate=0, const CvArr* mask=NULL );
image
输入图像 s (虽然也可以使用 CvMat** ).
hist
直方图指针
accumulate
累计标识。如果设置，则直方图在开始时不被清零。这个特征保证可以为多个图像计算一个
单独的直方图，或者在线更新直方图。
mask
操作 mask, 确定输入图像的哪个象素被计数
函数 cvCalcHist 计算单通道或多通道图像的直方图。用来增加直方块的数组
元素可从相应输入图像的同样位置提取。
Sample. 计算和显示彩色图像的 2D 色调－饱和度图像
#include
#include

int main( int argc, char** argv )
{
IplImage* src;
if( argc == 2 && (src=cvLoadImage(argv[1], 1))!= 0)
{
IplImage* h_plane = cvCreateImage( cvGetSize(src), 8, 1 );
IplImage* s_plane = cvCreateImage( cvGetSize(src), 8, 1 );
IplImage* v_plane = cvCreateImage( cvGetSize(src), 8, 1 );
IplImage* planes[] = { h_plane, s_plane };
IplImage* hsv = cvCreateImage( cvGetSize(src), 8, 3 );
int h_bins = 30, s_bins = 32;
int hist_size[] = {h_bins, s_bins};
float h_ranges[] = { 0, 180 }; /* hue varies from 0 (~0°red) to
180 (~360°red again) */
float s_ranges[] = { 0, 255 }; /* saturation varies from 0
(black-gray-white) to 255 (pure spectrum color) */
float* ranges[] = { h_ranges, s_ranges };
int scale = 10;
IplImage* hist_img =
cvCreateImage( cvSize(h_bins*scale,s_bins*scale), 8, 3 );
CvHistogram* hist;
float max_value = 0;
int h, s;

cvCvtColor( src, hsv, CV_BGR2HSV );
cvCvtPixToPlane( hsv, h_plane, s_plane, v_plane, 0 );
hist = cvCreateHist( 2, hist_size, CV_HIST_ARRAY, ranges, 1 );
cvCalcHist( planes, hist, 0, 0 );
cvGetMinMaxHistValue( hist, 0, &max_value, 0, 0 );
cvZero( hist_img );

for( h = 0; h < h_bins; h++ )
{
for( s = 0; s < s_bins; s++ )
{
float bin_val = cvQueryHistValue_2D( hist, h, s );
int intensity = cvRound(bin_val*255/max_value);
cvRectangle( hist_img, cvPoint( h*scale, s*scale ),
cvPoint( (h+1)*scale - 1, (s+1)*scale - 1),
CV_RGB(intensity,intensity,intensity), /*
graw a grayscale histogram.

if you have idea how to do it

nicer let us know */
CV_FILLED );
}
}

cvNamedWindow( "Source", 1 );
cvShowImage( "Source", src );

cvNamedWindow( "H-S Histogram", 1 );
cvShowImage( "H-S Histogram", hist_img );

cvWaitKey(0);
}
}

CalcBackProject
计算反向投影

void cvCalcBackProject( IplImage** image, CvArr* back_project, const
CvHistogram* hist );
image
输入图像 (也可以传递 CvMat** ).
back_project
反向投影图像，与输入图像具有同样类型.
hist
直方图
函数 cvCalcBackProject 直方图的反向投影. 对于所有输入的单通道图像同一
位置的象素数组，该函数根据相应的象素数组(RGB)，放置其对应的直方块的值
到输出图像中。用统计学术语，输出图像象素点的值是观测数组在某个分布（直
方图）下的的概率。例如，为了发现图像中的红色目标，可以这么做：
1. 对红色物体计算色调直方图，假设图像仅仅包含该物体。则直方图有可能有极值，对
应着红颜色。
2. 对将要搜索目标的输入图像，使用直方图计算其色调平面的反向投影，然后对图像做
阈值操作。
3. 在产生的图像中发现连通部分，然后使用某种附加准则选择正确的部分，比如最大的
连同部分。
这是 Camshift 彩色目标跟踪器中的一个逼进算法，除了第三步，CAMSHIFT 算法使用了上
一次目标位置来定位反向投影中的目标。

CalcBackProjectPatch
用直方图比较来定位图像中的模板

void cvCalcBackProjectPatch( IplImage** image, CvArr* dst,
CvSize patch_size, CvHistogram* hist,
int method, float factor );
image
输入图像 (可以传递 CvMat** )
dst
输出图像.
patch_size
扫描输入图像的补丁尺寸
hist
直方图
method
比较方法，传递给 cvCompareHist (见该函数的描述).
factor
直方图的归一化因子，将影响输出图像的归一化缩放。如果为 1，则不定。
函数 cvCalcBackProjectPatch 通过输入图像补丁的直方图和给定直方图的比
较，来计算反向投影。提取图像在 ROI 中每一个位置的某种测量结果产生了数
组 image. 这些结果可以是色调, x 差分, y 差分, Laplacian 滤波器, 有方向
Gabor 滤波器等中的一个或多个。每种测量输出都被划归为它自己的单独图像。
image 图像数组是这些测量图像的集合。一个多维直方图 hist 从这些图像数组
中被采样创建。最后直方图被归一化。直方图 hist 的维数通常很大等于图像数
组 image 的元素个数。
在选择的 ROI 中，每一个新的图像被测量并且转换为一个图像数组。在以锚点
为“补丁”中心的图像 image 区域中计算直方图（如下图所示）。用参数
norm_factor 来归一化直方图，使得它可以与 hist 互相比较。计算出的直方图
与直方图模型互相比较，（hist 使用函数 cvCompareHist ，比较方法是
method=method). 输出结果被放置到概率图像 dst 补丁锚点的对应位置上。这
个过程随着补丁滑过整个 ROI 而重复进行。迭代直方图的更新可以通过在原直
方图中减除“补丁”已覆盖的尾象素点或者加上新覆盖的象素点来实现，这种更
新方式可以节省大量的操作，尽管目前在函数体中还没有实现。
Back Project Calculation by Patches

CalcProbDensity
两个直方图相除

void cvCalcProbDensity( const CvHistogram* hist1, const CvHistogram*
hist2,
CvHistogram* dst_hist, double scale=255 );
hist1
第一个直方图(分子).
hist2
第二个直方图
dst_hist
输出的直方图
scale
输出直方图的尺度因子
函数 cvCalcProbDensity 从两个直方图中计算目标概率密度：
dist_hist(I)=0 if hist1(I)==0
scale if hist1(I)!=0 && hist2(I)>hist1(I)
hist2(I)*scale/hist1(I) if hist1(I)!=0 &&
hist2(I)<=hist1(I)
所以输出的直方块小于尺度因子。

匹配

MatchTemplate
比较模板和重叠的图像区域

void cvMatchTemplate( const CvArr* image, const CvArr* templ,
CvArr* result, int method );
image
欲搜索的图像。它应该是单通道、8-比特或 32-比特浮点数图像
templ
搜索模板，不能大于输入图像，且与输入图像具有一样的数据类型
result
比较结果的映射图像。单通道、32-比特浮点数. 如果图像是 W×H 而 templ 是 w×h ，则
result 一定是 (W-w+1）×(H-h+1）.
method
指定匹配方法：
函数 cvMatchTemplate 与函数 cvCalcBackProjectPatch 类似。它滑动过整个
图像 image, 用指定方法比较 templ 与图像尺寸为 w×h 的重叠区域，并且将
比较结果存到 result 中。下面是不同的比较方法，可以使用其中的一种 (I 表
示图像，T - 模板, R - 结果. 模板与图像重叠区域 x'=0..w-1, y'=0..h-1 之
间求和):
method=CV_TM_SQDIFF:
R(x,y)=sum x',y' [T(x',y')-I(x+x',y+y')] 2

method=CV_TM_SQDIFF_NORMED:
R(x,y)=sum x',y' [T(x',y')-I(x+x',y+y')] 2 /sqrt[sum x',y' T(x',y') 2 •sum x',y' I(x+x',
y+y') 2 ]

method=CV_TM_CCORR:
R(x,y)=sum x',y' [T(x',y')•I(x+x',y+y')]

method=CV_TM_CCORR_NORMED:
R(x,y)=sum x',y' [T(x',y')•I(x+x',y+y')]/sqrt[sum x',y' T(x',y') 2 •sum x',y' I(x+x',
y+y') 2 ]

method=CV_TM_CCOEFF:
R(x,y)=sum x',y' [T'(x',y')•I'(x+x',y+y')],

where T'(x',y')=T(x',y') - 1/(w•h)•sum x",y" T(x",y") (mean template
brightness=>0)
I'(x+x',y+y')=I(x+x',y+y') - 1/(w•h)•sum x",y" I(x+x",y+y") (mean
patch brightness=>0)

method=CV_TM_CCOEFF_NORMED:
R(x,y)=sum x',y' [T'(x',y')•I'(x+x',y+y')]/sqrt[sum x',y' T'(x',y') 2 •sum x',y' I'(x
+x',y+y') 2 ]

函数完成比较后，通过使用 cvMinMaxLoc 找全局最小值 CV_TM_SQDIFF*) 或者最大值
(CV_TM_CCORR* and CV_TM_CCOEFF*)。

MatchShapes
比较两个形状

double cvMatchShapes( const void* object1, const void* object2,
int method, double parameter=0 );
object1
第一个轮廓或灰度图像
object2
第二个轮廓或灰度图像
method
比较方法，其中之一 CV_CONTOUR_MATCH_I1, CV_CONTOURS_MATCH_I2 or
CV_CONTOURS_MATCH_I3.
parameter
比较方法的参数 (目前不用).
函数 cvMatchShapes 比较两个形状。三个实现方法全部使用 Hu 矩 (见
cvGetHuMoments) (A ~ object1, B - object2):
method=CV_CONTOUR_MATCH_I1:
I 1 (A,B)=sum i=1..7 abs(1/m A
i - 1/m B
i )

method=CV_CONTOUR_MATCH_I2:
I 2 (A,B)=sum i=1..7 abs(m A
i - m B
i )

method=CV_CONTOUR_MATCH_I3:
I 3 (A,B)=sum i=1..7 abs(m A
i - m B
i )/abs(m A
i )

其中
m A
i =sign(h A
i )•log(h A
i ),
m B
i =sign(h B
i )•log(h B
i ),
h A
i , h B
i - A 和 B 的 Hu 矩.

CalcEMD2
两个加权点集之间计算最小工作距离

float cvCalcEMD2( const CvArr* signature1, const CvArr* signature2, int
distance_type,
CvDistanceFunction distance_func=NULL, const CvArr*
cost_matrix=NULL,
CvArr* flow=NULL, float* lower_bound=NULL, void*
userdata=NULL );
typedef float (*CvDistanceFunction)(const float* f1, const float* f2,
void* userdata);
signature1
第一个签名，大小为 size1×(dims+1) 的浮点数矩阵，每一行依次存储点的权重和点的坐
标。矩阵允许只有一列（即仅有权重），如果使用用户自定义的代价矩阵。
signature2
第二个签名，与 signature1 的格式一样 size2×(dims+1)，尽管行数可以不同(列数要
相同)。当一个额外的虚拟点加入 signature1 或 signature2 中的时候，权重也可不同。
distance_type
使用的准则， CV_DIST_L1, CV_DIST_L2, 和 CV_DIST_C 分别为标准的准则。
CV_DIST_USER 意味着使用用户自定义函数 distance_func 或预先计算好的代价矩阵
cost_matrix 。
distance_func
用户自定义的距离函数。用两个点的坐标计算两点之间的距离。
cost_matrix
自定义大小为 size1×size2 的代价矩阵。 cost_matrix 和 distance_func 两者至少
有一个必须为 NULL. 而且，如果使用代价函数，下边界无法计算，因为它需要准则函数。
flow
产生的大小为 size1×size2 流矩阵（flow matrix）: flow ij 是从 signature1 的第 i 个
点到 signature2 的第 j 个点的流(flow)。
lower_bound
可选的输入/输出参数：两个签名之间的距离下边界，是两个质心之间的距离。如果使用自
定义代价矩阵，点集的所有权重不等，或者有签名只包含权重（即该签名矩阵只有单独一列），
则下边界也许不会计算。用户必须初始化 *lower_bound. 如果质心之间的距离大于获等
于 *lower_bound (这意味着签名之间足够远），函数则不计算 EMD. 任何情况下，函数
返回时 *lower_bound 都被设置为计算出来的质心距离。因此如果用户想同时计算质心距
离和 T EMD, *lower_bound 应该被设置为 0.
userdata
传输到自定义距离函数的可选数据指针
函数 cvCalcEMD2 计算两个加权点集之间的移动距离或距离下界。在
[RubnerSept98] 中所描述的其中一个应用就是图像提取得多维直方图比较。
EMD 是一个使用某种单纯形算法（simplex algorithm）来解决的交通问题。其
计算复杂度在最坏情况下是指数形式的，但是平均而言它的速度相当快。对实的
准则，下边界的计算可以更快（使用线性时间算法），且它可用来粗略确定两个
点集是否足够远以至无法联系到同一个目标上。

结构分析

轮廓处理函数

ApproxChains
用多边形曲线逼近
Freeman
链

CvSeq* cvApproxChains( CvSeq* src_seq, CvMemStorage* storage,
int method=CV_CHAIN_APPROX_SIMPLE,
double parameter=0, int minimal_perimeter=0, int
recursive=0 );
src_seq
涉及其它链的链指针
storage
存储多边形线段位置的缓存
method
逼近方法 (见函数 cvFindContours 的描述).
parameter
方法参数(现在不用).
minimal_perimeter
仅逼近周长大于 minimal_perimeter 轮廓。其它的链从结果中除去。
recursive
如果非 0, 函数从 src_seq 中利用 h_next 和 v_next links 连接逼近所有可访问的
链。如果为 0, 则仅逼近单链。
这是一个单独的逼近程序。对同样的逼近标识，函数 cvApproxChains 与
cvFindContours 的工作方式一模一样。它返回发现的第一个轮廓的指针。其它
的逼近模块，可以用返回结构中的 v_next 和 v_next 域来访问

StartReadChainPoints
初始化链读取

void cvStartReadChainPoints( CvChain* chain, CvChainPtReader* reader );
chain
链的指针
reader
链的读取状态
函数 cvStartReadChainPoints 初始化一个特殊的读取器 (参考 Dynamic Data
Structures 以获得关于集合与序列的更多内容).

ReadChainPoint
得到下一个链的点

CvPoint cvReadChainPoint( CvChainPtReader* reader );
reader
链的读取状态
函数 cvReadChainPoint 返回当前链的点，并且更新读取位置。

ApproxPoly
用指定精度逼近多边形曲线

CvSeq* cvApproxPoly( const void* src_seq, int header_size, CvMemStorage*
storage,
int method, double parameter, int parameter2=0 );
src_seq
点集数组序列
header_size
逼近曲线的头尺寸
storage
逼近轮廓的容器。如果为 NULL，则使用输入的序列
method
逼近方法。目前仅支持 CV_POLY_APPROX_DP ，对应 Douglas-Peucker 算法.
parameter
方法相关参数。对 CV_POLY_APPROX_DP 它是指定的逼近精度
parameter2
如果 src_seq 是序列，它表示要么逼近单个序列，要么在 src_seq 的同一个或低级层次
上逼近所有序列 (参考 cvFindContours 中对轮廓继承结构的描述). 如果 src_seq 是点集
的数组 (CvMat*) ，参数指定曲线是闭合 (parameter2!=0) 还是非闭合
(parameter2=0).
函数 cvApproxPoly 逼近一个或多个曲线，并返回逼近结果。对多个曲线的逼近，
生成的树将与输入的具有同样的结构。(1:1 的对应关系).

BoundingRect
计算点集的最外面（
up-right
）矩形边界

CvRect cvBoundingRect( CvArr* points, int update=0 );
points
二维点集，点的序列或向量 (CvMat)
update
更新标识。下面是轮廓类型和标识的一些可能组合:
• update=0, contour ~ CvContour*: 不计算矩形边界，但直接由轮廓头的 rect 域得到。
• update=1, contour ~ CvContour*: 计算矩形边界，而且将结果写入到轮廓头的 rect 域
中 header.
• update=0, contour ~ CvSeq* or CvMat*: 计算并返回边界矩形
• update=1, contour ~ CvSeq* or CvMat*: 产生运行错误（runtime error is raised）
函数 cvBoundingRect 返回二维点集的最外面（up-right）矩形边界。

ContourArea
计算整个轮廓或部分轮廓的面积

double cvContourArea( const CvArr* contour, CvSlice slice=CV_WHOLE_SEQ );
contour
轮廓 (定点的序列或数组).
slice
感兴趣轮廓部分的起始点，缺省是计算整个轮廓的面积。
函数 cvContourArea 计算整个轮廓或部分轮廓的面积。对后面的情况，面积表
示轮廓部分和起始点连线构成的封闭部分的面积。如下图所示：

NOTE: 轮廓的方向影响面积的符号。因此函数也许会返回负的结果。应用函数
fabs() 得到面积的绝对值。

ArcLength
计算轮廓周长或曲线长度

double cvArcLength( const void* curve, CvSlice slice=CV_WHOLE_SEQ, int
is_closed=-1 );
curve
曲线点集序列或数组
slice
曲线的起始点，缺省是计算整个曲线的长度
is_closed
表示曲线是否闭合，有三种情况：
• is_closed=0 - 假设曲线不闭合
• is_closed>0 - 假设曲线闭合
• is_closed<0 - 若曲线是序列，检查 ((CvSeq*)curve)->flags 中的标识
CV_SEQ_FLAG_CLOSED 来确定曲线是否闭合。否则 (曲线由点集的数组 (CvMat*)
表示) 假设曲线不闭合。
函数 cvArcLength 通过依次计算序列点之间的线段长度，并求和来得到曲线的
长度。

CreateContourTree
创建轮廓的继承表示形式

CvContourTree* cvCreateContourTree( const CvSeq* contour, CvMemStorage*
storage, double threshold );
contour
输入的轮廓
storage
输出树的容器
threshold
逼近精度
函数 cvCreateContourTree 为输入轮廓 contour 创建一个二叉树，并返回树
根的指针。如果参数 threshold 小于或等于 0 ,则函数创建一个完整的二叉树。
如果 threshold 大于 0 ，函数用 threshold 指定的精度创建二叉树：如果
基线的截断区域顶点小于 threshold，该数就停止生长并作为函数的最终结果返
回。

ContourFromContourTree
由树恢复轮廓

CvSeq* cvContourFromContourTree( const CvContourTree* tree,
CvMemStorage* storage,
CvTermCriteria criteria );
tree
轮廓树
storage
重构的轮廓容器
criteria
停止重构的准则
函数 cvContourFromContourTree 从二叉树恢复轮廓。参数 criteria 决定了重
构的精度和使用树的数目及层次。所以它可建立逼近的轮廓。函数返回重构的
轮廓。

MatchContourTrees
用树的形式比较两个轮廓

double cvMatchContourTrees( const CvContourTree* tree1, const
CvContourTree* tree2,
int method, double threshold );
tree1
第一个轮廓树
tree2
第二个轮廓树
method
相似度。仅支持 CV_CONTOUR_TREES_MATCH_I1 。
threshold
相似度阈值
函数 cvMatchContourTrees 计算两个轮廓树的匹配值。从树根开始通过逐层比
较来计算相似度。如果某层的相似度小于 threshold, 则中断比较过程，且返
回当前的差值。

计算几何

MaxRect
对两个给定矩形，寻找矩形边界

CvRect cvMaxRect( const CvRect* rect1, const CvRect* rect2 );
rect1
第一个矩形
rect2
第二个矩形
函数 cvMaxRect 寻找包含两个输入矩形的具有最小面积的矩形边界。

CvBox2D
旋转的二维盒子

typedef struct CvBox2D
{
CvPoint2D32f center; /* 盒子的中心 */
CvSize2D32f size; /* 盒子的长和宽 */
float angle; /* 水平轴与第一个边的夹角，用弧度表示*/
}
CvBox2D;

BoxPoints
寻找盒子的顶点

void cvBoxPoints( CvBox2D box, CvPoint2D32f pt[4] );
box
盒子
pt
顶点数组
函数 cvBoxPoints 计算输入的二维盒子的定点。下面是函数代码：
void cvBoxPoints( CvBox2D box, CvPoint2D32f pt[4] )
{
float a = (float)cos(box.angle)*0.5f;
float b = (float)sin(box.angle)*0.5f;

pt[0].x = box.center.x - a*box.size.height - b*box.size.width;
pt[0].y = box.center.y + b*box.size.height - a*box.size.width;
pt[1].x = box.center.x + a*box.size.height - b*box.size.width;
pt[1].y = box.center.y - b*box.size.height - a*box.size.width;
pt[2].x = 2*box.center.x - pt[0].x;
pt[2].y = 2*box.center.y - pt[0].y;
pt[3].x = 2*box.center.x - pt[1].x;
pt[3].y = 2*box.center.y - pt[1].y;
}

FitEllipse
二维点集的椭圆拟合

CvBox2D cvFitEllipse2( const CvArr* points );
points
点集的序列或数组
函数 cvFitEllipse 对给定的一组二维点集作椭圆的最佳拟合(最小二乘意义上
的)。返回的结构与 cvEllipse 中的意义类似，除了 size 表示椭圆轴的整个长
度，而不是一半长度。

FitLine
2D
或
3D
点集的直线拟合

void cvFitLine( const CvArr* points, int dist_type, double param,
double reps, double aeps, float* line );
points
2D 或 3D 点集，32-比特整数或浮点数坐标
dist_type
拟合的距离类型（见讨论）.
param
对某些距离的数字参数，如果是 0，则选择某些最优值
reps, aeps
半径 (坐标原点到直线的距离) 和角度的精度，一般设为 0.01。
line
输出的直线参数。2D 拟合情况下，它是包含 4 个浮点数的数组 (vx, vy, x0, y0)，其
中 (vx, vy) 是线的单位向量而 (x0, y0) 是线上的某个点. 对 3D 拟合，它是包含 6 个
浮点数的数组 (vx, vy, vz, x0, y0, z0)，其中 (vx, vy, vz) 是线的单位向量，
而 (x0, y0, z0) 是线上某点。
函数 cvFitLine 通过求 sum i ρ(r i ) 的最小值方法，用 2D 或 3D 点集拟合直
线，其中 r i 是第 i 个点到直线的距离， ρ(r) 是下面的距离函数之一：
dist_type=CV_DIST_L2 (L 2 ):
ρ(r)=r 2 /2 (最简单和最快的最小二乘法)

dist_type=CV_DIST_L1 (L 1 ):
ρ(r)=r

dist_type=CV_DIST_L12 (L 1 -L 2 ):
ρ(r)=2•[sqrt(1+r 2 /2) - 1]

dist_type=CV_DIST_FAIR (Fair):
ρ(r)=C 2 •[r/C - log(1 + r/C)], C=1.3998

dist_type=CV_DIST_WELSCH (Welsch):
ρ(r)=C 2 /2•[1 - exp(-(r/C) 2 )], C=2.9846

dist_type=CV_DIST_HUBER (Huber):
ρ(r)= r 2 /2, if r < C
C•(r-C/2), otherwise; C=1.345

ConvexHull2
发现点集的凸外形

CvSeq* cvConvexHull2( const CvArr* input, void* hull_storage=NULL,
int orientation=CV_CLOCKWISE, int
return_points=0 );
points
2D 点集的序列或数组，32-比特整数或浮点数坐标
hull_storage
输出的数组(CvMat*) 或内存缓存 (CvMemStorage*)，用以存储凸外形。如果是数组，则它
应该是一维的，而且与输入的数组/序列具有同样数目的元素。输出时修改头使得数组裁减
到外形的尺寸。输出时，通过修改头结构将数组裁减到凸外形的尺寸。
orientation
凸外形的旋转方向: 逆时针或顺时针（CV_CLOCKWISE or CV_COUNTER_CLOCKWISE）
return_points
如果非零，点集将以外形 (hull) 存储，而不是 hull_storage 为数组情况下的顶点形式
(indices) 以及 hull_storag 为内存存储模式下的点集形式(points)。
函数 cvConvexHull2 使用 Sklansky 算法计算 2D 点集的凸外形。如果
hull_storage 是内存存储仓，函数根据 return_points 的值，创建一个包含
外形的点集或指向这些点的指针的序列。
例子. 由点集序列或数组创建凸外形
#include "cv.h"
#include "highgui.h"
#include

#define ARRAY 0 /* switch between array/sequence method by replacing
0<=>1 */

void main( int argc, char** argv )
{
IplImage* img = cvCreateImage( cvSize( 500, 500 ), 8, 3 );
cvNamedWindow( "hull", 1 );

#if !ARRAY
CvMemStorage* storage = cvCreateMemStorage();
#endif

for(;;)
{
int i, count = rand()%100 + 1, hullcount;
CvPoint pt0;
#if !ARRAY
CvSeq* ptseq = cvCreateSeq( CV_SEQ_KIND_GENERIC|CV_32SC2,
sizeof(CvContour),
sizeof(CvPoint), storage );
CvSeq* hull;

for( i = 0; i < count; i++ )
{
pt0.x = rand() % (img->width/2) + img->width/4;
pt0.y = rand() % (img->height/2) + img->height/4;
cvSeqPush( ptseq, &pt0 );
}
hull = cvConvexHull2( ptseq, 0, CV_CLOCKWISE, 0 );
hullcount = hull->total;
#else
CvPoint* points = (CvPoint*)malloc( count * sizeof(points[0]));
int* hull = (int*)malloc( count * sizeof(hull[0]));
CvMat point_mat = cvMat( 1, count, CV_32SC2, points );
CvMat hull_mat = cvMat( 1, count, CV_32SC1, hull );

for( i = 0; i < count; i++ )
{
pt0.x = rand() % (img->width/2) + img->width/4;
pt0.y = rand() % (img->height/2) + img->height/4;
points[i] = pt0;
}
cvConvexHull2( &point_mat, &hull_mat, CV_CLOCKWISE, 0 );
hullcount = hull_mat.cols;
#endif
cvZero( img );
for( i = 0; i < count; i++ )
{
#if !ARRAY
pt0 = *CV_GET_SEQ_ELEM( CvPoint, ptseq, i );
#else
pt0 = points[i];
#endif
cvCircle( img, pt0, 2, CV_RGB( 255, 0, 0 ), CV_FILLED );
}

#if !ARRAY
pt0 = **CV_GET_SEQ_ELEM( CvPoint*, hull, hullcount - 1 );
#else
pt0 = points[hull[hullcount-1]];
#endif

for( i = 0; i < hullcount; i++ )
{
#if !ARRAY
CvPoint pt = **CV_GET_SEQ_ELEM( CvPoint*, hull, i );
#else
CvPoint pt = points[hull[i]];
#endif
cvLine( img, pt0, pt, CV_RGB( 0, 255, 0 ));
pt0 = pt;
}

cvShowImage( "hull", img );

int key = cvWaitKey(0);
if( key == 27 ) // 'ESC'
break;

#if !ARRAY
cvClearMemStorage( storage );
#else
free( points );
free( hull );
#endif
}
}

CheckContourConvexity
测试轮廓的凸性

int cvCheckContourConvexity( const CvArr* contour );
contour
被测试轮廓 (点序列或数组).
函数 cvCheckContourConvexity 输入的轮廓是否为凸的。必须是简单轮廓，比
如没有自交叉。

CvConvexityDefect
用来描述一个简单轮廓凸性缺陷的结构体

typedef struct CvConvexityDefect
{
CvPoint* start; /* 缺陷开始的轮廓点 */
CvPoint* end; /* 缺陷结束的轮廓点 */
CvPoint* depth_point; /* 缺陷中距离凸形最远的轮廓点(谷底) */
float depth; /* 谷底距离凸形的深度*/
} CvConvexityDefect;
Picture. Convexity defects of hand contour.

ConvexityDefects
发现轮廓凸形缺陷

CvSeq* cvConvexityDefects( const CvArr* contour, const CvArr* convexhull,
CvMemStorage* storage=NULL );
contour
输入轮廓
convexhull
用 cvConvexHull2 得到的凸外形，它应该包含轮廓的定点或下标，而不是外形点的本身，
即 cvConvexHull2 中的参数 return_points 应该设置为 0.
storage
凸性缺陷的输出序列容器。如果为 NULL, 使用轮廓或外形的存储仓。
函数 cvConvexityDefects 发现输入轮廓的所有凸性缺陷，并且返回
CvConvexityDefect 结构序列。

MinAreaRect2
对给定的
2D
点集，寻找最小面积的包围矩形

CvBox2D cvMinAreaRect2( const CvArr* points, CvMemStorage*
storage=NULL );
points
点序列或点集数组
storage
可选的临时存储仓
函数 cvMinAreaRect2 通过建立凸外形并且旋转外形以寻找给定 2D 点集的最
小面积的包围矩形.
Picture. Minimal-area bounding rectangle for contour

MinEnclosingCircle
对给定的
2D
点集，寻找最小面积的包围圆形

int cvMinEnclosingCircle( const CvArr* points, CvPoint2D32f* center,
float* radius );
points
点序列或点集数组
center
输出参数：圆心
radius
输出参数：半径
函数 cvMinEnclosingCircle 对给定的 2D 点集迭代寻找最小面积的包围圆形。
如果产生的圆包含所有点，返回非零。否则返回零（算法失败）。

CalcPGH
计算轮廓的
pair-wise
几何直方图

void cvCalcPGH( const CvSeq* contour, CvHistogram* hist );
contour
输入轮廓，当前仅仅支持具有整数坐标的点集
hist
计算出的直方图，必须是两维的。
函数 cvCalcPGH 计算轮廓的 2D pair-wise（Hunnish: 不知如何翻译，只好保
留）几何直方图（pair-wise geometrical histogram ：PGH), 算法描述见
[Iivarinen97]. 算法考虑的每一对轮廓边缘。计算每一对边缘之间的夹角以及
最大最小距离。具体做法是，轮流考虑每一个边缘做为基准，函数循环遍历所有
边缘。在考虑基准边缘和其它边缘的时候，选择非基准线上的点到基准线上的
最大和最小距离。边缘之间的角度定义了直方图的行，而在其中增加对应计算出
来的最大和最小距离的所有直方块， (即直方图是 [Iivarninen97] 定义中的转
置). 该直方图用来做轮廓匹配。

平面划分

CvSubdiv2D
平面划分

#define CV_SUBDIV2D_FIELDS() \
CV_GRAPH_FIELDS() \
int quad_edges; \
int is_geometry_valid; \
CvSubdiv2DEdge recent_edge; \
CvPoint2D32f topleft; \
CvPoint2D32f bottomright;

typedef struct CvSubdiv2D
{
CV_SUBDIV2D_FIELDS()
}
CvSubdiv2D;
平面划分是将一个平面分割为一组互不重叠的能够覆盖整个平面的区域
P(facets)。上面结构描述了建立在 2D 点集上的划分结构，其中点集互相连接
并且构成平面图形，该图形通过结合一些无限连接外部划分点(称为凸形点)的边
缘，将一个平面用边按照其边缘划分成很多小区域(facets)。
对于每一个划分操作，都有一个对偶划分与之对应，对偶的意思是小区域和点(划
分的顶点)变换角色，即在对偶划分中，小区域被当做一个顶点(以下称之为虚拟
点)，而原始的划分顶点被当做小区域。在如下所示的图例中，原始的划分用实
线来表示，而对偶划分用点线来表示。

OpenCV 使用 Delaunay's 算法将平面分割成小的三角形区域。分割的实现通过从
一个假定的三角形(该三角形确保包括所有的分割点)开始不断迭代来完成。在这
种情况下，对偶划分就是输入的 2d 点集的 Voronoi 图表。这种划分可以用于对
一个平面的 3d 分段变换、形态变换、平面点的快速定位以及建立特定的图结构
(比如 NNG,RNG 等等)。

CvQuadEdge2D
平面划分中的
Quad-edge(
四方边缘结构
)
/* quad-edge 中的一条边缘，低两位表示该边缘的索引号，其它高位表示边缘指
针。 */
typedef long CvSubdiv2DEdge;

/* 四方边缘的结构场 */
#define CV_QUADEDGE2D_FIELDS() \
int flags; \
struct CvSubdiv2DPoint* pt[4]; \
CvSubdiv2DEdge next[4];

typedef struct CvQuadEdge2D
{
CV_QUADEDGE2D_FIELDS()
}
CvQuadEdge2D;
Quad-edge(译者注：以下称之为四方边缘结构)是平面划分的基元，其中包括四
个边缘 (e, eRot 以及它们的逆)。

CvSubdiv2DPoint
原始和对偶划分点

#define CV_SUBDIV2D_POINT_FIELDS()\
int flags; \
CvSubdiv2DEdge first; \
CvPoint2D32f pt;

#define CV_SUBDIV2D_VIRTUAL_POINT_FLAG (1 << 30)

typedef struct CvSubdiv2DPoint
{
CV_SUBDIV2D_POINT_FIELDS()
}
CvSubdiv2DPoint;

Subdiv2DGetEdge
返回给定的边缘之一

CvSubdiv2DEdge cvSubdiv2DGetEdge( CvSubdiv2DEdge edge, CvNextEdgeType
type );
#define cvSubdiv2DNextEdge( edge ) cvSubdiv2DGetEdge( edge,
CV_NEXT_AROUND_ORG )
edge
划分的边缘 (并不是四方边缘结构)
type
确定函数返回哪条相关边缘，是下面几种之一：
• CV_NEXT_AROUND_ORG - 边缘原点的下一条 (eOnext on the picture above if e is
the input edge)
• CV_NEXT_AROUND_DST - 边缘顶点的下一条 (eDnext)
• CV_PREV_AROUND_ORG - 边缘原点的前一条 (reversed eRnext)
• CV_PREV_AROUND_DST - 边缘终点的前一条 (reversed eLnext)
• CV_NEXT_AROUND_LEFT - 左区域的下一条 (eLnext)
• CV_NEXT_AROUND_RIGHT - 右区域的下一条(eRnext)
• CV_PREV_AROUND_LEFT - 左区域的前一条 (reversed eOnext)
• CV_PREV_AROUND_RIGHT - 右区域的前一条 (reversed eDnext)
函数 cvSubdiv2DGetEdge 返回与输入边缘相关的边缘

Subdiv2DRotateEdge
返回同一个四方边缘结构中的另一条边缘

CvSubdiv2DEdge cvSubdiv2DRotateEdge( CvSubdiv2DEdge edge, int rotate );
edge
划分的边缘 (并不是四方边缘结构)
type
确定函数根据输入的边缘返回同一四方边缘结构中的哪条边缘，是下面几种之一:
• 0 - 输入边缘 (上图中的 e，如果 e 是输入边缘)
• 1 - 旋转边缘 (eRot)
• 2 -逆边缘 ( e 的反向边缘)
• 3 - 旋转边缘的反向边缘(eRot 的反向边缘，图中绿色)
函数 cvSubdiv2DRotateEdge 根据输入的边缘返回四方边缘结构中的一条边缘

Subdiv2DEdgeOrg
返回边缘的原点

CvSubdiv2DPoint* cvSubdiv2DEdgeOrg( CvSubdiv2DEdge edge );
edge
划分的边缘 (并不是四方边缘结构)
函数 cvSubdiv2DEdgeOrg 返回边缘的原点。如果该边缘是从对偶划分得到并且
虚点坐标还没有计算出来，可能返回空指针。虚点可以用函数来
cvCalcSubdivVoronoi2D 计算。

Subdiv2DEdgeDst
Returns edge destination
CvSubdiv2DPoint* cvSubdiv2DEdgeDst( CvSubdiv2DEdge edge );
edge
划分的边缘 (并不是四方边缘结构)
函数 cvSubdiv2DEdgeDst 返回边缘的终点。如果该边缘是从对偶划分得到并且
虚点坐标还没有计算出来，可能返回空指针。虚点可以用函数来
cvCalcSubdivVoronoi2D 计算。

CreateSubdivDelaunay2D
生成的空
Delaunay
三角测量

CvSubdiv2D* cvCreateSubdivDelaunay2D( CvRect rect, CvMemStorage*
storage );
rect
Rectangle 包括所有待加入划分操作的 2d 点的四方形。
storage
划分操作的存储器
函数 cvCreateSubdivDelaunay2D 生成一个空的 Delaunay 划分, 其中 2d
points 可以进一步使用函数 cvSubdivDelaunay2DInsert 来添加。所有的点一
定要在指定的四方形中添加，否则就会报运行错误。

SubdivDelaunay2DInsert
向
Delaunay
三角测量中插入一个点

CvSubdiv2DPoint* cvSubdivDelaunay2DInsert( CvSubdiv2D* subdiv,
CvPoint2D32f pt);
subdiv
通过函数 cvCreateSubdivDelaunay2D.生成的 Delaunay 划分
pt
待插入的点
函数 cvSubdivDelaunay2DInsert 向划分的结构中插入一个点并且正确地改变
划分的拓朴结构。如果划分结构中已经存在一个相同的坐标点，则不会有新点插
入。该函数返回指向已插入点的指针。在这个截断，不计算任何虚点坐标。

Subdiv2DLocate
在
Delaunay
三角测量中定位输入点

CvSubdiv2DPointLocation cvSubdiv2DLocate( CvSubdiv2D* subdiv,
CvPoint2D32f pt,
CvSubdiv2DEdge* edge,
CvSubdiv2DPoint**
vertex=NULL );
subdiv
Delaunay 或者是其它分割结构.
pt
待定位的输入点
edge
与输入点对应的输入边缘(点在其上或者其右)
vertex
与输入点对应的输出顶点坐标(指向 double 类型)，可选。
函数 cvSubdiv2DLocate 在划分中定位输入点，共有 5 种类型:
• 输入点落入某小区域内。函数返回参数 CV_PTLOC_INSIDE 且*edge 中包含小区
域的边缘之一。
• 输入点落 p 在边缘之上。函数返回参数 CV_PTLOC_ON_EDGE 且 *edge 包含此边
缘。
• 输入点与划分的顶点之一相对应。函数返回参数 CV_PTLOC_VERTEX 且 *vertex
中包括指向该顶点的指针；
• 输入点落在划分的参考区域之外。函数返回参数 CV_PTLOC_OUTSIDE_RECT 且不
填写任何指针。
• 输入参数之一有误。函数报运行错误(如果已经选则了沉默或者父母出错模式，则函数
返回 CV_PTLOC_ERROR) 。

FindNearestPoint2D
根据输入点，找到其最近的划分顶点

CvSubdiv2DPoint* cvFindNearestPoint2D( CvSubdiv2D* subdiv, CvPoint2D32f
pt );
subdiv
Delaunay 或者其它划分方式
pt
输入点
函数 cvFindNearestPoint2D 是另一个定位输入点的函数。该函数找到输入点的
最近划分顶点。尽管划分出的小区域(facet)被用来作为起始点，但是输入点不
一定非得在最终找到的顶点所在的小区域之内。该函数返回指向找到的划分顶点
的指针。

CalcSubdivVoronoi2D
计算
Voronoi
图表的细胞结构

void cvCalcSubdivVoronoi2D( CvSubdiv2D* subdiv );
subdiv
Delaunay 划分,其中所有的点已经添加。
函数 cvCalcSubdivVoronoi2D 计算虚点的坐标，所有与原划分中的某顶点相对
应的虚点形成了(当他们相互连接时)该顶点的 Voronoi 细胞的边界。

ClearSubdivVoronoi2D
移除所有的虚点

void cvClearSubdivVoronoi2D( CvSubdiv2D* subdiv );
subdiv
Delaunay 划分
函数 cvClearSubdivVoronoi2D 移除所有的虚点。当划分的结果被函数
cvCalcSubdivVoronoi2D 的前一次调用更改时，该函数被 cvCalcSubdivVoronoi2D
内部调用。

还有一些其它的底层处理函数与平面划分操作协同工作，参见 cv.h 及源码。生
成 delaunay.c 三角测量以及 2d 随机点集的 Voronoi 图表的演示代码可以在
opencv/samples/c 目录下的 delaunay.c 文件中找到。

运动分析与对象跟踪

背景统计量的累积

Acc
将帧叠加到累积器（
accumulator
）中

void cvAcc( const CvArr* image, CvArr* sum, const CvArr* mask=NULL );
image
输入图像, 1- 或 3-通道, 8-比特或 32-比特浮点数. (多通道的每一个通道都单独处理).
sum
同一个输入图像通道的累积，32-比特或 64-比特浮点数数组.
mask
可选的运算 mask.
函数 cvAcc 将整个图像 image 或某个选择区域叠加到 sum 中：
sum(x,y)=sum(x,y)+image(x,y) if mask(x,y)!=0

SquareAcc
叠加输入图像的平方到累积器中

void cvSquareAcc( const CvArr* image, CvArr* sqsum, const CvArr*
mask=NULL );
image
输入图像, 1- 或 3-通道, 8-比特或 32-比特浮点数 (多通道的每一个通道都单独处理)
sqsum
同一个输入图像通道的累积，32-比特或 64-比特浮点数数组.
mask
可选的运算 mask.
函数 cvSquareAcc 叠加输入图像 image 或某个选择区域的二次方，到累积器
sqsum 中
sqsum(x,y)=sqsum(x,y)+image(x,y) 2 if mask(x,y)!=0

MultiplyAcc
将两幅输入图像的乘积叠加到累积器中

void cvMultiplyAcc( const CvArr* image1, const CvArr* image2, CvArr* acc,
const CvArr* mask=NULL );
image1
第一个输入图像, 1- or 3-通道, 8-比特 or 32-比特浮点数 (多通道的每一个通道都单独处理)
image2
第二个输入图像, 与第一个图像的格式一样
acc
同一个输入图像通道的累积，32-比特或 64-比特浮点数数组.
mask
可选的运算 mask.
函数 cvMultiplyAcc 叠加两个输入图像的乘积到累积器 acc:
acc(x,y)=acc(x,y) + image1(x,y)•image2(x,y) if mask(x,y)!=0

RunningAvg
更新
running average
（
Hunnish:
不知道
running average
如何翻译才恰当）

void cvRunningAvg( const CvArr* image, CvArr* acc, double alpha, const
CvArr* mask=NULL );
image
输入图像, 1- or 3-通道, 8-比特 or 32-比特浮点数 (each channel of multi-channel image is
processed independently).
acc
同一个输入图像通道的累积，32-比特或 64-比特浮点数数组.
alpha
输入图像权重
mask
可选的运算 mask
函数 cvRunningAvg 计算输入图像 image 的加权和，以及累积器 acc 使得 acc
成为帧序列的一个 running average：
acc(x,y)=(1-α)•acc(x,y) + α•image(x,y) if mask(x,y)!=0
其中 α (alpha) 调节更新速率 (累积器以多快的速率忘掉前面的帧).

运动模板

UpdateMotionHistory
去掉影像
(silhouette)
以更新运动历史图像

void cvUpdateMotionHistory( const CvArr* silhouette, CvArr* mhi,
double timestamp, double duration );
silhouette
影像 mask，运动发生地方具有非零象素
mhi
运动历史图像(单通道, 32-比特浮点数)，为本函数所更新
timestamp
当前时间，毫秒或其它单位
duration
运动跟踪的最大持续时间，用 timestamp 一样的时间单位
函数 cvUpdateMotionHistory 用下面方式更新运动历史图像：
mhi(x,y)=timestamp if silhouette(x,y)!=0
0 if silhouette(x,y)=0 and
mhi(x,y) mhi(x,y) otherwise
也就是，MHI（motion history image）中在运动发生的象素点被设置为当前时
间戳，而运动发生较久的象素点被清除。

CalcMotionGradient
计算运动历史图像的梯度方向

void cvCalcMotionGradient( const CvArr* mhi, CvArr* mask, CvArr*
orientation,
double delta1, double delta2, int
aperture_size=3 );
mhi
运动历史图像
mask
Mask 图像；用来标注运动梯度数据正确的点，为输出参数。
orientation
运动梯度的方向图像，包含从 0 到 360 角度
delta1, delta2
函数在每个象素点 (x,y) 邻域寻找 MHI 的最小值 (m(x,y)) 和最大值 (M(x,y))，并且假设梯
度是正确的，当且仅当：
min(delta1,delta2) <= M(x,y)-m(x,y) <= max(delta1,delta2).
aperture_size
函数所用微分算子的开孔尺寸 CV_SCHARR, 1, 3, 5 or 7 (见 cvSobel).
函数 cvCalcMotionGradient 计算 MHI 的差分 Dx 和 Dy ，然后计算梯度方向
如下式：
orientation(x,y)=arctan(Dy(x,y)/Dx(x,y))
其中都要考虑 Dx(x,y)' 和 Dy(x,y)' 的符号 (如 cvCartToPolar 类似). 然
后填充 mask 以表示哪些方向是正确的(见 delta1 和 delta2 的描述).

CalcGlobalOrientation
计算某些选择区域的全局运动方向

double cvCalcGlobalOrientation( const CvArr* orientation, const CvArr*
mask, const CvArr* mhi,
double timestamp, double duration );
orientation
运动梯度方向图像，由函数 cvCalcMotionGradient 得到
mask
Mask 图像. 它可以是正确梯度 mask (由函数 cvCalcMotionGradient 得到)与区域 mask 的
结合，其中区域 mask 确定哪些方向需要计算。
mhi
运动历史图象
timestamp
当前时间（单位毫秒或其它）最好在传递它到函数 cvUpdateMotionHistory 之前存储一下以
便以后的重用，因为对大图像运行 cvUpdateMotionHistory 和 cvCalcMotionGradient 会花费
一些时间
duration
运动跟踪的最大持续时间，用法与 cvUpdateMotionHistory 中的一致
函数 cvCalcGlobalOrientation 在选择的区域内计算整个运动方向，并且返回
0° 到 360° 之间的角度值。首先函数创建运动直方图，寻找基本方向做为直
方图最大值的坐标。然后函数计算与基本方向的相对偏移量，做为所有方向向量
的加权和：运行越近，权重越大。得到的角度是基本方向和偏移量的循环和。

SegmentMotion
将整个运动分割为独立的运动部分

CvSeq* cvSegmentMotion( const CvArr* mhi, CvArr* seg_mask, CvMemStorage*
storage,
double timestamp, double seg_thresh );
mhi
运动历史图像
seg_mask
发现应当存储的 mask 的图像, 单通道, 32-比特，浮点数.
storage
包含运动连通域序列的内存存储仓
timestamp
当前时间，毫秒单位
seg_thresh
分割阈值，推荐等于或大于运动历史“每步”之间的间隔。
函数 cvSegmentMotion 寻找所有的运动分割，并且在 seg_mask 用不同的单独数
字(1,2,...)标识它们。它也返回一个具有 CvConnectedComp 结构的序列，其中
每个结构对应一个运动部件。在这之后，每个运动部件的运动方向就可以被函数
cvCalcGlobalOrientation 利用提取的特定部件的掩模(mask)计算出来(使用
cvCmp)

对象跟踪

MeanShift
在反向投影图中发现目标中心

int cvMeanShift( const CvArr* prob_image, CvRect window,
CvTermCriteria criteria, CvConnectedComp* comp );
prob_image
目标直方图的反向投影(见 cvCalcBackProject).
window
初始搜索窗口
criteria
确定窗口搜索停止的准则
comp
生成的结构，包含收敛的搜索窗口坐标 (comp->rect 字段) 与窗口内部所有象素点的和
(comp->area 字段).
函数 cvMeanShift 在给定反向投影和初始搜索窗口位置的情况下，用迭代方法
寻找目标中心。当搜索窗口中心的移动小于某个给定值时或者函数已经达到最大
迭代次数时停止迭代。函数返回迭代次数。

CamShift
发现目标中心，尺寸和方向

int cvCamShift( const CvArr* prob_image, CvRect window, CvTermCriteria
criteria,
CvConnectedComp* comp, CvBox2D* box=NULL );
prob_image
目标直方图的反向投影 (见 cvCalcBackProject).
window
初始搜索窗口
criteria
确定窗口搜索停止的准则
comp
生成的结构，包含收敛的搜索窗口坐标 (comp->rect 字段) 与窗口内部所有象素点的和
(comp->area 字段).
box
目标的带边界盒子。如果非 NULL, 则包含目标的尺寸和方向。
函数 cvCamShift 实现了 CAMSHIFT 目标跟踪算法([Bradski98]). 首先它调用
函数 cvMeanShift 寻找目标中心，然后计算目标尺寸和方向。最后返回函数
cvMeanShift 中的迭代次数。
CvCamShiftTracker 类在 cv.hpp 中被声明，函数实现了彩色目标的跟踪。

SnakeImage
改变轮廓位置使得它的能量最小

void cvSnakeImage( const IplImage* image, CvPoint* points, int length,
float* alpha, float* beta, float* gamma, int
coeff_usage,
CvSize win, CvTermCriteria criteria, int
calc_gradient=1 );
image
输入图像或外部能量域
points
轮廓点 (snake).
length
轮廓点的数目
alpha
连续性能量的权 Weight[s]，单个浮点数或长度为 length 的浮点数数组，每个轮廓点有一
个权
beta
曲率能量的权 Weight[s]，与 alpha 类似
gamma
图像能量的权 Weight[s]，与 alpha 类似
coeff_usage
前面三个参数的不同使用方法：
• CV_VALUE 表示每个 alpha, beta, gamma 都是指向为所有点所用的一个单独数值;
• CV_ARRAY 表示每个 alpha, beta, gamma 是一个指向系数数组的指针，snake 上
面各点的系数都不相同。因此，各个系数数组必须与轮廓具有同样的大小。所有数
组必须与轮廓具有同样大小
win
每个点用于搜索最小值的邻域尺寸，两个 win.width 和 win.height 都必须是奇数
criteria
终止条件
calc_gradient
梯度符号。如果非零，函数为每一个图像象素计算梯度幅值，且把它当成能量场，否则考虑
输入图像本身。
函数 cvSnakeImage 更新 snake 是为了最小化 snake 的整个能量，其中能量是
依赖于轮廓形状的内部能量(轮廓越光滑，内部能量越小)以及依赖于能量场的外
部能量之和，外部能量通常在哪些局部能量极值点中达到最小值(这些局部能量
极值点与图像梯度表示的图像边缘相对应)。
参数 criteria.epsilon 用来定义必须从迭代中除掉以保证迭代正常运行的点
的最少数目。
如果在迭代中去掉的点数目小于 criteria.epsilon 或者函数达到了最大的迭
代次数 criteria.max_iter ，则终止函数。

光流

CalcOpticalFlowHS
计算两幅图像的光流

void cvCalcOpticalFlowHS( const CvArr* prev, const CvArr* curr, int
use_previous,
CvArr* velx, CvArr* vely, double lambda,
CvTermCriteria criteria );
prev
第一幅图像, 8-比特, 单通道.
curr
第二幅图像, 8-比特, 单通道.
use_previous
使用以前的 (输入) 速度域
velx
光流的水平部分，与输入图像大小一样, 32-比特，浮点数, 单通道.
vely
光流的垂直部分，与输入图像大小一样, 32-比特，浮点数, 单通道.
lambda
Lagrangian 乘子
criteria
速度计算的终止条件
函数 cvCalcOpticalFlowHS 为输入图像的每一个象素计算光流，使用 Horn &
Schunck 算法 [Horn81].

CalcOpticalFlowLK
计算两幅图像的光流

void cvCalcOpticalFlowLK( const CvArr* prev, const CvArr* curr, CvSize
win_size,
CvArr* velx, CvArr* vely );
prev
第一幅图像, 8-比特, 单通道.
curr
第二幅图像, 8-比特, 单通道.
win_size
用来归类象素的平均窗口尺寸（Size of the averaging window used for grouping pixels）
velx
光流的水平部分，与输入图像大小一样, 32-比特，浮点数, 单通道.
vely
光流的垂直部分，与输入图像大小一样, 32-比特，浮点数, 单通道.
函数 cvCalcOpticalFlowLK 为输入图像的每一个象素计算光流，使用 Lucas &
Kanade 算法 [Lucas81].

CalcOpticalFlowBM
用块匹配方法计算两幅图像的光流

void cvCalcOpticalFlowBM( const CvArr* prev, const CvArr* curr, CvSize
block_size,
CvSize shift_size, CvSize max_range, int
use_previous,
CvArr* velx, CvArr* vely );
prev
第一幅图像, 8-比特, 单通道.
curr
第二幅图像, 8-比特, 单通道.
block_size
比较的基本块尺寸
shift_size
块坐标的增量
max_range
块周围象素的扫描邻域的尺寸
use_previous
使用以前的 (输入) 速度域
velx
光流的水平部分，尺寸为 floor((prev->width - block_size.width)/shiftSize.width) ×
floor((prev->height - block_size.height)/shiftSize.height) , 32-比特，浮点数, 单通道.
vely
光流的垂直部分，与 velx 大小一样，32-比特，浮点数, 单通道.
函数 cvCalcOpticalFlowBM 为重叠块 block_size.width×block_size.height
中的每一个象素计算光流，因此其速度域小于整个图像的速度域。对每一个在图
像 prev 中的块，函数试图在 curr 中某些原始块或其偏移
(velx(x0,y0),vely(x0,y0)) 块的邻域里寻找类似的块，如同在前一个函数调用
中所计算的类似(如果 use_previous=1)

CalcOpticalFlowPyrLK
计算一个稀疏特征集的光流，使用金字塔中的迭代
Lucas-Kanade
方法

void cvCalcOpticalFlowPyrLK( const CvArr* prev, const CvArr* curr, CvArr*
prev_pyr, CvArr* curr_pyr,
const CvPoint2D32f* prev_features,
CvPoint2D32f* curr_features,
int count, CvSize win_size, int level,
char* status,
float* track_error, CvTermCriteria
criteria, int flags );
prev
在时间 t 的第一帧
curr
在时间 t + dt 的第二帧
prev_pyr
第一帧的金字塔缓存. 如果指针非 NULL , 则缓存必须有足够的空间来存储金字塔从层 1
到层 #level 的内容。尺寸 (image_width+8)*image_height/3 比特足够了
curr_pyr
与 prev_pyr 类似，用于第二帧
prev_features
需要发现光流的点集
curr_features
包含新计算出来的位置的点集
features
第二幅图像中
count
特征点的数目
win_size
每个金字塔层的搜索窗口尺寸
level
最大的金字塔层数。如果为 0 , 不使用金字塔 (即金字塔为单层), 如果为 1 , 使用两层，下
面依次类推。
status
数组。如果对应特征的光流被发现，数组中的每一个元素都被设置为 1，否则设置为 0。
error
双精度数组，包含原始图像碎片与移动点之间的差。为可选参数，可以是 NULL .
criteria
准则，指定在每个金字塔层，为某点寻找光流的迭代过程的终止条件。
flags
其它选项：
• CV_LKFLOW_PYR_A_READY , 在调用之前，先计算第一帧的金字塔
• CV_LKFLOW_PYR_B_READY , 在调用之前，先计算第二帧的金字塔
• CV_LKFLOW_INITIAL_GUESSES , 在调用之前，数组 B 包含特征的初始坐标
（Hunnish: 在本节中没有出现数组 B，不知是指的哪一个）
函数 cvCalcOpticalFlowPyrLK 实现了金字塔中 Lucas-Kanade 光流计算的稀
疏迭代版本 ([Bouguet00])。它根据给出的前一帧特征点坐标计算当前视频帧
上的特征点坐标。函数寻找具有子象素精度的坐标值。
两个参数 prev_pyr 和 curr_pyr 都遵循下列规则：如果图像指针为 0, 函数
在内部为其分配缓存空间，计算金字塔，然后再处理过后释放缓存。否则，函
数计算金字塔且存储它到缓存中，除非设置标识 CV_LKFLOW_PYR_A[B]_READY 。
图像应该足够大以便能够容纳 Gaussian 金字塔数据。调用函数以后，金字塔
被计算而且相应图像的标识也被设置，为下一次调用准备就绪 (比如：对除了第
一个图像的所有图像序列，标识 CV_LKFLOW_PYR_A_READY 被设置).

预估器

CvKalman
Kalman
滤波器状态

typedef struct CvKalman
{
int MP; /* 测量向量维数 */
int DP; /* 状态向量维数 */
int CP; /* 控制向量维数 */

/* 向后兼容字段 */
#if 1
float* PosterState; /* =state_pre->data.fl */
float* PriorState; /* =state_post->data.fl */
float* DynamMatr; /* =transition_matrix->data.fl */
float* MeasurementMatr; /* =measurement_matrix->data.fl */
float* MNCovariance; /* =measurement_noise_cov->data.fl */
float* PNCovariance; /* =process_noise_cov->data.fl */
float* KalmGainMatr; /* =gain->data.fl */
float* PriorErrorCovariance;/* =error_cov_pre->data.fl */
float* PosterErrorCovariance;/* =error_cov_post->data.fl */
float* Temp1; /* temp1->data.fl */
float* Temp2; /* temp2->data.fl */
#endif

CvMat* state_pre; /* 预测状态 (x'(k)):
x(k)=A*x(k-1)+B*u(k) */
CvMat* state_post; /* 矫正状态 (x(k)):
x(k)=x'(k)+K(k)*(z(k)-H*x'(k)) */
CvMat* transition_matrix; /* 状态传递矩阵 state transition matrix
(A) */
CvMat* control_matrix; /* 控制矩阵 control matrix (B)
(如果没有控制，则不使用它)*/
CvMat* measurement_matrix; /* 测量矩阵 measurement matrix (H) */
CvMat* process_noise_cov; /* 处理噪声相关矩阵 process noise
covariance matrix (Q) */
CvMat* measurement_noise_cov; /* 测量噪声相关矩阵 measurement noise
covariance matrix (R) */
CvMat* error_cov_pre; /* 先验错误估计相关矩阵 priori error
estimate covariance matrix (P'(k)):
P'(k)=A*P(k-1)*At + Q)*/
CvMat* gain; /* Kalman 增益矩阵 gain matrix (K(k)):
K(k)=P'(k)*Ht*inv(H*P'(k)*Ht+R)*/
CvMat* error_cov_post; /* 后验错误估计相关矩阵 posteriori
error estimate covariance matrix (P(k)):
P(k)=(I-K(k)*H)*P'(k) */
CvMat* temp1; /* 临时矩阵 temporary matrices */
CvMat* temp2;
CvMat* temp3;
CvMat* temp4;
CvMat* temp5;
}
CvKalman;
（Hunnish: 害怕有翻译上的不准确，因此在翻译注释时，保留了原来的英文术
语，以便大家对照）
结构 CvKalman 用来保存 Kalman 滤波器状态。它由函数 cvCreateKalman 创
建，由函数 f cvKalmanPredict 和 cvKalmanCorrect 更新，由 cvReleaseKalman
释放. 通常该结构是为标准 Kalman 所使用的 (符号和公式都借自非常优秀的
Kalman 教程 [Welch95]):
x k =A•x k-1 +B•u k +w k 译者注：系统运动方程
z k =H•x k +v k , 译者注：系统观测方程
其中:
x k (x k-1 ) - 系统在时刻 k (k-1) 的状态向量（state of the system at the moment
k (k-1)）
z k - 在时刻 k 的系统状态测量向量（measurement of the system state at the
moment k）
u k - 应用于时刻 k 的外部控制 (external control applied at the moment k)

w k 和 v k 分别为正态分布的运动和测量噪声
p(w) ~ N(0,Q)
p(v) ~ N(0,R),

即,
Q - 运动噪声的相关矩阵，常量或变量
R - 测量噪声的相关矩阵，常量或变量
对标准 Kalman 滤波器，所有矩阵: A, B, H, Q 和 R 都是通过 cvCreateKalman
在分配结构 CvKalman 时初始化一次。但是，同样的结构和函数，通过在当前系
统状态邻域中线性化扩展 Kalman 滤波器方程，可以用来模拟扩展 Kalman 滤波
器，在这种情况下， A, B, H (也许还有 Q 和 R) 在每一步中都被更新。

CreateKalman
分配
Kalman
滤波器结构

CvKalman* cvCreateKalman( int dynam_params, int measure_params, int
control_params=0 );
dynam_params
状态向量维数
measure_params
测量向量维数
control_params
控制向量维数
函数 cvCreateKalman 分配 CvKalman 以及它的所有矩阵和初始参数

ReleaseKalman
释放
Kalman
滤波器结构

void cvReleaseKalman( CvKalman** kalman );
kalman
指向 Kalman 滤波器结构的双指针
函数 cvReleaseKalman 释放结构 CvKalman 和里面所有矩阵

KalmanPredict
估计后来的模型状态

const CvMat* cvKalmanPredict( CvKalman* kalman, const CvMat*
control=NULL );
#define cvKalmanUpdateByTime cvKalmanPredict
kalman
Kalman 滤波器状态
control
控制向量 (u k ), 如果没有外部控制 (control_params=0) 应该为 NULL
函数 cvKalmanPredict 根据当前状态估计后来的随机模型状态，并存储于
kalman->state_pre:
x' k =A•x k +B•u k
P' k =A•P k-1 *A T + Q,
其中
x' k 是预测状态 (kalman->state_pre),
x k-1 是前一步的矫正状态 (kalman->state_post)
(应该在开始的某个地方初始化，即缺省为零向量),
u k 是外部控制(control 参数),
P' k 是先验误差相关矩阵 (kalman->error_cov_pre)
P k-1 是前一步的后验误差相关矩阵(kalman->error_cov_post)
(应该在开始的某个地方初始化，即缺省为单位矩阵),
函数返回估计得到的状态值

KalmanCorrect
调节模型状态

const CvMat* cvKalmanCorrect( CvKalman* kalman, const CvMat*
measurement );
#define cvKalmanUpdateByMeasurement cvKalmanCorrect
kalman
被更新的 Kalman 结构的指针
measurement
指向测量向量的指针，向量形式为 CvMat
函数 cvKalmanCorrect 在给定的模型状态的测量基础上，调节随机模型状态：
K k =P' k •H T •(H•P' k •H T +R) -1
x k =x' k +K k •(z k -H•x' k )
P k =(I-K k •H)•P' k
其中
z k - 给定测量(mesurement parameter)
K k - Kalman "增益" 矩阵
函数存储调节状态到 kalman->state_post 中并且输出时返回它
例子. 使用 Kalman 滤波器跟踪一个旋转的点
#include "cv.h"
#include "highgui.h"
#include

int main(int argc, char** argv)
{
/* A matrix data */
const float A[] = { 1, 1, 0, 1 };

IplImage* img = cvCreateImage( cvSize(500,500), 8, 3 );
CvKalman* kalman = cvCreateKalman( 2, 1, 0 );
/* state is (phi, delta_phi) - angle and angle increment */
CvMat* state = cvCreateMat( 2, 1, CV_32FC1 );
CvMat* process_noise = cvCreateMat( 2, 1, CV_32FC1 );
/* only phi (angle) is measured */
CvMat* measurement = cvCreateMat( 1, 1, CV_32FC1 );
CvRandState rng;
int code = -1;

cvRandInit( &rng, 0, 1, -1, CV_RAND_UNI );

cvZero( measurement );
cvNamedWindow( "Kalman", 1 );

for(;;)
{
cvRandSetRange( &rng, 0, 0.1, 0 );
rng.disttype = CV_RAND_NORMAL;

cvRand( &rng, state );

memcpy( kalman->transition_matrix->data.fl, A, sizeof(A));
cvSetIdentity( kalman->measurement_matrix, cvRealScalar(1) );
cvSetIdentity( kalman->process_noise_cov, cvRealScalar(1e-5) );
cvSetIdentity( kalman->measurement_noise_cov,
cvRealScalar(1e-1) );
cvSetIdentity( kalman->error_cov_post, cvRealScalar(1));
/* choose random initial state */
cvRand( &rng, kalman->state_post );

rng.disttype = CV_RAND_NORMAL;

for(;;)
{
#define calc_point(angle)
\
cvPoint( cvRound(img->width/2 +
img->width/3*cos(angle)), \
cvRound(img->height/2 -
img->width/3*sin(angle)))

float state_angle = state->data.fl[0];
CvPoint state_pt = calc_point(state_angle);

/* predict point position */
const CvMat* prediction = cvKalmanPredict( kalman, 0 );
float predict_angle = prediction->data.fl[0];
CvPoint predict_pt = calc_point(predict_angle);
float measurement_angle;
CvPoint measurement_pt;

cvRandSetRange( &rng, 0,
sqrt(kalman->measurement_noise_cov->data.fl[0]), 0 );
cvRand( &rng, measurement );

/* generate measurement */
cvMatMulAdd( kalman->measurement_matrix, state, measurement,
measurement );

measurement_angle = measurement->data.fl[0];
measurement_pt = calc_point(measurement_angle);

/* plot points */
#define draw_cross( center, color, d )
\
cvLine( img, cvPoint( center.x - d, center.y - d ),
\
cvPoint( center.x + d, center.y + d ), color,
1, 0 ); \
cvLine( img, cvPoint( center.x + d, center.y - d ),
\
cvPoint( center.x - d, center.y + d ), color,
1, 0 )

cvZero( img );
draw_cross( state_pt, CV_RGB(255,255,255), 3 );
draw_cross( measurement_pt, CV_RGB(255,0,0), 3 );
draw_cross( predict_pt, CV_RGB(0,255,0), 3 );
cvLine( img, state_pt, predict_pt, CV_RGB(255,255,0), 3, 0 );

/* adjust Kalman filter state */
cvKalmanCorrect( kalman, measurement );

cvRandSetRange( &rng, 0,
sqrt(kalman->process_noise_cov->data.fl[0]), 0 );
cvRand( &rng, process_noise );
cvMatMulAdd( kalman->transition_matrix, state,
process_noise, state );

cvShowImage( "Kalman", img );
code = cvWaitKey( 100 );

if( code > 0 ) /* break current simulation by pressing a key
*/
break;
}
if( code == 27 ) /* exit by ESCAPE */
break;
}

return 0;
}

CvConDensation
ConDensaation
状态

typedef struct CvConDensation
{
int MP; // 测量向量的维数： Dimension of measurement vector
int DP; // 状态向量的维数： Dimension of state vector
float* DynamMatr; // 线性动态系统矩阵：Matrix of the
linear Dynamics system
float* State; // 状态向量： Vector of State
int SamplesNum; // 粒子数： Number of the Samples
float** flSamples; // 粒子向量数组： array of the Sample
Vectors
float** flNewSamples; // 粒子向量临时数组： temporary array of
the Sample Vectors
float* flConfidence; // 每个粒子的置信度(译者注：也就是粒子
的权值)：Confidence for each Sample
float* flCumulative; // 权值的累计： Cumulative confidence
float* Temp; // 临时向量：Temporary vector
float* RandomSample; // 用来更新粒子集的随机向量：
RandomVector to update sample set
CvRandState* RandS; // 产生随机向量的结构数组： Array of
structures to generate random vectors
} CvConDensation;
结构 CvConDensation 中条件概率密度传播(译者注：粒子滤波的一种特例)
（Con-Dens-Aation: 单词 CONditional DENSity propagATION 的缩写）跟踪器
的状态。该算法描述可参考
http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/ISARD1/condensation.htm
l

CreateConDensation
分配
ConDensation
滤波器结构

CvConDensation* cvCreateConDensation( int dynam_params, int
measure_params, int sample_count );
dynam_params
状态向量的维数
measure_params
测量向量的维数
sample_count
粒子数
函数 cvCreateConDensation 创建结构 CvConDensation 并且返回结构指针。

ReleaseConDensation
释放
ConDensation
滤波器结构

void cvReleaseConDensation( CvConDensation** condens );
condens
要释放结构的双指针
函数 cvReleaseConDensation 释放结构 CvConDensation (见 cvConDensation)
并且清空所有事先被开辟的内存空间。

ConDensInitSampleSet
初始化
ConDensation
算法中的粒子集

void cvConDensInitSampleSet( CvConDensation* condens, CvMat* lower_bound,
CvMat* upper_bound );
condens
需要初始化的结构指针
lower_bound
每一维的下界向量
upper_bound
每一维的上界向量
函数 cvConDensInitSampleSet 在指定区间内填充结构 CvConDensation 中的
样例数组。

ConDensUpdateByTime
估计下个模型状态

void cvConDensUpdateByTime( CvConDensation* condens );
condens
要更新的机构指针
函数 cvConDensUpdateByTime 从当前状态估计下一个随机模型状态。

模式识别

目标检测
目标检测方法最初由 Paul Viola [Viola01]提出，并由 Rainer Lienhart
[Lienhart02]对这一方法进行了改善. 首先，利用样本（大约几百幅样本图片）
的 harr 特征进行分类器训练，得到一个级联的 boosted 分类器。训练样本分为
正例样本和反例样本，其中正例样本是指待检目标样本(例如人脸或汽车等)，反
例样本指其它任意图片，所有的样本图片都被归一化为同样的尺寸大小(例如，
20x20)。
分类器训练完以后，就可以应用于输入图像中的感兴趣区域(与训练样本相同的
尺寸)的检测。检测到目标区域(汽车或人脸)分类器输出为 1，否则输出为 0。为
了检测整副图像，可以在图像中移动搜索窗口，检测每一个位置来确定可能的目
标。为了搜索不同大小的目标物体，分类器被设计为可以进行尺寸改变，这样
比改变待检图像的尺寸大小更为有效。所以，为了在图像中检测未知大小的目标
物体，扫描程序通常需要用不同比例大小的搜索窗口对图片进行几次扫描。
分类器中的“级联”是指最终的分类器是由几个简单分类器级联组成。在图像检
测中，被检窗口依次通过每一级分类器，这样在前面几层的检测中大部分的候
选区域就被排除了，全部通过每一级分类器检测的区域即为目标区域。目前支
持这种分类器的 boosting 技术有四种： Discrete Adaboost, Real Adaboost,
Gentle Adaboost and Logitboost。"boosted" 即指级联分类器的每一层都可以
从中选取一个 boosting 算法(权重投票)，并利用基础分类器的自我训练得到。
基础分类器是至少有两个叶结点的决策树分类器。海尔特征是基础分类器的输
入，主要描述如下。目前的算法主要利用下面的海尔特征。

每个特定分类器所使用的特征用形状、感兴趣区域中的位置以及比例系数（这里
的比例系数跟检测时候采用的比例系数是不一样的，尽管最后会取两个系数的乘
积值）来定义。例如在第三行特征(2c)的情况下，响应计算为覆盖全部特征整个
矩形框(包括两个白色矩形框和一个黑色矩形框)象素的和减去黑色矩形框内象
素和的三倍。每个矩形框内的象素和都可以通过积分图象很快的计算出来。(察
看下面和对 cvIntegral 的描述).
通过 HaarFaceDetect 的演示版可以察看目标检测的工作情况。
下面只是检测部分的参考手册。 haartraining 是它的一个单独的应用，可以用
来对系列样本训练级联的 boosted 分类器。详细察看
opencv/apps/haartraining。

CvHaarFeature, CvHaarClassifier, CvHaarStageClassifier,
CvHaarClassifierCascade
Boosted Haar
分类器结构

#define CV_HAAR_FEATURE_MAX 3

/* 一个 harr 特征由 2－3 个具有相应权重的矩形组成 a haar feature
consists of 2-3 rectangles with appropriate weights */
typedef struct CvHaarFeature
{
int tilted; /* 0 means up-right feature, 1 means 45--rotated
feature */

/* 2-3 rectangles with weights of opposite signs and
with absolute values inversely proportional to the areas of the
rectangles.
if rect[2].weight !=0, then
the feature consists of 3 rectangles, otherwise it consists of 2
*/
struct
{
CvRect r;
float weight;
} rect[CV_HAAR_FEATURE_MAX];
}
CvHaarFeature;

/* a single tree classifier (stump in the simplest case) that returns the
response for the feature
at the particular image location (i.e. pixel sum over subrectangles
of the window) and gives out
a value depending on the responce */
typedef struct CvHaarClassifier
{
int count; /* number of nodes in the decision tree */

/* these are "parallel" arrays. Every index i
corresponds to a node of the decision tree (root has 0-th index).

left[i] - index of the left child (or negated index if the left
child is a leaf)
right[i] - index of the right child (or negated index if the right
child is a leaf)
threshold[i] - branch threshold. if feature responce is <=
threshold, left branch
is chosen, otherwise right branch is chosed.
alpha[i] - output value correponding to the leaf. */
CvHaarFeature* haar_feature;
float* threshold;
int* left;
int* right;
float* alpha;
}
CvHaarClassifier;

/* a boosted battery of classifiers(=stage classifier):
the stage classifier returns 1
if the sum of the classifiers' responces
is greater than threshold and 0 otherwise */
typedef struct CvHaarStageClassifier
{
int count; /* number of classifiers in the battery */
float threshold; /* threshold for the boosted classifier */
CvHaarClassifier* classifier; /* array of classifiers */

/* these fields are used for organizing trees of stage classifiers,
rather than just stright cascades */
int next;
int child;
int parent;
}
CvHaarStageClassifier;

typedef struct CvHidHaarClassifierCascade CvHidHaarClassifierCascade;

/* cascade or tree of stage classifiers */
typedef struct CvHaarClassifierCascade
{
int flags; /* signature */
int count; /* number of stages */
CvSize orig_window_size; /* original object size (the cascade is
trained for) */

/* these two parameters are set by
cvSetImagesForHaarClassifierCascade */
CvSize real_window_size; /* current object size */
double scale; /* current scale */
CvHaarStageClassifier* stage_classifier; /* array of stage
classifiers */
CvHidHaarClassifierCascade* hid_cascade; /* hidden optimized
representation of the cascade,
created by
cvSetImagesForHaarClassifierCascade */
}
CvHaarClassifierCascade;

所有的结构都代表一个级联 boosted Haar 分类器。级联有下面的等级结构：
Cascade:
Stage 1 :
Classifier 11 :
Feature 11
Classifier 12 :
Feature 12
...
Stage 2 :
Classifier 21 :
Feature 21
...
...
整个等级可以手工构建，也可以利用函数 cvLoadHaarClassifierCascade 从已有
的磁盘文件或嵌入式基中导入。

cvLoadHaarClassifierCascade
从文件中装载训练好的级联分类器或者从
OpenCV
中嵌入的分类器数据库中导入

CvHaarClassifierCascade* cvLoadHaarClassifierCascade(
const char* directory,
CvSize orig_window_size );
directory
训练好的级联分类器的路径
orig_window_size
级联分类器训练中采用的检测目标的尺寸。因为这个信息没有在级联分类器中存储，所有要
单独指出。
函数 cvLoadHaarClassifierCascade 用于从文件中装载训练好的利用海尔特征
的级联分类器，或者从 OpenCV 中嵌入的分类器数据库中导入。分类器的训练可
以应用函数 haartraining(详细察看 opencv/apps/haartraining)
函数已经过时了。现在的目标检测分类器通常存储在 XML 或 YAML 文件中,而
不是通过路径导入。从文件中导入分类器，可以使用函数 cvLoad 。

cvReleaseHaarClassifierCascade
释放
haar classifier cascade
。

void cvReleaseHaarClassifierCascade( CvHaarClassifierCascade**
cascade );
cascade
双指针类型指针指向要释放的 cascade. 指针由函数声明。
函数 cvReleaseHaarClassifierCascade 释放 cascade 的动态内存，其中
cascade 的动态内存或者是手工创建，或者通过函数
cvLoadHaarClassifierCascade 或 cvLoad 分配。

cvHaarDetectObjects
检测图像中的目标

typedef struct CvAvgComp
{
CvRect rect; /* bounding rectangle for the object (average rectangle
of a group) */
int neighbors; /* number of neighbor rectangles in the group */
}
CvAvgComp;

CvSeq* cvHaarDetectObjects( const CvArr* image, CvHaarClassifierCascade*
cascade,
CvMemStorage* storage, double
scale_factor=1.1,
int min_neighbors=3, int flags=0,
CvSize min_size=cvSize(0,0) );
image
被检图像
cascade
harr 分类器级联的内部标识形式
storage
用来存储检测到的一序列候选目标矩形框的内存区域。
scale_factor
在前后两次相继的扫描中，搜索窗口的比例系数。例如 1.1 指将搜索窗口依次扩大 10%。
min_neighbors
构成检测目标的相邻矩形的最小个数(缺省－1)。如果组成检测目标的小矩形的个数和小于
min_neighbors-1 都会被排除。如果 min_neighbors 为 0, 则函数不做任何操作就返回
所有的被检候选矩形框，这种设定值一般用在用户自定义对检测结果的组合程序上。
flags
操作方式。当前唯一可以定义的操作方式是 CV_HAAR_DO_CANNY_PRUNING。如果被设定，
函数利用 Canny 边缘检测器来排除一些边缘很少或者很多的图像区域，因为这样的区域一般
不含被检目标。人脸检测中通过设定阈值使用了这种方法，并因此提高了检测速度。
min_size
检测窗口的最小尺寸。缺省的情况下被设为分类器训练时采用的样本尺寸(人脸检测中缺省
大小是~20×20)。
函数 cvHaarDetectObjects 使用针对某目标物体训练的级联分类器在图像中找
到包含目标物体的矩形区域，并且将这些区域作为一序列的矩形框返回。函数以
不同比例大小的扫描窗口对图像进行几次搜索(察看
cvSetImagesForHaarClassifierCascade)。每次都要对图像中的这些重叠区域
利用 cvRunHaarClassifierCascade 进行检测。有时候也会利用某些继承
（heuristics）技术以减少分析的候选区域，例如利用 Canny 裁减（prunning）
方法。函数在处理和收集到候选的方框(全部通过级联分类器各层的区域)之后，
接着对这些区域进行组合并且返回一系列各个足够大的组合中的平均矩形。调节
程序中的缺省参数(scale_factor=1.1, min_neighbors=3, flags=0)用于对目标
进行更精确同时也是耗时较长的进一步检测。为了能对视频图像进行更快的实时
检测，参数设置通常是：scale_factor=1.2, min_neighbors=2,
flags=CV_HAAR_DO_CANNY_PRUNING, min_size=
(例如, 对于视频会议的图像区域).
例子:利用级联的 Haar classifiers 寻找检测目标(e.g. faces).
#include "cv.h"
#include "highgui.h"

CvHaarClassifierCascade* load_object_detector( const char*
cascade_path )
{
return (CvHaarClassifierCascade*)cvLoad( cascade_path );
}

void detect_and_draw_objects( IplImage* image,
CvHaarClassifierCascade* cascade,
int do_pyramids )
{
IplImage* small_image = image;
CvMemStorage* storage = cvCreateMemStorage(0);
CvSeq* faces;
int i, scale = 1;

/* if the flag is specified, down-scale the 输入图像 to get a
performance boost w/o loosing quality (perhaps) */
if( do_pyramids )
{
small_image =
cvCreateImage( cvSize(image->width/2,image->height/2), IPL_DEPTH_8U,
3 );
cvPyrDown( image, small_image, CV_GAUSSIAN_5x5 );
scale = 2;
}

/* use the fastest variant */
faces = cvHaarDetectObjects( small_image, cascade, storage, 1.2, 2,
CV_HAAR_DO_CANNY_PRUNING );

/* draw all the rectangles */
for( i = 0; i < faces->total; i++ )
{
/* extract the rectanlges only */
CvRect face_rect = *(CvRect*)cvGetSeqElem( faces, i, 0 );
cvRectangle( image,
cvPoint(face_rect.x*scale,face_rect.y*scale),
cvPoint((face_rect.x+face_rect.width)*scale,
(face_rect.y+face_rect.height)*scale),
CV_RGB(255,0,0), 3 );
}

if( small_image != image )
cvReleaseImage( &small_image );
cvReleaseMemStorage( &storage );
}

/* takes image filename and cascade path from the command line */
int main( int argc, char** argv )
{
IplImage* image;
if( argc==3 && (image = cvLoadImage( argv[1], 1 )) != 0 )
{
CvHaarClassifierCascade* cascade =
load_object_detector(argv[2]);
detect_and_draw_objects( image, cascade, 1 );
cvNamedWindow( "test", 0 );
cvShowImage( "test", image );
cvWaitKey(0);
cvReleaseHaarClassifierCascade( &cascade );
cvReleaseImage( &image );
}

return 0;
}

cvSetImagesForHaarClassifierCascade
为隐藏的
cascade(hidden cascade)
指定图像

void cvSetImagesForHaarClassifierCascade( CvHaarClassifierCascade*
cascade,
const CvArr* sum, const
CvArr* sqsum,
const CvArr* tilted_sum,
double scale );
cascade
隐藏 Harr 分类器级联（ Hidden Haar classifier cascade ） , 由函数
cvCreateHidHaarClassifierCascade 生成
sum
32－比特，单通道图像的积分图像（Integral (sum) 单通道 image of 32-比特 integer format）.
这幅图像以及随后的两幅用于对快速特征的评价和亮度/对比度的归一化。它们都可以利用
函数 cvIntegral 从 8-比特或浮点数单通道的输入图像中得到。
sqsum
单通道 64 比特图像的平方和图像
tilted_sum
单通道 32 比特整数格式的图像的倾斜和（Tilted sum）
scale
cascade 的窗口比例. 如果 scale=1, 就只用原始窗口尺寸检测 (只检测同样尺寸大小的目
标物体 ) - 原始窗口尺寸在函数 cvLoadHaarClassifierCascade 中定义 ( 在
""中缺省为 24x24), 如果 scale=2, 使用的窗口是上面的两倍 (在 face
cascade 中缺省值是 48x48 )。这样尽管可以将检测速度提高四倍，但同时尺寸小于 48x48
的人脸将不能被检测到。
函数 cvSetImagesForHaarClassifierCascade 为 hidden classifier cascade
指定图像 and/or 窗口比例系数。如果图像指针为空，会继续使用原来的图像
(i.e. NULLs 意味这"不改变图像")。比例系数没有 "protection" 值,但是原来
的值可以通过函数 cvGetHaarClassifierCascadeScale 重新得到并使用。这个
函数用于对特定图像中检测特定目标尺寸的 cascade 分类器的设定。函数通过
cvHaarDetectObjects 进行内部调用，但当需要在更低一层的函数
cvRunHaarClassifierCascade 中使用的时候，用户也可以自行调用。

cvRunHaarClassifierCascade
在给定位置的图像中运行
cascade of boosted classifier
int cvRunHaarClassifierCascade( CvHaarClassifierCascade* cascade,
CvPoint pt, int start_stage=0 );

cascade
Haar 级联分类器
pt
待检测区域的左上角坐标。待检测区域大小为原始窗口尺寸乘以当前设定的比例系数。当前
窗口尺寸可以通过 cvGetHaarClassifierCascadeWindowSize 重新得到。
start_stage
级联层的初始下标值（从 0 开始计数）。函数假定前面所有每层的分类器都已通过。这个特
征通过函数 cvHaarDetectObjects 内部调用，用于更好的处理器高速缓冲存储器。
函数 cvRunHaarHaarClassifierCascade 用于对单幅图片的检测。在函数调用前
首先利用 cvSetImagesForHaarClassifierCascade 设定积分图和合适的比例系
数 (=> 窗口尺寸)。当分析的矩形框全部通过级联分类器每一层的时返回正值
(这是一个候选目标)，否则返回 0 或负值。

照相机定标和三维重建

照相机定标

CalibrateCamera
对相机单精度定标

void cvCalibrateCamera( int image_count, int* point_counts, CvSize
image_size,
CvPoint2D32f* image_points, CvPoint3D32f*
object_points,
CvVect32f distortion_coeffs, CvMatr32f
camera_matrix,
CvVect32f translation_vectors, CvMatr32f
rotation_matrixes,
int use_intrinsic_guess );

image_count
图像个数。
point_counts
每副图像定标点个数的数组
image_size
图像大小
image_points
指向图像的指针
object_points
指向检测目标的指针
distortion_coeffs
寻找到四个变形系数的数组。
camera_matrix
相机参数矩阵。Camera matrix found.
translation_vectors
每个图像中模式位置的平移矢量矩阵。
rotation_matrixes
图像中模式位置的旋转矩阵。
use_intrinsic_guess
是否使用内部猜测（Intrinsic guess）. 设为 1，则使用
函数 cvCalibrateCamera 利用目标图像模式和目标模式的象素点信息计算相机
参数。

CalibrateCamera_64d
相机双精度定标

void cvCalibrateCamera_64d( int image_count, int* point_counts, CvSize
image_size,
CvPoint2D64d* image_points, CvPoint3D64d*
object_points,
CvVect64d distortion_coeffs, CvMatr64d
camera_matrix,
CvVect64d translation_vectors, CvMatr64d
rotation_matrixes,
int use_intrinsic_guess );

image_count
图像个数
point_counts
每副图像定标点数目的数组
image_size
图像大小
image_points
图像指针
object_points
模式对象指针 Pointer to the pattern.
distortion_coeffs
寻找变形系数 Distortion coefficients found.
camera_matrix
相机矩阵 Camera matrix found.
translation_vectors
图像中模式位置的平移矢量矩阵
rotation_matrixes
图像中每个模式位置的旋转矩阵
use_intrinsic_guess
Intrinsic guess. If equal to 1, intrinsic guess is needed.
函数 cvCalibrateCamera_64d 跟函数 cvCalibrateCamera 用法基本相同，不过
cvCalibrateCamera_64d 使用的是双精度类型。

Rodrigues
进行旋转矩阵和旋转向量间的转换，采用单精度。

void cvRodrigues( CvMat* rotation_matrix, CvMat* rotation_vector,
CvMat* jacobian, int conv_type);

rotation_matrix
旋转矩阵(3x3), 32-比特 or 64-比特浮点数
rotation_vector
跟旋转矩阵相同类型的旋转向量(3x1 or 1x3)
jacobian
雅可比矩阵 3 × 9
conv_type
转换方式；设定为 CV_RODRIGUES_M2V，矩阵转化为向量。CV_RODRIGUES_V2M 向量转化
为矩阵
函数 cvRodrigues 进行旋转矩阵和旋转向量之间的相互转换。

UnDistortOnce
校正相机镜头变形
Corrects camera lens distortion
void cvUnDistortOnce( const CvArr* src, CvArr* dst,
const float* intrinsic_matrix,
const float* distortion_coeffs,
int interpolate=1 );

src
原图像(变形图像)
dst
目标图像 (校正)图像.
intrinsic_matrix
相机的内参数矩阵(3x3).
distortion_coeffs
向量的四个变形系数 k 1 , k 2 , p 1 和 p 2 .
interpolate
双线性卷积标志。
函数 cvUnDistortOnce 校正单幅图像的镜头变形。相机的内置参数矩阵和变形
系数 k 1 , k 2 , p 1 ,和 p 2 事先由函数 cvCalibrateCamera 计算得到。

UnDistortInit
计算畸变点数组和插值系数
Calculates arrays of distorted points indices and interpolation
coefficients
void cvUnDistortInit( const CvArr* src, CvArr* undistortion_map,
const float* intrinsic_matrix,
const float* distortion_coeffs,
int interpolate=1 );

src
任意的原图像(变形图形)，图像的大小要和通道数匹配。
undistortion_map
32-比特整数的图像，如果 interpolate=0，与输入图像尺寸相同，如果 interpolate=1，
是输入图像的 3 倍
intrinsic_matrix
摄像机的内参数矩阵
distortion_coeffs
向量的 4 个变形系数 k 1 , k 2 , p 1 and p 2
interpolate
双线性卷积标志
函数 cvUnDistortInit 利用摄像机内参数和变形系数计算畸变点指数数组和插
值系数。为函数 cvUnDistort 计算非畸变图。
摄像机的内参数矩阵和变形系数可以由函数 cvCalibrateCamera 计算。

UnDistort
校正相机镜头变形
Corrects camera lens distortion
void cvUnDistort( const CvArr* src, CvArr* dst,
const CvArr* undistortion_map, int interpolate=1 );

src
原图像(变形图像)
dst
目标图像(校正后图像)
undistortion_map
未变形图像，由函数 cvUnDistortInit 提前计算
interpolate
双线性卷积标志，与函数 cvUnDistortInit 中相同。
函数 cvUnDistort 提前计算出的未变形图校正相机镜头变形，速度比函数
cvUnDistortOnce 快。（利用先前计算出的非变形图来校正摄像机的镜头变形。
速度比函数 cvUnDistortOnce 快）

FindChessBoardCornerGuesses
发现棋盘内部角点的大概位置

int cvFindChessBoardCornerGuesses( const CvArr* image, CvArr* thresh,
CvMemStorage* storage, CvSize
board_size,
CvPoint2D32f* corners, int*
corner_count=NULL );

image
输入的棋盘图像，象素位数为 IPL_DEPTH_8U.
thresh
临时图像，与输入图像的大小、格式一样
storage
中间数据的存储区，如果为空，函数生成暂时的内存区域。
board_size
棋盘每一行和每一列的内部角点数目。宽（列数目）必须小于等于高（行数目）
corners
角点数组的指针
corner_count
带符号的已发现角点数目. 正值表示整个棋盘的角点都以找到，负值表示不是所有的角点都
被找到。
函数 cvFindChessBoardCornerGuesses 试图确定输入图像是否是棋盘视图，并
且确定棋盘的内部角点。如果所有角点都被发现，函数返回非零值，并且将角点
按一定顺序排列（逐行由左到右），否则，函数返回零。例如一个简单棋盘有 8
x 8 方块和 7 x 7 内部方块相切的角点。单词“大概 approximate" 表示发现
的角点坐标与实际坐标会有几个象素的偏差。为得到更精确的坐标，可使用函数
cvFindCornerSubPix.

姿态估计

FindExtrinsicCameraParams
为模式寻找摄像机外参数矩阵

void cvFindExtrinsicCameraParams( int point_count, CvSize image_size,
CvPoint2D32f* image_points,
CvPoint3D32f* object_points,
CvVect32f focal_length, CvPoint2D32f
principal_point,
CvVect32f distortion_coeffs,
CvVect32f rotation_vector,
CvVect32f translation_vector );

point_count
点的个数
ImageSize
图像大小
image_points
图像指针
object_points
模式指针 Pointer to the pattern.
focal_length
焦距
principal_point
基点
distortion_coeffs
变形系数。
rotation_vector
旋转向量
translation_vector
平移向量
函数 cvFindExtrinsicCameraParams 寻找模式的摄像机外参数矩阵

FindExtrinsicCameraParams_64d
以双精度形式寻找照相机外参数
Finds extrinsic camera parameters for pattern with double
precision
void cvFindExtrinsicCameraParams_64d( int point_count, CvSize
image_size,
CvPoint2D64d* image_points,
CvPoint3D64d* object_points,
CvVect64d focal_length,
CvPoint2D64d principal_point,
CvVect64d distortion_coeffs,
CvVect64d rotation_vector,
CvVect64d translation_vector );

point_count
点的个数
ImageSize
图像尺寸
image_points
图像指针
object_points
模式指针 Pointer to the pattern.
focal_length
焦距
principal_point
基点
distortion_coeffs
变形系数
rotation_vector
旋转向量
translation_vector
平移向量
函数 cvFindExtrinsicCameraParams_64d 建立对象模式的外参数，双精度。

CreatePOSITObject
初始化目标信息
Initializes structure containing object information
CvPOSITObject* cvCreatePOSITObject( CvPoint3D32f* points, int
point_count );

points
指向 3D 对象模型的指针
point_count
目标对象的点数
函数 cvCreatePOSITObject 为对象结构分配内存并计算对象的逆矩阵。
预处理的对象数据存储在结构 CvPOSITObject 中，通过 OpenCV 内部调用，即用
户不能直接得到得到数据结构。用户只可以创建这个结构并将指针传递给函数。
对象是一系列给定坐标的像素点，函数 cvPOSIT 计算从照相机坐标系到目标点
points[0] 之间的向量。
当完成上述对象的工作以后，必须使用函数 cvReleasePOSITObject 释放内存。

POSIT
执行
POSIT
算法。
Implements POSIT algorithm
void cvPOSIT( CvPOSITObject* posit_object, CvPoint2D32f* image_points,
double focal_length,
CvTermCriteria criteria, CvMatr32f rotation_matrix,
CvVect32f translation_vector );

posit_object
指向对象结构的指针
image_points
指针，指向目标像素点在二维平面图上的投影。
focal_length
使用的摄像机的焦距
criteria
POSIT 迭代算法程序终止的条件
rotation_matrix
旋转矩阵
translation_vector
平移矩阵 Translation vector.
函数 cvPOSIT 执行 POSIT 算法。图像坐标在摄像机坐标系统中给出。焦距可以
通过摄像机标定得到。算法每一次迭代都会重新计算在估计位置的透视投影。
两次投影之间的范式差值是对应点间的最大距离。如果差值过小，参数
criteria.epsilon 就会终止程序。

ReleasePOSITObject
释放
3D
对象结构

void cvReleasePOSITObject( CvPOSITObject** posit_object );

posit_object
指向 CvPOSIT structure 双指针
函数 cvReleasePOSITObject 释放函数 cvCreatePOSITObject 分配的内存。

CalcImageHomography
计算长方形或椭圆形平面对象的单应矩阵
(
例如，胳膊
) Calculates homography matrix for oblong
planar object (e.g. arm)
void cvCalcImageHomography( float* line, CvPoint3D32f* center,
float* intrinsic, float* homography );

line
主要对象的轴方向 (vector (dx,dy,dz)).
center
对象坐标中心 ((cx,cy,cz)).
intrinsic
摄像机内参数 (3x3 matrix).
homography
输出的单应矩阵(3x3).
函数 cvCalcImageHomography 计算初始图像由图像平面到 3D oblong object
line 界定的平面转换的单应矩阵。 (察看 OpenCV 指南中的 3D 重建一章 Figure
6-10 )

外极线几何

FindFundamentalMat
计算图像中对应点的基本矩阵

int cvFindFundamentalMat( CvMat* points1,
CvMat* points2,
CvMat* fundamental_matrix,
int method,
double param1,
double param2,
CvMat* status=0);

points1
第一幅图像点的数组 2xN/Nx2 或 3xN/Nx3 (N 点的个数). 点坐标应该是浮点数(双精度或
单精度)。
points2
第二副图像的点的数组，格式、大小与第一幅图像相同。
fundamental_matrix
输出的基本矩阵。大小是 3x3 or 9x3 (7-point method can returns up to 3 matrices).
method
计算基本矩阵的方法
CV_FM_7POINT - for 7-point algorithm. Number of points == 7
CV_FM_8POINT - for 8-point algorithm. Number of points >= 8
CV_FM_RANSAC - for RANSAC algorithm. Number of points >= 8
CV_FM_LMEDS - for LMedS algorithm. Number of points >= 8
param1
这个参数只用于方法 RANSAC 或 LMedS 。它是点到外极线的最大距离，超过这个值的点
将被舍弃，不用于后面的计算。通常这个值的设定是 0.5 or 1.0 。
param2
这个参数只用于方法 RANSAC 或 LMedS 。它表示矩阵在某种精度上的正确的理想值。
例如可以被设为 0.99 。
status
N 个元素的数组, 在计算过程中没有被舍弃的点，元素被被置为 1。否则置为 0。数组由方法
RANSAC and LMedS 计算。其它方法的时候 status 被置为 1's。这个参数是可选的。 Th
外极线几何可以用下面的等式描述:
p 2
T *F*p 1 =0,
其中 F 是基本矩阵，ip 1 和 p 2 分别是两幅图上的对应点。
函数 FindFundamentalMat 利用上面列出的四种方法之一计算基本矩阵，并返回
基本矩阵的值：没有找到矩阵，返回 0，找到一个矩阵返回 1，多个矩阵返回 3。
基本矩阵可以用来进一步计算两幅图像的对应外极点的坐标。
7 点法使用确定的 7 个点。这种方法能找到 1 个或者 3 个基本矩阵，返回矩阵的
个数；如果目标数组中有足够的空间存储所有检测到的矩阵，该函数将所有矩阵
存储，否则，只存贮其中之一。其它方法使用 8 点或者更多点并且返回一个基本
矩阵。
Example. Fundamental matrix calculation
int point_count = 100;
CvMat* points1;
CvMat* points2;
CvMat* status;
CvMat* fundamental_matrix;

points1 = cvCreateMat(2,point_count,CV_32F);
points2 = cvCreateMat(2,point_count,CV_32F);
status = cvCreateMat(1,point_count,CV_32F);

/* Fill the points here ... */

fundamental_matrix = cvCreateMat(3,3,CV_32F);
int num =
cvFindFundamentalMat(points1,points2,fundamental_matrix,CV_FM_RANSAC,
1.0,0.99,status);
if( num == 1 )
{
printf("Fundamental matrix was found\n");
}
else
{
printf("Fundamental matrix was not found\n");
}

/*====== Example of code for three matrixes ======*/
CvMat* points1;
CvMat* points2;
CvMat* fundamental_matrix;

points1 = cvCreateMat(2,7,CV_32F);
points2 = cvCreateMat(2,7,CV_32F);

/* Fill the points here... */

fundamental_matrix = cvCreateMat(9,3,CV_32F);
int num =
cvFindFundamentalMat(points1,points2,fundamental_matrix,CV_FM_7POINT,
0,0,0);
printf("Found %d matrixes\n",num);

ComputeCorrespondEpilines
根据一幅图像中的点计算其在另一幅图像中对应的外极线。

void cvComputeCorrespondEpilines( const CvMat* points,
int which_image,
const CvMat* fundamental_matrix,
CvMat* correspondent_lines);

points
输入点: 2xN or 3xN array (N 点的个数)
which_image
包含点的图像指数(1 or 2)
fundamental_matrix
基本矩阵
correspondent_lines
计算外极点, 3xN array
函数 ComputeCorrespondEpilines 根据外级线几何的基本方程计算每个输入点
的对应外级线。如果点位于第一幅图像(which_image=1),对应的外极线可以如下
计算 :
l 2 =F*p 1
其中 F 是基本矩阵，p 1 是第一幅图像中的点， l 2 - 是与第二幅对应的外极线。如果点位于
第二副图像中 which_image=2)，计算如下:
l 1 =F T *p 2
其中 p 2 是第二幅图像中的点，l 1 是对应于第一幅图像的外极线
每条外极线都可以用三个系数表示 a, b, c:
a*x + b*y + c = 0
归一化后的外极线系数存储在 correspondent_lines.

按字母顺序的函数列表

2
2DRotationMatrix

A
Acc ApproxChains ArcLength
AdaptiveThreshold ApproxPoly

B
BoundingRect BoxPoints

C
CalcBackProject CalibrateCamera ConvexityDefects
CalcBackProjectPatch CalibrateCamera_64d CopyHist
CalcEMD2 CamShift CornerEigenValsAndVecs
CalcGlobalOrientation Canny CornerMinEigenVal
CalcHist CheckContourConvexity CreateConDensation
CalcImageHomography ClearHist CreateContourTree
CalcMotionGradient ClearSubdivVoronoi2D CreateHist
CalcOpticalFlowBM CompareHist CreateKalman
CalcOpticalFlowHS ComputeCorrespondEpilines CreatePOSITObject
CalcOpticalFlowLK ConDensInitSampleSet CreateStructuringElementEx
CalcOpticalFlowPyrLK ConDensUpdateByTime CreateSubdivDelaunay2D
CalcPGH ContourArea CvtColor
CalcProbDensity ContourFromContourTree
CalcSubdivVoronoi2D ConvexHull2

D
Dilate DistTransform

E
EndFindContours Erode

F
Filter2D FindExtrinsicCameraParams FindNextContour
FindChessBoardCornerGuesses FindExtrinsicCameraParams_64d FitEllipse
FindContours FindFundamentalMat FitLine2D
FindCornerSubPix FindNearestPoint2D FloodFill

G
GetCentralMoment GetMinMaxHistValue GetRectSubPix
GetHistValue_1D GetNormalizedCentralMoment GetSpatialMoment
GetHuMoments GetQuadrangleSubPix GoodFeaturesToTrack

H
HaarDetectObjects HoughLines

I
InitLineIterator Integral

K
KalmanCorrect KalmanPredict

L
Laplace LoadHaarClassifierCascade

M
MakeHistHeaderForArray MaxRect Moments
MatchContourTrees MeanShift MorphologyEx
MatchShapes MinAreaRect2 MultiplyAcc
MatchTemplate MinEnclosingCircle

N
NormalizeHist

P
POSIT PyrDown PyrUp
PreCornerDetect PyrSegmentation

Q
QueryHistValue_1D

R
ReadChainPoint ReleaseKalman Rodrigues
ReleaseConDensation ReleasePOSITObject RunHaarClassifierCascade
ReleaseHaarClassifierCascade ReleaseStructuringElement RunningAvg
ReleaseHist Resize

S
SampleLine Sobel Subdiv2DGetEdge
SegmentMotion SquareAcc Subdiv2DLocate
SetHistBinRanges StartFindContours Subdiv2DRotateEdge
SetImagesForHaarClassifierCascade StartReadChainPoints SubdivDelaunay2DInsert
Smooth Subdiv2DEdgeDst SubstituteContour
SnakeImage Subdiv2DEdgeOrg

T
ThreshHist Threshold

U
UnDistort UnDistortOnce
UnDistortInit UpdateMotionHistory

W
WarpAffine WarpPerspective WarpPerspectiveQMatrix

参考书目
下面的参考书目列出了对于 Intel Computer Vision Library 用户的一些有用的
出版物。目录不是很全，只作为一个学习的起点。
1. [Borgefors86] Gunilla Borgefors, "Distance Transformations in Digital Images". Computer
Vision, Graphics and Image Processing 34, 344-371 (1986).
2. [Bouguet00] Jean-Yves Bouguet. Pyramidal Implementation of the Lucas Kanade Feature
Tracker.
The paper is included into OpenCV distribution (algo_tracking.pdf)
3. [Bradski98] G.R. Bradski. Computer vision face tracking as a component of a perceptual
user interface. In Workshop on Applications of Computer Vision, pages 214?19, Princeton,
NJ, Oct. 1998.
Updated version can be found at
http://www.intel.com/technology/itj/q21998/articles/art_2.htm.
Also, it is included into OpenCV distribution (camshift.pdf)
4. [Bradski00] G. Bradski and J. Davis. Motion Segmentation and Pose Recognition with
Motion History Gradients. IEEE WACV'00, 2000.
5. [Burt81] P. J. Burt, T. H. Hong, A. Rosenfeld. Segmentation and Estimation of Image
Region Properties Through Cooperative Hierarchical Computation. IEEE Tran. On SMC,
Vol. 11, N.12, 1981, pp. 802-809.
6. [Canny86] J. Canny. A Computational Approach to Edge Detection, IEEE Trans. on Pattern
Analysis and Machine Intelligence, 8(6), pp. 679-698 (1986).
7. [Davis97] J. Davis and Bobick. The Representation and Recognition of Action Using
Temporal Templates. MIT Media Lab Technical Report 402, 1997.
8. [DeMenthon92] Daniel F. DeMenthon and Larry S. Davis. Model-Based Object Pose in 25
Lines of Code. In Proceedings of ECCV '92, pp. 335-343, 1992.
9. [Fitzgibbon95] Andrew W. Fitzgibbon, R.B.Fisher. A Buyer's Guide to Conic Fitting.
Proc.5th British Machine Vision Conference, Birmingham, pp. 513-522, 1995.
10. [Horn81] Berthold K.P. Horn and Brian G. Schunck. Determining Optical Flow. Artificial
Intelligence, 17, pp. 185-203, 1981.
11. [Hu62] M. Hu. Visual Pattern Recognition by Moment Invariants, IRE Transactions on
Information Theory, 8:2, pp. 179-187, 1962.
12. [Iivarinen97] Jukka Iivarinen, Markus Peura, Jaakko Srel, and Ari Visa. Comparison of
Combined Shape Descriptors for Irregular Objects, 8th British Machine Vision
Conference, BMVC'97.
http://www.cis.hut.fi/research/IA/paper/publications/bmvc97/bmvc97.html
13. [Jahne97] B. Jahne. Digital Image Processing. Springer, New York, 1997.
14. [Lucas81] Lucas, B., and Kanade, T. An Iterative Image Registration Technique with an
Application to Stereo Vision, Proc. of 7th International Joint Conference on Artificial
Intelligence (IJCAI), pp. 674-679.
15. [Kass88] M. Kass, A. Witkin, and D. Terzopoulos. Snakes: Active Contour Models,
International Journal of Computer Vision, pp. 321-331, 1988.
16. [Lienhart02] Rainer Lienhart and Jochen Maydt. An Extended Set of Haar-like Features
for Rapid Object Detection. IEEE ICIP 2002, Vol. 1, pp. 900-903, Sep. 2002.
This paper, as well as the extended technical report, can be retrieved at
http://www.lienhart.de/Publications/publications.html
17. [Matas98] J.Matas, C.Galambos, J.Kittler. Progressive Probabilistic Hough Transform.
British Machine Vision Conference, 1998.
18. [Rosenfeld73] A. Rosenfeld and E. Johnston. Angle Detection on Digital Curves. IEEE
Trans. Computers, 22:875-878, 1973.
19. [RubnerJan98] Y. Rubner. C. Tomasi, L.J. Guibas. Metrics for Distributions with
Applications to Image Databases. Proceedings of the 1998 IEEE International Conference
on Computer Vision, Bombay, India, January 1998, pp. 59-66.
20. [RubnerSept98] Y. Rubner. C. Tomasi, L.J. Guibas. The Earth Mover's Distance as a
Metric for Image Retrieval. Technical Report STAN-CS-TN-98-86, Department of
Computer Science, Stanford University, September 1998.
21. [RubnerOct98] Y. Rubner. C. Tomasi. Texture Metrics. Proceeding of the IEEE
International Conference on Systems, Man, and Cybernetics, San-Diego, CA, October
1998, pp. 4601-4607. http://robotics.stanford.edu/~rubner/publications.html
22. [Serra82] J. Serra. Image Analysis and Mathematical Morphology. Academic Press, 1982.
23. [Schiele00] Bernt Schiele and James L. Crowley. Recognition without Correspondence
Using Multidimensional Receptive Field Histograms. In International Journal of
Computer Vision 36 (1), pp. 31-50, January 2000.
24. [Suzuki85] S. Suzuki, K. Abe. Topological Structural Analysis of Digital Binary Images
by Border Following. CVGIP, v.30, n.1. 1985, pp. 32-46.
25. [Teh89] C.H. Teh, R.T. Chin. On the Detection of Dominant Points on Digital Curves. -
IEEE Tr. PAMI, 1989, v.11, No.8, p. 859-872.
26. [Trucco98] Emanuele Trucco, Alessandro Verri. Introductory Techniques for 3-D
Computer Vision. Prentice Hall, Inc., 1998.
27. [Viola01] Paul Viola and Michael J. Jones. Rapid Object Detection using a Boosted
Cascade of Simple Features. IEEE CVPR, 2001.
The paper is available online at http://www.ai.mit.edu/people/viola/
28. [Welch95] Greg Welch, Gary Bishop. An Introduction To the Kalman Filter. Technical
Report TR95-041, University of North Carolina at Chapel Hill, 1995.
Online version is available at
http://www.cs.unc.edu/~welch/kalman/kalman_filter/kalman.html
29. [Williams92] D. J. Williams and M. Shah. A Fast Algorithm for Active Contours and
Curvature Estimation. CVGIP: Image Understanding, Vol. 55, No. 1, pp. 14-26, Jan., 1992.
http://www.cs.ucf.edu/~vision/papers/shah/92/WIS92A.pdf.
30. [Yuille89] A.Y.Yuille, D.S.Cohen, and P.W.Hallinan. Feature Extraction from Faces Using
Deformable Templates in CVPR, pp. 104-109, 1989.
31. [Zhang96] Z. Zhang. Parameter Estimation Techniques: A Tutorial with Application to
Conic Fitting, Image and Vision Computing Journal, 1996.
32. [Zhang99] Z. Zhang. Flexible Camera Calibration By Viewing a Plane From Unknown
Orientations. International Conference on Computer Vision (ICCV'99), Corfu, Greece,
pages 666-673, September 1999.
33. [Zhang00] Z. Zhang. A Flexible New Technique for Camera Calibration. IEEE
Transactions on Pattern Analysis and Machine Intelligence, 22(11):1330-1334, 2000.

CXCORE 参考手册

HUNNISH 注：
本翻译是直接根据 OpenCV Beta 4.0 版本的用户手册翻译的，原文件是：
/doc/ref/opencvref_cxcore.htm, 可以从 SOURCEFORG 上面的
OpenCV 项目下载，也可以直接从阿须数码中下载：
http://www.assuredigit.com/incoming/sourcecode/opencv/chinese_docs/ref/open
cvref_cxcore.htm。
翻译中肯定有不少错误，另外也有些术语和原文语义理解不透导致翻译不准确或者错
误，也请有心人赐教。
翻译由 Y.Q.Zhang, J.H.Tan, X.C.Qin, M.Liu 和 Z.T.Fan 鼎力完成，全文由 Hunnish
做统一修改校正。
翻译由张兆翔，于示琪进一步校正完成。

• 基础结构
• 数组操作
o 初始化
o 获取元素和数组子集
o 拷贝和填充
o 变换和置换
o 算术、逻辑和比较
o 统计
o 线性代数
o 数学函数
o 随机数生成
o 离散变换
• 动态结构
o 内存存储
o 序列
o 集合
o 图
o 树－－－－－－－－－－－－－－－－－－－－－－－
• 绘图函数 ****************************************
o 曲线和形状
o 文本
o 点集和轮廓
• 数据保存和运行时类型信息
o 文件存储
o 写数据
o 读数据
o 运行时类型信息和通用函数－－－－－－－－－－－－－－－
• 其它混合函数 *********************************************
• 错误处理和系统函数
o 错误处理
o 系统函数
• 依字母顺序函数列表
• 例子列表－－－－－－－－－－－－－－－－－－－－－－－－－－－

基础结构

CvPoint
基于二维整形坐标轴的点

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
二维浮点坐标上的点

typedef struct CvPoint2D32f
{
float x; /* X 坐标, 通常以 0 为基点*/
float y; /* Y 坐标, 通常以 0 为基点*/
}
CvPoint2D32f;
/* 构造函数 */
inline CvPoint2D32f cvPoint2D32f( double x, double y );
/* 从 CvPoint 转换来 */
inline CvPoint2D32f cvPointTo32f( CvPoint point );

CvPoint3D32f
三维浮点坐标上的点

typedef struct CvPoint3D32f
{
float x; /* x-坐标，通常基于 0 */
float y; /* y-坐标, 通常基于 0*/
float z; /* z-坐标，通常基于 0 */
}
CvPoint3D32f;

/* 构造函数 */
inline CvPoint3D32f cvPoint3D32f( double x, double y, double z );

CvPoint2D64f
2D point with double precision floating-point coordinates
typedef struct CvPoint2D64f
{
double x; /* x-坐标，通常基于 0 */
double y; /* y-坐标，通常基于 0 */
}
CvPoint2D64f;

/* 构造函数 */
inline CvPoint2D64f cvPoint2D64f( double x, double y );

/* 从 CvPoint 转换得来 */
inline CvPoint2D64f cvPointTo64f( CvPoint point );

CvPoint3D64f
3D point with double precision floating-point coordinates
typedef struct CvPoint3D64f
{
double x; /* x-坐标，通常基于 0 */
double y; /* y-坐标，通常基于 0 */
double z; /* z-坐标，通常基于 0 */
}
CvPoint3D64f;

/* 构造函数 */
inline CvPoint3D64f cvPoint3D64f( double x, double y, double z );

CvSize
矩形框大小，以像素为精度

typedef struct CvSize
{
int width; /* 矩形宽 */
int height; /* 矩形高 */
}
CvSize;

/* 构造函数 */
inline CvSize cvSize( int width, int height );

CvSize2D32f
以低像素精度标量矩形框大小

typedef struct CvSize2D32f
{
float width; /* 矩形宽 */
float height; /* 矩形高 */
}
CvSize2D32f;

/* 构造函数*/
inline CvSize2D32f cvSize2D32f( double width, double height );

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

CvScalar
可存放在
1-
，
2-
，
3-
，
4-TUPLE
类型的捆绑数据的容器

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

/* 构造函数：用 val0 初始化 val[0]用 val1 初始化 val[1]等等*/
inline CvScalar cvScalar( double val0, double val1=0,
double val2=0, double val3=0 );
/* 构造函数：用 val0123 初始化 val0123 */
inline CvScalar cvScalarAll( double val0123 );

/* 构造函数：用 val0 初始化 val[0],val[1]…val[3]用 0 初始化 */
inline CvScalar cvRealScalar( double val0 );

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 和 epsilon 限制条件 */
CvTermCriteria cvCheckTermCriteria( CvTermCriteria criteria,
double default_eps,
int default_max_iters );

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; /* 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; /* 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; /* HASH 表节点池 */
void** hashtable; /* HASH 表:每个入口有一个节点列表，有相同的 "以 HASH
大小为模板的 HASH 值" */
int hashsize; /* HASH 表大小 */
int total; /* 稀疏数组的节点数 */
int valoffset; /* 数组节点值在字节中的偏移 */
int idxoffset; /* 数组节点索引在字节中的偏移 */
int size[CV_MAX_DIM]; /*维大小 */

} CvSparseMat;

IplImage
IPL
图像头

typedef struct _IplImage
{
int nSize; /* 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
and IPL_DEPTH_64F 可支持 */
char colorModel[4]; /* 被 OpenCV 忽略 */
char channelSeq[4]; /* 同上 */
int dataOrder; /* 0 - 交叉存取颜色通道, 1 - 分开的颜色通道.
只有 cvCreateImage 可以创建交叉存取图像 */
int origin; /* 0 - 顶—左结构,
1 - 底—左结构 (Windows bitmaps 风格) */
int align; /* 图像行排列 (4 or 8). OpenCV 忽略它，使用
widthStep 代替 */
int width; /* 图像宽像素数 */
int height; /* 图像高像素数*/
struct _IplROI *roi;/* 图像感兴趣区域. 当该值非空只对该区域进行处理
*/
struct _IplImage *maskROI; /* 在 OpenCV 中必须置 NULL */
void *imageId; /* 同上*/
struct _IplTileInfo *tileInfo; /*同上*/
int imageSize; /* 图像数据大小(在交叉存取格式下
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
只支持其中的一个子集:
• alpha 通道在 OpenCV 中被忽略.
• colorModel 和 channelSeq 被 OpenCV 忽略. OpenCV 颜色转换的唯一个函数
cvCvtColor 把原图像的颜色空间的目标图像的颜色空间作为一个参数.
• 数据顺序必须是 IPL_DATA_ORDER_PIXEL (颜色通道是交叉存取), 然面平面图像的被选
择通道可以被处理，就像 COI（感兴趣的通道）被设置过一样.
• 当 widthStep 被用于去接近图像行序列，排列是被 OpenCV 忽略的.
• 不支持 maskROI . 处理 MASK 的函数把他当作一个分离的参数. MASK 在 OpenCV 里是
8-bit, 然而在 IPL 他是 1-bit.
• 名字信息不支持.
• 边际模式和边际常量是不支持的. 每个 OpenCV 函数处理像素的邻近的像素，通常使
用单一的固定代码边际模式.
除了上述限制, OpenCV 处理 ROI 有不同的要求.要求原图像和目标图像的尺寸或 ROI 的尺寸必须
（根据不同的作操，例如 cvPyrDown 目标图像的宽（高）必须等于原图像的宽（高）除 2 ±1)精确
匹配,而 IPL 处理交叉区域，如图像的大小或 ROI 大小可能是完全独立的。

CvArr
不确定数组

typedef void CvArr;
CvArr* 仅仅是被用于作函数的参数，用于指示函数接收的数组类型可以不止一个，如
IplImage*, CvMat* 甚至 CvSeq*. 最终的数组类型是在运行时通过分析数组头的前 4
个字节判断。

数组操作

初始化

CreateImage
创建头并分配数据

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

CreateImageHeader
分配，初始化，并且返回
IplImage
结构

IplImage* cvCreateImageHeader( CvSize size, int depth, int channels );
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 函数不是作为默认的 (见 CV_TURN_ON_IPL_COMPATIBILITY 宏)

ReleaseImageHeader
释放头

void cvReleaseImageHeader( IplImage** image );
image
双指针指向头内存分配单元.
函数 cvReleaseImageHeader 释放头. 相似于
if( image )
{
iplDeallocate( *image, IPL_IMAGE_HEADER | IPL_IMAGE_ROI );
*image = 0;
}
然而 IPL 函数不是作为默认的 (见 CV_TURN_ON_IPL_COMPATIBILITY 宏)

ReleaseImage
释放头和图像数据

void cvReleaseImage( IplImage** image );
image
双指针指向图像内存分配单元。
函数 cvReleaseImage 释放头和图像数据，相似于：
if( *image )
{
cvReleaseData( *image );
cvReleaseImageHeader( image );
}

InitImageHeader
初始他被用图分配的图像头

IplImage* cvInitImageHeader( IplImage* image, CvSize size, int depth,
int channels, int origin=0, int align=4 );
image
被初始化的图像头.
size
图像的宽高.
depth
像深(见 CreateImage).
channels
通道数(见 CreateImage).
origin
IPL_ORIGIN_TL 或 IPL_ORIGIN_BL.
align
图像行排列, 典型的 4 或 8 字节.
函数 cvInitImageHeader 初始他图像头结构, 指向用户指定的图像并且返回这个指
针。

CloneImage
制作图像的完整拷贝

IplImage* cvCloneImage( const IplImage* image );
image
原图像.
函数 cvCloneImage 制作图像的完整拷贝包括头、ROI 和数据

SetImageCOI
基于给定的值设置感兴趣通道

void cvSetImageCOI( IplImage* image, int coi );
image
图像头.
coi
感兴趣通道.
函数 cvSetImageCOI 基于给定的值设置感兴趣的通道。值 0 意味着所有的通道都被选
定, 1 意味着第一个通道被选定等等。如果 ROI 是 NULL 并且 COI!= 0, ROI 被分配.
然而大多数的 OpenCV 函数不支持 COI, 对于这种状况当处理分离图像/矩阵通道时，
可以拷贝（通过 cvCopy 号 cvSplit) 通道来分离图像/矩阵，处理后如果需要可再拷
贝（通过 cvCopy 或 cvCvtPlaneToPix）回来.

GetImageCOI
返回感兴趣通道号

int cvGetImageCOI( const IplImage* image );
image
图像头.
函数 cvGetImageCOI 返回图像的感兴趣通道（当所有的通道都被选中返回值是 0).

SetImageROI
基于给定的矩形设置感兴趣区域

void cvSetImageROI( IplImage* image, CvRect rect );
image
图像头.
rect
ROI 矩形.
函数 cvSetImageROI 基于给定的矩形设置图像的 ROI（感兴趣区域） . 如果 ROI 是
NULL 并且参数 RECT 的值不等于整个图像, ROI 被分配. 不像 COI, 大多数的 OpenCV
函数支持 ROI 并且处理它就行它是一个分离的图像 (例如, 所有的像素坐标从 ROI 的
顶-左或底-左角（基于图像的结构）计算。

ResetImageROI
释放图偈的
ROI
void cvResetImageROI( IplImage* image );
image
图像头.
函数 cvResetImageROI 释放图像 ROI. 释放之后整个图像被认为是全部被选中的。相
似的结果可以通过下述办法
cvSetImageROI( image, cvRect( 0, 0, image->width, image->height ));
cvSetImageCOI( image, 0 );
但是后者的变量不分配 image->roi.

GetImageROI
返回图像的
ROI
坐标

CvRect cvGetImageROI( const IplImage* image );
image
图像头.
函数 cvGetImageROI 返回图像 ROI 坐标. 如果没有 ROI 则返回矩形值为
cvRect(0,0,image->width,image->height)

CreateMat
创建矩阵

CvMat* cvCreateMat( int rows, int cols, int type );
rows
矩阵行数.
cols
矩阵列数.
type
矩阵元素类型. 通常以 CV_(S|U|F)C型式描述,
例如:
CV_8UC1 意思是一个 8-bit 无符号单通道矩阵, CV_32SC2 意思是一个 32-bit 有符号二个通
道的矩阵.
函数 cvCreateMat 为新的矩阵分配头和下面的数据, 并且返回一个指向新创建的矩阵
的指针. 是下列操作的缩写型式:
CvMat* mat = cvCreateMatHeader( rows, cols, type );
cvCreateData( mat );
矩阵按行存贮. 所有的行以 4 个字节排列。

CreateMatHeader
创建新的矩阵头

CvMat* cvCreateMatHeader( int rows, int cols, int type );
rows
矩阵行数.
cols
矩阵列数.
type
矩阵元素类型(见 cvCreateMat).
函数 cvCreateMatHeader 分配新的矩阵头并且返回指向它的指针. 矩阵数据可被进一
步的分配，使用 cvCreateData 或通过 cvSetData 明确的分配数据.

ReleaseMat
删除矩阵

void cvReleaseMat( CvMat** mat );
mat
双指针指向矩阵.
函数 cvReleaseMat 缩减矩阵数据参考计数并且释放矩阵头 :
if( *mat )
cvDecRefData( *mat );
cvFree( (void**)mat );

InitMatHeader
初始化矩阵头

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 矩阵函数
用于处理原始数据。
例如, 下面的代码计算通用数组格式存贮的数据的矩阵乘积.
计算两个矩阵的积
double a[] = { 1, 2, 3, 4
5, 6, 7, 8,
9, 10, 11, 12 };

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

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

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

cvMatMulAdd( &Ma, &Mb, 0, &Mc );
// c 数组存贮 a(3x4) 和 b(4x3) 矩阵的积

Mat
初始化矩阵的头
(
轻磅变量
)
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 );

CloneMat
创建矩阵拷贝

CvMat* cvCloneMat( const CvMat* mat );
mat
输入矩阵.
函数 cvCloneMat 创建输入矩阵的一个拷贝并且返回该矩阵的指针.

CreateMatND
创建多维密集数组

CvMatND* cvCreateMatND( int dims, const int* sizes, int type );
dims
数组维数. 但不许超过 CV_MAX_DIM (默认=32，但这个默认值可能在编译时被改变 )的定
义
sizes
数组的维大小.
type
数组元素类型. 与 CvMat 相同
函数 cvCreateMatND 分配头给多维密集数组并且分配下面的数据，返回指向被创建数组
的指针 . 是下列的缩减形式:
CvMatND* mat = cvCreateMatNDHeader( dims, sizes, type );
cvCreateData( mat );
矩阵按行存贮. 所有的行以 4 个字节排列。.

CreateMatNDHeader
创建新的数组头

CvMatND* cvCreateMatNDHeader( int dims, const int* sizes, int type );
dims
数组维数.
sizes
维大小.
type
数组元素类型. 与 CvMat 相同
函数 cvCreateMatND 分配头给多维密集数组。数组数据可以用 cvCreateData 进一步的
被分配或利用 cvSetData 由用户明确指定.

ReleaseMatND
删除多维数组

void cvReleaseMatND( CvMatND** mat );
mat
指向数组的双指针.
函数 cvReleaseMatND 缩减数组参考计数并释放数组头:
if( *mat )
cvDecRefData( *mat );
cvFree( (void**)mat );

InitMatNDHeader
初始化多维数组头

CvMatND* cvInitMatNDHeader( CvMatND* mat, int dims, const int* sizes, int type,
void* data=NULL );
mat
指向要被出初始化的数组头指针.
dims
数组维数.
sizes
维大小.
type
数组元素类型. 与 CvMat 相同
data
可选的分配给矩阵头的数据指针.
函数 cvInitMatNDHeader 初始化用户指派的 CvMatND 结构.

CloneMatND
创建多维数组的完整拷贝

CvMatND* cvCloneMatND( const CvMatND* mat );
mat
输入数组
函数 cvCloneMatND 创建输入数组的拷贝并返回指针.

DecRefData
缩减数组数据的参考计数

void cvDecRefData( CvArr* arr );
arr
数组头.
函数 cvDecRefData 缩减 CvMat 或 CvMatND 数据的参考计数，如参考计数指针非 NULL
并且计数到 0 就删除数据，在当前的执行中只有当数据是用 cvCreateData 分配的参考
计算才会是非 NULL，换句话说 :
使用 cvSetData 指派外部数据给头
矩阵头代表部分大的矩阵或图像
矩阵头是从图像头或 N 维矩阵头转换过来的。
参考计数如果被设置成 NULL 就不会被缩减. 无论数据是否被删除,数据指针和参考计数
指针都将被这个函数清空。

IncRefData
增加数组数据的参考计数

int cvIncRefData( CvArr* arr );
arr
数组头.
函数 cvIncRefData 增加 CvMat 或 CvMatND 数据参考计数，如果参考计数非空返回新
的计数值否则返回 0。

CreateData
分配数组数据

void cvCreateData( CvArr* arr );
arr
数组头.
函数 cvCreateData 分配图像，矩阵或多维数组数据. 对于矩阵类型使用 OpenCV 的分
配函数，对于 IplImage 类型如果 CV_TURN_ON_IPL_COMPATIBILITY 没有被调用也是可以
使用这种方法的反之使用 IPL 函数分配数据

ReleaseData
释放数组数据

void cvReleaseData( CvArr* arr );
arr
数组头
函数 cvReleaseData 释放数组数据. 对于 CvMat 或 CvMatND 结构只需调用
cvDecRefData(), 也就是说这个函数不能删除外部数据。见 cvCreateData.

SetData
指派用户数据给数组头

void cvSetData( CvArr* arr, void* data, int step );
arr
数组头.
data
用户数据.
step
整行字节长.
函数 cvSetData 指派用记数据给数组头. 头应该已经使用 cvCreate*Header,
cvInit*Header 或 cvMat (对于矩阵)初始化过.

GetRawData
返回组数的底层信息

void cvGetRawData( const CvArr* arr, uchar** data,
int* step=NULL, CvSize* roi_size=NULL );
arr
数组头.
data
输出指针，指针指向整个图像的结构或 ROI
step
输出行字节长
roi_size
输出 ROI 尺寸
函数 cvGetRawData 添充给输出变量数组的底层信息。所有的输出参数是可选的 , 因
此这些指针可设为 NULL. 如果数组是设置了 ROI 的 IplImage 结构, ROI 参数被返回。
接下来的例子展示怎样去接近数组元素。
使用 GetRawData 计算单通道浮点数组的元素绝对值.
float* data;
int step;

CvSize size;
int x, y;

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

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

GetMat
从不确定数组返回矩阵头

CvMat* cvGetMat( const CvArr* arr, CvMat* header, int* coi=NULL, int allowND=0 );
arr
输入数组.
header
指向 CvMat 结构的指针，作为临时缓存 .
coi
可选的输出参数，用于输出 COI.
allowND
如果非 0，函数就接收多维密集数组 (CvMatND*)并且返回 2D (如果 CvMatND 是二维的）
或 1D 矩阵(当 CvMatND 是一维或多于二维). 数组必须是连续的.
函数 cvGetMat 从输入的数组生成矩阵头，输入的数组可以是 - CvMat 结构, IplImage
结构或多维密集数组 CvMatND* (后者只有当 allowND != 0 时才可以使用) . 如果是
矩阵函数只是返回指向矩阵的指针.如果是 IplImage* 或 CvMatND* 函数用当前图像
的 ROI 初始化头结构并且返回指向这个临时结构的指针。因为 CvMat 不支持 COI，所以
他们的返回结果是不同的.
这个函数提供了一个简单的方法，用同一代码处理 IplImage 和 CvMat 二种数据类型。
这个函数的反向转换可以用 cvGetImage 将 CvMat 转换成 IplImage .
输入的数组必须有已分配好的底层数据或附加的数据，否则该函数将调用失败
如果输入的数组是 IplImage 格式，使用平面式数据编排并设置了 COI，函数返回的指针指向被选
定的平面并设置 COI=0.利用 OPENCV 函数对于多通道平面编排图像可以处理每个平面。

GetImage
从不确定数组返回图像头

IplImage* cvGetImage( const CvArr* arr, IplImage* image_header );
arr
输入数组.
image_header
指向 IplImage 结构的指针，该结构存贮在一个临时缓存 .
函数 cvGetImage 从输出数组获得图头，该数组可是以矩阵- CvMat*, 或图像 -
IplImage*. 如果是图像函数只是返回输入参数的指针，如是查 CvMat* 函数用输入参
数矩阵初始化图像头。因此如果我们把 IplImage 转换成 CvMat 然后再转换 CvMat
回 IplImage,如果 ROI 被设置过了我们可能会获得不同的头，这样一些计算图像跨度的
IPL 函数就会失败。

CreateSparseMat
创建稀疏数组

CvSparseMat* cvCreateSparseMat( int dims, const int* sizes, int type );
dims
数组维数。相对于密集型矩阵，稀疏数组的维数是不受限制的（最多可达 2 16 ).
sizes
数组的维大小.
type
数组元素类型，见 CvMat
函数 cvCreateSparseMat 分配多维稀疏数组. Initially the array contain no
elements, that is cvGet*D or cvGetReal*D return zero for every index

ReleaseSparseMat
删除稀疏数组

void cvReleaseSparseMat( CvSparseMat** mat );
mat
双指针指向数组。
函数 cvReleaseSparseMat 释放稀疏数组并清空数组指针

CloneSparseMat
创建稀疏数组的拷贝

CvSparseMat* cvCloneSparseMat( const CvSparseMat* mat );
mat
输放的数组。
函数 cvCloneSparseMat 创建输入数组的拷贝并返回指向这个拷贝的指针.

获取元素和数组子集

GetSubRect
根据输入的图像或矩阵的矩形数组子集返回矩阵头

CvMat* cvGetSubRect( const CvArr* arr, CvMat* submat, CvRect rect );
arr
输入数组
submat
指针指向结果数组头 Pointer to the resultant sub-array header.
rect
以 0 坐标为基准的 ROI.
函数 cvGetSubRect 根据指定的数组矩形返回矩阵头，换句话说，函数允许处理输入数
组的指定的一个子矩形，就像一个独立的数组一样进行处理。函数在处理时要考虑进输
入数组的 ROI，因此数组的 ROI 是实际上被提取的。

GetRow, GetRows
返回数组的行或在一定跨度内的行

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 );
arr
输入数组.
submat
指向返回的子数组头的指针.
row
被选定的行号下标，以 0 为基准.
start_row
跨度的开始行（包括此行）索引下标，以 0 为下标基准
end_row
跨度的结束行（不包括此行）索引下标，以 0 为下标基准.
delta_row
在跨度内的索引下标跨步，从开始行到结束行每隔 delta_row 行提取一行。
函数 GetRow 和 GetRows 根据指定的行或跨度从输入数组中返回对应的头。 GetRow 是
cvGetRows 的缩写:
cvGetRow( arr, submat, row ) ~ cvGetRows( arr, submat, row, row + 1, 1 );

GetCol, GetCols
返回数组的列或一定跨度内的列

CvMat* cvGetCol( const CvArr* arr, CvMat* submat, int col );
CvMat* cvGetCols( const CvArr* arr, CvMat* submat, int start_col, int end_col );
arr
输入数组
submat
指向结果子数组头指针.
col
选定的列索引下标，该下标以 0 为基准。
start_col
跨度的开始列（包括该列）索引下标，该下标以 0 为基准。
end_col
跨度的结束列（不包括该列）索引下标，该下标以 0 为基准。
函数 GetCol 和 GetCols 根据指定的列/列跨度返回头。GetCol 是 cvGetCols 的缩写
形式:
cvGetCol( arr, submat, col ); // ~ cvGetCols( arr, submat, col, col + 1 );

GetDiag
返回一个数组对角线

CvMat* cvGetDiag( const CvArr* arr, CvMat* submat, int diag=0 );
arr
输入数组.
submat
指向结果子集的头指针.
diag
数组对角线。0 是主对角线，-1 是主对角线上面对角线，1 是主对角线下对角线，以此类推。
函数 cvGetDiag 根据指定的 diag 参数返回数组的对角线头。

GetSize
返回图像或矩阵
ROI
大小

CvSize cvGetSize( const CvArr* arr );
arr
数组头.
函数 cvGetSize 返回矩阵或图像的行数和列数，如果是图像就返回 ROI 的大小

InitSparseMatIterator
初始化稀疏数线元素迭代器

CvSparseNode* cvInitSparseMatIterator( const CvSparseMat* mat,
CvSparseMatIterator* mat_iterator );
mat
输入的数组.
mat_iterator
被初始化迭代器.
函数 cvInitSparseMatIterator 初始化稀疏数组元素的迭代器并且返回指向第一个元
素的指针，如果数组为空则返回 NULL。

GetNextSparseNode
初始化稀疏数线元素迭代器

CvSparseNode* cvGetNextSparseNode( CvSparseMatIterator* mat_iterator );
mat_iterator
稀疏数组的迭代器
函数 cvGetNextSparseNode 移动迭代器到下一个稀疏矩阵元素并返回指向他的指针。在
当前的版本不存在任何元素的特殊顺序，因为元素是按 HASH 表存贮的下面的列子描述
怎样在稀疏矩阵上迭代 :
利用 cvInitSparseMatIterator 和 cvGetNextSparseNode 计算浮点稀疏数组
的和。
double sum;
int i, dims = cvGetDims( array );
CvSparseMatIterator mat_iterator;
CvSparseNode* node = cvInitSparseMatIterator( array, &mat_iterator );

for( ; node != 0; node = cvGetNextSparseNode( &mat_iterator ))
{
int* idx = CV_NODE_IDX( array, node ); /* get pointer to the element
indices */
float val = *(float*)CV_NODE_VAL( array, node ); /* get value of the
element
(assume that the
type is CV_32FC1) */
printf( "(" );
for( i = 0; i < dims; i++ )
printf( "%4d%s", idx[i], i < dims - 1 "," : "): " );
printf( "%g\n", val );

sum += val;
}

printf( "\nTotal sum = %g\n", sum );

GetElemType
返回数组元素类型

int cvGetElemType( const CvArr* arr );
arr
输入数组.
函数 GetElemType 返回数组元素类型就像在 cvCreateMat 中讨论的一样:
CV_8UC1 ... CV_64FC4

GetDims, GetDimSize
返回数组维数和他们的大小或者殊维的大小

int cvGetDims( const CvArr* arr, int* sizes=NULL );
int cvGetDimSize( const CvArr* arr, int index );
arr
输入数组.
sizes
可选的输出数组维尺寸向量，对于 2D 数组第一位是数组行数（高），第二位是数组列数（宽）
index
以 0 为基准的维索引下标（对于矩阵 0 意味着行数，1 意味着列数，对于图象 0 意味着高，1
意味着宽。
函数 cvGetDims 返回维数和他们的大小。如果是 IplImage 或 CvMat 总是返回 2，不
管图像/矩阵行数。函数 cvGetDimSize 返回特定的维大小（每维的元素数）。例如，
接下来的代码使用二种方法计算数组元素总数。
// via cvGetDims()
int sizes[CV_MAX_DIM];
int i, total = 1;
int dims = cvGetDims( arr, size );
for( i = 0; i < dims; i++ )
total *= sizes[i];

// via cvGetDims() and cvGetDimSize()
int i, total = 1;
int dims = cvGetDims( arr );
for( i = 0; i < dims; i++ )
total *= cvGetDimsSize( arr, i );

Ptr*D
返回指向特殊数组元素的指针

uchar* cvPtr1D( const CvArr* arr, int idx0, int* type=NULL );
uchar* cvPtr2D( const CvArr* arr, int idx0, int idx1, int* type=NULL );
uchar* cvPtr3D( const CvArr* arr, int idx0, int idx1, int idx2, int* type=NULL );
uchar* cvPtrND( const CvArr* arr, int* idx, int* type=NULL, int create_node=1,
unsigned* precalc_hashval=NULL );
arr
输入数组.
idx0
元素下标的第一个以 0 为基准的成员
idx1
元素下标的第二个以 0 为基准的成员
idx2
元素下标的第三个以 0 为基准的成员
idx
数组元素下标
type
可选的，矩阵元素类型输出参数
create_node
可选的，为稀疏矩阵输入的参数。如果这个参数非零就意味着被需要的元素如果不存在就会
被创建。
precalc_hashval
可选的，为稀疏矩阵设置的输入参数。如果这个指针非 NULL，函数不会重新计算节点的
HASH 值，而是从指定位置获取。这种方法有利于提高智能组合数据的操作（TODO: 提供
了一个例子)
函数 cvPtr*D 返回指向特殊数组元素的指针。数组维数应该与转递给函数物下标数相匹
配，除了 cvPtr1D 函数，它可以被用于顺序存取的 1D，2D 或 nD 密集数组
函数也可以用于稀疏数组，并且如果被需要的节点不存在函数可以创建这个节点并设置
为 0
就像其它获取数组元素的函数 (cvGet[Real]*D, cvSet[Real]*D)如果元素的下标超出
了范围就会产生错误

Get*D
返回特殊的数组元素

CvScalar cvGet1D( const CvArr* arr, int idx0 );
CvScalar cvGet2D( const CvArr* arr, int idx0, int idx1 );
CvScalar cvGet3D( const CvArr* arr, int idx0, int idx1, int idx2 );
CvScalar cvGetND( const CvArr* arr, int* idx );
arr
输入数组.
idx0
元素下标第一个以 0 为基准的成员
idx1
元素下标第二个以 0 为基准的成员
idx2
元素下标第三个以 0 为基准的成员
idx
元素下标数组
函数 cvGet*D 返回指定的数组元素。对于稀疏数组如果需要的节点不存在函数返回 0
（不会创建新的节点）

GetReal*D
返回单通道数组的指定元素

double cvGetReal1D( const CvArr* arr, int idx0 );
double cvGetReal2D( const CvArr* arr, int idx0, int idx1 );
double cvGetReal3D( const CvArr* arr, int idx0, int idx1, int idx2 );
double cvGetRealND( const CvArr* arr, int* idx );
arr
输入数组，必须是单通道.
idx0
元素下标的第一个成员，以 0 为基准
idx1
元素下标的第二个成员，以 0 为基准
idx2
元素下标的第三个成员，以 0 为基准
idx
元素下标数组
函数 cvGetReal*D 返回单通道数组的指定元素，如果数组是多通道的，就会产生运行时
错误，而 cvGet*D 函数可以安全的被用于单通道和多通道数组，但他们运行时会有点
慢
如果指定的点不存在对于稀疏数组点会返回 0（不会创建新的节点）。

mGet
返回单通道浮点矩阵指定元素

double cvmGet( const CvMat* mat, int row, int col );
mat
输入矩阵.
row
行下标，以 0 为基点.
col
列下标，以 0 为基点
函数 cvmGet 是 cvGetReal2D 对于单通道浮点矩阵的快速替代函数，函数运行比较快速
因为它是内连函数，这个函数对于数组类型、数组元素类型的检查作的很少，并且仅
在调式模式下检查数的行和列范围。

Set*D
修改指定的数组

void cvSet1D( CvArr* arr, int idx0, CvScalar value );
void cvSet2D( CvArr* arr, int idx0, int idx1, CvScalar value );
void cvSet3D( CvArr* arr, int idx0, int idx1, int idx2, CvScalar value );
void cvSetND( CvArr* arr, int* idx, CvScalar value );
arr
输入数组
idx0
元素下标的第一个成员，以 0 为基点
idx1
元素下标的第二个成员，以 0 为基点
idx2
元素下标的第三个成员，以 0 为基点
idx
元素下标数组
value
指派的值
函数 cvSet*D 指定新的值给指定的数组元素。对于稀疏矩阵如果指定节点不存在函数
创建新的节点

SetReal*D
修改指定数组元素值

void cvSetReal1D( CvArr* arr, int idx0, double value );
void cvSetReal2D( CvArr* arr, int idx0, int idx1, double value );
void cvSetReal3D( CvArr* arr, int idx0, int idx1, int idx2, double value );
void cvSetRealND( CvArr* arr, int* idx, double value );
arr
输入数组.
idx0
元素下标的第一个成员，以 0 为基点
idx1
元素下标的第二个成员，以 0 为基点
idx2
元素下标的第三个成员，以 0 为基点
idx
元素下标数组
value
指派的值
函数 cvSetReal*D 分配新的值给单通道数组的指定元素，如果数组是多通道就会产生
运行时错误。然而 cvSet*D 可以安全的被用于多通道和单通道数组，只是稍微有点慢。
对于稀疏数组如果指定的节点不存在函数会创建该节点。

mSet
返回单通道浮点矩阵的指定元素

void cvmSet( CvMat* mat, int row, int col, double value );
mat
矩阵.
row
行下标,以 0 为基点.
col
列下标,以 0 为基点.
value
矩阵元素的新值
函数 cvmSet 是 cvSetReal2D 快速替代,对于单通道浮点矩阵因为这个函数是内连的所
以比较快,函数对于数组类型、数组元素类型的检查作的很少，并且仅在调式模式下检
查数的行和列范围。

ClearND
清除指定数组元素

void cvClearND( CvArr* arr, int* idx );
arr
输入数组.
idx
数组元素下标
函数 cvClearND 清除指定密集型数组的元素(置 0)或删除稀疏数组的元素 ,如果元素不
存在函数不作任何事

拷贝和添加

Copy
拷贝一个数组给另一个数组

void cvCopy( const CvArr* src, CvArr* dst, const CvArr* mask=NULL );
src
输入数组.
dst
输出数组
mask
Operation mask, 8-bit single channel array; specifies elements of destination array to be changed.
函数 cvCopy copies selected elements from input array to output array:
dst(I)=src(I) if mask(I)!=0.
If any of the passed arrays is of IplImage type, then its ROI and COI fields
are used. Both arrays must have the same type, the same number of dimensions
and the same size. 函数 can also copy sparse arrays (mask is not supported in
this case).

Set
Sets every element of array to given value
void cvSet( CvArr* arr, CvScalar value, const CvArr* mask=NULL );
arr
The destination array.
value
Fill value.
mask
操作覆盖面,8 位单通道数组 ; 输出数组中的覆盖面指定元素被除数修改.
函数 cvSet 拷贝数量值到输出数组的每一个被除数选定的元素:
arr(I)=value if mask(I)!=0
如果数组 arr 是 IplImage 类型, 那么就会使用 ROI,但 COI 不能设置 .

SetZero
清空数组

void cvSetZero( CvArr* arr );
#define cvZero cvSetZero
arr
要被清空数组.
函数 cvSetZero 清空数组. 对于密集型号数组(CvMat, CvMatND or IplImage)
cvZero(array) 就相当于 cvSet(array,cvScalarAll(0),0), 对于稀疏数组所有的元
素都将被删除.

变换和置换

Reshape
不拷贝数据修改矩阵
/
图像形状

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 值修改输出数组
函数 cvReshape 初始化 CvMat 头 header 以便于让头指向修改后的形状（但数据保持
原样）-也就是说修改通道数,修改行数或者两者者改变.
例如, 接下来的代码创建一个图像缓存、两个图像头，第一个是 320x240x3 图像第二
个是 960x240x1 图像:
IplImage* color_img = cvCreateImage( cvSize(320,240), IPL_DEPTH_8U, 3 );
CvMat gray_mat_hdr;
IplImage gray_img_hdr, *gray_img;
cvReshape( color_img, &gray_mat_hdr, 1 );
gray_img = cvGetImage( &gray_mat_hdr, &gray_img_hdr );
下一个例子转换 3x3 矩阵成单向量 1x9
CvMat* mat = cvCreateMat( 3, 3, CV_32F );
CvMat row_header, *row;
row = cvReshape( mat, &row_header, 0, 1 );

ReshapeMatND
修改多维数组形状，拷贝
/
不拷贝数据

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 是不被使用的
函数 cvReshapeMatND 是 cvReshape 的高级版本，它可以处理多维数组（能够呛处理通
用的图像和矩阵）并且修改维数，下面的是使用 cvReshapeMatND 重写 cvReshape 的二
个例子：
IplImage* color_img = cvCreateImage( cvSize(320,240), IPL_DEPTH_8U, 3 );
IplImage gray_img_hdr, *gray_img;
gray_img = (IplImage*)cvReshapeND( color_img, &gray_img_hdr, 1, 0, 0 );

...

/*second example is modified to convert 2x2x2 array to 8x1 vector */
int size[] = { 2, 2, 2 };
CvMatND* mat = cvCreateMatND( 3, size, CV_32F );
CvMat row_header, *row;
row = cvReshapeND( mat, &row_header, 0, 1, 0 );

Repeat
用原数组管道式添充输出数组

void cvRepeat( const CvArr* src, CvArr* dst );
src
输入数组, 图像或矩阵。
dst
输出数组，图像或矩阵
函数 cvRepeat 使用被管道化的原数组添充输出数组：
dst(i,j)=src(i mod rows(src), j mod cols(src))
因此，输出数组可能小于输入数组

Flip
垂直，水平或即垂直又水平翻转二维数组

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

src
原数组.
dst
目标责任制数组. 如果 dst = NULL 翻转是在内部替换.
flip_mode
指定怎样去翻转数组。
flip_mode = 0 沿 X-轴翻转, flip_mode > 0 (如 1) 沿 Y-轴翻转， flip_mode < 0 (如 -1) 沿 X-
轴和 Y-轴翻转.见下面的公式
函数 cvFlip 以三种方式之一翻转数组 (行和列下标是以 0 为基点的):
dst(i,j)=src(rows(src)-i-1,j) if flip_mode = 0
dst(i,j)=src(i,cols(src1)-j-1) if flip_mode > 0
dst(i,j)=src(rows(src)-i-1,cols(src)-j-1) if flip_mode < 0
函数主要使用在:
• 垂直翻转图像(flip_mode > 0)用于顶-左和底-左图像结构的转换, 主要用于 WIN32 系统下的
视频操作处理.
• 水平图像转换，使用连续的水平转换和绝对值差检查垂直轴对称（flip_mode > 0)
• 水平和垂直同时转换，用于连续的水平转换和绝对真理值差检查中心对称 s(flip_mode < 0)
• 翻转 1 维指针数组的顺序(flip_mode > 0)

Split
分割多通道数组成几个单通道数组或者从数组中提取一个通道

void cvSplit( const CvArr* src, CvArr* dst0, CvArr* dst1,
CvArr* dst2, CvArr* dst3 );
#define cvCvtPixToPlane cvSplit
src
原数组.
dst0...dst3
目标通道
函数 cvSplit 分割多通道数组成分离的单通道数组 d。可获得两种操作模式 . 如果原
数组有 N 通道且前 N 输出数组非 NULL, 所有的通道都会被从原数组中提取，如果前 N
个通道只有一个通道非 NULL 函数只提取该指定通道，否则会产生一个错误，余下的通
道（超过前 N 个通道的以上的）必须被设置成 NULL，对于设置了 COI 的 IplImage 结使
用 cvCopy 也可以从图像中提取单通道。

Merge
从几个单通道数组组合多通道数组或插入一个单通到数组

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，就拷贝所有通道到输出数组，如果在前 N 个通道中只有一个单通道非 NULL ，
只拷贝这个通道到输出数组，否则就会产生错误。除前 N 通道以外的余下的通道必须
置 NULL。对于设置了 COI 的 IplImage 结构使用 cvCopy 也可以实现向图像中插入一个
通道。

算术，逻辑和比较

LUT
利用搜索表转换数组

void cvLUT( const CvArr* src, CvArr* dst, const CvArr* lut );
src
元素为 8 位的原数组。
dst
与原数组有相同通道数的输出数组，深度不确定
lut
有 256 个元素的搜索表;必须要与原输出数组有想同像深。
函数 cvLUT 使用搜索中的值添充输出数组. 坐标入口来自于原数组，也就是说函数处理
每个元素按如下方式：
dst(I)=lut[src(I)+DELTA]
这里当 src 的深度是 CV_8U 时 DELTA=0 ,src 的深度是 CV_8S 时 DELTA=128

ConvertScale
使用线性变换转换数组

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

#define cvCvtScale cvConvertScale
#define cvScale cvConvertScale
#define cvConvert( src, dst ) cvConvertScale( (src), (dst), 1, 0 )
src
原数组.
dst
输出数组
scale
比例因子.
shift
原数组元素按比例缩放后添加的值。
函数 cvConvertScale 有多个不同的目的因此就有多个意义，函数按比例从一个数组中
拷贝元素到另一个元素这种操作是最先执行的，或者任意的类型转换，正如下面的操作：
dst(I)=src(I)*scale + (shift,shift,...)
多通道的数组对各个地区通道是独立处理的。
类型转换主要用于舍入和饱合度，也就是如果缩放后的结果+转换值不能用输出数组元
素类型值精确表达，就设置成最接近该数的值到真正的坐标轴上。
如果 scale=1, shift=0 就不会进行比例缩放. 这是一个特殊的优化，相当
cvConvert 。如果原和输出数组的类型相同这同样也是一另一种情形，函数可以被用于
比例化并且移动矩阵或图像这就变成 cvScale 的同义词了。

ConvertScaleAbs
使用线性变换转换输入数组元素成
8位无符号整型

void cvConvertScaleAbs( const CvArr* src, CvArr* dst, double scale=1, double
shift=0 );
#define cvCvtScaleAbs cvConvertScaleAbs
src
原数组
dst
输出数组 (深度为 8u).
scale
比例因子.
shift
原数组元素按比例缩放后添加的值。
函数 cvConvertScaleAbs 与前一函数是相同的，但它是存贮变换结果的绝对值：
dst(I)=abs(src(I)*scale + (shift,shift,...))
函数只支持目标数数组的深度为 8u (8-bit 无符号) , 对于别的类型函数仿效于
cvConvertScale 和 cvAbs 函数的联合

Add
计算两个数中每个元素的和

void cvAdd( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr*
mask=NULL );
src1
第一个原数组
src2
第二个原数组
dst
输出数组
mask
操作的覆盖面, 8-bit 单通道数组; 只有覆盖面指定的输出数组被修改。
函数 cvAdd 加一个数组到别一个数组中：
dst(I)=src1(I)+src2(I) if mask(I)!=0
除覆盖面外所有的数组必须有相同的类型相同的大小（或 ROI 尺寸）。

AddS
计算数量和数组的和

void cvAddS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr*
mask=NULL );
src
原数组.
value
被加入数量
dst
输出数组
mask
操作的覆盖面（8-bit 单通道数组） ; 只有覆盖面指定的输出数组被修改
函数 cvAddS 用数量值与原数组 src1 的每个元素想加并存贮结果到
dst(I)=src(I)+value if mask(I)!=0
除覆盖面外所有数组都必须有相同的类型，相同的大小（或 ROI 大小）

AddWeighted
计算两数组的加磅值的和

void cvAddWeighted( const CvArr* src1, double alpha,
const CvArr* src2, double beta,
double gamma, CvArr* dst );
src1
第一个原数组.
alpha
第一个数组元素的磅值
src2
第二个原数组
beta
第二个数组元素的磅值
dst
输出数组
gamma
作和合添加的数量。
函数 cvAddWeighted 计算两数组的加磅值的和：
dst(I)=src1(I)*alpha+src2(I)*beta+gamma
所有的数组必须的相同的类型相同的大小（或 ROI 大小）

Sub
计算两个数组每个元素的差

void cvSub( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr*
mask=NULL );
src1
第一个原数组
src2
第二个原数组.
dst
输出数组.
mask
操作覆盖面（ 8-bit 单通道数组）; 只有覆盖面指定的输出数组被修改
函数 cvSub 从一个数组减去别一个数组:
dst(I)=src1(I)-src2(I) if mask(I)!=0
除覆盖面外所有数组都必须有相同的类型，相同的大小（或 ROI 大小）

SubS
计算数组和数量之间的差

void cvSubS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr*
mask=NULL );
src
原数组.
value
被减的数量.
dst
输出数组.
mask
操作覆盖面（ 8-bit 单通道数组）; 只有覆盖面指定的输出数组被修改
函数 cvSubS 从原数组的每个元素中减去一个数量：
dst(I)=src(I)-value if mask(I)!=0
除覆盖面外所有数组都必须有相同的类型，相同的大小（或 ROI 大小）。

SubRS
计算数量和数组之间的差

void cvSubRS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr*
mask=NULL );
src
第一个原数组。
value
被减的数量
dst
输出数组
mask
操作覆盖面（ 8-bit 单通道数组）; 只有覆盖面指定的输出数组被修改
函数 cvSubRS 从一个数量减去原数组的每个元素：
dst(I)=value-src(I) if mask(I)!=0
除覆盖面外所有数组都必须有相同的类型，相同的大小（或 ROI 大小）。

Mul
计算两个数组中每个元素的积

void cvMul( const CvArr* src1, const CvArr* src2, CvArr* dst, double scale=1 );
src1
第一个原数组.
src2
第二个原数组.
dst
输出数组.
scale
设置的比例因子
函数 cvMul 计算两个数组中每个元素的积：
dst(I)=scale•src1(I)•src2(I)
所有的数组必须有相同的类型和相同的大小（或 ROI 大小）

Div
两个数组每个元素相除

void cvDiv( const CvArr* src1, const CvArr* src2, CvArr* dst, double scale=1 );
src1
第一个原数组。如该指针为 NULL，假高该数组的所有元素都为 1
src2
第二个原数组。
dst
输出数组
scale
设置的比例因子
函数 cvDiv 用一个数组除以另一个数组:
dst(I)=scale•src1(I)/src2(I), if src1!=NULL
dst(I)=scale/src2(I), if src1=NULL
所有的数组必须有相同的类型和相同的大小（或 ROI 大小）

And
计算两个数组的每个元素的按位与

void cvAnd( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr*
mask=NULL );
src1
第一个原数组
src2
第二个原数组.
dst
输出数组
mask
操作覆盖面（ 8-bit 单通道数组）; 只有覆盖面指定的输出数组被修改
函数 cvAnd 计算两个数组的每个元素的按位逻辑与：
dst(I)=src1(I)&src2(I) if mask(I)!=0
对浮点数组按位表示操作是很有利的。除覆盖面，所有数组都必须有相同的类型，相同
的大小（或 ROI 大小）。

AndS
计算数组每个元素与数量之间的按位与

void cvAndS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr*
mask=NULL );
src
原数组.
value
操作中用到的数量
dst
输出数组
mask
操作覆盖面（ 8-bit 单通道数组）; 只有覆盖面指定的输出数组被修改
函数 AndS 计算数组中每个元素与数量之量的按位与：
dst(I)=src(I)&value if mask(I)!=0
在实际操作之前首先把数量类型转换成与数组相同的类型。对浮点数组按位表示操作是
很有利的。除覆盖面，所有数组都必须有相同的类型，相同的大小（或 ROI 大小）。
接下来的例子描述怎样计算浮点数组元素的绝对值，通过清除最前面的符号位：
float a[] = { -1, 2, -3, 4, -5, 6, -7, 8, -9 };
CvMat A = cvMat( 3, 3, CV_32F, &a );
int i, abs_mask = 0x7fffffff;
cvAndS( &A, cvRealScalar(*(float*)&abs_mask), &A, 0 );
for( i = 0; i < 9; i++ )
printf("%.1f ", a[i] );
代码结果是:
1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0

Or
计算两个数组每个元素的按位或

void cvOr( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr*
mask=NULL );
src1
第一个原数组
src2
第二个原数组
dst
输出数组.
mask
操作覆盖面（ 8-bit 单通道数组）; 只有覆盖面指定的输出数组被修改
函数 cvOr 计算两个数组每个元素的按位或：
dst(I)=src1(I)|src2(I)
对浮点数组按位表示操作是很有利的。除覆盖面，所有数组都必须有相同的类型，相同
的大小（或 ROI 大小）。

OrS
计算数组中每个元素与数量之间的按位或

void cvOrS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr*
mask=NULL );
src1
原数组
value
操作中用到的数量
dst
目数组.
mask
操作覆盖面（ 8-bit 单通道数组）; 只有覆盖面指定的输出数组被修改
函数 OrS 计算数组中每个元素和数量之间的按位或：
dst(I)=src(I)|value if mask(I)!=0
在实际操作之前首先把数量类型转换成与数组相同的类型。对浮点数组按位表示操作是
很有利的。除覆盖面，所有数组都必须有相同的类型，相同的大小（或 ROI 大小）。

Xor
计算两个数组中的每个元素的按位异或

void cvXor( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr*
mask=NULL );
src1
第一个原数组
src2
第二个原数组.
dst
输出数组
mask
操作覆盖面（ 8-bit 单通道数组）; 只有覆盖面指定的输出数组被修改
函数 cvXor 计算两个数组元素的按位异或：
dst(I)=src1(I)^src2(I) if mask(I)!=0
对浮点数组按位表示操作是很有利的。除覆盖面，所有数组都必须有相同的类型，相同
的大小（或 ROI 大小）。

XorS
计算数组元素与数量之间的按位异或

void cvXorS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr*
mask=NULL );
src
原数组
value
操作中用到的数量
dst
输出数组.
mask
操作覆盖面（ 8-bit 单通道数组）; 只有覆盖面指定的输出数组被修改。
函数 XorS 计算数组元素与数量之间的按位异或：
dst(I)=src(I)^value if mask(I)!=0
在实际操作之前首先把数量类型转换成与数组相同的类型。对浮点数组按位表示操作是
很有利的。除覆盖面，所有数组都必须有相同的类型，相同的大小（或 ROI 大小）。
下面例子描述怎样对共轭复数向量转换，通过转换前面的符号位：
float a[] = { 1, 0, 0, 1, -1, 0, 0, -1 }; /* 1, j, -1, -j */
CvMat A = cvMat( 4, 1, CV_32FC2, &a );
int i, neg_mask = 0x80000000;
cvXorS( &A, cvScalar( 0, *(float*)&neg_mask, 0, 0 ), &A, 0 );
for( i = 0; i < 4; i++ )
printf("(%.1f, %.1f) ", a[i*2], a[i*2+1] );
The code should print:
(1.0,0.0) (0.0,-1.0) (-1.0,0.0) (0.0,1.0)

Not
计算数组元素的按位取反

void cvNot( const CvArr* src, CvArr* dst );
src1
原数组
dst
输出数组
函数不取反每个数组元素的每一位
dst(I)=~src(I)

Cmp
比较两个数组元素
P
void cvCmp( const CvArr* src1, const CvArr* src2, CvArr* dst, int cmp_op );
src1
第一个原数组
src2
第二个原数组，这两个数组必须有一个单通道
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 '!='.
如果元素之间的关系为真则设置 dst(I)为 0xff (也就是所有的位都为 '1') 否则为 0。
除了输出数组所有数组必须是相同的类型相同的大小（或 ROI 大小）。

CmpS
比较数组的每个元素与数量的关系

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
函数 cvCmpS 比较数组元素与数量并且添充目标覆盖面数组：
dst(I)=src(I) op scalar,
这里 op 是 '=', '>', '>=', '<', '<=' or '!='.
如果元素之间的关系为真则设置 dst(I)为 0xff (也就是所有的位都为 '1') 否则为 0。
所有的数组必须有相同的大小（或 ROI 大小）

InRange
检查数组元素是否在两个数组之间

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
对二通道数组，以此类推
如果 src(I) 在范围内 dst(I)被设置为 0xff (每一位都是 '1')否则置 0 。除了输出
数组所有数组必须是相同的类型相同的大小（或 ROI 大小）。

InRangeS
检查数组元素是否在两个数量之间

void cvInRangeS( const CvArr* src, CvScalar lower, CvScalar upper, CvArr* dst );
src
第一个原数组
lower
包括进的下边界.
upper
不包括进的上边界
dst
输出数组必须是 8u 或 8s 类型.
函数 cvInRangeS 检查输入数组元素范围：
dst(I)=lower 0 <= src(I) 0 < upper 0
对于单通道数组：
dst(I)=lower 0 <= src(I) 0 < upper 0 &&
lower 1 <= src(I) 1 < upper 1
对于双通道数组以此类推
如果 src(I) 在范围内 dst(I)被设置为 0xff (每一位都是 '1')否则置 0 。所有的数
组必须有相同的大小（或 ROI 大小）

Max
查找两个数组中每个元素的较大值

void cvMax( const CvArr* src1, const CvArr* src2, CvArr* dst );
src1
第一个原数组
src2
第二个原数组
dst
输出数组
函数 cvMax 计算两个数组中每个元素的较大值：
dst(I)=max(src1(I), src2(I))
所有的数组必须的一个单通道，相同的数据类型和相同的大小（或 ROI 大小）

MaxS
查找数组元素与数量之间的较大值

void cvMaxS( const CvArr* src, double value, CvArr* dst );
src
第一个原数组.
value
数量值.
dst
输出数组
函数 cvMaxS 计算数组元素和数量之间的较大值：
dst(I)=max(src(I), value)
所有数组必须有一个单一通道，相同的数据类型相同的大小（或 ROI 大小）

Min
查找两个数组元素之间

的较小值

void cvMin( const CvArr* src1, const CvArr* src2, CvArr* dst );
src1
第一个原数组
src2
第二个原数组.
dst
输出数组.
函数 cvMin 计算两个数组元素的较大值
dst(I)=min(src1(I),src2(I))
所有数组必须有一个单一通道，相同的数据类型相同的大小（或 ROI 大小）

MinS
查找数组元素和数量之间的较大值

void cvMinS( const CvArr* src, double value, CvArr* dst );
src
第一个原数组
value
数量值.
dst
输出数组..
函数 cvMinS 计算数组元素和数量之量的较小值：
dst(I)=min(src(I), value)
所有数组必须有一个单一通道，相同的数据类型相同的大小（或 ROI 大小）

AbsDiff
计算两个数组差的绝对值

void cvAbsDiff( const CvArr* src1, const CvArr* src2, CvArr* dst );
src1
第一个原数组
src2
第二个原数组
dst
输出数组
函数 cvAbsDiff 计算两个数组差的绝对值
dst(I) c = abs(src1(I) c - src2(I) c ).
所有数组必须有相同的数据类型相同的大小（或 ROI 大小）

AbsDiffS
计算数组元素与数量之间差的绝对值

void cvAbsDiffS( const CvArr* src, CvArr* dst, CvScalar value );
#define cvAbs(src, dst) cvAbsDiffS(src, dst, cvScalarAll(0))
src
原数组.
dst
输出数组
value
数量.
函数 cvAbsDiffS 计算数组元素与数量之间差的绝对值
dst(I) c = abs(src(I) c - value c ).
所有数组必须有相同的数据类型相同的大小（或 ROI 大小）

统计

CountNonZero
计算非零数组元素

int cvCountNonZero( const CvArr* arr );
arr
数组, 必须是单通道数组或者设置 COI（感兴趣通道）的多通道图像。
函数 cvCountNonZero 返回 arr 中非零元素的数目:
result = sum I arr(I)!=0
当 IplImage 支持 ROI 和 COI。

Sum
计算数组元素的和

CvScalar cvSum( const CvArr* arr );
arr
数组.
函数 cvSum 独立地为每一个通道计算数组元素的和 S :
S c = sum I arr(I) c
如果数组是 IplImage 类型和设置了 COI, 该函数只处理选定的通道并将和存储到第一个标量成员
(S 0 )。

Avg
计算数组元素的平均值

CvScalar cvAvg( const CvArr* arr, const CvArr* mask=NULL );
arr
数组.
mask
可选操作掩模
函数 cvAvg 独立地为每一个通道计算数组元素的平均值 M :
N = sum I mask(I)!=0

M c = 1/N • sum I,mask(I)!=0 arr(I) c
如果数组是 IplImage 类型和设置 COI , 该函数只处理选定的通道并将和存储到第一个标量成员
(S 0 )。

AvgSdv
计算数组元素的平均值

void cvAvgSdv( const CvArr* arr, CvScalar* mean, CvScalar* std_dev, const CvArr*
mask=NULL );
arr
数组
mean
指向平均值的指针，如果不需要的话可以为空（ NULL）。
std_dev
指向标准差的指针。
mask
可选操作掩模。
函数 cvAvgSdv 独立地为每一个通道计算数组元素的平均值和标准差：
N = sum I mask(I)!=0

mean c = 1/N • sum I,mask(I)!=0 arr(I) c

std_dev c = sqrt(1/N • sum I,mask(I)!=0 (arr(I) c - M c ) 2 )
如果数组是 IplImage 类型和设置了 COI ,该函数只处理选定的通道并将平均值和标准差存储到
第一个输出标量成员 (M 0 and S 0 )。

MinMaxLoc
查找数组和子数组的全局最小值和最大值

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)或当 MASK 不为 NULL 时指定的数组区域中，搜索极值。
如果数组不止一个通道，它就必须是设置了 COI 的 IplImage 类型。如果是多维数组
min_loc->x 和 max_loc->x 将包含极值的原始位置信息 (线性的)。

Norm
计算数组的绝对范数，

绝对差分范数或者相对差分范数

double cvNorm( const CvArr* arr1, const CvArr* arr2=NULL, int norm_type=CV_L2,
const CvArr* mask=NULL );
arr1
第一输入图像
arr2
第二输入图像，如果为空（NULL）, 计算 arr1 的绝对范数，否则计算 arr1-arr2 的绝
对范数或者相对范数。
normType
范数类型，参见“讨论”。
mask
可选操作掩模。
如果 arr2 为空（NULL），函数 cvNorm 计算 arr1 的绝对范数：
norm = ||arr1|| C = max I abs(arr1(I)), 如果 normType = CV_C

norm = ||arr1|| L1 = sum I abs(arr1(I)), 如果 normType = CV_L1

norm = ||arr1|| L2 = sqrt( sum I arr1(I) 2 ), 如果 normType = CV_L2

如果 arr2 不为空（NULL），该函数计算绝对差分范数或者相对差分范数：
norm = ||arr1-arr2|| C = max I abs(arr1(I)-arr2(I)), 如果 normType = CV_C

norm = ||arr1-arr2|| L1 = sum I abs(arr1(I)-arr2(I)), 如果 normType = CV_L1

norm = ||arr1-arr2|| L2 = sqrt( sum I (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 返回计算所得的范数。多通道数组被视为单通道处理，因此，所有通道的结
果是结合在一起的。

线性代数

SetIdentity
初始化带尺度的单位矩阵

void cvSetIdentity( CvArr* mat, CvScalar value=cvRealScalar(1) );
mat
待初始化的矩阵 (不一定是方阵)。
value
赋值给对角线元素的值。
函数 cvSetIdentity 初始化带尺度的单位矩阵:
arr(i,j)=value 如果 i=j,
否则为 0

DotProduct
用欧几里得准则计算两个数组的点积

double cvDotProduct( const CvArr* src1, const CvArr* src2 );
src1
第一输入数组。
src2
第二输入数组。
函数 cvDotProduct 计算并返回两个数组的欧几里得点积。
src1•src2 = sum I (src1(I)*src2(I))
如果是多通道数组，所有通道的结果是累加在一起的。特别地， cvDotProduct(a,a),
将返回 ||a|| 2 ，这里 a 是一个复向量。该函数可以处理多通道数组,逐行或逐层等
等。

CrossProduct
计算两个三维向量的叉积

void cvCrossProduct( const CvArr* src1, const CvArr* src2, CvArr* dst );
src1
第一输入向量。
src2
第二输入向量。
dst
输出向量
函数 cvCrossProduct 计算两个三维向量的差积：
dst = src1 × src2, (dst 1 = src1 2 src2 3 - src1 3 src2 2 , dst 2 = src1 3 src2 1 - src1 1 src2 3 ,
dst 3 = src1 1 src2 2 - src1 2 src2 1 ).

ScaleAdd
计算一个数组缩放后与另一个数组的和

void cvScaleAdd( const CvArr* src1, CvScalar scale, const CvArr* src2, CvArr*
dst );
#define cvMulAddS cvScaleAdd
src1
第一输入数组
scale
第一输入数组的缩放因子
src2
第二输入数组
dst
输出数组
函数 cvScaleAdd 计算一个数组缩放后与另一个数组的和:
dst(I)=src1(I)*scale + src2(I)
所有的数组参数必须有相同的类型和大小。

GEMM
通用矩阵乘法

void cvGEMM( const CvArr* src1, const CvArr* src2, double alpha,
const CvArr* src3, double beta, CvArr* dst, int tABC=0 );
#define cvMatMulAdd( src1, src2, src3, dst ) cvGEMM( src1, src2, 1, src3, 1,
dst, 0 )
#define cvMatMul( src1, src2, dst ) cvMatMulAdd( src1, src2, 0, dst )
src1
第一输入数组
src2
第二输入数组
src3
第三输入数组 (偏移量)，如果没有偏移量，可以为空（ NULL）。
dst
输出数组
tABC
T 操作标志，可以是 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*src1 T *src2 + beta*src3 T
函数 cvGEMM 执行通用矩阵乘法:
dst = alpha*op(src1)*op(src2) + beta*op(src3), 这里 op(X) 是 X 或者 X T
所有的矩阵应该有相同的数据类型和协调的矩阵大小。支持实数浮点矩阵或者复数浮点
矩阵。

Transform
对数组每一个元素执行矩阵变换

void cvTransform( const CvArr* src, CvArr* dst, const CvMat* transmat, const
CvMat* shiftvec=NULL );
src
输入数组
dst
输出数组
transmat
变换矩阵
shiftvec
可选偏移向量
函数 cvTransform 对数组 src 每一个元素执行矩阵变换并将结果存储到 dst:
dst(I)=transmat*src(I) + shiftvec 或者 dst(I) k =sum j (transmat(k,j)*src(I) j )
+ shiftvec(k)
N-通道数组 src 的每一个元素都被视为一个 N 元向量，使用一个 M×N 的变换矩阵
transmat 和偏移向量 shiftvec 把它变换到一个 M-通道的数组 dst 的一个元素中。
这里可以选择将偏移向量 shiftvec 嵌入到 transmat 中。这样的话 transmat 应该是
M×N+1 的矩阵，并且最右边的一列被看作是偏移向量。
输入数组和输出数组应该有相同的位深（depth）和同样的大小或者 ROI 大小。
transmat 和 shiftvec 应该是实数浮点矩阵。
该函数可以用来进行 ND 点集的几何变换，任意的线性颜色空间变换，通道转换等。

PerspectiveTransform
向量数组的透视变换

void cvPerspectiveTransform( const CvArr* src, CvArr* dst, const CvMat* mat );
src
输入的三通道浮点数组
dst
输出三通道浮点数组
mat
4 × 4 变换矩阵
函数 cvPerspectiveTransform 用下面的方式变换 src 的每一个元素 (通过将其视为
二维或者三维的向量):
(x, y, z) -> (x'/w, y'/w, z'/w) 或者
(x, y) -> (x'/w, y'/w),

这里
(x', y', z', w') = mat*(x, y, z, 1) 或者
(x', y', w') = mat*(x, y, 1)

并且 w = w' 如果 w'!=0,
否则 w = inf

MulTransposed
计算数组和数组的转置的乘积

void cvMulTransposed( const CvArr* src, CvArr* dst, int order, const CvArr*
delta=NULL );
src
输入矩阵
dst
目标矩阵
order
乘法顺序
delta
一个可选数组，在乘法之前从 src 中减去该数组。
函数 cvMulTransposed 计算 src 和它的转置的乘积。
函数求值公式：
如果 order=0
dst=(src-delta)*(src-delta) T
否则
dst=(src-delta) T *(src-delta)

Trace
返回矩阵的迹

CvScalar cvTrace( const CvArr* mat );
mat
输入矩阵
函数 cvTrace 返回矩阵 mat 的对角线元素的和。
tr(src1)=sum i mat(i,i)

Transpose
矩阵的转置

void cvTranspose( const CvArr* src, CvArr* dst );
#define cvT cvTranspose
src
输入矩阵
dst
目标矩阵
函数 cvTranspose 对矩阵 src 求转置:
dst(i,j)=src(j,i)
注意，假设是复数矩阵不会求得复数的共轭。共轭应该是独立的：查看的 cvXorS 例
子代码。

Det
返回矩阵的行列式值

double cvDet( const CvArr* mat );
mat
输入矩阵
函数 cvDet 返回方阵 mat 的行列式值。对小矩阵直接计算，对大矩阵用高斯
(GAUSSIAN)消去法。对于对称正定(positive-determined)矩阵也可以用 SVD 函数来
求，U=V=NULL ，然后用 w 的对角线元素的乘积来计算行列式。

Invert
查找矩阵的逆矩阵或伪逆矩阵

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 - 正定对称矩阵的 SVD 方法
函数 cvInvert 对矩阵 src1 求逆并将结果存储到 src2
如果是 LU 方法该函数返回 src1 的行列式值 (src1 必须是方阵)。如果是 0, 矩阵
不求逆， src2 用 0 填充。
如果 SVD 方法该函数返回 src1 的条件数的倒数(最小奇异值和最大奇异值的比值) ，
如果 src1 全为 0 则返回 0。如果 src1 是奇异的， SVD 方法计算一个伪逆矩阵。

Solve
求解线性系统或者最小二乘法问题

int cvSolve( const CvArr* src1, const CvArr* src2, CvArr* dst, int
method=CV_LU );
A
输入矩阵
B
线性系统的右部
X
输出解答
method
解决方法(矩阵求逆) :
CV_LU - 最佳主元选取的高斯消除法
CV_SVD - 奇异值分解法 (SVD)
CV_SVD_SYM - 对正定对称矩阵的 SVD 方法
函数 cvSolve 解决线性系统或者最小二乘法问题 (后者用 SVD 方法可以解决):
dst = arg min X ||src1*X-src2||
如果使用 CV_LU 方法。如果 src1 是非奇异的，该函数则返回 1 ，否则返回 0 ，在
后一种情况下 dst 是无效的。

SVD
对实数浮点矩阵进行奇异值分解

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 or M×N). 如果 CV_SVD_U_T 被指定，应该交换上面所说的行
与列的数目。
V
可选右部正交矩阵(N×N)
flags
操作标志；可以是 0 或者下面的值的组合:
• CV_SVD_MODIFY_A 通过操作可以修改矩阵 src1 。这样处理速度会比较快。
• CV_SVD_U_T 意味着会返回转置矩阵 U ，指定这个标志将加快处理速度。
• CV_SVD_V_T 意味着会返回转置矩阵 V ，指定这个标志将加快处理速度。
函数 cvSVD 将矩阵 A 分解成一个对角线矩阵和两个正交矩阵的乘积：
A=U*W*V T
这里 w 是一个奇异值的对角线矩阵，它可以被编码成奇异值的一维向量，u 和 v 也是
一样。所有的奇异值都是非负的并按降序存储。（u 和 v 也相应的存储）。
SVD 算法在数值处理上已经很稳定，它的典型应用包括：
• 当 A 是一个方阵、对称阵和正矩阵时精确的求解特征值问题，例如, 当 A 时一个协方差矩
阵时。在这种情况下 w 将是一个特征值的的向量，并且 U=V 是矩阵的特征向量(因此，当
需要计算特征向量时 u 和 v 只需要计算其中一个就可以了) 。
• 精确的求解病态线性系统
• 超定线性系统的最小二乘求解。上一个问题和这个问题都可以用指定 CV_SVD 的 cvSolve
方法。
• 精确计算矩阵的不同特征，如秩(非零奇异值的数目), 条件数(最大奇异值和最小奇异值的比
例), 行列式值(行列式的绝对值等于奇异值的乘积).上述的所有这些值都不要求计算矩阵 u
和 v 。

SVBkSb
奇异值回代算法（
back substitution
）

void cvSVBkSb( const CvArr* W, const CvArr* U, const CvArr* V,
const CvArr* B, CvArr* X, int flags );
W
奇异值矩阵或者向量
U
左正交矩阵 (可能是转置的)
V
右正交矩阵 (可能是转置的)
B
原始矩阵 A 的伪逆的乘法矩阵。这个是可选参数。如果它被省略则假定它是一个适当大小
的单位矩阵(因此 x 将是 A 的伪逆的重建).。
X
目标矩阵: 奇异值回代算法的结果
flags
操作标志, 和刚刚讨论的 cvSVD 的标志一样。
函数 cvSVBkSb 为被分解的矩阵 A 和矩阵 B 计算回代逆（back substitution） (参
见 cvSVD 说明) :
X=V*W -1 *U T *B
这里
W -1 (i,i)=1/W(i,i) 如果 W(i,i) > epsilon•sum i W(i,i),
否则 0
epsilon 是一个依赖于矩阵数据类型的的很小的数。
该函数和 cvSVD 函数被用来执行 cvInvert 和 cvSolve, 用这些函数 (svd & bksb)的原因是初级函
数（low-level）函数可以避免高级函数 (inv & solve) 计算中内部分配的临时矩阵。

EigenVV
计算对称矩阵的特征值和特征向量

void cvEigenVV( CvArr* mat, CvArr* evects, CvArr* evals, double eps=0 );
mat
输入对称方阵。在处理过程中将被改变。
evects
特征向量输出矩阵，连续按行存储
evals
特征值输出矩阵，按降序存储(当然特征值和特征向量的排序是同步的)。
eps
对角化的精确度 (典型地， DBL_EPSILON=≈10 -15 就足够了)。
函数 cvEigenVV 计算矩阵 A 的特征值和特征向量:
mat*evects(i,:)' = evals(i)*evects(i,:)' (在 MATLAB 的记法)
矩阵 A 的数据将会被这个函数修改。
目前这个函数比函数 cvSVD 要慢，精确度要低，如果已知 A 是正定的，(例如, 它是
一个协方差矩阵), 它通常被交给函数 cvSVD 来计算其特征值和特征向量，尤其是在不
需要计算特征向量的情况下

CalcCovarMatrix
计算向量集合的协方差矩阵

void cvCalcCovarMatrix( const CvArr** vects, int count, CvArr* cov_mat, CvArr*
avg, int flags );
vects
输入向量。他们必须有同样的数据类型和大小。这个向量不一定非是一维的，他们也可以是
二维（例如，图像）等等。
count
输入向量的数目
cov_mat
输出协方差矩阵，它是浮点型的方阵。
avg
输入或者输出数组 (依赖于标记“flags”) - 输入向量的平均向量。
flags
操作标志,下面值的组合:
CV_COVAR_SCRAMBLED - 输出协方差矩阵按下面计算:
scale*[vects[0]-avg,vects[1]-avg,...] T *[vects[0]-avg,vects[1]-avg,...],
即协方差矩阵是 count×count. 这样一个不寻常的矩阵用于一组大型向量的快速 PCA 方法
(例如, 人脸识别的 EigenFaces 技术)。这个混杂（"scrambled"）矩阵的特征值将和真正的协
方差矩阵的特征值匹配，真正的特征向量可以很容易的从混杂（"scrambled"）协方差矩阵的
特征向量中计算出来。
CV_COVAR_NORMAL - 输出协方差矩阵被计算成:
scale*[vects[0]-avg,vects[1]-avg,...]*[vects[0]-avg,vects[1]-avg,...] T
,
也就是说, cov_mat 将是一个和每一个输入向量的元素数目具有同样线性大小的通常协方
差矩阵。 CV_COVAR_SCRAMBLED 和 CV_COVAR_NORMAL 只能同时指定其中一个。
CV_COVAR_USE_AVG - 如果这个标志被指定，该函数将不会从输入向量中计算 avg ，而
是用过去的 avg 向量，如果 avg 已经以某种方式计算出来了这样做是很有用的。或者如果
协方差矩阵是部分计算出来的 - 倘若这样, avg 不是输入向量的子集的平均值，而是整个集
合的平均向量。
CV_COVAR_SCALE - 如果这个标志被指定，协方差矩阵被缩放了。 the covariation matrix is
scaled.在 "normal" 模式下缩放比例是 1./count, 在 "scrambled" 模式下缩放比例是每一
个输入向量的元素总和的倒数。缺省地(如果没有指定标志) 协方差矩阵不被缩放
(scale=1)。
函数 cvCalcCovarMatrix 计算输入向量的协方差矩阵和平均向量。该函数可以被运用
到主成分分析中（PCA），
以及马氏距离（Mahalanobis distance）比较向量中等等。

Mahalonobis
计算两个向量之间的马氏距离（
Mahalonobis distance
）

double cvMahalanobis( const CvArr* vec1, const CvArr* vec2, CvArr* mat );
vec1
第一个一维输入向量
vec2
第二个一维输入向量
mat
The inverse covariation matrix. 协方差矩阵的逆矩阵
函数 cvMahalonobis 计算两个向量之间的加权距离，其返回结果是：
d(vec1,vec2)=sqrt( sum i,j {mat(i,j)*(vec1(i)-vec2(i))*(vec1(j)-vec2(j))} )
协方差矩阵可以用函数 cvCalcCovarMatrix 计算出来，逆矩阵可以用函数 cvInvert 计
算出来 (CV_SVD 方法是一个比较好的选择, 因为矩阵可能是奇异的).

数学函数

Round, Floor, Ceil
转换浮点数为整数

int cvRound( double value );
int cvFloor( double value );
int cvCeil( double value );
value
输入浮点值
函数 cvRound, cvFloor, cvCeil 用一种舍入方法将输入浮点数转换成整数。 cvRound
返回和参数最接近的整数值。 cvFloor 返回不大于参数的最大整数值。cvCeil 返回不
小于参数的最小整数值。在某些体系结构中该函数工作起来比标准 C 操作起来还要
快。如果参数的绝对值大于 2 31 , 结果是不可预料的。特别值 (±Inf, NaN) 是不可控
制的。

Sqrt
计算平方根

float cvSqrt( float value );
value
输入浮点值
函数 cvSqrt 计算输入值的平方根。如果输入的是复数，结果将不可预料。

InvSqrt
计算平方根的倒数

float cvInvSqrt( float value );
value
输入浮点值
函数 cvInvSqrt 计算输入值的平方根的倒数，大多数情况下它比 1./sqrt(value) 要
快。如果输入的是 0 或者复数，结果将不可预料。特别值 (±Inf, NaN) 是不可控制
的。

Cbrt
计算立方根

float cvCbrt( float value );
value
输入浮点值
函数 cvCbrt 计算输入值的立方根，大多数情况下它比 pow(value,1./3) 要快。另外,
负数也是可操作的。特别值 (±Inf, NaN) 是不可控制的。

FastArctan
计算二维向量的角度

float cvFastArctan( float y, float x );
x
二维向量的 x 坐标
y
二维向量的 y 坐标
函数 cvFastArctan 计算二维向量的全范围角度角度，变化范围是 0°到 360°。精
确度为 ~0.1° 。

IsNaN
判断输入是否是一个数字

int cvIsNaN( double value );
value
输入浮点值
函数 cvIsNaN 发给输入是一个数字则返回 1 ( IEEE754 标准 )，否则返回 0 。

IsInf
判断输入是否是无穷大

int cvIsInf( double value );
value
输入浮点值
函数 cvIsInf 如果输入是 ±Infinity ( IEEE754 标准 )则返回 1 ,否则返回 0 .

CartToPolar
计算二维向量的长度和
/
或者角度

void cvCartToPolar( const CvArr* x, const CvArr* y, CvArr* magnitude,
CvArr* angle=NULL, int angle_in_degrees=0 );
x
x 坐标数组
y
y 坐标数组
magnitude
存储向量长度输出数组，如果不是必要的它可以为空（NULL）
angle
存储角度输出数组, 如果不是必要的它可以为空（NULL）。它可以被标准化为弧度 (0..2π) 或
者度数(0..360°)
angle_in_degrees
指示角度是用弧度或者度数表示的标志，缺省模式为弧度
函数 cvCartToPolar 计算二维向量(x(I),y(I))的长度，角度，或者两者同时计算:
magnitude(I)=sqrt( x(I) 2 +y(I) 2 ),
angle(I)=atan( y(I)/x(I) )
角度的精确度 ≈0.1°. (0,0) 点的角度被设置为 0.

PolarToCart
计算极坐标形式的二维向量对应的直角坐标

void cvPolarToCart( const CvArr* magnitude, const CvArr* angle,
CvArr* x, CvArr* y, int angle_in_degrees=0 );
magnitude
长度数组.如果为空（NULL），长度被假定为全是 1's.
angle
角度数组,弧度或者角度表示.
x
输出 x 坐标数组, 如果不需要，可以为空（NULL）.
y
输出 y 坐标数组, 如果不需要，可以为空（NULL）.
angle_in_degrees
指示角度是用弧度或者度数表示的标志，缺省模式为弧度
函数 cvPolarToCart 计算每个向量 magnitude(I)*exp(angle(I)*j), j=sqrt(-1)的 x
坐标，y 坐标或者两者都计算:
x(I)=magnitude(I)*cos(angle(I)),
y(I)=magnitude(I)*sin(angle(I))

Pow
对数组内每个元素求幂

void cvPow( const CvArr* src, CvArr* dst, double power );
src
输入数组
dst
输出数组, 应该和输入数组有相同的类型
power
幂指数
函数 cvPow 计算输入数组的每个元素的 p 次幂:
dst(I)=src(I) p , 如果 p 是整数
否则 dst(I)=abs(src(I)) p
也就是说，对于非整型的幂指数使用输入数组元素的绝对值进行计算。然而，使用一些
额外的操作，负值也可以得到正确的结果，象下面的例子，计算数组元素的立方根：
CvSize size = cvGetSize(src);
CvMat* mask = cvCreateMat( size.height, size.width, CV_8UC1 );
cvCmpS( src, 0, mask, CV_CMP_LT ); /* 查找负数 */
cvPow( src, dst, 1./3 );
cvSubRS( dst, cvScalarAll(0), dst, mask ); /* 输入的负值的结果求反 */
cvReleaseMat( &mask );
对于一些幂值, 例如整数值, 0.5 和 -0.5, 优化算法被使用。

Exp
计算数组元素的指数幂

void cvExp( const CvArr* src, CvArr* dst );
src
输入数组
dst
输出数组, 它应该是 double 型的或者和输入数组有相同的类型
函数 cvExp 计算输入数组的每个元素的 e 次幂:
dst(I)=exp(src(I))
最大相对误差为 ≈7e-6. 通常, 该函数转换无法输出的值为 0 输出。

Log
Calculates natural logarithm of every array element absolute value
计算每个数组元素的绝对值的自然对
数

void cvLog( const CvArr* src, CvArr* dst );
src
输入数组
dst
输出数组, 它应该是 double 型的或者和输入数组有相同的类型
函数 cvLog 计算输入数组每个元素的绝对值的自然对数:
dst(I)=log(abs(src(I))), src(I)!=0
dst(I)=C, src(I)=0
这里 C 是一个大负数 (≈-700 通常的运算中)

SolveCubic
求解曲线函数的实根

void cvSolveCubic( const CvArr* coeffs, CvArr* roots );
coeffs
等式系数, 一个三到四个元素的数组.
roots
输出的矩阵等式的实根。它应该具有三个元素.
函数 cvSolveCubic 求解曲线函数的实根:
coeffs[0]*x 3 + coeffs[1]*x 2 + coeffs[2]*x + coeffs[3] = 0
(如果 coeffs 是四元素的矢量)

or

x 3 + coeffs[0]*x 2 + coeffs[1]*x + coeffs[2] = 0
(如果 coeffs 是三元素的矢量)
函数返回求解得到的实根数目. 实根被存储在矩阵 root 中, 如果只有一个实根则用 0
来替代相关值.
随机数生成

RNG
初始化随机数生成器状态

CvRNG cvRNG( int64 seed=-1 );
seed
64-bit 的值用来初始化一个随机序列
函数 cvRNG 初始化随机数生成器并返回其状态。指向这个状态的指针可以传递给函数
cvRandInt, cvRandReal 和 cvRandArr . 在通常的实现中使用一个
multiply-with-carry generator 。

RandArr
用随机数填充数组并更新
RNG
状态

void cvRandArr( CvRNG* rng, CvArr* arr, int dist_type, CvScalar param1, CvScalar
param2 );
rng
被 cvRNG 初始化的 RNG 状态.
arr
输出数组
dist_type
分布类型:
CV_RAND_UNI - 均匀分布
CV_RAND_NORMAL - 正常分布或者高斯分布
param1
分布的第一个参数。如果是均匀分布它是随机数范围的闭下边界。如果是正态分布它是随机
数的平均值。
param2
分布的第二个参数。如果是均匀分布它是随机数范围的开上边界。如果是正态分布它是随机
数的标准差。
函数 cvRandArr 用均匀分布的或者正态分布的随机数填充输出数组。在下面的例子中
该函数被用来添加一些正常分布的浮点数到二维数组的随机位置。
/* let's noisy_screen be the floating-point 2d array that is to be "crapped"
*/
CvRNG rng_state = cvRNG(0xffffffff);
int i, pointCount = 1000;
/* allocate the array of coordinates of points */
CvMat* locations = cvCreateMat( pointCount, 1, CV_32SC2 );
/* arr of random point values */
CvMat* values = cvCreateMat( pointCount, 1, CV_32FC1 );
CvSize size = cvGetSize( noisy_screen );

cvRandInit( &rng_state,
0, 1, /* 现在使用虚参数以后再调整 */
0xffffffff /*这里使用一个确定的种子 */,
CV_RAND_UNI /* 指定为均匀分布类型 */ );

/* 初始化 locations */
cvRandArr( &rng_state, locations, CV_RAND_UNI, cvScalar(0,0,0,0),
cvScalar(size.width,size.height,0,0) );

/* modify RNG to make it produce normally distributed values */
rng_state.disttype = CV_RAND_NORMAL;
cvRandSetRange( &rng_state,
30 /* deviation */,
100 /* average point brightness */,
-1 /* initialize all the dimensions */ );
/* generate values */
cvRandArr( &rng_state, values, CV_RAND_NORMAL,
cvRealScalar(100), // average intensity
cvRealScalar(30) // deviation of the intensity
);

/* set the points */
for( i = 0; i < pointCount; i++ )
{
CvPoint pt = *(CvPoint*)cvPtr1D( locations, i, 0 );
float value = *(float*)cvPtr1D( values, i, 0 );
*((float*)cvPtr2D( noisy_screen, pt.y, pt.x, 0 )) += value;
}

/* not to forget to release the temporary arrays */
cvReleaseMat( &locations );
cvReleaseMat( &values );

/* RNG state does not need to be deallocated */

RandInt
返回
32-bit
无符号整型并更新
RNG
unsigned cvRandInt( CvRNG* rng );
rng
被 cvRNG 初始化的 RNG 状态，被 RandSetRange (虽然, 后面这个函数对我们正讨论的
函数的结果没有什么影响)随意地设置。
函数 cvRandInt 返回均匀分布的随机 32-bit 无符号整型值并更新 RNG 状态。它和 C
运行库里面的 rand() 函数十分相似，但是它产生的总是一个 32-bit 数而 rand() 返
回一个 0 到 RAND_MAX （它是 2**16 或者 2**32, 依赖于操作平台）之间的数。
该函数用来产生一个标量随机数，例如点， patch sizes, table indices 等,用模操
作可以产生一个确定边界的整数，人和其他特定的边界缩放到 0.. 1 可以产生一个浮点
数。下面是用 cvRandInt 重写的前一个函数讨论的例子:
/* the input and the task is the same as in the previous sample. */
CvRNG rng_state = cvRNG(0xffffffff);
int i, pointCount = 1000;
/* ... - no arrays are allocated here */
CvSize size = cvGetSize( noisy_screen );
/* make a buffer for normally distributed numbers to reduce call overhead */
#define bufferSize 16
float normalValueBuffer[bufferSize];
CvMat normalValueMat = cvMat( bufferSize, 1, CV_32F, normalValueBuffer );
int valuesLeft = 0;

for( i = 0; i < pointCount; i++ )
{
CvPoint pt;
/* generate random point */
pt.x = cvRandInt( &rng_state ) % size.width;
pt.y = cvRandInt( &rng_state ) % size.height;

if( valuesLeft <= 0 )
{
/* fulfill the buffer with normally distributed numbers if the buffer
is empty */
cvRandArr( &rng_state, &normalValueMat, CV_RAND_NORMAL,
cvRealScalar(100), cvRealScalar(30) );
valuesLeft = bufferSize;
}
*((float*)cvPtr2D( noisy_screen, pt.y, pt.x, 0 ) =
normalValueBuffer[--valuesLeft];
}

/* there is no need to deallocate normalValueMat because we have
both the matrix header and the data on stack. It is a common and efficient
practice of working with small, fixed-size matrices */

RandReal
返回浮点型随机数并更新
RNG
double cvRandReal( CvRNG* rng );
rng
被 cvRNG 初始化的 RNG 状态
函数 cvRandReal 返回均匀分布的随机浮点数，范围在 0..1 之间 (不包括 1 )。

离散变换

DFT
执行一维或者二维浮点数组的离散傅立叶正变换或者离散傅立叶逆变换

#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

void cvDFT( const CvArr* src, CvArr* dst, int flags );
src
输入数组, 实数或者复数.
dst
输出数组，和输入数组有相同的类型和大小。
flags
变换标志, 下面的值的组合:
CV_DXT_FORWARD - 正向 1D 或者 2D 变换. 结果不被缩放.
CV_DXT_INVERSE - 逆向 1D 或者 2D 变换. 结果不被缩放.当然 CV_DXT_FORWARD 和
CV_DXT_INVERSE 是互斥的.
CV_DXT_SCALE - 对结果进行缩放: 用数组元素除以它. 通常, 它和 CV_DXT_INVERSE 组
合在一起,可以使用缩写 CV_DXT_INV_SCALE.
CV_DXT_ROWS - 输入矩阵的每个独立的行进行整型或者逆向变换。这个标志允许用户同时
变换多个向量，减少开销(它往往比处理它自己要快好几倍), 进行 3D 和高维的变换等等。
函数 cvDFT 执行一维或者二维浮点数组的离散傅立叶正变换或者离散傅立叶逆变换:
N 元一维向量的正向傅立叶变换:
y = F (N) •x, 这里 F (N)
jk =exp(-i•2Pi•j•k/N), i=sqrt(-1)

N 元一维向量的逆向傅立叶变换:
x'= (F (N) ) -1 •y = conj(F (N) )•y
x = (1/N)•x

M×N 元二维向量的正向傅立叶变换:
Y = F (M) •X•F (N)

M×N 元二维向量的逆向傅立叶变换:
X'= conj(F (M) )•Y•conj(F (N) )
X = (1/(M•N))•X'
假设时实数数据 (单通道) ,从 IPL 借鉴过来的压缩格式被用来表现一个正向傅立叶变
换的结果或者逆向傅立叶变换的输入：
Re Y 0,0 Re Y 0,1 Im Y 0,1 Re Y 0,2 Im Y 0,2 ... Re Y 0,N/2-1 Im Y 0,N/2-1 Re
Y 0,N/2
Re Y 1,0 Re Y 1,1 Im Y 1,1 Re Y 1,2 Im Y 1,2 ... Re Y 1,N/2-1 Im Y 1,N/2-1 Re
Y 1,N/2
Im Y 1,0 Re Y 2,1 Im Y 2,1 Re Y 2,2 Im Y 2,2 ... Re Y 2,N/2-1 Im Y 2,N/2-1 Im
Y 2,N/2
...........................................................................
.................
Re Y M/2-1,0 Re Y M-3,1 Im Y M-3,1 Re Y M-3,2 Im Y M-3,2 ... Re Y M-3,N/2-1 Im Y M-3,N/2-1 Re Y M-3,N/2
Im Y M/2-1,0 Re Y M-2,1 Im Y M-2,1 Re Y M-2,2 Im Y M-2,2 ... Re Y M-2,N/2-1 Im Y M-2,N/2-1 Im Y M-2,N/2
Re Y M/2,0 Re Y M-1,1 Im Y M-1,1 Re Y M-1,2 Im Y M-1,2 ... Re Y M-1,N/2-1 Im Y M-1,N/2-1 Im Y M-1,N/2
注意:如果 N 时偶数最后一列存在（is present）, 如果 M 时偶数最后一行（is
present）.
如果是一维实数的变换结果就像上面矩阵的第一行的形式。
利用 DFT 求解二维卷积
CvMat* A = cvCreateMat( M1, N1, CV_32F );
CvMat* B = cvCreateMat( M2, N2, A->type );

// it is also possible to have only abs(M2-M1)+1×abs(N2-N1)+1
// part of the full convolution result
CvMat* conv = cvCreateMat( A->rows + B->rows - 1, A->cols + B->cols - 1,
A->type );

// initialize A and B
...

int dft_M = cvGetOptimalDFTSize( A->rows + B->rows - 1 );
int dft_N = cvGetOptimalDFTSize( A->cols + B->cols - 1 );

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

// copy A to dft_A and pad dft_A with zeros
cvGetSubRect( dft_A, &tmp, cvRect(0,0,A->cols,A->rows));
cvCopy( A, &tmp );
cvGetSubRect( dft_A, &tmp, cvRect(A->cols,0,dft_A->cols -
A->cols,A->rows));
cvZero( &tmp );
// no need to pad bottom part of dft_A with zeros because of
// use nonzero_rows parameter in cvDFT() call below

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

// repeat the same with the second array
cvGetSubRect( dft_B, &tmp, cvRect(0,0,B->cols,B->rows));
cvCopy( B, &tmp );
cvGetSubRect( dft_B, &tmp, cvRect(B->cols,0,dft_B->cols -
B->cols,B->rows));
cvZero( &tmp );
// no need to pad bottom part of dft_B with zeros because of
// use nonzero_rows parameter in cvDFT() call below

cvDFT( dft_B, dft_B, CV_DXT_FORWBRD, B->rows );

cvMulSpectrums( dft_A, dft_B, dft_A, 0 /* or CV_DXT_MUL_CONJ to get
correlation
rather than convolution */ );

cvDFT( dft_A, dft_A, CV_DXT_INV_SCALE, conv->rows ); // calculate only the
top part
cvGetSubRect( dft_A, &tmp, cvRect(0,0,conv->cols,conv->rows) );

cvCopy( &tmp, conv );

GetOptimalDFTSize
对于给定的矢量尺寸返回最优
DFT
尺寸

int cvGetOptimalDFTSize( int size0 );
size0
矢量长度.
函数 cvGetOptimalDFTSize 返回最小值 N that is greater to equal to size0, such
that DFT of a vector of size N can be computed fast. In the current implementation
N=2 p ×3 q ×5 r for some p, q, r.
The function returns a negative number if size0 is too large (very close to
INT_MAX)

MulSpectrums
两个傅立叶频谱的每个元素的乘法（
Performs per-element multiplication of two Fourier spectrums
）

void cvMulSpectrums( const CvArr* src1, const CvArr* src2, CvArr* dst, int
flags );
src1
第一输入数组
src2
第二输入数组
dst
输出数组，和输入数组有相同的类型和大小。
flags
下面列举的值的组合:
CV_DXT_ROWS - 把数组的每一行视为一个单独的频谱 (参见 cvDFT 的参数讨论).
CV_DXT_MUL_CONJ - 在做乘法之前取第二个输入数组的共轭.
函数 cvMulSpectrums 执行两个 CCS-packed 或者实数或复数傅立叶变换的结果复数
矩阵的每个元素的乘法。（performs per-element multiplication of the two
CCS-packed or complex matrices that are results of real or complex Fourier
transform.）
该函数和 cvDFT 可以用来快速计算两个数组的卷积.

DCT
执行一维或者二维浮点数组的离散余弦变换或者离散反余弦变换

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

void cvDCT( const CvArr* src, CvArr* dst, int flags );
src
输入数组, 1D 或者 2D 实数数组.
dst
输出数组，和输入数组有相同的类型和大小。
flags
变换标志符, 下面值的组合:
CV_DXT_FORWARD - 1D 或者 2D 余弦变换.
CV_DXT_INVERSE - 1D or 2D 反余弦变换.
CV_DXT_ROWS - 对输入矩阵的每个独立的行进行余弦或者反余弦变换. 这个标志允许用户
同时进行多个向量的变换，可以用来减少开销（它往往比处理它自己要快好几倍），以及 3D
和高维变换等等。
函数 cvDCT 执行一维或者二维浮点数组的离散余弦变换或者离散反余弦变换：
N 元一维向量的余弦变换:
y = C (N) •x, 这里 C (N)
jk =sqrt((j==0?1:2)/N)•cos(Pi•(2k+1)•j/N)

N 元一维向量的反余弦变换:
x = (C (N) ) -1 •y = (C (N) ) T •y

M×N 元二维向量的余弦变换:
Y = (C (M) )•X•(C (N) ) T

M×N 元二维向量的反余弦变换:
X = (C (M) ) T •Y•C (N)

动态结构

内存存储（memory storage)

CvMemStorage
Growing memory storage
typedef struct CvMemStorage
{
struct CvMemBlock* bottom;/* first allocated block */
struct CvMemBlock* top; /* the current memory block - top of the stack */
struct CvMemStorage* parent; /* borrows new blocks from */
int block_size; /* block size */
int free_space; /* free space in the top block (in bytes) */
} CvMemStorage;
内存存储器是一个可用来存储诸如序列，轮廓，图形,子划分等动态增长数据结构的底
层结构。它是由一系列以同等大小的内存块构成，呈列表型 ---bottom 域指的是列首，
top 域指的是当前指向的块但未必是列尾.在 bottom 和 top 之间所有的块(包括 bottom,
不包括 top）被完全占据了空间；在 top 和列尾之间所有的块（包括块尾，不包括 top)
则是空的；而 top 块本身则被占据了部分空间 -- free_space 指的是 top 块剩余的空
字节数。
新分配的内存缓冲区（或显示的通过 cvMemStorageAlloc 函数分配，或隐示的通过
cvSeqPush, cvGraphAddEdge 等高级函数分配）总是起始于当前块（即 top 块)的剩余那
部分，如果剩余那部分能满足要求（够分配的大小）。分配后，free_space 就减少了
新分配的那部分内存大小，外加一些用来保存适当列型的附加大小。当 top 块的剩余空
间无法满足被分配的块（缓冲区）大小时，top 块的下一个存储块被置为当前块（新的
top 块） -- free_space 被置为先前分配的整个块的大小。
如果已经不存在空的存储块（即：top 块已是列尾），则必须再分配一个新的块（或从
parent 那继承,见 cvCreateChildMemStorage)并将该块加到列尾上去。于是，存储器（memory
storage)就如同栈（Stack)那样, bottom 指向栈底，(top, free_space)对指向栈顶。
栈顶可通过 cvSaveMemStoragePos 保存，通过 cvRestoreMemStoragePos 恢复指向，通过
cvClearStorage 重置。

CvMemBlock
内存存储块结构

typedef struct CvMemBlock
{
struct CvMemBlock* prev;
struct CvMemBlock* next;
} CvMemBlock;
CvMemBlock 代表一个单独的内存存储块结构。内存存储块中的实际数据存储在
header 块之后(即：存在一个头指针 head 指向的块 header ，该块不存储数据）,于
是，内存块的第 i 个字节可以通过表达式 ((char*)(mem_block_ptr+1))[i] 获得。然
而，通常没必要直接去获得存储结构的域。

CvMemStoragePos
内存存储块地址

typedef struct CvMemStoragePos
{
CvMemBlock* top;
int free_space;
} CvMemStoragePos;
该结构（如以下所说）保存栈顶的地址，栈顶可以通过 cvSaveMemStoragePos 保存，
也可以通过 cvRestoreMemStoragePos 恢复。

CreateMemStorage
创建内存块
CvMemStorage* cvCreateMemStorage( int block_size=0 );
block_size：存储块的大小以字节表示。如果大小是 0 byte, 则将该块设置成默认值
-- 当前默认大小为 64k.
函数 cvCreateMemStorage 创建一内存块并返回指向块首的指针。起初，存储块是空的。
头部（即：header)的所有域值都为 0，除了 block_size 外.

CreateChildMemStorage
创建子内存块

CvMemStorage* cvCreateChildMemStorage( CvMemStorage* parent );
parent 父内存块
函数 cvCreateChildMemStorage 创建一类似于普通内存块的子内存块，除了内存分配/释放
机制不同外。当一个子存储块需要一个新的块加入时，它就试图从 parent 那得到这样
一个块。如果 parent 中还未被占据空间的那些块中的第一个块是可获得的，就获取
第一个块（依此类推），再将该块从 parent 那里去除。如果不存在这样的块，则 parent
要么分配一个，要么从它自己 parent (即：parent 的 parent) 那借个过来。换句话
说，完全有可能形成一个链或更为复杂的结构，其中的内存存储块互为 child/ parent
关系（父子关系）。当子存储结构被释放或清除，它就把所有的块还给各自的 parent.
在其他方面，子存储结构同普通存储结构一样。
子存储结构在下列情况中是非常有用的。想象一下，如果用户需要处理存储在某个块中
的动态数据，再将处理的结果存放在该块中。在使用了最简单的方法处理后，临时数据
作为输入和输出数据被存放在了同一个存储块中，于是该存储块看上去就类似下面处理
后的样子： Dynamic data processing without using child storage.
结果，在存储块中，出现了垃圾（临时数据）。然而，如果在开始处理数据前就先建立
一个子存储块，将临时数据写入子存储块中并在最后释放子存储块，那么最终在源/目
的存储块（source / destination storage) 中就不会出现垃圾, 于是该存储块看上
去应该是如下形式：Dynamic data processing using a child storage.

ReleaseMemStorage
释放内存块

void cvReleaseMemStorage( CvMemStorage** storage );
storage: 指向被释放了的存储块的指针
函数 cvReleaseMemStorage 释放所有的存储（内存）块或者将它们返回给各自的
parent（如果需要的话）。接下来再释放 header 块（即：释放头指针 head 指向的块
= free(head)）并清除指向该块的指针（即：head = NULL)。在释放作为 parent 的块
之前，先清除各自的 child 块。

ClearMemStorage
清空内存存储块

void cvClearMemStorage( CvMemStorage* storage );
storage:存储存储块
函数 cvClearMemStorage 将存储块的 top 置到存储块的头部（注：清空存储块中的存
储内容）。该函数并不释放内存（仅清空内存）。假使该内存块有一个父内存块（即：
存在一内存块与其有父子关系），则函数就将所有的块返回给其 parent.

MemStorageAlloc
在存储块中分配以内存缓冲区

void* cvMemStorageAlloc( CvMemStorage* storage, size_t size );
storage：内存块.
size：缓冲区的大小.
函数 cvMemStorageAlloc 在存储块中分配一内存缓冲区。该缓冲区的大小不能超过内
存块的大小，否则就会导致运行时错误。缓冲区的地址被调整为 CV_STRUCT_ALIGN 字节
（当前为 sizeof(double)).

MemStorageAllocString
在存储块中分配一文本字符串

typedef struct CvString
{
int len;
char* ptr;
}
CvString;

CvString cvMemStorageAllocString( CvMemStorage* storage, const char* ptr, int
len=-1 );
storage：存储块
ptr：字符串
len：字符串的长度（不计算‘\0’）。如果参数为负数，函数就计算该字符串的长度。
函数 cvMemStorageAlloString 在存储块中创建了一字符串的拷贝。它返回一结构，该
结构包含字符串的长度（该长度或通过用户传递，或通过计算得到）和指向被拷贝了的
字符串的指针。

SaveMemStoragePos
保存内存块的位置（地址）

void cvSaveMemStoragePos( const CvMemStorage* storage, CvMemStoragePos* pos );
storage：内存块.
pos：内存块顶部位置。
函数 cvSaveMemStoragePos 将存储块的当前位置保存到参数 pos 中。函数
cvRestoreMemStoragePos 可进一步获取该位置（地址）。

RestoreMemStoragePos
恢复内存存储块的位置

void cvRestoreMemStoragePos( CvMemStorage* storage, CvMemStoragePos* pos );
storage：内存块.
pos：新的存储块的位置
函数 cvRestoreMemStoragePos 通过参数 pos 恢复内存块的位置。该函数和函数
cvClearMemStorage 是释放被占用内存块的唯一方法。注意：没有什么方法可去释放存
储块中被占用的部分内存。

Sequences

CvSeq
Growable sequence of elements
#define CV_SEQUENCE_FIELDS() \
int flags; /* micsellaneous flags */ \
int header_size; /* size of sequence header */ \
struct CvSeq* h_prev; /* previous sequence */ \
struct CvSeq* h_next; /* next sequence */ \
struct CvSeq* v_prev; /* 2nd previous sequence */ \
struct CvSeq* v_next; /* 2nd next sequence */ \
int total; /* total number of elements */ \
int elem_size;/* size of sequence element in bytes */ \
char* block_max;/* maximal bound of the last block */ \
char* ptr; /* current write pointer */ \
int delta_elems; /* how many elements allocated when the sequence grows
(sequence granularity) */ \
CvMemStorage* storage; /* where the seq is stored */ \
CvSeqBlock* free_blocks; /* free blocks list */ \
CvSeqBlock* first; /* pointer to the first sequence block */

typedef struct CvSeq
{
CV_SEQUENCE_FIELDS()
} CvSeq;
结构 CvSeq 是所有 OpenCV 动态数据结构的基础。
通过不同寻常的宏定义简化了带有附加参数的结构 CvSeq 的扩展。为了扩展 CvSeq,
用户可以定义一新的数据结构或在通过宏 CV_SEQUENCE_FIELDS()所包括的 CvSeq 的域
后在放入用户自定义的域。
有两种类型的序列 -- 稠密序列和稀疏序列。稠密序列都派生自 CvSeq, 它们用来代表
可扩展的一维数组 -- 向量，栈，队列，双端队列。数据间不存在空隙（即：连续存放）
-- 如果元素从序列中间被删除或插入新的元素到序列中（不是两端），那么此元素后
边的相关元素会被移动。稀疏序列都派生自 CvSet,后面会有详细的讨论。它们都是由
节点所组成的序列，每一个节点要么被占用空间要么是空，由 flag 标志指定。这些
序列作为无序的数据结构而被使用，如点集，图，哈希表等。
The field header_size contains the actual size of the sequence header and should
be greater or equal to sizeof(CvSeq).
域 header_size 含有序列头部节点的实际大小，此大小大于或等于 sizeof(CvSeq).
域 h_prev, h_next, v_prev, v_next 可用来创建不同序列的层次结构。域 h_prev,
h_next 指向同一层次结构前一个和后一个序列，而域 v_prev, v_next 指向在垂直方向
上的前一个和后一个序列，即：父亲和子孙。
域 first 指向第一个序列快，块结构在后面描述。
域 total 包含稠密序列的总元素数和稀疏序列被分配的节点数。
域 flags 的高 16 位描述（包含）特定的动态结构类型（CV_SEQ_MAGIC_VAL 表示稠密
序列,CV_SET_MAGIC_VAL 表示稀疏序列），同时包含形形色色的信息。
低 CV_SEQ_ELTYPE_BITS 位包含元素类型的 ID(标示符）。大多数处理函数并不会用到
元素类型，而会用到存放在 elem_size 中的元素大小。如果序列中包含 CvMat 中的
数据，那么元素的类型就与 CvMat 中的类型相匹配，如：CV_32SC2 可以被使用为由
二维空间中的点序列， CV_32FC1 用为由浮点数组成的序列等。通过宏
CV_SEQ_ELTYPE(seq_header_ptr) 来获取序列中元素的类型。处理数字序列的函数判
断： elem.size 等同于序列元素的大小。除了与 CvMat 相兼容的类型外，还有几个在
头 cvtypes.h 中定义的额外的类型。
Standard Types of Sequence Elements
#define CV_SEQ_ELTYPE_POINT CV_32SC2 /* (x,y) */
#define CV_SEQ_ELTYPE_CODE CV_8UC1 /* freeman code: 0..7 */
#define CV_SEQ_ELTYPE_GENERIC 0 /* unspecified type of sequence
elements */
#define CV_SEQ_ELTYPE_PTR CV_USRTYPE1 /* =6 */
#define CV_SEQ_ELTYPE_PPOINT CV_SEQ_ELTYPE_PTR /* &elem: pointer
to element of other sequence */
#define CV_SEQ_ELTYPE_INDEX CV_32SC1 /* #elem: index of element
of some other sequence */
#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 /*
first_edge, &(x,y) */
#define CV_SEQ_ELTYPE_TRIAN_ATR CV_SEQ_ELTYPE_GENERIC /* vertex of
the binary tree */
#define CV_SEQ_ELTYPE_CONNECTED_COMP CV_SEQ_ELTYPE_GENERIC /* connected
component */
#define CV_SEQ_ELTYPE_POINT3D CV_32FC3 /* (x,y,z) */
后面的 CV_SEQ_KIND_BITS 字节表示序列的类型：
Standard Kinds of Sequences
/* generic (unspecified) kind of sequence */
#define CV_SEQ_KIND_GENERIC (0 << CV_SEQ_ELTYPE_BITS)

/* dense sequence suntypes */
#define CV_SEQ_KIND_CURVE (1 << CV_SEQ_ELTYPE_BITS)
#define CV_SEQ_KIND_BIN_TREE (2 << CV_SEQ_ELTYPE_BITS)

/* sparse sequence (or set) subtypes */
#define CV_SEQ_KIND_GRAPH (3 << CV_SEQ_ELTYPE_BITS)
#define CV_SEQ_KIND_SUBDIV2D (4 << CV_SEQ_ELTYPE_BITS)

CvSeqBlock
连续序列块

typedef struct CvSeqBlock
{
struct CvSeqBlock* prev; /* previous sequence block */
struct CvSeqBlock* next; /* next sequence block */
int start_index; /* index of the first element in the block +
sequence->first->start_index */
int count; /* number of elements in the block */
char* data; /* pointer to the first element of the block */
} CvSeqBlock;
序列块构成一个双向的循环列表，因此指针 prev 和 next 永远不会为 null, 而总是
指向序列中的前一个和后一个序列块。也就是说：最后一个序列块的 next 指向的就是
序列中的第一个块，而第一个块的 prev 指向最后一个块。域 start_index 和 count
有助于跟踪序列中块的位置。例如，一个含 10 个元素的序列被分成了 3 块，每一块的
大小分别为 3， 5， 2，第一块的参数 start_index 为 2，那么该序列的 (start_index,
count) 相应为（2，3），（5，5），（10，2）。第一个块的参数 start_index 通常
为 0，除非一些元素已被插入到序列中。

CvSlice
序列分割

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

inline CvSlice cvSlice( int start, int end );
#define CV_WHOLE_SEQ_END_INDEX 0x3fffffff
#define CV_WHOLE_SEQ cvSlice(0, CV_WHOLE_SEQ_END_INDEX)

/* calculates the sequence slice length */
int cvSliceLength( CvSlice slice, const CvSeq* seq );
有关序列的一些操作函数将 CvSlice 作为输入参数，默认情况下该参数通常被设置成
整个序列（CV_WHOLE_SEQ)。start_index 和 end_index 任何一个都可以是负数或超
过序列长度，start_index 是闭界，end_index 是开界。如果两者相等，那么分割被认
为是空分割（即：不包含任何元素）。由于序列被看作是循环结构，所以分割可以选
择序列中靠后的几个元素，靠前的参数反而跟着它们，如 cvSlice（-2，3）。函数用
下列发法来规范分割参数：首先，调用 cvSliceLength 来决定分割的长度，然后，
start_index 被使用类似于 cvGetSeqElem 的参数来规范（例如：负数也被允许）。
实际的分割操作起始于规范化了的 start_index ，中止于 start_index +
cvSliceLength()。（再次假设序列是循环结构）
如果函数并不接受分割参数，但你还是想要处理序列的一部分，那么可以使用函数
cvSeqSlice 获取子序列。

CreateSeq
创建一序列

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_size 必须等同于
sizeof(CvPoint).
函数 cvCreateSeq 创建一序列并且返回指向该序列的指针。函数在存储块中
分配序列的头部作为一个连续躯体，并且设置结构的 flags 域, elem_size 域,
header_size 域和 storage 域的值为被传递过来的值，设置 delta_elems 为
默认值（可通过函数 cvSetSeqBlockSize 重新对其赋值），清空其他的头部域，
包括前 sizeof(CvSeq) 个字节的空间。

SetSeqBlockSize
设置序列块的大小

void cvSetSeqBlockSize( CvSeq* seq, int delta_elems );
seq: 序列
delta_elems: 满足元素所需的块的大小
函数 cvSetSeqBlockSize 会对内存分配的粒度产生影响。当序列缓冲区中空间消耗完
时，函数为 delta_elems 个序列元素分配空间。如果新分配的空间与之前分配的空间
相邻的话，这两个块就合并，否则，就创建了一个新的序列快。因此，参数值越大，序
列中出现碎片的可能性就越小，不过内存中更多的空间将被浪费。当序列被创建后，参
数 delta_elems 大小将被设置为默认大小（1K).之后，就可随时调用该函数，并影
响内存分配。函数可以修改被传递过来的参数值，以满足内存块的大小限制。

SeqPush
Adds element to sequence end
char* cvSeqPush( CvSeq* seq, void* element=NULL );
seq: 块
element: 添加的元素
函数 cvSeqPush 在序列块的尾部添加一元素并返回指向该元素得指针。如果输入参数
为 null, 函数就仅仅分配一空间，留给下一个元素使用。下列代码说明如何使用该函
数去创建一空间。
The following code demonstrates how to create a new sequence using this function:
CvMemStorage* storage = cvCreateMemStorage(0);
CvSeq* seq = cvCreateSeq( CV_32SC1, /* sequence of integer elements */
sizeof(CvSeq), /* header size - no extra fields */
sizeof(int), /* element size */
storage /* the container storage */ );
int i;
for( i = 0; i < 100; i++ )
{
int* added = (int*)cvSeqPush( seq, &i );
printf( "%d is added\n", *added );
}

...
/* release memory storage in the end */
cvReleaseMemStorage( &storage );
函数 cvSeqPush 的时间复杂度为 O(1). 如果需要分配并使用的空间比较大，则存在一
分配较快的函数（见：cvStartWriteSeq 和相关函数）

SeqPop
删除序列尾部元素

void cvSeqPop( CvSeq* seq, void* element=NULL );
seq: 序列
element: 可选参数。如果该指针不为空，就拷贝被珊元素到指针指向的位置
函数 cvSeqPop 从序列中删除一元素。如果序列已经为空，就报告一错误。函数时间复
杂度为 O(1).

SeqPushFront
在序列头部添加元素

char* cvSeqPushFront( CvSeq* seq, void* element=NULL );
seq: 序列
element: 添加的元素
函数 cvSeqPushFront 类似于 cvSeqPush，不过是在序列头部添加元素。时间复杂度
为 O(1).

SeqPopFront
删除序列的头部元素

void cvSeqPopFront( CvSeq* seq, void* element=NULL );
seq: 序列
element: 可选参数。如果该指针不为空，就拷贝被珊元素到指针指向的位置。
函数 cvSeqPopFront 删除序列的头部元素。如果序列已经为空，就报告一错误。函数
时间复杂度为 O(1).

SeqPushMulti
添加多个元素到序列尾部或头部。

void cvSeqPushMulti( CvSeq* seq, void* elements, int count, int in_front=0 );
seq: 序列
elements: 待添加的元素
count: 添加的元素个数
in_front: 标示在头部还是尾部添加元素
CV_BACK ( = 0) -- 在序列尾部添加元素。
CV_FRONT( != 0) -- 在序列头部添加元素。
函数 cvSeqPushMulti 在序列头部或尾部添加多个元素。元素按输入数组中的顺序被
添加到序列中，不过它们可以添加到不同的序列中

SeqPopMulti
删除多个序列头部或尾部的元素

void cvSeqPopMulti( CvSeq* seq, void* elements, int count, int in_front=0 );
seq: 序列
elements: 待删除的元素
count: 删除的元素个数
in_front: 标示在头部还是尾部删除元素
CV_BACK ( = 0) -- 删除序列尾部元素。
CV_FRONT( != 0) -- 删除序列头部元素。
函数 cvSeqPopMulti 删除多个序列头部或尾部的元素。如果待删除的元素个数超过了
序列中的元素总数，则函数删除尽可能多的元素。

SeqInsert
在序列中添加元素

char* cvSeqInsert( CvSeq* seq, int before_index, void* element=NULL );
seq: 序列
before_index: 元素插入的位置（索引）。如果插入的位置在 0（允许的参数最小值）
前，则该函数等同于函数 cvSeqPushFront.如果是在 seq_total（允许的参数最大值）
后，则该函数等同于 cvSeqPush.
element: 待插入的元素
函数 cvSeqInsert 移动从被插入的位置到序列尾部元素所在的位置的所有元素，如果
指针 element 不位 null, 则拷贝 element 中的元素到指定位置。函数返回指向被插
入元素的指针。

SeqRemove
删除序列中的元素。

void cvSeqRemove( CvSeq* seq, int index );
seq: 序列
index: 被珊元素的索引。
函数 cvSeqRemove 删除指定的索引元素。如果索引出了序列的范围，就报告发现错误。
企图从空序列中删除元素，函数报告错误。函数通过移动序列中的元素来删除索引元素。

ClearSeq
清空序列

void cvClearSeq( CvSeq* seq );
seq
Sequence.
seq: 序列
函数 cvClearSeq 删除序列中的所有元素。函数不会将内存返回到存储器中，当新的元
素添加到序列中时，可重新使用该内存。函数时间复杂度为 O(1).

GetSeqElem
返回索引所指定的元素指针

char* cvGetSeqElem( const CvSeq* seq, int index );
#define CV_GET_SEQ_ELEM( TYPE, seq, index )
(TYPE*)cvGetSeqElem( (CvSeq*)(seq), (index) )
seq: 序列
index: 索引
函数 cvGetSeqElem 查找序列中索引所指定的元素，并返回指向该元素的指
针。如果元素不存在，则返回 0。函数支持负数，即： -1 代表序列的最后
一个元素， -2 代表最后第二个元素，等。如果序列只包含一个块，或者所需
的元素在第一个块中，那么应当使用宏, CV_GET_SEQ_ELEM( elemType, seq, index )
宏中的参数 elemType 是序列中元素的类型（如：CvPoint), 参数 seq 表示序列，参
数 index 代表所需元素的索引。该宏首先核查所需的元素是否属于第一个块，如果是，
则返回该元素，否则，该宏就调用主函数 GetSeqElem. 如果索引为负数的话，则总是
调用函数 cvGetSeqElem。函数的时间复杂度为 O(1), 假设块的大小要比元素
的数量要小。

SeqElemIdx
返回序列中元素的索引

int cvSeqElemIdx( const CvSeq* seq, const void* element, CvSeqBlock**
block=NULL );
seq: 序列
element: 指向序列中元素的指针
block: 可选参数，如果不为空(NULL),则存放包含该元素的块的地址
函数 cvSeqElemIdx 返回元素的索引，如果该元素不存在这个序列中，则返回一负数。

CvtSeqToArray
拷贝序列中的元素到一个连续的内存块中

void* cvCvtSeqToArray( const CvSeq* seq, void* elements, CvSlice
slice=CV_WHOLE_SEQ );
seq: 序列
elemenets: 指向目的（存放拷贝元素的）数组的指针，指针指向的空间必须足够大。
slice: 拷贝到序列中的序列部分。
函数 cvCvtSeqToArray 拷贝整个序列或部分序列到指定的缓冲区中，并返回指向该缓
冲区的指针.

MakeSeqHeaderForArray
构建序列

CvSeq* cvMakeSeqHeaderForArray( int seq_type, int header_size, int elem_size,
void* elements, int total,
CvSeq* seq, CvSeqBlock* block );
seq_type：序列的类型
header_size：序列的头部大小。大小必须大于等于数组的大小。
elem_size：元素的大小
elements：形成该序列的元素
total：序列中元素的总数。参数值必须等于数据的大小
seq：指向被使用作为序列头部的局部变量
block：指向局部变量的指针
函数 cvMakeSeqHeaderForArray 初始化序列的头部。序列块由用户分配（例如：在栈
上）。该函数不拷贝数据。创建的序列只包含一个块，和一个 NULL 指针，因此可以读
取指针，但试图将元素添加到序列中则多数会引发错误。

SeqSlice
为各个序列碎片建立头

CvSeq* cvSeqSlice( const CvSeq* seq, CvSlice slice,
CvMemStorage* storage=NULL, int copy_data=0 );
seq: 序列
slice: 部分序列块
storage: 存放新的序列和拷贝数据（如果需要）的目的存储空间。如果为 NULL, 则函
数使用包含该输入数据的存储空间。
copy_data: 标示是否要拷贝元素，如果 copy_data != 0, 则需要拷贝；如果
copy_data == 0, 则不需拷贝。
函数 cvSeqSlice 创建一序列，该序列表示输入序列中特定的一部分（slice),。新序
列要么与原序列共享元素要么拥有自己的一份拷贝。因此，如果有人需要去处理该
部分序列，但函数却没有 slice 参数，则使用该函数去获取该序列。.

CloneSeq
创建序列的一份拷贝

CvSeq* cvCloneSeq( const CvSeq* seq, CvMemStorage* storage=NULL );
seq: 序列
storage：存放新序列的 header 部分和拷贝数据（如果需要）的目的存储块。如果为 NULL,
则函数使用包含输入序列的存储块。
函数 cvCloneSeq 创建输入序列的一份完全拷贝。调用函数 cvCloneSeq (seq, storage)
等同于调用 cvSeqSlice(seq, CV_WHOLE_SEQ, storage, 1).

SeqRemoveSlice
删除序列的
slice
部分

void cvSeqRemoveSlice( CvSeq* seq, CvSlice slice );
seq: 序列
slice: 序列中被移动的那部分
函数 cvSeqRemoveSlice 删除序列中的 slice 部分

SeqInsertSlice
在序列中插入一数组

void cvSeqInsertSlice( CvSeq* seq, int before_index, const CvArr* from_arr );
seq: 序列
slice: 序列中被移动的那部分
from_arr: 从中获取元素的数组
函数 cvSeqInsertSlice 在指定位置插入来自数组 from_arr 中所有元素。数组
from_arr 可以是一个矩阵也可以是另外一个序列。

SeqInvert
将序列中的元素进行逆序操作

void cvSeqInvert( CvSeq* seq );
seq: 序列
函数 cvSeqInvert 对序列进行逆序操作 -- 即：使第一个元素成为最后一个，最后一
个元素为第一个。

SeqSort
使用特定的比较函数对序列中的元素进行排序

/* a < b ? -1 : a > b ? 1 : 0 */
typedef int (CV_CDECL* CvCmpFunc)(const void* a, const void* b, void* userdata);

void cvSeqSort( CvSeq* seq, CvCmpFunc func, void* userdata=NULL );
seq: 待排序的序列
func: 比较函数，按照元素间的大小关系返回负数，零，正数（见：上面的声明和下面
的例子） --相关函数为 C 运行时库中的 qsort, 后者（qsort)不使用参数 userdata.
userdata: 传递给比较函数的用户参数；有些情况下，可避免全局变量的使用
函数 cvSeqSort 使用特定的标准对序列进行排序。下面是一个使用该函数的实例
/* Sort 2d points in top-to-bottom left-to-right order */
static int cmp_func( const void* _a, const void* _b, void* userdata )
{
CvPoint* a = (CvPoint*)_a;
CvPoint* b = (CvPoint*)_b;
int y_diff = a->y - b->y;
int x_diff = a->x - b->x;
return y_diff ? y_diff : x_diff;
}

...

CvMemStorage* storage = cvCreateMemStorage(0);
CvSeq* seq = cvCreateSeq( CV_32SC2, sizeof(CvSeq), sizeof(CvPoint), storage );
int i;

for( i = 0; i < 10; i++ )
{
CvPoint pt;
pt.x = rand() % 1000;
pt.y = rand() % 1000;
cvSeqPush( seq, &pt );
}

cvSeqSort( seq, cmp_func, 0 /* userdata is not used here */ );

/* print out the sorted sequence */
for( i = 0; i < seq->total; i++ )
{
CvPoint* pt = (CvPoint*)cvSeqElem( seq, i );
printf( "(%d,%d)\n", pt->x, pt->y );
}

cvReleaseMemStorage( &storage );

SeqSearch
查询序列中的元素
/* 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 );
seq: 序列
elem: 待查询的元素
func: 比较函数，按照元素间的大小关系返回负数，零，正数（见：cvSeqSort）
is_sorted: 标示序列是否已经排序
elem_idx: 输出参数；（已查找到）元素的索引值
user_data: 传递到比较函数的用户参数；在某些情况下，有助于避免使用全局变量。
函数 cvSeqSearch 查找序列中的元素。如果序列已被排序，则使用二分查找（时间复
杂度为 O(log(N))否则使用简单线性查找。若查找的元素不存在，函数返回 NULL 指针，
而索引值设置为序列中的元素数（如果使用的是线性查找）或满足表达式 seq(i) >
elem 的最小的 i.

StartAppendToSeq
将数据写入序列中，并初始化该过程

void cvStartAppendToSeq( CvSeq* seq, CvSeqWriter* writer );
seq: 指向序列的指针
writer: writer 的状态；由该函数初始化
函数 cvStartAppendToSeq 初始化将数据写入序列这个过程。通过宏
CV_WRITE_SEQ_ELEM( written_elem, writer )，写入的元素被添加到序列尾部。注意：
在写入期间，序列的其他操作可能会产生的错误的结果，甚至破怀该序列（见
cvFlushSeqWriter 的相关描述，有助于避免这些错误）

StartWriteSeq
创建新序列，并初始化写入部分（
writer)
void cvStartWriteSeq( int seq_flags, int header_size, int elem_size,
CvMemStorage* storage, CvSeqWriter* writer );
seq_flags: 标示被创建的序列。如果序列还未传递给任何处理特定序列类型的函数，
则序列值等于 0，否则，必须从之前定义的序列类型中选择一个合适的类型。
header_size: 头部的大小。参数值不小于 sizeof(CvSeq). 如果定义了某一类型，则
该类型不许符合基类的条件。
elem_size: 元素的大小（以字节计）；必须与序列类型相一致。例如：如果创建了包
含指针的序列（元素类型为 CV_SEQ_ELTYPE_POINT), 那么 elem_size 必须等同于
sizeof(CvPoint).
storage: 序列的（在内存）位置
writer: 写入部分 writer 的状态；由该函数初始化
函数 cvStartWriteSeq 是函数 cvCreateSeq 和函数 cvStartAppendToSeq 的组合。
指向被创建的序列的指针存放在 writer->seq 中, 通过函数 cvEndWriteSeq 返回（因
当在最后调用）

EndWriteSeq
完成写入操作
CvSeq* cvEndWriteSeq( CvSeqWriter* writer );
• writer：写入部分 writer 的状态
函数 cvEndWriteSeq 完成写入操作并返回指向被写入元素的序列的地址。同时，函数
会截取最后那个不完整的序列块，将块的剩余部分返回到内存中之后，序列就可以被安
全的读和写。

FlushSeqWriter
根据写入状态，刷新序列头部
void cvFlushSeqWriter( CvSeqWriter* writer );
writer: 写入部分的状态
函数 cvFlushSeqWriter 用来使用户在写入过程中每当需要时读取序列元素，比如说，
核查制定的条件。函数更新序列的头部，从而使读取序列中的数据成为可能。不过，写
入并没有被关闭，为的是随时都可以将数据写入序列。在有些算法中，经常需要刷新，
考虑使用 cvSeqPush 代替该函数。

StartReadSeq
初始化序列中的读取过程

void cvStartReadSeq( const CvSeq* seq, CvSeqReader* reader, int reverse=0 );
seq: 序列
reader: 读取部分的状态；由该函数初始化
reverse: 决定遍历序列的方向。如果 reverse 为０，则读取顺序被定位从序列头部
元素开始，否则从尾部开始读取
函数 cvStartReadSeq 初始化读取部分的状态。毕竟，顺序读取可通过调用
宏 CV_READ_SEQ_ELEM( read_elem, reader )，逆序读取可通过调用宏
CV_REV_READ_SEQ_ELEM( read_elem, reader )。这两个宏都将序列元素读进
read_elem 中，并将指针移到下一个元素。下面代码显示了如何去使用 reader
和 writer.
CvMemStorage* storage = cvCreateMemStorage(0);
CvSeq* seq = cvCreateSeq( CV_32SC1, sizeof(CvSeq), sizeof(int), storage );
CvSeqWriter writer;
CvSeqReader reader;
int i;

cvStartAppendToSeq( seq, &writer );
for( i = 0; i < 10; i++ )
{
int val = rand()%100;
CV_WRITE_SEQ_ELEM( val, writer );
printf("%d is written\n", val );
}
cvEndWriteSeq( &writer );

cvStartReadSeq( seq, &reader, 0 );
for( i = 0; i < seq->total; i++ )
{
int val;
#if 1
CV_READ_SEQ_ELEM( val, reader );
printf("%d is read\n", val );
#else /* alternative way, that is prefferable if sequence elements are large,
or their size/type is unknown at compile time */
printf("%d is read\n", *(int*)reader.ptr );
CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
#endif
}
...

cvReleaseStorage( &storage );

GetSeqReaderPos
返回当前的读取器的位置

int cvGetSeqReaderPos( CvSeqReader* reader );
reader
读取器的状态.
函数 cvGetSeqReaderPos 返回当前的 reader 位置（在 0 到 reader->seq->total -
1 中）

SetSeqReaderPos
移动读取器到指定的位置。

void cvSetSeqReaderPos( CvSeqReader* reader, int index, int is_relative=0 );
reader: reader 的状态
index: 目的位置。如果使用了 positioning mode, 则实际位置为 index %
reader->seq->total.
is_relative: 如果不位 0, 那么索引（index) 就相对于当前的位置
函数 cvSetSeqReaderPos 将 read 的位置移动到绝对位置，或相对于当前的位置（相
对位置）

Sets

CvSet
Collection of nodes
typedef struct CvSetElem
{
int flags; /* it is negative if the node is free and zero or positive
otherwise */
struct CvSetElem* next_free; /* if the node is free, the field is a
pointer to next free node */
}
CvSetElem;

#define CV_SET_FIELDS() \
CV_SEQUENCE_FIELDS() /* inherits from CvSeq */ \
struct CvSetElem* free_elems; /* list of free nodes */

typedef struct CvSet
{
CV_SET_FIELDS()
} CvSet;
在 OpenCV 的稀疏数据结构中， CvSet 是一基本结构。
从上面的声明中可知：CvSet 继承自 CvSeq，并在此基础上增加了个 free_elems 域，
该域是空节点组成的列表。集合中的每一个节点，无论空否，都是线性表中的一个元素。
尽管对于稠密的表中的元素没有限制，集合（派生的结构）元素必须起始于整数域，并
与结构 CvSetElem 相吻合，因为这两个域对于（由空节点组成）集合的组织是必要的。
如果节点为空，flags 为负，next_free 指向下一个空节点。如果节点已被占据空间，
flags 为正， flags 包含节点索引值（使用表达式 set_elem->flags &
CV_SET_ELEM_IDX_MASKH 获取), flags 的剩余内容由用户决定。宏
CV_IS_SET_ELEM(set_elem.ptr)用来识别特定的节点是否为空。
起初,集合 set 同表 list 都为空。当需要一个来自集合中的新节点时，就从表 list
中去获取，然后表进行了更新。如果表 list 碰巧为空，于是就分配一内存块，块中的
所有节点与表 list 相连。结果，集合的 total 域被设置为空节点和非空节点的和。
当非空节点别释放后，就将它加到空节点列表中。最先被释放的节点也就是最先被占用
空间的节点
在 OpenCV 中， CvSet 用来代表图形（CvGraph), 稀疏多维数组（CvSparseMat), 平
面子划分（planner subdivisions)等

CreateSet
创建空的数据集
CvSet* cvCreateSet( int set_flags, int header_size,
int elem_size, CvMemStorage* storage );
set_flags: 集合的类型
header_size: 头节点的大小；可能小于 sizeof(CvSet)
elem_size: 元素的大小；可能小于 CvSetElem
storage: 相关容器
函数 CvCreateSet 创建一具有特定头部节点大小和元素类型的空集。并返回指向该集
合的指针。

SetAdd
占用集合中的一个节点
int cvSetAdd( CvSet* set_header, CvSetElem* elem=NULL, CvSetElem**
inserted_elem=NULL );
set_header: 集合
elem: 可选的输入参数，被插入的元素。如果不为 NULL, 函数就将数据拷贝到新分配
的节点。（拷贝后，清空第一个域的 MSB)
函数 cvSetAdd 分配一新的节点，将输入数据拷贝给它（可选），并且返回指向该节点
的指针和节点的索引值。索引值可通过节点的 flags 域的低位中获得。函数的时间复杂
度为 O(1), 不过，存在着一个函数可快速的分配内存。（见 cvSetNew)

SetRemove
从点集中删除元素

void cvSetRemove( CvSet* set_header, int index );
set_header：集合
index：被删元素的索引值
函数 cvSetRemove 从点集中删除一具有特定索引值的元素。如果指定位置的节点为空，
函数将什么都不做。函数的时间复杂度为 O(1), 不过,存在一函数可更快速的完成该操
作，该函数就是 cvSetRemoveByPtr

SetNew
添加元素到点集中

CvSetElem* cvSetNew( CvSet* set_header );
• set_header: 集合
函数 cvSetNew 是 cvSetAdd 的变体，内联函数。它占用一新节点，并返回指向该节点
的指针而不是索引。

SetRemoveByPtr
删除指针指向的集合元素

void cvSetRemoveByPtr( CvSet* set_header, void* elem );
set_header: 集合
elem: 被删除的元素
函数 cvSetRemoveByPtr 是一内联函数，是函数 cvSetRemove 轻微变化而来的。该函
数并不会检查节点是否为空 -- 用户负责这一检查。

GetSetElem
通过索引值查找相应的集合元素

CvSetElem* cvGetSetElem( const CvSet* set_header, int index );
set_header: 集合
index: 索引值
函数 cvGetSetElem 通过索引值查找相应的元素。函数返回指向该元素的指针，如果索
引值无效或相应的节点为空，则返回 0。若函数使用 cvGetSeqElem 去查找节点，则
函数支持负的索引值。

ClearSet
清空点集

void cvClearSet( CvSet* set_header );
set_header: 待清空的点集
函数 cvClearSet 删除集合中的所有元素。时间复杂度为 O(1).

Graphs

CvGraph
有向权图和无向权图

#define CV_GRAPH_VERTEX_FIELDS() \
int flags; /* vertex flags */ \
struct CvGraphEdge* first; /* the first incident edge */

typedef struct CvGraphVtx
{
CV_GRAPH_VERTEX_FIELDS()
}
CvGraphVtx;

#define CV_GRAPH_EDGE_FIELDS() \
int flags; /* edge flags */ \
float weight; /* edge weight */ \
struct CvGraphEdge* next[2]; /* the next edges in the incidence lists
for staring (0) */ \
/* and ending (1) vertices */ \
struct CvGraphVtx* vtx[2]; /* the starting (0) and ending (1) vertices
*/

typedef struct CvGraphEdge
{
CV_GRAPH_EDGE_FIELDS()
}
CvGraphEdge;

#define CV_GRAPH_FIELDS() \
CV_SET_FIELDS() /* set of vertices */ \
CvSet* edges; /* set of edges */

typedef struct CvGraph
{
CV_GRAPH_FIELDS()
}
CvGraph;
在 OpenCV 图形结构中，CvGraph 是一基本结构。
图形结构继承自 CvSet -- 该部分描绘了普通图的属性和图的顶点，也包含了一个点集
作为其成员 -- 该点集描述了图的边缘。利用宏（可以简化结构扩展和定制）使用与其
它 OpenCV 可扩展结构一样的方法和技巧，同样的方法和技巧，我们声明了定点，边和
头部结构。虽然顶点结构和边结构无法从 CvSetElem 显式地继承时，但它们满足点集元
素的两个条件（在开始是有一个整数域和满足 CvSetElem 结构）。 flags 域用来标
记顶点和边是否已被占用或者处于其他目的，如：遍历图时（见：cvStartScanGraph 等），
因此最好不要去直接使用它们。图代表的就是边的集合。存在有向和无向的区别。对于
后者（无向图），在连接顶点 A 到顶点 B 的边同连接顶点 B 到顶点 A 的边是没什
么区别的，在某一时刻，只可能存在一个，即：要么是要么是.

CreateGraph
创建一个空树

CvGraph* cvCreateGraph( int graph_flags, int header_size, int vtx_size,
int edge_size, CvMemStorage* storage );
graph_flags: 被创建的图的类型。通常，无向图为 CV_SEQ_KIND_GRAPH,无向图为
CV_SEQ_KIND_GRAPH | CV_GRAPH_FLAG_ORIENTED.
header_size: 头部大小；可能小于 sizeof(CvGraph)
vtx_size: 顶点大小；常规的定点结构必须来自 CvGraphVtx (使用宏
CV_GRAPH_VERTEX_FIELDS())
edge_size: 边的大小；常规的边结构必须来自 CvGraphEdge (使用宏
CV_GRAPH_EDGE_FIELDS())
storage: 图的容器
函数 cvCreateGraph 创建一空图并且返回指向该图的指针。

GraphAddVtx
插入一顶点到图中

int cvGraphAddVtx( CvGraph* graph, const CvGraphVtx* vtx=NULL,
CvGraphVtx** inserted_vtx=NULL );
graph: 图
vtx: 可选输入参数，用来初始化新加入的顶点（仅大小超过 sizeof(CvGraphVtx) 的
用户自定义的域才会被拷贝）
inserted_vertex: 可选的输出参数。如果不为 NULL, 则传回新加入顶点的地址
函数 cvGraphAddVtx 将一顶点加入到图中，并返回定点的索引

GraphRemoveVtx
通过索引从图中删除一顶点

int cvGraphRemoveVtx( CvGraph* graph, int index );
graph: 图
vtx_idx: 被珊顶点的索引
函数 cvGraphRemoveAddVtx 从图中删除一顶点，连同删除含有此顶点的边。如果输入
的顶点不属于该图的话，将报告删除出错（不存在而无法删除）。返回值为被删除的边
数，如果顶点不属于该图的话，返回 -1。

GraphRemoveVtxByPtr
通过指针从图中删除一顶点

int cvGraphRemoveVtxByPtr( CvGraph* graph, CvGraphVtx* vtx );
graph: 图
vtx; 指向被删除的边的指针
函数 cvGraphRemoveVtxByPtr 从图中删除一顶点，连同删除含有此顶点的边。如果输
入的顶点不属于该图的话，将报告删除出错（不存在而无法删除）。返回值为被删除的
边数，如果顶点不属于该图的话，返回 -1。

GetGraphVtx
通过索引值查找图的相应顶点

CvGraphVtx* cvGetGraphVtx( CvGraph* graph, int vtx_idx );
graph: 图
vtx_idx: 定点的索引值
函数 cvGetGraphVtx 通过索引值查找对应的顶点，并返回指向该顶点的指针，如果不
存在则返回 NULL.

GraphVtxIdx
返回定点相应的索引值
int cvGraphVtxIdx( CvGraph* graph, CvGraphVtx* vtx );
graph: 图
vtx: 指向顶点的指针
函数 cvGraphVtxIdx 返回与顶点相应的索引值

GraphAddEdge
通过索引值在图中加入一条边

int cvGraphAddEdge( CvGraph* graph, int start_idx, int end_idx,
const CvGraphEdge* edge=NULL, CvGraphEdge**
inserted_edge=NULL );
graph: 图
start_idx; 边的起始顶点的索引值
end_idx: 边的尾部顶点的索引值（对于无向图，参数的次序无关紧要，即：start_idx
和 end_idx 可互为起始顶点和尾部顶点）
edge: 可选的输入参数，初始化边的数据
inserted_edge: 可选的输出参数，包含被插入的边的地址。
函数 cvGraphAddEdge 连接两特定的顶点。如果该边成功地加入到图中，返回 1；如
果连接两顶点的边已经存在，返回 0；如果顶点没被发现（不存在）或者起始顶点和
尾部顶点是同一个定点，或其他特殊情况，返回 -1。如果是后者（即：返回值为负），
函数默认的报告一个错误。

GraphAddEdgeByPtr
通过指针在图中加入一条边

int cvGraphAddEdgeByPtr( CvGraph* graph, CvGraphVtx* start_vtx, CvGraphVtx*
end_vtx,
const CvGraphEdge* edge=NULL, CvGraphEdge**
inserted_edge=NULL );
const CvGraphEdge* edge=NULL, CvGraphEdge**
inserted_edge=NULL )
graph:图
start_vtx: 指向起始顶点的指针
end_vtx: 指向尾部顶点的指针。对于无向图来说，顶点参数的次序无关紧要。
edge: 可选的输入参数，初始化边的数据
inserted_edge: 可选的输出参数，包含被插入的边的地址。
函数 cvGraphAddEdge 连接两特定的顶点。如果该边成功地加入到图中，返回 1；如
果连接两顶点的边已经存在，返回 0；如果顶点没被发现（不存在）或者起始顶点和
尾部顶点是同一个定点，或其他特殊情况，返回 -1。如果是后者（即：返回值为负），
函数默认的报告一个错误

GraphRemoveEdge
通过索引值从图中删除顶点

void cvGraphRemoveEdge( CvGraph* graph, int start_idx, int end_idx );
graph: 图
start_idx: 起始顶点的索引值
end_idx; 尾部顶点的索引值。对于无向图来说，顶点参数的次序无关紧要。
函数 cvGraphRemoveEdge 删除连接两特定顶点的边。若两顶点并没有相连接（即：不
存在由这两个顶点连接的边），函数什么都不做。

GraphRemoveEdgeByPtr
通过指针从图中删除边

void cvGraphRemoveEdgeByPtr( CvGraph* graph, CvGraphVtx* start_vtx,
CvGraphVtx* end_vtx );
graph: 图
start_vtx; 指向起始顶点的指针
end_vtx; 指向尾部顶点的指针。对于无向图来说，顶点参数的次序无关紧要。
函数 cvGraphRemoveEdgeByPtr 删除连接两特定顶点的边。若两顶点并没有相连接（即：
不存在由这两个顶点连接的边），函数什么都不做。

FindGraphEdge
通过索引值在图中查找相应的边

CvGraphEdge* cvFindGraphEdge( const CvGraph* graph, int start_idx, int end_idx );
#define cvGraphFindEdge cvFindGraphEdge
graph: 图
start_idx: 其实顶点的索引值
end_idx; 尾部顶点的索引值。对于无向图来说，顶点参数的次序无关紧要
函数 cvFindGraphEdge 查找与两特定顶点相对应的边，并返回指向该边的指针。如果
该边不存在，返回 NULL.

FindGraphEdgeByPtr
通过指针在图中查找相应的边

CvGraphEdge* cvFindGraphEdgeByPtr( const CvGraph* graph, const CvGraphVtx*
start_vtx,
const CvGraphVtx* end_vtx );
#define cvGraphFindEdgeByPtr cvFindGraphEdgeByPtr
graph: 图
start_vtx; 指向起始顶点的指针
end_vtx; 指向尾部顶点的指针。对于无向图来说，顶点参数的次序无关紧要。
函数 cvFindGraphEdgeByPtr 查找与两特定顶点相对应的边，并返回指向该边的指针。
如果该边不存在，返回 NULL

GraphEdgeIdx
返回与该边相应的索引值
int cvGraphEdgeIdx( CvGraph* graph, CvGraphEdge* edge );
graph: 图
edge: 指向该边的指针
函数 cvGraphEdgeIdx 返回与边对应的索引值。

GraphVtxDegree
（通过索引值）统计与顶点相关联的边数

int cvGraphVtxDegree( const CvGraph* graph, int vtx_idx );
graph: 图
vtx_idx: 顶点对应的索引值
函数 cvGraphVtxDegree 返回与特定顶点相关联的边数，包括以该顶点为起始顶点的和
尾部顶点的。统计边数，可以适用下列代码：
CvGraphEdge* edge = vertex->first; int count = 0;
while( edge )
{
edge = CV_NEXT_GRAPH_EDGE( edge, vertex );
count++;
}
宏 CV_NEXT_GRAPH_EDGE(edge, vertex) 返回依附于该顶点的下一条边。

GraphVtxDegreeByPtr
（通过指针）统计与顶点相关联的边数

int cvGraphVtxDegreeByPtr( const CvGraph* graph, const CvGraphVtx* vtx );
graph: 图
vtx: 顶点对应的指针
函数 cvGraphVtxDegreeByPtr 返回与特定顶点相关联的边数，包括以该顶点为起始顶
点的和尾部顶点的

ClearGraph
删除图
void cvClearGraph( CvGraph* graph );
graph:图
函数 cvClearGraph 删除该图的所有顶点和边。时间复杂度为 O(1).

CloneGraph
克隆图

CvGraph* cvCloneGraph( const CvGraph* graph, CvMemStorage* storage );
graph: 待拷贝的图
storage: 容器，存放拷贝
函数 cvCloneGraph 创建图的完全拷贝。如果顶点和边含有指向外部变量的指针，那么
图和它的拷贝共享这些指针。在新的图中，顶点和边可能存在不同，因为函数重新分割
了顶点和边的点集。

CvGraphScanner
图的遍历
typedef struct CvGraphScanner
{
CvGraphVtx* vtx; /* current graph vertex (or current edge origin)
*/
CvGraphVtx* dst; /* current graph edge destination vertex */
CvGraphEdge* edge; /* current edge */

CvGraph* graph; /* the graph */
CvSeq* stack; /* the graph vertex stack */
int index; /* the lower bound of certainly visited vertices
*/
int mask; /* event mask */
}
CvGraphScanner;
结构 cvGraphScanner 深度遍历整个图。函数的相关讨论如下（看：StartScanGraph)

StartScanGraph
创建一结构，用来对图进行深度遍历

CvGraphScanner* cvCreateGraphScanner( CvGraph* graph, CvGraphVtx* vtx=NULL,
int mask=CV_GRAPH_ALL_ITEMS );
graph: 图
vtx: 开始遍历的（起始）顶点。如果为 NULL, 便利就从第一个顶点开始（指：顶点序
列中，具有最小索引值的顶点）
mask: 事件掩码（event mask)代表用户感兴趣的事件（此时函数 cvNextGraphItem 将
控制返回给用户）。这个只可能是 CV_GRAPH_ALL_ITEMS (如果用户对所有的事件都感
兴趣的话）或者是下列标志的组合:
CV_GRAPH_VERTEXT -- 在第一次被访问的顶点处停下
CV_GRAPH_TREE_EDGE -- 在 tree edge 处停下(tree edge 指连接最后被访问的
顶点与接下来被访问的顶点的边）
CV_GRAPH_BACK_EDGE -- 在 back edge 处停下（back edge 指连接最后被访问的
顶点与其在搜索树中祖先的边）
CV_GRAPH_FORWARD_EDGE -- 在 forward edge 处停下（forward edge 指连接最
后被访问的顶点与其在搜索树中后裔的边）
CV_GRAPH_CROSS_EDGE -- 在 cross edge 处停下（cross edge 指连接不同搜索
树中或同一搜索树中不同分支的边.只有在有向图中，才存在着一概念）
CV_GRAPH_ANY_EDGE -- 在 any edge 处停下（any edge 指任何边，包括 tree
edge, back edge, forward edge, cross edge)
CV_GRAPH_NEW_TREE -- 在每一个新的搜索树开始处停下。首先遍历从起始顶点开
始可以访问到的顶点和边，然后查找搜索图中访问不到的顶点或边并恢复遍历。在开始
遍历一颗新的树时（包括第一次调用 cvNextGraphItem 时的树），产生
CV_GRAPH_NEW_TREE 事件。
函数 cvCreateGraphScanner 创建一结构用来深度遍历搜索树。函数 cvNextGraphItem
要使用该初始化了的结构 -- 层层遍历的过程。

NextGraphItem
逐层遍历整个图

int cvNextGraphItem( CvGraphScanner* scanner );
scanner: 图的遍历状态。被此函数更新。
函数 cvNextGraphItem 遍历整个图，直到用户感兴趣的事件发生（即：调用
cvCreateGraphScanner 时， mask 对应的事件）或遍历结束。在前面一种情况下，函
数返回参数 mask 相应的事件，当再次调用函数时，恢复遍历）。在后一种情况下，返
回 CV_GRAPH_OVER(-1)。当 mask 相应的事件为 CV_GRAPH_BACKTRACKING 或
CV_GRAPH_NEW_TEEE 时，当前正在被访问的顶点被存放在 scanner->vtx 中。如果事
件与边 edge 相关，那么 edge 本身被存放在 scanner->edge, 该边的起始顶点存放在
scanner->vtx 中，尾部节点存放在 scanner->dst 中。

ReleaseGraphScanner
完成图地遍历过程

void cvReleaseGraphScanner( CvGraphScanner** scanner );
scanner: 指向遍历器的指针.
函数 cvGraphScanner 完成图的遍历过程，并释放遍历器的状态。

Trees

CV_TREE_NODE_FIELDS
用于树结点类型声明的（助手）宏

#define CV_TREE_NODE_FIELDS(node_type) \
int flags; /* micsellaneous flags */ \
int header_size; /* size of sequence header */ \
struct node_type* h_prev; /* previous sequence */ \
struct node_type* h_next; /* next sequence */ \
struct node_type* v_prev; /* 2nd previous sequence */ \
struct node_type* v_next; /* 2nd next sequence */
宏 CV_TREE_NODE_FIELDS() 用来声明一层次性结构，例如 CvSeq -- 所有动态结构的
基本类型。如果树的节点是由该宏所声明的，那么就可以使用（该部分的）以下函数对
树进行相关操作。

CvTreeNodeIterator
打开现存的存储结构或者创建新的文件存储结构

typedef struct CvTreeNodeIterator
{
const void* node;
int level;
int max_level;
}
CvTreeNodeIterator;
结构 CvTreeNodeIterator 用来对树进行遍历。该树的节点是由宏
CV_TREE_NODE_FIELDS 声明。

InitTreeNodeIterator
用来初始化树结点的迭代器

void cvInitTreeNodeIterator( CvTreeNodeIterator* tree_iterator,
const void* first, int max_level );
tree_iterator: 初始化了的迭代器
first: （开始）遍历的第一个节点
max_level: 限制对树进行遍历的最高层（即：第 max_level 层）(假设第一个节点所
在的层为第一层）。例如：1 指的是遍历第一个节点所在层，2 指的是遍历第一层和第
二层
函数 cvInitTreeNodeIterator 用来初始化树的迭代器。

NextTreeNode
返回当前节点，并将迭代器 iterator 移向当前节点的下一个节点
void* cvNextTreeNode( CvTreeNodeIterator* tree_iterator );
tree_iterator: 初始化了的迭代器
函数 cvNextTreeNode 返回当前节点并且更新迭代器（iterator) -- 并将 iterator 移
向（当前节点）下一个节点。换句话说，函数的行为类似于表达式 *p++ (通常的 C 指
针或 C++ 集合迭代器）。如果没有更多的节点（即：当前节点为最后的节点），则
函数返回值为 NULL.

PrevTreeNode
返回当前节点，并将迭代器 iterator 移向当前节点的前一个节点
void* cvPrevTreeNode( CvTreeNodeIterator* tree_iterator );
tree_iterator: 初始化了的迭代器
函数 cvPrevTreeNode 返回当前节点并且更新迭代器（iterator) -- 并将 iterator 移
向（当前节点的）前一个节点。换句话说，函数的行为类似于表达式 *p-- (通常的 C 指
针或 C++ 集合迭代器）。如果没有更多的节点（即：当前节点为头节点），则函数
返回值为 NULL.

TreeToNodeSeq
将所有的节点指针（即：指向树结点的指针）收集到线性表 sequence 中
CvSeq* cvTreeToNodeSeq( const void* first, int header_size, CvMemStorage*
storage );
first: 初始树结点
header_size: 线性表的表头大小，大小通常为 sizeof(CvSeq)
函数 cvTreeToNodeSeq 将树的节点指针挨个的存放到线性表中。存放的顺序以深度为
先。

InsertNodeIntoTree
将新的节点插入到树中

void cvInsertNodeIntoTree( void* node, void* parent, void* frame );
node: 待插入的节点
parent: 树中的父节点（即：含有子节点的节点）
frame: 顶部节点。如果节点 parent 等同于节点 frame，则将节点的域 v_prev 设
为 NULL 而不是 parent.
函数 cvInsertNodeIntoTree 将另一个节点插入到树中。函数不分配任何内存，仅仅修
改树节点的连接关系。

RemoveNodeFromTree
从树中删除节点

void cvRemoveNodeFromTree( void* node, void* frame );
node：待删除的节点。
frame: 顶部节点。如果 node->v.prev = NULL 且 node->h.prev = NULL, 则将
frame->v.next 设为 node->h.next
函数 cvRemoveNodeFromTree 从树中删除节点。它不会释放任何内存，仅仅修改树中节
点的连接关系

绘图函数
绘图函数作用于任何象素深度的矩阵/图像. Antialiasing 技术只能在 8 位图像上实现.
所有的函数包括彩色图像的色彩参数（色彩参数是指 rgb 它是由宏 CV_RGB 或 cvScalar
函数构成。）和灰度图像的亮度。
.如果一幅绘制图形部分或全部位于图像之外，那么对它先做裁剪。对于彩色图像正常
的色彩通道是 B(蓝),G(绿),R(红)..。如果需要其它的色彩，可以通过 cvScalar 中的特
殊色彩通道构造色彩，或者在绘制图像之前或之后使用 cvCvtColor 或者 cvTransform
来转换。

曲线与形状

CV_RGB
创建

一个色彩值
.
#define CV_RGB( r, g, b ) cvScalar( (b), (g), (r) )

Line
绘制连接两个点的线段

void cvLine( CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color,
int thickness=1, int line_type=8, int shift=0 );
img
图像。
pt1
线段的第一个端点。
pt2
线段的第二个端点。
color
线段的颜色。
thickness
线段的粗细程度。
line_type
线段的类型。
8 (or 0) - 8-（connected line)连接线。
4 - 4-(connected line)连接线。
CV_AA - antialiased 线条。
shift
坐标点的小数点位数。
函数 cvLine 在图像中的点 1 和点 2 之间画一条线段。线段被图像或感兴趣的矩形所裁
剪。对于具有整数坐标的 non-antialiasing 线条，使用 8-连接或者 4-连接 Bresenham
算法。画粗线条时结尾是圆形的。画 antialiased 线条使用高斯滤波。对于特殊颜色
的线条使用宏 CV_RGB( r, g, b )。

Rectangle
绘制简单、指定粗细或者带填充的

矩形

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) 或亮度（灰度图像）(grayscale image）。
thickness
组成矩形的线条的粗细程度。取负值时（如 CV_FILLED）函数绘制填充了色彩的矩形。
line_type
线条的类型。见 cvLine 的描述
shift
坐标点的小数点位数。

函数 cvRectangle 通过对角线上的两个顶点绘制矩形。

Circle
绘制圆形。

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 绘制或填充一个给定圆心和半径的圆。圆被感兴趣矩形所裁剪。若指定
圆的颜色，可以使用宏 CV_RGB ( r, g, b )。

Ellipse
绘制椭圆圆弧和椭圆扇形。

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 矩形所忽
略。反走样弧线和粗弧线使用线性分段近似值。所有的角都是以角度的形式给定的。图
片下面要解释参数的含义。
Parameters of Elliptic Arc

FillPoly
填充多边形内部

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
组成多边形的线条的类型。
shift
顶点坐标的小数点位数。
函数 cvFillPoly 用于一个单独被多变形轮廓所限定的区域内进行填充。函数可以填充
复杂的区域,例如，有漏洞的区域和有交叉点的区域等等。

FillConvexPoly
填充多边形外部

void cvFillConvexPoly( CvArr* img, CvPoint* pts, int npts,
CvScalar color, int line_type=8, int shift=0 );
img
图像初始化。
pts
多边形的定点坐标集合。
npts
多边形的定点个数.
color
多边形的颜色。.
line_type
组成多边形的线条的类型。
shift
顶点坐标的小数点位数。

函数 cvFillConvexPoly 填充多边形限定区域的。这个函数比函数 cvFillPoly 在响应速
度上更快。它除了可以填充多边形区域的外部还可以填充任何的单调多边形。例如：一
个被水平线（扫描线）至多两次截断的多边形。

PolyLine
绘制多边形。

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
线段的类型。
shift
顶点的小数点位数。
函数 cvPolyLine 绘制一个简单的或多样的多角曲线。

文本

InitFont
字体结构初始化。

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 字体集 (http://sources.isc.org/utils/misc/hershey-font.txt) 。
CV_FONT_HERSHEY_SIMPLEX - 正常大小无衬线字体。
CV_FONT_HERSHEY_PLAIN - 小号无衬线字体。
CV_FONT_HERSHEY_DUPLEX - 正常大小无衬线字体。( 比 CV_FONT_HERSHEY_SIMPLEX
更复杂)
CV_FONT_HERSHEY_COMPLEX - 正常大小有衬线字体。
CV_FONT_HERSHEY_TRIPLEX - 正常大小有衬线字体 ( 比 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
字体的斜度。当值为 0 时，字符不倾斜。当值为 1.0f 时，字体倾斜 45 度。
thickness
字体笔划的粗细程度。.
line_type
字体笔划的类型，见 cvLine 的描述。
函数 cvInitFont 完成对文本的描述。

PutText
在图像中加入文本。

void cvPutText( CvArr* img, const char* text, CvPoint org, const CvFont* font,
CvScalar color );
img
输入图像。
text
显示字符串。
org
第一个字符左下角的坐标。
font
字体结构初始化。
color
文本的字体颜色。
函数 cvPutText 将具有指定字体的和指定颜色的文本加载到图像中。加载到图像中的文
本被感兴趣的矩形框圈定。

GetTextSize
设置字符串文本的宽度和高度。

void cvGetTextSize( const char* text_string, const CvFont* font, CvSize*
text_size, int* baseline );
font
字体结构初始化
text_string
输入字符串。
text_size
合成字符串的字符的大小。文本的高度不包括基线以下的部分。
baseline
基线长度。
函数 cvGetTextSize 是用于当特殊的字体在指定的字符串中被使用的时候计算 binding
rectangle 的。

点集和轮廓

DrawContours
在图像中绘制简单的和复杂的轮廓。

void cvDrawContours( CvArr *img, CvSeq* contour,
CvScalar external_color, CvScalar hole_color,
int max_level, int thickness=1,
int line_type=8 );
img
图像初始化。
contour
指针指向初始轮廓。
external_color
外层轮廓的颜色。
hole_color
内层轮廓的颜色。
max_level
绘制轮廓的最大等级。如果等级为 0，绘制单独的轮廓。如果为 1，在相同的级别下绘制轮
廓。如果值为 2，所有的轮廓。If 2, all contours after and all contours one level below the contours
are drawn, etc.如果值为负数，函数不能绘制轮廓 If the value is negative, the function does not
draw the contours following after contour but draws child contours of contour up to
abs(max_level)-1 level.
thickness
绘制轮廓时所使用的线条的粗细度。如果值为负(e.g. =CV_FILLED),绘制内层轮廓。
line_type
线条的类型。
函数 cvDrawContours cvDrawContours 如果 thickness>=0 在图像中绘制轮廓。如果
thickness<0 在限定的区域内绘制轮廓。
示例. 通过 contour 函数探测连通分支量
#include "cv.h"
#include "highgui.h"

int main( int argc, char** argv )
{
IplImage* src;
// 第一条命令行参数确定了图像的文件名。
if( argc == 2 && (src=cvLoadImage(argv[1], 0))!= 0)
{
IplImage* dst = cvCreateImage( cvGetSize(src), 8, 3 );
CvMemStorage* storage = cvCreateMemStorage(0);
CvSeq* contour = 0;

cvThreshold( src, src, 1, 255, CV_THRESH_BINARY );
cvNamedWindow( "Source", 1 );
cvShowImage( "Source", src );

cvFindContours( src, storage, &contour, sizeof(CvContour),
CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );
cvZero( dst );

for( ; contour != 0; contour = contour->h_next )
{
CvScalar color = CV_RGB( rand()&255, rand()&255, rand()&255 );
/* 用 1 替代 CV_FILLED 所指示的轮廓外形 */
cvDrawContours( dst, contour, color, color, -1, CV_FILLED, 8 );
}

cvNamedWindow( "Components", 1 );
cvShowImage( "Components", dst );
cvWaitKey(0);
}
}
在样本中用 1 替代 CV_FILLED 所指示的轮廓外形。

数据保存和运行时类型信息

文件存储

CvFileStorage
文件存储器的初始化

typedef struct CvFileStorage
{
... // hidden fields
} CvFileStorage;
构造函数 CvFileStorage 是将磁盘上存储的文件关联起来的“黑匣子” 。在下列函数
描述中利用 CvFileStorage 输入并允许存储或打开由标量值组成的层次集合,根
据 CXCore 对象(例如矩阵,序列，图表 ) 和用户自定义对象。
CXCore 能将数据读入或写入 XML (http://www.w3c.org/XML) or YAML
(http://www.yaml.org) 格式. 下面这个例子是利用 CXCore 函数将 3×3 单位浮点矩阵
存入 XML 和 YAML 文档。
XML:

3
3

1. 0. 0. 0. 1. 0. 0. 0. 1.

YAML:
%YAML:1.0
A: !!opencv-matrix
rows: 3
cols: 3
dt: f
data: [ 1., 0., 0., 0., 1., 0., 0., 0., 1.]
从例子中可以看到, XML 试用嵌套标签来表现层次，而 YAML 用缩排来表现（类似于
Python 语言）。
相同的 CXCore 函数也能够在这两种格式下读写数据，特殊的格式决定了文件的扩展
名， .xml 是 XML 的扩展名， .yml 或 .yaml 是 YAML 的扩展名。

CvFileNode
文件存储器节点

/* 文件节点类型 */
#define CV_NODE_NONE 0
#define CV_NODE_INT 1
#define CV_NODE_INTEGER CV_NODE_INT
#define CV_NODE_REAL 2
#define CV_NODE_FLOAT CV_NODE_REAL
#define CV_NODE_STR 3
#define CV_NODE_STRING CV_NODE_STR
#define CV_NODE_REF 4 /* not used */
#define CV_NODE_SEQ 5
#define CV_NODE_MAP 6
#define CV_NODE_TYPE_MASK 7

/* 可选标记 */
#define CV_NODE_USER 16
#define CV_NODE_EMPTY 32
#define CV_NODE_NAMED 64

#define CV_NODE_TYPE(tag) ((tag) & CV_NODE_TYPE_MASK)

#define CV_NODE_IS_INT(tag) (CV_NODE_TYPE(tag) == CV_NODE_INT)
#define CV_NODE_IS_REAL(tag) (CV_NODE_TYPE(tag) == CV_NODE_REAL)
#define CV_NODE_IS_STRING(tag) (CV_NODE_TYPE(tag) == CV_NODE_STRING)
#define CV_NODE_IS_SEQ(tag) (CV_NODE_TYPE(tag) == CV_NODE_SEQ)
#define CV_NODE_IS_MAP(tag) (CV_NODE_TYPE(tag) == CV_NODE_MAP)
#define CV_NODE_IS_COLLECTION(tag) (CV_NODE_TYPE(tag) >= CV_NODE_SEQ)
#define CV_NODE_IS_FLOW(tag) (((tag) & CV_NODE_FLOW) != 0)
#define CV_NODE_IS_EMPTY(tag) (((tag) & CV_NODE_EMPTY) != 0)
#define CV_NODE_IS_USER(tag) (((tag) & CV_NODE_USER) != 0)
#define CV_NODE_HAS_NAME(tag) (((tag) & CV_NODE_NAMED) != 0)

#define CV_NODE_SEQ_SIMPLE 256
#define CV_NODE_SEQ_IS_SIMPLE(seq) (((seq)->flags & CV_NODE_SEQ_SIMPLE) != 0)

typedef struct CvString
{
int len;
char* ptr;
}
CvString;

/*关键字 readed 的原理是文件存储器对存储的无用信息进行加速查找操作 */
typedef struct CvStringHashNode
{
unsigned hashval;
CvString str;
struct CvStringHashNode* next;
}
CvStringHashNode;

/* 文件存储器的基本元素是-标量或集合*/
typedef struct CvFileNode
{
int tag;
struct CvTypeInfo* info; /* 类型信息（只能用于用户自定义对象，对于其它对
象它为 0） */
union
{
double f; /* 浮点数*/
int i; /* 整形数 */
CvString str; /* 字符文本 */
CvSeq* seq; /* 序列 (文件节点的有序集合) */
struct CvMap* map; /*图表 (指定的文件节点的集合 ) */
} data;
}
CvFileNode;
这个构造函数只是用于重新找到文件存储器上的数据(例如，从文件中下载数据）。当
数据已经写入文件时利用最小的缓冲继续完成，此时没有数据存放在文件存储器。
相反，当从文件中读数据时，所有文件在内存中像树一样被解析和描绘。树的每一个节
点被 CvFileNode 表现出来。文件节点 N 的类型能够通过 CV_NODE_TYPE(N->tag) 被重新
找到。一些节点（叶结点）作为变量：字符串文本，整数，浮点数。其它的文件节点是
集合文件节点,有两个类型集合：序列和图表 (我们这里使用 YAML 符号,无论用哪种
方法，对于 XML 是同样有效）。序列(不要与 CvSeq 混淆）是由有序的非指定文件节点
构成的，图表是由无序的指定文件节点构成的。因而 ,序列的原理是通过索引
（cvGetSepElem)来存取，图形的原理是通过姓名（cvGetFileNodeByName)来存取下表
描述不同类型的节点：
Type CV_NODE_TYPE(node->tag) Value
Integer CV_NODE_INT node->data.i
Floating-point CV_NODE_REAL node->data.f
Text string CV_NODE_STR node->data.str.ptr
Sequence CV_NODE_SEQ node->data.seq
Map CV_NODE_MAP node->data.map*
*
这里不需要存取图表内容（顺便说一下 CvMapThere 是一个隐藏的构造函数）。图形原理可
以被 cvGetFileNodeByName 函数重新得到通过指针指向图表文件节点。
一个用户对象是一个标准的类型实例，例如 CvMat, CvSeq 等,或者任何一个已注册的类
型使用 cvRegisterTypeInfo。这样的对象，例如图表（像表现 XML 和 YAM 示例文件一
样）是最初在文件中表现出来的。在文件存储器打开并分析之后。当用户调用 cvRead
或 cvReadByName 函数时那么对象将请求被解析 (内存中原来的表述）。

CvAttrList
显示属性

typedef struct CvAttrList
{
const char** attr; /* NULL-将中止一对数组 (attribute_name,attribute_value)
*/
struct CvAttrList* next; /* 指针指向下一个属性块 */
}
CvAttrList;

/* initializes 初始化构造函数 CvAttrList */
inline CvAttrList cvAttrList( const char** attr=NULL, CvAttrList* next=NULL );

/* 返回值为属性值，找不到适合的属性则返回值为 0(NULL)*/
const char* cvAttrValue( const CvAttrList* attr, const char* attr_name );
在执行当前的属性时通常需通过特定的参数来完成，除了对象类型说明(type_id 属性)
以外，标示符不支持 XML 属性。

OpenFileStorage
打开文件存储器读
/
写数据。

CvFileStorage* cvOpenFileStorage( const char* filename, CvMemStorage*
memstorage, int flags );
filename
内存中的相关文件的文件名。

内存中通常存储临时数据和动态结构，例如 CvSeq 和 CvGraph。如果 memstorage 为空,
将建立和使用一个暂存器。
flags
读/写选择器。
CV_STORAGE_READ - 内存处于读状态。
CV_STORAGE_WRITE - 内存处于写状态。
函数 cvOpenFileStorage 打开文件存储器读写数据，之后建立文件或继续使用现有的文
件。文件扩展名决定读文件的类型： .xml 是
XML
的扩展名, .yml 或 .yaml 是
YAML
的扩展名。该函数的返回指针指向 CvFileStorage 构造函数。

ReleaseFileStorage
释放文件存储单元

void cvReleaseFileStorage( CvFileStorage** fs );
fs
双指针指向被关闭的文件存储器。
函数 cvReleaseFileStorage 关闭一个相关的文件存储器并释放所有的临时内存。只有
在内存的 I/O 操作完成后才能关闭文件存储器。

写数据

StartWriteStruct
向文件存储器中写数据

void cvStartWriteStruct( CvFileStorage* fs, const char* name,
int struct_flags, const char* type_name=NULL,
CvAttrList attributes=cvAttrList());
fs
初始化文件存储器。
name
被写入的数据结构的名称。在内存被读取时可以通过名称访问数据结构。
struct_flags
有下列两个值：
CV_NODE_SEQ - 被写入的数据结构为序列结构。这样的数据没有名称。
CV_NODE_MAP - 被写入的数据结构为图表结构。这样的数据含有名称。
有且只有这两个表识符被指定

CV_NODE_FLOW - 这个可选择标识符只能作用于 YAML 流。被写入的数据结构被看做一个
数据流（不是数据块），它更加紧凑是所有标量的基础。
type_name
可选参数 - 对象类型名称。如果是 XML 用打开标识符 type_id 属性写入。如果是 YAML
用冒号后面的数据结构名写入，基本上它是伴随用户对象出现的。当存储器读时，编
码类型名通常决定对象类型（见 Cvtypeinfo 和 cvfindtypeinfo）。
attributes
这个参数通常不会被当前执行。
函数 cvStartWriteStruct 开始写复合的数据结构（数据集合）包括序列或图表, 标量
和结构被写入， cvEndWriteStruct 被指定. 该函数能够合并一些对象或写入一些用
户对象函数。

EndWriteStruct
中止写数据结构

void cvEndWriteStruct( CvFileStorage* fs );
fs
初始化文件存储器。
函数 cvEndWriteStruct 中止普通的写数据操作。

WriteInt
写入一个整形值

void cvWriteInt( CvFileStorage* fs, const char* name, int value );
fs
初始化文件存储器。
name
写入值的名称。如果母结构是一个序列，name 的值为 NULL。
value
写入的整形值。
函数 cvWriteInt 将一个单独的整形值（有名称的或无名称的）写入文件存储器。

WriteReal
写入一个浮点形值

void cvWriteReal( CvFileStorage* fs, const char* name, double value );
fs
初始化文件存储器。
name
写入值的名称。如果母结构是一个序列，name 的值为 NULL。
value
写入的浮点形值。
函数 cvWriteReal 将一个单独的整形值（有名称的或无名称的）写入文件存储器。特
殊的值被编码：The special values are encoded: NaN (一个编码量的非) 例如 .NaN,
±无穷大例如 +.Inf (-.Inf)。
下面的实例表明怎样使用低级写函数存储自定义数据结构。
void write_termcriteria( CvFileStorage* fs, const char* struct_name,
CvTermCriteria* termcrit )
{
cvStartWriteStruct( fs, struct_name, CV_NODE_MAP, NULL, cvAttrList(0,0));
cvWriteComment( fs, "termination criteria", 1 ); // 正确的描述
if( termcrit->type & CV_TERMCRIT_ITER )
cvWriteInteger( fs, "max_iterations", termcrit->max_iter );
if( termcrit->type & CV_TERMCRIT_EPS )
cvWriteReal( fs, "accuracy", termcrit->epsilon );
cvEndWriteStruct( fs );
}

WriteString
写入字符串文本

void cvWriteString( CvFileStorage* fs, const char* name,
const char* str, int quote=0 );
fs
初始化文件存储器。
name
写入字符串的名称。如果母结构是一个序列，name 的值为 NULL。
str
写入的字符串文本。
quote
如果不为 0，不管是否标准，字符串都将被写入。如果标识符为 0。只有在标准的情况下（字
符串的首位是数字或者空格）字符串被写入。
函数 cvWriteString 将字符串文本写入文件存储器。

WriteComment
写入注释

void cvWriteComment( CvFileStorage* fs, const char* comment, int
eol_comment );
fs
初始化文件存储器。
comment
写入的注释,单行的或者多行的。
eol_comment
如果不为 0，函数将注释加到当前行的后面。如果为 0，并且是多行注释或者结尾没有注释
行，那么注释将从新的一行开始。
函数 cvWriteComment 将注释写入文件存储器。读内存时注释将被跳过，它只能被用于
调试和描述。

StartNextStream
打开下一个数据流

void cvStartNextStream( CvFileStorage* fs );
fs
初始化文件存储器。
函数 cvStartNextStream 从文件存储器中打开下一个数据流。 YAML 和 XML 都支持
多数据流。这对连接多个文件和恢复写入的程序很有用。

Write
写入用户对象

void cvWrite( CvFileStorage* fs, const char* name,
const void* ptr, CvAttrList attributes=cvAttrList() );
fs
初始化文件存储器。
name
写入对象的名称。如果母结构是一个序列，name 的值为 NULL。
ptr
定义指针指向对象。
attributes
定义对象的属性。
函数 cvWrite 将对象写入文件存储器。首先，使用 cvTypeOf 查找恰当的类型信息。
其次写入指定的方法类型信息。
属性被用于定制输入程序。下面的属性支持标准类型 The standard types support the
following attributes (所有的*dt 属性在 cvWriteRawData 中都有相同的格式）：
CvSeq
• header_dt -序列首位用户区的描述，它紧跟在 CvSeq 或 CvChain（如果是自由序列）
或 CvContour（如果是轮廓或点序列）之后。
• dt - 序列原理的描述。
• recursive - 如果属性没有被引用并且不等于“0”或“false"，则所有的序列树（轮廓）
都被存储。
CvGraph
• header_dt - 图表头用户区的描述，它紧跟在 CvGraph 之后。
• vertex_dt - 图表顶点用户区的描述。
• edge_dt - 图表边用户区的描述（注意磅值经常被写入，所以不需要详细的说明）。
下面的代码的含义是建立 YAML 文件用来描述 CvFileStorage ：
#include "cxcore.h"

int main( int argc, char** argv )
{
CvMat* mat = cvCreateMat( 3, 3, CV_32F );
CvFileStorage* fs = cvOpenFileStorage( "example.yml", 0,
CV_STORAGE_WRITE );

cvSetIdentity( mat );
cvWrite( fs, "A", mat, cvAttrList(0,0) );

cvReleaseFileStorage( &fs );
cvReleaseMat( &mat );
return 0;
}

WriteRawData
写入重数

void cvWriteRawData( CvFileStorage* fs, const void* src,
int len, const char* dt );
fs
初始化文件存储器。
src
指针指向输入数组。
len
写入数组的长度。
dt
下面是每一个数组元素说明的格式： ([count]{'u'|'c'|'w'|'s'|'i'|'f'|'d'})...,
这些特性与 C 语言的类型相似：
• 'u' - 8 位无符号数。
• 'c' - 8 位符号数。
• 'w' - 16 位无符号数。
• 's' - 16 位符号数。
• 'i' - 32 位符号数。
• 'f' - 单精度浮点数。
• 'd' - 双精度浮点数。
• 'r' - 指针。输入的带符号的低 32 位整数。这个类型常被用来存储数据结构。用来连
接两个基本项。
count 是用来选择计数值的确定类型。例如, dt='2if' 是指任意的一个数组元素的结构
是：2 个字节整形数，后面跟一个单精度浮点数。上面的说明与‘iif', '2i1f' 等相同。
另外一个例子：dt='u'是指一个由类型组成的数组， dt='2d'是指由两个双精度浮点数
构成的数组。
函数 cvWriteRawData 将重数写入文件存储器。那些元素由单独的重数构成。一些函数
命令能够被循环调用替换包括 cvWriteInt 和 cvWriteReal 命令，但是一个单独的命令
更加有效。注意，那是因为元素没有名字，把它们写入序列比写入图表要好。

WriteFileNode
将文件节点写入另一个文件存储器

void cvWriteFileNode( CvFileStorage* fs, const char* new_node_name,
const CvFileNode* node, int embed );
fs
设置目的文件存储器
new_file_node
在目的文件存储器中设置新的文件节点名。保持现有的文件节点名，使用
cvGetFileNodeName(节点).
node

被写入的节点。
embed
如果被写入的节点已经存在并且它的值不为 0，不建立额外的等级。所有的节点元素被写
入常用的输入结构。图表元素只被写入图表，序列元素只被写入序列
函数 cvWriteFileNode 将一个文件节点的拷贝写入文件存储器可能请求的函数是：
将几个文件存储器合而为一。在 XML 和 YAML 之间变换格式等。

读取数据
从文件存储器中得到数据有两种方法：第一，查找文件节点包括那些被请求的数据；
其次，利用手动或者使用自定义 read 方法取得数据。

GetRootFileNode
从文件存储器中得到一个高层节点

CvFileNode* cvGetRootFileNode( const CvFileStorage* fs, int stream_index=0 );
fs
初始化文件存储器。
stream_index
流的零基索引。参考 cvStartNextStream. 在通常情况下，文件中只有一个流，但是可以拥
有多个。
函数 cvGetRootFileNode 返回一个高层文件节点。高层节点没有名称，它们和流相对
应，接连存入文件存储器。如果超出索引，函数返回 NULL 指针，所以高层节点反复
调用函数 stream_index=0,1,...,直到返回 NULL 指针。这个函数可以在文件存储器中反
复调用。

GetFileNodeByName
在图表或者文件存储器中查找节点

CvFileNode* cvGetFileNodeByName( const CvFileStorage* fs,
const CvFileNode* map,
const char* name );
fs
初始化文件存储器。
map
设置母图表。如果为 NULL，函数在所有的高层节点（流）中检索，从第一个开始。
name
设置文件节点名。
函数 cvGetFileNodeByName 文件节点通过 name 查找文件节点该节点在图表中被查
找或者，如果指针为 NULL，在内存中的高层文件节点中查找。在图表中或者
cvGetSeqElem 序列中使用这个函数。可能反复调用文件存储器 i 加速确定某个多重表
示值（例如结构数组）可能在 cvGetHashedKey 和 cvGetFileNode 之中用到一个。

GetHashedKey
返回一个指向已有名称的唯一指针

CvStringHashNode* cvGetHashedKey( CvFileStorage* fs, const char* name,
int len=-1, int create_missing=0 );
fs
初始化文件存储器。
name
设置文字节点名。
len
名称（名称已知）的长度，如果值为-1 长度需要被计算出来。
create_missing
标识符说明，是否应该将一个缺省节点的值加入哈希表。
函数 cvGetHashedKey 返回指向每一个特殊文件节点名的特殊指针。这个指针通过
cvGetFileNode 函数。它比 cvGetFileNodeByName 快。
观察下面例子：用二维图来表示一个点集，例：
%YAML:1.0
points:
- { x: 10, y: 10 }
- { x: 20, y: 20 }
- { x: 30, y: 30 }
# ...
因而,它使用哈希指针“x”和“y"加速对点的编译。
Example. Reading an array of structures from file storage
例：从一个文件存储器中读取顺序的结构
#include "cxcore.h"

int main( int argc, char** argv )
{
CvFileStorage* fs = cvOpenFileStorage( "points.yml", 0, CV_STORAGE_READ );
CvStringHashNode* x_key = cvGetHashedNode( fs, "x", -1, 1 );
CvStringHashNode* y_key = cvGetHashedNode( fs, "y", -1, 1 );
CvFileNode* points = cvGetFileNodeByName( fs, 0, "points" );

if( CV_NODE_IS_SEQ(points->tag) )
{
CvSeq* seq = points->data.seq;
int i, total = seq->total;
CvSeqReader reader;
cvStartReadSeq( seq, &reader, 0 );
for( i = 0; i < total; i++ )
{
CvFileNode* pt = (CvFileNode*)reader.ptr;
#if 1 /* 快变量 */
CvFileNode* xnode = cvGetFileNode( fs, pt, x_key, 0 );
CvFileNode* ynode = cvGetFileNode( fs, pt, y_key, 0 );
assert( xnode && CV_NODE_IS_INT(xnode->tag) &&
ynode && CV_NODE_IS_INT(ynode->tag));
int x = xnode->data.i; // or x = cvReadInt( xnode, 0 );
int y = ynode->data.i; // or y = cvReadInt( ynode, 0 );
#elif 1 /* 慢变量：不使用 x 值与 y 值 */
CvFileNode* xnode = cvGetFileNodeByName( fs, pt, "x" );
CvFileNode* ynode = cvGetFileNodeByName( fs, pt, "y" );
assert( xnode && CV_NODE_IS_INT(xnode->tag) &&
ynode && CV_NODE_IS_INT(ynode->tag));
int x = xnode->data.i; // or x = cvReadInt( xnode, 0 );
int y = ynode->data.i; // or y = cvReadInt( ynode, 0 );
#else /* 最慢的可以轻松使用的变量 */
int x = cvReadIntByName( fs, pt, "x", 0 /* default value */ );
int y = cvReadIntByName( fs, pt, "y", 0 /* default value */ );
#endif
CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
printf("%d: (%d, %d)\n", i, x, y );
}
}
cvReleaseFileStorage( &fs );
return 0;
}
请注意,无论使用那一种方法访问图表，都比使用序列慢，例如上面的例子，在单一
数字序列中点像数字一样被编译。

GetFileNode
在图表或者文件存储器中查找节点

CvFileNode* cvGetFileNode( CvFileStorage* fs, CvFileNode* map,
const CvStringHashNode* key, int
create_missing=0 );
fs
初始化文件存储器。
map
设置母图表。如果为 NULL，函数在所有的高层节点（流）中检索，如果图表与值都为 NULLs,
函数返回到根节点-图表包含高层节点
key
指向节点名的特殊节点 , 从 cvGetHashedKey 中得到。
create_missing
标识符说明，是否应该将一个缺省节点加入图表。
函数 cvGetFileNode 查找一个文件节点。函数能够插入一个新的节点，当它不在图表
中时

GetFileNodeName
返回文件节点名

const char* cvGetFileNodeName( const CvFileNode* node );
node
初始化文件节点。
函数 cvGetFileNodeName 返回文件节点名或返回 NULL(如果文件节点没有名称或者
node 为 NULL 。

ReadInt
从文件节点中得到整形值

int cvReadInt( const CvFileNode* node, int default_value=0 );
node
初始化文件节点
default_value
如果 node 为 NULL，返回一个值。
函数 cvReadInt 从文件节点中返回整数。如果文件节点为 NULL， default_value 被返
回。另外如果文件节点有类型 CV_NODE_INT, 则 node->data.i 被返回。如果文件
节点有类型 CV_NODE_REAL, 则 node->data.f 被修改成整数后返回。另外一种情况
是，结果不确定。

ReadIntByName
查找文件节点返回它的值

int cvReadIntByName( const CvFileStorage* fs, const CvFileNode* map,
const char* name, int default_value=0 );
fs
初始化文件存储器。
map
设置母图表。如果为 NULL，函数在所有的高层节点（流）中检索。
name
设置节点名。
default_value
如果文件节点为 NULL，返回一个值。
函数 cvReadIntByName 是 cvGetFileNodeByName 和 cvReadInt 的简单重叠.

ReadReal
从文件节点中得到浮点形值

double cvReadReal( const CvFileNode* node, double default_value=0. );
node
初始化文件节点。
default_value
如果 node 为 NULL，返回一个值。
函数 cvReadReal 从文件节点中返回浮点形值。如果文件节点为 NULL， default_value
被返回。另外如果文件节点有类型 CV_NODE_REAL , 则 node->data.f 被返回。如果
文件节点有类型 CV_NODE_INT , 则 node->data.i 被修改成浮点数后返回。另外
一种情况是，结果不确定。 .

ReadRealByName
查找文件节点返回它的浮点形值

double cvReadRealByName( const CvFileStorage* fs, const CvFileNode* map,
const char* name, double default_value=0. );
fs
初始化文件存储器。
map
设置母图表。如果为 NULL，函数在所有的高层节点（流）中检索。
name
设置节点名。
default_value
如果 node 为 NULL，返回一个值。
函数 cvReadRealByName 是 cvGetFileNodeByName 和 cvReadReal 的简单重叠。

ReadString
从文件节点中得到字符串文本

const char* cvReadString( const CvFileNode* node, const char*
default_value=NULL );
node
初始化文件节点。
default_value
如果 node 为 NULL，返回一个值。
函数 cvReadString 从文件节点中返回字符串文本。如果文件节点为 NULL，
default_value 被返回。另外如果文件节点有类型 CV_NODE_STR, 则
data.str.ptr 被返回。另外一种情况是，结果不确定。

ReadStringByName
查找文件节点返回它的字符串文本

const char* cvReadStringByName( const CvFileStorage* fs, const CvFileNode* map,
const char* name, const char*
default_value=NULL );
fs
初始化文件存储器。
map
设置母图表。如果为 NULL，函数在所有的高层节点（流）中检索。
name
设置节点名。
default_value
如果文件节点为 NULL，返回一个值。
函数 cvReadStringByName 是 cvGetFileNodeByName 和 cvReadString 的简单重叠。

Read
解释对象并返回指向它的指针

void* cvRead( CvFileStorage* fs, CvFileNode* node,
CvAttrList* attributes=NULL );
fs
初始化文件存储器。
node
设置对象根节点。
attributes
不被使用的参数.
函数 cvRead 解释用户对象 (在文件存储器子树中建立新的对象）并返回。对象被解
释，必须按原有的支持读方法的类型 (参考 CvTypeInfo).用类型名决定对象，并在文
件中被解释。如果对象是动态结构，它将在内存中通过 cvOpenFileStorage 或者使
NULL 指针被建立。在临时性内存中。当 cvReleaseFileStorage 被调用时释放内存。如
果对象不是动态结构 ,将在堆中被建立用专用函数或通用函数 cvRelease. 释放内存。

ReadByName
查找对象并解释

void* cvReadByName( CvFileStorage* fs, const CvFileNode* map,
const char* name, CvAttrList* attributes=NULL );
fs
初始化文件存储器。
map
设置双亲节点。如果它为 NULL，函数从高层节点中查找。
name
设置节点名称。
attributes
不被使用的参数.
函数 cvReadByName 是由 cvGetFileNodeByName 和 cvRead 叠合的。 .

ReadRawData
读重数

void cvReadRawData( const CvFileStorage* fs, const CvFileNode* src,
void* dst, const char* dt );
fs
初始化文件存储器。
src
设置文件节点（有序的）来读数。
dst
设置指向目的数组的指针。
dt
数组元素的说明。格式参考 cvWriteRawData。
函数 cvReadRawData 从有序的文件节点中读取元素。

StartReadRawData
初始化文件节点读取器

void cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src,
CvSeqReader* reader );
fs
初始化文件存储器。
src 设置文件节点(有序的）来读数。
•
reader 设置顺序读取指针。
函数 cvStartReadRawData 初始化顺序读取器从文件节点中读取数据。能够通过
cvReadRawDataSlice.初始化文件读取器。

ReadRawDataSlice
初始化文件节点按序读取器

void cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader,
int count, void* dst, const char* dt );
fs
初始化文件存储器。
reader
设置按序读取器 . 用 cvStartReadRawData.初始化。
count
被读取元素的数量。
dst
指向目的数组的指针。
dt
数组元素的说明。格式参考 cvWriteRawData。
函数 cvReadRawDataSlice 从文件节点读一个或多个元素，组成一个序列用于指
定数组。读入元素的总数由其他数组的元素总和构成的。例如如果 dt='2if',
函数将读是总数三倍的序列元素。

运行时类型信息和通用函数

CvTypeInfo
类型信息

typedef int (CV_CDECL *CvIsInstanceFunc)( const void* struct_ptr );
typedef void (CV_CDECL *CvReleaseFunc)( void** struct_dblptr );
typedef void* (CV_CDECL *CvReadFunc)( CvFileStorage* storage,
CvFileNode* node );
typedef void (CV_CDECL *CvWriteFunc)( CvFileStorage* storage,
const char* name,
const void* struct_ptr,
CvAttrList attributes );
typedef void* (CV_CDECL *CvCloneFunc)( const void* struct_ptr );

typedef struct CvTypeInfo
{
int flags; /* 不常用 */
int header_size; /* (CvTypeInfo)的大小 */
struct CvTypeInfo* prev; /* 在列表中已定义过的类型 */
struct CvTypeInfo* next; /* 在列表中下一个已定义过的类型 */
const char* type_name; /*定义类型名，并写入文件存储器 */

/* methods */
CvIsInstanceFunc is_instance; /* 选择被传递的对象属于的类型 */
CvReleaseFunc release; /* 释放对象的内存空间 */
CvReadFunc read; /* 从文件存储器中读对象 */
CvWriteFunc write; /* 将对象写入文件存储器 */
CvCloneFunc clone; /* 复制一个对象 */
}
CvTypeInfo;
结构 CvTypeInfo 包含的信息包括标准的或用户自定义的类型。类型有没有包含
指向相应的 CvTypeInfo 结构的指针。在已有的对象中查找类型的方法是使用
cvTypeOf 函数。已有的信息可以通过类型名使用 cvFindType 来查找，这个方法
在从文件存储器中读对象的时候被使用。用户可以通过 cvRegisterType 定义一
个新的类型，并将类型信息结构加到文件列表的开始端，它可以从标准类型
中建立专门的类型，不必考虑基本的方法。

RegisterType
定义新类型

void cvRegisterType( const CvTypeInfo* info );
info
类型信息结构。
函数 cvRegisterType 定义一个新类型,可以通过信息来描述它。

UnregisterType
删除定义的类型

void cvUnregisterType( const char* type_name );
type_name
被删除的类型的名称。
函数 cvUnregisterType 通过指定的名称删除已定义的类型。如果不知道类型名,
可以用 cvTypeOf 或者连续扫描类型列表，从 cvFirstType 开始,然后调
用 cvUnregisterType(info->type_name)。

FirstType
返回类型列表的首位。

CvTypeInfo* cvFirstType( void );
函数 cvFirstType 返回类型列表中的第一个类型。

FindType
通过类型名查找类型

CvTypeInfo* cvFindType( const char* type_name );
type_name
类型名
函数 cvFindType 通过类型名查找指定的类型。如果找不到返回值为 NULL。

TypeOf
返回对象的类型

CvTypeInfo* cvTypeOf( const void* struct_ptr );
struct_ptr
定义对象指针。
函数 cvTypeOf 查找指定对象的类型。它反复扫描类型列表，调用每一个类型信
息结构中的函数和方法与对象做比较，直到它们中的一个的返回值不为 0 或者所
有的类型都被访问。

Release
删除对象

void cvRelease( void** struct_ptr );
struct_ptr
定义指向对象的双指针。
函数 cvRelease 查找指定对象的类型，然后调用 release。

Clone
克隆一个对象

void* cvClone( const void* struct_ptr );
struct_ptr
定义被克隆的对象
函数 cvClone 查找指定对象的类型，然后调用 clone。

Save
存储对象到文件中

void cvSave( const char* filename, const void* struct_ptr,
const char* name=NULL,
const char* comment=NULL,
CvAttrList attributes=cvAttrList());
filename
初始化文件名。
struct_ptr
指定要存储的对象。
name
可选择的对象名。如果为 NULL, 对象名将从 filename 中列出。
comment
可选注释。加在文件的开始处。
•
attributes 可选属性。通过 cvWrite。
函数 cvSave 存储对象到文件。它给 cvWrite 提供一个简单的界面。

Load
从文件中打开对象。

void* cvLoad( const char* filename, CvMemStorage* memstorage=NULL,
const char* name=NULL, const char** real_name=NULL );
filename
初始化文件名
memstorage
动态结构的内存，例如 CvSeq 或 CvGraph。不能作用于矩阵或图像。
name
可选对象名。如果为 NULL,内存中的第一个高层对象被打开。
real_name
可选输出参数。它包括已打开的对象的名称 (如果 name=NULL 时有效）。
函数 cvLoad 从文件中打开对象。它给 cvRead 提供一个简单的界面.对象被打开
之后，文件存储器被关闭，所有的临时缓冲区被删除。因而，打开一个动态结构，
如序列，轮廓或图像。它应该通过一个有效的目的文件内存发挥作用。
其它混合函数

CheckArr
检查输入数组的每一个元素是否是非法值

int cvCheckArr( const CvArr* arr, int flags=0,
double min_val=0, double max_val=0);
#define cvCheckArray cvCheckArr
arr
待检查数组
flags
操作标志, 0 或者下面值的组合:
CV_CHECK_RANGE - 如果设置这个标志 , 函数检查数组的每一个值是否在范围
[minVal,maxVal) 以内,如果不在范围内它不检查每一个元素是否是 NaN 或者 ±Infinity。
CV_CHECK_QUIET - 如果设置这个标志, 如果一个元素是非法的或者越界的，函数不会产
生一个错误。
min_val
有效值范围的闭下边界。只有当 CV_CHECK_RANGE 被设置的时候它才有作用。
max_val
有效值范围的开上边界。只有当 CV_CHECK_RANGE 被设置的时候它才有作用。
函数 cvCheckArr 检查每一个数组元素不是 NaN 也不是 ±Infinity 。如果
CV_CHECK_RANGE 被设定, 它也检查每一个元素是大于等于 minVal 并且小于
maxVal。如果检查成功函数返回非零值，例如，所有元素都是合法的并且在范围
内，如果检查失败则返回 0 。在后一种情况下如果 CV_CHECK_QUIET 标志没有
被设定，函数报出运行错误。

KMeans2
按照给定的群的数目拆分向量的集合（
Splits set of vectors by given number of clusters
）

void cvKMeans2( const CvArr* samples, int cluster_count,
CvArr* labels, CvTermCriteria termcrit );
samples
输入样例的浮点矩阵，每个样例一行。
cluster_count
拆分集合的群的数目
labels
输出整数向量，为每个样例存储群索引
termcrit
指定最大迭代次数和/或精度(distance the centers move by between the subsequent iterations).
函数 cvKMeans2 执行 k-means 算法查找 cluster_count 群的中心并沿着群
分组输入样例，输出 labels(i) 包含样例的群索引，存储在样例矩阵的第 i 行。
例子. 带 k-means 的高斯分布的随机群样例（Clustering random samples of
multi-gaussian distribution with k-means）
#include "cxcore.h"
#include "highgui.h"

void main( int argc, char** argv )
{
#define MAX_CLUSTERS 5
CvScalar color_tab[MAX_CLUSTERS];
IplImage* img = cvCreateImage( cvSize( 500, 500 ), 8, 3 );
CvRNG rng = cvRNG(0xffffffff);

color_tab[0] = CV_RGB(255,0,0);
color_tab[1] = CV_RGB(0,255,0);
color_tab[2] = CV_RGB(100,100,255);
color_tab[3] = CV_RGB(255,0,255);
color_tab[4] = CV_RGB(255,255,0);

cvNamedWindow( "clusters", 1 );

for(;;)
{
int k, cluster_count = cvRandInt(&rng)%MAX_CLUSTERS + 1;
int i, sample_count = cvRandInt(&rng)%1000 + 1;
CvMat* points = cvCreateMat( sample_count, 1, CV_32FC2 );
CvMat* clusters = cvCreateMat( sample_count, 1, CV_32SC1 );

/* generate random sample from multigaussian distribution */
for( k = 0; k < cluster_count; k++ )
{
CvPoint center;
CvMat point_chunk;
center.x = cvRandInt(&rng)%img->width;
center.y = cvRandInt(&rng)%img->height;
cvGetRows( points, &point_chunk,
k*sample_count/cluster_count,
k == cluster_count - 1 ? sample_count :
(k+1)*sample_count/cluster_count );
cvRandArr( &rng, &point_chunk, CV_RAND_NORMAL,
cvScalar(center.x,center.y,0,0),
cvScalar(img->width/6, img->height/6,0,0) );
}

/* shuffle samples */
for( i = 0; i < sample_count/2; i++ )
{
CvPoint2D32f* pt1 = (CvPoint2D32f*)points->data.fl +
cvRandInt(&rng)%sample_count;
CvPoint2D32f* pt2 = (CvPoint2D32f*)points->data.fl +
cvRandInt(&rng)%sample_count;
CvPoint2D32f temp;
CV_SWAP( *pt1, *pt2, temp );
}

cvKMeans2( points, cluster_count, clusters,
cvTermCriteria( CV_TERMCRIT_EPS+CV_TERMCRIT_ITER,
10, 1.0 ));

cvZero( img );

for( i = 0; i < sample_count; i++ )
{
CvPoint2D32f pt = ((CvPoint2D32f*)points->data.fl)[i];
int cluster_idx = clusters->data.i[i];
cvCircle( img, cvPointFrom32f(pt), 2,
color_tab[cluster_idx], CV_FILLED );
}

cvReleaseMat( &points );
cvReleaseMat( &clusters );

cvShowImage( "clusters", img );

int key = cvWaitKey(0);
if( key == 27 ) // 'ESC'
break;
}
}

SeqPartition
Splits sequence into equivalency classes
拆分序列为等效的类

typedef int (CV_CDECL* CvCmpFunc)(const void* a, const void* b, void*
userdata);
int cvSeqPartition( const CvSeq* seq, CvMemStorage* storage, CvSeq**
labels,
CvCmpFunc is_equal, void* userdata );
seq
划分序列
storage
存储序列的等效类的存储器，如果为空（NULL）, 函数用 seq->storage 存储输出标签
labels
labels
输出参数。双重指向基于 0 标签的输入序列元素的序列。
is_equal
如果两个特殊元素是来自同一个类这个关系函数返回非零值，否则返回 0 。划分算法用关
系函数的传递闭包得到等价类。
userdata
传递给 is_equal 函数的透明指针。
函数 cvSeqPartition 执行二次方程算法为拆分集合为一个或者更多的等效类。
函数返回等效等效类的数目。
Example. Partitioning 2d point set.
#include "cxcore.h"
#include "highgui.h"
#include

CvSeq* point_seq = 0;
IplImage* canvas = 0;
CvScalar* colors = 0;
int pos = 10;

int is_equal( const void* _a, const void* _b, void* userdata )
{
CvPoint a = *(const CvPoint*)_a;
CvPoint b = *(const CvPoint*)_b;
double threshold = *(double*)userdata;
return (double)(a.x - b.x)*(a.x - b.x) + (double)(a.y - b.y)*(a.y -
b.y) <= threshold;
}

void on_track( int pos )
{
CvSeq* labels = 0;
double threshold = pos*pos;
int i, class_count = cvSeqPartition( point_seq, 0, &labels, is_equal,
&threshold );
printf("%4d classes\n", class_count );
cvZero( canvas );

for( i = 0; i < labels->total; i++ )
{
CvPoint pt = *(CvPoint*)cvGetSeqElem( point_seq, i, 0 );
CvScalar color = colors[*(int*)cvGetSeqElem( labels, i, 0 )];
cvCircle( canvas, pt, 1, color, -1 );
}

cvShowImage( "points", canvas );
}

int main( int argc, char** argv )
{
CvMemStorage* storage = cvCreateMemStorage(0);
point_seq = cvCreateSeq( CV_32SC2, sizeof(CvSeq), sizeof(CvPoint),
storage );
CvRNG rng = cvRNG(0xffffffff);

int width = 500, height = 500;
int i, count = 1000;
canvas = cvCreateImage( cvSize(width,height), 8, 3 );

colors = (CvScalar*)cvAlloc( count*sizeof(colors[0]) );
for( i = 0; i < count; i++ )
{
CvPoint pt;
int icolor;
pt.x = cvRandInt( &rng ) % width;
pt.y = cvRandInt( &rng ) % height;
cvSeqPush( point_seq, &pt );
icolor = cvRandInt( &rng ) | 0x00404040;
colors[i] = CV_RGB(icolor & 255, (icolor >> 8)&255, (icolor >>
16)&255);
}

cvNamedWindow( "points", 1 );
cvCreateTrackbar( "threshold", "points", &pos, 50, on_track );
on_track(pos);
cvWaitKey(0);
return 0;
}

错误处理和系统函数

错误处理
在 OpenCV 中错误处理和 IPL (Image Processing Library)很相似。假如错误
处理函数不返回错误代码，而是用 CV_ERROR 宏调用 cvError 函数报错，按次序
地，用 cvSetErrStatus 函数设置错误状态，然后调用标准的或者用户自定义的
错误处理器(它可以显示一个消息对话框，写出错误日志等等, 参考函数
cvRedirectError, cvNulDevReport, cvStdErrReport, cvGuiBoxReport)。每个
程序的线程都有一个全局变量，它包含了错误状态(一个整数值)。这个状态可以
被 cvGetErrStatus 函数检索到。
有三个错误处理模式(参考 cvSetErrMode 和 cvGetErrMode):
Leaf
错误处理器被调用以后程序被终止。这是缺省值。它在调试中是很有用的，当错误发生的时
候立即产生错误信息。然而对于产生式系统后面两种方法可能会为他们提供更多的控制方
式。
Parent
错误处理器被调用以后程序不会被终止。栈被清空 (它用 C++ 异常处理机制完成写/输出
--w/o)。当调用 CxCore 的函数 cvGetErrStatus 起作用以后用户可以检查错误代码。
Silent
和 Parent 模式相似, 但是没有错误处理器被调用。
事实上,
Leaf
和
Parent
模式的语义被错误处理器执行，上面的描述对
cvNulDevReport, cvStdErrReport. cvGuiBoxReport 的行为有一些细微的差别，
一些自定义的错误处理器可能语义上会有很大的不同。

错误处理宏
报错，检查错误等的宏

/* special macros for enclosing processing statements within a function
and separating
them from prologue (resource initialization) and epilogue (guaranteed
resource release) */
#define __BEGIN__ {
#define __END__ goto exit; exit: ; }
/* proceeds to "resource release" stage */
#define EXIT goto exit

/* Declares locally 函数 name for CV_ERROR() use */
#define CV_FUNCNAME( Name ) \
static char cvFuncName[] = Name

/* Raises an error within the current context */
#define CV_ERROR( Code, Msg ) \
{ \
cvError( (Code), cvFuncName, Msg, __FILE__, __LINE__ ); \
EXIT; \
}

/* Checks status after calling CXCORE function */
#define CV_CHECK() \
{ \
if( cvGetErrStatus() < 0 ) \
CV_ERROR( CV_StsBackTrace, "Inner function failed." ); \
}

/* Provies shorthand for CXCORE function call and CV_CHECK() */
#define CV_CALL( Statement ) \
{ \
Statement; \
CV_CHECK(); \
}

/* Checks some condition in both debug and release configurations */
#define CV_ASSERT( Condition )
\
{
\
if( !(Condition) )
\
CV_ERROR( CV_StsInternal, "Assertion: " #Condition " failed" );
\
}

/* these macros are similar to their CV_... counterparts, but they
do not need exit label nor cvFuncName to be defined */
#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) ...
取代上面的讨论, 这里有典型的 CXCORE 函数和这些函数使用的样例。
错误处理宏的使用
#include "cxcore.h"
#include

void cvResizeDCT( CvMat* input_array, CvMat* output_array )
{
CvMat* temp_array = 0; // declare pointer that should be released
anyway.

CV_FUNCNAME( "cvResizeDCT" ); // declare cvFuncName

__BEGIN__; // start processing. There may be some declarations just
after this macro,
// but they couldn't be accessed from the epilogue.

if( !CV_IS_MAT(input_array) || !CV_IS_MAT(output_array) )
// use CV_ERROR() to raise an error
CV_ERROR( CV_StsBadArg, "input_array or output_array are not
valid matrices" );

// some restrictions that are going to be removed later, may be checked
with CV_ASSERT()
CV_ASSERT( input_array->rows == 1 && output_array->rows == 1 );

// use CV_CALL for safe function call
CV_CALL( temp_array = cvCreateMat( input_array->rows,
MAX(input_array->cols,output_array->cols),
input_array->type ));

if( output_array->cols > input_array->cols )
CV_CALL( cvZero( temp_array ));

temp_array->cols = input_array->cols;
CV_CALL( cvDCT( input_array, temp_array, CV_DXT_FORWARD ));
temp_array->cols = output_array->cols;
CV_CALL( cvDCT( temp_array, output_array, CV_DXT_INVERSE ));
CV_CALL( cvScale( output_array, output_array,
1./sqrt((double)input_array->cols*output_array->cols), 0 ));

__END__; // finish processing. Epilogue follows after the macro.

// release temp_array. If temp_array has not been allocated before
an error occured, cvReleaseMat
// takes care of it and does nothing in this case.
cvReleaseMat( &temp_array );
}

int main( int argc, char** argv )
{
CvMat* src = cvCreateMat( 1, 512, CV_32F );
#if 1 /* no errors */
CvMat* dst = cvCreateMat( 1, 256, CV_32F );
#else
CvMat* dst = 0; /* test error processing mechanism */
#endif
cvSet( src, cvRealScalar(1.), 0 );
#if 0 /* change 0 to 1 to suppress error handler invocation */
cvSetErrMode( CV_ErrModeSilent );
#endif
cvResizeDCT( src, dst ); // if some error occurs, the message box will
popup, or a message will be
// written to log, or some user-defined
processing will be done
if( cvGetErrStatus() < 0 )
printf("Some error occured" );
else
printf("Everything is OK" );
return 0;
}

GetErrStatus
返回当前错误状态

int cvGetErrStatus( void );
函数 cvGetErrStatus 返回当前错误状态 - 这个状态是被上一步调用的
cvSetErrStatus 设置的。注意, 在
Leaf
模式下错误一旦发生程序立即被终
止，因此对于总是需要调用函数后蔡获得控制的应用，可以调用 cvSetErrMode
函数将错误模式设置为
Parent
或
Silent
。

SetErrStatus
设置错误状态

void cvSetErrStatus( int status );
status
错误状态
函数 cvSetErrStatus 设置错误状态为指定的值。大多数情况下, 该函数被用
来重设错误状态(设置为 CV_StsOk) 以从错误中恢复。在其他情况下调用
cvError 或 CV_ERROR 更自然一些。

GetErrMode
返回当前错误模式

int cvGetErrMode( void );
函数 cvGetErrMode 返回当前错误模式 - 这个值是在之前被 cvSetErrMode 函
数设定的。

SetErrMode
设置当前错误模式

#define CV_ErrModeLeaf 0
#define CV_ErrModeParent 1
#define CV_ErrModeSilent 2
int cvSetErrMode( int mode );
mode
错误模式
函数 cvSetErrMode 设置指定的错误模式。关于不同的错误模式的讨论参考本节
开始.

Error
产生一个错误

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
产生错误的行号
函数 cvError 设置错误状态为指定的值(通过 cvSetErrStatus) ，如果错误模
式不是
Silent
, 调用错误处理器。

ErrorStr
返回错误状态编码的原文描述

const char* cvErrorStr( int status );
status
错误状态
函数 cvErrorStr 返回指定错误状态编码的原文描述。如果是步知道的状态该函
数返回空（NULL）指针。

RedirectError
设置一个新的错误处理器

typedef int (CV_CDECL *CvErrorCallback)( int status, const char*
func_name,
const char* err_msg, const char* file_name, int
line );

CvErrorCallback cvRedirectError( CvErrorCallback error_handler,
void* userdata=NULL, void**
prev_userdata=NULL );
error_handler
新的错误处理器
userdata
传给错误处理器的任意透明指针
prev_userdata
指向前面分配给用户数据的指针的指针
函数 cvRedirectError 在标准错误处理器或者有确定借口的自定义错误处理器
中选择一个新的错误处理器。错误处理器和 cvError 函数有相同的参数。如
果错误处理器返回非零的值, 程序终止, 否则, 程序继续运行。错误处理器通过
cvGetErrMode 检查当前错误模式而作出决定。

cvNulDevReport cvStdErrReport cvGuiBoxReport
提供标准错误操作

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
指向用户数据的指针，被标准错误操作忽略。
函数 cvNullDevReport, cvStdErrReport, cvGuiBoxReport 提供标准错误操作。
cvGuiBoxReport 是 Win32 系统缺省的错误处理器， cvStdErrReport - 其他系
统. cvGuiBoxReport 弹出错误描述的消息框并提供几个选择。下面是一个消息
框的例子，如果和例子中的错误描述相同，它和上面的例子代码可能是兼容的。
错误消息对话框

如果错误处理器是 cvStdErrReport, 上面的消息将被打印到标准错误输出，程序将要终止和
继续依赖于当前错误模式。
错误消息打印到标准错误输出 (在
Leaf
模式)
OpenCV ERROR: Bad argument (input_array or output_array are not valid
matrices)
in function cvResizeDCT,
D:\User\VP\Projects\avl_proba\a.cpp(75)
Terminating the application...

系统函数

Alloc
分配内存缓冲区

void* cvAlloc( size_t size );
size
以字节为单位的缓冲区大小
函数 cvAlloc 分配字节缓冲区大小并返回分配的缓冲区的指针。如果错误处理
函数产生了一个错误报告则返回一个空（NULL）指针。缺省地 cvAlloc 调用
icvAlloc 而 icvAlloc 调用 malloc ，然而用 cvSetMemoryManager 调用用户
自定义的内存分配和释放函数也是可能的。

Free
释放内存缓冲区

void cvFree( void** ptr );
buffer
指向被释放的缓冲区的双重指针
函数 cvFree 释放被 cvAlloc 分配的缓冲区。在退出的时候它清除缓冲区指针，
这就是为什么要使用双重指针的原因。如果 *buffer 已经是空（NULL）, 函
数什么也不做。

GetTickCount
Returns number of tics
int64 cvGetTickCount( void );
函数 cvGetTickCount 返回从依赖于平台的事件(从启动开始 CPU 的 ticks 数
目, 从 1970 年开始的微秒数目等等)开始的 tics 的数目。该函数对于精确测
量函数/用户代码的执行时间是很有用的。要转化 tics 的数目为时间单位，使
用函数 cvGetTickFrequency 。

GetTickFrequency
返回每个微秒的
tics
的数目

double cvGetTickFrequency( void );
函数 cvGetTickFrequency 返回每个微秒的 tics 的数目。因此，
cvGetTickCount() 和 cvGetTickFrequency() 将给出从依赖于平台的事件开始
的 tics 的数目。

RegisterModule
Registers another module
注册另外的模块

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;

int cvRegisterModule( const CvModuleInfo* module_info );
module_info
模块信息
函数 cvRegisterModule 添加模块到已注册模块列表中。模块被注册后，用
cvGetModuleInfo 函数可以检索到它的信息。注册模块可以通过 CXCORE 的支持
利用优化插件 (IPP, MKL, ...)。 CXCORE ， CV (computer vision), CVAUX
(auxilary computer vision) 和 HIGHGUI (visualization & image/video
acquisition) 自身就是模块的例子。通常注册后共享库就被载入。参考
cxcore/src/cxswitcher.cpp and cv/src/cvswitcher.cpp 获取细节信息, 怎样
注册的参考 cxcore/src/cxswitcher.cpp ， cxcore/src/_cxipp.h 显示了 IPP
和 MKL 是怎样连接到模块的。

GetModuleInfo
检索注册模块和插件的信息

void cvGetModuleInfo( const char* module_name,
const char** version,
const char** loaded_addon_plugins );
module_name
模块名, 或者 NULL ，则代表所有的模块
version
输出参数，模块的信息，包括版本信息
loaded_addon_plugins
优化插件的名字和版本列表，这里 CXCORE 可以被找到和载入
函数 cvGetModuleInfo 返回一个或者所有注册模块的信息。返回信息被存储到
库当中，因此，用户不用释放或者修改返回的文本字符。

UseOptimized
在优化
/
不优化两个模式之间切换

int cvUseOptimized( int on_off );
on_off
优化(<>0) 或者不优化 (0).
函数 cvUseOptimized 在两个模式之间切换,这里只有纯 C 才从 cxcore,
OpenCV 等执行。如果可用 IPP 和 MKL 函数也可使用。当 cvUseOptimized(0)
被调用, 所有的优化库都不被载入。该函数在调试模式下是很有用的， IPP&MKL
不工作, 在线跨速比较等。它返回载入的优化函数的数目。注意，缺省地优化插
件是被载入的，因此在程序开始调用 cvUseOptimized(1) 是没有必要的(事实上,
它只会增加启动时间)

SetMemoryManager
分配自定义
/
缺省内存管理函数

typedef void* (CV_CDECL *CvAllocFunc)(size_t size, void* userdata);
typedef int (CV_CDECL *CvFreeFunc)(void* pptr, void* userdata);

void cvSetMemoryManager( CvAllocFunc alloc_func=NULL,
CvFreeFunc free_func=NULL,
void* userdata=NULL );
alloc_func
分配函数; 除了 userdata 可能用来确定上下文关系外，接口和 malloc 相似
free_func
释放函数; 接口和 free 相似
userdata
透明的传给自定义函数的用户数据
函数 cvSetMemoryManager 设置将被 cvAlloc，cvFree 和高级函数 (例如.
cvCreateImage) 调用的用户自定义内存管理函数(代替 malloc 和 free)。注
意, 当用 cvAlloc 分配数据的时候该函数被调用。当然, 为了避免无限循环调
用，它不允许从自定义分配/释放函数调用 cvAlloc 和 cvFree 。
如果 alloc_func 和 free_func 指针是 NULL, 恢复缺省的内存管理函数。

SetIPLAllocators
切换图像
IPL
函数的分配
/
释放

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

void cvSetIPLAllocators( Cv_iplCreateImageHeader create_header,
Cv_iplAllocateImageData allocate_data,
Cv_iplDeallocate deallocate,
Cv_iplCreateROI create_roi,
Cv_iplCloneImage clone_image );

#define CV_TURN_ON_IPL_COMPATIBILITY()
\
cvSetIPLAllocators( iplCreateImageHeader, iplAllocateImage,
\
iplDeallocate, iplCreateROI, iplCloneImage )
create_header
指向 iplCreateImageHeader 的指针
allocate_data
指向 iplAllocateImage 的指针
deallocate
指向 iplDeallocate 的指针
create_roi
指向 iplCreateROI 的指针
clone_image
指向 iplCloneImage 的指针
函数 cvSetIPLAllocators 使用 CXCORE 来进行图像 IPL 函数的分配/释放
操作。为了方便, 这里提供了环绕宏 CV_TURN_ON_IPL_COMPATIBILITY。当 IPL
和 CXCORE/OpenCV 同时使用以及调用 iplCreateImageHeader 等情况该函数很
有用。如果 IPL 仅仅是被调用来进行数据处理，该函数就必要了，因为所有的
分配/释放都由 CXCORE 来完成, 或者所有的分配/释放都由 IPL 和一些
OpenCV 函数来处理数据。

依字母顺序函数列表

A
AbsDiff AddWeighted Avg
AbsDiffS Alloc AvgSdv
Add And
AddS AndS

C
CalcCovarMatrix CloneMat CreateImage
CartToPolar CloneMatND CreateImageHeader
Cbrt CloneSeq CreateMat
CheckArr CloneSparseMat CreateMatHeader
Circle Cmp CreateMatND
Clear*D CmpS CreateMatNDHeader
ClearGraph ConvertScale CreateMemStorage
ClearMemStorage ConvertScaleAbs CreateSeq
ClearSeq Copy CreateSet
ClearSet CountNonZero CreateSparseMat
Clone CreateChildMemStorage CrossProduct
CloneGraph CreateData CvtSeqToArray
CloneImage CreateGraph

D
DCT Det DrawContours
DFT Div
DecRefData DotProduct

E
EigenVV EndWriteStruct Exp
Ellipse Error
EndWriteSeq ErrorStr

F
FastArctan FindGraphEdgeByPtr FlushSeqWriter
FillConvexPoly FindType Free
FillPoly FirstType
FindGraphEdge Flip

G
GEMM GetImageROI GetTickFrequency
Get*D GetMat GraphAddEdge
GetCol GetModuleInfo GraphAddEdgeByPtr
GetDiag GetNextSparseNode GraphAddVtx
GetDims GetRawData GraphEdgeIdx
GetElemType GetReal*D GraphRemoveEdge
GetErrMode GetRootFileNode GraphRemoveEdgeByPtr
GetErrStatus GetRow GraphRemoveVtx
GetFileNode GetSeqElem GraphRemoveVtxByPtr
GetFileNodeByName GetSeqReaderPos GraphVtxDegree
GetFileNodeName GetSetElem GraphVtxDegreeByPtr
GetGraphVtx GetSize GraphVtxIdx
GetHashedKey GetSubRect GuiBoxReport
GetImage GetTextSize Get
GetImageCOI GetTickCount

I
InRange InitMatHeader InvSqrt
InRangeS InitMatNDHeader Invert
IncRefData InitSparseMatIterator IsInf
InitFont InitTreeNodeIterator IsNaN
InitImageHeader InsertNodeIntoTree

K
KMeans2

L
LUT Load
Line Log

M
Mahalonobis MemStorageAlloc MinS
MakeSeqHeaderForArray MemStorageAllocString Mul
Mat Merge MulSpectrums
Max Min MulTransposed
MaxS MinMaxLoc

N
NextGraphItem Norm NulDevReport
NextTreeNode Not

O
OpenFileStorage Or OrS

P
PerspectiveTransform Pow PutText
PolarToCart PrevTreeNode
PolyLine Ptr*D

R
RNG ReadString ReleaseMat
RandArr ReadStringByName ReleaseMatND
RandInt Rectangle ReleaseMemStorage
RandReal RedirectError ReleaseSparseMat
Read RegisterModule RemoveNodeFromTree
ReadByName RegisterType Repeat
ReadInt Release ResetImageROI
ReadIntByName ReleaseData Reshape
ReadRawData ReleaseFileStorage ReshapeMatND
ReadRawDataSlice ReleaseGraphScanner RestoreMemStoragePos
ReadReal ReleaseImage Round
ReadRealByName ReleaseImageHeader

S
SVBkSb SeqSlice SetZero
SVD SeqSort Solve
Save Set Split
SaveMemStoragePos Set*D Sqrt
ScaleAdd SetAdd StartAppendToSeq
SeqElemIdx SetData StartNextStream
SeqInsert SetErrMode StartReadRawData
SeqInsertSlice SetErrStatus StartReadSeq
SeqInvert SetIPLAllocators StartScanGraph
SeqPartition SetIdentity StartWriteSeq
SeqPop SetImageCOI StartWriteStruct
SeqPopFront SetImageROI StdErrReport
SeqPopMulti SetMemoryManager Sub
SeqPush SetNew SubRS
SeqPushFront SetReal*D SubS
SeqPushMulti SetRemove Sum
SeqRemove SetRemoveByPtr Set
SeqRemoveSlice SetSeqBlockSize
SeqSearch SetSeqReaderPos

T
Trace Transpose TypeOf
Transform TreeToNodeSeq

U
UnregisterType UseOptimized

W
Write WriteInt WriteString
WriteComment WriteRawData
WriteFileNode WriteReal

X
Xor XorS

例子列表

HighGUI 概述
TODO

简单图形界面

cvNamedWindow
创建窗口

int cvNamedWindow( const char* name, int flags );
name
窗口的名字，它被用来区分不同的窗口，并被显示为窗口标题。
flags
窗口属性标志。目前唯一支持的标志是 CV_WINDOW_AUTOSIZE。当这个标志被设置后，如
果用户不能手动改变窗口大小，窗口大小会自动调整以适合被显示图像（参考
cvShowImage）。
函数 cvNamedWindow 创建一个可以放置图像和 trackbar 的窗口。被创建的窗口可以通
过它们的名字被引用。
如果已经存在这个名字的窗口，这个函数将不做任何事情。

cvDestroyWindow
销毁一个窗口

void cvDestroyWindow( const char* name );
name
要被销毁的窗口的名字。
函数 cvDestroyWindow 销毁指定名字的窗口。

cvDestroyAllWindows
销毁所有
HighGUI
窗口

void cvDestroyAllWindows(void);
函数 cvDestroyAllWindows 销毁所有已经打开的 HighGUI 窗口。

cvResizeWindow
设定窗口大小

void cvResizeWindow( const char* name, int width, int height );
name
将被设置窗口的名字。
width
新的窗口宽度。
height
新的窗口高度。
函数 cvResizeWindow 改变窗口的大小。

cvMoveWindow
设定窗口的位置

void cvMoveWindow( const char* name, int x, int y );
name
将被设置的窗口的名字。
x
窗口左上角的 x 坐标。
y
窗口左上角的 y 坐标。
函数 cvMoveWindow 改变窗口的位置。

cvGetWindowHandle
通过名字获取窗口句柄

void* cvGetWindowHandle( const char* name );
name
窗口名字。
函数 cvGetWindowHandle 返回原始的窗口句柄（在 Win32 情况下返回 HWND，GTK+情况下
返回 GtkWidget）

cvGetWindowName
通过句柄获取窗口的名字

const char* cvGetWindowName( void* window_handle );
window_handle
窗口句柄。
给定函数 cvGetWindowName 一个窗口的句柄（在 Win32 情况下是 HWND，GTK+情况下是
GtkWidget），函数返回窗口的名字。

cvShowImage
在指定窗口中显示图像

void cvShowImage( const char* name, const CvArr* image );
name
窗口的名字。
image
被显示的图像。
函数 cvShowImage 在指定窗口中显示图像。如果窗口创建的时候被设定标志
CV_WINDOW_AUTOSIZE，那么图像将以原始尺寸显示；否则，图像将被伸缩以适合窗口大
小。

cvCreateTrackbar
创建
trackbar
并将它添加到指定的窗口。

CV_EXTERN_C_FUNCPTR( void (*CvTrackbarCallback)(int pos) );

int cvCreateTrackbar( const char* trackbar_name, const char* window_name,
int* value, int count, CvTrackbarCallback on_change );
trackbar_name
被创建的 trackbar 名字。
window_name
窗口名字，这个窗口将为被创建 trackbar 的父对象。
value
整数指针，它的值将反映滑块的位置。这个变量指定创建时的滑块位置。
count
滑块位置的最大值。最小值一直是 0。
on_change
每次滑块位置被改变的时候，被调用函数的指针。这个函数应该被声明为 void Foo(int);
如果没有回调函数，这个值可以设为 NULL。
函数 cvCreateTrackbar 用指定的名字和范围来创建 trackbar（滑块或者范围控制），
指定与 trackbar 位置同步的变量，并且指定当 trackbar 位置被改变的时候调用的回调
函数。被创建的 trackbar 显示在指定窗口的顶端。

cvGetTrackbarPos
获取
trackbar
的位置

int cvGetTrackbarPos( const char* trackbar_name, const char* window_name );
trackbar_name
trackbar 的名字。
window_name
trackbar 父窗口的名字。
函数 cvGetTrackbarPos 返回指定 trackbar 的当前位置。

cvSetTrackbarPos
设置
trackbar
位置

void cvSetTrackbarPos( const char* trackbar_name, const char* window_name, int
pos );
trackbar_name
trackbar 的名字。
window_name
trackbar 父窗口的名字。
pos
新的位置。
函数 cvSetTrackbarPos 设置指定 trackbar 的位置。

cvSetMouseCallback
设置鼠标事件的回调函数

#define CV_EVENT_MOUSEMOVE 0
#define CV_EVENT_LBUTTONDOWN 1
#define CV_EVENT_RBUTTONDOWN 2
#define CV_EVENT_MBUTTONDOWN 3
#define CV_EVENT_LBUTTONUP 4
#define CV_EVENT_RBUTTONUP 5
#define CV_EVENT_MBUTTONUP 6
#define CV_EVENT_LBUTTONDBLCLK 7
#define CV_EVENT_RBUTTONDBLCLK 8
#define CV_EVENT_MBUTTONDBLCLK 9

#define CV_EVENT_FLAG_LBUTTON 1
#define CV_EVENT_FLAG_RBUTTON 2
#define CV_EVENT_FLAG_MBUTTON 4
#define CV_EVENT_FLAG_CTRLKEY 8
#define CV_EVENT_FLAG_SHIFTKEY 16
#define CV_EVENT_FLAG_ALTKEY 32

CV_EXTERN_C_FUNCPTR( void (*CvMouseCallback )(int event, int x, int y, int flags,
void* param) );

void cvSetMouseCallback( const char* window_name, CvMouseCallback on_mouse,
void* param=NULL );
window_name
窗口的名字。
on_mouse
指定窗口里每次鼠标时间发生的时候，被调用的函数指针。这个函数的原型应该为
void Foo(int event, int x, int y, int flags, void* param);
其中 event 是 CV_EVENT_*变量之一， x 和 y 是鼠标指针在图像坐标系的坐标（不是窗口
坐标系）， flags 是 CV_EVENT_FLAG 的组合， param 是用户定义的传递到
cvSetMouseCallback 函数调用的参数。
param
用户定义的传递到回调函数的参数。
函数 cvSetMouseCallback 设定指定窗口鼠标事件发生时的回调函数。详细使用方法，
请参考 opencv/samples/c/ffilldemo.c demo。

cvWaitKey
等待按键事件

int cvWaitKey( int delay=0 );
delay
延迟的毫秒数。
函数 cvWaitKey 无限制的等待按键事件（delay<=0 时）；或者延迟"delay"毫秒。返回
值为被按键的值，如果超过指定时间则返回-1。
注释：这个函数是 HighGUI 中唯一能够获取和操作事件的函数，所以在一般的事件处理
中，它需要周期地被调用，除非 HighGUI 被用在某些能够处理事件的环境中。

读取与保存图像

cvLoadImage
从文件中读取图像

IplImage* cvLoadImage( const char* filename, int iscolor=1 );
filename
要被读入的文件的文件名。
iscolor
指定读入图像的颜色：
如果 >0，读入的图像将被强制转换为 3 通道彩色图像；
如果为 0, 读入的图像将被强制转换为灰度图像；
如果 <0, 读入的图像将与它本来颜色信息一样（颜色通道数目由图像文件决定）。
函数 cvLoadImage 从指定文件读入图像，返回读入图像的指针。目前支持如下文件格式：
• Windows 位图文件 - BMP, DIB；
• JPEG 文件 - JPEG, JPG, JPE；
• 便携式网络图片 - PNG；
• 便携式图像格式 - PBM，PGM，PPM；
• Sun rasters - SR，RAS；
• TIFF 文件 - TIFF，TIF。

cvSaveImage
保存图像到文件

int cvSaveImage( const char* filename, const CvArr* image );
filename
文件名。
image
要保存的图像。
函数 cvSaveImage 保存图像到指定文件。图像格式的的选择依赖于 filename 的扩展名，
请参考 cvLoadImage。只有 8 位单通道或者 3 通道（通道顺序为'BGR' ）可以使用这个
函数保存。如果格式，深度或者通道不符合要求，请先用 cvCvtScale 和 cvCvtColor
转换；或者使用通用的 cvSave 保存图像为 XML 或者 YAML 格式。

视频读写函数

CvCapture
视频获取结构

typedef struct CvCapture CvCapture;
结构 CvCapture 没有公共接口，它只能被用来作为视频获取函数的一个参数。

cvCaptureFromFile
初始化从文件中获取视频

CvCapture* cvCaptureFromFile( const char* filename );
filename
视频文件名。
函数 cvCaptureFromFile 给指定文件中的视频流分配和初始化 CvCapture 结构。
当分配的结构不再使用的时候，它应该使用 cvReleaseCapture 函数释放掉。

cvCaptureFromCAM
初始化从摄像头中获取视频

CvCapture* cvCaptureFromCAM( int index );
index
要使用的摄像头索引。如果只有一个摄像头或者用哪个摄像头也无所谓，那使用参数-1 应该
便可以。
函数 cvCaptureFromCAM 给从摄像头的视频流分配和初始化 CvCapture 结构。目前在
Windows 下可使用两种接口：Video for Windows（VFW）和 Matrox Imaging Library（MIL）；
Linux 下也有两种接口：V4L 和 FireWire（IEEE1394）。
释放这个结构，使用函数 cvReleaseCapture。

cvReleaseCapture
释放
CvCapture
结构

void cvReleaseCapture( CvCapture** capture );
capture
视频获取结构指针。
函数 cvReleaseCapture 释放由 cvCaptureFromFile 或者 cvCaptureFromCAM 申请的
CvCapture 结构。

cvGrabFrame
从摄像头或者视频文件中抓取帧

int cvGrabFrame( CvCapture* capture );
capture
视频获取结构指针。
函数 cvGrabFrame 从摄像头或者文件中抓取帧。被抓取的帧在内部被存储。这个函数的
目的是
快速
的抓取帧，这一点对同时从几个摄像头读取数据的同步是很重要的。被抓取
的帧可能是压缩的格式（由摄像头／驱动定义），所以没有被公开出来。如果要取回获
取的帧，请使用 cvRetrieveFrame。

cvRetrieveFrame
取回由函数
cvGrabFrame
抓取的图像

IplImage* cvRetrieveFrame( CvCapture* capture );
capture
视频获取结构。
函数 cvRetrieveFrame 返回由函数 cvGrabFrame 抓取的图像的指针。返回的图像不可以
被用户释放或者修改。

cvQueryFrame
从摄像头或者文件中抓取并返回一帧

IplImage* cvQueryFrame( CvCapture* capture );
capture
视频获取结构。
函数 cvQueryFrame 从摄像头或者文件中抓取一帧，然后解压并返回这一帧。这个函数
仅仅是函数 cvGrabFrame 和函数 cvRetrieveFrame 在一起调用的组合。返回的图像不可
以被用户释放或者修改。

cvGetCaptureProperty
获得视频获取结构的属性

double cvGetCaptureProperty( CvCapture* capture, int property_id );
capture
视频获取结构。
property_id
属性标识。可以是下面之一：
CV_CAP_PROP_POS_MSEC - 影片目前位置，为毫秒数或者视频获取时间戳
CV_CAP_PROP_POS_FRAMES - 将被下一步解压／获取的帧索引，以 0 为起点
CV_CAP_PROP_POS_AVI_RATIO - 视频文件的相对位置（0 - 影片的开始，1 - 影片的结尾)
CV_CAP_PROP_FRAME_WIDTH - 视频流中的帧宽度
CV_CAP_PROP_FRAME_HEIGHT - 视频流中的帧高度
CV_CAP_PROP_FPS - 帧率
CV_CAP_PROP_FOURCC - 表示 codec 的四个字符 CV_CAP_PROP_FRAME_COUNT - 视频文件
中帧的总数
函数 cvGetCaptureProperty 获得摄像头或者视频文件的指定属性。
译者注：有时候这个函数在 cvQueryFrame 被调用一次后，再调用 cvGetCaptureProperty
才会返回正确的数值。

cvSetCaptureProperty
设置视频获取属性

int cvSetCaptureProperty( CvCapture* capture, int property_id, double value );
capture
视频获取结构。
property_id
属性标识符。可以是下面之一：
CV_CAP_PROP_POS_MSEC - 从文件开始的位置，单位为毫秒
CV_CAP_PROP_POS_FRAMES - 单位为帧数的位置（只对视频文件有效）
CV_CAP_PROP_POS_AVI_RATIO - 视频文件的相对位置（0 - 影片的开始，1 - 影片的结尾)
CV_CAP_PROP_FRAME_WIDTH - 视频流的帧宽度（只对摄像头有效）
CV_CAP_PROP_FRAME_HEIGHT - 视频流的帧高度（只对摄像头有效）
CV_CAP_PROP_FPS - 帧率（只对摄像头有效）
CV_CAP_PROP_FOURCC - 表示 codec 的四个字符（只对摄像头有效）
value
属性的值。
函数 cvSetCaptureProperty 设置指定视频获取的属性。目前这个函数对视频文件只支
持： CV_CAP_PROP_POS_MSEC, CV_CAP_PROP_POS_FRAMES, CV_CAP_PROP_POS_AVI_RATIO

cvCreateVideoWriter
创建视频文件写入器

typedef struct CvVideoWriter CvVideoWriter;
CvVideoWriter* cvCreateVideoWriter( const char* filename, int fourcc, double
fps, CvSize frame_size, int is_color=1 );
filename
输出视频文件名。
fourcc
四个字符用来表示压缩帧的 codec 例如，CV_FOURCC('P','I','M','1')是 MPEG-1
codec， CV_FOURCC('M','J','P','G')是 motion-jpeg codec 等。在 Win32 下，如果传
入参数-1，可以从一个对话框中选择压缩方法和压缩参数。
fps
被创建视频流的帧率。
frame_size
视频流的大小。
is_color
如果非零，编码器将希望得到彩色帧并进行编码；否则，是灰度帧（只有在 Windows 下支
持这个标志）。
函数 cvCreateVideoWriter 创建视频写入器结构。

cvReleaseVideoWriter
释放视频写入器

void cvReleaseVideoWriter( CvVideoWriter** writer );
writer
指向视频写入器的指针。
函数 cvReleaseVideoWriter 结束视频文件的写入并且释放这个结构。

cvWriteFrame
写入一帧到一个视频文件中

int cvWriteFrame( CvVideoWriter* writer, const IplImage* image );
writer
视频写入器结构。
image
被写入的帧。
函数 cvWriteFrame 写入／附加到视频文件一帧。

实用函数与系统函数

cvInitSystem
初始化
HighGUI
int cvInitSystem( int argc, char** argv );
argc
命令行参数个数。
argv
命令行参数数组。
函数 cvInitSystem 初始化 HighGUI。如果在第一个窗口被创建前这个函数不能被用户显
式地调用，这个函数将以参数 argc=0，argv=NULL 隐式地被调用。在 Win32 下，没有必
要显式调用这个函数。在 X Window 下，参数也许被用来自定义一个 HighGUI 窗口和控
件的外观。

cvConvertImage
Converts one image to another with optional vertical flip
void cvConvertImage( const CvArr* src, CvArr* dst, int flags=0 );
src
输入图像。
dst
目标图像。必须为单通道或者 3 通道 8 位图像。
flags
操作标志：
CV_CVTIMG_FLIP - 垂直翻转图像。 CV_CVTIMG_SWAP_RB - 交换红蓝通道。在 OpenCV
中，彩色图像的通道顺序是 BGR 然而在一些系统中，在显式图像之前通道顺序应该被翻转
为（cvShowImage 能够自动转换）。
函数 cvConvertImage 转换一幅图像到另一幅图像，如果需要的话可以垂直翻转图像。
这个函数被 cvShowImage 使用

按字母顺序排列的函数列表

C
CaptureFromCAM ConvertImage CreateVideoWriter
CaptureFromFile CreateTrackbar

D
DestroyAllWindows DestroyWindow

G
GetCaptureProperty GetWindowHandle GrabFrame
GetTrackbarPos GetWindowName

I
InitSystem

L
LoadImage

M
MoveWindow

N
NamedWindow

Q
QueryFrame

R
ReleaseCapture ResizeWindow
ReleaseVideoWriter RetrieveFrame

S
SaveImage SetMouseCallback ShowImage
SetCaptureProperty SetTrackbarPos

W
WaitKey WriteFrame

CV 参考手册

你可能感兴趣的:(opencv学习笔记)