This is the class that associates an Obstacle with its path properties. 更多...

#include <obstacle.h>

apollo::planning::Obstacle 的协作图:

Public 成员函数
	Obstacle ()=default

	Obstacle (const std::string &id, const perception::PerceptionObstacle &perception_obstacle, const prediction::ObstaclePriority::Priority &obstacle_priority, const bool is_static)

	Obstacle (const std::string &id, const perception::PerceptionObstacle &perception_obstacle, const prediction::Trajectory &trajectory, const prediction::ObstaclePriority::Priority &obstacle_priority, const bool is_static)

const std::string &	Id () const

void	SetId (const std::string &id)

double	speed () const

int32_t	PerceptionId () const

bool	IsStatic () const

bool	IsVirtual () const

common::TrajectoryPoint	GetPointAtTime (const double time) const

common::math::Box2d	GetBoundingBox (const common::TrajectoryPoint &point) const

const common::math::Box2d &	PerceptionBoundingBox () const

const common::math::Polygon2d &	PerceptionPolygon () const

const prediction::Trajectory &	Trajectory () const

bool	HasTrajectory () const

const perception::PerceptionObstacle &	Perception () const

bool	IsCautionLevelObstacle () const

const ObjectDecisionType &	LateralDecision () const
	return the merged lateral decision Lateral decision is one of {Nudge, Ignore}

const ObjectDecisionType &	LongitudinalDecision () const
	return the merged longitudinal decision Longitudinal decision is one of {Stop, Yield, Follow, Overtake, Ignore}

std::string	DebugString () const

void	PrintPolygonCurve () const

const SLBoundary &	PerceptionSLBoundary () const

const STBoundary &	reference_line_st_boundary () const

const STBoundary &	path_st_boundary () const

const std::vector< std::string > &	decider_tags () const

const std::vector< ObjectDecisionType > &	decisions () const

void	AddLongitudinalDecision (const std::string &decider_tag, const ObjectDecisionType &decision)

void	AddLateralDecision (const std::string &decider_tag, const ObjectDecisionType &decision)

bool	HasLateralDecision () const

void	set_path_st_boundary (const STBoundary &boundary)

bool	is_path_st_boundary_initialized ()

void	SetStBoundaryType (const STBoundary::BoundaryType type)

void	EraseStBoundary ()

void	EraseDecision ()

void	SetReferenceLineStBoundary (const STBoundary &boundary)

void	SetReferenceLineStBoundaryType (const STBoundary::BoundaryType type)

void	EraseReferenceLineStBoundary ()

bool	HasLongitudinalDecision () const

bool	HasNonIgnoreDecision () const

double	MinRadiusStopDistance (const common::VehicleParam &vehicle_param) const
	Calculate stop distance with the obstacle using the ADC's minimum turning radius

bool	IsIgnore () const
	Check if this object can be safely ignored.

bool	IsLongitudinalIgnore () const

bool	IsLateralIgnore () const

void	BuildReferenceLineStBoundary (const ReferenceLine &reference_line, const double adc_start_s)

void	SetPerceptionSlBoundary (const SLBoundary &sl_boundary)

void	SetBlockingObstacle (bool blocking)

bool	IsBlockingObstacle () const

bool	IsLaneBlocking () const

void	CheckLaneBlocking (const ReferenceLine &reference_line)

bool	IsLaneChangeBlocking () const

void	SetLaneChangeBlocking (const bool is_distance_clear)

common::math::Polygon2d	GetObstacleTrajectoryPolygon (const common::TrajectoryPoint &point) const

静态 Public 成员函数
static std::list< std::unique_ptr< Obstacle > >	CreateObstacles (const prediction::PredictionObstacles &predictions)
	This is a helper function that can create obstacles from prediction data.

static std::unique_ptr< Obstacle >	CreateStaticVirtualObstacles (const std::string &id, const common::math::Box2d &obstacle_box)

static bool	IsValidPerceptionObstacle (const perception::PerceptionObstacle &obstacle)

static bool	IsValidTrajectoryPoint (const common::TrajectoryPoint &point)

static bool	IsLongitudinalDecision (const ObjectDecisionType &decision)
	check if an ObjectDecisionType is a longitudinal decision.

static bool	IsLateralDecision (const ObjectDecisionType &decision)
	check if an ObjectDecisionType is a lateral decision.

详细描述

This is the class that associates an Obstacle with its path properties.

An obstacle's path properties relative to a path. The s and l values are examples of path properties. The decision of an obstacle is also associated with a path.

The decisions have two categories: lateral decision and longitudinal decision. Lateral decision includes: nudge, ignore. Lateral decision safety priority: nudge > ignore. Longitudinal decision includes: stop, yield, follow, overtake, ignore. Decision safety priorities order: stop > yield >= follow > overtake > ignore

