SUMO - Simulation of Urban MObility
GNERerouter.cpp
Go to the documentation of this file.
1 /****************************************************************************/
8 /****************************************************************************/
9 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
10 // Copyright (C) 2001-2017 DLR (http://www.dlr.de/) and contributors
11 /****************************************************************************/
12 //
13 // This file is part of SUMO.
14 // SUMO is free software; you can redistribute it and/or modify
15 // it under the terms of the GNU General Public License as published by
16 // the Free Software Foundation; either version 3 of the License, or
17 // (at your option) any later version.
18 //
19 /****************************************************************************/
20 
21 // ===========================================================================
22 // included modules
23 // ===========================================================================
24 #ifdef _MSC_VER
25 #include <windows_config.h>
26 #else
27 #include <config.h>
28 #endif
29 
30 #include <string>
31 #include <iostream>
32 #include <utility>
38 #include <utils/common/ToString.h>
39 #include <utils/geom/GeomHelper.h>
46 #include <utils/gui/div/GLHelper.h>
50 
51 #include "GNEViewNet.h"
52 #include "GNERerouter.h"
53 #include "GNERerouterDialog.h"
54 #include "GNERerouterInterval.h"
55 #include "GNELane.h"
56 #include "GNEEdge.h"
57 #include "GNEViewNet.h"
58 #include "GNEUndoList.h"
59 #include "GNENet.h"
60 #include "GNEChange_Attribute.h"
61 
62 
63 // ===========================================================================
64 // member method definitions
65 // ===========================================================================
66 
67 GNERerouter::GNERerouter(const std::string& id, GNEViewNet* viewNet, Position pos, std::vector<GNEEdge*> edges, const std::string& filename, double probability, bool off) :
68  GNEAdditional(id, viewNet, pos, SUMO_TAG_REROUTER, ICON_REROUTER),
69  myEdges(edges),
70  myFilename(filename),
71  myProbability(probability),
72  myOff(off) {
73  // Update geometry;
75  // Set colors
76  myBaseColor = RGBColor(76, 170, 50, 255);
77  myBaseColorSelected = RGBColor(161, 255, 135, 255);
78 }
79 
80 
82 }
83 
84 
85 void
87  // Clear shape
88  myShape.clear();
89 
90  // Set block icon position
92 
93  // Set block icon offset
94  myBlockIconOffset = Position(-0.5, -0.5);
95 
96  // Set block icon rotation, and using their rotation for draw logo
98 
99  // Set position
100  myShape.push_back(myPosition);
101 
102  /*
103  // Add shape of childs (To avoid graphics errors)
104  for (childEdges::iterator i = myChildEdges.begin(); i != myChildEdges.end(); i++) {
105  myShape.append(i->edge->getLanes().at(0)->getShape());
106  }
107 
108  // Update geometry of additional parent
109  updateConnections();
110  */
111  // Refresh element (neccesary to avoid grabbing problems)
113 }
114 
115 
116 Position
118  return myPosition;
119 }
120 
121 
122 void
124  // Open rerouter dialog
125  GNERerouterDialog(this);
126 }
127 
128 
129 void
130 GNERerouter::moveAdditionalGeometry(double offsetx, double offsety) {
131  // change Position
132  myPosition = Position(offsetx, offsety);
133  updateGeometry();
134 }
135 
136 
137 void
138 GNERerouter::commmitAdditionalGeometryMoved(double oldPosx, double oldPosy, GNEUndoList* undoList) {
139  undoList->p_begin("position of " + toString(getTag()));
140  undoList->p_add(new GNEChange_Attribute(this, SUMO_ATTR_POSITION, toString(myPosition), true, toString(Position(oldPosx, oldPosy))));
141  undoList->p_end();
142  // Refresh element
144 }
145 
146 
147 void
149  // Write parameters
150  device.openTag(getTag());
151  device.writeAttr(SUMO_ATTR_ID, getID());
152  // obtain ID's of Edges
153  std::vector<std::string> edgeIDs;
154  for (std::vector<GNEEdge*>::const_iterator i = myEdges.begin(); i != myEdges.end(); i++) {
155  edgeIDs.push_back((*i)->getID());
156  }
157  device.writeAttr(SUMO_ATTR_EDGES, joinToString(edgeIDs, " ").c_str());
159  if (!myFilename.empty()) {
161  }
162  device.writeAttr(SUMO_ATTR_OFF, myOff);
163  device.writeAttr(SUMO_ATTR_X, myPosition.x());
164  device.writeAttr(SUMO_ATTR_Y, myPosition.y());
165  if (myBlocked) {
167  }
168  // write intervals
169  for (std::vector<GNERerouterInterval>::const_iterator i = myRerouterIntervals.begin(); i != myRerouterIntervals.end(); i++) {
170  device.openTag(i->getTag());
171  device.writeAttr(SUMO_ATTR_BEGIN, i->getBegin());
172  device.writeAttr(SUMO_ATTR_END, i->getEnd());
173 
174  // write closing lane reroutes
175  for (std::vector<GNEClosingLaneReroute>::const_iterator j = i->getClosingLaneReroutes().begin(); j != i->getClosingLaneReroutes().end(); j++) {
176  device.openTag(j->getTag());
177  device.writeAttr(SUMO_ATTR_LANE, j->getClosedLane()->getID());
178  device.writeAttr(SUMO_ATTR_ALLOW, getVehicleClassNames(j->getAllowedVehicles()));
179  device.writeAttr(SUMO_ATTR_DISALLOW, getVehicleClassNames(j->getDisallowedVehicles()));
180  device.closeTag();
181  }
182 
183  // write closing reroutes
184  for (std::vector<GNEClosingReroute>::const_iterator j = i->getClosingReroutes().begin(); j != i->getClosingReroutes().end(); j++) {
185  device.openTag(j->getTag());
186  device.writeAttr(SUMO_ATTR_EDGE, j->getClosedEdge()->getID());
187  device.writeAttr(SUMO_ATTR_ALLOW, getVehicleClassNames(j->getAllowedVehicles()));
188  device.writeAttr(SUMO_ATTR_DISALLOW, getVehicleClassNames(j->getDisallowedVehicles()));
189  device.closeTag();
190  }
191 
192  // write dest prob reroutes
193  for (std::vector<GNEDestProbReroute>::const_iterator j = i->getDestProbReroutes().begin(); j != i->getDestProbReroutes().end(); j++) {
194  device.openTag(j->getTag());
195  device.writeAttr(SUMO_ATTR_EDGE, j->getNewDestination()->getID());
196  device.writeAttr(SUMO_ATTR_PROB, j->getProbability());
197  device.closeTag();
198  }
199 
200  // write route prob reroutes
201  for (std::vector<GNERouteProbReroute>::const_iterator j = i->getRouteProbReroutes().begin(); j != i->getRouteProbReroutes().end(); j++) {
202  device.openTag(j->getTag());
203  device.writeAttr(SUMO_ATTR_ROUTE, j->getNewRouteId());
204  device.writeAttr(SUMO_ATTR_PROB, j->getProbability());
205  device.closeTag();
206  }
207 
208  // Close tag
209  device.closeTag();
210  }
211 
212  // Close tag
213  device.closeTag();
214 }
215 
216 
217 void
219  // Check that edge is valid and doesn't exist previously
220  if (edge == NULL) {
221  throw InvalidArgument("Trying to add an empty " + toString(SUMO_TAG_EDGE) + " child in " + toString(getTag()) + " with ID='" + getID() + "'");
222  } else if (std::find(myEdges.begin(), myEdges.end(), edge) != myEdges.end()) {
223  throw InvalidArgument("Trying to add a duplicate " + toString(SUMO_TAG_EDGE) + " child in " + toString(getTag()) + " with ID='" + getID() + "'");
224  } else {
225  myEdges.push_back(edge);
226  }
227 }
228 
229 
230 void
232  // Check that edge is valid and exist previously
233  if (edge == NULL) {
234  throw InvalidArgument("Trying to remove an empty " + toString(SUMO_TAG_EDGE) + " child in " + toString(getTag()) + " with ID='" + getID() + "'");
235  } else if (std::find(myEdges.begin(), myEdges.end(), edge) == myEdges.end()) {
236  throw InvalidArgument("Trying to remove a non previously inserted " + toString(SUMO_TAG_EDGE) + " child in " + toString(getTag()) + " with ID='" + getID() + "'");
237  } else {
238  myEdges.erase(std::find(myEdges.begin(), myEdges.end(), edge));
239  }
240 }
241 
242 
243 const std::vector<GNEEdge*>&
245  return myEdges;
246 }
247 
248 
249 bool
251  // obtain a copy of current rerouter Intervals to check overlapping
252  std::vector<GNERerouterInterval> copyOfMyRerouterIntervals;
253  copyOfMyRerouterIntervals.push_back(rerouterInterval);
254  if (checkOverlapping(copyOfMyRerouterIntervals) == true) {
255  myRerouterIntervals = copyOfMyRerouterIntervals;
256  return true;
257  } else {
258  return false;
259  }
260 }
261 
262 
263 const std::vector<GNERerouterInterval>&
265  return myRerouterIntervals;
266 }
267 
268 
269 bool
270 GNERerouter::setRerouterIntervals(const std::vector<GNERerouterInterval>& rerouterIntervals) {
271  if (checkOverlapping(rerouterIntervals) == true) {
272  myRerouterIntervals = rerouterIntervals;
273  return true;
274  } else {
275  return false;
276  }
277 }
278 
279 
280 const std::string&
282  return myViewNet->getNet()->getMicrosimID();
283 }
284 
285 
286 void
288  // Start drawing adding an gl identificator
289  glPushName(getGlID());
290 
291  // Add a draw matrix for drawing logo
292  glPushMatrix();
293  glTranslated(myShape[0].x(), myShape[0].y(), getType());
294  glColor3d(1, 1, 1);
295  glRotated(180, 0, 0, 1);
296 
297  // Draw icon depending of rerouter is or isn't selected
298  if (isAdditionalSelected()) {
300  } else {
302  }
303 
304  // Pop draw matrix
305  glPopMatrix();
306 
307  // Show Lock icon depending of the Edit mode
308  drawLockIcon(0.4);
309 
310  /*
311  // Draw symbols in every lane
312  const double exaggeration = s.addSize.getExaggeration(s);
313 
314  if (s.scale * exaggeration >= 3) {
315  // draw rerouter symbol over all lanes
316 
317  for (childEdges::const_iterator i = myChildEdges.begin(); i != myChildEdges.end(); i++) {
318  for (int lanePosIt = 0; lanePosIt < (int)i->positionsOverLanes.size(); lanePosIt++) {
319  glPushMatrix();
320  glTranslated(i->positionsOverLanes.at(lanePosIt).x(), i->positionsOverLanes.at(lanePosIt).y(), 0);
321  glRotated(i->rotationsOverLanes.at(lanePosIt), 0, 0, 1);
322  glTranslated(0, 0, getType());
323  glScaled(exaggeration, exaggeration, 1);
324  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
325 
326  glBegin(GL_TRIANGLES);
327  glColor3d(1, .8f, 0);
328  // base
329  glVertex2d(0 - 1.4, 0);
330  glVertex2d(0 - 1.4, 6);
331  glVertex2d(0 + 1.4, 6);
332  glVertex2d(0 + 1.4, 0);
333  glVertex2d(0 - 1.4, 0);
334  glVertex2d(0 + 1.4, 6);
335  glEnd();
336 
337  glTranslated(0, 0, .1);
338  glColor3d(0, 0, 0);
339  pfSetPosition(0, 0);
340  pfSetScale(3.f);
341  double w = pfdkGetStringWidth("U");
342  glRotated(180, 0, 1, 0);
343  glTranslated(-w / 2., 2, 0);
344  pfDrawString("U");
345 
346  glTranslated(w / 2., -2, 0);
347  std::string str = toString((int)(myProbability * 100)) + "%";
348  pfSetPosition(0, 0);
349  pfSetScale(.7f);
350  w = pfdkGetStringWidth(str.c_str());
351  glTranslated(-w / 2., 4, 0);
352  pfDrawString(str.c_str());
353  glPopMatrix();
354  }
355  }
356  glPopName();
357  }
358 
359  // Draw connections
360  drawConnections();
361  */
362  // Pop name
363  glPopName();
364 
365  // Draw name
366  drawName(getCenteringBoundary().getCenter(), s.scale, s.addName);
367 }
368 
369 
370 std::string
372  switch (key) {
373  case SUMO_ATTR_ID:
374  return getAdditionalID();
375  case SUMO_ATTR_EDGES: {
376  // obtain ID's of Edges
377  std::vector<std::string> edgeIDs;
378  for (std::vector<GNEEdge*>::const_iterator i = myEdges.begin(); i != myEdges.end(); i++) {
379  edgeIDs.push_back((*i)->getID());
380  }
381  return joinToString(edgeIDs, " ");
382  }
383  case SUMO_ATTR_POSITION:
384  return toString(myPosition);
385  case SUMO_ATTR_FILE:
386  return myFilename;
387  case SUMO_ATTR_PROB:
388  return toString(myProbability);
389  case SUMO_ATTR_OFF:
390  return toString(myOff);
392  return toString(myBlocked);
393  default:
394  throw InvalidArgument(toString(getTag()) + " doesn't have an attribute of type '" + toString(key) + "'");
395  }
396 }
397 
398 
399 void
400 GNERerouter::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) {
401  if (value == getAttribute(key)) {
402  return; //avoid needless changes, later logic relies on the fact that attributes have changed
403  }
404  switch (key) {
405  case SUMO_ATTR_ID:
406  case SUMO_ATTR_EDGES:
407  case SUMO_ATTR_POSITION:
408  case SUMO_ATTR_FILE:
409  case SUMO_ATTR_PROB:
410  case SUMO_ATTR_OFF:
412  undoList->p_add(new GNEChange_Attribute(this, key, value));
413  updateGeometry();
414  break;
415  default:
416  throw InvalidArgument(toString(getTag()) + " doesn't have an attribute of type '" + toString(key) + "'");
417  }
418 }
419 
420 
421 bool
422 GNERerouter::isValid(SumoXMLAttr key, const std::string& value) {
423  switch (key) {
424  case SUMO_ATTR_ID:
425  if (myViewNet->getNet()->getAdditional(getTag(), value) == NULL) {
426  return true;
427  } else {
428  return false;
429  }
430  case SUMO_ATTR_EDGES: {
431  std::vector<std::string> edgeIds = GNEAttributeCarrier::parse<std::vector<std::string> > (value);
432  // Empty Edges aren't valid
433  if (edgeIds.empty()) {
434  return false;
435  }
436  // Iterate over parsed edges and check that exists
437  for (int i = 0; i < (int)edgeIds.size(); i++) {
438  if (myViewNet->getNet()->retrieveEdge(edgeIds.at(i), false) == NULL) {
439  return false;
440  }
441  }
442  // all edges exist, then is valid
443  return true;
444  }
445  case SUMO_ATTR_POSITION:
446  bool ok;
447  return GeomConvHelper::parseShapeReporting(value, "user-supplied position", 0, ok, false).size() == 1;
448  case SUMO_ATTR_FILE:
449  return isValidFilename(value);
450  case SUMO_ATTR_PROB:
451  return canParse<double>(value) && (parse<double>(value)) >= 0 && (parse<double>(value) <= 1);
452  case SUMO_ATTR_OFF:
453  return canParse<bool>(value);
455  return canParse<bool>(value);
456  default:
457  throw InvalidArgument(toString(getTag()) + " doesn't have an attribute of type '" + toString(key) + "'");
458  }
459 }
460 
461 
462 void
463 GNERerouter::setAttribute(SumoXMLAttr key, const std::string& value) {
464  switch (key) {
465  case SUMO_ATTR_ID:
466  setAdditionalID(value);
467  break;
468  case SUMO_ATTR_EDGES: {
469  // Declare auxiliar variables
470  std::vector<std::string> edgeIds = GNEAttributeCarrier::parse<std::vector<std::string> > (value);
471  GNEEdge* edge;
472  // first remove references of current rerouter in all edge childs
473  for (std::vector<GNEEdge*>::iterator i = myEdges.begin(); i != myEdges.end(); i++) {
474  (*i)->removeGNERerouter(this);
475  }
476  // clear previous edges
477  myEdges.clear();
478  // Iterate over parsed edges and obtain pointer to edges
479  for (int i = 0; i < (int)edgeIds.size(); i++) {
480  edge = myViewNet->getNet()->retrieveEdge(edgeIds.at(i), false);
481  if (edge) {
482  myEdges.push_back(edge);
483  edge->addGNERerouter(this);
484  } else {
485  throw InvalidArgument("Trying to set an non-valid edge in " + getID());
486  }
487  }
488  break;
489  }
490  case SUMO_ATTR_POSITION:
491  bool ok;
492  myPosition = GeomConvHelper::parseShapeReporting(value, "user-supplied position", 0, ok, false)[0];
493  updateGeometry();
494  getViewNet()->update();
495  break;
496  case SUMO_ATTR_FILE:
497  myFilename = value;
498  break;
499  case SUMO_ATTR_PROB:
500  myProbability = parse<double>(value);
501  break;
502  case SUMO_ATTR_OFF:
503  myOff = parse<bool>(value);
504  break;
506  myBlocked = parse<bool>(value);
507  getViewNet()->update();
508  break;
509  default:
510  throw InvalidArgument(toString(getTag()) + " doesn't have an attribute of type '" + toString(key) + "'");
511  }
512 }
513 
514 
515 bool
516 GNERerouter::checkOverlapping(std::vector<GNERerouterInterval> rerouterIntervals) {
517  // only can be overlapping if there are more than two elements
518  if (rerouterIntervals.size() <= 1) {
519  return true;
520  }
521  // first short vector
522  std::sort(rerouterIntervals.begin(), rerouterIntervals.end());
523 
524  // first check that all Begins are differents
525  for (std::vector<GNERerouterInterval>::const_iterator i = (rerouterIntervals.begin() + 1); i != rerouterIntervals.end(); i++) {
526  if ((i - 1)->getBegin() == i->getBegin()) {
527  return false;
528  }
529  }
530  // now check that end of every interval isn't overlapped with the begin of the next interval
531  for (std::vector<GNERerouterInterval>::const_iterator i = rerouterIntervals.begin(); i != (rerouterIntervals.end() - 1); i++) {
532  if (i->getEnd() > (i + 1)->getBegin()) {
533  return false;
534  }
535  }
536 
537  // all ok, then return true
538  return true;
539 }
540 /****************************************************************************/
static void drawTexturedBox(int which, double size)
Draws a named texture as a box with the given size.
std::string getVehicleClassNames(SVCPermissions permissions, bool expand)
Returns the ids of the given classes, divided using a &#39; &#39;.
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:256
GNEEdge * retrieveEdge(const std::string &id, bool failHard=true)
get edge by id
Definition: GNENet.cpp:743
double scale
information about a lane&#39;s width (temporary, used for a single view)
~GNERerouter()
Destructor.
Definition: GNERerouter.cpp:81
GUIVisualizationTextSettings addName
const std::string & getAdditionalID() const
returns the ID of additional
static GUIGlID getTexture(GUITexture which)
returns a texture previously defined in the enum GUITexture
GNEAdditional * getAdditional(SumoXMLTag type, const std::string &id) const
Returns the named additional.
Definition: GNENet.cpp:1331
Stores the information about how to visualize structures.
double y() const
Returns the y-position.
Definition: Position.h:68
std::string getAttribute(SumoXMLAttr key) const
const std::vector< GNERerouterInterval > & getRerouterIntervals() const
get rerouter intervals
Position getPositionInView() const
Returns position of Rerouter in view.
double x() const
Returns the x-position.
Definition: Position.h:63
weights: time range begin
void removeEdgeChild(GNEEdge *edge)
remove edge child
bool myOff
attribute to enable or disable inactive initially
Definition: GNERerouter.h:158
void p_begin(const std::string &description)
Begin undo command sub-group. This begins a new group of commands that are treated as a single comman...
Definition: GNEUndoList.cpp:82
const std::string & getParentName() const
Returns the name of the parent object (if any)
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
double myProbability
probability of rerouter
Definition: GNERerouter.h:155
static bool isValidFilename(const std::string &value)
true if value is a valid file value
void writeAdditional(OutputDevice &device) const
writte additional element into a xml file
const std::vector< GNEEdge * > & getEdgeChilds() const
get edge chidls
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
GNEViewNet * myViewNet
The GNEViewNet this additional element belongs.
RGBColor myBaseColorSelected
base color selected (Default blue)
void p_add(GNEChange_Attribute *cmd)
special method, avoid empty changes, always execute
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
method for setting the attribute and letting the object perform additional changes ...
Dialog for edit rerouters.
GNERerouter(const std::string &id, GNEViewNet *viewNet, Position pos, std::vector< GNEEdge *> edges, const std::string &filename, double probability, bool off)
Constructor.
Definition: GNERerouter.cpp:67
bool isValid(SumoXMLAttr key, const std::string &value)
method for checking if the key and their conrrespond attribute are valids
void commmitAdditionalGeometryMoved(double oldPosx, double oldPosy, GNEUndoList *undoList)
updated geometry changes in the attributes of additional
GUIGlObjectType getType() const
Returns the type of the object as coded in GUIGlObjectType.
void drawLockIcon(double size=0.5) const
draw lock icon
the edges of a route
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:56
void refreshAdditional(GNEAdditional *additional)
refreshes boundary information of an additional after a geometry update
Definition: GNENet.cpp:825
PositionVector myShape
The shape of the additional element.
bool addRerouterInterval(const GNERerouterInterval &rerouterInterval)
add rerouter interval
std::string myFilename
filename of rerouter
Definition: GNERerouter.h:152
void p_end()
End undo command sub-group. If the sub-group is still empty, it will be deleted; otherwise, the sub-group will be added as a new command into parent group. A matching begin() must have been called previously.
Definition: GNEUndoList.cpp:89
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:46
bool checkOverlapping(std::vector< GNERerouterInterval > rerouterIntervals)
check overlapping of a vector of rerouter intervals
void setBlockIconRotation(GNELane *lane=NULL)
set Rotation of block Icon
bool setRerouterIntervals(const std::vector< GNERerouterInterval > &rerouterIntervals)
set rerouter intervals
void removeGNERerouter(GNERerouter *rerouter)
remove a reference to a rerouter that has this edge as parameter
Definition: GNEEdge.cpp:1078
friend class GNEChange_Attribute
declare friend class
block movement of a graphic element
void moveAdditionalGeometry(double offsetx, double offsety)
change the position of the rerouter geometry
void drawName(const Position &pos, const double scale, const GUIVisualizationTextSettings &settings, const double angle=0) const
draw name of item
void setAdditionalID(const std::string &id)
set the ID of additional
virtual const std::string & getMicrosimID() const
Returns the id of the object as known to microsim.
const std::string getID() const
function to support debugging
Position myBlockIconOffset
The offSet of the block icon.
begin/end of the description of an edge
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:57
GNEViewNet * getViewNet() const
Returns a pointer to GNEViewNet in which additional element is located.
std::vector< GNEEdge * > myEdges
edges of Rerouter
Definition: GNERerouter.h:149
bool myBlocked
boolean to check if additional element is blocked (i.e. cannot be moved with mouse) ...
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
An Element which don&#39;t belongs to GNENet but has influency in the simulation.
Definition: GNEAdditional.h:62
weights: time range end
void addEdgeChild(GNEEdge *edge)
add edge child
RGBColor myBaseColor
base color (Default green)
void updateGeometry()
update pre-computed geometry information
Definition: GNERerouter.cpp:86
GNENet * getNet() const
get the net object
GUIGlID getGlID() const
Returns the numerical id of the object.
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:71
Position myPosition
The position in which this additional element is located.
bool closeTag()
Closes the most recently opened tag.
bool isAdditionalSelected() const
static PositionVector parseShapeReporting(const std::string &shpdef, const std::string &objecttype, const char *objectid, bool &ok, bool allowEmpty, bool report=true)
Builds a PositionVector from a string representation, reporting occured errors.
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
Definition: ToString.h:228
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
std::vector< GNERerouterInterval > myRerouterIntervals
set with the GNERerouterInterval
Definition: GNERerouter.h:161
void openAdditionalDialog()
open GNERerouterDialog
Position myBlockIconPosition
position of the block icon
SumoXMLTag getTag() const
get XML Tag assigned to this object