# /usr/obj/OpenCV-2.2.0/OpenCV-2.2.0/modules/core/include/opencv2/core/types_c.h File Reference

Go to the source code of this file.

## Classes

struct | _IplConvKernel
struct | _IplConvKernelFP
struct | _IplImage
struct | _IplROI
union | Cv32suf
union | Cv64suf
struct | CvAttrList
struct | CvBox2D
struct | CvChain
struct | CvContour
struct | CvFileNode
struct | CvGraph
struct | CvGraphEdge
struct | CvGraphVtx
struct | CvGraphVtx2D
struct | CvHistogram
struct | CvLineIterator
struct | CvMat
struct | CvMatND
struct | CvMemBlock
struct | CvMemStorage
struct | CvMemStoragePos
struct | CvModuleInfo
struct | CvPluginFuncInfo
struct | CvPoint
struct | CvPoint2D32f
struct | CvPoint2D64f
struct | CvPoint3D32f
struct | CvPoint3D64f
struct | CvRect
struct | CvScalar
struct | CvSeq
struct | CvSeqBlock
struct | CvSeqReader
struct | CvSeqWriter
struct | CvSet
struct | CvSetElem
struct | CvSize
struct | CvSize2D32f
struct | CvSlice
struct | CvSparseMat
struct | CvSparseMatIterator
struct | CvSparseNode
struct | CvString
struct | CvStringHashNode
struct | CvTermCriteria
struct | CvTypeInfo

## Defines

