planning: changed perception_sl_boundary to PerceptionSLBoundary

modules/planning/common/path_obstacle.cc

@@ -430,7 +430,7 @@ const std::string PathObstacle::DebugString() const {
 
 void PathObstacle::EraseStBoundary() { st_boundary_ = StBoundary(); }
 
-const SLBoundary& PathObstacle::perception_sl_boundary() const {
+const SLBoundary& PathObstacle::PerceptionSLBoundary() const {
   return perception_sl_boundary_;
 }
 

modules/planning/common/path_obstacle.h

@@ -83,7 +83,7 @@ class PathObstacle {
 
   const std::string DebugString() const;
 
-  const SLBoundary& perception_sl_boundary() const;
+  const SLBoundary& PerceptionSLBoundary() const;
 
   const StBoundary& st_boundary() const;
 

modules/planning/common/reference_line_info.cc

@@ -195,14 +195,14 @@ bool ReferenceLineInfo::AddObstacles(
 
 bool ReferenceLineInfo::IsUnrelaventObstacle(PathObstacle* path_obstacle) {
   // if adc is on the road, and obstacle behind adc, ignore
-  if (path_obstacle->perception_sl_boundary().end_s() >
+  if (path_obstacle->PerceptionSLBoundary().end_s() >
       reference_line_.Length()) {
     return true;
   }
   if (is_on_reference_line_ &&
-      path_obstacle->perception_sl_boundary().end_s() <
+      path_obstacle->PerceptionSLBoundary().end_s() <
           adc_sl_boundary_.end_s() &&
-      reference_line_.IsOnRoad(path_obstacle->perception_sl_boundary())) {
+      reference_line_.IsOnRoad(path_obstacle->PerceptionSLBoundary())) {
     return true;
   }
   return false;
@@ -382,7 +382,7 @@ bool ReferenceLineInfo::ReachedDestination() const {
           dest_ptr->obstacle()->PerceptionBoundingBox().center())) {
     return false;
   }
-  const double stop_s = dest_ptr->perception_sl_boundary().start_s() +
+  const double stop_s = dest_ptr->PerceptionSLBoundary().start_s() +
                         dest_ptr->LongitudinalDecision().stop().distance_s();
   return adc_sl_boundary_.end_s() + kDestinationDeltaS > stop_s;
 }

modules/planning/planner/em/em_planner.cc

@@ -103,7 +103,7 @@ void EMPlanner::RecordObstacleDebugInfo(
     auto obstacle_debug = ptr_debug->mutable_planning_data()->add_obstacle();
     obstacle_debug->set_id(path_obstacle->Id());
     obstacle_debug->mutable_sl_boundary()->CopyFrom(
-        path_obstacle->perception_sl_boundary());
+        path_obstacle->PerceptionSLBoundary());
     const auto& decider_tags = path_obstacle->decider_tags();
     const auto& decisions = path_obstacle->decisions();
     if (decider_tags.size() != decisions.size()) {

modules/planning/tasks/dp_poly_path/dp_road_graph.cc

@@ -321,7 +321,7 @@ bool DPRoadGraph::IsSafeForLaneChange() {
 
   for (const auto &path_obstacle :
        reference_line_info_.path_decision().path_obstacles().Items()) {
-    const auto &sl_boundary = path_obstacle->perception_sl_boundary();
+    const auto &sl_boundary = path_obstacle->PerceptionSLBoundary();
     const auto &adc_sl_boundary = reference_line_info_.AdcSlBoundary();
 
     constexpr double kLateralShift = 2.5;

modules/planning/tasks/dp_poly_path/trajectory_cost.cc

@@ -60,7 +60,7 @@ TrajectoryCost::TrajectoryCost(
     if (ptr_path_obstacle->IsIgnore()) {
       continue;
     }
-    auto sl_boundary = ptr_path_obstacle->perception_sl_boundary();
+    auto sl_boundary = ptr_path_obstacle->PerceptionSLBoundary();
     const auto &vehicle_param =
         common::VehicleConfigHelper::instance()->GetConfig().vehicle_param();
 

modules/planning/tasks/path_decider/path_decider.cc

@@ -111,7 +111,7 @@ bool PathDecider::MakeStaticObstacleDecision(
     ObjectDecisionType object_decision;
     object_decision.mutable_ignore();
 
-    const auto &sl_boundary = path_obstacle->perception_sl_boundary();
+    const auto &sl_boundary = path_obstacle->PerceptionSLBoundary();
 
     if (sl_boundary.start_s() < frenet_points.front().s() ||
         sl_boundary.start_s() > frenet_points.back().s()) {
@@ -176,9 +176,9 @@ double PathDecider::MinimumRadiusStopDistance(
   const auto &vehicle_param = VehicleConfigHelper::GetConfig().vehicle_param();
   const double min_turn_radius = VehicleConfigHelper::MinSafeTurnRadius();
   double lateral_diff =
-      std::max(std::fabs(path_obstacle.perception_sl_boundary().start_l() -
+      std::max(std::fabs(path_obstacle.PerceptionSLBoundary().start_l() -
                          reference_line_info_->AdcSlBoundary().end_l()),
-               std::fabs(path_obstacle.perception_sl_boundary().end_l() -
+               std::fabs(path_obstacle.PerceptionSLBoundary().end_l() -
                          reference_line_info_->AdcSlBoundary().start_l()));
   lateral_diff = std::max(lateral_diff, vehicle_param.width());
   const double kEpison = 1e-5;
@@ -203,7 +203,7 @@ ObjectStop PathDecider::GenerateObjectStopDecision(
   object_stop.set_distance_s(-stop_distance);
 
   const double stop_ref_s =
-      path_obstacle.perception_sl_boundary().start_s() - stop_distance;
+      path_obstacle.PerceptionSLBoundary().start_s() - stop_distance;
   const auto stop_ref_point =
       reference_line_info_->reference_line().GetReferencePoint(stop_ref_s);
   object_stop.mutable_stop_point()->set_x(stop_ref_point.x());

modules/planning/tasks/st_graph/st_boundary_mapper.cc

@@ -106,7 +106,7 @@ Status StBoundaryMapper::GetGraphBoundary(PathDecision* path_decision) const {
     }
     const auto& decision = path_obstacle->LongitudinalDecision();
     if (decision.has_stop()) {
-      const double stop_s = path_obstacle->perception_sl_boundary().start_s() +
+      const double stop_s = path_obstacle->PerceptionSLBoundary().start_s() +
                             decision.stop().distance_s();
       // this is a rough estimation based on reference line s, so that a large
       // buffer is used.
@@ -156,12 +156,12 @@ bool StBoundaryMapper::MapStopDecision(PathObstacle* stop_obstacle) const {
   const auto& stop_decision = stop_obstacle->LongitudinalDecision();
   DCHECK(stop_decision.has_stop()) << "Must have stop decision";
 
-  if (stop_obstacle->perception_sl_boundary().start_s() > planning_distance_) {
+  if (stop_obstacle->PerceptionSLBoundary().start_s() > planning_distance_) {
     return true;
   }
 
   double st_stop_s = 0.0;
-  const double stop_ref_s = stop_obstacle->perception_sl_boundary().start_s() +
+  const double stop_ref_s = stop_obstacle->PerceptionSLBoundary().start_s() +
                             stop_decision.stop().distance_s() -
                             vehicle_param_.front_edge_to_center();
 
@@ -175,7 +175,7 @@ bool StBoundaryMapper::MapStopDecision(PathObstacle* stop_obstacle) const {
       AERROR << "Fail to get path point from reference s. The sl boundary of "
                 "stop obstacle "
              << stop_obstacle->Id() << " is: "
-             << stop_obstacle->perception_sl_boundary().DebugString();
+             << stop_obstacle->PerceptionSLBoundary().DebugString();
       return false;
     }
 
@@ -509,18 +509,18 @@ Status StBoundaryMapper::GetSpeedLimits(
       if (!const_path_obstacle->LateralDecision().has_nudge()) {
         continue;
       }
-      if (path_s < const_path_obstacle->perception_sl_boundary().start_s() ||
-          path_s > const_path_obstacle->perception_sl_boundary().end_s()) {
+      if (path_s < const_path_obstacle->PerceptionSLBoundary().start_s() ||
+          path_s > const_path_obstacle->PerceptionSLBoundary().end_s()) {
         continue;
       }
       constexpr double kRange = 1.0;  // meters
       const auto& nudge = const_path_obstacle->LateralDecision().nudge();
       bool is_close_on_left =
           (nudge.type() == ObjectNudge::LEFT_NUDGE) &&
-          (const_path_obstacle->perception_sl_boundary().end_l() > -kRange);
+          (const_path_obstacle->PerceptionSLBoundary().end_l() > -kRange);
       bool is_close_on_right =
           (nudge.type() == ObjectNudge::RIGHT_NUDGE) &&
-          (const_path_obstacle->perception_sl_boundary().start_l() < kRange);
+          (const_path_obstacle->PerceptionSLBoundary().start_l() < kRange);
       if (is_close_on_left || is_close_on_right) {
         double nudge_speed_ratio = 1.0;
         if (const_path_obstacle->obstacle()->IsStatic()) {

modules/planning/tasks/traffic_decider/backside_vehicle.cc

@@ -36,7 +36,7 @@ void BacksideVehicle::MakeLaneKeepingObstacleDecision(
   const double adc_length_s =
       adc_sl_boundary.end_s() - adc_sl_boundary.start_s();
   for (const auto* path_obstacle : path_decision->path_obstacles().Items()) {
-    if (path_obstacle->perception_sl_boundary().end_s() >=
+    if (path_obstacle->PerceptionSLBoundary().end_s() >=
         adc_sl_boundary.end_s()) {  // don't ignore such vehicles.
       continue;
     }
@@ -55,7 +55,7 @@ void BacksideVehicle::MakeLaneKeepingObstacleDecision(
       continue;
     }
 
-    if (path_obstacle->perception_sl_boundary().start_s() <
+    if (path_obstacle->PerceptionSLBoundary().start_s() <
         adc_sl_boundary.end_s()) {
       path_decision->AddLongitudinalDecision(rule_id, path_obstacle->Id(),
                                              ignore);

modules/planning/tasks/traffic_decider/destination.cc

@@ -44,7 +44,7 @@ bool Destination::ApplyRule(Frame*,
   }
 
   auto stop_point = reference_line_info->reference_line().GetReferencePoint(
-      destination->perception_sl_boundary().start_s() -
+      destination->PerceptionSLBoundary().start_s() -
       FLAGS_stop_distance_destination);
   ObjectDecisionType stop;
   stop.mutable_stop();