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

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;