#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>
#include <math.h>

Classes
union	Cv32suf

union	Cv64suf

struct	_IplImage

struct	_IplROI

struct	_IplConvKernel

struct	_IplConvKernelFP

struct	CvMat

struct	CvMatND

struct	CvSparseMat

struct	CvSparseNode

struct	CvSparseMatIterator

struct	CvHistogram

struct	CvRect

struct	CvTermCriteria

struct	CvPoint

struct	CvPoint2D32f

struct	CvPoint3D32f

struct	CvPoint2D64f

struct	CvPoint3D64f

struct	CvSize

struct	CvSize2D32f

struct	CvBox2D

struct	CvLineIterator

struct	CvSlice

struct	CvScalar

struct	CvMemBlock

struct	CvMemStorage

struct	CvMemStoragePos

struct	CvSeqBlock

struct	CvSeq

struct	CvSetElem

struct	CvSet

struct	CvGraphEdge

struct	CvGraphVtx

struct	CvGraphVtx2D

struct	CvGraph

struct	CvChain

struct	CvContour

struct	CvSeqWriter

struct	CvSeqReader

struct	CvAttrList

struct	CvString

struct	CvStringHashNode

struct	CvFileNode

struct	CvTypeInfo

struct	CvPluginFuncInfo

struct	CvModuleInfo

Macros
#define	CV_SSE2 0

#define	CV_CDECL

#define	CV_STDCALL

#define	CV_EXTERN_C

#define	CV_DEFAULT(val)

#define	CV_EXTERN_C_FUNCPTR(x) typedef x

#define	CV_INLINE static

#define	CV_EXPORTS

#define	CVAPI(rettype) CV_EXTERN_C CV_EXPORTS rettype CV_CDECL

#define	CV_PI 3.1415926535897932384626433832795

#define	CV_LOG2 0.69314718055994530941723212145818

#define	CV_SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t))

#define	MIN(a, b) ((a) > (b) ? (b) : (a))

#define	MAX(a, b) ((a) < (b) ? (b) : (a))

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

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

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

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

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

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

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

#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

#define	IPL_IMAGE_HEADER 1

#define	IPL_IMAGE_DATA 2

#define	IPL_IMAGE_ROI 4

#define	IPL_BORDER_REFLECT_101 4

#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

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

#define	CV_CN_MAX 64

#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_MAKETYPE(depth, cn) ((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_DEPTH_MASK (CV_DEPTH_MAX - 1)

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

#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_MAT_TEMP_FLAG_SHIFT 15

#define	CV_MAT_TEMP_FLAG (1 << CV_MAT_TEMP_FLAG_SHIFT)

#define	CV_IS_TEMP_MAT(flags) ((flags) & CV_MAT_TEMP_FLAG)

#define	CV_MAGIC_MASK 0xFFFF0000

#define	CV_MAT_MAGIC_VAL 0x42420000

#define	CV_TYPE_NAME_MAT "opencv-matrix"

#define	CV_IS_MAT_HDR(mat)

#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	CV_MAT_ELEM_PTR_FAST(mat, row, col, pix_size)

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

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

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

#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"

#define	CV_IS_SPARSE_MAT_HDR(mat)

#define	CV_IS_SPARSE_MAT(mat) CV_IS_SPARSE_MAT_HDR(mat)

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

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

#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

#define	CV_HIST_UNIFORM 1

#define	CV_IS_HIST(hist)

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

#define	CV_TERMCRIT_ITER 1

#define	CV_TERMCRIT_NUMBER CV_TERMCRIT_ITER

#define	CV_TERMCRIT_EPS 2

#define	CV_WHOLE_SEQ_END_INDEX 0x3fffffff

#define	CV_WHOLE_SEQ cvSlice(0, CV_WHOLE_SEQ_END_INDEX)

#define	CV_STORAGE_MAGIC_VAL 0x42890000

#define	CV_IS_STORAGE(storage)

#define	CV_TREE_NODE_FIELDS(node_type)

#define	CV_SEQUENCE_FIELDS()

#define	CV_TYPE_NAME_SEQ "opencv-sequence"

#define	CV_TYPE_NAME_SEQ_TREE "opencv-sequence-tree"

#define	CV_SET_ELEM_FIELDS(elem_type)

#define	CV_SET_FIELDS()

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

