add road type for hdmap

modules/map/hdmap/adapter/xml_parser/common_define.h

@@ -60,6 +60,7 @@ using PbSignalType = apollo::hdmap::Signal_Type;
 using PbSubSignalType = apollo::hdmap::Subsignal_Type;
 using PbStopSignType = apollo::hdmap::StopSign_StopType;
 using PbBoundaryEdgeType = apollo::hdmap::BoundaryEdge_Type;
+using PbRoadType = apollo::hdmap::Road_Type;
 
 struct StopLineInternal {
   std::string id;
@@ -125,6 +126,8 @@ struct RoadInternal {
   bool in_junction;
   std::string junction_id;
 
+  std::string type;
+
   std::vector<RoadSectionInternal> sections;
 
   std::vector<TrafficLightInternal> traffic_lights;

modules/map/hdmap/adapter/xml_parser/roads_xml_parser.cc

@@ -47,46 +47,32 @@ Status RoadsXmlParser::Parse(const tinyxml2::XMLElement& xml_node,
       std::string err_msg = "Error parsing road attributes";
       return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
     }
+
     RoadInternal road_internal;
     road_internal.id = id;
     road_internal.road.mutable_id()->set_id(id);
     if (IsRoadBelongToJunction(junction_id)) {
       road_internal.road.mutable_junction_id()->set_id(junction_id);
     }
+
+    std::string type;
+    checker = UtilXmlParser::QueryStringAttribute(*road_node, "type", &type);
+    if (checker != tinyxml2::XML_SUCCESS) {
+      // forward compatibility with old data
+      type = "CITYROAD";
+    }
+    PbRoadType pb_road_type;
+    RETURN_IF_ERROR(to_pb_road_type(type, &pb_road_type));
+    road_internal.road.set_type(pb_road_type);
+
     // lanes
     RETURN_IF_ERROR(LanesXmlParser::Parse(*road_node, road_internal.id,
                                           &road_internal.sections));
 
     // objects
-    auto sub_node = road_node->FirstChildElement("objects");
-    if (sub_node != nullptr) {
-      // stop line
-      ObjectsXmlParser::ParseStopLines(*sub_node, &road_internal.stop_lines);
-      // crosswalks
-      ObjectsXmlParser::ParseCrosswalks(*sub_node, &road_internal.crosswalks);
-      // clearareas
-      ObjectsXmlParser::ParseClearAreas(*sub_node, &road_internal.clear_areas);
-      // speed_bumps
-      ObjectsXmlParser::ParseSpeedBumps(*sub_node, &road_internal.speed_bumps);
-      // parking_spaces
-      ObjectsXmlParser::ParseParkingSpaces(
-                                    *sub_node, &road_internal.parking_spaces);
-      // pnc_junctions
-      ObjectsXmlParser::ParsePNCJunctions(
-                                    *sub_node, &road_internal.pnc_junctions);
-    }
-
+    Parse_road_objects(*road_node, &road_internal);
     // signals
-    sub_node = road_node->FirstChildElement("signals");
-    if (sub_node != nullptr) {
-      // traffic lights
-      SignalsXmlParser::ParseTrafficLights(*sub_node,
-                                           &road_internal.traffic_lights);
-      // stop signs
-      SignalsXmlParser::ParseStopSigns(*sub_node, &road_internal.stop_signs);
-      // yield signs
-      SignalsXmlParser::ParseYieldSigns(*sub_node, &road_internal.yield_signs);
-    }
+    Parse_road_signals(*road_node, &road_internal);
 
     roads->push_back(road_internal);
     road_node = road_node->NextSiblingElement("road");
@@ -95,6 +81,67 @@ Status RoadsXmlParser::Parse(const tinyxml2::XMLElement& xml_node,
   return Status::OK();
 }
 
+void RoadsXmlParser::Parse_road_objects(const tinyxml2::XMLElement& xml_node,
+                                    RoadInternal* road_info) {
+  CHECK_NOTNULL(road_info);
+
+  // objects
+  auto sub_node = xml_node.FirstChildElement("objects");
+  if (sub_node != nullptr) {
+    // stop line
+    ObjectsXmlParser::ParseStopLines(*sub_node, &road_info->stop_lines);
+    // crosswalks
+    ObjectsXmlParser::ParseCrosswalks(*sub_node, &road_info->crosswalks);
+    // clearareas
+    ObjectsXmlParser::ParseClearAreas(*sub_node, &road_info->clear_areas);
+    // speed_bumps
+    ObjectsXmlParser::ParseSpeedBumps(*sub_node, &road_info->speed_bumps);
+    // parking_spaces
+    ObjectsXmlParser::ParseParkingSpaces(*sub_node, &road_info->parking_spaces);
+    // pnc_junctions
+    ObjectsXmlParser::ParsePNCJunctions(*sub_node, &road_info->pnc_junctions);
+  }
+}
+
+void RoadsXmlParser::Parse_road_signals(const tinyxml2::XMLElement& xml_node,
+                                    RoadInternal* road_info) {
+  CHECK_NOTNULL(road_info);
+
+  // signals
+  auto sub_node = xml_node.FirstChildElement("signals");
+  if (sub_node != nullptr) {
+    // traffic lights
+    SignalsXmlParser::ParseTrafficLights(*sub_node,
+                                      &road_info->traffic_lights);
+    // stop signs
+    SignalsXmlParser::ParseStopSigns(*sub_node, &road_info->stop_signs);
+    // yield signs
+    SignalsXmlParser::ParseYieldSigns(*sub_node, &road_info->yield_signs);
+  }
+}
+
+Status RoadsXmlParser::to_pb_road_type(const std::string& type,
+                                    PbRoadType* pb_road_type) {
+  CHECK_NOTNULL(pb_road_type);
+
+  std::string upper_type = UtilXmlParser::ToUpper(type);
+
+  if (upper_type == "UNKNOWN") {
+    *pb_road_type = apollo::hdmap::Road::UNKNOWN;
+  } else if (upper_type == "HIGHWAY") {
+    *pb_road_type = apollo::hdmap::Road::HIGHWAY;
+  } else if (upper_type == "CITYROAD") {
+    *pb_road_type = apollo::hdmap::Road::CITY_ROAD;
+  } else if (upper_type == "PARK") {
+    *pb_road_type = apollo::hdmap::Road::PARK;
+  } else {
+      std::string err_msg = "Error or unsupport road type";
+      return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
+  }
+
+  return Status::OK();
+}
+
 }  // namespace adapter
 }  // namespace hdmap
 }  // namespace apollo

