apollo::v2x::utils 命名空间参考

函数
bool	FindAllRoadId (const std::shared_ptr<::apollo::hdmap::HDMap > &hdmap, const ::apollo::hdmap::LaneInfoConstPtr &start_laneinfo, const ::apollo::hdmap::LaneInfoConstPtr &end_laneinfo, size_t max_road_count, std::unordered_set< std::string > *result_id_set)
bool	CheckCarInSet (const std::shared_ptr<::apollo::hdmap::HDMap > &hdmap, const std::unordered_set< std::string > &id_set, const ::apollo::hdmap::LaneInfoConstPtr &car_laneinfo, size_t max_lane_count)
bool	GetRsuInfo (const std::shared_ptr<::apollo::hdmap::HDMap > &hdmap, const OSLocation &os_location, const std::set< std::string > &rsu_whitelist, double distance, double max_heading_difference, std::shared_ptr<::apollo::v2x::CarStatus > *v2x_car_status, std::string *out_junction_id, double *out_heading)
OSLightColor	GetNextColor (OSLightColor color)
void	UniqueOslight (OSLight *os_light)

函数说明

CheckCarInSet()

bool apollo::v2x::utils::CheckCarInSet	(	const std::shared_ptr<::apollo::hdmap::HDMap > &	hdmap,
		const std::unordered_set< std::string > &	id_set,
		const ::apollo::hdmap::LaneInfoConstPtr &	car_laneinfo,
		size_t	max_lane_count
	)

在文件 utils.cc 第 386 行定义.

                                          {
  size_t lane_counter = 0;
  ::apollo::hdmap::Id id;
  auto car_laneinfo_tmp = car_laneinfo;
  while (true) {
    if (id_set.count(car_laneinfo_tmp->road_id().id()) == 1) {
      AINFO << "find the car is in the speed limit region";
      return true;
    }
    if (car_laneinfo_tmp->lane().successor_id_size() == 0) {
      AWARN << "The lane of the card no successor";
      return false;
    }
    id = car_laneinfo_tmp->lane().successor_id(0);
    AINFO << "Lane id " << id.id();
    car_laneinfo_tmp = hdmap->GetLaneById(id);
    if (car_laneinfo_tmp == nullptr) {
      AWARN << "Get lane by id is null.";
      return false;
    } else {
      if (++lane_counter > max_lane_count) {
        AWARN << "not find the road in after try to " << lane_counter;
        return false;
      }
    }
  }
}

FindAllRoadId()

bool apollo::v2x::utils::FindAllRoadId	(	const std::shared_ptr<::apollo::hdmap::HDMap > &	hdmap,
		const ::apollo::hdmap::LaneInfoConstPtr &	start_laneinfo,
		const ::apollo::hdmap::LaneInfoConstPtr &	end_laneinfo,
		size_t	max_road_count,
		std::unordered_set< std::string > *	result_id_set
	)

在文件 utils.cc 第 343 行定义.

                                                               {
  if (!result_id_set) {
    return false;
  }
  size_t road_counter = 0;
  ::apollo::hdmap::Id id;
  result_id_set->clear();
  result_id_set->insert(start_laneinfo->road_id().id());
  ::apollo::hdmap::LaneInfoConstPtr start_laneinfo_tmp = start_laneinfo;
  while (true) {
    if (0 == start_laneinfo_tmp->lane().successor_id_size()) {
      AINFO << "The lane has no successor";
      return false;
    }
    id = start_laneinfo_tmp->lane().successor_id(0);
    AINFO << "Lane id " << id.id();
    start_laneinfo_tmp = hdmap->GetLaneById(id);
    if (start_laneinfo_tmp == nullptr) {
      AINFO << "Get lane by id is null.";
      return false;
    }
    result_id_set->insert(start_laneinfo_tmp->road_id().id());
    if (start_laneinfo_tmp->road_id().id() == end_laneinfo->road_id().id()) {
      std::stringstream ss;
      ss << "find all the road id: ";
      for (const auto &item : *result_id_set) {
        ss << item << " ";
      }
      AINFO << ss.str();
      return true;
    }
    road_counter++;
    if (road_counter > max_road_count) {
      AINFO << "not find the end road id after try " << road_counter;
      return false;
    }
  }
}

GetNextColor()

OSLightColor apollo::v2x::utils::GetNextColor

(

OSLightColor

color

)