#define	CV_GRAPH_EDGE_FIELDS()

#define	CV_GRAPH_VERTEX_FIELDS()

#define	CV_GRAPH_FIELDS()

#define	CV_TYPE_NAME_GRAPH "opencv-graph"

#define	CV_CONTOUR_FIELDS()

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

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

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

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

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

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

#define	CV_SEQ_CHAIN (CV_SEQ_KIND_CURVE \| CV_SEQ_ELTYPE_CODE)

#define	CV_SEQ_CHAIN_CONTOUR (CV_SEQ_FLAG_CLOSED \| CV_SEQ_CHAIN)

#define	CV_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)

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

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

#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()

#define	CV_SEQ_READER_FIELDS()

#define	CV_SEQ_ELEM(seq, elem_type, 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)

#define	CV_WRITE_SEQ_ELEM(elem, writer)

#define	CV_NEXT_SEQ_ELEM(elem_size, reader)

#define	CV_PREV_SEQ_ELEM(elem_size, reader)

#define	CV_READ_SEQ_ELEM(elem, reader)

#define	CV_REV_READ_SEQ_ELEM(elem, reader)

#define	CV_READ_CHAIN_POINT(_pt, reader)

#define	CV_CURRENT_POINT(reader) (((CvPoint)((reader).ptr)))

#define	CV_PREV_POINT(reader) (((CvPoint)((reader).prev_elem)))

#define	CV_READ_EDGE(pt1, pt2, reader)

#define	CV_NEXT_GRAPH_EDGE(edge, vertex)

#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

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

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

Typedefs
typedef long long	int64

typedef unsigned long long	uint64

typedef unsigned char	uchar

typedef unsigned short	ushort

typedef signed char	schar

typedef void	CvArr

typedef union Cv32suf	Cv32suf

typedef union Cv64suf	Cv64suf

typedef uint64	CvRNG

typedef struct _IplImage	IplImage

typedef struct _IplTileInfo	IplTileInfo

typedef struct _IplROI	IplROI

typedef struct _IplConvKernel	IplConvKernel

typedef struct _IplConvKernelFP	IplConvKernelFP

typedef struct CvMat	CvMat

typedef struct CvMatND	CvMatND

typedef struct CvSparseMat	CvSparseMat

typedef struct CvSparseNode	CvSparseNode

typedef struct CvSparseMatIterator	CvSparseMatIterator

typedef int	CvHistType

typedef struct CvHistogram	CvHistogram

typedef struct CvRect	CvRect

typedef struct CvTermCriteria	CvTermCriteria

typedef struct CvPoint	CvPoint

typedef struct CvPoint2D32f	CvPoint2D32f

typedef struct CvPoint3D32f	CvPoint3D32f

typedef struct CvPoint2D64f	CvPoint2D64f

typedef struct CvPoint3D64f	CvPoint3D64f

typedef struct CvSize2D32f	CvSize2D32f

typedef struct CvBox2D	CvBox2D

typedef struct CvLineIterator	CvLineIterator

typedef struct CvSlice	CvSlice

typedef struct CvScalar	CvScalar

typedef struct CvMemBlock	CvMemBlock

typedef struct CvMemStorage	CvMemStorage

typedef struct CvMemStoragePos	CvMemStoragePos

typedef struct CvSeqBlock	CvSeqBlock

typedef struct CvSeq	CvSeq

typedef struct CvSetElem	CvSetElem

typedef struct CvSet	CvSet

typedef struct CvGraphEdge	CvGraphEdge

typedef struct CvGraphVtx	CvGraphVtx

typedef struct CvGraphVtx2D	CvGraphVtx2D

typedef struct CvGraph	CvGraph

typedef struct CvChain	CvChain

typedef struct CvContour	CvContour

typedef CvContour	CvPoint2DSeq

typedef struct CvSeqWriter	CvSeqWriter

typedef struct CvSeqReader	CvSeqReader

typedef struct CvFileStorage	CvFileStorage

typedef struct CvAttrList	CvAttrList

typedef struct CvString	CvString

typedef struct CvStringHashNode	CvStringHashNode

typedef struct CvGenericHash	CvFileNodeHash

typedef struct CvFileNode	CvFileNode

typedef int(CV_CDECL *	CvIsInstanceFunc )(const void *struct_ptr)

