OpenCV  2.4.13.2
Open Source Computer Vision
core/include/opencv2/core/types_c.h File Reference
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>
#include <stdint.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_ATTR_UNUSED
 
#define CV_ATTR_USED
 
#define CV_ENABLE_UNROLLED   1
 
#define CV_CDECL
 
#define CV_STDCALL
 
#define CV_EXTERN_C   extern "C"
 
#define CV_DEFAULT(val)   = val
 
#define CV_EXTERN_C_FUNCPTR(x)   extern "C" { typedef x; }
 
#define CV_INLINE   inline
 
#define CV_BIG_INT(n)   n##LL
 
#define CV_BIG_UINT(n)   n##ULL
 
#define CV_CARRAY(counter)
 
#define CV_CUSTOM_CARRAY(args)
 
#define CV_EXPORTS_W_SIMPLE   CV_EXPORTS
 
#define CV_EXPORTS_AS(synonym)   CV_EXPORTS
 
#define CV_EXPORTS_W_MAP   CV_EXPORTS
 
#define CV_IN_OUT
 
#define CV_OUT
 
#define CV_PROP
 
#define CV_PROP_RW
 
#define CV_WRAP_DEFAULT(value)
 
#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)   abs(a)
 
#define CV_CMP(a, b)   (((a) > (b)) - ((a) < (b)))
 
#define CV_SIGN(a)   CV_CMP((a),0)
 
#define CV_VFP   0
 
#define cvInvSqrt(value)   ((float)(1./sqrt(value)))
 
#define cvSqrt(value)   ((float)sqrt(value))
 
#define CV_RNG_COEFF   4164903690U
 
#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_BORDER_TRANSPARENT   5
 
#define IPL_IMAGE_MAGIC_VAL   ((int)sizeof(IplImage))
 
#define CV_TYPE_NAME_IMAGE   "opencv-image"
 
#define CV_IS_IMAGE_HDR(img)   ((img) != NULL && ((const IplImage*)(img))->nSize == sizeof(IplImage))
 
#define CV_IS_IMAGE(img)   (CV_IS_IMAGE_HDR(img) && ((IplImage*)img)->imageData != NULL)
 
#define IPL_DEPTH_64F   64
 
#define CV_IMAGE_ELEM(image, elemtype, row, col)   (((elemtype*)((image)->imageData + (image)->widthStep*(row)))[(col)])
 
#define CV_CN_MAX   512
 
#define CV_CN_SHIFT   3
 
#define CV_DEPTH_MAX   (1 << CV_CN_SHIFT)
 
#define CV_8U   0
 
#define CV_8S   1
 
#define CV_16U   2
 
#define CV_16S   3
 
#define CV_32S   4
 
#define CV_32F   5
 
#define CV_64F   6
 
#define CV_USRTYPE1   7
 
#define CV_MAT_DEPTH_MASK   (CV_DEPTH_MAX - 1)
 
#define CV_MAT_DEPTH(flags)   ((flags) & CV_MAT_DEPTH_MASK)
 
#define CV_MAKETYPE(depth, cn)   (CV_MAT_DEPTH(depth) + (((cn)-1) << CV_CN_SHIFT))
 
#define CV_MAKE_TYPE   CV_MAKETYPE
 
#define CV_8UC1   CV_MAKETYPE(CV_8U,1)
 
#define CV_8UC2   CV_MAKETYPE(CV_8U,2)
 
#define CV_8UC3   CV_MAKETYPE(CV_8U,3)
 
#define CV_8UC4   CV_MAKETYPE(CV_8U,4)
 
#define CV_8UC(n)   CV_MAKETYPE(CV_8U,(n))
 
#define CV_8SC1   CV_MAKETYPE(CV_8S,1)
 
#define CV_8SC2   CV_MAKETYPE(CV_8S,2)
 
#define CV_8SC3   CV_MAKETYPE(CV_8S,3)
 
#define CV_8SC4   CV_MAKETYPE(CV_8S,4)
 
#define CV_8SC(n)   CV_MAKETYPE(CV_8S,(n))
 
#define CV_16UC1   CV_MAKETYPE(CV_16U,1)
 
#define CV_16UC2   CV_MAKETYPE(CV_16U,2)
 
#define CV_16UC3   CV_MAKETYPE(CV_16U,3)
 
#define CV_16UC4   CV_MAKETYPE(CV_16U,4)
 
#define CV_16UC(n)   CV_MAKETYPE(CV_16U,(n))
 
#define CV_16SC1   CV_MAKETYPE(CV_16S,1)
 
#define CV_16SC2   CV_MAKETYPE(CV_16S,2)
 
#define CV_16SC3   CV_MAKETYPE(CV_16S,3)
 
#define CV_16SC4   CV_MAKETYPE(CV_16S,4)
 
#define CV_16SC(n)   CV_MAKETYPE(CV_16S,(n))
 
#define CV_32SC1   CV_MAKETYPE(CV_32S,1)
 
#define CV_32SC2   CV_MAKETYPE(CV_32S,2)
 
#define CV_32SC3   CV_MAKETYPE(CV_32S,3)
 
#define CV_32SC4   CV_MAKETYPE(CV_32S,4)
 
#define CV_32SC(n)   CV_MAKETYPE(CV_32S,(n))
 
#define CV_32FC1   CV_MAKETYPE(CV_32F,1)
 
#define CV_32FC2   CV_MAKETYPE(CV_32F,2)
 
#define CV_32FC3   CV_MAKETYPE(CV_32F,3)
 
#define CV_32FC4   CV_MAKETYPE(CV_32F,4)
 
#define CV_32FC(n)   CV_MAKETYPE(CV_32F,(n))
 
#define CV_64FC1   CV_MAKETYPE(CV_64F,1)
 
#define CV_64FC2   CV_MAKETYPE(CV_64F,2)
 
#define CV_64FC3   CV_MAKETYPE(CV_64F,3)
 
#define CV_64FC4   CV_MAKETYPE(CV_64F,4)
 
#define CV_64FC(n)   CV_MAKETYPE(CV_64F,(n))
 
#define CV_AUTO_STEP   0x7fffffff
 
#define CV_WHOLE_ARR   cvSlice( 0, 0x3fffffff )
 
#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_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_SUBMAT_FLAG_SHIFT   15
 
