apollo::planning::Stage类 参考

#include <stage.h>

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

apollo::planning::Stage 的协作图:

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

Protected 成员函数
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 属性
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.h 第 46 行定义.

构造及析构函数说明

Stage()

apollo::planning::Stage::Stage

(

)

在文件 stage.cc 第 40 行定义.

    : next_stage_(""), context_(nullptr), injector_(nullptr), name_("") {}

~Stage()

virtual apollo::planning::Stage::~Stage ( )

virtualdefault

成员函数说明

ExecuteTaskOnOpenSpace()

StageResult apollo::planning::Stage::ExecuteTaskOnOpenSpace ( Frame *  frame )

protected

在文件 stage.cc 第 206 行定义.

                                                      {
  auto ret = common::Status::OK();
  StageResult stage_result;
  for (auto task : task_list_) {
    const double start_timestamp = Clock::NowInSeconds();
 
    ret = task->Execute(frame);
 
    if (!ret.ok()) {
      stage_result.SetTaskStatus(ret);
      AERROR << "Failed to run tasks[" << task->Name()
             << "], Error message: " << ret.error_message();
      const double end_timestamp = Clock::NowInSeconds();
      const double time_diff_ms = (end_timestamp - start_timestamp) * 1000;
      AINFO << "Planning Perf: task name [" << task->Name() << "], "
            << time_diff_ms << " ms.";
      return stage_result;
    }
 
    const double end_timestamp = Clock::NowInSeconds();
    const double time_diff_ms = (end_timestamp - start_timestamp) * 1000;
    AINFO << "Planning Perf: task name [" << task->Name() << "], "
          << time_diff_ms << " ms.";
  }
 
  if (frame->open_space_info().fallback_flag() ||
      frame->open_space_info().stop_flag()) {
    auto& trajectory = frame->open_space_info().fallback_trajectory().first;
    auto& gear = frame->open_space_info().fallback_trajectory().second;
    PublishableTrajectory publishable_trajectory(Clock::NowInSeconds(),
                                                 trajectory);
    auto publishable_traj_and_gear =
        std::make_pair(std::move(publishable_trajectory), gear);
 
    *(frame->mutable_open_space_info()->mutable_publishable_trajectory_data()) =
        std::move(publishable_traj_and_gear);
  } else {
    auto& trajectory =
        frame->open_space_info().chosen_partitioned_trajectory().first;
    auto& gear =
        frame->open_space_info().chosen_partitioned_trajectory().second;
    PublishableTrajectory publishable_trajectory(Clock::NowInSeconds(),
                                                 trajectory);
    auto publishable_traj_and_gear =
        std::make_pair(std::move(publishable_trajectory), gear);
 
    *(frame->mutable_open_space_info()->mutable_publishable_trajectory_data()) =
        std::move(publishable_traj_and_gear);
  }
  return stage_result;
}

ExecuteTaskOnReferenceLine()

StageResult apollo::planning::Stage::ExecuteTaskOnReferenceLine ( const common::TrajectoryPoint &  planning_start_point, Frame *  frame  )

protected

在文件 stage.cc 第 101 行定义.

                                                                     {
  StageResult stage_result;
  if (frame->reference_line_info().empty()) {
    AERROR << "referenceline is empty in stage" << name_;
    return stage_result.SetStageStatus(StageStatusType::ERROR);
  }
  for (auto& reference_line_info : *frame->mutable_reference_line_info()) {
    if (!reference_line_info.IsDrivable()) {
      AERROR << "The generated path is not drivable skip";
      reference_line_info.SetDrivable(false);
      continue;
    }
 
    if (reference_line_info.IsChangeLanePath()) {
      AERROR << "The generated refline is change lane path, skip";
      reference_line_info.SetDrivable(false);
      continue;
    }
    common::Status ret = common::Status::OK();
    for (auto task : task_list_) {
      const double start_timestamp = Clock::NowInSeconds();
 
      ret = task->Execute(frame, &reference_line_info);
 
      const double end_timestamp = Clock::NowInSeconds();
      const double time_diff_ms = (end_timestamp - start_timestamp) * 1000;
      ADEBUG << "after task[" << task->Name()
             << "]: " << reference_line_info.PathSpeedDebugString();
      ADEBUG << task->Name() << " time spend: " << time_diff_ms << " ms.";
      AINFO << "Planning Perf: task name [" << task->Name() << "], "
            << time_diff_ms << " ms.";
      RecordDebugInfo(&reference_line_info, task->Name(), time_diff_ms);
 
      if (!ret.ok()) {
        stage_result.SetTaskStatus(ret);
        AERROR << "Failed to run tasks[" << task->Name()
               << "], Error message: " << ret.error_message();
        break;
      }
    }
    // Generate fallback trajectory in case of task error.
    if (!ret.ok()) {
      fallback_task_->Execute(frame, &reference_line_info);
    }
    DiscretizedTrajectory trajectory;
    if (!reference_line_info.CombinePathAndSpeedProfile(
            planning_start_point.relative_time(),
            planning_start_point.path_point().s(), &trajectory)) {
      AERROR << "Fail to aggregate planning trajectory."
             << reference_line_info.IsChangeLanePath();
      reference_line_info.SetDrivable(false);
      continue;
    }
    reference_line_info.SetTrajectory(trajectory);
    reference_line_info.SetDrivable(true);
    return stage_result;
  }
  return stage_result;
}

