ReferenceLineInfo holds all data for one reference line. 更多...

#include <reference_line_info.h>

apollo::planning::ReferenceLineInfo 的协作图:

Public 类型
enum class	LaneType { LeftForward , LeftReverse , RightForward , RightReverse }

enum	OverlapType { CLEAR_AREA = 1 , CROSSWALK = 2 , OBSTACLE = 3 , PNC_JUNCTION = 4 , SIGNAL = 5 , STOP_SIGN = 6 , YIELD_SIGN = 7 , JUNCTION = 8 , AREA = 9 }

Public 成员函数
	ReferenceLineInfo ()=default

	ReferenceLineInfo (const common::VehicleState &vehicle_state, const common::TrajectoryPoint &adc_planning_point, const ReferenceLine &reference_line, const hdmap::RouteSegments &segments)

bool	Init (const std::vector< const Obstacle * > &obstacles, double target_speed)

bool	AddObstacles (const std::vector< const Obstacle * > &obstacles)

Obstacle *	AddObstacle (const Obstacle *obstacle)

const common::VehicleState &	vehicle_state () const

PathDecision *	path_decision ()

const PathDecision &	path_decision () const

const ReferenceLine &	reference_line () const

ReferenceLine *	mutable_reference_line ()

double	SDistanceToDestination () const

double	SDistanceToRefEnd () const

bool	ReachedDestination () const

void	SetTrajectory (const DiscretizedTrajectory &trajectory)

const DiscretizedTrajectory &	trajectory () const

double	Cost () const

void	AddCost (double cost)

void	SetCost (double cost)

double	PriorityCost () const

void	SetPriorityCost (double cost)

void	SetLatticeStopPoint (const StopPoint &stop_point)

void	SetLatticeCruiseSpeed (double speed)

const PlanningTarget &	planning_target () const

void	SetCruiseSpeed (double speed)

void	LimitCruiseSpeed (double speed)
	Limit the cruise speed based on the "base_cruise_speed_".

double	GetBaseCruiseSpeed () const

double	GetCruiseSpeed () const

hdmap::LaneInfoConstPtr	LocateLaneInfo (const double s) const

bool	GetNeighborLaneInfo (const ReferenceLineInfo::LaneType lane_type, const double s, hdmap::Id ptr_lane_id, double ptr_lane_width) const

bool	IsStartFrom (const ReferenceLineInfo &previous_reference_line_info) const
	check if current reference line is started from another reference line info line.

planning_internal::Debug *	mutable_debug ()

const planning_internal::Debug &	debug () const

LatencyStats *	mutable_latency_stats ()

const LatencyStats &	latency_stats () const

const PathData &	path_data () const

const PathData &	fallback_path_data () const

const SpeedData &	speed_data () const

PathData *	mutable_path_data ()

PathData *	mutable_fallback_path_data ()

SpeedData *	mutable_speed_data ()

const RSSInfo &	rss_info () const

RSSInfo *	mutable_rss_info ()

bool	CombinePathAndSpeedProfile (const double relative_time, const double start_s, DiscretizedTrajectory *discretized_trajectory)

bool	AdjustTrajectoryWhichStartsFromCurrentPos (const common::TrajectoryPoint &planning_start_point, const std::vector< common::TrajectoryPoint > &trajectory, DiscretizedTrajectory *adjusted_trajectory)

const SLBoundary &	AdcSlBoundary () const

std::string	PathSpeedDebugString () const

void	PrintReferenceSegmentDebugString ()

bool	IsChangeLanePath () const
	Check if the current reference line is a change lane reference line, i.e., ADC's current position is not on this reference line.

bool	IsNeighborLanePath () const
	Check if the current reference line is the neighbor of the vehicle current position

void	SetDrivable (bool drivable)
	Set if the vehicle can drive following this reference line A planner need to set this value to true if the reference line is OK

bool	IsDrivable () const

void	ExportEngageAdvice (common::EngageAdvice engage_advice, PlanningContext planning_context) const

const hdmap::RouteSegments &	Lanes () const

std::list< hdmap::Id >	TargetLaneId () const

void	ExportDecision (DecisionResult decision_result, PlanningContext planning_context) const

void	SetJunctionRightOfWay (const double junction_s, const bool is_protected) const

ADCTrajectory::RightOfWayStatus	GetRightOfWayStatus () const

hdmap::Lane::LaneTurn	GetPathTurnType (const double s) const

bool	GetIntersectionRightofWayStatus (const hdmap::PathOverlap &pnc_junction_overlap) const

double	OffsetToOtherReferenceLine () const

void	SetOffsetToOtherReferenceLine (const double offset)

const std::vector< PathBoundary > &	GetCandidatePathBoundaries () const

void	SetCandidatePathBoundaries (std::vector< PathBoundary > &&candidate_path_boundaries)

const std::vector< PathData > &	GetCandidatePathData () const

std::vector< PathData > *	MutableCandidatePathData ()

void	SetCandidatePathData (std::vector< PathData > &&candidate_path_data)

Obstacle *	GetBlockingObstacle () const

void	SetBlockingObstacle (const std::string &blocking_obstacle_id)

bool	is_path_lane_borrow () const

void	set_is_path_lane_borrow (const bool is_path_lane_borrow)

void	set_is_on_reference_line ()

uint32_t	GetPriority () const

void	SetPriority (uint32_t priority)

void	set_trajectory_type (const ADCTrajectory::TrajectoryType trajectory_type)

ADCTrajectory::TrajectoryType	trajectory_type () const

StGraphData *	mutable_st_graph_data ()

const StGraphData &	st_graph_data ()

const std::vector< std::pair< OverlapType, hdmap::PathOverlap > > &	FirstEncounteredOverlaps () const

int	GetPnCJunction (const double s, hdmap::PathOverlap *pnc_junction_overlap) const

int	GetJunction (const double s, hdmap::PathOverlap *junction_overlap) const

int	GetArea (const double s, hdmap::PathOverlap *area_overlap) const

std::vector< common::SLPoint >	GetAllStopDecisionSLPoint () const

void	SetTurnSignal (const common::VehicleSignal::TurnSignal &turn_signal)

void	SetEmergencyLight ()

void	set_path_reusable (const bool path_reusable)

bool	path_reusable () const

hdmap::PathOverlap *	GetOverlapOnReferenceLine (const std::string &overlap_id, const OverlapType &overlap_type) const

void	set_key (std::size_t key)

std::size_t	key () const

void	set_index (std::size_t index)

std::size_t	index () const

void	set_id (std::string id)

std::string	id () const

void	GetRangeOverlaps (std::vector< hdmap::PathOverlap > *path_overlaps, double start_s, double end_s)

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

std::vector< double > *	mutable_reference_line_towing_l ()

const PathBoundary &	reference_line_towing_path_boundary () const

PathBoundary *	mutable_reference_line_towing_path_boundary ()

const std::vector< SLPolygon > &	obs_sl_polygons () const

std::vector< SLPolygon > *	mutable_obs_sl_polygons ()

详细描述

ReferenceLineInfo holds all data for one reference line.

在文件 reference_line_info.h 第 56 行定义.

成员枚举类型说明

◆ LaneType

enum class apollo::planning::ReferenceLineInfo::LaneType

strong

枚举值
LeftForward
LeftReverse
RightForward
RightReverse

在文件 reference_line_info.h 第 58 行定义.

58{ LeftForward, LeftReverse, RightForward, RightReverse };

apollo::planning::ReferenceLineInfo::LaneType::LeftReverse

@ LeftReverse

apollo::planning::ReferenceLineInfo::LaneType::LeftForward

@ LeftForward

apollo::planning::ReferenceLineInfo::LaneType::RightReverse

@ RightReverse

apollo::planning::ReferenceLineInfo::LaneType::RightForward

@ RightForward

◆ OverlapType

enum apollo::planning::ReferenceLineInfo::OverlapType

