apollo::prediction::EvaluatorManager类 参考

#include <evaluator_manager.h>

apollo::prediction::EvaluatorManager 的协作图:

Public 成员函数
	EvaluatorManager ()
	Constructor
virtual	~EvaluatorManager ()=default
	Destructor
void	Init (const PredictionConf &config)
	Initializer
Evaluator *	GetEvaluator (const ObstacleConf::EvaluatorType &type)
	Get evaluator
void	Run (const ADCTrajectoryContainer *adc_trajectory_container, ObstaclesContainer *obstacles_container)
	Run evaluators
void	EvaluateObstacle (const ADCTrajectoryContainer *adc_trajectory_container, Obstacle *obstacle, ObstaclesContainer *obstacles_container, std::vector< Obstacle * > dynamic_env)
void	EvaluateObstacle (Obstacle *obstacle, ObstaclesContainer *obstacles_container)
void	EvaluateMultiObstacle (const ADCTrajectoryContainer *adc_trajectory_container, ObstaclesContainer *obstacles_container)

详细描述

在文件 evaluator_manager.h 第 43 行定义.

构造及析构函数说明

EvaluatorManager()

apollo::prediction::EvaluatorManager::EvaluatorManager

(

)

Constructor

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

{}

~EvaluatorManager()

virtual apollo::prediction::EvaluatorManager::~EvaluatorManager ( )

virtualdefault

Destructor

成员函数说明

EvaluateMultiObstacle()

void apollo::prediction::EvaluatorManager::EvaluateMultiObstacle	(	const ADCTrajectoryContainer *	adc_trajectory_container,
		ObstaclesContainer *	obstacles_container
	)

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

                                             {
  Evaluator* evaluator = nullptr;
  evaluator = GetEvaluator(multi_agent_evaluator_);
  CHECK_NOTNULL(evaluator);
  std::vector<int> obs_ids = obstacles_container->curr_frame_considered_obstacle_ids();
 
  // 1. Evaluate the pedestrain
  if (FLAGS_enable_multi_agent_pedestrian_evaluator) {
    for (int id : obs_ids) {
      Obstacle* obstacle = obstacles_container->GetObstacle(id);
      // whether the pedestrian exsit in the conside obstacle list
      if (obstacle->type() == perception::PerceptionObstacle::PEDESTRIAN &&
          !obstacle->IsStill()) {
        evaluator->Evaluate(adc_trajectory_container, 
          obstacle, obstacles_container);
        AINFO << "Succeed to run multi agent pedestrian evaluator!";
        break;
      }
    }
  }
 
  // 2. Evaluate the vechicle
  if (FLAGS_enable_multi_agent_vehicle_evaluator) {
    for (int id : obs_ids) {
      Obstacle* obstacle = obstacles_container->GetObstacle(id);
      // whether the vehicle exsit in the conside obstacle list
      if (obstacle->type() == perception::PerceptionObstacle::VEHICLE &&
          !obstacle->IsStill()) {
        evaluator->Evaluate(adc_trajectory_container, 
          obstacle, obstacles_container);
        AINFO << "Succeed to run multi agent vehicle evaluator!";
        break;
      }
    }
  }
}

EvaluateObstacle() [1/2]