#define CV_SUBMAT_FLAG   (1 << CV_SUBMAT_FLAG_SHIFT)
 
#define CV_IS_SUBMAT(flags)   ((flags) & CV_MAT_SUBMAT_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_HDR_Z(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 IPL2CV_DEPTH(depth)
 
#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   1024
 
#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   12
 
#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   2
 
#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   (1 << CV_SEQ_ELTYPE_BITS)
 
#define CV_SEQ_KIND_SUBDIV2D   (2 << 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   (0 << 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_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)   0
 
#define CV_IS_SEQ_HOLE(seq)   (((seq)->flags & CV_SEQ_FLAG_HOLE) != 0)
 
#define CV_IS_SEQ_SIMPLE(seq)   1
 
#define CV_IS_SEQ_POINT_SET(seq)   ((CV_SEQ_ELTYPE(seq) == CV_32SC2 || CV_SEQ_ELTYPE(seq) == CV_32FC2))
 
#define CV_IS_SEQ_POINT_SUBSET(seq)   (CV_IS_SEQ_INDEX( seq ) || CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_PPOINT)
 
#define CV_IS_SEQ_POLYLINE(seq)   (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && CV_IS_SEQ_POINT_SET(seq))
 
#define CV_IS_SEQ_POLYGON(seq)   (CV_IS_SEQ_POLYLINE(seq) && CV_IS_SEQ_CLOSED(seq))
 
#define CV_IS_SEQ_CHAIN(seq)   (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && (seq)->elem_size == 1)
 
#define CV_IS_SEQ_CONTOUR(seq)   (CV_IS_SEQ_CLOSED(seq) && (CV_IS_SEQ_POLYLINE(seq) || CV_IS_SEQ_CHAIN(seq)))
 
#define CV_IS_SEQ_CHAIN_CONTOUR(seq)   (CV_IS_SEQ_CHAIN( seq ) && CV_IS_SEQ_CLOSED( seq ))
 
#define CV_IS_SEQ_POLYGON_TREE(seq)
 
#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_STORAGE_MEMORY   4
 
#define CV_STORAGE_FORMAT_MASK   (7<<3)
 
#define CV_STORAGE_FORMAT_AUTO   0
 
#define CV_STORAGE_FORMAT_XML   8
 
#define CV_STORAGE_FORMAT_YAML   16
 
#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 int64_t int64
 
typedef uint64_t uint64
 
typedef unsigned char uchar
 
typedef unsigned short ushort
 
typedef signed char schar
 
typedef void CvArr
 
typedef int CVStatus
 
typedef uint64 CvRNG
 
typedef struct _IplTileInfo IplTileInfo
 
typedef int CvHistType
 
typedef CvContour CvPoint2DSeq
 
typedef struct CvFileStorage CvFileStorage
 
typedef struct CvGenericHash CvFileNodeHash
 
typedef int(* CvIsInstanceFunc) (const void *struct_ptr)
 
typedef void(* CvReleaseFunc) (void **struct_dblptr)
 
typedef void *(* CvReadFunc) (CvFileStorage *storage, CvFileNode *node)
 
typedef void(* CvWriteFunc) (CvFileStorage *storage, const char *name, const void *struct_ptr, CvAttrList attributes)
 
typedef void *(* CvCloneFunc) (const void *struct_ptr)
 

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_OpenGlNotSupported = -218, CV_OpenGlApiCallError = -219, CV_OpenCLDoubleNotSupported = -220,
  CV_OpenCLInitError = -221, CV_OpenCLNoAMDBlasFft = -222
}
 

Functions

int cvRound (double value)
 
int cvFloor (double value)
 
int cvCeil (double value)
 
int cvIsNaN (double value)
 
int cvIsInf (double value)
 
CvRNG cvRNG (int64 seed=-1)
 
unsigned cvRandInt (CvRNG *rng)
 
double cvRandReal (CvRNG *rng)
 
CvMat cvMat (int rows, int cols, int type, void *data=NULL)
 
double cvmGet (const CvMat *mat, int row, int col)
 
void cvmSet (CvMat *mat, int row, int col, double value)
 
int cvIplDepth (int type)
 
CvRect cvRect (int x, int y, int width, int height)
 
IplROI cvRectToROI (CvRect rect, int coi)
 
CvRect cvROIToRect (IplROI roi)
 
CvTermCriteria cvTermCriteria (int type, int max_iter, double epsilon)
 
CvPoint cvPoint (int x, int y)
 
CvPoint2D32f cvPoint2D32f (double x, double y)
 
CvPoint2D32f cvPointTo32f (CvPoint point)
 
CvPoint cvPointFrom32f (CvPoint2D32f point)
 
CvPoint3D32f cvPoint3D32f (double x, double y, double z)
 
CvPoint2D64f cvPoint2D64f (double x, double y)
 
CvPoint3D64f cvPoint3D64f (double x, double y, double z)
 
CvSize cvSize (int width, int height)
 
CvSize2D32f cvSize2D32f (double width, double height)
 
CvSlice cvSlice (int start, int end)
 
CvScalar cvScalar (double val0, double val1=0, double val2=0, double val3=0)
 
CvScalar cvRealScalar (double val0)
 
CvScalar cvScalarAll (double val0123)
 
CvAttrList cvAttrList (const char **attr=NULL, CvAttrList *next=NULL)
 

Macro Definition Documentation

§ CV_16S

#define CV_16S   3

§ CV_16SC

#define CV_16SC (   n)    CV_MAKETYPE(CV_16S,(n))

§ CV_16SC1

#define CV_16SC1   CV_MAKETYPE(CV_16S,1)

§ CV_16SC2

#define CV_16SC2   CV_MAKETYPE(CV_16S,2)

§ CV_16SC3

#define CV_16SC3   CV_MAKETYPE(CV_16S,3)

§ CV_16SC4

#define CV_16SC4   CV_MAKETYPE(CV_16S,4)

§ CV_16U

#define CV_16U   2

§ CV_16UC

#define CV_16UC (   n)    CV_MAKETYPE(CV_16U,(n))

§ CV_16UC1

#define CV_16UC1   CV_MAKETYPE(CV_16U,1)

§ CV_16UC2

#define CV_16UC2   CV_MAKETYPE(CV_16U,2)

§ CV_16UC3

