#include <path.h>

apollo::hdmap::Path 的协作图:

Public 成员函数
	Path ()=default

	Path (const std::vector< MapPathPoint > &path_points)

	Path (std::vector< MapPathPoint > &&path_points)

	Path (std::vector< LaneSegment > &&path_points)

	Path (const std::vector< LaneSegment > &path_points)

	Path (const std::vector< MapPathPoint > &path_points, const std::vector< LaneSegment > &lane_segments)

	Path (std::vector< MapPathPoint > &&path_points, std::vector< LaneSegment > &&lane_segments)

	Path (const std::vector< MapPathPoint > &path_points, const std::vector< LaneSegment > &lane_segments, const double max_approximation_error)

	Path (std::vector< MapPathPoint > &&path_points, std::vector< LaneSegment > &&lane_segments, const double max_approximation_error)

MapPathPoint	GetSmoothPoint (const InterpolatedIndex &index) const

MapPathPoint	GetSmoothPoint (double s) const

double	GetSFromIndex (const InterpolatedIndex &index) const

InterpolatedIndex	GetIndexFromS (double s) const

InterpolatedIndex	GetLaneIndexFromS (double s) const

std::vector< hdmap::LaneSegment >	GetLaneSegments (const double start_s, const double end_s) const

bool	GetNearestPoint (const common::math::Vec2d &point, double accumulate_s, double lateral) const

bool	GetNearestPoint (const common::math::Vec2d &point, double accumulate_s, double lateral, double *distance) const

bool	GetProjectionWithHueristicParams (const common::math::Vec2d &point, const double hueristic_start_s, const double hueristic_end_s, double accumulate_s, double lateral, double *min_distance) const

bool	GetProjection (const common::math::Vec2d &point, double accumulate_s, double lateral) const

bool	GetProjection (const double heading, const common::math::Vec2d &point, double accumulate_s, double lateral) const

bool	GetProjectionWithWarmStartS (const common::math::Vec2d &point, double accumulate_s, double lateral) const

bool	GetProjection (const common::math::Vec2d &point, double accumulate_s, double lateral, double *distance) const

bool	GetProjection (const common::math::Vec2d &point, const double heading, double accumulate_s, double lateral, double *distance) const

bool	GetHeadingAlongPath (const common::math::Vec2d &point, double *heading) const

int	num_points () const

int	num_segments () const

const std::vector< MapPathPoint > &	path_points () const

const std::vector< LaneSegment > &	lane_segments () const

const std::vector< LaneSegment > &	lane_segments_to_next_point () const

const std::vector< common::math::Vec2d > &	unit_directions () const

const std::vector< double > &	accumulated_s () const

const std::vector< common::math::LineSegment2d > &	segments () const

const PathApproximation *	approximation () const

double	length () const

const PathOverlap *	NextLaneOverlap (double s) const

const std::vector< PathOverlap > &	lane_overlaps () const

const std::vector< PathOverlap > &	signal_overlaps () const

const std::vector< PathOverlap > &	yield_sign_overlaps () const

const std::vector< PathOverlap > &	stop_sign_overlaps () const

const std::vector< PathOverlap > &	crosswalk_overlaps () const

const std::vector< PathOverlap > &	junction_overlaps () const

const std::vector< PathOverlap > &	pnc_junction_overlaps () const

const std::vector< PathOverlap > &	clear_area_overlaps () const

const std::vector< PathOverlap > &	speed_bump_overlaps () const

const std::vector< PathOverlap > &	parking_space_overlaps () const

const std::vector< PathOverlap > &	dead_end_overlaps () const

const std::vector< PathOverlap > &	area_overlaps () const

double	GetLaneLeftWidth (const double s) const

double	GetLaneRightWidth (const double s) const

bool	GetLaneWidth (const double s, double lane_left_width, double lane_right_width) const

double	GetRoadLeftWidth (const double s) const

double	GetRoadRightWidth (const double s) const

bool	GetRoadWidth (const double s, double road_left_width, double road_ight_width) const

bool	IsOnPath (const common::math::Vec2d &point) const

bool	OverlapWith (const common::math::Box2d &box, double width) const

std::string	DebugString () const

Protected 类型
using	GetOverlapFromLaneFunc = std::function< const std::vector< OverlapInfoConstPtr > &(const LaneInfo &)>

Protected 成员函数
void	Init ()

void	InitPoints ()

void	InitLaneSegments ()

void	InitWidth ()

void	InitPointIndex ()

void	InitOverlaps ()

double	GetSample (const std::vector< double > &samples, const double s) const

void	GetAllOverlaps (GetOverlapFromLaneFunc GetOverlaps_from_lane, std::vector< PathOverlap > *const overlaps) const

Protected 属性
int	num_points_ = 0

int	num_segments_ = 0

std::vector< MapPathPoint >	path_points_

std::vector< LaneSegment >	lane_segments_

std::vector< double >	lane_accumulated_s_

std::vector< LaneSegment >	lane_segments_to_next_point_

std::vector< common::math::Vec2d >	unit_directions_

double	length_ = 0.0

std::vector< double >	accumulated_s_

std::vector< common::math::LineSegment2d >	segments_

bool	use_path_approximation_ = false

PathApproximation	approximation_

int	num_sample_points_ = 0

std::vector< double >	lane_left_width_

std::vector< double >	lane_right_width_

std::vector< double >	road_left_width_

std::vector< double >	road_right_width_

std::vector< int >	last_point_index_

std::vector< PathOverlap >	lane_overlaps_

std::vector< PathOverlap >	signal_overlaps_

std::vector< PathOverlap >	yield_sign_overlaps_

std::vector< PathOverlap >	stop_sign_overlaps_

std::vector< PathOverlap >	crosswalk_overlaps_

std::vector< PathOverlap >	parking_space_overlaps_

std::vector< PathOverlap >	dead_end_overlaps_

std::vector< PathOverlap >	junction_overlaps_

std::vector< PathOverlap >	pnc_junction_overlaps_

std::vector< PathOverlap >	clear_area_overlaps_

std::vector< PathOverlap >	speed_bump_overlaps_

std::vector< PathOverlap >	area_overlaps_

详细描述

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

成员类型定义说明

◆ GetOverlapFromLaneFunc

