opencv2.2.0源代码（include文件）分析（2）

modules/core/include/opencv2/core/types_c.h

前面的是一些宏定义，是为了兼容C，C++。对于一些函数的调用方式，建议补充一点补充知识：http://blog.csdn.net/yongdun_007/archive/2010/12/21/6090281.aspx，

这个头文件是很重要的一个文件，建议大家都看看，这里定义了opencv用到的所有的数据类型和结构。详细如下： types_c.h包括：常用的宏指令和内联函数，随机数的生成，图像数据类型，矩阵数据类型，多维稠密矩阵，多维稀疏矩阵，稀疏矩阵迭代，直方图，其他数据类型定义（包括矩形，终止准则，点和变量，size变量和Box变量，片和部分，尺度或者角度），动态数据结构（包括内存存储，序列，节点或者集，图结构，链和轮廓），序列类型，序列的读/写操作，对序列的操作（包括图的微操作），保持数据结构的稳定性，系统数据类型。

常用的宏指令和内联函数

#define CV_PI 3.1415926535897932384626433832795//定义PI大小

#define CV_LOG2 0.69314718055994530941723212145818//定义log2

#define CV_SWAP(a,b,t) ((t) = (a), (a) = (b), (b) = (t))//交换a,b

#ifndef MIN #define MIN(a,b) ((a) > (b) ? (b) : (a))//求a,b最小值

#endif #ifndef MAX #define MAX(a,b) ((a) < (b) ? (b) : (a))//求a,b最大值

#endif /* min & max without jumps */

#define CV_IMIN(a, b) ((a) ^ (((a)^(b)) & (((a) < (b)) - 1)))

//

#define CV_IMAX(a, b) ((a) ^ (((a)^(b)) & (((a) > (b)) - 1)))

//

/* absolute value without jumps */

#ifndef __cplusplus #define CV_IABS(a) (((a) ^ ((a) < 0 ? -1 : 0)) - ((a) < 0 ? -1 : 0))

#else

#define CV_IABS(a) abs(a)

#endif

#define CV_CMP(a,b) (((a) > (b)) - ((a) < (b)))

#define CV_SIGN(a) CV_CMP((a),0)

// 返回和参数最接近的整数值 CV_INLINE int cvRound( double value )

//返回不大于参数的最大整数值 CV_INLINE int cvFloor( double value )

//返回不小于参数的最小整数值 CV_INLINE int cvCeil( double value )

//对参数开平方并进行求倒

#define cvInvSqrt(value) ((float)(1./sqrt(value)))

//对参数开平方

#define cvSqrt(value) ((float)sqrt(value))

//判定是否为合法数 CV_INLINE int cvIsNaN( double value )

//判定是否为无穷 CV_INLINE int cvIsInf( double value )

随机数的生成

typedef uint64 CvRNG;

//初始化随机数生成器状态 CV_INLINE CvRNG cvRNG( int64 seed CV_DEFAULT(-1))

//返回32位无符号整型并更新RNG CV_INLINE unsigned cvRandInt( CvRNG* rng )

//返回浮点型随机数并更新RNG CV_INLINE double cvRandReal( CvRNG* rng )

图像数据类型

#ifndef HAVE_IPL

/* * The following definitions (until #endif)

* is an extract from IPL headers.

* Copyright (c) 1995 Intel Corporation.

*/

//定义深度位数

#define IPL_DEPTH_SIGN 0x80000000

#define IPL_DEPTH_1U 1

#define IPL_DEPTH_8U 8

#define IPL_DEPTH_16U 16

#define IPL_DEPTH_32F 32

//定义有符号深度位数

#define IPL_DEPTH_8S (IPL_DEPTH_SIGN| 8)

#define IPL_DEPTH_16S (IPL_DEPTH_SIGN|16)

#define IPL_DEPTH_32S (IPL_DEPTH_SIGN|32)

//定义数据顺序

#define IPL_DATA_ORDER_PIXEL 0

#define IPL_DATA_ORDER_PLANE 1

//定义图像原点位置

#define IPL_ORIGIN_TL 0 //左上

#define IPL_ORIGIN_BL 1 //左下

//定义扫描线位数

#define IPL_ALIGN_4BYTES 4

#define IPL_ALIGN_8BYTES 8

#define IPL_ALIGN_16BYTES 16

#define IPL_ALIGN_32BYTES 32

//定义扫描线对齐

#define IPL_ALIGN_DWORD IPL_ALIGN_4BYTES

#define IPL_ALIGN_QWORD IPL_ALIGN_8BYTES

//定义扫描线宽度状态

#define IPL_BORDER_CONSTANT 0 //扫描线连续

#define IPL_BORDER_REPLICATE 1 //双扫描线

#define IPL_BORDER_REFLECT 2 //带阴影扫描线

#define IPL_BORDER_WRAP 3 //波浪扫描线

//定义图像结构体

typedef struct _IplImage

{

int nSize; /* sizeof(IplImage) */
int ID; /* version (=0)*/
int nChannels; /* Most of OpenCV functions support 1,2,3 or 4 channels */
int alphaChannel; /* Ignored by OpenCV */
int depth; /* Pixel depth in bits: IPL_DEPTH_8U, IPL_DEPTH_8S, IPL_DEPTH_16S, IPL_DEPTH_32S,IPL_DEPTH_32F and IPL_DEPTH_64F are supported. */
char colorModel[4]; /* Ignored by OpenCV */
char channelSeq[4]; /* ditto */
int dataOrder; /* 0 - interleaved color channels, 1 - separate color channels. cvCreateImage can only create interleaved images */
int origin; /* 0 - top-left origin, 1 - bottom-left origin (Windows bitmaps style). */
int align; /* Alignment of image rows (4 or 8). OpenCV ignores it and uses widthStep instead. */
int width; /* Image width in pixels. */
int height; /* Image height in pixels. */
struct _IplROI *roi; /* Image ROI. If NULL, the whole image is selected. */
struct _IplImage *maskROI; /* Must be NULL. */
void *imageId; /* " " */
struct _IplTileInfo *tileInfo; /* " " */
int imageSize; /* Image data size in bytes (==image->height*image->widthStep in case of interleaved data)*/
char *imageData; /* Pointer to aligned image data. */
int widthStep; /* Size of aligned image row in bytes. */
int BorderMode[4]; /* Ignored by OpenCV. */
int BorderConst[4]; /* Ditto. */
char *imageDataOrigin; /* Pointer to very origin of image data (not necessarily aligned) - needed for correct deallocation */
} IplImage;