#define | 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)
#define | 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)
#define | 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)
#define | 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)
#define | 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)
#define | 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)
#define | 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_CARRAY(counter)
#define | CV_CDECL
#define | CV_CMP(a, b) (((a) > (b)) - ((a) < (b)))
#define | CV_CN_MAX 512
#define | CV_CN_SHIFT 3
#define | CV_CONTOUR_FIELDS()
#define | CV_CURRENT_POINT(reader) (*((CvPoint*)((reader).ptr)))
#define | CV_CUSTOM_CARRAY(args)
#define | CV_DEFAULT(val) = 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_EXPORTS_AS(synonym) CV_EXPORTS
#define | CV_EXPORTS_W CV_EXPORTS
#define | CV_EXPORTS_W_MAP CV_EXPORTS
#define | CV_EXPORTS_W_SIMPLE CV_EXPORTS
#define | CV_EXTERN_C extern "C"
#define | CV_EXTERN_C_FUNCPTR(x) extern "C" { 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()
#define | CV_GRAPH_FIELDS()
#define | CV_GRAPH_FLAG_ORIENTED (1 << CV_SEQ_FLAG_SHIFT)
#define | CV_GRAPH_VERTEX_FIELDS()
#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) abs(a)
#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_IN_OUT
#define | CV_INLINE inline
#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)
#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)
#define | CV_IS_MAT_HDR_Z(mat)
#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) 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)
#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)
#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) 1
#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)
#define | CV_IS_STORAGE(storage)
#define | CV_IS_SUBDIV2D(seq) (CV_IS_SET(seq) && CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_SUBDIV2D)
#define | CV_IS_SUBMAT(flags) ((flags) & CV_MAT_SUBMAT_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) (CV_MAT_DEPTH(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)
#define | CV_MAT_MAGIC_VAL 0x42420000
#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)
#define | CV_NEXT_SEQ_ELEM(elem_size, reader)
#define | CV_NODE_EMPTY 32
#define | CV_NODE_FLOAT CV_NODE_REAL
#define | CV_NODE_FLOW 8
#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
#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_OUT
#define | CV_PI 3.1415926535897932384626433832795
#define | CV_PREV_POINT(reader) (*((CvPoint*)((reader).prev_elem)))
#define | CV_PREV_SEQ_ELEM(elem_size, reader)
#define | CV_PROP
#define | CV_PROP_RW
#define | CV_READ_CHAIN_POINT(_pt, reader)
#define | CV_READ_EDGE(pt1, pt2, reader)
#define | CV_READ_SEQ_ELEM(elem, reader)
#define | CV_REV_READ_SEQ_ELEM(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)
#define | CV_SEQ_ELTYPE(seq) ((seq)->flags & CV_SEQ_ELTYPE_MASK)
#define | CV_SEQ_ELTYPE_BITS 12
#define | CV_SEQ_ELTYPE_CODE CV_8UC1
#define | CV_SEQ_ELTYPE_CONNECTED_COMP 0
#define | CV_SEQ_ELTYPE_GENERIC 0
#define | CV_SEQ_ELTYPE_GRAPH_EDGE 0
#define | CV_SEQ_ELTYPE_GRAPH_VERTEX 0
#define | CV_SEQ_ELTYPE_INDEX CV_32SC1
#define | CV_SEQ_ELTYPE_MASK ((1 << CV_SEQ_ELTYPE_BITS) - 1)
#define | CV_SEQ_ELTYPE_POINT CV_32SC2
#define | CV_SEQ_ELTYPE_POINT3D CV_32FC3
#define | CV_SEQ_ELTYPE_PPOINT CV_SEQ_ELTYPE_PTR
#define | CV_SEQ_ELTYPE_PTR CV_USRTYPE1
#define | CV_SEQ_ELTYPE_TRIAN_ATR 0
#define | CV_SEQ_FLAG_CLOSED (1 << CV_SEQ_FLAG_SHIFT)
#define | CV_SEQ_FLAG_CONVEX (0 << CV_SEQ_FLAG_SHIFT)
#define | CV_SEQ_FLAG_HOLE (2 << CV_SEQ_FLAG_SHIFT)
#define | CV_SEQ_FLAG_SHIFT (CV_SEQ_KIND_BITS + CV_SEQ_ELTYPE_BITS)
#define | CV_SEQ_FLAG_SIMPLE (0 << 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 2
#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 (1 << CV_SEQ_ELTYPE_BITS)
#define | CV_SEQ_KIND_MASK (((1 << CV_SEQ_KIND_BITS) - 1)<<CV_SEQ_ELTYPE_BITS)
#define | CV_SEQ_KIND_SUBDIV2D (2 << 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()
#define | CV_SEQ_SIMPLE_POLYGON (CV_SEQ_FLAG_SIMPLE | CV_SEQ_POLYGON )
#define | CV_SEQ_WRITER_FIELDS()
#define | CV_SEQUENCE_FIELDS()
#define | CV_SET_ELEM_FIELDS(elem_type)
#define | CV_SET_ELEM_FREE_FLAG (1 << (sizeof(int)*8-1))
#define | CV_SET_ELEM_IDX_MASK ((1 << 26) - 1)
#define | CV_SET_FIELDS()
#define | CV_SET_MAGIC_VAL 0x42980000
#define | CV_SIGN(a) CV_CMP((a),0)
#define | CV_SPARSE_MAT_MAGIC_VAL 0x42440000
#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_SUBMAT_FLAG (1 << CV_SUBMAT_FLAG_SHIFT)
#define | CV_SUBMAT_FLAG_SHIFT 15
#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)
#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_WRAP
#define | CV_WRAP_AS(synonym)
#define | CV_WRAP_DEFAULT(value)
#define | CV_WRITE_SEQ_ELEM(elem, writer)
#define | CV_WRITE_SEQ_ELEM_VAR(elem_ptr, writer)
#define | cvInvSqrt(value) ((float)(1./sqrt(value)))
#define | cvSqrt(value) ((float)sqrt(value))
#define | IPL2CV_DEPTH(depth)
#define | IPL_ALIGN_16BYTES 16
#define | IPL_ALIGN_32BYTES 32
#define | IPL_ALIGN_4BYTES 4
#define | IPL_ALIGN_8BYTES 8
#define | IPL_ALIGN_DWORD IPL_ALIGN_4BYTES
#define | IPL_ALIGN_QWORD IPL_ALIGN_8BYTES
#define | IPL_BORDER_CONSTANT 0
#define | IPL_BORDER_REFLECT 2
#define | IPL_BORDER_REFLECT_101 4
#define | IPL_BORDER_REPLICATE 1
#define | IPL_BORDER_TRANSPARENT 5
#define | IPL_BORDER_WRAP 3
#define | IPL_DATA_ORDER_PIXEL 0
#define | IPL_DATA_ORDER_PLANE 1
#define | IPL_DEPTH_16S (IPL_DEPTH_SIGN|16)
#define | IPL_DEPTH_16U 16
#define | IPL_DEPTH_1U 1
#define | IPL_DEPTH_32F 32
#define | IPL_DEPTH_32S (IPL_DEPTH_SIGN|32)
#define | IPL_DEPTH_64F 64
#define | IPL_DEPTH_8S (IPL_DEPTH_SIGN| 8)
#define | IPL_DEPTH_8U 8
#define | IPL_DEPTH_SIGN 0x80000000
#define | IPL_IMAGE_DATA 2
#define | IPL_IMAGE_HEADER 1
#define | IPL_IMAGE_MAGIC_VAL ((int)sizeof(IplImage))
#define | IPL_IMAGE_ROI 4
#define | IPL_ORIGIN_BL 1
#define | IPL_ORIGIN_TL 0
#define | MAX(a, b) ((a) < (b) ? (b) : (a))
#define | MIN(a, b) ((a) > (b) ? (b) : (a))

