apollo::v2x::InternalData类 参考

#include <utils.h>

apollo::v2x::InternalData 的协作图:

Public 成员函数
	InternalData ()
virtual	~InternalData ()
void	reset ()
bool	TrafficLightProc (const std::shared_ptr<::apollo::hdmap::HDMap > &hdmap, double distance, ::apollo::v2x::RoadTrafficLight *msg)
bool	ProcTrafficlight (const std::shared_ptr<::apollo::hdmap::HDMap > &hdmap, const ObuLight *x2v_traffic_light, const std::string &junction_id, bool flag_u_turn, double distance, double check_time, std::shared_ptr< OSLight > *os_light)
bool	ProcPlanningMessage (const ::apollo::planning::ADCTrajectory *planning_msg, const OSLight *last_os_light, std::shared_ptr<::apollo::perception::TrafficLightDetection > *res_light)

详细描述

在文件 utils.h 第 42 行定义.

构造及析构函数说明

InternalData()

apollo::v2x::InternalData::InternalData

(

)

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

                           {
  remaining_time_ = new int32_t[kBufferSize];
  msg_timestamp_ = new double[kBufferSize];
  CHECK_NOTNULL(remaining_time_);
  CHECK_NOTNULL(msg_timestamp_);
  obu_light_ = std::make_shared<ObuLight>();
  this->reset();
}

~InternalData()

apollo::v2x::InternalData::~InternalData ( )

virtual

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

                            {
  delete[] remaining_time_;
  delete[] msg_timestamp_;
}

成员函数说明

ProcPlanningMessage()

bool apollo::v2x::InternalData::ProcPlanningMessage	(	const ::apollo::planning::ADCTrajectory *	planning_msg,
		const OSLight *	last_os_light,
		std::shared_ptr<::apollo::perception::TrafficLightDetection > *	res_light
	)

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

                                                                     {
  if (!planning_msg || !res_light || !(*res_light)) {
    return false;
  }
  // Keep this blank header for protect other module against coredump.
  (*res_light)->mutable_header();
  if (!planning_msg->has_debug() ||
      !planning_msg->debug().has_planning_data()) {
    return false;
  }
  const auto &planning_debug = planning_msg->debug().planning_data();
  if (!planning_debug.has_signal_light() ||
      0 == planning_debug.signal_light().signal_size()) {
    return false;
  }
  const std::string light_id =
      planning_debug.signal_light().signal(0).light_id();
  if (!last_os_light || light_id.empty()) {
    return true;  // output traffic light without v2x;
  }
  ::apollo::common::Direction attr = ::apollo::common::Direction::EAST;
  bool found = false;
  for (int idx = 0; idx < last_os_light->road_traffic_light_size(); idx++) {
    const auto &road_tl = last_os_light->road_traffic_light(idx);
    if (0 == road_tl.single_traffic_light_size()) {
      continue;
    }
    if (road_tl.single_traffic_light(0).id() == light_id) {
      attr = road_tl.road_attribute();
      found = true;
      break;
    }
  }
  if (!found) {
    AWARN << "Failed to find light_id from os_light: " << light_id
          << " , Ignored";
    return true;  // output traffic light without v2x;
  }
  (*res_light)->clear_traffic_light();
  auto res_frame_id = std::to_string(last_os_light->has_intersection_id()
                                         ? last_os_light->intersection_id()
                                         : -1);
  (*res_light)->mutable_header()->set_frame_id(res_frame_id);
  AINFO << "Selected road attr: " << ::apollo::common::Direction_Name(attr);
  std::set<std::string> idset;
  for (int idx = 0; idx < last_os_light->road_traffic_light_size(); idx++) {
    const auto &road_tl = last_os_light->road_traffic_light(idx);
    if (0 == road_tl.single_traffic_light_size()) {
      continue;
    }
    if (road_tl.road_attribute() != attr) {
      continue;
    }
    const auto &single_tl = road_tl.single_traffic_light(0);
    if (single_tl.traffic_light_type_size() < 1) {
      continue;
    }
    auto *light1 = (*res_light)->add_traffic_light();
    // SET ID
    // light1->set_id(single_tl.id());
    light1->set_id(SingleTrafficLight_Type_Name(  //
        single_tl.traffic_light_type(0)));
    idset.emplace(single_tl.id());
 
    if (single_tl.has_color()) {
      switch (single_tl.color()) {
        case OSLightColor::SingleTrafficLight_Color_RED:
          light1->set_color(
              ::apollo::perception::TrafficLight_Color::TrafficLight_Color_RED);
          break;
        case OSLightColor::SingleTrafficLight_Color_YELLOW:
          light1->set_color(::apollo::perception::TrafficLight_Color::
                                TrafficLight_Color_YELLOW);
          break;
        case OSLightColor::SingleTrafficLight_Color_GREEN:
        case OSLightColor::SingleTrafficLight_Color_FLASH_GREEN:
          light1->set_color(::apollo::perception::TrafficLight_Color::
                                TrafficLight_Color_GREEN);
          break;
        case OSLightColor::SingleTrafficLight_Color_BLACK:
          light1->set_color(::apollo::perception::TrafficLight_Color::
                                TrafficLight_Color_BLACK);
          break;
        default:
          light1->set_color(::apollo::perception::TrafficLight_Color::
                                TrafficLight_Color_UNKNOWN);
          break;
      }
    }
    // REMAINING_TIME
    if (single_tl.has_color_remaining_time_s()) {
      light1->set_remaining_time(single_tl.color_remaining_time_s());
    }
  }
  return true;
}