//定义图像分块信息结构体 typedef struct _IplTileInfo IplTileInfo;

//定义图像感兴趣区域

typedef struct _IplROI

{

int coi; /* 0 - no COI (all channels are selected), 1 - 0th channel is selected ...*/ //感兴趣通道
int xOffset; //X坐标值
int yOffset; //y坐标值
int width; //感兴趣区域宽度
int height; //感兴趣区域高度
} IplROI;

//定义卷积核结构体

typedef struct _IplConvKernel

{

int nCols;
int nRows;
int anchorX;
int anchorY;
int *values;
int nShiftR;
} IplConvKernel;

//定义快速卷积核结构体

typedef struct _IplConvKernelFP

{

int nCols;
int nRows;
int anchorX;
int anchorY;
float *values;
} IplConvKernelFP;

#define IPL_IMAGE_HEADER 1

#define IPL_IMAGE_DATA 2

#define IPL_IMAGE_ROI 4

#endif/*HAVE_IPL*/

//定义边界模式

#define IPL_BORDER_REFLECT_101 4 //带有阴影

#define IPL_BORDER_TRANSPARENT 5 //透明

#define IPL_IMAGE_MAGIC_VAL ((int)sizeof(IplImage))

#define CV_TYPE_NAME_IMAGE "opencv-image"

#define CV_IS_IMAGE_HDR(img) / ((img) != NULL && ((const IplImage*)(img))->nSize == sizeof(IplImage))

#define CV_IS_IMAGE(img) / (CV_IS_IMAGE_HDR(img) && ((IplImage*)img)->imageData != NULL)

//定义存储在图像的双精度数据 #define IPL_DEPTH_64F 64

//定义从给定图像，给定数据类型，给定坐标(col,row)获取图像像素值

#define CV_IMAGE_ELEM( image, elemtype, row, col ) / (((elemtype*)((image)->imageData + (image)->widthStep*(row)))[(col)])

矩阵数据类型

//

#define CV_CN_MAX 512

//定义矩阵数据最大值 #define CV_CN_SHIFT 3

//

#define CV_DEPTH_MAX (1 << CV_CN_SHIFT)

//定义矩阵数据类型

#define CV_8U 0

#define CV_8S 1

#define CV_16U 2

#define CV_16S 3

#define CV_32S 4

#define CV_32F 5

#define CV_64F 6

#define CV_USRTYPE1 7

//

#define CV_MAT_DEPTH_MASK (CV_DEPTH_MAX - 1)

#define CV_MAT_DEPTH(flags) ((flags) & CV_MAT_DEPTH_MASK)

//

#define CV_MAKETYPE(depth,cn) (CV_MAT_DEPTH(depth) + (((cn)-1) << CV_CN_SHIFT))

#define CV_MAKE_TYPE CV_MAKETYPE

//

#define CV_8UC1 CV_MAKETYPE(CV_8U,1)

#define CV_8UC2 CV_MAKETYPE(CV_8U,2)

#define CV_8UC3 CV_MAKETYPE(CV_8U,3)

#define CV_8UC4 CV_MAKETYPE(CV_8U,4)

#define CV_8UC(n) CV_MAKETYPE(CV_8U,(n))

//

#define CV_8SC1 CV_MAKETYPE(CV_8S,1)

#define CV_8SC2 CV_MAKETYPE(CV_8S,2)

#define CV_8SC3 CV_MAKETYPE(CV_8S,3)

#define CV_8SC4 CV_MAKETYPE(CV_8S,4)

#define CV_8SC(n) CV_MAKETYPE(CV_8S,(n))

//

#define CV_16UC1 CV_MAKETYPE(CV_16U,1)

#define CV_16UC2 CV_MAKETYPE(CV_16U,2)

#define CV_16UC3 CV_MAKETYPE(CV_16U,3)

#define CV_16UC4 CV_MAKETYPE(CV_16U,4)

#define CV_16UC(n) CV_MAKETYPE(CV_16U,(n))

//

#define CV_16SC1 CV_MAKETYPE(CV_16S,1)

#define CV_16SC2 CV_MAKETYPE(CV_16S,2)

#define CV_16SC3 CV_MAKETYPE(CV_16S,3)

#define CV_16SC4 CV_MAKETYPE(CV_16S,4)

#define CV_16SC(n) CV_MAKETYPE(CV_16S,(n))

//

#define CV_32SC1 CV_MAKETYPE(CV_32S,1)

#define CV_32SC2 CV_MAKETYPE(CV_32S,2)

#define CV_32SC3 CV_MAKETYPE(CV_32S,3)

#define CV_32SC4 CV_MAKETYPE(CV_32S,4)

#define CV_32SC(n) CV_MAKETYPE(CV_32S,(n))

//

#define CV_32FC1 CV_MAKETYPE(CV_32F,1)

#define CV_32FC2 CV_MAKETYPE(CV_32F,2)