using apollo::hdmap::Path::GetOverlapFromLaneFunc = std::function<const std::vector<OverlapInfoConstPtr>&(const LaneInfo&)>

protected

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

构造及析构函数说明

◆ Path() [1/9]

apollo::hdmap::Path::Path ( )

default

◆ Path() [2/9]

apollo::hdmap::Path::Path ( const std::vector< MapPathPoint > & path_points )

explicit

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

    : path_points_(path_points) {
  Init();
}

◆ Path() [3/9]

apollo::hdmap::Path::Path ( std::vector< MapPathPoint > && path_points )

explicit

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

    : path_points_(std::move(path_points)) {
  Init();
}

◆ Path() [4/9]

apollo::hdmap::Path::Path ( std::vector< LaneSegment > && path_points )

explicit

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

    : lane_segments_(std::move(segments)) {
  for (const auto& segment : lane_segments_) {
    const auto points = MapPathPoint::GetPointsFromLane(
        segment.lane, segment.start_s, segment.end_s);
    path_points_.insert(path_points_.end(), points.begin(), points.end());
  }
  MapPathPoint::RemoveDuplicates(&path_points_);
  CHECK_GE(path_points_.size(), 2U);
  Init();
}

◆ Path() [5/9]

apollo::hdmap::Path::Path ( const std::vector< LaneSegment > & path_points )

explicit

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

    : lane_segments_(segments) {
  for (const auto& segment : lane_segments_) {
    const auto points = MapPathPoint::GetPointsFromLane(
        segment.lane, segment.start_s, segment.end_s);
    path_points_.insert(path_points_.end(), points.begin(), points.end());
  }
  MapPathPoint::RemoveDuplicates(&path_points_);
  CHECK_GE(path_points_.size(), 2U);
  Init();
}

◆ Path() [6/9]

apollo::hdmap::Path::Path	(	const std::vector< MapPathPoint > &	path_points,
		const std::vector< LaneSegment > &	lane_segments
	)

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

    : path_points_(path_points), lane_segments_(lane_segments) {
  Init();
}

◆ Path() [7/9]

apollo::hdmap::Path::Path	(	std::vector< MapPathPoint > &&	path_points,
		std::vector< LaneSegment > &&	lane_segments
	)

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

    : path_points_(std::move(path_points)),
      lane_segments_(std::move(lane_segments)) {
  Init();
}

◆ Path() [8/9]

apollo::hdmap::Path::Path	(	const std::vector< MapPathPoint > &	path_points,
		const std::vector< LaneSegment > &	lane_segments,
		const double	max_approximation_error
	)

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

    : path_points_(path_points), lane_segments_(lane_segments) {
  Init();
  if (max_approximation_error > 0.0) {
    use_path_approximation_ = true;
    approximation_ = PathApproximation(*this, max_approximation_error);
  }
}

◆ Path() [9/9]

apollo::hdmap::Path::Path	(	std::vector< MapPathPoint > &&	path_points,
		std::vector< LaneSegment > &&	lane_segments,
		const double	max_approximation_error
	)

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

    : path_points_(std::move(path_points)),
      lane_segments_(std::move(lane_segments)) {
  Init();
  if (max_approximation_error > 0.0) {
    use_path_approximation_ = true;
    approximation_ = PathApproximation(*this, max_approximation_error);
  }
}

成员函数说明

◆ accumulated_s()

const std::vector< double > & apollo::hdmap::Path::accumulated_s ( ) const

inline

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

289{ return accumulated_s_; }

apollo::hdmap::Path::accumulated_s_

std::vector< double > accumulated_s_

Definition path.h:374

◆ approximation()

const PathApproximation * apollo::hdmap::Path::approximation ( ) const

inline

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

293{ return &approximation_; }

◆ area_overlaps()

const std::vector< PathOverlap > & apollo::hdmap::Path::area_overlaps ( ) const

inline

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

                                                      {
    return area_overlaps_;
  }

◆ clear_area_overlaps()

const std::vector< PathOverlap > & apollo::hdmap::Path::clear_area_overlaps ( ) const

inline

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

                                                            {
    return clear_area_overlaps_;
  }

◆ crosswalk_overlaps()

const std::vector< PathOverlap > & apollo::hdmap::Path::crosswalk_overlaps ( ) const

inline

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

                                                           {
    return crosswalk_overlaps_;
  }

◆ dead_end_overlaps()

const std::vector< PathOverlap > & apollo::hdmap::Path::dead_end_overlaps ( ) const

inline

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

                                                          {
    return dead_end_overlaps_;
  }

◆ DebugString()

std::string apollo::hdmap::Path::DebugString ( ) const

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

                                  {
  return absl::StrCat(
      "num_points = ", num_points_,
      "  points = "
      "{(",
      absl::StrJoin(path_points_, "), (", DebugStringFormatter()),
      ")}  "
      "numlane_segments_ = ",
      lane_segments_.size(),
      "  lane_segments = "
      "{(",
      absl::StrJoin(lane_segments_, "), (", DebugStringFormatter()), ")}");
}

◆ GetAllOverlaps()

void apollo::hdmap::Path::GetAllOverlaps	(	GetOverlapFromLaneFunc	GetOverlaps_from_lane,
		std::vector< PathOverlap > *const	overlaps
	)		const

