planning: use enum type, rather than string to identify rules

modules/planning/common/planning_gflags.cc

@@ -137,7 +137,6 @@ DEFINE_double(stop_max_distance_buffer, 4.0,
 DEFINE_double(stop_min_speed, 0.1, "min speed for computing stop");
 DEFINE_double(stop_max_deceleration, 6.0, "max deceleration");
 /// traffic light
-DEFINE_bool(enable_signal_lights, false, "enable signal_lights");
 DEFINE_string(signal_light_virtual_object_id_prefix, "SL_",
               "prefix for converting signal id to virtual object id");
 DEFINE_double(max_deacceleration_for_yellow_light_stop, 2.0,

modules/planning/common/planning_gflags.h

@@ -102,7 +102,6 @@ DECLARE_double(stop_max_distance_buffer);
 DECLARE_double(stop_min_speed);
 DECLARE_double(stop_max_deceleration);
 /// triffic light
-DECLARE_bool(enable_signal_lights);
 DECLARE_string(signal_light_virtual_object_id_prefix);
 DECLARE_double(max_deacceleration_for_yellow_light_stop);
 /// crosswalk

modules/planning/conf/planning_config.pb.txt

@@ -144,9 +144,5 @@ reference_line_smoother_config {
 }
 
 rule_config : {
-    name: "BacksideVehicle"
-}
-
-rule_config : {
-    name: "SignalLight"
+    rule_id: BACKSIDE_VEHICLE
 }

modules/planning/planning.cc

@@ -82,6 +82,15 @@ Status Planning::InitFrame(const uint32_t sequence_num, const double timestamp,
   return Status::OK();
 }
 
+bool Planning::HasSignalLight(const PlanningConfig& config) {
+  for (const auto& rule_config : config.rule_config()) {
+    if (rule_config.rule_id() == RuleConfig::SIGNAL_LIGHT) {
+      return true;
+    }
+  }
+  return false;
+}
+
 Status Planning::Init() {
   pnc_map_.reset(new hdmap::PncMap(apollo::hdmap::BaseMapFile()));
   Frame::SetMap(pnc_map_.get());
@@ -112,7 +121,7 @@ Status Planning::Init() {
     AERROR << error_msg;
     return Status(ErrorCode::PLANNING_ERROR, error_msg);
   }
-  if (FLAGS_enable_signal_lights &&
+  if (HasSignalLight(config_) &&
       AdapterManager::GetTrafficLightDetection() == nullptr) {
     std::string error_msg("Traffic Light Detection is not registered");
     AERROR << error_msg;

modules/planning/planning.h

@@ -97,6 +97,8 @@ class Planning : public apollo::common::ApolloApp {
 
   void RegisterPlanners();
 
+  bool HasSignalLight(const PlanningConfig& config);
+
   apollo::common::util::Factory<PlanningConfig::PlannerType, Planner>
       planner_factory_;
 

modules/planning/proto/planning_config.proto

@@ -19,7 +19,12 @@ enum TaskType {
 };
 
 message RuleConfig {
-    optional string name = 1;
+    enum RuleId {
+        BACKSIDE_VEHICLE = 1;
+        SIGNAL_LIGHT = 2;
+        CROSSWALK = 3;
+    }
+    optional RuleId rule_id = 1;
 }
 
 message EMPlannerConfig {

modules/planning/tasks/traffic_decider/backside_vehicle.cc

@@ -25,7 +25,8 @@
 namespace apollo {
 namespace planning {
 
-BacksideVehicle::BacksideVehicle() : TrafficRule("BacksideVehicle") {}
+BacksideVehicle::BacksideVehicle(const RuleConfig& config)
+    : TrafficRule(config) {}
 
 bool BacksideVehicle::ApplyRule(Frame* frame,
                                 ReferenceLineInfo* const reference_line_info) {
@@ -33,6 +34,7 @@ bool BacksideVehicle::ApplyRule(Frame* frame,
   const auto& adc_sl_boundary = reference_line_info->AdcSlBoundary();
   ObjectDecisionType ignore;
   ignore.mutable_ignore();
+  const std::string rule_id = RuleConfig::RuleId_Name(config_.rule_id());
   for (const auto* path_obstacle : path_decision->path_obstacles().Items()) {
     if (path_obstacle->perception_sl_boundary().end_s() >=
         adc_sl_boundary.end_s()) {
@@ -40,15 +42,15 @@ bool BacksideVehicle::ApplyRule(Frame* frame,
     }
 
     if (path_obstacle->st_boundary().IsEmpty()) {
-      path_decision->AddLongitudinalDecision(Name(), path_obstacle->Id(),
+      path_decision->AddLongitudinalDecision(rule_id, path_obstacle->Id(),
                                              ignore);
-      path_decision->AddLateralDecision(Name(), path_obstacle->Id(), ignore);
+      path_decision->AddLateralDecision(rule_id, path_obstacle->Id(), ignore);
       continue;
     }
     if (path_obstacle->st_boundary().min_s() < 0) {
-      path_decision->AddLongitudinalDecision(Name(), path_obstacle->Id(),
+      path_decision->AddLongitudinalDecision(rule_id, path_obstacle->Id(),
                                              ignore);
-      path_decision->AddLateralDecision(Name(), path_obstacle->Id(), ignore);
+      path_decision->AddLateralDecision(rule_id, path_obstacle->Id(), ignore);
       continue;
     }
   }

modules/planning/tasks/traffic_decider/backside_vehicle.h

@@ -30,7 +30,7 @@ namespace planning {
 
 class BacksideVehicle : public TrafficRule {
  public:
-  BacksideVehicle();
+  explicit BacksideVehicle(const RuleConfig& config);
   virtual ~BacksideVehicle() = default;
 
   bool ApplyRule(Frame* frame, ReferenceLineInfo* const reference_line_info);

modules/planning/tasks/traffic_decider/crosswalk.cc

@@ -24,10 +24,10 @@
 #include <vector>
 
 #include "modules/common/proto/pnc_point.pb.h"
-#include "modules/perception/proto/perception_obstacle.pb.h"
 
 #include "modules/common/vehicle_state/vehicle_state.h"
 #include "modules/map/hdmap/hdmap_util.h"
+#include "modules/perception/proto/perception_obstacle.pb.h"
 #include "modules/planning/common/frame.h"
 #include "modules/planning/common/planning_gflags.h"
 
@@ -40,7 +40,7 @@ using apollo::common::math::Vec2d;
 using apollo::hdmap::HDMapUtil;
 using apollo::perception::PerceptionObstacle;
 
-Crosswalk::Crosswalk() : TrafficRule("Crosswalk") {}
+Crosswalk::Crosswalk(const RuleConfig& config) : TrafficRule(config) {}
 
 bool Crosswalk::ApplyRule(Frame* frame,
                           ReferenceLineInfo* const reference_line_info) {
@@ -229,7 +229,8 @@ void Crosswalk::CreateStopObstacle(
   auto* path_decision = reference_line_info->path_decision();
   ObjectDecisionType stop;
   stop.mutable_stop();
-  path_decision->AddLongitudinalDecision(Name(), stop_wall->Id(), stop);
+  path_decision->AddLongitudinalDecision(
+      RuleConfig::RuleId_Name(config_.rule_id()), stop_wall->Id(), stop);
 }
 
 }  // namespace planning

modules/planning/tasks/traffic_decider/crosswalk.h

@@ -31,7 +31,7 @@ namespace planning {
 
 class Crosswalk : public TrafficRule {
  public:
-  Crosswalk();
+  explicit Crosswalk(const RuleConfig& config);
   virtual ~Crosswalk() = default;
 
   bool ApplyRule(Frame* frame, ReferenceLineInfo* const reference_line_info);

modules/planning/tasks/traffic_decider/signal_light.cc

@@ -38,15 +38,10 @@ using apollo::common::adapter::AdapterManager;
 using apollo::perception::TrafficLight;
 using apollo::perception::TrafficLightDetection;
 
-SignalLight::SignalLight() : TrafficRule("SignalLight") {}
+SignalLight::SignalLight(const RuleConfig& config) : TrafficRule(config) {}
 
 bool SignalLight::ApplyRule(Frame* frame,
                             ReferenceLineInfo* const reference_line_info) {
-  if (!FLAGS_enable_signal_lights) {
-    return true;
-  }
-  Init();
-
   if (!FindValidSignalLight(reference_line_info)) {
     return true;
   }
@@ -55,11 +50,6 @@ bool SignalLight::ApplyRule(Frame* frame,
   return true;
 }
 
-void SignalLight::Init() {
-  signals_.clear();
-  signal_lights_.clear();
-}
-
 void SignalLight::ReadSignals() {
   if (AdapterManager::GetTrafficLightDetection()->Empty()) {
     return;
@@ -165,14 +155,15 @@ void SignalLight::CreateStopObstacle(
   sl_point.set_s(signal_light->start_s);
   sl_point.set_l(0);
   common::math::Vec2d vec2d;
-  reference_line_info->reference_line().SLToXY(sl_point, &vec2d);
-  double heading = reference_line_info->reference_line()
-                       .GetReferencePoint(signal_light->start_s)
-                       .heading();
-  double left_lane_width;
-  double right_lane_width;
-  reference_line_info->reference_line().GetLaneWidth(
-      signal_light->start_s, &left_lane_width, &right_lane_width);
+  const auto& reference_line = reference_line_info->reference_line();
+  reference_line.SLToXY(sl_point, &vec2d);
+
+  double heading =
+      reference_line.GetReferencePoint(signal_light->start_s).heading();
+  double left_lane_width = 0.0;
+  double right_lane_width = 0.0;
+  reference_line.GetLaneWidth(signal_light->start_s, &left_lane_width,
+                              &right_lane_width);
 
   common::math::Box2d stop_box{{vec2d.x(), vec2d.y()},
                                heading,
@@ -186,7 +177,8 @@ void SignalLight::CreateStopObstacle(
   auto* path_decision = reference_line_info->path_decision();
   ObjectDecisionType stop;
   stop.mutable_stop();
-  path_decision->AddLongitudinalDecision(Name(), stop_wall->Id(), stop);
+  path_decision->AddLongitudinalDecision(
+      RuleConfig::RuleId_Name(config_.rule_id()), stop_wall->Id(), stop);
 }
 
 }  // namespace planning

modules/planning/tasks/traffic_decider/signal_light.h

@@ -34,13 +34,13 @@ namespace planning {
 
 class SignalLight : public TrafficRule {
  public:
-  SignalLight();
+  explicit SignalLight(const RuleConfig& config);
+
   virtual ~SignalLight() = default;
 
   bool ApplyRule(Frame* frame, ReferenceLineInfo* const reference_line_info);
 
  private:
-  void Init();
   void ReadSignals();
   bool FindValidSignalLight(ReferenceLineInfo* const reference_line_info);
   const apollo::perception::TrafficLight GetSignal(

modules/planning/tasks/traffic_decider/traffic_decider.cc

@@ -34,15 +34,20 @@ using common::VehicleConfigHelper;
 TrafficDecider::TrafficDecider() : Task("TrafficDecider") {}
 
 void TrafficDecider::RegisterRules() {
-  rule_factory_.Register("BacksideVehicle", []() -> TrafficRule * {
-    return new BacksideVehicle();
-  });
+  rule_factory_.Register(RuleConfig::BACKSIDE_VEHICLE,
+                         [](const RuleConfig &config) -> TrafficRule * {
+                           return new BacksideVehicle(config);
+                         });
 
-  rule_factory_.Register("SignalLight",
-                         []() -> TrafficRule * { return new SignalLight(); });
+  rule_factory_.Register(RuleConfig::SIGNAL_LIGHT,
+                         [](const RuleConfig &config) -> TrafficRule * {
+                           return new SignalLight(config);
+                         });
 
-  rule_factory_.Register("Crosswalk",
-                         []() -> TrafficRule * { return new Crosswalk(); });
+  rule_factory_.Register(RuleConfig::CROSSWALK,
+                         [](const RuleConfig &config) -> TrafficRule * {
+                           return new Crosswalk(config);
+                         });
 }
 
 bool TrafficDecider::Init(const PlanningConfig &config) {
@@ -56,14 +61,14 @@ Status TrafficDecider::Execute(Frame *frame,
                                ReferenceLineInfo *reference_line_info) {
   Task::Execute(frame, reference_line_info);
 
-  for (const auto rule_config : rule_configs_) {
-    auto rule = rule_factory_.CreateObject(rule_config.name());
+  for (const auto &rule_config : rule_configs_) {
+    auto rule = rule_factory_.CreateObject(rule_config.rule_id(), rule_config);
     if (!rule) {
       AERROR << "Could not find rule " << rule_config.DebugString();
       continue;
     }
     rule->ApplyRule(frame, reference_line_info);
-    ADEBUG << "Applied rule " << rule_config.name();
+    ADEBUG << "Applied rule " << RuleConfig::RuleId_Name(rule_config.rule_id());
   }
   return Status::OK();
 }

modules/planning/tasks/traffic_decider/traffic_decider.h

@@ -56,7 +56,9 @@ class TrafficDecider : public Task {
  private:
   void RegisterRules();
 
-  apollo::common::util::Factory<std::string, TrafficRule> rule_factory_;
+  apollo::common::util::Factory<RuleConfig::RuleId, TrafficRule,
+                                TrafficRule *(*)(const RuleConfig &config)>
+      rule_factory_;
   google::protobuf::RepeatedPtrField<RuleConfig> rule_configs_;
 };
 

modules/planning/tasks/traffic_decider/traffic_rule.h

@@ -31,14 +31,14 @@ namespace planning {
 
 class TrafficRule {
  public:
-  explicit TrafficRule(const std::string& name) : name_(name) {}
+  explicit TrafficRule(const RuleConfig& config) : config_(config) {}
   virtual ~TrafficRule() = default;
-  virtual const std::string& Name() const { return name_; }
+  virtual RuleConfig::RuleId Id() const { return config_.rule_id(); }
   virtual bool ApplyRule(Frame* frame,
                          ReferenceLineInfo* const reference_line_info) = 0;
 
- private:
-  const std::string name_;
+ protected:
+  RuleConfig config_;
 };
 
 }  // namespace planning