Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
GUIVehicle.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
20// A MSVehicle extended by some values for usage within the gui
21/****************************************************************************/
22#include <config.h>
23
24#include <cmath>
25#include <vector>
26#include <string>
27#include <bitset>
44#include <microsim/MSGlobals.h>
45#include <microsim/MSVehicle.h>
46#include <microsim/MSJunction.h>
47#include <microsim/MSLane.h>
48#include <microsim/MSLink.h>
49#include <microsim/MSStop.h>
64#include <gui/GUIGlobals.h>
65#include "GUIVehicle.h"
66#include "GUIPerson.h"
67#include "GUIContainer.h"
68#include "GUINet.h"
69#include "GUIEdge.h"
70#include "GUILane.h"
71
72#define SPEEDMODE_DEFAULT 31
73#define LANECHANGEMODE_DEFAULT 1621
74
75//#define DEBUG_FOES
76
77// ===========================================================================
78// FOX callback mapping
79// ===========================================================================
80
81// Object implementation
82
83
84/* -------------------------------------------------------------------------
85 * GUIVehicle - methods
86 * ----------------------------------------------------------------------- */
87
89 MSVehicleType* type, const double speedFactor) :
90 MSVehicle(pars, route, type, speedFactor),
91 GUIBaseVehicle((MSBaseVehicle&) * this) {
92}
93
94
97
98
102 const bool isElecHybrid = getDevice(typeid(MSDevice_ElecHybrid)) != nullptr ? true : false;
103 const bool hasBattery = getDevice(typeid(MSDevice_Battery)) != nullptr;
105 // add items
106 ret->mkItem(TL("lane [id]"), true, new FunctionBindingString<GUIVehicle>(this, &GUIVehicle::getLaneID));
108 ret->mkItem(TL("shadow lane [id]"), true, new FunctionBindingString<GUIVehicle>(this, &GUIVehicle::getShadowLaneID));
109 }
111 ret->mkItem(TL("target lane [id]"), true, new FunctionBindingString<GUIVehicle>(this, &GUIVehicle::getTargetLaneID));
112 }
113 if (isSelected()) {
114 ret->mkItem(TL("back lanes [id,..]"), true, new FunctionBindingString<GUIVehicle>(this, &GUIVehicle::getBackLaneIDs));
115 }
116 ret->mkItem(TL("position [m]"), true,
118 ret->mkItem(TL("lateral offset [m]"), true,
120 ret->mkItem(TL("speed [m/s]"), true,
122 ret->mkItem(TL("lateral speed [m/s]"), true,
124 ret->mkItem(TL("acceleration [m/s^2]"), true,
126 ret->mkItem(TL("angle [degree]"), true,
128 ret->mkItem(TL("slope [degree]"), true,
130 ret->mkItem(TL("speed factor"), true,
132 ret->mkItem(TL("time gap on lane [s]"), true,
134 ret->mkItem(TL("waiting time [s]"), true,
136 ret->mkItem(TLF("waiting time (accumulated, % s) [s]", time2string(MSGlobals::gWaitingTimeMemory)).c_str(), true,
138 ret->mkItem(TL("time since startup [s]"), true,
140 ret->mkItem(TL("time loss [s]"), true,
142 ret->mkItem(TL("impatience"), true,
144 ret->mkItem(TL("last lane change [s]"), true,
146 ret->mkItem(TL("desired depart [s]"), false, time2string(getParameter().depart));
147 ret->mkItem(TL("depart delay [s]"), false, time2string(getDepartDelay()));
148 ret->mkItem(TL("odometer [m]"), true,
150 if (getParameter().repetitionNumber < std::numeric_limits<int>::max()) {
151 ret->mkItem(TL("remaining [#]"), false, (int) getParameter().repetitionNumber - getParameter().repetitionsDone);
152 }
153 if (getParameter().repetitionOffset > 0) {
154 ret->mkItem(TL("insertion period [s]"), false, time2string(getParameter().repetitionOffset));
155 }
156 if (getParameter().repetitionProbability > 0) {
157 ret->mkItem(TL("insertion probability"), false, getParameter().repetitionProbability);
158 }
159 if (getParameter().poissonRate > 0) {
160 ret->mkItem(TL("poisson rate"), false, getParameter().poissonRate);
161 }
162 ret->mkItem(TL("stop info"), true, new FunctionBindingString<GUIVehicle>(this, &GUIVehicle::getStopInfo));
163 ret->mkItem(TL("line"), false, myParameter->line);
164 ret->mkItem(TL("CO2 [mg/s]"), true,
165 new FunctionBinding<GUIVehicle, double>(this, &MSVehicle::getEmissions<PollutantsInterface::CO2>));
166 ret->mkItem(TL("CO [mg/s]"), true,
167 new FunctionBinding<GUIVehicle, double>(this, &MSVehicle::getEmissions<PollutantsInterface::CO>));
168 ret->mkItem(TL("HC [mg/s]"), true,
169 new FunctionBinding<GUIVehicle, double>(this, &MSVehicle::getEmissions<PollutantsInterface::HC>));
170 ret->mkItem(TL("NOx [mg/s]"), true,
171 new FunctionBinding<GUIVehicle, double>(this, &MSVehicle::getEmissions<PollutantsInterface::NO_X>));
172 ret->mkItem(TL("PMx [mg/s]"), true,
173 new FunctionBinding<GUIVehicle, double>(this, &MSVehicle::getEmissions<PollutantsInterface::PM_X>));
174 ret->mkItem(TL("fuel [mg/s]"), true,
175 new FunctionBinding<GUIVehicle, double>(this, &MSVehicle::getEmissions<PollutantsInterface::FUEL>));
176 ret->mkItem(TL("electricity [Wh/s]"), true,
177 new FunctionBinding<GUIVehicle, double>(this, &MSVehicle::getEmissions<PollutantsInterface::ELEC>));
178 ret->mkItem(TL("noise (Harmonoise) [dB]"), true,
180 ret->mkItem(TL("devices"), false, getDeviceDescription());
181 ret->mkItem(TL("persons"), true,
183 ret->mkItem(TL("containers"), true,
185 ret->mkItem(TL("lcState right"), true, new FunctionBindingString<GUIVehicle>(this, &GUIVehicle::getLCStateRight));
186 ret->mkItem(TL("lcState left"), true, new FunctionBindingString<GUIVehicle>(this, &GUIVehicle::getLCStateLeft));
187 ret->mkItem(TL("parking badges"), false, joinToString(getParkingBadges(), " "));
188 // close building
190 ret->mkItem(TL("lcState center"), true, new FunctionBindingString<GUIVehicle>(this, &GUIVehicle::getLCStateCenter));
191 ret->mkItem(TL("right side on edge [m]"), true, new FunctionBinding<GUIVehicle, double>(this, &GUIVehicle::getRightSideOnEdge2));
192 ret->mkItem(TL("left side on edge [m]"), true, new FunctionBinding<GUIVehicle, double>(this, &GUIVehicle::getLeftSideOnEdge));
193 ret->mkItem(TL("rightmost edge sublane [#]"), true, new FunctionBinding<GUIVehicle, int>(this, &GUIVehicle::getRightSublaneOnEdge));
194 ret->mkItem(TL("leftmost edge sublane [#]"), true, new FunctionBinding<GUIVehicle, int>(this, &GUIVehicle::getLeftSublaneOnEdge));
195 ret->mkItem(TL("lane change maneuver distance [m]"), true, new FunctionBinding<GUIVehicle, double>(this, &GUIVehicle::getManeuverDist));
196 }
197 if (isRailway(getVClass())) {
198 ret->mkItem(TL("driveways"), true, new FunctionBindingString<GUIVehicle>(this, &GUIVehicle::getDriveWays));
199 }
200 if (hasBattery || isElecHybrid) {
201 ret->mkItem(TL("present state of charge [Wh]"), true,
203 }
204 if (hasBattery) {
205 ret->mkItem(TL("relative state of charge (SoC) [-]"), true,
207 ret->mkItem(TL("current timestep charge [Wh]"), true,
209 ret->mkItem(TL("maximum charge rate [W]"), true,
211 }
212 if (isElecHybrid) {
213 ret->mkItem(TL("present electric current [A]"), true,
215 }
216 if (hasInfluencer()) {
218 ret->mkItem(TL("speed mode"), true, new FunctionBindingString<GUIVehicle>(this, &GUIVehicle::getSpeedMode));
219 }
221 ret->mkItem(TL("lane change mode"), true, new FunctionBindingString<GUIVehicle>(this, &GUIVehicle::getLaneChangeMode));
222 }
223 }
225 return ret;
226}
227
228
231 GUIParameterTableWindow* ret = new GUIParameterTableWindow(app, *this, "vType:" + myType->getID());
232 ret->mkItem(TL("length [m]"), false, myType->getLength());
233 ret->mkItem(TL("width [m]"), false, myType->getWidth());
234 ret->mkItem(TL("height [m]"), false, myType->getHeight());
235 ret->mkItem(TL("minGap [m]"), false, myType->getMinGap());
236 ret->mkItem(TL("vehicle class"), false, SumoVehicleClassStrings.getString(myType->getVehicleClass()));
237 ret->mkItem(TL("emission class"), false, PollutantsInterface::getName(myType->getEmissionClass()));
238 ret->mkItem(TL("mass [kg]"), false, myType->getMass());
239 ret->mkItem(TL("car-following model"), false, SUMOXMLDefinitions::CarFollowModels.getString((SumoXMLTag)getCarFollowModel().getModelID()));
240 ret->mkItem(TL("lane-change model"), false, SUMOXMLDefinitions::LaneChangeModels.getString(getLaneChangeModel().getModelID()));
241 ret->mkItem(TL("guiShape"), false, getVehicleShapeName(myType->getGuiShape()));
242 ret->mkItem(TL("maximum speed [m/s]"), false, getVehicleType().getMaxSpeed());
243 ret->mkItem(TL("desired maximum speed [m/s]"), false, getVehicleType().getDesiredMaxSpeed());
244 ret->mkItem(TL("maximum acceleration [m/s^2]"), false, getCarFollowModel().getMaxAccel());
245 ret->mkItem(TL("maximum deceleration [m/s^2]"), false, getCarFollowModel().getMaxDecel());
246 ret->mkItem(TL("emergency deceleration [m/s^2]"), false, getCarFollowModel().getEmergencyDecel());
247 ret->mkItem(TL("apparent deceleration [m/s^2]"), false, getCarFollowModel().getApparentDecel());
248 ret->mkItem(TL("imperfection (sigma)"), false, getCarFollowModel().getImperfection());
249 ret->mkItem(TL("desired headway (tau) [s]"), false, getCarFollowModel().getHeadwayTime());
250 ret->mkItem(TL("speedfactor"), false, myType->getParameter().speedFactor.toStr(gPrecision));
252 ret->mkItem(TL("action step length [s]"), false, myType->getActionStepLengthSecs());
253 }
254 ret->mkItem(TL("person capacity"), false, myType->getPersonCapacity());
255 ret->mkItem(TL("boarding time [s]"), false, STEPS2TIME(myType->getLoadingDuration(true)));
256 ret->mkItem(TL("container capacity"), false, myType->getContainerCapacity());
257 ret->mkItem(TL("loading time [s]"), false, STEPS2TIME(myType->getLoadingDuration(false)));
259 ret->mkItem(TL("minGapLat [m]"), false, myType->getMinGapLat());
260 ret->mkItem(TL("maxSpeedLat [m/s]"), false, myType->getMaxSpeedLat());
261 ret->mkItem(TL("latAlignment"), true, new FunctionBindingString<GUIVehicle>(this, &GUIVehicle::getDynamicAlignment));
262 } else if (MSGlobals::gLaneChangeDuration > 0) {
263 ret->mkItem(TL("maxSpeedLat [m/s]"), false, myType->getMaxSpeedLat());
264 }
265 for (auto item : myType->getParameter().lcParameter) {
266 ret->mkItem(toString(item.first).c_str(), false, toString(item.second));
267 }
268 for (auto item : myType->getParameter().jmParameter) {
269 ret->mkItem(toString(item.first).c_str(), false, toString(item.second));
270 }
272 ret->mkItem(TL("manoeuver Angle vs Times"), false, myType->getParameter().getManoeuverAngleTimesS());
273 }
275 return ret;
276}
277
278
279std::string
284 std::string align2 = toString(getLaneChangeModel().getDesiredAlignment());
285 if (align2 != align) {
286 align = align2 + " (default: " + align + ")";
287 }
288 return align;
289}
290
291void
293 glTranslated(0, 0, getType() + .2); // draw on top of cars
294 for (DriveItemVector::const_iterator i = myLFLinkLanes.begin(); i != myLFLinkLanes.end(); ++i) {
295 if ((*i).myLink == nullptr) {
296 continue;
297 }
298 MSLink* link = (*i).myLink;
299 MSLane* via = link->getViaLaneOrLane();
300 if (via != nullptr) {
301 Position p = via->getShape()[0];
302 if ((*i).mySetRequest) {
303 glColor3d(0, .8, 0);
304 } else {
305 glColor3d(.8, 0, 0);
306 }
307 const SUMOTime leaveTime = (*i).myLink->getLeaveTime(
308 (*i).myArrivalTime, (*i).myArrivalSpeed, (*i).getLeaveSpeed(), getVehicleType().getLength());
309 drawLinkItem(p, (*i).myArrivalTime, leaveTime, s.vehicleName.size / s.scale);
310 // the time slot that ego vehicle uses when checking opened may
311 // differ from the one it requests in setApproaching
312 MSLink::ApproachingVehicleInformation avi = (*i).myLink->getApproaching(this);
313 assert(avi.arrivalTime == (*i).myArrivalTime && avi.leavingTime == leaveTime);
314 UNUSED_PARAMETER(avi); // only used for assertion
315 }
316 }
317 glTranslated(0, 0, getType() - .2); // draw on top of cars
318}
319
320
321void
323 RGBColor current = GLHelper::getColor();
324 RGBColor darker = current.changedBrightness(-51);
325 const double exaggeration = (s.vehicleSize.getExaggeration(s, this)
327 if (exaggeration == 0) {
328 return;
329 }
330 // bool reversed =
331 MSTrainHelper trainHelper(this, isReversed() && s.drawReversed, s.secondaryShape, exaggeration, s.vehicleQuality);
332 const int numCarriages = trainHelper.getNumCarriages();
333 const int firstPassengerCarriage = trainHelper.getFirstPassengerCarriage();
334 const int noPersonsBackCarriages = (getVehicleType().getGuiShape() == SUMOVehicleShape::TRUCK_SEMITRAILER || getVehicleType().getGuiShape() == SUMOVehicleShape::TRUCK_1TRAILER) && numCarriages > 1 ? 1 : 0;
335 const int firstContainerCarriage = numCarriages == 1 || getVehicleType().getGuiShape() == SUMOVehicleShape::TRUCK_1TRAILER ? 0 : 1;
336 const int seatsPerCarriage = (int)ceil(getVType().getPersonCapacity() / (numCarriages - firstPassengerCarriage - noPersonsBackCarriages));
337 const int containersPerCarriage = (int)ceil(getVType().getContainerCapacity() / (numCarriages - firstContainerCarriage));
338 // Handle seats.
339 int requiredSeats = getNumPassengers();
340 int requiredPositions = getNumContainers();
341 if (requiredSeats > 0) {
342 mySeatPositions.clear();
343 }
344 if (requiredPositions > 0) {
345 myContainerPositions.clear();
346 }
347 GLHelper::popMatrix(); // undo initial translation and rotation
348 const double xCornerCut = 0.3 * exaggeration;
349 const double yCornerCut = 0.4 * trainHelper.getUpscaleLength();
350 Position front, back;
351 double angle = 0.0;
352 double curCLength = trainHelper.getFirstCarriageLength();
353 const std::vector<MSTrainHelper::Carriage*>& carriages = trainHelper.getCarriages();
354 for (int i = 0; i < numCarriages; ++i) {
355 front = carriages[i]->front;
356 back = carriages[i]->back;
357 if (front == back) {
358 // No place for drawing available.
359 continue;
360 }
361 const double drawnCarriageLength = front.distanceTo2D(back);
362 angle = atan2((front.x() - back.x()), (back.y() - front.y())) * (double) 180.0 / (double) M_PI;
363 // if we are in reverse 'first' carriages are drawn last so the >= test doesn't work
364 const bool reversed = trainHelper.isReversed();
365 if (reversed) {
366 if (i <= numCarriages - firstPassengerCarriage) {
367 computeSeats(back, front, SUMO_const_waitingPersonWidth, seatsPerCarriage, exaggeration, requiredSeats, mySeatPositions);
368 }
369 if (i <= numCarriages - firstContainerCarriage) {
370 computeSeats(front, back, SUMO_const_waitingContainerWidth, containersPerCarriage, exaggeration, requiredPositions, myContainerPositions);
371 }
372 } else {
373 if (i >= firstPassengerCarriage) {
374 computeSeats(front, back, SUMO_const_waitingPersonWidth, seatsPerCarriage, exaggeration, requiredSeats, mySeatPositions);
375 }
376 if (i >= firstContainerCarriage) {
377 computeSeats(front, back, SUMO_const_waitingContainerWidth, containersPerCarriage, exaggeration, requiredPositions, myContainerPositions);
378 }
379 }
380 curCLength = (i == trainHelper.getFirstCarriageNo() ? trainHelper.getFirstCarriageLength() : trainHelper.getCarriageLength());
382 if (s.trueZ) {
383 glTranslated(front.x(), front.y(), front.z() + 1);
384 } else {
385 glTranslated(front.x(), front.y(), getType());
386 }
387 glRotated(angle, 0, 0, 1);
388 double halfWidth = trainHelper.getHalfWidth();
389 std::string imgFile = getVType().getImgFile();
390 if (asImage && i != trainHelper.getFirstCarriageNo()) {
391 if (getVType().getParameter().hasParameter("carriageImages")) {
392 std::vector<std::string> imgFiles = StringTokenizer(getVType().getParameter().getParameter("carriageImages", ""), ",").getVector();
393 if (imgFiles.size() > 0) {
394 const int carIndex = trainHelper.isReversed() ? numCarriages - i : i;
395 imgFile = imgFiles[MIN2((int)imgFiles.size() - 1, carIndex - 1)];
396 }
397 }
398 }
399 if (!asImage || !GUIBaseVehicleHelper::drawAction_drawVehicleAsImage(s, imgFile, this, getVType().getWidth() * exaggeration, curCLength)) {
400 switch (getVType().getGuiShape()) {
403 if (i == trainHelper.getFirstCarriageNo()) { // at the moment amReversed is only ever set for rail - so has no impact in this call
404 GUIBaseVehicleHelper::drawAction_drawVehicleAsPoly(s, getVType().getGuiShape(), getVType().getWidth() * exaggeration, curCLength, 0, false, reversed);
405 } else {
406 GLHelper::setColor(current);
407 GLHelper::drawBoxLine(Position(0, 0), 180, curCLength, halfWidth);
408 }
409 break;
410 default: {
411 if (i == trainHelper.getFirstCarriageNo()) {
412 GLHelper::setColor(darker);
413 } else {
414 GLHelper::setColor(current);
415 }
416 // generic rail carriage
417 glBegin(GL_TRIANGLE_FAN);
418 glVertex2d(-halfWidth + xCornerCut, 0);
419 glVertex2d(-halfWidth, yCornerCut);
420 glVertex2d(-halfWidth, drawnCarriageLength - yCornerCut);
421 glVertex2d(-halfWidth + xCornerCut, drawnCarriageLength);
422 glVertex2d(halfWidth - xCornerCut, drawnCarriageLength);
423 glVertex2d(halfWidth, drawnCarriageLength - yCornerCut);
424 glVertex2d(halfWidth, yCornerCut);
425 glVertex2d(halfWidth - xCornerCut, 0);
426 glEnd();
427 // indicate front of the head of the train
428 if (i == trainHelper.getFirstCarriageNo()) {
429 glTranslated(0, 0, 0.1);
430 glColor3d(0, 0, 0);
431 glBegin(GL_TRIANGLE_FAN);
432 if (reversed) { // not quite correct as its drawing at the wrong end of the locomotive - however useful as visual indicator of reverse?
433 glVertex2d(-halfWidth + xCornerCut, yCornerCut);
434 glVertex2d(-halfWidth + 2 * xCornerCut, 3 * yCornerCut);
435 glVertex2d(halfWidth - 2 * xCornerCut, 3 * yCornerCut);
436 glVertex2d(halfWidth - xCornerCut, yCornerCut);
437 } else {
438 glVertex2d(-halfWidth + 2 * xCornerCut, yCornerCut);
439 glVertex2d(-halfWidth + xCornerCut, 3 * yCornerCut);
440 glVertex2d(halfWidth - xCornerCut, 3 * yCornerCut);
441 glVertex2d(halfWidth - 2 * xCornerCut, yCornerCut);
442 }
443 glEnd();
444 glTranslated(0, 0, -0.1);
445 }
446 }
447 }
448 }
450 }
451 if (getVType().getGuiShape() == SUMOVehicleShape::RAIL_CAR) {
453 if (s.trueZ) {
454 glTranslated(front.x(), front.y(), front.z() + 1);
455 } else {
456 glTranslated(front.x(), front.y(), getType());
457 }
458 glRotated(angle, 0, 0, 1);
462 }
463 // restore matrix
465 front = getPosition();
466 glTranslated(front.x(), front.y(), getType());
467 const double degAngle = RAD2DEG(getAngle() + M_PI / 2.);
468 glRotated(degAngle, 0, 0, 1);
469 glScaled(exaggeration, trainHelper.getUpscaleLength(), 1);
470 if (mySeatPositions.size() == 0) {
471 mySeatPositions.push_back(Seat(back, DEG2RAD(angle)));
472 }
473 if (myContainerPositions.size() == 0) {
474 myContainerPositions.push_back(Seat(back, DEG2RAD(angle)));
475 }
476}
477
478#define BLINKER_POS_FRONT .5
479#define BLINKER_POS_BACK .5
480
481inline void
482drawAction_drawBlinker(double dir, double length) {
483 glColor3d(1.f, .8f, 0);
485 glTranslated(dir, BLINKER_POS_FRONT, -0.1);
489 glTranslated(dir, length - BLINKER_POS_BACK, -0.1);
492}
493
494
495void
512
513
514inline void
515GUIVehicle::drawAction_drawVehicleBrakeLight(double length, bool onlyOne) const {
517 return;
518 }
519 glColor3f(1.f, .2f, 0);
521 if (onlyOne) {
522 glTranslated(0, length, -0.1);
524 } else {
525 glTranslated(-getVehicleType().getWidth() * 0.5, length, -0.1);
529 glTranslated(getVehicleType().getWidth() * 0.5, length, -0.1);
531 }
533}
534
535inline void
539 glTranslated(0, 2.5, .5);
540 glColor3f(0, 0, 1);
543 }
544}
545
546
547double
548GUIVehicle::getColorValue(const GUIVisualizationSettings& s, int activeScheme) const {
549 switch (activeScheme) {
550 case 8:
551 if (isStopped()) {
552 return isParking() ? -2 : -1;
553 }
554 return getSpeed();
555 case 9:
556 // color by action step
557 if (isActionStep(SIMSTEP)) {
558 // Upcoming simstep is actionstep (t was already increased before drawing)
559 return 1.;
560 } else if (isActive()) {
561 // Completed simstep was actionstep
562 return 2.;
563 } else {
564 // not active
565 return 0.;
566 }
567 case 10:
568 return getWaitingSeconds();
569 case 11:
571 case 12:
573 case 13:
574 return getLane()->getVehicleMaxSpeed(this);
575 case 14:
576 return getEmissions<PollutantsInterface::CO2>();
577 case 15:
578 return getEmissions<PollutantsInterface::CO>();
579 case 16:
580 return getEmissions<PollutantsInterface::PM_X>();
581 case 17:
582 return getEmissions<PollutantsInterface::NO_X>();
583 case 18:
584 return getEmissions<PollutantsInterface::HC>();
585 case 19:
586 return getEmissions<PollutantsInterface::FUEL>();
587 case 20:
589 case 21:
590 return getNumberReroutes();
591 case 22:
593 case 23:
594 return getLaneChangeModel().isOpposite() ? -100 : getBestLaneOffset();
595 case 24:
596 return getAcceleration();
597 case 25:
598 return getTimeGapOnLane();
599 case 26:
600 return STEPS2TIME(getDepartDelay());
601 case 27:
602 return getEmissions<PollutantsInterface::ELEC>();
603 case 28:
605 case 29:
606 return getChargedEnergy();
607 case 30:
608 return getTimeLossSeconds();
609 case 31:
610 return getStopDelay();
611 case 32:
612 return getStopArrivalDelay();
613 case 33:
615 case 34: // by numerical param value
616 std::string error;
617 std::string val = getPrefixedParameter(s.vehicleParam, error);
618 try {
619 if (val == "") {
621 } else {
622 return StringUtils::toDouble(val);
623 }
624 } catch (NumberFormatException&) {
625 try {
626 return StringUtils::toBool(val);
627 } catch (BoolFormatException&) {
628 WRITE_WARNINGF(TL("Vehicle parameter '%' key '%' is not a number for vehicle '%'."),
631 }
632 }
633 }
634 return 0;
635}
636
637
638void
640 myLock.lock();
641 std::vector<std::vector<MSVehicle::LaneQ> > bestLanes = myBestLanes;
642 myLock.unlock();
643 for (std::vector<std::vector<MSVehicle::LaneQ> >::iterator j = bestLanes.begin(); j != bestLanes.end(); ++j) {
644 std::vector<MSVehicle::LaneQ>& lanes = *j;
645 double gmax = -1;
646 double rmax = -1;
647 for (std::vector<MSVehicle::LaneQ>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) {
648 gmax = MAX2((*i).length, gmax);
649 rmax = MAX2((*i).occupation, rmax);
650 }
651 for (std::vector<MSVehicle::LaneQ>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) {
652 const PositionVector& shape = (*i).lane->getShape();
653 double g = (*i).length / gmax;
654 double r = (*i).occupation / rmax;
655 glColor3d(r, g, 0);
656 double width = 0.5 / (1 + abs((*i).bestLaneOffset));
657 GLHelper::drawBoxLines(shape, width);
658
659 PositionVector s1 = shape;
660 s1.move2side((double) .1);
661 glColor3d(r, 0, 0);
663 s1.move2side((double) - .2);
664 glColor3d(0, g, 0);
666
667 glColor3d(r, g, 0);
668 }
669 }
670}
671
672
673void
674GUIVehicle::drawRouteHelper(const GUIVisualizationSettings& s, ConstMSRoutePtr r, bool future, bool noLoop, const RGBColor& col) const {
675 const double exaggeration = s.vehicleSize.getExaggeration(s, this) * (s.gaming ? 0.5 : 1);
676 MSRouteIterator start = future ? myCurrEdge : r->begin();
677 MSRouteIterator i = start;
678 const std::vector<MSLane*>& bestLaneConts = getBestLanesContinuation();
679 // draw continuation lanes when drawing the current route where available
680 int bestLaneIndex = (r == myRoute ? 0 : (int)bestLaneConts.size());
681 std::map<const MSLane*, int> repeatLane; // count repeated occurrences of the same edge
682 const double textSize = s.vehicleName.size / s.scale;
683 const GUILane* prevLane = nullptr;
684 int reversalIndex = 0;
685 const int indexDigits = (int)toString(r->size()).size();
686 if (!isOnRoad() && !isParking()) {
687 // simulation time has already advanced so isRemoteControlled is always false
688 const std::string offRoadLabel = hasInfluencer() && getInfluencer()->isRemoteAffected(SIMSTEP) ? "offRoad" : "teleporting";
689 GLHelper::drawTextSettings(s.vehicleValue, offRoadLabel, getPosition(), s.scale, s.angle, 1.0);
690 } else if (myLane->isInternal()) {
691 bestLaneIndex++;
692 }
693 const bool s2 = s.secondaryShape;
694 for (; i != r->end(); ++i) {
695 const GUILane* lane;
696 if (bestLaneIndex < (int)bestLaneConts.size() && bestLaneConts[bestLaneIndex] != 0 && (*i) == &(bestLaneConts[bestLaneIndex]->getEdge())) {
697 lane = static_cast<GUILane*>(bestLaneConts[bestLaneIndex]);
698 ++bestLaneIndex;
699 } else {
700 const std::vector<MSLane*>* allowed = (*i)->allowedLanes(getVClass());
701 if (allowed != nullptr && allowed->size() != 0) {
702 lane = static_cast<GUILane*>((*allowed)[0]);
703 } else {
704 lane = static_cast<GUILane*>((*i)->getLanes()[0]);
705 }
706 }
708 GLHelper::drawBoxLines(lane->getShape(s2), lane->getShapeRotations(s2), lane->getShapeLengths(s2), exaggeration);
709 if (prevLane != nullptr && lane->getBidiLane() == prevLane) {
710 // indicate train reversal
711 std::string label = "reverse:" + toString(reversalIndex++);
712 if (s.showRouteIndex) {
713 label += "@r" + toString((int)(i - myCurrEdge));
714 }
715 Position pos = lane->geometryPositionAtOffset(lane->getLength() / 2) - Position(0, textSize * repeatLane[lane]);
716 GLHelper::drawTextSettings(s.vehicleValue, label, pos, s.scale, s.angle, 1.0);
717 }
718 if (s.showRouteIndex) {
719 std::string label = toString((int)(i - myCurrEdge));
720 const double laneAngle = lane->getShape(s2).angleAt2D(0);
721 Position pos = lane->getShape(s2).front() - Position(0, textSize * repeatLane[lane]) + Position(
722 (laneAngle >= -0.25 * M_PI && laneAngle < 0.75 * M_PI ? 1 : -1) * 0.4 * indexDigits * textSize, 0);
723 //GLHelper::drawText(label, pos, 1.0, textSize, s.vehicleName.color);
724 GLHelper::drawTextSettings(s.vehicleName, label, pos, s.scale, s.angle, 1.0);
725 }
726 repeatLane[lane]++;
727 prevLane = lane;
728 if (noLoop && i != start && (*i) == (*start)) {
729 break;
730 }
731 }
732 drawStopLabels(s, noLoop, col);
735}
736
737
738double
742
743
744std::string
746 std::string result = "";
747 if (isParking()) {
748 result += "parking";
749 } else if (isStopped()) {
750 result += "stopped";
751 } else if (hasStops()) {
752 return "next: " + myStops.front().getDescription();
753 } else {
754 return "";
755 }
756 if (myStops.front().pars.triggered) {
757 result += ", triggered";
758 }
759 if (myStops.front().pars.containerTriggered) {
760 result += ", containerTriggered";
761 }
762 if (myStops.front().pars.collision) {
763 result += ", collision";
764 }
765 if (myStops.front().pars.arrival != -1) {
766 result += ", arrival=" + time2string(myStops.front().pars.arrival);
767 }
768 if (myStops.front().pars.started != -1) {
769 result += ", started=" + time2string(myStops.front().pars.started);
770 }
771 if (myStops.front().pars.until != -1) {
772 result += ", until=" + time2string(myStops.front().pars.until);
773 }
774 if (myStops.front().pars.extension != -1) {
775 result += ", extension=" + time2string(myStops.front().pars.extension);
776 }
777 if (!myStops.front().pars.permitted.empty()) {
778 result += ", permitted=" + toString(myStops.front().pars.permitted);
779 }
780 if (myStops.front().pars.actType != "") {
781 result += ", actType=" + myStops.front().pars.actType;
782 }
783 result += ", duration=" + time2string(myStops.front().duration);
784 return StringUtils::wrapText(result, 60);
785}
786
787
788void
790 double dist = myLane->getLength() - getPositionOnLane();
791#ifdef DEBUG_FOES
792 gDebugFlag1 = true;
793 std::cout << SIMTIME << " selectBlockingFoes veh=" << getID() << " dist=" << dist << " numLinks=" << myLFLinkLanes.size() << "\n";
794#endif
795 for (DriveItemVector::const_iterator i = myLFLinkLanes.begin(); i != myLFLinkLanes.end(); ++i) {
796 const DriveProcessItem& dpi = *i;
797 if (dpi.myLink == nullptr) {
799 continue;
800 }
801 MSLink::BlockingFoes blockingFoes;
802 std::vector<const MSPerson*> blockingPersons;
803#ifdef DEBUG_FOES
804 std::cout << " foeLink=" << dpi.myLink->getViaLaneOrLane()->getID() << "\n";
805 const bool isOpen =
806#endif
809#ifdef DEBUG_FOES
810 if (!isOpen) {
811 std::cout << " closed due to:\n";
812 for (const auto& item : blockingFoes) {
813 std::cout << " " << item->getID() << "\n";
814 }
815 }
816#endif
817 if (getLaneChangeModel().getShadowLane() != nullptr) {
819 if (parallelLink != nullptr) {
820 const double shadowLatPos = getLateralPositionOnLane() - getLaneChangeModel().getShadowDirection() * 0.5 * (
822#ifdef DEBUG_FOES
823 const bool isShadowOpen =
824#endif
825 parallelLink->opened(dpi.myArrivalTime, dpi.myArrivalSpeed, dpi.getLeaveSpeed(),
828 getWaitingTime(), shadowLatPos, &blockingFoes, false, this, dpi.myDistance);
829#ifdef DEBUG_FOES
830 if (!isShadowOpen) {
831 std::cout << " foes at shadow link=" << parallelLink->getViaLaneOrLane()->getID() << ":\n";
832 for (const auto& item : blockingFoes) {
833 std::cout << " " << item->getID() << "\n";
834 }
835 }
836#endif
837 }
838 }
839 for (const auto& item : blockingFoes) {
840 if (item->isVehicle()) {
841 gSelected.select(static_cast<const GUIVehicle*>(item)->getGlID());
842 } else {
843 gSelected.select(static_cast<const GUIPerson*>(item)->getGlID());
844 }
845 }
846 const MSLink::LinkLeaders linkLeaders = (dpi.myLink)->getLeaderInfo(this, dist, &blockingPersons);
847#ifdef DEBUG_FOES
848 gDebugFlag1 = false;
849#endif
850 for (MSLink::LinkLeaders::const_iterator it = linkLeaders.begin(); it != linkLeaders.end(); ++it) {
851 // the vehicle to enter the junction first has priority
852 const GUIVehicle* leader = dynamic_cast<const GUIVehicle*>(it->vehAndGap.first);
853 if (leader != nullptr) {
854 if (isLeader(dpi.myLink, leader, it->vehAndGap.second) || it->inTheWay()) {
855 gSelected.select(leader->getGlID());
856#ifdef DEBUG_FOES
857 std::cout << " linkLeader=" << leader->getID() << "\n";
858#endif
859 }
860 } else {
861 for (std::vector<const MSPerson*>::iterator it_p = blockingPersons.begin(); it_p != blockingPersons.end(); ++it_p) {
862 const GUIPerson* foe = dynamic_cast<const GUIPerson*>(*it_p);
863 if (foe != nullptr) {
864 gSelected.select(foe->getGlID());
865 //std::cout << SIMTIME << " veh=" << getID() << " is blocked on link " << dpi.myLink->getRespondIndex() << " to " << dpi.myLink->getViaLaneOrLane()->getID() << " by pedestrian. dist=" << it->second << "\n";
866 }
867 }
868 }
869 }
870 dist += dpi.myLink->getViaLaneOrLane()->getLength();
871 }
872}
873
874
875void
879 if (view != nullptr) {
880 if (add) {
884 }
885 } else {
887 myAdditionalVisualizations[view] &= ~VO_DRAW_OUTSIDE_NETWORK;
888 }
889 }
890}
891
892bool
896
897int
899 const double rightSide = getRightSideOnEdge();
900 const std::vector<double>& sublaneSides = myLane->getEdge().getSubLaneSides();
901 for (int i = 0; i < (int)sublaneSides.size(); ++i) {
902 if (sublaneSides[i] > rightSide) {
903 return MAX2(i - 1, 0);
904 }
905 }
906 return (int)sublaneSides.size() - 1;
907}
908
909int
911 const double leftSide = getLeftSideOnEdge();
912 const std::vector<double>& sublaneSides = myLane->getEdge().getSubLaneSides();
913 for (int i = (int)sublaneSides.size() - 1; i >= 0; --i) {
914 if (sublaneSides[i] < leftSide) {
915 return i;
916 }
917 }
918 return -1;
919}
920
921
922std::string
924 return toString((LaneChangeAction)getLaneChangeModel().getSavedState(-1).second);
925}
926
927std::string
929 return toString((LaneChangeAction)getLaneChangeModel().getSavedState(1).second);
930}
931
932std::string
934 return toString((LaneChangeAction)getLaneChangeModel().getSavedState(0).second);
935}
936
937std::string
939 return Named::getIDSecure(myLane, "n/a");
940}
941
942std::string
946
947std::string
949 return Named::getIDSecure(getLaneChangeModel().getShadowLane(), "");
950}
951
952std::string
954 return Named::getIDSecure(getLaneChangeModel().getTargetLane(), "");
955}
956
957
958std::string
960 std::vector<std::string> result;
961 for (auto item : myMoveReminders) {
962 const MSDriveWay* dw = dynamic_cast<const MSDriveWay*>(item.first);
963 if (dw) {
964 result.push_back(dw->getID());
965 }
966 }
967 return StringUtils::wrapText(joinToStringSorting(result, " "), 60);
968}
969
970double
974
975std::string
977 return std::bitset<6>(getInfluencer()->getSpeedMode()).to_string();
978}
979
980std::string
982 return std::bitset<12>(getInfluencer()->getLaneChangeMode()).to_string();
983}
984
985void
987 SUMOTime intermediateDuration = TIME2STEPS(20);
988 SUMOTime finalDuration = SUMOTime_MAX;
989 if (myParameter->stops.size() >= 2) {
990 // copy durations from the original stops
991 intermediateDuration = myParameter->stops.front().duration;
992 finalDuration = myParameter->stops.back().duration;
993 }
994 // if the stop is already in the list of stops, cancel all stops that come
995 // after it and set the stop duration
996 std::string line = "";
997 int destinations = 0;
998 bool add = true;
999 for (auto it = myStops.begin(); it != myStops.end(); it++) {
1000 if (!it->reached && destinations < 2 && it->busstop != nullptr) {
1001 line += it->busstop->getID();
1002 destinations++;
1003 }
1004 if (it->busstop == busStop) {
1005 it->duration = finalDuration;
1006 myStops.erase(++it, myStops.end());
1007 add = false;
1008 break;
1009 } else {
1010 it->duration = MIN2(it->duration, intermediateDuration);
1011 }
1012 }
1013 if (destinations < 2) {
1014 line += busStop->getID();
1015 }
1016 if (add) {
1017 // create new stop
1019 stopPar.busstop = busStop->getID();
1020 stopPar.lane = busStop->getLane().getID();
1021 stopPar.startPos = busStop->getBeginLanePosition();
1022 stopPar.endPos = busStop->getEndLanePosition();
1023 stopPar.duration = finalDuration;
1024 stopPar.until = -1;
1025 stopPar.triggered = false;
1026 stopPar.containerTriggered = false;
1027 stopPar.parking = ParkingType::ONROAD;
1028 stopPar.index = STOP_INDEX_FIT;
1030 // clean up prior route to improve visualisation, ensure that the stop can be added immediately
1031 ConstMSEdgeVector edges = myRoute->getEdges();
1032 edges.erase(edges.begin(), edges.begin() + getRoutePosition());
1033 edges.push_back(&busStop->getLane().getEdge());
1034 replaceRouteEdges(edges, -1, 0, "DRT.tmp", false, false, false);
1035 std::string errorMsg;
1036 // add stop
1037 addStop(stopPar, errorMsg);
1038 }
1039 const bool hasReroutingDevice = getDevice(typeid(MSDevice_Routing)) != nullptr;
1040 SUMOAbstractRouter<MSEdge, SUMOVehicle>& router = hasReroutingDevice
1043 // reroute to ensure the new stop is reached
1044 reroute(MSNet::getInstance()->getCurrentTimeStep(), "DRT", router);
1045 myParameter->line = line;
1046 assert(haveValidStopEdges());
1047}
1048
1050GUIVehicle::getVisualPosition(bool s2, const double offset) const {
1051 if (s2) {
1052 // see MSVehicle::getPosition
1053 if (myLane == nullptr) {
1054 return Position::INVALID;
1055 }
1056 if (isParking()) {
1057 if (myStops.begin()->parkingarea != nullptr) {
1058 return myStops.begin()->parkingarea->getVehiclePosition(*this);
1059 } else {
1060 // position beside the road
1061 PositionVector shp = myLane->getEdge().getLanes()[0]->getShape(s2);
1063 return shp.positionAtOffset((getPositionOnLane() + offset) * myLane->getLengthGeometryFactor(s2));
1064 }
1065 }
1066 const PositionVector& shape = myLane->getShape(s2);
1067 const double posLat = (MSGlobals::gLefthand ? 1 : -1) * getLateralPositionOnLane();
1068 return shape.positionAtOffset((getPositionOnLane() + offset) * myLane->getLengthGeometryFactor(s2), posLat);
1069 } else {
1070 return getPosition(offset);
1071 }
1072}
1073
1074
1075double
1077 if (s2) {
1078 // see MSVehicle::computeAngle
1079 const PositionVector& shape = myLane->getShape(s2);
1080 if (isParking()) {
1081 if (myStops.begin()->parkingarea != nullptr) {
1082 return myStops.begin()->parkingarea->getVehicleAngle(*this);
1083 } else {
1085 }
1086 }
1087 // if (myLaneChangeModel->isChangingLanes()) {
1088 const double lefthandSign = (MSGlobals::gLefthand ? -1 : 1);
1089 Position p1 = getVisualPosition(s2);
1090 Position p2 = getVisualPosition(s2, MAX2(0.0, -myType->getLength()));
1091 double result = (p1 != p2 ? p2.angleTo2D(p1) :
1094 result += lefthandSign * DEG2RAD(myLaneChangeModel->getAngleOffset());
1095 }
1096 return result;
1097 } else {
1098 return getAngle();
1099 }
1100}
1101/****************************************************************************/
long long int SUMOTime
Definition GUI.h:36
@ GLO_VEHICLE
a vehicle
GUISelectedStorage gSelected
A global holder of selected objects.
#define BLINKER_POS_FRONT
#define LANECHANGEMODE_DEFAULT
#define SPEEDMODE_DEFAULT
void drawAction_drawBlinker(double dir, double length)
#define BLINKER_POS_BACK
#define DEG2RAD(x)
Definition GeomHelper.h:35
#define RAD2DEG(x)
Definition GeomHelper.h:36
std::vector< const MSEdge * > ConstMSEdgeVector
Definition MSEdge.h:74
ConstMSEdgeVector::const_iterator MSRouteIterator
Definition MSRoute.h:57
#define WRITE_WARNINGF(...)
Definition MsgHandler.h:296
#define TL(string)
Definition MsgHandler.h:315
#define TLF(string,...)
Definition MsgHandler.h:317
std::shared_ptr< const MSRoute > ConstMSRoutePtr
Definition Route.h:32
std::string time2string(SUMOTime t, bool humanReadable)
convert SUMOTime to string (independently of global format setting)
Definition SUMOTime.cpp:69
#define STEPS2TIME(x)
Definition SUMOTime.h:55
#define SIMSTEP
Definition SUMOTime.h:61
#define SUMOTime_MAX
Definition SUMOTime.h:34
#define SIMTIME
Definition SUMOTime.h:62
#define TIME2STEPS(x)
Definition SUMOTime.h:57
const long long int VTYPEPARS_ACTIONSTEPLENGTH_SET
@ GIVEN
The alignment as offset is given.
bool isRailway(SVCPermissions permissions)
Returns whether an edge with the given permissions is a railway edge.
std::string getVehicleShapeName(SUMOVehicleShape id)
Returns the class name of the shape class given by its id.
StringBijection< SUMOVehicleClass > SumoVehicleClassStrings(sumoVehicleClassStringInitializer, SVC_CUSTOM2, false)
@ RAIL_CAR
render as a (city) rail without locomotive
@ TRUCK_1TRAILER
render as a transport vehicle with one trailer
@ TRUCK_SEMITRAILER
render as a semi-trailer transport vehicle ("Sattelschlepper")
const int STOP_START_SET
const int STOP_INDEX_FIT
const int STOP_END_SET
SumoXMLTag
Numbers representing SUMO-XML - element names.
LaneChangeAction
The state of a vehicle's lane-change behavior.
int gPrecision
the precision for floating point outputs
Definition StdDefs.cpp:26
bool gDebugFlag1
global utility flags for debugging
Definition StdDefs.cpp:37
const double SUMO_const_laneWidth
Definition StdDefs.h:48
#define UNUSED_PARAMETER(x)
Definition StdDefs.h:30
T MIN2(T a, T b)
Definition StdDefs.h:76
T MAX2(T a, T b)
Definition StdDefs.h:82
const double SUMO_const_waitingContainerWidth
Definition StdDefs.h:54
const double SUMO_const_waitingPersonWidth
Definition StdDefs.h:52
std::string joinToStringSorting(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
Definition ToString.h:299
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
Definition ToString.h:283
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition ToString.h:46
std::string toStr(std::streamsize accuracy) const
Returns the string representation of this distribution.
static void drawLine(const Position &beg, double rot, double visLength)
Draws a thin line.
Definition GLHelper.cpp:433
static void setColor(const RGBColor &c)
Sets the gl-color to this value.
Definition GLHelper.cpp:649
static void drawFilledCircle(const double widradiusth, const int steps=8)
Draws a filled circle around (0,0)
Definition GLHelper.cpp:564
static void popMatrix()
pop matrix
Definition GLHelper.cpp:131
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:348
static RGBColor getColor()
gets the gl-color
Definition GLHelper.cpp:655
static void drawBoxLine(const Position &beg, double rot, double visLength, double width, double offset=0)
Draws a thick line.
Definition GLHelper.cpp:296
static void pushMatrix()
push matrix
Definition GLHelper.cpp:118
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:782
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_drawVehicleAsPoly(const GUIVisualizationSettings &s, const SUMOVehicleShape shape, const double width, const double length, int carriageIndex=-1, bool isStopped=false, bool amReversed=false)
draw vehicle as a polygon
A MSVehicle extended by some values for usage within the gui.
int getNumContainers() const
return the number of passengers
void drawParkingInfo(const GUIVisualizationSettings &s) const
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
void drawChargingInfo(const GUIVisualizationSettings &s) const
@ VO_DRAW_OUTSIDE_NETWORK
draw vehicle outside the road network
FXMutex myLock
The mutex used to avoid concurrent updates of the vehicle buffer.
double getNaviDegree() const
return the current angle in navigational degrees
void computeSeats(const Position &front, const Position &back, double seatOffset, int maxSeats, double exaggeration, int &requiredSeats, Seats &into, double extraOffset=0) const
add seats to mySeatPositions and update requiredSeats
int getNumPassengers() const
return the number of passengers
std::map< GUISUMOAbstractView *, int > myAdditionalVisualizations
Enabled visualisations, per view.
void drawStopLabels(const GUIVisualizationSettings &s, bool noLoop, const RGBColor &col) const
Seats mySeatPositions
positions of seats in the vehicle (updated at every drawing step)
std::string getDeviceDescription()
lists equipped device (types) for the current vehicle
const MSVehicleType & getVType() const
A shortcut to myVehicle.myType.
GUIGlObjectType getType() const
Returns the type of the object as coded in GUIGlObjectType.
GUIGlID getGlID() const
Returns the numerical id of the object.
Representation of a lane in the micro simulation (gui-version)
Definition GUILane.h:60
const std::vector< double > & getShapeRotations(bool secondary) const
Definition GUILane.cpp:1115
const PositionVector & getShape(bool secondary) const override
Definition GUILane.cpp:1109
const std::vector< double > & getShapeLengths(bool secondary) const
Definition GUILane.cpp:1121
GUISUMOAbstractView * getActiveView() const
get the active view or 0
static GUIMainWindow * getInstance()
get instance
A window containing a gl-object's parameter.
void mkItem(const char *name, bool dynamic, ValueSource< T > *src)
Adds a row which obtains its value from a ValueSource.
void closeBuilding(const Parameterised *p=0)
Closes the building of the table.
T getColor(const double value) const
bool removeAdditionalGLVisualisation(GUIGlObject *const which)
Removes an object from the list of objects that show additional things.
bool addAdditionalGLVisualisation(GUIGlObject *const which)
Adds an object to call its additional visualisation method.
void select(GUIGlID id, bool update=true)
Adds the object with the given id.
bool isSelected(GUIGlObjectType type, GUIGlID id)
Returns the information whether the object with the given type and id is selected.
A MSVehicle extended by some values for usage within the gui.
Definition GUIVehicle.h:51
bool isSelected() const
whether this vehicle is selected in the GUI
int getLeftSublaneOnEdge() const
double getAngle() const
Return current angle.
Definition GUIVehicle.h:81
Position getPosition(const double offset=0) const
Return current position (x/y, cartesian)
Definition GUIVehicle.h:71
double getColorValue(const GUIVisualizationSettings &s, int activeScheme) const
gets the color value according to the current scheme index
std::string getDynamicAlignment() const
return the current lateral alignment as string
double getVisualAngle(bool s2) const
Returns the vehicle's direction in radians taking into account secondary shape.
void selectBlockingFoes() const
adds the blocking foes to the current selection
GUIParameterTableWindow * getTypeParameterWindow(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own type parameter window.
void drawBestLanes() const
Draws the vehicle's best lanes.
void drawOutsideNetwork(bool add)
register vehicle for drawing while outside the network
int getRightSublaneOnEdge() const
return the righmost sublane on the edge occupied by the vehicle
void drawRouteHelper(const GUIVisualizationSettings &s, ConstMSRoutePtr r, bool future, bool noLoop, const RGBColor &col) const
Draws the route.
std::string getStopInfo() const
retrieve information about the current stop state
GUIParameterTableWindow * getParameterWindow(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own parameter window.
std::string getBackLaneIDs() const
double getLeftSideOnEdge() const
return left vehicle side on current edge
Definition GUIVehicle.h:144
void drawAction_drawCarriageClass(const GUIVisualizationSettings &s, bool asImage) const
draws the given guiShape with distinct carriages/modules
std::string getShadowLaneID() const
double getManeuverDist() const
return the lane-change maneuver distance
double getRightSideOnEdge2() const
return right vehicle side on current edge (without argument)
Definition GUIVehicle.h:140
std::string getSpeedMode() const
return the speed mode as bit string
GUIVehicle(SUMOVehicleParameter *pars, ConstMSRoutePtr route, MSVehicleType *type, const double speedFactor)
Constructor.
void drawAction_drawVehicleBlinker(double length) const
void rerouteDRTStop(MSStoppingPlace *busStop)
handle route to accomodate to given stop
std::string getLCStateRight() const
return the lanechange state
void drawAction_drawVehicleBlueLight() const
double getLastLaneChangeOffset() const
Returns the time since the last lane change in seconds.
std::string getLaneID() const
return vehicle lane id
void drawAction_drawLinkItems(const GUIVisualizationSettings &s) const
std::string getTargetLaneID() const
std::string getLCStateLeft() const
Position getVisualPosition(bool s2, const double offset=0) const
Return current position taking into account secondary shape.
void drawAction_drawVehicleBrakeLight(double length, bool onlyOne=false) const
std::string getDriveWays() const
~GUIVehicle()
destructor
std::string getLCStateCenter() const
std::string getLaneChangeMode() const
return the lane change mode as bit string
Stores the information about how to visualize structures.
GUIVisualizationTextSettings vehicleName
GUIVisualizationSizeSettings vehicleSize
bool trueZ
drawl all objects according to their z data
GUIVisualizationTextSettings vehicleValue
int vehicleQuality
The quality of vehicle drawing.
bool gaming
whether the application is in gaming mode or not
std::string vehicleParam
key for coloring by vehicle parameter
GUIScaler vehicleScaler
The size scaling settings for vehicles.
double scale
information about a lane's width (temporary, used for a single view)
bool secondaryShape
whether secondary lane shape shall be drawn
bool drawReversed
Whether to draw reversed vehicles in their reversed state.
bool showRouteIndex
Information whether the route index should be shown.
double angle
The current view rotation angle.
double getManeuverDist() const
Returns the remaining unblocked distance for the current maneuver. (only used by sublane model)
MSLane * getShadowLane() const
Returns the lane the vehicle's shadow is on during continuous/sublane lane change.
int getShadowDirection() const
return the direction in which the current shadow lane lies
double getSpeedLat() const
return the lateral speed of the current lane change maneuver
double getAngleOffset() const
return the angle offset resulting from lane change and sigma
bool isChangingLanes() const
return true if the vehicle currently performs a lane change maneuver
The base class for microscopic and mesoscopic vehicles.
double getMaxSpeed() const
Returns the maximum speed (the minimum of desired and technical maximum speed)
bool haveValidStopEdges(bool silent=false) const
check whether all stop.edge MSRouteIterators are valid and in order
std::list< MSStop > myStops
The vehicle's list of stops.
double getImpatience() const
Returns this vehicles impatience.
virtual double getLateralPositionOnLane() const
Get the vehicle's lateral position on the lane.
MSVehicleType * myType
This vehicle's type.
MoveReminderCont myMoveReminders
Currently relevant move reminders.
const SUMOVehicleParameter & getParameter() const
Returns the vehicle's parameter (including departure definition)
double getMaxChargeRate() const
Returns the maximum charge rate allowed by the battery in the current time step (W)
double getChosenSpeedFactor() const
Returns the precomputed factor by which the driver wants to be faster than the speed limit.
bool isReversed() const
Returns whether the logical state of the vehicle is reversed - for drawing.
double getOdometer() const
Returns the distance that was already driven by this vehicle.
double getLength() const
Returns the vehicle's length.
bool isParking() const
Returns whether the vehicle is parking.
double getHarmonoise_NoiseEmissions() const
Returns noise emissions of the current state.
int getPersonNumber() const
Returns the number of persons.
double getRelativeStateOfCharge() const
Returns actual relative state of charge of battery (-)
MSRouteIterator myCurrEdge
Iterator to current route-edge.
const std::vector< std::string > & getParkingBadges() const
get the valid parking access rights (vehicle settings override vehicle type settings)
ConstMSRoutePtr myRoute
This vehicle's route.
double getWidth() const
Returns the vehicle's width.
double getStateOfCharge() const
Returns actual state of charge of battery (Wh) RICE_CHECK: This may be a misnomer,...
double getWaitingSeconds() const
Returns the number of seconds waited (speed was lesser than 0.1m/s)
bool hasStops() const
Returns whether the vehicle has to stop somewhere.
std::string getPrefixedParameter(const std::string &key, std::string &error) const
retrieve parameters of devices, models and the vehicle itself
SUMOVehicleClass getVClass() const
Returns the vehicle's access class.
bool addStop(const SUMOVehicleParameter::Stop &stopPar, std::string &errorMsg, SUMOTime untilOffset=0, MSRouteIterator *searchStart=nullptr)
Adds a stop.
double getChargedEnergy() const
Returns the energy charged to the battery in the current time step (Wh)
int getRoutePosition() const
return index of edge within route
SUMOTime getDepartDelay() const
Returns the depart delay.
double getElecHybridCurrent() const
Returns actual current (A) of ElecHybrid device RICE_CHECK: Is this the current consumed from the ove...
const SUMOVehicleParameter * myParameter
This vehicle's parameter.
int getNumberReroutes() const
Returns the number of new routes this vehicle got.
bool reroute(SUMOTime t, const std::string &info, SUMOAbstractRouter< MSEdge, SUMOVehicle > &router, const bool onInit=false, const bool withTaz=false, const bool silent=false, const MSEdge *sink=nullptr)
Performs a rerouting using the given router.
int getRNGIndex() const
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
bool isStopped() const
Returns whether the vehicle is at a stop.
MSDevice * getDevice(const std::type_info &type) const
Returns a device of the given type if it exists, nullptr otherwise.
int getContainerNumber() const
Returns the number of containers.
bool replaceRouteEdges(ConstMSEdgeVector &edges, double cost, double savings, const std::string &info, bool onInit=false, bool check=false, bool removeStops=true, std::string *msgReturn=nullptr)
Replaces the current route by the given edges.
double getMaxDecel() const
Get the vehicle type's maximal comfortable deceleration [m/s^2].
Definition MSCFModel.h:264
Battery device for electric vehicles.
A device which collects info on the vehicle trip (mainly on departure and arrival)
A device that performs vehicle rerouting based on current edge speeds.
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
Definition MSEdge.h:168
const std::vector< double > getSubLaneSides() const
Returns the right side offsets of this edge's sublanes.
Definition MSEdge.h:661
static bool gModelParkingManoeuver
whether parking simulation includes manoeuver time and any associated lane blocking
Definition MSGlobals.h:162
static double gLateralResolution
Definition MSGlobals.h:100
static bool gLefthand
Whether lefthand-drive is being simulated.
Definition MSGlobals.h:174
static bool gSublane
whether sublane simulation is enabled (sublane model or continuous lanechanging)
Definition MSGlobals.h:165
static SUMOTime gLaneChangeDuration
Definition MSGlobals.h:97
static SUMOTime gWaitingTimeMemory
length of memory for waiting times (in millisecs)
Definition MSGlobals.h:115
Representation of a lane in the micro simulation.
Definition MSLane.h:84
virtual double getLengthGeometryFactor(bool) const
Definition MSLane.h:290
double getLength() const
Returns the lane's length.
Definition MSLane.h:606
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the lane's maximum speed, given a vehicle's speed limit adaptation.
Definition MSLane.h:574
bool isInternal() const
Definition MSLane.cpp:2546
MSLane * getBidiLane() const
retrieve bidirectional lane or nullptr
Definition MSLane.cpp:4565
virtual const PositionVector & getShape(bool) const
Definition MSLane.h:294
MSEdge & getEdge() const
Returns the lane's edge.
Definition MSLane.h:764
double getWidth() const
Returns the lane's width.
Definition MSLane.h:635
const Position geometryPositionAtOffset(double offset, double lateralOffset=0) const
Definition MSLane.h:560
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition MSNet.cpp:186
MSVehicleRouter & getRouterTT(const int rngIndex, const MSEdgeVector &prohibited=MSEdgeVector()) const
Definition MSNet.cpp:1508
static MSVehicleRouter & getRouterTT(const int rngIndex, SUMOVehicleClass svc, const MSEdgeVector &prohibited=MSEdgeVector())
return the vehicle router instance
A lane area vehicles can halt at.
double getBeginLanePosition() const
Returns the begin position of this stop.
double getEndLanePosition() const
Returns the end position of this stop.
const MSLane & getLane() const
Returns the lane this stop is located at.
A class that helps computing positions of a train's carriages and additional structures.
int getFirstCarriageNo() const
double getFirstCarriageLength() const
bool isReversed() const
const std::vector< Carriage * > & getCarriages() const
double getCarriageLength() const
int getNumCarriages() const
double getUpscaleLength() const
int getFirstPassengerCarriage() const
double getHalfWidth() const
bool isRemoteAffected(SUMOTime t) const
Representation of a vehicle in the micro simulation.
Definition MSVehicle.h:77
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)
double getTimeGapOnLane() const
Returns the time gap in seconds to the leader of the vehicle on the same lane.
double getStopDelay() const
Returns the public transport stop delay in seconds.
bool isOnRoad() const
Returns the information whether the vehicle is on a road (is simulated)
Definition MSVehicle.h:605
bool isActive() const
Returns whether the current simulation step is an action point for the vehicle.
Definition MSVehicle.h:628
double getTimeLossSeconds() const
Returns the time loss in seconds.
Definition MSVehicle.h:720
double getAccumulatedWaitingSeconds() const
Returns the number of seconds waited (speed was lesser than 0.1m/s) within the last millisecs.
Definition MSVehicle.h:714
SUMOTime getWaitingTime(const bool accumulated=false) const
Returns the SUMOTime waited (speed was lesser than 0.1m/s)
Definition MSVehicle.h:670
double getTimeSinceStartupSeconds() const
Definition MSVehicle.h:691
MSAbstractLaneChangeModel & getLaneChangeModel()
bool isActionStep(SUMOTime t) const
Returns whether the next simulation step will be an action point for the vehicle.
Definition MSVehicle.h:635
MSAbstractLaneChangeModel * myLaneChangeModel
Definition MSVehicle.h:1882
std::vector< MSLane * > myFurtherLanes
The information into which lanes the vehicle laps into.
Definition MSVehicle.h:1909
bool signalSet(int which) const
Returns whether the given signal is on.
Definition MSVehicle.h:1186
double getAcceleration() const
Returns the vehicle's acceleration in m/s (this is computed as the last step's mean acceleration in c...
Definition MSVehicle.h:514
const std::vector< MSLane * > & getBestLanesContinuation() const
Returns the best sequence of lanes to continue the route starting at myLane.
int getBestLaneOffset() const
double getStopArrivalDelay() const
Returns the estimated public transport stop arrival delay in seconds.
@ VEH_SIGNAL_BLINKER_RIGHT
Right blinker lights are switched on.
Definition MSVehicle.h:1108
@ VEH_SIGNAL_BRAKELIGHT
The brake lights are on.
Definition MSVehicle.h:1114
@ VEH_SIGNAL_EMERGENCY_BLUE
A blue emergency light is on.
Definition MSVehicle.h:1130
@ VEH_SIGNAL_BLINKER_LEFT
Left blinker lights are switched on.
Definition MSVehicle.h:1110
@ VEH_SIGNAL_BLINKER_EMERGENCY
Blinker lights on both sides are switched on.
Definition MSVehicle.h:1112
const MSLane * getLane() const
Returns the lane the vehicle is on.
Definition MSVehicle.h:581
bool isLeader(const MSLink *link, const MSVehicle *veh, const double gap) const
whether the given vehicle must be followed at the given junction
Influencer & getInfluencer()
std::vector< std::vector< LaneQ > > myBestLanes
Definition MSVehicle.h:1892
double getLateralPositionOnLane() const
Get the vehicle's lateral position on the lane.
Definition MSVehicle.h:413
double getSlope() const
Returns the slope of the road at vehicle's position in degrees.
double getSpeed() const
Returns the vehicle's current speed.
Definition MSVehicle.h:490
const MSCFModel & getCarFollowModel() const
Returns the vehicle's car following model definition.
Definition MSVehicle.h:969
double getPositionOnLane() const
Get the vehicle's position along the lane.
Definition MSVehicle.h:374
MSLane * myLane
The lane the vehicle is on.
Definition MSVehicle.h:1880
bool hasInfluencer() const
whether the vehicle is individually influenced (via TraCI or special parameters)
Definition MSVehicle.h:1680
DriveItemVector myLFLinkLanes
container for the planned speeds in the current step
Definition MSVehicle.h:2010
The car-following model and parameter.
double getMinGapLat() const
Get the minimum lateral gap that vehicles of this type maintain.
double getWidth() const
Get the width which vehicles of this class shall have when being drawn.
SUMOVehicleClass getVehicleClass() const
Get this vehicle type's vehicle class.
const LatAlignmentDefinition & getPreferredLateralAlignment() const
Get vehicle's preferred lateral alignment procedure.
int getPersonCapacity() const
Get this vehicle type's person capacity.
const std::string & getID() const
Returns the name of the vehicle type.
double getMinGap() const
Get the free space in front of vehicles of this class.
SUMOTime getLoadingDuration(const bool isPerson) const
Get this vehicle type's loading duration.
double getHeight() const
Get the height which vehicles of this class shall have when being drawn.
double getActionStepLengthSecs() const
Returns this type's default action step length in seconds.
double getMaxSpeedLat() const
Get vehicle's maximum lateral speed [m/s].
SUMOEmissionClass getEmissionClass() const
Get this vehicle type's emission class.
double getLength() const
Get vehicle's length [m].
SUMOVehicleShape getGuiShape() const
Get this vehicle type's shape.
double getMass() const
Get this vehicle type's mass.
std::string getImgFile() const
Get this vehicle type's raster model file name.
const SUMOVTypeParameter & getParameter() const
double getPreferredLateralAlignmentOffset() const
Get vehicle's preferred lateral alignment offset (in m from center line)
int getContainerCapacity() const
Get this vehicle type's container capacity.
static std::string getIDSecure(const T *obj, const std::string &fallBack="NULL")
get an identifier for Named-like object which may be Null
Definition Named.h:67
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.
static std::string getName(const SUMOEmissionClass c)
Checks whether the string describes a known vehicle class.
A point in 2D or 3D with translation and scaling methods.
Definition Position.h:37
static const Position INVALID
used to indicate that a position is valid
Definition Position.h:322
double distanceTo2D(const Position &p2) const
returns the euclidean distance in the x-y-plane
Definition Position.h:276
double x() const
Returns the x-position.
Definition Position.h:55
double z() const
Returns the z-position.
Definition Position.h:65
double angleTo2D(const Position &other) const
returns the angle in the plane of the vector pointing from here to the other position (in radians bet...
Definition Position.h:286
double y() const
Returns the y-position.
Definition Position.h:60
A list of positions.
double length() const
Returns the length.
double rotationAtOffset(double pos) const
Returns the rotation at the given length.
Position positionAtOffset(double pos, double lateralOffset=0) const
Returns the position at the given length.
void move2side(double amount, double maxExtension=100)
move position vector to side using certain amount
double angleAt2D(int pos) const
get angle in certain position of position vector (in radians between -M_PI and M_PI)
RGBColor changedBrightness(int change, int toChange=3) const
Returns a new color with altered brightness.
Definition RGBColor.cpp:200
bool wasSet(long long int what) const
Returns whether the given parameter was set.
Distribution_Parameterized speedFactor
The factor by which the maximum speed may deviate from the allowed max speed on the street.
SubParams lcParameter
Lane-changing parameter.
SubParams jmParameter
Junction-model parameter.
std::string getManoeuverAngleTimesS() const
Returns myManoeuverAngleTimes as a string for xml output.
Definition of vehicle stop (position and duration)
ParkingType parking
whether the vehicle is removed from the net while stopping
std::string lane
The lane to stop at.
double startPos
The stopping position start.
int parametersSet
Information for the output which parameter were set.
int index
at which position in the stops list
SUMOTime until
The time at which the vehicle may continue its journey.
bool triggered
whether an arriving person lets the vehicle continue
double endPos
The stopping position end.
std::string busstop
(Optional) bus stop if one is assigned to the stop
bool containerTriggered
whether an arriving container lets the vehicle continue
SUMOTime duration
The stopping duration.
Structure representing possible vehicle parameter.
std::vector< Stop > stops
List of the stops the vehicle will make, TraCI may add entries here.
std::string line
The vehicle's line (mainly for public transport)
static StringBijection< SumoXMLTag > CarFollowModels
car following models
static StringBijection< LaneChangeModel > LaneChangeModels
lane change models
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 std::string wrapText(const std::string s, int width)
remove leading and trailing whitespace
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
Drive process items represent bounds on the safe velocity corresponding to the upcoming links.
Definition MSVehicle.h:1949
double getLeaveSpeed() const
Definition MSVehicle.h:2000