apollo::prediction 命名空间参考

apollo::prediction 更多...

命名空间
namespace	math_util
namespace	network
	apollo::prediction::network
namespace	predictor_util

类
class	ADCTrajectoryContainer
class	AffineTransform
class	BaseThreadPool
struct	CarPosition
class	Container
class	ContainerManager
class	CostEvaluator
class	CruiseMLPEvaluator
class	CruiseScenarioFeatures
class	CyclistKeepLaneEvaluator
struct	DataForLearning
struct	DataForTuning
class	EmptyPredictor
class	EnvironmentFeatures
class	Evaluator
class	EvaluatorManager
struct	EvaluatorModelConf
class	EvaluatorSubmodule
class	ExtrapolationPredictor
class	FakePredictionComponent
	class FakePredictionComponent This class generates fake prediction messages. 更多...
struct	Feature
class	FeatureExtractor
class	FeatureOutput
struct	Features
struct	FnnVehicleModel
struct	FrameEnv
class	FreeMovePredictor
struct	Intent
class	InteractionFilter
class	InteractionPredictor
class	JointlyPredictionPlanningEvaluator
class	JunctionAnalyzer
struct	JunctionExit
struct	JunctionFeature
class	JunctionMapEvaluator
class	JunctionMLPEvaluator
class	JunctionPredictor
class	JunctionScenarioFeatures
class	KMLMapBasedTest
struct	Lane
class	LaneAggregatingEvaluator
struct	LaneFeature
struct	LaneGraph
struct	LaneObstacle
struct	LanePoint
class	LaneScanningEvaluator
struct	LaneSegment
struct	LaneSequence
class	LaneSequencePredictor
struct	Layer
class	LevelThreadPool
struct	ListDataForLearning
struct	ListDataForTuning
struct	ListFrameEnv
struct	ListPredictionResult
struct	Matrix
class	MessageProcess
class	MLPEvaluator
struct	Model
class	ModelBase
struct	ModelConf
class	ModelManager
class	MoveSequencePredictor
class	MultiAgentEvaluator
class	MultiAgentPedestrianCpuTorch
class	MultiAgentPedestrianGpuTorch
class	MultiAgentVehicleCpuTorch
class	MultiAgentVehicleGpuTorch
struct	NearbyObstacle
struct	NetParameter
class	Obstacle
	Prediction obstacle. 更多...
class	ObstacleClusters
struct	ObstacleConf
struct	ObstacleHistory
struct	ObstacleIntent
struct	ObstacleInteractiveTag
struct	ObstaclePriority
class	ObstaclesContainer
class	ObstaclesPrioritizer
class	PedestrianInteractionEvaluator
struct	Performance
struct	Polyline
class	PoseContainer
class	PredictionComponent
struct	PredictionConf
class	PredictionConstants
class	PredictionMap
struct	PredictionObstacle
struct	PredictionObstacles
struct	PredictionPathPoint
struct	PredictionResult
class	PredictionThreadPool
struct	PredictionTrajectoryPoint
class	Predictor
class	PredictorManager
class	PredictorSubmodule
class	RightOfWay
class	RoadGraph
struct	Scenario
class	ScenarioAnalyzer
class	ScenarioFeatures
class	ScenarioManager
class	SemanticLSTMEvaluator
class	SemanticLstmPedestrianCpuTorch
class	SemanticLstmPedestrianGpuTorch
class	SemanticLstmVehicleCpuTorch
class	SemanticLstmVehicleGpuTorch
class	SemanticMap
class	SequencePredictor
class	SingleLanePredictor
struct	StopSign
class	StoryTellingContainer
class	SubmoduleOutput
struct	TopicConf
struct	Trajectory
class	ValidationChecker
struct	Vector
class	VectorNet
class	VectornetEvaluator
struct	VectorNetFeature
struct	VerificationSample
struct	VNVector
struct	WorldCoord

