OpenCV  3.4.7
Open Source Computer Vision
Classes | Macros | Typedefs | Enumerations | Functions
types_c.h File Reference
#include "opencv2/core/cvdef.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>
#include "opencv2/core.hpp"

Classes

struct  CvAttrList
 List of attributes. : More...
 
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
 Type information. More...
 
struct  IplConvKernel
 
struct  IplConvKernelFP
 
struct  IplImage
 
struct  IplROI
 

Macros

#define CV_ARE_CNS_EQ(mat1, mat2)   ((((mat1)->type ^ (mat2)->type) & CV_MAT_CN_MASK) == 0)
 
#define CV_ARE_DEPTHS_EQ(mat1, mat2)   ((((mat1)->type ^ (mat2)->type) & CV_MAT_DEPTH_MASK) == 0)
 
#define CV_ARE_SIZES_EQ(mat1, mat2)   ((mat1)->rows == (mat2)->rows && (mat1)->cols == (mat2)->cols)
 
#define CV_ARE_TYPES_EQ(mat1, mat2)   ((((mat1)->type ^ (mat2)->type) & CV_MAT_TYPE_MASK) == 0)
 
#define CV_AUTO_STEP   0x7fffffff
 
#define CV_CDECL
 
#define CV_CMP(a, b)   (((a) > (b)) - ((a) < (b)))
 
#define CV_CONTOUR_FIELDS()
 
#define CV_CURRENT_POINT(reader)   (*((CvPoint*)((reader).ptr)))
 
#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_FLAG_ORIENTED   (1 << CV_SEQ_FLAG_SHIFT)
 
#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_IMPL   CV_EXTERN_C
 
#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_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_UNIFORM_HIST(hist)   (((hist)->type & CV_HIST_UNIFORM_FLAG) != 0)
 
#define CV_MAGIC_MASK   0xFFFF0000
 
#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_MATND_MAGIC_VAL   0x42430000
 
#define CV_MAX_DIM   32
 
#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_PREV_POINT(reader)   (*((CvPoint*)((reader).prev_elem)))
 
#define CV_PREV_SEQ_ELEM(elem_size, reader)
 
#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_RNG_COEFF   4164903690U
 
#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)
 Set Order is not preserved. There can be gaps between sequence elements. After the element has been inserted it stays in the same place all the time. The MSB(most-significant or sign bit) of the first field (flags) is 0 iff the element exists. More...
 
#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_BASE64   64
 
#define CV_STORAGE_FORMAT_AUTO   0
 
#define CV_STORAGE_FORMAT_JSON   24
 
#define CV_STORAGE_FORMAT_MASK   (7<<3)
 
#define CV_STORAGE_FORMAT_XML   8
 
#define CV_STORAGE_FORMAT_YAML   16
 
#define CV_STORAGE_MAGIC_VAL   0x42890000
 
#define CV_STORAGE_MEMORY   4
 
#define CV_STORAGE_READ   0
 
#define CV_STORAGE_WRITE   1
 
#define CV_STORAGE_WRITE_BASE64   (CV_STORAGE_BASE64 | CV_STORAGE_WRITE)
 
#define CV_STORAGE_WRITE_BINARY   CV_STORAGE_WRITE
 
#define CV_STORAGE_WRITE_TEXT   CV_STORAGE_WRITE
 
#define CV_STRUCT_INITIALIZER   {}
 
#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_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_WHOLE_ARR   cvSlice( 0, 0x3fffffff )
 
#define CV_WHOLE_SEQ   cvSlice(0, CV_WHOLE_SEQ_END_INDEX)
 
#define CV_WHOLE_SEQ_END_INDEX   0x3fffffff
 
#define CV_WRITE_SEQ_ELEM(elem, writer)
 
#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
 
Graph

We represent a graph as a set of vertices. Vertices contain their adjacency lists (more exactly, pointers to first incoming or outcoming edge (or 0 if isolated vertex)). Edges are stored in another set. There is a singly-linked list of incoming/outcoming edges for each vertex.

Each edge consists of:

  • Two pointers to the starting and ending vertices (vtx[0] and vtx[1] respectively).

    A graph may be oriented or not. In the latter case, edges between vertex i to vertex j are not distinguished during search operations.

  • Two pointers to next edges for the starting and ending vertices, where next[0] points to the next edge in the vtx[0] adjacency list and next[1] points to the next edge in the vtx[1] adjacency list.
See also
CvGraphEdge, CvGraphVtx, CvGraphVtx2D, CvGraph
#define CV_GRAPH_EDGE_FIELDS()
 
#define CV_GRAPH_VERTEX_FIELDS()
 
#define CV_GRAPH_FIELDS()
 
#define CV_TYPE_NAME_GRAPH   "opencv-graph"
 

Typedefs

