apollo::prediction::SingleLanePredictor类 参考

#include <single_lane_predictor.h>

类 apollo::prediction::SingleLanePredictor 继承关系图:

apollo::prediction::SingleLanePredictor 的协作图:

Public 成员函数
	SingleLanePredictor ()
	Constructor
virtual	~SingleLanePredictor ()=default
	Destructor
bool	Predict (const ADCTrajectoryContainer *adc_trajectory_container, Obstacle *obstacle, ObstaclesContainer *obstacles_container) override
	Make prediction
Public 成员函数 继承自 apollo::prediction::SequencePredictor
	SequencePredictor ()=default
	Constructor
virtual	~SequencePredictor ()=default
	Destructor
	FRIEND_TEST (SequencePredictorTest, General)
Public 成员函数 继承自 apollo::prediction::Predictor
	Predictor ()=default
	Constructor
virtual	~Predictor ()=default
	Destructor
int	NumOfTrajectories (const Obstacle &obstacle)
	Get trajectory size
void	TrimTrajectories (const ADCTrajectoryContainer &adc_trajectory_container, Obstacle *obstacle)
	Trim prediction trajectories by adc trajectory
const ObstacleConf::PredictorType &	predictor_type ()
	get the predictor type

Protected 成员函数
void	GenerateTrajectoryPoints (const Obstacle &obstacle, const LaneSequence &lane_sequence, const double total_time, const double period, std::vector< apollo::common::TrajectoryPoint > *points)
	Draw lane sequence trajectory points
Protected 成员函数 继承自 apollo::prediction::SequencePredictor
bool	GetLongitudinalPolynomial (const Obstacle &obstacle, const LaneSequence &lane_sequence, const std::pair< double, double > &lon_end_state, std::array< double, 5 > *coefficients)
bool	GetLateralPolynomial (const Obstacle &obstacle, const LaneSequence &lane_sequence, const double time_to_end_state, std::array< double, 4 > *coefficients)
void	FilterLaneSequences (const Feature &feature, const std::string &lane_id, const Obstacle *ego_vehicle_ptr, const ADCTrajectoryContainer *adc_trajectory_container, std::vector< bool > *enable_lane_sequence)
	Filter lane sequences
LaneChangeType	GetLaneChangeType (const std::string &lane_id, const LaneSequence &lane_sequence)
	Get lane change type
double	GetLaneChangeDistanceWithADC (const LaneSequence &lane_sequence, const Obstacle *ego_vehicle_ptr, const ADCTrajectoryContainer *adc_trajectory_container)
	Get lane change distance with ADC
void	DrawConstantAccelerationTrajectory (const Obstacle &obstacle, const LaneSequence &lane_sequence, const double total_time, const double period, const double acceleration, std::vector< apollo::common::TrajectoryPoint > *points)
	Draw constant acceleration trajectory points
double	GetLaneSequenceCurvatureByS (const LaneSequence &lane_sequence, const double s)
	Get lane sequence curvature by s
void	Clear ()
	Clear private members
std::string	ToString (const LaneSequence &sequence)
	Convert a lane sequence to string
Protected 成员函数 继承自 apollo::prediction::Predictor
void	SetEqualProbability (const double probability, const int start_index, Obstacle *obstacle_ptr)
	Set equal probability to prediction trajectories
bool	TrimTrajectory (const ADCTrajectoryContainer &adc_trajectory_container, Obstacle *obstacle, Trajectory *trajectory)
	Trim a single prediction trajectory, keep the portion that is not in junction.
bool	SupposedToStop (const Feature &feature, const double stop_distance, double *acceleration)
	Determine if an obstacle is supposed to stop within a distance

额外继承的成员函数
Public 类型 继承自 apollo::prediction::SequencePredictor
enum class	LaneChangeType {   LEFT , RIGHT , STRAIGHT , ONTO_LANE ,   INVALID }
静态 Protected 成员函数 继承自 apollo::prediction::Predictor
static Trajectory	GenerateTrajectory (const std::vector< apollo::common::TrajectoryPoint > &points)
	Generate trajectory from trajectory points
Protected 属性 继承自 apollo::prediction::Predictor
ObstacleConf::PredictorType	predictor_type_

详细描述

在文件 single_lane_predictor.h 第 29 行定义.

构造及析构函数说明

SingleLanePredictor()

apollo::prediction::SingleLanePredictor::SingleLanePredictor

(

)

Constructor

在文件 single_lane_predictor.cc 第 32 行定义.

                                         {
  predictor_type_ = ObstacleConf::SINGLE_LANE_PREDICTOR;
}

~SingleLanePredictor()

virtual apollo::prediction::SingleLanePredictor::~SingleLanePredictor ( )

virtualdefault

Destructor

成员函数说明

GenerateTrajectoryPoints()

void apollo::prediction::SingleLanePredictor::GenerateTrajectoryPoints ( const Obstacle &  obstacle, const LaneSequence &  lane_sequence, const double  total_time, const double  period, std::vector< apollo::common::TrajectoryPoint > *  points  )

protected

Draw lane sequence trajectory points

参数