Ignore decision belongs to both lateral decision and longitudinal decision, and it has the lowest priority.

在文件 obstacle.h 第 62 行定义.

构造及析构函数说明

◆ Obstacle() [1/3]

apollo::planning::Obstacle::Obstacle ( )

default

◆ Obstacle() [2/3]

apollo::planning::Obstacle::Obstacle	(	const std::string &	id,
		const perception::PerceptionObstacle &	perception_obstacle,
		const prediction::ObstaclePriority::Priority &	obstacle_priority,
		const bool	is_static
	)

在文件 obstacle.cc 第 63 行定义.

    : id_(id),
      perception_id_(perception_obstacle.id()),
      perception_obstacle_(perception_obstacle),
      perception_bounding_box_({perception_obstacle_.position().x(),
                                perception_obstacle_.position().y()},
                               perception_obstacle_.theta(),
                               perception_obstacle_.length(),
                               perception_obstacle_.width()) {
  is_caution_level_obstacle_ = (obstacle_priority == ObstaclePriority::CAUTION);
  std::vector<common::math::Vec2d> polygon_points;
  if (FLAGS_use_navigation_mode ||
      perception_obstacle.polygon_point_size() <= 2) {
    perception_bounding_box_.GetAllCorners(&polygon_points);
  } else {
    ACHECK(perception_obstacle.polygon_point_size() > 2)
        << "object " << id << "has less than 3 polygon points";
    for (const auto& point : perception_obstacle.polygon_point()) {
      polygon_points.emplace_back(point.x(), point.y());
    }
  }
  ACHECK(common::math::Polygon2d::ComputeConvexHull(polygon_points,
                                                    &perception_polygon_))
      << "object[" << id << "] polygon is not a valid convex hull.\n"
      << perception_obstacle.DebugString();
 
  is_static_ = (is_static || obstacle_priority == ObstaclePriority::IGNORE);
  is_virtual_ = (perception_obstacle.id() < 0);
  speed_ = std::hypot(perception_obstacle.velocity().x(),
                      perception_obstacle.velocity().y());
}

◆ Obstacle() [3/3]

apollo::planning::Obstacle::Obstacle	(	const std::string &	id,
		const perception::PerceptionObstacle &	perception_obstacle,
		const prediction::Trajectory &	trajectory,
		const prediction::ObstaclePriority::Priority &	obstacle_priority,
		const bool	is_static
	)

在文件 obstacle.cc 第 98 行定义.

    : Obstacle(id, perception_obstacle, obstacle_priority, is_static) {
  trajectory_ = trajectory;
  auto& trajectory_points = *trajectory_.mutable_trajectory_point();
  double cumulative_s = 0.0;
  if (trajectory_points.size() > 0) {
    trajectory_points[0].mutable_path_point()->set_s(0.0);
  }
  for (int i = 1; i < trajectory_points.size(); ++i) {
    const auto& prev = trajectory_points[i - 1];
    const auto& cur = trajectory_points[i];
    if (prev.relative_time() >= cur.relative_time()) {
      AERROR << "prediction time is not increasing."
             << "current point: " << cur.ShortDebugString()
             << "previous point: " << prev.ShortDebugString();
    }
    cumulative_s +=
        common::util::DistanceXY(prev.path_point(), cur.path_point());
    trajectory_points[i].mutable_path_point()->set_s(cumulative_s);
  }
}

成员函数说明

◆ AddLateralDecision()

void apollo::planning::Obstacle::AddLateralDecision	(	const std::string &	decider_tag,
		const ObjectDecisionType &	decision
	)

在文件 obstacle.cc 第 661 行定义.

                                                                      {
  DCHECK(IsLateralDecision(decision))
      << "Decision: " << decision.ShortDebugString()
      << " is not a lateral decision";
  lateral_decision_ = MergeLateralDecision(lateral_decision_, decision);
  ADEBUG << decider_tag << " added obstacle " << Id()
         << " a lateral decision: " << decision.ShortDebugString()
         << ". The merged decision is: "
         << lateral_decision_.ShortDebugString();
  decisions_.push_back(decision);
  decider_tags_.push_back(decider_tag);
}

◆ AddLongitudinalDecision()

void apollo::planning::Obstacle::AddLongitudinalDecision	(	const std::string &	decider_tag,
		const ObjectDecisionType &	decision
	)

