Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
GUIViewTraffic.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
22// A view on the simulation; this view is a microscopic one
23/****************************************************************************/
24#include <config.h>
25
26#ifdef HAVE_FFMPEG
28#endif
29
30#include <iostream>
31#include <utility>
32#include <cmath>
33#include <limits>
36#include <gui/GUIGlobals.h>
37#include <guisim/GUIEdge.h>
38#include <guisim/GUILane.h>
39#include <guisim/GUINet.h>
40#include <guisim/GUIVehicle.h>
42#include <microsim/MSEdge.h>
43#include <microsim/MSGlobals.h>
45#include <microsim/MSLane.h>
67
68#include "GUISUMOViewParent.h"
69#include "GUIViewTraffic.h"
70
71// ===========================================================================
72// member method definitions
73// ===========================================================================
75 FXComposite* p,
76 GUIMainWindow& app,
77 GUISUMOViewParent* parent,
78 GUINet& net, FXGLVisual* glVis,
79 FXGLCanvas* share) :
80 GUISUMOAbstractView(p, app, parent, net.getVisualisationSpeedUp(), glVis, share),
81 myTrackedID(GUIGlObject::INVALID_ID),
82 myTLSGame(OptionsCont::getOptions().getString("game.mode") == "tls")
83#ifdef HAVE_FFMPEG
84 , myCurrentVideo(nullptr)
85#endif
86{}
87
88
92
93
94void
96 // build coloring tools
97 {
98 const std::vector<std::string>& names = gSchemeStorage.getNames();
99 for (std::vector<std::string>::const_iterator i = names.begin(); i != names.end(); ++i) {
100 v->getColoringSchemesCombo()->appendIconItem(i->c_str());
101 if ((*i) == myVisualizationSettings->name) {
103 }
104 }
105 }
106 // for junctions
108 (std::string("\t") + TL("Locate Junctions") + std::string("\t") + TL("Locate a junction within the network.")).c_str(),
111 // for edges
113 (std::string("\t") + TL("Locate Edges") + std::string("\t") + TL("Locate an edge within the network.")).c_str(),
116 // for vehicles
118 (std::string("\t") + TL("Locate Vehicles") + std::string("\t") + TL("Locate a vehicle within the network.")).c_str(),
121 // for persons
123 (std::string("\t") + TL("Locate Persons") + std::string("\t") + TL("Locate a person within the network.")).c_str(),
126 // for containers
128 (std::string("\t") + TL("Locate Container") + std::string("\t") + TL("Locate a container within the network.")).c_str(),
131 // for tls
133 (std::string("\t") + TL("Locate TLS") + std::string("\t") + TL("Locate a tls within the network.")).c_str(),
136 // for additional stuff
138 (std::string("\t") + TL("Locate Additional") + std::string("\t") + TL("Locate an additional structure within the network.")).c_str(),
141 // for pois
143 (std::string("\t") + TL("Locate PoI") + std::string("\t") + TL("Locate a PoI within the network.")).c_str(),
146 // for polygons
148 (std::string("\t") + TL("Locate Polygon") + std::string("\t") + TL("Locate a Polygon within the network.")).c_str(),
151}
152
153
154bool
155GUIViewTraffic::setColorScheme(const std::string& name) {
156 if (!gSchemeStorage.contains(name)) {
157 return false;
158 }
159 if (myGUIDialogViewSettings != nullptr) {
162 }
163 }
166 update();
167 return true;
168}
169
170
171void
174 assert(!scheme.isFixed());
175 double minValue = std::numeric_limits<double>::infinity();
176 double maxValue = -std::numeric_limits<double>::infinity();
177 // retrieve range
178 bool hasMissingData = false;
179 if (objectType == GLO_LANE) {
180 // XXX (see #3409) multi-colors are not currently handled. this is a quick hack
181 if (active == 22) {
182 active = 21; // segment height, fall back to start height
183 } else if (active == 24) {
184 active = 23; // segment incline, fall back to total incline
185 }
186 const MSEdgeVector& edges = MSEdge::getAllEdges();
187 for (MSEdgeVector::const_iterator it = edges.begin(); it != edges.end(); ++it) {
189 const double val = static_cast<GUIEdge*>(*it)->getColorValue(s, active);
190 if (val == s.MISSING_DATA) {
191 hasMissingData = true;
192 continue;
193 }
194 minValue = MIN2(minValue, val);
195 maxValue = MAX2(maxValue, val);
196 } else {
197 const std::vector<MSLane*>& lanes = (*it)->getLanes();
198 for (std::vector<MSLane*>::const_iterator it_l = lanes.begin(); it_l != lanes.end(); it_l++) {
199 const double val = static_cast<GUILane*>(*it_l)->getColorValue(s, active);
200 if (val == s.MISSING_DATA) {
201 hasMissingData = true;
202 continue;
203 }
204 minValue = MIN2(minValue, val);
205 maxValue = MAX2(maxValue, val);
206 }
207 }
208 }
209 } else if (objectType == GLO_JUNCTION) {
210 if (active == 3) {
211 std::set<const MSJunction*> junctions;
212 for (MSEdge* edge : MSEdge::getAllEdges()) {
213 junctions.insert(edge->getFromJunction());
214 junctions.insert(edge->getToJunction());
215 }
216 for (const MSJunction* junction : junctions) {
217 minValue = MIN2(minValue, junction->getPosition().z());
218 maxValue = MAX2(maxValue, junction->getPosition().z());
219 }
220 }
221 }
223 scheme.clear();
224 // add threshold for every distinct value
225 std::set<SVCPermissions> codes;
226 for (MSEdge* edge : MSEdge::getAllEdges()) {
227 for (MSLane* lane : edge->getLanes()) {
228 codes.insert(lane->getPermissions());
229 }
230 }
231 int step = MAX2(1, 360 / (int)codes.size());
232 int hue = 0;
233 for (SVCPermissions p : codes) {
234 scheme.addColor(RGBColor::fromHSV(hue, 1, 1), (double)p);
235 hue = (hue + step) % 360;
236 }
237 return;
238 }
239 buildMinMaxRainbow(s, scheme, rs, minValue, maxValue, hasMissingData);
240}
241
242
243std::vector<std::string>
245 if (GUINet::getGUIInstance() != nullptr) {
247 }
248 return std::vector<std::string>();
249}
250
251
252std::vector<std::string>
254 if (GUINet::getGUIInstance() != nullptr) {
256 }
257 return std::vector<std::string>();
258}
259
260std::vector<std::string>
261GUIViewTraffic::getMeanDataAttrs(const std::string& meanDataID) const {
262 if (GUINet::getGUIInstance() != nullptr) {
263 return GUINet::getGUIInstance()->getMeanDataAttrs(meanDataID);
264 }
265 return std::vector<std::string>();
266}
267
268
269std::vector<std::string>
271 std::set<std::string> keys;
272 for (const MSEdge* e : MSEdge::getAllEdges()) {
273 if (edgeKeys) {
274 for (const auto& item : e->getParametersMap()) {
275 keys.insert(item.first);
276 }
277 } else {
278 for (const auto lane : e->getLanes()) {
279 for (const auto& item : lane->getParametersMap()) {
280 keys.insert(item.first);
281 }
282 }
283 }
284 }
285 return std::vector<std::string>(keys.begin(), keys.end());
286}
287
288
289std::vector<std::string>
290GUIViewTraffic::getVehicleParamKeys(bool /*vTypeKeys*/) const {
291 std::set<std::string> keys;
293 vc->secureVehicles();
294 for (auto vehIt = vc->loadedVehBegin(); vehIt != vc->loadedVehEnd(); ++vehIt) {
295 for (auto kv : vehIt->second->getParameter().getParametersMap()) {
296 keys.insert(kv.first);
297 }
298 }
299 vc->releaseVehicles();
300 return std::vector<std::string>(keys.begin(), keys.end());
301}
302
303std::vector<std::string>
305 std::set<std::string> keys;
306 const ShapeContainer::POIs& pois = static_cast<ShapeContainer&>(GUINet::getInstance()->getShapeContainer()).getPOIs();
307 for (auto item : pois) {
308 for (auto kv : item.second->getParametersMap()) {
309 keys.insert(kv.first);
310 }
311 }
312 return std::vector<std::string>(keys.begin(), keys.end());
313}
314
315int
316GUIViewTraffic::doPaintGL(int mode, const Boundary& bound) {
317 // init view settings
318 glRenderMode(mode);
319 glMatrixMode(GL_MODELVIEW);
321 glDisable(GL_TEXTURE_2D);
322 glDisable(GL_ALPHA_TEST);
323 glEnable(GL_BLEND);
324 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
325 glEnable(GL_DEPTH_TEST);
326
327 // draw decals (if not in grabbing mode)
328 drawDecals();
331 paintGLGrid();
332 }
333 glLineWidth(1);
334 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
335 const float minB[2] = { (float)bound.xmin(), (float)bound.ymin() };
336 const float maxB[2] = { (float)bound.xmax(), (float)bound.ymax() };
337 glEnable(GL_POLYGON_OFFSET_FILL);
338 glEnable(GL_POLYGON_OFFSET_LINE);
340 int hits2 = grid.Search(minB, maxB, *myVisualizationSettings);
342 // Draw additional objects
343 if (myAdditionallyDrawn.size() > 0) {
344 glTranslated(0, 0, -.01);
346 for (auto i : myAdditionallyDrawn) {
347 i.first->drawGLAdditional(this, *myVisualizationSettings);
348 }
350 glTranslated(0, 0, .01);
351 }
353 /*
354 // draw legends
355 glMatrixMode(GL_MODELVIEW);
356 glLoadIdentity();
357 glTranslated(1.-.2, 1.-.5, 0.);
358 glScaled(.2, .5, 1.);
359 GUIColoringSchemesMap<GUILane> &sm = GUIViewTraffic::getLaneSchemesMap(); //!!!
360 sm.getColorer(myVisualizationSettings->laneEdgeMode)->drawLegend();
361 */
362 return hits2;
363}
364
365
366void
368 myTrackedID = id;
370 if (o != nullptr) {
371 GUIBaseVehicle* v = dynamic_cast<GUIBaseVehicle*>(o);
372 if (v != nullptr) {
374 }
375 }
376}
377
378
379void
383
384
387 return myTrackedID;
388}
389
390
391void
393 if (myTLSGame) {
395 MSTrafficLightLogic* minTll = nullptr;
396 double minDist = std::numeric_limits<double>::infinity();
397 for (MSTrafficLightLogic* const tll : tlsControl.getAllLogics()) {
398 if (tlsControl.isActive(tll) && tll->getProgramID() != "off") {
399 // get the links
400 const MSTrafficLightLogic::LaneVector& lanes = tll->getLanesAt(0);
401 if (lanes.size() > 0) {
402 const Position& endPos = lanes[0]->getShape().back();
403 if (endPos.distanceTo(pos) < minDist) {
404 minDist = endPos.distanceTo(pos);
405 minTll = tll;
406 }
407 }
408 }
409 }
410 if (minTll != nullptr) {
411 if (minTll->getPhaseNumber() == 0) {
412 // MSRailSignal
413 return;
414 }
415 const int ci = minTll->getCurrentPhaseIndex();
416 const int n = minTll->getPhaseNumber();
417 int greenCount = 0;
418 for (auto& phase : minTll->getPhases()) {
419 if (phase->isGreenPhase()) {
420 greenCount++;
421 }
422 }
423 int nextPhase = (ci + 1) % n;
424 SUMOTime nextDuration = 0;
425 if (minTll->getCurrentPhaseDef().isGreenPhase() || (greenCount == 1 && minTll->getCurrentPhaseDef().isAllRedPhase())) {
426 nextDuration = minTll->getPhase(nextPhase).duration;
427 } else {
428 // we are in transition to a green phase
429 // -> skip forward to the transition into the next green phase
430 // but ensure that the total transition time is maintained
431 // taking into account how much time was already spent
432 SUMOTime spentTransition = minTll->getSpentDuration();
433 // the transition may consist of more than one phase so we
434 // search backwards until the prior green phase
435 for (int i = ci - 1; i != ci; i--) {
436 if (i < 0) {
437 i = n - 1;
438 }
439 if (minTll->getPhase(i).isGreenPhase()) {
440 break;
441 }
442 spentTransition += minTll->getPhase(i).duration;
443 }
444 // now we skip past the next greenphase
445 int numGreen = 0;
446 int i = nextPhase;
447 for (; numGreen < 2; i = (i + 1) % n) {
448 if (minTll->getPhase(i).isGreenPhase()) {
449 numGreen++;
450 continue;
451 }
452 // transition after the next green
453 if (numGreen == 1) {
454 SUMOTime dur = minTll->getPhase(i).duration;
455 if (dur <= spentTransition) {
456 spentTransition -= dur;
457 } else {
458 nextPhase = i;
459 nextDuration = dur - spentTransition;
460 break;
461 }
462 }
463 }
464 }
465 minTll->changeStepAndDuration(tlsControl, MSNet::getInstance()->getCurrentTimeStep(), nextPhase, nextDuration);
466 update();
467 }
468 } else {
469 // DRT game
471 return;
472 }
473 const auto& sel = gSelected.getSelected(GLO_VEHICLE);
474 if (sel.size() == 0) {
475 // find closest pt vehicle
476 double minDist = std::numeric_limits<double>::infinity();
477 GUIVehicle* closest = nullptr;
481 for (it = vc.loadedVehBegin(); it != end; ++it) {
482 GUIVehicle* veh = dynamic_cast<GUIVehicle*>(it->second);
483 assert(veh != 0);
484 if (veh->getParameter().line != "") {
485 const double dist = veh->getPosition().distanceTo2D(pos);
486 if (dist < minDist) {
487 minDist = dist;
488 closest = veh;
489 }
490 }
491 }
492 if (closest != nullptr) {
493 gSelected.select(closest->getGlID());
495 }
496 } else {
497 // find closest pt stop
498 double minDist = std::numeric_limits<double>::infinity();
499 MSStoppingPlace* closestStop = nullptr;
501 for (auto it = stops.begin(); it != stops.end(); ++it) {
502 MSStoppingPlace* stop = it->second;
503 const double dist = pos.distanceTo2D(stop->getLane().geometryPositionAtOffset(stop->getEndLanePosition()));
504 if (dist < minDist) {
505 minDist = dist;
506 closestStop = stop;
507 }
508 }
509 if (closestStop != 0) {
510 GUIGlID id = *sel.begin();
512 assert(veh != 0);
513 MSLane* lane = veh->getMutableLane();
514 lane->getVehiclesSecure();
515 veh->rerouteDRTStop(closestStop);
517 lane->releaseVehicles();
518 }
519 }
520 }
521}
522
523
524void
526 const auto& sel = gSelected.getSelected(GLO_VEHICLE);
527 if (sel.size() > 0) {
528 GUIGlID id = *sel.begin();
530 if (veh != 0) {
532 }
534 }
536}
537
538
543
544
545long
546GUIViewTraffic::onCmdCloseLane(FXObject*, FXSelector, void*) {
547 GUILane* lane = getLaneUnderCursor();
548 if (lane != nullptr) {
549 lane->closeTraffic();
551 update();
552 }
553 return 1;
554}
555
556
557long
558GUIViewTraffic::onCmdCloseEdge(FXObject*, FXSelector, void*) {
559 GUILane* lane = getLaneUnderCursor();
560 if (lane != nullptr) {
561 dynamic_cast<GUIEdge*>(&lane->getEdge())->closeTraffic(lane);
563 update();
564 }
565 return 1;
566}
567
568
569long
570GUIViewTraffic::onCmdAddRerouter(FXObject*, FXSelector, void*) {
571 GUILane* lane = getLaneUnderCursor();
572 if (lane != nullptr) {
573 dynamic_cast<GUIEdge*>(&lane->getEdge())->addRerouter();
575 update();
576 }
577 return 1;
578}
579
580
581long
582GUIViewTraffic::showLaneReachability(GUILane* lane, FXObject* menu, FXSelector) {
583 if (lane != nullptr) {
584 // reset
585 const double UNREACHED = INVALID_DOUBLE;
587 for (const MSEdge* const e : MSEdge::getAllEdges()) {
588 for (MSLane* const l : e->getLanes()) {
589 GUILane* gLane = dynamic_cast<GUILane*>(l);
590 gLane->setReachability(UNREACHED);
591 }
592 }
593 // prepare
594 FXMenuCommand* mc = dynamic_cast<FXMenuCommand*>(menu);
595 const SUMOVehicleClass svc = SumoVehicleClassStrings.get(mc->getText().text());
596 const double defaultMaxSpeed = SUMOVTypeParameter::VClassDefaultValues(svc).desiredMaxSpeed;
597 // find reachable
598 std::map<MSEdge*, double> reachableEdges;
599 reachableEdges[&lane->getEdge()] = 0;
600 MSEdgeVector check;
601 check.push_back(&lane->getEdge());
602 while (check.size() > 0) {
603 MSEdge* e = check.front();
604 check.erase(check.begin());
605 double traveltime = reachableEdges[e];
606 for (MSLane* const l : e->getLanes()) {
607 if (l->allowsVehicleClass(svc)) {
608 GUILane* gLane = dynamic_cast<GUILane*>(l);
609 gSelected.select(gLane->getGlID(), false);
610 gLane->setReachability(traveltime);
611 }
612 }
613 const double dt = e->getLength() / MIN2(e->getSpeedLimit(), defaultMaxSpeed);
614 // ensure algorithm termination
615 traveltime += MAX2(dt, NUMERICAL_EPS);
616 for (MSEdge* const nextEdge : e->getSuccessors(svc)) {
617 if (reachableEdges.count(nextEdge) == 0 ||
618 // revisit edge via faster path
619 reachableEdges[nextEdge] > traveltime) {
620 reachableEdges[nextEdge] = traveltime;
621 check.push_back(nextEdge);
622 }
623 }
624 if (svc == SVC_PEDESTRIAN) {
625 // can also walk backwards
626 for (MSEdge* const prevEdge : e->getPredecessors()) {
627 if (prevEdge->allowedLanes(*e, svc) != nullptr &&
628 (reachableEdges.count(prevEdge) == 0 ||
629 // revisit edge via faster path
630 reachableEdges[prevEdge] > traveltime)) {
631 reachableEdges[prevEdge] = traveltime;
632 check.push_back(prevEdge);
633 }
634 }
635 // and connect to arbitrary incoming if there are no walkingareas
637 for (const MSEdge* const in_const : e->getToJunction()->getIncoming()) {
638 MSEdge* in = const_cast<MSEdge*>(in_const);
639 if ((in->getPermissions() & svc) == svc &&
640 (reachableEdges.count(in) == 0 ||
641 // revisit edge via faster path
642 reachableEdges[in] > traveltime)) {
643 reachableEdges[in] = traveltime;
644 check.push_back(in);
645 }
646 }
647 }
648 }
649 }
651 }
652 return 1;
653}
654
655
656long
657GUIViewTraffic::onCmdShowReachability(FXObject* menu, FXSelector selector, void*) {
658 GUILane* lane = getLaneUnderCursor();
659 if (lane != nullptr) {
660 // reset
661 showLaneReachability(lane, menu, selector);
662 // switch to 'color by selection' unless coloring 'by reachability'
665 }
666 update();
667 }
668 return 1;
669}
670
671
672GUILane*
674 if (makeCurrent()) {
675 int id = getObjectUnderCursor();
676 if (id != 0) {
678 if (o != nullptr) {
679 return dynamic_cast<GUILane*>(o);
680 }
681 }
682 makeNonCurrent();
683 }
684 return nullptr;
685}
686
687
688long
689GUIViewTraffic::onDoubleClicked(FXObject*, FXSelector, void*) {
690 // leave fullscreen mode
691 if (myApp->isFullScreen()) {
692 myApp->onCmdFullScreen(nullptr, 0, nullptr);
693 } else {
694 stopTrack();
695 }
696 return 1;
697}
698
699
700
701void
702GUIViewTraffic::saveFrame(const std::string& destFile, FXColor* buf) {
703#ifdef HAVE_FFMPEG
704 if (myCurrentVideo == nullptr) {
705 myCurrentVideo = new GUIVideoEncoder(destFile.c_str(), getWidth(), getHeight(), myApp->getDelay());
706 }
707 myCurrentVideo->writeFrame((uint8_t*)buf);
708#else
709 UNUSED_PARAMETER(destFile);
710 UNUSED_PARAMETER(buf);
711#endif
712}
713
714
715void
717#ifdef HAVE_FFMPEG
718 if (myCurrentVideo != nullptr) {
719 delete myCurrentVideo;
720 myCurrentVideo = nullptr;
721 }
722#endif
723}
724
725
726void
728#ifdef HAVE_FFMPEG
729 if (myCurrentVideo != nullptr) {
731 }
732#endif
734}
735
736
737const std::vector<SUMOTime>
741
742
743void
745 GUIShapeContainer& shapeContainer = dynamic_cast<GUIShapeContainer&>(GUINet::getInstance()->getShapeContainer());
746 if (s.showPedestrianNetwork) {
747 shapeContainer.removeInactivePolygonTypes(std::set<std::string> {"jupedsim.pedestrian_network"});
748 } else {
749 shapeContainer.addInactivePolygonTypes(std::set<std::string> {"jupedsim.pedestrian_network"});
750 }
751 update();
752}
753
754
755void
757 GUIShapeContainer& shapeContainer = dynamic_cast<GUIShapeContainer&>(GUINet::getInstance()->getShapeContainer());
758 for (auto polygonwithID : shapeContainer.getPolygons()) {
759 if (polygonwithID.second->getShapeType() == "jupedsim.pedestrian_network") {
760 polygonwithID.second->setShapeColor(s.pedestrianNetworkColor);
761 }
762 }
763 update();
764}
765
766/****************************************************************************/
long long int SUMOTime
Definition GUI.h:36
@ MID_HOTKEY_SHIFT_O_LOCATEPOI
Locate poi - button.
Definition GUIAppEnum.h:182
@ MID_HOTKEY_SHIFT_A_LOCATEADDITIONAL
Locate additional structure - button.
Definition GUIAppEnum.h:172
@ MID_HOTKEY_SHIFT_C_LOCATECONTAINER
Locate container - button.
Definition GUIAppEnum.h:174
@ MID_HOTKEY_SHIFT_V_LOCATEVEHICLE
Locate vehicle - button.
Definition GUIAppEnum.h:192
@ MID_HOTKEY_SHIFT_L_LOCATEPOLY
Locate polygons - button.
Definition GUIAppEnum.h:180
@ MID_HOTKEY_SHIFT_E_LOCATEEDGE
Locate edge - button.
Definition GUIAppEnum.h:176
@ MID_HOTKEY_SHIFT_P_LOCATEPERSON
Locate person - button.
Definition GUIAppEnum.h:184
@ MID_HOTKEY_SHIFT_J_LOCATEJUNCTION
Locate junction - button.
Definition GUIAppEnum.h:178
@ MID_HOTKEY_SHIFT_T_LOCATETLS
Locate TLS - button.
Definition GUIAppEnum.h:190
GUICompleteSchemeStorage gSchemeStorage
#define GUIDesignButtonPopup
checkable button placed in popup (for example, locate buttons)
Definition GUIDesigns.h:112
unsigned int GUIGlID
Definition GUIGlObject.h:43
GUIGlObjectType
@ GLO_JUNCTION
a junction
@ GLO_LANE
a lane
@ GLO_VEHICLE
a vehicle
GUISelectedStorage gSelected
A global holder of selected objects.
@ LOCATEVEHICLE
@ LOCATEPERSON
@ LOCATECONTAINER
@ LOCATEJUNCTION
std::vector< MSEdge * > MSEdgeVector
Definition MSEdge.h:73
#define TL(string)
Definition MsgHandler.h:315
#define INVALID_ID
SUMOTime DELTA_T
Definition SUMOTime.cpp:38
StringBijection< SUMOVehicleClass > SumoVehicleClassStrings(sumoVehicleClassStringInitializer, SVC_CUSTOM2, false)
long long int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
@ SVC_PEDESTRIAN
pedestrian
@ SUMO_TAG_BUS_STOP
A bus stop.
const double INVALID_DOUBLE
invalid double
Definition StdDefs.h:64
const double SUMO_const_laneWidth
Definition StdDefs.h:48
#define UNUSED_PARAMETER(x)
Definition StdDefs.h:30
T MIN2(T a, T b)
Definition StdDefs.h:76
T MAX2(T a, T b)
Definition StdDefs.h:82
A class that stores a 2D geometrical boundary.
Definition Boundary.h:39
double ymin() const
Returns minimum y-coordinate.
Definition Boundary.cpp:130
double xmin() const
Returns minimum x-coordinate.
Definition Boundary.cpp:118
double ymax() const
Returns maximum y-coordinate.
Definition Boundary.cpp:136
double xmax() const
Returns maximum x-coordinate.
Definition Boundary.cpp:124
static void popMatrix()
pop matrix
Definition GLHelper.cpp:131
static void pushMatrix()
push matrix
Definition GLHelper.cpp:118
A MSVehicle extended by some values for usage within the gui.
void removeActiveAddVisualisation(GUISUMOAbstractView *const parent, int which)
Adds the named visualisation feature to the given view.
void addActiveAddVisualisation(GUISUMOAbstractView *const parent, int which)
Adds the named visualisation feature to the given view.
@ VO_TRACK
track the vehicle (only needed for cleaning up)
@ VO_SHOW_FUTURE_ROUTE
show vehicle's current continued from the current position
bool contains(const std::string &name) const
Returns the information whether a setting with the given name is stored.
GUIVisualizationSettings & get(const std::string &name)
Returns the named scheme.
const std::vector< std::string > & getNames() const
Returns a list of stored settings names.
std::string getCurrentScheme() const
Returns the name of the currently chosen scheme.
void setCurrentScheme(const std::string &)
Sets the named scheme as the current.
A road/street connecting two junctions (gui-version)
Definition GUIEdge.h:51
double getColorValue(const GUIVisualizationSettings &s, int activeScheme) const override
gets the color value according to the current scheme index
Definition GUIEdge.cpp:540
MFXComboBoxIcon * getColoringSchemesCombo()
return combobox with the current coloring schemes (standard, fastest standard, real world....
FXPopup * getLocatorPopup()
@ brief return a pointer to locator popup
static const GUIGlID INVALID_ID
Definition GUIGlObject.h:72
GUIGlID getGlID() const
Returns the numerical id of the object.
void unblockObject(GUIGlID id)
Marks an object as unblocked.
GUIGlObject * getObjectBlocking(GUIGlID id) const
Returns the object from the container locking it.
static GUIGlObjectStorage gIDStorage
A single static instance of this class.
static bool gSecondaryShape
whether secondary shapes are currently being drawn
Definition GUIGlobals.h:49
static FXIcon * getIcon(const GUIIcon which)
returns a icon previously defined in the enum GUIIcon
Representation of a lane in the micro simulation (gui-version)
Definition GUILane.h:60
void setReachability(double value)
Definition GUILane.h:246
double getColorValue(const GUIVisualizationSettings &s, int activeScheme) const override
gets the color value according to the current scheme index
Definition GUILane.cpp:1297
void closeTraffic(bool rebuildAllowed=true)
close this lane for traffic
Definition GUILane.cpp:1584
virtual const std::vector< SUMOTime > retrieveBreakpoints() const
retrieve breakpoints if provided by the application
virtual double getDelay() const
Returns the delay (should be overwritten by subclasses if applicable)
virtual long onCmdFullScreen(FXObject *, FXSelector, void *)
Toggle full screen mode.
bool isGaming() const
return whether the gui is in gaming mode
MFXStaticToolTip * getStaticTooltipMenu() const
get static toolTip for menus
A MSNet extended by some values for usage within the gui.
Definition GUINet.h:82
GUIVehicleControl * getGUIVehicleControl()
Returns the vehicle control.
Definition GUINet.cpp:582
void unlock()
release exclusive access to the simulation state
Definition GUINet.cpp:594
std::vector< std::string > getEdgeDataAttrs() const
return list of loaded edgeData attributes
Definition GUINet.cpp:728
SUMORTree & getVisualisationSpeedUp()
Returns the RTree used for visualisation speed-up.
Definition GUINet.h:285
std::vector< std::string > getMeanDataIDs() const
return list of loaded edgeData ids (being computed in the current simulation)
Definition GUINet.cpp:738
void lock()
grant exclusive access to the simulation state
Definition GUINet.cpp:588
static GUINet * getGUIInstance()
Returns the pointer to the unique instance of GUINet (singleton).
Definition GUINet.cpp:572
std::vector< std::string > getMeanDataAttrs(const std::string &meanDataID) const
return list of available attributes for the given meanData id
Definition GUINet.cpp:749
const std::string & getName() const
int addColor(const T &color, const double threshold, const std::string &name="")
virtual void checkSnapshots()
Checks whether it is time for a snapshot.
void paintGLGrid() const
paints a grid
FXbool makeCurrent()
A reimplementation due to some internal reasons.
void buildMinMaxRainbow(const GUIVisualizationSettings &s, GUIColorScheme &scheme, const GUIVisualizationRainbowSettings &rs, double minValue, double maxValue, bool hasMissingData)
helper function for buildColorRainbow
void addSnapshot(SUMOTime time, const std::string &file, const int w=-1, const int h=-1)
Sets the snapshot time to file map.
GUIGlID getObjectUnderCursor()
returns the id of the front object under the cursor using GL_SELECT
GUIMainWindow * myApp
The application.
double m2p(double meter) const
meter-to-pixels conversion method
GUIVisualizationSettings * myVisualizationSettings
visualization settings
GUIDialog_ViewSettings * myGUIDialogViewSettings
Visualization changer.
std::map< GUIGlObject *, int > myAdditionallyDrawn
List of objects for which GUIGlObject::drawGLAdditional is called.
void drawDecals()
Draws the stored decals.
A single child window which contains a view of the simulation area.
void notifyChanged()
inform the update target of earlier changes
void clear()
Clears the list of selected objects.
void select(GUIGlID id, bool update=true)
Adds the object with the given id.
const std::unordered_set< GUIGlID > & getSelected() const
Returns the set of ids of all selected objects.
Storage for geometrical objects extended by mutexes.
void removeInactivePolygonTypes(std::set< std::string > inactivePolygonTypes)
Remove some polygon types that were deemed as inactive.
void addInactivePolygonTypes(std::set< std::string > inactivePolygonTypes)
Adds new polygon types to the set of inactive ones.
The class responsible for building and deletion of vehicles (gui-version)
void secureVehicles()
lock access to vehicle removal/additions for thread synchronization
void releaseVehicles()
unlock access to vehicle removal/additions for thread synchronization
A MSVehicle extended by some values for usage within the gui.
Definition GUIVehicle.h:51
Position getPosition(const double offset=0) const
Return current position (x/y, cartesian)
Definition GUIVehicle.h:71
void rerouteDRTStop(MSStoppingPlace *busStop)
handle route to accomodate to given stop
A simple video encoder from RGBA pics to anything ffmpeg can handle.
void saveFrame(const std::string &destFile, FXColor *buf) override
Adds a frame to a video snapshot which will be initialized if necessary.
SUMOTime getCurrentTimeStep() const override
get the current simulation time
std::vector< std::string > getVehicleParamKeys(bool vTypeKeys) const override
return list of available vehicle parameters
virtual void buildViewToolBars(GUIGlChildWindow *) override
builds the view toolbars
std::vector< std::string > getMeanDataIDs() const override
return list of loaded edgeData ids (being computed in the current simulation)
virtual ~GUIViewTraffic()
destructor
long onCmdCloseLane(FXObject *, FXSelector, void *) override
interaction with the simulation
std::vector< std::string > getMeanDataAttrs(const std::string &meanDataID) const override
return list of available attributes for the given meanData id
void stopTrack() override
Stops vehicle tracking.
int doPaintGL(int mode, const Boundary &bound) override
paint GL
GUIGlID getTrackedID() const override
Returns the id of the tracked vehicle (-1 if none)
std::vector< std::string > getPOIParamKeys() const override
return list of available POI parameters
long onCmdCloseEdge(FXObject *, FXSelector, void *) override
void onGamingClick(Position pos) override
handle mouse click in gaming mode
void endSnapshot() override
Ends a video snapshot.
long onCmdShowReachability(FXObject *, FXSelector, void *) override
highlight edges according to reachability
void drawPedestrianNetwork(const GUIVisualizationSettings &s) const override
Draw (or not) the JuPedSim pedestrian network.
void checkSnapshots() override
Checks whether it is time for a snapshot.
bool setColorScheme(const std::string &name) override
set color scheme
const std::vector< SUMOTime > retrieveBreakpoints() const override
retrieve breakpoints from the current runThread
GUILane * getLaneUnderCursor() override
returns the GUILane at cursor position (implementation depends on view)
void buildColorRainbow(const GUIVisualizationSettings &s, GUIColorScheme &scheme, int active, GUIGlObjectType objectType, const GUIVisualizationRainbowSettings &rs) override
recalibrate color scheme according to the current value range
void startTrack(int id) override
Starts vehicle tracking.
long onDoubleClicked(FXObject *, FXSelector, void *) override
std::vector< std::string > getEdgeDataAttrs() const override
return list of loaded edgeData attributes
static long showLaneReachability(GUILane *lane, FXObject *, FXSelector)
long onCmdAddRerouter(FXObject *, FXSelector, void *) override
std::vector< std::string > getEdgeLaneParamKeys(bool edgeKeys) const override
return list of available edge parameters
void changePedestrianNetworkColor(const GUIVisualizationSettings &s) const override
Change the color of the JuPedSim pedestrian network.
bool myTLSGame
whether game mode was set to 'tls'
void onGamingRightClick(Position pos) override
Stores the information about how to visualize structures.
bool showPedestrianNetwork
Flag for visualizing the pedestrian network generated for JuPedSim.
std::string name
The name of this setting.
RGBColor pedestrianNetworkColor
The color of the pedestrian network generated for JuPedSim.
bool gaming
whether the application is in gaming mode or not
bool showGrid
Information whether a grid shall be shown.
double scale
information about a lane's width (temporary, used for a single view)
bool secondaryShape
whether secondary lane shape shall be drawn
GUIColorer laneColorer
The lane colorer.
static const std::string SCHEME_NAME_PERMISSION_CODE
long setCurrentItem(const FXint index, FXbool notify=FALSE)
Set the current item (index is zero-based)
FXint getNumItems() const
Return the number of items in the list.
FXint appendIconItem(const FXString &text, FXIcon *icon=nullptr, FXColor bgColor=FXRGB(255, 255, 255), void *ptr=nullptr)
append icon item in the last position
const SUMOVehicleParameter & getParameter() const
Returns the vehicle's parameter (including departure definition)
A road/street connecting two junctions.
Definition MSEdge.h:77
static const MSEdgeVector & getAllEdges()
Returns all edges with a numerical id.
Definition MSEdge.cpp:1086
SVCPermissions getPermissions() const
Returns the combined permissions of all lanes of this edge.
Definition MSEdge.h:649
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
Definition MSEdge.h:168
double getSpeedLimit() const
Returns the speed limit of the edge @caution The speed limit of the first lane is retured; should pro...
Definition MSEdge.cpp:1158
const MSJunction * getToJunction() const
Definition MSEdge.h:418
double getLength() const
return the length of the edge
Definition MSEdge.h:685
const MSEdgeVector & getPredecessors() const
Definition MSEdge.h:409
const MSEdgeVector & getSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges, restricted by vClass.
Definition MSEdge.cpp:1258
static bool gUseMesoSim
Definition MSGlobals.h:106
The base class for an intersection.
Definition MSJunction.h:58
const ConstMSEdgeVector & getIncoming() const
Definition MSJunction.h:108
Representation of a lane in the micro simulation.
Definition MSLane.h:84
virtual const VehCont & getVehiclesSecure() const
Returns the vehicles container; locks it for microsimulation.
Definition MSLane.h:483
virtual void releaseVehicles() const
Allows to use the container for microsimulation again.
Definition MSLane.h:513
MSEdge & getEdge() const
Returns the lane's edge.
Definition MSLane.h:764
const Position geometryPositionAtOffset(double offset, double lateralOffset=0) const
Definition MSLane.h:560
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition MSNet.cpp:186
MSTLLogicControl & getTLSControl()
Returns the tls logics control.
Definition MSNet.h:451
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
Definition MSNet.h:320
bool hasPedestrianNetwork() const
return whether the network contains walkingareas and crossings
Definition MSNet.h:795
ShapeContainer & getShapeContainer()
Returns the shapes container.
Definition MSNet.h:501
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition MSNet.h:378
const NamedObjectCont< MSStoppingPlace * > & getStoppingPlaces(SumoXMLTag category) const
Definition MSNet.cpp:1416
SUMOTime duration
The duration of the phase.
bool isGreenPhase() const
Returns whether this phase is a pure "green" phase.
bool isAllRedPhase() const
Returns whether this phase is an "all red" phase.
A lane area vehicles can halt at.
double getEndLanePosition() const
Returns the end position of this stop.
const MSLane & getLane() const
Returns the lane this stop is located at.
A class that stores and controls tls and switching of their programs.
std::vector< MSTrafficLightLogic * > getAllLogics() const
Returns a vector which contains all logics.
bool isActive(const MSTrafficLightLogic *tl) const
Returns whether the given tls program is the currently active for his tls.
The parent class for traffic light logics.
virtual const MSPhaseDefinition & getCurrentPhaseDef() const =0
Returns the definition of the current phase.
virtual int getPhaseNumber() const =0
Returns the number of phases.
virtual int getCurrentPhaseIndex() const =0
Returns the current index within the program.
std::vector< MSLane * > LaneVector
Definition of the list of arrival lanes subjected to this tls.
virtual void changeStepAndDuration(MSTLLogicControl &tlcontrol, SUMOTime simStep, int step, SUMOTime stepDuration)=0
Changes the current phase and her duration.
virtual const MSPhaseDefinition & getPhase(int givenstep) const =0
Returns the definition of the phase from the given position within the plan.
virtual const Phases & getPhases() const =0
Returns the phases of this tls program.
SUMOTime getSpentDuration(SUMOTime simStep=-1) const
Returns the duration spent in the current phase.
The class responsible for building and deletion of vehicles.
std::map< std::string, SUMOVehicle * >::const_iterator constVehIt
Definition of the internal vehicles map iterator.
constVehIt loadedVehBegin() const
Returns the begin of the internal vehicle map.
constVehIt loadedVehEnd() const
Returns the end of the internal vehicle map.
MSLane * getMutableLane() const
Returns the lane the vehicle is on Non const version indicates that something volatile is going on.
Definition MSVehicle.h:589
IDMap::const_iterator begin() const
Returns a reference to the begin iterator for the internal map.
IDMap::const_iterator end() const
Returns a reference to the end iterator for the internal map.
A storage for options typed value containers)
Definition OptionsCont.h:89
A point in 2D or 3D with translation and scaling methods.
Definition Position.h:37
double distanceTo2D(const Position &p2) const
returns the euclidean distance in the x-y-plane
Definition Position.h:276
double distanceTo(const Position &p2) const
returns the euclidean distance in 3 dimensions
Definition Position.h:266
static RGBColor fromHSV(double h, double s, double v)
Converts the given hsv-triplet to rgb, inspired by http://alvyray.com/Papers/CG/hsv2rgb....
Definition RGBColor.cpp:371
A RT-tree for efficient storing of SUMO's GL-objects.
Definition SUMORTree.h:66
virtual int Search(const float a_min[2], const float a_max[2], const GUIVisualizationSettings &c) const
Find all within search rectangle.
Definition SUMORTree.h:116
std::string line
The vehicle's line (mainly for public transport)
Storage for geometrical objects.
const Polygons & getPolygons() const
Returns all polygons.
struct for default values that depend of VClass
double desiredMaxSpeed
The vehicle type's desired maximum speed [m/s].