OpenCV453
core_c.h
1/*M///////////////////////////////////////////////////////////////////////////////////////
2//
3// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4//
5// By downloading, copying, installing or using the software you agree to this license.
6// If you do not agree to this license, do not download, install,
7// copy or use the software.
8//
9//
10// License Agreement
11// For Open Source Computer Vision Library
12//
13// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
14// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
15// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
16// Third party copyrights are property of their respective owners.
17//
18// Redistribution and use in source and binary forms, with or without modification,
19// are permitted provided that the following conditions are met:
20//
21// * Redistribution's of source code must retain the above copyright notice,
22// this list of conditions and the following disclaimer.
23//
24// * Redistribution's in binary form must reproduce the above copyright notice,
25// this list of conditions and the following disclaimer in the documentation
26// and/or other materials provided with the distribution.
27//
28// * The name of the copyright holders may not be used to endorse or promote products
29// derived from this software without specific prior written permission.
30//
31// This software is provided by the copyright holders and contributors "as is" and
32// any express or implied warranties, including, but not limited to, the implied
33// warranties of merchantability and fitness for a particular purpose are disclaimed.
34// In no event shall the Intel Corporation or contributors be liable for any direct,
35// indirect, incidental, special, exemplary, or consequential damages
36// (including, but not limited to, procurement of substitute goods or services;
37// loss of use, data, or profits; or business interruption) however caused
38// and on any theory of liability, whether in contract, strict liability,
39// or tort (including negligence or otherwise) arising in any way out of
40// the use of this software, even if advised of the possibility of such damage.
41//
42//M*/
43
44
45#ifndef OPENCV_CORE_C_H
46#define OPENCV_CORE_C_H
47
48#include "opencv2/core/types_c.h"
49
50#ifdef __cplusplus
51# ifdef _MSC_VER
52/* disable warning C4190: 'function' has C-linkage specified, but returns UDT 'typename'
53 which is incompatible with C
54
55 It is OK to disable it because we only extend few plain structures with
56 C++ constructors for simpler interoperability with C++ API of the library
57*/
58# pragma warning(disable:4190)
59# elif defined __clang__ && __clang_major__ >= 3
60# pragma GCC diagnostic ignored "-Wreturn-type-c-linkage"
61# endif
62#endif
63
64#ifdef __cplusplus
65extern "C" {
66#endif
67
72/****************************************************************************************\
73* Array allocation, deallocation, initialization and access to elements *
74\****************************************************************************************/
75
80CVAPI(void*) cvAlloc( size_t size );
81
88CVAPI(void) cvFree_( void* ptr );
89#define cvFree(ptr) (cvFree_(*(ptr)), *(ptr)=0)
90
97CVAPI(IplImage*) cvCreateImageHeader( CvSize size, int depth, int channels );
98
109CVAPI(IplImage*) cvInitImageHeader( IplImage* image, CvSize size, int depth,
110 int channels, int origin CV_DEFAULT(0),
111 int align CV_DEFAULT(4));
112
125CVAPI(IplImage*) cvCreateImage( CvSize size, int depth, int channels );
126
140CVAPI(void) cvReleaseImageHeader( IplImage** image );
141
154CVAPI(void) cvReleaseImage( IplImage** image );
155
157CVAPI(IplImage*) cvCloneImage( const IplImage* image );
158
169CVAPI(void) cvSetImageCOI( IplImage* image, int coi );
170
177CVAPI(int) cvGetImageCOI( const IplImage* image );
178
190CVAPI(void) cvSetImageROI( IplImage* image, CvRect rect );
191
201CVAPI(void) cvResetImageROI( IplImage* image );
202
208CVAPI(CvRect) cvGetImageROI( const IplImage* image );
209
218CVAPI(CvMat*) cvCreateMatHeader( int rows, int cols, int type );
219
220#define CV_AUTOSTEP 0x7fffffff
221
254CVAPI(CvMat*) cvInitMatHeader( CvMat* mat, int rows, int cols,
255 int type, void* data CV_DEFAULT(NULL),
256 int step CV_DEFAULT(CV_AUTOSTEP) );
257
272CVAPI(CvMat*) cvCreateMat( int rows, int cols, int type );
273
285CVAPI(void) cvReleaseMat( CvMat** mat );
286
298CV_INLINE void cvDecRefData( CvArr* arr )
299{
300 if( CV_IS_MAT( arr ))
301 {
302 CvMat* mat = (CvMat*)arr;
303 mat->data.ptr = NULL;
304 if( mat->refcount != NULL && --*mat->refcount == 0 )
305 cvFree( &mat->refcount );
306 mat->refcount = NULL;
307 }
308 else if( CV_IS_MATND( arr ))
309 {
310 CvMatND* mat = (CvMatND*)arr;
311 mat->data.ptr = NULL;
312 if( mat->refcount != NULL && --*mat->refcount == 0 )
313 cvFree( &mat->refcount );
314 mat->refcount = NULL;
315 }
316}
317
324CV_INLINE int cvIncRefData( CvArr* arr )
325{
326 int refcount = 0;
327 if( CV_IS_MAT( arr ))
328 {
329 CvMat* mat = (CvMat*)arr;
330 if( mat->refcount != NULL )
331 refcount = ++*mat->refcount;
332 }
333 else if( CV_IS_MATND( arr ))
334 {
335 CvMatND* mat = (CvMatND*)arr;
336 if( mat->refcount != NULL )
337 refcount = ++*mat->refcount;
338 }
339 return refcount;
340}
341
342
344CVAPI(CvMat*) cvCloneMat( const CvMat* mat );
345
346
357CVAPI(CvMat*) cvGetSubRect( const CvArr* arr, CvMat* submat, CvRect rect );
358#define cvGetSubArr cvGetSubRect
359
371CVAPI(CvMat*) cvGetRows( const CvArr* arr, CvMat* submat,
372 int start_row, int end_row,
373 int delta_row CV_DEFAULT(1));
374
380CV_INLINE CvMat* cvGetRow( const CvArr* arr, CvMat* submat, int row )
381{
382 return cvGetRows( arr, submat, row, row + 1, 1 );
383}
384
385
398CVAPI(CvMat*) cvGetCols( const CvArr* arr, CvMat* submat,
399 int start_col, int end_col );
400
406CV_INLINE CvMat* cvGetCol( const CvArr* arr, CvMat* submat, int col )
407{
408 return cvGetCols( arr, submat, col, col + 1 );
409}
410
420CVAPI(CvMat*) cvGetDiag( const CvArr* arr, CvMat* submat,
421 int diag CV_DEFAULT(0));
422
424CVAPI(void) cvScalarToRawData( const CvScalar* scalar, void* data, int type,
425 int extend_to_12 CV_DEFAULT(0) );
426
427CVAPI(void) cvRawDataToScalar( const void* data, int type, CvScalar* scalar );
428
437CVAPI(CvMatND*) cvCreateMatNDHeader( int dims, const int* sizes, int type );
438
451CVAPI(CvMatND*) cvCreateMatND( int dims, const int* sizes, int type );
452
461CVAPI(CvMatND*) cvInitMatNDHeader( CvMatND* mat, int dims, const int* sizes,
462 int type, void* data CV_DEFAULT(NULL) );
463
475CV_INLINE void cvReleaseMatND( CvMatND** mat )
476{
477 cvReleaseMat( (CvMat**)mat );
478}
479
481CVAPI(CvMatND*) cvCloneMatND( const CvMatND* mat );
482
492CVAPI(CvSparseMat*) cvCreateSparseMat( int dims, const int* sizes, int type );
493
499CVAPI(void) cvReleaseSparseMat( CvSparseMat** mat );
500
502CVAPI(CvSparseMat*) cvCloneSparseMat( const CvSparseMat* mat );
503
511CVAPI(CvSparseNode*) cvInitSparseMatIterator( const CvSparseMat* mat,
512 CvSparseMatIterator* mat_iterator );
513
542CV_INLINE CvSparseNode* cvGetNextSparseNode( CvSparseMatIterator* mat_iterator )
543{
544 if( mat_iterator->node->next )
545 return mat_iterator->node = mat_iterator->node->next;
546 else
547 {
548 int idx;
549 for( idx = ++mat_iterator->curidx; idx < mat_iterator->mat->hashsize; idx++ )
550 {
551 CvSparseNode* node = (CvSparseNode*)mat_iterator->mat->hashtable[idx];
552 if( node )
553 {
554 mat_iterator->curidx = idx;
555 return mat_iterator->node = node;
556 }
557 }
558 return NULL;
559 }
560}
561
562
563#define CV_MAX_ARR 10
564
566typedef struct CvNArrayIterator
567{
568 int count;
569 int dims;
570 CvSize size;
571 uchar* ptr[CV_MAX_ARR];
572 int stack[CV_MAX_DIM];
573 CvMatND* hdr[CV_MAX_ARR];
575}
576CvNArrayIterator;
577
578#define CV_NO_DEPTH_CHECK 1
579#define CV_NO_CN_CHECK 2
580#define CV_NO_SIZE_CHECK 4
581
585CVAPI(int) cvInitNArrayIterator( int count, CvArr** arrs,
586 const CvArr* mask, CvMatND* stubs,
587 CvNArrayIterator* array_iterator,
588 int flags CV_DEFAULT(0) );
589
591CVAPI(int) cvNextNArraySlice( CvNArrayIterator* array_iterator );
592
593
604CVAPI(int) cvGetElemType( const CvArr* arr );
605
622CVAPI(int) cvGetDims( const CvArr* arr, int* sizes CV_DEFAULT(NULL) );
623
624
631CVAPI(int) cvGetDimSize( const CvArr* arr, int index );
632
633
649CVAPI(uchar*) cvPtr1D( const CvArr* arr, int idx0, int* type CV_DEFAULT(NULL));
651CVAPI(uchar*) cvPtr2D( const CvArr* arr, int idx0, int idx1, int* type CV_DEFAULT(NULL) );
653CVAPI(uchar*) cvPtr3D( const CvArr* arr, int idx0, int idx1, int idx2,
654 int* type CV_DEFAULT(NULL));
665CVAPI(uchar*) cvPtrND( const CvArr* arr, const int* idx, int* type CV_DEFAULT(NULL),
666 int create_node CV_DEFAULT(1),
667 unsigned* precalc_hashval CV_DEFAULT(NULL));
668
676CVAPI(CvScalar) cvGet1D( const CvArr* arr, int idx0 );
678CVAPI(CvScalar) cvGet2D( const CvArr* arr, int idx0, int idx1 );
680CVAPI(CvScalar) cvGet3D( const CvArr* arr, int idx0, int idx1, int idx2 );
685CVAPI(CvScalar) cvGetND( const CvArr* arr, const int* idx );
686
698CVAPI(double) cvGetReal1D( const CvArr* arr, int idx0 );
700CVAPI(double) cvGetReal2D( const CvArr* arr, int idx0, int idx1 );
702CVAPI(double) cvGetReal3D( const CvArr* arr, int idx0, int idx1, int idx2 );
707CVAPI(double) cvGetRealND( const CvArr* arr, const int* idx );
708
717CVAPI(void) cvSet1D( CvArr* arr, int idx0, CvScalar value );
719CVAPI(void) cvSet2D( CvArr* arr, int idx0, int idx1, CvScalar value );
721CVAPI(void) cvSet3D( CvArr* arr, int idx0, int idx1, int idx2, CvScalar value );
727CVAPI(void) cvSetND( CvArr* arr, const int* idx, CvScalar value );
728
740CVAPI(void) cvSetReal1D( CvArr* arr, int idx0, double value );
742CVAPI(void) cvSetReal2D( CvArr* arr, int idx0, int idx1, double value );
744CVAPI(void) cvSetReal3D( CvArr* arr, int idx0,
745 int idx1, int idx2, double value );
751CVAPI(void) cvSetRealND( CvArr* arr, const int* idx, double value );
752
755CVAPI(void) cvClearND( CvArr* arr, const int* idx );
756
779CVAPI(CvMat*) cvGetMat( const CvArr* arr, CvMat* header,
780 int* coi CV_DEFAULT(NULL),
781 int allowND CV_DEFAULT(0));
782
793CVAPI(IplImage*) cvGetImage( const CvArr* arr, IplImage* image_header );
794
795
832CVAPI(CvArr*) cvReshapeMatND( const CvArr* arr,
833 int sizeof_header, CvArr* header,
834 int new_cn, int new_dims, int* new_sizes );
835
836#define cvReshapeND( arr, header, new_cn, new_dims, new_sizes ) \
837 cvReshapeMatND( (arr), sizeof(*(header)), (header), \
838 (new_cn), (new_dims), (new_sizes))
839
867CVAPI(CvMat*) cvReshape( const CvArr* arr, CvMat* header,
868 int new_cn, int new_rows CV_DEFAULT(0) );
869
872CVAPI(void) cvRepeat( const CvArr* src, CvArr* dst );
873
882CVAPI(void) cvCreateData( CvArr* arr );
883
891CVAPI(void) cvReleaseData( CvArr* arr );
892
902CVAPI(void) cvSetData( CvArr* arr, void* data, int step );
903
930CVAPI(void) cvGetRawData( const CvArr* arr, uchar** data,
931 int* step CV_DEFAULT(NULL),
932 CvSize* roi_size CV_DEFAULT(NULL));
933
940CVAPI(CvSize) cvGetSize( const CvArr* arr );
941
956CVAPI(void) cvCopy( const CvArr* src, CvArr* dst,
957 const CvArr* mask CV_DEFAULT(NULL) );
958
969CVAPI(void) cvSet( CvArr* arr, CvScalar value,
970 const CvArr* mask CV_DEFAULT(NULL) );
971
979CVAPI(void) cvSetZero( CvArr* arr );
980#define cvZero cvSetZero
981
982
985CVAPI(void) cvSplit( const CvArr* src, CvArr* dst0, CvArr* dst1,
986 CvArr* dst2, CvArr* dst3 );
987
990CVAPI(void) cvMerge( const CvArr* src0, const CvArr* src1,
991 const CvArr* src2, const CvArr* src3,
992 CvArr* dst );
993
996CVAPI(void) cvMixChannels( const CvArr** src, int src_count,
997 CvArr** dst, int dst_count,
998 const int* from_to, int pair_count );
999
1018CVAPI(void) cvConvertScale( const CvArr* src, CvArr* dst,
1019 double scale CV_DEFAULT(1),
1020 double shift CV_DEFAULT(0) );
1021#define cvCvtScale cvConvertScale
1022#define cvScale cvConvertScale
1023#define cvConvert( src, dst ) cvConvertScale( (src), (dst), 1, 0 )
1024
1025
1031CVAPI(void) cvConvertScaleAbs( const CvArr* src, CvArr* dst,
1032 double scale CV_DEFAULT(1),
1033 double shift CV_DEFAULT(0) );
1034#define cvCvtScaleAbs cvConvertScaleAbs
1035
1036
1041CVAPI(CvTermCriteria) cvCheckTermCriteria( CvTermCriteria criteria,
1042 double default_eps,
1043 int default_max_iters );
1044
1045/****************************************************************************************\
1046* Arithmetic, logic and comparison operations *
1047\****************************************************************************************/
1048
1050CVAPI(void) cvAdd( const CvArr* src1, const CvArr* src2, CvArr* dst,
1051 const CvArr* mask CV_DEFAULT(NULL));
1052
1054CVAPI(void) cvAddS( const CvArr* src, CvScalar value, CvArr* dst,
1055 const CvArr* mask CV_DEFAULT(NULL));
1056
1058CVAPI(void) cvSub( const CvArr* src1, const CvArr* src2, CvArr* dst,
1059 const CvArr* mask CV_DEFAULT(NULL));
1060
1062CV_INLINE void cvSubS( const CvArr* src, CvScalar value, CvArr* dst,
1063 const CvArr* mask CV_DEFAULT(NULL))
1064{
1065 cvAddS( src, cvScalar( -value.val[0], -value.val[1], -value.val[2], -value.val[3]),
1066 dst, mask );
1067}
1068
1070CVAPI(void) cvSubRS( const CvArr* src, CvScalar value, CvArr* dst,
1071 const CvArr* mask CV_DEFAULT(NULL));
1072
1075CVAPI(void) cvMul( const CvArr* src1, const CvArr* src2,
1076 CvArr* dst, double scale CV_DEFAULT(1) );
1077
1081CVAPI(void) cvDiv( const CvArr* src1, const CvArr* src2,
1082 CvArr* dst, double scale CV_DEFAULT(1));
1083
1085CVAPI(void) cvScaleAdd( const CvArr* src1, CvScalar scale,
1086 const CvArr* src2, CvArr* dst );
1087#define cvAXPY( A, real_scalar, B, C ) cvScaleAdd(A, cvRealScalar(real_scalar), B, C)
1088
1090CVAPI(void) cvAddWeighted( const CvArr* src1, double alpha,
1091 const CvArr* src2, double beta,
1092 double gamma, CvArr* dst );
1093
1106CVAPI(double) cvDotProduct( const CvArr* src1, const CvArr* src2 );
1107
1109CVAPI(void) cvAnd( const CvArr* src1, const CvArr* src2,
1110 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
1111
1113CVAPI(void) cvAndS( const CvArr* src, CvScalar value,
1114 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
1115
1117CVAPI(void) cvOr( const CvArr* src1, const CvArr* src2,
1118 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
1119
1121CVAPI(void) cvOrS( const CvArr* src, CvScalar value,
1122 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
1123
1125CVAPI(void) cvXor( const CvArr* src1, const CvArr* src2,
1126 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
1127
1129CVAPI(void) cvXorS( const CvArr* src, CvScalar value,
1130 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
1131
1133CVAPI(void) cvNot( const CvArr* src, CvArr* dst );
1134
1136CVAPI(void) cvInRange( const CvArr* src, const CvArr* lower,
1137 const CvArr* upper, CvArr* dst );
1138
1140CVAPI(void) cvInRangeS( const CvArr* src, CvScalar lower,
1141 CvScalar upper, CvArr* dst );
1142
1143#define CV_CMP_EQ 0
1144#define CV_CMP_GT 1
1145#define CV_CMP_GE 2
1146#define CV_CMP_LT 3
1147#define CV_CMP_LE 4
1148#define CV_CMP_NE 5
1149
1154CVAPI(void) cvCmp( const CvArr* src1, const CvArr* src2, CvArr* dst, int cmp_op );
1155
1157CVAPI(void) cvCmpS( const CvArr* src, double value, CvArr* dst, int cmp_op );
1158
1160CVAPI(void) cvMin( const CvArr* src1, const CvArr* src2, CvArr* dst );
1161
1163CVAPI(void) cvMax( const CvArr* src1, const CvArr* src2, CvArr* dst );
1164
1166CVAPI(void) cvMinS( const CvArr* src, double value, CvArr* dst );
1167
1169CVAPI(void) cvMaxS( const CvArr* src, double value, CvArr* dst );
1170
1172CVAPI(void) cvAbsDiff( const CvArr* src1, const CvArr* src2, CvArr* dst );
1173
1175CVAPI(void) cvAbsDiffS( const CvArr* src, CvArr* dst, CvScalar value );
1176#define cvAbs( src, dst ) cvAbsDiffS( (src), (dst), cvScalarAll(0))
1177
1178/****************************************************************************************\
1179* Math operations *
1180\****************************************************************************************/
1181
1184CVAPI(void) cvCartToPolar( const CvArr* x, const CvArr* y,
1185 CvArr* magnitude, CvArr* angle CV_DEFAULT(NULL),
1186 int angle_in_degrees CV_DEFAULT(0));
1187
1191CVAPI(void) cvPolarToCart( const CvArr* magnitude, const CvArr* angle,
1192 CvArr* x, CvArr* y,
1193 int angle_in_degrees CV_DEFAULT(0));
1194
1196CVAPI(void) cvPow( const CvArr* src, CvArr* dst, double power );
1197
1201CVAPI(void) cvExp( const CvArr* src, CvArr* dst );
1202
1207CVAPI(void) cvLog( const CvArr* src, CvArr* dst );
1208
1210CVAPI(float) cvFastArctan( float y, float x );
1211
1213CVAPI(float) cvCbrt( float value );
1214
1215#define CV_CHECK_RANGE 1
1216#define CV_CHECK_QUIET 2
1221CVAPI(int) cvCheckArr( const CvArr* arr, int flags CV_DEFAULT(0),
1222 double min_val CV_DEFAULT(0), double max_val CV_DEFAULT(0));
1223#define cvCheckArray cvCheckArr
1224
1225#define CV_RAND_UNI 0
1226#define CV_RAND_NORMAL 1
1227
1244CVAPI(void) cvRandArr( CvRNG* rng, CvArr* arr, int dist_type,
1245 CvScalar param1, CvScalar param2 );
1246
1247CVAPI(void) cvRandShuffle( CvArr* mat, CvRNG* rng,
1248 double iter_factor CV_DEFAULT(1.));
1249
1250#define CV_SORT_EVERY_ROW 0
1251#define CV_SORT_EVERY_COLUMN 1
1252#define CV_SORT_ASCENDING 0
1253#define CV_SORT_DESCENDING 16
1254
1255CVAPI(void) cvSort( const CvArr* src, CvArr* dst CV_DEFAULT(NULL),
1256 CvArr* idxmat CV_DEFAULT(NULL),
1257 int flags CV_DEFAULT(0));
1258
1260CVAPI(int) cvSolveCubic( const CvMat* coeffs, CvMat* roots );
1261
1263CVAPI(void) cvSolvePoly(const CvMat* coeffs, CvMat *roots2,
1264 int maxiter CV_DEFAULT(20), int fig CV_DEFAULT(100));
1265
1266/****************************************************************************************\
1267* Matrix operations *
1268\****************************************************************************************/
1269
1280CVAPI(void) cvCrossProduct( const CvArr* src1, const CvArr* src2, CvArr* dst );
1281
1283#define cvMatMulAdd( src1, src2, src3, dst ) cvGEMM( (src1), (src2), 1., (src3), 1., (dst), 0 )
1284#define cvMatMul( src1, src2, dst ) cvMatMulAdd( (src1), (src2), NULL, (dst))
1285
1286#define CV_GEMM_A_T 1
1287#define CV_GEMM_B_T 2
1288#define CV_GEMM_C_T 4
1291CVAPI(void) cvGEMM( const CvArr* src1, const CvArr* src2, double alpha,
1292 const CvArr* src3, double beta, CvArr* dst,
1293 int tABC CV_DEFAULT(0));
1294#define cvMatMulAddEx cvGEMM
1295
1298CVAPI(void) cvTransform( const CvArr* src, CvArr* dst,
1299 const CvMat* transmat,
1300 const CvMat* shiftvec CV_DEFAULT(NULL));
1301#define cvMatMulAddS cvTransform
1302
1304CVAPI(void) cvPerspectiveTransform( const CvArr* src, CvArr* dst,
1305 const CvMat* mat );
1306
1308CVAPI(void) cvMulTransposed( const CvArr* src, CvArr* dst, int order,
1309 const CvArr* delta CV_DEFAULT(NULL),
1310 double scale CV_DEFAULT(1.) );
1311
1313CVAPI(void) cvTranspose( const CvArr* src, CvArr* dst );
1314#define cvT cvTranspose
1315
1317CVAPI(void) cvCompleteSymm( CvMat* matrix, int LtoR CV_DEFAULT(0) );
1318
1322CVAPI(void) cvFlip( const CvArr* src, CvArr* dst CV_DEFAULT(NULL),
1323 int flip_mode CV_DEFAULT(0));
1324#define cvMirror cvFlip
1325
1326
1327#define CV_SVD_MODIFY_A 1
1328#define CV_SVD_U_T 2
1329#define CV_SVD_V_T 4
1330
1332CVAPI(void) cvSVD( CvArr* A, CvArr* W, CvArr* U CV_DEFAULT(NULL),
1333 CvArr* V CV_DEFAULT(NULL), int flags CV_DEFAULT(0));
1334
1337CVAPI(void) cvSVBkSb( const CvArr* W, const CvArr* U,
1338 const CvArr* V, const CvArr* B,
1339 CvArr* X, int flags );
1340
1341#define CV_LU 0
1342#define CV_SVD 1
1343#define CV_SVD_SYM 2
1344#define CV_CHOLESKY 3
1345#define CV_QR 4
1346#define CV_NORMAL 16
1347
1349CVAPI(double) cvInvert( const CvArr* src, CvArr* dst,
1350 int method CV_DEFAULT(CV_LU));
1351#define cvInv cvInvert
1352
1355CVAPI(int) cvSolve( const CvArr* src1, const CvArr* src2, CvArr* dst,
1356 int method CV_DEFAULT(CV_LU));
1357
1359CVAPI(double) cvDet( const CvArr* mat );
1360
1362CVAPI(CvScalar) cvTrace( const CvArr* mat );
1363
1365CVAPI(void) cvEigenVV( CvArr* mat, CvArr* evects, CvArr* evals,
1366 double eps CV_DEFAULT(0),
1367 int lowindex CV_DEFAULT(-1),
1368 int highindex CV_DEFAULT(-1));
1369
1371//CVAPI(void) cvSelectedEigenVV( CvArr* mat, CvArr* evects, CvArr* evals,
1372// int lowindex, int highindex );
1373
1375CVAPI(void) cvSetIdentity( CvArr* mat, CvScalar value CV_DEFAULT(cvRealScalar(1)) );
1376
1378CVAPI(CvArr*) cvRange( CvArr* mat, double start, double end );
1379
1387#define CV_COVAR_SCRAMBLED 0
1388
1390#define CV_COVAR_NORMAL 1
1391
1394#define CV_COVAR_USE_AVG 2
1395
1397#define CV_COVAR_SCALE 4
1398
1400#define CV_COVAR_ROWS 8
1401
1403#define CV_COVAR_COLS 16
1404
1410CVAPI(void) cvCalcCovarMatrix( const CvArr** vects, int count,
1411 CvArr* cov_mat, CvArr* avg, int flags );
1412
1413#define CV_PCA_DATA_AS_ROW 0
1414#define CV_PCA_DATA_AS_COL 1
1415#define CV_PCA_USE_AVG 2
1416CVAPI(void) cvCalcPCA( const CvArr* data, CvArr* mean,
1417 CvArr* eigenvals, CvArr* eigenvects, int flags );
1418
1419CVAPI(void) cvProjectPCA( const CvArr* data, const CvArr* mean,
1420 const CvArr* eigenvects, CvArr* result );
1421
1422CVAPI(void) cvBackProjectPCA( const CvArr* proj, const CvArr* mean,
1423 const CvArr* eigenvects, CvArr* result );
1424
1426CVAPI(double) cvMahalanobis( const CvArr* vec1, const CvArr* vec2, const CvArr* mat );
1427#define cvMahalonobis cvMahalanobis
1428
1429/****************************************************************************************\
1430* Array Statistics *
1431\****************************************************************************************/
1432
1434CVAPI(CvScalar) cvSum( const CvArr* arr );
1435
1437CVAPI(int) cvCountNonZero( const CvArr* arr );
1438
1440CVAPI(CvScalar) cvAvg( const CvArr* arr, const CvArr* mask CV_DEFAULT(NULL) );
1441
1443CVAPI(void) cvAvgSdv( const CvArr* arr, CvScalar* mean, CvScalar* std_dev,
1444 const CvArr* mask CV_DEFAULT(NULL) );
1445
1447CVAPI(void) cvMinMaxLoc( const CvArr* arr, double* min_val, double* max_val,
1448 CvPoint* min_loc CV_DEFAULT(NULL),
1449 CvPoint* max_loc CV_DEFAULT(NULL),
1450 const CvArr* mask CV_DEFAULT(NULL) );
1451
1456#define CV_C 1
1457#define CV_L1 2
1458#define CV_L2 4
1459#define CV_NORM_MASK 7
1460#define CV_RELATIVE 8
1461#define CV_DIFF 16
1462#define CV_MINMAX 32
1463
1464#define CV_DIFF_C (CV_DIFF | CV_C)
1465#define CV_DIFF_L1 (CV_DIFF | CV_L1)
1466#define CV_DIFF_L2 (CV_DIFF | CV_L2)
1467#define CV_RELATIVE_C (CV_RELATIVE | CV_C)
1468#define CV_RELATIVE_L1 (CV_RELATIVE | CV_L1)
1469#define CV_RELATIVE_L2 (CV_RELATIVE | CV_L2)
1475CVAPI(double) cvNorm( const CvArr* arr1, const CvArr* arr2 CV_DEFAULT(NULL),
1476 int norm_type CV_DEFAULT(CV_L2),
1477 const CvArr* mask CV_DEFAULT(NULL) );
1478
1480CVAPI(void) cvNormalize( const CvArr* src, CvArr* dst,
1481 double a CV_DEFAULT(1.), double b CV_DEFAULT(0.),
1482 int norm_type CV_DEFAULT(CV_L2),
1483 const CvArr* mask CV_DEFAULT(NULL) );
1484
1489#define CV_REDUCE_SUM 0
1490#define CV_REDUCE_AVG 1
1491#define CV_REDUCE_MAX 2
1492#define CV_REDUCE_MIN 3
1496CVAPI(void) cvReduce( const CvArr* src, CvArr* dst, int dim CV_DEFAULT(-1),
1497 int op CV_DEFAULT(CV_REDUCE_SUM) );
1498
1499/****************************************************************************************\
1500* Discrete Linear Transforms and Related Functions *
1501\****************************************************************************************/
1502
1507#define CV_DXT_FORWARD 0
1508#define CV_DXT_INVERSE 1
1509#define CV_DXT_SCALE 2
1510#define CV_DXT_INV_SCALE (CV_DXT_INVERSE + CV_DXT_SCALE)
1511#define CV_DXT_INVERSE_SCALE CV_DXT_INV_SCALE
1512#define CV_DXT_ROWS 4
1513#define CV_DXT_MUL_CONJ 8
1522CVAPI(void) cvDFT( const CvArr* src, CvArr* dst, int flags,
1523 int nonzero_rows CV_DEFAULT(0) );
1524#define cvFFT cvDFT
1525
1529CVAPI(void) cvMulSpectrums( const CvArr* src1, const CvArr* src2,
1530 CvArr* dst, int flags );
1531
1533CVAPI(int) cvGetOptimalDFTSize( int size0 );
1534
1538CVAPI(void) cvDCT( const CvArr* src, CvArr* dst, int flags );
1539
1540/****************************************************************************************\
1541* Dynamic data structures *
1542\****************************************************************************************/
1543
1545CVAPI(int) cvSliceLength( CvSlice slice, const CvSeq* seq );
1546
1547
1551CVAPI(CvMemStorage*) cvCreateMemStorage( int block_size CV_DEFAULT(0));
1552
1553
1555CVAPI(CvMemStorage*) cvCreateChildMemStorage( CvMemStorage* parent );
1556
1557
1560CVAPI(void) cvReleaseMemStorage( CvMemStorage** storage );
1561
1562
1567CVAPI(void) cvClearMemStorage( CvMemStorage* storage );
1568
1570CVAPI(void) cvSaveMemStoragePos( const CvMemStorage* storage, CvMemStoragePos* pos );
1571
1573CVAPI(void) cvRestoreMemStoragePos( CvMemStorage* storage, CvMemStoragePos* pos );
1574
1576CVAPI(void*) cvMemStorageAlloc( CvMemStorage* storage, size_t size );
1577
1579//CVAPI(CvString) cvMemStorageAllocString( CvMemStorage* storage, const char* ptr,
1580// int len CV_DEFAULT(-1) );
1581
1583CVAPI(CvSeq*) cvCreateSeq( int seq_flags, size_t header_size,
1584 size_t elem_size, CvMemStorage* storage );
1585
1588CVAPI(void) cvSetSeqBlockSize( CvSeq* seq, int delta_elems );
1589
1590
1592CVAPI(schar*) cvSeqPush( CvSeq* seq, const void* element CV_DEFAULT(NULL));
1593
1594
1596CVAPI(schar*) cvSeqPushFront( CvSeq* seq, const void* element CV_DEFAULT(NULL));
1597
1598
1600CVAPI(void) cvSeqPop( CvSeq* seq, void* element CV_DEFAULT(NULL));
1601
1602
1604CVAPI(void) cvSeqPopFront( CvSeq* seq, void* element CV_DEFAULT(NULL));
1605
1606
1607#define CV_FRONT 1
1608#define CV_BACK 0
1610CVAPI(void) cvSeqPushMulti( CvSeq* seq, const void* elements,
1611 int count, int in_front CV_DEFAULT(0) );
1612
1614CVAPI(void) cvSeqPopMulti( CvSeq* seq, void* elements,
1615 int count, int in_front CV_DEFAULT(0) );
1616
1619CVAPI(schar*) cvSeqInsert( CvSeq* seq, int before_index,
1620 const void* element CV_DEFAULT(NULL));
1621
1623CVAPI(void) cvSeqRemove( CvSeq* seq, int index );
1624
1625
1629CVAPI(void) cvClearSeq( CvSeq* seq );
1630
1631
1635CVAPI(schar*) cvGetSeqElem( const CvSeq* seq, int index );
1636
1639CVAPI(int) cvSeqElemIdx( const CvSeq* seq, const void* element,
1640 CvSeqBlock** block CV_DEFAULT(NULL) );
1641
1643CVAPI(void) cvStartAppendToSeq( CvSeq* seq, CvSeqWriter* writer );
1644
1645
1647CVAPI(void) cvStartWriteSeq( int seq_flags, int header_size,
1648 int elem_size, CvMemStorage* storage,
1649 CvSeqWriter* writer );
1650
1655CVAPI(CvSeq*) cvEndWriteSeq( CvSeqWriter* writer );
1656
1657
1660CVAPI(void) cvFlushSeqWriter( CvSeqWriter* writer );
1661
1662
1665CVAPI(void) cvStartReadSeq( const CvSeq* seq, CvSeqReader* reader,
1666 int reverse CV_DEFAULT(0) );
1667
1668
1670CVAPI(int) cvGetSeqReaderPos( CvSeqReader* reader );
1671
1672
1675CVAPI(void) cvSetSeqReaderPos( CvSeqReader* reader, int index,
1676 int is_relative CV_DEFAULT(0));
1677
1679CVAPI(void*) cvCvtSeqToArray( const CvSeq* seq, void* elements,
1680 CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ) );
1681
1685CVAPI(CvSeq*) cvMakeSeqHeaderForArray( int seq_type, int header_size,
1686 int elem_size, void* elements, int total,
1687 CvSeq* seq, CvSeqBlock* block );
1688
1690CVAPI(CvSeq*) cvSeqSlice( const CvSeq* seq, CvSlice slice,
1691 CvMemStorage* storage CV_DEFAULT(NULL),
1692 int copy_data CV_DEFAULT(0));
1693
1694CV_INLINE CvSeq* cvCloneSeq( const CvSeq* seq, CvMemStorage* storage CV_DEFAULT(NULL))
1695{
1696 return cvSeqSlice( seq, CV_WHOLE_SEQ, storage, 1 );
1697}
1698
1700CVAPI(void) cvSeqRemoveSlice( CvSeq* seq, CvSlice slice );
1701
1703CVAPI(void) cvSeqInsertSlice( CvSeq* seq, int before_index, const CvArr* from_arr );
1704
1706typedef int (CV_CDECL* CvCmpFunc)(const void* a, const void* b, void* userdata );
1707
1709CVAPI(void) cvSeqSort( CvSeq* seq, CvCmpFunc func, void* userdata CV_DEFAULT(NULL) );
1710
1712CVAPI(schar*) cvSeqSearch( CvSeq* seq, const void* elem, CvCmpFunc func,
1713 int is_sorted, int* elem_idx,
1714 void* userdata CV_DEFAULT(NULL) );
1715
1717CVAPI(void) cvSeqInvert( CvSeq* seq );
1718
1720CVAPI(int) cvSeqPartition( const CvSeq* seq, CvMemStorage* storage,
1721 CvSeq** labels, CvCmpFunc is_equal, void* userdata );
1722
1723/************ Internal sequence functions ************/
1724CVAPI(void) cvChangeSeqBlock( void* reader, int direction );
1725CVAPI(void) cvCreateSeqBlock( CvSeqWriter* writer );
1726
1727
1729CVAPI(CvSet*) cvCreateSet( int set_flags, int header_size,
1730 int elem_size, CvMemStorage* storage );
1731
1733CVAPI(int) cvSetAdd( CvSet* set_header, CvSetElem* elem CV_DEFAULT(NULL),
1734 CvSetElem** inserted_elem CV_DEFAULT(NULL) );
1735
1737CV_INLINE CvSetElem* cvSetNew( CvSet* set_header )
1738{
1739 CvSetElem* elem = set_header->free_elems;
1740 if( elem )
1741 {
1742 set_header->free_elems = elem->next_free;
1743 elem->flags = elem->flags & CV_SET_ELEM_IDX_MASK;
1744 set_header->active_count++;
1745 }
1746 else
1747 cvSetAdd( set_header, NULL, &elem );
1748 return elem;
1749}
1750
1752CV_INLINE void cvSetRemoveByPtr( CvSet* set_header, void* elem )
1753{
1754 CvSetElem* _elem = (CvSetElem*)elem;
1755 assert( _elem->flags >= 0 /*&& (elem->flags & CV_SET_ELEM_IDX_MASK) < set_header->total*/ );
1756 _elem->next_free = set_header->free_elems;
1757 _elem->flags = (_elem->flags & CV_SET_ELEM_IDX_MASK) | CV_SET_ELEM_FREE_FLAG;
1758 set_header->free_elems = _elem;
1759 set_header->active_count--;
1760}
1761
1763CVAPI(void) cvSetRemove( CvSet* set_header, int index );
1764
1767CV_INLINE CvSetElem* cvGetSetElem( const CvSet* set_header, int idx )
1768{
1769 CvSetElem* elem = (CvSetElem*)(void *)cvGetSeqElem( (CvSeq*)set_header, idx );
1770 return elem && CV_IS_SET_ELEM( elem ) ? elem : 0;
1771}
1772
1774CVAPI(void) cvClearSet( CvSet* set_header );
1775
1777CVAPI(CvGraph*) cvCreateGraph( int graph_flags, int header_size,
1778 int vtx_size, int edge_size,
1779 CvMemStorage* storage );
1780
1782CVAPI(int) cvGraphAddVtx( CvGraph* graph, const CvGraphVtx* vtx CV_DEFAULT(NULL),
1783 CvGraphVtx** inserted_vtx CV_DEFAULT(NULL) );
1784
1785
1787CVAPI(int) cvGraphRemoveVtx( CvGraph* graph, int index );
1788CVAPI(int) cvGraphRemoveVtxByPtr( CvGraph* graph, CvGraphVtx* vtx );
1789
1790
1795CVAPI(int) cvGraphAddEdge( CvGraph* graph,
1796 int start_idx, int end_idx,
1797 const CvGraphEdge* edge CV_DEFAULT(NULL),
1798 CvGraphEdge** inserted_edge CV_DEFAULT(NULL) );
1799
1800CVAPI(int) cvGraphAddEdgeByPtr( CvGraph* graph,
1801 CvGraphVtx* start_vtx, CvGraphVtx* end_vtx,
1802 const CvGraphEdge* edge CV_DEFAULT(NULL),
1803 CvGraphEdge** inserted_edge CV_DEFAULT(NULL) );
1804
1806CVAPI(void) cvGraphRemoveEdge( CvGraph* graph, int start_idx, int end_idx );
1807CVAPI(void) cvGraphRemoveEdgeByPtr( CvGraph* graph, CvGraphVtx* start_vtx,
1808 CvGraphVtx* end_vtx );
1809
1811CVAPI(CvGraphEdge*) cvFindGraphEdge( const CvGraph* graph, int start_idx, int end_idx );
1812CVAPI(CvGraphEdge*) cvFindGraphEdgeByPtr( const CvGraph* graph,
1813 const CvGraphVtx* start_vtx,
1814 const CvGraphVtx* end_vtx );
1815#define cvGraphFindEdge cvFindGraphEdge
1816#define cvGraphFindEdgeByPtr cvFindGraphEdgeByPtr
1817
1819CVAPI(void) cvClearGraph( CvGraph* graph );
1820
1821
1823CVAPI(int) cvGraphVtxDegree( const CvGraph* graph, int vtx_idx );
1824CVAPI(int) cvGraphVtxDegreeByPtr( const CvGraph* graph, const CvGraphVtx* vtx );
1825
1826
1828#define cvGetGraphVtx( graph, idx ) (CvGraphVtx*)cvGetSetElem((CvSet*)(graph), (idx))
1829
1831#define cvGraphVtxIdx( graph, vtx ) ((vtx)->flags & CV_SET_ELEM_IDX_MASK)
1832
1834#define cvGraphEdgeIdx( graph, edge ) ((edge)->flags & CV_SET_ELEM_IDX_MASK)
1835
1836#define cvGraphGetVtxCount( graph ) ((graph)->active_count)
1837#define cvGraphGetEdgeCount( graph ) ((graph)->edges->active_count)
1838
1839#define CV_GRAPH_VERTEX 1
1840#define CV_GRAPH_TREE_EDGE 2
1841#define CV_GRAPH_BACK_EDGE 4
1842#define CV_GRAPH_FORWARD_EDGE 8
1843#define CV_GRAPH_CROSS_EDGE 16
1844#define CV_GRAPH_ANY_EDGE 30
1845#define CV_GRAPH_NEW_TREE 32
1846#define CV_GRAPH_BACKTRACKING 64
1847#define CV_GRAPH_OVER -1
1848
1849#define CV_GRAPH_ALL_ITEMS -1
1850
1852#define CV_GRAPH_ITEM_VISITED_FLAG (1 << 30)
1853#define CV_IS_GRAPH_VERTEX_VISITED(vtx) \
1854 (((CvGraphVtx*)(vtx))->flags & CV_GRAPH_ITEM_VISITED_FLAG)
1855#define CV_IS_GRAPH_EDGE_VISITED(edge) \
1856 (((CvGraphEdge*)(edge))->flags & CV_GRAPH_ITEM_VISITED_FLAG)
1857#define CV_GRAPH_SEARCH_TREE_NODE_FLAG (1 << 29)
1858#define CV_GRAPH_FORWARD_EDGE_FLAG (1 << 28)
1859
1860typedef struct CvGraphScanner
1861{
1862 CvGraphVtx* vtx; /* current graph vertex (or current edge origin) */
1863 CvGraphVtx* dst; /* current graph edge destination vertex */
1864 CvGraphEdge* edge; /* current edge */
1865
1866 CvGraph* graph; /* the graph */
1867 CvSeq* stack; /* the graph vertex stack */
1868 int index; /* the lower bound of certainly visited vertices */
1869 int mask; /* event mask */
1870}
1871CvGraphScanner;
1872
1874CVAPI(CvGraphScanner*) cvCreateGraphScanner( CvGraph* graph,
1875 CvGraphVtx* vtx CV_DEFAULT(NULL),
1876 int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS));
1877
1879CVAPI(void) cvReleaseGraphScanner( CvGraphScanner** scanner );
1880
1882CVAPI(int) cvNextGraphItem( CvGraphScanner* scanner );
1883
1885CVAPI(CvGraph*) cvCloneGraph( const CvGraph* graph, CvMemStorage* storage );
1886
1887
1890CVAPI(void) cvLUT( const CvArr* src, CvArr* dst, const CvArr* lut );
1891
1892
1893/******************* Iteration through the sequence tree *****************/
1894typedef struct CvTreeNodeIterator
1895{
1896 const void* node;
1897 int level;
1898 int max_level;
1899}
1900CvTreeNodeIterator;
1901
1902CVAPI(void) cvInitTreeNodeIterator( CvTreeNodeIterator* tree_iterator,
1903 const void* first, int max_level );
1904CVAPI(void*) cvNextTreeNode( CvTreeNodeIterator* tree_iterator );
1905CVAPI(void*) cvPrevTreeNode( CvTreeNodeIterator* tree_iterator );
1906
1910CVAPI(void) cvInsertNodeIntoTree( void* node, void* parent, void* frame );
1911
1913CVAPI(void) cvRemoveNodeFromTree( void* node, void* frame );
1914
1917CVAPI(CvSeq*) cvTreeToNodeSeq( const void* first, int header_size,
1918 CvMemStorage* storage );
1919
1922#define CV_KMEANS_USE_INITIAL_LABELS 1
1923CVAPI(int) cvKMeans2( const CvArr* samples, int cluster_count, CvArr* labels,
1924 CvTermCriteria termcrit, int attempts CV_DEFAULT(1),
1925 CvRNG* rng CV_DEFAULT(0), int flags CV_DEFAULT(0),
1926 CvArr* _centers CV_DEFAULT(0), double* compactness CV_DEFAULT(0) );
1927
1928/****************************************************************************************\
1929* System functions *
1930\****************************************************************************************/
1931
1933CVAPI(int) cvUseOptimized( int on_off );
1934
1935typedef IplImage* (CV_STDCALL* Cv_iplCreateImageHeader)
1936 (int,int,int,char*,char*,int,int,int,int,int,
1937 IplROI*,IplImage*,void*,IplTileInfo*);
1938typedef void (CV_STDCALL* Cv_iplAllocateImageData)(IplImage*,int,int);
1939typedef void (CV_STDCALL* Cv_iplDeallocate)(IplImage*,int);
1940typedef IplROI* (CV_STDCALL* Cv_iplCreateROI)(int,int,int,int,int);
1941typedef IplImage* (CV_STDCALL* Cv_iplCloneImage)(const IplImage*);
1942
1959CVAPI(void) cvSetIPLAllocators( Cv_iplCreateImageHeader create_header,
1960 Cv_iplAllocateImageData allocate_data,
1961 Cv_iplDeallocate deallocate,
1962 Cv_iplCreateROI create_roi,
1963 Cv_iplCloneImage clone_image );
1964
1965#define CV_TURN_ON_IPL_COMPATIBILITY() \
1966 cvSetIPLAllocators( iplCreateImageHeader, iplAllocateImage, \
1967 iplDeallocate, iplCreateROI, iplCloneImage )
1968
1969/****************************************************************************************\
1970* Data Persistence *
1971\****************************************************************************************/
1972
1973#if 0
1974/********************************** High-level functions ********************************/
1975
1996CVAPI(CvFileStorage*) cvOpenFileStorage( const char* filename, CvMemStorage* memstorage,
1997 int flags, const char* encoding CV_DEFAULT(NULL) );
1998
2005CVAPI(void) cvReleaseFileStorage( CvFileStorage** fs );
2006
2008CVAPI(const char*) cvAttrValue( const CvAttrList* attr, const char* attr_name );
2009
2036CVAPI(void) cvStartWriteStruct( CvFileStorage* fs, const char* name,
2037 int struct_flags, const char* type_name CV_DEFAULT(NULL),
2038 CvAttrList attributes CV_DEFAULT(cvAttrList()));
2039
2044CVAPI(void) cvEndWriteStruct( CvFileStorage* fs );
2045
2054CVAPI(void) cvWriteInt( CvFileStorage* fs, const char* name, int value );
2055
2081CVAPI(void) cvWriteReal( CvFileStorage* fs, const char* name, double value );
2082
2094CVAPI(void) cvWriteString( CvFileStorage* fs, const char* name,
2095 const char* str, int quote CV_DEFAULT(0) );
2096
2106CVAPI(void) cvWriteComment( CvFileStorage* fs, const char* comment,
2107 int eol_comment );
2108
2154CVAPI(void) cvWrite( CvFileStorage* fs, const char* name, const void* ptr,
2155 CvAttrList attributes CV_DEFAULT(cvAttrList()));
2156
2181CVAPI(void) cvStartNextStream( CvFileStorage* fs );
2182
2194CVAPI(void) cvWriteRawData( CvFileStorage* fs, const void* src,
2195 int len, const char* dt );
2196
2211CVAPI(void) cvWriteRawDataBase64( CvFileStorage* fs, const void* src,
2212 int len, const char* dt );
2213
2282CVAPI(CvStringHashNode*) cvGetHashedKey( CvFileStorage* fs, const char* name,
2283 int len CV_DEFAULT(-1),
2284 int create_missing CV_DEFAULT(0));
2285
2297CVAPI(CvFileNode*) cvGetRootFileNode( const CvFileStorage* fs,
2298 int stream_index CV_DEFAULT(0) );
2299
2310CVAPI(CvFileNode*) cvGetFileNode( CvFileStorage* fs, CvFileNode* map,
2311 const CvStringHashNode* key,
2312 int create_missing CV_DEFAULT(0) );
2313
2326CVAPI(CvFileNode*) cvGetFileNodeByName( const CvFileStorage* fs,
2327 const CvFileNode* map,
2328 const char* name );
2329
2340CV_INLINE int cvReadInt( const CvFileNode* node, int default_value CV_DEFAULT(0) )
2341{
2342 return !node ? default_value :
2343 CV_NODE_IS_INT(node->tag) ? node->data.i :
2344 CV_NODE_IS_REAL(node->tag) ? cvRound(node->data.f) : 0x7fffffff;
2345}
2346
2355CV_INLINE int cvReadIntByName( const CvFileStorage* fs, const CvFileNode* map,
2356 const char* name, int default_value CV_DEFAULT(0) )
2357{
2358 return cvReadInt( cvGetFileNodeByName( fs, map, name ), default_value );
2359}
2360
2371CV_INLINE double cvReadReal( const CvFileNode* node, double default_value CV_DEFAULT(0.) )
2372{
2373 return !node ? default_value :
2374 CV_NODE_IS_INT(node->tag) ? (double)node->data.i :
2375 CV_NODE_IS_REAL(node->tag) ? node->data.f : 1e300;
2376}
2377
2386CV_INLINE double cvReadRealByName( const CvFileStorage* fs, const CvFileNode* map,
2387 const char* name, double default_value CV_DEFAULT(0.) )
2388{
2389 return cvReadReal( cvGetFileNodeByName( fs, map, name ), default_value );
2390}
2391
2401CV_INLINE const char* cvReadString( const CvFileNode* node,
2402 const char* default_value CV_DEFAULT(NULL) )
2403{
2404 return !node ? default_value : CV_NODE_IS_STRING(node->tag) ? node->data.str.ptr : 0;
2405}
2406
2415CV_INLINE const char* cvReadStringByName( const CvFileStorage* fs, const CvFileNode* map,
2416 const char* name, const char* default_value CV_DEFAULT(NULL) )
2417{
2418 return cvReadString( cvGetFileNodeByName( fs, map, name ), default_value );
2419}
2420
2421
2436CVAPI(void*) cvRead( CvFileStorage* fs, CvFileNode* node,
2437 CvAttrList* attributes CV_DEFAULT(NULL));
2438
2447CV_INLINE void* cvReadByName( CvFileStorage* fs, const CvFileNode* map,
2448 const char* name, CvAttrList* attributes CV_DEFAULT(NULL) )
2449{
2450 return cvRead( fs, cvGetFileNodeByName( fs, map, name ), attributes );
2451}
2452
2453
2462CVAPI(void) cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src,
2463 CvSeqReader* reader );
2464
2478CVAPI(void) cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader,
2479 int count, void* dst, const char* dt );
2480
2489CVAPI(void) cvReadRawData( const CvFileStorage* fs, const CvFileNode* src,
2490 void* dst, const char* dt );
2491
2505CVAPI(void) cvWriteFileNode( CvFileStorage* fs, const char* new_node_name,
2506 const CvFileNode* node, int embed );
2507
2514CVAPI(const char*) cvGetFileNodeName( const CvFileNode* node );
2515
2516/*********************************** Adding own types ***********************************/
2517
2524CVAPI(void) cvRegisterType( const CvTypeInfo* info );
2525
2533CVAPI(void) cvUnregisterType( const char* type_name );
2534
2540CVAPI(CvTypeInfo*) cvFirstType(void);
2541
2548CVAPI(CvTypeInfo*) cvFindType( const char* type_name );
2549
2558CVAPI(CvTypeInfo*) cvTypeOf( const void* struct_ptr );
2559
2560#endif
2561
2567CVAPI(void) cvRelease( void** struct_ptr );
2568
2576CVAPI(void*) cvClone( const void* struct_ptr );
2577
2578/*********************************** Measuring Execution Time ***************************/
2579
2582CVAPI(int64) cvGetTickCount( void );
2583CVAPI(double) cvGetTickFrequency( void );
2584
2585/*********************************** CPU capabilities ***********************************/
2586
2587CVAPI(int) cvCheckHardwareSupport(int feature);
2588
2589/*********************************** Multi-Threading ************************************/
2590
2592CVAPI(int) cvGetNumThreads( void );
2593CVAPI(void) cvSetNumThreads( int threads CV_DEFAULT(0) );
2595CVAPI(int) cvGetThreadNum( void );
2596
2597
2598/********************************** Error Handling **************************************/
2599
2601CVAPI(int) cvGetErrStatus( void );
2602
2604CVAPI(void) cvSetErrStatus( int status );
2605
2606#define CV_ErrModeLeaf 0 /* Print error and exit program */
2607#define CV_ErrModeParent 1 /* Print error and continue */
2608#define CV_ErrModeSilent 2 /* Don't print and continue */
2609
2611CVAPI(int) cvGetErrMode( void );
2612
2614CVAPI(int) cvSetErrMode( int mode );
2615
2619CVAPI(void) cvError( int status, const char* func_name,
2620 const char* err_msg, const char* file_name, int line );
2621
2623CVAPI(const char*) cvErrorStr( int status );
2624
2626CVAPI(int) cvGetErrInfo( const char** errcode_desc, const char** description,
2627 const char** filename, int* line );
2628
2630CVAPI(int) cvErrorFromIppStatus( int ipp_status );
2631
2632typedef int (CV_CDECL *CvErrorCallback)( int status, const char* func_name,
2633 const char* err_msg, const char* file_name, int line, void* userdata );
2634
2636CVAPI(CvErrorCallback) cvRedirectError( CvErrorCallback error_handler,
2637 void* userdata CV_DEFAULT(NULL),
2638 void** prev_userdata CV_DEFAULT(NULL) );
2639
2641CVAPI(int) cvNulDevReport( int status, const char* func_name, const char* err_msg,
2642 const char* file_name, int line, void* userdata );
2643
2645CVAPI(int) cvStdErrReport( int status, const char* func_name, const char* err_msg,
2646 const char* file_name, int line, void* userdata );
2647
2649CVAPI(int) cvGuiBoxReport( int status, const char* func_name, const char* err_msg,
2650 const char* file_name, int line, void* userdata );
2651
2652#define OPENCV_ERROR(status,func,context) \
2653cvError((status),(func),(context),__FILE__,__LINE__)
2654
2655#define OPENCV_ASSERT(expr,func,context) \
2656{if (! (expr)) \
2657{OPENCV_ERROR(CV_StsInternal,(func),(context));}}
2658
2659#define OPENCV_CALL( Func ) \
2660{ \
2661Func; \
2662}
2663
2664
2666#ifdef CV_NO_FUNC_NAMES
2667#define CV_FUNCNAME( Name )
2668#define cvFuncName ""
2669#else
2670#define CV_FUNCNAME( Name ) \
2671static char cvFuncName[] = Name
2672#endif
2673
2674
2679#define CV_ERROR( Code, Msg ) \
2680{ \
2681 cvError( (Code), cvFuncName, Msg, __FILE__, __LINE__ ); \
2682 __CV_EXIT__; \
2683}
2684
2690#define CV_CHECK() \
2691{ \
2692 if( cvGetErrStatus() < 0 ) \
2693 CV_ERROR( CV_StsBackTrace, "Inner function failed." ); \
2694}
2695
2696
2702#define CV_CALL( Func ) \
2703{ \
2704 Func; \
2705 CV_CHECK(); \
2706}
2707
2708
2710#define CV_ASSERT( Condition ) \
2711{ \
2712 if( !(Condition) ) \
2713 CV_ERROR( CV_StsInternal, "Assertion: " #Condition " failed" ); \
2714}
2715
2716#define __CV_BEGIN__ {
2717#define __CV_END__ goto exit; exit: ; }
2718#define __CV_EXIT__ goto exit
2719
2722#ifdef __cplusplus
2723} // extern "C"
2724#endif
2725
2726#ifdef __cplusplus
2727
2728#include "opencv2/core/utility.hpp"
2729
2730namespace cv
2731{
2732
2735
2737
2739CV_EXPORTS Mat cvarrToMat(const CvArr* arr, bool copyData=false,
2740 bool allowND=true, int coiMode=0,
2741 AutoBuffer<double>* buf=0);
2742
2743static inline Mat cvarrToMatND(const CvArr* arr, bool copyData=false, int coiMode=0)
2744{
2745 return cvarrToMat(arr, copyData, true, coiMode);
2746}
2747
2748
2750CV_EXPORTS void extractImageCOI(const CvArr* arr, OutputArray coiimg, int coi=-1);
2752CV_EXPORTS void insertImageCOI(InputArray coiimg, CvArr* arr, int coi=-1);
2753
2754
2755
2757
2758template<> struct DefaultDeleter<CvMat>{ CV_EXPORTS void operator ()(CvMat* obj) const; };
2759template<> struct DefaultDeleter<IplImage>{ CV_EXPORTS void operator ()(IplImage* obj) const; };
2760template<> struct DefaultDeleter<CvMatND>{ CV_EXPORTS void operator ()(CvMatND* obj) const; };
2761template<> struct DefaultDeleter<CvSparseMat>{ CV_EXPORTS void operator ()(CvSparseMat* obj) const; };
2762template<> struct DefaultDeleter<CvMemStorage>{ CV_EXPORTS void operator ()(CvMemStorage* obj) const; };
2763
2765
2766template<typename _Tp> class SeqIterator;
2767
2768typedef Ptr<CvMemStorage> MemStorage;
2769
2780template<typename _Tp> class Seq
2781{
2782public:
2783 typedef SeqIterator<_Tp> iterator;
2784 typedef SeqIterator<_Tp> const_iterator;
2785
2787 Seq();
2789 Seq(const CvSeq* seq);
2791 Seq(MemStorage& storage, int headerSize = sizeof(CvSeq));
2793 _Tp& operator [](int idx);
2795 const _Tp& operator[](int idx) const;
2797 SeqIterator<_Tp> begin() const;
2799 SeqIterator<_Tp> end() const;
2801 size_t size() const;
2803 int type() const;
2805 int depth() const;
2807 int channels() const;
2809 size_t elemSize() const;
2811 size_t index(const _Tp& elem) const;
2813 void push_back(const _Tp& elem);
2815 void push_front(const _Tp& elem);
2817 void push_back(const _Tp* elems, size_t count);
2819 void push_front(const _Tp* elems, size_t count);
2821 void insert(int idx, const _Tp& elem);
2823 void insert(int idx, const _Tp* elems, size_t count);
2825 void remove(int idx);
2827 void remove(const Range& r);
2828
2830 _Tp& front();
2832 const _Tp& front() const;
2834 _Tp& back();
2836 const _Tp& back() const;
2838 bool empty() const;
2839
2841 void clear();
2843 void pop_front();
2845 void pop_back();
2847 void pop_front(_Tp* elems, size_t count);
2849 void pop_back(_Tp* elems, size_t count);
2850
2852 void copyTo(std::vector<_Tp>& vec, const Range& range=Range::all()) const;
2854 operator std::vector<_Tp>() const;
2855
2856 CvSeq* seq;
2857};
2858
2859
2863template<typename _Tp> class SeqIterator : public CvSeqReader
2864{
2865public:
2867 SeqIterator();
2869 SeqIterator(const Seq<_Tp>& seq, bool seekEnd=false);
2871 void seek(size_t pos);
2873 size_t tell() const;
2875 _Tp& operator *();
2877 const _Tp& operator *() const;
2879 SeqIterator& operator ++();
2881 SeqIterator operator ++(int) const;
2883 SeqIterator& operator --();
2885 SeqIterator operator --(int) const;
2886
2888 SeqIterator& operator +=(int);
2890 SeqIterator& operator -=(int);
2891
2892 // this is index of the current element module seq->total*2
2893 // (to distinguish between 0 and seq->total)
2894 int index;
2895};
2896
2897
2898
2899// bridge C++ => C Seq API
2900CV_EXPORTS schar* seqPush( CvSeq* seq, const void* element=0);
2901CV_EXPORTS schar* seqPushFront( CvSeq* seq, const void* element=0);
2902CV_EXPORTS void seqPop( CvSeq* seq, void* element=0);
2903CV_EXPORTS void seqPopFront( CvSeq* seq, void* element=0);
2904CV_EXPORTS void seqPopMulti( CvSeq* seq, void* elements,
2905 int count, int in_front=0 );
2906CV_EXPORTS void seqRemove( CvSeq* seq, int index );
2907CV_EXPORTS void clearSeq( CvSeq* seq );
2908CV_EXPORTS schar* getSeqElem( const CvSeq* seq, int index );
2909CV_EXPORTS void seqRemoveSlice( CvSeq* seq, CvSlice slice );
2910CV_EXPORTS void seqInsertSlice( CvSeq* seq, int before_index, const CvArr* from_arr );
2911
2912template<typename _Tp> inline Seq<_Tp>::Seq() : seq(0) {}
2913template<typename _Tp> inline Seq<_Tp>::Seq( const CvSeq* _seq ) : seq((CvSeq*)_seq)
2914{
2915 CV_Assert(!_seq || _seq->elem_size == sizeof(_Tp));
2916}
2917
2918template<typename _Tp> inline Seq<_Tp>::Seq( MemStorage& storage,
2919 int headerSize )
2920{
2921 CV_Assert(headerSize >= (int)sizeof(CvSeq));
2922 seq = cvCreateSeq(DataType<_Tp>::type, headerSize, sizeof(_Tp), storage);
2923}
2924
2925template<typename _Tp> inline _Tp& Seq<_Tp>::operator [](int idx)
2926{ return *(_Tp*)getSeqElem(seq, idx); }
2927
2928template<typename _Tp> inline const _Tp& Seq<_Tp>::operator [](int idx) const
2929{ return *(_Tp*)getSeqElem(seq, idx); }
2930
2931template<typename _Tp> inline SeqIterator<_Tp> Seq<_Tp>::begin() const
2932{ return SeqIterator<_Tp>(*this); }
2933
2934template<typename _Tp> inline SeqIterator<_Tp> Seq<_Tp>::end() const
2935{ return SeqIterator<_Tp>(*this, true); }
2936
2937template<typename _Tp> inline size_t Seq<_Tp>::size() const
2938{ return seq ? seq->total : 0; }
2939
2940template<typename _Tp> inline int Seq<_Tp>::type() const
2941{ return seq ? CV_MAT_TYPE(seq->flags) : 0; }
2942
2943template<typename _Tp> inline int Seq<_Tp>::depth() const
2944{ return seq ? CV_MAT_DEPTH(seq->flags) : 0; }
2945
2946template<typename _Tp> inline int Seq<_Tp>::channels() const
2947{ return seq ? CV_MAT_CN(seq->flags) : 0; }
2948
2949template<typename _Tp> inline size_t Seq<_Tp>::elemSize() const
2950{ return seq ? seq->elem_size : 0; }
2951
2952template<typename _Tp> inline size_t Seq<_Tp>::index(const _Tp& elem) const
2953{ return cvSeqElemIdx(seq, &elem); }
2954
2955template<typename _Tp> inline void Seq<_Tp>::push_back(const _Tp& elem)
2956{ cvSeqPush(seq, &elem); }
2957
2958template<typename _Tp> inline void Seq<_Tp>::push_front(const _Tp& elem)
2959{ cvSeqPushFront(seq, &elem); }
2960
2961template<typename _Tp> inline void Seq<_Tp>::push_back(const _Tp* elem, size_t count)
2962{ cvSeqPushMulti(seq, elem, (int)count, 0); }
2963
2964template<typename _Tp> inline void Seq<_Tp>::push_front(const _Tp* elem, size_t count)
2965{ cvSeqPushMulti(seq, elem, (int)count, 1); }
2966
2967template<typename _Tp> inline _Tp& Seq<_Tp>::back()
2968{ return *(_Tp*)getSeqElem(seq, -1); }
2969
2970template<typename _Tp> inline const _Tp& Seq<_Tp>::back() const
2971{ return *(const _Tp*)getSeqElem(seq, -1); }
2972
2973template<typename _Tp> inline _Tp& Seq<_Tp>::front()
2974{ return *(_Tp*)getSeqElem(seq, 0); }
2975
2976template<typename _Tp> inline const _Tp& Seq<_Tp>::front() const
2977{ return *(const _Tp*)getSeqElem(seq, 0); }
2978
2979template<typename _Tp> inline bool Seq<_Tp>::empty() const
2980{ return !seq || seq->total == 0; }
2981
2982template<typename _Tp> inline void Seq<_Tp>::clear()
2983{ if(seq) clearSeq(seq); }
2984
2985template<typename _Tp> inline void Seq<_Tp>::pop_back()
2986{ seqPop(seq); }
2987
2988template<typename _Tp> inline void Seq<_Tp>::pop_front()
2989{ seqPopFront(seq); }
2990
2991template<typename _Tp> inline void Seq<_Tp>::pop_back(_Tp* elem, size_t count)
2992{ seqPopMulti(seq, elem, (int)count, 0); }
2993
2994template<typename _Tp> inline void Seq<_Tp>::pop_front(_Tp* elem, size_t count)
2995{ seqPopMulti(seq, elem, (int)count, 1); }
2996
2997template<typename _Tp> inline void Seq<_Tp>::insert(int idx, const _Tp& elem)
2998{ seqInsert(seq, idx, &elem); }
2999
3000template<typename _Tp> inline void Seq<_Tp>::insert(int idx, const _Tp* elems, size_t count)
3001{
3002 CvMat m = cvMat(1, count, DataType<_Tp>::type, elems);
3003 seqInsertSlice(seq, idx, &m);
3004}
3005
3006template<typename _Tp> inline void Seq<_Tp>::remove(int idx)
3007{ seqRemove(seq, idx); }
3008
3009template<typename _Tp> inline void Seq<_Tp>::remove(const Range& r)
3010{ seqRemoveSlice(seq, cvSlice(r.start, r.end)); }
3011
3012template<typename _Tp> inline void Seq<_Tp>::copyTo(std::vector<_Tp>& vec, const Range& range) const
3013{
3014 size_t len = !seq ? 0 : range == Range::all() ? seq->total : range.end - range.start;
3015 vec.resize(len);
3016 if( seq && len )
3017 cvCvtSeqToArray(seq, &vec[0], cvSlice(range));
3018}
3019
3020template<typename _Tp> inline Seq<_Tp>::operator std::vector<_Tp>() const
3021{
3022 std::vector<_Tp> vec;
3023 copyTo(vec);
3024 return vec;
3025}
3026
3027template<typename _Tp> inline SeqIterator<_Tp>::SeqIterator()
3028{ memset(this, 0, sizeof(*this)); }
3029
3030template<typename _Tp> inline SeqIterator<_Tp>::SeqIterator(const Seq<_Tp>& _seq, bool seekEnd)
3031{
3032 cvStartReadSeq(_seq.seq, this);
3033 index = seekEnd ? _seq.seq->total : 0;
3034}
3035
3036template<typename _Tp> inline void SeqIterator<_Tp>::seek(size_t pos)
3037{
3038 cvSetSeqReaderPos(this, (int)pos, false);
3039 index = pos;
3040}
3041
3042template<typename _Tp> inline size_t SeqIterator<_Tp>::tell() const
3043{ return index; }
3044
3045template<typename _Tp> inline _Tp& SeqIterator<_Tp>::operator *()
3046{ return *(_Tp*)ptr; }
3047
3048template<typename _Tp> inline const _Tp& SeqIterator<_Tp>::operator *() const
3049{ return *(const _Tp*)ptr; }
3050
3051template<typename _Tp> inline SeqIterator<_Tp>& SeqIterator<_Tp>::operator ++()
3052{
3053 CV_NEXT_SEQ_ELEM(sizeof(_Tp), *this);
3054 if( ++index >= seq->total*2 )
3055 index = 0;
3056 return *this;
3057}
3058
3059template<typename _Tp> inline SeqIterator<_Tp> SeqIterator<_Tp>::operator ++(int) const
3060{
3061 SeqIterator<_Tp> it = *this;
3062 ++*this;
3063 return it;
3064}
3065
3066template<typename _Tp> inline SeqIterator<_Tp>& SeqIterator<_Tp>::operator --()
3067{
3068 CV_PREV_SEQ_ELEM(sizeof(_Tp), *this);
3069 if( --index < 0 )
3070 index = seq->total*2-1;
3071 return *this;
3072}
3073
3074template<typename _Tp> inline SeqIterator<_Tp> SeqIterator<_Tp>::operator --(int) const
3075{
3076 SeqIterator<_Tp> it = *this;
3077 --*this;
3078 return it;
3079}
3080
3081template<typename _Tp> inline SeqIterator<_Tp>& SeqIterator<_Tp>::operator +=(int delta)
3082{
3083 cvSetSeqReaderPos(this, delta, 1);
3084 index += delta;
3085 int n = seq->total*2;
3086 if( index < 0 )
3087 index += n;
3088 if( index >= n )
3089 index -= n;
3090 return *this;
3091}
3092
3093template<typename _Tp> inline SeqIterator<_Tp>& SeqIterator<_Tp>::operator -=(int delta)
3094{
3095 return (*this += -delta);
3096}
3097
3098template<typename _Tp> inline ptrdiff_t operator - (const SeqIterator<_Tp>& a,
3099 const SeqIterator<_Tp>& b)
3100{
3101 ptrdiff_t delta = a.index - b.index, n = a.seq->total;
3102 if( delta > n || delta < -n )
3103 delta += delta < 0 ? n : -n;
3104 return delta;
3105}
3106
3107template<typename _Tp> inline bool operator == (const SeqIterator<_Tp>& a,
3108 const SeqIterator<_Tp>& b)
3109{
3110 return a.seq == b.seq && a.index == b.index;
3111}
3112
3113template<typename _Tp> inline bool operator != (const SeqIterator<_Tp>& a,
3114 const SeqIterator<_Tp>& b)
3115{
3116 return !(a == b);
3117}
3118
3120
3121} // cv
3122
3123#endif
3124
3125#endif
cv::copyTo
void CV_EXPORTS_W copyTo(InputArray src, OutputArray dst, InputArray mask)
This is an overloaded member function, provided for convenience (python) Copies the matrix to another...
cvMat
CV_INLINE CvMat cvMat(int rows, int cols, int type, void *data CV_DEFAULT(NULL))
Definition: core/types_c.h:551
CvCmpFunc
int(CV_CDECL * CvCmpFunc)(const void *a, const void *b, void *userdata)
Definition: core_c.h:1706
cvSetRemoveByPtr
CV_INLINE void cvSetRemoveByPtr(CvSet *set_header, void *elem)
Definition: core_c.h:1752
cvSubS
CV_INLINE void cvSubS(const CvArr *src, CvScalar value, CvArr *dst, const CvArr *mask CV_DEFAULT(NULL))
Definition: core_c.h:1062
cvGetSetElem
CV_INLINE CvSetElem * cvGetSetElem(const CvSet *set_header, int idx)
Definition: core_c.h:1767
cvIncRefData
CV_INLINE int cvIncRefData(CvArr *arr)
Increments array data reference counter.
Definition: core_c.h:324
cvGetCol
CV_INLINE CvMat * cvGetCol(const CvArr *arr, CvMat *submat, int col)
Definition: core_c.h:406
cvReleaseMatND
CV_INLINE void cvReleaseMatND(CvMatND **mat)
Deallocates a multi-dimensional array.
Definition: core_c.h:475
CVAPI
CVAPI(void *) cvAlloc(size_t size)
Changes the shape of a multi-dimensional array without copying the data.
cvDecRefData
CV_INLINE void cvDecRefData(CvArr *arr)
Decrements an array data reference counter.
Definition: core_c.h:298
cvGetNextSparseNode
CV_INLINE CvSparseNode * cvGetNextSparseNode(CvSparseMatIterator *mat_iterator)
Returns the next sparse matrix element
Definition: core_c.h:542
cvGetRow
CV_INLINE CvMat * cvGetRow(const CvArr *arr, CvMat *submat, int row)
Definition: core_c.h:380
CV_PREV_SEQ_ELEM
#define CV_PREV_SEQ_ELEM(elem_size, reader)
Definition: core/types_c.h:1931
CvNArrayIterator
struct CvNArrayIterator CvNArrayIterator
CV_NEXT_SEQ_ELEM
#define CV_NEXT_SEQ_ELEM(elem_size, reader)
Definition: core/types_c.h:1921
CvArr
void CvArr
This is the "metatype" used only as a function parameter.
Definition: core/types_c.h:139
cvSetNew
CV_INLINE CvSetElem * cvSetNew(CvSet *set_header)
Definition: core_c.h:1737
CV_IS_SET_ELEM
#define CV_IS_SET_ELEM(ptr)
Definition: core/types_c.h:1614
cv::operator*
CV_INLINE v_reg< _Tp, n > operator*(const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
Multiply values
cv::operator-
CV_INLINE v_reg< _Tp, n > operator-(const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
Subtract values
cvRound
CV_INLINE int cvRound(double value)
Rounds floating-point number to the nearest integer
Definition: fast_math.hpp:200
CV_Assert
#define CV_Assert(expr)
Checks a condition at runtime and throws exception if it fails
Definition: base.hpp:342
cv
"black box" representation of the file storage associated with a file on disk.
Definition: aruco.hpp:75
_IplImage
Definition: core/types_c.h:328
_IplROI
Definition: core/types_c.h:383
CvGraphEdge
Definition: core/types_c.h:1651
CvGraph
Definition: core/types_c.h:1678
CvGraphScanner
Definition: core_c.h:1861
CvGraphVtx
Definition: core/types_c.h:1657
CvMat
Definition: core/types_c.h:469
CvMatND
Definition: core/types_c.h:690
CvMemStorage
Definition: core/types_c.h:1498
CvMemStoragePos
Definition: core/types_c.h:1514
CvNArrayIterator
Definition: core_c.h:567
CvNArrayIterator::stack
int stack[CV_MAX_DIM]
Definition: core_c.h:572
CvNArrayIterator::size
CvSize size
Definition: core_c.h:570
CvNArrayIterator::count
int count
Definition: core_c.h:568
CvNArrayIterator::dims
int dims
Definition: core_c.h:569
CvNArrayIterator::hdr
CvMatND * hdr[CV_MAX_ARR]
Definition: core_c.h:573
CvNArrayIterator::ptr
uchar * ptr[CV_MAX_ARR]
Definition: core_c.h:571
CvPoint
Definition: core/types_c.h:951
CvRect
Definition: core/types_c.h:848
CvScalar
Definition: core/types_c.h:1383
CvSeqBlock
Definition: core/types_c.h:1524
CvSeq
Definition: core/types_c.h:1574
CvSeqReader
Definition: core/types_c.h:1877
CvSeqWriter
Definition: core/types_c.h:1852
CvSetElem
Definition: core/types_c.h:1593
CvSet
Definition: core/types_c.h:1604
CvSize
Definition: core/types_c.h:1174
CvSlice
Definition: core/types_c.h:1337
CvSparseMat
Definition: core/types_c.h:747
CvSparseMatIterator
Definition: core/types_c.h:787
CvSparseNode
Definition: core/types_c.h:780
CvTermCriteria
Definition: core/types_c.h:918
CvTreeNodeIterator
Definition: core_c.h:1895
構築: doxygen 1.9.2