在文件 obstacle.cc 第 646 行定义.

                                                                           {
  DCHECK(IsLongitudinalDecision(decision))
      << "Decision: " << decision.ShortDebugString()
      << " is not a longitudinal decision";
  longitudinal_decision_ =
      MergeLongitudinalDecision(longitudinal_decision_, decision);
  ADEBUG << decider_tag << " added obstacle " << Id()
         << " longitudinal decision: " << decision.ShortDebugString()
         << ". The merged decision is: "
         << longitudinal_decision_.ShortDebugString();
  decisions_.push_back(decision);
  decider_tags_.push_back(decider_tag);
}

◆ BuildReferenceLineStBoundary()

void apollo::planning::Obstacle::BuildReferenceLineStBoundary	(	const ReferenceLine &	reference_line,
		const double	adc_start_s
	)

在文件 obstacle.cc 第 316 行定义.

                                                                      {
  const auto& adc_param =
      VehicleConfigHelper::Instance()->GetConfig().vehicle_param();
  const double half_adc_width = adc_param.width() / 2;
  if (is_static_ || trajectory_.trajectory_point().empty()) {
    std::vector<std::pair<STPoint, STPoint>> point_pairs;
    double start_s = sl_boundary_.start_s();
    double end_s = sl_boundary_.end_s();
    if (end_s - start_s < kStBoundaryDeltaS) {
      end_s = start_s + kStBoundaryDeltaS;
    }
    if (!reference_line.IsBlockRoad(perception_bounding_box_, half_adc_width)) {
      return;
    }
    point_pairs.emplace_back(STPoint(start_s - adc_start_s, 0.0),
                             STPoint(end_s - adc_start_s, 0.0));
    point_pairs.emplace_back(STPoint(start_s - adc_start_s, FLAGS_st_max_t),
                             STPoint(end_s - adc_start_s, FLAGS_st_max_t));
    reference_line_st_boundary_ = STBoundary(point_pairs);
  } else {
    if (BuildTrajectoryStBoundary(reference_line, adc_start_s,
                                  &reference_line_st_boundary_)) {
      ADEBUG << "Found st_boundary for obstacle " << id_;
      ADEBUG << "st_boundary: min_t = " << reference_line_st_boundary_.min_t()
             << ", max_t = " << reference_line_st_boundary_.max_t()
             << ", min_s = " << reference_line_st_boundary_.min_s()
             << ", max_s = " << reference_line_st_boundary_.max_s();
    } else {
      ADEBUG << "No st_boundary for obstacle " << id_;
    }
  }
}

◆ CheckLaneBlocking()

void apollo::planning::Obstacle::CheckLaneBlocking ( const ReferenceLine & reference_line )

在文件 obstacle.cc 第 739 行定义.

                                                                    {
  if (!IsStatic()) {
    is_lane_blocking_ = false;
    return;
  }
  DCHECK(sl_boundary_.has_start_s());
  DCHECK(sl_boundary_.has_end_s());
  DCHECK(sl_boundary_.has_start_l());
  DCHECK(sl_boundary_.has_end_l());
 
  if (sl_boundary_.start_l() * sl_boundary_.end_l() < 0.0) {
    is_lane_blocking_ = true;
    return;
  }
 
  const double driving_width = reference_line.GetDrivingWidth(sl_boundary_);
  auto vehicle_param = common::VehicleConfigHelper::GetConfig().vehicle_param();
 
  if (reference_line.IsOnLane(sl_boundary_) &&
      driving_width <
          vehicle_param.width() + FLAGS_static_obstacle_nudge_l_buffer) {
    is_lane_blocking_ = true;
    return;
  }
 
  is_lane_blocking_ = false;
}

◆ CreateObstacles()

std::list< std::unique_ptr< Obstacle > > apollo::planning::Obstacle::CreateObstacles ( const prediction::PredictionObstacles & predictions )

static

This is a helper function that can create obstacles from prediction data.

The original prediction may have multiple trajectories for each obstacle. But this function will create one obstacle for each trajectory.

参数

predictions The prediction results

返回: obstacles The output obstacles saved in a list of unique_ptr.

