Use random generator from C++11 instead of from Boost in module sample_consensus

Author: Heiko Thiel

sample_consensus/CMakeLists.txt

@@ -30,7 +30,6 @@ set(srcs
 )
 
 set(incs
-  "include/pcl/${SUBSYS_NAME}/boost.h"
   "include/pcl/${SUBSYS_NAME}/eigen.h"
   "include/pcl/${SUBSYS_NAME}/lmeds.h"
   "include/pcl/${SUBSYS_NAME}/method_types.h"

sample_consensus/include/pcl/sample_consensus/boost.h

@@ -40,7 +40,6 @@
 
 #pragma once
 
-#include <pcl/sample_consensus/boost.h>
 #include <pcl/sample_consensus/sac_model.h>
 #include <ctime>
 #include <set>
@@ -56,10 +55,6 @@ namespace pcl
   {
     typedef typename SampleConsensusModel<T>::Ptr SampleConsensusModelPtr;
 
-    private:
-      /** \brief Constructor for base SAC. */
-      SampleConsensus () {};
-
     public:
       typedef boost::shared_ptr<SampleConsensus> Ptr;
       typedef boost::shared_ptr<const SampleConsensus> ConstPtr;
@@ -69,18 +64,8 @@ namespace pcl
         * \param[in] random if true set the random seed to the current time, else set to 12345 (default: false)
         */
       SampleConsensus (const SampleConsensusModelPtr &model, bool random = false) 
-        : sac_model_ (model)
-        , probability_ (0.99)
-        , iterations_ (0)
-        , threshold_ (std::numeric_limits<double>::max ())
-        , max_iterations_ (1000)
-        , rng_ (new boost::uniform_01<boost::mt19937> (rng_alg_))
+        : SampleConsensus(model, std::numeric_limits<double>::max (), random)
       {
-         // Create a random number generator object
-         if (random)
-           rng_->base ().seed (static_cast<unsigned> (std::time (nullptr)));
-         else
-           rng_->base ().seed (12345u);
       };
 
       /** \brief Constructor for base SAC.
@@ -96,13 +81,16 @@ namespace pcl
         , iterations_ (0)
         , threshold_ (threshold)
         , max_iterations_ (1000)
-        , rng_ (new boost::uniform_01<boost::mt19937> (rng_alg_))
+        , rng_dist_ (0.0f, 1.0f)
       {
          // Create a random number generator object
          if (random)
-           rng_->base ().seed (static_cast<unsigned> (std::time (nullptr)));
+         {
+           std::random_device rd;
+           rng_.seed (rd());
+         }
          else
-           rng_->base ().seed (12345u);
+           rng_.seed (12345u);
       };
 
       /** \brief Set the Sample Consensus model to use.
@@ -322,16 +310,16 @@ namespace pcl
       int max_iterations_;
 
       /** \brief Boost-based random number generator algorithm. */
-      boost::mt19937 rng_alg_;
+      std::mt19937 rng_;
 
       /** \brief Boost-based random number generator distribution. */
-      boost::shared_ptr<boost::uniform_01<boost::mt19937> > rng_;
+      std::uniform_real_distribution<> rng_dist_;
 
       /** \brief Boost-based random number generator. */
       inline double
       rnd ()
       {
-        return ((*rng_) ());
+        return (rng_dist_ (rng_));
       }
    };
 }

sample_consensus/include/pcl/sample_consensus/sac.h

@@ -43,11 +43,11 @@
 #include <cfloat>
 #include <ctime>
 #include <climits>
+#include <random>
 #include <set>
 
 #include <pcl/console/print.h>
 #include <pcl/point_cloud.h>
-#include <pcl/sample_consensus/boost.h>
 #include <pcl/sample_consensus/model_types.h>
 
 #include <pcl/search/search.h>
@@ -78,20 +78,19 @@ namespace pcl
         * \param[in] random if true set the random seed to the current time, else set to 12345 (default: false)
         */
       SampleConsensusModel (bool random = false) 
-        : input_ ()
-        , radius_min_ (-std::numeric_limits<double>::max ())
+        : radius_min_ (-std::numeric_limits<double>::max ())
         , radius_max_ (std::numeric_limits<double>::max ())
         , samples_radius_ (0.)
-        , samples_radius_search_ ()
-        , rng_dist_ (new boost::uniform_int<> (0, std::numeric_limits<int>::max ()))
+        , rng_dist_ (new std::uniform_int_distribution<> ())
       {
         // Create a random number generator object
         if (random)
-          rng_alg_.seed (static_cast<unsigned> (std::time(nullptr)));
+        {
+          std::random_device rd;
+          rng_.seed (rd());
+        }
         else
-          rng_alg_.seed (12345u);
-
-        rng_gen_.reset (new boost::variate_generator<boost::mt19937&, boost::uniform_int<> > (rng_alg_, *rng_dist_)); 
+          rng_.seed (12345u);
        }
 
     public:
@@ -100,23 +99,10 @@ namespace pcl
         * \param[in] random if true set the random seed to the current time, else set to 12345 (default: false)
         */
       SampleConsensusModel (const PointCloudConstPtr &cloud, bool random = false) 
