autowarefoundation · satoshi-ota · Nov 28, 2023 · Nov 28, 2023
diff --git a/planning/behavior_path_planner/config/avoidance/avoidance.param.yaml b/planning/behavior_path_planner/config/avoidance/avoidance.param.yaml
@@ -27,7 +27,6 @@
       # avoidance is performed for the object type with true
       target_object:
         car:
-          is_target: true                              # [-]
           execute_num: 1                               # [-]
           moving_speed_threshold: 1.0                  # [m/s]
           moving_time_threshold: 1.0                   # [s]
@@ -38,7 +37,6 @@
           safety_buffer_longitudinal: 0.0              # [m]
           use_conservative_buffer_longitudinal: true   # [-] When set to true, the base_link2front is added to the longitudinal buffer before avoidance.
         truck:
-          is_target: true
           execute_num: 1
           moving_speed_threshold: 1.0                  # 3.6km/h
           moving_time_threshold: 1.0
@@ -49,7 +47,6 @@
           safety_buffer_longitudinal: 0.0
           use_conservative_buffer_longitudinal: true
         bus:
-          is_target: true
           execute_num: 1
           moving_speed_threshold: 1.0                  # 3.6km/h
           moving_time_threshold: 1.0
@@ -60,7 +57,6 @@
           safety_buffer_longitudinal: 0.0
           use_conservative_buffer_longitudinal: true
         trailer:
-          is_target: true
           execute_num: 1
           moving_speed_threshold: 1.0                  # 3.6km/h
           moving_time_threshold: 1.0
@@ -71,7 +67,6 @@
           safety_buffer_longitudinal: 0.0
           use_conservative_buffer_longitudinal: true
         unknown:
-          is_target: true
           execute_num: 1
           moving_speed_threshold: 0.28                 # 1.0km/h
           moving_time_threshold: 1.0
@@ -82,7 +77,6 @@
           safety_buffer_longitudinal: 0.0
           use_conservative_buffer_longitudinal: true
         bicycle:
-          is_target: true
           execute_num: 1
           moving_speed_threshold: 0.28                 # 1.0km/h
           moving_time_threshold: 1.0
@@ -93,7 +87,6 @@
           safety_buffer_longitudinal: 1.0
           use_conservative_buffer_longitudinal: true
         motorcycle:
-          is_target: true
           execute_num: 1
           moving_speed_threshold: 1.0                  # 3.6km/h
           moving_time_threshold: 1.0
@@ -104,7 +97,6 @@
           safety_buffer_longitudinal: 1.0
           use_conservative_buffer_longitudinal: true
         pedestrian:
-          is_target: true
           execute_num: 1
           moving_speed_threshold: 0.28                 # 1.0km/h
           moving_time_threshold: 1.0
@@ -119,6 +111,16 @@
 
       # For target object filtering
       target_filtering:
+        # avoidance target type
+        target_type:
+          car: true                                      # [-]
+          truck: true                                    # [-]
+          bus: true                                      # [-]
+          trailer: true                                  # [-]
+          unknown: true                                  # [-]
+          bicycle: true                                  # [-]
+          motorcycle: true                               # [-]
+          pedestrian: true                               # [-]
         # detection range
         object_check_goal_distance: 20.0                # [m]
         # filtering parking objects
@@ -152,6 +154,16 @@
 
       # For safety check
       safety_check:
+        # safety check target type
+        target_type:
+          car: true                                      # [-]
+          truck: true                                    # [-]
+          bus: true                                      # [-]
+          trailer: true                                  # [-]
+          unknown: false                                 # [-]
+          bicycle: true                                  # [-]
+          motorcycle: true                               # [-]
+          pedestrian: true                               # [-]
         # safety check configuration
         enable: true                                     # [-]
         check_current_lane: false                        # [-]

diff --git a/planning/behavior_path_planner/config/avoidance_by_lc/avoidance_by_lc.param.yaml b/planning/behavior_path_planner/config/avoidance_by_lc/avoidance_by_lc.param.yaml
@@ -7,7 +7,6 @@
       # avoidance is performed for the object type with true
       target_object:
         car:
-          is_target: true                              # [-]
           execute_num: 2                               # [-]
           moving_speed_threshold: 1.0                  # [m/s]
           moving_time_threshold: 1.0                   # [s]
@@ -16,7 +15,6 @@
           avoid_margin_lateral: 1.0                    # [m]
           safety_buffer_lateral: 0.7                   # [m]
         truck:
-          is_target: true
           execute_num: 2
           moving_speed_threshold: 1.0                  # 3.6km/h
           moving_time_threshold: 1.0
