Made changes per review

segmentation/include/pcl/segmentation/conditional_euclidean_clustering.h

@@ -99,8 +99,6 @@ namespace pcl
       ConditionalEuclideanClustering (bool extract_removed_clusters = false) :
           searcher_ (),
           condition_function_ (),
-
-          max_cluster_size_ (std::numeric_limits<int>::max ()),
           extract_removed_clusters_ (extract_removed_clusters),
           small_clusters_ (new pcl::IndicesClusters),
           large_clusters_ (new pcl::IndicesClusters)
@@ -248,10 +246,10 @@ namespace pcl
       int min_cluster_size_{1};
 
       /** \brief The maximum cluster size (default = unlimited) */
-      int max_cluster_size_{0};
+      int max_cluster_size_{std::numeric_limits<int>::max ()};
 
       /** \brief Set to true if you want to be able to extract the clusters that are too large or too small (default = false) */
-      bool extract_removed_clusters_{false};
+      bool extract_removed_clusters_;
 
       /** \brief The resultant clusters that contain less than min_cluster_size points */
       pcl::IndicesClustersPtr small_clusters_{nullptr};

segmentation/include/pcl/segmentation/extract_clusters.h

@@ -337,10 +337,7 @@ namespace pcl
 
       //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       /** \brief Empty constructor. */
-      EuclideanClusterExtraction () : tree_ (), 
-
-                                      max_pts_per_cluster_ (std::numeric_limits<pcl::uindex_t>::max ())
-      {};
+      EuclideanClusterExtraction () : tree_ () {};
 
       /** \brief Provide a pointer to the search object.
         * \param[in] tree a pointer to the spatial search object.
@@ -422,7 +419,7 @@ namespace pcl
       using BasePCLBase::deinitCompute;
 
       /** \brief A pointer to the spatial search object. */
-      KdTreePtr tree_;
+      KdTreePtr tree_{nullptr};
 
       /** \brief The spatial cluster tolerance as a measure in the L2 Euclidean space. */
       double cluster_tolerance_{0.0};
@@ -431,7 +428,7 @@ namespace pcl
       pcl::uindex_t min_pts_per_cluster_{1};
 
       /** \brief The maximum number of points that a cluster needs to contain in order to be considered valid (default = MAXINT). */
-      pcl::uindex_t max_pts_per_cluster_{0};
+      pcl::uindex_t max_pts_per_cluster_{std::numeric_limits<pcl::uindex_t>::max()};
 
       /** \brief Class getName method. */
       virtual std::string getClassName () const { return ("EuclideanClusterExtraction"); }

segmentation/include/pcl/segmentation/extract_labeled_clusters.h