在文件 obstacle.cc 第 197 行定义.

                                                      {
  std::list<std::unique_ptr<Obstacle>> obstacles;
  for (const auto& prediction_obstacle : predictions.prediction_obstacle()) {
    if (!IsValidPerceptionObstacle(prediction_obstacle.perception_obstacle())) {
      AERROR << "Invalid perception obstacle: "
             << prediction_obstacle.perception_obstacle().DebugString();
      continue;
    }
    const auto perception_id =
        std::to_string(prediction_obstacle.perception_obstacle().id());
    if (prediction_obstacle.trajectory().empty()) {
      obstacles.emplace_back(
          new Obstacle(perception_id, prediction_obstacle.perception_obstacle(),
                       prediction_obstacle.priority().priority(),
                       prediction_obstacle.is_static()));
      continue;
    }
 
    int trajectory_index = 0;
    for (const auto& trajectory : prediction_obstacle.trajectory()) {
      bool is_valid_trajectory = true;
      for (const auto& point : trajectory.trajectory_point()) {
        if (!IsValidTrajectoryPoint(point)) {
          AERROR << "obj:" << perception_id
                 << " TrajectoryPoint: " << trajectory.ShortDebugString()
                 << " is NOT valid.";
          is_valid_trajectory = false;
          break;
        }
      }
      if (!is_valid_trajectory) {
        continue;
      }
 
      const std::string obstacle_id =
          absl::StrCat(perception_id, "_", trajectory_index);
      obstacles.emplace_back(
          new Obstacle(obstacle_id, prediction_obstacle.perception_obstacle(),
                       trajectory, prediction_obstacle.priority().priority(),
                       prediction_obstacle.is_static()));
      ++trajectory_index;
    }
  }
  return obstacles;
}

◆ CreateStaticVirtualObstacles()

std::unique_ptr< Obstacle > apollo::planning::Obstacle::CreateStaticVirtualObstacles	(	const std::string &	id,
		const common::math::Box2d &	obstacle_box
	)

static

在文件 obstacle.cc 第 244 行定义.

                                                              {
  // create a "virtual" perception_obstacle
  perception::PerceptionObstacle perception_obstacle;
  // simulator needs a valid integer
  size_t negative_id = std::hash<std::string>{}(id);
  // set the first bit to 1 so negative_id became negative number
  negative_id |= (0x1 << 31);
  perception_obstacle.set_id(static_cast<int32_t>(negative_id));
  perception_obstacle.mutable_position()->set_x(obstacle_box.center().x());
  perception_obstacle.mutable_position()->set_y(obstacle_box.center().y());
  perception_obstacle.set_theta(obstacle_box.heading());
  perception_obstacle.mutable_velocity()->set_x(0);
  perception_obstacle.mutable_velocity()->set_y(0);
  perception_obstacle.set_length(obstacle_box.length());
  perception_obstacle.set_width(obstacle_box.width());
  perception_obstacle.set_height(FLAGS_virtual_stop_wall_height);
  perception_obstacle.set_type(
      perception::PerceptionObstacle::UNKNOWN_UNMOVABLE);
  perception_obstacle.set_tracking_time(1.0);
 
  std::vector<common::math::Vec2d> corner_points;
  obstacle_box.GetAllCorners(&corner_points);
  for (const auto& corner_point : corner_points) {
    auto* point = perception_obstacle.add_polygon_point();
    point->set_x(corner_point.x());
    point->set_y(corner_point.y());
  }
  auto* obstacle =
      new Obstacle(id, perception_obstacle, ObstaclePriority::NORMAL, true);
  obstacle->is_virtual_ = true;
  return std::unique_ptr<Obstacle>(obstacle);
}

◆ DebugString()

std::string apollo::planning::Obstacle::DebugString ( ) const

在文件 obstacle.cc 第 675 行定义.

                                      {
  std::stringstream ss;
  ss << "Obstacle id: " << id_;
  for (size_t i = 0; i < decisions_.size(); ++i) {
    ss << " decision: " << decisions_[i].DebugString() << ", made by "
       << decider_tags_[i];
  }
  if (lateral_decision_.object_tag_case() !=
      ObjectDecisionType::OBJECT_TAG_NOT_SET) {
    ss << "lateral decision: " << lateral_decision_.ShortDebugString();
  }
  if (longitudinal_decision_.object_tag_case() !=
      ObjectDecisionType::OBJECT_TAG_NOT_SET) {
    ss << "longitudinal decision: "
       << longitudinal_decision_.ShortDebugString();
  }
  return ss.str();
}

◆ decider_tags()

const std::vector< std::string > & apollo::planning::Obstacle::decider_tags ( ) const

在文件 obstacle.cc 第 525 行定义.

                                                         {
  return decider_tags_;
}

◆ decisions()

const std::vector< ObjectDecisionType > & apollo::planning::Obstacle::decisions ( ) const

在文件 obstacle.cc 第 529 行定义.

                                                               {
  return decisions_;
}

◆ EraseDecision()

void apollo::planning::Obstacle::EraseDecision ( )

在文件 obstacle.cc 第 709 行定义.

                             {
  lateral_decision_.Clear();
  longitudinal_decision_.Clear();
  decider_tags_.clear();
}

◆ EraseReferenceLineStBoundary()

void apollo::planning::Obstacle::EraseReferenceLineStBoundary ( )