@@ -25,7 +23,6 @@
           avoid_margin_lateral: 1.0
           safety_buffer_lateral: 0.7
         bus:
-          is_target: true
           execute_num: 2
           moving_speed_threshold: 1.0                  # 3.6km/h
           moving_time_threshold: 1.0
@@ -34,7 +31,6 @@
           avoid_margin_lateral: 1.0
           safety_buffer_lateral: 0.7
         trailer:
-          is_target: true
           execute_num: 2
           moving_speed_threshold: 1.0                  # 3.6km/h
           moving_time_threshold: 1.0
@@ -43,7 +39,6 @@
           avoid_margin_lateral: 1.0
           safety_buffer_lateral: 0.7
         unknown:
-          is_target: true
           execute_num: 1
           moving_speed_threshold: 0.28                 # 1.0km/h
           moving_time_threshold: 1.0
@@ -52,7 +47,6 @@
           avoid_margin_lateral: 1.0
           safety_buffer_lateral: 0.0
         bicycle:
-          is_target: true
           execute_num: 2
           moving_speed_threshold: 0.28                 # 1.0km/h
           moving_time_threshold: 1.0
@@ -61,7 +55,6 @@
           avoid_margin_lateral: 1.0
           safety_buffer_lateral: 1.0
         motorcycle:
-          is_target: true
           execute_num: 2
           moving_speed_threshold: 1.0                  # 3.6km/h
           moving_time_threshold: 1.0
@@ -70,7 +63,6 @@
           avoid_margin_lateral: 1.0
           safety_buffer_lateral: 1.0
         pedestrian:
-          is_target: true
           execute_num: 2
           moving_speed_threshold: 0.28                 # 1.0km/h
           moving_time_threshold: 1.0
@@ -80,3 +72,16 @@
           safety_buffer_lateral: 1.0
         lower_distance_for_polygon_expansion: 0.0      # [m]
         upper_distance_for_polygon_expansion: 1.0      # [m]
