apollo::planning::ParkAndGoScenario类 参考

#include <park_and_go_scenario.h>

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

apollo::planning::ParkAndGoScenario 的协作图:

Public 成员函数
bool	Init (std::shared_ptr< DependencyInjector > injector, const std::string &name) override
ParkAndGoContext *	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.
Public 成员函数 继承自 apollo::planning::Scenario
	Scenario ()
virtual	~Scenario ()=default
virtual ScenarioResult	Process (const common::TrajectoryPoint &planning_init_point, Frame *frame)
virtual bool	Exit (Frame *frame)
virtual bool	Enter (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_

详细描述

在文件 park_and_go_scenario.h 第 32 行定义.

成员函数说明

GetContext()

ParkAndGoContext * apollo::planning::ParkAndGoScenario::GetContext ( )

inlineoverridevirtual

Get the scenario context.

实现了 apollo::planning::Scenario.

在文件 park_and_go_scenario.h 第 40 行定义.

{ return &context_; }

Init()

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

overridevirtual

重载 apollo::planning::Scenario .

在文件 park_and_go_scenario.cc 第 32 行定义.

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

IsTransferable()

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

在文件 park_and_go_scenario.cc 第 53 行定义.

                                                           {
  if (!frame.local_view().planning_command->has_lane_follow_command()) {
    AINFO << "PARK_AND_GO: Don't has lane follow command!";
    return false;
  }
  if (other_scenario == nullptr || frame.reference_line_info().empty()) {
    AINFO << "PARK_AND_GO: Don't has reference line info or other scenario!";
    return false;
  }
  bool park_and_go = false;
  const auto& scenario_config = context_.scenario_config;
  const auto vehicle_state_provider = injector_->vehicle_state();
  common::VehicleState vehicle_state = vehicle_state_provider->vehicle_state();
  auto adc_point = common::util::PointFactory::ToPointENU(vehicle_state);
  // TODO(SHU) might consider gear == GEAR_PARKING
  double adc_speed = vehicle_state_provider->linear_velocity();
  double s = 0.0;
  double l = 0.0;
  const double max_abs_speed_when_stopped =
      common::VehicleConfigHelper::Instance()
          ->GetConfig()
          .vehicle_param()
          .max_abs_speed_when_stopped();
 
  hdmap::LaneInfoConstPtr lane;
 
  // check ego vehicle distance to destination
  const auto routing_end = frame.local_view().end_lane_way_point;
  if (nullptr == routing_end) {
    AINFO << "PARK_AND_GO: Don't has end lane way point!";
    return false;
  }
  common::SLPoint dest_sl;
  const auto& reference_line_info = frame.reference_line_info().front();
  const auto& reference_line = reference_line_info.reference_line();
  reference_line.XYToSL(routing_end->pose(), &dest_sl);
  const double adc_front_edge_s = reference_line_info.AdcSlBoundary().end_s();
 
  bool is_ego_on_lane = false;
  bool is_lane_type_city_driving = false;
  HDMapUtil::BaseMap().GetNearestLaneWithDistance(
      adc_point, 5.0, &lane, &s, &l);
  if (lane != nullptr && lane->IsOnLane({adc_point.x(), adc_point.y()})) {
    is_ego_on_lane = true;
    if (lane->lane().type() == hdmap::Lane::CITY_DRIVING) {
      is_lane_type_city_driving = true;
    }
  }
 
  const double adc_distance_to_dest = dest_sl.s() - adc_front_edge_s;
  ADEBUG << "adc_distance_to_dest:" << adc_distance_to_dest;
  bool is_vehicle_static = (std::fabs(adc_speed) < max_abs_speed_when_stopped);
  bool is_distance_far_enough =
      (adc_distance_to_dest > scenario_config.min_dist_to_dest());
  AINFO << "PARK_AND_GO: " << is_vehicle_static << "," << is_distance_far_enough
        << "," << is_ego_on_lane << "," << is_lane_type_city_driving;
  // if vehicle is static, far enough to destination and (off-lane or not on
  // city_driving lane)
  if (std::fabs(adc_speed) < max_abs_speed_when_stopped &&
      adc_distance_to_dest > scenario_config.min_dist_to_dest() &&
      (!is_ego_on_lane || !is_lane_type_city_driving)) {
    park_and_go = true;
  }
  return park_and_go;
}

---

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

• modules/planning/scenarios/park_and_go/park_and_go_scenario.h
• modules/planning/scenarios/park_and_go/park_and_go_scenario.cc