imgproc.hpp
Go to the documentation of this file.
1 
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"
52 
53 #ifdef __cplusplus
54 
58 namespace cv
59 {
60 
62 enum { BORDER_REPLICATE=IPL_BORDER_REPLICATE, BORDER_CONSTANT=IPL_BORDER_CONSTANT,
63  BORDER_REFLECT=IPL_BORDER_REFLECT, BORDER_WRAP=IPL_BORDER_WRAP,
65  BORDER_TRANSPARENT=IPL_BORDER_TRANSPARENT,
67 
69 CV_EXPORTS_W int borderInterpolate( int p, int len, int borderType );
70 
80 class CV_EXPORTS BaseRowFilter
81 {
82 public:
84  BaseRowFilter();
86  virtual ~BaseRowFilter();
88  virtual void operator()(const uchar* src, uchar* dst,
89  int width, int cn) = 0;
90  int ksize, anchor;
91 };
92 
93 
107 class CV_EXPORTS BaseColumnFilter
108 {
109 public:
113  virtual ~BaseColumnFilter();
115  virtual void operator()(const uchar** src, uchar* dst, int dststep,
116  int dstcount, int width) = 0;
118  virtual void reset();
119  int ksize, anchor;
120 };
121 
133 class CV_EXPORTS BaseFilter
134 {
135 public:
137  BaseFilter();
139  virtual ~BaseFilter();
141  virtual void operator()(const uchar** src, uchar* dst, int dststep,
142  int dstcount, int width, int cn) = 0;
144  virtual void reset();
147 };
148 
222 class CV_EXPORTS FilterEngine
223 {
224 public:
226  FilterEngine();
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());
236  virtual ~FilterEngine();
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());
245  virtual int start(Size wholeSize, Rect roi, int maxBufRows=-1);
247  virtual int start(const Mat& src, const Rect& srcRoi=Rect(0,0,-1,-1),
248  bool isolated=false, int maxBufRows=-1);
250  virtual int proceed(const uchar* src, int srcStep, int srcCount,
251  uchar* dst, int dstStep);
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);
258  bool isSeparable() const { return (const BaseFilter*)filter2D == 0; }
260  int remainingInputRows() const;
261  int remainingOutputRows() const;
262 
263  int srcType, dstType, bufType;
266  int maxWidth;
269  int dx1, dx2;
270  int rowBorderType, columnBorderType;
271  vector<int> borderTab;
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 
283 };
284 
288 
290 CV_EXPORTS int getKernelType(InputArray kernel, Point anchor);
291 
293 CV_EXPORTS Ptr<BaseRowFilter> getLinearRowFilter(int srcType, int bufType,
294  InputArray kernel, int anchor,
295  int symmetryType);
296 
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 
304 CV_EXPORTS Ptr<BaseFilter> getLinearFilter(int srcType, int dstType,
306  Point anchor=Point(-1,-1),
307  double delta=0, int bits=0);
308 
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 
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 
324 CV_EXPORTS_W Mat getGaussianKernel( int ksize, double sigma, int ktype=CV_64F );
325 
327 CV_EXPORTS Ptr<FilterEngine> createGaussianFilter( int type, Size ksize,
328  double sigma1, double sigma2=0,
329  int borderType=BORDER_DEFAULT);
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 );
335 CV_EXPORTS Ptr<FilterEngine> createDerivFilter( int srcType, int dstType,
336  int dx, int dy, int ksize,
337  int borderType=BORDER_DEFAULT );
339 CV_EXPORTS Ptr<BaseRowFilter> getRowSumFilter(int srcType, int sumType,
340  int ksize, int anchor=-1);
342 CV_EXPORTS Ptr<BaseColumnFilter> getColumnSumFilter( int sumType, int dstType,
343  int ksize, int anchor=-1,
344  double scale=1);
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 
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 
360 
362 CV_EXPORTS Ptr<BaseRowFilter> getMorphologyRowFilter(int op, int type, int ksize, int anchor=-1);
364 CV_EXPORTS Ptr<BaseColumnFilter> getMorphologyColumnFilter(int op, int type, int ksize, int anchor=-1);
366 CV_EXPORTS Ptr<BaseFilter> getMorphologyFilter(int op, int type, InputArray kernel,
367  Point anchor=Point(-1,-1));
368 
370 static inline Scalar morphologyDefaultBorderValue() { return Scalar::all(DBL_MAX); }
371 
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 
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 
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 
391 CV_EXPORTS_W void medianBlur( InputArray src, OutputArray dst, int ksize );
393 CV_EXPORTS_W void GaussianBlur( InputArray src,
394  OutputArray dst, Size ksize,
395  double sigmaX, double sigmaY=0,
396  int borderType=BORDER_DEFAULT );
398 CV_EXPORTS_W void bilateralFilter( InputArray src, OutputArray dst, int d,
399  double sigmaColor, double sigmaSpace,
400  int borderType=BORDER_DEFAULT );
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 );
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 );
411 CV_EXPORTS_W void blur( InputArray src, OutputArray dst,
412  Size ksize, Point anchor=Point(-1,-1),
413  int borderType=BORDER_DEFAULT );
414 
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 
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 
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 
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 
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 
443 CV_EXPORTS_W void Canny( InputArray image, OutputArray edges,
444  double threshold1, double threshold2,
445  int apertureSize=3, bool L2gradient=false );
446 
448 CV_EXPORTS_W void cornerMinEigenVal( InputArray src, OutputArray dst,
449  int blockSize, int ksize=3,
450  int borderType=BORDER_DEFAULT );
451 
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 
461 CV_EXPORTS_W void cornerEigenValsAndVecs( InputArray src, OutputArray dst,
462  int blockSize, int ksize,
463  int borderType=BORDER_DEFAULT );
464 
466 CV_EXPORTS_W void preCornerDetect( InputArray src, OutputArray dst, int ksize,
467  int borderType=BORDER_DEFAULT );
468 
471  Size winSize, Size zeroZone,
472  TermCriteria criteria );
473 
476  int maxCorners, double qualityLevel, double minDistance,
477  InputArray mask=noArray(), int blockSize=3,
478  bool useHarrisDetector=false, double k=0.04 );
479 
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 
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 
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 {
501 };
502 
506 class CV_EXPORTS GeneralizedHough : public Algorithm
507 {
508 public:
509  static Ptr<GeneralizedHough> create(int method);
510 
511  virtual ~GeneralizedHough();
512 
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 
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 
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 
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 
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 
552 enum
553 {
561 };
562 
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 
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 
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 {
587 };
588 
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 
596 CV_EXPORTS_W void convertMaps( InputArray map1, InputArray map2,
597  OutputArray dstmap1, OutputArray dstmap2,
598  int dstmap1type, bool nninterpolation=false );
599 
601 CV_EXPORTS_W Mat getRotationMatrix2D( Point2f center, double angle, double scale );
603 CV_EXPORTS Mat getPerspectiveTransform( const Point2f src[], const Point2f dst[] );
605 CV_EXPORTS Mat getAffineTransform( const Point2f src[], const Point2f dst[] );
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 
613 CV_EXPORTS_W void getRectSubPix( InputArray image, Size patchSize,
614  Point2f center, OutputArray patch, int patchType=-1 );
615 
617 CV_EXPORTS_W void integral( InputArray src, OutputArray sum, int sdepth=-1 );
618 
623 CV_EXPORTS_AS(integral3) void integral( InputArray src, OutputArray sum,
625  int sdepth=-1 );
626 
628 CV_EXPORTS_W void accumulate( InputArray src, InputOutputArray dst,
629  InputArray mask=noArray() );
631 CV_EXPORTS_W void accumulateSquare( InputArray src, InputOutputArray dst,
632  InputArray mask=noArray() );
634 CV_EXPORTS_W void accumulateProduct( InputArray src1, InputArray src2,
635  InputOutputArray dst, InputArray mask=noArray() );
637 CV_EXPORTS_W void accumulateWeighted( InputArray src, InputOutputArray dst,
638  double alpha, InputArray mask=noArray() );
639 
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 
654 
656 CV_EXPORTS_W double threshold( InputArray src, OutputArray dst,
657  double thresh, double maxval, int type );
658 
661 
663 CV_EXPORTS_W void adaptiveThreshold( InputArray src, OutputArray dst,
664  double maxValue, int adaptiveMethod,
665  int thresholdType, int blockSize, double C );
666 
668 CV_EXPORTS_W void pyrDown( InputArray src, OutputArray dst,
669  const Size& dstsize=Size(), int borderType=BORDER_DEFAULT );
671 CV_EXPORTS_W void pyrUp( InputArray src, OutputArray dst,
672  const Size& dstsize=Size(), int borderType=BORDER_DEFAULT );
673 
675 CV_EXPORTS void buildPyramid( InputArray src, OutputArrayOfArrays dst,
676  int maxlevel, int borderType=BORDER_DEFAULT );
677 
679 CV_EXPORTS_W void undistort( InputArray src, OutputArray dst,
680  InputArray cameraMatrix,
681  InputArray distCoeffs,
682  InputArray newCameraMatrix=noArray() );
683 
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 {
693 };
694 
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 
702 CV_EXPORTS_W Mat getDefaultNewCameraMatrix( InputArray cameraMatrix, Size imgsize=Size(),
703  bool centerPrincipalPoint=false );
704 
706 CV_EXPORTS_W void undistortPoints( InputArray src, OutputArray dst,
707  InputArray cameraMatrix, InputArray distCoeffs,
709 
710 template<> CV_EXPORTS void Ptr<CvHistogram>::delete_obj();
711 
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 
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,
728  const vector<int>& histSize,
729  const vector<float>& ranges,
730  bool accumulate=false );
731 
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 
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,
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 
758 CV_EXPORTS_W double compareHist( InputArray H1, InputArray H2, int method );
759 
761 CV_EXPORTS double compareHist( const SparseMat& H1, const SparseMat& H2, int method );
762 
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 
786 CV_EXPORTS_W void watershed( InputArray image, InputOutputArray markers );
787 
789 CV_EXPORTS_W void pyrMeanShiftFiltering( InputArray src, OutputArray dst,
790  double sp, double sr, int maxLevel=1,
793 
795 enum
796 {
797  GC_BGD = 0,
798  GC_FGD = 1,
799  GC_PR_BGD = 2,
801 };
802 
804 enum
805 {
809 };
810 
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 {
820 };
821 
823 CV_EXPORTS_AS(distanceTransformWithLabels) void distanceTransform( InputArray src, OutputArray dst,
826 
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 
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 
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 {
850 
853 
856 
859 
862 
865 
874 
883 
886 
895 
898 
903 
908 
911 
914 
919 
924 
929 
932 
939 
944 
949 
954 
959 
964 
969 
974 
979 
980  //YUV 4:2:0 formats family
987 
994 
1003 
1012 
1021 
1022  //YUV 4:2:2 formats family
1025  //COLOR_YUV2RGB_VYUY = 109,
1026  //COLOR_YUV2BGR_VYUY = 110,
1031 
1034  //COLOR_YUV2RGBA_VYUY = 113,
1035  //COLOR_YUV2BGRA_VYUY = 114,
1040 
1049 
1058 
1061  //COLOR_YUV2GRAY_VYUY = COLOR_YUV2GRAY_UYVY,
1067 
1068  // alpha premultiplication
1071 
1076 
1085 
1087 };
1088 
1089 
1091 CV_EXPORTS_W void cvtColor( InputArray src, OutputArray dst, int code, int dstCn=0 );
1092 
1094 class CV_EXPORTS_W_MAP Moments
1095 {
1096 public:
1098  Moments();
1100  Moments(double m00, double m10, double m01, double m20, double m11,
1101  double m02, double m30, double m21, double m12, double m03 );
1103  Moments( const CvMoments& moments );
1105  operator CvMoments() const;
1106 
1108  CV_PROP_RW double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03;
1110  CV_PROP_RW double mu20, mu11, mu02, mu30, mu21, mu12, mu03;
1112  CV_PROP_RW double nu20, nu11, nu02, nu30, nu21, nu12, nu03;
1113 };
1114 
1116 CV_EXPORTS_W Moments moments( InputArray array, bool binaryImage=false );
1117 
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 
1124 
1126 CV_EXPORTS_W void matchTemplate( InputArray image, InputArray templ,
1127  OutputArray result, int method );
1128 
1130 enum
1131 {
1137 };
1138 
1140 enum
1141 {
1146 };
1147 
1149 CV_EXPORTS_W void findContours( InputOutputArray image, OutputArrayOfArrays contours,
1150  OutputArray hierarchy, int mode,
1151  int method, Point offset=Point());
1152 
1154 CV_EXPORTS void findContours( InputOutputArray image, OutputArrayOfArrays contours,
1155  int mode, int method, Point offset=Point());
1156 
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 
1165 CV_EXPORTS_W void approxPolyDP( InputArray curve,
1166  OutputArray approxCurve,
1167  double epsilon, bool closed );
1168 
1170 CV_EXPORTS_W double arcLength( InputArray curve, bool closed );
1172 CV_EXPORTS_W Rect boundingRect( InputArray points );
1174 CV_EXPORTS_W double contourArea( InputArray contour, bool oriented=false );
1176 CV_EXPORTS_W RotatedRect minAreaRect( InputArray points );
1178 CV_EXPORTS_W void minEnclosingCircle( InputArray points,
1179  CV_OUT Point2f& center, CV_OUT float& radius );
1181 CV_EXPORTS_W double matchShapes( InputArray contour1, InputArray contour2,
1182  int method, double parameter );
1184 CV_EXPORTS_W void convexHull( InputArray points, OutputArray hull,
1185  bool clockwise=false, bool returnPoints=true );
1188 
1190 CV_EXPORTS_W bool isContourConvex( InputArray contour );
1191 
1193 CV_EXPORTS_W float intersectConvexConvex( InputArray _p1, InputArray _p2,
1194  OutputArray _p12, bool handleNested=true );
1195 
1197 CV_EXPORTS_W RotatedRect fitEllipse( InputArray points );
1198 
1200 CV_EXPORTS_W void fitLine( InputArray points, OutputArray line, int distType,
1201  double param, double reps, double aeps );
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;
1274  int type;
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;
1291 
1295 };
1296 
1297 }
1298 
1299 #endif /* __cplusplus */
1300 
1301 #endif
1302 
1303 /* End of file. */
CV_EXPORTS_W void HoughCircles(InputArray image, OutputArray circles, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0)
finds circles in the grayscale image using 2+1 gradient Hough transform
int dims
Definition: core_c.h:218
Definition: imgproc.hpp:65
CvArr CvPoint2D32f double M
Definition: imgproc_c.h:186
Point2f bottomRight
Definition: imgproc.hpp:1294
Definition: imgproc.hpp:889
Point anchor
Definition: imgproc.hpp:265
CV_EXPORTS_W double contourArea(InputArray contour, bool oriented=false)
computes the contour area
bool isSeparable() const
returns true if the filter is separable
Definition: imgproc.hpp:258
Definition: imgproc.hpp:878
Definition: imgproc.hpp:926
Point2i Point
Definition: core.hpp:893
const CvMat const CvMat CvSize CvMat CvMat * H2
Definition: calib3d.hpp:297
Definition: imgproc.hpp:286
Definition: imgproc.hpp:1078
OutputArray OutputArray int sdepth
Definition: imgproc.hpp:621
Definition: imgproc.hpp:879
area-based (or super) interpolation
Definition: imgproc.hpp:557
Definition: imgproc.hpp:1032
CvPoint2D32f pt[4]
Definition: imgproc_c.h:410
CV_EXPORTS_W void cornerHarris(InputArray src, OutputArray dst, int blockSize, int ksize, double k, int borderType=BORDER_DEFAULT)
computes Harris cornerness criteria at each image pixel
CV_EXPORTS_W void minEnclosingCircle(InputArray points, CV_OUT Point2f &center, CV_OUT float &radius)
computes the minimal enclosing circle for a set of points
Definition: imgproc.hpp:937
CvArr * edges
Definition: imgproc_c.h:555
int recentEdge
Definition: imgproc.hpp:1292
Definition: imgproc.hpp:1145
CV_EXPORTS_W float initWideAngleProjMap(InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2, int projType=PROJ_SPHERICAL_EQRECT, double alpha=0)
initializes maps for cv::remap() for wide-angle
const _OutputArray & OutputArray
Definition: core.hpp:1449
GLenum mode
Definition: imgproc.hpp:963
int int int int * dy
Definition: imgproc.hpp:852
Definition: imgproc.hpp:1056
The Base Class for Column-wise Filters.
Definition: imgproc.hpp:107
Definition: imgproc.hpp:1024
IplImage CvRect * roi
Definition: legacy.hpp:234
GLdouble GLdouble GLdouble GLdouble top
Termination criteria in iterative algorithms.
Definition: core.hpp:2091
Definition: imgproc.hpp:585
Definition: imgproc.hpp:287
Definition: imgproc.hpp:854
bicubic interpolation
Definition: imgproc.hpp:556
retrieve all the contours and the whole hierarchy
Definition: imgproc.hpp:1135
Definition: imgproc.hpp:1123
Definition: imgproc.hpp:379
int borderElemSize
Definition: imgproc.hpp:272
CV_EXPORTS int getKernelType(InputArray kernel, Point anchor)
returns type (one of KERNEL_*) of 1D or 2D kernel specified by its coefficients.
Definition: imgproc.hpp:922
Definition: imgproc.hpp:933
CV_EXPORTS_W void undistortPoints(InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R=noArray(), InputArray P=noArray())
returns points' coordinates after lens distortion correction
CV_EXPORTS_W void adaptiveThreshold(InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)
applies variable (adaptive) threshold to the image
CV_EXPORTS_W Mat getRotationMatrix2D(Point2f center, double angle, double scale)
returns 2x3 affine transformation matrix for the planar rotation.
Definition: imgproc.hpp:975
Definition: imgproc.hpp:905
Definition: imgproc.hpp:894
vector< uchar > srcRow
Definition: imgproc.hpp:274
CV_EXPORTS_W void cornerSubPix(InputArray image, InputOutputArray corners, Size winSize, Size zeroZone, TermCriteria criteria)
adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria ...
Definition: imgproc.hpp:1017
Definition: imgproc.hpp:1064
Definition: imgproc.hpp:1019
CV_EXPORTS_W void convertMaps(InputArray map1, InputArray map2, OutputArray dstmap1, OutputArray dstmap2, int dstmap1type, bool nninterpolation=false)
converts maps for remap from floating-point to fixed-point format or backwards
Definition: imgproc.hpp:1014
Definition: imgproc.hpp:915
CV_EXPORTS_W void cvtColor(InputArray src, OutputArray dst, int code, int dstCn=0)
converts image from one color space to another
Definition: imgproc.hpp:807
Lanczos interpolation over 8x8 neighborhood.
Definition: imgproc.hpp:558
Definition: types_c.h:415
CV_EXPORTS_W void invertAffineTransform(InputArray M, OutputArray iM)
computes 2x3 affine transformation matrix that is inverse to the specified 2x3 affine transformation...
Definition: imgproc.hpp:1054
Definition: imgproc.hpp:1079
Definition: imgproc.hpp:1033
Size ksize
Definition: imgproc.hpp:145
Definition: imgproc.hpp:978
Ptr< BaseFilter > filter2D
Definition: imgproc.hpp:280
Definition: imgproc.hpp:650
Point anchor
Definition: imgproc.hpp:146
Definition: imgproc.hpp:692
Definition: types_c.h:338
void delete_obj()
deletes the object. Override if needed
Definition: operations.hpp:2612
Definition: imgproc.hpp:1086
Definition: imgproc.hpp:1065
Definition: imgproc.hpp:941
const CvArr * convexhull
Definition: imgproc_c.h:400
Size2i Size
Definition: core.hpp:896
Definition: imgproc.hpp:992
Definition: types_c.h:405
Definition: imgproc.hpp:808
void int double dp
Definition: imgproc_c.h:608
CV_EXPORTS_W void cornerMinEigenVal(InputArray src, OutputArray dst, int blockSize, int ksize=3, int borderType=BORDER_DEFAULT)
computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness crit...
Definition: imgproc.hpp:1043
CV_EXPORTS_W void accumulate(InputArray src, InputOutputArray dst, InputArray mask=noArray())
adds image to the accumulator (dst += src). Unlike cv::add, dst and src can have different types...
Definition: imgproc.hpp:584
Definition: imgproc.hpp:1057
Definition: imgproc.hpp:1123
Definition: imgproc.hpp:864
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
CV_EXPORTS_W void pyrMeanShiftFiltering(InputArray src, OutputArray dst, double sp, double sr, int maxLevel=1, TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1))
filters image using meanshift algorithm
CvSeq * contour
Definition: core_c.h:1431
Definition: imgproc.hpp:1045
CV_EXPORTS void calcBackProject(const Mat *images, int nimages, const int *channels, InputArray hist, OutputArray backProject, const float **ranges, double scale=1, bool uniform=true)
computes back projection for the set of images
CV_EXPORTS_W void HoughLinesP(InputArray image, OutputArray lines, double rho, double theta, int threshold, double minLineLength=0, double maxLineGap=0)
finds line segments in the black-n-white image using probabilistic Hough transform ...
Definition: types_c.h:361
CV_EXPORTS_W void getDerivKernels(OutputArray kx, OutputArray ky, int dx, int dy, int ksize, bool normalize=false, int ktype=CV_32F)
initializes kernels of the generalized Sobel operator
const int * idx
Definition: core_c.h:323
CV_EXPORTS_W Moments moments(InputArray array, bool binaryImage=false)
computes moments of the rasterized shape or a vector of points
const CvArr * src1
Definition: core_c.h:436
CV_EXPORTS void calcHist(const Mat *images, int nimages, const int *channels, InputArray mask, OutputArray hist, int dims, const int *histSize, const float **ranges, bool uniform=true, bool accumulate=false)
computes the joint dense histogram for a set of images.
CV_EXPORTS_W void equalizeHist(InputArray src, OutputArray dst)
normalizes the grayscale image brightness and contrast by normalizing its histogram ...
InputArray InputArrayOfArrays
Definition: core.hpp:1448
Definition: imgproc.hpp:869
GLenum GLsizei width
Definition: imgproc.hpp:962
OutputArray OutputArray sqsum
Definition: imgproc.hpp:620
CvArr * markers
Definition: imgproc_c.h:130
CvArr double threshold1
Definition: imgproc_c.h:555
Definition: imgproc.hpp:660
int rowBorderType
Definition: imgproc.hpp:270
Definition: imgproc.hpp:988
const CvArr * signature2
Definition: imgproc_c.h:287
CV_EXPORTS Mat getAffineTransform(const Point2f src[], const Point2f dst[])
returns 2x3 affine transformation for the corresponding 3 point pairs.
GLuint src
Definition: core_c.h:1650
CV_EXPORTS_W Mat getGaussianKernel(int ksize, double sigma, int ktype=CV_64F)
returns the Gaussian kernel with the specified parameters
Definition: types_c.h:401
Definition: imgproc.hpp:953
Definition: imgproc.hpp:506
void int double rho
Definition: imgproc_c.h:603
CV_EXPORTS_W void createHanningWindow(OutputArray dst, Size winSize, int type)
CV_EXPORTS_W int borderInterpolate(int p, int len, int borderType)
1D interpolation function: returns coordinate of the "donor" pixel for the specified location p...
int int int flags
Definition: highgui_c.h:186
Definition: imgproc.hpp:950
Definition: types_c.h:403
CV_EXPORTS Ptr< BaseFilter > getMorphologyFilter(int op, int type, InputArray kernel, Point anchor=Point(-1,-1))
returns 2D morphological filter
Definition: imgproc.hpp:499
struct CvMoments CvMoments
foreground
Definition: imgproc.hpp:798
Definition: imgproc.hpp:287
CV_EXPORTS_W double PSNR(InputArray src1, InputArray src2)
computes PSNR image/video quality metric
int d
Definition: legacy.hpp:3064
int startY0
Definition: imgproc.hpp:277
Definition: imgproc.hpp:993
Definition: imgproc.hpp:1143
int double double reps
Definition: imgproc_c.h:616
GLfloat angle
Definition: core_c.h:1297
Definition: imgproc.hpp:1123
most probably foreground
Definition: imgproc.hpp:800
CvPoint center
Definition: core_c.h:1290
Definition: imgproc.hpp:940
CV_EXPORTS_W void getRectSubPix(InputArray image, Size patchSize, Point2f center, OutputArray patch, int patchType=-1)
extracts rectangle from the image at sub-pixel location
Definition: imgproc.hpp:920
Definition: imgproc.hpp:1042
Definition: types_c.h:337
Definition: imgproc.hpp:653
int int int int shape
Definition: imgproc_c.h:223
int freeQEdge
Definition: imgproc.hpp:1288
CV_EXPORTS_W void watershed(InputArray image, InputOutputArray markers)
segments the image using watershed algorithm
CvArr const CvMat * kernel
Definition: imgproc_c.h:89
Definition: imgproc.hpp:985
CV_EXPORTS_W void Canny(InputArray image, OutputArray edges, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false)
applies Canny edge detector and produces the edge map.
int maxWidth
Definition: imgproc.hpp:266
Definition: imgproc.hpp:935
CV_EXPORTS_W void findContours(InputOutputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point())
retrieves contours and the hierarchical information from black-n-white image.
Definition: imgproc.hpp:1008
Definition: types_c.h:366
Definition: types_c.h:360
Definition: imgproc.hpp:921
Definition: imgproc.hpp:983
OutputArray sum
Definition: imgproc.hpp:620
Definition: imgproc.hpp:904
Definition: imgproc.hpp:948
Definition: types_c.h:414
Definition: imgproc.hpp:286
vector< uchar * > rows
Definition: imgproc.hpp:278
Definition: imgproc.hpp:806
CV_EXPORTS_W void matchTemplate(InputArray image, InputArray templ, OutputArray result, int method)
computes the proximity map for the raster template and the image where the template is searched for ...
GLenum GLsizei GLenum GLenum const GLvoid * image
Definition: highgui_c.h:230
Definition: imgproc.hpp:982
Definition: types_c.h:593
CV_EXPORTS void buildPyramid(InputArray src, OutputArrayOfArrays dst, int maxlevel, int borderType=BORDER_DEFAULT)
builds the gaussian pyramid using pyrDown() as a basic operation
Definition: imgproc.hpp:1074
CV_EXPORTS_W void warpAffine(InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar())
warps the image using affine transformation
CV_EXPORTS_W void resize(InputArray src, OutputArray dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR)
resizes the image
CV_EXPORTS_W Point2d phaseCorrelateRes(InputArray src1, InputArray src2, InputArray window, CV_OUT double *response=0)
const CvArr CvArr int method
Definition: imgproc_c.h:281
CV_EXPORTS Ptr< BaseRowFilter > getMorphologyRowFilter(int op, int type, int ksize, int anchor=-1)
returns horizontal 1D morphological filter
CV_EXPORTS_W RotatedRect minAreaRect(InputArray points)
computes the minimal rotated rectangle for a set of points
CV_EXPORTS void eigen2x2(const float *a, float *e, int n)
raster image moments
Definition: imgproc.hpp:1094
Definition: imgproc.hpp:947
Definition: imgproc.hpp:1070
Definition: imgproc.hpp:890
Definition: imgproc.hpp:849
Proxy datatype for passing Mat's and vector<>'s as input parameters.
Definition: core.hpp:1312
Definition: imgproc.hpp:831
CV_EXPORTS_W double pointPolygonTest(InputArray contour, Point2f pt, bool measureDist)
checks if the point is inside the contour. Optionally computes the signed distance from the point to ...
Definition: imgproc.hpp:936
Definition: imgproc.hpp:66
Point2f topLeft
Definition: imgproc.hpp:1293
CvRect rect
Definition: core_c.h:100
Definition: imgproc.hpp:925
CV_EXPORTS_W void initUndistortRectifyMap(InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, Size size, int m1type, OutputArray map1, OutputArray map2)
initializes maps for cv::remap() to correct lens distortion and optionally rectify the image ...
Definition: imgproc.hpp:981
CV_EXPORTS_W void accumulateProduct(InputArray src1, InputArray src2, InputOutputArray dst, InputArray mask=noArray())
adds product of the 2 images to the accumulator (dst += src1*src2).
Definition: imgproc.hpp:866
const CvPoint2D32f vertex[4]
Definition: legacy.hpp:1070
The 2D size class.
Definition: core.hpp:81
Definition: imgproc.hpp:559
int double double double aeps
Definition: imgproc_c.h:616
const CvArr const CvArr CvArr * result
Definition: core_c.h:805
typedef void(CV_CDECL *CvMouseCallback)(int event
The Base Class for 1D or Row-wise Filters.
Definition: imgproc.hpp:80
vector< uchar > constBorderRow
Definition: imgproc.hpp:276
CvPoint2D32f double CvTermCriteria criteria
Definition: calib3d.hpp:65
Definition: imgproc.hpp:997
Definition: imgproc.hpp:1004
CV_EXPORTS Ptr< FilterEngine > createBoxFilter(int srcType, int dstType, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT)
returns box filter engine
OutputArray OutputArray int int int labelType
Definition: imgproc.hpp:825
retrieve only the most external (top-level) contours
Definition: imgproc.hpp:1132
Definition: imgproc.hpp:918
Definition: imgproc.hpp:965
Definition: imgproc.hpp:881
Definition: imgproc.hpp:927
Definition: imgproc.hpp:1023
Definition: types_c.h:345
Definition: imgproc.hpp:930
Definition: imgproc.hpp:586
retrieve the connected components (that can possibly be nested)
Definition: imgproc.hpp:1134
GLint GLvoid * img
Definition: legacy.hpp:1150
Definition: imgproc.hpp:286
Definition: imgproc.hpp:961
Definition: imgproc.hpp:1052
Definition: imgproc.hpp:1072
double start
Definition: core_c.h:774
Definition: types_c.h:590
Definition: imgproc.hpp:934
Definition: imgproc.hpp:1037
Definition: types_c.h:334
Definition: imgproc.hpp:892
CV_EXPORTS_W void adaptiveBilateralFilter(InputArray src, OutputArray dst, Size ksize, double sigmaSpace, double maxSigmaColor=20.0, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT)
smooths the image using adaptive bilateral filter
Definition: imgproc.hpp:651
CV_EXPORTS_W void remap(InputArray src, OutputArray dst, InputArray map1, InputArray map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar())
warps the image using the precomputed maps. The maps are stored in either floating-point or integer f...
CV_EXPORTS_W RotatedRect fitEllipse(InputArray points)
fits ellipse to the set of 2D points
Definition: imgproc.hpp:868
Definition: imgproc.hpp:863
Definition: imgproc.hpp:1000
Definition: imgproc.hpp:938
Definition: imgproc.hpp:358
Definition: imgproc.hpp:851
const _InputArray & InputArray
Definition: core.hpp:1447
Definition: imgproc.hpp:917
Definition: imgproc.hpp:1082
Definition: imgproc.hpp:1020
CV_EXPORTS_W void grabCut(InputArray img, InputOutputArray mask, Rect rect, InputOutputArray bgdModel, InputOutputArray fgdModel, int iterCount, int mode=GC_EVAL)
segments the image using GrabCut algorithm
Definition: imgproc.hpp:876
vector< int > borderTab
Definition: imgproc.hpp:271
CvPoint2D32f CvSubdiv2DEdge * edge
Definition: legacy.hpp:2954
Definition: imgproc.hpp:1027
CV_EXPORTS Ptr< FilterEngine > createGaussianFilter(int type, Size ksize, double sigma1, double sigma2=0, int borderType=BORDER_DEFAULT)
returns the Gaussian filter engine
Definition: imgproc.hpp:906
CV_EXPORTS Ptr< BaseColumnFilter > getLinearColumnFilter(int bufType, int dstType, InputArray kernel, int anchor, int symmetryType, double delta=0, int bits=0)
returns the primitive column filter with the specified kernel
Definition: imgproc.hpp:967
Definition: imgproc.hpp:888
the desired accuracy or change in parameters at which the iterative algorithm stops ...
Definition: core.hpp:2098
Definition: imgproc.hpp:970
Definition: imgproc.hpp:907
Definition: imgproc.hpp:897
Definition: imgproc.hpp:1044
CV_EXPORTS_W void preCornerDetect(InputArray src, OutputArray dst, int ksize, int borderType=BORDER_DEFAULT)
computes another complex cornerness criteria at each pixel
Definition: imgproc.hpp:999
GLclampf GLclampf GLclampf alpha
Definition: core_c.h:687
int CvHistogram * hist
Definition: imgproc_c.h:440
Definition: imgproc.hpp:1005
Definition: imgproc.hpp:1081
const CvMat const CvMat const CvMat CvMat CvMat CvMat CvMat CvSize CvMat * R
Definition: calib3d.hpp:270
CV_EXPORTS_W void convexityDefects(InputArray contour, InputArray convexhull, OutputArray convexityDefects)
computes the contour convexity defects
Definition: imgproc.hpp:998
Definition: imgproc.hpp:1030
Definition: imgproc.hpp:1051
Definition: types_c.h:364
CvPoint const int int contours
Definition: core_c.h:1319
Definition: imgproc.hpp:984
Definition: imgproc.hpp:498
OutputArray OutputArray int int maskSize
Definition: imgproc.hpp:823
Definition: imgproc.hpp:63
The Base Class for Non-Separable 2D Filters.
Definition: imgproc.hpp:133
Definition: imgproc.hpp:973
CvSize int int int CvPoint int delta
Definition: core_c.h:1427
Definition: imgproc.hpp:951
CV_EXPORTS_W void bilateralFilter(InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT)
smooths the image using bilateral filter
Definition: imgproc.hpp:945
Ptr< BaseColumnFilter > columnFilter
Definition: imgproc.hpp:282
CV_EXPORTS_W void GaussianBlur(InputArray src, OutputArray dst, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT)
smooths the image using Gaussian filter.
Definition: imgproc.hpp:1206
Definition: imgproc.hpp:818
Definition: imgproc.hpp:875
Definition: imgproc.hpp:1063
Definition: types_c.h:370
CV_EXPORTS_W void Laplacian(InputArray src, OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)
applies Laplacian operator to the image
Definition: imgproc.hpp:1059
Definition: imgproc.hpp:891
Definition: types_c.h:412
CvArr int CvScalar param1
Definition: core_c.h:649
Definition: imgproc.hpp:358
Definition: types_c.h:596
CV_EXPORTS_W void blur(InputArray src, OutputArray dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT)
a synonym for normalized box filter
Definition: types_c.h:591
const CvMat CvMat CvMat int k
Definition: legacy.hpp:3052
Definition: imgproc.hpp:819
CV_EXPORTS_W void morphologyEx(InputArray src, OutputArray dst, int op, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
applies an advanced morphological operation to the image
Definition: imgproc.hpp:900
CV_EXPORTS Ptr< FilterEngine > createMorphologyFilter(int op, int type, InputArray kernel, Point anchor=Point(-1,-1), int rowBorderType=BORDER_CONSTANT, int columnBorderType=-1, const Scalar &borderValue=morphologyDefaultBorderValue())
returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported.
Definition: imgproc.hpp:902
Definition: imgproc.hpp:379
GLintptr offset
CV_EXPORTS_W void HoughLines(InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn=0, double stn=0)
finds lines in the black-n-white image using the standard or pyramid Hough transform ...
OutputArray OutputArray OutputArray tilted
Definition: imgproc.hpp:623
CvArr double double sr
Definition: imgproc_c.h:125
int ksize
Definition: imgproc.hpp:90
Definition: imgproc.hpp:1010
Definition: imgproc.hpp:882
GLenum GLsizei n
Definition: imgproc.hpp:1075
Definition: imgproc.hpp:652
Definition: imgproc.hpp:1066
Definition: imgproc.hpp:1053
GLdouble left
CV_EXPORTS_W void dilate(InputArray src, OutputArray dst, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
dilates the image (applies the local maximum operator)
Definition: imgproc.hpp:956
Definition: imgproc.hpp:1050
CV_EXPORTS_W void boxFilter(InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT)
smooths the image using the box filter. Each pixel is processed in O(1) time
const CvArr CvArr * flow
Definition: tracking.hpp:102
Size ksize
Definition: imgproc.hpp:264
Definition: types_c.h:404
Definition: types_c.h:402
CV_EXPORTS_W void pyrDown(InputArray src, OutputArray dst, const Size &dstsize=Size(), int borderType=BORDER_DEFAULT)
smooths and downsamples the image
Definition: imgproc.hpp:1038
Definition: imgproc.hpp:356
Definition: imgproc.hpp:943
CV_EXPORTS_W Mat getStructuringElement(int shape, Size ksize, Point anchor=Point(-1,-1))
returns structuring element of the specified shape and size
void int double double theta
Definition: imgproc_c.h:603
Definition: imgproc.hpp:989
CV_EXPORTS_W Ptr< CLAHE > createCLAHE(double clipLimit=40.0, Size tileGridSize=Size(8, 8))
OutputArray OutputArrayOfArrays
Definition: core.hpp:1450
Definition: imgproc.hpp:357
vector< QuadEdge > qedges
Definition: imgproc.hpp:1287
CV_EXPORTS Ptr< FilterEngine > createDerivFilter(int srcType, int dstType, int dx, int dy, int ksize, int borderType=BORDER_DEFAULT)
returns filter engine for the generalized Sobel operator
Point2f pt
Definition: imgproc.hpp:1275
int type
Definition: imgproc.hpp:1274
Definition: imgproc.hpp:976
const CvArr CvArr double int int int iterations
Definition: tracking.hpp:102
Definition: imgproc.hpp:62
Definition: types_c.h:362
CV_EXPORTS_W double threshold(InputArray src, OutputArray dst, double thresh, double maxval, int type)
applies fixed threshold to the image
GLdouble GLdouble right
Definition: imgproc.hpp:910
CvArr double double threshold2
Definition: imgproc_c.h:555
Definition: imgproc.hpp:357
The Core Functionality.
Ptr< BaseRowFilter > rowFilter
Definition: imgproc.hpp:281
CV_EXPORTS_W void accumulateSquare(InputArray src, InputOutputArray dst, InputArray mask=noArray())
adds squared src image to the accumulator (dst += src*src).
CV_EXPORTS_W double matchShapes(InputArray contour1, InputArray contour2, int method, double parameter)
matches two contours using one of the available algorithms
Definition: imgproc.hpp:928
Definition: imgproc.hpp:64
Definition: imgproc.hpp:1123
Definition: imgproc.hpp:861
Definition: imgproc.hpp:977
The n-dimensional matrix class.
Definition: core.hpp:1688
Definition: imgproc.hpp:952
Definition: imgproc.hpp:1062
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei imageSize
Definition: legacy.hpp:631
CV_EXPORTS_W void pyrUp(InputArray src, OutputArray dst, const Size &dstsize=Size(), int borderType=BORDER_DEFAULT)
upsamples and smoothes the image
Definition: imgproc.hpp:972
CV_EXPORTS_W void cornerEigenValsAndVecs(InputArray src, OutputArray dst, int blockSize, int ksize, int borderType=BORDER_DEFAULT)
computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix at each pixel...
Definition: imgproc.hpp:1083
Definition: imgproc.hpp:1046
OutputArray InputOutputArray
Definition: core.hpp:1451
Definition: imgproc.hpp:858
ditto
Definition: core.hpp:2097
Definition: imgproc.hpp:1142
CvArr CvPoint2D32f double maxRadius
Definition: imgproc_c.h:191
GLsizei const GLfloat * value
Definition: core_c.h:341
CvSize CvPoint2D32f * corners
Definition: calib3d.hpp:215
CV_EXPORTS_W void Scharr(InputArray src, OutputArray dst, int ddepth, int dx, int dy, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)
applies the vertical or horizontal Scharr operator to the image
Definition: imgproc.hpp:660
bilinear interpolation
Definition: imgproc.hpp:555
OutputArray OutputArray labels
Definition: imgproc.hpp:823
Definition: imgproc.hpp:1016
CV_EXPORTS_W void distanceTransform(InputArray src, OutputArray dst, int distanceType, int maskSize)
computes the distance transform map
Definition: imgproc.hpp:893
static Scalar_< double > all(doublev0)
returns a scalar with all elements set to v0
Definition: imgproc.hpp:1018
Window window
Definition: tracking.hpp:154
Definition: imgproc.hpp:931
Definition: imgproc.hpp:957
GLfloat GLfloat p
GLuint GLuint GLsizei GLenum type
Definition: core_c.h:114
Definition: imgproc.hpp:1002
Definition: imgproc.hpp:855
Definition: imgproc.hpp:1009
Definition: imgproc.hpp:901
int srcType
Definition: imgproc.hpp:263
Definition: imgproc.hpp:887
Definition: imgproc.hpp:909
float ** ranges
Definition: imgproc_c.h:435
Definition: imgproc.hpp:867
Definition: imgproc.hpp:946
CV_EXPORTS_W void convexHull(InputArray points, OutputArray hull, bool clockwise=false, bool returnPoints=true)
computes convex hull for a set of 2D points.
Definition: imgproc.hpp:1080
Definition: imgproc.hpp:359
Definition: imgproc.hpp:923
CV_EXPORTS_W void integral(InputArray src, OutputArray sum, int sdepth=-1)
computes the integral image
int int channels
Definition: core_c.h:73
int dx2
Definition: imgproc.hpp:269
int CvArr CvTermCriteria termcrit
Definition: core_c.h:1472
OutputArray OutputArray int distanceType
Definition: imgproc.hpp:823
CV_EXPORTS_W double arcLength(InputArray curve, bool closed)
computes the contour perimeter (closed=true) or a curve length
Definition: imgproc.hpp:860
CV_EXPORTS_AS(sumElems) Scalar sum(InputArray src)
computes sum of array elements
template 2D point class.
Definition: core.hpp:82
Definition: imgproc.hpp:500
CV_EXPORTS_W void accumulateWeighted(InputArray src, InputOutputArray dst, double alpha, InputArray mask=noArray())
updates the running average (dst = dst*(1-alpha) + src*alpha)
CvArr double sp
Definition: imgproc_c.h:125
Definition: imgproc.hpp:62
Definition: imgproc.hpp:66
Definition: imgproc.hpp:991
Definition: imgproc.hpp:968
Definition: imgproc.hpp:1123
Definition: types_c.h:594
CvArr int code
Definition: imgproc_c.h:144
CV_PROP_RW double nu30
Definition: imgproc.hpp:1112
GLboolean GLboolean GLboolean GLboolean a
Definition: legacy.hpp:633
CV_EXPORTS Ptr< BaseFilter > getLinearFilter(int srcType, int dstType, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int bits=0)
returns 2D filter with the specified kernel
CV_EXPORTS_W Mat getGaborKernel(Size ksize, double sigma, double theta, double lambd, double gamma, double psi=CV_PI *0.5, int ktype=CV_64F)
returns the Gabor kernel with the specified parameters
CV_EXPORTS_W void filter2D(InputArray src, OutputArray dst, int ddepth, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT)
applies non-separable 2D linear filter to the image
CV_EXPORTS_W void goodFeaturesToTrack(InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, InputArray mask=noArray(), int blockSize=3, bool useHarrisDetector=false, double k=0.04)
finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxi...
Definition: imgproc.hpp:766
Definition: imgproc.hpp:986
int int int * dx
Definition: imgproc.hpp:1047
CV_EXPORTS Ptr< BaseRowFilter > getRowSumFilter(int srcType, int sumType, int ksize, int anchor=-1)
returns horizontal 1D box filter
The Main Class for Image Filtering.
Definition: imgproc.hpp:222
Definition: imgproc.hpp:1001
vector< Vertex > vtx
Definition: imgproc.hpp:1286
CV_EXPORTS_W Point2d phaseCorrelate(InputArray src1, InputArray src2, InputArray window=noArray())
Base class for high-level OpenCV algorithms.
Definition: core.hpp:4390
CV_EXPORTS_W void copyMakeBorder(InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar &value=Scalar())
copies 2D array to a larger destination array with extrapolation of the outer part of src using the s...
Definition: imgproc.hpp:1055
Definition: imgproc.hpp:1007
Definition: imgproc.hpp:971
CV_EXPORTS Ptr< FilterEngine > createSeparableLinearFilter(int srcType, int dstType, InputArray rowKernel, InputArray columnKernel, Point anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, const Scalar &borderValue=Scalar())
returns the separable linear filter engine
Definition: imgproc.hpp:379
Definition: imgproc.hpp:1011
Definition: imgproc.hpp:896
GLboolean reset
int ksize
Definition: imgproc.hpp:119
Definition: imgproc.hpp:1048
CV_EXPORTS_W void drawContours(InputOutputArray image, InputArrayOfArrays contours, int contourIdx, const Scalar &color, int thickness=1, int lineType=8, InputArray hierarchy=noArray(), int maxLevel=INT_MAX, Point offset=Point())
draws contours in the image
int firstEdge
Definition: imgproc.hpp:1273
Definition: imgproc.hpp:63
CvArr int CvScalar CvScalar param2
Definition: core_c.h:649
Definition: imgproc.hpp:1123
CV_EXPORTS float EMD(InputArray signature1, InputArray signature2, int distType, InputArray cost=noArray(), float *lowerBound=0, OutputArray flow=noArray())
unsigned char uchar
Definition: types_c.h:170
CV_EXPORTS_W void Sobel(InputArray src, OutputArray dst, int ddepth, int dx, int dy, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)
applies generalized Sobel operator to the image
Definition: imgproc.hpp:652
CV_EXPORTS_W void erode(InputArray src, OutputArray dst, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
erodes the image (applies the local minimum operator)
Definition: imgproc.hpp:880
double const CvArr double double gamma
Definition: core_c.h:523
GLuint dst
Definition: calib3d.hpp:134
GLenum GLsizei len
CV_EXPORTS_W Mat getDefaultNewCameraMatrix(InputArray cameraMatrix, Size imgsize=Size(), bool centerPrincipalPoint=false)
returns the default new camera matrix (by default it is the same as cameraMatrix unless centerPricipa...
Definition: types_c.h:595
Definition: imgproc.hpp:885
Definition: types_c.h:365
Definition: imgproc.hpp:960
CV_EXPORTS Ptr< BaseColumnFilter > getMorphologyColumnFilter(int op, int type, int ksize, int anchor=-1)
returns vertical 1D morphological filter
Definition: imgproc.hpp:995
Definition: imgproc.hpp:1277
GLsizei const GLfloat * points
CV_EXPORTS_W void warpPerspective(InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar())
warps the image using perspective transformation
Definition: imgproc.hpp:356
const CvArr * templ
Definition: imgproc_c.h:281
Definition: types_c.h:592
Definition: imgproc.hpp:1069
Smart pointer to dynamically allocated objects.
Definition: core.hpp:1268
GLdouble GLdouble GLdouble bottom
CV_PROP_RW double m30
Definition: imgproc.hpp:1108
Definition: imgproc.hpp:1084
CV_EXPORTS_W Rect boundingRect(InputArray points)
computes the bounding rectangle for a contour
CV_EXPORTS int floodFill(InputOutputArray image, Point seedPoint, Scalar newVal, CV_OUT Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4)
fills the semi-uniform image region starting from the specified seed point
Definition: imgproc.hpp:1028
const CvArr * cost
Definition: calib3d.hpp:359
Definition: imgproc.hpp:1073
CV_EXPORTS_W void medianBlur(InputArray src, OutputArray dst, int ksize)
smooths the image using median filter.
CV_PROP_RW double mu30
Definition: imgproc.hpp:1110
Definition: types_c.h:363
Definition: imgproc.hpp:691
const GLfloat * m
CV_EXPORTS Ptr< BaseRowFilter > getLinearRowFilter(int srcType, int bufType, InputArray kernel, int anchor, int symmetryType)
returns the primitive row filter with the specified kernel
Definition: imgproc.hpp:996
CvGraphVtx * vtx
Definition: core_c.h:1151
Definition: imgproc.hpp:942
Definition: imgproc.hpp:899
Definition: imgproc.hpp:1077
Definition: imgproc.hpp:871
nearest neighbor interpolation
Definition: imgproc.hpp:554
CV_EXPORTS OutputArray noArray()
int freePoint
Definition: imgproc.hpp:1289
Definition: imgproc.hpp:64
GLenum GLenum GLenum GLenum GLenum scale
bool validGeometry
Definition: imgproc.hpp:1290
most probably background
Definition: imgproc.hpp:799
Definition: imgproc.hpp:560
Definition: imgproc.hpp:584
const CvArr const CvArr * src2
Definition: core_c.h:436
CV_EXPORTS_W float intersectConvexConvex(InputArray _p1, InputArray _p2, OutputArray _p12, bool handleNested=true)
finds intersection of two convex polygons
CV_EXPORTS_W void approxPolyDP(InputArray curve, OutputArray approxCurve, double epsilon, bool closed)
approximates contour or a curve using Douglas-Peucker algorithm
Point_< float > Point2f
Definition: core.hpp:898
GLenum GLint GLuint mask
Definition: tracking.hpp:132
vector< uchar > ringBuf
Definition: imgproc.hpp:273
Definition: types_c.h:336
Definition: imgproc.hpp:1015
Definition: imgproc.hpp:1144
CV_EXPORTS_W bool isContourConvex(InputArray contour)
returns true if the contour is convex. Does not support contours with self-intersection ...
Definition: imgproc.hpp:884
Definition: imgproc.hpp:958
CvPoint int radius
Definition: core_c.h:1290
Definition: imgproc.hpp:990
Definition: imgproc.hpp:1006
const CvMat const CvMat CvSize CvMat * H1
Definition: calib3d.hpp:297
Definition: imgproc.hpp:1013
Size wholeSize
Definition: imgproc.hpp:267
CV_EXPORTS_W void undistort(InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix=noArray())
corrects lens distortion for the given camera matrix and distortion coefficients
Definition: types_c.h:335
CV_EXPORTS_W double compareHist(InputArray H1, InputArray H2, int method)
compares two histograms stored in dense arrays
Definition: imgproc.hpp:1039
Rect roi
Definition: imgproc.hpp:268
vector< uchar > constBorderValue
Definition: imgproc.hpp:275
CV_EXPORTS_W void fitLine(InputArray points, OutputArray line, int distType, double param, double reps, double aeps)
fits line to the set of 2D points using M-estimator algorithm
GLsizeiptr size
Definition: core_c.h:939
Definition: imgproc.hpp:877
Scalar_< double > Scalar
Definition: core.hpp:968
CV_EXPORTS Mat getPerspectiveTransform(const Point2f src[], const Point2f dst[])
returns 3x3 perspective transformation for the corresponding 4 point pairs.
Definition: imgproc.hpp:955
Proxy datatype for passing Mat's and vector<>'s as input parameters.
Definition: core.hpp:1400
GLfloat param
Definition: imgproc.hpp:651
Definition: imgproc.hpp:872
CV_EXPORTS Ptr< FilterEngine > createLinearFilter(int srcType, int dstType, InputArray kernel, Point _anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, const Scalar &borderValue=Scalar())
returns the non-separable linear filter engine
CV_EXPORTS void rotate(const GpuMat &src, GpuMat &dst, Size dsize, double angle, double xShift=0, double yShift=0, int interpolation=INTER_LINEAR, Stream &stream=Stream::Null())
CV_EXPORTS void HuMoments(const Moments &moments, double hu[7])
computes 7 Hu invariants from the moments
Definition: imgproc.hpp:650
Definition: imgproc.hpp:912
Definition: imgproc.hpp:1041
Definition: imgproc.hpp:1060
Rect_< int > Rect
Definition: core.hpp:897
Definition: imgproc.hpp:857
CV_EXPORTS Ptr< BaseColumnFilter > getColumnSumFilter(int sumType, int dstType, int ksize, int anchor=-1, double scale=1)
returns vertical 1D box filter
Definition: types_c.h:413
Definition: imgproc.hpp:870
CV_EXPORTS_W void sepFilter2D(InputArray src, OutputArray dst, int ddepth, InputArray kernelX, InputArray kernelY, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT)
applies separable 2D linear filter to the image
Definition: imgproc.hpp:873
Definition: imgproc.hpp:1267
const CvArr * next
Definition: tracking.hpp:102
Definition: imgproc.hpp:1029
Definition: imgproc.hpp:1136
Definition: imgproc.hpp:966
Definition: imgproc.hpp:916
retrieve all the contours without any hierarchical information
Definition: imgproc.hpp:1133
Definition: imgproc.hpp:1036
CV_EXPORTS_W void normalize(InputArray src, OutputArray dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, InputArray mask=noArray())
scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and...
Definition: imgproc.hpp:848
background
Definition: imgproc.hpp:797
Definition: imgproc.hpp:831
CV_EXPORTS void insert(const Mat &plane, Mat &a, int coi)
Definition: imgproc.hpp:913
CV_EXPORTS_W void line(CV_IN_OUT Mat &img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
draws the line segment (pt1, pt2) in the image
GLuint color
Definition: core_c.h:1276