apollo::prediction::InteractionPredictor类 参考

#include <interaction_predictor.h>

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

apollo::prediction::InteractionPredictor 的协作图:

Public 成员函数
	InteractionPredictor ()
	Constructor
virtual	~InteractionPredictor ()=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
bool	Predict (const ADCTrajectoryContainer *adc_trajectory_container, Obstacle *obstacle, ObstaclesContainer *obstacles_container) override
	Make prediction
	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

额外继承的成员函数
Public 类型 继承自 apollo::prediction::SequencePredictor
enum class	LaneChangeType {   LEFT , RIGHT , STRAIGHT , ONTO_LANE ,   INVALID }
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
静态 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_

详细描述

在文件 interaction_predictor.h 第 31 行定义.

构造及析构函数说明

InteractionPredictor()

apollo::prediction::InteractionPredictor::InteractionPredictor

(

)

Constructor

在文件 interaction_predictor.cc 第 42 行定义.

                                           {
  predictor_type_ = ObstacleConf::INTERACTION_PREDICTOR;
}

~InteractionPredictor()

virtual apollo::prediction::InteractionPredictor::~InteractionPredictor ( )

virtualdefault

Destructor

成员函数说明

Predict()

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

overridevirtual

Make prediction

参数

Obstacle	pointer
Obstacles	container

返回

If predicted successfully

实现了 apollo::prediction::Predictor.

在文件 interaction_predictor.cc 第 46 行定义.

                                             {
  Clear();
  CHECK_NOTNULL(obstacle);
  CHECK_GT(obstacle->history_size(), 0U);
 
  BuildADCTrajectory(adc_trajectory_container,
                     FLAGS_collision_cost_time_resolution);
 
  obstacle->SetPredictorType(predictor_type_);
 
  Feature* feature_ptr = obstacle->mutable_latest_feature();
 
  if (!feature_ptr->lane().has_lane_graph()) {
    AERROR << "Obstacle [" << obstacle->id() << "] has no lane graph.";
    return false;
  }
  auto* lane_graph = feature_ptr->mutable_lane()->mutable_lane_graph();
 
  int num_lane_sequence = lane_graph->lane_sequence_size();
  std::vector<double> best_lon_accelerations(num_lane_sequence, 0.0);
  std::vector<double> candidate_lon_accelerations = {0.0,  -0.5, -1.0, -1.5,
                                                     -2.0, -2.5, -3.0};
  double smallest_cost = std::numeric_limits<double>::max();
  std::vector<double> posteriors(num_lane_sequence, 0.0);
  double posterior_sum = 0.0;
  for (int i = 0; i < num_lane_sequence; ++i) {
    const LaneSequence& lane_sequence = lane_graph->lane_sequence(i);
    for (const double lon_acceleration : candidate_lon_accelerations) {
      double cost = ComputeTrajectoryCost(
          *obstacle, lane_sequence, lon_acceleration, adc_trajectory_container);
      if (cost < smallest_cost) {
        smallest_cost = cost;
        best_lon_accelerations[i] = lon_acceleration;
      }
    }
 
    double likelihood = ComputeLikelihood(smallest_cost);
    double prior = lane_sequence.probability();
    double posterior = ComputePosterior(prior, likelihood);
    posteriors[i] = posterior;
    posterior_sum += posterior;
  }
 
  int best_seq_idx = 0;
  double largest_posterior = 0.0;
  CHECK_EQ(posteriors.size(),
           static_cast<size_t>(lane_graph->lane_sequence_size()));
  for (int i = 0; i < num_lane_sequence; ++i) {
    double normalized_posterior =
        posteriors[i] / (posterior_sum + FLAGS_double_precision);
    lane_graph->mutable_lane_sequence(i)->set_probability(normalized_posterior);
    if (normalized_posterior > largest_posterior) {
      largest_posterior = normalized_posterior;
      best_seq_idx = i;
    }
  }
 
  double probability_threshold = 0.5;
  if (largest_posterior > probability_threshold) {
    for (int i = 0; i < num_lane_sequence; ++i) {
      const LaneSequence& lane_sequence = lane_graph->lane_sequence(i);
      if (lane_sequence.probability() < probability_threshold) {
        continue;
      }
      double best_lon_acceleration = best_lon_accelerations[i];
      if (lane_sequence.has_stop_sign()) {
        double stop_acceleration = 0.0;
        double stop_distance = lane_sequence.stop_sign().lane_sequence_s() -
                               lane_sequence.lane_s();
        SupposedToStop(*feature_ptr, stop_distance, &stop_acceleration);
        best_lon_acceleration =
            std::min(best_lon_acceleration, stop_acceleration);
      }
      std::vector<TrajectoryPoint> points;
      DrawTrajectory(*obstacle, lane_sequence, best_lon_acceleration,
                     FLAGS_prediction_trajectory_time_length,
                     FLAGS_prediction_trajectory_time_resolution, &points);
      Trajectory trajectory = GenerateTrajectory(points);
      obstacle->mutable_latest_feature()->add_predicted_trajectory()->CopyFrom(
          trajectory);
    }
  } else {
    const LaneSequence& sequence = lane_graph->lane_sequence(best_seq_idx);
    double best_lon_acceleration = best_lon_accelerations[best_seq_idx];
    if (sequence.has_stop_sign()) {
      double stop_distance =
          sequence.stop_sign().lane_sequence_s() - sequence.lane_s();
      SupposedToStop(*feature_ptr, stop_distance, &best_lon_acceleration);
    }
    std::vector<TrajectoryPoint> points;
    DrawTrajectory(*obstacle, lane_graph->lane_sequence(best_seq_idx),
                   best_lon_acceleration,
                   FLAGS_prediction_trajectory_time_length,
                   FLAGS_prediction_trajectory_time_resolution, &points);
    Trajectory trajectory = GenerateTrajectory(points);
    obstacle->mutable_latest_feature()->add_predicted_trajectory()->CopyFrom(
        trajectory);
  }
  return true;
}

---

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

• modules/prediction/predictor/interaction/interaction_predictor.h
• modules/prediction/predictor/interaction/interaction_predictor.cc