## Typedefs

typedef union Cv32suf | Cv32suf
typedef union Cv64suf | Cv64suf
typedef void | CvArr
typedef struct CvAttrList | CvAttrList
typedef struct CvBox2D | CvBox2D
typedef struct CvChain | CvChain
typedef void *(CV_CDECL * | CvCloneFunc )(const void *struct_ptr)
typedef struct CvContour | CvContour
typedef struct CvFileNode | CvFileNode
typedef struct CvGenericHash | CvFileNodeHash
typedef struct CvFileStorage | CvFileStorage
typedef struct CvGraph | CvGraph
typedef struct CvGraphEdge | CvGraphEdge
typedef struct CvGraphVtx | CvGraphVtx
typedef struct CvGraphVtx2D | CvGraphVtx2D
typedef struct CvHistogram | CvHistogram
typedef int | CvHistType
typedef int(CV_CDECL * | CvIsInstanceFunc )(const void *struct_ptr)
typedef struct CvLineIterator | CvLineIterator
typedef struct CvMat | CvMat
typedef struct CvMatND | CvMatND
typedef struct CvMemBlock | CvMemBlock
typedef struct CvMemStorage | CvMemStorage
typedef struct CvMemStoragePos | CvMemStoragePos
typedef struct CvModuleInfo | CvModuleInfo
typedef struct CvPluginFuncInfo | CvPluginFuncInfo
typedef struct CvPoint | CvPoint
typedef struct CvPoint2D32f | CvPoint2D32f
typedef struct CvPoint2D64f | CvPoint2D64f
typedef CvContour | CvPoint2DSeq
typedef struct CvPoint3D32f | CvPoint3D32f
typedef struct CvPoint3D64f | CvPoint3D64f
typedef void *(CV_CDECL * | CvReadFunc )(CvFileStorage *storage, CvFileNode *node)
typedef struct CvRect | CvRect
typedef void(CV_CDECL * | CvReleaseFunc )(void **struct_dblptr)
typedef uint64 | CvRNG
typedef struct CvScalar | CvScalar
typedef struct CvSeq | CvSeq
typedef struct CvSeqBlock | CvSeqBlock
typedef struct CvSeqReader | CvSeqReader
typedef struct CvSeqWriter | CvSeqWriter
typedef struct CvSet | CvSet
typedef struct CvSetElem | CvSetElem
typedef struct CvSize2D32f | CvSize2D32f
typedef struct CvSlice | CvSlice
typedef struct CvSparseMat | CvSparseMat
typedef struct CvSparseMatIterator | CvSparseMatIterator
typedef struct CvSparseNode | CvSparseNode
typedef int | CVStatus
typedef struct CvString | CvString
typedef struct CvStringHashNode | CvStringHashNode
typedef struct CvTermCriteria | CvTermCriteria
typedef struct CvTypeInfo | CvTypeInfo
typedef void(CV_CDECL * | CvWriteFunc )(CvFileStorage *storage, const char *name, const void *struct_ptr, CvAttrList attributes)
typedef int64_t | int64
typedef struct _IplConvKernel | IplConvKernel
typedef struct _IplConvKernelFP | IplConvKernelFP
typedef struct _IplImage | IplImage
typedef struct _IplROI | IplROI
typedef struct _IplTileInfo | IplTileInfo
typedef signed char | schar
typedef unsigned char | uchar
typedef uint64_t | uint64
typedef unsigned short | ushort

