refactor(pointcloud_preprocessor): rework parameters

perception/autoware_detection_by_tracker/package.xml

@@ -24,6 +24,9 @@
   <depend>tf2_geometry_msgs</depend>
   <depend>tf2_ros</depend>
   <depend>tier4_perception_msgs</depend>
+<<<<<<< HEAD
+=======
+>>>>>>> original/main
 
   <test_depend>ament_lint_auto</test_depend>
   <test_depend>autoware_lint_common</test_depend>

perception/autoware_detection_by_tracker/src/tracker/tracker_handler.cpp

@@ -23,12 +23,20 @@ namespace autoware::detection_by_tracker
 {
 
 void TrackerHandler::onTrackedObjects(
+<<<<<<< HEAD
+  const autoware_perception_msgs::msg::TrackedObjects::ConstSharedPtr msg)
+=======
   const autoware_perception_msgs::msg::TrackedObjects::ConstSharedPtr input_objects_msg)
+>>>>>>> original/main
 {
   constexpr size_t max_buffer_size = 10;
 
   // Add tracked objects to buffer
+<<<<<<< HEAD
+  objects_buffer_.push_front(*msg);
+=======
   objects_buffer_.push_front(*input_objects_msg);
+>>>>>>> original/main
 
   // Remove old data
   while (max_buffer_size < objects_buffer_.size()) {

perception/autoware_ground_segmentation/CMakeLists.txt

@@ -104,7 +104,11 @@ if(BUILD_TESTING)
     test/test_ransac_ground_filter.cpp
   )
   target_link_libraries(test_ransac_ground_filter
+<<<<<<< HEAD:perception/ground_segmentation/CMakeLists.txt
+    ground_segmentation
+=======
     autoware_ground_segmentation
+>>>>>>> original/main:perception/autoware_ground_segmentation/CMakeLists.txt
     ${YAML_CPP_LIBRARIES})
 
 endif()

perception/autoware_ground_segmentation/launch/scan_ground_filter.launch.py

@@ -35,7 +35,11 @@ def launch_setup(context, *args, **kwargs):
 
     nodes = [
         ComposableNode(
+<<<<<<< HEAD:perception/ground_segmentation/launch/scan_ground_filter.launch.py
+            package="ground_segmentation",
+=======
             package="autoware_ground_segmentation",
+>>>>>>> original/main:perception/autoware_ground_segmentation/launch/scan_ground_filter.launch.py
             plugin="autoware::ground_segmentation::ScanGroundFilterComponent",
             name="scan_ground_filter",
             remappings=[

perception/autoware_ground_segmentation/src/ransac_ground_filter/node.cpp

@@ -80,9 +80,16 @@ PlaneBasis getPlaneBasis(const Eigen::Vector3d & plane_normal)
   return basis;
 }
 
-using autoware::pointcloud_preprocessor::get_param;
-
-RANSACGroundFilterComponent::RANSACGroundFilterComponent(const rclcpp::NodeOptions & options)
+< < < < < < < < HEAD : perception / ground_segmentation / src / ransac_ground_filter /
+                       node.cpp using pointcloud_preprocessor::get_param;
+== == == == using autoware::pointcloud_preprocessor::get_param;
+>>>>>>>> original /
+           main
+: perception /
+  autoware_ground_segmentation / src / ransac_ground_filter /
+  node.cpp
+
+  RANSACGroundFilterComponent::RANSACGroundFilterComponent(const rclcpp::NodeOptions & options)
 : Filter("RANSACGroundFilter", options)
 {
   base_frame_ = declare_parameter<std::string>("base_frame", "base_link");

perception/autoware_ground_segmentation/src/ray_ground_filter/node.hpp

@@ -58,8 +58,16 @@
 #include <tf2_eigen/tf2_eigen.hpp>
 #endif
 
+<<<<<<<<
+  HEAD : perception / ground_segmentation / src / ray_ground_filter / node.hpp
+#include "gencolors.hpp"
+#include "pointcloud_preprocessor/filter.hpp"
+  == == == ==
 #include "autoware/pointcloud_preprocessor/filter.hpp"
 #include "gencolors.hpp"
+  >>>>>>>> original /
+  main : perception / autoware_ground_segmentation / src / ray_ground_filter /
+         node.hpp
 
 #include <opencv2/core.hpp>
 #include <opencv2/imgproc.hpp>
@@ -75,7 +83,7 @@
 #include <string>
 #include <vector>
 
-namespace bg = boost::geometry;
+         namespace bg = boost::geometry;
 using Point = bg::model::d2::point_xy<double>;
 using Polygon = bg::model::polygon<Point>;
 
@@ -184,26 +192,33 @@ class RayGroundFilterComponent : public autoware::pointcloud_preprocessor::Filte
    * @param out_only_indices_cloud_ptr Resulting PointCloud with the indices kept
    * @param out_removed_indices_cloud_ptr Resulting PointCloud with the indices removed
    */
-  void ExtractPointsIndices(
-    const PointCloud2::ConstSharedPtr in_cloud_ptr, const pcl::PointIndices & in_indices,
+  void ExtractPointsIndices(const PointCloud2::ConstSharedPtr in_cloud_ptr,
+                            const pcl::PointIndices & in_indices, < < < < < < < < HEAD
+                            : perception / ground_segmentation / src / ray_ground_filter /
+                                node.hpp PointCloud2::SharedPtr out_only_indices_cloud_ptr,
+                              PointCloud2::SharedPtr out_removed_indices_cloud_ptr);
+========
     PointCloud2::SharedPtr ground_cloud_msg_ptr, PointCloud2::SharedPtr no_ground_cloud_msg_ptr);
+>>>>>>>> original / main : perception / autoware_ground_segmentation / src / ray_ground_filter /
+                           node.hpp
 
-  boost::optional<float> calcPointVehicleIntersection(const Point & point);
+                             boost::optional<float>
+                             calcPointVehicleIntersection(const Point & point);
 
-  void setVehicleFootprint(
-    const double min_x, const double max_x, const double min_y, const double max_y);
-  void initializePointCloud2(
-    const PointCloud2::ConstSharedPtr & in_cloud_ptr,
-    const PointCloud2::SharedPtr & out_cloud_msg_ptr);
-  /** \brief Parameter service callback result : needed to be hold */
-  OnSetParametersCallbackHandle::SharedPtr set_param_res_;
+void setVehicleFootprint(
+  const double min_x, const double max_x, const double min_y, const double max_y);
+void initializePointCloud2(
+  const PointCloud2::ConstSharedPtr & in_cloud_ptr,
+  const PointCloud2::SharedPtr & out_cloud_msg_ptr);
+/** \brief Parameter service callback result : needed to be hold */
+OnSetParametersCallbackHandle::SharedPtr set_param_res_;
 
-  /** \brief Parameter service callback */
-  rcl_interfaces::msg::SetParametersResult paramCallback(const std::vector<rclcpp::Parameter> & p);
+/** \brief Parameter service callback */
+rcl_interfaces::msg::SetParametersResult paramCallback(const std::vector<rclcpp::Parameter> & p);
 
 public:
-  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
-  explicit RayGroundFilterComponent(const rclcpp::NodeOptions & options);
+EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+explicit RayGroundFilterComponent(const rclcpp::NodeOptions & options);
 };
 }  // namespace autoware::ground_segmentation
 

perception/autoware_ground_segmentation/src/scan_ground_filter/node.cpp

@@ -32,8 +32,11 @@ using autoware::universe_utils::normalizeDegree;
 using autoware::universe_utils::normalizeRadian;
 using autoware::vehicle_info_utils::VehicleInfoUtils;
 
-ScanGroundFilterComponent::ScanGroundFilterComponent(const rclcpp::NodeOptions & options)
-: autoware::pointcloud_preprocessor::Filter("ScanGroundFilter", options)
+ScanGroundFilterComponent::ScanGroundFilterComponent(const rclcpp::NodeOptions & options)<<<<<<<<
+  HEAD : perception / ground_segmentation / src / scan_ground_filter /
+    node.cpp : pointcloud_preprocessor::Filter("ScanGroundFilter", options) ==
+  == == == : autoware::pointcloud_preprocessor::Filter("ScanGroundFilter", options)>>>>>>>> original
+  / main : perception / autoware_ground_segmentation / src / scan_ground_filter / node.cpp
 {
   // set initial parameters
   {

perception/autoware_ground_segmentation/src/scan_ground_filter/node.hpp

@@ -15,9 +15,18 @@
 #ifndef SCAN_GROUND_FILTER__NODE_HPP_
 #define SCAN_GROUND_FILTER__NODE_HPP_
 
+<<<<<<<<
+  HEAD : perception / ground_segmentation / src / scan_ground_filter / node.hpp
+#include "autoware_vehicle_info_utils/vehicle_info.hpp"
+#include "pointcloud_preprocessor/filter.hpp"
+#include "pointcloud_preprocessor/transform_info.hpp"
+  == == == ==
 #include "autoware/pointcloud_preprocessor/filter.hpp"
 #include "autoware/pointcloud_preprocessor/transform_info.hpp"
 #include "autoware_vehicle_info_utils/vehicle_info.hpp"
+  >>>>>>>> original /
+  main : perception / autoware_ground_segmentation / src / scan_ground_filter /
+         node.hpp
 
 #include <sensor_msgs/msg/point_cloud2.hpp>
 
@@ -38,7 +47,7 @@
 #include <string>
 #include <vector>
 
-class ScanGroundFilterTest;
+         class ScanGroundFilterTest;
 
 namespace autoware::ground_segmentation
 {

perception/autoware_ground_segmentation/test/test_ransac_ground_filter.cpp

@@ -134,8 +134,12 @@ void convertPCL2PointCloud2(
 
 TEST_F(RansacGroundFilterTestSuite, TestCase1)
 {
+<<<<<<< HEAD:perception/ground_segmentation/test/test_ransac_ground_filter.cpp
+  const auto share_dir = ament_index_cpp::get_package_share_directory("ground_segmentation");
+=======
   const auto share_dir =
     ament_index_cpp::get_package_share_directory("autoware_ground_segmentation");
+>>>>>>> original/main:perception/autoware_ground_segmentation/test/test_ransac_ground_filter.cpp
   const auto config_path = share_dir + "/config/ransac_ground_filter.param.yaml";
   YAML::Node config = YAML::LoadFile(config_path);
   auto params = config["/**"]["ros__parameters"];

perception/autoware_image_projection_based_fusion/docs/segmentation-pointcloud-fusion.md

@@ -32,8 +32,14 @@ The node `segmentation_pointcloud_fusion` is a package for filtering pointcloud
 
 ### Core Parameters
 
+<<<<<<< HEAD:perception/image_projection_based_fusion/docs/segmentation-pointcloud-fusion.md
+{{ json_to_markdown("perception/image_projection_based_fusion/schema/segmentation_pointcloud_fusion.schema.json") }}
+=======
+
 {{ json_to_markdown("perception/autoware_image_projection_based_fusion/schema/segmentation_pointcloud_fusion.schema.json") }}
 
+> > > > > > > original/main:perception/autoware_image_projection_based_fusion/docs/segmentation-pointcloud-fusion.md
+
 ## Assumptions / Known limits
 
 <!-- Write assumptions and limitations of your implementation.

perception/autoware_image_projection_based_fusion/include/autoware/image_projection_based_fusion/pointpainting_fusion/node.hpp

@@ -17,66 +17,80 @@
 
 #include "autoware/image_projection_based_fusion/fusion_node.hpp"
 #include "autoware/image_projection_based_fusion/pointpainting_fusion/pointpainting_trt.hpp"
+<<<<<<<<
+  HEAD : perception / image_projection_based_fusion / include / autoware /
+    image_projection_based_fusion / pointpainting_fusion / node.hpp
+#include "lidar_centerpoint/postprocess/non_maximum_suppression.hpp"
+
+#include <autoware/image_projection_based_fusion/utils/geometry.hpp>
+#include <autoware/image_projection_based_fusion/utils/utils.hpp>
+#include <lidar_centerpoint/centerpoint_trt.hpp>
+#include <lidar_centerpoint/detection_class_remapper.hpp>
+  == == == ==
 #include "autoware/lidar_centerpoint/postprocess/non_maximum_suppression.hpp"
 
 #include <autoware/image_projection_based_fusion/utils/geometry.hpp>
 #include <autoware/image_projection_based_fusion/utils/utils.hpp>
 #include <autoware/lidar_centerpoint/centerpoint_trt.hpp>
 #include <autoware/lidar_centerpoint/detection_class_remapper.hpp>
+  >>>>>>>> original /
+  main : perception / autoware_image_projection_based_fusion / include / autoware /
+         image_projection_based_fusion / pointpainting_fusion /
+         node.hpp
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
-namespace autoware::image_projection_based_fusion
+         namespace autoware::image_projection_based_fusion
 {
-using Label = autoware_perception_msgs::msg::ObjectClassification;
+  using Label = autoware_perception_msgs::msg::ObjectClassification;
 
-inline bool isInsideBbox(
-  float proj_x, float proj_y, sensor_msgs::msg::RegionOfInterest roi, float zc)
-{
-  // z_c is scaling to normalize projection point
-  return proj_x >= roi.x_offset * zc && proj_x <= (roi.x_offset + roi.width) * zc &&
-         proj_y >= roi.y_offset * zc && proj_y <= (roi.y_offset + roi.height) * zc;
-}
+  inline bool isInsideBbox(
+    float proj_x, float proj_y, sensor_msgs::msg::RegionOfInterest roi, float zc)
+  {
+    // z_c is scaling to normalize projection point
+    return proj_x >= roi.x_offset * zc && proj_x <= (roi.x_offset + roi.width) * zc &&
+           proj_y >= roi.y_offset * zc && proj_y <= (roi.y_offset + roi.height) * zc;
+  }
 
-class PointPaintingFusionNode
-: public FusionNode<sensor_msgs::msg::PointCloud2, DetectedObjects, DetectedObjectsWithFeature>
-{
-public:
-  explicit PointPaintingFusionNode(const rclcpp::NodeOptions & options);
+  class PointPaintingFusionNode
+  : public FusionNode<sensor_msgs::msg::PointCloud2, DetectedObjects, DetectedObjectsWithFeature>
+  {
+  public:
+    explicit PointPaintingFusionNode(const rclcpp::NodeOptions & options);
 
-protected:
-  void preprocess(sensor_msgs::msg::PointCloud2 & pointcloud_msg) override;
+  protected:
+    void preprocess(sensor_msgs::msg::PointCloud2 & pointcloud_msg) override;
 
-  void fuseOnSingleImage(
-    const sensor_msgs::msg::PointCloud2 & input_pointcloud_msg, const std::size_t image_id,
-    const DetectedObjectsWithFeature & input_roi_msg,
-    const sensor_msgs::msg::CameraInfo & camera_info,
-    sensor_msgs::msg::PointCloud2 & painted_pointcloud_msg) override;
+    void fuseOnSingleImage(
+      const sensor_msgs::msg::PointCloud2 & input_pointcloud_msg, const std::size_t image_id,
+      const DetectedObjectsWithFeature & input_roi_msg,
+      const sensor_msgs::msg::CameraInfo & camera_info,
+      sensor_msgs::msg::PointCloud2 & painted_pointcloud_msg) override;
 
-  void postprocess(sensor_msgs::msg::PointCloud2 & painted_pointcloud_msg) override;
+    void postprocess(sensor_msgs::msg::PointCloud2 & painted_pointcloud_msg) override;
 
-  rclcpp::Publisher<DetectedObjects>::SharedPtr obj_pub_ptr_;
+    rclcpp::Publisher<DetectedObjects>::SharedPtr obj_pub_ptr_;
 
-  std::vector<double> tan_h_;  // horizontal field of view
+    std::vector<double> tan_h_;  // horizontal field of view
 
-  int omp_num_threads_{1};
-  float score_threshold_{0.0};
-  std::vector<std::string> class_names_;
-  std::map<std::string, float> class_index_;
-  std::map<std::string, std::function<bool(int)>> isClassTable_;
-  std::vector<double> pointcloud_range;
-  bool has_variance_{false};
-  bool has_twist_{false};
+    int omp_num_threads_{1};
+    float score_threshold_{0.0};
+    std::vector<std::string> class_names_;
+    std::map<std::string, float> class_index_;
+    std::map<std::string, std::function<bool(int)>> isClassTable_;
+    std::vector<double> pointcloud_range;
+    bool has_variance_{false};
+    bool has_twist_{false};
 
-  autoware::lidar_centerpoint::NonMaximumSuppression iou_bev_nms_;
-  autoware::lidar_centerpoint::DetectionClassRemapper detection_class_remapper_;
+    autoware::lidar_centerpoint::NonMaximumSuppression iou_bev_nms_;
+    autoware::lidar_centerpoint::DetectionClassRemapper detection_class_remapper_;
 
-  std::unique_ptr<image_projection_based_fusion::PointPaintingTRT> detector_ptr_{nullptr};
+    std::unique_ptr<image_projection_based_fusion::PointPaintingTRT> detector_ptr_{nullptr};
 
-  bool out_of_scope(const DetectedObjects & obj);
-};
+    bool out_of_scope(const DetectedObjects & obj);
+  };
 }  // namespace autoware::image_projection_based_fusion
 #endif  // AUTOWARE__IMAGE_PROJECTION_BASED_FUSION__POINTPAINTING_FUSION__NODE_HPP_