枚举值
CLEAR_AREA
CROSSWALK
OBSTACLE
PNC_JUNCTION
SIGNAL
STOP_SIGN
YIELD_SIGN
JUNCTION
AREA

在文件 reference_line_info.h 第 239 行定义.

                   {
    CLEAR_AREA = 1,
    CROSSWALK = 2,
    OBSTACLE = 3,
    PNC_JUNCTION = 4,
    SIGNAL = 5,
    STOP_SIGN = 6,
    YIELD_SIGN = 7,
    JUNCTION = 8,
    AREA = 9,
  };

构造及析构函数说明

◆ ReferenceLineInfo() [1/2]

apollo::planning::ReferenceLineInfo::ReferenceLineInfo ( )

default

◆ ReferenceLineInfo() [2/2]

apollo::planning::ReferenceLineInfo::ReferenceLineInfo	(	const common::VehicleState &	vehicle_state,
		const common::TrajectoryPoint &	adc_planning_point,
		const ReferenceLine &	reference_line,
		const hdmap::RouteSegments &	segments
	)

在文件 reference_line_info.cc 第 53 行定义.

    : vehicle_state_(vehicle_state),
      adc_planning_point_(adc_planning_point),
      reference_line_(reference_line),
      lanes_(segments) {
  if (lanes_.size() == 0) {
    return;
  }
  std::ostringstream segs_id;
  segs_id.setf(std::ios::fixed);
  segs_id.precision(2);
  segs_id.str("");
  for (const auto& seg : lanes_) {
    segs_id << "_" << seg.lane->id().id();
  }
 
  segs_id << "_" << lanes_.front().start_s << "_" << lanes_.back().end_s;
  key_ = cyber::common::Hash(segs_id.str());
  id_ = segs_id.str();
}

成员函数说明

◆ AdcSlBoundary()

const SLBoundary & apollo::planning::ReferenceLineInfo::AdcSlBoundary ( ) const

在文件 reference_line_info.cc 第 366 行定义.

                                                         {
  return adc_sl_boundary_;
}

◆ AddCost()

void apollo::planning::ReferenceLineInfo::AddCost ( double cost )

inline

在文件 reference_line_info.h 第 88 行定义.

88{ cost_ += cost; }

◆ AddObstacle()

Obstacle * apollo::planning::ReferenceLineInfo::AddObstacle ( const Obstacle * obstacle )

在文件 reference_line_info.cc 第 394 行定义.

                                                                 {
  if (!obstacle) {
    AERROR << "The provided obstacle is empty";
    return nullptr;
  }
  auto* mutable_obstacle = path_decision_.AddObstacle(*obstacle);
  if (!mutable_obstacle) {
    AERROR << "failed to add obstacle " << obstacle->Id();
    return nullptr;
  }
 
  SLBoundary perception_sl;
  if (!reference_line_.GetSLBoundary(obstacle->PerceptionPolygon(),
                                     &perception_sl)) {
    AERROR << "Failed to get sl boundary for obstacle: " << obstacle->Id();
    return mutable_obstacle;
  }
  mutable_obstacle->SetPerceptionSlBoundary(perception_sl);
  mutable_obstacle->CheckLaneBlocking(reference_line_);
  if (mutable_obstacle->IsLaneBlocking()) {
    ADEBUG << "obstacle [" << obstacle->Id() << "] is lane blocking.";
  } else {
    ADEBUG << "obstacle [" << obstacle->Id() << "] is NOT lane blocking.";
  }
 
  if (IsIrrelevantObstacle(*mutable_obstacle)) {
    ObjectDecisionType ignore;
    ignore.mutable_ignore();
    path_decision_.AddLateralDecision("reference_line_filter", obstacle->Id(),
                                      ignore);
    path_decision_.AddLongitudinalDecision("reference_line_filter",
                                           obstacle->Id(), ignore);
    AINFO << "NO build reference line st boundary. id:" << obstacle->Id();
  } else {
    AINFO << "build reference line st boundary. id:" << obstacle->Id();
    mutable_obstacle->BuildReferenceLineStBoundary(reference_line_,
                                                   adc_sl_boundary_.start_s());
 
    ADEBUG << "reference line st boundary: t["
           << mutable_obstacle->reference_line_st_boundary().min_t() << ", "
           << mutable_obstacle->reference_line_st_boundary().max_t() << "] s["
           << mutable_obstacle->reference_line_st_boundary().min_s() << ", "
           << mutable_obstacle->reference_line_st_boundary().max_s() << "]";
  }
  return mutable_obstacle;
}

◆ AddObstacles()

bool apollo::planning::ReferenceLineInfo::AddObstacles ( const std::vector< const Obstacle * > & obstacles )

在文件 reference_line_info.cc 第 441 行定义.

                                                 {
  if (FLAGS_use_multi_thread_to_add_obstacles) {
    std::vector<std::future<Obstacle*>> results;
    for (const auto* obstacle : obstacles) {
      results.push_back(
          cyber::Async(&ReferenceLineInfo::AddObstacle, this, obstacle));
    }
    for (auto& result : results) {
      if (!result.get()) {
        AERROR << "Fail to add obstacles.";
        return false;
      }
    }
  } else {
    for (const auto* obstacle : obstacles) {
      if (!AddObstacle(obstacle)) {
        AERROR << "Failed to add obstacle " << obstacle->Id();
        return false;
      }
    }
  }
 
  return true;
}

◆ AdjustTrajectoryWhichStartsFromCurrentPos()

bool apollo::planning::ReferenceLineInfo::AdjustTrajectoryWhichStartsFromCurrentPos	(	const common::TrajectoryPoint &	planning_start_point,
		const std::vector< common::TrajectoryPoint > &	trajectory,
		DiscretizedTrajectory *	adjusted_trajectory
	)

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

                                                {
  ACHECK(adjusted_trajectory != nullptr);
  // find insert index by check heading
  static constexpr double kMaxAngleDiff = M_PI_2;
  const double start_point_heading = planning_start_point.path_point().theta();
  const double start_point_x = planning_start_point.path_point().x();
  const double start_point_y = planning_start_point.path_point().y();
  const double start_point_relative_time = planning_start_point.relative_time();
 
  int insert_idx = -1;
  for (size_t i = 0; i < trajectory.size(); ++i) {
    // skip trajectory_points early than planning_start_point
    if (trajectory[i].relative_time() <= start_point_relative_time) {
      continue;
    }
 
    const double cur_point_x = trajectory[i].path_point().x();
    const double cur_point_y = trajectory[i].path_point().y();
    const double tracking_heading =
        std::atan2(cur_point_y - start_point_y, cur_point_x - start_point_x);
    if (std::fabs(common::math::AngleDiff(start_point_heading,
                                          tracking_heading)) < kMaxAngleDiff) {
      insert_idx = i;
      break;
    }
  }
  if (insert_idx == -1) {
    AERROR << "All points are behind of planning init point";
    return false;
  }
 
  DiscretizedTrajectory cut_trajectory(trajectory);
  cut_trajectory.erase(cut_trajectory.begin(),
                       cut_trajectory.begin() + insert_idx);
  cut_trajectory.insert(cut_trajectory.begin(), planning_start_point);
 
  // In class TrajectoryStitcher, the stitched point which is also the planning
  // init point is supposed have one planning_cycle_time ahead respect to
  // current timestamp as its relative time. So the relative timelines
  // of planning init point and the trajectory which start from current
  // position(relative time = 0) are the same. Therefore any conflicts on the
  // relative time including the one below should return false and inspected its
  // cause.
  if (cut_trajectory.size() > 1 && cut_trajectory.front().relative_time() >=
                                       cut_trajectory[1].relative_time()) {
    AERROR << "planning init point relative_time["
           << cut_trajectory.front().relative_time()
           << "] larger than its next point's relative_time["
           << cut_trajectory[1].relative_time() << "]";
    return false;
  }
 
  // In class TrajectoryStitcher, the planing_init_point is set to have s as 0,
  // so adjustment is needed to be done on the other points
  double accumulated_s = 0.0;
  for (size_t i = 1; i < cut_trajectory.size(); ++i) {
    const auto& pre_path_point = cut_trajectory[i - 1].path_point();
    auto* cur_path_point = cut_trajectory[i].mutable_path_point();
    accumulated_s += std::sqrt((cur_path_point->x() - pre_path_point.x()) *
                                   (cur_path_point->x() - pre_path_point.x()) +
                               (cur_path_point->y() - pre_path_point.y()) *
                                   (cur_path_point->y() - pre_path_point.y()));
    cur_path_point->set_s(accumulated_s);
  }
 
  // reevaluate relative_time to make delta t the same
  adjusted_trajectory->clear();
  // use varied resolution to reduce data load but also provide enough data
  // point for control module
  const double kDenseTimeResoltuion = FLAGS_trajectory_time_min_interval;
  const double kSparseTimeResolution = FLAGS_trajectory_time_max_interval;
  const double kDenseTimeSec = FLAGS_trajectory_time_high_density_period;
  for (double cur_rel_time = cut_trajectory.front().relative_time();
       cur_rel_time <= cut_trajectory.back().relative_time();
       cur_rel_time += (cur_rel_time < kDenseTimeSec ? kDenseTimeResoltuion
                                                     : kSparseTimeResolution)) {
    adjusted_trajectory->AppendTrajectoryPoint(
        cut_trajectory.Evaluate(cur_rel_time));
  }
  return true;
}