ExecuteTaskOnReferenceLineForOnlineLearning()

StageResult apollo::planning::Stage::ExecuteTaskOnReferenceLineForOnlineLearning ( const common::TrajectoryPoint &  planning_start_point, Frame *  frame  )

protected

在文件 stage.cc 第 162 行定义.

                                                                     {
  // online learning mode
  for (auto& reference_line_info : *frame->mutable_reference_line_info()) {
    reference_line_info.SetDrivable(false);
  }
 
  StageResult stage_result;
  // FIXME(all): current only pick up the first reference line to use
  // learning model trajectory
  auto& picked_reference_line_info =
      frame->mutable_reference_line_info()->front();
  for (auto task : task_list_) {
    const double start_timestamp = Clock::NowInSeconds();
 
    const auto ret = task->Execute(frame, &picked_reference_line_info);
 
    const double end_timestamp = Clock::NowInSeconds();
    const double time_diff_ms = (end_timestamp - start_timestamp) * 1000;
    ADEBUG << "task[" << task->Name() << "] time spent: " << time_diff_ms
           << " ms.";
    RecordDebugInfo(&picked_reference_line_info, task->Name(), time_diff_ms);
 
    if (!ret.ok()) {
      stage_result.SetTaskStatus(ret);
      AERROR << "Failed to run tasks[" << task->Name()
             << "], Error message: " << ret.error_message();
      break;
    }
  }
 
  const std::vector<common::TrajectoryPoint>& adc_future_trajectory_points =
      picked_reference_line_info.trajectory();
  DiscretizedTrajectory trajectory;
  if (picked_reference_line_info.AdjustTrajectoryWhichStartsFromCurrentPos(
          planning_start_point, adc_future_trajectory_points, &trajectory)) {
    picked_reference_line_info.SetTrajectory(trajectory);
    picked_reference_line_info.SetDrivable(true);
    picked_reference_line_info.SetCost(0);
  }
 
  return stage_result;
}

FinishScenario()

StageResult apollo::planning::Stage::FinishScenario ( )

protectedvirtual

在文件 stage.cc 第 258 行定义.

                                  {
  next_stage_ = "";
  return StageResult(StageStatusType::FINISHED);
}

GetContextAs()

template<typename T >

T * apollo::planning::Stage::GetContextAs ( ) const

inline

在文件 stage.h 第 67 行定义.

                          {
    return static_cast<T*>(context_);
  }

Init()

bool apollo::planning::Stage::Init ( const StagePipeline &  config, const std::shared_ptr< DependencyInjector > &  injector, const std::string &  config_dir, void *  context  )

virtual

被 apollo::planning::StageApproachingParkingSpot, apollo::planning::StopSignUnprotectedStageCreep, apollo::planning::TrafficLightUnprotectedLeftTurnStageCreep, apollo::planning::TrafficLightUnprotectedRightTurnStageCreep , 以及 apollo::planning::YieldSignStageCreep 重载.

在文件 stage.cc 第 43 行定义.

                                                             {
  pipeline_config_ = config;
  next_stage_ = config.name();
  injector_ = injector;
  name_ = config.name();
  context_ = context;
  injector_->planning_context()
      ->mutable_planning_status()
      ->mutable_scenario()
      ->set_stage_type(name_);
  std::string path_name = ConfigUtil::TransformToPathName(name_);
  std::string task_config_dir = config_dir + "/" + path_name;
  // Load task plugin.
  for (int i = 0; i < pipeline_config_.task_size(); ++i) {
    auto task = pipeline_config_.task(i);
    auto task_type = task.type();
    auto task_ptr = apollo::cyber::plugin_manager::PluginManager::Instance()
                        ->CreateInstance<Task>(
                            ConfigUtil::GetFullPlanningClassName(task_type));
    if (nullptr == task_ptr) {
      AERROR << "Create task " << task.name() << " of " << name_ << " failed!";
      return false;
    }
    if (task_ptr->Init(task_config_dir, task.name(), injector)) {
      task_list_.push_back(task_ptr);
    } else {
      AERROR << task.name() << " init failed!";
      return false;
    }
  }
  // Load trajectory fallback task.
  // If fallback task is not set, use "FastStopTrajectoryFallback" as default.
  std::string fallback_task_type = "FastStopTrajectoryFallback";
  std::string fallback_task_name = "FAST_STOP_TRAJECTORY_FALLBACK";
  if (pipeline_config_.has_fallback_task()) {
    fallback_task_type = pipeline_config_.fallback_task().type();
    fallback_task_name = pipeline_config_.fallback_task().name();
  }
  fallback_task_ =
      apollo::cyber::plugin_manager::PluginManager::Instance()
          ->CreateInstance<Task>(
              ConfigUtil::GetFullPlanningClassName(fallback_task_type));
  if (nullptr == fallback_task_) {
    AERROR << "Create fallback task " << fallback_task_name << " of " << name_
           << " failed!";
    return false;
  }
  if (!fallback_task_->Init(task_config_dir, fallback_task_name, injector)) {
    AERROR << fallback_task_name << " init failed!";
    return false;
  }
  return true;
}