typedef void(CV_CDECL *	CvReleaseFunc )(void **struct_dblptr)

typedef void (CV_CDECL	CvReadFunc )(CvFileStorage storage, CvFileNode node)

typedef void(CV_CDECL *	CvWriteFunc )(CvFileStorage storage, const char name, const void *struct_ptr, CvAttrList attributes)

typedef void (CV_CDECL	CvCloneFunc )(const void *struct_ptr)

typedef struct CvTypeInfo	CvTypeInfo

typedef struct CvPluginFuncInfo	CvPluginFuncInfo

typedef struct CvModuleInfo	CvModuleInfo

Functions
CV_INLINE int	cvRound (double value)

CV_INLINE int	cvFloor (double value)

CV_INLINE int	cvCeil (double value)

CV_INLINE int	cvIsNaN (double value)

CV_INLINE int	cvIsInf (double value)

CV_INLINE CvRNG	cvRNG (int64 seed CV_DEFAULT(-1))

CV_INLINE unsigned	cvRandInt (CvRNG *rng)

CV_INLINE double	cvRandReal (CvRNG *rng)

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

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	cvCvToIplDepth (int type)

CV_INLINE CvRect	cvRect (int x, int y, int width, int height)

CV_INLINE IplROI	cvRectToROI (CvRect rect, int coi)

CV_INLINE CvRect	cvROIToRect (IplROI roi)

CV_INLINE CvTermCriteria	cvTermCriteria (int type, int max_iter, double epsilon)

CV_INLINE CvPoint	cvPoint (int x, int y)

CV_INLINE CvPoint2D32f	cvPoint2D32f (double x, double y)

CV_INLINE CvPoint2D32f	cvPointTo32f (CvPoint point)

CV_INLINE CvPoint	cvPointFrom32f (CvPoint2D32f point)

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

CV_INLINE CvPoint2D64f	cvPoint2D64f (double x, double y)

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

CV_INLINE CvSize	cvSize (int width, int height)

CV_INLINE CvSize2D32f	cvSize2D32f (double width, double height)

CV_INLINE CvSlice	cvSlice (int start, int end)

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

CV_INLINE CvScalar	cvRealScalar (double val0)

CV_INLINE CvScalar	cvScalarAll (double val0123)

CV_INLINE CvAttrList	cvAttrList (const char *attr CV_DEFAULT(NULL), CvAttrList next CV_DEFAULT(NULL))

Macro Definition Documentation

cvRound cvRound CV_16S 3

#define CV_16SC ( n ) CV_MAKETYPE(CV_16S,(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)

cvRound cvRound CV_16U 2

#define CV_16UC ( n ) CV_MAKETYPE(CV_16U,(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)

cvRound CV_32F 5

#define CV_32FC ( n ) CV_MAKETYPE(CV_32F,(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)

cvRound cvRound CV_32S 4

#define CV_32SC ( n ) CV_MAKETYPE(CV_32S,(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)

cvRound cvRound CV_64F 6

#define CV_64FC ( n ) CV_MAKETYPE(CV_64F,(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)

cvRound cvRound CV_8S 1

#define CV_8SC ( n ) CV_MAKETYPE(CV_8S,(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)

cvRound cvRound CV_8U 0

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

#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_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_ARE_TYPES_EQ	(	mat1,
		mat2
	)	((((mat1)->type ^ (mat2)->type) & CV_MAT_TYPE_MASK) == 0)

#define CV_AUTO_STEP 0x7fffffff

#define CV_CDECL

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

#define CV_CN_MAX 64

#define CV_CN_SHIFT 3

#define CV_CONTOUR_FIELDS ( )

Value:

CV_SEQUENCE_FIELDS()     \
    CvRect rect;             \
    int color;               \
    int reserved[3];

#define CV_CURRENT_POINT ( reader ) (*((CvPoint*)((reader).ptr)))

#define CV_DEFAULT ( val )

#define CV_DEPTH_MAX (1 << CV_CN_SHIFT)

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

#define CV_ELEM_SIZE1 ( type ) ((((sizeof(size_t)<<28)|0x8442211) >> CV_MAT_DEPTH(type)*4) & 15)

#define CV_EXPORTS

#define CV_EXTERN_C

#define CV_EXTERN_C_FUNCPTR ( x ) typedef x

