Eclipse SUMO - Simulation of Urban MObility
NWWriter_XML.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2022 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials are made available under the
5 // terms of the Eclipse Public License 2.0 which is available at
6 // https://www.eclipse.org/legal/epl-2.0/
7 // This Source Code may also be made available under the following Secondary
8 // Licenses when the conditions for such availability set forth in the Eclipse
9 // Public License 2.0 are satisfied: GNU General Public License, version 2
10 // or later which is available at
11 // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 /****************************************************************************/
21 // Exporter writing networks using XML (native input) format
22 /****************************************************************************/
23 #include <config.h>
24 #include <algorithm>
26 #include <netbuild/NBEdge.h>
27 #include <netbuild/NBEdgeCont.h>
28 #include <netbuild/NBNode.h>
29 #include <netbuild/NBNodeCont.h>
30 #include <netbuild/NBNetBuilder.h>
31 #include <netbuild/NBPTLineCont.h>
32 #include <netbuild/NBParking.h>
33 #include <utils/common/ToString.h>
38 #include "NWFrame.h"
39 #include "NWWriter_SUMO.h"
40 #include "NWWriter_XML.h"
41 
42 
43 
44 // ===========================================================================
45 // method definitions
46 // ===========================================================================
47 // ---------------------------------------------------------------------------
48 // static methods
49 // ---------------------------------------------------------------------------
50 void
52  // check whether plain-output files shall be generated
53  if (oc.isSet("plain-output-prefix")) {
54  writeNodes(oc, nb.getNodeCont());
55  if (nb.getTypeCont().size() > 0) {
56  writeTypes(oc, nb.getTypeCont());
57  }
60  }
61  if (oc.isSet("junctions.join-output")) {
63  }
64  if (oc.isSet("street-sign-output")) {
65  writeStreetSigns(oc, nb.getEdgeCont());
66  }
67  if (oc.exists("ptstop-output") && oc.isSet("ptstop-output")) {
68  writePTStops(oc, nb.getPTStopCont());
69  }
70  if (oc.exists("ptline-output") && oc.isSet("ptline-output")) {
71  writePTLines(oc, nb.getPTLineCont());
72  }
73 
74  if (oc.exists("parking-output") && oc.isSet("parking-output")) {
76  }
77  if (oc.exists("taz-output") && oc.isSet("taz-output")) {
79  }
80 }
81 
82 
83 void
86  bool useGeo = oc.exists("proj.plain-geo") && oc.getBool("proj.plain-geo");
87  if (useGeo && !gch.usingGeoProjection()) {
88  WRITE_WARNING("Ignoring option \"proj.plain-geo\" because no geo-conversion has been defined");
89  useGeo = false;
90  }
91  const bool geoAccuracy = useGeo || gch.usingInverseGeoProjection();
92 
93  OutputDevice& device = OutputDevice::getDevice(oc.getString("plain-output-prefix") + ".nod.xml");
94  std::map<SumoXMLAttr, std::string> attrs;
96  device.writeXMLHeader("nodes", "nodes_file.xsd", attrs);
97 
98  // write network offsets and projection to allow reconstruction of original coordinates
99  if (!useGeo) {
101  }
102 
103  // write nodes
104  TrafficLightType tlsDefaultType = SUMOXMLDefinitions::TrafficLightTypes.get(oc.getString("tls.default-type"));
105  for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
106  NBNode* n = (*i).second;
107  device.openTag(SUMO_TAG_NODE);
108  device.writeAttr(SUMO_ATTR_ID, n->getID());
109  // write position
110  Position pos = n->getPosition();
111  if (useGeo) {
112  gch.cartesian2geo(pos);
113  }
114  if (geoAccuracy) {
115  device.setPrecision(gPrecisionGeo);
116  }
117  NWFrame::writePositionLong(pos, device);
118  if (geoAccuracy) {
119  device.setPrecision();
120  }
121 
122  device.writeAttr(SUMO_ATTR_TYPE, toString(n->getType()));
123  if (n->isTLControlled()) {
124  // set may contain multiple programs for the same id.
125  // make sure ids are unique and sorted
126  std::set<std::string> tlsIDs;
127  std::set<std::string> controlledInnerEdges;
128  std::string tlType = "";
130  tlsIDs.insert(tl->getID());
131  std::vector<std::string> cie = tl->getControlledInnerEdges();
132  controlledInnerEdges.insert(cie.begin(), cie.end());
133  if (tl->getType() != tlsDefaultType) {
134  tlType = toString(tl->getType());
135  }
136  }
137  std::vector<std::string> sortedIDs(tlsIDs.begin(), tlsIDs.end());
138  sort(sortedIDs.begin(), sortedIDs.end());
139  device.writeAttr(SUMO_ATTR_TLID, sortedIDs);
140  if (tlType != "") {
141  device.writeAttr(SUMO_ATTR_TLTYPE, tlType);
142  }
143  if (controlledInnerEdges.size() > 0) {
144  std::vector<std::string> sortedCIEs(controlledInnerEdges.begin(), controlledInnerEdges.end());
145  sort(sortedCIEs.begin(), sortedCIEs.end());
146  device.writeAttr(SUMO_ATTR_CONTROLLED_INNER, joinToString(sortedCIEs, " "));
147  }
148  }
149  if (n->hasCustomShape()) {
150  writeShape(device, gch, n->getShape(), SUMO_ATTR_SHAPE, useGeo, geoAccuracy);
151  }
153  device.writeAttr(SUMO_ATTR_RADIUS, n->getRadius());
154  }
155  if (n->getKeepClear() == false) {
156  device.writeAttr<bool>(SUMO_ATTR_KEEP_CLEAR, n->getKeepClear());
157  }
158  if (n->getRightOfWay() != RightOfWay::DEFAULT) {
159  device.writeAttr<std::string>(SUMO_ATTR_RIGHT_OF_WAY, toString(n->getRightOfWay()));
160  }
161  if (n->getFringeType() != FringeType::DEFAULT) {
162  device.writeAttr<std::string>(SUMO_ATTR_FRINGE, toString(n->getFringeType()));
163  }
164  if (n->getName() != "") {
165  device.writeAttr<std::string>(SUMO_ATTR_NAME, n->getName());
166  }
167  n->writeParams(device);
168  device.closeTag();
169  }
170  device.close();
171 }
172 
173 
174 void
176  OutputDevice& device = OutputDevice::getDevice(oc.getString("plain-output-prefix") + ".typ.xml");
177  std::map<SumoXMLAttr, std::string> attrs;
179  device.writeXMLHeader("types", "types_file.xsd", attrs);
180  tc.writeEdgeTypes(device);
181  device.close();
182 }
183 
184 
185 void
187  const GeoConvHelper& gch = GeoConvHelper::getFinal();
188  bool useGeo = oc.exists("proj.plain-geo") && oc.getBool("proj.plain-geo");
189  const bool geoAccuracy = useGeo || gch.usingInverseGeoProjection();
190 
191  std::map<SumoXMLAttr, std::string> attrs;
193  OutputDevice& edevice = OutputDevice::getDevice(oc.getString("plain-output-prefix") + ".edg.xml");
194  edevice.writeXMLHeader("edges", "edges_file.xsd", attrs);
195  OutputDevice& cdevice = OutputDevice::getDevice(oc.getString("plain-output-prefix") + ".con.xml");
196  cdevice.writeXMLHeader("connections", "connections_file.xsd", attrs);
197  const bool writeNames = oc.getBool("output.street-names");
198  LaneSpreadFunction defaultSpread = SUMOXMLDefinitions::LaneSpreadFunctions.get(oc.getString("default.spreadtype"));
199  for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) {
200  // write the edge itself to the edges-files
201  NBEdge* e = (*i).second;
202  edevice.openTag(SUMO_TAG_EDGE);
203  edevice.writeAttr(SUMO_ATTR_ID, e->getID());
204  edevice.writeAttr(SUMO_ATTR_FROM, e->getFromNode()->getID());
205  edevice.writeAttr(SUMO_ATTR_TO, e->getToNode()->getID());
206  if (writeNames && e->getStreetName() != "") {
208  }
210  // write the type if given
211  if (e->getTypeID() != "") {
212  edevice.writeAttr(SUMO_ATTR_TYPE, e->getTypeID());
213  }
215  if (!e->hasLaneSpecificSpeed()) {
216  edevice.writeAttr(SUMO_ATTR_SPEED, e->getSpeed());
217  }
218  // write non-default geometry
219  if (!e->hasDefaultGeometry()) {
220  writeShape(edevice, gch, e->getGeometry(), SUMO_ATTR_SHAPE, useGeo, geoAccuracy);
221  }
222  // write the spread type if not default ("right")
223  if (e->getLaneSpreadFunction() != defaultSpread) {
225  }
226  // write the length if it was specified
227  if (e->hasLoadedLength()) {
229  }
230  // some attributes can be set by edge default or per lane. Write as default if possible (efficiency)
232  edevice.writeAttr(SUMO_ATTR_WIDTH, e->getLaneWidth());
233  }
236  }
237  if (!e->hasLaneSpecificPermissions()) {
238  writePermissions(edevice, e->getPermissions(0));
239  }
242  }
243  if (e->getDistance() != 0) {
245  }
246  if (e->needsLaneSpecificOutput()) {
247  int idx = 0;
248  for (const NBEdge::Lane& lane : e->getLanes()) {
249  edevice.openTag(SUMO_TAG_LANE);
250  edevice.writeAttr(SUMO_ATTR_INDEX, idx++);
251  // write allowed lanes
252  if (e->hasLaneSpecificPermissions()) {
253  writePermissions(edevice, lane.permissions);
254  }
255  writePreferences(edevice, lane.preferred);
256  // write other attributes
257  if (lane.width != NBEdge::UNSPECIFIED_WIDTH && e->hasLaneSpecificWidth()) {
258  edevice.writeAttr(SUMO_ATTR_WIDTH, lane.width);
259  }
260  if (lane.endOffset != NBEdge::UNSPECIFIED_OFFSET && e->hasLaneSpecificEndOffset()) {
261  edevice.writeAttr(SUMO_ATTR_ENDOFFSET, lane.endOffset);
262  }
263  if (e->hasLaneSpecificSpeed()) {
264  edevice.writeAttr(SUMO_ATTR_SPEED, lane.speed);
265  }
266  if (lane.accelRamp) {
267  edevice.writeAttr(SUMO_ATTR_ACCELERATION, lane.accelRamp);
268  }
269  if (lane.customShape.size() > 0) {
270  writeShape(edevice, gch, lane.customShape, SUMO_ATTR_SHAPE, useGeo, geoAccuracy);
271  }
272  if (lane.type != "") {
273  edevice.writeAttr(SUMO_ATTR_TYPE, lane.type);
274  }
275  if (lane.changeLeft != SVCAll && lane.changeLeft != SVC_UNSPECIFIED && lane.changeLeft != SVC_IGNORING) {
276  edevice.writeAttr(SUMO_ATTR_CHANGE_LEFT, getVehicleClassNames(lane.changeLeft));
277  }
278  if (lane.changeRight != SVCAll && lane.changeRight != SVC_UNSPECIFIED && lane.changeRight != SVC_IGNORING) {
279  edevice.writeAttr(SUMO_ATTR_CHANGE_RIGHT, getVehicleClassNames(lane.changeRight));
280  }
281  if (lane.oppositeID != "") {
282  edevice.openTag(SUMO_TAG_NEIGH);
283  edevice.writeAttr(SUMO_ATTR_LANE, lane.oppositeID);
284  edevice.closeTag();
285  }
286  lane.writeParams(edevice);
287  NWWriter_SUMO::writeStopOffsets(edevice, lane.laneStopOffset);
288  edevice.closeTag();
289  }
290  }
291  e->writeParams(edevice);
292  edevice.closeTag();
293  // write this edge's connections to the connections-files
294  const std::vector<NBEdge::Connection> connections = e->getConnections();
295  if (connections.empty()) {
296  // if there are no connections and this appears to be customized, preserve the information
297  const int numOutgoing = (int)e->getToNode()->getOutgoingEdges().size();
298  if (numOutgoing > 0) {
299  const SVCPermissions inPerm = e->getPermissions();
300  SVCPermissions outPerm = 0;
301  for (auto out : e->getToNode()->getOutgoingEdges()) {
302  outPerm |= out->getPermissions();
303  }
304  if ((inPerm & outPerm) != 0 && (inPerm & outPerm) != SVC_PEDESTRIAN) {
305  cdevice.openTag(SUMO_TAG_CONNECTION);
306  cdevice.writeAttr(SUMO_ATTR_FROM, e->getID());
307  cdevice.closeTag();
308  cdevice << "\n";
309  }
310  }
311  } else {
312  for (NBEdge::Connection c : connections) {
313  if (useGeo) {
314  for (Position& p : c.customShape) {
315  gch.cartesian2geo(p);
316  }
317  }
318  NWWriter_SUMO::writeConnection(cdevice, *e, c, false, NWWriter_SUMO::PLAIN, geoAccuracy);
319  }
320  cdevice << "\n";
321  }
322  }
323  // write roundabout information to the edges-files
324  if (ec.getRoundabouts().size() > 0) {
325  edevice.lf();
327  }
328 
329  // write loaded prohibitions to the connections-file
330  for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
331  NWWriter_SUMO::writeProhibitions(cdevice, i->second->getProhibitions());
332  }
333  // write pedestrian crossings to the connections-file
334  for (std::map<std::string, NBNode*>::const_iterator it_node = nc.begin(); it_node != nc.end(); ++it_node) {
335  const std::vector<NBNode::Crossing*>& crossings = (*it_node).second->getCrossings();
336  for (auto c : crossings) {
337  cdevice.openTag(SUMO_TAG_CROSSING);
338  cdevice.writeAttr(SUMO_ATTR_NODE, (*it_node).second->getID());
339  cdevice.writeAttr(SUMO_ATTR_EDGES, c->edges);
340  cdevice.writeAttr(SUMO_ATTR_PRIORITY, c->priority);
341  if (c->customWidth != NBEdge::UNSPECIFIED_WIDTH) {
342  cdevice.writeAttr(SUMO_ATTR_WIDTH, c->customWidth);
343  }
344  if (c->customTLIndex != -1) {
345  cdevice.writeAttr(SUMO_ATTR_TLLINKINDEX, c->customTLIndex);
346  }
347  if (c->customTLIndex2 != -1) {
348  cdevice.writeAttr(SUMO_ATTR_TLLINKINDEX2, c->customTLIndex2);
349  }
350  if (c->customShape.size() != 0) {
351  writeShape(cdevice, gch, c->customShape, SUMO_ATTR_SHAPE, useGeo, geoAccuracy);
352  }
353  cdevice.closeTag();
354  }
355  }
356  // write custom walkingarea shapes to the connections file
357  for (std::map<std::string, NBNode*>::const_iterator it_node = nc.begin(); it_node != nc.end(); ++it_node) {
358  for (const auto& wacs : it_node->second->getWalkingAreaCustomShapes()) {
359  cdevice.openTag(SUMO_TAG_WALKINGAREA);
360  cdevice.writeAttr(SUMO_ATTR_NODE, it_node->first);
361  cdevice.writeAttr(SUMO_ATTR_EDGES, joinNamedToString(wacs.edges, " "));
362  if (wacs.shape.size() != 0) {
363  writeShape(cdevice, gch, wacs.shape, SUMO_ATTR_SHAPE, useGeo, geoAccuracy);
364  }
365  if (wacs.width != NBEdge::UNSPECIFIED_WIDTH) {
366  cdevice.writeAttr(SUMO_ATTR_WIDTH, wacs.width);
367  }
368  cdevice.closeTag();
369  }
370  }
371 
372  edevice.close();
373  cdevice.close();
374 }
375 
376 
377 void
379  std::map<SumoXMLAttr, std::string> attrs;
381  OutputDevice& device = OutputDevice::getDevice(oc.getString("plain-output-prefix") + ".tll.xml");
382  device.writeXMLHeader("tlLogics", "tllogic_file.xsd", attrs);
384  // we also need to remember the associations between tlLogics and connections
385  // since the information in con.xml is insufficient
386  for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) {
387  NBEdge* e = (*i).second;
388  // write this edge's tl-controlled connections
389  const std::vector<NBEdge::Connection> connections = e->getConnections();
390  for (std::vector<NBEdge::Connection>::const_iterator c = connections.begin(); c != connections.end(); ++c) {
391  if (c->tlID != "") {
392  NWWriter_SUMO::writeConnection(device, *e, *c, false, NWWriter_SUMO::TLL);
393  }
394  }
395  }
396  device.close();
397 }
398 
399 
400 void
402  std::map<SumoXMLAttr, std::string> attrs;
404  OutputDevice& device = OutputDevice::getDevice(oc.getString("junctions.join-output"));
405  device.writeXMLHeader("nodes", "nodes_file.xsd", attrs);
406  const std::vector<std::set<std::string> >& clusters = nc.getJoinedClusters();
407  for (std::vector<std::set<std::string> >::const_iterator it = clusters.begin(); it != clusters.end(); it++) {
408  assert((*it).size() > 0);
409  device.openTag(SUMO_TAG_JOIN);
410  // prepare string
411  std::ostringstream oss;
412  for (std::set<std::string>::const_iterator it_id = it->begin(); it_id != it->end(); it_id++) {
413  oss << *it_id << " ";
414  }
415  // remove final space
416  std::string ids = oss.str();
417  device.writeAttr(SUMO_ATTR_NODES, ids.substr(0, ids.size() - 1));
418  device.closeTag();
419  }
420  device.close();
421 }
422 
423 
424 void
426  OutputDevice& device = OutputDevice::getDevice(oc.getString("street-sign-output"));
427  device.writeXMLHeader("additional", "additional_file.xsd");
428  for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) {
429  NBEdge* e = (*i).second;
430  const std::vector<NBSign>& signs = e->getSigns();
431  for (std::vector<NBSign>::const_iterator it = signs.begin(); it != signs.end(); ++it) {
432  it->writeAsPOI(device, e);
433  }
434  }
435  device.close();
436 }
437 void
439  OutputDevice& device = OutputDevice::getDevice(oc.getString("ptstop-output"));
440  device.writeXMLHeader("additional", "additional_file.xsd");
441  for (std::map<std::string, NBPTStop*>::const_iterator i = sc.begin(); i != sc.end(); ++i) {
442  i->second->write(device);
443  }
444  device.close();
445 }
447  OutputDevice& device = OutputDevice::getDevice(oc.getString("ptline-output"));
448  device.writeXMLHeader("ptLines", "ptlines_file.xsd");
449  for (const auto& item : lc.getLines()) {
450  item.second->write(device);
451  }
452  device.close();
453 }
454 
456  OutputDevice& device = OutputDevice::getDevice(oc.getString("parking-output"));
457  device.writeXMLHeader("additional", "additional_file.xsd");
458  for (NBParking& p : pc) {
459  p.write(device, ec);
460  }
461  device.close();
462 }
463 
464 void
466  OutputDevice& device = OutputDevice::getDevice(oc.getString("taz-output"));
467  device.writeXMLHeader("additional", "additional_file.xsd");
468  for (std::map<std::string, NBDistrict*>::const_iterator i = dc.begin(); i != dc.end(); i++) {
469  NWWriter_SUMO::writeDistrict(device, *(*i).second);
470  }
471 }
472 
473 void
474 NWWriter_XML::writeShape(OutputDevice& out, const GeoConvHelper& gch, PositionVector shape, SumoXMLAttr attr, bool useGeo, bool geoAccuracy) {
475  if (useGeo) {
476  for (int i = 0; i < (int) shape.size(); i++) {
477  gch.cartesian2geo(shape[i]);
478  }
479  }
480  if (geoAccuracy) {
482  }
483  out.writeAttr(attr, shape);
484  if (geoAccuracy) {
485  out.setPrecision();
486  }
487 }
488 
489 /****************************************************************************/
490 
491 
492 /****************************************************************************/
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:280
const SVCPermissions SVCAll
all VClasses are allowed
const SVCPermissions SVC_UNSPECIFIED
permissions not specified
const std::string & getVehicleClassNames(SVCPermissions permissions, bool expand)
Returns the ids of the given classes, divided using a ' '.
void writePermissions(OutputDevice &into, SVCPermissions permissions)
writes allowed disallowed attributes if needed;
void writePreferences(OutputDevice &into, SVCPermissions preferred)
writes allowed disallowed attributes if needed;
@ SVC_IGNORING
vehicles ignoring classes
@ SVC_PEDESTRIAN
pedestrian
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
TrafficLightType
@ SUMO_TAG_JOIN
Join operation.
@ SUMO_TAG_CONNECTION
connectio between two lanes
@ SUMO_TAG_WALKINGAREA
walking area for pedestrians
@ SUMO_TAG_CROSSING
crossing between edges for pedestrians
@ SUMO_TAG_NODE
alternative definition for junction
@ SUMO_TAG_LANE
begin/end of the description of a single lane
@ SUMO_TAG_NEIGH
begin/end of the description of a neighboring lane
@ SUMO_TAG_EDGE
begin/end of the description of an edge
LaneSpreadFunction
Numbers representing special SUMO-XML-attribute values Information how the edge's lateral offset shal...
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
@ SUMO_ATTR_NODE
@ SUMO_ATTR_LANE
@ SUMO_ATTR_NODES
a list of node ids, used for controlling joining
@ SUMO_ATTR_TLLINKINDEX2
link: the index of the opposite direction link of a pedestrian crossing
@ SUMO_ATTR_SPEED
@ SUMO_ATTR_RADIUS
The turning radius at an intersection in m.
@ SUMO_ATTR_EDGES
the edges of a route
@ SUMO_ATTR_FRINGE
Fringe type of node.
@ SUMO_ATTR_PRIORITY
@ SUMO_ATTR_NUMLANES
@ SUMO_ATTR_SHAPE
edge: the shape in xml-definition
@ SUMO_ATTR_TLTYPE
node: the type of traffic light
@ SUMO_ATTR_CHANGE_LEFT
@ SUMO_ATTR_INDEX
@ SUMO_ATTR_NAME
@ SUMO_ATTR_SPREADTYPE
The information about how to spread the lanes from the given position.
@ SUMO_ATTR_ENDOFFSET
@ SUMO_ATTR_TO
@ SUMO_ATTR_FROM
@ SUMO_ATTR_ACCELERATION
@ SUMO_ATTR_CHANGE_RIGHT
@ SUMO_ATTR_TLID
link,node: the traffic light id responsible for this link
@ SUMO_ATTR_DISTANCE
@ SUMO_ATTR_TYPE
@ SUMO_ATTR_LENGTH
@ SUMO_ATTR_VERSION
@ SUMO_ATTR_ID
@ SUMO_ATTR_RIGHT_OF_WAY
How to compute right of way.
@ SUMO_ATTR_CONTROLLED_INNER
@ SUMO_ATTR_WIDTH
@ SUMO_ATTR_TLLINKINDEX
link: the index of the link within the traffic light
@ SUMO_ATTR_KEEP_CLEAR
Whether vehicles must keep the junction clear.
int gPrecisionGeo
Definition: StdDefs.cpp:26
const double NETWORK_VERSION
version for written networks and default version for loading
Definition: StdDefs.h:66
std::string joinNamedToString(const std::set< T *, C > &ns, const T_BETWEEN &between)
Definition: ToString.h:303
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
Definition: ToString.h:269
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
static methods for processing the coordinates conversion for the current net
Definition: GeoConvHelper.h:53
static void writeLocation(OutputDevice &into)
writes the location element
void cartesian2geo(Position &cartesian) const
Converts the given cartesian (shifted) position to its geo (lat/long) representation.
bool usingInverseGeoProjection() const
Returns the information whether an inverse transformation will happen.
static const GeoConvHelper & getFinal()
the coordinate transformation for writing the location element and for tracking the original coordina...
bool usingGeoProjection() const
Returns whether a transformation from geo to metric coordinates will be performed.
A container for districts.
std::map< std::string, NBDistrict * >::const_iterator begin() const
Returns the pointer to the begin of the stored districts.
std::map< std::string, NBDistrict * >::const_iterator end() const
Returns the pointer to the end of the stored districts.
Storage for edges, including some functionality operating on multiple edges.
Definition: NBEdgeCont.h:59
std::map< std::string, NBEdge * >::const_iterator begin() const
Returns the pointer to the begin of the stored edges.
Definition: NBEdgeCont.h:183
const std::set< EdgeSet > getRoundabouts() const
Returns the determined roundabouts.
std::map< std::string, NBEdge * >::const_iterator end() const
Returns the pointer to the end of the stored edges.
Definition: NBEdgeCont.h:191
The representation of a single edge during network building.
Definition: NBEdge.h:91
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
Definition: NBEdge.cpp:4022
double getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn't set.
Definition: NBEdge.h:597
double getLaneWidth() const
Returns the default width of lanes of this edge.
Definition: NBEdge.h:630
const std::string & getStreetName() const
Returns the street name of this edge.
Definition: NBEdge.h:643
bool hasLaneSpecificSpeed() const
whether lanes differ in speed
Definition: NBEdge.cpp:2325
LaneSpreadFunction getLaneSpreadFunction() const
Returns how this edge's lanes' lateral offset is computed.
Definition: NBEdge.cpp:942
bool hasLoadedLength() const
Returns whether a length was set explicitly.
Definition: NBEdge.h:607
const std::vector< NBSign > & getSigns() const
get Signs
Definition: NBEdge.h:1395
bool hasLaneSpecificStopOffsets() const
whether lanes differ in stopOffsets
Definition: NBEdge.cpp:2369
const std::string & getID() const
Definition: NBEdge.h:1465
const std::vector< NBEdge::Lane > & getLanes() const
Returns the lane definitions.
Definition: NBEdge.h:701
NBNode * getToNode() const
Returns the destination node of the edge.
Definition: NBEdge.h:541
double getSpeed() const
Returns the speed allowed on this edge.
Definition: NBEdge.h:614
double getDistance() const
get distance
Definition: NBEdge.h:653
const StopOffset & getEdgeStopOffset() const
Returns the stopOffset to the end of the edge.
Definition: NBEdge.cpp:3891
bool hasLaneSpecificPermissions() const
whether lanes differ in allowed vehicle classes
Definition: NBEdge.cpp:2311
bool needsLaneSpecificOutput() const
whether at least one lane has values differing from the edges values
Definition: NBEdge.cpp:2424
int getNumLanes() const
Returns the number of lanes.
Definition: NBEdge.h:515
const PositionVector & getGeometry() const
Returns the geometry of the edge.
Definition: NBEdge.h:752
bool hasLaneSpecificWidth() const
whether lanes differ in width
Definition: NBEdge.cpp:2336
bool hasLaneSpecificEndOffset() const
whether lanes differ in offset
Definition: NBEdge.cpp:2358
bool hasDefaultGeometry() const
Returns whether the geometry consists only of the node positions.
Definition: NBEdge.cpp:604
int getPriority() const
Returns the priority of the edge.
Definition: NBEdge.h:522
static const double UNSPECIFIED_WIDTH
unspecified lane width
Definition: NBEdge.h:349
const std::vector< Connection > & getConnections() const
Returns the connections.
Definition: NBEdge.h:1006
const std::string & getTypeID() const
get ID of type
Definition: NBEdge.h:1146
double getEndOffset() const
Returns the offset to the destination node.
Definition: NBEdge.h:660
static const double UNSPECIFIED_OFFSET
unspecified lane offset
Definition: NBEdge.h:352
NBNode * getFromNode() const
Returns the origin node of the edge.
Definition: NBEdge.h:534
Instance responsible for building networks.
Definition: NBNetBuilder.h:107
NBDistrictCont & getDistrictCont()
Returns a reference the districts container.
Definition: NBNetBuilder.h:168
NBTypeCont & getTypeCont()
Returns a reference to the type container.
Definition: NBNetBuilder.h:158
NBParkingCont & getParkingCont()
Definition: NBNetBuilder.h:184
NBPTLineCont & getPTLineCont()
Returns a reference to the pt line container.
Definition: NBNetBuilder.h:179
NBEdgeCont & getEdgeCont()
Definition: NBNetBuilder.h:148
NBPTStopCont & getPTStopCont()
Returns a reference to the pt stop container.
Definition: NBNetBuilder.h:174
NBNodeCont & getNodeCont()
Returns a reference to the node container.
Definition: NBNetBuilder.h:153
NBTrafficLightLogicCont & getTLLogicCont()
Returns a reference to the traffic light logics container.
Definition: NBNetBuilder.h:163
Container for nodes during the netbuilding process.
Definition: NBNodeCont.h:58
std::map< std::string, NBNode * >::const_iterator begin() const
Returns the pointer to the begin of the stored nodes.
Definition: NBNodeCont.h:113
std::map< std::string, NBNode * >::const_iterator end() const
Returns the pointer to the end of the stored nodes.
Definition: NBNodeCont.h:118
const std::vector< std::set< std::string > > & getJoinedClusters() const
gets all joined clusters (see doc for myClusters2Join)
Definition: NBNodeCont.h:327
Represents a single node (junction) during network building.
Definition: NBNode.h:66
RightOfWay getRightOfWay() const
Returns hint on how to compute right of way.
Definition: NBNode.h:288
static const double UNSPECIFIED_RADIUS
unspecified lane width
Definition: NBNode.h:208
FringeType getFringeType() const
Returns fringe type.
Definition: NBNode.h:293
SumoXMLNodeType getType() const
Returns the type of this node.
Definition: NBNode.h:273
const std::string & getName() const
Returns intersection name.
Definition: NBNode.h:298
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges (The edges which start at this node)
Definition: NBNode.h:261
bool hasCustomShape() const
return whether the shape was set by the user
Definition: NBNode.h:558
const std::set< NBTrafficLightDefinition * > & getControllingTLS() const
Returns the traffic lights that were assigned to this node (The set of tls that control this node)
Definition: NBNode.h:324
const PositionVector & getShape() const
retrieve the junction shape
Definition: NBNode.cpp:2418
const Position & getPosition() const
Definition: NBNode.h:248
double getRadius() const
Returns the turning radius of this node.
Definition: NBNode.h:278
bool isTLControlled() const
Returns whether this node is controlled by any tls.
Definition: NBNode.h:319
bool getKeepClear() const
Returns the keepClear flag.
Definition: NBNode.h:283
const std::map< std::string, NBPTLine * > & getLines() const
Definition: NBPTLineCont.h:42
std::map< std::string, NBPTStop * >::const_iterator begin() const
Returns the pointer to the begin of the stored pt stops.
Definition: NBPTStopCont.h:54
std::map< std::string, NBPTStop * >::const_iterator end() const
Returns the pointer to the end of the stored pt stops.
Definition: NBPTStopCont.h:61
The representation of an imported parking area.
Definition: NBParking.h:42
The base class for traffic light logic definitions.
A container for traffic light definitions and built programs.
A storage for available edgeTypes of edges.
Definition: NBTypeCont.h:52
void writeEdgeTypes(OutputDevice &into) const
writes all EdgeTypes (and their lanes) as XML
Definition: NBTypeCont.cpp:365
int size() const
Returns the number of known edgeTypes.
Definition: NBTypeCont.cpp:243
static void writePositionLong(const Position &pos, OutputDevice &dev)
Writes the given position to device in long format (one attribute per dimension)
Definition: NWFrame.cpp:187
static void writeConnection(OutputDevice &into, const NBEdge &from, const NBEdge::Connection &c, bool includeInternal, ConnectionStyle style=SUMONET, bool geoAccuracy=false)
Writes connections outgoing from the given edge (also used in NWWriter_XML)
static void writeProhibitions(OutputDevice &into, const NBConnectionProhibits &prohibitions)
writes the given prohibitions
static void writeDistrict(OutputDevice &into, const NBDistrict &d)
Writes a district.
static void writeRoundabouts(OutputDevice &into, const std::set< EdgeSet > &roundabouts, const NBEdgeCont &ec)
Writes roundabouts.
static void writeStopOffsets(OutputDevice &into, const StopOffset &stopOffset)
Write a stopOffset element into output device.
static void writeTrafficLights(OutputDevice &into, const NBTrafficLightLogicCont &tllCont)
writes the traffic light logics to the given device
static void writeTypes(const OptionsCont &oc, NBTypeCont &tc)
Writes the types file.
static void writeNetwork(const OptionsCont &oc, NBNetBuilder &nb)
Writes the network into XML-files (nodes, edges, connections, traffic lights)
static void writeStreetSigns(const OptionsCont &oc, NBEdgeCont &ec)
Writes street signs as POIs to file.
static void writeParkingAreas(const OptionsCont &cont, NBParkingCont &pc, NBEdgeCont &ec)
writes imported parking areas to file
static void writeTrafficLights(const OptionsCont &oc, NBTrafficLightLogicCont &tc, NBEdgeCont &ec)
Writes the traffic lights file.
static void writeEdgesAndConnections(const OptionsCont &oc, NBNodeCont &nc, NBEdgeCont &ec)
Writes the edges and connections files.
static void writeJoinedJunctions(const OptionsCont &oc, NBNodeCont &nc)
Writes the joined-juncionts to file.
static void writePTLines(const OptionsCont &cont, NBPTLineCont &lc)
static void writePTStops(const OptionsCont &oc, NBPTStopCont &ec)
Writes the pt stops file.
static void writeShape(OutputDevice &out, const GeoConvHelper &gch, PositionVector shape, SumoXMLAttr attr, bool useGeo, bool geoAccuracy)
static void writeDistricts(const OptionsCont &oc, NBDistrictCont &dc)
writes imported districts (TAZ) to file
static void writeNodes(const OptionsCont &oc, NBNodeCont &nc)
Writes the nodes file.
const std::string & getID() const
Returns the id.
Definition: Named.h:74
A storage for options typed value containers)
Definition: OptionsCont.h:89
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
bool exists(const std::string &name) const
Returns the information whether the named option is known.
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
void lf()
writes a line feed if applicable
Definition: OutputDevice.h:236
void close()
Closes the device and removes it from the dictionary.
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:248
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
void setPrecision(int precision=gPrecision)
Sets the precision or resets it to default.
bool writeXMLHeader(const std::string &rootElement, const std::string &schemaFile, std::map< SumoXMLAttr, std::string > attrs=std::map< SumoXMLAttr, std::string >(), bool includeConfig=true)
Writes an XML header with optional configuration.
static OutputDevice & getDevice(const std::string &name)
Returns the described OutputDevice.
void writeParams(OutputDevice &device) const
write Params in the given outputdevice
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
A list of positions.
static StringBijection< LaneSpreadFunction > LaneSpreadFunctions
lane spread functions
static StringBijection< TrafficLightType > TrafficLightTypes
traffic light types
bool isDefined() const
check if stopOffset was defined
T get(const std::string &str) const
static std::string escapeXML(const std::string &orig, const bool maskDoubleHyphen=false)
Replaces the standard escapes by their XML entities.
A structure which describes a connection between edges or lanes.
Definition: NBEdge.h:197
An (internal) definition of a single lane of an edge.
Definition: NBEdge.h:142