apollo::planning::PathTimeGraph类 参考

#include <path_time_graph.h>

apollo::planning::PathTimeGraph 的协作图:

Public 成员函数
	PathTimeGraph (const std::vector< const Obstacle * > &obstacles, const std::vector< common::PathPoint > &discretized_ref_points, const ReferenceLineInfo *ptr_reference_line_info, const double s_start, const double s_end, const double t_start, const double t_end, const std::array< double, 3 > &init_d)
const std::vector< STBoundary > &	GetPathTimeObstacles () const
bool	GetPathTimeObstacle (const std::string &obstacle_id, STBoundary *path_time_obstacle)
std::vector< std::pair< double, double > >	GetPathBlockingIntervals (const double t) const
std::vector< std::vector< std::pair< double, double > > >	GetPathBlockingIntervals (const double t_start, const double t_end, const double t_resolution)
std::pair< double, double >	get_path_range () const
std::pair< double, double >	get_time_range () const
std::vector< STPoint >	GetObstacleSurroundingPoints (const std::string &obstacle_id, const double s_dist, const double t_density) const
bool	IsObstacleInGraph (const std::string &obstacle_id)
std::vector< std::pair< double, double > >	GetLateralBounds (const double s_start, const double s_end, const double s_resolution)

详细描述

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

构造及析构函数说明

PathTimeGraph()

apollo::planning::PathTimeGraph::PathTimeGraph	(	const std::vector< const Obstacle * > &	obstacles,
		const std::vector< common::PathPoint > &	discretized_ref_points,
		const ReferenceLineInfo *	ptr_reference_line_info,
		const double	s_start,
		const double	s_end,
		const double	t_start,
		const double	t_end,
		const std::array< double, 3 > &	init_d
	)

在文件 path_time_graph.cc 第 43 行定义.

                                       {
  CHECK_LT(s_start, s_end);
  CHECK_LT(t_start, t_end);
  path_range_.first = s_start;
  path_range_.second = s_end;
  time_range_.first = t_start;
  time_range_.second = t_end;
  ptr_reference_line_info_ = ptr_reference_line_info;
  init_d_ = init_d;
 
  SetupObstacles(obstacles, discretized_ref_points);
}

成员函数说明

get_path_range()

std::pair< double, double > apollo::planning::PathTimeGraph::get_path_range

(

)

const

在文件 path_time_graph.cc 第 250 行定义.

                                                            {
  return path_range_;
}

get_time_range()

std::pair< double, double > apollo::planning::PathTimeGraph::get_time_range

(

)

const

在文件 path_time_graph.cc 第 254 行定义.

                                                            {
  return time_range_;
}

GetLateralBounds()

std::vector< std::pair< double, double > > apollo::planning::PathTimeGraph::GetLateralBounds	(	const double	s_start,
		const double	s_end,
		const double	s_resolution
	)

在文件 path_time_graph.cc 第 314 行定义.

                                                                         {
  CHECK_LT(s_start, s_end);
  CHECK_GT(s_resolution, FLAGS_numerical_epsilon);
  std::vector<std::pair<double, double>> bounds;
  std::vector<double> discretized_path;
  double s_range = s_end - s_start;
  double s_curr = s_start;
  size_t num_bound = static_cast<size_t>(s_range / s_resolution);
 
  const auto& vehicle_config =
      common::VehicleConfigHelper::Instance()->GetConfig();
  double ego_width = vehicle_config.vehicle_param().width();
 
  // Initialize bounds by reference line width
  for (size_t i = 0; i < num_bound; ++i) {
    double left_width = FLAGS_default_reference_line_width / 2.0;
    double right_width = FLAGS_default_reference_line_width / 2.0;
    ptr_reference_line_info_->reference_line().GetLaneWidth(s_curr, &left_width,
                                                            &right_width);
    double ego_d_lower = init_d_[0] - ego_width / 2.0;
    double ego_d_upper = init_d_[0] + ego_width / 2.0;
    bounds.emplace_back(
        std::min(-right_width, ego_d_lower - FLAGS_bound_buffer),
        std::max(left_width, ego_d_upper + FLAGS_bound_buffer));
    discretized_path.push_back(s_curr);
    s_curr += s_resolution;
  }
 
  for (const SLBoundary& static_sl_boundary : static_obs_sl_boundaries_) {
    UpdateLateralBoundsByObstacle(static_sl_boundary, discretized_path, s_start,
                                  s_end, &bounds);
  }
 
  for (size_t i = 0; i < bounds.size(); ++i) {
    bounds[i].first += ego_width / 2.0;
    bounds[i].second -= ego_width / 2.0;
    if (bounds[i].first >= bounds[i].second) {
      bounds[i].first = 0.0;
      bounds[i].second = 0.0;
    }
  }
  return bounds;
}

GetObstacleSurroundingPoints()

