#include <traffic_light_unprotected_right_turn_scenario.h>

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

apollo::planning::TrafficLightUnprotectedRightTurnScenario 的协作图:

Public 成员函数
bool	Init (std::shared_ptr< DependencyInjector > injector, const std::string &name) override

TrafficLightUnprotectedRightTurnContext *	GetContext () override
	Get the scenario context.

bool	IsTransferable (const Scenario *const other_scenario, const Frame &frame) override
	Each scenario should define its own transfer condition, i.e., when it should allow to transfer from other scenario to itself.

bool	Exit (Frame *frame) override

bool	Enter (Frame *frame) override

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

virtual	~Scenario ()=default

virtual ScenarioResult	Process (const common::TrajectoryPoint &planning_init_point, Frame *frame)

std::shared_ptr< Stage >	CreateStage (const StagePipeline &stage_pipeline)
	Each scenario should define its own stages object's creation scenario will call stage's Stage::Process function following a configured order, The return value of Stage::Process function determines the transition from one stage to another.

const ScenarioStatusType &	GetStatus () const

const std::string	GetStage () const

const std::string &	GetMsg () const

const std::string &	Name () const

void	Reset ()
	Reset the scenario, used before entering the scenario.

额外继承的成员函数
Protected 成员函数继承自 apollo::planning::Scenario
template<typename T >
bool	LoadConfig (T *config)

Protected 属性继承自 apollo::planning::Scenario
ScenarioResult	scenario_result_

std::shared_ptr< Stage >	current_stage_

std::unordered_map< std::string, const StagePipeline * >	stage_pipeline_map_

std::string	msg_

std::shared_ptr< DependencyInjector >	injector_

std::string	config_path_

std::string	config_dir_

std::string	name_

ScenarioPipeline	scenario_pipeline_config_

详细描述

在文件 traffic_light_unprotected_right_turn_scenario.h 第 34 行定义.

成员函数说明

◆ Enter()

bool apollo::planning::TrafficLightUnprotectedRightTurnScenario::Enter ( Frame * frame )

overridevirtual

重载 apollo::planning::Scenario .

在文件 traffic_light_unprotected_right_turn_scenario.cc 第 146 行定义.

                                                                 {
  const auto& reference_line_info = frame->reference_line_info().front();
  std::string current_traffic_light_overlap_id;
  const auto& overlaps = reference_line_info.FirstEncounteredOverlaps();
  for (auto overlap : overlaps) {
    if (overlap.first == ReferenceLineInfo::SIGNAL) {
      current_traffic_light_overlap_id = overlap.second.object_id;
      break;
    }
  }
 
  if (current_traffic_light_overlap_id.empty()) {
    injector_->planning_context()
        ->mutable_planning_status()
        ->mutable_traffic_light()
        ->Clear();
    AERROR << "Can not find traffic light overlap in reference line!";
    return false;
  }
 
  // find all the traffic light at/within the same location/group
  const std::vector<apollo::hdmap::PathOverlap>& traffic_light_overlaps =
      reference_line_info.reference_line().map_path().signal_overlaps();
  auto traffic_light_overlap_itr = std::find_if(
      traffic_light_overlaps.begin(), traffic_light_overlaps.end(),
      [&current_traffic_light_overlap_id](const hdmap::PathOverlap& overlap) {
        return overlap.object_id == current_traffic_light_overlap_id;
      });
  if (traffic_light_overlap_itr == traffic_light_overlaps.end()) {
    injector_->planning_context()
        ->mutable_planning_status()
        ->mutable_traffic_light()
        ->Clear();
    return true;
  }
 
  static constexpr double kTrafficLightGroupingMaxDist = 2.0;  // unit: m
  const double current_traffic_light_overlap_start_s =
      traffic_light_overlap_itr->start_s;
  for (const auto& traffic_light_overlap : traffic_light_overlaps) {
    const double dist =
        traffic_light_overlap.start_s - current_traffic_light_overlap_start_s;
    if (fabs(dist) <= kTrafficLightGroupingMaxDist) {
      injector_->planning_context()
          ->mutable_planning_status()
          ->mutable_traffic_light()
          ->add_current_traffic_light_overlap_id(
              traffic_light_overlap.object_id);
      ADEBUG << "Update PlanningContext with first_encountered traffic_light["
             << traffic_light_overlap.object_id << "] start_s["
             << traffic_light_overlap.start_s << "]";
    }
  }
  return true;
}

◆ Exit()

bool apollo::planning::TrafficLightUnprotectedRightTurnScenario::Exit ( Frame * frame )

overridevirtual

重载 apollo::planning::Scenario .

在文件 traffic_light_unprotected_right_turn_scenario.cc 第 138 行定义.

                                                                {
  injector_->planning_context()
      ->mutable_planning_status()
      ->mutable_traffic_light()
      ->Clear();
  return true;
}

◆ GetContext()

TrafficLightUnprotectedRightTurnContext * apollo::planning::TrafficLightUnprotectedRightTurnScenario::GetContext ( )