protected

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

                                                                        {
  if (overlaps == nullptr) {
    return;
  }
  overlaps->clear();
  std::unordered_map<std::string, std::vector<std::pair<double, double>>>
      overlaps_by_id;
  double s = 0.0;
  for (const auto& lane_segment : lane_segments_) {
    if (lane_segment.lane == nullptr) {
      continue;
    }
    for (const auto& overlap : GetOverlaps_from_lane(*(lane_segment.lane))) {
      const auto& overlap_info =
          overlap->GetObjectOverlapInfo(lane_segment.lane->id());
      if (overlap_info == nullptr) {
        continue;
      }
 
      const auto& lane_overlap_info = overlap_info->lane_overlap_info();
      if (lane_overlap_info.start_s() <= lane_segment.end_s &&
          lane_overlap_info.end_s() >= lane_segment.start_s) {
        const double ref_s = s - lane_segment.start_s;
        const double adjusted_start_s =
            std::max(lane_overlap_info.start_s(), lane_segment.start_s) + ref_s;
        const double adjusted_end_s =
            std::min(lane_overlap_info.end_s(), lane_segment.end_s) + ref_s;
        for (const auto& object : overlap->overlap().object()) {
          if (object.id().id() != lane_segment.lane->id().id()) {
            overlaps_by_id[object.id().id()].emplace_back(adjusted_start_s,
                                                          adjusted_end_s);
          }
        }
      }
    }
    s += lane_segment.end_s - lane_segment.start_s;
  }
  for (auto& overlaps_one_object : overlaps_by_id) {
    const std::string& object_id = overlaps_one_object.first;
    auto& segments = overlaps_one_object.second;
    std::sort(segments.begin(), segments.end());
 
    const double kMinOverlapDistanceGap = 1.5;  // in meters.
    for (const auto& segment : segments) {
      if (!overlaps->empty() && overlaps->back().object_id == object_id &&
          segment.first - overlaps->back().end_s <= kMinOverlapDistanceGap) {
        overlaps->back().end_s =
            std::max(overlaps->back().end_s, segment.second);
      } else {
        overlaps->emplace_back(object_id, segment.first, segment.second);
      }
    }
  }
  std::sort(overlaps->begin(), overlaps->end(),
            [](const PathOverlap& overlap1, const PathOverlap& overlap2) {
              return overlap1.start_s < overlap2.start_s;
            });
}

◆ GetHeadingAlongPath()

bool apollo::hdmap::Path::GetHeadingAlongPath	(	const common::math::Vec2d &	point,
		double *	heading
	)		const

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

                                                                        {
  if (heading == nullptr) {
    return false;
  }
  double s = 0;
  double l = 0;
  if (GetProjection(point, &s, &l)) {
    *heading = GetSmoothPoint(s).heading();
    return true;
  }
  return false;
}

◆ GetIndexFromS()

InterpolatedIndex apollo::hdmap::Path::GetIndexFromS ( double s ) const

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

                                                    {
  if (s <= 0.0) {
    return {0, 0.0};
  }
  CHECK_GT(num_points_, 0);
  if (s >= length_) {
    return {num_points_ - 1, 0.0};
  }
  const int sample_id = static_cast<int>(s / kSampleDistance);
  if (sample_id >= num_sample_points_) {
    return {num_points_ - 1, 0.0};
  }
  const int next_sample_id = sample_id + 1;
  int low = last_point_index_[sample_id];
  int high = (next_sample_id < num_sample_points_
                  ? std::min(num_points_, last_point_index_[next_sample_id] + 1)
                  : num_points_);
  while (low + 1 < high) {
    const int mid = (low + high) >> 1;
    if (accumulated_s_[mid] <= s) {
      low = mid;
    } else {
      high = mid;
    }
  }
  return {low, s - accumulated_s_[low]};
}

◆ GetLaneIndexFromS()

InterpolatedIndex apollo::hdmap::Path::GetLaneIndexFromS ( double s ) const

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

                                                        {
  if (s <= 0.0) {
    return {0, 0.0};
  }
  CHECK_GT(lane_segments_.size(), 0U);
  if (s >= length_) {
    return {static_cast<int>(lane_segments_.size() - 1),
            lane_segments_.back().Length()};
  }
  auto iter = std::lower_bound(lane_accumulated_s_.begin(),
                               lane_accumulated_s_.end(), s);
  if (iter == lane_accumulated_s_.end()) {
    return {static_cast<int>(lane_segments_.size() - 1),
            lane_segments_.back().Length()};
  }
  int index =
      static_cast<int>(std::distance(lane_accumulated_s_.begin(), iter));
  if (index == 0) {
    return {index, s};
  } else {
    return {index, s - lane_accumulated_s_[index - 1]};
  }
}

◆ GetLaneLeftWidth()

double apollo::hdmap::Path::GetLaneLeftWidth ( const double s ) const

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

                                                  {
  return GetSample(lane_left_width_, s);
}

◆ GetLaneRightWidth()

double apollo::hdmap::Path::GetLaneRightWidth ( const double s ) const

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

                                                   {
  return GetSample(lane_right_width_, s);
}

◆ GetLaneSegments()

std::vector< hdmap::LaneSegment > apollo::hdmap::Path::GetLaneSegments	(	const double	start_s,
		const double	end_s
	)		const

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

                                                    {
  std::vector<hdmap::LaneSegment> lanes;
  if (start_s + kMathEpsilon > end_s) {
    return lanes;
  }
  auto start_index = GetLaneIndexFromS(start_s);
  if (start_index.offset + kMathEpsilon >=
      lane_segments_[start_index.id].Length()) {
    start_index.id += 1;
    start_index.offset = 0;
  }
  const int num_lanes = static_cast<int>(lane_segments_.size());
  if (start_index.id >= num_lanes) {
    return lanes;
  }
  lanes.emplace_back(lane_segments_[start_index.id].lane, start_index.offset,
                     lane_segments_[start_index.id].Length());
  auto end_index = GetLaneIndexFromS(end_s);
  for (int i = start_index.id; i < end_index.id && i < num_lanes; ++i) {
    lanes.emplace_back(lane_segments_[i]);
  }
  if (end_index.offset >= kMathEpsilon) {
    lanes.emplace_back(lane_segments_[end_index.id].lane, 0, end_index.offset);
  }
  return lanes;
}

◆ GetLaneWidth()

bool apollo::hdmap::Path::GetLaneWidth	(	const double	s,
		double *	lane_left_width,
		double *	lane_right_width
	)		const

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

                                                        {
  CHECK_NOTNULL(lane_left_width);
  CHECK_NOTNULL(lane_right_width);
 
  if (s < 0.0 || s > length_) {
    return false;
  }
  *lane_left_width = GetSample(lane_left_width_, s);
  *lane_right_width = GetSample(lane_right_width_, s);
  return true;
}

◆ GetNearestPoint() [1/2]

bool apollo::hdmap::Path::GetNearestPoint	(	const common::math::Vec2d &	point,
		double *	accumulate_s,
		double *	lateral
	)		const

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

                                                  {
  double distance = 0.0;
  return GetNearestPoint(point, accumulate_s, lateral, &distance);
}

◆ GetNearestPoint() [2/2]

