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( const 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( const 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, vector<Point2f>& nextPts,
389 vector<uchar>& status, vector<float>& err,
390 Size winSize=Size(15,15), int maxLevel=3,
391 TermCriteria criteria=TermCriteria(
392 TermCriteria::COUNT+TermCriteria::EPS,
394 double derivLambda=0.5,
397 CV_EXPORTS void calcOpticalFlowFarneback( const Mat& prev0, const Mat& next0,
398 Mat& flow0, double pyr_scale, int levels, int winsize,
399 int iterations, int poly_n, double poly_sigma, int flags );
402 template<> inline void Ptr<CvHistogram>::delete_obj()
403 { cvReleaseHist(&obj); }
405 CV_EXPORTS void calcHist( const Mat* images, int nimages,
406 const int* channels, const Mat& mask,
407 MatND& hist, int dims, const int* histSize,
408 const float** ranges, bool uniform=true,
409 bool accumulate=false );
411 CV_EXPORTS void calcHist( const Mat* images, int nimages,
412 const int* channels, const Mat& mask,
413 SparseMat& hist, int dims, const int* histSize,
414 const float** ranges, bool uniform=true,
415 bool accumulate=false );
417 CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
418 const int* channels, const MatND& hist,
419 Mat& backProject, const float** ranges,
420 double scale=1, bool uniform=true );
422 CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
423 const int* channels, const SparseMat& hist,
424 Mat& backProject, const float** ranges,
425 double scale=1, bool uniform=true );
427 CV_EXPORTS double compareHist( const MatND& H1, const MatND& H2, int method );
429 CV_EXPORTS double compareHist( const SparseMat& H1, const SparseMat& H2, int method );
431 CV_EXPORTS void equalizeHist( const Mat& src, Mat& dst );
433 CV_EXPORTS void watershed( const Mat& image, Mat& markers );
435 enum { INPAINT_NS=CV_INPAINT_NS, INPAINT_TELEA=CV_INPAINT_TELEA };
437 CV_EXPORTS void inpaint( const Mat& src, const Mat& inpaintMask,
438 Mat& dst, double inpaintRange, int flags );
440 CV_EXPORTS void distanceTransform( const Mat& src, Mat& dst, Mat& labels,
441 int distanceType, int maskSize );
443 CV_EXPORTS void distanceTransform( const Mat& src, Mat& dst,
444 int distanceType, int maskSize );
446 enum { FLOODFILL_FIXED_RANGE = 1 << 16,
447 FLOODFILL_MASK_ONLY = 1 << 17 };
449 CV_EXPORTS int floodFill( Mat& image,
450 Point seedPoint, Scalar newVal, Rect* rect=0,
451 Scalar loDiff=Scalar(), Scalar upDiff=Scalar(),
454 CV_EXPORTS int floodFill( Mat& image, Mat& mask,
455 Point seedPoint, Scalar newVal, Rect* rect=0,
456 Scalar loDiff=Scalar(), Scalar upDiff=Scalar(),
459 CV_EXPORTS void cvtColor( const Mat& src, Mat& dst, int code, int dstCn=0 );
461 class CV_EXPORTS Moments
465 Moments(double m00, double m10, double m01, double m20, double m11,
466 double m02, double m30, double m21, double m12, double m03 );
467 Moments( const CvMoments& moments );
468 operator CvMoments() const;
470 double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03; // spatial moments
471 double mu20, mu11, mu02, mu30, mu21, mu12, mu03; // central moments
472 double nu20, nu11, nu02, nu30, nu21, nu12, nu03; // central normalized moments
475 CV_EXPORTS Moments moments( const Mat& array, bool binaryImage=false );
477 CV_EXPORTS void HuMoments( const Moments& moments, double hu[7] );
479 enum { TM_SQDIFF=CV_TM_SQDIFF, TM_SQDIFF_NORMED=CV_TM_SQDIFF_NORMED,
480 TM_CCORR=CV_TM_CCORR, TM_CCORR_NORMED=CV_TM_CCORR_NORMED,
481 TM_CCOEFF=CV_TM_CCOEFF, TM_CCOEFF_NORMED=CV_TM_CCOEFF_NORMED };
483 CV_EXPORTS void matchTemplate( const Mat& image, const Mat& templ, Mat& result, int method );
485 enum { RETR_EXTERNAL=CV_RETR_EXTERNAL, RETR_LIST=CV_RETR_LIST,
486 RETR_CCOMP=CV_RETR_CCOMP, RETR_TREE=CV_RETR_TREE };
488 enum { CHAIN_APPROX_NONE=CV_CHAIN_APPROX_NONE,
489 CHAIN_APPROX_SIMPLE=CV_CHAIN_APPROX_SIMPLE,
490 CHAIN_APPROX_TC89_L1=CV_CHAIN_APPROX_TC89_L1,
491 CHAIN_APPROX_TC89_KCOS=CV_CHAIN_APPROX_TC89_KCOS };
493 CV_EXPORTS void findContours( const Mat& image, vector<vector<Point> >& contours,
494 vector<Vec4i>& hierarchy, int mode,
495 int method, Point offset=Point());
497 CV_EXPORTS void findContours( const Mat& image, vector<vector<Point> >& contours,
498 int mode, int method, Point offset=Point());
500 CV_EXPORTS void drawContours( Mat& image, const vector<vector<Point> >& contours,
501 int contourIdx, const Scalar& color,
502 int thickness=1, int lineType=8,
503 const vector<Vec4i>& hierarchy=vector<Vec4i>(),
504 int maxLevel=INT_MAX, Point offset=Point() );
506 CV_EXPORTS void approxPolyDP( const Mat& curve,
507 vector<Point>& approxCurve,
508 double epsilon, bool closed );
509 CV_EXPORTS void approxPolyDP( const Mat& curve,
510 vector<Point2f>& approxCurve,
511 double epsilon, bool closed );
513 CV_EXPORTS double arcLength( const Mat& curve, bool closed );
514 CV_EXPORTS Rect boundingRect( const Mat& points );
515 CV_EXPORTS double contourArea( const Mat& contour );
516 CV_EXPORTS RotatedRect minAreaRect( const Mat& points );
517 CV_EXPORTS void minEnclosingCircle( const Mat& points,
518 Point2f& center, float& radius );
519 CV_EXPORTS double matchShapes( const Mat& contour1,
521 int method, double parameter );
523 CV_EXPORTS void convexHull( const Mat& points, vector<int>& hull, bool clockwise=false );
524 CV_EXPORTS void convexHull( const Mat& points, vector<Point>& hull, bool clockwise=false );
525 CV_EXPORTS void convexHull( const Mat& points, vector<Point2f>& hull, bool clockwise=false );
527 CV_EXPORTS bool isContourConvex( const Mat& contour );
529 CV_EXPORTS RotatedRect fitEllipse( const Mat& points );
531 CV_EXPORTS void fitLine( const Mat& points, Vec4f& line, int distType,
532 double param, double reps, double aeps );
533 CV_EXPORTS void fitLine( const Mat& points, Vec6f& line, int distType,
534 double param, double reps, double aeps );
536 CV_EXPORTS double pointPolygonTest( const Mat& contour,
537 Point2f pt, bool measureDist );
539 CV_EXPORTS Mat estimateRigidTransform( const Mat& A, const Mat& B,
542 CV_EXPORTS void updateMotionHistory( const Mat& silhouette, Mat& mhi,
543 double timestamp, double duration );
545 CV_EXPORTS void calcMotionGradient( const Mat& mhi, Mat& mask,
547 double delta1, double delta2,
548 int apertureSize=3 );
550 CV_EXPORTS double calcGlobalOrientation( const Mat& orientation, const Mat& mask,
551 const Mat& mhi, double timestamp,
553 // TODO: need good API for cvSegmentMotion
555 CV_EXPORTS RotatedRect CamShift( const Mat& probImage, Rect& window,
556 TermCriteria criteria );
558 CV_EXPORTS int meanShift( const Mat& probImage, Rect& window,
559 TermCriteria criteria );
561 CV_EXPORTS int estimateAffine3D(const Mat& from, const Mat& to, Mat& out,
562 vector<uchar>& outliers,
563 double param1 = 3.0, double param2 = 0.99);
565 class CV_EXPORTS KalmanFilter
569 KalmanFilter(int dynamParams, int measureParams, int controlParams=0);
570 void init(int dynamParams, int measureParams, int controlParams=0);
572 const Mat& predict(const Mat& control=Mat());
573 const Mat& correct(const Mat& measurement);
575 Mat statePre; // predicted state (x'(k)):
576 // x(k)=A*x(k-1)+B*u(k)
577 Mat statePost; // corrected state (x(k)):
578 // x(k)=x'(k)+K(k)*(z(k)-H*x'(k))
579 Mat transitionMatrix; // state transition matrix (A)
580 Mat controlMatrix; // control matrix (B)
581 // (it is not used if there is no control)
582 Mat measurementMatrix; // measurement matrix (H)
583 Mat processNoiseCov; // process noise covariance matrix (Q)
584 Mat measurementNoiseCov;// measurement noise covariance matrix (R)
585 Mat errorCovPre; // priori error estimate covariance matrix (P'(k)):
586 // P'(k)=A*P(k-1)*At + Q)*/
587 Mat gain; // Kalman gain matrix (K(k)):
588 // K(k)=P'(k)*Ht*inv(H*P'(k)*Ht+R)
589 Mat errorCovPost; // posteriori error estimate covariance matrix (P(k)):
590 // P(k)=(I-K(k)*H)*P'(k)
591 Mat temp1; // temporary matrices
599 ///////////////////////////// Object Detection ////////////////////////////
601 CV_EXPORTS void groupRectangles(vector<Rect>& rectList, int groupThreshold, double eps=0.2);
603 class CV_EXPORTS FeatureEvaluator
606 enum { HAAR = 0, LBP = 1 };
607 virtual ~FeatureEvaluator();
608 virtual bool read(const FileNode& node);
609 virtual Ptr<FeatureEvaluator> clone() const;
610 virtual int getFeatureType() const;
612 virtual bool setImage(const Mat&, Size origWinSize);
613 virtual bool setWindow(Point p);
615 virtual double calcOrd(int featureIdx) const;
616 virtual int calcCat(int featureIdx) const;
618 static Ptr<FeatureEvaluator> create(int type);
621 template<> inline void Ptr<CvHaarClassifierCascade>::delete_obj()
622 { cvReleaseHaarClassifierCascade(&obj); }
624 class CV_EXPORTS CascadeClassifier
627 struct CV_EXPORTS DTreeNode
630 float threshold; // for ordered features only
635 struct CV_EXPORTS DTree
640 struct CV_EXPORTS Stage
648 enum { DO_CANNY_PRUNING = CV_HAAR_DO_CANNY_PRUNING,
649 SCALE_IMAGE = CV_HAAR_SCALE_IMAGE,
650 FIND_BIGGEST_OBJECT = CV_HAAR_FIND_BIGGEST_OBJECT,
651 DO_ROUGH_SEARCH = CV_HAAR_DO_ROUGH_SEARCH };
654 CascadeClassifier(const string& filename);
655 ~CascadeClassifier();
658 bool load(const string& filename);
659 bool read(const FileNode& node);
660 void detectMultiScale( const Mat& image,
661 vector<Rect>& objects,
662 double scaleFactor=1.1,
663 int minNeighbors=3, int flags=0,
664 Size minSize=Size());
666 bool setImage( Ptr<FeatureEvaluator>&, const Mat& );
667 int runAt( Ptr<FeatureEvaluator>&, Point );
676 vector<Stage> stages;
677 vector<DTree> classifiers;
678 vector<DTreeNode> nodes;
679 vector<float> leaves;
682 Ptr<FeatureEvaluator> feval;
683 Ptr<CvHaarClassifierCascade> oldCascade;
687 CV_EXPORTS void undistortPoints( const Mat& src, vector<Point2f>& dst,
688 const Mat& cameraMatrix, const Mat& distCoeffs,
689 const Mat& R=Mat(), const Mat& P=Mat());
690 CV_EXPORTS void undistortPoints( const Mat& src, Mat& dst,
691 const Mat& cameraMatrix, const Mat& distCoeffs,
692 const Mat& R=Mat(), const Mat& P=Mat());
694 CV_EXPORTS void Rodrigues(const Mat& src, Mat& dst);
695 CV_EXPORTS void Rodrigues(const Mat& src, Mat& dst, Mat& jacobian);
697 enum { LMEDS=4, RANSAC=8 };
699 CV_EXPORTS Mat findHomography( const Mat& srcPoints,
700 const Mat& dstPoints,
701 Mat& mask, int method=0,
702 double ransacReprojThreshold=0 );
704 CV_EXPORTS Mat findHomography( const Mat& srcPoints,
705 const Mat& dstPoints,
706 vector<uchar>& mask, int method=0,
707 double ransacReprojThreshold=0 );
709 CV_EXPORTS Mat findHomography( const Mat& srcPoints,
710 const Mat& dstPoints,
711 int method=0, double ransacReprojThreshold=0 );
713 /* Computes RQ decomposition for 3x3 matrices */
714 CV_EXPORTS void RQDecomp3x3( const Mat& M, Mat& R, Mat& Q );
715 CV_EXPORTS Vec3d RQDecomp3x3( const Mat& M, Mat& R, Mat& Q,
716 Mat& Qx, Mat& Qy, Mat& Qz );
718 CV_EXPORTS void decomposeProjectionMatrix( const Mat& projMatrix, Mat& cameraMatrix,
719 Mat& rotMatrix, Mat& transVect );
720 CV_EXPORTS void decomposeProjectionMatrix( const Mat& projMatrix, Mat& cameraMatrix,
721 Mat& rotMatrix, Mat& transVect,
722 Mat& rotMatrixX, Mat& rotMatrixY,
723 Mat& rotMatrixZ, Vec3d& eulerAngles );
725 CV_EXPORTS void matMulDeriv( const Mat& A, const Mat& B, Mat& dABdA, Mat& dABdB );
727 CV_EXPORTS void composeRT( const Mat& rvec1, const Mat& tvec1,
728 const Mat& rvec2, const Mat& tvec2,
729 Mat& rvec3, Mat& tvec3 );
731 CV_EXPORTS void composeRT( const Mat& rvec1, const Mat& tvec1,
732 const Mat& rvec2, const Mat& tvec2,
733 Mat& rvec3, Mat& tvec3,
734 Mat& dr3dr1, Mat& dr3dt1,
735 Mat& dr3dr2, Mat& dr3dt2,
736 Mat& dt3dr1, Mat& dt3dt1,
737 Mat& dt3dr2, Mat& dt3dt2 );
739 CV_EXPORTS void projectPoints( const Mat& objectPoints,
740 const Mat& rvec, const Mat& tvec,
741 const Mat& cameraMatrix,
742 const Mat& distCoeffs,
743 vector<Point2f>& imagePoints );
745 CV_EXPORTS void projectPoints( const Mat& objectPoints,
746 const Mat& rvec, const Mat& tvec,
747 const Mat& cameraMatrix,
748 const Mat& distCoeffs,
749 vector<Point2f>& imagePoints,
750 Mat& dpdrot, Mat& dpdt, Mat& dpdf,
751 Mat& dpdc, Mat& dpddist,
752 double aspectRatio=0 );
754 CV_EXPORTS void solvePnP( const Mat& objectPoints,
755 const Mat& imagePoints,
756 const Mat& cameraMatrix,
757 const Mat& distCoeffs,
758 Mat& rvec, Mat& tvec,
759 bool useExtrinsicGuess=false );
761 CV_EXPORTS Mat initCameraMatrix2D( const vector<vector<Point3f> >& objectPoints,
762 const vector<vector<Point2f> >& imagePoints,
763 Size imageSize, double aspectRatio=1. );
765 enum { CALIB_CB_ADAPTIVE_THRESH = CV_CALIB_CB_ADAPTIVE_THRESH,
766 CALIB_CB_NORMALIZE_IMAGE = CV_CALIB_CB_NORMALIZE_IMAGE,
767 CALIB_CB_FILTER_QUADS = CV_CALIB_CB_FILTER_QUADS };
769 CV_EXPORTS bool findChessboardCorners( const Mat& image, Size patternSize,
770 vector<Point2f>& corners,
771 int flags=CV_CALIB_CB_ADAPTIVE_THRESH+
772 CV_CALIB_CB_NORMALIZE_IMAGE );
774 CV_EXPORTS void drawChessboardCorners( Mat& image, Size patternSize,
776 bool patternWasFound );
780 CALIB_USE_INTRINSIC_GUESS = CV_CALIB_USE_INTRINSIC_GUESS,
781 CALIB_FIX_ASPECT_RATIO = CV_CALIB_FIX_ASPECT_RATIO,
782 CALIB_FIX_PRINCIPAL_POINT = CV_CALIB_FIX_PRINCIPAL_POINT,
783 CALIB_ZERO_TANGENT_DIST = CV_CALIB_ZERO_TANGENT_DIST,
784 CALIB_FIX_FOCAL_LENGTH = CV_CALIB_FIX_FOCAL_LENGTH,
785 CALIB_FIX_K1 = CV_CALIB_FIX_K1,
786 CALIB_FIX_K2 = CV_CALIB_FIX_K2,
787 CALIB_FIX_K3 = CV_CALIB_FIX_K3,
789 CALIB_FIX_INTRINSIC = CV_CALIB_FIX_INTRINSIC,
790 CALIB_SAME_FOCAL_LENGTH = CV_CALIB_SAME_FOCAL_LENGTH,
791 // for stereo rectification
792 CALIB_ZERO_DISPARITY = CV_CALIB_ZERO_DISPARITY
795 CV_EXPORTS void calibrateCamera( const vector<vector<Point3f> >& objectPoints,
796 const vector<vector<Point2f> >& imagePoints,
798 Mat& cameraMatrix, Mat& distCoeffs,
799 vector<Mat>& rvecs, vector<Mat>& tvecs,
802 CV_EXPORTS void calibrationMatrixValues( const Mat& cameraMatrix,
804 double apertureWidth,
805 double apertureHeight,
809 Point2d& principalPoint,
810 double& aspectRatio );
812 CV_EXPORTS void stereoCalibrate( const vector<vector<Point3f> >& objectPoints,
813 const vector<vector<Point2f> >& imagePoints1,
814 const vector<vector<Point2f> >& imagePoints2,
815 Mat& cameraMatrix1, Mat& distCoeffs1,
816 Mat& cameraMatrix2, Mat& distCoeffs2,
817 Size imageSize, Mat& R, Mat& T,
819 TermCriteria criteria = TermCriteria(TermCriteria::COUNT+
820 TermCriteria::EPS, 30, 1e-6),
821 int flags=CALIB_FIX_INTRINSIC );
823 CV_EXPORTS void stereoRectify( const Mat& cameraMatrix1, const Mat& distCoeffs1,
824 const Mat& cameraMatrix2, const Mat& distCoeffs2,
825 Size imageSize, const Mat& R, const Mat& T,
826 Mat& R1, Mat& R2, Mat& P1, Mat& P2, Mat& Q,
827 int flags=CALIB_ZERO_DISPARITY );
829 CV_EXPORTS bool stereoRectifyUncalibrated( const Mat& points1,
831 const Mat& F, Size imgSize,
833 double threshold=5 );
835 CV_EXPORTS void convertPointsHomogeneous( const Mat& src, vector<Point3f>& dst );
836 CV_EXPORTS void convertPointsHomogeneous( const Mat& src, vector<Point2f>& dst );
840 FM_7POINT = CV_FM_7POINT,
841 FM_8POINT = CV_FM_8POINT,
842 FM_LMEDS = CV_FM_LMEDS,
843 FM_RANSAC = CV_FM_RANSAC
846 CV_EXPORTS Mat findFundamentalMat( const Mat& points1, const Mat& points2,
847 vector<uchar>& mask, int method=FM_RANSAC,
848 double param1=3., double param2=0.99 );
850 CV_EXPORTS Mat findFundamentalMat( const Mat& points1, const Mat& points2,
851 int method=FM_RANSAC,
852 double param1=3., double param2=0.99 );
854 CV_EXPORTS void computeCorrespondEpilines( const Mat& points1,
855 int whichImage, const Mat& F,
856 vector<Vec3f>& lines );
858 template<> inline void Ptr<CvStereoBMState>::delete_obj()
859 { cvReleaseStereoBMState(&obj); }
861 // Block matching stereo correspondence algorithm
862 class CV_EXPORTS StereoBM
865 enum { NORMALIZED_RESPONSE = CV_STEREO_BM_NORMALIZED_RESPONSE,
866 BASIC_PRESET=CV_STEREO_BM_BASIC,
867 FISH_EYE_PRESET=CV_STEREO_BM_FISH_EYE,
868 NARROW_PRESET=CV_STEREO_BM_NARROW };
871 StereoBM(int preset, int ndisparities=0, int SADWindowSize=21);
872 void init(int preset, int ndisparities=0, int SADWindowSize=21);
873 void operator()( const Mat& left, const Mat& right, Mat& disparity );
875 Ptr<CvStereoBMState> state;
878 CV_EXPORTS void reprojectImageTo3D( const Mat& disparity,
879 Mat& _3dImage, const Mat& Q,
880 bool handleMissingValues=false );
882 class CV_EXPORTS KeyPoint
885 KeyPoint() : pt(0,0), size(0), angle(-1), response(0), octave(0), class_id(-1) {}
886 KeyPoint(Point2f _pt, float _size, float _angle=-1,
887 float _response=0, int _octave=0, int _class_id=-1)
888 : pt(_pt), size(_size), angle(_angle),
889 response(_response), octave(_octave), class_id(_class_id) {}
890 KeyPoint(float x, float y, float _size, float _angle=-1,
891 float _response=0, int _octave=0, int _class_id=-1)
892 : pt(x, y), size(_size), angle(_angle),
893 response(_response), octave(_octave), class_id(_class_id) {}
903 CV_EXPORTS void write(FileStorage& fs, const string& name, const vector<KeyPoint>& keypoints);
904 CV_EXPORTS void read(const FileNode& node, vector<KeyPoint>& keypoints);
906 class CV_EXPORTS SURF : public CvSURFParams
910 SURF(double _hessianThreshold, int _nOctaves=4,
911 int _nOctaveLayers=2, bool _extended=false);
913 int descriptorSize() const;
914 void operator()(const Mat& img, const Mat& mask,
915 vector<KeyPoint>& keypoints) const;
916 void operator()(const Mat& img, const Mat& mask,
917 vector<KeyPoint>& keypoints,
918 vector<float>& descriptors,
919 bool useProvidedKeypoints=false) const;
923 class CV_EXPORTS MSER : public CvMSERParams
927 MSER( int _delta, int _min_area, int _max_area,
928 float _max_variation, float _min_diversity,
929 int _max_evolution, double _area_threshold,
930 double _min_margin, int _edge_blur_size );
931 void operator()(Mat& image, vector<vector<Point> >& msers, const Mat& mask) const;
935 class CV_EXPORTS StarDetector : CvStarDetectorParams
939 StarDetector(int _maxSize, int _responseThreshold,
940 int _lineThresholdProjected,
941 int _lineThresholdBinarized,
942 int _suppressNonmaxSize);
944 void operator()(const Mat& image, vector<KeyPoint>& keypoints) const;
949 //////////////////////////////////////////////////////////////////////////////////////////
951 class CV_EXPORTS CvLevMarq
955 CvLevMarq( int nparams, int nerrs, CvTermCriteria criteria=
956 cvTermCriteria(CV_TERMCRIT_EPS+CV_TERMCRIT_ITER,30,DBL_EPSILON),
957 bool completeSymmFlag=false );
959 void init( int nparams, int nerrs, CvTermCriteria criteria=
960 cvTermCriteria(CV_TERMCRIT_EPS+CV_TERMCRIT_ITER,30,DBL_EPSILON),
961 bool completeSymmFlag=false );
962 bool update( const CvMat*& param, CvMat*& J, CvMat*& err );
963 bool updateAlt( const CvMat*& param, CvMat*& JtJ, CvMat*& JtErr, double*& errNorm );
967 enum { DONE=0, STARTED=1, CALC_J=2, CHECK_ERR=3 };
979 double prevErrNorm, errNorm;
981 CvTermCriteria criteria;
984 bool completeSymmFlag;
988 // 2009-01-12, Xavier Delacour <xavier.delacour@gmail.com>
994 struct CvLSHOperations
996 virtual ~CvLSHOperations() {}
998 virtual int vector_add(const void* data) = 0;
999 virtual void vector_remove(int i) = 0;
1000 virtual const void* vector_lookup(int i) = 0;
1001 virtual void vector_reserve(int n) = 0;
1002 virtual unsigned int vector_count() = 0;
1004 virtual void hash_insert(lsh_hash h, int l, int i) = 0;
1005 virtual void hash_remove(lsh_hash h, int l, int i) = 0;
1006 virtual int hash_lookup(lsh_hash h, int l, int* ret_i, int ret_i_max) = 0;
1010 #endif /* __cplusplus */
1012 #endif /* _CV_HPP_ */