#define CV_16UC3   CV_MAKETYPE(CV_16U,3)

§ CV_16UC4

#define CV_16UC4   CV_MAKETYPE(CV_16U,4)

§ CV_32F

#define CV_32F   5

§ CV_32FC

#define CV_32FC (   n)    CV_MAKETYPE(CV_32F,(n))

§ CV_32FC1

#define CV_32FC1   CV_MAKETYPE(CV_32F,1)

§ CV_32FC2

#define CV_32FC2   CV_MAKETYPE(CV_32F,2)

§ CV_32FC3

#define CV_32FC3   CV_MAKETYPE(CV_32F,3)

§ CV_32FC4

#define CV_32FC4   CV_MAKETYPE(CV_32F,4)

§ CV_32S

#define CV_32S   4

§ CV_32SC

#define CV_32SC (   n)    CV_MAKETYPE(CV_32S,(n))

§ CV_32SC1

#define CV_32SC1   CV_MAKETYPE(CV_32S,1)

§ CV_32SC2

#define CV_32SC2   CV_MAKETYPE(CV_32S,2)

§ CV_32SC3

#define CV_32SC3   CV_MAKETYPE(CV_32S,3)

§ CV_32SC4

#define CV_32SC4   CV_MAKETYPE(CV_32S,4)

§ CV_64F

#define CV_64F   6

§ CV_64FC

#define CV_64FC (   n)    CV_MAKETYPE(CV_64F,(n))

§ CV_64FC1

#define CV_64FC1   CV_MAKETYPE(CV_64F,1)

§ CV_64FC2

#define CV_64FC2   CV_MAKETYPE(CV_64F,2)

§ CV_64FC3

#define CV_64FC3   CV_MAKETYPE(CV_64F,3)

§ CV_64FC4

#define CV_64FC4   CV_MAKETYPE(CV_64F,4)

§ CV_8S

#define CV_8S   1

§ CV_8SC

#define CV_8SC (   n)    CV_MAKETYPE(CV_8S,(n))

§ CV_8SC1

#define CV_8SC1   CV_MAKETYPE(CV_8S,1)

§ CV_8SC2

#define CV_8SC2   CV_MAKETYPE(CV_8S,2)

§ CV_8SC3

#define CV_8SC3   CV_MAKETYPE(CV_8S,3)

§ CV_8SC4

#define CV_8SC4   CV_MAKETYPE(CV_8S,4)

§ CV_8U

#define CV_8U   0

§ CV_8UC

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

§ CV_8UC1

#define CV_8UC1   CV_MAKETYPE(CV_8U,1)

§ CV_8UC2

#define CV_8UC2   CV_MAKETYPE(CV_8U,2)

§ CV_8UC3

#define CV_8UC3   CV_MAKETYPE(CV_8U,3)

§ CV_8UC4

#define CV_8UC4   CV_MAKETYPE(CV_8U,4)

§ CV_ARE_CNS_EQ

#define CV_ARE_CNS_EQ (   mat1,
  mat2 
)    ((((mat1)->type ^ (mat2)->type) & CV_MAT_CN_MASK) == 0)

§ CV_ARE_DEPTHS_EQ

#define CV_ARE_DEPTHS_EQ (   mat1,
  mat2 
)    ((((mat1)->type ^ (mat2)->type) & CV_MAT_DEPTH_MASK) == 0)

§ CV_ARE_SIZES_EQ

#define CV_ARE_SIZES_EQ (   mat1,
  mat2 
)    ((mat1)->rows == (mat2)->rows && (mat1)->cols == (mat2)->cols)

§ CV_ARE_TYPES_EQ

#define CV_ARE_TYPES_EQ (   mat1,
  mat2 
)    ((((mat1)->type ^ (mat2)->type) & CV_MAT_TYPE_MASK) == 0)

§ CV_ATTR_UNUSED

#define CV_ATTR_UNUSED

§ CV_ATTR_USED

#define CV_ATTR_USED

§ CV_AUTO_STEP

#define CV_AUTO_STEP   0x7fffffff

§ CV_BIG_INT

#define CV_BIG_INT (   n)    n##LL

§ CV_BIG_UINT

#define CV_BIG_UINT (   n)    n##ULL

§ CV_CARRAY

#define CV_CARRAY (   counter)

§ CV_CDECL

#define CV_CDECL

§ CV_CMP

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

§ CV_CN_MAX

#define CV_CN_MAX   512

§ CV_CN_SHIFT

#define CV_CN_SHIFT   3

§ CV_CONTOUR_FIELDS

#define CV_CONTOUR_FIELDS ( )
Value:
CvRect rect; \
int color; \
int reserved[3];
#define CV_SEQUENCE_FIELDS()
Definition: core/include/opencv2/core/types_c.h:1358

§ CV_CURRENT_POINT

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

§ CV_CUSTOM_CARRAY

#define CV_CUSTOM_CARRAY (   args)

§ CV_DEFAULT

#define CV_DEFAULT (   val)    = val

§ CV_DEPTH_MAX

#define CV_DEPTH_MAX   (1 << CV_CN_SHIFT)

§ CV_ELEM_SIZE

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

§ CV_ELEM_SIZE1

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

§ CV_ENABLE_UNROLLED

#define CV_ENABLE_UNROLLED   1

§ CV_EXPORTS_AS

#define CV_EXPORTS_AS (   synonym)    CV_EXPORTS

§ CV_EXPORTS_W_MAP

#define CV_EXPORTS_W_MAP   CV_EXPORTS

§ CV_EXPORTS_W_SIMPLE

#define CV_EXPORTS_W_SIMPLE   CV_EXPORTS

§ CV_EXTERN_C

#define CV_EXTERN_C   extern "C"

§ CV_EXTERN_C_FUNCPTR

#define CV_EXTERN_C_FUNCPTR (   x)    extern "C" { typedef x; }

§ CV_GET_SEQ_ELEM

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

§ CV_GRAPH

#define CV_GRAPH   CV_SEQ_KIND_GRAPH

§ CV_GRAPH_EDGE_FIELDS

#define CV_GRAPH_EDGE_FIELDS ( )
Value:
int flags; \
float weight; \
struct CvGraphEdge* next[2]; \
struct CvGraphVtx* vtx[2];
int int int flags
Definition: highgui_c.h:187
Definition: core/include/opencv2/core/types_c.h:1445
Definition: core/include/opencv2/core/types_c.h:1451

