#include <jointly_prediction_planning_evaluator.h>

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

apollo::prediction::JointlyPredictionPlanningEvaluator 的协作图:

Public 成员函数
	JointlyPredictionPlanningEvaluator ()
	Constructor

virtual	~JointlyPredictionPlanningEvaluator ()=default
	Destructor

void	Clear ()
	Clear obstacle feature map

bool	VectornetProcessObstaclePosition (Obstacle obstacle_ptr, ObstaclesContainer obstacles_container, torch::Tensor ptr_target_obs_pos, torch::Tensor ptr_target_obs_pos_step, torch::Tensor ptr_vector_mask, torch::Tensor ptr_all_obstacle_pos, torch::Tensor ptr_all_obs_p_id, torch::Tensor ptr_obs_length)
	Process obstacle position to vector

bool	VectornetProcessMapData (FeatureVector map_feature, PidVector map_p_id, const int obs_num, torch::Tensor ptr_map_data, torch::Tensor ptr_all_map_p_id, torch::Tensor *ptr_vector_mask)
	Process map data to vector

bool	Evaluate (Obstacle obstacle_ptr, ObstaclesContainer obstacles_container) override
	Override Evaluate

bool	Evaluate (const ADCTrajectoryContainer adc_trajectory_container, Obstacle obstacle_ptr, ObstaclesContainer *obstacles_container) override
	Override Evaluate

bool	ExtractObstaclesHistory (Obstacle obstacle_ptr, ObstaclesContainer obstacles_container, std::vector< std::pair< double, double > > curr_pos_history, std::vector< std::pair< double, double > > all_obs_length, std::vector< std::vector< std::pair< double, double > > > all_obs_pos_history, torch::Tensor vector_mask)
	Extract all obstacles history

bool	ExtractADCTrajectory (std::vector< TrajectoryPoint > trajectory_points, Obstacle obstacle_ptr, std::vector< std::pair< double, double > > *acd_traj_curr_pos)
	Extract adc trajectory and convert world coord to obstacle coord

std::string	GetName () override
	Get the name of evaluator.

Public 成员函数继承自 apollo::prediction::Evaluator
	Evaluator ()=default
	Constructor

virtual	~Evaluator ()=default
	Destructor

virtual bool	Evaluate (Obstacle obstacle, ObstaclesContainer obstacles_container, std::vector< Obstacle * > dynamic_env)
	Evaluate an obstacle

额外继承的成员函数
Protected 成员函数继承自 apollo::prediction::Evaluator
std::pair< double, double >	WorldCoordToObjCoord (std::pair< double, double > input_world_coord, std::pair< double, double > obj_world_coord, double obj_world_angle)

std::pair< double, double >	WorldCoordToObjCoordNorth (std::pair< double, double > input_world_coord, std::pair< double, double > obj_world_coord, double obj_world_angle)

double	WorldAngleToObjAngle (double input_world_angle, double obj_world_angle)

Eigen::MatrixXf	VectorToMatrixXf (const std::vector< double > &nums, const int start_index, const int end_index)

Eigen::MatrixXf	VectorToMatrixXf (const std::vector< double > &nums, const int start_index, const int end_index, const int output_num_row, const int output_num_col)

Protected 属性继承自 apollo::prediction::Evaluator
ObstacleConf::EvaluatorType	evaluator_type_

详细描述

在文件 jointly_prediction_planning_evaluator.h 第 34 行定义.

构造及析构函数说明

◆ JointlyPredictionPlanningEvaluator()

apollo::prediction::JointlyPredictionPlanningEvaluator::JointlyPredictionPlanningEvaluator ( )

Constructor

在文件 jointly_prediction_planning_evaluator.cc 第 40 行定义.

    : device_(torch::kCPU) {
  evaluator_type_ = ObstacleConf::JOINTLY_PREDICTION_PLANNING_EVALUATOR;
  LoadModel();
}

◆ ~JointlyPredictionPlanningEvaluator()

virtual apollo::prediction::JointlyPredictionPlanningEvaluator::~JointlyPredictionPlanningEvaluator ( )

virtualdefault

Destructor

成员函数说明

◆ Clear()

void apollo::prediction::JointlyPredictionPlanningEvaluator::Clear ( )

Clear obstacle feature map

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

46{}

◆ Evaluate() [1/2]