#define CV_32FC3 CV_MAKETYPE(CV_32F,3)

#define CV_32FC4 CV_MAKETYPE(CV_32F,4)

#define CV_32FC(n) CV_MAKETYPE(CV_32F,(n))

//

#define CV_64FC1 CV_MAKETYPE(CV_64F,1)

#define CV_64FC2 CV_MAKETYPE(CV_64F,2)

#define CV_64FC3 CV_MAKETYPE(CV_64F,3)

#define CV_64FC4 CV_MAKETYPE(CV_64F,4)

#define CV_64FC(n) CV_MAKETYPE(CV_64F,(n))

//

#define CV_AUTO_STEP 0x7fffffff

#define CV_WHOLE_ARR cvSlice( 0, 0x3fffffff )

//

#define CV_MAT_CN_MASK ((CV_CN_MAX - 1) << CV_CN_SHIFT)

#define CV_MAT_CN(flags) ((((flags) & CV_MAT_CN_MASK) >> CV_CN_SHIFT) + 1)

#define CV_MAT_TYPE_MASK (CV_DEPTH_MAX*CV_CN_MAX - 1)

#define CV_MAT_TYPE(flags) ((flags) & CV_MAT_TYPE_MASK)

#define CV_MAT_CONT_FLAG_SHIFT 14

#define CV_MAT_CONT_FLAG (1 << CV_MAT_CONT_FLAG_SHIFT)

#define CV_IS_MAT_CONT(flags) ((flags) & CV_MAT_CONT_FLAG)

#define CV_IS_CONT_MAT CV_IS_MAT_CONT

#define CV_SUBMAT_FLAG_SHIFT 15

#define CV_SUBMAT_FLAG (1 << CV_SUBMAT_FLAG_SHIFT)

#define CV_IS_SUBMAT(flags) ((flags) & CV_MAT_SUBMAT_FLAG)

//

#define CV_MAGIC_MASK 0xFFFF0000

#define CV_MAT_MAGIC_VAL 0x42420000

#define CV_TYPE_NAME_MAT "opencv-matrix"

//定义矩阵结构体

typedef struct CvMat

{

int type;
int step; /* for internal use only */
int* refcount;
int hdr_refcount;
union
{
uchar* ptr;
short* s;
int* i;
float* fl;
double* db;
} data;
#ifdef __cplusplus
union
{
int rows;
int height;
};
union
{
int cols;
int width;
};
#else
int rows;
int cols;
#endif
} CvMat;

//判断矩阵头指针

#define CV_IS_MAT_HDR(mat) / ((mat) != NULL && / (((const CvMat*)(mat))->type & CV_MAGIC_MASK) == CV_MAT_MAGIC_VAL && / ((const CvMat*)(mat))->cols > 0 && ((const CvMat*)(mat))->rows > 0)

//

#define CV_IS_MAT_HDR_Z(mat) / ((mat) != NULL && / (((const CvMat*)(mat))->type & CV_MAGIC_MASK) == CV_MAT_MAGIC_VAL && / ((const CvMat*)(mat))->cols >= 0 && ((const CvMat*)(mat))->rows >= 0)

//

#define CV_IS_MAT(mat) / (CV_IS_MAT_HDR(mat) && ((const CvMat*)(mat))->data.ptr != NULL)

//

#define CV_IS_MASK_ARR(mat) / (((mat)->type & (CV_MAT_TYPE_MASK & ~CV_8SC1)) == 0)

#define CV_ARE_TYPES_EQ(mat1, mat2) / ((((mat1)->type ^ (mat2)->type) & CV_MAT_TYPE_MASK) == 0)

//

#define CV_ARE_CNS_EQ(mat1, mat2) / ((((mat1)->type ^ (mat2)->type) & CV_MAT_CN_MASK) == 0)

//

#define CV_ARE_DEPTHS_EQ(mat1, mat2) / ((((mat1)->type ^ (mat2)->type) & CV_MAT_DEPTH_MASK) == 0)

//

#define CV_ARE_SIZES_EQ(mat1, mat2) / ((mat1)->rows == (mat2)->rows && (mat1)->cols == (mat2)->cols)

#define CV_IS_MAT_CONST(mat) / (((mat)->rows|(mat)->cols) == 1)

//

/* Size of each channel item, 0x124489 = 1000 0100 0100 0010 0010 0001 0001 ~ array of sizeof(arr_type_elem) */ #define CV_ELEM_SIZE1(type) / ((((sizeof(size_t)<<28)|0x8442211) >> CV_MAT_DEPTH(type)*4) & 15)

//

/* 0x3a50 = 11 10 10 01 01 00 00 ~ array of log2(sizeof(arr_type_elem)) */

#define CV_ELEM_SIZE(type) / (CV_MAT_CN(type) << ((((sizeof(size_t)/4+1)*16384|0x3a50) >> CV_MAT_DEPTH(type)*2) & 3))

//

#define IPL2CV_DEPTH(depth) / ((((CV_8U)+(CV_16U<<4)+(CV_32F<<8)+(CV_64F<<16)+(CV_8S<<20)+ / (CV_16S<<24)+(CV_32S<<28)) >> ((((depth) & 0xF0) >> 2) + / (((depth) & IPL_DEPTH_SIGN) ? 20 : 0))) & 15)

//初始化矩阵

/* Inline constructor. No data is allocated internally!!! * (Use together with cvCreateData, or use cvCreateMat instead to * get a matrix with allocated data): */

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

//快速将数据添加到矩阵

#define CV_MAT_ELEM_PTR_FAST( mat, row, col, pix_size ) / (assert( (unsigned)(row) < (unsigned)(mat).rows && / (unsigned)(col) < (unsigned)(mat).cols ), / (mat).data.ptr + (size_t)(mat).step*(row) + (pix_size)*(col))