§ CV_GRAPH_FIELDS

#define CV_GRAPH_FIELDS ( )
Value:
CvSet* edges;
#define CV_SET_FIELDS()
Definition: core/include/opencv2/core/types_c.h:1395

§ CV_GRAPH_FLAG_ORIENTED

#define CV_GRAPH_FLAG_ORIENTED   (1 << CV_SEQ_FLAG_SHIFT)

§ CV_GRAPH_VERTEX_FIELDS

#define CV_GRAPH_VERTEX_FIELDS ( )
Value:
int flags; \
struct CvGraphEdge* first;
int int int flags
Definition: highgui_c.h:187
Definition: core/include/opencv2/core/types_c.h:1445

§ CV_HIST_ARRAY

#define CV_HIST_ARRAY   0

§ CV_HIST_HAS_RANGES

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

§ CV_HIST_MAGIC_VAL

#define CV_HIST_MAGIC_VAL   0x42450000

§ CV_HIST_RANGES_FLAG

#define CV_HIST_RANGES_FLAG   (1 << 11)

§ CV_HIST_SPARSE

#define CV_HIST_SPARSE   1

§ CV_HIST_TREE

#define CV_HIST_TREE   CV_HIST_SPARSE

§ CV_HIST_UNIFORM

#define CV_HIST_UNIFORM   1

§ CV_HIST_UNIFORM_FLAG

#define CV_HIST_UNIFORM_FLAG   (1 << 10)

§ CV_IABS

#define CV_IABS (   a)    abs(a)

§ CV_IMAGE_ELEM

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

§ CV_IMAX

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

§ CV_IMIN

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

§ CV_IN_OUT

#define CV_IN_OUT

§ CV_INLINE

#define CV_INLINE   inline

§ CV_IS_CONT_MAT

#define CV_IS_CONT_MAT   CV_IS_MAT_CONT

§ CV_IS_GRAPH

#define CV_IS_GRAPH (   seq)    (CV_IS_SET(seq) && CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_GRAPH)

§ CV_IS_GRAPH_ORIENTED

#define CV_IS_GRAPH_ORIENTED (   seq)    (((seq)->flags & CV_GRAPH_FLAG_ORIENTED) != 0)

§ CV_IS_HIST

#define CV_IS_HIST (   hist)
Value:
((hist) != NULL && \
(((CvHistogram*)(hist))->type & CV_MAGIC_MASK) == CV_HIST_MAGIC_VAL && \
(hist)->bins != NULL)
#define CV_HIST_MAGIC_VAL
Definition: core/include/opencv2/core/types_c.h:943
#define CV_MAGIC_MASK
Definition: core/include/opencv2/core/types_c.h:677
Definition: core/include/opencv2/core/types_c.h:957

§ CV_IS_IMAGE

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

§ CV_IS_IMAGE_HDR

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

§ CV_IS_MASK_ARR

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

§ CV_IS_MAT

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

§ CV_IS_MAT_CONST

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

§ CV_IS_MAT_CONT

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

§ CV_IS_MAT_HDR

#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_MAGIC_MASK
Definition: core/include/opencv2/core/types_c.h:677
#define CV_MAT_MAGIC_VAL
Definition: core/include/opencv2/core/types_c.h:678
Definition: core/include/opencv2/core/types_c.h:681

§ CV_IS_MAT_HDR_Z

#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_MAGIC_MASK
Definition: core/include/opencv2/core/types_c.h:677
#define CV_MAT_MAGIC_VAL
Definition: core/include/opencv2/core/types_c.h:678
Definition: core/include/opencv2/core/types_c.h:681

§ CV_IS_MATND

#define CV_IS_MATND (   mat)    (CV_IS_MATND_HDR(mat) && ((const CvMatND*)(mat))->data.ptr != NULL)

§ CV_IS_MATND_HDR

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

§ CV_IS_SEQ

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

§ CV_IS_SEQ_CHAIN

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

§ CV_IS_SEQ_CHAIN_CONTOUR

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

§ CV_IS_SEQ_CLOSED

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

§ CV_IS_SEQ_CONTOUR

#define CV_IS_SEQ_CONTOUR (   seq)    (CV_IS_SEQ_CLOSED(seq) && (CV_IS_SEQ_POLYLINE(seq) || CV_IS_SEQ_CHAIN(seq)))

§ CV_IS_SEQ_CONVEX

#define CV_IS_SEQ_CONVEX (   seq)    0

§ CV_IS_SEQ_CURVE

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

§ CV_IS_SEQ_HOLE

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

§ CV_IS_SEQ_INDEX

#define CV_IS_SEQ_INDEX (   seq)
Value:
#define CV_SEQ_ELTYPE(seq)
Definition: core/include/opencv2/core/types_c.h:1578
#define CV_SEQ_KIND(seq)
Definition: core/include/opencv2/core/types_c.h:1579
#define CV_SEQ_ELTYPE_INDEX
Definition: core/include/opencv2/core/types_c.h:1524
#define CV_SEQ_KIND_GENERIC
Definition: core/include/opencv2/core/types_c.h:1535

§ CV_IS_SEQ_POINT_SET

#define CV_IS_SEQ_POINT_SET (   seq)    ((CV_SEQ_ELTYPE(seq) == CV_32SC2 || CV_SEQ_ELTYPE(seq) == CV_32FC2))

§ CV_IS_SEQ_POINT_SUBSET

#define CV_IS_SEQ_POINT_SUBSET (   seq)    (CV_IS_SEQ_INDEX( seq ) || CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_PPOINT)

§ CV_IS_SEQ_POLYGON

#define CV_IS_SEQ_POLYGON (   seq)    (CV_IS_SEQ_POLYLINE(seq) && CV_IS_SEQ_CLOSED(seq))

§ CV_IS_SEQ_POLYGON_TREE

#define CV_IS_SEQ_POLYGON_TREE (   seq)
Value:
CV_SEQ_KIND( seq ) == CV_SEQ_KIND_BIN_TREE )
#define CV_SEQ_KIND_BIN_TREE
Definition: core/include/opencv2/core/types_c.h:1537
#define CV_SEQ_ELTYPE(seq)
Definition: core/include/opencv2/core/types_c.h:1578
#define CV_SEQ_ELTYPE_TRIAN_ATR
Definition: core/include/opencv2/core/types_c.h:1527