+
+      # For target object filtering
+      target_filtering:
+        # avoidance target type
+        target_type:
+          car: true                                    # [-]
+          truck: true                                  # [-]
+          bus: true                                    # [-]
+          trailer: true                                # [-]
+          unknown: true                                # [-]
+          bicycle: false                               # [-]
+          motorcycle: false                            # [-]
+          pedestrian: false                            # [-]
diff --git a/...vior_path_planner/include/behavior_path_planner/utils/avoidance/avoidance_module_data.hpp b/...vior_path_planner/include/behavior_path_planner/utils/avoidance/avoidance_module_data.hpp
@@ -54,7 +54,9 @@ using behavior_path_planner::utils::path_safety_checker::CollisionCheckDebug;
 
 struct ObjectParameter
 {
-  bool is_target{false};
+  bool is_avoidance_target{false};
+
+  bool is_safety_check_target{false};
 
   size_t execute_num{1};
 

diff --git a/planning/behavior_path_planner/src/scene_module/avoidance/manager.cpp b/planning/behavior_path_planner/src/scene_module/avoidance/manager.cpp
@@ -64,90 +64,123 @@
  // target object
   {
     const auto get_object_param = [&](std::string && ns) {
       ObjectParameter param{};
-      param.is_target = getOrDeclareParameter<bool>(*node, ns + "is_target");
       param.execute_num = getOrDeclareParameter<int>(*node, ns + "execute_num");
       param.moving_speed_threshold =
         getOrDeclareParameter<double>(*node, ns + "moving_speed_threshold");
      param.moving_time_threshold =
        getOrDeclareParameter<double>(*node, ns + "moving_time_threshold");
      param.max_expand_ratio = getOrDeclareParameter<double>(*node, ns + "max_expand_ratio");
      param.envelope_buffer_margin =
        getOrDeclareParameter<double>(*node, ns + "envelope_buffer_margin");
      param.avoid_margin_lateral =
        getOrDeclareParameter<double>(*node, ns + "avoid_margin_lateral");
      param.safety_buffer_lateral =
        getOrDeclareParameter<double>(*node, ns + "safety_buffer_lateral");
      param.safety_buffer_longitudinal =
        getOrDeclareParameter<double>(*node, ns + "safety_buffer_longitudinal");
      param.use_conservative_buffer_longitudinal =
        getOrDeclareParameter<bool>(*node, ns + "use_conservative_buffer_longitudinal");
      return param;
    };

    const std::string ns = "avoidance.target_object.";
    p.object_parameters.emplace(
      ObjectClassification::MOTORCYCLE, get_object_param(ns + "motorcycle."));
    p.object_parameters.emplace(ObjectClassification::CAR, get_object_param(ns + "car."));
    p.object_parameters.emplace(ObjectClassification::TRUCK, get_object_param(ns + "truck."));
    p.object_parameters.emplace(ObjectClassification::TRAILER, get_object_param(ns + "trailer."));
    p.object_parameters.emplace(ObjectClassification::BUS, get_object_param(ns + "bus."));
    p.object_parameters.emplace(
      ObjectClassification::PEDESTRIAN, get_object_param(ns + "pedestrian."));
    p.object_parameters.emplace(ObjectClassification::BICYCLE, get_object_param(ns + "bicycle."));
    p.object_parameters.emplace(ObjectClassification::UNKNOWN, get_object_param(ns + "unknown."));

    p.lower_distance_for_polygon_expansion =
      getOrDeclareParameter<double>(*node, ns + "lower_distance_for_polygon_expansion");
    p.upper_distance_for_polygon_expansion =
      getOrDeclareParameter<double>(*node, ns + "upper_distance_for_polygon_expansion");
  }
 
   // target filtering
   {
+    const auto set_target_flag = [&](const uint8_t & object_type, const std::string & ns) {
+      if (p.object_parameters.count(object_type) == 0) {
+        return;
+      }
+      p.object_parameters.at(object_type).is_avoidance_target =
+        getOrDeclareParameter<bool>(*node, ns);
+    };
+
     std::string ns = "avoidance.target_filtering.";
+    set_target_flag(ObjectClassification::CAR, ns + "target_type.car");
+    set_target_flag(ObjectClassification::TRUCK, ns + "target_type.truck");
+    set_target_flag(ObjectClassification::TRAILER, ns + "target_type.trailer");
+    set_target_flag(ObjectClassification::BUS, ns + "target_type.bus");
+    set_target_flag(ObjectClassification::PEDESTRIAN, ns + "target_type.pedestrian");
+    set_target_flag(ObjectClassification::BICYCLE, ns + "target_type.bicycle");
+    set_target_flag(ObjectClassification::MOTORCYCLE, ns + "target_type.motorcycle");
+    set_target_flag(ObjectClassification::UNKNOWN, ns + "target_type.unknown");
+
     p.object_check_goal_distance =
       getOrDeclareParameter<double>(*node, ns + "object_check_goal_distance");
     p.threshold_distance_object_is_on_center =
      getOrDeclareParameter<double>(*node, ns + "threshold_distance_object_is_on_center");
    p.object_check_shiftable_ratio =
      getOrDeclareParameter<double>(*node, ns + "object_check_shiftable_ratio");
    p.object_check_min_road_shoulder_width =
      getOrDeclareParameter<double>(*node, ns + "object_check_min_road_shoulder_width");
    p.object_check_yaw_deviation =
      getOrDeclareParameter<double>(*node, ns + "intersection.yaw_deviation");
    p.object_last_seen_threshold =
      getOrDeclareParameter<double>(*node, ns + "object_last_seen_threshold");
  }

  {
    std::string ns = "avoidance.target_filtering.force_avoidance.";
    p.enable_force_avoidance_for_stopped_vehicle =
      getOrDeclareParameter<bool>(*node, ns + "enable");
    p.threshold_time_force_avoidance_for_stopped_vehicle =
      getOrDeclareParameter<double>(*node, ns + "time_threshold");
    p.object_ignore_section_traffic_light_in_front_distance =
      getOrDeclareParameter<double>(*node, ns + "ignore_area.traffic_light.front_distance");
    p.object_ignore_section_crosswalk_in_front_distance =
      getOrDeclareParameter<double>(*node, ns + "ignore_area.crosswalk.front_distance");
    p.object_ignore_section_crosswalk_behind_distance =
      getOrDeclareParameter<double>(*node, ns + "ignore_area.crosswalk.behind_distance");
  }

  {
    std::string ns = "avoidance.target_filtering.detection_area.";
    p.use_static_detection_area = getOrDeclareParameter<bool>(*node, ns + "static");
    p.object_check_min_forward_distance =
      getOrDeclareParameter<double>(*node, ns + "min_forward_distance");
    p.object_check_max_forward_distance =
      getOrDeclareParameter<double>(*node, ns + "max_forward_distance");
    p.object_check_backward_distance =
      getOrDeclareParameter<double>(*node, ns + "backward_distance");
  }
 
   // safety check general params
   {
+    const auto set_target_flag = [&](const uint8_t & object_type, const std::string & ns) {
+      if (p.object_parameters.count(object_type) == 0) {
+        return;
+      }
+      p.object_parameters.at(object_type).is_safety_check_target =
+        getOrDeclareParameter<bool>(*node, ns);
+    };
+
     std::string ns = "avoidance.safety_check.";
+    set_target_flag(ObjectClassification::CAR, ns + "target_type.car");
+    set_target_flag(ObjectClassification::TRUCK, ns + "target_type.truck");
+    set_target_flag(ObjectClassification::TRAILER, ns + "target_type.trailer");
+    set_target_flag(ObjectClassification::BUS, ns + "target_type.bus");
+    set_target_flag(ObjectClassification::PEDESTRIAN, ns + "target_type.pedestrian");
+    set_target_flag(ObjectClassification::BICYCLE, ns + "target_type.bicycle");
+    set_target_flag(ObjectClassification::MOTORCYCLE, ns + "target_type.motorcycle");
+    set_target_flag(ObjectClassification::UNKNOWN, ns + "target_type.unknown");
+
     p.enable_safety_check = getOrDeclareParameter<bool>(*node, ns + "enable");
     p.check_current_lane = getOrDeclareParameter<bool>(*node, ns + "check_current_lane");
     p.check_shift_side_lane = getOrDeclareParameter<bool>(*node, ns + "check_shift_side_lane");
@@ -346,7 +379,6 @@
   const auto update_object_param = [&p, &parameters](
                                      const auto & semantic, const std::string & ns) {
     auto & config = p->object_parameters.at(semantic);
-    updateParam<bool>(parameters, ns + "is_target", config.is_target);
     updateParam<double>(parameters, ns + "moving_speed_threshold", config.moving_speed_threshold);
     updateParam<double>(parameters, ns + "moving_time_threshold", config.moving_time_threshold);
     updateParam<double>(parameters, ns + "max_expand_ratio", config.max_expand_ratio);

diff --git a/planning/behavior_path_planner/src/scene_module/lane_change/manager.cpp b/planning/behavior_path_planner/src/scene_module/lane_change/manager.cpp
@@ -284,44 +284,60 @@
  // target object
   {
     const auto get_object_param = [&](std::string && ns) {
       ObjectParameter param{};
-      param.is_target = getOrDeclareParameter<bool>(*node, ns + "is_target");
       param.execute_num = getOrDeclareParameter<int>(*node, ns + "execute_num");
       param.moving_speed_threshold =
         getOrDeclareParameter<double>(*node, ns + "moving_speed_threshold");
      param.moving_time_threshold =
        getOrDeclareParameter<double>(*node, ns + "moving_time_threshold");
      param.max_expand_ratio = getOrDeclareParameter<double>(*node, ns + "max_expand_ratio");
      param.envelope_buffer_margin =
        getOrDeclareParameter<double>(*node, ns + "envelope_buffer_margin");
      param.avoid_margin_lateral =
        getOrDeclareParameter<double>(*node, ns + "avoid_margin_lateral");
      param.safety_buffer_lateral =
        getOrDeclareParameter<double>(*node, ns + "safety_buffer_lateral");
      return param;
    };

    const std::string ns = "avoidance_by_lane_change.target_object.";
    p.object_parameters.emplace(
      ObjectClassification::MOTORCYCLE, get_object_param(ns + "motorcycle."));
    p.object_parameters.emplace(ObjectClassification::CAR, get_object_param(ns + "car."));
    p.object_parameters.emplace(ObjectClassification::TRUCK, get_object_param(ns + "truck."));
    p.object_parameters.emplace(ObjectClassification::TRAILER, get_object_param(ns + "trailer."));
    p.object_parameters.emplace(ObjectClassification::BUS, get_object_param(ns + "bus."));
    p.object_parameters.emplace(
      ObjectClassification::PEDESTRIAN, get_object_param(ns + "pedestrian."));
    p.object_parameters.emplace(ObjectClassification::BICYCLE, get_object_param(ns + "bicycle."));
    p.object_parameters.emplace(ObjectClassification::UNKNOWN, get_object_param(ns + "unknown."));

    p.lower_distance_for_polygon_expansion =
      getOrDeclareParameter<double>(*node, ns + "lower_distance_for_polygon_expansion");
    p.upper_distance_for_polygon_expansion =
      getOrDeclareParameter<double>(*node, ns + "upper_distance_for_polygon_expansion");
  }
 
   // target filtering
   {
+    const auto set_target_flag = [&](const uint8_t & object_type, const std::string & ns) {
+      if (p.object_parameters.count(object_type) == 0) {
+        return;
+      }
+      p.object_parameters.at(object_type).is_avoidance_target =
+        getOrDeclareParameter<bool>(*node, ns);
+    };
+
     std::string ns = "avoidance.target_filtering.";
+    set_target_flag(ObjectClassification::CAR, ns + "target_type.car");
+    set_target_flag(ObjectClassification::TRUCK, ns + "target_type.truck");
+    set_target_flag(ObjectClassification::TRAILER, ns + "target_type.trailer");
+    set_target_flag(ObjectClassification::BUS, ns + "target_type.bus");
+    set_target_flag(ObjectClassification::PEDESTRIAN, ns + "target_type.pedestrian");
+    set_target_flag(ObjectClassification::BICYCLE, ns + "target_type.bicycle");
+    set_target_flag(ObjectClassification::MOTORCYCLE, ns + "target_type.motorcycle");
+    set_target_flag(ObjectClassification::UNKNOWN, ns + "target_type.unknown");
+
     p.object_check_goal_distance =
       getOrDeclareParameter<double>(*node, ns + "object_check_goal_distance");
     p.threshold_distance_object_is_on_center =

diff --git a/planning/behavior_path_planner/src/utils/avoidance/utils.cpp b/planning/behavior_path_planner/src/utils/avoidance/utils.cpp
@@ -1,4 +1,4 @@
 // Copyright 2021 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.
@@ -235,7 +235,7 @@
 
 namespace filtering_utils
 {
-bool isTargetObjectType(
+bool isAvoidanceTargetObjectType(
   const PredictedObject & object, const std::shared_ptr<AvoidanceParameters> & parameters)
 {
   const auto object_type = utils::getHighestProbLabel(object.classification);
@@ -244,7 +244,19 @@
     return false;
   }
 
-  return parameters->object_parameters.at(object_type).is_target;
+  return parameters->object_parameters.at(object_type).is_avoidance_target;
+}
+
+bool isSafetyCheckTargetObjectType(
+  const PredictedObject & object, const std::shared_ptr<AvoidanceParameters> & parameters)
+{
+  const auto object_type = utils::getHighestProbLabel(object.classification);
+
+  if (parameters->object_parameters.count(object_type) == 0) {
+    return false;
+  }
+
+  return parameters->object_parameters.at(object_type).is_safety_check_target;
 }
 
 bool isVehicleTypeObject(const ObjectData & object)
@@ -311,17 +323,17 @@
    object_polygon, utils::toPolygon2d(lanelet::utils::to2D(polygon.basicPolygon())));
 }

 bool isParallelToEgoLane(const ObjectData & object, const double threshold)
 {
  const auto & object_pose = object.object.kinematics.initial_pose_with_covariance.pose;
  const auto closest_pose =
    lanelet::utils::getClosestCenterPose(object.overhang_lanelet, object_pose.position);
  const auto yaw_deviation = std::abs(calcYawDeviation(closest_pose, object_pose));

  return yaw_deviation < threshold || yaw_deviation > M_PI - threshold;
 }

 bool isObjectOnRoadShoulder(
  ObjectData & object, const std::shared_ptr<RouteHandler> & route_handler,
  const std::shared_ptr<AvoidanceParameters> & parameters)
 {
@@ -334,7 +346,7 @@
  // assume that there are no parked vehicles in intersection.
  std::string turn_direction = object.overhang_lanelet.attributeOr("turn_direction", "else");
  if (turn_direction == "right" || turn_direction == "left" || turn_direction == "straight") {
    return false;
  }

  // ============================================ <- most_left_lanelet.leftBound()
@@ -357,7 +369,7 @@

  bool is_left_side_parked_vehicle = false;
  if (!isOnRight(object)) {
    auto [object_shiftable_distance, sub_type] = [&]() {
      const auto most_left_road_lanelet =
        route_handler->getMostLeftLanelet(object.overhang_lanelet);
      const auto most_left_lanelet_candidates =
@@ -373,7 +385,7 @@
        if (sub_type.value() == "road_shoulder") {
          most_left_lanelet = ll;
        }
      }

      const auto center_to_left_boundary =
        distance2d(to2D(most_left_lanelet.leftBound().basicLineString()), to2D(centerline_point));
@@ -383,19 +395,19 @@
    }();

    if (sub_type.value() != "road_shoulder") {
      object_shiftable_distance += parameters->object_check_min_road_shoulder_width;
    }

    const auto arc_coordinates = toArcCoordinates(
      to2D(object.overhang_lanelet.centerline().basicLineString()), object_centroid);
    object.shiftable_ratio = arc_coordinates.distance / object_shiftable_distance;

    is_left_side_parked_vehicle = object.shiftable_ratio > parameters->object_check_shiftable_ratio;
  }

  bool is_right_side_parked_vehicle = false;
  if (isOnRight(object)) {
    auto [object_shiftable_distance, sub_type] = [&]() {
      const auto most_right_road_lanelet =
        route_handler->getMostRightLanelet(object.overhang_lanelet);
      const auto most_right_lanelet_candidates =
@@ -411,7 +423,7 @@
        if (sub_type.value() == "road_shoulder") {
          most_right_lanelet = ll;
        }
      }

      const auto center_to_right_boundary =
        distance2d(to2D(most_right_lanelet.rightBound().basicLineString()), to2D(centerline_point));
@@ -421,18 +433,18 @@
    }();

    if (sub_type.value() != "road_shoulder") {
      object_shiftable_distance += parameters->object_check_min_road_shoulder_width;
    }

    const auto arc_coordinates = toArcCoordinates(
      to2D(object.overhang_lanelet.centerline().basicLineString()), object_centroid);
    object.shiftable_ratio = -1.0 * arc_coordinates.distance / object_shiftable_distance;

    is_right_side_parked_vehicle =
      object.shiftable_ratio > parameters->object_check_shiftable_ratio;
  }

  return is_left_side_parked_vehicle || is_right_side_parked_vehicle;
 }

 bool isForceAvoidanceTarget(
@@ -494,87 +506,87 @@
  return !not_parked_object;
 }

 bool isSatisfiedWithCommonCondition(
  ObjectData & object, const AvoidancePlanningData & data,
  const std::shared_ptr<const PlannerData> & planner_data,
   const std::shared_ptr<AvoidanceParameters> & parameters)
 {
   // Step1. filtered by target object type.
-  if (!isTargetObjectType(object.object, parameters)) {
+  if (!isAvoidanceTargetObjectType(object.object, parameters)) {
     object.reason = AvoidanceDebugFactor::OBJECT_IS_NOT_TYPE;
     return false;
   }

  // Step2. filtered stopped objects.
  const auto object_type = utils::getHighestProbLabel(object.object.classification);
  const auto object_parameter = parameters->object_parameters.at(object_type);
  if (object.move_time > object_parameter.moving_time_threshold) {
    object.reason = AvoidanceDebugFactor::MOVING_OBJECT;
    return false;
  }

  // Step3. filtered by longitudinal distance.
  const auto & ego_pos = planner_data->self_odometry->pose.pose.position;
  fillLongitudinalAndLengthByClosestEnvelopeFootprint(data.reference_path_rough, ego_pos, object);

  if (object.longitudinal < -parameters->object_check_backward_distance) {
    object.reason = AvoidanceDebugFactor::OBJECT_IS_BEHIND_THRESHOLD;
    return false;
  }

  if (object.longitudinal > parameters->object_check_max_forward_distance) {
    object.reason = AvoidanceDebugFactor::OBJECT_IS_IN_FRONT_THRESHOLD;
    return false;
  }

  // Step4. filtered by distance between object and goal position.
  // TODO(Satoshi OTA): remove following two conditions after it can execute avoidance and goal
  // planner module simultaneously.
  const auto & rh = planner_data->route_handler;
  const auto ego_idx = planner_data->findEgoIndex(data.reference_path_rough.points);
  const auto to_goal_distance =
    rh->isInGoalRouteSection(data.current_lanelets.back())
      ? calcSignedArcLength(
          data.reference_path_rough.points, ego_idx, data.reference_path_rough.points.size() - 1)
      : std::numeric_limits<double>::max();

  if (object.longitudinal > to_goal_distance) {
    object.reason = AvoidanceDebugFactor::OBJECT_BEHIND_PATH_GOAL;
    return false;
  }

  if (
    object.longitudinal + object.length / 2 + parameters->object_check_goal_distance >
    to_goal_distance) {
    object.reason = "TooNearToGoal";
    return false;
  }

  return true;
 }

 bool isSatisfiedWithNonVehicleCondition(
  ObjectData & object, [[maybe_unused]] const AvoidancePlanningData & data,
  const std::shared_ptr<const PlannerData> & planner_data,
  [[maybe_unused]] const std::shared_ptr<AvoidanceParameters> & parameters)
 {
  // avoidance module ignore pedestrian and bicycle around crosswalk
  if (isWithinCrosswalk(object, planner_data->route_handler->getOverallGraphPtr())) {
    object.reason = "CrosswalkUser";
    return false;
  }

  return true;
 }

 bool isSatisfiedWithVehicleCondition(
  ObjectData & object, const AvoidancePlanningData & data,
  const std::shared_ptr<const PlannerData> & planner_data,
  const std::shared_ptr<AvoidanceParameters> & parameters)
 {
  using boost::geometry::within;

  object.is_within_intersection = isWithinIntersection(object, planner_data->route_handler);

  // from here condition check for vehicle type objects.
  if (isForceAvoidanceTarget(object, data, planner_data, parameters)) {
@@ -583,8 +595,8 @@

  // Object is on center line -> ignore.
  if (std::abs(object.lateral) < parameters->threshold_distance_object_is_on_center) {
    object.reason = AvoidanceDebugFactor::TOO_NEAR_TO_CENTERLINE;
    return false;
  }

  lanelet::BasicPoint2d object_centroid(object.centroid.x(), object.centroid.y());
@@ -594,8 +606,8 @@
    if (isObjectOnRoadShoulder(object, planner_data->route_handler, parameters)) {
      return true;
    } else {
      object.reason = AvoidanceDebugFactor::NOT_PARKING_OBJECT;
      return false;
    }
  }

@@ -604,14 +616,14 @@
  }

  if (isParallelToEgoLane(object, parameters->object_check_yaw_deviation)) {
    object.reason = "ParallelToEgoLane";
    return false;
  }

  return true;
 }

 bool isNoNeedAvoidanceBehavior(
  ObjectData & object, const std::shared_ptr<AvoidanceParameters> & parameters)
 {
  if (!object.avoid_margin.has_value()) {
@@ -619,48 +631,48 @@
  }

  const auto shift_length =
    calcShiftLength(isOnRight(object), object.overhang_dist, object.avoid_margin.value());
  if (!isShiftNecessary(isOnRight(object), shift_length)) {
    object.reason = "NotNeedAvoidance";
    return true;
  }

  if (std::abs(shift_length) < parameters->lateral_execution_threshold) {
    object.reason = "LessThanExecutionThreshold";
    return true;
  }

  return false;
 }

 std::optional<double> getAvoidMargin(
  const ObjectData & object, const std::shared_ptr<const PlannerData> & planner_data,
  const std::shared_ptr<AvoidanceParameters> & parameters)
 {
  const auto & vehicle_width = planner_data->parameters.vehicle_width;
  const auto object_type = utils::getHighestProbLabel(object.object.classification);
  const auto object_parameter = parameters->object_parameters.at(object_type);

  const auto max_avoid_margin = object_parameter.safety_buffer_lateral * object.distance_factor +
                                object_parameter.avoid_margin_lateral + 0.5 * vehicle_width;
  const auto min_avoid_margin = object_parameter.safety_buffer_lateral + 0.5 * vehicle_width;
  const auto soft_lateral_distance_limit =
    object.to_road_shoulder_distance - parameters->soft_road_shoulder_margin - 0.5 * vehicle_width;
  const auto hard_lateral_distance_limit =
    object.to_road_shoulder_distance - parameters->hard_road_shoulder_margin - 0.5 * vehicle_width;

  // Step1. check avoidable or not.
  if (hard_lateral_distance_limit < min_avoid_margin) {
    return std::nullopt;
  }

  // Step2. check if it should expand road shoulder margin.
  if (soft_lateral_distance_limit < min_avoid_margin) {
    return min_avoid_margin;
  }

  // Step3. nominal case. avoid margin is limited by soft constraint.
  return std::min(soft_lateral_distance_limit, max_avoid_margin);
 }
 }  // namespace filtering_utils

