Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-2026 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 : /****************************************************************************/
14 : /// @file SUMOVehicleClass.cpp
15 : /// @author Daniel Krajzewicz
16 : /// @author Jakob Erdmann
17 : /// @author Michael Behrisch
18 : /// @author Walter Bamberger
19 : /// @author Laura Bieker-Walz
20 : /// @date 2006-01-24
21 : ///
22 : // Definitions of SUMO vehicle classes and helper functions
23 : /****************************************************************************/
24 : #include <config.h>
25 :
26 : #include <string>
27 : #include <map>
28 : #include "SUMOVehicleClass.h"
29 : #include <utils/common/StringUtils.h>
30 : #include <utils/common/ToString.h>
31 : #include <utils/common/MsgHandler.h>
32 : #include <utils/common/StringTokenizer.h>
33 : #include <utils/iodevices/OutputDevice.h>
34 : #include <utils/xml/SUMOSAXAttributes.h>
35 :
36 :
37 : // ===========================================================================
38 : // static members
39 : // ===========================================================================
40 :
41 : static StringBijection<SUMOVehicleClass>::Entry sumoVehicleClassStringInitializer[] = {
42 : {"ignoring", SVC_IGNORING},
43 : {"private", SVC_PRIVATE},
44 : {"public_emergency", SVC_EMERGENCY}, // !!! deprecated
45 : {"emergency", SVC_EMERGENCY},
46 : {"public_authority", SVC_AUTHORITY}, // !!! deprecated
47 : {"authority", SVC_AUTHORITY},
48 : {"public_army", SVC_ARMY}, // !!! deprecated
49 : {"army", SVC_ARMY},
50 : {"vip", SVC_VIP},
51 : {"pedestrian", SVC_PEDESTRIAN},
52 : {"passenger", SVC_PASSENGER},
53 : {"hov", SVC_HOV},
54 : {"taxi", SVC_TAXI},
55 : {"public_transport", SVC_BUS}, // !!! deprecated
56 : {"bus", SVC_BUS},
57 : {"coach", SVC_COACH},
58 : {"delivery", SVC_DELIVERY},
59 : {"transport", SVC_TRUCK}, // !!! deprecated
60 : {"truck", SVC_TRUCK},
61 : {"trailer", SVC_TRAILER},
62 : {"motorcycle", SVC_MOTORCYCLE},
63 : {"moped", SVC_MOPED},
64 : {"bicycle", SVC_BICYCLE},
65 : {"evehicle", SVC_E_VEHICLE},
66 : {"lightrail", SVC_TRAM}, // !!! deprecated
67 : {"tram", SVC_TRAM},
68 : {"cityrail", SVC_RAIL_URBAN}, // !!! deprecated
69 : {"rail_urban", SVC_RAIL_URBAN},
70 : {"rail_slow", SVC_RAIL}, // !!! deprecated
71 : {"rail", SVC_RAIL},
72 : {"rail_electric", SVC_RAIL_ELECTRIC},
73 : {"rail_fast", SVC_RAIL_FAST},
74 : {"ship", SVC_SHIP},
75 : {"container", SVC_CONTAINER},
76 : {"cable_car", SVC_CABLE_CAR},
77 : {"subway", SVC_SUBWAY},
78 : {"aircraft", SVC_AIRCRAFT},
79 : {"wheelchair", SVC_WHEELCHAIR},
80 : {"scooter", SVC_SCOOTER},
81 : {"drone", SVC_DRONE},
82 : {"custom1", SVC_CUSTOM1},
83 : {"custom2", SVC_CUSTOM2}
84 : };
85 :
86 :
87 : StringBijection<SUMOVehicleClass> SumoVehicleClassStrings(
88 : sumoVehicleClassStringInitializer, SVC_CUSTOM2, false);
89 :
90 : // count only non-deprecated classes
91 : const int NUM_VCLASSES = SumoVehicleClassStrings.size() - 8;
92 :
93 : std::set<std::string> deprecatedVehicleClassesSeen;
94 :
95 :
96 : static StringBijection<SUMOVehicleShape>::Entry sumoVehicleShapeStringInitializer[] = {
97 : {"pedestrian", SUMOVehicleShape::PEDESTRIAN},
98 : {"bicycle", SUMOVehicleShape::BICYCLE},
99 : {"moped", SUMOVehicleShape::MOPED},
100 : {"motorcycle", SUMOVehicleShape::MOTORCYCLE},
101 : {"passenger", SUMOVehicleShape::PASSENGER},
102 : {"passenger/sedan", SUMOVehicleShape::PASSENGER_SEDAN},
103 : {"passenger/hatchback", SUMOVehicleShape::PASSENGER_HATCHBACK},
104 : {"passenger/wagon", SUMOVehicleShape::PASSENGER_WAGON},
105 : {"passenger/van", SUMOVehicleShape::PASSENGER_VAN},
106 : {"taxi", SUMOVehicleShape::TAXI},
107 : {"delivery", SUMOVehicleShape::DELIVERY},
108 : {"transport", SUMOVehicleShape::TRUCK}, // !!! deprecated
109 : {"truck", SUMOVehicleShape::TRUCK},
110 : {"transport/semitrailer", SUMOVehicleShape::TRUCK_SEMITRAILER}, // !!! deprecated
111 : {"truck/semitrailer", SUMOVehicleShape::TRUCK_SEMITRAILER},
112 : {"transport/trailer", SUMOVehicleShape::TRUCK_1TRAILER}, // !!! deprecated
113 : {"truck/trailer", SUMOVehicleShape::TRUCK_1TRAILER},
114 : {"bus/city", SUMOVehicleShape::BUS}, // !!! deprecated
115 : {"bus", SUMOVehicleShape::BUS},
116 : {"bus/overland", SUMOVehicleShape::BUS_COACH}, // !!! deprecated
117 : {"bus/coach", SUMOVehicleShape::BUS_COACH},
118 : {"bus/flexible", SUMOVehicleShape::BUS_FLEXIBLE},
119 : {"bus/trolley", SUMOVehicleShape::BUS_TROLLEY},
120 : {"rail/slow", SUMOVehicleShape::RAIL}, // !!! deprecated
121 : {"rail/fast", SUMOVehicleShape::RAIL}, // !!! deprecated
122 : {"rail", SUMOVehicleShape::RAIL},
123 : {"rail/light", SUMOVehicleShape::RAIL_CAR}, // !!! deprecated
124 : {"rail/city", SUMOVehicleShape::RAIL_CAR}, // !!! deprecated
125 : {"rail/railcar", SUMOVehicleShape::RAIL_CAR},
126 : {"rail/cargo", SUMOVehicleShape::RAIL_CARGO},
127 : {"evehicle", SUMOVehicleShape::E_VEHICLE},
128 : {"ant", SUMOVehicleShape::ANT},
129 : {"ship", SUMOVehicleShape::SHIP},
130 : {"emergency", SUMOVehicleShape::EMERGENCY},
131 : {"firebrigade", SUMOVehicleShape::FIREBRIGADE},
132 : {"police", SUMOVehicleShape::POLICE},
133 : {"rickshaw", SUMOVehicleShape::RICKSHAW },
134 : {"scooter", SUMOVehicleShape::SCOOTER},
135 : {"aircraft", SUMOVehicleShape::AIRCRAFT},
136 : {"", SUMOVehicleShape::UNKNOWN}
137 : };
138 :
139 :
140 : StringBijection<SUMOVehicleShape> SumoVehicleShapeStrings(
141 : sumoVehicleShapeStringInitializer, SUMOVehicleShape::UNKNOWN, false);
142 :
143 : // ===========================================================================
144 : // static values used for cached
145 : // ===========================================================================
146 :
147 : static std::map<SVCPermissions, std::vector<std::string> > vehicleClassNamesListCached;
148 : static std::map<std::string, SVCPermissions> parseVehicleClassesCached;
149 : static std::map<SVCPermissions, std::string> getVehicleClassNamesCached;
150 : static std::string VehicleClassNameAll = "all";
151 :
152 : // ===========================================================================
153 : // additional constants
154 : // ===========================================================================
155 :
156 : const SUMOVehicleClass SUMOVehicleClass_MAX = SVC_CUSTOM2;
157 :
158 : const SVCPermissions SVCAll = 2 * (long long int)SUMOVehicleClass_MAX - 1; // all relevant bits set to 1
159 :
160 : const SVCPermissions SVC_UNSPECIFIED = -1;
161 :
162 : const SUMOEmissionClass EMISSION_CLASS_UNSPECIFIED = -1;
163 :
164 : const std::string DEFAULT_VTYPE_ID("DEFAULT_VEHTYPE");
165 : const std::string DEFAULT_PEDTYPE_ID("DEFAULT_PEDTYPE");
166 : const std::string DEFAULT_BIKETYPE_ID("DEFAULT_BIKETYPE");
167 : const std::string DEFAULT_CONTAINERTYPE_ID("DEFAULT_CONTAINERTYPE");
168 : const std::string DEFAULT_TAXITYPE_ID("DEFAULT_TAXITYPE");
169 : const std::string DEFAULT_RAILTYPE_ID("DEFAULT_RAILTYPE");
170 :
171 : const std::set<std::string> DEFAULT_VTYPES({DEFAULT_VTYPE_ID, DEFAULT_PEDTYPE_ID, DEFAULT_BIKETYPE_ID, DEFAULT_CONTAINERTYPE_ID, DEFAULT_TAXITYPE_ID, DEFAULT_RAILTYPE_ID});
172 :
173 : const double DEFAULT_VEH_PROB(1.);
174 : const double DEFAULT_VEH_MASS(1500.);
175 : const double DEFAULT_VEH_WIDTH(1.8);
176 : const double DEFAULT_VEH_HEIGHT(1.5);
177 : const double DEFAULT_VEH_SHUT_OFF_STOP(300.);
178 :
179 : const double DEFAULT_PEDESTRIAN_SPEED(5. / 3.6);
180 :
181 : const double DEFAULT_BICYCLE_SPEED(20. / 3.6);
182 :
183 : const double DEFAULT_CONTAINER_TRANSHIP_SPEED(5. / 3.6);
184 :
185 :
186 : // ===========================================================================
187 : // method definitions
188 : // ===========================================================================
189 :
190 : // Stop Offset
191 :
192 2895748 : StopOffset::StopOffset() :
193 2895748 : myPermissions(SVCAll),
194 2895748 : myOffset(0) {
195 2895748 : }
196 :
197 :
198 2229 : StopOffset::StopOffset(const SUMOSAXAttributes& attrs, bool& ok) :
199 2229 : myPermissions(SVC_IGNORING),
200 2229 : myOffset(0) {
201 : // first check conditions
202 2229 : if (attrs.hasAttribute(SUMO_ATTR_VCLASSES) && attrs.hasAttribute(SUMO_ATTR_EXCEPTIONS)) {
203 0 : WRITE_ERROR(TL("Simultaneous specification of vClasses and exceptions is not allowed"));
204 0 : ok = false;
205 : }
206 2229 : if (!attrs.hasAttribute(SUMO_ATTR_VALUE)) {
207 2 : WRITE_ERROR(TL("StopOffset requires an offset value"));
208 2 : ok = false;
209 : }
210 : // parse elements
211 2229 : const std::string vClasses = attrs.getOpt<std::string>(SUMO_ATTR_VCLASSES, nullptr, ok, "");
212 2229 : const std::string exceptions = attrs.getOpt<std::string>(SUMO_ATTR_EXCEPTIONS, nullptr, ok, "");
213 : // parse permissions
214 2229 : if (attrs.hasAttribute(SUMO_ATTR_VCLASSES)) {
215 1212 : myPermissions = parseVehicleClasses(vClasses);
216 1017 : } else if (attrs.hasAttribute(SUMO_ATTR_EXCEPTIONS)) {
217 1001 : myPermissions = ~parseVehicleClasses(exceptions);
218 : } else {
219 : // no vClasses specified, thus apply to all
220 16 : myPermissions = parseVehicleClasses("all");
221 : }
222 : // parse offset
223 2229 : myOffset = attrs.getOpt<double>(SUMO_ATTR_VALUE, nullptr, ok, 0);
224 2229 : }
225 :
226 :
227 : bool
228 2493474880 : StopOffset::isDefined() const {
229 2493474880 : return myOffset != 0;
230 : }
231 :
232 :
233 : void
234 1793129 : StopOffset::reset() {
235 1793129 : myPermissions = SVC_IGNORING;
236 1793129 : myOffset = 0;
237 1793129 : }
238 :
239 :
240 : SVCPermissions
241 94290 : StopOffset::getPermissions() const {
242 94290 : return myPermissions;
243 : }
244 :
245 :
246 : std::string
247 0 : StopOffset::getExceptions() const {
248 0 : return getVehicleClassNames(~myPermissions);
249 : }
250 :
251 :
252 : double
253 180385 : StopOffset::getOffset() const {
254 180385 : return myOffset;
255 : }
256 :
257 :
258 : void
259 0 : StopOffset::setPermissions(const SVCPermissions permissions) {
260 0 : myPermissions = permissions;
261 0 : }
262 :
263 :
264 : void
265 0 : StopOffset::setExceptions(const std::string permissions) {
266 0 : myPermissions = ~parseVehicleClasses(permissions);
267 0 : }
268 :
269 :
270 : void
271 0 : StopOffset::setOffset(const double offset) {
272 0 : myOffset = offset;
273 0 : }
274 :
275 :
276 : bool
277 0 : StopOffset::operator==(StopOffset const& other) const {
278 0 : return ((myPermissions == other.myPermissions) &&
279 0 : (myOffset == other.myOffset));
280 : }
281 :
282 :
283 : bool
284 153416 : StopOffset::operator!=(StopOffset const& other) const {
285 153416 : return ((myPermissions != other.myPermissions) ||
286 153393 : (myOffset != other.myOffset));
287 : }
288 :
289 : // Conversion of SUMOVehicleClass
290 :
291 : const std::string&
292 980864 : getVehicleClassNames(SVCPermissions permissions, bool expand) {
293 980864 : if ((permissions & SVCAll) == SVCAll && !expand) {
294 : return VehicleClassNameAll;
295 : }
296 : // check if previously was cached
297 : if (getVehicleClassNamesCached.count(permissions) == 0) {
298 11388 : getVehicleClassNamesCached[permissions] = joinToString(getVehicleClassNamesList(permissions), ' ');
299 : }
300 463109 : return getVehicleClassNamesCached.at(permissions);
301 : }
302 :
303 :
304 : const std::vector<std::string>&
305 5887 : getVehicleClassNamesList(SVCPermissions permissions) {
306 : // first check if it's cached
307 : if (vehicleClassNamesListCached.count(permissions) == 0) {
308 5840 : const std::vector<std::string> classNames = SumoVehicleClassStrings.getStrings();
309 : std::vector<std::string> result;
310 204400 : for (std::vector<std::string>::const_iterator it = classNames.begin(); it != classNames.end(); it++) {
311 198560 : const SVCPermissions svc = (SVCPermissions)SumoVehicleClassStrings.get(*it);
312 198560 : if ((svc & permissions) == svc && svc != SVC_IGNORING) {
313 19510 : result.push_back(*it);
314 : }
315 : }
316 : // add it into vehicleClassNamesListCached
317 5840 : vehicleClassNamesListCached[permissions] = result;
318 5840 : }
319 5887 : return vehicleClassNamesListCached.at(permissions);
320 : }
321 :
322 :
323 : SUMOVehicleClass
324 577324 : getVehicleClassID(const std::string& name) {
325 : if (SumoVehicleClassStrings.hasString(name)) {
326 577309 : return SumoVehicleClassStrings.get(name);
327 : }
328 45 : throw InvalidArgument("Unknown vehicle class '" + name + "'.");
329 : }
330 :
331 :
332 : SVCPermissions
333 0 : getVehicleClassCompoundID(const std::string& name) {
334 : SVCPermissions ret = SVC_IGNORING;
335 0 : const std::vector<std::string> names = SumoVehicleClassStrings.getStrings();
336 0 : for (std::vector<std::string>::const_iterator it = names.begin(); it != names.end(); it++) {
337 0 : if (name.find(*it) != std::string::npos) {
338 0 : ret = ret | (SVCPermissions) SumoVehicleClassStrings.get(*it);
339 : }
340 : }
341 0 : return ret;
342 0 : }
343 :
344 :
345 : SVCPermissions
346 1661376 : parseVehicleClasses(const std::string& allowedS) {
347 1661376 : if (allowedS == VehicleClassNameAll) {
348 : return SVCAll;
349 : }
350 : // check if allowedS was previously cached
351 : if (parseVehicleClassesCached.count(allowedS) == 0) {
352 : SVCPermissions result = 0;
353 1200288 : StringTokenizer sta(allowedS, " ");
354 876436 : while (sta.hasNext()) {
355 476340 : const std::string s = sta.next();
356 476340 : if (!SumoVehicleClassStrings.hasString(s)) {
357 23 : if (!SUMOXMLDefinitions::isValidNetID(s)) {
358 21 : WRITE_ERRORF(TL("Invalid character in vehicle class '%' encountered."), s);
359 16 : } else if (gIgnoreUnknownVClass) {
360 27 : WRITE_WARNINGF(TL("Unknown vehicle class '%' ignored."), s);
361 : } else {
362 21 : WRITE_ERRORF(TL("Unknown vehicle class '%' encountered."), s);
363 : }
364 : } else {
365 476317 : const SUMOVehicleClass vc = getVehicleClassID(s);
366 476317 : const std::string& realName = SumoVehicleClassStrings.getString(vc);
367 476317 : if (realName != s) {
368 : deprecatedVehicleClassesSeen.insert(s);
369 : }
370 476317 : result |= vc;
371 : }
372 : }
373 : // save parsed vehicle class cached
374 400096 : parseVehicleClassesCached[allowedS] = result;
375 400096 : }
376 1649128 : return parseVehicleClassesCached.at(allowedS);
377 : }
378 :
379 :
380 : void
381 0 : clearParseVehicleClassesCache() {
382 : parseVehicleClassesCached.clear();
383 0 : }
384 :
385 : bool
386 0 : canParseVehicleClasses(const std::string& classes) {
387 0 : if (classes == VehicleClassNameAll) {
388 : return true;
389 : }
390 : // check if was previously cached
391 : if (parseVehicleClassesCached.count(classes) != 0) {
392 0 : return true;
393 : }
394 0 : StringTokenizer sta(classes, " ");
395 0 : while (sta.hasNext()) {
396 0 : if (!SumoVehicleClassStrings.hasString(sta.next())) {
397 : return false;
398 : }
399 : }
400 : return true;
401 0 : }
402 :
403 :
404 : SVCPermissions
405 7117564 : parseVehicleClasses(const std::string& allowedS, const std::string& disallowedS, const MMVersion& networkVersion) {
406 7117564 : if (allowedS.size() == 0 && disallowedS.size() == 0) {
407 : return SVCAll;
408 1309794 : } else if (allowedS.size() > 0 && disallowedS.size() > 0) {
409 1 : WRITE_WARNING(TL("SVCPermissions must be specified either via 'allow' or 'disallow'. Ignoring 'disallow'"));
410 1 : return parseVehicleClasses(allowedS);
411 1309793 : } else if (allowedS.size() > 0) {
412 770094 : return parseVehicleClasses(allowedS);
413 : } else {
414 539699 : return invertPermissions(extraDisallowed(parseVehicleClasses(disallowedS), networkVersion));
415 : }
416 : }
417 :
418 : SVCPermissions
419 539699 : extraDisallowed(SVCPermissions disallowed, const MMVersion& networkVersion) {
420 : if (networkVersion < MMVersion(1, 3)) {
421 31633 : disallowed |= SVC_RAIL_FAST;
422 : }
423 : if (networkVersion < MMVersion(1, 20)) {
424 257150 : if ((disallowed & SVC_RAIL_URBAN) != 0) {
425 : disallowed |= SVC_SUBWAY;
426 49769 : disallowed |= SVC_CABLE_CAR;
427 : }
428 : }
429 539699 : return disallowed;
430 : }
431 :
432 :
433 : SVCPermissions
434 539786 : invertPermissions(SVCPermissions permissions) {
435 539786 : return SVCAll & ~permissions;
436 : }
437 :
438 :
439 : SVCPermissions
440 15883 : parseVehicleClasses(const std::vector<std::string>& allowedS) {
441 : SVCPermissions result = 0;
442 15883 : if (std::find(allowedS.begin(), allowedS.end(), VehicleClassNameAll) != allowedS.end()) {
443 : return SVCAll;
444 : }
445 47439 : for (std::vector<std::string>::const_iterator i = allowedS.begin(); i != allowedS.end(); ++i) {
446 31564 : const SUMOVehicleClass vc = getVehicleClassID(*i);
447 31557 : const std::string& realName = SumoVehicleClassStrings.getString(vc);
448 31557 : if (realName != *i) {
449 0 : WRITE_WARNINGF(TL("The vehicle class '%' is deprecated, use '%' instead."), (*i), realName);
450 : }
451 31557 : result |= getVehicleClassID(*i);
452 : }
453 : return result;
454 : }
455 :
456 :
457 : void
458 537913 : writePermissions(OutputDevice& into, SVCPermissions permissions) {
459 537913 : if (permissions == SVCAll || permissions == SVC_UNSPECIFIED) {
460 353023 : into.writeOptionalAttr(SUMO_ATTR_ALLOW, "", true);
461 353023 : into.writeOptionalAttr(SUMO_ATTR_DISALLOW, "", true);
462 353023 : return;
463 : }
464 184890 : if (permissions == 0) {
465 927 : into.writeOptionalAttr(SUMO_ATTR_ALLOW, "", true);
466 927 : into.writeAttr(SUMO_ATTR_DISALLOW, VehicleClassNameAll);
467 927 : return;
468 : }
469 : int num_allowed = 0;
470 6254742 : for (SVCPermissions mask = 1; mask <= SUMOVehicleClass_MAX; mask = mask << 1) {
471 6070779 : if ((mask & permissions) == mask) {
472 2257085 : ++num_allowed;
473 : }
474 : }
475 183963 : if (num_allowed <= (NUM_VCLASSES - num_allowed) && num_allowed > 0) {
476 94173 : into.writeAttr(SUMO_ATTR_ALLOW, getVehicleClassNames(permissions));
477 94173 : into.writeOptionalAttr(SUMO_ATTR_DISALLOW, "", true);
478 : } else {
479 89790 : into.writeOptionalAttr(SUMO_ATTR_ALLOW, "", true);
480 89790 : into.writeAttr(SUMO_ATTR_DISALLOW, getVehicleClassNames(~permissions));
481 : }
482 : }
483 :
484 :
485 : void
486 277875 : writePreferences(OutputDevice& into, SVCPermissions preferred) {
487 277875 : into.writeOptionalAttr(SUMO_ATTR_PREFER, getVehicleClassNames(preferred), preferred == SVCAll || preferred == 0);
488 277875 : }
489 :
490 :
491 : SUMOVehicleShape
492 16 : getVehicleShapeID(const std::string& name) {
493 : if (SumoVehicleShapeStrings.hasString(name)) {
494 16 : return SumoVehicleShapeStrings.get(name);
495 : } else {
496 0 : throw InvalidArgument("Unknown vehicle shape '" + name + "'.");
497 : }
498 : }
499 :
500 :
501 : bool
502 0 : canParseVehicleShape(const std::string& shape) {
503 0 : return SumoVehicleShapeStrings.hasString(shape);
504 : }
505 :
506 :
507 : std::string
508 171 : getVehicleShapeName(SUMOVehicleShape id) {
509 171 : return SumoVehicleShapeStrings.getString(id);
510 : }
511 :
512 :
513 6269318815 : bool isRailway(SVCPermissions permissions) {
514 6269318815 : return (permissions & SVC_RAIL_CLASSES) != 0 && (permissions & ~(SVC_RAIL_CLASSES | SVC_TAXI)) == 0;
515 : }
516 :
517 9808756 : bool isRailwayOrShared(SVCPermissions permissions) {
518 : // basically check that it isn't SVC_ALL
519 9808756 : return (permissions & SVC_RAIL_CLASSES) != 0 && (permissions & SVC_NON_ROAD_RAIL) == 0;
520 : }
521 :
522 2439 : bool isTram(SVCPermissions permissions) {
523 2439 : return (permissions & SVC_RAIL_CLASSES) == SVC_TRAM && (permissions & SVC_PASSENGER) == 0;
524 : }
525 :
526 110069 : bool isBikepath(SVCPermissions permissions) {
527 110069 : return (permissions & SVC_BICYCLE) == SVC_BICYCLE && (permissions & SVC_ROAD_MOTOR_CLASSES) == 0;
528 : }
529 :
530 :
531 : bool
532 54788345 : isWaterway(SVCPermissions permissions) {
533 54788345 : return permissions == SVC_SHIP;
534 : }
535 :
536 : bool
537 6113326 : isAirway(SVCPermissions permissions) {
538 6113326 : return permissions == SVC_AIRCRAFT || permissions == SVC_DRONE;
539 : }
540 :
541 : bool
542 162631 : isForbidden(SVCPermissions permissions) {
543 162631 : return (permissions & SVCAll) == 0;
544 : }
545 :
546 :
547 : bool
548 25629 : isSidewalk(SVCPermissions permissions) {
549 25629 : return (permissions & SVCAll) == SVC_PEDESTRIAN;
550 : }
551 :
552 :
553 : bool
554 1853 : isForVulnerableModes(SVCPermissions permissions) {
555 1853 : return ((permissions & SVC_VULNERABLE) != 0 && (permissions & ~SVC_VULNERABLE) == 0);
556 : }
557 :
558 :
559 : bool
560 18607 : noVehicles(SVCPermissions permissions) {
561 18607 : return isForbidden(permissions) || isSidewalk(permissions);
562 : }
563 :
564 :
565 : double
566 379098 : getDefaultVehicleLength(const SUMOVehicleClass vc) {
567 379098 : switch (vc) {
568 : case SVC_PEDESTRIAN:
569 : return 0.215;
570 : case SVC_WHEELCHAIR:
571 : return 1.2;
572 48434 : case SVC_BICYCLE:
573 48434 : return 1.6;
574 : case SVC_SCOOTER:
575 : return 1.2;
576 118 : case SVC_MOPED:
577 118 : return 2.1;
578 139 : case SVC_MOTORCYCLE:
579 139 : return 2.2;
580 543 : case SVC_TRUCK:
581 543 : return 7.1;
582 70 : case SVC_TRAILER:
583 70 : return 16.5;
584 1413 : case SVC_BUS:
585 1413 : return 12.;
586 41 : case SVC_COACH:
587 41 : return 14.;
588 423 : case SVC_TRAM:
589 423 : return 22.;
590 1005 : case SVC_RAIL_URBAN:
591 : case SVC_SUBWAY:
592 1005 : return 36.5 * 3;
593 49914 : case SVC_RAIL:
594 49914 : return 67.5 * 2;
595 48 : case SVC_RAIL_ELECTRIC:
596 : case SVC_RAIL_FAST:
597 48 : return 25. * 8;
598 359 : case SVC_DELIVERY:
599 : case SVC_EMERGENCY:
600 359 : return 6.5;
601 318 : case SVC_SHIP:
602 318 : return 17;
603 43132 : case SVC_CONTAINER:
604 43132 : return 6.096;
605 24 : case SVC_DRONE:
606 24 : return 0.5;
607 24 : case SVC_AIRCRAFT:
608 24 : return 72.7;
609 132945 : default:
610 132945 : return 5; /*4.3*/
611 : }
612 : }
613 :
614 :
615 :
616 : /****************************************************************************/
|
