SUMO - Simulation of Urban MObility
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
GUINet.cpp
Go to the documentation of this file.
1 /****************************************************************************/
10 // A MSNet extended by some values for usage within the gui
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 // included modules
25 // ===========================================================================
26 #ifdef _MSC_VER
27 #include <windows_config.h>
28 #else
29 #include <config.h>
30 #endif
31 
32 #include <utility>
33 #include <set>
34 #include <vector>
35 #include <map>
42 #include <utils/common/RGBColor.h>
44 #include <microsim/MSNet.h>
45 #include <microsim/MSJunction.h>
47 #include <microsim/MSEdge.h>
52 #include <guisim/GUIEdge.h>
53 #include <guisim/GUILane.h>
60 #include <gui/GUIGlobals.h>
61 #include "GUINet.h"
62 #include "GUIShapeContainer.h"
63 
64 #ifdef HAVE_INTERNAL
65 #include <mesogui/GUIMEVehicleControl.h>
66 #endif
67 
68 #ifdef CHECK_MEMORY_LEAKS
69 #include <foreign/nvwa/debug_new.h>
70 #endif // CHECK_MEMORY_LEAKS
71 
72 
73 // ===========================================================================
74 // definition of static variables used for visualisation of objects' values
75 // ===========================================================================
76 template std::vector< GLObjectValuePassConnector<SUMOReal>* > GLObjectValuePassConnector<SUMOReal>::myContainer;
78 
79 template std::vector< GLObjectValuePassConnector<std::pair<int, class MSPhaseDefinition> >* > GLObjectValuePassConnector<std::pair<int, class MSPhaseDefinition> >::myContainer;
81 
82 
83 // ===========================================================================
84 // member method definitions
85 // ===========================================================================
86 GUINet::GUINet(MSVehicleControl* vc, MSEventControl* beginOfTimestepEvents,
87  MSEventControl* endOfTimestepEvents, MSEventControl* insertionEvents) :
88  MSNet(vc, beginOfTimestepEvents, endOfTimestepEvents, insertionEvents, new GUIShapeContainer(myGrid)),
90  myLastSimDuration(0), /*myLastVisDuration(0),*/ myLastIdleDuration(0),
91  myLastVehicleMovementCount(0), myOverallVehicleCount(0), myOverallSimDuration(0) {
93 }
94 
95 
97  if (myLock.locked()) {
98  myLock.unlock();
99  }
100  // delete allocated wrappers
101  // of junctions
102  for (std::vector<GUIJunctionWrapper*>::iterator i1 = myJunctionWrapper.begin(); i1 != myJunctionWrapper.end(); i1++) {
103  delete(*i1);
104  }
105  // of additional structures
107  // of tl-logics
108  for (Logics2WrapperMap::iterator i3 = myLogics2Wrapper.begin(); i3 != myLogics2Wrapper.end(); i3++) {
109  delete(*i3).second;
110  }
111  // of detectors
112  for (std::vector<GUIDetectorWrapper*>::iterator i = myDetectorDict.begin(); i != myDetectorDict.end(); ++i) {
113  delete *i;
114  }
115 }
116 
117 
118 const Boundary&
120  return myBoundary;
121 }
122 
123 
126  if (myPersonControl == 0) {
128  }
129  return *myPersonControl;
130 }
131 
132 
133 void
135  // get the list of loaded tl-logics
136  const std::vector<MSTrafficLightLogic*>& logics = getTLSControl().getAllLogics();
137  // allocate storage for the wrappers
138  myTLLogicWrappers.reserve(logics.size());
139  // go through the logics
140  for (std::vector<MSTrafficLightLogic*>::const_iterator i = logics.begin(); i != logics.end(); ++i) {
141  createTLWrapper(*i);
142  }
143 }
144 
145 
146 GUIGlID
148  if (myLogics2Wrapper.count(tll) > 0) {
149  return myLogics2Wrapper[tll]->getGlID();
150  }
151  // get the links
152  const MSTrafficLightLogic::LinkVectorVector& links = tll->getLinks();
153  if (links.size() == 0) { // @legacy this should never happen in 0.13.0+ networks
154  return 0;
155  }
156  // build the wrapper
159  // build the association link->wrapper
160  MSTrafficLightLogic::LinkVectorVector::const_iterator j;
161  for (j = links.begin(); j != links.end(); ++j) {
162  MSTrafficLightLogic::LinkVector::const_iterator j2;
163  for (j2 = (*j).begin(); j2 != (*j).end(); ++j2) {
164  myLinks2Logic[*j2] = tll->getID();
165  }
166  }
168  myLogics2Wrapper[tll] = tllw;
169  return tllw->getGlID();
170 }
171 
172 
173 Position
174 GUINet::getJunctionPosition(const std::string& name) const {
175  // !!! no check for existance!
176  return myJunctions->get(name)->getPosition();
177 }
178 
179 
180 bool
181 GUINet::vehicleExists(const std::string& name) const {
182  return myVehicleControl->getVehicle(name) != 0;
183 }
184 
185 
186 unsigned int
188  if (myLinks2Logic.count(link) == 0) {
189  assert(false);
190  return 0;
191  }
192  MSTrafficLightLogic* tll = myLogics->getActive(myLinks2Logic.find(link)->second);
193  if (myLogics2Wrapper.count(tll) == 0) {
194  // tll may have been added via traci. @see ticket #459
195  return 0;
196  }
197  return myLogics2Wrapper.find(tll)->second->getGlID();
198 }
199 
200 
201 int
203  Links2LogicMap::const_iterator i = myLinks2Logic.find(link);
204  if (i == myLinks2Logic.end()) {
205  return -1;
206  }
207  if (myLogics2Wrapper.find(myLogics->getActive((*i).second)) == myLogics2Wrapper.end()) {
208  return -1;
209  }
210  return myLogics2Wrapper.find(myLogics->getActive((*i).second))->second->getLinkIndex(link);
211 }
212 
213 
214 void
218 }
219 
220 
221 void
225 }
226 
227 
228 std::vector<GUIGlID>
229 GUINet::getJunctionIDs(bool includeInternal) const {
230  std::vector<GUIGlID> ret;
231  for (std::vector<GUIJunctionWrapper*>::const_iterator i = myJunctionWrapper.begin(); i != myJunctionWrapper.end(); ++i) {
232  if (!(*i)->isInner() || includeInternal) {
233  ret.push_back((*i)->getGlID());
234  }
235  }
236  return ret;
237 }
238 
239 
240 std::vector<GUIGlID>
242  std::vector<GUIGlID> ret;
243  std::vector<std::string> ids;
244  for (std::map<MSTrafficLightLogic*, GUITrafficLightLogicWrapper*>::const_iterator i = myLogics2Wrapper.begin(); i != myLogics2Wrapper.end(); ++i) {
245  std::string sid = (*i).second->getMicrosimID();
246  if (find(ids.begin(), ids.end(), sid) == ids.end()) {
247  ret.push_back((*i).second->getGlID());
248  ids.push_back(sid);
249  }
250  }
251  return ret;
252 }
253 
254 
255 void
257  // initialise detector storage for gui
258  const std::vector<SumoXMLTag> types = myDetectorControl->getAvailableTypes();
259  for (std::vector<SumoXMLTag>::const_iterator i = types.begin(); i != types.end(); ++i) {
260  const std::map<std::string, MSDetectorFileOutput*>& dets = myDetectorControl->getTypedDetectors(*i).getMyMap();
261  for (std::map<std::string, MSDetectorFileOutput*>::const_iterator j = dets.begin(); j != dets.end(); ++j) {
262  GUIDetectorWrapper* wrapper = (*j).second->buildDetectorGUIRepresentation();
263  if (wrapper != 0) {
264  myDetectorDict.push_back(wrapper);
265  myGrid.addAdditionalGLObject(wrapper);
266  }
267  }
268  }
269  // initialise the tl-map
270  initTLMap();
271  // initialise edge storage for gui
273  // initialise junction storage for gui
274  size_t size = myJunctions->size();
275  myJunctionWrapper.reserve(size);
276  const std::map<std::string, MSJunction*>& junctions = myJunctions->getMyMap();
277  for (std::map<std::string, MSJunction*>::const_iterator i = junctions.begin(); i != junctions.end(); ++i) {
278  myJunctionWrapper.push_back(new GUIJunctionWrapper(*(*i).second));
279  }
280  // build the visualization tree
281  float* cmin = new float[2];
282  float* cmax = new float[2];
283  for (std::vector<GUIEdge*>::iterator i = myEdgeWrapper.begin(); i != myEdgeWrapper.end(); ++i) {
284  GUIEdge* edge = *i;
285  Boundary b;
286  const std::vector<MSLane*>& lanes = edge->getLanes();
287  for (std::vector<MSLane*>::const_iterator j = lanes.begin(); j != lanes.end(); ++j) {
288  b.add((*j)->getShape().getBoxBoundary());
289  }
290  // make sure persons are always drawn and selectable since they depend on their edge being drawn
292  cmin[0] = b.xmin();
293  cmin[1] = b.ymin();
294  cmax[0] = b.xmax();
295  cmax[1] = b.ymax();
296  myGrid.Insert(cmin, cmax, edge);
297  myBoundary.add(b);
298  if (myBoundary.getWidth() > 10e16 || myBoundary.getHeight() > 10e16) {
299  throw ProcessError("Network size exceeds 1 Lightyear. Please reconsider your inputs.\n");
300  }
301  }
302  for (std::vector<GUIJunctionWrapper*>::iterator i = myJunctionWrapper.begin(); i != myJunctionWrapper.end(); ++i) {
303  GUIJunctionWrapper* junction = *i;
304  Boundary b = junction->getBoundary();
305  b.grow(2.);
306  cmin[0] = b.xmin();
307  cmin[1] = b.ymin();
308  cmax[0] = b.xmax();
309  cmax[1] = b.ymax();
310  myGrid.Insert(cmin, cmax, junction);
311  myBoundary.add(b);
312  }
313  delete[] cmin;
314  delete[] cmax;
316 }
317 
318 
319 unsigned int
321  return myLastSimDuration +/*myLastVisDuration+*/myLastIdleDuration;
322 }
323 
324 
325 unsigned int
327  return myLastSimDuration;
328 }
329 
330 /*
331 int
332 GUINet::getVisDuration() const
333 {
334  return myLastVisDuration;
335 }
336 */
337 
338 
339 SUMOReal
341  if (myLastSimDuration == 0) {
342  return -1;
343  }
344  return (SUMOReal) 1000. / (SUMOReal) myLastSimDuration;
345 }
346 
347 
348 SUMOReal
349 GUINet::getUPS() const {
350  if (myLastSimDuration == 0) {
351  return -1;
352  }
354 }
355 
356 
357 SUMOReal
358 GUINet::getMeanRTFactor(int duration) const {
359  if (myOverallSimDuration == 0) {
360  return -1;
361  }
362  return ((SUMOReal)(duration) * (SUMOReal) 1000. / (SUMOReal)myOverallSimDuration);
363 }
364 
365 
366 SUMOReal
368  if (myOverallSimDuration == 0) {
369  return -1;
370  }
372 }
373 
374 
375 unsigned int
377  return myLastIdleDuration;
378 }
379 
380 
381 void
383  myLastSimDuration = val;
384  myOverallSimDuration += val;
387 }
388 
389 /*
390 void
391 GUINet::setVisDuration(int val)
392 {
393  myLastVisDuration = val;
394 }
395 */
396 
397 void
399  myLastIdleDuration = val;
400 }
401 
402 
405  GUISUMOAbstractView& parent) {
406  GUIGLObjectPopupMenu* ret = new GUIGLObjectPopupMenu(app, parent, *this);
407  buildPopupHeader(ret, app);
410  buildPositionCopyEntry(ret, false);
411  return ret;
412 }
413 
414 
419  new GUIParameterTableWindow(app, *this, 15);
420  // add items
421  ret->mkItem("loaded vehicles [#]", true,
423  ret->mkItem("waiting vehicles [#]", true,
425  ret->mkItem("departed vehicles [#]", true,
427  ret->mkItem("running vehicles [#]", true,
429  ret->mkItem("arrived vehicles [#]", true,
431  ret->mkItem("collisions [#]", true,
433  ret->mkItem("teleports [#]", true,
435  ret->mkItem("end time [s]", false, OptionsCont::getOptions().getString("end"));
436  ret->mkItem("begin time [s]", false, OptionsCont::getOptions().getString("begin"));
437 // ret->mkItem("time step [s]", true, new FunctionBinding<GUINet, SUMOTime>(this, &GUINet::getCurrentTimeStep));
438  if (logSimulationDuration()) {
439  ret->mkItem("step duration [ms]", true, new FunctionBinding<GUINet, unsigned int>(this, &GUINet::getWholeDuration));
440  ret->mkItem("simulation duration [ms]", true, new FunctionBinding<GUINet, unsigned int>(this, &GUINet::getSimDuration));
441  /*
442  ret->mkItem("visualisation duration [ms]", true,
443  new CastingFunctionBinding<GUINet, SUMOReal, int>(
444  &(getNet()), &GUINet::getVisDuration));
445  */
446  ret->mkItem("idle duration [ms]", true, new FunctionBinding<GUINet, unsigned int>(this, &GUINet::getIdleDuration));
447  ret->mkItem("duration factor []", true, new FunctionBinding<GUINet, SUMOReal>(this, &GUINet::getRTFactor));
448  /*
449  ret->mkItem("mean duration factor []", true,
450  new FuncBinding_IntParam<GUINet, SUMOReal>(
451  &(getNet()), &GUINet::getMeanRTFactor), 1);
452  */
453  ret->mkItem("ups [#]", true, new FunctionBinding<GUINet, SUMOReal>(this, &GUINet::getUPS));
454  ret->mkItem("mean ups [#]", true, new FunctionBinding<GUINet, SUMOReal>(this, &GUINet::getMeanUPS));
455  }
456  // close building
457  ret->closeBuilding();
458  return ret;
459 }
460 
461 
462 void
464 }
465 
466 Boundary
468  return getBoundary();
469 }
470 
471 
472 GUINet*
474  GUINet* net = dynamic_cast<GUINet*>(MSNet::getInstance());
475  if (net != 0) {
476  return net;
477  }
478  throw ProcessError("A gui-network was not yet constructed.");
479 }
480 
481 
484  return dynamic_cast<GUIVehicleControl*>(myVehicleControl);
485 }
486 
487 
488 void
490  myLock.lock();
491 }
492 
493 
494 void
496  myLock.unlock();
497 }
498 
499 #ifdef HAVE_INTERNAL
500 GUIMEVehicleControl*
501 GUINet::getGUIMEVehicleControl() {
502  return dynamic_cast<GUIMEVehicleControl*>(myVehicleControl);
503 }
504 #endif
505 
506 
507 #ifdef HAVE_OSG
508 void
509 GUINet::updateColor(const GUIVisualizationSettings& s) {
510  for (std::vector<GUIEdge*>::const_iterator i = myEdgeWrapper.begin(); i != myEdgeWrapper.end(); ++i) {
511  if ((*i)->getPurpose() != MSEdge::EDGEFUNCTION_INTERNAL) {
512  const std::vector<MSLane*>& lanes = (*i)->getLanes();
513  for (std::vector<MSLane*>::const_iterator j = lanes.begin(); j != lanes.end(); ++j) {
514  static_cast<GUILane*>(*j)->updateColor(s);
515  }
516  }
517  }
518  for (std::vector<GUIJunctionWrapper*>::iterator i = myJunctionWrapper.begin(); i != myJunctionWrapper.end(); ++i) {
519  (*i)->updateColor(s);
520  }
521 }
522 #endif
523 
524 /****************************************************************************/
525 
Boundary getBoundary() const
Returns the boundary of the junction.
Boundary myBoundary
The networks boundary.
Definition: GUINet.h:311
SUMOReal getHeight() const
Returns the height of the boundary.
Definition: Boundary.cpp:142
The class responsible for building and deletion of vehicles (gui-version)
SUMOReal getWidth() const
Returns the width of the boudary.
Definition: Boundary.cpp:136
unsigned int getRunningVehicleNo() const
Returns the number of build and inserted, but not yet deleted vehicles.
std::vector< GUIJunctionWrapper * > myJunctionWrapper
Wrapped MS-junctions.
Definition: GUINet.h:317
unsigned int getDepartedVehicleNo() const
Returns the number of inserted vehicles.
Storage for geometrical objects extended by mutexes.
SUMOReal getMeanRTFactor(int duration) const
Returns the simulation speed as a factor to real time.
Definition: GUINet.cpp:358
friend class GUITrafficLightLogicWrapper
Definition: GUINet.h:92
void unlock()
release exclusive access to the simulation state
Definition: GUINet.cpp:495
const std::vector< MSLane * > & getLanes() const
Returns this edge&#39;s lanes.
Definition: MSEdge.h:168
MSVehicleControl * myVehicleControl
Controls vehicle building and deletion;.
Definition: MSNet.h:524
void Insert(const float a_min[2], const float a_max[2], GUIGlObject *a_dataId)
Insert entry (delegate to appropriate layer)
Definition: LayeredRTree.h:79
SUMOReal ymin() const
Returns minimum y-coordinate.
Definition: Boundary.cpp:124
Stores the information about how to visualize structures.
static const SUMOReal SIDEWALK_OFFSET
the offset for computing person positions when walking
Definition: MSPerson.h:597
LayeredRTree myGrid
The visualization speed-up.
Definition: GUINet.h:308
void initTLMap()
Initialises the tl-logic map and wrappers.
Definition: GUINet.cpp:134
SUMOReal xmin() const
Returns minimum x-coordinate.
Definition: Boundary.cpp:112
void buildCenterPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to center to the object.
MSTrafficLightLogic * getActive(const std::string &id) const
Returns the active program of a named tls.
MSPersonControl * myPersonControl
Controls person building and deletion;.
Definition: MSNet.h:526
~GUINet()
Destructor.
Definition: GUINet.cpp:96
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:150
void initGUIStructures()
Initialises gui wrappers.
Definition: GUINet.cpp:256
void lock()
grant exclusive access to the simulation state
Definition: GUINet.cpp:489
unsigned int getWholeDuration() const
Returns the duration of the last step (sim+visualisation+idle) (in ms)
Definition: GUINet.cpp:320
Links2LogicMap myLinks2Logic
The link-to-logic-id map.
Definition: GUINet.h:329
Position getJunctionPosition(const std::string &name) const
returns the position of a junction
Definition: GUINet.cpp:174
void buildShowParamsPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to open the parameter window.
std::vector< GUIDetectorWrapper * > myDetectorDict
A detector dictionary.
Definition: GUINet.h:323
long myOverallVehicleCount
Definition: GUINet.h:341
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.
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
Definition: GUINet.cpp:463
GUIGlID getGlID() const
Returns the numerical id of the object.
Definition: GUIGlObject.h:115
SUMOReal xmax() const
Returns maximum x-coordinate.
Definition: Boundary.cpp:118
const Boundary & getBoundary() const
returns the bounder of the network
Definition: GUINet.cpp:119
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:48
void setIdleDuration(int val)
Sets the duration of the last step&#39;s idle part.
Definition: GUINet.cpp:398
The simulated network and simulation perfomer.
Definition: MSNet.h:89
void setNetObject(GUIGlObject *object)
Sets the given object as the &quot;network&quot; object.
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:67
SUMOLong myVehiclesMoved
The overall number of vehicle movements.
Definition: MSNet.h:567
Representation of a lane in the micro simulation (gui-version)
Definition: GUILane.h:70
T get(const std::string &id) const
Retrieves an item.
unsigned int getCollisionCount() const
return the number of collisions
GUIGLObjectPopupMenu * getPopUpMenu(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own popup-menu.
Definition: GUINet.cpp:404
Logics2WrapperMap myLogics2Wrapper
The traffic light-to-wrapper map.
Definition: GUINet.h:335
A road/street connecting two junctions (gui-version)
Definition: GUIEdge.h:61
const std::string & getID() const
Returns the id.
Definition: Named.h:60
SUMOReal getUPS() const
Returns the update per seconds rate.
Definition: GUINet.cpp:349
const NamedObjectCont< MSDetectorFileOutput * > & getTypedDetectors(SumoXMLTag type) const
Returns the list of detectors of the given type.
unsigned int getLoadedVehicleNo() const
Returns the number of build vehicles.
GUIGlID createTLWrapper(MSTrafficLightLogic *tll)
creates a wrapper for the given logic and returns the GlID
Definition: GUINet.cpp:147
std::vector< GUIGlID > getJunctionIDs(bool includeInternal) const
Definition: GUINet.cpp:229
std::vector< LinkVector > LinkVectorVector
Definition of a list that holds lists of links that do have the same attribute.
unsigned int getTeleportCount() const
return the number of teleports (including collisions)
unsigned int getWaitingVehicleNo() const
Returns the number of waiting vehicles.
GUIParameterTableWindow * getParameterWindow(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own parameter window.
Definition: GUINet.cpp:416
static GUINet * getGUIInstance()
Returns the pointer to the unique instance of GUINet (singleton).
Definition: GUINet.cpp:473
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:46
MSTLLogicControl & getTLSControl()
Returns the tls logics control.
Definition: MSNet.h:304
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition: MSNet.h:253
const LinkVectorVector & getLinks() const
Returns the list of lists of all affected links.
MSDetectorControl * myDetectorControl
Controls detectors;.
Definition: MSNet.h:536
static GUIGlObjectStorage gIDStorage
A single static instance of this class.
MSTLLogicControl * myLogics
Controls tls logics, realizes waiting on tls rules;.
Definition: MSNet.h:532
int getLinkTLIndex(MSLink *link) const
Definition: GUINet.cpp:202
static void clearDictionary()
Clears the dictionary (the objects will not be deleted)
unsigned int size() const
Returns the number of items within the container.
std::vector< MSTrafficLightLogic * > myTLLogicWrappers
Wrapped TL-Logics.
Definition: GUINet.h:320
unsigned int myLastIdleDuration
Definition: GUINet.h:339
unsigned int getSimDuration() const
Returns the duration of the last step&#39;s simulation part (in ms)
Definition: GUINet.cpp:326
const IDMap & getMyMap() const
unsigned int GUIGlID
Definition: GUIGlObject.h:48
void unlock()
release mutex lock
Definition: MFXMutex.cpp:93
void setSimDuration(int val)
Sets the duration of the last step&#39;s simulation part.
Definition: GUINet.cpp:382
std::vector< GUIEdge * > myEdgeWrapper
Wrapped MS-edges.
Definition: GUINet.h:314
void add(SUMOReal x, SUMOReal y)
Makes the boundary include the given coordinate.
Definition: Boundary.cpp:76
const std::vector< SumoXMLTag > getAvailableTypes() const
Returns the list of available detector types.
Boundary & grow(SUMOReal by)
extends the boundary by the given amount
Definition: Boundary.cpp:200
unsigned int getIdleDuration() const
Returns the duration of the last step&#39;s idle part (in ms)
Definition: GUINet.cpp:376
MSJunctionControl * myJunctions
Controls junctions, realizes right-of-way rules;.
Definition: MSNet.h:530
A MSNet extended by some values for usage within the gui.
Definition: GUINet.h:90
SUMOReal getMeanUPS() const
Returns the update per seconds rate.
Definition: GUINet.cpp:367
void addAdditionalGLObject(GUIGlObject *o)
Adds an additional object (detector/shape/trigger) for visualisation.
Definition: SUMORTree.h:117
MSInsertionControl & getInsertionControl()
Returns the insertion control.
Definition: MSNet.h:284
A mutex encapsulator which locks/unlocks the given mutex on construction/destruction, respectively.
Definition: AbstractMutex.h:71
long myOverallSimDuration
Definition: GUINet.h:342
The popup menu of a globject.
GUIVehicleControl * getGUIVehicleControl()
Returns the vehicle control.
Definition: GUINet.cpp:483
std::vector< GUIGlID > getTLSIDs() const
Returns the gl-ids of all traffic light logics within the net.
Definition: GUINet.cpp:241
bool vehicleExists(const std::string &name) const
returns the information whether the vehicle still exists
Definition: GUINet.cpp:181
void lock()
lock mutex
Definition: MFXMutex.cpp:83
unsigned int getEndedVehicleNo() const
Returns the number of removed vehicles.
SUMOVehicle * getVehicle(const std::string &id) const
Returns the vehicle with the given id.
The network - empty.
unsigned int myLastSimDuration
The step durations (simulation, /*visualisation, */idle)
Definition: GUINet.h:339
unsigned int getLinkTLID(MSLink *link) const
Definition: GUINet.cpp:187
The parent class for traffic light logics.
#define SUMOReal
Definition: config.h:215
SUMOReal getRTFactor() const
Returns the simulation speed as a factor to real time.
Definition: GUINet.cpp:340
static void updateAll()
Updates all instances (passes values)
GUI-version of the person control for building gui persons.
SUMOReal ymax() const
Returns maximum y-coordinate.
Definition: Boundary.cpp:130
void simulationStep()
Performs a single simulation step (locking the simulation)
Definition: GUINet.cpp:222
FXbool locked()
Definition: MFXMutex.h:68
bool logSimulationDuration() const
Returns whether duration shall be logged.
Definition: MSNet.cpp:596
The class responsible for building and deletion of vehicles.
std::vector< MSTrafficLightLogic * > getAllLogics() const
Returns a vector which contains all logics.
void simulationStep()
Performs a single simulation step.
Definition: MSNet.cpp:349
The edge is an internal edge.
Definition: MSEdge.h:90
GUINet(MSVehicleControl *vc, MSEventControl *beginOfTimestepEvents, MSEventControl *endOfTimestepEvents, MSEventControl *insertionEvents)
Constructor.
Definition: GUINet.cpp:86
void guiSimulationStep()
Some further steps needed for gui processing.
Definition: GUINet.cpp:215
void mkItem(const char *name, bool dynamic, ValueSource< unsigned > *src)
Adds a row which obtains its value from an unsigned-ValueSource.
void closeBuilding()
Closes the building of the table.
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
Definition: GUINet.cpp:467
A window containing a gl-object&#39;s parameter.
Stores time-dependant events and executes them at the proper time.
static void fill(std::vector< GUIEdge * > &netsWrappers)
Definition: GUIEdge.cpp:123
long myLastVehicleMovementCount
Definition: GUINet.h:341
MFXMutex myLock
The mutex used to avoid concurrent updates of the vehicle buffer.
Definition: GUINet.h:346
void buildPopupHeader(GUIGLObjectPopupMenu *ret, GUIMainWindow &app, bool addSeparator=true)
Builds the header.
const Position & getPosition() const
Definition: MSJunction.cpp:58
MSPersonControl & getPersonControl()
Returns the person control.
Definition: GUINet.cpp:125
Class passing values from a GUIGlObject to another object.