//快速将数据添加到矩阵（1）

#define CV_MAT_ELEM_PTR( mat, row, col ) / CV_MAT_ELEM_PTR_FAST( mat, row, col, CV_ELEM_SIZE((mat).type) )

//快速将数据添加到矩阵（2）

#define CV_MAT_ELEM( mat, elemtype, row, col ) / (*(elemtype*)CV_MAT_ELEM_PTR_FAST( mat, row, col, sizeof(elemtype)))

//从矩阵中获取数据 CV_INLINE double cvmGet( const CvMat* mat, int row, int col )

//将数据添加到矩阵 CV_INLINE void cvmSet( CvMat* mat, int row, int col, double value )

//设置矩阵数据类型 CV_INLINE int cvIplDepth( int type )

多维稠密矩阵

//

#define CV_MATND_MAGIC_VAL 0x42430000

#define CV_TYPE_NAME_MATND "opencv-nd-matrix"

//

#define CV_MAX_DIM 32

#define CV_MAX_DIM_HEAP (1 << 16)

//定义稠密矩阵结构体

typedef struct CvMatND

{

int type;
int dims;
int* refcount;
int hdr_refcount;
union
{
uchar* ptr;
float* fl;
double* db;
int* i;
short* s;
} data;
struct
{
int size;
int step;
} dim[CV_MAX_DIM];
} CvMatND;

//

#define CV_IS_MATND_HDR(mat) / ((mat) != NULL && (((const CvMatND*)(mat))->type & CV_MAGIC_MASK) == CV_MATND_MAGIC_VAL)

//

#define CV_IS_MATND(mat) / (CV_IS_MATND_HDR(mat) && ((const CvMatND*)(mat))->data.ptr != NULL)

多维稀疏矩阵

//

#define CV_SPARSE_MAT_MAGIC_VAL 0x42440000

#define CV_TYPE_NAME_SPARSE_MAT "opencv-sparse-matrix"

// struct CvSet;

//定义稀疏矩阵结构体

typedef struct CvSparseMat

{

int type;
int dims;
int* refcount;
int hdr_refcount;
struct CvSet* heap;
void** hashtable;
int hashsize;
int valoffset;
int idxoffset;
int size[CV_MAX_DIM];
} CvSparseMat;

//

#define CV_IS_SPARSE_MAT_HDR(mat) / ((mat) != NULL && / (((const CvSparseMat*)(mat))->type & CV_MAGIC_MASK) == CV_SPARSE_MAT_MAGIC_VAL) // #define CV_IS_SPARSE_MAT(mat) / CV_IS_SPARSE_MAT_HDR(mat)

稀疏矩阵迭代

//定义稀疏矩阵迭代体结构体

typedef struct CvSparseNode

{

unsigned hashval;
struct CvSparseNode* next;
} CvSparseNode;

//定义稀疏矩阵迭代器

typedef struct CvSparseMatIterator

{

CvSparseMat* mat;
CvSparseNode* node;
int curidx;
} CvSparseMatIterator;

#define CV_NODE_VAL(mat,node) ((void*)((uchar*)(node) + (mat)->valoffset))

#define CV_NODE_IDX(mat,node) ((int*)((uchar*)(node) + (mat)->idxoffset))

直方图

typedef int CvHistType;

//

#define CV_HIST_MAGIC_VAL 0x42450000

#define CV_HIST_UNIFORM_FLAG (1 << 10)

//维区域是否设置的标签

#define CV_HIST_RANGES_FLAG (1 << 11) //定义矩阵状态

#define CV_HIST_ARRAY 0 //数组直方图

#define CV_HIST_SPARSE 1 //稀疏直方图

#define CV_HIST_TREE CV_HIST_SPARSE //树形直方图

/* should be used as a parameter only, it turns to CV_HIST_UNIFORM_FLAG of hist->type */

#define CV_HIST_UNIFORM 1

//定义直方图结构体

typedef struct CvHistogram

{

int type;
CvArr* bins;
float thresh[CV_MAX_DIM][2]; /* For uniform histograms. */
float** thresh2; /* For non-uniform histograms. */
CvMatND mat; /* Embedded matrix header for array histograms. */
} CvHistogram;

//

#define CV_IS_HIST( hist ) / ((hist) != NULL && / (((CvHistogram*)(hist))->type & CV_MAGIC_MASK) == CV_HIST_MAGIC_VAL && / (hist)->bins != NULL)

//

#define CV_IS_UNIFORM_HIST( hist ) / (((hist)->type & CV_HIST_UNIFORM_FLAG) != 0)

//

#define CV_IS_SPARSE_HIST( hist ) / CV_IS_SPARSE_MAT((hist)->bins)

//

#define CV_HIST_HAS_RANGES( hist ) / (((hist)->type & CV_HIST_RANGES_FLAG) != 0)

其他数据类型应用定义------矩形

//定义矩形结构体

typedef struct CvRect

{

int x;
int y;
int width;
int height;
} CvRect;

//矩形初始化 CV_INLINE CvRect cvRect( int x, int y, int width, int height )

{

CvRect r;
r.x = x;
r.y = y;
r.width = width;
r.height = height;
return r;
}

//在感兴趣通道上设置图的感兴趣区域 CV_INLINE IplROI cvRectToROI( CvRect rect, int coi )

//获取感兴趣区域的矩形大小 CV_INLINE CvRect cvROIToRect( IplROI roi )

其他数据类型应用定义------终止准则

//

#define CV_TERMCRIT_ITER 1

#define CV_TERMCRIT_NUMBER CV_TERMCRIT_ITER

#define CV_TERMCRIT_EPS 2

//定义迭代算法的终止准则结构体

typedef struct CvTermCriteria

