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