OpenCV 4.5.3(日本語機械翻訳)
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
65 extern "C" {
66 #endif
67
72 /****************************************************************************************\
73 * Array allocation, deallocation, initialization and access to elements *
74 \****************************************************************************************/
75
80 CVAPI(void*) cvAlloc( size_t size );
81
88 CVAPI(void) cvFree_( void* ptr );
89 #define cvFree(ptr) (cvFree_(*(ptr)), *(ptr)=0)
90
97 CVAPI(IplImage*) cvCreateImageHeader( CvSize size, int depth, int channels );
98
109 CVAPI(IplImage*) cvInitImageHeader( IplImage* image, CvSize size, int depth,
110 int channels, int origin CV_DEFAULT(0),
111 int align CV_DEFAULT(4));
112
125 CVAPI(IplImage*) cvCreateImage( CvSize size, int depth, int channels );
126
140 CVAPI(void) cvReleaseImageHeader( IplImage** image );
141
154 CVAPI(void) cvReleaseImage( IplImage** image );
155
157 CVAPI(IplImage*) cvCloneImage( const IplImage* image );
158
169 CVAPI(void) cvSetImageCOI( IplImage* image, int coi );
170
177 CVAPI(int) cvGetImageCOI( const IplImage* image );
178
190 CVAPI(void) cvSetImageROI( IplImage* image, CvRect rect );
191
201 CVAPI(void) cvResetImageROI( IplImage* image );
202
208 CVAPI(CvRect) cvGetImageROI( const IplImage* image );
209
218 CVAPI(CvMat*) cvCreateMatHeader( int rows, int cols, int type );
219
220 #define CV_AUTOSTEP 0x7fffffff
221
254 CVAPI(CvMat*) cvInitMatHeader( CvMat* mat, int rows, int cols,
255 int type, void* data CV_DEFAULT(NULL),
256 int step CV_DEFAULT(CV_AUTOSTEP) );
257
272 CVAPI(CvMat*) cvCreateMat( int rows, int cols, int type );
273
285 CVAPI(void) cvReleaseMat( CvMat** mat );
286
298 CV_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
324 CV_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
344 CVAPI(CvMat*) cvCloneMat( const CvMat* mat );
345
346
357 CVAPI(CvMat*) cvGetSubRect( const CvArr* arr, CvMat* submat, CvRect rect );
358 #define cvGetSubArr cvGetSubRect
359
371 CVAPI(CvMat*) cvGetRows( const CvArr* arr, CvMat* submat,
372 int start_row, int end_row,
373 int delta_row CV_DEFAULT(1));
374
380 CV_INLINE CvMat* cvGetRow( const CvArr* arr, CvMat* submat, int row )
381{
382 return cvGetRows( arr, submat, row, row + 1, 1 );
383}
384
385
398 CVAPI(CvMat*) cvGetCols( const CvArr* arr, CvMat* submat,
399 int start_col, int end_col );
400
406 CV_INLINE CvMat* cvGetCol( const CvArr* arr, CvMat* submat, int col )
407{
408 return cvGetCols( arr, submat, col, col + 1 );
409}
410
420 CVAPI(CvMat*) cvGetDiag( const CvArr* arr, CvMat* submat,
421 int diag CV_DEFAULT(0));
422
424 CVAPI(void) cvScalarToRawData( const CvScalar* scalar, void* data, int type,
425 int extend_to_12 CV_DEFAULT(0) );
426
427 CVAPI(void) cvRawDataToScalar( const void* data, int type, CvScalar* scalar );
428
437 CVAPI(CvMatND*) cvCreateMatNDHeader( int dims, const int* sizes, int type );
438
451 CVAPI(CvMatND*) cvCreateMatND( int dims, const int* sizes, int type );
452
461 CVAPI(CvMatND*) cvInitMatNDHeader( CvMatND* mat, int dims, const int* sizes,
462 int type, void* data CV_DEFAULT(NULL) );
463
475 CV_INLINE void cvReleaseMatND( CvMatND** mat )
476{
477 cvReleaseMat( (CvMat**)mat );
478}
479
481 CVAPI(CvMatND*) cvCloneMatND( const CvMatND* mat );
482
492 CVAPI(CvSparseMat*) cvCreateSparseMat( int dims, const int* sizes, int type );
493
499 CVAPI(void) cvReleaseSparseMat( CvSparseMat** mat );
500
502 CVAPI(CvSparseMat*) cvCloneSparseMat( const CvSparseMat* mat );
503
511 CVAPI(CvSparseNode*) cvInitSparseMatIterator( const CvSparseMat* mat,
512 CvSparseMatIterator* mat_iterator );
513
542 CV_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
566 typedef 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}
576 CvNArrayIterator;
577
578 #define CV_NO_DEPTH_CHECK 1
579 #define CV_NO_CN_CHECK 2
580 #define CV_NO_SIZE_CHECK 4
581
585 CVAPI(int) cvInitNArrayIterator( int count, CvArr** arrs,
586 const CvArr* mask, CvMatND* stubs,
587 CvNArrayIterator* array_iterator,
588 int flags CV_DEFAULT(0) );
589
591 CVAPI(int) cvNextNArraySlice( CvNArrayIterator* array_iterator );
592
593
604 CVAPI(int) cvGetElemType( const CvArr* arr );
605
622 CVAPI(int) cvGetDims( const CvArr* arr, int* sizes CV_DEFAULT(NULL) );
623
624
631 CVAPI(int) cvGetDimSize( const CvArr* arr, int index );
632
633
649 CVAPI(uchar*) cvPtr1D( const CvArr* arr, int idx0, int* type CV_DEFAULT(NULL));
651 CVAPI(uchar*) cvPtr2D( const CvArr* arr, int idx0, int idx1, int* type CV_DEFAULT(NULL) );
653 CVAPI(uchar*) cvPtr3D( const CvArr* arr, int idx0, int idx1, int idx2,
654 int* type CV_DEFAULT(NULL));
665 CVAPI(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
676 CVAPI(CvScalar) cvGet1D( const CvArr* arr, int idx0 );
678 CVAPI(CvScalar) cvGet2D( const CvArr* arr, int idx0, int idx1 );
680 CVAPI(CvScalar) cvGet3D( const CvArr* arr, int idx0, int idx1, int idx2 );
685 CVAPI(CvScalar) cvGetND( const CvArr* arr, const int* idx );
686
698 CVAPI(double) cvGetReal1D( const CvArr* arr, int idx0 );
700 CVAPI(double) cvGetReal2D( const CvArr* arr, int idx0, int idx1 );
702 CVAPI(double) cvGetReal3D( const CvArr* arr, int idx0, int idx1, int idx2 );
707 CVAPI(double) cvGetRealND( const CvArr* arr, const int* idx );
708
717 CVAPI(void) cvSet1D( CvArr* arr, int idx0, CvScalar value );
719 CVAPI(void) cvSet2D( CvArr* arr, int idx0, int idx1, CvScalar value );
721 CVAPI(void) cvSet3D( CvArr* arr, int idx0, int idx1, int idx2, CvScalar value );
727 CVAPI(void) cvSetND( CvArr* arr, const int* idx, CvScalar value );
728
740 CVAPI(void) cvSetReal1D( CvArr* arr, int idx0, double value );
742 CVAPI(void) cvSetReal2D( CvArr* arr, int idx0, int idx1, double value );
744 CVAPI(void) cvSetReal3D( CvArr* arr, int idx0,
745 int idx1, int idx2, double value );
751 CVAPI(void) cvSetRealND( CvArr* arr, const int* idx, double value );
752
755 CVAPI(void) cvClearND( CvArr* arr, const int* idx );
756
779 CVAPI(CvMat*) cvGetMat( const CvArr* arr, CvMat* header,
780 int* coi CV_DEFAULT(NULL),
781 int allowND CV_DEFAULT(0));
782
793 CVAPI(IplImage*) cvGetImage( const CvArr* arr, IplImage* image_header );
794
795
832 CVAPI(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
867 CVAPI(CvMat*) cvReshape( const CvArr* arr, CvMat* header,
868 int new_cn, int new_rows CV_DEFAULT(0) );
869
872 CVAPI(void) cvRepeat( const CvArr* src, CvArr* dst );
873
882 CVAPI(void) cvCreateData( CvArr* arr );
883
891 CVAPI(void) cvReleaseData( CvArr* arr );
892
902 CVAPI(void) cvSetData( CvArr* arr, void* data, int step );
903
930 CVAPI(void) cvGetRawData( const CvArr* arr, uchar** data,
931 int* step CV_DEFAULT(NULL),
932 CvSize* roi_size CV_DEFAULT(NULL));
933
940 CVAPI(CvSize) cvGetSize( const CvArr* arr );
941
956 CVAPI(void) cvCopy( const CvArr* src, CvArr* dst,
957 const CvArr* mask CV_DEFAULT(NULL) );
958
969 CVAPI(void) cvSet( CvArr* arr, CvScalar value,
970 const CvArr* mask CV_DEFAULT(NULL) );
971
979 CVAPI(void) cvSetZero( CvArr* arr );
980 #define cvZero cvSetZero
981
982
985 CVAPI(void) cvSplit( const CvArr* src, CvArr* dst0, CvArr* dst1,
986 CvArr* dst2, CvArr* dst3 );
987
990 CVAPI(void) cvMerge( const CvArr* src0, const CvArr* src1,
991 const CvArr* src2, const CvArr* src3,
992 CvArr* dst );
993
996 CVAPI(void) cvMixChannels( const CvArr** src, int src_count,
997 CvArr** dst, int dst_count,
998 const int* from_to, int pair_count );
999
1018 CVAPI(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
1031 CVAPI(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
1041 CVAPI(CvTermCriteria) cvCheckTermCriteria( CvTermCriteria criteria,
1042 double default_eps,
1043 int default_max_iters );
1044
1045 /****************************************************************************************\
1046 * Arithmetic, logic and comparison operations *
1047 \****************************************************************************************/
1048
1050 CVAPI(void) cvAdd( const CvArr* src1, const CvArr* src2, CvArr* dst,
1051 const CvArr* mask CV_DEFAULT(NULL));
1052
1054 CVAPI(void) cvAddS( const CvArr* src, CvScalar value, CvArr* dst,
1055 const CvArr* mask CV_DEFAULT(NULL));
1056
1058 CVAPI(void) cvSub( const CvArr* src1, const CvArr* src2, CvArr* dst,
1059 const CvArr* mask CV_DEFAULT(NULL));
1060
1062 CV_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
1070 CVAPI(void) cvSubRS( const CvArr* src, CvScalar value, CvArr* dst,
1071 const CvArr* mask CV_DEFAULT(NULL));
1072
1075 CVAPI(void) cvMul( const CvArr* src1, const CvArr* src2,
1076 CvArr* dst, double scale CV_DEFAULT(1) );
1077
1081 CVAPI(void) cvDiv( const CvArr* src1, const CvArr* src2,
1082 CvArr* dst, double scale CV_DEFAULT(1));
1083
1085 CVAPI(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
1090 CVAPI(void) cvAddWeighted( const CvArr* src1, double alpha,
1091 const CvArr* src2, double beta,
1092 double gamma, CvArr* dst );
1093
1106 CVAPI(double) cvDotProduct( const CvArr* src1, const CvArr* src2 );
1107
1109 CVAPI(void) cvAnd( const CvArr* src1, const CvArr* src2,
1110 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
1111
1113 CVAPI(void) cvAndS( const CvArr* src, CvScalar value,
1114 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
1115
1117 CVAPI(void) cvOr( const CvArr* src1, const CvArr* src2,
1118 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
1119
1121 CVAPI(void) cvOrS( const CvArr* src, CvScalar value,
1122 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
1123
1125 CVAPI(void) cvXor( const CvArr* src1, const CvArr* src2,
1126 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
1127
1129 CVAPI(void) cvXorS( const CvArr* src, CvScalar value,
1130 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
1131
1133 CVAPI(void) cvNot( const CvArr* src, CvArr* dst );
1134
1136 CVAPI(void) cvInRange( const CvArr* src, const CvArr* lower,
1137 const CvArr* upper, CvArr* dst );
1138
1140 CVAPI(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
1154 CVAPI(void) cvCmp( const CvArr* src1, const CvArr* src2, CvArr* dst, int cmp_op );
1155
1157 CVAPI(void) cvCmpS( const CvArr* src, double value, CvArr* dst, int cmp_op );
1158
1160 CVAPI(void) cvMin( const CvArr* src1, const CvArr* src2, CvArr* dst );
1161
1163 CVAPI(void) cvMax( const CvArr* src1, const CvArr* src2, CvArr* dst );
1164
1166 CVAPI(void) cvMinS( const CvArr* src, double value, CvArr* dst );
1167
1169 CVAPI(void) cvMaxS( const CvArr* src, double value, CvArr* dst );
1170
1172 CVAPI(void) cvAbsDiff( const CvArr* src1, const CvArr* src2, CvArr* dst );
1173
1175 CVAPI(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
1184 CVAPI(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
1191 CVAPI(void) cvPolarToCart( const CvArr* magnitude, const CvArr* angle,
1192 CvArr* x, CvArr* y,
1193 int angle_in_degrees CV_DEFAULT(0));
1194
1196 CVAPI(void) cvPow( const CvArr* src, CvArr* dst, double power );
1197
1201 CVAPI(void) cvExp( const CvArr* src, CvArr* dst );
1202
1207 CVAPI(void) cvLog( const CvArr* src, CvArr* dst );
1208
1210 CVAPI(float) cvFastArctan( float y, float x );
1211
1213 CVAPI(float) cvCbrt( float value );
1214
1215 #define CV_CHECK_RANGE 1
1216 #define CV_CHECK_QUIET 2
1221 CVAPI(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
1244 CVAPI(void) cvRandArr( CvRNG* rng, CvArr* arr, int dist_type,
1245 CvScalar param1, CvScalar param2 );
1246
1247 CVAPI(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
1255 CVAPI(void) cvSort( const CvArr* src, CvArr* dst CV_DEFAULT(NULL),
1256 CvArr* idxmat CV_DEFAULT(NULL),
1257 int flags CV_DEFAULT(0));
1258
1260 CVAPI(int) cvSolveCubic( const CvMat* coeffs, CvMat* roots );
1261
1263 CVAPI(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
1280 CVAPI(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
1291 CVAPI(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
1298 CVAPI(void) cvTransform( const CvArr* src, CvArr* dst,
1299 const CvMat* transmat,
1300 const CvMat* shiftvec CV_DEFAULT(NULL));
1301 #define cvMatMulAddS cvTransform
1302
1304 CVAPI(void) cvPerspectiveTransform( const CvArr* src, CvArr* dst,
1305 const CvMat* mat );
1306
1308 CVAPI(void) cvMulTransposed( const CvArr* src, CvArr* dst, int order,
1309 const CvArr* delta CV_DEFAULT(NULL),
1310 double scale CV_DEFAULT(1.) );
1311
1313 CVAPI(void) cvTranspose( const CvArr* src, CvArr* dst );
1314 #define cvT cvTranspose
1315
1317 CVAPI(void) cvCompleteSymm( CvMat* matrix, int LtoR CV_DEFAULT(0) );
1318
1322 CVAPI(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
1332 CVAPI(void) cvSVD( CvArr* A, CvArr* W, CvArr* U CV_DEFAULT(NULL),
1333 CvArr* V CV_DEFAULT(NULL), int flags CV_DEFAULT(0));
1334
1337 CVAPI(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
1349 CVAPI(double) cvInvert( const CvArr* src, CvArr* dst,
1350 int method CV_DEFAULT(CV_LU));
1351 #define cvInv cvInvert
1352
1355 CVAPI(int) cvSolve( const CvArr* src1, const CvArr* src2, CvArr* dst,
1356 int method CV_DEFAULT(CV_LU));
1357
1359 CVAPI(double) cvDet( const CvArr* mat );
1360
1362 CVAPI(CvScalar) cvTrace( const CvArr* mat );
1363
1365 CVAPI(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
1375 CVAPI(void) cvSetIdentity( CvArr* mat, CvScalar value CV_DEFAULT(cvRealScalar(1)) );
1376
1378 CVAPI(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
1410 CVAPI(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
1416 CVAPI(void) cvCalcPCA( const CvArr* data, CvArr* mean,
1417 CvArr* eigenvals, CvArr* eigenvects, int flags );
1418
1419 CVAPI(void) cvProjectPCA( const CvArr* data, const CvArr* mean,
1420 const CvArr* eigenvects, CvArr* result );
1421
1422 CVAPI(void) cvBackProjectPCA( const CvArr* proj, const CvArr* mean,
1423 const CvArr* eigenvects, CvArr* result );
1424
1426 CVAPI(double) cvMahalanobis( const CvArr* vec1, const CvArr* vec2, const CvArr* mat );
1427 #define cvMahalonobis cvMahalanobis
1428
1429 /****************************************************************************************\
1430 * Array Statistics *
1431 \****************************************************************************************/
1432
1434 CVAPI(CvScalar) cvSum( const CvArr* arr );
1435
1437 CVAPI(int) cvCountNonZero( const CvArr* arr );
1438
1440 CVAPI(CvScalar) cvAvg( const CvArr* arr, const CvArr* mask CV_DEFAULT(NULL) );
1441
1443 CVAPI(void) cvAvgSdv( const CvArr* arr, CvScalar* mean, CvScalar* std_dev,
1444 const CvArr* mask CV_DEFAULT(NULL) );
1445
1447 CVAPI(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)
1475 CVAPI(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
1480 CVAPI(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
1496 CVAPI(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
1522 CVAPI(void) cvDFT( const CvArr* src, CvArr* dst, int flags,
1523 int nonzero_rows CV_DEFAULT(0) );
1524 #define cvFFT cvDFT
1525
1529 CVAPI(void) cvMulSpectrums( const CvArr* src1, const CvArr* src2,
1530 CvArr* dst, int flags );
1531
1533 CVAPI(int) cvGetOptimalDFTSize( int size0 );
1534
1538 CVAPI(void) cvDCT( const CvArr* src, CvArr* dst, int flags );
1539
1540 /****************************************************************************************\
1541 * Dynamic data structures *
1542 \****************************************************************************************/
1543
1545 CVAPI(int) cvSliceLength( CvSlice slice, const CvSeq* seq );
1546
1547
1551 CVAPI(CvMemStorage*) cvCreateMemStorage( int block_size CV_DEFAULT(0));
1552
1553
1555 CVAPI(CvMemStorage*) cvCreateChildMemStorage( CvMemStorage* parent );
1556
1557
1560 CVAPI(void) cvReleaseMemStorage( CvMemStorage** storage );
1561
1562
1567 CVAPI(void) cvClearMemStorage( CvMemStorage* storage );
1568
1570 CVAPI(void) cvSaveMemStoragePos( const CvMemStorage* storage, CvMemStoragePos* pos );
1571
1573 CVAPI(void) cvRestoreMemStoragePos( CvMemStorage* storage, CvMemStoragePos* pos );
1574
1576 CVAPI(void*) cvMemStorageAlloc( CvMemStorage* storage, size_t size );
1577
1579 //CVAPI(CvString) cvMemStorageAllocString( CvMemStorage* storage, const char* ptr,
1580 // int len CV_DEFAULT(-1) );
1581
1583 CVAPI(CvSeq*) cvCreateSeq( int seq_flags, size_t header_size,
1584 size_t elem_size, CvMemStorage* storage );
1585
1588 CVAPI(void) cvSetSeqBlockSize( CvSeq* seq, int delta_elems );
1589
1590
1592 CVAPI(schar*) cvSeqPush( CvSeq* seq, const void* element CV_DEFAULT(NULL));
1593
1594
1596 CVAPI(schar*) cvSeqPushFront( CvSeq* seq, const void* element CV_DEFAULT(NULL));
1597
1598
1600 CVAPI(void) cvSeqPop( CvSeq* seq, void* element CV_DEFAULT(NULL));
1601
1602
1604 CVAPI(void) cvSeqPopFront( CvSeq* seq, void* element CV_DEFAULT(NULL));
1605
1606
1607 #define CV_FRONT 1
1608 #define CV_BACK 0
1610 CVAPI(void) cvSeqPushMulti( CvSeq* seq, const void* elements,
1611 int count, int in_front CV_DEFAULT(0) );
1612
1614 CVAPI(void) cvSeqPopMulti( CvSeq* seq, void* elements,
1615 int count, int in_front CV_DEFAULT(0) );
1616
1619 CVAPI(schar*) cvSeqInsert( CvSeq* seq, int before_index,
1620 const void* element CV_DEFAULT(NULL));
1621
1623 CVAPI(void) cvSeqRemove( CvSeq* seq, int index );
1624
1625
1629 CVAPI(void) cvClearSeq( CvSeq* seq );
1630
1631
1635 CVAPI(schar*) cvGetSeqElem( const CvSeq* seq, int index );
1636
1639 CVAPI(int) cvSeqElemIdx( const CvSeq* seq, const void* element,
1640 CvSeqBlock** block CV_DEFAULT(NULL) );
1641
1643 CVAPI(void) cvStartAppendToSeq( CvSeq* seq, CvSeqWriter* writer );
1644
1645
1647 CVAPI(void) cvStartWriteSeq( int seq_flags, int header_size,
1648 int elem_size, CvMemStorage* storage,
1649 CvSeqWriter* writer );
1650
1655 CVAPI(CvSeq*) cvEndWriteSeq( CvSeqWriter* writer );
1656
1657
1660 CVAPI(void) cvFlushSeqWriter( CvSeqWriter* writer );
1661
1662
1665 CVAPI(void) cvStartReadSeq( const CvSeq* seq, CvSeqReader* reader,
1666 int reverse CV_DEFAULT(0) );
1667
1668
1670 CVAPI(int) cvGetSeqReaderPos( CvSeqReader* reader );
1671
1672
1675 CVAPI(void) cvSetSeqReaderPos( CvSeqReader* reader, int index,
1676 int is_relative CV_DEFAULT(0));
1677
1679 CVAPI(void*) cvCvtSeqToArray( const CvSeq* seq, void* elements,
1680 CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ) );
1681
1685 CVAPI(CvSeq*) cvMakeSeqHeaderForArray( int seq_type, int header_size,
1686 int elem_size, void* elements, int total,
1687 CvSeq* seq, CvSeqBlock* block );
1688
1690 CVAPI(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
1700 CVAPI(void) cvSeqRemoveSlice( CvSeq* seq, CvSlice slice );
1701
1703 CVAPI(void) cvSeqInsertSlice( CvSeq* seq, int before_index, const CvArr* from_arr );
1704
1706 typedef int (CV_CDECL* CvCmpFunc)(const void* a, const void* b, void* userdata );
1707
1709 CVAPI(void) cvSeqSort( CvSeq* seq, CvCmpFunc func, void* userdata CV_DEFAULT(NULL) );
1710
1712 CVAPI(schar*) cvSeqSearch( CvSeq* seq, const void* elem, CvCmpFunc func,
1713 int is_sorted, int* elem_idx,
1714 void* userdata CV_DEFAULT(NULL) );
1715
1717 CVAPI(void) cvSeqInvert( CvSeq* seq );
1718
1720 CVAPI(int) cvSeqPartition( const CvSeq* seq, CvMemStorage* storage,
1721 CvSeq** labels, CvCmpFunc is_equal, void* userdata );
1722
1723 /************ Internal sequence functions ************/
1724 CVAPI(void) cvChangeSeqBlock( void* reader, int direction );
1725 CVAPI(void) cvCreateSeqBlock( CvSeqWriter* writer );
1726
1727
1729 CVAPI(CvSet*) cvCreateSet( int set_flags, int header_size,
1730 int elem_size, CvMemStorage* storage );
1731
1733 CVAPI(int) cvSetAdd( CvSet* set_header, CvSetElem* elem CV_DEFAULT(NULL),
1734 CvSetElem** inserted_elem CV_DEFAULT(NULL) );
1735
1737 CV_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
1752 CV_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
1763 CVAPI(void) cvSetRemove( CvSet* set_header, int index );
1764
1767 CV_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
1774 CVAPI(void) cvClearSet( CvSet* set_header );
1775
1777 CVAPI(CvGraph*) cvCreateGraph( int graph_flags, int header_size,
1778 int vtx_size, int edge_size,
1779 CvMemStorage* storage );
1780
1782 CVAPI(int) cvGraphAddVtx( CvGraph* graph, const CvGraphVtx* vtx CV_DEFAULT(NULL),
1783 CvGraphVtx** inserted_vtx CV_DEFAULT(NULL) );
1784
1785
1787 CVAPI(int) cvGraphRemoveVtx( CvGraph* graph, int index );
1788 CVAPI(int) cvGraphRemoveVtxByPtr( CvGraph* graph, CvGraphVtx* vtx );
1789
1790
1795 CVAPI(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
1800 CVAPI(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
1806 CVAPI(void) cvGraphRemoveEdge( CvGraph* graph, int start_idx, int end_idx );
1807 CVAPI(void) cvGraphRemoveEdgeByPtr( CvGraph* graph, CvGraphVtx* start_vtx,
1808 CvGraphVtx* end_vtx );
1809
1811 CVAPI(CvGraphEdge*) cvFindGraphEdge( const CvGraph* graph, int start_idx, int end_idx );
1812 CVAPI(CvGraphEdge*) cvFindGraphEdgeByPtr( const CvGraph* graph,
1813 const CvGraphVtx* start_vtx,
1814 const CvGraphVtx* end_vtx );
1815 #define cvGraphFindEdge cvFindGraphEdge
1816 #define cvGraphFindEdgeByPtr cvFindGraphEdgeByPtr
1817
1819 CVAPI(void) cvClearGraph( CvGraph* graph );
1820
1821
1823 CVAPI(int) cvGraphVtxDegree( const CvGraph* graph, int vtx_idx );
1824 CVAPI(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
1860 typedef 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}
1871 CvGraphScanner;
1872
1874 CVAPI(CvGraphScanner*) cvCreateGraphScanner( CvGraph* graph,
1875 CvGraphVtx* vtx CV_DEFAULT(NULL),
1876 int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS));
1877
1879 CVAPI(void) cvReleaseGraphScanner( CvGraphScanner** scanner );
1880
1882 CVAPI(int) cvNextGraphItem( CvGraphScanner* scanner );
1883
1885 CVAPI(CvGraph*) cvCloneGraph( const CvGraph* graph, CvMemStorage* storage );
1886
1887
1890 CVAPI(void) cvLUT( const CvArr* src, CvArr* dst, const CvArr* lut );
1891
1892
1893 /******************* Iteration through the sequence tree *****************/
1894 typedef struct CvTreeNodeIterator
1895{
1896 const void* node;
1897 int level;
1898 int max_level;
1899}
1900 CvTreeNodeIterator;
1901
1902 CVAPI(void) cvInitTreeNodeIterator( CvTreeNodeIterator* tree_iterator,
1903 const void* first, int max_level );
1904 CVAPI(void*) cvNextTreeNode( CvTreeNodeIterator* tree_iterator );
1905 CVAPI(void*) cvPrevTreeNode( CvTreeNodeIterator* tree_iterator );
1906
1910 CVAPI(void) cvInsertNodeIntoTree( void* node, void* parent, void* frame );
1911
1913 CVAPI(void) cvRemoveNodeFromTree( void* node, void* frame );
1914
1917 CVAPI(CvSeq*) cvTreeToNodeSeq( const void* first, int header_size,
1918 CvMemStorage* storage );
1919
1922 #define CV_KMEANS_USE_INITIAL_LABELS 1
1923 CVAPI(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
1933 CVAPI(int) cvUseOptimized( int on_off );
1934
1935 typedef IplImage* (CV_STDCALL* Cv_iplCreateImageHeader)
1936 (int,int,int,char*,char*,int,int,int,int,int,
1937 IplROI*,IplImage*,void*,IplTileInfo*);
1938 typedef void (CV_STDCALL* Cv_iplAllocateImageData)(IplImage*,int,int);
1939 typedef void (CV_STDCALL* Cv_iplDeallocate)(IplImage*,int);
1940 typedef IplROI* (CV_STDCALL* Cv_iplCreateROI)(int,int,int,int,int);
1941 typedef IplImage* (CV_STDCALL* Cv_iplCloneImage)(const IplImage*);
1942
1959 CVAPI(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
1996 CVAPI(CvFileStorage*) cvOpenFileStorage( const char* filename, CvMemStorage* memstorage,
1997 int flags, const char* encoding CV_DEFAULT(NULL) );
1998
2005 CVAPI(void) cvReleaseFileStorage( CvFileStorage** fs );
2006
2008 CVAPI(const char*) cvAttrValue( const CvAttrList* attr, const char* attr_name );
2009
2036 CVAPI(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
2044 CVAPI(void) cvEndWriteStruct( CvFileStorage* fs );
2045
2054 CVAPI(void) cvWriteInt( CvFileStorage* fs, const char* name, int value );
2055
2081 CVAPI(void) cvWriteReal( CvFileStorage* fs, const char* name, double value );
2082
2094 CVAPI(void) cvWriteString( CvFileStorage* fs, const char* name,
2095 const char* str, int quote CV_DEFAULT(0) );
2096
2106 CVAPI(void) cvWriteComment( CvFileStorage* fs, const char* comment,
2107 int eol_comment );
2108
2154 CVAPI(void) cvWrite( CvFileStorage* fs, const char* name, const void* ptr,
2155 CvAttrList attributes CV_DEFAULT(cvAttrList()));
2156
2181 CVAPI(void) cvStartNextStream( CvFileStorage* fs );
2182
2194 CVAPI(void) cvWriteRawData( CvFileStorage* fs, const void* src,
2195 int len, const char* dt );
2196
2211 CVAPI(void) cvWriteRawDataBase64( CvFileStorage* fs, const void* src,
2212 int len, const char* dt );
2213
2282 CVAPI(CvStringHashNode*) cvGetHashedKey( CvFileStorage* fs, const char* name,
2283 int len CV_DEFAULT(-1),
2284 int create_missing CV_DEFAULT(0));
2285
2297 CVAPI(CvFileNode*) cvGetRootFileNode( const CvFileStorage* fs,
2298 int stream_index CV_DEFAULT(0) );
2299
2310 CVAPI(CvFileNode*) cvGetFileNode( CvFileStorage* fs, CvFileNode* map,
2311 const CvStringHashNode* key,
2312 int create_missing CV_DEFAULT(0) );
2313
2326 CVAPI(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
2436 CVAPI(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
2462 CVAPI(void) cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src,
2463 CvSeqReader* reader );
2464
2478 CVAPI(void) cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader,
2479 int count, void* dst, const char* dt );
2480
2489 CVAPI(void) cvReadRawData( const CvFileStorage* fs, const CvFileNode* src,
2490 void* dst, const char* dt );
2491
2505 CVAPI(void) cvWriteFileNode( CvFileStorage* fs, const char* new_node_name,
2506 const CvFileNode* node, int embed );
2507
2514 CVAPI(const char*) cvGetFileNodeName( const CvFileNode* node );
2515
2516 /*********************************** Adding own types ***********************************/
2517
2524 CVAPI(void) cvRegisterType( const CvTypeInfo* info );
2525
2533 CVAPI(void) cvUnregisterType( const char* type_name );
2534
2540 CVAPI(CvTypeInfo*) cvFirstType(void);
2541
2548 CVAPI(CvTypeInfo*) cvFindType( const char* type_name );
2549
2558 CVAPI(CvTypeInfo*) cvTypeOf( const void* struct_ptr );
2559
2560 #endif
2561
2567 CVAPI(void) cvRelease( void** struct_ptr );
2568
2576 CVAPI(void*) cvClone( const void* struct_ptr );
2577
2578 /*********************************** Measuring Execution Time ***************************/
2579
2582 CVAPI(int64) cvGetTickCount( void );
2583 CVAPI(double) cvGetTickFrequency( void );
2584
2585 /*********************************** CPU capabilities ***********************************/
2586
2587 CVAPI(int) cvCheckHardwareSupport(int feature);
2588
2589 /*********************************** Multi-Threading ************************************/
2590
2592 CVAPI(int) cvGetNumThreads( void );
2593 CVAPI(void) cvSetNumThreads( int threads CV_DEFAULT(0) );
2595 CVAPI(int) cvGetThreadNum( void );
2596
2597
2598 /********************************** Error Handling **************************************/
2599
2601 CVAPI(int) cvGetErrStatus( void );
2602
2604 CVAPI(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
2611 CVAPI(int) cvGetErrMode( void );
2612
2614 CVAPI(int) cvSetErrMode( int mode );
2615
2619 CVAPI(void) cvError( int status, const char* func_name,
2620 const char* err_msg, const char* file_name, int line );
2621
2623 CVAPI(const char*) cvErrorStr( int status );
2624
2626 CVAPI(int) cvGetErrInfo( const char** errcode_desc, const char** description,
2627 const char** filename, int* line );
2628
2630 CVAPI(int) cvErrorFromIppStatus( int ipp_status );
2631
2632 typedef int (CV_CDECL *CvErrorCallback)( int status, const char* func_name,
2633 const char* err_msg, const char* file_name, int line, void* userdata );
2634
2636 CVAPI(CvErrorCallback) cvRedirectError( CvErrorCallback error_handler,
2637 void* userdata CV_DEFAULT(NULL),
2638 void** prev_userdata CV_DEFAULT(NULL) );
2639
2641 CVAPI(int) cvNulDevReport( int status, const char* func_name, const char* err_msg,
2642 const char* file_name, int line, void* userdata );
2643
2645 CVAPI(int) cvStdErrReport( int status, const char* func_name, const char* err_msg,
2646 const char* file_name, int line, void* userdata );
2647
2649 CVAPI(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) \
2653 cvError((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 { \
2661 Func; \
2662 }
2663
2664
2666 #ifdef CV_NO_FUNC_NAMES
2667 #define CV_FUNCNAME( Name )
2668 #define cvFuncName ""
2669 #else
2670 #define CV_FUNCNAME( Name ) \
2671 static 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
2730 namespace 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
2743 static 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
2758 template<> struct DefaultDeleter<CvMat>{ CV_EXPORTS void operator ()(CvMat* obj) const; };
2759 template<> struct DefaultDeleter<IplImage>{ CV_EXPORTS void operator ()(IplImage* obj) const; };
2760 template<> struct DefaultDeleter<CvMatND>{ CV_EXPORTS void operator ()(CvMatND* obj) const; };
2761 template<> struct DefaultDeleter<CvSparseMat>{ CV_EXPORTS void operator ()(CvSparseMat* obj) const; };
2762 template<> struct DefaultDeleter<CvMemStorage>{ CV_EXPORTS void operator ()(CvMemStorage* obj) const; };
2763
2765
2766 template<typename _Tp> class SeqIterator;
2767
2768 typedef Ptr<CvMemStorage> MemStorage;
2769
2780 template<typename _Tp> class Seq
2781{
2782 public:
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
2863 template<typename _Tp> class SeqIterator : public CvSeqReader
2864{
2865 public:
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
2912 template<typename _Tp> inline Seq<_Tp>::Seq() : seq(0) {}
2913 template<typename _Tp> inline Seq<_Tp>::Seq( const CvSeq* _seq ) : seq((CvSeq*)_seq)
2914{
2915 CV_Assert(!_seq || _seq->elem_size == sizeof(_Tp));
2916}
2917
2918 template<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
2925 template<typename _Tp> inline _Tp& Seq<_Tp>::operator [](int idx)
2926{ return *(_Tp*)getSeqElem(seq, idx); }
2927
2928 template<typename _Tp> inline const _Tp& Seq<_Tp>::operator [](int idx) const
2929 { return *(_Tp*)getSeqElem(seq, idx); }
2930
2931 template<typename _Tp> inline SeqIterator<_Tp> Seq<_Tp>::begin() const
2932 { return SeqIterator<_Tp>(*this); }
2933
2934 template<typename _Tp> inline SeqIterator<_Tp> Seq<_Tp>::end() const
2935 { return SeqIterator<_Tp>(*this, true); }
2936
2937 template<typename _Tp> inline size_t Seq<_Tp>::size() const
2938 { return seq ? seq->total : 0; }
2939
2940 template<typename _Tp> inline int Seq<_Tp>::type() const
2941 { return seq ? CV_MAT_TYPE(seq->flags) : 0; }
2942
2943 template<typename _Tp> inline int Seq<_Tp>::depth() const
2944 { return seq ? CV_MAT_DEPTH(seq->flags) : 0; }
2945
2946 template<typename _Tp> inline int Seq<_Tp>::channels() const
2947 { return seq ? CV_MAT_CN(seq->flags) : 0; }
2948
2949 template<typename _Tp> inline size_t Seq<_Tp>::elemSize() const
2950 { return seq ? seq->elem_size : 0; }
2951
2952 template<typename _Tp> inline size_t Seq<_Tp>::index(const _Tp& elem) const
2953 { return cvSeqElemIdx(seq, &elem); }
2954
2955 template<typename _Tp> inline void Seq<_Tp>::push_back(const _Tp& elem)
2956{ cvSeqPush(seq, &elem); }
2957
2958 template<typename _Tp> inline void Seq<_Tp>::push_front(const _Tp& elem)
2959{ cvSeqPushFront(seq, &elem); }
2960
2961 template<typename _Tp> inline void Seq<_Tp>::push_back(const _Tp* elem, size_t count)
2962{ cvSeqPushMulti(seq, elem, (int)count, 0); }
2963
2964 template<typename _Tp> inline void Seq<_Tp>::push_front(const _Tp* elem, size_t count)
2965{ cvSeqPushMulti(seq, elem, (int)count, 1); }
2966
2967 template<typename _Tp> inline _Tp& Seq<_Tp>::back()
2968{ return *(_Tp*)getSeqElem(seq, -1); }
2969
2970 template<typename _Tp> inline const _Tp& Seq<_Tp>::back() const
2971 { return *(const _Tp*)getSeqElem(seq, -1); }
2972
2973 template<typename _Tp> inline _Tp& Seq<_Tp>::front()
2974{ return *(_Tp*)getSeqElem(seq, 0); }
2975
2976 template<typename _Tp> inline const _Tp& Seq<_Tp>::front() const
2977 { return *(const _Tp*)getSeqElem(seq, 0); }
2978
2979 template<typename _Tp> inline bool Seq<_Tp>::empty() const
2980 { return !seq || seq->total == 0; }
2981
2982 template<typename _Tp> inline void Seq<_Tp>::clear()
2983{ if(seq) clearSeq(seq); }
2984
2985 template<typename _Tp> inline void Seq<_Tp>::pop_back()
2986{ seqPop(seq); }
2987
2988 template<typename _Tp> inline void Seq<_Tp>::pop_front()
2989{ seqPopFront(seq); }
2990
2991 template<typename _Tp> inline void Seq<_Tp>::pop_back(_Tp* elem, size_t count)
2992{ seqPopMulti(seq, elem, (int)count, 0); }
2993
2994 template<typename _Tp> inline void Seq<_Tp>::pop_front(_Tp* elem, size_t count)
2995{ seqPopMulti(seq, elem, (int)count, 1); }
2996
2997 template<typename _Tp> inline void Seq<_Tp>::insert(int idx, const _Tp& elem)
2998{ seqInsert(seq, idx, &elem); }
2999
3000 template<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
3006 template<typename _Tp> inline void Seq<_Tp>::remove(int idx)
3007{ seqRemove(seq, idx); }
3008
3009 template<typename _Tp> inline void Seq<_Tp>::remove(const Range& r)
3010{ seqRemoveSlice(seq, cvSlice(r.start, r.end)); }
3011
3012 template<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
3020 template<typename _Tp> inline Seq<_Tp>::operator std::vector<_Tp>() const
3021 {
3022 std::vector<_Tp> vec;
3023 copyTo(vec);
3024 return vec;
3025}
3026
3027 template<typename _Tp> inline SeqIterator<_Tp>::SeqIterator()
3028{ memset(this, 0, sizeof(*this)); }
3029
3030 template<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
3036 template<typename _Tp> inline void SeqIterator<_Tp>::seek(size_t pos)
3037{
3038 cvSetSeqReaderPos(this, (int)pos, false);
3039 index = pos;
3040}
3041
3042 template<typename _Tp> inline size_t SeqIterator<_Tp>::tell() const
3043 { return index; }
3044
3045 template<typename _Tp> inline _Tp& SeqIterator<_Tp>::operator *()
3046{ return *(_Tp*)ptr; }
3047
3048 template<typename _Tp> inline const _Tp& SeqIterator<_Tp>::operator *() const
3049 { return *(const _Tp*)ptr; }
3050
3051 template<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
3059 template<typename _Tp> inline SeqIterator<_Tp> SeqIterator<_Tp>::operator ++(int) const
3060 {
3061 SeqIterator<_Tp> it = *this;
3062 ++*this;
3063 return it;
3064}
3065
3066 template<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
3074 template<typename _Tp> inline SeqIterator<_Tp> SeqIterator<_Tp>::operator --(int) const
3075 {
3076 SeqIterator<_Tp> it = *this;
3077 --*this;
3078 return it;
3079}
3080
3081 template<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
3093 template<typename _Tp> inline SeqIterator<_Tp>& SeqIterator<_Tp>::operator -=(int delta)
3094{
3095 return (*this += -delta);
3096}
3097
3098 template<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
3107 template<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
3113 template<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