apollo::prediction::FeatureOutput类 参考

#include <feature_output.h>

apollo::prediction::FeatureOutput 的协作图:

Public 成员函数
	FeatureOutput ()=delete
	Constructor; disabled

静态 Public 成员函数
static void	Close ()
	Close the output stream
static void	Clear ()
	Reset
static bool	Ready ()
	Check if output is ready
static void	InsertFeatureProto (const Feature &feature)
	Insert a feature
static void	InsertDataForLearning (const Feature &feature, const std::vector< double > &feature_values, const std::string &category, const LaneSequence *lane_sequence_ptr)
	Insert a data_for_learning
static void	InsertDataForLearning (const Feature &feature, const std::vector< double > &feature_values, const std::vector< std::string > &string_feature_values, const std::string &category, const LaneSequence *lane_sequence_ptr)
static void	InsertPredictionResult (const Obstacle *obstacle, const PredictionObstacle &prediction_obstacle, const ObstacleConf &obstacle_conf, const Scenario &scenario)
	Insert a prediction result with predicted trajectories
static void	InsertFrameEnv (const FrameEnv &frame_env)
	Insert a frame env
static void	InsertDataForTuning (const Feature &feature, const std::vector< double > &feature_values, const std::string &category, const LaneSequence &lane_sequence, const std::vector< apollo::common::TrajectoryPoint > &adc_trajectory)
	Insert a data_for_tuning
static void	WriteFeatureProto ()
	Write features to a file
static void	WriteDataForLearning ()
	Write DataForLearning features to a file
static void	WritePredictionResult ()
	Write PredictionResult to a file
static void	WriteFrameEnv ()
	Write frame env to a file
static void	WriteDataForTuning ()
	Write DataForTuning features to a file
static int	Size ()
	Get feature size
static int	SizeOfDataForLearning ()
	Get the size of data_for_learning features.
static int	SizeOfPredictionResult ()
	Get the size of prediction results.
static int	SizeOfFrameEnv ()
	Get the size of frame env.
static int	SizeOfDataForTuning ()
	Get the size of data for tuning.

详细描述

在文件 feature_output.h 第 30 行定义.

构造及析构函数说明

FeatureOutput()

apollo::prediction::FeatureOutput::FeatureOutput ( )

delete

Constructor; disabled

成员函数说明

Clear()

void apollo::prediction::FeatureOutput::Clear ( )

static

Reset

在文件 feature_output.cc 第 72 行定义.

                          {
  UNIQUE_LOCK_MULTITHREAD(mutex_feature_);
  idx_feature_ = 0;
  idx_learning_ = 0;
  idx_prediction_result_ = 0;
  idx_frame_env_ = 0;
  idx_tuning_ = 0;
  features_.Clear();
  list_data_for_learning_.Clear();
  list_prediction_result_.Clear();
  list_frame_env_.Clear();
  list_data_for_tuning_.Clear();
}

Close()

void apollo::prediction::FeatureOutput::Close ( )

static

Close the output stream

在文件 feature_output.cc 第 41 行定义.

                          {
  ADEBUG << "Close feature output";
  switch (FLAGS_prediction_offline_mode) {
    case 1: {
      WriteFeatureProto();
      break;
    }
    case 2: {
      WriteDataForLearning();
      break;
    }
    case 3: {
      WritePredictionResult();
      break;
    }
    case 4: {
      WriteFrameEnv();
      break;
    }
    case 5: {
      WriteDataForTuning();
      break;
    }
    default: {
      // No data dump
      break;
    }
  }
  Clear();
}

InsertDataForLearning() [1/2]

void apollo::prediction::FeatureOutput::InsertDataForLearning ( const Feature &  feature, const std::vector< double > &  feature_values, const std::string &  category, const LaneSequence *  lane_sequence_ptr  )

static

Insert a data_for_learning

参数

A	feature in proto

在文件 feature_output.cc 第 96 行定义.

                                                                      {
  const std::vector<std::string> dummy_string_feature_values;
  InsertDataForLearning(feature, feature_values, dummy_string_feature_values,
                        category, lane_sequence_ptr);
}

InsertDataForLearning() [2/2]

void apollo::prediction::FeatureOutput::InsertDataForLearning ( const Feature &  feature, const std::vector< double > &  feature_values, const std::vector< std::string > &  string_feature_values, const std::string &  category, const LaneSequence *  lane_sequence_ptr  )

static

