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-2018 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_ELECTRIC}, // !!! deprecated
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 // ===========================================================================
134 // additional constants
135 // ===========================================================================
136 
138 const SVCPermissions SVCAll = 2 * SUMOVehicleClass_MAX - 1; // all relevant bits set to 1
140 
141 
142 // ===========================================================================
143 // method definitions
144 // ===========================================================================
145 // ------------ Conversion of SUMOVehicleClass
146 
147 std::string
148 getVehicleClassNames(SVCPermissions permissions, bool expand) {
149  if (permissions == SVCAll && !expand) {
150  return "all";
151  }
152  return joinToString(getVehicleClassNamesList(permissions), ' ');
153 }
154 
155 
156 std::vector<std::string>
159  const std::vector<std::string> classNames = SumoVehicleClassStrings.getStrings();
160  std::vector<std::string> result;
161  for (std::vector<std::string>::const_iterator it = classNames.begin(); it != classNames.end(); it++) {
162  const int svc = (int)SumoVehicleClassStrings.get(*it);
163  if ((svc & permissions) == svc && svc != SVC_IGNORING) {
164  result.push_back(*it);
165  }
166  }
167  return result;
168 }
169 
170 
172 getVehicleClassID(const std::string& name) {
173  if (SumoVehicleClassStrings.hasString(name)) {
174  return SumoVehicleClassStrings.get(name);
175  }
176  throw InvalidArgument("Unknown vehicle class '" + name + "'.");
177 }
178 
179 
180 int
181 getVehicleClassCompoundID(const std::string& name) {
182  int ret = SVC_IGNORING;
183  const std::vector<std::string> names = SumoVehicleClassStrings.getStrings();
184  for (std::vector<std::string>::const_iterator it = names.begin(); it != names.end(); it++) {
185  if (name.find(*it) != std::string::npos) {
186  ret = ret | (int) SumoVehicleClassStrings.get(*it);
187  }
188  }
189  return ret;
190 }
191 
192 
194 parseVehicleClasses(const std::string& allowedS) {
195  if (allowedS == "all") {
196  return SVCAll;
197  }
198  SVCPermissions result = 0;
199  StringTokenizer sta(allowedS, " ");
200  while (sta.hasNext()) {
201  const std::string s = sta.next();
202  if (!SumoVehicleClassStrings.hasString(s)) {
203  WRITE_ERROR("Unknown vehicle class '" + s + "' encountered.");
204  } else {
205  const SUMOVehicleClass vc = getVehicleClassID(s);
206  const std::string& realName = SumoVehicleClassStrings.getString(vc);
207  if (realName != s) {
209  }
210  result |= vc;
211  }
212  }
213  return result;
214 }
215 
216 
217 bool
218 canParseVehicleClasses(const std::string& classes) {
219  if (classes == "all") {
220  return true;
221  }
222  StringTokenizer sta(classes, " ");
223  while (sta.hasNext()) {
224  if (!SumoVehicleClassStrings.hasString(sta.next())) {
225  return false;
226  }
227  }
228  return true;
229 }
230 
231 
232 extern SVCPermissions parseVehicleClasses(const std::string& allowedS, const std::string& disallowedS) {
233  if (allowedS.size() == 0 && disallowedS.size() == 0) {
234  return SVCAll;
235  } else if (allowedS.size() > 0 && disallowedS.size() > 0) {
236  WRITE_WARNING("SVCPermissions must be specified either via 'allow' or 'disallow'. Ignoring 'disallow'");
237  return parseVehicleClasses(allowedS);
238  } else if (allowedS.size() > 0) {
239  return parseVehicleClasses(allowedS);
240  } else {
241  return invertPermissions(parseVehicleClasses(disallowedS));
242  }
243 }
244 
245 extern SVCPermissions
247  return SVCAll & ~permissions;
248 }
249 
251 parseVehicleClasses(const std::vector<std::string>& allowedS) {
252  SVCPermissions result = 0;
253  for (std::vector<std::string>::const_iterator i = allowedS.begin(); i != allowedS.end(); ++i) {
254  const SUMOVehicleClass vc = getVehicleClassID(*i);
255  const std::string& realName = SumoVehicleClassStrings.getString(vc);
256  if (realName != *i) {
257  WRITE_WARNING("The vehicle class '" + (*i) + "' is deprecated, use '" + realName + "' instead.");
258  }
259  result |= getVehicleClassID(*i);
260  }
261  return result;
262 }
263 
264 
265 void
267  if (permissions == SVCAll) {
268  return;
269  } else if (permissions == 0) {
270  into.writeAttr(SUMO_ATTR_DISALLOW, "all");
271  return;
272  } else {
273  int num_allowed = 0;
274  for (int mask = 1; mask <= SUMOVehicleClass_MAX; mask = mask << 1) {
275  if ((mask & permissions) == mask) {
276  ++num_allowed;
277  }
278  }
279  if (num_allowed <= (SumoVehicleClassStrings.size() - num_allowed) && num_allowed > 0) {
280  into.writeAttr(SUMO_ATTR_ALLOW, getVehicleClassNames(permissions));
281  } else {
283  }
284  }
285 }
286 
287 
288 void
290  if (preferred == SVCAll || preferred == 0) {
291  return;
292  } else {
294  }
295 }
296 
297 
299 getVehicleShapeID(const std::string& name) {
300  if (SumoVehicleShapeStrings.hasString(name)) {
301  return SumoVehicleShapeStrings.get(name);
302  } else {
303  throw InvalidArgument("Unknown vehicle shape '" + name + "'.");
304  }
305 }
306 
307 
308 bool canParseVehicleShape(const std::string& shape) {
309  return SumoVehicleShapeStrings.hasString(shape);
310 }
311 
312 
313 std::string
315  return SumoVehicleShapeStrings.getString(id);
316 }
317 
318 
319 bool isRailway(SVCPermissions permissions) {
320  return (permissions & SVC_RAIL_CLASSES) > 0 && (permissions & SVC_PASSENGER) == 0;
321 }
322 
323 
324 bool isWaterway(SVCPermissions permissions) {
325  return permissions == SVC_SHIP;
326 }
327 
328 
329 bool isForbidden(SVCPermissions permissions) {
330  return (permissions & SVCAll) == 0;
331 }
332 
333 bool isSidewalk(SVCPermissions permissions) {
334  return (permissions & SVCAll) == SVC_PEDESTRIAN;
335 }
336 
337 bool noVehicles(SVCPermissions permissions) {
338  return isForbidden(permissions) || isSidewalk(permissions);
339 }
340 
341 std::map<SVCPermissions, double> parseStopOffsets(const SUMOSAXAttributes& attrs, bool& ok) {
342  const std::string vClasses = attrs.getOpt<std::string>(SUMO_ATTR_VCLASSES, nullptr, ok, "");
343  const std::string exceptions = attrs.getOpt<std::string>(SUMO_ATTR_EXCEPTIONS, nullptr, ok, "");
344  if (attrs.hasAttribute(SUMO_ATTR_VCLASSES) && attrs.hasAttribute(SUMO_ATTR_EXCEPTIONS)) {
345  WRITE_ERROR("Simultaneous specification of vClasses and exceptions is not allowed!");
346  ok = false;
347  return std::map<SVCPermissions, double>();
348  }
349  const double value = attrs.get<double>(SUMO_ATTR_VALUE, nullptr, ok);
350 
351  int vClassBitset;
352  if (attrs.hasAttribute(SUMO_ATTR_VCLASSES)) {
353  vClassBitset = parseVehicleClasses(vClasses);
354  } else if (attrs.hasAttribute(SUMO_ATTR_EXCEPTIONS)) {
355  vClassBitset = ~parseVehicleClasses(exceptions);
356  } else {
357  // no vClasses specified, thus apply to all
358  vClassBitset = parseVehicleClasses("all");
359  }
360 
361  std::map<SVCPermissions, double> offsets;
362  offsets[vClassBitset] = value;
363  return offsets;
364 }
365 
366 
367 const std::string DEFAULT_VTYPE_ID("DEFAULT_VEHTYPE");
368 const std::string DEFAULT_PEDTYPE_ID("DEFAULT_PEDTYPE");
369 const std::string DEFAULT_BIKETYPE_ID("DEFAULT_BIKETYPE");
370 
371 const double DEFAULT_VEH_PROB(1.);
372 
373 const double DEFAULT_PEDESTRIAN_SPEED(5. / 3.6);
374 
375 const double DEFAULT_CONTAINER_TRANSHIP_SPEED(5. / 3.6);
376 
377 /****************************************************************************/
378 
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
std::string getVehicleClassNames(SVCPermissions permissions, bool expand)
Returns the ids of the given classes, divided using a &#39; &#39;.
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
is a pedestrian
std::string next()
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
StringBijection< SUMOVehicleShape > SumoVehicleShapeStrings(sumoVehicleShapeStringInitializer, SVS_UNKNOWN, false)
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
std::vector< std::string > getVehicleClassNamesList(SVCPermissions permissions)
Returns the ids of the given classes, divided using a &#39; &#39;.
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.
render as a delivery vehicle
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.
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
vehicle is a (possibly fast moving) electric rail
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:241
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
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)
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:247
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
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
render as a semi-trailer transport vehicle ("Sattelschlepper")
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
Definition: ToString.h:237
vehicles ignoring classes
const SVCPermissions SVC_UNSPECIFIED
permissions not specified
render as a trolley bus
is a user-defined type
is an electric vehicle