bool apollo::hdmap::Path::GetNearestPoint	(	const common::math::Vec2d &	point,
		double *	accumulate_s,
		double *	lateral,
		double *	distance
	)		const

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

                                                                        {
  if (!GetProjection(point, accumulate_s, lateral, min_distance)) {
    return false;
  }
  if (*accumulate_s < 0.0) {
    *accumulate_s = 0.0;
    *min_distance = point.DistanceTo(path_points_[0]);
  } else if (*accumulate_s > length_) {
    *accumulate_s = length_;
    *min_distance = point.DistanceTo(path_points_.back());
  }
  return true;
}

◆ GetProjection() [1/4]

bool apollo::hdmap::Path::GetProjection	(	const common::math::Vec2d &	point,
		const double	heading,
		double *	accumulate_s,
		double *	lateral,
		double *	distance
	)		const

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

                                                     {
  if (segments_.empty()) {
    return false;
  }
  if (accumulate_s == nullptr || lateral == nullptr ||
      min_distance == nullptr) {
    return false;
  }
  if (use_path_approximation_) {
    return approximation_.GetProjection(*this, point, accumulate_s, lateral,
                                        min_distance);
  }
  CHECK_GE(num_points_, 2);
  *min_distance = std::numeric_limits<double>::infinity();
  int min_index = 0;
  for (int i = 0; i < num_segments_; ++i) {
    if (abs(common::math::AngleDiff(segments_[i].heading(), heading)) >= M_PI_2)
      continue;
    const double distance = segments_[i].DistanceSquareTo(point);
    if (distance < *min_distance) {
      min_index = i;
      *min_distance = distance;
    }
  }
  *min_distance = std::sqrt(*min_distance);
  const auto& nearest_seg = segments_[min_index];
  const auto prod = nearest_seg.ProductOntoUnit(point);
  const auto proj = nearest_seg.ProjectOntoUnit(point);
  if (min_index == 0) {
    *accumulate_s = std::min(proj, nearest_seg.length());
    if (proj < 0) {
      *lateral = prod;
    } else {
      *lateral = (prod > 0.0 ? 1 : -1) * *min_distance;
    }
  } else if (min_index == num_segments_ - 1) {
    *accumulate_s = accumulated_s_[min_index] + std::max(0.0, proj);
    if (proj > 0) {
      *lateral = prod;
    } else {
      *lateral = (prod > 0.0 ? 1 : -1) * *min_distance;
    }
  } else {
    *accumulate_s = accumulated_s_[min_index] +
                    std::max(0.0, std::min(proj, nearest_seg.length()));
    *lateral = (prod > 0.0 ? 1 : -1) * *min_distance;
  }
  return true;
}

◆ GetProjection() [2/4]

bool apollo::hdmap::Path::GetProjection	(	const common::math::Vec2d &	point,
		double *	accumulate_s,
		double *	lateral
	)		const

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

                                                {
  double distance = 0.0;
  return GetProjection(point, accumulate_s, lateral, &distance);
}

◆ GetProjection() [3/4]

bool apollo::hdmap::Path::GetProjection	(	const common::math::Vec2d &	point,
		double *	accumulate_s,
		double *	lateral,
		double *	distance
	)		const

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

                                                                      {
  if (segments_.empty()) {
    return false;
  }
  if (accumulate_s == nullptr || lateral == nullptr ||
      min_distance == nullptr) {
    return false;
  }
  if (use_path_approximation_) {
    return approximation_.GetProjection(*this, point, accumulate_s, lateral,
                                        min_distance);
  }
  CHECK_GE(num_points_, 2);
  *min_distance = std::numeric_limits<double>::infinity();
  int min_index = 0;
  for (int i = 0; i < num_segments_; ++i) {
    const double distance = segments_[i].DistanceSquareTo(point);
    if (distance < *min_distance) {
      min_index = i;
      *min_distance = distance;
    }
  }
  *min_distance = std::sqrt(*min_distance);
  const auto& nearest_seg = segments_[min_index];
  const auto prod = nearest_seg.ProductOntoUnit(point);
  const auto proj = nearest_seg.ProjectOntoUnit(point);
  if (min_index == 0) {
    *accumulate_s = std::min(proj, nearest_seg.length());
    if (proj < 0) {
      *lateral = prod;
    } else {
      *lateral = (prod > 0.0 ? 1 : -1) * *min_distance;
    }
  } else if (min_index == num_segments_ - 1) {
    *accumulate_s = accumulated_s_[min_index] + std::max(0.0, proj);
    if (proj > 0) {
      *lateral = prod;
    } else {
      *lateral = (prod > 0.0 ? 1 : -1) * *min_distance;
    }
  } else {
    *accumulate_s = accumulated_s_[min_index] +
                    std::max(0.0, std::min(proj, nearest_seg.length()));
    *lateral = (prod > 0.0 ? 1 : -1) * *min_distance;
  }
  return true;
}

◆ GetProjection() [4/4]

bool apollo::hdmap::Path::GetProjection	(	const double	heading,
		const common::math::Vec2d &	point,
		double *	accumulate_s,
		double *	lateral
	)		const

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

                                                                      {
  double distance = 0.0;
  return GetProjection(point, heading, accumulate_s, lateral, &distance);
}

◆ GetProjectionWithHueristicParams()