void apollo::prediction::EvaluatorManager::EvaluateObstacle	(	const ADCTrajectoryContainer *	adc_trajectory_container,
		Obstacle *	obstacle,
		ObstaclesContainer *	obstacles_container,
		std::vector< Obstacle * >	dynamic_env
	)

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

                                      {
  Evaluator* evaluator = nullptr;
  // Select different evaluators depending on the obstacle's type.
  switch (obstacle->type()) {
    case PerceptionObstacle::VEHICLE: {
      if (FLAGS_enable_multi_agent_vehicle_evaluator) {
        AINFO << "The vehicles are evaluated by multi agent evaluator!";
        break;
      }
      if (obstacle->IsCaution() && !obstacle->IsSlow()) {
        if (obstacle->IsInteractiveObstacle()) {
          evaluator = GetEvaluator(interaction_evaluator_);
        } else if (obstacle->IsNearJunction()) {
          evaluator = GetEvaluator(vehicle_in_junction_caution_evaluator_);
        } else if (obstacle->IsOnLane()) {
          evaluator = GetEvaluator(vehicle_on_lane_caution_evaluator_);
        } else {
          evaluator = GetEvaluator(vehicle_default_caution_evaluator_);
        }
        CHECK_NOTNULL(evaluator);
        AINFO << "Caution Obstacle: " << obstacle->id() << " used " << evaluator->GetName();
        // Evaluate and break if success
        if (evaluator->GetName() == "JOINTLY_PREDICTION_PLANNING_EVALUATOR") {
          if (evaluator->Evaluate(adc_trajectory_container,
                                  obstacle, obstacles_container)) {
            break;
          } else {
            AERROR << "Obstacle: " << obstacle->id()
                  << " interaction evaluator failed,"
                  << " downgrade to normal level!";
          }
        } else {
          if (evaluator->Evaluate(obstacle, obstacles_container)) {
            break;
          } else {
            AERROR << "Obstacle: " << obstacle->id()
                  << " caution evaluator failed, downgrade to normal level!";
          }
        }
      }
 
      // if obstacle is not caution or caution_evaluator run failed
      if (obstacle->HasJunctionFeatureWithExits() &&
          !obstacle->IsCloseToJunctionExit()) {
        evaluator = GetEvaluator(vehicle_in_junction_evaluator_);
      } else if (obstacle->IsOnLane()) {
        evaluator = GetEvaluator(vehicle_on_lane_evaluator_);
      } else {
        AINFO << "Obstacle: " << obstacle->id()
               << " is neither on lane, nor in junction. Skip evaluating.";
        break;
      }
      AINFO << "Normal Obstacle: " << obstacle->id() << " used " << evaluator->GetName();
      CHECK_NOTNULL(evaluator);
      if (evaluator->GetName() == "LANE_SCANNING_EVALUATOR") {
        evaluator->Evaluate(obstacle, obstacles_container, dynamic_env);
      } else {
        evaluator->Evaluate(obstacle, obstacles_container);
      }
      break;
    }
    case PerceptionObstacle::BICYCLE: {
      if (obstacle->IsOnLane()) {
        evaluator = GetEvaluator(cyclist_on_lane_evaluator_);
        CHECK_NOTNULL(evaluator);
        evaluator->Evaluate(obstacle, obstacles_container);
      }
      break;
    }
    case PerceptionObstacle::PEDESTRIAN: {
      if (FLAGS_prediction_offline_mode ==
              PredictionConstants::kDumpDataForLearning ||
              (!FLAGS_enable_multi_agent_pedestrian_evaluator &&
              obstacle->latest_feature().priority().priority() ==
              ObstaclePriority::CAUTION)) {
        evaluator = GetEvaluator(pedestrian_evaluator_);
        CHECK_NOTNULL(evaluator);
        auto start_time_inference = std::chrono::system_clock::now();
        evaluator->Evaluate(obstacle, obstacles_container);
        auto end_time_inference = std::chrono::system_clock::now();
        std::chrono::duration<double> time_cost_lstm =
            end_time_inference - start_time_inference;
        AINFO << "semantic lstm evaluator used time: "
               << time_cost_lstm.count() * 1000 << " ms.";
        break;
      }
    }
    default: {
      if (obstacle->IsOnLane()) {
        evaluator = GetEvaluator(default_on_lane_evaluator_);
        CHECK_NOTNULL(evaluator);
        evaluator->Evaluate(obstacle, obstacles_container);
      }
      break;
    }
  }
}

EvaluateObstacle() [2/2]

void apollo::prediction::EvaluatorManager::EvaluateObstacle	(	Obstacle *	obstacle,
		ObstaclesContainer *	obstacles_container
	)

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

                                                                 {
  std::vector<Obstacle*> dummy_dynamic_env;
  ADCTrajectoryContainer* adc_trajectory_container = nullptr;
  EvaluateObstacle(adc_trajectory_container, obstacle,
                   obstacles_container, dummy_dynamic_env);
}

GetEvaluator()

Evaluator * apollo::prediction::EvaluatorManager::GetEvaluator

(

const ObstacleConf::EvaluatorType &

type

)

Get evaluator

返回

Pointer to the evaluator

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

                                           {
  auto it = evaluators_.find(type);
  return it != evaluators_.end() ? it->second.get() : nullptr;
}

Init()

void apollo::prediction::EvaluatorManager::Init

(

const PredictionConf &

config

)

Initializer

参数

Prediction

