apollo::planning::StopSignUnprotectedStageStop类 参考

#include <stage_stop.h>

类 apollo::planning::StopSignUnprotectedStageStop 继承关系图:

apollo::planning::StopSignUnprotectedStageStop 的协作图:

Public 成员函数
StageResult	Process (const common::TrajectoryPoint &planning_init_point, Frame *frame) override
	Each stage does its business logic inside Process function.
Public 成员函数 继承自 apollo::planning::Stage
	Stage ()
virtual bool	Init (const StagePipeline &config, const std::shared_ptr< DependencyInjector > &injector, const std::string &config_dir, void *context)
virtual	~Stage ()=default
const std::string &	Name () const
template<typename T >
T *	GetContextAs () const
const std::string &	NextStage () const

额外继承的成员函数
Protected 成员函数 继承自 apollo::planning::Stage
StageResult	ExecuteTaskOnReferenceLine (const common::TrajectoryPoint &planning_start_point, Frame *frame)
StageResult	ExecuteTaskOnReferenceLineForOnlineLearning (const common::TrajectoryPoint &planning_start_point, Frame *frame)
StageResult	ExecuteTaskOnOpenSpace (Frame *frame)
virtual StageResult	FinishScenario ()
void	RecordDebugInfo (ReferenceLineInfo *reference_line_info, const std::string &name, const double time_diff_ms)
Protected 属性 继承自 apollo::planning::Stage
std::vector< std::shared_ptr< Task > >	task_list_
std::shared_ptr< Task >	fallback_task_
std::string	next_stage_
void *	context_
std::shared_ptr< DependencyInjector >	injector_
StagePipeline	pipeline_config_

详细描述

在文件 stage_stop.h 第 33 行定义.

成员函数说明

Process()

StageResult apollo::planning::StopSignUnprotectedStageStop::Process ( const common::TrajectoryPoint &  planning_init_point, Frame *  frame  )

overridevirtual

Each stage does its business logic inside Process function.

If the stage want to transit to a different stage after finish, it should set the type of 'next_stage_'.

实现了 apollo::planning::Stage.

在文件 stage_stop.cc 第 50 行定义.

                                                              {
  ADEBUG << "stage: Stop";
  CHECK_NOTNULL(frame);
  CHECK_NOTNULL(context_);
 
  auto context = GetContextAs<StopSignUnprotectedContext>();
  const ScenarioStopSignUnprotectedConfig& scenario_config =
      context->scenario_config;
 
  StageResult result = ExecuteTaskOnReferenceLine(planning_init_point, frame);
  if (result.HasError()) {
    AERROR << "StopSignUnprotectedPreStop planning error";
  }
 
  const auto& reference_line_info = frame->reference_line_info().front();
  std::string stop_sign_overlap_id = context->current_stop_sign_overlap_id;
 
  // refresh overlap along reference line
  PathOverlap* current_stop_sign_overlap =
      reference_line_info.GetOverlapOnReferenceLine(
          stop_sign_overlap_id, ReferenceLineInfo::STOP_SIGN);
  if (!current_stop_sign_overlap) {
    return FinishScenario();
  }
 
  // set right_of_way_status
  const double stop_sign_start_s = current_stop_sign_overlap->start_s;
  reference_line_info.SetJunctionRightOfWay(stop_sign_start_s, false);
 
  static constexpr double kPassStopLineBuffer = 1.0;  // unit: m
  const double adc_front_edge_s = reference_line_info.AdcSlBoundary().end_s();
  const double distance_adc_pass_stop_sign =
      adc_front_edge_s - stop_sign_start_s;
  // passed stop line too far
  if (distance_adc_pass_stop_sign > kPassStopLineBuffer) {
    return FinishStage();
  }
 
  // check on wait-time
  auto start_time = context->stop_start_time;
  const double wait_time = Clock::NowInSeconds() - start_time;
  ADEBUG << "stop_start_time[" << start_time << "] wait_time[" << wait_time
         << "]";
  if (wait_time < scenario_config.stop_duration_sec()) {
    return result.SetStageStatus(StageStatusType::RUNNING);
  }
 
  // check on watch_vehicles
  auto& watch_vehicles = context->watch_vehicles;
  if (watch_vehicles.empty()) {
    return FinishStage();
  }
 
  // get all vehicles currently watched
  std::vector<std::string> watch_vehicle_ids;
  for (const auto& watch_vehicle : watch_vehicles) {
    std::copy(watch_vehicle.second.begin(), watch_vehicle.second.end(),
              std::back_inserter(watch_vehicle_ids));
    // for debug
    std::string s;
    for (const std::string& vehicle : watch_vehicle.second) {
      s = s.empty() ? vehicle : s + "," + vehicle;
    }
    const std::string& associated_lane_id = watch_vehicle.first;
    ADEBUG << "watch_vehicles: lane_id[" << associated_lane_id << "] vehicle["
           << s << "]";
  }
 
  // remove duplicates (caused when same vehicle on mutiple lanes)
  watch_vehicle_ids.erase(
      unique(watch_vehicle_ids.begin(), watch_vehicle_ids.end()),
      watch_vehicle_ids.end());
 
  if (watch_vehicle_ids.empty()) {
    return FinishStage();
  }
 
  // pass vehicles being watched to DECIDER_RULE_BASED_STOP task
  // for visualization
  for (const auto& perception_obstacle_id : watch_vehicle_ids) {
    injector_->planning_context()
        ->mutable_planning_status()
        ->mutable_stop_sign()
        ->add_wait_for_obstacle_id(perception_obstacle_id);
  }
 
  // check timeout while waiting for only one vehicle
  if (wait_time > scenario_config.stop_timeout_sec() &&
      watch_vehicle_ids.size() <= 1) {
    return FinishStage();
  }
 
  const PathDecision& path_decision = reference_line_info.path_decision();
  RemoveWatchVehicle(path_decision, &watch_vehicles);
 
  return result.SetStageStatus(StageStatusType::RUNNING);
}

---

该类的文档由以下文件生成:

• modules/planning/scenarios/stop_sign_unprotected/stage_stop.h
• modules/planning/scenarios/stop_sign_unprotected/stage_stop.cc