## Enumerations

enum

{
CV_StsOk = 0, CV_StsBackTrace = -1, CV_StsError = -2, CV_StsInternal = -3,
CV_StsNoMem = -4, CV_StsBadArg = -5, CV_StsBadFunc = -6, CV_StsNoConv = -7,
CV_StsAutoTrace = -8, CV_HeaderIsNull = -9, CV_BadImageSize = -10, CV_BadOffset = -11,
CV_BadDataPtr = -12, CV_BadStep = -13, CV_BadModelOrChSeq = -14, CV_BadNumChannels = -15,
CV_BadNumChannel1U = -16, CV_BadDepth = -17, CV_BadAlphaChannel = -18, CV_BadOrder = -19,
CV_BadOrigin = -20, CV_BadAlign = -21, CV_BadCallBack = -22, CV_BadTileSize = -23,
CV_BadCOI = -24, CV_BadROISize = -25, CV_MaskIsTiled = -26, CV_StsNullPtr = -27,
CV_StsVecLengthErr = -28, CV_StsFilterStructContentErr = -29, CV_StsKernelStructContentErr = -30, CV_StsFilterOffsetErr = -31,
CV_StsBadSize = -201, CV_StsDivByZero = -202, CV_StsInplaceNotSupported = -203, CV_StsObjectNotFound = -204,
CV_StsUnmatchedFormats = -205, CV_StsBadFlag = -206, CV_StsBadPoint = -207, CV_StsBadMask = -208,
CV_StsUnmatchedSizes = -209, CV_StsUnsupportedFormat = -210, CV_StsOutOfRange = -211, CV_StsParseError = -212,
CV_StsNotImplemented = -213, CV_StsBadMemBlock = -214, CV_StsAssert = -215, CV_GpuNotSupported = -216,
CV_GpuApiCallError = -217, CV_GpuNppCallError = -218
}

## Functions

CV_INLINE CvAttrList | cvAttrList (const char **attr CV_DEFAULT(NULL), CvAttrList *next CV_DEFAULT(NULL))
CV_INLINE int | cvCeil (double value)
CV_INLINE int | cvFloor (double value)
CV_INLINE int | cvIplDepth (int type)
CV_INLINE int | cvIsInf (double value)
CV_INLINE int | cvIsNaN (double value)
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 CvPoint | cvPoint (int x, int y)
CV_INLINE CvPoint2D32f | cvPoint2D32f (double x, double y)
CV_INLINE CvPoint2D64f | cvPoint2D64f (double x, double y)
CV_INLINE CvPoint3D32f | cvPoint3D32f (double x, double y, double z)
CV_INLINE CvPoint3D64f | cvPoint3D64f (double x, double y, double z)
CV_INLINE CvPoint | cvPointFrom32f (CvPoint2D32f point)
CV_INLINE CvPoint2D32f | cvPointTo32f (CvPoint point)
CV_INLINE unsigned | cvRandInt (CvRNG *rng)
CV_INLINE double | cvRandReal (CvRNG *rng)
CV_INLINE CvScalar | cvRealScalar (double val0)
CV_INLINE CvRect | cvRect (int x, int y, int width, int height)
CV_INLINE IplROI | cvRectToROI (CvRect rect, int coi)
CV_INLINE CvRNG | cvRNG (int64 seed CV_DEFAULT(-1))
CV_INLINE CvRect | cvROIToRect (IplROI roi)
CV_INLINE int | cvRound (double value)
CV_INLINE CvScalar | cvScalar (double val0, double val1 CV_DEFAULT(0), double val2 CV_DEFAULT(0), double val3 CV_DEFAULT(0))
CV_INLINE CvScalar | cvScalarAll (double val0123)
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 CvTermCriteria | cvTermCriteria (int type, int max_iter, double epsilon)

