Fix binary compatibility of opencv_contrib

modules/contrib/include/opencv2/contrib/contrib.hpp

@@ -857,6 +857,17 @@ namespace cv
         LDA(int num_components = 0) :
             _num_components(num_components) {};
 
+        // Initializes and performs a Discriminant Analysis with Fisher's
+        // Optimization Criterion on given data in src and corresponding labels
+        // in labels. If 0 (or less) number of components are given, they are
+        // automatically determined for given data in computation.
+        LDA(const Mat& src, vector<int> labels,
+                int num_components = 0) :
+                    _num_components(num_components)
+        {
+            this->compute(src, labels); //! compute eigenvectors and eigenvalues
+        }
+
         // Initializes and performs a Discriminant Analysis with Fisher's
         // Optimization Criterion on given data in src and corresponding labels
         // in labels. If 0 (or less) number of components are given, they are
@@ -917,7 +928,7 @@ namespace cv
         CV_WRAP virtual void train(InputArrayOfArrays src, InputArray labels) = 0;
 
         // Updates a FaceRecognizer.
-        CV_WRAP virtual void update(InputArrayOfArrays src, InputArray labels);
+        CV_WRAP void update(InputArrayOfArrays src, InputArray labels);
 
         // Gets a prediction from a FaceRecognizer.
         virtual int predict(InputArray src) const = 0;

modules/contrib/include/opencv2/contrib/detection_based_tracker.hpp

@@ -12,66 +12,17 @@ class DetectionBasedTracker
     public:
         struct Parameters
         {
+            int minObjectSize;
+            int maxObjectSize;
+            double scaleFactor;
             int maxTrackLifetime;
+            int minNeighbors;
             int minDetectionPeriod; //the minimal time between run of the big object detector (on the whole frame) in ms (1000 mean 1 sec), default=0
 
             Parameters();
         };
 
-        class IDetector
-        {
-            public:
-                IDetector():
-                    minObjSize(96, 96),
-                    maxObjSize(INT_MAX, INT_MAX),
-                    minNeighbours(2),
-                    scaleFactor(1.1f)
-                {}
-                virtual ~IDetector() {}
-
-                virtual void detect(const cv::Mat& image, std::vector<cv::Rect>& objects) = 0;
-
-                void setMinObjectSize(const cv::Size& min)
-                {
-                    minObjSize = min;
-                }
-                void setMaxObjectSize(const cv::Size& max)
-                {
-                    maxObjSize = max;
-                }
-                cv::Size getMinObjectSize() const
-                {
-                    return minObjSize;
-                }
-                cv::Size getMaxObjectSize() const
-                {
-                    return maxObjSize;
-                }
-                float getScaleFactor()
-                {
-                    return scaleFactor;
-                }
-                void setScaleFactor(float value)
-                {
-                    scaleFactor = value;
-                }
-                int getMinNeighbours()
-                {
-                    return minNeighbours;
-                }
-                void setMinNeighbours(int value)
-                {
-                    minNeighbours = value;
-                }
-
-            protected:
-                cv::Size minObjSize;
-                cv::Size maxObjSize;
-                int minNeighbours;
-                float scaleFactor;
-        };
-
-        DetectionBasedTracker(cv::Ptr<IDetector> mainDetector, cv::Ptr<IDetector> trackingDetector, const Parameters& params);
+        DetectionBasedTracker(const std::string& cascadeFilename, const Parameters& params);
         virtual ~DetectionBasedTracker();
 
         virtual bool run();
@@ -81,39 +32,19 @@ class DetectionBasedTracker
         virtual void process(const cv::Mat& imageGray);
 
         bool setParameters(const Parameters& params);
-        const Parameters& getParameters() const;
+        const Parameters& getParameters();
 
         
         typedef std::pair<cv::Rect, int> Object;
         virtual void getObjects(std::vector<cv::Rect>& result) const;
         virtual void getObjects(std::vector<Object>& result) const;
 
-        enum ObjectStatus
-        {
-            DETECTED_NOT_SHOWN_YET,
-            DETECTED,
-            DETECTED_TEMPORARY_LOST,
-            WRONG_OBJECT
-        };
-        struct ExtObject
-        {
-            int id;
-            cv::Rect location;
-            ObjectStatus status;
-            ExtObject(int _id, cv::Rect _location, ObjectStatus _status)
-                :id(_id), location(_location), status(_status)
-            {
-            }
-        };
-        virtual void getObjects(std::vector<ExtObject>& result) const;
-
-        virtual int addObject(const cv::Rect& location); //returns id of the new object
-
     protected:
         class SeparateDetectionWork;
         cv::Ptr<SeparateDetectionWork> separateDetectionWork;
         friend void* workcycleObjectDetectorFunction(void* p);
 
+
         struct InnerParameters
         {
             int numLastPositionsToTrack;
@@ -159,11 +90,11 @@ class DetectionBasedTracker
         std::vector<float> weightsPositionsSmoothing;
         std::vector<float> weightsSizesSmoothing;
 
-        cv::Ptr<IDetector> cascadeForTracking;
+        cv::CascadeClassifier cascadeForTracking;
+
 
         void updateTrackedObjects(const std::vector<cv::Rect>& detectedObjects);
         cv::Rect calcTrackedObjectPositionToShow(int i) const;
-        cv::Rect calcTrackedObjectPositionToShow(int i, ObjectStatus& status) const;
         void detectInRegion(const cv::Mat& img, const cv::Rect& r, std::vector<cv::Rect>& detectedObjectsInRegions);
 };