Apollo 10.0
自动驾驶开放平台
Public 成员函数 | 静态 Public 成员函数 | 所有成员列表
apollo::prediction::MessageProcess类 参考

#include <message_process.h>

apollo::prediction::MessageProcess 的协作图:

Public 成员函数

 MessageProcess ()=delete
 

静态 Public 成员函数

static bool Init (ContainerManager *container_manager, EvaluatorManager *evaluator_manager, PredictorManager *predictor_manager, const PredictionConf &prediction_conf)
 
static bool InitContainers (ContainerManager *container_manager)
 
static bool InitEvaluators (EvaluatorManager *evaluator_manager, const PredictionConf &prediction_conf)
 
static bool InitPredictors (PredictorManager *predictor_manager, const PredictionConf &prediction_conf)
 
static void ContainerProcess (const std::shared_ptr< ContainerManager > &container_manager, const perception::PerceptionObstacles &perception_obstacles, ScenarioManager *scenario_manger)
 
static void OnPerception (const perception::PerceptionObstacles &perception_obstacles, const std::shared_ptr< ContainerManager > &container_manager, EvaluatorManager *evaluator_manager, PredictorManager *predictor_manager, ScenarioManager *scenario_manager, PredictionObstacles *const prediction_obstacles)
 
static void OnLocalization (ContainerManager *container_manager, const localization::LocalizationEstimate &localization)
 
static void OnPlanning (ContainerManager *container_manager, const planning::ADCTrajectory &adc_trajectory)
 
static void OnStoryTelling (ContainerManager *container_manager, const storytelling::Stories &story)
 
static void ProcessOfflineData (const PredictionConf &prediction_conf, const std::shared_ptr< ContainerManager > &container_manager, EvaluatorManager *evaluator_manager, PredictorManager *predictor_manager, ScenarioManager *scenario_manager, const std::string &record_filepath)
 

详细描述

在文件 message_process.h 第 40 行定义.

构造及析构函数说明

◆ MessageProcess()

apollo::prediction::MessageProcess::MessageProcess ( )
delete

成员函数说明

◆ ContainerProcess()

void apollo::prediction::MessageProcess::ContainerProcess ( const std::shared_ptr< ContainerManager > &  container_manager,
const perception::PerceptionObstacles &  perception_obstacles,
ScenarioManager *  scenario_manger 
)
static

在文件 message_process.cc 第 97 行定义.

100 {
101 ADEBUG << "Received a perception message ["
102 << perception_obstacles.ShortDebugString() << "].";
103
104 // Get obstacles_container
105 auto ptr_obstacles_container =
106 container_manager->GetContainer<ObstaclesContainer>(
107 AdapterConfig::PERCEPTION_OBSTACLES);
108 CHECK_NOTNULL(ptr_obstacles_container);
109 ptr_obstacles_container->CleanUp();
110
111 // Get pose_container
112 auto ptr_ego_pose_container = container_manager->GetContainer<PoseContainer>(
113 AdapterConfig::LOCALIZATION);
114 CHECK_NOTNULL(ptr_ego_pose_container);
115
116 // Get adc_trajectory_container
117 auto ptr_ego_trajectory_container =
118 container_manager->GetContainer<ADCTrajectoryContainer>(
119 AdapterConfig::PLANNING_TRAJECTORY);
120 CHECK_NOTNULL(ptr_ego_trajectory_container);
121
122 // Get storytelling_container
123 auto ptr_storytelling_container =
124 container_manager->GetContainer<StoryTellingContainer>(
125 AdapterConfig::STORYTELLING);
126 CHECK_NOTNULL(ptr_storytelling_container);
127
128 // Insert ADC into the obstacle_container.
129 const PerceptionObstacle* ptr_ego_vehicle =
130 ptr_ego_pose_container->ToPerceptionObstacle();
131 if (ptr_ego_vehicle != nullptr) {
132 double perception_obs_timestamp = ptr_ego_vehicle->timestamp();
133 if (perception_obstacles.has_header() &&
134 perception_obstacles.header().has_timestamp_sec()) {
135 ADEBUG << "Correcting " << std::fixed << std::setprecision(6)
136 << ptr_ego_vehicle->timestamp() << " to " << std::fixed
137 << std::setprecision(6)
138 << perception_obstacles.header().timestamp_sec();
139 perception_obs_timestamp = perception_obstacles.header().timestamp_sec();
140 }
141 ptr_obstacles_container->InsertPerceptionObstacle(*ptr_ego_vehicle,
142 perception_obs_timestamp);
143 double x = ptr_ego_vehicle->position().x();
144 double y = ptr_ego_vehicle->position().y();
145 ADEBUG << "Get ADC position [" << std::fixed << std::setprecision(6) << x
146 << ", " << std::fixed << std::setprecision(6) << y << "].";
147 ptr_ego_trajectory_container->SetPosition({x, y});
148 }
149
150 // Insert perception_obstacles
151 ptr_obstacles_container->Insert(perception_obstacles);
152
153 ObstaclesPrioritizer obstacles_prioritizer(container_manager);
154
155 InteractionFilter interaction_filter(container_manager);
156
157 // Ignore some obstacles
158 obstacles_prioritizer.AssignIgnoreLevel();
159
160 // Scenario analysis
161 scenario_manager->Run(container_manager.get());
162
163 // Build junction feature for the obstacles in junction
164 const Scenario scenario = scenario_manager->scenario();
165 if (scenario.type() == Scenario::JUNCTION && scenario.has_junction_id()) {
166 ptr_obstacles_container->GetJunctionAnalyzer()->Init(
167 scenario.junction_id());
168 ptr_obstacles_container->BuildJunctionFeature();
169 }
170
171 // Build lane graph
172 ptr_obstacles_container->BuildLaneGraph();
173
174 // Assign CautionLevel for obstacles
175 obstacles_prioritizer.AssignCautionLevel();
176
177 // Add interactive tag
178 if (FLAGS_enable_interactive_tag) {
179 interaction_filter.AssignInteractiveTag();
180 }
181
182 // Analyze RightOfWay for the caution obstacles
183 RightOfWay::Analyze(container_manager.get());
184}
apollo::prediction::RightOfWay::Analyze
static void Analyze(ContainerManager *container_manager)
Set right_of_way for all lane_sequence
Definition right_of_way.cc:38
ADEBUG
#define ADEBUG
Definition log.h:41

