apollo::prediction::ObstacleClusters类 参考

#include <obstacle_clusters.h>

apollo::prediction::ObstacleClusters 的协作图:

Public 成员函数
	ObstacleClusters ()=default
	Constructor
void	Init ()
	Remove all lane graphs
LaneGraph	GetLaneGraph (const double start_s, const double length, const bool consider_lane_split, std::shared_ptr< const apollo::hdmap::LaneInfo > lane_info_ptr)
	Obtain a lane graph given a lane info and s
LaneGraph	GetLaneGraphWithoutMemorizing (const double start_s, const double length, const bool is_on_lane, std::shared_ptr< const apollo::hdmap::LaneInfo > lane_info_ptr)
	Obtain a lane graph given a lane info and s, but don't memorize it.
bool	ForwardNearbyObstacle (const LaneSequence &lane_sequence, const double s, LaneObstacle *const lane_obstacle)
	Get the nearest obstacle on lane sequence at s
void	AddObstacle (const int obstacle_id, const std::string &lane_id, const double lane_s, const double lane_l)
	Add an obstacle into clusters
void	ClearObstacle ()
void	SortObstacles ()
	Sort lane obstacles by lane s
bool	ForwardNearbyObstacle (const LaneSequence &lane_sequence, const int obstacle_id, const double obstacle_s, const double obstacle_l, NearbyObstacle *const nearby_obstacle_ptr)
	Get the forward nearest obstacle on lane sequence at s
bool	BackwardNearbyObstacle (const LaneSequence &lane_sequence, const int obstacle_id, const double obstacle_s, const double obstacle_l, NearbyObstacle *const nearby_obstacle_ptr)
	Get the backward nearest obstacle on lane sequence at s
StopSign	QueryStopSignByLaneId (const std::string &lane_id)
	Query stop sign by lane ID
std::unordered_map< std::string, std::vector< LaneObstacle > > &	GetLaneObstacles ()

详细描述

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

构造及析构函数说明

ObstacleClusters()

apollo::prediction::ObstacleClusters::ObstacleClusters ( )

default

Constructor

成员函数说明

AddObstacle()

void apollo::prediction::ObstacleClusters::AddObstacle	(	const int	obstacle_id,
		const std::string &	lane_id,
		const double	lane_s,
		const double	lane_l
	)

Add an obstacle into clusters

参数

obstacle	id
lane	id
lane	s
lane	l

在文件 obstacle_clusters.cc 第 48 行定义.

                                                                             {
  LaneObstacle lane_obstacle;
  lane_obstacle.set_obstacle_id(obstacle_id);
  lane_obstacle.set_lane_id(lane_id);
  lane_obstacle.set_lane_s(lane_s);
  lane_obstacle.set_lane_l(lane_l);
  lane_obstacles_[lane_id].push_back(std::move(lane_obstacle));
}

BackwardNearbyObstacle()

bool apollo::prediction::ObstacleClusters::BackwardNearbyObstacle	(	const LaneSequence &	lane_sequence,
		const int	obstacle_id,
		const double	obstacle_s,
		const double	obstacle_l,
		NearbyObstacle *const	nearby_obstacle_ptr
	)

Get the backward nearest obstacle on lane sequence at s

参数

Lane	sequence
s	offset in the first lane of the lane sequence
the	forward obstacle on lane

返回

If the backward obstacle is found

