apollo::planning::NaviPlanner类 参考

NaviPlanner is a planner based on real-time relative maps. 更多...

#include <navi_planner.h>

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

apollo::planning::NaviPlanner 的协作图:

Public 成员函数
virtual	~NaviPlanner ()=default
std::string	Name () override
common::Status	Init (const std::shared_ptr< DependencyInjector > &injector, const std::string &config_path="") override
common::Status	Plan (const common::TrajectoryPoint &planning_init_point, Frame *frame, ADCTrajectory *ptr_computed_trajectory) override
	Override function Plan in parent class Planner.
void	Stop () override
common::Status	PlanOnReferenceLine (const common::TrajectoryPoint &planning_init_point, Frame *frame, ReferenceLineInfo *reference_line_info) override
	Override function Plan in parent class Planner.
Public 成员函数 继承自 apollo::planning::PlannerWithReferenceLine
virtual	~PlannerWithReferenceLine ()=default
	Destructor
Public 成员函数 继承自 apollo::planning::Planner
virtual	~Planner ()=default
	Destructor
virtual void	Reset (Frame *frame)
template<typename T >
bool	LoadConfig (const std::string &custom_config_path, T *config)

额外继承的成员函数
Protected 属性 继承自 apollo::planning::Planner
std::shared_ptr< DependencyInjector >	injector_ = nullptr

详细描述

NaviPlanner is a planner based on real-time relative maps.

It uses the vehicle's FLU (Front-Left-Up) coordinate system to accomplish tasks such as cruising, following, overtaking, nudging, changing lanes and stopping. Note that NaviPlanner is only used in navigation mode (turn on navigation mode by setting "FLAGS_use_navigation_mode" to "true") and do not use it in standard mode.

在文件 navi_planner.h 第 59 行定义.

构造及析构函数说明

~NaviPlanner()

virtual apollo::planning::NaviPlanner::~NaviPlanner ( )

virtualdefault

成员函数说明

Init()

Status apollo::planning::NaviPlanner::Init ( const std::shared_ptr< DependencyInjector > &  injector, const std::string &  config_path = ""  )

overridevirtual

重载 apollo::planning::Planner .

在文件 navi_planner.cc 第 76 行定义.

                                                       {
  Planner::Init(injector, config_path);
  // NaviPlanner is only used in navigation mode based on the real-time relative
  // map.
  if (!FLAGS_use_navigation_mode) {
    const std::string msg = "NaviPlanner is only used in navigation mode.";
    AERROR << msg;
    return Status(ErrorCode::PLANNING_ERROR, msg);
  }
 
  AINFO << "In NaviPlanner::Init()";
  RegisterTasks();
  PlannerNaviConfig planner_conf;
  LoadConfig<PlannerNaviConfig>(config_path, &planner_conf);
  for (const auto task : planner_conf.task()) {
    tasks_.emplace_back(
        task_factory_.CreateObject(static_cast<NaviTaskType>(task)));
    AINFO << "Created task:" << tasks_.back()->Name();
  }
  for (auto& task : tasks_) {
    if (!task->Init(planner_conf)) {
      const std::string msg =
          absl::StrCat("Init task[", task->Name(), "] failed.");
      AERROR << msg;
      return Status(ErrorCode::PLANNING_ERROR, msg);
    }
  }
  return Status::OK();
}

Name()

std::string apollo::planning::NaviPlanner::Name ( )

inlineoverridevirtual

实现了 apollo::planning::Planner.

在文件 navi_planner.h 第 63 行定义.

{ return "NAVI"; }

Plan()

Status apollo::planning::NaviPlanner::Plan ( const common::TrajectoryPoint &  planning_init_point, Frame *  frame, ADCTrajectory *  ptr_computed_trajectory  )

overridevirtual

Override function Plan in parent class Planner.

参数

planning_init_point	The trajectory point where planning starts.
frame	Current planning frame.

返回

OK if planning succeeds; error otherwise.

实现了 apollo::planning::Planner.

在文件 navi_planner.cc 第 107 行定义.

                                                                               {
  // NaviPlanner is only used in navigation mode based on the real-time relative
  // map.
  if (!FLAGS_use_navigation_mode) {
    const std::string msg = "NaviPlanner is only used in navigation mode.";
    AERROR << msg;
    return Status(ErrorCode::PLANNING_ERROR, msg);
  }
 
  size_t success_line_count = 0;
  for (auto& reference_line_info : *frame->mutable_reference_line_info()) {
    uint32_t priority = reference_line_info.GetPriority();
    reference_line_info.SetCost(priority * kStraightForwardLineCost);
    if (priority != KDestLanePriority) {
      reference_line_info.SetDrivable(false);
      continue;
    }
    auto status =
        PlanOnReferenceLine(planning_init_point, frame, &reference_line_info);
 
    if (status.ok() && reference_line_info.IsDrivable()) {
      success_line_count += 1;
    } else {
      reference_line_info.SetDrivable(false);
      AERROR << "Failed to plan on reference line  "
             << reference_line_info.Lanes().Id();
    }
    ADEBUG << "ref line info: " << reference_line_info.Lanes().Id()
           << " priority : " << reference_line_info.GetPriority()
           << " cost : " << reference_line_info.Cost()
           << " driveable : " << reference_line_info.IsDrivable();
  }
 
  if (success_line_count > 0) {
    return Status::OK();
  }
 
  return Status(ErrorCode::PLANNING_ERROR,
                "Failed to plan on any reference line.");
}

