cxcore.h
上传用户:soukeisyuu
上传日期:2022-07-03
资源大小:5943k
文件大小:85k
源码类别:

波变换

开发平台:

Visual C++

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