contrib.hpp
Go to the documentation of this file.
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*/
42 
43 #ifndef __OPENCV_CONTRIB_HPP__
44 #define __OPENCV_CONTRIB_HPP__
45 
46 #include "opencv2/core/core.hpp"
50 
51 #ifdef __cplusplus
52 
53 /****************************************************************************************\
54 * Adaptive Skin Detector *
55 \****************************************************************************************/
56 
57 class CV_EXPORTS CvAdaptiveSkinDetector
58 {
59 private:
60  enum {
61  GSD_HUE_LT = 3,
62  GSD_HUE_UT = 33,
63  GSD_INTENSITY_LT = 15,
64  GSD_INTENSITY_UT = 250
65  };
66 
67  class CV_EXPORTS Histogram
68  {
69  private:
70  enum {
71  HistogramSize = (GSD_HUE_UT - GSD_HUE_LT + 1)
72  };
73 
74  protected:
75  int findCoverageIndex(double surfaceToCover, int defaultValue = 0);
76 
77  public:
78  CvHistogram *fHistogram;
79  Histogram();
80  virtual ~Histogram();
81 
82  void findCurveThresholds(int &x1, int &x2, double percent = 0.05);
83  void mergeWith(Histogram *source, double weight);
84  };
85 
86  int nStartCounter, nFrameCount, nSkinHueLowerBound, nSkinHueUpperBound, nMorphingMethod, nSamplingDivider;
87  double fHistogramMergeFactor, fHuePercentCovered;
88  Histogram histogramHueMotion, skinHueHistogram;
89  IplImage *imgHueFrame, *imgSaturationFrame, *imgLastGrayFrame, *imgMotionFrame, *imgFilteredFrame;
90  IplImage *imgShrinked, *imgTemp, *imgGrayFrame, *imgHSVFrame;
91 
92 protected:
93  void initData(IplImage *src, int widthDivider, int heightDivider);
94  void adaptiveFilter();
95 
96 public:
97 
98  enum {
99  MORPHING_METHOD_NONE = 0,
100  MORPHING_METHOD_ERODE = 1,
101  MORPHING_METHOD_ERODE_ERODE = 2,
102  MORPHING_METHOD_ERODE_DILATE = 3
103  };
104 
105  CvAdaptiveSkinDetector(int samplingDivider = 1, int morphingMethod = MORPHING_METHOD_NONE);
106  virtual ~CvAdaptiveSkinDetector();
107 
108  virtual void process(IplImage *inputBGRImage, IplImage *outputHueMask);
109 };
110 
111 
112 /****************************************************************************************\
113  * Fuzzy MeanShift Tracker *
114  \****************************************************************************************/
115 
116 class CV_EXPORTS CvFuzzyPoint {
117 public:
118  double x, y, value;
119 
120  CvFuzzyPoint(double _x, double _y);
121 };
122 
123 class CV_EXPORTS CvFuzzyCurve {
124 private:
125  std::vector<CvFuzzyPoint> points;
126  double value, centre;
127 
128  bool between(double x, double x1, double x2);
129 
130 public:
131  CvFuzzyCurve();
132  ~CvFuzzyCurve();
133 
134  void setCentre(double _centre);
135  double getCentre();
136  void clear();
137  void addPoint(double x, double y);
138  double calcValue(double param);
139  double getValue();
140  void setValue(double _value);
141 };
142 
143 class CV_EXPORTS CvFuzzyFunction {
144 public:
145  std::vector<CvFuzzyCurve> curves;
146 
147  CvFuzzyFunction();
148  ~CvFuzzyFunction();
149  void addCurve(CvFuzzyCurve *curve, double value = 0);
150  void resetValues();
151  double calcValue();
152  CvFuzzyCurve *newCurve();
153 };
154 
155 class CV_EXPORTS CvFuzzyRule {
156 private:
157  CvFuzzyCurve *fuzzyInput1, *fuzzyInput2;
158  CvFuzzyCurve *fuzzyOutput;
159 public:
160  CvFuzzyRule();
161  ~CvFuzzyRule();
162  void setRule(CvFuzzyCurve *c1, CvFuzzyCurve *c2, CvFuzzyCurve *o1);
163  double calcValue(double param1, double param2);
164  CvFuzzyCurve *getOutputCurve();
165 };
166 
167 class CV_EXPORTS CvFuzzyController {
168 private:
169  std::vector<CvFuzzyRule*> rules;
170 public:
173  void addRule(CvFuzzyCurve *c1, CvFuzzyCurve *c2, CvFuzzyCurve *o1);
174  double calcOutput(double param1, double param2);
175 };
176 
177 class CV_EXPORTS CvFuzzyMeanShiftTracker
178 {
179 private:
180  class FuzzyResizer
181  {
182  private:
183  CvFuzzyFunction iInput, iOutput;
184  CvFuzzyController fuzzyController;
185  public:
186  FuzzyResizer();
187  int calcOutput(double edgeDensity, double density);
188  };
189 
190  class SearchWindow
191  {
192  public:
193  FuzzyResizer *fuzzyResizer;
194  int x, y;
195  int width, height, maxWidth, maxHeight, ellipseHeight, ellipseWidth;
196  int ldx, ldy, ldw, ldh, numShifts, numIters;
197  int xGc, yGc;
198  long m00, m01, m10, m11, m02, m20;
199  double ellipseAngle;
200  double density;
201  unsigned int depthLow, depthHigh;
202  int verticalEdgeLeft, verticalEdgeRight, horizontalEdgeTop, horizontalEdgeBottom;
203 
204  SearchWindow();
205  ~SearchWindow();
206  void setSize(int _x, int _y, int _width, int _height);
207  void initDepthValues(IplImage *maskImage, IplImage *depthMap);
208  bool shift();
209  void extractInfo(IplImage *maskImage, IplImage *depthMap, bool initDepth);
210  void getResizeAttribsEdgeDensityLinear(int &resizeDx, int &resizeDy, int &resizeDw, int &resizeDh);
211  void getResizeAttribsInnerDensity(int &resizeDx, int &resizeDy, int &resizeDw, int &resizeDh);
212  void getResizeAttribsEdgeDensityFuzzy(int &resizeDx, int &resizeDy, int &resizeDw, int &resizeDh);
213  bool meanShift(IplImage *maskImage, IplImage *depthMap, int maxIteration, bool initDepth);
214  };
215 
216 public:
218  {
219  tsNone = 0,
220  tsSearching = 1,
221  tsTracking = 2,
222  tsSetWindow = 3,
223  tsDisabled = 10
224  };
225 
227  rmEdgeDensityLinear = 0,
228  rmEdgeDensityFuzzy = 1,
229  rmInnerDensity = 2
230  };
231 
232  enum {
233  MinKernelMass = 1000
234  };
235 
236  SearchWindow kernel;
238 
239 private:
240  enum
241  {
242  MaxMeanShiftIteration = 5,
243  MaxSetSizeIteration = 5
244  };
245 
246  void findOptimumSearchWindow(SearchWindow &searchWindow, IplImage *maskImage, IplImage *depthMap, int maxIteration, int resizeMethod, bool initDepth);
247 
248 public:
251 
252  void track(IplImage *maskImage, IplImage *depthMap, int resizeMethod, bool resetSearch, int minKernelMass = MinKernelMass);
253 };
254 
255 
256 namespace cv
257 {
258 
259  class CV_EXPORTS Octree
260  {
261  public:
262  struct Node
263  {
264  Node() {}
265  int begin, end;
266  float x_min, x_max, y_min, y_max, z_min, z_max;
268  bool isLeaf;
269  int children[8];
270  };
271 
272  Octree();
273  Octree( const vector<Point3f>& points, int maxLevels = 10, int minPoints = 20 );
274  virtual ~Octree();
275 
276  virtual void buildTree( const vector<Point3f>& points, int maxLevels = 10, int minPoints = 20 );
277  virtual void getPointsWithinSphere( const Point3f& center, float radius,
278  vector<Point3f>& points ) const;
279  const vector<Node>& getNodes() const { return nodes; }
280  private:
281  int minPoints;
282  vector<Point3f> points;
283  vector<Node> nodes;
284 
285  virtual void buildNext(size_t node_ind);
286  };
287 
288 
289  class CV_EXPORTS Mesh3D
290  {
291  public:
293 
294  Mesh3D();
295  Mesh3D(const vector<Point3f>& vtx);
296  ~Mesh3D();
297 
298  void buildOctree();
299  void clearOctree();
300  float estimateResolution(float tryRatio = 0.1f);
301  void computeNormals(float normalRadius, int minNeighbors = 20);
302  void computeNormals(const vector<int>& subset, float normalRadius, int minNeighbors = 20);
303 
304  void writeAsVrml(const String& file, const vector<Scalar>& colors = vector<Scalar>()) const;
305 
306  vector<Point3f> vtx;
307  vector<Point3f> normals;
308  float resolution;
310 
311  const static Point3f allzero;
312  };
313 
314  class CV_EXPORTS SpinImageModel
315  {
316  public:
317 
318  /* model parameters, leave unset for default or auto estimate */
321 
322  float binSize;
324 
325  float lambda;
326  float gamma;
327 
330 
331  /* public interface */
332  SpinImageModel();
333  explicit SpinImageModel(const Mesh3D& mesh);
334  ~SpinImageModel();
335 
336  void setLogger(std::ostream* log);
337  void selectRandomSubset(float ratio);
338  void setSubset(const vector<int>& subset);
339  void compute();
340 
341  void match(const SpinImageModel& scene, vector< vector<Vec2i> >& result);
342 
343  Mat packRandomScaledSpins(bool separateScale = false, size_t xCount = 10, size_t yCount = 10) const;
344 
345  size_t getSpinCount() const { return spinImages.rows; }
346  Mat getSpinImage(size_t index) const { return spinImages.row((int)index); }
347  const Point3f& getSpinVertex(size_t index) const { return mesh.vtx[subset[index]]; }
348  const Point3f& getSpinNormal(size_t index) const { return mesh.normals[subset[index]]; }
349 
350  const Mesh3D& getMesh() const { return mesh; }
351  Mesh3D& getMesh() { return mesh; }
352 
353  /* static utility functions */
354  static bool spinCorrelation(const Mat& spin1, const Mat& spin2, float lambda, float& result);
355 
356  static Point2f calcSpinMapCoo(const Point3f& point, const Point3f& vertex, const Point3f& normal);
357 
358  static float geometricConsistency(const Point3f& pointScene1, const Point3f& normalScene1,
359  const Point3f& pointModel1, const Point3f& normalModel1,
360  const Point3f& pointScene2, const Point3f& normalScene2,
361  const Point3f& pointModel2, const Point3f& normalModel2);
362 
363  static float groupingCreteria(const Point3f& pointScene1, const Point3f& normalScene1,
364  const Point3f& pointModel1, const Point3f& normalModel1,
365  const Point3f& pointScene2, const Point3f& normalScene2,
366  const Point3f& pointModel2, const Point3f& normalModel2,
367  float gamma);
368  protected:
369  void defaultParams();
370 
371  void matchSpinToModel(const Mat& spin, vector<int>& indeces,
372  vector<float>& corrCoeffs, bool useExtremeOutliers = true) const;
373 
374  void repackSpinImages(const vector<uchar>& mask, Mat& spinImages, bool reAlloc = true) const;
375 
376  vector<int> subset;
379  std::ostream* out;
380  };
381 
382  class CV_EXPORTS TickMeter
383  {
384  public:
385  TickMeter();
386  void start();
387  void stop();
388 
389  int64 getTimeTicks() const;
390  double getTimeMicro() const;
391  double getTimeMilli() const;
392  double getTimeSec() const;
393  int64 getCounter() const;
394 
395  void reset();
396  private:
397  int64 counter;
398  int64 sumTime;
399  int64 startTime;
400  };
401 
402  CV_EXPORTS std::ostream& operator<<(std::ostream& out, const TickMeter& tm);
403 
404  class CV_EXPORTS SelfSimDescriptor
405  {
406  public:
408  SelfSimDescriptor(int _ssize, int _lsize,
409  int _startDistanceBucket=DEFAULT_START_DISTANCE_BUCKET,
410  int _numberOfDistanceBuckets=DEFAULT_NUM_DISTANCE_BUCKETS,
411  int _nangles=DEFAULT_NUM_ANGLES);
413  virtual ~SelfSimDescriptor();
414  SelfSimDescriptor& operator = (const SelfSimDescriptor& ss);
415 
416  size_t getDescriptorSize() const;
417  Size getGridSize( Size imgsize, Size winStride ) const;
418 
419  virtual void compute(const Mat& img, vector<float>& descriptors, Size winStride=Size(),
420  const vector<Point>& locations=vector<Point>()) const;
421  virtual void computeLogPolarMapping(Mat& mappingMask) const;
422  virtual void SSD(const Mat& img, Point pt, Mat& ssd) const;
423 
429 
430  enum { DEFAULT_SMALL_SIZE = 5, DEFAULT_LARGE_SIZE = 41,
431  DEFAULT_NUM_ANGLES = 20, DEFAULT_START_DISTANCE_BUCKET = 3,
432  DEFAULT_NUM_DISTANCE_BUCKETS = 7 };
433  };
434 
435 
436  typedef bool (*BundleAdjustCallback)(int iteration, double norm_error, void* user_data);
437 
438  class CV_EXPORTS LevMarqSparse {
439  public:
440  LevMarqSparse();
441  LevMarqSparse(int npoints, // number of points
442  int ncameras, // number of cameras
443  int nPointParams, // number of params per one point (3 in case of 3D points)
444  int nCameraParams, // number of parameters per one camera
445  int nErrParams, // number of parameters in measurement vector
446  // for 1 point at one camera (2 in case of 2D projections)
447  Mat& visibility, // visibility matrix. rows correspond to points, columns correspond to cameras
448  // 1 - point is visible for the camera, 0 - invisible
449  Mat& P0, // starting vector of parameters, first cameras then points
450  Mat& X, // measurements, in order of visibility. non visible cases are skipped
451  TermCriteria criteria, // termination criteria
452 
453  // callback for estimation of Jacobian matrices
454  void (CV_CDECL * fjac)(int i, int j, Mat& point_params,
455  Mat& cam_params, Mat& A, Mat& B, void* data),
456  // callback for estimation of backprojection errors
457  void (CV_CDECL * func)(int i, int j, Mat& point_params,
458  Mat& cam_params, Mat& estim, void* data),
459  void* data, // user-specific data passed to the callbacks
460  BundleAdjustCallback cb, void* user_data
461  );
462 
463  virtual ~LevMarqSparse();
464 
465  virtual void run( int npoints, // number of points
466  int ncameras, // number of cameras
467  int nPointParams, // number of params per one point (3 in case of 3D points)
468  int nCameraParams, // number of parameters per one camera
469  int nErrParams, // number of parameters in measurement vector
470  // for 1 point at one camera (2 in case of 2D projections)
471  Mat& visibility, // visibility matrix. rows correspond to points, columns correspond to cameras
472  // 1 - point is visible for the camera, 0 - invisible
473  Mat& P0, // starting vector of parameters, first cameras then points
474  Mat& X, // measurements, in order of visibility. non visible cases are skipped
475  TermCriteria criteria, // termination criteria
476 
477  // callback for estimation of Jacobian matrices
478  void (CV_CDECL * fjac)(int i, int j, Mat& point_params,
479  Mat& cam_params, Mat& A, Mat& B, void* data),
480  // callback for estimation of backprojection errors
481  void (CV_CDECL * func)(int i, int j, Mat& point_params,
482  Mat& cam_params, Mat& estim, void* data),
483  void* data // user-specific data passed to the callbacks
484  );
485 
486  virtual void clear();
487 
488  // useful function to do simple bundle adjustment tasks
489  static void bundleAdjust(vector<Point3d>& points, // positions of points in global coordinate system (input and output)
490  const vector<vector<Point2d> >& imagePoints, // projections of 3d points for every camera
491  const vector<vector<int> >& visibility, // visibility of 3d points for every camera
492  vector<Mat>& cameraMatrix, // intrinsic matrices of all cameras (input and output)
493  vector<Mat>& R, // rotation matrices of all cameras (input and output)
494  vector<Mat>& T, // translation vector of all cameras (input and output)
495  vector<Mat>& distCoeffs, // distortion coefficients of all cameras (input and output)
496  const TermCriteria& criteria=
497  TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON),
498  BundleAdjustCallback cb = 0, void* user_data = 0);
499 
500  public:
501  virtual void optimize(CvMat &_vis); //main function that runs minimization
502 
503  //iteratively asks for measurement for visible camera-point pairs
504  void ask_for_proj(CvMat &_vis,bool once=false);
505  //iteratively asks for Jacobians for every camera_point pair
506  void ask_for_projac(CvMat &_vis);
507 
508  CvMat* err; //error X-hX
509  double prevErrNorm, errNorm;
510  double lambda;
512  int iters;
513 
514  CvMat** U; //size of array is equal to number of cameras
515  CvMat** V; //size of array is equal to number of points
516  CvMat** inv_V_star; //inverse of V*
517 
518  CvMat** A;
519  CvMat** B;
520  CvMat** W;
521 
522  CvMat* X; //measurement
523  CvMat* hX; //current measurement extimation given new parameter vector
524 
525  CvMat* prevP; //current already accepted parameter.
526  CvMat* P; // parameters used to evaluate function with new params
527  // this parameters may be rejected
528 
529  CvMat* deltaP; //computed increase of parameters (result of normal system solution )
530 
531  CvMat** ea; // sum_i AijT * e_ij , used as right part of normal equation
532  // length of array is j = number of cameras
533  CvMat** eb; // sum_j BijT * e_ij , used as right part of normal equation
534  // length of array is i = number of points
535 
536  CvMat** Yj; //length of array is i = num_points
537 
538  CvMat* S; //big matrix of block Sjk , each block has size num_cam_params x num_cam_params
539 
540  CvMat* JtJ_diag; //diagonal of JtJ, used to backup diagonal elements before augmentation
541 
542  CvMat* Vis_index; // matrix which element is index of measurement for point i and camera j
543 
544  int num_cams;
549 
550  //target function and jacobian pointers, which needs to be initialized
551  void (*fjac)(int i, int j, Mat& point_params, Mat& cam_params, Mat& A, Mat& B, void* data);
552  void (*func)(int i, int j, Mat& point_params, Mat& cam_params, Mat& estim, void* data);
553 
554  void* data;
555 
557  void* user_data;
558  };
559 
560  CV_EXPORTS_W int chamerMatching( Mat& img, Mat& templ,
561  CV_OUT vector<vector<Point> >& results, CV_OUT vector<float>& cost,
562  double templScale=1, int maxMatches = 20,
563  double minMatchDistance = 1.0, int padX = 3,
564  int padY = 3, int scales = 5, double minScale = 0.6, double maxScale = 1.6,
565  double orientationWeight = 0.5, double truncate = 20);
566 
567 
568  class CV_EXPORTS_W StereoVar
569  {
570  public:
571  // Flags
572  enum {USE_INITIAL_DISPARITY = 1, USE_EQUALIZE_HIST = 2, USE_SMART_ID = 4, USE_AUTO_PARAMS = 8, USE_MEDIAN_FILTERING = 16};
573  enum {CYCLE_O, CYCLE_V};
574  enum {PENALIZATION_TICHONOV, PENALIZATION_CHARBONNIER, PENALIZATION_PERONA_MALIK};
575 
577  CV_WRAP StereoVar();
578 
580  CV_WRAP StereoVar(int levels, double pyrScale, int nIt, int minDisp, int maxDisp, int poly_n, double poly_sigma, float fi, float lambda, int penalization, int cycle, int flags);
581 
583  virtual ~StereoVar();
584 
586  CV_WRAP_AS(compute) virtual void operator()(const Mat& left, const Mat& right, CV_OUT Mat& disp);
587 
588  CV_PROP_RW int levels;
589  CV_PROP_RW double pyrScale;
590  CV_PROP_RW int nIt;
591  CV_PROP_RW int minDisp;
592  CV_PROP_RW int maxDisp;
593  CV_PROP_RW int poly_n;
594  CV_PROP_RW double poly_sigma;
595  CV_PROP_RW float fi;
596  CV_PROP_RW float lambda;
597  CV_PROP_RW int penalization;
598  CV_PROP_RW int cycle;
599  CV_PROP_RW int flags;
600 
601  private:
602  void autoParams();
603  void FMG(Mat &I1, Mat &I2, Mat &I2x, Mat &u, int level);
604  void VCycle_MyFAS(Mat &I1_h, Mat &I2_h, Mat &I2x_h, Mat &u_h, int level);
605  void VariationalSolver(Mat &I1_h, Mat &I2_h, Mat &I2x_h, Mat &u_h, int level);
606  };
607 
608  CV_EXPORTS void polyfit(const Mat& srcx, const Mat& srcy, Mat& dst, int order);
609 
610  class CV_EXPORTS Directory
611  {
612  public:
613  static std::vector<std::string> GetListFiles ( const std::string& path, const std::string & exten = "*", bool addPath = true );
614  static std::vector<std::string> GetListFilesR ( const std::string& path, const std::string & exten = "*", bool addPath = true );
615  static std::vector<std::string> GetListFolders( const std::string& path, const std::string & exten = "*", bool addPath = true );
616  };
617 
618  /*
619  * Generation of a set of different colors by the following way:
620  * 1) generate more then need colors (in "factor" times) in RGB,
621  * 2) convert them to Lab,
622  * 3) choose the needed count of colors from the set that are more different from
623  * each other,
624  * 4) convert the colors back to RGB
625  */
626  CV_EXPORTS void generateColors( std::vector<Scalar>& colors, size_t count, size_t factor=100 );
627 
628 
629  /*
630  * Estimate the rigid body motion from frame0 to frame1. The method is based on the paper
631  * "Real-Time Visual Odometry from Dense RGB-D Images", F. Steinbucker, J. Strum, D. Cremers, ICCV, 2011.
632  */
633  enum { ROTATION = 1,
636  };
637  CV_EXPORTS bool RGBDOdometry( Mat& Rt, const Mat& initRt,
638  const Mat& image0, const Mat& depth0, const Mat& mask0,
639  const Mat& image1, const Mat& depth1, const Mat& mask1,
640  const Mat& cameraMatrix, float minDepth=0.f, float maxDepth=4.f, float maxDepthDiff=0.07f,
641  const std::vector<int>& iterCounts=std::vector<int>(),
642  const std::vector<float>& minGradientMagnitudes=std::vector<float>(),
643  int transformType=RIGID_BODY_MOTION );
644 
654  class CV_EXPORTS LogPolar_Interp
655  {
656  public:
657 
659 
674  LogPolar_Interp(int w, int h, Point2i center, int R=70, double ro0=3.0,
675  int interp=INTER_LINEAR, int full=1, int S=117, int sp=1);
681  const Mat to_cortical(const Mat &source);
687  const Mat to_cartesian(const Mat &source);
691  ~LogPolar_Interp();
692 
693  protected:
694 
697 
698  int S, R, M, N;
700  double ro0, romax, a, q;
701  int interp;
702 
705 
706  void create_map(int M, int N, int R, int S, double ro0);
707  };
708 
718  class CV_EXPORTS LogPolar_Overlapping
719  {
720  public:
722 
737  LogPolar_Overlapping(int w, int h, Point2i center, int R=70,
738  double ro0=3.0, int full=1, int S=117, int sp=1);
744  const Mat to_cortical(const Mat &source);
750  const Mat to_cartesian(const Mat &source);
755 
756  protected:
757 
760  vector<int> Rsr;
761  vector<int> Csr;
762  vector<double> Wsr;
763 
764  int S, R, M, N, ind1;
766  double ro0, romax, a, q;
767 
768  struct kernel
769  {
770  kernel() { w = 0; }
771  vector<double> weights;
772  int w;
773  };
774 
777  vector<kernel> w_ker_2D;
778 
779  void create_map(int M, int N, int R, int S, double ro0);
780  };
781 
792  class CV_EXPORTS LogPolar_Adjacent
793  {
794  public:
796 
812  LogPolar_Adjacent(int w, int h, Point2i center, int R=70, double ro0=3.0, double smin=0.25, int full=1, int S=117, int sp=1);
818  const Mat to_cortical(const Mat &source);
824  const Mat to_cartesian(const Mat &source);
829 
830  protected:
831  struct pixel
832  {
833  pixel() { u = v = 0; a = 0.; }
834  int u;
835  int v;
836  double a;
837  };
838  int S, R, M, N;
840  double ro0, romax, a, q;
841  vector<vector<pixel> > L;
842  vector<double> A;
843 
844  void subdivide_recursively(double x, double y, int i, int j, double length, double smin);
845  bool get_uv(double x, double y, int&u, int&v);
846  void create_map(int M, int N, int R, int S, double ro0, double smin);
847  };
848 
851 
852  class CV_EXPORTS LDA
853  {
854  public:
855  // Initializes a LDA with num_components (default 0) and specifies how
856  // samples are aligned (default dataAsRow=true).
857  LDA(int num_components = 0) :
858  _num_components(num_components) {};
859 
860  // Initializes and performs a Discriminant Analysis with Fisher's
861  // Optimization Criterion on given data in src and corresponding labels
862  // in labels. If 0 (or less) number of components are given, they are
863  // automatically determined for given data in computation.
864  LDA(const Mat& src, vector<int> labels,
865  int num_components = 0) :
866  _num_components(num_components)
867  {
868  this->compute(src, labels);
869  }
870 
871  // Initializes and performs a Discriminant Analysis with Fisher's
872  // Optimization Criterion on given data in src and corresponding labels
873  // in labels. If 0 (or less) number of components are given, they are
874  // automatically determined for given data in computation.
876  int num_components = 0) :
877  _num_components(num_components)
878  {
879  this->compute(src, labels);
880  }
881 
882  // Serializes this object to a given filename.
883  void save(const string& filename) const;
884 
885  // Deserializes this object from a given filename.
886  void load(const string& filename);
887 
888  // Serializes this object to a given cv::FileStorage.
889  void save(FileStorage& fs) const;
890 
891  // Deserializes this object from a given cv::FileStorage.
892  void load(const FileStorage& node);
893 
894  // Destructor.
895  ~LDA() {}
896 
898  void compute(InputArrayOfArrays src, InputArray labels);
899 
900  // Projects samples into the LDA subspace.
901  Mat project(InputArray src);
902 
903  // Reconstructs projections from the LDA subspace.
904  Mat reconstruct(InputArray src);
905 
906  // Returns the eigenvectors of this LDA.
907  Mat eigenvectors() const { return _eigenvectors; };
908 
909  // Returns the eigenvalues of this LDA.
910  Mat eigenvalues() const { return _eigenvalues; }
911 
912  protected:
917 
919  };
920 
921  class CV_EXPORTS_W FaceRecognizer : public Algorithm
922  {
923  public:
925  virtual ~FaceRecognizer() {}
926 
927  // Trains a FaceRecognizer.
928  CV_WRAP virtual void train(InputArrayOfArrays src, InputArray labels) = 0;
929 
930  // Updates a FaceRecognizer.
931  CV_WRAP void update(InputArrayOfArrays src, InputArray labels);
932 
933  // Gets a prediction from a FaceRecognizer.
934  virtual int predict(InputArray src) const = 0;
935 
936  // Predicts the label and confidence for a given sample.
937  CV_WRAP virtual void predict(InputArray src, CV_OUT int &label, CV_OUT double &confidence) const = 0;
938 
939  // Serializes this object to a given filename.
940  CV_WRAP virtual void save(const string& filename) const;
941 
942  // Deserializes this object from a given filename.
943  CV_WRAP virtual void load(const string& filename);
944 
945  // Serializes this object to a given cv::FileStorage.
946  virtual void save(FileStorage& fs) const = 0;
947 
948  // Deserializes this object from a given cv::FileStorage.
949  virtual void load(const FileStorage& fs) = 0;
950 
951  };
952 
953  CV_EXPORTS_W Ptr<FaceRecognizer> createEigenFaceRecognizer(int num_components = 0, double threshold = DBL_MAX);
954  CV_EXPORTS_W Ptr<FaceRecognizer> createFisherFaceRecognizer(int num_components = 0, double threshold = DBL_MAX);
955  CV_EXPORTS_W Ptr<FaceRecognizer> createLBPHFaceRecognizer(int radius=1, int neighbors=8,
956  int grid_x=8, int grid_y=8, double threshold = DBL_MAX);
957 
958  enum
959  {
972  };
973 
974  CV_EXPORTS_W void applyColorMap(InputArray src, OutputArray dst, int colormap);
975 
976  CV_EXPORTS bool initModule_contrib();
977 }
978 
980 
982 
983 #endif
984 
985 #endif
Mat Csri
Definition: contrib.hpp:696
CvArr CvPoint2D32f double M
Definition: imgproc_c.h:186
double prevErrNorm
Definition: contrib.hpp:509
LogPolar_Interp()
Definition: contrib.hpp:658
vector< int > Rsr
Definition: contrib.hpp:760
bool isLeaf
Definition: contrib.hpp:268
float T_GeometriccConsistency
Definition: contrib.hpp:328
GLsizei GLsizei GLchar * source
CvPoint2D32f pt[4]
Definition: imgproc_c.h:410
GLenum GLint GLint y
Definition: core_c.h:613
const _OutputArray & OutputArray
Definition: core.hpp:1449
double romax
Definition: contrib.hpp:766
CvFileNode * node
Definition: core_c.h:1638
Definition: contrib.hpp:167
Definition: contrib.hpp:768
bool(* BundleAdjustCallback)(int iteration, double norm_error, void *user_data)
Definition: contrib.hpp:436
Definition: contrib.hpp:635
Termination criteria in iterative algorithms.
Definition: core.hpp:2091
int iters
Definition: contrib.hpp:512
Definition: contrib.hpp:610
int imageWidth
Definition: contrib.hpp:323
CvTermCriteria criteria
Definition: contrib.hpp:511
GLint level
Definition: tracking.hpp:88
int CvScalar value
Definition: core_c.h:340
const char const char ** filename
Definition: core_c.h:1750
CvMat ** V
Definition: contrib.hpp:515
Definition: contrib.hpp:262
int num_err_param
Definition: contrib.hpp:546
vector< Point3f > vtx
Definition: contrib.hpp:306
const Point3f & getSpinNormal(size_t index) const
Definition: contrib.hpp:348
CV_EXPORTS_W void applyColorMap(InputArray src, OutputArray dst, int colormap)
Mat _eigenvalues
Definition: contrib.hpp:916
CV_EXPORTS Mat subspaceReconstruct(InputArray W, InputArray mean, InputArray src)
float resolution
Definition: contrib.hpp:308
CvMat * X
Definition: contrib.hpp:522
LDA(InputArrayOfArrays src, InputArray labels, int num_components=0)
Definition: contrib.hpp:875
Definition: types_c.h:921
Size2i Size
Definition: core.hpp:896
Definition: contrib.hpp:289
float lambda
Definition: contrib.hpp:325
Definition: contrib.hpp:438
int minNeighbors
Definition: contrib.hpp:320
CvCmpFunc func
Definition: core_c.h:1072
CvMat * S
Definition: contrib.hpp:538
vector< kernel > w_ker_2D
Definition: contrib.hpp:777
CvMat * err
Definition: contrib.hpp:508
CvMat ** inv_V_star
Definition: contrib.hpp:516
Mat eigenvectors() const
Definition: contrib.hpp:907
Definition: contrib.hpp:574
Definition: contrib.hpp:965
Mesh3D mesh
Definition: contrib.hpp:377
GLuint src
Definition: core_c.h:1650
Mat getSpinImage(size_t index) const
Definition: contrib.hpp:346
int int int flags
Definition: highgui_c.h:186
Definition: contrib.hpp:852
GLuint index
Definition: core_c.h:986
const CvArr int CvArr CvArr double lambda
Definition: legacy.hpp:3133
GLsizei GLsizei GLenum GLenum const GLvoid * data
Definition: core_c.h:403
const CvMat const CvMat const CvMat CvMat CvMat CvMat CvMat CvSize CvMat CvMat * T
Definition: calib3d.hpp:270
Mat _eigenvectors
Definition: contrib.hpp:915
~LDA()
Definition: contrib.hpp:895
CvPoint center
Definition: core_c.h:1290
Node()
Definition: contrib.hpp:264
CvPoint * points
Definition: legacy.hpp:798
void * data
Definition: contrib.hpp:554
CV_EXPORTS_W int chamerMatching(Mat &img, Mat &templ, CV_OUT vector< vector< Point > > &results, CV_OUT vector< float > &cost, double templScale=1, int maxMatches=20, double minMatchDistance=1.0, int padX=3, int padY=3, int scales=5, double minScale=0.6, double maxScale=1.6, double orientationWeight=0.5, double truncate=20)
bool _dataAsRow
Definition: contrib.hpp:913
vector< int > subset
Definition: contrib.hpp:376
CV_EXPORTS bool initModule_contrib()
int top
Definition: contrib.hpp:839
Definition: contrib.hpp:962
int startDistanceBucket
Definition: contrib.hpp:426
Definition: contrib.hpp:971
CV_EXPORTS void polyfit(const Mat &srcx, const Mat &srcy, Mat &dst, int order)
int searchMode
Definition: contrib.hpp:237
void process(const Mat_< T1 > &m1, Mat_< T2 > &m2, Op op)
Definition: mat.hpp:1084
Definition: contrib.hpp:177
int top
Definition: contrib.hpp:699
Proxy datatype for passing Mat's and vector<>'s as input parameters.
Definition: core.hpp:1312
void clear(const ColorA &color=ColorA::black(), bool clearDepthBuffer=true)
double CvStereoLineCoeff CvPoint3D64f * point
Definition: legacy.hpp:558
SearchWindow kernel
Definition: contrib.hpp:236
const CvPoint2D32f vertex[4]
Definition: legacy.hpp:1070
Definition: contrib.hpp:967
The 2D size class.
Definition: core.hpp:81
Definition: contrib.hpp:259
Mat Rsri
Definition: contrib.hpp:695
const CvArr const CvArr CvArr * result
Definition: core_c.h:805
typedef void(CV_CDECL *CvMouseCallback)(int event
CvPoint2D32f double CvTermCriteria criteria
Definition: calib3d.hpp:65
const vector< Node > & getNodes() const
Definition: contrib.hpp:279
Definition: contrib.hpp:654
CvMat ** W
Definition: contrib.hpp:520
Mat Csri
Definition: contrib.hpp:759
Definition: contrib.hpp:964
GLint GLvoid * img
Definition: legacy.hpp:1150
double start
Definition: core_c.h:774
TrackingState
Definition: contrib.hpp:217
CV_EXPORTS std::ostream & operator<<(std::ostream &out, const TickMeter &tm)
SourceFileRef load(const DataSourceRef &dataSource, size_t sampleRate=0)
const CvArr CvArr double int levels
Definition: tracking.hpp:102
CvArr * W
Definition: core_c.h:728
int width
Definition: highgui_c.h:130
Definition: contrib.hpp:718
const _InputArray & InputArray
Definition: core.hpp:1447
vector< int > Csr
Definition: contrib.hpp:761
GLuint interp
CvMat ** B
Definition: contrib.hpp:519
virtual ~FaceRecognizer()
virtual destructor
Definition: contrib.hpp:925
CvMat * JtJ_diag
Definition: contrib.hpp:540
template 3D point class.
Definition: core.hpp:777
CV_EXPORTS void generateColors(std::vector< Scalar > &colors, size_t count, size_t factor=100)
void * user_data
Definition: contrib.hpp:557
std::string String
Definition: core.hpp:85
GLdouble GLdouble GLdouble GLdouble q
CvMat * deltaP
Definition: contrib.hpp:529
const CvMat const CvMat const CvMat CvMat CvMat CvMat CvMat CvSize CvMat * R
Definition: calib3d.hpp:270
int v
Definition: contrib.hpp:835
ResizeMethod
Definition: contrib.hpp:226
CvArr int order
Definition: core_c.h:704
int index
Definition: core_c.h:309
CvMat * P
Definition: contrib.hpp:526
Definition: contrib.hpp:382
BundleAdjustCallback cb
Definition: contrib.hpp:556
const CvArr CvArr double int int int int double poly_sigma
Definition: tracking.hpp:102
CvArr int CvScalar param1
Definition: core_c.h:649
vector< double > weights
Definition: contrib.hpp:771
float T_GroupingCorespondances
Definition: contrib.hpp:329
CvMat ** eb
Definition: contrib.hpp:533
GLenum GLint x
Definition: core_c.h:632
const Mesh3D & getMesh() const
Definition: contrib.hpp:350
Definition: contrib.hpp:314
GLuint GLuint GLsizei count
Definition: core_c.h:973
Definition: contrib.hpp:831
int _num_components
Definition: contrib.hpp:914
Definition: contrib.hpp:968
int w
Definition: contrib.hpp:772
void colormap(const Mat &quantized, Mat &dst)
Debug function to colormap a quantized image for viewing.
pixel()
Definition: contrib.hpp:833
vector< double > A
Definition: contrib.hpp:842
int numberOfAngles
Definition: contrib.hpp:428
The Image Processing.
GLdouble left
vector< Point3f > normals
Definition: contrib.hpp:307
GLuint GLsizei GLsizei * length
Mesh3D & getMesh()
Definition: contrib.hpp:351
float z_min
Definition: contrib.hpp:266
LogPolar_Adjacent()
Definition: contrib.hpp:795
void * data
Definition: core_c.h:206
Definition: contrib.hpp:568
std::ostream * out
Definition: contrib.hpp:379
CV_EXPORTS bool RGBDOdometry(Mat &Rt, const Mat &initRt, const Mat &image0, const Mat &depth0, const Mat &mask0, const Mat &image1, const Mat &depth1, const Mat &mask1, const Mat &cameraMatrix, float minDepth=0.f, float maxDepth=4.f, float maxDepthDiff=0.07f, const std::vector< int > &iterCounts=std::vector< int >(), const std::vector< float > &minGradientMagnitudes=std::vector< float >(), int transformType=RIGID_BODY_MOTION)
CvMat ** ea
Definition: contrib.hpp:531
CV_EXPORTS Mat subspaceProject(InputArray W, InputArray mean, InputArray src)
Definition: types_c.h:645
const GLdouble * v
XML/YAML File Storage Class.
Definition: core.hpp:4040
GLdouble GLdouble right
int num_cam_param
Definition: contrib.hpp:547
The Core Functionality.
The n-dimensional matrix class.
Definition: core.hpp:1688
LDA(const Mat &src, vector< int > labels, int num_components=0)
Definition: contrib.hpp:864
int top
Definition: contrib.hpp:765
Definition: types_c.h:465
Definition: types_c.h:997
int maxLevels
Definition: contrib.hpp:267
int int y
Definition: highgui_c.h:186
const CvArr CvSeq CvSeq ** descriptors
Definition: compat.hpp:647
CvArr * mean
Definition: core_c.h:802
GLsizei const GLfloat * value
Definition: core_c.h:341
void begin(GLenum mode)
bilinear interpolation
Definition: imgproc.hpp:555
double y
Definition: contrib.hpp:118
Definition: contrib.hpp:123
Mat Rsri
Definition: contrib.hpp:758
Definition: contrib.hpp:116
Definition: contrib.hpp:57
Mat row(int y) const
returns a new matrix header for the specified row
Definition: mat.hpp:309
__int64 int64
Definition: types_c.h:158
float gamma
Definition: contrib.hpp:326
int largeSize
Definition: contrib.hpp:425
Definition: contrib.hpp:970
int int int int int int h
int numberOfDistanceBuckets
Definition: contrib.hpp:427
vector< vector< pixel > > L
Definition: contrib.hpp:841
LDA(int num_components=0)
Definition: contrib.hpp:857
double lambda
Definition: contrib.hpp:510
float binSize
Definition: contrib.hpp:322
Definition: contrib.hpp:792
Definition: contrib.hpp:969
CvMat * Vis_index
Definition: contrib.hpp:542
CV_EXPORTS_W void log(InputArray src, OutputArray dst)
computes natural logarithm of absolute value of each matrix element: dst = log(abs(src)) ...
double threshold
Definition: imgproc_c.h:463
CvArr double sp
Definition: imgproc_c.h:125
CvMat * hX
Definition: contrib.hpp:523
CV_EXPORTS_W Ptr< FaceRecognizer > createEigenFaceRecognizer(int num_components=0, double threshold=DBL_MAX)
std::vector< CvFuzzyCurve > curves
Definition: contrib.hpp:145
GLboolean GLboolean GLboolean GLboolean a
Definition: legacy.hpp:633
Definition: contrib.hpp:155
CV_EXPORTS_W Ptr< FaceRecognizer > createLBPHFaceRecognizer(int radius=1, int neighbors=8, int grid_x=8, int grid_y=8, double threshold=DBL_MAX)
LogPolar_Overlapping()
Definition: contrib.hpp:721
Definition: contrib.hpp:960
Base class for high-level OpenCV algorithms.
Definition: core.hpp:4390
Definition: contrib.hpp:966
Definition: contrib.hpp:404
GLboolean reset
GLsizei const GLint * locations
double factor
Definition: imgproc_c.h:459
double romax
Definition: contrib.hpp:840
CvArr int CvScalar CvScalar param2
Definition: core_c.h:649
CvMat ** Yj
Definition: contrib.hpp:536
CvMat ** U
Definition: contrib.hpp:514
double const CvArr double double gamma
Definition: core_c.h:523
GLuint dst
Definition: calib3d.hpp:134
Definition: contrib.hpp:634
int int height
Definition: highgui_c.h:130
CV_EXPORTS void selectRandomSubset(int count, int size, std::vector< int > &subset)
Octree octree
Definition: contrib.hpp:309
Definition: contrib.hpp:963
int u
Definition: contrib.hpp:834
int end
Definition: contrib.hpp:265
size_t getSpinCount() const
Definition: contrib.hpp:345
const CvArr CvArr double int int int int poly_n
Definition: tracking.hpp:102
const CvArr const CvArr const CvArr CvArr * X
Definition: core_c.h:733
double romax
Definition: contrib.hpp:700
double a
Definition: contrib.hpp:836
GLsizei const GLfloat * points
vector< double > Wsr
Definition: contrib.hpp:762
const CvArr * templ
Definition: imgproc_c.h:281
GLubyte GLubyte GLubyte GLubyte w
CvPoint2D32f float a
Definition: legacy.hpp:578
Mat CSIyx
Definition: contrib.hpp:776
int x
Definition: highgui_c.h:186
GLdouble GLdouble GLdouble bottom
int num_points
Definition: contrib.hpp:545
Mat ETAyx
Definition: contrib.hpp:703
Mat CSIyx
Definition: contrib.hpp:704
const CvArr * cost
Definition: calib3d.hpp:359
const CvMat * B
Definition: calib3d.hpp:161
int S
Definition: contrib.hpp:698
float maxWidth
Definition: legacy.hpp:1062
int S
Definition: contrib.hpp:838
const Point3f & getSpinVertex(size_t index) const
Definition: contrib.hpp:347
CvGraphVtx * vtx
Definition: core_c.h:1151
Mat ETAyx
Definition: contrib.hpp:775
CV_EXPORTS_W int meanShift(InputArray probImage, CV_OUT CV_IN_OUT Rect &window, TermCriteria criteria)
updates the object tracking window using meanshift algorithm
Definition: contrib.hpp:143
Mat eigenvalues() const
Definition: contrib.hpp:910
const CvArr * right
Definition: calib3d.hpp:353
int smallSize
Definition: contrib.hpp:424
CV_EXPORTS_W Ptr< FaceRecognizer > createFisherFaceRecognizer(int num_components=0, double threshold=DBL_MAX)
kernel()
Definition: contrib.hpp:770
int num_cams
Definition: contrib.hpp:544
GLenum GLint GLuint mask
Definition: tracking.hpp:132
CvMat * prevP
Definition: contrib.hpp:525
int interp
Definition: contrib.hpp:701
GLclampf f
CvPoint int radius
Definition: core_c.h:1290
Definition: contrib.hpp:961
const CvMat const CvMat * npoints
Definition: calib3d.hpp:196
float normalRadius
Definition: contrib.hpp:319
CvMat ** A
Definition: contrib.hpp:518
Mat spinImages
Definition: contrib.hpp:378
Definition: contrib.hpp:921
GLfloat param
int S
Definition: contrib.hpp:764
Definition: contrib.hpp:633
Definition: contrib.hpp:292
static const Point3f allzero
Definition: contrib.hpp:311
CvMemStorage CvSeq ** labels
Definition: core_c.h:1083
int num_point_param
Definition: contrib.hpp:548