Name()

const std::string & apollo::planning::Stage::Name

(

)

const

在文件 stage.cc 第 99 行定义.

{ return name_; }

NextStage()

const std::string & apollo::planning::Stage::NextStage ( ) const

inline

在文件 stage.h 第 71 行定义.

{ return next_stage_; }

Process()

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

pure virtual

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::BareIntersectionUnprotectedStageApproach, apollo::planning::BareIntersectionUnprotectedStageIntersectionCruise, apollo::planning::EmergencyPullOverStageApproach, apollo::planning::EmergencyPullOverStageSlowDown, apollo::planning::EmergencyPullOverStageStandby, apollo::planning::EmergencyStopStageApproach, apollo::planning::EmergencyStopStageStandby, apollo::planning::LaneFollowStage, apollo::planning::ParkAndGoStageAdjust, apollo::planning::ParkAndGoStageCheck, apollo::planning::ParkAndGoStageCruise, apollo::planning::ParkAndGoStagePreCruise, apollo::planning::PullOverStageApproach, apollo::planning::PullOverStageRetryApproachParking, apollo::planning::PullOverStageRetryParking, apollo::planning::StopSignUnprotectedStageCreep, apollo::planning::StopSignUnprotectedStageIntersectionCruise, apollo::planning::StopSignUnprotectedStagePreStop, apollo::planning::StopSignUnprotectedStageStop, apollo::planning::TrafficLightProtectedStageApproach, apollo::planning::TrafficLightProtectedStageIntersectionCruise, apollo::planning::TrafficLightUnprotectedLeftTurnStageApproach, apollo::planning::TrafficLightUnprotectedLeftTurnStageCreep, apollo::planning::TrafficLightUnprotectedLeftTurnStageIntersectionCruise, apollo::planning::TrafficLightUnprotectedRightTurnStageCreep, apollo::planning::TrafficLightUnprotectedRightTurnStageIntersectionCruise, apollo::planning::TrafficLightUnprotectedRightTurnStageStop, apollo::planning::StageApproachingParkingSpot, apollo::planning::StageParking, apollo::planning::YieldSignStageApproach , 以及 apollo::planning::YieldSignStageCreep 内被实现.

RecordDebugInfo()

void apollo::planning::Stage::RecordDebugInfo ( ReferenceLineInfo *  reference_line_info, const std::string &  name, const double  time_diff_ms  )

protected

在文件 stage.cc 第 263 行定义.

                                                       {
  if (!FLAGS_enable_record_debug) {
    ADEBUG << "Skip record debug info";
    return;
  }
  if (reference_line_info == nullptr) {
    AERROR << "Reference line info is null.";
    return;
  }
 
  auto ptr_latency_stats = reference_line_info->mutable_latency_stats();
 
  auto ptr_stats = ptr_latency_stats->add_task_stats();
  ptr_stats->set_name(name);
  ptr_stats->set_time_ms(time_diff_ms);
}

类成员变量说明

context_

void* apollo::planning::Stage::context_

protected

在文件 stage.h 第 90 行定义.

fallback_task_

std::shared_ptr<Task> apollo::planning::Stage::fallback_task_

protected

在文件 stage.h 第 88 行定义.

injector_

std::shared_ptr<DependencyInjector> apollo::planning::Stage::injector_

protected

在文件 stage.h 第 91 行定义.

next_stage_

std::string apollo::planning::Stage::next_stage_

protected

在文件 stage.h 第 89 行定义.

pipeline_config_

StagePipeline apollo::planning::Stage::pipeline_config_

protected

在文件 stage.h 第 92 行定义.

task_list_

std::vector<std::shared_ptr<Task> > apollo::planning::Stage::task_list_

protected

在文件 stage.h 第 87 行定义.

---

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

• modules/planning/planning_interface_base/scenario_base/stage.h
• modules/planning/planning_interface_base/scenario_base/stage.cc