apollo::planning::GriddedPathTimeGraph类 参考

#include <gridded_path_time_graph.h>

apollo::planning::GriddedPathTimeGraph 的协作图:

Public 成员函数
	GriddedPathTimeGraph (const StGraphData &st_graph_data, const DpStSpeedOptimizerConfig &dp_config, const std::vector< const Obstacle * > &obstacles, const common::TrajectoryPoint &init_point)
common::Status	Search (SpeedData *const speed_data)

详细描述

在文件 gridded_path_time_graph.h 第 43 行定义.

构造及析构函数说明

GriddedPathTimeGraph()

apollo::planning::GriddedPathTimeGraph::GriddedPathTimeGraph	(	const StGraphData &	st_graph_data,
		const DpStSpeedOptimizerConfig &	dp_config,
		const std::vector< const Obstacle * > &	obstacles,
		const common::TrajectoryPoint &	init_point
	)

在文件 gridded_path_time_graph.cc 第 68 行定义.

    : st_graph_data_(st_graph_data),
      gridded_path_time_graph_config_(dp_config),
      obstacles_(obstacles),
      init_point_(init_point),
      dp_st_cost_(dp_config, st_graph_data_.total_time_by_conf(),
                  st_graph_data_.path_length(), obstacles,
                  st_graph_data_.st_drivable_boundary(), init_point_) {
  total_length_t_ = st_graph_data_.total_time_by_conf();
  unit_t_ = gridded_path_time_graph_config_.unit_t();
  total_length_s_ = st_graph_data_.path_length();
  dense_unit_s_ = gridded_path_time_graph_config_.dense_unit_s();
  sparse_unit_s_ = gridded_path_time_graph_config_.sparse_unit_s();
  dense_dimension_s_ = gridded_path_time_graph_config_.dense_dimension_s();
  // Safety approach preventing unreachable acceleration/deceleration
  max_acceleration_ =
      std::min(std::abs(vehicle_param_.max_acceleration()),
               std::abs(gridded_path_time_graph_config_.max_acceleration()));
  max_deceleration_ =
      -1.0 *
      std::min(std::abs(vehicle_param_.max_deceleration()),
               std::abs(gridded_path_time_graph_config_.max_deceleration()));
}

成员函数说明

Search()

Status apollo::planning::GriddedPathTimeGraph::Search

(

SpeedData *const

speed_data

)

在文件 gridded_path_time_graph.cc 第 95 行定义.

                                                               {
  static constexpr double kBounadryEpsilon = 1e-2;
  for (const auto& boundary : st_graph_data_.st_boundaries()) {
    // KeepClear obstacles not considered in Dp St decision
    if (boundary->boundary_type() == STBoundary::BoundaryType::KEEP_CLEAR) {
      continue;
    }
    // If init point in collision with obstacle, return speed fallback
    if (boundary->IsPointInBoundary({0.0, 0.0}) ||
        (std::fabs(boundary->min_t()) < kBounadryEpsilon &&
         std::fabs(boundary->min_s()) < kBounadryEpsilon)) {
      dimension_t_ = static_cast<uint32_t>(std::ceil(
                         total_length_t_ / static_cast<double>(unit_t_))) +
                     1;
      std::vector<SpeedPoint> speed_profile;
      double t = 0.0;
      for (uint32_t i = 0; i < dimension_t_; ++i, t += unit_t_) {
        speed_profile.push_back(PointFactory::ToSpeedPoint(0, t));
      }
      *speed_data = SpeedData(speed_profile);
      return Status::OK();
    }
  }
 
  if (!InitCostTable().ok()) {
    const std::string msg = "Initialize cost table failed.";
    AERROR << msg;
    return Status(ErrorCode::PLANNING_ERROR, msg);
  }
 
  if (!InitSpeedLimitLookUp().ok()) {
    const std::string msg = "Initialize speed limit lookup table failed.";
    AERROR << msg;
    return Status(ErrorCode::PLANNING_ERROR, msg);
  }
 
  if (!CalculateTotalCost().ok()) {
    const std::string msg = "Calculate total cost failed.";
    AERROR << msg;
    return Status(ErrorCode::PLANNING_ERROR, msg);
  }
 
  if (!RetrieveSpeedProfile(speed_data).ok()) {
    const std::string msg = "Retrieve best speed profile failed.";
    AERROR << msg;
    return Status(ErrorCode::PLANNING_ERROR, msg);
  }
  return Status::OK();
}

---

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

• modules/planning/tasks/path_time_heuristic/gridded_path_time_graph.h
• modules/planning/tasks/path_time_heuristic/gridded_path_time_graph.cc