在文件 feature_output.cc 第 104 行定义.

                                                                      {
  UNIQUE_LOCK_MULTITHREAD(mutex_feature_);
  DataForLearning* data_for_learning =
      list_data_for_learning_.add_data_for_learning();
  data_for_learning->set_id(feature.id());
  data_for_learning->set_timestamp(feature.timestamp());
  *(data_for_learning->mutable_features_for_learning()) = {
      feature_values.begin(), feature_values.end()};
  *(data_for_learning->mutable_string_features_for_learning()) = {
      string_feature_values.begin(), string_feature_values.end()};
  data_for_learning->set_category(category);
  ADEBUG << "Insert [" << category
         << "] data for learning with size = " << feature_values.size();
  if (lane_sequence_ptr != nullptr) {
    data_for_learning->set_lane_sequence_id(
        lane_sequence_ptr->lane_sequence_id());
  }
}

InsertDataForTuning()

void apollo::prediction::FeatureOutput::InsertDataForTuning ( const Feature &  feature, const std::vector< double > &  feature_values, const std::string &  category, const LaneSequence &  lane_sequence, const std::vector< apollo::common::TrajectoryPoint > &  adc_trajectory  )

static

Insert a data_for_tuning

参数

A	feature in proto
values	for tuning
category	of the data
lane	sequence
adc	trajectory

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

                                                      {
  UNIQUE_LOCK_MULTITHREAD(mutex_feature_);
  DataForTuning* data_for_tuning = list_data_for_tuning_.add_data_for_tuning();
  data_for_tuning->set_id(feature.id());
  data_for_tuning->set_timestamp(feature.timestamp());
  *data_for_tuning->mutable_values_for_tuning() = {feature_values.begin(),
                                                   feature_values.end()};
  data_for_tuning->set_category(category);
  ADEBUG << "Insert [" << category
         << "] data for tuning with size = " << feature_values.size();
  data_for_tuning->set_lane_sequence_id(lane_sequence.lane_sequence_id());
  for (const auto& adc_traj_point : adc_trajectory) {
    data_for_tuning->add_adc_trajectory_point()->CopyFrom(adc_traj_point);
  }
}

InsertFeatureProto()

void apollo::prediction::FeatureOutput::InsertFeatureProto ( const Feature &  feature )

static

Insert a feature

参数

A	feature in proto

在文件 feature_output.cc 第 91 行定义.

                                                             {
  UNIQUE_LOCK_MULTITHREAD(mutex_feature_);
  features_.add_feature()->CopyFrom(feature);
}

InsertFrameEnv()

void apollo::prediction::FeatureOutput::InsertFrameEnv ( const FrameEnv &  frame_env )

static

Insert a frame env

参数

frame

env

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

                                                            {
  UNIQUE_LOCK_MULTITHREAD(mutex_feature_);
  list_frame_env_.add_frame_env()->CopyFrom(frame_env);
}

InsertPredictionResult()

void apollo::prediction::FeatureOutput::InsertPredictionResult ( const Obstacle *  obstacle, const PredictionObstacle &  prediction_obstacle, const ObstacleConf &  obstacle_conf, const Scenario &  scenario  )

static

Insert a prediction result with predicted trajectories

参数

Obstacle	id
prediction_obstacle
obstacle_conf
scenario

在文件 feature_output.cc 第 126 行定义.

                                                                 {
  UNIQUE_LOCK_MULTITHREAD(mutex_feature_);
  PredictionResult* prediction_result =
      list_prediction_result_.add_prediction_result();
  prediction_result->set_id(obstacle->id());
  prediction_result->set_timestamp(prediction_obstacle.timestamp());
  for (int i = 0; i < prediction_obstacle.trajectory_size(); ++i) {
    prediction_result->add_trajectory()->CopyFrom(
        prediction_obstacle.trajectory(i));
    prediction_result->mutable_obstacle_conf()->CopyFrom(obstacle_conf);
  }
  // Insert the scenario that the single obstacle is in
  if (scenario.type() == Scenario::JUNCTION &&
      obstacle->IsInJunction(scenario.junction_id())) {
    prediction_result->mutable_scenario()->set_type(Scenario::JUNCTION);
  } else if (obstacle->IsOnLane()) {
    prediction_result->mutable_scenario()->set_type(Scenario::CRUISE);
  }
}

Ready()

bool apollo::prediction::FeatureOutput::Ready ( )

static

Check if output is ready

返回

True if output is ready

在文件 feature_output.cc 第 86 行定义.

                          {
  Clear();
  return true;
}

Size()

int apollo::prediction::FeatureOutput::Size ( )

static

Get feature size

返回

Feature size

在文件 feature_output.cc 第 238 行定义.

                        {
  UNIQUE_LOCK_MULTITHREAD(mutex_feature_);
  return features_.feature_size();
}

SizeOfDataForLearning()

int apollo::prediction::FeatureOutput::SizeOfDataForLearning ( )

static

Get the size of data_for_learning features.

返回

The size of data_for_learning features.

在文件 feature_output.cc 第 243 行定义.

                                         {
  UNIQUE_LOCK_MULTITHREAD(mutex_feature_);
  return list_data_for_learning_.data_for_learning_size();
}

