apollo::prediction::JunctionAnalyzer类 参考

#include <junction_analyzer.h>

apollo::prediction::JunctionAnalyzer 的协作图:

Public 成员函数
void	Init (const std::string &junction_id)
	Initialize by junction ID, if junction id differs from prev cycle
void	Clear ()
	Clear all stored data
const std::string &	GetJunctionId ()
	Get junction ID
double	ComputeJunctionRange ()
	Compute junction range
const JunctionFeature &	GetJunctionFeature (const std::string &start_lane_id)
	Get junction feature starting from start_lane_id
JunctionFeature	GetJunctionFeature (const std::vector< std::string > &start_lane_ids)
	Get junction feature starting from start_lane_ids

详细描述

在文件 junction_analyzer.h 第 30 行定义.

成员函数说明

Clear()

void apollo::prediction::JunctionAnalyzer::Clear

(

)

Clear all stored data

在文件 junction_analyzer.cc 第 44 行定义.

                             {
  // Clear all data
  junction_info_ptr_ = nullptr;
  junction_exits_.clear();
  junction_features_.clear();
}

ComputeJunctionRange()

double apollo::prediction::JunctionAnalyzer::ComputeJunctionRange

(

)

Compute junction range

返回

Junction range

在文件 junction_analyzer.cc 第 175 行定义.

                                              {
  CHECK_NOTNULL(junction_info_ptr_);
  if (!junction_info_ptr_->junction().has_polygon() ||
      junction_info_ptr_->junction().polygon().point_size() < 3) {
    AERROR << "Junction [" << GetJunctionId()
           << "] has not enough polygon points to compute range";
    return FLAGS_defualt_junction_range;
  }
  double x_min = std::numeric_limits<double>::infinity();
  double x_max = -std::numeric_limits<double>::infinity();
  double y_min = std::numeric_limits<double>::infinity();
  double y_max = -std::numeric_limits<double>::infinity();
  for (const auto& point : junction_info_ptr_->junction().polygon().point()) {
    x_min = std::min(x_min, point.x());
    x_max = std::max(x_max, point.x());
    y_min = std::min(y_min, point.y());
    y_max = std::max(y_max, point.y());
  }
  double dx = std::abs(x_max - x_min);
  double dy = std::abs(y_max - y_min);
  double range = std::sqrt(dx * dx + dy * dy);
  return range;
}

GetJunctionFeature() [1/2]

const JunctionFeature & apollo::prediction::JunctionAnalyzer::GetJunctionFeature

(

const std::string &

start_lane_id

)

Get junction feature starting from start_lane_id

参数

start

lane ID

返回

junction

在文件 junction_analyzer.cc 第 119 行定义.

                                    {
  if (junction_features_.find(start_lane_id) != junction_features_.end()) {
    return junction_features_[start_lane_id];
  }
  JunctionFeature junction_feature;
  junction_feature.set_junction_id(GetJunctionId());
  junction_feature.set_junction_range(ComputeJunctionRange());
  // Find all junction-exit-lanes that are successors of the start_lane_id.
  std::vector<JunctionExit> junction_exits = GetJunctionExits(start_lane_id);
 
  for (const auto& junction_exit : junction_exits) {
    junction_feature.add_junction_exit()->CopyFrom(junction_exit);
  }
  junction_feature.mutable_enter_lane()->set_lane_id(start_lane_id);
  junction_feature.add_start_lane_id(start_lane_id);
  junction_features_[start_lane_id] = junction_feature;
  return junction_features_[start_lane_id];
}

GetJunctionFeature() [2/2]

JunctionFeature apollo::prediction::JunctionAnalyzer::GetJunctionFeature

(

const std::vector< std::string > &

start_lane_ids

)

Get junction feature starting from start_lane_ids

参数

start

lane IDs

返回

junction

在文件 junction_analyzer.cc 第 139 行定义.

                                                {
  JunctionFeature merged_junction_feature;
  bool initialized = false;
  std::unordered_map<std::string, JunctionExit> junction_exits_map;
  for (const std::string& start_lane_id : start_lane_ids) {
    JunctionFeature junction_feature = GetJunctionFeature(start_lane_id);
    if (!initialized) {
      merged_junction_feature.set_junction_id(junction_feature.junction_id());
      merged_junction_feature.set_junction_range(
          junction_feature.junction_range());
      initialized = true;
    }
    for (const JunctionExit& junction_exit : junction_feature.junction_exit()) {
      if (junction_exits_map.find(junction_exit.exit_lane_id()) ==
          junction_exits_map.end()) {
        junction_exits_map[junction_exit.exit_lane_id()] = junction_exit;
      }
    }
  }
  for (const auto& exit : junction_exits_map) {
    merged_junction_feature.add_start_lane_id(exit.first);
    merged_junction_feature.add_junction_exit()->CopyFrom(exit.second);
  }
  return merged_junction_feature;
}

GetJunctionId()

const std::string & apollo::prediction::JunctionAnalyzer::GetJunctionId

(

)

Get junction ID

返回

Junction ID

在文件 junction_analyzer.cc 第 170 行定义.

                                                 {
  CHECK_NOTNULL(junction_info_ptr_);
  return junction_info_ptr_->id().id();
}

Init()

void apollo::prediction::JunctionAnalyzer::Init

(

const std::string &

junction_id

)

Initialize by junction ID, if junction id differs from prev cycle

参数

junction

ID

在文件 junction_analyzer.cc 第 34 行定义.

                                                        {
  if (junction_info_ptr_ != nullptr &&
      junction_info_ptr_->id().id() == junction_id) {
    return;
  }
  Clear();
  junction_info_ptr_ = PredictionMap::JunctionById(junction_id);
  SetAllJunctionExits();
}

---

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

• modules/prediction/common/junction_analyzer.h
• modules/prediction/common/junction_analyzer.cc