◆ CombinePathAndSpeedProfile()

bool apollo::planning::ReferenceLineInfo::CombinePathAndSpeedProfile	(	const double	relative_time,
		const double	start_s,
		DiscretizedTrajectory *	discretized_trajectory
	)

在文件 reference_line_info.cc 第 531 行定义.

                                                       {
  ACHECK(ptr_discretized_trajectory != nullptr);
  // use varied resolution to reduce data load but also provide enough data
  // point for control module
  const double kDenseTimeResoltuion = FLAGS_trajectory_time_min_interval;
  const double kSparseTimeResolution = FLAGS_trajectory_time_max_interval;
  const double kDenseTimeSec = FLAGS_trajectory_time_high_density_period;
 
  if (path_data_.discretized_path().empty()) {
    AERROR << "path data is empty";
    return false;
  }
 
  if (speed_data_.empty()) {
    AERROR << "speed profile is empty";
    return false;
  }
 
  for (double cur_rel_time = 0.0; cur_rel_time < speed_data_.TotalTime();
       cur_rel_time += (cur_rel_time < kDenseTimeSec ? kDenseTimeResoltuion
                                                     : kSparseTimeResolution)) {
    common::SpeedPoint speed_point;
    if (!speed_data_.EvaluateByTime(cur_rel_time, &speed_point)) {
      AERROR << "Fail to get speed point with relative time " << cur_rel_time;
      return false;
    }
 
    if (speed_point.s() > path_data_.discretized_path().Length()) {
      break;
    }
    common::PathPoint path_point =
        path_data_.GetPathPointWithPathS(speed_point.s());
    path_point.set_s(path_point.s() + start_s);
 
    common::TrajectoryPoint trajectory_point;
    trajectory_point.mutable_path_point()->CopyFrom(path_point);
    trajectory_point.set_v(speed_point.v());
    trajectory_point.set_a(speed_point.a());
    trajectory_point.set_relative_time(speed_point.t() + relative_time);
    ptr_discretized_trajectory->AppendTrajectoryPoint(trajectory_point);
  }
  if (path_data_.is_reverse_path()) {
    std::for_each(ptr_discretized_trajectory->begin(),
                  ptr_discretized_trajectory->end(),
                  [](common::TrajectoryPoint& trajectory_point) {
                    trajectory_point.set_v(-trajectory_point.v());
                    trajectory_point.set_a(-trajectory_point.a());
                    trajectory_point.mutable_path_point()->set_s(
                        -trajectory_point.path_point().s());
                  });
    AINFO << "reversed path";
    ptr_discretized_trajectory->SetIsReversed(true);
  }
  return true;
}

◆ Cost()

double apollo::planning::ReferenceLineInfo::Cost ( ) const

inline

在文件 reference_line_info.h 第 87 行定义.

87{ return cost_; }

◆ debug()

const planning_internal::Debug & apollo::planning::ReferenceLineInfo::debug ( ) const

inline

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

128{ return debug_; }

◆ ExportDecision()

void apollo::planning::ReferenceLineInfo::ExportDecision	(	DecisionResult *	decision_result,
		PlanningContext *	planning_context
	)		const

在文件 reference_line_info.cc 第 873 行定义.

                                                                              {
  MakeDecision(decision_result, planning_context);
  ExportVehicleSignal(decision_result->mutable_vehicle_signal());
  auto* main_decision = decision_result->mutable_main_decision();
  if (main_decision->has_stop()) {
    main_decision->mutable_stop()->set_change_lane_type(
        Lanes().PreviousAction());
  } else if (main_decision->has_cruise()) {
    main_decision->mutable_cruise()->set_change_lane_type(
        Lanes().PreviousAction());
  }
}

◆ ExportEngageAdvice()

void apollo::planning::ReferenceLineInfo::ExportEngageAdvice	(	common::EngageAdvice *	engage_advice,
		PlanningContext *	planning_context
	)		const

在文件 reference_line_info.cc 第 1008 行定义.

                                                                          {
  static EngageAdvice prev_advice;
  static constexpr double kMaxAngleDiff = M_PI / 6.0;
 
  bool engage = false;
  if (!IsDrivable()) {
    prev_advice.set_reason("Reference line not drivable");
  } else if (!is_on_reference_line_) {
    const auto& scenario_type =
        planning_context->planning_status().scenario().scenario_type();
    if (scenario_type == "PARK_AND_GO" || IsChangeLanePath()) {
      // note: when is_on_reference_line_ is FALSE
      //   (1) always engage while in PARK_AND_GO scenario
      //   (2) engage when "ChangeLanePath" is picked as Drivable ref line
      //       where most likely ADC not OnLane yet
      engage = true;
    } else {
      prev_advice.set_reason("Not on reference line");
    }
  } else {
    // check heading
    auto ref_point =
        reference_line_.GetReferencePoint(adc_sl_boundary_.end_s());
    if (common::math::AngleDiff(vehicle_state_.heading(), ref_point.heading()) <
        kMaxAngleDiff) {
      engage = true;
    } else {
      prev_advice.set_reason("Vehicle heading is not aligned");
    }
  }
 
  if (engage) {
    if (vehicle_state_.driving_mode() !=
        Chassis::DrivingMode::Chassis_DrivingMode_COMPLETE_AUTO_DRIVE) {
      // READY_TO_ENGAGE when in non-AUTO mode
      prev_advice.set_advice(EngageAdvice::READY_TO_ENGAGE);
    } else {
      // KEEP_ENGAGED when in AUTO mode
      prev_advice.set_advice(EngageAdvice::KEEP_ENGAGED);
    }
    prev_advice.clear_reason();
  } else {
    if (prev_advice.advice() != EngageAdvice::DISALLOW_ENGAGE) {
      prev_advice.set_advice(EngageAdvice::PREPARE_DISENGAGE);
    }
  }
  engage_advice->CopyFrom(prev_advice);
}

◆ fallback_path_data()

const PathData & apollo::planning::ReferenceLineInfo::fallback_path_data ( ) const

在文件 reference_line_info.cc 第 513 行定义.

                                                            {
  return fallback_path_data_;
}

◆ FirstEncounteredOverlaps()

const std::vector< std::pair< OverlapType, hdmap::PathOverlap > > & apollo::planning::ReferenceLineInfo::FirstEncounteredOverlaps ( ) const

inline

在文件 reference_line_info.h 第 252 行定义.

                                   {
    return first_encounter_overlaps_;
  }

◆ GetAllStopDecisionSLPoint()