§ CV_IS_SEQ_POLYLINE

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

§ CV_IS_SEQ_SIMPLE

#define CV_IS_SEQ_SIMPLE (   seq)    1

§ CV_IS_SET

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

§ CV_IS_SET_ELEM

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

§ CV_IS_SPARSE_HIST

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

§ CV_IS_SPARSE_MAT

#define CV_IS_SPARSE_MAT (   mat)    CV_IS_SPARSE_MAT_HDR(mat)

§ CV_IS_SPARSE_MAT_HDR

#define CV_IS_SPARSE_MAT_HDR (   mat)
Value:
((mat) != NULL && \
(((const CvSparseMat*)(mat))->type & CV_MAGIC_MASK) == CV_SPARSE_MAT_MAGIC_VAL)
#define CV_MAGIC_MASK
Definition: core/include/opencv2/core/types_c.h:677
Definition: core/include/opencv2/core/types_c.h:894
#define CV_SPARSE_MAT_MAGIC_VAL
Definition: core/include/opencv2/core/types_c.h:889

§ CV_IS_STORAGE

#define CV_IS_STORAGE (   storage)
Value:
((storage) != NULL && \
(((CvMemStorage*)(storage))->signature & CV_MAGIC_MASK) == CV_STORAGE_MAGIC_VAL)
#define CV_MAGIC_MASK
Definition: core/include/opencv2/core/types_c.h:677
Definition: core/include/opencv2/core/types_c.h:1308
#define CV_STORAGE_MAGIC_VAL
Definition: core/include/opencv2/core/types_c.h:1306

§ CV_IS_SUBDIV2D

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

§ CV_IS_SUBMAT

#define CV_IS_SUBMAT (   flags)    ((flags) & CV_MAT_SUBMAT_FLAG)

§ CV_IS_UNIFORM_HIST

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

§ CV_LOG2

#define CV_LOG2   0.69314718055994530941723212145818

§ CV_MAGIC_MASK

#define CV_MAGIC_MASK   0xFFFF0000

§ CV_MAKE_TYPE

#define CV_MAKE_TYPE   CV_MAKETYPE

§ CV_MAKETYPE

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

§ CV_MAT_CN

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

§ CV_MAT_CN_MASK

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

§ CV_MAT_CONT_FLAG

#define CV_MAT_CONT_FLAG   (1 << CV_MAT_CONT_FLAG_SHIFT)

§ CV_MAT_CONT_FLAG_SHIFT

#define CV_MAT_CONT_FLAG_SHIFT   14

§ CV_MAT_DEPTH

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

§ CV_MAT_DEPTH_MASK

#define CV_MAT_DEPTH_MASK   (CV_DEPTH_MAX - 1)

§ CV_MAT_ELEM

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

§ CV_MAT_ELEM_PTR

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

§ CV_MAT_ELEM_PTR_FAST

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

§ CV_MAT_MAGIC_VAL

#define CV_MAT_MAGIC_VAL   0x42420000

§ CV_MAT_TYPE

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

§ CV_MAT_TYPE_MASK

#define CV_MAT_TYPE_MASK   (CV_DEPTH_MAX*CV_CN_MAX - 1)

§ CV_MATND_MAGIC_VAL

#define CV_MATND_MAGIC_VAL   0x42430000

§ CV_MAX_DIM

#define CV_MAX_DIM   32

§ CV_MAX_DIM_HEAP

#define CV_MAX_DIM_HEAP   1024

§ CV_NEXT_GRAPH_EDGE

#define CV_NEXT_GRAPH_EDGE (   edge,
  vertex 
)
Value:
(assert((edge)->vtx[0] == (vertex) || (edge)->vtx[1] == (vertex)), \
(edge)->next[(edge)->vtx[1] == (vertex)])

§ CV_NEXT_SEQ_ELEM

#define CV_NEXT_SEQ_ELEM (   elem_size,
  reader 
)
Value:
{ \
if( ((reader).ptr += (elem_size)) >= (reader).block_max ) \
{ \
cvChangeSeqBlock( &(reader), 1 ); \
} \
}

§ CV_NODE_EMPTY

#define CV_NODE_EMPTY   32

§ CV_NODE_FLOAT

#define CV_NODE_FLOAT   CV_NODE_REAL

§ CV_NODE_FLOW

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

§ CV_NODE_HAS_NAME

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

§ CV_NODE_IDX

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

§ CV_NODE_INT

#define CV_NODE_INT   1

§ CV_NODE_INTEGER

#define CV_NODE_INTEGER   CV_NODE_INT

§ CV_NODE_IS_COLLECTION

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

§ CV_NODE_IS_EMPTY

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

§ CV_NODE_IS_FLOW

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

§ CV_NODE_IS_INT

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

§ CV_NODE_IS_MAP

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

§ CV_NODE_IS_REAL

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

§ CV_NODE_IS_SEQ

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

§ CV_NODE_IS_STRING

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

§ CV_NODE_IS_USER

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

§ CV_NODE_MAP

#define CV_NODE_MAP   6

§ CV_NODE_NAMED

#define CV_NODE_NAMED   64

§ CV_NODE_NONE

#define CV_NODE_NONE   0

§ CV_NODE_REAL

#define CV_NODE_REAL   2

§ CV_NODE_REF

#define CV_NODE_REF   4 /* not used */

§ CV_NODE_SEQ

#define CV_NODE_SEQ   5

§ CV_NODE_SEQ_IS_SIMPLE

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

§ CV_NODE_SEQ_SIMPLE

#define CV_NODE_SEQ_SIMPLE   256

§ CV_NODE_STR

#define CV_NODE_STR   3

§ CV_NODE_STRING

#define CV_NODE_STRING   CV_NODE_STR

§ CV_NODE_TYPE

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

§ CV_NODE_TYPE_MASK

#define CV_NODE_TYPE_MASK   7

§ CV_NODE_USER

#define CV_NODE_USER   16

§ CV_NODE_VAL

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

§ CV_ORIENTED_GRAPH

#define CV_ORIENTED_GRAPH   (CV_SEQ_KIND_GRAPH|CV_GRAPH_FLAG_ORIENTED)

§ CV_OUT

