chore(lane_change, QC): remove unused function (autowarefoundation#10188)

chore(lane_change): remove unused function

Signed-off-by: Mamoru Sobue <mamoru.sobue@tier4.jp>

Author: soblin

planning/behavior_path_planner/autoware_behavior_path_lane_change_module/include/autoware/behavior_path_lane_change_module/utils/utils.hpp

@@ -104,10 +104,6 @@ bool path_footprint_exceeds_target_lane_bound(
   const CommonDataPtr & common_data_ptr, const PathWithLaneId & path, const VehicleInfo & ego_info,
   const double margin = 0.1);
 
-std::vector<DrivableLanes> generateDrivableLanes(
-  const std::vector<DrivableLanes> & original_drivable_lanes, const RouteHandler & route_handler,
-  const lanelet::ConstLanelets & current_lanes, const lanelet::ConstLanelets & lane_change_lanes);
-
 std::vector<DrivableLanes> generateDrivableLanes(
   const RouteHandler & route_handler, const lanelet::ConstLanelets & current_lanes,
   const lanelet::ConstLanelets & lane_change_lanes);

planning/behavior_path_planner/autoware_behavior_path_lane_change_module/src/utils/utils.cpp

@@ -206,125 +206,6 @@ std::vector<DrivableLanes> generateDrivableLanes(
   return drivable_lanes;
 }
 
-std::vector<DrivableLanes> generateDrivableLanes(
-  const std::vector<DrivableLanes> & original_drivable_lanes, const RouteHandler & route_handler,
-  const lanelet::ConstLanelets & current_lanes, const lanelet::ConstLanelets & lane_change_lanes)
-{
-  const auto has_same_lane =
-    [](const lanelet::ConstLanelets & lanes, const lanelet::ConstLanelet & lane) {
-      if (lanes.empty()) return false;
-      const auto has_same = [&](const auto & ll) { return ll.id() == lane.id(); };
-      return std::find_if(lanes.begin(), lanes.end(), has_same) != lanes.end();
-    };
-
-  const auto check_middle = [&](const auto & lane) -> std::optional<DrivableLanes> {
-    for (const auto & drivable_lane : original_drivable_lanes) {
-      if (has_same_lane(drivable_lane.middle_lanes, lane)) {
-        return drivable_lane;
-      }
-    }
-    return std::nullopt;
-  };
-
-  const auto check_left = [&](const auto & lane) -> std::optional<DrivableLanes> {
-    for (const auto & drivable_lane : original_drivable_lanes) {
-      if (drivable_lane.left_lane.id() == lane.id()) {
-        return drivable_lane;
-      }
-    }
-    return std::nullopt;
-  };
-
-  const auto check_right = [&](const auto & lane) -> std::optional<DrivableLanes> {
-    for (const auto & drivable_lane : original_drivable_lanes) {
-      if (drivable_lane.right_lane.id() == lane.id()) {
-        return drivable_lane;
-      }
-    }
-    return std::nullopt;
-  };
-
-  size_t current_lc_idx = 0;
-  std::vector<DrivableLanes> drivable_lanes(current_lanes.size());
-  for (size_t i = 0; i < current_lanes.size(); ++i) {
-    const auto & current_lane = current_lanes.at(i);
-
-    const auto middle_drivable_lane = check_middle(current_lane);
-    if (middle_drivable_lane) {
-      drivable_lanes.at(i) = *middle_drivable_lane;
-    }
-
-    const auto left_drivable_lane = check_left(current_lane);
-    if (left_drivable_lane) {
-      drivable_lanes.at(i) = *left_drivable_lane;
-    }
-
-    const auto right_drivable_lane = check_right(current_lane);
-    if (right_drivable_lane) {
-      drivable_lanes.at(i) = *right_drivable_lane;
-    }
-
-    if (!middle_drivable_lane && !left_drivable_lane && !right_drivable_lane) {
-      drivable_lanes.at(i).left_lane = current_lane;
-      drivable_lanes.at(i).right_lane = current_lane;
-    }
-
-    const auto left_lane = route_handler.getLeftLanelet(current_lane);
-    const auto right_lane = route_handler.getRightLanelet(current_lane);
-    if (!left_lane && !right_lane) {
-      continue;
-    }
-
-    for (size_t lc_idx = current_lc_idx; lc_idx < lane_change_lanes.size(); ++lc_idx) {
-      const auto & lc_lane = lane_change_lanes.at(lc_idx);
-      if (left_lane && lc_lane.id() == left_lane->id()) {
-        if (left_drivable_lane) {
-          drivable_lanes.at(i).left_lane = lc_lane;
-        }
-        current_lc_idx = lc_idx;
-        break;
-      }
-
-      if (right_lane && lc_lane.id() == right_lane->id()) {
-        if (right_drivable_lane) {
-          drivable_lanes.at(i).right_lane = lc_lane;
-        }
-        current_lc_idx = lc_idx;
-        break;
-      }
-    }
-  }
-
-  for (size_t i = current_lc_idx + 1; i < lane_change_lanes.size(); ++i) {
-    const auto & lc_lane = lane_change_lanes.at(i);
-    DrivableLanes drivable_lane;
-
-    const auto middle_drivable_lane = check_middle(lc_lane);
-    if (middle_drivable_lane) {
-      drivable_lane = *middle_drivable_lane;
-    }
-
-    const auto left_drivable_lane = check_left(lc_lane);
-    if (left_drivable_lane) {
-      drivable_lane = *left_drivable_lane;
-    }
-
-    const auto right_drivable_lane = check_right(lc_lane);
-    if (right_drivable_lane) {
-      drivable_lane = *right_drivable_lane;
-    }
-
-    if (!middle_drivable_lane && !left_drivable_lane && !right_drivable_lane) {
-      drivable_lane.left_lane = lc_lane;
-      drivable_lane.right_lane = lc_lane;
-    }
-
-    drivable_lanes.push_back(drivable_lane);
-  }
-
-  return drivable_lanes;
-}
-
 double getLateralShift(const LaneChangePath & path)
 {
   if (path.shifted_path.shift_length.empty()) {