#define CV_GET_SEQ_ELEM	(	elem_type,
		seq,
		index
	)	CV_SEQ_ELEM( (seq), elem_type, (index) )

#define CV_GRAPH CV_SEQ_KIND_GRAPH

#define CV_GRAPH_EDGE_FIELDS ( )

Value:

int flags;                      \
    float weight;                   \
    struct CvGraphEdge* next[2];    \
    struct CvGraphVtx* vtx[2];

#define CV_GRAPH_FIELDS ( )

Value:

CV_SET_FIELDS() \

CvSet* edges;

#define CV_GRAPH_FLAG_ORIENTED (1 << CV_SEQ_FLAG_SHIFT)

#define CV_GRAPH_VERTEX_FIELDS ( )

Value:

int flags; \

struct CvGraphEdge* first;

#define CV_HIST_ARRAY 0

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

#define CV_HIST_MAGIC_VAL 0x42450000

#define CV_HIST_RANGES_FLAG (1 << 11)

#define CV_HIST_SPARSE 1

#define CV_HIST_TREE CV_HIST_SPARSE

#define CV_HIST_UNIFORM 1

#define CV_HIST_UNIFORM_FLAG (1 << 10)

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

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

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

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

#define CV_INLINE static

#define CV_IS_CONT_MAT CV_IS_MAT_CONT

#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_HIST ( hist )

Value:

((hist) != NULL  && \
     (((CvHistogram*)(hist))->type & CV_MAGIC_MASK) == CV_HIST_MAGIC_VAL && \
     (hist)->bins != NULL)

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

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

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

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

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

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

#define CV_IS_MAT_HDR ( mat )

Value:

((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_MATND ( mat ) (CV_IS_MATND_HDR(mat) && ((const CvMatND*)(mat))->data.ptr != NULL)

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

#define CV_IS_SEQ ( seq ) ((seq) != NULL && (((CvSeq*)(seq))->flags & CV_MAGIC_MASK) == CV_SEQ_MAGIC_VAL)

#define CV_IS_SEQ_CHAIN ( seq ) (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && (seq)->elem_size == 1)

#define CV_IS_SEQ_CHAIN_CONTOUR ( seq ) (CV_IS_SEQ_CHAIN( seq ) && CV_IS_SEQ_CLOSED( seq ))

#define CV_IS_SEQ_CLOSED ( seq ) (((seq)->flags & CV_SEQ_FLAG_CLOSED) != 0)

#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_CONVEX ( seq ) (((seq)->flags & CV_SEQ_FLAG_CONVEX) != 0)

#define CV_IS_SEQ_CURVE ( seq ) (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE)

#define CV_IS_SEQ_HOLE ( seq ) (((seq)->flags & CV_SEQ_FLAG_HOLE) != 0)

#define CV_IS_SEQ_INDEX ( seq )

Value:

((CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_INDEX) && \

(CV_SEQ_KIND(seq) == CV_SEQ_KIND_GENERIC))

#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_POLYGON ( seq ) (CV_IS_SEQ_POLYLINE(seq) && CV_IS_SEQ_CLOSED(seq))

#define CV_IS_SEQ_POLYGON_TREE ( seq )

Value:

(CV_SEQ_ELTYPE (seq) == CV_SEQ_ELTYPE_TRIAN_ATR && \

CV_SEQ_KIND( seq ) == CV_SEQ_KIND_BIN_TREE )

#define CV_IS_SEQ_POLYLINE ( seq ) (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && CV_IS_SEQ_POINT_SET(seq))

#define CV_IS_SEQ_SIMPLE ( seq )

Value:

((((seq)->flags & CV_SEQ_FLAG_SIMPLE) != 0) || \

CV_IS_SEQ_CONVEX(seq))

#define CV_IS_SET ( set ) ((set) != NULL && (((CvSeq*)(set))->flags & CV_MAGIC_MASK) == CV_SET_MAGIC_VAL)

#define CV_IS_SET_ELEM ( ptr ) (((CvSetElem*)(ptr))->flags >= 0)

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

#define CV_IS_SPARSE_MAT ( mat ) CV_IS_SPARSE_MAT_HDR(mat)

#define CV_IS_SPARSE_MAT_HDR ( mat )

Value:

((mat) != NULL && \

(((const CvSparseMat*)(mat))->type & CV_MAGIC_MASK) == CV_SPARSE_MAT_MAGIC_VAL)

#define CV_IS_STORAGE ( storage )

Value:

((storage) != NULL && \

(((CvMemStorage*)(storage))->signature & CV_MAGIC_MASK) == CV_STORAGE_MAGIC_VAL)

#define CV_IS_SUBDIV2D ( seq ) (CV_IS_SET(seq) && CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_SUBDIV2D)

#define CV_IS_TEMP_MAT ( flags ) ((flags) & CV_MAT_TEMP_FLAG)

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

#define CV_LOG2 0.69314718055994530941723212145818

#define CV_MAGIC_MASK 0xFFFF0000

#define CV_MAKE_TYPE CV_MAKETYPE

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

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

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

#define CV_MAT_CONT_FLAG (1 << CV_MAT_CONT_FLAG_SHIFT)

#define CV_MAT_CONT_FLAG_SHIFT 14

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

#define CV_MAT_DEPTH_MASK (CV_DEPTH_MAX - 1)

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

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

#define CV_MAT_ELEM_PTR_FAST	(	mat,
		row,
		col,
		pix_size
	)

Value:

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

#define CV_MAT_MAGIC_VAL 0x42420000

#define CV_MAT_TEMP_FLAG (1 << CV_MAT_TEMP_FLAG_SHIFT)

#define CV_MAT_TEMP_FLAG_SHIFT 15

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

#define CV_MAT_TYPE_MASK (CV_DEPTH_MAX*CV_CN_MAX - 1)

#define CV_MATND_MAGIC_VAL 0x42430000

#define CV_MAX_DIM 32

#define CV_MAX_DIM_HEAP (1 << 16)

#define CV_NEXT_GRAPH_EDGE	(	edge,
		vertex
	)

