apollo::hdmap::adapter::ObjectsXmlParser类 参考

#include <objects_xml_parser.h>

apollo::hdmap::adapter::ObjectsXmlParser 的协作图:

静态 Public 成员函数
static Status	ParseCrosswalks (const tinyxml2::XMLElement &xml_node, std::vector< PbCrosswalk > *crosswalks)
static Status	ParseClearAreas (const tinyxml2::XMLElement &xml_node, std::vector< PbClearArea > *clear_areas)
static Status	ParseSpeedBumps (const tinyxml2::XMLElement &xml_node, std::vector< PbSpeedBump > *speed_bumps)
static Status	ParseStopLines (const tinyxml2::XMLElement &xml_node, std::vector< StopLineInternal > *stop_lines)
static Status	ParseParkingSpaces (const tinyxml2::XMLElement &xml_node, std::vector< PbParkingSpace > *parking_spaces)
static Status	ParsePNCJunctions (const tinyxml2::XMLElement &xml_node, std::vector< PbPNCJunction > *pnc_junctions)
static Status	ParsePassageGroup (const tinyxml2::XMLElement &xml_node, PbPNCJunction *pnc_junction)
static Status	ParsePassage (const tinyxml2::XMLElement &xml_node, PbPassageGroup *passage_group)
static Status	ParsePassageIds (const tinyxml2::XMLElement &xml_node, const std::string &child_node_name, std::vector< std::string > *passage_node_ids)
static Status	ToPassageType (const std::string &type, PbPassageType *passage_type)
static Status	ParseRSUs (const tinyxml2::XMLElement &xml_node, std::vector< RSUInternal > *rsus)
static Status	ParseObjects (const tinyxml2::XMLElement &xml_node, ObjectInternal *objects)

详细描述

在文件 objects_xml_parser.h 第 29 行定义.

成员函数说明

ParseClearAreas()

Status apollo::hdmap::adapter::ObjectsXmlParser::ParseClearAreas ( const tinyxml2::XMLElement &  xml_node, std::vector< PbClearArea > *  clear_areas  )

static

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

                                         {
  CHECK_NOTNULL(clear_areas);
  const tinyxml2::XMLElement* sub_node = xml_node.FirstChildElement("object");
  while (sub_node) {
    std::string object_type;
    std::string object_id;
    int checker =
        UtilXmlParser::QueryStringAttribute(*sub_node, "id", &object_id);
    checker +=
        UtilXmlParser::QueryStringAttribute(*sub_node, "type", &object_type);
    if (checker != tinyxml2::XML_SUCCESS) {
      std::string err_msg = "Error parse object type.";
      return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
    }
 
    if (object_type == "clearArea") {
      PbClearArea clear_area;
      clear_area.mutable_id()->set_id(object_id);
      PbPolygon* polygon = clear_area.mutable_polygon();
      ACHECK(polygon != nullptr);
      const tinyxml2::XMLElement* outline_node =
          sub_node->FirstChildElement("outline");
      if (outline_node == nullptr) {
        std::string err_msg = "Error parse cleararea outline";
        return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
      }
      RETURN_IF_ERROR(UtilXmlParser::ParseOutline(*outline_node, polygon));
      clear_areas->emplace_back(clear_area);
    }
    sub_node = sub_node->NextSiblingElement("object");
  }
 
  return Status::OK();
}

ParseCrosswalks()

Status apollo::hdmap::adapter::ObjectsXmlParser::ParseCrosswalks ( const tinyxml2::XMLElement &  xml_node, std::vector< PbCrosswalk > *  crosswalks  )

static

在文件 objects_xml_parser.cc 第 26 行定义.

                                                                             {
  CHECK_NOTNULL(crosswalks);
  const tinyxml2::XMLElement* sub_node = xml_node.FirstChildElement("object");
  while (sub_node) {
    std::string object_type;
    std::string object_id;
    int checker =
        UtilXmlParser::QueryStringAttribute(*sub_node, "type", &object_type);
    checker += UtilXmlParser::QueryStringAttribute(*sub_node, "id", &object_id);
    if (checker != tinyxml2::XML_SUCCESS) {
      std::string err_msg = "Error parse object type.";
      return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
    }
 
    if (object_type == "crosswalk") {
      PbCrosswalk crosswalk;
      crosswalk.mutable_id()->set_id(object_id);
      PbPolygon* polygon = crosswalk.mutable_polygon();
      const tinyxml2::XMLElement* outline_node =
          sub_node->FirstChildElement("outline");
      if (outline_node == nullptr) {
        std::string err_msg = "Error parse crosswalk outline";
        return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
      }
      RETURN_IF_ERROR(UtilXmlParser::ParseOutline(*outline_node, polygon));
      crosswalks->emplace_back(crosswalk);
    }
    sub_node = sub_node->NextSiblingElement("object");
  }
  return Status::OK();
}

