Eclipse SUMO - Simulation of Urban MObility
GUIPerson.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-2023 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/****************************************************************************/
20// A MSPerson extended by some values for usage within the gui
21/****************************************************************************/
22#include <config.h>
23
37
38#include "GUILane.h"
39#include "GUIPerson.h"
40
41//#define GUIPerson_DEBUG_DRAW_WALKINGAREA_PATHS 1
42
43// ===========================================================================
44// FOX callback mapping
45// ===========================================================================
46
47FXDEFMAP(GUIPerson::GUIPersonPopupMenu) GUIPersonPopupMenuMap[] = {
56};
57
58// Object implementation
59FXIMPLEMENT(GUIPerson::GUIPersonPopupMenu, GUIGLObjectPopupMenu, GUIPersonPopupMenuMap, ARRAYNUMBER(GUIPersonPopupMenuMap))
60
61// ===========================================================================
62// method definitions
63// ===========================================================================
64
65// -------------------------------------------------------------------------
66// GUIPerson::GUIPersonPopupMenu - methods
67// -------------------------------------------------------------------------
68
71 GUIGLObjectPopupMenu(app, parent, o) {
72}
73
74
76
77
78long
80 assert(myObject->getType() == GLO_PERSON);
81 if (!static_cast<GUIPerson*>(myObject)->hasActiveAddVisualisation(myParent, VO_SHOW_ROUTE)) {
82 static_cast<GUIPerson*>(myObject)->addActiveAddVisualisation(myParent, VO_SHOW_ROUTE);
83 }
84 return 1;
85}
86
87
88long
90 assert(myObject->getType() == GLO_PERSON);
91 static_cast<GUIPerson*>(myObject)->removeActiveAddVisualisation(myParent, VO_SHOW_ROUTE);
92 return 1;
93}
94
95
96long
98 assert(myObject->getType() == GLO_PERSON);
99 if (!static_cast<GUIPerson*>(myObject)->hasActiveAddVisualisation(myParent, VO_SHOW_WALKINGAREA_PATH)) {
100 static_cast<GUIPerson*>(myObject)->addActiveAddVisualisation(myParent, VO_SHOW_WALKINGAREA_PATH);
101 }
102 return 1;
103}
104
105
106long
108 assert(myObject->getType() == GLO_PERSON);
109 static_cast<GUIPerson*>(myObject)->removeActiveAddVisualisation(myParent, VO_SHOW_WALKINGAREA_PATH);
110 return 1;
111}
112
113
114long
115GUIPerson::GUIPersonPopupMenu::onCmdShowPlan(FXObject*, FXSelector, void*) {
116 GUIPerson* p = dynamic_cast<GUIPerson*>(myObject);
117 if (p == nullptr) {
118 return 1;
119 }
120 GUIParameterTableWindow* ret = new GUIParameterTableWindow(*myApplication, *p);
121 // add items
122 for (int stage = 1; stage < p->getNumStages(); stage++) {
123 ret->mkItem(toString(stage).c_str(), false, p->getStageSummary(stage));
124 }
125 // close building (use an object that is not Parameterised as argument)
126 Parameterised dummyParameterised;
127 ret->closeBuilding(&dummyParameterised);
128 return 1;
129}
130
131
132long
134 assert(myObject->getType() == GLO_PERSON);
135 if (myParent->getTrackedID() != static_cast<GUIPerson*>(myObject)->getGlID()) {
136 myParent->startTrack(static_cast<GUIPerson*>(myObject)->getGlID());
137 }
138 return 1;
139}
140
141
142long
144 assert(myObject->getType() == GLO_PERSON);
145 myParent->stopTrack();
146 return 1;
147}
148
149
150long
152 GUIPerson* person = static_cast<GUIPerson*>(myObject);
153 MSStage* stage = person->getCurrentStage();
154 stage->abort(person);
155 stage->getEdge()->removeTransportable(person);
156 if (stage->getDestinationStop() != nullptr) {
157 stage->getDestinationStop()->removeTransportable(person);
158 }
160 myParent->update();
161 return 1;
162}
163
164// -------------------------------------------------------------------------
165// GUIPerson - methods
166// -------------------------------------------------------------------------
167
169 MSPerson(pars, vtype, plan, speedFactor),
170 GUIGlObject(GLO_PERSON, pars->id, GUIIconSubSys::getIcon(GUIIcon::PERSON)),
171 myLock(true)
172{ }
173
174
176 myLock.lock();
177 for (std::map<GUISUMOAbstractView*, int>::iterator i = myAdditionalVisualizations.begin(); i != myAdditionalVisualizations.end(); ++i) {
178 if (i->first->getTrackedID() == getGlID()) {
179 i->first->stopTrack();
180 }
181 while (i->first->removeAdditionalGLVisualisation(this));
182 }
183 myLock.unlock();
184}
185
186
189 GUIGLObjectPopupMenu* ret = new GUIPersonPopupMenu(app, parent, *this);
190 buildPopupHeader(ret, app);
195 GUIDesigns::buildFXMenuCommand(ret, "Hide Current Route", nullptr, ret, MID_HIDE_CURRENTROUTE);
196 } else {
197 GUIDesigns::buildFXMenuCommand(ret, "Show Current Route", nullptr, ret, MID_SHOW_CURRENTROUTE);
198 }
200 GUIDesigns::buildFXMenuCommand(ret, "Hide Walkingarea Path", nullptr, ret, MID_HIDE_WALKINGAREA_PATH);
201 } else {
202 GUIDesigns::buildFXMenuCommand(ret, "Show Walkingarea Path", nullptr, ret, MID_SHOW_WALKINGAREA_PATH);
203 }
204 new FXMenuSeparator(ret);
205 if (parent.getTrackedID() != getGlID()) {
206 GUIDesigns::buildFXMenuCommand(ret, "Start Tracking", nullptr, ret, MID_START_TRACK);
207 } else {
208 GUIDesigns::buildFXMenuCommand(ret, "Stop Tracking", nullptr, ret, MID_STOP_TRACK);
209 }
210 GUIDesigns::buildFXMenuCommand(ret, "Remove", nullptr, ret, MID_REMOVE_OBJECT);
211 new FXMenuSeparator(ret);
212 //
216 new FXMenuSeparator(ret);
217 buildPositionCopyEntry(ret, app);
218 return ret;
219}
220
221
226 // add items
228 // there is always the "start" stage which we do not count here because it is not strictly part of the plan
230 ret->mkItem("start edge [id]", true, new FunctionBindingString<GUIPerson>(this, &GUIPerson::getFromEdgeID));
231 ret->mkItem("dest edge [id]", true, new FunctionBindingString<GUIPerson>(this, &GUIPerson::getDestinationEdgeID));
232 ret->mkItem("dest stop [id]", true, new FunctionBindingString<GUIPerson>(this, &GUIPerson::getDestinationStopID));
233 ret->mkItem("arrivalPos [m]", true, new FunctionBinding<GUIPerson, double>(this, &GUIPerson::getStageArrivalPos));
234 ret->mkItem("edge [id]", true, new FunctionBindingString<GUIPerson>(this, &GUIPerson::getEdgeID));
235 ret->mkItem("position [m]", true, new FunctionBinding<GUIPerson, double>(this, &GUIPerson::getEdgePos));
236 ret->mkItem("speed [m/s]", true, new FunctionBinding<GUIPerson, double>(this, &GUIPerson::getSpeed));
237 ret->mkItem("speed factor", false, getChosenSpeedFactor());
238 ret->mkItem("angle [degree]", true, new FunctionBinding<GUIPerson, double>(this, &GUIPerson::getNaviDegree));
239 ret->mkItem("waiting time [s]", true, new FunctionBinding<GUIPerson, double>(this, &GUIPerson::getWaitingSeconds));
240 ret->mkItem("vehicle [id]", true, new FunctionBindingString<GUIPerson>(this, &GUIPerson::getVehicleID));
241 ret->mkItem("stop duration [s]", true, new FunctionBinding<GUIPerson, double>(this, &GUIPerson::getStopDuration));
242 ret->mkItem("desired depart [s]", false, time2string(getParameter().depart));
243 // close building
245 return ret;
246}
247
248
251 GUIParameterTableWindow* ret = new GUIParameterTableWindow(app, *this, "vType:" + myVType->getID());
252 ret->mkItem("length", false, myVType->getLength());
253 ret->mkItem("width", false, myVType->getWidth());
254 ret->mkItem("height", false, myVType->getHeight());
255 ret->mkItem("minGap", false, myVType->getMinGap());
256 ret->mkItem("mass [kg]", false, myVType->getMass());
257 ret->mkItem("desired max speed [m/s]", false, myVType->getDesiredMaxSpeed());
258 ret->mkItem("maximum speed [m/s]", false, myVType->getMaxSpeed());
260 return ret;
261}
262
263
264double
266 return s.personSize.getExaggeration(s, this, s.personQuality == 1 ? 40 : 80);
267}
268
269
272 Boundary b;
273 // ensure that the vehicle is drawn, otherwise myPositionInVehicle will not be updated
274 b.add(getGUIPosition());
275 b.grow(MAX2(getVehicleType().getWidth(), getVehicleType().getLength()));
276 return b;
277}
278
279
280void
284 Position p1 = getGUIPosition(&s);
285 double angle = getGUIAngle();
286 glTranslated(p1.x(), p1.y(), getType());
287 // set person color
288 setColor(s);
289 // scale
290 const double exaggeration = getExaggeration(s);
291 glScaled(exaggeration, exaggeration, 1);
292 switch (s.personQuality) {
293 case 0:
295 break;
296 case 1:
297 GUIBasePersonHelper::drawAction_drawAsCircle(angle, getVehicleType().getLength(), getVehicleType().getWidth(), s.scale * exaggeration);
298 break;
299 case 2:
301 break;
302 case 3:
303 default:
305 getVehicleType().getImgFile(), getVehicleType().getGuiShape(), 1);
306 break;
307 }
309#ifdef GUIPerson_DEBUG_DRAW_WALKINGAREA_PATHS
311#endif
312 drawName(p1, s.scale, s.personName, s.angle);
313 if (s.personValue.show(this)) {
314 Position p2 = p1 + Position(0, 0.6 * s.personName.scaledSize(s.scale));
315 const double value = getColorValue(s, s.personColorer.getActive());
317 }
319}
320
321
322void
325 if (stage != nullptr) {
326 setColor(s);
327 MSPModel_Striping::PState* stripingState = dynamic_cast<MSPModel_Striping::PState*>(stage->getState());
328 if (stripingState != nullptr) {
329 const MSPModel_Striping::WalkingAreaPath* waPath = stripingState->myWalkingAreaPath;
330 if (waPath != nullptr) {
332 glTranslated(0, 0, getType());
333 GLHelper::drawBoxLines(waPath->shape, 0.05);
335 }
336 }
337 }
338}
339
340void
344 glTranslated(0, 0, getType() - .1); // don't draw on top of other cars
347 }
350 setColor(s);
351 RGBColor current = GLHelper::getColor();
352 RGBColor darker = current.changedBrightness(-51);
353 GLHelper::setColor(darker);
355 assert(stage != 0);
356 const double exaggeration = getExaggeration(s);
357 const ConstMSEdgeVector& edges = stage->getRoute();
358 const bool s2 = s.secondaryShape;
359 for (ConstMSEdgeVector::const_iterator it = edges.begin(); it != edges.end(); ++it) {
360 GUILane* lane = static_cast<GUILane*>((*it)->getLanes()[0]);
361 GLHelper::drawBoxLines(lane->getShape(s2), lane->getShapeRotations(s2), lane->getShapeLengths(s2), exaggeration);
362 }
363 }
364 }
367}
368
369
370void
373}
374
375
376void
378 RGBColor col;
379 const GUIColorer& c = s.personColorer;
380 if (!setFunctionalColor(c.getActive(), this, col)) {
381 col = c.getScheme().getColor(getColorValue(s, c.getActive()));
382 }
384}
385
386
387bool
388GUIPerson::setFunctionalColor(int activeScheme, const MSPerson* person, RGBColor& col) {
389 switch (activeScheme) {
390 case 0: {
391 if (person->getParameter().wasSet(VEHPARS_COLOR_SET)) {
392 col = person->getParameter().color;
393 return true;
394 }
396 col = person->getVehicleType().getColor();
397 return true;
398 }
399 return false;
400 }
401 case 2: {
402 if (person->getParameter().wasSet(VEHPARS_COLOR_SET)) {
403 col = person->getParameter().color;
404 return true;
405 }
406 return false;
407 }
408 case 3: {
410 col = person->getVehicleType().getColor();
411 return true;
412 }
413 return false;
414 }
415 case 9: { // color by angle
416 double hue = GeomHelper::naviDegree(person->getAngle());
417 col = RGBColor::fromHSV(hue, 1., 1.);
418 return true;
419 }
420 case 10: { // color randomly (by pointer)
421 const double hue = (double)((long long int)person % 360); // [0-360]
422 const double sat = (double)(((long long int)person / 360) % 67) / 100. + 0.33; // [0.33-1]
423 col = RGBColor::fromHSV(hue, sat, 1.);
424 return true;
425 }
426 default:
427 return false;
428 }
429}
430
431
432double
433GUIPerson::getColorValue(const GUIVisualizationSettings& /* s */, int activeScheme) const {
434 switch (activeScheme) {
435 case 4:
436 switch (getCurrentStageType()) {
438 return -1;
440 return -2;
441 default:
442 return getSpeed();
443 }
444 case 5:
445 if (isWaiting4Vehicle()) {
446 return 5;
447 } else {
448 return (double)getCurrentStageType();
449 }
450 case 6:
451 return getWaitingSeconds();
452 case 7:
453 return isJammed() ? 1 : 0;
454 case 8:
456 }
457 return 0;
458}
459
460
461double
463 FXMutexLock locker(myLock);
464 if (hasArrived()) {
465 return -1;
466 }
467 return MSPerson::getEdgePos();
468}
469
470int
472 FXMutexLock locker(myLock);
473 if (hasArrived()) {
475 }
476 return MSPerson::getDirection();
477}
478
479
482 FXMutexLock locker(myLock);
483 if (hasArrived()) {
484 return Position::INVALID;
485 }
486 return MSPerson::getPosition();
487}
488
489
492 FXMutexLock locker(myLock);
493 if (hasArrived()) {
494 return Position::INVALID;
495 }
499 } else if (isWaiting4Vehicle()
500 && s != nullptr
501 && s->gaming
502 && getCurrentStage()->getOriginStop() != nullptr
503 && s->addSize.getExaggeration(*s, nullptr) > 1) {
504 // shift position away from stop center
507 Position shifted = ref + (pos - ref) * s->personSize.getExaggeration(*s, this);
508 return shifted;
509 }
510 }
511 return MSPerson::getPosition();
512}
513
514
515double
517 FXMutexLock locker(myLock);
518 if (hasArrived()) {
519 return INVALID_DOUBLE;
520 }
523 } else {
524 return MSPerson::getAngle();
525 }
526}
527
528
529double
531 FXMutexLock locker(myLock);
532 if (hasArrived()) {
533 return INVALID_DOUBLE;
534 }
536}
537
538
539double
541 FXMutexLock locker(myLock);
542 if (hasArrived()) {
543 return -1;
544 }
546}
547
548
549double
551 FXMutexLock locker(myLock);
552 if (hasArrived()) {
553 return -1;
554 }
555 return MSPerson::getSpeed();
556}
557
558
559std::string
561 FXMutexLock locker(myLock);
562 if (hasArrived()) {
563 return "arrived";
564 }
565 return toString(getNumStages() - getNumRemainingStages()) + " of " + toString(getNumStages() - 1);
566}
567
568
569std::string
571 FXMutexLock locker(myLock);
572 if (hasArrived()) {
573 return "arrived";
574 }
575 return getEdge()->getID();
576}
577
578
579std::string
581 FXMutexLock locker(myLock);
582 if (hasArrived()) {
583 return "arrived";
584 }
585 return getFromEdge()->getID();
586}
587
588
589std::string
591 FXMutexLock locker(myLock);
592 if (hasArrived()) {
593 return "arrived";
594 }
595 return getDestination()->getID();
596}
597
598
599std::string
601 FXMutexLock locker(myLock);
602 if (hasArrived()) {
603 return "";
604 }
606 if (destStop != nullptr) {
607 return destStop->getID();
608 } else {
609 return "";
610 }
611}
612
613
614std::string
616 FXMutexLock locker(myLock);
617 if (hasArrived()) {
618 return "";
619 }
621 if (veh != nullptr) {
622 return veh->getID();
623 } else {
624 return "";
625 }
626}
627
628
629double
631 FXMutexLock locker(myLock);
632 if (hasArrived()) {
633 return -1;
634 }
636 return STEPS2TIME(dynamic_cast<MSStageWaiting*>(getCurrentStage())->getStopEnd() - SIMSTEP);
637 } else {
638 return -1;
639 }
640}
641
642
643double
645 FXMutexLock locker(myLock);
646 if (hasArrived()) {
647 return INVALID_DOUBLE;
648 }
649 return getCurrentStage()->getArrivalPos();
650}
651
652bool
653GUIPerson::proceed(MSNet* net, SUMOTime time, const bool vehicleArrived) {
654 // acquire lock before locking the person to avoid mutual deadlock (#9468)
656 FXMutexLock locker(myLock);
657 return MSTransportable::proceed(net, time, vehicleArrived);
658}
659
660// -------------------------------------------------------------------------
661// GUIPerson - Additional Visualsation methods
662// -------------------------------------------------------------------------
663
664bool
666 return myAdditionalVisualizations.find(parent) != myAdditionalVisualizations.end() && (myAdditionalVisualizations.find(parent)->second & which) != 0;
667}
668
669
670void
672 if (myAdditionalVisualizations.find(parent) == myAdditionalVisualizations.end()) {
673 myAdditionalVisualizations[parent] = 0;
674 }
675 myAdditionalVisualizations[parent] |= which;
676 parent->addAdditionalGLVisualisation(this);
677}
678
679
680void
682 myAdditionalVisualizations[parent] &= ~which;
684}
685
686bool
689}
690
691
692/****************************************************************************/
long long int SUMOTime
Definition: GUI.h:36
@ MID_HIDE_CURRENTROUTE
Hide vehicle's current route.
Definition: GUIAppEnum.h:488
@ MID_SHOWPLAN
Show transportable plan.
Definition: GUIAppEnum.h:468
@ MID_HIDE_WALKINGAREA_PATH
Hide persons's path on walkingarea.
Definition: GUIAppEnum.h:522
@ MID_SHOW_WALKINGAREA_PATH
Show persons's path on walkingarea.
Definition: GUIAppEnum.h:520
@ MID_START_TRACK
Start to track a vehicle.
Definition: GUIAppEnum.h:506
@ MID_REMOVE_OBJECT
remove a vehicle or person
Definition: GUIAppEnum.h:518
@ MID_SHOW_CURRENTROUTE
Show vehicle's current route.
Definition: GUIAppEnum.h:486
@ MID_STOP_TRACK
Stop to track a vehicle.
Definition: GUIAppEnum.h:508
@ GLO_MAX
empty max
@ GLO_PERSON
a person
GUISelectedStorage gSelected
A global holder of selected objects.
GUIIcon
An enumeration of icons used by the gui applications.
Definition: GUIIcons.h:33
FXDEFMAP(GUIPerson::GUIPersonPopupMenu) GUIPersonPopupMenuMap[]
std::vector< const MSEdge * > ConstMSEdgeVector
Definition: MSEdge.h:74
std::string time2string(SUMOTime t, bool humanReadable)
convert SUMOTime to string (independently of global format setting)
Definition: SUMOTime.cpp:69
#define STEPS2TIME(x)
Definition: SUMOTime.h:55
#define SIMSTEP
Definition: SUMOTime.h:61
const long long int VTYPEPARS_COLOR_SET
const int VEHPARS_COLOR_SET
const double INVALID_DOUBLE
invalid double
Definition: StdDefs.h:64
T MAX2(T a, T b)
Definition: StdDefs.h:82
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:39
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
Definition: Boundary.cpp:78
Boundary & grow(double by)
extends the boundary by the given amount
Definition: Boundary.cpp:300
static void setColor(const RGBColor &c)
Sets the gl-color to this value.
Definition: GLHelper.cpp:583
static void pushName(unsigned int name)
push Name
Definition: GLHelper.cpp:139
static void popMatrix()
pop matrix
Definition: GLHelper.cpp:130
static void drawBoxLines(const PositionVector &geom, const std::vector< double > &rots, const std::vector< double > &lengths, double width, int cornerDetail=0, double offset=0)
Draws thick lines.
Definition: GLHelper.cpp:329
static RGBColor getColor()
gets the gl-color
Definition: GLHelper.cpp:589
static void popName()
pop Name
Definition: GLHelper.cpp:148
static void pushMatrix()
push matrix
Definition: GLHelper.cpp:117
static void drawTextSettings(const GUIVisualizationTextSettings &settings, const std::string &text, const Position &pos, const double scale, const double angle=0, const double layer=2048, const int align=0)
Definition: GLHelper.cpp:716
static void drawAction_drawAsPoly(const double angle, const double length, const double width)
static void drawAction_drawAsImage(const double angle, const double length, const double width, const std::string &file, const SUMOVehicleShape guiShape, const double exaggeration)
static void drawAction_drawAsCircle(const double angle, const double length, const double width, double detail)
static void drawAction_drawAsTriangle(const double angle, const double length, const double width)
static FXMenuCommand * buildFXMenuCommand(FXComposite *p, const std::string &text, FXIcon *icon, FXObject *tgt, FXSelector sel)
build menu command
Definition: GUIDesigns.cpp:42
The popup menu of a globject.
void buildShowTypeParamsPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to open the type parameter window.
void buildShowParamsPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to open the parameter window.
void buildCenterPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to center to the object.
void buildNameCopyPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds entries which allow to copy the name / typed name into the clipboard.
void buildPopupHeader(GUIGLObjectPopupMenu *ret, GUIMainWindow &app, bool addSeparator=true)
Builds the header.
GUIGlObjectType getType() const
Returns the type of the object as coded in GUIGlObjectType.
Definition: GUIGlObject.h:154
void buildSelectionPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to (de)select the object.
void buildPositionCopyEntry(GUIGLObjectPopupMenu *ret, const GUIMainWindow &app) const
Builds an entry which allows to copy the cursor position if geo projection is used,...
GUIGlID getGlID() const
Returns the numerical id of the object.
Definition: GUIGlObject.h:102
void drawName(const Position &pos, const double scale, const GUIVisualizationTextSettings &settings, const double angle=0, bool forceShow=false) const
draw name of item
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
const std::vector< double > & getShapeRotations(bool secondary) const
Definition: GUILane.cpp:1066
const PositionVector & getShape(bool secondary) const override
Definition: GUILane.cpp:1060
const std::vector< double > & getShapeLengths(bool secondary) const
Definition: GUILane.cpp:1072
A window containing a gl-object's parameter.
void mkItem(const char *name, bool dynamic, ValueSource< T > *src)
Adds a row which obtains its value from a ValueSource.
void closeBuilding(const Parameterised *p=0)
Closes the building of the table.
long onCmdStartTrack(FXObject *, FXSelector, void *)
Called if the person shall be tracked.
Definition: GUIPerson.cpp:133
long onCmdShowPlan(FXObject *, FXSelector, void *)
Called if the plan shall be shown.
Definition: GUIPerson.cpp:115
long onCmdRemoveObject(FXObject *, FXSelector, void *)
Called when removing the person.
Definition: GUIPerson.cpp:151
long onCmdHideCurrentRoute(FXObject *, FXSelector, void *)
Called if the current route of the person shall be hidden.
Definition: GUIPerson.cpp:89
long onCmdHideWalkingareaPath(FXObject *, FXSelector, void *)
Called if the walkingarea path of the person shall be hidden.
Definition: GUIPerson.cpp:107
~GUIPersonPopupMenu()
Destructor.
Definition: GUIPerson.cpp:75
long onCmdStopTrack(FXObject *, FXSelector, void *)
Called if the person shall not be tracked any longer.
Definition: GUIPerson.cpp:143
long onCmdShowCurrentRoute(FXObject *, FXSelector, void *)
Called if the current route of the person shall be shown.
Definition: GUIPerson.cpp:79
long onCmdShowWalkingareaPath(FXObject *, FXSelector, void *)
Called if the walkingarea path of the person shall be shown.
Definition: GUIPerson.cpp:97
void setColor(const GUIVisualizationSettings &s) const
sets the color according to the currente settings
Definition: GUIPerson.cpp:377
void drawAction_drawWalkingareaPath(const GUIVisualizationSettings &s) const
draw walking area path
Definition: GUIPerson.cpp:323
bool proceed(MSNet *net, SUMOTime time, const bool vehicleArrived=false) override
Definition: GUIPerson.cpp:653
double getExaggeration(const GUIVisualizationSettings &s) const override
return exaggeration associated with this GLObject
Definition: GUIPerson.cpp:265
std::string getDestinationStopID() const
get destination stop ID
Definition: GUIPerson.cpp:600
std::string getDestinationEdgeID() const
get destination edge ID
Definition: GUIPerson.cpp:590
std::string getStageIndexDescription() const
get stage index description
Definition: GUIPerson.cpp:560
Position getPosition() const override
return the Network coordinate of the person
Definition: GUIPerson.cpp:481
virtual void drawGLAdditional(GUISUMOAbstractView *const parent, const GUIVisualizationSettings &s) const override
Draws additionally triggered visualisations.
Definition: GUIPerson.cpp:341
GUIGLObjectPopupMenu * getPopUpMenu(GUIMainWindow &app, GUISUMOAbstractView &parent) override
Returns an own popup-menu.
Definition: GUIPerson.cpp:188
double getColorValue(const GUIVisualizationSettings &s, int activeScheme) const override
gets the color value according to the current scheme index
Definition: GUIPerson.cpp:433
~GUIPerson()
destructor
Definition: GUIPerson.cpp:175
double getGUIAngle() const
return the angle of the person (only for drawing centering and tracking)
Definition: GUIPerson.cpp:516
Boundary getCenteringBoundary() const override
Returns the boundary to which the view shall be centered in order to show the object.
Definition: GUIPerson.cpp:271
bool isSelected() const override
whether this person is selected in the GUI
Definition: GUIPerson.cpp:687
Position getGUIPosition(const GUIVisualizationSettings *s=nullptr) const
return the Network coordinate of the person (only for drawing centering and tracking)
Definition: GUIPerson.cpp:491
double getStopDuration() const
get remaining duration of current stop or -1
Definition: GUIPerson.cpp:630
GUIBaseVehicle::Seat myPositionInVehicle
The position of a person while riding a vehicle.
Definition: GUIPerson.h:277
std::map< GUISUMOAbstractView *, int > myAdditionalVisualizations
Enabled visualisations, per view.
Definition: GUIPerson.h:280
@ VO_SHOW_WALKINGAREA_PATH
show the current walkingarea path
Definition: GUIPerson.h:234
@ VO_SHOW_ROUTE
show persons's current route
Definition: GUIPerson.h:236
double getEdgePos() const override
Return the position on the edge.
Definition: GUIPerson.cpp:462
double getSpeed() const override
the current speed of the person
Definition: GUIPerson.cpp:550
double getNaviDegree() const
return the current angle of the person
Definition: GUIPerson.cpp:530
std::string getVehicleID() const
get current vehicle id if applicable
Definition: GUIPerson.cpp:615
GUIPerson(const SUMOVehicleParameter *pars, MSVehicleType *vtype, MSTransportable::MSTransportablePlan *plan, const double speedFactor)
Constructor.
Definition: GUIPerson.cpp:168
std::string getEdgeID() const
get edge ID
Definition: GUIPerson.cpp:570
bool hasActiveAddVisualisation(GUISUMOAbstractView *const parent, int which) const
Returns whether the named feature is enabled in the given view.
Definition: GUIPerson.cpp:665
double getWaitingSeconds() const override
the time this person spent waiting in seconds
Definition: GUIPerson.cpp:540
void setPositionInVehicle(const GUIBaseVehicle::Seat &pos)
Definition: GUIPerson.cpp:371
void removeActiveAddVisualisation(GUISUMOAbstractView *const parent, int which) override
Adds the named visualisation feature to the given view.
Definition: GUIPerson.cpp:681
GUIParameterTableWindow * getParameterWindow(GUIMainWindow &app, GUISUMOAbstractView &parent) override
Returns an own parameter window.
Definition: GUIPerson.cpp:223
FXMutex myLock
The mutex used to avoid concurrent updates of the vehicle buffer.
Definition: GUIPerson.h:274
int getDirection() const override
Return the movement directon on the edge.
Definition: GUIPerson.cpp:471
std::string getFromEdgeID() const
ger from edge ID
Definition: GUIPerson.cpp:580
double getStageArrivalPos() const
get stage arrival position
Definition: GUIPerson.cpp:644
static bool setFunctionalColor(int activeScheme, const MSPerson *person, RGBColor &col)
sets the color according to the current scheme index and some vehicle function
Definition: GUIPerson.cpp:388
GUIParameterTableWindow * getTypeParameterWindow(GUIMainWindow &app, GUISUMOAbstractView &parent) override
Returns an own type parameter window.
Definition: GUIPerson.cpp:250
void addActiveAddVisualisation(GUISUMOAbstractView *const parent, int which)
Adds the named visualisation feature to the given view.
Definition: GUIPerson.cpp:671
void drawGL(const GUIVisualizationSettings &s) const override
Draws the object.
Definition: GUIPerson.cpp:281
T getColor(const double value) const
bool removeAdditionalGLVisualisation(GUIGlObject *const which)
Removes an object from the list of objects that show additional things.
bool addAdditionalGLVisualisation(GUIGlObject *const which)
Adds an object to call its additional visualisation method.
virtual GUIGlID getTrackedID() const
get tracked id
bool isSelected(GUIGlObjectType type, GUIGlID id)
Returns the information whether the object with the given type and id is selected.
Stores the information about how to visualize structures.
GUIVisualizationTextSettings personValue
GUIVisualizationSizeSettings addSize
int personQuality
The quality of person drawing.
bool gaming
whether the application is in gaming mode or not
GUIVisualizationSizeSettings personSize
GUIColorer personColorer
The person colorer.
double scale
information about a lane's width (temporary, used for a single view)
bool secondaryShape
whether secondary lane shape shall be drawn
GUIVisualizationTextSettings personName
double angle
The current view rotation angle.
static double naviDegree(const double angle)
Definition: GeomHelper.cpp:192
virtual void removeTransportable(MSTransportable *t) const
Definition: MSEdge.cpp:1095
The simulated network and simulation perfomer.
Definition: MSNet.h:88
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:183
virtual MSTransportableControl & getPersonControl()
Returns the person control.
Definition: MSNet.cpp:1172
Container for pedestrian state and individual position update function.
const WalkingAreaPath * myWalkingAreaPath
the current walkingAreaPath or 0
static const int UNDEFINED_DIRECTION
Definition: MSPModel.h:121
double getChosenSpeedFactor() const
the current speed factor of the transportable (where applicable)
Definition: MSPerson.h:267
bool isJammed() const
whether the person is jammed as defined by the current pedestrian model
Definition: MSPerson.cpp:163
virtual double getArrivalPos() const
Definition: MSStage.h:89
virtual MSStoppingPlace * getOriginStop() const
returns the origin stop (if any). only needed for MSStageTrip
Definition: MSStage.h:85
MSStoppingPlace * getDestinationStop() const
returns the destination stop (if any)
Definition: MSStage.h:80
virtual SUMOVehicle * getVehicle() const
Current vehicle in which the transportable is driving (or nullptr)
Definition: MSStage.h:162
virtual void abort(MSTransportable *)
abort this stage (TraCI)
Definition: MSStage.h:136
virtual const MSEdge * getEdge() const
Returns the current edge.
Definition: MSStage.cpp:67
const std::vector< const MSEdge * > & getRoute() const
virtual MSTransportableStateAdapter * getState() const
Definition: MSStageMoving.h:49
A lane area vehicles can halt at.
Position getCenterPos() const
the position in the middle of the stop shape
void removeTransportable(const MSTransportable *p)
Removes a transportable from this stop.
virtual void erase(MSTransportable *transportable)
removes a single transportable
const MSEdge * getFromEdge() const
Returns the departure edge.
virtual double getEdgePos() const
Return the position on the edge.
std::string getCurrentStageDescription() const
Returns the current stage description as a string.
const MSEdge * getDestination() const
Returns the current destination.
virtual double getAngle() const
return the current angle of the transportable
MSStageType getStageType(int next) const
the stage type for the nth next stage
bool isWaiting4Vehicle() const
Whether the transportable waits for a vehicle.
int getNumRemainingStages() const
Return the number of remaining stages (including the current)
virtual double getSpeed() const
the current speed of the transportable
std::string getStageSummary(int stageIndex) const
return textual summary for the given stage
MSStage * getCurrentStage() const
Return the current stage.
virtual bool proceed(MSNet *net, SUMOTime time, const bool vehicleArrived=false)
MSVehicleType * myVType
This transportable's type. (mainly used for drawing related information Note sure if it is really nec...
virtual Position getPosition() const
Return the Network coordinate of the transportable.
const MSVehicleType & getVehicleType() const
Returns the object's "vehicle" type.
int getNumStages() const
Return the total number stages in this persons plan.
MSStageType getCurrentStageType() const
the current stage type of the transportable
virtual double getWaitingSeconds() const
the time this transportable spent waiting in seconds
bool hasArrived() const
return whether the person has reached the end of its plan
const MSEdge * getEdge() const
Returns the current edge.
virtual int getDirection() const
Return the movement directon on the edge.
std::vector< MSStage * > MSTransportablePlan
the structure holding the plan of a transportable
const SUMOVehicleParameter & getParameter() const
Returns the vehicle's parameter (including departure definition)
The car-following model and parameter.
Definition: MSVehicleType.h:63
double getWidth() const
Get the width which vehicles of this class shall have when being drawn.
double getMaxSpeed() const
Get vehicle's (technical) maximum speed [m/s].
double getDesiredMaxSpeed() const
Returns the vehicles's desired maximum speed.
const std::string & getID() const
Returns the name of the vehicle type.
Definition: MSVehicleType.h:91
double getMinGap() const
Get the free space in front of vehicles of this class.
double getHeight() const
Get the height which vehicles of this class shall have when being drawn.
double getLength() const
Get vehicle's length [m].
bool wasSet(int what) const
Returns whether the given parameter was set.
Definition: MSVehicleType.h:80
double getMass() const
Get this vehicle type's mass.
const SUMOVTypeParameter & getParameter() const
const RGBColor & getColor() const
Returns this type's color.
const std::string & getID() const
Returns the id.
Definition: Named.h:74
An upper class for objects with additional parameters.
Definition: Parameterised.h:41
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
static const Position INVALID
used to indicate that a position is valid
Definition: Position.h:300
double x() const
Returns the x-position.
Definition: Position.h:55
double y() const
Returns the y-position.
Definition: Position.h:60
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
RGBColor changedBrightness(int change, int toChange=3) const
Returns a new color with altered brightness.
Definition: RGBColor.cpp:200
Representation of a vehicle.
Definition: SUMOVehicle.h:62
Structure representing possible vehicle parameter.
RGBColor color
The vehicle's color, TraCI may change this.
bool wasSet(int what) const
Returns whether the given parameter was set.
A scoped lock which only triggers on condition.
Definition: ScopedLocker.h:40
double getExaggeration(const GUIVisualizationSettings &s, const GUIGlObject *o, double factor=20) const
return the drawing size including exaggeration and constantSize values
bool show(const GUIGlObject *o) const
whether to show the text
double scaledSize(double scale, double constFactor=0.1) const
get scale size