#define CV_OUT

§ CV_PI

#define CV_PI   3.1415926535897932384626433832795

§ CV_PREV_POINT

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

§ CV_PREV_SEQ_ELEM

#define CV_PREV_SEQ_ELEM (   elem_size,
  reader 
)
Value:
{ \
if( ((reader).ptr -= (elem_size)) < (reader).block_min ) \
{ \
cvChangeSeqBlock( &(reader), -1 ); \
} \
}

§ CV_PROP

#define CV_PROP

§ CV_PROP_RW

#define CV_PROP_RW

§ CV_READ_CHAIN_POINT

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

§ CV_READ_EDGE

#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_PREV_POINT(reader)
Definition: core/include/opencv2/core/types_c.h:1749
#define CV_CURRENT_POINT(reader)
Definition: core/include/opencv2/core/types_c.h:1748
Definition: core/include/opencv2/core/types_c.h:1057

§ CV_READ_SEQ_ELEM

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

§ CV_REV_READ_SEQ_ELEM

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

§ CV_RNG_COEFF

#define CV_RNG_COEFF   4164903690U

§ CV_SEQ_CHAIN

#define CV_SEQ_CHAIN   (CV_SEQ_KIND_CURVE | CV_SEQ_ELTYPE_CODE)

§ CV_SEQ_CHAIN_CONTOUR

#define CV_SEQ_CHAIN_CONTOUR   (CV_SEQ_FLAG_CLOSED | CV_SEQ_CHAIN)

§ CV_SEQ_CONNECTED_COMP

#define CV_SEQ_CONNECTED_COMP   (CV_SEQ_KIND_GENERIC | CV_SEQ_ELTYPE_CONNECTED_COMP)

§ CV_SEQ_CONTOUR

#define CV_SEQ_CONTOUR   CV_SEQ_POLYGON

§ CV_SEQ_ELEM

#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) )))
schar * cvGetSeqElem(const CvSeq *seq, int index)
Definition: core/include/opencv2/core/types_c.h:1334
Definition: core/include/opencv2/core/types_c.h:1369

§ CV_SEQ_ELTYPE

#define CV_SEQ_ELTYPE (   seq)    ((seq)->flags & CV_SEQ_ELTYPE_MASK)

§ CV_SEQ_ELTYPE_BITS

#define CV_SEQ_ELTYPE_BITS   12

§ CV_SEQ_ELTYPE_CODE

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

§ CV_SEQ_ELTYPE_CONNECTED_COMP

#define CV_SEQ_ELTYPE_CONNECTED_COMP   0 /* connected component */

§ CV_SEQ_ELTYPE_GENERIC

#define CV_SEQ_ELTYPE_GENERIC   0

§ CV_SEQ_ELTYPE_GRAPH_EDGE

#define CV_SEQ_ELTYPE_GRAPH_EDGE   0 /* &next_o, &next_d, &vtx_o, &vtx_d */

§ CV_SEQ_ELTYPE_GRAPH_VERTEX

#define CV_SEQ_ELTYPE_GRAPH_VERTEX   0 /* first_edge, &(x,y) */

§ CV_SEQ_ELTYPE_INDEX

#define CV_SEQ_ELTYPE_INDEX   CV_32SC1 /* #(x,y) */

§ CV_SEQ_ELTYPE_MASK

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

§ CV_SEQ_ELTYPE_POINT

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

§ CV_SEQ_ELTYPE_POINT3D

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

§ CV_SEQ_ELTYPE_PPOINT

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

§ CV_SEQ_ELTYPE_PTR

#define CV_SEQ_ELTYPE_PTR   CV_USRTYPE1

§ CV_SEQ_ELTYPE_TRIAN_ATR

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

§ CV_SEQ_FLAG_CLOSED

#define CV_SEQ_FLAG_CLOSED   (1 << CV_SEQ_FLAG_SHIFT)

§ CV_SEQ_FLAG_CONVEX

#define CV_SEQ_FLAG_CONVEX   (0 << CV_SEQ_FLAG_SHIFT)

§ CV_SEQ_FLAG_HOLE

#define CV_SEQ_FLAG_HOLE   (2 << CV_SEQ_FLAG_SHIFT)

§ CV_SEQ_FLAG_SHIFT

#define CV_SEQ_FLAG_SHIFT   (CV_SEQ_KIND_BITS + CV_SEQ_ELTYPE_BITS)

§ CV_SEQ_FLAG_SIMPLE

#define CV_SEQ_FLAG_SIMPLE   (0 << CV_SEQ_FLAG_SHIFT)

§ CV_SEQ_INDEX

#define CV_SEQ_INDEX   (CV_SEQ_KIND_GENERIC | CV_SEQ_ELTYPE_INDEX)

§ CV_SEQ_KIND

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

§ CV_SEQ_KIND_BIN_TREE

#define CV_SEQ_KIND_BIN_TREE   (2 << CV_SEQ_ELTYPE_BITS)

§ CV_SEQ_KIND_BITS

#define CV_SEQ_KIND_BITS   2

§ CV_SEQ_KIND_CURVE

#define CV_SEQ_KIND_CURVE   (1 << CV_SEQ_ELTYPE_BITS)

§ CV_SEQ_KIND_GENERIC

#define CV_SEQ_KIND_GENERIC   (0 << CV_SEQ_ELTYPE_BITS)

§ CV_SEQ_KIND_GRAPH

#define CV_SEQ_KIND_GRAPH   (1 << CV_SEQ_ELTYPE_BITS)

§ CV_SEQ_KIND_MASK

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

§ CV_SEQ_KIND_SUBDIV2D

#define CV_SEQ_KIND_SUBDIV2D   (2 << CV_SEQ_ELTYPE_BITS)

§ CV_SEQ_MAGIC_VAL

#define CV_SEQ_MAGIC_VAL   0x42990000

§ CV_SEQ_POINT3D_SET

#define CV_SEQ_POINT3D_SET   (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT3D)

§ CV_SEQ_POINT_SET

#define CV_SEQ_POINT_SET   (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT)

§ CV_SEQ_POLYGON

#define CV_SEQ_POLYGON   (CV_SEQ_FLAG_CLOSED | CV_SEQ_POLYLINE )

§ CV_SEQ_POLYGON_TREE

