SUMO - Simulation of Urban MObility
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
GUIEdge.cpp
Go to the documentation of this file.
1 /****************************************************************************/
10 // A road/street connecting two junctions (gui-version)
11 /****************************************************************************/
12 // SUMO, Simulation of Urban MObility; see http://sumo-sim.org/
13 // Copyright (C) 2001-2013 DLR (http://www.dlr.de/) and contributors
14 /****************************************************************************/
15 //
16 // This file is part of SUMO.
17 // SUMO is free software: you can redistribute it and/or modify
18 // it under the terms of the GNU General Public License as published by
19 // the Free Software Foundation, either version 3 of the License, or
20 // (at your option) any later version.
21 //
22 /****************************************************************************/
23 
24 
25 // ===========================================================================
26 // included modules
27 // ===========================================================================
28 #ifdef _MSC_VER
29 #include <windows_config.h>
30 #else
31 #include <config.h>
32 #endif
33 
34 #include <vector>
35 #include <cmath>
36 #include <string>
37 #include <algorithm>
42 #include <utils/geom/GeomHelper.h>
45 #include <utils/gui/div/GLHelper.h>
48 #include <microsim/MSBaseVehicle.h>
49 #include <microsim/MSEdge.h>
50 #include <microsim/MSJunction.h>
51 #include <microsim/MSLaneChanger.h>
52 #include <microsim/MSGlobals.h>
55 #include "GUIEdge.h"
56 #include "GUINet.h"
57 #include "GUILane.h"
58 #include "GUIPerson.h"
59 
60 #ifdef HAVE_INTERNAL
61 #include <mesogui/GUIMEVehicleControl.h>
62 #include <mesosim/MESegment.h>
63 #include <mesosim/MELoop.h>
64 #include <mesosim/MEVehicle.h>
65 #endif
66 
67 #ifdef CHECK_MEMORY_LEAKS
68 #include <foreign/nvwa/debug_new.h>
69 #endif // CHECK_MEMORY_LEAKS
70 
71 
72 // ===========================================================================
73 // included modules
74 // ===========================================================================
75 GUIEdge::GUIEdge(const std::string& id, int numericalID,
76  const EdgeBasicFunction function, const std::string& streetName)
77  : MSEdge(id, numericalID, function, streetName),
78  GUIGlObject(GLO_EDGE, id) {}
79 
80 
82  // just to quit cleanly on a failure
83  if (myLock.locked()) {
84  myLock.unlock();
85  }
86 }
87 
88 
89 MSLane&
90 GUIEdge::getLane(size_t laneNo) {
91  assert(laneNo < myLanes->size());
92  return *((*myLanes)[laneNo]);
93 }
94 
95 
96 std::vector<GUIGlID>
97 GUIEdge::getIDs(bool includeInternal) {
98  std::vector<GUIGlID> ret;
99  ret.reserve(MSEdge::myDict.size());
100  for (MSEdge::DictType::iterator i = MSEdge::myDict.begin(); i != MSEdge::myDict.end(); ++i) {
101  GUIEdge* edge = dynamic_cast<GUIEdge*>(i->second);
102  assert(edge);
103  if (edge->getPurpose() != EDGEFUNCTION_INTERNAL || includeInternal) {
104  ret.push_back(edge->getGlID());
105  }
106  }
107  return ret;
108 }
109 
110 
111 Boundary
113  Boundary ret;
114  for (std::vector<MSLane*>::const_iterator i = myLanes->begin(); i != myLanes->end(); ++i) {
115  ret.add((*i)->getShape().getBoxBoundary());
116  }
117  ret.grow(10);
118  return ret;
119 }
120 
121 
122 void
123 GUIEdge::fill(std::vector<GUIEdge*>& netsWrappers) {
124  size_t size = MSEdge::dictSize();
125  netsWrappers.reserve(size);
126  for (DictType::iterator i = myDict.begin(); i != myDict.end(); ++i) {
127  if (i->second->getPurpose() != MSEdge::EDGEFUNCTION_DISTRICT) {
128  netsWrappers.push_back(static_cast<GUIEdge*>((*i).second));
129  }
130  }
131 }
132 
133 
134 
137  GUIGLObjectPopupMenu* ret = new GUIGLObjectPopupMenu(app, parent, *this);
138  buildPopupHeader(ret, app);
144  }
145  const SUMOReal pos = getLanes()[0]->getShape().nearest_offset_to_point2D(parent.getPositionInformation());
146  new FXMenuCommand(ret, ("pos: " + toString(pos)).c_str(), 0, 0, 0);
147  buildPositionCopyEntry(ret, false);
148  return ret;
149 }
150 
151 
154  GUISUMOAbstractView& parent) {
155  GUIParameterTableWindow* ret = 0;
156 #ifdef HAVE_INTERNAL
157  ret = new GUIParameterTableWindow(app, *this, 16);
158  // add edge items
159  ret->mkItem("length [m]", false, (*myLanes)[0]->getLength());
160  ret->mkItem("allowed speed [m/s]", false, getAllowedSpeed());
161  ret->mkItem("occupancy [%]", true,
162  new FunctionBinding<GUIEdge, SUMOReal>(this, &GUIEdge::getOccupancy));
163  ret->mkItem("mean vehicle speed [m/s]", true,
164  new FunctionBinding<GUIEdge, SUMOReal>(this, &GUIEdge::getMeanSpeed));
165  ret->mkItem("flow [veh/h/lane]", true,
166  new FunctionBinding<GUIEdge, SUMOReal>(this, &GUIEdge::getFlow));
167  ret->mkItem("#vehicles", true,
168  new CastingFunctionBinding<GUIEdge, SUMOReal, unsigned int>(this, &GUIEdge::getVehicleNo));
169  ret->mkItem("vehicle ids", false, getVehicleIDs());
170  // add segment items
171  MESegment* segment = getSegmentAtPosition(parent.getPositionInformation());
172  ret->mkItem("segment index", false, segment->getIndex());
173  ret->mkItem("segment length [m]", false, segment->getLength());
174  ret->mkItem("segment allowed speed [m/s]", false, segment->getMaxSpeed());
175  ret->mkItem("segment jam threshold [%]", false, segment->getRelativeJamThreshold());
176  ret->mkItem("segment occupancy [%]", true, new FunctionBinding<MESegment, SUMOReal>(segment, &MESegment::getRelativeOccupancy));
177  ret->mkItem("segment mean vehicle speed [m/s]", true, new FunctionBinding<MESegment, SUMOReal>(segment, &MESegment::getMeanSpeed));
178  ret->mkItem("segment flow [veh/h/lane]", true, new FunctionBinding<MESegment, SUMOReal>(segment, &MESegment::getFlow));
179  ret->mkItem("segment #vehicles", true, new CastingFunctionBinding<MESegment, SUMOReal, size_t>(segment, &MESegment::getCarNumber));
180  ret->mkItem("segment leader leave time", true, new FunctionBinding<MESegment, SUMOReal>(segment, &MESegment::getEventTimeSeconds));
181 
182  // close building
183  ret->closeBuilding();
184 #else
185  UNUSED_PARAMETER(app);
186  UNUSED_PARAMETER(parent);
187 #endif
188  return ret;
189 }
190 
191 
192 Boundary
194  Boundary b = getBoundary();
195  b.grow(20);
196  return b;
197 }
198 
199 
200 void
203  return;
204  }
206  glPushName(getGlID());
207  }
208  // draw the lanes
209  for (std::vector<MSLane*>::const_iterator i = myLanes->begin(); i != myLanes->end(); ++i) {
210 #ifdef HAVE_INTERNAL
212  setColor(s);
213  }
214 #endif
215  GUILane* l = dynamic_cast<GUILane*>(*i);
216  if (l != 0) {
217  l->drawGL(s);
218  }
219  }
220 #ifdef HAVE_INTERNAL
222  const GUIVisualizationTextSettings& nameSettings = s.vehicleName;
223  GUIMEVehicleControl* vehicleControl = GUINet::getGUIInstance()->getGUIMEVehicleControl();
224  if (vehicleControl != 0) {
225  // draw the meso vehicles
226  vehicleControl->secureVehicles();
227  size_t laneIndex = 0;
228  MESegment::Queue queue;
229  for (std::vector<MSLane*>::const_iterator msl = myLanes->begin(); msl != myLanes->end(); ++msl, ++laneIndex) {
230  GUILane* l = static_cast<GUILane*>(*msl);
231  const PositionVector& shape = l->getShape();
232  const std::vector<SUMOReal>& shapeRotations = l->getShapeRotations();
233  const std::vector<SUMOReal>& shapeLengths = l->getShapeLengths();
234  const Position& laneBeg = shape[0];
235  glPushMatrix();
236  glTranslated(laneBeg.x(), laneBeg.y(), 0);
237  glRotated(shapeRotations[0], 0, 0, 1);
238  // go through the vehicles
239  int shapeIndex = 0;
240  SUMOReal shapeOffset = 0; // ofset at start of current shape
241  SUMOReal segmentOffset = 0; // offset at start of current segment
242  for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this);
243  segment != 0; segment = segment->getNextSegment()) {
244  const SUMOReal length = segment->getLength();
245  if (laneIndex < segment->numQueues()) {
246  // make a copy so we don't have to worry about synchronization
247  queue = segment->getQueue(laneIndex);
248  const SUMOReal avgCarSize = segment->getOccupancy() / segment->getCarNumber();
249  const size_t queueSize = queue.size();
250  for (size_t i = 0; i < queueSize; ++i) {
251  MSBaseVehicle* veh = queue[queueSize - i - 1];
252  setVehicleColor(s, veh);
253  SUMOReal vehiclePosition = segmentOffset + length - i * avgCarSize;
254  SUMOReal xOff = 0.f;
255  while (vehiclePosition < segmentOffset) {
256  // if there is only a single queue for a
257  // multi-lane edge shift vehicles and start
258  // drawing again from the end of the segment
259  vehiclePosition += length;
260  xOff += 0.5f;
261  }
262  while (shapeIndex < (int)shapeRotations.size() - 1 && vehiclePosition > shapeOffset + shapeLengths[shapeIndex]) {
263  glPopMatrix();
264  shapeOffset += shapeLengths[shapeIndex];
265  shapeIndex++;
266  glPushMatrix();
267  glTranslated(shape[shapeIndex].x(), shape[shapeIndex].y(), 0);
268  glRotated(shapeRotations[shapeIndex], 0, 0, 1);
269  }
270  glPushMatrix();
271  glTranslated(xOff, -(vehiclePosition - shapeOffset), GLO_VEHICLE);
272  glPushMatrix();
273  glScaled(1, avgCarSize, 1);
274  glBegin(GL_TRIANGLES);
275  glVertex2d(0, 0);
276  glVertex2d(0 - 1.25, 1);
277  glVertex2d(0 + 1.25, 1);
278  glEnd();
279  glPopMatrix();
280  glPopMatrix();
281  if (nameSettings.show) {
282  GLHelper::drawText(veh->getID(),
283  Position(xOff, -(vehiclePosition - shapeOffset)),
284  GLO_MAX, nameSettings.size / s.scale, nameSettings.color, 0);
285  }
286  }
287  }
288  segmentOffset += length;
289  }
290  glPopMatrix();
291  }
292  vehicleControl->releaseVehicles();
293  }
294  glPopName();
295  }
296 #endif
297  // (optionally) draw the name and/or the street name
298  const bool drawEdgeName = s.edgeName.show && myFunction == EDGEFUNCTION_NORMAL;
299  const bool drawInternalEdgeName = s.internalEdgeName.show && myFunction != EDGEFUNCTION_NORMAL;
300  const bool drawStreetName = s.streetName.show && myStreetName != "";
301  if (drawEdgeName || drawInternalEdgeName || drawStreetName) {
302  GUILane* lane1 = dynamic_cast<GUILane*>((*myLanes)[0]);
303  GUILane* lane2 = dynamic_cast<GUILane*>((*myLanes).back());
304  if (lane1 != 0 && lane2 != 0) {
305  Position p = lane1->getShape().positionAtOffset(lane1->getShape().length() / (SUMOReal) 2.);
306  p.add(lane2->getShape().positionAtOffset(lane2->getShape().length() / (SUMOReal) 2.));
307  p.mul(.5);
308  SUMOReal angle = lane1->getShape().rotationDegreeAtOffset(lane1->getShape().length() / (SUMOReal) 2.);
309  angle += 90;
310  if (angle > 90 && angle < 270) {
311  angle -= 180;
312  }
313  if (drawEdgeName) {
314  drawName(p, s.scale, s.edgeName, angle);
315  } else if (drawInternalEdgeName) {
316  drawName(p, s.scale, s.internalEdgeName, angle);
317  }
318  if (drawStreetName) {
320  s.streetName.size / s.scale, s.streetName.color, angle);
321  }
322  }
323  }
324  myLock.lock();
325  for (std::set<MSPerson*>::const_iterator i = myPersons.begin(); i != myPersons.end(); ++i) {
326  GUIPerson* person = dynamic_cast<GUIPerson*>(*i);
327  assert(person != 0);
328  person->drawGL(s);
329  }
330  myLock.unlock();
331 }
332 
333 #ifdef HAVE_INTERNAL
334 unsigned int
335 GUIEdge::getVehicleNo() const {
336  size_t vehNo = 0;
337  for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this); segment != 0; segment = segment->getNextSegment()) {
338  vehNo += segment->getCarNumber();
339  }
340  return (unsigned int)vehNo;
341 }
342 
343 
344 std::string
345 GUIEdge::getVehicleIDs() const {
346  std::string result = " ";
347  std::vector<const MEVehicle*> vehs;
348  for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this); segment != 0; segment = segment->getNextSegment()) {
349  std::vector<const MEVehicle*> segmentVehs = segment->getVehicles();
350  vehs.insert(vehs.end(), segmentVehs.begin(), segmentVehs.end());
351  }
352  for (std::vector<const MEVehicle*>::const_iterator it = vehs.begin(); it != vehs.end(); it++) {
353  result += (*it)->getID() + " ";
354  }
355  return result;
356 }
357 
358 
359 SUMOReal
360 GUIEdge::getFlow() const {
361  SUMOReal flow = 0;
362  for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this); segment != 0; segment = segment->getNextSegment()) {
363  flow += (SUMOReal) segment->getCarNumber() * segment->getMeanSpeed();
364  }
365  return 3600 * flow / (*myLanes)[0]->getLength();
366 }
367 
368 
369 SUMOReal
370 GUIEdge::getOccupancy() const {
371  SUMOReal occ = 0;
372  for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this); segment != 0; segment = segment->getNextSegment()) {
373  occ += segment->getOccupancy();
374  }
375  return occ / (*myLanes)[0]->getLength() / (SUMOReal)(myLanes->size());
376 }
377 
378 
379 SUMOReal
380 GUIEdge::getMeanSpeed() const {
381  SUMOReal v = 0;
382  SUMOReal no = 0;
383  for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this); segment != 0; segment = segment->getNextSegment()) {
384  SUMOReal vehNo = (SUMOReal) segment->getCarNumber();
385  v += vehNo * segment->getMeanSpeed();
386  no += vehNo;
387  }
388  if (no == 0) {
389  return getSpeedLimit();
390  }
391  return v / no;
392 }
393 
394 
395 SUMOReal
396 GUIEdge::getAllowedSpeed() const {
397  return (*myLanes)[0]->getSpeedLimit();
398 }
399 
400 
401 SUMOReal
402 GUIEdge::getRelativeSpeed() const {
403  return getMeanSpeed() / getAllowedSpeed();
404 }
405 
406 
407 void
408 GUIEdge::setColor(const GUIVisualizationSettings& s) const {
409  GLHelper::setColor(s.edgeColorer.getScheme().getColor(getColorValue(s.edgeColorer.getActive())));
410 }
411 
412 
413 SUMOReal
414 GUIEdge::getColorValue(size_t activeScheme) const {
415  switch (activeScheme) {
416  case 1:
417  return gSelected.isSelected(getType(), getGlID());
418  case 2:
419  return getPurpose();
420  case 3:
421  return getAllowedSpeed();
422  case 4:
423  return getOccupancy();
424  case 5:
425  return getMeanSpeed();
426  case 6:
427  return getFlow();
428  case 7:
429  return getRelativeSpeed();
430  }
431  return 0;
432 }
433 
434 
435 MESegment*
436 GUIEdge::getSegmentAtPosition(const Position& pos) {
437  const PositionVector& shape = getLanes()[0]->getShape();
438  const SUMOReal lanePos = shape.nearest_offset_to_point2D(pos);
439  return MSGlobals::gMesoNet->getSegmentForEdge(*this, lanePos);
440 }
441 
442 
443 void
444 GUIEdge::setVehicleColor(const GUIVisualizationSettings& s, MSBaseVehicle* veh) const {
445  const GUIColorer& c = s.vehicleColorer;
446  switch (c.getActive()) {
447  case 1:
449  break;
450  case 2:
452  break;
453  case 3:
455  break;
456  default:
458  }
459 }
460 
461 #endif
462 
463 /****************************************************************************/
464 
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
Definition: GUIEdge.cpp:193
std::set< MSPerson * > myPersons
Persons on the edge (only for drawing)
Definition: MSEdge.h:556
const std::vector< SUMOReal > & getShapeRotations() const
Definition: GUILane.cpp:668
RGBColor color
The vehicle&#39;s color.
std::vector< MSLane * > * myLanes
Container for the edge&#39;s lane; should be sorted: (right-hand-traffic) the more left the lane...
Definition: MSEdge.h:535
GUIVisualizationTextSettings streetName
const RGBColor getColor(const SUMOReal value) const
SUMOReal nearest_offset_to_point2D(const Position &p, bool perpendicular=true) const
Position positionAtOffset(SUMOReal pos) const
Returns the position at the given length.
void buildNameCopyPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds entries which allow to copy the name / typed name into the clipboard.
a vehicles
void add(const Position &pos)
Adds the given position to this one.
Definition: Position.h:119
virtual GUIGLObjectPopupMenu * getPopUpMenu(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own popup-menu.
Definition: GUIEdge.cpp:136
const std::vector< MSLane * > & getLanes() const
Returns this edge&#39;s lanes.
Definition: MSEdge.h:167
Stores the information about how to visualize structures.
const EdgeBasicFunction myFunction
the purpose of the edge
Definition: MSEdge.h:541
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
Definition: GUILane.cpp:451
GUIVisualizationTextSettings vehicleName
const std::string & getStreetName() const
Returns the street name of the edge.
Definition: MSEdge.h:218
void buildCenterPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to center to the object.
The edge is a macroscopic connector (source/sink)
Definition: MSEdge.h:88
const MSRoute & getRoute() const
Returns the current route.
Definition: MSBaseVehicle.h:86
bool isSelected(GUIGlObjectType type, GUIGlID id)
Returns the information whether the object with the given type and id is selected.
GUIEdge(const std::string &id, int numericalID, const EdgeBasicFunction function, const std::string &streetName)
Constructor.
Definition: GUIEdge.cpp:75
const std::vector< SUMOReal > & getShapeLengths() const
Definition: GUILane.cpp:674
static void drawText(const std::string &text, const Position &pos, const SUMOReal layer, const SUMOReal size, const RGBColor &col=RGBColor::BLACK, const SUMOReal angle=0)
draw Text with given parameters
Definition: GLHelper.cpp:318
void buildShowParamsPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to open the parameter window.
The base class for microscopic and mesoscopic vehicles.
Definition: MSBaseVehicle.h:57
EdgeBasicFunction
Defines possible edge types.
Definition: MSEdge.h:82
SUMOReal x() const
Returns the x-position.
Definition: Position.h:63
void buildPositionCopyEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to copy the cursor position if geo projection is used, also builds an entry for copying the geo-position.
GUIGlID getGlID() const
Returns the numerical id of the object.
Definition: GUIGlObject.h:115
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:36
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:48
SUMOReal scale
information about a lane&#39;s width (temporary, used for a single view)
size_t getActive() const
Definition: GUIColorer.h:72
Representation of a lane in the micro simulation (gui-version)
Definition: GUILane.h:70
GUIColorer vehicleColorer
The vehicle colorer.
GUIVisualizationTextSettings edgeName
A road/street connecting two junctions (gui-version)
Definition: GUIEdge.h:61
A road/street connecting two junctions.
Definition: MSEdge.h:73
GUIGlObjectType getType() const
Returns the type of the object as coded in GUIGlObjectType.
Definition: GUIGlObject.h:159
SUMOReal getLength() const
return the length of the edge
Definition: MSEdge.cpp:564
~GUIEdge()
Destructor.
Definition: GUIEdge.cpp:81
The edge is a district edge.
Definition: MSEdge.h:92
static void setColor(const RGBColor &c)
Sets the gl-color to this value.
Definition: GLHelper.cpp:301
static GUINet * getGUIInstance()
Returns the pointer to the unique instance of GUINet (singleton).
Definition: GUINet.cpp:472
GUIVisualizationTextSettings internalEdgeName
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:46
A list of positions.
virtual GUIParameterTableWindow * getParameterWindow(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own parameter window.
Definition: GUIEdge.cpp:153
MSLane & getLane(size_t laneNo)
returns the enumerated lane (!!! why not private with a friend?)
Definition: GUIEdge.cpp:90
void drawName(const Position &pos, const SUMOReal scale, const GUIVisualizationTextSettings &settings, const SUMOReal angle=0) const
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
Definition: ToString.h:51
SUMOReal getSpeedLimit() const
Returns the speed limit of the edge The speed limit of the first lane is retured; should probably be...
Definition: MSEdge.cpp:570
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
Definition: GUIPerson.cpp:159
void unlock()
release mutex lock
Definition: MFXMutex.cpp:93
static std::vector< GUIGlID > getIDs(bool includeInternal)
Definition: GUIEdge.cpp:97
SUMOReal length() const
Returns the length.
SUMOReal rotationDegreeAtOffset(SUMOReal pos) const
Returns the rotation at the given length.
void add(SUMOReal x, SUMOReal y)
Makes the boundary include the given coordinate.
Definition: Boundary.cpp:76
Boundary & grow(SUMOReal by)
extends the boundary by the given amount
Definition: Boundary.cpp:200
EdgeBasicFunction getPurpose() const
Returns the edge type (EdgeBasicFunction)
Definition: MSEdge.h:203
GUIColorScheme & getScheme()
Definition: GUIColorer.h:76
MFXMutex myLock
The mutex used to avoid concurrent updates of myPersons.
Definition: GUIEdge.h:187
The edge is a normal street.
Definition: MSEdge.h:86
SUMOReal y() const
Returns the y-position.
Definition: Position.h:68
static size_t dictSize()
Returns the number of edges.
Definition: MSEdge.cpp:495
const MSVehicleType & getVehicleType() const
Returns the vehicle&#39;s type definition.
Definition: MSBaseVehicle.h:94
The popup menu of a globject.
an edge
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
Definition: GUIEdge.cpp:201
std::string myStreetName
Definition: MSEdge.h:573
void mul(SUMOReal val)
Multiplies both positions with the given value.
Definition: Position.h:99
void buildSelectionPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to (de)select the object.
const SUMOVehicleParameter & getParameter() const
Returns the vehicle&#39;s parameter (including departure definition)
void lock()
lock mutex
Definition: MFXMutex.cpp:83
Base class for coloring. Allows changing the used colors and sets the used color in dependence to a v...
Definition: GUIColorer.h:50
const RGBColor & getColor() const
Returns this type&#39;s color.
static DictType myDict
Static dictionary to associate string-ids with objects.
Definition: MSEdge.h:587
const RGBColor & getColor() const
Returns the color.
Definition: MSRoute.cpp:293
#define SUMOReal
Definition: config.h:221
static const bool gUseMesoSim
Definition: MSGlobals.h:95
Boundary getBoundary() const
Returns the street&#39;s geometry.
Definition: GUIEdge.cpp:112
FXbool locked()
Definition: MFXMutex.h:68
empty max
Position getPositionInformation() const
Returns the cursor&#39;s x/y position within the network.
The edge is an internal edge.
Definition: MSEdge.h:90
void mkItem(const char *name, bool dynamic, ValueSource< unsigned > *src)
Adds a row which obtains its value from an unsigned-ValueSource.
GUISelectedStorage gSelected
A global holder of selected objects.
void closeBuilding()
Closes the building of the table.
Representation of a lane in the micro simulation.
Definition: MSLane.h:73
A window containing a gl-object&#39;s parameter.
static void fill(std::vector< GUIEdge * > &netsWrappers)
Definition: GUIEdge.cpp:123
void buildPopupHeader(GUIGLObjectPopupMenu *ret, GUIMainWindow &app, bool addSeparator=true)
Builds the header.
const std::string & getID() const
Returns the name of the vehicle.
const PositionVector & getShape() const
Definition: GUILane.cpp:662