{

int type; /* may be combination of CV_TERMCRIT_ITER CV_TERMCRIT_EPS */
int max_iter;
double epsilon;
} CvTermCriteria;

//初始化终止准则 CV_INLINE CvTermCriteria cvTermCriteria( int type, int max_iter, double epsilon )

其他数据类型应用定义------点和变量

//定义整型二维点

typedef struct CvPoint

{

int x;
int y;
} CvPoint;

//初始化二维点

CV_INLINE CvPoint cvPoint( int x, int y )

{

CvPoint p;
p.x = x;
p.y = y;
return p;
}

//定义浮点型二维点

typedef struct CvPoint2D32f

{

float x;
float y;
} CvPoint2D32f;

//初始化浮点型二维点

CV_INLINE CvPoint2D32f cvPoint2D32f( double x, double y )

{

CvPoint2D32f p;

p.x = (float)x;
p.y = (float)y;
return p;
}

//

CV_INLINE CvPoint2D32f cvPointTo32f( CvPoint point )

{

return cvPoint2D32f( (float)point.x, (float)point.y );
}

CV_INLINE CvPoint cvPointFrom32f( CvPoint2D32f point )

{

CvPoint ipt;
ipt.x = cvRound(point.x);
ipt.y = cvRound(point.y);
return ipt;
}

//定义浮点型三维点

typedef struct CvPoint3D32f

{

float x;
float y;
float z;
} CvPoint3D32f;

//初始化浮点型三维点

CV_INLINE CvPoint3D32f cvPoint3D32f( double x, double y, double z )

{

CvPoint3D32f p;
p.x = (float)x;
p.y = (float)y;
p.z = (float)z;
return p;
}

//定义双精度型二维点

typedef struct CvPoint2D64f

{

double x;
double y;
} CvPoint2D64f;

//初始化双精度型二维点

CV_INLINE CvPoint2D64f cvPoint2D64f( double x, double y )

{

CvPoint2D64f p;
p.x = x;
p.y = y;
return p;
}

//定义双精度型三维点

typedef struct CvPoint3D64f

{

double x;
double y;
double z;
}CvPoint3D64f;

//初始化双精度型三维点

CV_INLINE CvPoint3D64f cvPoint3D64f( double x, double y, double z )

{

CvPoint3D64f p;
p.x = x;
p.y = y;
p.z = z;
return p;
}

其他数据类型应用定义------size变量和Box箱变量

//定义size

typedef struct

{

int width;
int height;
} CvSize;

//初始化size

CV_INLINE CvSize cvSize( int width, int height )

{

CvSize s;
s.width = width;
s.height = height;
return s;
}

//定义二维浮点型size

typedef struct CvSize2D32f

{

float width;
float height;
} CvSize2D32f;

//初始化二维浮点型size

CV_INLINE CvSize2D32f cvSize2D32f( double width, double height )

{

CvSize2D32f s;
s.width = (float)width;
s.height = (float)height;
return s;
}

//定义二维箱

typedef struct CvBox2D

{

CvPoint2D32f center; /* Center of the box. */
CvSize2D32f size; /* Box width and length. */
float angle; /* Angle between the horizontal axis */ /* and the first side (i.e. length) in degrees */
} CvBox2D;

//定义线性迭代状态

typedef struct CvLineIterator

{

/* Pointer to the current point: */
uchar* ptr; /* Bresenham algorithm state: */
int err;
int plus_delta
; int minus_delta;
int plus_step;
int minus_step;
} CvLineIterator;

其他数据类型应用定义------片，部分

//定义片

typedef struct CvSlice

{

int start_index,
end_index;
} CvSlice;

//初始化片

CV_INLINE CvSlice cvSlice( int start, int end )

{

CvSlice slice;
slice.start_index = start;
slice.end_index = end;
return slice;
}

#define CV_WHOLE_SEQ_END_INDEX 0x3fffffff #define CV_WHOLE_SEQ cvSlice(0, CV_WHOLE_SEQ_END_INDEX)

其他数据类型应用定义------尺度，角度

//定义角度结构体

typedef struct CvScalar

{

double val[4];
} CvScalar;

//初始化角度

CV_INLINE CvScalar cvScalar( double val0, double val1 CV_DEFAULT(0), double val2 CV_DEFAULT(0), double val3 CV_DEFAULT(0))

{

CvScalar scalar;
scalar.val[0] = val0;
scalar.val[1] = val1;
scalar.val[2] = val2;
scalar.val[3] = val3;
return scalar;
}

CV_INLINE CvScalar cvRealScalar( double val0 ) { CvScalar scalar; scalar.val[0] = val0; scalar.val[1] = scalar.val[2] = scalar.val[3] = 0; return scalar; } CV_INLINE CvScalar cvScalarAll( double val0123 ) { CvScalar scalar; scalar.val[0] = val0123; scalar.val[1] = val0123; scalar.val[2] = val0123; scalar.val[3] = val0123; return scalar; }

动态数据结构-内存存储

//定义内存块结构 typedef struct CvMemBlock { struct CvMemBlock* prev; struct CvMemBlock* next; } CvMemBlock; #define CV_STORAGE_MAGIC_VAL 0x42890000 typedef struct CvMemStorage { int signature; CvMemBlock* bottom; /* First allocated block. */ CvMemBlock* top; /* Current memory block - top of the stack. */ struct CvMemStorage* parent; /* We get new blocks from parent as needed. */ int block_size; /* Block size. */ int free_space; /* Remaining free space in current block. */ } CvMemStorage; #define CV_IS_STORAGE(storage) / ((storage) != NULL && / (((CvMemStorage*)(storage))->signature & CV_MAGIC_MASK) == CV_STORAGE_MAGIC_VAL) typedef struct CvMemStoragePos { CvMemBlock* top; int free_space; } CvMemStoragePos;

