- Main Page
- Related Pages
- Namespaces
- Classes
- Files

- File List
- File Members

# C:/opt/OpenCV-2.2.0/modules/core/include/opencv2/core/core_c.h

Go to the documentation of this file.

    00001 /*M///////////////////////////////////////////////////////////////////////////////////////
    00002 //
    00003 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
    00004 //
    00005 //  By downloading, copying, installing or using the software you agree to this license.
    00006 //  If you do not agree to this license, do not download, install,
    00007 //  copy or use the software.
    00008 //
    00009 //
    00010 //                           License Agreement
    00011 //                For Open Source Computer Vision Library
    00012 //
    00013 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
    00014 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
    00015 // Third party copyrights are property of their respective owners.
    00016 //
    00017 // Redistribution and use in source and binary forms, with or without modification,
    00018 // are permitted provided that the following conditions are met:
    00019 //
    00020 //   * Redistribution's of source code must retain the above copyright notice,
    00021 //     this list of conditions and the following disclaimer.
    00022 //
    00023 //   * Redistribution's in binary form must reproduce the above copyright notice,
    00024 //     this list of conditions and the following disclaimer in the documentation
    00025 //     and/or other materials provided with the distribution.
    00026 //
    00027 //   * The name of the copyright holders may not be used to endorse or promote products
    00028 //     derived from this software without specific prior written permission.
    00029 //
    00030 // This software is provided by the copyright holders and contributors "as is" and
    00031 // any express or implied warranties, including, but not limited to, the implied
    00032 // warranties of merchantability and fitness for a particular purpose are disclaimed.
    00033 // In no event shall the Intel Corporation or contributors be liable for any direct,
    00034 // indirect, incidental, special, exemplary, or consequential damages
    00035 // (including, but not limited to, procurement of substitute goods or services;
    00036 // loss of use, data, or profits; or business interruption) however caused
    00037 // and on any theory of liability, whether in contract, strict liability,
    00038 // or tort (including negligence or otherwise) arising in any way out of
    00039 // the use of this software, even if advised of the possibility of such damage.
    00040 //
    00041 //M*/
    00042
    00043
    00044 #ifndef __OPENCV_CORE_C_H__
    00045 #define __OPENCV_CORE_C_H__
    00046
    00047 #include "opencv2/core/types_c.h"
    00048
    00049 #ifdef __cplusplus
    00050 extern "C" {
    00051 #endif
    00052
    00053 /****************************************************************************************\
    00054 *          Array allocation, deallocation, initialization and access to elements         *
    00055 \****************************************************************************************/
    00056
    00057 /* <malloc> wrapper.
    00058    If there is no enough memory, the function
    00059    (as well as other OpenCV functions that call cvAlloc)
    00060    raises an error. */
    00061 CVAPI(void*)  cvAlloc( size_t size );
    00062
    00063 /* <free> wrapper.
    00064    Here and further all the memory releasing functions
    00065    (that all call cvFree) take double pointer in order to
    00066    to clear pointer to the data after releasing it.
    00067    Passing pointer to NULL pointer is Ok: nothing happens in this case
    00068 */
    00069 CVAPI(void)   cvFree_( void* ptr );
    00070 #define cvFree(ptr) (cvFree_(*(ptr)), *(ptr)=0)
    00071
    00072 /* Allocates and initializes IplImage header */
    00073 CVAPI(IplImage*)  cvCreateImageHeader( CvSize size, int depth, int channels );
    00074
    00075 /* Inializes IplImage header */
    00076 CVAPI(IplImage*) cvInitImageHeader( IplImage* image, CvSize size, int depth,
    00077                                    int channels, int origin CV_DEFAULT(0),
    00078                                    int align CV_DEFAULT(4));
    00079
    00080 /* Creates IPL image (header and data) */
    00081 CVAPI(IplImage*)  cvCreateImage( CvSize size, int depth, int channels );
    00082
    00083 /* Releases (i.e. deallocates) IPL image header */
    00084 CVAPI(void)  cvReleaseImageHeader( IplImage** image );
    00085
    00086 /* Releases IPL image header and data */
    00087 CVAPI(void)  cvReleaseImage( IplImage** image );
    00088
    00089 /* Creates a copy of IPL image (widthStep may differ) */
    00090 CVAPI(IplImage*) cvCloneImage( const IplImage* image );
    00091
    00092 /* Sets a Channel Of Interest (only a few functions support COI) -
    00093    use cvCopy to extract the selected channel and/or put it back */
    00094 CVAPI(void)  cvSetImageCOI( IplImage* image, int coi );
    00095
    00096 /* Retrieves image Channel Of Interest */
    00097 CVAPI(int)  cvGetImageCOI( const IplImage* image );
    00098
    00099 /* Sets image ROI (region of interest) (COI is not changed) */
    00100 CVAPI(void)  cvSetImageROI( IplImage* image, CvRect rect );
    00101
    00102 /* Resets image ROI and COI */
    00103 CVAPI(void)  cvResetImageROI( IplImage* image );
    00104
    00105 /* Retrieves image ROI */
    00106 CVAPI(CvRect) cvGetImageROI( const IplImage* image );
    00107
    00108 /* Allocates and initalizes CvMat header */
    00109 CVAPI(CvMat*)  cvCreateMatHeader( int rows, int cols, int type );
    00110
    00111 #define CV_AUTOSTEP  0x7fffffff
    00112
    00113 /* Initializes CvMat header */
    00114 CVAPI(CvMat*) cvInitMatHeader( CvMat* mat, int rows, int cols,
    00115                               int type, void* data CV_DEFAULT(NULL),
    00116                               int step CV_DEFAULT(CV_AUTOSTEP) );
    00117
    00118 /* Allocates and initializes CvMat header and allocates data */
    00119 CVAPI(CvMat*)  cvCreateMat( int rows, int cols, int type );
    00120
    00121 /* Releases CvMat header and deallocates matrix data
    00122    (reference counting is used for data) */
    00123 CVAPI(void)  cvReleaseMat( CvMat** mat );
    00124
    00125 /* Decrements CvMat data reference counter and deallocates the data if
    00126    it reaches 0 */
    00127 CV_INLINE  void  cvDecRefData( CvArr* arr )
    00128 {
    00129     if( CV_IS_MAT( arr ))
    00130     {
    00131         CvMat* mat = (CvMat*)arr;
    00132         mat->data.ptr = NULL;
    00133         if( mat->refcount != NULL && --*mat->refcount == 0 )
    00134             cvFree( &mat->refcount );
    00135         mat->refcount = NULL;
    00136     }
    00137     else if( CV_IS_MATND( arr ))
    00138     {
    00139         CvMatND* mat = (CvMatND*)arr;
    00140         mat->data.ptr = NULL;
    00141         if( mat->refcount != NULL && --*mat->refcount == 0 )
    00142             cvFree( &mat->refcount );
    00143         mat->refcount = NULL;
    00144     }
    00145 }
    00146
    00147 /* Increments CvMat data reference counter */
    00148 CV_INLINE  int  cvIncRefData( CvArr* arr )
    00149 {
    00150     int refcount = 0;
    00151     if( CV_IS_MAT( arr ))
    00152     {
    00153         CvMat* mat = (CvMat*)arr;
    00154         if( mat->refcount != NULL )
    00155             refcount = ++*mat->refcount;
    00156     }
    00157     else if( CV_IS_MATND( arr ))
    00158     {
    00159         CvMatND* mat = (CvMatND*)arr;
    00160         if( mat->refcount != NULL )
    00161             refcount = ++*mat->refcount;
    00162     }
    00163     return refcount;
    00164 }
    00165
    00166
    00167 /* Creates an exact copy of the input matrix (except, may be, step value) */
    00168 CVAPI(CvMat*) cvCloneMat( const CvMat* mat );
    00169
    00170
    00171 /* Makes a new matrix from <rect> subrectangle of input array.
    00172    No data is copied */
    00173 CVAPI(CvMat*) cvGetSubRect( const CvArr* arr, CvMat* submat, CvRect rect );
    00174 #define cvGetSubArr cvGetSubRect
    00175
    00176 /* Selects row span of the input array: arr(start_row:delta_row:end_row,:)
    00177     (end_row is not included into the span). */
    00178 CVAPI(CvMat*) cvGetRows( const CvArr* arr, CvMat* submat,
    00179                         int start_row, int end_row,
    00180                         int delta_row CV_DEFAULT(1));
    00181
    00182 CV_INLINE  CvMat*  cvGetRow( const CvArr* arr, CvMat* submat, int row )
    00183 {
    00184     return cvGetRows( arr, submat, row, row + 1, 1 );
    00185 }
    00186
    00187
    00188 /* Selects column span of the input array: arr(:,start_col:end_col)
    00189    (end_col is not included into the span) */
    00190 CVAPI(CvMat*) cvGetCols( const CvArr* arr, CvMat* submat,
    00191                         int start_col, int end_col );
    00192
    00193 CV_INLINE  CvMat*  cvGetCol( const CvArr* arr, CvMat* submat, int col )
    00194 {
    00195     return cvGetCols( arr, submat, col, col + 1 );
    00196 }
    00197
    00198 /* Select a diagonal of the input array.
    00199    (diag = 0 means the main diagonal, >0 means a diagonal above the main one,
    00200    <0 - below the main one).
    00201    The diagonal will be represented as a column (nx1 matrix). */
    00202 CVAPI(CvMat*) cvGetDiag( const CvArr* arr, CvMat* submat,
    00203                             int diag CV_DEFAULT(0));
    00204
    00205 /* low-level scalar <-> raw data conversion functions */
    00206 CVAPI(void) cvScalarToRawData( const CvScalar* scalar, void* data, int type,
    00207                               int extend_to_12 CV_DEFAULT(0) );
    00208
    00209 CVAPI(void) cvRawDataToScalar( const void* data, int type, CvScalar* scalar );
    00210
    00211 /* Allocates and initializes CvMatND header */
    00212 CVAPI(CvMatND*)  cvCreateMatNDHeader( int dims, const int* sizes, int type );
    00213
    00214 /* Allocates and initializes CvMatND header and allocates data */
    00215 CVAPI(CvMatND*)  cvCreateMatND( int dims, const int* sizes, int type );
    00216
    00217 /* Initializes preallocated CvMatND header */
    00218 CVAPI(CvMatND*)  cvInitMatNDHeader( CvMatND* mat, int dims, const int* sizes,
    00219                                     int type, void* data CV_DEFAULT(NULL) );
    00220
    00221 /* Releases CvMatND */
    00222 CV_INLINE  void  cvReleaseMatND( CvMatND** mat )
    00223 {
    00224     cvReleaseMat( (CvMat**)mat );
    00225 }
    00226
    00227 /* Creates a copy of CvMatND (except, may be, steps) */
    00228 CVAPI(CvMatND*) cvCloneMatND( const CvMatND* mat );
    00229
    00230 /* Allocates and initializes CvSparseMat header and allocates data */
    00231 CVAPI(CvSparseMat*)  cvCreateSparseMat( int dims, const int* sizes, int type );
    00232
    00233 /* Releases CvSparseMat */
    00234 CVAPI(void)  cvReleaseSparseMat( CvSparseMat** mat );
    00235
    00236 /* Creates a copy of CvSparseMat (except, may be, zero items) */
    00237 CVAPI(CvSparseMat*) cvCloneSparseMat( const CvSparseMat* mat );
    00238
    00239 /* Initializes sparse array iterator
    00240    (returns the first node or NULL if the array is empty) */
    00241 CVAPI(CvSparseNode*) cvInitSparseMatIterator( const CvSparseMat* mat,
    00242                                               CvSparseMatIterator* mat_iterator );
    00243
    00244 // returns next sparse array node (or NULL if there is no more nodes)
    00245 CV_INLINE CvSparseNode* cvGetNextSparseNode( CvSparseMatIterator* mat_iterator )
    00246 {
    00247     if( mat_iterator->node->next )
    00248         return mat_iterator->node = mat_iterator->node->next;
    00249     else
    00250     {
    00251         int idx;
    00252         for( idx = ++mat_iterator->curidx; idx < mat_iterator->mat->hashsize; idx++ )
    00253         {
    00254             CvSparseNode* node = (CvSparseNode*)mat_iterator->mat->hashtable[idx];
    00255             if( node )
    00256             {
    00257                 mat_iterator->curidx = idx;
    00258                 return mat_iterator->node = node;
    00259             }
    00260         }
    00261         return NULL;
    00262     }
    00263 }
    00264
    00265 /**************** matrix iterator: used for n-ary operations on dense arrays *********/
    00266
    00267 #define CV_MAX_ARR 10
    00268
    00269 typedef struct CvNArrayIterator
    00270 {
    00271     int count; /* number of arrays */
    00272     int dims; /* number of dimensions to iterate */
    00273     CvSize size; /* maximal common linear size: { width = size, height = 1 } */
    00274     uchar* ptr[CV_MAX_ARR]; /* pointers to the array slices */
    00275     int stack[CV_MAX_DIM]; /* for internal use */
    00276     CvMatND* hdr[CV_MAX_ARR]; /* pointers to the headers of the
    00277                                  matrices that are processed */
    00278 }
    00279 CvNArrayIterator;
    00280
    00281 #define CV_NO_DEPTH_CHECK     1
    00282 #define CV_NO_CN_CHECK        2
    00283 #define CV_NO_SIZE_CHECK      4
    00284
    00285 /* initializes iterator that traverses through several arrays simulteneously
    00286    (the function together with cvNextArraySlice is used for
    00287     N-ari element-wise operations) */
    00288 CVAPI(int) cvInitNArrayIterator( int count, CvArr** arrs,
    00289                                  const CvArr* mask, CvMatND* stubs,
    00290                                  CvNArrayIterator* array_iterator,
    00291                                  int flags CV_DEFAULT(0) );
    00292
    00293 /* returns zero value if iteration is finished, non-zero (slice length) otherwise */
    00294 CVAPI(int) cvNextNArraySlice( CvNArrayIterator* array_iterator );
    00295
    00296
    00297 /* Returns type of array elements:
    00298    CV_8UC1 ... CV_64FC4 ... */
    00299 CVAPI(int) cvGetElemType( const CvArr* arr );
    00300
    00301 /* Retrieves number of an array dimensions and
    00302    optionally sizes of the dimensions */
    00303 CVAPI(int) cvGetDims( const CvArr* arr, int* sizes CV_DEFAULT(NULL) );
    00304
    00305
    00306 /* Retrieves size of a particular array dimension.
    00307    For 2d arrays cvGetDimSize(arr,0) returns number of rows (image height)
    00308    and cvGetDimSize(arr,1) returns number of columns (image width) */
    00309 CVAPI(int) cvGetDimSize( const CvArr* arr, int index );
    00310
    00311
    00312 /* ptr = &arr(idx0,idx1,...). All indexes are zero-based,
    00313    the major dimensions go first (e.g. (y,x) for 2D, (z,y,x) for 3D */
    00314 CVAPI(uchar*) cvPtr1D( const CvArr* arr, int idx0, int* type CV_DEFAULT(NULL));
    00315 CVAPI(uchar*) cvPtr2D( const CvArr* arr, int idx0, int idx1, int* type CV_DEFAULT(NULL) );
    00316 CVAPI(uchar*) cvPtr3D( const CvArr* arr, int idx0, int idx1, int idx2,
    00317                       int* type CV_DEFAULT(NULL));
    00318
    00319 /* For CvMat or IplImage number of indices should be 2
    00320    (row index (y) goes first, column index (x) goes next).
    00321    For CvMatND or CvSparseMat number of infices should match number of <dims> and
    00322    indices order should match the array dimension order. */
    00323 CVAPI(uchar*) cvPtrND( const CvArr* arr, const int* idx, int* type CV_DEFAULT(NULL),
    00324                       int create_node CV_DEFAULT(1),
    00325                       unsigned* precalc_hashval CV_DEFAULT(NULL));
    00326
    00327 /* value = arr(idx0,idx1,...) */
    00328 CVAPI(CvScalar) cvGet1D( const CvArr* arr, int idx0 );
    00329 CVAPI(CvScalar) cvGet2D( const CvArr* arr, int idx0, int idx1 );
    00330 CVAPI(CvScalar) cvGet3D( const CvArr* arr, int idx0, int idx1, int idx2 );
    00331 CVAPI(CvScalar) cvGetND( const CvArr* arr, const int* idx );
    00332
    00333 /* for 1-channel arrays */
    00334 CVAPI(double) cvGetReal1D( const CvArr* arr, int idx0 );
    00335 CVAPI(double) cvGetReal2D( const CvArr* arr, int idx0, int idx1 );
    00336 CVAPI(double) cvGetReal3D( const CvArr* arr, int idx0, int idx1, int idx2 );
    00337 CVAPI(double) cvGetRealND( const CvArr* arr, const int* idx );
    00338
    00339 /* arr(idx0,idx1,...) = value */
    00340 CVAPI(void) cvSet1D( CvArr* arr, int idx0, CvScalar value );
    00341 CVAPI(void) cvSet2D( CvArr* arr, int idx0, int idx1, CvScalar value );
    00342 CVAPI(void) cvSet3D( CvArr* arr, int idx0, int idx1, int idx2, CvScalar value );
    00343 CVAPI(void) cvSetND( CvArr* arr, const int* idx, CvScalar value );
    00344
    00345 /* for 1-channel arrays */
    00346 CVAPI(void) cvSetReal1D( CvArr* arr, int idx0, double value );
    00347 CVAPI(void) cvSetReal2D( CvArr* arr, int idx0, int idx1, double value );
    00348 CVAPI(void) cvSetReal3D( CvArr* arr, int idx0,
    00349                         int idx1, int idx2, double value );
    00350 CVAPI(void) cvSetRealND( CvArr* arr, const int* idx, double value );
    00351
    00352 /* clears element of ND dense array,
    00353    in case of sparse arrays it deletes the specified node */
    00354 CVAPI(void) cvClearND( CvArr* arr, const int* idx );
    00355
    00356 /* Converts CvArr (IplImage or CvMat,...) to CvMat.
    00357    If the last parameter is non-zero, function can
    00358    convert multi(>2)-dimensional array to CvMat as long as
    00359    the last array's dimension is continous. The resultant
    00360    matrix will be have appropriate (a huge) number of rows */
    00361 CVAPI(CvMat*) cvGetMat( const CvArr* arr, CvMat* header,
    00362                        int* coi CV_DEFAULT(NULL),
    00363                        int allowND CV_DEFAULT(0));
    00364
    00365 /* Converts CvArr (IplImage or CvMat) to IplImage */
    00366 CVAPI(IplImage*) cvGetImage( const CvArr* arr, IplImage* image_header );
    00367
    00368
    00369 /* Changes a shape of multi-dimensional array.
    00370    new_cn == 0 means that number of channels remains unchanged.
    00371    new_dims == 0 means that number and sizes of dimensions remain the same
    00372    (unless they need to be changed to set the new number of channels)
    00373    if new_dims == 1, there is no need to specify new dimension sizes
    00374    The resultant configuration should be achievable w/o data copying.
    00375    If the resultant array is sparse, CvSparseMat header should be passed
    00376    to the function else if the result is 1 or 2 dimensional,
    00377    CvMat header should be passed to the function
    00378    else CvMatND header should be passed */
    00379 CVAPI(CvArr*) cvReshapeMatND( const CvArr* arr,
    00380                              int sizeof_header, CvArr* header,
    00381                              int new_cn, int new_dims, int* new_sizes );
    00382
    00383 #define cvReshapeND( arr, header, new_cn, new_dims, new_sizes )   \
    00384       cvReshapeMatND( (arr), sizeof(*(header)), (header),         \
    00385                       (new_cn), (new_dims), (new_sizes))
    00386
    00387 CVAPI(CvMat*) cvReshape( const CvArr* arr, CvMat* header,
    00388                         int new_cn, int new_rows CV_DEFAULT(0) );
    00389
    00390 /* Repeats source 2d array several times in both horizontal and
    00391    vertical direction to fill destination array */
    00392 CVAPI(void) cvRepeat( const CvArr* src, CvArr* dst );
    00393
    00394 /* Allocates array data */
    00395 CVAPI(void)  cvCreateData( CvArr* arr );
    00396
    00397 /* Releases array data */
    00398 CVAPI(void)  cvReleaseData( CvArr* arr );
    00399
    00400 /* Attaches user data to the array header. The step is reffered to
    00401    the pre-last dimension. That is, all the planes of the array
    00402    must be joint (w/o gaps) */
    00403 CVAPI(void)  cvSetData( CvArr* arr, void* data, int step );
    00404
    00405 /* Retrieves raw data of CvMat, IplImage or CvMatND.
    00406    In the latter case the function raises an error if
    00407    the array can not be represented as a matrix */
    00408 CVAPI(void) cvGetRawData( const CvArr* arr, uchar** data,
    00409                          int* step CV_DEFAULT(NULL),
    00410                          CvSize* roi_size CV_DEFAULT(NULL));
    00411
    00412 /* Returns width and height of array in elements */
    00413 CVAPI(CvSize) cvGetSize( const CvArr* arr );
    00414
    00415 /* Copies source array to destination array */
    00416 CVAPI(void)  cvCopy( const CvArr* src, CvArr* dst,
    00417                      const CvArr* mask CV_DEFAULT(NULL) );
    00418
    00419 /* Sets all or "masked" elements of input array
    00420    to the same value*/
    00421 CVAPI(void)  cvSet( CvArr* arr, CvScalar value,
    00422                     const CvArr* mask CV_DEFAULT(NULL) );
    00423
    00424 /* Clears all the array elements (sets them to 0) */
    00425 CVAPI(void)  cvSetZero( CvArr* arr );
    00426 #define cvZero  cvSetZero
    00427
    00428
    00429 /* Splits a multi-channel array into the set of single-channel arrays or
    00430    extracts particular [color] plane */
    00431 CVAPI(void)  cvSplit( const CvArr* src, CvArr* dst0, CvArr* dst1,
    00432                       CvArr* dst2, CvArr* dst3 );
    00433
    00434 /* Merges a set of single-channel arrays into the single multi-channel array
    00435    or inserts one particular [color] plane to the array */
    00436 CVAPI(void)  cvMerge( const CvArr* src0, const CvArr* src1,
    00437                       const CvArr* src2, const CvArr* src3,
    00438                       CvArr* dst );
    00439
    00440 /* Copies several channels from input arrays to
    00441    certain channels of output arrays */
    00442 CVAPI(void)  cvMixChannels( const CvArr** src, int src_count,
    00443                             CvArr** dst, int dst_count,
    00444                             const int* from_to, int pair_count );
    00445
    00446 /* Performs linear transformation on every source array element:
    00447    dst(x,y,c) = scale*src(x,y,c)+shift.
    00448    Arbitrary combination of input and output array depths are allowed
    00449    (number of channels must be the same), thus the function can be used
    00450    for type conversion */
    00451 CVAPI(void)  cvConvertScale( const CvArr* src, CvArr* dst,
    00452                              double scale CV_DEFAULT(1),
    00453                              double shift CV_DEFAULT(0) );
    00454 #define cvCvtScale cvConvertScale
    00455 #define cvScale  cvConvertScale
    00456 #define cvConvert( src, dst )  cvConvertScale( (src), (dst), 1, 0 )
    00457
    00458
    00459 /* Performs linear transformation on every source array element,
    00460    stores absolute value of the result:
    00461    dst(x,y,c) = abs(scale*src(x,y,c)+shift).
    00462    destination array must have 8u type.
    00463    In other cases one may use cvConvertScale + cvAbsDiffS */
    00464 CVAPI(void)  cvConvertScaleAbs( const CvArr* src, CvArr* dst,
    00465                                 double scale CV_DEFAULT(1),
    00466                                 double shift CV_DEFAULT(0) );
    00467 #define cvCvtScaleAbs  cvConvertScaleAbs
    00468
    00469
    00470 /* checks termination criteria validity and
    00471    sets eps to default_eps (if it is not set),
    00472    max_iter to default_max_iters (if it is not set)
    00473 */
    00474 CVAPI(CvTermCriteria) cvCheckTermCriteria( CvTermCriteria criteria,
    00475                                            double default_eps,
    00476                                            int default_max_iters );
    00477
    00478 /****************************************************************************************\
    00479 *                   Arithmetic, logic and comparison operations                          *
    00480 \****************************************************************************************/
    00481
    00482 /* dst(mask) = src1(mask) + src2(mask) */
    00483 CVAPI(void)  cvAdd( const CvArr* src1, const CvArr* src2, CvArr* dst,
    00484                     const CvArr* mask CV_DEFAULT(NULL));
    00485
    00486 /* dst(mask) = src(mask) + value */
    00487 CVAPI(void)  cvAddS( const CvArr* src, CvScalar value, CvArr* dst,
    00488                      const CvArr* mask CV_DEFAULT(NULL));
    00489
    00490 /* dst(mask) = src1(mask) - src2(mask) */
    00491 CVAPI(void)  cvSub( const CvArr* src1, const CvArr* src2, CvArr* dst,
    00492                     const CvArr* mask CV_DEFAULT(NULL));
    00493
    00494 /* dst(mask) = src(mask) - value = src(mask) + (-value) */
    00495 CV_INLINE  void  cvSubS( const CvArr* src, CvScalar value, CvArr* dst,
    00496                          const CvArr* mask CV_DEFAULT(NULL))
    00497 {
    00498     cvAddS( src, cvScalar( -value.val[0], -value.val[1], -value.val[2], -value.val[3]),
    00499             dst, mask );
    00500 }
    00501
    00502 /* dst(mask) = value - src(mask) */
    00503 CVAPI(void)  cvSubRS( const CvArr* src, CvScalar value, CvArr* dst,
    00504                       const CvArr* mask CV_DEFAULT(NULL));
    00505
    00506 /* dst(idx) = src1(idx) * src2(idx) * scale
    00507    (scaled element-wise multiplication of 2 arrays) */
    00508 CVAPI(void)  cvMul( const CvArr* src1, const CvArr* src2,
    00509                     CvArr* dst, double scale CV_DEFAULT(1) );
    00510
    00511 /* element-wise division/inversion with scaling:
    00512     dst(idx) = src1(idx) * scale / src2(idx)
    00513     or dst(idx) = scale / src2(idx) if src1 == 0 */
    00514 CVAPI(void)  cvDiv( const CvArr* src1, const CvArr* src2,
    00515                     CvArr* dst, double scale CV_DEFAULT(1));
    00516
    00517 /* dst = src1 * scale + src2 */
    00518 CVAPI(void)  cvScaleAdd( const CvArr* src1, CvScalar scale,
    00519                          const CvArr* src2, CvArr* dst );
    00520 #define cvAXPY( A, real_scalar, B, C ) cvScaleAdd(A, cvRealScalar(real_scalar), B, C)
    00521
    00522 /* dst = src1 * alpha + src2 * beta + gamma */
    00523 CVAPI(void)  cvAddWeighted( const CvArr* src1, double alpha,
    00524                             const CvArr* src2, double beta,
    00525                             double gamma, CvArr* dst );
    00526
    00527 /* result = sum_i(src1(i) * src2(i)) (results for all channels are accumulated together) */
    00528 CVAPI(double)  cvDotProduct( const CvArr* src1, const CvArr* src2 );
    00529
    00530 /* dst(idx) = src1(idx) & src2(idx) */
    00531 CVAPI(void) cvAnd( const CvArr* src1, const CvArr* src2,
    00532                   CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
    00533
    00534 /* dst(idx) = src(idx) & value */
    00535 CVAPI(void) cvAndS( const CvArr* src, CvScalar value,
    00536                    CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
    00537
    00538 /* dst(idx) = src1(idx) | src2(idx) */
    00539 CVAPI(void) cvOr( const CvArr* src1, const CvArr* src2,
    00540                  CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
    00541
    00542 /* dst(idx) = src(idx) | value */
    00543 CVAPI(void) cvOrS( const CvArr* src, CvScalar value,
    00544                   CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
    00545
    00546 /* dst(idx) = src1(idx) ^ src2(idx) */
    00547 CVAPI(void) cvXor( const CvArr* src1, const CvArr* src2,
    00548                   CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
    00549
    00550 /* dst(idx) = src(idx) ^ value */
    00551 CVAPI(void) cvXorS( const CvArr* src, CvScalar value,
    00552                    CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
    00553
    00554 /* dst(idx) = ~src(idx) */
    00555 CVAPI(void) cvNot( const CvArr* src, CvArr* dst );
    00556
    00557 /* dst(idx) = lower(idx) <= src(idx) < upper(idx) */
    00558 CVAPI(void) cvInRange( const CvArr* src, const CvArr* lower,
    00559                       const CvArr* upper, CvArr* dst );
    00560
    00561 /* dst(idx) = lower <= src(idx) < upper */
    00562 CVAPI(void) cvInRangeS( const CvArr* src, CvScalar lower,
    00563                        CvScalar upper, CvArr* dst );
    00564
    00565 #define CV_CMP_EQ   0
    00566 #define CV_CMP_GT   1
    00567 #define CV_CMP_GE   2
    00568 #define CV_CMP_LT   3
    00569 #define CV_CMP_LE   4
    00570 #define CV_CMP_NE   5
    00571
    00572 /* The comparison operation support single-channel arrays only.
    00573    Destination image should be 8uC1 or 8sC1 */
    00574
    00575 /* dst(idx) = src1(idx) _cmp_op_ src2(idx) */
    00576 CVAPI(void) cvCmp( const CvArr* src1, const CvArr* src2, CvArr* dst, int cmp_op );
    00577
    00578 /* dst(idx) = src1(idx) _cmp_op_ value */
    00579 CVAPI(void) cvCmpS( const CvArr* src, double value, CvArr* dst, int cmp_op );
    00580
    00581 /* dst(idx) = min(src1(idx),src2(idx)) */
    00582 CVAPI(void) cvMin( const CvArr* src1, const CvArr* src2, CvArr* dst );
    00583
    00584 /* dst(idx) = max(src1(idx),src2(idx)) */
    00585 CVAPI(void) cvMax( const CvArr* src1, const CvArr* src2, CvArr* dst );
    00586
    00587 /* dst(idx) = min(src(idx),value) */
    00588 CVAPI(void) cvMinS( const CvArr* src, double value, CvArr* dst );
    00589
    00590 /* dst(idx) = max(src(idx),value) */
    00591 CVAPI(void) cvMaxS( const CvArr* src, double value, CvArr* dst );
    00592
    00593 /* dst(x,y,c) = abs(src1(x,y,c) - src2(x,y,c)) */
    00594 CVAPI(void) cvAbsDiff( const CvArr* src1, const CvArr* src2, CvArr* dst );
    00595
    00596 /* dst(x,y,c) = abs(src(x,y,c) - value(c)) */
    00597 CVAPI(void) cvAbsDiffS( const CvArr* src, CvArr* dst, CvScalar value );
    00598 #define cvAbs( src, dst ) cvAbsDiffS( (src), (dst), cvScalarAll(0))
    00599
    00600 /****************************************************************************************\
    00601 *                                Math operations                                         *
    00602 \****************************************************************************************/
    00603
    00604 /* Does cartesian->polar coordinates conversion.
    00605    Either of output components (magnitude or angle) is optional */
    00606 CVAPI(void)  cvCartToPolar( const CvArr* x, const CvArr* y,
    00607                             CvArr* magnitude, CvArr* angle CV_DEFAULT(NULL),
    00608                             int angle_in_degrees CV_DEFAULT(0));
    00609
    00610 /* Does polar->cartesian coordinates conversion.
    00611    Either of output components (magnitude or angle) is optional.
    00612    If magnitude is missing it is assumed to be all 1's */
    00613 CVAPI(void)  cvPolarToCart( const CvArr* magnitude, const CvArr* angle,
    00614                             CvArr* x, CvArr* y,
    00615                             int angle_in_degrees CV_DEFAULT(0));
    00616
    00617 /* Does powering: dst(idx) = src(idx)^power */
    00618 CVAPI(void)  cvPow( const CvArr* src, CvArr* dst, double power );
    00619
    00620 /* Does exponention: dst(idx) = exp(src(idx)).
    00621    Overflow is not handled yet. Underflow is handled.
    00622    Maximal relative error is ~7e-6 for single-precision input */
    00623 CVAPI(void)  cvExp( const CvArr* src, CvArr* dst );
    00624
    00625 /* Calculates natural logarithms: dst(idx) = log(abs(src(idx))).
    00626    Logarithm of 0 gives large negative number(~-700)
    00627    Maximal relative error is ~3e-7 for single-precision output
    00628 */
    00629 CVAPI(void)  cvLog( const CvArr* src, CvArr* dst );
    00630
    00631 /* Fast arctangent calculation */
    00632 CVAPI(float) cvFastArctan( float y, float x );
    00633
    00634 /* Fast cubic root calculation */
    00635 CVAPI(float)  cvCbrt( float value );
    00636
    00637 /* Checks array values for NaNs, Infs or simply for too large numbers
    00638    (if CV_CHECK_RANGE is set). If CV_CHECK_QUIET is set,
    00639    no runtime errors is raised (function returns zero value in case of "bad" values).
    00640    Otherwise cvError is called */
    00641 #define  CV_CHECK_RANGE    1
    00642 #define  CV_CHECK_QUIET    2
    00643 CVAPI(int)  cvCheckArr( const CvArr* arr, int flags CV_DEFAULT(0),
    00644                         double min_val CV_DEFAULT(0), double max_val CV_DEFAULT(0));
    00645 #define cvCheckArray cvCheckArr
    00646
    00647 #define CV_RAND_UNI      0
    00648 #define CV_RAND_NORMAL   1
    00649 CVAPI(void) cvRandArr( CvRNG* rng, CvArr* arr, int dist_type,
    00650                       CvScalar param1, CvScalar param2 );
    00651
    00652 CVAPI(void) cvRandShuffle( CvArr* mat, CvRNG* rng,
    00653                            double iter_factor CV_DEFAULT(1.));
    00654
    00655 #define CV_SORT_EVERY_ROW 0
    00656 #define CV_SORT_EVERY_COLUMN 1
    00657 #define CV_SORT_ASCENDING 0
    00658 #define CV_SORT_DESCENDING 16
    00659
    00660 CVAPI(void) cvSort( const CvArr* src, CvArr* dst CV_DEFAULT(NULL),
    00661                     CvArr* idxmat CV_DEFAULT(NULL),
    00662                     int flags CV_DEFAULT(0));
    00663
    00664 /* Finds real roots of a cubic equation */
    00665 CVAPI(int) cvSolveCubic( const CvMat* coeffs, CvMat* roots );
    00666
    00667 /* Finds all real and complex roots of a polynomial equation */
    00668 CVAPI(void) cvSolvePoly(const CvMat* coeffs, CvMat *roots2,
    00669                         int maxiter CV_DEFAULT(20), int fig CV_DEFAULT(100));
    00670
    00671 /****************************************************************************************\
    00672 *                                Matrix operations                                       *
    00673 \****************************************************************************************/
    00674
    00675 /* Calculates cross product of two 3d vectors */
    00676 CVAPI(void)  cvCrossProduct( const CvArr* src1, const CvArr* src2, CvArr* dst );
    00677
    00678 /* Matrix transform: dst = A*B + C, C is optional */
    00679 #define cvMatMulAdd( src1, src2, src3, dst ) cvGEMM( (src1), (src2), 1., (src3), 1., (dst), 0 )
    00680 #define cvMatMul( src1, src2, dst )  cvMatMulAdd( (src1), (src2), NULL, (dst))
    00681
    00682 #define CV_GEMM_A_T 1
    00683 #define CV_GEMM_B_T 2
    00684 #define CV_GEMM_C_T 4
    00685 /* Extended matrix transform:
    00686    dst = alpha*op(A)*op(B) + beta*op(C), where op(X) is X or X^T */
    00687 CVAPI(void)  cvGEMM( const CvArr* src1, const CvArr* src2, double alpha,
    00688                      const CvArr* src3, double beta, CvArr* dst,
    00689                      int tABC CV_DEFAULT(0));
    00690 #define cvMatMulAddEx cvGEMM
    00691
    00692 /* Transforms each element of source array and stores
    00693    resultant vectors in destination array */
    00694 CVAPI(void)  cvTransform( const CvArr* src, CvArr* dst,
    00695                           const CvMat* transmat,
    00696                           const CvMat* shiftvec CV_DEFAULT(NULL));
    00697 #define cvMatMulAddS cvTransform
    00698
    00699 /* Does perspective transform on every element of input array */
    00700 CVAPI(void)  cvPerspectiveTransform( const CvArr* src, CvArr* dst,
    00701                                      const CvMat* mat );
    00702
    00703 /* Calculates (A-delta)*(A-delta)^T (order=0) or (A-delta)^T*(A-delta) (order=1) */
    00704 CVAPI(void) cvMulTransposed( const CvArr* src, CvArr* dst, int order,
    00705                              const CvArr* delta CV_DEFAULT(NULL),
    00706                              double scale CV_DEFAULT(1.) );
    00707
    00708 /* Tranposes matrix. Square matrices can be transposed in-place */
    00709 CVAPI(void)  cvTranspose( const CvArr* src, CvArr* dst );
    00710 #define cvT cvTranspose
    00711
    00712 /* Completes the symmetric matrix from the lower (LtoR=0) or from the upper (LtoR!=0) part */
    00713 CVAPI(void)  cvCompleteSymm( CvMat* matrix, int LtoR CV_DEFAULT(0) );
    00714
    00715 /* Mirror array data around horizontal (flip=0),
    00716    vertical (flip=1) or both(flip=-1) axises:
    00717    cvFlip(src) flips images vertically and sequences horizontally (inplace) */
    00718 CVAPI(void)  cvFlip( const CvArr* src, CvArr* dst CV_DEFAULT(NULL),
    00719                      int flip_mode CV_DEFAULT(0));
    00720 #define cvMirror cvFlip
    00721
    00722
    00723 #define CV_SVD_MODIFY_A   1
    00724 #define CV_SVD_U_T        2
    00725 #define CV_SVD_V_T        4
    00726
    00727 /* Performs Singular Value Decomposition of a matrix */
    00728 CVAPI(void)   cvSVD( CvArr* A, CvArr* W, CvArr* U CV_DEFAULT(NULL),
    00729                      CvArr* V CV_DEFAULT(NULL), int flags CV_DEFAULT(0));
    00730
    00731 /* Performs Singular Value Back Substitution (solves A*X = B):
    00732    flags must be the same as in cvSVD */
    00733 CVAPI(void)   cvSVBkSb( const CvArr* W, const CvArr* U,
    00734                         const CvArr* V, const CvArr* B,
    00735                         CvArr* X, int flags );
    00736
    00737 #define CV_LU  0
    00738 #define CV_SVD 1
    00739 #define CV_SVD_SYM 2
    00740 #define CV_CHOLESKY 3
    00741 #define CV_QR  4
    00742 #define CV_NORMAL 16
    00743
    00744 /* Inverts matrix */
    00745 CVAPI(double)  cvInvert( const CvArr* src, CvArr* dst,
    00746                          int method CV_DEFAULT(CV_LU));
    00747 #define cvInv cvInvert
    00748
    00749 /* Solves linear system (src1)*(dst) = (src2)
    00750    (returns 0 if src1 is a singular and CV_LU method is used) */
    00751 CVAPI(int)  cvSolve( const CvArr* src1, const CvArr* src2, CvArr* dst,
    00752                      int method CV_DEFAULT(CV_LU));
    00753
    00754 /* Calculates determinant of input matrix */
    00755 CVAPI(double) cvDet( const CvArr* mat );
    00756
    00757 /* Calculates trace of the matrix (sum of elements on the main diagonal) */
    00758 CVAPI(CvScalar) cvTrace( const CvArr* mat );
    00759
    00760 /* Finds eigen values and vectors of a symmetric matrix */
    00761 CVAPI(void)  cvEigenVV( CvArr* mat, CvArr* evects, CvArr* evals,
    00762                         double eps CV_DEFAULT(0),
    00763                         int lowindex CV_DEFAULT(-1),
    00764                         int highindex CV_DEFAULT(-1));
    00765
    00767 //CVAPI(void)  cvSelectedEigenVV( CvArr* mat, CvArr* evects, CvArr* evals,
    00768 //                                int lowindex, int highindex );
    00769
    00770 /* Makes an identity matrix (mat_ij = i == j) */
    00771 CVAPI(void)  cvSetIdentity( CvArr* mat, CvScalar value CV_DEFAULT(cvRealScalar(1)) );
    00772
    00773 /* Fills matrix with given range of numbers */
    00774 CVAPI(CvArr*)  cvRange( CvArr* mat, double start, double end );
    00775
    00776 /* Calculates covariation matrix for a set of vectors */
    00777 /* transpose([v1-avg, v2-avg,...]) * [v1-avg,v2-avg,...] */
    00778 #define CV_COVAR_SCRAMBLED 0
    00779
    00780 /* [v1-avg, v2-avg,...] * transpose([v1-avg,v2-avg,...]) */
    00781 #define CV_COVAR_NORMAL    1
    00782
    00783 /* do not calc average (i.e. mean vector) - use the input vector instead
    00784    (useful for calculating covariance matrix by parts) */
    00785 #define CV_COVAR_USE_AVG   2
    00786
    00787 /* scale the covariance matrix coefficients by number of the vectors */
    00788 #define CV_COVAR_SCALE     4
    00789
    00790 /* all the input vectors are stored in a single matrix, as its rows */
    00791 #define CV_COVAR_ROWS      8
    00792
    00793 /* all the input vectors are stored in a single matrix, as its columns */
    00794 #define CV_COVAR_COLS     16
    00795
    00796 CVAPI(void)  cvCalcCovarMatrix( const CvArr** vects, int count,
    00797                                 CvArr* cov_mat, CvArr* avg, int flags );
    00798
    00799 #define CV_PCA_DATA_AS_ROW 0
    00800 #define CV_PCA_DATA_AS_COL 1
    00801 #define CV_PCA_USE_AVG 2
    00802 CVAPI(void)  cvCalcPCA( const CvArr* data, CvArr* mean,
    00803                         CvArr* eigenvals, CvArr* eigenvects, int flags );
    00804
    00805 CVAPI(void)  cvProjectPCA( const CvArr* data, const CvArr* mean,
    00806                            const CvArr* eigenvects, CvArr* result );
    00807
    00808 CVAPI(void)  cvBackProjectPCA( const CvArr* proj, const CvArr* mean,
    00809                                const CvArr* eigenvects, CvArr* result );
    00810
    00811 /* Calculates Mahalanobis(weighted) distance */
    00812 CVAPI(double)  cvMahalanobis( const CvArr* vec1, const CvArr* vec2, const CvArr* mat );
    00813 #define cvMahalonobis  cvMahalanobis
    00814
    00815 /****************************************************************************************\
    00816 *                                    Array Statistics                                    *
    00817 \****************************************************************************************/
    00818
    00819 /* Finds sum of array elements */
    00820 CVAPI(CvScalar)  cvSum( const CvArr* arr );
    00821
    00822 /* Calculates number of non-zero pixels */
    00823 CVAPI(int)  cvCountNonZero( const CvArr* arr );
    00824
    00825 /* Calculates mean value of array elements */
    00826 CVAPI(CvScalar)  cvAvg( const CvArr* arr, const CvArr* mask CV_DEFAULT(NULL) );
    00827
    00828 /* Calculates mean and standard deviation of pixel values */
    00829 CVAPI(void)  cvAvgSdv( const CvArr* arr, CvScalar* mean, CvScalar* std_dev,
    00830                        const CvArr* mask CV_DEFAULT(NULL) );
    00831
    00832 /* Finds global minimum, maximum and their positions */
    00833 CVAPI(void)  cvMinMaxLoc( const CvArr* arr, double* min_val, double* max_val,
    00834                           CvPoint* min_loc CV_DEFAULT(NULL),
    00835                           CvPoint* max_loc CV_DEFAULT(NULL),
    00836                           const CvArr* mask CV_DEFAULT(NULL) );
    00837
    00838 /* types of array norm */
    00839 #define CV_C            1
    00840 #define CV_L1           2
    00841 #define CV_L2           4
    00842 #define CV_NORM_MASK    7
    00843 #define CV_RELATIVE     8
    00844 #define CV_DIFF         16
    00845 #define CV_MINMAX       32
    00846
    00847 #define CV_DIFF_C       (CV_DIFF | CV_C)
    00848 #define CV_DIFF_L1      (CV_DIFF | CV_L1)
    00849 #define CV_DIFF_L2      (CV_DIFF | CV_L2)
    00850 #define CV_RELATIVE_C   (CV_RELATIVE | CV_C)
    00851 #define CV_RELATIVE_L1  (CV_RELATIVE | CV_L1)
    00852 #define CV_RELATIVE_L2  (CV_RELATIVE | CV_L2)
    00853
    00854 /* Finds norm, difference norm or relative difference norm for an array (or two arrays) */
    00855 CVAPI(double)  cvNorm( const CvArr* arr1, const CvArr* arr2 CV_DEFAULT(NULL),
    00856                        int norm_type CV_DEFAULT(CV_L2),
    00857                        const CvArr* mask CV_DEFAULT(NULL) );
    00858
    00859 CVAPI(void)  cvNormalize( const CvArr* src, CvArr* dst,
    00860                           double a CV_DEFAULT(1.), double b CV_DEFAULT(0.),
    00861                           int norm_type CV_DEFAULT(CV_L2),
    00862                           const CvArr* mask CV_DEFAULT(NULL) );
    00863
    00864
    00865 #define CV_REDUCE_SUM 0
    00866 #define CV_REDUCE_AVG 1
    00867 #define CV_REDUCE_MAX 2
    00868 #define CV_REDUCE_MIN 3
    00869
    00870 CVAPI(void)  cvReduce( const CvArr* src, CvArr* dst, int dim CV_DEFAULT(-1),
    00871                        int op CV_DEFAULT(CV_REDUCE_SUM) );
    00872
    00873 /****************************************************************************************\
    00874 *                      Discrete Linear Transforms and Related Functions                  *
    00875 \****************************************************************************************/
    00876
    00877 #define CV_DXT_FORWARD  0
    00878 #define CV_DXT_INVERSE  1
    00879 #define CV_DXT_SCALE    2 /* divide result by size of array */
    00880 #define CV_DXT_INV_SCALE (CV_DXT_INVERSE + CV_DXT_SCALE)
    00881 #define CV_DXT_INVERSE_SCALE CV_DXT_INV_SCALE
    00882 #define CV_DXT_ROWS     4 /* transform each row individually */
    00883 #define CV_DXT_MUL_CONJ 8 /* conjugate the second argument of cvMulSpectrums */
    00884
    00885 /* Discrete Fourier Transform:
    00886     complex->complex,
    00887     real->ccs (forward),
    00888     ccs->real (inverse) */
    00889 CVAPI(void)  cvDFT( const CvArr* src, CvArr* dst, int flags,
    00890                     int nonzero_rows CV_DEFAULT(0) );
    00891 #define cvFFT cvDFT
    00892
    00893 /* Multiply results of DFTs: DFT(X)*DFT(Y) or DFT(X)*conj(DFT(Y)) */
    00894 CVAPI(void)  cvMulSpectrums( const CvArr* src1, const CvArr* src2,
    00895                              CvArr* dst, int flags );
    00896
    00897 /* Finds optimal DFT vector size >= size0 */
    00898 CVAPI(int)  cvGetOptimalDFTSize( int size0 );
    00899
    00900 /* Discrete Cosine Transform */
    00901 CVAPI(void)  cvDCT( const CvArr* src, CvArr* dst, int flags );
    00902
    00903 /****************************************************************************************\
    00904 *                              Dynamic data structures                                   *
    00905 \****************************************************************************************/
    00906
    00907 /* Calculates length of sequence slice (with support of negative indices). */
    00908 CVAPI(int) cvSliceLength( CvSlice slice, const CvSeq* seq );
    00909
    00910
    00911 /* Creates new memory storage.
    00912    block_size == 0 means that default,
    00913    somewhat optimal size, is used (currently, it is 64K) */
    00914 CVAPI(CvMemStorage*)  cvCreateMemStorage( int block_size CV_DEFAULT(0));
    00915
    00916
    00917 /* Creates a memory storage that will borrow memory blocks from parent storage */
    00918 CVAPI(CvMemStorage*)  cvCreateChildMemStorage( CvMemStorage* parent );
    00919
    00920
    00921 /* Releases memory storage. All the children of a parent must be released before
    00922    the parent. A child storage returns all the blocks to parent when it is released */
    00923 CVAPI(void)  cvReleaseMemStorage( CvMemStorage** storage );
    00924
    00925
    00926 /* Clears memory storage. This is the only way(!!!) (besides cvRestoreMemStoragePos)
    00927    to reuse memory allocated for the storage - cvClearSeq,cvClearSet ...
    00928    do not free any memory.
    00929    A child storage returns all the blocks to the parent when it is cleared */
    00930 CVAPI(void)  cvClearMemStorage( CvMemStorage* storage );
    00931
    00932 /* Remember a storage "free memory" position */
    00933 CVAPI(void)  cvSaveMemStoragePos( const CvMemStorage* storage, CvMemStoragePos* pos );
    00934
    00935 /* Restore a storage "free memory" position */
    00936 CVAPI(void)  cvRestoreMemStoragePos( CvMemStorage* storage, CvMemStoragePos* pos );
    00937
    00938 /* Allocates continuous buffer of the specified size in the storage */
    00939 CVAPI(void*) cvMemStorageAlloc( CvMemStorage* storage, size_t size );
    00940
    00941 /* Allocates string in memory storage */
    00942 CVAPI(CvString) cvMemStorageAllocString( CvMemStorage* storage, const char* ptr,
    00943                                         int len CV_DEFAULT(-1) );
    00944
    00945 /* Creates new empty sequence that will reside in the specified storage */
    00946 CVAPI(CvSeq*)  cvCreateSeq( int seq_flags, int header_size,
    00947                             int elem_size, CvMemStorage* storage );
    00948
    00949 /* Changes default size (granularity) of sequence blocks.
    00950    The default size is ~1Kbyte */
    00951 CVAPI(void)  cvSetSeqBlockSize( CvSeq* seq, int delta_elems );
    00952
    00953
    00954 /* Adds new element to the end of sequence. Returns pointer to the element */
    00955 CVAPI(schar*)  cvSeqPush( CvSeq* seq, const void* element CV_DEFAULT(NULL));
    00956
    00957
    00958 /* Adds new element to the beginning of sequence. Returns pointer to it */
    00959 CVAPI(schar*)  cvSeqPushFront( CvSeq* seq, const void* element CV_DEFAULT(NULL));
    00960
    00961
    00962 /* Removes the last element from sequence and optionally saves it */
    00963 CVAPI(void)  cvSeqPop( CvSeq* seq, void* element CV_DEFAULT(NULL));
    00964
    00965
    00966 /* Removes the first element from sequence and optioanally saves it */
    00967 CVAPI(void)  cvSeqPopFront( CvSeq* seq, void* element CV_DEFAULT(NULL));
    00968
    00969
    00970 #define CV_FRONT 1
    00971 #define CV_BACK 0
    00972 /* Adds several new elements to the end of sequence */
    00973 CVAPI(void)  cvSeqPushMulti( CvSeq* seq, const void* elements,
    00974                              int count, int in_front CV_DEFAULT(0) );
    00975
    00976 /* Removes several elements from the end of sequence and optionally saves them */
    00977 CVAPI(void)  cvSeqPopMulti( CvSeq* seq, void* elements,
    00978                             int count, int in_front CV_DEFAULT(0) );
    00979
    00980 /* Inserts a new element in the middle of sequence.
    00981    cvSeqInsert(seq,0,elem) == cvSeqPushFront(seq,elem) */
    00982 CVAPI(schar*)  cvSeqInsert( CvSeq* seq, int before_index,
    00983                             const void* element CV_DEFAULT(NULL));
    00984
    00985 /* Removes specified sequence element */
    00986 CVAPI(void)  cvSeqRemove( CvSeq* seq, int index );
    00987
    00988
    00989 /* Removes all the elements from the sequence. The freed memory
    00990    can be reused later only by the same sequence unless cvClearMemStorage
    00991    or cvRestoreMemStoragePos is called */
    00992 CVAPI(void)  cvClearSeq( CvSeq* seq );
    00993
    00994
    00995 /* Retrieves pointer to specified sequence element.
    00996    Negative indices are supported and mean counting from the end
    00997    (e.g -1 means the last sequence element) */
    00998 CVAPI(schar*)  cvGetSeqElem( const CvSeq* seq, int index );
    00999
    01000 /* Calculates index of the specified sequence element.
    01001    Returns -1 if element does not belong to the sequence */
    01002 CVAPI(int)  cvSeqElemIdx( const CvSeq* seq, const void* element,
    01003                          CvSeqBlock** block CV_DEFAULT(NULL) );
    01004
    01005 /* Initializes sequence writer. The new elements will be added to the end of sequence */
    01006 CVAPI(void)  cvStartAppendToSeq( CvSeq* seq, CvSeqWriter* writer );
    01007
    01008
    01009 /* Combination of cvCreateSeq and cvStartAppendToSeq */
    01010 CVAPI(void)  cvStartWriteSeq( int seq_flags, int header_size,
    01011                               int elem_size, CvMemStorage* storage,
    01012                               CvSeqWriter* writer );
    01013
    01014 /* Closes sequence writer, updates sequence header and returns pointer
    01015    to the resultant sequence
    01016    (which may be useful if the sequence was created using cvStartWriteSeq))
    01017 */
    01018 CVAPI(CvSeq*)  cvEndWriteSeq( CvSeqWriter* writer );
    01019
    01020
    01021 /* Updates sequence header. May be useful to get access to some of previously
    01022    written elements via cvGetSeqElem or sequence reader */
    01023 CVAPI(void)   cvFlushSeqWriter( CvSeqWriter* writer );
    01024
    01025
    01026 /* Initializes sequence reader.
    01027    The sequence can be read in forward or backward direction */
    01028 CVAPI(void) cvStartReadSeq( const CvSeq* seq, CvSeqReader* reader,
    01029                            int reverse CV_DEFAULT(0) );
    01030
    01031
    01032 /* Returns current sequence reader position (currently observed sequence element) */
    01033 CVAPI(int)  cvGetSeqReaderPos( CvSeqReader* reader );
    01034
    01035
    01036 /* Changes sequence reader position. It may seek to an absolute or
    01037    to relative to the current position */
    01038 CVAPI(void)   cvSetSeqReaderPos( CvSeqReader* reader, int index,
    01039                                  int is_relative CV_DEFAULT(0));
    01040
    01041 /* Copies sequence content to a continuous piece of memory */
    01042 CVAPI(void*)  cvCvtSeqToArray( const CvSeq* seq, void* elements,
    01043                                CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ) );
    01044
    01045 /* Creates sequence header for array.
    01046    After that all the operations on sequences that do not alter the content
    01047    can be applied to the resultant sequence */
    01048 CVAPI(CvSeq*) cvMakeSeqHeaderForArray( int seq_type, int header_size,
    01049                                        int elem_size, void* elements, int total,
    01050                                        CvSeq* seq, CvSeqBlock* block );
    01051
    01052 /* Extracts sequence slice (with or without copying sequence elements) */
    01053 CVAPI(CvSeq*) cvSeqSlice( const CvSeq* seq, CvSlice slice,
    01054                          CvMemStorage* storage CV_DEFAULT(NULL),
    01055                          int copy_data CV_DEFAULT(0));
    01056
    01057 CV_INLINE CvSeq* cvCloneSeq( const CvSeq* seq, CvMemStorage* storage CV_DEFAULT(NULL))
    01058 {
    01059     return cvSeqSlice( seq, CV_WHOLE_SEQ, storage, 1 );
    01060 }
    01061
    01062 /* Removes sequence slice */
    01063 CVAPI(void)  cvSeqRemoveSlice( CvSeq* seq, CvSlice slice );
    01064
    01065 /* Inserts a sequence or array into another sequence */
    01066 CVAPI(void)  cvSeqInsertSlice( CvSeq* seq, int before_index, const CvArr* from_arr );
    01067
    01068 /* a < b ? -1 : a > b ? 1 : 0 */
    01069 typedef int (CV_CDECL* CvCmpFunc)(const void* a, const void* b, void* userdata );
    01070
    01071 /* Sorts sequence in-place given element comparison function */
    01072 CVAPI(void) cvSeqSort( CvSeq* seq, CvCmpFunc func, void* userdata CV_DEFAULT(NULL) );
    01073
    01074 /* Finds element in a [sorted] sequence */
    01075 CVAPI(schar*) cvSeqSearch( CvSeq* seq, const void* elem, CvCmpFunc func,
    01076                            int is_sorted, int* elem_idx,
    01077                            void* userdata CV_DEFAULT(NULL) );
    01078
    01079 /* Reverses order of sequence elements in-place */
    01080 CVAPI(void) cvSeqInvert( CvSeq* seq );
    01081
    01082 /* Splits sequence into one or more equivalence classes using the specified criteria */
    01083 CVAPI(int)  cvSeqPartition( const CvSeq* seq, CvMemStorage* storage,
    01084                             CvSeq** labels, CvCmpFunc is_equal, void* userdata );
    01085
    01086 /************ Internal sequence functions ************/
    01087 CVAPI(void)  cvChangeSeqBlock( void* reader, int direction );
    01088 CVAPI(void)  cvCreateSeqBlock( CvSeqWriter* writer );
    01089
    01090
    01091 /* Creates a new set */
    01092 CVAPI(CvSet*)  cvCreateSet( int set_flags, int header_size,
    01093                             int elem_size, CvMemStorage* storage );
    01094
    01095 /* Adds new element to the set and returns pointer to it */
    01096 CVAPI(int)  cvSetAdd( CvSet* set_header, CvSetElem* elem CV_DEFAULT(NULL),
    01097                       CvSetElem** inserted_elem CV_DEFAULT(NULL) );
    01098
    01099 /* Fast variant of cvSetAdd */
    01100 CV_INLINE  CvSetElem* cvSetNew( CvSet* set_header )
    01101 {
    01102     CvSetElem* elem = set_header->free_elems;
    01103     if( elem )
    01104     {
    01105         set_header->free_elems = elem->next_free;
    01106         elem->flags = elem->flags & CV_SET_ELEM_IDX_MASK;
    01107         set_header->active_count++;
    01108     }
    01109     else
    01110         cvSetAdd( set_header, NULL, (CvSetElem**)&elem );
    01111     return elem;
    01112 }
    01113
    01114 /* Removes set element given its pointer */
    01115 CV_INLINE  void cvSetRemoveByPtr( CvSet* set_header, void* elem )
    01116 {
    01117     CvSetElem* _elem = (CvSetElem*)elem;
    01118     assert( _elem->flags >= 0 /*&& (elem->flags & CV_SET_ELEM_IDX_MASK) < set_header->total*/ );
    01119     _elem->next_free = set_header->free_elems;
    01120     _elem->flags = (_elem->flags & CV_SET_ELEM_IDX_MASK) | CV_SET_ELEM_FREE_FLAG;
    01121     set_header->free_elems = _elem;
    01122     set_header->active_count--;
    01123 }
    01124
    01125 /* Removes element from the set by its index  */
    01126 CVAPI(void)   cvSetRemove( CvSet* set_header, int index );
    01127
    01128 /* Returns a set element by index. If the element doesn't belong to the set,
    01129    NULL is returned */
    01130 CV_INLINE CvSetElem* cvGetSetElem( const CvSet* set_header, int index )
    01131 {
    01132     CvSetElem* elem = (CvSetElem*)cvGetSeqElem( (CvSeq*)set_header, index );
    01133     return elem && CV_IS_SET_ELEM( elem ) ? elem : 0;
    01134 }
    01135
    01136 /* Removes all the elements from the set */
    01137 CVAPI(void)  cvClearSet( CvSet* set_header );
    01138
    01139 /* Creates new graph */
    01140 CVAPI(CvGraph*)  cvCreateGraph( int graph_flags, int header_size,
    01141                                 int vtx_size, int edge_size,
    01142                                 CvMemStorage* storage );
    01143
    01144 /* Adds new vertex to the graph */
    01145 CVAPI(int)  cvGraphAddVtx( CvGraph* graph, const CvGraphVtx* vtx CV_DEFAULT(NULL),
    01146                            CvGraphVtx** inserted_vtx CV_DEFAULT(NULL) );
    01147
    01148
    01149 /* Removes vertex from the graph together with all incident edges */
    01150 CVAPI(int)  cvGraphRemoveVtx( CvGraph* graph, int index );
    01151 CVAPI(int)  cvGraphRemoveVtxByPtr( CvGraph* graph, CvGraphVtx* vtx );
    01152
    01153
    01154 /* Link two vertices specifed by indices or pointers if they
    01155    are not connected or return pointer to already existing edge
    01156    connecting the vertices.
    01157    Functions return 1 if a new edge was created, 0 otherwise */
    01158 CVAPI(int)  cvGraphAddEdge( CvGraph* graph,
    01159                             int start_idx, int end_idx,
    01160                             const CvGraphEdge* edge CV_DEFAULT(NULL),
    01161                             CvGraphEdge** inserted_edge CV_DEFAULT(NULL) );
    01162
    01163 CVAPI(int)  cvGraphAddEdgeByPtr( CvGraph* graph,
    01164                                CvGraphVtx* start_vtx, CvGraphVtx* end_vtx,
    01165                                const CvGraphEdge* edge CV_DEFAULT(NULL),
    01166                                CvGraphEdge** inserted_edge CV_DEFAULT(NULL) );
    01167
    01168 /* Remove edge connecting two vertices */
    01169 CVAPI(void)  cvGraphRemoveEdge( CvGraph* graph, int start_idx, int end_idx );
    01170 CVAPI(void)  cvGraphRemoveEdgeByPtr( CvGraph* graph, CvGraphVtx* start_vtx,
    01171                                      CvGraphVtx* end_vtx );
    01172
    01173 /* Find edge connecting two vertices */
    01174 CVAPI(CvGraphEdge*)  cvFindGraphEdge( const CvGraph* graph, int start_idx, int end_idx );
    01175 CVAPI(CvGraphEdge*)  cvFindGraphEdgeByPtr( const CvGraph* graph,
    01176                                            const CvGraphVtx* start_vtx,
    01177                                            const CvGraphVtx* end_vtx );
    01178 #define cvGraphFindEdge cvFindGraphEdge
    01179 #define cvGraphFindEdgeByPtr cvFindGraphEdgeByPtr
    01180
    01181 /* Remove all vertices and edges from the graph */
    01182 CVAPI(void)  cvClearGraph( CvGraph* graph );
    01183
    01184
    01185 /* Count number of edges incident to the vertex */
    01186 CVAPI(int)  cvGraphVtxDegree( const CvGraph* graph, int vtx_idx );
    01187 CVAPI(int)  cvGraphVtxDegreeByPtr( const CvGraph* graph, const CvGraphVtx* vtx );
    01188
    01189
    01190 /* Retrieves graph vertex by given index */
    01191 #define cvGetGraphVtx( graph, idx ) (CvGraphVtx*)cvGetSetElem((CvSet*)(graph), (idx))
    01192
    01193 /* Retrieves index of a graph vertex given its pointer */
    01194 #define cvGraphVtxIdx( graph, vtx ) ((vtx)->flags & CV_SET_ELEM_IDX_MASK)
    01195
    01196 /* Retrieves index of a graph edge given its pointer */
    01197 #define cvGraphEdgeIdx( graph, edge ) ((edge)->flags & CV_SET_ELEM_IDX_MASK)
    01198
    01199 #define cvGraphGetVtxCount( graph ) ((graph)->active_count)
    01200 #define cvGraphGetEdgeCount( graph ) ((graph)->edges->active_count)
    01201
    01202 #define  CV_GRAPH_VERTEX        1
    01203 #define  CV_GRAPH_TREE_EDGE     2
    01204 #define  CV_GRAPH_BACK_EDGE     4
    01205 #define  CV_GRAPH_FORWARD_EDGE  8
    01206 #define  CV_GRAPH_CROSS_EDGE    16
    01207 #define  CV_GRAPH_ANY_EDGE      30
    01208 #define  CV_GRAPH_NEW_TREE      32
    01209 #define  CV_GRAPH_BACKTRACKING  64
    01210 #define  CV_GRAPH_OVER          -1
    01211
    01212 #define  CV_GRAPH_ALL_ITEMS    -1
    01213
    01214 /* flags for graph vertices and edges */
    01215 #define  CV_GRAPH_ITEM_VISITED_FLAG  (1 << 30)
    01216 #define  CV_IS_GRAPH_VERTEX_VISITED(vtx) \
    01217     (((CvGraphVtx*)(vtx))->flags & CV_GRAPH_ITEM_VISITED_FLAG)
    01218 #define  CV_IS_GRAPH_EDGE_VISITED(edge) \
    01219     (((CvGraphEdge*)(edge))->flags & CV_GRAPH_ITEM_VISITED_FLAG)
    01220 #define  CV_GRAPH_SEARCH_TREE_NODE_FLAG   (1 << 29)
    01221 #define  CV_GRAPH_FORWARD_EDGE_FLAG       (1 << 28)
    01222
    01223 typedef struct CvGraphScanner
    01224 {
    01225     CvGraphVtx* vtx;       /* current graph vertex (or current edge origin) */
    01226     CvGraphVtx* dst;       /* current graph edge destination vertex */
    01227     CvGraphEdge* edge;     /* current edge */
    01228
    01229     CvGraph* graph;        /* the graph */
    01230     CvSeq*   stack;        /* the graph vertex stack */
    01231     int      index;        /* the lower bound of certainly visited vertices */
    01232     int      mask;         /* event mask */
    01233 }
    01234 CvGraphScanner;
    01235
    01236 /* Creates new graph scanner. */
    01237 CVAPI(CvGraphScanner*)  cvCreateGraphScanner( CvGraph* graph,
    01238                                              CvGraphVtx* vtx CV_DEFAULT(NULL),
    01239                                              int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS));
    01240
    01241 /* Releases graph scanner. */
    01242 CVAPI(void) cvReleaseGraphScanner( CvGraphScanner** scanner );
    01243
    01244 /* Get next graph element */
    01245 CVAPI(int)  cvNextGraphItem( CvGraphScanner* scanner );
    01246
    01247 /* Creates a copy of graph */
    01248 CVAPI(CvGraph*) cvCloneGraph( const CvGraph* graph, CvMemStorage* storage );
    01249
    01250 /****************************************************************************************\
    01251 *                                     Drawing                                            *
    01252 \****************************************************************************************/
    01253
    01254 /****************************************************************************************\
    01255 *       Drawing functions work with images/matrices of arbitrary type.                   *
    01256 *       For color images the channel order is BGR[A]                                     *
    01257 *       Antialiasing is supported only for 8-bit image now.                              *
    01258 *       All the functions include parameter color that means rgb value (that may be      *
    01259 *       constructed with CV_RGB macro) for color images and brightness                   *
    01260 *       for grayscale images.                                                            *
    01261 *       If a drawn figure is partially or completely outside of the image, it is clipped.*
    01262 \****************************************************************************************/
    01263
    01264 #define CV_RGB( r, g, b )  cvScalar( (b), (g), (r), 0 )
    01265 #define CV_FILLED -1
    01266
    01267 #define CV_AA 16
    01268
    01269 /* Draws 4-connected, 8-connected or antialiased line segment connecting two points */
    01270 CVAPI(void)  cvLine( CvArr* img, CvPoint pt1, CvPoint pt2,
    01271                      CvScalar color, int thickness CV_DEFAULT(1),
    01272                      int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
    01273
    01274 /* Draws a rectangle given two opposite corners of the rectangle (pt1 & pt2),
    01275    if thickness<0 (e.g. thickness == CV_FILLED), the filled box is drawn */
    01276 CVAPI(void)  cvRectangle( CvArr* img, CvPoint pt1, CvPoint pt2,
    01277                           CvScalar color, int thickness CV_DEFAULT(1),
    01278                           int line_type CV_DEFAULT(8),
    01279                           int shift CV_DEFAULT(0));
    01280
    01281 /* Draws a rectangle specified by a CvRect structure */
    01282 CVAPI(void)  cvRectangleR( CvArr* img, CvRect r,
    01283                            CvScalar color, int thickness CV_DEFAULT(1),
    01284                            int line_type CV_DEFAULT(8),
    01285                            int shift CV_DEFAULT(0));
    01286
    01287
    01288 /* Draws a circle with specified center and radius.
    01289    Thickness works in the same way as with cvRectangle */
    01290 CVAPI(void)  cvCircle( CvArr* img, CvPoint center, int radius,
    01291                        CvScalar color, int thickness CV_DEFAULT(1),
    01292                        int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
    01293
    01294 /* Draws ellipse outline, filled ellipse, elliptic arc or filled elliptic sector,
    01295    depending on <thickness>, <start_angle> and <end_angle> parameters. The resultant figure
    01296    is rotated by <angle>. All the angles are in degrees */
    01297 CVAPI(void)  cvEllipse( CvArr* img, CvPoint center, CvSize axes,
    01298                         double angle, double start_angle, double end_angle,
    01299                         CvScalar color, int thickness CV_DEFAULT(1),
    01300                         int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
    01301
    01302 CV_INLINE  void  cvEllipseBox( CvArr* img, CvBox2D box, CvScalar color,
    01303                                int thickness CV_DEFAULT(1),
    01304                                int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) )
    01305 {
    01306     CvSize axes;
    01307     axes.width = cvRound(box.size.width*0.5);
    01308     axes.height = cvRound(box.size.height*0.5);
    01309
    01310     cvEllipse( img, cvPointFrom32f( box.center ), axes, box.angle,
    01311                0, 360, color, thickness, line_type, shift );
    01312 }
    01313
    01314 /* Fills convex or monotonous polygon. */
    01315 CVAPI(void)  cvFillConvexPoly( CvArr* img, const CvPoint* pts, int npts, CvScalar color,
    01316                                int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
    01317
    01318 /* Fills an area bounded by one or more arbitrary polygons */
    01319 CVAPI(void)  cvFillPoly( CvArr* img, CvPoint** pts, const int* npts,
    01320                          int contours, CvScalar color,
    01321                          int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
    01322
    01323 /* Draws one or more polygonal curves */
    01324 CVAPI(void)  cvPolyLine( CvArr* img, CvPoint** pts, const int* npts, int contours,
    01325                          int is_closed, CvScalar color, int thickness CV_DEFAULT(1),
    01326                          int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
    01327
    01328 #define cvDrawRect cvRectangle
    01329 #define cvDrawLine cvLine
    01330 #define cvDrawCircle cvCircle
    01331 #define cvDrawEllipse cvEllipse
    01332 #define cvDrawPolyLine cvPolyLine
    01333
    01334 /* Clips the line segment connecting *pt1 and *pt2
    01335    by the rectangular window
    01336    (0<=x<img_size.width, 0<=y<img_size.height). */
    01337 CVAPI(int) cvClipLine( CvSize img_size, CvPoint* pt1, CvPoint* pt2 );
    01338
    01339 /* Initializes line iterator. Initially, line_iterator->ptr will point
    01340    to pt1 (or pt2, see left_to_right description) location in the image.
    01341    Returns the number of pixels on the line between the ending points. */
    01342 CVAPI(int)  cvInitLineIterator( const CvArr* image, CvPoint pt1, CvPoint pt2,
    01343                                 CvLineIterator* line_iterator,
    01344                                 int connectivity CV_DEFAULT(8),
    01345                                 int left_to_right CV_DEFAULT(0));
    01346
    01347 /* Moves iterator to the next line point */
    01348 #define CV_NEXT_LINE_POINT( line_iterator )                     \
    01349 {                                                               \
    01350     int _line_iterator_mask = (line_iterator).err < 0 ? -1 : 0; \
    01351     (line_iterator).err += (line_iterator).minus_delta +        \
    01352         ((line_iterator).plus_delta & _line_iterator_mask);     \
    01353     (line_iterator).ptr += (line_iterator).minus_step +         \
    01354         ((line_iterator).plus_step & _line_iterator_mask);      \
    01355 }
    01356
    01357
    01358 /* basic font types */
    01359 #define CV_FONT_HERSHEY_SIMPLEX         0
    01360 #define CV_FONT_HERSHEY_PLAIN           1
    01361 #define CV_FONT_HERSHEY_DUPLEX          2
    01362 #define CV_FONT_HERSHEY_COMPLEX         3
    01363 #define CV_FONT_HERSHEY_TRIPLEX         4
    01364 #define CV_FONT_HERSHEY_COMPLEX_SMALL   5
    01365 #define CV_FONT_HERSHEY_SCRIPT_SIMPLEX  6
    01366 #define CV_FONT_HERSHEY_SCRIPT_COMPLEX  7
    01367
    01368 /* font flags */
    01369 #define CV_FONT_ITALIC                 16
    01370
    01371 #define CV_FONT_VECTOR0    CV_FONT_HERSHEY_SIMPLEX
    01372
    01373
    01374 /* Font structure */
    01375 typedef struct CvFont
    01376 {
    01377         const char* nameFont;           //Qt:nameFont
    01378         CvScalar color;                         //Qt:ColorFont -> cvScalar(blue_component, green_component, red\_component[, alpha_component])
    01379     int         font_face;              //Qt: bool italic         /* =CV_FONT_* */
    01380     const int*  ascii;                  /* font data and metrics */
    01381     const int*  greek;
    01382     const int*  cyrillic;
    01383     float       hscale, vscale;
    01384     float       shear;                  /* slope coefficient: 0 - normal, >0 - italic */
    01385     int         thickness;              //Qt: weight               /* letters thickness */
    01386     float       dx;                     /* horizontal interval between letters */
    01387     int         line_type;              //Qt: PointSize
    01388 }
    01389 CvFont;
    01390
    01391 /* Initializes font structure used further in cvPutText */
    01392 CVAPI(void)  cvInitFont( CvFont* font, int font_face,
    01393                          double hscale, double vscale,
    01394                          double shear CV_DEFAULT(0),
    01395                          int thickness CV_DEFAULT(1),
    01396                          int line_type CV_DEFAULT(8));
    01397
    01398 CV_INLINE CvFont cvFont( double scale, int thickness CV_DEFAULT(1) )
    01399 {
    01400     CvFont font;
    01401     cvInitFont( &font, CV_FONT_HERSHEY_PLAIN, scale, scale, 0, thickness, CV_AA );
    01402     return font;
    01403 }
    01404
    01405 /* Renders text stroke with specified font and color at specified location.
    01406    CvFont should be initialized with cvInitFont */
    01407 CVAPI(void)  cvPutText( CvArr* img, const char* text, CvPoint org,
    01408                         const CvFont* font, CvScalar color );
    01409
    01410 /* Calculates bounding box of text stroke (useful for alignment) */
    01411 CVAPI(void)  cvGetTextSize( const char* text_string, const CvFont* font,
    01412                             CvSize* text_size, int* baseline );
    01413
    01414
    01415
    01416 /* Unpacks color value, if arrtype is CV_8UC?, <color> is treated as
    01417    packed color value, otherwise the first channels (depending on arrtype)
    01418    of destination scalar are set to the same value = <color> */
    01419 CVAPI(CvScalar)  cvColorToScalar( double packed_color, int arrtype );
    01420
    01421 /* Returns the polygon points which make up the given ellipse.  The ellipse is define by
    01422    the box of size 'axes' rotated 'angle' around the 'center'.  A partial sweep
    01423    of the ellipse arc can be done by spcifying arc_start and arc_end to be something
    01424    other than 0 and 360, respectively.  The input array 'pts' must be large enough to
    01425    hold the result.  The total number of points stored into 'pts' is returned by this
    01426    function. */
    01427 CVAPI(int) cvEllipse2Poly( CvPoint center, CvSize axes,
    01428                  int angle, int arc_start, int arc_end, CvPoint * pts, int delta );
    01429
    01430 /* Draws contour outlines or filled interiors on the image */
    01431 CVAPI(void)  cvDrawContours( CvArr *img, CvSeq* contour,
    01432                              CvScalar external_color, CvScalar hole_color,
    01433                              int max_level, int thickness CV_DEFAULT(1),
    01434                              int line_type CV_DEFAULT(8),
    01435                              CvPoint offset CV_DEFAULT(cvPoint(0,0)));
    01436
    01437 /* Does look-up transformation. Elements of the source array
    01438    (that should be 8uC1 or 8sC1) are used as indexes in lutarr 256-element table */
    01439 CVAPI(void) cvLUT( const CvArr* src, CvArr* dst, const CvArr* lut );
    01440
    01441
    01442 /******************* Iteration through the sequence tree *****************/
    01443 typedef struct CvTreeNodeIterator
    01444 {
    01445     const void* node;
    01446     int level;
    01447     int max_level;
    01448 }
    01449 CvTreeNodeIterator;
    01450
    01451 CVAPI(void) cvInitTreeNodeIterator( CvTreeNodeIterator* tree_iterator,
    01452                                    const void* first, int max_level );
    01453 CVAPI(void*) cvNextTreeNode( CvTreeNodeIterator* tree_iterator );
    01454 CVAPI(void*) cvPrevTreeNode( CvTreeNodeIterator* tree_iterator );
    01455
    01456 /* Inserts sequence into tree with specified "parent" sequence.
    01457    If parent is equal to frame (e.g. the most external contour),
    01458    then added contour will have null pointer to parent. */
    01459 CVAPI(void) cvInsertNodeIntoTree( void* node, void* parent, void* frame );
    01460
    01461 /* Removes contour from tree (together with the contour children). */
    01462 CVAPI(void) cvRemoveNodeFromTree( void* node, void* frame );
    01463
    01464 /* Gathers pointers to all the sequences,
    01465    accessible from the <first>, to the single sequence */
    01466 CVAPI(CvSeq*) cvTreeToNodeSeq( const void* first, int header_size,
    01467                               CvMemStorage* storage );
    01468
    01469 /* The function implements the K-means algorithm for clustering an array of sample
    01470    vectors in a specified number of classes */
    01471 #define CV_KMEANS_USE_INITIAL_LABELS    1
    01472 CVAPI(int) cvKMeans2( const CvArr* samples, int cluster_count, CvArr* labels,
    01473                       CvTermCriteria termcrit, int attempts CV_DEFAULT(1),
    01474                       CvRNG* rng CV_DEFAULT(0), int flags CV_DEFAULT(0),
    01475                       CvArr* _centers CV_DEFAULT(0), double* compactness CV_DEFAULT(0) );
    01476
    01477 /****************************************************************************************\
    01478 *                                    System functions                                    *
    01479 \****************************************************************************************/
    01480
    01481 /* Add the function pointers table with associated information to the IPP primitives list */
    01482 CVAPI(int)  cvRegisterModule( const CvModuleInfo* module_info );
    01483
    01484 /* Loads optimized functions from IPP, MKL etc. or switches back to pure C code */
    01485 CVAPI(int)  cvUseOptimized( int on_off );
    01486
    01487 /* Retrieves information about the registered modules and loaded optimized plugins */
    01488 CVAPI(void)  cvGetModuleInfo( const char* module_name,
    01489                               const char** version,
    01490                               const char** loaded_addon_plugins );
    01491
    01492 typedef void* (CV_CDECL *CvAllocFunc)(size_t size, void* userdata);
    01493 typedef int (CV_CDECL *CvFreeFunc)(void* pptr, void* userdata);
    01494
    01495 /* Set user-defined memory managment functions (substitutors for malloc and free) that
    01496    will be called by cvAlloc, cvFree and higher-level functions (e.g. cvCreateImage) */
    01497 CVAPI(void) cvSetMemoryManager( CvAllocFunc alloc_func CV_DEFAULT(NULL),
    01498                                CvFreeFunc free_func CV_DEFAULT(NULL),
    01499                                void* userdata CV_DEFAULT(NULL));
    01500
    01501
    01502 typedef IplImage* (CV_STDCALL* Cv_iplCreateImageHeader)
    01503                             (int,int,int,char*,char*,int,int,int,int,int,
    01504                             IplROI*,IplImage*,void*,IplTileInfo*);
    01505 typedef void (CV_STDCALL* Cv_iplAllocateImageData)(IplImage*,int,int);
    01506 typedef void (CV_STDCALL* Cv_iplDeallocate)(IplImage*,int);
    01507 typedef IplROI* (CV_STDCALL* Cv_iplCreateROI)(int,int,int,int,int);
    01508 typedef IplImage* (CV_STDCALL* Cv_iplCloneImage)(const IplImage*);
    01509
    01510 /* Makes OpenCV use IPL functions for IplImage allocation/deallocation */
    01511 CVAPI(void) cvSetIPLAllocators( Cv_iplCreateImageHeader create_header,
    01512                                Cv_iplAllocateImageData allocate_data,
    01513                                Cv_iplDeallocate deallocate,
    01514                                Cv_iplCreateROI create_roi,
    01515                                Cv_iplCloneImage clone_image );
    01516
    01517 #define CV_TURN_ON_IPL_COMPATIBILITY()                                  \
    01518     cvSetIPLAllocators( iplCreateImageHeader, iplAllocateImage,         \
    01519                         iplDeallocate, iplCreateROI, iplCloneImage )
    01520
    01521 /****************************************************************************************\
    01522 *                                    Data Persistence                                    *
    01523 \****************************************************************************************/
    01524
    01525 /********************************** High-level functions ********************************/
    01526
    01527 /* opens existing or creates new file storage */
    01528 CVAPI(CvFileStorage*)  cvOpenFileStorage( const char* filename,
    01529                                           CvMemStorage* memstorage,
    01530                                           int flags );
    01531
    01532 /* closes file storage and deallocates buffers */
    01533 CVAPI(void) cvReleaseFileStorage( CvFileStorage** fs );
    01534
    01535 /* returns attribute value or 0 (NULL) if there is no such attribute */
    01536 CVAPI(const char*) cvAttrValue( const CvAttrList* attr, const char* attr_name );
    01537
    01538 /* starts writing compound structure (map or sequence) */
    01539 CVAPI(void) cvStartWriteStruct( CvFileStorage* fs, const char* name,
    01540                                 int struct_flags, const char* type_name CV_DEFAULT(NULL),
    01541                                 CvAttrList attributes CV_DEFAULT(cvAttrList()));
    01542
    01543 /* finishes writing compound structure */
    01544 CVAPI(void) cvEndWriteStruct( CvFileStorage* fs );
    01545
    01546 /* writes an integer */
    01547 CVAPI(void) cvWriteInt( CvFileStorage* fs, const char* name, int value );
    01548
    01549 /* writes a floating-point number */
    01550 CVAPI(void) cvWriteReal( CvFileStorage* fs, const char* name, double value );
    01551
    01552 /* writes a string */
    01553 CVAPI(void) cvWriteString( CvFileStorage* fs, const char* name,
    01554                            const char* str, int quote CV_DEFAULT(0) );
    01555
    01556 /* writes a comment */
    01557 CVAPI(void) cvWriteComment( CvFileStorage* fs, const char* comment,
    01558                             int eol_comment );
    01559
    01560 /* writes instance of a standard type (matrix, image, sequence, graph etc.)
    01561    or user-defined type */
    01562 CVAPI(void) cvWrite( CvFileStorage* fs, const char* name, const void* ptr,
    01563                          CvAttrList attributes CV_DEFAULT(cvAttrList()));
    01564
    01565 /* starts the next stream */
    01566 CVAPI(void) cvStartNextStream( CvFileStorage* fs );
    01567
    01568 /* helper function: writes multiple integer or floating-point numbers */
    01569 CVAPI(void) cvWriteRawData( CvFileStorage* fs, const void* src,
    01570                                 int len, const char* dt );
    01571
    01572 /* returns the hash entry corresponding to the specified literal key string or 0
    01573    if there is no such a key in the storage */
    01574 CVAPI(CvStringHashNode*) cvGetHashedKey( CvFileStorage* fs, const char* name,
    01575                                         int len CV_DEFAULT(-1),
    01576                                         int create_missing CV_DEFAULT(0));
    01577
    01578 /* returns file node with the specified key within the specified map
    01579    (collection of named nodes) */
    01580 CVAPI(CvFileNode*) cvGetRootFileNode( const CvFileStorage* fs,
    01581                                      int stream_index CV_DEFAULT(0) );
    01582
    01583 /* returns file node with the specified key within the specified map
    01584    (collection of named nodes) */
    01585 CVAPI(CvFileNode*) cvGetFileNode( CvFileStorage* fs, CvFileNode* map,
    01586                                  const CvStringHashNode* key,
    01587                                  int create_missing CV_DEFAULT(0) );
    01588
    01589 /* this is a slower version of cvGetFileNode that takes the key as a literal string */
    01590 CVAPI(CvFileNode*) cvGetFileNodeByName( const CvFileStorage* fs,
    01591                                        const CvFileNode* map,
    01592                                        const char* name );
    01593
    01594 CV_INLINE int cvReadInt( const CvFileNode* node, int default_value CV_DEFAULT(0) )
    01595 {
    01596     return !node ? default_value :
    01597         CV_NODE_IS_INT(node->tag) ? node->data.i :
    01598         CV_NODE_IS_REAL(node->tag) ? cvRound(node->data.f) : 0x7fffffff;
    01599 }
    01600
    01601
    01602 CV_INLINE int cvReadIntByName( const CvFileStorage* fs, const CvFileNode* map,
    01603                          const char* name, int default_value CV_DEFAULT(0) )
    01604 {
    01605     return cvReadInt( cvGetFileNodeByName( fs, map, name ), default_value );
    01606 }
    01607
    01608
    01609 CV_INLINE double cvReadReal( const CvFileNode* node, double default_value CV_DEFAULT(0.) )
    01610 {
    01611     return !node ? default_value :
    01612         CV_NODE_IS_INT(node->tag) ? (double)node->data.i :
    01613         CV_NODE_IS_REAL(node->tag) ? node->data.f : 1e300;
    01614 }
    01615
    01616
    01617 CV_INLINE double cvReadRealByName( const CvFileStorage* fs, const CvFileNode* map,
    01618                         const char* name, double default_value CV_DEFAULT(0.) )
    01619 {
    01620     return cvReadReal( cvGetFileNodeByName( fs, map, name ), default_value );
    01621 }
    01622
    01623
    01624 CV_INLINE const char* cvReadString( const CvFileNode* node,
    01625                         const char* default_value CV_DEFAULT(NULL) )
    01626 {
    01627     return !node ? default_value : CV_NODE_IS_STRING(node->tag) ? node->data.str.ptr : 0;
    01628 }
    01629
    01630
    01631 CV_INLINE const char* cvReadStringByName( const CvFileStorage* fs, const CvFileNode* map,
    01632                         const char* name, const char* default_value CV_DEFAULT(NULL) )
    01633 {
    01634     return cvReadString( cvGetFileNodeByName( fs, map, name ), default_value );
    01635 }
    01636
    01637
    01638 /* decodes standard or user-defined object and returns it */
    01639 CVAPI(void*) cvRead( CvFileStorage* fs, CvFileNode* node,
    01640                         CvAttrList* attributes CV_DEFAULT(NULL));
    01641
    01642 /* decodes standard or user-defined object and returns it */
    01643 CV_INLINE void* cvReadByName( CvFileStorage* fs, const CvFileNode* map,
    01644                               const char* name, CvAttrList* attributes CV_DEFAULT(NULL) )
    01645 {
    01646     return cvRead( fs, cvGetFileNodeByName( fs, map, name ), attributes );
    01647 }
    01648
    01649
    01650 /* starts reading data from sequence or scalar numeric node */
    01651 CVAPI(void) cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src,
    01652                                CvSeqReader* reader );
    01653
    01654 /* reads multiple numbers and stores them to array */
    01655 CVAPI(void) cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader,
    01656                                int count, void* dst, const char* dt );
    01657
    01658 /* combination of two previous functions for easier reading of whole sequences */
    01659 CVAPI(void) cvReadRawData( const CvFileStorage* fs, const CvFileNode* src,
    01660                           void* dst, const char* dt );
    01661
    01662 /* writes a copy of file node to file storage */
    01663 CVAPI(void) cvWriteFileNode( CvFileStorage* fs, const char* new_node_name,
    01664                             const CvFileNode* node, int embed );
    01665
    01666 /* returns name of file node */
    01667 CVAPI(const char*) cvGetFileNodeName( const CvFileNode* node );
    01668
    01669 /*********************************** Adding own types ***********************************/
    01670
    01671 CVAPI(void) cvRegisterType( const CvTypeInfo* info );
    01672 CVAPI(void) cvUnregisterType( const char* type_name );
    01673 CVAPI(CvTypeInfo*) cvFirstType(void);
    01674 CVAPI(CvTypeInfo*) cvFindType( const char* type_name );
    01675 CVAPI(CvTypeInfo*) cvTypeOf( const void* struct_ptr );
    01676
    01677 /* universal functions */
    01678 CVAPI(void) cvRelease( void** struct_ptr );
    01679 CVAPI(void*) cvClone( const void* struct_ptr );
    01680
    01681 /* simple API for reading/writing data */
    01682 CVAPI(void) cvSave( const char* filename, const void* struct_ptr,
    01683                     const char* name CV_DEFAULT(NULL),
    01684                     const char* comment CV_DEFAULT(NULL),
    01685                     CvAttrList attributes CV_DEFAULT(cvAttrList()));
    01686 CVAPI(void*) cvLoad( const char* filename,
    01687                      CvMemStorage* memstorage CV_DEFAULT(NULL),
    01688                      const char* name CV_DEFAULT(NULL),
    01689                      const char** real_name CV_DEFAULT(NULL) );
    01690
    01691 /*********************************** Measuring Execution Time ***************************/
    01692
    01693 /* helper functions for RNG initialization and accurate time measurement:
    01694    uses internal clock counter on x86 */
    01695 CVAPI(int64)  cvGetTickCount( void );
    01696 CVAPI(double) cvGetTickFrequency( void );
    01697
    01698 /*********************************** CPU capabilities ***********************************/
    01699
    01700 #define CV_CPU_NONE    0
    01701 #define CV_CPU_MMX     1
    01702 #define CV_CPU_SSE     2
    01703 #define CV_CPU_SSE2    3
    01704 #define CV_CPU_SSE3    4
    01705 #define CV_CPU_SSSE3   5
    01706 #define CV_CPU_SSE4_1  6
    01707 #define CV_CPU_SSE4_2  7
    01708 #define CV_CPU_AVX    10
    01709 #define CV_HARDWARE_MAX_FEATURE 255
    01710
    01711 CVAPI(int) cvCheckHardwareSupport(int feature);
    01712
    01713 /*********************************** Multi-Threading ************************************/
    01714
    01715 /* retrieve/set the number of threads used in OpenMP implementations */
    01716 CVAPI(int)  cvGetNumThreads( void );
    01717 CVAPI(void) cvSetNumThreads( int threads CV_DEFAULT(0) );
    01718 /* get index of the thread being executed */
    01719 CVAPI(int)  cvGetThreadNum( void );
    01720
    01721
    01722 /********************************** Error Handling **************************************/
    01723
    01724 /* Get current OpenCV error status */
    01725 CVAPI(int) cvGetErrStatus( void );
    01726
    01727 /* Sets error status silently */
    01728 CVAPI(void) cvSetErrStatus( int status );
    01729
    01730 #define CV_ErrModeLeaf     0   /* Print error and exit program */
    01731 #define CV_ErrModeParent   1   /* Print error and continue */
    01732 #define CV_ErrModeSilent   2   /* Don't print and continue */
    01733
    01734 /* Retrives current error processing mode */
    01735 CVAPI(int)  cvGetErrMode( void );
    01736
    01737 /* Sets error processing mode, returns previously used mode */
    01738 CVAPI(int) cvSetErrMode( int mode );
    01739
    01740 /* Sets error status and performs some additonal actions (displaying message box,
    01741  writing message to stderr, terminating application etc.)
    01742  depending on the current error mode */
    01743 CVAPI(void) cvError( int status, const char* func_name,
    01744                     const char* err_msg, const char* file_name, int line );
    01745
    01746 /* Retrieves textual description of the error given its code */
    01747 CVAPI(const char*) cvErrorStr( int status );
    01748
    01749 /* Retrieves detailed information about the last error occured */
    01750 CVAPI(int) cvGetErrInfo( const char** errcode_desc, const char** description,
    01751                         const char** filename, int* line );
    01752
    01753 /* Maps IPP error codes to the counterparts from OpenCV */
    01754 CVAPI(int) cvErrorFromIppStatus( int ipp_status );
    01755
    01756 typedef int (CV_CDECL *CvErrorCallback)( int status, const char* func_name,
    01757                                         const char* err_msg, const char* file_name, int line, void* userdata );
    01758
    01759 /* Assigns a new error-handling function */
    01760 CVAPI(CvErrorCallback) cvRedirectError( CvErrorCallback error_handler,
    01761                                        void* userdata CV_DEFAULT(NULL),
    01762                                        void** prev_userdata CV_DEFAULT(NULL) );
    01763
    01764 /*
    01765  Output to:
    01766  cvNulDevReport - nothing
    01767  cvStdErrReport - console(fprintf(stderr,...))
    01768  cvGuiBoxReport - MessageBox(WIN32)
    01769  */
    01770 CVAPI(int) cvNulDevReport( int status, const char* func_name, const char* err_msg,
    01771                           const char* file_name, int line, void* userdata );
    01772
    01773 CVAPI(int) cvStdErrReport( int status, const char* func_name, const char* err_msg,
    01774                           const char* file_name, int line, void* userdata );
    01775
    01776 CVAPI(int) cvGuiBoxReport( int status, const char* func_name, const char* err_msg,
    01777                           const char* file_name, int line, void* userdata );
    01778
    01779 #define OPENCV_ERROR(status,func,context)                           \
    01780 cvError((status),(func),(context),__FILE__,__LINE__)
    01781
    01782 #define OPENCV_ERRCHK(func,context)                                 \
    01783 {if (cvGetErrStatus() >= 0)                         \
    01784 {OPENCV_ERROR(CV_StsBackTrace,(func),(context));}}
    01785
    01786 #define OPENCV_ASSERT(expr,func,context)                            \
    01787 {if (! (expr))                                      \
    01788 {OPENCV_ERROR(CV_StsInternal,(func),(context));}}
    01789
    01790 #define OPENCV_RSTERR() (cvSetErrStatus(CV_StsOk))
    01791
    01792 #define OPENCV_CALL( Func )                                         \
    01793 {                                                                   \
    01794 Func;                                                           \
    01795 }
    01796
    01797
    01798 /* CV_FUNCNAME macro defines icvFuncName constant which is used by CV_ERROR macro */
    01799 #ifdef CV_NO_FUNC_NAMES
    01800 #define CV_FUNCNAME( Name )
    01801 #define cvFuncName ""
    01802 #else
    01803 #define CV_FUNCNAME( Name )  \
    01804 static char cvFuncName[] = Name
    01805 #endif
    01806
    01807
    01808 /*
    01809  CV_ERROR macro unconditionally raises error with passed code and message.
    01810  After raising error, control will be transferred to the exit label.
    01811  */
    01812 #define CV_ERROR( Code, Msg )                                       \
    01813 {                                                                   \
    01814     cvError( (Code), cvFuncName, Msg, __FILE__, __LINE__ );        \
    01815     __CV_EXIT__;                                                   \
    01816 }
    01817
    01818 /* Simplified form of CV_ERROR */
    01819 #define CV_ERROR_FROM_CODE( code )   \
    01820     CV_ERROR( code, "" )
    01821
    01822 /*
    01823  CV_CHECK macro checks error status after CV (or IPL)
    01824  function call. If error detected, control will be transferred to the exit
    01825  label.
    01826  */
    01827 #define CV_CHECK()                                                  \
    01828 {                                                                   \
    01829     if( cvGetErrStatus() < 0 )                                      \
    01830         CV_ERROR( CV_StsBackTrace, "Inner function failed." );      \
    01831 }
    01832
    01833
    01834 /*
    01835  CV_CALL macro calls CV (or IPL) function, checks error status and
    01836  signals a error if the function failed. Useful in "parent node"
    01837  error procesing mode
    01838  */
    01839 #define CV_CALL( Func )                                             \
    01840 {                                                                   \
    01841     Func;                                                           \
    01842     CV_CHECK();                                                     \
    01843 }
    01844
    01845
    01846 /* Runtime assertion macro */
    01847 #define CV_ASSERT( Condition )                                          \
    01848 {                                                                       \
    01849     if( !(Condition) )                                                  \
    01850         CV_ERROR( CV_StsInternal, "Assertion: " #Condition " failed" ); \
    01851 }
    01852
    01853 #define __CV_BEGIN__       {
    01854 #define __CV_END__         goto exit; exit: ; }
    01855 #define __CV_EXIT__        goto exit
    01856
    01857 #ifdef __cplusplus
    01858 }
    01859
    01860 // classes for automatic module/RTTI data registration/unregistration
    01861 struct CV_EXPORTS CvModule
    01862 {
    01863     CvModule( CvModuleInfo* _info );
    01864     ~CvModule();
    01865     CvModuleInfo* info;
    01866
    01867     static CvModuleInfo* first;
    01868     static CvModuleInfo* last;
    01869 };
    01870
    01871 struct CV_EXPORTS CvType
    01872 {
    01873     CvType( const char* type_name,
    01874             CvIsInstanceFunc is_instance, CvReleaseFunc release=0,
    01875             CvReadFunc read=0, CvWriteFunc write=0, CvCloneFunc clone=0 );
    01876     ~CvType();
    01877     CvTypeInfo* info;
    01878
    01879     static CvTypeInfo* first;
    01880     static CvTypeInfo* last;
    01881 };
    01882
    01883 #endif
    01884
    01885 #endif

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines