feat(map_based_predictor): add path cut for road border

perception/autoware_map_based_prediction/CMakeLists.txt

@@ -36,8 +36,11 @@ ament_auto_add_library(map_based_prediction_node SHARED
   lib/predictor_vru/traffic_signal.cpp
   lib/predictor_vru/fence.cpp
   lib/predictor_vru/vegetation.cpp
+  lib/predictor_vru/guard_rail.cpp
+  lib/predictor_vru/road_border.cpp
   lib/predictor_vru/path_cut_debug.cpp
   lib/path_cut/path_cut_utils.cpp
+  lib/path_cut/footprint_path_cut.cpp
   lib/utils.cpp
 )
 

perception/autoware_map_based_prediction/include/autoware/map_based_prediction/path_cut/footprint_path_cut.hpp

@@ -0,0 +1,55 @@
+// Copyright 2026 TIER IV, inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef AUTOWARE__MAP_BASED_PREDICTION__PATH_CUT__FOOTPRINT_PATH_CUT_HPP_
+#define AUTOWARE__MAP_BASED_PREDICTION__PATH_CUT__FOOTPRINT_PATH_CUT_HPP_
+
+#include "autoware/map_based_prediction/path_cut/path_cut_utils.hpp"
+
+#include <autoware_utils_geometry/boost_geometry.hpp>
+
+#include <autoware_perception_msgs/msg/predicted_objects.hpp>
+#include <autoware_perception_msgs/msg/shape.hpp>
+
+#include <lanelet2_core/primitives/BoundingBox.h>
+
+#include <optional>
+#include <vector>
+
+namespace autoware::map_based_prediction::path_cut
+{
+
+double calc_footprint_search_margin(const autoware_perception_msgs::msg::Shape & shape);
+
+bool shape_has_footprint(const autoware_perception_msgs::msg::Shape & shape);
+
+bool has_required_info(const autoware_perception_msgs::msg::PredictedObject & predicted_object);
+
+lanelet::BoundingBox2d get_bbox_contain_path_with_footprint(
+  const std::vector<PredictedPath> & predicted_paths,
+  const autoware_perception_msgs::msg::Shape & object_shape);
+lanelet::BoundingBox2d get_bbox_contain_path_with_footprint(
+  const PredictedPath & predicted_path, const autoware_perception_msgs::msg::Shape & object_shape);
+
+std::optional<size_t> find_footprint_crossing_index(
+  const PredictedPath & predicted_path, const autoware_perception_msgs::msg::Shape & object_shape,
+  const std::vector<autoware_utils_geometry::LineString2d> & linestrings_2d);
+
+std::optional<size_t> find_footprint_crossing_index(
+  const PredictedPath & predicted_path, const autoware_perception_msgs::msg::Shape & object_shape,
+  const std::vector<autoware_utils_geometry::Polygon2d> & polygons_2d);
+
+}  // namespace autoware::map_based_prediction::path_cut
+
+#endif  // AUTOWARE__MAP_BASED_PREDICTION__PATH_CUT__FOOTPRINT_PATH_CUT_HPP_

perception/autoware_map_based_prediction/include/autoware/map_based_prediction/predictor_vru/guard_rail.hpp

@@ -0,0 +1,46 @@
+// Copyright 2026 TIER IV, inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef AUTOWARE__MAP_BASED_PREDICTION__PREDICTOR_VRU__GUARD_RAIL_HPP_
+#define AUTOWARE__MAP_BASED_PREDICTION__PREDICTOR_VRU__GUARD_RAIL_HPP_
+
+#include "autoware/map_based_prediction/path_generator/path_generator.hpp"
+
+#include <autoware_perception_msgs/msg/predicted_objects.hpp>
+
+#include <lanelet2_core/LaneletMap.h>
+
+#include <memory>
+#include <vector>
+
+namespace autoware::map_based_prediction
+{
+
+class GuardRailModule
+{
+public:
+  GuardRailModule() = default;
+
+  void build_from_map(std::shared_ptr<lanelet::LaneletMap> lanelet_map_ptr);
+
+  [[nodiscard]] std::vector<PredictedPath> cut_paths_crossing_guard_rail(
+    const autoware_perception_msgs::msg::PredictedObject & predicted_object) const;
+
+private:
+  lanelet::LaneletMapUPtr guard_rail_layer_{nullptr};
+};
+
+}  // namespace autoware::map_based_prediction
+
+#endif  // AUTOWARE__MAP_BASED_PREDICTION__PREDICTOR_VRU__GUARD_RAIL_HPP_

perception/autoware_map_based_prediction/include/autoware/map_based_prediction/predictor_vru/path_cut_debug.hpp