bool apollo::hdmap::Path::GetProjectionWithHueristicParams	(	const common::math::Vec2d &	point,
		const double	hueristic_start_s,
		const double	hueristic_end_s,
		double *	accumulate_s,
		double *	lateral,
		double *	min_distance
	)		const

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

                                                                        {
  if (segments_.empty()) {
    return false;
  }
  if (accumulate_s == nullptr || lateral == nullptr ||
      min_distance == nullptr) {
    return false;
  }
  CHECK_GE(num_points_, 2);
  *min_distance = std::numeric_limits<double>::infinity();
 
  int start_interpolation_index = GetIndexFromS(hueristic_start_s).id;
  int end_interpolation_index = static_cast<int>(
      std::fmin(num_segments_, GetIndexFromS(hueristic_end_s).id + 1));
  int min_index = start_interpolation_index;
  for (int i = start_interpolation_index; i <= end_interpolation_index; ++i) {
    const double distance = segments_[i].DistanceSquareTo(point);
    if (distance < *min_distance) {
      min_index = i;
      *min_distance = distance;
    }
  }
  *min_distance = std::sqrt(*min_distance);
  const auto& nearest_seg = segments_[min_index];
  const auto prod = nearest_seg.ProductOntoUnit(point);
  const auto proj = nearest_seg.ProjectOntoUnit(point);
  if (min_index == 0) {
    *accumulate_s = std::min(proj, nearest_seg.length());
    if (proj < 0) {
      *lateral = prod;
    } else {
      *lateral = (prod > 0.0 ? 1 : -1) * *min_distance;
    }
  } else if (min_index == num_segments_ - 1) {
    *accumulate_s = accumulated_s_[min_index] + std::max(0.0, proj);
    if (proj > 0) {
      *lateral = prod;
    } else {
      *lateral = (prod > 0.0 ? 1 : -1) * *min_distance;
    }
  } else {
    *accumulate_s = accumulated_s_[min_index] +
                    std::max(0.0, std::min(proj, nearest_seg.length()));
    *lateral = (prod > 0.0 ? 1 : -1) * *min_distance;
  }
  return true;
}

◆ GetProjectionWithWarmStartS()

bool apollo::hdmap::Path::GetProjectionWithWarmStartS	(	const common::math::Vec2d &	point,
		double *	accumulate_s,
		double *	lateral
	)		const

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

                                                              {
  if (segments_.empty()) {
    return false;
  }
  if (accumulate_s == nullptr || lateral == nullptr) {
    return false;
  }
  if (*accumulate_s < 0.0) {
    *accumulate_s = 0.0;
  } else if (*accumulate_s > length()) {
    *accumulate_s = length();
  }
  CHECK_GE(num_points_, 2);
  double warm_start_s = *accumulate_s;
  // Find the segment at the position of "accumulate_s".
  int left_index = 0;
  int right_index = num_segments_;
  int mid_index = 0;
  // Find the segment with projection of the given point on it.
  while (right_index > left_index + 1) {
    FindIndex(left_index, right_index, warm_start_s, &mid_index);
    const auto& segment = segments_[mid_index];
    const auto& start_point = segment.start();
    double delta_x = point.x() - start_point.x();
    double delta_y = point.y() - start_point.y();
    const auto& unit_direction = segment.unit_direction();
    double proj = delta_x * unit_direction.x() + delta_y * unit_direction.y();
    *accumulate_s = accumulated_s_[mid_index] + proj;
    *lateral = unit_direction.x() * delta_y - unit_direction.y() * delta_x;
    if (proj > 0.0) {
      if (proj < segment.length()) {
        return true;
      }
      if (mid_index == right_index) {
        *accumulate_s = accumulated_s_[mid_index];
        return true;
      }
      left_index = mid_index + 1;
    } else {
      if (mid_index == left_index) {
        *accumulate_s = accumulated_s_[mid_index];
        return true;
      }
      if (std::abs(proj) < segments_[mid_index - 1].length()) {
        return true;
      }
      right_index = mid_index - 1;
    }
    warm_start_s = segment.length() + proj;
  }
  return true;
}

◆ GetRoadLeftWidth()

double apollo::hdmap::Path::GetRoadLeftWidth ( const double s ) const

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

                                                  {
  return GetSample(road_left_width_, s);
}

◆ GetRoadRightWidth()

double apollo::hdmap::Path::GetRoadRightWidth ( const double s ) const

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

                                                   {
  return GetSample(road_right_width_, s);
}

◆ GetRoadWidth()

bool apollo::hdmap::Path::GetRoadWidth	(	const double	s,
		double *	road_left_width,
		double *	road_ight_width
	)		const

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

                                                        {
  CHECK_NOTNULL(road_left_width);
  CHECK_NOTNULL(road_right_width);
 
  if (s < 0.0 || s > length_) {
    return false;
  }
 
  *road_left_width = GetSample(road_left_width_, s);
  *road_right_width = GetSample(road_right_width_, s);
  return true;
}

◆ GetSample()

double apollo::hdmap::Path::GetSample	(	const std::vector< double > &	samples,
		const double	s
	)		const

protected

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

                                             {
  if (samples.empty()) {
    return 0.0;
  }
  if (s <= 0.0) {
    return samples[0];
  }
  const int idx = static_cast<int>(s / kSampleDistance);
  if (idx >= num_sample_points_ - 1) {
    return samples.back();
  }
  const double ratio = (s - idx * kSampleDistance) / kSampleDistance;
  return samples[idx] * (1.0 - ratio) + samples[idx + 1] * ratio;
}

◆ GetSFromIndex()

double apollo::hdmap::Path::GetSFromIndex ( const InterpolatedIndex & index ) const

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

                                                               {
  if (index.id < 0) {
    return 0.0;
  }
  if (index.id >= num_points_) {
    return length_;
  }
  return accumulated_s_[index.id] + index.offset;
}

◆ GetSmoothPoint() [1/2]

MapPathPoint apollo::hdmap::Path::GetSmoothPoint ( const InterpolatedIndex & index ) const

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

                                                                      {
  CHECK_GE(index.id, 0);
  CHECK_LT(index.id, num_points_);
 
  const MapPathPoint& ref_point = path_points_[index.id];
  if (std::abs(index.offset) > kMathEpsilon) {
    const Vec2d delta = unit_directions_[index.id] * index.offset;
    MapPathPoint point({ref_point.x() + delta.x(), ref_point.y() + delta.y()},
                       ref_point.heading());
    if (index.id < num_segments_ && !ref_point.lane_waypoints().empty()) {
      const LaneSegment& lane_segment = lane_segments_to_next_point_[index.id];
      auto ref_lane_waypoint = ref_point.lane_waypoints()[0];
      if (lane_segment.lane != nullptr) {
        for (const auto& lane_waypoint : ref_point.lane_waypoints()) {
          if (lane_waypoint.lane->id().id() == lane_segment.lane->id().id()) {
            ref_lane_waypoint = lane_waypoint;
            break;
          }
        }
        point.add_lane_waypoint(
            LaneWaypoint(lane_segment.lane, lane_segment.start_s + index.offset,
                         ref_lane_waypoint.l));
      }
    }
    if (point.lane_waypoints().empty() && !ref_point.lane_waypoints().empty()) {
      point.add_lane_waypoint(ref_point.lane_waypoints()[0]);
    }
    return point;
  } else {
    return ref_point;
  }
}

