Eclipse SUMO - Simulation of Urban MObility
SUMOVehicleClass.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-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
19 // Definitions of SUMO vehicle classes and helper functions
20 /****************************************************************************/
21 
22 
23 // ===========================================================================
24 // included modules
25 // ===========================================================================
26 #include <config.h>
27 
28 #include <string>
29 #include <map>
30 #include "SUMOVehicleClass.h"
32 #include <utils/common/ToString.h>
37 
38 
39 // ===========================================================================
40 // static members
41 // ===========================================================================
42 
44  {"ignoring", SVC_IGNORING},
45  {"private", SVC_PRIVATE},
46  {"public_emergency", SVC_EMERGENCY}, // !!! deprecated
47  {"emergency", SVC_EMERGENCY},
48  {"public_authority", SVC_AUTHORITY}, // !!! deprecated
49  {"authority", SVC_AUTHORITY},
50  {"public_army", SVC_ARMY}, // !!! deprecated
51  {"army", SVC_ARMY},
52  {"vip", SVC_VIP},
53  {"passenger", SVC_PASSENGER},
54  {"hov", SVC_HOV},
55  {"taxi", SVC_TAXI},
56  {"public_transport", SVC_BUS}, // !!! deprecated
57  {"bus", SVC_BUS},
58  {"coach", SVC_COACH},
59  {"delivery", SVC_DELIVERY},
60  {"transport", SVC_TRUCK},
61  {"truck", SVC_TRUCK},
62  {"trailer", SVC_TRAILER},
63  {"lightrail", SVC_TRAM}, // !!! deprecated
64  {"tram", SVC_TRAM},
65  {"cityrail", SVC_RAIL_URBAN}, // !!! deprecated
66  {"rail_urban", SVC_RAIL_URBAN},
67  {"rail_slow", SVC_RAIL}, // !!! deprecated
68  {"rail", SVC_RAIL},
69  {"rail_fast", SVC_RAIL_FAST},
70  {"rail_electric", SVC_RAIL_ELECTRIC},
71  {"motorcycle", SVC_MOTORCYCLE},
72  {"moped", SVC_MOPED},
73  {"bicycle", SVC_BICYCLE},
74  {"pedestrian", SVC_PEDESTRIAN},
75  {"evehicle", SVC_E_VEHICLE},
76  {"ship", SVC_SHIP},
77  {"custom1", SVC_CUSTOM1},
78  {"custom2", SVC_CUSTOM2}
79 };
80 
82  sumoVehicleClassStringInitializer, SVC_CUSTOM2, false);
83 
84 
85 std::set<std::string> deprecatedVehicleClassesSeen;
86 
87 
89  {"pedestrian", SVS_PEDESTRIAN},
90  {"bicycle", SVS_BICYCLE},
91  {"moped", SVS_MOPED},
92  {"motorcycle", SVS_MOTORCYCLE},
93  {"passenger", SVS_PASSENGER},
94  {"passenger/sedan", SVS_PASSENGER_SEDAN},
95  {"passenger/hatchback", SVS_PASSENGER_HATCHBACK},
96  {"passenger/wagon", SVS_PASSENGER_WAGON},
97  {"passenger/van", SVS_PASSENGER_VAN},
98  {"delivery", SVS_DELIVERY},
99  {"transport", SVS_TRUCK}, // !!! deprecated
100  {"truck", SVS_TRUCK},
101  {"transport/semitrailer", SVS_TRUCK_SEMITRAILER}, // !!! deprecated
102  {"truck/semitrailer", SVS_TRUCK_SEMITRAILER},
103  {"transport/trailer", SVS_TRUCK_1TRAILER}, // !!! deprecated
104  {"truck/trailer", SVS_TRUCK_1TRAILER},
105  {"bus/city", SVS_BUS}, // !!! deprecated
106  {"bus", SVS_BUS},
107  {"bus/overland", SVS_BUS_COACH}, // !!! deprecated
108  {"bus/coach", SVS_BUS_COACH},
109  {"bus/flexible", SVS_BUS_FLEXIBLE},
110  {"bus/trolley", SVS_BUS_TROLLEY},
111  {"rail/slow", SVS_RAIL}, // !!! deprecated
112  {"rail/fast", SVS_RAIL}, // !!! deprecated
113  {"rail", SVS_RAIL},
114  {"rail/light", SVS_RAIL_CAR}, // !!! deprecated
115  {"rail/city", SVS_RAIL_CAR}, // !!! deprecated
116  {"rail/railcar", SVS_RAIL_CAR},
117  {"rail/cargo", SVS_RAIL_CARGO},
118  {"evehicle", SVS_E_VEHICLE},
119  {"ant", SVS_ANT},
120  {"ship", SVS_SHIP},
121  {"emergency", SVS_EMERGENCY},
122  {"firebrigade", SVS_FIREBRIGADE},
123  {"police", SVS_POLICE},
124  {"rickshaw", SVS_RICKSHAW },
125  {"", SVS_UNKNOWN}
126 };
127 
128 
130  sumoVehicleShapeStringInitializer, SVS_UNKNOWN, false);
131 
132 // ===========================================================================
133 // static values used for cached
134 // ===========================================================================
135 
136 static std::map<int, std::vector<std::string> > vehicleClassNamesListCached;
137 static std::map<std::string, SVCPermissions> parseVehicleClassesCached;
138 static std::map<SVCPermissions, std::string> getVehicleClassNamesCached;
139 static std::string vehicleClassNameAll = "all";
140 
141 // ===========================================================================
142 // additional constants
143 // ===========================================================================
144 
146 
147 const SVCPermissions SVCAll = 2 * SUMOVehicleClass_MAX - 1; // all relevant bits set to 1
148 
150 
151 const std::string DEFAULT_VTYPE_ID("DEFAULT_VEHTYPE");
152 
153 const std::string DEFAULT_PEDTYPE_ID("DEFAULT_PEDTYPE");
154 
155 const std::string DEFAULT_BIKETYPE_ID("DEFAULT_BIKETYPE");
156 
157 const double DEFAULT_VEH_PROB(1.);
158 
159 const double DEFAULT_PEDESTRIAN_SPEED(5. / 3.6);
160 
161 const double DEFAULT_CONTAINER_TRANSHIP_SPEED(5. / 3.6);
162 
163 // ===========================================================================
164 // method definitions
165 // ===========================================================================
166 // ------------ Conversion of SUMOVehicleClass
167 
168 const std::string&
169 getVehicleClassNames(SVCPermissions permissions, bool expand) {
170  if (permissions == SVCAll && !expand) {
171  return vehicleClassNameAll;
172  }
173  // check if previously was cached
174  if (getVehicleClassNamesCached.count(permissions) == 0) {
175  getVehicleClassNamesCached[permissions] = joinToString(getVehicleClassNamesList(permissions), ' ');
176  }
177  return getVehicleClassNamesCached.at(permissions);
178 }
179 
180 
181 const std::vector<std::string>&
183  // first check if it's cached
184  if (vehicleClassNamesListCached.count(permissions) == 0) {
185  const std::vector<std::string> classNames = SumoVehicleClassStrings.getStrings();
186  std::vector<std::string> result;
187  for (std::vector<std::string>::const_iterator it = classNames.begin(); it != classNames.end(); it++) {
188  const int svc = (int)SumoVehicleClassStrings.get(*it);
189  if ((svc & permissions) == svc && svc != SVC_IGNORING) {
190  result.push_back(*it);
191  }
192  }
193  // add it into vehicleClassNamesListCached
194  vehicleClassNamesListCached[permissions] = result;
195  }
196  return vehicleClassNamesListCached.at(permissions);
197 }
198 
199 
201 getVehicleClassID(const std::string& name) {
202  if (SumoVehicleClassStrings.hasString(name)) {
203  return SumoVehicleClassStrings.get(name);
204  }
205  throw InvalidArgument("Unknown vehicle class '" + name + "'.");
206 }
207 
208 
209 int
210 getVehicleClassCompoundID(const std::string& name) {
211  int ret = SVC_IGNORING;
212  const std::vector<std::string> names = SumoVehicleClassStrings.getStrings();
213  for (std::vector<std::string>::const_iterator it = names.begin(); it != names.end(); it++) {
214  if (name.find(*it) != std::string::npos) {
215  ret = ret | (int) SumoVehicleClassStrings.get(*it);
216  }
217  }
218  return ret;
219 }
220 
221 
223 parseVehicleClasses(const std::string& allowedS) {
224  if (allowedS == "all") {
225  return SVCAll;
226  }
227  // check if allowedS was previously cached
228  if (parseVehicleClassesCached.count(allowedS) == 0) {
229  SVCPermissions result = 0;
230  StringTokenizer sta(allowedS, " ");
231  while (sta.hasNext()) {
232  const std::string s = sta.next();
233  if (!SumoVehicleClassStrings.hasString(s)) {
234  WRITE_ERROR("Unknown vehicle class '" + s + "' encountered.");
235  } else {
236  const SUMOVehicleClass vc = getVehicleClassID(s);
237  const std::string& realName = SumoVehicleClassStrings.getString(vc);
238  if (realName != s) {
240  }
241  result |= vc;
242  }
243  }
244  // save parsed vehicle class cached
245  parseVehicleClassesCached[allowedS] = result;
246  }
247  return parseVehicleClassesCached.at(allowedS);
248 }
249 
250 
251 bool
252 canParseVehicleClasses(const std::string& classes) {
253  if (classes == "all") {
254  return true;
255  }
256  // check if was previously cached
257  if (parseVehicleClassesCached.count(classes) != 0) {
258  return true;
259  }
260  StringTokenizer sta(classes, " ");
261  while (sta.hasNext()) {
262  if (!SumoVehicleClassStrings.hasString(sta.next())) {
263  return false;
264  }
265  }
266  return true;
267 }
268 
269 
271 parseVehicleClasses(const std::string& allowedS, const std::string& disallowedS, double networkVersion) {
272  if (allowedS.size() == 0 && disallowedS.size() == 0) {
273  return SVCAll;
274  } else if (allowedS.size() > 0 && disallowedS.size() > 0) {
275  WRITE_WARNING("SVCPermissions must be specified either via 'allow' or 'disallow'. Ignoring 'disallow'");
276  return parseVehicleClasses(allowedS);
277  } else if (allowedS.size() > 0) {
278  return parseVehicleClasses(allowedS);
279  } else {
280  return invertPermissions(parseVehicleClasses(disallowedS) | (networkVersion < 1.3 ? SVC_RAIL_FAST : 0));
281  }
282 }
283 
284 
287  return SVCAll & ~permissions;
288 }
289 
290 
292 parseVehicleClasses(const std::vector<std::string>& allowedS) {
293  SVCPermissions result = 0;
294  if (std::find(allowedS.begin(), allowedS.end(), "all") != allowedS.end()) {
295  return SVCAll;
296  }
297  for (std::vector<std::string>::const_iterator i = allowedS.begin(); i != allowedS.end(); ++i) {
298  const SUMOVehicleClass vc = getVehicleClassID(*i);
299  const std::string& realName = SumoVehicleClassStrings.getString(vc);
300  if (realName != *i) {
301  WRITE_WARNING("The vehicle class '" + (*i) + "' is deprecated, use '" + realName + "' instead.");
302  }
303  result |= getVehicleClassID(*i);
304  }
305  return result;
306 }
307 
308 
309 void
311  if (permissions == SVCAll) {
312  return;
313  } else if (permissions == 0) {
314  into.writeAttr(SUMO_ATTR_DISALLOW, "all");
315  return;
316  } else {
317  int num_allowed = 0;
318  for (int mask = 1; mask <= SUMOVehicleClass_MAX; mask = mask << 1) {
319  if ((mask & permissions) == mask) {
320  ++num_allowed;
321  }
322  }
323  if (num_allowed <= (SumoVehicleClassStrings.size() - num_allowed) && num_allowed > 0) {
324  into.writeAttr(SUMO_ATTR_ALLOW, getVehicleClassNames(permissions));
325  } else {
327  }
328  }
329 }
330 
331 
332 void
334  if (preferred == SVCAll || preferred == 0) {
335  return;
336  } else {
338  }
339 }
340 
341 
343 getVehicleShapeID(const std::string& name) {
344  if (SumoVehicleShapeStrings.hasString(name)) {
345  return SumoVehicleShapeStrings.get(name);
346  } else {
347  throw InvalidArgument("Unknown vehicle shape '" + name + "'.");
348  }
349 }
350 
351 
352 bool
353 canParseVehicleShape(const std::string& shape) {
354  return SumoVehicleShapeStrings.hasString(shape);
355 }
356 
357 
358 std::string
360  return SumoVehicleShapeStrings.getString(id);
361 }
362 
363 
364 bool isRailway(SVCPermissions permissions) {
365  return (permissions & SVC_RAIL_CLASSES) > 0 && (permissions & SVC_PASSENGER) == 0;
366 }
367 
368 
369 bool
371  return permissions == SVC_SHIP;
372 }
373 
374 
375 bool
377  return (permissions & SVCAll) == 0;
378 }
379 
380 
381 bool
383  return (permissions & SVCAll) == SVC_PEDESTRIAN;
384 }
385 
386 
387 bool
389  return isForbidden(permissions) || isSidewalk(permissions);
390 }
391 
392 
393 std::map<SVCPermissions, double> parseStopOffsets(const SUMOSAXAttributes& attrs, bool& ok) {
394  const std::string vClasses = attrs.getOpt<std::string>(SUMO_ATTR_VCLASSES, nullptr, ok, "");
395  const std::string exceptions = attrs.getOpt<std::string>(SUMO_ATTR_EXCEPTIONS, nullptr, ok, "");
396  if (attrs.hasAttribute(SUMO_ATTR_VCLASSES) && attrs.hasAttribute(SUMO_ATTR_EXCEPTIONS)) {
397  WRITE_ERROR("Simultaneous specification of vClasses and exceptions is not allowed!");
398  ok = false;
399  return std::map<SVCPermissions, double>();
400  }
401  const double value = attrs.get<double>(SUMO_ATTR_VALUE, nullptr, ok);
402 
403  int vClassBitset;
404  if (attrs.hasAttribute(SUMO_ATTR_VCLASSES)) {
405  vClassBitset = parseVehicleClasses(vClasses);
406  } else if (attrs.hasAttribute(SUMO_ATTR_EXCEPTIONS)) {
407  vClassBitset = ~parseVehicleClasses(exceptions);
408  } else {
409  // no vClasses specified, thus apply to all
410  vClassBitset = parseVehicleClasses("all");
411  }
412 
413  std::map<SVCPermissions, double> offsets;
414  offsets[vClassBitset] = value;
415  return offsets;
416 }
417 
418 /****************************************************************************/
419 
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
void writePermissions(OutputDevice &into, SVCPermissions permissions)
writes allowed disallowed attributes if needed;
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:256
vehicle is a motorcycle
vehicle is a coach
render as a rail
std::set< std::string > deprecatedVehicleClassesSeen
std::string next()
returns the next substring when it exists. Otherwise the behaviour is undefined
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
StringBijection< SUMOVehicleShape > SumoVehicleShapeStrings(sumoVehicleShapeStringInitializer, SVS_UNKNOWN, false)
static std::map< std::string, SVCPermissions > parseVehicleClassesCached
const double DEFAULT_VEH_PROB(1.)
render as a motorcycle
vehicle is a not electrified rail
void writePreferences(OutputDevice &into, SVCPermissions preferred)
writes allowed disallowed attributes if needed;
render as a transport vehicle
const std::string & getString(const T key) const
vehicle is a bicycle
render as a flexible city bus
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
vehicle is a small delivery vehicle
vehicle is a light rail
const std::string DEFAULT_BIKETYPE_ID("DEFAULT_BIKETYPE")
std::map< SVCPermissions, double > parseStopOffsets(const SUMOSAXAttributes &attrs, bool &ok)
Extract stopOffsets from attributes of stopOffset element.
automated car (with cruise controllers)
StringBijection< SUMOVehicleClass >::Entry sumoVehicleClassStringInitializer[]
StringBijection< SUMOVehicleShape >::Entry sumoVehicleShapeStringInitializer[]
render as a sedan passenger vehicle ("Stufenheck")
bool isForbidden(SVCPermissions permissions)
Returns whether an edge with the given permission is a forbidden edge.
bool isRailway(SVCPermissions permissions)
Returns whether an edge with the given permission is a railway edge.
bool hasNext()
returns the information whether further substrings exist
const SVCPermissions SVCAll
all VClasses are allowed
vehicle is a HOV
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list...
std::vector< std::string > getStrings() const
rail vehicle that requires electrified tracks
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:239
authorities vehicles
SVCPermissions invertPermissions(SVCPermissions permissions)
negate the given permissions and ensure that only relevant bits are set
vehicle is a city rail
std::string getVehicleShapeName(SUMOVehicleShape id)
Returns the class name of the shape class given by its id.
vehicle is a large transport vehicle
static std::map< SVCPermissions, std::string > getVehicleClassNamesCached
is a user-defined type
const double DEFAULT_PEDESTRIAN_SPEED(5./3.6)
bool canParseVehicleShape(const std::string &shape)
Checks whether the given string contains only known vehicle shape.
int size() const
const int SUMOVehicleClass_MAX
const double DEFAULT_CONTAINER_TRANSHIP_SPEED(5./3.6)
static std::string vehicleClassNameAll
render as a hatchback passenger vehicle ("Fliessheck")
Encapsulated SAX-Attributes.
render as a bus
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
army vehicles
classes which drive on tracks
private vehicles
not defined
bool isWaterway(SVCPermissions permissions)
Returns whether an edge with the given permission is a waterway edge.
render as a bicycle
T get(const std::string &str) const
render as a (city) rail without locomotive
int getVehicleClassCompoundID(const std::string &name)
Returns the OR&#39;ed id of the compound class given by its name.
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
render as a van
StringBijection< SUMOVehicleClass > SumoVehicleClassStrings(sumoVehicleClassStringInitializer, SVC_CUSTOM2, false)
render as a passenger vehicle
render as a police car
vehicle is a passenger car (a "normal" car)
is an arbitrary ship
vehicle is a moped
bool canParseVehicleClasses(const std::string &classes)
Checks whether the given string contains only known vehicle classes.
render as a cargo train
render as a fire brigade
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:245
vehicle is a taxi
vehicle is a bus
render as a giant ant
render as a pedestrian
render as a moped
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue, bool report=true) const
Tries to read given attribute assuming it is an int.
SUMOVehicleShape
Definition of vehicle classes to differ between different appearences.
render as a arbitrary ship
const std::string & getVehicleClassNames(SVCPermissions permissions, bool expand)
Returns the ids of the given classes, divided using a &#39; &#39;.
vip vehicles
bool noVehicles(SVCPermissions permissions)
Returns whether an edge with the given permission forbids vehicles.
vehicle is a large transport vehicle
render as an emergency vehicle
render as a (futuristic) e-vehicle
SUMOVehicleShape getVehicleShapeID(const std::string &name)
Returns the class id of the shape class given by its name.
render as a rickshaw
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:64
bool hasString(const std::string &str) const
bool isSidewalk(SVCPermissions permissions)
Returns whether an edge with the given permission is a sidewalk.
public emergency vehicles
render as a transport vehicle with one trailer
render as a wagon passenger vehicle ("Combi")
const std::string DEFAULT_PEDTYPE_ID("DEFAULT_PEDTYPE")
const std::string DEFAULT_VTYPE_ID("DEFAULT_VEHTYPE")
render as a coach
const std::vector< std::string > & getVehicleClassNamesList(SVCPermissions permissions)
Returns the ids of the given classes, divided using a &#39; &#39;.
render as a semi-trailer transport vehicle ("Sattelschlepper")
vehicle that is allowed to drive on high-speed rail tracks
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
Definition: ToString.h:247
vehicles ignoring classes
const SVCPermissions SVC_UNSPECIFIED
permissions not specified
render as a trolley bus
is a user-defined type
static std::map< int, std::vector< std::string > > vehicleClassNamesListCached
is an electric vehicle