ParseObjects()

Status apollo::hdmap::adapter::ObjectsXmlParser::ParseObjects ( const tinyxml2::XMLElement &  xml_node, ObjectInternal *  objects  )

static

在文件 objects_xml_parser.cc 第 405 行定义.

                                                               {
  CHECK_NOTNULL(objects);
 
  // objects
  auto sub_node = xml_node.FirstChildElement("objects");
  if (sub_node != nullptr) {
    // rsus
    RETURN_IF_ERROR(ObjectsXmlParser::ParseRSUs(*sub_node, &objects->rsus));
  }
 
  return Status::OK();
}

ParseParkingSpaces()

Status apollo::hdmap::adapter::ObjectsXmlParser::ParseParkingSpaces ( const tinyxml2::XMLElement &  xml_node, std::vector< PbParkingSpace > *  parking_spaces  )

static

在文件 objects_xml_parser.cc 第 172 行定义.

                                               {
  CHECK_NOTNULL(parking_spaces);
  const tinyxml2::XMLElement* sub_node = xml_node.FirstChildElement("object");
  while (sub_node) {
    std::string object_type;
    std::string object_id;
    int checker =
        UtilXmlParser::QueryStringAttribute(*sub_node, "type", &object_type);
    checker += UtilXmlParser::QueryStringAttribute(*sub_node, "id", &object_id);
    if (checker != tinyxml2::XML_SUCCESS) {
      std::string err_msg = "Error parse object type.";
      return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
    }
 
    if (object_type == "parkingSpace") {
      PbParkingSpace parking_space;
      parking_space.mutable_id()->set_id(object_id);
 
      double heading = 0.0;
      checker = sub_node->QueryDoubleAttribute("heading", &heading);
      if (checker != tinyxml2::XML_SUCCESS) {
        std::string err_msg = "Error parse parking space heading.";
        return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
      }
      parking_space.set_heading(heading);
 
      PbPolygon* polygon = parking_space.mutable_polygon();
      const auto* outline_node = sub_node->FirstChildElement("outline");
      if (outline_node == nullptr) {
        std::string err_msg = "Error parse parking space outline";
        return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
      }
      RETURN_IF_ERROR(UtilXmlParser::ParseOutline(*outline_node, polygon));
      parking_spaces->emplace_back(parking_space);
    }
    sub_node = sub_node->NextSiblingElement("object");
  }
  return Status::OK();
}

ParsePassage()

Status apollo::hdmap::adapter::ObjectsXmlParser::ParsePassage ( const tinyxml2::XMLElement &  xml_node, PbPassageGroup *  passage_group  )

static

在文件 objects_xml_parser.cc 第 279 行定义.

                                                                     {
  CHECK_NOTNULL(passage_group);
 
  auto sub_node = xml_node.FirstChildElement("passage");
  while (sub_node) {
    std::string object_type;
    int checker =
        UtilXmlParser::QueryStringAttribute(*sub_node, "type", &object_type);
    if (checker != tinyxml2::XML_SUCCESS) {
      std::string err_msg = "Error parse object type.";
      return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
    }
 
    auto passage = passage_group->add_passage();
    PbPassageType pb_passage_type;
    RETURN_IF_ERROR(ToPassageType(object_type, &pb_passage_type));
    passage->set_type(pb_passage_type);
 
    std::vector<std::string> passage_node_ids;
    RETURN_IF_ERROR(ParsePassageIds(*sub_node, "laneID", &passage_node_ids));
    for (auto id : passage_node_ids) {
      passage->add_lane_id()->set_id(id);
    }
 
    RETURN_IF_ERROR(ParsePassageIds(*sub_node, "signalID", &passage_node_ids));
    for (auto id : passage_node_ids) {
      passage->add_signal_id()->set_id(id);
    }
 
    RETURN_IF_ERROR(ParsePassageIds(*sub_node, "yieldlID", &passage_node_ids));
    for (auto id : passage_node_ids) {
      passage->add_yield_id()->set_id(id);
    }
 
    RETURN_IF_ERROR(
        ParsePassageIds(*sub_node, "stopSignID", &passage_node_ids));
    for (auto id : passage_node_ids) {
      passage->add_stop_sign_id()->set_id(id);
    }
 
    sub_node = sub_node->NextSiblingElement("passage");
  }
 
  return Status::OK();
}

ParsePassageGroup()