◆ GetSmoothPoint() [2/2]

MapPathPoint apollo::hdmap::Path::GetSmoothPoint ( double s ) const

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

                                                {
  return GetSmoothPoint(GetIndexFromS(s));
}

◆ Init()

void apollo::hdmap::Path::Init ( )

protected

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

                {
  InitPoints();
  InitLaneSegments();
  InitPointIndex();
  InitWidth();
  InitOverlaps();
}

◆ InitLaneSegments()

void apollo::hdmap::Path::InitLaneSegments ( )

protected

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

                            {
  if (lane_segments_.empty()) {
    for (int i = 0; i + 1 < num_points_; ++i) {
      LaneSegment lane_segment;
      if (FindLaneSegment(path_points_[i], path_points_[i + 1],
                          &lane_segment)) {
        lane_segments_.push_back(lane_segment);
      }
    }
  }
  LaneSegment::Join(&lane_segments_);
  if (lane_segments_.empty()) {
    return;
  }
  lane_accumulated_s_.resize(lane_segments_.size());
  lane_accumulated_s_[0] = lane_segments_[0].Length();
  for (std::size_t i = 1; i < lane_segments_.size(); ++i) {
    lane_accumulated_s_[i] =
        lane_accumulated_s_[i - 1] + lane_segments_[i].Length();
  }
 
  lane_segments_to_next_point_.clear();
  lane_segments_to_next_point_.reserve(num_points_);
  for (int i = 0; i + 1 < num_points_; ++i) {
    LaneSegment lane_segment;
    if (FindLaneSegment(path_points_[i], path_points_[i + 1], &lane_segment)) {
      lane_segments_to_next_point_.push_back(lane_segment);
    } else {
      lane_segments_to_next_point_.push_back(LaneSegment());
    }
  }
  CHECK_EQ(lane_segments_to_next_point_.size(),
           static_cast<size_t>(num_segments_));
}

◆ InitOverlaps()

void apollo::hdmap::Path::InitOverlaps ( )

protected

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

                        {
  GetAllOverlaps(std::bind(&LaneInfo::cross_lanes, _1), &lane_overlaps_);
  GetAllOverlaps(std::bind(&LaneInfo::signals, _1), &signal_overlaps_);
  GetAllOverlaps(std::bind(&LaneInfo::yield_signs, _1), &yield_sign_overlaps_);
  GetAllOverlaps(std::bind(&LaneInfo::stop_signs, _1), &stop_sign_overlaps_);
  GetAllOverlaps(std::bind(&LaneInfo::crosswalks, _1), &crosswalk_overlaps_);
  GetAllOverlaps(std::bind(&LaneInfo::junctions, _1), &junction_overlaps_);
  GetAllOverlaps(std::bind(&LaneInfo::pnc_junctions, _1),
                 &pnc_junction_overlaps_);
  GetAllOverlaps(std::bind(&LaneInfo::clear_areas, _1), &clear_area_overlaps_);
  GetAllOverlaps(std::bind(&LaneInfo::speed_bumps, _1), &speed_bump_overlaps_);
  GetAllOverlaps(std::bind(&LaneInfo::parking_spaces, _1),
                 &parking_space_overlaps_);
  GetAllOverlaps(std::bind(&LaneInfo::areas, _1), &area_overlaps_);
}

◆ InitPointIndex()

void apollo::hdmap::Path::InitPointIndex ( )

protected

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

                          {
  last_point_index_.clear();
  last_point_index_.reserve(num_sample_points_);
  double s = 0.0;
  int last_index = 0;
  for (int i = 0; i < num_sample_points_; ++i) {
    while (last_index + 1 < num_points_ &&
           accumulated_s_[last_index + 1] <= s) {
      ++last_index;
    }
    last_point_index_.push_back(last_index);
    s += kSampleDistance;
  }
  CHECK_EQ(last_point_index_.size(), static_cast<size_t>(num_sample_points_));
}

◆ InitPoints()

void apollo::hdmap::Path::InitPoints ( )

protected

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

                      {
  num_points_ = static_cast<int>(path_points_.size());
  CHECK_GE(num_points_, 2);
 
  accumulated_s_.clear();
  accumulated_s_.reserve(num_points_);
  segments_.clear();
  segments_.reserve(num_points_);
  unit_directions_.clear();
  unit_directions_.reserve(num_points_);
  double s = 0.0;
  for (int i = 0; i < num_points_; ++i) {
    accumulated_s_.push_back(s);
    Vec2d heading;
    if (i + 1 >= num_points_) {
      heading = path_points_[i] - path_points_[i - 1];
      heading.Normalize();
    } else {
      segments_.emplace_back(path_points_[i], path_points_[i + 1]);
      heading = path_points_[i + 1] - path_points_[i];
      float heading_length = heading.Length();
      // TODO(All): use heading.length when all adjacent lanes are guarantee to
      // be connected.
      s += heading_length;
      // Normalize "heading".
      if (heading_length > 0.0) {
        heading /= heading_length;
      }
    }
    unit_directions_.push_back(heading);
  }
  length_ = s;
  num_sample_points_ = static_cast<int>(length_ / kSampleDistance) + 1;
  num_segments_ = num_points_ - 1;
 
  CHECK_EQ(accumulated_s_.size(), static_cast<size_t>(num_points_));
  CHECK_EQ(unit_directions_.size(), static_cast<size_t>(num_points_));
  CHECK_EQ(segments_.size(), static_cast<size_t>(num_segments_));
}

◆ InitWidth()

void apollo::hdmap::Path::InitWidth ( )