bool apollo::prediction::JointlyPredictionPlanningEvaluator::Evaluate	(	const ADCTrajectoryContainer *	adc_trajectory_container,
		Obstacle *	obstacle_ptr,
		ObstaclesContainer *	obstacles_container
	)

overridevirtual

Override Evaluate

参数

ADC	trajectory container
Obstacle	pointer
Obstacles	container

重载 apollo::prediction::Evaluator .

在文件 jointly_prediction_planning_evaluator.cc 第 167 行定义.

                                               {
  omp_set_num_threads(1);
 
  obstacle_ptr->SetEvaluatorType(evaluator_type_);
 
  Clear();
  CHECK_NOTNULL(obstacle_ptr);
  int id = obstacle_ptr->id();
  if (!obstacle_ptr->latest_feature().IsInitialized()) {
    AERROR << "Obstacle [" << id << "] has no latest feature.";
    return false;
  }
  Feature* latest_feature_ptr = obstacle_ptr->mutable_latest_feature();
  CHECK_NOTNULL(latest_feature_ptr);
 
  if (adc_trajectory_container == nullptr) {
    AERROR << "Null adc trajectory container";
    return false;
  }
 
  int obs_num =
      obstacles_container->curr_frame_considered_obstacle_ids().size();
 
  auto start_time_obs = std::chrono::system_clock::now();
 
  torch::Tensor target_obstacle_pos = torch::zeros({20, 2});
  torch::Tensor target_obstacle_pos_step = torch::zeros({20, 2});
  torch::Tensor vector_mask = torch::zeros({450, 50});
  torch::Tensor all_obstacle_pos = torch::zeros({obs_num, 20, 2});
  torch::Tensor all_obs_p_id = torch::zeros({obs_num, 2});
  torch::Tensor obs_length_tmp = torch::zeros({obs_num, 2});
 
  if (!VectornetProcessObstaclePosition(obstacle_ptr,
                                       obstacles_container,
                                       &target_obstacle_pos,
                                       &target_obstacle_pos_step,
                                       &vector_mask,
                                       &all_obstacle_pos,
                                       &all_obs_p_id,
                                       &obs_length_tmp)) {
    AERROR << "Obstacle [" << id << "] processing obstacle position fails.";
    return false;
  }
 
  auto end_time_obs = std::chrono::system_clock::now();
  std::chrono::duration<double> diff_obs = end_time_obs - start_time_obs;
  ADEBUG << "obstacle vectors used time: " << diff_obs.count() * 1000 << " ms.";
 
 
  // Query the map data vector
  FeatureVector map_feature;
  PidVector map_p_id;
  double pos_x = latest_feature_ptr->position().x();
  double pos_y = latest_feature_ptr->position().y();
  common::PointENU center_point;
  center_point.set_x(pos_x);
  center_point.set_y(pos_y);
  double heading = latest_feature_ptr->velocity_heading();
 
  auto start_time_query = std::chrono::system_clock::now();
 
  if (!vector_net_.query(center_point, heading, &map_feature, &map_p_id)) {
    return false;
  }
 
  auto end_time_query = std::chrono::system_clock::now();
  std::chrono::duration<double> diff_query = end_time_query - start_time_query;
  ADEBUG << "vectors query used time: " << diff_query.count() * 1000 << " ms.";
 
  // process map data & map p id & v_mask for map polyline
  int map_polyline_num = map_feature.size();
  int data_length =
      ((obs_num + map_polyline_num) < 450) ? (obs_num + map_polyline_num) : 450;
 
  // Process input tensor
  auto start_time_data_prep = std::chrono::system_clock::now();
  int map_polyline_num_valid =
      ((obs_num + map_polyline_num) < 450) ? map_polyline_num : (450 - obs_num);
  map_polyline_num_valid =
      map_polyline_num_valid > 0 ? map_polyline_num_valid : 0;
  torch::Tensor map_data = torch::zeros({map_polyline_num_valid, 50, 9});
  torch::Tensor all_map_p_id = torch::zeros({map_polyline_num_valid, 2});
 
  if (!VectornetProcessMapData(&map_feature,
                               &map_p_id,
                               obs_num,
                               &map_data,
                               &all_map_p_id,
                               &vector_mask)) {
    AERROR << "Obstacle [" << id << "] processing map data fails.";
    return false;
  }
 
  // process p mask
  torch::Tensor polyline_mask = torch::zeros({450});
  if (data_length < 450) {
    polyline_mask.index_put_(
        {torch::indexing::Slice(data_length, torch::indexing::None)}, 1);
  }
 
  // Extend obs data to specific dimension
  torch::Tensor obs_pos_data = torch::cat(
      {all_obstacle_pos.index(
           {torch::indexing::Slice(),
            torch::indexing::Slice(torch::indexing::None, -1),
            torch::indexing::Slice()}),
       all_obstacle_pos.index({torch::indexing::Slice(),
                               torch::indexing::Slice(1, torch::indexing::None),
                               torch::indexing::Slice()})},
      2);
  // Add obs length
  torch::Tensor obs_length = obs_length_tmp.unsqueeze(1).repeat({1, 19, 1});
  // Add obs attribute
  torch::Tensor obs_attr_agent =
      torch::tensor({11.0, 4.0}).unsqueeze(0).unsqueeze(0).repeat({1, 19, 1});
  torch::Tensor obs_attr_other =
      torch::tensor({10.0, 4.0}).unsqueeze(0).unsqueeze(0).repeat(
        {(obs_num - 1), 19, 1});
  torch::Tensor obs_attr = torch::cat({obs_attr_agent, obs_attr_other}, 0);
  // ADD obs id
  // add 500 to avoid same id as in map_info
  torch::Tensor obs_id =
      torch::arange(500, obs_num + 500).unsqueeze(1).repeat(
        {1, 19}).unsqueeze(2);
  // Process obs data
  torch::Tensor obs_data_with_len = torch::cat({obs_pos_data, obs_length}, 2);
  torch::Tensor obs_data_with_attr =
      torch::cat({obs_data_with_len, obs_attr}, 2);
  torch::Tensor obs_data_with_id = torch::cat({obs_data_with_attr, obs_id}, 2);
  torch::Tensor obs_data_final =
      torch::cat({torch::zeros({obs_num, (50 - 19), 9}), obs_data_with_id}, 1);
 
  // Extend data & pid to specific demension
  torch::Tensor data_tmp = torch::cat({obs_data_final, map_data}, 0);
  torch::Tensor p_id_tmp = torch::cat({all_obs_p_id, all_map_p_id}, 0);
  torch::Tensor vector_data;
  torch::Tensor polyline_id;
  if (data_length < 450) {
    torch::Tensor data_zeros = torch::zeros({(450 - data_length), 50, 9});
    torch::Tensor p_id_zeros = torch::zeros({(450 - data_length), 2});
    vector_data = torch::cat({data_tmp, data_zeros}, 0);
    polyline_id = torch::cat({p_id_tmp, p_id_zeros}, 0);
  } else {
    vector_data = data_tmp;
    polyline_id = p_id_tmp;
  }
 
  // Empty rand mask as placeholder
  auto rand_mask = torch::zeros({450}).toType(at::kBool);
  // Change mask type to bool
  auto bool_vector_mask = vector_mask.toType(at::kBool);
  auto bool_polyline_mask = polyline_mask.toType(at::kBool);
 
  // Process ADC trajectory & Extract features of ADC trajectory
  std::vector<std::pair<double, double>> adc_traj_curr_pos(30, {0.0, 0.0});
  torch::Tensor adc_trajectory = torch::zeros({1, 30, 6});
  const auto& adc_traj = adc_trajectory_container->adc_trajectory();
  size_t adc_traj_points_num = adc_traj.trajectory_point().size();
  if (adc_traj_points_num < 1) {
    AERROR << "adc_traj points num is " << adc_traj_points_num
           << " adc traj points are not enough";
    return false;
  }
  std::vector<TrajectoryPoint> adc_traj_points;
  // ADC trajectory info as model input needs to match with
  // the predicted obstalce's timestamp.
  double time_interval = obstacle_ptr->latest_feature().timestamp() -
      adc_traj.header().timestamp_sec();
  for (size_t i = 0; i < adc_traj_points_num - 1; ++i) {
    double delta_time = time_interval -
        adc_traj.trajectory_point(0).relative_time();
    adc_traj_points.emplace_back(
        InterpolateUsingLinearApproximation(
            adc_traj.trajectory_point(i),
            adc_traj.trajectory_point(i + 1), delta_time));
  }
  if (!ExtractADCTrajectory(&adc_traj_points,
      obstacle_ptr, &adc_traj_curr_pos)) {
    AERROR << "Failed to extract adc trajectory";
    return false;
  }
  size_t traj_points_num = adc_traj_points.size();
  for (size_t j = 0; j < 30; ++j) {
    if (j > traj_points_num - 1) {
      adc_trajectory[0][j][0] =
          adc_traj_curr_pos[traj_points_num - 1].first;
      adc_trajectory[0][j][1] =
          adc_traj_curr_pos[traj_points_num - 1].second;
      adc_trajectory[0][j][2] =
          adc_traj_points[traj_points_num - 1].path_point().theta();
      adc_trajectory[0][j][3] =
          adc_traj_points[traj_points_num - 1].v();
      adc_trajectory[0][j][4] =
          adc_traj_points[traj_points_num - 1].a();
      adc_trajectory[0][j][5] =
          adc_traj_points[traj_points_num - 1].path_point().kappa();
    } else {
      adc_trajectory[0][j][0] =
          adc_traj_curr_pos[j].first;
      adc_trajectory[0][j][1] =
          adc_traj_curr_pos[j].second;
      adc_trajectory[0][j][2] =
          adc_traj_points[j].path_point().theta();
      adc_trajectory[0][j][3] =
          adc_traj_points[j].v();
      adc_trajectory[0][j][4] =
          adc_traj_points[j].a();
      adc_trajectory[0][j][5] =
          adc_traj_points[j].path_point().kappa();
    }
  }
 
  // Build input features for torch
  std::vector<torch::jit::IValue> torch_inputs;
  auto X_value = c10::ivalue::Tuple::create(
      {std::move(target_obstacle_pos.unsqueeze(0).to(device_)),
       std::move(target_obstacle_pos_step.unsqueeze(0).to(device_)),
       std::move(vector_data.unsqueeze(0).to(device_)),
       std::move(bool_vector_mask.unsqueeze(0).to(device_)),
       std::move(bool_polyline_mask.unsqueeze(0).to(device_)),
       std::move(rand_mask.unsqueeze(0).to(device_)),
       std::move(polyline_id.unsqueeze(0).to(device_))});
  torch_inputs.push_back(c10::ivalue::Tuple::create(
      {X_value, std::move(adc_trajectory.to(device_))}));
 
  auto end_time_data_prep = std::chrono::system_clock::now();
  std::chrono::duration<double> diff_data_prep =
      end_time_data_prep - start_time_data_prep;
  ADEBUG << "vectornet input tensor prepration used time: "
         << diff_data_prep.count() * 1000 << " ms.";
 
  // Compute pred_traj
  auto start_time_inference = std::chrono::system_clock::now();
  at::Tensor torch_output_tensor = torch_default_output_tensor_;
  torch_output_tensor =
      torch_vehicle_model_.forward(torch_inputs).toTensor().to(torch::kCPU);
 
  auto end_time_inference = std::chrono::system_clock::now();
  std::chrono::duration<double> diff_inference =
      end_time_inference - start_time_inference;
  ADEBUG << "vectornet-interaction inference used time: "
         << diff_inference.count() * 1000
         << " ms.";
 
  // Get the trajectory
  auto torch_output = torch_output_tensor.accessor<float, 3>();
  Trajectory* trajectory = latest_feature_ptr->add_predicted_trajectory();
  trajectory->set_probability(1.0);
 
  for (int i = 0; i < 30; ++i) {
    double prev_x = pos_x;
    double prev_y = pos_y;
    if (i > 0) {
      const auto& last_point = trajectory->trajectory_point(i - 1).path_point();
      prev_x = last_point.x();
      prev_y = last_point.y();
    }
    TrajectoryPoint* point = trajectory->add_trajectory_point();
    double dx = static_cast<double>(torch_output[0][i][0]);
    double dy = static_cast<double>(torch_output[0][i][1]);
 
    double heading = latest_feature_ptr->velocity_heading();
    Vec2d offset(dx, dy);
    Vec2d rotated_offset = offset.rotate(heading - (M_PI / 2));
    double point_x = pos_x + rotated_offset.x();
    double point_y = pos_y + rotated_offset.y();
    point->mutable_path_point()->set_x(point_x);
    point->mutable_path_point()->set_y(point_y);
 
    if (i < 10) {  // use origin heading for the first second
      point->mutable_path_point()->set_theta(
          latest_feature_ptr->velocity_heading());
    } else {
      point->mutable_path_point()->set_theta(
          std::atan2(trajectory->trajectory_point(i).path_point().y() -
                         trajectory->trajectory_point(i - 1).path_point().y(),
                     trajectory->trajectory_point(i).path_point().x() -
                         trajectory->trajectory_point(i - 1).path_point().x()));
    }
    point->set_relative_time(static_cast<double>(i) *
                             FLAGS_prediction_trajectory_time_resolution);
    if (i == 0) {
      point->set_v(latest_feature_ptr->speed());
    } else {
      double diff_x = point_x - prev_x;
      double diff_y = point_y - prev_y;
      point->set_v(std::hypot(diff_x, diff_y) /
                   FLAGS_prediction_trajectory_time_resolution);
    }
  }
 
  return true;
}

