SUMO - Simulation of Urban MObility
NWWriter_XML.cpp
Go to the documentation of this file.
1 /****************************************************************************/
9 // Exporter writing networks using XML (native input) format
10 /****************************************************************************/
11 // SUMO, Simulation of Urban MObility; see http://sumo-sim.org/
12 // Copyright (C) 2001-2014 DLR (http://www.dlr.de/) and contributors
13 /****************************************************************************/
14 //
15 // This file is part of SUMO.
16 // SUMO is free software: you can redistribute it and/or modify
17 // it under the terms of the GNU General Public License as published by
18 // the Free Software Foundation, either version 3 of the License, or
19 // (at your option) any later version.
20 //
21 /****************************************************************************/
22 
23 
24 // ===========================================================================
25 // included modules
26 // ===========================================================================
27 #ifdef _MSC_VER
28 #include <windows_config.h>
29 #else
30 #include <config.h>
31 #endif
32 #include <algorithm>
34 #include <netbuild/NBEdge.h>
35 #include <netbuild/NBEdgeCont.h>
36 #include <netbuild/NBNode.h>
37 #include <netbuild/NBNodeCont.h>
38 #include <netbuild/NBNetBuilder.h>
39 #include <utils/common/ToString.h>
44 #include "NWFrame.h"
45 #include "NWWriter_SUMO.h"
46 #include "NWWriter_XML.h"
47 
48 #ifdef CHECK_MEMORY_LEAKS
49 #include <foreign/nvwa/debug_new.h>
50 #endif // CHECK_MEMORY_LEAKS
51 
52 
53 
54 // ===========================================================================
55 // method definitions
56 // ===========================================================================
57 // ---------------------------------------------------------------------------
58 // static methods
59 // ---------------------------------------------------------------------------
60 void
62  // check whether plain-output files shall be generated
63  if (oc.isSet("plain-output-prefix")) {
64  writeNodes(oc, nb.getNodeCont());
67  }
68  if (oc.isSet("junctions.join-output")) {
70  }
71  if (oc.isSet("street-sign-output")) {
72  writeStreetSigns(oc, nb.getEdgeCont());
73  }
74 }
75 
76 
77 void
80  bool useGeo = oc.exists("proj.plain-geo") && oc.getBool("proj.plain-geo");
81  if (useGeo && !gch.usingGeoProjection()) {
82  WRITE_WARNING("Ignoring option \"proj.plain-geo\" because no geo-conversion has been defined");
83  useGeo = false;
84  }
85  const bool geoAccuracy = useGeo || gch.usingInverseGeoProjection();
86 
87  OutputDevice& device = OutputDevice::getDevice(oc.getString("plain-output-prefix") + ".nod.xml");
88  device.writeXMLHeader("nodes", NWFrame::MAJOR_VERSION + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://sumo-sim.org/xsd/nodes_file.xsd\"");
89 
90  // write network offsets and projection to allow reconstruction of original coordinates
91  if (!useGeo) {
93  }
94 
95  // write nodes
96  for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
97  NBNode* n = (*i).second;
98  device.openTag(SUMO_TAG_NODE);
99  device.writeAttr(SUMO_ATTR_ID, n->getID());
100  // write position
101  Position pos = n->getPosition();
102  if (useGeo) {
103  gch.cartesian2geo(pos);
104  }
105  if (geoAccuracy) {
107  }
108  NWFrame::writePositionLong(pos, device);
109  if (geoAccuracy) {
110  device.setPrecision();
111  }
112 
113  device.writeAttr(SUMO_ATTR_TYPE, toString(n->getType()));
114  if (n->isTLControlled()) {
115  const std::set<NBTrafficLightDefinition*>& tlss = n->getControllingTLS();
116  // set may contain multiple programs for the same id.
117  // make sure ids are unique and sorted
118  std::set<std::string> tlsIDs;
119  std::set<std::string> controlledInnerEdges;
120  for (std::set<NBTrafficLightDefinition*>::const_iterator it_tl = tlss.begin(); it_tl != tlss.end(); it_tl++) {
121  tlsIDs.insert((*it_tl)->getID());
122  std::vector<std::string> cie = (*it_tl)->getControlledInnerEdges();
123  controlledInnerEdges.insert(cie.begin(), cie.end());
124  }
125  std::vector<std::string> sortedIDs(tlsIDs.begin(), tlsIDs.end());
126  sort(sortedIDs.begin(), sortedIDs.end());
127  device.writeAttr(SUMO_ATTR_TLID, sortedIDs);
128  if (controlledInnerEdges.size() > 0) {
129  std::vector<std::string> sortedCIEs(controlledInnerEdges.begin(), controlledInnerEdges.end());
130  sort(sortedCIEs.begin(), sortedCIEs.end());
131  device.writeAttr(SUMO_ATTR_CONTROLLED_INNER, joinToString(sortedCIEs, " "));
132  }
133  }
134  if (n->hasCustomShape()) {
135  device.writeAttr(SUMO_ATTR_SHAPE, n->getShape());
136  }
137  device.closeTag();
138  }
139  device.close();
140 }
141 
142 
143 void
145  const GeoConvHelper& gch = GeoConvHelper::getFinal();
146  bool useGeo = oc.exists("proj.plain-geo") && oc.getBool("proj.plain-geo");
147  const bool geoAccuracy = useGeo || gch.usingInverseGeoProjection();
148 
149  OutputDevice& edevice = OutputDevice::getDevice(oc.getString("plain-output-prefix") + ".edg.xml");
150  edevice.writeXMLHeader("edges", NWFrame::MAJOR_VERSION + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://sumo-sim.org/xsd/edges_file.xsd\"");
151  OutputDevice& cdevice = OutputDevice::getDevice(oc.getString("plain-output-prefix") + ".con.xml");
152  cdevice.writeXMLHeader("connections", NWFrame::MAJOR_VERSION + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://sumo-sim.org/xsd/connections_file.xsd\"");
153  bool noNames = !oc.getBool("output.street-names");
154  for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) {
155  // write the edge itself to the edges-files
156  NBEdge* e = (*i).second;
157  edevice.openTag(SUMO_TAG_EDGE);
158  edevice.writeAttr(SUMO_ATTR_ID, e->getID());
159  edevice.writeAttr(SUMO_ATTR_FROM, e->getFromNode()->getID());
160  edevice.writeAttr(SUMO_ATTR_TO, e->getToNode()->getID());
161  if (!noNames && e->getStreetName() != "") {
163  }
165  // write the type if given
166  if (e->getTypeID() != "") {
167  edevice.writeAttr(SUMO_ATTR_TYPE, e->getTypeID());
168  }
170  if (!e->hasLaneSpecificSpeed()) {
171  edevice.writeAttr(SUMO_ATTR_SPEED, e->getSpeed());
172  }
173  // write non-default geometry
174  if (!e->hasDefaultGeometry()) {
175  PositionVector geom = e->getGeometry();
176  if (useGeo) {
177  for (int i = 0; i < (int) geom.size(); i++) {
178  gch.cartesian2geo(geom[i]);
179  }
180  }
181  if (geoAccuracy) {
183  }
184  edevice.writeAttr(SUMO_ATTR_SHAPE, geom);
185  if (geoAccuracy) {
186  edevice.setPrecision();
187  }
188  }
189  // write the spread type if not default ("right")
192  }
193  // write the length if it was specified
194  if (e->hasLoadedLength()) {
196  }
197  // some attributes can be set by edge default or per lane. Write as default if possible (efficiency)
199  edevice.writeAttr(SUMO_ATTR_WIDTH, e->getLaneWidth());
200  }
203  }
204  if (!e->needsLaneSpecificOutput()) {
205  edevice.closeTag();
206  } else {
207  for (unsigned int i = 0; i < e->getLanes().size(); ++i) {
208  const NBEdge::Lane& lane = e->getLanes()[i];
209  edevice.openTag(SUMO_TAG_LANE);
210  edevice.writeAttr(SUMO_ATTR_INDEX, i);
211  // write allowed lanes
214  // write other attributes
216  edevice.writeAttr(SUMO_ATTR_WIDTH, lane.width);
217  }
219  edevice.writeAttr(SUMO_ATTR_ENDOFFSET, lane.endOffset);
220  }
221  if (e->hasLaneSpecificSpeed()) {
222  edevice.writeAttr(SUMO_ATTR_SPEED, lane.speed);
223  }
224  edevice.closeTag();
225  }
226  edevice.closeTag();
227  }
228  // write this edge's connections to the connections-files
230  const std::vector<NBEdge::Connection> connections = e->getConnections();
231  for (std::vector<NBEdge::Connection>::const_iterator c = connections.begin(); c != connections.end(); ++c) {
232  NWWriter_SUMO::writeConnection(cdevice, *e, *c, false, NWWriter_SUMO::PLAIN);
233  }
234  if (connections.size() > 0) {
235  cdevice << "\n";
236  }
237  }
238 
239  // write loaded prohibitions to the connections-file
240  for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
241  NWWriter_SUMO::writeProhibitions(cdevice, i->second->getProhibitions());
242  }
243  // write pedestrian crossings to the connections-file
244  for (std::map<std::string, NBNode*>::const_iterator it_node = nc.begin(); it_node != nc.end(); ++it_node) {
245  const std::vector<NBNode::Crossing>& crossings = (*it_node).second->getCrossings();
246  for (std::vector<NBNode::Crossing>::const_iterator it = crossings.begin(); it != crossings.end(); it++) {
247  cdevice.openTag(SUMO_TAG_CROSSING);
248  cdevice.writeAttr(SUMO_ATTR_NODE, (*it_node).second->getID());
249  cdevice.writeAttr(SUMO_ATTR_EDGES, (*it).edges);
250  cdevice.writeAttr(SUMO_ATTR_PRIORITY, (*it).priority);
251  if ((*it).width != NBNode::DEFAULT_CROSSING_WIDTH) {
252  cdevice.writeAttr(SUMO_ATTR_WIDTH, (*it).width);
253  }
254  cdevice.closeTag();
255  }
256  }
257  edevice.close();
258  cdevice.close();
259 }
260 
261 
262 void
264  OutputDevice& device = OutputDevice::getDevice(oc.getString("plain-output-prefix") + ".tll.xml");
265  device.writeXMLHeader("tlLogics", NWFrame::MAJOR_VERSION + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://sumo-sim.org/xsd/tllogic_file.xsd\"");
267  // we also need to remember the associations between tlLogics and connections
268  // since the information in con.xml is insufficient
269  for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) {
270  NBEdge* e = (*i).second;
271  // write this edge's tl-controlled connections
272  const std::vector<NBEdge::Connection> connections = e->getConnections();
273  for (std::vector<NBEdge::Connection>::const_iterator c = connections.begin(); c != connections.end(); ++c) {
274  if (c->tlID != "") {
275  NWWriter_SUMO::writeConnection(device, *e, *c, false, NWWriter_SUMO::TLL);
276  }
277  }
278  }
279  device.close();
280 }
281 
282 
283 void
285  OutputDevice& device = OutputDevice::getDevice(oc.getString("junctions.join-output"));
286  device.writeXMLHeader("nodes", NWFrame::MAJOR_VERSION + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://sumo-sim.org/xsd/nodes_file.xsd\"");
287  const std::vector<std::set<std::string> >& clusters = nc.getJoinedClusters();
288  for (std::vector<std::set<std::string> >::const_iterator it = clusters.begin(); it != clusters.end(); it++) {
289  assert((*it).size() > 0);
290  device.openTag(SUMO_TAG_JOIN);
291  // prepare string
292  std::ostringstream oss;
293  for (std::set<std::string>::const_iterator it_id = it->begin(); it_id != it->end(); it_id++) {
294  oss << *it_id << " ";
295  }
296  // remove final space
297  std::string ids = oss.str();
298  device.writeAttr(SUMO_ATTR_NODES, ids.substr(0, ids.size() - 1));
299  device.closeTag();
300  }
301  device.close();
302 }
303 
304 
305 void
307  OutputDevice& device = OutputDevice::getDevice(oc.getString("street-sign-output"));
308  device.writeXMLHeader("pois", NWFrame::MAJOR_VERSION + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://sumo-sim.org/xsd/poi_file.xsd\"");
309  for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) {
310  NBEdge* e = (*i).second;
311  const std::vector<NBSign>& signs = e->getSigns();
312  for (std::vector<NBSign>::const_iterator it = signs.begin(); it != signs.end(); ++it) {
313  it->writeAsPOI(device, e);
314  }
315  }
316  device.close();
317 }
318 /****************************************************************************/
319 
The information about how to spread the lanes from the given position.
const std::vector< std::set< std::string > > & getJoinedClusters() const
gets all joined clusters (see doc for myClusters2Join)
Definition: NBNodeCont.h:318
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:257
void close()
Closes the device and removes it from the dictionary.
const std::string & getTypeID() const
Definition: NBEdge.h:885
SUMOReal endOffset
This lane's offset to the intersection begin.
Definition: NBEdge.h:136
void cartesian2geo(Position &cartesian) const
Converts the given cartesian (shifted) position to its geo (lat/long) representation.
a list of node ids, used for controlling joining
static const SUMOReal UNSPECIFIED_WIDTH
unspecified lane width
Definition: NBEdge.h:201
static void writeStreetSigns(const OptionsCont &oc, NBEdgeCont &ec)
Writes street signs as POIs to file.
bool hasDefaultGeometry() const
Returns whether the geometry consists only of the node positions.
Definition: NBEdge.cpp:379
A container for traffic light definitions and built programs.
bool hasLaneSpecificEndOffset() const
whether lanes differ in offset
Definition: NBEdge.cpp:1392
static void writeLocation(OutputDevice &into)
writes the location element
bool isTLControlled() const
Returns whether this node is controlled by any tls.
Definition: NBNode.h:295
const std::vector< NBEdge::Lane > & getLanes() const
Returns the lane definitions.
Definition: NBEdge.h:503
#define GEO_OUTPUT_ACCURACY
Definition: config.h:16
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
The representation of a single edge during network building.
Definition: NBEdge.h:71
static std::string escapeXML(const std::string &orig)
Replaces the standard escapes by their XML entities.
static void writeJoinedJunctions(const OptionsCont &oc, NBNodeCont &nc)
Writes the joined-juncionts to file.
static void writeProhibitions(OutputDevice &into, const NBConnectionProhibits &prohibitions)
writes the given prohibitions
SUMOReal getLaneWidth() const
Returns the default width of lanes of this edge.
Definition: NBEdge.h:446
static void writeTrafficLights(OutputDevice &into, const NBTrafficLightLogicCont &tllCont)
writes the traffic light logics to the given device
static const SUMOReal UNSPECIFIED_OFFSET
unspecified lane offset
Definition: NBEdge.h:203
static void writePermissions(OutputDevice &into, SVCPermissions permissions)
writes allowed disallowed attributes if needed;
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:200
const std::vector< NBSign > & getSigns() const
Definition: NBEdge.h:1045
bool writeXMLHeader(const std::string &rootElement, const std::string &attrs="", const std::string &comment="")
Writes an XML header with optional configuration.
SUMOReal speed
The speed allowed on this lane.
Definition: NBEdge.h:130
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
SUMOReal getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn't set.
Definition: NBEdge.h:412
An (internal) definition of a single lane of an edge.
Definition: NBEdge.h:123
const std::string & getID() const
Returns the id.
Definition: Named.h:60
SVCPermissions permissions
List of vehicle types that are allowed on this lane.
Definition: NBEdge.h:132
void setPrecision(unsigned int precision=OUTPUT_ACCURACY)
Sets the precison or resets it to default.
const Position & getPosition() const
Returns the position of this node.
Definition: NBNode.h:232
static void writeNodes(const OptionsCont &oc, NBNodeCont &nc)
Writes the nodes file.
std::map< std::string, NBEdge * >::const_iterator end() const
Returns the pointer to the end of the stored edges.
Definition: NBEdgeCont.h:198
bool usingGeoProjection() const
Returns whether a transformation from geo to metric coordinates will be performed.
static methods for processing the coordinates conversion for the current net
Definition: GeoConvHelper.h:59
const std::set< NBTrafficLightDefinition * > & getControllingTLS() const
Returns the traffic lights that were assigned to this node.
Definition: NBNode.h:309
bool hasLaneSpecificSpeed() const
whether lanes differ in speed
Definition: NBEdge.cpp:1381
the edges of a route
int getPriority() const
Returns the priority of the edge.
Definition: NBEdge.h:352
SVCPermissions preferred
List of vehicle types that are preferred on this lane.
Definition: NBEdge.h:134
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:46
NBEdgeCont & getEdgeCont()
Returns the edge container.
Definition: NBNetBuilder.h:154
A list of positions.
static void writeTrafficLights(const OptionsCont &oc, NBTrafficLightLogicCont &tc, NBEdgeCont &ec)
Writes the traffic lights file.
unsigned int getNumLanes() const
Returns the number of lanes.
Definition: NBEdge.h:344
SumoXMLNodeType getType() const
Returns the type of this node.
Definition: NBNode.h:269
bool hasLoadedLength() const
Returns whether a length was set explicitly.
Definition: NBEdge.h:420
Storage for edges, including some functionality operating on multiple edges.
Definition: NBEdgeCont.h:66
bool needsLaneSpecificOutput() const
whether at least one lane has values differing from the edges values
Definition: NBEdge.cpp:1403
static void writeNetwork(const OptionsCont &oc, NBNetBuilder &nb)
Writes the network into XML-files (nodes, edges, connections, traffic lights)
static void writePositionLong(const Position &pos, OutputDevice &dev)
Writes the given position to device in long format (one attribute per dimension)
Definition: NWFrame.cpp:152
std::map< std::string, NBNode * >::const_iterator end() const
Returns the pointer to the end of the stored nodes.
Definition: NBNodeCont.h:142
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
Definition: ToString.h:53
const PositionVector & getShape() const
retrieve the junction shape
Definition: NBNode.cpp:1397
SUMOReal getEndOffset() const
Returns the offset to the destination node.
Definition: NBEdge.h:471
std::map< std::string, NBEdge * >::const_iterator begin() const
Returns the pointer to the begin of the stored edges.
Definition: NBEdgeCont.h:190
NBNode * getToNode() const
Returns the destination node of the edge.
Definition: NBEdge.h:368
static void writeEdgesAndConnections(const OptionsCont &oc, NBNodeCont &nc, NBEdgeCont &ec)
Writes the edges and connections files.
NBNodeCont & getNodeCont()
Returns the node container.
Definition: NBNetBuilder.h:162
Instance responsible for building networks.
Definition: NBNetBuilder.h:113
static OutputDevice & getDevice(const std::string &name)
Returns the described OutputDevice.
const PositionVector & getGeometry() const
Returns the geometry of the edge.
Definition: NBEdge.h:521
A storage for options typed value containers)
Definition: OptionsCont.h:108
static const SUMOReal DEFAULT_CROSSING_WIDTH
default width of pedetrian crossings
Definition: NBNode.h:189
void sortOutgoingConnectionsByIndex()
sorts the outgoing connections by their from-lane-index and their to-lane-index
Definition: NBEdge.cpp:817
NBTrafficLightLogicCont & getTLLogicCont()
Returns the traffic light logics container.
Definition: NBNetBuilder.h:178
static void writePreferences(OutputDevice &into, SVCPermissions preferred)
writes allowed disallowed attributes if needed;
static const GeoConvHelper & getFinal()
the coordinate transformation for writing the location element and for tracking the original coordina...
LaneSpreadFunction getLaneSpreadFunction() const
Returns how this edge's lanes' lateral offset is computed.
Definition: NBEdge.h:597
Represents a single node (junction) during network building.
Definition: NBNode.h:75
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=OUTPUT_ACCURACY)
Definition: ToString.h:153
bool hasLaneSpecificWidth() const
whether lanes differ in width
Definition: NBEdge.cpp:1370
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:71
bool closeTag()
Closes the most recently opened tag.
SUMOReal getSpeed() const
Returns the speed allowed on this edge.
Definition: NBEdge.h:428
Container for nodes during the netbuilding process.
Definition: NBNodeCont.h:64
bool usingInverseGeoProjection() const
Returns the information whether an inverse transformation will happen.
const std::string & getStreetName() const
Returns the street name of this edge.
Definition: NBEdge.h:458
const std::vector< Connection > & getConnections() const
Returns the connections.
Definition: NBEdge.h:747
static const std::string MAJOR_VERSION
The version number for written files.
Definition: NWFrame.h:77
std::map< std::string, NBNode * >::const_iterator begin() const
Returns the pointer to the begin of the stored nodes.
Definition: NBNodeCont.h:134
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
bool exists(const std::string &name) const
Returns the information whether the named option is known.
bool hasCustomShape()
return whether the shape was set by the user
Definition: NBNode.h:483
SUMOReal width
This lane's width.
Definition: NBEdge.h:138
static void writeConnection(OutputDevice &into, const NBEdge &from, const NBEdge::Connection &c, bool includeInternal, ConnectionStyle style=SUMONET)
Writes connections outgoing from the given edge (also used in NWWriter_XML)
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
NBNode * getFromNode() const
Returns the origin node of the edge.
Definition: NBEdge.h:360