Status apollo::hdmap::adapter::ObjectsXmlParser::ParsePassageGroup ( const tinyxml2::XMLElement &  xml_node, PbPNCJunction *  pnc_junction  )

static

在文件 objects_xml_parser.cc 第 254 行定义.

                                                                        {
  CHECK_NOTNULL(pnc_junction);
 
  auto sub_node = xml_node.FirstChildElement("passageGroup");
  while (sub_node) {
    std::string object_id;
    std::string object_type;
    PbPassageGroup* passage_group = pnc_junction->add_passage_group();
    int checker =
        UtilXmlParser::QueryStringAttribute(*sub_node, "id", &object_id);
    if (checker != tinyxml2::XML_SUCCESS) {
      std::string err_msg = "Error parse object type.";
      return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
    }
    passage_group->mutable_id()->set_id(object_id);
 
    RETURN_IF_ERROR(ParsePassage(*sub_node, passage_group));
 
    sub_node = sub_node->NextSiblingElement("passageGroup");
  }
 
  return Status::OK();
}

ParsePassageIds()

Status apollo::hdmap::adapter::ObjectsXmlParser::ParsePassageIds ( const tinyxml2::XMLElement &  xml_node, const std::string &  child_node_name, std::vector< std::string > *  passage_node_ids  )

static

在文件 objects_xml_parser.cc 第 326 行定义.

                                            {
  CHECK_NOTNULL(passage_node_ids);
 
  passage_node_ids->clear();
  auto sub_node = xml_node.FirstChildElement(child_node_name.c_str());
  while (sub_node) {
    std::string object_id;
    int checker =
        UtilXmlParser::QueryStringAttribute(*sub_node, "id", &object_id);
    if (checker != tinyxml2::XML_SUCCESS) {
      std::string err_msg = "Error parse passage lane id.";
      return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
    }
    passage_node_ids->push_back(object_id);
 
    sub_node = sub_node->NextSiblingElement(child_node_name.c_str());
  }
 
  return Status::OK();
}

ParsePNCJunctions()

Status apollo::hdmap::adapter::ObjectsXmlParser::ParsePNCJunctions ( const tinyxml2::XMLElement &  xml_node, std::vector< PbPNCJunction > *  pnc_junctions  )

static

在文件 objects_xml_parser.cc 第 214 行定义.

                                             {
  CHECK_NOTNULL(pnc_junctions);
 
  const tinyxml2::XMLElement* sub_node = xml_node.FirstChildElement("object");
  while (sub_node) {
    std::string object_type;
    std::string object_id;
    int checker =
        UtilXmlParser::QueryStringAttribute(*sub_node, "type", &object_type);
    checker += UtilXmlParser::QueryStringAttribute(*sub_node, "id", &object_id);
    if (checker != tinyxml2::XML_SUCCESS) {
      std::string err_msg = "Error parse object type.";
      return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
    }
 
    if (object_type == "PNCJunction") {
      PbPNCJunction pnc_junction;
      pnc_junction.mutable_id()->set_id(object_id);
 
      PbPolygon* polygon = pnc_junction.mutable_polygon();
      const auto* outline_node = sub_node->FirstChildElement("outline");
      if (outline_node == nullptr) {
        std::string err_msg = "Error parse pnc junction outline";
        return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
      }
      RETURN_IF_ERROR(UtilXmlParser::ParseOutline(*outline_node, polygon));
 
      RETURN_IF_ERROR(ParsePassageGroup(*sub_node, &pnc_junction));
 
      pnc_junctions->emplace_back(pnc_junction);
    }
 
    sub_node = sub_node->NextSiblingElement("object");
  }
 
  return Status::OK();
}

ParseRSUs()

Status apollo::hdmap::adapter::ObjectsXmlParser::ParseRSUs ( const tinyxml2::XMLElement &  xml_node, std::vector< RSUInternal > *  rsus  )

static

在文件 objects_xml_parser.cc 第 365 行定义.

                                  {
  CHECK_NOTNULL(rsus);
 
  auto rsu_node = xml_node.FirstChildElement("object");
  while (rsu_node) {
    std::string object_type;
    std::string object_id;
    int checker =
        UtilXmlParser::QueryStringAttribute(*rsu_node, "type", &object_type);
    checker +=
        UtilXmlParser::QueryStringAttribute(*rsu_node, "id", &object_id);
    if (checker != tinyxml2::XML_SUCCESS) {
      std::string err_msg = "Error parse rsu type.";
      return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
    }
 
    if (object_type == "rsu") {
      std::string junction_id;
      checker = UtilXmlParser::QueryStringAttribute(*rsu_node,
                                            "junctionID", &junction_id);
      if (checker != tinyxml2::XML_SUCCESS) {
        std::string err_msg = "Error parse rsu junction id.";
        return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
      }
 
      RSUInternal rsu;
      rsu.rsu.mutable_id()->set_id(object_id);
      rsu.rsu.mutable_junction_id()->set_id(junction_id);
      rsu.id = object_id;
      rsus->emplace_back(rsu);
 
      rsu_node = rsu_node->NextSiblingElement("object");
    }
  }
 
  return Status::OK();
}

