#include <bare_intersection_unprotected_scenario.h>

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

apollo::planning::BareIntersectionUnprotectedScenario 的协作图:

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

BareIntersectionUnprotectedContext *	GetContext () override
	Get the scenario context.

bool	IsTransferable (const Scenario *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	Enter (Frame *frame) override

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

virtual	~Scenario ()=default

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

virtual bool	Exit (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_

详细描述

在文件 bare_intersection_unprotected_scenario.h 第 41 行定义.

成员函数说明

◆ Enter()

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

overridevirtual

重载 apollo::planning::Scenario .

在文件 bare_intersection_unprotected_scenario.cc 第 129 行定义.

                                                            {
  // set to first_encountered pnc_junction
  const auto& first_encountered_overlaps =
      frame->reference_line_info().front().FirstEncounteredOverlaps();
  for (const auto& overlap : first_encountered_overlaps) {
    if (overlap.first == ReferenceLineInfo::PNC_JUNCTION) {
      context_.current_pnc_junction_overlap_id = overlap.second.object_id;
      ADEBUG << "Update PlanningContext with first_encountered pnc_junction["
             << overlap.second.object_id << "] start_s["
             << overlap.second.start_s << "]";
      break;
    }
  }
  return true;
}

◆ GetContext()

BareIntersectionUnprotectedContext * apollo::planning::BareIntersectionUnprotectedScenario::GetContext ( )

inlineoverridevirtual

Get the scenario context.

实现了 apollo::planning::Scenario.

在文件 bare_intersection_unprotected_scenario.h 第 48 行定义.

                                                            {
    return &context_;
  }

◆ Init()

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

overridevirtual

重载 apollo::planning::Scenario .

在文件 bare_intersection_unprotected_scenario.cc 第 35 行定义.

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

◆ IsTransferable()

bool apollo::planning::BareIntersectionUnprotectedScenario::IsTransferable	(	const Scenario *	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 .

在文件 bare_intersection_unprotected_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* pnc_junction_overlap = nullptr;
  hdmap::PathOverlap* traffic_sign_overlap = nullptr;
  // note: first_encountered_overlaps already sorted
  if (first_encountered_overlaps.empty()) {
    return false;
  }
 
  for (const auto& overlap : first_encountered_overlaps) {
    if ((overlap.first == ReferenceLineInfo::SIGNAL ||
         overlap.first == ReferenceLineInfo::STOP_SIGN ||
         overlap.first == ReferenceLineInfo::YIELD_SIGN) &&
        traffic_sign_overlap == nullptr) {
      traffic_sign_overlap = const_cast<hdmap::PathOverlap*>(&overlap.second);
      break;
    } else if (overlap.first == ReferenceLineInfo::PNC_JUNCTION &&
               pnc_junction_overlap == nullptr) {
      pnc_junction_overlap = const_cast<hdmap::PathOverlap*>(&overlap.second);
    }
  }
 
  if (traffic_sign_overlap && pnc_junction_overlap) {
    static constexpr double kJunctionDelta = 10.0;
    double s_diff = std::fabs(traffic_sign_overlap->start_s -
                              pnc_junction_overlap->start_s);
    if (s_diff >= kJunctionDelta) {
      if (pnc_junction_overlap->start_s > traffic_sign_overlap->start_s) {
        pnc_junction_overlap = nullptr;
      } else {
        traffic_sign_overlap = nullptr;
      }
    }
  }
 
  if (traffic_sign_overlap || !pnc_junction_overlap) {
    return false;
  }
 
  if (reference_line_info.GetIntersectionRightofWayStatus(
          *pnc_junction_overlap)) {
    return false;
  }
 
  const double adc_front_edge_s = reference_line_info.AdcSlBoundary().end_s();
  const double adc_distance_to_pnc_junction =
      pnc_junction_overlap->start_s - adc_front_edge_s;
  ADEBUG << "adc_distance_to_pnc_junction[" << adc_distance_to_pnc_junction
         << "] pnc_junction[" << pnc_junction_overlap->object_id
         << "] pnc_junction_overlap_start_s[" << pnc_junction_overlap->start_s
         << "]";
 
  const bool bare_junction_scenario =
      (adc_distance_to_pnc_junction > 0.0 &&
       adc_distance_to_pnc_junction <=
           context_.scenario_config
               .start_bare_intersection_scenario_distance());
 
  return bare_junction_scenario;
}

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

modules/planning/scenarios/bare_intersection_unprotected/bare_intersection_unprotected_scenario.h
modules/planning/scenarios/bare_intersection_unprotected/bare_intersection_unprotected_scenario.cc

Public 成员函数

额外继承的成员函数

详细描述

成员函数说明

◆ Enter()

◆ GetContext()

◆ Init()

◆ IsTransferable()