OpenCV 2.4.8 components for OpenCVgrabber.
[mmanager-3rdparty.git] / OpenCV2.4.8 / build / include / opencv2 / imgproc / imgproc.hpp
1 /*! \file imgproc.hpp
2  \brief The Image Processing
3  */
4
5 /*M///////////////////////////////////////////////////////////////////////////////////////
6 //
7 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
8 //
9 //  By downloading, copying, installing or using the software you agree to this license.
10 //  If you do not agree to this license, do not download, install,
11 //  copy or use the software.
12 //
13 //
14 //                           License Agreement
15 //                For Open Source Computer Vision Library
16 //
17 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
18 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
19 // Third party copyrights are property of their respective owners.
20 //
21 // Redistribution and use in source and binary forms, with or without modification,
22 // are permitted provided that the following conditions are met:
23 //
24 //   * Redistribution's of source code must retain the above copyright notice,
25 //     this list of conditions and the following disclaimer.
26 //
27 //   * Redistribution's in binary form must reproduce the above copyright notice,
28 //     this list of conditions and the following disclaimer in the documentation
29 //     and/or other materials provided with the distribution.
30 //
31 //   * The name of the copyright holders may not be used to endorse or promote products
32 //     derived from this software without specific prior written permission.
33 //
34 // This software is provided by the copyright holders and contributors "as is" and
35 // any express or implied warranties, including, but not limited to, the implied
36 // warranties of merchantability and fitness for a particular purpose are disclaimed.
37 // In no event shall the Intel Corporation or contributors be liable for any direct,
38 // indirect, incidental, special, exemplary, or consequential damages
39 // (including, but not limited to, procurement of substitute goods or services;
40 // loss of use, data, or profits; or business interruption) however caused
41 // and on any theory of liability, whether in contract, strict liability,
42 // or tort (including negligence or otherwise) arising in any way out of
43 // the use of this software, even if advised of the possibility of such damage.
44 //
45 //M*/
46
47 #ifndef __OPENCV_IMGPROC_HPP__
48 #define __OPENCV_IMGPROC_HPP__
49
50 #include "opencv2/core/core.hpp"
51 #include "opencv2/imgproc/types_c.h"
52
53 #ifdef __cplusplus
54
55 /*! \namespace cv
56  Namespace where all the C++ OpenCV functionality resides
57  */
58 namespace cv
59 {
60
61 //! various border interpolation methods
62 enum { BORDER_REPLICATE=IPL_BORDER_REPLICATE, BORDER_CONSTANT=IPL_BORDER_CONSTANT,
63        BORDER_REFLECT=IPL_BORDER_REFLECT, BORDER_WRAP=IPL_BORDER_WRAP,
64        BORDER_REFLECT_101=IPL_BORDER_REFLECT_101, BORDER_REFLECT101=BORDER_REFLECT_101,
65        BORDER_TRANSPARENT=IPL_BORDER_TRANSPARENT,
66        BORDER_DEFAULT=BORDER_REFLECT_101, BORDER_ISOLATED=16 };
67
68 //! 1D interpolation function: returns coordinate of the "donor" pixel for the specified location p.
69 CV_EXPORTS_W int borderInterpolate( int p, int len, int borderType );
70
71 /*!
72  The Base Class for 1D or Row-wise Filters
73
74  This is the base class for linear or non-linear filters that process 1D data.
75  In particular, such filters are used for the "horizontal" filtering parts in separable filters.
76
77  Several functions in OpenCV return Ptr<BaseRowFilter> for the specific types of filters,
78  and those pointers can be used directly or within cv::FilterEngine.
79 */
80 class CV_EXPORTS BaseRowFilter
81 {
82 public:
83     //! the default constructor
84     BaseRowFilter();
85     //! the destructor
86     virtual ~BaseRowFilter();
87     //! the filtering operator. Must be overrided in the derived classes. The horizontal border interpolation is done outside of the class.
88     virtual void operator()(const uchar* src, uchar* dst,
89                             int width, int cn) = 0;
90     int ksize, anchor;
91 };
92
93
94 /*!
95  The Base Class for Column-wise Filters
96
97  This is the base class for linear or non-linear filters that process columns of 2D arrays.
98  Such filters are used for the "vertical" filtering parts in separable filters.
99
100  Several functions in OpenCV return Ptr<BaseColumnFilter> for the specific types of filters,
101  and those pointers can be used directly or within cv::FilterEngine.
102
103  Unlike cv::BaseRowFilter, cv::BaseColumnFilter may have some context information,
104  i.e. box filter keeps the sliding sum of elements. To reset the state BaseColumnFilter::reset()
105  must be called (e.g. the method is called by cv::FilterEngine)
106  */
107 class CV_EXPORTS BaseColumnFilter
108 {
109 public:
110     //! the default constructor
111     BaseColumnFilter();
112     //! the destructor
113     virtual ~BaseColumnFilter();
114     //! the filtering operator. Must be overrided in the derived classes. The vertical border interpolation is done outside of the class.
115     virtual void operator()(const uchar** src, uchar* dst, int dststep,
116                             int dstcount, int width) = 0;
117     //! resets the internal buffers, if any
118     virtual void reset();
119     int ksize, anchor;
120 };
121
122 /*!
123  The Base Class for Non-Separable 2D Filters.
124
125  This is the base class for linear or non-linear 2D filters.
126
127  Several functions in OpenCV return Ptr<BaseFilter> for the specific types of filters,
128  and those pointers can be used directly or within cv::FilterEngine.
129
130  Similar to cv::BaseColumnFilter, the class may have some context information,
131  that should be reset using BaseFilter::reset() method before processing the new array.
132 */
133 class CV_EXPORTS BaseFilter
134 {
135 public:
136     //! the default constructor
137     BaseFilter();
138     //! the destructor
139     virtual ~BaseFilter();
140     //! the filtering operator. The horizontal and the vertical border interpolation is done outside of the class.
141     virtual void operator()(const uchar** src, uchar* dst, int dststep,
142                             int dstcount, int width, int cn) = 0;
143     //! resets the internal buffers, if any
144     virtual void reset();
145     Size ksize;
146     Point anchor;
147 };
148
149 /*!
150  The Main Class for Image Filtering.
151
152  The class can be used to apply an arbitrary filtering operation to an image.
153  It contains all the necessary intermediate buffers, it computes extrapolated values
154  of the "virtual" pixels outside of the image etc.
155  Pointers to the initialized cv::FilterEngine instances
156  are returned by various OpenCV functions, such as cv::createSeparableLinearFilter(),
157  cv::createLinearFilter(), cv::createGaussianFilter(), cv::createDerivFilter(),
158  cv::createBoxFilter() and cv::createMorphologyFilter().
159
160  Using the class you can process large images by parts and build complex pipelines
161  that include filtering as some of the stages. If all you need is to apply some pre-defined
162  filtering operation, you may use cv::filter2D(), cv::erode(), cv::dilate() etc.
163  functions that create FilterEngine internally.
164
165  Here is the example on how to use the class to implement Laplacian operator, which is the sum of
166  second-order derivatives. More complex variant for different types is implemented in cv::Laplacian().
167
168  \code
169  void laplace_f(const Mat& src, Mat& dst)
170  {
171      CV_Assert( src.type() == CV_32F );
172      // make sure the destination array has the proper size and type
173      dst.create(src.size(), src.type());
174
175      // get the derivative and smooth kernels for d2I/dx2.
176      // for d2I/dy2 we could use the same kernels, just swapped
177      Mat kd, ks;
178      getSobelKernels( kd, ks, 2, 0, ksize, false, ktype );
179
180      // let's process 10 source rows at once
181      int DELTA = std::min(10, src.rows);
182      Ptr<FilterEngine> Fxx = createSeparableLinearFilter(src.type(),
183      dst.type(), kd, ks, Point(-1,-1), 0, borderType, borderType, Scalar() );
184      Ptr<FilterEngine> Fyy = createSeparableLinearFilter(src.type(),
185      dst.type(), ks, kd, Point(-1,-1), 0, borderType, borderType, Scalar() );
186
187      int y = Fxx->start(src), dsty = 0, dy = 0;
188      Fyy->start(src);
189      const uchar* sptr = src.data + y*src.step;
190
191      // allocate the buffers for the spatial image derivatives;
192      // the buffers need to have more than DELTA rows, because at the
193      // last iteration the output may take max(kd.rows-1,ks.rows-1)
194      // rows more than the input.
195      Mat Ixx( DELTA + kd.rows - 1, src.cols, dst.type() );
196      Mat Iyy( DELTA + kd.rows - 1, src.cols, dst.type() );
197
198      // inside the loop we always pass DELTA rows to the filter
199      // (note that the "proceed" method takes care of possibe overflow, since
200      // it was given the actual image height in the "start" method)
201      // on output we can get:
202      //  * < DELTA rows (the initial buffer accumulation stage)
203      //  * = DELTA rows (settled state in the middle)
204      //  * > DELTA rows (then the input image is over, but we generate
205      //                  "virtual" rows using the border mode and filter them)
206      // this variable number of output rows is dy.
207      // dsty is the current output row.
208      // sptr is the pointer to the first input row in the portion to process
209      for( ; dsty < dst.rows; sptr += DELTA*src.step, dsty += dy )
210      {
211          Fxx->proceed( sptr, (int)src.step, DELTA, Ixx.data, (int)Ixx.step );
212          dy = Fyy->proceed( sptr, (int)src.step, DELTA, d2y.data, (int)Iyy.step );
213          if( dy > 0 )
214          {
215              Mat dstripe = dst.rowRange(dsty, dsty + dy);
216              add(Ixx.rowRange(0, dy), Iyy.rowRange(0, dy), dstripe);
217          }
218      }
219  }
220  \endcode
221 */
222 class CV_EXPORTS FilterEngine
223 {
224 public:
225     //! the default constructor
226     FilterEngine();
227     //! the full constructor. Either _filter2D or both _rowFilter and _columnFilter must be non-empty.
228     FilterEngine(const Ptr<BaseFilter>& _filter2D,
229                  const Ptr<BaseRowFilter>& _rowFilter,
230                  const Ptr<BaseColumnFilter>& _columnFilter,
231                  int srcType, int dstType, int bufType,
232                  int _rowBorderType=BORDER_REPLICATE,
233                  int _columnBorderType=-1,
234                  const Scalar& _borderValue=Scalar());
235     //! the destructor
236     virtual ~FilterEngine();
237     //! reinitializes the engine. The previously assigned filters are released.
238     void init(const Ptr<BaseFilter>& _filter2D,
239               const Ptr<BaseRowFilter>& _rowFilter,
240               const Ptr<BaseColumnFilter>& _columnFilter,
241               int srcType, int dstType, int bufType,
242               int _rowBorderType=BORDER_REPLICATE, int _columnBorderType=-1,
243               const Scalar& _borderValue=Scalar());
244     //! starts filtering of the specified ROI of an image of size wholeSize.
245     virtual int start(Size wholeSize, Rect roi, int maxBufRows=-1);
246     //! starts filtering of the specified ROI of the specified image.
247     virtual int start(const Mat& src, const Rect& srcRoi=Rect(0,0,-1,-1),
248                       bool isolated=false, int maxBufRows=-1);
249     //! processes the next srcCount rows of the image.
250     virtual int proceed(const uchar* src, int srcStep, int srcCount,
251                         uchar* dst, int dstStep);
252     //! applies filter to the specified ROI of the image. if srcRoi=(0,0,-1,-1), the whole image is filtered.
253     virtual void apply( const Mat& src, Mat& dst,
254                         const Rect& srcRoi=Rect(0,0,-1,-1),
255                         Point dstOfs=Point(0,0),
256                         bool isolated=false);
257     //! returns true if the filter is separable
258     bool isSeparable() const { return (const BaseFilter*)filter2D == 0; }
259     //! returns the number
260     int remainingInputRows() const;
261     int remainingOutputRows() const;
262
263     int srcType, dstType, bufType;
264     Size ksize;
265     Point anchor;
266     int maxWidth;
267     Size wholeSize;
268     Rect roi;
269     int dx1, dx2;
270     int rowBorderType, columnBorderType;
271     vector<int> borderTab;
272     int borderElemSize;
273     vector<uchar> ringBuf;
274     vector<uchar> srcRow;
275     vector<uchar> constBorderValue;
276     vector<uchar> constBorderRow;
277     int bufStep, startY, startY0, endY, rowCount, dstY;
278     vector<uchar*> rows;
279
280     Ptr<BaseFilter> filter2D;
281     Ptr<BaseRowFilter> rowFilter;
282     Ptr<BaseColumnFilter> columnFilter;
283 };
284
285 //! type of the kernel
286 enum { KERNEL_GENERAL=0, KERNEL_SYMMETRICAL=1, KERNEL_ASYMMETRICAL=2,
287        KERNEL_SMOOTH=4, KERNEL_INTEGER=8 };
288
289 //! returns type (one of KERNEL_*) of 1D or 2D kernel specified by its coefficients.
290 CV_EXPORTS int getKernelType(InputArray kernel, Point anchor);
291
292 //! returns the primitive row filter with the specified kernel
293 CV_EXPORTS Ptr<BaseRowFilter> getLinearRowFilter(int srcType, int bufType,
294                                             InputArray kernel, int anchor,
295                                             int symmetryType);
296
297 //! returns the primitive column filter with the specified kernel
298 CV_EXPORTS Ptr<BaseColumnFilter> getLinearColumnFilter(int bufType, int dstType,
299                                             InputArray kernel, int anchor,
300                                             int symmetryType, double delta=0,
301                                             int bits=0);
302
303 //! returns 2D filter with the specified kernel
304 CV_EXPORTS Ptr<BaseFilter> getLinearFilter(int srcType, int dstType,
305                                            InputArray kernel,
306                                            Point anchor=Point(-1,-1),
307                                            double delta=0, int bits=0);
308
309 //! returns the separable linear filter engine
310 CV_EXPORTS Ptr<FilterEngine> createSeparableLinearFilter(int srcType, int dstType,
311                           InputArray rowKernel, InputArray columnKernel,
312                           Point anchor=Point(-1,-1), double delta=0,
313                           int rowBorderType=BORDER_DEFAULT,
314                           int columnBorderType=-1,
315                           const Scalar& borderValue=Scalar());
316
317 //! returns the non-separable linear filter engine
318 CV_EXPORTS Ptr<FilterEngine> createLinearFilter(int srcType, int dstType,
319                  InputArray kernel, Point _anchor=Point(-1,-1),
320                  double delta=0, int rowBorderType=BORDER_DEFAULT,
321                  int columnBorderType=-1, const Scalar& borderValue=Scalar());
322
323 //! returns the Gaussian kernel with the specified parameters
324 CV_EXPORTS_W Mat getGaussianKernel( int ksize, double sigma, int ktype=CV_64F );
325
326 //! returns the Gaussian filter engine
327 CV_EXPORTS Ptr<FilterEngine> createGaussianFilter( int type, Size ksize,
328                                     double sigma1, double sigma2=0,
329                                     int borderType=BORDER_DEFAULT);
330 //! initializes kernels of the generalized Sobel operator
331 CV_EXPORTS_W void getDerivKernels( OutputArray kx, OutputArray ky,
332                                    int dx, int dy, int ksize,
333                                    bool normalize=false, int ktype=CV_32F );
334 //! returns filter engine for the generalized Sobel operator
335 CV_EXPORTS Ptr<FilterEngine> createDerivFilter( int srcType, int dstType,
336                                         int dx, int dy, int ksize,
337                                         int borderType=BORDER_DEFAULT );
338 //! returns horizontal 1D box filter
339 CV_EXPORTS Ptr<BaseRowFilter> getRowSumFilter(int srcType, int sumType,
340                                               int ksize, int anchor=-1);
341 //! returns vertical 1D box filter
342 CV_EXPORTS Ptr<BaseColumnFilter> getColumnSumFilter( int sumType, int dstType,
343                                                      int ksize, int anchor=-1,
344                                                      double scale=1);
345 //! returns box filter engine
346 CV_EXPORTS Ptr<FilterEngine> createBoxFilter( int srcType, int dstType, Size ksize,
347                                               Point anchor=Point(-1,-1),
348                                               bool normalize=true,
349                                               int borderType=BORDER_DEFAULT);
350
351 //! returns the Gabor kernel with the specified parameters
352 CV_EXPORTS_W Mat getGaborKernel( Size ksize, double sigma, double theta, double lambd,
353                                  double gamma, double psi=CV_PI*0.5, int ktype=CV_64F );
354
355 //! type of morphological operation
356 enum { MORPH_ERODE=CV_MOP_ERODE, MORPH_DILATE=CV_MOP_DILATE,
357        MORPH_OPEN=CV_MOP_OPEN, MORPH_CLOSE=CV_MOP_CLOSE,
358        MORPH_GRADIENT=CV_MOP_GRADIENT, MORPH_TOPHAT=CV_MOP_TOPHAT,
359        MORPH_BLACKHAT=CV_MOP_BLACKHAT };
360
361 //! returns horizontal 1D morphological filter
362 CV_EXPORTS Ptr<BaseRowFilter> getMorphologyRowFilter(int op, int type, int ksize, int anchor=-1);
363 //! returns vertical 1D morphological filter
364 CV_EXPORTS Ptr<BaseColumnFilter> getMorphologyColumnFilter(int op, int type, int ksize, int anchor=-1);
365 //! returns 2D morphological filter
366 CV_EXPORTS Ptr<BaseFilter> getMorphologyFilter(int op, int type, InputArray kernel,
367                                                Point anchor=Point(-1,-1));
368
369 //! returns "magic" border value for erosion and dilation. It is automatically transformed to Scalar::all(-DBL_MAX) for dilation.
370 static inline Scalar morphologyDefaultBorderValue() { return Scalar::all(DBL_MAX); }
371
372 //! returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported.
373 CV_EXPORTS Ptr<FilterEngine> createMorphologyFilter(int op, int type, InputArray kernel,
374                     Point anchor=Point(-1,-1), int rowBorderType=BORDER_CONSTANT,
375                     int columnBorderType=-1,
376                     const Scalar& borderValue=morphologyDefaultBorderValue());
377
378 //! shape of the structuring element
379 enum { MORPH_RECT=0, MORPH_CROSS=1, MORPH_ELLIPSE=2 };
380 //! returns structuring element of the specified shape and size
381 CV_EXPORTS_W Mat getStructuringElement(int shape, Size ksize, Point anchor=Point(-1,-1));
382
383 template<> CV_EXPORTS void Ptr<IplConvKernel>::delete_obj();
384
385 //! copies 2D array to a larger destination array with extrapolation of the outer part of src using the specified border mode
386 CV_EXPORTS_W void copyMakeBorder( InputArray src, OutputArray dst,
387                                 int top, int bottom, int left, int right,
388                                 int borderType, const Scalar& value=Scalar() );
389
390 //! smooths the image using median filter.
391 CV_EXPORTS_W void medianBlur( InputArray src, OutputArray dst, int ksize );
392 //! smooths the image using Gaussian filter.
393 CV_EXPORTS_W void GaussianBlur( InputArray src,
394                                                OutputArray dst, Size ksize,
395                                                double sigmaX, double sigmaY=0,
396                                                int borderType=BORDER_DEFAULT );
397 //! smooths the image using bilateral filter
398 CV_EXPORTS_W void bilateralFilter( InputArray src, OutputArray dst, int d,
399                                    double sigmaColor, double sigmaSpace,
400                                    int borderType=BORDER_DEFAULT );
401 //! smooths the image using adaptive bilateral filter
402 CV_EXPORTS_W void adaptiveBilateralFilter( InputArray src, OutputArray dst, Size ksize,
403                                            double sigmaSpace, double maxSigmaColor = 20.0, Point anchor=Point(-1, -1),
404                                            int borderType=BORDER_DEFAULT );
405 //! smooths the image using the box filter. Each pixel is processed in O(1) time
406 CV_EXPORTS_W void boxFilter( InputArray src, OutputArray dst, int ddepth,
407                              Size ksize, Point anchor=Point(-1,-1),
408                              bool normalize=true,
409                              int borderType=BORDER_DEFAULT );
410 //! a synonym for normalized box filter
411 CV_EXPORTS_W void blur( InputArray src, OutputArray dst,
412                         Size ksize, Point anchor=Point(-1,-1),
413                         int borderType=BORDER_DEFAULT );
414
415 //! applies non-separable 2D linear filter to the image
416 CV_EXPORTS_W void filter2D( InputArray src, OutputArray dst, int ddepth,
417                             InputArray kernel, Point anchor=Point(-1,-1),
418                             double delta=0, int borderType=BORDER_DEFAULT );
419
420 //! applies separable 2D linear filter to the image
421 CV_EXPORTS_W void sepFilter2D( InputArray src, OutputArray dst, int ddepth,
422                                InputArray kernelX, InputArray kernelY,
423                                Point anchor=Point(-1,-1),
424                                double delta=0, int borderType=BORDER_DEFAULT );
425
426 //! applies generalized Sobel operator to the image
427 CV_EXPORTS_W void Sobel( InputArray src, OutputArray dst, int ddepth,
428                          int dx, int dy, int ksize=3,
429                          double scale=1, double delta=0,
430                          int borderType=BORDER_DEFAULT );
431
432 //! applies the vertical or horizontal Scharr operator to the image
433 CV_EXPORTS_W void Scharr( InputArray src, OutputArray dst, int ddepth,
434                           int dx, int dy, double scale=1, double delta=0,
435                           int borderType=BORDER_DEFAULT );
436
437 //! applies Laplacian operator to the image
438 CV_EXPORTS_W void Laplacian( InputArray src, OutputArray dst, int ddepth,
439                              int ksize=1, double scale=1, double delta=0,
440                              int borderType=BORDER_DEFAULT );
441
442 //! applies Canny edge detector and produces the edge map.
443 CV_EXPORTS_W void Canny( InputArray image, OutputArray edges,
444                          double threshold1, double threshold2,
445                          int apertureSize=3, bool L2gradient=false );
446
447 //! computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria
448 CV_EXPORTS_W void cornerMinEigenVal( InputArray src, OutputArray dst,
449                                    int blockSize, int ksize=3,
450                                    int borderType=BORDER_DEFAULT );
451
452 //! computes Harris cornerness criteria at each image pixel
453 CV_EXPORTS_W void cornerHarris( InputArray src, OutputArray dst, int blockSize,
454                                 int ksize, double k,
455                                 int borderType=BORDER_DEFAULT );
456
457 // low-level function for computing eigenvalues and eigenvectors of 2x2 matrices
458 CV_EXPORTS void eigen2x2( const float* a, float* e, int n );
459
460 //! computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix  at each pixel. The output is stored as 6-channel matrix.
461 CV_EXPORTS_W void cornerEigenValsAndVecs( InputArray src, OutputArray dst,
462                                           int blockSize, int ksize,
463                                           int borderType=BORDER_DEFAULT );
464
465 //! computes another complex cornerness criteria at each pixel
466 CV_EXPORTS_W void preCornerDetect( InputArray src, OutputArray dst, int ksize,
467                                    int borderType=BORDER_DEFAULT );
468
469 //! adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria
470 CV_EXPORTS_W void cornerSubPix( InputArray image, InputOutputArray corners,
471                                 Size winSize, Size zeroZone,
472                                 TermCriteria criteria );
473
474 //! finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima
475 CV_EXPORTS_W void goodFeaturesToTrack( InputArray image, OutputArray corners,
476                                      int maxCorners, double qualityLevel, double minDistance,
477                                      InputArray mask=noArray(), int blockSize=3,
478                                      bool useHarrisDetector=false, double k=0.04 );
479
480 //! finds lines in the black-n-white image using the standard or pyramid Hough transform
481 CV_EXPORTS_W void HoughLines( InputArray image, OutputArray lines,
482                               double rho, double theta, int threshold,
483                               double srn=0, double stn=0 );
484
485 //! finds line segments in the black-n-white image using probabilistic Hough transform
486 CV_EXPORTS_W void HoughLinesP( InputArray image, OutputArray lines,
487                                double rho, double theta, int threshold,
488                                double minLineLength=0, double maxLineGap=0 );
489
490 //! finds circles in the grayscale image using 2+1 gradient Hough transform
491 CV_EXPORTS_W void HoughCircles( InputArray image, OutputArray circles,
492                                int method, double dp, double minDist,
493                                double param1=100, double param2=100,
494                                int minRadius=0, int maxRadius=0 );
495
496 enum
497 {
498     GHT_POSITION = 0,
499     GHT_SCALE = 1,
500     GHT_ROTATION = 2
501 };
502
503 //! finds arbitrary template in the grayscale image using Generalized Hough Transform
504 //! Ballard, D.H. (1981). Generalizing the Hough transform to detect arbitrary shapes. Pattern Recognition 13 (2): 111-122.
505 //! Guil, N., Gonz├ílez-Linares, J.M. and Zapata, E.L. (1999). Bidimensional shape detection using an invariant approach. Pattern Recognition 32 (6): 1025-1038.
506 class CV_EXPORTS GeneralizedHough : public Algorithm
507 {
508 public:
509     static Ptr<GeneralizedHough> create(int method);
510
511     virtual ~GeneralizedHough();
512
513     //! set template to search
514     void setTemplate(InputArray templ, int cannyThreshold = 100, Point templCenter = Point(-1, -1));
515     void setTemplate(InputArray edges, InputArray dx, InputArray dy, Point templCenter = Point(-1, -1));
516
517     //! find template on image
518     void detect(InputArray image, OutputArray positions, OutputArray votes = cv::noArray(), int cannyThreshold = 100);
519     void detect(InputArray edges, InputArray dx, InputArray dy, OutputArray positions, OutputArray votes = cv::noArray());
520
521     void release();
522
523 protected:
524     virtual void setTemplateImpl(const Mat& edges, const Mat& dx, const Mat& dy, Point templCenter) = 0;
525     virtual void detectImpl(const Mat& edges, const Mat& dx, const Mat& dy, OutputArray positions, OutputArray votes) = 0;
526     virtual void releaseImpl() = 0;
527
528 private:
529     Mat edges_, dx_, dy_;
530 };
531
532 //! erodes the image (applies the local minimum operator)
533 CV_EXPORTS_W void erode( InputArray src, OutputArray dst, InputArray kernel,
534                          Point anchor=Point(-1,-1), int iterations=1,
535                          int borderType=BORDER_CONSTANT,
536                          const Scalar& borderValue=morphologyDefaultBorderValue() );
537
538 //! dilates the image (applies the local maximum operator)
539 CV_EXPORTS_W void dilate( InputArray src, OutputArray dst, InputArray kernel,
540                           Point anchor=Point(-1,-1), int iterations=1,
541                           int borderType=BORDER_CONSTANT,
542                           const Scalar& borderValue=morphologyDefaultBorderValue() );
543
544 //! applies an advanced morphological operation to the image
545 CV_EXPORTS_W void morphologyEx( InputArray src, OutputArray dst,
546                                 int op, InputArray kernel,
547                                 Point anchor=Point(-1,-1), int iterations=1,
548                                 int borderType=BORDER_CONSTANT,
549                                 const Scalar& borderValue=morphologyDefaultBorderValue() );
550
551 //! interpolation algorithm
552 enum
553 {
554     INTER_NEAREST=CV_INTER_NN, //!< nearest neighbor interpolation
555     INTER_LINEAR=CV_INTER_LINEAR, //!< bilinear interpolation
556     INTER_CUBIC=CV_INTER_CUBIC, //!< bicubic interpolation
557     INTER_AREA=CV_INTER_AREA, //!< area-based (or super) interpolation
558     INTER_LANCZOS4=CV_INTER_LANCZOS4, //!< Lanczos interpolation over 8x8 neighborhood
559     INTER_MAX=7,
560     WARP_INVERSE_MAP=CV_WARP_INVERSE_MAP
561 };
562
563 //! resizes the image
564 CV_EXPORTS_W void resize( InputArray src, OutputArray dst,
565                           Size dsize, double fx=0, double fy=0,
566                           int interpolation=INTER_LINEAR );
567
568 //! warps the image using affine transformation
569 CV_EXPORTS_W void warpAffine( InputArray src, OutputArray dst,
570                               InputArray M, Size dsize,
571                               int flags=INTER_LINEAR,
572                               int borderMode=BORDER_CONSTANT,
573                               const Scalar& borderValue=Scalar());
574
575 //! warps the image using perspective transformation
576 CV_EXPORTS_W void warpPerspective( InputArray src, OutputArray dst,
577                                    InputArray M, Size dsize,
578                                    int flags=INTER_LINEAR,
579                                    int borderMode=BORDER_CONSTANT,
580                                    const Scalar& borderValue=Scalar());
581
582 enum
583 {
584     INTER_BITS=5, INTER_BITS2=INTER_BITS*2,
585     INTER_TAB_SIZE=(1<<INTER_BITS),
586     INTER_TAB_SIZE2=INTER_TAB_SIZE*INTER_TAB_SIZE
587 };
588
589 //! warps the image using the precomputed maps. The maps are stored in either floating-point or integer fixed-point format
590 CV_EXPORTS_W void remap( InputArray src, OutputArray dst,
591                          InputArray map1, InputArray map2,
592                          int interpolation, int borderMode=BORDER_CONSTANT,
593                          const Scalar& borderValue=Scalar());
594
595 //! converts maps for remap from floating-point to fixed-point format or backwards
596 CV_EXPORTS_W void convertMaps( InputArray map1, InputArray map2,
597                                OutputArray dstmap1, OutputArray dstmap2,
598                                int dstmap1type, bool nninterpolation=false );
599
600 //! returns 2x3 affine transformation matrix for the planar rotation.
601 CV_EXPORTS_W Mat getRotationMatrix2D( Point2f center, double angle, double scale );
602 //! returns 3x3 perspective transformation for the corresponding 4 point pairs.
603 CV_EXPORTS Mat getPerspectiveTransform( const Point2f src[], const Point2f dst[] );
604 //! returns 2x3 affine transformation for the corresponding 3 point pairs.
605 CV_EXPORTS Mat getAffineTransform( const Point2f src[], const Point2f dst[] );
606 //! computes 2x3 affine transformation matrix that is inverse to the specified 2x3 affine transformation.
607 CV_EXPORTS_W void invertAffineTransform( InputArray M, OutputArray iM );
608
609 CV_EXPORTS_W Mat getPerspectiveTransform( InputArray src, InputArray dst );
610 CV_EXPORTS_W Mat getAffineTransform( InputArray src, InputArray dst );
611
612 //! extracts rectangle from the image at sub-pixel location
613 CV_EXPORTS_W void getRectSubPix( InputArray image, Size patchSize,
614                                  Point2f center, OutputArray patch, int patchType=-1 );
615
616 //! computes the integral image
617 CV_EXPORTS_W void integral( InputArray src, OutputArray sum, int sdepth=-1 );
618
619 //! computes the integral image and integral for the squared image
620 CV_EXPORTS_AS(integral2) void integral( InputArray src, OutputArray sum,
621                                         OutputArray sqsum, int sdepth=-1 );
622 //! computes the integral image, integral for the squared image and the tilted integral image
623 CV_EXPORTS_AS(integral3) void integral( InputArray src, OutputArray sum,
624                                         OutputArray sqsum, OutputArray tilted,
625                                         int sdepth=-1 );
626
627 //! adds image to the accumulator (dst += src). Unlike cv::add, dst and src can have different types.
628 CV_EXPORTS_W void accumulate( InputArray src, InputOutputArray dst,
629                               InputArray mask=noArray() );
630 //! adds squared src image to the accumulator (dst += src*src).
631 CV_EXPORTS_W void accumulateSquare( InputArray src, InputOutputArray dst,
632                                     InputArray mask=noArray() );
633 //! adds product of the 2 images to the accumulator (dst += src1*src2).
634 CV_EXPORTS_W void accumulateProduct( InputArray src1, InputArray src2,
635                                      InputOutputArray dst, InputArray mask=noArray() );
636 //! updates the running average (dst = dst*(1-alpha) + src*alpha)
637 CV_EXPORTS_W void accumulateWeighted( InputArray src, InputOutputArray dst,
638                                       double alpha, InputArray mask=noArray() );
639
640 //! computes PSNR image/video quality metric
641 CV_EXPORTS_W double PSNR(InputArray src1, InputArray src2);
642
643 CV_EXPORTS_W Point2d phaseCorrelate(InputArray src1, InputArray src2,
644                                   InputArray window = noArray());
645 CV_EXPORTS_W Point2d phaseCorrelateRes(InputArray src1, InputArray src2,
646                                     InputArray window, CV_OUT double* response = 0);
647 CV_EXPORTS_W void createHanningWindow(OutputArray dst, Size winSize, int type);
648
649 //! type of the threshold operation
650 enum { THRESH_BINARY=CV_THRESH_BINARY, THRESH_BINARY_INV=CV_THRESH_BINARY_INV,
651        THRESH_TRUNC=CV_THRESH_TRUNC, THRESH_TOZERO=CV_THRESH_TOZERO,
652        THRESH_TOZERO_INV=CV_THRESH_TOZERO_INV, THRESH_MASK=CV_THRESH_MASK,
653        THRESH_OTSU=CV_THRESH_OTSU };
654
655 //! applies fixed threshold to the image
656 CV_EXPORTS_W double threshold( InputArray src, OutputArray dst,
657                                double thresh, double maxval, int type );
658
659 //! adaptive threshold algorithm
660 enum { ADAPTIVE_THRESH_MEAN_C=0, ADAPTIVE_THRESH_GAUSSIAN_C=1 };
661
662 //! applies variable (adaptive) threshold to the image
663 CV_EXPORTS_W void adaptiveThreshold( InputArray src, OutputArray dst,
664                                      double maxValue, int adaptiveMethod,
665                                      int thresholdType, int blockSize, double C );
666
667 //! smooths and downsamples the image
668 CV_EXPORTS_W void pyrDown( InputArray src, OutputArray dst,
669                            const Size& dstsize=Size(), int borderType=BORDER_DEFAULT );
670 //! upsamples and smoothes the image
671 CV_EXPORTS_W void pyrUp( InputArray src, OutputArray dst,
672                          const Size& dstsize=Size(), int borderType=BORDER_DEFAULT );
673
674 //! builds the gaussian pyramid using pyrDown() as a basic operation
675 CV_EXPORTS void buildPyramid( InputArray src, OutputArrayOfArrays dst,
676                               int maxlevel, int borderType=BORDER_DEFAULT );
677
678 //! corrects lens distortion for the given camera matrix and distortion coefficients
679 CV_EXPORTS_W void undistort( InputArray src, OutputArray dst,
680                              InputArray cameraMatrix,
681                              InputArray distCoeffs,
682                              InputArray newCameraMatrix=noArray() );
683
684 //! initializes maps for cv::remap() to correct lens distortion and optionally rectify the image
685 CV_EXPORTS_W void initUndistortRectifyMap( InputArray cameraMatrix, InputArray distCoeffs,
686                            InputArray R, InputArray newCameraMatrix,
687                            Size size, int m1type, OutputArray map1, OutputArray map2 );
688
689 enum
690 {
691     PROJ_SPHERICAL_ORTHO = 0,
692     PROJ_SPHERICAL_EQRECT = 1
693 };
694
695 //! initializes maps for cv::remap() for wide-angle
696 CV_EXPORTS_W float initWideAngleProjMap( InputArray cameraMatrix, InputArray distCoeffs,
697                                          Size imageSize, int destImageWidth,
698                                          int m1type, OutputArray map1, OutputArray map2,
699                                          int projType=PROJ_SPHERICAL_EQRECT, double alpha=0);
700
701 //! returns the default new camera matrix (by default it is the same as cameraMatrix unless centerPricipalPoint=true)
702 CV_EXPORTS_W Mat getDefaultNewCameraMatrix( InputArray cameraMatrix, Size imgsize=Size(),
703                                             bool centerPrincipalPoint=false );
704
705 //! returns points' coordinates after lens distortion correction
706 CV_EXPORTS_W void undistortPoints( InputArray src, OutputArray dst,
707                                    InputArray cameraMatrix, InputArray distCoeffs,
708                                    InputArray R=noArray(), InputArray P=noArray());
709
710 template<> CV_EXPORTS void Ptr<CvHistogram>::delete_obj();
711
712 //! computes the joint dense histogram for a set of images.
713 CV_EXPORTS void calcHist( const Mat* images, int nimages,
714                           const int* channels, InputArray mask,
715                           OutputArray hist, int dims, const int* histSize,
716                           const float** ranges, bool uniform=true, bool accumulate=false );
717
718 //! computes the joint sparse histogram for a set of images.
719 CV_EXPORTS void calcHist( const Mat* images, int nimages,
720                           const int* channels, InputArray mask,
721                           SparseMat& hist, int dims,
722                           const int* histSize, const float** ranges,
723                           bool uniform=true, bool accumulate=false );
724
725 CV_EXPORTS_W void calcHist( InputArrayOfArrays images,
726                             const vector<int>& channels,
727                             InputArray mask, OutputArray hist,
728                             const vector<int>& histSize,
729                             const vector<float>& ranges,
730                             bool accumulate=false );
731
732 //! computes back projection for the set of images
733 CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
734                                  const int* channels, InputArray hist,
735                                  OutputArray backProject, const float** ranges,
736                                  double scale=1, bool uniform=true );
737
738 //! computes back projection for the set of images
739 CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
740                                  const int* channels, const SparseMat& hist,
741                                  OutputArray backProject, const float** ranges,
742                                  double scale=1, bool uniform=true );
743
744 CV_EXPORTS_W void calcBackProject( InputArrayOfArrays images, const vector<int>& channels,
745                                    InputArray hist, OutputArray dst,
746                                    const vector<float>& ranges,
747                                    double scale );
748
749 /*CV_EXPORTS void calcBackProjectPatch( const Mat* images, int nimages, const int* channels,
750                                       InputArray hist, OutputArray dst, Size patchSize,
751                                       int method, double factor=1 );
752
753 CV_EXPORTS_W void calcBackProjectPatch( InputArrayOfArrays images, const vector<int>& channels,
754                                         InputArray hist, OutputArray dst, Size patchSize,
755                                         int method, double factor=1 );*/
756
757 //! compares two histograms stored in dense arrays
758 CV_EXPORTS_W double compareHist( InputArray H1, InputArray H2, int method );
759
760 //! compares two histograms stored in sparse arrays
761 CV_EXPORTS double compareHist( const SparseMat& H1, const SparseMat& H2, int method );
762
763 //! normalizes the grayscale image brightness and contrast by normalizing its histogram
764 CV_EXPORTS_W void equalizeHist( InputArray src, OutputArray dst );
765
766 class CV_EXPORTS_W CLAHE : public Algorithm
767 {
768 public:
769     CV_WRAP virtual void apply(InputArray src, OutputArray dst) = 0;
770
771     CV_WRAP virtual void setClipLimit(double clipLimit) = 0;
772     CV_WRAP virtual double getClipLimit() const = 0;
773
774     CV_WRAP virtual void setTilesGridSize(Size tileGridSize) = 0;
775     CV_WRAP virtual Size getTilesGridSize() const = 0;
776
777     CV_WRAP virtual void collectGarbage() = 0;
778 };
779 CV_EXPORTS_W Ptr<CLAHE> createCLAHE(double clipLimit = 40.0, Size tileGridSize = Size(8, 8));
780
781 CV_EXPORTS float EMD( InputArray signature1, InputArray signature2,
782                       int distType, InputArray cost=noArray(),
783                       float* lowerBound=0, OutputArray flow=noArray() );
784
785 //! segments the image using watershed algorithm
786 CV_EXPORTS_W void watershed( InputArray image, InputOutputArray markers );
787
788 //! filters image using meanshift algorithm
789 CV_EXPORTS_W void pyrMeanShiftFiltering( InputArray src, OutputArray dst,
790                                          double sp, double sr, int maxLevel=1,
791                                          TermCriteria termcrit=TermCriteria(
792                                             TermCriteria::MAX_ITER+TermCriteria::EPS,5,1) );
793
794 //! class of the pixel in GrabCut algorithm
795 enum
796 {
797     GC_BGD    = 0,  //!< background
798     GC_FGD    = 1,  //!< foreground
799     GC_PR_BGD = 2,  //!< most probably background
800     GC_PR_FGD = 3   //!< most probably foreground
801 };
802
803 //! GrabCut algorithm flags
804 enum
805 {
806     GC_INIT_WITH_RECT  = 0,
807     GC_INIT_WITH_MASK  = 1,
808     GC_EVAL            = 2
809 };
810
811 //! segments the image using GrabCut algorithm
812 CV_EXPORTS_W void grabCut( InputArray img, InputOutputArray mask, Rect rect,
813                            InputOutputArray bgdModel, InputOutputArray fgdModel,
814                            int iterCount, int mode = GC_EVAL );
815
816 enum
817 {
818     DIST_LABEL_CCOMP = 0,
819     DIST_LABEL_PIXEL = 1
820 };
821
822 //! builds the discrete Voronoi diagram
823 CV_EXPORTS_AS(distanceTransformWithLabels) void distanceTransform( InputArray src, OutputArray dst,
824                                      OutputArray labels, int distanceType, int maskSize,
825                                      int labelType=DIST_LABEL_CCOMP );
826
827 //! computes the distance transform map
828 CV_EXPORTS_W void distanceTransform( InputArray src, OutputArray dst,
829                                      int distanceType, int maskSize );
830
831 enum { FLOODFILL_FIXED_RANGE = 1 << 16, FLOODFILL_MASK_ONLY = 1 << 17 };
832
833 //! fills the semi-uniform image region starting from the specified seed point
834 CV_EXPORTS int floodFill( InputOutputArray image,
835                           Point seedPoint, Scalar newVal, CV_OUT Rect* rect=0,
836                           Scalar loDiff=Scalar(), Scalar upDiff=Scalar(),
837                           int flags=4 );
838
839 //! fills the semi-uniform image region and/or the mask starting from the specified seed point
840 CV_EXPORTS_W int floodFill( InputOutputArray image, InputOutputArray mask,
841                             Point seedPoint, Scalar newVal, CV_OUT Rect* rect=0,
842                             Scalar loDiff=Scalar(), Scalar upDiff=Scalar(),
843                             int flags=4 );
844
845
846 enum
847 {
848     COLOR_BGR2BGRA    =0,
849     COLOR_RGB2RGBA    =COLOR_BGR2BGRA,
850
851     COLOR_BGRA2BGR    =1,
852     COLOR_RGBA2RGB    =COLOR_BGRA2BGR,
853
854     COLOR_BGR2RGBA    =2,
855     COLOR_RGB2BGRA    =COLOR_BGR2RGBA,
856
857     COLOR_RGBA2BGR    =3,
858     COLOR_BGRA2RGB    =COLOR_RGBA2BGR,
859
860     COLOR_BGR2RGB     =4,
861     COLOR_RGB2BGR     =COLOR_BGR2RGB,
862
863     COLOR_BGRA2RGBA   =5,
864     COLOR_RGBA2BGRA   =COLOR_BGRA2RGBA,
865
866     COLOR_BGR2GRAY    =6,
867     COLOR_RGB2GRAY    =7,
868     COLOR_GRAY2BGR    =8,
869     COLOR_GRAY2RGB    =COLOR_GRAY2BGR,
870     COLOR_GRAY2BGRA   =9,
871     COLOR_GRAY2RGBA   =COLOR_GRAY2BGRA,
872     COLOR_BGRA2GRAY   =10,
873     COLOR_RGBA2GRAY   =11,
874
875     COLOR_BGR2BGR565  =12,
876     COLOR_RGB2BGR565  =13,
877     COLOR_BGR5652BGR  =14,
878     COLOR_BGR5652RGB  =15,
879     COLOR_BGRA2BGR565 =16,
880     COLOR_RGBA2BGR565 =17,
881     COLOR_BGR5652BGRA =18,
882     COLOR_BGR5652RGBA =19,
883
884     COLOR_GRAY2BGR565 =20,
885     COLOR_BGR5652GRAY =21,
886
887     COLOR_BGR2BGR555  =22,
888     COLOR_RGB2BGR555  =23,
889     COLOR_BGR5552BGR  =24,
890     COLOR_BGR5552RGB  =25,
891     COLOR_BGRA2BGR555 =26,
892     COLOR_RGBA2BGR555 =27,
893     COLOR_BGR5552BGRA =28,
894     COLOR_BGR5552RGBA =29,
895
896     COLOR_GRAY2BGR555 =30,
897     COLOR_BGR5552GRAY =31,
898
899     COLOR_BGR2XYZ     =32,
900     COLOR_RGB2XYZ     =33,
901     COLOR_XYZ2BGR     =34,
902     COLOR_XYZ2RGB     =35,
903
904     COLOR_BGR2YCrCb   =36,
905     COLOR_RGB2YCrCb   =37,
906     COLOR_YCrCb2BGR   =38,
907     COLOR_YCrCb2RGB   =39,
908
909     COLOR_BGR2HSV     =40,
910     COLOR_RGB2HSV     =41,
911
912     COLOR_BGR2Lab     =44,
913     COLOR_RGB2Lab     =45,
914
915     COLOR_BayerBG2BGR =46,
916     COLOR_BayerGB2BGR =47,
917     COLOR_BayerRG2BGR =48,
918     COLOR_BayerGR2BGR =49,
919
920     COLOR_BayerBG2RGB =COLOR_BayerRG2BGR,
921     COLOR_BayerGB2RGB =COLOR_BayerGR2BGR,
922     COLOR_BayerRG2RGB =COLOR_BayerBG2BGR,
923     COLOR_BayerGR2RGB =COLOR_BayerGB2BGR,
924
925     COLOR_BGR2Luv     =50,
926     COLOR_RGB2Luv     =51,
927     COLOR_BGR2HLS     =52,
928     COLOR_RGB2HLS     =53,
929
930     COLOR_HSV2BGR     =54,
931     COLOR_HSV2RGB     =55,
932
933     COLOR_Lab2BGR     =56,
934     COLOR_Lab2RGB     =57,
935     COLOR_Luv2BGR     =58,
936     COLOR_Luv2RGB     =59,
937     COLOR_HLS2BGR     =60,
938     COLOR_HLS2RGB     =61,
939
940     COLOR_BayerBG2BGR_VNG =62,
941     COLOR_BayerGB2BGR_VNG =63,
942     COLOR_BayerRG2BGR_VNG =64,
943     COLOR_BayerGR2BGR_VNG =65,
944
945     COLOR_BayerBG2RGB_VNG =COLOR_BayerRG2BGR_VNG,
946     COLOR_BayerGB2RGB_VNG =COLOR_BayerGR2BGR_VNG,
947     COLOR_BayerRG2RGB_VNG =COLOR_BayerBG2BGR_VNG,
948     COLOR_BayerGR2RGB_VNG =COLOR_BayerGB2BGR_VNG,
949
950     COLOR_BGR2HSV_FULL = 66,
951     COLOR_RGB2HSV_FULL = 67,
952     COLOR_BGR2HLS_FULL = 68,
953     COLOR_RGB2HLS_FULL = 69,
954
955     COLOR_HSV2BGR_FULL = 70,
956     COLOR_HSV2RGB_FULL = 71,
957     COLOR_HLS2BGR_FULL = 72,
958     COLOR_HLS2RGB_FULL = 73,
959
960     COLOR_LBGR2Lab     = 74,
961     COLOR_LRGB2Lab     = 75,
962     COLOR_LBGR2Luv     = 76,
963     COLOR_LRGB2Luv     = 77,
964
965     COLOR_Lab2LBGR     = 78,
966     COLOR_Lab2LRGB     = 79,
967     COLOR_Luv2LBGR     = 80,
968     COLOR_Luv2LRGB     = 81,
969
970     COLOR_BGR2YUV      = 82,
971     COLOR_RGB2YUV      = 83,
972     COLOR_YUV2BGR      = 84,
973     COLOR_YUV2RGB      = 85,
974
975     COLOR_BayerBG2GRAY = 86,
976     COLOR_BayerGB2GRAY = 87,
977     COLOR_BayerRG2GRAY = 88,
978     COLOR_BayerGR2GRAY = 89,
979
980     //YUV 4:2:0 formats family
981     COLOR_YUV2RGB_NV12 = 90,
982     COLOR_YUV2BGR_NV12 = 91,
983     COLOR_YUV2RGB_NV21 = 92,
984     COLOR_YUV2BGR_NV21 = 93,
985     COLOR_YUV420sp2RGB = COLOR_YUV2RGB_NV21,
986     COLOR_YUV420sp2BGR = COLOR_YUV2BGR_NV21,
987
988     COLOR_YUV2RGBA_NV12 = 94,
989     COLOR_YUV2BGRA_NV12 = 95,
990     COLOR_YUV2RGBA_NV21 = 96,
991     COLOR_YUV2BGRA_NV21 = 97,
992     COLOR_YUV420sp2RGBA = COLOR_YUV2RGBA_NV21,
993     COLOR_YUV420sp2BGRA = COLOR_YUV2BGRA_NV21,
994
995     COLOR_YUV2RGB_YV12 = 98,
996     COLOR_YUV2BGR_YV12 = 99,
997     COLOR_YUV2RGB_IYUV = 100,
998     COLOR_YUV2BGR_IYUV = 101,
999     COLOR_YUV2RGB_I420 = COLOR_YUV2RGB_IYUV,
1000     COLOR_YUV2BGR_I420 = COLOR_YUV2BGR_IYUV,
1001     COLOR_YUV420p2RGB = COLOR_YUV2RGB_YV12,
1002     COLOR_YUV420p2BGR = COLOR_YUV2BGR_YV12,
1003
1004     COLOR_YUV2RGBA_YV12 = 102,
1005     COLOR_YUV2BGRA_YV12 = 103,
1006     COLOR_YUV2RGBA_IYUV = 104,
1007     COLOR_YUV2BGRA_IYUV = 105,
1008     COLOR_YUV2RGBA_I420 = COLOR_YUV2RGBA_IYUV,
1009     COLOR_YUV2BGRA_I420 = COLOR_YUV2BGRA_IYUV,
1010     COLOR_YUV420p2RGBA = COLOR_YUV2RGBA_YV12,
1011     COLOR_YUV420p2BGRA = COLOR_YUV2BGRA_YV12,
1012
1013     COLOR_YUV2GRAY_420 = 106,
1014     COLOR_YUV2GRAY_NV21 = COLOR_YUV2GRAY_420,
1015     COLOR_YUV2GRAY_NV12 = COLOR_YUV2GRAY_420,
1016     COLOR_YUV2GRAY_YV12 = COLOR_YUV2GRAY_420,
1017     COLOR_YUV2GRAY_IYUV = COLOR_YUV2GRAY_420,
1018     COLOR_YUV2GRAY_I420 = COLOR_YUV2GRAY_420,
1019     COLOR_YUV420sp2GRAY = COLOR_YUV2GRAY_420,
1020     COLOR_YUV420p2GRAY = COLOR_YUV2GRAY_420,
1021
1022     //YUV 4:2:2 formats family
1023     COLOR_YUV2RGB_UYVY = 107,
1024     COLOR_YUV2BGR_UYVY = 108,
1025     //COLOR_YUV2RGB_VYUY = 109,
1026     //COLOR_YUV2BGR_VYUY = 110,
1027     COLOR_YUV2RGB_Y422 = COLOR_YUV2RGB_UYVY,
1028     COLOR_YUV2BGR_Y422 = COLOR_YUV2BGR_UYVY,
1029     COLOR_YUV2RGB_UYNV = COLOR_YUV2RGB_UYVY,
1030     COLOR_YUV2BGR_UYNV = COLOR_YUV2BGR_UYVY,
1031
1032     COLOR_YUV2RGBA_UYVY = 111,
1033     COLOR_YUV2BGRA_UYVY = 112,
1034     //COLOR_YUV2RGBA_VYUY = 113,
1035     //COLOR_YUV2BGRA_VYUY = 114,
1036     COLOR_YUV2RGBA_Y422 = COLOR_YUV2RGBA_UYVY,
1037     COLOR_YUV2BGRA_Y422 = COLOR_YUV2BGRA_UYVY,
1038     COLOR_YUV2RGBA_UYNV = COLOR_YUV2RGBA_UYVY,
1039     COLOR_YUV2BGRA_UYNV = COLOR_YUV2BGRA_UYVY,
1040
1041     COLOR_YUV2RGB_YUY2 = 115,
1042     COLOR_YUV2BGR_YUY2 = 116,
1043     COLOR_YUV2RGB_YVYU = 117,
1044     COLOR_YUV2BGR_YVYU = 118,
1045     COLOR_YUV2RGB_YUYV = COLOR_YUV2RGB_YUY2,
1046     COLOR_YUV2BGR_YUYV = COLOR_YUV2BGR_YUY2,
1047     COLOR_YUV2RGB_YUNV = COLOR_YUV2RGB_YUY2,
1048     COLOR_YUV2BGR_YUNV = COLOR_YUV2BGR_YUY2,
1049
1050     COLOR_YUV2RGBA_YUY2 = 119,
1051     COLOR_YUV2BGRA_YUY2 = 120,
1052     COLOR_YUV2RGBA_YVYU = 121,
1053     COLOR_YUV2BGRA_YVYU = 122,
1054     COLOR_YUV2RGBA_YUYV = COLOR_YUV2RGBA_YUY2,
1055     COLOR_YUV2BGRA_YUYV = COLOR_YUV2BGRA_YUY2,
1056     COLOR_YUV2RGBA_YUNV = COLOR_YUV2RGBA_YUY2,
1057     COLOR_YUV2BGRA_YUNV = COLOR_YUV2BGRA_YUY2,
1058
1059     COLOR_YUV2GRAY_UYVY = 123,
1060     COLOR_YUV2GRAY_YUY2 = 124,
1061     //COLOR_YUV2GRAY_VYUY = COLOR_YUV2GRAY_UYVY,
1062     COLOR_YUV2GRAY_Y422 = COLOR_YUV2GRAY_UYVY,
1063     COLOR_YUV2GRAY_UYNV = COLOR_YUV2GRAY_UYVY,
1064     COLOR_YUV2GRAY_YVYU = COLOR_YUV2GRAY_YUY2,
1065     COLOR_YUV2GRAY_YUYV = COLOR_YUV2GRAY_YUY2,
1066     COLOR_YUV2GRAY_YUNV = COLOR_YUV2GRAY_YUY2,
1067
1068     // alpha premultiplication
1069     COLOR_RGBA2mRGBA = 125,
1070     COLOR_mRGBA2RGBA = 126,
1071
1072     COLOR_RGB2YUV_I420 = 127,
1073     COLOR_BGR2YUV_I420 = 128,
1074     COLOR_RGB2YUV_IYUV = COLOR_RGB2YUV_I420,
1075     COLOR_BGR2YUV_IYUV = COLOR_BGR2YUV_I420,
1076
1077     COLOR_RGBA2YUV_I420 = 129,
1078     COLOR_BGRA2YUV_I420 = 130,
1079     COLOR_RGBA2YUV_IYUV = COLOR_RGBA2YUV_I420,
1080     COLOR_BGRA2YUV_IYUV = COLOR_BGRA2YUV_I420,
1081     COLOR_RGB2YUV_YV12  = 131,
1082     COLOR_BGR2YUV_YV12  = 132,
1083     COLOR_RGBA2YUV_YV12 = 133,
1084     COLOR_BGRA2YUV_YV12 = 134,
1085
1086     COLOR_COLORCVT_MAX  = 135
1087 };
1088
1089
1090 //! converts image from one color space to another
1091 CV_EXPORTS_W void cvtColor( InputArray src, OutputArray dst, int code, int dstCn=0 );
1092
1093 //! raster image moments
1094 class CV_EXPORTS_W_MAP Moments
1095 {
1096 public:
1097     //! the default constructor
1098     Moments();
1099     //! the full constructor
1100     Moments(double m00, double m10, double m01, double m20, double m11,
1101             double m02, double m30, double m21, double m12, double m03 );
1102     //! the conversion from CvMoments
1103     Moments( const CvMoments& moments );
1104     //! the conversion to CvMoments
1105     operator CvMoments() const;
1106
1107     //! spatial moments
1108     CV_PROP_RW double  m00, m10, m01, m20, m11, m02, m30, m21, m12, m03;
1109     //! central moments
1110     CV_PROP_RW double  mu20, mu11, mu02, mu30, mu21, mu12, mu03;
1111     //! central normalized moments
1112     CV_PROP_RW double  nu20, nu11, nu02, nu30, nu21, nu12, nu03;
1113 };
1114
1115 //! computes moments of the rasterized shape or a vector of points
1116 CV_EXPORTS_W Moments moments( InputArray array, bool binaryImage=false );
1117
1118 //! computes 7 Hu invariants from the moments
1119 CV_EXPORTS void HuMoments( const Moments& moments, double hu[7] );
1120 CV_EXPORTS_W void HuMoments( const Moments& m, CV_OUT OutputArray hu );
1121
1122 //! type of the template matching operation
1123 enum { TM_SQDIFF=0, TM_SQDIFF_NORMED=1, TM_CCORR=2, TM_CCORR_NORMED=3, TM_CCOEFF=4, TM_CCOEFF_NORMED=5 };
1124
1125 //! computes the proximity map for the raster template and the image where the template is searched for
1126 CV_EXPORTS_W void matchTemplate( InputArray image, InputArray templ,
1127                                  OutputArray result, int method );
1128
1129 //! mode of the contour retrieval algorithm
1130 enum
1131 {
1132     RETR_EXTERNAL=CV_RETR_EXTERNAL, //!< retrieve only the most external (top-level) contours
1133     RETR_LIST=CV_RETR_LIST, //!< retrieve all the contours without any hierarchical information
1134     RETR_CCOMP=CV_RETR_CCOMP, //!< retrieve the connected components (that can possibly be nested)
1135     RETR_TREE=CV_RETR_TREE, //!< retrieve all the contours and the whole hierarchy
1136     RETR_FLOODFILL=CV_RETR_FLOODFILL
1137 };
1138
1139 //! the contour approximation algorithm
1140 enum
1141 {
1142     CHAIN_APPROX_NONE=CV_CHAIN_APPROX_NONE,
1143     CHAIN_APPROX_SIMPLE=CV_CHAIN_APPROX_SIMPLE,
1144     CHAIN_APPROX_TC89_L1=CV_CHAIN_APPROX_TC89_L1,
1145     CHAIN_APPROX_TC89_KCOS=CV_CHAIN_APPROX_TC89_KCOS
1146 };
1147
1148 //! retrieves contours and the hierarchical information from black-n-white image.
1149 CV_EXPORTS_W void findContours( InputOutputArray image, OutputArrayOfArrays contours,
1150                               OutputArray hierarchy, int mode,
1151                               int method, Point offset=Point());
1152
1153 //! retrieves contours from black-n-white image.
1154 CV_EXPORTS void findContours( InputOutputArray image, OutputArrayOfArrays contours,
1155                               int mode, int method, Point offset=Point());
1156
1157 //! draws contours in the image
1158 CV_EXPORTS_W void drawContours( InputOutputArray image, InputArrayOfArrays contours,
1159                               int contourIdx, const Scalar& color,
1160                               int thickness=1, int lineType=8,
1161                               InputArray hierarchy=noArray(),
1162                               int maxLevel=INT_MAX, Point offset=Point() );
1163
1164 //! approximates contour or a curve using Douglas-Peucker algorithm
1165 CV_EXPORTS_W void approxPolyDP( InputArray curve,
1166                                 OutputArray approxCurve,
1167                                 double epsilon, bool closed );
1168
1169 //! computes the contour perimeter (closed=true) or a curve length
1170 CV_EXPORTS_W double arcLength( InputArray curve, bool closed );
1171 //! computes the bounding rectangle for a contour
1172 CV_EXPORTS_W Rect boundingRect( InputArray points );
1173 //! computes the contour area
1174 CV_EXPORTS_W double contourArea( InputArray contour, bool oriented=false );
1175 //! computes the minimal rotated rectangle for a set of points
1176 CV_EXPORTS_W RotatedRect minAreaRect( InputArray points );
1177 //! computes the minimal enclosing circle for a set of points
1178 CV_EXPORTS_W void minEnclosingCircle( InputArray points,
1179                                       CV_OUT Point2f& center, CV_OUT float& radius );
1180 //! matches two contours using one of the available algorithms
1181 CV_EXPORTS_W double matchShapes( InputArray contour1, InputArray contour2,
1182                                  int method, double parameter );
1183 //! computes convex hull for a set of 2D points.
1184 CV_EXPORTS_W void convexHull( InputArray points, OutputArray hull,
1185                               bool clockwise=false, bool returnPoints=true );
1186 //! computes the contour convexity defects
1187 CV_EXPORTS_W void convexityDefects( InputArray contour, InputArray convexhull, OutputArray convexityDefects );
1188
1189 //! returns true if the contour is convex. Does not support contours with self-intersection
1190 CV_EXPORTS_W bool isContourConvex( InputArray contour );
1191
1192 //! finds intersection of two convex polygons
1193 CV_EXPORTS_W float intersectConvexConvex( InputArray _p1, InputArray _p2,
1194                                           OutputArray _p12, bool handleNested=true );
1195
1196 //! fits ellipse to the set of 2D points
1197 CV_EXPORTS_W RotatedRect fitEllipse( InputArray points );
1198
1199 //! fits line to the set of 2D points using M-estimator algorithm
1200 CV_EXPORTS_W void fitLine( InputArray points, OutputArray line, int distType,
1201                            double param, double reps, double aeps );
1202 //! checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary
1203 CV_EXPORTS_W double pointPolygonTest( InputArray contour, Point2f pt, bool measureDist );
1204
1205
1206 class CV_EXPORTS_W Subdiv2D
1207 {
1208 public:
1209     enum
1210     {
1211         PTLOC_ERROR = -2,
1212         PTLOC_OUTSIDE_RECT = -1,
1213         PTLOC_INSIDE = 0,
1214         PTLOC_VERTEX = 1,
1215         PTLOC_ON_EDGE = 2
1216     };
1217
1218     enum
1219     {
1220         NEXT_AROUND_ORG   = 0x00,
1221         NEXT_AROUND_DST   = 0x22,
1222         PREV_AROUND_ORG   = 0x11,
1223         PREV_AROUND_DST   = 0x33,
1224         NEXT_AROUND_LEFT  = 0x13,
1225         NEXT_AROUND_RIGHT = 0x31,
1226         PREV_AROUND_LEFT  = 0x20,
1227         PREV_AROUND_RIGHT = 0x02
1228     };
1229
1230     CV_WRAP Subdiv2D();
1231     CV_WRAP Subdiv2D(Rect rect);
1232     CV_WRAP void initDelaunay(Rect rect);
1233
1234     CV_WRAP int insert(Point2f pt);
1235     CV_WRAP void insert(const vector<Point2f>& ptvec);
1236     CV_WRAP int locate(Point2f pt, CV_OUT int& edge, CV_OUT int& vertex);
1237
1238     CV_WRAP int findNearest(Point2f pt, CV_OUT Point2f* nearestPt=0);
1239     CV_WRAP void getEdgeList(CV_OUT vector<Vec4f>& edgeList) const;
1240     CV_WRAP void getTriangleList(CV_OUT vector<Vec6f>& triangleList) const;
1241     CV_WRAP void getVoronoiFacetList(const vector<int>& idx, CV_OUT vector<vector<Point2f> >& facetList,
1242                                      CV_OUT vector<Point2f>& facetCenters);
1243
1244     CV_WRAP Point2f getVertex(int vertex, CV_OUT int* firstEdge=0) const;
1245
1246     CV_WRAP int getEdge( int edge, int nextEdgeType ) const;
1247     CV_WRAP int nextEdge(int edge) const;
1248     CV_WRAP int rotateEdge(int edge, int rotate) const;
1249     CV_WRAP int symEdge(int edge) const;
1250     CV_WRAP int edgeOrg(int edge, CV_OUT Point2f* orgpt=0) const;
1251     CV_WRAP int edgeDst(int edge, CV_OUT Point2f* dstpt=0) const;
1252
1253 protected:
1254     int newEdge();
1255     void deleteEdge(int edge);
1256     int newPoint(Point2f pt, bool isvirtual, int firstEdge=0);
1257     void deletePoint(int vtx);
1258     void setEdgePoints( int edge, int orgPt, int dstPt );
1259     void splice( int edgeA, int edgeB );
1260     int connectEdges( int edgeA, int edgeB );
1261     void swapEdges( int edge );
1262     int isRightOf(Point2f pt, int edge) const;
1263     void calcVoronoi();
1264     void clearVoronoi();
1265     void checkSubdiv() const;
1266
1267     struct CV_EXPORTS Vertex
1268     {
1269         Vertex();
1270         Vertex(Point2f pt, bool _isvirtual, int _firstEdge=0);
1271         bool isvirtual() const;
1272         bool isfree() const;
1273         int firstEdge;
1274         int type;
1275         Point2f pt;
1276     };
1277     struct CV_EXPORTS QuadEdge
1278     {
1279         QuadEdge();
1280         QuadEdge(int edgeidx);
1281         bool isfree() const;
1282         int next[4];
1283         int pt[4];
1284     };
1285
1286     vector<Vertex> vtx;
1287     vector<QuadEdge> qedges;
1288     int freeQEdge;
1289     int freePoint;
1290     bool validGeometry;
1291
1292     int recentEdge;
1293     Point2f topLeft;
1294     Point2f bottomRight;
1295 };
1296
1297 }
1298
1299 #endif /* __cplusplus */
1300
1301 #endif
1302
1303 /* End of file. */