• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1  /*M///////////////////////////////////////////////////////////////////////////////////////
2  //
3  //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4  //
5  //  By downloading, copying, installing or using the software you agree to this license.
6  //  If you do not agree to this license, do not download, install,
7  //  copy or use the software.
8  //
9  //
10  //                        Intel License Agreement
11  //                For Open Source Computer Vision Library
12  //
13  // Copyright (C) 2000, Intel Corporation, all rights reserved.
14  // Third party copyrights are property of their respective owners.
15  //
16  // Redistribution and use in source and binary forms, with or without modification,
17  // are permitted provided that the following conditions are met:
18  //
19  //   * Redistribution's of source code must retain the above copyright notice,
20  //     this list of conditions and the following disclaimer.
21  //
22  //   * Redistribution's in binary form must reproduce the above copyright notice,
23  //     this list of conditions and the following disclaimer in the documentation
24  //     and/or other materials provided with the distribution.
25  //
26  //   * The name of Intel Corporation may not be used to endorse or promote products
27  //     derived from this software without specific prior written permission.
28  //
29  // This software is provided by the copyright holders and contributors "as is" and
30  // any express or implied warranties, including, but not limited to, the implied
31  // warranties of merchantability and fitness for a particular purpose are disclaimed.
32  // In no event shall the Intel Corporation or contributors be liable for any direct,
33  // indirect, incidental, special, exemplary, or consequential damages
34  // (including, but not limited to, procurement of substitute goods or services;
35  // loss of use, data, or profits; or business interruption) however caused
36  // and on any theory of liability, whether in contract, strict liability,
37  // or tort (including negligence or otherwise) arising in any way out of
38  // the use of this software, even if advised of the possibility of such damage.
39  //
40  //M*/
41  
42  
43  #ifndef _CV_H_
44  #define _CV_H_
45  
46  #ifdef __IPL_H__
47  #define HAVE_IPL
48  #endif
49  
50  #ifndef SKIP_INCLUDES
51    #if defined(_CH_)
52      #pragma package <chopencv>
53      #include <chdl.h>
LOAD_CHDL(cv)54      LOAD_CHDL(cv)
55    #endif
56  #endif
57  
58  #include "cxcore.h"
59  #include "cvtypes.h"
60  
61  #ifdef __cplusplus
62  extern "C" {
63  #endif
64  
65  /****************************************************************************************\
66  *                                    Image Processing                                    *
67  \****************************************************************************************/
68  
69  /* Copies source 2D array inside of the larger destination array and
70     makes a border of the specified type (IPL_BORDER_*) around the copied area. */
71  CVAPI(void) cvCopyMakeBorder( const CvArr* src, CvArr* dst, CvPoint offset,
72                                int bordertype, CvScalar value CV_DEFAULT(cvScalarAll(0)));
73  
74  #define CV_BLUR_NO_SCALE 0
75  #define CV_BLUR  1
76  #define CV_GAUSSIAN  2
77  #define CV_MEDIAN 3
78  #define CV_BILATERAL 4
79  
80  /* Smoothes array (removes noise) */
81  CVAPI(void) cvSmooth( const CvArr* src, CvArr* dst,
82                        int smoothtype CV_DEFAULT(CV_GAUSSIAN),
83                        int size1 CV_DEFAULT(3),
84                        int size2 CV_DEFAULT(0),
85                        double sigma1 CV_DEFAULT(0),
86                        double sigma2 CV_DEFAULT(0));
87  
88  /* Convolves the image with the kernel */
89  CVAPI(void) cvFilter2D( const CvArr* src, CvArr* dst, const CvMat* kernel,
90                          CvPoint anchor CV_DEFAULT(cvPoint(-1,-1)));
91  
92  /* Finds integral image: SUM(X,Y) = sum(x<X,y<Y)I(x,y) */
93  CVAPI(void) cvIntegral( const CvArr* image, CvArr* sum,
94                         CvArr* sqsum CV_DEFAULT(NULL),
95                         CvArr* tilted_sum CV_DEFAULT(NULL));
96  
97  /*
98     Smoothes the input image with gaussian kernel and then down-samples it.
99     dst_width = floor(src_width/2)[+1],
100     dst_height = floor(src_height/2)[+1]
101  */
102  CVAPI(void)  cvPyrDown( const CvArr* src, CvArr* dst,
103                          int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );
104  
105  /*
106     Up-samples image and smoothes the result with gaussian kernel.
107     dst_width = src_width*2,
108     dst_height = src_height*2
109  */
110  CVAPI(void)  cvPyrUp( const CvArr* src, CvArr* dst,
111                        int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );
112  
113  /* Builds pyramid for an image */
114  CVAPI(CvMat**) cvCreatePyramid( const CvArr* img, int extra_layers, double rate,
115                                  const CvSize* layer_sizes CV_DEFAULT(0),
116                                  CvArr* bufarr CV_DEFAULT(0),
117                                  int calc CV_DEFAULT(1),
118                                  int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );
119  
120  /* Releases pyramid */
121  CVAPI(void)  cvReleasePyramid( CvMat*** pyramid, int extra_layers );
122  
123  
124  /* Splits color or grayscale image into multiple connected components
125     of nearly the same color/brightness using modification of Burt algorithm.
126     comp with contain a pointer to sequence (CvSeq)
127     of connected components (CvConnectedComp) */
128  CVAPI(void) cvPyrSegmentation( IplImage* src, IplImage* dst,
129                                CvMemStorage* storage, CvSeq** comp,
130                                int level, double threshold1,
131                                double threshold2 );
132  
133  /* Filters image using meanshift algorithm */
134  CVAPI(void) cvPyrMeanShiftFiltering( const CvArr* src, CvArr* dst,
135      double sp, double sr, int max_level CV_DEFAULT(1),
136      CvTermCriteria termcrit CV_DEFAULT(cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,5,1)));
137  
138  /* Segments image using seed "markers" */
139  CVAPI(void) cvWatershed( const CvArr* image, CvArr* markers );
140  
141  #define CV_INPAINT_NS      0
142  #define CV_INPAINT_TELEA   1
143  
144  /* Inpaints the selected region in the image */
145  CVAPI(void) cvInpaint( const CvArr* src, const CvArr* inpaint_mask,
146                         CvArr* dst, double inpaintRange, int flags );
147  
148  #define CV_SCHARR -1
149  #define CV_MAX_SOBEL_KSIZE 7
150  
151  /* Calculates an image derivative using generalized Sobel
152     (aperture_size = 1,3,5,7) or Scharr (aperture_size = -1) operator.
153     Scharr can be used only for the first dx or dy derivative */
154  CVAPI(void) cvSobel( const CvArr* src, CvArr* dst,
155                      int xorder, int yorder,
156                      int aperture_size CV_DEFAULT(3));
157  
158  /* Calculates the image Laplacian: (d2/dx + d2/dy)I */
159  CVAPI(void) cvLaplace( const CvArr* src, CvArr* dst,
160                        int aperture_size CV_DEFAULT(3) );
161  
162  /* Constants for color conversion */
163  #define  CV_BGR2BGRA    0
164  #define  CV_RGB2RGBA    CV_BGR2BGRA
165  
166  #define  CV_BGRA2BGR    1
167  #define  CV_RGBA2RGB    CV_BGRA2BGR
168  
169  #define  CV_BGR2RGBA    2
170  #define  CV_RGB2BGRA    CV_BGR2RGBA
171  
172  #define  CV_RGBA2BGR    3
173  #define  CV_BGRA2RGB    CV_RGBA2BGR
174  
175  #define  CV_BGR2RGB     4
176  #define  CV_RGB2BGR     CV_BGR2RGB
177  
178  #define  CV_BGRA2RGBA   5
179  #define  CV_RGBA2BGRA   CV_BGRA2RGBA
180  
181  #define  CV_BGR2GRAY    6
182  #define  CV_RGB2GRAY    7
183  #define  CV_GRAY2BGR    8
184  #define  CV_GRAY2RGB    CV_GRAY2BGR
185  #define  CV_GRAY2BGRA   9
186  #define  CV_GRAY2RGBA   CV_GRAY2BGRA
187  #define  CV_BGRA2GRAY   10
188  #define  CV_RGBA2GRAY   11
189  
190  #define  CV_BGR2BGR565  12
191  #define  CV_RGB2BGR565  13
192  #define  CV_BGR5652BGR  14
193  #define  CV_BGR5652RGB  15
194  #define  CV_BGRA2BGR565 16
195  #define  CV_RGBA2BGR565 17
196  #define  CV_BGR5652BGRA 18
197  #define  CV_BGR5652RGBA 19
198  
199  #define  CV_GRAY2BGR565 20
200  #define  CV_BGR5652GRAY 21
201  
202  #define  CV_BGR2BGR555  22
203  #define  CV_RGB2BGR555  23
204  #define  CV_BGR5552BGR  24
205  #define  CV_BGR5552RGB  25
206  #define  CV_BGRA2BGR555 26
207  #define  CV_RGBA2BGR555 27
208  #define  CV_BGR5552BGRA 28
209  #define  CV_BGR5552RGBA 29
210  
211  #define  CV_GRAY2BGR555 30
212  #define  CV_BGR5552GRAY 31
213  
214  #define  CV_BGR2XYZ     32
215  #define  CV_RGB2XYZ     33
216  #define  CV_XYZ2BGR     34
217  #define  CV_XYZ2RGB     35
218  
219  #define  CV_BGR2YCrCb   36
220  #define  CV_RGB2YCrCb   37
221  #define  CV_YCrCb2BGR   38
222  #define  CV_YCrCb2RGB   39
223  
224  #define  CV_BGR2HSV     40
225  #define  CV_RGB2HSV     41
226  
227  #define  CV_BGR2Lab     44
228  #define  CV_RGB2Lab     45
229  
230  #define  CV_BayerBG2BGR 46
231  #define  CV_BayerGB2BGR 47
232  #define  CV_BayerRG2BGR 48
233  #define  CV_BayerGR2BGR 49
234  
235  #define  CV_BayerBG2RGB CV_BayerRG2BGR
236  #define  CV_BayerGB2RGB CV_BayerGR2BGR
237  #define  CV_BayerRG2RGB CV_BayerBG2BGR
238  #define  CV_BayerGR2RGB CV_BayerGB2BGR
239  
240  #define  CV_BGR2Luv     50
241  #define  CV_RGB2Luv     51
242  #define  CV_BGR2HLS     52
243  #define  CV_RGB2HLS     53
244  
245  #define  CV_HSV2BGR     54
246  #define  CV_HSV2RGB     55
247  
248  #define  CV_Lab2BGR     56
249  #define  CV_Lab2RGB     57
250  #define  CV_Luv2BGR     58
251  #define  CV_Luv2RGB     59
252  #define  CV_HLS2BGR     60
253  #define  CV_HLS2RGB     61
254  
255  #define  CV_COLORCVT_MAX  100
256  
257  /* Converts input array pixels from one color space to another */
258  CVAPI(void)  cvCvtColor( const CvArr* src, CvArr* dst, int code );
259  
260  #define  CV_INTER_NN        0
261  #define  CV_INTER_LINEAR    1
262  #define  CV_INTER_CUBIC     2
263  #define  CV_INTER_AREA      3
264  
265  #define  CV_WARP_FILL_OUTLIERS 8
266  #define  CV_WARP_INVERSE_MAP  16
267  
268  /* Resizes image (input array is resized to fit the destination array) */
269  CVAPI(void)  cvResize( const CvArr* src, CvArr* dst,
270                         int interpolation CV_DEFAULT( CV_INTER_LINEAR ));
271  
272  /* Warps image with affine transform */
273  CVAPI(void)  cvWarpAffine( const CvArr* src, CvArr* dst, const CvMat* map_matrix,
274                             int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS),
275                             CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
276  
277  /* Computes affine transform matrix for mapping src[i] to dst[i] (i=0,1,2) */
278  CVAPI(CvMat*) cvGetAffineTransform( const CvPoint2D32f * src,
279                                      const CvPoint2D32f * dst,
280                                      CvMat * map_matrix );
281  
282  /* Computes rotation_matrix matrix */
283  CVAPI(CvMat*)  cv2DRotationMatrix( CvPoint2D32f center, double angle,
284                                     double scale, CvMat* map_matrix );
285  
286  /* Warps image with perspective (projective) transform */
287  CVAPI(void)  cvWarpPerspective( const CvArr* src, CvArr* dst, const CvMat* map_matrix,
288                                  int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS),
289                                  CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
290  
291  /* Computes perspective transform matrix for mapping src[i] to dst[i] (i=0,1,2,3) */
292  CVAPI(CvMat*) cvGetPerspectiveTransform( const CvPoint2D32f* src,
293                                           const CvPoint2D32f* dst,
294                                           CvMat* map_matrix );
295  
296  /* Performs generic geometric transformation using the specified coordinate maps */
297  CVAPI(void)  cvRemap( const CvArr* src, CvArr* dst,
298                        const CvArr* mapx, const CvArr* mapy,
299                        int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS),
300                        CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
301  
302  /* Converts mapx & mapy from floating-point to integer formats for cvRemap */
303  CVAPI(void)  cvConvertMaps( const CvArr* mapx, const CvArr* mapy,
304                              CvArr* mapxy, CvArr* mapalpha );
305  
306  /* Performs forward or inverse log-polar image transform */
307  CVAPI(void)  cvLogPolar( const CvArr* src, CvArr* dst,
308                           CvPoint2D32f center, double M,
309                           int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS));
310  
311  #define  CV_SHAPE_RECT      0
312  #define  CV_SHAPE_CROSS     1
313  #define  CV_SHAPE_ELLIPSE   2
314  #define  CV_SHAPE_CUSTOM    100
315  
316  /* creates structuring element used for morphological operations */
317  CVAPI(IplConvKernel*)  cvCreateStructuringElementEx(
318              int cols, int  rows, int  anchor_x, int  anchor_y,
319              int shape, int* values CV_DEFAULT(NULL) );
320  
321  /* releases structuring element */
322  CVAPI(void)  cvReleaseStructuringElement( IplConvKernel** element );
323  
324  /* erodes input image (applies minimum filter) one or more times.
325     If element pointer is NULL, 3x3 rectangular element is used */
326  CVAPI(void)  cvErode( const CvArr* src, CvArr* dst,
327                        IplConvKernel* element CV_DEFAULT(NULL),
328                        int iterations CV_DEFAULT(1) );
329  
330  /* dilates input image (applies maximum filter) one or more times.
331     If element pointer is NULL, 3x3 rectangular element is used */
332  CVAPI(void)  cvDilate( const CvArr* src, CvArr* dst,
333                         IplConvKernel* element CV_DEFAULT(NULL),
334                         int iterations CV_DEFAULT(1) );
335  
336  #define CV_MOP_OPEN         2
337  #define CV_MOP_CLOSE        3
338  #define CV_MOP_GRADIENT     4
339  #define CV_MOP_TOPHAT       5
340  #define CV_MOP_BLACKHAT     6
341  
342  /* Performs complex morphological transformation */
343  CVAPI(void)  cvMorphologyEx( const CvArr* src, CvArr* dst,
344                               CvArr* temp, IplConvKernel* element,
345                               int operation, int iterations CV_DEFAULT(1) );
346  
347  /* Calculates all spatial and central moments up to the 3rd order */
348  CVAPI(void) cvMoments( const CvArr* arr, CvMoments* moments, int binary CV_DEFAULT(0));
349  
350  /* Retrieve particular spatial, central or normalized central moments */
351  CVAPI(double)  cvGetSpatialMoment( CvMoments* moments, int x_order, int y_order );
352  CVAPI(double)  cvGetCentralMoment( CvMoments* moments, int x_order, int y_order );
353  CVAPI(double)  cvGetNormalizedCentralMoment( CvMoments* moments,
354                                               int x_order, int y_order );
355  
356  /* Calculates 7 Hu's invariants from precalculated spatial and central moments */
357  CVAPI(void) cvGetHuMoments( CvMoments*  moments, CvHuMoments*  hu_moments );
358  
359  /*********************************** data sampling **************************************/
360  
361  /* Fetches pixels that belong to the specified line segment and stores them to the buffer.
362     Returns the number of retrieved points. */
363  CVAPI(int)  cvSampleLine( const CvArr* image, CvPoint pt1, CvPoint pt2, void* buffer,
364                            int connectivity CV_DEFAULT(8));
365  
366  /* Retrieves the rectangular image region with specified center from the input array.
367   dst(x,y) <- src(x + center.x - dst_width/2, y + center.y - dst_height/2).
368   Values of pixels with fractional coordinates are retrieved using bilinear interpolation*/
369  CVAPI(void)  cvGetRectSubPix( const CvArr* src, CvArr* dst, CvPoint2D32f center );
370  
371  
372  /* Retrieves quadrangle from the input array.
373      matrixarr = ( a11  a12 | b1 )   dst(x,y) <- src(A[x y]' + b)
374                  ( a21  a22 | b2 )   (bilinear interpolation is used to retrieve pixels
375                                       with fractional coordinates)
376  */
377  CVAPI(void)  cvGetQuadrangleSubPix( const CvArr* src, CvArr* dst,
378                                      const CvMat* map_matrix );
379  
380  /* Methods for comparing two array */
381  #define  CV_TM_SQDIFF        0
382  #define  CV_TM_SQDIFF_NORMED 1
383  #define  CV_TM_CCORR         2
384  #define  CV_TM_CCORR_NORMED  3
385  #define  CV_TM_CCOEFF        4
386  #define  CV_TM_CCOEFF_NORMED 5
387  
388  /* Measures similarity between template and overlapped windows in the source image
389     and fills the resultant image with the measurements */
390  CVAPI(void)  cvMatchTemplate( const CvArr* image, const CvArr* templ,
391                                CvArr* result, int method );
392  
393  /* Computes earth mover distance between
394     two weighted point sets (called signatures) */
395  CVAPI(float)  cvCalcEMD2( const CvArr* signature1,
396                            const CvArr* signature2,
397                            int distance_type,
398                            CvDistanceFunction distance_func CV_DEFAULT(NULL),
399                            const CvArr* cost_matrix CV_DEFAULT(NULL),
400                            CvArr* flow CV_DEFAULT(NULL),
401                            float* lower_bound CV_DEFAULT(NULL),
402                            void* userdata CV_DEFAULT(NULL));
403  
404  /****************************************************************************************\
405  *                              Contours retrieving                                       *
406  \****************************************************************************************/
407  
408  /* Retrieves outer and optionally inner boundaries of white (non-zero) connected
409     components in the black (zero) background */
410  CVAPI(int)  cvFindContours( CvArr* image, CvMemStorage* storage, CvSeq** first_contour,
411                              int header_size CV_DEFAULT(sizeof(CvContour)),
412                              int mode CV_DEFAULT(CV_RETR_LIST),
413                              int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
414                              CvPoint offset CV_DEFAULT(cvPoint(0,0)));
415  
416  
417  /* Initalizes contour retrieving process.
418     Calls cvStartFindContours.
419     Calls cvFindNextContour until null pointer is returned
420     or some other condition becomes true.
421     Calls cvEndFindContours at the end. */
422  CVAPI(CvContourScanner)  cvStartFindContours( CvArr* image, CvMemStorage* storage,
423                              int header_size CV_DEFAULT(sizeof(CvContour)),
424                              int mode CV_DEFAULT(CV_RETR_LIST),
425                              int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
426                              CvPoint offset CV_DEFAULT(cvPoint(0,0)));
427  
428  /* Retrieves next contour */
429  CVAPI(CvSeq*)  cvFindNextContour( CvContourScanner scanner );
430  
431  
432  /* Substitutes the last retrieved contour with the new one
433     (if the substitutor is null, the last retrieved contour is removed from the tree) */
434  CVAPI(void)   cvSubstituteContour( CvContourScanner scanner, CvSeq* new_contour );
435  
436  
437  /* Releases contour scanner and returns pointer to the first outer contour */
438  CVAPI(CvSeq*)  cvEndFindContours( CvContourScanner* scanner );
439  
440  /* Approximates a single Freeman chain or a tree of chains to polygonal curves */
441  CVAPI(CvSeq*) cvApproxChains( CvSeq* src_seq, CvMemStorage* storage,
442                              int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
443                              double parameter CV_DEFAULT(0),
444                              int  minimal_perimeter CV_DEFAULT(0),
445                              int  recursive CV_DEFAULT(0));
446  
447  
448  /* Initalizes Freeman chain reader.
449     The reader is used to iteratively get coordinates of all the chain points.
450     If the Freeman codes should be read as is, a simple sequence reader should be used */
451  CVAPI(void) cvStartReadChainPoints( CvChain* chain, CvChainPtReader* reader );
452  
453  /* Retrieves the next chain point */
454  CVAPI(CvPoint) cvReadChainPoint( CvChainPtReader* reader );
455  
456  
457  /****************************************************************************************\
458  *                                  Motion Analysis                                       *
459  \****************************************************************************************/
460  
461  /************************************ optical flow ***************************************/
462  
463  /* Calculates optical flow for 2 images using classical Lucas & Kanade algorithm */
464  CVAPI(void)  cvCalcOpticalFlowLK( const CvArr* prev, const CvArr* curr,
465                                    CvSize win_size, CvArr* velx, CvArr* vely );
466  
467  /* Calculates optical flow for 2 images using block matching algorithm */
468  CVAPI(void)  cvCalcOpticalFlowBM( const CvArr* prev, const CvArr* curr,
469                                    CvSize block_size, CvSize shift_size,
470                                    CvSize max_range, int use_previous,
471                                    CvArr* velx, CvArr* vely );
472  
473  /* Calculates Optical flow for 2 images using Horn & Schunck algorithm */
474  CVAPI(void)  cvCalcOpticalFlowHS( const CvArr* prev, const CvArr* curr,
475                                    int use_previous, CvArr* velx, CvArr* vely,
476                                    double lambda, CvTermCriteria criteria );
477  
478  #define  CV_LKFLOW_PYR_A_READY       1
479  #define  CV_LKFLOW_PYR_B_READY       2
480  #define  CV_LKFLOW_INITIAL_GUESSES   4
481  #define  CV_LKFLOW_GET_MIN_EIGENVALS 8
482  
483  /* It is Lucas & Kanade method, modified to use pyramids.
484     Also it does several iterations to get optical flow for
485     every point at every pyramid level.
486     Calculates optical flow between two images for certain set of points (i.e.
487     it is a "sparse" optical flow, which is opposite to the previous 3 methods) */
488  CVAPI(void)  cvCalcOpticalFlowPyrLK( const CvArr*  prev, const CvArr*  curr,
489                                       CvArr*  prev_pyr, CvArr*  curr_pyr,
490                                       const CvPoint2D32f* prev_features,
491                                       CvPoint2D32f* curr_features,
492                                       int       count,
493                                       CvSize    win_size,
494                                       int       level,
495                                       char*     status,
496                                       float*    track_error,
497                                       CvTermCriteria criteria,
498                                       int       flags );
499  
500  
501  /* Modification of a previous sparse optical flow algorithm to calculate
502     affine flow */
503  CVAPI(void)  cvCalcAffineFlowPyrLK( const CvArr*  prev, const CvArr*  curr,
504                                      CvArr*  prev_pyr, CvArr*  curr_pyr,
505                                      const CvPoint2D32f* prev_features,
506                                      CvPoint2D32f* curr_features,
507                                      float* matrices, int  count,
508                                      CvSize win_size, int  level,
509                                      char* status, float* track_error,
510                                      CvTermCriteria criteria, int flags );
511  
512  /* Estimate rigid transformation between 2 images or 2 point sets */
513  CVAPI(int)  cvEstimateRigidTransform( const CvArr* A, const CvArr* B,
514                                        CvMat* M, int full_affine );
515  
516  /********************************* motion templates *************************************/
517  
518  /****************************************************************************************\
519  *        All the motion template functions work only with single channel images.         *
520  *        Silhouette image must have depth IPL_DEPTH_8U or IPL_DEPTH_8S                   *
521  *        Motion history image must have depth IPL_DEPTH_32F,                             *
522  *        Gradient mask - IPL_DEPTH_8U or IPL_DEPTH_8S,                                   *
523  *        Motion orientation image - IPL_DEPTH_32F                                        *
524  *        Segmentation mask - IPL_DEPTH_32F                                               *
525  *        All the angles are in degrees, all the times are in milliseconds                *
526  \****************************************************************************************/
527  
528  /* Updates motion history image given motion silhouette */
529  CVAPI(void)    cvUpdateMotionHistory( const CvArr* silhouette, CvArr* mhi,
530                                        double timestamp, double duration );
531  
532  /* Calculates gradient of the motion history image and fills
533     a mask indicating where the gradient is valid */
534  CVAPI(void)    cvCalcMotionGradient( const CvArr* mhi, CvArr* mask, CvArr* orientation,
535                                       double delta1, double delta2,
536                                       int aperture_size CV_DEFAULT(3));
537  
538  /* Calculates average motion direction within a selected motion region
539     (region can be selected by setting ROIs and/or by composing a valid gradient mask
540     with the region mask) */
541  CVAPI(double)  cvCalcGlobalOrientation( const CvArr* orientation, const CvArr* mask,
542                                          const CvArr* mhi, double timestamp,
543                                          double duration );
544  
545  /* Splits a motion history image into a few parts corresponding to separate independent motions
546     (e.g. left hand, right hand) */
547  CVAPI(CvSeq*)  cvSegmentMotion( const CvArr* mhi, CvArr* seg_mask,
548                                  CvMemStorage* storage,
549                                  double timestamp, double seg_thresh );
550  
551  /*********************** Background statistics accumulation *****************************/
552  
553  /* Adds image to accumulator */
554  CVAPI(void)  cvAcc( const CvArr* image, CvArr* sum,
555                      const CvArr* mask CV_DEFAULT(NULL) );
556  
557  /* Adds squared image to accumulator */
558  CVAPI(void)  cvSquareAcc( const CvArr* image, CvArr* sqsum,
559                            const CvArr* mask CV_DEFAULT(NULL) );
560  
561  /* Adds a product of two images to accumulator */
562  CVAPI(void)  cvMultiplyAcc( const CvArr* image1, const CvArr* image2, CvArr* acc,
563                              const CvArr* mask CV_DEFAULT(NULL) );
564  
565  /* Adds image to accumulator with weights: acc = acc*(1-alpha) + image*alpha */
566  CVAPI(void)  cvRunningAvg( const CvArr* image, CvArr* acc, double alpha,
567                             const CvArr* mask CV_DEFAULT(NULL) );
568  
569  
570  /****************************************************************************************\
571  *                                       Tracking                                         *
572  \****************************************************************************************/
573  
574  /* Implements CAMSHIFT algorithm - determines object position, size and orientation
575     from the object histogram back project (extension of meanshift) */
576  CVAPI(int)  cvCamShift( const CvArr* prob_image, CvRect  window,
577                         CvTermCriteria criteria, CvConnectedComp* comp,
578                         CvBox2D* box CV_DEFAULT(NULL) );
579  
580  /* Implements MeanShift algorithm - determines object position
581     from the object histogram back project */
582  CVAPI(int)  cvMeanShift( const CvArr* prob_image, CvRect  window,
583                          CvTermCriteria criteria, CvConnectedComp* comp );
584  
585  /* Creates ConDensation filter state */
586  CVAPI(CvConDensation*)  cvCreateConDensation( int dynam_params,
587                                               int measure_params,
588                                               int sample_count );
589  
590  /* Releases ConDensation filter state */
591  CVAPI(void)  cvReleaseConDensation( CvConDensation** condens );
592  
593  /* Updates ConDensation filter by time (predict future state of the system) */
594  CVAPI(void)  cvConDensUpdateByTime( CvConDensation* condens);
595  
596  /* Initializes ConDensation filter samples  */
597  CVAPI(void)  cvConDensInitSampleSet( CvConDensation* condens, CvMat* lower_bound, CvMat* upper_bound );
598  
599  /* Creates Kalman filter and sets A, B, Q, R and state to some initial values */
600  CVAPI(CvKalman*) cvCreateKalman( int dynam_params, int measure_params,
601                                  int control_params CV_DEFAULT(0));
602  
603  /* Releases Kalman filter state */
604  CVAPI(void)  cvReleaseKalman( CvKalman** kalman);
605  
606  /* Updates Kalman filter by time (predicts future state of the system) */
607  CVAPI(const CvMat*)  cvKalmanPredict( CvKalman* kalman,
608                                       const CvMat* control CV_DEFAULT(NULL));
609  
610  /* Updates Kalman filter by measurement
611     (corrects state of the system and internal matrices) */
612  CVAPI(const CvMat*)  cvKalmanCorrect( CvKalman* kalman, const CvMat* measurement );
613  
614  /****************************************************************************************\
615  *                              Planar subdivisions                                       *
616  \****************************************************************************************/
617  
618  /* Initializes Delaunay triangulation */
619  CVAPI(void)  cvInitSubdivDelaunay2D( CvSubdiv2D* subdiv, CvRect rect );
620  
621  /* Creates new subdivision */
622  CVAPI(CvSubdiv2D*)  cvCreateSubdiv2D( int subdiv_type, int header_size,
623                                        int vtx_size, int quadedge_size,
624                                        CvMemStorage* storage );
625  
626  /************************* high-level subdivision functions ***************************/
627  
628  /* Simplified Delaunay diagram creation */
629  CV_INLINE  CvSubdiv2D* cvCreateSubdivDelaunay2D( CvRect rect, CvMemStorage* storage )
630  {
631      CvSubdiv2D* subdiv = cvCreateSubdiv2D( CV_SEQ_KIND_SUBDIV2D, sizeof(*subdiv),
632                           sizeof(CvSubdiv2DPoint), sizeof(CvQuadEdge2D), storage );
633  
634      cvInitSubdivDelaunay2D( subdiv, rect );
635      return subdiv;
636  }
637  
638  
639  /* Inserts new point to the Delaunay triangulation */
640  CVAPI(CvSubdiv2DPoint*)  cvSubdivDelaunay2DInsert( CvSubdiv2D* subdiv, CvPoint2D32f pt);
641  
642  /* Locates a point within the Delaunay triangulation (finds the edge
643     the point is left to or belongs to, or the triangulation point the given
644     point coinsides with */
645  CVAPI(CvSubdiv2DPointLocation)  cvSubdiv2DLocate(
646                                 CvSubdiv2D* subdiv, CvPoint2D32f pt,
647                                 CvSubdiv2DEdge* edge,
648                                 CvSubdiv2DPoint** vertex CV_DEFAULT(NULL) );
649  
650  /* Calculates Voronoi tesselation (i.e. coordinates of Voronoi points) */
651  CVAPI(void)  cvCalcSubdivVoronoi2D( CvSubdiv2D* subdiv );
652  
653  
654  /* Removes all Voronoi points from the tesselation */
655  CVAPI(void)  cvClearSubdivVoronoi2D( CvSubdiv2D* subdiv );
656  
657  
658  /* Finds the nearest to the given point vertex in subdivision. */
659  CVAPI(CvSubdiv2DPoint*) cvFindNearestPoint2D( CvSubdiv2D* subdiv, CvPoint2D32f pt );
660  
661  
662  /************ Basic quad-edge navigation and operations ************/
663  
664  CV_INLINE  CvSubdiv2DEdge  cvSubdiv2DNextEdge( CvSubdiv2DEdge edge )
665  {
666      return  CV_SUBDIV2D_NEXT_EDGE(edge);
667  }
668  
669  
670  CV_INLINE  CvSubdiv2DEdge  cvSubdiv2DRotateEdge( CvSubdiv2DEdge edge, int rotate )
671  {
672      return  (edge & ~3) + ((edge + rotate) & 3);
673  }
674  
675  CV_INLINE  CvSubdiv2DEdge  cvSubdiv2DSymEdge( CvSubdiv2DEdge edge )
676  {
677      return edge ^ 2;
678  }
679  
680  CV_INLINE  CvSubdiv2DEdge  cvSubdiv2DGetEdge( CvSubdiv2DEdge edge, CvNextEdgeType type )
681  {
682      CvQuadEdge2D* e = (CvQuadEdge2D*)(edge & ~3);
683      edge = e->next[(edge + (int)type) & 3];
684      return  (edge & ~3) + ((edge + ((int)type >> 4)) & 3);
685  }
686  
687  
688  CV_INLINE  CvSubdiv2DPoint*  cvSubdiv2DEdgeOrg( CvSubdiv2DEdge edge )
689  {
690      CvQuadEdge2D* e = (CvQuadEdge2D*)(edge & ~3);
691      return (CvSubdiv2DPoint*)e->pt[edge & 3];
692  }
693  
694  
695  CV_INLINE  CvSubdiv2DPoint*  cvSubdiv2DEdgeDst( CvSubdiv2DEdge edge )
696  {
697      CvQuadEdge2D* e = (CvQuadEdge2D*)(edge & ~3);
698      return (CvSubdiv2DPoint*)e->pt[(edge + 2) & 3];
699  }
700  
701  
702  CV_INLINE  double  cvTriangleArea( CvPoint2D32f a, CvPoint2D32f b, CvPoint2D32f c )
703  {
704      return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
705  }
706  
707  
708  /****************************************************************************************\
709  *                            Contour Processing and Shape Analysis                       *
710  \****************************************************************************************/
711  
712  #define CV_POLY_APPROX_DP 0
713  
714  /* Approximates a single polygonal curve (contour) or
715     a tree of polygonal curves (contours) */
716  CVAPI(CvSeq*)  cvApproxPoly( const void* src_seq,
717                               int header_size, CvMemStorage* storage,
718                               int method, double parameter,
719                               int parameter2 CV_DEFAULT(0));
720  
721  #define CV_DOMINANT_IPAN 1
722  
723  /* Finds high-curvature points of the contour */
724  CVAPI(CvSeq*) cvFindDominantPoints( CvSeq* contour, CvMemStorage* storage,
725                                     int method CV_DEFAULT(CV_DOMINANT_IPAN),
726                                     double parameter1 CV_DEFAULT(0),
727                                     double parameter2 CV_DEFAULT(0),
728                                     double parameter3 CV_DEFAULT(0),
729                                     double parameter4 CV_DEFAULT(0));
730  
731  /* Calculates perimeter of a contour or length of a part of contour */
732  CVAPI(double)  cvArcLength( const void* curve,
733                              CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ),
734                              int is_closed CV_DEFAULT(-1));
735  #define cvContourPerimeter( contour ) cvArcLength( contour, CV_WHOLE_SEQ, 1 )
736  
737  /* Calculates contour boundning rectangle (update=1) or
738     just retrieves pre-calculated rectangle (update=0) */
739  CVAPI(CvRect)  cvBoundingRect( CvArr* points, int update CV_DEFAULT(0) );
740  
741  /* Calculates area of a contour or contour segment */
742  CVAPI(double)  cvContourArea( const CvArr* contour,
743                                CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ));
744  
745  /* Finds minimum area rotated rectangle bounding a set of points */
746  CVAPI(CvBox2D)  cvMinAreaRect2( const CvArr* points,
747                                  CvMemStorage* storage CV_DEFAULT(NULL));
748  
749  /* Finds minimum enclosing circle for a set of points */
750  CVAPI(int)  cvMinEnclosingCircle( const CvArr* points,
751                                    CvPoint2D32f* center, float* radius );
752  
753  #define CV_CONTOURS_MATCH_I1  1
754  #define CV_CONTOURS_MATCH_I2  2
755  #define CV_CONTOURS_MATCH_I3  3
756  
757  /* Compares two contours by matching their moments */
758  CVAPI(double)  cvMatchShapes( const void* object1, const void* object2,
759                                int method, double parameter CV_DEFAULT(0));
760  
761  /* Builds hierarhical representation of a contour */
762  CVAPI(CvContourTree*)  cvCreateContourTree( const CvSeq* contour,
763                                              CvMemStorage* storage,
764                                              double threshold );
765  
766  /* Reconstruct (completelly or partially) contour a from contour tree */
767  CVAPI(CvSeq*)  cvContourFromContourTree( const CvContourTree* tree,
768                                           CvMemStorage* storage,
769                                           CvTermCriteria criteria );
770  
771  /* Compares two contour trees */
772  #define  CV_CONTOUR_TREES_MATCH_I1  1
773  
774  CVAPI(double)  cvMatchContourTrees( const CvContourTree* tree1,
775                                      const CvContourTree* tree2,
776                                      int method, double threshold );
777  
778  /* Calculates histogram of a contour */
779  CVAPI(void)  cvCalcPGH( const CvSeq* contour, CvHistogram* hist );
780  
781  #define CV_CLOCKWISE         1
782  #define CV_COUNTER_CLOCKWISE 2
783  
784  /* Calculates exact convex hull of 2d point set */
785  CVAPI(CvSeq*) cvConvexHull2( const CvArr* input,
786                               void* hull_storage CV_DEFAULT(NULL),
787                               int orientation CV_DEFAULT(CV_CLOCKWISE),
788                               int return_points CV_DEFAULT(0));
789  
790  /* Checks whether the contour is convex or not (returns 1 if convex, 0 if not) */
791  CVAPI(int)  cvCheckContourConvexity( const CvArr* contour );
792  
793  /* Finds convexity defects for the contour */
794  CVAPI(CvSeq*)  cvConvexityDefects( const CvArr* contour, const CvArr* convexhull,
795                                     CvMemStorage* storage CV_DEFAULT(NULL));
796  
797  /* Fits ellipse into a set of 2d points */
798  CVAPI(CvBox2D) cvFitEllipse2( const CvArr* points );
799  
800  /* Finds minimum rectangle containing two given rectangles */
801  CVAPI(CvRect)  cvMaxRect( const CvRect* rect1, const CvRect* rect2 );
802  
803  /* Finds coordinates of the box vertices */
804  CVAPI(void) cvBoxPoints( CvBox2D box, CvPoint2D32f pt[4] );
805  
806  /* Initializes sequence header for a matrix (column or row vector) of points -
807     a wrapper for cvMakeSeqHeaderForArray (it does not initialize bounding rectangle!!!) */
808  CVAPI(CvSeq*) cvPointSeqFromMat( int seq_kind, const CvArr* mat,
809                                   CvContour* contour_header,
810                                   CvSeqBlock* block );
811  
812  /* Checks whether the point is inside polygon, outside, on an edge (at a vertex).
813     Returns positive, negative or zero value, correspondingly.
814     Optionally, measures a signed distance between
815     the point and the nearest polygon edge (measure_dist=1) */
816  CVAPI(double) cvPointPolygonTest( const CvArr* contour,
817                                    CvPoint2D32f pt, int measure_dist );
818  
819  /****************************************************************************************\
820  *                                  Histogram functions                                   *
821  \****************************************************************************************/
822  
823  /* Creates new histogram */
824  CVAPI(CvHistogram*)  cvCreateHist( int dims, int* sizes, int type,
825                                     float** ranges CV_DEFAULT(NULL),
826                                     int uniform CV_DEFAULT(1));
827  
828  /* Assignes histogram bin ranges */
829  CVAPI(void)  cvSetHistBinRanges( CvHistogram* hist, float** ranges,
830                                  int uniform CV_DEFAULT(1));
831  
832  /* Creates histogram header for array */
833  CVAPI(CvHistogram*)  cvMakeHistHeaderForArray(
834                              int  dims, int* sizes, CvHistogram* hist,
835                              float* data, float** ranges CV_DEFAULT(NULL),
836                              int uniform CV_DEFAULT(1));
837  
838  /* Releases histogram */
839  CVAPI(void)  cvReleaseHist( CvHistogram** hist );
840  
841  /* Clears all the histogram bins */
842  CVAPI(void)  cvClearHist( CvHistogram* hist );
843  
844  /* Finds indices and values of minimum and maximum histogram bins */
845  CVAPI(void)  cvGetMinMaxHistValue( const CvHistogram* hist,
846                                     float* min_value, float* max_value,
847                                     int* min_idx CV_DEFAULT(NULL),
848                                     int* max_idx CV_DEFAULT(NULL));
849  
850  
851  /* Normalizes histogram by dividing all bins by sum of the bins, multiplied by <factor>.
852     After that sum of histogram bins is equal to <factor> */
853  CVAPI(void)  cvNormalizeHist( CvHistogram* hist, double factor );
854  
855  
856  /* Clear all histogram bins that are below the threshold */
857  CVAPI(void)  cvThreshHist( CvHistogram* hist, double threshold );
858  
859  #define CV_COMP_CORREL        0
860  #define CV_COMP_CHISQR        1
861  #define CV_COMP_INTERSECT     2
862  #define CV_COMP_BHATTACHARYYA 3
863  
864  /* Compares two histogram */
865  CVAPI(double)  cvCompareHist( const CvHistogram* hist1,
866                                const CvHistogram* hist2,
867                                int method);
868  
869  /* Copies one histogram to another. Destination histogram is created if
870     the destination pointer is NULL */
871  CVAPI(void)  cvCopyHist( const CvHistogram* src, CvHistogram** dst );
872  
873  
874  /* Calculates bayesian probabilistic histograms
875     (each or src and dst is an array of <number> histograms */
876  CVAPI(void)  cvCalcBayesianProb( CvHistogram** src, int number,
877                                  CvHistogram** dst);
878  
879  /* Calculates array histogram */
880  CVAPI(void)  cvCalcArrHist( CvArr** arr, CvHistogram* hist,
881                              int accumulate CV_DEFAULT(0),
882                              const CvArr* mask CV_DEFAULT(NULL) );
883  
884  CV_INLINE  void  cvCalcHist( IplImage** image, CvHistogram* hist,
885                               int accumulate CV_DEFAULT(0),
886                               const CvArr* mask CV_DEFAULT(NULL) )
887  {
888      cvCalcArrHist( (CvArr**)image, hist, accumulate, mask );
889  }
890  
891  /* Calculates back project */
892  CVAPI(void)  cvCalcArrBackProject( CvArr** image, CvArr* dst,
893                                     const CvHistogram* hist );
894  #define  cvCalcBackProject(image, dst, hist) cvCalcArrBackProject((CvArr**)image, dst, hist)
895  
896  
897  /* Does some sort of template matching but compares histograms of
898     template and each window location */
899  CVAPI(void)  cvCalcArrBackProjectPatch( CvArr** image, CvArr* dst, CvSize range,
900                                          CvHistogram* hist, int method,
901                                          double factor );
902  #define  cvCalcBackProjectPatch( image, dst, range, hist, method, factor ) \
903       cvCalcArrBackProjectPatch( (CvArr**)image, dst, range, hist, method, factor )
904  
905  
906  /* calculates probabilistic density (divides one histogram by another) */
907  CVAPI(void)  cvCalcProbDensity( const CvHistogram* hist1, const CvHistogram* hist2,
908                                  CvHistogram* dst_hist, double scale CV_DEFAULT(255) );
909  
910  /* equalizes histogram of 8-bit single-channel image */
911  CVAPI(void)  cvEqualizeHist( const CvArr* src, CvArr* dst );
912  
913  
914  #define  CV_VALUE  1
915  #define  CV_ARRAY  2
916  /* Updates active contour in order to minimize its cummulative
917     (internal and external) energy. */
918  CVAPI(void)  cvSnakeImage( const IplImage* image, CvPoint* points,
919                             int  length, float* alpha,
920                             float* beta, float* gamma,
921                             int coeff_usage, CvSize  win,
922                             CvTermCriteria criteria, int calc_gradient CV_DEFAULT(1));
923  
924  /* Calculates the cooficients of the homography matrix */
925  CVAPI(void)  cvCalcImageHomography( float* line, CvPoint3D32f* center,
926                                      float* intrinsic, float* homography );
927  
928  #define CV_DIST_MASK_3   3
929  #define CV_DIST_MASK_5   5
930  #define CV_DIST_MASK_PRECISE 0
931  
932  /* Applies distance transform to binary image */
933  CVAPI(void)  cvDistTransform( const CvArr* src, CvArr* dst,
934                                int distance_type CV_DEFAULT(CV_DIST_L2),
935                                int mask_size CV_DEFAULT(3),
936                                const float* mask CV_DEFAULT(NULL),
937                                CvArr* labels CV_DEFAULT(NULL));
938  
939  
940  /* Types of thresholding */
941  #define CV_THRESH_BINARY      0  /* value = value > threshold ? max_value : 0       */
942  #define CV_THRESH_BINARY_INV  1  /* value = value > threshold ? 0 : max_value       */
943  #define CV_THRESH_TRUNC       2  /* value = value > threshold ? threshold : value   */
944  #define CV_THRESH_TOZERO      3  /* value = value > threshold ? value : 0           */
945  #define CV_THRESH_TOZERO_INV  4  /* value = value > threshold ? 0 : value           */
946  #define CV_THRESH_MASK        7
947  
948  #define CV_THRESH_OTSU        8  /* use Otsu algorithm to choose the optimal threshold value;
949                                      combine the flag with one of the above CV_THRESH_* values */
950  
951  /* Applies fixed-level threshold to grayscale image.
952     This is a basic operation applied before retrieving contours */
953  CVAPI(double)  cvThreshold( const CvArr*  src, CvArr*  dst,
954                              double  threshold, double  max_value,
955                              int threshold_type );
956  
957  #define CV_ADAPTIVE_THRESH_MEAN_C  0
958  #define CV_ADAPTIVE_THRESH_GAUSSIAN_C  1
959  
960  /* Applies adaptive threshold to grayscale image.
961     The two parameters for methods CV_ADAPTIVE_THRESH_MEAN_C and
962     CV_ADAPTIVE_THRESH_GAUSSIAN_C are:
963     neighborhood size (3, 5, 7 etc.),
964     and a constant subtracted from mean (...,-3,-2,-1,0,1,2,3,...) */
965  CVAPI(void)  cvAdaptiveThreshold( const CvArr* src, CvArr* dst, double max_value,
966                                    int adaptive_method CV_DEFAULT(CV_ADAPTIVE_THRESH_MEAN_C),
967                                    int threshold_type CV_DEFAULT(CV_THRESH_BINARY),
968                                    int block_size CV_DEFAULT(3),
969                                    double param1 CV_DEFAULT(5));
970  
971  #define CV_FLOODFILL_FIXED_RANGE (1 << 16)
972  #define CV_FLOODFILL_MASK_ONLY   (1 << 17)
973  
974  /* Fills the connected component until the color difference gets large enough */
975  CVAPI(void)  cvFloodFill( CvArr* image, CvPoint seed_point,
976                            CvScalar new_val, CvScalar lo_diff CV_DEFAULT(cvScalarAll(0)),
977                            CvScalar up_diff CV_DEFAULT(cvScalarAll(0)),
978                            CvConnectedComp* comp CV_DEFAULT(NULL),
979                            int flags CV_DEFAULT(4),
980                            CvArr* mask CV_DEFAULT(NULL));
981  
982  /****************************************************************************************\
983  *                                  Feature detection                                     *
984  \****************************************************************************************/
985  
986  #define CV_CANNY_L2_GRADIENT  (1 << 31)
987  
988  /* Runs canny edge detector */
989  CVAPI(void)  cvCanny( const CvArr* image, CvArr* edges, double threshold1,
990                        double threshold2, int  aperture_size CV_DEFAULT(3) );
991  
992  /* Calculates constraint image for corner detection
993     Dx^2 * Dyy + Dxx * Dy^2 - 2 * Dx * Dy * Dxy.
994     Applying threshold to the result gives coordinates of corners */
995  CVAPI(void) cvPreCornerDetect( const CvArr* image, CvArr* corners,
996                                int aperture_size CV_DEFAULT(3) );
997  
998  /* Calculates eigen values and vectors of 2x2
999     gradient covariation matrix at every image pixel */
1000  CVAPI(void)  cvCornerEigenValsAndVecs( const CvArr* image, CvArr* eigenvv,
1001                                        int block_size, int aperture_size CV_DEFAULT(3) );
1002  
1003  /* Calculates minimal eigenvalue for 2x2 gradient covariation matrix at
1004     every image pixel */
1005  CVAPI(void)  cvCornerMinEigenVal( const CvArr* image, CvArr* eigenval,
1006                                   int block_size, int aperture_size CV_DEFAULT(3) );
1007  
1008  /* Harris corner detector:
1009     Calculates det(M) - k*(trace(M)^2), where M is 2x2 gradient covariation matrix for each pixel */
1010  CVAPI(void)  cvCornerHarris( const CvArr* image, CvArr* harris_responce,
1011                               int block_size, int aperture_size CV_DEFAULT(3),
1012                               double k CV_DEFAULT(0.04) );
1013  
1014  /* Adjust corner position using some sort of gradient search */
1015  CVAPI(void)  cvFindCornerSubPix( const CvArr* image, CvPoint2D32f* corners,
1016                                   int count, CvSize win, CvSize zero_zone,
1017                                   CvTermCriteria  criteria );
1018  
1019  /* Finds a sparse set of points within the selected region
1020     that seem to be easy to track */
1021  CVAPI(void)  cvGoodFeaturesToTrack( const CvArr* image, CvArr* eig_image,
1022                                     CvArr* temp_image, CvPoint2D32f* corners,
1023                                     int* corner_count, double  quality_level,
1024                                     double  min_distance,
1025                                     const CvArr* mask CV_DEFAULT(NULL),
1026                                     int block_size CV_DEFAULT(3),
1027                                     int use_harris CV_DEFAULT(0),
1028                                     double k CV_DEFAULT(0.04) );
1029  
1030  #define CV_HOUGH_STANDARD 0
1031  #define CV_HOUGH_PROBABILISTIC 1
1032  #define CV_HOUGH_MULTI_SCALE 2
1033  #define CV_HOUGH_GRADIENT 3
1034  
1035  /* Finds lines on binary image using one of several methods.
1036     line_storage is either memory storage or 1 x <max number of lines> CvMat, its
1037     number of columns is changed by the function.
1038     method is one of CV_HOUGH_*;
1039     rho, theta and threshold are used for each of those methods;
1040     param1 ~ line length, param2 ~ line gap - for probabilistic,
1041     param1 ~ srn, param2 ~ stn - for multi-scale */
1042  CVAPI(CvSeq*)  cvHoughLines2( CvArr* image, void* line_storage, int method,
1043                                double rho, double theta, int threshold,
1044                                double param1 CV_DEFAULT(0), double param2 CV_DEFAULT(0));
1045  
1046  /* Finds circles in the image */
1047  CVAPI(CvSeq*) cvHoughCircles( CvArr* image, void* circle_storage,
1048                                int method, double dp, double min_dist,
1049                                double param1 CV_DEFAULT(100),
1050                                double param2 CV_DEFAULT(100),
1051                                int min_radius CV_DEFAULT(0),
1052                                int max_radius CV_DEFAULT(0));
1053  
1054  /* Fits a line into set of 2d or 3d points in a robust way (M-estimator technique) */
1055  CVAPI(void)  cvFitLine( const CvArr* points, int dist_type, double param,
1056                          double reps, double aeps, float* line );
1057  
1058  
1059  
1060  struct CvFeatureTree;
1061  
1062  /* Constructs kd-tree from set of feature descriptors */
1063  CVAPI(struct CvFeatureTree*) cvCreateFeatureTree(CvMat* desc);
1064  
1065  /* Release kd-tree */
1066  CVAPI(void) cvReleaseFeatureTree(struct CvFeatureTree* tr);
1067  
1068  /* Searches kd-tree for k nearest neighbors of given reference points,
1069     searching at most emax leaves. */
1070  CVAPI(void) cvFindFeatures(struct CvFeatureTree* tr, CvMat* desc,
1071  		    CvMat* results, CvMat* dist, int k CV_DEFAULT(2), int emax CV_DEFAULT(20));
1072  
1073  /* Search kd-tree for all points that are inlier to given rect region. */
1074  CVAPI(int) cvFindFeaturesBoxed(struct CvFeatureTree* tr,
1075  		    CvMat* bounds_min, CvMat* bounds_max,
1076  		    CvMat* results);
1077  
1078  typedef struct CvSURFPoint
1079  {
1080      CvPoint2D32f pt;
1081      int laplacian;
1082      int size;
1083      float dir;
1084      float hessian;
1085  } CvSURFPoint;
1086  
1087  CV_INLINE CvSURFPoint cvSURFPoint( CvPoint2D32f pt, int laplacian,
1088                                     int size, float dir CV_DEFAULT(0),
1089                                     float hessian CV_DEFAULT(0))
1090  {
1091      CvSURFPoint kp;
1092      kp.pt = pt;
1093      kp.laplacian = laplacian;
1094      kp.size = size;
1095      kp.dir = dir;
1096      kp.hessian = hessian;
1097      return kp;
1098  }
1099  
1100  typedef struct CvSURFParams
1101  {
1102      int extended;
1103      double hessianThreshold;
1104  
1105      int nOctaves;
1106      int nOctaveLayers;
1107  }
1108  CvSURFParams;
1109  
1110  CVAPI(CvSURFParams) cvSURFParams( double hessianThreshold, int extended CV_DEFAULT(0) );
1111  CVAPI(void) cvExtractSURF( const CvArr* img, const CvArr* mask,
1112                             CvSeq** keypoints, CvSeq** descriptors,
1113                             CvMemStorage* storage, CvSURFParams params );
1114  
1115  /****************************************************************************************\
1116  *                         Haar-like Object Detection functions                           *
1117  \****************************************************************************************/
1118  
1119  /* Loads haar classifier cascade from a directory.
1120     It is obsolete: convert your cascade to xml and use cvLoad instead */
1121  CVAPI(CvHaarClassifierCascade*) cvLoadHaarClassifierCascade(
1122                      const char* directory, CvSize orig_window_size);
1123  
1124  CVAPI(void) cvReleaseHaarClassifierCascade( CvHaarClassifierCascade** cascade );
1125  
1126  #define CV_HAAR_DO_CANNY_PRUNING    1
1127  #define CV_HAAR_SCALE_IMAGE         2
1128  #define CV_HAAR_FIND_BIGGEST_OBJECT 4
1129  #define CV_HAAR_DO_ROUGH_SEARCH     8
1130  
1131  CVAPI(CvSeq*) cvHaarDetectObjects( const CvArr* image,
1132                       CvHaarClassifierCascade* cascade,
1133                       CvMemStorage* storage, double scale_factor CV_DEFAULT(1.1),
1134                       int min_neighbors CV_DEFAULT(3), int flags CV_DEFAULT(0),
1135                       CvSize min_size CV_DEFAULT(cvSize(0,0)));
1136  
1137  /* sets images for haar classifier cascade */
1138  CVAPI(void) cvSetImagesForHaarClassifierCascade( CvHaarClassifierCascade* cascade,
1139                                                  const CvArr* sum, const CvArr* sqsum,
1140                                                  const CvArr* tilted_sum, double scale );
1141  
1142  /* runs the cascade on the specified window */
1143  CVAPI(int) cvRunHaarClassifierCascade( CvHaarClassifierCascade* cascade,
1144                                        CvPoint pt, int start_stage CV_DEFAULT(0));
1145  
1146  
1147  /* Alternate version that uses ints instead of floats */
1148  CVAPI(CvSeq*) mycvHaarDetectObjects( const CvArr* image,
1149                       CvHaarClassifierCascade* cascade,
1150                       CvMemStorage* storage, double scale_factor CV_DEFAULT(1.1),
1151                       int min_neighbors CV_DEFAULT(3), int flags CV_DEFAULT(0),
1152                       CvSize min_size CV_DEFAULT(cvSize(0,0)));
1153  
1154  CVAPI(void) mycvSetImagesForHaarClassifierCascade( CvHaarClassifierCascade* cascade,
1155                                                  const CvArr* sum, const CvArr* sqsum,
1156                                                  const CvArr* tilted_sum, double scale );
1157  
1158  CVAPI(int) mycvRunHaarClassifierCascade( CvHaarClassifierCascade* cascade,
1159                                        CvPoint pt, int start_stage CV_DEFAULT(0));
1160  
1161  /****************************************************************************************\
1162  *                      Camera Calibration, Pose Estimation and Stereo                    *
1163  \****************************************************************************************/
1164  
1165  /* Transforms the input image to compensate lens distortion */
1166  CVAPI(void) cvUndistort2( const CvArr* src, CvArr* dst,
1167                            const CvMat* camera_matrix,
1168                            const CvMat* distortion_coeffs );
1169  
1170  /* Computes transformation map from intrinsic camera parameters
1171     that can used by cvRemap */
1172  CVAPI(void) cvInitUndistortMap( const CvMat* camera_matrix,
1173                                  const CvMat* distortion_coeffs,
1174                                  CvArr* mapx, CvArr* mapy );
1175  
1176  /* Computes undistortion+rectification map for a head of stereo camera */
1177  CVAPI(void) cvInitUndistortRectifyMap( const CvMat* camera_matrix,
1178                                         const CvMat* dist_coeffs,
1179                                         const CvMat *R, const CvMat* new_camera_matrix,
1180                                         CvArr* mapx, CvArr* mapy );
1181  
1182  /* Computes the original (undistorted) feature coordinates
1183     from the observed (distorted) coordinates */
1184  CVAPI(void) cvUndistortPoints( const CvMat* src, CvMat* dst,
1185                                 const CvMat* camera_matrix,
1186                                 const CvMat* dist_coeffs,
1187                                 const CvMat* R CV_DEFAULT(0),
1188                                 const CvMat* P CV_DEFAULT(0));
1189  
1190  /* Converts rotation vector to rotation matrix or vice versa */
1191  CVAPI(int) cvRodrigues2( const CvMat* src, CvMat* dst,
1192                           CvMat* jacobian CV_DEFAULT(0) );
1193  
1194  #define CV_LMEDS 4
1195  #define CV_RANSAC 8
1196  
1197  /* Finds perspective transformation between the object plane and image (view) plane */
1198  CVAPI(int) cvFindHomography( const CvMat* src_points,
1199                               const CvMat* dst_points,
1200                               CvMat* homography,
1201                               int method CV_DEFAULT(0),
1202                               double ransacReprojThreshold CV_DEFAULT(0),
1203                               CvMat* mask CV_DEFAULT(0));
1204  
1205  /* Computes RQ decomposition for 3x3 matrices */
1206  CVAPI(void) cvRQDecomp3x3( const CvMat *matrixM, CvMat *matrixR, CvMat *matrixQ,
1207                             CvMat *matrixQx CV_DEFAULT(NULL),
1208                             CvMat *matrixQy CV_DEFAULT(NULL),
1209                             CvMat *matrixQz CV_DEFAULT(NULL),
1210                             CvPoint3D64f *eulerAngles CV_DEFAULT(NULL));
1211  
1212  /* Computes projection matrix decomposition */
1213  CVAPI(void) cvDecomposeProjectionMatrix( const CvMat *projMatr, CvMat *calibMatr,
1214                                           CvMat *rotMatr, CvMat *posVect,
1215                                           CvMat *rotMatrX CV_DEFAULT(NULL),
1216                                           CvMat *rotMatrY CV_DEFAULT(NULL),
1217                                           CvMat *rotMatrZ CV_DEFAULT(NULL),
1218                                           CvPoint3D64f *eulerAngles CV_DEFAULT(NULL));
1219  
1220  /* Computes d(AB)/dA and d(AB)/dB */
1221  CVAPI(void) cvCalcMatMulDeriv( const CvMat* A, const CvMat* B, CvMat* dABdA, CvMat* dABdB );
1222  
1223  /* Computes r3 = rodrigues(rodrigues(r2)*rodrigues(r1)),
1224     t3 = rodrigues(r2)*t1 + t2 and the respective derivatives */
1225  CVAPI(void) cvComposeRT( const CvMat* _rvec1, const CvMat* _tvec1,
1226                           const CvMat* _rvec2, const CvMat* _tvec2,
1227                           CvMat* _rvec3, CvMat* _tvec3,
1228                           CvMat* dr3dr1 CV_DEFAULT(0), CvMat* dr3dt1 CV_DEFAULT(0),
1229                           CvMat* dr3dr2 CV_DEFAULT(0), CvMat* dr3dt2 CV_DEFAULT(0),
1230                           CvMat* dt3dr1 CV_DEFAULT(0), CvMat* dt3dt1 CV_DEFAULT(0),
1231                           CvMat* dt3dr2 CV_DEFAULT(0), CvMat* dt3dt2 CV_DEFAULT(0) );
1232  
1233  /* Projects object points to the view plane using
1234     the specified extrinsic and intrinsic camera parameters */
1235  CVAPI(void) cvProjectPoints2( const CvMat* object_points, const CvMat* rotation_vector,
1236                                const CvMat* translation_vector, const CvMat* camera_matrix,
1237                                const CvMat* distortion_coeffs, CvMat* image_points,
1238                                CvMat* dpdrot CV_DEFAULT(NULL), CvMat* dpdt CV_DEFAULT(NULL),
1239                                CvMat* dpdf CV_DEFAULT(NULL), CvMat* dpdc CV_DEFAULT(NULL),
1240                                CvMat* dpddist CV_DEFAULT(NULL),
1241                                double aspect_ratio CV_DEFAULT(0));
1242  
1243  /* Finds extrinsic camera parameters from
1244     a few known corresponding point pairs and intrinsic parameters */
1245  CVAPI(void) cvFindExtrinsicCameraParams2( const CvMat* object_points,
1246                                            const CvMat* image_points,
1247                                            const CvMat* camera_matrix,
1248                                            const CvMat* distortion_coeffs,
1249                                            CvMat* rotation_vector,
1250                                            CvMat* translation_vector );
1251  
1252  /* Computes initial estimate of the intrinsic camera parameters
1253     in case of planar calibration target (e.g. chessboard) */
1254  CVAPI(void) cvInitIntrinsicParams2D( const CvMat* object_points,
1255                                       const CvMat* image_points,
1256                                       const CvMat* npoints, CvSize image_size,
1257                                       CvMat* camera_matrix,
1258                                       double aspect_ratio CV_DEFAULT(1.) );
1259  
1260  #define CV_CALIB_CB_ADAPTIVE_THRESH  1
1261  #define CV_CALIB_CB_NORMALIZE_IMAGE  2
1262  #define CV_CALIB_CB_FILTER_QUADS     4
1263  
1264  /* Detects corners on a chessboard calibration pattern */
1265  CVAPI(int) cvFindChessboardCorners( const void* image, CvSize pattern_size,
1266                                      CvPoint2D32f* corners,
1267                                      int* corner_count CV_DEFAULT(NULL),
1268                                      int flags CV_DEFAULT(CV_CALIB_CB_ADAPTIVE_THRESH+
1269                                          CV_CALIB_CB_NORMALIZE_IMAGE) );
1270  
1271  /* Draws individual chessboard corners or the whole chessboard detected */
1272  CVAPI(void) cvDrawChessboardCorners( CvArr* image, CvSize pattern_size,
1273                                       CvPoint2D32f* corners,
1274                                       int count, int pattern_was_found );
1275  
1276  #define CV_CALIB_USE_INTRINSIC_GUESS  1
1277  #define CV_CALIB_FIX_ASPECT_RATIO     2
1278  #define CV_CALIB_FIX_PRINCIPAL_POINT  4
1279  #define CV_CALIB_ZERO_TANGENT_DIST    8
1280  #define CV_CALIB_FIX_FOCAL_LENGTH 16
1281  #define CV_CALIB_FIX_K1  32
1282  #define CV_CALIB_FIX_K2  64
1283  #define CV_CALIB_FIX_K3  128
1284  
1285  /* Finds intrinsic and extrinsic camera parameters
1286     from a few views of known calibration pattern */
1287  CVAPI(void) cvCalibrateCamera2( const CvMat* object_points,
1288                                  const CvMat* image_points,
1289                                  const CvMat* point_counts,
1290                                  CvSize image_size,
1291                                  CvMat* camera_matrix,
1292                                  CvMat* distortion_coeffs,
1293                                  CvMat* rotation_vectors CV_DEFAULT(NULL),
1294                                  CvMat* translation_vectors CV_DEFAULT(NULL),
1295                                  int flags CV_DEFAULT(0) );
1296  
1297  /* Computes various useful characteristics of the camera from the data computed by
1298     cvCalibrateCamera2 */
1299  CVAPI(void) cvCalibrationMatrixValues( const CvMat *camera_matrix,
1300                                  CvSize image_size,
1301                                  double aperture_width CV_DEFAULT(0),
1302                                  double aperture_height CV_DEFAULT(0),
1303                                  double *fovx CV_DEFAULT(NULL),
1304                                  double *fovy CV_DEFAULT(NULL),
1305                                  double *focal_length CV_DEFAULT(NULL),
1306                                  CvPoint2D64f *principal_point CV_DEFAULT(NULL),
1307                                  double *pixel_aspect_ratio CV_DEFAULT(NULL));
1308  
1309  #define CV_CALIB_FIX_INTRINSIC  256
1310  #define CV_CALIB_SAME_FOCAL_LENGTH 512
1311  
1312  /* Computes the transformation from one camera coordinate system to another one
1313     from a few correspondent views of the same calibration target. Optionally, calibrates
1314     both cameras */
1315  CVAPI(void) cvStereoCalibrate( const CvMat* object_points, const CvMat* image_points1,
1316                                 const CvMat* image_points2, const CvMat* npoints,
1317                                 CvMat* camera_matrix1, CvMat* dist_coeffs1,
1318                                 CvMat* camera_matrix2, CvMat* dist_coeffs2,
1319                                 CvSize image_size, CvMat* R, CvMat* T,
1320                                 CvMat* E CV_DEFAULT(0), CvMat* F CV_DEFAULT(0),
1321                                 CvTermCriteria term_crit CV_DEFAULT(cvTermCriteria(
1322                                     CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,30,1e-6)),
1323                                 int flags CV_DEFAULT(CV_CALIB_FIX_INTRINSIC) );
1324  
1325  #define CV_CALIB_ZERO_DISPARITY 1024
1326  
1327  /* Computes 3D rotations (+ optional shift) for each camera coordinate system to make both
1328     views parallel (=> to make all the epipolar lines horizontal or vertical) */
1329  CVAPI(void) cvStereoRectify( const CvMat* camera_matrix1, const CvMat* camera_matrix2,
1330                               const CvMat* dist_coeffs1, const CvMat* dist_coeffs2,
1331                               CvSize image_size, const CvMat* R, const CvMat* T,
1332                               CvMat* R1, CvMat* R2, CvMat* P1, CvMat* P2,
1333                               CvMat* Q CV_DEFAULT(0),
1334                               int flags CV_DEFAULT(CV_CALIB_ZERO_DISPARITY) );
1335  
1336  /* Computes rectification transformations for uncalibrated pair of images using a set
1337     of point correspondences */
1338  CVAPI(int) cvStereoRectifyUncalibrated( const CvMat* points1, const CvMat* points2,
1339                                          const CvMat* F, CvSize img_size,
1340                                          CvMat* H1, CvMat* H2,
1341                                          double threshold CV_DEFAULT(5));
1342  
1343  typedef struct CvPOSITObject CvPOSITObject;
1344  
1345  /* Allocates and initializes CvPOSITObject structure before doing cvPOSIT */
1346  CVAPI(CvPOSITObject*)  cvCreatePOSITObject( CvPoint3D32f* points, int point_count );
1347  
1348  
1349  /* Runs POSIT (POSe from ITeration) algorithm for determining 3d position of
1350     an object given its model and projection in a weak-perspective case */
1351  CVAPI(void)  cvPOSIT(  CvPOSITObject* posit_object, CvPoint2D32f* image_points,
1352                         double focal_length, CvTermCriteria criteria,
1353                         CvMatr32f rotation_matrix, CvVect32f translation_vector);
1354  
1355  /* Releases CvPOSITObject structure */
1356  CVAPI(void)  cvReleasePOSITObject( CvPOSITObject**  posit_object );
1357  
1358  /* updates the number of RANSAC iterations */
1359  CVAPI(int) cvRANSACUpdateNumIters( double p, double err_prob,
1360                                     int model_points, int max_iters );
1361  
1362  CVAPI(void) cvConvertPointsHomogeneous( const CvMat* src, CvMat* dst );
1363  
1364  /* Calculates fundamental matrix given a set of corresponding points */
1365  #define CV_FM_7POINT 1
1366  #define CV_FM_8POINT 2
1367  #define CV_FM_LMEDS_ONLY  CV_LMEDS
1368  #define CV_FM_RANSAC_ONLY CV_RANSAC
1369  #define CV_FM_LMEDS CV_LMEDS
1370  #define CV_FM_RANSAC CV_RANSAC
1371  CVAPI(int) cvFindFundamentalMat( const CvMat* points1, const CvMat* points2,
1372                                   CvMat* fundamental_matrix,
1373                                   int method CV_DEFAULT(CV_FM_RANSAC),
1374                                   double param1 CV_DEFAULT(3.), double param2 CV_DEFAULT(0.99),
1375                                   CvMat* status CV_DEFAULT(NULL) );
1376  
1377  /* For each input point on one of images
1378     computes parameters of the corresponding
1379     epipolar line on the other image */
1380  CVAPI(void) cvComputeCorrespondEpilines( const CvMat* points,
1381                                           int which_image,
1382                                           const CvMat* fundamental_matrix,
1383                                           CvMat* correspondent_lines );
1384  
1385  /* stereo correspondence parameters and functions */
1386  
1387  #define CV_STEREO_BM_NORMALIZED_RESPONSE  0
1388  
1389  /* Block matching algorithm structure */
1390  typedef struct CvStereoBMState
1391  {
1392      // pre-filtering (normalization of input images)
1393      int preFilterType; // =CV_STEREO_BM_NORMALIZED_RESPONSE now
1394      int preFilterSize; // averaging window size: ~5x5..21x21
1395      int preFilterCap; // the output of pre-filtering is clipped by [-preFilterCap,preFilterCap]
1396  
1397      // correspondence using Sum of Absolute Difference (SAD)
1398      int SADWindowSize; // ~5x5..21x21
1399      int minDisparity;  // minimum disparity (can be negative)
1400      int numberOfDisparities; // maximum disparity - minimum disparity (> 0)
1401  
1402      // post-filtering
1403      int textureThreshold;  // the disparity is only computed for pixels
1404                             // with textured enough neighborhood
1405      int uniquenessRatio;   // accept the computed disparity d* only if
1406                             // SAD(d) >= SAD(d*)*(1 + uniquenessRatio/100.)
1407                             // for any d != d*+/-1 within the search range.
1408      int speckleWindowSize; // disparity variation window
1409      int speckleRange; // acceptable range of variation in window
1410  
1411      // temporary buffers
1412      CvMat* preFilteredImg0;
1413      CvMat* preFilteredImg1;
1414      CvMat* slidingSumBuf;
1415  }
1416  CvStereoBMState;
1417  
1418  #define CV_STEREO_BM_BASIC 0
1419  #define CV_STEREO_BM_FISH_EYE 1
1420  #define CV_STEREO_BM_NARROW 2
1421  
1422  CVAPI(CvStereoBMState*) cvCreateStereoBMState(int preset CV_DEFAULT(CV_STEREO_BM_BASIC),
1423                                                int numberOfDisparities CV_DEFAULT(0));
1424  
1425  CVAPI(void) cvReleaseStereoBMState( CvStereoBMState** state );
1426  
1427  CVAPI(void) cvFindStereoCorrespondenceBM( const CvArr* left, const CvArr* right,
1428                                            CvArr* disparity, CvStereoBMState* state );
1429  
1430  /* Kolmogorov-Zabin stereo-correspondence algorithm (a.k.a. KZ1) */
1431  #define CV_STEREO_GC_OCCLUDED  SHRT_MAX
1432  
1433  typedef struct CvStereoGCState
1434  {
1435      int Ithreshold;
1436      int interactionRadius;
1437      float K, lambda, lambda1, lambda2;
1438      int occlusionCost;
1439      int minDisparity;
1440      int numberOfDisparities;
1441      int maxIters;
1442  
1443      CvMat* left;
1444      CvMat* right;
1445      CvMat* dispLeft;
1446      CvMat* dispRight;
1447      CvMat* ptrLeft;
1448      CvMat* ptrRight;
1449      CvMat* vtxBuf;
1450      CvMat* edgeBuf;
1451  }
1452  CvStereoGCState;
1453  
1454  CVAPI(CvStereoGCState*) cvCreateStereoGCState( int numberOfDisparities, int maxIters );
1455  CVAPI(void) cvReleaseStereoGCState( CvStereoGCState** state );
1456  
1457  CVAPI(void) cvFindStereoCorrespondenceGC( const CvArr* left, const CvArr* right,
1458                                            CvArr* disparityLeft, CvArr* disparityRight,
1459                                            CvStereoGCState* state,
1460                                            int useDisparityGuess CV_DEFAULT(0) );
1461  
1462  /* Reprojects the computed disparity image to the 3D space using the specified 4x4 matrix */
1463  CVAPI(void)  cvReprojectImageTo3D( const CvArr* disparityImage,
1464                                     CvArr* _3dImage, const CvMat* Q );
1465  
1466  #ifdef __cplusplus
1467  }
1468  #endif
1469  
1470  #ifdef __cplusplus
1471  #include "cv.hpp"
1472  #endif
1473  
1474  /****************************************************************************************\
1475  *                                 Backward compatibility                                 *
1476  \****************************************************************************************/
1477  
1478  #ifndef CV_NO_BACKWARD_COMPATIBILITY
1479  #include "cvcompat.h"
1480  #endif
1481  
1482  #endif /*_CV_H_*/
1483