std::vector< common::SLPoint > apollo::planning::ReferenceLineInfo::GetAllStopDecisionSLPoint ( ) const

在文件 reference_line_info.cc 第 1164 行定义.

          {
  std::vector<common::SLPoint> result;
  for (const auto* obstacle : path_decision_.obstacles().Items()) {
    const auto& object_decision = obstacle->LongitudinalDecision();
    if (!object_decision.has_stop()) {
      continue;
    }
    apollo::common::PointENU stop_point = object_decision.stop().stop_point();
    common::SLPoint stop_line_sl;
    reference_line_.XYToSL(stop_point, &stop_line_sl);
    if (stop_line_sl.s() <= 0 || stop_line_sl.s() >= reference_line_.Length()) {
      continue;
    }
    result.push_back(stop_line_sl);
  }
 
  // sort by s
  if (!result.empty()) {
    std::sort(result.begin(), result.end(),
              [](const common::SLPoint& a, const common::SLPoint& b) {
                return a.s() < b.s();
              });
  }
 
  return result;
}

◆ GetArea()

int apollo::planning::ReferenceLineInfo::GetArea	(	const double	s,
		hdmap::PathOverlap *	area_overlap
	)		const

在文件 reference_line_info.cc 第 1143 行定义.

                                                                     {
  CHECK_NOTNULL(area_overlap);
  const std::vector<hdmap::PathOverlap>& area_overlaps =
      reference_line_.map_path().area_overlaps();
 
  static constexpr double kError = 1.0;  // meter
  for (const auto& overlap : area_overlaps) {
    if (s >= overlap.start_s - kError && s <= overlap.end_s + kError) {
      *area_overlap = overlap;
      return 1;
    }
  }
  return 0;
}

◆ GetBaseCruiseSpeed()

double apollo::planning::ReferenceLineInfo::GetBaseCruiseSpeed ( ) const

在文件 reference_line_info.cc 第 165 行定义.

                                                   {
  return base_cruise_speed_ > 0.0 ? base_cruise_speed_
                                  : FLAGS_default_cruise_speed;
}

◆ GetBlockingObstacle()

Obstacle * apollo::planning::ReferenceLineInfo::GetBlockingObstacle ( ) const

inline

在文件 reference_line_info.h 第 211 行定义.

211{ return blocking_obstacle_; }

◆ GetCandidatePathBoundaries()

const std::vector< PathBoundary > & apollo::planning::ReferenceLineInfo::GetCandidatePathBoundaries ( ) const

在文件 reference_line_info.cc 第 148 行定义.

          {
  return candidate_path_boundaries_;
}

◆ GetCandidatePathData()

const std::vector< PathData > & apollo::planning::ReferenceLineInfo::GetCandidatePathData ( ) const

在文件 reference_line_info.cc 第 139 行定义.

                                                                         {
  return candidate_path_data_;
}

◆ GetCruiseSpeed()

double apollo::planning::ReferenceLineInfo::GetCruiseSpeed ( ) const

在文件 reference_line_info.cc 第 170 行定义.

                                               {
  return cruise_speed_ > 0.0 ? cruise_speed_ : FLAGS_default_cruise_speed;
}

◆ GetIntersectionRightofWayStatus()

bool apollo::planning::ReferenceLineInfo::GetIntersectionRightofWayStatus ( const hdmap::PathOverlap & pnc_junction_overlap ) const

在文件 reference_line_info.cc 第 1101 行定义.

                                                        {
  if (GetPathTurnType(pnc_junction_overlap.start_s) != hdmap::Lane::NO_TURN) {
    return false;
  }
 
  // TODO(all): iterate exits of intersection to check/compare speed-limit
  return true;
}

◆ GetJunction()

int apollo::planning::ReferenceLineInfo::GetJunction	(	const double	s,
		hdmap::PathOverlap *	junction_overlap
	)		const

在文件 reference_line_info.cc 第 1127 行定义.

                                                                             {
  CHECK_NOTNULL(junction_overlap);
  const std::vector<hdmap::PathOverlap>& junction_overlaps =
      reference_line_.map_path().junction_overlaps();
 
  static constexpr double kError = 1.0;  // meter
  for (const auto& overlap : junction_overlaps) {
    if (s >= overlap.start_s - kError && s <= overlap.end_s + kError) {
      *junction_overlap = overlap;
      return 1;
    }
  }
  return 0;
}

◆ GetNeighborLaneInfo()

bool apollo::planning::ReferenceLineInfo::GetNeighborLaneInfo	(	const ReferenceLineInfo::LaneType	lane_type,
		const double	s,
		hdmap::Id *	ptr_lane_id,
		double *	ptr_lane_width
	)		const

在文件 reference_line_info.cc 第 186 行定义.

                                                        {
  auto ptr_lane_info = LocateLaneInfo(s);
  if (ptr_lane_info == nullptr) {
    return false;
  }
 
  switch (lane_type) {
    case LaneType::LeftForward: {
      if (ptr_lane_info->lane().left_neighbor_forward_lane_id().empty()) {
        return false;
      }
      *ptr_lane_id = ptr_lane_info->lane().left_neighbor_forward_lane_id(0);
      break;
    }
    case LaneType::LeftReverse: {
      if (ptr_lane_info->lane().left_neighbor_reverse_lane_id().empty()) {
        return false;
      }
      *ptr_lane_id = ptr_lane_info->lane().left_neighbor_reverse_lane_id(0);
      break;
    }
    case LaneType::RightForward: {
      if (ptr_lane_info->lane().right_neighbor_forward_lane_id().empty()) {
        return false;
      }
      *ptr_lane_id = ptr_lane_info->lane().right_neighbor_forward_lane_id(0);
      break;
    }
    case LaneType::RightReverse: {
      if (ptr_lane_info->lane().right_neighbor_reverse_lane_id().empty()) {
        return false;
      }
      *ptr_lane_id = ptr_lane_info->lane().right_neighbor_reverse_lane_id(0);
      break;
    }
    default:
      ACHECK(false);
  }
  auto ptr_neighbor_lane =
      hdmap::HDMapUtil::BaseMapPtr()->GetLaneById(*ptr_lane_id);
  if (ptr_neighbor_lane == nullptr) {
    return false;
  }
 
  auto ref_point = reference_line_.GetReferencePoint(s);
 
  double neighbor_s = 0.0;
  double neighbor_l = 0.0;
  if (!ptr_neighbor_lane->GetProjection({ref_point.x(), ref_point.y()},
                                        &neighbor_s, &neighbor_l)) {
    return false;
  }
 
  *ptr_lane_width = ptr_neighbor_lane->GetWidth(neighbor_s);
  return true;
}

◆ GetOverlapOnReferenceLine()

hdmap::PathOverlap * apollo::planning::ReferenceLineInfo::GetOverlapOnReferenceLine	(	const std::string &	overlap_id,
		const OverlapType &	overlap_type
	)		const