@@ -31,7 +31,7 @@
 namespace autoware::map_based_prediction
 {
 
-enum class PathCutSource { Vegetation, Fence };
+enum class PathCutSource { Vegetation, Fence, RoadBorder, GuardRail };
 
 struct PathCutDebug
 {

perception/autoware_map_based_prediction/include/autoware/map_based_prediction/predictor_vru/predictor_vru.hpp

@@ -16,9 +16,12 @@
 #define AUTOWARE__MAP_BASED_PREDICTION__PREDICTOR_VRU__PREDICTOR_VRU_HPP_
 
 #include "autoware/map_based_prediction/data_structure.hpp"
+#include "autoware/map_based_prediction/path_cut/path_cut_utils.hpp"
 #include "autoware/map_based_prediction/path_generator/path_generator.hpp"
 #include "autoware/map_based_prediction/predictor_vru/fence.hpp"
+#include "autoware/map_based_prediction/predictor_vru/guard_rail.hpp"
 #include "autoware/map_based_prediction/predictor_vru/history.hpp"
+#include "autoware/map_based_prediction/predictor_vru/road_border.hpp"
 #include "autoware/map_based_prediction/predictor_vru/traffic_signal.hpp"
 #include "autoware/map_based_prediction/predictor_vru/vegetation.hpp"
 
@@ -72,6 +75,11 @@ class PredictorVru
 
   const Params & getParams() const { return params_; }
 
+  void set_max_deceleration(const path_cut::MaxDecelerationParams & max_decel_params)
+  {
+    max_decel_params_ = max_decel_params;
+  }
+
   void setLaneletMap(std::shared_ptr<lanelet::LaneletMap> lanelet_map_ptr);
 
   void setTimeKeeper(std::shared_ptr<autoware_utils::TimeKeeper> time_keeper_ptr)
@@ -108,10 +116,13 @@ class PredictorVru
   // Sub-modules
   FenceModule fence_module_;
   VegetationModule vegetation_module_;
+  GuardRailModule guard_rail_module_;
+  RoadBorderModule road_border_module_;
   TrafficSignalModule traffic_signal_module_;
   CrosswalkUserHistoryManager history_manager_;
 
   Params params_{};
+  path_cut::MaxDecelerationParams max_decel_params_{};
 
   PredictedObject getPredictedObjectAsCrosswalkUser(
     const TrackedObject & object, const rclcpp::Time & stamp,

perception/autoware_map_based_prediction/include/autoware/map_based_prediction/predictor_vru/road_border.hpp

@@ -0,0 +1,49 @@
+// Copyright 2026 TIER IV, inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef AUTOWARE__MAP_BASED_PREDICTION__PREDICTOR_VRU__ROAD_BORDER_HPP_
+#define AUTOWARE__MAP_BASED_PREDICTION__PREDICTOR_VRU__ROAD_BORDER_HPP_
+
+#include "autoware/map_based_prediction/path_cut/path_cut_utils.hpp"
+#include "autoware/map_based_prediction/path_generator/path_generator.hpp"
+
+#include <autoware_perception_msgs/msg/tracked_object.hpp>
+
+#include <lanelet2_core/LaneletMap.h>
+
+#include <memory>
+
+namespace autoware::map_based_prediction
+{
+
+class RoadBorderModule
+{
+public:
+  RoadBorderModule() = default;
+
+  void build_from_map(std::shared_ptr<lanelet::LaneletMap> lanelet_map_ptr);
+
+  [[nodiscard]] PredictedPath cut_path_at_road_border(
+    const PredictedPath & predicted_path,
+    const autoware_perception_msgs::msg::TrackedObject & object,
+    const path_cut::MaxDecelerationParams & max_decel_params) const;
+
+private:
+  std::shared_ptr<lanelet::LaneletMap> lanelet_map_ptr_{nullptr};
+  lanelet::LaneletMapUPtr road_border_layer_{nullptr};
+};
+
+}  // namespace autoware::map_based_prediction
+
+#endif  // AUTOWARE__MAP_BASED_PREDICTION__PREDICTOR_VRU__ROAD_BORDER_HPP_

perception/autoware_map_based_prediction/lib/path_cut/footprint_path_cut.cpp

@@ -0,0 +1,136 @@
+// Copyright 2026 TIER IV, inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "autoware/map_based_prediction/path_cut/footprint_path_cut.hpp"
+
+#include <autoware_utils_geometry/boost_polygon_utils.hpp>
+#include <autoware_utils_geometry/geometry.hpp>
+
+#include <boost/geometry.hpp>
+
+#include <algorithm>
+#include <cmath>
+
+namespace autoware::map_based_prediction::path_cut
+{
+
+namespace
+{
+void extend_bbox_by_footprint(
+  lanelet::BoundingBox2d & search_bbox, const PredictedPath & predicted_path, const double margin)
+{
+  const lanelet::BasicPoint2d offset(margin, margin);
+  for (const auto & pose : predicted_path.path) {
+    const lanelet::BasicPoint2d center(pose.position.x, pose.position.y);
+    search_bbox.extend(center - offset);
+    search_bbox.extend(center + offset);
+  }
+}
+}  // namespace
+
+double calc_footprint_search_margin(const autoware_perception_msgs::msg::Shape & shape)
+{
+  if (shape.type == autoware_perception_msgs::msg::Shape::BOUNDING_BOX) {
+    const auto hx = shape.dimensions.x * 0.5;
+    const auto hy = shape.dimensions.y * 0.5;
+    return std::hypot(hx, hy);
+  }
+  if (shape.type == autoware_perception_msgs::msg::Shape::CYLINDER) {
+    return shape.dimensions.x * 0.5;
+  }
+  return std::max(shape.dimensions.x, shape.dimensions.y) * 0.5;
+}
+
+bool shape_has_footprint(const autoware_perception_msgs::msg::Shape & shape)
+{
+  using autoware_perception_msgs::msg::Shape;
+  switch (shape.type) {
+    case Shape::BOUNDING_BOX:
+      return shape.dimensions.x > 0.0 && shape.dimensions.y > 0.0;
+    case Shape::CYLINDER:
+      return shape.dimensions.x > 0.0;
+    case Shape::POLYGON:
+      return !shape.footprint.points.empty();
+    default:
+      return false;
+  }
+}
+
+bool has_required_info(const autoware_perception_msgs::msg::PredictedObject & predicted_object)
+{
+  return !predicted_object.kinematics.predicted_paths.empty() &&
+         shape_has_footprint(predicted_object.shape);
+}
+
+lanelet::BoundingBox2d get_bbox_contain_path_with_footprint(
+  const std::vector<PredictedPath> & predicted_paths,
+  const autoware_perception_msgs::msg::Shape & object_shape)
+{
+  lanelet::BoundingBox2d search_bbox;
+  const auto margin = calc_footprint_search_margin(object_shape);
+  for (const auto & predicted_path : predicted_paths) {
+    extend_bbox_by_footprint(search_bbox, predicted_path, margin);
+  }
+  return search_bbox;
+}
+
+lanelet::BoundingBox2d get_bbox_contain_path_with_footprint(
+  const PredictedPath & predicted_path, const autoware_perception_msgs::msg::Shape & object_shape)
+{
+  lanelet::BoundingBox2d search_bbox;
+  extend_bbox_by_footprint(search_bbox, predicted_path, calc_footprint_search_margin(object_shape));
+  return search_bbox;
+}
+
+std::optional<size_t> find_footprint_crossing_index(
+  const PredictedPath & predicted_path, const autoware_perception_msgs::msg::Shape & object_shape,
+  const std::vector<autoware_utils_geometry::LineString2d> & linestrings_2d)
+{
+  if (linestrings_2d.empty()) {
+    return std::nullopt;
+  }
+  for (auto i = 0UL; i < predicted_path.path.size(); ++i) {
+    const autoware_utils_geometry::Polygon2d footprint =
+      autoware_utils_geometry::to_polygon2d(predicted_path.path.at(i), object_shape);
+    for (const auto & linestring : linestrings_2d) {
+      if (boost::geometry::intersects(footprint, linestring)) {
+        return i;
+      }
+    }
+  }
+  return std::nullopt;
+}
+
+std::optional<size_t> find_footprint_crossing_index(
+  const PredictedPath & predicted_path, const autoware_perception_msgs::msg::Shape & object_shape,
+  const std::vector<autoware_utils_geometry::Polygon2d> & polygons_2d)
+{
+  if (polygons_2d.empty()) {
+    return std::nullopt;
+  }
+  for (auto i = 0UL; i < predicted_path.path.size(); ++i) {
+    const autoware_utils_geometry::Polygon2d footprint =
+      autoware_utils_geometry::to_polygon2d(predicted_path.path.at(i), object_shape);
+    for (const auto & polygon : polygons_2d) {
+      // NOTE: intersects_convex (GJK) treats both polygons as convex. A non-convex boundary area
+      // is evaluated as its convex hull, but this works effectively.
+      if (autoware_utils_geometry::intersects_convex(footprint, polygon)) {
+        return i;
+      }
+    }
+  }
+  return std::nullopt;
+}
+
+}  // namespace autoware::map_based_prediction::path_cut