类型定义
using	ConstLaneInfoPtr = std::shared_ptr< const LaneInfo >
using	Point = apollo::common::Point3D
using	IdObstacleListMap = std::unordered_map< int, std::list< Obstacle * > >
using	FeatureVector = std::vector< std::vector< std::vector< double > > >
using	PidVector = std::vector< std::vector< double > >
using	LaneInfoPtr = std::shared_ptr< const LaneInfo >
using	JunctionInfoPtr = std::shared_ptr< const JunctionInfo >

枚举
enum	ATTRIBUTE_TYPE {   ROAD , LANE_UNKOWN , LANE_DOTTED_YELLOW , LANE_DOTTED_WHITE ,   LANE_SOLID_YELLOW , LANE_SOLID_WHITE , LANE_DOUBLE_YELLOW , LANE_CURB ,   JUNCTION , CROSSWALK }
enum	BOUNDARY_TYPE { UNKNOW , NORMAL , LEFT_BOUNDARY , RIGHT_BOUNDARY }

函数
void	GetRecordFileNames (const boost::filesystem::path &p, std::vector< std::string > *record_files)
double	ComputeMean (const std::vector< double > &nums, size_t start, size_t end)
void	WarmUp (const std::vector< torch::jit::IValue > &torch_inputs, torch::jit::script::Module *model, at::Tensor *default_output)
	warm up function to avoid slowly inference of torch model
void	GenerateDataForLearning ()
	CYBER_REGISTER_COMPONENT (FakePredictionComponent)

详细描述

apollo::prediction

类型定义说明

ConstLaneInfoPtr

typedef std::shared_ptr< const LaneInfo > apollo::prediction::ConstLaneInfoPtr

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

FeatureVector

using apollo::prediction::FeatureVector = typedef std::vector<std::vector<std::vector<double> >>

在文件 vector_net.h 第 33 行定义.

IdObstacleListMap

using apollo::prediction::IdObstacleListMap = typedef std::unordered_map<int, std::list<Obstacle*> >

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

JunctionInfoPtr

using apollo::prediction::JunctionInfoPtr = typedef std::shared_ptr<const JunctionInfo>

在文件 feature_extractor.cc 第 29 行定义.

LaneInfoPtr

using apollo::prediction::LaneInfoPtr = typedef std::shared_ptr<const LaneInfo>

在文件 feature_extractor.cc 第 28 行定义.

PidVector

using apollo::prediction::PidVector = typedef std::vector<std::vector<double> >

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

Point

using apollo::prediction::Point = typedef apollo::common::Point3D

在文件 pose_container.cc 第 28 行定义.

枚举类型说明

ATTRIBUTE_TYPE

enum apollo::prediction::ATTRIBUTE_TYPE

枚举值
ROAD
LANE_UNKOWN
LANE_DOTTED_YELLOW
LANE_DOTTED_WHITE
LANE_SOLID_YELLOW
LANE_SOLID_WHITE
LANE_DOUBLE_YELLOW
LANE_CURB
JUNCTION
CROSSWALK

在文件 vector_net.h 第 36 行定义.

                    {
  ROAD,
  LANE_UNKOWN,
  LANE_DOTTED_YELLOW,
  LANE_DOTTED_WHITE,
  LANE_SOLID_YELLOW,
  LANE_SOLID_WHITE,
  LANE_DOUBLE_YELLOW,
  LANE_CURB,
  JUNCTION,
  CROSSWALK,
};

BOUNDARY_TYPE

enum apollo::prediction::BOUNDARY_TYPE

枚举值
UNKNOW
NORMAL
LEFT_BOUNDARY
RIGHT_BOUNDARY

在文件 vector_net.h 第 49 行定义.

                   {
  UNKNOW,
  NORMAL,
  LEFT_BOUNDARY,
  RIGHT_BOUNDARY,
};

函数说明

ComputeMean()

double apollo::prediction::ComputeMean	(	const std::vector< double > &	nums,
		size_t	start,
		size_t	end
	)