在文件 reference_line_info.cc 第 1192 行定义.

                                                                        {
  if (overlap_type == ReferenceLineInfo::SIGNAL) {
    // traffic_light_overlap
    const auto& traffic_light_overlaps =
        reference_line_.map_path().signal_overlaps();
    for (const auto& traffic_light_overlap : traffic_light_overlaps) {
      if (traffic_light_overlap.object_id == overlap_id) {
        return const_cast<hdmap::PathOverlap*>(&traffic_light_overlap);
      }
    }
  } else if (overlap_type == ReferenceLineInfo::STOP_SIGN) {
    // stop_sign_overlap
    const auto& stop_sign_overlaps =
        reference_line_.map_path().stop_sign_overlaps();
    for (const auto& stop_sign_overlap : stop_sign_overlaps) {
      if (stop_sign_overlap.object_id == overlap_id) {
        return const_cast<hdmap::PathOverlap*>(&stop_sign_overlap);
      }
    }
  } else if (overlap_type == ReferenceLineInfo::PNC_JUNCTION) {
    // pnc_junction_overlap
    const auto& pnc_junction_overlaps =
        reference_line_.map_path().pnc_junction_overlaps();
    for (const auto& pnc_junction_overlap : pnc_junction_overlaps) {
      if (pnc_junction_overlap.object_id == overlap_id) {
        return const_cast<hdmap::PathOverlap*>(&pnc_junction_overlap);
      }
    }
  } else if (overlap_type == ReferenceLineInfo::YIELD_SIGN) {
    // yield_sign_overlap
    const auto& yield_sign_overlaps =
        reference_line_.map_path().yield_sign_overlaps();
    for (const auto& yield_sign_overlap : yield_sign_overlaps) {
      if (yield_sign_overlap.object_id == overlap_id) {
        return const_cast<hdmap::PathOverlap*>(&yield_sign_overlap);
      }
    }
  } else if (overlap_type == ReferenceLineInfo::JUNCTION) {
    // junction_overlap
    const auto& junction_overlaps =
        reference_line_.map_path().junction_overlaps();
    for (const auto& junction_overlap : junction_overlaps) {
      if (junction_overlap.object_id == overlap_id) {
        return const_cast<hdmap::PathOverlap*>(&junction_overlap);
      }
    }
  } else if (overlap_type == ReferenceLineInfo::AREA) {
    // area_overlap
    const auto& area_overlaps = reference_line_.map_path().area_overlaps();
    for (const auto& area_overlap : area_overlaps) {
      if (area_overlap.object_id == overlap_id) {
        return const_cast<hdmap::PathOverlap*>(&area_overlap);
      }
    }
  }
 
  return nullptr;
}

◆ GetPathTurnType()

hdmap::Lane::LaneTurn apollo::planning::ReferenceLineInfo::GetPathTurnType ( const double s ) const

在文件 reference_line_info.cc 第 1079 行定义.

                                                                         {
  const double forward_buffer = 20.0;
  double route_s = 0.0;
  for (const auto& seg : Lanes()) {
    if (route_s > s + forward_buffer) {
      break;
    }
    route_s += seg.end_s - seg.start_s;
    if (route_s < s) {
      continue;
    }
    const auto& turn_type = seg.lane->lane().turn();
    if (turn_type == hdmap::Lane::LEFT_TURN ||
        turn_type == hdmap::Lane::RIGHT_TURN ||
        turn_type == hdmap::Lane::U_TURN) {
      return turn_type;
    }
  }
 
  return hdmap::Lane::NO_TURN;
}

◆ GetPnCJunction()

int apollo::planning::ReferenceLineInfo::GetPnCJunction	(	const double	s,
		hdmap::PathOverlap *	pnc_junction_overlap
	)		const

在文件 reference_line_info.cc 第 1111 行定义.

                                                                  {
  CHECK_NOTNULL(pnc_junction_overlap);
  const std::vector<hdmap::PathOverlap>& pnc_junction_overlaps =
      reference_line_.map_path().pnc_junction_overlaps();
 
  static constexpr double kError = 1.0;  // meter
  for (const auto& overlap : pnc_junction_overlaps) {
    if (s >= overlap.start_s - kError && s <= overlap.end_s + kError) {
      *pnc_junction_overlap = overlap;
      return 1;
    }
  }
  return 0;
}

◆ GetPriority()

uint32_t apollo::planning::ReferenceLineInfo::GetPriority ( ) const

inline

在文件 reference_line_info.h 第 221 行定义.

221{ return reference_line_.GetPriority(); }

apollo::planning::ReferenceLine::GetPriority

uint32_t GetPriority() const

Definition reference_line.h:217

◆ GetRangeOverlaps()

void apollo::planning::ReferenceLineInfo::GetRangeOverlaps	(	std::vector< hdmap::PathOverlap > *	path_overlaps,
		double	start_s,
		double	end_s
	)

在文件 reference_line_info.cc 第 1255 行定义.

                  {
  CHECK_NOTNULL(path_overlaps);
  const std::vector<hdmap::PathOverlap>& junction_overlaps =
      reference_line_.map_path().junction_overlaps();
 
  static constexpr double kError = 0.1;  // meter
  AINFO << "GetRangeOverlaps start_s: " << start_s << ", end_s: " << end_s;
  for (const auto& overlap : junction_overlaps) {
    if (start_s >= overlap.end_s - kError) {
      continue;
    } else if (end_s < overlap.start_s - kError) {
      break;
    } else {
      AINFO << "overlap emplace_back " << overlap.start_s << ", "
            << overlap.end_s << " ]";
      path_overlaps->emplace_back(overlap);
    }
  }
}

◆ GetRightOfWayStatus()

ADCTrajectory::RightOfWayStatus apollo::planning::ReferenceLineInfo::GetRightOfWayStatus ( ) const

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

                                                                           {
  for (const auto& overlap : reference_line_.map_path().junction_overlaps()) {
    if (overlap.end_s < adc_sl_boundary_.start_s()) {
      junction_right_of_way_map_.erase(overlap.object_id);
    } else if (WithinOverlap(overlap, adc_sl_boundary_.end_s())) {
      auto is_protected = junction_right_of_way_map_[overlap.object_id];
      if (is_protected) {
        return ADCTrajectory::PROTECTED;
      }
    }
  }
  return ADCTrajectory::UNPROTECTED;
}

◆ id()

std::string apollo::planning::ReferenceLineInfo::id ( ) const

inline

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

280{ return id_; }

◆ index()

std::size_t apollo::planning::ReferenceLineInfo::index ( ) const

inline

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

277{ return index_; }

◆ Init()

bool apollo::planning::ReferenceLineInfo::Init	(	const std::vector< const Obstacle * > &	obstacles,
		double	target_speed
	)

在文件 reference_line_info.cc 第 77 行定义.

                                                  {
  const auto& param = VehicleConfigHelper::GetConfig().vehicle_param();
  // stitching point
  const auto& path_point = adc_planning_point_.path_point();
  Vec2d position(path_point.x(), path_point.y());
  Vec2d vec_to_center(
      (param.front_edge_to_center() - param.back_edge_to_center()) / 2.0,
      (param.left_edge_to_center() - param.right_edge_to_center()) / 2.0);
  Vec2d center(position + vec_to_center.rotate(path_point.theta()));
  Box2d box(center, path_point.theta(), param.length(), param.width());
  // realtime vehicle position
  Vec2d vehicle_position(vehicle_state_.x(), vehicle_state_.y());
  Vec2d vehicle_center(vehicle_position +
                       vec_to_center.rotate(vehicle_state_.heading()));
  Box2d vehicle_box(vehicle_center, vehicle_state_.heading(), param.length(),
                    param.width());
 
  if (!reference_line_.GetSLBoundary(box, &adc_sl_boundary_)) {
    AERROR << "Failed to get ADC boundary from box: " << box.DebugString();
    return false;
  }
 
  InitFirstOverlaps();
 
  if (adc_sl_boundary_.end_s() < 0 ||
      adc_sl_boundary_.start_s() > reference_line_.Length()) {
    AWARN << "Vehicle SL " << adc_sl_boundary_.ShortDebugString()
          << " is not on reference line:[0, " << reference_line_.Length()
          << "]";
  }
  static constexpr double kOutOfReferenceLineL = 14.0;  // in meters
  if (adc_sl_boundary_.start_l() > kOutOfReferenceLineL ||
      adc_sl_boundary_.end_l() < -kOutOfReferenceLineL) {
    AERROR << "Ego vehicle is too far away from reference line."
           << "adc_sl_boundary_.start_l:" << adc_sl_boundary_.start_l()
           << "adc_sl_boundary_.end_l:" << adc_sl_boundary_.end_l();
    return false;
  }
  is_on_reference_line_ = reference_line_.IsOnLane(adc_sl_boundary_);
  if (!AddObstacles(obstacles)) {
    AERROR << "Failed to add obstacles to reference line";
    return false;
  }
 
  const auto& map_path = reference_line_.map_path();
  for (const auto& speed_bump : map_path.speed_bump_overlaps()) {
    // -1 and + 1.0 are added to make sure it can be sampled.
    reference_line_.AddSpeedLimit(speed_bump.start_s - 1.0,
                                  speed_bump.end_s + 1.0,
                                  FLAGS_speed_bump_speed_limit);
  }
 
  SetCruiseSpeed(target_speed);
  // set lattice planning target speed limit;
  SetLatticeCruiseSpeed(target_speed);
 
  vehicle_signal_.Clear();
 
  return true;
}