◆ Init()

bool apollo::prediction::MessageProcess::Init ( ContainerManager *  container_manager,
EvaluatorManager *  evaluator_manager,
PredictorManager *  predictor_manager,
const PredictionConf &  prediction_conf 
)
static

在文件 message_process.cc 第 54 行定义.

57 {
58 InitContainers(container_manager);
59 InitEvaluators(evaluator_manager, prediction_conf);
60 InitPredictors(predictor_manager, prediction_conf);
61
62 if (!FLAGS_use_navigation_mode && !PredictionMap::Ready()) {
63 AERROR << "Map cannot be loaded.";
64 return false;
65 }
66
67 return true;
68}
apollo::prediction::MessageProcess::InitContainers
static bool InitContainers(ContainerManager *container_manager)
Definition message_process.cc:70
apollo::prediction::MessageProcess::InitEvaluators
static bool InitEvaluators(EvaluatorManager *evaluator_manager, const PredictionConf &prediction_conf)
Definition message_process.cc:85
apollo::prediction::MessageProcess::InitPredictors
static bool InitPredictors(PredictorManager *predictor_manager, const PredictionConf &prediction_conf)
Definition message_process.cc:91
apollo::prediction::PredictionMap::Ready
static bool Ready()
Check if map is ready
Definition prediction_map.cc:38
AERROR
#define AERROR
Definition log.h:44

◆ InitContainers()

bool apollo::prediction::MessageProcess::InitContainers ( ContainerManager *  container_manager)
static

在文件 message_process.cc 第 70 行定义.

70 {
71 common::adapter::AdapterManagerConfig adapter_conf;
72 if (!cyber::common::GetProtoFromFile(FLAGS_prediction_adapter_config_filename,
73 &adapter_conf)) {
74 AERROR << "Unable to load adapter conf file: "
75 << FLAGS_prediction_adapter_config_filename;
76 return false;
77 }
78 ADEBUG << "Adapter config file is loaded into: "
79 << adapter_conf.ShortDebugString();
80
81 container_manager->Init(adapter_conf);
82 return true;
83}
apollo::cyber::common::GetProtoFromFile
bool GetProtoFromFile(const std::string &file_name, google::protobuf::Message *message)
Parses the content of the file specified by the file_name as a representation of protobufs,...
Definition file.cc:132

◆ InitEvaluators()

bool apollo::prediction::MessageProcess::InitEvaluators ( EvaluatorManager *  evaluator_manager,
const PredictionConf &  prediction_conf 
)
static

在文件 message_process.cc 第 85 行定义.

86 {
87 evaluator_manager->Init(prediction_conf);
88 return true;
89}

◆ InitPredictors()

bool apollo::prediction::MessageProcess::InitPredictors ( PredictorManager *  predictor_manager,
const PredictionConf &  prediction_conf 
)
static

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

92 {
93 predictor_manager->Init(prediction_conf);
94 return true;
95}

◆ OnLocalization()

void apollo::prediction::MessageProcess::OnLocalization ( ContainerManager *  container_manager,
const localization::LocalizationEstimate &  localization 
)
static

在文件 message_process.cc 第 259 行定义.