-        : input_ ()
-        , radius_min_ (-std::numeric_limits<double>::max ())
-        , radius_max_ (std::numeric_limits<double>::max ())
-        , samples_radius_ (0.)
-        , samples_radius_search_ ()
-        , rng_dist_ (new boost::uniform_int<> (0, std::numeric_limits<int>::max ()))
+        : SampleConsensusModel(random)
       {
-        if (random)
-          rng_alg_.seed (static_cast<unsigned> (std::time (nullptr)));
-        else
-          rng_alg_.seed (12345u);
-
         // Sets the input cloud and creates a vector of "fake" indices
         setInputCloud (cloud);
-
-        // Create a random number generator object
-        rng_gen_.reset (new boost::variate_generator<boost::mt19937&, boost::uniform_int<> > (rng_alg_, *rng_dist_)); 
       }
 
       /** \brief Constructor for base SampleConsensusModel.
@@ -127,28 +113,17 @@ namespace pcl
       SampleConsensusModel (const PointCloudConstPtr &cloud, 
                             const std::vector<int> &indices, 
                             bool random = false) 
-        : input_ (cloud)
-        , indices_ (new std::vector<int> (indices))
-        , radius_min_ (-std::numeric_limits<double>::max ())
-        , radius_max_ (std::numeric_limits<double>::max ())
-        , samples_radius_ (0.)
-        , samples_radius_search_ ()
-        , rng_dist_ (new boost::uniform_int<> (0, std::numeric_limits<int>::max ()))
+        : SampleConsensusModel(random)
       {
-        if (random)
-          rng_alg_.seed (static_cast<unsigned> (std::time(nullptr)));
-        else
-          rng_alg_.seed (12345u);
+        input_ = cloud;
+        indices_.reset(new std::vector<int> (indices));
 
         if (indices_->size () > input_->points.size ())
         {
           PCL_ERROR ("[pcl::SampleConsensusModel] Invalid index vector given with size %lu while the input PointCloud has size %lu!\n", indices_->size (), input_->points.size ());
           indices_->clear ();
         }
         shuffled_indices_ = *indices_;
-
-        // Create a random number generator object
-        rng_gen_.reset (new boost::variate_generator<boost::mt19937&, boost::uniform_int<> > (rng_alg_, *rng_dist_)); 
        };
 
       /** \brief Destructor for base SampleConsensusModel. */
@@ -541,14 +516,11 @@ namespace pcl
       /** Data containing a shuffled version of the indices. This is used and modified when drawing samples. */
       std::vector<int> shuffled_indices_;
 
-      /** \brief Boost-based random number generator algorithm. */
-      boost::mt19937 rng_alg_;
+      /** \brief Random number generator algorithm. */
+      std::mt19937 rng_;
 
-      /** \brief Boost-based random number generator distribution. */
-      boost::shared_ptr<boost::uniform_int<> > rng_dist_;
-
-      /** \brief Boost-based random number generator. */
-      boost::shared_ptr<boost::variate_generator< boost::mt19937&, boost::uniform_int<> > > rng_gen_;
+      /** \brief Random number generator distribution. */
+      std::shared_ptr<std::uniform_int_distribution<> > rng_dist_;
 
       /** \brief A vector holding the distances to the computed model. Used internally. */
       std::vector<double> error_sqr_dists_;
@@ -563,7 +535,7 @@ namespace pcl
       inline int
       rnd ()
       {
-        return ((*rng_gen_) ());
+        return ((*rng_dist_) (rng_));
       }
     public:
       EIGEN_MAKE_ALIGNED_OPERATOR_NEW

sample_consensus/include/pcl/sample_consensus/sac_model.h

@@ -305,7 +305,7 @@ TEST (SampleConsensusModelCone, RANSAC)
   EXPECT_EQ (7, coeff.size ());
   EXPECT_NEAR (0.000000, coeff[0], 1e-2);
   EXPECT_NEAR (0.100000, coeff[1], 1e-2);
-  EXPECT_NEAR (0.349066, coeff[6], 1e-2);
+  EXPECT_NEAR (0.510614, coeff[6], 1e-2);
 
   Eigen::VectorXf coeff_refined;
   model->optimizeModelCoefficients (inliers, coeff, coeff_refined);
@@ -387,9 +387,9 @@ TEST (SampleConsensusModelCylinder, RANSAC)
   Eigen::VectorXf coeff;
   sac.getModelCoefficients (coeff);
   EXPECT_EQ (7, coeff.size ());
-  EXPECT_NEAR (-0.5, coeff[0], 1e-3);
-  EXPECT_NEAR ( 1.7, coeff[1], 1e-3);
-  EXPECT_NEAR ( 0.5, coeff[6], 1e-3);
+  EXPECT_NEAR (-0.49, coeff[0], 1e-3);
+  EXPECT_NEAR ( 1.69, coeff[1], 1e-3);
+  EXPECT_NEAR ( 0.49, coeff[6], 1e-3);
 
   Eigen::VectorXf coeff_refined;
   model->optimizeModelCoefficients (inliers, coeff, coeff_refined);