refactor(autoware_compare_map_segmentation): resolve clang-tidy error in autoware_compare_map_segmentation (autowarefoundation#9162)

yhisaki · pre-commit-ci[bot] · web-flow · commit c5c0642be05f · 2024-10-29T13:34:14.000+09:00
* refactor(autoware_compare_map_segmentation): resolve clang-tidy error in autoware_compare_map_segmentation

Signed-off-by: Y.Hisaki &lt;yhisaki31@gmail.com&gt;

* style(pre-commit): autofix

* include message_filters as SYSTEM

Signed-off-by: Y.Hisaki &lt;yhisaki31@gmail.com&gt;

* style(pre-commit): autofix

---------

Signed-off-by: Y.Hisaki &lt;yhisaki31@gmail.com&gt;
Co-authored-by: pre-commit-ci[bot] &lt;66853113+pre-commit-ci[bot]@users.noreply.github.com&gt;
diff --git a/perception/autoware_compare_map_segmentation/src/compare_elevation_map_filter/node.cpp b/perception/autoware_compare_map_segmentation/src/compare_elevation_map_filter/node.cpp
@@ -29,9 +29,7 @@
 #include <pcl_conversions/pcl_conversions.h>
 #include <rcutils/filesystem.h>  // To be replaced by std::filesystem in C++17
 
-#include <memory>
 #include <string>
-#include <utility>
 
 namespace autoware::compare_map_segmentation
 {
diff --git a/perception/autoware_compare_map_segmentation/src/compare_elevation_map_filter/node.hpp b/perception/autoware_compare_map_segmentation/src/compare_elevation_map_filter/node.hpp
@@ -24,11 +24,7 @@
 
 #include <grid_map_msgs/msg/grid_map.hpp>
 
-#include <iostream>
-#include <memory>
-#include <mutex>
 #include <string>
-#include <vector>
 namespace autoware::compare_map_segmentation
 {
 class CompareElevationMapFilterComponent : public autoware::pointcloud_preprocessor::Filter
diff --git a/perception/autoware_compare_map_segmentation/src/distance_based_compare_map_filter/node.cpp b/perception/autoware_compare_map_segmentation/src/distance_based_compare_map_filter/node.cpp
@@ -51,10 +51,10 @@ bool DistanceBasedStaticMapLoader::is_close_to_map(
   if (!is_initialized_.load(std::memory_order_acquire)) {
     return false;
   }
-  if (map_ptr_ == NULL) {
+  if (map_ptr_ == nullptr) {
     return false;
   }
-  if (tree_ == NULL) {
+  if (tree_ == nullptr) {
     return false;
   }
 
@@ -89,8 +89,8 @@ bool DistanceBasedDynamicMapLoader::is_close_to_map(
   if (static_cast<size_t>(map_grid_index) >= current_voxel_grid_array_.size()) {
     return false;
   }
-  if (current_voxel_grid_array_.at(map_grid_index) != NULL) {
-    if (current_voxel_grid_array_.at(map_grid_index)->map_cell_kdtree == NULL) {
+  if (current_voxel_grid_array_.at(map_grid_index) != nullptr) {
+    if (current_voxel_grid_array_.at(map_grid_index)->map_cell_kdtree == nullptr) {
       return false;
     }
     std::vector<int> nn_indices(1);
diff --git a/perception/autoware_compare_map_segmentation/src/distance_based_compare_map_filter/node.hpp b/perception/autoware_compare_map_segmentation/src/distance_based_compare_map_filter/node.hpp
@@ -24,14 +24,13 @@
 
 #include <memory>
 #include <string>
-#include <vector>
 
 namespace autoware::compare_map_segmentation
 {
 
-typedef typename pcl::Filter<pcl::PointXYZ>::PointCloud PointCloud;
-typedef typename PointCloud::Ptr PointCloudPtr;
-typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+using PointCloud = typename pcl::Filter<pcl::PointXYZ>::PointCloud;
+using PointCloudPtr = typename PointCloud::Ptr;
+using PointCloudConstPtr = typename PointCloud::ConstPtr;
 
 class DistanceBasedStaticMapLoader : public VoxelGridStaticMapLoader
 {
@@ -102,8 +101,8 @@ class DistanceBasedDynamicMapLoader : public VoxelGridDynamicMapLoader
 class DistanceBasedCompareMapFilterComponent : public autoware::pointcloud_preprocessor::Filter
 {
 protected:
-  virtual void filter(
-    const PointCloud2ConstPtr & input, const IndicesPtr & indices, PointCloud2 & output);
+  void filter(
+    const PointCloud2ConstPtr & input, const IndicesPtr & indices, PointCloud2 & output) override;
 
 private:
   double distance_threshold_;
diff --git a/perception/autoware_compare_map_segmentation/src/voxel_based_approximate_compare_map_filter/node.cpp b/perception/autoware_compare_map_segmentation/src/voxel_based_approximate_compare_map_filter/node.cpp
@@ -29,7 +29,7 @@ namespace autoware::compare_map_segmentation
 bool VoxelBasedApproximateStaticMapLoader::is_close_to_map(
   const pcl::PointXYZ & point, [[maybe_unused]] const double distance_threshold)
 {
-  if (voxel_map_ptr_ == NULL) {
+  if (voxel_map_ptr_ == nullptr) {
     return false;
   }
   const int index =
@@ -55,7 +55,7 @@ bool VoxelBasedApproximateDynamicMapLoader::is_close_to_map(
   if (static_cast<size_t>(map_grid_index) >= current_voxel_grid_array_.size()) {
     return false;
   }
-  if (current_voxel_grid_array_.at(map_grid_index) != NULL) {
+  if (current_voxel_grid_array_.at(map_grid_index) != nullptr) {
     const int index = current_voxel_grid_array_.at(map_grid_index)
                         ->map_cell_voxel_grid.getCentroidIndexAt(
                           current_voxel_grid_array_.at(map_grid_index)
diff --git a/perception/autoware_compare_map_segmentation/src/voxel_based_approximate_compare_map_filter/node.hpp b/perception/autoware_compare_map_segmentation/src/voxel_based_approximate_compare_map_filter/node.hpp
@@ -23,7 +23,6 @@
 
 #include <memory>
 #include <string>
-#include <vector>
 
 namespace autoware::compare_map_segmentation
 {
@@ -59,8 +58,8 @@ class VoxelBasedApproximateCompareMapFilterComponent
 : public autoware::pointcloud_preprocessor::Filter
 {
 protected:
-  virtual void filter(
-    const PointCloud2ConstPtr & input, const IndicesPtr & indices, PointCloud2 & output);
+  void filter(
+    const PointCloud2ConstPtr & input, const IndicesPtr & indices, PointCloud2 & output) override;
 
 private:
   double distance_threshold_;
diff --git a/perception/autoware_compare_map_segmentation/src/voxel_based_compare_map_filter/node.cpp b/perception/autoware_compare_map_segmentation/src/voxel_based_compare_map_filter/node.cpp
@@ -22,11 +22,9 @@
 #include <pcl/segmentation/segment_differences.h>
 
 #include <string>
-#include <vector>
 
 namespace autoware::compare_map_segmentation
 {
-using autoware::pointcloud_preprocessor::get_param;
 
 VoxelBasedCompareMapFilterComponent::VoxelBasedCompareMapFilterComponent(
   const rclcpp::NodeOptions & options)
diff --git a/perception/autoware_compare_map_segmentation/src/voxel_based_compare_map_filter/node.hpp b/perception/autoware_compare_map_segmentation/src/voxel_based_compare_map_filter/node.hpp
@@ -22,15 +22,14 @@
 #include <pcl/search/pcl_search.h>
 
 #include <memory>
-#include <vector>
 
 namespace autoware::compare_map_segmentation
 {
 class VoxelBasedCompareMapFilterComponent : public autoware::pointcloud_preprocessor::Filter
 {
 protected:
-  virtual void filter(
-    const PointCloud2ConstPtr & input, const IndicesPtr & indices, PointCloud2 & output);
+  void filter(
+    const PointCloud2ConstPtr & input, const IndicesPtr & indices, PointCloud2 & output) override;
 
 private:
   // pcl::SegmentDifferences<pcl::PointXYZ> impl_;
@@ -39,8 +38,6 @@ class VoxelBasedCompareMapFilterComponent : public autoware::pointcloud_preproce
   double distance_threshold_;
   bool set_map_in_voxel_grid_;
 
-  bool dynamic_map_load_enable_;
-
 public:
   PCL_MAKE_ALIGNED_OPERATOR_NEW
   explicit VoxelBasedCompareMapFilterComponent(const rclcpp::NodeOptions & options);
diff --git a/perception/autoware_compare_map_segmentation/src/voxel_distance_based_compare_map_filter/node.cpp b/perception/autoware_compare_map_segmentation/src/voxel_distance_based_compare_map_filter/node.cpp
@@ -61,13 +61,13 @@ bool VoxelDistanceBasedStaticMapLoader::is_close_to_map(
   if (!is_initialized_.load(std::memory_order_acquire)) {
     return false;
   }
-  if (voxel_map_ptr_ == NULL) {
+  if (voxel_map_ptr_ == nullptr) {
     return false;
   }
-  if (map_ptr_ == NULL) {
+  if (map_ptr_ == nullptr) {
     return false;
   }
-  if (tree_ == NULL) {
+  if (tree_ == nullptr) {
     return false;
   }
   if (is_close_to_neighbor_voxels(point, distance_threshold, voxel_grid_, tree_)) {
@@ -91,7 +91,7 @@ bool VoxelDistanceBasedDynamicMapLoader::is_close_to_map(
     return false;
   }
   if (
-    current_voxel_grid_array_.at(map_grid_index) != NULL &&
+    current_voxel_grid_array_.at(map_grid_index) != nullptr &&
     is_close_to_neighbor_voxels(
       point, distance_threshold, current_voxel_grid_array_.at(map_grid_index)->map_cell_voxel_grid,
       current_voxel_grid_array_.at(map_grid_index)->map_cell_kdtree)) {
diff --git a/perception/autoware_compare_map_segmentation/src/voxel_distance_based_compare_map_filter/node.hpp b/perception/autoware_compare_map_segmentation/src/voxel_distance_based_compare_map_filter/node.hpp
@@ -25,14 +25,13 @@
 #include <memory>
 #include <string>
 #include <utility>
-#include <vector>
 
 namespace autoware::compare_map_segmentation
 {
 
-typedef typename pcl::Filter<pcl::PointXYZ>::PointCloud PointCloud;
-typedef typename PointCloud::Ptr PointCloudPtr;
-typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+using PointCloud = typename pcl::Filter<pcl::PointXYZ>::PointCloud;
+using PointCloudPtr = typename PointCloud::Ptr;
+using PointCloudConstPtr = typename PointCloud::ConstPtr;
 
 class VoxelDistanceBasedStaticMapLoader : public VoxelGridStaticMapLoader
 {
@@ -124,8 +123,8 @@ class VoxelDistanceBasedDynamicMapLoader : public VoxelGridDynamicMapLoader
 class VoxelDistanceBasedCompareMapFilterComponent : public autoware::pointcloud_preprocessor::Filter
 {
 protected:
-  virtual void filter(
-    const PointCloud2ConstPtr & input, const IndicesPtr & indices, PointCloud2 & output);
+  void filter(
+    const PointCloud2ConstPtr & input, const IndicesPtr & indices, PointCloud2 & output) override;
 
   void input_target_callback(const PointCloud2ConstPtr map);
 
diff --git a/perception/autoware_compare_map_segmentation/src/voxel_grid_map_loader/voxel_grid_map_loader.cpp b/perception/autoware_compare_map_segmentation/src/voxel_grid_map_loader/voxel_grid_map_loader.cpp
@@ -47,7 +47,7 @@ bool VoxelGridMapLoader::is_close_to_neighbor_voxels(
   if (index != -1) {
     return true;
   }
-  if (tree == NULL) {
+  if (tree == nullptr) {
     return false;
   }
   std::vector<int> nn_indices(1);
@@ -64,7 +64,7 @@ bool VoxelGridMapLoader::is_close_to_neighbor_voxels(
 {
   // check map downsampled pc
   double distance_threshold_z = downsize_ratio_z_axis_ * distance_threshold;
-  if (map == NULL) {
+  if (map == nullptr) {
     return false;
   }
   if (is_in_voxel(
@@ -331,7 +331,7 @@ bool VoxelGridDynamicMapLoader::is_close_to_next_map_grid(
   if (
     static_cast<size_t>(neighbor_map_grid_index) >= current_voxel_grid_array_.size() ||
     neighbor_map_grid_index == current_map_grid_index ||
-    current_voxel_grid_array_.at(neighbor_map_grid_index) != NULL) {
+    current_voxel_grid_array_.at(neighbor_map_grid_index) != nullptr) {
     return false;
   }
   if (is_close_to_neighbor_voxels(
@@ -360,7 +360,7 @@ bool VoxelGridDynamicMapLoader::is_close_to_map(
     return false;
   }
   if (
-    current_voxel_grid_array_.at(map_grid_index) != NULL &&
+    current_voxel_grid_array_.at(map_grid_index) != nullptr &&
     is_close_to_neighbor_voxels(
       point, distance_threshold, current_voxel_grid_array_.at(map_grid_index)->map_cell_pc_ptr,
       current_voxel_grid_array_.at(map_grid_index)->map_cell_voxel_grid)) {
diff --git a/perception/autoware_compare_map_segmentation/src/voxel_grid_map_loader/voxel_grid_map_loader.hpp b/perception/autoware_compare_map_segmentation/src/voxel_grid_map_loader/voxel_grid_map_loader.hpp
@@ -30,7 +30,6 @@
 #include <map>
 #include <memory>
 #include <string>
-#include <thread>
 #include <utility>
 #include <vector>
 
@@ -93,13 +92,15 @@ class VoxelGridMapLoader
   bool debug_ = false;
 
 public:
-  typedef VoxelGridEx<pcl::PointXYZ> VoxelGridPointXYZ;
-  typedef typename pcl::Filter<pcl::PointXYZ>::PointCloud PointCloud;
-  typedef typename PointCloud::Ptr PointCloudPtr;
+  using VoxelGridPointXYZ = VoxelGridEx<pcl::PointXYZ>;
+  using PointCloud = typename pcl::Filter<pcl::PointXYZ>::PointCloud;
+  using PointCloudPtr = typename PointCloud::Ptr;
   explicit VoxelGridMapLoader(
     rclcpp::Node * node, double leaf_size, double downsize_ratio_z_axis,
     std::string * tf_map_input_frame);
 
+  virtual ~VoxelGridMapLoader() = default;
+
   virtual bool is_close_to_map(const pcl::PointXYZ & point, const double distance_threshold) = 0;
   static bool is_close_to_neighbor_voxels(
     const pcl::PointXYZ & point, const double distance_threshold, VoxelGridPointXYZ & voxel,
@@ -142,7 +143,7 @@ class VoxelGridDynamicMapLoader : public VoxelGridMapLoader
     pcl::search::Search<pcl::PointXYZ>::Ptr map_cell_kdtree;
   };
 
-  typedef typename std::map<std::string, struct MapGridVoxelInfo> VoxelGridDict;
+  using VoxelGridDict = typename std::map<std::string, struct MapGridVoxelInfo>;
 
   /** \brief Map to hold loaded map grid id and it's voxel filter */
   VoxelGridDict current_voxel_grid_dict_;
diff --git a/sensing/autoware_pointcloud_preprocessor/CMakeLists.txt b/sensing/autoware_pointcloud_preprocessor/CMakeLists.txt
@@ -36,6 +36,7 @@ target_include_directories(pointcloud_preprocessor_filter_base PUBLIC
 )
 
 ament_target_dependencies(pointcloud_preprocessor_filter_base
+  SYSTEM
   message_filters
   pcl_conversions
   rclcpp
@@ -56,6 +57,7 @@ target_include_directories(faster_voxel_grid_downsample_filter PUBLIC
 )
 
 ament_target_dependencies(faster_voxel_grid_downsample_filter
+  SYSTEM
   pcl_conversions
   rclcpp
   sensor_msgs

Original file line number	Diff line number	Diff line change
`@@ -29,9 +29,7 @@`
`29`	`29`	`#include <pcl_conversions/pcl_conversions.h>`
`30`	`30`	`#include <rcutils/filesystem.h> // To be replaced by std::filesystem in C++17`
`31`	`31`
`32`		`-#include <memory>`
`33`	`32`	`#include <string>`
`34`		`-#include <utility>`
`35`	`33`
`36`	`34`	`namespace autoware::compare_map_segmentation`
`37`	`35`	`{`
Original file line number	Diff line number	Diff line change
`@@ -51,10 +51,10 @@ bool DistanceBasedStaticMapLoader::is_close_to_map(`
`51`	`51`	`if (!is_initialized_.load(std::memory_order_acquire)) {`
`52`	`52`	`return false;`
`53`	`53`	`}`
`54`		`- if (map_ptr_ == NULL) {`
	`54`	`+ if (map_ptr_ == nullptr) {`
`55`	`55`	`return false;`
`56`	`56`	`}`
`57`		`- if (tree_ == NULL) {`
	`57`	`+ if (tree_ == nullptr) {`
`58`	`58`	`return false;`
`59`	`59`	`}`
`60`	`60`
`@@ -89,8 +89,8 @@ bool DistanceBasedDynamicMapLoader::is_close_to_map(`
`89`	`89`	`if (static_cast<size_t>(map_grid_index) >= current_voxel_grid_array_.size()) {`
`90`	`90`	`return false;`
`91`	`91`	`}`
`92`		`- if (current_voxel_grid_array_.at(map_grid_index) != NULL) {`
`93`		`- if (current_voxel_grid_array_.at(map_grid_index)->map_cell_kdtree == NULL) {`
	`92`	`+ if (current_voxel_grid_array_.at(map_grid_index) != nullptr) {`
	`93`	`+ if (current_voxel_grid_array_.at(map_grid_index)->map_cell_kdtree == nullptr) {`
`94`	`94`	`return false;`
`95`	`95`	`}`
`96`	`96`	`std::vector<int> nn_indices(1);`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ namespace autoware::compare_map_segmentation`
`29`	`29`	`bool VoxelBasedApproximateStaticMapLoader::is_close_to_map(`
`30`	`30`	`const pcl::PointXYZ & point, [[maybe_unused]] const double distance_threshold)`
`31`	`31`	`{`
`32`		`- if (voxel_map_ptr_ == NULL) {`
	`32`	`+ if (voxel_map_ptr_ == nullptr) {`
`33`	`33`	`return false;`
`34`	`34`	`}`
`35`	`35`	`const int index =`
`@@ -55,7 +55,7 @@ bool VoxelBasedApproximateDynamicMapLoader::is_close_to_map(`
`55`	`55`	`if (static_cast<size_t>(map_grid_index) >= current_voxel_grid_array_.size()) {`
`56`	`56`	`return false;`
`57`	`57`	`}`
`58`		`- if (current_voxel_grid_array_.at(map_grid_index) != NULL) {`
	`58`	`+ if (current_voxel_grid_array_.at(map_grid_index) != nullptr) {`
`59`	`59`	`const int index = current_voxel_grid_array_.at(map_grid_index)`
`60`	`60`	`->map_cell_voxel_grid.getCentroidIndexAt(`
`61`	`61`	`current_voxel_grid_array_.at(map_grid_index)`
Original file line number	Diff line number	Diff line change
`@@ -22,11 +22,9 @@`
`22`	`22`	`#include <pcl/segmentation/segment_differences.h>`
`23`	`23`
`24`	`24`	`#include <string>`
`25`		`-#include <vector>`
`26`	`25`
`27`	`26`	`namespace autoware::compare_map_segmentation`
`28`	`27`	`{`
`29`		`-using autoware::pointcloud_preprocessor::get_param;`
`30`	`28`
`31`	`29`	`VoxelBasedCompareMapFilterComponent::VoxelBasedCompareMapFilterComponent(`
`32`	`30`	`const rclcpp::NodeOptions & options)`
Original file line number	Diff line number	Diff line change
`@@ -61,13 +61,13 @@ bool VoxelDistanceBasedStaticMapLoader::is_close_to_map(`
`61`	`61`	`if (!is_initialized_.load(std::memory_order_acquire)) {`
`62`	`62`	`return false;`
`63`	`63`	`}`
`64`		`- if (voxel_map_ptr_ == NULL) {`
	`64`	`+ if (voxel_map_ptr_ == nullptr) {`
`65`	`65`	`return false;`
`66`	`66`	`}`
`67`		`- if (map_ptr_ == NULL) {`
	`67`	`+ if (map_ptr_ == nullptr) {`
`68`	`68`	`return false;`
`69`	`69`	`}`
`70`		`- if (tree_ == NULL) {`
	`70`	`+ if (tree_ == nullptr) {`
`71`	`71`	`return false;`
`72`	`72`	`}`
`73`	`73`	`if (is_close_to_neighbor_voxels(point, distance_threshold, voxel_grid_, tree_)) {`
`@@ -91,7 +91,7 @@ bool VoxelDistanceBasedDynamicMapLoader::is_close_to_map(`
`91`	`91`	`return false;`
`92`	`92`	`}`
`93`	`93`	`if (`
`94`		`- current_voxel_grid_array_.at(map_grid_index) != NULL &&`
	`94`	`+ current_voxel_grid_array_.at(map_grid_index) != nullptr &&`
`95`	`95`	`is_close_to_neighbor_voxels(`
`96`	`96`	`point, distance_threshold, current_voxel_grid_array_.at(map_grid_index)->map_cell_voxel_grid,`
`97`	`97`	`current_voxel_grid_array_.at(map_grid_index)->map_cell_kdtree)) {`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ bool VoxelGridMapLoader::is_close_to_neighbor_voxels(`
`47`	`47`	`if (index != -1) {`
`48`	`48`	`return true;`
`49`	`49`	`}`
`50`		`- if (tree == NULL) {`
	`50`	`+ if (tree == nullptr) {`
`51`	`51`	`return false;`
`52`	`52`	`}`
`53`	`53`	`std::vector<int> nn_indices(1);`
`@@ -64,7 +64,7 @@ bool VoxelGridMapLoader::is_close_to_neighbor_voxels(`
`64`	`64`	`{`
`65`	`65`	`// check map downsampled pc`
`66`	`66`	`double distance_threshold_z = downsize_ratio_z_axis_ * distance_threshold;`
`67`		`- if (map == NULL) {`
	`67`	`+ if (map == nullptr) {`
`68`	`68`	`return false;`
`69`	`69`	`}`
`70`	`70`	`if (is_in_voxel(`
`@@ -331,7 +331,7 @@ bool VoxelGridDynamicMapLoader::is_close_to_next_map_grid(`
`331`	`331`	`if (`
`332`	`332`	`static_cast<size_t>(neighbor_map_grid_index) >= current_voxel_grid_array_.size() \|\|`
`333`	`333`	`neighbor_map_grid_index == current_map_grid_index \|\|`
`334`		`- current_voxel_grid_array_.at(neighbor_map_grid_index) != NULL) {`
	`334`	`+ current_voxel_grid_array_.at(neighbor_map_grid_index) != nullptr) {`
`335`	`335`	`return false;`
`336`	`336`	`}`
`337`	`337`	`if (is_close_to_neighbor_voxels(`
`@@ -360,7 +360,7 @@ bool VoxelGridDynamicMapLoader::is_close_to_map(`
`360`	`360`	`return false;`
`361`	`361`	`}`
`362`	`362`	`if (`
`363`		`- current_voxel_grid_array_.at(map_grid_index) != NULL &&`
	`363`	`+ current_voxel_grid_array_.at(map_grid_index) != nullptr &&`
`364`	`364`	`is_close_to_neighbor_voxels(`
`365`	`365`	`point, distance_threshold, current_voxel_grid_array_.at(map_grid_index)->map_cell_pc_ptr,`
`366`	`366`	`current_voxel_grid_array_.at(map_grid_index)->map_cell_voxel_grid)) {`
Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,7 @@ target_include_directories(pointcloud_preprocessor_filter_base PUBLIC`
`36`	`36`	`)`
`37`	`37`
`38`	`38`	`ament_target_dependencies(pointcloud_preprocessor_filter_base`
	`39`	`+ SYSTEM`
`39`	`40`	`message_filters`
`40`	`41`	`pcl_conversions`
`41`	`42`	`rclcpp`
`@@ -56,6 +57,7 @@ target_include_directories(faster_voxel_grid_downsample_filter PUBLIC`
`56`	`57`	`)`
`57`	`58`
`58`	`59`	`ament_target_dependencies(faster_voxel_grid_downsample_filter`
	`60`	`+ SYSTEM`
`59`	`61`	`pcl_conversions`
`60`	`62`	`rclcpp`
`61`	`63`	`sensor_msgs`