在文件 obstacle.cc 第 724 行定义.

                                            {
  reference_line_st_boundary_ = STBoundary();
}

◆ EraseStBoundary()

void apollo::planning::Obstacle::EraseStBoundary ( )

在文件 obstacle.cc 第 707 行定义.

707{ path_st_boundary_ = STBoundary(); }

◆ GetBoundingBox()

common::math::Box2d apollo::planning::Obstacle::GetBoundingBox ( const common::TrajectoryPoint & point ) const

在文件 obstacle.cc 第 159 行定义.

                                              {
  return common::math::Box2d({point.path_point().x(), point.path_point().y()},
                             point.path_point().theta(),
                             perception_obstacle_.length(),
                             perception_obstacle_.width());
}

◆ GetObstacleTrajectoryPolygon()

common::math::Polygon2d apollo::planning::Obstacle::GetObstacleTrajectoryPolygon ( const common::TrajectoryPoint & point ) const

在文件 obstacle.cc 第 773 行定义.

                                              {
  double delta_heading =
      point.path_point().theta() - perception_obstacle_.theta();
  double cos_delta_heading = cos(delta_heading);
  double sin_delta_heading = sin(delta_heading);
  std::vector<common::math::Vec2d> polygon_point;
  polygon_point.reserve(perception_polygon_.points().size());
 
  for (auto& iter : perception_polygon_.points()) {
    double relative_x = iter.x() - perception_obstacle_.position().x();
    double relative_y = iter.y() - perception_obstacle_.position().y();
    double x = relative_x * cos_delta_heading - relative_y * sin_delta_heading +
               point.path_point().x();
    double y = relative_x * sin_delta_heading + relative_y * cos_delta_heading +
               point.path_point().y();
    polygon_point.emplace_back(x, y);
  }
 
  common::math::Polygon2d trajectory_point_polygon(polygon_point);
  return trajectory_point_polygon;
}

◆ GetPointAtTime()

common::TrajectoryPoint apollo::planning::Obstacle::GetPointAtTime ( const double time ) const

在文件 obstacle.cc 第 124 行定义.

                                      {
  const auto& points = trajectory_.trajectory_point();
  if (points.size() < 2) {
    common::TrajectoryPoint point;
    point.mutable_path_point()->set_x(perception_obstacle_.position().x());
    point.mutable_path_point()->set_y(perception_obstacle_.position().y());
    point.mutable_path_point()->set_z(perception_obstacle_.position().z());
    point.mutable_path_point()->set_theta(perception_obstacle_.theta());
    point.mutable_path_point()->set_s(0.0);
    point.mutable_path_point()->set_kappa(0.0);
    point.mutable_path_point()->set_dkappa(0.0);
    point.mutable_path_point()->set_ddkappa(0.0);
    point.set_v(0.0);
    point.set_a(0.0);
    point.set_relative_time(0.0);
    return point;
  } else {
    auto comp = [](const common::TrajectoryPoint p, const double time) {
      return p.relative_time() < time;
    };
 
    auto it_lower =
        std::lower_bound(points.begin(), points.end(), relative_time, comp);
 
    if (it_lower == points.begin()) {
      return *points.begin();
    } else if (it_lower == points.end()) {
      return *points.rbegin();
    }
    return common::math::InterpolateUsingLinearApproximation(
        *(it_lower - 1), *it_lower, relative_time);
  }
}

◆ HasLateralDecision()

bool apollo::planning::Obstacle::HasLateralDecision ( ) const

在文件 obstacle.cc 第 631 行定义.

                                        {
  return lateral_decision_.object_tag_case() !=
         ObjectDecisionType::OBJECT_TAG_NOT_SET;
}

◆ HasLongitudinalDecision()

bool apollo::planning::Obstacle::HasLongitudinalDecision ( ) const

在文件 obstacle.cc 第 636 行定义.

                                             {
  return longitudinal_decision_.object_tag_case() !=
         ObjectDecisionType::OBJECT_TAG_NOT_SET;
}

◆ HasNonIgnoreDecision()

bool apollo::planning::Obstacle::HasNonIgnoreDecision ( ) const

在文件 obstacle.cc 第 641 行定义.

                                          {
  return (HasLateralDecision() && !IsLateralIgnore()) ||
         (HasLongitudinalDecision() && !IsLongitudinalIgnore());
}

◆ HasTrajectory()

bool apollo::planning::Obstacle::HasTrajectory ( ) const

inline

在文件 obstacle.h 第 98 行定义.

                             {
    return !(trajectory_.trajectory_point().empty());
  }

◆ Id()

const std::string & apollo::planning::Obstacle::Id ( ) const

inline

在文件 obstacle.h 第 75 行定义.