动态数据结构-序列（线性）

//定义序列块结构体 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. */ schar* data; /* Pointer to the first element of the block. */ } CvSeqBlock; //定义序列节点 #define CV_TREE_NODE_FIELDS(node_type) / int flags; /* Miscellaneous 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. */ //读和写序列（动态的添加和删除元素） #define CV_SEQUENCE_FIELDS() / CV_TREE_NODE_FIELDS(CvSeq); / int total; /* Total number of elements. */ / int elem_size; /* Size of sequence element in bytes. */ / schar* block_max; /* Maximal bound of the last block. */ / schar* ptr; /* Current write pointer. */ / int delta_elems; /* Grow seq this many at a time. */ / 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; #define CV_TYPE_NAME_SEQ "opencv-sequence" #define CV_TYPE_NAME_SEQ_TREE "opencv-sequence-tree"

动态数据结构-节点（集）

（节点顺序是不被保护的，他们可看成介于元素间的空隙，但被插入后就保留在该地方，判断有元素，看MSB‘mose-significant or sign bit’的标志位） //定义序列节点属性 #define CV_SET_ELEM_FIELDS(elem_type) / int flags; / struct elem_type* next_free; //设置序列元素 typedef struct CvSetElem { CV_SET_ELEM_FIELDS(CvSetElem) } CvSetElem; // #define CV_SET_FIELDS() / CV_SEQUENCE_FIELDS() / CvSetElem* free_elems; / int active_count; // typedef struct CvSet { CV_SET_FIELDS() } CvSet; #define CV_SET_ELEM_IDX_MASK ((1 << 26) - 1) #define CV_SET_ELEM_FREE_FLAG (1 << (sizeof(int)*8-1)) //定义元素指针被设置与否 #define CV_IS_SET_ELEM( ptr ) (((CvSetElem*)(ptr))->flags >= 0) 动态数据结构-图结构 /* 这里图结构是基于点序列的，点包括相邻列表（具体讲，是指向第一个进和出（或者为0，即独立点）的边缘），边缘被存储在另一个数据集中。对于每一个点都有单一的列表来表示进/出的边缘。 每一条边包括： 1,分别指向开始和结束的点(vtx[0]和vtx[1]) 对于无向图，点i到j的边，在查找时是相同的。 2，分别指向边的开始点，即next[0]指向vtx[0]相邻的点和结束点，即 next[1]指向vtx[1]相邻的点。 */ //定义图边属性 #define CV_GRAPH_EDGE_FIELDS() / int flags; / float weight; / struct CvGraphEdge* next[2]; / struct CvGraphVtx* vtx[2]; //定义图节点属性 #define CV_GRAPH_VERTEX_FIELDS() / int flags; / struct CvGraphEdge* first; //定义图边结构体 typedef struct CvGraphEdge { CV_GRAPH_EDGE_FIELDS() } CvGraphEdge; //定义图节点结构体 typedef struct CvGraphVtx { CV_GRAPH_VERTEX_FIELDS() } CvGraphVtx; //定义二维图 typedef struct CvGraphVtx2D { CV_GRAPH_VERTEX_FIELDS() CvPoint2D32f* ptr; } CvGraphVtx2D; /* 图的定义继承节点的定义（是一系列节点集，并包含另一个边集） */ //定义图属性 #define CV_GRAPH_FIELDS() / CV_SET_FIELDS() / CvSet* edges; //定义图结构 typedef struct CvGraph { CV_GRAPH_FIELDS() } CvGraph; #define CV_TYPE_NAME_GRAPH "opencv-graph"

动态数据结构-链和轮廓

//定义链结构 typedef struct CvChain { CV_SEQUENCE_FIELDS() CvPoint origin; } CvChain; //定义轮廓属性 #define CV_CONTOUR_FIELDS() / CV_SEQUENCE_FIELDS() / CvRect rect; / int color; / int reserved[3]; //定义轮廓结构体 typedef struct CvContour { CV_CONTOUR_FIELDS() } CvContour; typedef CvContour CvPoint2DSeq;

序列类型

