apollo::planning::STBoundary类 参考

#include <st_boundary.h>

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

apollo::planning::STBoundary 的协作图:

Public 类型
enum class	BoundaryType {   UNKNOWN , STOP , FOLLOW , YIELD ,   OVERTAKE , KEEP_CLEAR }

Public 成员函数
	STBoundary ()=default
	Constructors: STBoundary must be initialized with a vector of ST-point pairs.
	STBoundary (const std::vector< std::pair< STPoint, STPoint > > &point_pairs, bool is_accurate_boundary=false)
	STBoundary (const common::math::Box2d &box)=delete
	STBoundary (std::vector< common::math::Vec2d > points)=delete
	~STBoundary ()=default
	Default destructor.
bool	IsEmpty () const
bool	GetUnblockSRange (const double curr_time, double *s_upper, double *s_lower) const
bool	GetBoundarySRange (const double curr_time, double *s_upper, double *s_lower) const
bool	GetBoundarySlopes (const double curr_time, double *ds_upper, double *ds_lower) const
void	PrintDebug (std::string suffix="") const
BoundaryType	boundary_type () const
const std::string &	id () const
double	characteristic_length () const
void	set_id (const std::string &id)
void	SetBoundaryType (const BoundaryType &boundary_type)
void	SetCharacteristicLength (const double characteristic_length)
double	min_s () const
double	min_t () const
double	max_s () const
double	max_t () const
std::vector< STPoint >	upper_points () const
std::vector< STPoint >	lower_points () const
bool	IsPointInBoundary (const STPoint &st_point) const
STBoundary	ExpandByS (const double s) const
STBoundary	ExpandByT (const double t) const
STBoundary	CutOffByT (const double t) const
STPoint	upper_left_point () const
STPoint	upper_right_point () const
STPoint	bottom_left_point () const
STPoint	bottom_right_point () const
void	set_upper_left_point (STPoint st_point)
void	set_upper_right_point (STPoint st_point)
void	set_bottom_left_point (STPoint st_point)
void	set_bottom_right_point (STPoint st_point)
void	set_obstacle_road_right_ending_t (double road_right_ending_t)
double	obstacle_road_right_ending_t () const
Public 成员函数 继承自 apollo::common::math::Polygon2d
	Polygon2d ()=default
	Empty constructor.
	Polygon2d (const Box2d &box)
	Constructor which takes a box.
	Polygon2d (std::vector< Vec2d > points, bool check_area=true)
	Constructor which takes a vector of points as its vertices.
const std::vector< Vec2d > &	points () const
	Get the vertices of the polygon.
const std::vector< LineSegment2d > &	line_segments () const
	Get the edges of the polygon.
int	num_points () const
	Get the number of vertices of the polygon.
bool	is_convex () const
	Check if the polygon is convex.
double	area () const
	Get the area of the polygon.
double	DistanceToBoundary (const Vec2d &point) const
	Compute the distance from a point to the boundary of the polygon.
double	DistanceTo (const Vec2d &point) const
	Compute the distance from a point to the polygon.
double	DistanceTo (const LineSegment2d &line_segment) const
	Compute the distance from a line segment to the polygon.
double	DistanceTo (const Box2d &box) const
	Compute the distance from a box to the polygon.
double	DistanceTo (const Polygon2d &polygon) const
	Compute the distance from another polygon to the polygon.
double	DistanceSquareTo (const Vec2d &point) const
	Compute the square of distance from a point to the polygon.
bool	IsPointIn (const Vec2d &point) const
	Check if a point is within the polygon.
bool	IsPointOnBoundary (const Vec2d &point) const
	Check if a point is on the boundary of the polygon.
bool	Contains (const LineSegment2d &line_segment) const
	Check if the polygon contains a line segment.
bool	Contains (const Polygon2d &polygon) const
	Check if the polygon contains another polygon.
bool	HasOverlap (const LineSegment2d &line_segment) const
	Check if a line segment has overlap with this polygon.