@@ -741,20 +753,20 @@
  return path_arclength_arr.size() - 1;
 }

 std::vector<UUID> concatParentIds(const std::vector<UUID> & ids1, const std::vector<UUID> & ids2)
 {
  std::vector<UUID> ret;
  for (const auto id2 : ids2) {
    if (std::any_of(ids1.begin(), ids1.end(), [&id2](const auto & id1) { return id1 == id2; })) {
      continue;
    }
    ret.push_back(id2);
  }

  return ret;
 }

 std::vector<UUID> calcParentIds(const AvoidLineArray & lines1, const AvoidLine & lines2)
 {
  // Get the ID of the original AP whose transition area overlaps with the given AP,
  // and set it to the parent id.
@@ -770,7 +782,7 @@

    ret.push_back(al.id);
  }
  return ret;
 }

 double lerpShiftLengthOnArc(double arc, const AvoidLine & ap)
@@ -935,7 +947,7 @@

    // generate obstacle polygon
    const double diff_poly_buffer =
      object.avoid_margin.value() - object_parameter.envelope_buffer_margin - vehicle_width / 2.0;
    const auto obj_poly =
      tier4_autoware_utils::expandPolygon(object.envelope_poly, diff_poly_buffer);
    const bool is_left = 0 < object.lateral;