在文件 obstacle_clusters.cc 第 103 行定义.

                                               {
  if (lane_sequence.lane_segment().empty()) {
    AERROR << "Empty lane sequence found.";
    return false;
  }
  const LaneSegment& lane_segment = lane_sequence.lane_segment(0);
  std::string lane_id = lane_segment.lane_id();
 
  // Search current lane
  if (lane_obstacles_.find(lane_id) != lane_obstacles_.end() &&
      !lane_obstacles_[lane_id].empty()) {
    for (int i = static_cast<int>(lane_obstacles_[lane_id].size()) - 1; i >= 0;
         --i) {
      const LaneObstacle& lane_obstacle = lane_obstacles_[lane_id][i];
      if (lane_obstacle.obstacle_id() == obstacle_id) {
        continue;
      }
      double relative_s = lane_obstacle.lane_s() - obstacle_s;
      double relative_l = lane_obstacle.lane_l() - obstacle_l;
      if (relative_s < 0.0) {
        nearby_obstacle_ptr->set_id(lane_obstacle.obstacle_id());
        nearby_obstacle_ptr->set_s(relative_s);
        nearby_obstacle_ptr->set_l(relative_l);
        return true;
      }
    }
  }
 
  // Search backward lanes
  std::shared_ptr<const LaneInfo> lane_info_ptr =
      PredictionMap::LaneById(lane_id);
  bool found_one_behind = false;
  double relative_s = -std::numeric_limits<double>::infinity();
  double relative_l = 0.0;
  for (const auto& predecessor_lane_id :
       lane_info_ptr->lane().predecessor_id()) {
    std::string lane_id = predecessor_lane_id.id();
    if (lane_obstacles_.find(lane_id) == lane_obstacles_.end() ||
        lane_obstacles_[lane_id].empty()) {
      continue;
    }
    std::shared_ptr<const LaneInfo> pred_lane_info_ptr =
        PredictionMap::LaneById(predecessor_lane_id.id());
    const LaneObstacle& backward_obs = lane_obstacles_[lane_id].back();
    double delta_s = backward_obs.lane_s() -
                     (obstacle_s + pred_lane_info_ptr->total_length());
    found_one_behind = true;
    if (delta_s > relative_s) {
      relative_s = delta_s;
      relative_l = backward_obs.lane_l() - obstacle_l;
      nearby_obstacle_ptr->set_id(backward_obs.obstacle_id());
      nearby_obstacle_ptr->set_s(relative_s);
      nearby_obstacle_ptr->set_l(relative_l);
    }
  }
 
  return found_one_behind;
}

ClearObstacle()

void apollo::prediction::ObstacleClusters::ClearObstacle

(

)

在文件 obstacle_clusters.cc 第 59 行定义.

                                     {
  lane_obstacles_.clear();
}

ForwardNearbyObstacle() [1/2]

bool apollo::prediction::ObstacleClusters::ForwardNearbyObstacle	(	const LaneSequence &	lane_sequence,
		const double	s,
		LaneObstacle *const	lane_obstacle
	)

Get the nearest obstacle on lane sequence at s

参数

Lane	sequence
s	offset in the first lane of the lane sequence
the	forward obstacle on lane

返回

If the forward obstacle is found

ForwardNearbyObstacle() [2/2]

bool apollo::prediction::ObstacleClusters::ForwardNearbyObstacle	(	const LaneSequence &	lane_sequence,
		const int	obstacle_id,
		const double	obstacle_s,
		const double	obstacle_l,
		NearbyObstacle *const	nearby_obstacle_ptr
	)

Get the forward nearest obstacle on lane sequence at s

参数

Lane	sequence
s	offset in the first lane of the lane sequence
the	forward obstacle on lane

返回

If the forward obstacle is found

在文件 obstacle_clusters.cc 第 73 行定义.

                                               {
  double accumulated_s = 0.0;
  for (const LaneSegment& lane_segment : lane_sequence.lane_segment()) {
    std::string lane_id = lane_segment.lane_id();
    double lane_length = lane_segment.total_length();
    if (lane_obstacles_.find(lane_id) == lane_obstacles_.end() ||
        lane_obstacles_[lane_id].empty()) {
      accumulated_s += lane_length;
      continue;
    }
    for (const LaneObstacle& lane_obstacle : lane_obstacles_[lane_id]) {
      if (lane_obstacle.obstacle_id() == obstacle_id) {
        continue;
      }
      double relative_s = accumulated_s + lane_obstacle.lane_s() - obstacle_s;
      double relative_l = lane_obstacle.lane_l() - obstacle_l;
      if (relative_s > 0.0) {
        nearby_obstacle_ptr->set_id(lane_obstacle.obstacle_id());
        nearby_obstacle_ptr->set_s(relative_s);
        nearby_obstacle_ptr->set_l(relative_l);
        return true;
      }
    }
  }
  return false;
}

GetLaneGraph()

LaneGraph apollo::prediction::ObstacleClusters::GetLaneGraph	(	const double	start_s,
		const double	length,
		const bool	consider_lane_split,
		std::shared_ptr< const apollo::hdmap::LaneInfo >	lane_info_ptr
	)