◆ is_path_lane_borrow()

bool apollo::planning::ReferenceLineInfo::is_path_lane_borrow ( ) const

inline

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

214{ return is_path_lane_borrow_; }

◆ IsChangeLanePath()

bool apollo::planning::ReferenceLineInfo::IsChangeLanePath ( ) const

Check if the current reference line is a change lane reference line, i.e., ADC's current position is not on this reference line.

在文件 reference_line_info.cc 第 682 行定义.

                                               {
  return !Lanes().IsOnSegment();
}

◆ IsDrivable()

bool apollo::planning::ReferenceLineInfo::IsDrivable ( ) const

在文件 reference_line_info.cc 第 680 行定义.

680{ return is_drivable_; }

◆ IsNeighborLanePath()

bool apollo::planning::ReferenceLineInfo::IsNeighborLanePath ( ) const

Check if the current reference line is the neighbor of the vehicle current position

在文件 reference_line_info.cc 第 686 行定义.

                                                 {
  return Lanes().IsNeighborSegment();
}

◆ IsStartFrom()

bool apollo::planning::ReferenceLineInfo::IsStartFrom ( const ReferenceLineInfo & previous_reference_line_info ) const

check if current reference line is started from another reference line info line.

The method is to check if the start point of current reference line is on previous reference line info.

返回: returns true if current reference line starts on previous reference line, otherwise false.

在文件 reference_line_info.cc 第 498 行定义.

                                                                 {
  if (reference_line_.reference_points().empty()) {
    return false;
  }
  auto start_point = reference_line_.reference_points().front();
  const auto& prev_reference_line =
      previous_reference_line_info.reference_line();
  common::SLPoint sl_point;
  prev_reference_line.XYToSL(start_point, &sl_point);
  return previous_reference_line_info.reference_line_.IsOnLane(sl_point);
}

◆ key()

std::size_t apollo::planning::ReferenceLineInfo::key ( ) const

inline

在文件 reference_line_info.h 第 274 行定义.

274{ return key_; }

◆ Lanes()

const hdmap::RouteSegments & apollo::planning::ReferenceLineInfo::Lanes ( ) const

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

356{ return lanes_; }

◆ latency_stats()

const LatencyStats & apollo::planning::ReferenceLineInfo::latency_stats ( ) const

inline

在文件 reference_line_info.h 第 130 行定义.

130{ return latency_stats_; }

◆ LimitCruiseSpeed()

void apollo::planning::ReferenceLineInfo::LimitCruiseSpeed ( double speed )

Limit the cruise speed based on the "base_cruise_speed_".

If the new setting speed > "base_cruise_speed_", it will be ignored.

参数

speed The new speed.

在文件 reference_line_info.cc 第 158 行定义.

                                                     {
  if (base_cruise_speed_ <= speed) {
    return;
  }
  cruise_speed_ = speed;
}

◆ LocateLaneInfo()

hdmap::LaneInfoConstPtr apollo::planning::ReferenceLineInfo::LocateLaneInfo ( const double s ) const

在文件 reference_line_info.cc 第 174 行定义.

                          {
  std::vector<hdmap::LaneInfoConstPtr> lanes;
  reference_line_.GetLaneFromS(s, &lanes);
  if (lanes.empty()) {
    AWARN << "cannot get any lane using s";
    return nullptr;
  }
 
  return lanes.front();
}

◆ mutable_debug()

planning_internal::Debug * apollo::planning::ReferenceLineInfo::mutable_debug ( )

inline

在文件 reference_line_info.h 第 127 行定义.

127{ return &debug_; }

◆ mutable_fallback_path_data()

PathData * apollo::planning::ReferenceLineInfo::mutable_fallback_path_data ( )

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

                                                        {
  return &fallback_path_data_;
}

◆ mutable_latency_stats()

LatencyStats * apollo::planning::ReferenceLineInfo::mutable_latency_stats ( )

inline

在文件 reference_line_info.h 第 129 行定义.

129{ return &latency_stats_; }

◆ mutable_obs_sl_polygons()

std::vector< SLPolygon > * apollo::planning::ReferenceLineInfo::mutable_obs_sl_polygons ( )

在文件 reference_line_info.cc 第 1298 行定义.

                                                                 {
  return &obs_sl_polygons_;
}

◆ mutable_path_data()

PathData * apollo::planning::ReferenceLineInfo::mutable_path_data ( )

在文件 reference_line_info.cc 第 519 行定义.

519{ return &path_data_; }

◆ mutable_reference_line()

ReferenceLine * apollo::planning::ReferenceLineInfo::mutable_reference_line ( )

在文件 reference_line_info.cc 第 380 行定义.

                                                         {
  return &reference_line_;
}

◆ mutable_reference_line_towing_l()

std::vector< double > * apollo::planning::ReferenceLineInfo::mutable_reference_line_towing_l ( )

在文件 reference_line_info.cc 第 1281 行定义.

                                                                      {
  return &reference_line_towing_l_;
}

◆ mutable_reference_line_towing_path_boundary()

PathBoundary * apollo::planning::ReferenceLineInfo::mutable_reference_line_towing_path_boundary ( )

在文件 reference_line_info.cc 第 1290 行定义.

                                                                             {
  return &reference_line_towing_path_boundary_;
}

◆ mutable_rss_info()

RSSInfo * apollo::planning::ReferenceLineInfo::mutable_rss_info ( )

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

529{ return &rss_info_; }

◆ mutable_speed_data()

SpeedData * apollo::planning::ReferenceLineInfo::mutable_speed_data ( )

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

525{ return &speed_data_; }

◆ mutable_st_graph_data()

StGraphData * apollo::planning::ReferenceLineInfo::mutable_st_graph_data ( )

inline

在文件 reference_line_info.h 第 234 行定义.

234{ return &st_graph_data_; }

◆ MutableCandidatePathData()

std::vector< PathData > * apollo::planning::ReferenceLineInfo::MutableCandidatePathData ( )

在文件 reference_line_info.cc 第 1251 行定义.

                                                                 {
  return &candidate_path_data_;
}

◆ obs_sl_polygons()

const std::vector< SLPolygon > & apollo::planning::ReferenceLineInfo::obs_sl_polygons ( ) const

在文件 reference_line_info.cc 第 1294 行定义.

                                                                     {
  return obs_sl_polygons_;
}

◆ OffsetToOtherReferenceLine()

double apollo::planning::ReferenceLineInfo::OffsetToOtherReferenceLine ( ) const

inline

在文件 reference_line_info.h 第 195 行定义.

                                            {
    return offset_to_other_reference_line_;
  }

◆ path_data()

const PathData & apollo::planning::ReferenceLineInfo::path_data ( ) const

在文件 reference_line_info.cc 第 511 行定义.

511{ return path_data_; }

◆ path_decision() [1/2]

PathDecision * apollo::planning::ReferenceLineInfo::path_decision ( )

在文件 reference_line_info.cc 第 370 行定义.

370{ return &path_decision_; }

◆ path_decision() [2/2]

const PathDecision & apollo::planning::ReferenceLineInfo::path_decision ( ) const

在文件 reference_line_info.cc 第 372 行定义.

                                                           {
  return path_decision_;
}

◆ path_reusable()

bool apollo::planning::ReferenceLineInfo::path_reusable ( ) const

inline

在文件 reference_line_info.h 第 269 行定义.

269{ return path_reusable_; }

◆ PathSpeedDebugString()