◆ Evaluate() [2/2]

bool apollo::prediction::JointlyPredictionPlanningEvaluator::Evaluate	(	Obstacle *	obstacle_ptr,
		ObstaclesContainer *	obstacles_container
	)

overridevirtual

Override Evaluate

参数

Obstacle	pointer
Obstacles	container

实现了 apollo::prediction::Evaluator.

在文件 jointly_prediction_planning_evaluator.cc 第 160 行定义.

                                                                              {
  const ADCTrajectoryContainer* adc_trajectory_container;
  Evaluate(adc_trajectory_container, obstacle_ptr, obstacles_container);
  return true;
}

◆ ExtractADCTrajectory()

bool apollo::prediction::JointlyPredictionPlanningEvaluator::ExtractADCTrajectory	(	std::vector< TrajectoryPoint > *	trajectory_points,
		Obstacle *	obstacle_ptr,
		std::vector< std::pair< double, double > > *	acd_traj_curr_pos
	)

Extract adc trajectory and convert world coord to obstacle coord

参数

Obstacle pointer Feature container in a vector for receiving the obstacle history

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

                                                           {
  adc_traj_curr_pos->resize(30, {0.0, 0.0});
  const Feature& obs_curr_feature = obstacle_ptr->latest_feature();
  double obs_curr_heading = obs_curr_feature.velocity_heading();
  std::pair<double, double> obs_curr_pos = std::make_pair(
      obs_curr_feature.position().x(), obs_curr_feature.position().y());
  size_t adc_traj_points_num = trajectory_points->size();
  for (size_t i = 0; i < 30; ++i) {
    if (i > adc_traj_points_num -1) {
      adc_traj_curr_pos->at(i) =
          adc_traj_curr_pos->at(adc_traj_points_num - 1);
    } else {
      adc_traj_curr_pos->at(i) = WorldCoordToObjCoordNorth(
          std::make_pair(trajectory_points->at(i).path_point().x(),
          trajectory_points->at(i).path_point().y()),
          obs_curr_pos, obs_curr_heading);
    }
  }
  return true;
}

