#include <stage_creep.h>

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

apollo::planning::TrafficLightUnprotectedRightTurnStageCreep 的协作图:

Public 成员函数
bool	Init (const StagePipeline &config, const std::shared_ptr< DependencyInjector > &injector, const std::string &config_dir, void *context) override

StageResult	Process (const common::TrajectoryPoint &planning_init_point, Frame *frame) override
	Each stage does its business logic inside Process function.

Public 成员函数继承自 apollo::planning::BaseStageCreep
common::Status	ProcessCreep (Frame frame, ReferenceLineInfo reference_line_info) const

bool	CheckCreepDone (const Frame &frame, const ReferenceLineInfo &reference_line_info, const double stop_sign_overlap_end_s, const double wait_time_sec, const double timeout_sec)

double	GetCreepFinishS (double overlap_end_s, const Frame &frame, const ReferenceLineInfo &reference_line_info) const
	Get the postion where creeping stage finishes.

Public 成员函数继承自 apollo::planning::Stage
	Stage ()

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_creep.h 第 34 行定义.

成员函数说明

◆ Init()

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

overridevirtual

重载 apollo::planning::Stage .

在文件 stage_creep.cc 第 44 行定义.

                                                {
  CHECK_NOTNULL(context);
  bool ret = Stage::Init(config, injector, config_dir, context);
  if (!ret) {
    AERROR << Name() << "init failed!";
    return false;
  }
  return ret;
}

◆ Process()

StageResult apollo::planning::TrafficLightUnprotectedRightTurnStageCreep::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_creep.cc 第 57 行定义.

                                                              {
  ADEBUG << "stage: Creep";
  CHECK_NOTNULL(frame);
  CHECK_NOTNULL(context_);
 
  auto context = GetContextAs<TrafficLightUnprotectedRightTurnContext>();
  const ScenarioTrafficLightUnprotectedRightTurnConfig& scenario_config =
      context->scenario_config;
 
  if (!pipeline_config_.enabled()) {
    return FinishStage();
  }
 
  // Run creep decider.
  for (auto& reference_line_info : *frame->mutable_reference_line_info()) {
    if (!reference_line_info.IsDrivable()) {
      AERROR << "The generated path is not drivable";
      break;
    }
 
    const auto ret = ProcessCreep(frame, &reference_line_info);
    if (!ret.ok()) {
      AERROR << "Failed to run CreepDecider ], Error message: "
             << ret.error_message();
      break;
    }
  }
 
  StageResult result = ExecuteTaskOnReferenceLine(planning_init_point, frame);
  if (result.HasError()) {
    AERROR << "TrafficLightUnprotectedRightTurnStageCreep planning error";
  }
 
  if (context->current_traffic_light_overlap_ids.empty()) {
    return FinishScenario();
  }
 
  const auto& reference_line_info = frame->reference_line_info().front();
  const std::string traffic_light_overlap_id =
      context->current_traffic_light_overlap_ids[0];
  PathOverlap* current_traffic_light_overlap =
      reference_line_info.GetOverlapOnReferenceLine(traffic_light_overlap_id,
                                                    ReferenceLineInfo::SIGNAL);
  if (!current_traffic_light_overlap) {
    return FinishScenario();
  }
 
  // set right_of_way_status
  reference_line_info.SetJunctionRightOfWay(
      current_traffic_light_overlap->start_s, false);
 
  // creep
  // note: don't check traffic light color while creeping on right turn
  const double wait_time = Clock::NowInSeconds() - context->creep_start_time;
  const double timeout_sec = scenario_config.creep_timeout_sec();
 
  double creep_stop_s = GetCreepFinishS(current_traffic_light_overlap->end_s,
                                        *frame, reference_line_info);
  const double distance =
      creep_stop_s - reference_line_info.AdcSlBoundary().end_s();
  if (distance <= 0.0) {
    auto& rfl_info = frame->mutable_reference_line_info()->front();
    *(rfl_info.mutable_speed_data()) =
        SpeedProfileGenerator::GenerateFixedDistanceCreepProfile(0.0, 0);
  }
 
  if (CheckCreepDone(*frame, reference_line_info,
                     current_traffic_light_overlap->end_s, wait_time,
                     timeout_sec)) {
    return FinishStage();
  }
 
  return result.SetStageStatus(StageStatusType::RUNNING);
}

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

modules/planning/scenarios/traffic_light_unprotected_right_turn/stage_creep.h
modules/planning/scenarios/traffic_light_unprotected_right_turn/stage_creep.cc

Public 成员函数

额外继承的成员函数

详细描述

成员函数说明

◆ Init()

◆ Process()