OpenCV 2.4.8 components for OpenCVgrabber.
[mmanager-3rdparty.git] / OpenCV2.4.8 / build / include / opencv2 / contrib / contrib.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*/
42
43 #ifndef __OPENCV_CONTRIB_HPP__
44 #define __OPENCV_CONTRIB_HPP__
45
46 #include "opencv2/core/core.hpp"
47 #include "opencv2/imgproc/imgproc.hpp"
48 #include "opencv2/features2d/features2d.hpp"
49 #include "opencv2/objdetect/objdetect.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:
171     CvFuzzyController();
172     ~CvFuzzyController();
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:
217     enum TrackingState
218     {
219         tsNone          = 0,
220         tsSearching     = 1,
221         tsTracking      = 2,
222         tsSetWindow     = 3,
223         tsDisabled      = 10
224     };
225
226     enum ResizeMethod {
227         rmEdgeDensityLinear     = 0,
228         rmEdgeDensityFuzzy      = 1,
229         rmInnerDensity          = 2
230     };
231
232     enum {
233         MinKernelMass           = 1000
234     };
235
236     SearchWindow kernel;
237     int searchMode;
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:
249     CvFuzzyMeanShiftTracker();
250     ~CvFuzzyMeanShiftTracker();
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;
267             int maxLevels;
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:
292         struct EmptyMeshException {};
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;
309         Octree octree;
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 */
319         float normalRadius;
320         int minNeighbors;
321
322         float binSize;
323         int imageWidth;
324
325         float lambda;
326         float gamma;
327
328         float T_GeometriccConsistency;
329         float T_GroupingCorespondances;
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;
377         Mesh3D mesh;
378         Mat spinImages;
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:
407         SelfSimDescriptor();
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);
412         SelfSimDescriptor(const SelfSimDescriptor& ss);
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
424         int smallSize;
425         int largeSize;
426         int startDistanceBucket;
427         int numberOfDistanceBuckets;
428         int numberOfAngles;
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;
511         CvTermCriteria criteria;
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;
545         int num_points;
546         int num_err_param;
547         int num_cam_param;
548         int num_point_param;
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
556         BundleAdjustCallback cb;
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
576         //! the default constructor
577         CV_WRAP StereoVar();
578
579         //! the full constructor taking all the necessary algorithm parameters
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
582         //! the destructor
583         virtual ~StereoVar();
584
585         //! the stereo correspondence operator that computes disparity map for the specified rectified stereo pair
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,
634            TRANSLATION       = 2,
635            RIGID_BODY_MOTION = 4
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
645     /**
646     *Bilinear interpolation technique.
647     *
648     *The value of a desired cortical pixel is obtained through a bilinear interpolation of the values
649     *of the four nearest neighbouring Cartesian pixels to the center of the RF.
650     *The same principle is applied to the inverse transformation.
651     *
652     *More details can be found in http://dx.doi.org/10.1007/978-3-642-23968-7_5
653     */
654     class CV_EXPORTS LogPolar_Interp
655     {
656     public:
657
658         LogPolar_Interp() {}
659
660         /**
661         *Constructor
662         *\param w the width of the input image
663         *\param h the height of the input image
664         *\param center the transformation center: where the output precision is maximal
665         *\param R the number of rings of the cortical image (default value 70 pixel)
666         *\param ro0 the radius of the blind spot (default value 3 pixel)
667         *\param full \a 1 (default value) means that the retinal image (the inverse transform) is computed within the circumscribing circle.
668         *            \a 0 means that the retinal image is computed within the inscribed circle.
669         *\param S the number of sectors of the cortical image (default value 70 pixel).
670         *         Its value is usually internally computed to obtain a pixel aspect ratio equals to 1.
671         *\param sp \a 1 (default value) means that the parameter \a S is internally computed.
672         *          \a 0 means that the parameter \a S is provided by the user.
673         */
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);
676         /**
677         *Transformation from Cartesian image to cortical (log-polar) image.
678         *\param source the Cartesian image
679         *\return the transformed image (cortical image)
680         */
681         const Mat to_cortical(const Mat &source);
682         /**
683         *Transformation from cortical image to retinal (inverse log-polar) image.
684         *\param source the cortical image
685         *\return the transformed image (retinal image)
686         */
687         const Mat to_cartesian(const Mat &source);
688         /**
689         *Destructor
690         */
691         ~LogPolar_Interp();
692
693     protected:
694
695         Mat Rsri;
696         Mat Csri;
697
698         int S, R, M, N;
699         int top, bottom,left,right;
700         double ro0, romax, a, q;
701         int interp;
702
703         Mat ETAyx;
704         Mat CSIyx;
705
706         void create_map(int M, int N, int R, int S, double ro0);
707     };
708
709     /**
710     *Overlapping circular receptive fields technique
711     *
712     *The Cartesian plane is divided in two regions: the fovea and the periphery.
713     *The fovea (oversampling) is handled by using the bilinear interpolation technique described above, whereas in
714     *the periphery we use the overlapping Gaussian circular RFs.
715     *
716     *More details can be found in http://dx.doi.org/10.1007/978-3-642-23968-7_5
717     */
718     class CV_EXPORTS LogPolar_Overlapping
719     {
720     public:
721         LogPolar_Overlapping() {}
722
723         /**
724         *Constructor
725         *\param w the width of the input image
726         *\param h the height of the input image
727         *\param center the transformation center: where the output precision is maximal
728         *\param R the number of rings of the cortical image (default value 70 pixel)
729         *\param ro0 the radius of the blind spot (default value 3 pixel)
730         *\param full \a 1 (default value) means that the retinal image (the inverse transform) is computed within the circumscribing circle.
731         *            \a 0 means that the retinal image is computed within the inscribed circle.
732         *\param S the number of sectors of the cortical image (default value 70 pixel).
733         *         Its value is usually internally computed to obtain a pixel aspect ratio equals to 1.
734         *\param sp \a 1 (default value) means that the parameter \a S is internally computed.
735         *          \a 0 means that the parameter \a S is provided by the user.
736         */
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);
739         /**
740         *Transformation from Cartesian image to cortical (log-polar) image.
741         *\param source the Cartesian image
742         *\return the transformed image (cortical image)
743         */
744         const Mat to_cortical(const Mat &source);
745         /**
746         *Transformation from cortical image to retinal (inverse log-polar) image.
747         *\param source the cortical image
748         *\return the transformed image (retinal image)
749         */
750         const Mat to_cartesian(const Mat &source);
751         /**
752         *Destructor
753         */
754         ~LogPolar_Overlapping();
755
756     protected:
757
758         Mat Rsri;
759         Mat Csri;
760         vector<int> Rsr;
761         vector<int> Csr;
762         vector<double> Wsr;
763
764         int S, R, M, N, ind1;
765         int top, bottom,left,right;
766         double ro0, romax, a, q;
767
768         struct kernel
769         {
770             kernel() { w = 0; }
771             vector<double> weights;
772             int w;
773         };
774
775         Mat ETAyx;
776         Mat CSIyx;
777         vector<kernel> w_ker_2D;
778
779         void create_map(int M, int N, int R, int S, double ro0);
780     };
781
782     /**
783     * Adjacent receptive fields technique
784     *
785     *All the Cartesian pixels, whose coordinates in the cortical domain share the same integer part, are assigned to the same RF.
786     *The precision of the boundaries of the RF can be improved by breaking each pixel into subpixels and assigning each of them to the correct RF.
787     *This technique is implemented from: Traver, V., Pla, F.: Log-polar mapping template design: From task-level requirements
788     *to geometry parameters. Image Vision Comput. 26(10) (2008) 1354-1370
789     *
790     *More details can be found in http://dx.doi.org/10.1007/978-3-642-23968-7_5
791     */
792     class CV_EXPORTS LogPolar_Adjacent
793     {
794     public:
795         LogPolar_Adjacent() {}
796
797         /**
798          *Constructor
799          *\param w the width of the input image
800          *\param h the height of the input image
801          *\param center the transformation center: where the output precision is maximal
802          *\param R the number of rings of the cortical image (default value 70 pixel)
803          *\param ro0 the radius of the blind spot (default value 3 pixel)
804          *\param smin the size of the subpixel (default value 0.25 pixel)
805          *\param full \a 1 (default value) means that the retinal image (the inverse transform) is computed within the circumscribing circle.
806          *            \a 0 means that the retinal image is computed within the inscribed circle.
807          *\param S the number of sectors of the cortical image (default value 70 pixel).
808          *         Its value is usually internally computed to obtain a pixel aspect ratio equals to 1.
809          *\param sp \a 1 (default value) means that the parameter \a S is internally computed.
810          *          \a 0 means that the parameter \a S is provided by the user.
811          */
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);
813         /**
814          *Transformation from Cartesian image to cortical (log-polar) image.
815          *\param source the Cartesian image
816          *\return the transformed image (cortical image)
817          */
818         const Mat to_cortical(const Mat &source);
819         /**
820          *Transformation from cortical image to retinal (inverse log-polar) image.
821          *\param source the cortical image
822          *\return the transformed image (retinal image)
823          */
824         const Mat to_cartesian(const Mat &source);
825         /**
826          *Destructor
827          */
828         ~LogPolar_Adjacent();
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;
839         int top, bottom,left,right;
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
849     CV_EXPORTS Mat subspaceProject(InputArray W, InputArray mean, InputArray src);
850     CV_EXPORTS Mat subspaceReconstruct(InputArray W, InputArray mean, InputArray src);
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); //! compute eigenvectors and eigenvalues
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.
875         LDA(InputArrayOfArrays src, InputArray labels,
876                 int num_components = 0) :
877                     _num_components(num_components)
878         {
879             this->compute(src, labels); //! compute eigenvectors and eigenvalues
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
897         //! Compute the discriminants for data in src and labels.
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:
913         bool _dataAsRow;
914         int _num_components;
915         Mat _eigenvectors;
916         Mat _eigenvalues;
917
918         void lda(InputArrayOfArrays src, InputArray labels);
919     };
920
921     class CV_EXPORTS_W FaceRecognizer : public Algorithm
922     {
923     public:
924         //! virtual destructor
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     {
960         COLORMAP_AUTUMN = 0,
961         COLORMAP_BONE = 1,
962         COLORMAP_JET = 2,
963         COLORMAP_WINTER = 3,
964         COLORMAP_RAINBOW = 4,
965         COLORMAP_OCEAN = 5,
966         COLORMAP_SUMMER = 6,
967         COLORMAP_SPRING = 7,
968         COLORMAP_COOL = 8,
969         COLORMAP_HSV = 9,
970         COLORMAP_PINK = 10,
971         COLORMAP_HOT = 11
972     };
973
974     CV_EXPORTS_W void applyColorMap(InputArray src, OutputArray dst, int colormap);
975
976     CV_EXPORTS bool initModule_contrib();
977 }
978
979 #include "opencv2/contrib/retina.hpp"
980
981 #include "opencv2/contrib/openfabmap.hpp"
982
983 #endif
984
985 #endif