//表示稠密序列 #define CV_SEQ_MAGIC_VAL 0x42990000 #define CV_IS_SEQ(seq) / ((seq) != NULL && (((CvSeq*)(seq))->flags & CV_MAGIC_MASK) == CV_SEQ_MAGIC_VAL) //表示稀疏序列 #define CV_SET_MAGIC_VAL 0x42980000 #define CV_IS_SET(set) / ((set) != NULL && (((CvSeq*)(set))->flags & CV_MAGIC_MASK) == CV_SET_MAGIC_VAL) //表示稠密序列元素位数 #define CV_SEQ_ELTYPE_BITS 12 #define CV_SEQ_ELTYPE_MASK ((1 << CV_SEQ_ELTYPE_BITS) - 1) // #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 #define CV_SEQ_ELTYPE_PTR CV_USRTYPE1 #define CV_SEQ_ELTYPE_PPOINT CV_SEQ_ELTYPE_PTR /* &(x,y) */ #define CV_SEQ_ELTYPE_INDEX CV_32SC1 /* #(x,y) */ #define CV_SEQ_ELTYPE_GRAPH_EDGE 0 /* &next_o, &next_d, &vtx_o, &vtx_d */ #define CV_SEQ_ELTYPE_GRAPH_VERTEX 0 /* first_edge, &(x,y) */ #define CV_SEQ_ELTYPE_TRIAN_ATR 0 /* vertex of the binary tree */ #define CV_SEQ_ELTYPE_CONNECTED_COMP 0 /* connected component */ #define CV_SEQ_ELTYPE_POINT3D CV_32FC3 /* (x,y,z) */ //表示稠密序列类型位数 #define CV_SEQ_KIND_BITS 2 #define CV_SEQ_KIND_MASK (((1 << CV_SEQ_KIND_BITS) - 1)<flags & CV_SEQ_ELTYPE_MASK) #define CV_SEQ_KIND( seq ) ((seq)->flags & CV_SEQ_KIND_MASK ) //标记检测 #define CV_IS_SEQ_INDEX( seq ) ((CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_INDEX) && / (CV_SEQ_KIND(seq) == CV_SEQ_KIND_GENERIC)) #define CV_IS_SEQ_CURVE( seq ) (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE) #define CV_IS_SEQ_CLOSED( seq ) (((seq)->flags & CV_SEQ_FLAG_CLOSED) != 0) #define CV_IS_SEQ_CONVEX( seq ) 0 #define CV_IS_SEQ_HOLE( seq ) (((seq)->flags & CV_SEQ_FLAG_HOLE) != 0) #define CV_IS_SEQ_SIMPLE( seq ) 1 //类型检测 #define CV_IS_SEQ_POINT_SET( seq ) / ((CV_SEQ_ELTYPE(seq) == CV_32SC2 || CV_SEQ_ELTYPE(seq) == CV_32FC2)) #define CV_IS_SEQ_POINT_SUBSET( seq ) / (CV_IS_SEQ_INDEX( seq ) || CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_PPOINT) #define CV_IS_SEQ_POLYLINE( seq ) / (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && CV_IS_SEQ_POINT_SET(seq)) #define CV_IS_SEQ_POLYGON( seq ) / (CV_IS_SEQ_POLYLINE(seq) && CV_IS_SEQ_CLOSED(seq)) #define CV_IS_SEQ_CHAIN( seq ) / (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && (seq)->elem_size == 1) #define CV_IS_SEQ_CONTOUR( seq ) / (CV_IS_SEQ_CLOSED(seq) && (CV_IS_SEQ_POLYLINE(seq) || CV_IS_SEQ_CHAIN(seq))) #define CV_IS_SEQ_CHAIN_CONTOUR( seq ) / (CV_IS_SEQ_CHAIN( seq ) && CV_IS_SEQ_CLOSED( seq )) #define CV_IS_SEQ_POLYGON_TREE( seq ) / (CV_SEQ_ELTYPE (seq) == CV_SEQ_ELTYPE_TRIAN_ATR && / CV_SEQ_KIND( seq ) == CV_SEQ_KIND_BIN_TREE ) #define CV_IS_GRAPH( seq ) / (CV_IS_SET(seq) && CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_GRAPH) #define CV_IS_GRAPH_ORIENTED( seq ) / (((seq)->flags & CV_GRAPH_FLAG_ORIENTED) != 0) #define CV_IS_SUBDIV2D( seq ) / (CV_IS_SET(seq) && CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_SUBDIV2D)

序列的读/写操作

//定义序列写的属性 #define CV_SEQ_WRITER_FIELDS() / int header_size; / CvSeq* seq; /* the sequence written */ / CvSeqBlock* block; /* current block */ / schar* ptr; /* pointer to free space */ / schar* block_min; /* pointer to the beginning of block*// schar* block_max; /* pointer to the end of block */ //定义序列写结构体 typedef struct CvSeqWriter { CV_SEQ_WRITER_FIELDS() } CvSeqWriter; //定义序列读的属性 #define CV_SEQ_READER_FIELDS() / int header_size; / CvSeq* seq; /* sequence, beign read */ / CvSeqBlock* block; /* current block */ / schar* ptr; /* pointer to element be read next */ / schar* block_min; /* pointer to the beginning of block *// schar* block_max; /* pointer to the end of block */ / int delta_index;/* = seq->first->start_index */ / schar* prev_elem; /* pointer to previous element */ //定义序列读的结构体 typedef struct CvSeqReader { CV_SEQ_READER_FIELDS() } CvSeqReader; 对序列的操作 #define CV_SEQ_ELEM( seq, elem_type, index ) / /* assert gives some guarantee that parameter is valid */ / ( assert(sizeof((seq)->first[0]) == sizeof(CvSeqBlock) && / (seq)->elem_size == sizeof(elem_type)), / (elem_type*)((seq)->first && (unsigned)index < / (unsigned)((seq)->first->count) ? / (seq)->first->data + (index) * sizeof(elem_type) : / cvGetSeqElem( (CvSeq*)(seq), (index) ))) #define CV_GET_SEQ_ELEM( elem_type, seq, index ) CV_SEQ_ELEM( (seq), elem_type, (index) ) //在序列中增加元素 #define CV_WRITE_SEQ_ELEM_VAR( elem_ptr, writer ) / { / if( (writer).ptr >= (writer).block_max ) / { / cvCreateSeqBlock( &writer); / } / memcpy((writer).ptr, elem_ptr, (writer).seq->elem_size);/ (writer).ptr += (writer).seq->elem_size; / } #define CV_WRITE_SEQ_ELEM( elem, writer ) / { / assert( (writer).seq->elem_size == sizeof(elem)); / if( (writer).ptr >= (writer).block_max ) / { / cvCreateSeqBlock( &writer); / } / assert( (writer).ptr <= (writer).block_max - sizeof(elem));/ memcpy((writer).ptr, &(elem), sizeof(elem)); / (writer).ptr += sizeof(elem); / } //向前移动读序列位置 #define CV_NEXT_SEQ_ELEM( elem_size, reader ) / { / if( ((reader).ptr += (elem_size)) >= (reader).block_max ) / { / cvChangeSeqBlock( &(reader), 1 ); / } / } //向前移动读序列位置 #define CV_PREV_SEQ_ELEM( elem_size, reader ) / { / if( ((reader).ptr -= (elem_size)) < (reader).block_min ) / { / cvChangeSeqBlock( &(reader), -1 ); / } / } //读序列中元素并向前移动读位置 #define CV_READ_SEQ_ELEM( elem, reader ) / { / assert( (reader).seq->elem_size == sizeof(elem)); / memcpy( &(elem), (reader).ptr, sizeof((elem))); / CV_NEXT_SEQ_ELEM( sizeof(elem), reader ) / } //读序列中元素并向前移动读位置 #define CV_REV_READ_SEQ_ELEM( elem, reader ) / { / assert( (reader).seq->elem_size == sizeof(elem)); / memcpy(&(elem), (reader).ptr, sizeof((elem))); / CV_PREV_SEQ_ELEM( sizeof(elem), reader ) / } #define CV_READ_CHAIN_POINT( _pt, reader ) / { / (_pt) = (reader).pt; / if( (reader).ptr ) / { / CV_READ_SEQ_ELEM( (reader).code, (reader)); / assert( ((reader).code & ~7) == 0 ); / (reader).pt.x += (reader).deltas[(int)(reader).code][0]; / (reader).pt.y += (reader).deltas[(int)(reader).code][1]; / } / } #define CV_CURRENT_POINT( reader ) (*((CvPoint*)((reader).ptr))) #define CV_PREV_POINT( reader ) (*((CvPoint*)((reader).prev_elem))) //读边序列 #define CV_READ_EDGE( pt1, pt2, reader ) / { / assert( sizeof(pt1) == sizeof(CvPoint) && / sizeof(pt2) == sizeof(CvPoint) && / reader.seq->elem_size == sizeof(CvPoint)); / (pt1) = CV_PREV_POINT( reader ); / (pt2) = CV_CURRENT_POINT( reader ); / (reader).prev_elem = (reader).ptr; / CV_NEXT_SEQ_ELEM( sizeof(CvPoint), (reader)); / } 对序列的操作-图的微操作 //返回给定顶点的图边缘 #define CV_NEXT_GRAPH_EDGE( edge, vertex ) / (assert((edge)->vtx[0] == (vertex) || (edge)->vtx[1] == (vertex)), / (edge)->next[(edge)->vtx[1] == (vertex)])

