Eclipse SUMO - Simulation of Urban MObility
GUIContainer.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/****************************************************************************/
19// A MSContainer extended by some values for usage within the gui
20/****************************************************************************/
21#include <config.h>
22
23#include <cmath>
24#include <vector>
25#include <string>
28#include <microsim/MSLane.h>
44#include <gui/GUIGlobals.h>
47
48#include "GUIContainer.h"
49#include "GUINet.h"
50#include "GUIEdge.h"
51
52//#define GUIContainer_DEBUG_DRAW_WALKING_AREA_SHAPE
53
54// ===========================================================================
55// FOX callback mapping
56// ===========================================================================
57FXDEFMAP(GUIContainer::GUIContainerPopupMenu) GUIContainerPopupMenuMap[] = {
61};
62
63// Object implementation
64FXIMPLEMENT(GUIContainer::GUIContainerPopupMenu, GUIGLObjectPopupMenu, GUIContainerPopupMenuMap, ARRAYNUMBER(GUIContainerPopupMenuMap))
65
66#define WATER_WAY_OFFSET 6.0
67
68// ===========================================================================
69// method definitions
70// ===========================================================================
71/* -------------------------------------------------------------------------
72 * GUIContainer::GUIContainerPopupMenu - methods
73 * ----------------------------------------------------------------------- */
76 : GUIGLObjectPopupMenu(app, parent, o) {
77}
78
79
81
82
83long
85 GUIContainer* p = dynamic_cast<GUIContainer*>(myObject);
86 if (p == nullptr) {
87 return 1;
88 }
89 GUIParameterTableWindow* ret = new GUIParameterTableWindow(*myApplication, *p);
90 // add items
91 for (int stage = 1; stage < p->getNumStages(); stage++) {
92 ret->mkItem(toString(stage).c_str(), false, p->getStageSummary(stage));
93 }
94 // close building (use an object that is not Parameterised as argument)
95 Parameterised dummy;
96 ret->closeBuilding(&dummy);
97 return 1;
98}
99
100
101long
103 assert(myObject->getType() == GLO_PERSON);
104 if (myParent->getTrackedID() != static_cast<GUIContainer*>(myObject)->getGlID()) {
105 myParent->startTrack(static_cast<GUIContainer*>(myObject)->getGlID());
106 }
107 return 1;
108}
109
110long
112 assert(myObject->getType() == GLO_PERSON);
113 myParent->stopTrack();
114 return 1;
115}
116
117
118
119
120/* -------------------------------------------------------------------------
121 * GUIContainer - methods
122 * ----------------------------------------------------------------------- */
124 MSTransportable(pars, vtype, plan, false),
126}
127
128
130}
131
132
135 GUISUMOAbstractView& parent) {
136 GUIGLObjectPopupMenu* ret = new GUIContainerPopupMenu(app, parent, *this);
137 buildPopupHeader(ret, app);
141 new FXMenuSeparator(ret);
142 if (parent.getTrackedID() != getGlID()) {
143 GUIDesigns::buildFXMenuCommand(ret, "Start Tracking", nullptr, ret, MID_START_TRACK);
144 } else {
145 GUIDesigns::buildFXMenuCommand(ret, "Stop Tracking", nullptr, ret, MID_STOP_TRACK);
146 }
147 //
148
152 new FXMenuSeparator(ret);
153 buildPositionCopyEntry(ret, app);
154 return ret;
155}
156
157
162 // add items
163 ret->mkItem("stage", false, getCurrentStageDescription());
164 // there is always the "start" stage which we do not count here because it is not strictly part of the plan
165 ret->mkItem("stage index", false, toString(getNumStages() - getNumRemainingStages()) + " of " + toString(getNumStages() - 1));
166 ret->mkItem("start edge [id]", false, getFromEdge()->getID());
167 ret->mkItem("dest edge [id]", false, getDestination()->getID());
168 ret->mkItem("arrivalPos [m]", false, toString(getCurrentStage()->getArrivalPos()));
169 ret->mkItem("edge [id]", false, getEdge()->getID());
170 ret->mkItem("position [m]", true, new FunctionBinding<GUIContainer, double>(this, &GUIContainer::getEdgePos));
171 ret->mkItem("speed [m/s]", true, new FunctionBinding<GUIContainer, double>(this, &GUIContainer::getSpeed));
172 ret->mkItem("speed factor", false, getChosenSpeedFactor());
173 ret->mkItem("angle [degree]", true, new FunctionBinding<GUIContainer, double>(this, &GUIContainer::getAngle));
174 ret->mkItem("waiting time [s]", true, new FunctionBinding<GUIContainer, double>(this, &GUIContainer::getWaitingSeconds));
175 ret->mkItem("desired depart [s]", false, time2string(getParameter().depart));
176 // close building
178 return ret;
179}
180
181
184 GUIParameterTableWindow* ret = new GUIParameterTableWindow(app, *this, "vType:" + myVType->getID());
185 ret->mkItem("length", false, myVType->getLength());
186 ret->mkItem("width", false, myVType->getWidth());
187 ret->mkItem("height", false, myVType->getHeight());
188 ret->mkItem("minGap", false, myVType->getMinGap());
189 ret->mkItem("mass [kg]", false, myVType->getMass());
190 ret->mkItem("maximum speed [m/s]", false, myVType->getMaxSpeed());
192 return ret;
193}
194
195
196double
198 return s.containerSize.getExaggeration(s, this);
199}
200
201
204 Boundary b;
205 // ensure that the vehicle is drawn, otherwise myPositionInVehicle will not be updated
206 b.add(getPosition());
207 b.grow(20);
208 return b;
209}
210
211
212void
216 Position p1 = getPosition();
217 double angle = getAngle();
221 }
222 glTranslated(p1.x(), p1.y(), getType());
223 glRotated(RAD2DEG(angle), 0, 0, 1);
224 // set container color
225 setColor(s);
226 // scale
227 const double upscale = getExaggeration(s);
228 glScaled(upscale, upscale, 1);
229 switch (s.containerQuality) {
230 case 0:
231 case 1:
232 case 2:
234 break;
235 case 3:
236 default:
238 break;
239 }
241
242 drawName(p1, s.scale, s.containerName, s.angle);
244}
245
246
247void
251 /*
252 glTranslated(0, 0, getType() - .1); // don't draw on top of other cars
253 if (hasActiveAddVisualisation(parent, VO_SHOW_BEST_LANES)) {
254 drawBestLanes();
255 }
256 if (hasActiveAddVisualisation(parent, VO_SHOW_ROUTE)) {
257 drawRoute(s, 0, 0.25);
258 }
259 if (hasActiveAddVisualisation(parent, VO_SHOW_ALL_ROUTES)) {
260 if (getNumberReroutes() > 0) {
261 const int noReroutePlus1 = getNumberReroutes() + 1;
262 for (int i = noReroutePlus1 - 1; i >= 0; i--) {
263 double darken = double(0.4) / double(noReroutePlus1) * double(i);
264 drawRoute(s, i, darken);
265 }
266 } else {
267 drawRoute(s, 0, 0.25);
268 }
269 }
270 if (hasActiveAddVisualisation(parent, VO_SHOW_LFLINKITEMS)) {
271 for (DriveItemVector::const_iterator i = myLFLinkLanes.begin(); i != myLFLinkLanes.end(); ++i) {
272 if((*i).myLink==0) {
273 continue;
274 }
275 MSLink* link = (*i).myLink;
276 MSLane *via = link->getViaLane();
277 if (via == 0) {
278 via = link->getLane();
279 }
280 if (via != 0) {
281 Position p = via->getShape()[0];
282 if((*i).mySetRequest) {
283 glColor3f(0, 1, 0);
284 } else {
285 glColor3f(1, 0, 0);
286 }
287 glTranslated(p.x(), p.y(), -.1);
288 GLHelper::drawFilledCircle(1);
289 glTranslated(-p.x(), -p.y(), .1);
290 }
291 }
292 }
293 */
296}
297
298
299
300
301void
303 const GUIColorer& c = s.containerColorer;
304 if (!setFunctionalColor(c.getActive())) {
306 }
307}
308
309
310bool
311GUIContainer::setFunctionalColor(int activeScheme) const {
312 switch (activeScheme) {
313 case 0: {
314 if (getParameter().wasSet(VEHPARS_COLOR_SET)) {
316 return true;
317 }
318 if (getVehicleType().wasSet(VTYPEPARS_COLOR_SET)) {
320 return true;
321 }
322 return false;
323 }
324 case 2: {
325 if (getParameter().wasSet(VEHPARS_COLOR_SET)) {
327 return true;
328 }
329 return false;
330 }
331 case 3: {
332 if (getVehicleType().wasSet(VTYPEPARS_COLOR_SET)) {
334 return true;
335 }
336 return false;
337 }
338 case 8: { // color by angle
339 double hue = GeomHelper::naviDegree(getAngle());
341 return true;
342 }
343 case 9: { // color randomly (by pointer)
344 const double hue = (double)((long long int)this % 360); // [0-360]
345 const double sat = (double)(((long long int)this / 360) % 67) / 100. + 0.33; // [0.33-1]
347 return true;
348 }
349 default:
350 return false;
351 }
352}
353
354
355double
356GUIContainer::getColorValue(const GUIVisualizationSettings& /* s */, int activeScheme) const {
357 switch (activeScheme) {
358 case 4:
359 return getSpeed();
360 case 5:
361 if (isWaiting4Vehicle()) {
362 return 5;
363 } else {
364 return (double)getCurrentStageType();
365 }
366 case 6:
367 return getWaitingSeconds();
368 case 7:
370 }
371 return 0;
372}
373
374
375double
377 FXMutexLock locker(myLock);
379}
380
381int
383 FXMutexLock locker(myLock);
385}
386
387
390 FXMutexLock locker(myLock);
391 if (getCurrentStageType() == MSStageType::WAITING && getEdge()->getPermissions() == SVC_SHIP) {
392 MSLane* lane = getEdge()->getLanes().front(); //the most right lane of the water way
393 PositionVector laneShape = lane->getShape();
395 }
397}
398
399
400double
402 FXMutexLock locker(myLock);
404}
405
406
407double
409 FXMutexLock locker(myLock);
411}
412
413
414double
416 FXMutexLock locker(myLock);
418}
419
420
421void
423 // draw pedestrian shape
424 glScaled(getVehicleType().getLength(), getVehicleType().getWidth(), 1);
425 glBegin(GL_QUADS);
426 glVertex2d(0, 0.5);
427 glVertex2d(0, -0.5);
428 glVertex2d(-1, -0.5);
429 glVertex2d(-1, 0.5);
430 glEnd();
431 GLHelper::setColor(GLHelper::getColor().changedBrightness(-30));
432 glTranslated(0, 0, .045);
433 glBegin(GL_QUADS);
434 glVertex2d(-0.1, 0.4);
435 glVertex2d(-0.1, -0.4);
436 glVertex2d(-0.9, -0.4);
437 glVertex2d(-0.9, 0.4);
438 glEnd();
439}
440
441
442void
444 const std::string& file = getVehicleType().getImgFile();
445 if (file != "") {
446 // @todo invent an option for controlling whether images should be rotated or not
447 //if (getVehicleType().getGuiShape() == SVS_CONTAINER) {
448 // glRotated(RAD2DEG(getAngle() + M_PI / 2.), 0, 0, 1);
449 //}
450 int textureID = GUITexturesHelper::getTextureID(file);
451 if (textureID > 0) {
452 const double exaggeration = s.personSize.getExaggeration(s, this);
453 const double halfLength = getVehicleType().getLength() / 2.0 * exaggeration;
454 const double halfWidth = getVehicleType().getWidth() / 2.0 * exaggeration;
455 GUITexturesHelper::drawTexturedBox(textureID, -halfWidth, -halfLength, halfWidth, halfLength);
456 }
457 } else {
458 // fallback if no image is defined
460 }
461}
462
463bool
466}
467
468/****************************************************************************/
@ MID_SHOWPLAN
Show transportable plan.
Definition: GUIAppEnum.h:468
@ MID_START_TRACK
Start to track a vehicle.
Definition: GUIAppEnum.h:506
@ MID_STOP_TRACK
Stop to track a vehicle.
Definition: GUIAppEnum.h:508
FXDEFMAP(GUIContainer::GUIContainerPopupMenu) GUIContainerPopupMenuMap[]
#define WATER_WAY_OFFSET
@ GLO_CONTAINER
a container
@ 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
#define RAD2DEG(x)
Definition: GeomHelper.h:36
std::string time2string(SUMOTime t, bool humanReadable)
convert SUMOTime to string (independently of global format setting)
Definition: SUMOTime.cpp:69
const long long int VTYPEPARS_COLOR_SET
@ SVC_SHIP
is an arbitrary ship
const int VEHPARS_COLOR_SET
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 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
long onCmdStartTrack(FXObject *, FXSelector, void *)
Called if the person shall be tracked.
long onCmdShowPlan(FXObject *, FXSelector, void *)
Called if the plan shall be shown.
long onCmdStopTrack(FXObject *, FXSelector, void *)
Called if the person shall not be tracked any longer.
GUIContainerPopupMenu(GUIMainWindow &app, GUISUMOAbstractView &parent, GUIGlObject &o)
Constructor.
bool setFunctionalColor(int activeScheme) const
sets the color according to the current scheme index and some vehicle function
void drawAction_drawAsPoly(const GUIVisualizationSettings &s) const
double getWaitingSeconds() const override
the time this container spent waiting in seconds
Position getPosition() const override
return the Network coordinate of the container
void drawGL(const GUIVisualizationSettings &s) const override
Draws the object.
bool isSelected() const override
whether this container is selected in the GUI
void drawAction_drawAsImage(const GUIVisualizationSettings &s) const
double getSpeed() const override
the current speed of the container
Boundary getCenteringBoundary() const override
Returns the boundary to which the view shall be centered in order to show the object.
GUIContainer(const SUMOVehicleParameter *pars, MSVehicleType *vtype, MSTransportable::MSTransportablePlan *plan)
Constructor.
GUIGLObjectPopupMenu * getPopUpMenu(GUIMainWindow &app, GUISUMOAbstractView &parent) override
Returns an own popup-menu.
double getAngle() const override
return the current angle of the container
FXMutex myLock
The mutex used to avoid concurrent updates of the vehicle buffer.
Definition: GUIContainer.h:186
double getEdgePos() const override
return the offset from the start of the current edge
GUIBaseVehicle::Seat myPositionInVehicle
The position of a container while riding a vehicle.
Definition: GUIContainer.h:189
GUIParameterTableWindow * getTypeParameterWindow(GUIMainWindow &app, GUISUMOAbstractView &parent) override
Returns an own type parameter window.
GUIParameterTableWindow * getParameterWindow(GUIMainWindow &app, GUISUMOAbstractView &parent) override
Returns an own parameter window.
~GUIContainer()
destructor
int getDirection() const override
Return the movement directon on the edge.
virtual void drawGLAdditional(GUISUMOAbstractView *const parent, const GUIVisualizationSettings &s) const override
Draws additionally triggered visualisations.
void setColor(const GUIVisualizationSettings &s) const
sets the color according to the currente settings
double getColorValue(const GUIVisualizationSettings &s, int activeScheme) const override
gets the color value according to the current scheme index
double getExaggeration(const GUIVisualizationSettings &s) const override
return exaggeration associated with this GLObject
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
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.
T getColor(const double value) const
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.
static void drawTexturedBox(int which, double size)
Draws a named texture as a box with the given size.
static int getTextureID(const std::string &filename, const bool mirrorX=false)
return texture id for the given filename (initialize on first use)
Stores the information about how to visualize structures.
GUIVisualizationSizeSettings containerSize
int containerQuality
The quality of container drawing.
GUIVisualizationSizeSettings personSize
double scale
information about a lane's width (temporary, used for a single view)
GUIVisualizationTextSettings containerName
GUIColorer containerColorer
The container colorer.
double angle
The current view rotation angle.
static double naviDegree(const double angle)
Definition: GeomHelper.cpp:192
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
Definition: MSEdge.h:168
Representation of a lane in the micro simulation.
Definition: MSLane.h:84
virtual const PositionVector & getShape(bool) const
Definition: MSLane.h:293
const MSEdge * getFromEdge() const
Returns the departure edge.
virtual double getChosenSpeedFactor() const
the current speed factor of the transportable (where applicable)
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
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.
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.
double getArrivalPos() const
returns the final arrival pos
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
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].
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].
double getMass() const
Get this vehicle type's mass.
std::string getImgFile() const
Get this vehicle type's raster model file name.
const SUMOVTypeParameter & getParameter() const
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
double x() const
Returns the x-position.
Definition: Position.h:55
double y() const
Returns the y-position.
Definition: Position.h:60
A list of positions.
Position positionAtOffset2D(double pos, double lateralOffset=0) const
Returns the position at the given length.
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
Structure representing possible vehicle parameter.
double getExaggeration(const GUIVisualizationSettings &s, const GUIGlObject *o, double factor=20) const
return the drawing size including exaggeration and constantSize values