Part H of transition to support modernize-use-default-member-init (#5899)

* Part H of transition to support modernize-use-default-member-init

* Updated per inspection

* Corrected formatting complaints

* Addressed CI clang-tidy issues

* Fixed another CI clang-tidy complaint

* Fixed yet more CI clang-tidy issues

* Made changes per review

* Fixed some typos

* Addressed more review changes

* Fixed new clang-tidy CI complaints

* Fixed clang-format CI complaint

* Fixed another piecemeal clang-format complaint

* Made more changes per review

* Fixed missed review comment

Author: gnawme

.clang-tidy

@@ -12,6 +12,8 @@ Checks: >
     modernize-return-braced-init-list,
     modernize-shrink-to-fit,
     modernize-use-auto,
+    modernize-use-bool-literals,
+    modernize-use-default-member-init,
     modernize-use-emplace,
     modernize-use-equals-default,
     modernize-use-equals-delete,

features/include/pcl/features/cvfh.h

@@ -212,7 +212,7 @@ namespace pcl
       /** \brief Values describing the viewpoint ("pinhole" camera model assumed). 
         * By default, the viewpoint is set to 0,0,0.
         */
-      float vpx_{0}, vpy_{0}, vpz_{0};
+      float vpx_{0.0f}, vpy_{0.0f}, vpz_{0.0f};
 
       /** \brief Size of the voxels after voxel gridding. IMPORTANT: Must match the voxel 
         * size of the training data or the normalize_bins_ flag must be set to true.

features/include/pcl/features/impl/esf.hpp

@@ -66,18 +66,18 @@ pcl::ESFEstimation<PointInT, PointOutT>::computeESF (
   wt_d2.reserve (sample_size * 3);
   wt_d3.reserve (sample_size);
 
-  float h_in[binsize] = {0};
-  float h_out[binsize] = {0};
-  float h_mix[binsize] = {0};
-  float h_mix_ratio[binsize] = {0};
-
-  float h_a3_in[binsize] = {0};
-  float h_a3_out[binsize] = {0};
-  float h_a3_mix[binsize] = {0};
-
-  float h_d3_in[binsize] = {0};
-  float h_d3_out[binsize] = {0};
-  float h_d3_mix[binsize] = {0};
+  float h_in[binsize] = {0.0f};
+  float h_out[binsize] = {0.0f};
+  float h_mix[binsize] = {0.0f};
+  float h_mix_ratio[binsize] = {0.0f};
+
+  float h_a3_in[binsize] = {0.0f};
+  float h_a3_out[binsize] = {0.0f};
+  float h_a3_mix[binsize] = {0.0f};
+
+  float h_d3_in[binsize] = {0.0f};
+  float h_d3_out[binsize] = {0.0f};
+  float h_d3_mix[binsize] = {0.0f};
 
   float ratio=0.0;
   float pih = static_cast<float>(M_PI) / 2.0f;

io/include/pcl/io/ensenso_grabber.h

@@ -443,13 +443,13 @@ namespace pcl
       boost::signals2::signal<sig_cb_ensenso_point_cloud_images>* point_cloud_images_signal_;
 
       /** @brief Whether an Ensenso device is opened or not */
-      bool device_open_;
+      bool device_open_{false};
 
       /** @brief Whether an TCP port is opened or not */
-      bool tcp_open_;
+      bool tcp_open_{false};
 
       /** @brief Whether an Ensenso device is running or not */
-      bool running_;
+      bool running_{false};
 
       /** @brief Point cloud capture/processing frequency */
       pcl::EventFrequency frequency_;

io/include/pcl/io/openni2/openni2_device.h

@@ -315,16 +315,16 @@ namespace pcl
           mutable std::vector<OpenNI2VideoMode> color_video_modes_;
           mutable std::vector<OpenNI2VideoMode> depth_video_modes_;
 
-          bool ir_video_started_;
-          bool color_video_started_;
-          bool depth_video_started_;
+          bool ir_video_started_{false};
+          bool color_video_started_{false};
+          bool depth_video_started_{false};
 
           /** \brief distance between the projector and the IR camera in meters*/
-          float baseline_;
+          float baseline_{0.0f};
           /** the value for shadow (occluded pixels) */
-          std::uint64_t shadow_value_;
+          std::uint64_t shadow_value_{0};
           /** the value for pixels without a valid disparity measurement */
-          std::uint64_t no_sample_value_;
+          std::uint64_t no_sample_value_{0};
       };
 
       PCL_EXPORTS std::ostream& operator<< (std::ostream& stream, const OpenNI2Device& device);