Obtain a lane graph given a lane info and s

参数

lane	start s
lane	total length
if	consider lane split ahead
lane	info

返回

a corresponding lane graph

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

                                                 {
  std::string lane_id = lane_info_ptr->id().id();
  RoadGraph road_graph(start_s, length, consider_lane_split, lane_info_ptr);
  LaneGraph lane_graph;
  road_graph.BuildLaneGraph(&lane_graph);
  return lane_graph;
}

GetLaneGraphWithoutMemorizing()

LaneGraph apollo::prediction::ObstacleClusters::GetLaneGraphWithoutMemorizing	(	const double	start_s,
		const double	length,
		const bool	is_on_lane,
		std::shared_ptr< const apollo::hdmap::LaneInfo >	lane_info_ptr
	)

Obtain a lane graph given a lane info and s, but don't memorize it.

参数

lane	start s
lane	total length
if	the obstacle is on lane
lane	info

返回

a corresponding lane graph

在文件 obstacle_clusters.cc 第 39 行定义.

                                                 {
  RoadGraph road_graph(start_s, length, true, lane_info_ptr);
  LaneGraph lane_graph;
  road_graph.BuildLaneGraphBidirection(&lane_graph);
  return lane_graph;
}

GetLaneObstacles()

std::unordered_map< std::string, std::vector< LaneObstacle > > & apollo::prediction::ObstacleClusters::GetLaneObstacles ( )

inline

在文件 obstacle_clusters.h 第 128 行定义.

                     {
    return lane_obstacles_;
  }

Init()

void apollo::prediction::ObstacleClusters::Init

(

)

Remove all lane graphs

QueryStopSignByLaneId()

StopSign apollo::prediction::ObstacleClusters::QueryStopSignByLaneId

(

const std::string &

lane_id

)

Query stop sign by lane ID

参数

lane

ID

返回

the stop sign

在文件 obstacle_clusters.cc 第 165 行定义.

                                                                         {
  StopSign stop_sign;
  // Find the stop_sign by lane_id in the hashtable
  if (lane_id_stop_sign_map_.find(lane_id) != lane_id_stop_sign_map_.end()) {
    return lane_id_stop_sign_map_[lane_id];
  }
  std::shared_ptr<const LaneInfo> lane_info_ptr =
      PredictionMap::LaneById(lane_id);
  CHECK_NOTNULL(lane_info_ptr);
  for (const auto& overlap_id : lane_info_ptr->lane().overlap_id()) {
    auto overlap_info_ptr = PredictionMap::OverlapById(overlap_id.id());
    if (overlap_info_ptr == nullptr) {
      continue;
    }
    for (const auto& object : overlap_info_ptr->overlap().object()) {
      // find the overlap with stop_sign
      if (object.has_stop_sign_overlap_info()) {
        for (const auto& obj : overlap_info_ptr->overlap().object()) {
          // find the obj of in the overlap
          if (obj.has_lane_overlap_info()) {
            if (!stop_sign.has_lane_s() ||
                stop_sign.lane_s() > obj.lane_overlap_info().start_s()) {
              stop_sign.set_stop_sign_id(object.id().id());
              stop_sign.set_lane_id(lane_id);
              stop_sign.set_lane_s(obj.lane_overlap_info().start_s());
              lane_id_stop_sign_map_[lane_id] = stop_sign;
            }
          }
        }
      }
    }
  }
  return lane_id_stop_sign_map_[lane_id];
}

SortObstacles()

void apollo::prediction::ObstacleClusters::SortObstacles

(

)

Sort lane obstacles by lane s

在文件 obstacle_clusters.cc 第 63 行定义.

                                     {
  for (auto iter = lane_obstacles_.begin(); iter != lane_obstacles_.end();
       ++iter) {
    std::sort(iter->second.begin(), iter->second.end(),
              [](const LaneObstacle& obs0, const LaneObstacle& obs1) -> bool {
                return obs0.lane_s() < obs1.lane_s();
              });
  }
}

---

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

• modules/prediction/container/obstacles/obstacle_clusters.h
• modules/prediction/container/obstacles/obstacle_clusters.cc