◆ ExtractObstaclesHistory()

bool apollo::prediction::JointlyPredictionPlanningEvaluator::ExtractObstaclesHistory	(	Obstacle *	obstacle_ptr,
		ObstaclesContainer *	obstacles_container,
		std::vector< std::pair< double, double > > *	curr_pos_history,
		std::vector< std::pair< double, double > > *	all_obs_length,
		std::vector< std::vector< std::pair< double, double > > > *	all_obs_pos_history,
		torch::Tensor *	vector_mask
	)

Extract all obstacles history

参数

Obstacles container Feature container in a vector for receiving the obstacle history

在文件 jointly_prediction_planning_evaluator.cc 第 464 行定义.

                              {
  const Feature& obs_curr_feature = obstacle_ptr->latest_feature();
  double obs_curr_heading = obs_curr_feature.velocity_heading();
  std::pair<double, double> obs_curr_pos = std::make_pair(
      obs_curr_feature.position().x(), obs_curr_feature.position().y());
  // Extract target obstacle history
  for (std::size_t i = 0; i < obstacle_ptr->history_size() && i < 20; ++i) {
    const Feature& target_feature = obstacle_ptr->feature(i);
    if (!target_feature.IsInitialized()) {
      break;
    }
    target_pos_history->at(i) =
        WorldCoordToObjCoordNorth(std::make_pair(target_feature.position().x(),
                                            target_feature.position().y()),
                             obs_curr_pos, obs_curr_heading);
  }
  all_obs_length->emplace_back(
      std::make_pair(obs_curr_feature.length(), obs_curr_feature.width()));
  all_obs_pos_history->emplace_back(*target_pos_history);
 
  // Extract other obstacles & convert pos to traget obstacle relative coord
  std::vector<std::pair<double, double>> pos_history(20, {0.0, 0.0});
  for (int id : obstacles_container->curr_frame_considered_obstacle_ids()) {
    Obstacle* obstacle = obstacles_container->GetObstacle(id);
    if (!obstacle) {
      continue;
    }
    int target_id = obstacle_ptr->id();
    if (id == target_id) {
      continue;
    }
    const Feature& other_obs_curr_feature = obstacle->latest_feature();
    all_obs_length->emplace_back(std::make_pair(
        other_obs_curr_feature.length(), other_obs_curr_feature.width()));
 
    size_t obs_his_size = obstacle->history_size();
    obs_his_size = obs_his_size <= 20 ? obs_his_size : 20;
    int cur_idx = all_obs_pos_history->size();
    if (obs_his_size > 1) {
      vector_mask->index_put_({cur_idx,
                              torch::indexing::Slice(torch::indexing::None,
                                                     -(obs_his_size - 1))}, 1);
    } else {
      vector_mask->index_put_({cur_idx,
                              torch::indexing::Slice(torch::indexing::None,
                              -1)}, 1);
    }
 
    for (size_t i = 0; i < obs_his_size; ++i) {
      const Feature& feature = obstacle->feature(i);
      if (!feature.IsInitialized()) {
        break;
      }
      pos_history[i] = WorldCoordToObjCoordNorth(
          std::make_pair(feature.position().x(), feature.position().y()),
          obs_curr_pos, obs_curr_heading);
    }
    all_obs_pos_history->emplace_back(pos_history);
  }
  return true;
}

