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