fixed DynamicAdaptedFeatureDetector

diff --git a/modules/features2d/include/opencv2/features2d/features2d.hpp b/modules/features2d/include/opencv2/features2d/features2d.hpp
index 31a14d0..6383361 100644 (file)
--- a/modules/features2d/include/opencv2/features2d/features2d.hpp
+++ b/modules/features2d/include/opencv2/features2d/features2d.hpp
@@ -1487,20 +1487,22 @@ public:
        /** pure virtual interface
         */
     virtual ~AdjusterAdapter() {}
-       /** too few features were detected so, adjust the detector params accordingly
-        * \param min the minimum number of desired features
-        * \param n_detected the number previously detected
-        */
-       virtual void tooFew(int min, int n_detected) = 0;
-       /** too many features were detected so, adjust the detector params accordingly
-        * \param max the maximum number of desired features
-        * \param n_detected the number previously detected
-        */
-       virtual void tooMany(int max, int n_detected) = 0;
-       /** are params maxed out or still valid?
-        * \return false if the parameters can't be adjusted any more
-        */
-       virtual bool good() const = 0;
+    /** too few features were detected so, adjust the detector params accordingly
+     * \param min the minimum number of desired features
+     * \param n_detected the number previously detected
+     */
+    virtual void tooFew(int min, int n_detected) = 0;
+    /** too many features were detected so, adjust the detector params accordingly
+     * \param max the maximum number of desired features
+     * \param n_detected the number previously detected
+     */
+    virtual void tooMany(int max, int n_detected) = 0;
+    /** are params maxed out or still valid?
+     * \return false if the parameters can't be adjusted any more
+     */
+    virtual bool good() const = 0;
+
+    virtual Ptr<AdjusterAdapter> clone() const = 0;
 
     static Ptr<AdjusterAdapter> create( const string& detectorType );
 };
@@ -1521,11 +1523,11 @@ class CV_EXPORTS DynamicAdaptedFeatureDetector: public FeatureDetector
 public:
 
     /** \param adjaster an AdjusterAdapter that will do the detection and parameter adjustment
-        * \param max_features the maximum desired number of features
-        * \param max_iters the maximum number of times to try to adjust the feature detector params
-        *                      for the FastAdjuster this can be high, but with Star or Surf this can get time consuming
-     * \param min_features the minimum desired features
-        */
+     *  \param max_features the maximum desired number of features
+     *  \param max_iters the maximum number of times to try to adjust the feature detector params
+     *                         for the FastAdjuster this can be high, but with Star or Surf this can get time consuming
+     *  \param min_features the minimum desired features
+     */
     DynamicAdaptedFeatureDetector( const Ptr<AdjusterAdapter>& adjaster, int min_features=400, int max_features=500, int max_iters=5 );
 
     virtual bool empty() const;
@@ -1534,30 +1536,34 @@ protected:
     virtual void detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask=Mat() ) const;
 
 private:
-       int escape_iters_;
-       int min_features_, max_features_;
-       Ptr<AdjusterAdapter> adjuster_;
+    int escape_iters_;
+    int min_features_, max_features_;
+    const Ptr<AdjusterAdapter> adjuster_;
 };
 
 /**\brief an adjust for the FAST detector. This will basically decrement or increment the
- * threshhold by 1
+ * threshold by 1
  */
 class CV_EXPORTS FastAdjuster: public AdjusterAdapter
 {
 public:
-       /**\param init_thresh the initial threshhold to start with, default = 20
-        * \param nonmax whether to use non max or not for fast feature detection
-        */
-       FastAdjuster(int init_thresh = 20, bool nonmax = true);
-       virtual void tooFew(int min, int n_detected);
-       virtual void tooMany(int max, int n_detected);
-       virtual bool good() const;
+    /**\param init_thresh the initial threshold to start with, default = 20
+     * \param nonmax whether to use non max or not for fast feature detection
+     */
+    FastAdjuster(int init_thresh = 20, bool nonmax = true);
+
+    virtual void tooFew(int min, int n_detected);
+    virtual void tooMany(int max, int n_detected);
+    virtual bool good() const;
+
+    virtual Ptr<AdjusterAdapter> clone() const;
 
 protected:
     virtual void detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask=Mat() ) const;
 
-       int thresh_;
-       bool nonmax_;
+    int thresh_;
+    bool nonmax_;
+    int init_thresh_;
 };
 
 