在文件 utils.cc 第 482 行定义.

                                              {
  switch (color) {
    case OSLightColor::SingleTrafficLight_Color_GREEN:
      return OSLightColor::SingleTrafficLight_Color_YELLOW;
    case OSLightColor::SingleTrafficLight_Color_YELLOW:
      return OSLightColor::SingleTrafficLight_Color_RED;
    case OSLightColor::SingleTrafficLight_Color_RED:
      return OSLightColor::SingleTrafficLight_Color_GREEN;
    default:
      return color;
  }
}

GetRsuInfo()

bool apollo::v2x::utils::GetRsuInfo	(	const std::shared_ptr<::apollo::hdmap::HDMap > &	hdmap,
		const OSLocation &	os_location,
		const std::set< std::string > &	rsu_whitelist,
		double	distance,
		double	max_heading_difference,
		std::shared_ptr<::apollo::v2x::CarStatus > *	v2x_car_status,
		std::string *	out_junction_id,
		double *	out_heading
	)

在文件 utils.cc 第 417 行定义.

                                                                 {
  if (!v2x_car_status) {
    return false;
  }
  if (!out_junction_id) {
    return false;
  }
  if (!out_heading) {
    return false;
  }
  *out_junction_id = kUnknownJunctionId;
  auto res = std::make_shared<::apollo::v2x::CarStatus>();
  if (nullptr == res) {
    return false;
  }
  if (!os_location.has_header()) {
    return false;
  }
  if (!os_location.has_pose()) {
    return false;
  }
  res->mutable_localization()->CopyFrom(os_location);
  ::apollo::common::PointENU point;
  point.set_x(os_location.pose().position().x());
  point.set_y(os_location.pose().position().y());
  double heading = ::apollo::common::math::QuaternionToHeading(
      os_location.pose().orientation().qw(),
      os_location.pose().orientation().qx(),
      os_location.pose().orientation().qy(),
      os_location.pose().orientation().qz());
  *out_heading = heading;
  std::vector<::apollo::hdmap::RSUInfoConstPtr> rsus;
  if (0 != hdmap->GetForwardNearestRSUs(point, distance, heading,
                                        max_heading_difference, &rsus) ||
      rsus.empty()) {
    AINFO << "no rsu is found";
    return false;
  }
  AINFO << "Get " << rsus.size() << " rsu(s)";
  if (rsu_whitelist.find(rsus[0]->id().id() + "_tl") == rsu_whitelist.cend()) {
    AINFO << "This rsu id '" << rsus[0]->id().id()
          << "' is not in the white list";
    return false;
  }
  AINFO << "This RSU is in the white list";
  AINFO << "Junction id " << rsus[0]->rsu().junction_id().id();
  auto junction_info = hdmap->GetJunctionById(rsus[0]->rsu().junction_id());
  if (nullptr == junction_info) {
    return false;
  }
  std::shared_ptr<::apollo::v2x::ObuJunction> obu_junction = nullptr;
  if (!ProtoAdapter::JunctionHd2obu(junction_info, &obu_junction)) {
    return false;
  }
  res->mutable_junction()->CopyFrom(*obu_junction);
  *v2x_car_status = res;
  *out_junction_id = junction_info->id().id();
  return true;
}

UniqueOslight()

void apollo::v2x::utils::UniqueOslight

(

OSLight *

os_light

)

在文件 utils.cc 第 495 行定义.

                                      {
  if (nullptr == os_light) {
    return;
  }
  auto tmp_os_light = std::make_shared<OSLight>();
  tmp_os_light->CopyFrom(*os_light);
  os_light->clear_road_traffic_light();
  std::set<std::string> idset;
  for (int idx_tl = 0; idx_tl < tmp_os_light->road_traffic_light_size();
       idx_tl++) {
    const auto &tmp_road_tl = tmp_os_light->road_traffic_light(idx_tl);
    for (int idx_single = 0;
         idx_single < tmp_road_tl.single_traffic_light_size(); idx_single++) {
      const auto &single = tmp_road_tl.single_traffic_light(idx_single);
      if (0 == single.traffic_light_type_size()) {
        continue;
      }
      std::string tmpid =
          single.id() +
          std::to_string(static_cast<int>(single.traffic_light_type(0)));
      // Has ID
      if (idset.find(tmpid) != idset.cend()) {
        continue;
      }
      idset.insert(tmpid);
      // UNIQUE ID
      auto res_tl = os_light->add_road_traffic_light();
      res_tl->set_gps_x_m(tmp_road_tl.gps_x_m());
      res_tl->set_gps_y_m(tmp_road_tl.gps_y_m());
      res_tl->set_road_attribute(tmp_road_tl.road_attribute());
      auto res_single = res_tl->add_single_traffic_light();
      res_single->CopyFrom(single);
    }
  }
}