config

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

                                                        {
  if (FLAGS_enable_semantic_map) {
    semantic_map_.reset(new SemanticMap());
    semantic_map_->Init();
    AINFO << "Init SemanticMap instance.";
  } else {
    AINFO << "SemanticMap is not enabled.";
  }
 
  RegisterEvaluators();
 
  for (const auto& obstacle_conf : config.obstacle_conf()) {
    if (!obstacle_conf.has_obstacle_type()) {
      AERROR << "Obstacle config [" << obstacle_conf.ShortDebugString()
             << "] has not defined obstacle type.";
      continue;
    }
 
    if (!obstacle_conf.has_evaluator_type()) {
      ADEBUG << "Obstacle config [" << obstacle_conf.ShortDebugString()
             << "] has not defined evaluator type.";
      continue;
    }
 
    if (obstacle_conf.has_obstacle_status()) {
      switch (obstacle_conf.obstacle_type()) {
        case PerceptionObstacle::VEHICLE: {
          if (obstacle_conf.obstacle_status() == ObstacleConf::ON_LANE) {
            if (obstacle_conf.priority_type() == ObstaclePriority::CAUTION) {
              vehicle_on_lane_caution_evaluator_ =
                  obstacle_conf.evaluator_type();
            } else {
              vehicle_on_lane_evaluator_ = obstacle_conf.evaluator_type();
            }
          }
          if (obstacle_conf.obstacle_status() == ObstacleConf::IN_JUNCTION) {
            if (obstacle_conf.priority_type() == ObstaclePriority::CAUTION) {
              vehicle_in_junction_caution_evaluator_ =
                  obstacle_conf.evaluator_type();
            } else {
              vehicle_in_junction_evaluator_ = obstacle_conf.evaluator_type();
            }
          }
          break;
        }
        case PerceptionObstacle::BICYCLE: {
          if (obstacle_conf.obstacle_status() == ObstacleConf::ON_LANE) {
            cyclist_on_lane_evaluator_ = obstacle_conf.evaluator_type();
          }
          break;
        }
        case PerceptionObstacle::PEDESTRIAN: {
          if (FLAGS_prediction_offline_mode ==
                  PredictionConstants::kDumpDataForLearning ||
              obstacle_conf.priority_type() == ObstaclePriority::CAUTION) {
            pedestrian_evaluator_ = obstacle_conf.evaluator_type();
            break;
          }
        }
        case PerceptionObstacle::UNKNOWN: {
          if (obstacle_conf.obstacle_status() == ObstacleConf::ON_LANE) {
            default_on_lane_evaluator_ = obstacle_conf.evaluator_type();
          }
          break;
        }
        default: {
          break;
        }
      }
    } else if (obstacle_conf.has_interactive_tag()) {
      interaction_evaluator_ = obstacle_conf.evaluator_type();
    }
  }
 
  AINFO << "Defined vehicle on lane obstacle evaluator ["
        << vehicle_on_lane_evaluator_ << "]";
  AINFO << "Defined cyclist on lane obstacle evaluator ["
        << cyclist_on_lane_evaluator_ << "]";
  AINFO << "Defined default on lane obstacle evaluator ["
        << default_on_lane_evaluator_ << "]";
}

Run()

void apollo::prediction::EvaluatorManager::Run	(	const ADCTrajectoryContainer *	adc_trajectory_container,
		ObstaclesContainer *	obstacles_container
	)

Run evaluators

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

                                             {
  if (FLAGS_enable_semantic_map ||
      FLAGS_prediction_offline_mode == PredictionConstants::kDumpFrameEnv) {
    size_t max_num_frame = 10;
    if (FLAGS_prediction_offline_mode == PredictionConstants::kDumpFrameEnv) {
      max_num_frame = 20;
    }
    BuildObstacleIdHistoryMap(obstacles_container, max_num_frame);
    DumpCurrentFrameEnv(obstacles_container);
    if (FLAGS_prediction_offline_mode == PredictionConstants::kDumpFrameEnv) {
      return;
    }
    semantic_map_->RunCurrFrame(obstacle_id_history_map_);
  }
 
  std::vector<Obstacle*> dynamic_env;
 
  if (FLAGS_enable_multi_agent_pedestrian_evaluator || 
    FLAGS_enable_multi_agent_vehicle_evaluator) {
    auto start_time_multi = std::chrono::system_clock::now();
    EvaluateMultiObstacle(adc_trajectory_container, obstacles_container);
    auto end_time_multi = std::chrono::system_clock::now();
    std::chrono::duration<double> time_cost_multi =
        end_time_multi - start_time_multi;
    AINFO << "multi agents evaluator used time: "
          << time_cost_multi.count() * 1000 << " ms.";
  }
 
  if (FLAGS_enable_multi_thread) {
    IdObstacleListMap id_obstacle_map;
    GroupObstaclesByObstacleIds(obstacles_container, &id_obstacle_map);
    PredictionThreadPool::ForEach(
        id_obstacle_map.begin(), id_obstacle_map.end(),
        [&](IdObstacleListMap::iterator::value_type& obstacles_iter) {
          for (auto obstacle_ptr : obstacles_iter.second) {
            EvaluateObstacle(adc_trajectory_container, obstacle_ptr,
                            obstacles_container, dynamic_env);
          }
        });
  } else {
    for (int id : obstacles_container->curr_frame_considered_obstacle_ids()) {
      Obstacle* obstacle = obstacles_container->GetObstacle(id);
 
      if (obstacle == nullptr) {
        continue;
      }
      if (obstacle->IsStill()) {
        ADEBUG << "Ignore still obstacle [" << id << "] in evaluator_manager";
        continue;
      }
 
      EvaluateObstacle(adc_trajectory_container, obstacle,
                      obstacles_container, dynamic_env);
    }
  }
}

---

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

• modules/prediction/evaluator/evaluator_manager.h
• modules/prediction/evaluator/evaluator_manager.cc