style(pre-commit): autofix

Author: pre-commit-ci[bot]

sensing/autoware_crop_box_filter/CMakeLists.txt

@@ -26,5 +26,3 @@ ament_auto_package(INSTALL_TO_SHARE
   launch
   config
 )
-
-

sensing/autoware_crop_box_filter/README.md

@@ -12,41 +12,40 @@ The `autoware_crop_box_filter` is implemented as a autoware core node that subsc
 
 ### Input
 
-| Name              | Type                            | Description       |
-| ----------------- | ------------------------------- | ----------------- |
-| `~/input/points`  | `sensor_msgs::msg::PointCloud2` | reference points  |
+| Name             | Type                            | Description      |
+| ---------------- | ------------------------------- | ---------------- |
+| `~/input/points` | `sensor_msgs::msg::PointCloud2` | reference points |
 
 ### Output
 
-| Name              | Type                            | Description     |
-| ----------------- | ------------------------------- | --------------- |
-| `~/output/points` | `sensor_msgs::msg::PointCloud2` | filtered points |
+| Name                 | Type                                 | Description          |
+| -------------------- | ------------------------------------ | -------------------- |
+| `~/output/points`    | `sensor_msgs::msg::PointCloud2`      | filtered points      |
 | `~/crop_box_polygon` | `geometry_msgs::msg::PolygonStamped` | bounding box polygon |
 
 ## Parameters
 
 ### Launch file Parameters
 
-| Name               | Type   | Default Value | Description                           |
-| ------------------ | ------ | ------------- | ------------------------------------- |
-| `input_frame`      | string | " "           | the frame id in which filtering is performed                         |
-| `output_frame`     | string | " "           | output frame id of the filtered points                                                |
-| `input_pointcloud_frame`     | string | " "           | frame id of input  pointcloud  |                                              
-| `max_queue_size`   | int    | 5             | max buffer size of input/output topics |
-| `crop_box_filter_param_file` | string | " "           | path to the parameter file for the node |
-
+| Name                         | Type   | Default Value | Description                                  |
+| ---------------------------- | ------ | ------------- | -------------------------------------------- |
+| `input_frame`                | string | " "           | the frame id in which filtering is performed |
+| `output_frame`               | string | " "           | output frame id of the filtered points       |
+| `input_pointcloud_frame`     | string | " "           | frame id of input pointcloud                 |
+| `max_queue_size`             | int    | 5             | max buffer size of input/output topics       |
+| `crop_box_filter_param_file` | string | " "           | path to the parameter file for the node      |
 
 ### Node Parameters
 
-| Name               | Type   | Default Value | Description                           |
-| ------------------ | ------ | ------------- | ------------------------------------- |
-| `min_x`            | double | -5.0          | minimum x value of the crop box       |
-| `min_y`            | double | -5.0          | minimum y value of the crop box       |
-| `min_z`            | double | -5.0          | minimum z value of the crop box       |
-| `max_x`            | double | 5.0           | maximum x value of the crop box       |
-| `max_y`            | double | 5.0           | maximum y value of the crop box       |
-| `max_z`            | double | 5.0           | maximum z value of the crop box       |
-| `negative`         | bool   | true          | if true, points inside the box are removed, otherwise points outside the box are removed |
+| Name       | Type   | Default Value | Description                                                                              |
+| ---------- | ------ | ------------- | ---------------------------------------------------------------------------------------- |
+| `min_x`    | double | -5.0          | minimum x value of the crop box                                                          |
+| `min_y`    | double | -5.0          | minimum y value of the crop box                                                          |
+| `min_z`    | double | -5.0          | minimum z value of the crop box                                                          |
+| `max_x`    | double | 5.0           | maximum x value of the crop box                                                          |
+| `max_y`    | double | 5.0           | maximum y value of the crop box                                                          |
+| `max_z`    | double | 5.0           | maximum z value of the crop box                                                          |
+| `negative` | bool   | true          | if true, points inside the box are removed, otherwise points outside the box are removed |
 
 ## Usage
 