◆ GetName()

std::string apollo::prediction::JointlyPredictionPlanningEvaluator::GetName ( )

inlineoverridevirtual

Get the name of evaluator.

实现了 apollo::prediction::Evaluator.

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

                               {
    return "JOINTLY_PREDICTION_PLANNING_EVALUATOR";
  }

◆ VectornetProcessMapData()

bool apollo::prediction::JointlyPredictionPlanningEvaluator::VectornetProcessMapData	(	FeatureVector *	map_feature,
		PidVector *	map_p_id,
		const int	obs_num,
		torch::Tensor *	ptr_map_data,
		torch::Tensor *	ptr_all_map_p_id,
		torch::Tensor *	ptr_vector_mask
	)

Process map data to vector

参数

FeatureVector	map feature vector
int	obstacle number
PidVector	map p_id vector
Tensor	map data
Tensor	map data p_id

在文件 jointly_prediction_planning_evaluator.cc 第 119 行定义.

                                    {
  int map_polyline_num = map_feature->size();
 
  for (int i = 0; i < map_polyline_num && obs_num + i < 450; ++i) {
    size_t one_polyline_vector_size = map_feature->at(i).size();
    if (one_polyline_vector_size < 50) {
      ptr_vector_mask->index_put_({obs_num + i,
                                   torch::indexing::Slice(
                                       one_polyline_vector_size,
                                       torch::indexing::None)},
                                  1);
    }
  }
 
  auto opts = torch::TensorOptions().dtype(torch::kDouble);
 
  for (int i = 0; i < map_polyline_num && i + obs_num < 450; ++i) {
    ptr_all_map_p_id->index_put_({i}, torch::from_blob(map_p_id->at(i).data(),
                                                       {2},
                                                       opts));
 
    int one_polyline_vector_size = map_feature->at(i).size();
    for (int j = 0; j < one_polyline_vector_size && j < 50; ++j) {
      ptr_map_data->index_put_({i, j},
                               torch::from_blob(map_feature->at(i)[j].data(),
                                                {9},
                                                opts));
    }
  }
  *ptr_map_data = ptr_map_data->toType(at::kFloat);
  *ptr_all_map_p_id = ptr_all_map_p_id->toType(at::kFloat);
 
  return true;
}

