text: ////////////////////////////////////////////////////////////////////////////////////////
  //
  //  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 For Embedded Computer Vision Library
  //
  // Copyright (c) 2008-2012, EMCV Project,
  // Copyright (c) 2000-2007, Intel Corporation,
  // 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:
  //
  //    * Redistributions of source code must retain the above copyright notice, 
  //      this list of conditions and the following disclaimer.
  //    * Redistributions 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.
  //    * Neither the name of the copyright holders nor the names of their contributors 
  //      may 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 COPYRIGHT OWNER 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.
  //
  // Contributors:
  //    * Shiqi Yu (Shenzhen Institute of Advanced Technology, Chinese Academy of Sciences)
  
  #ifndef _CV_H_
  #define _CV_H_
  
  #include "../cxcore/cxcore.h"
  #include "cvtypes.h"
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  
  /****************************************************************************************\
  *                                    Image Processing                                    *
  \****************************************************************************************/
  
  /* Copies source 2D array inside of the larger destination array and
     makes a border of the specified type (IPL_BORDER_*) around the copied area. */
  CVAPI(void) cvCopyMakeBorder( const CvArr* src, CvArr* dst, CvPoint offset,
                                int bordertype, CvScalar value CV_DEFAULT(cvScalarAll(0)));
  
  #define CV_BLUR_NO_SCALE 0
  #define CV_BLUR  1
  #define CV_GAUSSIAN  2
  #define CV_MEDIAN 3
  #define CV_BILATERAL 4
  
  /* Smoothes array (removes noise) */
  CVAPI(void) cvSmooth( const CvArr* src, CvArr* dst,
                        int smoothtype CV_DEFAULT(CV_GAUSSIAN),
                        int param1 CV_DEFAULT(3),
                        int param2 CV_DEFAULT(0),
                        double param3 CV_DEFAULT(0),
                        double param4 CV_DEFAULT(0));
  
  /* Convolves the image with the kernel */
  CVAPI(void) cvFilter2D( const CvArr* src, CvArr* dst, const CvMat* kernel,
                          CvPoint anchor CV_DEFAULT(cvPoint(-1,-1)));
  
  /* Finds integral image: SUM(X,Y) = sum(x<X,y<Y)I(x,y) */
  CVAPI(void) cvIntegral( const CvArr* image, CvArr* sum,
                         CvArr* sqsum CV_DEFAULT(NULL),
                         CvArr* tilted_sum CV_DEFAULT(NULL));
  
  /*
     Smoothes the input image with gaussian kernel and then down-samples it.
     dst_width = floor(src_width/2)[+1],
     dst_height = floor(src_height/2)[+1]
  */
  CVAPI(void)  cvPyrDown( const CvArr* src, CvArr* dst,
                          int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );
  
  /* 
     Up-samples image and smoothes the result with gaussian kernel.
     dst_width = src_width*2,
     dst_height = src_height*2
  */
  CVAPI(void)  cvPyrUp( const CvArr* src, CvArr* dst,
                        int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );
  
  
  /* Builds the whole pyramid at once. Output array of CvMat headers (levels[*])
     is initialized with the headers of subsequent pyramid levels */
  /*CVAPI  void  cvCalcPyramid( const CvArr* src, CvArr* container,
                                CvMat* levels, int level_count,
                                int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );*/
  
  
  /* Splits color or grayscale image into multiple connected components
     of nearly the same color/brightness using modification of Burt algorithm.
     comp with contain a pointer to sequence (CvSeq)
     of connected components (CvConnectedComp) */
  CVAPI(void) cvPyrSegmentation( IplImage* src, IplImage* dst,
                                CvMemStorage* storage, CvSeq** comp,
                                int level, double threshold1,
                                double threshold2 );
  
  /* Filters image using meanshift algorithm */
  CVAPI(void) cvPyrMeanShiftFiltering( const CvArr* src, CvArr* dst, 
      double sp, double sr, int max_level CV_DEFAULT(1),
      CvTermCriteria termcrit CV_DEFAULT(cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,5,1)));
  
  /* Segments image using seed "markers" */
  CVAPI(void) cvWatershed( const CvArr* image, CvArr* markers );
  
  #define CV_INPAINT_NS      0
  #define CV_INPAINT_TELEA   1
  
  /* Inpaints the selected region in the image */
  CVAPI(void) cvInpaint( const CvArr* src, const CvArr* inpaint_mask,
                         CvArr* dst, double inpaintRange, int flags );
  
  #define CV_SCHARR -1
  #define CV_MAX_SOBEL_KSIZE 7
  
  /* Calculates an image derivative using generalized Sobel
     (aperture_size = 1,3,5,7) or Scharr (aperture_size = -1) operator.
     Scharr can be used only for the first dx or dy derivative */
  CVAPI(void) cvSobel( const CvArr* src, CvArr* dst,
                      int xorder, int yorder,
                      int aperture_size CV_DEFAULT(3));
  
  /* Calculates the image Laplacian: (d2/dx + d2/dy)I */
  CVAPI(void) cvLaplace( const CvArr* src, CvArr* dst,
                        int aperture_size CV_DEFAULT(3) );
  
  /* Constants for color conversion */
  #define  CV_BGR2BGRA    0
  #define  CV_RGB2RGBA    CV_BGR2BGRA
  
  #define  CV_BGRA2BGR    1
  #define  CV_RGBA2RGB    CV_BGRA2BGR
  
  #define  CV_BGR2RGBA    2
  #define  CV_RGB2BGRA    CV_BGR2RGBA
  
  #define  CV_RGBA2BGR    3
  #define  CV_BGRA2RGB    CV_RGBA2BGR
  
  #define  CV_BGR2RGB     4
  #define  CV_RGB2BGR     CV_BGR2RGB
  
  #define  CV_BGRA2RGBA   5
  #define  CV_RGBA2BGRA   CV_BGRA2RGBA
  
  #define  CV_BGR2GRAY    6
  #define  CV_RGB2GRAY    7
  #define  CV_GRAY2BGR    8
  #define  CV_GRAY2RGB    CV_GRAY2BGR
  #define  CV_GRAY2BGRA   9
  #define  CV_GRAY2RGBA   CV_GRAY2BGRA
  #define  CV_BGRA2GRAY   10
  #define  CV_RGBA2GRAY   11
  
  #define  CV_BGR2BGR565  12
  #define  CV_RGB2BGR565  13
  #define  CV_BGR5652BGR  14
  #define  CV_BGR5652RGB  15
  #define  CV_BGRA2BGR565 16
  #define  CV_RGBA2BGR565 17
  #define  CV_BGR5652BGRA 18
  #define  CV_BGR5652RGBA 19
  
  #define  CV_GRAY2BGR565 20
  #define  CV_BGR5652GRAY 21
  
  #define  CV_BGR2BGR555  22
  #define  CV_RGB2BGR555  23
  #define  CV_BGR5552BGR  24
  #define  CV_BGR5552RGB  25
  #define  CV_BGRA2BGR555 26
  #define  CV_RGBA2BGR555 27
  #define  CV_BGR5552BGRA 28
  #define  CV_BGR5552RGBA 29
  
  #define  CV_GRAY2BGR555 30
  #define  CV_BGR5552GRAY 31
  
  #define  CV_BGR2XYZ     32
  #define  CV_RGB2XYZ     33
  #define  CV_XYZ2BGR     34
  #define  CV_XYZ2RGB     35
  
  #define  CV_BGR2YCrCb   36
  #define  CV_RGB2YCrCb   37
  #define  CV_YCrCb2BGR   38
  #define  CV_YCrCb2RGB   39
  
  #define  CV_BGR2HSV     40
  #define  CV_RGB2HSV     41
  
  #define  CV_BGR2Lab     44
  #define  CV_RGB2Lab     45
  
  #define  CV_BayerBG2BGR 46
  #define  CV_BayerGB2BGR 47
  #define  CV_BayerRG2BGR 48
  #define  CV_BayerGR2BGR 49
  
  #define  CV_BayerBG2RGB CV_BayerRG2BGR
  #define  CV_BayerGB2RGB CV_BayerGR2BGR
  #define  CV_BayerRG2RGB CV_BayerBG2BGR
  #define  CV_BayerGR2RGB CV_BayerGB2BGR
  
  #define  CV_BGR2Luv     50
  #define  CV_RGB2Luv     51
  #define  CV_BGR2HLS     52
  #define  CV_RGB2HLS     53
  
  #define  CV_HSV2BGR     54
  #define  CV_HSV2RGB     55
  
  #define  CV_Lab2BGR     56
  #define  CV_Lab2RGB     57
  #define  CV_Luv2BGR     58
  #define  CV_Luv2RGB     59
  #define  CV_HLS2BGR     60
  #define  CV_HLS2RGB     61
  
  #define  CV_COLORCVT_MAX  100
  
  /* Converts input array pixels from one color space to another */
  CVAPI(void)  cvCvtColor( const CvArr* src, CvArr* dst, int code );
  
  #define  CV_INTER_NN        0
  #define  CV_INTER_LINEAR    1
  #define  CV_INTER_CUBIC     2
  #define  CV_INTER_AREA      3
  
  #define  CV_WARP_FILL_OUTLIERS 8
  #define  CV_WARP_INVERSE_MAP  16
  
  /* Resizes image (input array is resized to fit the destination array) */
  CVAPI(void)  cvResize( const CvArr* src, CvArr* dst,
                         int interpolation CV_DEFAULT( CV_INTER_LINEAR ));
  
  /* Warps image with affine transform */ 
  CVAPI(void)  cvWarpAffine( const CvArr* src, CvArr* dst, const CvMat* map_matrix,
                             int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS),
                             CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
  
  /* Computes affine transform matrix for mapping src[i] to dst[i] (i=0,1,2) */
  CVAPI(CvMat*) cvGetAffineTransform( const CvPoint2D32f * src, 
                                      const CvPoint2D32f * dst, 
                                      CvMat * map_matrix );
  
  /* Computes rotation_matrix matrix */
  CVAPI(CvMat*)  cv2DRotationMatrix( CvPoint2D32f center, double angle,
                                     double scale, CvMat* map_matrix );
  
  /* Warps image with perspective (projective) transform */
  CVAPI(void)  cvWarpPerspective( const CvArr* src, CvArr* dst, const CvMat* map_matrix,
                                  int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS),
                                  CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
  
  /* Computes perspective transform matrix for mapping src[i] to dst[i] (i=0,1,2,3) */
  CVAPI(CvMat*) cvGetPerspectiveTransform( const CvPoint2D32f* src,
                                           const CvPoint2D32f* dst,
                                           CvMat* map_matrix );
  
  /* Performs generic geometric transformation using the specified coordinate maps */
  CVAPI(void)  cvRemap( const CvArr* src, CvArr* dst,
                        const CvArr* mapx, const CvArr* mapy,
                        int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS),
                        CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
  
  /* Performs forward or inverse log-polar image transform */
  CVAPI(void)  cvLogPolar( const CvArr* src, CvArr* dst,
                           CvPoint2D32f center, double M,
                           int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS));
  
  #define  CV_SHAPE_RECT      0
  #define  CV_SHAPE_CROSS     1
  #define  CV_SHAPE_ELLIPSE   2
  #define  CV_SHAPE_CUSTOM    100
  
  /* creates structuring element used for morphological operations */
  CVAPI(IplConvKernel*)  cvCreateStructuringElementEx(
              int cols, int  rows, int  anchor_x, int  anchor_y,
              int shape, int* values CV_DEFAULT(NULL) );
  
  /* releases structuring element */
  CVAPI(void)  cvReleaseStructuringElement( IplConvKernel** element );
  
  /* erodes input image (applies minimum filter) one or more times.
     If element pointer is NULL, 3x3 rectangular element is used */
  CVAPI(void)  cvErode( const CvArr* src, CvArr* dst,
                        IplConvKernel* element CV_DEFAULT(NULL),
                        int iterations CV_DEFAULT(1) );
  
  /* dilates input image (applies maximum filter) one or more times.
     If element pointer is NULL, 3x3 rectangular element is used */
  CVAPI(void)  cvDilate( const CvArr* src, CvArr* dst,
                         IplConvKernel* element CV_DEFAULT(NULL),
                         int iterations CV_DEFAULT(1) );
  
  #define CV_MOP_OPEN         2
  #define CV_MOP_CLOSE        3
  #define CV_MOP_GRADIENT     4
  #define CV_MOP_TOPHAT       5
  #define CV_MOP_BLACKHAT     6
  
  /* Performs complex morphological transformation */
  CVAPI(void)  cvMorphologyEx( const CvArr* src, CvArr* dst,
                               CvArr* temp, IplConvKernel* element,
                               int operation, int iterations CV_DEFAULT(1) );
  
  /* Calculates all spatial and central moments up to the 3rd order */
  CVAPI(void) cvMoments( const CvArr* arr, CvMoments* moments, int binary CV_DEFAULT(0));
  
  /* Retrieve particular spatial, central or normalized central moments */
  CVAPI(double)  cvGetSpatialMoment( CvMoments* moments, int x_order, int y_order );
  CVAPI(double)  cvGetCentralMoment( CvMoments* moments, int x_order, int y_order );
  CVAPI(double)  cvGetNormalizedCentralMoment( CvMoments* moments,
                                               int x_order, int y_order );
  
  /* Calculates 7 Hu's invariants from precalculated spatial and central moments */
  CVAPI(void) cvGetHuMoments( CvMoments*  moments, CvHuMoments*  hu_moments );
  
  /*********************************** data sampling **************************************/
  
  /* Fetches pixels that belong to the specified line segment and stores them to the buffer.
     Returns the number of retrieved points. */
  CVAPI(int)  cvSampleLine( const CvArr* image, CvPoint pt1, CvPoint pt2, void* buffer,
                            int connectivity CV_DEFAULT(8));
  
  /* Retrieves the rectangular image region with specified center from the input array.
   dst(x,y) <- src(x + center.x - dst_width/2, y + center.y - dst_height/2).
   Values of pixels with fractional coordinates are retrieved using bilinear interpolation*/
  CVAPI(void)  cvGetRectSubPix( const CvArr* src, CvArr* dst, CvPoint2D32f center );
  
  
  /* Retrieves quadrangle from the input array.
      matrixarr = ( a11  a12 | b1 )   dst(x,y) <- src(A[x y]' + b)
                  ( a21  a22 | b2 )   (bilinear interpolation is used to retrieve pixels
                                       with fractional coordinates)
  */
  CVAPI(void)  cvGetQuadrangleSubPix( const CvArr* src, CvArr* dst,
                                      const CvMat* map_matrix );
  
  /* Methods for comparing two array */
  #define  CV_TM_SQDIFF        0
  #define  CV_TM_SQDIFF_NORMED 1
  #define  CV_TM_CCORR         2
  #define  CV_TM_CCORR_NORMED  3
  #define  CV_TM_CCOEFF        4
  #define  CV_TM_CCOEFF_NORMED 5
  
  /* Measures similarity between template and overlapped windows in the source image
     and fills the resultant image with the measurements */
  CVAPI(void)  cvMatchTemplate( const CvArr* image, const CvArr* templ,
                                CvArr* result, int method );
  
  /* Computes earth mover distance between
     two weighted point sets (called signatures) */
  CVAPI(float)  cvCalcEMD2( const CvArr* signature1,
                            const CvArr* signature2,
                            int distance_type,
                            CvDistanceFunction distance_func CV_DEFAULT(NULL),
                            const CvArr* cost_matrix CV_DEFAULT(NULL),
                            CvArr* flow CV_DEFAULT(NULL),
                            float* lower_bound CV_DEFAULT(NULL),
                            void* userdata CV_DEFAULT(NULL));
  
  /****************************************************************************************\
  *                              Contours retrieving                                       *
  \****************************************************************************************/
  
  /* Retrieves outer and optionally inner boundaries of white (non-zero) connected
     components in the black (zero) background */
  CVAPI(int)  cvFindContours( CvArr* image, CvMemStorage* storage, CvSeq** first_contour,
                              int header_size CV_DEFAULT(sizeof(CvContour)),
                              int mode CV_DEFAULT(CV_RETR_LIST),
                              int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
                              CvPoint offset CV_DEFAULT(cvPoint(0,0)));
  
  
  /* Initalizes contour retrieving process.
     Calls cvStartFindContours.
     Calls cvFindNextContour until null pointer is returned
     or some other condition becomes true.
     Calls cvEndFindContours at the end. */
  CVAPI(CvContourScanner)  cvStartFindContours( CvArr* image, CvMemStorage* storage,
                              int header_size CV_DEFAULT(sizeof(CvContour)),
                              int mode CV_DEFAULT(CV_RETR_LIST),
                              int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
                              CvPoint offset CV_DEFAULT(cvPoint(0,0)));
  
  /* Retrieves next contour */
  CVAPI(CvSeq*)  cvFindNextContour( CvContourScanner scanner );
  
  
  /* Substitutes the last retrieved contour with the new one
     (if the substitutor is null, the last retrieved contour is removed from the tree) */
  CVAPI(void)   cvSubstituteContour( CvContourScanner scanner, CvSeq* new_contour );
  
  
  /* Releases contour scanner and returns pointer to the first outer contour */
  CVAPI(CvSeq*)  cvEndFindContours( CvContourScanner* scanner );
  
  /* Approximates a single Freeman chain or a tree of chains to polygonal curves */
  CVAPI(CvSeq*) cvApproxChains( CvSeq* src_seq, CvMemStorage* storage,
                              int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
                              double parameter CV_DEFAULT(0),
                              int  minimal_perimeter CV_DEFAULT(0),
                              int  recursive CV_DEFAULT(0));
  
  
  /* Initalizes Freeman chain reader.
     The reader is used to iteratively get coordinates of all the chain points.
     If the Freeman codes should be read as is, a simple sequence reader should be used */
  CVAPI(void) cvStartReadChainPoints( CvChain* chain, CvChainPtReader* reader );
  
  /* Retrieves the next chain point */
  CVAPI(CvPoint) cvReadChainPoint( CvChainPtReader* reader );
  
  
  /****************************************************************************************\
  *                                  Motion Analysis                                       *
  \****************************************************************************************/
  
  /************************************ optical flow ***************************************/
  
  /* Calculates optical flow for 2 images using classical Lucas & Kanade algorithm */
  CVAPI(void)  cvCalcOpticalFlowLK( const CvArr* prev, const CvArr* curr,
                                    CvSize win_size, CvArr* velx, CvArr* vely );
  
  /* Calculates optical flow for 2 images using block matching algorithm */
  CVAPI(void)  cvCalcOpticalFlowBM( const CvArr* prev, const CvArr* curr,
                                    CvSize block_size, CvSize shift_size,
                                    CvSize max_range, int use_previous,
                                    CvArr* velx, CvArr* vely );
  
  /* Calculates Optical flow for 2 images using Horn & Schunck algorithm */
  CVAPI(void)  cvCalcOpticalFlowHS( const CvArr* prev, const CvArr* curr,
                                    int use_previous, CvArr* velx, CvArr* vely,
                                    double lambda, CvTermCriteria criteria );
  
  #define  CV_LKFLOW_PYR_A_READY       1
  #define  CV_LKFLOW_PYR_B_READY       2
  #define  CV_LKFLOW_INITIAL_GUESSES   4
  
  /* It is Lucas & Kanade method, modified to use pyramids.
     Also it does several iterations to get optical flow for
     every point at every pyramid level.
     Calculates optical flow between two images for certain set of points (i.e.
     it is a "sparse" optical flow, which is opposite to the previous 3 methods) */
  CVAPI(void)  cvCalcOpticalFlowPyrLK( const CvArr*  prev, const CvArr*  curr,
                                       CvArr*  prev_pyr, CvArr*  curr_pyr,
                                       const CvPoint2D32f* prev_features,
                                       CvPoint2D32f* curr_features,
                                       int       count,
                                       CvSize    win_size,
                                       int       level,
                                       char*     status,
                                       float*    track_error,
                                       CvTermCriteria criteria,
                                       int       flags );
  
  
  /* Modification of a previous sparse optical flow algorithm to calculate
     affine flow */
  /*CVAPI  void  cvCalcAffineFlowPyrLK( const CvArr*  prev, const CvArr*  curr,
                                       CvArr*  prev_pyr, CvArr*  curr_pyr,
                                       CvPoint2D32f* prev_features,
                                       CvPoint2D32f* curr_features,
                                       float*  matrices, int  count,
                                       CvSize  win_size, int  level,
                                       char*  status, float* track_error,
                                       CvTermCriteria criteria, int flags );*/
  
  /********************************* motion templates *************************************/
  
  /****************************************************************************************\
  *        All the motion template functions work only with single channel images.         *
  *        Silhouette image must have depth IPL_DEPTH_8U or IPL_DEPTH_8S                   *
  *        Motion history image must have depth IPL_DEPTH_32F,                             *
  *        Gradient mask - IPL_DEPTH_8U or IPL_DEPTH_8S,                                   *
  *        Motion orientation image - IPL_DEPTH_32F                                        *
  *        Segmentation mask - IPL_DEPTH_32F                                               *
  *        All the angles are in degrees, all the times are in milliseconds                *
  \****************************************************************************************/
  
  /* Updates motion history image given motion silhouette */
  CVAPI(void)    cvUpdateMotionHistory( const CvArr* silhouette, CvArr* mhi,
                                        double timestamp, double duration );
  
  /* Calculates gradient of the motion history image and fills
     a mask indicating where the gradient is valid */
  CVAPI(void)    cvCalcMotionGradient( const CvArr* mhi, CvArr* mask, CvArr* orientation,
                                       double delta1, double delta2,
                                       int aperture_size CV_DEFAULT(3));
  
  /* Calculates average motion direction within a selected motion region 
     (region can be selected by setting ROIs and/or by composing a valid gradient mask
     with the region mask) */
  CVAPI(double)  cvCalcGlobalOrientation( const CvArr* orientation, const CvArr* mask,
                                          const CvArr* mhi, double timestamp,
                                          double duration );
  
  /* Splits a motion history image into a few parts corresponding to separate independent motions
     (e.g. left hand, right hand) */
  CVAPI(CvSeq*)  cvSegmentMotion( const CvArr* mhi, CvArr* seg_mask,
                                  CvMemStorage* storage,
                                  double timestamp, double seg_thresh );
  
  /*********************** Background statistics accumulation *****************************/
  
  /* Adds image to accumulator */
  CVAPI(void)  cvAcc( const CvArr* image, CvArr* sum,
                      const CvArr* mask CV_DEFAULT(NULL) );
  
  /* Adds squared image to accumulator */
  CVAPI(void)  cvSquareAcc( const CvArr* image, CvArr* sqsum,
                            const CvArr* mask CV_DEFAULT(NULL) );
  
  /* Adds a product of two images to accumulator */
  CVAPI(void)  cvMultiplyAcc( const CvArr* image1, const CvArr* image2, CvArr* acc,
                              const CvArr* mask CV_DEFAULT(NULL) );
  
  /* Adds image to accumulator with weights: acc = acc*(1-alpha) + image*alpha */
  CVAPI(void)  cvRunningAvg( const CvArr* image, CvArr* acc, double alpha,
                             const CvArr* mask CV_DEFAULT(NULL) );
  
  
  /****************************************************************************************\
  *                                       Tracking                                         *
  \****************************************************************************************/
  
  /* Implements CAMSHIFT algorithm - determines object position, size and orientation
     from the object histogram back project (extension of meanshift) */
  CVAPI(int)  cvCamShift( const CvArr* prob_image, CvRect  window,
                         CvTermCriteria criteria, CvConnectedComp* comp,
                         CvBox2D* box CV_DEFAULT(NULL) );
  
  /* Implements MeanShift algorithm - determines object position
     from the object histogram back project */
  CVAPI(int)  cvMeanShift( const CvArr* prob_image, CvRect  window,
                          CvTermCriteria criteria, CvConnectedComp* comp );
  
  /* Creates ConDensation filter state */
  CVAPI(CvConDensation*)  cvCreateConDensation( int dynam_params,
                                               int measure_params,
                                               int sample_count );
  
  /* Releases ConDensation filter state */
  CVAPI(void)  cvReleaseConDensation( CvConDensation** condens );
  
  /* Updates ConDensation filter by time (predict future state of the system) */
  CVAPI(void)  cvConDensUpdateByTime( CvConDensation* condens);
  
  /* Initializes ConDensation filter samples  */
  CVAPI(void)  cvConDensInitSampleSet( CvConDensation* condens, CvMat* lower_bound, CvMat* upper_bound );
  
  /* Creates Kalman filter and sets A, B, Q, R and state to some initial values */
  CVAPI(CvKalman*) cvCreateKalman( int dynam_params, int measure_params,
                                  int control_params CV_DEFAULT(0));
  
  /* Releases Kalman filter state */
  CVAPI(void)  cvReleaseKalman( CvKalman** kalman);
  
  /* Updates Kalman filter by time (predicts future state of the system) */
  CVAPI(const CvMat*)  cvKalmanPredict( CvKalman* kalman,
                                       const CvMat* control CV_DEFAULT(NULL));
  
  /* Updates Kalman filter by measurement
     (corrects state of the system and internal matrices) */
  CVAPI(const CvMat*)  cvKalmanCorrect( CvKalman* kalman, const CvMat* measurement );
  
  /****************************************************************************************\
  *                              Planar subdivisions                                       *
  \****************************************************************************************/
  
  /* Initializes Delaunay triangulation */
  CVAPI(void)  cvInitSubdivDelaunay2D( CvSubdiv2D* subdiv, CvRect rect );
  
  /* Creates new subdivision */
  CVAPI(CvSubdiv2D*)  cvCreateSubdiv2D( int subdiv_type, int header_size,
                                        int vtx_size, int quadedge_size,
                                        CvMemStorage* storage );
  
  /************************* high-level subdivision functions ***************************/
  
  /* Simplified Delaunay diagram creation */
  CV_INLINE  CvSubdiv2D* cvCreateSubdivDelaunay2D( CvRect rect, CvMemStorage* storage )
  {
      CvSubdiv2D* subdiv = cvCreateSubdiv2D( CV_SEQ_KIND_SUBDIV2D, sizeof(*subdiv),
                           sizeof(CvSubdiv2DPoint), sizeof(CvQuadEdge2D), storage );
  
      cvInitSubdivDelaunay2D( subdiv, rect );
      return subdiv;
  }
  
  
  /* Inserts new point to the Delaunay triangulation */
  CVAPI(CvSubdiv2DPoint*)  cvSubdivDelaunay2DInsert( CvSubdiv2D* subdiv, CvPoint2D32f pt);
  
  /* Locates a point within the Delaunay triangulation (finds the edge
     the point is left to or belongs to, or the triangulation point the given
     point coinsides with */
  CVAPI(CvSubdiv2DPointLocation)  cvSubdiv2DLocate(
                                 CvSubdiv2D* subdiv, CvPoint2D32f pt,
                                 CvSubdiv2DEdge* edge,
                                 CvSubdiv2DPoint** vertex CV_DEFAULT(NULL) );
  
  /* Calculates Voronoi tesselation (i.e. coordinates of Voronoi points) */
  CVAPI(void)  cvCalcSubdivVoronoi2D( CvSubdiv2D* subdiv );
  
  
  /* Removes all Voronoi points from the tesselation */
  CVAPI(void)  cvClearSubdivVoronoi2D( CvSubdiv2D* subdiv );
  
  
  /* Finds the nearest to the given point vertex in subdivision. */
  CVAPI(CvSubdiv2DPoint*) cvFindNearestPoint2D( CvSubdiv2D* subdiv, CvPoint2D32f pt );
  
  
  /************ Basic quad-edge navigation and operations ************/
  
  CV_INLINE  CvSubdiv2DEdge  cvSubdiv2DNextEdge( CvSubdiv2DEdge edge )
  {
      return  CV_SUBDIV2D_NEXT_EDGE(edge);
  }
  
  
  CV_INLINE  CvSubdiv2DEdge  cvSubdiv2DRotateEdge( CvSubdiv2DEdge edge, int rotate )
  {
      return  (edge & ~3) + ((edge + rotate) & 3);
  }
  
  CV_INLINE  CvSubdiv2DEdge  cvSubdiv2DSymEdge( CvSubdiv2DEdge edge )
  {
      return edge ^ 2;
  }
  
  CV_INLINE  CvSubdiv2DEdge  cvSubdiv2DGetEdge( CvSubdiv2DEdge edge, CvNextEdgeType type )
  {
      CvQuadEdge2D* e = (CvQuadEdge2D*)(edge & ~3);
      edge = e->next[(edge + (int)type) & 3];
      return  (edge & ~3) + ((edge + ((int)type >> 4)) & 3);
  }
  
  
  CV_INLINE  CvSubdiv2DPoint*  cvSubdiv2DEdgeOrg( CvSubdiv2DEdge edge )
  {
      CvQuadEdge2D* e = (CvQuadEdge2D*)(edge & ~3);
      return (CvSubdiv2DPoint*)e->pt[edge & 3];
  }
  
  
  CV_INLINE  CvSubdiv2DPoint*  cvSubdiv2DEdgeDst( CvSubdiv2DEdge edge )
  {
      CvQuadEdge2D* e = (CvQuadEdge2D*)(edge & ~3);
      return (CvSubdiv2DPoint*)e->pt[(edge + 2) & 3];
  }
  
  
  CV_INLINE  double  cvTriangleArea( CvPoint2D32f a, CvPoint2D32f b, CvPoint2D32f c )
  {
      return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
  }
  
  
  /****************************************************************************************\
  *                            Contour Processing and Shape Analysis                       *
  \****************************************************************************************/
  
  #define CV_POLY_APPROX_DP 0
  
  /* Approximates a single polygonal curve (contour) or
     a tree of polygonal curves (contours) */
  CVAPI(CvSeq*)  cvApproxPoly( const void* src_seq,
                               int header_size, CvMemStorage* storage,
                               int method, double parameter,
                               int parameter2 CV_DEFAULT(0));
  
  #define CV_DOMINANT_IPAN 1
  
  /* Finds high-curvature points of the contour */
  CVAPI(CvSeq*) cvFindDominantPoints( CvSeq* contour, CvMemStorage* storage,
                                     int method CV_DEFAULT(CV_DOMINANT_IPAN),
                                     double parameter1 CV_DEFAULT(0),
                                     double parameter2 CV_DEFAULT(0),
                                     double parameter3 CV_DEFAULT(0),
                                     double parameter4 CV_DEFAULT(0));
  
  /* Calculates perimeter of a contour or length of a part of contour */
  CVAPI(double)  cvArcLength( const void* curve,
                              CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ),
                              int is_closed CV_DEFAULT(-1));
  #define cvContourPerimeter( contour ) cvArcLength( contour, CV_WHOLE_SEQ, 1 )
  
  /* Calculates contour boundning rectangle (update=1) or
     just retrieves pre-calculated rectangle (update=0) */
  CVAPI(CvRect)  cvBoundingRect( CvArr* points, int update CV_DEFAULT(0) );
  
  /* Calculates area of a contour or contour segment */
  CVAPI(double)  cvContourArea( const CvArr* contour,
                                CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ));
  
  /* Finds minimum area rotated rectangle bounding a set of points */
  CVAPI(CvBox2D)  cvMinAreaRect2( const CvArr* points,
                                  CvMemStorage* storage CV_DEFAULT(NULL));
  
  /* Finds minimum enclosing circle for a set of points */
  CVAPI(int)  cvMinEnclosingCircle( const CvArr* points,
                                    CvPoint2D32f* center, float* radius );
  
  #define CV_CONTOURS_MATCH_I1  1
  #define CV_CONTOURS_MATCH_I2  2
  #define CV_CONTOURS_MATCH_I3  3
  
  /* Compares two contours by matching their moments */
  CVAPI(double)  cvMatchShapes( const void* object1, const void* object2,
                                int method, double parameter CV_DEFAULT(0));
  
  /* Builds hierarhical representation of a contour */
  CVAPI(CvContourTree*)  cvCreateContourTree( const CvSeq* contour,
                                              CvMemStorage* storage,
                                              double threshold );
  
  /* Reconstruct (completelly or partially) contour a from contour tree */
  CVAPI(CvSeq*)  cvContourFromContourTree( const CvContourTree* tree,
                                           CvMemStorage* storage,
                                           CvTermCriteria criteria );
  
  /* Compares two contour trees */
  #define  CV_CONTOUR_TREES_MATCH_I1  1
  
  CVAPI(double)  cvMatchContourTrees( const CvContourTree* tree1,
                                      const CvContourTree* tree2,
                                      int method, double threshold );
  
  /* Calculates histogram of a contour */
  CVAPI(void)  cvCalcPGH( const CvSeq* contour, CvHistogram* hist );
  
  #define CV_CLOCKWISE         1
  #define CV_COUNTER_CLOCKWISE 2
  
  /* Calculates exact convex hull of 2d point set */
  CVAPI(CvSeq*) cvConvexHull2( const CvArr* input,
                               void* hull_storage CV_DEFAULT(NULL),
                               int orientation CV_DEFAULT(CV_CLOCKWISE),
                               int return_points CV_DEFAULT(0));
  
  /* Checks whether the contour is convex or not (returns 1 if convex, 0 if not) */
  CVAPI(int)  cvCheckContourConvexity( const CvArr* contour );
  
  /* Finds convexity defects for the contour */
  CVAPI(CvSeq*)  cvConvexityDefects( const CvArr* contour, const CvArr* convexhull,
                                     CvMemStorage* storage CV_DEFAULT(NULL));
  
  /* Fits ellipse into a set of 2d points */
  CVAPI(CvBox2D) cvFitEllipse2( const CvArr* points );
  
  /* Finds minimum rectangle containing two given rectangles */
  CVAPI(CvRect)  cvMaxRect( const CvRect* rect1, const CvRect* rect2 );
  
  /* Finds coordinates of the box vertices */
  CVAPI(void) cvBoxPoints( CvBox2D box, CvPoint2D32f pt[4] );
  
  /* Initializes sequence header for a matrix (column or row vector) of points -
     a wrapper for cvMakeSeqHeaderForArray (it does not initialize bounding rectangle!!!) */
  CVAPI(CvSeq*) cvPointSeqFromMat( int seq_kind, const CvArr* mat,
                                   CvContour* contour_header,
                                   CvSeqBlock* block );
  
  /* Checks whether the point is inside polygon, outside, on an edge (at a vertex).
     Returns positive, negative or zero value, correspondingly.
     Optionally, measures a signed distance between
     the point and the nearest polygon edge (measure_dist=1) */
  CVAPI(double) cvPointPolygonTest( const CvArr* contour,
                                    CvPoint2D32f pt, int measure_dist );
  
  /****************************************************************************************\
  *                                  Histogram functions                                   *
  \****************************************************************************************/
  
  /* Creates new histogram */
  CVAPI(CvHistogram*)  cvCreateHist( int dims, int* sizes, int type,
                                     float** ranges CV_DEFAULT(NULL),
                                     int uniform CV_DEFAULT(1));
  
  /* Assignes histogram bin ranges */
  CVAPI(void)  cvSetHistBinRanges( CvHistogram* hist, float** ranges,
                                  int uniform CV_DEFAULT(1));
  
  /* Creates histogram header for array */
  CVAPI(CvHistogram*)  cvMakeHistHeaderForArray(
                              int  dims, int* sizes, CvHistogram* hist,
                              float* data, float** ranges CV_DEFAULT(NULL),
                              int uniform CV_DEFAULT(1));
  
  /* Releases histogram */
  CVAPI(void)  cvReleaseHist( CvHistogram** hist );
  
  /* Clears all the histogram bins */
  CVAPI(void)  cvClearHist( CvHistogram* hist );
  
  /* Finds indices and values of minimum and maximum histogram bins */
  CVAPI(void)  cvGetMinMaxHistValue( const CvHistogram* hist,
                                     float* min_value, float* max_value,
                                     int* min_idx CV_DEFAULT(NULL),
                                     int* max_idx CV_DEFAULT(NULL));
  
  
  /* Normalizes histogram by dividing all bins by sum of the bins, multiplied by <factor>.
     After that sum of histogram bins is equal to <factor> */
  CVAPI(void)  cvNormalizeHist( CvHistogram* hist, double factor );
  
  
  /* Clear all histogram bins that are below the threshold */
  CVAPI(void)  cvThreshHist( CvHistogram* hist, double threshold );
  
  #define CV_COMP_CORREL        0
  #define CV_COMP_CHISQR        1
  #define CV_COMP_INTERSECT     2
  #define CV_COMP_BHATTACHARYYA 3
  
  /* Compares two histogram */
  CVAPI(double)  cvCompareHist( const CvHistogram* hist1,
                                const CvHistogram* hist2,
                                int method);
  
  /* Copies one histogram to another. Destination histogram is created if
     the destination pointer is NULL */
  CVAPI(void)  cvCopyHist( const CvHistogram* src, CvHistogram** dst );
  
  
  /* Calculates bayesian probabilistic histograms
     (each or src and dst is an array of <number> histograms */
  CVAPI(void)  cvCalcBayesianProb( CvHistogram** src, int number,
                                  CvHistogram** dst);
  
  /* Calculates array histogram */
  CVAPI(void)  cvCalcArrHist( CvArr** arr, CvHistogram* hist,
                              int accumulate CV_DEFAULT(0),
                              const CvArr* mask CV_DEFAULT(NULL) );
  
  CV_INLINE  void  cvCalcHist( IplImage** image, CvHistogram* hist,
                               int accumulate CV_DEFAULT(0),
                               const CvArr* mask CV_DEFAULT(NULL) )
  {
      cvCalcArrHist( (CvArr**)image, hist, accumulate, mask );
  }
  
  /* Calculates back project */
  CVAPI(void)  cvCalcArrBackProject( CvArr** image, CvArr* dst,
                                     const CvHistogram* hist );
  #define  cvCalcBackProject(image, dst, hist) cvCalcArrBackProject((CvArr**)image, dst, hist)
  
  
  /* Does some sort of template matching but compares histograms of
     template and each window location */
  CVAPI(void)  cvCalcArrBackProjectPatch( CvArr** image, CvArr* dst, CvSize range,
                                          CvHistogram* hist, int method,
                                          double factor );
  #define  cvCalcBackProjectPatch( image, dst, range, hist, method, factor ) \
       cvCalcArrBackProjectPatch( (CvArr**)image, dst, range, hist, method, factor )
  
  
  /* calculates probabilistic density (divides one histogram by another) */
  CVAPI(void)  cvCalcProbDensity( const CvHistogram* hist1, const CvHistogram* hist2,
                                  CvHistogram* dst_hist, double scale CV_DEFAULT(255) );
  
  /* equalizes histogram of 8-bit single-channel image */
  CVAPI(void)  cvEqualizeHist( const CvArr* src, CvArr* dst );
  
  
  #define  CV_VALUE  1
  #define  CV_ARRAY  2
  /* Updates active contour in order to minimize its cummulative
     (internal and external) energy. */
  CVAPI(void)  cvSnakeImage( const IplImage* image, CvPoint* points,
                             int  length, float* alpha,
                             float* beta, float* gamma,
                             int coeff_usage, CvSize  win,
                             CvTermCriteria criteria, int calc_gradient CV_DEFAULT(1));
  
  /* Calculates the cooficients of the homography matrix */
  CVAPI(void)  cvCalcImageHomography( float* line, CvPoint3D32f* center,
                                      float* intrinsic, float* homography );
  
  #define CV_DIST_MASK_3   3
  #define CV_DIST_MASK_5   5
  #define CV_DIST_MASK_PRECISE 0
  
  /* Applies distance transform to binary image */
  CVAPI(void)  cvDistTransform( const CvArr* src, CvArr* dst,
                                int distance_type CV_DEFAULT(CV_DIST_L2),
                                int mask_size CV_DEFAULT(3),
                                const float* mask CV_DEFAULT(NULL),
                                CvArr* labels CV_DEFAULT(NULL));
  
  
  /* Types of thresholding */
  #define CV_THRESH_BINARY      0  /* value = value > threshold ? max_value : 0       */
  #define CV_THRESH_BINARY_INV  1  /* value = value > threshold ? 0 : max_value       */
  #define CV_THRESH_TRUNC       2  /* value = value > threshold ? threshold : value   */
  #define CV_THRESH_TOZERO      3  /* value = value > threshold ? value : 0           */
  #define CV_THRESH_TOZERO_INV  4  /* value = value > threshold ? 0 : value           */
  #define CV_THRESH_MASK        7
  
  #define CV_THRESH_OTSU        8  /* use Otsu algorithm to choose the optimal threshold value;
                                      combine the flag with one of the above CV_THRESH_* values */
  
  /* Applies fixed-level threshold to grayscale image.
     This is a basic operation applied before retrieving contours */
  CVAPI(void)  cvThreshold( const CvArr*  src, CvArr*  dst,
                            double  threshold, double  max_value,
                            int threshold_type );
  
  #define CV_ADAPTIVE_THRESH_MEAN_C  0
  #define CV_ADAPTIVE_THRESH_GAUSSIAN_C  1
  
  /* Applies adaptive threshold to grayscale image.
     The two parameters for methods CV_ADAPTIVE_THRESH_MEAN_C and
     CV_ADAPTIVE_THRESH_GAUSSIAN_C are:
     neighborhood size (3, 5, 7 etc.),
     and a constant subtracted from mean (...,-3,-2,-1,0,1,2,3,...) */
  CVAPI(void)  cvAdaptiveThreshold( const CvArr* src, CvArr* dst, double max_value,
                                    int adaptive_method CV_DEFAULT(CV_ADAPTIVE_THRESH_MEAN_C),
                                    int threshold_type CV_DEFAULT(CV_THRESH_BINARY),
                                    int block_size CV_DEFAULT(3),
                                    double param1 CV_DEFAULT(5));
  
  #define CV_FLOODFILL_FIXED_RANGE (1 << 16)
  #define CV_FLOODFILL_MASK_ONLY   (1 << 17)
  
  /* Fills the connected component until the color difference gets large enough */
  CVAPI(void)  cvFloodFill( CvArr* image, CvPoint seed_point,
                            CvScalar new_val, CvScalar lo_diff CV_DEFAULT(cvScalarAll(0)),
                            CvScalar up_diff CV_DEFAULT(cvScalarAll(0)),
                            CvConnectedComp* comp CV_DEFAULT(NULL),
                            int flags CV_DEFAULT(4),
                            CvArr* mask CV_DEFAULT(NULL));
  
  /****************************************************************************************\
  *                                  Feature detection                                     *
  \****************************************************************************************/
  
  #define CV_CANNY_L2_GRADIENT  (1 << 31)
  
  /* Runs canny edge detector */
  CVAPI(void)  cvCanny( const CvArr* image, CvArr* edges, double threshold1,
                        double threshold2, int  aperture_size CV_DEFAULT(3) );
  
  /* Calculates constraint image for corner detection
     Dx^2 * Dyy + Dxx * Dy^2 - 2 * Dx * Dy * Dxy.
     Applying threshold to the result gives coordinates of corners */
  CVAPI(void) cvPreCornerDetect( const CvArr* image, CvArr* corners,
                                int aperture_size CV_DEFAULT(3) );
  
  /* Calculates eigen values and vectors of 2x2
     gradient covariation matrix at every image pixel */
  CVAPI(void)  cvCornerEigenValsAndVecs( const CvArr* image, CvArr* eigenvv,
                                        int block_size, int aperture_size CV_DEFAULT(3) );
  
  /* Calculates minimal eigenvalue for 2x2 gradient covariation matrix at
     every image pixel */
  CVAPI(void)  cvCornerMinEigenVal( const CvArr* image, CvArr* eigenval,
                                   int block_size, int aperture_size CV_DEFAULT(3) );
  
  /* Harris corner detector:
     Calculates det(M) - k*(trace(M)^2), where M is 2x2 gradient covariation matrix for each pixel */
  CVAPI(void)  cvCornerHarris( const CvArr* image, CvArr* harris_responce,
                               int block_size, int aperture_size CV_DEFAULT(3),
                               double k CV_DEFAULT(0.04) );
  
  /* Adjust corner position using some sort of gradient search */
  CVAPI(void)  cvFindCornerSubPix( const CvArr* image, CvPoint2D32f* corners,
                                   int count, CvSize win, CvSize zero_zone,
                                   CvTermCriteria  criteria );
  
  /* Finds a sparse set of points within the selected region
     that seem to be easy to track */
  CVAPI(void)  cvGoodFeaturesToTrack( const CvArr* image, CvArr* eig_image,
                                     CvArr* temp_image, CvPoint2D32f* corners,
                                     int* corner_count, double  quality_level,
                                     double  min_distance,
                                     const CvArr* mask CV_DEFAULT(NULL),
                                     int block_size CV_DEFAULT(3),
                                     int use_harris CV_DEFAULT(0),
                                     double k CV_DEFAULT(0.04) );
  
  #define CV_HOUGH_STANDARD 0
  #define CV_HOUGH_PROBABILISTIC 1
  #define CV_HOUGH_MULTI_SCALE 2
  #define CV_HOUGH_GRADIENT 3
  
  /* Finds lines on binary image using one of several methods.
     line_storage is either memory storage or 1 x <max number of lines> CvMat, its
     number of columns is changed by the function.
     method is one of CV_HOUGH_*;
     rho, theta and threshold are used for each of those methods;
     param1 ~ line length, param2 ~ line gap - for probabilistic,
     param1 ~ srn, param2 ~ stn - for multi-scale */
  CVAPI(CvSeq*)  cvHoughLines2( CvArr* image, void* line_storage, int method, 
                                double rho, double theta, int threshold,
                                double param1 CV_DEFAULT(0), double param2 CV_DEFAULT(0));
  
  /* Finds circles in the image */
  CVAPI(CvSeq*) cvHoughCircles( CvArr* image, void* circle_storage,
                                int method, double dp, double min_dist,
                                double param1 CV_DEFAULT(100),
                                double param2 CV_DEFAULT(100),
                                int min_radius CV_DEFAULT(0),
                                int max_radius CV_DEFAULT(0));
  
  /* Fits a line into set of 2d or 3d points in a robust way (M-estimator technique) */
  CVAPI(void)  cvFitLine( const CvArr* points, int dist_type, double param,
                          double reps, double aeps, float* line );
  
  /****************************************************************************************\
  *                         Haar-like Object Detection functions                           *
  \****************************************************************************************/
  
  /* Loads haar classifier cascade from a directory.
     It is obsolete: convert your cascade to xml and use cvLoad instead */
  CVAPI(CvHaarClassifierCascade*) cvLoadHaarClassifierCascade(
                      const char* directory, CvSize orig_window_size);
  
  CVAPI(void) cvReleaseHaarClassifierCascade( CvHaarClassifierCascade** cascade );
  
  CVAPI(CvSeq*) cvHaarDetectObjects( const CvArr* image,
                       CvHaarClassifierCascade* cascade,
                       CvMemStorage* storage, int scale_factor32x CV_DEFAULT(36),
                       int min_neighbors CV_DEFAULT(3), int flags CV_DEFAULT(0),
                       CvSize min_size CV_DEFAULT(cvSize(0,0)));
  
  /* sets images for haar classifier cascade */
  CVAPI(void) cvSetImagesForHaarClassifierCascade( CvHaarClassifierCascade* cascade,
                                                  const CvArr* sum, const CvArr* sqsum,
                                                  const CvArr* tilted_sum, int scale32x );
  
  /* runs the cascade on the specified window */
  CVAPI(int) cvRunHaarClassifierCascade( CvHaarClassifierCascade* cascade,
                                        CvPoint pt, int start_stage CV_DEFAULT(0));
  
  CVAPI(CvHaarClassifierCascade *) LoadFixedCascade(const char * sFileName);
  
  /****************************************************************************************\
  *                     Camera Calibration and Rectification functions                     *
  \****************************************************************************************/
  
  /* transforms the input image to compensate lens distortion */
  CVAPI(void) cvUndistort2( const CvArr* src, CvArr* dst,
                            const CvMat* intrinsic_matrix,
                            const CvMat* distortion_coeffs );
  
  /* computes transformation map from intrinsic camera parameters
     that can used by cvRemap */
  CVAPI(void) cvInitUndistortMap( const CvMat* intrinsic_matrix,
                                  const CvMat* distortion_coeffs,
                                  CvArr* mapx, CvArr* mapy );
  
  /* converts rotation vector to rotation matrix or vice versa */
  CVAPI(int) cvRodrigues2( const CvMat* src, CvMat* dst,
                           CvMat* jacobian CV_DEFAULT(0) );
  
  /* finds perspective transformation between the object plane and image (view) plane */
  CVAPI(void) cvFindHomography( const CvMat* src_points,
                                const CvMat* dst_points,
                                CvMat* homography );
  
  /* projects object points to the view plane using
     the specified extrinsic and intrinsic camera parameters */
  CVAPI(void) cvProjectPoints2( const CvMat* object_points, const CvMat* rotation_vector,
                                const CvMat* translation_vector, const CvMat* intrinsic_matrix,
                                const CvMat* distortion_coeffs, CvMat* image_points,
                                CvMat* dpdrot CV_DEFAULT(NULL), CvMat* dpdt CV_DEFAULT(NULL),
                                CvMat* dpdf CV_DEFAULT(NULL), CvMat* dpdc CV_DEFAULT(NULL),
                                CvMat* dpddist CV_DEFAULT(NULL) );
  
  /* finds extrinsic camera parameters from
     a few known corresponding point pairs and intrinsic parameters */
  CVAPI(void) cvFindExtrinsicCameraParams2( const CvMat* object_points,
                                            const CvMat* image_points,
                                            const CvMat* intrinsic_matrix,
                                            const CvMat* distortion_coeffs,
                                            CvMat* rotation_vector,
                                            CvMat* translation_vector );
  
  #define CV_CALIB_USE_INTRINSIC_GUESS  1
  #define CV_CALIB_FIX_ASPECT_RATIO     2
  #define CV_CALIB_FIX_PRINCIPAL_POINT  4
  #define CV_CALIB_ZERO_TANGENT_DIST    8
  
  /* finds intrinsic and extrinsic camera parameters
     from a few views of known calibration pattern */
  CVAPI(void) cvCalibrateCamera2( const CvMat* object_points,
                                  const CvMat* image_points,
                                  const CvMat* point_counts,
                                  CvSize image_size,
                                  CvMat* intrinsic_matrix,
                                  CvMat* distortion_coeffs,
                                  CvMat* rotation_vectors CV_DEFAULT(NULL),
                                  CvMat* translation_vectors CV_DEFAULT(NULL),
                                  int flags CV_DEFAULT(0) );
  
  #define CV_CALIB_CB_ADAPTIVE_THRESH  1
  #define CV_CALIB_CB_NORMALIZE_IMAGE  2
  #define CV_CALIB_CB_FILTER_QUADS     4 
  
  /* Detects corners on a chessboard calibration pattern */
  CVAPI(int) cvFindChessboardCorners( const void* image, CvSize pattern_size,
                                      CvPoint2D32f* corners,
                                      int* corner_count CV_DEFAULT(NULL),
                                      int flags CV_DEFAULT(CV_CALIB_CB_ADAPTIVE_THRESH) );
  
  /* Draws individual chessboard corners or the whole chessboard detected */
  CVAPI(void) cvDrawChessboardCorners( CvArr* image, CvSize pattern_size,
                                       CvPoint2D32f* corners,
                                       int count, int pattern_was_found );
  
  typedef struct CvPOSITObject CvPOSITObject;
  
  /* Allocates and initializes CvPOSITObject structure before doing cvPOSIT */
  CVAPI(CvPOSITObject*)  cvCreatePOSITObject( CvPoint3D32f* points, int point_count );
  
  
  /* Runs POSIT (POSe from ITeration) algorithm for determining 3d position of
     an object given its model and projection in a weak-perspective case */
  CVAPI(void)  cvPOSIT(  CvPOSITObject* posit_object, CvPoint2D32f* image_points,
                         double focal_length, CvTermCriteria criteria,
                         CvMatr32f rotation_matrix, CvVect32f translation_vector);
  
  /* Releases CvPOSITObject structure */
  CVAPI(void)  cvReleasePOSITObject( CvPOSITObject**  posit_object );
  
  
  /****************************************************************************************\
  *                                 Epipolar Geometry                                      *
  \****************************************************************************************/
  
  CVAPI(void) cvConvertPointsHomogenious( const CvMat* src, CvMat* dst );
  
  /* Calculates fundamental matrix given a set of corresponding points */
  #define CV_FM_7POINT 1
  #define CV_FM_8POINT 2
  #define CV_FM_LMEDS_ONLY  4
  #define CV_FM_RANSAC_ONLY 8
  #define CV_FM_LMEDS (CV_FM_LMEDS_ONLY + CV_FM_8POINT)
  #define CV_FM_RANSAC (CV_FM_RANSAC_ONLY + CV_FM_8POINT)
  CVAPI(int) cvFindFundamentalMat( const CvMat* points1, const CvMat* points2,
                                   CvMat* fundamental_matrix,
                                   int method CV_DEFAULT(CV_FM_RANSAC),
                                   double param1 CV_DEFAULT(1.), double param2 CV_DEFAULT(0.99),
                                   CvMat* status CV_DEFAULT(NULL) );
  
  /* For each input point on one of images
     computes parameters of the corresponding
     epipolar line on the other image */
  CVAPI(void) cvComputeCorrespondEpilines( const CvMat* points,
                                           int which_image,
                                           const CvMat* fundamental_matrix,
                                           CvMat* correspondent_lines );
                                           
  
  #ifdef __cplusplus
  }
  #endif
  
  
  #endif /*_CV_H_*/
  