在文件 cruise_mlp_evaluator.cc 第 37 行定义.

                                                                            {
  int count = 0;
  double sum = 0.0;
  for (size_t i = start; i <= end && i < nums.size(); i++) {
    sum += nums[i];
    ++count;
  }
  return (count == 0) ? 0.0 : sum / count;
}

CYBER_REGISTER_COMPONENT()

apollo::prediction::CYBER_REGISTER_COMPONENT

(

FakePredictionComponent

)

GenerateDataForLearning()

void apollo::prediction::GenerateDataForLearning

(

)

在文件 records_to_offline_data.cc 第 30 行定义.

                               {
  apollo::hdmap::HDMapUtil::ReloadMaps();
  if (!FeatureOutput::Ready()) {
    AERROR << "Feature output is not ready.";
    return;
  }
  if (FLAGS_prediction_offline_bags.empty()) {
    return;
  }
 
  PredictionConf prediction_conf;
  if (!cyber::common::GetProtoFromFile(FLAGS_prediction_conf_file,
                                       &prediction_conf)) {
    AERROR << "Unable to load adapter conf file: "
           << FLAGS_prediction_adapter_config_filename;
    return;
  }
  ADEBUG << "Adapter config file is loaded into: "
         << prediction_conf.ShortDebugString();
 
  auto container_manager = std::make_shared<ContainerManager>();
  EvaluatorManager evaluator_manager;
  PredictorManager predictor_manager;
  ScenarioManager scenario_manager;
 
  if (!MessageProcess::Init(container_manager.get(), &evaluator_manager,
                            &predictor_manager, prediction_conf)) {
    return;
  }
  const std::vector<std::string> inputs =
      absl::StrSplit(FLAGS_prediction_offline_bags, ':');
  for (const auto& input : inputs) {
    std::vector<std::string> offline_bags;
    GetRecordFileNames(boost::filesystem::path(input), &offline_bags);
    std::sort(offline_bags.begin(), offline_bags.end());
    AINFO << "For input " << input << ", found " << offline_bags.size()
          << "  rosbags to process";
    for (std::size_t i = 0; i < offline_bags.size(); ++i) {
      AINFO << "\tProcessing: [ " << i << " / " << offline_bags.size()
            << " ]: " << offline_bags[i];
      MessageProcess::ProcessOfflineData(prediction_conf, container_manager,
                                         &evaluator_manager, &predictor_manager,
                                         &scenario_manager, offline_bags[i]);
    }
  }
  FeatureOutput::Close();
}

GetRecordFileNames()

void apollo::prediction::GetRecordFileNames	(	const boost::filesystem::path &	p,
		std::vector< std::string > *	record_files
	)

在文件 data_extraction.cc 第 24 行定义.

                                                            {
  ACHECK(record_files);
  if (!boost::filesystem::exists(p)) {
    return;
  }
  if (boost::filesystem::is_regular_file(p)) {
    AINFO << "Found record file: " << p.c_str();
    record_files->push_back(p.c_str());
    return;
  }
  if (boost::filesystem::is_directory(p)) {
    for (auto& entry : boost::make_iterator_range(
             boost::filesystem::directory_iterator(p), {})) {
      GetRecordFileNames(entry.path(), record_files);
    }
  }
}

WarmUp()

void apollo::prediction::WarmUp	(	const std::vector< torch::jit::IValue > &	torch_inputs,
		torch::jit::script::Module *	model,
		at::Tensor *	default_output
	)

warm up function to avoid slowly inference of torch model

参数

torch_inputs	input vector of torch model
model	torch model instance
default_output	pointer of output, which is usually maintained by evaluator

在文件 warm_up.cc 第 28 行定义.

                                          {
  for (uint32_t i = 0; i < FLAGS_warm_up_times; i++) {
    if (default_output_ptr != nullptr)
      *default_output_ptr =
          model->forward(torch_inputs).toTensor().to(torch::kCPU);
    else
      model->forward(torch_inputs);
  }
}