保持数据结构的连续性的说明

//文件存储的“黑箱”定义 typedef struct CvFileStorage CvFileStorage; //存储标记 #define CV_STORAGE_READ 0 #define CV_STORAGE_WRITE 1 #define CV_STORAGE_WRITE_TEXT CV_STORAGE_WRITE #define CV_STORAGE_WRITE_BINARY CV_STORAGE_WRITE #define CV_STORAGE_APPEND 2 //属性列表 typedef struct CvAttrList { const char** attr; /* NULL-terminated array of (attribute_name,attribute_value) pairs. */ struct CvAttrList* next; /* Pointer to next chunk of the attributes list. */ } CvAttrList; CV_INLINE CvAttrList cvAttrList( const char** attr CV_DEFAULT(NULL), CvAttrList* next CV_DEFAULT(NULL) ) { CvAttrList l; l.attr = attr; l.next = next; return l; } struct CvTypeInfo; #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_TYPE(flags) ((flags) & CV_NODE_TYPE_MASK) /* file node flags */ #define CV_NODE_FLOW 8 /* Used only for writing structures in YAML format. */ #define CV_NODE_USER 16 #define CV_NODE_EMPTY 32 #define CV_NODE_NAMED 64 #define CV_NODE_IS_INT(flags) (CV_NODE_TYPE(flags) == CV_NODE_INT) #define CV_NODE_IS_REAL(flags) (CV_NODE_TYPE(flags) == CV_NODE_REAL) #define CV_NODE_IS_STRING(flags) (CV_NODE_TYPE(flags) == CV_NODE_STRING) #define CV_NODE_IS_SEQ(flags) (CV_NODE_TYPE(flags) == CV_NODE_SEQ) #define CV_NODE_IS_MAP(flags) (CV_NODE_TYPE(flags) == CV_NODE_MAP) #define CV_NODE_IS_COLLECTION(flags) (CV_NODE_TYPE(flags) >= CV_NODE_SEQ) #define CV_NODE_IS_FLOW(flags) (((flags) & CV_NODE_FLOW) != 0) #define CV_NODE_IS_EMPTY(flags) (((flags) & CV_NODE_EMPTY) != 0) #define CV_NODE_IS_USER(flags) (((flags) & CV_NODE_USER) != 0) #define CV_NODE_HAS_NAME(flags) (((flags) & 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; //所有的元素名字以哈希表中，增加搜索速度 typedef struct CvStringHashNode{ unsigned hashval; CvString str; struct CvStringHashNode* next; } CvStringHashNode; typedef struct CvGenericHash CvFileNodeHash; /* Basic element of the file storage - scalar or collection: */ typedef struct CvFileNode { int tag; struct CvTypeInfo* info; /* type information (only for user-defined object, for others it is 0) */ union { double f; /* scalar floating-point number */ int i; /* scalar integer number */ CvString str; /* text string */ CvSeq* seq; /* sequence (ordered collection of file nodes) */ CvFileNodeHash* map; /* map (collection of named file nodes) */ } data; } CvFileNode; #ifdef __cplusplus extern "C" { #endif 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 ); #ifdef __cplusplus } #endif typedef struct CvTypeInfo { int flags; int header_size; struct CvTypeInfo* prev; struct CvTypeInfo* next; const char* type_name; CvIsInstanceFunc is_instance; CvReleaseFunc release; CvReadFunc read; CvWriteFunc write; CvCloneFunc clone; } CvTypeInfo;

系统数据类型

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;