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