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-2015 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 #ifdef CHECK_MEMORY_LEAKS
59 #include <foreign/nvwa/debug_new.h>
60 #endif // CHECK_MEMORY_LEAKS
61 
62 
63 // ===========================================================================
64 // used constants
65 // ===========================================================================
67 
68 // ===========================================================================
69 // method definitions
70 // ===========================================================================
72  NBEdgeCont& ec,
73  NBTypeCont& tc,
74  NBDistrictCont& dc,
76  OptionsCont& options)
77  : SUMOSAXHandler("xml-edges - file"),
78  myOptions(options),
79  myNodeCont(nc),
80  myEdgeCont(ec),
81  myTypeCont(tc),
82  myDistrictCont(dc),
83  myTLLogicCont(tlc),
84  myCurrentEdge(0), myHaveReportedAboutOverwriting(false),
85  myHaveReportedAboutTypeOverride(false),
86  myHaveWarnedAboutDeprecatedLaneId(false),
87  myKeepEdgeShape(!options.getBool("plain.extend-edge-shape"))
88 {}
89 
90 
92 
93 
94 void
96  const SUMOSAXAttributes& attrs) {
97  switch (element) {
98  case SUMO_TAG_EDGE:
99  addEdge(attrs);
100  break;
101  case SUMO_TAG_LANE:
102  addLane(attrs);
103  break;
104  case SUMO_TAG_SPLIT:
105  addSplit(attrs);
106  break;
107  case SUMO_TAG_DELETE:
108  deleteEdge(attrs);
109  break;
110  case SUMO_TAG_ROUNDABOUT:
111  addRoundabout(attrs);
112  break;
113  default:
114  break;
115  }
116 }
117 
118 
119 void
121  myIsUpdate = false;
122  bool ok = true;
123  // initialise the edge
124  myCurrentEdge = 0;
125  mySplits.clear();
126  // get the id, report an error if not given or empty...
127  myCurrentID = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
128  if (!ok) {
129  return;
130  }
132  // check deprecated (unused) attributes
133  // use default values, first
137  if (myCurrentEdge != 0) {
138  // update existing edge. only update lane-specific settings when explicitly requested
139  myIsUpdate = true;
143  } else {
144  // this is a completely new edge. get the type specific defaults
148  }
149  myCurrentType = "";
153  myCurrentStreetName = "";
154  myReinitKeepEdgeShape = false;
157  // check whether a type's values shall be used
158  if (attrs.hasAttribute(SUMO_ATTR_TYPE)) {
159  myCurrentType = attrs.get<std::string>(SUMO_ATTR_TYPE, myCurrentID.c_str(), ok);
160  if (!ok) {
161  return;
162  }
163  if (!myTypeCont.knows(myCurrentType) && !myOptions.getBool("ignore-errors.edge-type")) {
164  WRITE_ERROR("Type '" + myCurrentType + "' used by edge '" + myCurrentID + "' was not defined (ignore with option --ignore-errors.edge-type).");
165  return;
166  }
174  }
175  // use values from the edge to overwrite if existing, then
176  if (myIsUpdate) {
178  WRITE_MESSAGE("Duplicate edge id occurred ('" + myCurrentID + "'); assuming overwriting is wished.");
180  }
183  WRITE_MESSAGE("Edge '" + myCurrentID + "' changed it's type; assuming type override is wished.");
185  }
186  }
187  if (attrs.getOpt<bool>(SUMO_ATTR_REMOVE, myCurrentID.c_str(), ok, false)) {
189  myCurrentEdge = 0;
190  return;
191  }
196  myReinitKeepEdgeShape = true;
197  }
201  }
203  }
204  // speed, priority and the number of lanes have now default values;
205  // try to read the real values from the file
206  if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
207  myCurrentSpeed = attrs.get<SUMOReal>(SUMO_ATTR_SPEED, myCurrentID.c_str(), ok);
208  }
209  if (myOptions.getBool("speed-in-kmh") && myCurrentSpeed != NBEdge::UNSPECIFIED_SPEED) {
211  }
212  // try to get the number of lanes
213  if (attrs.hasAttribute(SUMO_ATTR_NUMLANES)) {
214  myCurrentLaneNo = attrs.get<int>(SUMO_ATTR_NUMLANES, myCurrentID.c_str(), ok);
215  }
216  // try to get the priority
217  if (attrs.hasAttribute(SUMO_ATTR_PRIORITY)) {
218  myCurrentPriority = attrs.get<int>(SUMO_ATTR_PRIORITY, myCurrentID.c_str(), ok);
219  }
220  // try to get the width
221  if (attrs.hasAttribute(SUMO_ATTR_WIDTH)) {
222  myCurrentWidth = attrs.get<SUMOReal>(SUMO_ATTR_WIDTH, myCurrentID.c_str(), ok);
223  }
224  // try to get the offset of the stop line from the intersection
225  if (attrs.hasAttribute(SUMO_ATTR_ENDOFFSET)) {
227  }
228  // try to get the street name
229  if (attrs.hasAttribute(SUMO_ATTR_NAME)) {
230  myCurrentStreetName = attrs.get<std::string>(SUMO_ATTR_NAME, myCurrentID.c_str(), ok);
231  if (myCurrentStreetName != "" && myOptions.isDefault("output.street-names")) {
232  myOptions.set("output.street-names", "true");
233  }
234  }
235 
236  // try to get the allowed/disallowed classes
238  std::string allowS = attrs.hasAttribute(SUMO_ATTR_ALLOW) ? attrs.getStringSecure(SUMO_ATTR_ALLOW, "") : "";
239  std::string disallowS = attrs.hasAttribute(SUMO_ATTR_DISALLOW) ? attrs.getStringSecure(SUMO_ATTR_DISALLOW, "") : "";
240  // XXX matter of interpretation: should updated permissions replace or extend previously set permissions?
241  myPermissions = parseVehicleClasses(allowS, disallowS);
242  }
243  // try to set the nodes
244  if (!setNodes(attrs)) {
245  // return if this failed
246  return;
247  }
248  // try to get the shape
249  myShape = tryGetShape(attrs);
250  // try to get the spread type
252  // try to get the length
254  // try to get the sidewalkWidth
256  // try to get the bikeLaneWidth
258  // insert the parsed edge into the edges map
259  if (!ok) {
260  return;
261  }
262  // check whether a previously defined edge shall be overwritten
263  if (myCurrentEdge != 0) {
269  } else {
270  // the edge must be allocated in dependence to whether a shape is given
271  if (myShape.size() == 0) {
275  } else {
280  }
281  }
285  }
286 }
287 
288 
289 void
291  if (myCurrentEdge == 0) {
292  if (!OptionsCont::getOptions().isInStringVector("remove-edges.explicit", myCurrentID)) {
293  WRITE_ERROR("Additional lane information could not be set - the edge with id '" + myCurrentID + "' is not known.");
294  }
295  return;
296  }
297  bool ok = true;
298  int lane;
299  if (attrs.hasAttribute(SUMO_ATTR_ID)) {
300  lane = attrs.get<int>(SUMO_ATTR_ID, myCurrentID.c_str(), ok);
303  WRITE_WARNING("'" + toString(SUMO_ATTR_ID) + "' is deprecated, please use '" + toString(SUMO_ATTR_INDEX) + "' instead.");
304  }
305  } else {
306  lane = attrs.get<int>(SUMO_ATTR_INDEX, myCurrentID.c_str(), ok);
307  }
308  std::string allowed, disallowed, preferred;
309  allowed = attrs.getOpt<std::string>(SUMO_ATTR_ALLOW, 0, ok, "");
310  disallowed = attrs.getOpt<std::string>(SUMO_ATTR_DISALLOW, 0, ok, "");
311  preferred = attrs.getOpt<std::string>(SUMO_ATTR_PREFER, 0, ok, "");
312  if (!ok) {
313  return;
314  }
315  // check whether this lane exists
316  if (lane >= (int) myCurrentEdge->getNumLanes()) {
317  WRITE_ERROR("Lane index is larger than number of lanes (edge '" + myCurrentID + "').");
318  return;
319  }
320  // set information about allowed / disallowed vehicle classes
321  myCurrentEdge->setPermissions(parseVehicleClasses(allowed, disallowed), lane);
323  // try to get the width
324  if (attrs.hasAttribute(SUMO_ATTR_WIDTH)) {
325  myCurrentEdge->setLaneWidth(lane, attrs.get<SUMOReal>(SUMO_ATTR_WIDTH, myCurrentID.c_str(), ok));
326  }
327  // try to get the end-offset (lane shortened due to pedestrian crossing etc..)
328  if (attrs.hasAttribute(SUMO_ATTR_ENDOFFSET)) {
330  }
331  // try to get lane specific speed (should not occur for german networks)
332  if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
333  myCurrentEdge->setSpeed(lane, attrs.get<SUMOReal>(SUMO_ATTR_SPEED, myCurrentID.c_str(), ok));
334  }
335 }
336 
337 
339  if (myCurrentEdge == 0) {
340  if (!OptionsCont::getOptions().isInStringVector("remove-edges.explicit", myCurrentID)) {
341  WRITE_WARNING("Ignoring 'split' because it cannot be assigned to an edge");
342  }
343  return;
344  }
345  bool ok = true;
346  Split e;
347  e.pos = attrs.get<SUMOReal>(SUMO_ATTR_POSITION, 0, ok);
348  if (ok) {
349  if (fabs(e.pos) > myCurrentEdge->getGeometry().length()) {
350  WRITE_ERROR("Edge '" + myCurrentID + "' has a split at invalid position " + toString(e.pos) + ".");
351  return;
352  }
353  std::vector<Split>::iterator i = find_if(mySplits.begin(), mySplits.end(), split_by_pos_finder(e.pos));
354  if (i != mySplits.end()) {
355  WRITE_ERROR("Edge '" + myCurrentID + "' has already a split at position " + toString(e.pos) + ".");
356  return;
357  }
358  const std::string nameid = toString((int)e.pos);
359  if (e.pos < 0) {
361  }
362  std::vector<std::string> lanes;
363  SUMOSAXAttributes::parseStringVector(attrs.getOpt<std::string>(SUMO_ATTR_LANES, 0, ok, ""), lanes);
364  for (std::vector<std::string>::iterator i = lanes.begin(); i != lanes.end(); ++i) {
365  try {
366  int lane = TplConvert::_2int((*i).c_str());
367  e.lanes.push_back(lane);
368  } catch (NumberFormatException&) {
369  WRITE_ERROR("Error on parsing a split (edge '" + myCurrentID + "').");
370  } catch (EmptyData&) {
371  WRITE_ERROR("Error on parsing a split (edge '" + myCurrentID + "').");
372  }
373  }
374  if (e.lanes.empty()) {
375  for (size_t l = 0; l < myCurrentEdge->getNumLanes(); ++l) {
376  e.lanes.push_back((int) l);
377  }
378  }
379  e.speed = attrs.getOpt(SUMO_ATTR_SPEED, 0, ok, myCurrentEdge->getSpeed());
380  if (attrs.hasAttribute(SUMO_ATTR_SPEED) && myOptions.getBool("speed-in-kmh")) {
381  e.speed /= (SUMOReal) 3.6;
382  }
383  if (!ok) {
384  return;
385  }
386  e.node = new NBNode(myCurrentID + "." + nameid,
390  mySplits.push_back(e);
391  }
392 }
393 
394 
395 bool
397  // the names and the coordinates of the beginning and the end node
398  // may be found, try
399  bool ok = true;
400  std::string begNodeID = myIsUpdate ? myCurrentEdge->getFromNode()->getID() : "";
401  std::string endNodeID = myIsUpdate ? myCurrentEdge->getToNode()->getID() : "";
402  std::string oldBegID = begNodeID;
403  std::string oldEndID = endNodeID;
404  if (attrs.hasAttribute(SUMO_ATTR_FROM)) {
405  begNodeID = attrs.get<std::string>(SUMO_ATTR_FROM, 0, ok);
406  } else if (!myIsUpdate) {
407  WRITE_ERROR("The from-node is not given for edge '" + myCurrentID + "'.");
408  ok = false;
409  }
410  if (attrs.hasAttribute(SUMO_ATTR_TO)) {
411  endNodeID = attrs.get<std::string>(SUMO_ATTR_TO, 0, ok);
412  } else if (!myIsUpdate) {
413  WRITE_ERROR("The to-node is not given for edge '" + myCurrentID + "'.");
414  ok = false;
415  }
416  if (!ok) {
417  return false;
418  }
419  myFromNode = myNodeCont.retrieve(begNodeID);
420  myToNode = myNodeCont.retrieve(endNodeID);
421  if (myFromNode == 0) {
422  WRITE_ERROR("Edge's '" + myCurrentID + "' from-node '" + begNodeID + "' is not known.");
423  }
424  if (myToNode == 0) {
425  WRITE_ERROR("Edge's '" + myCurrentID + "' to-node '" + endNodeID + "' is not known.");
426  }
427  if (myFromNode != 0 && myToNode != 0) {
428  if (myIsUpdate && (myFromNode->getID() != oldBegID || myToNode->getID() != oldEndID)) {
430  }
431  }
432  return myFromNode != 0 && myToNode != 0;
433 }
434 
435 
438  if (!attrs.hasAttribute(SUMO_ATTR_SHAPE)) {
439  return myShape;
440  }
441  // try to build shape
442  bool ok = true;
443  if (!attrs.hasAttribute(SUMO_ATTR_SHAPE)) {
444  myReinitKeepEdgeShape = false;
445  return PositionVector();
446  }
449  WRITE_ERROR("Unable to project coordinates for edge '" + myCurrentID + "'.");
450  }
452  return shape;
453 }
454 
455 
458  bool ok = true;
460  std::string lsfS = toString(result);
461  lsfS = attrs.getOpt<std::string>(SUMO_ATTR_SPREADTYPE, myCurrentID.c_str(), ok, lsfS);
462  if (SUMOXMLDefinitions::LaneSpreadFunctions.hasString(lsfS)) {
464  } else {
465  WRITE_WARNING("Ignoring unknown spreadType '" + lsfS + "' for edge '" + myCurrentID + "'.");
466  }
467  return result;
468 }
469 
470 
471 void
473  bool ok = true;
474  myCurrentID = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
475  if (!ok) {
476  return;
477  }
479  if (edge == 0) {
480  WRITE_WARNING("Ignoring tag '" + toString(SUMO_TAG_DELETE) + "' for unknown edge '" +
481  myCurrentID + "'");
482  return;
483  }
484  myEdgeCont.extract(myDistrictCont, edge, true);
485 }
486 
487 
488 void
490  if (element == SUMO_TAG_EDGE && myCurrentEdge != 0) {
491  // add bike lane, wait until lanes are loaded to avoid building if it already exists
494  }
495  // add sidewalk, wait until lanes are loaded to avoid building if it already exists
498  }
499  if (!myIsUpdate) {
500  try {
502  WRITE_ERROR("Duplicate edge occured. ID='" + myCurrentID + "'");
503  delete myCurrentEdge;
504  }
505  } catch (InvalidArgument& e) {
506  WRITE_ERROR(e.what());
507  throw;
508  } catch (...) {
509  WRITE_ERROR("An important information is missing in edge '" + myCurrentID + "'.");
510  }
511  }
512  if (mySplits.size() != 0) {
513  std::vector<Split>::iterator i;
514  NBEdge* e = myCurrentEdge;
515  sort(mySplits.begin(), mySplits.end(), split_sorter());
516  unsigned int noLanesMax = e->getNumLanes();
517  // compute the node positions and sort the lanes
518  for (i = mySplits.begin(); i != mySplits.end(); ++i) {
519  sort((*i).lanes.begin(), (*i).lanes.end());
520  noLanesMax = MAX2(noLanesMax, (unsigned int)(*i).lanes.size());
521  }
522  // split the edge
523  std::vector<int> currLanes;
524  for (unsigned int l = 0; l < e->getNumLanes(); ++l) {
525  currLanes.push_back(l);
526  }
527  if (e->getNumLanes() != mySplits.back().lanes.size()) {
528  // invalidate traffic light definitions loaded from a SUMO network
529  // XXX it would be preferable to reconstruct the phase definitions heuristically
531  // if the number of lanes changes the connections should be
532  // recomputed
533  e->invalidateConnections(true);
534  }
535 
536  std::string edgeid = e->getID();
537  SUMOReal seen = 0;
538  for (i = mySplits.begin(); i != mySplits.end(); ++i) {
539  const Split& exp = *i;
540  assert(exp.lanes.size() != 0);
541  if (exp.pos > 0 && e->getGeometry().length() + seen > exp.pos && exp.pos > seen) {
542  if (myNodeCont.insert(exp.node)) {
544  // split the edge
545  std::string pid = e->getID();
546  myEdgeCont.splitAt(myDistrictCont, e, exp.pos - seen, exp.node,
547  pid, exp.node->getID(), e->getNumLanes(), (unsigned int) exp.lanes.size(), exp.speed);
548  seen = exp.pos;
549  std::vector<int> newLanes = exp.lanes;
550  NBEdge* pe = myEdgeCont.retrieve(pid);
551  NBEdge* ne = myEdgeCont.retrieve(exp.node->getID());
552  // reconnect lanes
553  pe->invalidateConnections(true);
554  // new on right
555  unsigned int rightMostP = currLanes[0];
556  unsigned int rightMostN = newLanes[0];
557  for (int l = 0; l < (int) rightMostP - (int) rightMostN; ++l) {
558  pe->addLane2LaneConnection(0, ne, l, NBEdge::L2L_VALIDATED, true);
559  }
560  // new on left
561  unsigned int leftMostP = currLanes.back();
562  unsigned int leftMostN = newLanes.back();
563  for (int l = 0; l < (int) leftMostN - (int) leftMostP; ++l) {
564  pe->addLane2LaneConnection(pe->getNumLanes() - 1, ne, leftMostN - l - rightMostN, NBEdge::L2L_VALIDATED, true);
565  }
566  // all other connected
567  for (unsigned int l = 0; l < noLanesMax; ++l) {
568  if (find(currLanes.begin(), currLanes.end(), l) == currLanes.end()) {
569  continue;
570  }
571  if (find(newLanes.begin(), newLanes.end(), l) == newLanes.end()) {
572  continue;
573  }
574  pe->addLane2LaneConnection(l - rightMostP, ne, l - rightMostN, NBEdge::L2L_VALIDATED, true);
575  }
576  // move to next
577  e = ne;
578  currLanes = newLanes;
579  } else {
580  WRITE_WARNING("Error on parsing a split (edge '" + myCurrentID + "').");
581  }
582  } else if (exp.pos == 0) {
583  if (e->getNumLanes() < exp.lanes.size()) {
584  e->incLaneNo((int) exp.lanes.size() - e->getNumLanes());
585  } else {
586  e->decLaneNo(e->getNumLanes() - (int) exp.lanes.size());
587  }
588  currLanes = exp.lanes;
589  // invalidate traffic light definition loaded from a SUMO network
590  // XXX it would be preferable to reconstruct the phase definitions heuristically
592  } else {
593  WRITE_WARNING("Split at '" + toString(exp.pos) + "' lies beyond the edge's length (edge '" + myCurrentID + "').");
594  }
595  }
596  // patch lane offsets
597  e = myEdgeCont.retrieve(edgeid);
598  if (mySplits.front().pos != 0) {
599  // add a dummy split at the beginning to ensure correct offset
600  Split start;
601  start.pos = 0;
602  for (int lane = 0; lane < (int)e->getNumLanes(); ++lane) {
603  start.lanes.push_back(lane);
604  }
605  mySplits.insert(mySplits.begin(), start);
606  }
607  i = mySplits.begin();
608  for (; i != mySplits.end(); ++i) {
609  unsigned int maxLeft = (*i).lanes.back();
610  SUMOReal offset = 0;
611  if (maxLeft < noLanesMax) {
613  offset = SUMO_const_laneWidthAndOffset * (noLanesMax - 1 - maxLeft);
614  } else {
615  offset = SUMO_const_halfLaneAndOffset * (noLanesMax - 1 - maxLeft);
616  }
617  }
618  unsigned int maxRight = (*i).lanes.front();
619  if (maxRight > 0 && e->getLaneSpreadFunction() == LANESPREAD_CENTER) {
620  offset -= SUMO_const_halfLaneAndOffset * maxRight;
621  }
622  if (offset != 0) {
623  PositionVector g = e->getGeometry();
624  g.move2side(offset);
625  e->setGeometry(g);
626  }
627  if (e->getToNode()->getOutgoingEdges().size() != 0) {
628  e = e->getToNode()->getOutgoingEdges()[0];
629  }
630  }
631  }
632  }
633 }
634 
635 
636 void
638  if (attrs.hasAttribute(SUMO_ATTR_EDGES)) {
639  std::vector<std::string> edgeIDs = attrs.getStringVector(SUMO_ATTR_EDGES);
640  EdgeSet roundabout;
641  for (std::vector<std::string>::iterator it = edgeIDs.begin(); it != edgeIDs.end(); ++it) {
642  NBEdge* edge = myEdgeCont.retrieve(*it);
643  if (edge == 0) {
644  if (!myEdgeCont.wasIgnored(*it)) {
645  WRITE_ERROR("Unknown edge '" + (*it) + "' in roundabout");
646  }
647  } else {
648  roundabout.insert(edge);
649  }
650  }
651  myEdgeCont.addRoundabout(roundabout);
652  } else {
653  WRITE_ERROR("Empty edges in roundabout.");
654  }
655 }
656 
657 
658 
659 /****************************************************************************/
660 
void invalidateConnections(bool reallowSetting=false)
Definition: NBEdge.cpp:943
The information about how to spread the lanes from the given position.
const std::string & getTypeID() const
Definition: NBEdge.h:905
static const SUMOReal UNSPECIFIED_WIDTH
unspecified lane width
Definition: NBEdge.h:201
LaneSpreadFunction myLanesSpread
Information about how to spread the lanes.
Finds a split at the given position.
static bool transformCoordinates(Position &from, bool includeInBoundary=true, GeoConvHelper *from_srs=0)
transforms loaded coordinates handles projections, offsets (using GeoConvHelper) and import of height...
bool hasDefaultGeometry() const
Returns whether the geometry consists only of the node positions.
Definition: NBEdge.cpp:414
std::string myCurrentID
The current edge&#39;s id.
const SUMOReal SUMO_const_halfLaneAndOffset
Definition: StdDefs.h:54
static StringBijection< LaneSpreadFunction > LaneSpreadFunctions
void markAsSplit(const NBNode *node)
mark a node as being created form a split
Definition: NBNodeCont.h:326
PositionVector myShape
The shape of the edge.
A container for traffic light definitions and built programs.
void setLaneWidth(int lane, SUMOReal width)
set lane specific width (negative lane implies set for all lanes)
Definition: NBEdge.cpp:2263
SUMOReal myBikeLaneWidth
The width of the bike lane that shall be added to the current edge.
void setSpeed(int lane, SUMOReal speed)
set lane specific speed (negative lane implies set for all lanes)
Definition: NBEdge.cpp:2318
void addRoundabout(const SUMOSAXAttributes &attrs)
Parses a roundabout and stores it in myEdgeCont.
SUMOReal mySidewalkWidth
The width of the sidewalk that shall be added to the current edge.
const SUMOReal SUMO_const_laneWidthAndOffset
Definition: StdDefs.h:53
bool setNodes(const SUMOSAXAttributes &attrs)
Sets from/to node information of the currently parsed edge.
void addSidewalk(SUMOReal width)
add a pedestrian sidewalk of the given width and shift existing connctions
Definition: NBEdge.cpp:2447
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:70
void incLaneNo(unsigned int by)
Definition: NBEdge.cpp:2179
NBNode * myFromNode
The nodes the edge starts and ends at.
bool addLane2LaneConnection(unsigned int fromLane, NBEdge *dest, unsigned int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, bool keepClear=true, SUMOReal contPos=UNSPECIFIED_CONTPOS)
Adds a connection between the specified this edge&#39;s lane and an approached one.
Definition: NBEdge.cpp:675
const SUMOReal SUMOXML_INVALID_POSITION
A container for districts.
static const SUMOReal UNSPECIFIED_SPEED
unspecified lane speed
Definition: NBEdge.h:205
NIXMLEdgesHandler(NBNodeCont &nc, NBEdgeCont &ec, NBTypeCont &tc, NBDistrictCont &dc, NBTrafficLightLogicCont &tlc, OptionsCont &options)
Constructor.
T MAX2(T a, T b)
Definition: StdDefs.h:79
bool myHaveReportedAboutOverwriting
Information whether at least one edge&#39;s attributes were overwritten.
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:2334
bool splitAt(NBDistrictCont &dc, NBEdge *edge, NBNode *node)
Splits the edge at the position nearest to the given node.
Definition: NBEdgeCont.cpp:411
NBDistrictCont & myDistrictCont
The districts container (needed if an edge must be split)
static const SUMOReal UNSPECIFIED_OFFSET
unspecified lane offset
Definition: NBEdge.h:203
SAX-handler base for SUMO-files.
void setGeometry(const PositionVector &g, bool inner=false)
(Re)sets the edge&#39;s geometry
Definition: NBEdge.cpp:427
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list...
SUMOReal getWidth(const std::string &type) const
Returns the lane width for the given type [m].
Definition: NBTypeCont.cpp:217
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:200
The connection was computed and validated.
Definition: NBEdge.h:115
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:69
const bool myKeepEdgeShape
Whether the edge shape shall be kept generally.
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.
SUMOReal getSidewalkWidth(const std::string &type) const
Returns the lane width for a sidewalk to be added [m].
Definition: NBTypeCont.cpp:223
const EdgeVector & getOutgoingEdges() const
Returns this node&#39;s outgoing edges.
Definition: NBNode.h:248
SUMOReal getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn&#39;t set.
Definition: NBEdge.h:413
const std::string & getID() const
Returns the id.
Definition: Named.h:65
static void parseStringVector(const std::string &def, std::vector< std::string > &into)
Splits the given string.
const Position & getPosition() const
Returns the position of this node.
Definition: NBNode.h:228
SUMOReal getSpeed(const std::string &type) const
Returns the maximal velocity for the given type [m/s].
Definition: NBTypeCont.cpp:181
std::vector< Split > mySplits
The list of this edge&#39;s splits.
SUMOReal getBikeLaneWidth(const std::string &type) const
Returns the lane width for a bike lane to be added [m].
Definition: NBTypeCont.cpp:229
std::set< NBEdge * > EdgeSet
Definition: NBCont.h:51
the edges of a route
int getPriority() const
Returns the priority of the edge.
Definition: NBEdge.h:353
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
Definition: NBEdgeCont.cpp:161
bool myHaveWarnedAboutDeprecatedLaneId
Encapsulated SAX-Attributes.
SUMOReal speed
The speed after this change.
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:387
void deleteEdge(const SUMOSAXAttributes &attrs)
parses delete tag and deletes the specified edge
int getNumLanes(const std::string &type) const
Returns the number of lanes for the given type.
Definition: NBTypeCont.cpp:175
A structure which describes changes of lane number or speed along the road.
A list of positions.
void addSplit(const SUMOSAXAttributes &attrs)
Parses a split and stores it in mySplits. Splits are executed Upon reading the end tag of an edge...
unsigned int getNumLanes() const
Returns the number of lanes.
Definition: NBEdge.h:345
std::string myCurrentType
The current edge&#39;s type.
int getPriority(const std::string &type) const
Returns the priority for the given type.
Definition: NBTypeCont.cpp:187
bool hasLoadedLength() const
Returns whether a length was set explicitly.
Definition: NBEdge.h:421
Position positionAtOffset(SUMOReal pos, SUMOReal lateralOffset=0) const
Returns the position at the given length.
SUMOReal myCurrentEndOffset
The current edge&#39;s offset till the destination node.
Storage for edges, including some functionality operating on multiple edges.
Definition: NBEdgeCont.h:66
std::vector< int > lanes
The lanes after this change.
NBNodeCont & myNodeCont
The nodes container (for retrieval of referenced nodes)
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)
bool isDefault(const std::string &name) const
Returns the information whether the named option has still the default value.
bool knows(const std::string &type) const
Returns whether the named type is in the container.
Definition: NBTypeCont.cpp:75
LaneSpreadFunction tryGetLaneSpread(const SUMOSAXAttributes &attrs)
Tries to parse the spread type.
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
Definition: ToString.h:53
void setLoadedLength(SUMOReal val)
Definition: NBEdge.cpp:2377
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:205
SUMOReal length() const
Returns the length.
void addBikeLane(SUMOReal width)
add a bicycle lane of the given width and shift existing connctions
Definition: NBEdge.cpp:2453
void decLaneNo(unsigned int by)
Definition: NBEdge.cpp:2205
static int _2int(const E *const data)
Definition: TplConvert.h:114
NBNode * getToNode() const
Returns the destination node of the edge.
Definition: NBEdge.h:369
SVCPermissions myPermissions
Information about lane permissions.
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.
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
Definition: NBEdgeCont.cpp:246
SUMOReal myCurrentSpeed
The current edge&#39;s maximum speed.
static const SUMOReal UNSPECIFIED_LOADED_LENGTH
no length override given
Definition: NBEdge.h:210
void setPreferredVehicleClass(SVCPermissions permissions, int lane=-1)
Definition: NBEdge.cpp:2348
const PositionVector & getGeometry() const
Returns the geometry of the edge.
Definition: NBEdge.h:521
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:108
NBEdge * myCurrentEdge
The currently processed edge.
void erase(NBDistrictCont &dc, NBEdge *edge)
Removes the given edge from the container (deleting it)
Definition: NBEdgeCont.cpp:380
bool insert(const std::string &id, const Position &position, NBDistrict *district=0)
Inserts a node into the map.
Definition: NBNodeCont.cpp:80
OptionsCont & myOptions
A reference to the program&#39;s options.
LaneSpreadFunction
Numbers representing special SUMO-XML-attribute values Information how the edge&#39;s lateral offset shal...
NBTypeCont & myTypeCont
The types container (for retrieval of type defaults)
LaneSpreadFunction getLaneSpreadFunction() const
Returns how this edge&#39;s lanes&#39; lateral offset is computed.
Definition: NBEdge.h:601
Represents a single node (junction) during network building.
Definition: NBNode.h:74
T get(const std::string &str) const
void move2side(SUMOReal amount)
bool myHaveReportedAboutTypeOverride
Information whether at least one edge&#39;s type was changed.
void setEndOffset(int lane, SUMOReal offset)
set lane specific end-offset (negative lane implies set for all lanes)
Definition: NBEdge.cpp:2302
#define SUMOReal
Definition: config.h:214
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.
bool wasIgnored(std::string id) const
Returns whether the edge with the id was ignored during parsing.
Definition: NBEdgeCont.h:464
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
NBEdgeCont & myEdgeCont
The edges container (for insertion of build edges)
NBNode * retrieve(const std::string &id) const
Returns the node with the given name.
Definition: NBNodeCont.cpp:109
int myCurrentLaneNo
The current edge&#39;s number of lanes.
SVCPermissions getPermissions(const std::string &type) const
Returns allowed vehicle classes for the given type.
Definition: NBTypeCont.cpp:211
SUMOReal getSpeed() const
Returns the speed allowed on this edge.
Definition: NBEdge.h:429
Container for nodes during the netbuilding process.
Definition: NBNodeCont.h:64
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
SUMOReal myCurrentWidth
The current edge&#39;s lane width.
SUMOReal myLength
The current edge&#39;s length.
SUMOReal pos
The position of this change.
std::string myCurrentStreetName
The current edge&#39;s street name.
void addRoundabout(const EdgeSet &roundabout)
add user specified roundabout
Definition: NBEdgeCont.cpp:941
#define WRITE_MESSAGE(msg)
Definition: MsgHandler.h:201
void invalidateTLS(NBTrafficLightLogicCont &tlCont)
causes the traffic light to be computed anew
Definition: NBNode.cpp:352
const std::string & getStreetName() const
Returns the street name of this edge.
Definition: NBEdge.h:463
void addLane(const SUMOSAXAttributes &attrs)
Parses a lane and modifies myCurrentEdge according to the given attribures.
int myCurrentPriority
The current edge&#39;s priority.
NBNode * node
The new node that is created for this split.
const SVCPermissions SVC_UNSPECIFIED
void reinit(NBNode *from, NBNode *to, const std::string &type, SUMOReal speed, unsigned int nolanes, int priority, PositionVector geom, SUMOReal width, SUMOReal offset, const std::string &streetName, LaneSpreadFunction spread=LANESPREAD_RIGHT, bool tryIgnoreNodePositions=false)
Resets initial values.
Definition: NBEdge.cpp:266
A storage for available types of edges.
Definition: NBTypeCont.h:62
PositionVector tryGetShape(const SUMOSAXAttributes &attrs)
Tries to parse the shape definition.
NBNode * getFromNode() const
Returns the origin node of the edge.
Definition: NBEdge.h:361