protected

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

                     {
  lane_left_width_.clear();
  lane_left_width_.reserve(num_sample_points_);
  lane_right_width_.clear();
  lane_right_width_.reserve(num_sample_points_);
 
  road_left_width_.clear();
  road_left_width_.reserve(num_sample_points_);
  road_right_width_.clear();
  road_right_width_.reserve(num_sample_points_);
 
  double sample_s = 0;
  double segment_end_s = -1.0;
  double segment_start_s = -1.0;
  double waypoint_s = 0.0;
  double left_width = 0.0;
  double right_width = 0.0;
  const LaneWaypoint* cur_waypoint = nullptr;
  bool is_reach_to_end = false;
  int path_point_index = 0;
  for (int i = 0; i < num_sample_points_; ++i) {
    // Find the segment at the position of "sample_s".
    while (segment_end_s < sample_s && !is_reach_to_end) {
      const auto& cur_point = path_points_[path_point_index];
      cur_waypoint = &(cur_point.lane_waypoints()[0]);
      CHECK_NOTNULL(cur_waypoint->lane);
      segment_start_s = accumulated_s_[path_point_index];
      segment_end_s = segment_start_s + segments_[path_point_index].length();
      if (++path_point_index >= num_points_) {
        is_reach_to_end = true;
      }
    }
    // Find the width of the way point at the position of "sample_s".
    waypoint_s = cur_waypoint->s + sample_s - segment_start_s;
    cur_waypoint->lane->GetWidth(waypoint_s, &left_width, &right_width);
    lane_left_width_.push_back(left_width - cur_waypoint->l);
    lane_right_width_.push_back(right_width + cur_waypoint->l);
    cur_waypoint->lane->GetRoadWidth(waypoint_s, &left_width, &right_width);
    road_left_width_.push_back(left_width - cur_waypoint->l);
    road_right_width_.push_back(right_width + cur_waypoint->l);
    sample_s += kSampleDistance;
  }
  // Check the width array size.
  auto num_sample_points = static_cast<size_t>(num_sample_points_);
  CHECK_EQ(lane_left_width_.size(), num_sample_points);
  CHECK_EQ(lane_right_width_.size(), num_sample_points);
 
  CHECK_EQ(road_left_width_.size(), num_sample_points);
  CHECK_EQ(road_right_width_.size(), num_sample_points);
}

◆ IsOnPath()

bool apollo::hdmap::Path::IsOnPath ( const common::math::Vec2d & point ) const

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

                                            {
  double accumulate_s = 0.0;
  double lateral = 0.0;
  if (!GetProjection(point, &accumulate_s, &lateral)) {
    return false;
  }
  double lane_left_width = 0.0;
  double lane_right_width = 0.0;
  if (!GetLaneWidth(accumulate_s, &lane_left_width, &lane_right_width)) {
    return false;
  }
  if (lateral < lane_left_width && lateral > -lane_right_width) {
    return true;
  }
  return false;
}

◆ junction_overlaps()

const std::vector< PathOverlap > & apollo::hdmap::Path::junction_overlaps ( ) const

inline

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

                                                          {
    return junction_overlaps_;
  }

◆ lane_overlaps()

const std::vector< PathOverlap > & apollo::hdmap::Path::lane_overlaps ( ) const

inline

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

                                                      {
    return lane_overlaps_;
  }

◆ lane_segments()

const std::vector< LaneSegment > & apollo::hdmap::Path::lane_segments ( ) const

inline

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

                                                      {
    return lane_segments_;
  }

◆ lane_segments_to_next_point()

const std::vector< LaneSegment > & apollo::hdmap::Path::lane_segments_to_next_point ( ) const

inline

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

                                                                    {
    return lane_segments_to_next_point_;
  }

◆ length()

double apollo::hdmap::Path::length ( ) const

inline

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

294{ return length_; }

◆ NextLaneOverlap()

const PathOverlap * apollo::hdmap::Path::NextLaneOverlap ( double s ) const

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

                                                       {
  auto next = std::upper_bound(
      lane_overlaps_.begin(), lane_overlaps_.end(), s,
      [](double s, const PathOverlap& o) { return s < o.start_s; });
  if (next == lane_overlaps_.end()) {
    return nullptr;
  } else {
    return &(*next);
  }
}

◆ num_points()

int apollo::hdmap::Path::num_points ( ) const

inline

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

277{ return num_points_; }

◆ num_segments()

int apollo::hdmap::Path::num_segments ( ) const

inline

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

278{ return num_segments_; }

◆ OverlapWith()

bool apollo::hdmap::Path::OverlapWith	(	const common::math::Box2d &	box,
		double	width
	)		const

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

                                                                     {
  if (use_path_approximation_) {
    return approximation_.OverlapWith(*this, box, width);
  }
  const Vec2d center = box.center();
  const double radius_sqr = Sqr(box.diagonal() / 2.0 + width) + kMathEpsilon;
  for (const auto& segment : segments_) {
    if (segment.DistanceSquareTo(center) > radius_sqr) {
      continue;
    }
    if (box.DistanceTo(segment) <= width + kMathEpsilon) {
      return true;
    }
  }
  return false;
}

◆ parking_space_overlaps()

const std::vector< PathOverlap > & apollo::hdmap::Path::parking_space_overlaps ( ) const

inline

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

                                                               {
    return parking_space_overlaps_;
  }

◆ path_points()

const std::vector< MapPathPoint > & apollo::hdmap::Path::path_points ( ) const

inline

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

279{ return path_points_; }

◆ pnc_junction_overlaps()

const std::vector< PathOverlap > & apollo::hdmap::Path::pnc_junction_overlaps ( ) const

inline

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

                                                              {
    return pnc_junction_overlaps_;
  }

◆ segments()

const std::vector< common::math::LineSegment2d > & apollo::hdmap::Path::segments ( ) const

inline

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

                                                             {
    return segments_;
  }

◆ signal_overlaps()

const std::vector< PathOverlap > & apollo::hdmap::Path::signal_overlaps ( ) const

inline

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

                                                        {
    return signal_overlaps_;
  }

◆ speed_bump_overlaps()

const std::vector< PathOverlap > & apollo::hdmap::Path::speed_bump_overlaps ( ) const

inline

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

                                                            {
    return speed_bump_overlaps_;
  }

◆ stop_sign_overlaps()

const std::vector< PathOverlap > & apollo::hdmap::Path::stop_sign_overlaps ( ) const

inline

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

                                                           {
    return stop_sign_overlaps_;
  }

◆ unit_directions()

const std::vector< common::math::Vec2d > & apollo::hdmap::Path::unit_directions ( ) const

inline

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

                                                            {
    return unit_directions_;
  }