ParseSpeedBumps()

Status apollo::hdmap::adapter::ObjectsXmlParser::ParseSpeedBumps ( const tinyxml2::XMLElement &  xml_node, std::vector< PbSpeedBump > *  speed_bumps  )

static

在文件 objects_xml_parser.cc 第 96 行定义.

                                         {
  CHECK_NOTNULL(speed_bumps);
  const tinyxml2::XMLElement* object_node =
      xml_node.FirstChildElement("object");
  while (object_node) {
    std::string object_type;
    std::string object_id;
    int checker =
        UtilXmlParser::QueryStringAttribute(*object_node, "id", &object_id);
    checker +=
        UtilXmlParser::QueryStringAttribute(*object_node, "type", &object_type);
    if (checker != tinyxml2::XML_SUCCESS) {
      std::string err_msg = "Error parse object type.";
      return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
    }
 
    if (object_type == "speedBump") {
      PbSpeedBump speed_bump;
      const tinyxml2::XMLElement* sub_node =
          object_node->FirstChildElement("geometry");
      speed_bump.mutable_id()->set_id(object_id);
      while (sub_node) {
        PbCurve* curve = speed_bump.add_position();
        PbCurveSegment* curve_segment = curve->add_segment();
        RETURN_IF_ERROR(UtilXmlParser::ParseGeometry(*sub_node, curve_segment));
        sub_node = sub_node->NextSiblingElement("geometry");
      }
      if (speed_bump.position().empty()) {
        std::string err_msg = "Error speed bump miss stop line.";
        return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
      }
      speed_bumps->emplace_back(speed_bump);
    }
    object_node = object_node->NextSiblingElement("object");
  }
  return Status::OK();
}

ParseStopLines()

Status apollo::hdmap::adapter::ObjectsXmlParser::ParseStopLines ( const tinyxml2::XMLElement &  xml_node, std::vector< StopLineInternal > *  stop_lines  )

static

在文件 objects_xml_parser.cc 第 136 行定义.

                                             {
  CHECK_NOTNULL(stop_lines);
  const tinyxml2::XMLElement* object_node =
      xml_node.FirstChildElement("object");
  while (object_node) {
    std::string object_type;
    std::string object_id;
    int checker =
        UtilXmlParser::QueryStringAttribute(*object_node, "id", &object_id);
    checker +=
        UtilXmlParser::QueryStringAttribute(*object_node, "type", &object_type);
    if (checker != tinyxml2::XML_SUCCESS) {
      std::string err_msg = "Error parse object type.";
      return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
    }
 
    if (object_type == "stopline") {
      StopLineInternal stop_line;
      stop_line.id = object_id;
      PbCurveSegment* curve_segment = stop_line.curve.add_segment();
      ACHECK(curve_segment != nullptr);
      const auto sub_node = object_node->FirstChildElement("geometry");
      if (sub_node == nullptr) {
        std::string err_msg = "Error parse stopline geometry";
        return Status(apollo::common::ErrorCode::HDMAP_DATA_ERROR, err_msg);
      }
      RETURN_IF_ERROR(UtilXmlParser::ParseGeometry(*sub_node, curve_segment));
      stop_lines->emplace_back(stop_line);
    }
    object_node = object_node->NextSiblingElement("object");
  }
  return Status::OK();
}

ToPassageType()

Status apollo::hdmap::adapter::ObjectsXmlParser::ToPassageType ( const std::string &  type, PbPassageType *  passage_type  )

static

在文件 objects_xml_parser.cc 第 349 行定义.

                                                                    {
  CHECK_NOTNULL(passage_type);
 
  std::string upper_str = UtilXmlParser::ToUpper(type);
  if (upper_str == "ENTRANCE") {
    *passage_type = apollo::hdmap::Passage_Type_ENTRANCE;
  } else if (upper_str == "EXIT") {
    *passage_type = apollo::hdmap::Passage_Type_EXIT;
  } else {
    *passage_type = apollo::hdmap::Passage_Type_UNKNOWN;
  }
 
  return Status::OK();
}

---

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

• modules/map/hdmap/adapter/xml_parser/objects_xml_parser.h
• modules/map/hdmap/adapter/xml_parser/objects_xml_parser.cc