bool	GetOverlap (const LineSegment2d &line_segment, Vec2d *const first, Vec2d *const last) const
	Get the overlap of a line segment and this polygon.
void	GetAllVertices (std::vector< Vec2d > *const vertices) const
	Get all vertices of the polygon
std::vector< Vec2d >	GetAllVertices () const
	Get all vertices of the polygon
std::vector< LineSegment2d >	GetAllOverlaps (const LineSegment2d &line_segment) const
	Get all overlapped line segments of a line segment and this polygon.
bool	HasOverlap (const Polygon2d &polygon) const
	Check if this polygon has overlap with another polygon.
bool	ComputeOverlap (const Polygon2d &other_polygon, Polygon2d *const overlap_polygon) const
	Compute the overlap of this polygon and the other polygon if any.
double	ComputeIoU (const Polygon2d &other_polygon) const
	Compute intersection over union ratio of this polygon and the other polygon.
AABox2d	AABoundingBox () const
	Get the axis-aligned bound box of the polygon.
Box2d	BoundingBoxWithHeading (const double heading) const
	Get the bound box according to a heading.
Box2d	MinAreaBoundingBox () const
	Get the bounding box with the minimal area.
void	ExtremePoints (const double heading, Vec2d *const first, Vec2d *const last) const
	Get the extreme points along a heading direction.
Polygon2d	ExpandByDistance (const double distance) const
	Expand this polygon by a distance.
Polygon2d	PolygonExpandByDistance (const double distance) const
void	CalculateVertices (const Vec2d &shift_vec)
std::string	DebugString () const
	Get a string containing essential information about the polygon for debugging purpose.
double	min_x () const
double	max_x () const
double	min_y () const
double	max_y () const
LineSegment2d	MinLineSegment () const

静态 Public 成员函数
static STBoundary	CreateInstance (const std::vector< STPoint > &lower_points, const std::vector< STPoint > &upper_points)
	Wrapper of the constructor (old).
static STBoundary	CreateInstanceAccurate (const std::vector< STPoint > &lower_points, const std::vector< STPoint > &upper_points)
	Wrapper of the constructor.
static std::string	TypeName (BoundaryType type)
静态 Public 成员函数 继承自 apollo::common::math::Polygon2d
static bool	ComputeConvexHull (const std::vector< Vec2d > &points, Polygon2d *const polygon, bool check_area=true)
	Compute the convex hull of a group of points.

额外继承的成员函数
Protected 成员函数 继承自 apollo::common::math::Polygon2d
void	BuildFromPoints (bool check_area=true)
int	Next (int at) const
int	Prev (int at) const
静态 Protected 成员函数 继承自 apollo::common::math::Polygon2d
static bool	ClipConvexHull (const LineSegment2d &line_segment, std::vector< Vec2d > *const points)
Protected 属性 继承自 apollo::common::math::Polygon2d
std::vector< Vec2d >	points_
int	num_points_ = 0
std::vector< LineSegment2d >	line_segments_
bool	is_convex_ = false
double	area_ = 0.0
double	min_x_ = 0.0
double	max_x_ = 0.0
double	min_y_ = 0.0
double	max_y_ = 0.0

详细描述

在文件 st_boundary.h 第 40 行定义.

成员枚举类型说明

BoundaryType

enum class apollo::planning::STBoundary::BoundaryType

strong

枚举值
UNKNOWN
STOP
FOLLOW
YIELD
OVERTAKE
KEEP_CLEAR

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

                          {
    UNKNOWN,
    STOP,
    FOLLOW,
    YIELD,
    OVERTAKE,
    KEEP_CLEAR,
  };

构造及析构函数说明

STBoundary() [1/4]

apollo::planning::STBoundary::STBoundary ( )

default

Constructors: STBoundary must be initialized with a vector of ST-point pairs.

Each pair refers to a time t, with (lower_s, upper_s).

STBoundary() [2/4]