@@ -1567,30 +1573,36 @@ protected:
 class CV_EXPORTS StarAdjuster: public AdjusterAdapter
 {
 public:
-       StarAdjuster(double initial_thresh = 30.0);
-       virtual void tooFew(int min, int n_detected);
-       virtual void tooMany(int max, int n_detected);
-       virtual bool good() const;
+    StarAdjuster(double initial_thresh = 30.0);
+
+    virtual void tooFew(int min, int n_detected);
+    virtual void tooMany(int max, int n_detected);
+    virtual bool good() const;
+
+    virtual Ptr<AdjusterAdapter> clone() const;
 
 protected:
     virtual void detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask=Mat() ) const;
 
-       double thresh_;
-       CvStarDetectorParams params_; //todo use these instead of thresh_
+    double thresh_, init_thresh_;
+    CvStarDetectorParams params_; //todo use these instead of thresh_
 };
 
 class CV_EXPORTS SurfAdjuster: public AdjusterAdapter
 {
 public:
-    SurfAdjuster();
-       virtual void tooFew(int min, int n_detected);
-       virtual void tooMany(int max, int n_detected);
-       virtual bool good() const;
+    SurfAdjuster( double initial_thresh=400.f );
+
+    virtual void tooFew(int min, int n_detected);
+    virtual void tooMany(int max, int n_detected);
+    virtual bool good() const;
+
+    virtual Ptr<AdjusterAdapter> clone() const;
 
 protected:
     virtual void detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask=Mat() ) const;
 
