fixed DynamicAdaptedFeatureDetector

modules/features2d/include/opencv2/features2d/features2d.hpp

@@ -1502,6 +1502,8 @@ public:
      */
     virtual bool good() const = 0;
 
+    virtual Ptr<AdjusterAdapter> clone() const = 0;
+
     static Ptr<AdjusterAdapter> create( const string& detectorType );
 };
 /** \brief an adaptively adjusting detector that iteratively detects until the desired number
@@ -1536,28 +1538,32 @@ protected:
 private:
     int escape_iters_;
     int min_features_, max_features_;
-	Ptr<AdjusterAdapter> adjuster_;
+    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 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 init_thresh_;
 };
 
 
@@ -1568,29 +1574,35 @@ 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;
 
+    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_;
     CvStarDetectorParams params_; //todo use these instead of thresh_
 };
 
 class CV_EXPORTS SurfAdjuster: public AdjusterAdapter
 {
 public:
-    SurfAdjuster();
+    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,

modules/features2d/src/dynamic.cpp

@@ -63,37 +63,38 @@ void DynamicAdaptedFeatureDetector::detectImpl(const Mat& image, vector<KeyPoint
     //flag for whether the correct threshhold has been reached
     bool thresh_good = false;
 
-	//this is bad but adjuster should persist from detection to detection
+    Ptr<AdjusterAdapter> adjuster = adjuster_->clone();
-	AdjusterAdapter& adjuster = const_cast<AdjusterAdapter&> (*adjuster_);
 
     //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();
 
         //the adjuster takes care of calling the detector with updated parameters
-		adjuster.detect(image, keypoints,mask);
+        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());
+            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());
+            adjuster->tooMany(max_features_, (int)keypoints.size());
         }
         else
             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
@@ -120,8 +121,14 @@ bool FastAdjuster::good() const
     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
@@ -147,8 +154,14 @@ bool StarAdjuster::good() const
     return (thresh_ > 2) && (thresh_ < 200);
 }
 
-SurfAdjuster::SurfAdjuster() :
+Ptr<AdjusterAdapter> StarAdjuster::clone() const
-    thresh_(400.0)
+{
+    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
@@ -176,6 +189,12 @@ bool SurfAdjuster::good() const
     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 )
 {
     Ptr<AdjusterAdapter> adapter;