75{ return id_; }

◆ is_path_st_boundary_initialized()

bool apollo::planning::Obstacle::is_path_st_boundary_initialized ( )

inline

在文件 obstacle.h 第 165 行定义.

                                         {
    return path_st_boundary_initialized_;
  }

◆ IsBlockingObstacle()

bool apollo::planning::Obstacle::IsBlockingObstacle ( ) const

inline

在文件 obstacle.h 第 217 行定义.

217{ return is_blocking_obstacle_; }

◆ IsCautionLevelObstacle()

bool apollo::planning::Obstacle::IsCautionLevelObstacle ( ) const

inline

在文件 obstacle.h 第 124 行定义.

                                             {
    return is_caution_level_obstacle_;
  }

◆ IsIgnore()

bool apollo::planning::Obstacle::IsIgnore ( ) const

Check if this object can be safely ignored.

The object will be ignored if the lateral decision is ignore and the longitudinal decision is ignore return longitudinal_decision_ == ignore && lateral_decision == ignore.

在文件 obstacle.cc 第 585 行定义.

                              {
  return IsLongitudinalIgnore() && IsLateralIgnore();
}

◆ IsLaneBlocking()

bool apollo::planning::Obstacle::IsLaneBlocking ( ) const

inline

在文件 obstacle.h 第 222 行定义.

222{ return is_lane_blocking_; }

◆ IsLaneChangeBlocking()

bool apollo::planning::Obstacle::IsLaneChangeBlocking ( ) const

inline

在文件 obstacle.h 第 224 行定义.

224{ return is_lane_change_blocking_; }

◆ IsLateralDecision()

bool apollo::planning::Obstacle::IsLateralDecision ( const ObjectDecisionType & decision )

static

check if an ObjectDecisionType is a lateral decision.

在文件 obstacle.cc 第 533 行定义.

                                                                   {
  return decision.has_ignore() || decision.has_nudge();
}

◆ IsLateralIgnore()

bool apollo::planning::Obstacle::IsLateralIgnore ( ) const

在文件 obstacle.cc 第 593 行定义.

                                     {
  return lateral_decision_.has_ignore();
}

◆ IsLongitudinalDecision()

bool apollo::planning::Obstacle::IsLongitudinalDecision ( const ObjectDecisionType & decision )

static

check if an ObjectDecisionType is a longitudinal decision.

在文件 obstacle.cc 第 537 行定义.

                                                                        {
  return decision.has_ignore() || decision.has_stop() || decision.has_yield() ||
         decision.has_follow() || decision.has_overtake();
}

◆ IsLongitudinalIgnore()

bool apollo::planning::Obstacle::IsLongitudinalIgnore ( ) const

在文件 obstacle.cc 第 589 行定义.

                                          {
  return longitudinal_decision_.has_ignore();
}

◆ IsStatic()

bool apollo::planning::Obstacle::IsStatic ( ) const

inline

在文件 obstacle.h 第 82 行定义.

82{ return is_static_; }

◆ IsValidPerceptionObstacle()

bool apollo::planning::Obstacle::IsValidPerceptionObstacle ( const perception::PerceptionObstacle & obstacle )

static

在文件 obstacle.cc 第 167 行定义.

                                                                           {
  if (obstacle.length() <= 0.0) {
    AERROR << "invalid obstacle length:" << obstacle.length();
    return false;
  }
  if (obstacle.width() <= 0.0) {
    AERROR << "invalid obstacle width:" << obstacle.width();
    return false;
  }
  if (obstacle.height() <= 0.0) {
    AERROR << "invalid obstacle height:" << obstacle.height();
    return false;
  }
  if (obstacle.has_velocity()) {
    if (std::isnan(obstacle.velocity().x()) ||
        std::isnan(obstacle.velocity().y())) {
      AERROR << "invalid obstacle velocity:"
             << obstacle.velocity().DebugString();
      return false;
    }
  }
  for (auto pt : obstacle.polygon_point()) {
    if (std::isnan(pt.x()) || std::isnan(pt.y())) {
      AERROR << "invalid obstacle polygon point:" << pt.DebugString();
      return false;
    }
  }
  return true;
}

◆ IsValidTrajectoryPoint()

bool apollo::planning::Obstacle::IsValidTrajectoryPoint ( const common::TrajectoryPoint & point )

static

在文件 obstacle.cc 第 278 行定义.

                                                                        {
  return !((!point.has_path_point()) || std::isnan(point.path_point().x()) ||
           std::isnan(point.path_point().y()) ||
           std::isnan(point.path_point().z()) ||
           std::isnan(point.path_point().kappa()) ||
           std::isnan(point.path_point().s()) ||
           std::isnan(point.path_point().dkappa()) ||
           std::isnan(point.path_point().ddkappa()) || std::isnan(point.v()) ||
           std::isnan(point.a()) || std::isnan(point.relative_time()));
}

