prediction_map.h

浏览该文件的文档.

/******************************************************************************
 * Copyright 2017 The Apollo Authors. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *****************************************************************************/
 
#pragma once
 
#include <memory>
#include <string>
#include <vector>
 
#include "modules/map/pnc_map/path.h"
 
namespace apollo {
namespace prediction {
 
class PredictionMap {
 public:
  static bool Ready();
 
  static Eigen::Vector2d PositionOnLane(
      const std::shared_ptr<const hdmap::LaneInfo> lane_info, const double s);
 
  static double HeadingOnLane(
      const std::shared_ptr<const hdmap::LaneInfo> lane_info, const double s);
 
  static double CurvatureOnLane(const std::string& lane_id, const double s);
 
  static double LaneTotalWidth(
      const std::shared_ptr<const hdmap::LaneInfo> lane_info, const double s);
 
  static std::shared_ptr<const hdmap::LaneInfo> LaneById(const std::string& id);
 
  static std::shared_ptr<const hdmap::JunctionInfo> JunctionById(
      const std::string& id);
 
  static std::shared_ptr<const hdmap::OverlapInfo> OverlapById(
      const std::string& id);
 
  static bool GetProjection(
      const Eigen::Vector2d& position,
      const std::shared_ptr<const hdmap::LaneInfo> lane_info, double* s,
      double* l);
 
  static bool HasNearbyLane(const double x, const double y,
                            const double radius);
 
  static bool ProjectionFromLane(
      std::shared_ptr<const hdmap::LaneInfo> lane_info, const double s,
      hdmap::MapPathPoint* path_point);
 
  static bool IsVirtualLane(const std::string& lane_id);
 
  static bool OnVirtualLane(const Eigen::Vector2d& position,
                            const double radius);
 
  static void OnLane(
      const std::vector<std::shared_ptr<const hdmap::LaneInfo>>& prev_lanes,
      const Eigen::Vector2d& point, const double heading, const double radius,
      const bool on_lane, const int max_num_lane,
      const double max_lane_angle_diff,
      std::vector<std::shared_ptr<const hdmap::LaneInfo>>* lanes);
 
  static std::shared_ptr<const apollo::hdmap::LaneInfo>
  GetMostLikelyCurrentLane(const common::PointENU& position,
                           const double radius, const double heading,
                           const double angle_diff_threshold);
 
  static bool IsProjectionApproximateWithinLane(
      const Eigen::Vector2d& ego_position, const std::string& lane_id);
 
  static bool NearJunction(const Eigen::Vector2d& point, const double radius);
 
  static bool IsPointInJunction(
      const double x, const double y,
      const std::shared_ptr<const hdmap::JunctionInfo> junction_info_ptr);
 
  static bool InJunction(const Eigen::Vector2d& point, const double radius);
 
  static bool IsLaneInJunction(
      const std::shared_ptr<const hdmap::LaneInfo> lane_info,
      const std::string& junction_id);
 
  static std::vector<std::shared_ptr<const apollo::hdmap::JunctionInfo>>
  GetJunctions(const Eigen::Vector2d& point, const double radius);
 
  static std::vector<std::shared_ptr<const apollo::hdmap::PNCJunctionInfo>>
  GetPNCJunctions(const Eigen::Vector2d& point, const double radius);
 
  static double PathHeading(std::shared_ptr<const hdmap::LaneInfo> lane_info,
                            const common::PointENU& point);
 
  static bool SmoothPointFromLane(const std::string& id, const double s,
                                  const double l, Eigen::Vector2d* point,
                                  double* heading);
 
  static void NearbyLanesByCurrentLanes(
      const Eigen::Vector2d& point, const double heading, const double radius,
      const std::vector<std::shared_ptr<const hdmap::LaneInfo>>& lanes,
      const int max_num_lane,
      std::vector<std::shared_ptr<const hdmap::LaneInfo>>* nearby_lanes);
 
  static std::shared_ptr<const hdmap::LaneInfo> GetLeftNeighborLane(
      const std::shared_ptr<const hdmap::LaneInfo>& ptr_ego_lane,
      const Eigen::Vector2d& ego_position, const double threshold);
 
  static std::shared_ptr<const hdmap::LaneInfo> GetRightNeighborLane(
      const std::shared_ptr<const hdmap::LaneInfo>& ptr_ego_lane,
      const Eigen::Vector2d& ego_position, const double threshold);
 
  static std::vector<std::string> NearbyLaneIds(const Eigen::Vector2d& point,
                                                const double radius);
 
  static bool IsLeftNeighborLane(
      std::shared_ptr<const hdmap::LaneInfo> target_lane,
      std::shared_ptr<const hdmap::LaneInfo> curr_lane);
 
  static bool IsLeftNeighborLane(
      std::shared_ptr<const hdmap::LaneInfo> target_lane,
      const std::vector<std::shared_ptr<const hdmap::LaneInfo>>& lanes);
 
  static bool IsRightNeighborLane(
      std::shared_ptr<const hdmap::LaneInfo> target_lane,
      std::shared_ptr<const hdmap::LaneInfo> curr_lane);
 
  static bool IsRightNeighborLane(
      std::shared_ptr<const hdmap::LaneInfo> target_lane,
      const std::vector<std::shared_ptr<const hdmap::LaneInfo>>& lanes);
 
  static bool IsSuccessorLane(
      std::shared_ptr<const hdmap::LaneInfo> target_lane,
      std::shared_ptr<const hdmap::LaneInfo> curr_lane);
 
  static bool IsSuccessorLane(
      std::shared_ptr<const hdmap::LaneInfo> target_lane,
      const std::vector<std::shared_ptr<const hdmap::LaneInfo>>& lanes);
 
  static bool IsPredecessorLane(
      std::shared_ptr<const hdmap::LaneInfo> target_lane,
      std::shared_ptr<const hdmap::LaneInfo> curr_lane);
 
  static bool IsPredecessorLane(
      std::shared_ptr<const hdmap::LaneInfo> target_lane,
      const std::vector<std::shared_ptr<const hdmap::LaneInfo>>& lanes);
 
  static bool IsIdenticalLane(std::shared_ptr<const hdmap::LaneInfo> other_lane,
                              std::shared_ptr<const hdmap::LaneInfo> curr_lane);
 
  static bool IsIdenticalLane(
      std::shared_ptr<const hdmap::LaneInfo> other_lane,
      const std::vector<std::shared_ptr<const hdmap::LaneInfo>>& lanes);
 
  static int LaneTurnType(const std::string& lane_id);
 
  static std::vector<std::shared_ptr<const hdmap::LaneInfo>> GetNearbyLanes(
      const common::PointENU& position, const double nearby_radius);
 
  static std::shared_ptr<const hdmap::LaneInfo>
  LaneWithSmallestAverageCurvature(
      const std::vector<std::shared_ptr<const hdmap::LaneInfo>>& lane_infos);
 
  static double AverageCurvature(const std::string& lane_id,
                                 const size_t sample_size);
 
 private:
  static std::shared_ptr<const hdmap::LaneInfo> GetNeighborLane(
      const std::shared_ptr<const hdmap::LaneInfo>& ptr_ego_lane,
      const Eigen::Vector2d& ego_position,
      const std::vector<std::string>& neighbor_lane_ids,
      const double threshold);
 
  PredictionMap() = delete;
};
 
}  // namespace prediction
}  // namespace apollo