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.org/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
186 // add items
187 ret->mkItem("Type Information:", false, "");
188 ret->mkItem("type [id]", false, myVType->getID());
189 ret->mkItem("length", false, myVType->getLength());
190 ret->mkItem("width", false, myVType->getWidth());
191 ret->mkItem("height", false, myVType->getHeight());
192 ret->mkItem("minGap", false, myVType->getMinGap());
193 ret->mkItem("maximum speed [m/s]", false, myVType->getMaxSpeed());
194 // close building
196 return ret;
197}
198
199
200double
202 return s.containerSize.getExaggeration(s, this);
203}
204
205
208 Boundary b;
209 // ensure that the vehicle is drawn, otherwise myPositionInVehicle will not be updated
210 b.add(getPosition());
211 b.grow(20);
212 return b;
213}
214
215
216void
220 Position p1 = getPosition();
221 double angle = getAngle();
225 }
226 glTranslated(p1.x(), p1.y(), getType());
227 glRotated(RAD2DEG(angle), 0, 0, 1);
228 // set container color
229 setColor(s);
230 // scale
231 const double upscale = getExaggeration(s);
232 glScaled(upscale, upscale, 1);
233 switch (s.containerQuality) {
234 case 0:
235 case 1:
236 case 2:
238 break;
239 case 3:
240 default:
242 break;
243 }
245
246 drawName(p1, s.scale, s.containerName, s.angle);
248}
249
250
251void
255 /*
256 glTranslated(0, 0, getType() - .1); // don't draw on top of other cars
257 if (hasActiveAddVisualisation(parent, VO_SHOW_BEST_LANES)) {
258 drawBestLanes();
259 }
260 if (hasActiveAddVisualisation(parent, VO_SHOW_ROUTE)) {
261 drawRoute(s, 0, 0.25);
262 }
263 if (hasActiveAddVisualisation(parent, VO_SHOW_ALL_ROUTES)) {
264 if (getNumberReroutes() > 0) {
265 const int noReroutePlus1 = getNumberReroutes() + 1;
266 for (int i = noReroutePlus1 - 1; i >= 0; i--) {
267 double darken = double(0.4) / double(noReroutePlus1) * double(i);
268 drawRoute(s, i, darken);
269 }
270 } else {
271 drawRoute(s, 0, 0.25);
272 }
273 }
274 if (hasActiveAddVisualisation(parent, VO_SHOW_LFLINKITEMS)) {
275 for (DriveItemVector::const_iterator i = myLFLinkLanes.begin(); i != myLFLinkLanes.end(); ++i) {
276 if((*i).myLink==0) {
277 continue;
278 }
279 MSLink* link = (*i).myLink;
280 MSLane *via = link->getViaLane();
281 if (via == 0) {
282 via = link->getLane();
283 }
284 if (via != 0) {
285 Position p = via->getShape()[0];
286 if((*i).mySetRequest) {
287 glColor3f(0, 1, 0);
288 } else {
289 glColor3f(1, 0, 0);
290 }
291 glTranslated(p.x(), p.y(), -.1);
292 GLHelper::drawFilledCircle(1);
293 glTranslated(-p.x(), -p.y(), .1);
294 }
295 }
296 }
297 */
300}
301
302
303
304
305void
307 const GUIColorer& c = s.containerColorer;
308 if (!setFunctionalColor(c.getActive())) {
310 }
311}
312
313
314bool
315GUIContainer::setFunctionalColor(int activeScheme) const {
316 switch (activeScheme) {
317 case 0: {
318 if (getParameter().wasSet(VEHPARS_COLOR_SET)) {
320 return true;
321 }
322 if (getVehicleType().wasSet(VTYPEPARS_COLOR_SET)) {
324 return true;
325 }
326 return false;
327 }
328 case 2: {
329 if (getParameter().wasSet(VEHPARS_COLOR_SET)) {
331 return true;
332 }
333 return false;
334 }
335 case 3: {
336 if (getVehicleType().wasSet(VTYPEPARS_COLOR_SET)) {
338 return true;
339 }
340 return false;
341 }
342 case 8: { // color by angle
343 double hue = GeomHelper::naviDegree(getAngle());
345 return true;
346 }
347 case 9: { // color randomly (by pointer)
348 const double hue = (double)((long long int)this % 360); // [0-360]
349 const double sat = (double)(((long long int)this / 360) % 67) / 100. + 0.33; // [0.33-1]
351 return true;
352 }
353 default:
354 return false;
355 }
356}
357
358
359double
360GUIContainer::getColorValue(const GUIVisualizationSettings& /* s */, int activeScheme) const {
361 switch (activeScheme) {
362 case 4:
363 return getSpeed();
364 case 5:
365 if (isWaiting4Vehicle()) {
366 return 5;
367 } else {
368 return (double)getCurrentStageType();
369 }
370 case 6:
371 return getWaitingSeconds();
372 case 7:
374 }
375 return 0;
376}
377
378
379double
381 FXMutexLock locker(myLock);
383}
384
385int
387 FXMutexLock locker(myLock);
389}
390
391
394 FXMutexLock locker(myLock);
395 if (getCurrentStageType() == MSStageType::WAITING && getEdge()->getPermissions() == SVC_SHIP) {
396 MSLane* lane = getEdge()->getLanes().front(); //the most right lane of the water way
397 PositionVector laneShape = lane->getShape();
399 }
401}
402
403
404double
406 FXMutexLock locker(myLock);
408}
409
410
411double
413 FXMutexLock locker(myLock);
415}
416
417
418double
420 FXMutexLock locker(myLock);
422}
423
424
425void
427 // draw pedestrian shape
428 glScaled(getVehicleType().getLength(), getVehicleType().getWidth(), 1);
429 glBegin(GL_QUADS);
430 glVertex2d(0, 0.5);
431 glVertex2d(0, -0.5);
432 glVertex2d(-1, -0.5);
433 glVertex2d(-1, 0.5);
434 glEnd();
435 GLHelper::setColor(GLHelper::getColor().changedBrightness(-30));
436 glTranslated(0, 0, .045);
437 glBegin(GL_QUADS);
438 glVertex2d(-0.1, 0.4);
439 glVertex2d(-0.1, -0.4);
440 glVertex2d(-0.9, -0.4);
441 glVertex2d(-0.9, 0.4);
442 glEnd();
443}
444
445
446void
448 const std::string& file = getVehicleType().getImgFile();
449 if (file != "") {
450 // @todo invent an option for controlling whether images should be rotated or not
451 //if (getVehicleType().getGuiShape() == SVS_CONTAINER) {
452 // glRotated(RAD2DEG(getAngle() + M_PI / 2.), 0, 0, 1);
453 //}
454 int textureID = GUITexturesHelper::getTextureID(file);
455 if (textureID > 0) {
456 const double exaggeration = s.personSize.getExaggeration(s, this);
457 const double halfLength = getVehicleType().getLength() / 2.0 * exaggeration;
458 const double halfWidth = getVehicleType().getWidth() / 2.0 * exaggeration;
459 GUITexturesHelper::drawTexturedBox(textureID, -halfWidth, -halfLength, halfWidth, halfLength);
460 }
461 } else {
462 // fallback if no image is defined
464 }
465}
466
467bool
470}
471
472/****************************************************************************/
@ MID_SHOWPLAN
Show transportable plan.
Definition: GUIAppEnum.h:466
@ MID_START_TRACK
Start to track a vehicle.
Definition: GUIAppEnum.h:504
@ MID_STOP_TRACK
Stop to track a vehicle.
Definition: GUIAppEnum.h:506
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)
convert SUMOTime to string
Definition: SUMOTime.cpp:68
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.
const 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].
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