sensing/autoware_crop_box_filter/include/autoware/crop_box_filter/crop_box_filter_node.hpp

@@ -55,36 +55,33 @@
 #ifndef AUTOWARE__CROP_BOX_FILTER__CROP_BOX_FILTER_NODE_HPP_
 #define AUTOWARE__CROP_BOX_FILTER__CROP_BOX_FILTER_NODE_HPP_
 
-#include <geometry_msgs/msg/polygon_stamped.hpp>
-#include <sensor_msgs/msg/point_cloud2.hpp>
-#include <sensor_msgs/point_cloud2_iterator.hpp>
-
+#include <autoware/point_types/types.hpp>
 #include <autoware_utils/ros/debug_publisher.hpp>
 #include <autoware_utils/ros/managed_transform_buffer.hpp>
 #include <autoware_utils/ros/published_time_publisher.hpp>
 #include <autoware_utils/system/stop_watch.hpp>
 
-#include <autoware/point_types/types.hpp>
+#include <geometry_msgs/msg/polygon_stamped.hpp>
+#include <sensor_msgs/msg/point_cloud2.hpp>
+#include <sensor_msgs/point_cloud2_iterator.hpp>
 
 #include <memory>
-#include <vector>
 #include <string>
 #include <utility>
+#include <vector>
 
 namespace autoware::crop_box_filter
 {
 class CropBoxFilter : public rclcpp::Node
 {
+  using PointCloud2 = sensor_msgs::msg::PointCloud2;
+  using PointCloud2ConstPtr = sensor_msgs::msg::PointCloud2::ConstSharedPtr;
 
-using PointCloud2 = sensor_msgs::msg::PointCloud2;
-using PointCloud2ConstPtr = sensor_msgs::msg::PointCloud2::ConstSharedPtr;
-
-using PointCloud = pcl::PointCloud<pcl::PointXYZ>;
-using PointCloudPtr = PointCloud::Ptr;
-using PointCloudConstPtr = PointCloud::ConstPtr;
+  using PointCloud = pcl::PointCloud<pcl::PointXYZ>;
+  using PointCloudPtr = PointCloud::Ptr;
+  using PointCloudConstPtr = PointCloud::ConstPtr;
 
 private:
-
   // member variable declaration & definitions *************************************
 
   /** \brief The managed transform buffer. */
@@ -141,16 +138,16 @@ using PointCloudConstPtr = PointCloud::ConstPtr;
   std::unique_ptr<autoware_utils::PublishedTimePublisher> published_time_publisher_;
 
   // function declaration *************************************
-  
+
   void publish_crop_box_polygon();
-  
+
   void pointcloud_callback(const PointCloud2ConstPtr cloud);
 
   /** \brief Parameter service callback */
   rcl_interfaces::msg::SetParametersResult param_callback(const std::vector<rclcpp::Parameter> & p);
 
-  /** \brief Return whether the input PointCloud2 data has the same layout than PointXYZI. That is to
-   * say whether you can memcpy from the PointCloud2 data buffer to a PointXYZI */
+  /** \brief Return whether the input PointCloud2 data has the same layout than PointXYZI. That is
+   * to say whether you can memcpy from the PointCloud2 data buffer to a PointXYZI */
   bool is_data_layout_compatible_with_point_xyzi(const PointCloud2 & input);
 
   /** \brief Return whether the input PointCloud2 data has the same layout than PointXYZIRC. That is
@@ -161,8 +158,8 @@ using PointCloudConstPtr = PointCloud::ConstPtr;
    * is to say whether you can memcpy from the PointCloud2 data buffer to a PointXYZIRADRT */
   bool is_data_layout_compatible_with_point_xyziradrt(const PointCloud2 & input);
 
-  /** \brief Return whether the input PointCloud2 data has the same layout than PointXYZIRCAEDT. That
-   * is to say whether you can memcpy from the PointCloud2 data buffer to a PointXYZIRCAEDT */
+  /** \brief Return whether the input PointCloud2 data has the same layout than PointXYZIRCAEDT.
+   * That is to say whether you can memcpy from the PointCloud2 data buffer to a PointXYZIRCAEDT */
   bool is_data_layout_compatible_with_point_xyzircaedt(const PointCloud2 & input);
 
   bool is_valid(const PointCloud2ConstPtr & cloud);
@@ -180,7 +177,6 @@ using PointCloudConstPtr = PointCloud::ConstPtr;
     }
     return false;
   }
