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-2022 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>
34 #include <utils/geom/GeomHelper.h>
40 #include <utils/gui/div/GLHelper.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 // ===========================================================================
57 FXDEFMAP(GUIContainer::GUIContainerPopupMenu) GUIContainerPopupMenuMap[] = {
61 };
62 
63 // Object implementation
64 FXIMPLEMENT(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 
83 long
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 
101 long
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 
110 long
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),
125  GUIGlObject(GLO_CONTAINER, pars->id) {
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, false);
154  return ret;
155 }
156 
157 
161  GUIParameterTableWindow* ret = new GUIParameterTableWindow(app, *this);
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, getSpeedFactor());
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
177  ret->closeBuilding(&getParameter());
178  return ret;
179 }
180 
181 
185  GUIParameterTableWindow* ret = new GUIParameterTableWindow(app, *this);
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
195  ret->closeBuilding(&(myVType->getParameter()));
196  return ret;
197 }
198 
199 
200 double
202  return s.containerSize.getExaggeration(s, this);
203 }
204 
205 
206 Boundary
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 
216 void
220  Position p1 = getPosition();
221  double angle = getAngle();
224  angle = myPositionInVehicle.angle;
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 
251 void
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 
305 void
307  const GUIColorer& c = s.containerColorer;
308  if (!setFunctionalColor(c.getActive())) {
310  }
311 }
312 
313 
314 bool
315 GUIContainer::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)) {
323  GLHelper::setColor(getVehicleType().getColor());
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)) {
337  GLHelper::setColor(getVehicleType().getColor());
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 = (((long long int)this / 360) % 67) / 100.0 + 0.33; // [0.33-1]
350  GLHelper::setColor(RGBColor::fromHSV(hue, sat, 1.));
351  return true;
352  }
353  default:
354  return false;
355  }
356 }
357 
358 
359 double
360 GUIContainer::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 
379 double
381  FXMutexLock locker(myLock);
383 }
384 
385 int
387  FXMutexLock locker(myLock);
389 }
390 
391 
392 Position
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();
398  return laneShape.positionAtOffset2D(getEdgePos(), WATER_WAY_OFFSET);
399  }
401 }
402 
403 
404 double
406  FXMutexLock locker(myLock);
407  return MSTransportable::getAngle();
408 }
409 
410 
411 double
413  FXMutexLock locker(myLock);
415 }
416 
417 
418 double
420  FXMutexLock locker(myLock);
421  return MSTransportable::getSpeed();
422 }
423 
424 
425 void
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 
446 void
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 
467 bool
470 }
471 
472 /****************************************************************************/
@ MID_SHOWPLAN
Show transportable plan.
Definition: GUIAppEnum.h:429
@ MID_START_TRACK
Start to track a vehicle.
Definition: GUIAppEnum.h:467
@ MID_STOP_TRACK
Stop to track a vehicle.
Definition: GUIAppEnum.h:469
FXDEFMAP(GUIContainer::GUIContainerPopupMenu) GUIContainerPopupMenuMap[]
#define WATER_WAY_OFFSET
@ GLO_CONTAINER
a container
@ GLO_PERSON
a person
GUISelectedStorage gSelected
A global holder of selected objects.
#define RAD2DEG(x)
Definition: GeomHelper.h:36
std::string time2string(SUMOTime t)
convert SUMOTime to string
Definition: SUMOTime.cpp:68
const 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:77
Boundary & grow(double by)
extends the boundary by the given amount
Definition: Boundary.cpp:299
static void setColor(const RGBColor &c)
Sets the gl-color to this value.
Definition: GLHelper.cpp:507
static void pushName(unsigned int name)
push Name
Definition: GLHelper.cpp:132
static void popMatrix()
pop matrix
Definition: GLHelper.cpp:123
static RGBColor getColor()
gets the gl-color
Definition: GLHelper.cpp:513
static void popName()
pop Name
Definition: GLHelper.cpp:141
static void pushMatrix()
push matrix
Definition: GLHelper.cpp:114
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 asociated 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 buildPositionCopyEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to copy the cursor position if geo projection is used,...
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.
void buildSelectionPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to (de)select the object.
GUIGlID getGlID() const
Returns the numerical id of the object.
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:82
const PositionVector & getShape() const
Returns this lane's shape.
Definition: MSLane.h:478
virtual double getEdgePos() const
Return the position on the edge.
std::string getCurrentStageDescription() const
Returns the current stage description as a string.
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
const SUMOVehicleParameter & getParameter() const
Returns the vehicle's parameter (including departure definition)
MSVehicleType * myVType
This transportable's type. (mainly used for drawing related information Note sure if it is really nec...
const MSVehicleType & getVehicleType() const
Returns the object's "vehicle" type.
virtual Position getPosition() const
Return the Network coordinate of the transportable.
double getArrivalPos() const
returns the final arrival pos
const MSEdge * getFromEdge() const
Returns the departure edge.
int getNumStages() const
Return the total number stages in this persons plan.
MSStageType getCurrentStageType() const
the current stage type of the transportable
const MSEdge * getEdge() const
Returns the current edge.
MSStage * getCurrentStage() const
Return the current stage.
virtual double getWaitingSeconds() const
the time this transportable spent waiting in seconds
virtual int getDirection() const
Return the movement directon on the edge.
std::vector< MSStage * > MSTransportablePlan
the structure holding the plan of a transportable
const MSEdge * getDestination() const
Returns the current destination.
virtual double getSpeedFactor() const
the current speed factor of the transportable (where applicable)
The car-following model and parameter.
Definition: MSVehicleType.h:62
double getWidth() const
Get the width which vehicles of this class shall have when being drawn.
double getMaxSpeed() const
Get vehicle's maximum speed [m/s].
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.
const std::string & getID() const
Returns the name of the vehicle type.
Definition: MSVehicleType.h:90
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:368
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