Eclipse SUMO - Simulation of Urban MObility
GUIMEVehicle.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2001-2023 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
20// A MSVehicle extended by some values for usage within the gui
21/****************************************************************************/
22#include <config.h>
23
34#include <guisim/GUILane.h>
35
36#include "GUIMEVehicle.h"
37
38
39// ===========================================================================
40// method definitions
41// ===========================================================================
42
44 MSVehicleType* type, const double speedFactor) :
45 MEVehicle(pars, route, type, speedFactor),
46 GUIBaseVehicle((MSBaseVehicle&) * this) {
47}
48
49
51
52
57 // add items
58 ret->mkItem("edge [id]", true, new FunctionBindingString<GUIMEVehicle>(this, &GUIMEVehicle::getEdgeID));
59 ret->mkItem("segment [#]", true, new FunctionBinding<GUIMEVehicle, int>(this, &GUIMEVehicle::getSegmentIndex));
60 ret->mkItem("queue [#]", true, new FunctionBinding<GUIMEVehicle, int>(this, &GUIMEVehicle::getQueIndex));
62 ret->mkItem("speed [m/s]", true, new FunctionBinding<GUIMEVehicle, double>(this, &MEVehicle::getSpeed));
63 ret->mkItem("angle [degree]", true, new FunctionBinding<GUIMEVehicle, double>(this, &GUIBaseVehicle::getNaviDegree));
64 ret->mkItem("waiting time [s]", true,
66 ret->mkItem("speed factor", false, getChosenSpeedFactor());
67 //ret->mkItem("time gap [s]", true,
68 // new FunctionBinding<GUIMEVehicle, double>(this, &MSVehicle::getTimeGap));
69 //ret->mkItem("waiting time [s]", true,
70 // new FunctionBinding<GUIMEVehicle, double>(this, &MSVehicle::getWaitingSeconds));
71 //ret->mkItem("impatience", true,
72 // new FunctionBinding<GUIMEVehicle, double>(this, &MSVehicle::getImpatience));
73 //ret->mkItem("last lane change [s]", true,
74 // new FunctionBinding<GUIMEVehicle, double>(this, &GUIMEVehicle::getLastLaneChangeOffset));
75 ret->mkItem("desired depart [s]", false, time2string(getParameter().depart));
76 ret->mkItem("depart delay [s]", false, time2string(getDepartDelay()));
77 ret->mkItem("odometer [m]", true,
79 if (getParameter().repetitionNumber < std::numeric_limits<int>::max()) {
80 ret->mkItem("remaining [#]", false, (int) getParameter().repetitionNumber - getParameter().repetitionsDone);
81 }
82 if (getParameter().repetitionOffset > 0) {
83 ret->mkItem("insertion period [s]", false, time2string(getParameter().repetitionOffset));
84 }
85 if (getParameter().repetitionProbability > 0) {
86 ret->mkItem("insertion probability", false, getParameter().repetitionProbability);
87 }
88 //ret->mkItem("stop info", false, getStopInfo());
89 ret->mkItem("line", false, myParameter->line);
90 //ret->mkItem("CO2 [mg/s]", true,
91 // new FunctionBinding<GUIMEVehicle, double>(this, &GUIMEVehicle::getCO2Emissions));
92 //ret->mkItem("CO [mg/s]", true,
93 // new FunctionBinding<GUIMEVehicle, double>(this, &GUIMEVehicle::getCOEmissions));
94 //ret->mkItem("HC [mg/s]", true,
95 // new FunctionBinding<GUIMEVehicle, double>(this, &GUIMEVehicle::getHCEmissions));
96 //ret->mkItem("NOx [mg/s]", true,
97 // new FunctionBinding<GUIMEVehicle, double>(this, &GUIMEVehicle::getNOxEmissions));
98 //ret->mkItem("PMx [mg/s]", true,
99 // new FunctionBinding<GUIMEVehicle, double>(this, &GUIMEVehicle::getPMxEmissions));
100 //ret->mkItem("fuel [ml/s]", true,
101 // new FunctionBinding<GUIMEVehicle, double>(this, &GUIMEVehicle::getFuelConsumption));
102 //ret->mkItem("noise (Harmonoise) [dB]", true,
103 // new FunctionBinding<GUIMEVehicle, double>(this, &GUIMEVehicle::getHarmonoise_NoiseEmissions));
104 ret->mkItem("devices", false, getDeviceDescription());
105 //ret->mkItem("persons", true,
106 // new FunctionBinding<GUIMEVehicle, int>(this, &GUIMEVehicle::getPersonNumber));
107 //ret->mkItem("containers", true,
108 // new FunctionBinding<GUIMEVehicle, int>(this, &GUIMEVehicle::getContainerNumber));
109 // meso specific values
110 ret->mkItem("event time [s]", true, new FunctionBinding<GUIMEVehicle, double>(this, &MEVehicle::getEventTimeSeconds));
112 ret->mkItem("block time [s]", true, new FunctionBinding<GUIMEVehicle, double>(this, &MEVehicle::getBlockTimeSeconds));
115 // close building
117 return ret;
118}
119
120
125 // add items
126 ret->mkItem("Type Information:", false, "");
127 ret->mkItem("type [id]", false, myType->getID());
128 ret->mkItem("length", false, myType->getLength());
129 ret->mkItem("minGap", false, myType->getMinGap());
130 ret->mkItem("vehicle class", false, SumoVehicleClassStrings.getString(myType->getVehicleClass()));
131 ret->mkItem("emission class", false, PollutantsInterface::getName(myType->getEmissionClass()));
132 ret->mkItem("maximum speed [m/s]", false, getMaxSpeed());
133 //ret->mkItem("maximum acceleration [m/s^2]", false, getCarFollowModel().getMaxAccel());
134 //ret->mkItem("maximum deceleration [m/s^2]", false, getCarFollowModel().getMaxDecel());
135 //ret->mkItem("imperfection (sigma)", false, getCarFollowModel().getImperfection());
136 //ret->mkItem("desired headway (tau)", false, getCarFollowModel().getHeadwayTime());
137 ret->mkItem("person capacity", false, myType->getPersonCapacity());
138 ret->mkItem("container capacity", false, myType->getContainerCapacity());
139 // close building
141 return ret;
142}
143
144
145void
148}
149
150
151double
152GUIMEVehicle::getColorValue(const GUIVisualizationSettings& /* s */, int activeScheme) const {
153 switch (activeScheme) {
154 case 8:
155 return getSpeed();
156 case 9:
157 return 0; // by actionStep
158 case 10:
159 return getWaitingSeconds();
160 case 11:
161 return 0; // getAccumulatedWaitingSeconds
162 case 12:
163 return 0; // invalid getLastLaneChangeOffset();
164 case 13:
165 return getSegment()->getEdge().getVehicleMaxSpeed(this);
166 case 14:
167 return 0; // invalid getEmissions<PollutantsInterface::CO2>();
168 case 15:
169 return 0; // invalid getEmissions<PollutantsInterface::CO>();
170 case 16:
171 return 0; // invalid getEmissions<PollutantsInterface::PM_X>();
172 case 17:
173 return 0; // invalid getEmissions<PollutantsInterface::NO_X>();
174 case 18:
175 return 0; // invalid getEmissions<PollutantsInterface::HC>();
176 case 19:
177 return 0; // invalid getEmissions<PollutantsInterface::FUEL>();
178 case 20:
179 return 0; // invalid getHarmonoise_NoiseEmissions();
180 case 21: // reroute number
181 if (getNumberReroutes() == 0) {
182 return -1;
183 }
184 return getNumberReroutes();
185 case 22:
187 case 23:
188 return 0; // invalid getBestLaneOffset();
189 case 24:
190 return 0; // invalid getAcceleration();
191 case 25:
192 return 0; // invalid getTimeGapOnLane();
193 case 26:
194 return STEPS2TIME(getDepartDelay());
195 case 27:
196 return 0; // electricityConsumption
197 case 28:
198 return 0; // timeLossSeconds
199 case 29:
200 return 0; // getSpeedLat
201 }
202 return 0;
203}
204
205
206
207void
208GUIMEVehicle::drawRouteHelper(const GUIVisualizationSettings& s, ConstMSRoutePtr r, bool future, bool noLoop, const RGBColor& col) const {
209 const double exaggeration = getExaggeration(s);
210 MSRouteIterator start = future ? myCurrEdge : r->begin();
211 MSRouteIterator i = start;
212 std::map<const MSLane*, int> repeatLane; // count repeated occurrences of the same edge
213 const double textSize = s.vehicleName.size / s.scale;
214 const int indexDigits = (int)toString(r->size()).size();
215 const bool s2 = s.secondaryShape;
216 for (; i != r->end(); ++i) {
217 const GUILane* lane = static_cast<GUILane*>((*i)->getLanes()[0]);
218 GLHelper::drawBoxLines(lane->getShape(s2), lane->getShapeRotations(s2), lane->getShapeLengths(s2), exaggeration);
219 if (s.showRouteIndex) {
220 std::string label = toString((int)(i - myCurrEdge));
221 const double laneAngle = lane->getShape(s2).angleAt2D(0);
222 Position pos = lane->getShape(s2).front() - Position(0, textSize * repeatLane[lane]) + Position(
223 (laneAngle >= -0.25 * M_PI && laneAngle < 0.75 * M_PI ? 1 : -1) * 0.4 * indexDigits * textSize, 0);
224 //GLHelper::drawText(label, pos, 1.0, textSize, s.vehicleName.color);
225 GLHelper::drawTextSettings(s.vehicleName, label, pos, s.scale, s.angle, 1.0);
226 }
227 if (noLoop && i != start && (*i) == (*start)) {
228 break;
229 }
230 repeatLane[lane]++;
231 }
232 drawStopLabels(s, noLoop, col);
233 drawParkingInfo(s, col);
234}
235
236
237double
239 // @todo possibly we could compute something reasonable here
240 return 0;
241}
242
243
244std::string
246 std::string result = "";
247 if (isParking()) {
248 result += "parking";
249 } else if (isStopped()) {
250 result += "stopped";
251 } else {
252 return "";
253 }
254 return result;
255}
256
257std::string
259 return getEdge()->getID();
260}
261
262int
264 return getSegment() != nullptr ? getSegment()->getIndex() : -1;
265}
266
267
268void
270 // @todo possibly we could compute something reasonable here
271}
272
273
274double
276 return s.vehicleSize.getExaggeration(s, this);
277}
278
279
282 // getPosition returns the start of the first lane, so we do not use it here
283 getEdge()->lock();
284 const double curTime = SIMTIME;
285 double vehiclePosition = 0.;
286 const MESegment* const segment = getSegment();
287 const int queIdx = getQueIndex();
288 if (segment != nullptr && queIdx != MESegment::PARKING_QUEUE) {
289 vehiclePosition = segment->getLength();
290 const std::vector<MEVehicle*>& queue = segment->getQueue(queIdx);
291 for (auto it = queue.rbegin(); it != queue.rend(); ++it) {
292 const MEVehicle* const v = *it;
293 const double intendedLeave = MIN2(v->getEventTimeSeconds(), v->getBlockTimeSeconds());
294 const double entry = v->getLastEntryTimeSeconds();
295 const double offset = segment->getLength() * (curTime - entry) / (intendedLeave - entry);
296 if (offset < vehiclePosition) {
297 vehiclePosition = offset;
298 }
299 if (v == this) {
300 break;
301 }
302 vehiclePosition -= v->getVehicleType().getLengthWithGap();
303 }
304 }
305 Boundary b;
306 const MSLane* const lane = getEdge()->getLanes()[queIdx == MESegment::PARKING_QUEUE ? 0 : queIdx];
307 b.add(lane->geometryPositionAtOffset(getPositionOnLane() + vehiclePosition));
309 getEdge()->unlock();
310 return b;
311}
312
313
314/****************************************************************************/
@ GLO_VEHICLE
a vehicle
GUISelectedStorage gSelected
A global holder of selected objects.
ConstMSEdgeVector::const_iterator MSRouteIterator
Definition: MSRoute.h:56
std::shared_ptr< const MSRoute > ConstMSRoutePtr
Definition: Route.h:32
std::string time2string(SUMOTime t)
convert SUMOTime to string
Definition: SUMOTime.cpp:68
#define STEPS2TIME(x)
Definition: SUMOTime.h:54
#define SIMTIME
Definition: SUMOTime.h:61
StringBijection< SUMOVehicleClass > SumoVehicleClassStrings(sumoVehicleClassStringInitializer, SVC_CUSTOM2, false)
T MIN2(T a, T b)
Definition: StdDefs.h:76
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:39
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
Definition: Boundary.cpp:78
Boundary & grow(double by)
extends the boundary by the given amount
Definition: Boundary.cpp:300
static void 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 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
static void drawAction_drawVehicleAsBoxPlus(const double width, const double length, bool amReversed=false)
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
double getNaviDegree() const
return the current angle in navigational degrees
void drawStopLabels(const GUIVisualizationSettings &s, bool noLoop, const RGBColor &col) const
std::string getDeviceDescription()
lists equipped device (types) for the current vehicle
const MSVehicleType & getVType() const
A shortcut to myVehicle.myType.
GUIGlID getGlID() const
Returns the numerical id of the object.
Definition: GUIGlObject.h:102
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:1065
const PositionVector & getShape(bool secondary) const override
Definition: GUILane.cpp:1059
const std::vector< double > & getShapeLengths(bool secondary) const
Definition: GUILane.cpp:1071
void drawAction_drawCarriageClass(const GUIVisualizationSettings &s, bool asImage) const
draws the given guiShape with distinct carriages/modules
std::string getStopInfo() const
retrieve information about the current stop state
GUIMEVehicle(SUMOVehicleParameter *pars, ConstMSRoutePtr route, MSVehicleType *type, const double speedFactor)
Constructor.
int getSegmentIndex() const
~GUIMEVehicle()
destructor
GUIParameterTableWindow * getParameterWindow(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own parameter window.
virtual Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
GUIParameterTableWindow * getTypeParameterWindow(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own type parameter window.
void drawRouteHelper(const GUIVisualizationSettings &s, ConstMSRoutePtr r, bool future, bool noLoop, const RGBColor &col) const
Draws the route.
double getLastLaneChangeOffset() const
Returns the time since the last lane change in seconds.
double getExaggeration(const GUIVisualizationSettings &s) const
return exaggeration associated with this GLObject
void selectBlockingFoes() const
adds the blocking foes to the current selection
double getColorValue(const GUIVisualizationSettings &s, int activeScheme) const
gets the color value according to the current scheme index
std::string getEdgeID() const
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.
bool isSelected(GUIGlObjectType type, GUIGlID id)
Returns the information whether the object with the given type and id is selected.
Stores the information about how to visualize structures.
GUIVisualizationTextSettings vehicleName
GUIVisualizationSizeSettings vehicleSize
double scale
information about a lane's width (temporary, used for a single view)
bool secondaryShape
whether secondary lane shape shall be drawn
bool showRouteIndex
Information whether the route index should be shown.
double angle
The current view rotation angle.
A single mesoscopic segment (cell)
Definition: MESegment.h:49
static const int PARKING_QUEUE
Definition: MESegment.h:52
double getLength() const
Returns the length of the segment in meters.
Definition: MESegment.h:242
const std::vector< MEVehicle * > & getQueue(int index) const
Returns the cars in the queue with the given index for visualization.
Definition: MESegment.h:217
const MSEdge & getEdge() const
Returns the edge this segment belongs to.
Definition: MESegment.h:359
int getIndex() const
Returns the running index of the segment in the edge (0 is the most upstream).
Definition: MESegment.h:226
A vehicle from the mesoscopic point of view.
Definition: MEVehicle.h:42
double getLastEntryTimeSeconds() const
Returns the entry time for the current segment.
Definition: MEVehicle.h:304
double getBlockTimeSeconds() const
Returns the time at which the vehicle was blocked on the current segment.
Definition: MEVehicle.h:309
double getCurrentStoppingTimeSeconds() const
Returns the delay that is accrued due to option –meso-tls-penalty or –meso-minor-penalty.
Definition: MEVehicle.cpp:301
double getPositionOnLane() const
Get the vehicle's position along the lane.
Definition: MEVehicle.cpp:80
MESegment * getSegment() const
Returns the current segment the vehicle is on.
Definition: MEVehicle.h:230
int getQueIndex() const
Returns the index of the que the vehicle is in.
Definition: MEVehicle.h:238
double getCurrentLinkPenaltySeconds() const
Returns the delay that is accrued due to option –meso-tls-penalty or –meso-minor-penalty.
Definition: MEVehicle.cpp:411
double getSpeed() const
Returns the vehicle's estimated speed assuming no delays.
Definition: MEVehicle.cpp:109
double getEventTimeSeconds() const
Returns the earliest leave time for the current segment.
Definition: MEVehicle.h:299
The base class for microscopic and mesoscopic vehicles.
Definition: MSBaseVehicle.h:55
double getMaxSpeed() const
Returns the maximum speed (the minimum of desired and technical maximum speed)
MSVehicleType * myType
This vehicle's type.
const SUMOVehicleParameter & getParameter() const
Returns the vehicle's parameter (including departure definition)
double getChosenSpeedFactor() const
Returns the precomputed factor by which the driver wants to be faster than the speed limit.
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.
const MSEdge * getEdge() const
Returns the edge the vehicle is currently at.
MSRouteIterator myCurrEdge
Iterator to current route-edge.
double getWidth() const
Returns the vehicle's width.
double getWaitingSeconds() const
Returns the number of seconds waited (speed was lesser than 0.1m/s)
SUMOTime getDepartDelay() const
Returns the depart delay.
const SUMOVehicleParameter * myParameter
This vehicle's parameter.
int getNumberReroutes() const
Returns the number of new routes this vehicle got.
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
bool isStopped() const
Returns whether the vehicle is at a stop.
virtual void unlock() const
release exclusive access to the mesoscopic state
Definition: MSEdge.h:747
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
Definition: MSEdge.h:168
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the maximum speed the vehicle may use on this edge.
Definition: MSEdge.cpp:1068
virtual void lock() const
grant exclusive access to the mesoscopic state
Definition: MSEdge.h:744
Representation of a lane in the micro simulation.
Definition: MSLane.h:84
const Position geometryPositionAtOffset(double offset, double lateralOffset=0) const
Definition: MSLane.h:551
The car-following model and parameter.
Definition: MSVehicleType.h:63
double getLengthWithGap() const
Get vehicle's length including the minimum gap [m].
SUMOVehicleClass getVehicleClass() const
Get this vehicle type's vehicle class.
int getPersonCapacity() const
Get this vehicle type's person capacity.
const std::string & getID() const
Returns the name of the vehicle type.
Definition: MSVehicleType.h:91
double getMinGap() const
Get the free space in front of vehicles of this class.
SUMOEmissionClass getEmissionClass() const
Get this vehicle type's emission class.
double getLength() const
Get vehicle's length [m].
const SUMOVTypeParameter & getParameter() const
int getContainerCapacity() const
Get this vehicle type's container capacity.
const std::string & getID() const
Returns the id.
Definition: Named.h:74
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
double angleAt2D(int pos) const
get angle in certain position of position vector
Structure representing possible vehicle parameter.
std::string line
The vehicle's line (mainly for public transport)
#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