Eclipse SUMO - Simulation of Urban MObility
AdditionalHandler.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 // Copyright (C) 2001-2024 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 /****************************************************************************/
18 // The XML-Handler for additionals loading
19 /****************************************************************************/
20 #include <config.h>
21 
22 #include <utils/common/MsgHandler.h>
23 #include <utils/xml/SUMOSAXHandler.h>
24 #include <utils/shapes/Shape.h>
25 #include <utils/shapes/PointOfInterest.h>
26 #include <utils/options/OptionsCont.h>
27 #include <utils/vehicle/SUMOVehicleParserHelper.h>
28 #include <utils/xml/SUMOXMLDefinitions.h>
29 
30 #include "AdditionalHandler.h"
31 
32 
33 // ===========================================================================
34 // method definitions
35 // ===========================================================================
36 
37 AdditionalHandler::AdditionalHandler() {}
38 
39 
40 AdditionalHandler::~AdditionalHandler() {}
41 
42 
43 bool
44 AdditionalHandler::beginParseAttributes(SumoXMLTag tag, const SUMOSAXAttributes& attrs) {
45  // open SUMOBaseOBject
46  myCommonXMLStructure.openSUMOBaseOBject();
47  // check tag
48  try {
49  switch (tag) {
50  // Stopping Places
51  case SUMO_TAG_BUS_STOP:
52  parseBusStopAttributes(attrs);
53  break;
54  case SUMO_TAG_TRAIN_STOP:
55  parseTrainStopAttributes(attrs);
56  break;
57  case SUMO_TAG_ACCESS:
58  parseAccessAttributes(attrs);
59  break;
60  case SUMO_TAG_CONTAINER_STOP:
61  parseContainerStopAttributes(attrs);
62  break;
63  case SUMO_TAG_CHARGING_STATION:
64  parseChargingStationAttributes(attrs);
65  break;
66  case SUMO_TAG_PARKING_AREA:
67  parseParkingAreaAttributes(attrs);
68  break;
69  case SUMO_TAG_PARKING_SPACE:
70  parseParkingSpaceAttributes(attrs);
71  break;
72  // Detectors
73  case SUMO_TAG_E1DETECTOR:
74  case SUMO_TAG_INDUCTION_LOOP:
75  parseE1Attributes(attrs);
76  break;
77  case SUMO_TAG_E2DETECTOR:
78  case SUMO_TAG_LANE_AREA_DETECTOR:
79  parseE2Attributes(attrs);
80  break;
81  case SUMO_TAG_E3DETECTOR:
82  case SUMO_TAG_ENTRY_EXIT_DETECTOR:
83  parseE3Attributes(attrs);
84  break;
85  case SUMO_TAG_DET_ENTRY:
86  parseEntryAttributes(attrs);
87  break;
88  case SUMO_TAG_DET_EXIT:
89  parseExitAttributes(attrs);
90  break;
91  case SUMO_TAG_INSTANT_INDUCTION_LOOP:
92  parseE1InstantAttributes(attrs);
93  break;
94  // TAZs
95  case SUMO_TAG_TAZ:
96  parseTAZAttributes(attrs);
97  break;
98  case SUMO_TAG_TAZSOURCE:
99  parseTAZSourceAttributes(attrs);
100  break;
101  case SUMO_TAG_TAZSINK:
102  parseTAZSinkAttributes(attrs);
103  break;
104  // Variable Speed Sign
105  case SUMO_TAG_VSS:
106  parseVariableSpeedSignAttributes(attrs);
107  break;
108  case SUMO_TAG_STEP:
109  parseVariableSpeedSignStepAttributes(attrs);
110  break;
111  // Calibrator
112  case SUMO_TAG_CALIBRATOR:
113  case GNE_TAG_CALIBRATOR_LANE:
114  parseCalibratorAttributes(attrs);
115  break;
116  // flow (calibrator)
117  case SUMO_TAG_FLOW:
118  parseCalibratorFlowAttributes(attrs);
119  break;
120  // Rerouter
121  case SUMO_TAG_REROUTER:
122  parseRerouterAttributes(attrs);
123  break;
124  case SUMO_TAG_INTERVAL:
125  parseRerouterIntervalAttributes(attrs);
126  break;
127  case SUMO_TAG_CLOSING_LANE_REROUTE:
128  parseClosingLaneRerouteAttributes(attrs);
129  break;
130  case SUMO_TAG_CLOSING_REROUTE:
131  parseClosingRerouteAttributes(attrs);
132  break;
133  case SUMO_TAG_DEST_PROB_REROUTE:
134  parseDestProbRerouteAttributes(attrs);
135  break;
136  case SUMO_TAG_PARKING_AREA_REROUTE:
137  parseParkingAreaRerouteAttributes(attrs);
138  break;
139  case SUMO_TAG_ROUTE_PROB_REROUTE:
140  parseRouteProbRerouteAttributes(attrs);
141  break;
142  // Route probe
143  case SUMO_TAG_ROUTEPROBE:
144  parseRouteProbeAttributes(attrs);
145  break;
146  // Vaporizer (deprecated)
147  case SUMO_TAG_VAPORIZER:
148  parseVaporizerAttributes(attrs);
149  break;
150  // wires
151  case SUMO_TAG_TRACTION_SUBSTATION:
152  parseTractionSubstation(attrs);
153  break;
154  case SUMO_TAG_OVERHEAD_WIRE_CLAMP:
155  parseOverheadWireClamp(attrs);
156  break;
157  case SUMO_TAG_OVERHEAD_WIRE_SECTION:
158  parseOverheadWire(attrs);
159  break;
160  // Poly
161  case SUMO_TAG_POLY:
162  parsePolyAttributes(attrs);
163  break;
164  case SUMO_TAG_POI:
165  parsePOIAttributes(attrs);
166  break;
167  // JuPedSim
168  case GNE_TAG_JPS_WALKABLEAREA:
169  parseJpsWalkableAreaAttributes(attrs);
170  break;
171  case GNE_TAG_JPS_OBSTACLE:
172  parseJpsObstacleAttributes(attrs);
173  break;
174  // parameters
175  case SUMO_TAG_PARAM:
176  parseParameters(attrs);
177  break;
178  default:
179  // tag cannot be parsed in AdditionalHandler
180  return false;
181  break;
182  }
183  } catch (InvalidArgument& e) {
184  writeError(e.what());
185  }
186  return true;
187 }
188 
189 
190 void
191 AdditionalHandler::endParseAttributes() {
192  // get last inserted object
193  CommonXMLStructure::SumoBaseObject* obj = myCommonXMLStructure.getCurrentSumoBaseObject();
194  // close SUMOBaseOBject
195  myCommonXMLStructure.closeSUMOBaseOBject();
196  // check tag
197  switch (obj->getTag()) {
198  // Stopping Places
199  case SUMO_TAG_BUS_STOP:
200  case SUMO_TAG_TRAIN_STOP:
201  case SUMO_TAG_CONTAINER_STOP:
202  case SUMO_TAG_CHARGING_STATION:
203  case SUMO_TAG_PARKING_AREA:
204  // detectors
205  case SUMO_TAG_E1DETECTOR:
206  case SUMO_TAG_INDUCTION_LOOP:
207  case SUMO_TAG_E2DETECTOR:
208  case SUMO_TAG_LANE_AREA_DETECTOR:
209  case SUMO_TAG_E3DETECTOR:
210  case SUMO_TAG_ENTRY_EXIT_DETECTOR:
211  case SUMO_TAG_INSTANT_INDUCTION_LOOP:
212  // TAZs
213  case SUMO_TAG_TAZ:
214  // Variable Speed Sign
215  case SUMO_TAG_VSS:
216  // Calibrator
217  case SUMO_TAG_CALIBRATOR:
218  case GNE_TAG_CALIBRATOR_LANE:
219  // Rerouter
220  case SUMO_TAG_REROUTER:
221  // Route probe
222  case SUMO_TAG_ROUTEPROBE:
223  // Vaporizer (deprecated)
224  case SUMO_TAG_VAPORIZER:
225  // wires
226  case SUMO_TAG_TRACTION_SUBSTATION:
227  case SUMO_TAG_OVERHEAD_WIRE_SECTION:
228  case SUMO_TAG_OVERHEAD_WIRE_CLAMP:
229  // Shapes
230  case SUMO_TAG_POLY:
231  case SUMO_TAG_POI:
232  // JuPedSim
233  case GNE_TAG_JPS_WALKABLEAREA:
234  case GNE_TAG_JPS_OBSTACLE:
235  // parse object and all their childrens
236  parseSumoBaseObject(obj);
237  // delete object (and all of their childrens)
238  delete obj;
239  break;
240  default:
241  break;
242  }
243 }
244 
245 
246 void
247 AdditionalHandler::parseSumoBaseObject(CommonXMLStructure::SumoBaseObject* obj) {
248  // switch tag
249  switch (obj->getTag()) {
250  // Stopping Places
251  case SUMO_TAG_BUS_STOP:
252  buildBusStop(obj,
253  obj->getStringAttribute(SUMO_ATTR_ID),
254  obj->getStringAttribute(SUMO_ATTR_LANE),
255  obj->getDoubleAttribute(SUMO_ATTR_STARTPOS),
256  obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
257  obj->getStringAttribute(SUMO_ATTR_NAME),
258  obj->getStringListAttribute(SUMO_ATTR_LINES),
259  obj->getIntAttribute(SUMO_ATTR_PERSON_CAPACITY),
260  obj->getDoubleAttribute(SUMO_ATTR_PARKING_LENGTH),
261  obj->getColorAttribute(SUMO_ATTR_COLOR),
262  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
263  obj->getParameters());
264  break;
265  case SUMO_TAG_TRAIN_STOP:
266  buildTrainStop(obj,
267  obj->getStringAttribute(SUMO_ATTR_ID),
268  obj->getStringAttribute(SUMO_ATTR_LANE),
269  obj->getDoubleAttribute(SUMO_ATTR_STARTPOS),
270  obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
271  obj->getStringAttribute(SUMO_ATTR_NAME),
272  obj->getStringListAttribute(SUMO_ATTR_LINES),
273  obj->getIntAttribute(SUMO_ATTR_PERSON_CAPACITY),
274  obj->getDoubleAttribute(SUMO_ATTR_PARKING_LENGTH),
275  obj->getColorAttribute(SUMO_ATTR_COLOR),
276  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
277  obj->getParameters());
278  break;
279  case SUMO_TAG_ACCESS:
280  buildAccess(obj,
281  obj->getStringAttribute(SUMO_ATTR_LANE),
282  obj->getStringAttribute(SUMO_ATTR_POSITION),
283  obj->getDoubleAttribute(SUMO_ATTR_LENGTH),
284  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
285  obj->getParameters());
286  break;
287  case SUMO_TAG_CONTAINER_STOP:
288  buildContainerStop(obj,
289  obj->getStringAttribute(SUMO_ATTR_ID),
290  obj->getStringAttribute(SUMO_ATTR_LANE),
291  obj->getDoubleAttribute(SUMO_ATTR_STARTPOS),
292  obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
293  obj->getStringAttribute(SUMO_ATTR_NAME),
294  obj->getStringListAttribute(SUMO_ATTR_LINES),
295  obj->getIntAttribute(SUMO_ATTR_CONTAINER_CAPACITY),
296  obj->getDoubleAttribute(SUMO_ATTR_PARKING_LENGTH),
297  obj->getColorAttribute(SUMO_ATTR_COLOR),
298  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
299  obj->getParameters());
300  break;
301  case SUMO_TAG_CHARGING_STATION:
302  buildChargingStation(obj,
303  obj->getStringAttribute(SUMO_ATTR_ID),
304  obj->getStringAttribute(SUMO_ATTR_LANE),
305  obj->getDoubleAttribute(SUMO_ATTR_STARTPOS),
306  obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
307  obj->getStringAttribute(SUMO_ATTR_NAME),
308  obj->getDoubleAttribute(SUMO_ATTR_CHARGINGPOWER),
309  obj->getDoubleAttribute(SUMO_ATTR_EFFICIENCY),
310  obj->getBoolAttribute(SUMO_ATTR_CHARGEINTRANSIT),
311  obj->getTimeAttribute(SUMO_ATTR_CHARGEDELAY),
312  obj->getStringAttribute(SUMO_ATTR_CHARGETYPE),
313  obj->getTimeAttribute(SUMO_ATTR_WAITINGTIME),
314  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
315  obj->getStringAttribute(SUMO_ATTR_PARKING_AREA),
316  obj->getParameters());
317  break;
318  case SUMO_TAG_PARKING_AREA:
319  buildParkingArea(obj,
320  obj->getStringAttribute(SUMO_ATTR_ID),
321  obj->getStringAttribute(SUMO_ATTR_LANE),
322  obj->getDoubleAttribute(SUMO_ATTR_STARTPOS),
323  obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
324  obj->getStringAttribute(SUMO_ATTR_DEPARTPOS),
325  obj->getStringAttribute(SUMO_ATTR_NAME),
326  obj->getStringListAttribute(SUMO_ATTR_ACCEPTED_BADGES),
327  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
328  obj->getIntAttribute(SUMO_ATTR_ROADSIDE_CAPACITY),
329  obj->getBoolAttribute(SUMO_ATTR_ONROAD),
330  obj->getDoubleAttribute(SUMO_ATTR_WIDTH),
331  obj->getDoubleAttribute(SUMO_ATTR_LENGTH),
332  obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
333  obj->getBoolAttribute(SUMO_ATTR_LEFTHAND),
334  obj->getParameters());
335  break;
336  case SUMO_TAG_PARKING_SPACE:
337  buildParkingSpace(obj,
338  obj->getDoubleAttribute(SUMO_ATTR_X),
339  obj->getDoubleAttribute(SUMO_ATTR_Y),
340  obj->getDoubleAttribute(SUMO_ATTR_Z),
341  obj->getStringAttribute(SUMO_ATTR_NAME),
342  obj->getStringAttribute(SUMO_ATTR_WIDTH),
343  obj->getStringAttribute(SUMO_ATTR_LENGTH),
344  obj->getStringAttribute(SUMO_ATTR_ANGLE),
345  obj->getDoubleAttribute(SUMO_ATTR_SLOPE),
346  obj->getParameters());
347  break;
348  // Detectors
349  case SUMO_TAG_E1DETECTOR:
350  case SUMO_TAG_INDUCTION_LOOP:
351  // build E1
352  buildE1Detector(obj,
353  obj->getStringAttribute(SUMO_ATTR_ID),
354  obj->getStringAttribute(SUMO_ATTR_LANE),
355  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
356  obj->getPeriodAttribute(),
357  obj->getStringAttribute(SUMO_ATTR_FILE),
358  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
359  obj->getStringListAttribute(SUMO_ATTR_NEXT_EDGES),
360  obj->getStringAttribute(SUMO_ATTR_DETECT_PERSONS),
361  obj->getStringAttribute(SUMO_ATTR_NAME),
362  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
363  obj->getParameters());
364  break;
365  case SUMO_TAG_E2DETECTOR:
366  case SUMO_TAG_LANE_AREA_DETECTOR:
367  if (obj->hasStringAttribute(SUMO_ATTR_LANE)) {
368  buildSingleLaneDetectorE2(obj,
369  obj->getStringAttribute(SUMO_ATTR_ID),
370  obj->getStringAttribute(SUMO_ATTR_LANE),
371  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
372  obj->getDoubleAttribute(SUMO_ATTR_LENGTH),
373  obj->getPeriodAttribute(),
374  obj->getStringAttribute(SUMO_ATTR_TLID),
375  obj->getStringAttribute(SUMO_ATTR_FILE),
376  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
377  obj->getStringListAttribute(SUMO_ATTR_NEXT_EDGES),
378  obj->getStringAttribute(SUMO_ATTR_DETECT_PERSONS),
379  obj->getStringAttribute(SUMO_ATTR_NAME),
380  obj->getTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD),
381  obj->getDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD),
382  obj->getDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD),
383  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
384  obj->getBoolAttribute(SUMO_ATTR_SHOW_DETECTOR),
385  obj->getParameters());
386  } else {
387  buildMultiLaneDetectorE2(obj,
388  obj->getStringAttribute(SUMO_ATTR_ID),
389  obj->getStringListAttribute(SUMO_ATTR_LANES),
390  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
391  obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
392  obj->getPeriodAttribute(),
393  obj->getStringAttribute(SUMO_ATTR_TLID),
394  obj->getStringAttribute(SUMO_ATTR_FILE),
395  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
396  obj->getStringListAttribute(SUMO_ATTR_NEXT_EDGES),
397  obj->getStringAttribute(SUMO_ATTR_DETECT_PERSONS),
398  obj->getStringAttribute(SUMO_ATTR_NAME),
399  obj->getTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD),
400  obj->getDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD),
401  obj->getDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD),
402  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
403  obj->getBoolAttribute(SUMO_ATTR_SHOW_DETECTOR),
404  obj->getParameters());
405  }
406  break;
407  case SUMO_TAG_E3DETECTOR:
408  case SUMO_TAG_ENTRY_EXIT_DETECTOR:
409  buildDetectorE3(obj,
410  obj->getStringAttribute(SUMO_ATTR_ID),
411  obj->getPositionAttribute(SUMO_ATTR_POSITION),
412  obj->getPeriodAttribute(),
413  obj->getStringAttribute(SUMO_ATTR_FILE),
414  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
415  obj->getStringListAttribute(SUMO_ATTR_NEXT_EDGES),
416  obj->getStringAttribute(SUMO_ATTR_DETECT_PERSONS),
417  obj->getStringAttribute(SUMO_ATTR_NAME),
418  obj->getTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD),
419  obj->getDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD),
420  obj->getBoolAttribute(SUMO_ATTR_OPEN_ENTRY),
421  obj->getBoolAttribute(SUMO_ATTR_EXPECT_ARRIVAL),
422  obj->getParameters());
423  break;
424  case SUMO_TAG_DET_ENTRY:
425  buildDetectorEntry(obj,
426  obj->getStringAttribute(SUMO_ATTR_LANE),
427  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
428  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
429  obj->getParameters());
430  break;
431  case SUMO_TAG_DET_EXIT:
432  buildDetectorExit(obj,
433  obj->getStringAttribute(SUMO_ATTR_LANE),
434  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
435  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
436  obj->getParameters());
437  break;
438  case SUMO_TAG_INSTANT_INDUCTION_LOOP:
439  buildDetectorE1Instant(obj,
440  obj->getStringAttribute(SUMO_ATTR_ID),
441  obj->getStringAttribute(SUMO_ATTR_LANE),
442  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
443  obj->getStringAttribute(SUMO_ATTR_FILE),
444  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
445  obj->getStringListAttribute(SUMO_ATTR_NEXT_EDGES),
446  obj->getStringAttribute(SUMO_ATTR_DETECT_PERSONS),
447  obj->getStringAttribute(SUMO_ATTR_NAME),
448  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
449  obj->getParameters());
450  break;
451  // TAZs
452  case SUMO_TAG_TAZ:
453  buildTAZ(obj,
454  obj->getStringAttribute(SUMO_ATTR_ID),
455  obj->getPositionVectorAttribute(SUMO_ATTR_SHAPE),
456  obj->getPositionAttribute(SUMO_ATTR_CENTER),
457  obj->getBoolAttribute(SUMO_ATTR_FILL),
458  obj->getColorAttribute(SUMO_ATTR_COLOR),
459  obj->getStringListAttribute(SUMO_ATTR_EDGES),
460  obj->getStringAttribute(SUMO_ATTR_NAME),
461  obj->getParameters());
462  break;
463  case SUMO_TAG_TAZSOURCE:
464  buildTAZSource(obj,
465  obj->getStringAttribute(SUMO_ATTR_ID),
466  obj->getDoubleAttribute(SUMO_ATTR_WEIGHT));
467  break;
468  case SUMO_TAG_TAZSINK:
469  buildTAZSink(obj,
470  obj->getStringAttribute(SUMO_ATTR_ID),
471  obj->getDoubleAttribute(SUMO_ATTR_WEIGHT));
472  break;
473  // Variable Speed Sign
474  case SUMO_TAG_VSS:
475  buildVariableSpeedSign(obj,
476  obj->getStringAttribute(SUMO_ATTR_ID),
477  obj->getPositionAttribute(SUMO_ATTR_POSITION),
478  obj->getStringListAttribute(SUMO_ATTR_LANES),
479  obj->getStringAttribute(SUMO_ATTR_NAME),
480  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
481  obj->getParameters());
482  break;
483  case SUMO_TAG_STEP:
484  buildVariableSpeedSignStep(obj,
485  obj->getTimeAttribute(SUMO_ATTR_TIME),
486  obj->getStringAttribute(SUMO_ATTR_SPEED));
487  break;
488  // Calibrator
489  case SUMO_TAG_CALIBRATOR:
490  buildEdgeCalibrator(obj,
491  obj->getStringAttribute(SUMO_ATTR_ID),
492  obj->getStringAttribute(SUMO_ATTR_EDGE),
493  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
494  obj->getStringAttribute(SUMO_ATTR_NAME),
495  obj->getStringAttribute(SUMO_ATTR_OUTPUT),
496  obj->getPeriodAttribute(),
497  obj->getStringAttribute(SUMO_ATTR_ROUTEPROBE),
498  obj->getDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD),
499  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
500  obj->getParameters());
501  break;
502  case GNE_TAG_CALIBRATOR_LANE:
503  buildLaneCalibrator(obj,
504  obj->getStringAttribute(SUMO_ATTR_ID),
505  obj->getStringAttribute(SUMO_ATTR_LANE),
506  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
507  obj->getStringAttribute(SUMO_ATTR_NAME),
508  obj->getStringAttribute(SUMO_ATTR_OUTPUT),
509  obj->getPeriodAttribute(),
510  obj->getStringAttribute(SUMO_ATTR_ROUTEPROBE),
511  obj->getDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD),
512  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
513  obj->getParameters());
514  break;
515  case SUMO_TAG_FLOW:
516  buildCalibratorFlow(obj,
517  obj->getVehicleParameter());
518  break;
519  // Rerouter
520  case SUMO_TAG_REROUTER:
521  buildRerouter(obj,
522  obj->getStringAttribute(SUMO_ATTR_ID),
523  obj->getPositionAttribute(SUMO_ATTR_POSITION),
524  obj->getStringListAttribute(SUMO_ATTR_EDGES),
525  obj->getDoubleAttribute(SUMO_ATTR_PROB),
526  obj->getStringAttribute(SUMO_ATTR_NAME),
527  obj->getBoolAttribute(SUMO_ATTR_OFF),
528  obj->getBoolAttribute(SUMO_ATTR_OPTIONAL),
529  obj->getTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD),
530  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
531  obj->getParameters());
532  break;
533  case SUMO_TAG_CLOSING_LANE_REROUTE:
534  buildClosingLaneReroute(obj,
535  obj->getStringAttribute(SUMO_ATTR_ID),
536  parseVehicleClasses(obj->getStringAttribute(SUMO_ATTR_ALLOW), obj->getStringAttribute(SUMO_ATTR_DISALLOW)));
537  break;
538  case SUMO_TAG_CLOSING_REROUTE:
539  buildClosingReroute(obj,
540  obj->getStringAttribute(SUMO_ATTR_ID),
541  parseVehicleClasses(obj->getStringAttribute(SUMO_ATTR_ALLOW), obj->getStringAttribute(SUMO_ATTR_DISALLOW)));
542  break;
543  case SUMO_TAG_DEST_PROB_REROUTE:
544  buildDestProbReroute(obj,
545  obj->getStringAttribute(SUMO_ATTR_ID),
546  obj->getDoubleAttribute(SUMO_ATTR_PROB));
547  break;
548  case SUMO_TAG_PARKING_AREA_REROUTE:
549  buildParkingAreaReroute(obj,
550  obj->getStringAttribute(SUMO_ATTR_ID),
551  obj->getDoubleAttribute(SUMO_ATTR_PROB),
552  obj->getBoolAttribute(SUMO_ATTR_VISIBLE));
553  break;
554  case SUMO_TAG_ROUTE_PROB_REROUTE:
555  buildRouteProbReroute(obj,
556  obj->getStringAttribute(SUMO_ATTR_ID),
557  obj->getDoubleAttribute(SUMO_ATTR_PROB));
558  break;
559  case SUMO_TAG_INTERVAL:
560  // check if is VSS or a REROUTER interval
561  if (obj->getParentSumoBaseObject()->getTag() == SUMO_TAG_REROUTER) {
562  buildRerouterInterval(obj,
563  obj->getTimeAttribute(SUMO_ATTR_BEGIN),
564  obj->getTimeAttribute(SUMO_ATTR_END));
565  } else {
566  buildVariableSpeedSignStep(obj,
567  obj->getTimeAttribute(SUMO_ATTR_TIME),
568  obj->getStringAttribute(SUMO_ATTR_SPEED));
569  }
570  break;
571  // Route probe
572  case SUMO_TAG_ROUTEPROBE:
573  buildRouteProbe(obj,
574  obj->getStringAttribute(SUMO_ATTR_ID),
575  obj->getStringAttribute(SUMO_ATTR_EDGE),
576  obj->getPeriodAttribute(),
577  obj->getStringAttribute(SUMO_ATTR_NAME),
578  obj->getStringAttribute(SUMO_ATTR_FILE),
579  obj->getTimeAttribute(SUMO_ATTR_BEGIN),
580  obj->getParameters());
581  break;
582  // Vaporizer (deprecated)
583  case SUMO_TAG_VAPORIZER:
584  buildVaporizer(obj,
585  obj->getStringAttribute(SUMO_ATTR_ID),
586  obj->getTimeAttribute(SUMO_ATTR_BEGIN),
587  obj->getTimeAttribute(SUMO_ATTR_END),
588  obj->getStringAttribute(SUMO_ATTR_NAME),
589  obj->getParameters());
590  break;
591  // wire elements
592  case SUMO_TAG_TRACTION_SUBSTATION:
593  buildTractionSubstation(obj,
594  obj->getStringAttribute(SUMO_ATTR_ID),
595  obj->getPositionAttribute(SUMO_ATTR_POSITION),
596  obj->getDoubleAttribute(SUMO_ATTR_VOLTAGE),
597  obj->getDoubleAttribute(SUMO_ATTR_CURRENTLIMIT),
598  obj->getParameters());
599  break;
600  case SUMO_TAG_OVERHEAD_WIRE_SECTION:
601  buildOverheadWire(obj,
602  obj->getStringAttribute(SUMO_ATTR_ID),
603  obj->getStringAttribute(SUMO_ATTR_SUBSTATIONID),
604  obj->getStringListAttribute(SUMO_ATTR_LANES),
605  obj->getDoubleAttribute(SUMO_ATTR_STARTPOS),
606  obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
607  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
608  obj->getStringListAttribute(SUMO_ATTR_OVERHEAD_WIRE_FORBIDDEN),
609  obj->getParameters());
610  break;
611  case SUMO_TAG_OVERHEAD_WIRE_CLAMP:
612  buildOverheadWireClamp(obj,
613  obj->getStringAttribute(SUMO_ATTR_ID),
614  obj->getStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_START),
615  obj->getStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANESTART),
616  obj->getStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_END),
617  obj->getStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANEEND),
618  obj->getParameters());
619  break;
620  // Polygon
621  case SUMO_TAG_POLY:
622  buildPolygon(obj,
623  obj->getStringAttribute(SUMO_ATTR_ID),
624  obj->getStringAttribute(SUMO_ATTR_TYPE),
625  obj->getColorAttribute(SUMO_ATTR_COLOR),
626  obj->getDoubleAttribute(SUMO_ATTR_LAYER),
627  obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
628  obj->getStringAttribute(SUMO_ATTR_IMGFILE),
629  obj->getBoolAttribute(SUMO_ATTR_RELATIVEPATH),
630  obj->getPositionVectorAttribute(SUMO_ATTR_SHAPE),
631  obj->getBoolAttribute(SUMO_ATTR_GEO),
632  obj->getBoolAttribute(SUMO_ATTR_FILL),
633  obj->getDoubleAttribute(SUMO_ATTR_LINEWIDTH),
634  obj->getStringAttribute(SUMO_ATTR_NAME),
635  obj->getParameters());
636  break;
637  // POI
638  case SUMO_TAG_POI:
639  // check if we want to create a POI, POILane or POIGEO
640  if (obj->hasDoubleAttribute(SUMO_ATTR_X)) {
641  // build POI over view
642  buildPOI(obj,
643  obj->getStringAttribute(SUMO_ATTR_ID),
644  obj->getStringAttribute(SUMO_ATTR_TYPE),
645  obj->getColorAttribute(SUMO_ATTR_COLOR),
646  obj->getDoubleAttribute(SUMO_ATTR_X),
647  obj->getDoubleAttribute(SUMO_ATTR_Y),
648  obj->getStringAttribute(SUMO_ATTR_ICON),
649  obj->getDoubleAttribute(SUMO_ATTR_LAYER),
650  obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
651  obj->getStringAttribute(SUMO_ATTR_IMGFILE),
652  obj->getBoolAttribute(SUMO_ATTR_RELATIVEPATH),
653  obj->getDoubleAttribute(SUMO_ATTR_WIDTH),
654  obj->getDoubleAttribute(SUMO_ATTR_HEIGHT),
655  obj->getStringAttribute(SUMO_ATTR_NAME),
656  obj->getParameters());
657  } else if (obj->hasStringAttribute(SUMO_ATTR_LANE)) {
658  // build POI over Lane
659  buildPOILane(obj,
660  obj->getStringAttribute(SUMO_ATTR_ID),
661  obj->getStringAttribute(SUMO_ATTR_TYPE),
662  obj->getColorAttribute(SUMO_ATTR_COLOR),
663  obj->getStringAttribute(SUMO_ATTR_LANE),
664  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
665  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
666  obj->getDoubleAttribute(SUMO_ATTR_POSITION_LAT),
667  obj->getStringAttribute(SUMO_ATTR_ICON),
668  obj->getDoubleAttribute(SUMO_ATTR_LAYER),
669  obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
670  obj->getStringAttribute(SUMO_ATTR_IMGFILE),
671  obj->getBoolAttribute(SUMO_ATTR_RELATIVEPATH),
672  obj->getDoubleAttribute(SUMO_ATTR_WIDTH),
673  obj->getDoubleAttribute(SUMO_ATTR_HEIGHT),
674  obj->getStringAttribute(SUMO_ATTR_NAME),
675  obj->getParameters());
676  } else {
677  // build POIGEO over view
678  buildPOIGeo(obj,
679  obj->getStringAttribute(SUMO_ATTR_ID),
680  obj->getStringAttribute(SUMO_ATTR_TYPE),
681  obj->getColorAttribute(SUMO_ATTR_COLOR),
682  obj->getDoubleAttribute(SUMO_ATTR_LON),
683  obj->getDoubleAttribute(SUMO_ATTR_LAT),
684  obj->getStringAttribute(SUMO_ATTR_ICON),
685  obj->getDoubleAttribute(SUMO_ATTR_LAYER),
686  obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
687  obj->getStringAttribute(SUMO_ATTR_IMGFILE),
688  obj->getBoolAttribute(SUMO_ATTR_RELATIVEPATH),
689  obj->getDoubleAttribute(SUMO_ATTR_WIDTH),
690  obj->getDoubleAttribute(SUMO_ATTR_HEIGHT),
691  obj->getStringAttribute(SUMO_ATTR_NAME),
692  obj->getParameters());
693  }
694  break;
695  // Jps WalkableArea
696  case GNE_TAG_JPS_WALKABLEAREA:
697  buildJpsWalkableArea(obj,
698  obj->getStringAttribute(SUMO_ATTR_ID),
699  obj->getPositionVectorAttribute(SUMO_ATTR_SHAPE),
700  obj->getBoolAttribute(SUMO_ATTR_GEO),
701  obj->getStringAttribute(SUMO_ATTR_NAME),
702  obj->getParameters());
703  break;
704  // Jps Obstacle
705  case GNE_TAG_JPS_OBSTACLE:
706  buildJpsObstacle(obj,
707  obj->getStringAttribute(SUMO_ATTR_ID),
708  obj->getPositionVectorAttribute(SUMO_ATTR_SHAPE),
709  obj->getBoolAttribute(SUMO_ATTR_GEO),
710  obj->getStringAttribute(SUMO_ATTR_NAME),
711  obj->getParameters());
712  break;
713  default:
714  break;
715  }
716  // now iterate over childrens
717  for (const auto& child : obj->getSumoBaseObjectChildren()) {
718  // call this function recursively
719  parseSumoBaseObject(child);
720  }
721 }
722 
723 
724 bool
725 AdditionalHandler::isErrorCreatingElement() const {
726  return myErrorCreatingElement;
727 }
728 
729 
730 void
731 AdditionalHandler::writeError(const std::string& error) {
732  WRITE_ERROR(error);
733  myErrorCreatingElement = true;
734 }
735 
736 
737 void
738 AdditionalHandler::parseBusStopAttributes(const SUMOSAXAttributes& attrs) {
739  // declare Ok Flag
740  bool parsedOk = true;
741  // needed attributes
742  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
743  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
744  // optional attributes
745  const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
746  const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
747  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
748  const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, id.c_str(), parsedOk, std::vector<std::string>());
749  const int personCapacity = attrs.getOpt<int>(SUMO_ATTR_PERSON_CAPACITY, id.c_str(), parsedOk, 6);
750  const double parkingLength = attrs.getOpt<double>(SUMO_ATTR_PARKING_LENGTH, id.c_str(), parsedOk, 0);
751  const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::INVISIBLE);
752  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
753  // continue if flag is ok
754  if (parsedOk) {
755  // set tag
756  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_BUS_STOP);
757  // add all attributes
758  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
759  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
760  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
761  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
762  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
763  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LINES, lines);
764  myCommonXMLStructure.getCurrentSumoBaseObject()->addIntAttribute(SUMO_ATTR_PERSON_CAPACITY, personCapacity);
765  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PARKING_LENGTH, parkingLength);
766  myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
767  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
768  }
769 }
770 
771 
772 void
773 AdditionalHandler::parseTrainStopAttributes(const SUMOSAXAttributes& attrs) {
774  // declare Ok Flag
775  bool parsedOk = true;
776  // needed attributes
777  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
778  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
779  // optional attributes
780  const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
781  const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
782  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
783  const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, id.c_str(), parsedOk, std::vector<std::string>());
784  const int personCapacity = attrs.getOpt<int>(SUMO_ATTR_PERSON_CAPACITY, id.c_str(), parsedOk, 6);
785  const double parkingLength = attrs.getOpt<double>(SUMO_ATTR_PARKING_LENGTH, id.c_str(), parsedOk, 0);
786  const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::INVISIBLE);
787  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
788  // continue if flag is ok
789  if (parsedOk) {
790  // set tag
791  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TRAIN_STOP);
792  // add all attributes
793  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
794  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
795  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
796  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
797  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
798  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LINES, lines);
799  myCommonXMLStructure.getCurrentSumoBaseObject()->addIntAttribute(SUMO_ATTR_PERSON_CAPACITY, personCapacity);
800  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PARKING_LENGTH, parkingLength);
801  myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
802  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
803  }
804 }
805 
806 
807 void
808 AdditionalHandler::parseAccessAttributes(const SUMOSAXAttributes& attrs) {
809  // declare Ok Flag
810  bool parsedOk = true;
811  // needed attributes
812  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, "", parsedOk);
813  const std::string position = attrs.get<std::string>(SUMO_ATTR_POSITION, "", parsedOk);
814  // optional attributes
815  const double length = attrs.getOpt<double>(SUMO_ATTR_LENGTH, "", parsedOk, -1.00); /* in future updates, INVALID_DOUBLE */
816  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, "", parsedOk, false);
817  // check parent
818  checkParent(SUMO_TAG_ACCESS, {SUMO_TAG_BUS_STOP, SUMO_TAG_TRAIN_STOP}, parsedOk);
819  // continue if flag is ok
820  if (parsedOk) {
821  // set tag
822  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ACCESS);
823  // add all attributes
824  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
825  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_POSITION, position);
826  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LENGTH, length);
827  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
828  }
829 }
830 
831 
832 void
833 AdditionalHandler::parseContainerStopAttributes(const SUMOSAXAttributes& attrs) {
834  // declare Ok Flag
835  bool parsedOk = true;
836  // needed attributes
837  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
838  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
839  // optional attributes
840  const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
841  const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
842  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
843  const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, id.c_str(), parsedOk, std::vector<std::string>());
844  const int containerCapacity = attrs.getOpt<int>(SUMO_ATTR_CONTAINER_CAPACITY, id.c_str(), parsedOk, 6);
845  const double parkingLength = attrs.getOpt<double>(SUMO_ATTR_PARKING_LENGTH, id.c_str(), parsedOk, 0);
846  const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::INVISIBLE);
847  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
848  // continue if flag is ok
849  if (parsedOk) {
850  // set tag
851  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CONTAINER_STOP);
852  // add all attributes
853  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
854  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
855  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
856  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
857  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
858  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LINES, lines);
859  myCommonXMLStructure.getCurrentSumoBaseObject()->addIntAttribute(SUMO_ATTR_CONTAINER_CAPACITY, containerCapacity);
860  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PARKING_LENGTH, parkingLength);
861  myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
862  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
863  }
864 }
865 
866 
867 void
868 AdditionalHandler::parseChargingStationAttributes(const SUMOSAXAttributes& attrs) {
869  // declare Ok Flag
870  bool parsedOk = true;
871  // needed attributes
872  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
873  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
874  // optional attributes
875  const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
876  const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
877  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
878  const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, id.c_str(), parsedOk, std::vector<std::string>());
879  const double chargingPower = attrs.getOpt<double>(SUMO_ATTR_CHARGINGPOWER, id.c_str(), parsedOk, 22000);
880  const double efficiency = attrs.getOpt<double>(SUMO_ATTR_EFFICIENCY, id.c_str(), parsedOk, 0.95);
881  const bool chargeInTransit = attrs.getOpt<bool>(SUMO_ATTR_CHARGEINTRANSIT, id.c_str(), parsedOk, 0);
882  const SUMOTime chargeDelay = attrs.getOptSUMOTimeReporting(SUMO_ATTR_CHARGEDELAY, id.c_str(), parsedOk, 0);
883  const std::string chargeType = attrs.getOpt<std::string>(SUMO_ATTR_CHARGETYPE, id.c_str(), parsedOk, "normal");
884  const SUMOTime waitingTime = attrs.getOptSUMOTimeReporting(SUMO_ATTR_WAITINGTIME, id.c_str(), parsedOk, TIME2STEPS(900));
885  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
886  const std::string parkingAreaID = attrs.getOpt<std::string>(SUMO_ATTR_PARKING_AREA, id.c_str(), parsedOk, "");
887 
888  // check charge type
889  if ((chargeType != "normal") && (chargeType != "electric") && (chargeType != "fuel")) {
890  writeError(TLF("Invalid charge type '%' defined in chargingStation '%'.", chargeType, id));
891  parsedOk = false;
892  }
893  // continue if flag is ok
894  if (parsedOk) {
895  // set tag
896  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CHARGING_STATION);
897  // add all attributes
898  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
899  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
900  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
901  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
902  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
903  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LINES, lines);
904  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_CHARGINGPOWER, chargingPower);
905  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_EFFICIENCY, efficiency);
906  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_CHARGEINTRANSIT, chargeInTransit);
907  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_CHARGEDELAY, chargeDelay);
908  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_CHARGETYPE, chargeType);
909  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_WAITINGTIME, waitingTime);
910  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
911  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_PARKING_AREA, parkingAreaID);
912  }
913 }
914 
915 
916 void
917 AdditionalHandler::parseParkingAreaAttributes(const SUMOSAXAttributes& attrs) {
918  // declare Ok Flag
919  bool parsedOk = true;
920  // needed attributes
921  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
922  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
923  // optional attributes
924  const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
925  const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
926  const std::string departPos = attrs.getOpt<std::string>(SUMO_ATTR_DEPARTPOS, id.c_str(), parsedOk, "");
927  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
928  const std::vector<std::string> badges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_ACCEPTED_BADGES, id.c_str(), parsedOk, std::vector<std::string>());
929  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
930  const int roadSideCapacity = attrs.getOpt<int>(SUMO_ATTR_ROADSIDE_CAPACITY, id.c_str(), parsedOk, 0);
931  const bool onRoad = attrs.getOpt<bool>(SUMO_ATTR_ONROAD, id.c_str(), parsedOk, false);
932  const double width = attrs.getOpt<double>(SUMO_ATTR_WIDTH, id.c_str(), parsedOk, 0);
933  const double length = attrs.getOpt<double>(SUMO_ATTR_LENGTH, id.c_str(), parsedOk, 0);
934  const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), parsedOk, 0);
935  const bool lefthand = attrs.getOpt<bool>(SUMO_ATTR_LEFTHAND, id.c_str(), parsedOk, false);
936 
937  // continue if flag is ok
938  if (parsedOk) {
939  // set tag
940  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_PARKING_AREA);
941  // add all attributes
942  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
943  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
944  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
945  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
946  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DEPARTPOS, departPos);
947  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
948  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_ACCEPTED_BADGES, badges);
949  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
950  myCommonXMLStructure.getCurrentSumoBaseObject()->addIntAttribute(SUMO_ATTR_ROADSIDE_CAPACITY, roadSideCapacity);
951  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_ONROAD, onRoad);
952  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_WIDTH, width);
953  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LENGTH, length);
954  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ANGLE, angle);
955  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_LEFTHAND, lefthand);
956  }
957 }
958 
959 
960 void
961 AdditionalHandler::parseParkingSpaceAttributes(const SUMOSAXAttributes& attrs) {
962  // declare Ok Flag
963  bool parsedOk = true;
964  // needed attributes
965  const double x = attrs.get<double>(SUMO_ATTR_X, "", parsedOk);
966  const double y = attrs.get<double>(SUMO_ATTR_Y, "", parsedOk);
967  // optional attributes
968  const double z = attrs.getOpt<double>(SUMO_ATTR_Z, "", parsedOk, 0);
969  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, "", parsedOk, "");
970  const std::string width = attrs.getOpt<std::string>(SUMO_ATTR_WIDTH, "", parsedOk, "");
971  const std::string length = attrs.getOpt<std::string>(SUMO_ATTR_LENGTH, "", parsedOk, "");
972  const std::string angle = attrs.getOpt<std::string>(SUMO_ATTR_ANGLE, "", parsedOk, "");
973  const double slope = attrs.getOpt<double>(SUMO_ATTR_SLOPE, "", parsedOk, 0);
974  // check parent
975  checkParent(SUMO_TAG_PARKING_SPACE, {SUMO_TAG_PARKING_AREA}, parsedOk);
976  // continue if flag is ok
977  if (parsedOk) {
978  // set tag
979  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_PARKING_SPACE);
980  // add all attributes
981  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_X, x);
982  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_Y, y);
983  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_Z, z);
984  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
985  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_WIDTH, width);
986  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LENGTH, length);
987  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ANGLE, angle);
988  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_SLOPE, slope);
989  }
990 }
991 
992 
993 void
994 AdditionalHandler::parseE1Attributes(const SUMOSAXAttributes& attrs) {
995  // declare Ok Flag
996  bool parsedOk = true;
997  // needed attributes
998  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
999  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
1000  const double position = attrs.get<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk);
1001  const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, SUMOTime_MAX_PERIOD);
1002  const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1003  // optional attributes
1004  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1005  const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1006  const std::vector<std::string> nextEdges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_NEXT_EDGES, id.c_str(), parsedOk, std::vector<std::string>());
1007  const std::string detectPersons = attrs.getOpt<std::string>(SUMO_ATTR_DETECT_PERSONS, "", parsedOk);
1008  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1009  // continue if flag is ok
1010  if (parsedOk && checkDetectPersons(SUMO_TAG_E1DETECTOR, id, detectPersons)) {
1011  // set tag
1012  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_E1DETECTOR);
1013  // add all attributes
1014  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1015  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1016  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1017  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1018  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1019  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1020  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1021  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_NEXT_EDGES, nextEdges);
1022  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DETECT_PERSONS, detectPersons);
1023  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1024  }
1025 }
1026 
1027 
1028 void
1029 AdditionalHandler::parseE2Attributes(const SUMOSAXAttributes& attrs) {
1030  // declare Ok Flag
1031  bool parsedOk = true;
1032  const int positionDef = attrs.hasAttribute(SUMO_ATTR_POSITION) ? 1 : 0;
1033  const int endPosDef = attrs.hasAttribute(SUMO_ATTR_ENDPOS) ? 1 : 0;
1034  const int lengthDef = attrs.hasAttribute(SUMO_ATTR_LENGTH) ? 1 : 0;
1035  // check attributes
1036  if (attrs.hasAttribute(SUMO_ATTR_LANE) && ((positionDef + endPosDef + lengthDef) > 2)) {
1037  writeError(TL("'pos', 'endPos' and 'length' cannot be defined together in a single lane area detector."));
1038  } else if (attrs.hasAttribute(SUMO_ATTR_LANE) && ((positionDef + endPosDef + lengthDef) < 2)) {
1039  writeError(TL("A single lane area detector requires two parameters of those 'pos', 'endPos' and 'length'."));
1040  } else {
1041  // needed attributes
1042  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1043  const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1044  // special attributes
1045  const std::string laneId = attrs.getOpt<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk, "");
1046  const std::vector<std::string> laneIds = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LANES, id.c_str(), parsedOk, std::vector<std::string>());
1047  const double position = attrs.getOpt<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, 0);
1048  const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, 0);
1049  const double length = attrs.getOpt<double>(SUMO_ATTR_LENGTH, id.c_str(), parsedOk, 0);
1050  // optional attributes
1051  const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, SUMOTime_MAX_PERIOD);
1052  const std::string trafficLight = attrs.getOpt<std::string>(SUMO_ATTR_TLID, id.c_str(), parsedOk, "");
1053  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1054  const SUMOTime haltingTimeThreshold = attrs.getOptSUMOTimeReporting(SUMO_ATTR_HALTING_TIME_THRESHOLD, id.c_str(), parsedOk, TIME2STEPS(1));
1055  const double haltingSpeedThreshold = attrs.getOpt<double>(SUMO_ATTR_HALTING_SPEED_THRESHOLD, id.c_str(), parsedOk, 1.39);
1056  const double jamDistThreshold = attrs.getOpt<double>(SUMO_ATTR_JAM_DIST_THRESHOLD, id.c_str(), parsedOk, 10);
1057  const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1058  const std::vector<std::string> nextEdges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_NEXT_EDGES, id.c_str(), parsedOk, std::vector<std::string>());
1059  const std::string detectPersons = attrs.getOpt<std::string>(SUMO_ATTR_DETECT_PERSONS, "", parsedOk);
1060  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1061  const bool show = attrs.getOpt<bool>(SUMO_ATTR_SHOW_DETECTOR, id.c_str(), parsedOk, true);
1062  // continue if flag is ok
1063  if (parsedOk && checkDetectPersons(SUMO_TAG_E2DETECTOR, id, detectPersons)) {
1064  // set tag
1065  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_E2DETECTOR);
1066  // add attributes depending of Lane/Lanes
1067  if (attrs.hasAttribute(SUMO_ATTR_LANE)) {
1068  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1069  if (positionDef == 0) {
1070  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, endPos - length);
1071  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LENGTH, length);
1072  } else if (endPosDef == 0) {
1073  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1074  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LENGTH, length);
1075  } else if (lengthDef == 0) {
1076  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1077  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LENGTH, endPos - position);
1078  }
1079  } else {
1080  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LANES, laneIds);
1081  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1082  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
1083  }
1084  // add all attributes
1085  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1086  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1087  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_TLID, trafficLight);
1088  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1089  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1090  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_NEXT_EDGES, nextEdges);
1091  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DETECT_PERSONS, detectPersons);
1092  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1093  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD, haltingTimeThreshold);
1094  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD, haltingSpeedThreshold);
1095  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD, jamDistThreshold);
1096  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1097  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_SHOW_DETECTOR, show);
1098  }
1099  }
1100 }
1101 
1102 
1103 void
1104 AdditionalHandler::parseE3Attributes(const SUMOSAXAttributes& attrs) {
1105  // declare Ok Flag
1106  bool parsedOk = true;
1107  // needed attributes
1108  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1109  const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1110  const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, SUMOTime_MAX_PERIOD);
1111  // optional attributes
1112  const Position pos = attrs.getOpt<Position>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, Position());
1113  const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1114  const std::vector<std::string> nextEdges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_NEXT_EDGES, id.c_str(), parsedOk, std::vector<std::string>());
1115  const std::string detectPersons = attrs.getOpt<std::string>(SUMO_ATTR_DETECT_PERSONS, "", parsedOk);
1116  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1117  const SUMOTime haltingTimeThreshold = attrs.getOptSUMOTimeReporting(SUMO_ATTR_HALTING_TIME_THRESHOLD, id.c_str(), parsedOk, TIME2STEPS(1));
1118  const double haltingSpeedThreshold = attrs.getOpt<double>(SUMO_ATTR_HALTING_SPEED_THRESHOLD, id.c_str(), parsedOk, 1.39);
1119  const bool openEntry = attrs.getOpt<bool>(SUMO_ATTR_OPEN_ENTRY, id.c_str(), parsedOk, false);
1120  const bool expectedArrival = attrs.getOpt<bool>(SUMO_ATTR_EXPECT_ARRIVAL, id.c_str(), parsedOk, false);
1121  // continue if flag is ok
1122  if (parsedOk && checkDetectPersons(SUMO_TAG_E3DETECTOR, id, detectPersons)) {
1123  // set tag
1124  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_E3DETECTOR);
1125  // add all attributes
1126  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1127  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1128  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1129  myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_POSITION, pos);
1130  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1131  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_NEXT_EDGES, nextEdges);
1132  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DETECT_PERSONS, detectPersons);
1133  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1134  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD, haltingTimeThreshold);
1135  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD, haltingSpeedThreshold);
1136  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_OPEN_ENTRY, openEntry);
1137  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_EXPECT_ARRIVAL, expectedArrival);
1138  }
1139 }
1140 
1141 
1142 void
1143 AdditionalHandler::parseEntryAttributes(const SUMOSAXAttributes& attrs) {
1144  // declare Ok Flag
1145  bool parsedOk = true;
1146  // needed attributes
1147  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, "", parsedOk);
1148  const double position = attrs.get<double>(SUMO_ATTR_POSITION, "", parsedOk);
1149  // optional attributes
1150  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, "", parsedOk, false);
1151  // check parent
1152  checkParent(SUMO_TAG_DET_ENTRY, {SUMO_TAG_E3DETECTOR}, parsedOk);
1153  // continue if flag is ok
1154  if (parsedOk) {
1155  // set tag
1156  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_DET_ENTRY);
1157  // add all attributes
1158  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1159  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1160  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1161  }
1162 }
1163 
1164 
1165 void
1166 AdditionalHandler::parseExitAttributes(const SUMOSAXAttributes& attrs) {
1167  // declare Ok Flag
1168  bool parsedOk = true;
1169  // needed attributes
1170  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, "", parsedOk);
1171  const double position = attrs.get<double>(SUMO_ATTR_POSITION, "", parsedOk);
1172  // optional attributes
1173  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, "", parsedOk, false);
1174  // check parent
1175  checkParent(SUMO_TAG_DET_EXIT, {SUMO_TAG_E3DETECTOR}, parsedOk);
1176  // continue if flag is ok
1177  if (parsedOk) {
1178  // set tag
1179  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_DET_EXIT);
1180  // add all attributes
1181  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1182  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1183  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1184  }
1185 }
1186 
1187 
1188 void
1189 AdditionalHandler::parseE1InstantAttributes(const SUMOSAXAttributes& attrs) {
1190  // declare Ok Flag
1191  bool parsedOk = true;
1192  // needed attributes
1193  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1194  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
1195  const double position = attrs.get<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk);
1196  const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1197  // optional attributes
1198  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1199  const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1200  const std::vector<std::string> nextEdges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_NEXT_EDGES, id.c_str(), parsedOk, std::vector<std::string>());
1201  const std::string detectPersons = attrs.getOpt<std::string>(SUMO_ATTR_DETECT_PERSONS, "", parsedOk);
1202  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1203  // continue if flag is ok
1204  if (parsedOk && checkDetectPersons(SUMO_TAG_INSTANT_INDUCTION_LOOP, id, detectPersons)) {
1205  // set tag
1206  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_INSTANT_INDUCTION_LOOP);
1207  // add all attributes
1208  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1209  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1210  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1211  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1212  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1213  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_NEXT_EDGES, nextEdges);
1214  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DETECT_PERSONS, detectPersons);
1215  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1216  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1217  }
1218 }
1219 
1220 
1221 void
1222 AdditionalHandler::parseTAZAttributes(const SUMOSAXAttributes& attrs) {
1223  // declare Ok Flag
1224  bool parsedOk = true;
1225  // needed attributes
1226  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1227  // optional attributes
1228  const PositionVector shape = attrs.getOpt<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), parsedOk, PositionVector());
1229  const Position center = attrs.getOpt<Position>(SUMO_ATTR_CENTER, id.c_str(), parsedOk, shape.size() > 0 ? shape.getCentroid() : Position::INVALID);
1230  const bool fill = attrs.getOpt<bool>(SUMO_ATTR_FILL, id.c_str(), parsedOk, false);
1231  const std::vector<std::string> edges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EDGES, id.c_str(), parsedOk, std::vector<std::string>());
1232  const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::RED);
1233  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1234  // continue if flag is ok
1235  if (parsedOk) {
1236  // set tag
1237  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TAZ);
1238  // add all attributes
1239  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1240  myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionVectorAttribute(SUMO_ATTR_SHAPE, shape);
1241  myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_CENTER, center);
1242  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FILL, fill);
1243  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_EDGES, edges);
1244  myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
1245  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1246  }
1247 }
1248 
1249 
1250 void
1251 AdditionalHandler::parseTAZSourceAttributes(const SUMOSAXAttributes& attrs) {
1252  // declare Ok Flag
1253  bool parsedOk = true;
1254  // needed attributes
1255  const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1256  const double weight = attrs.get<double>(SUMO_ATTR_WEIGHT, edgeID.c_str(), parsedOk);
1257  // check parent
1258  checkParent(SUMO_TAG_TAZSOURCE, {SUMO_TAG_TAZ}, parsedOk);
1259  // continue if flag is ok
1260  if (parsedOk) {
1261  // set tag
1262  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TAZSOURCE);
1263  // add all attributes
1264  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, edgeID);
1265  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_WEIGHT, weight);
1266  }
1267 }
1268 
1269 
1270 void
1271 AdditionalHandler::parseTAZSinkAttributes(const SUMOSAXAttributes& attrs) {
1272  // declare Ok Flag
1273  bool parsedOk = true;
1274  // needed attributes
1275  const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1276  const double weight = attrs.get<double>(SUMO_ATTR_WEIGHT, edgeID.c_str(), parsedOk);
1277  // check parent
1278  checkParent(SUMO_TAG_TAZSINK, {SUMO_TAG_TAZ}, parsedOk);
1279  // continue if flag is ok
1280  if (parsedOk) {
1281  // set tag
1282  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TAZSINK);
1283  // add all attributes
1284  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, edgeID);
1285  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_WEIGHT, weight);
1286  }
1287 }
1288 
1289 
1290 void
1291 AdditionalHandler::parseVariableSpeedSignAttributes(const SUMOSAXAttributes& attrs) {
1292  // declare Ok Flag
1293  bool parsedOk = true;
1294  // needed attributes
1295  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1296  const std::vector<std::string> lanes = attrs.get<std::vector<std::string> >(SUMO_ATTR_LANES, id.c_str(), parsedOk);
1297  // optional attributes
1298  const Position pos = attrs.getOpt<Position>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, Position());
1299  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1300  const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1301  // continue if flag is ok
1302  if (parsedOk) {
1303  // set tag
1304  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_VSS);
1305  // add all attributes
1306  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1307  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LANES, lanes);
1308  myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_POSITION, pos);
1309  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1310  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1311  }
1312 }
1313 
1314 
1315 void
1316 AdditionalHandler::parseVariableSpeedSignStepAttributes(const SUMOSAXAttributes& attrs) {
1317  // declare Ok Flag
1318  bool parsedOk = true;
1319  // needed attributes
1320  const SUMOTime time = attrs.getSUMOTimeReporting(SUMO_ATTR_TIME, "", parsedOk);
1321  // optional attributes
1322  const std::string speed = attrs.getOpt<std::string>(SUMO_ATTR_SPEED, "", parsedOk, "");
1323  // check parent
1324  checkParent(SUMO_TAG_STEP, {SUMO_TAG_VSS}, parsedOk);
1325  // continue if flag is ok
1326  if (parsedOk) {
1327  // set tag
1328  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_STEP);
1329  // add all attributes
1330  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_TIME, time);
1331  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_SPEED, speed);
1332  }
1333 }
1334 
1335 
1336 void
1337 AdditionalHandler::parseCalibratorAttributes(const SUMOSAXAttributes& attrs) {
1338  // declare Ok Flag
1339  bool parsedOk = true;
1340  // check that frecuency and trafficLight aren't defined together
1341  if ((attrs.hasAttribute(SUMO_ATTR_EDGE) && attrs.hasAttribute(SUMO_ATTR_LANE)) ||
1342  (!attrs.hasAttribute(SUMO_ATTR_EDGE) && !attrs.hasAttribute(SUMO_ATTR_LANE))) {
1343  writeError(TL("Calibrators need either an edge or a lane"));
1344  parsedOk = false;
1345  }
1346  // needed attributes
1347  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1348  const double pos = attrs.get<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk);
1349  // special attributes
1350  const std::string edge = attrs.getOpt<std::string>(SUMO_ATTR_EDGE, id.c_str(), parsedOk, "");
1351  const std::string lane = attrs.getOpt<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk, "");
1352  // optional attributes
1353  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1354  const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, DELTA_T);
1355  const std::string routeProbe = attrs.getOpt<std::string>(SUMO_ATTR_ROUTEPROBE, id.c_str(), parsedOk, "");
1356  const double jamThreshold = attrs.getOpt<double>(SUMO_ATTR_JAM_DIST_THRESHOLD, id.c_str(), parsedOk, 0.5);
1357  const std::string output = attrs.getOpt<std::string>(SUMO_ATTR_OUTPUT, id.c_str(), parsedOk, "");
1358  const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1359  // continue if flag is ok
1360  if (parsedOk) {
1361  // set tag depending of edge/lane
1362  if (attrs.hasAttribute(SUMO_ATTR_EDGE)) {
1363  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CALIBRATOR);
1364  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_EDGE, edge);
1365  } else {
1366  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(GNE_TAG_CALIBRATOR_LANE);
1367  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, lane);
1368  }
1369  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1370  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, pos);
1371  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1372  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1373  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ROUTEPROBE, routeProbe);
1374  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD, jamThreshold);
1375  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OUTPUT, output);
1376  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1377  }
1378 }
1379 
1380 
1381 void
1382 AdditionalHandler::parseCalibratorFlowAttributes(const SUMOSAXAttributes& attrs) {
1383  // declare Ok Flag
1384  bool parsedOk = true;
1385  // check parent
1386  if (myCommonXMLStructure.getCurrentSumoBaseObject()->getParentSumoBaseObject() &&
1387  myCommonXMLStructure.getCurrentSumoBaseObject()->getParentSumoBaseObject()->getTag() != SUMO_TAG_ROOTFILE) {
1388  // check that frecuency and trafficLight aren't defined together
1389  if (!attrs.hasAttribute(SUMO_ATTR_TYPE) && !attrs.hasAttribute(SUMO_ATTR_VEHSPERHOUR) && !attrs.hasAttribute(SUMO_ATTR_SPEED)) {
1390  writeError(TL("CalibratorFlows need either the attribute vehsPerHour or speed or type (or any combination of these)"));
1391  }
1392  // first parse flow
1393  SUMOVehicleParameter* flowParameter = SUMOVehicleParserHelper::parseVehicleAttributes(SUMO_TAG_FLOW, attrs, false, true, true);
1394  if (flowParameter) {
1395  // set VPH and speed
1396  if (attrs.hasAttribute(SUMO_ATTR_VEHSPERHOUR)) {
1397  flowParameter->repetitionOffset = TIME2STEPS(3600. / attrs.get<double>(SUMO_ATTR_VEHSPERHOUR, "", parsedOk));
1398  flowParameter->parametersSet |= VEHPARS_VPH_SET;
1399  }
1400  if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
1401  flowParameter->calibratorSpeed = attrs.get<double>(SUMO_ATTR_SPEED, "", parsedOk);
1402  flowParameter->parametersSet |= VEHPARS_CALIBRATORSPEED_SET;
1403  }
1404  // set begin and end
1405  flowParameter->depart = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, "", parsedOk);
1406  flowParameter->repetitionEnd = attrs.getSUMOTimeReporting(SUMO_ATTR_END, "", parsedOk);
1407  if (parsedOk) {
1408  // set tag
1409  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_FLOW);
1410  // set vehicle parameters
1411  myCommonXMLStructure.getCurrentSumoBaseObject()->setVehicleParameter(flowParameter);
1412  // delete flow parameter (because in XMLStructure we have a copy)
1413  delete flowParameter;
1414  }
1415  }
1416  }
1417 }
1418 
1419 
1420 void
1421 AdditionalHandler::parseRerouterAttributes(const SUMOSAXAttributes& attrs) {
1422  // declare Ok Flag
1423  bool parsedOk = true;
1424  // needed attributes
1425  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1426  const std::vector<std::string> edges = attrs.get<std::vector<std::string> >(SUMO_ATTR_EDGES, id.c_str(), parsedOk);
1427  // optional attributes
1428  const Position pos = attrs.getOpt<Position>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, Position::INVALID);
1429  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1430  const double probability = attrs.getOpt<double>(SUMO_ATTR_PROB, id.c_str(), parsedOk, 1);
1431  SUMOTime timeThreshold = attrs.getOptSUMOTimeReporting(SUMO_ATTR_HALTING_TIME_THRESHOLD, id.c_str(), parsedOk, 0);
1432  const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1433  const bool off = attrs.getOpt<bool>(SUMO_ATTR_OFF, id.c_str(), parsedOk, false);
1434  const bool optional = attrs.getOpt<bool>(SUMO_ATTR_OPTIONAL, id.c_str(), parsedOk, false);
1435  // continue if flag is ok
1436  if (parsedOk) {
1437  // set tag
1438  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_REROUTER);
1439  // add all attributes
1440  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1441  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_EDGES, edges);
1442  myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_POSITION, pos);
1443  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1444  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PROB, probability);
1445  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD, timeThreshold);
1446  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1447  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_OFF, off);
1448  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_OPTIONAL, optional);
1449  }
1450 }
1451 
1452 
1453 void
1454 AdditionalHandler::parseRerouterIntervalAttributes(const SUMOSAXAttributes& attrs) {
1455  // declare Ok Flag
1456  bool parsedOk = true;
1457  // needed attributes
1458  const SUMOTime begin = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, "", parsedOk);
1459  const SUMOTime end = attrs.getSUMOTimeReporting(SUMO_ATTR_END, "", parsedOk);
1460  // check parent
1461  checkParent(SUMO_TAG_INTERVAL, {SUMO_TAG_REROUTER}, parsedOk);
1462  // continue if flag is ok
1463  if (parsedOk) {
1464  // set tag
1465  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_INTERVAL);
1466  // add all attributes
1467  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_BEGIN, begin);
1468  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_END, end);
1469  }
1470 }
1471 
1472 
1473 void
1474 AdditionalHandler::parseClosingLaneRerouteAttributes(const SUMOSAXAttributes& attrs) {
1475  // declare Ok Flag
1476  bool parsedOk = true;
1477  // needed attributes
1478  const std::string laneID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1479  // optional attributes
1480  const std::string disallow = attrs.getOpt<std::string>(SUMO_ATTR_DISALLOW, "", parsedOk, "");
1481  const std::string allow = attrs.getOpt<std::string>(SUMO_ATTR_ALLOW, "", parsedOk, !disallow.size() ? "authority" : "");
1482  // check parent
1483  checkParent(SUMO_TAG_CLOSING_LANE_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1484  // continue if flag is ok
1485  if (parsedOk) {
1486  // set tag
1487  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CLOSING_LANE_REROUTE);
1488  // add all attributes
1489  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, laneID);
1490  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ALLOW, allow);
1491  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DISALLOW, disallow);
1492  }
1493 }
1494 
1495 
1496 void
1497 AdditionalHandler::parseClosingRerouteAttributes(const SUMOSAXAttributes& attrs) {
1498  // declare Ok Flag
1499  bool parsedOk = true;
1500  // needed attributes
1501  const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1502  // optional attributes
1503  const std::string disallow = attrs.getOpt<std::string>(SUMO_ATTR_DISALLOW, "", parsedOk, "");
1504  const std::string allow = attrs.getOpt<std::string>(SUMO_ATTR_ALLOW, "", parsedOk, !disallow.size() ? "authority" : "");
1505  // check parent
1506  checkParent(SUMO_TAG_CLOSING_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1507  // continue if flag is ok
1508  if (parsedOk) {
1509  // set tag
1510  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CLOSING_REROUTE);
1511  // add all attributes
1512  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, edgeID);
1513  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ALLOW, allow);
1514  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DISALLOW, disallow);
1515  }
1516 }
1517 
1518 
1519 void
1520 AdditionalHandler::parseDestProbRerouteAttributes(const SUMOSAXAttributes& attrs) {
1521  // declare Ok Flag
1522  bool parsedOk = true;
1523  // needed attributes
1524  const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1525  const double probability = attrs.getOpt<double>(SUMO_ATTR_PROB, "", parsedOk, 1);
1526  // check parent
1527  checkParent(SUMO_TAG_DEST_PROB_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1528  // continue if flag is ok
1529  if (parsedOk) {
1530  if (probability < 0) {
1531  writeError(TLF("Probability of % must be equal or greater than 0", toString(SUMO_TAG_DEST_PROB_REROUTE)));
1532  } else {
1533  // set tag
1534  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_DEST_PROB_REROUTE);
1535  // add all attributes
1536  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, edgeID);
1537  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PROB, probability);
1538  }
1539  }
1540 }
1541 
1542 
1543 void
1544 AdditionalHandler::parseParkingAreaRerouteAttributes(const SUMOSAXAttributes& attrs) {
1545  // declare Ok Flag
1546  bool parsedOk = true;
1547  // needed attributes
1548  const std::string parkingAreaID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1549  const double probability = attrs.getOpt<double>(SUMO_ATTR_PROB, "", parsedOk, 1);
1550  // optional attributes
1551  const bool visible = attrs.getOpt<bool>(SUMO_ATTR_VISIBLE, "", parsedOk, false);
1552  // check parent
1553  checkParent(SUMO_TAG_PARKING_AREA_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1554  // continue if flag is ok
1555  if (parsedOk) {
1556  if (probability < 0) {
1557  writeError(TLF("Probability of % must be equal or greater than 0", toString(SUMO_TAG_PARKING_AREA_REROUTE)));
1558  } else {
1559  // set tag
1560  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_PARKING_AREA_REROUTE);
1561  // add all attributes
1562  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, parkingAreaID);
1563  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PROB, probability);
1564  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_VISIBLE, visible);
1565  }
1566  }
1567 }
1568 
1569 
1570 void
1571 AdditionalHandler::parseRouteProbRerouteAttributes(const SUMOSAXAttributes& attrs) {
1572  // declare Ok Flag
1573  bool parsedOk = true;
1574  // needed attributes
1575  const std::string routeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1576  const double probability = attrs.getOpt<double>(SUMO_ATTR_PROB, "", parsedOk, 1);
1577  // check parent
1578  checkParent(SUMO_TAG_ROUTE_PROB_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1579  // continue if flag is ok
1580  if (parsedOk) {
1581  if (probability < 0) {
1582  writeError(TLF("Probability of % must be equal or greater than 0", toString(SUMO_TAG_ROUTE_PROB_REROUTE)));
1583  } else {
1584  // set tag
1585  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ROUTE_PROB_REROUTE);
1586  // add all attributes
1587  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, routeID);
1588  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PROB, probability);
1589  }
1590  }
1591 }
1592 
1593 
1594 void
1595 AdditionalHandler::parseRouteProbeAttributes(const SUMOSAXAttributes& attrs) {
1596  // declare Ok Flag
1597  bool parsedOk = true;
1598  // needed attributes
1599  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1600  const std::string edge = attrs.get<std::string>(SUMO_ATTR_EDGE, id.c_str(), parsedOk);
1601  const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1602  const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, SUMOTime_MAX_PERIOD);
1603  const SUMOTime begin = attrs.getOptSUMOTimeReporting(SUMO_ATTR_BEGIN, id.c_str(), parsedOk, -1);
1604  // optional attributes
1605  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1606  // continue if flag is ok
1607  if (parsedOk) {
1608  // set tag
1609  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ROUTEPROBE);
1610  // add all attributes
1611  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1612  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_EDGE, edge);
1613  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1614  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1615  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1616  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_BEGIN, begin);
1617  }
1618 }
1619 
1620 
1621 void
1622 AdditionalHandler::parseVaporizerAttributes(const SUMOSAXAttributes& attrs) {
1623  // declare Ok Flag
1624  bool parsedOk = true;
1625  // needed attributes
1626  const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1627  SUMOTime begin = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, nullptr, parsedOk);
1628  SUMOTime end = attrs.getSUMOTimeReporting(SUMO_ATTR_END, nullptr, parsedOk);
1629  // optional attributes
1630  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, edgeID.c_str(), parsedOk, "");
1631  // continue if flag is ok
1632  if (parsedOk) {
1633  // set tag
1634  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_VAPORIZER);
1635  // add all attributes
1636  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, edgeID);
1637  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_BEGIN, begin);
1638  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_END, end);
1639  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1640  }
1641 }
1642 
1643 
1644 void
1645 AdditionalHandler::parseTractionSubstation(const SUMOSAXAttributes& attrs) {
1646  // declare Ok Flag
1647  bool parsedOk = true;
1648  // needed attributes
1649  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1650  // optional attributes
1651  const Position pos = attrs.getOpt<Position>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, Position::INVALID);
1652  const double voltage = attrs.getOpt<double>(SUMO_ATTR_VOLTAGE, id.c_str(), parsedOk, 600);
1653  const double currentLimit = attrs.getOpt<double>(SUMO_ATTR_CURRENTLIMIT, id.c_str(), parsedOk, 400);
1654  // continue if flag is ok
1655  if (parsedOk) {
1656  // set tag
1657  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TRACTION_SUBSTATION);
1658  // add all attributes
1659  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1660  myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_POSITION, pos);
1661  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_VOLTAGE, voltage);
1662  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_CURRENTLIMIT, currentLimit);
1663  }
1664 }
1665 
1666 
1667 void
1668 AdditionalHandler::parseOverheadWire(const SUMOSAXAttributes& attrs) {
1669  // declare Ok Flag
1670  bool parsedOk = true;
1671  // needed attributes
1672  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1673  const std::string substationID = attrs.get<std::string>(SUMO_ATTR_SUBSTATIONID, id.c_str(), parsedOk);
1674  const std::vector<std::string> laneIDs = attrs.get<std::vector<std::string> >(SUMO_ATTR_LANES, id.c_str(), parsedOk);
1675  // optional attributes
1676  const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, 0);
1677  const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
1678  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1679  const std::vector<std::string> forbiddenInnerLanes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_OVERHEAD_WIRE_FORBIDDEN, "", parsedOk);
1680  // continue if flag is ok
1681  if (parsedOk) {
1682  // set tag
1683  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_OVERHEAD_WIRE_SECTION);
1684  // add all attributes
1685  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1686  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_SUBSTATIONID, substationID);
1687  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LANES, laneIDs);
1688  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
1689  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
1690  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1691  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_OVERHEAD_WIRE_FORBIDDEN, forbiddenInnerLanes);
1692  }
1693 }
1694 
1695 
1696 void
1697 AdditionalHandler::parseOverheadWireClamp(const SUMOSAXAttributes& attrs) {
1698  // declare Ok Flag
1699  bool parsedOk = true;
1700  // needed attributes
1701  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1702  const std::string substationId = attrs.get<std::string>(SUMO_ATTR_SUBSTATIONID, id.c_str(), parsedOk);
1703  const std::string wireClampStart = attrs.get<std::string>(SUMO_ATTR_OVERHEAD_WIRECLAMP_START, id.c_str(), parsedOk);
1704  const std::string wireClampLaneStart = attrs.get<std::string>(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANESTART, id.c_str(), parsedOk);
1705  const std::string wireClampEnd = attrs.get<std::string>(SUMO_ATTR_OVERHEAD_WIRECLAMP_END, id.c_str(), parsedOk);
1706  const std::string wireClampLaneEnd = attrs.get<std::string>(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANEEND, id.c_str(), parsedOk);
1707  // continue if flag is ok
1708  if (parsedOk) {
1709  // set tag
1710  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_OVERHEAD_WIRE_CLAMP);
1711  // add all attributes
1712  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1713  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_SUBSTATIONID, substationId);
1714  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_START, wireClampStart);
1715  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANESTART, wireClampLaneStart);
1716  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_END, wireClampEnd);
1717  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANEEND, wireClampLaneEnd);
1718  }
1719 }
1720 
1721 
1722 void
1723 AdditionalHandler::parsePolyAttributes(const SUMOSAXAttributes& attrs) {
1724  // declare Ok Flag
1725  bool parsedOk = true;
1726  // needed attributes
1727  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1728  const PositionVector shapeStr = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), parsedOk);
1729  // optional attributes
1730  const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::RED);
1731  const bool geo = attrs.getOpt<bool>(SUMO_ATTR_GEO, id.c_str(), parsedOk, false);
1732  const bool fill = attrs.getOpt<bool>(SUMO_ATTR_FILL, id.c_str(), parsedOk, false);
1733  const double lineWidth = attrs.getOpt<double>(SUMO_ATTR_LINEWIDTH, id.c_str(), parsedOk, Shape::DEFAULT_LINEWIDTH);
1734  const double layer = attrs.getOpt<double>(SUMO_ATTR_LAYER, id.c_str(), parsedOk, Shape::DEFAULT_LAYER);
1735  const std::string type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, id.c_str(), parsedOk, Shape::DEFAULT_TYPE);
1736  const std::string imgFile = attrs.getOpt<std::string>(SUMO_ATTR_IMGFILE, id.c_str(), parsedOk, Shape::DEFAULT_IMG_FILE);
1737  const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), parsedOk, Shape::DEFAULT_ANGLE);
1738  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1739  const bool relativePath = attrs.getOpt<bool>(SUMO_ATTR_RELATIVEPATH, id.c_str(), parsedOk, Shape::DEFAULT_RELATIVEPATH);
1740  // continue if flag is ok
1741  if (parsedOk) {
1742  // set tag
1743  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_POLY);
1744  // add all attributes
1745  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1746  myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionVectorAttribute(SUMO_ATTR_SHAPE, shapeStr);
1747  myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
1748  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_GEO, geo);
1749  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FILL, fill);
1750  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LINEWIDTH, lineWidth);
1751  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LAYER, layer);
1752  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_TYPE, type);
1753  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_IMGFILE, imgFile);
1754  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ANGLE, angle);
1755  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1756  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_RELATIVEPATH, relativePath);
1757  }
1758 }
1759 
1760 
1761 void
1762 AdditionalHandler::parsePOIAttributes(const SUMOSAXAttributes& attrs) {
1763  // declare Ok Flag
1764  bool parsedOk = true;
1765  // check that x and y are defined together
1766  if ((attrs.hasAttribute(SUMO_ATTR_X) && !attrs.hasAttribute(SUMO_ATTR_Y)) ||
1767  (!attrs.hasAttribute(SUMO_ATTR_X) && attrs.hasAttribute(SUMO_ATTR_Y))) {
1768  writeError(TL("X and Y must be be defined together in POIs"));
1769  parsedOk = false;
1770  }
1771  // check that lane and pos are defined together
1772  if ((attrs.hasAttribute(SUMO_ATTR_LANE) && !attrs.hasAttribute(SUMO_ATTR_POSITION)) ||
1773  (!attrs.hasAttribute(SUMO_ATTR_LANE) && attrs.hasAttribute(SUMO_ATTR_POSITION))) {
1774  writeError(TL("lane and position must be defined together in POIs"));
1775  parsedOk = false;
1776  }
1777  // check that lon and lat are defined together
1778  if ((attrs.hasAttribute(SUMO_ATTR_LON) && !attrs.hasAttribute(SUMO_ATTR_LAT)) ||
1779  (!attrs.hasAttribute(SUMO_ATTR_LON) && attrs.hasAttribute(SUMO_ATTR_LAT))) {
1780  writeError(TL("lon and lat must be be defined together in POIs"));
1781  parsedOk = false;
1782  }
1783  // needed attributes
1784  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1785  // special attributes
1786  const double x = attrs.getOpt<double>(SUMO_ATTR_X, id.c_str(), parsedOk, 0);
1787  const double y = attrs.getOpt<double>(SUMO_ATTR_Y, id.c_str(), parsedOk, 0);
1788  const std::string lane = attrs.getOpt<std::string>(SUMO_ATTR_LANE, "", parsedOk, "");
1789  const double pos = attrs.getOpt<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, 0);
1790  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1791  const double posLat = attrs.getOpt<double>(SUMO_ATTR_POSITION_LAT, id.c_str(), parsedOk, 0);
1792  const double lon = attrs.getOpt<double>(SUMO_ATTR_LON, id.c_str(), parsedOk, 0);
1793  const double lat = attrs.getOpt<double>(SUMO_ATTR_LAT, id.c_str(), parsedOk, 0);
1794  // optional attributes
1795  const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::RED);
1796  const std::string type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, "", parsedOk, Shape::DEFAULT_TYPE);
1797  std::string icon = attrs.getOpt<std::string>(SUMO_ATTR_ICON, "", parsedOk, SUMOXMLDefinitions::POIIcons.getString(POIIcon::NONE));
1798  const double layer = attrs.getOpt<double>(SUMO_ATTR_LAYER, id.c_str(), parsedOk, Shape::DEFAULT_LAYER_POI);
1799  const std::string imgFile = attrs.getOpt<std::string>(SUMO_ATTR_IMGFILE, "", parsedOk, Shape::DEFAULT_IMG_FILE);
1800  const double width = attrs.getOpt<double>(SUMO_ATTR_WIDTH, id.c_str(), parsedOk, Shape::DEFAULT_IMG_WIDTH);
1801  const double height = attrs.getOpt<double>(SUMO_ATTR_HEIGHT, id.c_str(), parsedOk, Shape::DEFAULT_IMG_HEIGHT);
1802  const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), parsedOk, Shape::DEFAULT_ANGLE);
1803  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1804  const bool relativePath = attrs.getOpt<bool>(SUMO_ATTR_RELATIVEPATH, id.c_str(), parsedOk, Shape::DEFAULT_RELATIVEPATH);
1805  // check icon
1806  if (!SUMOXMLDefinitions::POIIcons.hasString(icon)) {
1807  WRITE_WARNING(TLF("Invalid icon % for POI '%', using default", icon, id));
1808  icon = "none";
1809  }
1810  // continue if flag is ok
1811  if (parsedOk) {
1812  // set tag
1813  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_POI);
1814  // add attributes depending of Lane/Lanes
1815  if (attrs.hasAttribute(SUMO_ATTR_X) && attrs.hasAttribute(SUMO_ATTR_Y)) {
1816  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_X, x);
1817  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_Y, y);
1818  } else if (attrs.hasAttribute(SUMO_ATTR_LANE) && attrs.hasAttribute(SUMO_ATTR_POSITION)) {
1819  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, lane);
1820  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, pos);
1821  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1822  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION_LAT, posLat);
1823  } else {
1824  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LON, lon);
1825  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LAT, lat);
1826  }
1827  // add rest attributes
1828  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1829  myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
1830  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_TYPE, type);
1831  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ICON, icon);
1832  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LAYER, layer);
1833  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_IMGFILE, imgFile);
1834  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_WIDTH, width);
1835  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_HEIGHT, height);
1836  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ANGLE, angle);
1837  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1838  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_RELATIVEPATH, relativePath);
1839  }
1840 }
1841 
1842 
1843 void
1844 AdditionalHandler::parseJpsWalkableAreaAttributes(const SUMOSAXAttributes& attrs) {
1845  // declare Ok Flag
1846  bool parsedOk = true;
1847  // needed attributes
1848  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1849  const PositionVector shapeStr = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), parsedOk);
1850  // optional attributes
1851  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1852  // continue if flag is ok
1853  if (parsedOk) {
1854  // set tag
1855  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(GNE_TAG_JPS_WALKABLEAREA);
1856  // add all attributes
1857  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1858  myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionVectorAttribute(SUMO_ATTR_SHAPE, shapeStr);
1859  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1860  }
1861 }
1862 
1863 
1864 void
1865 AdditionalHandler::parseJpsObstacleAttributes(const SUMOSAXAttributes& attrs) {
1866  // declare Ok Flag
1867  bool parsedOk = true;
1868  // needed attributes
1869  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1870  const PositionVector shapeStr = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), parsedOk);
1871  // optional attributes
1872  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1873  // continue if flag is ok
1874  if (parsedOk) {
1875  // set tag
1876  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(GNE_TAG_JPS_OBSTACLE);
1877  // add all attributes
1878  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1879  myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionVectorAttribute(SUMO_ATTR_SHAPE, shapeStr);
1880  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1881  }
1882 }
1883 
1884 
1885 void
1886 AdditionalHandler::parseParameters(const SUMOSAXAttributes& attrs) {
1887  // declare Ok Flag
1888  bool parsedOk = true;
1889  // get key
1890  const std::string key = attrs.get<std::string>(SUMO_ATTR_KEY, nullptr, parsedOk);
1891  // get SumoBaseObject parent
1892  CommonXMLStructure::SumoBaseObject* SumoBaseObjectParent = myCommonXMLStructure.getCurrentSumoBaseObject()->getParentSumoBaseObject();
1893  // check parent
1894  if (SumoBaseObjectParent == nullptr) {
1895  writeError(TL("Parameters must be defined within an object."));
1896  } else if (SumoBaseObjectParent->getTag() == SUMO_TAG_ROOTFILE) {
1897  writeError(TL("Parameters cannot be defined in the additional file's root."));
1898  } else if (SumoBaseObjectParent->getTag() == SUMO_TAG_PARAM) {
1899  writeError(TL("Parameters cannot be defined within another parameter."));
1900  } else if (parsedOk) {
1901  // get tag str
1902  const std::string parentTagStr = toString(SumoBaseObjectParent->getTag());
1903  // circumventing empty string value
1904  const std::string value = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
1905  // show warnings if values are invalid
1906  if (key.empty()) {
1907  WRITE_WARNINGF(TL("Error parsing key from % generic parameter. Key cannot be empty."), parentTagStr);
1908  } else if (!SUMOXMLDefinitions::isValidParameterKey(key)) {
1909  WRITE_WARNINGF(TL("Error parsing key from % generic parameter. Key contains invalid characters."), parentTagStr);
1910  } else {
1911  WRITE_DEBUG("Inserting generic parameter '" + key + "|" + value + "' into " + parentTagStr);
1912  // insert parameter in SumoBaseObjectParent
1913  SumoBaseObjectParent->addParameter(key, value);
1914  }
1915  }
1916 }
1917 
1918 
1919 void
1920 AdditionalHandler::checkParent(const SumoXMLTag currentTag, const std::vector<SumoXMLTag>& parentTags, bool& ok) {
1921  // check that parent SUMOBaseObject's tag is the parentTag
1922  CommonXMLStructure::SumoBaseObject* const parent = myCommonXMLStructure.getCurrentSumoBaseObject()->getParentSumoBaseObject();
1923  if ((parent != nullptr) &&
1924  (parentTags.size() > 0) &&
1925  (std::find(parentTags.begin(), parentTags.end(), parent->getTag()) == parentTags.end())) {
1926  const std::string id = parent->hasStringAttribute(SUMO_ATTR_ID) ? ", id: '" + parent->getStringAttribute(SUMO_ATTR_ID) + "'" : "";
1927  writeError(TLF("'%' must be defined within the definition of a '%' (found % '%').", toString(currentTag), toString(parentTags.front()), toString(parent->getTag()), id));
1928  ok = false;
1929  }
1930 }
1931 
1932 
1933 bool
1934 AdditionalHandler::checkDetectPersons(const SumoXMLTag currentTag, const std::string& id, const std::string& detectPersons) {
1935  if (detectPersons.empty() || SUMOXMLDefinitions::PersonModeValues.hasString(detectPersons)) {
1936  return true;
1937  } else {
1938  writeError(TLF("Attribute '%' defined in % with id '%' doesn't have a valid value (given '%').", toString(SUMO_ATTR_DETECT_PERSONS), toString(currentTag), id, detectPersons));
1939  return false;
1940  }
1941 }
1942 
1943 /****************************************************************************/
SUMOTime
long long int SUMOTime
Definition: GUI.h:35
WRITE_DEBUG
#define WRITE_DEBUG(msg)
Definition: MsgHandler.h:306
WRITE_WARNINGF
#define WRITE_WARNINGF(...)
Definition: MsgHandler.h:296
WRITE_ERROR
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:304
WRITE_WARNING
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:295
TL
#define TL(string)
Definition: MsgHandler.h:315
TLF
#define TLF(string,...)
Definition: MsgHandler.h:317
DELTA_T
SUMOTime DELTA_T
Definition: SUMOTime.cpp:38
SUMOTime_MAX_PERIOD
#define SUMOTime_MAX_PERIOD
Definition: SUMOTime.h:36
TIME2STEPS
#define TIME2STEPS(x)
Definition: SUMOTime.h:57
parseVehicleClasses
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
Definition: SUMOVehicleClass.cpp:342
VEHPARS_VPH_SET
const int VEHPARS_VPH_SET
Definition: SUMOVehicleParameter.h:51
VEHPARS_CALIBRATORSPEED_SET
const int VEHPARS_CALIBRATORSPEED_SET
Definition: SUMOVehicleParameter.h:71
SumoXMLTag
SumoXMLTag
Numbers representing SUMO-XML - element names.
Definition: SUMOXMLDefinitions.h:41
SUMO_TAG_TRACTION_SUBSTATION
@ SUMO_TAG_TRACTION_SUBSTATION
A traction substation.
Definition: SUMOXMLDefinitions.h:141
SUMO_TAG_INTERVAL
@ SUMO_TAG_INTERVAL
an aggreagated-output interval
Definition: SUMOXMLDefinitions.h:119
SUMO_TAG_CLOSING_REROUTE
@ SUMO_TAG_CLOSING_REROUTE
reroute of type closing
Definition: SUMOXMLDefinitions.h:123
SUMO_TAG_REROUTER
@ SUMO_TAG_REROUTER
A rerouter.
Definition: SUMOXMLDefinitions.h:115
SUMO_TAG_ROUTEPROBE
@ SUMO_TAG_ROUTEPROBE
a routeprobe detector
Definition: SUMOXMLDefinitions.h:107
SUMO_TAG_TAZ
@ SUMO_TAG_TAZ
a traffic assignment zone
Definition: SUMOXMLDefinitions.h:181
SUMO_TAG_E2DETECTOR
@ SUMO_TAG_E2DETECTOR
an e2 detector
Definition: SUMOXMLDefinitions.h:85
SUMO_TAG_CHARGING_STATION
@ SUMO_TAG_CHARGING_STATION
A Charging Station.
Definition: SUMOXMLDefinitions.h:73
SUMO_TAG_ACCESS
@ SUMO_TAG_ACCESS
An access point for a train stop.
Definition: SUMOXMLDefinitions.h:69
SUMO_TAG_CONTAINER_STOP
@ SUMO_TAG_CONTAINER_STOP
A container stop.
Definition: SUMOXMLDefinitions.h:71
SUMO_TAG_PARKING_AREA_REROUTE
@ SUMO_TAG_PARKING_AREA_REROUTE
entry for an alternative parking zone
Definition: SUMOXMLDefinitions.h:129
SUMO_TAG_ROOTFILE
@ SUMO_TAG_ROOTFILE
root file
Definition: SUMOXMLDefinitions.h:43
SUMO_TAG_TAZSINK
@ SUMO_TAG_TAZSINK
a sink within a district (connection road)
Definition: SUMOXMLDefinitions.h:185
SUMO_TAG_BUS_STOP
@ SUMO_TAG_BUS_STOP
A bus stop.
Definition: SUMOXMLDefinitions.h:63
SUMO_TAG_POI
@ SUMO_TAG_POI
begin/end of the description of a Point of interest
Definition: SUMOXMLDefinitions.h:55
SUMO_TAG_STEP
@ SUMO_TAG_STEP
trigger: a step description
Definition: SUMOXMLDefinitions.h:137
SUMO_TAG_OVERHEAD_WIRE_CLAMP
@ SUMO_TAG_OVERHEAD_WIRE_CLAMP
An overhead wire clamp (connection of wires in opposite directions)
Definition: SUMOXMLDefinitions.h:147
SUMO_TAG_FLOW
@ SUMO_TAG_FLOW
a flow definition using from and to edges or a route
Definition: SUMOXMLDefinitions.h:163
SUMO_TAG_PARKING_AREA
@ SUMO_TAG_PARKING_AREA
A parking area.
Definition: SUMOXMLDefinitions.h:77
SUMO_TAG_ROUTE_PROB_REROUTE
@ SUMO_TAG_ROUTE_PROB_REROUTE
probability of route of a reroute
Definition: SUMOXMLDefinitions.h:127
GNE_TAG_CALIBRATOR_LANE
@ GNE_TAG_CALIBRATOR_LANE
A calibrator placed over lane.
Definition: SUMOXMLDefinitions.h:111
SUMO_TAG_DET_ENTRY
@ SUMO_TAG_DET_ENTRY
an e3 entry point
Definition: SUMOXMLDefinitions.h:95
SUMO_TAG_PARKING_SPACE
@ SUMO_TAG_PARKING_SPACE
A parking space for a single vehicle within a parking area.
Definition: SUMOXMLDefinitions.h:79
SUMO_TAG_POLY
@ SUMO_TAG_POLY
begin/end of the description of a polygon
Definition: SUMOXMLDefinitions.h:53
SUMO_TAG_OVERHEAD_WIRE_SECTION
@ SUMO_TAG_OVERHEAD_WIRE_SECTION
An overhead wire section.
Definition: SUMOXMLDefinitions.h:145
SUMO_TAG_TRAIN_STOP
@ SUMO_TAG_TRAIN_STOP
A train stop (alias for bus stop)
Definition: SUMOXMLDefinitions.h:65
SUMO_TAG_INSTANT_INDUCTION_LOOP
@ SUMO_TAG_INSTANT_INDUCTION_LOOP
An instantenous induction loop.
Definition: SUMOXMLDefinitions.h:105
SUMO_TAG_DEST_PROB_REROUTE
@ SUMO_TAG_DEST_PROB_REROUTE
probability of destination of a reroute
Definition: SUMOXMLDefinitions.h:121
SUMO_TAG_PARAM
@ SUMO_TAG_PARAM
parameter associated to a certain key
Definition: SUMOXMLDefinitions.h:213
SUMO_TAG_E1DETECTOR
@ SUMO_TAG_E1DETECTOR
an e1 detector
Definition: SUMOXMLDefinitions.h:81
GNE_TAG_JPS_OBSTACLE
@ GNE_TAG_JPS_OBSTACLE
polygon used for draw juPedSim obstacles
Definition: SUMOXMLDefinitions.h:435
SUMO_TAG_DET_EXIT
@ SUMO_TAG_DET_EXIT
an e3 exit point
Definition: SUMOXMLDefinitions.h:97
SUMO_TAG_VAPORIZER
@ SUMO_TAG_VAPORIZER
vaporizer of vehicles
Definition: SUMOXMLDefinitions.h:139
SUMO_TAG_LANE_AREA_DETECTOR
@ SUMO_TAG_LANE_AREA_DETECTOR
alternative tag for e2 detector
Definition: SUMOXMLDefinitions.h:87
SUMO_TAG_TAZSOURCE
@ SUMO_TAG_TAZSOURCE
a source within a district (connection road)
Definition: SUMOXMLDefinitions.h:183
SUMO_TAG_CLOSING_LANE_REROUTE
@ SUMO_TAG_CLOSING_LANE_REROUTE
lane of a reroute of type closing
Definition: SUMOXMLDefinitions.h:125
SUMO_TAG_INDUCTION_LOOP
@ SUMO_TAG_INDUCTION_LOOP
alternative tag for e1 detector
Definition: SUMOXMLDefinitions.h:83
GNE_TAG_JPS_WALKABLEAREA
@ GNE_TAG_JPS_WALKABLEAREA
polygon used for draw juPedSim walkable areas
Definition: SUMOXMLDefinitions.h:433
SUMO_TAG_CALIBRATOR
@ SUMO_TAG_CALIBRATOR
A calibrator placed over edge.
Definition: SUMOXMLDefinitions.h:109
SUMO_TAG_ENTRY_EXIT_DETECTOR
@ SUMO_TAG_ENTRY_EXIT_DETECTOR
alternative tag for e3 detector
Definition: SUMOXMLDefinitions.h:93
SUMO_TAG_E3DETECTOR
@ SUMO_TAG_E3DETECTOR
an e3 detector
Definition: SUMOXMLDefinitions.h:91
SUMO_TAG_VSS
@ SUMO_TAG_VSS
A variable speed sign.
Definition: SUMOXMLDefinitions.h:133
SUMO_ATTR_EXPECT_ARRIVAL
@ SUMO_ATTR_EXPECT_ARRIVAL
Definition: SUMOXMLDefinitions.h:1492
SUMO_ATTR_STARTPOS
@ SUMO_ATTR_STARTPOS
Definition: SUMOXMLDefinitions.h:1549
SUMO_ATTR_DISALLOW
@ SUMO_ATTR_DISALLOW
Definition: SUMOXMLDefinitions.h:1530
SUMO_ATTR_LINES
@ SUMO_ATTR_LINES
Definition: SUMOXMLDefinitions.h:1517
SUMO_ATTR_ALLOW
@ SUMO_ATTR_ALLOW
Definition: SUMOXMLDefinitions.h:1529
SUMO_ATTR_ICON
@ SUMO_ATTR_ICON
icon
Definition: SUMOXMLDefinitions.h:1422
SUMO_ATTR_LANE
@ SUMO_ATTR_LANE
Definition: SUMOXMLDefinitions.h:867
SUMO_ATTR_ACCEPTED_BADGES
@ SUMO_ATTR_ACCEPTED_BADGES
Definition: SUMOXMLDefinitions.h:1512
SUMO_ATTR_LON
@ SUMO_ATTR_LON
Definition: SUMOXMLDefinitions.h:1571
SUMO_ATTR_VEHSPERHOUR
@ SUMO_ATTR_VEHSPERHOUR
Definition: SUMOXMLDefinitions.h:1535
SUMO_ATTR_SPEED
@ SUMO_ATTR_SPEED
Definition: SUMOXMLDefinitions.h:820
SUMO_ATTR_WAITINGTIME
@ SUMO_ATTR_WAITINGTIME
Definition: SUMOXMLDefinitions.h:818
SUMO_ATTR_VALUE
@ SUMO_ATTR_VALUE
Definition: SUMOXMLDefinitions.h:1526
SUMO_ATTR_NEXT_EDGES
@ SUMO_ATTR_NEXT_EDGES
Definition: SUMOXMLDefinitions.h:1328
SUMO_ATTR_FILE
@ SUMO_ATTR_FILE
Definition: SUMOXMLDefinitions.h:1363
SUMO_ATTR_PARKING_AREA
@ SUMO_ATTR_PARKING_AREA
Definition: SUMOXMLDefinitions.h:1510
SUMO_ATTR_Y
@ SUMO_ATTR_Y
Definition: SUMOXMLDefinitions.h:861
SUMO_ATTR_SUBSTATIONID
@ SUMO_ATTR_SUBSTATIONID
id of a traction substation substation
Definition: SUMOXMLDefinitions.h:1011
SUMO_ATTR_Z
@ SUMO_ATTR_Z
Definition: SUMOXMLDefinitions.h:862
SUMO_ATTR_EDGE
@ SUMO_ATTR_EDGE
Definition: SUMOXMLDefinitions.h:866
SUMO_ATTR_JAM_DIST_THRESHOLD
@ SUMO_ATTR_JAM_DIST_THRESHOLD
Definition: SUMOXMLDefinitions.h:1489
SUMO_ATTR_CHARGETYPE
@ SUMO_ATTR_CHARGETYPE
Charge type (fuel or electric)
Definition: SUMOXMLDefinitions.h:1043
SUMO_ATTR_PARKING_LENGTH
@ SUMO_ATTR_PARKING_LENGTH
Definition: SUMOXMLDefinitions.h:1351
SUMO_ATTR_ENDPOS
@ SUMO_ATTR_ENDPOS
Definition: SUMOXMLDefinitions.h:1550
SUMO_ATTR_VOLTAGE
@ SUMO_ATTR_VOLTAGE
voltage of the traction substation [V]
Definition: SUMOXMLDefinitions.h:1005
SUMO_ATTR_X
@ SUMO_ATTR_X
Definition: SUMOXMLDefinitions.h:860
SUMO_ATTR_BEGIN
@ SUMO_ATTR_BEGIN
weights: time range begin
Definition: SUMOXMLDefinitions.h:1380
SUMO_ATTR_EDGES
@ SUMO_ATTR_EDGES
the edges of a route
Definition: SUMOXMLDefinitions.h:946
SUMO_ATTR_OFF
@ SUMO_ATTR_OFF
Definition: SUMOXMLDefinitions.h:1502
SUMO_ATTR_ROUTEPROBE
@ SUMO_ATTR_ROUTEPROBE
Definition: SUMOXMLDefinitions.h:1370
SUMO_ATTR_LINEWIDTH
@ SUMO_ATTR_LINEWIDTH
Definition: SUMOXMLDefinitions.h:1427
SUMO_ATTR_POSITION_LAT
@ SUMO_ATTR_POSITION_LAT
Definition: SUMOXMLDefinitions.h:878
SUMO_ATTR_OVERHEAD_WIRE_FORBIDDEN
@ SUMO_ATTR_OVERHEAD_WIRE_FORBIDDEN
forbidden lanes for overhead wire segment
Definition: SUMOXMLDefinitions.h:1015
SUMO_ATTR_HALTING_TIME_THRESHOLD
@ SUMO_ATTR_HALTING_TIME_THRESHOLD
Definition: SUMOXMLDefinitions.h:1487
SUMO_ATTR_GEO
@ SUMO_ATTR_GEO
Definition: SUMOXMLDefinitions.h:1574
SUMO_ATTR_LANES
@ SUMO_ATTR_LANES
Definition: SUMOXMLDefinitions.h:1334
SUMO_ATTR_VTYPES
@ SUMO_ATTR_VTYPES
Definition: SUMOXMLDefinitions.h:1327
SUMO_ATTR_OVERHEAD_WIRECLAMP_END
@ SUMO_ATTR_OVERHEAD_WIRECLAMP_END
id of the overhead wire, to the end of which the overhead wire clamp is connected
Definition: SUMOXMLDefinitions.h:1025
SUMO_ATTR_SHAPE
@ SUMO_ATTR_SHAPE
edge: the shape in xml-definition
Definition: SUMOXMLDefinitions.h:1394
SUMO_ATTR_DEPARTPOS
@ SUMO_ATTR_DEPARTPOS
Definition: SUMOXMLDefinitions.h:952
SUMO_ATTR_LEFTHAND
@ SUMO_ATTR_LEFTHAND
Definition: SUMOXMLDefinitions.h:1636
SUMO_ATTR_WEIGHT
@ SUMO_ATTR_WEIGHT
Definition: SUMOXMLDefinitions.h:941
SUMO_ATTR_OVERHEAD_WIRECLAMP_LANESTART
@ SUMO_ATTR_OVERHEAD_WIRECLAMP_LANESTART
id of the overhead wire lane, to the start of which the overhead wire clamp is connected
Definition: SUMOXMLDefinitions.h:1027
SUMO_ATTR_CHARGEINTRANSIT
@ SUMO_ATTR_CHARGEINTRANSIT
Allow/disallow charge in transit in Charging Stations.
Definition: SUMOXMLDefinitions.h:1039
SUMO_ATTR_OVERHEAD_WIRECLAMP_START
@ SUMO_ATTR_OVERHEAD_WIRECLAMP_START
id of the overhead wire, to the start of which the overhead wire clamp is connected
Definition: SUMOXMLDefinitions.h:1023
SUMO_ATTR_CONTAINER_CAPACITY
@ SUMO_ATTR_CONTAINER_CAPACITY
Definition: SUMOXMLDefinitions.h:1350
SUMO_ATTR_FILL
@ SUMO_ATTR_FILL
Fill the polygon.
Definition: SUMOXMLDefinitions.h:1426
SUMO_ATTR_NAME
@ SUMO_ATTR_NAME
Definition: SUMOXMLDefinitions.h:902
SUMO_ATTR_PERIOD
@ SUMO_ATTR_PERIOD
Definition: SUMOXMLDefinitions.h:1343
SUMO_ATTR_LAYER
@ SUMO_ATTR_LAYER
A layer number.
Definition: SUMOXMLDefinitions.h:1424
SUMO_ATTR_SLOPE
@ SUMO_ATTR_SLOPE
Definition: SUMOXMLDefinitions.h:868
SUMO_ATTR_HALTING_SPEED_THRESHOLD
@ SUMO_ATTR_HALTING_SPEED_THRESHOLD
Definition: SUMOXMLDefinitions.h:1488
SUMO_ATTR_CENTER
@ SUMO_ATTR_CENTER
Definition: SUMOXMLDefinitions.h:919
SUMO_ATTR_ANGLE
@ SUMO_ATTR_ANGLE
Definition: SUMOXMLDefinitions.h:863
SUMO_ATTR_HEIGHT
@ SUMO_ATTR_HEIGHT
Definition: SUMOXMLDefinitions.h:1541
SUMO_ATTR_END
@ SUMO_ATTR_END
weights: time range end
Definition: SUMOXMLDefinitions.h:1382
SUMO_ATTR_ROADSIDE_CAPACITY
@ SUMO_ATTR_ROADSIDE_CAPACITY
Definition: SUMOXMLDefinitions.h:1511
SUMO_ATTR_CURRENTLIMIT
@ SUMO_ATTR_CURRENTLIMIT
current limit of the traction substation [A]
Definition: SUMOXMLDefinitions.h:1009
SUMO_ATTR_TLID
@ SUMO_ATTR_TLID
link,node: the traffic light id responsible for this link
Definition: SUMOXMLDefinitions.h:1384
SUMO_ATTR_OPTIONAL
@ SUMO_ATTR_OPTIONAL
Definition: SUMOXMLDefinitions.h:1659
SUMO_ATTR_OUTPUT
@ SUMO_ATTR_OUTPUT
Definition: SUMOXMLDefinitions.h:1540
SUMO_ATTR_SHOW_DETECTOR
@ SUMO_ATTR_SHOW_DETECTOR
Definition: SUMOXMLDefinitions.h:1490
SUMO_ATTR_CHARGINGPOWER
@ SUMO_ATTR_CHARGINGPOWER
Definition: SUMOXMLDefinitions.h:1035
SUMO_ATTR_PROB
@ SUMO_ATTR_PROB
Definition: SUMOXMLDefinitions.h:1321
SUMO_ATTR_FRIENDLY_POS
@ SUMO_ATTR_FRIENDLY_POS
Definition: SUMOXMLDefinitions.h:1503
SUMO_ATTR_ONROAD
@ SUMO_ATTR_ONROAD
Definition: SUMOXMLDefinitions.h:1513
SUMO_ATTR_LAT
@ SUMO_ATTR_LAT
Definition: SUMOXMLDefinitions.h:1572
SUMO_ATTR_TYPE
@ SUMO_ATTR_TYPE
Definition: SUMOXMLDefinitions.h:864
SUMO_ATTR_LENGTH
@ SUMO_ATTR_LENGTH
Definition: SUMOXMLDefinitions.h:915
SUMO_ATTR_COLOR
@ SUMO_ATTR_COLOR
A color information.
Definition: SUMOXMLDefinitions.h:1412
SUMO_ATTR_EFFICIENCY
@ SUMO_ATTR_EFFICIENCY
Eficiency of the charge in Charging Stations.
Definition: SUMOXMLDefinitions.h:1037
SUMO_ATTR_ID
@ SUMO_ATTR_ID
Definition: SUMOXMLDefinitions.h:900
SUMO_ATTR_VISIBLE
@ SUMO_ATTR_VISIBLE
Definition: SUMOXMLDefinitions.h:1653
SUMO_ATTR_OPEN_ENTRY
@ SUMO_ATTR_OPEN_ENTRY
Definition: SUMOXMLDefinitions.h:1491
SUMO_ATTR_IMGFILE
@ SUMO_ATTR_IMGFILE
Definition: SUMOXMLDefinitions.h:1544
SUMO_ATTR_WIDTH
@ SUMO_ATTR_WIDTH
Definition: SUMOXMLDefinitions.h:908
SUMO_ATTR_PERSON_CAPACITY
@ SUMO_ATTR_PERSON_CAPACITY
Definition: SUMOXMLDefinitions.h:1349
SUMO_ATTR_KEY
@ SUMO_ATTR_KEY
Definition: SUMOXMLDefinitions.h:927
SUMO_ATTR_POSITION
@ SUMO_ATTR_POSITION
Definition: SUMOXMLDefinitions.h:865
SUMO_ATTR_CHARGEDELAY
@ SUMO_ATTR_CHARGEDELAY
Delay in the charge of charging stations (different of waiting time)
Definition: SUMOXMLDefinitions.h:1041
SUMO_ATTR_TIME
@ SUMO_ATTR_TIME
trigger: the time of the step
Definition: SUMOXMLDefinitions.h:1378
SUMO_ATTR_OVERHEAD_WIRECLAMP_LANEEND
@ SUMO_ATTR_OVERHEAD_WIRECLAMP_LANEEND
id of the overhead wire lane, to the end of which the overhead wire clamp is connected
Definition: SUMOXMLDefinitions.h:1029
SUMO_ATTR_DETECT_PERSONS
@ SUMO_ATTR_DETECT_PERSONS
Definition: SUMOXMLDefinitions.h:1563
SUMO_ATTR_RELATIVEPATH
@ SUMO_ATTR_RELATIVEPATH
Definition: SUMOXMLDefinitions.h:1545
INVALID_DOUBLE
const double INVALID_DOUBLE
invalid double
Definition: StdDefs.h:64
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
AdditionalHandler::buildDestProbReroute
virtual void buildDestProbReroute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &newEdgeDestinationID, const double probability)=0
builds a dest prob reroute
AdditionalHandler::parseE1InstantAttributes
void parseE1InstantAttributes(const SUMOSAXAttributes &attrs)
parse E1 instant attributes
Definition: AdditionalHandler.cpp:1189
AdditionalHandler::parseCalibratorAttributes
void parseCalibratorAttributes(const SUMOSAXAttributes &attrs)
parse calibrator attributes
Definition: AdditionalHandler.cpp:1337
AdditionalHandler::parseChargingStationAttributes
void parseChargingStationAttributes(const SUMOSAXAttributes &attrs)
parse chargingStation attributes
Definition: AdditionalHandler.cpp:868
AdditionalHandler::buildSingleLaneDetectorE2
virtual void buildSingleLaneDetectorE2(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &laneID, const double pos, const double length, const SUMOTime period, const std::string &trafficLight, const std::string &filename, const std::vector< std::string > &vehicleTypes, const std::vector< std::string > &nextEdges, const std::string &detectPersons, const std::string &name, const SUMOTime timeThreshold, const double speedThreshold, const double jamThreshold, const bool friendlyPos, const bool show, const Parameterised::Map &parameters)=0
Builds a single-lane Area Detector (E2)
AdditionalHandler::buildRouteProbReroute
virtual void buildRouteProbReroute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &newRouteID, const double probability)=0
builds a route prob reroute
AdditionalHandler::buildVariableSpeedSign
virtual void buildVariableSpeedSign(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const Position &pos, const std::vector< std::string > &laneIDs, const std::string &name, const std::vector< std::string > &vTypes, const Parameterised::Map &parameters)=0
Builds a VariableSpeedSign (lane speed additional)
AdditionalHandler::checkDetectPersons
bool checkDetectPersons(const SumoXMLTag currentTag, const std::string &id, const std::string &detectPersons)
check detect persons
Definition: AdditionalHandler.cpp:1934
AdditionalHandler::buildTrainStop
virtual void buildTrainStop(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &laneID, const double startPos, const double endPos, const std::string &name, const std::vector< std::string > &lines, const int personCapacity, const double parkingLength, const RGBColor &color, const bool friendlyPosition, const Parameterised::Map &parameters)=0
Builds a train stop.
AdditionalHandler::parseSumoBaseObject
void parseSumoBaseObject(CommonXMLStructure::SumoBaseObject *obj)
parse SumoBaseObject (it's called recursivelly)
Definition: AdditionalHandler.cpp:247
AdditionalHandler::buildEdgeCalibrator
virtual void buildEdgeCalibrator(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &edgeID, const double pos, const std::string &name, const std::string &outfile, const SUMOTime period, const std::string &routeprobe, const double jamThreshold, const std::vector< std::string > &vTypes, const Parameterised::Map &parameters)=0
builds a microscopic calibrator over an edge
AdditionalHandler::buildRerouterInterval
virtual void buildRerouterInterval(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOTime begin, const SUMOTime end)=0
builds a rerouter interval
AdditionalHandler::buildParkingSpace
virtual void buildParkingSpace(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const double x, const double y, const double z, const std::string &name, const std::string &width, const std::string &length, const std::string &angle, const double slope, const Parameterised::Map &parameters)=0
Builds a Parking Space.
AdditionalHandler::parseRouteProbRerouteAttributes
void parseRouteProbRerouteAttributes(const SUMOSAXAttributes &attrs)
parse route prob reroute attributes
Definition: AdditionalHandler.cpp:1571
AdditionalHandler::buildRerouter
virtual void buildRerouter(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const Position &pos, const std::vector< std::string > &edgeIDs, const double prob, const std::string &name, const bool off, const bool optional, const SUMOTime timeThreshold, const std::vector< std::string > &vTypes, const Parameterised::Map &parameters)=0
builds a rerouter
AdditionalHandler::parseJpsWalkableAreaAttributes
void parseJpsWalkableAreaAttributes(const SUMOSAXAttributes &attrs)
parse juPedSim walkable area attributes
Definition: AdditionalHandler.cpp:1844
AdditionalHandler::parseCalibratorFlowAttributes
void parseCalibratorFlowAttributes(const SUMOSAXAttributes &attrs)
parse calibrator flow attributes
Definition: AdditionalHandler.cpp:1382
AdditionalHandler::parseParkingAreaRerouteAttributes
void parseParkingAreaRerouteAttributes(const SUMOSAXAttributes &attrs)
parse parking area reroute attributes
Definition: AdditionalHandler.cpp:1544
AdditionalHandler::parseTAZAttributes
void parseTAZAttributes(const SUMOSAXAttributes &attrs)
parse TAZ attributes
Definition: AdditionalHandler.cpp:1222
AdditionalHandler::AdditionalHandler
AdditionalHandler()
Constructor.
Definition: AdditionalHandler.cpp:37
AdditionalHandler::buildPOILane
virtual void buildPOILane(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &type, const RGBColor &color, const std::string &laneID, const double posOverLane, const bool friendlyPosition, const double posLat, const std::string &icon, const double layer, const double angle, const std::string &imgFile, const bool relativePath, const double width, const double height, const std::string &name, const Parameterised::Map &parameters)=0
Builds a POI over lane using the given values.
AdditionalHandler::buildLaneCalibrator
virtual void buildLaneCalibrator(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &laneID, const double pos, const std::string &name, const std::string &outfile, const SUMOTime period, const std::string &routeprobe, const double jamThreshold, const std::vector< std::string > &vTypes, const Parameterised::Map &parameters)=0
builds a microscopic calibrator over a lane
AdditionalHandler::checkParent
void checkParent(const SumoXMLTag currentTag, const std::vector< SumoXMLTag > &parentTags, bool &ok)
check parents
Definition: AdditionalHandler.cpp:1920
AdditionalHandler::parseOverheadWire
void parseOverheadWire(const SUMOSAXAttributes &attrs)
parse overhead wire segment
Definition: AdditionalHandler.cpp:1668
AdditionalHandler::myCommonXMLStructure
CommonXMLStructure myCommonXMLStructure
common XML Structure
Definition: AdditionalHandler.h:633
AdditionalHandler::buildOverheadWireClamp
virtual void buildOverheadWireClamp(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &overheadWireIDStartClamp, const std::string &laneIDStartClamp, const std::string &overheadWireIDEndClamp, const std::string &laneIDEndClamp, const Parameterised::Map &parameters)=0
build overhead wire clamp
AdditionalHandler::parseTractionSubstation
void parseTractionSubstation(const SUMOSAXAttributes &attrs)
parse traction substation
Definition: AdditionalHandler.cpp:1645
AdditionalHandler::parseE3Attributes
void parseE3Attributes(const SUMOSAXAttributes &attrs)
parse E3 attributes
Definition: AdditionalHandler.cpp:1104
AdditionalHandler::parseE2Attributes
void parseE2Attributes(const SUMOSAXAttributes &attrs)
parse E2 attributes
Definition: AdditionalHandler.cpp:1029
AdditionalHandler::parseTAZSinkAttributes
void parseTAZSinkAttributes(const SUMOSAXAttributes &attrs)
parse TAZ sink attributes
Definition: AdditionalHandler.cpp:1271
AdditionalHandler::parseOverheadWireClamp
void parseOverheadWireClamp(const SUMOSAXAttributes &attrs)
parse overhead wire clamp
Definition: AdditionalHandler.cpp:1697
AdditionalHandler::writeError
void writeError(const std::string &error)
write error and enable error creating element
Definition: AdditionalHandler.cpp:731
AdditionalHandler::beginParseAttributes
bool beginParseAttributes(SumoXMLTag tag, const SUMOSAXAttributes &attrs)
begin parse attributes
Definition: AdditionalHandler.cpp:44
AdditionalHandler::parseTrainStopAttributes
void parseTrainStopAttributes(const SUMOSAXAttributes &attrs)
parse trainStop attributes
Definition: AdditionalHandler.cpp:773
AdditionalHandler::buildVariableSpeedSignStep
virtual void buildVariableSpeedSignStep(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOTime time, const std::string &speed)=0
Builds a VariableSpeedSign Step.
AdditionalHandler::buildDetectorEntry
virtual void buildDetectorEntry(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &laneID, const double pos, const bool friendlyPos, const Parameterised::Map &parameters)=0
Builds a entry detector (E3)
AdditionalHandler::parsePOIAttributes
void parsePOIAttributes(const SUMOSAXAttributes &attrs)
parse POI attributes
Definition: AdditionalHandler.cpp:1762
AdditionalHandler::myErrorCreatingElement
bool myErrorCreatingElement
flag for check if a element wasn't created
Definition: AdditionalHandler.h:636
AdditionalHandler::endParseAttributes
void endParseAttributes()
end parse attributes
Definition: AdditionalHandler.cpp:191
AdditionalHandler::buildE1Detector
virtual void buildE1Detector(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &laneID, const double position, const SUMOTime period, const std::string &file, const std::vector< std::string > &vehicleTypes, const std::vector< std::string > &nextEdges, const std::string &detectPersons, const std::string &name, const bool friendlyPos, const Parameterised::Map &parameters)=0
Builds a induction loop detector (E1)
AdditionalHandler::buildDetectorE3
virtual void buildDetectorE3(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const Position &pos, const SUMOTime period, const std::string &filename, const std::vector< std::string > &vehicleTypes, const std::vector< std::string > &nextEdges, const std::string &detectPersons, const std::string &name, const SUMOTime timeThreshold, const double speedThreshold, const bool openEntry, const bool expectedArrival, const Parameterised::Map &parameters)=0
Builds a multi entry exit detector (E3)
AdditionalHandler::buildJpsObstacle
virtual void buildJpsObstacle(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const PositionVector &shape, bool geo, const std::string &name, const Parameterised::Map &parameters)=0
Builds a JuPedSim obstacle using the given values.
AdditionalHandler::buildPOIGeo
virtual void buildPOIGeo(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &type, const RGBColor &color, const double lon, const double lat, const std::string &icon, const double layer, const double angle, const std::string &imgFile, bool relativePath, const double width, const double height, const std::string &name, const Parameterised::Map &parameters)=0
Builds a POI in GEO coordinaten using the given values.
AdditionalHandler::buildDetectorE1Instant
virtual void buildDetectorE1Instant(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &laneID, const double pos, const std::string &filename, const std::vector< std::string > &vehicleTypes, const std::vector< std::string > &nextEdges, const std::string &detectPersons, const std::string &name, const bool friendlyPos, const Parameterised::Map &parameters)=0
Builds a Instant Induction Loop Detector (E1Instant)
AdditionalHandler::buildJpsWalkableArea
virtual void buildJpsWalkableArea(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const PositionVector &shape, bool geo, const std::string &name, const Parameterised::Map &parameters)=0
Builds a JuPedSim walkable area using the given values.
AdditionalHandler::parseJpsObstacleAttributes
void parseJpsObstacleAttributes(const SUMOSAXAttributes &attrs)
parse juPedSim obstacle attributes
Definition: AdditionalHandler.cpp:1865
AdditionalHandler::buildChargingStation
virtual void buildChargingStation(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &laneID, const double startPos, const double endPos, const std::string &name, const double chargingPower, const double efficiency, const bool chargeInTransit, const SUMOTime chargeDelay, const std::string &chargeType, const SUMOTime waitingTime, const bool friendlyPosition, const std::string &parkingAreaID, const Parameterised::Map &parameters)=0
Builds a charging Station.
AdditionalHandler::parseVariableSpeedSignAttributes
void parseVariableSpeedSignAttributes(const SUMOSAXAttributes &attrs)
parse variable speed sign attributes
Definition: AdditionalHandler.cpp:1291
AdditionalHandler::~AdditionalHandler
virtual ~AdditionalHandler()
Destructor.
Definition: AdditionalHandler.cpp:40
AdditionalHandler::buildParkingArea
virtual void buildParkingArea(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &laneID, const double startPos, const double endPos, const std::string &departPos, const std::string &name, const std::vector< std::string > &lines, const bool friendlyPosition, const int roadSideCapacity, const bool onRoad, const double width, const double length, const double angle, const bool lefthand, const Parameterised::Map &parameters)=0
Builds a Parking Area.
AdditionalHandler::buildTAZ
virtual void buildTAZ(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const PositionVector &shape, const Position &center, const bool fill, const RGBColor &color, const std::vector< std::string > &edgeIDs, const std::string &name, const Parameterised::Map &parameters)=0
Builds a TAZ (Traffic Assignment Zone)
AdditionalHandler::buildPOI
virtual void buildPOI(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &type, const RGBColor &color, const double x, const double y, const std::string &icon, const double layer, const double angle, const std::string &imgFile, bool relativePath, const double width, const double height, const std::string &name, const Parameterised::Map &parameters)=0
Builds a POI using the given values.
AdditionalHandler::parseDestProbRerouteAttributes
void parseDestProbRerouteAttributes(const SUMOSAXAttributes &attrs)
parse dest prob reroute attributes
Definition: AdditionalHandler.cpp:1520
AdditionalHandler::buildCalibratorFlow
virtual void buildCalibratorFlow(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &vehicleParameter)=0
builds a calibrator flow
AdditionalHandler::parseE1Attributes
void parseE1Attributes(const SUMOSAXAttributes &attrs)
parse E1 attributes
Definition: AdditionalHandler.cpp:994
AdditionalHandler::buildOverheadWire
virtual void buildOverheadWire(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &substationId, const std::vector< std::string > &laneIDs, const double startPos, const double endPos, const bool friendlyPos, const std::vector< std::string > &forbiddenInnerLanes, const Parameterised::Map &parameters)=0
build overhead wire
AdditionalHandler::parseVariableSpeedSignStepAttributes
void parseVariableSpeedSignStepAttributes(const SUMOSAXAttributes &attrs)
parse variable speed sign step attributes
Definition: AdditionalHandler.cpp:1316
AdditionalHandler::parseParameters
void parseParameters(const SUMOSAXAttributes &attrs)
parse generic parameters
Definition: AdditionalHandler.cpp:1886
AdditionalHandler::parseParkingSpaceAttributes
void parseParkingSpaceAttributes(const SUMOSAXAttributes &attrs)
parse parking space attributes
Definition: AdditionalHandler.cpp:961
AdditionalHandler::parseExitAttributes
void parseExitAttributes(const SUMOSAXAttributes &attrs)
parse exist attributes
Definition: AdditionalHandler.cpp:1166
AdditionalHandler::buildClosingLaneReroute
virtual void buildClosingLaneReroute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &closedLane, SVCPermissions permissions)=0
builds a closing lane reroute
AdditionalHandler::buildTAZSink
virtual void buildTAZSink(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &edgeID, const double arrivalWeight)=0
Builds a TAZSink (Traffic Assignment Zone)
AdditionalHandler::parseRerouterAttributes
void parseRerouterAttributes(const SUMOSAXAttributes &attrs)
parse rerouter attributes
Definition: AdditionalHandler.cpp:1421
AdditionalHandler::parseBusStopAttributes
void parseBusStopAttributes(const SUMOSAXAttributes &attrs)
Definition: AdditionalHandler.cpp:738
AdditionalHandler::buildClosingReroute
virtual void buildClosingReroute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &closedEdgeID, SVCPermissions permissions)=0
builds a closing edge reroute
AdditionalHandler::parseContainerStopAttributes
void parseContainerStopAttributes(const SUMOSAXAttributes &attrs)
parse containerStop attributes
Definition: AdditionalHandler.cpp:833
AdditionalHandler::buildMultiLaneDetectorE2
virtual void buildMultiLaneDetectorE2(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::vector< std::string > &laneIDs, const double pos, const double endPos, const SUMOTime period, const std::string &trafficLight, const std::string &filename, const std::vector< std::string > &vehicleTypes, const std::vector< std::string > &nextEdges, const std::string &detectPersons, const std::string &name, const SUMOTime timeThreshold, const double speedThreshold, const double jamThreshold, const bool friendlyPos, const bool show, const Parameterised::Map &parameters)=0
Builds a multi-lane Area Detector (E2)
AdditionalHandler::parseParkingAreaAttributes
void parseParkingAreaAttributes(const SUMOSAXAttributes &attrs)
parse parking area attributes
Definition: AdditionalHandler.cpp:917
AdditionalHandler::buildVaporizer
virtual void buildVaporizer(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &edgeID, const SUMOTime from, const SUMOTime endTime, const std::string &name, const Parameterised::Map &parameters)=0
Builds a vaporizer (lane speed additional)
AdditionalHandler::buildDetectorExit
virtual void buildDetectorExit(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &laneID, const double pos, const bool friendlyPos, const Parameterised::Map &parameters)=0
Builds a exit detector (E3)
AdditionalHandler::buildContainerStop
virtual void buildContainerStop(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &laneID, const double startPos, const double endPos, const std::string &name, const std::vector< std::string > &lines, const int containerCapacity, const double parkingLength, const RGBColor &color, const bool friendlyPosition, const Parameterised::Map &parameters)=0
Builds a container stop.
AdditionalHandler::buildTractionSubstation
virtual void buildTractionSubstation(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const Position &pos, const double voltage, const double currentLimit, const Parameterised::Map &parameters)=0
build traction substation
AdditionalHandler::buildBusStop
virtual void buildBusStop(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &laneID, const double startPos, const double endPos, const std::string &name, const std::vector< std::string > &lines, const int personCapacity, const double parkingLength, const RGBColor &color, const bool friendlyPosition, const Parameterised::Map &parameters)=0
Builds a bus stop.
AdditionalHandler::buildAccess
virtual void buildAccess(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &laneID, const std::string &pos, const double length, const bool friendlyPos, const Parameterised::Map &parameters)=0
Builds an Access.
AdditionalHandler::parseRouteProbeAttributes
void parseRouteProbeAttributes(const SUMOSAXAttributes &attrs)
parse route probe attributes
Definition: AdditionalHandler.cpp:1595
AdditionalHandler::parseAccessAttributes
void parseAccessAttributes(const SUMOSAXAttributes &attrs)
parse access attributes
Definition: AdditionalHandler.cpp:808
AdditionalHandler::parseTAZSourceAttributes
void parseTAZSourceAttributes(const SUMOSAXAttributes &attrs)
parse TAZ source attributes
Definition: AdditionalHandler.cpp:1251
AdditionalHandler::parseVaporizerAttributes
void parseVaporizerAttributes(const SUMOSAXAttributes &attrs)
parse vaporizer attributes
Definition: AdditionalHandler.cpp:1622
AdditionalHandler::buildParkingAreaReroute
virtual void buildParkingAreaReroute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &newParkignAreaID, const double probability, const bool visible)=0
builds a parking area reroute
AdditionalHandler::buildRouteProbe
virtual void buildRouteProbe(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &edgeID, const SUMOTime period, const std::string &name, const std::string &file, const SUMOTime begin, const Parameterised::Map &parameters)=0
builds a Route probe
AdditionalHandler::parseClosingLaneRerouteAttributes
void parseClosingLaneRerouteAttributes(const SUMOSAXAttributes &attrs)
parse closing lane reroute attributes
Definition: AdditionalHandler.cpp:1474
AdditionalHandler::parseRerouterIntervalAttributes
void parseRerouterIntervalAttributes(const SUMOSAXAttributes &attrs)
parse rerouter interval attributes
Definition: AdditionalHandler.cpp:1454
AdditionalHandler::isErrorCreatingElement
bool isErrorCreatingElement() const
get flag for check if a element wasn't created
Definition: AdditionalHandler.cpp:725
AdditionalHandler::parseEntryAttributes
void parseEntryAttributes(const SUMOSAXAttributes &attrs)
parse entry attributes
Definition: AdditionalHandler.cpp:1143
AdditionalHandler::buildTAZSource
virtual void buildTAZSource(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &edgeID, const double departWeight)=0
Builds a TAZSource (Traffic Assignment Zone)
AdditionalHandler::parsePolyAttributes
void parsePolyAttributes(const SUMOSAXAttributes &attrs)
Definition: AdditionalHandler.cpp:1723
AdditionalHandler::parseClosingRerouteAttributes
void parseClosingRerouteAttributes(const SUMOSAXAttributes &attrs)
parse closing reroute attributes
Definition: AdditionalHandler.cpp:1497
AdditionalHandler::buildPolygon
virtual void buildPolygon(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &type, const RGBColor &color, const double layer, const double angle, const std::string &imgFile, const bool relativePath, const PositionVector &shape, const bool geo, const bool fill, const double lineWidth, const std::string &name, const Parameterised::Map &parameters)=0
Builds a polygon using the given values.
CommonXMLStructure::SumoBaseObject::addIntAttribute
void addIntAttribute(const SumoXMLAttr attr, const int value)
add int attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:622
CommonXMLStructure::SumoBaseObject::getColorAttribute
const RGBColor & getColorAttribute(const SumoXMLAttr attr) const
get color attribute
Definition: CommonXMLStructure.cpp:457
CommonXMLStructure::SumoBaseObject::getTimeAttribute
SUMOTime getTimeAttribute(const SumoXMLAttr attr) const
get time attribute
Definition: CommonXMLStructure.cpp:429
CommonXMLStructure::SumoBaseObject::getPositionVectorAttribute
const PositionVector & getPositionVectorAttribute(const SumoXMLAttr attr) const
get PositionVector attribute
Definition: CommonXMLStructure.cpp:490
CommonXMLStructure::SumoBaseObject::hasStringAttribute
bool hasStringAttribute(const SumoXMLAttr attr) const
has function
Definition: CommonXMLStructure.cpp:556
CommonXMLStructure::SumoBaseObject::setTag
void setTag(const SumoXMLTag tag)
set SumoBaseObject tag
Definition: CommonXMLStructure.cpp:319
CommonXMLStructure::SumoBaseObject::getParentSumoBaseObject
SumoBaseObject * getParentSumoBaseObject() const
get pointer to mySumoBaseObjectParent SumoBaseObject (if is null, then is the root)
Definition: CommonXMLStructure.cpp:331
CommonXMLStructure::SumoBaseObject::getPositionAttribute
const Position & getPositionAttribute(const SumoXMLAttr attr) const
get Position attribute
Definition: CommonXMLStructure.cpp:418
CommonXMLStructure::SumoBaseObject::addPositionVectorAttribute
void addPositionVectorAttribute(const SumoXMLAttr attr, const PositionVector &value)
add PositionVector attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:670
CommonXMLStructure::SumoBaseObject::getParameters
const std::map< std::string, std::string > & getParameters() const
get parameters
Definition: CommonXMLStructure.cpp:538
CommonXMLStructure::SumoBaseObject::addBoolAttribute
void addBoolAttribute(const SumoXMLAttr attr, const bool value)
add bool attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:634
CommonXMLStructure::SumoBaseObject::getTag
SumoXMLTag getTag() const
get XML myTag
Definition: CommonXMLStructure.cpp:325
CommonXMLStructure::SumoBaseObject::addTimeAttribute
void addTimeAttribute(const SumoXMLAttr attr, const SUMOTime value)
add time attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:646
CommonXMLStructure::SumoBaseObject::addStringListAttribute
void addStringListAttribute(const SumoXMLAttr attr, const std::vector< std::string > &value)
add string list attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:658
CommonXMLStructure::SumoBaseObject::getIntAttribute
int getIntAttribute(const SumoXMLAttr attr) const
get int attribute
Definition: CommonXMLStructure.cpp:385
CommonXMLStructure::SumoBaseObject::addDoubleAttribute
void addDoubleAttribute(const SumoXMLAttr attr, const double value)
add double attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:628
CommonXMLStructure::SumoBaseObject::hasDoubleAttribute
bool hasDoubleAttribute(const SumoXMLAttr attr) const
check if current SumoBaseObject has the given double attribute
Definition: CommonXMLStructure.cpp:568
CommonXMLStructure::SumoBaseObject::addPositionAttribute
void addPositionAttribute(const SumoXMLAttr attr, const Position &value)
add Position attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:640
CommonXMLStructure::SumoBaseObject::getBoolAttribute
bool getBoolAttribute(const SumoXMLAttr attr) const
get bool attribute
Definition: CommonXMLStructure.cpp:407
CommonXMLStructure::SumoBaseObject::getPeriodAttribute
SUMOTime getPeriodAttribute() const
get 'period' attribute
Definition: CommonXMLStructure.cpp:440
CommonXMLStructure::SumoBaseObject::setVehicleParameter
void setVehicleParameter(const SUMOVehicleParameter *vehicleParameter)
set vehicle parameters
Definition: CommonXMLStructure.cpp:706
CommonXMLStructure::SumoBaseObject::addStringAttribute
void addStringAttribute(const SumoXMLAttr attr, const std::string &value)
add string attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:616
CommonXMLStructure::SumoBaseObject::getDoubleAttribute
double getDoubleAttribute(const SumoXMLAttr attr) const
get double attribute
Definition: CommonXMLStructure.cpp:396
CommonXMLStructure::SumoBaseObject::getVehicleParameter
const SUMOVehicleParameter & getVehicleParameter() const
get vehicle parameters
Definition: CommonXMLStructure.cpp:517
CommonXMLStructure::SumoBaseObject::getStringListAttribute
const std::vector< std::string > & getStringListAttribute(const SumoXMLAttr attr) const
get string list attribute
Definition: CommonXMLStructure.cpp:468
CommonXMLStructure::SumoBaseObject::addColorAttribute
void addColorAttribute(const SumoXMLAttr attr, const RGBColor &value)
add color attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:652
CommonXMLStructure::SumoBaseObject::getStringAttribute
const std::string & getStringAttribute(const SumoXMLAttr attr) const
get string attribute
Definition: CommonXMLStructure.cpp:374
CommonXMLStructure::SumoBaseObject::getSumoBaseObjectChildren
const std::vector< SumoBaseObject * > & getSumoBaseObjectChildren() const
get SumoBaseObject children
Definition: CommonXMLStructure.cpp:550
CommonXMLStructure::getCurrentSumoBaseObject
CommonXMLStructure::SumoBaseObject * getCurrentSumoBaseObject() const
get current editedSumoBaseObject
Definition: CommonXMLStructure.cpp:841
CommonXMLStructure::openSUMOBaseOBject
void openSUMOBaseOBject()
open SUMOBaseOBject
Definition: CommonXMLStructure.cpp:799
CommonXMLStructure::closeSUMOBaseOBject
void closeSUMOBaseOBject()
close myTag
Definition: CommonXMLStructure.cpp:818
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
Position::INVALID
static const Position INVALID
used to indicate that a position is valid
Definition: Position.h:322
PositionVector
A list of positions.
Definition: PositionVector.h:43
RGBColor::INVISIBLE
static const RGBColor INVISIBLE
Definition: RGBColor.h:195
RGBColor::RED
static const RGBColor RED
named colors
Definition: RGBColor.h:185
SUMOSAXAttributes
Encapsulated SAX-Attributes.
Definition: SUMOSAXAttributes.h:56
SUMOSAXAttributes::getString
virtual std::string getString(int id, bool *isPresent=nullptr) const =0
Returns the string-value of the named (by its enum-value) attribute.
SUMOSAXAttributes::getOptPeriod
SUMOTime getOptPeriod(const char *objectid, bool &ok, SUMOTime defaultValue, bool report=true) const
Tries to read the SUMOTime 'period' attribute.
Definition: SUMOSAXAttributes.cpp:147
SUMOSAXAttributes::getOpt
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue=T(), bool report=true) const
Tries to read given attribute assuming it is an int.
Definition: SUMOSAXAttributes.h:459
SUMOSAXAttributes::getOptSUMOTimeReporting
SUMOTime getOptSUMOTimeReporting(int attr, const char *objectid, bool &ok, SUMOTime defaultValue, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
Definition: SUMOSAXAttributes.cpp:123
SUMOSAXAttributes::get
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
Definition: SUMOSAXAttributes.h:433
SUMOSAXAttributes::hasAttribute
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
SUMOSAXAttributes::getSUMOTimeReporting
SUMOTime getSUMOTimeReporting(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
Definition: SUMOSAXAttributes.cpp:60
SUMOVehicleParameter
Structure representing possible vehicle parameter.
Definition: SUMOVehicleParameter.h:332
SUMOVehicleParameter::parametersSet
int parametersSet
Information for the router which parameter were set, TraCI may modify this (when changing color)
Definition: SUMOVehicleParameter.h:815
SUMOVehicleParameter::repetitionOffset
SUMOTime repetitionOffset
The time offset between vehicle reinsertions.
Definition: SUMOVehicleParameter.h:759
SUMOVehicleParameter::repetitionEnd
SUMOTime repetitionEnd
The time at which the flow ends (only needed when using repetitionProbability)
Definition: SUMOVehicleParameter.h:771
SUMOVehicleParameter::calibratorSpeed
double calibratorSpeed
speed (used by calibrator flows
Definition: SUMOVehicleParameter.h:809
SUMOVehicleParserHelper::parseVehicleAttributes
static SUMOVehicleParameter * parseVehicleAttributes(int element, const SUMOSAXAttributes &attrs, const bool hardFail, const bool optionalID=false, const bool skipDepart=false, const bool allowInternalRoutes=false)
Parses a vehicle's attributes.
Definition: SUMOVehicleParserHelper.cpp:334
SUMOXMLDefinitions::PersonModeValues
static StringBijection< PersonMode > PersonModeValues
person modes
Definition: SUMOXMLDefinitions.h:2257
SUMOXMLDefinitions::POIIcons
static StringBijection< POIIcon > POIIcons
POI icon values.
Definition: SUMOXMLDefinitions.h:2287
SUMOXMLDefinitions::isValidParameterKey
static bool isValidParameterKey(const std::string &value)
whether the given string is a valid key for a parameter
Definition: SUMOXMLDefinitions.cpp:1791
Shape::DEFAULT_RELATIVEPATH
static const bool DEFAULT_RELATIVEPATH
Definition: Shape.h:48
Shape::DEFAULT_LAYER
static const double DEFAULT_LAYER
Definition: Shape.h:43
Shape::DEFAULT_LAYER_POI
static const double DEFAULT_LAYER_POI
Definition: Shape.h:45
Shape::DEFAULT_IMG_WIDTH
static const double DEFAULT_IMG_WIDTH
Definition: Shape.h:49
Shape::DEFAULT_IMG_FILE
static const std::string DEFAULT_IMG_FILE
Definition: Shape.h:47
Shape::DEFAULT_LINEWIDTH
static const double DEFAULT_LINEWIDTH
Definition: Shape.h:44
Shape::DEFAULT_ANGLE
static const double DEFAULT_ANGLE
Definition: Shape.h:46
Shape::DEFAULT_IMG_HEIGHT
static const double DEFAULT_IMG_HEIGHT
Definition: Shape.h:50
Shape::DEFAULT_TYPE
static const std::string DEFAULT_TYPE
Definition: Shape.h:42
StringBijection::hasString
bool hasString(const std::string &str) const
Definition: StringBijection.h:114
StringBijection::getString
const std::string & getString(const T key) const
Definition: StringBijection.h:104