std::vector< STPoint > apollo::planning::PathTimeGraph::GetObstacleSurroundingPoints	(	const std::string &	obstacle_id,
		const double	s_dist,
		const double	t_density
	)		const

在文件 path_time_graph.cc 第 258 行定义.

                                      {
  ACHECK(t_min_density > 0.0);
  std::vector<STPoint> pt_pairs;
  if (path_time_obstacle_map_.find(obstacle_id) ==
      path_time_obstacle_map_.end()) {
    return pt_pairs;
  }
 
  const auto& pt_obstacle = path_time_obstacle_map_.at(obstacle_id);
 
  double s0 = 0.0;
  double s1 = 0.0;
 
  double t0 = 0.0;
  double t1 = 0.0;
  if (s_dist > 0.0) {
    s0 = pt_obstacle.upper_left_point().s();
    s1 = pt_obstacle.upper_right_point().s();
 
    t0 = pt_obstacle.upper_left_point().t();
    t1 = pt_obstacle.upper_right_point().t();
  } else {
    s0 = pt_obstacle.bottom_left_point().s();
    s1 = pt_obstacle.bottom_right_point().s();
 
    t0 = pt_obstacle.bottom_left_point().t();
    t1 = pt_obstacle.bottom_right_point().t();
  }
 
  double time_gap = t1 - t0;
  ACHECK(time_gap > -FLAGS_numerical_epsilon);
  time_gap = std::fabs(time_gap);
 
  size_t num_sections = static_cast<size_t>(time_gap / t_min_density + 1);
  double t_interval = time_gap / static_cast<double>(num_sections);
 
  for (size_t i = 0; i <= num_sections; ++i) {
    double t = t_interval * static_cast<double>(i) + t0;
    double s = lerp(s0, t0, s1, t1, t) + s_dist;
 
    STPoint ptt;
    ptt.set_t(t);
    ptt.set_s(s);
    pt_pairs.push_back(std::move(ptt));
  }
 
  return pt_pairs;
}

GetPathBlockingIntervals() [1/2]

std::vector< std::pair< double, double > > apollo::planning::PathTimeGraph::GetPathBlockingIntervals

(

const double

t

)

const

在文件 path_time_graph.cc 第 216 行定义.

                          {
  ACHECK(time_range_.first <= t && t <= time_range_.second);
  std::vector<std::pair<double, double>> intervals;
  for (const auto& pt_obstacle : path_time_obstacles_) {
    if (t > pt_obstacle.max_t() || t < pt_obstacle.min_t()) {
      continue;
    }
    double s_upper = lerp(pt_obstacle.upper_left_point().s(),
                          pt_obstacle.upper_left_point().t(),
                          pt_obstacle.upper_right_point().s(),
                          pt_obstacle.upper_right_point().t(), t);
 
    double s_lower = lerp(pt_obstacle.bottom_left_point().s(),
                          pt_obstacle.bottom_left_point().t(),
                          pt_obstacle.bottom_right_point().s(),
                          pt_obstacle.bottom_right_point().t(), t);
 
    intervals.emplace_back(s_lower, s_upper);
  }
  return intervals;
}

GetPathBlockingIntervals() [2/2]

std::vector< std::vector< std::pair< double, double > > > apollo::planning::PathTimeGraph::GetPathBlockingIntervals	(	const double	t_start,
		const double	t_end,
		const double	t_resolution
	)

在文件 path_time_graph.cc 第 240 行定义.

                                                                   {
  std::vector<std::vector<std::pair<double, double>>> intervals;
  for (double t = t_start; t <= t_end; t += t_resolution) {
    intervals.push_back(GetPathBlockingIntervals(t));
  }
  return intervals;
}

GetPathTimeObstacle()

bool apollo::planning::PathTimeGraph::GetPathTimeObstacle	(	const std::string &	obstacle_id,
		STBoundary *	path_time_obstacle
	)

在文件 path_time_graph.cc 第 206 行定义.

                                                                        {
  if (path_time_obstacle_map_.find(obstacle_id) ==
      path_time_obstacle_map_.end()) {
    return false;
  }
  *path_time_obstacle = path_time_obstacle_map_[obstacle_id];
  return true;
}

GetPathTimeObstacles()

const std::vector< STBoundary > & apollo::planning::PathTimeGraph::GetPathTimeObstacles

(

)

const

在文件 path_time_graph.cc 第 202 行定义.

                                                                       {
  return path_time_obstacles_;
}

IsObstacleInGraph()

bool apollo::planning::PathTimeGraph::IsObstacleInGraph

(

const std::string &

obstacle_id

)

在文件 path_time_graph.cc 第 309 行定义.

                                                                  {
  return path_time_obstacle_map_.find(obstacle_id) !=
         path_time_obstacle_map_.end();
}

---

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

• modules/planning/planners/lattice/behavior/path_time_graph.h
• modules/planning/planners/lattice/behavior/path_time_graph.cc