#include <stage_approach.h>

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

apollo::planning::BareIntersectionUnprotectedStageApproach 的协作图:

Public 成员函数
StageResult	Process (const common::TrajectoryPoint &planning_init_point, Frame *frame) override
	Each stage does its business logic inside Process function.

bool	CheckClear (const ReferenceLineInfo &reference_line_info, std::vector< std::string > *wait_for_obstacle_ids)

StageResult	FinishStage (Frame *frame)

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_approach.h 第 36 行定义.

成员函数说明

◆ CheckClear()

bool apollo::planning::BareIntersectionUnprotectedStageApproach::CheckClear	(	const ReferenceLineInfo &	reference_line_info,
		std::vector< std::string > *	wait_for_obstacle_ids
	)

在文件 stage_approach.cc 第 133 行定义.

                                                 {
  // TODO(all): move to conf
  static constexpr double kConf_min_boundary_t = 6.0;        // second
  static constexpr double kConf_ignore_max_st_min_t = 0.1;   // second
  static constexpr double kConf_ignore_min_st_min_s = 15.0;  // meter
 
  bool all_far_away = true;
  for (auto* obstacle :
       reference_line_info.path_decision().obstacles().Items()) {
    if (obstacle->IsVirtual() || obstacle->IsStatic()) {
      continue;
    }
    if (obstacle->reference_line_st_boundary().min_t() < kConf_min_boundary_t) {
      const double kepsilon = 1e-6;
      double obstacle_traveled_s =
          obstacle->reference_line_st_boundary().bottom_left_point().s() -
          obstacle->reference_line_st_boundary().bottom_right_point().s();
      ADEBUG << "obstacle[" << obstacle->Id() << "] obstacle_st_min_t["
             << obstacle->reference_line_st_boundary().min_t()
             << "] obstacle_st_min_s["
             << obstacle->reference_line_st_boundary().min_s()
             << "] obstacle_traveled_s[" << obstacle_traveled_s << "]";
 
      // ignore the obstacle which is already on reference line and moving
      // along the direction of ADC
      if (obstacle_traveled_s < kepsilon &&
          obstacle->reference_line_st_boundary().min_t() <
              kConf_ignore_max_st_min_t &&
          obstacle->reference_line_st_boundary().min_s() >
              kConf_ignore_min_st_min_s) {
        continue;
      }
 
      wait_for_obstacle_ids->push_back(obstacle->Id());
      all_far_away = false;
    }
  }
  return all_far_away;
}

◆ FinishStage()

StageResult apollo::planning::BareIntersectionUnprotectedStageApproach::FinishStage ( Frame * frame )

在文件 stage_approach.cc 第 175 行定义.

                  {
  next_stage_ = "BARE_INTERSECTION_UNPROTECTED_INTERSECTION_CRUISE";
 
  // reset cruise_speed
  auto& reference_line_info = frame->mutable_reference_line_info()->front();
  reference_line_info.LimitCruiseSpeed(FLAGS_default_cruise_speed);
 
  return StageResult(StageStatusType::FINISHED);
}

◆ Process()

StageResult apollo::planning::BareIntersectionUnprotectedStageApproach::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_approach.cc 第 37 行定义.

                                                              {
  ADEBUG << "stage: Approach";
  CHECK_NOTNULL(frame);
 
  scenario_config_.CopyFrom(
      GetContextAs<BareIntersectionUnprotectedContext>()->scenario_config);
 
  StageResult result = ExecuteTaskOnReferenceLine(planning_init_point, frame);
  if (result.HasError()) {
    AERROR << "BareIntersectionUnprotectedStageApproach planning error";
  }
 
  const auto& reference_line_info = frame->reference_line_info().front();
 
  const std::string pnc_junction_overlap_id =
      GetContextAs<BareIntersectionUnprotectedContext>()
          ->current_pnc_junction_overlap_id;
  if (pnc_junction_overlap_id.empty()) {
    return FinishScenario();
  }
 
  // get overlap along reference line
  PathOverlap* current_pnc_junction =
      reference_line_info.GetOverlapOnReferenceLine(
          pnc_junction_overlap_id, ReferenceLineInfo::PNC_JUNCTION);
  if (!current_pnc_junction) {
    return FinishScenario();
  }
 
  static constexpr double kPassStopLineBuffer = 0.3;  // unit: m
  const double adc_front_edge_s = reference_line_info.AdcSlBoundary().end_s();
  const double distance_adc_to_pnc_junction =
      current_pnc_junction->start_s - adc_front_edge_s;
  ADEBUG << "pnc_junction_overlap_id[" << pnc_junction_overlap_id
         << "] start_s[" << current_pnc_junction->start_s
         << "] distance_adc_to_pnc_junction[" << distance_adc_to_pnc_junction
         << "]";
  if (distance_adc_to_pnc_junction < -kPassStopLineBuffer) {
    // passed stop line
    return FinishStage(frame);
  }
 
  // set cruise_speed to slow down
  frame->mutable_reference_line_info()->front().LimitCruiseSpeed(
      scenario_config_.approach_cruise_speed());
 
  // set right_of_way_status
  reference_line_info.SetJunctionRightOfWay(current_pnc_junction->start_s,
                                            false);
 
  result = ExecuteTaskOnReferenceLine(planning_init_point, frame);
  if (result.HasError()) {
    AERROR << "BareIntersectionUnprotectedStageApproach planning error";
  }
 
  std::vector<std::string> wait_for_obstacle_ids;
  bool clear = CheckClear(reference_line_info, &wait_for_obstacle_ids);
 
  if (scenario_config_.enable_explicit_stop()) {
    bool stop = false;
    static constexpr double kCheckClearDistance = 5.0;  // meter
    static constexpr double kStartWatchDistance = 2.0;  // meter
    if (distance_adc_to_pnc_junction <= kCheckClearDistance &&
        distance_adc_to_pnc_junction >= kStartWatchDistance && !clear) {
      stop = true;
    } else if (distance_adc_to_pnc_junction < kStartWatchDistance) {
      // creeping area
      counter_ = clear ? counter_ + 1 : 0;
 
      if (counter_ >= 5) {
        counter_ = 0;  // reset
      } else {
        stop = true;
      }
    }
 
    if (stop) {
      // build stop decision
      ADEBUG << "BuildStopDecision: bare pnc_junction["
             << pnc_junction_overlap_id << "] start_s["
             << current_pnc_junction->start_s << "]";
      const std::string virtual_obstacle_id =
          "PNC_JUNCTION_" + current_pnc_junction->object_id;
      planning::util::BuildStopDecision(
          virtual_obstacle_id, current_pnc_junction->start_s,
          scenario_config_.stop_distance(),
          StopReasonCode::STOP_REASON_STOP_SIGN, wait_for_obstacle_ids,
          "bare intersection", frame,
          &(frame->mutable_reference_line_info()->front()));
    }
  }
 
  return result.SetStageStatus(StageStatusType::RUNNING);
}

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

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

Public 成员函数

额外继承的成员函数

详细描述

成员函数说明

◆ CheckClear()

◆ FinishStage()

◆ Process()