261 {
262 auto ptr_ego_pose_container = container_manager->GetContainer<PoseContainer>(
263 AdapterConfig::LOCALIZATION);
264 ACHECK(ptr_ego_pose_container != nullptr);
265 ptr_ego_pose_container->Insert(localization);
266
267 ADEBUG << "Received a localization message ["
268 << localization.ShortDebugString() << "].";
269}
ACHECK
#define ACHECK(cond)
Definition log.h:80

◆ OnPerception()

void apollo::prediction::MessageProcess::OnPerception ( const perception::PerceptionObstacles &  perception_obstacles,
const std::shared_ptr< ContainerManager > &  container_manager,
EvaluatorManager *  evaluator_manager,
PredictorManager *  predictor_manager,
ScenarioManager *  scenario_manager,
PredictionObstacles *const  prediction_obstacles 
)
static

在文件 message_process.cc 第 186 行定义.

191 {
192 ContainerProcess(container_manager, perception_obstacles, scenario_manager);
193
194 auto ptr_obstacles_container =
195 container_manager->GetContainer<ObstaclesContainer>(
196 AdapterConfig::PERCEPTION_OBSTACLES);
197 CHECK_NOTNULL(ptr_obstacles_container);
198
199 auto ptr_ego_trajectory_container =
200 container_manager->GetContainer<ADCTrajectoryContainer>(
201 AdapterConfig::PLANNING_TRAJECTORY);
202 CHECK_NOTNULL(ptr_ego_trajectory_container);
203
204 // Insert features to FeatureOutput for offline_mode
205 if (FLAGS_prediction_offline_mode == PredictionConstants::kDumpFeatureProto) {
206 for (const int id :
207 ptr_obstacles_container->curr_frame_movable_obstacle_ids()) {
208 Obstacle* obstacle_ptr = ptr_obstacles_container->GetObstacle(id);
209 if (obstacle_ptr == nullptr) {
210 AERROR << "Null obstacle found.";
211 continue;
212 }
213 if (!obstacle_ptr->latest_feature().IsInitialized()) {
214 AERROR << "Obstacle [" << id << "] has no latest feature.";
215 continue;
216 }
217 // TODO(all): the adc trajectory should be part of features for learning
218 // algorithms rather than part of the feature.proto
219 *obstacle_ptr->mutable_latest_feature()->mutable_adc_trajectory_point() =
220 ptr_ego_trajectory_container->adc_trajectory().trajectory_point();
221
222 // adc trajectory timestamp
223 obstacle_ptr->mutable_latest_feature()->set_adc_timestamp(
224 ptr_ego_trajectory_container->adc_trajectory()
225 .header().timestamp_sec());
226
227 // ego pose_container
228 auto ptr_ego_pose = container_manager->GetContainer<PoseContainer>(
229 AdapterConfig::LOCALIZATION);
230 CHECK_NOTNULL(ptr_ego_pose);
231
232 // adc localization
233 obstacle_ptr->mutable_latest_feature()->mutable_adc_localization()->
234 CopyFrom(*ptr_ego_pose->ToPerceptionObstacle());
235
236 FeatureOutput::InsertFeatureProto(obstacle_ptr->latest_feature());
237 ADEBUG << "Insert feature into feature output";
238 }
239 // Not doing evaluation on offline mode
240 return;
241 }
242
243 // Make evaluations
244 evaluator_manager->Run(ptr_ego_trajectory_container,
245 ptr_obstacles_container);
246 if (FLAGS_prediction_offline_mode ==
247 PredictionConstants::kDumpDataForLearning ||
248 FLAGS_prediction_offline_mode == PredictionConstants::kDumpFrameEnv) {
249 return;
250 }
251 // Make predictions
252 predictor_manager->Run(perception_obstacles, ptr_ego_trajectory_container,
253 ptr_obstacles_container);
254
255 // Get predicted obstacles
256 *prediction_obstacles = predictor_manager->prediction_obstacles();
257}
apollo::prediction::FeatureOutput::InsertFeatureProto
static void InsertFeatureProto(const Feature &feature)
Insert a feature
Definition feature_output.cc:91
apollo::prediction::MessageProcess::ContainerProcess
static void ContainerProcess(const std::shared_ptr< ContainerManager > &container_manager, const perception::PerceptionObstacles &perception_obstacles, ScenarioManager *scenario_manger)
Definition message_process.cc:97

◆ OnPlanning()

void apollo::prediction::MessageProcess::OnPlanning ( ContainerManager *  container_manager,
const planning::ADCTrajectory &  adc_trajectory 
)
static

在文件 message_process.cc 第 271 行定义.

