apollo::prediction::ObstaclesPrioritizer类 参考

#include <obstacles_prioritizer.h>

apollo::prediction::ObstaclesPrioritizer 的协作图:

Public 成员函数
	ObstaclesPrioritizer ()=delete
	ObstaclesPrioritizer (const std::shared_ptr< ContainerManager > &container_manager)
void	AssignIgnoreLevel ()
void	AssignCautionLevel ()

详细描述

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

构造及析构函数说明

ObstaclesPrioritizer() [1/2]

apollo::prediction::ObstaclesPrioritizer::ObstaclesPrioritizer ( )

delete

ObstaclesPrioritizer() [2/2]

apollo::prediction::ObstaclesPrioritizer::ObstaclesPrioritizer ( const std::shared_ptr< ContainerManager > &  container_manager )

explicit

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

    : container_manager_(container_manager) {}

成员函数说明

AssignCautionLevel()

void apollo::prediction::ObstaclesPrioritizer::AssignCautionLevel

(

)

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

                                              {
  auto obstacles_container =
      container_manager_->GetContainer<ObstaclesContainer>(
          AdapterConfig::PERCEPTION_OBSTACLES);
  if (obstacles_container == nullptr) {
    AERROR << "Obstacles container pointer is a null pointer.";
    return;
  }
  Obstacle* ego_vehicle =
      obstacles_container->GetObstacle(FLAGS_ego_vehicle_id);
  if (ego_vehicle == nullptr) {
    AERROR << "Ego vehicle not found";
    return;
  }
  if (ego_vehicle->history_size() == 0) {
    AERROR << "Ego vehicle has no history";
    return;
  }
  auto storytelling_container =
      container_manager_->GetContainer<StoryTellingContainer>(
          AdapterConfig::STORYTELLING);
  if (storytelling_container->ADCDistanceToJunction() <
      FLAGS_junction_distance_threshold) {
    AssignCautionLevelInJunction(*ego_vehicle, obstacles_container,
                                 storytelling_container->ADCJunctionId());
  }
  AssignCautionLevelCruiseKeepLane(*ego_vehicle, obstacles_container);
  AssignCautionLevelCruiseChangeLane(*ego_vehicle, obstacles_container);
  AssignCautionLevelByEgoReferenceLine(*ego_vehicle, obstacles_container);
  AssignCautionLevelPedestrianByEgoReferenceLine(*ego_vehicle,
                                                 obstacles_container);
  if (FLAGS_enable_all_pedestrian_caution_in_front) {
    AssignCautionLevelPedestrianInFront(*ego_vehicle, obstacles_container);
  }
  if (FLAGS_enable_rank_caution_obstacles) {
    RankingCautionLevelObstacles(*ego_vehicle, obstacles_container);
  }
}

AssignIgnoreLevel()

void apollo::prediction::ObstaclesPrioritizer::AssignIgnoreLevel

(

)

在文件 obstacles_prioritizer.cc 第 95 行定义.

                                             {
  auto obstacles_container =
      container_manager_->GetContainer<ObstaclesContainer>(
          AdapterConfig::PERCEPTION_OBSTACLES);
  if (obstacles_container == nullptr) {
    AERROR << "Obstacles container pointer is a null pointer.";
    return;
  }
 
  Obstacle* ego_obstacle_ptr =
      obstacles_container->GetObstacle(FLAGS_ego_vehicle_id);
  if (ego_obstacle_ptr == nullptr) {
    AERROR << "Ego obstacle nullptr found";
    return;
  }
 
  const Feature& ego_feature = ego_obstacle_ptr->latest_feature();
  double ego_theta = ego_feature.theta();
  double ego_x = ego_feature.position().x();
  double ego_y = ego_feature.position().y();
  ADEBUG << "Get pose (" << ego_x << ", " << ego_y << ", " << ego_theta << ")";
 
  // Build rectangular scan_area
  Box2d scan_box({ego_x + FLAGS_scan_length / 2.0 * std::cos(ego_theta),
                  ego_y + FLAGS_scan_length / 2.0 * std::sin(ego_theta)},
                 ego_theta, FLAGS_scan_length, FLAGS_scan_width);
 
  const auto& obstacle_ids =
      obstacles_container->curr_frame_movable_obstacle_ids();
  for (const int obstacle_id : obstacle_ids) {
    Obstacle* obstacle_ptr = obstacles_container->GetObstacle(obstacle_id);
    if (obstacle_ptr == nullptr) {
      AERROR << "Null obstacle pointer found.";
      continue;
    }
    if (obstacle_ptr->history_size() == 0) {
      AERROR << "Obstacle [" << obstacle_ptr->id() << "] has no feature.";
      continue;
    }
    Feature* latest_feature_ptr = obstacle_ptr->mutable_latest_feature();
    double obstacle_x = latest_feature_ptr->position().x();
    double obstacle_y = latest_feature_ptr->position().y();
    Vec2d ego_to_obstacle_vec(obstacle_x - ego_x, obstacle_y - ego_y);
    Vec2d ego_vec = Vec2d::CreateUnitVec2d(ego_theta);
    double s = ego_to_obstacle_vec.InnerProd(ego_vec);
 
    double pedestrian_like_nearby_lane_radius =
        FLAGS_pedestrian_nearby_lane_search_radius;
    bool is_near_lane = PredictionMap::HasNearbyLane(
        obstacle_x, obstacle_y, pedestrian_like_nearby_lane_radius);
 
    // Decide if we need consider this obstacle
    bool is_in_scan_area = scan_box.IsPointIn({obstacle_x, obstacle_y});
    bool is_on_lane = obstacle_ptr->IsOnLane();
    bool is_pedestrian_like_in_front_near_lanes =
        s > FLAGS_back_dist_ignore_ped &&
        (latest_feature_ptr->type() == PerceptionObstacle::PEDESTRIAN ||
         latest_feature_ptr->type() == PerceptionObstacle::BICYCLE ||
         latest_feature_ptr->type() == PerceptionObstacle::UNKNOWN ||
         latest_feature_ptr->type() == PerceptionObstacle::UNKNOWN_MOVABLE) &&
        is_near_lane;
    bool is_near_junction = obstacle_ptr->IsNearJunction();
 
    bool need_consider = is_in_scan_area || is_on_lane || is_near_junction ||
                         is_pedestrian_like_in_front_near_lanes;
 
    if (!need_consider) {
      latest_feature_ptr->mutable_priority()->set_priority(
          ObstaclePriority::IGNORE);
    } else {
      latest_feature_ptr->mutable_priority()->set_priority(
          ObstaclePriority::NORMAL);
    }
  }
  obstacles_container->SetConsideredObstacleIds();
}

---

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

• modules/prediction/scenario/prioritization/obstacles_prioritizer.h
• modules/prediction/scenario/prioritization/obstacles_prioritizer.cc