apollo::planning::STBoundary::STBoundary ( const std::vector< std::pair< STPoint, STPoint > > &  point_pairs, bool  is_accurate_boundary = false  )

explicit

在文件 st_boundary.cc 第 34 行定义.

                               {
  ACHECK(IsValid(point_pairs)) << "The input point_pairs are NOT valid";
 
  std::vector<std::pair<STPoint, STPoint>> reduced_pairs(point_pairs);
  if (!is_accurate_boundary) {
    RemoveRedundantPoints(&reduced_pairs);
  }
 
  for (const auto& item : reduced_pairs) {
    // use same t for both points
    const double t = item.first.t();
    lower_points_.emplace_back(item.first.s(), t);
    upper_points_.emplace_back(item.second.s(), t);
  }
 
  for (const auto& point : lower_points_) {
    points_.emplace_back(point.t(), point.s());
  }
  for (auto rit = upper_points_.rbegin(); rit != upper_points_.rend(); ++rit) {
    points_.emplace_back(rit->t(), rit->s());
  }
 
  BuildFromPoints();
 
  for (const auto& point : lower_points_) {
    min_s_ = std::fmin(min_s_, point.s());
  }
  for (const auto& point : upper_points_) {
    max_s_ = std::fmax(max_s_, point.s());
  }
  min_t_ = lower_points_.front().t();
  max_t_ = lower_points_.back().t();
 
  obstacle_road_right_ending_t_ = std::numeric_limits<double>::lowest();
}

STBoundary() [3/4]

apollo::planning::STBoundary::STBoundary ( const common::math::Box2d &  box )

explicitdelete

STBoundary() [4/4]

apollo::planning::STBoundary::STBoundary ( std::vector< common::math::Vec2d >  points )

explicitdelete

~STBoundary()

apollo::planning::STBoundary::~STBoundary ( )

default

Default destructor.

成员函数说明

bottom_left_point()

STPoint apollo::planning::STBoundary::bottom_left_point

(

)

const

在文件 st_boundary.cc 第 374 行定义.

                                            {
  DCHECK(!lower_points_.empty()) << "StBoundary has zero points.";
  return lower_points_.front();
}

bottom_right_point()

STPoint apollo::planning::STBoundary::bottom_right_point

(

)

const

在文件 st_boundary.cc 第 379 行定义.

                                             {
  DCHECK(!lower_points_.empty()) << "StBoundary has zero points.";
  return lower_points_.back();
}

boundary_type()

STBoundary::BoundaryType apollo::planning::STBoundary::boundary_type

(

)

const

在文件 st_boundary.cc 第 326 行定义.

                                                       {
  return boundary_type_;
}

characteristic_length()

double apollo::planning::STBoundary::characteristic_length

(

)

const

在文件 st_boundary.cc 第 337 行定义.

                                               {
  return characteristic_length_;
}

CreateInstance()

STBoundary apollo::planning::STBoundary::CreateInstance ( const std::vector< STPoint > &  lower_points, const std::vector< STPoint > &  upper_points  )

static

Wrapper of the constructor (old).

在文件 st_boundary.cc 第 72 行定义.

                                            {
  if (lower_points.size() != upper_points.size() || lower_points.size() < 2) {
    return STBoundary();
  }
 
  std::vector<std::pair<STPoint, STPoint>> point_pairs;
  for (size_t i = 0; i < lower_points.size(); ++i) {
    point_pairs.emplace_back(
        STPoint(lower_points.at(i).s(), lower_points.at(i).t()),
        STPoint(upper_points.at(i).s(), upper_points.at(i).t()));
  }
  return STBoundary(point_pairs);
}

CreateInstanceAccurate()

STBoundary apollo::planning::STBoundary::CreateInstanceAccurate ( const std::vector< STPoint > &  lower_points, const std::vector< STPoint > &  upper_points  )

static

Wrapper of the constructor.

It doesn't use RemoveRedundantPoints and generates an accurate ST-boundary.

在文件 st_boundary.cc 第 88 行定义.

                                            {
  if (lower_points.size() != upper_points.size() || lower_points.size() < 2) {
    return STBoundary();
  }
 
  std::vector<std::pair<STPoint, STPoint>> point_pairs;
  for (size_t i = 0; i < lower_points.size(); ++i) {
    point_pairs.emplace_back(
        STPoint(lower_points.at(i).s(), lower_points.at(i).t()),
        STPoint(upper_points.at(i).s(), upper_points.at(i).t()));
  }
  return STBoundary(point_pairs, true);
}

CutOffByT()

STBoundary apollo::planning::STBoundary::CutOffByT

(

const double

t

)

const

在文件 st_boundary.cc 第 350 行定义.

                                                     {
  std::vector<STPoint> lower_points;
  std::vector<STPoint> upper_points;
  for (size_t i = 0; i < lower_points_.size() && i < upper_points_.size();
       ++i) {
    if (lower_points_[i].t() < t) {
      continue;
    }
    lower_points.push_back(lower_points_[i]);
    upper_points.push_back(upper_points_[i]);
  }
  return CreateInstance(lower_points, upper_points);
}

ExpandByS()

STBoundary apollo::planning::STBoundary::ExpandByS

(

const double

s

)

const

在文件 st_boundary.cc 第 263 行定义.

                                                     {
  if (lower_points_.empty()) {
    return STBoundary();
  }
  std::vector<std::pair<STPoint, STPoint>> point_pairs;
  for (size_t i = 0; i < lower_points_.size(); ++i) {
    point_pairs.emplace_back(
        STPoint(lower_points_[i].s() - s, lower_points_[i].t()),
        STPoint(upper_points_[i].s() + s, upper_points_[i].t()));
  }
  return STBoundary(std::move(point_pairs));
}

ExpandByT()

STBoundary apollo::planning::STBoundary::ExpandByT

(

const double

t

)

const

在文件 st_boundary.cc 第 276 行定义.

                                                     {
  if (lower_points_.empty()) {
    AERROR << "The current st_boundary has NO points.";
    return STBoundary();
  }
 
  std::vector<std::pair<STPoint, STPoint>> point_pairs;
 
  const double left_delta_t = lower_points_[1].t() - lower_points_[0].t();
  const double lower_left_delta_s = lower_points_[1].s() - lower_points_[0].s();
  const double upper_left_delta_s = upper_points_[1].s() - upper_points_[0].s();
 
  point_pairs.emplace_back(
      STPoint(lower_points_[0].s() - t * lower_left_delta_s / left_delta_t,
              lower_points_[0].t() - t),
      STPoint(upper_points_[0].s() - t * upper_left_delta_s / left_delta_t,
              upper_points_.front().t() - t));
 
  const double kMinSEpsilon = 1e-3;
  point_pairs.front().first.set_s(
      std::fmin(point_pairs.front().second.s() - kMinSEpsilon,
                point_pairs.front().first.s()));
 
  for (size_t i = 0; i < lower_points_.size(); ++i) {
    point_pairs.emplace_back(lower_points_[i], upper_points_[i]);
  }
 
  size_t length = lower_points_.size();
  DCHECK_GE(length, 2U);
 
  const double right_delta_t =
      lower_points_[length - 1].t() - lower_points_[length - 2].t();
  const double lower_right_delta_s =
      lower_points_[length - 1].s() - lower_points_[length - 2].s();
  const double upper_right_delta_s =
      upper_points_[length - 1].s() - upper_points_[length - 2].s();
 
  point_pairs.emplace_back(STPoint(lower_points_.back().s() +
                                       t * lower_right_delta_s / right_delta_t,
                                   lower_points_.back().t() + t),
                           STPoint(upper_points_.back().s() +
                                       t * upper_right_delta_s / right_delta_t,
                                   upper_points_.back().t() + t));
  point_pairs.back().second.set_s(
      std::fmax(point_pairs.back().second.s(),
                point_pairs.back().first.s() + kMinSEpsilon));
 
  return STBoundary(std::move(point_pairs));
}

GetBoundarySlopes()

bool apollo::planning::STBoundary::GetBoundarySlopes	(	const double	curr_time,
		double *	ds_upper,
		double *	ds_lower
	)		const

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

                                                           {
  if (ds_upper == nullptr || ds_lower == nullptr) {
    return false;
  }
  if (curr_time < min_t_ || curr_time > max_t_) {
    return false;
  }
 
  static constexpr double kTimeIncrement = 0.05;
  double t_prev = curr_time - kTimeIncrement;
  double prev_s_upper = 0.0;
  double prev_s_lower = 0.0;
  bool has_prev = GetBoundarySRange(t_prev, &prev_s_upper, &prev_s_lower);
  double t_next = curr_time + kTimeIncrement;
  double next_s_upper = 0.0;
  double next_s_lower = 0.0;
  bool has_next = GetBoundarySRange(t_next, &next_s_upper, &next_s_lower);
  double curr_s_upper = 0.0;
  double curr_s_lower = 0.0;
  GetBoundarySRange(curr_time, &curr_s_upper, &curr_s_lower);
  if (!has_prev && !has_next) {
    return false;
  }
  if (has_prev && has_next) {
    *ds_upper = ((next_s_upper - curr_s_upper) / kTimeIncrement +
                 (curr_s_upper - prev_s_upper) / kTimeIncrement) *
                0.5;
    *ds_lower = ((next_s_lower - curr_s_lower) / kTimeIncrement +
                 (curr_s_lower - prev_s_lower) / kTimeIncrement) *
                0.5;
    return true;
  }
  if (has_prev) {
    *ds_upper = (curr_s_upper - prev_s_upper) / kTimeIncrement;
    *ds_lower = (curr_s_lower - prev_s_lower) / kTimeIncrement;
  } else {
    *ds_upper = (next_s_upper - curr_s_upper) / kTimeIncrement;
    *ds_lower = (next_s_lower - curr_s_lower) / kTimeIncrement;
  }
  return true;
}

GetBoundarySRange()

bool apollo::planning::STBoundary::GetBoundarySRange	(	const double	curr_time,
		double *	s_upper,
		double *	s_lower
	)		const

在文件 st_boundary.cc 第 172 行定义.

                                                          {
  CHECK_NOTNULL(s_upper);
  CHECK_NOTNULL(s_lower);
  if (curr_time < min_t_ || curr_time > max_t_) {
    return false;
  }
 
  size_t left = 0;
  size_t right = 0;
  if (!GetIndexRange(lower_points_, curr_time, &left, &right)) {
    AERROR << "Fail to get index range.";
    return false;
  }
  const double r =
      (left == right
           ? 0.0
           : (curr_time - upper_points_[left].t()) /
                 (upper_points_[right].t() - upper_points_[left].t()));
 
  *s_upper = upper_points_[left].s() +
             r * (upper_points_[right].s() - upper_points_[left].s());
  *s_lower = lower_points_[left].s() +
             r * (lower_points_[right].s() - lower_points_[left].s());
 
  *s_upper = std::fmin(*s_upper, FLAGS_speed_lon_decision_horizon);
  *s_lower = std::fmax(*s_lower, 0.0);
  return true;
}

GetUnblockSRange()

bool apollo::planning::STBoundary::GetUnblockSRange	(	const double	curr_time,
		double *	s_upper,
		double *	s_lower
	)		const