PlanOnReferenceLine()

Status apollo::planning::NaviPlanner::PlanOnReferenceLine ( const common::TrajectoryPoint &  planning_init_point, Frame *  frame, ReferenceLineInfo *  reference_line_info  )

overridevirtual

Override function Plan in parent class Planner.

参数

planning_init_point	The trajectory point where planning starts.
frame	Current planning frame.
reference_line_info	The computed reference line.

返回

OK if planning succeeds; error otherwise.

重载 apollo::planning::PlannerWithReferenceLine .

在文件 navi_planner.cc 第 149 行定义.

                                            {
  if (!reference_line_info->IsChangeLanePath() &&
      reference_line_info->IsNeighborLanePath()) {
    reference_line_info->AddCost(kStraightForwardLineCost);
  }
  ADEBUG << "planning start point:" << planning_init_point.DebugString();
  auto* heuristic_speed_data = reference_line_info->mutable_speed_data();
  auto speed_profile =
      GenerateInitSpeedProfile(planning_init_point, reference_line_info);
  if (speed_profile.empty()) {
    speed_profile = GenerateSpeedHotStart(planning_init_point);
    ADEBUG << "Using dummy hot start for speed vector";
  }
  *heuristic_speed_data = SpeedData(speed_profile);
 
  auto ret = Status::OK();
 
  for (auto& task : tasks_) {
    const double start_timestamp = Clock::NowInSeconds();
    ret = task->Execute(frame, reference_line_info);
    if (!ret.ok()) {
      AERROR << "Failed to run tasks[" << task->Name()
             << "], Error message: " << ret.error_message();
      break;
    }
    const double end_timestamp = Clock::NowInSeconds();
    const double time_diff_ms = (end_timestamp - start_timestamp) * 1000;
 
    ADEBUG << "after task " << task->Name() << ":"
           << reference_line_info->PathSpeedDebugString();
    ADEBUG << task->Name() << " time spend: " << time_diff_ms << " ms.";
 
    RecordDebugInfo(reference_line_info, task->Name(), time_diff_ms);
  }
 
  RecordObstacleDebugInfo(reference_line_info);
 
  if (reference_line_info->path_data().Empty()) {
    ADEBUG << "Path fallback.";
    GenerateFallbackPathProfile(reference_line_info,
                                reference_line_info->mutable_path_data());
    reference_line_info->AddCost(kPathOptimizationFallbackClost);
  }
 
  if (!ret.ok() || reference_line_info->speed_data().empty()) {
    ADEBUG << "Speed fallback.";
    GenerateFallbackSpeedProfile(reference_line_info->mutable_speed_data());
    reference_line_info->AddCost(kSpeedOptimizationFallbackClost);
  }
 
  DiscretizedTrajectory trajectory;
  if (!reference_line_info->CombinePathAndSpeedProfile(
          planning_init_point.relative_time(),
          planning_init_point.path_point().s(), &trajectory)) {
    const std::string msg = "Fail to aggregate planning trajectory.";
    AERROR << msg;
    return Status(ErrorCode::PLANNING_ERROR, msg);
  }
 
  for (const auto* obstacle :
       reference_line_info->path_decision()->obstacles().Items()) {
    if (obstacle->IsVirtual()) {
      continue;
    }
    if (!obstacle->IsStatic()) {
      continue;
    }
    if (obstacle->LongitudinalDecision().has_stop()) {
      static constexpr double kRefrenceLineStaticObsCost = 1e3;
      reference_line_info->AddCost(kRefrenceLineStaticObsCost);
    }
  }
 
  if (FLAGS_enable_trajectory_check) {
    if (ConstraintChecker::ValidTrajectory(trajectory) !=
        ConstraintChecker::Result::VALID) {
      const std::string msg = "Current planning trajectory is not valid.";
      AERROR << msg;
      return Status(ErrorCode::PLANNING_ERROR, msg);
    }
  }
 
  reference_line_info->SetTrajectory(trajectory);
  reference_line_info->SetDrivable(true);
  return Status::OK();
}

Stop()

void apollo::planning::NaviPlanner::Stop ( )

inlineoverridevirtual

实现了 apollo::planning::Planner.

在文件 navi_planner.h 第 78 行定义.

{}

---

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

• modules/planning/planners/navi/navi_planner.h
• modules/planning/planners/navi/navi_planner.cc