◆ IsVirtual()

bool apollo::planning::Obstacle::IsVirtual ( ) const

inline

在文件 obstacle.h 第 83 行定义.

83{ return is_virtual_; }

◆ LateralDecision()

const ObjectDecisionType & apollo::planning::Obstacle::LateralDecision ( ) const

return the merged lateral decision Lateral decision is one of {Nudge, Ignore}

在文件 obstacle.cc 第 581 行定义.

                                                          {
  return lateral_decision_;
}

◆ LongitudinalDecision()

const ObjectDecisionType & apollo::planning::Obstacle::LongitudinalDecision ( ) const

return the merged longitudinal decision Longitudinal decision is one of {Stop, Yield, Follow, Overtake, Ignore}

在文件 obstacle.cc 第 577 行定义.

                                                               {
  return longitudinal_decision_;
}

◆ MinRadiusStopDistance()

double apollo::planning::Obstacle::MinRadiusStopDistance ( const common::VehicleParam & vehicle_param ) const

Calculate stop distance with the obstacle using the ADC's minimum turning radius

在文件 obstacle.cc 第 293 行定义.

                                                   {
  if (min_radius_stop_distance_ > 0) {
    return min_radius_stop_distance_;
  }
  static constexpr double stop_distance_buffer = 0.5;
  const double min_turn_radius = VehicleConfigHelper::MinSafeTurnRadius();
  double lateral_diff =
      vehicle_param.width() / 2.0 + std::max(std::fabs(sl_boundary_.start_l()),
                                             std::fabs(sl_boundary_.end_l()));
  const double kEpison = 1e-5;
  lateral_diff = std::min(lateral_diff, min_turn_radius - kEpison);
  double stop_distance =
      std::sqrt(std::fabs(min_turn_radius * min_turn_radius -
                          (min_turn_radius - lateral_diff) *
                              (min_turn_radius - lateral_diff))) +
      stop_distance_buffer;
  stop_distance -= vehicle_param.front_edge_to_center();
  stop_distance = std::min(stop_distance, FLAGS_max_stop_distance_obstacle);
  stop_distance = std::max(stop_distance, FLAGS_min_stop_distance_obstacle);
  return stop_distance;
}

◆ path_st_boundary()

const STBoundary & apollo::planning::Obstacle::path_st_boundary ( ) const

在文件 obstacle.cc 第 521 行定义.

                                                   {
  return path_st_boundary_;
}

◆ Perception()

const perception::PerceptionObstacle & apollo::planning::Obstacle::Perception ( ) const

inline

在文件 obstacle.h 第 102 行定义.

                                                         {
    return perception_obstacle_;
  }

◆ PerceptionBoundingBox()

const common::math::Box2d & apollo::planning::Obstacle::PerceptionBoundingBox ( ) const

inline

在文件 obstacle.h 第 90 行定义.

                                                       {
    return perception_bounding_box_;
  }

◆ PerceptionId()

int32_t apollo::planning::Obstacle::PerceptionId ( ) const

inline

在文件 obstacle.h 第 80 行定义.

80{ return perception_id_; }

◆ PerceptionPolygon()

const common::math::Polygon2d & apollo::planning::Obstacle::PerceptionPolygon ( ) const

inline

在文件 obstacle.h 第 93 行定义.

                                                       {
    return perception_polygon_;
  }

◆ PerceptionSLBoundary()

const SLBoundary & apollo::planning::Obstacle::PerceptionSLBoundary ( ) const

在文件 obstacle.cc 第 694 行定义.

                                                       {
  return sl_boundary_;
}

◆ PrintPolygonCurve()

void apollo::planning::Obstacle::PrintPolygonCurve ( ) const

在文件 obstacle.cc 第 796 行定义.

                                       {
  if (perception_polygon_.points().size() < 1) {
    return;
  }
 
  PrintCurves print_curve;
  for (const auto& p : perception_polygon_.points()) {
    print_curve.AddPoint(id_ + "_ObsPolygon", p.x(), p.y());
  }
  print_curve.AddPoint(id_ + "_ObsPolygon", perception_polygon_.points()[0].x(),
                       perception_polygon_.points()[0].y());
  print_curve.PrintToLog();
}

◆ reference_line_st_boundary()

const STBoundary & apollo::planning::Obstacle::reference_line_st_boundary ( ) const

在文件 obstacle.cc 第 517 行定义.

                                                             {
  return reference_line_st_boundary_;
}

