text: /*M///////////////////////////////////////////////////////////////////////////////////////
  //
  //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
  //
  //  By downloading, copying, installing or using the software you agree to this license.
  //  If you do not agree to this license, do not download, install,
  //  copy or use the software.
  //
  //
  //                           License Agreement
  //                For Open Source Computer Vision Library
  //
  // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
  // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
  // Third party copyrights are property of their respective owners.
  //
  // Redistribution and use in source and binary forms, with or without modification,
  // are permitted provided that the following conditions are met:
  //
  //   * Redistribution's of source code must retain the above copyright notice,
  //     this list of conditions and the following disclaimer.
  //
  //   * Redistribution's in binary form must reproduce the above copyright notice,
  //     this list of conditions and the following disclaimer in the documentation
  //     and/or other materials provided with the distribution.
  //
  //   * The name of the copyright holders may not be used to endorse or promote products
  //     derived from this software without specific prior written permission.
  //
  // This software is provided by the copyright holders and contributors "as is" and
  // any express or implied warranties, including, but not limited to, the implied
  // warranties of merchantability and fitness for a particular purpose are disclaimed.
  // In no event shall the Intel Corporation or contributors be liable for any direct,
  // indirect, incidental, special, exemplary, or consequential damages
  // (including, but not limited to, procurement of substitute goods or services;
  // loss of use, data, or profits; or business interruption) however caused
  // and on any theory of liability, whether in contract, strict liability,
  // or tort (including negligence or otherwise) arising in any way out of
  // the use of this software, even if advised of the possibility of such damage.
  //
  //M*/
  
  
  #ifndef __OPENCV_CORE_C_H__
  #define __OPENCV_CORE_C_H__
  
  #include "opencv2/core/types_c.h"
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  /****************************************************************************************\
  *          Array allocation, deallocation, initialization and access to elements         *
  \****************************************************************************************/
  
  /* <malloc> wrapper.
     If there is no enough memory, the function
     (as well as other OpenCV functions that call cvAlloc)
     raises an error. */
  CVAPI(void*)  cvAlloc( size_t size );
  
  /* <free> wrapper.
     Here and further all the memory releasing functions
     (that all call cvFree) take double pointer in order to
     to clear pointer to the data after releasing it.
     Passing pointer to NULL pointer is Ok: nothing happens in this case
  */
  CVAPI(void)   cvFree_( void* ptr );
  #define cvFree(ptr) (cvFree_(*(ptr)), *(ptr)=0)
  
  /* Allocates and initializes IplImage header */
  CVAPI(IplImage*)  cvCreateImageHeader( CvSize size, int depth, int channels );
  
  /* Inializes IplImage header */
  CVAPI(IplImage*) cvInitImageHeader( IplImage* image, CvSize size, int depth,
                                     int channels, int origin CV_DEFAULT(0),
                                     int align CV_DEFAULT(4));
  
  /* Creates IPL image (header and data) */
  CVAPI(IplImage*)  cvCreateImage( CvSize size, int depth, int channels );
  
  /* Releases (i.e. deallocates) IPL image header */
  CVAPI(void)  cvReleaseImageHeader( IplImage** image );
  
  /* Releases IPL image header and data */
  CVAPI(void)  cvReleaseImage( IplImage** image );
  
  /* Creates a copy of IPL image (widthStep may differ) */
  CVAPI(IplImage*) cvCloneImage( const IplImage* image );
  
  /* Sets a Channel Of Interest (only a few functions support COI) -
     use cvCopy to extract the selected channel and/or put it back */
  CVAPI(void)  cvSetImageCOI( IplImage* image, int coi );
  
  /* Retrieves image Channel Of Interest */
  CVAPI(int)  cvGetImageCOI( const IplImage* image );
  
  /* Sets image ROI (region of interest) (COI is not changed) */
  CVAPI(void)  cvSetImageROI( IplImage* image, CvRect rect );
  
  /* Resets image ROI and COI */
  CVAPI(void)  cvResetImageROI( IplImage* image );
  
  /* Retrieves image ROI */
  CVAPI(CvRect) cvGetImageROI( const IplImage* image );
  
  /* Allocates and initializes CvMat header */
  CVAPI(CvMat*)  cvCreateMatHeader( int rows, int cols, int type );
  
  #define CV_AUTOSTEP  0x7fffffff
  
  /* Initializes CvMat header */
  CVAPI(CvMat*) cvInitMatHeader( CvMat* mat, int rows, int cols,
                                int type, void* data CV_DEFAULT(NULL),
                                int step CV_DEFAULT(CV_AUTOSTEP) );
  
  /* Allocates and initializes CvMat header and allocates data */
  CVAPI(CvMat*)  cvCreateMat( int rows, int cols, int type );
  
  /* Releases CvMat header and deallocates matrix data
     (reference counting is used for data) */
  CVAPI(void)  cvReleaseMat( CvMat** mat );
  
  /* Decrements CvMat data reference counter and deallocates the data if
     it reaches 0 */
  CV_INLINE  void  cvDecRefData( CvArr* arr )
  {
      if( CV_IS_MAT( arr ))
      {
          CvMat* mat = (CvMat*)arr;
          mat->data.ptr = NULL;
          if( mat->refcount != NULL && --*mat->refcount == 0 )
              cvFree( &mat->refcount );
          mat->refcount = NULL;
      }
      else if( CV_IS_MATND( arr ))
      {
          CvMatND* mat = (CvMatND*)arr;
          mat->data.ptr = NULL;
          if( mat->refcount != NULL && --*mat->refcount == 0 )
              cvFree( &mat->refcount );
          mat->refcount = NULL;
      }
  }
  
  /* Increments CvMat data reference counter */
  CV_INLINE  int  cvIncRefData( CvArr* arr )
  {
      int refcount = 0;
      if( CV_IS_MAT( arr ))
      {
          CvMat* mat = (CvMat*)arr;
          if( mat->refcount != NULL )
              refcount = ++*mat->refcount;
      }
      else if( CV_IS_MATND( arr ))
      {
          CvMatND* mat = (CvMatND*)arr;
          if( mat->refcount != NULL )
              refcount = ++*mat->refcount;
      }
      return refcount;
  }
  
  
  /* Creates an exact copy of the input matrix (except, may be, step value) */
  CVAPI(CvMat*) cvCloneMat( const CvMat* mat );
  
  
  /* Makes a new matrix from <rect> subrectangle of input array.
     No data is copied */
  CVAPI(CvMat*) cvGetSubRect( const CvArr* arr, CvMat* submat, CvRect rect );
  #define cvGetSubArr cvGetSubRect
  
  /* Selects row span of the input array: arr(start_row:delta_row:end_row,:)
      (end_row is not included into the span). */
  CVAPI(CvMat*) cvGetRows( const CvArr* arr, CvMat* submat,
                          int start_row, int end_row,
                          int delta_row CV_DEFAULT(1));
  
  CV_INLINE  CvMat*  cvGetRow( const CvArr* arr, CvMat* submat, int row )
  {
      return cvGetRows( arr, submat, row, row + 1, 1 );
  }
  
  
  /* Selects column span of the input array: arr(:,start_col:end_col)
     (end_col is not included into the span) */
  CVAPI(CvMat*) cvGetCols( const CvArr* arr, CvMat* submat,
                          int start_col, int end_col );
  
  CV_INLINE  CvMat*  cvGetCol( const CvArr* arr, CvMat* submat, int col )
  {
      return cvGetCols( arr, submat, col, col + 1 );
  }
  
  /* Select a diagonal of the input array.
     (diag = 0 means the main diagonal, >0 means a diagonal above the main one,
     <0 - below the main one).
     The diagonal will be represented as a column (nx1 matrix). */
  CVAPI(CvMat*) cvGetDiag( const CvArr* arr, CvMat* submat,
                              int diag CV_DEFAULT(0));
  
  /* low-level scalar <-> raw data conversion functions */
  CVAPI(void) cvScalarToRawData( const CvScalar* scalar, void* data, int type,
                                int extend_to_12 CV_DEFAULT(0) );
  
  CVAPI(void) cvRawDataToScalar( const void* data, int type, CvScalar* scalar );
  
  /* Allocates and initializes CvMatND header */
  CVAPI(CvMatND*)  cvCreateMatNDHeader( int dims, const int* sizes, int type );
  
  /* Allocates and initializes CvMatND header and allocates data */
  CVAPI(CvMatND*)  cvCreateMatND( int dims, const int* sizes, int type );
  
  /* Initializes preallocated CvMatND header */
  CVAPI(CvMatND*)  cvInitMatNDHeader( CvMatND* mat, int dims, const int* sizes,
                                      int type, void* data CV_DEFAULT(NULL) );
  
  /* Releases CvMatND */
  CV_INLINE  void  cvReleaseMatND( CvMatND** mat )
  {
      cvReleaseMat( (CvMat**)mat );
  }
  
  /* Creates a copy of CvMatND (except, may be, steps) */
  CVAPI(CvMatND*) cvCloneMatND( const CvMatND* mat );
  
  /* Allocates and initializes CvSparseMat header and allocates data */
  // CVAPI(CvSparseMat*)  cvCreateSparseMat( int dims, const int* sizes, int type );
  
  // /* Releases CvSparseMat */
  // CVAPI(void)  cvReleaseSparseMat( CvSparseMat** mat );
  
  // /* Creates a copy of CvSparseMat (except, may be, zero items) */
  // CVAPI(CvSparseMat*) cvCloneSparseMat( const CvSparseMat* mat );
  
  // /* Initializes sparse array iterator
  //    (returns the first node or NULL if the array is empty) */
  // CVAPI(CvSparseNode*) cvInitSparseMatIterator( const CvSparseMat* mat,
  //                                               CvSparseMatIterator* mat_iterator );
  
  // // returns next sparse array node (or NULL if there is no more nodes)
  // CV_INLINE CvSparseNode* cvGetNextSparseNode( CvSparseMatIterator* mat_iterator )
  // {
  //     if( mat_iterator->node->next )
  //         return mat_iterator->node = mat_iterator->node->next;
  //     else
  //     {
  //         int idx;
  //         for( idx = ++mat_iterator->curidx; idx < mat_iterator->mat->hashsize; idx++ )
  //         {
  //             CvSparseNode* node = (CvSparseNode*)mat_iterator->mat->hashtable[idx];
  //             if( node )
  //             {
  //                 mat_iterator->curidx = idx;
  //                 return mat_iterator->node = node;
  //             }
  //         }
  //         return NULL;
  //     }
  // }
  
  /**************** matrix iterator: used for n-ary operations on dense arrays *********/
  
  #define CV_MAX_ARR 10
  
  typedef struct CvNArrayIterator
  {
      int count; /* number of arrays */
      int dims; /* number of dimensions to iterate */
      CvSize size; /* maximal common linear size: { width = size, height = 1 } */
      uchar* ptr[CV_MAX_ARR]; /* pointers to the array slices */
      int stack[CV_MAX_DIM]; /* for internal use */
      CvMatND* hdr[CV_MAX_ARR]; /* pointers to the headers of the
                                   matrices that are processed */
  }
  CvNArrayIterator;
  
  #define CV_NO_DEPTH_CHECK     1
  #define CV_NO_CN_CHECK        2
  #define CV_NO_SIZE_CHECK      4
  
  /* initializes iterator that traverses through several arrays simulteneously
     (the function together with cvNextArraySlice is used for
      N-ari element-wise operations) */
  CVAPI(int) cvInitNArrayIterator( int count, CvArr** arrs,
                                   const CvArr* mask, CvMatND* stubs,
                                   CvNArrayIterator* array_iterator,
                                   int flags CV_DEFAULT(0) );
  
  /* returns zero value if iteration is finished, non-zero (slice length) otherwise */
  CVAPI(int) cvNextNArraySlice( CvNArrayIterator* array_iterator );
  
  
  /* Returns type of array elements:
     CV_8UC1 ... CV_64FC4 ... */
  CVAPI(int) cvGetElemType( const CvArr* arr );
  
  /* Retrieves number of an array dimensions and
     optionally sizes of the dimensions */
  CVAPI(int) cvGetDims( const CvArr* arr, int* sizes CV_DEFAULT(NULL) );
  
  
  /* Retrieves size of a particular array dimension.
     For 2d arrays cvGetDimSize(arr,0) returns number of rows (image height)
     and cvGetDimSize(arr,1) returns number of columns (image width) */
  CVAPI(int) cvGetDimSize( const CvArr* arr, int index );
  
  
  /* ptr = &arr(idx0,idx1,...). All indexes are zero-based,
     the major dimensions go first (e.g. (y,x) for 2D, (z,y,x) for 3D */
  CVAPI(uchar*) cvPtr1D( const CvArr* arr, int idx0, int* type CV_DEFAULT(NULL));
  CVAPI(uchar*) cvPtr2D( const CvArr* arr, int idx0, int idx1, int* type CV_DEFAULT(NULL) );
  CVAPI(uchar*) cvPtr3D( const CvArr* arr, int idx0, int idx1, int idx2,
                        int* type CV_DEFAULT(NULL));
  
  /* For CvMat or IplImage number of indices should be 2
     (row index (y) goes first, column index (x) goes next).
     For CvMatND or CvSparseMat number of infices should match number of <dims> and
     indices order should match the array dimension order. */
  CVAPI(uchar*) cvPtrND( const CvArr* arr, const int* idx, int* type CV_DEFAULT(NULL),
                        int create_node CV_DEFAULT(1),
                        unsigned* precalc_hashval CV_DEFAULT(NULL));
  
  /* value = arr(idx0,idx1,...) */
  CVAPI(CvScalar) cvGet1D( const CvArr* arr, int idx0 );
  CVAPI(CvScalar) cvGet2D( const CvArr* arr, int idx0, int idx1 );
  CVAPI(CvScalar) cvGet3D( const CvArr* arr, int idx0, int idx1, int idx2 );
  CVAPI(CvScalar) cvGetND( const CvArr* arr, const int* idx );
  
  /* for 1-channel arrays */
  CVAPI(double) cvGetReal1D( const CvArr* arr, int idx0 );
  CVAPI(double) cvGetReal2D( const CvArr* arr, int idx0, int idx1 );
  CVAPI(double) cvGetReal3D( const CvArr* arr, int idx0, int idx1, int idx2 );
  CVAPI(double) cvGetRealND( const CvArr* arr, const int* idx );
  
  /* arr(idx0,idx1,...) = value */
  CVAPI(void) cvSet1D( CvArr* arr, int idx0, CvScalar value );
  CVAPI(void) cvSet2D( CvArr* arr, int idx0, int idx1, CvScalar value );
  CVAPI(void) cvSet3D( CvArr* arr, int idx0, int idx1, int idx2, CvScalar value );
  CVAPI(void) cvSetND( CvArr* arr, const int* idx, CvScalar value );
  
  /* for 1-channel arrays */
  CVAPI(void) cvSetReal1D( CvArr* arr, int idx0, double value );
  CVAPI(void) cvSetReal2D( CvArr* arr, int idx0, int idx1, double value );
  CVAPI(void) cvSetReal3D( CvArr* arr, int idx0,
                          int idx1, int idx2, double value );
  CVAPI(void) cvSetRealND( CvArr* arr, const int* idx, double value );
  
  /* clears element of ND dense array,
     in case of sparse arrays it deletes the specified node */
  CVAPI(void) cvClearND( CvArr* arr, const int* idx );
  
  /* Converts CvArr (IplImage or CvMat,...) to CvMat.
     If the last parameter is non-zero, function can
     convert multi(>2)-dimensional array to CvMat as long as
     the last array's dimension is continous. The resultant
     matrix will be have appropriate (a huge) number of rows */
  CVAPI(CvMat*) cvGetMat( const CvArr* arr, CvMat* header,
                         int* coi CV_DEFAULT(NULL),
                         int allowND CV_DEFAULT(0));
  
  /* Converts CvArr (IplImage or CvMat) to IplImage */
  CVAPI(IplImage*) cvGetImage( const CvArr* arr, IplImage* image_header );
  
  
  /* Changes a shape of multi-dimensional array.
     new_cn == 0 means that number of channels remains unchanged.
     new_dims == 0 means that number and sizes of dimensions remain the same
     (unless they need to be changed to set the new number of channels)
     if new_dims == 1, there is no need to specify new dimension sizes
     The resultant configuration should be achievable w/o data copying.
     If the resultant array is sparse, CvSparseMat header should be passed
     to the function else if the result is 1 or 2 dimensional,
     CvMat header should be passed to the function
     else CvMatND header should be passed */
  CVAPI(CvArr*) cvReshapeMatND( const CvArr* arr,
                               int sizeof_header, CvArr* header,
                               int new_cn, int new_dims, int* new_sizes );
  
  #define cvReshapeND( arr, header, new_cn, new_dims, new_sizes )   \
        cvReshapeMatND( (arr), sizeof(*(header)), (header),         \
                        (new_cn), (new_dims), (new_sizes))
  
  CVAPI(CvMat*) cvReshape( const CvArr* arr, CvMat* header,
                          int new_cn, int new_rows CV_DEFAULT(0) );
  
  /* Repeats source 2d array several times in both horizontal and
     vertical direction to fill destination array */
  CVAPI(void) cvRepeat( const CvArr* src, CvArr* dst );
  
  /* Allocates array data */
  CVAPI(void)  cvCreateData( CvArr* arr );
  
  /* Releases array data */
  CVAPI(void)  cvReleaseData( CvArr* arr );
  
  /* Attaches user data to the array header. The step is reffered to
     the pre-last dimension. That is, all the planes of the array
     must be joint (w/o gaps) */
  CVAPI(void)  cvSetData( CvArr* arr, void* data, int step );
  
  /* Retrieves raw data of CvMat, IplImage or CvMatND.
     In the latter case the function raises an error if
     the array can not be represented as a matrix */
  CVAPI(void) cvGetRawData( const CvArr* arr, uchar** data,
                           int* step CV_DEFAULT(NULL),
                           CvSize* roi_size CV_DEFAULT(NULL));
  
  /* Returns width and height of array in elements */
  CVAPI(CvSize) cvGetSize( const CvArr* arr );
  
  /* Copies source array to destination array */
  CVAPI(void)  cvCopy( const CvArr* src, CvArr* dst,
                       const CvArr* mask CV_DEFAULT(NULL) );
  
  /* Sets all or "masked" elements of input array
     to the same value*/
  CVAPI(void)  cvSet( CvArr* arr, CvScalar value,
                      const CvArr* mask CV_DEFAULT(NULL) );
  
  /* Clears all the array elements (sets them to 0) */
  CVAPI(void)  cvSetZero( CvArr* arr );
  #define cvZero  cvSetZero
  
  
  /* Splits a multi-channel array into the set of single-channel arrays or
     extracts particular [color] plane */
  CVAPI(void)  cvSplit( const CvArr* src, CvArr* dst0, CvArr* dst1,
                        CvArr* dst2, CvArr* dst3 );
  
  /* Merges a set of single-channel arrays into the single multi-channel array
     or inserts one particular [color] plane to the array */
  CVAPI(void)  cvMerge( const CvArr* src0, const CvArr* src1,
                        const CvArr* src2, const CvArr* src3,
                        CvArr* dst );
  
  /* Copies several channels from input arrays to
     certain channels of output arrays */
  CVAPI(void)  cvMixChannels( const CvArr** src, int src_count,
                              CvArr** dst, int dst_count,
                              const int* from_to, int pair_count );
  
  /* Performs linear transformation on every source array element:
     dst(x,y,c) = scale*src(x,y,c)+shift.
     Arbitrary combination of input and output array depths are allowed
     (number of channels must be the same), thus the function can be used
     for type conversion */
  CVAPI(void)  cvConvertScale( const CvArr* src, CvArr* dst,
                               double scale CV_DEFAULT(1),
                               double shift CV_DEFAULT(0) );
  #define cvCvtScale cvConvertScale
  #define cvScale  cvConvertScale
  #define cvConvert( src, dst )  cvConvertScale( (src), (dst), 1, 0 )
  
  
  /* Performs linear transformation on every source array element,
     stores absolute value of the result:
     dst(x,y,c) = abs(scale*src(x,y,c)+shift).
     destination array must have 8u type.
     In other cases one may use cvConvertScale + cvAbsDiffS */
  CVAPI(void)  cvConvertScaleAbs( const CvArr* src, CvArr* dst,
                                  double scale CV_DEFAULT(1),
                                  double shift CV_DEFAULT(0) );
  #define cvCvtScaleAbs  cvConvertScaleAbs
  
  
  /* checks termination criteria validity and
     sets eps to default_eps (if it is not set),
     max_iter to default_max_iters (if it is not set)
  */
  CVAPI(CvTermCriteria) cvCheckTermCriteria( CvTermCriteria criteria,
                                             double default_eps,
                                             int default_max_iters );
  
  /****************************************************************************************\
  *                   Arithmetic, logic and comparison operations                          *
  \****************************************************************************************/
  
  /* dst(mask) = src1(mask) + src2(mask) */
  CVAPI(void)  cvAdd( const CvArr* src1, const CvArr* src2, CvArr* dst,
                      const CvArr* mask CV_DEFAULT(NULL));
  
  /* dst(mask) = src(mask) + value */
  CVAPI(void)  cvAddS( const CvArr* src, CvScalar value, CvArr* dst,
                       const CvArr* mask CV_DEFAULT(NULL));
  
  /* dst(mask) = src1(mask) - src2(mask) */
  CVAPI(void)  cvSub( const CvArr* src1, const CvArr* src2, CvArr* dst,
                      const CvArr* mask CV_DEFAULT(NULL));
  
  /* dst(mask) = src(mask) - value = src(mask) + (-value) */
  CV_INLINE  void  cvSubS( const CvArr* src, CvScalar value, CvArr* dst,
                           const CvArr* mask CV_DEFAULT(NULL))
  {
      cvAddS( src, cvScalar( -value.val[0], -value.val[1], -value.val[2], -value.val[3]),
              dst, mask );
  }
  
  /* dst(mask) = value - src(mask) */
  CVAPI(void)  cvSubRS( const CvArr* src, CvScalar value, CvArr* dst,
                        const CvArr* mask CV_DEFAULT(NULL));
  
  /* dst(idx) = src1(idx) * src2(idx) * scale
     (scaled element-wise multiplication of 2 arrays) */
  CVAPI(void)  cvMul( const CvArr* src1, const CvArr* src2,
                      CvArr* dst, double scale CV_DEFAULT(1) );
  
  /* element-wise division/inversion with scaling:
      dst(idx) = src1(idx) * scale / src2(idx)
      or dst(idx) = scale / src2(idx) if src1 == 0 */
  CVAPI(void)  cvDiv( const CvArr* src1, const CvArr* src2,
                      CvArr* dst, double scale CV_DEFAULT(1));
  
  /* dst = src1 * scale + src2 */
  CVAPI(void)  cvScaleAdd( const CvArr* src1, CvScalar scale,
                           const CvArr* src2, CvArr* dst );
  #define cvAXPY( A, real_scalar, B, C ) cvScaleAdd(A, cvRealScalar(real_scalar), B, C)
  
  /* dst = src1 * alpha + src2 * beta + gamma */
  CVAPI(void)  cvAddWeighted( const CvArr* src1, double alpha,
                              const CvArr* src2, double beta,
                              double gamma, CvArr* dst );
  
  /* result = sum_i(src1(i) * src2(i)) (results for all channels are accumulated together) */
  CVAPI(double)  cvDotProduct( const CvArr* src1, const CvArr* src2 );
  
  /* dst(idx) = src1(idx) & src2(idx) */
  CVAPI(void) cvAnd( const CvArr* src1, const CvArr* src2,
                    CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
  
  /* dst(idx) = src(idx) & value */
  CVAPI(void) cvAndS( const CvArr* src, CvScalar value,
                     CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
  
  /* dst(idx) = src1(idx) | src2(idx) */
  CVAPI(void) cvOr( const CvArr* src1, const CvArr* src2,
                   CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
  
  /* dst(idx) = src(idx) | value */
  CVAPI(void) cvOrS( const CvArr* src, CvScalar value,
                    CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
  
  /* dst(idx) = src1(idx) ^ src2(idx) */
  CVAPI(void) cvXor( const CvArr* src1, const CvArr* src2,
                    CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
  
  /* dst(idx) = src(idx) ^ value */
  CVAPI(void) cvXorS( const CvArr* src, CvScalar value,
                     CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
  
  /* dst(idx) = ~src(idx) */
  CVAPI(void) cvNot( const CvArr* src, CvArr* dst );
  
  /* dst(idx) = lower(idx) <= src(idx) < upper(idx) */
  CVAPI(void) cvInRange( const CvArr* src, const CvArr* lower,
                        const CvArr* upper, CvArr* dst );
  
  /* dst(idx) = lower <= src(idx) < upper */
  CVAPI(void) cvInRangeS( const CvArr* src, CvScalar lower,
                         CvScalar upper, CvArr* dst );
  
  #define CV_CMP_EQ   0
  #define CV_CMP_GT   1
  #define CV_CMP_GE   2
  #define CV_CMP_LT   3
  #define CV_CMP_LE   4
  #define CV_CMP_NE   5
  
  /* The comparison operation support single-channel arrays only.
     Destination image should be 8uC1 or 8sC1 */
  
  /* dst(idx) = src1(idx) _cmp_op_ src2(idx) */
  CVAPI(void) cvCmp( const CvArr* src1, const CvArr* src2, CvArr* dst, int cmp_op );
  
  /* dst(idx) = src1(idx) _cmp_op_ value */
  CVAPI(void) cvCmpS( const CvArr* src, double value, CvArr* dst, int cmp_op );
  
  /* dst(idx) = min(src1(idx),src2(idx)) */
  CVAPI(void) cvMin( const CvArr* src1, const CvArr* src2, CvArr* dst );
  
  /* dst(idx) = max(src1(idx),src2(idx)) */
  CVAPI(void) cvMax( const CvArr* src1, const CvArr* src2, CvArr* dst );
  
  /* dst(idx) = min(src(idx),value) */
  CVAPI(void) cvMinS( const CvArr* src, double value, CvArr* dst );
  
  /* dst(idx) = max(src(idx),value) */
  CVAPI(void) cvMaxS( const CvArr* src, double value, CvArr* dst );
  
  /* dst(x,y,c) = abs(src1(x,y,c) - src2(x,y,c)) */
  CVAPI(void) cvAbsDiff( const CvArr* src1, const CvArr* src2, CvArr* dst );
  
  /* dst(x,y,c) = abs(src(x,y,c) - value(c)) */
  CVAPI(void) cvAbsDiffS( const CvArr* src, CvArr* dst, CvScalar value );
  #define cvAbs( src, dst ) cvAbsDiffS( (src), (dst), cvScalarAll(0))
  
  /****************************************************************************************\
  *                                Math operations                                         *
  \****************************************************************************************/
  
  /* Does cartesian->polar coordinates conversion.
     Either of output components (magnitude or angle) is optional */
  CVAPI(void)  cvCartToPolar( const CvArr* x, const CvArr* y,
                              CvArr* magnitude, CvArr* angle CV_DEFAULT(NULL),
                              int angle_in_degrees CV_DEFAULT(0));
  
  /* Does polar->cartesian coordinates conversion.
     Either of output components (magnitude or angle) is optional.
     If magnitude is missing it is assumed to be all 1's */
  CVAPI(void)  cvPolarToCart( const CvArr* magnitude, const CvArr* angle,
                              CvArr* x, CvArr* y,
                              int angle_in_degrees CV_DEFAULT(0));
  
  /* Does powering: dst(idx) = src(idx)^power */
  CVAPI(void)  cvPow( const CvArr* src, CvArr* dst, double power );
  
  /* Does exponention: dst(idx) = exp(src(idx)).
     Overflow is not handled yet. Underflow is handled.
     Maximal relative error is ~7e-6 for single-precision input */
  CVAPI(void)  cvExp( const CvArr* src, CvArr* dst );
  
  /* Calculates natural logarithms: dst(idx) = log(abs(src(idx))).
     Logarithm of 0 gives large negative number(~-700)
     Maximal relative error is ~3e-7 for single-precision output
  */
  CVAPI(void)  cvLog( const CvArr* src, CvArr* dst );
  
  /* Fast arctangent calculation */
  CVAPI(float) cvFastArctan( float y, float x );
  
  /* Fast cubic root calculation */
  CVAPI(float)  cvCbrt( float value );
  
  /* Checks array values for NaNs, Infs or simply for too large numbers
     (if CV_CHECK_RANGE is set). If CV_CHECK_QUIET is set,
     no runtime errors is raised (function returns zero value in case of "bad" values).
     Otherwise cvError is called */
  #define  CV_CHECK_RANGE    1
  #define  CV_CHECK_QUIET    2
  CVAPI(int)  cvCheckArr( const CvArr* arr, int flags CV_DEFAULT(0),
                          double min_val CV_DEFAULT(0), double max_val CV_DEFAULT(0));
  #define cvCheckArray cvCheckArr
  
  #define CV_RAND_UNI      0
  #define CV_RAND_NORMAL   1
  CVAPI(void) cvRandArr( CvRNG* rng, CvArr* arr, int dist_type,
                        CvScalar param1, CvScalar param2 );
  
  CVAPI(void) cvRandShuffle( CvArr* mat, CvRNG* rng,
                             double iter_factor CV_DEFAULT(1.));
  
  #define CV_SORT_EVERY_ROW 0
  #define CV_SORT_EVERY_COLUMN 1
  #define CV_SORT_ASCENDING 0
  #define CV_SORT_DESCENDING 16
  
  CVAPI(void) cvSort( const CvArr* src, CvArr* dst CV_DEFAULT(NULL),
                      CvArr* idxmat CV_DEFAULT(NULL),
                      int flags CV_DEFAULT(0));
  
  /* Finds real roots of a cubic equation */
  CVAPI(int) cvSolveCubic( const CvMat* coeffs, CvMat* roots );
  
  /* Finds all real and complex roots of a polynomial equation */
  CVAPI(void) cvSolvePoly(const CvMat* coeffs, CvMat *roots2,
        int maxiter CV_DEFAULT(20), int fig CV_DEFAULT(100));
  
  /****************************************************************************************\
  *                                Matrix operations                                       *
  \****************************************************************************************/
  
  /* Calculates cross product of two 3d vectors */
  CVAPI(void)  cvCrossProduct( const CvArr* src1, const CvArr* src2, CvArr* dst );
  
  /* Matrix transform: dst = A*B + C, C is optional */
  #define cvMatMulAdd( src1, src2, src3, dst ) cvGEMM( (src1), (src2), 1., (src3), 1., (dst), 0 )
  #define cvMatMul( src1, src2, dst )  cvMatMulAdd( (src1), (src2), NULL, (dst))
  
  #define CV_GEMM_A_T 1
  #define CV_GEMM_B_T 2
  #define CV_GEMM_C_T 4
  /* Extended matrix transform:
     dst = alpha*op(A)*op(B) + beta*op(C), where op(X) is X or X^T */
  CVAPI(void)  cvGEMM( const CvArr* src1, const CvArr* src2, double alpha,
                       const CvArr* src3, double beta, CvArr* dst,
                       int tABC CV_DEFAULT(0));
  #define cvMatMulAddEx cvGEMM
  
  /* Transforms each element of source array and stores
     resultant vectors in destination array */
  CVAPI(void)  cvTransform( const CvArr* src, CvArr* dst,
                            const CvMat* transmat,
                            const CvMat* shiftvec CV_DEFAULT(NULL));
  #define cvMatMulAddS cvTransform
  
  /* Does perspective transform on every element of input array */
  CVAPI(void)  cvPerspectiveTransform( const CvArr* src, CvArr* dst,
                                       const CvMat* mat );
  
  /* Calculates (A-delta)*(A-delta)^T (order=0) or (A-delta)^T*(A-delta) (order=1) */
  CVAPI(void) cvMulTransposed( const CvArr* src, CvArr* dst, int order,
                               const CvArr* delta CV_DEFAULT(NULL),
                               double scale CV_DEFAULT(1.) );
  
  /* Tranposes matrix. Square matrices can be transposed in-place */
  CVAPI(void)  cvTranspose( const CvArr* src, CvArr* dst );
  #define cvT cvTranspose
  
  /* Completes the symmetric matrix from the lower (LtoR=0) or from the upper (LtoR!=0) part */
  CVAPI(void)  cvCompleteSymm( CvMat* matrix, int LtoR CV_DEFAULT(0) );
  
  /* Mirror array data around horizontal (flip=0),
     vertical (flip=1) or both(flip=-1) axises:
     cvFlip(src) flips images vertically and sequences horizontally (inplace) */
  CVAPI(void)  cvFlip( const CvArr* src, CvArr* dst CV_DEFAULT(NULL),
                       int flip_mode CV_DEFAULT(0));
  #define cvMirror cvFlip
  
  
  #define CV_SVD_MODIFY_A   1
  #define CV_SVD_U_T        2
  #define CV_SVD_V_T        4
  
  /* Performs Singular Value Decomposition of a matrix */
  CVAPI(void)   cvSVD( CvArr* A, CvArr* W, CvArr* U CV_DEFAULT(NULL),
                       CvArr* V CV_DEFAULT(NULL), int flags CV_DEFAULT(0));
  
  /* Performs Singular Value Back Substitution (solves A*X = B):
     flags must be the same as in cvSVD */
  CVAPI(void)   cvSVBkSb( const CvArr* W, const CvArr* U,
                          const CvArr* V, const CvArr* B,
                          CvArr* X, int flags );
  
  #define CV_LU  0
  #define CV_SVD 1
  #define CV_SVD_SYM 2
  #define CV_CHOLESKY 3
  #define CV_QR  4
  #define CV_NORMAL 16
  
  /* Inverts matrix */
  CVAPI(double)  cvInvert( const CvArr* src, CvArr* dst,
                           int method CV_DEFAULT(CV_LU));
  #define cvInv cvInvert
  
  /* Solves linear system (src1)*(dst) = (src2)
     (returns 0 if src1 is a singular and CV_LU method is used) */
  CVAPI(int)  cvSolve( const CvArr* src1, const CvArr* src2, CvArr* dst,
                       int method CV_DEFAULT(CV_LU));
  
  /* Calculates determinant of input matrix */
  CVAPI(double) cvDet( const CvArr* mat );
  
  /* Calculates trace of the matrix (sum of elements on the main diagonal) */
  CVAPI(CvScalar) cvTrace( const CvArr* mat );
  
  /* Finds eigen values and vectors of a symmetric matrix */
  CVAPI(void)  cvEigenVV( CvArr* mat, CvArr* evects, CvArr* evals,
                          double eps CV_DEFAULT(0),
                          int lowindex CV_DEFAULT(-1),
                          int highindex CV_DEFAULT(-1));
  
  ///* Finds selected eigen values and vectors of a symmetric matrix */
  //CVAPI(void)  cvSelectedEigenVV( CvArr* mat, CvArr* evects, CvArr* evals,
  //                                int lowindex, int highindex );
  
  /* Makes an identity matrix (mat_ij = i == j) */
  CVAPI(void)  cvSetIdentity( CvArr* mat, CvScalar value CV_DEFAULT(cvRealScalar(1)) );
  
  /* Fills matrix with given range of numbers */
  CVAPI(CvArr*)  cvRange( CvArr* mat, double start, double end );
  
  /* Calculates covariation matrix for a set of vectors */
  /* transpose([v1-avg, v2-avg,...]) * [v1-avg,v2-avg,...] */
  #define CV_COVAR_SCRAMBLED 0
  
  /* [v1-avg, v2-avg,...] * transpose([v1-avg,v2-avg,...]) */
  #define CV_COVAR_NORMAL    1
  
  /* do not calc average (i.e. mean vector) - use the input vector instead
     (useful for calculating covariance matrix by parts) */
  #define CV_COVAR_USE_AVG   2
  
  /* scale the covariance matrix coefficients by number of the vectors */
  #define CV_COVAR_SCALE     4
  
  /* all the input vectors are stored in a single matrix, as its rows */
  #define CV_COVAR_ROWS      8
  
  /* all the input vectors are stored in a single matrix, as its columns */
  #define CV_COVAR_COLS     16
  
  CVAPI(void)  cvCalcCovarMatrix( const CvArr** vects, int count,
                                  CvArr* cov_mat, CvArr* avg, int flags );
  
  #define CV_PCA_DATA_AS_ROW 0
  #define CV_PCA_DATA_AS_COL 1
  #define CV_PCA_USE_AVG 2
  CVAPI(void)  cvCalcPCA( const CvArr* data, CvArr* mean,
                          CvArr* eigenvals, CvArr* eigenvects, int flags );
  
  CVAPI(void)  cvProjectPCA( const CvArr* data, const CvArr* mean,
                             const CvArr* eigenvects, CvArr* result );
  
  CVAPI(void)  cvBackProjectPCA( const CvArr* proj, const CvArr* mean,
                                 const CvArr* eigenvects, CvArr* result );
  
  /* Calculates Mahalanobis(weighted) distance */
  CVAPI(double)  cvMahalanobis( const CvArr* vec1, const CvArr* vec2, const CvArr* mat );
  #define cvMahalonobis  cvMahalanobis
  
  /****************************************************************************************\
  *                                    Array Statistics                                    *
  \****************************************************************************************/
  
  /* Finds sum of array elements */
  CVAPI(CvScalar)  cvSum( const CvArr* arr );
  
  /* Calculates number of non-zero pixels */
  CVAPI(int)  cvCountNonZero( const CvArr* arr );
  
  /* Calculates mean value of array elements */
  CVAPI(CvScalar)  cvAvg( const CvArr* arr, const CvArr* mask CV_DEFAULT(NULL) );
  
  /* Calculates mean and standard deviation of pixel values */
  CVAPI(void)  cvAvgSdv( const CvArr* arr, CvScalar* mean, CvScalar* std_dev,
                         const CvArr* mask CV_DEFAULT(NULL) );
  
  /* Finds global minimum, maximum and their positions */
  CVAPI(void)  cvMinMaxLoc( const CvArr* arr, double* min_val, double* max_val,
                            CvPoint* min_loc CV_DEFAULT(NULL),
                            CvPoint* max_loc CV_DEFAULT(NULL),
                            const CvArr* mask CV_DEFAULT(NULL) );
  
  /* types of array norm */
  #define CV_C            1
  #define CV_L1           2
  #define CV_L2           4
  #define CV_NORM_MASK    7
  #define CV_RELATIVE     8
  #define CV_DIFF         16
  #define CV_MINMAX       32
  
  #define CV_DIFF_C       (CV_DIFF | CV_C)
  #define CV_DIFF_L1      (CV_DIFF | CV_L1)
  #define CV_DIFF_L2      (CV_DIFF | CV_L2)
  #define CV_RELATIVE_C   (CV_RELATIVE | CV_C)
  #define CV_RELATIVE_L1  (CV_RELATIVE | CV_L1)
  #define CV_RELATIVE_L2  (CV_RELATIVE | CV_L2)
  
  /* Finds norm, difference norm or relative difference norm for an array (or two arrays) */
  CVAPI(double)  cvNorm( const CvArr* arr1, const CvArr* arr2 CV_DEFAULT(NULL),
                         int norm_type CV_DEFAULT(CV_L2),
                         const CvArr* mask CV_DEFAULT(NULL) );
  
  CVAPI(void)  cvNormalize( const CvArr* src, CvArr* dst,
                            double a CV_DEFAULT(1.), double b CV_DEFAULT(0.),
                            int norm_type CV_DEFAULT(CV_L2),
                            const CvArr* mask CV_DEFAULT(NULL) );
  
  
  #define CV_REDUCE_SUM 0
  #define CV_REDUCE_AVG 1
  #define CV_REDUCE_MAX 2
  #define CV_REDUCE_MIN 3
  
  CVAPI(void)  cvReduce( const CvArr* src, CvArr* dst, int dim CV_DEFAULT(-1),
                         int op CV_DEFAULT(CV_REDUCE_SUM) );
  
  /****************************************************************************************\
  *                      Discrete Linear Transforms and Related Functions                  *
  \****************************************************************************************/
  
  #define CV_DXT_FORWARD  0
  #define CV_DXT_INVERSE  1
  #define CV_DXT_SCALE    2 /* divide result by size of array */
  #define CV_DXT_INV_SCALE (CV_DXT_INVERSE + CV_DXT_SCALE)
  #define CV_DXT_INVERSE_SCALE CV_DXT_INV_SCALE
  #define CV_DXT_ROWS     4 /* transform each row individually */
  #define CV_DXT_MUL_CONJ 8 /* conjugate the second argument of cvMulSpectrums */
  
  /* Discrete Fourier Transform:
      complex->complex,
      real->ccs (forward),
      ccs->real (inverse) */
  CVAPI(void)  cvDFT( const CvArr* src, CvArr* dst, int flags,
                      int nonzero_rows CV_DEFAULT(0) );
  #define cvFFT cvDFT
  
  /* Multiply results of DFTs: DFT(X)*DFT(Y) or DFT(X)*conj(DFT(Y)) */
  CVAPI(void)  cvMulSpectrums( const CvArr* src1, const CvArr* src2,
                               CvArr* dst, int flags );
  
  /* Finds optimal DFT vector size >= size0 */
  CVAPI(int)  cvGetOptimalDFTSize( int size0 );
  
  /* Discrete Cosine Transform */
  CVAPI(void)  cvDCT( const CvArr* src, CvArr* dst, int flags );
  
  /****************************************************************************************\
  *                              Dynamic data structures                                   *
  \****************************************************************************************/
  
  /* Calculates length of sequence slice (with support of negative indices). */
  CVAPI(int) cvSliceLength( CvSlice slice, const CvSeq* seq );
  
  
  /* Creates new memory storage.
     block_size == 0 means that default,
     somewhat optimal size, is used (currently, it is 64K) */
  CVAPI(CvMemStorage*)  cvCreateMemStorage( int block_size CV_DEFAULT(0));
  
  
  /* Creates a memory storage that will borrow memory blocks from parent storage */
  CVAPI(CvMemStorage*)  cvCreateChildMemStorage( CvMemStorage* parent );
  
  
  /* Releases memory storage. All the children of a parent must be released before
     the parent. A child storage returns all the blocks to parent when it is released */
  CVAPI(void)  cvReleaseMemStorage( CvMemStorage** storage );
  
  
  /* Clears memory storage. This is the only way(!!!) (besides cvRestoreMemStoragePos)
     to reuse memory allocated for the storage - cvClearSeq,cvClearSet ...
     do not free any memory.
     A child storage returns all the blocks to the parent when it is cleared */
  CVAPI(void)  cvClearMemStorage( CvMemStorage* storage );
  
  /* Remember a storage "free memory" position */
  CVAPI(void)  cvSaveMemStoragePos( const CvMemStorage* storage, CvMemStoragePos* pos );
  
  /* Restore a storage "free memory" position */
  CVAPI(void)  cvRestoreMemStoragePos( CvMemStorage* storage, CvMemStoragePos* pos );
  
  /* Allocates continuous buffer of the specified size in the storage */
  CVAPI(void*) cvMemStorageAlloc( CvMemStorage* storage, size_t size );
  
  /* Allocates string in memory storage */
  CVAPI(CvString) cvMemStorageAllocString( CvMemStorage* storage, const char* ptr,
                                           int len CV_DEFAULT(-1) );
  
  /* Creates new empty sequence that will reside in the specified storage */
  CVAPI(CvSeq*)  cvCreateSeq( int seq_flags, size_t header_size,
                              size_t elem_size, CvMemStorage* storage );
  
  /* Changes default size (granularity) of sequence blocks.
     The default size is ~1Kbyte */
  CVAPI(void)  cvSetSeqBlockSize( CvSeq* seq, int delta_elems );
  
  
  /* Adds new element to the end of sequence. Returns pointer to the element */
  CVAPI(schar*)  cvSeqPush( CvSeq* seq, const void* element CV_DEFAULT(NULL));
  
  
  /* Adds new element to the beginning of sequence. Returns pointer to it */
  CVAPI(schar*)  cvSeqPushFront( CvSeq* seq, const void* element CV_DEFAULT(NULL));
  
  
  /* Removes the last element from sequence and optionally saves it */
  CVAPI(void)  cvSeqPop( CvSeq* seq, void* element CV_DEFAULT(NULL));
  
  
  /* Removes the first element from sequence and optioanally saves it */
  CVAPI(void)  cvSeqPopFront( CvSeq* seq, void* element CV_DEFAULT(NULL));
  
  
  #define CV_FRONT 1
  #define CV_BACK 0
  /* Adds several new elements to the end of sequence */
  CVAPI(void)  cvSeqPushMulti( CvSeq* seq, const void* elements,
                               int count, int in_front CV_DEFAULT(0) );
  
  /* Removes several elements from the end of sequence and optionally saves them */
  CVAPI(void)  cvSeqPopMulti( CvSeq* seq, void* elements,
                              int count, int in_front CV_DEFAULT(0) );
  
  /* Inserts a new element in the middle of sequence.
     cvSeqInsert(seq,0,elem) == cvSeqPushFront(seq,elem) */
  CVAPI(schar*)  cvSeqInsert( CvSeq* seq, int before_index,
                              const void* element CV_DEFAULT(NULL));
  
  /* Removes specified sequence element */
  CVAPI(void)  cvSeqRemove( CvSeq* seq, int index );
  
  
  /* Removes all the elements from the sequence. The freed memory
     can be reused later only by the same sequence unless cvClearMemStorage
     or cvRestoreMemStoragePos is called */
  CVAPI(void)  cvClearSeq( CvSeq* seq );
  
  
  /* Retrieves pointer to specified sequence element.
     Negative indices are supported and mean counting from the end
     (e.g -1 means the last sequence element) */
  CVAPI(schar*)  cvGetSeqElem( const CvSeq* seq, int index );
  
  /* Calculates index of the specified sequence element.
     Returns -1 if element does not belong to the sequence */
  CVAPI(int)  cvSeqElemIdx( const CvSeq* seq, const void* element,
                           CvSeqBlock** block CV_DEFAULT(NULL) );
  
  /* Initializes sequence writer. The new elements will be added to the end of sequence */
  CVAPI(void)  cvStartAppendToSeq( CvSeq* seq, CvSeqWriter* writer );
  
  
  /* Combination of cvCreateSeq and cvStartAppendToSeq */
  CVAPI(void)  cvStartWriteSeq( int seq_flags, int header_size,
                                int elem_size, CvMemStorage* storage,
                                CvSeqWriter* writer );
  
  /* Closes sequence writer, updates sequence header and returns pointer
     to the resultant sequence
     (which may be useful if the sequence was created using cvStartWriteSeq))
  */
  CVAPI(CvSeq*)  cvEndWriteSeq( CvSeqWriter* writer );
  
  
  /* Updates sequence header. May be useful to get access to some of previously
     written elements via cvGetSeqElem or sequence reader */
  CVAPI(void)   cvFlushSeqWriter( CvSeqWriter* writer );
  
  
  /* Initializes sequence reader.
     The sequence can be read in forward or backward direction */
  CVAPI(void) cvStartReadSeq( const CvSeq* seq, CvSeqReader* reader,
                             int reverse CV_DEFAULT(0) );
  
  
  /* Returns current sequence reader position (currently observed sequence element) */
  CVAPI(int)  cvGetSeqReaderPos( CvSeqReader* reader );
  
  
  /* Changes sequence reader position. It may seek to an absolute or
     to relative to the current position */
  CVAPI(void)   cvSetSeqReaderPos( CvSeqReader* reader, int index,
                                   int is_relative CV_DEFAULT(0));
  
  /* Copies sequence content to a continuous piece of memory */
  CVAPI(void*)  cvCvtSeqToArray( const CvSeq* seq, void* elements,
                                 CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ) );
  
  /* Creates sequence header for array.
     After that all the operations on sequences that do not alter the content
     can be applied to the resultant sequence */
  CVAPI(CvSeq*) cvMakeSeqHeaderForArray( int seq_type, int header_size,
                                         int elem_size, void* elements, int total,
                                         CvSeq* seq, CvSeqBlock* block );
  
  /* Extracts sequence slice (with or without copying sequence elements) */
  CVAPI(CvSeq*) cvSeqSlice( const CvSeq* seq, CvSlice slice,
                           CvMemStorage* storage CV_DEFAULT(NULL),
                           int copy_data CV_DEFAULT(0));
  
  CV_INLINE CvSeq* cvCloneSeq( const CvSeq* seq, CvMemStorage* storage CV_DEFAULT(NULL))
  {
      return cvSeqSlice( seq, CV_WHOLE_SEQ, storage, 1 );
  }
  
  /* Removes sequence slice */
  CVAPI(void)  cvSeqRemoveSlice( CvSeq* seq, CvSlice slice );
  
  /* Inserts a sequence or array into another sequence */
  CVAPI(void)  cvSeqInsertSlice( CvSeq* seq, int before_index, const CvArr* from_arr );
  
  /* a < b ? -1 : a > b ? 1 : 0 */
  typedef int (CV_CDECL* CvCmpFunc)(const void* a, const void* b, void* userdata );
  
  /* Sorts sequence in-place given element comparison function */
  CVAPI(void) cvSeqSort( CvSeq* seq, CvCmpFunc func, void* userdata CV_DEFAULT(NULL) );
  
  /* Finds element in a [sorted] sequence */
  CVAPI(schar*) cvSeqSearch( CvSeq* seq, const void* elem, CvCmpFunc func,
                             int is_sorted, int* elem_idx,
                             void* userdata CV_DEFAULT(NULL) );
  
  /* Reverses order of sequence elements in-place */
  CVAPI(void) cvSeqInvert( CvSeq* seq );
  
  /* Splits sequence into one or more equivalence classes using the specified criteria */
  CVAPI(int)  cvSeqPartition( const CvSeq* seq, CvMemStorage* storage,
                              CvSeq** labels, CvCmpFunc is_equal, void* userdata );
  
  /************ Internal sequence functions ************/
  CVAPI(void)  cvChangeSeqBlock( void* reader, int direction );
  CVAPI(void)  cvCreateSeqBlock( CvSeqWriter* writer );
  
  
  /* Creates a new set */
  CVAPI(CvSet*)  cvCreateSet( int set_flags, int header_size,
                              int elem_size, CvMemStorage* storage );
  
  /* Adds new element to the set and returns pointer to it */
  CVAPI(int)  cvSetAdd( CvSet* set_header, CvSetElem* elem CV_DEFAULT(NULL),
                        CvSetElem** inserted_elem CV_DEFAULT(NULL) );
  
  /* Fast variant of cvSetAdd */
  CV_INLINE  CvSetElem* cvSetNew( CvSet* set_header )
  {
      CvSetElem* elem = set_header->free_elems;
      if( elem )
      {
          set_header->free_elems = elem->next_free;
          elem->flags = elem->flags & CV_SET_ELEM_IDX_MASK;
          set_header->active_count++;
      }
      else
          cvSetAdd( set_header, NULL, &elem );
      return elem;
  }
  
  /* Removes set element given its pointer */
  CV_INLINE  void cvSetRemoveByPtr( CvSet* set_header, void* elem )
  {
      CvSetElem* _elem = (CvSetElem*)elem;
      assert( _elem->flags >= 0 /*&& (elem->flags & CV_SET_ELEM_IDX_MASK) < set_header->total*/ );
      _elem->next_free = set_header->free_elems;
      _elem->flags = (_elem->flags & CV_SET_ELEM_IDX_MASK) | CV_SET_ELEM_FREE_FLAG;
      set_header->free_elems = _elem;
      set_header->active_count--;
  }
  
  /* Removes element from the set by its index  */
  CVAPI(void)   cvSetRemove( CvSet* set_header, int index );
  
  /* Returns a set element by index. If the element doesn't belong to the set,
     NULL is returned */
  CV_INLINE CvSetElem* cvGetSetElem( const CvSet* set_header, int idx )
  {
      CvSetElem* elem = (CvSetElem*)(void *)cvGetSeqElem( (CvSeq*)set_header, idx );
      return elem && CV_IS_SET_ELEM( elem ) ? elem : 0;
  }
  
  /* Removes all the elements from the set */
  CVAPI(void)  cvClearSet( CvSet* set_header );
  
  /* Creates new graph */
  CVAPI(CvGraph*)  cvCreateGraph( int graph_flags, int header_size,
                                  int vtx_size, int edge_size,
                                  CvMemStorage* storage );
  
  /* Adds new vertex to the graph */
  CVAPI(int)  cvGraphAddVtx( CvGraph* graph, const CvGraphVtx* vtx CV_DEFAULT(NULL),
                             CvGraphVtx** inserted_vtx CV_DEFAULT(NULL) );
  
  
  /* Removes vertex from the graph together with all incident edges */
  CVAPI(int)  cvGraphRemoveVtx( CvGraph* graph, int index );
  CVAPI(int)  cvGraphRemoveVtxByPtr( CvGraph* graph, CvGraphVtx* vtx );
  
  
  /* Link two vertices specifed by indices or pointers if they
     are not connected or return pointer to already existing edge
     connecting the vertices.
     Functions return 1 if a new edge was created, 0 otherwise */
  CVAPI(int)  cvGraphAddEdge( CvGraph* graph,
                              int start_idx, int end_idx,
                              const CvGraphEdge* edge CV_DEFAULT(NULL),
                              CvGraphEdge** inserted_edge CV_DEFAULT(NULL) );
  
  CVAPI(int)  cvGraphAddEdgeByPtr( CvGraph* graph,
                                 CvGraphVtx* start_vtx, CvGraphVtx* end_vtx,
                                 const CvGraphEdge* edge CV_DEFAULT(NULL),
                                 CvGraphEdge** inserted_edge CV_DEFAULT(NULL) );
  
  /* Remove edge connecting two vertices */
  CVAPI(void)  cvGraphRemoveEdge( CvGraph* graph, int start_idx, int end_idx );
  CVAPI(void)  cvGraphRemoveEdgeByPtr( CvGraph* graph, CvGraphVtx* start_vtx,
                                       CvGraphVtx* end_vtx );
  
  /* Find edge connecting two vertices */
  CVAPI(CvGraphEdge*)  cvFindGraphEdge( const CvGraph* graph, int start_idx, int end_idx );
  CVAPI(CvGraphEdge*)  cvFindGraphEdgeByPtr( const CvGraph* graph,
                                             const CvGraphVtx* start_vtx,
                                             const CvGraphVtx* end_vtx );
  #define cvGraphFindEdge cvFindGraphEdge
  #define cvGraphFindEdgeByPtr cvFindGraphEdgeByPtr
  
  /* Remove all vertices and edges from the graph */
  CVAPI(void)  cvClearGraph( CvGraph* graph );
  
  
  /* Count number of edges incident to the vertex */
  CVAPI(int)  cvGraphVtxDegree( const CvGraph* graph, int vtx_idx );
  CVAPI(int)  cvGraphVtxDegreeByPtr( const CvGraph* graph, const CvGraphVtx* vtx );
  
  
  /* Retrieves graph vertex by given index */
  #define cvGetGraphVtx( graph, idx ) (CvGraphVtx*)cvGetSetElem((CvSet*)(graph), (idx))
  
  /* Retrieves index of a graph vertex given its pointer */
  #define cvGraphVtxIdx( graph, vtx ) ((vtx)->flags & CV_SET_ELEM_IDX_MASK)
  
  /* Retrieves index of a graph edge given its pointer */
  #define cvGraphEdgeIdx( graph, edge ) ((edge)->flags & CV_SET_ELEM_IDX_MASK)
  
  #define cvGraphGetVtxCount( graph ) ((graph)->active_count)
  #define cvGraphGetEdgeCount( graph ) ((graph)->edges->active_count)
  
  #define  CV_GRAPH_VERTEX        1
  #define  CV_GRAPH_TREE_EDGE     2
  #define  CV_GRAPH_BACK_EDGE     4
  #define  CV_GRAPH_FORWARD_EDGE  8
  #define  CV_GRAPH_CROSS_EDGE    16
  #define  CV_GRAPH_ANY_EDGE      30
  #define  CV_GRAPH_NEW_TREE      32
  #define  CV_GRAPH_BACKTRACKING  64
  #define  CV_GRAPH_OVER          -1
  
  #define  CV_GRAPH_ALL_ITEMS    -1
  
  /* flags for graph vertices and edges */
  #define  CV_GRAPH_ITEM_VISITED_FLAG  (1 << 30)
  #define  CV_IS_GRAPH_VERTEX_VISITED(vtx) \
      (((CvGraphVtx*)(vtx))->flags & CV_GRAPH_ITEM_VISITED_FLAG)
  #define  CV_IS_GRAPH_EDGE_VISITED(edge) \
      (((CvGraphEdge*)(edge))->flags & CV_GRAPH_ITEM_VISITED_FLAG)
  #define  CV_GRAPH_SEARCH_TREE_NODE_FLAG   (1 << 29)
  #define  CV_GRAPH_FORWARD_EDGE_FLAG       (1 << 28)
  
  typedef struct CvGraphScanner
  {
      CvGraphVtx* vtx;       /* current graph vertex (or current edge origin) */
      CvGraphVtx* dst;       /* current graph edge destination vertex */
      CvGraphEdge* edge;     /* current edge */
  
      CvGraph* graph;        /* the graph */
      CvSeq*   stack;        /* the graph vertex stack */
      int      index;        /* the lower bound of certainly visited vertices */
      int      mask;         /* event mask */
  }
  CvGraphScanner;
  
  /* Creates new graph scanner. */
  CVAPI(CvGraphScanner*)  cvCreateGraphScanner( CvGraph* graph,
                                               CvGraphVtx* vtx CV_DEFAULT(NULL),
                                               int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS));
  
  /* Releases graph scanner. */
  CVAPI(void) cvReleaseGraphScanner( CvGraphScanner** scanner );
  
  /* Get next graph element */
  CVAPI(int)  cvNextGraphItem( CvGraphScanner* scanner );
  
  /* Creates a copy of graph */
  CVAPI(CvGraph*) cvCloneGraph( const CvGraph* graph, CvMemStorage* storage );
  
  /****************************************************************************************\
  *                                     Drawing                                            *
  \****************************************************************************************/
  
  /****************************************************************************************\
  *       Drawing functions work with images/matrices of arbitrary type.                   *
  *       For color images the channel order is BGR[A]                                     *
  *       Antialiasing is supported only for 8-bit image now.                              *
  *       All the functions include parameter color that means rgb value (that may be      *
  *       constructed with CV_RGB macro) for color images and brightness                   *
  *       for grayscale images.                                                            *
  *       If a drawn figure is partially or completely outside of the image, it is clipped.*
  \****************************************************************************************/
  
  #define CV_RGB( r, g, b )  cvScalar( (b), (g), (r), 0 )
  #define CV_FILLED -1
  
  #define CV_AA 16
  
  /* Draws 4-connected, 8-connected or antialiased line segment connecting two points */
  CVAPI(void)  cvLine( CvArr* img, CvPoint pt1, CvPoint pt2,
                       CvScalar color, int thickness CV_DEFAULT(1),
                       int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
  
  /* Draws a rectangle given two opposite corners of the rectangle (pt1 & pt2),
     if thickness<0 (e.g. thickness == CV_FILLED), the filled box is drawn */
  CVAPI(void)  cvRectangle( CvArr* img, CvPoint pt1, CvPoint pt2,
                            CvScalar color, int thickness CV_DEFAULT(1),
                            int line_type CV_DEFAULT(8),
                            int shift CV_DEFAULT(0));
  
  /* Draws a rectangle specified by a CvRect structure */
  CVAPI(void)  cvRectangleR( CvArr* img, CvRect r,
                             CvScalar color, int thickness CV_DEFAULT(1),
                             int line_type CV_DEFAULT(8),
                             int shift CV_DEFAULT(0));
  
  
  /* Draws a circle with specified center and radius.
     Thickness works in the same way as with cvRectangle */
  CVAPI(void)  cvCircle( CvArr* img, CvPoint center, int radius,
                         CvScalar color, int thickness CV_DEFAULT(1),
                         int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
  
  /* Draws ellipse outline, filled ellipse, elliptic arc or filled elliptic sector,
     depending on <thickness>, <start_angle> and <end_angle> parameters. The resultant figure
     is rotated by <angle>. All the angles are in degrees */
  CVAPI(void)  cvEllipse( CvArr* img, CvPoint center, CvSize axes,
                          double angle, double start_angle, double end_angle,
                          CvScalar color, int thickness CV_DEFAULT(1),
                          int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
  
  CV_INLINE  void  cvEllipseBox( CvArr* img, CvBox2D box, CvScalar color,
                                 int thickness CV_DEFAULT(1),
                                 int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) )
  {
      CvSize axes;
      axes.width = cvRound(box.size.width*0.5);
      axes.height = cvRound(box.size.height*0.5);
  
      cvEllipse( img, cvPointFrom32f( box.center ), axes, box.angle,
                 0, 360, color, thickness, line_type, shift );
  }
  
  // /* Fills convex or monotonous polygon. */
  // CVAPI(void)  cvFillConvexPoly( CvArr* img, const CvPoint* pts, int npts, CvScalar color,
  //                                int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
  
  // /* Fills an area bounded by one or more arbitrary polygons */
  // CVAPI(void)  cvFillPoly( CvArr* img, CvPoint** pts, const int* npts,
  //                          int contours, CvScalar color,
  //                          int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
  
  // /* Draws one or more polygonal curves */
  // CVAPI(void)  cvPolyLine( CvArr* img, CvPoint** pts, const int* npts, int contours,
  //                          int is_closed, CvScalar color, int thickness CV_DEFAULT(1),
  //                          int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
  
  #define cvDrawRect cvRectangle
  #define cvDrawLine cvLine
  #define cvDrawCircle cvCircle
  #define cvDrawEllipse cvEllipse
  #define cvDrawPolyLine cvPolyLine
  
  /* Clips the line segment connecting *pt1 and *pt2
     by the rectangular window
     (0<=x<img_size.width, 0<=y<img_size.height). */
  CVAPI(int) cvClipLine( CvSize img_size, CvPoint* pt1, CvPoint* pt2 );
  
  /* Initializes line iterator. Initially, line_iterator->ptr will point
     to pt1 (or pt2, see left_to_right description) location in the image.
     Returns the number of pixels on the line between the ending points. */
  // CVAPI(int)  cvInitLineIterator( const CvArr* image, CvPoint pt1, CvPoint pt2,
  //                                 CvLineIterator* line_iterator,
  //                                 int connectivity CV_DEFAULT(8),
  //                                 int left_to_right CV_DEFAULT(0));
  
  /* Moves iterator to the next line point */
  #define CV_NEXT_LINE_POINT( line_iterator )                     \
  {                                                               \
      int _line_iterator_mask = (line_iterator).err < 0 ? -1 : 0; \
      (line_iterator).err += (line_iterator).minus_delta +        \
          ((line_iterator).plus_delta & _line_iterator_mask);     \
      (line_iterator).ptr += (line_iterator).minus_step +         \
          ((line_iterator).plus_step & _line_iterator_mask);      \
  }
  
  
  /* basic font types */
  // #define CV_FONT_HERSHEY_SIMPLEX         0
  // #define CV_FONT_HERSHEY_PLAIN           1
  // #define CV_FONT_HERSHEY_DUPLEX          2
  // #define CV_FONT_HERSHEY_COMPLEX         3
  // #define CV_FONT_HERSHEY_TRIPLEX         4
  // #define CV_FONT_HERSHEY_COMPLEX_SMALL   5
  // #define CV_FONT_HERSHEY_SCRIPT_SIMPLEX  6
  // #define CV_FONT_HERSHEY_SCRIPT_COMPLEX  7
  
  // /* font flags */
  // #define CV_FONT_ITALIC                 16
  
  // #define CV_FONT_VECTOR0    CV_FONT_HERSHEY_SIMPLEX
  
  
  // /* Font structure */
  // typedef struct CvFont
  // {
  //   const char* nameFont;   //Qt:nameFont
  //   CvScalar color;       //Qt:ColorFont -> cvScalar(blue_component, green_component, red\_component[, alpha_component])
  //     int         font_face;    //Qt: bool italic         /* =CV_FONT_* */
  //     const int*  ascii;      /* font data and metrics */
  //     const int*  greek;
  //     const int*  cyrillic;
  //     float       hscale, vscale;
  //     float       shear;      /* slope coefficient: 0 - normal, >0 - italic */
  //     int         thickness;    //Qt: weight               /* letters thickness */
  //     float       dx;       /* horizontal interval between letters */
  //     int         line_type;    //Qt: PointSize
  // }
  // CvFont;
  
  // /* Initializes font structure used further in cvPutText */
  // CVAPI(void)  cvInitFont( CvFont* font, int font_face,
  //                          double hscale, double vscale,
  //                          double shear CV_DEFAULT(0),
  //                          int thickness CV_DEFAULT(1),
  //                          int line_type CV_DEFAULT(8));
  
  // CV_INLINE CvFont cvFont( double scale, int thickness CV_DEFAULT(1) )
  // {
  //     CvFont font;
  //     cvInitFont( &font, CV_FONT_HERSHEY_PLAIN, scale, scale, 0, thickness, CV_AA );
  //     return font;
  // }
  
  // /* Renders text stroke with specified font and color at specified location.
  //    CvFont should be initialized with cvInitFont */
  // CVAPI(void)  cvPutText( CvArr* img, const char* text, CvPoint org,
  //                         const CvFont* font, CvScalar color );
  
  // /* Calculates bounding box of text stroke (useful for alignment) */
  // CVAPI(void)  cvGetTextSize( const char* text_string, const CvFont* font,
  //                             CvSize* text_size, int* baseline );
  
  
  
  /* Unpacks color value, if arrtype is CV_8UC?, <color> is treated as
     packed color value, otherwise the first channels (depending on arrtype)
     of destination scalar are set to the same value = <color> */
  CVAPI(CvScalar)  cvColorToScalar( double packed_color, int arrtype );
  
  /* Returns the polygon points which make up the given ellipse.  The ellipse is define by
     the box of size 'axes' rotated 'angle' around the 'center'.  A partial sweep
     of the ellipse arc can be done by spcifying arc_start and arc_end to be something
     other than 0 and 360, respectively.  The input array 'pts' must be large enough to
     hold the result.  The total number of points stored into 'pts' is returned by this
     function. */
  CVAPI(int) cvEllipse2Poly( CvPoint center, CvSize axes,
                   int angle, int arc_start, int arc_end, CvPoint * pts, int delta );
  
  /* Draws contour outlines or filled interiors on the image */
  // CVAPI(void)  cvDrawContours( CvArr *img, CvSeq* contour,
  //                              CvScalar external_color, CvScalar hole_color,
  //                              int max_level, int thickness CV_DEFAULT(1),
  //                              int line_type CV_DEFAULT(8),
  //                              CvPoint offset CV_DEFAULT(cvPoint(0,0)));
  
  /* Does look-up transformation. Elements of the source array
     (that should be 8uC1 or 8sC1) are used as indexes in lutarr 256-element table */
  CVAPI(void) cvLUT( const CvArr* src, CvArr* dst, const CvArr* lut );
  
  
  /******************* Iteration through the sequence tree *****************/
  typedef struct CvTreeNodeIterator
  {
      const void* node;
      int level;
      int max_level;
  }
  CvTreeNodeIterator;
  
  CVAPI(void) cvInitTreeNodeIterator( CvTreeNodeIterator* tree_iterator,
                                     const void* first, int max_level );
  CVAPI(void*) cvNextTreeNode( CvTreeNodeIterator* tree_iterator );
  CVAPI(void*) cvPrevTreeNode( CvTreeNodeIterator* tree_iterator );
  
  /* Inserts sequence into tree with specified "parent" sequence.
     If parent is equal to frame (e.g. the most external contour),
     then added contour will have null pointer to parent. */
  CVAPI(void) cvInsertNodeIntoTree( void* node, void* parent, void* frame );
  
  /* Removes contour from tree (together with the contour children). */
  CVAPI(void) cvRemoveNodeFromTree( void* node, void* frame );
  
  /* Gathers pointers to all the sequences,
     accessible from the <first>, to the single sequence */
  CVAPI(CvSeq*) cvTreeToNodeSeq( const void* first, int header_size,
                                CvMemStorage* storage );
  
  /* The function implements the K-means algorithm for clustering an array of sample
     vectors in a specified number of classes */
  // #define CV_KMEANS_USE_INITIAL_LABELS    1
  // CVAPI(int) cvKMeans2( const CvArr* samples, int cluster_count, CvArr* labels,
  //                       CvTermCriteria termcrit, int attempts CV_DEFAULT(1),
  //                       CvRNG* rng CV_DEFAULT(0), int flags CV_DEFAULT(0),
  //                       CvArr* _centers CV_DEFAULT(0), double* compactness CV_DEFAULT(0) );
  
  /****************************************************************************************\
  *                                    System functions                                    *
  \****************************************************************************************/
  
  /* Add the function pointers table with associated information to the IPP primitives list */
  CVAPI(int)  cvRegisterModule( const CvModuleInfo* module_info );
  
  /* Loads optimized functions from IPP, MKL etc. or switches back to pure C code */
  CVAPI(int)  cvUseOptimized( int on_off );
  
  /* Retrieves information about the registered modules and loaded optimized plugins */
  CVAPI(void)  cvGetModuleInfo( const char* module_name,
                                const char** version,
                                const char** loaded_addon_plugins );
  
  typedef void* (CV_CDECL *CvAllocFunc)(size_t size, void* userdata);
  typedef int (CV_CDECL *CvFreeFunc)(void* pptr, void* userdata);
  
  /* Set user-defined memory managment functions (substitutors for malloc and free) that
     will be called by cvAlloc, cvFree and higher-level functions (e.g. cvCreateImage) */
  CVAPI(void) cvSetMemoryManager( CvAllocFunc alloc_func CV_DEFAULT(NULL),
                                 CvFreeFunc free_func CV_DEFAULT(NULL),
                                 void* userdata CV_DEFAULT(NULL));
  
  
  typedef IplImage* (CV_STDCALL* Cv_iplCreateImageHeader)
                              (int,int,int,char*,char*,int,int,int,int,int,
                              IplROI*,IplImage*,void*,IplTileInfo*);
  typedef void (CV_STDCALL* Cv_iplAllocateImageData)(IplImage*,int,int);
  typedef void (CV_STDCALL* Cv_iplDeallocate)(IplImage*,int);
  typedef IplROI* (CV_STDCALL* Cv_iplCreateROI)(int,int,int,int,int);
  typedef IplImage* (CV_STDCALL* Cv_iplCloneImage)(const IplImage*);
  
  /* Makes OpenCV use IPL functions for IplImage allocation/deallocation */
  CVAPI(void) cvSetIPLAllocators( Cv_iplCreateImageHeader create_header,
                                 Cv_iplAllocateImageData allocate_data,
                                 Cv_iplDeallocate deallocate,
                                 Cv_iplCreateROI create_roi,
                                 Cv_iplCloneImage clone_image );
  
  #define CV_TURN_ON_IPL_COMPATIBILITY()                                  \
      cvSetIPLAllocators( iplCreateImageHeader, iplAllocateImage,         \
                          iplDeallocate, iplCreateROI, iplCloneImage )
  
  /****************************************************************************************\
  *                                    Data Persistence                                    *
  \****************************************************************************************/
  
  /********************************** High-level functions ********************************/
  
  // /* opens existing or creates new file storage */
  // CVAPI(CvFileStorage*)  cvOpenFileStorage( const char* filename, CvMemStorage* memstorage,
  //                                           int flags, const char* encoding CV_DEFAULT(NULL) );
  
  // /* closes file storage and deallocates buffers */
  // CVAPI(void) cvReleaseFileStorage( CvFileStorage** fs );
  
  // /* returns attribute value or 0 (NULL) if there is no such attribute */
  // CVAPI(const char*) cvAttrValue( const CvAttrList* attr, const char* attr_name );
  
  // /* starts writing compound structure (map or sequence) */
  // CVAPI(void) cvStartWriteStruct( CvFileStorage* fs, const char* name,
  //                                 int struct_flags, const char* type_name CV_DEFAULT(NULL),
  //                                 CvAttrList attributes CV_DEFAULT(cvAttrList()));
  
  // /* finishes writing compound structure */
  // CVAPI(void) cvEndWriteStruct( CvFileStorage* fs );
  
  // /* writes an integer */
  // CVAPI(void) cvWriteInt( CvFileStorage* fs, const char* name, int value );
  
  // /* writes a floating-point number */
  // CVAPI(void) cvWriteReal( CvFileStorage* fs, const char* name, double value );
  
  // /* writes a string */
  // CVAPI(void) cvWriteString( CvFileStorage* fs, const char* name,
  //                            const char* str, int quote CV_DEFAULT(0) );
  
  // /* writes a comment */
  // CVAPI(void) cvWriteComment( CvFileStorage* fs, const char* comment,
  //                             int eol_comment );
  
  // /* writes instance of a standard type (matrix, image, sequence, graph etc.)
  //    or user-defined type */
  // CVAPI(void) cvWrite( CvFileStorage* fs, const char* name, const void* ptr,
  //                          CvAttrList attributes CV_DEFAULT(cvAttrList()));
  
  // /* starts the next stream */
  // CVAPI(void) cvStartNextStream( CvFileStorage* fs );
  
  // /* helper function: writes multiple integer or floating-point numbers */
  // CVAPI(void) cvWriteRawData( CvFileStorage* fs, const void* src,
  //                                 int len, const char* dt );
  
  // /* returns the hash entry corresponding to the specified literal key string or 0
  //    if there is no such a key in the storage */
  // CVAPI(CvStringHashNode*) cvGetHashedKey( CvFileStorage* fs, const char* name,
  //                                         int len CV_DEFAULT(-1),
  //                                         int create_missing CV_DEFAULT(0));
  
  // /* returns file node with the specified key within the specified map
  //    (collection of named nodes) */
  // CVAPI(CvFileNode*) cvGetRootFileNode( const CvFileStorage* fs,
  //                                      int stream_index CV_DEFAULT(0) );
  
  // /* returns file node with the specified key within the specified map
  //    (collection of named nodes) */
  // CVAPI(CvFileNode*) cvGetFileNode( CvFileStorage* fs, CvFileNode* map,
  //                                  const CvStringHashNode* key,
  //                                  int create_missing CV_DEFAULT(0) );
  
  // /* this is a slower version of cvGetFileNode that takes the key as a literal string */
  // CVAPI(CvFileNode*) cvGetFileNodeByName( const CvFileStorage* fs,
  //                                        const CvFileNode* map,
  //                                        const char* name );
  
  // CV_INLINE int cvReadInt( const CvFileNode* node, int default_value CV_DEFAULT(0) )
  // {
  //     return !node ? default_value :
  //         CV_NODE_IS_INT(node->tag) ? node->data.i :
  //         CV_NODE_IS_REAL(node->tag) ? cvRound(node->data.f) : 0x7fffffff;
  // }
  
  
  // CV_INLINE int cvReadIntByName( const CvFileStorage* fs, const CvFileNode* map,
  //                          const char* name, int default_value CV_DEFAULT(0) )
  // {
  //     return cvReadInt( cvGetFileNodeByName( fs, map, name ), default_value );
  // }
  
  
  // CV_INLINE double cvReadReal( const CvFileNode* node, double default_value CV_DEFAULT(0.) )
  // {
  //     return !node ? default_value :
  //         CV_NODE_IS_INT(node->tag) ? (double)node->data.i :
  //         CV_NODE_IS_REAL(node->tag) ? node->data.f : 1e300;
  // }
  
  
  // CV_INLINE double cvReadRealByName( const CvFileStorage* fs, const CvFileNode* map,
  //                         const char* name, double default_value CV_DEFAULT(0.) )
  // {
  //     return cvReadReal( cvGetFileNodeByName( fs, map, name ), default_value );
  // }
  
  
  // CV_INLINE const char* cvReadString( const CvFileNode* node,
  //                         const char* default_value CV_DEFAULT(NULL) )
  // {
  //     return !node ? default_value : CV_NODE_IS_STRING(node->tag) ? node->data.str.ptr : 0;
  // }
  
  
  // CV_INLINE const char* cvReadStringByName( const CvFileStorage* fs, const CvFileNode* map,
  //                         const char* name, const char* default_value CV_DEFAULT(NULL) )
  // {
  //     return cvReadString( cvGetFileNodeByName( fs, map, name ), default_value );
  // }
  
  
  // /* decodes standard or user-defined object and returns it */
  // CVAPI(void*) cvRead( CvFileStorage* fs, CvFileNode* node,
  //                         CvAttrList* attributes CV_DEFAULT(NULL));
  
  // /* decodes standard or user-defined object and returns it */
  // CV_INLINE void* cvReadByName( CvFileStorage* fs, const CvFileNode* map,
  //                               const char* name, CvAttrList* attributes CV_DEFAULT(NULL) )
  // {
  //     return cvRead( fs, cvGetFileNodeByName( fs, map, name ), attributes );
  // }
  
  
  // /* starts reading data from sequence or scalar numeric node */
  // CVAPI(void) cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src,
  //                                CvSeqReader* reader );
  
  // /* reads multiple numbers and stores them to array */
  // CVAPI(void) cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader,
  //                                int count, void* dst, const char* dt );
  
  // /* combination of two previous functions for easier reading of whole sequences */
  // CVAPI(void) cvReadRawData( const CvFileStorage* fs, const CvFileNode* src,
  //                           void* dst, const char* dt );
  
  // /* writes a copy of file node to file storage */
  // CVAPI(void) cvWriteFileNode( CvFileStorage* fs, const char* new_node_name,
  //                             const CvFileNode* node, int embed );
  
  // /* returns name of file node */
  // CVAPI(const char*) cvGetFileNodeName( const CvFileNode* node );
  
  /*********************************** Adding own types ***********************************/
  
  CVAPI(void) cvRegisterType( const CvTypeInfo* info );
  CVAPI(void) cvUnregisterType( const char* type_name );
  CVAPI(CvTypeInfo*) cvFirstType(void);
  CVAPI(CvTypeInfo*) cvFindType( const char* type_name );
  CVAPI(CvTypeInfo*) cvTypeOf( const void* struct_ptr );
  
  /* universal functions */
  CVAPI(void) cvRelease( void** struct_ptr );
  CVAPI(void*) cvClone( const void* struct_ptr );
  
  /* simple API for reading/writing data */
  CVAPI(void) cvSave( const char* filename, const void* struct_ptr,
                      const char* name CV_DEFAULT(NULL),
                      const char* comment CV_DEFAULT(NULL),
                      CvAttrList attributes CV_DEFAULT(cvAttrList()));
  CVAPI(void*) cvLoad( const char* filename,
                       CvMemStorage* memstorage CV_DEFAULT(NULL),
                       const char* name CV_DEFAULT(NULL),
                       const char** real_name CV_DEFAULT(NULL) );
  
  /*********************************** Measuring Execution Time ***************************/
  
  /* helper functions for RNG initialization and accurate time measurement:
     uses internal clock counter on x86 */
  CVAPI(int64)  cvGetTickCount( void );
  CVAPI(double) cvGetTickFrequency( void );
  
  /*********************************** CPU capabilities ***********************************/
  
  #define CV_CPU_NONE    0
  #define CV_CPU_MMX     1
  #define CV_CPU_SSE     2
  #define CV_CPU_SSE2    3
  #define CV_CPU_SSE3    4
  #define CV_CPU_SSSE3   5
  #define CV_CPU_SSE4_1  6
  #define CV_CPU_SSE4_2  7
  #define CV_CPU_POPCNT  8
  #define CV_CPU_AVX    10
  #define CV_CPU_AVX2   11
  #define CV_HARDWARE_MAX_FEATURE 255
  
  CVAPI(int) cvCheckHardwareSupport(int feature);
  
  /*********************************** Multi-Threading ************************************/
  
  /* retrieve/set the number of threads used in OpenMP implementations */
  CVAPI(int)  cvGetNumThreads( void );
  CVAPI(void) cvSetNumThreads( int threads CV_DEFAULT(0) );
  /* get index of the thread being executed */
  CVAPI(int)  cvGetThreadNum( void );
  
  
  /********************************** Error Handling **************************************/
  
  /* Get current OpenCV error status */
  CVAPI(int) cvGetErrStatus( void );
  
  /* Sets error status silently */
  CVAPI(void) cvSetErrStatus( int status );
  
  #define CV_ErrModeLeaf     0   /* Print error and exit program */
  #define CV_ErrModeParent   1   /* Print error and continue */
  #define CV_ErrModeSilent   2   /* Don't print and continue */
  
  /* Retrives current error processing mode */
  CVAPI(int)  cvGetErrMode( void );
  
  /* Sets error processing mode, returns previously used mode */
  CVAPI(int) cvSetErrMode( int mode );
  
  /* Sets error status and performs some additonal actions (displaying message box,
   writing message to stderr, terminating application etc.)
   depending on the current error mode */
  CVAPI(void) cvError( int status, const char* func_name,
                      const char* err_msg, const char* file_name, int line );
  
  /* Retrieves textual description of the error given its code */
  CVAPI(const char*) cvErrorStr( int status );
  
  /* Retrieves detailed information about the last error occured */
  CVAPI(int) cvGetErrInfo( const char** errcode_desc, const char** description,
                          const char** filename, int* line );
  
  /* Maps IPP error codes to the counterparts from OpenCV */
  CVAPI(int) cvErrorFromIppStatus( int ipp_status );
  
  typedef int (CV_CDECL *CvErrorCallback)( int status, const char* func_name,
                                          const char* err_msg, const char* file_name, int line, void* userdata );
  
  /* Assigns a new error-handling function */
  CVAPI(CvErrorCallback) cvRedirectError( CvErrorCallback error_handler,
                                         void* userdata CV_DEFAULT(NULL),
                                         void** prev_userdata CV_DEFAULT(NULL) );
  
  /*
   Output to:
   cvNulDevReport - nothing
   cvStdErrReport - console(fprintf(stderr,...))
   cvGuiBoxReport - MessageBox(WIN32)
   */
  CVAPI(int) cvNulDevReport( int status, const char* func_name, const char* err_msg,
                            const char* file_name, int line, void* userdata );
  
  CVAPI(int) cvStdErrReport( int status, const char* func_name, const char* err_msg,
                            const char* file_name, int line, void* userdata );
  
  CVAPI(int) cvGuiBoxReport( int status, const char* func_name, const char* err_msg,
                            const char* file_name, int line, void* userdata );
  
  #define OPENCV_ERROR(status,func,context)                           \
  cvError((status),(func),(context),__FILE__,__LINE__)
  
  #define OPENCV_ERRCHK(func,context)                                 \
  {if (cvGetErrStatus() >= 0)                         \
  {OPENCV_ERROR(CV_StsBackTrace,(func),(context));}}
  
  #define OPENCV_ASSERT(expr,func,context)                            \
  {if (! (expr))                                      \
  {OPENCV_ERROR(CV_StsInternal,(func),(context));}}
  
  #define OPENCV_RSTERR() (cvSetErrStatus(CV_StsOk))
  
  #define OPENCV_CALL( Func )                                         \
  {                                                                   \
  Func;                                                           \
  }
  
  
  /* CV_FUNCNAME macro defines icvFuncName constant which is used by CV_ERROR macro */
  #ifdef CV_NO_FUNC_NAMES
  #define CV_FUNCNAME( Name )
  #define cvFuncName ""
  #else
  #define CV_FUNCNAME( Name )  \
  static char cvFuncName[] = Name
  #endif
  
  
  /*
   CV_ERROR macro unconditionally raises error with passed code and message.
   After raising error, control will be transferred to the exit label.
   */
  #define CV_ERROR( Code, Msg )                                       \
  {                                                                   \
      cvError( (Code), cvFuncName, Msg, __FILE__, __LINE__ );        \
      __CV_EXIT__;                                                   \
  }
  
  /* Simplified form of CV_ERROR */
  #define CV_ERROR_FROM_CODE( code )   \
      CV_ERROR( code, "" )
  
  /*
   CV_CHECK macro checks error status after CV (or IPL)
   function call. If error detected, control will be transferred to the exit
   label.
   */
  #define CV_CHECK()                                                  \
  {                                                                   \
      if( cvGetErrStatus() < 0 )                                      \
          CV_ERROR( CV_StsBackTrace, "Inner function failed." );      \
  }
  
  
  /*
   CV_CALL macro calls CV (or IPL) function, checks error status and
   signals a error if the function failed. Useful in "parent node"
   error procesing mode
   */
  #define CV_CALL( Func )                                             \
  {                                                                   \
      Func;                                                           \
      CV_CHECK();                                                     \
  }
  
  
  /* Runtime assertion macro */
  #define CV_ASSERT( Condition )                                          \
  {                                                                       \
      if( !(Condition) )                                                  \
          CV_ERROR( CV_StsInternal, "Assertion: " #Condition " failed" ); \
  }
  
  #define __CV_BEGIN__       {
  #define __CV_END__         goto exit; exit: ; }
  #define __CV_EXIT__        goto exit
  
  #ifdef __cplusplus
  }
  
  // classes for automatic module/RTTI data registration/unregistration
  struct CV_EXPORTS CvModule
  {
      CvModule( CvModuleInfo* _info );
      ~CvModule();
      CvModuleInfo* info;
  
      static CvModuleInfo* first;
      static CvModuleInfo* last;
  };
  
  // struct CV_EXPORTS CvType
  // {
  //     CvType( const char* type_name,
  //             CvIsInstanceFunc is_instance, CvReleaseFunc release=0,
  //             CvReadFunc read=0, CvWriteFunc write=0, CvCloneFunc clone=0 );
  //     ~CvType();
  //     CvTypeInfo* info;
  
  //     static CvTypeInfo* first;
  //     static CvTypeInfo* last;
  // };
  
  #endif
  
  #endif
  