-       double thresh_;
+    double thresh_, init_thresh_;
 };
 
 CV_EXPORTS Mat windowedMatchingMask( const vector<KeyPoint>& keypoints1, const vector<KeyPoint>& keypoints2,

diff --git a/modules/features2d/src/dynamic.cpp b/modules/features2d/src/dynamic.cpp
index 8d12b2a..9495eb6 100644 (file)
--- a/modules/features2d/src/dynamic.cpp
+++ b/modules/features2d/src/dynamic.cpp
@@ -56,124 +56,143 @@ bool DynamicAdaptedFeatureDetector::empty() const
 
 void DynamicAdaptedFeatureDetector::detectImpl(const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask) const
 {
-       //for oscillation testing
-       bool down = false;
-       bool up = false;
+    //for oscillation testing
+    bool down = false;
+    bool up = false;
 
-       //flag for whether the correct threshhold has been reached
-       bool thresh_good = false;
+    //flag for whether the correct threshhold has been reached
+    bool thresh_good = false;
 
-       //this is bad but adjuster should persist from detection to detection
-       AdjusterAdapter& adjuster = const_cast<AdjusterAdapter&> (*adjuster_);
+    Ptr<AdjusterAdapter> adjuster = adjuster_->clone();
 
-       //break if the desired number hasn't been reached.
-       int iter_count = escape_iters_;
+    //break if the desired number hasn't been reached.
+    int iter_count = escape_iters_;
 
-    do
+    while( iter_count > 0 && !(down && up) && !thresh_good && adjuster->good() )
     {
-               keypoints.clear();
+        keypoints.clear();
 
-               //the adjuster takes care of calling the detector with updated parameters
-               adjuster.detect(image, keypoints,mask);
+        //the adjuster takes care of calling the detector with updated parameters
+        adjuster->detect(image, keypoints,mask);
 
-        if (int(keypoints.size()) < min_features_)
+        if( int(keypoints.size()) < min_features_ )
         {
-                       down = true;
-                       adjuster.tooFew(min_features_, (int)keypoints.size());
+            down = true;
+            adjuster->tooFew(min_features_, (int)keypoints.size());
         }
-        else if (int(keypoints.size()) > max_features_)
+        else if( int(keypoints.size()) > max_features_ )
         {
-                       up = true;
-                       adjuster.tooMany(max_features_, (int)keypoints.size());
+            up = true;
+            adjuster->tooMany(max_features_, (int)keypoints.size());
         }
         else
-                       thresh_good = true;
+            thresh_good = true;
+
+        iter_count--;
     }
-    while (--iter_count >= 0 && !(down && up) && !thresh_good && adjuster.good());
+
 }
 
 FastAdjuster::FastAdjuster(int init_thresh, bool nonmax) :
-    thresh_(init_thresh), nonmax_(nonmax)
+    thresh_(init_thresh), nonmax_(nonmax), init_thresh_(init_thresh)
 {}
 
 void FastAdjuster::detectImpl(const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask) const
 {
-       FastFeatureDetector(thresh_, nonmax_).detect(image, keypoints, mask);
+    FastFeatureDetector(thresh_, nonmax_).detect(image, keypoints, mask);
 }
 
 void FastAdjuster::tooFew(int, int)
 {
-       //fast is easy to adjust
-       thresh_--;
+    //fast is easy to adjust
+    thresh_--;
 }
 
 void FastAdjuster::tooMany(int, int)
 {
-       //fast is easy to adjust
-       thresh_++;
+    //fast is easy to adjust
+    thresh_++;
 }
 
 //return whether or not the threshhold is beyond
 //a useful point
 bool FastAdjuster::good() const
 {
-       return (thresh_ > 1) && (thresh_ < 200);
+    return (thresh_ > 1) && (thresh_ < 200);
+}
+
+Ptr<AdjusterAdapter> FastAdjuster::clone() const
+{
+    Ptr<AdjusterAdapter> cloned_obj = new FastAdjuster( init_thresh_, nonmax_ );
+    return cloned_obj;
 }
 
 StarAdjuster::StarAdjuster(double initial_thresh) :
-    thresh_(initial_thresh)
+    thresh_(initial_thresh), init_thresh_(initial_thresh)
 {}
 
 void StarAdjuster::detectImpl(const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask) const
 {
-       StarFeatureDetector detector_tmp(16, cvRound(thresh_), 10, 8, 3);
-       detector_tmp.detect(image, keypoints, mask);
+    StarFeatureDetector detector_tmp(16, cvRound(thresh_), 10, 8, 3);
+    detector_tmp.detect(image, keypoints, mask);
 }
 
 void StarAdjuster::tooFew(int, int)
 {
-       thresh_ *= 0.9;
-       if (thresh_ < 1.1)
-               thresh_ = 1.1;
+    thresh_ *= 0.9;
+    if (thresh_ < 1.1)
+            thresh_ = 1.1;
 }
 
 void StarAdjuster::tooMany(int, int)
 {
-       thresh_ *= 1.1;
+    thresh_ *= 1.1;
 }
 
 bool StarAdjuster::good() const
 {
-       return (thresh_ > 2) && (thresh_ < 200);
+    return (thresh_ > 2) && (thresh_ < 200);
 }
 
-SurfAdjuster::SurfAdjuster() :
-    thresh_(400.0)
+Ptr<AdjusterAdapter> StarAdjuster::clone() const
+{
+    Ptr<AdjusterAdapter> cloned_obj = new StarAdjuster( init_thresh_ );
+    return cloned_obj;
+}
+
+SurfAdjuster::SurfAdjuster( double initial_thresh ) :
+    thresh_(initial_thresh), init_thresh_(initial_thresh)
 {}
 
 void SurfAdjuster::detectImpl(const Mat& image, vector<KeyPoint>& keypoints, const cv::Mat& mask) const
 {
-       SurfFeatureDetector detector_tmp(thresh_);
-       detector_tmp.detect(image, keypoints, mask);
+    SurfFeatureDetector detector_tmp(thresh_);
+    detector_tmp.detect(image, keypoints, mask);
 }
 
 void SurfAdjuster::tooFew(int, int)
 {
-       thresh_ *= 0.9;
-       if (thresh_ < 1.1)
-               thresh_ = 1.1;
+    thresh_ *= 0.9;
+    if (thresh_ < 1.1)
+            thresh_ = 1.1;
 }
 
 void SurfAdjuster::tooMany(int, int)
 {
-       thresh_ *= 1.1;
+    thresh_ *= 1.1;
 }
 
 //return whether or not the threshhold is beyond
 //a useful point
 bool SurfAdjuster::good() const
 {
-       return (thresh_ > 2) && (thresh_ < 1000);
+    return (thresh_ > 2) && (thresh_ < 1000);
+}
+
+Ptr<AdjusterAdapter> SurfAdjuster::clone() const
+{
+    Ptr<AdjusterAdapter> cloned_obj = new SurfAdjuster( init_thresh_ );
+    return cloned_obj;
 }
 
 Ptr<AdjusterAdapter> AdjusterAdapter::create( const string& detectorType )