std::string apollo::planning::ReferenceLineInfo::PathSpeedDebugString ( ) const

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

                                                        {
  return absl::StrCat("path_data:", path_data_.DebugString(),
                      "speed_data:", speed_data_.DebugString());
}

◆ planning_target()

const PlanningTarget & apollo::planning::ReferenceLineInfo::planning_target ( ) const

inline

在文件 reference_line_info.h 第 95 行定义.

95{ return planning_target_; }

◆ PrintReferenceSegmentDebugString()

void apollo::planning::ReferenceLineInfo::PrintReferenceSegmentDebugString ( )

在文件 reference_line_info.cc 第 1302 行定义.

                                                         {
  PrintCurves print_curve;
  const auto& lane_segments = reference_line_.GetMapPath().lane_segments();
  for (size_t i = 0; i < lane_segments.size(); ++i) {
    for (const auto& seg :
         lane_segments.at(i).lane->lane().left_boundary().curve().segment()) {
      for (const auto& pt : seg.line_segment().point()) {
        print_curve.AddPoint(std::to_string(index_) + "_left_pt_print", pt.x(),
                             pt.y());
      }
    }
    for (const auto& seg :
         lane_segments.at(i).lane->lane().right_boundary().curve().segment()) {
      for (const auto& pt : seg.line_segment().point()) {
        print_curve.AddPoint(std::to_string(index_) + "_right_pt_print", pt.x(),
                             pt.y());
      }
    }
    for (const auto& pt : lane_segments.at(i).lane->points()) {
      print_curve.AddPoint(std::to_string(index_) + "_center_pt_print", pt.x(),
                           pt.y());
    }
  }
  print_curve.PrintToLog();
}

◆ PriorityCost()

double apollo::planning::ReferenceLineInfo::PriorityCost ( ) const

inline

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

90{ return priority_cost_; }

◆ ReachedDestination()

bool apollo::planning::ReferenceLineInfo::ReachedDestination ( ) const

在文件 reference_line_info.cc 第 815 行定义.

                                                 {
  const double distance_destination = SDistanceToDestination();
  const double distance_ref_end = SDistanceToRefEnd();
  AINFO << "distance_destination:" << distance_destination
        << "distance_ref_end: " << distance_ref_end;
  return distance_destination <= FLAGS_passed_destination_threshold ||
         distance_ref_end <= FLAGS_passed_referenceline_end_threshold;
}

◆ reference_line()

const ReferenceLine & apollo::planning::ReferenceLineInfo::reference_line ( ) const

在文件 reference_line_info.cc 第 376 行定义.

                                                             {
  return reference_line_;
}

◆ reference_line_towing_l()

const std::vector< double > & apollo::planning::ReferenceLineInfo::reference_line_towing_l ( ) const

在文件 reference_line_info.cc 第 1277 行定义.

                                                                          {
  return reference_line_towing_l_;
}

◆ reference_line_towing_path_boundary()

const PathBoundary & apollo::planning::ReferenceLineInfo::reference_line_towing_path_boundary ( ) const

在文件 reference_line_info.cc 第 1285 行定义.

          {
  return reference_line_towing_path_boundary_;
}

◆ rss_info()

const RSSInfo & apollo::planning::ReferenceLineInfo::rss_info ( ) const

在文件 reference_line_info.cc 第 527 行定义.

527{ return rss_info_; }

◆ SDistanceToDestination()

double apollo::planning::ReferenceLineInfo::SDistanceToDestination ( ) const

在文件 reference_line_info.cc 第 824 行定义.

                                                       {
  double res = std::numeric_limits<double>::max();
  const auto* dest_ptr = path_decision_.Find(FLAGS_destination_obstacle_id);
  if (!dest_ptr) {
    return res;
  }
  if (!dest_ptr->LongitudinalDecision().has_stop()) {
    return res;
  }
  if (!reference_line_.IsOnLane(dest_ptr->PerceptionBoundingBox().center())) {
    return res;
  }
  const double stop_s = dest_ptr->PerceptionSLBoundary().start_s() +
                        dest_ptr->LongitudinalDecision().stop().distance_s();
  AINFO << "stop_s: " << stop_s << "end_s: " << adc_sl_boundary_.end_s();
  return stop_s - adc_sl_boundary_.end_s();
}

◆ SDistanceToRefEnd()

double apollo::planning::ReferenceLineInfo::SDistanceToRefEnd ( ) const

在文件 reference_line_info.cc 第 842 行定义.

                                                  {
  double res = std::numeric_limits<double>::max();
 
  std::string ref_end_id;
  for (const auto* obstacle : path_decision_.obstacles().Items()) {
    std::string id = obstacle->Id();
    if (id.find("REF_END") != std::string::npos) {
      ref_end_id = id;
      AINFO << "Found reference line end id: " << ref_end_id;
    } else {
      continue;
    }
  }
  if (!ref_end_id.empty()) {
    AINFO << "REF_END: " << ref_end_id;
    const auto* ref_end_ptr = path_decision_.Find(ref_end_id);
    AINFO << "ref_end_ptr:" << ref_end_ptr->DebugString();
    if (!ref_end_ptr && !ref_end_ptr->LongitudinalDecision().has_stop() &&
        !reference_line_.IsOnLane(
            ref_end_ptr->PerceptionBoundingBox().center())) {
      const double stop_s =
          ref_end_ptr->PerceptionSLBoundary().start_s() +
          ref_end_ptr->LongitudinalDecision().stop().distance_s();
      AINFO << "REF_END: stop_s: " << stop_s
            << "end_s: " << adc_sl_boundary_.end_s();
      res = stop_s - adc_sl_boundary_.end_s();
    }
  }
  return res;
}

◆ set_id()

void apollo::planning::ReferenceLineInfo::set_id ( std::string id )

inline

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

279{ id_ = id; }

◆ set_index()

void apollo::planning::ReferenceLineInfo::set_index ( std::size_t index )

inline

在文件 reference_line_info.h 第 276 行定义.

276{ index_ = index; }

apollo::planning::ReferenceLineInfo::index

std::size_t index() const

Definition reference_line_info.h:277

◆ set_is_on_reference_line()

void apollo::planning::ReferenceLineInfo::set_is_on_reference_line ( )

inline

在文件 reference_line_info.h 第 219 行定义.

219{ is_on_reference_line_ = true; }

◆ set_is_path_lane_borrow()

void apollo::planning::ReferenceLineInfo::set_is_path_lane_borrow ( const bool is_path_lane_borrow )

inline

在文件 reference_line_info.h 第 215 行定义.

                                                               {
    is_path_lane_borrow_ = is_path_lane_borrow;
  }

◆ set_key()

void apollo::planning::ReferenceLineInfo::set_key ( std::size_t key )

inline

在文件 reference_line_info.h 第 273 行定义.

273{ key_ = key; }

apollo::planning::ReferenceLineInfo::key

std::size_t key() const

Definition reference_line_info.h:274

◆ set_path_reusable()

void apollo::planning::ReferenceLineInfo::set_path_reusable ( const bool path_reusable )

inline

在文件 reference_line_info.h 第 265 行定义.

                                                   {
    path_reusable_ = path_reusable;
  }

◆ set_trajectory_type()

void apollo::planning::ReferenceLineInfo::set_trajectory_type ( const ADCTrajectory::TrajectoryType trajectory_type )

inline

在文件 reference_line_info.h 第 225 行定义.

                                                         {
    trajectory_type_ = trajectory_type;
  }

◆ SetBlockingObstacle()

void apollo::planning::ReferenceLineInfo::SetBlockingObstacle ( const std::string & blocking_obstacle_id )

在文件 reference_line_info.cc 第 1159 行定义.

                                           {
  blocking_obstacle_ = path_decision_.Find(blocking_obstacle_id);
}

◆ SetCandidatePathBoundaries()

void apollo::planning::ReferenceLineInfo::SetCandidatePathBoundaries ( std::vector< PathBoundary > && candidate_path_boundaries )

