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-2017 German Aerospace Center (DLR) and others.
4 /****************************************************************************/
5 //
6 // This program and the accompanying materials
7 // are made available under the terms of the Eclipse Public License v2.0
8 // which accompanies this distribution, and is available at
9 // http://www.eclipse.org/legal/epl-v20.html
10 //
11 /****************************************************************************/
19 // Sets and checks options for netbuild
20 /****************************************************************************/
21 
22 
23 // ===========================================================================
24 // included modules
25 // ===========================================================================
26 #ifdef _MSC_VER
27 #include <windows_config.h>
28 #else
29 #include <config.h>
30 #endif
31 
32 #include <string>
33 #include <fstream>
34 #include "NBFrame.h"
35 #include "NBNodeCont.h"
36 #include "NBEdgeCont.h"
38 #include "NBDistrictCont.h"
39 #include "NBRequest.h"
40 #include "NBTypeCont.h"
45 #include <utils/common/ToString.h>
49 
50 
51 // ===========================================================================
52 // method definitions
53 // ===========================================================================
54 void
55 NBFrame::fillOptions(bool forNetgen) {
57  // register building defaults
58  oc.doRegister("default.lanenumber", 'L', new Option_Integer(1));
59  oc.addSynonyme("default.lanenumber", "lanenumber", true);
60  oc.addDescription("default.lanenumber", "Building Defaults", "The default number of lanes in an edge");
61 
62  oc.doRegister("default.lanewidth", new Option_Float(NBEdge::UNSPECIFIED_WIDTH));
63  oc.addSynonyme("default.lanewidth", "lanewidth", true);
64  oc.addDescription("default.lanewidth", "Building Defaults", "The default width of lanes");
65 
66  oc.doRegister("default.speed", 'S', new Option_Float((double) 13.9));
67  oc.addSynonyme("default.speed", "speed", true);
68  oc.addDescription("default.speed", "Building Defaults", "The default speed on an edge (in m/s)");
69 
70  oc.doRegister("default.priority", 'P', new Option_Integer(-1));
71  oc.addSynonyme("default.priority", "priority", true);
72  oc.addDescription("default.priority", "Building Defaults", "The default priority of an edge");
73 
74  oc.doRegister("default.sidewalk-width", new Option_Float((double) 2.0));
75  oc.addDescription("default.sidewalk-width", "Building Defaults", "The default width of added sidewalks");
76 
77  oc.doRegister("default.crossing-width", new Option_Float((double) 4.0));
78  oc.addDescription("default.crossing-width", "Building Defaults", "The default width of a pedestrian crossing");
79 
80  oc.doRegister("default.disallow", new Option_String());
81  oc.addDescription("default.disallow", "Building Defaults", "The default for disallowed vehicle classes");
82 
83  oc.doRegister("default.junctions.keep-clear", new Option_Bool(true));
84  oc.addDescription("default.junctions.keep-clear", "Building Defaults", "Whether junctions should be kept clear by default");
85 
86  oc.doRegister("default.junctions.radius", new Option_Float(1.5));
87  oc.addDescription("default.junctions.radius", "Building Defaults", "The default turning radius of intersections");
88 
89  // register the data processing options
90  oc.doRegister("no-internal-links", new Option_Bool(false)); // !!! not described
91  oc.addDescription("no-internal-links", "Processing", "Omits internal links");
92 
93  oc.doRegister("numerical-ids", new Option_Bool(false));
94  oc.addDescription("numerical-ids", "Processing", "Remaps alphanumerical IDs of nodes and edges to ensure that all IDs are integers");
95 
97  oc.doRegister("reserved-ids", new Option_FileName());
98  oc.addDescription("reserved-ids", "Processing", "Ensures that generated ids do not included any of the typed IDs from FILE (SUMO-GUI selection file format)");
99 
100  if (!forNetgen) {
101  oc.doRegister("dismiss-vclasses", new Option_Bool(false));
102  oc.addDescription("dismiss-vclasses", "Processing", "Removes vehicle class restrictions from imported edges");
103  }
104 
105  oc.doRegister("no-turnarounds", new Option_Bool(false));
106  oc.addDescription("no-turnarounds", "Processing", "Disables building turnarounds");
107 
108  oc.doRegister("no-turnarounds.tls", new Option_Bool(false));
109  oc.addSynonyme("no-turnarounds.tls", "no-tls-turnarounds", true);
110  oc.addDescription("no-turnarounds.tls", "Processing", "Disables building turnarounds at tls-controlled junctions");
111 
112  oc.doRegister("no-left-connections", new Option_Bool(false));
113  oc.addDescription("no-left-connections", "Processing", "Disables building connections to left");
114 
115  if (!forNetgen) {
116  oc.doRegister("geometry.split", new Option_Bool(false)); // !!!not described
117  oc.addSynonyme("geometry.split", "split-geometry", true);
118  oc.addDescription("geometry.split", "Processing", "Splits edges across geometry nodes");
119 
120  oc.doRegister("geometry.remove", 'R', new Option_Bool(false));
121  oc.addSynonyme("geometry.remove", "remove-geometry", true);
122  oc.addDescription("geometry.remove", "Processing", "Replace nodes which only define edge geometry by geometry points (joins edges)");
123 
124  oc.doRegister("geometry.remove.keep-edges.explicit", new Option_String());
125  oc.addDescription("geometry.remove.keep-edges.explicit", "Processing", "Ensure that the given list of edges is not modified");
126 
127  oc.doRegister("geometry.remove.keep-edges.input-file", new Option_FileName());
128  oc.addDescription("geometry.remove.keep-edges.input-file", "Processing",
129  "Ensure that the edges in FILE are not modified (Each id on a single line. Selection files from SUMO-GUI are also supported)");
130 
131  oc.doRegister("geometry.max-segment-length", new Option_Float(0));
132  oc.addDescription("geometry.max-segment-length", "Processing", "splits geometry to restrict segment length");
133 
134  oc.doRegister("geometry.min-dist", new Option_Float(-1));
135  oc.addDescription("geometry.min-dist", "Processing", "reduces too similar geometry points");
136 
137  oc.doRegister("geometry.max-angle", new Option_Float(99));
138  oc.addDescription("geometry.max-angle", "Processing", "Warn about edge geometries with an angle above DEGREES in successive segments");
139 
140  oc.doRegister("geometry.min-radius", new Option_Float(9));
141  oc.addDescription("geometry.min-radius", "Processing", "Warn about edge geometries with a turning radius less than METERS at the start or end");
142 
143  oc.doRegister("geometry.min-radius.fix", new Option_Bool(false));
144  oc.addDescription("geometry.min-radius.fix", "Processing", "Straighten edge geometries to avoid turning radii less than geometry.min-radius");
145 
146  oc.doRegister("geometry.junction-mismatch-threshold", new Option_Float(20));
147  oc.addDescription("geometry.junction-mismatch-threshold", "Processing", "Warn if the junction shape is to far away from the original node position");
148 
149  oc.doRegister("geometry.check-overlap", new Option_Float(0));
150  oc.addDescription("geometry.check-overlap", "Processing", "Warn if edges overlap by more than the given threshold value");
151 
152  oc.doRegister("geometry.check-overlap.vertical-threshold", new Option_Float(4));
153  oc.addDescription("geometry.check-overlap.vertical-threshold", "Processing", "Ignore overlapping edges if they are separated vertically by the given threshold.");
154 
155  oc.doRegister("geometry.max-grade", new Option_Float(10));
156  oc.addDescription("geometry.max-grade", "Processing", "Warn about edge geometries with a grade in % above FLOAT. The threshold applies to roads with a speed limit of 50km/h and is scaled according to road speed.");
157  }
158 
159  oc.doRegister("offset.disable-normalization", new Option_Bool(false));
160  oc.addSynonyme("offset.disable-normalization", "disable-normalize-node-positions", true);
161  oc.addDescription("offset.disable-normalization", "Processing", "Turn off normalizing node positions");
162 
163  oc.doRegister("offset.x", new Option_Float(0));
164  oc.addSynonyme("offset.x", "x-offset-to-apply", true);
165  oc.addDescription("offset.x", "Processing", "Adds FLOAT to net x-positions");
166 
167  oc.doRegister("offset.y", new Option_Float(0));
168  oc.addSynonyme("offset.y", "y-offset-to-apply", true);
169  oc.addDescription("offset.y", "Processing", "Adds FLOAT to net y-positions");
170 
171  oc.doRegister("flip-y-axis", new Option_Bool(false));
172  oc.addSynonyme("flip-y-axis", "flip-y");
173  oc.addDescription("flip-y-axis", "Processing", "Flips the y-coordinate along zero");
174 
175  oc.doRegister("roundabouts.guess", new Option_Bool(false));
176  oc.addSynonyme("roundabouts.guess", "guess-roundabouts", true);
177  oc.addDescription("roundabouts.guess", "Processing", "Enable roundabout-guessing");
178 
179  oc.doRegister("opposites.guess", new Option_Bool(false));
180  oc.addDescription("opposites.guess", "Processing", "Enable guessing of opposite direction lanes usable for overtaking");
181 
182  oc.doRegister("opposites.guess.fix-lengths", new Option_Bool(false));
183  oc.addDescription("opposites.guess.fix-lengths", "Processing", "Ensure that opposite edges have the same length");
184 
185  oc.doRegister("lefthand", new Option_Bool(false));
186  oc.addDescription("lefthand", "Processing", "Assumes left-hand traffic on the network");
187 
188  oc.doRegister("edges.join", new Option_Bool(false));
189  oc.addDescription("edges.join", "Processing",
190  "Merges edges which connect the same nodes and are close to each other (recommended for VISSIM import)");
191 
192  oc.doRegister("junctions.join", new Option_Bool(false));
193  oc.addDescription("junctions.join", "Processing",
194  "Joins junctions that are close to each other (recommended for OSM import)");
195 
196  oc.doRegister("junctions.join-dist", new Option_Float(10));
197  oc.addDescription("junctions.join-dist", "Processing",
198  "Determines the maximal distance for joining junctions (defaults to 10)");
199 
200  if (!forNetgen) {
201  oc.doRegister("junctions.join-exclude", new Option_String());
202  oc.addDescription("junctions.join-exclude", "Processing", "Interprets STR as list of junctions to exclude from joining");
203 
204  oc.doRegister("speed.offset", new Option_Float(0));
205  oc.addDescription("speed.offset", "Processing", "Modifies all edge speeds by adding FLOAT");
206 
207  oc.doRegister("speed.factor", new Option_Float(1));
208  oc.addDescription("speed.factor", "Processing", "Modifies all edge speeds by multiplying by FLOAT");
209 
210  oc.doRegister("speed.minimum", new Option_Float(0));
211  oc.addDescription("speed.minimum", "Processing", "Modifies all edge speeds to at least FLOAT");
212  }
213 
214  oc.doRegister("junctions.corner-detail", new Option_Integer(0));
215  oc.addDescription("junctions.corner-detail", "Processing", "Generate INT intermediate points to smooth out intersection corners");
216 
217  oc.doRegister("junctions.internal-link-detail", new Option_Integer(5));
218  oc.addDescription("junctions.internal-link-detail", "Processing", "Generate INT intermediate points to smooth out lanes within the intersection");
219 
220  oc.doRegister("junctions.scurve-stretch", new Option_Float(0));
221  oc.addDescription("junctions.scurve-stretch", "Processing", "Generate longer intersections to allow for smooth s-curves when the number of lanes changes");
222 
223  oc.doRegister("junctions.join-turns", new Option_Bool(false));
224  oc.addDescription("junctions.join-turns", "Processing",
225  "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");
226 
227  oc.doRegister("rectangular-lane-cut", new Option_Bool(false));
228  oc.addDescription("rectangular-lane-cut", "Processing", "Forces rectangular cuts between lanes and intersections");
229 
230  oc.doRegister("check-lane-foes.roundabout", new Option_Bool(true));
231  oc.addDescription("check-lane-foes.roundabout", "Processing",
232  "Allow driving onto a multi-lane road if there are foes on other lanes (at roundabouts)");
233 
234  oc.doRegister("check-lane-foes.all", new Option_Bool(false));
235  oc.addDescription("check-lane-foes.all", "Processing",
236  "Allow driving onto a multi-lane road if there are foes on other lanes (everywhere)");
237 
238  oc.doRegister("sidewalks.guess", new Option_Bool(false));
239  oc.addDescription("sidewalks.guess", "Processing",
240  "Guess pedestrian sidewalks based on edge speed");
241 
242  oc.doRegister("sidewalks.guess.max-speed", new Option_Float((double) 13.89));
243  oc.addDescription("sidewalks.guess.max-speed", "Processing",
244  "Add sidewalks for edges with a speed equal or below the given limit");
245 
246  oc.doRegister("sidewalks.guess.min-speed", new Option_Float((double) 5.8));
247  oc.addDescription("sidewalks.guess.min-speed", "Processing",
248  "Add sidewalks for edges with a speed above the given limit");
249 
250  oc.doRegister("sidewalks.guess.from-permissions", new Option_Bool(false));
251  oc.addDescription("sidewalks.guess.from-permissions", "Processing",
252  "Add sidewalks for edges that allow pedestrians on any of their lanes regardless of speed");
253 
254  oc.doRegister("sidewalks.guess.exclude", new Option_String());
255  oc.addDescription("sidewalks.guess.exclude", "Processing",
256  "Do not guess sidewalks for the given list of edges");
257 
258  oc.doRegister("crossings.guess", new Option_Bool(false));
259  oc.addDescription("crossings.guess", "Processing",
260  "Guess pedestrian crossings based on the presence of sidewalks");
261 
262  oc.doRegister("crossings.guess.speed-threshold", new Option_Float(13.89));
263  oc.addDescription("crossings.guess.speed-threshold", "Processing",
264  "At uncontrolled nodes, do not build crossings across edges with a speed above the threshold");
265 
266  oc.doRegister("walkingareas", new Option_Bool(false));
267  oc.addDescription("walkingareas", "Processing", "Always build walking areas even if there are no crossings");
268 
269  // tls setting options
270  // explicit tls
271  oc.doRegister("tls.set", new Option_String());
272  oc.addSynonyme("tls.set", "explicite-tls", true);
273  oc.addDescription("tls.set", "TLS Building", "Interprets STR as list of junctions to be controlled by TLS");
274 
275  oc.doRegister("tls.unset", new Option_String());
276  oc.addSynonyme("tls.unset", "explicite-no-tls", true);
277  oc.addDescription("tls.unset", "TLS Building", "Interprets STR as list of junctions to be not controlled by TLS");
278 
279  // tls-guessing
280  oc.doRegister("tls.guess", new Option_Bool(false));
281  oc.addSynonyme("tls.guess", "guess-tls", true);
282  oc.addDescription("tls.guess", "TLS Building", "Turns on TLS guessing");
283 
284  if (!forNetgen) {
285  oc.doRegister("tls.taz-nodes", new Option_Bool(false));
286  oc.addSynonyme("tls.taz-nodes", "tls-guess.district-nodes", true);
287  oc.addDescription("tls.taz-nodes", "TLS Building", "Sets district nodes as tls-controlled"); // !!! describe
288  }
289 
290  oc.doRegister("tls-guess.joining", new Option_Bool(false));
291  oc.addDescription("tls-guess.joining", "TLS Building", "Includes node clusters into guess"); // !!! describe
292 
293  oc.doRegister("tls.join", new Option_Bool(false));
294  oc.addSynonyme("tls.join", "try-join-tls", true);
295  oc.addDescription("tls.join", "TLS Building", "Tries to cluster tls-controlled nodes"); // !!! describe
296 
297  oc.doRegister("tls.join-dist", new Option_Float(20));
298  oc.addDescription("tls.join-dist", "TLS Building",
299  "Determines the maximal distance for joining traffic lights (defaults to 20)");
300 
301  oc.doRegister("tls.uncontrolled-within", new Option_Bool(false));
302  oc.addDescription("tls.uncontrolled-within", "TLS Building",
303  "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");
304 
305  if (!forNetgen) {
306  oc.doRegister("tls.guess-signals", new Option_Bool(false));
307  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");
308 
309  oc.doRegister("tls.guess-signals.dist", new Option_Float(25));
310  oc.addDescription("tls.guess-signals.dist", "TLS Building", "Distance for interpreting nodes as signal locations");
311  }
312 
313 
314  // computational
315  oc.doRegister("tls.cycle.time", new Option_Integer(90));
316  oc.addDescription("tls.cycle.time", "TLS Building", "Use INT as cycle duration");
317 
318  oc.doRegister("tls.green.time", new Option_Integer(31));
319  oc.addSynonyme("tls.green.time", "traffic-light-green", true);
320  oc.addDescription("tls.green.time", "TLS Building", "Use INT as green phase duration");
321 
322  oc.doRegister("tls.yellow.min-decel", 'D', new Option_Float(3.0));
323  oc.addSynonyme("tls.yellow.min-decel", "min-decel", true);
324  oc.addDescription("tls.yellow.min-decel", "TLS Building", "Defines smallest vehicle deceleration");
325 
326  oc.doRegister("tls.yellow.patch-small", new Option_Bool(false));
327  oc.addSynonyme("tls.yellow.patch-small", "patch-small-tyellow", true);
328  oc.addDescription("tls.yellow.patch-small", "TLS Building", "Given yellow times are patched even if being too short");
329 
330  oc.doRegister("tls.yellow.time", new Option_Integer(-1));
331  oc.addSynonyme("tls.yellow.time", "traffic-light-yellow", true);
332  oc.addDescription("tls.yellow.time", "TLS Building", "Set INT as fixed time for yellow phase durations");
333 
334  oc.doRegister("tls.red.time", new Option_Integer(5));
335  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");
336 
337  oc.doRegister("tls.allred.time", new Option_Integer(0));
338  oc.addDescription("tls.allred.time", "TLS Building", "Set INT as fixed time for intermediate red phase after every switch");
339 
340  oc.doRegister("tls.left-green.time", new Option_Integer(6));
341  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");
342 
343  // tls-shifts
344  oc.doRegister("tls.half-offset", new Option_String());
345  oc.addSynonyme("tls.half-offset", "tl-logics.half-offset", true);
346  oc.addDescription("tls.half-offset", "TLS Building", "TLSs in STR will be shifted by half-phase");
347 
348  oc.doRegister("tls.quarter-offset", new Option_String());
349  oc.addSynonyme("tls.quarter-offset", "tl-logics.quarter-offset", true);
350  oc.addDescription("tls.quarter-offset", "TLS Building", "TLSs in STR will be shifted by quarter-phase");
351 
352  // tls type
353  oc.doRegister("tls.default-type", new Option_String("static"));
354  oc.addDescription("tls.default-type", "TLS Building", "TLSs with unspecified type will use STR as their algorithm");
355 
356  oc.doRegister("tls.min-dur", new Option_Integer(5));
357  oc.addDescription("tls.min-dur", "TLS Building", "Default minimum phase duration for traffic lights with variable phase length");
358 
359  oc.doRegister("tls.max-dur", new Option_Integer(50));
360  oc.addDescription("tls.max-dur", "TLS Building", "Default maximum phase duration for traffic lights with variable phase length");
361 
362  // edge pruning
363  oc.doRegister("keep-edges.min-speed", new Option_Float(-1));
364  oc.addSynonyme("keep-edges.min-speed", "edges-min-speed", true);
365  oc.addDescription("keep-edges.min-speed", "Edge Removal", "Only keep edges with speed in meters/second > FLOAT");
366 
367  oc.doRegister("remove-edges.explicit", new Option_String());
368  oc.addSynonyme("remove-edges.explicit", "remove-edges");
369  oc.addDescription("remove-edges.explicit", "Edge Removal", "Remove edges in STR");
370 
371  oc.doRegister("keep-edges.explicit", new Option_String());
372  oc.addSynonyme("keep-edges.explicit", "keep-edges");
373  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");
374 
375  oc.doRegister("keep-edges.input-file", new Option_FileName());
376  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");
377 
378  oc.doRegister("remove-edges.input-file", new Option_FileName());
379  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)");
380 
381  if (!forNetgen) {
382  oc.doRegister("keep-edges.postload", new Option_Bool(false));
383  oc.addDescription("keep-edges.postload", "Edge Removal", "Remove edges after joining");
384  }
385 
386  oc.doRegister("keep-edges.in-boundary", new Option_String());
387  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,...>)");
388 
389  oc.doRegister("keep-edges.in-geo-boundary", new Option_String());
390  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,...>)");
391 
392  if (!forNetgen) {
393  oc.doRegister("keep-edges.by-vclass", new Option_String());
394  oc.addDescription("keep-edges.by-vclass", "Edge Removal", "Only keep edges which allow one of the vclasss in STR");
395 
396  oc.doRegister("remove-edges.by-vclass", new Option_String());
397  oc.addDescription("remove-edges.by-vclass", "Edge Removal", "Remove edges which allow only vclasses from STR");
398 
399  oc.doRegister("keep-edges.by-type", new Option_String());
400  oc.addDescription("keep-edges.by-type", "Edge Removal", "Only keep edges where type is in STR");
401 
402  oc.doRegister("keep-edges.components", new Option_Integer(0));
403  oc.addDescription("keep-edges.components", "Edge Removal", "Only keep the INT largest weakly connected compoonents");
404 
405  oc.doRegister("remove-edges.by-type", new Option_String());
406  oc.addDescription("remove-edges.by-type", "Edge Removal", "Remove edges where type is in STR");
407 
408  oc.doRegister("remove-edges.isolated", new Option_Bool(false));
409  oc.addSynonyme("remove-edges.isolated", "remove-isolated", true);
410  oc.addDescription("remove-edges.isolated", "Edge Removal", "Removes isolated edges");
411  }
412 
413 
414  // unregulated nodes options
415  oc.doRegister("keep-nodes-unregulated", new Option_Bool(false));
416  oc.addSynonyme("keep-nodes-unregulated", "keep-unregulated");
417  oc.addDescription("keep-nodes-unregulated", "Unregulated Nodes", "All nodes will be unregulated");
418 
419  oc.doRegister("keep-nodes-unregulated.explicit", new Option_String());
420  oc.addSynonyme("keep-nodes-unregulated.explicit", "keep-unregulated.explicit");
421  oc.addSynonyme("keep-nodes-unregulated.explicit", "keep-unregulated.nodes", true);
422  oc.addDescription("keep-nodes-unregulated.explicit", "Unregulated Nodes", "Do not regulate nodes in STR");
423 
424  oc.doRegister("keep-nodes-unregulated.district-nodes", new Option_Bool(false));
425  oc.addSynonyme("keep-nodes-unregulated.district-nodes", "keep-unregulated.district-nodes");
426  oc.addDescription("keep-nodes-unregulated.district-nodes", "Unregulated Nodes", "Do not regulate district nodes");
427 
428  // ramp guessing options
429  if (!forNetgen) {
430  oc.doRegister("ramps.guess", new Option_Bool(false));
431  oc.addSynonyme("ramps.guess", "guess-ramps", true);
432  oc.addDescription("ramps.guess", "Ramp Guessing", "Enable ramp-guessing");
433 
434  oc.doRegister("ramps.max-ramp-speed", new Option_Float(-1));
435  oc.addSynonyme("ramps.max-ramp-speed", "ramp-guess.max-ramp-speed", true);
436  oc.addDescription("ramps.max-ramp-speed", "Ramp Guessing", "Treat edges with speed > FLOAT as no ramps");
437 
438  oc.doRegister("ramps.min-highway-speed", new Option_Float((double)(79 / 3.6)));
439  oc.addSynonyme("ramps.min-highway-speed", "ramp-guess.min-highway-speed", true);
440  oc.addDescription("ramps.min-highway-speed", "Ramp Guessing", "Treat edges with speed < FLOAT as no highways");
441 
442  oc.doRegister("ramps.ramp-length", new Option_Float(100));
443  oc.addSynonyme("ramps.ramp-length", "ramp-guess.ramp-length", true);
444  oc.addDescription("ramps.ramp-length", "Ramp Guessing", "Use FLOAT as ramp-length");
445 
446  oc.doRegister("ramps.set", new Option_String());
447  oc.addSynonyme("ramps.set", "ramp-guess.explicite", true);
448  oc.addDescription("ramps.set", "Ramp Guessing", "Tries to handle the given edges as ramps");
449 
450  oc.doRegister("ramps.unset", new Option_String());
451  oc.addDescription("ramps.unset", "Ramp Guessing", "Do not consider the given edges as ramps");
452 
453  oc.doRegister("ramps.no-split", new Option_Bool(false));
454  oc.addSynonyme("ramps.no-split", "ramp-guess.no-split", true);
455  oc.addDescription("ramps.no-split", "Ramp Guessing", "Avoids edge splitting");
456  }
457 }
458 
459 
460 bool
463  bool ok = true;
464  //
465  if (!oc.isDefault("tls-guess.joining")) {
466  WRITE_WARNING("'--tls-guess.joining' was joined with '--tls.join'.\n Please use '--tls.join' in future only.");
467  if (!oc.isSet("tls.join")) {
468  oc.set("tls.join", "true");
469  }
470  }
471  if (!SUMOXMLDefinitions::TrafficLightTypes.hasString(oc.getString("tls.default-type"))) {
472  WRITE_ERROR("unsupported value '" + oc.getString("tls.default-type") + "' for option '--tls.default-type'");
473  ok = false;
474  }
475  if (oc.isSet("keep-edges.in-boundary") && oc.isSet("keep-edges.in-geo-boundary")) {
476  WRITE_ERROR("only one of the options 'keep-edges.in-boundary' or 'keep-edges.in-geo-boundary' may be given");
477  ok = false;
478  }
479  if (oc.getBool("no-internal-links") && oc.getBool("crossings.guess")) {
480  WRITE_ERROR("only one of the options 'no-internal-links' or 'crossings.guess' may be given");
481  ok = false;
482  }
483  if (oc.getBool("no-internal-links") && oc.getBool("walkingareas")) {
484  WRITE_ERROR("only one of the options 'no-internal-links' or 'walkareas' may be given");
485  ok = false;
486  }
487  if (!oc.isDefault("tls.green.time") && !oc.isDefault("tls.cycle.time")) {
488  WRITE_ERROR("only one of the options 'tls.green.time' or 'tls.cycle.time' may be given");
489  ok = false;
490  }
491  if (oc.getInt("junctions.internal-link-detail") < 2) {
492  WRITE_ERROR("junctions.internal-link-detail must >= 2");
493  ok = false;
494  }
495  if (oc.getFloat("junctions.scurve-stretch") > 0) {
496  if (oc.getBool("no-internal-links")) {
497  WRITE_WARNING("option 'junctions.scurve-stretch' requires internal lanes to work. Option '--no-internal-links' was disabled.");
498  }
499  // make sure the option is set so heuristics cannot ignore it
500  oc.set("no-internal-links", "false");
501  }
502  return ok;
503 }
504 
505 
506 /****************************************************************************/
void doRegister(const std::string &name, Option *v)
Adds an option under the given name.
Definition: OptionsCont.cpp:81
static bool checkOptions()
Checks set options from the OptionsCont-singleton for being valid.
Definition: NBFrame.cpp:461
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
bool isDefault(const std::string &name) const
Returns the information whether the named option has still the default value.
static const double UNSPECIFIED_WIDTH
unspecified lane width
Definition: NBEdge.h:254
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:199
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:64
void addSynonyme(const std::string &name1, const std::string &name2, bool isDeprecated=false)
Adds a synonyme for an options name (any order)
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
static StringBijection< TrafficLightType > TrafficLightTypes
traffic light types
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:205
bool set(const std::string &name, const std::string &value)
Sets the given value for the named option.
An integer-option.
Definition: Option.h:312
A storage for options typed value containers)
Definition: OptionsCont.h:98
static void fillOptions(bool forNetgen)
Inserts options used by the network converter.
Definition: NBFrame.cpp:55
void addDescription(const std::string &name, const std::string &subtopic, const std::string &description)
Adds a description for an option.