apollo::planning::NaviObstacleDecider类 参考

NaviObstacleDecider is used to make appropriate decisions for obstacles around the vehicle in navigation mode. 更多...

#include <navi_obstacle_decider.h>

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

apollo::planning::NaviObstacleDecider 的协作图:

Public 成员函数
	NaviObstacleDecider ()
virtual	~NaviObstacleDecider ()=default
bool	Init (const PlannerNaviConfig &config) override
	Initialization parameters
double	GetNudgeDistance (const std::vector< const Obstacle * > &obstacles, const ReferenceLine &reference_line, const PathDecision &path_decision, const std::vector< common::PathPoint > &path_data_points, const common::VehicleState &vehicle_state, int *lane_obstacles_num)
	get the actual nudgable distance according to the position of the obstacle
void	GetUnsafeObstaclesInfo (const std::vector< common::PathPoint > &path_data_points, const std::vector< const Obstacle * > &obstacles)
	get the unsafe obstacles between trajectory and reference line.
const std::vector< std::tuple< std::string, double, double > > &	UnsafeObstacles ()
	Get unsafe obstacles' ID
Public 成员函数 继承自 apollo::planning::NaviTask
	NaviTask (const std::string &name)
virtual	~NaviTask ()=default
virtual const std::string &	Name () const
virtual apollo::common::Status	Execute (Frame *frame, ReferenceLineInfo *reference_line_info)

额外继承的成员函数
Protected 属性 继承自 apollo::planning::NaviTask
bool	is_init_ = false
Frame *	frame_ = nullptr
ReferenceLineInfo *	reference_line_info_ = nullptr

详细描述

NaviObstacleDecider is used to make appropriate decisions for obstacles around the vehicle in navigation mode.

Note that NaviObstacleDecider 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_obstacle_decider.h 第 53 行定义.

构造及析构函数说明

NaviObstacleDecider()

apollo::planning::NaviObstacleDecider::NaviObstacleDecider

(

)

在文件 navi_obstacle_decider.cc 第 45 行定义.

: NaviTask("NaviObstacleDecider") {}

~NaviObstacleDecider()

virtual apollo::planning::NaviObstacleDecider::~NaviObstacleDecider ( )

virtualdefault

成员函数说明

GetNudgeDistance()

double apollo::planning::NaviObstacleDecider::GetNudgeDistance	(	const std::vector< const Obstacle * > &	obstacles,
		const ReferenceLine &	reference_line,
		const PathDecision &	path_decision,
		const std::vector< common::PathPoint > &	path_data_points,
		const common::VehicleState &	vehicle_state,
		int *	lane_obstacles_num
	)

get the actual nudgable distance according to the position of the obstacle

返回

actual nudgable distance

在文件 navi_obstacle_decider.cc 第 261 行定义.

                                                                      {
  CHECK_NOTNULL(lane_obstacles_num);
 
  // Calculating the left and right nudgeable distance on the lane
  double left_nudge_lane = 0.0;
  double right_nudge_lane = 0.0;
  double routing_y = path_data_points[0].y();
  double min_lane_width = GetMinLaneWidth(path_data_points, reference_line);
 
  ADEBUG << "get min_lane_width: " << min_lane_width;
  if (routing_y <= 0.0) {
    left_nudge_lane = min_lane_width / 2.0 - std::fabs(routing_y) -
                      VehicleParam().left_edge_to_center();
    right_nudge_lane = -1.0 * (min_lane_width / 2.0 + std::fabs(routing_y) -
                               VehicleParam().right_edge_to_center());
  } else {
    left_nudge_lane = min_lane_width / 2.0 + std::fabs(routing_y) -
                      VehicleParam().left_edge_to_center();
    right_nudge_lane = -1.0 * (min_lane_width / 2.0 - std::fabs(routing_y) -
                               VehicleParam().right_edge_to_center());
  }
 
  // Calculating the left and right nudgable distance according to the
  // position of the obstacle.
  double left_nudge_obstacle = 0.0;
  double right_nudge_obstacle = 0.0;
 
  // Calculation of the number of current Lane obstacles
  obstacle_lat_dist_.clear();
  ProcessObstacle(obstacles, path_data_points, path_decision, min_lane_width,
                  vehicle_state);
  for (auto iter = obstacle_lat_dist_.begin(); iter != obstacle_lat_dist_.end();
       ++iter) {
    auto actual_dist = GetObstacleActualOffsetDistance(
        iter, right_nudge_lane, left_nudge_lane, lane_obstacles_num);
    auto lat_dist = iter->second;
    if (actual_dist > config_.min_nudge_distance() &&
        actual_dist < config_.max_nudge_distance()) {
      auto need_nudge_dist = config_.max_nudge_distance() - actual_dist;
      if (lat_dist >= 0.0) {
        right_nudge_obstacle =
            -1.0 * std::max(std::fabs(right_nudge_obstacle), need_nudge_dist);
      } else {
        left_nudge_obstacle =
            std::max(std::fabs(left_nudge_obstacle), need_nudge_dist);
      }
    }
  }
  ADEBUG << "get left_nudge_lane: " << left_nudge_lane
         << "get right_nudge_lane : " << right_nudge_lane
         << "get left_nudge_obstacle: " << left_nudge_obstacle
         << "get right_nudge_obstacle : " << right_nudge_obstacle;
  // Get the appropriate value of the nudge distance
  double nudge_dist = 0.0;
  if (std::fabs(left_nudge_obstacle) > kEpislon &&
      std::fabs(right_nudge_obstacle) <= kEpislon) {
    nudge_dist = std::min(left_nudge_lane, left_nudge_obstacle);
  } else if (std::fabs(right_nudge_obstacle) > kEpislon &&
             std::fabs(left_nudge_obstacle) <= kEpislon) {
    nudge_dist = std::max(right_nudge_lane, right_nudge_obstacle);
  }
 
  ADEBUG << "get nudge distance : " << nudge_dist
         << "get lane_obstacles_num : " << *lane_obstacles_num;
  RecordLastNudgeDistance(nudge_dist);
  SmoothNudgeDistance(vehicle_state, &nudge_dist);
  KeepNudgePosition(nudge_dist, lane_obstacles_num);
  ADEBUG << "last nudge distance : " << nudge_dist;
  return nudge_dist;
}

