Eclipse SUMO - Simulation of Urban MObility
NBFrame.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-2022 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// Sets and checks options for netbuild
21/****************************************************************************/
22#include <config.h>
23
24#include <string>
25#include <fstream>
26#include "NBFrame.h"
27#include "NBNodeCont.h"
28#include "NBEdgeCont.h"
30#include "NBDistrictCont.h"
31#include "NBRequest.h"
32#include "NBTypeCont.h"
41
42
43// ===========================================================================
44// method definitions
45// ===========================================================================
46void
47NBFrame::fillOptions(bool forNetgen) {
49 // register building defaults
50 oc.doRegister("default.lanenumber", 'L', new Option_Integer(1));
51 oc.addSynonyme("default.lanenumber", "lanenumber", true);
52 oc.addDescription("default.lanenumber", "Building Defaults", "The default number of lanes in an edge");
53
54 oc.doRegister("default.lanewidth", new Option_Float(NBEdge::UNSPECIFIED_WIDTH));
55 oc.addSynonyme("default.lanewidth", "lanewidth", true);
56 oc.addDescription("default.lanewidth", "Building Defaults", "The default width of lanes");
57
58 oc.doRegister("default.spreadtype", new Option_String("right"));
59 oc.addDescription("default.spreadtype", "Building Defaults", "The default method for computing lane shapes from edge shapes");
60
61 oc.doRegister("default.speed", 'S', new Option_Float((double) 13.89));
62 oc.addSynonyme("default.speed", "speed", true);
63 oc.addDescription("default.speed", "Building Defaults", "The default speed on an edge (in m/s)");
64
65 oc.doRegister("default.friction", new Option_Float(NBEdge::UNSPECIFIED_FRICTION));
66 oc.addSynonyme("default.friction", "friction", true);
67 oc.addDescription("default.friction", "Building Defaults", "The default friction on an edge");
68
69 oc.doRegister("default.priority", 'P', new Option_Integer(-1));
70 oc.addSynonyme("default.priority", "priority", true);
71 oc.addDescription("default.priority", "Building Defaults", "The default priority of an edge");
72
73 oc.doRegister("default.type", new Option_String());
74 oc.addDescription("default.type", "Building Defaults", "The default edge type");
75
76 oc.doRegister("default.sidewalk-width", new Option_Float((double) 2.0));
77 oc.addDescription("default.sidewalk-width", "Building Defaults", "The default width of added sidewalks");
78
79 oc.doRegister("default.bikelane-width", new Option_Float((double) 1.0));
80 oc.addDescription("default.bikelane-width", "Building Defaults", "The default width of added bike lanes");
81
82 oc.doRegister("default.crossing-width", new Option_Float((double) 4.0));
83 oc.addDescription("default.crossing-width", "Building Defaults", "The default width of a pedestrian crossing");
84
85 oc.doRegister("default.allow", new Option_String());
86 oc.addDescription("default.allow", "Building Defaults", "The default for allowed vehicle classes");
87
88 oc.doRegister("default.disallow", new Option_String());
89 oc.addDescription("default.disallow", "Building Defaults", "The default for disallowed vehicle classes");
90
91 oc.doRegister("default.junctions.keep-clear", new Option_Bool(true));
92 oc.addDescription("default.junctions.keep-clear", "Building Defaults", "Whether junctions should be kept clear by default");
93
94 oc.doRegister("default.junctions.radius", new Option_Float(4));
95 oc.addDescription("default.junctions.radius", "Building Defaults", "The default turning radius of intersections");
96
97 oc.doRegister("default.connection-length", new Option_Float((double) NBEdge::UNSPECIFIED_LOADED_LENGTH));
98 oc.addDescription("default.connection-length", "Building Defaults", "The default length when overriding connection lengths");
99
100 oc.doRegister("default.right-of-way", new Option_String("default"));
101 oc.addDescription("default.right-of-way", "Building Defaults", "The default algorithm for computing right of way rules ('default', 'edgePriority')");
102
103 oc.doRegister("junctions.right-before-left.speed-threshold", new Option_Float(49 / 3.6));
104 oc.addDescription("junctions.right-before-left.speed-threshold", "Junctions", "Allow building right-before-left junctions when the incoming edge speeds are below FLOAT (m/s)");
105
106 oc.doRegister("junctions.left-before-right", new Option_Bool(false));
107 oc.addDescription("junctions.left-before-right", "Junctions", "Build left-before-right junctions instead of right-before-left junctions");
108
109 // register the data processing options
110 oc.doRegister("no-internal-links", new Option_Bool(false)); // !!! not described
111 oc.addDescription("no-internal-links", "Junctions", "Omits internal links");
112
113 oc.doRegister("numerical-ids", new Option_Bool(false));
114 oc.addDescription("numerical-ids", "Processing", "Remaps alphanumerical IDs of nodes and edges to ensure that all IDs are integers");
115
116 oc.doRegister("numerical-ids.node-start", new Option_Integer(std::numeric_limits<int>::max()));
117 oc.addDescription("numerical-ids.node-start", "Processing", "Remaps IDs of nodes to integers starting at INT");
118
119 oc.doRegister("numerical-ids.edge-start", new Option_Integer(std::numeric_limits<int>::max()));
120 oc.addDescription("numerical-ids.edge-start", "Processing", "Remaps IDs of edges to integers starting at INT");
121
123 oc.doRegister("reserved-ids", new Option_FileName());
124 oc.addDescription("reserved-ids", "Processing", "Ensures that generated ids do not included any of the typed IDs from FILE (sumo-gui selection file format)");
125
126 if (!forNetgen) {
127 oc.doRegister("dismiss-vclasses", new Option_Bool(false));
128 oc.addDescription("dismiss-vclasses", "Processing", "Removes vehicle class restrictions from imported edges");
129 }
130
131 oc.doRegister("no-turnarounds", new Option_Bool(false));
132 oc.addDescription("no-turnarounds", "Junctions", "Disables building turnarounds");
133
134 oc.doRegister("no-turnarounds.tls", new Option_Bool(false));
135 oc.addSynonyme("no-turnarounds.tls", "no-tls-turnarounds", true);
136 oc.addDescription("no-turnarounds.tls", "Junctions", "Disables building turnarounds at tls-controlled junctions");
137
138 oc.doRegister("no-turnarounds.geometry", new Option_Bool(true));
139 oc.addDescription("no-turnarounds.geometry", "Junctions", "Disables building turnarounds at geometry-like junctions");
140
141 oc.doRegister("no-turnarounds.except-deadend", new Option_Bool(false));
142 oc.addDescription("no-turnarounds.except-deadend", "Junctions", "Disables building turnarounds except at dead end junctions");
143
144 oc.doRegister("no-turnarounds.except-turnlane", new Option_Bool(false));
145 oc.addDescription("no-turnarounds.except-turnlane", "Junctions", "Disables building turnarounds except at at junctions with a dedicated turning lane");
146
147 oc.doRegister("no-turnarounds.fringe", new Option_Bool(false));
148 oc.addDescription("no-turnarounds.fringe", "Junctions", "Disables building turnarounds at fringe junctions");
149
150 oc.doRegister("no-left-connections", new Option_Bool(false));
151 oc.addDescription("no-left-connections", "Junctions", "Disables building connections to left");
152
153 oc.doRegister("geometry.split", new Option_Bool(false)); // !!!not described
154 oc.addSynonyme("geometry.split", "split-geometry", true);
155 oc.addDescription("geometry.split", "Processing", "Splits edges across geometry nodes");
156
157 oc.doRegister("geometry.remove", 'R', new Option_Bool(false));
158 oc.addSynonyme("geometry.remove", "remove-geometry", true);
159 oc.addDescription("geometry.remove", "Processing", "Replace nodes which only define edge geometry by geometry points (joins edges)");
160
161 oc.doRegister("geometry.remove.keep-edges.explicit", new Option_StringVector());
162 oc.addDescription("geometry.remove.keep-edges.explicit", "Processing", "Ensure that the given list of edges is not modified");
163
164 oc.doRegister("geometry.remove.keep-edges.input-file", new Option_FileName());
165 oc.addDescription("geometry.remove.keep-edges.input-file", "Processing",
166 "Ensure that the edges in FILE are not modified (Each id on a single line. Selection files from sumo-gui are also supported)");
167
168 if (!forNetgen) {
169 oc.doRegister("geometry.remove.keep-ptstops", new Option_Bool(false));
170 oc.addDescription("geometry.remove.keep-ptstops", "Processing", "Ensure that edges with public transport stops are not modified");
171 }
172
173 oc.doRegister("geometry.remove.min-length", new Option_Float(0));
174 oc.addDescription("geometry.remove.min-length", "Processing",
175 "Allow merging edges with differing attributes when their length is below min-length");
176
177 oc.doRegister("geometry.remove.width-tolerance", new Option_Float(0));
178 oc.addDescription("geometry.remove.width-tolerance", "Processing",
179 "Allow merging edges with differing lane widths if the difference is below FLOAT");
180
181 oc.doRegister("geometry.max-segment-length", new Option_Float(0));
182 oc.addDescription("geometry.max-segment-length", "Processing", "splits geometry to restrict segment length");
183
184 if (!forNetgen) {
185 oc.doRegister("geometry.min-dist", new Option_Float(-1));
186 oc.addDescription("geometry.min-dist", "Processing", "reduces too similar geometry points");
187
188 oc.doRegister("geometry.max-angle", new Option_Float(99));
189 oc.addDescription("geometry.max-angle", "Processing", "Warn about edge geometries with an angle above DEGREES in successive segments");
190
191 oc.doRegister("geometry.min-radius", new Option_Float(9));
192 oc.addDescription("geometry.min-radius", "Processing", "Warn about edge geometries with a turning radius less than METERS at the start or end");
193
194 oc.doRegister("geometry.min-radius.fix", new Option_Bool(false));
195 oc.addDescription("geometry.min-radius.fix", "Processing", "Straighten edge geometries to avoid turning radii less than geometry.min-radius");
196
197 oc.doRegister("geometry.min-radius.fix.railways", new Option_Bool(true));
198 oc.addDescription("geometry.min-radius.fix.railways", "Processing", "Straighten edge geometries to avoid turning radii less than geometry.min-radius (only railways)");
199
200 oc.doRegister("geometry.junction-mismatch-threshold", new Option_Float(20));
201 oc.addDescription("geometry.junction-mismatch-threshold", "Processing", "Warn if the junction shape is to far away from the original node position");
202
203 oc.doRegister("geometry.check-overlap", new Option_Float(0));
204 oc.addDescription("geometry.check-overlap", "Processing", "Warn if edges overlap by more than the given threshold value");
205
206 oc.doRegister("geometry.check-overlap.vertical-threshold", new Option_Float(4));
207 oc.addDescription("geometry.check-overlap.vertical-threshold", "Processing", "Ignore overlapping edges if they are separated vertically by the given threshold.");
208
209 oc.doRegister("geometry.avoid-overlap", new Option_Bool(true));
210 oc.addDescription("geometry.avoid-overlap", "Processing", "Modify edge geometries to avoid overlap at junctions");
211
212 oc.doRegister("join-lanes", new Option_Bool(false));
213 oc.addDescription("join-lanes", "Processing", "join adjacent lanes that have the same permissions and which do not admit lane-changing (sidewalks and disallowed lanes)");
214
215 oc.doRegister("ptline.match-dist", new Option_Float(100));
216 oc.addDescription("ptline.match-dist", "Processing", "Matches stops outside the road network to the referencing pt line when below the given distance");
217 // railway processing options
218
219 oc.doRegister("railway.topology.repair", new Option_Bool(false));
220 oc.addDescription("railway.topology.repair", "Railway", "Repair topology of the railway network");
221
222 oc.doRegister("railway.topology.repair.minimal", new Option_Bool(false));
223 oc.addDescription("railway.topology.repair.minimal", "Railway", "Repair topology of the railway network just enough to let loaded public transport lines to work");
224
225 oc.doRegister("railway.topology.repair.connect-straight", new Option_Bool(false));
226 oc.addDescription("railway.topology.repair.connect-straight", "Railway", "Allow bidirectional rail use wherever rails with opposite directions meet at a straight angle");
227
228 oc.doRegister("railway.topology.repair.stop-turn", new Option_Bool(false));
229 oc.addDescription("railway.topology.repair.stop-turn", "Railway", "Add turn-around connections at all loaded stops.");
230
231 oc.doRegister("railway.topology.all-bidi", new Option_Bool(false));
232 oc.addDescription("railway.topology.all-bidi", "Railway", "Make all rails usable in both direction");
233
234 oc.doRegister("railway.topology.all-bidi.input-file", new Option_FileName());
235 oc.addDescription("railway.topology.all-bidi.input-file", "Railway", "Make all rails edge ids from FILE usable in both direction");
236
237 oc.doRegister("railway.topology.direction-priority", new Option_Bool(false));
238 oc.addDescription("railway.topology.direction-priority", "Railway", "Set edge priority values based on estimated main direction");
239
240 oc.doRegister("railway.topology.extend-priority", new Option_Bool(false));
241 oc.addDescription("railway.topology.extend-priority", "Railway", "Extend loaded edge priority values based on estimated main direction");
242
243 oc.doRegister("railway.access-distance", new Option_Float(150.f));
244 oc.addDescription("railway.access-distance", "Railway", "The search radius for finding suitable road accesses for rail stops");
245 oc.addSynonyme("railway.access-distance", "osm.stop-output.footway-access-distance", true);
246
247 oc.doRegister("railway.max-accesses", new Option_Integer(5));
248 oc.addDescription("railway.max-accesses", "Railway", "The maximum road accesses registered per rail stops");
249 oc.addSynonyme("railway.max-accesses", "osm.stop-output.footway-max-accesses", true);
250
251 oc.doRegister("railway.access-factor", new Option_Float(1.5));
252 oc.addDescription("railway.access-factor", "Railway", "The walking length of the access is computed as air-line distance multiplied by FLOAT");
253 oc.addSynonyme("railway.access-factor", "osm.stop-output.footway-access-factor", true);
254
255 oc.doRegister("ptstop-output.no-bidi", new Option_Bool(false));
256 oc.addDescription("ptstop-output.no-bidi", "Processing", "Skips automatic generation of stops on the bidi-edge of a loaded stop");
257 }
258
259 oc.doRegister("geometry.max-grade", new Option_Float(10));
260 oc.addDescription("geometry.max-grade", "Processing", "Warn about edge geometries with a grade in % above FLOAT.");
261
262 oc.doRegister("geometry.max-grade.fix", new Option_Bool(true));
263 oc.addDescription("geometry.max-grade.fix", "Processing", "Smooth edge edge geometries with a grade in above the warning threshold.");
264
265 oc.doRegister("offset.disable-normalization", new Option_Bool(false));
266 oc.addSynonyme("offset.disable-normalization", "disable-normalize-node-positions", true);
267 oc.addDescription("offset.disable-normalization", "Processing", "Turn off normalizing node positions");
268
269 oc.doRegister("offset.x", new Option_Float(0));
270 oc.addSynonyme("offset.x", "x-offset-to-apply", true);
271 oc.addDescription("offset.x", "Processing", "Adds FLOAT to net x-positions");
272
273 oc.doRegister("offset.y", new Option_Float(0));
274 oc.addSynonyme("offset.y", "y-offset-to-apply", true);
275 oc.addDescription("offset.y", "Processing", "Adds FLOAT to net y-positions");
276
277 oc.doRegister("offset.z", new Option_Float(0));
278 oc.addDescription("offset.z", "Processing", "Adds FLOAT to net z-positions");
279
280 oc.doRegister("flip-y-axis", new Option_Bool(false));
281 oc.addSynonyme("flip-y-axis", "flip-y");
282 oc.addDescription("flip-y-axis", "Processing", "Flips the y-coordinate along zero");
283
284 oc.doRegister("roundabouts.guess", new Option_Bool(true));
285 oc.addSynonyme("roundabouts.guess", "guess-roundabouts", true);
286 oc.addDescription("roundabouts.guess", "Processing", "Enable roundabout-guessing");
287
288 oc.doRegister("roundabouts.visibility-distance", new Option_Float(9));
289 oc.addDescription("roundabouts.visibility-distance", "Processing", "Default visibility when approaching a roundabout");
290
291 oc.doRegister("opposites.guess", new Option_Bool(false));
292 oc.addDescription("opposites.guess", "Processing", "Enable guessing of opposite direction lanes usable for overtaking");
293
294 oc.doRegister("opposites.guess.fix-lengths", new Option_Bool(true));
295 oc.addDescription("opposites.guess.fix-lengths", "Processing", "Ensure that opposite edges have the same length");
296
297 oc.doRegister("fringe.guess", new Option_Bool(false));
298 oc.addDescription("fringe.guess", "Processing", "Enable guessing of network fringe nodes");
299
300 oc.doRegister("fringe.guess.speed-threshold", new Option_Float(50 / 3.6));
301 oc.addDescription("fringe.guess.speed-threshold", "Processing", "Guess disconnected edges above the given speed as outer fringe");
302
303 oc.doRegister("lefthand", new Option_Bool(false));
304 oc.addDescription("lefthand", "Processing", "Assumes left-hand traffic on the network");
305
306 oc.doRegister("edges.join", new Option_Bool(false));
307 oc.addDescription("edges.join", "Processing",
308 "Merges edges which connect the same nodes and are close to each other (recommended for VISSIM import)");
309
310 oc.doRegister("junctions.join", new Option_Bool(false));
311 oc.addDescription("junctions.join", "Junctions",
312 "Joins junctions that are close to each other (recommended for OSM import)");
313
314 oc.doRegister("junctions.join-dist", new Option_Float(10));
315 oc.addDescription("junctions.join-dist", "Junctions",
316 "Determines the maximal distance for joining junctions (defaults to 10)");
317
318 if (!forNetgen) {
319 oc.doRegister("junctions.join-exclude", new Option_StringVector());
320 oc.addDescription("junctions.join-exclude", "Junctions", "Interprets STR[] as list of junctions to exclude from joining");
321 }
322
323 oc.doRegister("junctions.join-same", new Option_Bool(false));
324 oc.addDescription("junctions.join-same", "Junctions",
325 "Joins junctions that have the same coordinates even if not connected");
326
327 oc.doRegister("max-join-ids", new Option_Integer(4));
328 oc.addDescription("max-join-ids", "Junctions", "Abbreviate junction or TLS id if it joins more than INT junctions");
329
330 if (!forNetgen) {
331 oc.doRegister("speed.offset", new Option_Float(0));
332 oc.addDescription("speed.offset", "Processing", "Modifies all edge speeds by adding FLOAT");
333
334 oc.doRegister("speed.factor", new Option_Float(1));
335 oc.addDescription("speed.factor", "Processing", "Modifies all edge speeds by multiplying by FLOAT");
336
337 oc.doRegister("speed.minimum", new Option_Float(0));
338 oc.addDescription("speed.minimum", "Processing", "Modifies all edge speeds to at least FLOAT");
339
340 oc.doRegister("edges.join-tram-dist", new Option_Float(-1));
341 oc.addDescription("edges.join-tram-dist", "Processing",
342 "Joins tram edges into road lanes with similar geometry (within FLOAT distance)");
343 }
344
345 oc.doRegister("junctions.corner-detail", new Option_Integer(5));
346 oc.addDescription("junctions.corner-detail", "Junctions", "Generate INT intermediate points to smooth out intersection corners");
347
348 oc.doRegister("junctions.internal-link-detail", new Option_Integer(5));
349 oc.addDescription("junctions.internal-link-detail", "Junctions", "Generate INT intermediate points to smooth out lanes within the intersection");
350
351 oc.doRegister("junctions.scurve-stretch", new Option_Float(0));
352 oc.addDescription("junctions.scurve-stretch", "Junctions", "Generate longer intersections to allow for smooth s-curves when the number of lanes changes");
353
354 oc.doRegister("junctions.join-turns", new Option_Bool(false));
355 oc.addDescription("junctions.join-turns", "Junctions",
356 "Builds common edges for turning connections with common from- and to-edge. This causes discrepancies between geometrical length and assigned length due to averaging but enables lane-changing while turning");
357
358 oc.doRegister("junctions.limit-turn-speed", new Option_Float(5.5));
359 oc.addDescription("junctions.limit-turn-speed", "Junctions",
360 "Limits speed on junctions to an average lateral acceleration of at most FLOAT m/s^2)");
361
362 oc.doRegister("junctions.limit-turn-speed.min-angle", new Option_Float(15));
363 oc.addDescription("junctions.limit-turn-speed.min-angle", "Junctions",
364 "Do not limit turn speed for angular changes below FLOAT (degrees). The value is subtracted from the geometric angle before computing the turning radius.");
365
366 oc.doRegister("junctions.limit-turn-speed.min-angle.railway", new Option_Float(35));
367 oc.addDescription("junctions.limit-turn-speed.min-angle.railway", "Junctions",
368 "Do not limit turn speed for angular changes below FLOAT (degrees) on railway edges. The value is subtracted from the geometric angle before computing the turning radius.");
369
370 oc.doRegister("junctions.limit-turn-speed.warn.straight", new Option_Float(5));
371 oc.addDescription("junctions.limit-turn-speed.warn.straight", "Junctions",
372 "Warn about turn speed limits that reduce the speed of straight connections by more than FLOAT");
373
374 oc.doRegister("junctions.limit-turn-speed.warn.turn", new Option_Float(22));
375 oc.addDescription("junctions.limit-turn-speed.warn.turn", "Junctions",
376 "Warn about turn speed limits that reduce the speed of turning connections (no u-turns) by more than FLOAT");
377
378
379 oc.doRegister("junctions.small-radius", new Option_Float(1.5));
380 oc.addDescription("junctions.small-radius", "Junctions",
381 "Default radius for junctions that do not require wide vehicle turns");
382
383 oc.doRegister("junctions.higher-speed", new Option_Bool(false));
384 oc.addDescription("junctions.higher-speed", "Junctions",
385 "Use maximum value of incoming and outgoing edge speed on junction instead of average");
386
387 oc.doRegister("internal-junctions.vehicle-width", new Option_Float(1.8));
388 oc.addDescription("internal-junctions.vehicle-width", "Junctions",
389 "Assumed vehicle width for computing internal junction positions");
390
391 oc.doRegister("rectangular-lane-cut", new Option_Bool(false));
392 oc.addDescription("rectangular-lane-cut", "Junctions", "Forces rectangular cuts between lanes and intersections");
393
394 oc.doRegister("check-lane-foes.roundabout", new Option_Bool(true));
395 oc.addDescription("check-lane-foes.roundabout", "Junctions",
396 "Allow driving onto a multi-lane road if there are foes on other lanes (at roundabouts)");
397
398 oc.doRegister("check-lane-foes.all", new Option_Bool(false));
399 oc.addDescription("check-lane-foes.all", "Junctions",
400 "Allow driving onto a multi-lane road if there are foes on other lanes (everywhere)");
401
402 oc.doRegister("sidewalks.guess", new Option_Bool(false));
403 oc.addDescription("sidewalks.guess", "Pedestrian",
404 "Guess pedestrian sidewalks based on edge speed");
405
406 oc.doRegister("sidewalks.guess.max-speed", new Option_Float((double) 13.89));
407 oc.addDescription("sidewalks.guess.max-speed", "Pedestrian",
408 "Add sidewalks for edges with a speed equal or below the given limit");
409
410 oc.doRegister("sidewalks.guess.min-speed", new Option_Float((double) 5.8));
411 oc.addDescription("sidewalks.guess.min-speed", "Pedestrian",
412 "Add sidewalks for edges with a speed above the given limit");
413
414 oc.doRegister("sidewalks.guess.from-permissions", new Option_Bool(false));
415 oc.addDescription("sidewalks.guess.from-permissions", "Pedestrian",
416 "Add sidewalks for edges that allow pedestrians on any of their lanes regardless of speed");
417
418 oc.doRegister("sidewalks.guess.exclude", new Option_StringVector());
419 oc.addDescription("sidewalks.guess.exclude", "Pedestrian",
420 "Do not guess sidewalks for the given list of edges");
421
422 oc.doRegister("bikelanes.guess", new Option_Bool(false));
423 oc.addDescription("bikelanes.guess", "Bicycle",
424 "Guess bike lanes based on edge speed");
425
426 oc.doRegister("bikelanes.guess.max-speed", new Option_Float((double) 22.22));
427 oc.addDescription("bikelanes.guess.max-speed", "Bicycle",
428 "Add bike lanes for edges with a speed equal or below the given limit");
429
430 oc.doRegister("bikelanes.guess.min-speed", new Option_Float((double) 5.8));
431 oc.addDescription("bikelanes.guess.min-speed", "Bicycle",
432 "Add bike lanes for edges with a speed above the given limit");
433
434 oc.doRegister("bikelanes.guess.from-permissions", new Option_Bool(false));
435 oc.addDescription("bikelanes.guess.from-permissions", "Bicycle",
436 "Add bike lanes for edges that allow bicycles on any of their lanes regardless of speed");
437
438 oc.doRegister("bikelanes.guess.exclude", new Option_StringVector());
439 oc.addDescription("bikelanes.guess.exclude", "Bicycle",
440 "Do not guess bikelanes for the given list of edges");
441
442 oc.doRegister("crossings.guess", new Option_Bool(false));
443 oc.addDescription("crossings.guess", "Pedestrian",
444 "Guess pedestrian crossings based on the presence of sidewalks");
445
446 oc.doRegister("crossings.guess.speed-threshold", new Option_Float(13.89));
447 oc.addDescription("crossings.guess.speed-threshold", "Pedestrian",
448 "At uncontrolled nodes, do not build crossings across edges with a speed above the threshold");
449
450 oc.doRegister("walkingareas", new Option_Bool(false));
451 oc.addDescription("walkingareas", "Pedestrian", "Always build walking areas even if there are no crossings");
452
453 oc.doRegister("walkingareas.join-dist", new Option_Float(15));
454 oc.addDescription("walkingareas.join-dist", "Pedestrian", "Do not create a walkingarea between sidewalks that are connected by a pedestrian junction within FLOAT");
455
456 // tls setting options
457 // explicit tls
458 oc.doRegister("tls.set", new Option_StringVector());
459 oc.addSynonyme("tls.set", "explicite-tls", true);
460 oc.addDescription("tls.set", "TLS Building", "Interprets STR[] as list of junctions to be controlled by TLS");
461
462 oc.doRegister("tls.unset", new Option_StringVector());
463 oc.addSynonyme("tls.unset", "explicite-no-tls", true);
464 oc.addDescription("tls.unset", "TLS Building", "Interprets STR[] as list of junctions to be not controlled by TLS");
465
466 // tls-guessing
467 oc.doRegister("tls.guess", new Option_Bool(false));
468 oc.addSynonyme("tls.guess", "guess-tls", true);
469 oc.addDescription("tls.guess", "TLS Building", "Turns on TLS guessing");
470
471 oc.doRegister("tls.guess.threshold", new Option_Float(250 / 3.6));
472 oc.addDescription("tls.guess.threshold", "TLS Building", "Sets minimum value for the sum of all incoming lane speeds when guessing TLS");
473
474 if (!forNetgen) {
475 oc.doRegister("tls.taz-nodes", new Option_Bool(false));
476 oc.addSynonyme("tls.taz-nodes", "tls-guess.district-nodes", true);
477 oc.addDescription("tls.taz-nodes", "TLS Building", "Sets district nodes as tls-controlled"); // !!! describe
478 }
479
480 oc.doRegister("tls.guess.joining", new Option_Bool(false));
481 oc.addSynonyme("tls.guess.joining", "tls-guess.joining", true);
482 oc.addDescription("tls.guess.joining", "TLS Building", "Includes node clusters into guess"); // !!! describe
483
484 oc.doRegister("tls.join", new Option_Bool(false));
485 oc.addSynonyme("tls.join", "try-join-tls", true);
486 oc.addDescription("tls.join", "TLS Building", "Tries to cluster tls-controlled nodes"); // !!! describe
487
488 oc.doRegister("tls.join-dist", new Option_Float(20));
489 oc.addDescription("tls.join-dist", "TLS Building",
490 "Determines the maximal distance for joining traffic lights (defaults to 20)");
491
492 oc.doRegister("tls.uncontrolled-within", new Option_Bool(false));
493 oc.addDescription("tls.uncontrolled-within", "TLS Building",
494 "Do not control edges that lie fully within a joined traffic light. This may cause collisions but allows old traffic light plans to be used");
495
496 oc.doRegister("tls.ignore-internal-junction-jam", new Option_Bool(false));
497 oc.addDescription("tls.ignore-internal-junction-jam", "TLS Building",
498 "Do not build mutually conflicting response matrix, potentially ignoring vehicles that are stuck at an internal junction when their phase has ended");
499
500 if (!forNetgen) {
501 oc.doRegister("tls.guess-signals", new Option_Bool(false));
502 oc.addDescription("tls.guess-signals", "TLS Building", "Interprets tls nodes surrounding an intersection as signal positions for a larger TLS. This is typical pattern for OSM-derived networks");
503
504 oc.doRegister("tls.guess-signals.dist", new Option_Float(25));
505 oc.addDescription("tls.guess-signals.dist", "TLS Building", "Distance for interpreting nodes as signal locations");
506 }
507
508
509 // computational
510 oc.doRegister("tls.cycle.time", new Option_Integer(90));
511 oc.addDescription("tls.cycle.time", "TLS Building", "Use INT as cycle duration");
512
513 oc.doRegister("tls.green.time", new Option_Integer(31));
514 oc.addSynonyme("tls.green.time", "traffic-light-green", true);
515 oc.addDescription("tls.green.time", "TLS Building", "Use INT as green phase duration");
516
517 oc.doRegister("tls.yellow.min-decel", 'D', new Option_Float(3.0));
518 oc.addSynonyme("tls.yellow.min-decel", "min-decel", true);
519 oc.addDescription("tls.yellow.min-decel", "TLS Building", "Defines smallest vehicle deceleration");
520
521 oc.doRegister("tls.yellow.patch-small", new Option_Bool(false));
522 oc.addSynonyme("tls.yellow.patch-small", "patch-small-tyellow", true);
523 oc.addDescription("tls.yellow.patch-small", "TLS Building", "Given yellow times are patched even if being too short");
524
525 oc.doRegister("tls.yellow.time", new Option_Integer(-1));
526 oc.addSynonyme("tls.yellow.time", "traffic-light-yellow", true);
527 oc.addDescription("tls.yellow.time", "TLS Building", "Set INT as fixed time for yellow phase durations");
528
529 oc.doRegister("tls.red.time", new Option_Integer(5));
530 oc.addDescription("tls.red.time", "TLS Building", "Set INT as fixed time for red phase duration at traffic lights that do not have a conflicting flow");
531
532 oc.doRegister("tls.allred.time", new Option_Integer(0));
533 oc.addDescription("tls.allred.time", "TLS Building", "Set INT as fixed time for intermediate red phase after every switch");
534
535 oc.doRegister("tls.minor-left.max-speed", new Option_Float(19.44)); // 70km/h
536 oc.addDescription("tls.minor-left.max-speed", "TLS Building", "Use FLOAT as threshold for allowing left-turning vehicles to move in the same phase as oncoming straight-going vehicles");
537
538 oc.doRegister("tls.left-green.time", new Option_Integer(6));
539 oc.addDescription("tls.left-green.time", "TLS Building", "Use INT as green phase duration for left turns (s). Setting this value to 0 disables additional left-turning phases");
540
541 oc.doRegister("tls.nema.vehExt", new Option_Integer(2));
542 oc.addDescription("tls.nema.vehExt", "TLS Building", "Set INT as fixed time for intermediate vehext phase after every switch");
543
544 oc.doRegister("tls.nema.yellow", new Option_Integer(3));
545 oc.addDescription("tls.nema.yellow", "TLS Building", "Set INT as fixed time for intermediate NEMA yelow phase after every switch");
546
547 oc.doRegister("tls.nema.red", new Option_Integer(2));
548 oc.addDescription("tls.nema.red", "TLS Building", "Set INT as fixed time for intermediate NEMA red phase after every switch");
549
550 oc.doRegister("tls.crossing-min.time", new Option_Integer(4));
551 oc.addDescription("tls.crossing-min.time", "TLS Building", "Use INT as minimum green duration for pedestrian crossings (s).");
552
553 oc.doRegister("tls.crossing-clearance.time", new Option_Integer(5));
554 oc.addDescription("tls.crossing-clearance.time", "TLS Building", "Use INT as clearance time for pedestrian crossings (s).");
555
556 oc.doRegister("tls.scramble.time", new Option_Integer(5));
557 oc.addDescription("tls.scramble.time", "TLS Building", "Use INT as green phase duration for pedestrian scramble phase (s).");
558
559 // tls-shifts
560 oc.doRegister("tls.half-offset", new Option_StringVector());
561 oc.addSynonyme("tls.half-offset", "tl-logics.half-offset", true);
562 oc.addDescription("tls.half-offset", "TLS Building", "TLSs in STR[] will be shifted by half-phase");
563
564 oc.doRegister("tls.quarter-offset", new Option_StringVector());
565 oc.addSynonyme("tls.quarter-offset", "tl-logics.quarter-offset", true);
566 oc.addDescription("tls.quarter-offset", "TLS Building", "TLSs in STR[] will be shifted by quarter-phase");
567
568 // tls type
569 oc.doRegister("tls.default-type", new Option_String("static"));
570 oc.addDescription("tls.default-type", "TLS Building", "TLSs with unspecified type will use STR as their algorithm");
571
572 oc.doRegister("tls.layout", new Option_String("opposites"));
573 oc.addDescription("tls.layout", "TLS Building", "Set phase layout four grouping opposite directions or grouping all movements for one incoming edge ['opposites', 'incoming']");
574
575 oc.doRegister("tls.no-mixed", new Option_Bool(false));
576 oc.addDescription("tls.no-mixed", "TLS Building", "Avoid phases with green and red signals for different connections from the same lane");
577
578 oc.doRegister("tls.min-dur", new Option_Integer(5));
579 oc.addDescription("tls.min-dur", "TLS Building", "Default minimum phase duration for traffic lights with variable phase length");
580
581 oc.doRegister("tls.max-dur", new Option_Integer(50));
582 oc.addDescription("tls.max-dur", "TLS Building", "Default maximum phase duration for traffic lights with variable phase length");
583
584 oc.doRegister("tls.group-signals", new Option_Bool(false));
585 oc.addDescription("tls.group-signals", "TLS Building", "Assign the same tls link index to connections that share the same states");
586
587 oc.doRegister("tls.ungroup-signals", new Option_Bool(false));
588 oc.addDescription("tls.ungroup-signals", "TLS Building", "Assign a distinct tls link index to every connection");
589
590 // edge pruning
591 oc.doRegister("keep-edges.min-speed", new Option_Float(-1));
592 oc.addSynonyme("keep-edges.min-speed", "edges-min-speed", true);
593 oc.addDescription("keep-edges.min-speed", "Edge Removal", "Only keep edges with speed in meters/second > FLOAT");
594
595 oc.doRegister("remove-edges.explicit", new Option_StringVector());
596 oc.addSynonyme("remove-edges.explicit", "remove-edges");
597 oc.addDescription("remove-edges.explicit", "Edge Removal", "Remove edges in STR[]");
598
599 oc.doRegister("keep-edges.explicit", new Option_StringVector());
600 oc.addSynonyme("keep-edges.explicit", "keep-edges");
601 oc.addDescription("keep-edges.explicit", "Edge Removal", "Only keep edges in STR[] or those which are kept due to other keep-edges or remove-edges options");
602
603 oc.doRegister("keep-edges.input-file", new Option_FileName());
604 oc.addDescription("keep-edges.input-file", "Edge Removal", "Only keep edges in FILE (Each id on a single line. Selection files from sumo-gui are also supported) or those which are kept due to other keep-edges or remove-edges options");
605
606 oc.doRegister("remove-edges.input-file", new Option_FileName());
607 oc.addDescription("remove-edges.input-file", "Edge Removal", "Remove edges in FILE. (Each id on a single line. Selection files from sumo-gui are also supported)");
608
609 if (!forNetgen) {
610 oc.doRegister("keep-edges.postload", new Option_Bool(false));
611 oc.addDescription("keep-edges.postload", "Edge Removal", "Remove edges after joining");
612 }
613
614 oc.doRegister("keep-edges.in-boundary", new Option_StringVector());
615 oc.addDescription("keep-edges.in-boundary", "Edge Removal", "Only keep edges which are located within the given boundary (given either as CARTESIAN corner coordinates <xmin,ymin,xmax,ymax> or as polygon <x0,y0,x1,y1,...>)");
616
617 oc.doRegister("keep-edges.in-geo-boundary", new Option_StringVector());
618 oc.addDescription("keep-edges.in-geo-boundary", "Edge Removal", "Only keep edges which are located within the given boundary (given either as GEODETIC corner coordinates <lon-min,lat-min,lon-max,lat-max> or as polygon <lon0,lat0,lon1,lat1,...>)");
619
620 if (!forNetgen) {
621 oc.doRegister("keep-edges.by-vclass", new Option_StringVector());
622 oc.addDescription("keep-edges.by-vclass", "Edge Removal", "Only keep edges which allow one of the vclasses in STR[]");
623
624 oc.doRegister("remove-edges.by-vclass", new Option_StringVector());
625 oc.addDescription("remove-edges.by-vclass", "Edge Removal", "Remove edges which allow only vclasses from STR[]");
626
627 oc.doRegister("keep-edges.by-type", new Option_StringVector());
628 oc.addDescription("keep-edges.by-type", "Edge Removal", "Only keep edges where type is in STR[]");
629
630 oc.doRegister("keep-edges.components", new Option_Integer(0));
631 oc.addDescription("keep-edges.components", "Edge Removal", "Only keep the INT largest weakly connected components");
632
633 oc.doRegister("remove-edges.by-type", new Option_StringVector());
634 oc.addDescription("remove-edges.by-type", "Edge Removal", "Remove edges where type is in STR[]");
635
636 oc.doRegister("remove-edges.isolated", new Option_Bool(false));
637 oc.addSynonyme("remove-edges.isolated", "remove-isolated", true);
638 oc.addDescription("remove-edges.isolated", "Edge Removal", "Removes isolated edges");
639 }
640
641
642 // unregulated nodes options
643 oc.doRegister("keep-nodes-unregulated", new Option_Bool(false));
644 oc.addSynonyme("keep-nodes-unregulated", "keep-unregulated");
645 oc.addDescription("keep-nodes-unregulated", "Unregulated Nodes", "All nodes will be unregulated");
646
647 oc.doRegister("keep-nodes-unregulated.explicit", new Option_StringVector());
648 oc.addSynonyme("keep-nodes-unregulated.explicit", "keep-unregulated.explicit");
649 oc.addSynonyme("keep-nodes-unregulated.explicit", "keep-unregulated.nodes", true);
650 oc.addDescription("keep-nodes-unregulated.explicit", "Unregulated Nodes", "Do not regulate nodes in STR[]");
651
652 oc.doRegister("keep-nodes-unregulated.district-nodes", new Option_Bool(false));
653 oc.addSynonyme("keep-nodes-unregulated.district-nodes", "keep-unregulated.district-nodes");
654 oc.addDescription("keep-nodes-unregulated.district-nodes", "Unregulated Nodes", "Do not regulate district nodes");
655
656 // ramp guessing options
657 if (!forNetgen) {
658 oc.doRegister("ramps.guess", new Option_Bool(false));
659 oc.addSynonyme("ramps.guess", "guess-ramps", true);
660 oc.addDescription("ramps.guess", "Ramp Guessing", "Enable ramp-guessing");
661
662 oc.doRegister("ramps.guess-acceleration-lanes", new Option_Bool(true));
663 oc.addDescription("ramps.guess-acceleration-lanes", "Ramp Guessing", "Guess on-ramps and mark acceleration lanes if they exist but do not add new lanes");
664
665 oc.doRegister("ramps.max-ramp-speed", new Option_Float(-1));
666 oc.addSynonyme("ramps.max-ramp-speed", "ramp-guess.max-ramp-speed", true);
667 oc.addDescription("ramps.max-ramp-speed", "Ramp Guessing", "Treat edges with speed > FLOAT as no ramps");
668
669 oc.doRegister("ramps.min-highway-speed", new Option_Float((double)(79 / 3.6)));
670 oc.addSynonyme("ramps.min-highway-speed", "ramp-guess.min-highway-speed", true);
671 oc.addDescription("ramps.min-highway-speed", "Ramp Guessing", "Treat edges with speed < FLOAT as no highways");
672
673 oc.doRegister("ramps.ramp-length", new Option_Float(100));
674 oc.addSynonyme("ramps.ramp-length", "ramp-guess.ramp-length", true);
675 oc.addDescription("ramps.ramp-length", "Ramp Guessing", "Use FLOAT as ramp-length");
676
677 //The Weaving Length Limit for Short Free Onramps, Chiu Liu, Zhongren WangPhD even suggest 70m
678 oc.doRegister("ramps.min-weave-length", new Option_Float(50));
679 oc.addDescription("ramps.min-weave-length", "Ramp Guessing", "Use FLOAT as minimum ramp-length");
680
681 oc.doRegister("ramps.set", new Option_StringVector());
682 oc.addSynonyme("ramps.set", "ramp-guess.explicite", true);
683 oc.addDescription("ramps.set", "Ramp Guessing", "Tries to handle the given edges as ramps");
684
685 oc.doRegister("ramps.unset", new Option_StringVector());
686 oc.addDescription("ramps.unset", "Ramp Guessing", "Do not consider the given edges as ramps");
687
688 oc.doRegister("ramps.no-split", new Option_Bool(false));
689 oc.addSynonyme("ramps.no-split", "ramp-guess.no-split", true);
690 oc.addDescription("ramps.no-split", "Ramp Guessing", "Avoids edge splitting");
691 }
692}
693
694
695bool
698 bool ok = true;
699 //
700 if (!SUMOXMLDefinitions::TrafficLightTypes.hasString(oc.getString("tls.default-type"))) {
701 WRITE_ERROR("unsupported value '" + oc.getString("tls.default-type") + "' for option '--tls.default-type'");
702 ok = false;
703 }
704 if (oc.isSet("keep-edges.in-boundary") && oc.isSet("keep-edges.in-geo-boundary")) {
705 WRITE_ERROR(TL("only one of the options 'keep-edges.in-boundary' or 'keep-edges.in-geo-boundary' may be given"));
706 ok = false;
707 }
708 if (oc.getBool("no-internal-links") && oc.getBool("crossings.guess")) {
709 WRITE_ERROR(TL("only one of the options 'no-internal-links' or 'crossings.guess' may be given"));
710 ok = false;
711 }
712 if (oc.getBool("no-internal-links") && oc.getBool("walkingareas")) {
713 WRITE_ERROR(TL("only one of the options 'no-internal-links' or 'walkareas' may be given"));
714 ok = false;
715 }
716 if (!oc.isDefault("tls.green.time") && !oc.isDefault("tls.cycle.time")) {
717 WRITE_ERROR(TL("only one of the options 'tls.green.time' or 'tls.cycle.time' may be given"));
718 ok = false;
719 }
720 if (oc.getInt("default.lanenumber") < 1) {
721 WRITE_ERROR(TL("default.lanenumber must be at least 1"));
722 ok = false;
723 }
724 if (!oc.isDefault("default.lanewidth") && oc.getFloat("default.lanewidth") < POSITION_EPS) {
725 WRITE_ERROR("default.lanewidth must be at least " + toString(POSITION_EPS));
726 ok = false;
727 }
728 if (!oc.isDefault("default.disallow") && !oc.isDefault("default.allow")) {
729 WRITE_ERROR(TL("only one of the options 'default.disallow' or 'default.allow' may be given"));
730 ok = false;
731 }
732 if (oc.getInt("junctions.internal-link-detail") < 2) {
733 WRITE_ERROR(TL("junctions.internal-link-detail must >= 2"));
734 ok = false;
735 }
736 if (oc.getFloat("junctions.scurve-stretch") > 0) {
737 if (oc.getBool("no-internal-links")) {
738 WRITE_WARNING(TL("Option 'junctions.scurve-stretch' requires internal lanes to work. Option '--no-internal-links' will be disabled."));
739 }
740 // make sure the option is set so heuristics cannot ignore it
741 oc.set("no-internal-links", "false");
742 }
743 if (oc.getFloat("junctions.small-radius") > oc.getFloat("default.junctions.radius") && oc.getFloat("default.junctions.radius") >= 0) {
744 if (!oc.isDefault("junctions.small-radius")) {
745 WRITE_WARNING(TL("option 'default.junctions.radius' is smaller than option 'junctions.small-radius'"));
746 } else {
747 oc.setDefault("junctions.small-radius", oc.getValueString("default.junctions.radius"));
748 }
749 }
750 if (oc.getString("tls.layout") != "opposites"
751 && oc.getString("tls.layout") != "incoming"
752 && oc.getString("tls.layout") != "alternateOneWay") {
753 WRITE_ERROR(TL("tls.layout must be 'opposites', 'incoming' or 'alternateOneWay'"));
754 ok = false;
755 }
756 if (!oc.isDefault("default.right-of-way") &&
757 !SUMOXMLDefinitions::RightOfWayValues.hasString(oc.getString("default.right-of-way"))) {
758 WRITE_ERROR("default.right-of-way must be one of '" + toString(SUMOXMLDefinitions::RightOfWayValues.getStrings()) + "'");
759 ok = false;
760 }
761 if (oc.getFloat("roundabouts.visibility-distance") < 0 && oc.getFloat("roundabouts.visibility-distance") != NBEdge::UNSPECIFIED_VISIBILITY_DISTANCE) {
762 WRITE_ERROR(TL("roundabouts.visibility-distance must be positive or -1"));
763 ok = false;
764 }
765 if (oc.isDefault("railway.topology.repair") && oc.getBool("railway.topology.repair.connect-straight")) {
766 oc.setDefault("railway.topology.repair", "true");
767 }
768 if (oc.isDefault("railway.topology.repair") && oc.getBool("railway.topology.repair.minimal")) {
769 oc.setDefault("railway.topology.repair", "true");
770 }
771 if (oc.isDefault("railway.topology.all-bidi") && !oc.isDefault("railway.topology.all-bidi.input-file")) {
772 oc.setDefault("railway.topology.all-bidi", "true");
773 }
774 if (oc.isDefault("railway.topology.repair.stop-turn") && !oc.isDefault("railway.topology.repair")) {
775 oc.setDefault("railway.topology.repair.stop-turn", "true");
776 }
777 if (!SUMOXMLDefinitions::LaneSpreadFunctions.hasString(oc.getString("default.spreadtype"))) {
778 WRITE_ERROR("Unknown value for default.spreadtype '" + oc.getString("default.spreadtype") + "'.");
779 ok = false;
780 }
781 return ok;
782}
783
784
785/****************************************************************************/
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:274
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:265
#define TL(string)
Definition: MsgHandler.h:282
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
static const double UNSPECIFIED_FRICTION
unspecified lane friction
Definition: NBEdge.h:366
static const double UNSPECIFIED_LOADED_LENGTH
no length override given
Definition: NBEdge.h:375
static const double UNSPECIFIED_VISIBILITY_DISTANCE
unspecified foe visibility for connections
Definition: NBEdge.h:372
static const double UNSPECIFIED_WIDTH
unspecified lane width
Definition: NBEdge.h:357
static bool checkOptions()
Checks set options from the OptionsCont-singleton for being valid.
Definition: NBFrame.cpp:696
static void fillOptions(bool forNetgen)
Inserts options used by the network converter.
Definition: NBFrame.cpp:47
An integer-option.
Definition: Option.h:289
A storage for options typed value containers)
Definition: OptionsCont.h:89
void addDescription(const std::string &name, const std::string &subtopic, const std::string &description)
Adds a description for an option.
void doRegister(const std::string &name, Option *v)
Adds an option under the given name.
Definition: OptionsCont.cpp:76
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
void addSynonyme(const std::string &name1, const std::string &name2, bool isDeprecated=false)
Adds a synonyme for an options name (any order)
Definition: OptionsCont.cpp:97
bool isDefault(const std::string &name) const
Returns the information whether the named option has still the default value.
bool setDefault(const std::string &name, const std::string &value)
Sets the given value for the named option as new default value.
bool set(const std::string &name, const std::string &value, const bool append=false)
Sets the given value for the named option.
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
std::string getValueString(const std::string &name) const
Returns the string-value of the named option (all options)
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:59
static StringBijection< LaneSpreadFunction > LaneSpreadFunctions
lane spread functions
static StringBijection< TrafficLightType > TrafficLightTypes
traffic light types
static StringBijection< RightOfWay > RightOfWayValues
righ of way algorithms
bool hasString(const std::string &str) const