#define CV_SEQ_POLYGON_TREE   (CV_SEQ_KIND_BIN_TREE | CV_SEQ_ELTYPE_TRIAN_ATR)

§ CV_SEQ_POLYLINE

#define CV_SEQ_POLYLINE   (CV_SEQ_KIND_CURVE | CV_SEQ_ELTYPE_POINT)

§ CV_SEQ_READER_FIELDS

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

§ CV_SEQ_SIMPLE_POLYGON

#define CV_SEQ_SIMPLE_POLYGON   (CV_SEQ_FLAG_SIMPLE | CV_SEQ_POLYGON )

§ CV_SEQ_WRITER_FIELDS

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

§ CV_SEQUENCE_FIELDS

#define CV_SEQUENCE_FIELDS ( )
Value:
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_TREE_NODE_FIELDS(node_type)
Definition: core/include/opencv2/core/types_c.h:1346
Definition: core/include/opencv2/core/types_c.h:1369

§ CV_SET_ELEM_FIELDS

#define CV_SET_ELEM_FIELDS (   elem_type)
Value:
int flags; \
struct elem_type* next_free;
int int int flags
Definition: highgui_c.h:187

§ CV_SET_ELEM_FREE_FLAG

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

§ CV_SET_ELEM_IDX_MASK

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

§ CV_SET_FIELDS

#define CV_SET_FIELDS ( )
Value:
CvSetElem* free_elems; \
int active_count;
#define CV_SEQUENCE_FIELDS()
Definition: core/include/opencv2/core/types_c.h:1358

§ CV_SET_MAGIC_VAL

#define CV_SET_MAGIC_VAL   0x42980000

§ CV_SIGN

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

§ CV_SPARSE_MAT_MAGIC_VAL

#define CV_SPARSE_MAT_MAGIC_VAL   0x42440000

§ CV_STDCALL

#define CV_STDCALL

§ CV_STORAGE_APPEND

#define CV_STORAGE_APPEND   2

§ CV_STORAGE_FORMAT_AUTO

#define CV_STORAGE_FORMAT_AUTO   0

§ CV_STORAGE_FORMAT_MASK

#define CV_STORAGE_FORMAT_MASK   (7<<3)

§ CV_STORAGE_FORMAT_XML

#define CV_STORAGE_FORMAT_XML   8

§ CV_STORAGE_FORMAT_YAML

#define CV_STORAGE_FORMAT_YAML   16

§ CV_STORAGE_MAGIC_VAL

#define CV_STORAGE_MAGIC_VAL   0x42890000

§ CV_STORAGE_MEMORY

#define CV_STORAGE_MEMORY   4

§ CV_STORAGE_READ

#define CV_STORAGE_READ   0

§ CV_STORAGE_WRITE

#define CV_STORAGE_WRITE   1

§ CV_STORAGE_WRITE_BINARY

#define CV_STORAGE_WRITE_BINARY   CV_STORAGE_WRITE

§ CV_STORAGE_WRITE_TEXT

#define CV_STORAGE_WRITE_TEXT   CV_STORAGE_WRITE

§ CV_SUBMAT_FLAG

#define CV_SUBMAT_FLAG   (1 << CV_SUBMAT_FLAG_SHIFT)

§ CV_SUBMAT_FLAG_SHIFT

#define CV_SUBMAT_FLAG_SHIFT   15

§ CV_SWAP

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

§ CV_TERMCRIT_EPS

#define CV_TERMCRIT_EPS   2

§ CV_TERMCRIT_ITER

#define CV_TERMCRIT_ITER   1

§ CV_TERMCRIT_NUMBER

#define CV_TERMCRIT_NUMBER   CV_TERMCRIT_ITER

§ CV_TREE_NODE_FIELDS

#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. */
int int int flags
Definition: highgui_c.h:187

§ CV_TYPE_NAME_GRAPH

#define CV_TYPE_NAME_GRAPH   "opencv-graph"

§ CV_TYPE_NAME_IMAGE

#define CV_TYPE_NAME_IMAGE   "opencv-image"

§ CV_TYPE_NAME_MAT

#define CV_TYPE_NAME_MAT   "opencv-matrix"

§ CV_TYPE_NAME_MATND

#define CV_TYPE_NAME_MATND   "opencv-nd-matrix"

§ CV_TYPE_NAME_SEQ

#define CV_TYPE_NAME_SEQ   "opencv-sequence"

§ CV_TYPE_NAME_SEQ_TREE

#define CV_TYPE_NAME_SEQ_TREE   "opencv-sequence-tree"

§ CV_TYPE_NAME_SPARSE_MAT

#define CV_TYPE_NAME_SPARSE_MAT   "opencv-sparse-matrix"

§ CV_USRTYPE1

#define CV_USRTYPE1   7

§ CV_VFP

#define CV_VFP   0

§ CV_WHOLE_ARR

#define CV_WHOLE_ARR   cvSlice( 0, 0x3fffffff )

§ CV_WHOLE_SEQ

#define CV_WHOLE_SEQ   cvSlice(0, CV_WHOLE_SEQ_END_INDEX)

§ CV_WHOLE_SEQ_END_INDEX

#define CV_WHOLE_SEQ_END_INDEX   0x3fffffff

§ CV_WRAP_DEFAULT

#define CV_WRAP_DEFAULT (   value)

§ CV_WRITE_SEQ_ELEM

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

§ CV_WRITE_SEQ_ELEM_VAR

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

§ cvInvSqrt

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

§ cvSqrt

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

§ IPL2CV_DEPTH

#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_DEPTH_SIGN
Definition: core/include/opencv2/core/types_c.h:471
#define CV_64F
Definition: core/include/opencv2/core/types_c.h:611
#define CV_8S
Definition: core/include/opencv2/core/types_c.h:606
#define CV_16S
Definition: core/include/opencv2/core/types_c.h:608
#define CV_32F
Definition: core/include/opencv2/core/types_c.h:610
#define CV_16U
Definition: core/include/opencv2/core/types_c.h:607
#define CV_8U
Definition: core/include/opencv2/core/types_c.h:605

§ IPL_ALIGN_16BYTES

#define IPL_ALIGN_16BYTES   16

§ IPL_ALIGN_32BYTES

#define IPL_ALIGN_32BYTES   32

§ IPL_ALIGN_4BYTES

