#include <stage_stop.h>

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

apollo::planning::TrafficLightUnprotectedRightTurnStageStop 的协作图:

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::TrafficLightUnprotectedRightTurnStageStop::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 第 41 行定义.

                                                              {
  ADEBUG << "stage: Stop";
  CHECK_NOTNULL(frame);
  CHECK_NOTNULL(context_);
 
  auto context = GetContextAs<TrafficLightUnprotectedRightTurnContext>();
  const auto& scenario_config = context->scenario_config;
 
  StageResult result = ExecuteTaskOnReferenceLine(planning_init_point, frame);
  if (result.HasError()) {
    AERROR << "TrafficLightRightTurnUnprotectedStop planning error";
  }
 
  if (context->current_traffic_light_overlap_ids.empty()) {
    return FinishScenario();
  }
 
  const auto& reference_line_info = frame->reference_line_info().front();
  const double adc_front_edge_s = reference_line_info.AdcSlBoundary().end_s();
 
  bool traffic_light_all_stop = true;
  bool traffic_light_all_green = true;
  bool traffic_light_no_right_turn_on_red = false;
  PathOverlap* current_traffic_light_overlap = nullptr;
 
  for (const auto& traffic_light_overlap_id :
       context->current_traffic_light_overlap_ids) {
    // get overlap along reference line
    current_traffic_light_overlap =
        reference_line_info.GetOverlapOnReferenceLine(
            traffic_light_overlap_id, ReferenceLineInfo::SIGNAL);
    if (!current_traffic_light_overlap) {
      continue;
    }
 
    // set right_of_way_status
    reference_line_info.SetJunctionRightOfWay(
        current_traffic_light_overlap->start_s, false);
 
    const double distance_adc_to_stop_line =
        current_traffic_light_overlap->start_s - adc_front_edge_s;
    auto signal_color = frame->GetSignal(traffic_light_overlap_id).color();
    ADEBUG << "traffic_light_overlap_id[" << traffic_light_overlap_id
           << "] start_s[" << current_traffic_light_overlap->start_s
           << "] distance_adc_to_stop_line[" << distance_adc_to_stop_line
           << "] color[" << signal_color << "]";
 
    // check distance to stop line
    if (distance_adc_to_stop_line > scenario_config.max_valid_stop_distance()) {
      traffic_light_all_stop = false;
      break;
    }
 
    // check on traffic light color
    if (signal_color != TrafficLight::GREEN) {
      traffic_light_all_green = false;
      traffic_light_no_right_turn_on_red =
          CheckTrafficLightNoRightTurnOnRed(traffic_light_overlap_id);
      break;
    }
  }
 
  if (traffic_light_all_stop && traffic_light_all_green) {
    return FinishStage(true);
  }
 
  if (traffic_light_no_right_turn_on_red) {
    if (traffic_light_all_stop && !traffic_light_all_green) {
      // check distance pass stop line
      const double distance_adc_pass_stop_line =
          adc_front_edge_s - current_traffic_light_overlap->end_s;
      ADEBUG << "distance_adc_pass_stop_line[" << distance_adc_pass_stop_line
             << "]";
      if (distance_adc_pass_stop_line > scenario_config.min_pass_s_distance()) {
        return FinishStage(false);
      }
 
      if (scenario_config.enable_right_turn_on_red()) {
        // when right_turn_on_red is enabled
        // check on wait-time
        if (context->stop_start_time == 0.0) {
          context->stop_start_time = Clock::NowInSeconds();
        } else {
          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.red_light_right_turn_stop_duration_sec()) {
            return FinishStage(false);
          }
        }
      }
    }
  } else {
    return FinishStage(false);
  }
 
  return result.SetStageStatus(StageStatusType::RUNNING);
}

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

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

Public 成员函数

额外继承的成员函数

详细描述

成员函数说明

◆ Process()