在文件 reference_line_info.cc 第 153 行定义.

                                               {
  candidate_path_boundaries_ = std::move(path_boundaries);
}

◆ SetCandidatePathData()

void apollo::planning::ReferenceLineInfo::SetCandidatePathData ( std::vector< PathData > && candidate_path_data )

在文件 reference_line_info.cc 第 143 行定义.

                                               {
  candidate_path_data_ = std::move(candidate_path_data);
}

◆ SetCost()

void apollo::planning::ReferenceLineInfo::SetCost ( double cost )

inline

在文件 reference_line_info.h 第 89 行定义.

89{ cost_ = cost; }

◆ SetCruiseSpeed()

void apollo::planning::ReferenceLineInfo::SetCruiseSpeed ( double speed )

inline

在文件 reference_line_info.h 第 97 行定义.

                                    {
    cruise_speed_ = speed;
    base_cruise_speed_ = speed;
  }

◆ SetDrivable()

void apollo::planning::ReferenceLineInfo::SetDrivable ( bool drivable )

Set if the vehicle can drive following this reference line A planner need to set this value to true if the reference line is OK

在文件 reference_line_info.cc 第 678 行定义.

678{ is_drivable_ = drivable; }

◆ SetEmergencyLight()

void apollo::planning::ReferenceLineInfo::SetEmergencyLight ( )

在文件 reference_line_info.cc 第 804 行定义.

                                          {
  vehicle_signal_.set_emergency_light(true);
}

◆ SetJunctionRightOfWay()

void apollo::planning::ReferenceLineInfo::SetJunctionRightOfWay	(	const double	junction_s,
		const bool	is_protected
	)		const

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

                                                                             {
  for (const auto& overlap : reference_line_.map_path().junction_overlaps()) {
    if (WithinOverlap(overlap, junction_s)) {
      junction_right_of_way_map_[overlap.object_id] = is_protected;
    }
  }
}

◆ SetLatticeCruiseSpeed()

void apollo::planning::ReferenceLineInfo::SetLatticeCruiseSpeed ( double speed )

在文件 reference_line_info.cc 第 494 行定义.

                                                          {
  planning_target_.set_cruise_speed(speed);
}

◆ SetLatticeStopPoint()

void apollo::planning::ReferenceLineInfo::SetLatticeStopPoint ( const StopPoint & stop_point )

在文件 reference_line_info.cc 第 490 行定义.

                                                                       {
  planning_target_.mutable_stop_point()->CopyFrom(stop_point);
}

◆ SetOffsetToOtherReferenceLine()

void apollo::planning::ReferenceLineInfo::SetOffsetToOtherReferenceLine ( const double offset )

inline

在文件 reference_line_info.h 第 198 行定义.

                                                          {
    offset_to_other_reference_line_ = offset;
  }

◆ SetPriority()

void apollo::planning::ReferenceLineInfo::SetPriority ( uint32_t priority )

inline

在文件 reference_line_info.h 第 223 行定义.

223{ reference_line_.SetPriority(priority); }

apollo::planning::ReferenceLine::SetPriority

void SetPriority(uint32_t priority)

Definition reference_line.h:219

◆ SetPriorityCost()

void apollo::planning::ReferenceLineInfo::SetPriorityCost ( double cost )

inline

在文件 reference_line_info.h 第 91 行定义.

91{ priority_cost_ = cost; }

◆ SetTrajectory()

void apollo::planning::ReferenceLineInfo::SetTrajectory ( const DiscretizedTrajectory & trajectory )

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

                                                                             {
  discretized_trajectory_ = trajectory;
}

◆ SetTurnSignal()

void apollo::planning::ReferenceLineInfo::SetTurnSignal ( const common::VehicleSignal::TurnSignal & turn_signal )

在文件 reference_line_info.cc 第 799 行定义.

                                                {
  vehicle_signal_.set_turn_signal(turn_signal);
}

◆ speed_data()

const SpeedData & apollo::planning::ReferenceLineInfo::speed_data ( ) const

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

517{ return speed_data_; }

◆ st_graph_data()

const StGraphData & apollo::planning::ReferenceLineInfo::st_graph_data ( )

inline

在文件 reference_line_info.h 第 236 行定义.

236{ return st_graph_data_; }

◆ TargetLaneId()

std::list< hdmap::Id > apollo::planning::ReferenceLineInfo::TargetLaneId ( ) const

在文件 reference_line_info.cc 第 358 行定义.

                                                       {
  std::list<hdmap::Id> lane_ids;
  for (const auto& lane_seg : lanes_) {
    lane_ids.push_back(lane_seg.lane->id());
  }
  return lane_ids;
}

◆ trajectory()

const DiscretizedTrajectory & apollo::planning::ReferenceLineInfo::trajectory ( ) const

在文件 reference_line_info.cc 第 486 行定义.

                                                                 {
  return discretized_trajectory_;
}

◆ trajectory_type()

ADCTrajectory::TrajectoryType apollo::planning::ReferenceLineInfo::trajectory_type ( ) const

inline

在文件 reference_line_info.h 第 230 行定义.

                                                      {
    return trajectory_type_;
  }

◆ vehicle_state()

const common::VehicleState & apollo::planning::ReferenceLineInfo::vehicle_state ( ) const

inline

在文件 reference_line_info.h 第 71 行定义.

71{ return vehicle_state_; }

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

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

Public 类型

Public 成员函数

详细描述

成员枚举类型说明

◆ LaneType

◆ OverlapType

构造及析构函数说明

◆ ReferenceLineInfo() [1/2]

◆ ReferenceLineInfo() [2/2]

成员函数说明

◆ AdcSlBoundary()

◆ AddCost()

◆ AddObstacle()

◆ AddObstacles()

◆ AdjustTrajectoryWhichStartsFromCurrentPos()

◆ CombinePathAndSpeedProfile()

◆ Cost()

◆ debug()

◆ ExportDecision()

◆ ExportEngageAdvice()

◆ fallback_path_data()

◆ FirstEncounteredOverlaps()

◆ GetAllStopDecisionSLPoint()

◆ GetArea()

◆ GetBaseCruiseSpeed()

◆ GetBlockingObstacle()

◆ GetCandidatePathBoundaries()

◆ GetCandidatePathData()

◆ GetCruiseSpeed()

◆ GetIntersectionRightofWayStatus()

◆ GetJunction()

◆ GetNeighborLaneInfo()

◆ GetOverlapOnReferenceLine()

◆ GetPathTurnType()

◆ GetPnCJunction()

◆ GetPriority()

◆ GetRangeOverlaps()

◆ GetRightOfWayStatus()

◆ id()

◆ index()

◆ Init()

◆ is_path_lane_borrow()

◆ IsChangeLanePath()

◆ IsDrivable()

◆ IsNeighborLanePath()

◆ IsStartFrom()

◆ key()

◆ Lanes()

◆ latency_stats()

◆ LimitCruiseSpeed()

◆ LocateLaneInfo()

◆ mutable_debug()

◆ mutable_fallback_path_data()

◆ mutable_latency_stats()

◆ mutable_obs_sl_polygons()

◆ mutable_path_data()

◆ mutable_reference_line()

◆ mutable_reference_line_towing_l()

◆ mutable_reference_line_towing_path_boundary()

◆ mutable_rss_info()

◆ mutable_speed_data()

◆ mutable_st_graph_data()

◆ MutableCandidatePathData()

◆ obs_sl_polygons()

◆ OffsetToOtherReferenceLine()

◆ path_data()

◆ path_decision() [1/2]

◆ path_decision() [2/2]

◆ path_reusable()

◆ PathSpeedDebugString()

◆ planning_target()

◆ PrintReferenceSegmentDebugString()

◆ PriorityCost()

◆ ReachedDestination()

◆ reference_line()

◆ reference_line_towing_l()

◆ reference_line_towing_path_boundary()

◆ rss_info()

◆ SDistanceToDestination()

◆ SDistanceToRefEnd()