@@ -115,11 +115,7 @@ class LabeledEuclideanClusterExtraction : public PCLBase<PointT> {
 
   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   /** \brief Empty constructor. */
-  LabeledEuclideanClusterExtraction()
-  : tree_()
-  , 
-   max_pts_per_cluster_(std::numeric_limits<int>::max())
-  , max_label_(std::numeric_limits<int>::max()){};
+  LabeledEuclideanClusterExtraction() = default;
 
   /** \brief Provide a pointer to the search object.
    * \param[in] tree a pointer to the spatial search object.
@@ -221,7 +217,7 @@ class LabeledEuclideanClusterExtraction : public PCLBase<PointT> {
   using BasePCLBase::input_;
 
   /** \brief A pointer to the spatial search object. */
-  KdTreePtr tree_;
+  KdTreePtr tree_{nullptr};
 
   /** \brief The spatial cluster tolerance as a measure in the L2 Euclidean space. */
   double cluster_tolerance_{0};
@@ -232,11 +228,11 @@ class LabeledEuclideanClusterExtraction : public PCLBase<PointT> {
 
   /** \brief The maximum number of points that a cluster needs to contain in order to be
    * considered valid (default = MAXINT). */
-  int max_pts_per_cluster_;
+  int max_pts_per_cluster_{std::numeric_limits<int>::max()};
 
   /** \brief The maximum number of labels we can find in this pointcloud (default =
    * MAXINT)*/
-  unsigned int max_label_;
+  unsigned int max_label_{0};
 
   /** \brief Class getName method. */
   virtual std::string

segmentation/include/pcl/segmentation/extract_polygonal_prism_data.h

@@ -115,9 +115,7 @@ namespace pcl
       using PointIndicesConstPtr = PointIndices::ConstPtr;
 
       /** \brief Empty constructor. */
-      ExtractPolygonalPrismData () : planar_hull_ (), 
-                                     height_limit_max_(std::numeric_limits<float>::max()) 
-      {};
+      ExtractPolygonalPrismData () = default;
 
       /** \brief Provide a pointer to the input planar hull dataset.
         * \note Please see the example in the class description for how to obtain this.
@@ -198,7 +196,7 @@ namespace pcl
       /** \brief The maximum allowed height (distance to the model) a point
         * will be considered from. 
         */
-      double height_limit_max_{0.0};
+      double height_limit_max_{std::numeric_limits<float>::max()};
 
       /** \brief Values describing the data acquisition viewpoint. Default: 0,0,0. */
       float vpx_{0}, vpy_{0}, vpz_{0};

segmentation/include/pcl/segmentation/region_growing.h

@@ -282,7 +282,7 @@ namespace pcl
       pcl::uindex_t min_pts_per_cluster_{1};
 
       /** \brief Stores the maximum number of points that a cluster needs to contain in order to be considered valid. */
-      pcl::uindex_t max_pts_per_cluster_{0};
+      pcl::uindex_t max_pts_per_cluster_{std::numeric_limits<pcl::uindex_t>::max()};
 
       /** \brief Flag that signalizes if the smoothness constraint will be used. */
       bool smooth_mode_flag_{true};
@@ -294,7 +294,7 @@ namespace pcl
       bool residual_flag_{false};
 
       /** \brief Threshold used for testing the smoothness between points. */
-      float theta_threshold_{0.0f};
+      float theta_threshold_{30.0f / 180.0f * static_cast<float>(M_PI)};
 
       /** \brief Threshold used in residual test. */
       float residual_threshold_{0.05f};

segmentation/include/pcl/segmentation/sac_segmentation.h

@@ -84,10 +84,6 @@ namespace pcl
       SACSegmentation(bool random = false)
       : model_()
       , sac_()
-      , radius_min_(-std::numeric_limits<double>::max())
-      , radius_max_(std::numeric_limits<double>::max())
-      , samples_radius_search_()
-      , axis_(Eigen::Vector3f::Zero())
       , random_(random)
       {}
 
@@ -272,7 +268,7 @@ namespace pcl
       bool optimize_coefficients_{true};
 
       /** \brief The minimum and maximum radius limits for the model. Applicable to all models that estimate a radius. */
-      double radius_min_{0.0}, radius_max_{0.0};
+      double radius_min_{-std::numeric_limits<double>::max()}, radius_max_{std::numeric_limits<double>::max()};
 
       /** \brief The maximum distance of subsequent samples from the first (radius search) */
       double samples_radius_{0.0};
@@ -284,7 +280,7 @@ namespace pcl
       double eps_angle_{0.0};
 
       /** \brief The axis along which we need to search for a model perpendicular to. */
-      Eigen::Vector3f axis_{};
+      Eigen::Vector3f axis_{Eigen::Vector3f::Zero()};
 
       /** \brief Maximum number of iterations before giving up (user given parameter). */
       int max_iterations_{50};
@@ -296,7 +292,7 @@ namespace pcl
       double probability_{0.99};
 
       /** \brief Set to true if we need a random seed. */
-      bool random_{false};
+      bool random_;
 
       /** \brief Class get name method. */
       virtual std::string