-  
 
 public:
   PCL_MAKE_ALIGNED_OPERATOR_NEW

sensing/autoware_crop_box_filter/package.xml

@@ -17,7 +17,6 @@
   <maintainer email="lxg19892021@gmail.com">Xingang Liu</maintainer>
   <license>Apache License 2.0</license>
 
-
   <!-- Original authors -->
   <author>Open Perception</author>
   <author email="julius@kammerl.de">Julius Kammerl</author>
@@ -28,10 +27,10 @@
 
   <depend>autoware_point_types</depend>
   <depend>autoware_utils</depend>
+  <depend>geometry_msgs</depend>
   <depend>rclcpp</depend>
   <depend>rclcpp_components</depend>
   <depend>sensor_msgs</depend>
-  <depend>geometry_msgs</depend>
 
   <test_depend>ament_lint_auto</test_depend>
   <test_depend>autoware_lint_common</test_depend>

sensing/autoware_crop_box_filter/src/crop_box_filter_node.cpp

@@ -52,10 +52,11 @@
  */
 
 #include "autoware/crop_box_filter/crop_box_filter_node.hpp"
+
 #include <memory>
-#include <vector>
 #include <string>
 #include <utility>
+#include <vector>
 
 namespace autoware::crop_box_filter
 {
@@ -78,60 +79,47 @@ CropBoxFilter::CropBoxFilter(const rclcpp::NodeOptions & node_options)
 
   // get transform info for pointcloud
   {
-    
-    tf_input_orig_frame_ = static_cast<std::string>(declare_parameter("input_pointcloud_frame", "base_link"));
+    tf_input_orig_frame_ =
+      static_cast<std::string>(declare_parameter("input_pointcloud_frame", "base_link"));
     tf_input_frame_ = static_cast<std::string>(declare_parameter("input_frame", "base_link"));
     tf_output_frame_ = static_cast<std::string>(declare_parameter("output_frame", "base_link"));
 
     // Always consider static TF if in & out frames are same
     bool has_static_tf_only = false;
     if (tf_input_frame_ == tf_output_frame_) {
-    
       RCLCPP_INFO(
         this->get_logger(),
         "Input and output frames are the same. Overriding has_static_tf_only to true.");
-      
+
       has_static_tf_only = true;
     }
     managed_tf_buffer_ =
       std::make_unique<autoware_utils::ManagedTransformBuffer>(this, has_static_tf_only);
 
-
-    if (tf_input_orig_frame_ == tf_input_frame_)
-    {
+    if (tf_input_orig_frame_ == tf_input_frame_) {
       need_preprocess_transform_ = false;
       eigen_transform_preprocess_ = Eigen::Matrix4f::Identity(4, 4);
-    }
-    else
-    {
+    } else {
       if (!managed_tf_buffer_->get_transform(
-        tf_input_frame_, tf_input_orig_frame_, eigen_transform_preprocess_)) 
-      {
+            tf_input_frame_, tf_input_orig_frame_, eigen_transform_preprocess_)) {
         RCLCPP_ERROR(
-          this->get_logger(),
-          "Cannot get transform from %s to %s. Please check your TF tree.",tf_input_orig_frame_.c_str() , tf_input_frame_.c_str());
-      }
-      else
-      {
+          this->get_logger(), "Cannot get transform from %s to %s. Please check your TF tree.",
+          tf_input_orig_frame_.c_str(), tf_input_frame_.c_str());
+      } else {
         need_preprocess_transform_ = true;
       }
     }
 
-    if (tf_input_frame_ == tf_output_frame_)
-    {
+    if (tf_input_frame_ == tf_output_frame_) {
       need_postprocess_transform_ = false;
       eigen_transform_postprocess_ = Eigen::Matrix4f::Identity(4, 4);
-    }else
-    {
+    } else {
       if (!managed_tf_buffer_->get_transform(
-        tf_output_frame_, tf_input_frame_, eigen_transform_postprocess_)) 
-      {
+            tf_output_frame_, tf_input_frame_, eigen_transform_postprocess_)) {
         RCLCPP_ERROR(
-          this->get_logger(),
-          "Cannot get transform from %s to %s. Please check your TF tree.",tf_input_frame_.c_str()  , tf_output_frame_.c_str());
-      }
-      else
-      {
+          this->get_logger(), "Cannot get transform from %s to %s. Please check your TF tree.",
+          tf_input_frame_.c_str(), tf_output_frame_.c_str());
+      } else {
         need_postprocess_transform_ = true;
       }
     }