## Define Documentation

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

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

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

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

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

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

#define 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_CARRAY | ( |  | counter ) |

#define CV_CDECL

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

#define CV_CN_MAX 512

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

#define CV_DEFAULT | ( |  | val ) | = 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_EXPORTS_AS | ( |  | synonym ) | CV_EXPORTS

#define CV_EXPORTS_W CV_EXPORTS

#define CV_EXPORTS_W_MAP CV_EXPORTS

#define CV_EXPORTS_W_SIMPLE CV_EXPORTS

#define CV_EXTERN_C extern "C"

#define CV_EXTERN_C_FUNCPTR | ( |  | x ) | extern "C" { 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 ) | abs(a)

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

#define CV_INLINE inline

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

#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_SUBMAT | ( |  | flags ) | ((flags) & CV_MAT_SUBMAT_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
| ) |  | (CV_MAT_DEPTH(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_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

#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

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

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

#define CV_PROP_RW

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

#define CV_SEQ_ELTYPE_CODE CV_8UC1

#define CV_SEQ_ELTYPE_CONNECTED_COMP 0

#define CV_SEQ_ELTYPE_GENERIC 0

#define CV_SEQ_ELTYPE_GRAPH_EDGE 0

#define CV_SEQ_ELTYPE_GRAPH_VERTEX 0

#define CV_SEQ_ELTYPE_INDEX CV_32SC1

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

#define CV_SEQ_ELTYPE_POINT CV_32SC2

#define CV_SEQ_ELTYPE_POINT3D CV_32FC3

#define CV_SEQ_ELTYPE_PPOINT CV_SEQ_ELTYPE_PTR

#define CV_SEQ_ELTYPE_PTR CV_USRTYPE1

#define CV_SEQ_ELTYPE_TRIAN_ATR 0

#define CV_SEQ_FLAG_CLOSED (1 << CV_SEQ_FLAG_SHIFT)

#define CV_SEQ_FLAG_CONVEX (0 << CV_SEQ_FLAG_SHIFT)

#define CV_SEQ_FLAG_HOLE (2 << CV_SEQ_FLAG_SHIFT)

#define CV_SEQ_FLAG_SHIFT (CV_SEQ_KIND_BITS + CV_SEQ_ELTYPE_BITS)

#define CV_SEQ_FLAG_SIMPLE (0 << 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 2

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

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

#define CV_SEQ_KIND_SUBDIV2D (2 << 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;

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

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

#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_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_SUBMAT_FLAG (1 << CV_SUBMAT_FLAG_SHIFT)

#define CV_SUBMAT_FLAG_SHIFT 15

#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

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

#define CV_WRAP_AS | ( |  | synonym ) |

#define CV_WRAP_DEFAULT | ( |  | value ) |

#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;          \
    }

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

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

#define IPL2CV_DEPTH | ( |  | depth ) |

Value:

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

#define IPL_ALIGN_16BYTES 16

#define IPL_ALIGN_32BYTES 32

#define IPL_ALIGN_4BYTES 4

#define IPL_ALIGN_8BYTES 8

#define IPL_ALIGN_DWORD IPL_ALIGN_4BYTES

#define IPL_ALIGN_QWORD IPL_ALIGN_8BYTES

#define IPL_BORDER_CONSTANT 0

#define IPL_BORDER_REFLECT 2

#define IPL_BORDER_REFLECT_101 4

#define IPL_BORDER_REPLICATE 1

#define IPL_BORDER_TRANSPARENT 5

#define IPL_BORDER_WRAP 3

#define IPL_DATA_ORDER_PIXEL 0

#define IPL_DATA_ORDER_PLANE 1

#define IPL_DEPTH_16S (IPL_DEPTH_SIGN|16)

#define IPL_DEPTH_16U 16

#define IPL_DEPTH_1U 1

#define IPL_DEPTH_32F 32

#define IPL_DEPTH_32S (IPL_DEPTH_SIGN|32)

#define IPL_DEPTH_64F 64

#define IPL_DEPTH_8S (IPL_DEPTH_SIGN| 8)

#define IPL_DEPTH_8U 8

#define IPL_DEPTH_SIGN 0x80000000

#define IPL_IMAGE_DATA 2

#define IPL_IMAGE_HEADER 1

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

#define IPL_IMAGE_ROI 4

#define IPL_ORIGIN_BL 1

#define IPL_ORIGIN_TL 0

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

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

## Typedef Documentation

typedef union Cv32suf Cv32suf

typedef union Cv64suf Cv64suf

typedef void CvArr

typedef struct CvAttrList CvAttrList

typedef struct CvBox2D CvBox2D

typedef struct CvChain CvChain

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

typedef struct CvContour CvContour

typedef struct CvFileNode CvFileNode

typedef struct CvGenericHash CvFileNodeHash

typedef struct CvFileStorage CvFileStorage

typedef struct CvGraph CvGraph

typedef struct CvGraphEdge CvGraphEdge

typedef struct CvGraphVtx CvGraphVtx

typedef struct CvGraphVtx2D CvGraphVtx2D

typedef struct CvHistogram CvHistogram

typedef int CvHistType

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

typedef struct CvLineIterator CvLineIterator

typedef struct CvMat CvMat

typedef struct CvMatND CvMatND

typedef struct CvMemBlock CvMemBlock

typedef struct CvMemStorage CvMemStorage

typedef struct CvMemStoragePos CvMemStoragePos

typedef struct CvModuleInfo CvModuleInfo

typedef struct CvPluginFuncInfo CvPluginFuncInfo

typedef struct CvPoint CvPoint

typedef struct CvPoint2D32f CvPoint2D32f

typedef struct CvPoint2D64f CvPoint2D64f

typedef CvContour CvPoint2DSeq

typedef struct CvPoint3D32f CvPoint3D32f

typedef struct CvPoint3D64f CvPoint3D64f

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

typedef struct CvRect CvRect

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

typedef uint64 CvRNG

typedef struct CvScalar CvScalar

typedef struct CvSeq CvSeq

typedef struct CvSeqBlock CvSeqBlock

typedef struct CvSeqReader CvSeqReader

typedef struct CvSeqWriter CvSeqWriter

typedef struct CvSet CvSet

typedef struct CvSetElem CvSetElem

typedef struct CvSize2D32f CvSize2D32f

typedef struct CvSlice CvSlice

typedef struct CvSparseMat CvSparseMat

typedef struct CvSparseMatIterator CvSparseMatIterator

typedef struct CvSparseNode CvSparseNode

typedef int CVStatus

typedef struct CvString CvString

typedef struct CvStringHashNode CvStringHashNode

typedef struct CvTermCriteria CvTermCriteria

typedef struct CvTypeInfo CvTypeInfo

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

typedef int64_t int64

typedef struct _IplConvKernel IplConvKernel

typedef struct _IplConvKernelFP IplConvKernelFP

typedef struct _IplImage IplImage

typedef struct _IplROI IplROI

typedef struct _IplTileInfo IplTileInfo

typedef signed char schar

typedef unsigned char uchar

typedef uint64_t uint64

typedef unsigned short ushort

## Enumeration Type Documentation

anonymous enum

Enumerator:

  CV_StsOk |
  CV_StsBackTrace |
  CV_StsError |
  CV_StsInternal |
  CV_StsNoMem |
  CV_StsBadArg |
  CV_StsBadFunc |
  CV_StsNoConv |
  CV_StsAutoTrace |
  CV_HeaderIsNull |
  CV_BadImageSize |
  CV_BadOffset |
  CV_BadDataPtr |
  CV_BadStep |
  CV_BadModelOrChSeq |
  CV_BadNumChannels |
  CV_BadNumChannel1U |
  CV_BadDepth |
  CV_BadAlphaChannel |
  CV_BadOrder |
  CV_BadOrigin |
  CV_BadAlign |
  CV_BadCallBack |
  CV_BadTileSize |
  CV_BadCOI |
  CV_BadROISize |
  CV_MaskIsTiled |
  CV_StsNullPtr |
  CV_StsVecLengthErr |
  CV_StsFilterStructContentErr |
  CV_StsKernelStructContentErr |
  CV_StsFilterOffsetErr |
  CV_StsBadSize |
  CV_StsDivByZero |
  CV_StsInplaceNotSupported |
  CV_StsObjectNotFound |
  CV_StsUnmatchedFormats |
  CV_StsBadFlag |
  CV_StsBadPoint |
  CV_StsBadMask |
  CV_StsUnmatchedSizes |
  CV_StsUnsupportedFormat |
  CV_StsOutOfRange |
  CV_StsParseError |
  CV_StsNotImplemented |
  CV_StsBadMemBlock |
  CV_StsAssert |
  CV_GpuNotSupported |
  CV_GpuApiCallError |
  CV_GpuNppCallError |

## Function Documentation

CV_INLINE CvAttrList cvAttrList | ( | const char **attr | CV_DEFAULTNULL,
|  | CvAttrList *next | CV_DEFAULTNULL
| ) |  |

CV_INLINE int cvCeil | ( | double | value ) |

CV_INLINE int cvFloor | ( | double | value ) |

CV_INLINE int cvIplDepth | ( | int | type ) |

CV_INLINE int cvIsInf | ( | double | value ) |

CV_INLINE int cvIsNaN | ( | double | value ) |

CV_INLINE CvMat cvMat | ( | int | rows,
|  | int | cols,
|  | int | type,
|  | void *data | CV_DEFAULTNULL
| ) |  |

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 CvPoint cvPoint | ( | int | x,
|  | int | y
| ) |  |

CV_INLINE CvPoint2D32f cvPoint2D32f | ( | double | x,
|  | double | y
| ) |  |

CV_INLINE CvPoint2D64f cvPoint2D64f | ( | double | x,
|  | double | y
| ) |  |

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

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

CV_INLINE CvPoint cvPointFrom32f | ( | CvPoint2D32f | point ) |

CV_INLINE CvPoint2D32f cvPointTo32f | ( | CvPoint | point ) |

CV_INLINE unsigned cvRandInt | ( | CvRNG * | rng ) |

CV_INLINE double cvRandReal | ( | CvRNG * | rng ) |

CV_INLINE CvScalar cvRealScalar | ( | double | val0 ) |

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

CV_INLINE IplROI cvRectToROI | ( | CvRect | rect,
|  | int | coi
| ) |  |

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

CV_INLINE CvRect cvROIToRect | ( | IplROI | roi ) |

CV_INLINE int cvRound | ( | double | value ) |

CV_INLINE CvScalar cvScalar | ( | double | val0,
|  | double val1 | CV_DEFAULT0,
|  | double val2 | CV_DEFAULT0,
|  | double val3 | CV_DEFAULT0
| ) |  |

CV_INLINE CvScalar cvScalarAll | ( | double | val0123 ) |

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 CvTermCriteria cvTermCriteria | ( | int | type,
|  | int | max_iter,
|  | double | epsilon
| ) |  |

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines