apollo::hdmap::MapPathPoint类 参考

#include <path.h>

类 apollo::hdmap::MapPathPoint 继承关系图:

apollo::hdmap::MapPathPoint 的协作图:

Public 成员函数
	MapPathPoint ()=default
	MapPathPoint (const common::math::Vec2d &point, double heading)
	MapPathPoint (const common::math::Vec2d &point, double heading, LaneWaypoint lane_waypoint)
	MapPathPoint (const common::math::Vec2d &point, double heading, std::vector< LaneWaypoint > lane_waypoints)
double	heading () const
void	set_heading (const double heading)
const std::vector< LaneWaypoint > &	lane_waypoints () const
void	add_lane_waypoint (LaneWaypoint lane_waypoint)
void	add_lane_waypoints (const std::vector< LaneWaypoint > &lane_waypoints)
void	clear_lane_waypoints ()
std::string	DebugString () const
Public 成员函数 继承自 apollo::common::math::Vec2d
constexpr	Vec2d (const double x, const double y) noexcept
	Constructor which takes x- and y-coordinates.
constexpr	Vec2d () noexcept
	Constructor returning the zero vector.
double	x () const
	Getter for x component
double	y () const
	Getter for y component
void	set_x (const double x)
	Setter for x component
void	set_y (const double y)
	Setter for y component
double	Length () const
	Gets the length of the vector
double	LengthSquare () const
	Gets the squared length of the vector
double	Angle () const
	Gets the angle between the vector and the positive x semi-axis
void	Normalize ()
	Returns the unit vector that is co-linear with this vector
double	DistanceTo (const Vec2d &other) const
	Returns the distance to the given vector
double	DistanceSquareTo (const Vec2d &other) const
	Returns the squared distance to the given vector
double	CrossProd (const Vec2d &other) const
	Returns the "cross" product between these two Vec2d (non-standard).
double	InnerProd (const Vec2d &other) const
	Returns the inner product between these two Vec2d.
Vec2d	rotate (const double angle) const
	rotate the vector by angle.
void	SelfRotate (const double angle)
	rotate the vector itself by angle.
Vec2d	operator+ (const Vec2d &other) const
	Sums two Vec2d
Vec2d	operator- (const Vec2d &other) const
	Subtracts two Vec2d
Vec2d	operator* (const double ratio) const
	Multiplies Vec2d by a scalar
Vec2d	operator/ (const double ratio) const
	Divides Vec2d by a scalar
Vec2d &	operator+= (const Vec2d &other)
	Sums another Vec2d to the current one
Vec2d &	operator-= (const Vec2d &other)
	Subtracts another Vec2d to the current one
Vec2d &	operator*= (const double ratio)
	Multiplies this Vec2d by a scalar
Vec2d &	operator/= (const double ratio)
	Divides this Vec2d by a scalar
bool	operator== (const Vec2d &other) const
	Compares two Vec2d
std::string	DebugString () const
	Returns a human-readable string representing this object

静态 Public 成员函数
static void	RemoveDuplicates (std::vector< MapPathPoint > *points)
static std::vector< MapPathPoint >	GetPointsFromSegment (const LaneSegment &segment)
static std::vector< MapPathPoint >	GetPointsFromLane (LaneInfoConstPtr lane, const double start_s, const double end_s)
静态 Public 成员函数 继承自 apollo::common::math::Vec2d
static Vec2d	CreateUnitVec2d (const double angle)
	Creates a unit-vector with a given angle to the positive x semi-axis

Protected 属性
double	heading_ = 0.0
std::vector< LaneWaypoint >	lane_waypoints_
Protected 属性 继承自 apollo::common::math::Vec2d
double	x_ = 0.0
double	y_ = 0.0

详细描述

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

构造及析构函数说明

MapPathPoint() [1/4]

apollo::hdmap::MapPathPoint::MapPathPoint ( )

default

MapPathPoint() [2/4]

apollo::hdmap::MapPathPoint::MapPathPoint ( const common::math::Vec2d &  point, double  heading  )

inline

在文件 path.h 第 105 行定义.

      : Vec2d(point.x(), point.y()), heading_(heading) {}

MapPathPoint() [3/4]

apollo::hdmap::MapPathPoint::MapPathPoint ( const common::math::Vec2d &  point, double  heading, LaneWaypoint  lane_waypoint  )

inline

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

      : Vec2d(point.x(), point.y()), heading_(heading) {
    lane_waypoints_.emplace_back(std::move(lane_waypoint));
  }

MapPathPoint() [4/4]

apollo::hdmap::MapPathPoint::MapPathPoint ( const common::math::Vec2d &  point, double  heading, std::vector< LaneWaypoint >  lane_waypoints  )

inline

在文件 path.h 第 112 行定义.

      : Vec2d(point.x(), point.y()),
        heading_(heading),
        lane_waypoints_(std::move(lane_waypoints)) {}