◆ VectornetProcessObstaclePosition()

bool apollo::prediction::JointlyPredictionPlanningEvaluator::VectornetProcessObstaclePosition	(	Obstacle *	obstacle_ptr,
		ObstaclesContainer *	obstacles_container,
		torch::Tensor *	ptr_target_obs_pos,
		torch::Tensor *	ptr_target_obs_pos_step,
		torch::Tensor *	ptr_vector_mask,
		torch::Tensor *	ptr_all_obstacle_pos,
		torch::Tensor *	ptr_all_obs_p_id,
		torch::Tensor *	ptr_obs_length
	)

Process obstacle position to vector

参数

Obstacles	pointer
Obstacles	container
Tensor	target obstacle position
Tensor	target obstacle position step
Tensor	vector mask
Tensor	all obstacle position
Tensor	all obstacle p_id
Tensor	all obstacle length

在文件 jointly_prediction_planning_evaluator.cc 第 48 行定义.

                                   {
  // obs data vector
  // Extract features of pos_history
  std::vector<std::pair<double, double>> target_pos_history(20, {0.0, 0.0});
  std::vector<std::pair<double, double>> all_obs_length;
  std::vector<std::vector<std::pair<double, double>>> all_obs_pos_history;
 
  if (!ExtractObstaclesHistory(obstacle_ptr, obstacles_container,
                               &target_pos_history, &all_obs_length,
                               &all_obs_pos_history, ptr_vector_mask)) {
    AERROR << "Obstacle [" << obstacle_ptr->id()
           << "] failed to extract obstacle history";
    return false;
  }
 
  for (int j = 0; j < 20; ++j) {
    ptr_target_obs_pos->index_put_({19 - j, 0}, target_pos_history[j].first);
    ptr_target_obs_pos->index_put_({19 - j, 1}, target_pos_history[j].second);
    if (j == 19 || (j > 0 && target_pos_history[j + 1].first == 0.0)) {
      break;
    }
    ptr_target_obs_pos_step->index_put_(
        {19 - j, 0},
        target_pos_history[j].first - target_pos_history[j + 1].first);
    ptr_target_obs_pos_step->index_put_(
        {19 - j, 1},
        target_pos_history[j].second - target_pos_history[j + 1].second);
  }
 
  int obs_num =
      obstacles_container->curr_frame_considered_obstacle_ids().size();
  for (int i = 0; i < obs_num; ++i) {
    std::vector<double> obs_p_id{std::numeric_limits<float>::max(),
                              std::numeric_limits<float>::max()};
    for (int j = 0; j < 20; ++j) {
      // Process obs pid
      if (obs_p_id[0] > all_obs_pos_history[i][j].first) {
        obs_p_id[0] = all_obs_pos_history[i][j].first;
      }
      if (obs_p_id[1] > all_obs_pos_history[i][j].second) {
        obs_p_id[1] = all_obs_pos_history[i][j].second;
      }
      // Process obs pos history
      ptr_all_obstacle_pos->index_put_(
          {i, 19 - j, 0},
          all_obs_pos_history[i][j].first);
      ptr_all_obstacle_pos->index_put_(
          {i, 19 - j, 1},
          all_obs_pos_history[i][j].second);
    }
 
    ptr_all_obs_p_id->index_put_({i, 0}, obs_p_id[0]);
    ptr_all_obs_p_id->index_put_({i, 1}, obs_p_id[1]);
  }
 
  for (int i = 0; i < obs_num; ++i) {
    ptr_obs_length->index_put_({i, 0}, all_obs_length[i].first);
    ptr_obs_length->index_put_({i, 1}, all_obs_length[i].second);
  }
 
  return true;
}

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

modules/prediction/evaluator/vehicle/jointly_prediction_planning_evaluator.h
modules/prediction/evaluator/vehicle/jointly_prediction_planning_evaluator.cc

Public 成员函数

额外继承的成员函数

详细描述

构造及析构函数说明

◆ JointlyPredictionPlanningEvaluator()

◆ ~JointlyPredictionPlanningEvaluator()

成员函数说明

◆ Clear()

◆ Evaluate() [1/2]

◆ Evaluate() [2/2]

◆ ExtractADCTrajectory()

◆ ExtractObstaclesHistory()

◆ GetName()

◆ VectornetProcessMapData()

◆ VectornetProcessObstaclePosition()