io/include/pcl/io/openni2_grabber.h

@@ -421,9 +421,9 @@ namespace pcl
         convertToXYZIPointCloud (const pcl::io::openni2::IRImage::Ptr &image,
           const pcl::io::openni2::DepthImage::Ptr &depth_image);
 
-        std::vector<std::uint8_t> color_resize_buffer_;
-        std::vector<std::uint16_t> depth_resize_buffer_;
-        std::vector<std::uint16_t> ir_resize_buffer_;
+        std::vector<std::uint8_t> color_resize_buffer_{};
+        std::vector<std::uint16_t> depth_resize_buffer_{};
+        std::vector<std::uint16_t> ir_resize_buffer_{};
 
         // Stream callbacks /////////////////////////////////////////////////////
         void
@@ -444,25 +444,25 @@ namespace pcl
 
         std::string rgb_frame_id_;
         std::string depth_frame_id_;
-        unsigned image_width_;
-        unsigned image_height_;
-        unsigned depth_width_;
-        unsigned depth_height_;
-
-        bool image_required_;
-        bool depth_required_;
-        bool ir_required_;
-        bool sync_required_;
-
-        boost::signals2::signal<sig_cb_openni_image>* image_signal_;
-        boost::signals2::signal<sig_cb_openni_depth_image>* depth_image_signal_;
-        boost::signals2::signal<sig_cb_openni_ir_image>* ir_image_signal_;
-        boost::signals2::signal<sig_cb_openni_image_depth_image>* image_depth_image_signal_;
-        boost::signals2::signal<sig_cb_openni_ir_depth_image>* ir_depth_image_signal_;
-        boost::signals2::signal<sig_cb_openni_point_cloud>* point_cloud_signal_;
-        boost::signals2::signal<sig_cb_openni_point_cloud_i>* point_cloud_i_signal_;
-        boost::signals2::signal<sig_cb_openni_point_cloud_rgb>* point_cloud_rgb_signal_;
-        boost::signals2::signal<sig_cb_openni_point_cloud_rgba>* point_cloud_rgba_signal_;
+        unsigned image_width_{0};
+        unsigned image_height_{0};
+        unsigned depth_width_{0};
+        unsigned depth_height_{0};
+
+        bool image_required_{false};
+        bool depth_required_{false};
+        bool ir_required_{false};
+        bool sync_required_{false};
+
+        boost::signals2::signal<sig_cb_openni_image>* image_signal_{};
+        boost::signals2::signal<sig_cb_openni_depth_image>* depth_image_signal_{};
+        boost::signals2::signal<sig_cb_openni_ir_image>* ir_image_signal_{};
+        boost::signals2::signal<sig_cb_openni_image_depth_image>* image_depth_image_signal_{};
+        boost::signals2::signal<sig_cb_openni_ir_depth_image>* ir_depth_image_signal_{};
+        boost::signals2::signal<sig_cb_openni_point_cloud>* point_cloud_signal_{};
+        boost::signals2::signal<sig_cb_openni_point_cloud_i>* point_cloud_i_signal_{};
+        boost::signals2::signal<sig_cb_openni_point_cloud_rgb>* point_cloud_rgb_signal_{};
+        boost::signals2::signal<sig_cb_openni_point_cloud_rgba>* point_cloud_rgba_signal_{};
 
         struct modeComp
         {
@@ -483,14 +483,13 @@ namespace pcl
         // Mapping from config (enum) modes to native OpenNI modes
         std::map<int, pcl::io::openni2::OpenNI2VideoMode> config2oni_map_;
 
-        pcl::io::openni2::OpenNI2Device::CallbackHandle depth_callback_handle_;
-        pcl::io::openni2::OpenNI2Device::CallbackHandle image_callback_handle_;
-        pcl::io::openni2::OpenNI2Device::CallbackHandle ir_callback_handle_;
-        bool running_;
+        pcl::io::openni2::OpenNI2Device::CallbackHandle depth_callback_handle_{};
+        pcl::io::openni2::OpenNI2Device::CallbackHandle image_callback_handle_{};
+        pcl::io::openni2::OpenNI2Device::CallbackHandle ir_callback_handle_{};
+        bool running_{false};
 
-
-        CameraParameters rgb_parameters_;
-        CameraParameters depth_parameters_;
+        CameraParameters rgb_parameters_{std::numeric_limits<double>::quiet_NaN ()};
+        CameraParameters depth_parameters_{std::numeric_limits<double>::quiet_NaN ()};
 
       public:
         PCL_MAKE_ALIGNED_OPERATOR_NEW

io/include/pcl/io/real_sense_2_grabber.h

@@ -199,17 +199,17 @@ namespace pcl
     /** \brief Repeat playback when reading from file */
     bool repeat_playback_;
     /** \brief controlling the state of the thread. */
-    bool quit_;
+    bool quit_{false};
     /** \brief Is the grabber running. */
-    bool running_;
+    bool running_{false};
     /** \brief Calculated FPS for the grabber. */
-    float fps_;
+    float fps_{0.0f};
     /** \brief Width for the depth and color sensor. Default 424*/
-    std::uint32_t device_width_;
+    std::uint32_t device_width_{424};
     /** \brief Height for the depth and color sensor. Default 240 */
-    std::uint32_t device_height_;
+    std::uint32_t device_height_{240};
     /** \brief Target FPS for the device. Default 30. */
-    std::uint32_t target_fps_;
+    std::uint32_t target_fps_{30};
     /** \brief Declare pointcloud object, for calculating pointclouds and texture mappings */
     rs2::pointcloud pc_;
     /** \brief Declare RealSense pipeline, encapsulating the actual device and sensors */

io/src/ensenso_grabber.cpp

@@ -62,10 +62,7 @@ ensensoExceptionHandling (const NxLibException& ex,
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-pcl::EnsensoGrabber::EnsensoGrabber () :
-    device_open_ (false),
-    tcp_open_ (false),
-    running_ (false)
+pcl::EnsensoGrabber::EnsensoGrabber ()
 {
   point_cloud_signal_ = createSignal<sig_cb_ensenso_point_cloud> ();
   images_signal_ = createSignal<sig_cb_ensenso_images> ();

io/src/openni2/openni2_device.cpp

@@ -48,10 +48,7 @@ using namespace pcl::io::openni2;
 using openni::VideoMode;
 using std::vector;
 
-pcl::io::openni2::OpenNI2Device::OpenNI2Device (const std::string& device_URI) :
-  ir_video_started_(false),
-  color_video_started_(false),
-  depth_video_started_(false)
+pcl::io::openni2::OpenNI2Device::OpenNI2Device (const std::string& device_URI)
 {
   openni::Status status = openni::OpenNI::initialize ();
   if (status != openni::STATUS_OK)

io/src/openni2_grabber.cpp

@@ -73,24 +73,6 @@ namespace
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 pcl::io::OpenNI2Grabber::OpenNI2Grabber (const std::string& device_id, const Mode& depth_mode, const Mode& image_mode)
-  : color_resize_buffer_(0)
-  , depth_resize_buffer_(0)
-  , ir_resize_buffer_(0)
-  , image_width_ ()
-  , image_height_ ()
-  , depth_width_ ()
-  , depth_height_ ()
-  , image_required_ (false)
-  , depth_required_ (false)
-  , ir_required_ (false)
-  , sync_required_ (false)
-  , image_signal_ (), depth_image_signal_ (), ir_image_signal_ (), image_depth_image_signal_ ()
-  , ir_depth_image_signal_ (), point_cloud_signal_ (), point_cloud_i_signal_ ()
-  , point_cloud_rgb_signal_ (), point_cloud_rgba_signal_ ()
-  , depth_callback_handle_ (), image_callback_handle_ (), ir_callback_handle_ ()
-  , running_ (false)
-  , rgb_parameters_(std::numeric_limits<double>::quiet_NaN () )
-  , depth_parameters_(std::numeric_limits<double>::quiet_NaN () )
 {
   // initialize driver
   updateModeMaps (); // registering mapping from PCL enum modes to openni::VideoMode and vice versa