成员函数说明

add_lane_waypoint()

void apollo::hdmap::MapPathPoint::add_lane_waypoint ( LaneWaypoint  lane_waypoint )

inline

在文件 path.h 第 125 行定义.

                                                     {
    lane_waypoints_.emplace_back(std::move(lane_waypoint));
  }

add_lane_waypoints()

void apollo::hdmap::MapPathPoint::add_lane_waypoints ( const std::vector< LaneWaypoint > &  lane_waypoints )

inline

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

                                                                         {
    lane_waypoints_.insert(lane_waypoints_.end(), lane_waypoints.begin(),
                           lane_waypoints.end());
  }

clear_lane_waypoints()

void apollo::hdmap::MapPathPoint::clear_lane_waypoints ( )

inline

在文件 path.h 第 133 行定义.

{ lane_waypoints_.clear(); }

DebugString()

std::string apollo::hdmap::MapPathPoint::DebugString

(

)

const

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

                                          {
  return absl::StrCat(
      "x = ", x_, "  y = ", y_, "  heading = ", heading_,
      "  lwp = "
      "{(",
      absl::StrJoin(lane_waypoints_, "), (", DebugStringFormatter()), ")}");
}

GetPointsFromLane()

std::vector< MapPathPoint > apollo::hdmap::MapPathPoint::GetPointsFromLane ( LaneInfoConstPtr  lane, const double  start_s, const double  end_s  )

static

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

                                                                              {
  std::vector<MapPathPoint> points;
  if (start_s >= end_s) {
    return points;
  }
  double accumulate_s = 0.0;
  for (size_t i = 0; i < lane->points().size(); ++i) {
    if (accumulate_s >= start_s && accumulate_s <= end_s) {
      points.emplace_back(lane->points()[i], lane->headings()[i],
                          LaneWaypoint(lane, accumulate_s));
    }
    if (i < lane->segments().size()) {
      const auto& segment = lane->segments()[i];
      const double next_accumulate_s = accumulate_s + segment.length();
      if (start_s > accumulate_s && start_s < next_accumulate_s) {
        points.emplace_back(segment.start() + segment.unit_direction() *
                                                  (start_s - accumulate_s),
                            lane->headings()[i], LaneWaypoint(lane, start_s));
      }
      if (end_s > accumulate_s && end_s < next_accumulate_s) {
        points.emplace_back(
            segment.start() + segment.unit_direction() * (end_s - accumulate_s),
            lane->headings()[i], LaneWaypoint(lane, end_s));
      }
      accumulate_s = next_accumulate_s;
    }
    if (accumulate_s > end_s) {
      break;
    }
  }
  return points;
}

GetPointsFromSegment()

std::vector< MapPathPoint > apollo::hdmap::MapPathPoint::GetPointsFromSegment ( const LaneSegment &  segment )

static

在文件 path.cc 第 201 行定义.

                                {
  return GetPointsFromLane(segment.lane, segment.start_s, segment.end_s);
}

heading()

double apollo::hdmap::MapPathPoint::heading ( ) const

inline

在文件 path.h 第 118 行定义.

{ return heading_; }

lane_waypoints()

const std::vector< LaneWaypoint > & apollo::hdmap::MapPathPoint::lane_waypoints ( ) const

inline

在文件 path.h 第 121 行定义.

                                                        {
    return lane_waypoints_;
  }

RemoveDuplicates()

void apollo::hdmap::MapPathPoint::RemoveDuplicates ( std::vector< MapPathPoint > *  points )

static

在文件 path.cc 第 241 行定义.

                                                                   {
  static constexpr double kDuplicatedPointsEpsilon = 1e-7;
  static constexpr double limit =
      kDuplicatedPointsEpsilon * kDuplicatedPointsEpsilon;
  CHECK_NOTNULL(points);
  int count = 0;
  for (size_t i = 0; i < points->size(); ++i) {
    if (count == 0 ||
        (*points)[i].DistanceSquareTo((*points)[count - 1]) > limit) {
      (*points)[count++] = (*points)[i];
    } else {
      (*points)[count - 1].add_lane_waypoints((*points)[i].lane_waypoints());
    }
  }
  points->resize(count);
}

set_heading()

void apollo::hdmap::MapPathPoint::set_heading ( const double  heading )

inline

在文件 path.h 第 119 行定义.

{ heading_ = heading; }

类成员变量说明

heading_

double apollo::hdmap::MapPathPoint::heading_ = 0.0

protected

在文件 path.h 第 147 行定义.

lane_waypoints_

std::vector<LaneWaypoint> apollo::hdmap::MapPathPoint::lane_waypoints_

protected

在文件 path.h 第 148 行定义.

---

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

• modules/map/pnc_map/path.h
• modules/map/pnc_map/path.cc