SUMO - Simulation of Urban MObility
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
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-2016 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 // method definitions
65 // ===========================================================================
67  NBEdgeCont& ec,
68  NBTypeCont& tc,
69  NBDistrictCont& dc,
71  OptionsCont& options)
72  : SUMOSAXHandler("xml-edges - file"),
73  myOptions(options),
74  myNodeCont(nc),
75  myEdgeCont(ec),
76  myTypeCont(tc),
77  myDistrictCont(dc),
78  myTLLogicCont(tlc),
79  myCurrentEdge(0), myHaveReportedAboutOverwriting(false),
80  myHaveReportedAboutTypeOverride(false),
81  myHaveWarnedAboutDeprecatedLaneId(false),
82  myKeepEdgeShape(!options.getBool("plain.extend-edge-shape")) {
83 }
84 
85 
87 
88 
89 void
91  const SUMOSAXAttributes& attrs) {
92  switch (element) {
93  case SUMO_TAG_EDGE:
94  addEdge(attrs);
95  break;
96  case SUMO_TAG_LANE:
97  addLane(attrs);
98  break;
99  case SUMO_TAG_NEIGH:
101  break;
102  case SUMO_TAG_SPLIT:
103  addSplit(attrs);
104  break;
105  case SUMO_TAG_DELETE:
106  deleteEdge(attrs);
107  break;
108  case SUMO_TAG_ROUNDABOUT:
109  addRoundabout(attrs);
110  break;
111  default:
112  break;
113  }
114 }
115 
116 
117 void
119  myIsUpdate = false;
120  bool ok = true;
121  // initialise the edge
122  myCurrentEdge = 0;
123  mySplits.clear();
124  // get the id, report an error if not given or empty...
125  myCurrentID = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
126  if (!ok) {
127  return;
128  }
130  // check deprecated (unused) attributes
131  // use default values, first
135  if (myCurrentEdge != 0) {
136  // update existing edge. only update lane-specific settings when explicitly requested
137  myIsUpdate = true;
141  } else {
142  // this is a completely new edge. get the type specific defaults
146  }
147  myCurrentType = "";
151  myCurrentStreetName = "";
152  myReinitKeepEdgeShape = false;
155  // check whether a type's values shall be used
156  if (attrs.hasAttribute(SUMO_ATTR_TYPE)) {
157  myCurrentType = attrs.get<std::string>(SUMO_ATTR_TYPE, myCurrentID.c_str(), ok);
158  if (!ok) {
159  return;
160  }
161  if (!myTypeCont.knows(myCurrentType) && !myOptions.getBool("ignore-errors.edge-type")) {
162  WRITE_ERROR("Type '" + myCurrentType + "' used by edge '" + myCurrentID + "' was not defined (ignore with option --ignore-errors.edge-type).");
163  return;
164  }
172  }
173  // use values from the edge to overwrite if existing, then
174  if (myIsUpdate) {
176  WRITE_MESSAGE("Duplicate edge id occurred ('" + myCurrentID + "'); assuming overwriting is wished.");
178  }
181  WRITE_MESSAGE("Edge '" + myCurrentID + "' changed it's type; assuming type override is wished.");
183  }
184  }
185  if (attrs.getOpt<bool>(SUMO_ATTR_REMOVE, myCurrentID.c_str(), ok, false)) {
187  myCurrentEdge = 0;
188  return;
189  }
194  myReinitKeepEdgeShape = true;
195  }
199  }
201  }
202  // speed, priority and the number of lanes have now default values;
203  // try to read the real values from the file
204  if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
205  myCurrentSpeed = attrs.get<SUMOReal>(SUMO_ATTR_SPEED, myCurrentID.c_str(), ok);
206  }
207  if (myOptions.getBool("speed-in-kmh") && myCurrentSpeed != NBEdge::UNSPECIFIED_SPEED) {
209  }
210  // try to get the number of lanes
211  if (attrs.hasAttribute(SUMO_ATTR_NUMLANES)) {
212  myCurrentLaneNo = attrs.get<int>(SUMO_ATTR_NUMLANES, myCurrentID.c_str(), ok);
213  }
214  // try to get the priority
215  if (attrs.hasAttribute(SUMO_ATTR_PRIORITY)) {
216  myCurrentPriority = attrs.get<int>(SUMO_ATTR_PRIORITY, myCurrentID.c_str(), ok);
217  }
218  // try to get the width
219  if (attrs.hasAttribute(SUMO_ATTR_WIDTH)) {
220  myCurrentWidth = attrs.get<SUMOReal>(SUMO_ATTR_WIDTH, myCurrentID.c_str(), ok);
221  }
222  // try to get the offset of the stop line from the intersection
223  if (attrs.hasAttribute(SUMO_ATTR_ENDOFFSET)) {
225  }
226  // try to get the street name
227  if (attrs.hasAttribute(SUMO_ATTR_NAME)) {
228  myCurrentStreetName = attrs.get<std::string>(SUMO_ATTR_NAME, myCurrentID.c_str(), ok);
229  if (myCurrentStreetName != "" && myOptions.isDefault("output.street-names")) {
230  myOptions.set("output.street-names", "true");
231  }
232  }
233 
234  // try to get the allowed/disallowed classes
236  std::string allowS = attrs.hasAttribute(SUMO_ATTR_ALLOW) ? attrs.getStringSecure(SUMO_ATTR_ALLOW, "") : "";
237  std::string disallowS = attrs.hasAttribute(SUMO_ATTR_DISALLOW) ? attrs.getStringSecure(SUMO_ATTR_DISALLOW, "") : "";
238  // XXX matter of interpretation: should updated permissions replace or extend previously set permissions?
239  myPermissions = parseVehicleClasses(allowS, disallowS);
240  }
241  // try to set the nodes
242  if (!setNodes(attrs)) {
243  // return if this failed
244  return;
245  }
246  // try to get the shape
247  myShape = tryGetShape(attrs);
248  // try to get the spread type
250  // try to get the length
252  // try to get the sidewalkWidth
254  // try to get the bikeLaneWidth
256  // insert the parsed edge into the edges map
257  if (!ok) {
258  return;
259  }
260  // check whether a previously defined edge shall be overwritten
261  if (myCurrentEdge != 0) {
267  } else {
268  // the edge must be allocated in dependence to whether a shape is given
269  if (myShape.size() == 0) {
273  } else {
278  }
279  }
283  }
284 }
285 
286 
287 void
289  if (myCurrentEdge == 0) {
290  if (!OptionsCont::getOptions().isInStringVector("remove-edges.explicit", myCurrentID)) {
291  WRITE_ERROR("Additional lane information could not be set - the edge with id '" + myCurrentID + "' is not known.");
292  }
293  return;
294  }
295  bool ok = true;
296  int lane;
297  if (attrs.hasAttribute(SUMO_ATTR_ID)) {
298  lane = attrs.get<int>(SUMO_ATTR_ID, myCurrentID.c_str(), ok);
301  WRITE_WARNING("'" + toString(SUMO_ATTR_ID) + "' is deprecated, please use '" + toString(SUMO_ATTR_INDEX) + "' instead.");
302  }
303  } else {
304  lane = attrs.get<int>(SUMO_ATTR_INDEX, myCurrentID.c_str(), ok);
305  }
306  if (!ok) {
307  return;
308  }
309  // check whether this lane exists
310  if (lane >= (int) myCurrentEdge->getNumLanes()) {
311  WRITE_ERROR("Lane index is larger than number of lanes (edge '" + myCurrentID + "').");
312  return;
313  }
314  // set information about allowed / disallowed vehicle classes (if specified)
316  const std::string allowed = attrs.getOpt<std::string>(SUMO_ATTR_ALLOW, 0, ok, "");
317  const std::string disallowed = attrs.getOpt<std::string>(SUMO_ATTR_DISALLOW, 0, ok, "");
318  myCurrentEdge->setPermissions(parseVehicleClasses(allowed, disallowed), lane);
319  }
320  if (attrs.hasAttribute(SUMO_ATTR_PREFER)) {
321  const std::string preferred = attrs.get<std::string>(SUMO_ATTR_PREFER, 0, ok);
323  }
324  // try to get the width
325  if (attrs.hasAttribute(SUMO_ATTR_WIDTH)) {
326  myCurrentEdge->setLaneWidth(lane, attrs.get<SUMOReal>(SUMO_ATTR_WIDTH, myCurrentID.c_str(), ok));
327  }
328  // try to get the end-offset (lane shortened due to pedestrian crossing etc..)
329  if (attrs.hasAttribute(SUMO_ATTR_ENDOFFSET)) {
331  }
332  // try to get lane specific speed (should not occur for german networks)
333  if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
334  myCurrentEdge->setSpeed(lane, attrs.get<SUMOReal>(SUMO_ATTR_SPEED, 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<SUMOReal>(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 /= (SUMOReal) 3.6;
383  }
384  if (!ok) {
385  return;
386  }
387  e.node = new NBNode(myCurrentID + "." + nameid,
391  mySplits.push_back(e);
392  }
393 }
394 
395 
396 bool
398  // the names and the coordinates of the beginning and the end node
399  // may be found, try
400  bool ok = true;
401  std::string begNodeID = myIsUpdate ? myCurrentEdge->getFromNode()->getID() : "";
402  std::string endNodeID = myIsUpdate ? myCurrentEdge->getToNode()->getID() : "";
403  std::string oldBegID = begNodeID;
404  std::string oldEndID = endNodeID;
405  if (attrs.hasAttribute(SUMO_ATTR_FROM)) {
406  begNodeID = attrs.get<std::string>(SUMO_ATTR_FROM, 0, ok);
407  } else if (!myIsUpdate) {
408  WRITE_ERROR("The from-node is not given for edge '" + myCurrentID + "'.");
409  ok = false;
410  }
411  if (attrs.hasAttribute(SUMO_ATTR_TO)) {
412  endNodeID = attrs.get<std::string>(SUMO_ATTR_TO, 0, ok);
413  } else if (!myIsUpdate) {
414  WRITE_ERROR("The to-node is not given for edge '" + myCurrentID + "'.");
415  ok = false;
416  }
417  if (!ok) {
418  return false;
419  }
420  myFromNode = myNodeCont.retrieve(begNodeID);
421  myToNode = myNodeCont.retrieve(endNodeID);
422  if (myFromNode == 0) {
423  WRITE_ERROR("Edge's '" + myCurrentID + "' from-node '" + begNodeID + "' is not known.");
424  }
425  if (myToNode == 0) {
426  WRITE_ERROR("Edge's '" + myCurrentID + "' to-node '" + endNodeID + "' is not known.");
427  }
428  if (myFromNode != 0 && myToNode != 0) {
429  if (myIsUpdate && (myFromNode->getID() != oldBegID || myToNode->getID() != oldEndID)) {
431  }
432  }
433  return myFromNode != 0 && myToNode != 0;
434 }
435 
436 
439  if (!attrs.hasAttribute(SUMO_ATTR_SHAPE)) {
440  return myShape;
441  }
442  // try to build shape
443  bool ok = true;
444  if (!attrs.hasAttribute(SUMO_ATTR_SHAPE)) {
445  myReinitKeepEdgeShape = false;
446  return PositionVector();
447  }
450  WRITE_ERROR("Unable to project coordinates for edge '" + myCurrentID + "'.");
451  }
453  return shape;
454 }
455 
456 
459  bool ok = true;
461  std::string lsfS = toString(result);
462  lsfS = attrs.getOpt<std::string>(SUMO_ATTR_SPREADTYPE, myCurrentID.c_str(), ok, lsfS);
463  if (SUMOXMLDefinitions::LaneSpreadFunctions.hasString(lsfS)) {
465  } else {
466  WRITE_WARNING("Ignoring unknown spreadType '" + lsfS + "' for edge '" + myCurrentID + "'.");
467  }
468  return result;
469 }
470 
471 
472 void
474  bool ok = true;
475  myCurrentID = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
476  if (!ok) {
477  return;
478  }
480  if (edge == 0) {
481  WRITE_WARNING("Ignoring tag '" + toString(SUMO_TAG_DELETE) + "' for unknown edge '" +
482  myCurrentID + "'");
483  return;
484  }
485  myEdgeCont.extract(myDistrictCont, edge, true);
486 }
487 
488 
489 void
491  if (element == SUMO_TAG_EDGE && myCurrentEdge != 0) {
492  // add bike lane, wait until lanes are loaded to avoid building if it already exists
495  }
496  // add sidewalk, wait until lanes are loaded to avoid building if it already exists
499  }
500  if (!myIsUpdate) {
501  try {
503  WRITE_ERROR("Duplicate edge occured. ID='" + myCurrentID + "'");
504  delete myCurrentEdge;
505  }
506  } catch (InvalidArgument& e) {
507  WRITE_ERROR(e.what());
508  throw;
509  } catch (...) {
510  WRITE_ERROR("An important information is missing in edge '" + myCurrentID + "'.");
511  }
512  }
513  if (mySplits.size() != 0) {
514  std::vector<Split>::iterator i;
515  NBEdge* e = myCurrentEdge;
516  sort(mySplits.begin(), mySplits.end(), split_sorter());
517  int noLanesMax = e->getNumLanes();
518  // compute the node positions and sort the lanes
519  for (i = mySplits.begin(); i != mySplits.end(); ++i) {
520  sort((*i).lanes.begin(), (*i).lanes.end());
521  noLanesMax = MAX2(noLanesMax, (int)(*i).lanes.size());
522  }
523  // split the edge
524  std::vector<int> currLanes;
525  for (int l = 0; l < e->getNumLanes(); ++l) {
526  currLanes.push_back(l);
527  }
528  if (e->getNumLanes() != (int)mySplits.back().lanes.size()) {
529  // invalidate traffic light definitions loaded from a SUMO network
530  // XXX it would be preferable to reconstruct the phase definitions heuristically
532  // if the number of lanes changes the connections should be
533  // recomputed
534  e->invalidateConnections(true);
535  }
536 
537  std::string edgeid = e->getID();
538  SUMOReal seen = 0;
539  for (i = mySplits.begin(); i != mySplits.end(); ++i) {
540  const Split& exp = *i;
541  assert(exp.lanes.size() != 0);
542  if (exp.pos > 0 && e->getGeometry().length() + seen > exp.pos && exp.pos > seen) {
543  if (myNodeCont.insert(exp.node)) {
545  // split the edge
546  std::string pid = e->getID();
547  myEdgeCont.splitAt(myDistrictCont, e, exp.pos - seen, exp.node,
548  pid, exp.node->getID(), e->getNumLanes(), (int) exp.lanes.size(), exp.speed);
549  seen = exp.pos;
550  std::vector<int> newLanes = exp.lanes;
551  NBEdge* pe = myEdgeCont.retrieve(pid);
552  NBEdge* ne = myEdgeCont.retrieve(exp.node->getID());
553  // reconnect lanes
554  pe->invalidateConnections(true);
555  // new on right
556  int rightMostP = currLanes[0];
557  int rightMostN = newLanes[0];
558  for (int l = 0; l < (int) rightMostP - (int) rightMostN; ++l) {
559  pe->addLane2LaneConnection(0, ne, l, NBEdge::L2L_VALIDATED, true);
560  }
561  // new on left
562  int leftMostP = currLanes.back();
563  int leftMostN = newLanes.back();
564  for (int l = 0; l < (int) leftMostN - (int) leftMostP; ++l) {
565  pe->addLane2LaneConnection(pe->getNumLanes() - 1, ne, leftMostN - l - rightMostN, NBEdge::L2L_VALIDATED, true);
566  }
567  // all other connected
568  for (int l = 0; l < noLanesMax; ++l) {
569  if (find(currLanes.begin(), currLanes.end(), l) == currLanes.end()) {
570  continue;
571  }
572  if (find(newLanes.begin(), newLanes.end(), l) == newLanes.end()) {
573  continue;
574  }
575  pe->addLane2LaneConnection(l - rightMostP, ne, l - rightMostN, NBEdge::L2L_VALIDATED, true);
576  }
577  // move to next
578  e = ne;
579  currLanes = newLanes;
580  } else {
581  WRITE_WARNING("Error on parsing a split (edge '" + myCurrentID + "').");
582  }
583  } else if (exp.pos == 0) {
584  const int laneCountDiff = e->getNumLanes() - (int)exp.lanes.size();
585  if (laneCountDiff < 0) {
586  e->incLaneNo(-laneCountDiff);
587  } else {
588  e->decLaneNo(laneCountDiff);
589  }
590  currLanes = exp.lanes;
591  // invalidate traffic light definition loaded from a SUMO network
592  // XXX it would be preferable to reconstruct the phase definitions heuristically
594  } else {
595  WRITE_WARNING("Split at '" + toString(exp.pos) + "' lies beyond the edge's length (edge '" + myCurrentID + "').");
596  }
597  }
598  // patch lane offsets
599  e = myEdgeCont.retrieve(edgeid);
600  if (mySplits.front().pos != 0) {
601  // add a dummy split at the beginning to ensure correct offset
602  Split start;
603  start.pos = 0;
604  for (int lane = 0; lane < (int)e->getNumLanes(); ++lane) {
605  start.lanes.push_back(lane);
606  }
607  mySplits.insert(mySplits.begin(), start);
608  }
609  i = mySplits.begin();
610  for (; i != mySplits.end(); ++i) {
611  int maxLeft = (*i).lanes.back();
612  SUMOReal offset = 0;
613  if (maxLeft < noLanesMax) {
615  offset = SUMO_const_laneWidthAndOffset * (noLanesMax - 1 - maxLeft);
616  } else {
617  offset = SUMO_const_halfLaneAndOffset * (noLanesMax - 1 - maxLeft);
618  }
619  }
620  int maxRight = (*i).lanes.front();
621  if (maxRight > 0 && e->getLaneSpreadFunction() == LANESPREAD_CENTER) {
622  offset -= SUMO_const_halfLaneAndOffset * maxRight;
623  }
624  if (offset != 0) {
625  PositionVector g = e->getGeometry();
626  g.move2side(offset);
627  e->setGeometry(g);
628  }
629  if (e->getToNode()->getOutgoingEdges().size() != 0) {
630  e = e->getToNode()->getOutgoingEdges()[0];
631  }
632  }
633  }
634  }
635 }
636 
637 
638 void
640  if (attrs.hasAttribute(SUMO_ATTR_EDGES)) {
641  std::vector<std::string> edgeIDs = attrs.getStringVector(SUMO_ATTR_EDGES);
642  EdgeSet roundabout;
643  for (std::vector<std::string>::iterator it = edgeIDs.begin(); it != edgeIDs.end(); ++it) {
644  NBEdge* edge = myEdgeCont.retrieve(*it);
645  if (edge == 0) {
646  if (!myEdgeCont.wasIgnored(*it)) {
647  WRITE_ERROR("Unknown edge '" + (*it) + "' in roundabout");
648  }
649  } else {
650  roundabout.insert(edge);
651  }
652  }
653  myEdgeCont.addRoundabout(roundabout);
654  } else {
655  WRITE_ERROR("Empty edges in roundabout.");
656  }
657 }
658 
659 
660 
661 /****************************************************************************/
662 
void invalidateConnections(bool reallowSetting=false)
invalidate current connections of edge
Definition: NBEdge.cpp:1111
The information about how to spread the lanes from the given position.
const std::string & getTypeID() const
get ID of type
Definition: NBEdge.h:934
static const SUMOReal UNSPECIFIED_WIDTH
unspecified lane width
Definition: NBEdge.h:237
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:480
std::string myCurrentID
The current edge'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:324
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:2627
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:2682
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:2824
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
The representation of a single edge during network building.
Definition: NBEdge.h:71
NBNode * myFromNode
The nodes the edge starts and ends at.
A container for districts.
static const SUMOReal UNSPECIFIED_SPEED
unspecified lane speed
Definition: NBEdge.h:243
NIXMLEdgesHandler(NBNodeCont &nc, NBEdgeCont &ec, NBTypeCont &tc, NBDistrictCont &dc, NBTrafficLightLogicCont &tlc, OptionsCont &options)
Constructor.
T MAX2(T a, T b)
Definition: StdDefs.h:75
bool myHaveReportedAboutOverwriting
Information whether at least one edge'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:2698
bool splitAt(NBDistrictCont &dc, NBEdge *edge, NBNode *node)
Splits the edge at the position nearest to the given node.
Definition: NBEdgeCont.cpp:412
NBDistrictCont & myDistrictCont
The districts container (needed if an edge must be split)
Lane & getLaneStruct(int lane)
Definition: NBEdge.h:1117
static const SUMOReal UNSPECIFIED_OFFSET
unspecified lane offset
Definition: NBEdge.h:240
SAX-handler base for SUMO-files.
void setGeometry(const PositionVector &g, bool inner=false)
(Re)sets the edge's geometry
Definition: NBEdge.cpp:493
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:221
#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:69
void reinit(NBNode *from, NBNode *to, const std::string &type, SUMOReal speed, 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:319
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.
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:227
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges.
Definition: NBNode.h:248
SUMOReal getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn't set.
Definition: NBEdge.h:472
const std::string & getID() const
Returns the id.
Definition: Named.h:66
void incLaneNo(int by)
increment lane
Definition: NBEdge.cpp:2543
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:185
std::vector< Split > mySplits
The list of this edge's splits.
SUMOReal getBikeLaneWidth(const std::string &type) const
Returns the lane width for a bike lane to be added [m].
Definition: NBTypeCont.cpp:233
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:402
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
Definition: NBEdgeCont.cpp:162
bool myHaveWarnedAboutDeprecatedLaneId
void decLaneNo(int by)
decrement lane
Definition: NBEdge.cpp:2569
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:388
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:179
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...
std::string myCurrentType
The current edge's type.
int getPriority(const std::string &type) const
Returns the priority for the given type.
Definition: NBTypeCont.cpp:191
bool addLane2LaneConnection(int fromLane, NBEdge *dest, int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, bool keepClear=true, SUMOReal contPos=UNSPECIFIED_CONTPOS, SUMOReal visibility=UNSPECIFIED_VISIBILITY_DISTANCE)
Adds a connection between the specified this edge's lane and an approached one.
Definition: NBEdge.cpp:802
bool hasLoadedLength() const
Returns whether a length was set explicitly.
Definition: NBEdge.h:482
int getNumLanes() const
Returns the number of lanes.
Definition: NBEdge.h:395
Position positionAtOffset(SUMOReal pos, SUMOReal lateralOffset=0) const
Returns the position at the given length.
SUMOReal myCurrentEndOffset
The current edge'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:79
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:55
void setLoadedLength(SUMOReal val)
set loaded lenght
Definition: NBEdge.cpp:2741
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
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:2846
static int _2int(const E *const data)
converts a char-type array into the integer value described by it
Definition: TplConvert.h:149
NBNode * getToNode() const
Returns the destination node of the edge.
Definition: NBEdge.h:416
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:247
SUMOReal myCurrentSpeed
The current edge's maximum speed.
static const SUMOReal UNSPECIFIED_LOADED_LENGTH
no length override given
Definition: NBEdge.h:252
void setPreferredVehicleClass(SVCPermissions permissions, int lane=-1)
set preferred Vehicle Class
Definition: NBEdge.cpp:2712
const PositionVector & getGeometry() const
Returns the geometry of the edge.
Definition: NBEdge.h:577
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:381
bool insert(const std::string &id, const Position &position, NBDistrict *district=0)
Inserts a node into the map.
Definition: NBNodeCont.cpp:81
OptionsCont & myOptions
A reference to the program's options.
LaneSpreadFunction
Numbers representing special SUMO-XML-attribute values Information how the edge's lateral offset shal...
NBTypeCont & myTypeCont
The types container (for retrieval of type defaults)
LaneSpreadFunction getLaneSpreadFunction() const
Returns how this edge's lanes' lateral offset is computed.
Definition: NBEdge.h:646
Represents a single node (junction) during network building.
Definition: NBNode.h:74
T get(const std::string &str) const
void move2side(SUMOReal amount)
move position vector to side using certain ammount
bool myHaveReportedAboutTypeOverride
Information whether at least one edge'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:2666
#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:469
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:110
int myCurrentLaneNo
The current edge's number of lanes.
SVCPermissions getPermissions(const std::string &type) const
Returns allowed vehicle classes for the given type.
Definition: NBTypeCont.cpp:215
SUMOReal getSpeed() const
Returns the speed allowed on this edge.
Definition: NBEdge.h:489
Container for nodes during the netbuilding process.
Definition: NBNodeCont.h:63
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's lane width.
SUMOReal myLength
The current edge's length.
SUMOReal pos
The position of this change.
std::string myCurrentStreetName
The current edge's street name.
void addRoundabout(const EdgeSet &roundabout)
add user specified roundabout
Definition: NBEdgeCont.cpp:996
#define WRITE_MESSAGE(msg)
Definition: MsgHandler.h:201
void invalidateTLS(NBTrafficLightLogicCont &tlCont)
causes the traffic light to be computed anew
Definition: NBNode.cpp:354
const std::string & getStreetName() const
Returns the street name of this edge.
Definition: NBEdge.h:518
void addLane(const SUMOSAXAttributes &attrs)
Parses a lane and modifies myCurrentEdge according to the given attribures.
int myCurrentPriority
The current edge's priority.
NBNode * node
The new node that is created for this split.
const SVCPermissions SVC_UNSPECIFIED
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:409