feat(trajectory_validator): filter collision objects by shape

planning/autoware_trajectory_validator/config/trajectory_validator.param.yaml

@@ -23,12 +23,10 @@
             stopped_velocity_threshold: 0.3
             history_timeout: 0.3
         enable_assessment:
-          # default value is true.
-          unknown: false
-          animal: false
-          hazard: false
-          over_drivable: false
-          under_drivable: false
+          base: [bbox]
+          unknown: [""]
+          over_drivable: [""]
+          under_drivable: [""]
         pet_margin:
           ego_earlier: 0.6
           object_earlier: 1.0
@@ -88,12 +86,11 @@
               enable_abandon: false
       rss:
         enable_assessment:
-          # default value is true.
-          unknown: false
-          animal: false
-          hazard: false
-          over_drivable: false
-          under_drivable: false
+          base: [bbox, polygon]
+          motorcycle: [bbox]
+          bicycle: [bbox]
+          over_drivable: [""]
+          under_drivable: [""]
         stop_distance_margin: 2.0
         ego_total_braking_delay: 0.4
         ego_footprint_margin:

planning/autoware_trajectory_validator/param/parameter_struct.yaml

@@ -88,13 +88,17 @@ validator:
             read_only: false
       enable_assessment:
         base:
-          &drac_ea {
-            type: bool,
-            default_value: true,
-            description: DRAC enable_assessment per class,
+          &drac_ea_base {
+            type: string_array,
+            default_value: [bbox],
+            description: 'DRAC target Shape types per class. Supported values are bbox and polygon. Use [""] to disable the class.',
             read_only: false,
           }
-        unknown: *drac_ea
+        unknown: &drac_ea
+          type: string_array
+          default_value: []
+          description: DRAC target Shape types per class. Supported values are bbox and polygon. Use [""] to disable the class.
+          read_only: false
         car: *drac_ea
         truck: *drac_ea
         bus: *drac_ea
@@ -282,13 +286,17 @@ validator:
     rss:
       enable_assessment:
         base:
-          &rss_ea {
-            type: bool,
-            default_value: true,
-            description: RSS enable_assessment per class,
+          &rss_ea_base {
+            type: string_array,
+            default_value: [bbox, polygon],
+            description: 'RSS target Shape types per class. Supported values are bbox and polygon. Use [""] to disable the class.',
             read_only: false,
           }
-        unknown: *rss_ea
+        unknown: &rss_ea
+          type: string_array
+          default_value: []
+          description: RSS target Shape types per class. Supported values are bbox and polygon. Use [""] to disable the class.
+          read_only: false
         car: *rss_ea
         truck: *rss_ea
         bus: *rss_ea

planning/autoware_trajectory_validator/schema/trajectory_validator.schema.json

@@ -23,22 +23,36 @@
       "required": [],
       "additionalProperties": false
     },
-    "enable_assessment_per_class": {
+    "target_shapes_per_class": {
       "type": "object",
       "properties": {
-        "base": { "type": "boolean", "default": true },
-        "unknown": { "type": "boolean", "default": true },
-        "car": { "type": "boolean", "default": true },
-        "truck": { "type": "boolean", "default": true },
-        "bus": { "type": "boolean", "default": true },
-        "trailer": { "type": "boolean", "default": true },
-        "motorcycle": { "type": "boolean", "default": true },
-        "bicycle": { "type": "boolean", "default": true },
-        "pedestrian": { "type": "boolean", "default": true },
-        "animal": { "type": "boolean", "default": true },
-        "hazard": { "type": "boolean", "default": true },
-        "over_drivable": { "type": "boolean", "default": true },
-        "under_drivable": { "type": "boolean", "default": true }
+        "base": {
+          "type": "array",
+          "oneOf": [
+            {
+              "minItems": 1,
+              "items": { "enum": ["bbox", "polygon"] }
+            },
+            {
+              "minItems": 1,
+              "maxItems": 1,
+              "items": { "const": "" }
+            }
+          ],
+          "default": ["bbox"]
+        },
+        "unknown": { "$ref": "#/definitions/target_shapes_override" },
+        "car": { "$ref": "#/definitions/target_shapes_override" },
+        "truck": { "$ref": "#/definitions/target_shapes_override" },
+        "bus": { "$ref": "#/definitions/target_shapes_override" },
+        "trailer": { "$ref": "#/definitions/target_shapes_override" },
+        "motorcycle": { "$ref": "#/definitions/target_shapes_override" },
+        "bicycle": { "$ref": "#/definitions/target_shapes_override" },
+        "pedestrian": { "$ref": "#/definitions/target_shapes_override" },
+        "animal": { "$ref": "#/definitions/target_shapes_override" },
+        "hazard": { "$ref": "#/definitions/target_shapes_override" },
+        "over_drivable": { "$ref": "#/definitions/target_shapes_override" },
+        "under_drivable": { "$ref": "#/definitions/target_shapes_override" }
       },
       "required": [],
       "additionalProperties": false
@@ -63,6 +77,44 @@
       "required": [],
       "additionalProperties": false
     },
+    "target_shapes_override": {
+      "type": "array",
+      "default": [],
+      "oneOf": [
+        {
+          "maxItems": 0
+        },
+        {
+          "minItems": 1,
+          "items": { "enum": ["bbox", "polygon"] }
+        },
+        {
+          "minItems": 1,
+          "maxItems": 1,
+          "items": { "const": "" }
+        }
+      ]
+    },
+    "rss_target_shapes_per_class": {
+      "allOf": [{ "$ref": "#/definitions/target_shapes_per_class" }],
+      "properties": {
+        "base": {
+          "type": "array",
+          "oneOf": [
+            {
+              "minItems": 1,
+              "items": { "enum": ["bbox", "polygon"] }
+            },
+            {
+              "minItems": 1,
+              "maxItems": 1,
+              "items": { "const": "" }
+            }
+          ],
+          "default": ["bbox", "polygon"]
+        }
+      }
+    },
     "labeled_double": {
       "type": "object",
       "properties": {
@@ -230,7 +282,7 @@
                   "required": [],
                   "additionalProperties": false
                 },
-                "enable_assessment": { "$ref": "#/definitions/enable_assessment_per_class" },
+                "enable_assessment": { "$ref": "#/definitions/target_shapes_per_class" },
                 "pet_margin": {
                   "type": "object",
                   "properties": {
@@ -339,7 +391,7 @@
               "type": "object",
               "description": "Responsibility-Sensitive Safety (RSS) assessment settings.",
               "properties": {
-                "enable_assessment": { "$ref": "#/definitions/enable_assessment_per_class" },
+                "enable_assessment": { "$ref": "#/definitions/rss_target_shapes_per_class" },
                 "stop_distance_margin": {
                   "type": "number",
                   "description": "Required remaining distance to the object when ego stops [m].",

planning/autoware_trajectory_validator/src/filters/safety/collision_check_filter/assessment.cpp

@@ -471,7 +471,7 @@ DracArtifact assess(
 
   for (const auto & predicted_object : predicted_objects.objects) {
     const auto & drac_params = drac_param_map.at(to_type_string(predicted_object.classification));
-    if (!drac_params.enable_assessment) {
+    if (!drac_params.target_shape_types.contains(predicted_object.shape.type)) {
       continue;
     }
 
@@ -560,7 +560,7 @@ RssArtifact assess(
 
   for (const auto & object : context.predicted_objects->objects) {
     const auto & rss_params = rss_param_map.at(to_type_string(object.classification));
-    if (!rss_params.enable_assessment) {
+    if (!rss_params.target_shape_types.contains(object.shape.type)) {
       continue;
     }
 

planning/autoware_trajectory_validator/src/filters/safety/collision_check_filter/collision_check_filter.cpp

@@ -16,20 +16,35 @@
 
 #include "assessment.hpp"
 
+#include <rclcpp/logging.hpp>
+
 #include <fmt/core.h>
 
 #include <algorithm>
 #include <array>
 #include <cmath>
 #include <limits>
-#include <optional>
 #include <string>
 #include <string_view>
 #include <utility>
 #include <vector>
 
 namespace autoware::trajectory_validator::plugin::safety
 {
+namespace
+{
+void log_target_shape_type_params(
+  const std::string_view assessment_name, const std::string_view class_name,
+  const TargetShapeTypeParams & target_shape_types)
+{
+  RCLCPP_INFO(
+    rclcpp::get_logger("CollisionCheckFilter"),
+    "%s collision target shape types: class=%s, bbox=%s, polygon=%s",
+    std::string(assessment_name).c_str(), std::string(class_name).c_str(),
+    target_shape_types.bbox ? "true" : "false", target_shape_types.polygon ? "true" : "false");
+}
+}  // namespace
+
 void CollisionCheckFilter::update_parameters(const validator::Params & node_params)
 {
   global_params_ = GlobalParams(node_params.collision_check.global_setting);
@@ -39,6 +54,13 @@ void CollisionCheckFilter::update_parameters(const validator::Params & node_para
 
   drac_param_map_ = create_param_map_per_object<DracParams>(node_params);
   rss_param_map_ = create_param_map_per_object<RssParams>(node_params);
+
+  for (const auto & [class_name, params] : drac_param_map_) {
+    log_target_shape_type_params("DRAC", class_name, params.target_shape_types);
+  }
+  for (const auto & [class_name, params] : rss_param_map_) {
+    log_target_shape_type_params("RSS", class_name, params.target_shape_types);
+  }
 }
 
 void CollisionCheckFilter::clear_detection_times()

planning/autoware_trajectory_validator/src/filters/safety/collision_check_filter/parameter.hpp

@@ -18,6 +18,7 @@
 #include <autoware/object_recognition_utils/object_recognition_utils.hpp>
 #include <autoware_trajectory_validator/autoware_trajectory_validator_param.hpp>
 
+#include <algorithm>
 #include <cmath>
 #include <map>
 #include <stdexcept>
@@ -69,6 +70,55 @@
   return to_type_string(autoware::object_recognition_utils::getHighestProbLabel(obj));
 }
 
+inline bool is_disabled_target_shape_config(const std::vector<std::string> & shape_names)
+{
+  return shape_names.size() == 1U && shape_names.front().empty();
+}
+
+struct TargetShapeTypeParams
+{
+  bool bbox{true};
+  bool polygon{false};
+
+  TargetShapeTypeParams() = default;
+  explicit TargetShapeTypeParams(const std::vector<std::string> & shape_names)
+  : bbox{false}, polygon{false}
+  {
+    if (is_disabled_target_shape_config(shape_names)) {
+      return;
+    }
+
+    for (const auto & shape_name : shape_names) {
+      if (shape_name == "bbox") {
+        bbox = true;
+      } else if (shape_name == "polygon") {
+        polygon = true;
+      } else if (shape_name.empty()) {
+        throw std::invalid_argument(
+          "Invalid collision check target shape configuration. Use [\"\"] alone to disable the "
+          "class.");
+      } else {
+        throw std::invalid_argument(
+          "Unsupported collision check target shape: " + shape_name +
+          ". Supported values are bbox and polygon. Use [\"\"] to disable the class.");
+      }
+    }
+  }
+
+  bool contains(const uint8_t shape_type) const
+  {
+    using autoware_perception_msgs::msg::Shape;
+
+    if (shape_type == Shape::BOUNDING_BOX) {
+      return bbox;
+    }
+    if (shape_type == Shape::POLYGON) {
+      return polygon;
+    }
+    return false;
+  }
+};
+
 template <typename OutT, typename ParamStruct>
 OutT extract_labeled_param(const ParamStruct & params_struct, const std::string_view key)
 {
@@ -103,6 +153,8 @@
       return static_cast<OutT>(std::isnan(label_value) ? params_struct.base : label_value);
     } else if constexpr (std::is_same_v<OutT, std::string>) {
       return static_cast<OutT>(label_value.empty() ? params_struct.base : label_value);
+    } else if constexpr (std::is_same_v<OutT, std::vector<std::string>>) {
+      return static_cast<OutT>(label_value.empty() ? params_struct.base : label_value);
     } else {
       return static_cast<OutT>(label_value);
     }
@@ -236,7 +288,8 @@
         extract_labeled_param<bool>(input_acceleration.enable_abandon, key);
     };
 
-    enable_assessment = extract_labeled_param<bool>(drac.enable_assessment, key);
+    target_shape_types = TargetShapeTypeParams(
+      extract_labeled_param<std::vector<std::string>>(drac.enable_assessment, key));
     pet_margin.ego_earlier = extract_labeled_param<double>(drac.pet_margin.ego_earlier, key);
     pet_margin.object_earlier = extract_labeled_param<double>(drac.pet_margin.object_earlier, key);
     ego_footprint_margin.lateral =
@@ -282,7 +335,7 @@
       map_based.object_prioritized_object_earlier);
   }
 
-  bool enable_assessment{true};
+  TargetShapeTypeParams target_shape_types{};
   PetMargin pet_margin{};
   EgoFootprintMargin ego_footprint_margin{};
   EgoReactionBrakingDelay ego_reaction_braking_delay{};
@@ -301,7 +354,8 @@
   RssParams(const validator::Params & node_params, const std::string_view key)
   {
     const auto & rss = node_params.collision_check.rss;
-    enable_assessment = extract_labeled_param<bool>(rss.enable_assessment, key);
+    target_shape_types = TargetShapeTypeParams(
+      extract_labeled_param<std::vector<std::string>>(rss.enable_assessment, key));
     stop_distance_margin = extract_labeled_param<double>(rss.stop_distance_margin, key);
     ego_total_braking_delay = extract_labeled_param<double>(rss.ego_total_braking_delay, key);
     ego_footprint_margin.lateral = rss.ego_footprint_margin.lateral;
@@ -313,7 +367,7 @@
       extract_labeled_param<double>(rss.error_threshold.ego_acceleration, key);
   }
 
-  bool enable_assessment{true};
+  TargetShapeTypeParams target_shape_types{};
   double stop_distance_margin{2.0};
   double ego_total_braking_delay{0.4};
   EgoFootprintMargin ego_footprint_margin{};