Value:

(assert((edge)->vtx[0] == (vertex) || (edge)->vtx[1] == (vertex)), \

(edge)->next[(edge)->vtx[1] == (vertex)])

#define CV_NEXT_SEQ_ELEM	(	elem_size,
		reader
	)

Value:

{                                                             \
    if( ((reader).ptr += (elem_size)) >= (reader).block_max ) \
    {                                                         \
        cvChangeSeqBlock( &(reader), 1 );                     \
    }                                                         \
}

#define CV_NODE_EMPTY 32

#define CV_NODE_FLOAT CV_NODE_REAL

#define CV_NODE_FLOW 8 /* Used only for writing structures in YAML format. */

#define CV_NODE_HAS_NAME ( flags ) (((flags) & CV_NODE_NAMED) != 0)

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

#define CV_NODE_INT 1

#define CV_NODE_INTEGER CV_NODE_INT

#define CV_NODE_IS_COLLECTION ( flags ) (CV_NODE_TYPE(flags) >= CV_NODE_SEQ)

#define CV_NODE_IS_EMPTY ( flags ) (((flags) & CV_NODE_EMPTY) != 0)

#define CV_NODE_IS_FLOW ( flags ) (((flags) & CV_NODE_FLOW) != 0)

#define CV_NODE_IS_INT ( flags ) (CV_NODE_TYPE(flags) == CV_NODE_INT)

#define CV_NODE_IS_MAP ( flags ) (CV_NODE_TYPE(flags) == CV_NODE_MAP)

#define CV_NODE_IS_REAL ( flags ) (CV_NODE_TYPE(flags) == CV_NODE_REAL)

#define CV_NODE_IS_SEQ ( flags ) (CV_NODE_TYPE(flags) == CV_NODE_SEQ)

#define CV_NODE_IS_STRING ( flags ) (CV_NODE_TYPE(flags) == CV_NODE_STRING)

#define CV_NODE_IS_USER ( flags ) (((flags) & CV_NODE_USER) != 0)

#define CV_NODE_MAP 6

#define CV_NODE_NAMED 64

#define CV_NODE_NONE 0

#define CV_NODE_REAL 2

#define CV_NODE_REF 4 /* not used */

#define CV_NODE_SEQ 5

#define CV_NODE_SEQ_IS_SIMPLE ( seq ) (((seq)->flags & CV_NODE_SEQ_SIMPLE) != 0)

#define CV_NODE_SEQ_SIMPLE 256

#define CV_NODE_STR 3