ProcTrafficlight()

bool apollo::v2x::InternalData::ProcTrafficlight	(	const std::shared_ptr<::apollo::hdmap::HDMap > &	hdmap,
		const ObuLight *	x2v_traffic_light,
		const std::string &	junction_id,
		bool	flag_u_turn,
		double	distance,
		double	check_time,
		std::shared_ptr< OSLight > *	os_light
	)

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

                                      {
  if (nullptr == os_light) {
    return false;
  }
  if (nullptr == *os_light) {
    return false;
  }
  if (!x2v_traffic_light) {
    if (junction_id == kUnknownJunctionId) {
      return false;
    }
    return true;
  }
  if (junction_id != x2v_traffic_light->hdmap_junction_id()) {
    AWARN << "current junction id " << junction_id
          << ", received the junction id "
          << x2v_traffic_light->hdmap_junction_id();
    return false;
  }
  std::shared_ptr<OSLight> os_traffic_light = nullptr;
  if (!ProtoAdapter::LightObu2Sys(*x2v_traffic_light, &os_traffic_light)) {
    return false;
  }
  int num_os_traffic_light = os_traffic_light->road_traffic_light_size();
  if (0 == num_os_traffic_light) {
    AERROR << "Ignored no traffic light contained after conventor.";
    return false;
  }
  std::shared_ptr<OSLight> sim_traffic_light_data = nullptr;
  // enter the new intersection if the sim message is not null, clear
  auto cur_junction_id = x2v_traffic_light->intersection_id();
  auto tmp_os_traffic_light = std::make_shared<OSLight>();
  tmp_os_traffic_light->CopyFrom(*os_traffic_light);
  // clear road traffic light
  tmp_os_traffic_light->clear_road_traffic_light();
  for (int i = 0; i < num_os_traffic_light; i++) {
    auto os_current_light = os_traffic_light->mutable_road_traffic_light(i);
    if (!TrafficLightProc(hdmap, distance, os_current_light)) {
      AERROR << "Traffic light proc failed";
      continue;
    }
    if (os_current_light->single_traffic_light_size() > 0) {
      auto tmp_os_current_light =
          tmp_os_traffic_light->add_road_traffic_light();
      tmp_os_current_light->CopyFrom(*(os_current_light));
    }
  }
  tmp_os_traffic_light->set_confidence(IsRushHour() ? 0.5 : 1.0);
  AINFO << "all traffic light send to os BEFORE is: "
        << os_traffic_light->DebugString();
  if (0 == tmp_os_traffic_light->road_traffic_light_size()) {
    return false;
  }
  cur_junction_id = x2v_traffic_light->intersection_id();
  tmp_os_traffic_light->set_intersection_id(cur_junction_id);
  // enter a new junction, need to clear the list
  if (cur_junction_id != intersection_id_) {
    AINFO << "Enter New Juncion: " << cur_junction_id;
    oslight_ = nullptr;
    intersection_id_ = cur_junction_id;
    int num_traffic_light = tmp_os_traffic_light->road_traffic_light_size();
    for (int i = 0; i < num_traffic_light; i++) {
      auto remaining_time = tmp_os_traffic_light->road_traffic_light(i)
                                .single_traffic_light(0)
                                .color_remaining_time_s();
      remaining_time_[i] = remaining_time;
      msg_timestamp_[i] = x2v_traffic_light->header().timestamp_sec();
    }
  } else {
    ADEBUG << "Same Juncion: " << cur_junction_id;
    if (flag_u_turn) {
      for (unsigned int i = 0; i < kBufferSize; i++) {
        msg_timestamp_[i] = 0.0;
        remaining_time_[i] = -1;
      }
      oslight_ = nullptr;
    }
    int num_traffic_light = tmp_os_traffic_light->road_traffic_light_size();
    for (int i = 0; i < num_traffic_light; i++) {
      auto remaining_time = tmp_os_traffic_light->road_traffic_light(i)
                                .single_traffic_light(0)
                                .color_remaining_time_s();
      if ((remaining_time_[i] != remaining_time)) {
        remaining_time_[i] = remaining_time;
        msg_timestamp_[i] = x2v_traffic_light->header().timestamp_sec();
      }
    }
    if (!!oslight_) {
      int road_valid_size =
          std::min(oslight_->road_traffic_light_size(),
                   tmp_os_traffic_light->road_traffic_light_size());
      for (int i = 0; i < road_valid_size; i++) {
        const auto &last_msg_road = oslight_->road_traffic_light(i);
        auto current_msg_road =
            tmp_os_traffic_light->mutable_road_traffic_light(i);
        int single_valid_size =
            std::min(last_msg_road.single_traffic_light_size(),
                     current_msg_road->single_traffic_light_size());
        for (int j = 0; j < single_valid_size; j++) {
          const auto &last_msg_single_traffic_light =
              last_msg_road.single_traffic_light(j);
          auto current_msg_single_traffic_light =
              current_msg_road->mutable_single_traffic_light(j);
          if (last_msg_single_traffic_light.color() ==
              current_msg_single_traffic_light->color()) {
            if (current_msg_single_traffic_light->color_remaining_time_s() >
                last_msg_single_traffic_light.color_remaining_time_s()) {
              AINFO << "correct the remaining time";
              current_msg_single_traffic_light->set_color_remaining_time_s(
                  last_msg_single_traffic_light.color_remaining_time_s());
            }
          }
        }
      }
    }
  }
  oslight_ = std::make_shared<::apollo::v2x::IntersectionTrafficLightData>();
  oslight_->CopyFrom(*tmp_os_traffic_light);
  (*os_light)->CopyFrom(*tmp_os_traffic_light);
  return true;
}

