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// Intel License Agreement 11// For Open Source Computer Vision Library 12// 13// Copyright (C) 2000, Intel Corporation, all rights reserved. 14// Third party copyrights are property of their respective owners. 15// 16// Redistribution and use in source and binary forms, with or without modification, 17// are permitted provided that the following conditions are met: 18// 19// * Redistribution's of source code must retain the above copyright notice, 20// this list of conditions and the following disclaimer. 21// 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. 25// 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. 28// 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. 39// 40//M*/ 41 42 43#ifndef _CXCORE_H_ 44#define _CXCORE_H_ 45 46#ifdef __IPL_H__ 47#define HAVE_IPL 48#endif 49 50#ifndef SKIP_INCLUDES 51 #if defined HAVE_IPL && !defined __IPL_H__ 52 #ifndef _INC_WINDOWS 53 #define CV_PRETEND_WINDOWS 54 #define _INC_WINDOWS 55 typedef struct tagBITMAPINFOHEADER BITMAPINFOHEADER; 56 typedef int BOOL; 57 #endif 58 #if defined WIN32 || defined WIN64 59 #include "ipl.h" 60 #else 61 #include "ipl/ipl.h" 62 #endif 63 #ifdef CV_PRETEND_WINDOWS 64 #undef _INC_WINDOWS 65 #endif 66 #endif 67#endif // SKIP_INCLUDES 68 69#include "cxtypes.h" 70#include "cxerror.h" 71#include "cvver.h" 72 73#ifdef __cplusplus 74extern "C" { 75#endif 76 77/****************************************************************************************\ 78* Array allocation, deallocation, initialization and access to elements * 79\****************************************************************************************/ 80 81/* <malloc> wrapper. 82 If there is no enough memory, the function 83 (as well as other OpenCV functions that call cvAlloc) 84 raises an error. */ 85CVAPI(void*) cvAlloc( size_t size ); 86 87/* <free> wrapper. 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 92*/ 93CVAPI(void) cvFree_( void* ptr ); 94#define cvFree(ptr) (cvFree_(*(ptr)), *(ptr)=0) 95 96/* Allocates and initializes IplImage header */ 97CVAPI(IplImage*) cvCreateImageHeader( CvSize size, int depth, int channels ); 98 99/* Inializes IplImage header */ 100CVAPI(IplImage*) cvInitImageHeader( IplImage* image, CvSize size, int depth, 101 int channels, int origin CV_DEFAULT(0), 102 int align CV_DEFAULT(4)); 103 104/* Creates IPL image (header and data) */ 105CVAPI(IplImage*) cvCreateImage( CvSize size, int depth, int channels ); 106 107/* Releases (i.e. deallocates) IPL image header */ 108CVAPI(void) cvReleaseImageHeader( IplImage** image ); 109 110/* Releases IPL image header and data */ 111CVAPI(void) cvReleaseImage( IplImage** image ); 112 113/* Creates a copy of IPL image (widthStep may differ) */ 114CVAPI(IplImage*) cvCloneImage( const IplImage* image ); 115 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 */ 118CVAPI(void) cvSetImageCOI( IplImage* image, int coi ); 119 120/* Retrieves image Channel Of Interest */ 121CVAPI(int) cvGetImageCOI( const IplImage* image ); 122 123/* Sets image ROI (region of interest) (COI is not changed) */ 124CVAPI(void) cvSetImageROI( IplImage* image, CvRect rect ); 125 126/* Resets image ROI and COI */ 127CVAPI(void) cvResetImageROI( IplImage* image ); 128 129/* Retrieves image ROI */ 130CVAPI(CvRect) cvGetImageROI( const IplImage* image ); 131 132/* Allocates and initalizes CvMat header */ 133CVAPI(CvMat*) cvCreateMatHeader( int rows, int cols, int type ); 134 135#define CV_AUTOSTEP 0x7fffffff 136 137/* Initializes CvMat header */ 138CVAPI(CvMat*) cvInitMatHeader( CvMat* mat, int rows, int cols, 139 int type, void* data CV_DEFAULT(NULL), 140 int step CV_DEFAULT(CV_AUTOSTEP) ); 141 142/* Allocates and initializes CvMat header and allocates data */ 143CVAPI(CvMat*) cvCreateMat( int rows, int cols, int type ); 144 145/* Releases CvMat header and deallocates matrix data 146 (reference counting is used for data) */ 147CVAPI(void) cvReleaseMat( CvMat** mat ); 148 149/* Decrements CvMat data reference counter and deallocates the data if 150 it reaches 0 */ 151CV_INLINE void cvDecRefData( CvArr* arr ) 152{ 153 if( CV_IS_MAT( arr )) 154 { 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; 160 } 161 else if( CV_IS_MATND( arr )) 162 { 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; 168 } 169} 170 171/* Increments CvMat data reference counter */ 172CV_INLINE int cvIncRefData( CvArr* arr ) 173{ 174 int refcount = 0; 175 if( CV_IS_MAT( arr )) 176 { 177 CvMat* mat = (CvMat*)arr; 178 if( mat->refcount != NULL ) 179 refcount = ++*mat->refcount; 180 } 181 else if( CV_IS_MATND( arr )) 182 { 183 CvMatND* mat = (CvMatND*)arr; 184 if( mat->refcount != NULL ) 185 refcount = ++*mat->refcount; 186 } 187 return refcount; 188} 189 190 191/* Creates an exact copy of the input matrix (except, may be, step value) */ 192CVAPI(CvMat*) cvCloneMat( const CvMat* mat ); 193 194 195/* Makes a new matrix from <rect> subrectangle of input array. 196 No data is copied */ 197CVAPI(CvMat*) cvGetSubRect( const CvArr* arr, CvMat* submat, CvRect rect ); 198#define cvGetSubArr cvGetSubRect 199 200/* Selects row span of the input array: arr(start_row:delta_row:end_row,:) 201 (end_row is not included into the span). */ 202CVAPI(CvMat*) cvGetRows( const CvArr* arr, CvMat* submat, 203 int start_row, int end_row, 204 int delta_row CV_DEFAULT(1)); 205 206CV_INLINE CvMat* cvGetRow( const CvArr* arr, CvMat* submat, int row ) 207{ 208 return cvGetRows( arr, submat, row, row + 1, 1 ); 209} 210 211 212/* Selects column span of the input array: arr(:,start_col:end_col) 213 (end_col is not included into the span) */ 214CVAPI(CvMat*) cvGetCols( const CvArr* arr, CvMat* submat, 215 int start_col, int end_col ); 216 217CV_INLINE CvMat* cvGetCol( const CvArr* arr, CvMat* submat, int col ) 218{ 219 return cvGetCols( arr, submat, col, col + 1 ); 220} 221 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). */ 226CVAPI(CvMat*) cvGetDiag( const CvArr* arr, CvMat* submat, 227 int diag CV_DEFAULT(0)); 228 229/* low-level scalar <-> raw data conversion functions */ 230CVAPI(void) cvScalarToRawData( const CvScalar* scalar, void* data, int type, 231 int extend_to_12 CV_DEFAULT(0) ); 232 233CVAPI(void) cvRawDataToScalar( const void* data, int type, CvScalar* scalar ); 234 235/* Allocates and initializes CvMatND header */ 236CVAPI(CvMatND*) cvCreateMatNDHeader( int dims, const int* sizes, int type ); 237 238/* Allocates and initializes CvMatND header and allocates data */ 239CVAPI(CvMatND*) cvCreateMatND( int dims, const int* sizes, int type ); 240 241/* Initializes preallocated CvMatND header */ 242CVAPI(CvMatND*) cvInitMatNDHeader( CvMatND* mat, int dims, const int* sizes, 243 int type, void* data CV_DEFAULT(NULL) ); 244 245/* Releases CvMatND */ 246CV_INLINE void cvReleaseMatND( CvMatND** mat ) 247{ 248 cvReleaseMat( (CvMat**)mat ); 249} 250 251/* Creates a copy of CvMatND (except, may be, steps) */ 252CVAPI(CvMatND*) cvCloneMatND( const CvMatND* mat ); 253 254/* Allocates and initializes CvSparseMat header and allocates data */ 255CVAPI(CvSparseMat*) cvCreateSparseMat( int dims, const int* sizes, int type ); 256 257/* Releases CvSparseMat */ 258CVAPI(void) cvReleaseSparseMat( CvSparseMat** mat ); 259 260/* Creates a copy of CvSparseMat (except, may be, zero items) */ 261CVAPI(CvSparseMat*) cvCloneSparseMat( const CvSparseMat* mat ); 262 263/* Initializes sparse array iterator 264 (returns the first node or NULL if the array is empty) */ 265CVAPI(CvSparseNode*) cvInitSparseMatIterator( const CvSparseMat* mat, 266 CvSparseMatIterator* mat_iterator ); 267 268// returns next sparse array node (or NULL if there is no more nodes) 269CV_INLINE CvSparseNode* cvGetNextSparseNode( CvSparseMatIterator* mat_iterator ) 270{ 271 if( mat_iterator->node->next ) 272 return mat_iterator->node = mat_iterator->node->next; 273 else 274 { 275 int idx; 276 for( idx = ++mat_iterator->curidx; idx < mat_iterator->mat->hashsize; idx++ ) 277 { 278 CvSparseNode* node = (CvSparseNode*)mat_iterator->mat->hashtable[idx]; 279 if( node ) 280 { 281 mat_iterator->curidx = idx; 282 return mat_iterator->node = node; 283 } 284 } 285 return NULL; 286 } 287} 288 289/**************** matrix iterator: used for n-ary operations on dense arrays *********/ 290 291#define CV_MAX_ARR 10 292 293typedef struct CvNArrayIterator 294{ 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 */ 302} 303CvNArrayIterator; 304 305#define CV_NO_DEPTH_CHECK 1 306#define CV_NO_CN_CHECK 2 307#define CV_NO_SIZE_CHECK 4 308 309/* initializes iterator that traverses through several arrays simulteneously 310 (the function together with cvNextArraySlice is used for 311 N-ari element-wise operations) */ 312CVAPI(int) cvInitNArrayIterator( int count, CvArr** arrs, 313 const CvArr* mask, CvMatND* stubs, 314 CvNArrayIterator* array_iterator, 315 int flags CV_DEFAULT(0) ); 316 317/* returns zero value if iteration is finished, non-zero (slice length) otherwise */ 318CVAPI(int) cvNextNArraySlice( CvNArrayIterator* array_iterator ); 319 320 321/* Returns type of array elements: 322 CV_8UC1 ... CV_64FC4 ... */ 323CVAPI(int) cvGetElemType( const CvArr* arr ); 324 325/* Retrieves number of an array dimensions and 326 optionally sizes of the dimensions */ 327CVAPI(int) cvGetDims( const CvArr* arr, int* sizes CV_DEFAULT(NULL) ); 328 329 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) */ 333CVAPI(int) cvGetDimSize( const CvArr* arr, int index ); 334 335 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 */ 338CVAPI(uchar*) cvPtr1D( const CvArr* arr, int idx0, int* type CV_DEFAULT(NULL)); 339CVAPI(uchar*) cvPtr2D( const CvArr* arr, int idx0, int idx1, int* type CV_DEFAULT(NULL) ); 340CVAPI(uchar*) cvPtr3D( const CvArr* arr, int idx0, int idx1, int idx2, 341 int* type CV_DEFAULT(NULL)); 342 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. */ 347CVAPI(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)); 350 351/* value = arr(idx0,idx1,...) */ 352CVAPI(CvScalar) cvGet1D( const CvArr* arr, int idx0 ); 353CVAPI(CvScalar) cvGet2D( const CvArr* arr, int idx0, int idx1 ); 354CVAPI(CvScalar) cvGet3D( const CvArr* arr, int idx0, int idx1, int idx2 ); 355CVAPI(CvScalar) cvGetND( const CvArr* arr, const int* idx ); 356 357/* for 1-channel arrays */ 358CVAPI(double) cvGetReal1D( const CvArr* arr, int idx0 ); 359CVAPI(double) cvGetReal2D( const CvArr* arr, int idx0, int idx1 ); 360CVAPI(double) cvGetReal3D( const CvArr* arr, int idx0, int idx1, int idx2 ); 361CVAPI(double) cvGetRealND( const CvArr* arr, const int* idx ); 362 363/* arr(idx0,idx1,...) = value */ 364CVAPI(void) cvSet1D( CvArr* arr, int idx0, CvScalar value ); 365CVAPI(void) cvSet2D( CvArr* arr, int idx0, int idx1, CvScalar value ); 366CVAPI(void) cvSet3D( CvArr* arr, int idx0, int idx1, int idx2, CvScalar value ); 367CVAPI(void) cvSetND( CvArr* arr, const int* idx, CvScalar value ); 368 369/* for 1-channel arrays */ 370CVAPI(void) cvSetReal1D( CvArr* arr, int idx0, double value ); 371CVAPI(void) cvSetReal2D( CvArr* arr, int idx0, int idx1, double value ); 372CVAPI(void) cvSetReal3D( CvArr* arr, int idx0, 373 int idx1, int idx2, double value ); 374CVAPI(void) cvSetRealND( CvArr* arr, const int* idx, double value ); 375 376/* clears element of ND dense array, 377 in case of sparse arrays it deletes the specified node */ 378CVAPI(void) cvClearND( CvArr* arr, const int* idx ); 379 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 */ 385CVAPI(CvMat*) cvGetMat( const CvArr* arr, CvMat* header, 386 int* coi CV_DEFAULT(NULL), 387 int allowND CV_DEFAULT(0)); 388 389/* Converts CvArr (IplImage or CvMat) to IplImage */ 390CVAPI(IplImage*) cvGetImage( const CvArr* arr, IplImage* image_header ); 391 392 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 */ 403CVAPI(CvArr*) cvReshapeMatND( const CvArr* arr, 404 int sizeof_header, CvArr* header, 405 int new_cn, int new_dims, int* new_sizes ); 406 407#define cvReshapeND( arr, header, new_cn, new_dims, new_sizes ) \ 408 cvReshapeMatND( (arr), sizeof(*(header)), (header), \ 409 (new_cn), (new_dims), (new_sizes)) 410 411CVAPI(CvMat*) cvReshape( const CvArr* arr, CvMat* header, 412 int new_cn, int new_rows CV_DEFAULT(0) ); 413 414/* Repeats source 2d array several times in both horizontal and 415 vertical direction to fill destination array */ 416CVAPI(void) cvRepeat( const CvArr* src, CvArr* dst ); 417 418/* Allocates array data */ 419CVAPI(void) cvCreateData( CvArr* arr ); 420 421/* Releases array data */ 422CVAPI(void) cvReleaseData( CvArr* arr ); 423 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) */ 427CVAPI(void) cvSetData( CvArr* arr, void* data, int step ); 428 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 */ 432CVAPI(void) cvGetRawData( const CvArr* arr, uchar** data, 433 int* step CV_DEFAULT(NULL), 434 CvSize* roi_size CV_DEFAULT(NULL)); 435 436/* Returns width and height of array in elements */ 437CVAPI(CvSize) cvGetSize( const CvArr* arr ); 438 439/* Copies source array to destination array */ 440CVAPI(void) cvCopy( const CvArr* src, CvArr* dst, 441 const CvArr* mask CV_DEFAULT(NULL) ); 442 443/* Sets all or "masked" elements of input array 444 to the same value*/ 445CVAPI(void) cvSet( CvArr* arr, CvScalar value, 446 const CvArr* mask CV_DEFAULT(NULL) ); 447 448/* Clears all the array elements (sets them to 0) */ 449CVAPI(void) cvSetZero( CvArr* arr ); 450#define cvZero cvSetZero 451 452 453/* Splits a multi-channel array into the set of single-channel arrays or 454 extracts particular [color] plane */ 455CVAPI(void) cvSplit( const CvArr* src, CvArr* dst0, CvArr* dst1, 456 CvArr* dst2, CvArr* dst3 ); 457 458/* Merges a set of single-channel arrays into the single multi-channel array 459 or inserts one particular [color] plane to the array */ 460CVAPI(void) cvMerge( const CvArr* src0, const CvArr* src1, 461 const CvArr* src2, const CvArr* src3, 462 CvArr* dst ); 463 464/* Copies several channels from input arrays to 465 certain channels of output arrays */ 466CVAPI(void) cvMixChannels( const CvArr** src, int src_count, 467 CvArr** dst, int dst_count, 468 const int* from_to, int pair_count ); 469 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 */ 475CVAPI(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 ) 481 482 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 */ 488CVAPI(void) cvConvertScaleAbs( const CvArr* src, CvArr* dst, 489 double scale CV_DEFAULT(1), 490 double shift CV_DEFAULT(0) ); 491#define cvCvtScaleAbs cvConvertScaleAbs 492 493 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) 497*/ 498CVAPI(CvTermCriteria) cvCheckTermCriteria( CvTermCriteria criteria, 499 double default_eps, 500 int default_max_iters ); 501 502/****************************************************************************************\ 503* Arithmetic, logic and comparison operations * 504\****************************************************************************************/ 505 506/* dst(mask) = src1(mask) + src2(mask) */ 507CVAPI(void) cvAdd( const CvArr* src1, const CvArr* src2, CvArr* dst, 508 const CvArr* mask CV_DEFAULT(NULL)); 509 510/* dst(mask) = src(mask) + value */ 511CVAPI(void) cvAddS( const CvArr* src, CvScalar value, CvArr* dst, 512 const CvArr* mask CV_DEFAULT(NULL)); 513 514/* dst(mask) = src1(mask) - src2(mask) */ 515CVAPI(void) cvSub( const CvArr* src1, const CvArr* src2, CvArr* dst, 516 const CvArr* mask CV_DEFAULT(NULL)); 517 518/* dst(mask) = src(mask) - value = src(mask) + (-value) */ 519CV_INLINE void cvSubS( const CvArr* src, CvScalar value, CvArr* dst, 520 const CvArr* mask CV_DEFAULT(NULL)) 521{ 522 cvAddS( src, cvScalar( -value.val[0], -value.val[1], -value.val[2], -value.val[3]), 523 dst, mask ); 524} 525 526/* dst(mask) = value - src(mask) */ 527CVAPI(void) cvSubRS( const CvArr* src, CvScalar value, CvArr* dst, 528 const CvArr* mask CV_DEFAULT(NULL)); 529 530/* dst(idx) = src1(idx) * src2(idx) * scale 531 (scaled element-wise multiplication of 2 arrays) */ 532CVAPI(void) cvMul( const CvArr* src1, const CvArr* src2, 533 CvArr* dst, double scale CV_DEFAULT(1) ); 534 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 */ 538CVAPI(void) cvDiv( const CvArr* src1, const CvArr* src2, 539 CvArr* dst, double scale CV_DEFAULT(1)); 540 541/* dst = src1 * scale + src2 */ 542CVAPI(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) 545 546/* dst = src1 * alpha + src2 * beta + gamma */ 547CVAPI(void) cvAddWeighted( const CvArr* src1, double alpha, 548 const CvArr* src2, double beta, 549 double gamma, CvArr* dst ); 550 551/* result = sum_i(src1(i) * src2(i)) (results for all channels are accumulated together) */ 552CVAPI(double) cvDotProduct( const CvArr* src1, const CvArr* src2 ); 553 554/* dst(idx) = src1(idx) & src2(idx) */ 555CVAPI(void) cvAnd( const CvArr* src1, const CvArr* src2, 556 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL)); 557 558/* dst(idx) = src(idx) & value */ 559CVAPI(void) cvAndS( const CvArr* src, CvScalar value, 560 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL)); 561 562/* dst(idx) = src1(idx) | src2(idx) */ 563CVAPI(void) cvOr( const CvArr* src1, const CvArr* src2, 564 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL)); 565 566/* dst(idx) = src(idx) | value */ 567CVAPI(void) cvOrS( const CvArr* src, CvScalar value, 568 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL)); 569 570/* dst(idx) = src1(idx) ^ src2(idx) */ 571CVAPI(void) cvXor( const CvArr* src1, const CvArr* src2, 572 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL)); 573 574/* dst(idx) = src(idx) ^ value */ 575CVAPI(void) cvXorS( const CvArr* src, CvScalar value, 576 CvArr* dst, const CvArr* mask CV_DEFAULT(NULL)); 577 578/* dst(idx) = ~src(idx) */ 579CVAPI(void) cvNot( const CvArr* src, CvArr* dst ); 580 581/* dst(idx) = lower(idx) <= src(idx) < upper(idx) */ 582CVAPI(void) cvInRange( const CvArr* src, const CvArr* lower, 583 const CvArr* upper, CvArr* dst ); 584 585/* dst(idx) = lower <= src(idx) < upper */ 586CVAPI(void) cvInRangeS( const CvArr* src, CvScalar lower, 587 CvScalar upper, CvArr* dst ); 588 589#define CV_CMP_EQ 0 590#define CV_CMP_GT 1 591#define CV_CMP_GE 2 592#define CV_CMP_LT 3 593#define CV_CMP_LE 4 594#define CV_CMP_NE 5 595 596/* The comparison operation support single-channel arrays only. 597 Destination image should be 8uC1 or 8sC1 */ 598 599/* dst(idx) = src1(idx) _cmp_op_ src2(idx) */ 600CVAPI(void) cvCmp( const CvArr* src1, const CvArr* src2, CvArr* dst, int cmp_op ); 601 602/* dst(idx) = src1(idx) _cmp_op_ value */ 603CVAPI(void) cvCmpS( const CvArr* src, double value, CvArr* dst, int cmp_op ); 604 605/* dst(idx) = min(src1(idx),src2(idx)) */ 606CVAPI(void) cvMin( const CvArr* src1, const CvArr* src2, CvArr* dst ); 607 608/* dst(idx) = max(src1(idx),src2(idx)) */ 609CVAPI(void) cvMax( const CvArr* src1, const CvArr* src2, CvArr* dst ); 610 611/* dst(idx) = min(src(idx),value) */ 612CVAPI(void) cvMinS( const CvArr* src, double value, CvArr* dst ); 613 614/* dst(idx) = max(src(idx),value) */ 615CVAPI(void) cvMaxS( const CvArr* src, double value, CvArr* dst ); 616 617/* dst(x,y,c) = abs(src1(x,y,c) - src2(x,y,c)) */ 618CVAPI(void) cvAbsDiff( const CvArr* src1, const CvArr* src2, CvArr* dst ); 619 620/* dst(x,y,c) = abs(src(x,y,c) - value(c)) */ 621CVAPI(void) cvAbsDiffS( const CvArr* src, CvArr* dst, CvScalar value ); 622#define cvAbs( src, dst ) cvAbsDiffS( (src), (dst), cvScalarAll(0)) 623 624/****************************************************************************************\ 625* Math operations * 626\****************************************************************************************/ 627 628/* Does cartesian->polar coordinates conversion. 629 Either of output components (magnitude or angle) is optional */ 630CVAPI(void) cvCartToPolar( const CvArr* x, const CvArr* y, 631 CvArr* magnitude, CvArr* angle CV_DEFAULT(NULL), 632 int angle_in_degrees CV_DEFAULT(0)); 633 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 */ 637CVAPI(void) cvPolarToCart( const CvArr* magnitude, const CvArr* angle, 638 CvArr* x, CvArr* y, 639 int angle_in_degrees CV_DEFAULT(0)); 640 641/* Does powering: dst(idx) = src(idx)^power */ 642CVAPI(void) cvPow( const CvArr* src, CvArr* dst, double power ); 643 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 */ 647CVAPI(void) cvExp( const CvArr* src, CvArr* dst ); 648 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 652*/ 653CVAPI(void) cvLog( const CvArr* src, CvArr* dst ); 654 655/* Fast arctangent calculation */ 656CVAPI(float) cvFastArctan( float y, float x ); 657 658/* Fast cubic root calculation */ 659CVAPI(float) cvCbrt( float value ); 660 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 667CVAPI(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 670 671#define CV_RAND_UNI 0 672#define CV_RAND_NORMAL 1 673CVAPI(void) cvRandArr( CvRNG* rng, CvArr* arr, int dist_type, 674 CvScalar param1, CvScalar param2 ); 675 676CVAPI(void) cvRandShuffle( CvArr* mat, CvRNG* rng, 677 double iter_factor CV_DEFAULT(1.)); 678 679#define CV_SORT_EVERY_ROW 0 680#define CV_SORT_EVERY_COLUMN 1 681#define CV_SORT_ASCENDING 0 682#define CV_SORT_DESCENDING 16 683 684CVAPI(void) cvSort( const CvArr* src, CvArr* dst CV_DEFAULT(NULL), 685 CvArr* idxmat CV_DEFAULT(NULL), 686 int flags CV_DEFAULT(0)); 687 688/* Finds real roots of a cubic equation */ 689CVAPI(int) cvSolveCubic( const CvMat* coeffs, CvMat* roots ); 690 691/* Finds all real and complex roots of a polynomial equation */ 692CVAPI(void) cvSolvePoly(const CvMat* coeffs, CvMat *roots, 693 int maxiter CV_DEFAULT(0), int fig CV_DEFAULT(0)); 694 695/****************************************************************************************\ 696* Matrix operations * 697\****************************************************************************************/ 698 699/* Calculates cross product of two 3d vectors */ 700CVAPI(void) cvCrossProduct( const CvArr* src1, const CvArr* src2, CvArr* dst ); 701 702/* Matrix transform: dst = A*B + C, C is optional */ 703#define cvMatMulAdd( src1, src2, src3, dst ) cvGEMM( (src1), (src2), 1., (src3), 1., (dst), 0 ) 704#define cvMatMul( src1, src2, dst ) cvMatMulAdd( (src1), (src2), NULL, (dst)) 705 706#define CV_GEMM_A_T 1 707#define CV_GEMM_B_T 2 708#define CV_GEMM_C_T 4 709/* Extended matrix transform: 710 dst = alpha*op(A)*op(B) + beta*op(C), where op(X) is X or X^T */ 711CVAPI(void) cvGEMM( const CvArr* src1, const CvArr* src2, double alpha, 712 const CvArr* src3, double beta, CvArr* dst, 713 int tABC CV_DEFAULT(0)); 714#define cvMatMulAddEx cvGEMM 715 716/* Transforms each element of source array and stores 717 resultant vectors in destination array */ 718CVAPI(void) cvTransform( const CvArr* src, CvArr* dst, 719 const CvMat* transmat, 720 const CvMat* shiftvec CV_DEFAULT(NULL)); 721#define cvMatMulAddS cvTransform 722 723/* Does perspective transform on every element of input array */ 724CVAPI(void) cvPerspectiveTransform( const CvArr* src, CvArr* dst, 725 const CvMat* mat ); 726 727/* Calculates (A-delta)*(A-delta)^T (order=0) or (A-delta)^T*(A-delta) (order=1) */ 728CVAPI(void) cvMulTransposed( const CvArr* src, CvArr* dst, int order, 729 const CvArr* delta CV_DEFAULT(NULL), 730 double scale CV_DEFAULT(1.) ); 731 732/* Tranposes matrix. Square matrices can be transposed in-place */ 733CVAPI(void) cvTranspose( const CvArr* src, CvArr* dst ); 734#define cvT cvTranspose 735 736/* Completes the symmetric matrix from the lower (LtoR=0) or from the upper (LtoR!=0) part */ 737CVAPI(void) cvCompleteSymm( CvMat* matrix, int LtoR CV_DEFAULT(0) ); 738 739/* Mirror array data around horizontal (flip=0), 740 vertical (flip=1) or both(flip=-1) axises: 741 cvFlip(src) flips images vertically and sequences horizontally (inplace) */ 742CVAPI(void) cvFlip( const CvArr* src, CvArr* dst CV_DEFAULT(NULL), 743 int flip_mode CV_DEFAULT(0)); 744#define cvMirror cvFlip 745 746 747#define CV_SVD_MODIFY_A 1 748#define CV_SVD_U_T 2 749#define CV_SVD_V_T 4 750 751/* Performs Singular Value Decomposition of a matrix */ 752CVAPI(void) cvSVD( CvArr* A, CvArr* W, CvArr* U CV_DEFAULT(NULL), 753 CvArr* V CV_DEFAULT(NULL), int flags CV_DEFAULT(0)); 754 755/* Performs Singular Value Back Substitution (solves A*X = B): 756 flags must be the same as in cvSVD */ 757CVAPI(void) cvSVBkSb( const CvArr* W, const CvArr* U, 758 const CvArr* V, const CvArr* B, 759 CvArr* X, int flags ); 760 761#define CV_LU 0 762#define CV_SVD 1 763#define CV_SVD_SYM 2 764#define CV_LSQ 8 765 766/* Inverts matrix */ 767CVAPI(double) cvInvert( const CvArr* src, CvArr* dst, 768 int method CV_DEFAULT(CV_LU)); 769#define cvInv cvInvert 770 771/* Solves linear system (src1)*(dst) = (src2) 772 (returns 0 if src1 is a singular and CV_LU method is used) */ 773CVAPI(int) cvSolve( const CvArr* src1, const CvArr* src2, CvArr* dst, 774 int method CV_DEFAULT(CV_LU)); 775 776/* Calculates determinant of input matrix */ 777CVAPI(double) cvDet( const CvArr* mat ); 778 779/* Calculates trace of the matrix (sum of elements on the main diagonal) */ 780CVAPI(CvScalar) cvTrace( const CvArr* mat ); 781 782/* Finds eigen values and vectors of a symmetric matrix */ 783CVAPI(void) cvEigenVV( CvArr* mat, CvArr* evects, 784 CvArr* evals, double eps CV_DEFAULT(0)); 785 786/* Makes an identity matrix (mat_ij = i == j) */ 787CVAPI(void) cvSetIdentity( CvArr* mat, CvScalar value CV_DEFAULT(cvRealScalar(1)) ); 788 789/* Fills matrix with given range of numbers */ 790CVAPI(CvArr*) cvRange( CvArr* mat, double start, double end ); 791 792/* Calculates covariation matrix for a set of vectors */ 793/* transpose([v1-avg, v2-avg,...]) * [v1-avg,v2-avg,...] */ 794#define CV_COVAR_SCRAMBLED 0 795 796/* [v1-avg, v2-avg,...] * transpose([v1-avg,v2-avg,...]) */ 797#define CV_COVAR_NORMAL 1 798 799/* do not calc average (i.e. mean vector) - use the input vector instead 800 (useful for calculating covariance matrix by parts) */ 801#define CV_COVAR_USE_AVG 2 802 803/* scale the covariance matrix coefficients by number of the vectors */ 804#define CV_COVAR_SCALE 4 805 806/* all the input vectors are stored in a single matrix, as its rows */ 807#define CV_COVAR_ROWS 8 808 809/* all the input vectors are stored in a single matrix, as its columns */ 810#define CV_COVAR_COLS 16 811 812CVAPI(void) cvCalcCovarMatrix( const CvArr** vects, int count, 813 CvArr* cov_mat, CvArr* avg, int flags ); 814 815#define CV_PCA_DATA_AS_ROW 0 816#define CV_PCA_DATA_AS_COL 1 817#define CV_PCA_USE_AVG 2 818CVAPI(void) cvCalcPCA( const CvArr* data, CvArr* mean, 819 CvArr* eigenvals, CvArr* eigenvects, int flags ); 820 821CVAPI(void) cvProjectPCA( const CvArr* data, const CvArr* mean, 822 const CvArr* eigenvects, CvArr* result ); 823 824CVAPI(void) cvBackProjectPCA( const CvArr* proj, const CvArr* mean, 825 const CvArr* eigenvects, CvArr* result ); 826 827/* Calculates Mahalanobis(weighted) distance */ 828CVAPI(double) cvMahalanobis( const CvArr* vec1, const CvArr* vec2, CvArr* mat ); 829#define cvMahalonobis cvMahalanobis 830 831/****************************************************************************************\ 832* Array Statistics * 833\****************************************************************************************/ 834 835/* Finds sum of array elements */ 836CVAPI(CvScalar) cvSum( const CvArr* arr ); 837 838/* Calculates number of non-zero pixels */ 839CVAPI(int) cvCountNonZero( const CvArr* arr ); 840 841/* Calculates mean value of array elements */ 842CVAPI(CvScalar) cvAvg( const CvArr* arr, const CvArr* mask CV_DEFAULT(NULL) ); 843 844/* Calculates mean and standard deviation of pixel values */ 845CVAPI(void) cvAvgSdv( const CvArr* arr, CvScalar* mean, CvScalar* std_dev, 846 const CvArr* mask CV_DEFAULT(NULL) ); 847 848/* Finds global minimum, maximum and their positions */ 849CVAPI(void) cvMinMaxLoc( const CvArr* arr, double* min_val, double* max_val, 850 CvPoint* min_loc CV_DEFAULT(NULL), 851 CvPoint* max_loc CV_DEFAULT(NULL), 852 const CvArr* mask CV_DEFAULT(NULL) ); 853 854/* types of array norm */ 855#define CV_C 1 856#define CV_L1 2 857#define CV_L2 4 858#define CV_NORM_MASK 7 859#define CV_RELATIVE 8 860#define CV_DIFF 16 861#define CV_MINMAX 32 862 863#define CV_DIFF_C (CV_DIFF | CV_C) 864#define CV_DIFF_L1 (CV_DIFF | CV_L1) 865#define CV_DIFF_L2 (CV_DIFF | CV_L2) 866#define CV_RELATIVE_C (CV_RELATIVE | CV_C) 867#define CV_RELATIVE_L1 (CV_RELATIVE | CV_L1) 868#define CV_RELATIVE_L2 (CV_RELATIVE | CV_L2) 869 870/* Finds norm, difference norm or relative difference norm for an array (or two arrays) */ 871CVAPI(double) cvNorm( const CvArr* arr1, const CvArr* arr2 CV_DEFAULT(NULL), 872 int norm_type CV_DEFAULT(CV_L2), 873 const CvArr* mask CV_DEFAULT(NULL) ); 874 875CVAPI(void) cvNormalize( const CvArr* src, CvArr* dst, 876 double a CV_DEFAULT(1.), double b CV_DEFAULT(0.), 877 int norm_type CV_DEFAULT(CV_L2), 878 const CvArr* mask CV_DEFAULT(NULL) ); 879 880 881#define CV_REDUCE_SUM 0 882#define CV_REDUCE_AVG 1 883#define CV_REDUCE_MAX 2 884#define CV_REDUCE_MIN 3 885 886CVAPI(void) cvReduce( const CvArr* src, CvArr* dst, int dim CV_DEFAULT(-1), 887 int op CV_DEFAULT(CV_REDUCE_SUM) ); 888 889/****************************************************************************************\ 890* Discrete Linear Transforms and Related Functions * 891\****************************************************************************************/ 892 893#define CV_DXT_FORWARD 0 894#define CV_DXT_INVERSE 1 895#define CV_DXT_SCALE 2 /* divide result by size of array */ 896#define CV_DXT_INV_SCALE (CV_DXT_INVERSE + CV_DXT_SCALE) 897#define CV_DXT_INVERSE_SCALE CV_DXT_INV_SCALE 898#define CV_DXT_ROWS 4 /* transform each row individually */ 899#define CV_DXT_MUL_CONJ 8 /* conjugate the second argument of cvMulSpectrums */ 900 901/* Discrete Fourier Transform: 902 complex->complex, 903 real->ccs (forward), 904 ccs->real (inverse) */ 905CVAPI(void) cvDFT( const CvArr* src, CvArr* dst, int flags, 906 int nonzero_rows CV_DEFAULT(0) ); 907#define cvFFT cvDFT 908 909/* Multiply results of DFTs: DFT(X)*DFT(Y) or DFT(X)*conj(DFT(Y)) */ 910CVAPI(void) cvMulSpectrums( const CvArr* src1, const CvArr* src2, 911 CvArr* dst, int flags ); 912 913/* Finds optimal DFT vector size >= size0 */ 914CVAPI(int) cvGetOptimalDFTSize( int size0 ); 915 916/* Discrete Cosine Transform */ 917CVAPI(void) cvDCT( const CvArr* src, CvArr* dst, int flags ); 918 919/****************************************************************************************\ 920* Dynamic data structures * 921\****************************************************************************************/ 922 923/* Calculates length of sequence slice (with support of negative indices). */ 924CVAPI(int) cvSliceLength( CvSlice slice, const CvSeq* seq ); 925 926 927/* Creates new memory storage. 928 block_size == 0 means that default, 929 somewhat optimal size, is used (currently, it is 64K) */ 930CVAPI(CvMemStorage*) cvCreateMemStorage( int block_size CV_DEFAULT(0)); 931 932 933/* Creates a memory storage that will borrow memory blocks from parent storage */ 934CVAPI(CvMemStorage*) cvCreateChildMemStorage( CvMemStorage* parent ); 935 936 937/* Releases memory storage. All the children of a parent must be released before 938 the parent. A child storage returns all the blocks to parent when it is released */ 939CVAPI(void) cvReleaseMemStorage( CvMemStorage** storage ); 940 941 942/* Clears memory storage. This is the only way(!!!) (besides cvRestoreMemStoragePos) 943 to reuse memory allocated for the storage - cvClearSeq,cvClearSet ... 944 do not free any memory. 945 A child storage returns all the blocks to the parent when it is cleared */ 946CVAPI(void) cvClearMemStorage( CvMemStorage* storage ); 947 948/* Remember a storage "free memory" position */ 949CVAPI(void) cvSaveMemStoragePos( const CvMemStorage* storage, CvMemStoragePos* pos ); 950 951/* Restore a storage "free memory" position */ 952CVAPI(void) cvRestoreMemStoragePos( CvMemStorage* storage, CvMemStoragePos* pos ); 953 954/* Allocates continuous buffer of the specified size in the storage */ 955CVAPI(void*) cvMemStorageAlloc( CvMemStorage* storage, size_t size ); 956 957/* Allocates string in memory storage */ 958CVAPI(CvString) cvMemStorageAllocString( CvMemStorage* storage, const char* ptr, 959 int len CV_DEFAULT(-1) ); 960 961/* Creates new empty sequence that will reside in the specified storage */ 962CVAPI(CvSeq*) cvCreateSeq( int seq_flags, int header_size, 963 int elem_size, CvMemStorage* storage ); 964 965/* Changes default size (granularity) of sequence blocks. 966 The default size is ~1Kbyte */ 967CVAPI(void) cvSetSeqBlockSize( CvSeq* seq, int delta_elems ); 968 969 970/* Adds new element to the end of sequence. Returns pointer to the element */ 971CVAPI(schar*) cvSeqPush( CvSeq* seq, void* element CV_DEFAULT(NULL)); 972 973 974/* Adds new element to the beginning of sequence. Returns pointer to it */ 975CVAPI(schar*) cvSeqPushFront( CvSeq* seq, void* element CV_DEFAULT(NULL)); 976 977 978/* Removes the last element from sequence and optionally saves it */ 979CVAPI(void) cvSeqPop( CvSeq* seq, void* element CV_DEFAULT(NULL)); 980 981 982/* Removes the first element from sequence and optioanally saves it */ 983CVAPI(void) cvSeqPopFront( CvSeq* seq, void* element CV_DEFAULT(NULL)); 984 985 986#define CV_FRONT 1 987#define CV_BACK 0 988/* Adds several new elements to the end of sequence */ 989CVAPI(void) cvSeqPushMulti( CvSeq* seq, void* elements, 990 int count, int in_front CV_DEFAULT(0) ); 991 992/* Removes several elements from the end of sequence and optionally saves them */ 993CVAPI(void) cvSeqPopMulti( CvSeq* seq, void* elements, 994 int count, int in_front CV_DEFAULT(0) ); 995 996/* Inserts a new element in the middle of sequence. 997 cvSeqInsert(seq,0,elem) == cvSeqPushFront(seq,elem) */ 998CVAPI(schar*) cvSeqInsert( CvSeq* seq, int before_index, 999 void* element CV_DEFAULT(NULL)); 1000 1001/* Removes specified sequence element */ 1002CVAPI(void) cvSeqRemove( CvSeq* seq, int index ); 1003 1004 1005/* Removes all the elements from the sequence. The freed memory 1006 can be reused later only by the same sequence unless cvClearMemStorage 1007 or cvRestoreMemStoragePos is called */ 1008CVAPI(void) cvClearSeq( CvSeq* seq ); 1009 1010 1011/* Retrieves pointer to specified sequence element. 1012 Negative indices are supported and mean counting from the end 1013 (e.g -1 means the last sequence element) */ 1014CVAPI(schar*) cvGetSeqElem( const CvSeq* seq, int index ); 1015 1016/* Calculates index of the specified sequence element. 1017 Returns -1 if element does not belong to the sequence */ 1018CVAPI(int) cvSeqElemIdx( const CvSeq* seq, const void* element, 1019 CvSeqBlock** block CV_DEFAULT(NULL) ); 1020 1021/* Initializes sequence writer. The new elements will be added to the end of sequence */ 1022CVAPI(void) cvStartAppendToSeq( CvSeq* seq, CvSeqWriter* writer ); 1023 1024 1025/* Combination of cvCreateSeq and cvStartAppendToSeq */ 1026CVAPI(void) cvStartWriteSeq( int seq_flags, int header_size, 1027 int elem_size, CvMemStorage* storage, 1028 CvSeqWriter* writer ); 1029 1030/* Closes sequence writer, updates sequence header and returns pointer 1031 to the resultant sequence 1032 (which may be useful if the sequence was created using cvStartWriteSeq)) 1033*/ 1034CVAPI(CvSeq*) cvEndWriteSeq( CvSeqWriter* writer ); 1035 1036 1037/* Updates sequence header. May be useful to get access to some of previously 1038 written elements via cvGetSeqElem or sequence reader */ 1039CVAPI(void) cvFlushSeqWriter( CvSeqWriter* writer ); 1040 1041 1042/* Initializes sequence reader. 1043 The sequence can be read in forward or backward direction */ 1044CVAPI(void) cvStartReadSeq( const CvSeq* seq, CvSeqReader* reader, 1045 int reverse CV_DEFAULT(0) ); 1046 1047 1048/* Returns current sequence reader position (currently observed sequence element) */ 1049CVAPI(int) cvGetSeqReaderPos( CvSeqReader* reader ); 1050 1051 1052/* Changes sequence reader position. It may seek to an absolute or 1053 to relative to the current position */ 1054CVAPI(void) cvSetSeqReaderPos( CvSeqReader* reader, int index, 1055 int is_relative CV_DEFAULT(0)); 1056 1057/* Copies sequence content to a continuous piece of memory */ 1058CVAPI(void*) cvCvtSeqToArray( const CvSeq* seq, void* elements, 1059 CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ) ); 1060 1061/* Creates sequence header for array. 1062 After that all the operations on sequences that do not alter the content 1063 can be applied to the resultant sequence */ 1064CVAPI(CvSeq*) cvMakeSeqHeaderForArray( int seq_type, int header_size, 1065 int elem_size, void* elements, int total, 1066 CvSeq* seq, CvSeqBlock* block ); 1067 1068/* Extracts sequence slice (with or without copying sequence elements) */ 1069CVAPI(CvSeq*) cvSeqSlice( const CvSeq* seq, CvSlice slice, 1070 CvMemStorage* storage CV_DEFAULT(NULL), 1071 int copy_data CV_DEFAULT(0)); 1072 1073CV_INLINE CvSeq* cvCloneSeq( const CvSeq* seq, CvMemStorage* storage CV_DEFAULT(NULL)) 1074{ 1075 return cvSeqSlice( seq, CV_WHOLE_SEQ, storage, 1 ); 1076} 1077 1078/* Removes sequence slice */ 1079CVAPI(void) cvSeqRemoveSlice( CvSeq* seq, CvSlice slice ); 1080 1081/* Inserts a sequence or array into another sequence */ 1082CVAPI(void) cvSeqInsertSlice( CvSeq* seq, int before_index, const CvArr* from_arr ); 1083 1084/* a < b ? -1 : a > b ? 1 : 0 */ 1085typedef int (CV_CDECL* CvCmpFunc)(const void* a, const void* b, void* userdata ); 1086 1087/* Sorts sequence in-place given element comparison function */ 1088CVAPI(void) cvSeqSort( CvSeq* seq, CvCmpFunc func, void* userdata CV_DEFAULT(NULL) ); 1089 1090/* Finds element in a [sorted] sequence */ 1091CVAPI(schar*) cvSeqSearch( CvSeq* seq, const void* elem, CvCmpFunc func, 1092 int is_sorted, int* elem_idx, 1093 void* userdata CV_DEFAULT(NULL) ); 1094 1095/* Reverses order of sequence elements in-place */ 1096CVAPI(void) cvSeqInvert( CvSeq* seq ); 1097 1098/* Splits sequence into one or more equivalence classes using the specified criteria */ 1099CVAPI(int) cvSeqPartition( const CvSeq* seq, CvMemStorage* storage, 1100 CvSeq** labels, CvCmpFunc is_equal, void* userdata ); 1101 1102/************ Internal sequence functions ************/ 1103CVAPI(void) cvChangeSeqBlock( void* reader, int direction ); 1104CVAPI(void) cvCreateSeqBlock( CvSeqWriter* writer ); 1105 1106 1107/* Creates a new set */ 1108CVAPI(CvSet*) cvCreateSet( int set_flags, int header_size, 1109 int elem_size, CvMemStorage* storage ); 1110 1111/* Adds new element to the set and returns pointer to it */ 1112CVAPI(int) cvSetAdd( CvSet* set_header, CvSetElem* elem CV_DEFAULT(NULL), 1113 CvSetElem** inserted_elem CV_DEFAULT(NULL) ); 1114 1115/* Fast variant of cvSetAdd */ 1116CV_INLINE CvSetElem* cvSetNew( CvSet* set_header ) 1117{ 1118 CvSetElem* elem = set_header->free_elems; 1119 if( elem ) 1120 { 1121 set_header->free_elems = elem->next_free; 1122 elem->flags = elem->flags & CV_SET_ELEM_IDX_MASK; 1123 set_header->active_count++; 1124 } 1125 else 1126 cvSetAdd( set_header, NULL, (CvSetElem**)&elem ); 1127 return elem; 1128} 1129 1130/* Removes set element given its pointer */ 1131CV_INLINE void cvSetRemoveByPtr( CvSet* set_header, void* elem ) 1132{ 1133 CvSetElem* _elem = (CvSetElem*)elem; 1134 assert( _elem->flags >= 0 /*&& (elem->flags & CV_SET_ELEM_IDX_MASK) < set_header->total*/ ); 1135 _elem->next_free = set_header->free_elems; 1136 _elem->flags = (_elem->flags & CV_SET_ELEM_IDX_MASK) | CV_SET_ELEM_FREE_FLAG; 1137 set_header->free_elems = _elem; 1138 set_header->active_count--; 1139} 1140 1141/* Removes element from the set by its index */ 1142CVAPI(void) cvSetRemove( CvSet* set_header, int index ); 1143 1144/* Returns a set element by index. If the element doesn't belong to the set, 1145 NULL is returned */ 1146CV_INLINE CvSetElem* cvGetSetElem( const CvSet* set_header, int index ) 1147{ 1148 CvSetElem* elem = (CvSetElem*)cvGetSeqElem( (CvSeq*)set_header, index ); 1149 return elem && CV_IS_SET_ELEM( elem ) ? elem : 0; 1150} 1151 1152/* Removes all the elements from the set */ 1153CVAPI(void) cvClearSet( CvSet* set_header ); 1154 1155/* Creates new graph */ 1156CVAPI(CvGraph*) cvCreateGraph( int graph_flags, int header_size, 1157 int vtx_size, int edge_size, 1158 CvMemStorage* storage ); 1159 1160/* Adds new vertex to the graph */ 1161CVAPI(int) cvGraphAddVtx( CvGraph* graph, const CvGraphVtx* vtx CV_DEFAULT(NULL), 1162 CvGraphVtx** inserted_vtx CV_DEFAULT(NULL) ); 1163 1164 1165/* Removes vertex from the graph together with all incident edges */ 1166CVAPI(int) cvGraphRemoveVtx( CvGraph* graph, int index ); 1167CVAPI(int) cvGraphRemoveVtxByPtr( CvGraph* graph, CvGraphVtx* vtx ); 1168 1169 1170/* Link two vertices specifed by indices or pointers if they 1171 are not connected or return pointer to already existing edge 1172 connecting the vertices. 1173 Functions return 1 if a new edge was created, 0 otherwise */ 1174CVAPI(int) cvGraphAddEdge( CvGraph* graph, 1175 int start_idx, int end_idx, 1176 const CvGraphEdge* edge CV_DEFAULT(NULL), 1177 CvGraphEdge** inserted_edge CV_DEFAULT(NULL) ); 1178 1179CVAPI(int) cvGraphAddEdgeByPtr( CvGraph* graph, 1180 CvGraphVtx* start_vtx, CvGraphVtx* end_vtx, 1181 const CvGraphEdge* edge CV_DEFAULT(NULL), 1182 CvGraphEdge** inserted_edge CV_DEFAULT(NULL) ); 1183 1184/* Remove edge connecting two vertices */ 1185CVAPI(void) cvGraphRemoveEdge( CvGraph* graph, int start_idx, int end_idx ); 1186CVAPI(void) cvGraphRemoveEdgeByPtr( CvGraph* graph, CvGraphVtx* start_vtx, 1187 CvGraphVtx* end_vtx ); 1188 1189/* Find edge connecting two vertices */ 1190CVAPI(CvGraphEdge*) cvFindGraphEdge( const CvGraph* graph, int start_idx, int end_idx ); 1191CVAPI(CvGraphEdge*) cvFindGraphEdgeByPtr( const CvGraph* graph, 1192 const CvGraphVtx* start_vtx, 1193 const CvGraphVtx* end_vtx ); 1194#define cvGraphFindEdge cvFindGraphEdge 1195#define cvGraphFindEdgeByPtr cvFindGraphEdgeByPtr 1196 1197/* Remove all vertices and edges from the graph */ 1198CVAPI(void) cvClearGraph( CvGraph* graph ); 1199 1200 1201/* Count number of edges incident to the vertex */ 1202CVAPI(int) cvGraphVtxDegree( const CvGraph* graph, int vtx_idx ); 1203CVAPI(int) cvGraphVtxDegreeByPtr( const CvGraph* graph, const CvGraphVtx* vtx ); 1204 1205 1206/* Retrieves graph vertex by given index */ 1207#define cvGetGraphVtx( graph, idx ) (CvGraphVtx*)cvGetSetElem((CvSet*)(graph), (idx)) 1208 1209/* Retrieves index of a graph vertex given its pointer */ 1210#define cvGraphVtxIdx( graph, vtx ) ((vtx)->flags & CV_SET_ELEM_IDX_MASK) 1211 1212/* Retrieves index of a graph edge given its pointer */ 1213#define cvGraphEdgeIdx( graph, edge ) ((edge)->flags & CV_SET_ELEM_IDX_MASK) 1214 1215#define cvGraphGetVtxCount( graph ) ((graph)->active_count) 1216#define cvGraphGetEdgeCount( graph ) ((graph)->edges->active_count) 1217 1218#define CV_GRAPH_VERTEX 1 1219#define CV_GRAPH_TREE_EDGE 2 1220#define CV_GRAPH_BACK_EDGE 4 1221#define CV_GRAPH_FORWARD_EDGE 8 1222#define CV_GRAPH_CROSS_EDGE 16 1223#define CV_GRAPH_ANY_EDGE 30 1224#define CV_GRAPH_NEW_TREE 32 1225#define CV_GRAPH_BACKTRACKING 64 1226#define CV_GRAPH_OVER -1 1227 1228#define CV_GRAPH_ALL_ITEMS -1 1229 1230/* flags for graph vertices and edges */ 1231#define CV_GRAPH_ITEM_VISITED_FLAG (1 << 30) 1232#define CV_IS_GRAPH_VERTEX_VISITED(vtx) \ 1233 (((CvGraphVtx*)(vtx))->flags & CV_GRAPH_ITEM_VISITED_FLAG) 1234#define CV_IS_GRAPH_EDGE_VISITED(edge) \ 1235 (((CvGraphEdge*)(edge))->flags & CV_GRAPH_ITEM_VISITED_FLAG) 1236#define CV_GRAPH_SEARCH_TREE_NODE_FLAG (1 << 29) 1237#define CV_GRAPH_FORWARD_EDGE_FLAG (1 << 28) 1238 1239typedef struct CvGraphScanner 1240{ 1241 CvGraphVtx* vtx; /* current graph vertex (or current edge origin) */ 1242 CvGraphVtx* dst; /* current graph edge destination vertex */ 1243 CvGraphEdge* edge; /* current edge */ 1244 1245 CvGraph* graph; /* the graph */ 1246 CvSeq* stack; /* the graph vertex stack */ 1247 int index; /* the lower bound of certainly visited vertices */ 1248 int mask; /* event mask */ 1249} 1250CvGraphScanner; 1251 1252/* Creates new graph scanner. */ 1253CVAPI(CvGraphScanner*) cvCreateGraphScanner( CvGraph* graph, 1254 CvGraphVtx* vtx CV_DEFAULT(NULL), 1255 int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS)); 1256 1257/* Releases graph scanner. */ 1258CVAPI(void) cvReleaseGraphScanner( CvGraphScanner** scanner ); 1259 1260/* Get next graph element */ 1261CVAPI(int) cvNextGraphItem( CvGraphScanner* scanner ); 1262 1263/* Creates a copy of graph */ 1264CVAPI(CvGraph*) cvCloneGraph( const CvGraph* graph, CvMemStorage* storage ); 1265 1266/****************************************************************************************\ 1267* Drawing * 1268\****************************************************************************************/ 1269 1270/****************************************************************************************\ 1271* Drawing functions work with images/matrices of arbitrary type. * 1272* For color images the channel order is BGR[A] * 1273* Antialiasing is supported only for 8-bit image now. * 1274* All the functions include parameter color that means rgb value (that may be * 1275* constructed with CV_RGB macro) for color images and brightness * 1276* for grayscale images. * 1277* If a drawn figure is partially or completely outside of the image, it is clipped.* 1278\****************************************************************************************/ 1279 1280#define CV_RGB( r, g, b ) cvScalar( (b), (g), (r), 0 ) 1281#define CV_FILLED -1 1282 1283#define CV_AA 16 1284 1285/* Draws 4-connected, 8-connected or antialiased line segment connecting two points */ 1286CVAPI(void) cvLine( CvArr* img, CvPoint pt1, CvPoint pt2, 1287 CvScalar color, int thickness CV_DEFAULT(1), 1288 int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) ); 1289 1290/* Draws a rectangle given two opposite corners of the rectangle (pt1 & pt2), 1291 if thickness<0 (e.g. thickness == CV_FILLED), the filled box is drawn */ 1292CVAPI(void) cvRectangle( CvArr* img, CvPoint pt1, CvPoint pt2, 1293 CvScalar color, int thickness CV_DEFAULT(1), 1294 int line_type CV_DEFAULT(8), 1295 int shift CV_DEFAULT(0)); 1296 1297/* Draws a circle with specified center and radius. 1298 Thickness works in the same way as with cvRectangle */ 1299CVAPI(void) cvCircle( CvArr* img, CvPoint center, int radius, 1300 CvScalar color, int thickness CV_DEFAULT(1), 1301 int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0)); 1302 1303/* Draws ellipse outline, filled ellipse, elliptic arc or filled elliptic sector, 1304 depending on <thickness>, <start_angle> and <end_angle> parameters. The resultant figure 1305 is rotated by <angle>. All the angles are in degrees */ 1306CVAPI(void) cvEllipse( CvArr* img, CvPoint center, CvSize axes, 1307 double angle, double start_angle, double end_angle, 1308 CvScalar color, int thickness CV_DEFAULT(1), 1309 int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0)); 1310 1311CV_INLINE void cvEllipseBox( CvArr* img, CvBox2D box, CvScalar color, 1312 int thickness CV_DEFAULT(1), 1313 int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) ) 1314{ 1315 CvSize axes; 1316 axes.width = cvRound(box.size.height*0.5); 1317 axes.height = cvRound(box.size.width*0.5); 1318 1319 cvEllipse( img, cvPointFrom32f( box.center ), axes, box.angle, 1320 0, 360, color, thickness, line_type, shift ); 1321} 1322 1323/* Fills convex or monotonous polygon. */ 1324CVAPI(void) cvFillConvexPoly( CvArr* img, CvPoint* pts, int npts, CvScalar color, 1325 int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0)); 1326 1327/* Fills an area bounded by one or more arbitrary polygons */ 1328CVAPI(void) cvFillPoly( CvArr* img, CvPoint** pts, int* npts, int contours, CvScalar color, 1329 int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) ); 1330 1331/* Draws one or more polygonal curves */ 1332CVAPI(void) cvPolyLine( CvArr* img, CvPoint** pts, int* npts, int contours, 1333 int is_closed, CvScalar color, int thickness CV_DEFAULT(1), 1334 int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) ); 1335 1336#define cvDrawRect cvRectangle 1337#define cvDrawLine cvLine 1338#define cvDrawCircle cvCircle 1339#define cvDrawEllipse cvEllipse 1340#define cvDrawPolyLine cvPolyLine 1341 1342/* Clips the line segment connecting *pt1 and *pt2 1343 by the rectangular window 1344 (0<=x<img_size.width, 0<=y<img_size.height). */ 1345CVAPI(int) cvClipLine( CvSize img_size, CvPoint* pt1, CvPoint* pt2 ); 1346 1347/* Initializes line iterator. Initially, line_iterator->ptr will point 1348 to pt1 (or pt2, see left_to_right description) location in the image. 1349 Returns the number of pixels on the line between the ending points. */ 1350CVAPI(int) cvInitLineIterator( const CvArr* image, CvPoint pt1, CvPoint pt2, 1351 CvLineIterator* line_iterator, 1352 int connectivity CV_DEFAULT(8), 1353 int left_to_right CV_DEFAULT(0)); 1354 1355/* Moves iterator to the next line point */ 1356#define CV_NEXT_LINE_POINT( line_iterator ) \ 1357{ \ 1358 int _line_iterator_mask = (line_iterator).err < 0 ? -1 : 0; \ 1359 (line_iterator).err += (line_iterator).minus_delta + \ 1360 ((line_iterator).plus_delta & _line_iterator_mask); \ 1361 (line_iterator).ptr += (line_iterator).minus_step + \ 1362 ((line_iterator).plus_step & _line_iterator_mask); \ 1363} 1364 1365 1366/* basic font types */ 1367#define CV_FONT_HERSHEY_SIMPLEX 0 1368#define CV_FONT_HERSHEY_PLAIN 1 1369#define CV_FONT_HERSHEY_DUPLEX 2 1370#define CV_FONT_HERSHEY_COMPLEX 3 1371#define CV_FONT_HERSHEY_TRIPLEX 4 1372#define CV_FONT_HERSHEY_COMPLEX_SMALL 5 1373#define CV_FONT_HERSHEY_SCRIPT_SIMPLEX 6 1374#define CV_FONT_HERSHEY_SCRIPT_COMPLEX 7 1375 1376/* font flags */ 1377#define CV_FONT_ITALIC 16 1378 1379#define CV_FONT_VECTOR0 CV_FONT_HERSHEY_SIMPLEX 1380 1381/* Font structure */ 1382typedef struct CvFont 1383{ 1384 int font_face; /* =CV_FONT_* */ 1385 const int* ascii; /* font data and metrics */ 1386 const int* greek; 1387 const int* cyrillic; 1388 float hscale, vscale; 1389 float shear; /* slope coefficient: 0 - normal, >0 - italic */ 1390 int thickness; /* letters thickness */ 1391 float dx; /* horizontal interval between letters */ 1392 int line_type; 1393} 1394CvFont; 1395 1396/* Initializes font structure used further in cvPutText */ 1397CVAPI(void) cvInitFont( CvFont* font, int font_face, 1398 double hscale, double vscale, 1399 double shear CV_DEFAULT(0), 1400 int thickness CV_DEFAULT(1), 1401 int line_type CV_DEFAULT(8)); 1402 1403CV_INLINE CvFont cvFont( double scale, int thickness CV_DEFAULT(1) ) 1404{ 1405 CvFont font; 1406 cvInitFont( &font, CV_FONT_HERSHEY_PLAIN, scale, scale, 0, thickness, CV_AA ); 1407 return font; 1408} 1409 1410/* Renders text stroke with specified font and color at specified location. 1411 CvFont should be initialized with cvInitFont */ 1412CVAPI(void) cvPutText( CvArr* img, const char* text, CvPoint org, 1413 const CvFont* font, CvScalar color ); 1414 1415/* Calculates bounding box of text stroke (useful for alignment) */ 1416CVAPI(void) cvGetTextSize( const char* text_string, const CvFont* font, 1417 CvSize* text_size, int* baseline ); 1418 1419/* Unpacks color value, if arrtype is CV_8UC?, <color> is treated as 1420 packed color value, otherwise the first channels (depending on arrtype) 1421 of destination scalar are set to the same value = <color> */ 1422CVAPI(CvScalar) cvColorToScalar( double packed_color, int arrtype ); 1423 1424/* Returns the polygon points which make up the given ellipse. The ellipse is define by 1425 the box of size 'axes' rotated 'angle' around the 'center'. A partial sweep 1426 of the ellipse arc can be done by spcifying arc_start and arc_end to be something 1427 other than 0 and 360, respectively. The input array 'pts' must be large enough to 1428 hold the result. The total number of points stored into 'pts' is returned by this 1429 function. */ 1430CVAPI(int) cvEllipse2Poly( CvPoint center, CvSize axes, 1431 int angle, int arc_start, int arc_end, CvPoint * pts, int delta ); 1432 1433/* Draws contour outlines or filled interiors on the image */ 1434CVAPI(void) cvDrawContours( CvArr *img, CvSeq* contour, 1435 CvScalar external_color, CvScalar hole_color, 1436 int max_level, int thickness CV_DEFAULT(1), 1437 int line_type CV_DEFAULT(8), 1438 CvPoint offset CV_DEFAULT(cvPoint(0,0))); 1439 1440/* Does look-up transformation. Elements of the source array 1441 (that should be 8uC1 or 8sC1) are used as indexes in lutarr 256-element table */ 1442CVAPI(void) cvLUT( const CvArr* src, CvArr* dst, const CvArr* lut ); 1443 1444 1445/******************* Iteration through the sequence tree *****************/ 1446typedef struct CvTreeNodeIterator 1447{ 1448 const void* node; 1449 int level; 1450 int max_level; 1451} 1452CvTreeNodeIterator; 1453 1454CVAPI(void) cvInitTreeNodeIterator( CvTreeNodeIterator* tree_iterator, 1455 const void* first, int max_level ); 1456CVAPI(void*) cvNextTreeNode( CvTreeNodeIterator* tree_iterator ); 1457CVAPI(void*) cvPrevTreeNode( CvTreeNodeIterator* tree_iterator ); 1458 1459/* Inserts sequence into tree with specified "parent" sequence. 1460 If parent is equal to frame (e.g. the most external contour), 1461 then added contour will have null pointer to parent. */ 1462CVAPI(void) cvInsertNodeIntoTree( void* node, void* parent, void* frame ); 1463 1464/* Removes contour from tree (together with the contour children). */ 1465CVAPI(void) cvRemoveNodeFromTree( void* node, void* frame ); 1466 1467/* Gathers pointers to all the sequences, 1468 accessible from the <first>, to the single sequence */ 1469CVAPI(CvSeq*) cvTreeToNodeSeq( const void* first, int header_size, 1470 CvMemStorage* storage ); 1471 1472/* The function implements the K-means algorithm for clustering an array of sample 1473 vectors in a specified number of classes */ 1474CVAPI(void) cvKMeans2( const CvArr* samples, int cluster_count, 1475 CvArr* labels, CvTermCriteria termcrit ); 1476 1477/****************************************************************************************\ 1478* System functions * 1479\****************************************************************************************/ 1480 1481/* Add the function pointers table with associated information to the IPP primitives list */ 1482CVAPI(int) cvRegisterModule( const CvModuleInfo* module_info ); 1483 1484/* Loads optimized functions from IPP, MKL etc. or switches back to pure C code */ 1485CVAPI(int) cvUseOptimized( int on_off ); 1486 1487/* Retrieves information about the registered modules and loaded optimized plugins */ 1488CVAPI(void) cvGetModuleInfo( const char* module_name, 1489 const char** version, 1490 const char** loaded_addon_plugins ); 1491 1492/* Get current OpenCV error status */ 1493CVAPI(int) cvGetErrStatus( void ); 1494 1495/* Sets error status silently */ 1496CVAPI(void) cvSetErrStatus( int status ); 1497 1498#define CV_ErrModeLeaf 0 /* Print error and exit program */ 1499#define CV_ErrModeParent 1 /* Print error and continue */ 1500#define CV_ErrModeSilent 2 /* Don't print and continue */ 1501 1502/* Retrives current error processing mode */ 1503CVAPI(int) cvGetErrMode( void ); 1504 1505/* Sets error processing mode, returns previously used mode */ 1506CVAPI(int) cvSetErrMode( int mode ); 1507 1508/* Sets error status and performs some additonal actions (displaying message box, 1509 writing message to stderr, terminating application etc.) 1510 depending on the current error mode */ 1511CVAPI(void) cvError( int status, const char* func_name, 1512 const char* err_msg, const char* file_name, int line ); 1513 1514/* Retrieves textual description of the error given its code */ 1515CVAPI(const char*) cvErrorStr( int status ); 1516 1517/* Retrieves detailed information about the last error occured */ 1518CVAPI(int) cvGetErrInfo( const char** errcode_desc, const char** description, 1519 const char** filename, int* line ); 1520 1521/* Maps IPP error codes to the counterparts from OpenCV */ 1522CVAPI(int) cvErrorFromIppStatus( int ipp_status ); 1523 1524typedef int (CV_CDECL *CvErrorCallback)( int status, const char* func_name, 1525 const char* err_msg, const char* file_name, int line, void* userdata ); 1526 1527/* Assigns a new error-handling function */ 1528CVAPI(CvErrorCallback) cvRedirectError( CvErrorCallback error_handler, 1529 void* userdata CV_DEFAULT(NULL), 1530 void** prev_userdata CV_DEFAULT(NULL) ); 1531 1532/* 1533 Output to: 1534 cvNulDevReport - nothing 1535 cvStdErrReport - console(fprintf(stderr,...)) 1536 cvGuiBoxReport - MessageBox(WIN32) 1537*/ 1538CVAPI(int) cvNulDevReport( int status, const char* func_name, const char* err_msg, 1539 const char* file_name, int line, void* userdata ); 1540 1541CVAPI(int) cvStdErrReport( int status, const char* func_name, const char* err_msg, 1542 const char* file_name, int line, void* userdata ); 1543 1544CVAPI(int) cvGuiBoxReport( int status, const char* func_name, const char* err_msg, 1545 const char* file_name, int line, void* userdata ); 1546 1547typedef void* (CV_CDECL *CvAllocFunc)(size_t size, void* userdata); 1548typedef int (CV_CDECL *CvFreeFunc)(void* pptr, void* userdata); 1549 1550/* Set user-defined memory managment functions (substitutors for malloc and free) that 1551 will be called by cvAlloc, cvFree and higher-level functions (e.g. cvCreateImage) */ 1552CVAPI(void) cvSetMemoryManager( CvAllocFunc alloc_func CV_DEFAULT(NULL), 1553 CvFreeFunc free_func CV_DEFAULT(NULL), 1554 void* userdata CV_DEFAULT(NULL)); 1555 1556 1557typedef IplImage* (CV_STDCALL* Cv_iplCreateImageHeader) 1558 (int,int,int,char*,char*,int,int,int,int,int, 1559 IplROI*,IplImage*,void*,IplTileInfo*); 1560typedef void (CV_STDCALL* Cv_iplAllocateImageData)(IplImage*,int,int); 1561typedef void (CV_STDCALL* Cv_iplDeallocate)(IplImage*,int); 1562typedef IplROI* (CV_STDCALL* Cv_iplCreateROI)(int,int,int,int,int); 1563typedef IplImage* (CV_STDCALL* Cv_iplCloneImage)(const IplImage*); 1564 1565/* Makes OpenCV use IPL functions for IplImage allocation/deallocation */ 1566CVAPI(void) cvSetIPLAllocators( Cv_iplCreateImageHeader create_header, 1567 Cv_iplAllocateImageData allocate_data, 1568 Cv_iplDeallocate deallocate, 1569 Cv_iplCreateROI create_roi, 1570 Cv_iplCloneImage clone_image ); 1571 1572#define CV_TURN_ON_IPL_COMPATIBILITY() \ 1573 cvSetIPLAllocators( iplCreateImageHeader, iplAllocateImage, \ 1574 iplDeallocate, iplCreateROI, iplCloneImage ) 1575 1576/****************************************************************************************\ 1577* Data Persistence * 1578\****************************************************************************************/ 1579 1580/********************************** High-level functions ********************************/ 1581 1582/* opens existing or creates new file storage */ 1583CVAPI(CvFileStorage*) cvOpenFileStorage( const char* filename, 1584 CvMemStorage* memstorage, 1585 int flags ); 1586 1587/* closes file storage and deallocates buffers */ 1588CVAPI(void) cvReleaseFileStorage( CvFileStorage** fs ); 1589 1590/* returns attribute value or 0 (NULL) if there is no such attribute */ 1591CVAPI(const char*) cvAttrValue( const CvAttrList* attr, const char* attr_name ); 1592 1593/* starts writing compound structure (map or sequence) */ 1594CVAPI(void) cvStartWriteStruct( CvFileStorage* fs, const char* name, 1595 int struct_flags, const char* type_name CV_DEFAULT(NULL), 1596 CvAttrList attributes CV_DEFAULT(cvAttrList())); 1597 1598/* finishes writing compound structure */ 1599CVAPI(void) cvEndWriteStruct( CvFileStorage* fs ); 1600 1601/* writes an integer */ 1602CVAPI(void) cvWriteInt( CvFileStorage* fs, const char* name, int value ); 1603 1604/* writes a floating-point number */ 1605CVAPI(void) cvWriteReal( CvFileStorage* fs, const char* name, double value ); 1606 1607/* writes a string */ 1608CVAPI(void) cvWriteString( CvFileStorage* fs, const char* name, 1609 const char* str, int quote CV_DEFAULT(0) ); 1610 1611/* writes a comment */ 1612CVAPI(void) cvWriteComment( CvFileStorage* fs, const char* comment, 1613 int eol_comment ); 1614 1615/* writes instance of a standard type (matrix, image, sequence, graph etc.) 1616 or user-defined type */ 1617CVAPI(void) cvWrite( CvFileStorage* fs, const char* name, const void* ptr, 1618 CvAttrList attributes CV_DEFAULT(cvAttrList())); 1619 1620/* starts the next stream */ 1621CVAPI(void) cvStartNextStream( CvFileStorage* fs ); 1622 1623/* helper function: writes multiple integer or floating-point numbers */ 1624CVAPI(void) cvWriteRawData( CvFileStorage* fs, const void* src, 1625 int len, const char* dt ); 1626 1627/* returns the hash entry corresponding to the specified literal key string or 0 1628 if there is no such a key in the storage */ 1629CVAPI(CvStringHashNode*) cvGetHashedKey( CvFileStorage* fs, const char* name, 1630 int len CV_DEFAULT(-1), 1631 int create_missing CV_DEFAULT(0)); 1632 1633/* returns file node with the specified key within the specified map 1634 (collection of named nodes) */ 1635CVAPI(CvFileNode*) cvGetRootFileNode( const CvFileStorage* fs, 1636 int stream_index CV_DEFAULT(0) ); 1637 1638/* returns file node with the specified key within the specified map 1639 (collection of named nodes) */ 1640CVAPI(CvFileNode*) cvGetFileNode( CvFileStorage* fs, CvFileNode* map, 1641 const CvStringHashNode* key, 1642 int create_missing CV_DEFAULT(0) ); 1643 1644/* this is a slower version of cvGetFileNode that takes the key as a literal string */ 1645CVAPI(CvFileNode*) cvGetFileNodeByName( const CvFileStorage* fs, 1646 const CvFileNode* map, 1647 const char* name ); 1648 1649CV_INLINE int cvReadInt( const CvFileNode* node, int default_value CV_DEFAULT(0) ) 1650{ 1651 return !node ? default_value : 1652 CV_NODE_IS_INT(node->tag) ? node->data.i : 1653 CV_NODE_IS_REAL(node->tag) ? cvRound(node->data.f) : 0x7fffffff; 1654} 1655 1656 1657CV_INLINE int cvReadIntByName( const CvFileStorage* fs, const CvFileNode* map, 1658 const char* name, int default_value CV_DEFAULT(0) ) 1659{ 1660 return cvReadInt( cvGetFileNodeByName( fs, map, name ), default_value ); 1661} 1662 1663 1664CV_INLINE double cvReadReal( const CvFileNode* node, double default_value CV_DEFAULT(0.) ) 1665{ 1666 return !node ? default_value : 1667 CV_NODE_IS_INT(node->tag) ? (double)node->data.i : 1668 CV_NODE_IS_REAL(node->tag) ? node->data.f : 1e300; 1669} 1670 1671 1672CV_INLINE double cvReadRealByName( const CvFileStorage* fs, const CvFileNode* map, 1673 const char* name, double default_value CV_DEFAULT(0.) ) 1674{ 1675 return cvReadReal( cvGetFileNodeByName( fs, map, name ), default_value ); 1676} 1677 1678 1679CV_INLINE const char* cvReadString( const CvFileNode* node, 1680 const char* default_value CV_DEFAULT(NULL) ) 1681{ 1682 return !node ? default_value : CV_NODE_IS_STRING(node->tag) ? node->data.str.ptr : 0; 1683} 1684 1685 1686CV_INLINE const char* cvReadStringByName( const CvFileStorage* fs, const CvFileNode* map, 1687 const char* name, const char* default_value CV_DEFAULT(NULL) ) 1688{ 1689 return cvReadString( cvGetFileNodeByName( fs, map, name ), default_value ); 1690} 1691 1692 1693/* decodes standard or user-defined object and returns it */ 1694CVAPI(void*) cvRead( CvFileStorage* fs, CvFileNode* node, 1695 CvAttrList* attributes CV_DEFAULT(NULL)); 1696 1697/* decodes standard or user-defined object and returns it */ 1698CV_INLINE void* cvReadByName( CvFileStorage* fs, const CvFileNode* map, 1699 const char* name, CvAttrList* attributes CV_DEFAULT(NULL) ) 1700{ 1701 return cvRead( fs, cvGetFileNodeByName( fs, map, name ), attributes ); 1702} 1703 1704 1705/* starts reading data from sequence or scalar numeric node */ 1706CVAPI(void) cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src, 1707 CvSeqReader* reader ); 1708 1709/* reads multiple numbers and stores them to array */ 1710CVAPI(void) cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader, 1711 int count, void* dst, const char* dt ); 1712 1713/* combination of two previous functions for easier reading of whole sequences */ 1714CVAPI(void) cvReadRawData( const CvFileStorage* fs, const CvFileNode* src, 1715 void* dst, const char* dt ); 1716 1717/* writes a copy of file node to file storage */ 1718CVAPI(void) cvWriteFileNode( CvFileStorage* fs, const char* new_node_name, 1719 const CvFileNode* node, int embed ); 1720 1721/* returns name of file node */ 1722CVAPI(const char*) cvGetFileNodeName( const CvFileNode* node ); 1723 1724/*********************************** Adding own types ***********************************/ 1725 1726CVAPI(void) cvRegisterType( const CvTypeInfo* info ); 1727CVAPI(void) cvUnregisterType( const char* type_name ); 1728CVAPI(CvTypeInfo*) cvFirstType(void); 1729CVAPI(CvTypeInfo*) cvFindType( const char* type_name ); 1730CVAPI(CvTypeInfo*) cvTypeOf( const void* struct_ptr ); 1731 1732/* universal functions */ 1733CVAPI(void) cvRelease( void** struct_ptr ); 1734CVAPI(void*) cvClone( const void* struct_ptr ); 1735 1736/* simple API for reading/writing data */ 1737CVAPI(void) cvSave( const char* filename, const void* struct_ptr, 1738 const char* name CV_DEFAULT(NULL), 1739 const char* comment CV_DEFAULT(NULL), 1740 CvAttrList attributes CV_DEFAULT(cvAttrList())); 1741CVAPI(void*) cvLoad( const char* filename, 1742 CvMemStorage* memstorage CV_DEFAULT(NULL), 1743 const char* name CV_DEFAULT(NULL), 1744 const char** real_name CV_DEFAULT(NULL) ); 1745 1746/*********************************** Measuring Execution Time ***************************/ 1747 1748/* helper functions for RNG initialization and accurate time measurement: 1749 uses internal clock counter on x86 */ 1750CVAPI(int64) cvGetTickCount( void ); 1751CVAPI(double) cvGetTickFrequency( void ); 1752 1753/*********************************** Multi-Threading ************************************/ 1754 1755/* retrieve/set the number of threads used in OpenMP implementations */ 1756CVAPI(int) cvGetNumThreads( void ); 1757CVAPI(void) cvSetNumThreads( int threads CV_DEFAULT(0) ); 1758/* get index of the thread being executed */ 1759CVAPI(int) cvGetThreadNum( void ); 1760 1761/*************** Convenience functions for better interaction with HighGUI **************/ 1762 1763typedef IplImage* (CV_CDECL * CvLoadImageFunc)( const char* filename, int colorness ); 1764typedef CvMat* (CV_CDECL * CvLoadImageMFunc)( const char* filename, int colorness ); 1765typedef int (CV_CDECL * CvSaveImageFunc)( const char* filename, const CvArr* image ); 1766typedef void (CV_CDECL * CvShowImageFunc)( const char* windowname, const CvArr* image ); 1767 1768CVAPI(int) cvSetImageIOFunctions( CvLoadImageFunc _load_image, CvLoadImageMFunc _load_image_m, 1769 CvSaveImageFunc _save_image, CvShowImageFunc _show_image ); 1770 1771#define CV_SET_IMAGE_IO_FUNCTIONS() \ 1772 cvSetImageIOFunctions( cvLoadImage, cvLoadImageM, cvSaveImage, cvShowImage ) 1773 1774#ifdef __cplusplus 1775} 1776 1777#include "cxcore.hpp" 1778#endif 1779 1780#endif /*_CXCORE_H_*/ 1781