#define CV_NODE_STRING CV_NODE_STR

#define CV_NODE_TYPE ( flags ) ((flags) & CV_NODE_TYPE_MASK)

#define CV_NODE_TYPE_MASK 7

#define CV_NODE_USER 16

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

#define CV_ORIENTED_GRAPH (CV_SEQ_KIND_GRAPH|CV_GRAPH_FLAG_ORIENTED)

#define CV_PI 3.1415926535897932384626433832795

#define CV_PREV_POINT ( reader ) (*((CvPoint*)((reader).prev_elem)))

#define CV_PREV_SEQ_ELEM	(	elem_size,
		reader
	)

Value:

{                                                            \
    if( ((reader).ptr -= (elem_size)) < (reader).block_min ) \
    {                                                        \
        cvChangeSeqBlock( &(reader), -1 );                   \
    }                                                        \
}

#define CV_READ_CHAIN_POINT	(	_pt,
		reader
	)

Value:

{                                                                       \
    (_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_READ_EDGE	(	pt1,
		pt2,
		reader
	)

Value:

{                                                      \
    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_READ_SEQ_ELEM	(	elem,
		reader
	)

Value:

{                                                              \
    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
	)

Value:

{                                                                \
    assert( (reader).seq->elem_size == sizeof(elem));            \
    memcpy(&(elem), (reader).ptr, sizeof((elem)));               \
    CV_PREV_SEQ_ELEM( sizeof(elem), reader )                     \
}

#define CV_SEQ_CHAIN (CV_SEQ_KIND_CURVE | CV_SEQ_ELTYPE_CODE)

#define CV_SEQ_CHAIN_CONTOUR (CV_SEQ_FLAG_CLOSED | CV_SEQ_CHAIN)

#define CV_SEQ_CONNECTED_COMP (CV_SEQ_KIND_GENERIC | CV_SEQ_ELTYPE_CONNECTED_COMP)

#define CV_SEQ_CONTOUR CV_SEQ_POLYGON

#define CV_SEQ_ELEM	(	seq,
		elem_type,
		index
	)

Value:

/* 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_SEQ_ELTYPE ( seq ) ((seq)->flags & CV_SEQ_ELTYPE_MASK)

#define CV_SEQ_ELTYPE_BITS 9

#define CV_SEQ_ELTYPE_CODE CV_8UC1 /* freeman code: 0..7 */

#define CV_SEQ_ELTYPE_CONNECTED_COMP 0 /* connected component */

#define CV_SEQ_ELTYPE_GENERIC 0

#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_INDEX CV_32SC1 /* #(x,y) */

#define CV_SEQ_ELTYPE_MASK ((1 << CV_SEQ_ELTYPE_BITS) - 1)

#define CV_SEQ_ELTYPE_POINT CV_32SC2 /* (x,y) */

#define CV_SEQ_ELTYPE_POINT3D CV_32FC3 /* (x,y,z) */

#define CV_SEQ_ELTYPE_PPOINT CV_SEQ_ELTYPE_PTR /* &(x,y) */

#define CV_SEQ_ELTYPE_PTR CV_USRTYPE1

#define CV_SEQ_ELTYPE_TRIAN_ATR 0 /* vertex of the binary tree */

#define CV_SEQ_FLAG_CLOSED (1 << CV_SEQ_FLAG_SHIFT)

#define CV_SEQ_FLAG_CONVEX (4 << CV_SEQ_FLAG_SHIFT)

#define CV_SEQ_FLAG_HOLE (8 << CV_SEQ_FLAG_SHIFT)

#define CV_SEQ_FLAG_SHIFT (CV_SEQ_KIND_BITS + CV_SEQ_ELTYPE_BITS)

#define CV_SEQ_FLAG_SIMPLE (2 << CV_SEQ_FLAG_SHIFT)

#define CV_SEQ_INDEX (CV_SEQ_KIND_GENERIC | CV_SEQ_ELTYPE_INDEX)

#define CV_SEQ_KIND ( seq ) ((seq)->flags & CV_SEQ_KIND_MASK )

#define CV_SEQ_KIND_BIN_TREE (2 << CV_SEQ_ELTYPE_BITS)

#define CV_SEQ_KIND_BITS 3

#define CV_SEQ_KIND_CURVE (1 << CV_SEQ_ELTYPE_BITS)

#define CV_SEQ_KIND_GENERIC (0 << CV_SEQ_ELTYPE_BITS)

#define CV_SEQ_KIND_GRAPH (3 << CV_SEQ_ELTYPE_BITS)

#define CV_SEQ_KIND_MASK (((1 << CV_SEQ_KIND_BITS) - 1)<<CV_SEQ_ELTYPE_BITS)

#define CV_SEQ_KIND_SUBDIV2D (4 << CV_SEQ_ELTYPE_BITS)

#define CV_SEQ_MAGIC_VAL 0x42990000

#define CV_SEQ_POINT3D_SET (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT3D)

#define CV_SEQ_POINT_SET (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT)

#define CV_SEQ_POLYGON (CV_SEQ_FLAG_CLOSED | CV_SEQ_POLYLINE )

#define CV_SEQ_POLYGON_TREE (CV_SEQ_KIND_BIN_TREE | CV_SEQ_ELTYPE_TRIAN_ATR)

#define CV_SEQ_POLYLINE (CV_SEQ_KIND_CURVE | CV_SEQ_ELTYPE_POINT)

#define CV_SEQ_READER_FIELDS ( )

Value:

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 */

#define CV_SEQ_SIMPLE_POLYGON (CV_SEQ_FLAG_SIMPLE | CV_SEQ_POLYGON )

#define CV_SEQ_WRITER_FIELDS ( )

Value:

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 */

#define CV_SEQUENCE_FIELDS ( )

Value:

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. */

#define CV_SET_ELEM_FIELDS ( elem_type )

Value:

int flags; \

struct elem_type* next_free;

#define CV_SET_ELEM_FREE_FLAG (1 << (sizeof(int)*8-1))

#define CV_SET_ELEM_IDX_MASK ((1 << 26) - 1)

#define CV_SET_FIELDS ( )

Value:

CV_SEQUENCE_FIELDS()     \
    CvSetElem* free_elems;   \
    int active_count;

#define CV_SET_MAGIC_VAL 0x42980000

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

#define CV_SPARSE_MAT_MAGIC_VAL 0x42440000

#define CV_SSE2 0

#define CV_STDCALL

#define CV_STORAGE_APPEND 2

#define CV_STORAGE_MAGIC_VAL 0x42890000

#define CV_STORAGE_READ 0

#define CV_STORAGE_WRITE 1

#define CV_STORAGE_WRITE_BINARY CV_STORAGE_WRITE

#define CV_STORAGE_WRITE_TEXT CV_STORAGE_WRITE

#define CV_SWAP	(	a,
		b,
		t
	)	((t) = (a), (a) = (b), (b) = (t))

#define CV_TERMCRIT_EPS 2

#define CV_TERMCRIT_ITER 1

#define CV_TERMCRIT_NUMBER CV_TERMCRIT_ITER

#define CV_TREE_NODE_FIELDS ( node_type )

Value:

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_TYPE_NAME_GRAPH "opencv-graph"

#define CV_TYPE_NAME_IMAGE "opencv-image"

#define CV_TYPE_NAME_MAT "opencv-matrix"

#define CV_TYPE_NAME_MATND "opencv-nd-matrix"

#define CV_TYPE_NAME_SEQ "opencv-sequence"

#define CV_TYPE_NAME_SEQ_TREE "opencv-sequence-tree"

#define CV_TYPE_NAME_SPARSE_MAT "opencv-sparse-matrix"

#define CV_USRTYPE1 7

#define CV_WHOLE_ARR cvSlice( 0, 0x3fffffff )

#define CV_WHOLE_SEQ cvSlice(0, CV_WHOLE_SEQ_END_INDEX)

#define CV_WHOLE_SEQ_END_INDEX 0x3fffffff

#define CV_WRITE_SEQ_ELEM	(	elem,
		writer
	)

Value:

{                                                     \
    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_WRITE_SEQ_ELEM_VAR	(	elem_ptr,
		writer
	)

Value:

{                                                     \
    if( (writer).ptr >= (writer).block_max )          \
    {                                                 \
        cvCreateSeqBlock( &writer);                   \
    }                                                 \
    memcpy((writer).ptr, elem_ptr, (writer).seq->elem_size);\
    (writer).ptr += (writer).seq->elem_size;          \
}