1 /*M///////////////////////////////////////////////////////////////////////////////////////
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
5 // By downloading, copying, installing or using the software you agree to this license.
6 // If you do not agree to this license, do not download, install,
7 // copy or use the software.
11 // For Open Source Computer Vision Library
13 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
14 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
15 // Third party copyrights are property of their respective owners.
17 // Redistribution and use in source and binary forms, with or without modification,
18 // are permitted provided that the following conditions are met:
20 // * Redistribution's of source code must retain the above copyright notice,
21 // this list of conditions and the following disclaimer.
23 // * Redistribution's in binary form must reproduce the above copyright notice,
24 // this list of conditions and the following disclaimer in the documentation
25 // and/or other materials provided with the distribution.
27 // * The name of the copyright holders may not be used to endorse or promote products
28 // derived from this software without specific prior written permission.
30 // This software is provided by the copyright holders and contributors "as is" and
31 // any express or implied warranties, including, but not limited to, the implied
32 // warranties of merchantability and fitness for a particular purpose are disclaimed.
33 // In no event shall the Intel Corporation or contributors be liable for any direct,
34 // indirect, incidental, special, exemplary, or consequential damages
35 // (including, but not limited to, procurement of substitute goods or services;
36 // loss of use, data, or profits; or business interruption) however caused
37 // and on any theory of liability, whether in contract, strict liability,
38 // or tort (including negligence or otherwise) arising in any way out of
39 // the use of this software, even if advised of the possibility of such damage.
51 enum { BORDER_REPLICATE=IPL_BORDER_REPLICATE, BORDER_CONSTANT=IPL_BORDER_CONSTANT,
52 BORDER_REFLECT=IPL_BORDER_REFLECT, BORDER_REFLECT_101=IPL_BORDER_REFLECT_101,
53 BORDER_REFLECT101=BORDER_REFLECT_101, BORDER_WRAP=IPL_BORDER_WRAP,
54 BORDER_TRANSPARENT, BORDER_DEFAULT=BORDER_REFLECT_101, BORDER_ISOLATED=16 };
56 CV_EXPORTS int borderInterpolate( int p, int len, int borderType );
58 class CV_EXPORTS BaseRowFilter
62 virtual ~BaseRowFilter();
63 virtual void operator()(const uchar* src, uchar* dst,
64 int width, int cn) = 0;
69 class CV_EXPORTS BaseColumnFilter
73 virtual ~BaseColumnFilter();
74 virtual void operator()(const uchar** src, uchar* dst, int dststep,
75 int dstcount, int width) = 0;
81 class CV_EXPORTS BaseFilter
85 virtual ~BaseFilter();
86 virtual void operator()(const uchar** src, uchar* dst, int dststep,
87 int dstcount, int width, int cn) = 0;
94 class CV_EXPORTS FilterEngine
98 FilterEngine(const Ptr<BaseFilter>& _filter2D,
99 const Ptr<BaseRowFilter>& _rowFilter,
100 const Ptr<BaseColumnFilter>& _columnFilter,
101 int srcType, int dstType, int bufType,
102 int _rowBorderType=BORDER_REPLICATE,
103 int _columnBorderType=-1,
104 const Scalar& _borderValue=Scalar());
105 virtual ~FilterEngine();
106 void init(const Ptr<BaseFilter>& _filter2D,
107 const Ptr<BaseRowFilter>& _rowFilter,
108 const Ptr<BaseColumnFilter>& _columnFilter,
109 int srcType, int dstType, int bufType,
110 int _rowBorderType=BORDER_REPLICATE, int _columnBorderType=-1,
111 const Scalar& _borderValue=Scalar());
112 virtual int start(Size wholeSize, Rect roi, int maxBufRows=-1);
113 virtual int start(const Mat& src, const Rect& srcRoi=Rect(0,0,-1,-1),
114 bool isolated=false, int maxBufRows=-1);
115 virtual int proceed(const uchar* src, int srcStep, int srcCount,
116 uchar* dst, int dstStep);
117 virtual void apply( const Mat& src, Mat& dst,
118 const Rect& srcRoi=Rect(0,0,-1,-1),
119 Point dstOfs=Point(0,0),
120 bool isolated=false);
121 bool isSeparable() const { return (const BaseFilter*)filter2D == 0; }
122 int remainingInputRows() const;
123 int remainingOutputRows() const;
125 int srcType, dstType, bufType;
132 int rowBorderType, columnBorderType;
133 Vector<int> borderTab;
135 Vector<uchar> ringBuf;
136 Vector<uchar> srcRow;
137 Vector<uchar> constBorderValue;
138 Vector<uchar> constBorderRow;
139 int bufStep, startY, startY0, endY, rowCount, dstY;
142 Ptr<BaseFilter> filter2D;
143 Ptr<BaseRowFilter> rowFilter;
144 Ptr<BaseColumnFilter> columnFilter;
147 enum { KERNEL_GENERAL=0, KERNEL_SYMMETRICAL=1, KERNEL_ASYMMETRICAL=2,
148 KERNEL_SMOOTH=4, KERNEL_INTEGER=8 };
150 CV_EXPORTS int getKernelType(const Mat& kernel, Point anchor);
152 CV_EXPORTS Ptr<BaseRowFilter> getLinearRowFilter(int srcType, int bufType,
153 const Mat& kernel, int anchor,
156 CV_EXPORTS Ptr<BaseColumnFilter> getLinearColumnFilter(int bufType, int dstType,
157 const Mat& kernel, int anchor,
158 int symmetryType, double delta=0,
161 CV_EXPORTS Ptr<BaseFilter> getLinearFilter(int srcType, int dstType,
163 Point anchor=Point(-1,-1),
164 double delta=0, int bits=0);
166 CV_EXPORTS Ptr<FilterEngine> createSeparableLinearFilter(int srcType, int dstType,
167 const Mat& rowKernel, const Mat& columnKernel,
168 Point _anchor=Point(-1,-1), double delta=0,
169 int _rowBorderType=BORDER_DEFAULT,
170 int _columnBorderType=-1,
171 const Scalar& _borderValue=Scalar());
173 CV_EXPORTS Ptr<FilterEngine> createLinearFilter(int srcType, int dstType,
174 const Mat& kernel, Point _anchor=Point(-1,-1),
175 double delta=0, int _rowBorderType=BORDER_DEFAULT,
176 int _columnBorderType=-1, const Scalar& _borderValue=Scalar());
178 CV_EXPORTS Mat getGaussianKernel( int ksize, double sigma, int ktype=CV_64F );
180 CV_EXPORTS Ptr<FilterEngine> createGaussianFilter( int type, Size ksize,
181 double sigma1, double sigma2=0,
182 int borderType=BORDER_DEFAULT);
184 CV_EXPORTS void getDerivKernels( Mat& kx, Mat& ky, int dx, int dy, int ksize,
185 bool normalize=false, int ktype=CV_32F );
187 CV_EXPORTS Ptr<FilterEngine> createDerivFilter( int srcType, int dstType,
188 int dx, int dy, int ksize,
189 int borderType=BORDER_DEFAULT );
191 CV_EXPORTS Ptr<BaseRowFilter> getRowSumFilter(int srcType, int sumType,
192 int ksize, int anchor=-1);
193 CV_EXPORTS Ptr<BaseColumnFilter> getColumnSumFilter(int sumType, int dstType,
194 int ksize, int anchor=-1,
196 CV_EXPORTS Ptr<FilterEngine> createBoxFilter( int srcType, int dstType, Size ksize,
197 Point anchor=Point(-1,-1),
199 int borderType=BORDER_DEFAULT);
201 enum { MORPH_ERODE=0, MORPH_DILATE=1, MORPH_OPEN=2, MORPH_CLOSE=3,
202 MORPH_GRADIENT=4, MORPH_TOPHAT=5, MORPH_BLACKHAT=6 };
204 CV_EXPORTS Ptr<BaseRowFilter> getMorphologyRowFilter(int op, int type, int ksize, int anchor=-1);
205 CV_EXPORTS Ptr<BaseColumnFilter> getMorphologyColumnFilter(int op, int type, int ksize, int anchor=-1);
206 CV_EXPORTS Ptr<BaseFilter> getMorphologyFilter(int op, int type, const Mat& kernel,
207 Point anchor=Point(-1,-1));
209 static inline Scalar morphologyDefaultBorderValue() { return Scalar::all(DBL_MAX); }
211 CV_EXPORTS Ptr<FilterEngine> createMorphologyFilter(int op, int type, const Mat& kernel,
212 Point anchor=Point(-1,-1), int _rowBorderType=BORDER_CONSTANT,
213 int _columnBorderType=-1,
214 const Scalar& _borderValue=morphologyDefaultBorderValue());
216 enum { MORPH_RECT=0, MORPH_CROSS=1, MORPH_ELLIPSE=2 };
217 CV_EXPORTS Mat getStructuringElement(int shape, Size ksize, Point anchor=Point(-1,-1));
219 CV_EXPORTS void copyMakeBorder( const Mat& src, Mat& dst,
220 int top, int bottom, int left, int right,
221 int borderType, const Scalar& value=Scalar() );
223 CV_EXPORTS void medianBlur( const Mat& src, Mat& dst, int ksize );
224 CV_EXPORTS void GaussianBlur( const Mat& src, Mat& dst, Size ksize,
225 double sigma1, double sigma2=0,
226 int borderType=BORDER_DEFAULT );
227 CV_EXPORTS void bilateralFilter( const Mat& src, Mat& dst, int d,
228 double sigmaColor, double sigmaSpace,
229 int borderType=BORDER_DEFAULT );
230 CV_EXPORTS void boxFilter( const Mat& src, Mat& dst, int ddepth,
231 Size ksize, Point anchor=Point(-1,-1),
233 int borderType=BORDER_DEFAULT );
234 static inline void blur( const Mat& src, Mat& dst,
235 Size ksize, Point anchor=Point(-1,-1),
236 int borderType=BORDER_DEFAULT )
238 boxFilter( src, dst, -1, ksize, anchor, true, borderType );
241 CV_EXPORTS void filter2D( const Mat& src, Mat& dst, int ddepth,
242 const Mat& kernel, Point anchor=Point(-1,-1),
243 double delta=0, int borderType=BORDER_DEFAULT );
245 CV_EXPORTS void sepFilter2D( const Mat& src, Mat& dst, int ddepth,
246 const Mat& kernelX, const Mat& kernelY,
247 Point anchor=Point(-1,-1),
248 double delta=0, int borderType=BORDER_DEFAULT );
250 CV_EXPORTS void Sobel( const Mat& src, Mat& dst, int ddepth,
251 int dx, int dy, int ksize=3,
252 double scale=1, double delta=0,
253 int borderType=BORDER_DEFAULT );
255 CV_EXPORTS void Scharr( const Mat& src, Mat& dst, int ddepth,
256 int dx, int dy, double scale=1, double delta=0,
257 int borderType=BORDER_DEFAULT );
259 CV_EXPORTS void Laplacian( const Mat& src, Mat& dst, int ddepth,
260 int ksize=1, double scale=1, double delta=0,
261 int borderType=BORDER_DEFAULT );
263 CV_EXPORTS void Canny( const Mat& image, Mat& edges,
264 double threshold1, double threshold2,
265 int apertureSize=3, bool L2gradient=false );
267 CV_EXPORTS void cornerMinEigenVal( const Mat& src, Mat& dst,
268 int blockSize, int ksize=3,
269 int borderType=BORDER_DEFAULT );
271 CV_EXPORTS void cornerHarris( const Mat& src, Mat& dst, int blockSize,
273 int borderType=BORDER_DEFAULT );
275 CV_EXPORTS void cornerEigenValsAndVecs( const Mat& src, Mat& dst,
276 int blockSize, int ksize,
277 int borderType=BORDER_DEFAULT );
279 CV_EXPORTS void preCornerDetect( const Mat& src, Mat& dst, int ksize,
280 int borderType=BORDER_DEFAULT );
282 CV_EXPORTS void cornerSubPix( const Mat& image, Vector<Point2f>& corners,
283 Size winSize, Size zeroZone,
284 TermCriteria criteria );
286 CV_EXPORTS void goodFeaturesToTrack( const Mat& image, Vector<Point2f>& corners,
287 int maxCorners, double qualityLevel, double minDistance,
288 const Mat& mask=Mat(), int blockSize=3,
289 bool useHarrisDetector=false, double k=0.04 );
291 CV_EXPORTS void HoughLines( Mat& image, Vector<Vec2f>& lines,
292 double rho, double theta, int threshold,
293 double srn=0, double stn=0 );
295 CV_EXPORTS void HoughLinesP( Mat& image, Vector<Vec4i>& lines,
296 double rho, double theta, int threshold,
297 double minLineLength=0, double maxLineGap=0 );
299 CV_EXPORTS void HoughCircles( Mat& image, Vector<Vec3f>& circles,
300 int method, double dp, double minDist,
301 double param1=100, double param2=100,
302 int minRadius=0, int maxRadius=0 );
304 CV_EXPORTS void erode( const Mat& src, Mat& dst, const Mat& kernel,
305 Point anchor=Point(-1,-1), int iterations=1,
306 int borderType=BORDER_CONSTANT,
307 const Scalar& borderValue=morphologyDefaultBorderValue() );
308 CV_EXPORTS void dilate( const Mat& src, Mat& dst, const Mat& kernel,
309 Point anchor=Point(-1,-1), int iterations=1,
310 int borderType=BORDER_CONSTANT,
311 const Scalar& borderValue=morphologyDefaultBorderValue() );
312 CV_EXPORTS void morphologyEx( const Mat& src, Mat& dst, int op, const Mat& kernel,
313 Point anchor=Point(-1,-1), int iterations=1,
314 int borderType=BORDER_CONSTANT,
315 const Scalar& borderValue=morphologyDefaultBorderValue() );
317 enum { INTER_NEAREST=0, INTER_LINEAR=1, INTER_CUBIC=2, INTER_AREA=3,
318 INTER_LANCZOS4=4, INTER_MAX=7, WARP_INVERSE_MAP=16 };
320 CV_EXPORTS void resize( const Mat& src, Mat& dst,
321 Size dsize=Size(), double fx=0, double fy=0,
322 int interpolation=INTER_LINEAR );
324 CV_EXPORTS void warpAffine( const Mat& src, Mat& dst,
325 const Mat& M, Size dsize,
326 int flags=INTER_LINEAR,
327 int borderMode=BORDER_CONSTANT,
328 const Scalar& borderValue=Scalar());
329 CV_EXPORTS void warpPerspective( const Mat& src, Mat& dst,
330 const Mat& M, Size dsize,
331 int flags=INTER_LINEAR,
332 int borderMode=BORDER_CONSTANT,
333 const Scalar& borderValue=Scalar());
335 CV_EXPORTS void remap( const Mat& src, Mat& dst, const Mat& map1, const Mat& map2,
336 int interpolation, int borderMode=BORDER_CONSTANT,
337 const Scalar& borderValue=Scalar());
339 CV_EXPORTS void convertMaps( const Mat& map1, const Mat& map2, Mat& dstmap1, Mat& dstmap2,
340 int dstmap1type, bool nninterpolation=false );
342 CV_EXPORTS Mat getRotationMatrix2D( Point2f center, double angle, double scale );
343 CV_EXPORTS Mat getPerspectiveTransform( const Point2f src[], const Point2f dst[] );
344 CV_EXPORTS Mat getAffineTransform( const Point2f src[], const Point2f dst[] );
345 CV_EXPORTS void invertAffineTransform(const Mat& M, Mat& iM);
347 CV_EXPORTS void getRectSubPix( const Mat& image, Size patchSize,
348 Point2f center, Mat& patch, int patchType=-1 );
350 CV_EXPORTS void integral( const Mat& src, Mat& sum, int sdepth=-1 );
351 CV_EXPORTS void integral( const Mat& src, Mat& sum, Mat& sqsum, int sdepth=-1 );
352 CV_EXPORTS void integral( const Mat& src, Mat& sum, Mat& sqsum, Mat& tilted, int sdepth=-1 );
354 CV_EXPORTS void accumulate( const Mat& src, Mat& dst, const Mat& mask=Mat() );
355 CV_EXPORTS void accumulateSquare( const Mat& src, Mat& dst, const Mat& mask=Mat() );
356 CV_EXPORTS void accumulateProduct( const Mat& src1, const Mat& src2,
357 Mat& dst, const Mat& mask=Mat() );
358 CV_EXPORTS void accumulateWeighted( const Mat& src, Mat& dst,
359 double alpha, const Mat& mask=Mat() );
361 enum { THRESH_BINARY=0, THRESH_BINARY_INV=1, THRESH_TRUNC=2, THRESH_TOZERO=3,
362 THRESH_TOZERO_INV=4, THRESH_MASK=7, THRESH_OTSU=8 };
364 CV_EXPORTS double threshold( const Mat& src, Mat& dst, double thresh, double maxval, int type );
366 enum { ADAPTIVE_THRESH_MEAN_C=0, ADAPTIVE_THRESH_GAUSSIAN_C=1 };
368 CV_EXPORTS void adaptiveThreshold( const Mat& src, Mat& dst, double maxValue,
369 int adaptiveMethod, int thresholdType,
370 int blockSize, double C );
372 CV_EXPORTS void pyrDown( const Mat& src, Mat& dst, const Size& dstsize=Size());
373 CV_EXPORTS void pyrUp( const Mat& src, Mat& dst, const Size& dstsize=Size());
374 CV_EXPORTS void buildPyramid( const Mat& src, Vector<Mat>& dst, int maxlevel );
377 CV_EXPORTS void undistort( const Mat& src, Mat& dst, const Mat& cameraMatrix,
378 const Mat& distCoeffs, const Mat& newCameraMatrix=Mat() );
379 CV_EXPORTS void initUndistortRectifyMap( const Mat& cameraMatrix, const Mat& distCoeffs,
380 const Mat& R, const Mat& newCameraMatrix,
381 Size size, int m1type, Mat& map1, Mat& map2 );
382 CV_EXPORTS Mat getDefaultNewCameraMatrix( const Mat& cameraMatrix, Size imgsize=Size(),
383 bool centerPrincipalPoint=false );
385 enum { OPTFLOW_USE_INITIAL_FLOW=4, OPTFLOW_FARNEBACK_GAUSSIAN=256 };
387 CV_EXPORTS void calcOpticalFlowPyrLK( const Mat& prevImg, const Mat& nextImg,
388 const Vector<Point2f>& prevPts,
389 Vector<Point2f>& nextPts,
390 Vector<bool>& status, Vector<float>& err,
391 Size winSize=Size(15,15), int maxLevel=3,
392 TermCriteria criteria=TermCriteria(
393 TermCriteria::COUNT+TermCriteria::EPS,
395 double derivLambda=0.5,
398 CV_EXPORTS void calcOpticalFlowFarneback( const Mat& prev0, const Mat& next0,
399 Mat& flow0, double pyr_scale, int levels, int winsize,
400 int iterations, int poly_n, double poly_sigma, int flags );
403 CV_EXPORTS void calcHist( const Vector<Mat>& images, const Vector<int>& channels,
404 const Mat& mask, MatND& hist, const Vector<int>& histSize,
405 const Vector<Vector<float> >& ranges,
406 bool uniform=true, bool accumulate=false );
408 CV_EXPORTS void calcHist( const Vector<Mat>& images, const Vector<int>& channels,
409 const Mat& mask, SparseMat& hist, const Vector<int>& histSize,
410 const Vector<Vector<float> >& ranges,
411 bool uniform=true, bool accumulate=false );
413 CV_EXPORTS void calcBackProject( const Vector<Mat>& images, const Vector<int>& channels,
414 const MatND& hist, Mat& backProject,
415 const Vector<Vector<float> >& ranges,
416 double scale=1, bool uniform=true );
418 CV_EXPORTS void calcBackProject( const Vector<Mat>& images, const Vector<int>& channels,
419 const SparseMat& hist, Mat& backProject,
420 const Vector<Vector<float> >& ranges,
421 double scale=1, bool uniform=true );
423 CV_EXPORTS double compareHist( const MatND& H1, const MatND& H2, int method );
425 CV_EXPORTS double compareHist( const SparseMat& H1, const SparseMat& H2, int method );
427 CV_EXPORTS void equalizeHist( const Mat& src, Mat& dst );
429 CV_EXPORTS void watershed( const Mat& image, Mat& markers );
431 enum { INPAINT_NS=CV_INPAINT_NS, INPAINT_TELEA=CV_INPAINT_TELEA };
433 CV_EXPORTS void inpaint( const Mat& src, const Mat& inpaintMask,
434 Mat& dst, double inpaintRange, int flags );
436 CV_EXPORTS void distanceTransform( const Mat& src, Mat& dst, Mat& labels,
437 int distanceType, int maskSize );
439 CV_EXPORTS void distanceTransform( const Mat& src, Mat& dst,
440 int distanceType, int maskSize );
442 enum { FLOODFILL_FIXED_RANGE = 1 << 16,
443 FLOODFILL_MASK_ONLY = 1 << 17 };
445 CV_EXPORTS int floodFill( Mat& image,
446 Point seedPoint, Scalar newVal, Rect* rect=0,
447 Scalar loDiff=Scalar(), Scalar upDiff=Scalar(),
450 CV_EXPORTS int floodFill( Mat& image, Mat& mask,
451 Point seedPoint, Scalar newVal, Rect* rect=0,
452 Scalar loDiff=Scalar(), Scalar upDiff=Scalar(),
455 CV_EXPORTS void cvtColor( const Mat& src, Mat& dst, int code, int dstCn=0 );
457 class CV_EXPORTS Moments
461 Moments(double m00, double m10, double m01, double m20, double m11,
462 double m02, double m30, double m21, double m12, double m03 );
463 Moments( const CvMoments& moments );
464 operator CvMoments() const;
466 double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03; // spatial moments
467 double mu20, mu11, mu02, mu30, mu21, mu12, mu03; // central moments
468 double nu20, nu11, nu02, nu30, nu21, nu12, nu03; // central normalized moments
471 CV_EXPORTS Moments moments( const Mat& image, bool binaryImage=false );
473 CV_EXPORTS void HuMoments( const Moments& moments, double hu[7] );
475 enum { TM_SQDIFF=CV_TM_SQDIFF, TM_SQDIFF_NORMED=CV_TM_SQDIFF_NORMED,
476 TM_CCORR=CV_TM_CCORR, TM_CCORR_NORMED=CV_TM_CCORR_NORMED,
477 TM_CCOEFF=CV_TM_CCOEFF, TM_CCOEFF_NORMED=CV_TM_CCOEFF_NORMED };
479 CV_EXPORTS void matchTemplate( const Mat& image, const Mat& templ, Mat& result, int method );
481 enum { RETR_EXTERNAL=CV_RETR_EXTERNAL, RETR_LIST=CV_RETR_LIST,
482 RETR_CCOMP=CV_RETR_CCOMP, RETR_TREE=CV_RETR_TREE };
484 enum { CHAIN_APPROX_NONE=CV_CHAIN_APPROX_NONE,
485 CHAIN_APPROX_SIMPLE=CV_CHAIN_APPROX_SIMPLE,
486 CHAIN_APPROX_TC89_L1=CV_CHAIN_APPROX_TC89_L1,
487 CHAIN_APPROX_TC89_KCOS=CV_CHAIN_APPROX_TC89_KCOS };
489 CV_EXPORTS Vector<Vector<Point> >
490 findContours( const Mat& image, Vector<Vec4i>& hierarchy,
491 int mode, int method, Point offset=Point());
493 CV_EXPORTS Vector<Vector<Point> >
494 findContours( const Mat& image, int mode, int method, Point offset=Point());
497 drawContours( Mat& image, const Vector<Vector<Point> >& contours,
498 const Scalar& color, int thickness=1,
499 int lineType=8, const Vector<Vec4i>& hierarchy=Vector<Vec4i>(),
500 int maxLevel=1, Point offset=Point() );
502 CV_EXPORTS void approxPolyDP( const Vector<Point>& curve,
503 Vector<Point>& approxCurve,
504 double epsilon, bool closed );
505 CV_EXPORTS void approxPolyDP( const Vector<Point2f>& curve,
506 Vector<Point2f>& approxCurve,
507 double epsilon, bool closed );
509 CV_EXPORTS double arcLength( const Vector<Point>& curve, bool closed );
510 CV_EXPORTS double arcLength( const Vector<Point2f>& curve, bool closed );
512 CV_EXPORTS Rect boundingRect( const Vector<Point>& points );
513 CV_EXPORTS Rect boundingRect( const Vector<Point2f>& points );
515 CV_EXPORTS double contourArea( const Vector<Point>& contour );
516 CV_EXPORTS double contourArea( const Vector<Point2f>& contour );
518 CV_EXPORTS RotatedRect minAreaRect( const Vector<Point>& points );
519 CV_EXPORTS RotatedRect minAreaRect( const Vector<Point2f>& points );
521 CV_EXPORTS void minEnclosingCircle( const Vector<Point>& points,
522 Point2f center, float& radius );
523 CV_EXPORTS void minEnclosingCircle( const Vector<Point2f>& points,
524 Point2f center, float& radius );
526 CV_EXPORTS Moments moments( const Vector<Point>& points );
527 CV_EXPORTS Moments moments( const Vector<Point2f>& points );
529 CV_EXPORTS double matchShapes( const Vector<Point2f>& contour1,
530 const Vector<Point2f>& contour2,
531 int method, double parameter );
532 CV_EXPORTS double matchShapes( const Vector<Point>& contour1,
533 const Vector<Point>& contour2,
534 int method, double parameter );
536 CV_EXPORTS void convexHull( const Vector<Point>& points,
537 Vector<int>& hull, bool clockwise=false );
538 CV_EXPORTS void convexHull( const Vector<Point>& points,
539 Vector<Point>& hull, bool clockwise=false );
540 CV_EXPORTS void convexHull( const Vector<Point2f>& points,
541 Vector<int>& hull, bool clockwise=false );
542 CV_EXPORTS void convexHull( const Vector<Point2f>& points,
543 Vector<Point2f>& hull, bool clockwise=false );
545 CV_EXPORTS bool isContourConvex( const Vector<Point>& contour );
546 CV_EXPORTS bool isContourConvex( const Vector<Point2f>& contour );
548 CV_EXPORTS RotatedRect fitEllipse( const Vector<Point>& points );
549 CV_EXPORTS RotatedRect fitEllipse( const Vector<Point2f>& points );
551 CV_EXPORTS Vec4f fitLine( const Vector<Point> points, int distType,
552 double param, double reps, double aeps );
553 CV_EXPORTS Vec4f fitLine( const Vector<Point2f> points, int distType,
554 double param, double reps, double aeps );
555 CV_EXPORTS Vec6f fitLine( const Vector<Point3f> points, int distType,
556 double param, double reps, double aeps );
558 CV_EXPORTS double pointPolygonTest( const Vector<Point>& contour,
559 Point2f pt, bool measureDist );
560 CV_EXPORTS double pointPolygonTest( const Vector<Point2f>& contour,
561 Point2f pt, bool measureDist );
563 CV_EXPORTS Mat estimateRigidTransform( const Vector<Point2f>& A,
564 const Vector<Point2f>& B,
567 CV_EXPORTS void updateMotionHistory( const Mat& silhouette, Mat& mhi,
568 double timestamp, double duration );
570 CV_EXPORTS void calcMotionGradient( const Mat& mhi, Mat& mask,
572 double delta1, double delta2,
573 int apertureSize=3 );
575 CV_EXPORTS double calcGlobalOrientation( const Mat& orientation, const Mat& mask,
576 const Mat& mhi, double timestamp,
578 // TODO: need good API for cvSegmentMotion
580 CV_EXPORTS RotatedRect CAMShift( const Mat& probImage, Rect& window,
581 TermCriteria criteria );
583 CV_EXPORTS int meanShift( const Mat& probImage, Rect& window,
584 TermCriteria criteria );
586 CV_EXPORTS int estimateAffine3D(const Vector<Point3f>& from, const Vector<Point3f>& to, Mat& out, Vector<uchar>& outliers, double param1 = 3.0, double param2 = 0.99);
588 class CV_EXPORTS KalmanFilter
592 KalmanFilter(int dynamParams, int measureParams, int controlParams=0);
593 void init(int dynamParams, int measureParams, int controlParams=0);
595 const Mat& predict(const Mat& control=Mat());
596 const Mat& correct(const Mat& measurement);
598 Mat statePre; // predicted state (x'(k)):
599 // x(k)=A*x(k-1)+B*u(k)
600 Mat statePost; // corrected state (x(k)):
601 // x(k)=x'(k)+K(k)*(z(k)-H*x'(k))
602 Mat transitionMatrix; // state transition matrix (A)
603 Mat controlMatrix; // control matrix (B)
604 // (it is not used if there is no control)
605 Mat measurementMatrix; // measurement matrix (H)
606 Mat processNoiseCov; // process noise covariance matrix (Q)
607 Mat measurementNoiseCov;// measurement noise covariance matrix (R)
608 Mat errorCovPre; // priori error estimate covariance matrix (P'(k)):
609 // P'(k)=A*P(k-1)*At + Q)*/
610 Mat gain; // Kalman gain matrix (K(k)):
611 // K(k)=P'(k)*Ht*inv(H*P'(k)*Ht+R)
612 Mat errorCovPost; // posteriori error estimate covariance matrix (P(k)):
613 // P(k)=(I-K(k)*H)*P'(k)
614 Mat temp1; // temporary matrices
622 ///////////////////////////// Object Detection ////////////////////////////
624 CV_EXPORTS void groupRectangles(Vector<Rect>& rectList, int groupThreshold, double eps=0.2);
626 class CV_EXPORTS FeatureEvaluator
629 virtual ~FeatureEvaluator();
630 virtual bool read(const FileNode& node);
631 virtual int getFeatureType() const;
633 virtual bool setImage(const Mat&, Size origWinSize);
634 virtual int setWindow(Point);
636 virtual double calcOrd(int featureIdx, int pOffset) const;
637 virtual int calcCat(int featureIdx, int pOffset) const;
639 enum { HAAR = 0, LBP = 1 };
640 static Ptr<FeatureEvaluator> create(int type);
643 template<> inline void Ptr<CvHaarClassifierCascade>::delete_obj()
644 { cvReleaseHaarClassifierCascade(&obj); }
646 class CV_EXPORTS CascadeClassifier
649 struct CV_EXPORTS DTreeNode
652 float threshold; // for ordered features only
657 struct CV_EXPORTS DTree
662 struct CV_EXPORTS Stage
670 enum { DO_CANNY_PRUNING = CV_HAAR_DO_CANNY_PRUNING,
671 SCALE_IMAGE = CV_HAAR_SCALE_IMAGE,
672 FIND_BIGGEST_OBJECT = CV_HAAR_FIND_BIGGEST_OBJECT,
673 DO_ROUGH_SEARCH = CV_HAAR_DO_ROUGH_SEARCH };
676 CascadeClassifier(const String& filename);
677 ~CascadeClassifier();
680 bool load(const String& filename);
681 bool read(const FileNode& node);
682 void detectMultiScale( const Mat& image,
683 Vector<Rect>& objects,
684 double scaleFactor=1.1,
685 int minNeighbors=3, int flags=0,
686 Size minSize=Size());
688 //bool setImage( const Mat& image );
689 int runAt( Point pt );
697 Vector<Stage> stages;
698 Vector<DTree> classifiers;
699 Vector<DTreeNode> nodes;
700 Vector<float> leaves;
703 Ptr<FeatureEvaluator> feval;
704 Ptr<CvHaarClassifierCascade> oldCascade;
708 CV_EXPORTS void undistortPoints( const Vector<Point2f>& src, Vector<Point2f>& dst,
709 const Mat& cameraMatrix, const Mat& distCoeffs,
710 const Mat& R=Mat(), const Mat& P=Mat());
712 CV_EXPORTS Mat Rodrigues(const Mat& src);
713 CV_EXPORTS Mat Rodrigues(const Mat& src, Mat& jacobian);
715 enum { LMEDS=4, RANSAC=8 };
717 CV_EXPORTS Mat findHomography( const Vector<Point2f>& srcPoints,
718 const Vector<Point2f>& dstPoints,
719 Vector<bool>& mask, int method=0,
720 double ransacReprojThreshold=0 );
722 CV_EXPORTS Mat findHomography( const Vector<Point2f>& srcPoints,
723 const Vector<Point2f>& dstPoints,
724 int method=0, double ransacReprojThreshold=0 );
726 /* Computes RQ decomposition for 3x3 matrices */
727 CV_EXPORTS void RQDecomp3x3( const Mat& M, Mat& R, Mat& Q );
728 CV_EXPORTS Vec3d RQDecomp3x3( const Mat& M, Mat& R, Mat& Q,
729 Mat& Qx, Mat& Qy, Mat& Qz );
731 CV_EXPORTS void decomposeProjectionMatrix( const Mat& projMatrix, Mat& cameraMatrix,
732 Mat& rotMatrix, Mat& transVect );
733 CV_EXPORTS void decomposeProjectionMatrix( const Mat& projMatrix, Mat& cameraMatrix,
734 Mat& rotMatrix, Mat& transVect,
735 Mat& rotMatrixX, Mat& rotMatrixY,
736 Mat& rotMatrixZ, Vec3d& eulerAngles );
738 CV_EXPORTS void matMulDeriv( const Mat& A, const Mat& B, Mat& dABdA, Mat& dABdB );
740 CV_EXPORTS void composeRT( const Mat& rvec1, const Mat& tvec1,
741 const Mat& rvec2, const Mat& tvec2,
742 Mat& rvec3, Mat& tvec3 );
744 CV_EXPORTS void composeRT( const Mat& rvec1, const Mat& tvec1,
745 const Mat& rvec2, const Mat& tvec2,
746 Mat& rvec3, Mat& tvec3,
747 Mat& dr3dr1, Mat& dr3dt1,
748 Mat& dr3dr2, Mat& dr3dt2,
749 Mat& dt3dr1, Mat& dt3dt1,
750 Mat& dt3dr2, Mat& dt3dt2 );
752 CV_EXPORTS void projectPoints( const Vector<Point3f>& objectPoints,
753 const Mat& rvec, const Mat& tvec,
754 const Mat& cameraMatrix,
755 const Mat& distCoeffs,
756 Vector<Point2f>& imagePoints );
758 CV_EXPORTS void projectPoints( const Vector<Point3f>& objectPoints,
759 const Mat& rvec, const Mat& tvec,
760 const Mat& cameraMatrix,
761 const Mat& distCoeffs,
762 Vector<Point2f>& imagePoints,
763 Mat& dpdrot, Mat& dpdt, Mat& dpdf,
764 Mat& dpdc, Mat& dpddist,
765 double aspectRatio=0 );
767 CV_EXPORTS void solvePnP( const Vector<Point3f>& objectPoints,
768 const Vector<Point2f>& imagePoints,
769 const Mat& cameraMatrix,
770 const Mat& distCoeffs,
771 Mat& rvec, Mat& tvec,
772 bool useExtrinsicGuess=false );
774 CV_EXPORTS Mat initCameraMatrix2D( const Vector<Vector<Point3f> >& objectPoints,
775 const Vector<Vector<Point2f> >& imagePoints,
776 Size imageSize, double aspectRatio=1. );
778 enum { CALIB_CB_ADAPTIVE_THRESH = CV_CALIB_CB_ADAPTIVE_THRESH,
779 CALIB_CB_NORMALIZE_IMAGE = CV_CALIB_CB_NORMALIZE_IMAGE,
780 CALIB_CB_FILTER_QUADS = CV_CALIB_CB_FILTER_QUADS };
782 CV_EXPORTS bool findChessboardCorners( const Mat& image, Size patternSize,
783 Vector<Point2f>& corners,
784 int flags=CV_CALIB_CB_ADAPTIVE_THRESH+
785 CV_CALIB_CB_NORMALIZE_IMAGE );
787 CV_EXPORTS void drawChessboardCorners( Mat& image, Size patternSize,
788 const Vector<Point2f>& corners,
789 bool patternWasFound );
793 CALIB_USE_INTRINSIC_GUESS = CV_CALIB_USE_INTRINSIC_GUESS,
794 CALIB_FIX_ASPECT_RATIO = CV_CALIB_FIX_ASPECT_RATIO,
795 CALIB_FIX_PRINCIPAL_POINT = CV_CALIB_FIX_PRINCIPAL_POINT,
796 CALIB_ZERO_TANGENT_DIST = CV_CALIB_ZERO_TANGENT_DIST,
797 CALIB_FIX_FOCAL_LENGTH = CV_CALIB_FIX_FOCAL_LENGTH,
798 CALIB_FIX_K1 = CV_CALIB_FIX_K1,
799 CALIB_FIX_K2 = CV_CALIB_FIX_K2,
800 CALIB_FIX_K3 = CV_CALIB_FIX_K3,
802 CALIB_FIX_INTRINSIC = CV_CALIB_FIX_INTRINSIC,
803 CALIB_SAME_FOCAL_LENGTH = CV_CALIB_SAME_FOCAL_LENGTH,
804 // for stereo rectification
805 CALIB_ZERO_DISPARITY = CV_CALIB_ZERO_DISPARITY
808 CV_EXPORTS void calibrateCamera( const Vector<Vector<Point3f> >& objectPoints,
809 const Vector<Vector<Point2f> >& imagePoints,
811 Mat& cameraMatrix, Mat& distCoeffs,
812 Vector<Mat>& rvecs, Vector<Mat>& tvecs,
815 CV_EXPORTS void calibrationMatrixValues( const Mat& cameraMatrix,
817 double apertureWidth,
818 double apertureHeight,
822 Point2d& principalPoint,
823 double& aspectRatio );
825 CV_EXPORTS void stereoCalibrate( const Vector<Vector<Point3f> >& objectPoints,
826 const Vector<Vector<Point2f> >& imagePoints1,
827 const Vector<Vector<Point2f> >& imagePoints2,
828 Mat& cameraMatrix1, Mat& distCoeffs1,
829 Mat& cameraMatrix2, Mat& distCoeffs2,
830 Size imageSize, Mat& R, Mat& T,
832 TermCriteria criteria = TermCriteria(TermCriteria::COUNT+
833 TermCriteria::EPS, 30, 1e-6),
834 int flags=CALIB_FIX_INTRINSIC );
836 CV_EXPORTS void stereoRectify( const Mat& cameraMatrix1, const Mat& distCoeffs1,
837 const Mat& cameraMatrix2, const Mat& distCoeffs2,
838 Size imageSize, const Mat& R, const Mat& T,
839 Mat& R1, Mat& R2, Mat& P1, Mat& P2, Mat& Q,
840 int flags=CALIB_ZERO_DISPARITY );
842 CV_EXPORTS bool stereoRectifyUncalibrated( const Vector<Point2f>& points1,
843 const Vector<Point2f>& points2,
844 const Mat& F, Size imgSize,
846 double threshold=5 );
848 CV_EXPORTS void convertPointsHomogeneous( const Vector<Point2f>& src,
849 Vector<Point3f>& dst );
850 CV_EXPORTS void convertPointsHomogeneous( const Vector<Point3f>& src,
851 Vector<Point2f>& dst );
855 FM_7POINT = CV_FM_7POINT,
856 FM_8POINT = CV_FM_8POINT,
857 FM_LMEDS = CV_FM_LMEDS,
858 FM_RANSAC = CV_FM_RANSAC
861 CV_EXPORTS Mat findFundamentalMat( const Vector<Point2f>& points1,
862 const Vector<Point2f>& points2,
864 int method=FM_RANSAC,
865 double param1=3., double param2=0.99 );
867 CV_EXPORTS Mat findFundamentalMat( const Vector<Point2f>& points1,
868 const Vector<Point2f>& points2,
869 int method=FM_RANSAC,
870 double param1=3., double param2=0.99 );
872 CV_EXPORTS void computeCorrespondEpilines( const Vector<Point2f>& points1,
873 int whichImage, const Mat& F,
874 Vector<Vec3f>& lines );
876 template<> inline void Ptr<CvStereoBMState>::delete_obj()
877 { cvReleaseStereoBMState(&obj); }
879 // Block matching stereo correspondence algorithm
880 class CV_EXPORTS StereoBM
882 enum { NORMALIZED_RESPONSE = CV_STEREO_BM_NORMALIZED_RESPONSE,
883 BASIC_PRESET=CV_STEREO_BM_BASIC,
884 FISH_EYE_PRESET=CV_STEREO_BM_FISH_EYE,
885 NARROW_PRESET=CV_STEREO_BM_NARROW };
888 StereoBM(int preset, int ndisparities=0, int SADWindowSize=21);
889 void init(int preset, int ndisparities=0, int SADWindowSize=21);
890 void operator()( const Mat& left, const Mat& right, Mat& disparity );
892 Ptr<CvStereoBMState> state;
895 CV_EXPORTS void reprojectImageTo3D( const Mat& disparity,
896 Mat& _3dImage, const Mat& Q,
897 bool handleMissingValues=false );
899 class CV_EXPORTS KeyPoint
902 KeyPoint() : pt(0,0), size(0), angle(-1), response(0), octave(0) {}
903 KeyPoint(Point2f _pt, float _size, float _angle=-1, float _response=0, int _octave=0)
904 : pt(_pt), size(_size), angle(_angle), response(_response), octave(_octave) {}
905 KeyPoint(float x, float y, float _size, float _angle=-1, float _response=0, int _octave=0)
906 : pt(x, y), size(_size), angle(_angle), response(_response), octave(_octave) {}
915 CV_EXPORTS void write(FileStorage& fs, const String& name, const Vector<KeyPoint>& keypoints);
916 CV_EXPORTS void read(const FileNode& node, Vector<KeyPoint>& keypoints);
918 class CV_EXPORTS SURF : public CvSURFParams
922 SURF(double _hessianThreshold, bool _extended=false);
924 int descriptorSize() const;
925 void operator()(const Mat& img, const Mat& mask,
926 Vector<KeyPoint>& keypoints) const;
927 void operator()(const Mat& img, const Mat& mask,
928 Vector<KeyPoint>& keypoints,
929 Vector<float>& descriptors,
930 bool useProvidedKeypoints=false) const;
934 class CV_EXPORTS MSER : public CvMSERParams
938 MSER( int _delta, int _min_area, int _max_area,
939 float _max_variation, float _min_diversity,
940 int _max_evolution, double _area_threshold,
941 double _min_margin, int _edge_blur_size );
942 Vector<Vector<Point> > operator()(Mat& image, const Mat& mask) const;
946 class CV_EXPORTS StarDetector : CvStarDetectorParams
950 StarDetector(int _maxSize, int _responseThreshold,
951 int _lineThresholdProjected,
952 int _lineThresholdBinarized,
953 int _suppressNonmaxSize);
955 void operator()(const Mat& image, Vector<KeyPoint>& keypoints) const;
960 //////////////////////////////////////////////////////////////////////////////////////////
962 class CV_EXPORTS CvLevMarq
966 CvLevMarq( int nparams, int nerrs, CvTermCriteria criteria=
967 cvTermCriteria(CV_TERMCRIT_EPS+CV_TERMCRIT_ITER,30,DBL_EPSILON),
968 bool completeSymmFlag=false );
970 void init( int nparams, int nerrs, CvTermCriteria criteria=
971 cvTermCriteria(CV_TERMCRIT_EPS+CV_TERMCRIT_ITER,30,DBL_EPSILON),
972 bool completeSymmFlag=false );
973 bool update( const CvMat*& param, CvMat*& J, CvMat*& err );
974 bool updateAlt( const CvMat*& param, CvMat*& JtJ, CvMat*& JtErr, double*& errNorm );
978 enum { DONE=0, STARTED=1, CALC_J=2, CHECK_ERR=3 };
990 double prevErrNorm, errNorm;
992 CvTermCriteria criteria;
995 bool completeSymmFlag;
999 // 2009-01-12, Xavier Delacour <xavier.delacour@gmail.com>
1005 struct CvLSHOperations
1007 virtual ~CvLSHOperations() {}
1009 virtual int vector_add(const void* data) = 0;
1010 virtual void vector_remove(int i) = 0;
1011 virtual const void* vector_lookup(int i) = 0;
1012 virtual void vector_reserve(int n) = 0;
1013 virtual unsigned int vector_count() = 0;
1015 virtual void hash_insert(lsh_hash h, int l, int i) = 0;
1016 virtual void hash_remove(lsh_hash h, int l, int i) = 0;
1017 virtual int hash_lookup(lsh_hash h, int l, int* ret_i, int ret_i_max) = 0;
1021 #endif /* __cplusplus */
1023 #endif /* _CV_HPP_ */