◆ yield_sign_overlaps()

const std::vector< PathOverlap > & apollo::hdmap::Path::yield_sign_overlaps ( ) const

inline

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

                                                            {
    return yield_sign_overlaps_;
  }

类成员变量说明

◆ accumulated_s_

std::vector<double> apollo::hdmap::Path::accumulated_s_

protected

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

◆ approximation_

PathApproximation apollo::hdmap::Path::approximation_

protected

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

◆ area_overlaps_

std::vector<PathOverlap> apollo::hdmap::Path::area_overlaps_

protected

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

◆ clear_area_overlaps_

std::vector<PathOverlap> apollo::hdmap::Path::clear_area_overlaps_

protected

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

◆ crosswalk_overlaps_

std::vector<PathOverlap> apollo::hdmap::Path::crosswalk_overlaps_

protected

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

◆ dead_end_overlaps_

std::vector<PathOverlap> apollo::hdmap::Path::dead_end_overlaps_

protected

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

◆ junction_overlaps_

std::vector<PathOverlap> apollo::hdmap::Path::junction_overlaps_

protected

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

◆ lane_accumulated_s_

std::vector<double> apollo::hdmap::Path::lane_accumulated_s_

protected

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

◆ lane_left_width_

std::vector<double> apollo::hdmap::Path::lane_left_width_

protected

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

◆ lane_overlaps_

std::vector<PathOverlap> apollo::hdmap::Path::lane_overlaps_

protected

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

◆ lane_right_width_

std::vector<double> apollo::hdmap::Path::lane_right_width_

protected

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

◆ lane_segments_

std::vector<LaneSegment> apollo::hdmap::Path::lane_segments_

protected

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

◆ lane_segments_to_next_point_

std::vector<LaneSegment> apollo::hdmap::Path::lane_segments_to_next_point_

protected

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

◆ last_point_index_

std::vector<int> apollo::hdmap::Path::last_point_index_

protected

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

◆ length_

double apollo::hdmap::Path::length_ = 0.0

protected

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

◆ num_points_

int apollo::hdmap::Path::num_points_ = 0

protected

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

◆ num_sample_points_

int apollo::hdmap::Path::num_sample_points_ = 0

protected

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

◆ num_segments_

int apollo::hdmap::Path::num_segments_ = 0

protected

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

◆ parking_space_overlaps_

std::vector<PathOverlap> apollo::hdmap::Path::parking_space_overlaps_

protected

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

◆ path_points_

std::vector<MapPathPoint> apollo::hdmap::Path::path_points_

protected

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

◆ pnc_junction_overlaps_

std::vector<PathOverlap> apollo::hdmap::Path::pnc_junction_overlaps_

protected

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

◆ road_left_width_

std::vector<double> apollo::hdmap::Path::road_left_width_

protected

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

◆ road_right_width_

std::vector<double> apollo::hdmap::Path::road_right_width_

protected

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

◆ segments_

std::vector<common::math::LineSegment2d> apollo::hdmap::Path::segments_

protected

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

◆ signal_overlaps_

std::vector<PathOverlap> apollo::hdmap::Path::signal_overlaps_

protected

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

◆ speed_bump_overlaps_

std::vector<PathOverlap> apollo::hdmap::Path::speed_bump_overlaps_

protected

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

◆ stop_sign_overlaps_

std::vector<PathOverlap> apollo::hdmap::Path::stop_sign_overlaps_

protected

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

◆ unit_directions_

std::vector<common::math::Vec2d> apollo::hdmap::Path::unit_directions_

protected

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

◆ use_path_approximation_

bool apollo::hdmap::Path::use_path_approximation_ = false

protected

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

◆ yield_sign_overlaps_

std::vector<PathOverlap> apollo::hdmap::Path::yield_sign_overlaps_

protected

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

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

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

Public 成员函数

Protected 类型

Protected 成员函数

Protected 属性

详细描述

成员类型定义说明

◆ GetOverlapFromLaneFunc

构造及析构函数说明

◆ Path() [1/9]

◆ Path() [2/9]

◆ Path() [3/9]

◆ Path() [4/9]

◆ Path() [5/9]

◆ Path() [6/9]

◆ Path() [7/9]

◆ Path() [8/9]

◆ Path() [9/9]

成员函数说明

◆ accumulated_s()

◆ approximation()

◆ area_overlaps()

◆ clear_area_overlaps()

◆ crosswalk_overlaps()

◆ dead_end_overlaps()

◆ DebugString()

◆ GetAllOverlaps()

◆ GetHeadingAlongPath()

◆ GetIndexFromS()

◆ GetLaneIndexFromS()

◆ GetLaneLeftWidth()

◆ GetLaneRightWidth()

◆ GetLaneSegments()

◆ GetLaneWidth()

◆ GetNearestPoint() [1/2]

◆ GetNearestPoint() [2/2]

◆ GetProjection() [1/4]

◆ GetProjection() [2/4]

◆ GetProjection() [3/4]

◆ GetProjection() [4/4]

◆ GetProjectionWithHueristicParams()

◆ GetProjectionWithWarmStartS()

◆ GetRoadLeftWidth()

◆ GetRoadRightWidth()

◆ GetRoadWidth()

◆ GetSample()

◆ GetSFromIndex()

◆ GetSmoothPoint() [1/2]

◆ GetSmoothPoint() [2/2]

◆ Init()

◆ InitLaneSegments()

◆ InitOverlaps()

◆ InitPointIndex()

◆ InitPoints()

◆ InitWidth()

◆ IsOnPath()

◆ junction_overlaps()

◆ lane_overlaps()

◆ lane_segments()

◆ lane_segments_to_next_point()

◆ length()

◆ NextLaneOverlap()

◆ num_points()

◆ num_segments()

◆ OverlapWith()

◆ parking_space_overlaps()

◆ path_points()

◆ pnc_junction_overlaps()

◆ segments()

◆ signal_overlaps()

◆ speed_bump_overlaps()

◆ stop_sign_overlaps()

◆ unit_directions()

◆ yield_sign_overlaps()

类成员变量说明

◆ accumulated_s_

◆ approximation_

◆ area_overlaps_

◆ clear_area_overlaps_

◆ crosswalk_overlaps_

◆ dead_end_overlaps_