开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 波变换 > 查看源码
cv.hpp
资源名称：gabor.rar　[点击查看]
上传用户：soukeisyuu
上传日期：2022-07-03
资源大小：5943k
文件大小：43k
源码类别：

波变换

开发平台：

Visual C++

cv.hpp：源码内容
  1. /*M///////////////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
  4. //
  5. //  By downloading, copying, installing or using the software you agree to this license.
  6. //  If you do not agree to this license, do not download, install,
  7. //  copy or use the software.
  8. //
  9. //
  10. //                           License Agreement
  11. //                For Open Source Computer Vision Library
  12. //
  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.
  16. //
  17. // Redistribution and use in source and binary forms, with or without modification,
  18. // are permitted provided that the following conditions are met:
  19. //
  20. //   * Redistribution's of source code must retain the above copyright notice,
  21. //     this list of conditions and the following disclaimer.
  22. //
  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.
  26. //
  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.
  29. //
  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.
  40. //
  41. //M*/
  43. #ifndef _CV_HPP_
  44. #define _CV_HPP_
  46. #ifdef __cplusplus
  48. namespace cv
  49. {
  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
  59. {
  60. public:
  61.     BaseRowFilter();
  62.     virtual ~BaseRowFilter();
  63.     virtual void operator()(const uchar* src, uchar* dst,
  64.                             int width, int cn) = 0;
  65.     int ksize, anchor;
  66. };
  69. class CV_EXPORTS BaseColumnFilter
  70. {
  71. public:
  72.     BaseColumnFilter();
  73.     virtual ~BaseColumnFilter();
  74.     virtual void operator()(const uchar** src, uchar* dst, int dststep,
  75.                             int dstcount, int width) = 0;
  76.     virtual void reset();
  77.     int ksize, anchor;
  78. };
  81. class CV_EXPORTS BaseFilter
  82. {
  83. public:
  84.     BaseFilter();
  85.     virtual ~BaseFilter();
  86.     virtual void operator()(const uchar** src, uchar* dst, int dststep,
  87.                             int dstcount, int width, int cn) = 0;
  88.     virtual void reset();
  89.     Size ksize;
  90.     Point anchor;
  91. };
  94. class CV_EXPORTS FilterEngine
  95. {
  96. public:
  97.     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;
  124.     
  125.     int srcType, dstType, bufType;
  126.     Size ksize;
  127.     Point anchor;
  128.     int maxWidth;
  129.     Size wholeSize;
  130.     Rect roi;
  131.     int dx1, dx2;
  132.     int rowBorderType, columnBorderType;
  133.     vector<int> borderTab;
  134.     int borderElemSize;
  135.     vector<uchar> ringBuf;
  136.     vector<uchar> srcRow;
  137.     vector<uchar> constBorderValue;
  138.     vector<uchar> constBorderRow;
  139.     int bufStep, startY, startY0, endY, rowCount, dstY;
  140.     vector<uchar*> rows;
  141.     
  142.     Ptr<BaseFilter> filter2D;
  143.     Ptr<BaseRowFilter> rowFilter;
  144.     Ptr<BaseColumnFilter> columnFilter;
  145. };
  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,
  154.                                             int symmetryType);
  156. CV_EXPORTS Ptr<BaseColumnFilter> getLinearColumnFilter(int bufType, int dstType,
  157.                                             const Mat& kernel, int anchor,
  158.                                             int symmetryType, double delta=0,
  159.                                             int bits=0);
  161. CV_EXPORTS Ptr<BaseFilter> getLinearFilter(int srcType, int dstType,
  162.                                            const Mat& kernel,
  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,
  195.                                                        double scale=1);
  196. CV_EXPORTS Ptr<FilterEngine> createBoxFilter( int srcType, int dstType, Size ksize,
  197.                                                  Point anchor=Point(-1,-1),
  198.                                                  bool normalize=true,
  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),
  232.                            bool normalize=true,
  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 )
  237. {
  238.     boxFilter( src, dst, -1, ksize, anchor, true, borderType );
  239. }
  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,
  272.                               int ksize, double k,
  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,
  393.                             30, 0.01),
  394.                            double derivLambda=0.5,
  395.                            int flags=0 );
  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 );
  400.     
  402. template<> inline void Ptr<CvHistogram>::delete_obj()
  403. { cvReleaseHist(&obj); }
  404.     
  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 );
  416.     
  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 );
  421.     
  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(),
  452.                           int flags=4 );
  454. CV_EXPORTS int floodFill( Mat& image, Mat& mask,
  455.                           Point seedPoint, Scalar newVal, Rect* rect=0,
  456.                           Scalar loDiff=Scalar(), Scalar upDiff=Scalar(),
  457.                           int flags=4 );
  459. CV_EXPORTS void cvtColor( const Mat& src, Mat& dst, int code, int dstCn=0 );
  461. class CV_EXPORTS Moments
  462. {
  463. public:
  464.     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;
  469.     
  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
  473. };
  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 );
  512.     
  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,
  520.                                const Mat& contour2,
  521.                                int method, double parameter );
  522.     
  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,
  540.                                        bool fullAffine );
  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,
  546.                                     Mat& orientation,
  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,
  552.                                          double duration );
  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
  566. {
  567. public:
  568.     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
  592.     Mat temp2;
  593.     Mat temp3;
  594.     Mat temp4;
  595.     Mat temp5;
  596. };
  599. ///////////////////////////// Object Detection ////////////////////////////
  601. CV_EXPORTS void groupRectangles(vector<Rect>& rectList, int groupThreshold, double eps=0.2);
  602.         
  603. class CV_EXPORTS FeatureEvaluator
  604. {
  605. public:    
  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;
  611.     
  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);
  619. };
  620.     
  621. template<> inline void Ptr<CvHaarClassifierCascade>::delete_obj()
  622. { cvReleaseHaarClassifierCascade(&obj); }    
  623.    
  624. class CV_EXPORTS CascadeClassifier
  625. {
  626. public:
  627.     struct CV_EXPORTS DTreeNode
  628.     {
  629.         int featureIdx;
  630.         float threshold; // for ordered features only
  631.         int left;
  632.         int right;
  633.     };
  634.     
  635.     struct CV_EXPORTS DTree
  636.     {
  637.         int nodeCount;
  638.     };
  639.     
  640.     struct CV_EXPORTS Stage
  641.     {
  642.         int first;
  643.         int ntrees;
  644.         float threshold;
  645.     };
  646.     
  647.     enum { BOOST = 0 };
  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 };
  653.     CascadeClassifier();
  654.     CascadeClassifier(const string& filename);
  655.     ~CascadeClassifier();
  656.     
  657.     bool empty() const;
  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());
  665.  
  666.     bool setImage( Ptr<FeatureEvaluator>&, const Mat& );
  667.     int runAt( Ptr<FeatureEvaluator>&, Point );
  669.     bool is_stump_based;
  671.     int stageType;
  672.     int featureType;
  673.     int ncategories;
  674.     Size origWinSize;
  675.     
  676.     vector<Stage> stages;
  677.     vector<DTree> classifiers;
  678.     vector<DTreeNode> nodes;
  679.     vector<float> leaves;
  680.     vector<int> subsets;
  682.     Ptr<FeatureEvaluator> feval;
  683.     Ptr<CvHaarClassifierCascade> oldCascade;
  684. };
  686.     
  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 );
  703.     
  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,
  775.                                        const Mat& corners,
  776.                                        bool patternWasFound );
  778. enum
  779. {
  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,
  788.     // only for stereo
  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
  793. };
  795. CV_EXPORTS void calibrateCamera( const vector<vector<Point3f> >& objectPoints,
  796.                                  const vector<vector<Point2f> >& imagePoints,
  797.                                  Size imageSize,
  798.                                  Mat& cameraMatrix, Mat& distCoeffs,
  799.                                  vector<Mat>& rvecs, vector<Mat>& tvecs,
  800.                                  int flags=0 );
  802. CV_EXPORTS void calibrationMatrixValues( const Mat& cameraMatrix,
  803.                                 Size imageSize,
  804.                                 double apertureWidth,
  805.                                 double apertureHeight,
  806.                                 double& fovx,
  807.                                 double& fovy,
  808.                                 double& focalLength,
  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,
  818.                                  Mat& E, Mat& F,
  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,
  830.                                            const Mat& points2,
  831.                                            const Mat& F, Size imgSize,
  832.                                            Mat& H1, Mat& H2,
  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 );
  838. enum
  839. { 
  840.     FM_7POINT = CV_FM_7POINT,
  841.     FM_8POINT = CV_FM_8POINT,
  842.     FM_LMEDS = CV_FM_LMEDS,
  843.     FM_RANSAC = CV_FM_RANSAC
  844. };
  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
  863. {
  864. public:
  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 };
  869.     
  870.     StereoBM();
  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;
  876. };
  878. CV_EXPORTS void reprojectImageTo3D( const Mat& disparity,
  879.                                     Mat& _3dImage, const Mat& Q,
  880.                                     bool handleMissingValues=false );
  882. class CV_EXPORTS KeyPoint
  883. {
  884. public:    
  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) {}
  894.     
  895.     Point2f pt;
  896.     float size;
  897.     float angle;
  898.     float response;
  899.     int octave;
  900.     int class_id;
  901. };
  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
  907. {
  908. public:
  909.     SURF();
  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;
  920. };
  923. class CV_EXPORTS MSER : public CvMSERParams
  924. {
  925. public:
  926.     MSER();
  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;
  932. };
  935. class CV_EXPORTS StarDetector : CvStarDetectorParams
  936. {
  937. public:
  938.     StarDetector();
  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;
  945. };
  946.     
  947. }
  949. //////////////////////////////////////////////////////////////////////////////////////////
  951. class CV_EXPORTS CvLevMarq
  952. {
  953. public:
  954.     CvLevMarq();
  955.     CvLevMarq( int nparams, int nerrs, CvTermCriteria criteria=
  956.         cvTermCriteria(CV_TERMCRIT_EPS+CV_TERMCRIT_ITER,30,DBL_EPSILON),
  957.         bool completeSymmFlag=false );
  958.     ~CvLevMarq();
  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 );
  965.     void clear();
  966.     void step();
  967.     enum { DONE=0, STARTED=1, CALC_J=2, CHECK_ERR=3 };
  969.     CvMat* mask;
  970.     CvMat* prevParam;
  971.     CvMat* param;
  972.     CvMat* J;
  973.     CvMat* err;
  974.     CvMat* JtJ;
  975.     CvMat* JtJN;
  976.     CvMat* JtErr;
  977.     CvMat* JtJV;
  978.     CvMat* JtJW;
  979.     double prevErrNorm, errNorm;
  980.     int lambdaLg10;
  981.     CvTermCriteria criteria;
  982.     int state;
  983.     int iters;
  984.     bool completeSymmFlag;
  985. };
  988. // 2009-01-12, Xavier Delacour <xavier.delacour@gmail.com>
  990. struct lsh_hash {
  991.   int h1, h2;
  992. };
  994. struct CvLSHOperations
  995. {
  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;
  1007. };
  1010. #endif /* __cplusplus */
  1012. #endif /* _CV_HPP_ */
  1014. /* End of file. */