Eclipse SUMO - Simulation of Urban MObility
GUIBaseVehicle.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/****************************************************************************/
21// A MSVehicle extended by some values for usage within the gui
22/****************************************************************************/
23#include <config.h>
24
25#include <cmath>
26#include <vector>
27#include <string>
28#include <functional>
42#include <mesosim/MEVehicle.h>
43#include <mesosim/MELoop.h>
44#include <microsim/MSVehicle.h>
45#include <microsim/MSLane.h>
49#include <microsim/MSStop.h>
55#include <gui/GUIGlobals.h>
57
58#include "GUIBaseVehicle.h"
59#include "GUIPerson.h"
60#include "GUIContainer.h"
61#include "GUINet.h"
62#include "GUIEdge.h"
63#include "GUILane.h"
64#include "GUIParkingArea.h"
65
66//#define DRAW_BOUNDING_BOX
67
68// ===========================================================================
69// FOX callback mapping
70// ===========================================================================
71FXDEFMAP(GUIBaseVehicle::GUIBaseVehiclePopupMenu) GUIBaseVehiclePopupMenuMap[] = {
90};
91
92// Object implementation
93FXIMPLEMENT(GUIBaseVehicle::GUIBaseVehiclePopupMenu, GUIGLObjectPopupMenu, GUIBaseVehiclePopupMenuMap, ARRAYNUMBER(GUIBaseVehiclePopupMenuMap))
94
95// ===========================================================================
96// method definitions
97// ===========================================================================
98/* -------------------------------------------------------------------------
99 * GUIBaseVehicle::GUIBaseVehiclePopupMenu - methods
100 * ----------------------------------------------------------------------- */
103 : GUIGLObjectPopupMenu(app, parent, o) {
104}
105
106
108
109
110long
112 assert(myObject->getType() == GLO_VEHICLE);
113 if (!static_cast<GUIBaseVehicle*>(myObject)->hasActiveAddVisualisation(myParent, VO_SHOW_ALL_ROUTES)) {
114 static_cast<GUIBaseVehicle*>(myObject)->addActiveAddVisualisation(myParent, VO_SHOW_ALL_ROUTES);
115 }
116 return 1;
117}
118
119long
121 assert(myObject->getType() == GLO_VEHICLE);
122 static_cast<GUIBaseVehicle*>(myObject)->removeActiveAddVisualisation(myParent, VO_SHOW_ALL_ROUTES);
123 return 1;
124}
125
126
127long
129 assert(myObject->getType() == GLO_VEHICLE);
130 if (!static_cast<GUIBaseVehicle*>(myObject)->hasActiveAddVisualisation(myParent, VO_SHOW_ROUTE)) {
131 static_cast<GUIBaseVehicle*>(myObject)->addActiveAddVisualisation(myParent, VO_SHOW_ROUTE);
132 }
133 return 1;
134}
135
136long
138 assert(myObject->getType() == GLO_VEHICLE);
139 static_cast<GUIBaseVehicle*>(myObject)->removeActiveAddVisualisation(myParent, VO_SHOW_ROUTE);
140 return 1;
141}
142
143
144long
146 assert(myObject->getType() == GLO_VEHICLE);
147 if (!static_cast<GUIBaseVehicle*>(myObject)->hasActiveAddVisualisation(myParent, VO_SHOW_FUTURE_ROUTE)) {
148 static_cast<GUIBaseVehicle*>(myObject)->addActiveAddVisualisation(myParent, VO_SHOW_FUTURE_ROUTE);
149 }
150 return 1;
151}
152
153long
155 assert(myObject->getType() == GLO_VEHICLE);
156 static_cast<GUIBaseVehicle*>(myObject)->removeActiveAddVisualisation(myParent, VO_SHOW_FUTURE_ROUTE);
157 return 1;
158}
159
160
161long
163 assert(myObject->getType() == GLO_VEHICLE);
164 if (!static_cast<GUIBaseVehicle*>(myObject)->hasActiveAddVisualisation(myParent, VO_SHOW_ROUTE_NOLOOP)) {
165 static_cast<GUIBaseVehicle*>(myObject)->addActiveAddVisualisation(myParent, VO_SHOW_ROUTE_NOLOOP);
166 }
167 return 1;
168}
169
170long
172 assert(myObject->getType() == GLO_VEHICLE);
173 static_cast<GUIBaseVehicle*>(myObject)->removeActiveAddVisualisation(myParent, VO_SHOW_ROUTE_NOLOOP);
174 return 1;
175}
176
177
178long
180 assert(myObject->getType() == GLO_VEHICLE);
181 if (!static_cast<GUIBaseVehicle*>(myObject)->hasActiveAddVisualisation(myParent, VO_SHOW_BEST_LANES)) {
182 static_cast<GUIBaseVehicle*>(myObject)->addActiveAddVisualisation(myParent, VO_SHOW_BEST_LANES);
183 }
184 return 1;
185}
186
187long
189 assert(myObject->getType() == GLO_VEHICLE);
190 static_cast<GUIBaseVehicle*>(myObject)->removeActiveAddVisualisation(myParent, VO_SHOW_BEST_LANES);
191 return 1;
192}
193
194
195long
197 assert(myObject->getType() == GLO_VEHICLE);
198 if (myParent->getTrackedID() != static_cast<GUIBaseVehicle*>(myObject)->getGlID()) {
199 myParent->startTrack(static_cast<GUIBaseVehicle*>(myObject)->getGlID());
200 }
201 return 1;
202}
203
204long
206 assert(myObject->getType() == GLO_VEHICLE);
207 myParent->stopTrack();
208 return 1;
209}
210
211
212long
214 assert(myObject->getType() == GLO_VEHICLE);
215 if (!static_cast<GUIBaseVehicle*>(myObject)->hasActiveAddVisualisation(myParent, VO_SHOW_LFLINKITEMS)) {
216 static_cast<GUIBaseVehicle*>(myObject)->addActiveAddVisualisation(myParent, VO_SHOW_LFLINKITEMS);
217 }
218 return 1;
219}
220
221long
223 assert(myObject->getType() == GLO_VEHICLE);
224 static_cast<GUIBaseVehicle*>(myObject)->removeActiveAddVisualisation(myParent, VO_SHOW_LFLINKITEMS);
225 return 1;
226}
227
228long
230 assert(myObject->getType() == GLO_VEHICLE);
231 static_cast<GUIBaseVehicle*>(myObject)->selectBlockingFoes();
232 myParent->update();
233 return 1;
234}
235
236
237long
239 assert(myObject->getType() == GLO_VEHICLE);
240 const MSBaseVehicle& veh = static_cast<GUIBaseVehicle*>(myObject)->getVehicle();
241 for (const MSTransportable* t : veh.getPersons()) {
242 gSelected.select((static_cast<const GUIPerson*>(t))->getGlID());
243 }
244 for (MSTransportable* t : veh.getContainers()) {
245 gSelected.select((static_cast<const GUIContainer*>(t))->getGlID());
246 }
247 myParent->update();
248 return 1;
249}
250
251long
253 GUIBaseVehicle* baseVeh = static_cast<GUIBaseVehicle*>(myObject);
254 MSVehicle* microVeh = dynamic_cast<MSVehicle*>(&baseVeh->myVehicle);
255 if (microVeh != nullptr) {
256 MSLane* lane = microVeh->getMutableLane();
257 if (lane != nullptr) {
258 lane->getVehiclesSecure();
260 }
262 if (lane != nullptr) {
263 lane->releaseVehicles();
264 }
265 } else {
266 MEVehicle* mesoVeh = dynamic_cast<MEVehicle*>(&baseVeh->myVehicle);
268 }
270 myParent->destroyPopup();
271 myParent->update();
272 return 1;
273}
274
275
276long
278 GUIBaseVehicle* baseVeh = static_cast<GUIBaseVehicle*>(myObject);
279 MSVehicle* microVeh = dynamic_cast<MSVehicle*>(&baseVeh->myVehicle);
280 if (microVeh != nullptr) {
281 if (microVeh->isStopped()) {
282 microVeh->resumeFromStopping();
283 } else {
284 std::string errorOut;
285 const double brakeGap = microVeh->getCarFollowModel().brakeGap(microVeh->getSpeed());
286 std::pair<const MSLane*, double> stopPos = microVeh->getLanePosAfterDist(brakeGap);
287 if (stopPos.first != nullptr) {
289 stop.lane = stopPos.first->getID();
290 stop.startPos = stopPos.second;
291 stop.endPos = stopPos.second + POSITION_EPS;
292 stop.duration = TIME2STEPS(3600);
293 microVeh->addTraciStop(stop, errorOut);
294 if (errorOut != "") {
295 WRITE_WARNING(errorOut);
296 }
297 }
298 }
299 } else {
300 WRITE_WARNING(TL("GUI-triggered stop not implemented for meso"));
301 }
302 myParent->update();
303 return 1;
304}
305
306
307/* -------------------------------------------------------------------------
308 * GUIBaseVehicle - methods
309 * ----------------------------------------------------------------------- */
310
312 GUIGlObject(GLO_VEHICLE, vehicle.getID(), GUIIconSubSys::getIcon(GUIIcon::VEHICLE)),
313 myVehicle(vehicle),
314 myPopup(nullptr) {
315 // as it is possible to show all vehicle routes, we have to store them... (bug [ 2519761 ])
317 myVehicle.myMoveReminders.push_back(std::make_pair(myRoutes, 0.));
318 mySeatPositions.push_back(Seat()); // ensure length 1
319 myContainerPositions.push_back(Seat()); // ensure length 1
320}
321
322
324 myLock.lock();
325 for (std::map<GUISUMOAbstractView*, int>::iterator i = myAdditionalVisualizations.begin(); i != myAdditionalVisualizations.end(); ++i) {
326 while (i->first->removeAdditionalGLVisualisation(this));
327 }
328 myLock.unlock();
329 delete myRoutes;
330 if (myPopup != nullptr) {
332 }
333}
334
335
338 GUISUMOAbstractView& parent) {
339 GUIGLObjectPopupMenu* ret = new GUIBaseVehiclePopupMenu(app, parent, *this);
340 buildPopupHeader(ret, app);
344 //
346 GUIDesigns::buildFXMenuCommand(ret, "Hide Current Route", nullptr, ret, MID_HIDE_CURRENTROUTE);
347 } else {
348 GUIDesigns::buildFXMenuCommand(ret, "Show Current Route", nullptr, ret, MID_SHOW_CURRENTROUTE);
349 }
351 GUIDesigns::buildFXMenuCommand(ret, "Hide Future Route", nullptr, ret, MID_HIDE_FUTUREROUTE);
352 } else {
353 GUIDesigns::buildFXMenuCommand(ret, "Show Future Route", nullptr, ret, MID_SHOW_FUTUREROUTE);
354 }
356 GUIDesigns::buildFXMenuCommand(ret, "Hide All Routes", nullptr, ret, MID_HIDE_ALLROUTES);
357 } else {
358 GUIDesigns::buildFXMenuCommand(ret, "Show All Routes", nullptr, ret, MID_SHOW_ALLROUTES);
359 }
361 FXMenuCheck* showLoops = new FXMenuCheck(ret, "Draw looped routes", ret, MID_HIDE_ROUTE_NOLOOPS);
362 showLoops->setCheck(false);
363 } else {
364 FXMenuCheck* showLoops = new FXMenuCheck(ret, "Draw looped routes", ret, MID_SHOW_ROUTE_NOLOOPS);
365 showLoops->setCheck(true);
366 }
368 GUIDesigns::buildFXMenuCommand(ret, "Hide Best Lanes", nullptr, ret, MID_HIDE_BEST_LANES);
369 } else {
370 GUIDesigns::buildFXMenuCommand(ret, "Show Best Lanes", nullptr, ret, MID_SHOW_BEST_LANES);
371 }
373 GUIDesigns::buildFXMenuCommand(ret, "Hide Link Items", nullptr, ret, MID_HIDE_LFLINKITEMS);
374 } else {
375 GUIDesigns::buildFXMenuCommand(ret, "Show Link Items", nullptr, ret, MID_SHOW_LFLINKITEMS);
376 }
377 new FXMenuSeparator(ret);
378 if (parent.getTrackedID() != getGlID()) {
379 GUIDesigns::buildFXMenuCommand(ret, "Start Tracking", nullptr, ret, MID_START_TRACK);
380 } else {
381 GUIDesigns::buildFXMenuCommand(ret, "Stop Tracking", nullptr, ret, MID_STOP_TRACK);
382 }
383 GUIDesigns::buildFXMenuCommand(ret, "Select Foes", nullptr, ret, MID_SHOW_FOES);
384 if (myVehicle.getPersons().size() + myVehicle.getContainers().size() > 0) {
385 GUIDesigns::buildFXMenuCommand(ret, "Select transported", nullptr, ret, MID_SELECT_TRANSPORTED);
386 }
387 GUIDesigns::buildFXMenuCommand(ret, myVehicle.isStopped() ? "Abort stop" : "Stop", nullptr, ret, MID_TOGGLE_STOP);
388 GUIDesigns::buildFXMenuCommand(ret, "Remove", nullptr, ret, MID_REMOVE_OBJECT);
389
390 new FXMenuSeparator(ret);
391 //
392 buildShowParamsPopupEntry(ret, false);
394 buildPositionCopyEntry(ret, app);
395 myPopup = ret;
396 return ret;
397}
398
399
400void
402 myPopup = nullptr;
403}
404
405
406double
408 return (s.vehicleSize.getExaggeration(s, this) *
410}
411
412
415 Boundary b;
416 b.add(getPosition());
418 return b;
419}
420
421
422const std::string
424 return myVehicle.getParameter().getParameter("name", "");
425}
426
427
428void
429GUIBaseVehicle::drawOnPos(const GUIVisualizationSettings& s, const Position& pos, const double angle) const {
432 Position p1 = pos;
433 const double degAngle = RAD2DEG(angle + M_PI / 2.);
434 const double length = getVType().getLength();
435 glTranslated(p1.x(), p1.y(), getType());
436 glRotated(degAngle, 0, 0, 1);
437 RGBColor col = setColor(s);
438 // scale
439 const double upscale = getExaggeration(s);
440
441 if (upscale > 1 && s.laneWidthExaggeration > 1 && myVehicle.isOnRoad()) {
442 // optionally shift according to edge exaggeration
443 double offsetFromLeftBorder = myVehicle.getCurrentEdge()->getWidth() - myVehicle.getRightSideOnEdge() - myVehicle.getVehicleType().getWidth() / 2;
444 glTranslated((s.laneWidthExaggeration - 1) * -offsetFromLeftBorder / 2, 0, 0);
445 }
446
447 double upscaleLength = upscale;
448 if (upscale > 1 && length > 5 && s.vehicleQuality != 4) {
449 // reduce the length/width ratio because this is not usefull at high zoom
450 const double widthLengthFactor = length / 5;
451 const double shrinkFactor = MIN2(widthLengthFactor, sqrt(upscaleLength));
452 upscaleLength /= shrinkFactor;
453 }
454 glScaled(upscale, upscaleLength, 1);
455 /*
456 MSLaneChangeModel::DK2004 &m2 = static_cast<MSLaneChangeModel::DK2004&>(veh->getLaneChangeModel());
457 if((m2.getState()&LCA_URGENT)!=0) {
458 glColor3d(1, .4, .4);
459 } else if((m2.getState()&LCA_SPEEDGAIN)!=0) {
460 glColor3d(.4, .4, 1);
461 } else {
462 glColor3d(.4, 1, .4);
463 }
464 */
465 // draw the vehicle
466 bool drawCarriages = false;
467 const double geometryFactor = (s.scaleLength ?
468 ((myVehicle.getLane() != nullptr
470 : (myVehicle.getEdge()->getLanes().size() > 0 ? myVehicle.getEdge()->getLanes()[0]->getLengthGeometryFactor() : 1)))
471 : 1);
472 double scaledLength = length * geometryFactor;
473 if (col.alpha() != 0) {
474 switch (s.vehicleQuality) {
475 case 0:
477 break;
478 case 1:
480 break;
481 case 2:
482 drawCarriages = drawAction_drawVehicleAsPolyWithCarriagges(s, scaledLength);
483 // draw flashing blue light for emergency vehicles
484 if (getVType().getGuiShape() == SUMOVehicleShape::EMERGENCY) {
485 glTranslated(0, 0, .1);
487 }
488 break;
489 case 3:
490 drawCarriages = drawAction_drawVehicleAsPolyWithCarriagges(s, scaledLength, true);
491 break;
492 case 4: {
493 // do not scale circle radius by lengthGeometryFactor nor length and reduce the effect of width
494 const double w = 1.8 * sqrt(getVType().getWidth() / 1.8);
496 // display text at circle center
497 scaledLength = 0;
498 break;
499 }
500 default:
501 break;
502 }
503 if (s.drawMinGap) {
504 const double minGap = -getVType().getMinGap();
505 glColor3d(0., 1., 0.);
506 glBegin(GL_LINES);
507 glVertex2d(0., 0);
508 glVertex2d(0., minGap);
509 glVertex2d(-.5, minGap);
510 glVertex2d(.5, minGap);
511 glEnd();
512 }
515 const double brakeGap = -static_cast<MSVehicle&>(myVehicle).getCarFollowModel().brakeGap(myVehicle.getSpeed());
516 glColor3d(1., 0., 0.);
517 glBegin(GL_LINES);
518 glVertex2d(0., 0);
519 glVertex2d(0., brakeGap);
520 glVertex2d(-.5, brakeGap);
521 glVertex2d(.5, brakeGap);
522 glEnd();
523 }
524 if (s.showBTRange) {
526 if (dev != nullptr) {
527 glColor3d(1., 0., 0.);
528 GLHelper::drawOutlineCircle(dev->getRange(), dev->getRange() - .2, 32);
529 }
530 }
531 // draw the blinker and brakelights if wished
532 if (s.showBlinker) {
533 glTranslated(0, 0, .1);
534 switch (getVType().getGuiShape()) {
543 break;
546 drawAction_drawVehicleBlinker(scaledLength);
547 drawAction_drawVehicleBrakeLight(scaledLength, true);
548 break;
549 default:
550 // only SUMOVehicleShape::RAIL_CAR has blinkers and brake lights but they are drawn along with the carriages
551 if (!drawCarriages) {
552 drawAction_drawVehicleBlinker(scaledLength);
554 }
555 break;
556 }
557 }
558 // draw the wish to change the lane
560 /*
561 if(gSelected.isSelected(GLO_VEHICLE, veh->getGlID())) {
562 MSLaneChangeModel::DK2004 &m = static_cast<MSLaneChangeModel::DK2004&>(veh->getLaneChangeModel());
563 glColor3d(.5, .5, 1);
564 glBegin(GL_LINES);
565 glVertex2f(0, 0);
566 glVertex2f(m.getChangeProbability(), .5);
567 glEnd();
568
569 glColor3d(1, 0, 0);
570 glBegin(GL_LINES);
571 glVertex2f(0.1, 0);
572 glVertex2f(0.1, m.myMaxJam1);
573 glEnd();
574
575 glColor3d(0, 1, 0);
576 glBegin(GL_LINES);
577 glVertex2f(-0.1, 0);
578 glVertex2f(-0.1, m.myTDist);
579 glEnd();
580 }
581 */
582 }
583 }
584 glTranslated(0, MIN2(scaledLength / 2, double(5)), -getType()); // drawing name at GLO_MAX fails unless translating z
585 glScaled(1 / upscale, 1 / upscaleLength, 1);
586 glRotated(-degAngle, 0, 0, 1);
587 drawName(Position(0, 0), s.scale, s.vehicleName, s.angle);
588 if (s.vehicleName.show(this) && myVehicle.getParameter().line != "") {
589 glRotated(-s.angle, 0, 0, 1);
590 glTranslated(0, 0.7 * s.vehicleName.scaledSize(s.scale), 0);
591 glRotated(s.angle, 0, 0, 1);
593 }
594 if (s.vehicleValue.show(this)) {
595 glRotated(-s.angle, 0, 0, 1);
596 glTranslated(0, 0.7 * s.vehicleName.scaledSize(s.scale), 0);
597 glRotated(s.angle, 0, 0, 1);
598 const double value = getColorValue(s, s.vehicleColorer.getActive());
600 }
601 if (s.vehicleScaleValue.show(this)) {
602 glRotated(-s.angle, 0, 0, 1);
603 glTranslated(0, 0.7 * s.vehicleName.scaledSize(s.scale), 0);
604 glRotated(s.angle, 0, 0, 1);
605 const double value = getScaleValue(s, s.vehicleScaler.getActive());
607 }
608 if (s.vehicleText.show(this)) {
609 std::string error;
610 std::string value = myVehicle.getPrefixedParameter(s.vehicleTextParam, error);
611 if (value != "") {
613 glRotated(-s.angle, 0, 0, 1);
614 glTranslated(0, 0.7 * s.vehicleText.scaledSize(s.scale) * (double)lines.size(), 0);
615 glRotated(s.angle, 0, 0, 1);
616 for (std::string& line : lines) {
618 glRotated(-s.angle, 0, 0, 1);
619 glTranslated(0, -0.7 * s.vehicleText.scaledSize(s.scale), 0);
620 glRotated(s.angle, 0, 0, 1);
621 }
622 }
623 }
626 glRotated(-s.angle, 0, 0, 1);
627 glTranslated(0, 0.7 * s.vehicleName.scaledSize(s.scale), 0);
628 glRotated(s.angle, 0, 0, 1);
629 const double value = myVehicle.getNumberParkingReroutes();
631 }
632
633 if (!drawCarriages) {
634 mySeatPositions.clear();
635 myContainerPositions.clear();
636 int requiredSeats = getNumPassengers();
637 int requiredContainerPositions = getNumContainers();
638 const Position back = (p1 + Position(-scaledLength * upscaleLength, 0)).rotateAround2D(angle, p1);
639 computeSeats(p1, back, SUMO_const_waitingPersonWidth, getVType().getPersonCapacity(), upscale, requiredSeats, mySeatPositions);
640 computeSeats(p1, back, SUMO_const_waitingContainerWidth, getVType().getContainerCapacity(), upscale, requiredContainerPositions, myContainerPositions);
641 }
642
646}
647
648
649void
652}
653
654
655void
657 if (!myVehicle.isOnRoad()) {
658 drawGL(s);
659 }
662 glTranslated(0, 0, getType() - .1); // don't draw on top of other cars
665 }
666 bool noLoop = hasActiveAddVisualisation(parent, VO_SHOW_ROUTE_NOLOOP);
668 drawRoute(s, 0, 0.25, false, noLoop);
669 }
671 drawRoute(s, 0, 0.25, true, noLoop);
672 }
674 if (myVehicle.getNumberReroutes() > 0) {
675 const int noReroutePlus1 = myVehicle.getNumberReroutes() + 1;
676 for (int i = noReroutePlus1 - 1; i >= 0; i--) {
677 double darken = double(0.4) / double(noReroutePlus1) * double(i);
678 drawRoute(s, i, darken);
679 }
680 } else {
681 drawRoute(s, 0, 0.25, false, noLoop);
682 }
683 }
686 }
689}
690
691
692void
693GUIBaseVehicle::drawLinkItem(const Position& pos, SUMOTime arrivalTime, SUMOTime leaveTime, double exagerate) {
694 glTranslated(pos.x(), pos.y(), -.1);
696 std::string times = toString(STEPS2TIME(arrivalTime)) + "/" + toString(STEPS2TIME(leaveTime));
697 GLHelper::drawText(times.c_str(), Position(), .1, 1.6 * exagerate, RGBColor::GREEN, 0);
698 glTranslated(-pos.x(), -pos.y(), .1);
699}
700
701
704 RGBColor col;
705 const GUIColorer& c = s.vehicleColorer;
706 if (!setFunctionalColor(c.getActive(), &myVehicle, col)) {
707 col = c.getScheme().getColor(getColorValue(s, c.getActive()));
708 }
710 return col;
711}
712
713
714bool
715GUIBaseVehicle::setFunctionalColor(int activeScheme, const MSBaseVehicle* veh, RGBColor& col) {
716 switch (activeScheme) {
717 case 0: {
718 //test for emergency vehicle
720 col = RGBColor::WHITE;
721 return true;
722 }
723 //test for firebrigade
725 col = RGBColor::RED;
726 return true;
727 }
728 //test for police car
730 col = RGBColor::BLUE;
731 return true;
732 }
734 col = veh->getParameter().color;
735 return true;
736 }
738 col = veh->getVehicleType().getColor();
739 return true;
740 }
741 if (&(veh->getRoute().getColor()) != &RGBColor::DEFAULT_COLOR) {
742 col = veh->getRoute().getColor();
743 return true;
744 }
745 return false;
746 }
747 case 2: {
749 col = veh->getParameter().color;
750 return true;
751 }
752 return false;
753 }
754 case 3: {
756 col = veh->getVehicleType().getColor();
757 return true;
758 }
759 return false;
760 }
761 case 4: {
762 if (&(veh->getRoute().getColor()) != &RGBColor::DEFAULT_COLOR) {
763 col = veh->getRoute().getColor();
764 return true;
765 }
766 return false;
767 }
768 case 5: {
769 Position p = veh->getRoute().getEdges()[0]->getLanes()[0]->getShape()[0];
770 const Boundary& b = ((GUINet*) MSNet::getInstance())->getBoundary();
771 Position center = b.getCenter();
772 double hue = 180. + atan2(center.x() - p.x(), center.y() - p.y()) * 180. / M_PI;
773 double sat = p.distanceTo(center) / center.distanceTo(Position(b.xmin(), b.ymin()));
774 col = RGBColor::fromHSV(hue, sat, 1.);
775 return true;
776 }
777 case 6: {
778 Position p = veh->getRoute().getEdges().back()->getLanes()[0]->getShape()[-1];
779 const Boundary& b = ((GUINet*) MSNet::getInstance())->getBoundary();
780 Position center = b.getCenter();
781 double hue = 180. + atan2(center.x() - p.x(), center.y() - p.y()) * 180. / M_PI;
782 double sat = p.distanceTo(center) / center.distanceTo(Position(b.xmin(), b.ymin()));
783 col = RGBColor::fromHSV(hue, sat, 1.);
784 return true;
785 }
786 case 7: {
787 Position pb = veh->getRoute().getEdges()[0]->getLanes()[0]->getShape()[0];
788 Position pe = veh->getRoute().getEdges().back()->getLanes()[0]->getShape()[-1];
789 const Boundary& b = ((GUINet*) MSNet::getInstance())->getBoundary();
790 double hue = 180. + atan2(pb.x() - pe.x(), pb.y() - pe.y()) * 180. / M_PI;
791 Position minp(b.xmin(), b.ymin());
792 Position maxp(b.xmax(), b.ymax());
793 double sat = pb.distanceTo(pe) / minp.distanceTo(maxp);
794 col = RGBColor::fromHSV(hue, sat, 1.);
795 return true;
796 }
797 case 33: { // color randomly (by pointer hash)
798 std::hash<const MSBaseVehicle*> ptr_hash;
799 const double hue = (double)(ptr_hash(veh) % 360); // [0-360]
800 const double sat = (double)((ptr_hash(veh) / 360) % 67) / 100.0 + 0.33; // [0.33-1]
801 col = RGBColor::fromHSV(hue, sat, 1.);
802 return true;
803 }
804 case 34: { // color by angle
805 double hue = GeomHelper::naviDegree(veh->getAngle());
806 col = RGBColor::fromHSV(hue, 1., 1.);
807 return true;
808 }
809 }
810 return false;
811}
812
813
814double
816 switch (activeScheme) {
817 case 0: // uniform
818 return 0;
819 case 1: // selection
820 return myVehicle.isSelected();
821 case 2: // by speed
822 if (myVehicle.isStopped()) {
823 return myVehicle.isParking() ? -2 : -1;
824 }
825 return myVehicle.getSpeed();
826 case 3:
828 case 4: {
829 MSVehicle* microVeh = dynamic_cast<MSVehicle*>(&myVehicle);
830 return (microVeh != nullptr ? microVeh->getAccumulatedWaitingSeconds() : 0);
831 }
832 case 5: {
833 MSVehicle* microVeh = dynamic_cast<MSVehicle*>(&myVehicle);
834 return (microVeh != nullptr ? microVeh->getLane()->getVehicleMaxSpeed(microVeh) : myVehicle.getEdge()->getVehicleMaxSpeed(&myVehicle));
835 }
836 case 6:
838 case 7: {
839 MSVehicle* microVeh = dynamic_cast<MSVehicle*>(&myVehicle);
840 return (microVeh != nullptr
841 ? (microVeh->getLaneChangeModel().isOpposite() ? -100 : microVeh->getBestLaneOffset())
842 : 0);
843 }
844 case 8:
845 return myVehicle.getAcceleration();
846 case 9: {
847 MSVehicle* microVeh = dynamic_cast<MSVehicle*>(&myVehicle);
848 return (microVeh != nullptr ? microVeh->getTimeGapOnLane() : 0);
849 }
850 case 10:
852 case 11:
854 case 12:
855 return myVehicle.getStopDelay();
856 case 13:
858 case 14: // by numerical param value
859 std::string error;
860 std::string val = myVehicle.getPrefixedParameter(s.vehicleScaleParam, error);
861 try {
862 if (val == "") {
863 return 0;
864 } else {
865 return StringUtils::toDouble(val);
866 }
867 } catch (NumberFormatException&) {
868 try {
869 return StringUtils::toBool(val);
870 } catch (BoolFormatException&) {
871 WRITE_WARNING("Vehicle parameter '" + myVehicle.getParameter().getParameter(s.vehicleScaleParam, "0")
872 + "' key '" + s.vehicleScaleParam + "' is not a number for vehicle '" + myVehicle.getID() + "'");
873 return -1;
874 }
875 }
876 }
877 return 0;
878}
879
880
881// ------------ Additional visualisations
882bool
884 return myAdditionalVisualizations.find(parent) != myAdditionalVisualizations.end() && (myAdditionalVisualizations.find(parent)->second & which) != 0;
885}
886
887
888void
890 if (myAdditionalVisualizations.find(parent) == myAdditionalVisualizations.end()) {
891 myAdditionalVisualizations[parent] = 0;
892 }
893 myAdditionalVisualizations[parent] |= which;
894 parent->addAdditionalGLVisualisation(this);
895}
896
897
898void
900 myAdditionalVisualizations[parent] &= ~which;
901 if (myAdditionalVisualizations[parent] == 0) {
902 myAdditionalVisualizations.erase(parent);
903 }
905}
906
907
908void
909GUIBaseVehicle::drawRoute(const GUIVisualizationSettings& s, int routeNo, double darken, bool future, bool noLoop) const {
910 RGBColor vehColor = setColor(s);
911 RGBColor darker = vehColor.changedBrightness((int)(darken * -255));
912 if (darker == RGBColor::BLACK) {
913 darker = vehColor.multiply(1 - darken);
914 }
915 GLHelper::setColor(darker);
916 if (routeNo == 0) {
917 drawRouteHelper(s, myVehicle.getRoute(), future, noLoop, darker);
918 return;
919 }
920 const MSRoute* route = myRoutes->getRoute(routeNo - 1); // only prior routes are stored
921 if (route != nullptr) {
922 drawRouteHelper(s, *route, future, noLoop, darker);
923 }
924}
925
926
927void
928GUIBaseVehicle::drawStopLabels(const GUIVisualizationSettings& s, bool noLoop, const RGBColor& col) const {
929 // (vertical shift for repeated stops at the same position
930 std::map<const MSLane*, int> repeat; // count repeated occurrences of the same position
931 int stopIndex = 0;
932 for (const MSStop& stop : myVehicle.getStops()) {
933 double stopLanePos;
934 if (stop.getSpeed() > 0) {
935 stopLanePos = stop.reached ? stop.pars.endPos : stop.pars.startPos;
936 } else {
937 stopLanePos = stop.reached ? myVehicle.getPositionOnLane() : MAX2(0.0, stop.getEndPos(myVehicle));
938 }
939 if (stop.isOpposite && !stop.reached) {
940 stopLanePos = stop.lane->getLength() - stopLanePos;
941 }
942 Position pos = stop.lane->geometryPositionAtOffset(stopLanePos);
944 GLHelper::drawBoxLines(stop.lane->getShape().getOrthogonal(pos, 10, true, stop.lane->getWidth()), 0.1);
945 std::string label = (stop.getSpeed() > 0
946 ? (stop.reached ? "passing waypoint" : "waypoint ")
947 : (stop.reached ? "stopped" : "stop "));
948 if (!stop.reached) {
949 label += toString(stopIndex);
950 }
951
952 if (stop.isOpposite) {
953 label += " (opposite)";
954 }
955#ifdef _DEBUG
956 label += " (" + toString(stop.edge - myVehicle.getCurrentRouteEdge()) + "e)";
957#endif
959 label += " triggered:";
960 if (stop.triggered) {
961 label += "person";
962 if (stop.numExpectedPerson > 0) {
963 label += "(" + toString(stop.numExpectedPerson) + ")";
964 }
965 }
966 if (stop.containerTriggered) {
967 label += "container";
968 if (stop.numExpectedContainer > 0) {
969 label += "(" + toString(stop.numExpectedContainer) + ")";
970 }
971 }
972 if (stop.joinTriggered) {
973 label += "join";
974 if (stop.pars.join != "") {
975 label += "(" + stop.pars.join + ")";
976 }
977 }
978 }
979 if (stop.pars.until >= 0) {
980 label += " until:" + time2string(stop.pars.until);
981 }
982 if (stop.duration >= 0 || stop.pars.duration > 0) {
983 if (STEPS2TIME(stop.duration) > 3600 * 24) {
984 label += " duration:1day+";
985 } else {
986 label += " duration:" + time2string(stop.duration);
987 }
988 }
989 if (stop.getSpeed() > 0) {
990 if (stop.skipOnDemand) {
991 label += " onDemand (skipped)";
992 } else {
993 label += " speed:" + toString(stop.getSpeed());
994 }
995 }
996 if (stop.pars.actType != "") {
997 label += " actType:" + stop.pars.actType;
998 }
999 const double nameSize = s.vehicleName.size / s.scale;
1000 Position pos2 = pos - Position(0, nameSize * repeat[stop.lane]);
1001 if (noLoop && repeat[stop.lane] > 0) {
1002 break;
1003 }
1004 GLHelper::drawTextSettings(s.vehicleText, label, pos2, s.scale, s.angle, 1.0);
1005 repeat[stop.lane]++;
1006 stopIndex++;
1007 }
1008 // indicate arrivalPos if set
1010 const int arrivalEdge = myVehicle.getParameter().arrivalEdge >= 0
1012 : (int)myVehicle.getRoute().getEdges().size() - 1;
1013 const MSLane* arrivalLane = myVehicle.getRoute().getEdges()[arrivalEdge]->getLanes()[MAX2(0, myVehicle.getArrivalLane())];
1015 GLHelper::setColor(col);
1016 GLHelper::drawBoxLines(arrivalLane->getShape().getOrthogonal(pos, 10, true, arrivalLane->getWidth() * 0.5, 90), 0.1);
1017 GLHelper::drawBoxLines(arrivalLane->getShape().getOrthogonal(pos, 10, true, arrivalLane->getWidth() * 0.5, 270), 0.1);
1018 GLHelper::drawTextSettings(s.vehicleText, "arrival", pos, s.scale, s.angle, 1.0);
1019
1020 }
1021}
1022
1023void
1025 if (s.showParkingInfo) {
1027 if (pm != nullptr) {
1028 for (auto item : *pm) {
1029 const GUIParkingArea* pa = dynamic_cast<const GUIParkingArea*>(item.first);
1030 if (item.second.blockedAtTime >= 0) {
1031 std::string seenAgo = time2string(SIMSTEP - item.second.blockedAtTime);
1032 //if (item.second.blockedAtTime >= 0) {
1033 // seenAgo += ", " + time2string(SIMSTEP - item.second.blockedAtTimeLocal);
1034 //}
1035 GLHelper::drawTextSettings(s.vehicleValue, seenAgo, pa->getSignPos(), s.scale, s.angle, 1.0);
1036 }
1037 if (item.second.score != "") {
1038 const double dist = 0.4 * (s.vehicleText.scaledSize(s.scale) + s.vehicleValue.scaledSize(s.scale));
1039 Position shift(0, -dist);
1040 GLHelper::drawTextSettings(s.vehicleText, item.second.score, pa->getSignPos() + shift, s.scale, s.angle, 1.0);
1041 }
1042 }
1043 }
1044 }
1045}
1046
1048GUIBaseVehicle::getSeatPosition(int personIndex) const {
1050 return mySeatPositions[MIN2(personIndex, (int)mySeatPositions.size() - 1)];
1051}
1052
1054GUIBaseVehicle::getContainerPosition(int containerIndex) const {
1056 return myContainerPositions[MIN2(containerIndex, (int)myContainerPositions.size() - 1)];
1057}
1058
1059
1060void
1062 if (myVehicle.myPersonDevice != nullptr) {
1063 const std::vector<MSTransportable*>& ps = myVehicle.myPersonDevice->getTransportables();
1064 int personIndex = 0;
1065 for (std::vector<MSTransportable*>::const_iterator i = ps.begin(); i != ps.end(); ++i) {
1066 GUIPerson* person = dynamic_cast<GUIPerson*>(*i);
1067 assert(person != 0);
1068 person->setPositionInVehicle(getSeatPosition(personIndex++));
1069 person->drawGL(s);
1070 }
1071 }
1072 if (myVehicle.myContainerDevice != nullptr) {
1073 const std::vector<MSTransportable*>& cs = myVehicle.myContainerDevice->getTransportables();
1074 int containerIndex = 0;
1075 for (std::vector<MSTransportable*>::const_iterator i = cs.begin(); i != cs.end(); ++i) {
1076 GUIContainer* container = dynamic_cast<GUIContainer*>(*i);
1077 assert(container != 0);
1078 container->setPositionInVehicle(getContainerPosition(containerIndex++));
1079 container->drawGL(s);
1080 }
1081 }
1082#ifdef DRAW_BOUNDING_BOX
1084 MSVehicle& microVeh = dynamic_cast<MSVehicle&>(myVehicle);
1087 glTranslated(0, 0, getType());
1088 PositionVector smallBB = microVeh.getBoundingPoly();
1089 glColor3d(0.5, .8, 0);
1090 GLHelper::drawBoxLines(smallBB, 0.3);
1091 glTranslated(0, 0, 0.1);
1092 PositionVector boundingBox = microVeh.getBoundingBox();
1093 boundingBox.push_back(boundingBox.front());
1094 glColor3d(1, 0, 0);
1095 GLHelper::drawBoxLines(boundingBox, 0.15);
1098 }
1099#endif
1100}
1101
1102
1103bool
1105 if (getVType().getParameter().carriageLength > 0) {
1106 drawAction_drawCarriageClass(s, asImage);
1107 return true;
1108 } else {
1110 s, getVType().getImgFile(), this, getVType().getWidth(), scaledLength)) {
1111 return false;
1112 }
1113 GUIBaseVehicleHelper::drawAction_drawVehicleAsPoly(s, getVType().getGuiShape(), getVType().getWidth(), scaledLength, -1, myVehicle.isStopped());
1114 return false;
1115 }
1116}
1117
1118
1119int
1121 if (myVehicle.getPersonDevice() != nullptr) {
1122 return (int)myVehicle.getPersonDevice()->size();
1123 }
1124 return 0;
1125}
1126
1127
1128int
1130 if (myVehicle.getContainerDevice() != nullptr) {
1131 return (int)myVehicle.getContainerDevice()->size();
1132 }
1133 return 0;
1134}
1135
1136std::string
1138 std::vector<std::string> devs;
1139 for (MSDevice* d : myVehicle.getDevices()) {
1140 devs.push_back(d->deviceName());
1141 }
1142 return joinToString(devs, " ");
1143}
1144
1145
1146void
1147GUIBaseVehicle::computeSeats(const Position& front, const Position& back, double seatOffset, int maxSeats, double exaggeration, int& requiredSeats, Seats& into) const {
1148 if (requiredSeats <= 0) {
1149 return;
1150 }
1151 maxSeats = MAX2(maxSeats, 1); // compute at least one seat
1152 seatOffset *= exaggeration;
1153 const double vehWidth = getVType().getWidth() * exaggeration;
1154 const double length = front.distanceTo2D(back);
1155 const int rowSize = MAX2(1, (int)floor(vehWidth / seatOffset));
1156 const double rowOffset = MAX2(1.0, (length - getVType().getFrontSeatPos() - 1)) / ceil((double)maxSeats / rowSize);
1157 const double sideOffset = (rowSize - 1) / 2.0 * seatOffset;
1158 double rowPos = getVType().getFrontSeatPos() - rowOffset;
1159 double angle = back.angleTo2D(front);
1160 const int fillDirection = MSGlobals::gLefthand ? -1 : 1;
1161 //if (myVehicle.getID() == "v0") std::cout << SIMTIME << " seatOffset=" << seatOffset << " max=" << maxSeats << " ex=" << exaggeration << " req=" << requiredSeats << " rowSize=" << rowSize << " sideOffset=" << sideOffset << " front=" << front << " back=" << back << " a=" << angle << " da=" << RAD2DEG(angle) << "\n";
1162 for (int i = 0; requiredSeats > 0 && i < maxSeats; i++) {
1163 int seat = (i % rowSize);
1164 if (seat == 0) {
1165 rowPos += rowOffset;
1166 }
1167 into.push_back(Seat(PositionVector::positionAtOffset2D(front, back, rowPos, (sideOffset - seat * seatOffset) * fillDirection), angle));
1168 requiredSeats--;
1169 }
1170}
1171
1172
1173/****************************************************************************/
long long int SUMOTime
Definition: GUI.h:36
@ MID_HIDE_ALLROUTES
Hide all vehicle's routes.
Definition: GUIAppEnum.h:502
@ MID_HIDE_BEST_LANES
Hide vehicle's best lanes.
Definition: GUIAppEnum.h:498
@ MID_HIDE_CURRENTROUTE
Hide vehicle's current route.
Definition: GUIAppEnum.h:486
@ MID_SHOW_FOES
select foes of a vehicle
Definition: GUIAppEnum.h:508
@ MID_SHOW_BEST_LANES
Show vehicle's best lanes.
Definition: GUIAppEnum.h:496
@ MID_START_TRACK
Start to track a vehicle.
Definition: GUIAppEnum.h:504
@ MID_SHOW_ALLROUTES
Show all vehicle's routes.
Definition: GUIAppEnum.h:500
@ MID_SHOW_LFLINKITEMS
Definition: GUIAppEnum.h:509
@ MID_SHOW_ROUTE_NOLOOPS
Show vehicle's future route (without loops)
Definition: GUIAppEnum.h:492
@ MID_HIDE_ROUTE_NOLOOPS
Hide vehicle's future route (without loops)
Definition: GUIAppEnum.h:494
@ MID_TOGGLE_STOP
toggle stop state of a vehicle or person
Definition: GUIAppEnum.h:514
@ MID_HIDE_LFLINKITEMS
Definition: GUIAppEnum.h:510
@ MID_REMOVE_OBJECT
remove a vehicle or person
Definition: GUIAppEnum.h:516
@ MID_SHOW_FUTUREROUTE
Show vehicle's future route.
Definition: GUIAppEnum.h:488
@ MID_HIDE_FUTUREROUTE
Hide vehicle's future route.
Definition: GUIAppEnum.h:490
@ MID_SHOW_CURRENTROUTE
Show vehicle's current route.
Definition: GUIAppEnum.h:484
@ MID_STOP_TRACK
Stop to track a vehicle.
Definition: GUIAppEnum.h:506
@ MID_SELECT_TRANSPORTED
select transportables of a vehicle
Definition: GUIAppEnum.h:512
FXDEFMAP(GUIBaseVehicle::GUIBaseVehiclePopupMenu) GUIBaseVehiclePopupMenuMap[]
@ GLO_VEHICLE
a vehicle
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
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:265
#define TL(string)
Definition: MsgHandler.h:282
std::string time2string(SUMOTime t)
convert SUMOTime to string
Definition: SUMOTime.cpp:68
#define STEPS2TIME(x)
Definition: SUMOTime.h:54
#define SIMSTEP
Definition: SUMOTime.h:60
#define TIME2STEPS(x)
Definition: SUMOTime.h:56
const long long int VTYPEPARS_COLOR_SET
@ RAIL_CARGO
render as a cargo train
@ EMERGENCY
render as an emergency vehicle
@ RAIL
render as a rail
@ SCOOTER
render as a scooter
@ RAIL_CAR
render as a (city) rail without locomotive
@ SHIP
render as a arbitrary ship
@ BICYCLE
render as a bicycle
@ MOTORCYCLE
render as a motorcycle
@ ANT
render as a giant ant
@ FIREBRIGADE
render as a fire brigade
@ MOPED
render as a moped
@ POLICE
render as a police car
@ PEDESTRIAN
render as a pedestrian
const int VEHPARS_COLOR_SET
const int VEHPARS_ARRIVALPOS_SET
T MIN2(T a, T b)
Definition: StdDefs.h:71
T MAX2(T a, T b)
Definition: StdDefs.h:77
const double SUMO_const_waitingContainerWidth
Definition: StdDefs.h:54
const double SUMO_const_waitingPersonWidth
Definition: StdDefs.h:52
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
Definition: ToString.h:282
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
Position getCenter() const
Returns the center of the boundary.
Definition: Boundary.cpp:112
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
Definition: Boundary.cpp:78
double ymin() const
Returns minimum y-coordinate.
Definition: Boundary.cpp:130
double xmin() const
Returns minimum x-coordinate.
Definition: Boundary.cpp:118
Boundary & grow(double by)
extends the boundary by the given amount
Definition: Boundary.cpp:300
double ymax() const
Returns maximum y-coordinate.
Definition: Boundary.cpp:136
double xmax() const
Returns maximum x-coordinate.
Definition: Boundary.cpp:124
static void setColor(const RGBColor &c)
Sets the gl-color to this value.
Definition: GLHelper.cpp:583
static void drawFilledCircle(double width, int steps=8)
Draws a filled circle around (0,0)
Definition: GLHelper.cpp:498
static void pushName(unsigned int name)
push Name
Definition: GLHelper.cpp:139
static void drawOutlineCircle(double width, double iwidth, int steps=8)
Draws an unfilled circle around (0,0)
Definition: GLHelper.cpp:525
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 void popName()
pop Name
Definition: GLHelper.cpp:148
static void pushMatrix()
push matrix
Definition: GLHelper.cpp:117
static void drawText(const std::string &text, const Position &pos, const double layer, const double size, const RGBColor &col=RGBColor::BLACK, const double angle=0, const int align=0, double width=-1)
Definition: GLHelper.cpp:685
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
long onCmdHideFutureRoute(FXObject *, FXSelector, void *)
Called if the current route of the vehicle shall be hidden.
long onCmdStartTrack(FXObject *, FXSelector, void *)
Called if the vehicle shall be tracked.
long onCmdHideBestLanes(FXObject *, FXSelector, void *)
Called if the vehicle's best lanes shall be hidden.
long onCmdHideCurrentRoute(FXObject *, FXSelector, void *)
Called if the current route of the vehicle shall be hidden.
long onCmdShowBestLanes(FXObject *, FXSelector, void *)
Called if the vehicle's best lanes shall be shown.
long onCmdShowRouteNoLoops(FXObject *, FXSelector, void *)
Called if the current route of the vehicle shall be shown.
long onCmdShowLFLinkItems(FXObject *, FXSelector, void *)
Called if all routes of the vehicle shall be shown.
long onCmdShowFoes(FXObject *, FXSelector, void *)
Called to show (select) a vehicles foes.
long onCmdHideRouteNoLoops(FXObject *, FXSelector, void *)
Called if the current route of the vehicle shall be hidden.
long onCmdShowFutureRoute(FXObject *, FXSelector, void *)
Called if the current route of the vehicle shall be shown.
long onCmdShowAllRoutes(FXObject *, FXSelector, void *)
Called if all routes of the vehicle shall be shown.
long onCmdToggleStop(FXObject *, FXSelector, void *)
Called when toggling stop state.
long onCmdStopTrack(FXObject *, FXSelector, void *)
Called if the current shall not be tracked any longer.
long onCmdSelectTransported(FXObject *, FXSelector, void *)
Called to select all riding persons and containers.
long onCmdRemoveObject(FXObject *, FXSelector, void *)
Called when removing the vehicle.
long onCmdHideAllRoutes(FXObject *, FXSelector, void *)
Called if all routes of the vehicle shall be hidden.
long onCmdHideLFLinkItems(FXObject *, FXSelector, void *)
Called if all routes of the vehicle shall be hidden.
long onCmdShowCurrentRoute(FXObject *, FXSelector, void *)
Called if the current route of the vehicle shall be shown.
static void drawAction_drawVehicleAsTrianglePlus(const double width, const double length)
draw vehicle as a triangle
static bool drawAction_drawVehicleAsImage(const GUIVisualizationSettings &s, const std::string &file, const GUIGlObject *o, const double width, double length)
try to draw vehicle as raster image and return true if successful
static void drawAction_drawVehicleAsCircle(const double width, double detail)
draw vehicle as a circle
static void drawAction_drawVehicleAsPoly(const GUIVisualizationSettings &s, const SUMOVehicleShape shape, const double width, const double length, int carriageIndex=-1, bool isStopped=false)
draw vehicle as a polygon
static void drawAction_drawVehicleAsBoxPlus(const double width, const double length)
draw vehicle as a Box
A MSVehicle extended by some values for usage within the gui.
void drawParkingInfo(const GUIVisualizationSettings &s, const RGBColor &col) const
const Seat & getContainerPosition(int containerIndex) const
static bool setFunctionalColor(int activeScheme, const MSBaseVehicle *veh, RGBColor &col)
sets the color according to the current scheme index and some vehicle function
const std::string getOptionalName() const
Returns the value for generic parameter 'name' or ''.
virtual void drawAction_drawLinkItems(const GUIVisualizationSettings &) const
const Seat & getSeatPosition(int personIndex) const
returns the seat position for the person with the given index
RGBColor setColor(const GUIVisualizationSettings &s) const
sets the color according to the current settings
int getNumContainers() const
return the number of passengers
void drawOnPos(const GUIVisualizationSettings &s, const Position &pos, const double angle) const
Draws the object on the specified position with the specified angle.
GUIGLObjectPopupMenu * myPopup
current popup (to clean up in destructor). GUIBaseVehicle is not responsible for removal
GUIBaseVehicle(MSBaseVehicle &vehicle)
MSDevice_Vehroutes * myRoutes
virtual void drawAction_drawPersonsAndContainers(const GUIVisualizationSettings &s) const
bool hasActiveAddVisualisation(GUISUMOAbstractView *const parent, int which) const
Returns whether the named feature is enabled in the given view.
void removeActiveAddVisualisation(GUISUMOAbstractView *const parent, int which)
Adds the named visualisation feature to the given view.
void drawRoute(const GUIVisualizationSettings &s, int routeNo, double darken, bool future=false, bool noLoop=false) const
Chooses the route to draw and draws it, darkening it as given.
std::vector< Seat > Seats
MSBaseVehicle & myVehicle
The vehicle to which all calls should be delegated.
virtual void drawAction_drawVehicleBlinker(double) const
void removedPopupMenu()
notify object about popup menu removal
void addActiveAddVisualisation(GUISUMOAbstractView *const parent, int which)
Adds the named visualisation feature to the given view.
static void drawLinkItem(const Position &pos, SUMOTime arrivalTime, SUMOTime leaveTime, double exagerate)
double getScaleValue(const GUIVisualizationSettings &s, int activeScheme) const
gets the size multiplier value according to the current scheme index
virtual void drawBestLanes() const
Draws the vehicle's best lanes.
GUIGLObjectPopupMenu * getPopUpMenu(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own popup-menu.
void computeSeats(const Position &front, const Position &back, double seatOffset, int maxSeats, double exaggeration, int &requiredSeats, Seats &into) const
add seats to mySeatPositions and update requiredSeats
virtual Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
@ VO_SHOW_LFLINKITEMS
LFLinkItems.
@ VO_SHOW_ALL_ROUTES
show all vehicle's routes
@ VO_SHOW_ROUTE_NOLOOP
show vehicle's routes without loops
@ VO_SHOW_FUTURE_ROUTE
show vehicle's current continued from the current position
@ VO_SHOW_ROUTE
show vehicle's current route
@ VO_SHOW_BEST_LANES
show vehicle's best lanes
virtual void drawAction_drawCarriageClass(const GUIVisualizationSettings &s, bool asImage) const =0
draws the given guiShape with distinct carriages/modules
virtual void drawGLAdditional(GUISUMOAbstractView *const parent, const GUIVisualizationSettings &s) const
Draws additionally triggered visualisations.
Seats myContainerPositions
virtual double getAngle() const =0
Returns the vehicle's direction in radians.
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
FXMutex myLock
The mutex used to avoid concurrent updates of the vehicle buffer.
virtual void drawAction_drawVehicleBrakeLight(double length, bool onlyOne=false) const
virtual double getColorValue(const GUIVisualizationSettings &s, int activeScheme) const =0
gets the color value according to the current scheme index
int getNumPassengers() const
return the number of passengers
bool drawAction_drawVehicleAsPolyWithCarriagges(const GUIVisualizationSettings &s, double scaledLength, bool asImage=false) const
draw vehicle body and return whether carriages are being drawn
virtual Position getPosition(const double offset=0) const =0
Return current position (x/y, cartesian)
~GUIBaseVehicle()
destructor
double getExaggeration(const GUIVisualizationSettings &s) const
return exaggeration associated with this GLObject
virtual void drawAction_drawVehicleBlueLight() const
virtual void drawRouteHelper(const GUIVisualizationSettings &s, const MSRoute &r, bool future, bool noLoop, const RGBColor &col) const =0
Draws the route.
std::map< GUISUMOAbstractView *, int > myAdditionalVisualizations
Enabled visualisations, per view.
virtual void selectBlockingFoes() const =0
adds the blocking foes to the current selection
void drawStopLabels(const GUIVisualizationSettings &s, bool noLoop, const RGBColor &col) const
Seats mySeatPositions
positions of seats in the vehicle (updated at every drawing step)
const MSBaseVehicle & getVehicle()
std::string getDeviceDescription()
lists equipped device (types) for the current vehicle
const MSVehicleType & getVType() const
A shortcut to myVehicle.myType.
void setPositionInVehicle(const GUIBaseVehicle::Seat &pos)
Definition: GUIContainer.h:113
void drawGL(const GUIVisualizationSettings &s) const override
Draws the object.
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.
GUISUMOAbstractView * getParentView()
return the real owner of this popup
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
A MSNet extended by some values for usage within the gui.
Definition: GUINet.h:82
A lane area vehicles can halt at (gui-version)
const Position & getSignPos() const
void setPositionInVehicle(const GUIBaseVehicle::Seat &pos)
Definition: GUIPerson.cpp:374
void drawGL(const GUIVisualizationSettings &s) const override
Draws the object.
Definition: GUIPerson.cpp:285
const T getColor(const double value) const
bool removeAdditionalGLVisualisation(GUIGlObject *const which)
Removes an object from the list of objects that show additional things.
void destroyPopup()
destroys the popup
bool addAdditionalGLVisualisation(GUIGlObject *const which)
Adds an object to call its additional visualisation method.
virtual GUIGlID getTrackedID() const
get tracked id
void select(GUIGlID id, bool update=true)
Adds the object with the given id.
Stores the information about how to visualize structures.
GUIVisualizationTextSettings vehicleName
GUIVisualizationSizeSettings vehicleSize
bool showBlinker
Information whether vehicle blinkers shall be drawn.
GUIColorer vehicleColorer
The vehicle colorer.
GUIVisualizationTextSettings vehicleScaleValue
std::string vehicleScaleParam
key for scaling by vehicle parameter
bool showParkingInfo
Set whether parking related information should be shown.
GUIVisualizationTextSettings vehicleValue
int vehicleQuality
The quality of vehicle drawing.
double laneWidthExaggeration
The lane exaggeration (upscale thickness)
std::string vehicleTextParam
key for rendering vehicle textual parameter
bool scaleLength
Whether vehicle length shall be scaled with length/geometry factor.
GUIScaler vehicleScaler
The size scaling settings for vehicles.
double scale
information about a lane's width (temporary, used for a single view)
bool drawMinGap
Information whether the minimum gap shall be drawn.
GUIVisualizationTextSettings vehicleText
bool showBTRange
Information whether the communication range shall be drawn.
bool drawBrakeGap
Information whether the brake gap shall be drawn.
bool drawLaneChangePreference
Information whether the lane change preference shall be drawn.
double angle
The current view rotation angle.
static double naviDegree(const double angle)
Definition: GeomHelper.cpp:192
void vaporizeCar(MEVehicle *v, MSMoveReminder::Notification reason)
remove the given car and clean up the relevant data structures
Definition: MELoop.cpp:240
A vehicle from the mesoscopic point of view.
Definition: MEVehicle.h:42
The base class for microscopic and mesoscopic vehicles.
Definition: MSBaseVehicle.h:55
MSVehicleDevice * getDevice(const std::type_info &type) const
Returns a device of the given type if it exists or 0.
virtual bool isSelected() const
whether this vehicle is selected in the GUI
const std::vector< MSTransportable * > & getPersons() const
retrieve riding persons
std::map< const MSParkingArea *, PaMemory, ComparatorIdLess > ParkingMemory
const std::vector< MSVehicleDevice * > & getDevices() const
Returns this vehicle's devices.
virtual double getArrivalPos() const
Returns this vehicle's desired arrivalPos for its current route (may change on reroute)
virtual double getStopDelay() const
Returns the estimated public transport stop (departure) delay in seconds.
MoveReminderCont myMoveReminders
Currently relevant move reminders.
const SUMOVehicleParameter & getParameter() const
Returns the vehicle's parameter (including departure definition)
int getNumberParkingReroutes() const
std::vector< MSVehicleDevice * > myDevices
The devices this vehicle has.
virtual const MSEdge * getCurrentEdge() const
Returns the edge the vehicle is currently at (possibly an internal edge)
virtual double getTimeLossSeconds() const
Returns the time loss in seconds.
const MSRouteIterator & getCurrentRouteEdge() const
Returns an iterator pointing to the current edge in this vehicles route.
bool isParking() const
Returns whether the vehicle is parking.
const MSEdge * getEdge() const
Returns the edge the vehicle is currently at.
virtual int getArrivalLane() const
MSDevice_Transportable * myContainerDevice
The containers this vehicle may have.
const std::list< MSStop > & getStops() const
double getWaitingSeconds() const
Returns the number of seconds waited (speed was lesser than 0.1m/s)
const MSDevice_Transportable * getPersonDevice() const
MSDevice_Transportable * myPersonDevice
The passengers this vehicle may have.
std::string getPrefixedParameter(const std::string &key, std::string &error) const
retrieve parameters of devices, models and the vehicle itself
virtual double getStopArrivalDelay() const
Returns the estimated public transport stop arrival delay in seconds.
bool isStoppedTriggered() const
Returns whether the vehicle is on a triggered stop.
virtual double getAcceleration() const
Returns the vehicle's acceleration.
virtual double getRightSideOnEdge(const MSLane *lane=0) const
Get the vehicle's lateral position on the edge of the given lane (or its current edge if lane == 0)
const MSRoute & getRoute() const
Returns the current route.
const MSDevice_Transportable * getContainerDevice() const
SUMOTime getDepartDelay() const
Returns the depart delay.
int getNumberReroutes() const
Returns the number of new routes this vehicle got.
virtual bool isOnRoad() const
Returns the information whether the vehicle is on a road (is simulated)
const std::vector< MSTransportable * > & getContainers() const
retrieve riding containers
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
bool isStopped() const
Returns whether the vehicle is at a stop.
const ParkingMemory * getParkingMemory() const
double brakeGap(const double speed) const
Returns the distance the vehicle needs to halt including driver's reaction time tau (i....
Definition: MSCFModel.h:373
static double getRange()
Returns the configured range.
const std::vector< MSTransportable * > & getTransportables() const
Returns the list of transportables using this vehicle.
int size() const
Return the number of passengers / containers.
static MSDevice_Vehroutes * buildVehicleDevices(SUMOVehicle &v, std::vector< MSVehicleDevice * > &into, int maxRoutes=std::numeric_limits< int >::max())
Build devices for the given vehicle, if needed.
const MSRoute * getRoute(int index) const
Called on route retrieval.
Abstract in-vehicle / in-person device.
Definition: MSDevice.h:61
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
Definition: MSEdge.h:168
double getWidth() const
Returns the edges's width (sum over all lanes)
Definition: MSEdge.h:629
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the maximum speed the vehicle may use on this edge.
Definition: MSEdge.cpp:1068
static bool gUseMesoSim
Definition: MSGlobals.h:103
static MELoop * gMesoNet
mesoscopic simulation infrastructure
Definition: MSGlobals.h:109
static bool gLefthand
Whether lefthand-drive is being simulated.
Definition: MSGlobals.h:168
Representation of a lane in the micro simulation.
Definition: MSLane.h:84
virtual MSVehicle * removeVehicle(MSVehicle *remVehicle, MSMoveReminder::Notification notification, bool notify=true)
Definition: MSLane.cpp:2503
const PositionVector & getShape() const
Returns this lane's shape.
Definition: MSLane.h:506
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the lane's maximum speed, given a vehicle's speed limit adaptation.
Definition: MSLane.h:547
virtual const VehCont & getVehiclesSecure() const
Returns the vehicles container; locks it for microsimulation.
Definition: MSLane.h:456
virtual void releaseVehicles() const
Allows to use the container for microsimulation again.
Definition: MSLane.h:486
double getLengthGeometryFactor() const
return shape.length() / myLength
Definition: MSLane.h:511
double getWidth() const
Returns the lane's width.
Definition: MSLane.h:590
const Position geometryPositionAtOffset(double offset, double lateralOffset=0) const
Definition: MSLane.h:533
@ NOTIFICATION_VAPORIZED_GUI
The vehicle got removed via the GUI.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:183
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition: MSNet.h:379
const ConstMSEdgeVector & getEdges() const
Definition: MSRoute.h:124
const RGBColor & getColor() const
Returns the color.
Definition: MSRoute.cpp:406
Definition: MSStop.h:44
void scheduleVehicleRemoval(SUMOVehicle *veh, bool checkDuplicate=false)
Removes a vehicle after it has ended.
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:77
double getTimeGapOnLane() const
Returns the time gap in seconds to the leader of the vehicle on the same lane.
Definition: MSVehicle.cpp:6130
PositionVector getBoundingPoly(double offset=0) const
get bounding polygon
Definition: MSVehicle.cpp:6552
double getAccumulatedWaitingSeconds() const
Returns the number of seconds waited (speed was lesser than 0.1m/s) within the last millisecs.
Definition: MSVehicle.h:708
MSAbstractLaneChangeModel & getLaneChangeModel()
Definition: MSVehicle.cpp:5367
bool addTraciStop(SUMOVehicleParameter::Stop stop, std::string &errorMsg)
Definition: MSVehicle.cpp:6677
PositionVector getBoundingBox(double offset=0) const
get bounding rectangle
Definition: MSVehicle.cpp:6521
void onRemovalFromNet(const MSMoveReminder::Notification reason)
Called when the vehicle is removed from the network.
Definition: MSVehicle.cpp:1015
bool resumeFromStopping()
Definition: MSVehicle.cpp:6715
int getBestLaneOffset() const
Definition: MSVehicle.cpp:6019
const MSLane * getLane() const
Returns the lane the vehicle is on.
Definition: MSVehicle.h:577
MSLane * getMutableLane() const
Returns the lane the vehicle is on Non const version indicates that something volatile is going on.
Definition: MSVehicle.h:585
std::pair< const MSLane *, double > getLanePosAfterDist(double distance) const
return lane and position along bestlanes at the given distance
Definition: MSVehicle.cpp:6054
double getSpeed() const
Returns the vehicle's current speed.
Definition: MSVehicle.h:486
const MSCFModel & getCarFollowModel() const
Returns the vehicle's car following model definition.
Definition: MSVehicle.h:966
double getWidth() const
Get the width which vehicles of this class shall have when being drawn.
double getMinGap() const
Get the free space in front of vehicles of this class.
double getFrontSeatPos() const
Get offset of first seat from vehicle front.
double getLength() const
Get vehicle's length [m].
SUMOVehicleShape getGuiShape() const
Get this vehicle type's shape.
bool wasSet(int what) const
Returns whether the given parameter was set.
Definition: MSVehicleType.h:80
const RGBColor & getColor() const
Returns this type's color.
const std::string & getID() const
Returns the id.
Definition: Named.h:74
virtual const std::string getParameter(const std::string &key, const std::string defaultValue="") const
Returns the value for a given key.
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
double distanceTo2D(const Position &p2) const
returns the euclidean distance in the x-y-plane
Definition: Position.h:252
double distanceTo(const Position &p2) const
returns the euclidean distance in 3 dimension
Definition: Position.h:242
double x() const
Returns the x-position.
Definition: Position.h:55
double angleTo2D(const Position &other) const
returns the angle in the plane of the vector pointing from here to the other position
Definition: Position.h:262
double y() const
Returns the y-position.
Definition: Position.h:60
A list of positions.
PositionVector getOrthogonal(const Position &p, double extend, bool before, double length=1.0, double deg=90) const
return orthogonal through p (extending this vector if necessary)
Position positionAtOffset2D(double pos, double lateralOffset=0) const
Returns the position at the given length.
static const RGBColor WHITE
Definition: RGBColor.h:192
static const RGBColor BLUE
Definition: RGBColor.h:187
unsigned char alpha() const
Returns the alpha-amount of the color.
Definition: RGBColor.cpp:92
RGBColor multiply(double factor) const
Returns a new color with altered brightness.
Definition: RGBColor.cpp:230
static const RGBColor GREEN
Definition: RGBColor.h:186
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
static const RGBColor BLACK
Definition: RGBColor.h:193
RGBColor changedBrightness(int change, int toChange=3) const
Returns a new color with altered brightness.
Definition: RGBColor.cpp:200
static const RGBColor DEFAULT_COLOR
The default color (for vehicle types and vehicles)
Definition: RGBColor.h:199
static const RGBColor RED
named colors
Definition: RGBColor.h:185
virtual const MSLane * getLane() const =0
Returns the lane the object is currently at.
virtual double getSpeed() const =0
Returns the object's current speed.
virtual double getPositionOnLane() const =0
Get the object's position along the lane.
virtual double getAngle() const =0
Get the vehicle's angle.
Definition of vehicle stop (position and duration)
std::string lane
The lane to stop at.
double startPos
The stopping position start.
double endPos
The stopping position end.
SUMOTime duration
The stopping duration.
RGBColor color
The vehicle's color, TraCI may change this.
bool wasSet(int what) const
Returns whether the given parameter was set.
int arrivalEdge
(optional) The final edge within the route of the vehicle
std::string line
The vehicle's line (mainly for public transport)
static const int NEWLINE
identifier for splitting the given string at all newline characters
std::vector< std::string > getVector()
return vector of strings
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
static bool toBool(const std::string &sData)
converts a string into the bool value described by it by calling the char-type converter
#define M_PI
Definition: odrSpiral.cpp:45
double getExaggeration(const GUIVisualizationSettings &s, const GUIGlObject *o, double factor=20) const
return the drawing size including exaggeration and constantSize values
bool constantSizeSelected
whether only selected objects shall be drawn with constant
bool show(const GUIGlObject *o) const
whether to show the text
double scaledSize(double scale, double constFactor=0.1) const
get scale size