在文件 st_boundary.cc 第 123 行定义.

                                                         {
  CHECK_NOTNULL(s_upper);
  CHECK_NOTNULL(s_lower);
 
  *s_upper = FLAGS_speed_lon_decision_horizon;
  *s_lower = 0.0;
  if (curr_time < min_t_ || curr_time > max_t_) {
    return true;
  }
 
  size_t left = 0;
  size_t right = 0;
  if (!GetIndexRange(lower_points_, curr_time, &left, &right)) {
    AERROR << "Fail to get index range.";
    return false;
  }
 
  if (curr_time > upper_points_[right].t()) {
    return true;
  }
 
  const double r =
      (left == right
           ? 0.0
           : (curr_time - upper_points_[left].t()) /
                 (upper_points_[right].t() - upper_points_[left].t()));
 
  double upper_cross_s =
      upper_points_[left].s() +
      r * (upper_points_[right].s() - upper_points_[left].s());
  double lower_cross_s =
      lower_points_[left].s() +
      r * (lower_points_[right].s() - lower_points_[left].s());
 
  if (boundary_type_ == BoundaryType::STOP ||
      boundary_type_ == BoundaryType::YIELD ||
      boundary_type_ == BoundaryType::FOLLOW) {
    *s_upper = lower_cross_s;
  } else if (boundary_type_ == BoundaryType::OVERTAKE) {
    *s_lower = std::fmax(*s_lower, upper_cross_s);
  } else {
    ADEBUG << "boundary_type is not supported. boundary_type: "
           << static_cast<int>(boundary_type_);
    return false;
  }
  return true;
}

id()

const std::string & apollo::planning::STBoundary::id

(

)

const

在文件 st_boundary.cc 第 333 行定义.

{ return id_; }

IsEmpty()

bool apollo::planning::STBoundary::IsEmpty ( ) const

inline

在文件 st_boundary.h 第 69 行定义.

{ return lower_points_.empty(); }

IsPointInBoundary()

bool apollo::planning::STBoundary::IsPointInBoundary

(

const STPoint &

st_point

)

const

在文件 st_boundary.cc 第 245 行定义.

                                                                {
  if (st_point.t() <= min_t_ || st_point.t() >= max_t_) {
    return false;
  }
  size_t left = 0;
  size_t right = 0;
  if (!GetIndexRange(lower_points_, st_point.t(), &left, &right)) {
    AERROR << "failed to get index range.";
    return false;
  }
  const double check_upper = common::math::CrossProd(
      st_point, upper_points_[left], upper_points_[right]);
  const double check_lower = common::math::CrossProd(
      st_point, lower_points_[left], lower_points_[right]);
 
  return (check_upper * check_lower < 0);
}

lower_points()

std::vector< STPoint > apollo::planning::STBoundary::lower_points ( ) const

inline

在文件 st_boundary.h 第 107 行定义.

{ return lower_points_; }

max_s()

double apollo::planning::STBoundary::max_s

(

)

const

在文件 st_boundary.cc 第 347 行定义.

{ return max_s_; }

max_t()

double apollo::planning::STBoundary::max_t

(

)

const

在文件 st_boundary.cc 第 348 行定义.

{ return max_t_; }

min_s()

double apollo::planning::STBoundary::min_s

(

)

const

在文件 st_boundary.cc 第 345 行定义.

{ return min_s_; }

min_t()

double apollo::planning::STBoundary::min_t

(

)

const

在文件 st_boundary.cc 第 346 行定义.

{ return min_t_; }

obstacle_road_right_ending_t()

double apollo::planning::STBoundary::obstacle_road_right_ending_t ( ) const

inline

在文件 st_boundary.h 第 131 行定义.

                                              {
    return obstacle_road_right_ending_t_;
  }

PrintDebug()

void apollo::planning::STBoundary::PrintDebug

(

std::string

suffix = ""

)

const

在文件 st_boundary.cc 第 497 行定义.

                                                  {
  std::string type_name = TypeName(boundary_type_);
  std::string key_name = type_name + id_ + suffix;
  PrintPoints debug(key_name);
  if (lower_points_.empty() || upper_points_.empty()) {
    return;
  }
  for (auto pt : lower_points_) {
    debug.AddPoint(pt.t(), pt.s());
  }
  for (auto iter = upper_points_.rbegin(); iter != upper_points_.rend();
       iter++) {
    debug.AddPoint(iter->t(), iter->s());
  }
  debug.AddPoint(lower_points_.front().t(), lower_points_.front().s());
  debug.PrintToLog();
}