inlineoverridevirtual

Get the scenario context.

实现了 apollo::planning::Scenario.

在文件 traffic_light_unprotected_right_turn_scenario.h 第 42 行定义.

                                                                 {
    return &context_;
  }

◆ Init()

bool apollo::planning::TrafficLightUnprotectedRightTurnScenario::Init	(	std::shared_ptr< DependencyInjector >	injector,
		const std::string &	name
	)

overridevirtual

重载 apollo::planning::Scenario .

在文件 traffic_light_unprotected_right_turn_scenario.cc 第 39 行定义.

                                                                       {
  if (init_) {
    return true;
  }
 
  if (!Scenario::Init(injector, name)) {
    AERROR << "failed to init scenario" << Name();
    return false;
  }
 
  if (!Scenario::LoadConfig<ScenarioTrafficLightUnprotectedRightTurnConfig>(
          &context_.scenario_config)) {
    AERROR << "fail to get specific config of scenario " << Name();
    return false;
  }
  init_ = true;
  return true;
}

◆ IsTransferable()

bool apollo::planning::TrafficLightUnprotectedRightTurnScenario::IsTransferable	(	const Scenario *const	other_scenario,
		const Frame &	frame
	)

overridevirtual

Each scenario should define its own transfer condition, i.e., when it should allow to transfer from other scenario to itself.

重载 apollo::planning::Scenario .

在文件 traffic_light_unprotected_right_turn_scenario.cc 第 59 行定义.

                                                              {
  if (!frame.local_view().planning_command->has_lane_follow_command()) {
    return false;
  }
  if (other_scenario == nullptr || frame.reference_line_info().empty()) {
    return false;
  }
  const auto& reference_line_info = frame.reference_line_info().front();
  const auto& first_encountered_overlaps =
      reference_line_info.FirstEncounteredOverlaps();
  hdmap::PathOverlap* traffic_sign_overlap = nullptr;
  for (const auto& overlap : first_encountered_overlaps) {
    if (overlap.first == ReferenceLineInfo::STOP_SIGN ||
        overlap.first == ReferenceLineInfo::YIELD_SIGN) {
      return false;
    } else if (overlap.first == ReferenceLineInfo::SIGNAL) {
      traffic_sign_overlap = const_cast<hdmap::PathOverlap*>(&overlap.second);
      break;
    }
  }
  if (traffic_sign_overlap == nullptr) {
    return false;
  }
  const std::vector<hdmap::PathOverlap>& traffic_light_overlaps =
      reference_line_info.reference_line().map_path().signal_overlaps();
  const double start_check_distance =
      context_.scenario_config.start_traffic_light_scenario_distance();
  const double adc_front_edge_s = reference_line_info.AdcSlBoundary().end_s();
  // find all the traffic light belong to
  // the same group as first encountered traffic light
  std::vector<hdmap::PathOverlap> next_traffic_lights;
  static constexpr double kTrafficLightGroupingMaxDist = 2.0;  // unit: m
  for (const auto& overlap : traffic_light_overlaps) {
    const double dist = overlap.start_s - traffic_sign_overlap->start_s;
    if (fabs(dist) <= kTrafficLightGroupingMaxDist) {
      next_traffic_lights.push_back(overlap);
    }
  }
  bool traffic_light_scenario = false;
  // note: need iterate all lights to check no RED/YELLOW/UNKNOWN
  for (const auto& overlap : next_traffic_lights) {
    const double adc_distance_to_traffic_light =
        overlap.start_s - adc_front_edge_s;
    ADEBUG << "traffic_light[" << overlap.object_id << "] start_s["
           << overlap.start_s << "] adc_distance_to_traffic_light["
           << adc_distance_to_traffic_light << "]";
 
    // enter traffic-light scenarios: based on distance only
    if (adc_distance_to_traffic_light <= 0.0 ||
        adc_distance_to_traffic_light > start_check_distance) {
      continue;
    }
 
    const auto& signal_color = frame.GetSignal(overlap.object_id).color();
    ADEBUG << "traffic_light_id[" << overlap.object_id << "] start_s["
           << overlap.start_s << "] color[" << signal_color << "]";
 
    if (signal_color != perception::TrafficLight::GREEN &&
        signal_color != perception::TrafficLight::BLACK) {
      traffic_light_scenario = true;
      break;
    }
  }
  if (!traffic_light_scenario) {
    return false;
  }
  const auto& turn_type =
      reference_line_info.GetPathTurnType(traffic_sign_overlap->start_s);
  if (turn_type != hdmap::Lane::RIGHT_TURN) {
    return false;
  }
  context_.current_traffic_light_overlap_ids.clear();
  for (const auto& overlap : next_traffic_lights) {
    context_.current_traffic_light_overlap_ids.push_back(overlap.object_id);
  }
  return true;
}

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

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

Public 成员函数

额外继承的成员函数

详细描述

成员函数说明

◆ Enter()

◆ Exit()

◆ GetContext()

◆ Init()

◆ IsTransferable()