@@ -1031,7 +1043,7 @@
  }

  return extend_lanelets;
 }

 void insertDecelPoint(
  const Point & p_src, const double offset, const double velocity, PathWithLaneId & path,
@@ -1333,7 +1345,7 @@
  }
 }

 double getRoadShoulderDistance(
  ObjectData & object, const AvoidancePlanningData & data,
  const std::shared_ptr<const PlannerData> & planner_data,
  const std::shared_ptr<AvoidanceParameters> & parameters)
@@ -1342,16 +1354,16 @@

  const auto & object_pose = object.object.kinematics.initial_pose_with_covariance.pose;
  const auto object_closest_index =
    findNearestIndex(data.reference_path_rough.points, object_pose.position);
  const auto object_closest_pose =
    data.reference_path_rough.points.at(object_closest_index).point.pose;

  const auto rh = planner_data->route_handler;
  if (!rh->getClosestLaneletWithinRoute(object_closest_pose, &object.overhang_lanelet)) {
    return 0.0;
  }

  double road_shoulder_distance = std::numeric_limits<double>::max();

  const bool get_left = isOnRight(object) && parameters->use_adjacent_lane;
  const bool get_right = !isOnRight(object) && parameters->use_adjacent_lane;
@@ -1363,16 +1375,16 @@

  lanelet::ConstLineString3d target_line{};

  const auto update_road_to_shoulder_distance = [&](const auto & target_lanelet) {
    const auto lines =
      rh->getFurthestLinestring(target_lanelet, get_right, get_left, get_opposite, true);
    const auto & line = isOnRight(object) ? lines.back() : lines.front();
    const auto d = boost::geometry::distance(object.envelope_poly, to2D(line.basicLineString()));
    if (d < road_shoulder_distance) {
      road_shoulder_distance = d;
      target_line = line;
    }
  };

  // current lanelet
  {
@@ -1380,7 +1392,7 @@

    road_shoulder_distance = extendToRoadShoulderDistanceWithPolygon(
      rh, target_line, road_shoulder_distance, object.overhang_lanelet,
      object.overhang_pose.position, p_overhang, parameters->use_hatched_road_markings,
      parameters->use_intersection_areas);
  }