SizeOfDataForTuning()

int apollo::prediction::FeatureOutput::SizeOfDataForTuning ( )

static

Get the size of data for tuning.

返回

The size of data for tuning.

在文件 feature_output.cc 第 258 行定义.

                                       {
  UNIQUE_LOCK_MULTITHREAD(mutex_feature_);
  return list_data_for_tuning_.data_for_tuning_size();
}

SizeOfFrameEnv()

int apollo::prediction::FeatureOutput::SizeOfFrameEnv ( )

static

Get the size of frame env.

返回

The size of frame env.

在文件 feature_output.cc 第 253 行定义.

                                  {
  UNIQUE_LOCK_MULTITHREAD(mutex_feature_);
  return list_frame_env_.frame_env_size();
}

SizeOfPredictionResult()

int apollo::prediction::FeatureOutput::SizeOfPredictionResult ( )

static

Get the size of prediction results.

返回

The size of prediction results.

在文件 feature_output.cc 第 248 行定义.

                                          {
  UNIQUE_LOCK_MULTITHREAD(mutex_feature_);
  return list_prediction_result_.prediction_result_size();
}

WriteDataForLearning()

void apollo::prediction::FeatureOutput::WriteDataForLearning ( )

static

Write DataForLearning features to a file

在文件 feature_output.cc 第 185 行定义.

                                         {
  UNIQUE_LOCK_MULTITHREAD(mutex_feature_);
  if (list_data_for_learning_.data_for_learning().empty()) {
    ADEBUG << "Skip writing empty data_for_learning.";
  } else {
    const std::string file_name = absl::StrCat(
        FLAGS_prediction_data_dir, "/datalearn.", idx_learning_, ".bin");
    cyber::common::SetProtoToBinaryFile(list_data_for_learning_, file_name);
    list_data_for_learning_.Clear();
    ++idx_learning_;
  }
}

WriteDataForTuning()

void apollo::prediction::FeatureOutput::WriteDataForTuning ( )

static

Write DataForTuning features to a file

在文件 feature_output.cc 第 225 行定义.

                                       {
  UNIQUE_LOCK_MULTITHREAD(mutex_feature_);
  if (list_data_for_tuning_.data_for_tuning().empty()) {
    ADEBUG << "Skip writing empty data_for_tuning.";
    return;
  }
  const std::string file_name = absl::StrCat(
      FLAGS_prediction_data_dir, "/datatuning.", idx_tuning_, ".bin");
  cyber::common::SetProtoToBinaryFile(list_data_for_tuning_, file_name);
  list_data_for_tuning_.Clear();
  ++idx_tuning_;
}

WriteFeatureProto()

void apollo::prediction::FeatureOutput::WriteFeatureProto ( )

static

Write features to a file

在文件 feature_output.cc 第 172 行定义.

                                      {
  UNIQUE_LOCK_MULTITHREAD(mutex_feature_);
  if (features_.feature().empty()) {
    ADEBUG << "Skip writing empty feature.";
  } else {
    const std::string file_name = absl::StrCat(
        FLAGS_prediction_data_dir, "/feature.", idx_feature_, ".bin");
    cyber::common::SetProtoToBinaryFile(features_, file_name);
    features_.Clear();
    ++idx_feature_;
  }
}

WriteFrameEnv()

void apollo::prediction::FeatureOutput::WriteFrameEnv ( )

static

Write frame env to a file

在文件 feature_output.cc 第 212 行定义.

                                  {
  UNIQUE_LOCK_MULTITHREAD(mutex_feature_);
  if (list_frame_env_.frame_env().empty()) {
    ADEBUG << "Skip writing empty prediction_result.";
  } else {
    const std::string file_name = absl::StrCat(
        FLAGS_prediction_data_dir, "/frame_env.", idx_frame_env_, ".bin");
    cyber::common::SetProtoToBinaryFile(list_frame_env_, file_name);
    list_frame_env_.Clear();
    ++idx_frame_env_;
  }
}

WritePredictionResult()

void apollo::prediction::FeatureOutput::WritePredictionResult ( )

static

Write PredictionResult to a file

在文件 feature_output.cc 第 198 行定义.

                                          {
  UNIQUE_LOCK_MULTITHREAD(mutex_feature_);
  if (list_prediction_result_.prediction_result().empty()) {
    ADEBUG << "Skip writing empty prediction_result.";
  } else {
    const std::string file_name =
        absl::StrCat(FLAGS_prediction_data_dir, "/prediction_result.",
                     idx_prediction_result_, ".bin");
    cyber::common::SetProtoToBinaryFile(list_prediction_result_, file_name);
    list_prediction_result_.Clear();
    ++idx_prediction_result_;
  }
}

---

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

• modules/prediction/common/feature_output.h
• modules/prediction/common/feature_output.cc