@@ -170,31 +158,26 @@ CropBoxFilter::CropBoxFilter(const rclcpp::NodeOptions & node_options)
   // set parameter service callback
   {
     using std::placeholders::_1;
-    set_param_res_ = this->add_on_set_parameters_callback(
-      std::bind(&CropBoxFilter::param_callback, this, _1));
+    set_param_res_ =
+      this->add_on_set_parameters_callback(std::bind(&CropBoxFilter::param_callback, this, _1));
   }
 
   // set input pointcloud callback
   {
     sub_input_ = this->create_subscription<PointCloud2>(
-      "input", rclcpp::SensorDataQoS().keep_last(max_queue_size_), 
+      "input", rclcpp::SensorDataQoS().keep_last(max_queue_size_),
       std::bind(&CropBoxFilter::pointcloud_callback, this, std::placeholders::_1));
   }
 
-  
   RCLCPP_DEBUG(this->get_logger(), "[Filter Constructor] successfully created.");
 }
 
-
-
-
 void CropBoxFilter::pointcloud_callback(const PointCloud2ConstPtr cloud)
 {
   // check whether the pointcloud is valid
   if (
     !is_data_layout_compatible_with_point_xyzircaedt(*cloud) &&
-    !is_data_layout_compatible_with_point_xyzirc(*cloud)) 
-  {
+    !is_data_layout_compatible_with_point_xyzirc(*cloud)) {
     RCLCPP_ERROR(
       get_logger(),
       "The pointcloud layout is not compatible with PointXYZIRCAEDT or PointXYZIRC. Aborting");
@@ -227,14 +210,13 @@ void CropBoxFilter::pointcloud_callback(const PointCloud2ConstPtr cloud)
     "received.",
     cloud->width * cloud->height, cloud->header.frame_id.c_str());
   // pointcloud check finished
-  
+
   // pointcloud processing
   auto output = PointCloud2();
 
   std::scoped_lock lock(mutex_);
   stop_watch_ptr_->toc("processing_time", true);
 
-
   int x_offset = cloud->fields[pcl::getFieldIndex(*cloud, "x")].offset;
   int y_offset = cloud->fields[pcl::getFieldIndex(*cloud, "y")].offset;
   int z_offset = cloud->fields[pcl::getFieldIndex(*cloud, "z")].offset;
@@ -246,8 +228,7 @@ void CropBoxFilter::pointcloud_callback(const PointCloud2ConstPtr cloud)
 
   // pointcloud processing loop
   for (size_t global_offset = 0; global_offset + cloud->point_step <= cloud->data.size();
-       global_offset += cloud->point_step) 
-  {
+       global_offset += cloud->point_step) {
     Eigen::Vector4f point;
     Eigen::Vector4f point_preprocessed;
     std::memcpy(&point[0], &cloud->data[global_offset + x_offset], sizeof(float));
@@ -270,22 +251,18 @@ void CropBoxFilter::pointcloud_callback(const PointCloud2ConstPtr cloud)
                            point[1] > param_.min_y && point[1] < param_.max_y &&
                            point[0] > param_.min_x && point[0] < param_.max_x;
     if ((!param_.negative && point_is_inside) || (param_.negative && !point_is_inside)) {
-      
       // apply post-transform if needed
-      if(need_postprocess_transform_)
-      {
-        if(need_preprocess_transform_)
-        {
+      if (need_postprocess_transform_) {
+        if (need_preprocess_transform_) {
           Eigen::Vector4f point_postprocessed = eigen_transform_postprocess_ * point_preprocessed;
 
           memcpy(&output.data[output_size], &cloud->data[global_offset], cloud->point_step);
 
           std::memcpy(&output.data[output_size + x_offset], &point_postprocessed[0], sizeof(float));
           std::memcpy(&output.data[output_size + y_offset], &point_postprocessed[1], sizeof(float));
           std::memcpy(&output.data[output_size + z_offset], &point_postprocessed[2], sizeof(float));
-          
-        }else
-        {
+
+        } else {
           Eigen::Vector4f point_postprocessed = eigen_transform_postprocess_ * point;
 
           memcpy(&output.data[output_size], &cloud->data[global_offset], cloud->point_step);
@@ -294,9 +271,7 @@ void CropBoxFilter::pointcloud_callback(const PointCloud2ConstPtr cloud)
           std::memcpy(&output.data[output_size + y_offset], &point_postprocessed[1], sizeof(float));
           std::memcpy(&output.data[output_size + z_offset], &point_postprocessed[2], sizeof(float));
         }
-      }
-      else
-      {  
+      } else {
         memcpy(&output.data[output_size], &cloud->data[global_offset], cloud->point_step);
 
         if (need_preprocess_transform_) {
@@ -329,8 +304,7 @@ void CropBoxFilter::pointcloud_callback(const PointCloud2ConstPtr cloud)
   output.row_step = static_cast<uint32_t>(output.data.size() / output.height);
 
   // publish polygon if subscribers exist
-  if(crop_box_polygon_pub_->get_subscription_count() > 0)
-  {
+  if (crop_box_polygon_pub_->get_subscription_count() > 0) {
     publish_crop_box_polygon();
   }
 
@@ -423,7 +397,8 @@ rcl_interfaces::msg::SetParametersResult CropBoxFilter::param_callback(
   new_param.max_x = get_param(p, "max_x", new_param.max_x) ? new_param.max_x : param_.max_x;
   new_param.max_y = get_param(p, "max_y", new_param.max_y) ? new_param.max_y : param_.max_y;
   new_param.max_z = get_param(p, "max_z", new_param.max_z) ? new_param.max_z : param_.max_z;
-  new_param.negative = get_param(p, "negative", new_param.negative) ? new_param.negative : param_.negative;
+  new_param.negative =
+    get_param(p, "negative", new_param.negative) ? new_param.negative : param_.negative;
 
   param_ = new_param;
 
@@ -624,7 +599,7 @@ bool CropBoxFilter::is_data_layout_compatible_with_point_xyzircaedt(const PointC
   return same_layout;
 }
 
-bool CropBoxFilter::is_valid( const PointCloud2ConstPtr & cloud)
+bool CropBoxFilter::is_valid(const PointCloud2ConstPtr & cloud)
 {
   if (cloud->width * cloud->height * cloud->point_step != cloud->data.size()) {
     RCLCPP_WARN(