GetUnsafeObstaclesInfo()

void apollo::planning::NaviObstacleDecider::GetUnsafeObstaclesInfo	(	const std::vector< common::PathPoint > &	path_data_points,
		const std::vector< const Obstacle * > &	obstacles
	)

get the unsafe obstacles between trajectory and reference line.

在文件 navi_obstacle_decider.cc 第 356 行定义.

                                                 {
  // Find start point of the reference line.
  double reference_line_y = path_data_points[0].y();
 
  // Judging unsafed range according to the position of the reference line.
  double unsafe_refline_pos_y = 0.0;
  double unsafe_car_pos_y = 0.0;
  std::pair<double, double> unsafe_range;
  if (reference_line_y < 0.0) {
    unsafe_refline_pos_y = reference_line_y -
                           VehicleParam().right_edge_to_center() -
                           config_.speed_decider_detect_range();
    unsafe_car_pos_y = VehicleParam().right_edge_to_center() +
                       config_.speed_decider_detect_range();
    unsafe_range = std::make_pair(unsafe_refline_pos_y, unsafe_car_pos_y);
  } else {
    unsafe_refline_pos_y = reference_line_y +
                           VehicleParam().left_edge_to_center() +
                           config_.speed_decider_detect_range();
    unsafe_car_pos_y = -1.0 * (VehicleParam().left_edge_to_center() +
                               config_.speed_decider_detect_range());
    unsafe_range = std::make_pair(unsafe_car_pos_y, unsafe_refline_pos_y);
  }
  // Get obstacles'ID.
  unsafe_obstacle_info_.clear();
  PathPoint vehicle_projection_point =
      PathMatcher::MatchToPath(path_data_points, 0, 0);
  for (const auto& iter : obstacles) {
    const double obstacle_y = iter->Perception().position().y();
    if ((obstacle_y > unsafe_range.first && obstacle_y < unsafe_range.second) ||
        std::abs(iter->Perception().velocity().y()) >
            config_.lateral_velocity_value()) {
      auto projection_point = PathMatcher::MatchToPath(
          path_data_points, iter->Perception().position().x(), obstacle_y);
      if (vehicle_projection_point.s() >= projection_point.s()) {
        continue;
      }
      auto front_distance =
          (projection_point.s() - iter->Perception().length() / 2.0) -
          vehicle_projection_point.s();
      auto ref_theta = projection_point.theta();
      auto project_velocity =
          iter->Perception().velocity().x() * std::cos(ref_theta) +
          iter->Perception().velocity().y() * std::sin(ref_theta);
      ADEBUG << "Lateral speed : " << iter->Perception().velocity().y();
      unsafe_obstacle_info_.emplace_back(iter->Id(), front_distance,
                                         project_velocity);
    }
  }
}

Init()

bool apollo::planning::NaviObstacleDecider::Init ( const PlannerNaviConfig &  config )

overridevirtual

Initialization parameters

返回

Initialization success or not

重载 apollo::planning::NaviTask .

在文件 navi_obstacle_decider.cc 第 47 行定义.

                                                              {
  config_ = config.navi_obstacle_decider_config();
  return true;
}

UnsafeObstacles()

const std::vector< std::tuple< std::string, double, double > > & apollo::planning::NaviObstacleDecider::UnsafeObstacles ( )

inline

Get unsafe obstacles' ID

返回

unsafe_obstacle_ID_

在文件 navi_obstacle_decider.h 第 191 行定义.

                                     {
  return unsafe_obstacle_info_;
}

---

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

• modules/planning/planners/navi/decider/navi_obstacle_decider.h
• modules/planning/planners/navi/decider/navi_obstacle_decider.cc