set_bottom_left_point()

void apollo::planning::STBoundary::set_bottom_left_point

(

STPoint

st_point

)

在文件 st_boundary.cc 第 392 行定义.

                                                       {
  bottom_left_point_ = std::move(st_point);
}

set_bottom_right_point()

void apollo::planning::STBoundary::set_bottom_right_point

(

STPoint

st_point

)

在文件 st_boundary.cc 第 396 行定义.

                                                        {
  bottom_right_point_ = std::move(st_point);
}

set_id()

void apollo::planning::STBoundary::set_id

(

const std::string &

id

)

在文件 st_boundary.cc 第 335 行定义.

{ id_ = id; }

set_obstacle_road_right_ending_t()

void apollo::planning::STBoundary::set_obstacle_road_right_ending_t ( double  road_right_ending_t )

inline

在文件 st_boundary.h 第 128 行定义.

                                                                    {
    obstacle_road_right_ending_t_ = road_right_ending_t;
  }

set_upper_left_point()

void apollo::planning::STBoundary::set_upper_left_point

(

STPoint

st_point

)

在文件 st_boundary.cc 第 384 行定义.

                                                      {
  upper_left_point_ = std::move(st_point);
}

set_upper_right_point()

void apollo::planning::STBoundary::set_upper_right_point

(

STPoint

st_point

)

在文件 st_boundary.cc 第 388 行定义.

                                                       {
  upper_right_point_ = std::move(st_point);
}

SetBoundaryType()

void apollo::planning::STBoundary::SetBoundaryType

(

const BoundaryType &

boundary_type

)

在文件 st_boundary.cc 第 329 行定义.

                                                                  {
  boundary_type_ = boundary_type;
}

SetCharacteristicLength()

void apollo::planning::STBoundary::SetCharacteristicLength

(

const double

characteristic_length

)

在文件 st_boundary.cc 第 341 行定义.

                                                                           {
  characteristic_length_ = characteristic_length;
}

TypeName()

std::string apollo::planning::STBoundary::TypeName ( BoundaryType  type )

static

在文件 st_boundary.cc 第 104 行定义.

                                                {
  if (type == BoundaryType::FOLLOW) {
    return "FOLLOW";
  } else if (type == BoundaryType::KEEP_CLEAR) {
    return "KEEP_CLEAR";
  } else if (type == BoundaryType::OVERTAKE) {
    return "OVERTAKE";
  } else if (type == BoundaryType::STOP) {
    return "STOP";
  } else if (type == BoundaryType::YIELD) {
    return "YIELD";
  } else if (type == BoundaryType::UNKNOWN) {
    return "UNKNOWN";
  }
  AWARN << "Unknown boundary type " << static_cast<int>(type)
        << ", treated as UNKNOWN";
  return "UNKNOWN";
}

upper_left_point()

STPoint apollo::planning::STBoundary::upper_left_point

(

)

const

在文件 st_boundary.cc 第 364 行定义.

                                           {
  DCHECK(!upper_points_.empty()) << "StBoundary has zero points.";
  return upper_points_.front();
}

upper_points()

std::vector< STPoint > apollo::planning::STBoundary::upper_points ( ) const

inline

在文件 st_boundary.h 第 106 行定义.

{ return upper_points_; }

upper_right_point()

STPoint apollo::planning::STBoundary::upper_right_point

(

)

const

在文件 st_boundary.cc 第 369 行定义.

                                            {
  DCHECK(!upper_points_.empty()) << "StBoundary has zero points.";
  return upper_points_.back();
}

---

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

• modules/planning/planning_base/common/speed/st_boundary.h
• modules/planning/planning_base/common/speed/st_boundary.cc