typedef void CvArr
 This is the "metatype" used only as a function parameter. More...
 
typedef void *(* CvCloneFunc) (const void *struct_ptr)
 
typedef struct CvGenericHash CvFileNodeHash
 
typedef struct CvFileStorage CvFileStorage
 
typedef int CvHistType
 
typedef int(* CvIsInstanceFunc) (const void *struct_ptr)
 
typedef CvContour CvPoint2DSeq
 
typedef void *(* CvReadFunc) (CvFileStorage *storage, CvFileNode *node)
 
typedef void(* CvReleaseFunc) (void **struct_dblptr)
 
typedef uint64 CvRNG
 
typedef int CVStatus
 
typedef void(* CvWriteFunc) (CvFileStorage *storage, const char *name, const void *struct_ptr, CvAttrList attributes)
 
typedef struct _IplImage IplImage
 
typedef struct _IplTileInfo IplTileInfo
 

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_OpenCLApiCallError = -220,
  CV_OpenCLDoubleNotSupported = -221,
  CV_OpenCLInitError = -222,
  CV_OpenCLNoAMDBlasFft = -223
}
 

Functions

CvAttrList cvAttrList (const char **attr=NULL, CvAttrList *next=NULL)
 
CvBox2D cvBox2D (CvPoint2D32f c=CvPoint2D32f(), CvSize2D32f s=CvSize2D32f(), float a=0)
 
CvBox2D cvBox2D (const cv::RotatedRect &rr)
 
CvSparseMatcvCreateSparseMat (const cv::SparseMat &m)
 
int cvIplDepth (int type)
 
_IplImage cvIplImage (const cv::Mat &m)
 
IplImage cvIplImage ()
 
CvMat cvMat (const cv::Mat &m)
 
CvMat cvMat (int rows, int cols, int type, void *data=NULL)
 
CvMat cvMat ()
 
CvMat cvMat (const CvMat &m)
 
CvMatND cvMatND (const cv::Mat &m)
 
CvMatND cvMatND ()
 
double cvmGet (const CvMat *mat, int row, int col)
 Returns the particular element of single-channel floating-point matrix. More...
 
void cvmSet (CvMat *mat, int row, int col, double value)
 Sets a specific element of a single-channel floating-point matrix. More...
 
CvPoint cvPoint (int x, int y)
 
CvPoint cvPoint (const cv::Point &pt)
 
CvPoint2D32f cvPoint2D32f (double x, double y)
 
template<typename _Tp >
CvPoint2D32f cvPoint2D32f (const cv::Point_< _Tp > &pt)
 
CvPoint2D64f cvPoint2D64f (double x, double y)
 
CvPoint3D32f cvPoint3D32f (double x, double y, double z)
 
template<typename _Tp >
CvPoint3D32f cvPoint3D32f (const cv::Point3_< _Tp > &pt)
 
CvPoint3D64f cvPoint3D64f (double x, double y, double z)
 
CvPoint cvPointFrom32f (CvPoint2D32f point)
 
CvPoint2D32f cvPointTo32f (CvPoint point)
 
unsigned cvRandInt (CvRNG *rng)
 Returns a 32-bit unsigned integer and updates RNG. More...
 
double cvRandReal (CvRNG *rng)
 Returns a floating-point random number and updates RNG. More...
 
CvScalar cvRealScalar (double val0)
 
CvRect cvRect (int x, int y, int width, int height)
 
CvRect cvRect (const cv::Rect &rc)
 
IplROI cvRectToROI (CvRect rect, int coi)
 
CvRNG cvRNG (int64 seed=-1)
 Initializes a random number generator state. More...
 
CvRect cvROIToRect (IplROI roi)
 
CvScalar cvScalar (double val0, double val1=0, double val2=0, double val3=0)
 
CvScalar cvScalar ()
 
CvScalar cvScalar (const cv::Scalar &s)
 
CvScalar cvScalarAll (double val0123)
 
CvSize cvSize (int width, int height)
 
CvSize cvSize (const cv::Size &sz)
 
CvSize2D32f cvSize2D32f (double width, double height)
 
template<typename _Tp >
CvSize2D32f cvSize2D32f (const cv::Size_< _Tp > &sz)
 
CvSlice cvSlice (int start, int end)
 
CvSlice cvSlice (const cv::Range &r)
 
CvTermCriteria cvTermCriteria (int type, int max_iter, double epsilon)
 
CvTermCriteria cvTermCriteria (const cv::TermCriteria &t)
 

Macro Definition Documentation

§ CV_CDECL

#define CV_CDECL

§ CV_EXTERN_C_FUNCPTR

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

§ CV_IMPL

#define CV_IMPL   CV_EXTERN_C

§ CV_STDCALL

#define CV_STDCALL

§ CV_STRUCT_INITIALIZER

#define CV_STRUCT_INITIALIZER   {}