Obstacle
Lane	sequence
Total	prediction time
Prediction	period
A	vector of generated trajectory points

在文件 single_lane_predictor.cc 第 87 行定义.

                                        {
  const Feature& feature = obstacle.latest_feature();
  if (!feature.has_position() || !feature.has_velocity() ||
      !feature.position().has_x() || !feature.position().has_y()) {
    AERROR << "Obstacle [" << obstacle.id()
           << " is missing position or velocity";
    return;
  }
 
  double probability = lane_sequence.probability();
  double approach_rate = FLAGS_go_approach_rate;
  if (probability < FLAGS_lane_sequence_threshold_cruise) {
    approach_rate = 1.0;
  }
 
  Eigen::Vector2d position(feature.position().x(), feature.position().y());
  double speed = feature.speed();
 
  int lane_segment_index = 0;
  std::string lane_id =
      lane_sequence.lane_segment(lane_segment_index).lane_id();
  std::shared_ptr<const LaneInfo> lane_info = PredictionMap::LaneById(lane_id);
  double lane_s = 0.0;
  double lane_l = 0.0;
  if (!PredictionMap::GetProjection(position, lane_info, &lane_s, &lane_l)) {
    AERROR << "Failed in getting lane s and lane l";
    return;
  }
  size_t num_of_points = static_cast<size_t>(time_length / time_resolution);
  for (size_t i = 0; i < num_of_points; ++i) {
    double relative_time = static_cast<double>(i) * time_resolution;
    Eigen::Vector2d point;
    double theta = M_PI;
    if (!PredictionMap::SmoothPointFromLane(lane_id, lane_s, lane_l, &point,
                                            &theta)) {
      AERROR << "Unable to get smooth point from lane [" << lane_id
             << "] with s [" << lane_s << "] and l [" << lane_l << "]";
      break;
    }
    TrajectoryPoint trajectory_point;
    PathPoint path_point;
    path_point.set_x(point.x());
    path_point.set_y(point.y());
    path_point.set_z(0.0);
    path_point.set_theta(theta);
    path_point.set_lane_id(lane_id);
    trajectory_point.mutable_path_point()->CopyFrom(path_point);
    trajectory_point.set_v(speed);
    trajectory_point.set_a(0.0);
    trajectory_point.set_relative_time(relative_time);
    points->emplace_back(std::move(trajectory_point));
 
    lane_s += speed * time_resolution;
 
    while (lane_s > PredictionMap::LaneById(lane_id)->total_length() &&
           lane_segment_index + 1 < lane_sequence.lane_segment_size()) {
      lane_segment_index += 1;
      lane_s = lane_s - PredictionMap::LaneById(lane_id)->total_length();
      lane_id = lane_sequence.lane_segment(lane_segment_index).lane_id();
    }
 
    lane_l *= approach_rate;
  }
}

Predict()

bool apollo::prediction::SingleLanePredictor::Predict ( const ADCTrajectoryContainer *  adc_trajectory_container, Obstacle *  obstacle, ObstaclesContainer *  obstacles_container  )

overridevirtual

Make prediction

参数

ADC	trajectory container
Obstacle	pointer
Obstacles	container

返回

If predicted successfully

重载 apollo::prediction::SequencePredictor .

在文件 single_lane_predictor.cc 第 36 行定义.

                                             {
  Clear();
 
  CHECK_NOTNULL(obstacle);
  CHECK_GT(obstacle->history_size(), 0U);
 
  obstacle->SetPredictorType(predictor_type_);
 
  const Feature& feature = obstacle->latest_feature();
 
  if (!feature.has_lane() || !feature.lane().has_lane_graph()) {
    AERROR << "Obstacle [" << obstacle->id() << "] has no lane graph.";
    return false;
  }
 
  std::string lane_id = "";
  if (feature.lane().has_lane_feature()) {
    lane_id = feature.lane().lane_feature().lane_id();
  }
  int num_lane_sequence = feature.lane().lane_graph().lane_sequence_size();
 
  for (int i = 0; i < num_lane_sequence; ++i) {
    const LaneSequence& sequence = feature.lane().lane_graph().lane_sequence(i);
    if (sequence.lane_segment().empty()) {
      AERROR << "Empty lane segments.";
      continue;
    }
 
    ADEBUG << "Obstacle [" << obstacle->id()
           << "] will draw a lane sequence trajectory [" << ToString(sequence)
           << "] with probability [" << sequence.probability() << "].";
 
    std::vector<TrajectoryPoint> points;
    GenerateTrajectoryPoints(
        *obstacle, sequence, FLAGS_prediction_trajectory_time_length,
        FLAGS_prediction_trajectory_time_resolution, &points);
 
    if (points.empty()) {
      continue;
    }
 
    Trajectory trajectory = GenerateTrajectory(points);
    trajectory.set_probability(sequence.probability());
    obstacle->mutable_latest_feature()->add_predicted_trajectory()->CopyFrom(
        trajectory);
  }
  return true;
}

---

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

• modules/prediction/predictor/single_lane/single_lane_predictor.h
• modules/prediction/predictor/single_lane/single_lane_predictor.cc