◆ set_path_st_boundary()

void apollo::planning::Obstacle::set_path_st_boundary ( const STBoundary & boundary )

在文件 obstacle.cc 第 698 行定义.

                                                              {
  path_st_boundary_ = boundary;
  path_st_boundary_initialized_ = true;
}

◆ SetBlockingObstacle()

void apollo::planning::Obstacle::SetBlockingObstacle ( bool blocking )

inline

在文件 obstacle.h 第 216 行定义.

216{ is_blocking_obstacle_ = blocking; }

◆ SetId()

void apollo::planning::Obstacle::SetId ( const std::string & id )

inline

在文件 obstacle.h 第 76 行定义.

76{ id_ = id; }

◆ SetLaneChangeBlocking()

void apollo::planning::Obstacle::SetLaneChangeBlocking ( const bool is_distance_clear )

在文件 obstacle.cc 第 767 行定义.

                                                                 {
  is_lane_change_blocking_ = is_distance_clear;
}

◆ SetPerceptionSlBoundary()

void apollo::planning::Obstacle::SetPerceptionSlBoundary ( const SLBoundary & sl_boundary )

在文件 obstacle.cc 第 289 行定义.

                                                                    {
  sl_boundary_ = sl_boundary;
}

◆ SetReferenceLineStBoundary()

void apollo::planning::Obstacle::SetReferenceLineStBoundary ( const STBoundary & boundary )

在文件 obstacle.cc 第 715 行定义.

                                                                    {
  reference_line_st_boundary_ = boundary;
}

◆ SetReferenceLineStBoundaryType()

void apollo::planning::Obstacle::SetReferenceLineStBoundaryType ( const STBoundary::BoundaryType type )

在文件 obstacle.cc 第 719 行定义.

                                       {
  reference_line_st_boundary_.SetBoundaryType(type);
}

◆ SetStBoundaryType()

void apollo::planning::Obstacle::SetStBoundaryType ( const STBoundary::BoundaryType type )

在文件 obstacle.cc 第 703 行定义.

                                                                  {
  path_st_boundary_.SetBoundaryType(type);
}

◆ speed()

double apollo::planning::Obstacle::speed ( ) const

inline

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

78{ return speed_; }

◆ Trajectory()

const prediction::Trajectory & apollo::planning::Obstacle::Trajectory ( ) const

inline

在文件 obstacle.h 第 96 行定义.

96{ return trajectory_; }

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

modules/planning/planning_base/common/obstacle.h
modules/planning/planning_base/common/obstacle.cc

Public 成员函数

静态 Public 成员函数

详细描述

构造及析构函数说明

◆ Obstacle() [1/3]

◆ Obstacle() [2/3]

◆ Obstacle() [3/3]

成员函数说明

◆ AddLateralDecision()

◆ AddLongitudinalDecision()

◆ BuildReferenceLineStBoundary()

◆ CheckLaneBlocking()

◆ CreateObstacles()

◆ CreateStaticVirtualObstacles()

◆ DebugString()

◆ decider_tags()

◆ decisions()

◆ EraseDecision()

◆ EraseReferenceLineStBoundary()

◆ EraseStBoundary()

◆ GetBoundingBox()

◆ GetObstacleTrajectoryPolygon()

◆ GetPointAtTime()

◆ HasLateralDecision()

◆ HasLongitudinalDecision()

◆ HasNonIgnoreDecision()

◆ HasTrajectory()

◆ Id()

◆ is_path_st_boundary_initialized()

◆ IsBlockingObstacle()

◆ IsCautionLevelObstacle()

◆ IsIgnore()

◆ IsLaneBlocking()

◆ IsLaneChangeBlocking()

◆ IsLateralDecision()

◆ IsLateralIgnore()

◆ IsLongitudinalDecision()

◆ IsLongitudinalIgnore()

◆ IsStatic()

◆ IsValidPerceptionObstacle()

◆ IsValidTrajectoryPoint()

◆ IsVirtual()

◆ LateralDecision()

◆ LongitudinalDecision()

◆ MinRadiusStopDistance()

◆ path_st_boundary()

◆ Perception()

◆ PerceptionBoundingBox()

◆ PerceptionId()

◆ PerceptionPolygon()

◆ PerceptionSLBoundary()

◆ PrintPolygonCurve()

◆ reference_line_st_boundary()

◆ set_path_st_boundary()

◆ SetBlockingObstacle()

◆ SetId()

◆ SetLaneChangeBlocking()

◆ SetPerceptionSlBoundary()

◆ SetReferenceLineStBoundary()

◆ SetReferenceLineStBoundaryType()

◆ SetStBoundaryType()

◆ speed()

◆ Trajectory()