272 {
273 auto ptr_ego_trajectory_container =
274 container_manager->GetContainer<ADCTrajectoryContainer>(
275 AdapterConfig::PLANNING_TRAJECTORY);
276 ACHECK(ptr_ego_trajectory_container != nullptr);
277 ptr_ego_trajectory_container->Insert(adc_trajectory);
278
279 ADEBUG << "Received a planning message [" << adc_trajectory.ShortDebugString()
280 << "].";
281
282 auto ptr_storytelling_container =
283 container_manager->GetContainer<StoryTellingContainer>(
284 AdapterConfig::STORYTELLING);
285 CHECK_NOTNULL(ptr_storytelling_container);
286 ptr_ego_trajectory_container->SetJunction(
287 ptr_storytelling_container->ADCJunctionId(),
288 ptr_storytelling_container->ADCDistanceToJunction());
289}

◆ OnStoryTelling()

void apollo::prediction::MessageProcess::OnStoryTelling ( ContainerManager *  container_manager,
const storytelling::Stories &  story 
)
static

在文件 message_process.cc 第 291 行定义.

292 {
293 auto ptr_storytelling_container =
294 container_manager->GetContainer<StoryTellingContainer>(
295 AdapterConfig::STORYTELLING);
296 CHECK_NOTNULL(ptr_storytelling_container);
297 ptr_storytelling_container->Insert(story);
298
299 ADEBUG << "Received a storytelling message [" << story.ShortDebugString()
300 << "].";
301}

◆ ProcessOfflineData()

void apollo::prediction::MessageProcess::ProcessOfflineData ( const PredictionConf &  prediction_conf,
const std::shared_ptr< ContainerManager > &  container_manager,
EvaluatorManager *  evaluator_manager,
PredictorManager *  predictor_manager,
ScenarioManager *  scenario_manager,
const std::string &  record_filepath 
)
static

在文件 message_process.cc 第 303 行定义.

307 {
308 RecordReader reader(record_filepath);
309 RecordMessage message;
310 RecordWriter writer;
311 if (FLAGS_prediction_offline_mode == PredictionConstants::kDumpRecord) {
312 writer.Open(record_filepath + ".new_prediction");
313 }
314 while (reader.ReadMessage(&message)) {
315 if (message.channel_name ==
316 prediction_conf.topic_conf().perception_obstacle_topic()) {
317 PerceptionObstacles perception_obstacles;
318 if (perception_obstacles.ParseFromString(message.content)) {
319 if (FLAGS_prediction_offline_mode == PredictionConstants::kDumpRecord) {
320 writer.WriteMessage<PerceptionObstacles>(
321 message.channel_name, perception_obstacles, message.time);
322 }
323 PredictionObstacles prediction_obstacles;
324 OnPerception(perception_obstacles, container_manager, evaluator_manager,
325 predictor_manager, scenario_manager,
326 &prediction_obstacles);
327 if (FLAGS_prediction_offline_mode == PredictionConstants::kDumpRecord) {
328 writer.WriteMessage<PredictionObstacles>(
329 prediction_conf.topic_conf().perception_obstacle_topic(),
330 prediction_obstacles, message.time);
331 AINFO << "Generated a new prediction message.";
332 }
333 }
334 } else if (message.channel_name ==
335 prediction_conf.topic_conf().localization_topic()) {
336 LocalizationEstimate localization;
337 if (localization.ParseFromString(message.content)) {
338 if (FLAGS_prediction_offline_mode == PredictionConstants::kDumpRecord) {
339 writer.WriteMessage<LocalizationEstimate>(message.channel_name,
340 localization, message.time);
341 }
342 OnLocalization(container_manager.get(), localization);
343 }
344 } else if (message.channel_name ==
345 prediction_conf.topic_conf().planning_trajectory_topic()) {
346 ADCTrajectory adc_trajectory;
347 if (adc_trajectory.ParseFromString(message.content)) {
348 OnPlanning(container_manager.get(), adc_trajectory);
349 }
350 }
351 }
352 if (FLAGS_prediction_offline_mode == PredictionConstants::kDumpRecord) {
353 writer.Close();
354 }
355}
apollo::prediction::MessageProcess::OnPerception
static void OnPerception(const perception::PerceptionObstacles &perception_obstacles, const std::shared_ptr< ContainerManager > &container_manager, EvaluatorManager *evaluator_manager, PredictorManager *predictor_manager, ScenarioManager *scenario_manager, PredictionObstacles *const prediction_obstacles)
Definition message_process.cc:186
apollo::prediction::MessageProcess::OnLocalization
static void OnLocalization(ContainerManager *container_manager, const localization::LocalizationEstimate &localization)
Definition message_process.cc:259
apollo::prediction::MessageProcess::OnPlanning
static void OnPlanning(ContainerManager *container_manager, const planning::ADCTrajectory &adc_trajectory)
Definition message_process.cc:271
AINFO
#define AINFO
Definition log.h:42
该类的文档由以下文件生成: