apollo::planning::StopSignUnprotectedScenario类 参考

#include <stop_sign_unprotected_scenario.h>

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

apollo::planning::StopSignUnprotectedScenario 的协作图:

Public 成员函数
bool	Init (std::shared_ptr< DependencyInjector > injector, const std::string &name) override
StopSignUnprotectedContext *	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_

详细描述

在文件 stop_sign_unprotected_scenario.h 第 36 行定义.

成员函数说明

Enter()

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

overridevirtual

重载 apollo::planning::Scenario .

在文件 stop_sign_unprotected_scenario.cc 第 145 行定义.

                                                    {
  const auto& reference_line_info = frame->reference_line_info().front();
  std::string current_stop_sign_overlap_id;
  const auto& overlaps = reference_line_info.FirstEncounteredOverlaps();
  for (auto overlap : overlaps) {
    if (overlap.first == ReferenceLineInfo::STOP_SIGN) {
      current_stop_sign_overlap_id = overlap.second.object_id;
      break;
    }
  }
 
  if (current_stop_sign_overlap_id.empty()) {
    injector_->planning_context()
        ->mutable_planning_status()
        ->mutable_stop_sign()
        ->Clear();
    AERROR << "Can not find stop sign overlap in refline";
    return false;
  }
 
  const std::vector<hdmap::PathOverlap>& stop_sign_overlaps =
      reference_line_info.reference_line().map_path().stop_sign_overlaps();
  auto stop_sign_overlap_itr = std::find_if(
      stop_sign_overlaps.begin(), stop_sign_overlaps.end(),
      [&current_stop_sign_overlap_id](const hdmap::PathOverlap& overlap) {
        return overlap.object_id == current_stop_sign_overlap_id;
      });
 
  if (stop_sign_overlap_itr != stop_sign_overlaps.end()) {
    injector_->planning_context()
        ->mutable_planning_status()
        ->mutable_stop_sign()
        ->set_current_stop_sign_overlap_id(current_stop_sign_overlap_id);
    ADEBUG << "Update PlanningContext with first_encountered stop sign["
           << current_stop_sign_overlap_id << "] start_s["
           << stop_sign_overlap_itr->start_s << "]";
  } else {
    AERROR << "Can not find stop sign overlap " << current_stop_sign_overlap_id;
    return false;
  }
 
  hdmap::StopSignInfoConstPtr stop_sign = HDMapUtil::BaseMap().GetStopSignById(
      hdmap::MakeMapId(current_stop_sign_overlap_id));
  if (!stop_sign) {
    AERROR << "Could not find stop sign: " << current_stop_sign_overlap_id;
    return false;
  }
  context_.current_stop_sign_overlap_id = current_stop_sign_overlap_id;
  context_.watch_vehicles.clear();
 
  GetAssociatedLanes(*stop_sign);
  return true;
}

Exit()

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

overridevirtual

重载 apollo::planning::Scenario .

在文件 stop_sign_unprotected_scenario.cc 第 137 行定义.

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

GetContext()

StopSignUnprotectedContext * apollo::planning::StopSignUnprotectedScenario::GetContext ( )

inlineoverridevirtual

Get the scenario context.

实现了 apollo::planning::Scenario.

在文件 stop_sign_unprotected_scenario.h 第 44 行定义.

{ return &context_; }

Init()

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

overridevirtual

重载 apollo::planning::Scenario .

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

                                                                       {
  if (!Scenario::Init(injector, name)) {
    AERROR << "Failed to init scenario" << Name();
    return false;
  }
 
  if (!Scenario::LoadConfig<ScenarioStopSignUnprotectedConfig>(
          &context_.scenario_config)) {
    AERROR << "Fail to get config of scenario " << Name();
    return false;
  }
  return true;
}

IsTransferable()

bool apollo::planning::StopSignUnprotectedScenario::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 .

在文件 stop_sign_unprotected_scenario.cc 第 98 行定义.

                                                              {
  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();
  // note: first_encountered_overlaps already sorted
  hdmap::PathOverlap* stop_sign_overlap = nullptr;
  for (const auto& overlap : first_encountered_overlaps) {
    if (overlap.first == ReferenceLineInfo::SIGNAL ||
        overlap.first == ReferenceLineInfo::YIELD_SIGN) {
      return false;
    } else if (overlap.first == ReferenceLineInfo::STOP_SIGN) {
      stop_sign_overlap = const_cast<hdmap::PathOverlap*>(&overlap.second);
      break;
    }
  }
  if (stop_sign_overlap == nullptr) {
    return false;
  }
  const double adc_front_edge_s = reference_line_info.AdcSlBoundary().end_s();
  const double adc_distance_to_stop_sign =
      stop_sign_overlap->start_s - adc_front_edge_s;
  ADEBUG << "adc_distance_to_stop_sign[" << adc_distance_to_stop_sign
         << "] stop_sign[" << stop_sign_overlap->object_id
         << "] stop_sign_overlap_start_s[" << stop_sign_overlap->start_s << "]";
  const bool stop_sign_scenario =
      (adc_distance_to_stop_sign > 0.0 &&
       adc_distance_to_stop_sign <=
           context_.scenario_config.start_stop_sign_scenario_distance());
 
  return stop_sign_scenario;
}

---

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

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