reset()

void apollo::v2x::InternalData::reset

(

)

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

                         {
  oslight_ = nullptr;
  intersection_id_ = -1;
  change_color_timestamp_ = 0.0;
}

TrafficLightProc()

bool apollo::v2x::InternalData::TrafficLightProc	(	const std::shared_ptr<::apollo::hdmap::HDMap > &	hdmap,
		double	distance,
		::apollo::v2x::RoadTrafficLight *	msg
	)

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

                                    {
  if (nullptr == msg) {
    return false;
  }
  if (!msg->has_gps_x_m() || !msg->has_gps_y_m()) {
    AERROR << "Error::v2x traffic_light ignore, gps point is null";
    return false;
  }
  ::apollo::common::PointENU point;
  point.set_x(msg->gps_x_m());
  point.set_y(msg->gps_y_m());
  if (0 == msg->single_traffic_light_size()) {
    AERROR << "Error::v2x traffic_light ignore, size of single light is 0.";
    return false;
  }
  if (0 == msg->single_traffic_light(0).traffic_light_type_size()) {
    return false;
  }
  ::apollo::hdmap::LaneInfoConstPtr laneinfo;
  double dummy_s = 0, dummy_l = 0;
  if (0 != hdmap->GetNearestLane(point, &laneinfo, &dummy_s, &dummy_l)) {
    return false;
  }
  std::vector<::apollo::hdmap::SignalInfoConstPtr> signals;
  if (0 != hdmap->GetForwardNearestSignalsOnLane(point, distance, &signals)) {
    AERROR << "Error::v2x traffic_light ignore, hdmap get no signals."
           << "traffic light size : " << signals.size() << " "
           << std::setiosflags(std::ios::fixed) << std::setprecision(11)
           << "Point:x=" << point.x() << ",y=" << point.y();
    return false;
  }
  if (signals.empty()) {
    AERROR << "Get traffic light size : " << signals.size() << " "
           << std::setiosflags(std::ios::fixed) << std::setprecision(11)
           << "Point:x=" << point.x() << ",y=" << point.y();
    return false;
  }
  AINFO << "the size of traffic light from HDMap is: " << signals.size();
  auto tl_type = msg->single_traffic_light(0).traffic_light_type(0);
  auto color = msg->single_traffic_light(0).color();
  auto remaining_time = msg->single_traffic_light(0).color_remaining_time_s();
  auto next_color = msg->single_traffic_light(0).next_color();
  auto next_remaining_time =
      msg->single_traffic_light(0).next_remaining_time_s();
  msg->clear_single_traffic_light();
  for (size_t i = 0; i < signals.size(); i++) {
    auto signal_info = signals[i];
    auto single = msg->add_single_traffic_light();
    single->set_id(signal_info->id().id());
    single->add_traffic_light_type(tl_type);
    single->set_color(color);
    single->set_color_remaining_time_s(remaining_time);
    single->set_next_color(next_color);
    single->set_next_remaining_time_s(next_remaining_time);
  }
  return true;
}

---

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

• modules/v2x/v2x_proxy/app/utils.h
• modules/v2x/v2x_proxy/app/utils.cc