51 oc.
addSynonyme(
"default.lanenumber",
"lanenumber",
true);
52 oc.
addDescription(
"default.lanenumber",
"Building Defaults",
TL(
"The default number of lanes in an edge"));
55 oc.
addSynonyme(
"default.lanewidth",
"lanewidth",
true);
56 oc.
addDescription(
"default.lanewidth",
"Building Defaults",
TL(
"The default width of lanes"));
59 oc.
addDescription(
"default.spreadtype",
"Building Defaults",
TL(
"The default method for computing lane shapes from edge shapes"));
63 oc.
addDescription(
"default.speed",
"Building Defaults",
TL(
"The default speed on an edge (in m/s)"));
66 oc.
addSynonyme(
"default.friction",
"friction",
true);
67 oc.
addDescription(
"default.friction",
"Building Defaults",
TL(
"The default friction on an edge"));
70 oc.
addSynonyme(
"default.priority",
"priority",
true);
71 oc.
addDescription(
"default.priority",
"Building Defaults",
TL(
"The default priority of an edge"));
74 oc.
addDescription(
"default.type",
"Building Defaults",
TL(
"The default edge type"));
77 oc.
addDescription(
"default.sidewalk-width",
"Building Defaults",
TL(
"The default width of added sidewalks"));
80 oc.
addDescription(
"default.bikelane-width",
"Building Defaults",
TL(
"The default width of added bike lanes"));
83 oc.
addDescription(
"default.crossing-width",
"Building Defaults",
TL(
"The default width of a pedestrian crossing"));
86 oc.
addDescription(
"default.crossing-speed",
"Building Defaults",
TL(
"The default speed 'limit' on a pedestrian crossing (in m/s)"));
89 oc.
addDescription(
"default.walkingarea-speed",
"Building Defaults",
TL(
"The default speed 'limit' on a pedestrian walkingarea (in m/s)"));
92 oc.
addDescription(
"default.allow",
"Building Defaults",
TL(
"The default for allowed vehicle classes"));
95 oc.
addDescription(
"default.disallow",
"Building Defaults",
TL(
"The default for disallowed vehicle classes"));
98 oc.
addDescription(
"default.junctions.keep-clear",
"Building Defaults",
TL(
"Whether junctions should be kept clear by default"));
101 oc.
addDescription(
"default.junctions.radius",
"Building Defaults",
TL(
"The default turning radius of intersections"));
104 oc.
addDescription(
"default.connection-length",
"Building Defaults",
TL(
"The default length when overriding connection lengths"));
107 oc.
addDescription(
"default.connection.cont-pos",
"Building Defaults",
TL(
"Whether/where connections should have an internal junction"));
110 oc.
addDescription(
"default.right-of-way",
"Building Defaults",
TL(
"The default algorithm for computing right of way rules ('default', 'edgePriority')"));
113 oc.
addDescription(
"junctions.right-before-left.speed-threshold",
"Junctions",
TL(
"Allow building right-before-left junctions when the incoming edge speeds are below FLOAT (m/s)"));
116 oc.
addDescription(
"junctions.left-before-right",
"Junctions",
TL(
"Build left-before-right junctions instead of right-before-left junctions"));
120 oc.
addDescription(
"no-internal-links",
"Junctions",
TL(
"Omits internal links"));
123 oc.
addDescription(
"numerical-ids",
"Processing",
TL(
"Remaps alphanumerical IDs of nodes and edges to ensure that all IDs are integers"));
126 oc.
addDescription(
"numerical-ids.node-start",
"Processing",
TL(
"Remaps IDs of nodes to integers starting at INT"));
129 oc.
addDescription(
"numerical-ids.edge-start",
"Processing",
TL(
"Remaps IDs of edges to integers starting at INT"));
133 oc.
addDescription(
"reserved-ids",
"Processing",
TL(
"Ensures that generated ids do not included any of the typed IDs from FILE (sumo-gui selection file format)"));
137 oc.
addDescription(
"dismiss-vclasses",
"Processing",
TL(
"Removes vehicle class restrictions from imported edges"));
141 oc.
addDescription(
"no-turnarounds",
"Junctions",
TL(
"Disables building turnarounds"));
144 oc.
addSynonyme(
"no-turnarounds.tls",
"no-tls-turnarounds",
true);
145 oc.
addDescription(
"no-turnarounds.tls",
"Junctions",
TL(
"Disables building turnarounds at tls-controlled junctions"));
148 oc.
addDescription(
"no-turnarounds.geometry",
"Junctions",
TL(
"Disables building turnarounds at geometry-like junctions"));
151 oc.
addDescription(
"no-turnarounds.except-deadend",
"Junctions",
TL(
"Disables building turnarounds except at dead end junctions"));
154 oc.
addDescription(
"no-turnarounds.except-turnlane",
"Junctions",
TL(
"Disables building turnarounds except at at junctions with a dedicated turning lane"));
157 oc.
addDescription(
"no-turnarounds.fringe",
"Junctions",
TL(
"Disables building turnarounds at fringe junctions"));
160 oc.
addDescription(
"no-left-connections",
"Junctions",
TL(
"Disables building connections to left"));
163 oc.
addSynonyme(
"geometry.split",
"split-geometry",
true);
164 oc.
addDescription(
"geometry.split",
"Processing",
TL(
"Splits edges across geometry nodes"));
167 oc.
addSynonyme(
"geometry.remove",
"remove-geometry",
true);
168 oc.
addDescription(
"geometry.remove",
"Processing",
TL(
"Replace nodes which only define edge geometry by geometry points (joins edges)"));
171 oc.
addDescription(
"geometry.remove.keep-edges.explicit",
"Processing",
TL(
"Ensure that the given list of edges is not modified"));
174 oc.
addDescription(
"geometry.remove.keep-edges.input-file",
"Processing",
175 "Ensure that the edges in FILE are not modified (Each id on a single line. Selection files from sumo-gui are also supported)");
179 oc.
addDescription(
"geometry.remove.keep-ptstops",
"Processing",
TL(
"Ensure that edges with public transport stops are not modified"));
184 "Allow merging edges with differing attributes when their length is below min-length");
187 oc.
addDescription(
"geometry.remove.width-tolerance",
"Processing",
188 "Allow merging edges with differing lane widths if the difference is below FLOAT");
191 oc.
addDescription(
"geometry.remove.max-junction-size",
"Processing",
192 "Prevent removal of junctions with a size above FLOAT as defined by custom edge endpoints");
195 oc.
addDescription(
"geometry.max-segment-length",
"Processing",
TL(
"splits geometry to restrict segment length"));
199 oc.
addDescription(
"geometry.min-dist",
"Processing",
TL(
"reduces too similar geometry points"));
202 oc.
addDescription(
"geometry.max-angle",
"Processing",
TL(
"Warn about edge geometries with an angle above DEGREES in successive segments"));
205 oc.
addDescription(
"geometry.max-angle.fix",
"Processing",
TL(
"Straighten edge geometries with an angle above max-angle successive segments"));
208 oc.
addDescription(
"geometry.min-radius",
"Processing",
TL(
"Warn about edge geometries with a turning radius less than METERS at the start or end"));
211 oc.
addDescription(
"geometry.min-radius.fix",
"Processing",
TL(
"Straighten edge geometries to avoid turning radii less than geometry.min-radius"));
214 oc.
addDescription(
"geometry.min-radius.fix.railways",
"Processing",
TL(
"Straighten edge geometries to avoid turning radii less than geometry.min-radius (only railways)"));
217 oc.
addDescription(
"geometry.junction-mismatch-threshold",
"Processing",
TL(
"Warn if the junction shape is to far away from the original node position"));
220 oc.
addDescription(
"geometry.check-overlap",
"Processing",
TL(
"Warn if edges overlap by more than the given threshold value"));
223 oc.
addDescription(
"geometry.check-overlap.vertical-threshold",
"Processing",
TL(
"Ignore overlapping edges if they are separated vertically by the given threshold."));
226 oc.
addDescription(
"geometry.avoid-overlap",
"Processing",
TL(
"Modify edge geometries to avoid overlap at junctions"));
229 oc.
addDescription(
"join-lanes",
"Processing",
TL(
"join adjacent lanes that have the same permissions and which do not admit lane-changing (sidewalks and disallowed lanes)"));
232 oc.
addDescription(
"ptline.match-dist",
"Processing",
TL(
"Matches stops outside the road network to the referencing pt line when below the given distance"));
236 oc.
addDescription(
"railway.topology.repair",
"Railway",
TL(
"Repair topology of the railway network"));
239 oc.
addDescription(
"railway.topology.repair.minimal",
"Railway",
TL(
"Repair topology of the railway network just enough to let loaded public transport lines to work"));
242 oc.
addDescription(
"railway.topology.repair.connect-straight",
"Railway",
TL(
"Allow bidirectional rail use wherever rails with opposite directions meet at a straight angle"));
245 oc.
addDescription(
"railway.topology.repair.stop-turn",
"Railway",
TL(
"Add turn-around connections at all loaded stops."));
248 oc.
addDescription(
"railway.topology.repair.bidi-penalty",
"Railway",
TL(
"Penalty factor for adding new bidi edges to connect public transport stops"));
251 oc.
addDescription(
"railway.topology.all-bidi",
"Railway",
TL(
"Make all rails usable in both direction"));
254 oc.
addDescription(
"railway.topology.all-bidi.input-file",
"Railway",
TL(
"Make all rails edge ids from FILE usable in both direction"));
257 oc.
addDescription(
"railway.topology.direction-priority",
"Railway",
TL(
"Set edge priority values based on estimated main direction"));
260 oc.
addDescription(
"railway.topology.extend-priority",
"Railway",
TL(
"Extend loaded edge priority values based on estimated main direction"));
263 oc.
addDescription(
"railway.geometry.straighten",
"Railway",
TL(
"Move junctions to straighten a sequence of rail edges"));
266 oc.
addDescription(
"railway.signal.guess.by-stops",
"Railway",
TL(
"Guess signals that guard public transport stops"));
269 oc.
addDescription(
"railway.access-distance",
"Railway",
TL(
"The search radius for finding suitable road accesses for rail stops"));
270 oc.
addSynonyme(
"railway.access-distance",
"osm.stop-output.footway-access-distance",
true);
273 oc.
addDescription(
"railway.max-accesses",
"Railway",
TL(
"The maximum road accesses registered per rail stops"));
274 oc.
addSynonyme(
"railway.max-accesses",
"osm.stop-output.footway-max-accesses",
true);
277 oc.
addDescription(
"railway.access-factor",
"Railway",
TL(
"The walking length of the access is computed as air-line distance multiplied by FLOAT"));
278 oc.
addSynonyme(
"railway.access-factor",
"osm.stop-output.footway-access-factor",
true);
281 oc.
addDescription(
"ptstop-output.no-bidi",
"Processing",
TL(
"Skips automatic generation of stops on the bidi-edge of a loaded stop"));
285 oc.
addDescription(
"geometry.max-grade",
"Processing",
TL(
"Warn about edge geometries with a grade in % above FLOAT."));
288 oc.
addDescription(
"geometry.max-grade.fix",
"Processing",
TL(
"Smooth edge geometries with a grade above the warning threshold."));
291 oc.
addSynonyme(
"offset.disable-normalization",
"disable-normalize-node-positions",
true);
292 oc.
addDescription(
"offset.disable-normalization",
"Processing",
TL(
"Turn off normalizing node positions"));
295 oc.
addSynonyme(
"offset.x",
"x-offset-to-apply",
true);
296 oc.
addDescription(
"offset.x",
"Processing",
TL(
"Adds FLOAT to net x-positions"));
299 oc.
addSynonyme(
"offset.y",
"y-offset-to-apply",
true);
300 oc.
addDescription(
"offset.y",
"Processing",
TL(
"Adds FLOAT to net y-positions"));
303 oc.
addDescription(
"offset.z",
"Processing",
TL(
"Adds FLOAT to net z-positions"));
307 oc.
addDescription(
"flip-y-axis",
"Processing",
TL(
"Flips the y-coordinate along zero"));
310 oc.
addSynonyme(
"roundabouts.guess",
"guess-roundabouts",
true);
311 oc.
addDescription(
"roundabouts.guess",
"Processing",
TL(
"Enable roundabout-guessing"));
315 oc.
addDescription(
"roundabouts.guess.max-length",
"Processing",
TL(
"Structures with a circumference above FLOAT threshold are not classified as roundabout"));
318 oc.
addDescription(
"roundabouts.visibility-distance",
"Processing",
TL(
"Default visibility when approaching a roundabout"));
321 oc.
addDescription(
"opposites.guess",
"Processing",
TL(
"Enable guessing of opposite direction lanes usable for overtaking"));
324 oc.
addDescription(
"opposites.guess.fix-lengths",
"Processing",
TL(
"Ensure that opposite edges have the same length"));
327 oc.
addDescription(
"fringe.guess",
"Processing",
TL(
"Enable guessing of network fringe nodes"));
330 oc.
addDescription(
"fringe.guess.speed-threshold",
"Processing",
TL(
"Guess disconnected edges above the given speed as outer fringe"));
333 oc.
addDescription(
"lefthand",
"Processing",
TL(
"Assumes left-hand traffic on the network"));
337 "Merges edges which connect the same nodes and are close to each other (recommended for VISSIM import)");
341 "Joins junctions that are close to each other (recommended for OSM import)");
345 "Determines the maximal distance for joining junctions (defaults to 10)");
349 oc.
addDescription(
"junctions.join-exclude",
"Junctions",
TL(
"Interprets STR[] as list of junctions to exclude from joining"));
354 "Joins junctions that have the same coordinates even if not connected");
357 oc.
addDescription(
"max-join-ids",
"Junctions",
"Abbreviate junction or TLS id if it joins more than INT junctions");
361 oc.
addDescription(
"speed.offset",
"Processing",
TL(
"Modifies all edge speeds by adding FLOAT"));
364 oc.
addDescription(
"speed.factor",
"Processing",
TL(
"Modifies all edge speeds by multiplying by FLOAT"));
367 oc.
addDescription(
"speed.minimum",
"Processing",
TL(
"Modifies all edge speeds to at least FLOAT"));
371 "Joins tram edges into road lanes with similar geometry (within FLOAT distance)");
375 oc.
addDescription(
"junctions.corner-detail",
"Junctions",
TL(
"Generate INT intermediate points to smooth out intersection corners"));
378 oc.
addDescription(
"junctions.internal-link-detail",
"Junctions",
TL(
"Generate INT intermediate points to smooth out lanes within the intersection"));
381 oc.
addDescription(
"junctions.scurve-stretch",
"Junctions",
TL(
"Generate longer intersections to allow for smooth s-curves when the number of lanes changes"));
385 "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");
389 "Limits speed on junctions to an average lateral acceleration of at most FLOAT (m/s^2)");
392 oc.
addDescription(
"junctions.limit-turn-speed.min-angle",
"Junctions",
393 "Do not limit turn speed for angular changes below FLOAT (degrees). The value is subtracted from the geometric angle before computing the turning radius.");
396 oc.
addDescription(
"junctions.limit-turn-speed.min-angle.railway",
"Junctions",
397 "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.");
400 oc.
addDescription(
"junctions.limit-turn-speed.warn.straight",
"Junctions",
401 "Warn about turn speed limits that reduce the speed of straight connections by more than FLOAT");
404 oc.
addDescription(
"junctions.limit-turn-speed.warn.turn",
"Junctions",
405 "Warn about turn speed limits that reduce the speed of turning connections (no u-turns) by more than FLOAT");
409 "Default radius for junctions that do not require wide vehicle turns");
413 "Use maximum value of incoming and outgoing edge speed on junction instead of average");
417 "Build junctions with minimal shapes (ignoring edge overlap)");
421 "Build junction shapes based on edge endpoints (ignoring edge overlap)");
424 oc.
addDescription(
"internal-junctions.vehicle-width",
"Junctions",
425 "Assumed vehicle width for computing internal junction positions");
428 oc.
addDescription(
"rectangular-lane-cut",
"Junctions",
TL(
"Forces rectangular cuts between lanes and intersections"));
432 "Allow driving onto a multi-lane road if there are foes on other lanes (at roundabouts)");
436 "Allow driving onto a multi-lane road if there are foes on other lanes (everywhere)");
440 "Guess pedestrian sidewalks based on edge speed");
444 "Add sidewalks for edges with a speed equal or below the given limit");
448 "Add sidewalks for edges with a speed above the given limit");
451 oc.
addDescription(
"sidewalks.guess.from-permissions",
"Pedestrian",
452 "Add sidewalks for edges that allow pedestrians on any of their lanes regardless of speed");
456 "Do not guess sidewalks for the given list of edges");
460 "Guess bike lanes based on edge speed");
464 "Add bike lanes for edges with a speed equal or below the given limit");
468 "Add bike lanes for edges with a speed above the given limit");
472 "Add bike lanes for edges that allow bicycles on any of their lanes regardless of speed");
476 "Do not guess bikelanes for the given list of edges");
480 "Guess pedestrian crossings based on the presence of sidewalks");
483 oc.
addDescription(
"crossings.guess.speed-threshold",
"Pedestrian",
484 "At uncontrolled nodes, do not build crossings across edges with a speed above the threshold");
487 oc.
addDescription(
"crossings.guess.roundabout-priority",
"Pedestrian",
488 "Give priority to guessed crossings at roundabouts");
491 oc.
addDescription(
"walkingareas",
"Pedestrian",
TL(
"Always build walking areas even if there are no crossings"));
494 oc.
addDescription(
"walkingareas.join-dist",
"Pedestrian",
TL(
"Do not create a walkingarea between sidewalks that are connected by a pedestrian junction within FLOAT"));
500 oc.
addDescription(
"tls.set",
"TLS Building",
"Interprets STR[] as list of junctions to be controlled by TLS");
503 oc.
addSynonyme(
"tls.unset",
"explicite-no-tls",
true);
504 oc.
addDescription(
"tls.unset",
"TLS Building",
"Interprets STR[] as list of junctions to be not controlled by TLS");
509 oc.
addDescription(
"tls.guess",
"TLS Building",
"Turns on TLS guessing");
512 oc.
addDescription(
"tls.guess.threshold",
"TLS Building",
"Sets minimum value for the sum of all incoming lane speeds when guessing TLS");
516 oc.
addSynonyme(
"tls.taz-nodes",
"tls-guess.district-nodes",
true);
517 oc.
addDescription(
"tls.taz-nodes",
"TLS Building",
"Sets district nodes as tls-controlled");
521 oc.
addSynonyme(
"tls.guess.joining",
"tls-guess.joining",
true);
522 oc.
addDescription(
"tls.guess.joining",
"TLS Building",
"Includes node clusters into guess");
526 oc.
addDescription(
"tls.join",
"TLS Building",
"Tries to cluster tls-controlled nodes");
530 "Determines the maximal distance for joining traffic lights (defaults to 20)");
533 oc.
addDescription(
"tls.join-exclude",
"TLS Building",
TL(
"Interprets STR[] as list of tls ids to exclude from joining"));
537 "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");
540 oc.
addDescription(
"tls.ignore-internal-junction-jam",
"TLS Building",
541 "Do not build mutually conflicting response matrix, potentially ignoring vehicles that are stuck at an internal junction when their phase has ended");
545 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");
548 oc.
addDescription(
"tls.guess-signals.dist",
"TLS Building",
"Distance for interpreting nodes as signal locations");
551 oc.
addDescription(
"tls.guess-signals.slack",
"TLS Building",
"Number of uncontrolled entry edges to accept and still consider the central node as a traffic light");
557 oc.
addDescription(
"tls.cycle.time",
"TLS Building",
"Use INT as cycle duration");
560 oc.
addSynonyme(
"tls.green.time",
"traffic-light-green",
true);
561 oc.
addDescription(
"tls.green.time",
"TLS Building",
"Use INT as green phase duration");
564 oc.
addSynonyme(
"tls.yellow.min-decel",
"min-decel",
true);
565 oc.
addDescription(
"tls.yellow.min-decel",
"TLS Building",
"Defines smallest vehicle deceleration");
568 oc.
addSynonyme(
"tls.yellow.patch-small",
"patch-small-tyellow",
true);
569 oc.
addDescription(
"tls.yellow.patch-small",
"TLS Building",
"Given yellow times are patched even if being too short");
572 oc.
addSynonyme(
"tls.yellow.time",
"traffic-light-yellow",
true);
573 oc.
addDescription(
"tls.yellow.time",
"TLS Building",
"Set INT as fixed time for yellow phase durations");
576 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");
579 oc.
addDescription(
"tls.allred.time",
"TLS Building",
"Set INT as fixed time for intermediate red phase after every switch");
582 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");
585 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");
588 oc.
addDescription(
"tls.nema.vehExt",
"TLS Building",
"Set INT as fixed time for intermediate vehext phase after every switch");
591 oc.
addDescription(
"tls.nema.yellow",
"TLS Building",
"Set INT as fixed time for intermediate NEMA yellow phase after every switch");
594 oc.
addDescription(
"tls.nema.red",
"TLS Building",
"Set INT as fixed time for intermediate NEMA red phase after every switch");
597 oc.
addDescription(
"tls.crossing-min.time",
"TLS Building",
"Use INT as minimum green duration for pedestrian crossings (s).");
600 oc.
addDescription(
"tls.crossing-clearance.time",
"TLS Building",
"Use INT as clearance time for pedestrian crossings (s).");
603 oc.
addDescription(
"tls.scramble.time",
"TLS Building",
"Use INT as green phase duration for pedestrian scramble phase (s).");
607 oc.
addSynonyme(
"tls.half-offset",
"tl-logics.half-offset",
true);
608 oc.
addDescription(
"tls.half-offset",
"TLS Building",
"TLSs in STR[] will be shifted by half-phase");
611 oc.
addSynonyme(
"tls.quarter-offset",
"tl-logics.quarter-offset",
true);
612 oc.
addDescription(
"tls.quarter-offset",
"TLS Building",
"TLSs in STR[] will be shifted by quarter-phase");
616 oc.
addDescription(
"tls.default-type",
"TLS Building",
"TLSs with unspecified type will use STR as their algorithm");
619 oc.
addDescription(
"tls.layout",
"TLS Building",
"Set phase layout four grouping opposite directions or grouping all movements for one incoming edge ['opposites', 'incoming']");
622 oc.
addDescription(
"tls.no-mixed",
"TLS Building",
"Avoid phases with green and red signals for different connections from the same lane");
625 oc.
addDescription(
"tls.min-dur",
"TLS Building",
"Default minimum phase duration for traffic lights with variable phase length");
628 oc.
addDescription(
"tls.max-dur",
"TLS Building",
"Default maximum phase duration for traffic lights with variable phase length");
631 oc.
addDescription(
"tls.group-signals",
"TLS Building",
"Assign the same tls link index to connections that share the same states");
634 oc.
addDescription(
"tls.ungroup-signals",
"TLS Building",
"Assign a distinct tls link index to every connection");
637 oc.
addDescription(
"tls.rebuild",
"TLS Building",
"rebuild all traffic light plans in the network");
641 oc.
addSynonyme(
"keep-edges.min-speed",
"edges-min-speed",
true);
642 oc.
addDescription(
"keep-edges.min-speed",
"Edge Removal",
TL(
"Only keep edges with speed in meters/second > FLOAT"));
645 oc.
addSynonyme(
"remove-edges.explicit",
"remove-edges");
646 oc.
addDescription(
"remove-edges.explicit",
"Edge Removal",
TL(
"Remove edges in STR[]"));
649 oc.
addSynonyme(
"keep-edges.explicit",
"keep-edges");
650 oc.
addDescription(
"keep-edges.explicit",
"Edge Removal",
TL(
"Only keep edges in STR[] or those which are kept due to other keep-edges or remove-edges options"));
653 oc.
addDescription(
"keep-edges.input-file",
"Edge Removal",
TL(
"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"));
656 oc.
addDescription(
"remove-edges.input-file",
"Edge Removal",
TL(
"Remove edges in FILE. (Each id on a single line. Selection files from sumo-gui are also supported)"));
660 oc.
addDescription(
"keep-edges.postload",
"Edge Removal",
TL(
"Remove edges after loading, patching and joining"));
664 oc.
addDescription(
"keep-edges.in-boundary",
"Edge Removal",
TL(
"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,...>)"));
667 oc.
addDescription(
"keep-edges.in-geo-boundary",
"Edge Removal",
TL(
"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,...>)"));
671 oc.
addDescription(
"keep-edges.by-vclass",
"Edge Removal",
TL(
"Only keep edges which allow one of the vclasses in STR[]"));
674 oc.
addDescription(
"remove-edges.by-vclass",
"Edge Removal",
TL(
"Remove edges which allow only vclasses from STR[]"));
677 oc.
addDescription(
"keep-edges.by-type",
"Edge Removal",
TL(
"Only keep edges where type is in STR[]"));
680 oc.
addDescription(
"keep-edges.components",
"Edge Removal",
TL(
"Only keep the INT largest weakly connected components"));
683 oc.
addDescription(
"remove-edges.by-type",
"Edge Removal",
TL(
"Remove edges where type is in STR[]"));
686 oc.
addSynonyme(
"remove-edges.isolated",
"remove-isolated",
true);
687 oc.
addDescription(
"remove-edges.isolated",
"Edge Removal",
TL(
"Removes isolated edges"));
691 oc.
addDescription(
"keep-lanes.min-width",
"Edge Removal",
TL(
"Only keep lanes with width in meters > FLOAT"));
696 oc.
addSynonyme(
"keep-nodes-unregulated",
"keep-unregulated");
697 oc.
addDescription(
"keep-nodes-unregulated",
"Unregulated Nodes",
TL(
"All nodes will be unregulated"));
700 oc.
addSynonyme(
"keep-nodes-unregulated.explicit",
"keep-unregulated.explicit");
701 oc.
addSynonyme(
"keep-nodes-unregulated.explicit",
"keep-unregulated.nodes",
true);
702 oc.
addDescription(
"keep-nodes-unregulated.explicit",
"Unregulated Nodes",
TL(
"Do not regulate nodes in STR[]"));
705 oc.
addSynonyme(
"keep-nodes-unregulated.district-nodes",
"keep-unregulated.district-nodes");
706 oc.
addDescription(
"keep-nodes-unregulated.district-nodes",
"Unregulated Nodes",
TL(
"Do not regulate district nodes"));
711 oc.
addSynonyme(
"ramps.guess",
"guess-ramps",
true);
712 oc.
addDescription(
"ramps.guess",
"Ramp Guessing",
TL(
"Enable ramp-guessing"));
715 oc.
addDescription(
"ramps.guess-acceleration-lanes",
"Ramp Guessing",
TL(
"Guess on-ramps and mark acceleration lanes if they exist but do not add new lanes"));
718 oc.
addSynonyme(
"ramps.max-ramp-speed",
"ramp-guess.max-ramp-speed",
true);
719 oc.
addDescription(
"ramps.max-ramp-speed",
"Ramp Guessing",
TL(
"Treat edges with speed > FLOAT as no ramps"));
722 oc.
addSynonyme(
"ramps.min-highway-speed",
"ramp-guess.min-highway-speed",
true);
723 oc.
addDescription(
"ramps.min-highway-speed",
"Ramp Guessing",
TL(
"Treat edges with speed < FLOAT as no highways"));
726 oc.
addSynonyme(
"ramps.ramp-length",
"ramp-guess.ramp-length",
true);
727 oc.
addDescription(
"ramps.ramp-length",
"Ramp Guessing",
TL(
"Use FLOAT as ramp-length"));
731 oc.
addDescription(
"ramps.min-weave-length",
"Ramp Guessing",
TL(
"Use FLOAT as minimum ramp-length"));
734 oc.
addSynonyme(
"ramps.set",
"ramp-guess.explicite",
true);
735 oc.
addDescription(
"ramps.set",
"Ramp Guessing",
TL(
"Tries to handle the given edges as ramps"));
738 oc.
addDescription(
"ramps.unset",
"Ramp Guessing",
TL(
"Do not consider the given edges as ramps"));
741 oc.
addSynonyme(
"ramps.no-split",
"ramp-guess.no-split",
true);
742 oc.
addDescription(
"ramps.no-split",
"Ramp Guessing",
TL(
"Avoids edge splitting"));
755 if (oc.
isSet(
"keep-edges.in-boundary") && oc.
isSet(
"keep-edges.in-geo-boundary")) {
756 WRITE_ERROR(
TL(
"only one of the options 'keep-edges.in-boundary' or 'keep-edges.in-geo-boundary' may be given"));
759 if (oc.
getBool(
"no-internal-links") && oc.
getBool(
"crossings.guess")) {
760 WRITE_ERROR(
TL(
"only one of the options 'no-internal-links' or 'crossings.guess' may be given"));
763 if (oc.
getBool(
"no-internal-links") && oc.
getBool(
"walkingareas")) {
764 WRITE_ERROR(
TL(
"only one of the options 'no-internal-links' or 'walkareas' may be given"));
768 WRITE_ERROR(
TL(
"only one of the options 'tls.green.time' or 'tls.cycle.time' may be given"));
771 if (oc.
getInt(
"tls.green.time") <= 0) {
775 if (oc.
getInt(
"default.lanenumber") < 1) {
779 if (!oc.
isDefault(
"default.lanewidth") && oc.
getFloat(
"default.lanewidth") < POSITION_EPS) {
784 WRITE_ERROR(
TL(
"only one of the options 'default.disallow' or 'default.allow' may be given"));
787 if (oc.
getInt(
"junctions.internal-link-detail") < 2) {
791 if (oc.
getFloat(
"junctions.scurve-stretch") > 0) {
792 if (oc.
getBool(
"no-internal-links")) {
793 WRITE_WARNING(
TL(
"Option 'junctions.scurve-stretch' requires internal lanes to work. Option '--no-internal-links' will be disabled."));
796 oc.
set(
"no-internal-links",
"false");
798 if (oc.
getFloat(
"junctions.small-radius") > oc.
getFloat(
"default.junctions.radius") && oc.
getFloat(
"default.junctions.radius") >= 0) {
799 if (!oc.
isDefault(
"junctions.small-radius")) {
800 WRITE_WARNING(
TL(
"option 'default.junctions.radius' is smaller than option 'junctions.small-radius'"));
805 if (oc.
getString(
"tls.layout") !=
"opposites"
806 && oc.
getString(
"tls.layout") !=
"incoming"
807 && oc.
getString(
"tls.layout") !=
"alternateOneWay") {
808 WRITE_ERROR(
TL(
"tls.layout must be 'opposites', 'incoming' or 'alternateOneWay'"));
811 if (!oc.
isDefault(
"default.right-of-way") &&
817 WRITE_ERROR(
TL(
"roundabouts.visibility-distance must be positive or -1"));
820 if (oc.
isDefault(
"railway.topology.repair") && oc.
getBool(
"railway.topology.repair.connect-straight")) {
821 oc.
setDefault(
"railway.topology.repair",
"true");
823 if (oc.
isDefault(
"railway.topology.repair") && oc.
getBool(
"railway.topology.repair.minimal")) {
824 oc.
setDefault(
"railway.topology.repair",
"true");
826 if (oc.
isDefault(
"railway.topology.all-bidi") && !oc.
isDefault(
"railway.topology.all-bidi.input-file")) {
827 oc.
setDefault(
"railway.topology.all-bidi",
"true");
829 if (oc.
isDefault(
"railway.topology.repair.stop-turn") && !oc.
isDefault(
"railway.topology.repair")) {
830 oc.
setDefault(
"railway.topology.repair.stop-turn",
"true");
#define WRITE_ERRORF(...)
#define WRITE_WARNING(msg)
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
static const double UNSPECIFIED_FRICTION
unspecified lane friction
static const double UNSPECIFIED_LOADED_LENGTH
no length override given
static const double UNSPECIFIED_CONTPOS
unspecified internal junction position
static const double UNSPECIFIED_VISIBILITY_DISTANCE
unspecified foe visibility for connections
static const double UNSPECIFIED_WIDTH
unspecified lane width
static void fillOptions(OptionsCont &oc, bool forNetgen)
Inserts options used by the network converter.
static bool checkOptions(OptionsCont &oc)
Checks set options from the OptionsCont-singleton for being valid.
A storage for options typed value containers)
void addDescription(const std::string &name, const std::string &subtopic, const std::string &description)
Adds a description for an option.
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)
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.
void doRegister(const std::string &name, Option *o)
Adds an option under the given name.
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 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