SUMO - Simulation of Urban MObility
NIXMLEdgesHandler.cpp
Go to the documentation of this file.
1 /****************************************************************************/
11 // Importer for network edges stored in XML
12 /****************************************************************************/
13 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
14 // Copyright (C) 2001-2017 DLR (http://www.dlr.de/) and contributors
15 /****************************************************************************/
16 //
17 // This file is part of SUMO.
18 // SUMO is free software: you can redistribute it and/or modify
19 // it under the terms of the GNU General Public License as published by
20 // the Free Software Foundation, either version 3 of the License, or
21 // (at your option) any later version.
22 //
23 /****************************************************************************/
24 
25 
26 // ===========================================================================
27 // included modules
28 // ===========================================================================
29 #ifdef _MSC_VER
30 #include <windows_config.h>
31 #else
32 #include <config.h>
33 #endif
34 
35 #include <string>
36 #include <iostream>
37 #include <map>
38 #include <cmath>
39 #include <xercesc/sax/HandlerBase.hpp>
40 #include <xercesc/sax/AttributeList.hpp>
41 #include <xercesc/sax/SAXParseException.hpp>
42 #include <xercesc/sax/SAXException.hpp>
44 #include <netbuild/NBNodeCont.h>
45 #include <netbuild/NBTypeCont.h>
46 #include <netbuild/NBNetBuilder.h>
52 #include <utils/common/ToString.h>
55 #include "NIXMLNodesHandler.h"
56 #include "NIXMLEdgesHandler.h"
57 
58 
59 // ===========================================================================
60 // method definitions
61 // ===========================================================================
63  NBEdgeCont& ec,
64  NBTypeCont& tc,
65  NBDistrictCont& dc,
67  OptionsCont& options)
68  : SUMOSAXHandler("xml-edges - file"),
69  myOptions(options),
70  myNodeCont(nc),
71  myEdgeCont(ec),
72  myTypeCont(tc),
73  myDistrictCont(dc),
74  myTLLogicCont(tlc),
75  myCurrentEdge(0), myHaveReportedAboutOverwriting(false),
76  myHaveReportedAboutTypeOverride(false),
77  myHaveWarnedAboutDeprecatedLaneId(false),
78  myKeepEdgeShape(!options.getBool("plain.extend-edge-shape")) {
79 }
80 
81 
83 
84 
85 void
87  const SUMOSAXAttributes& attrs) {
88  switch (element) {
89  case SUMO_TAG_EDGE:
90  addEdge(attrs);
91  break;
92  case SUMO_TAG_LANE:
93  addLane(attrs);
94  break;
95  case SUMO_TAG_NEIGH:
97  break;
98  case SUMO_TAG_SPLIT:
99  addSplit(attrs);
100  break;
101  case SUMO_TAG_DELETE:
102  deleteEdge(attrs);
103  break;
104  case SUMO_TAG_ROUNDABOUT:
105  addRoundabout(attrs);
106  break;
107  default:
108  break;
109  }
110 }
111 
112 
113 void
115  myIsUpdate = false;
116  bool ok = true;
117  // initialise the edge
118  myCurrentEdge = 0;
119  mySplits.clear();
120  // get the id, report an error if not given or empty...
121  myCurrentID = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
122  if (!ok) {
123  return;
124  }
126  // check deprecated (unused) attributes
127  // use default values, first
131  if (myCurrentEdge != 0) {
132  // update existing edge. only update lane-specific settings when explicitly requested
133  myIsUpdate = true;
137  } else {
138  // this is a completely new edge. get the type specific defaults
142  }
143  myCurrentType = "";
147  myCurrentStreetName = "";
148  myReinitKeepEdgeShape = false;
151  // check whether a type's values shall be used
152  if (attrs.hasAttribute(SUMO_ATTR_TYPE)) {
153  myCurrentType = attrs.get<std::string>(SUMO_ATTR_TYPE, myCurrentID.c_str(), ok);
154  if (!ok) {
155  return;
156  }
157  if (!myTypeCont.knows(myCurrentType) && !myOptions.getBool("ignore-errors.edge-type")) {
158  WRITE_ERROR("Type '" + myCurrentType + "' used by edge '" + myCurrentID + "' was not defined (ignore with option --ignore-errors.edge-type).");
159  return;
160  }
168  }
169  // use values from the edge to overwrite if existing, then
170  if (myIsUpdate) {
172  WRITE_MESSAGE("Duplicate edge id occurred ('" + myCurrentID + "'); assuming overwriting is wished.");
174  }
177  WRITE_MESSAGE("Edge '" + myCurrentID + "' changed it's type; assuming type override is wished.");
179  }
180  }
181  if (attrs.getOpt<bool>(SUMO_ATTR_REMOVE, myCurrentID.c_str(), ok, false)) {
183  myCurrentEdge = 0;
184  return;
185  }
190  myReinitKeepEdgeShape = true;
191  }
195  }
197  }
198  // speed, priority and the number of lanes have now default values;
199  // try to read the real values from the file
200  if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
201  myCurrentSpeed = attrs.get<double>(SUMO_ATTR_SPEED, myCurrentID.c_str(), ok);
202  }
203  if (myOptions.getBool("speed-in-kmh") && myCurrentSpeed != NBEdge::UNSPECIFIED_SPEED) {
204  myCurrentSpeed = myCurrentSpeed / (double) 3.6;
205  }
206  // try to get the number of lanes
207  if (attrs.hasAttribute(SUMO_ATTR_NUMLANES)) {
208  myCurrentLaneNo = attrs.get<int>(SUMO_ATTR_NUMLANES, myCurrentID.c_str(), ok);
209  }
210  // try to get the priority
211  if (attrs.hasAttribute(SUMO_ATTR_PRIORITY)) {
212  myCurrentPriority = attrs.get<int>(SUMO_ATTR_PRIORITY, myCurrentID.c_str(), ok);
213  }
214  // try to get the width
215  if (attrs.hasAttribute(SUMO_ATTR_WIDTH)) {
216  myCurrentWidth = attrs.get<double>(SUMO_ATTR_WIDTH, myCurrentID.c_str(), ok);
217  }
218  // try to get the offset of the stop line from the intersection
219  if (attrs.hasAttribute(SUMO_ATTR_ENDOFFSET)) {
220  myCurrentEndOffset = attrs.get<double>(SUMO_ATTR_ENDOFFSET, myCurrentID.c_str(), ok);
221  }
222  // try to get the street name
223  if (attrs.hasAttribute(SUMO_ATTR_NAME)) {
224  myCurrentStreetName = attrs.get<std::string>(SUMO_ATTR_NAME, myCurrentID.c_str(), ok);
225  if (myCurrentStreetName != "" && myOptions.isDefault("output.street-names")) {
226  myOptions.set("output.street-names", "true");
227  }
228  }
229 
230  // try to get the allowed/disallowed classes
232  std::string allowS = attrs.hasAttribute(SUMO_ATTR_ALLOW) ? attrs.getStringSecure(SUMO_ATTR_ALLOW, "") : "";
233  std::string disallowS = attrs.hasAttribute(SUMO_ATTR_DISALLOW) ? attrs.getStringSecure(SUMO_ATTR_DISALLOW, "") : "";
234  // XXX matter of interpretation: should updated permissions replace or extend previously set permissions?
235  myPermissions = parseVehicleClasses(allowS, disallowS);
236  }
237  // try to set the nodes
238  if (!setNodes(attrs)) {
239  // return if this failed
240  return;
241  }
242  // try to get the shape
243  myShape = tryGetShape(attrs);
244  // try to get the spread type
246  // try to get the length
247  myLength = attrs.getOpt<double>(SUMO_ATTR_LENGTH, myCurrentID.c_str(), ok, myLength);
248  // try to get the sidewalkWidth
250  // try to get the bikeLaneWidth
252  // insert the parsed edge into the edges map
253  if (!ok) {
254  return;
255  }
256  // check whether a previously defined edge shall be overwritten
257  if (myCurrentEdge != 0) {
263  } else {
264  // the edge must be allocated in dependence to whether a shape is given
265  if (myShape.size() == 0) {
269  } else {
274  }
275  }
279  }
280 }
281 
282 
283 void
285  if (myCurrentEdge == 0) {
286  if (!OptionsCont::getOptions().isInStringVector("remove-edges.explicit", myCurrentID)) {
287  WRITE_ERROR("Additional lane information could not be set - the edge with id '" + myCurrentID + "' is not known.");
288  }
289  return;
290  }
291  bool ok = true;
292  int lane;
293  if (attrs.hasAttribute(SUMO_ATTR_ID)) {
294  lane = attrs.get<int>(SUMO_ATTR_ID, myCurrentID.c_str(), ok);
297  WRITE_WARNING("'" + toString(SUMO_ATTR_ID) + "' is deprecated, please use '" + toString(SUMO_ATTR_INDEX) + "' instead.");
298  }
299  } else {
300  lane = attrs.get<int>(SUMO_ATTR_INDEX, myCurrentID.c_str(), ok);
301  }
302  if (!ok) {
303  return;
304  }
305  // check whether this lane exists
306  if (lane >= (int) myCurrentEdge->getNumLanes()) {
307  WRITE_ERROR("Lane index is larger than number of lanes (edge '" + myCurrentID + "').");
308  return;
309  }
310  // set information about allowed / disallowed vehicle classes (if specified)
312  const std::string allowed = attrs.getOpt<std::string>(SUMO_ATTR_ALLOW, 0, ok, "");
313  const std::string disallowed = attrs.getOpt<std::string>(SUMO_ATTR_DISALLOW, 0, ok, "");
314  myCurrentEdge->setPermissions(parseVehicleClasses(allowed, disallowed), lane);
315  }
316  if (attrs.hasAttribute(SUMO_ATTR_PREFER)) {
317  const std::string preferred = attrs.get<std::string>(SUMO_ATTR_PREFER, 0, ok);
319  }
320  // try to get the width
321  if (attrs.hasAttribute(SUMO_ATTR_WIDTH)) {
322  myCurrentEdge->setLaneWidth(lane, attrs.get<double>(SUMO_ATTR_WIDTH, myCurrentID.c_str(), ok));
323  }
324  // try to get the end-offset (lane shortened due to pedestrian crossing etc..)
325  if (attrs.hasAttribute(SUMO_ATTR_ENDOFFSET)) {
326  myCurrentEdge->setEndOffset(lane, attrs.get<double>(SUMO_ATTR_ENDOFFSET, myCurrentID.c_str(), ok));
327  }
328  // try to get lane specific speed (should not occur for german networks)
329  if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
330  myCurrentEdge->setSpeed(lane, attrs.get<double>(SUMO_ATTR_SPEED, myCurrentID.c_str(), ok));
331  }
332  // check whether this is an acceleration lane
334  myCurrentEdge->setAcceleration(lane, attrs.get<bool>(SUMO_ATTR_ACCELERATION, myCurrentID.c_str(), ok));
335  }
336 }
337 
338 
340  if (myCurrentEdge == 0) {
341  if (!OptionsCont::getOptions().isInStringVector("remove-edges.explicit", myCurrentID)) {
342  WRITE_WARNING("Ignoring 'split' because it cannot be assigned to an edge");
343  }
344  return;
345  }
346  bool ok = true;
347  Split e;
348  e.pos = attrs.get<double>(SUMO_ATTR_POSITION, 0, ok);
349  if (ok) {
350  if (fabs(e.pos) > myCurrentEdge->getGeometry().length()) {
351  WRITE_ERROR("Edge '" + myCurrentID + "' has a split at invalid position " + toString(e.pos) + ".");
352  return;
353  }
354  std::vector<Split>::iterator i = find_if(mySplits.begin(), mySplits.end(), split_by_pos_finder(e.pos));
355  if (i != mySplits.end()) {
356  WRITE_ERROR("Edge '" + myCurrentID + "' has already a split at position " + toString(e.pos) + ".");
357  return;
358  }
359  const std::string nameid = toString((int)e.pos);
360  if (e.pos < 0) {
362  }
363  std::vector<std::string> lanes;
364  SUMOSAXAttributes::parseStringVector(attrs.getOpt<std::string>(SUMO_ATTR_LANES, 0, ok, ""), lanes);
365  for (std::vector<std::string>::iterator i = lanes.begin(); i != lanes.end(); ++i) {
366  try {
367  int lane = TplConvert::_2int((*i).c_str());
368  e.lanes.push_back(lane);
369  } catch (NumberFormatException&) {
370  WRITE_ERROR("Error on parsing a split (edge '" + myCurrentID + "').");
371  } catch (EmptyData&) {
372  WRITE_ERROR("Error on parsing a split (edge '" + myCurrentID + "').");
373  }
374  }
375  if (e.lanes.empty()) {
376  for (int l = 0; l < myCurrentEdge->getNumLanes(); ++l) {
377  e.lanes.push_back(l);
378  }
379  }
380  e.speed = attrs.getOpt(SUMO_ATTR_SPEED, 0, ok, myCurrentEdge->getSpeed());
381  if (attrs.hasAttribute(SUMO_ATTR_SPEED) && myOptions.getBool("speed-in-kmh")) {
382  e.speed /= (double) 3.6;
383  }
384  e.idBefore = attrs.getOpt(SUMO_ATTR_ID_BEFORE, 0, ok, std::string(""));
385  e.idAfter = attrs.getOpt(SUMO_ATTR_ID_AFTER, 0, ok, std::string(""));
386  if (!ok) {
387  return;
388  }
389  e.node = new NBNode(myCurrentID + "." + nameid,
393  mySplits.push_back(e);
394  }
395 }
396 
397 
398 bool
400  // the names and the coordinates of the beginning and the end node
401  // may be found, try
402  bool ok = true;
403  std::string begNodeID = myIsUpdate ? myCurrentEdge->getFromNode()->getID() : "";
404  std::string endNodeID = myIsUpdate ? myCurrentEdge->getToNode()->getID() : "";
405  std::string oldBegID = begNodeID;
406  std::string oldEndID = endNodeID;
407  if (attrs.hasAttribute(SUMO_ATTR_FROM)) {
408  begNodeID = attrs.get<std::string>(SUMO_ATTR_FROM, 0, ok);
409  } else if (!myIsUpdate) {
410  WRITE_ERROR("The from-node is not given for edge '" + myCurrentID + "'.");
411  ok = false;
412  }
413  if (attrs.hasAttribute(SUMO_ATTR_TO)) {
414  endNodeID = attrs.get<std::string>(SUMO_ATTR_TO, 0, ok);
415  } else if (!myIsUpdate) {
416  WRITE_ERROR("The to-node is not given for edge '" + myCurrentID + "'.");
417  ok = false;
418  }
419  if (!ok) {
420  return false;
421  }
422  myFromNode = myNodeCont.retrieve(begNodeID);
423  myToNode = myNodeCont.retrieve(endNodeID);
424  if (myFromNode == 0) {
425  WRITE_ERROR("Edge's '" + myCurrentID + "' from-node '" + begNodeID + "' is not known.");
426  }
427  if (myToNode == 0) {
428  WRITE_ERROR("Edge's '" + myCurrentID + "' to-node '" + endNodeID + "' is not known.");
429  }
430  if (myFromNode != 0 && myToNode != 0) {
431  if (myIsUpdate && (myFromNode->getID() != oldBegID || myToNode->getID() != oldEndID)) {
433  }
434  }
435  return myFromNode != 0 && myToNode != 0;
436 }
437 
438 
441  if (!attrs.hasAttribute(SUMO_ATTR_SHAPE)) {
442  return myShape;
443  }
444  // try to build shape
445  bool ok = true;
446  if (!attrs.hasAttribute(SUMO_ATTR_SHAPE)) {
447  myReinitKeepEdgeShape = false;
448  return PositionVector();
449  }
452  WRITE_ERROR("Unable to project coordinates for edge '" + myCurrentID + "'.");
453  }
455  return shape;
456 }
457 
458 
461  bool ok = true;
463  std::string lsfS = toString(result);
464  lsfS = attrs.getOpt<std::string>(SUMO_ATTR_SPREADTYPE, myCurrentID.c_str(), ok, lsfS);
465  if (SUMOXMLDefinitions::LaneSpreadFunctions.hasString(lsfS)) {
467  } else {
468  WRITE_WARNING("Ignoring unknown spreadType '" + lsfS + "' for edge '" + myCurrentID + "'.");
469  }
470  return result;
471 }
472 
473 
474 void
476  bool ok = true;
477  myCurrentID = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
478  if (!ok) {
479  return;
480  }
482  if (edge == 0) {
483  WRITE_WARNING("Ignoring tag '" + toString(SUMO_TAG_DELETE) + "' for unknown edge '" +
484  myCurrentID + "'");
485  return;
486  }
487  const int lane = attrs.getOpt<int>(SUMO_ATTR_INDEX, myCurrentID.c_str(), ok, -1);
488  if (lane < 0) {
489  myEdgeCont.extract(myDistrictCont, edge, true);
490  } else {
491  edge->removeFromConnections(0, lane, -1, false, true);
492  const EdgeVector incoming = edge->getIncomingEdges();
493  for (EdgeVector::const_iterator e = incoming.begin(); e != incoming.end(); ++e) {
494  (*e)->removeFromConnections(edge, -1, lane, false, true);
495  }
496  edge->deleteLane(lane, false);
497  }
498 }
499 
500 
501 void
503  if (element == SUMO_TAG_EDGE && myCurrentEdge != 0) {
504  // add bike lane, wait until lanes are loaded to avoid building if it already exists
507  }
508  // add sidewalk, wait until lanes are loaded to avoid building if it already exists
511  }
512  if (!myIsUpdate) {
513  try {
515  WRITE_ERROR("Duplicate edge occured. ID='" + myCurrentID + "'");
516  delete myCurrentEdge;
517  }
518  } catch (InvalidArgument& e) {
519  WRITE_ERROR(e.what());
520  throw;
521  } catch (...) {
522  WRITE_ERROR("An important information is missing in edge '" + myCurrentID + "'.");
523  }
524  }
525  if (mySplits.size() != 0) {
526  std::vector<Split>::iterator i;
527  NBEdge* e = myCurrentEdge;
528  sort(mySplits.begin(), mySplits.end(), split_sorter());
529  int noLanesMax = e->getNumLanes();
530  // compute the node positions and sort the lanes
531  for (i = mySplits.begin(); i != mySplits.end(); ++i) {
532  sort((*i).lanes.begin(), (*i).lanes.end());
533  noLanesMax = MAX2(noLanesMax, (int)(*i).lanes.size());
534  }
535  // split the edge
536  std::vector<int> currLanes;
537  for (int l = 0; l < e->getNumLanes(); ++l) {
538  currLanes.push_back(l);
539  }
540  if (e->getNumLanes() != (int)mySplits.back().lanes.size()) {
541  // invalidate traffic light definitions loaded from a SUMO network
542  // XXX it would be preferable to reconstruct the phase definitions heuristically
544  // if the number of lanes changes the connections should be
545  // recomputed
546  e->invalidateConnections(true);
547  }
548 
549  std::string firstID = "";
550  double seen = 0;
551  for (i = mySplits.begin(); i != mySplits.end(); ++i) {
552  const Split& exp = *i;
553  assert(exp.lanes.size() != 0);
554  if (exp.pos > 0 && e->getGeometry().length() + seen > exp.pos && exp.pos > seen) {
555  if (myNodeCont.insert(exp.node)) {
557  // split the edge
558  std::string idBefore = exp.idBefore == "" ? e->getID() : exp.idBefore;
559  std::string idAfter = exp.idAfter == "" ? exp.node->getID() : exp.idAfter;
560  if (firstID == "") {
561  firstID = idBefore;
562  }
563  myEdgeCont.splitAt(myDistrictCont, e, exp.pos - seen, exp.node,
564  idBefore, idAfter, e->getNumLanes(), (int) exp.lanes.size(), exp.speed);
565  seen = exp.pos;
566  std::vector<int> newLanes = exp.lanes;
567  NBEdge* pe = myEdgeCont.retrieve(idBefore);
568  NBEdge* ne = myEdgeCont.retrieve(idAfter);
569  // reconnect lanes
570  pe->invalidateConnections(true);
571  // new on right
572  int rightMostP = currLanes[0];
573  int rightMostN = newLanes[0];
574  for (int l = 0; l < (int) rightMostP - (int) rightMostN; ++l) {
575  pe->addLane2LaneConnection(0, ne, l, NBEdge::L2L_VALIDATED, true);
576  }
577  // new on left
578  int leftMostP = currLanes.back();
579  int leftMostN = newLanes.back();
580  for (int l = 0; l < (int) leftMostN - (int) leftMostP; ++l) {
581  pe->addLane2LaneConnection(pe->getNumLanes() - 1, ne, leftMostN - l - rightMostN, NBEdge::L2L_VALIDATED, true);
582  }
583  // all other connected
584  for (int l = 0; l < noLanesMax; ++l) {
585  if (find(currLanes.begin(), currLanes.end(), l) == currLanes.end()) {
586  continue;
587  }
588  if (find(newLanes.begin(), newLanes.end(), l) == newLanes.end()) {
589  continue;
590  }
591  pe->addLane2LaneConnection(l - rightMostP, ne, l - rightMostN, NBEdge::L2L_VALIDATED, true);
592  }
593  // move to next
594  e = ne;
595  currLanes = newLanes;
596  } else {
597  WRITE_WARNING("Error on parsing a split (edge '" + myCurrentID + "').");
598  }
599  } else if (exp.pos == 0) {
600  const int laneCountDiff = e->getNumLanes() - (int)exp.lanes.size();
601  if (laneCountDiff < 0) {
602  e->incLaneNo(-laneCountDiff);
603  } else {
604  e->decLaneNo(laneCountDiff);
605  }
606  currLanes = exp.lanes;
607  // invalidate traffic light definition loaded from a SUMO network
608  // XXX it would be preferable to reconstruct the phase definitions heuristically
610  } else {
611  WRITE_WARNING("Split at '" + toString(exp.pos) + "' lies beyond the edge's length (edge '" + myCurrentID + "').");
612  }
613  }
614  // patch lane offsets
615  e = myEdgeCont.retrieve(firstID);
616  if (mySplits.front().pos != 0) {
617  // add a dummy split at the beginning to ensure correct offset
618  Split start;
619  start.pos = 0;
620  for (int lane = 0; lane < (int)e->getNumLanes(); ++lane) {
621  start.lanes.push_back(lane);
622  }
623  mySplits.insert(mySplits.begin(), start);
624  }
625  i = mySplits.begin();
626  for (; i != mySplits.end(); ++i) {
627  int maxLeft = (*i).lanes.back();
628  double offset = 0;
629  if (maxLeft < noLanesMax) {
631  offset = SUMO_const_laneWidthAndOffset * (noLanesMax - 1 - maxLeft);
632  } else {
633  offset = SUMO_const_halfLaneAndOffset * (noLanesMax - 1 - maxLeft);
634  }
635  }
636  int maxRight = (*i).lanes.front();
637  if (maxRight > 0 && e->getLaneSpreadFunction() == LANESPREAD_CENTER) {
638  offset -= SUMO_const_halfLaneAndOffset * maxRight;
639  }
640  if (offset != 0) {
641  PositionVector g = e->getGeometry();
642  g.move2side(offset);
643  e->setGeometry(g);
644  }
645  if (e->getToNode()->getOutgoingEdges().size() != 0) {
646  e = e->getToNode()->getOutgoingEdges()[0];
647  }
648  }
649  }
650  myCurrentEdge = 0;
651  }
652 }
653 
654 
655 void
657  if (attrs.hasAttribute(SUMO_ATTR_EDGES)) {
658  std::vector<std::string> edgeIDs = attrs.getStringVector(SUMO_ATTR_EDGES);
659  EdgeSet roundabout;
660  for (std::vector<std::string>::iterator it = edgeIDs.begin(); it != edgeIDs.end(); ++it) {
661  NBEdge* edge = myEdgeCont.retrieve(*it);
662  if (edge == 0) {
663  if (!myEdgeCont.wasIgnored(*it)) {
664  WRITE_ERROR("Unknown edge '" + (*it) + "' in roundabout");
665  }
666  } else {
667  roundabout.insert(edge);
668  }
669  }
670  myEdgeCont.addRoundabout(roundabout);
671  } else {
672  WRITE_ERROR("Empty edges in roundabout.");
673  }
674 }
675 
676 
677 
678 /****************************************************************************/
679 
LaneSpreadFunction getLaneSpreadFunction() const
Returns how this edge&#39;s lanes&#39; lateral offset is computed.
Definition: NBEdge.h:677
void invalidateConnections(bool reallowSetting=false)
invalidate current connections of edge
Definition: NBEdge.cpp:1238
The information about how to spread the lanes from the given position.
NBNode * retrieve(const std::string &id) const
Returns the node with the given name.
Definition: NBNodeCont.cpp:106
double getSpeed(const std::string &type) const
Returns the maximal velocity for the given type [m/s].
Definition: NBTypeCont.cpp:181
LaneSpreadFunction myLanesSpread
Information about how to spread the lanes.
split something
Finds a split at the given position.
static const double UNSPECIFIED_LOADED_LENGTH
no length override given
Definition: NBEdge.h:270
EdgeVector getIncomingEdges() const
Returns the list of incoming edges unsorted.
Definition: NBEdge.cpp:1119
begin/end of the description of a single lane
void setEndOffset(int lane, double offset)
set lane specific end-offset (negative lane implies set for all lanes)
Definition: NBEdge.cpp:2846
std::string myCurrentID
The current edge&#39;s id.
static StringBijection< LaneSpreadFunction > LaneSpreadFunctions
lane spread functions
void markAsSplit(const NBNode *node)
mark a node as being created form a split
Definition: NBNodeCont.h:277
PositionVector myShape
The shape of the edge.
A container for traffic light definitions and built programs.
void setSpeed(int lane, double speed)
set lane specific speed (negative lane implies set for all lanes)
Definition: NBEdge.cpp:2862
void addRoundabout(const SUMOSAXAttributes &attrs)
Parses a roundabout and stores it in myEdgeCont.
bool setNodes(const SUMOSAXAttributes &attrs)
Sets from/to node information of the currently parsed edge.
int getPriority() const
Returns the priority of the edge.
Definition: NBEdge.h:420
const std::string & getTypeID() const
get ID of type
Definition: NBEdge.h:971
const double SUMO_const_halfLaneAndOffset
Definition: StdDefs.h:53
double myCurrentSpeed
The current edge&#39;s maximum speed.
The representation of a single edge during network building.
Definition: NBEdge.h:71
const double SUMO_const_laneWidthAndOffset
Definition: StdDefs.h:52
int getPriority(const std::string &type) const
Returns the priority for the given type.
Definition: NBTypeCont.cpp:187
NBNode * myFromNode
The nodes the edge starts and ends at.
A container for districts.
static const double UNSPECIFIED_OFFSET
unspecified lane offset
Definition: NBEdge.h:258
void removeFromConnections(NBEdge *toEdge, int fromLane=-1, int toLane=-1, bool tryLater=false, const bool adaptToLaneRemoval=false)
Removes the specified connection(s)
Definition: NBEdge.cpp:1174
NIXMLEdgesHandler(NBNodeCont &nc, NBEdgeCont &ec, NBTypeCont &tc, NBDistrictCont &dc, NBTrafficLightLogicCont &tlc, OptionsCont &options)
Constructor.
T MAX2(T a, T b)
Definition: StdDefs.h:70
bool myHaveReportedAboutOverwriting
Information whether at least one edge&#39;s attributes were overwritten.
bool hasLoadedLength() const
Returns whether a length was set explicitly.
Definition: NBEdge.h:500
void setPermissions(SVCPermissions permissions, int lane=-1)
set allowed/disallowed classes for the given lane or for all lanes if -1 is given ...
Definition: NBEdge.cpp:2885
void setLoadedLength(double val)
set loaded lenght
Definition: NBEdge.cpp:2928
bool splitAt(NBDistrictCont &dc, NBEdge *edge, NBNode *node)
Splits the edge at the position nearest to the given node.
Definition: NBEdgeCont.cpp:416
static bool transformCoordinates(PositionVector &from, bool includeInBoundary=true, GeoConvHelper *from_srs=0)
int getNumLanes(const std::string &type) const
Returns the number of lanes for the given type.
Definition: NBTypeCont.cpp:175
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
const std::string & getID() const
Returns the id.
Definition: Named.h:66
NBDistrictCont & myDistrictCont
The districts container (needed if an edge must be split)
bool isDefault(const std::string &name) const
Returns the information whether the named option has still the default value.
Lane & getLaneStruct(int lane)
Definition: NBEdge.h:1154
SAX-handler base for SUMO-files.
void addSidewalk(double width)
add a pedestrian sidewalk of the given width and shift existing connctions
Definition: NBEdge.cpp:3011
void setGeometry(const PositionVector &g, bool inner=false)
(Re)sets the edge&#39;s geometry
Definition: NBEdge.cpp:512
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list...
static const double UNSPECIFIED_WIDTH
unspecified lane width
Definition: NBEdge.h:255
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:200
The connection was computed and validated.
Definition: NBEdge.h:117
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:65
double getWidth(const std::string &type) const
Returns the lane width for the given type [m].
Definition: NBTypeCont.cpp:217
void setAcceleration(int lane, bool accelRamp)
marks one lane as acceleration lane
Definition: NBEdge.cpp:2877
virtual std::string getString(int id) const =0
Returns the string-value of the named (by its enum-value) attribute.
const bool myKeepEdgeShape
Whether the edge shape shall be kept generally.
const EdgeVector & getOutgoingEdges() const
Returns this node&#39;s outgoing edges (The edges which start at this node)
Definition: NBNode.h:245
bool myReinitKeepEdgeShape
Whether the edge shape shall be kept at reinitilization.
void addEdge(const SUMOSAXAttributes &attrs)
Parses an edge and stores the values in "myCurrentEdge".
~NIXMLEdgesHandler()
Destructor.
static const double UNSPECIFIED_SPEED
unspecified lane speed
Definition: NBEdge.h:261
void incLaneNo(int by)
increment lane
Definition: NBEdge.cpp:2723
static void parseStringVector(const std::string &def, std::vector< std::string > &into)
Splits the given string.
bool knows(const std::string &type) const
Returns whether the named type is in the container.
Definition: NBTypeCont.cpp:75
double getBikeLaneWidth(const std::string &type) const
Returns the lane width for a bike lane to be added [m].
Definition: NBTypeCont.cpp:229
std::vector< Split > mySplits
The list of this edge&#39;s splits.
std::set< NBEdge * > EdgeSet
container for unique edges
Definition: NBCont.h:51
the edges of a route
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
Definition: NBEdgeCont.cpp:158
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:56
double getSidewalkWidth(const std::string &type) const
Returns the lane width for a sidewalk to be added [m].
Definition: NBTypeCont.cpp:223
bool myHaveWarnedAboutDeprecatedLaneId
void decLaneNo(int by)
decrement lane
Definition: NBEdge.cpp:2749
Encapsulated SAX-Attributes.
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
void extract(NBDistrictCont &dc, NBEdge *edge, bool remember=false)
Removes the given edge from the container like erase but does not delete it.
Definition: NBEdgeCont.cpp:392
void deleteEdge(const SUMOSAXAttributes &attrs)
parses delete tag and deletes the specified edge or lane
int getNumLanes() const
Returns the number of lanes.
Definition: NBEdge.h:413
void deleteLane(int index, bool recompute=true)
delete lane
Definition: NBEdge.cpp:2734
A structure which describes changes of lane number or speed along the road.
A list of positions.
double pos
The position of this change.
void addSplit(const SUMOSAXAttributes &attrs)
Parses a split and stores it in mySplits. Splits are executed Upon reading the end tag of an edge...
T get(const std::string &str) const
std::string myCurrentType
The current edge&#39;s type.
bool hasDefaultGeometry() const
Returns whether the geometry consists only of the node positions.
Definition: NBEdge.cpp:488
double myLength
The current edge&#39;s length.
roundabout defined in junction
Storage for edges, including some functionality operating on multiple edges.
Definition: NBEdgeCont.h:66
std::vector< int > lanes
The lanes after this change.
const std::string & getStreetName() const
Returns the street name of this edge.
Definition: NBEdge.h:536
double myCurrentEndOffset
The current edge&#39;s offset till the destination node.
NBNodeCont & myNodeCont
The nodes container (for retrieval of referenced nodes)
edge: the shape in xml-definition
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
NBTrafficLightLogicCont & myTLLogicCont
The traffic lights container to add built tls to (when invalidating tls because of splits) ...
static void processNodeType(const SUMOSAXAttributes &attrs, NBNode *node, const std::string &nodeID, const Position &position, bool updateEdgeGeometries, NBNodeCont &nc, NBTrafficLightLogicCont &tlc)
parses node attributes (not related to positioning)
Sorts splits by their position (increasing)
LaneSpreadFunction tryGetLaneSpread(const SUMOSAXAttributes &attrs)
Tries to parse the spread type.
begin/end of the description of a neighboring lane
void reinit(NBNode *from, NBNode *to, const std::string &type, double speed, int nolanes, int priority, PositionVector geom, double width, double offset, const std::string &streetName, LaneSpreadFunction spread=LANESPREAD_RIGHT, bool tryIgnoreNodePositions=false)
Resets initial values.
Definition: NBEdge.cpp:327
double myBikeLaneWidth
The width of the bike lane that shall be added to the current edge.
void move2side(double amount)
move position vector to side using certain ammount
begin/end of the description of an edge
double getSpeed() const
Returns the speed allowed on this edge.
Definition: NBEdge.h:507
const PositionVector & getGeometry() const
Returns the geometry of the edge.
Definition: NBEdge.h:595
virtual std::vector< std::string > getStringVector(int attr) const =0
Tries to read given attribute assuming it is a string vector.
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:206
static int _2int(const E *const data)
converts a char-type array into the integer value described by it
Definition: TplConvert.h:149
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue, bool report=true) const
Tries to read given attribute assuming it is an int.
SVCPermissions myPermissions
Information about lane permissions.
std::string idAfter
The id for the edge after the split.
double length() const
Returns the length.
bool set(const std::string &name, const std::string &value)
Sets the given value for the named option.
bool myIsUpdate
Whether this edge definition is an update of a previously inserted edge.
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
Definition: NBCont.h:41
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
Definition: NBEdgeCont.cpp:251
void setPreferredVehicleClass(SVCPermissions permissions, int lane=-1)
set preferred Vehicle Class
Definition: NBEdge.cpp:2899
virtual std::string getStringSecure(int id, const std::string &def) const =0
Returns the string-value of the named (by its enum-value) attribute.
void myEndElement(int element)
Called when a closing tag occurs.
A storage for options typed value containers)
Definition: OptionsCont.h:99
NBEdge * myCurrentEdge
The currently processed edge.
void erase(NBDistrictCont &dc, NBEdge *edge)
Removes the given edge from the container (deleting it)
Definition: NBEdgeCont.cpp:385
bool insert(const std::string &id, const Position &position, NBDistrict *district=0)
Inserts a node into the map.
Definition: NBNodeCont.cpp:77
void addBikeLane(double width)
add a bicycle lane of the given width and shift existing connctions
Definition: NBEdge.cpp:3023
OptionsCont & myOptions
A reference to the program&#39;s options.
double myCurrentWidth
The current edge&#39;s lane width.
LaneSpreadFunction
Numbers representing special SUMO-XML-attribute values Information how the edge&#39;s lateral offset shal...
bool addLane2LaneConnection(int fromLane, NBEdge *dest, int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, bool keepClear=true, double contPos=UNSPECIFIED_CONTPOS, double visibility=UNSPECIFIED_VISIBILITY_DISTANCE)
Adds a connection between the specified this edge&#39;s lane and an approached one.
Definition: NBEdge.cpp:900
double speed
The speed after this change.
NBTypeCont & myTypeCont
The types container (for retrieval of type defaults)
const Position & getPosition() const
Definition: NBNode.h:232
Represents a single node (junction) during network building.
Definition: NBNode.h:75
bool myHaveReportedAboutTypeOverride
Information whether at least one edge&#39;s type was changed.
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
NBNode * getFromNode() const
Returns the origin node of the edge.
Definition: NBEdge.h:427
NBEdgeCont & myEdgeCont
The edges container (for insertion of build edges)
int myCurrentLaneNo
The current edge&#39;s number of lanes.
bool wasIgnored(std::string id) const
Returns whether the edge with the id was ignored during parsing.
Definition: NBEdgeCont.h:474
Container for nodes during the netbuilding process.
Definition: NBNodeCont.h:63
std::string myCurrentStreetName
The current edge&#39;s street name.
void addRoundabout(const EdgeSet &roundabout)
add user specified roundabout
delete certain element
double getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn&#39;t set.
Definition: NBEdge.h:490
double mySidewalkWidth
The width of the sidewalk that shall be added to the current edge.
#define WRITE_MESSAGE(msg)
Definition: MsgHandler.h:201
void invalidateTLS(NBTrafficLightLogicCont &tlCont)
causes the traffic light to be computed anew
Definition: NBNode.cpp:350
std::string idBefore
The id for the edge before the split.
Position positionAtOffset(double pos, double lateralOffset=0) const
Returns the position at the given length.
void addLane(const SUMOSAXAttributes &attrs)
Parses a lane and modifies myCurrentEdge according to the given attribures.
NBNode * getToNode() const
Returns the destination node of the edge.
Definition: NBEdge.h:434
int myCurrentPriority
The current edge&#39;s priority.
NBNode * node
The new node that is created for this split.
const SVCPermissions SVC_UNSPECIFIED
permissions not specified
void setLaneWidth(int lane, double width)
set lane specific width (negative lane implies set for all lanes)
Definition: NBEdge.cpp:2807
SVCPermissions getPermissions(const std::string &type) const
Returns allowed vehicle classes for the given type.
Definition: NBTypeCont.cpp:211
A storage for available types of edges.
Definition: NBTypeCont.h:62
PositionVector tryGetShape(const SUMOSAXAttributes &attrs)
Tries to parse the shape definition.