#define CV_IS_SET(set) \    ((set) != NULL && (((CvSeq*)(set))->flags & CV_MAGIC_MASK) == CV_SET_MAGIC_VAL)#define CV_SEQ_ELTYPE_BITS           9#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        3#define CV_SEQ_KIND_MASK        (((1 << CV_SEQ_KIND_BITS) - 1)<<CV_SEQ_ELTYPE_BITS)/* types of sequences */#define CV_SEQ_KIND_GENERIC     (0 << CV_SEQ_ELTYPE_BITS)#define CV_SEQ_KIND_CURVE       (1 << CV_SEQ_ELTYPE_BITS)#define CV_SEQ_KIND_BIN_TREE    (2 << CV_SEQ_ELTYPE_BITS)/* types of sparse sequences (sets) */#define CV_SEQ_KIND_GRAPH       (3 << CV_SEQ_ELTYPE_BITS)#define CV_SEQ_KIND_SUBDIV2D    (4 << CV_SEQ_ELTYPE_BITS)#define CV_SEQ_FLAG_SHIFT       (CV_SEQ_KIND_BITS + CV_SEQ_ELTYPE_BITS)/* flags for curves */#define CV_SEQ_FLAG_CLOSED     (1 << CV_SEQ_FLAG_SHIFT)#define CV_SEQ_FLAG_SIMPLE     (2 << CV_SEQ_FLAG_SHIFT)#define CV_SEQ_FLAG_CONVEX     (4 << CV_SEQ_FLAG_SHIFT)#define CV_SEQ_FLAG_HOLE       (8 << CV_SEQ_FLAG_SHIFT)/* flags for graphs */#define CV_GRAPH_FLAG_ORIENTED (1 << CV_SEQ_FLAG_SHIFT)#define CV_GRAPH               CV_SEQ_KIND_GRAPH#define CV_ORIENTED_GRAPH      (CV_SEQ_KIND_GRAPH|CV_GRAPH_FLAG_ORIENTED)/* point sets */#define CV_SEQ_POINT_SET       (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT)#define CV_SEQ_POINT3D_SET     (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT3D)#define CV_SEQ_POLYLINE        (CV_SEQ_KIND_CURVE  | CV_SEQ_ELTYPE_POINT)#define CV_SEQ_POLYGON         (CV_SEQ_FLAG_CLOSED | CV_SEQ_POLYLINE )#define CV_SEQ_CONTOUR         CV_SEQ_POLYGON#define CV_SEQ_SIMPLE_POLYGON  (CV_SEQ_FLAG_SIMPLE | CV_SEQ_POLYGON  )/* chain-coded curves */#define CV_SEQ_CHAIN           (CV_SEQ_KIND_CURVE  | CV_SEQ_ELTYPE_CODE)#define CV_SEQ_CHAIN_CONTOUR   (CV_SEQ_FLAG_CLOSED | CV_SEQ_CHAIN)/* binary tree for the contour */#define CV_SEQ_POLYGON_TREE    (CV_SEQ_KIND_BIN_TREE  | CV_SEQ_ELTYPE_TRIAN_ATR)/* sequence of the connected components */#define CV_SEQ_CONNECTED_COMP  (CV_SEQ_KIND_GENERIC  | CV_SEQ_ELTYPE_CONNECTED_COMP)/* sequence of the integer numbers */#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 )/* flag checking */#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 )     (((seq)->flags & CV_SEQ_FLAG_CONVEX) != 0)#define CV_IS_SEQ_HOLE( seq )       (((seq)->flags & CV_SEQ_FLAG_HOLE) != 0)#define CV_IS_SEQ_SIMPLE( seq )     ((((seq)->flags & CV_SEQ_FLAG_SIMPLE) != 0) || \                                    CV_IS_SEQ_CONVEX(seq))/* type checking macros */#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)/****************************************************************************************//*                            Sequence writer & reader                                  *//****************************************************************************************/#define CV_SEQ_WRITER_FIELDS()                                     \    int          header_size;                                      \    CvSeq*       seq;        /* the sequence written */            \    CvSeqBlock*  block;      /* current block */                   \    char*        ptr;        /* pointer to free space */           \    char*        block_min;  /* pointer to the beginning of block*/\    char*        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 */                    \    char*        ptr;        /* pointer to element be read next */  \    char*        block_min;  /* pointer to the beginning of block */\    char*        block_max;  /* pointer to the end of block */      \    int          delta_index;/* = seq->first->start_index   */      \    char*        prev_elem;  /* pointer to previous element */typedef struct CvSeqReader{    CV_SEQ_READER_FIELDS()}CvSeqReader;/****************************************************************************************//*                                Operations on sequences                               *//****************************************************************************************/#define  CV_SEQ_ELEM( seq, elem_type, index )                    \/* assert gives some guarantee that <seq> 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) )/* macro that adds element to sequence */#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);                     \}/* move reader position forward */#define CV_NEXT_SEQ_ELEM( elem_size, reader )                 \{                                                             \    if( ((reader).ptr += (elem_size)) >= (reader).block_max ) \    {                                                         \        cvChangeSeqBlock( &(reader), 1 );                     \    }                                                         \}/* move reader position backward */#define CV_PREV_SEQ_ELEM( elem_size, reader )                \{                                                            \    if( ((reader).ptr -= (elem_size)) < (reader).block_min ) \    {                                                        \        cvChangeSeqBlock( &(reader), -1 );                   \    }                                                        \}/* read element and move read position forward */#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 )                   \}/* read element and move read position backward */#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));      \}/************ Graph macros ************//* returns next graph edge for given vertex */#define  CV_NEXT_GRAPH_EDGE( edge, vertex )                              \     (assert((edge)->vtx[0] == (vertex) || (edge)->vtx[1] == (vertex)),  \      (edge)->next[(edge)->vtx[1] == (vertex)])/****************************************************************************************\*             Data structures for persistence (a.k.a serialization) functionality        *\****************************************************************************************//* "black box" file storage */typedef struct CvFileStorage CvFileStorage;/* storage flags */#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/* list of attributes */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 to 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;/* all the keys (names) of elements in the readed file storage   are stored in the hash to speed up the lookup operations */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 __cplusplusextern "C" {#endiftypedef 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}#endiftypedef 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;/**** System data types ******/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;#endif /*_CXCORE_TYPES_H_*//* End of file. */