modules\core\include\opencv2\core\types_c.h
前面的是一些宏定义,是为了兼容C,C++。对于一些函数的调用方式,建议补充一点补充知识:http://blog.youkuaiyun.com/yongdun_007/archive/2010/12/21/6090281.aspx,这个头文件是很重要的一个文件,建议大家都看看,这里定义了opencv用到的所有的数据类型和结构。详细如下:
types_c.h包括:常用的宏指令和内联函数,随机数的生成,图像数据类型,矩阵数据类型,多维稠密矩阵,多维稀疏矩阵,稀疏矩阵迭代,直方图,其他数据类型定义(包括矩形,终止准则,点和变量,size变量和Box变量,片和部分,尺度或者角度),动态数据结构(包括内存存储,序列,节点或者集,图结构,链和轮廓),序列类型,序列的读/写操作,对序列的操作(包括图的微操作),保持数据结构的稳定性,系统数据类型。
常用的宏指令和内联函数:
#define CV_PI 3.1415926535897932384626433832795//定义PI大小
#define CV_LOG20.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
#define CV_IMIN(a, b) ((a)^ (((a)^(b)) & (((a) < (b)) - 1)))//
#define CV_IMAX(a, b) ((a)^ (((a)^(b)) & (((a) > (b)) - 1)))//
#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 seedCV_DEFAULT(-1))
//返回32位无符号整型并更新RNG
CV_INLINE unsigned cvRandInt( CvRNG* rng )
//返回浮点型随机数并更新RNG
CV_INLINE double cvRandReal( CvRNG* rng )
图像数据类型
#ifndef HAVE_IPL
//定义深度位数
#define IPL_DEPTH_SIGN 0x80000000
#defineIPL_DEPTH_1U 1
#defineIPL_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//双扫描线
#defineIPL_BORDER_REFLECT 2 //带阴影扫描线
#defineIPL_BORDER_WRAP 3 //波浪扫描线
//定义图像结构体
typedef struct _IplImage
{
int nSize;
int ID;
int nChannels;
int alphaChannel;
int depth;
charcolorModel[4];
charchannelSeq[4];
int dataOrder;
int origin;
int align;
int width;
int height;
struct _IplROI*roi;
struct _IplImage*maskROI;
void *imageId;
struct _IplTileInfo*tileInfo;
int imageSize;
char *imageData;
int widthStep;
int BorderMode[4];
int BorderConst[4];
char*imageDataOrigin;
}
IplImage;
//定义图像分块信息结构体
typedef struct _IplTileInfo IplTileInfo;
//定义图像感兴趣区域
typedef struct _IplROI
{
int coi;//感兴趣通道
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
//定义边界模式
#defineIPL_BORDER_REFLECT_101 4 //带有阴影
#defineIPL_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
//
#defineCV_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 )
//
#defineCV_MAT_CN_MASK ((CV_CN_MAX- 1) << CV_CN_SHIFT)
#defineCV_MAT_CN(flags) ((((flags)& CV_MAT_CN_MASK) >> CV_CN_SHIFT) + 1)
#defineCV_MAT_TYPE_MASK (CV_DEPTH_MAX*CV_CN_MAX- 1)
#defineCV_MAT_TYPE(flags) ((flags) &CV_MAT_TYPE_MASK)
#define CV_MAT_CONT_FLAG_SHIFT 14
#defineCV_MAT_CONT_FLAG (1 <<CV_MAT_CONT_FLAG_SHIFT)
#define CV_IS_MAT_CONT(flags) ((flags)& CV_MAT_CONT_FLAG)
#defineCV_IS_CONT_MAT CV_IS_MAT_CONT
#defineCV_SUBMAT_FLAG_SHIFT 15
#defineCV_SUBMAT_FLAG (1<< CV_SUBMAT_FLAG_SHIFT)
#defineCV_IS_SUBMAT(flags) ((flags) & CV_MAT_SUBMAT_FLAG)
//
#defineCV_MAGIC_MASK 0xFFFF0000
#define CV_MAT_MAGIC_VAL 0x42420000
#define CV_TYPE_NAME_MAT "opencv-matrix"
//定义矩阵结构体
typedef struct CvMat
{
int type;
int step;
int* refcount;
int hdr_refcount;
union
{
uchar*ptr;
short*s;
int*i;
float*fl;
double*db;
} data;
#ifdef __cplusplus
union
{
introws;
intheight;
};
union
{
intcols;
intwidth;
};
#else
int rows;
int cols;
#endif
}
CvMat;
//判断矩阵头指针
#define CV_IS_MAT_HDR(mat) \
((mat) != NULL&& \
(((constCvMat*)(mat))->type & CV_MAGIC_MASK) == CV_MAT_MAGIC_VAL && \
((constCvMat*)(mat))->cols > 0 && ((const CvMat*)(mat))->rows > 0)
//
#define CV_IS_MAT_HDR_Z(mat) \
((mat) != NULL&& \
(((constCvMat*)(mat))->type & CV_MAGIC_MASK) == CV_MAT_MAGIC_VAL && \
((constCvMat*)(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)
//
#define CV_ELEM_SIZE1(type) \
((((sizeof(size_t)<<28)|0x8442211)>> CV_MAT_DEPTH(type)*4) & 15)
//
#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)
//初始化矩阵
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 )
多维稠密矩阵
//
#defineCV_MATND_MAGIC_VAL 0x42430000
#defineCV_TYPE_NAME_MATND "opencv-nd-matrix"
//
#defineCV_MAX_DIM 32
#defineCV_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
{
intsize;
intstep;
}
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)
多维稀疏矩阵
//
#defineCV_SPARSE_MAT_MAGIC_VAL 0x42440000
#defineCV_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;
intsize[CV_MAX_DIM];
}
CvSparseMat;
//
#define CV_IS_SPARSE_MAT_HDR(mat) \
((mat) != NULL&& \
(((constCvSparseMat*)(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;
structCvSparseNode* 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;
//
#defineCV_HIST_MAGIC_VAL 0x42450000
#define CV_HIST_UNIFORM_FLAG (1<< 10)
//维区域是否设置的标签
#define CV_HIST_RANGES_FLAG (1<< 11)
//定义矩阵状态
#defineCV_HIST_ARRAY 0 //数组直方图
#defineCV_HIST_SPARSE 1 //稀疏直方图
#defineCV_HIST_TREE CV_HIST_SPARSE//树形直方图
#defineCV_HIST_UNIFORM 1
//定义直方图结构体
typedef struct CvHistogram
{
int type;
CvArr* bins;
float thresh[CV_MAX_DIM][2];
float**thresh2;
CvMatND mat;
}
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
#defineCV_TERMCRIT_EPS 2
//定义迭代算法的终止准则结构体
typedef struct CvTermCriteria
{
int type;
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 )
{
returncvPoint2D32f( (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
{
CvPoint2D32fcenter;
CvSize2D32f size;
floatangle;
}
CvBox2D;
//定义线性迭代状态
typedef struct CvLineIterator
{
uchar* ptr;
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),
doubleval2 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
{
structCvMemBlock* prev;
structCvMemBlock* next;
}
CvMemBlock;
#defineCV_STORAGE_MAGIC_VAL 0x42890000
typedef struct CvMemStorage
{
int signature;
CvMemBlock*bottom;
CvMemBlock*top;
struct CvMemStorage*parent;
intblock_size;
intfree_space;
}
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
{
structCvSeqBlock* prev;
structCvSeqBlock* next;
int start_index;
int count;
schar*data;
}
CvSeqBlock;
//定义序列节点
#defineCV_TREE_NODE_FIELDS(node_type) \
int flags; \
int header_size; \
struct node_type*h_prev; \
struct node_type*h_next; \
struct node_type*v_prev; \
struct node_type*v_next
//读和写序列(动态的添加和删除元素) #defineCV_SEQUENCE_FIELDS() \
CV_TREE_NODE_FIELDS(CvSeq); \
int total; \
int elem_size; \
schar* block_max; \
schar* ptr; \
int delta_elems; \
CvMemStorage*storage; \
CvSeqBlock*free_blocks; \
CvSeqBlock*first;
//定义序列结构体
typedef struct CvSeq
{
CV_SEQUENCE_FIELDS()
}
CvSeq;
#defineCV_TYPE_NAME_SEQ "opencv-sequence"
#defineCV_TYPE_NAME_SEQ_TREE "opencv-sequence-tree"
动态数据结构-节点(集)
(节点顺序是不被保护的,他们可看成介于元素间的空隙,但被插入后就保留在该地方,判断有元素,看MSB‘mose-significant or sign bit’的标志位)
//定义序列节点属性
#defineCV_SET_ELEM_FIELDS(elem_type) \
int flags; \
struct elem_type*next_free;
//设置序列元素
typedef struct CvSetElem
{
CV_SET_ELEM_FIELDS(CvSetElem)
}
CvSetElem;
//
#defineCV_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)
动态数据结构-图结构
//定义图边属性
#defineCV_GRAPH_EDGE_FIELDS() \
intflags; \
floatweight; \
struct CvGraphEdge*next[2]; \
struct CvGraphVtx*vtx[2];
//定义图节点属性
#defineCV_GRAPH_VERTEX_FIELDS() \
intflags; \
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() \
CvRectrect; \
intcolor; \
int reserved[3];
//定义轮廓结构体
typedef struct CvContour
{
CV_CONTOUR_FIELDS()
}
CvContour;
typedef CvContour CvPoint2DSeq;
序列类型
//表示稠密序列
#defineCV_SEQ_MAGIC_VAL 0x42990000
#define CV_IS_SEQ(seq) \
((seq) != NULL&& (((CvSeq*)(seq))->flags & CV_MAGIC_MASK) == CV_SEQ_MAGIC_VAL)
//表示稀疏序列
#defineCV_SET_MAGIC_VAL 0x42980000
#define CV_IS_SET(set) \
((set) != NULL&& (((CvSeq*)(set))->flags & CV_MAGIC_MASK) == CV_SET_MAGIC_VAL)
//表示稠密序列元素位数
#defineCV_SEQ_ELTYPE_BITS 12
#defineCV_SEQ_ELTYPE_MASK ((1<< CV_SEQ_ELTYPE_BITS) - 1)
//
#defineCV_SEQ_ELTYPE_POINT CV_32SC2
#defineCV_SEQ_ELTYPE_CODE CV_8UC1
//
#defineCV_SEQ_ELTYPE_GENERIC 0
#defineCV_SEQ_ELTYPE_PTR CV_USRTYPE1
#defineCV_SEQ_ELTYPE_PPOINT CV_SEQ_ELTYPE_PTR
#defineCV_SEQ_ELTYPE_INDEX CV_32SC1
#defineCV_SEQ_ELTYPE_GRAPH_EDGE 0
#defineCV_SEQ_ELTYPE_GRAPH_VERTEX 0
#defineCV_SEQ_ELTYPE_TRIAN_ATR 0
#define CV_SEQ_ELTYPE_CONNECTED_COMP0
#defineCV_SEQ_ELTYPE_POINT3D CV_32FC3
//表示稠密序列类型位数
#defineCV_SEQ_KIND_BITS 2
#defineCV_SEQ_KIND_MASK (((1 <<CV_SEQ_KIND_BITS) - 1)<<CV_SEQ_ELTYPE_BITS)
//稠密序列的三种类型
#defineCV_SEQ_KIND_GENERIC (0 <<CV_SEQ_ELTYPE_BITS)
#defineCV_SEQ_KIND_CURVE (1 <<CV_SEQ_ELTYPE_BITS)
#defineCV_SEQ_KIND_BIN_TREE (2 << CV_SEQ_ELTYPE_BITS)
//稀疏序列的三种类型
#defineCV_SEQ_KIND_GRAPH (1 <<CV_SEQ_ELTYPE_BITS)
#defineCV_SEQ_KIND_SUBDIV2D (2 << CV_SEQ_ELTYPE_BITS)
#defineCV_SEQ_FLAG_SHIFT (CV_SEQ_KIND_BITS +CV_SEQ_ELTYPE_BITS)
//曲线序列的类型标志
#define CV_SEQ_FLAG_CLOSED (1<< CV_SEQ_FLAG_SHIFT)
#defineCV_SEQ_FLAG_SIMPLE (0 << CV_SEQ_FLAG_SHIFT)
#defineCV_SEQ_FLAG_CONVEX (0 << CV_SEQ_FLAG_SHIFT)
#defineCV_SEQ_FLAG_HOLE (2 <<CV_SEQ_FLAG_SHIFT)
//图序列的类型标志
#define CV_GRAPH_FLAG_ORIENTED (1 << CV_SEQ_FLAG_SHIFT)
#defineCV_GRAPH CV_SEQ_KIND_GRAPH
#defineCV_ORIENTED_GRAPH (CV_SEQ_KIND_GRAPH|CV_GRAPH_FLAG_ORIENTED)
//定义点集
#defineCV_SEQ_POINT_SET (CV_SEQ_KIND_GENERIC|CV_SEQ_ELTYPE_POINT)
#defineCV_SEQ_POINT3D_SET (CV_SEQ_KIND_GENERIC|CV_SEQ_ELTYPE_POINT3D)
#defineCV_SEQ_POLYLINE (CV_SEQ_KIND_CURVE |CV_SEQ_ELTYPE_POINT)
#defineCV_SEQ_POLYGON (CV_SEQ_FLAG_CLOSED| CV_SEQ_POLYLINE )
#defineCV_SEQ_CONTOUR CV_SEQ_POLYGON
#define CV_SEQ_SIMPLE_POLYGON (CV_SEQ_FLAG_SIMPLE| CV_SEQ_POLYGON )
//定义曲线链表
#defineCV_SEQ_CHAIN (CV_SEQ_KIND_CURVE |CV_SEQ_ELTYPE_CODE)
#define CV_SEQ_CHAIN_CONTOUR (CV_SEQ_FLAG_CLOSED| CV_SEQ_CHAIN)
//用二叉树表示轮廓集
#defineCV_SEQ_POLYGON_TREE (CV_SEQ_KIND_BIN_TREE |CV_SEQ_ELTYPE_TRIAN_ATR)
//连接部分的序列表示
#define CV_SEQ_CONNECTED_COMP (CV_SEQ_KIND_GENERIC |CV_SEQ_ELTYPE_CONNECTED_COMP)
//整数表示的序列
#define CV_SEQ_INDEX (CV_SEQ_KIND_GENERIC |CV_SEQ_ELTYPE_INDEX)
#define CV_SEQ_ELTYPE( seq ) ((seq)->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)
序列的读/写操作
//定义序列写的属性
#defineCV_SEQ_WRITER_FIELDS() \
int header_size; \
CvSeq* seq; \
CvSeqBlock* block; \
schar* ptr; \
schar* block_min; \
schar* block_max;
//定义序列写结构体
typedef struct CvSeqWriter
{
CV_SEQ_WRITER_FIELDS()
}
CvSeqWriter;
//定义序列读的属性
#defineCV_SEQ_READER_FIELDS() \
int header_size; \
CvSeq* seq; \
CvSeqBlock* block; \
schar* ptr; \
schar* block_min; \
schar* block_max; \
int delta_index; \
schar* prev_elem;
//定义序列读的结构体
typedef struct CvSeqReader
{
CV_SEQ_READER_FIELDS()
}
CvSeqReader;
对序列的操作
#define CV_SEQ_ELEM( seq,elem_type, index) \
\
( 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;
//存储标记
#defineCV_STORAGE_READ 0
#defineCV_STORAGE_WRITE 1
#defineCV_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;
struct CvAttrList*next;
}
CvAttrList;
CV_INLINE CvAttrList cvAttrList( constchar** attr CV_DEFAULT(NULL),
CvAttrList*next CV_DEFAULT(NULL) )
{
CvAttrList l;
l.attr = attr;
l.next = next;
return l;
}
struct CvTypeInfo;
#defineCV_NODE_NONE 0
#defineCV_NODE_INT 1
#defineCV_NODE_INTEGER CV_NODE_INT
#define CV_NODE_REAL 2
#defineCV_NODE_FLOAT CV_NODE_REAL
#defineCV_NODE_STR 3
#defineCV_NODE_STRING CV_NODE_STR
#defineCV_NODE_REF 4
#defineCV_NODE_SEQ 5
#defineCV_NODE_MAP 6
#define CV_NODE_TYPE_MASK 7
#define CV_NODE_TYPE(flags) ((flags)& CV_NODE_TYPE_MASK)
#defineCV_NODE_FLOW 8
#defineCV_NODE_USER 16
#defineCV_NODE_EMPTY 32
#defineCV_NODE_NAMED 64
#defineCV_NODE_IS_INT(flags) (CV_NODE_TYPE(flags)== CV_NODE_INT)
#defineCV_NODE_IS_REAL(flags) (CV_NODE_TYPE(flags)== CV_NODE_REAL)
#defineCV_NODE_IS_STRING(flags) (CV_NODE_TYPE(flags) ==CV_NODE_STRING)
#defineCV_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)
#defineCV_NODE_IS_FLOW(flags) (((flags) &CV_NODE_FLOW) != 0)
#defineCV_NODE_IS_EMPTY(flags) (((flags) &CV_NODE_EMPTY) != 0)
#defineCV_NODE_IS_USER(flags) (((flags) &CV_NODE_USER) != 0)
#defineCV_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;
structCvStringHashNode* next;
}
CvStringHashNode;
typedef struct CvGenericHashCvFileNodeHash;
typedef struct CvFileNode
{
int tag;
struct CvTypeInfo*info;
union
{
doublef;
inti;
CvStringstr;
CvSeq*seq;
CvFileNodeHash*map;
} 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,
constvoid* 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;
CvIsInstanceFuncis_instance;
CvReleaseFuncrelease;
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
{
structCvModuleInfo* next;
const char* name;
const char*version;
CvPluginFuncInfo*func_tab;
}
CvModuleInfo;