SUMO - Simulation of Urban MObility
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.dlr.de/
13 // Copyright (C) 2001-2016 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>
43 #include <utils/common/RGBColor.h>
45 #include <microsim/MSNet.h>
46 #include <microsim/MSJunction.h>
48 #include <microsim/MSEdge.h>
54 #include <guisim/GUIEdge.h>
55 #include <guisim/GUILane.h>
63 #include <gui/GUIGlobals.h>
64 #include "GUINet.h"
65 
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 
135  if (myContainerControl == 0) {
137  }
138  return *myContainerControl;
139 }
140 
141 
142 void
144  // get the list of loaded tl-logics
145  const std::vector<MSTrafficLightLogic*>& logics = getTLSControl().getAllLogics();
146  // allocate storage for the wrappers
147  myTLLogicWrappers.reserve(logics.size());
148  // go through the logics
149  for (std::vector<MSTrafficLightLogic*>::const_iterator i = logics.begin(); i != logics.end(); ++i) {
150  createTLWrapper(*i);
151  }
152 }
153 
154 
155 GUIGlID
157  if (myLogics2Wrapper.count(tll) > 0) {
158  return myLogics2Wrapper[tll]->getGlID();
159  }
160  // get the links
161  const MSTrafficLightLogic::LinkVectorVector& links = tll->getLinks();
162  if (links.size() == 0) { // @legacy this should never happen in 0.13.0+ networks
163  return 0;
164  }
165  // build the wrapper
168  // build the association link->wrapper
169  MSTrafficLightLogic::LinkVectorVector::const_iterator j;
170  for (j = links.begin(); j != links.end(); ++j) {
171  MSTrafficLightLogic::LinkVector::const_iterator j2;
172  for (j2 = (*j).begin(); j2 != (*j).end(); ++j2) {
173  myLinks2Logic[*j2] = tll->getID();
174  }
175  }
177  myLogics2Wrapper[tll] = tllw;
178  return tllw->getGlID();
179 }
180 
181 
182 Position
183 GUINet::getJunctionPosition(const std::string& name) const {
184  // !!! no check for existance!
185  return myJunctions->get(name)->getPosition();
186 }
187 
188 
189 bool
190 GUINet::vehicleExists(const std::string& name) const {
191  return myVehicleControl->getVehicle(name) != 0;
192 }
193 
194 
195 unsigned int
197  if (myLinks2Logic.count(link) == 0) {
198  assert(false);
199  return 0;
200  }
201  MSTrafficLightLogic* tll = myLogics->getActive(myLinks2Logic.find(link)->second);
202  if (myLogics2Wrapper.count(tll) == 0) {
203  // tll may have been added via traci. @see ticket #459
204  return 0;
205  }
206  return myLogics2Wrapper.find(tll)->second->getGlID();
207 }
208 
209 
210 int
212  Links2LogicMap::const_iterator i = myLinks2Logic.find(link);
213  if (i == myLinks2Logic.end()) {
214  return -1;
215  }
216  if (myLogics2Wrapper.find(myLogics->getActive((*i).second)) == myLogics2Wrapper.end()) {
217  return -1;
218  }
219  return myLogics2Wrapper.find(myLogics->getActive((*i).second))->second->getLinkIndex(link);
220 }
221 
222 
223 void
228 }
229 
230 
231 void
235 }
236 
237 
238 std::vector<GUIGlID>
239 GUINet::getJunctionIDs(bool includeInternal) const {
240  std::vector<GUIGlID> ret;
241  for (std::vector<GUIJunctionWrapper*>::const_iterator i = myJunctionWrapper.begin(); i != myJunctionWrapper.end(); ++i) {
242  if (!(*i)->isInner() || includeInternal) {
243  ret.push_back((*i)->getGlID());
244  }
245  }
246  return ret;
247 }
248 
249 
250 std::vector<GUIGlID>
252  std::vector<GUIGlID> ret;
253  std::vector<std::string> ids;
254  for (std::map<MSTrafficLightLogic*, GUITrafficLightLogicWrapper*>::const_iterator i = myLogics2Wrapper.begin(); i != myLogics2Wrapper.end(); ++i) {
255  std::string sid = (*i).second->getMicrosimID();
256  if (find(ids.begin(), ids.end(), sid) == ids.end()) {
257  ret.push_back((*i).second->getGlID());
258  ids.push_back(sid);
259  }
260  }
261  return ret;
262 }
263 
264 
265 void
267  // initialise detector storage for gui
268  const std::vector<SumoXMLTag> types = myDetectorControl->getAvailableTypes();
269  for (std::vector<SumoXMLTag>::const_iterator i = types.begin(); i != types.end(); ++i) {
270  const std::map<std::string, MSDetectorFileOutput*>& dets = myDetectorControl->getTypedDetectors(*i).getMyMap();
271  for (std::map<std::string, MSDetectorFileOutput*>::const_iterator j = dets.begin(); j != dets.end(); ++j) {
272  GUIDetectorWrapper* wrapper = (*j).second->buildDetectorGUIRepresentation();
273  if (wrapper != 0) {
274  myDetectorDict.push_back(wrapper);
275  myGrid.addAdditionalGLObject(wrapper);
276  }
277  }
278  }
279  // initialise the tl-map
280  initTLMap();
281  // initialise edge storage for gui
283  // initialise junction storage for gui
284  size_t size = myJunctions->size();
285  myJunctionWrapper.reserve(size);
286  const std::map<std::string, MSJunction*>& junctions = myJunctions->getMyMap();
287  for (std::map<std::string, MSJunction*>::const_iterator i = junctions.begin(); i != junctions.end(); ++i) {
288  myJunctionWrapper.push_back(new GUIJunctionWrapper(*(*i).second));
289  }
290  // build the visualization tree
291  float* cmin = new float[2];
292  float* cmax = new float[2];
293  for (std::vector<GUIEdge*>::iterator i = myEdgeWrapper.begin(); i != myEdgeWrapper.end(); ++i) {
294  GUIEdge* edge = *i;
295  Boundary b;
296  const std::vector<MSLane*>& lanes = edge->getLanes();
297  for (std::vector<MSLane*>::const_iterator j = lanes.begin(); j != lanes.end(); ++j) {
298  b.add((*j)->getShape().getBoxBoundary());
299  }
300  // make sure persons are always drawn and selectable since they depend on their edge being drawn
302  cmin[0] = b.xmin();
303  cmin[1] = b.ymin();
304  cmax[0] = b.xmax();
305  cmax[1] = b.ymax();
306  myGrid.Insert(cmin, cmax, edge);
307  myBoundary.add(b);
308  if (myBoundary.getWidth() > 10e16 || myBoundary.getHeight() > 10e16) {
309  throw ProcessError("Network size exceeds 1 Lightyear. Please reconsider your inputs.\n");
310  }
311  }
312  for (std::vector<GUIJunctionWrapper*>::iterator i = myJunctionWrapper.begin(); i != myJunctionWrapper.end(); ++i) {
313  GUIJunctionWrapper* junction = *i;
314  Boundary b = junction->getBoundary();
315  b.grow(2.);
316  cmin[0] = b.xmin();
317  cmin[1] = b.ymin();
318  cmax[0] = b.xmax();
319  cmax[1] = b.ymax();
320  myGrid.Insert(cmin, cmax, junction);
321  myBoundary.add(b);
322  }
323  delete[] cmin;
324  delete[] cmax;
326 }
327 
328 
329 unsigned int
331  return myLastSimDuration +/*myLastVisDuration+*/myLastIdleDuration;
332 }
333 
334 
335 unsigned int
337  return myLastSimDuration;
338 }
339 
340 /*
341 int
342 GUINet::getVisDuration() const
343 {
344  return myLastVisDuration;
345 }
346 */
347 
348 
349 SUMOReal
351  if (myLastSimDuration == 0) {
352  return -1;
353  }
354  return (SUMOReal) 1000. / (SUMOReal) myLastSimDuration;
355 }
356 
357 
358 SUMOReal
359 GUINet::getUPS() const {
360  if (myLastSimDuration == 0) {
361  return -1;
362  }
364 }
365 
366 
367 SUMOReal
368 GUINet::getMeanRTFactor(int duration) const {
369  if (myOverallSimDuration == 0) {
370  return -1;
371  }
372  return ((SUMOReal)(duration) * (SUMOReal) 1000. / (SUMOReal)myOverallSimDuration);
373 }
374 
375 
376 SUMOReal
378  if (myOverallSimDuration == 0) {
379  return -1;
380  }
382 }
383 
384 
385 unsigned int
387  return myLastIdleDuration;
388 }
389 
390 
391 void
393  myLastSimDuration = val;
394  myOverallSimDuration += val;
397 }
398 
399 /*
400 void
401 GUINet::setVisDuration(int val)
402 {
403  myLastVisDuration = val;
404 }
405 */
406 
407 void
409  myLastIdleDuration = val;
410 }
411 
412 
415  GUISUMOAbstractView& parent) {
416  GUIGLObjectPopupMenu* ret = new GUIGLObjectPopupMenu(app, parent, *this);
417  buildPopupHeader(ret, app);
420  buildPositionCopyEntry(ret, false);
421  return ret;
422 }
423 
424 
429  new GUIParameterTableWindow(app, *this, 28);
430  // add items
431  ret->mkItem("loaded vehicles [#]", true,
433  ret->mkItem("insertion-backlogged vehicles [#]", true,
435  ret->mkItem("departed vehicles [#]", true,
437  ret->mkItem("running vehicles [#]", true,
439  ret->mkItem("arrived vehicles [#]", true,
441  ret->mkItem("collisions [#]", true,
443  ret->mkItem("teleports [#]", true,
445  if (myPersonControl != 0) {
446  ret->mkItem("loaded persons [#]", true,
448  ret->mkItem("running persons [#]", true,
450  ret->mkItem("jammed persons [#]", true,
452  }
453  ret->mkItem("end time [s]", false, OptionsCont::getOptions().getString("end"));
454  ret->mkItem("begin time [s]", false, OptionsCont::getOptions().getString("begin"));
455 // ret->mkItem("time step [s]", true, new FunctionBinding<GUINet, SUMOTime>(this, &GUINet::getCurrentTimeStep));
456  if (logSimulationDuration()) {
457  ret->mkItem("step duration [ms]", true, new FunctionBinding<GUINet, unsigned int>(this, &GUINet::getWholeDuration));
458  ret->mkItem("simulation duration [ms]", true, new FunctionBinding<GUINet, unsigned int>(this, &GUINet::getSimDuration));
459  /*
460  ret->mkItem("visualisation duration [ms]", true,
461  new CastingFunctionBinding<GUINet, SUMOReal, int>(
462  &(getNet()), &GUINet::getVisDuration));
463  */
464  ret->mkItem("idle duration [ms]", true, new FunctionBinding<GUINet, unsigned int>(this, &GUINet::getIdleDuration));
465  ret->mkItem("duration factor []", true, new FunctionBinding<GUINet, SUMOReal>(this, &GUINet::getRTFactor));
466  /*
467  ret->mkItem("mean duration factor []", true,
468  new FuncBinding_IntParam<GUINet, SUMOReal>(
469  &(getNet()), &GUINet::getMeanRTFactor), 1);
470  */
471  ret->mkItem("ups [#]", true, new FunctionBinding<GUINet, SUMOReal>(this, &GUINet::getUPS));
472  ret->mkItem("mean ups [#]", true, new FunctionBinding<GUINet, SUMOReal>(this, &GUINet::getMeanUPS));
473  if (OptionsCont::getOptions().getBool("duration-log.statistics")) {
474  ret->mkItem("avg. trip length [m]", true, new FunctionBinding<GUINet, SUMOReal>(this, &GUINet::getAvgRouteLength));
475  ret->mkItem("avg. trip duration [s]", true, new FunctionBinding<GUINet, SUMOReal>(this, &GUINet::getAvgDuration));
476  ret->mkItem("avg. trip waiting time [s]", true, new FunctionBinding<GUINet, SUMOReal>(this, &GUINet::getAvgWaitingTime));
477  ret->mkItem("avg. trip time loss [s]", true, new FunctionBinding<GUINet, SUMOReal>(this, &GUINet::getAvgTimeLoss));
478  ret->mkItem("avg. trip depart delay [s]", true, new FunctionBinding<GUINet, SUMOReal>(this, &GUINet::getAvgDepartDelay));
479  }
480  }
481  ret->mkItem("nodes [#]", false, (int)myJunctions->size());
482  ret->mkItem("edges [#]", false, (int)GUIEdge::getIDs(false).size());
483  ret->mkItem("total edge length [km]", false, GUIEdge::getTotalLength(false, false) / 1000);
484  ret->mkItem("total lane length [km]", false, GUIEdge::getTotalLength(false, true) / 1000);
485  ret->mkItem("network version ", false, toString(myVersion));
486 
487  // close building
488  ret->closeBuilding();
489  return ret;
490 }
491 
492 
493 void
495 }
496 
497 Boundary
499  return getBoundary();
500 }
501 
502 
503 GUINet*
505  GUINet* net = dynamic_cast<GUINet*>(MSNet::getInstance());
506  if (net != 0) {
507  return net;
508  }
509  throw ProcessError("A gui-network was not yet constructed.");
510 }
511 
512 
515  return dynamic_cast<GUIVehicleControl*>(myVehicleControl);
516 }
517 
518 
519 void
521  myLock.lock();
522 }
523 
524 
525 void
527  myLock.unlock();
528 }
529 
532  return dynamic_cast<GUIMEVehicleControl*>(myVehicleControl);
533 }
534 
535 
536 #ifdef HAVE_OSG
537 void
538 GUINet::updateColor(const GUIVisualizationSettings& s) {
539  for (std::vector<GUIEdge*>::const_iterator i = myEdgeWrapper.begin(); i != myEdgeWrapper.end(); ++i) {
540  if ((*i)->getPurpose() != MSEdge::EDGEFUNCTION_INTERNAL) {
541  const std::vector<MSLane*>& lanes = (*i)->getLanes();
542  for (std::vector<MSLane*>::const_iterator j = lanes.begin(); j != lanes.end(); ++j) {
543  static_cast<GUILane*>(*j)->updateColor(s);
544  }
545  }
546  }
547  for (std::vector<GUIJunctionWrapper*>::iterator i = myJunctionWrapper.begin(); i != myJunctionWrapper.end(); ++i) {
548  (*i)->updateColor(s);
549  }
550 }
551 #endif
552 
553 /****************************************************************************/
554 
SUMOReal getAvgDuration() const
Definition: GUINet.h:213
Boundary getBoundary() const
Returns the boundary of the junction.
Boundary myBoundary
The networks boundary.
Definition: GUINet.h:334
unsigned int getLoadedPersonNumber() const
Returns the number of build Persons.
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:340
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:368
friend class GUITrafficLightLogicWrapper
Definition: GUINet.h:91
void unlock()
release exclusive access to the simulation state
Definition: GUINet.cpp:526
const std::vector< MSLane * > & getLanes() const
Returns this edge&#39;s lanes.
Definition: MSEdge.h:185
MSVehicleControl * myVehicleControl
Controls vehicle building and deletion;.
Definition: MSNet.h:667
SUMOReal ymin() const
Returns minimum y-coordinate.
Definition: Boundary.cpp:124
Stores the information about how to visualize structures.
SUMOReal getAvgWaitingTime() const
Definition: GUINet.h:216
LayeredRTree myGrid
The visualization speed-up.
Definition: GUINet.h:331
void initTLMap()
Initialises the tl-logic map and wrappers.
Definition: GUINet.cpp:143
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.
GUIMEVehicleControl * getGUIMEVehicleControl()
Returns the vehicle control.
Definition: GUINet.cpp:531
unsigned int getJammedPersonNumber() const
Returns the number of times a person was jammed.
The class responsible for building and deletion of vehicles (gui-version)
unsigned int getRunningPersonNumber() const
Returns the number of build and inserted, but not yet deleted Persons.
MSPersonControl * myPersonControl
Controls person building and deletion;.
Definition: MSNet.h:669
~GUINet()
Destructor.
Definition: GUINet.cpp:96
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:160
void initGUIStructures()
Initialises gui wrappers.
Definition: GUINet.cpp:266
SUMOReal getAvgDepartDelay() const
Definition: GUINet.h:222
void lock()
grant exclusive access to the simulation state
Definition: GUINet.cpp:520
unsigned int getWholeDuration() const
Returns the duration of the last step (sim+visualisation+idle) (in ms)
Definition: GUINet.cpp:330
Links2LogicMap myLinks2Logic
The link-to-logic-id map.
Definition: GUINet.h:352
Position getJunctionPosition(const std::string &name) const
returns the position of a junction
Definition: GUINet.cpp:183
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:346
long myOverallVehicleCount
Definition: GUINet.h:364
static SUMOReal getTotalLength(bool includeInternal, bool eachLane)
Definition: GUIEdge.cpp:115
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:494
GUIGlID getGlID() const
Returns the numerical id of the object.
Definition: GUIGlObject.h:123
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:408
The simulated network and simulation perfomer.
Definition: MSNet.h:94
void setNetObject(GUIGlObject *object)
Sets the given object as the "network" object.
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:69
Representation of a lane in the micro simulation (gui-version)
Definition: GUILane.h:70
T get(const std::string &id) const
Retrieves an item.
SUMOReal getAvgRouteLength() const
Definition: GUINet.h:210
unsigned int getCollisionCount() const
return the number of collisions
GUIGLObjectPopupMenu * getPopUpMenu(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own popup-menu.
Definition: GUINet.cpp:414
Logics2WrapperMap myLogics2Wrapper
The traffic light-to-wrapper map.
Definition: GUINet.h:358
#define new
Definition: debug_new.h:121
A road/street connecting two junctions (gui-version)
Definition: GUIEdge.h:60
const std::string & getID() const
Returns the id.
Definition: Named.h:65
long long int myVehiclesMoved
The overall number of vehicle movements.
Definition: MSNet.h:712
SUMOReal getUPS() const
Returns the update per seconds rate.
Definition: GUINet.cpp:359
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:156
std::vector< GUIGlID > getJunctionIDs(bool includeInternal) const
Definition: GUINet.cpp:239
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:426
static GUINet * getGUIInstance()
Returns the pointer to the unique instance of GUINet (singleton).
Definition: GUINet.cpp:504
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:369
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition: MSNet.h:308
const LinkVectorVector & getLinks() const
Returns the list of lists of all affected links.
MSDetectorControl * myDetectorControl
Controls detectors;.
Definition: MSNet.h:681
static GUIGlObjectStorage gIDStorage
A single static instance of this class.
MSTLLogicControl * myLogics
Controls tls logics, realizes waiting on tls rules;.
Definition: MSNet.h:677
int getLinkTLIndex(MSLink *link) const
Definition: GUINet.cpp:211
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:343
unsigned int myLastIdleDuration
Definition: GUINet.h:362
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
Definition: ToString.h:54
SUMOReal myVersion
the network version
Definition: MSNet.h:744
MSContainerControl * myContainerControl
Controls container building and deletion;.
Definition: MSNet.h:671
unsigned int getSimDuration() const
Returns the duration of the last step&#39;s simulation part (in ms)
Definition: GUINet.cpp:336
const IDMap & getMyMap() const
unsigned int GUIGlID
Definition: GUIGlObject.h:49
void unlock()
release mutex lock
Definition: MFXMutex.cpp:96
void setSimDuration(int val)
Sets the duration of the last step&#39;s simulation part.
Definition: GUINet.cpp:392
static std::vector< GUIGlID > getIDs(bool includeInternal)
Definition: GUIEdge.cpp:100
std::vector< GUIEdge * > myEdgeWrapper
Wrapped MS-edges.
Definition: GUINet.h:337
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:201
static const SUMOReal SIDEWALK_OFFSET
the offset for computing person positions when walking on edges without a sidewalk ...
Definition: MSPModel.h:81
void Insert(const float a_min[2], const float a_max[2], GUIGlObject *const &a_dataId)
Insert entry (delegate to appropriate layer)
Definition: LayeredRTree.h:79
GUI-version of the container control for building gui containers.
unsigned int getIdleDuration() const
Returns the duration of the last step&#39;s idle part (in ms)
Definition: GUINet.cpp:386
MSJunctionControl * myJunctions
Controls junctions, realizes right-of-way rules;.
Definition: MSNet.h:675
A MSNet extended by some values for usage within the gui.
Definition: GUINet.h:89
SUMOReal getMeanUPS() const
Returns the update per seconds rate.
Definition: GUINet.cpp:377
void addAdditionalGLObject(GUIGlObject *o)
Adds an additional object (detector/shape/trigger) for visualisation.
Definition: SUMORTree.h:129
MSInsertionControl & getInsertionControl()
Returns the insertion control.
Definition: MSNet.h:349
A mutex encapsulator which locks/unlocks the given mutex on construction/destruction, respectively.
Definition: AbstractMutex.h:71
long myOverallSimDuration
Definition: GUINet.h:365
The popup menu of a globject.
GUIVehicleControl * getGUIVehicleControl()
Returns the vehicle control.
Definition: GUINet.cpp:514
std::vector< GUIGlID > getTLSIDs() const
Returns the gl-ids of all traffic light logics within the net.
Definition: GUINet.cpp:251
bool vehicleExists(const std::string &name) const
returns the information whether the vehicle still exists
Definition: GUINet.cpp:190
void lock()
lock mutex
Definition: MFXMutex.cpp:86
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:362
unsigned int getLinkTLID(MSLink *link) const
Definition: GUINet.cpp:196
static void updateAll()
Updates all instances.
The parent class for traffic light logics.
#define SUMOReal
Definition: config.h:213
SUMOReal getRTFactor() const
Returns the simulation speed as a factor to real time.
Definition: GUINet.cpp:350
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:232
FXbool locked()
Definition: MFXMutex.h:70
bool logSimulationDuration() const
Returns whether duration shall be logged.
Definition: MSNet.cpp:684
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:420
The edge is an internal edge.
Definition: MSEdge.h:97
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:224
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:498
MSContainerControl & getContainerControl()
Returns the container control.
Definition: GUINet.cpp:134
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:157
long myLastVehicleMovementCount
Definition: GUINet.h:364
SUMOReal getAvgTimeLoss() const
Definition: GUINet.h:219
MFXMutex myLock
The mutex used to avoid concurrent updates of the vehicle buffer.
Definition: GUINet.h:369
void buildPopupHeader(GUIGLObjectPopupMenu *ret, GUIMainWindow &app, bool addSeparator=true)
Builds the header.
const Position & getPosition() const
Definition: MSJunction.cpp:67
MSPersonControl & getPersonControl()
Returns the person control.
Definition: GUINet.cpp:125
Class passing values from a GUIGlObject to another object.