modules/map/hdmap/adapter/xml_parser/roads_xml_parser.h

@@ -15,6 +15,7 @@ limitations under the License.
 #pragma once
 
 #include <vector>
+#include <string>
 
 #include "tinyxml2/tinyxml2.h"
 
@@ -29,6 +30,16 @@ class RoadsXmlParser {
  public:
   static Status Parse(const tinyxml2::XMLElement& xml_node,
                       std::vector<RoadInternal>* roads);
+
+
+ private:
+  static void Parse_road_objects(const tinyxml2::XMLElement& xml_node,
+                                RoadInternal* road_info);
+  static void Parse_road_signals(const tinyxml2::XMLElement& xml_node,
+                                RoadInternal* road_info);
+
+  static Status to_pb_road_type(const std::string& type,
+                            PbRoadType* pb_road_type);
 };
 
 }  // namespace adapter

modules/map/hdmap/hdmap_common.h

@@ -458,6 +458,8 @@ class RoadInfo {
 
   const std::vector<RoadBoundary> &GetBoundaries() const;
 
+  apollo::hdmap::Road_Type type() const { return road_.type(); }
+
  private:
   Road road_;
   std::vector<RoadSection> sections_;

modules/map/proto/map_road.proto

@@ -53,4 +53,12 @@ message Road {
 
   // if lane road not in the junction, junction id is null.
   optional Id junction_id = 3;
+
+  enum Type {
+    UNKNOWN = 0;
+    HIGHWAY = 1;
+    CITY_ROAD = 2;
+    PARK = 3;
+  };
+  optional Type type = 4;
 }