#define IPL_ALIGN_4BYTES   4

§ IPL_ALIGN_8BYTES

#define IPL_ALIGN_8BYTES   8

§ IPL_ALIGN_DWORD

#define IPL_ALIGN_DWORD   IPL_ALIGN_4BYTES

§ IPL_ALIGN_QWORD

#define IPL_ALIGN_QWORD   IPL_ALIGN_8BYTES

§ IPL_BORDER_CONSTANT

#define IPL_BORDER_CONSTANT   0

§ IPL_BORDER_REFLECT

#define IPL_BORDER_REFLECT   2

§ IPL_BORDER_REFLECT_101

#define IPL_BORDER_REFLECT_101   4

§ IPL_BORDER_REPLICATE

#define IPL_BORDER_REPLICATE   1

§ IPL_BORDER_TRANSPARENT

#define IPL_BORDER_TRANSPARENT   5

§ IPL_BORDER_WRAP

#define IPL_BORDER_WRAP   3

§ IPL_DATA_ORDER_PIXEL

#define IPL_DATA_ORDER_PIXEL   0

§ IPL_DATA_ORDER_PLANE

#define IPL_DATA_ORDER_PLANE   1

§ IPL_DEPTH_16S

#define IPL_DEPTH_16S   (IPL_DEPTH_SIGN|16)

§ IPL_DEPTH_16U

#define IPL_DEPTH_16U   16

§ IPL_DEPTH_1U

#define IPL_DEPTH_1U   1

§ IPL_DEPTH_32F

#define IPL_DEPTH_32F   32

§ IPL_DEPTH_32S

#define IPL_DEPTH_32S   (IPL_DEPTH_SIGN|32)

§ IPL_DEPTH_64F

#define IPL_DEPTH_64F   64

§ IPL_DEPTH_8S

#define IPL_DEPTH_8S   (IPL_DEPTH_SIGN| 8)

§ IPL_DEPTH_8U

#define IPL_DEPTH_8U   8

§ IPL_DEPTH_SIGN

#define IPL_DEPTH_SIGN   0x80000000

§ IPL_IMAGE_DATA

#define IPL_IMAGE_DATA   2

§ IPL_IMAGE_HEADER

#define IPL_IMAGE_HEADER   1

§ IPL_IMAGE_MAGIC_VAL

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

§ IPL_IMAGE_ROI

#define IPL_IMAGE_ROI   4

§ IPL_ORIGIN_BL

#define IPL_ORIGIN_BL   1

§ IPL_ORIGIN_TL

#define IPL_ORIGIN_TL   0

§ MAX

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

§ MIN

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

Typedef Documentation

§ CvArr

typedef void CvArr

§ CvCloneFunc

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

§ CvFileNodeHash

typedef struct CvGenericHash CvFileNodeHash

§ CvFileStorage

typedef struct CvFileStorage CvFileStorage

§ CvHistType

typedef int CvHistType

§ CvIsInstanceFunc

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

§ CvPoint2DSeq

§ CvReadFunc

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

§ CvReleaseFunc

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

§ CvRNG

typedef uint64 CvRNG

§ CVStatus

typedef int CVStatus

§ CvWriteFunc

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

§ int64

typedef int64_t int64

§ IplTileInfo

typedef struct _IplTileInfo IplTileInfo

§ schar

typedef signed char schar

§ uchar

typedef unsigned char uchar

§ uint64

typedef uint64_t uint64

§ ushort

typedef unsigned short ushort

Enumeration Type Documentation

§ anonymous enum

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_OpenGlNotSupported 
CV_OpenGlApiCallError 
CV_OpenCLDoubleNotSupported 
CV_OpenCLInitError 
CV_OpenCLNoAMDBlasFft 

Function Documentation

§ cvAttrList()

CvAttrList cvAttrList ( const char **  attr = NULL,
CvAttrList next = NULL 
)
inline

§ cvCeil()

int cvCeil ( double  value)
inline

§ cvFloor()

int cvFloor ( double  value)
inline

§ cvIplDepth()

int cvIplDepth ( int  type)
inline

§ cvIsInf()

int cvIsInf ( double  value)
inline

§ cvIsNaN()

int cvIsNaN ( double  value)
inline

§ cvMat()

CvMat cvMat ( int  rows,
int  cols,
int  type,
void data = NULL 
)
inline

§ cvmGet()

double cvmGet ( const CvMat mat,
int  row,
int  col 
)
inline

§ cvmSet()

void cvmSet ( CvMat mat,
int  row,
int  col,
double  value 
)
inline

§ cvPoint()

CvPoint cvPoint ( int  x,
int  y 
)
inline

§ cvPoint2D32f()

CvPoint2D32f cvPoint2D32f ( double  x,
double  y 
)
inline

§ cvPoint2D64f()

CvPoint2D64f cvPoint2D64f ( double  x,
double  y 
)
inline

§ cvPoint3D32f()

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

§ cvPoint3D64f()

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

§ cvPointFrom32f()

CvPoint cvPointFrom32f ( CvPoint2D32f  point)
inline

§ cvPointTo32f()

CvPoint2D32f cvPointTo32f ( CvPoint  point)
inline

§ cvRandInt()

unsigned cvRandInt ( CvRNG rng)
inline

§ cvRandReal()

double cvRandReal ( CvRNG rng)
inline

§ cvRealScalar()

CvScalar cvRealScalar ( double  val0)
inline

§ cvRect()

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

§ cvRectToROI()

IplROI cvRectToROI ( CvRect  rect,
int  coi 
)
inline

§ cvRNG()

CvRNG cvRNG ( int64  seed = -1)
inline

§ cvROIToRect()

CvRect cvROIToRect ( IplROI  roi)
inline

§ cvRound()

int cvRound ( double  value)
inline

§ cvScalar()

CvScalar cvScalar ( double  val0,
double  val1 = 0,
double  val2 = 0,
double  val3 = 0 
)
inline

§ cvScalarAll()

CvScalar cvScalarAll ( double  val0123)
inline

§ cvSize()

CvSize cvSize ( int  width,
int  height 
)
inline

§ cvSize2D32f()

CvSize2D32f cvSize2D32f ( double  width,
double  height 
)
inline

§ cvSlice()

CvSlice cvSlice ( int  start,
int  end 
)
inline

§ cvTermCriteria()

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