1 /*M///////////////////////////////////////////////////////////////////////////////////////
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
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.
10 // Intel License Agreement
11 // For Open Source Computer Vision Library
13 // Copyright (C) 2000, Intel Corporation, all rights reserved.
14 // Third party copyrights are property of their respective owners.
16 // Redistribution and use in source and binary forms, with or without modification,
17 // are permitted provided that the following conditions are met:
19 // * Redistribution's of source code must retain the above copyright notice,
20 // this list of conditions and the following disclaimer.
22 // * Redistribution's in binary form must reproduce the above copyright notice,
23 // this list of conditions and the following disclaimer in the documentation
24 // and/or other materials provided with the distribution.
26 // * The name of Intel Corporation may not be used to endorse or promote products
27 // derived from this software without specific prior written permission.
29 // This software is provided by the copyright holders and contributors "as is" and
30 // any express or implied warranties, including, but not limited to, the implied
31 // warranties of merchantability and fitness for a particular purpose are disclaimed.
32 // In no event shall the Intel Corporation or contributors be liable for any direct,
33 // indirect, incidental, special, exemplary, or consequential damages
34 // (including, but not limited to, procurement of substitute goods or services;
35 // loss of use, data, or profits; or business interruption) however caused
36 // and on any theory of liability, whether in contract, strict liability,
37 // or tort (including negligence or otherwise) arising in any way out of
38 // the use of this software, even if advised of the possibility of such damage.
51 #if defined HAVE_IPL && !defined __IPL_H__
53 #define CV_PRETEND_WINDOWS
55 typedef struct tagBITMAPINFOHEADER BITMAPINFOHEADER;
58 #if defined WIN32 || defined WIN64
63 #ifdef CV_PRETEND_WINDOWS
67 #endif // SKIP_INCLUDES
77 /****************************************************************************************\
78 * Array allocation, deallocation, initialization and access to elements *
79 \****************************************************************************************/
82 If there is no enough memory, the function
83 (as well as other OpenCV functions that call cvAlloc)
85 CVAPI(void*) cvAlloc( size_t size );
88 Here and further all the memory releasing functions
89 (that all call cvFree) take double pointer in order to
90 to clear pointer to the data after releasing it.
91 Passing pointer to NULL pointer is Ok: nothing happens in this case
93 CVAPI(void) cvFree_( void* ptr );
94 #define cvFree(ptr) (cvFree_(*(ptr)), *(ptr)=0)
96 /* Allocates and initializes IplImage header */
97 CVAPI(IplImage*) cvCreateImageHeader( CvSize size, int depth, int channels );
99 /* Inializes IplImage header */
100 CVAPI(IplImage*) cvInitImageHeader( IplImage* image, CvSize size, int depth,
101 int channels, int origin CV_DEFAULT(0),
102 int align CV_DEFAULT(4));
104 /* Creates IPL image (header and data) */
105 CVAPI(IplImage*) cvCreateImage( CvSize size, int depth, int channels );
107 /* Releases (i.e. deallocates) IPL image header */
108 CVAPI(void) cvReleaseImageHeader( IplImage** image );
110 /* Releases IPL image header and data */
111 CVAPI(void) cvReleaseImage( IplImage** image );
113 /* Creates a copy of IPL image (widthStep may differ) */
114 CVAPI(IplImage*) cvCloneImage( const IplImage* image );
116 /* Sets a Channel Of Interest (only a few functions support COI) -
117 use cvCopy to extract the selected channel and/or put it back */
118 CVAPI(void) cvSetImageCOI( IplImage* image, int coi );
120 /* Retrieves image Channel Of Interest */
121 CVAPI(int) cvGetImageCOI( const IplImage* image );
123 /* Sets image ROI (region of interest) (COI is not changed) */
124 CVAPI(void) cvSetImageROI( IplImage* image, CvRect rect );
126 /* Resets image ROI and COI */
127 CVAPI(void) cvResetImageROI( IplImage* image );
129 /* Retrieves image ROI */
130 CVAPI(CvRect) cvGetImageROI( const IplImage* image );
132 /* Allocates and initalizes CvMat header */
133 CVAPI(CvMat*) cvCreateMatHeader( int rows, int cols, int type );
135 #define CV_AUTOSTEP 0x7fffffff
137 /* Initializes CvMat header */
138 CVAPI(CvMat*) cvInitMatHeader( CvMat* mat, int rows, int cols,
139 int type, void* data CV_DEFAULT(NULL),
140 int step CV_DEFAULT(CV_AUTOSTEP) );
142 /* Allocates and initializes CvMat header and allocates data */
143 CVAPI(CvMat*) cvCreateMat( int rows, int cols, int type );
145 /* Releases CvMat header and deallocates matrix data
146 (reference counting is used for data) */
147 CVAPI(void) cvReleaseMat( CvMat** mat );
149 /* Decrements CvMat data reference counter and deallocates the data if
151 CV_INLINE void cvDecRefData( CvArr* arr )
153 if( CV_IS_MAT( arr ))
155 CvMat* mat = (CvMat*)arr;
156 mat->data.ptr = NULL;
157 if( mat->refcount != NULL && --*mat->refcount == 0 )
158 cvFree( &mat->refcount );
159 mat->refcount = NULL;
161 else if( CV_IS_MATND( arr ))
163 CvMatND* mat = (CvMatND*)arr;
164 mat->data.ptr = NULL;
165 if( mat->refcount != NULL && --*mat->refcount == 0 )
166 cvFree( &mat->refcount );
167 mat->refcount = NULL;
171 /* Increments CvMat data reference counter */
172 CV_INLINE int cvIncRefData( CvArr* arr )
175 if( CV_IS_MAT( arr ))
177 CvMat* mat = (CvMat*)arr;
178 if( mat->refcount != NULL )
179 refcount = ++*mat->refcount;
181 else if( CV_IS_MATND( arr ))
183 CvMatND* mat = (CvMatND*)arr;
184 if( mat->refcount != NULL )
185 refcount = ++*mat->refcount;
191 /* Creates an exact copy of the input matrix (except, may be, step value) */
192 CVAPI(CvMat*) cvCloneMat( const CvMat* mat );
195 /* Makes a new matrix from <rect> subrectangle of input array.
197 CVAPI(CvMat*) cvGetSubRect( const CvArr* arr, CvMat* submat, CvRect rect );
198 #define cvGetSubArr cvGetSubRect
200 /* Selects row span of the input array: arr(start_row:delta_row:end_row,:)
201 (end_row is not included into the span). */
202 CVAPI(CvMat*) cvGetRows( const CvArr* arr, CvMat* submat,
203 int start_row, int end_row,
204 int delta_row CV_DEFAULT(1));
206 CV_INLINE CvMat* cvGetRow( const CvArr* arr, CvMat* submat, int row )
208 return cvGetRows( arr, submat, row, row + 1, 1 );
212 /* Selects column span of the input array: arr(:,start_col:end_col)
213 (end_col is not included into the span) */
214 CVAPI(CvMat*) cvGetCols( const CvArr* arr, CvMat* submat,
215 int start_col, int end_col );
217 CV_INLINE CvMat* cvGetCol( const CvArr* arr, CvMat* submat, int col )
219 return cvGetCols( arr, submat, col, col + 1 );
222 /* Select a diagonal of the input array.
223 (diag = 0 means the main diagonal, >0 means a diagonal above the main one,
224 <0 - below the main one).
225 The diagonal will be represented as a column (nx1 matrix). */
226 CVAPI(CvMat*) cvGetDiag( const CvArr* arr, CvMat* submat,
227 int diag CV_DEFAULT(0));
229 /* low-level scalar <-> raw data conversion functions */
230 CVAPI(void) cvScalarToRawData( const CvScalar* scalar, void* data, int type,
231 int extend_to_12 CV_DEFAULT(0) );
233 CVAPI(void) cvRawDataToScalar( const void* data, int type, CvScalar* scalar );
235 /* Allocates and initializes CvMatND header */
236 CVAPI(CvMatND*) cvCreateMatNDHeader( int dims, const int* sizes, int type );
238 /* Allocates and initializes CvMatND header and allocates data */
239 CVAPI(CvMatND*) cvCreateMatND( int dims, const int* sizes, int type );
241 /* Initializes preallocated CvMatND header */
242 CVAPI(CvMatND*) cvInitMatNDHeader( CvMatND* mat, int dims, const int* sizes,
243 int type, void* data CV_DEFAULT(NULL) );
245 /* Releases CvMatND */
246 CV_INLINE void cvReleaseMatND( CvMatND** mat )
248 cvReleaseMat( (CvMat**)mat );
251 /* Creates a copy of CvMatND (except, may be, steps) */
252 CVAPI(CvMatND*) cvCloneMatND( const CvMatND* mat );
254 /* Allocates and initializes CvSparseMat header and allocates data */
255 CVAPI(CvSparseMat*) cvCreateSparseMat( int dims, const int* sizes, int type );
257 /* Releases CvSparseMat */
258 CVAPI(void) cvReleaseSparseMat( CvSparseMat** mat );
260 /* Creates a copy of CvSparseMat (except, may be, zero items) */
261 CVAPI(CvSparseMat*) cvCloneSparseMat( const CvSparseMat* mat );
263 /* Initializes sparse array iterator
264 (returns the first node or NULL if the array is empty) */
265 CVAPI(CvSparseNode*) cvInitSparseMatIterator( const CvSparseMat* mat,
266 CvSparseMatIterator* mat_iterator );
268 // returns next sparse array node (or NULL if there is no more nodes)
269 CV_INLINE CvSparseNode* cvGetNextSparseNode( CvSparseMatIterator* mat_iterator )
271 if( mat_iterator->node->next )
272 return mat_iterator->node = mat_iterator->node->next;
276 for( idx = ++mat_iterator->curidx; idx < mat_iterator->mat->hashsize; idx++ )
278 CvSparseNode* node = (CvSparseNode*)mat_iterator->mat->hashtable[idx];
281 mat_iterator->curidx = idx;
282 return mat_iterator->node = node;
289 /**************** matrix iterator: used for n-ary operations on dense arrays *********/
291 #define CV_MAX_ARR 10
293 typedef struct CvNArrayIterator
295 int count; /* number of arrays */
296 int dims; /* number of dimensions to iterate */
297 CvSize size; /* maximal common linear size: { width = size, height = 1 } */
298 uchar* ptr[CV_MAX_ARR]; /* pointers to the array slices */
299 int stack[CV_MAX_DIM]; /* for internal use */
300 CvMatND* hdr[CV_MAX_ARR]; /* pointers to the headers of the
301 matrices that are processed */
305 #define CV_NO_DEPTH_CHECK 1
306 #define CV_NO_CN_CHECK 2
307 #define CV_NO_SIZE_CHECK 4
309 /* initializes iterator that traverses through several arrays simulteneously
310 (the function together with cvNextArraySlice is used for
311 N-ari element-wise operations) */
312 CVAPI(int) cvInitNArrayIterator( int count, CvArr** arrs,
313 const CvArr* mask, CvMatND* stubs,
314 CvNArrayIterator* array_iterator,
315 int flags CV_DEFAULT(0) );
317 /* returns zero value if iteration is finished, non-zero (slice length) otherwise */
318 CVAPI(int) cvNextNArraySlice( CvNArrayIterator* array_iterator );
321 /* Returns type of array elements:
322 CV_8UC1 ... CV_64FC4 ... */
323 CVAPI(int) cvGetElemType( const CvArr* arr );
325 /* Retrieves number of an array dimensions and
326 optionally sizes of the dimensions */
327 CVAPI(int) cvGetDims( const CvArr* arr, int* sizes CV_DEFAULT(NULL) );
330 /* Retrieves size of a particular array dimension.
331 For 2d arrays cvGetDimSize(arr,0) returns number of rows (image height)
332 and cvGetDimSize(arr,1) returns number of columns (image width) */
333 CVAPI(int) cvGetDimSize( const CvArr* arr, int index );
336 /* ptr = &arr(idx0,idx1,...). All indexes are zero-based,
337 the major dimensions go first (e.g. (y,x) for 2D, (z,y,x) for 3D */
338 CVAPI(uchar*) cvPtr1D( const CvArr* arr, int idx0, int* type CV_DEFAULT(NULL));
339 CVAPI(uchar*) cvPtr2D( const CvArr* arr, int idx0, int idx1, int* type CV_DEFAULT(NULL) );
340 CVAPI(uchar*) cvPtr3D( const CvArr* arr, int idx0, int idx1, int idx2,
341 int* type CV_DEFAULT(NULL));
343 /* For CvMat or IplImage number of indices should be 2
344 (row index (y) goes first, column index (x) goes next).
345 For CvMatND or CvSparseMat number of infices should match number of <dims> and
346 indices order should match the array dimension order. */
347 CVAPI(uchar*) cvPtrND( const CvArr* arr, const int* idx, int* type CV_DEFAULT(NULL),
348 int create_node CV_DEFAULT(1),
349 unsigned* precalc_hashval CV_DEFAULT(NULL));
351 /* value = arr(idx0,idx1,...) */
352 CVAPI(CvScalar) cvGet1D( const CvArr* arr, int idx0 );
353 CVAPI(CvScalar) cvGet2D( const CvArr* arr, int idx0, int idx1 );
354 CVAPI(CvScalar) cvGet3D( const CvArr* arr, int idx0, int idx1, int idx2 );
355 CVAPI(CvScalar) cvGetND( const CvArr* arr, const int* idx );
357 /* for 1-channel arrays */
358 CVAPI(double) cvGetReal1D( const CvArr* arr, int idx0 );
359 CVAPI(double) cvGetReal2D( const CvArr* arr, int idx0, int idx1 );
360 CVAPI(double) cvGetReal3D( const CvArr* arr, int idx0, int idx1, int idx2 );
361 CVAPI(double) cvGetRealND( const CvArr* arr, const int* idx );
363 /* arr(idx0,idx1,...) = value */
364 CVAPI(void) cvSet1D( CvArr* arr, int idx0, CvScalar value );
365 CVAPI(void) cvSet2D( CvArr* arr, int idx0, int idx1, CvScalar value );
366 CVAPI(void) cvSet3D( CvArr* arr, int idx0, int idx1, int idx2, CvScalar value );
367 CVAPI(void) cvSetND( CvArr* arr, const int* idx, CvScalar value );
369 /* for 1-channel arrays */
370 CVAPI(void) cvSetReal1D( CvArr* arr, int idx0, double value );
371 CVAPI(void) cvSetReal2D( CvArr* arr, int idx0, int idx1, double value );
372 CVAPI(void) cvSetReal3D( CvArr* arr, int idx0,
373 int idx1, int idx2, double value );
374 CVAPI(void) cvSetRealND( CvArr* arr, const int* idx, double value );
376 /* clears element of ND dense array,
377 in case of sparse arrays it deletes the specified node */
378 CVAPI(void) cvClearND( CvArr* arr, const int* idx );
380 /* Converts CvArr (IplImage or CvMat,...) to CvMat.
381 If the last parameter is non-zero, function can
382 convert multi(>2)-dimensional array to CvMat as long as
383 the last array's dimension is continous. The resultant
384 matrix will be have appropriate (a huge) number of rows */
385 CVAPI(CvMat*) cvGetMat( const CvArr* arr, CvMat* header,
386 int* coi CV_DEFAULT(NULL),
387 int allowND CV_DEFAULT(0));
389 /* Converts CvArr (IplImage or CvMat) to IplImage */
390 CVAPI(IplImage*) cvGetImage( const CvArr* arr, IplImage* image_header );
393 /* Changes a shape of multi-dimensional array.
394 new_cn == 0 means that number of channels remains unchanged.
395 new_dims == 0 means that number and sizes of dimensions remain the same
396 (unless they need to be changed to set the new number of channels)
397 if new_dims == 1, there is no need to specify new dimension sizes
398 The resultant configuration should be achievable w/o data copying.
399 If the resultant array is sparse, CvSparseMat header should be passed
400 to the function else if the result is 1 or 2 dimensional,
401 CvMat header should be passed to the function
402 else CvMatND header should be passed */
403 CVAPI(CvArr*) cvReshapeMatND( const CvArr* arr,
404 int sizeof_header, CvArr* header,
405 int new_cn, int new_dims, int* new_sizes );
407 #define cvReshapeND( arr, header, new_cn, new_dims, new_sizes ) \
408 cvReshapeMatND( (arr), sizeof(*(header)), (header), \
409 (new_cn), (new_dims), (new_sizes))
411 CVAPI(CvMat*) cvReshape( const CvArr* arr, CvMat* header,
412 int new_cn, int new_rows CV_DEFAULT(0) );
414 /* Repeats source 2d array several times in both horizontal and
415 vertical direction to fill destination array */
416 CVAPI(void) cvRepeat( const CvArr* src, CvArr* dst );
418 /* Allocates array data */
419 CVAPI(void) cvCreateData( CvArr* arr );
421 /* Releases array data */
422 CVAPI(void) cvReleaseData( CvArr* arr );
424 /* Attaches user data to the array header. The step is reffered to
425 the pre-last dimension. That is, all the planes of the array
426 must be joint (w/o gaps) */
427 CVAPI(void) cvSetData( CvArr* arr, void* data, int step );
429 /* Retrieves raw data of CvMat, IplImage or CvMatND.
430 In the latter case the function raises an error if
431 the array can not be represented as a matrix */
432 CVAPI(void) cvGetRawData( const CvArr* arr, uchar** data,
433 int* step CV_DEFAULT(NULL),
434 CvSize* roi_size CV_DEFAULT(NULL));
436 /* Returns width and height of array in elements */
437 CVAPI(CvSize) cvGetSize( const CvArr* arr );
439 /* Copies source array to destination array */
440 CVAPI(void) cvCopy( const CvArr* src, CvArr* dst,
441 const CvArr* mask CV_DEFAULT(NULL) );
443 /* Sets all or "masked" elements of input array
445 CVAPI(void) cvSet( CvArr* arr, CvScalar value,
446 const CvArr* mask CV_DEFAULT(NULL) );
448 /* Clears all the array elements (sets them to 0) */
449 CVAPI(void) cvSetZero( CvArr* arr );
450 #define cvZero cvSetZero
453 /* Splits a multi-channel array into the set of single-channel arrays or
454 extracts particular [color] plane */
455 CVAPI(void) cvSplit( const CvArr* src, CvArr* dst0, CvArr* dst1,
456 CvArr* dst2, CvArr* dst3 );
458 /* Merges a set of single-channel arrays into the single multi-channel array
459 or inserts one particular [color] plane to the array */
460 CVAPI(void) cvMerge( const CvArr* src0, const CvArr* src1,
461 const CvArr* src2, const CvArr* src3,
464 /* Copies several channels from input arrays to
465 certain channels of output arrays */
466 CVAPI(void) cvMixChannels( const CvArr** src, int src_count,
467 CvArr** dst, int dst_count,
468 const int* from_to, int pair_count );
470 /* Performs linear transformation on every source array element:
471 dst(x,y,c) = scale*src(x,y,c)+shift.
472 Arbitrary combination of input and output array depths are allowed
473 (number of channels must be the same), thus the function can be used
474 for type conversion */
475 CVAPI(void) cvConvertScale( const CvArr* src, CvArr* dst,
476 double scale CV_DEFAULT(1),
477 double shift CV_DEFAULT(0) );
478 #define cvCvtScale cvConvertScale
479 #define cvScale cvConvertScale
480 #define cvConvert( src, dst ) cvConvertScale( (src), (dst), 1, 0 )
483 /* Performs linear transformation on every source array element,
484 stores absolute value of the result:
485 dst(x,y,c) = abs(scale*src(x,y,c)+shift).
486 destination array must have 8u type.
487 In other cases one may use cvConvertScale + cvAbsDiffS */
488 CVAPI(void) cvConvertScaleAbs( const CvArr* src, CvArr* dst,
489 double scale CV_DEFAULT(1),
490 double shift CV_DEFAULT(0) );
491 #define cvCvtScaleAbs cvConvertScaleAbs
494 /* checks termination criteria validity and
495 sets eps to default_eps (if it is not set),
496 max_iter to default_max_iters (if it is not set)
498 CVAPI(CvTermCriteria) cvCheckTermCriteria( CvTermCriteria criteria,
500 int default_max_iters );
502 /****************************************************************************************\
503 * Arithmetic, logic and comparison operations *
504 \****************************************************************************************/
506 /* dst(mask) = src1(mask) + src2(mask) */
507 CVAPI(void) cvAdd( const CvArr* src1, const CvArr* src2, CvArr* dst,
508 const CvArr* mask CV_DEFAULT(NULL));
510 /* dst(mask) = src(mask) + value */
511 CVAPI(void) cvAddS( const CvArr* src, CvScalar value, CvArr* dst,
512 const CvArr* mask CV_DEFAULT(NULL));
514 /* dst(mask) = src1(mask) - src2(mask) */
515 CVAPI(void) cvSub( const CvArr* src1, const CvArr* src2, CvArr* dst,
516 const CvArr* mask CV_DEFAULT(NULL));
518 /* dst(mask) = src(mask) - value = src(mask) + (-value) */
519 CV_INLINE void cvSubS( const CvArr* src, CvScalar value, CvArr* dst,
520 const CvArr* mask CV_DEFAULT(NULL))
522 cvAddS( src, cvScalar( -value.val[0], -value.val[1], -value.val[2], -value.val[3]),
526 /* dst(mask) = value - src(mask) */
527 CVAPI(void) cvSubRS( const CvArr* src, CvScalar value, CvArr* dst,
528 const CvArr* mask CV_DEFAULT(NULL));
530 /* dst(idx) = src1(idx) * src2(idx) * scale
531 (scaled element-wise multiplication of 2 arrays) */
532 CVAPI(void) cvMul( const CvArr* src1, const CvArr* src2,
533 CvArr* dst, double scale CV_DEFAULT(1) );
535 /* element-wise division/inversion with scaling:
536 dst(idx) = src1(idx) * scale / src2(idx)
537 or dst(idx) = scale / src2(idx) if src1 == 0 */
538 CVAPI(void) cvDiv( const CvArr* src1, const CvArr* src2,
539 CvArr* dst, double scale CV_DEFAULT(1));
541 /* dst = src1 * scale + src2 */
542 CVAPI(void) cvScaleAdd( const CvArr* src1, CvScalar scale,
543 const CvArr* src2, CvArr* dst );
544 #define cvAXPY( A, real_scalar, B, C ) cvScaleAdd(A, cvRealScalar(real_scalar), B, C)
546 /* dst = src1 * alpha + src2 * beta + gamma */
547 CVAPI(void) cvAddWeighted( const CvArr* src1, double alpha,
548 const CvArr* src2, double beta,
549 double gamma, CvArr* dst );
551 /* result = sum_i(src1(i) * src2(i)) (results for all channels are accumulated together) */
552 CVAPI(double) cvDotProduct( const CvArr* src1, const CvArr* src2 );
554 /* dst(idx) = src1(idx) & src2(idx) */
555 CVAPI(void) cvAnd( const CvArr* src1, const CvArr* src2,
556 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
558 /* dst(idx) = src(idx) & value */
559 CVAPI(void) cvAndS( const CvArr* src, CvScalar value,
560 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
562 /* dst(idx) = src1(idx) | src2(idx) */
563 CVAPI(void) cvOr( const CvArr* src1, const CvArr* src2,
564 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
566 /* dst(idx) = src(idx) | value */
567 CVAPI(void) cvOrS( const CvArr* src, CvScalar value,
568 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
570 /* dst(idx) = src1(idx) ^ src2(idx) */
571 CVAPI(void) cvXor( const CvArr* src1, const CvArr* src2,
572 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
574 /* dst(idx) = src(idx) ^ value */
575 CVAPI(void) cvXorS( const CvArr* src, CvScalar value,
576 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
578 /* dst(idx) = ~src(idx) */
579 CVAPI(void) cvNot( const CvArr* src, CvArr* dst );
581 /* dst(idx) = lower(idx) <= src(idx) < upper(idx) */
582 CVAPI(void) cvInRange( const CvArr* src, const CvArr* lower,
583 const CvArr* upper, CvArr* dst );
585 /* dst(idx) = lower <= src(idx) < upper */
586 CVAPI(void) cvInRangeS( const CvArr* src, CvScalar lower,
587 CvScalar upper, CvArr* dst );
596 /* The comparison operation support single-channel arrays only.
597 Destination image should be 8uC1 or 8sC1 */
599 /* dst(idx) = src1(idx) _cmp_op_ src2(idx) */
600 CVAPI(void) cvCmp( const CvArr* src1, const CvArr* src2, CvArr* dst, int cmp_op );
602 /* dst(idx) = src1(idx) _cmp_op_ value */
603 CVAPI(void) cvCmpS( const CvArr* src, double value, CvArr* dst, int cmp_op );
605 /* dst(idx) = min(src1(idx),src2(idx)) */
606 CVAPI(void) cvMin( const CvArr* src1, const CvArr* src2, CvArr* dst );
608 /* dst(idx) = max(src1(idx),src2(idx)) */
609 CVAPI(void) cvMax( const CvArr* src1, const CvArr* src2, CvArr* dst );
611 /* dst(idx) = min(src(idx),value) */
612 CVAPI(void) cvMinS( const CvArr* src, double value, CvArr* dst );
614 /* dst(idx) = max(src(idx),value) */
615 CVAPI(void) cvMaxS( const CvArr* src, double value, CvArr* dst );
617 /* dst(x,y,c) = abs(src1(x,y,c) - src2(x,y,c)) */
618 CVAPI(void) cvAbsDiff( const CvArr* src1, const CvArr* src2, CvArr* dst );
620 /* dst(x,y,c) = abs(src(x,y,c) - value(c)) */
621 CVAPI(void) cvAbsDiffS( const CvArr* src, CvArr* dst, CvScalar value );
622 #define cvAbs( src, dst ) cvAbsDiffS( (src), (dst), cvScalarAll(0))
624 /****************************************************************************************\
626 \****************************************************************************************/
628 /* Does cartesian->polar coordinates conversion.
629 Either of output components (magnitude or angle) is optional */
630 CVAPI(void) cvCartToPolar( const CvArr* x, const CvArr* y,
631 CvArr* magnitude, CvArr* angle CV_DEFAULT(NULL),
632 int angle_in_degrees CV_DEFAULT(0));
634 /* Does polar->cartesian coordinates conversion.
635 Either of output components (magnitude or angle) is optional.
636 If magnitude is missing it is assumed to be all 1's */
637 CVAPI(void) cvPolarToCart( const CvArr* magnitude, const CvArr* angle,
639 int angle_in_degrees CV_DEFAULT(0));
641 /* Does powering: dst(idx) = src(idx)^power */
642 CVAPI(void) cvPow( const CvArr* src, CvArr* dst, double power );
644 /* Does exponention: dst(idx) = exp(src(idx)).
645 Overflow is not handled yet. Underflow is handled.
646 Maximal relative error is ~7e-6 for single-precision input */
647 CVAPI(void) cvExp( const CvArr* src, CvArr* dst );
649 /* Calculates natural logarithms: dst(idx) = log(abs(src(idx))).
650 Logarithm of 0 gives large negative number(~-700)
651 Maximal relative error is ~3e-7 for single-precision output
653 CVAPI(void) cvLog( const CvArr* src, CvArr* dst );
655 /* Fast arctangent calculation */
656 CVAPI(float) cvFastArctan( float y, float x );
658 /* Fast cubic root calculation */
659 CVAPI(float) cvCbrt( float value );
661 /* Checks array values for NaNs, Infs or simply for too large numbers
662 (if CV_CHECK_RANGE is set). If CV_CHECK_QUIET is set,
663 no runtime errors is raised (function returns zero value in case of "bad" values).
664 Otherwise cvError is called */
665 #define CV_CHECK_RANGE 1
666 #define CV_CHECK_QUIET 2
667 CVAPI(int) cvCheckArr( const CvArr* arr, int flags CV_DEFAULT(0),
668 double min_val CV_DEFAULT(0), double max_val CV_DEFAULT(0));
669 #define cvCheckArray cvCheckArr
671 #define CV_RAND_UNI 0
672 #define CV_RAND_NORMAL 1
673 CVAPI(void) cvRandArr( CvRNG* rng, CvArr* arr, int dist_type,
674 CvScalar param1, CvScalar param2 );
676 CVAPI(void) cvRandShuffle( CvArr* mat, CvRNG* rng,
677 double iter_factor CV_DEFAULT(1.));
679 /* Finds real roots of a cubic equation */
680 CVAPI(int) cvSolveCubic( const CvMat* coeffs, CvMat* roots );
682 /* Finds all real and complex roots of a polynomial equation */
683 CVAPI(void) cvSolvePoly(const CvMat* coeffs, CvMat *roots,
684 int maxiter = 10, int fig = 10);
686 /****************************************************************************************\
687 * Matrix operations *
688 \****************************************************************************************/
690 /* Calculates cross product of two 3d vectors */
691 CVAPI(void) cvCrossProduct( const CvArr* src1, const CvArr* src2, CvArr* dst );
693 /* Matrix transform: dst = A*B + C, C is optional */
694 #define cvMatMulAdd( src1, src2, src3, dst ) cvGEMM( (src1), (src2), 1., (src3), 1., (dst), 0 )
695 #define cvMatMul( src1, src2, dst ) cvMatMulAdd( (src1), (src2), NULL, (dst))
697 #define CV_GEMM_A_T 1
698 #define CV_GEMM_B_T 2
699 #define CV_GEMM_C_T 4
700 /* Extended matrix transform:
701 dst = alpha*op(A)*op(B) + beta*op(C), where op(X) is X or X^T */
702 CVAPI(void) cvGEMM( const CvArr* src1, const CvArr* src2, double alpha,
703 const CvArr* src3, double beta, CvArr* dst,
704 int tABC CV_DEFAULT(0));
705 #define cvMatMulAddEx cvGEMM
707 /* Transforms each element of source array and stores
708 resultant vectors in destination array */
709 CVAPI(void) cvTransform( const CvArr* src, CvArr* dst,
710 const CvMat* transmat,
711 const CvMat* shiftvec CV_DEFAULT(NULL));
712 #define cvMatMulAddS cvTransform
714 /* Does perspective transform on every element of input array */
715 CVAPI(void) cvPerspectiveTransform( const CvArr* src, CvArr* dst,
718 /* Calculates (A-delta)*(A-delta)^T (order=0) or (A-delta)^T*(A-delta) (order=1) */
719 CVAPI(void) cvMulTransposed( const CvArr* src, CvArr* dst, int order,
720 const CvArr* delta CV_DEFAULT(NULL),
721 double scale CV_DEFAULT(1.) );
723 /* Tranposes matrix. Square matrices can be transposed in-place */
724 CVAPI(void) cvTranspose( const CvArr* src, CvArr* dst );
725 #define cvT cvTranspose
728 /* Mirror array data around horizontal (flip=0),
729 vertical (flip=1) or both(flip=-1) axises:
730 cvFlip(src) flips images vertically and sequences horizontally (inplace) */
731 CVAPI(void) cvFlip( const CvArr* src, CvArr* dst CV_DEFAULT(NULL),
732 int flip_mode CV_DEFAULT(0));
733 #define cvMirror cvFlip
736 #define CV_SVD_MODIFY_A 1
740 /* Performs Singular Value Decomposition of a matrix */
741 CVAPI(void) cvSVD( CvArr* A, CvArr* W, CvArr* U CV_DEFAULT(NULL),
742 CvArr* V CV_DEFAULT(NULL), int flags CV_DEFAULT(0));
744 /* Performs Singular Value Back Substitution (solves A*X = B):
745 flags must be the same as in cvSVD */
746 CVAPI(void) cvSVBkSb( const CvArr* W, const CvArr* U,
747 const CvArr* V, const CvArr* B,
748 CvArr* X, int flags );
754 CVAPI(double) cvInvert( const CvArr* src, CvArr* dst,
755 int method CV_DEFAULT(CV_LU));
756 #define cvInv cvInvert
758 /* Solves linear system (src1)*(dst) = (src2)
759 (returns 0 if src1 is a singular and CV_LU method is used) */
760 CVAPI(int) cvSolve( const CvArr* src1, const CvArr* src2, CvArr* dst,
761 int method CV_DEFAULT(CV_LU));
763 /* Calculates determinant of input matrix */
764 CVAPI(double) cvDet( const CvArr* mat );
766 /* Calculates trace of the matrix (sum of elements on the main diagonal) */
767 CVAPI(CvScalar) cvTrace( const CvArr* mat );
769 /* Finds eigen values and vectors of a symmetric matrix */
770 CVAPI(void) cvEigenVV( CvArr* mat, CvArr* evects,
771 CvArr* evals, double eps CV_DEFAULT(0));
773 /* Makes an identity matrix (mat_ij = i == j) */
774 CVAPI(void) cvSetIdentity( CvArr* mat, CvScalar value CV_DEFAULT(cvRealScalar(1)) );
776 /* Fills matrix with given range of numbers */
777 CVAPI(CvArr*) cvRange( CvArr* mat, double start, double end );
779 /* Calculates covariation matrix for a set of vectors */
780 /* transpose([v1-avg, v2-avg,...]) * [v1-avg,v2-avg,...] */
781 #define CV_COVAR_SCRAMBLED 0
783 /* [v1-avg, v2-avg,...] * transpose([v1-avg,v2-avg,...]) */
784 #define CV_COVAR_NORMAL 1
786 /* do not calc average (i.e. mean vector) - use the input vector instead
787 (useful for calculating covariance matrix by parts) */
788 #define CV_COVAR_USE_AVG 2
790 /* scale the covariance matrix coefficients by number of the vectors */
791 #define CV_COVAR_SCALE 4
793 /* all the input vectors are stored in a single matrix, as its rows */
794 #define CV_COVAR_ROWS 8
796 /* all the input vectors are stored in a single matrix, as its columns */
797 #define CV_COVAR_COLS 16
799 CVAPI(void) cvCalcCovarMatrix( const CvArr** vects, int count,
800 CvArr* cov_mat, CvArr* avg, int flags );
802 #define CV_PCA_DATA_AS_ROW 0
803 #define CV_PCA_DATA_AS_COL 1
804 #define CV_PCA_USE_AVG 2
805 CVAPI(void) cvCalcPCA( const CvArr* data, CvArr* mean,
806 CvArr* eigenvals, CvArr* eigenvects, int flags );
808 CVAPI(void) cvProjectPCA( const CvArr* data, const CvArr* mean,
809 const CvArr* eigenvects, CvArr* result );
811 CVAPI(void) cvBackProjectPCA( const CvArr* proj, const CvArr* mean,
812 const CvArr* eigenvects, CvArr* result );
814 /* Calculates Mahalanobis(weighted) distance */
815 CVAPI(double) cvMahalanobis( const CvArr* vec1, const CvArr* vec2, CvArr* mat );
816 #define cvMahalonobis cvMahalanobis
818 /****************************************************************************************\
820 \****************************************************************************************/
822 /* Finds sum of array elements */
823 CVAPI(CvScalar) cvSum( const CvArr* arr );
825 /* Calculates number of non-zero pixels */
826 CVAPI(int) cvCountNonZero( const CvArr* arr );
828 /* Calculates mean value of array elements */
829 CVAPI(CvScalar) cvAvg( const CvArr* arr, const CvArr* mask CV_DEFAULT(NULL) );
831 /* Calculates mean and standard deviation of pixel values */
832 CVAPI(void) cvAvgSdv( const CvArr* arr, CvScalar* mean, CvScalar* std_dev,
833 const CvArr* mask CV_DEFAULT(NULL) );
835 /* Finds global minimum, maximum and their positions */
836 CVAPI(void) cvMinMaxLoc( const CvArr* arr, double* min_val, double* max_val,
837 CvPoint* min_loc CV_DEFAULT(NULL),
838 CvPoint* max_loc CV_DEFAULT(NULL),
839 const CvArr* mask CV_DEFAULT(NULL) );
841 /* types of array norm */
845 #define CV_NORM_MASK 7
846 #define CV_RELATIVE 8
850 #define CV_DIFF_C (CV_DIFF | CV_C)
851 #define CV_DIFF_L1 (CV_DIFF | CV_L1)
852 #define CV_DIFF_L2 (CV_DIFF | CV_L2)
853 #define CV_RELATIVE_C (CV_RELATIVE | CV_C)
854 #define CV_RELATIVE_L1 (CV_RELATIVE | CV_L1)
855 #define CV_RELATIVE_L2 (CV_RELATIVE | CV_L2)
857 /* Finds norm, difference norm or relative difference norm for an array (or two arrays) */
858 CVAPI(double) cvNorm( const CvArr* arr1, const CvArr* arr2 CV_DEFAULT(NULL),
859 int norm_type CV_DEFAULT(CV_L2),
860 const CvArr* mask CV_DEFAULT(NULL) );
862 CVAPI(void) cvNormalize( const CvArr* src, CvArr* dst,
863 double a CV_DEFAULT(1.), double b CV_DEFAULT(0.),
864 int norm_type CV_DEFAULT(CV_L2),
865 const CvArr* mask CV_DEFAULT(NULL) );
868 #define CV_REDUCE_SUM 0
869 #define CV_REDUCE_AVG 1
870 #define CV_REDUCE_MAX 2
871 #define CV_REDUCE_MIN 3
873 CVAPI(void) cvReduce( const CvArr* src, CvArr* dst, int dim CV_DEFAULT(-1),
874 int op CV_DEFAULT(CV_REDUCE_SUM) );
876 /****************************************************************************************\
877 * Discrete Linear Transforms and Related Functions *
878 \****************************************************************************************/
880 #define CV_DXT_FORWARD 0
881 #define CV_DXT_INVERSE 1
882 #define CV_DXT_SCALE 2 /* divide result by size of array */
883 #define CV_DXT_INV_SCALE (CV_DXT_INVERSE + CV_DXT_SCALE)
884 #define CV_DXT_INVERSE_SCALE CV_DXT_INV_SCALE
885 #define CV_DXT_ROWS 4 /* transform each row individually */
886 #define CV_DXT_MUL_CONJ 8 /* conjugate the second argument of cvMulSpectrums */
888 /* Discrete Fourier Transform:
891 ccs->real (inverse) */
892 CVAPI(void) cvDFT( const CvArr* src, CvArr* dst, int flags,
893 int nonzero_rows CV_DEFAULT(0) );
896 /* Multiply results of DFTs: DFT(X)*DFT(Y) or DFT(X)*conj(DFT(Y)) */
897 CVAPI(void) cvMulSpectrums( const CvArr* src1, const CvArr* src2,
898 CvArr* dst, int flags );
900 /* Finds optimal DFT vector size >= size0 */
901 CVAPI(int) cvGetOptimalDFTSize( int size0 );
903 /* Discrete Cosine Transform */
904 CVAPI(void) cvDCT( const CvArr* src, CvArr* dst, int flags );
906 /****************************************************************************************\
907 * Dynamic data structures *
908 \****************************************************************************************/
910 /* Calculates length of sequence slice (with support of negative indices). */
911 CVAPI(int) cvSliceLength( CvSlice slice, const CvSeq* seq );
914 /* Creates new memory storage.
915 block_size == 0 means that default,
916 somewhat optimal size, is used (currently, it is 64K) */
917 CVAPI(CvMemStorage*) cvCreateMemStorage( int block_size CV_DEFAULT(0));
920 /* Creates a memory storage that will borrow memory blocks from parent storage */
921 CVAPI(CvMemStorage*) cvCreateChildMemStorage( CvMemStorage* parent );
924 /* Releases memory storage. All the children of a parent must be released before
925 the parent. A child storage returns all the blocks to parent when it is released */
926 CVAPI(void) cvReleaseMemStorage( CvMemStorage** storage );
929 /* Clears memory storage. This is the only way(!!!) (besides cvRestoreMemStoragePos)
930 to reuse memory allocated for the storage - cvClearSeq,cvClearSet ...
931 do not free any memory.
932 A child storage returns all the blocks to the parent when it is cleared */
933 CVAPI(void) cvClearMemStorage( CvMemStorage* storage );
935 /* Remember a storage "free memory" position */
936 CVAPI(void) cvSaveMemStoragePos( const CvMemStorage* storage, CvMemStoragePos* pos );
938 /* Restore a storage "free memory" position */
939 CVAPI(void) cvRestoreMemStoragePos( CvMemStorage* storage, CvMemStoragePos* pos );
941 /* Allocates continuous buffer of the specified size in the storage */
942 CVAPI(void*) cvMemStorageAlloc( CvMemStorage* storage, size_t size );
944 /* Allocates string in memory storage */
945 CVAPI(CvString) cvMemStorageAllocString( CvMemStorage* storage, const char* ptr,
946 int len CV_DEFAULT(-1) );
948 /* Creates new empty sequence that will reside in the specified storage */
949 CVAPI(CvSeq*) cvCreateSeq( int seq_flags, int header_size,
950 int elem_size, CvMemStorage* storage );
952 /* Changes default size (granularity) of sequence blocks.
953 The default size is ~1Kbyte */
954 CVAPI(void) cvSetSeqBlockSize( CvSeq* seq, int delta_elems );
957 /* Adds new element to the end of sequence. Returns pointer to the element */
958 CVAPI(schar*) cvSeqPush( CvSeq* seq, void* element CV_DEFAULT(NULL));
961 /* Adds new element to the beginning of sequence. Returns pointer to it */
962 CVAPI(schar*) cvSeqPushFront( CvSeq* seq, void* element CV_DEFAULT(NULL));
965 /* Removes the last element from sequence and optionally saves it */
966 CVAPI(void) cvSeqPop( CvSeq* seq, void* element CV_DEFAULT(NULL));
969 /* Removes the first element from sequence and optioanally saves it */
970 CVAPI(void) cvSeqPopFront( CvSeq* seq, void* element CV_DEFAULT(NULL));
975 /* Adds several new elements to the end of sequence */
976 CVAPI(void) cvSeqPushMulti( CvSeq* seq, void* elements,
977 int count, int in_front CV_DEFAULT(0) );
979 /* Removes several elements from the end of sequence and optionally saves them */
980 CVAPI(void) cvSeqPopMulti( CvSeq* seq, void* elements,
981 int count, int in_front CV_DEFAULT(0) );
983 /* Inserts a new element in the middle of sequence.
984 cvSeqInsert(seq,0,elem) == cvSeqPushFront(seq,elem) */
985 CVAPI(schar*) cvSeqInsert( CvSeq* seq, int before_index,
986 void* element CV_DEFAULT(NULL));
988 /* Removes specified sequence element */
989 CVAPI(void) cvSeqRemove( CvSeq* seq, int index );
992 /* Removes all the elements from the sequence. The freed memory
993 can be reused later only by the same sequence unless cvClearMemStorage
994 or cvRestoreMemStoragePos is called */
995 CVAPI(void) cvClearSeq( CvSeq* seq );
998 /* Retrieves pointer to specified sequence element.
999 Negative indices are supported and mean counting from the end
1000 (e.g -1 means the last sequence element) */
1001 CVAPI(schar*) cvGetSeqElem( const CvSeq* seq, int index );
1003 /* Calculates index of the specified sequence element.
1004 Returns -1 if element does not belong to the sequence */
1005 CVAPI(int) cvSeqElemIdx( const CvSeq* seq, const void* element,
1006 CvSeqBlock** block CV_DEFAULT(NULL) );
1008 /* Initializes sequence writer. The new elements will be added to the end of sequence */
1009 CVAPI(void) cvStartAppendToSeq( CvSeq* seq, CvSeqWriter* writer );
1012 /* Combination of cvCreateSeq and cvStartAppendToSeq */
1013 CVAPI(void) cvStartWriteSeq( int seq_flags, int header_size,
1014 int elem_size, CvMemStorage* storage,
1015 CvSeqWriter* writer );
1017 /* Closes sequence writer, updates sequence header and returns pointer
1018 to the resultant sequence
1019 (which may be useful if the sequence was created using cvStartWriteSeq))
1021 CVAPI(CvSeq*) cvEndWriteSeq( CvSeqWriter* writer );
1024 /* Updates sequence header. May be useful to get access to some of previously
1025 written elements via cvGetSeqElem or sequence reader */
1026 CVAPI(void) cvFlushSeqWriter( CvSeqWriter* writer );
1029 /* Initializes sequence reader.
1030 The sequence can be read in forward or backward direction */
1031 CVAPI(void) cvStartReadSeq( const CvSeq* seq, CvSeqReader* reader,
1032 int reverse CV_DEFAULT(0) );
1035 /* Returns current sequence reader position (currently observed sequence element) */
1036 CVAPI(int) cvGetSeqReaderPos( CvSeqReader* reader );
1039 /* Changes sequence reader position. It may seek to an absolute or
1040 to relative to the current position */
1041 CVAPI(void) cvSetSeqReaderPos( CvSeqReader* reader, int index,
1042 int is_relative CV_DEFAULT(0));
1044 /* Copies sequence content to a continuous piece of memory */
1045 CVAPI(void*) cvCvtSeqToArray( const CvSeq* seq, void* elements,
1046 CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ) );
1048 /* Creates sequence header for array.
1049 After that all the operations on sequences that do not alter the content
1050 can be applied to the resultant sequence */
1051 CVAPI(CvSeq*) cvMakeSeqHeaderForArray( int seq_type, int header_size,
1052 int elem_size, void* elements, int total,
1053 CvSeq* seq, CvSeqBlock* block );
1055 /* Extracts sequence slice (with or without copying sequence elements) */
1056 CVAPI(CvSeq*) cvSeqSlice( const CvSeq* seq, CvSlice slice,
1057 CvMemStorage* storage CV_DEFAULT(NULL),
1058 int copy_data CV_DEFAULT(0));
1060 CV_INLINE CvSeq* cvCloneSeq( const CvSeq* seq, CvMemStorage* storage CV_DEFAULT(NULL))
1062 return cvSeqSlice( seq, CV_WHOLE_SEQ, storage, 1 );
1065 /* Removes sequence slice */
1066 CVAPI(void) cvSeqRemoveSlice( CvSeq* seq, CvSlice slice );
1068 /* Inserts a sequence or array into another sequence */
1069 CVAPI(void) cvSeqInsertSlice( CvSeq* seq, int before_index, const CvArr* from_arr );
1071 /* a < b ? -1 : a > b ? 1 : 0 */
1072 typedef int (CV_CDECL* CvCmpFunc)(const void* a, const void* b, void* userdata );
1074 /* Sorts sequence in-place given element comparison function */
1075 CVAPI(void) cvSeqSort( CvSeq* seq, CvCmpFunc func, void* userdata CV_DEFAULT(NULL) );
1077 /* Finds element in a [sorted] sequence */
1078 CVAPI(schar*) cvSeqSearch( CvSeq* seq, const void* elem, CvCmpFunc func,
1079 int is_sorted, int* elem_idx,
1080 void* userdata CV_DEFAULT(NULL) );
1082 /* Reverses order of sequence elements in-place */
1083 CVAPI(void) cvSeqInvert( CvSeq* seq );
1085 /* Splits sequence into one or more equivalence classes using the specified criteria */
1086 CVAPI(int) cvSeqPartition( const CvSeq* seq, CvMemStorage* storage,
1087 CvSeq** labels, CvCmpFunc is_equal, void* userdata );
1089 /************ Internal sequence functions ************/
1090 CVAPI(void) cvChangeSeqBlock( void* reader, int direction );
1091 CVAPI(void) cvCreateSeqBlock( CvSeqWriter* writer );
1094 /* Creates a new set */
1095 CVAPI(CvSet*) cvCreateSet( int set_flags, int header_size,
1096 int elem_size, CvMemStorage* storage );
1098 /* Adds new element to the set and returns pointer to it */
1099 CVAPI(int) cvSetAdd( CvSet* set_header, CvSetElem* elem CV_DEFAULT(NULL),
1100 CvSetElem** inserted_elem CV_DEFAULT(NULL) );
1102 /* Fast variant of cvSetAdd */
1103 CV_INLINE CvSetElem* cvSetNew( CvSet* set_header )
1105 CvSetElem* elem = set_header->free_elems;
1108 set_header->free_elems = elem->next_free;
1109 elem->flags = elem->flags & CV_SET_ELEM_IDX_MASK;
1110 set_header->active_count++;
1113 cvSetAdd( set_header, NULL, (CvSetElem**)&elem );
1117 /* Removes set element given its pointer */
1118 CV_INLINE void cvSetRemoveByPtr( CvSet* set_header, void* elem )
1120 CvSetElem* _elem = (CvSetElem*)elem;
1121 assert( _elem->flags >= 0 /*&& (elem->flags & CV_SET_ELEM_IDX_MASK) < set_header->total*/ );
1122 _elem->next_free = set_header->free_elems;
1123 _elem->flags = (_elem->flags & CV_SET_ELEM_IDX_MASK) | CV_SET_ELEM_FREE_FLAG;
1124 set_header->free_elems = _elem;
1125 set_header->active_count--;
1128 /* Removes element from the set by its index */
1129 CVAPI(void) cvSetRemove( CvSet* set_header, int index );
1131 /* Returns a set element by index. If the element doesn't belong to the set,
1133 CV_INLINE CvSetElem* cvGetSetElem( const CvSet* set_header, int index )
1135 CvSetElem* elem = (CvSetElem*)cvGetSeqElem( (CvSeq*)set_header, index );
1136 return elem && CV_IS_SET_ELEM( elem ) ? elem : 0;
1139 /* Removes all the elements from the set */
1140 CVAPI(void) cvClearSet( CvSet* set_header );
1142 /* Creates new graph */
1143 CVAPI(CvGraph*) cvCreateGraph( int graph_flags, int header_size,
1144 int vtx_size, int edge_size,
1145 CvMemStorage* storage );
1147 /* Adds new vertex to the graph */
1148 CVAPI(int) cvGraphAddVtx( CvGraph* graph, const CvGraphVtx* vtx CV_DEFAULT(NULL),
1149 CvGraphVtx** inserted_vtx CV_DEFAULT(NULL) );
1152 /* Removes vertex from the graph together with all incident edges */
1153 CVAPI(int) cvGraphRemoveVtx( CvGraph* graph, int index );
1154 CVAPI(int) cvGraphRemoveVtxByPtr( CvGraph* graph, CvGraphVtx* vtx );
1157 /* Link two vertices specifed by indices or pointers if they
1158 are not connected or return pointer to already existing edge
1159 connecting the vertices.
1160 Functions return 1 if a new edge was created, 0 otherwise */
1161 CVAPI(int) cvGraphAddEdge( CvGraph* graph,
1162 int start_idx, int end_idx,
1163 const CvGraphEdge* edge CV_DEFAULT(NULL),
1164 CvGraphEdge** inserted_edge CV_DEFAULT(NULL) );
1166 CVAPI(int) cvGraphAddEdgeByPtr( CvGraph* graph,
1167 CvGraphVtx* start_vtx, CvGraphVtx* end_vtx,
1168 const CvGraphEdge* edge CV_DEFAULT(NULL),
1169 CvGraphEdge** inserted_edge CV_DEFAULT(NULL) );
1171 /* Remove edge connecting two vertices */
1172 CVAPI(void) cvGraphRemoveEdge( CvGraph* graph, int start_idx, int end_idx );
1173 CVAPI(void) cvGraphRemoveEdgeByPtr( CvGraph* graph, CvGraphVtx* start_vtx,
1174 CvGraphVtx* end_vtx );
1176 /* Find edge connecting two vertices */
1177 CVAPI(CvGraphEdge*) cvFindGraphEdge( const CvGraph* graph, int start_idx, int end_idx );
1178 CVAPI(CvGraphEdge*) cvFindGraphEdgeByPtr( const CvGraph* graph,
1179 const CvGraphVtx* start_vtx,
1180 const CvGraphVtx* end_vtx );
1181 #define cvGraphFindEdge cvFindGraphEdge
1182 #define cvGraphFindEdgeByPtr cvFindGraphEdgeByPtr
1184 /* Remove all vertices and edges from the graph */
1185 CVAPI(void) cvClearGraph( CvGraph* graph );
1188 /* Count number of edges incident to the vertex */
1189 CVAPI(int) cvGraphVtxDegree( const CvGraph* graph, int vtx_idx );
1190 CVAPI(int) cvGraphVtxDegreeByPtr( const CvGraph* graph, const CvGraphVtx* vtx );
1193 /* Retrieves graph vertex by given index */
1194 #define cvGetGraphVtx( graph, idx ) (CvGraphVtx*)cvGetSetElem((CvSet*)(graph), (idx))
1196 /* Retrieves index of a graph vertex given its pointer */
1197 #define cvGraphVtxIdx( graph, vtx ) ((vtx)->flags & CV_SET_ELEM_IDX_MASK)
1199 /* Retrieves index of a graph edge given its pointer */
1200 #define cvGraphEdgeIdx( graph, edge ) ((edge)->flags & CV_SET_ELEM_IDX_MASK)
1202 #define cvGraphGetVtxCount( graph ) ((graph)->active_count)
1203 #define cvGraphGetEdgeCount( graph ) ((graph)->edges->active_count)
1205 #define CV_GRAPH_VERTEX 1
1206 #define CV_GRAPH_TREE_EDGE 2
1207 #define CV_GRAPH_BACK_EDGE 4
1208 #define CV_GRAPH_FORWARD_EDGE 8
1209 #define CV_GRAPH_CROSS_EDGE 16
1210 #define CV_GRAPH_ANY_EDGE 30
1211 #define CV_GRAPH_NEW_TREE 32
1212 #define CV_GRAPH_BACKTRACKING 64
1213 #define CV_GRAPH_OVER -1
1215 #define CV_GRAPH_ALL_ITEMS -1
1217 /* flags for graph vertices and edges */
1218 #define CV_GRAPH_ITEM_VISITED_FLAG (1 << 30)
1219 #define CV_IS_GRAPH_VERTEX_VISITED(vtx) \
1220 (((CvGraphVtx*)(vtx))->flags & CV_GRAPH_ITEM_VISITED_FLAG)
1221 #define CV_IS_GRAPH_EDGE_VISITED(edge) \
1222 (((CvGraphEdge*)(edge))->flags & CV_GRAPH_ITEM_VISITED_FLAG)
1223 #define CV_GRAPH_SEARCH_TREE_NODE_FLAG (1 << 29)
1224 #define CV_GRAPH_FORWARD_EDGE_FLAG (1 << 28)
1226 typedef struct CvGraphScanner
1228 CvGraphVtx* vtx; /* current graph vertex (or current edge origin) */
1229 CvGraphVtx* dst; /* current graph edge destination vertex */
1230 CvGraphEdge* edge; /* current edge */
1232 CvGraph* graph; /* the graph */
1233 CvSeq* stack; /* the graph vertex stack */
1234 int index; /* the lower bound of certainly visited vertices */
1235 int mask; /* event mask */
1239 /* Creates new graph scanner. */
1240 CVAPI(CvGraphScanner*) cvCreateGraphScanner( CvGraph* graph,
1241 CvGraphVtx* vtx CV_DEFAULT(NULL),
1242 int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS));
1244 /* Releases graph scanner. */
1245 CVAPI(void) cvReleaseGraphScanner( CvGraphScanner** scanner );
1247 /* Get next graph element */
1248 CVAPI(int) cvNextGraphItem( CvGraphScanner* scanner );
1250 /* Creates a copy of graph */
1251 CVAPI(CvGraph*) cvCloneGraph( const CvGraph* graph, CvMemStorage* storage );
1253 /****************************************************************************************\
1255 \****************************************************************************************/
1257 /****************************************************************************************\
1258 * Drawing functions work with images/matrices of arbitrary type. *
1259 * For color images the channel order is BGR[A] *
1260 * Antialiasing is supported only for 8-bit image now. *
1261 * All the functions include parameter color that means rgb value (that may be *
1262 * constructed with CV_RGB macro) for color images and brightness *
1263 * for grayscale images. *
1264 * If a drawn figure is partially or completely outside of the image, it is clipped.*
1265 \****************************************************************************************/
1267 #define CV_RGB( r, g, b ) cvScalar( (b), (g), (r), 0 )
1268 #define CV_FILLED -1
1272 /* Draws 4-connected, 8-connected or antialiased line segment connecting two points */
1273 CVAPI(void) cvLine( CvArr* img, CvPoint pt1, CvPoint pt2,
1274 CvScalar color, int thickness CV_DEFAULT(1),
1275 int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
1277 /* Draws a rectangle given two opposite corners of the rectangle (pt1 & pt2),
1278 if thickness<0 (e.g. thickness == CV_FILLED), the filled box is drawn */
1279 CVAPI(void) cvRectangle( CvArr* img, CvPoint pt1, CvPoint pt2,
1280 CvScalar color, int thickness CV_DEFAULT(1),
1281 int line_type CV_DEFAULT(8),
1282 int shift CV_DEFAULT(0));
1284 /* Draws a circle with specified center and radius.
1285 Thickness works in the same way as with cvRectangle */
1286 CVAPI(void) cvCircle( CvArr* img, CvPoint center, int radius,
1287 CvScalar color, int thickness CV_DEFAULT(1),
1288 int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
1290 /* Draws ellipse outline, filled ellipse, elliptic arc or filled elliptic sector,
1291 depending on <thickness>, <start_angle> and <end_angle> parameters. The resultant figure
1292 is rotated by <angle>. All the angles are in degrees */
1293 CVAPI(void) cvEllipse( CvArr* img, CvPoint center, CvSize axes,
1294 double angle, double start_angle, double end_angle,
1295 CvScalar color, int thickness CV_DEFAULT(1),
1296 int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
1298 CV_INLINE void cvEllipseBox( CvArr* img, CvBox2D box, CvScalar color,
1299 int thickness CV_DEFAULT(1),
1300 int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) )
1303 axes.width = cvRound(box.size.height*0.5);
1304 axes.height = cvRound(box.size.width*0.5);
1306 cvEllipse( img, cvPointFrom32f( box.center ), axes, box.angle,
1307 0, 360, color, thickness, line_type, shift );
1310 /* Fills convex or monotonous polygon. */
1311 CVAPI(void) cvFillConvexPoly( CvArr* img, CvPoint* pts, int npts, CvScalar color,
1312 int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
1314 /* Fills an area bounded by one or more arbitrary polygons */
1315 CVAPI(void) cvFillPoly( CvArr* img, CvPoint** pts, int* npts, int contours, CvScalar color,
1316 int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
1318 /* Draws one or more polygonal curves */
1319 CVAPI(void) cvPolyLine( CvArr* img, CvPoint** pts, int* npts, int contours,
1320 int is_closed, CvScalar color, int thickness CV_DEFAULT(1),
1321 int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
1323 #define cvDrawRect cvRectangle
1324 #define cvDrawLine cvLine
1325 #define cvDrawCircle cvCircle
1326 #define cvDrawEllipse cvEllipse
1327 #define cvDrawPolyLine cvPolyLine
1329 /* Clips the line segment connecting *pt1 and *pt2
1330 by the rectangular window
1331 (0<=x<img_size.width, 0<=y<img_size.height). */
1332 CVAPI(int) cvClipLine( CvSize img_size, CvPoint* pt1, CvPoint* pt2 );
1334 /* Initializes line iterator. Initially, line_iterator->ptr will point
1335 to pt1 (or pt2, see left_to_right description) location in the image.
1336 Returns the number of pixels on the line between the ending points. */
1337 CVAPI(int) cvInitLineIterator( const CvArr* image, CvPoint pt1, CvPoint pt2,
1338 CvLineIterator* line_iterator,
1339 int connectivity CV_DEFAULT(8),
1340 int left_to_right CV_DEFAULT(0));
1342 /* Moves iterator to the next line point */
1343 #define CV_NEXT_LINE_POINT( line_iterator ) \
1345 int _line_iterator_mask = (line_iterator).err < 0 ? -1 : 0; \
1346 (line_iterator).err += (line_iterator).minus_delta + \
1347 ((line_iterator).plus_delta & _line_iterator_mask); \
1348 (line_iterator).ptr += (line_iterator).minus_step + \
1349 ((line_iterator).plus_step & _line_iterator_mask); \
1353 /* basic font types */
1354 #define CV_FONT_HERSHEY_SIMPLEX 0
1355 #define CV_FONT_HERSHEY_PLAIN 1
1356 #define CV_FONT_HERSHEY_DUPLEX 2
1357 #define CV_FONT_HERSHEY_COMPLEX 3
1358 #define CV_FONT_HERSHEY_TRIPLEX 4
1359 #define CV_FONT_HERSHEY_COMPLEX_SMALL 5
1360 #define CV_FONT_HERSHEY_SCRIPT_SIMPLEX 6
1361 #define CV_FONT_HERSHEY_SCRIPT_COMPLEX 7
1364 #define CV_FONT_ITALIC 16
1366 #define CV_FONT_VECTOR0 CV_FONT_HERSHEY_SIMPLEX
1368 /* Font structure */
1369 typedef struct CvFont
1371 int font_face; /* =CV_FONT_* */
1372 const int* ascii; /* font data and metrics */
1374 const int* cyrillic;
1375 float hscale, vscale;
1376 float shear; /* slope coefficient: 0 - normal, >0 - italic */
1377 int thickness; /* letters thickness */
1378 float dx; /* horizontal interval between letters */
1383 /* Initializes font structure used further in cvPutText */
1384 CVAPI(void) cvInitFont( CvFont* font, int font_face,
1385 double hscale, double vscale,
1386 double shear CV_DEFAULT(0),
1387 int thickness CV_DEFAULT(1),
1388 int line_type CV_DEFAULT(8));
1390 CV_INLINE CvFont cvFont( double scale, int thickness CV_DEFAULT(1) )
1393 cvInitFont( &font, CV_FONT_HERSHEY_PLAIN, scale, scale, 0, thickness, CV_AA );
1397 /* Renders text stroke with specified font and color at specified location.
1398 CvFont should be initialized with cvInitFont */
1399 CVAPI(void) cvPutText( CvArr* img, const char* text, CvPoint org,
1400 const CvFont* font, CvScalar color );
1402 /* Calculates bounding box of text stroke (useful for alignment) */
1403 CVAPI(void) cvGetTextSize( const char* text_string, const CvFont* font,
1404 CvSize* text_size, int* baseline );
1406 /* Unpacks color value, if arrtype is CV_8UC?, <color> is treated as
1407 packed color value, otherwise the first channels (depending on arrtype)
1408 of destination scalar are set to the same value = <color> */
1409 CVAPI(CvScalar) cvColorToScalar( double packed_color, int arrtype );
1411 /* Returns the polygon points which make up the given ellipse. The ellipse is define by
1412 the box of size 'axes' rotated 'angle' around the 'center'. A partial sweep
1413 of the ellipse arc can be done by spcifying arc_start and arc_end to be something
1414 other than 0 and 360, respectively. The input array 'pts' must be large enough to
1415 hold the result. The total number of points stored into 'pts' is returned by this
1417 CVAPI(int) cvEllipse2Poly( CvPoint center, CvSize axes,
1418 int angle, int arc_start, int arc_end, CvPoint * pts, int delta );
1420 /* Draws contour outlines or filled interiors on the image */
1421 CVAPI(void) cvDrawContours( CvArr *img, CvSeq* contour,
1422 CvScalar external_color, CvScalar hole_color,
1423 int max_level, int thickness CV_DEFAULT(1),
1424 int line_type CV_DEFAULT(8),
1425 CvPoint offset CV_DEFAULT(cvPoint(0,0)));
1427 /* Does look-up transformation. Elements of the source array
1428 (that should be 8uC1 or 8sC1) are used as indexes in lutarr 256-element table */
1429 CVAPI(void) cvLUT( const CvArr* src, CvArr* dst, const CvArr* lut );
1432 /******************* Iteration through the sequence tree *****************/
1433 typedef struct CvTreeNodeIterator
1441 CVAPI(void) cvInitTreeNodeIterator( CvTreeNodeIterator* tree_iterator,
1442 const void* first, int max_level );
1443 CVAPI(void*) cvNextTreeNode( CvTreeNodeIterator* tree_iterator );
1444 CVAPI(void*) cvPrevTreeNode( CvTreeNodeIterator* tree_iterator );
1446 /* Inserts sequence into tree with specified "parent" sequence.
1447 If parent is equal to frame (e.g. the most external contour),
1448 then added contour will have null pointer to parent. */
1449 CVAPI(void) cvInsertNodeIntoTree( void* node, void* parent, void* frame );
1451 /* Removes contour from tree (together with the contour children). */
1452 CVAPI(void) cvRemoveNodeFromTree( void* node, void* frame );
1454 /* Gathers pointers to all the sequences,
1455 accessible from the <first>, to the single sequence */
1456 CVAPI(CvSeq*) cvTreeToNodeSeq( const void* first, int header_size,
1457 CvMemStorage* storage );
1459 /* The function implements the K-means algorithm for clustering an array of sample
1460 vectors in a specified number of classes */
1461 CVAPI(void) cvKMeans2( const CvArr* samples, int cluster_count,
1462 CvArr* labels, CvTermCriteria termcrit );
1464 /****************************************************************************************\
1465 * System functions *
1466 \****************************************************************************************/
1468 /* Add the function pointers table with associated information to the IPP primitives list */
1469 CVAPI(int) cvRegisterModule( const CvModuleInfo* module_info );
1471 /* Loads optimized functions from IPP, MKL etc. or switches back to pure C code */
1472 CVAPI(int) cvUseOptimized( int on_off );
1474 /* Retrieves information about the registered modules and loaded optimized plugins */
1475 CVAPI(void) cvGetModuleInfo( const char* module_name,
1476 const char** version,
1477 const char** loaded_addon_plugins );
1479 /* Get current OpenCV error status */
1480 CVAPI(int) cvGetErrStatus( void );
1482 /* Sets error status silently */
1483 CVAPI(void) cvSetErrStatus( int status );
1485 #define CV_ErrModeLeaf 0 /* Print error and exit program */
1486 #define CV_ErrModeParent 1 /* Print error and continue */
1487 #define CV_ErrModeSilent 2 /* Don't print and continue */
1489 /* Retrives current error processing mode */
1490 CVAPI(int) cvGetErrMode( void );
1492 /* Sets error processing mode, returns previously used mode */
1493 CVAPI(int) cvSetErrMode( int mode );
1495 /* Sets error status and performs some additonal actions (displaying message box,
1496 writing message to stderr, terminating application etc.)
1497 depending on the current error mode */
1498 CVAPI(void) cvError( int status, const char* func_name,
1499 const char* err_msg, const char* file_name, int line );
1501 /* Retrieves textual description of the error given its code */
1502 CVAPI(const char*) cvErrorStr( int status );
1504 /* Retrieves detailed information about the last error occured */
1505 CVAPI(int) cvGetErrInfo( const char** errcode_desc, const char** description,
1506 const char** filename, int* line );
1508 /* Maps IPP error codes to the counterparts from OpenCV */
1509 CVAPI(int) cvErrorFromIppStatus( int ipp_status );
1511 typedef int (CV_CDECL *CvErrorCallback)( int status, const char* func_name,
1512 const char* err_msg, const char* file_name, int line, void* userdata );
1514 /* Assigns a new error-handling function */
1515 CVAPI(CvErrorCallback) cvRedirectError( CvErrorCallback error_handler,
1516 void* userdata CV_DEFAULT(NULL),
1517 void** prev_userdata CV_DEFAULT(NULL) );
1521 cvNulDevReport - nothing
1522 cvStdErrReport - console(fprintf(stderr,...))
1523 cvGuiBoxReport - MessageBox(WIN32)
1525 CVAPI(int) cvNulDevReport( int status, const char* func_name, const char* err_msg,
1526 const char* file_name, int line, void* userdata );
1528 CVAPI(int) cvStdErrReport( int status, const char* func_name, const char* err_msg,
1529 const char* file_name, int line, void* userdata );
1531 CVAPI(int) cvGuiBoxReport( int status, const char* func_name, const char* err_msg,
1532 const char* file_name, int line, void* userdata );
1534 typedef void* (CV_CDECL *CvAllocFunc)(size_t size, void* userdata);
1535 typedef int (CV_CDECL *CvFreeFunc)(void* pptr, void* userdata);
1537 /* Set user-defined memory managment functions (substitutors for malloc and free) that
1538 will be called by cvAlloc, cvFree and higher-level functions (e.g. cvCreateImage) */
1539 CVAPI(void) cvSetMemoryManager( CvAllocFunc alloc_func CV_DEFAULT(NULL),
1540 CvFreeFunc free_func CV_DEFAULT(NULL),
1541 void* userdata CV_DEFAULT(NULL));
1544 typedef IplImage* (CV_STDCALL* Cv_iplCreateImageHeader)
1545 (int,int,int,char*,char*,int,int,int,int,int,
1546 IplROI*,IplImage*,void*,IplTileInfo*);
1547 typedef void (CV_STDCALL* Cv_iplAllocateImageData)(IplImage*,int,int);
1548 typedef void (CV_STDCALL* Cv_iplDeallocate)(IplImage*,int);
1549 typedef IplROI* (CV_STDCALL* Cv_iplCreateROI)(int,int,int,int,int);
1550 typedef IplImage* (CV_STDCALL* Cv_iplCloneImage)(const IplImage*);
1552 /* Makes OpenCV use IPL functions for IplImage allocation/deallocation */
1553 CVAPI(void) cvSetIPLAllocators( Cv_iplCreateImageHeader create_header,
1554 Cv_iplAllocateImageData allocate_data,
1555 Cv_iplDeallocate deallocate,
1556 Cv_iplCreateROI create_roi,
1557 Cv_iplCloneImage clone_image );
1559 #define CV_TURN_ON_IPL_COMPATIBILITY() \
1560 cvSetIPLAllocators( iplCreateImageHeader, iplAllocateImage, \
1561 iplDeallocate, iplCreateROI, iplCloneImage )
1563 /****************************************************************************************\
1564 * Data Persistence *
1565 \****************************************************************************************/
1567 /********************************** High-level functions ********************************/
1569 /* opens existing or creates new file storage */
1570 CVAPI(CvFileStorage*) cvOpenFileStorage( const char* filename,
1571 CvMemStorage* memstorage,
1574 /* closes file storage and deallocates buffers */
1575 CVAPI(void) cvReleaseFileStorage( CvFileStorage** fs );
1577 /* returns attribute value or 0 (NULL) if there is no such attribute */
1578 CVAPI(const char*) cvAttrValue( const CvAttrList* attr, const char* attr_name );
1580 /* starts writing compound structure (map or sequence) */
1581 CVAPI(void) cvStartWriteStruct( CvFileStorage* fs, const char* name,
1582 int struct_flags, const char* type_name CV_DEFAULT(NULL),
1583 CvAttrList attributes CV_DEFAULT(cvAttrList()));
1585 /* finishes writing compound structure */
1586 CVAPI(void) cvEndWriteStruct( CvFileStorage* fs );
1588 /* writes an integer */
1589 CVAPI(void) cvWriteInt( CvFileStorage* fs, const char* name, int value );
1591 /* writes a floating-point number */
1592 CVAPI(void) cvWriteReal( CvFileStorage* fs, const char* name, double value );
1594 /* writes a string */
1595 CVAPI(void) cvWriteString( CvFileStorage* fs, const char* name,
1596 const char* str, int quote CV_DEFAULT(0) );
1598 /* writes a comment */
1599 CVAPI(void) cvWriteComment( CvFileStorage* fs, const char* comment,
1602 /* writes instance of a standard type (matrix, image, sequence, graph etc.)
1603 or user-defined type */
1604 CVAPI(void) cvWrite( CvFileStorage* fs, const char* name, const void* ptr,
1605 CvAttrList attributes CV_DEFAULT(cvAttrList()));
1607 /* starts the next stream */
1608 CVAPI(void) cvStartNextStream( CvFileStorage* fs );
1610 /* helper function: writes multiple integer or floating-point numbers */
1611 CVAPI(void) cvWriteRawData( CvFileStorage* fs, const void* src,
1612 int len, const char* dt );
1614 /* returns the hash entry corresponding to the specified literal key string or 0
1615 if there is no such a key in the storage */
1616 CVAPI(CvStringHashNode*) cvGetHashedKey( CvFileStorage* fs, const char* name,
1617 int len CV_DEFAULT(-1),
1618 int create_missing CV_DEFAULT(0));
1620 /* returns file node with the specified key within the specified map
1621 (collection of named nodes) */
1622 CVAPI(CvFileNode*) cvGetRootFileNode( const CvFileStorage* fs,
1623 int stream_index CV_DEFAULT(0) );
1625 /* returns file node with the specified key within the specified map
1626 (collection of named nodes) */
1627 CVAPI(CvFileNode*) cvGetFileNode( CvFileStorage* fs, CvFileNode* map,
1628 const CvStringHashNode* key,
1629 int create_missing CV_DEFAULT(0) );
1631 /* this is a slower version of cvGetFileNode that takes the key as a literal string */
1632 CVAPI(CvFileNode*) cvGetFileNodeByName( const CvFileStorage* fs,
1633 const CvFileNode* map,
1636 CV_INLINE int cvReadInt( const CvFileNode* node, int default_value CV_DEFAULT(0) )
1638 return !node ? default_value :
1639 CV_NODE_IS_INT(node->tag) ? node->data.i :
1640 CV_NODE_IS_REAL(node->tag) ? cvRound(node->data.f) : 0x7fffffff;
1644 CV_INLINE int cvReadIntByName( const CvFileStorage* fs, const CvFileNode* map,
1645 const char* name, int default_value CV_DEFAULT(0) )
1647 return cvReadInt( cvGetFileNodeByName( fs, map, name ), default_value );
1651 CV_INLINE double cvReadReal( const CvFileNode* node, double default_value CV_DEFAULT(0.) )
1653 return !node ? default_value :
1654 CV_NODE_IS_INT(node->tag) ? (double)node->data.i :
1655 CV_NODE_IS_REAL(node->tag) ? node->data.f : 1e300;
1659 CV_INLINE double cvReadRealByName( const CvFileStorage* fs, const CvFileNode* map,
1660 const char* name, double default_value CV_DEFAULT(0.) )
1662 return cvReadReal( cvGetFileNodeByName( fs, map, name ), default_value );
1666 CV_INLINE const char* cvReadString( const CvFileNode* node,
1667 const char* default_value CV_DEFAULT(NULL) )
1669 return !node ? default_value : CV_NODE_IS_STRING(node->tag) ? node->data.str.ptr : 0;
1673 CV_INLINE const char* cvReadStringByName( const CvFileStorage* fs, const CvFileNode* map,
1674 const char* name, const char* default_value CV_DEFAULT(NULL) )
1676 return cvReadString( cvGetFileNodeByName( fs, map, name ), default_value );
1680 /* decodes standard or user-defined object and returns it */
1681 CVAPI(void*) cvRead( CvFileStorage* fs, CvFileNode* node,
1682 CvAttrList* attributes CV_DEFAULT(NULL));
1684 /* decodes standard or user-defined object and returns it */
1685 CV_INLINE void* cvReadByName( CvFileStorage* fs, const CvFileNode* map,
1686 const char* name, CvAttrList* attributes CV_DEFAULT(NULL) )
1688 return cvRead( fs, cvGetFileNodeByName( fs, map, name ), attributes );
1692 /* starts reading data from sequence or scalar numeric node */
1693 CVAPI(void) cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src,
1694 CvSeqReader* reader );
1696 /* reads multiple numbers and stores them to array */
1697 CVAPI(void) cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader,
1698 int count, void* dst, const char* dt );
1700 /* combination of two previous functions for easier reading of whole sequences */
1701 CVAPI(void) cvReadRawData( const CvFileStorage* fs, const CvFileNode* src,
1702 void* dst, const char* dt );
1704 /* writes a copy of file node to file storage */
1705 CVAPI(void) cvWriteFileNode( CvFileStorage* fs, const char* new_node_name,
1706 const CvFileNode* node, int embed );
1708 /* returns name of file node */
1709 CVAPI(const char*) cvGetFileNodeName( const CvFileNode* node );
1711 /*********************************** Adding own types ***********************************/
1713 CVAPI(void) cvRegisterType( const CvTypeInfo* info );
1714 CVAPI(void) cvUnregisterType( const char* type_name );
1715 CVAPI(CvTypeInfo*) cvFirstType(void);
1716 CVAPI(CvTypeInfo*) cvFindType( const char* type_name );
1717 CVAPI(CvTypeInfo*) cvTypeOf( const void* struct_ptr );
1719 /* universal functions */
1720 CVAPI(void) cvRelease( void** struct_ptr );
1721 CVAPI(void*) cvClone( const void* struct_ptr );
1723 /* simple API for reading/writing data */
1724 CVAPI(void) cvSave( const char* filename, const void* struct_ptr,
1725 const char* name CV_DEFAULT(NULL),
1726 const char* comment CV_DEFAULT(NULL),
1727 CvAttrList attributes CV_DEFAULT(cvAttrList()));
1728 CVAPI(void*) cvLoad( const char* filename,
1729 CvMemStorage* memstorage CV_DEFAULT(NULL),
1730 const char* name CV_DEFAULT(NULL),
1731 const char** real_name CV_DEFAULT(NULL) );
1733 /*********************************** Measuring Execution Time ***************************/
1735 /* helper functions for RNG initialization and accurate time measurement:
1736 uses internal clock counter on x86 */
1737 CVAPI(int64) cvGetTickCount( void );
1738 CVAPI(double) cvGetTickFrequency( void );
1740 /*********************************** Multi-Threading ************************************/
1742 /* retrieve/set the number of threads used in OpenMP implementations */
1743 CVAPI(int) cvGetNumThreads( void );
1744 CVAPI(void) cvSetNumThreads( int threads CV_DEFAULT(0) );
1745 /* get index of the thread being executed */
1746 CVAPI(int) cvGetThreadNum( void );
1751 #include "cxcore.hpp"
1754 #endif /*_CXCORE_H_*/