@@ -1389,9 +1401,9 @@
  if (rh->getPreviousLaneletsWithinRoute(object.overhang_lanelet, &previous_lanelet)) {
    update_road_to_shoulder_distance(previous_lanelet.front());

    road_shoulder_distance = extendToRoadShoulderDistanceWithPolygon(
      rh, target_line, road_shoulder_distance, previous_lanelet.front(),
      object.overhang_pose.position, p_overhang, parameters->use_hatched_road_markings,
      parameters->use_intersection_areas);
  }

@@ -1400,13 +1412,13 @@
  if (rh->getNextLaneletWithinRoute(object.overhang_lanelet, &next_lanelet)) {
    update_road_to_shoulder_distance(next_lanelet);

    road_shoulder_distance = extendToRoadShoulderDistanceWithPolygon(
      rh, target_line, road_shoulder_distance, next_lanelet, object.overhang_pose.position,
      p_overhang, parameters->use_hatched_road_markings, parameters->use_intersection_areas);
  }

  return road_shoulder_distance;
 }

 void filterTargetObjects(
  ObjectDataArray & objects, AvoidancePlanningData & data, [[maybe_unused]] DebugData & debug,
@@ -1414,14 +1426,14 @@
  const std::shared_ptr<AvoidanceParameters> & parameters)
 {
  if (data.current_lanelets.empty()) {
    return;
  }

  const rclcpp::Time now = rclcpp::Clock(RCL_ROS_TIME).now();
  const auto push_target_object = [&data, &now](auto & object) {
    object.last_seen = now;
    data.target_objects.push_back(object);
  };

  for (auto & o : objects) {
    if (!filtering_utils::isSatisfiedWithCommonCondition(o, data, planner_data, parameters)) {
@@ -1705,10 +1717,12 @@
     });
   };
 
-  const auto to_predicted_objects = [&p](const auto & objects) {
+  const auto to_predicted_objects = [&p, &parameters](const auto & objects) {
     PredictedObjects ret{};
-    std::for_each(objects.begin(), objects.end(), [&p, &ret](const auto & object) {
-      ret.objects.push_back(object.object);
+    std::for_each(objects.begin(), objects.end(), [&p, &ret, &parameters](const auto & object) {
+      if (filtering_utils::isSafetyCheckTargetObjectType(object.object, parameters)) {
+        ret.objects.push_back(object.object);
+      }
     });
     return ret;
   };