Eclipse SUMO - Simulation of Urban MObility
GNEAdditionalHandler.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
14 // Builds trigger objects for netedit
15 /****************************************************************************/
16 
17 // ===========================================================================
18 // included modules
19 // ===========================================================================
20 #include <config.h>
21 #include <utils/xml/XMLSubSys.h>
25 #include <netedit/GNEViewNet.h>
26 #include <netedit/GNEUndoList.h>
27 #include <netedit/GNENet.h>
30 
31 #include "GNEAdditionalHandler.h"
32 #include "GNEBusStop.h"
33 #include "GNEAccess.h"
34 #include "GNECalibrator.h"
35 #include "GNECalibratorFlow.h"
36 #include "GNEChargingStation.h"
37 #include "GNEClosingLaneReroute.h"
38 #include "GNEClosingReroute.h"
39 #include "GNEContainerStop.h"
40 #include "GNEDestProbReroute.h"
41 #include "GNEDetectorE1.h"
42 #include "GNEDetectorE2.h"
43 #include "GNEDetectorE3.h"
44 #include "GNEDetectorEntryExit.h"
45 #include "GNEDetectorE1Instant.h"
46 #include "GNEParkingArea.h"
47 #include "GNEParkingSpace.h"
48 #include "GNERerouter.h"
49 #include "GNERerouterInterval.h"
50 #include "GNERouteProbReroute.h"
51 #include "GNEParkingAreaReroute.h"
52 #include "GNERouteProbe.h"
53 #include "GNEVaporizer.h"
54 #include "GNEVariableSpeedSign.h"
56 #include "GNETAZ.h"
57 #include "GNETAZSourceSink.h"
58 
59 
60 // ===========================================================================
61 // GNEAdditionalHandler method definitions
62 // ===========================================================================
63 
64 GNEAdditionalHandler::GNEAdditionalHandler(const std::string& file, GNEViewNet* viewNet, GNEAdditional* additionalParent) :
65  ShapeHandler(file, *viewNet->getNet()),
66  myViewNet(viewNet) {
67  // check if we're loading values of another additionals (example: Rerouter values)
68  if (additionalParent) {
71  }
72  // define default values for shapes
74 }
75 
76 
78 
79 
80 void
82  // Obtain tag of element
83  SumoXMLTag tag = static_cast<SumoXMLTag>(element);
84  // check if we're parsing a parameter
85  if (tag == SUMO_TAG_PARAM) {
86  // push element int stack
88  // parse parameter
89  parseParameter(attrs);
90  } else if (tag != SUMO_TAG_NOTHING) {
91  // push element int stack
92  if (tag == SUMO_TAG_TRAIN_STOP) {
93  // ensure that access elements can find their parent in myHierarchyInsertedAdditionals
94  tag = SUMO_TAG_BUS_STOP;
95  }
97  // Call parse and build depending of tag
98  switch (tag) {
99  case SUMO_TAG_POLY:
100  return parseAndBuildPoly(attrs);
101  case SUMO_TAG_POI:
102  return parseAndBuildPOI(attrs);
103  default:
104  // build additional
106  }
107  }
108 }
109 
110 
111 void
113  // Obtain tag of element
114  SumoXMLTag tag = static_cast<SumoXMLTag>(element);
115  switch (tag) {
116  case SUMO_TAG_TAZ: {
117  GNETAZ* TAZ = dynamic_cast<GNETAZ*>(myHierarchyInsertedAdditionals.getLastInsertedAdditional());
118  if (TAZ != nullptr) {
119  if (TAZ->getTAZShape().size() == 0) {
120  Boundary b;
121  if (TAZ->getChildAdditionals().size() > 0) {
122  for (const auto& i : TAZ->getChildAdditionals()) {
123  b.add(i->getCenteringBoundary());
124  }
125  PositionVector boundaryShape;
126  boundaryShape.push_back(Position(b.xmin(), b.ymin()));
127  boundaryShape.push_back(Position(b.xmax(), b.ymin()));
128  boundaryShape.push_back(Position(b.xmax(), b.ymax()));
129  boundaryShape.push_back(Position(b.xmin(), b.ymax()));
130  boundaryShape.push_back(Position(b.xmin(), b.ymin()));
131  TAZ->setAttribute(SUMO_ATTR_SHAPE, toString(boundaryShape), myViewNet->getUndoList());
132  }
133  }
134  }
135  break;
136  }
137  default:
138  break;
139  }
140  // pop last inserted element
142  // execute myEndElement of ShapeHandler (needed to update myLastParameterised)
144 }
145 
146 
147 Position
148 GNEAdditionalHandler::getLanePos(const std::string& poiID, const std::string& laneID, double lanePos, double lanePosLat) {
149  std::string edgeID;
150  int laneIndex;
151  NBHelpers::interpretLaneID(laneID, edgeID, laneIndex);
152  NBEdge* edge = myViewNet->getNet()->retrieveEdge(edgeID)->getNBEdge();
153  if (edge == nullptr || laneIndex < 0 || edge->getNumLanes() <= laneIndex) {
154  WRITE_ERROR("Lane '" + laneID + "' to place poi '" + poiID + "' on is not known.");
155  return Position::INVALID;
156  }
157  if (lanePos < 0) {
158  lanePos = edge->getLength() + lanePos;
159  }
160  if (lanePos < 0 || lanePos > edge->getLength()) {
161  WRITE_WARNING("lane position " + toString(lanePos) + " for poi '" + poiID + "' is not valid.");
162  }
163  return edge->getLanes()[laneIndex].shape.positionAtOffset(lanePos, -lanePosLat);
164 }
165 
166 
167 bool
168 GNEAdditionalHandler::buildAdditional(GNEViewNet* viewNet, bool allowUndoRedo, SumoXMLTag tag, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
169  // Call parse and build depending of tag
170  switch (tag) {
171  case SUMO_TAG_BUS_STOP:
172  case SUMO_TAG_TRAIN_STOP:
173  return parseAndBuildBusStop(viewNet, allowUndoRedo, attrs, insertedAdditionals);
174  case SUMO_TAG_ACCESS:
175  return parseAndBuildAccess(viewNet, allowUndoRedo, attrs, insertedAdditionals);
177  return parseAndBuildContainerStop(viewNet, allowUndoRedo, attrs, insertedAdditionals);
179  return parseAndBuildChargingStation(viewNet, allowUndoRedo, attrs, insertedAdditionals);
180  case SUMO_TAG_E1DETECTOR:
182  return parseAndBuildDetectorE1(viewNet, allowUndoRedo, attrs, insertedAdditionals);
183  case SUMO_TAG_E2DETECTOR:
186  return parseAndBuildDetectorE2(viewNet, allowUndoRedo, attrs, insertedAdditionals);
187  case SUMO_TAG_E3DETECTOR:
189  return parseAndBuildDetectorE3(viewNet, allowUndoRedo, attrs, insertedAdditionals);
190  case SUMO_TAG_DET_ENTRY:
191  return parseAndBuildDetectorEntry(viewNet, allowUndoRedo, attrs, insertedAdditionals);
192  case SUMO_TAG_DET_EXIT:
193  return parseAndBuildDetectorExit(viewNet, allowUndoRedo, attrs, insertedAdditionals);
195  return parseAndBuildDetectorE1Instant(viewNet, allowUndoRedo, attrs, insertedAdditionals);
196  case SUMO_TAG_ROUTEPROBE:
197  return parseAndBuildRouteProbe(viewNet, allowUndoRedo, attrs, insertedAdditionals);
198  case SUMO_TAG_VAPORIZER:
199  return parseAndBuildVaporizer(viewNet, allowUndoRedo, attrs, insertedAdditionals);
200  case SUMO_TAG_TAZ:
201  return parseAndBuildTAZ(viewNet, allowUndoRedo, attrs, insertedAdditionals);
202  case SUMO_TAG_TAZSOURCE:
203  return parseAndBuildTAZSource(viewNet, allowUndoRedo, attrs, insertedAdditionals);
204  case SUMO_TAG_TAZSINK:
205  return parseAndBuildTAZSink(viewNet, allowUndoRedo, attrs, insertedAdditionals);
206  case SUMO_TAG_VSS:
207  return parseAndBuildVariableSpeedSign(viewNet, allowUndoRedo, attrs, insertedAdditionals);
208  case SUMO_TAG_STEP:
209  return parseAndBuildVariableSpeedSignStep(viewNet, allowUndoRedo, attrs, insertedAdditionals);
210  case SUMO_TAG_CALIBRATOR:
212  return parseAndBuildCalibrator(viewNet, allowUndoRedo, attrs, insertedAdditionals);
214  return parseAndBuildParkingArea(viewNet, allowUndoRedo, attrs, insertedAdditionals);
216  return parseAndBuildParkingSpace(viewNet, allowUndoRedo, attrs, insertedAdditionals);
218  return parseAndBuildCalibratorFlow(viewNet, allowUndoRedo, attrs, insertedAdditionals);
219  case SUMO_TAG_REROUTER:
220  return parseAndBuildRerouter(viewNet, allowUndoRedo, attrs, insertedAdditionals);
221  case SUMO_TAG_INTERVAL:
222  return parseAndBuildRerouterInterval(viewNet, allowUndoRedo, attrs, insertedAdditionals);
224  return parseAndBuildRerouterClosingLaneReroute(viewNet, allowUndoRedo, attrs, insertedAdditionals);
226  return parseAndBuildRerouterClosingReroute(viewNet, allowUndoRedo, attrs, insertedAdditionals);
228  return parseAndBuildRerouterDestProbReroute(viewNet, allowUndoRedo, attrs, insertedAdditionals);
230  return parseAndBuildRerouterParkingAreaReroute(viewNet, allowUndoRedo, attrs, insertedAdditionals);
232  return parseAndBuildRerouterRouteProbReroute(viewNet, allowUndoRedo, attrs, insertedAdditionals);
233  default:
234  return false;
235  }
236 }
237 
238 
240 GNEAdditionalHandler::buildBusStop(GNEViewNet* viewNet, bool allowUndoRedo, const std::string& id, GNELane* lane, const double startPos, const double endPos, const int parametersSet,
241  const std::string& name, const std::vector<std::string>& lines, int personCapacity, bool friendlyPosition, bool blockMovement) {
242  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_BUS_STOP, id, false) == nullptr) {
243  GNEBusStop* busStop = new GNEBusStop(id, lane, viewNet, startPos, endPos, parametersSet, name, lines, personCapacity, friendlyPosition, blockMovement);
244  if (allowUndoRedo) {
245  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_BUS_STOP));
246  viewNet->getUndoList()->add(new GNEChange_Additional(busStop, true), true);
247  viewNet->getUndoList()->p_end();
248  } else {
249  viewNet->getNet()->insertAdditional(busStop);
250  lane->addChildAdditional(busStop);
251  busStop->incRef("buildBusStop");
252  }
253  return busStop;
254  } else {
255  throw ProcessError("Could not build " + toString(SUMO_TAG_BUS_STOP) + " with ID '" + id + "' in netedit; probably declared twice.");
256  }
257 }
258 
259 
261 GNEAdditionalHandler::buildAccess(GNEViewNet* viewNet, bool allowUndoRedo, GNEAdditional* busStop, GNELane* lane, double pos, const std::string& length, bool friendlyPos, bool blockMovement) {
262  // Check if busStop parent and lane is correct
263  if (lane == nullptr) {
264  throw ProcessError("Could not build " + toString(SUMO_TAG_ACCESS) + " in netedit; " + toString(SUMO_TAG_LANE) + " doesn't exist.");
265  } else if (busStop == nullptr) {
266  throw ProcessError("Could not build " + toString(SUMO_TAG_ACCESS) + " in netedit; " + toString(SUMO_TAG_BUS_STOP) + " parent doesn't exist.");
267  } else if (!accessCanBeCreated(busStop, lane->getParentEdge())) {
268  throw ProcessError("Could not build " + toString(SUMO_TAG_ACCESS) + " in netedit; " + toString(SUMO_TAG_BUS_STOP) + " parent already owns a Acces in the edge '" + lane->getParentEdge()->getID() + "'");
269  } else {
270  GNEAccess* access = new GNEAccess(busStop, lane, viewNet, pos, length, friendlyPos, blockMovement);
271  if (allowUndoRedo) {
272  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_ACCESS));
273  viewNet->getUndoList()->add(new GNEChange_Additional(access, true), true);
274  viewNet->getUndoList()->p_end();
275  } else {
276  viewNet->getNet()->insertAdditional(access);
277  lane->addChildAdditional(access);
278  busStop->addChildAdditional(access);
279  access->incRef("buildAccess");
280  }
281  return access;
282  }
283 }
284 
285 
287 GNEAdditionalHandler::buildContainerStop(GNEViewNet* viewNet, bool allowUndoRedo, const std::string& id, GNELane* lane, const double startPos, const double endPos, const int parametersSet,
288  const std::string& name, const std::vector<std::string>& lines, bool friendlyPosition, bool blockMovement) {
289  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_CONTAINER_STOP, id, false) == nullptr) {
290  GNEContainerStop* containerStop = new GNEContainerStop(id, lane, viewNet, startPos, endPos, parametersSet, name, lines, friendlyPosition, blockMovement);
291  if (allowUndoRedo) {
292  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_CONTAINER_STOP));
293  viewNet->getUndoList()->add(new GNEChange_Additional(containerStop, true), true);
294  viewNet->getUndoList()->p_end();
295  } else {
296  viewNet->getNet()->insertAdditional(containerStop);
297  lane->addChildAdditional(containerStop);
298  containerStop->incRef("buildContainerStop");
299  }
300  return containerStop;
301  } else {
302  throw ProcessError("Could not build " + toString(SUMO_TAG_CONTAINER_STOP) + " with ID '" + id + "' in netedit; probably declared twice.");
303  }
304 }
305 
306 
308 GNEAdditionalHandler::buildChargingStation(GNEViewNet* viewNet, bool allowUndoRedo, const std::string& id, GNELane* lane, const double startPos, const double endPos, const int parametersSet,
309  const std::string& name, double chargingPower, double efficiency, bool chargeInTransit, SUMOTime chargeDelay, bool friendlyPosition, bool blockMovement) {
310  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_CHARGING_STATION, id, false) == nullptr) {
311  GNEChargingStation* chargingStation = new GNEChargingStation(id, lane, viewNet, startPos, endPos, parametersSet, name, chargingPower, efficiency, chargeInTransit, chargeDelay, friendlyPosition, blockMovement);
312  if (allowUndoRedo) {
313  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_CHARGING_STATION));
314  viewNet->getUndoList()->add(new GNEChange_Additional(chargingStation, true), true);
315  viewNet->getUndoList()->p_end();
316  } else {
317  viewNet->getNet()->insertAdditional(chargingStation);
318  lane->addChildAdditional(chargingStation);
319  chargingStation->incRef("buildChargingStation");
320  }
321  return chargingStation;
322  } else {
323  throw ProcessError("Could not build " + toString(SUMO_TAG_CHARGING_STATION) + " with ID '" + id + "' in netedit; probably declared twice.");
324  }
325 }
326 
327 
329 GNEAdditionalHandler::buildParkingArea(GNEViewNet* viewNet, bool allowUndoRedo, const std::string& id, GNELane* lane, const double startPos, const double endPos, const int parametersSet,
330  const std::string& name, bool friendlyPosition, int roadSideCapacity, bool onRoad, double width, const std::string& length, double angle, bool blockMovement) {
331  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_PARKING_AREA, id, false) == nullptr) {
332  GNEParkingArea* parkingArea = new GNEParkingArea(id, lane, viewNet, startPos, endPos, parametersSet, name, friendlyPosition, roadSideCapacity, onRoad, width, length, angle, blockMovement);
333  if (allowUndoRedo) {
334  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_PARKING_AREA));
335  viewNet->getUndoList()->add(new GNEChange_Additional(parkingArea, true), true);
336  viewNet->getUndoList()->p_end();
337  } else {
338  viewNet->getNet()->insertAdditional(parkingArea);
339  lane->addChildAdditional(parkingArea);
340  parkingArea->incRef("buildParkingArea");
341  }
342  return parkingArea;
343  } else {
344  throw ProcessError("Could not build " + toString(SUMO_TAG_PARKING_AREA) + " with ID '" + id + "' in netedit; probably declared twice.");
345  }
346 }
347 
348 
350 GNEAdditionalHandler::buildParkingSpace(GNEViewNet* viewNet, bool allowUndoRedo, GNEAdditional* parkingAreaParent, Position pos, double width, double length, double angle, bool blockMovement) {
351  GNEParkingSpace* parkingSpace = new GNEParkingSpace(viewNet, parkingAreaParent, pos, width, length, angle, blockMovement);
352  if (allowUndoRedo) {
353  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_PARKING_SPACE));
354  viewNet->getUndoList()->add(new GNEChange_Additional(parkingSpace, true), true);
355  viewNet->getUndoList()->p_end();
356  } else {
357  viewNet->getNet()->insertAdditional(parkingSpace);
358  parkingAreaParent->addChildAdditional(parkingSpace);
359  parkingSpace->incRef("buildParkingSpace");
360  }
361  return parkingSpace;
362 }
363 
364 
366 GNEAdditionalHandler::buildDetectorE1(GNEViewNet* viewNet, bool allowUndoRedo, const std::string& id, GNELane* lane, double pos, SUMOTime freq, const std::string& filename, const std::string& vehicleTypes, const std::string& name, bool friendlyPos, bool blockMovement) {
367  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_E1DETECTOR, id, false) == nullptr) {
368  GNEDetectorE1* detectorE1 = new GNEDetectorE1(id, lane, viewNet, pos, freq, filename, vehicleTypes, name, friendlyPos, blockMovement);
369  if (allowUndoRedo) {
370  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_E1DETECTOR));
371  viewNet->getUndoList()->add(new GNEChange_Additional(detectorE1, true), true);
372  viewNet->getUndoList()->p_end();
373  } else {
374  viewNet->getNet()->insertAdditional(detectorE1);
375  lane->addChildAdditional(detectorE1);
376  detectorE1->incRef("buildDetectorE1");
377  }
378  return detectorE1;
379  } else {
380  throw ProcessError("Could not build " + toString(SUMO_TAG_E1DETECTOR) + " with ID '" + id + "' in netedit; probably declared twice.");
381  }
382 }
383 
384 
386 GNEAdditionalHandler::buildSingleLaneDetectorE2(GNEViewNet* viewNet, bool allowUndoRedo, const std::string& id, GNELane* lane, double pos, double length, SUMOTime freq, const std::string& filename,
387  const std::string& vehicleTypes, const std::string& name, SUMOTime timeThreshold, double speedThreshold, double jamThreshold, bool friendlyPos, bool blockMovement) {
388  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_E2DETECTOR, id, false) == nullptr) {
389  GNEDetectorE2* detectorE2 = new GNEDetectorE2(id, lane, viewNet, pos, length, freq, filename, vehicleTypes, name, timeThreshold, speedThreshold, jamThreshold, friendlyPos, blockMovement);
390  if (allowUndoRedo) {
391  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_E2DETECTOR));
392  viewNet->getUndoList()->add(new GNEChange_Additional(detectorE2, true), true);
393  viewNet->getUndoList()->p_end();
394  } else {
395  viewNet->getNet()->insertAdditional(detectorE2);
396  lane->addChildAdditional(detectorE2);
397  detectorE2->incRef("buildDetectorE2");
398  }
399  return detectorE2;
400  } else {
401  throw ProcessError("Could not build " + toString(SUMO_TAG_E2DETECTOR) + " with ID '" + id + "' in netedit; probably declared twice.");
402  }
403 }
404 
405 
407 GNEAdditionalHandler::buildMultiLaneDetectorE2(GNEViewNet* viewNet, bool allowUndoRedo, const std::string& id, const std::vector<GNELane*>& lanes, double pos, double endPos, SUMOTime freq, const std::string& filename,
408  const std::string& vehicleTypes, const std::string& name, SUMOTime timeThreshold, double speedThreshold, double jamThreshold, bool friendlyPos, bool blockMovement) {
409  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_E2DETECTOR_MULTILANE, id, false) == nullptr) {
410  GNEDetectorE2* detectorE2 = new GNEDetectorE2(id, lanes, viewNet, pos, endPos, freq, filename, vehicleTypes, name, timeThreshold, speedThreshold, jamThreshold, friendlyPos, blockMovement);
411  if (allowUndoRedo) {
413  viewNet->getUndoList()->add(new GNEChange_Additional(detectorE2, true), true);
414  viewNet->getUndoList()->p_end();
415  } else {
416  viewNet->getNet()->insertAdditional(detectorE2);
417  for (auto i : lanes) {
418  i->addChildAdditional(detectorE2);
419  }
420  detectorE2->incRef("buildDetectorE2Multilane");
421  }
422  // check E2 integrity
423  detectorE2->checkE2MultilaneIntegrity();
424  return detectorE2;
425  } else {
426  throw ProcessError("Could not build " + toString(SUMO_TAG_E2DETECTOR_MULTILANE) + " with ID '" + id + "' in netedit; probably declared twice.");
427  }
428 }
429 
430 
432 GNEAdditionalHandler::buildDetectorE3(GNEViewNet* viewNet, bool allowUndoRedo, const std::string& id, Position pos, SUMOTime freq, const std::string& filename, const std::string& vehicleTypes,
433  const std::string& name, SUMOTime timeThreshold, double speedThreshold, bool blockMovement) {
434  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_E3DETECTOR, id, false) == nullptr) {
435  GNEDetectorE3* detectorE3 = new GNEDetectorE3(id, viewNet, pos, freq, filename, vehicleTypes, name, timeThreshold, speedThreshold, blockMovement);
436  if (allowUndoRedo) {
437  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_E3DETECTOR));
438  viewNet->getUndoList()->add(new GNEChange_Additional(detectorE3, true), true);
439  viewNet->getUndoList()->p_end();
440  } else {
441  viewNet->getNet()->insertAdditional(detectorE3);
442  detectorE3->incRef("buildDetectorE3");
443  }
444  return detectorE3;
445  } else {
446  throw ProcessError("Could not build " + toString(SUMO_TAG_E3DETECTOR) + " with ID '" + id + "' in netedit; probably declared twice.");
447  }
448 }
449 
450 
452 GNEAdditionalHandler::buildDetectorEntry(GNEViewNet* viewNet, bool allowUndoRedo, GNEAdditional* E3Parent, GNELane* lane, double pos, bool friendlyPos, bool blockMovement) {
453  // Check if Detector E3 parent and lane is correct
454  if (lane == nullptr) {
455  throw ProcessError("Could not build " + toString(SUMO_TAG_DET_ENTRY) + " in netedit; " + toString(SUMO_TAG_LANE) + " doesn't exist.");
456  } else if (E3Parent == nullptr) {
457  throw ProcessError("Could not build " + toString(SUMO_TAG_DET_ENTRY) + " in netedit; " + toString(SUMO_TAG_E3DETECTOR) + " parent doesn't exist.");
458  } else {
459  GNEDetectorEntryExit* entry = new GNEDetectorEntryExit(SUMO_TAG_DET_ENTRY, viewNet, E3Parent, lane, pos, friendlyPos, blockMovement);
460  if (allowUndoRedo) {
461  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_DET_ENTRY));
462  viewNet->getUndoList()->add(new GNEChange_Additional(entry, true), true);
463  viewNet->getUndoList()->p_end();
464  } else {
465  viewNet->getNet()->insertAdditional(entry);
466  lane->addChildAdditional(entry);
467  E3Parent->addChildAdditional(entry);
468  entry->incRef("buildDetectorEntry");
469  }
470  return entry;
471  }
472 }
473 
474 
476 GNEAdditionalHandler::buildDetectorExit(GNEViewNet* viewNet, bool allowUndoRedo, GNEAdditional* E3Parent, GNELane* lane, double pos, bool friendlyPos, bool blockMovement) {
477  // Check if Detector E3 parent and lane is correct
478  if (lane == nullptr) {
479  throw ProcessError("Could not build " + toString(SUMO_TAG_DET_EXIT) + " in netedit; " + toString(SUMO_TAG_LANE) + " doesn't exist.");
480  } else if (E3Parent == nullptr) {
481  throw ProcessError("Could not build " + toString(SUMO_TAG_DET_EXIT) + " in netedit; " + toString(SUMO_TAG_E3DETECTOR) + " parent doesn't exist.");
482  } else {
483  GNEDetectorEntryExit* exit = new GNEDetectorEntryExit(SUMO_TAG_DET_EXIT, viewNet, E3Parent, lane, pos, friendlyPos, blockMovement);
484  if (allowUndoRedo) {
485  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_DET_EXIT));
486  viewNet->getUndoList()->add(new GNEChange_Additional(exit, true), true);
487  viewNet->getUndoList()->p_end();
488  } else {
489  viewNet->getNet()->insertAdditional(exit);
490  lane->addChildAdditional(exit);
491  E3Parent->addChildAdditional(exit);
492  exit->incRef("buildDetectorExit");
493  }
494  return exit;
495  }
496 }
497 
498 
500 GNEAdditionalHandler::buildDetectorE1Instant(GNEViewNet* viewNet, bool allowUndoRedo, const std::string& id, GNELane* lane, double pos, const std::string& filename, const std::string& vehicleTypes, const std::string& name, bool friendlyPos, bool blockMovement) {
501  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_INSTANT_INDUCTION_LOOP, id, false) == nullptr) {
502  GNEDetectorE1Instant* detectorE1Instant = new GNEDetectorE1Instant(id, lane, viewNet, pos, filename, vehicleTypes, name, friendlyPos, blockMovement);
503  if (allowUndoRedo) {
505  viewNet->getUndoList()->add(new GNEChange_Additional(detectorE1Instant, true), true);
506  viewNet->getUndoList()->p_end();
507  } else {
508  viewNet->getNet()->insertAdditional(detectorE1Instant);
509  lane->addChildAdditional(detectorE1Instant);
510  detectorE1Instant->incRef("buildDetectorE1Instant");
511  }
512  return detectorE1Instant;
513  } else {
514  throw ProcessError("Could not build " + toString(SUMO_TAG_INSTANT_INDUCTION_LOOP) + " with ID '" + id + "' in netedit; probably declared twice.");
515  }
516 }
517 
518 
520 GNEAdditionalHandler::buildCalibrator(GNEViewNet* viewNet, bool allowUndoRedo, const std::string& id, GNELane* lane, double pos, const std::string& name, const std::string& outfile, const SUMOTime freq, const std::string& routeprobe, bool centerAfterCreation) {
521  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_CALIBRATOR, id, false) == nullptr) {
522  GNECalibrator* calibrator = new GNECalibrator(id, viewNet, lane, pos, freq, name, outfile, routeprobe);
523  if (allowUndoRedo) {
524  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_CALIBRATOR));
525  viewNet->getUndoList()->add(new GNEChange_Additional(calibrator, true), true);
526  viewNet->getUndoList()->p_end();
527  // center after creation
528  if (centerAfterCreation) {
529  viewNet->centerTo(calibrator->getPositionInView(), false);
530  }
531  } else {
532  viewNet->getNet()->insertAdditional(calibrator);
533  lane->addChildAdditional(calibrator);
534  calibrator->incRef("buildCalibrator");
535  }
536  return calibrator;
537  } else {
538  throw ProcessError("Could not build " + toString(SUMO_TAG_CALIBRATOR) + " with ID '" + id + "' in netedit; probably declared twice.");
539  }
540 }
541 
542 
544 GNEAdditionalHandler::buildCalibrator(GNEViewNet* viewNet, bool allowUndoRedo, const std::string& id, GNEEdge* edge, double pos, const std::string& name, const std::string& outfile, const SUMOTime freq, const std::string& routeprobe, bool centerAfterCreation) {
545  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_CALIBRATOR, id, false) == nullptr) {
546  GNECalibrator* calibrator = new GNECalibrator(id, viewNet, edge, pos, freq, name, outfile, routeprobe);
547  if (allowUndoRedo) {
548  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_CALIBRATOR));
549  viewNet->getUndoList()->add(new GNEChange_Additional(calibrator, true), true);
550  viewNet->getUndoList()->p_end();
551  // center after creation
552  if (centerAfterCreation) {
553  viewNet->centerTo(calibrator->getPositionInView(), false);
554  }
555  } else {
556  viewNet->getNet()->insertAdditional(calibrator);
557  edge->addChildAdditional(calibrator);
558  calibrator->incRef("buildCalibrator");
559  }
560  return calibrator;
561  } else {
562  throw ProcessError("Could not build " + toString(SUMO_TAG_CALIBRATOR) + " with ID '" + id + "' in netedit; probably declared twice.");
563  }
564 }
565 
566 
568 GNEAdditionalHandler::buildCalibratorFlow(GNEViewNet* viewNet, bool allowUndoRedo, GNEAdditional* calibratorParent, GNEDemandElement* route, GNEDemandElement* vType,
569  const std::string& vehsPerHour, const std::string& speed, const RGBColor& color, const std::string& departLane, const std::string& departPos,
570  const std::string& departSpeed, const std::string& arrivalLane, const std::string& arrivalPos, const std::string& arrivalSpeed, const std::string& line,
571  int personNumber, int containerNumber, bool reroute, const std::string& departPosLat, const std::string& arrivalPosLat, SUMOTime begin, SUMOTime end) {
572 
573  // create Flow and add it to calibrator parent
574  GNECalibratorFlow* flow = new GNECalibratorFlow(calibratorParent, vType, route, vehsPerHour, speed, color, departLane, departPos, departSpeed,
575  arrivalLane, arrivalPos, arrivalSpeed, line, personNumber, containerNumber, reroute,
576  departPosLat, arrivalPosLat, begin, end);
577  if (allowUndoRedo) {
578  viewNet->getUndoList()->p_begin("add " + flow->getTagStr());
579  viewNet->getUndoList()->add(new GNEChange_Additional(flow, true), true);
580  viewNet->getUndoList()->p_end();
581  } else {
582  calibratorParent->addChildAdditional(flow);
583  flow->incRef("buildCalibratorFlow");
584  }
585  return flow;
586 }
587 
588 
590 GNEAdditionalHandler::buildRerouter(GNEViewNet* viewNet, bool allowUndoRedo, const std::string& id, Position pos, const std::vector<GNEEdge*>& edges, double prob, const std::string& name, const std::string& file, bool off, SUMOTime timeThreshold, const std::string& vTypes, bool blockMovement) {
591  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_REROUTER, id, false) == nullptr) {
592  GNERerouter* rerouter = new GNERerouter(id, viewNet, pos, edges, name, file, prob, off, timeThreshold, vTypes, blockMovement);
593  if (allowUndoRedo) {
594  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_REROUTER));
595  viewNet->getUndoList()->add(new GNEChange_Additional(rerouter, true), true);
596  viewNet->getUndoList()->p_end();
597  } else {
598  viewNet->getNet()->insertAdditional(rerouter);
599  // add this rerouter as parent of all edges
600  for (auto i : edges) {
601  i->addParentAdditional(rerouter);
602  }
603  rerouter->incRef("buildRerouter");
604  }
605  // parse rerouter children
606  if (!file.empty()) {
607  // we assume that rerouter values files is placed in the same folder as the additional file
608  std::string currentAdditionalFilename = FileHelpers::getFilePath(OptionsCont::getOptions().getString("additional-files"));
609  // Create additional handler for parse rerouter values
610  GNEAdditionalHandler rerouterValuesHandler(currentAdditionalFilename + file, viewNet, rerouter);
611  // disable validation for rerouters
612  XMLSubSys::setValidation("never", "auto");
613  // Run parser
614  if (!XMLSubSys::runParser(rerouterValuesHandler, currentAdditionalFilename + file, false)) {
615  WRITE_MESSAGE("Loading of " + file + " failed.");
616  }
617  // enable validation for rerouters
618  XMLSubSys::setValidation("auto", "auto");
619  }
620  return rerouter;
621  } else {
622  throw ProcessError("Could not build " + toString(SUMO_TAG_REROUTER) + " with ID '" + id + "' in netedit; probably declared twice.");
623  }
624 }
625 
626 
628 GNEAdditionalHandler::buildRerouterInterval(GNEViewNet* viewNet, bool allowUndoRedo, GNEAdditional* rerouterParent, SUMOTime begin, SUMOTime end) {
629  // check if new interval will produce a overlapping
630  if (checkOverlappingRerouterIntervals(rerouterParent, begin, end)) {
631  // create rerouter interval and add it into rerouter parent
632  GNERerouterInterval* rerouterInterval = new GNERerouterInterval(rerouterParent, begin, end);
633  if (allowUndoRedo) {
634  viewNet->getUndoList()->p_begin("add " + rerouterInterval->getTagStr());
635  viewNet->getUndoList()->add(new GNEChange_Additional(rerouterInterval, true), true);
636  viewNet->getUndoList()->p_end();
637  } else {
638  rerouterParent->addChildAdditional(rerouterInterval);
639  rerouterInterval->incRef("buildRerouterInterval");
640  }
641  return rerouterInterval;
642  } else {
643  throw ProcessError("Could not build " + toString(SUMO_TAG_INTERVAL) + " with begin '" + toString(begin) + "' and '" + toString(end) + "' in '" + rerouterParent->getID() + "' due overlapping.");
644  }
645 }
646 
647 
649 GNEAdditionalHandler::buildClosingLaneReroute(GNEViewNet* viewNet, bool allowUndoRedo, GNEAdditional* rerouterIntervalParent, GNELane* closedLane, SVCPermissions permissions) {
650  // create closing lane reorute
651  GNEClosingLaneReroute* closingLaneReroute = new GNEClosingLaneReroute(rerouterIntervalParent, closedLane, permissions);
652  // add it to interval parent depending of allowUndoRedo
653  if (allowUndoRedo) {
654  viewNet->getUndoList()->p_begin("add " + closingLaneReroute->getTagStr());
655  viewNet->getUndoList()->add(new GNEChange_Additional(closingLaneReroute, true), true);
656  viewNet->getUndoList()->p_end();
657  } else {
658  rerouterIntervalParent->addChildAdditional(closingLaneReroute);
659  closingLaneReroute->incRef("buildClosingLaneReroute");
660  }
661  return closingLaneReroute;
662 }
663 
664 
666 GNEAdditionalHandler::buildClosingReroute(GNEViewNet* viewNet, bool allowUndoRedo, GNEAdditional* rerouterIntervalParent, GNEEdge* closedEdge, SVCPermissions permissions) {
667  // create closing reroute
668  GNEClosingReroute* closingReroute = new GNEClosingReroute(rerouterIntervalParent, closedEdge, permissions);
669  // add it to interval parent depending of allowUndoRedo
670  if (allowUndoRedo) {
671  viewNet->getUndoList()->p_begin("add " + closingReroute->getTagStr());
672  viewNet->getUndoList()->add(new GNEChange_Additional(closingReroute, true), true);
673  viewNet->getUndoList()->p_end();
674  } else {
675  rerouterIntervalParent->addChildAdditional(closingReroute);
676  closingReroute->incRef("buildClosingReroute");
677  }
678  return closingReroute;
679 }
680 
681 
683 GNEAdditionalHandler::builDestProbReroute(GNEViewNet* viewNet, bool allowUndoRedo, GNEAdditional* rerouterIntervalParent, GNEEdge* newEdgeDestination, double probability) {
684  // create dest probability reroute
685  GNEDestProbReroute* destProbReroute = new GNEDestProbReroute(rerouterIntervalParent, newEdgeDestination, probability);
686  // add it to interval parent depending of allowUndoRedo
687  if (allowUndoRedo) {
688  viewNet->getUndoList()->p_begin("add " + destProbReroute->getTagStr());
689  viewNet->getUndoList()->add(new GNEChange_Additional(destProbReroute, true), true);
690  viewNet->getUndoList()->p_end();
691  } else {
692  rerouterIntervalParent->addChildAdditional(destProbReroute);
693  destProbReroute->incRef("builDestProbReroute");
694  }
695  return destProbReroute;
696 }
697 
698 
700 GNEAdditionalHandler::builParkingAreaReroute(GNEViewNet* viewNet, bool allowUndoRedo, GNEAdditional* rerouterIntervalParent, GNEAdditional* newParkingArea, double probability, bool visible) {
701  // create dest probability reroute
702  GNEParkingAreaReroute* parkingAreaReroute = new GNEParkingAreaReroute(rerouterIntervalParent, newParkingArea, probability, visible);
703  // add it to interval parent depending of allowUndoRedo
704  if (allowUndoRedo) {
705  viewNet->getUndoList()->p_begin("add " + parkingAreaReroute->getTagStr());
706  viewNet->getUndoList()->add(new GNEChange_Additional(parkingAreaReroute, true), true);
707  viewNet->getUndoList()->p_end();
708  } else {
709  rerouterIntervalParent->addChildAdditional(parkingAreaReroute);
710  parkingAreaReroute->incRef("builParkingAreaReroute");
711  }
712  return parkingAreaReroute;
713 }
714 
715 
717 GNEAdditionalHandler::buildRouteProbReroute(GNEViewNet* viewNet, bool allowUndoRedo, GNEAdditional* rerouterIntervalParent, const std::string& newRouteId, double probability) {
718  // create rout prob rereoute
719  GNERouteProbReroute* routeProbReroute = new GNERouteProbReroute(rerouterIntervalParent, newRouteId, probability);
720  // add it to interval parent depending of allowUndoRedo
721  if (allowUndoRedo) {
722  viewNet->getUndoList()->p_begin("add " + routeProbReroute->getTagStr());
723  viewNet->getUndoList()->add(new GNEChange_Additional(routeProbReroute, true), true);
724  viewNet->getUndoList()->p_end();
725  } else {
726  rerouterIntervalParent->addChildAdditional(routeProbReroute);
727  routeProbReroute->incRef("buildRouteProbReroute");
728  }
729  return routeProbReroute;
730 }
731 
732 
734 GNEAdditionalHandler::buildRouteProbe(GNEViewNet* viewNet, bool allowUndoRedo, const std::string& id, GNEEdge* edge, const std::string& freq, const std::string& name, const std::string& file, SUMOTime begin, bool centerAfterCreation) {
735  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_ROUTEPROBE, id, false) == nullptr) {
736  GNERouteProbe* routeProbe = new GNERouteProbe(id, viewNet, edge, freq, name, file, begin);
737  if (allowUndoRedo) {
738  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_ROUTEPROBE));
739  viewNet->getUndoList()->add(new GNEChange_Additional(routeProbe, true), true);
740  viewNet->getUndoList()->p_end();
741  // center after creation
742  if (centerAfterCreation) {
743  viewNet->centerTo(routeProbe->getPositionInView(), false);
744  }
745  } else {
746  viewNet->getNet()->insertAdditional(routeProbe);
747  edge->addChildAdditional(routeProbe);
748  routeProbe->incRef("buildRouteProbe");
749  }
750  return routeProbe;
751  } else {
752  throw ProcessError("Could not build " + toString(SUMO_TAG_ROUTEPROBE) + " with ID '" + id + "' in netedit; probably declared twice.");
753  }
754 }
755 
756 
758 GNEAdditionalHandler::buildVariableSpeedSign(GNEViewNet* viewNet, bool allowUndoRedo, const std::string& id, Position pos, const std::vector<GNELane*>& lanes, const std::string& name, bool blockMovement) {
759  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_VSS, id, false) == nullptr) {
760  GNEVariableSpeedSign* variableSpeedSign = new GNEVariableSpeedSign(id, viewNet, pos, lanes, name, blockMovement);
761  if (allowUndoRedo) {
762  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_VSS));
763  viewNet->getUndoList()->add(new GNEChange_Additional(variableSpeedSign, true), true);
764  viewNet->getUndoList()->p_end();
765  } else {
766  viewNet->getNet()->insertAdditional(variableSpeedSign);
767  // add this VSS as parent of all edges
768  for (auto i : lanes) {
769  i->addParentAdditional(variableSpeedSign);
770  }
771  variableSpeedSign->incRef("buildVariableSpeedSign");
772  }
773  return variableSpeedSign;
774  } else {
775  throw ProcessError("Could not build " + toString(SUMO_TAG_VSS) + " with ID '" + id + "' in netedit; probably declared twice.");
776  }
777 }
778 
779 
781 GNEAdditionalHandler::buildVariableSpeedSignStep(GNEViewNet* viewNet, bool allowUndoRedo, GNEAdditional* VSSParent, double time, double speed) {
782  // create Variable Speed Sign
783  GNEVariableSpeedSignStep* variableSpeedSignStep = new GNEVariableSpeedSignStep(VSSParent, time, speed);
784  // add it depending of allow undoRedo
785  if (allowUndoRedo) {
786  viewNet->getUndoList()->p_begin("add " + variableSpeedSignStep->getTagStr());
787  viewNet->getUndoList()->add(new GNEChange_Additional(variableSpeedSignStep, true), true);
788  viewNet->getUndoList()->p_end();
789  } else {
790  VSSParent->addChildAdditional(variableSpeedSignStep);
791  variableSpeedSignStep->incRef("buildVariableSpeedSignStep");
792  }
793  return variableSpeedSignStep;
794 }
795 
796 
798 GNEAdditionalHandler::buildVaporizer(GNEViewNet* viewNet, bool allowUndoRedo, GNEEdge* edge, SUMOTime startTime, SUMOTime endTime, const std::string& name, bool centerAfterCreation) {
799  GNEVaporizer* vaporizer = new GNEVaporizer(viewNet, edge, startTime, endTime, name);
800  if (allowUndoRedo) {
801  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_VAPORIZER));
802  viewNet->getUndoList()->add(new GNEChange_Additional(vaporizer, true), true);
803  viewNet->getUndoList()->p_end();
804  // center after creation
805  if (centerAfterCreation) {
806  viewNet->centerTo(vaporizer->getPositionInView(), false);
807  }
808  } else {
809  viewNet->getNet()->insertAdditional(vaporizer);
810  edge->addChildAdditional(vaporizer);
811  vaporizer->incRef("buildVaporizer");
812  }
813  return vaporizer;
814 }
815 
816 
818 GNEAdditionalHandler::buildTAZ(GNEViewNet* viewNet, bool allowUndoRedo, const std::string& id, const PositionVector& shape, const RGBColor& color, const std::vector<GNEEdge*>& edges, bool blockMovement) {
819  GNETAZ* TAZ = new GNETAZ(id, viewNet, shape, color, blockMovement);
820  // disable updating geometry of TAZ children during insertion (because in large nets provokes slowdowns)
821  viewNet->getNet()->disableUpdateGeometry();
822  if (allowUndoRedo) {
823  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_TAZ));
824  viewNet->getUndoList()->add(new GNEChange_Additional(TAZ, true), true);
825  // create TAZEdges
826  for (auto i : edges) {
827  // create TAZ Source using GNEChange_Additional
828  GNETAZSourceSink* TAZSource = new GNETAZSourceSink(SUMO_TAG_TAZSOURCE, TAZ, i, 1);
829  viewNet->getUndoList()->add(new GNEChange_Additional(TAZSource, true), true);
830  // create TAZ Sink using GNEChange_Additional
831  GNETAZSourceSink* TAZSink = new GNETAZSourceSink(SUMO_TAG_TAZSINK, TAZ, i, 1);
832  viewNet->getUndoList()->add(new GNEChange_Additional(TAZSink, true), true);
833  }
834  viewNet->getUndoList()->p_end();
835  } else {
836  viewNet->getNet()->insertAdditional(TAZ);
837  TAZ->incRef("buildTAZ");
838  for (auto i : edges) {
839  // create TAZ Source
840  GNETAZSourceSink* TAZSource = new GNETAZSourceSink(SUMO_TAG_TAZSOURCE, TAZ, i, 1);
841  TAZSource->incRef("buildTAZ");
842  TAZ->addChildAdditional(TAZSource);
843  // create TAZ Sink
844  GNETAZSourceSink* TAZSink = new GNETAZSourceSink(SUMO_TAG_TAZSINK, TAZ, i, 1);
845  TAZSink->incRef("buildTAZ");
846  TAZ->addChildAdditional(TAZSink);
847  }
848  }
849  // enable updating geometry again and update geometry of TAZ
850  viewNet->getNet()->enableUpdateGeometry();
851  // update TAZ Frame
852  TAZ->updateGeometry();
853  TAZ->updateParentAdditional();
854  return TAZ;
855 }
856 
857 
859 GNEAdditionalHandler::buildTAZSource(GNEViewNet* viewNet, bool allowUndoRedo, GNEAdditional* TAZ, GNEEdge* edge, double departWeight) {
860  GNEAdditional* TAZSink = nullptr;
861  // first check if a TAZSink in the same edge for the same TAZ
862  for (auto i : TAZ->getChildAdditionals()) {
863  if ((i->getTagProperty().getTag() == SUMO_TAG_TAZSINK) && (i->getAttribute(SUMO_ATTR_EDGE) == edge->getID())) {
864  TAZSink = i;
865  }
866  }
867  // check if TAZSink has to be created
868  if (TAZSink == nullptr) {
869  // Create TAZ with weight 0 (default)
870  TAZSink = new GNETAZSourceSink(SUMO_TAG_TAZSINK, TAZ, edge, 1);
871  if (allowUndoRedo) {
872  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_TAZSINK));
873  viewNet->getUndoList()->add(new GNEChange_Additional(TAZSink, true), true);
874  viewNet->getUndoList()->p_end();
875  } else {
876  viewNet->getNet()->insertAdditional(TAZSink);
877  TAZSink->incRef("buildTAZSource");
878  }
879  }
880  // now check check if TAZSource exist
881  GNEAdditional* TAZSource = nullptr;
882  // first check if a TAZSink in the same edge for the same TAZ
883  for (auto i : TAZ->getChildAdditionals()) {
884  if ((i->getTagProperty().getTag() == SUMO_TAG_TAZSOURCE) && (i->getAttribute(SUMO_ATTR_EDGE) == edge->getID())) {
885  TAZSource = i;
886  }
887  }
888  // check if TAZSource has to be created
889  if (TAZSource == nullptr) {
890  // Create TAZ only with departWeight
891  TAZSource = new GNETAZSourceSink(SUMO_TAG_TAZSOURCE, TAZ, edge, departWeight);
892  if (allowUndoRedo) {
893  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_TAZSOURCE));
894  viewNet->getUndoList()->add(new GNEChange_Additional(TAZSource, true), true);
895  viewNet->getUndoList()->p_end();
896  } else {
897  viewNet->getNet()->insertAdditional(TAZSource);
898  TAZSource->incRef("buildTAZSource");
899  }
900  } else {
901  // update TAZ Attribute
902  if (allowUndoRedo) {
903  viewNet->getUndoList()->p_begin("update " + toString(SUMO_TAG_TAZSOURCE));
904  TAZSource->setAttribute(SUMO_ATTR_WEIGHT, toString(departWeight), viewNet->getUndoList());
905  viewNet->getUndoList()->p_end();
906  } else {
907  TAZSource->setAttribute(SUMO_ATTR_WEIGHT, toString(departWeight), nullptr);
908  TAZSource->incRef("buildTAZSource");
909  }
910  }
911  return TAZSource;
912 }
913 
914 
916 GNEAdditionalHandler::buildTAZSink(GNEViewNet* viewNet, bool allowUndoRedo, GNEAdditional* TAZ, GNEEdge* edge, double arrivalWeight) {
917  GNEAdditional* TAZSource = nullptr;
918  // first check if a TAZSink in the same edge for the same TAZ
919  for (auto i : TAZ->getChildAdditionals()) {
920  if ((i->getTagProperty().getTag() == SUMO_TAG_TAZSOURCE) && (i->getAttribute(SUMO_ATTR_EDGE) == edge->getID())) {
921  TAZSource = i;
922  }
923  }
924  // check if TAZSource has to be created
925  if (TAZSource == nullptr) {
926  // Create TAZ with empty value
927  TAZSource = new GNETAZSourceSink(SUMO_TAG_TAZSOURCE, TAZ, edge, 1);
928  if (allowUndoRedo) {
929  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_TAZSOURCE));
930  viewNet->getUndoList()->add(new GNEChange_Additional(TAZSource, true), true);
931  viewNet->getUndoList()->p_end();
932  } else {
933  viewNet->getNet()->insertAdditional(TAZSource);
934  TAZSource->incRef("buildTAZSink");
935  }
936  }
937  GNEAdditional* TAZSink = nullptr;
938  // first check if a TAZSink in the same edge for the same TAZ
939  for (auto i : TAZ->getChildAdditionals()) {
940  if ((i->getTagProperty().getTag() == SUMO_TAG_TAZSINK) && (i->getAttribute(SUMO_ATTR_EDGE) == edge->getID())) {
941  TAZSink = i;
942  }
943  }
944  // check if TAZSink has to be created
945  if (TAZSink == nullptr) {
946  // Create TAZ only with arrivalWeight
947  TAZSink = new GNETAZSourceSink(SUMO_TAG_TAZSINK, TAZ, edge, arrivalWeight);
948  if (allowUndoRedo) {
949  viewNet->getUndoList()->p_begin("add " + toString(SUMO_TAG_TAZSINK));
950  viewNet->getUndoList()->add(new GNEChange_Additional(TAZSink, true), true);
951  viewNet->getUndoList()->p_end();
952  } else {
953  viewNet->getNet()->insertAdditional(TAZSink);
954  TAZSink->incRef("buildTAZSink");
955  }
956  } else {
957  // update TAZ Attribute
958  if (allowUndoRedo) {
959  viewNet->getUndoList()->p_begin("update " + toString(SUMO_TAG_TAZSINK));
960  TAZSink->setAttribute(SUMO_ATTR_WEIGHT, toString(arrivalWeight), viewNet->getUndoList());
961  viewNet->getUndoList()->p_end();
962  } else {
963  TAZSink->setAttribute(SUMO_ATTR_WEIGHT, toString(arrivalWeight), nullptr);
964  TAZSink->incRef("buildTAZSink");
965  }
966  }
967  return TAZSink;
968 }
969 
970 
971 double
972 GNEAdditionalHandler::getPosition(double pos, GNELane& lane, bool friendlyPos, const std::string& additionalID) {
973  if (pos < 0) {
974  pos = lane.getLaneShapeLength() + pos;
975  }
976  if (pos > lane.getLaneShapeLength()) {
977  if (friendlyPos) {
978  pos = lane.getLaneShapeLength() - (double) 0.1;
979  } else {
980  WRITE_WARNING("The position of additional '" + additionalID + "' lies beyond the lane's '" + lane.getID() + "' length.");
981  }
982  }
983  return pos;
984 }
985 
986 
987 bool GNEAdditionalHandler::checkAndFixDetectorPosition(double& pos, const double laneLength, const bool friendlyPos) {
988  if (fabs(pos) > laneLength) {
989  if (!friendlyPos) {
990  return false;
991  } else if (pos < 0) {
992  pos = 0;
993  } else if (pos > laneLength) {
994  pos = laneLength - 0.01;
995  }
996  }
997  return true;
998 }
999 
1000 
1001 bool GNEAdditionalHandler::fixE2DetectorPosition(double& pos, double& length, const double laneLength, const bool friendlyPos) {
1002  if ((pos < 0) || ((pos + length) > laneLength)) {
1003  if (!friendlyPos) {
1004  return false;
1005  } else if (pos < 0) {
1006  pos = 0;
1007  } else if (pos > laneLength) {
1008  pos = laneLength - 0.01;
1009  length = 0;
1010  } else if ((pos + length) > laneLength) {
1011  length = laneLength - pos - 0.01;
1012  }
1013  }
1014  return true;
1015 }
1016 
1017 
1018 bool
1020  // check that busStopParent is a busStop
1021  assert(busStopParent->getTagProperty().getTag() == SUMO_TAG_BUS_STOP);
1022  // check if exist another acces for the same busStop in the given edge
1023  for (auto i : busStopParent->getChildAdditionals()) {
1024  for (auto j : edge->getLanes()) {
1025  if (i->getAttribute(SUMO_ATTR_LANE) == j->getID()) {
1026  return false;
1027  }
1028  }
1029  }
1030  return true;
1031 }
1032 
1033 
1034 bool
1036  // check that rerouter is correct
1037  assert(rerouter->getTagProperty().getTag() == SUMO_TAG_REROUTER);
1038  // declare a vector to keep sorted rerouter children
1039  std::vector<std::pair<SUMOTime, SUMOTime>> sortedIntervals;
1040  // iterate over child additional
1041  for (auto i : rerouter->getChildAdditionals()) {
1042  sortedIntervals.push_back(std::make_pair((SUMOTime)0., (SUMOTime)0.));
1043  // set begin and end
1044  sortedIntervals.back().first = TIME2STEPS(i->getAttributeDouble(SUMO_ATTR_BEGIN));
1045  sortedIntervals.back().second = TIME2STEPS(i->getAttributeDouble(SUMO_ATTR_END));
1046  }
1047  // add new intervals
1048  sortedIntervals.push_back(std::make_pair(newBegin, newEnd));
1049  // sort children
1050  std::sort(sortedIntervals.begin(), sortedIntervals.end());
1051  // check overlapping after sorting
1052  for (int i = 0; i < (int)sortedIntervals.size() - 1; i++) {
1053  if (sortedIntervals.at(i).second > sortedIntervals.at(i + 1).first) {
1054  return false;
1055  }
1056  }
1057  return true;
1058 }
1059 
1060 
1061 
1062 
1063 bool
1064 GNEAdditionalHandler::parseAndBuildVaporizer(GNEViewNet* viewNet, bool allowUndoRedo, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
1065  bool abort = false;
1066  // parse attributes of Vaporizer
1067  const std::string edgeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_VAPORIZER, SUMO_ATTR_ID, abort);
1068  SUMOTime begin = GNEAttributeCarrier::parseAttributeFromXML<SUMOTime>(attrs, "", SUMO_TAG_VAPORIZER, SUMO_ATTR_BEGIN, abort);
1069  SUMOTime end = GNEAttributeCarrier::parseAttributeFromXML<SUMOTime>(attrs, "", SUMO_TAG_VAPORIZER, SUMO_ATTR_END, abort);
1070  std::string name = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_VAPORIZER, SUMO_ATTR_NAME, abort);
1071  // extra check for center element after creation
1072  bool centerAfterCreation = attrs.hasAttribute(GNE_ATTR_CENTER_AFTER_CREATION);
1073  // Continue if all parameters were successfully loaded
1074  if (!abort) {
1075  // get GNEEdge
1076  GNEEdge* edge = viewNet->getNet()->retrieveEdge(edgeID, false);
1077  // check that all parameters are valid
1078  if (edge == nullptr) {
1079  WRITE_WARNING("The edge '" + edgeID + "' to use within the " + toString(SUMO_TAG_VAPORIZER) + " is not known.");
1080  } else if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_VAPORIZER, edgeID, false) != nullptr) {
1081  WRITE_WARNING("There is already a " + toString(SUMO_TAG_VAPORIZER) + " in the edge '" + edgeID + "'.");
1082  } else if (begin > end) {
1083  WRITE_WARNING("Time interval of " + toString(SUMO_TAG_VAPORIZER) + " isn't valid. Attribute '" + toString(SUMO_ATTR_BEGIN) + "' is greater than attribute '" + toString(SUMO_ATTR_END) + "'.");
1084  } else {
1085  // build vaporizer
1086  GNEAdditional* additionalCreated = buildVaporizer(viewNet, allowUndoRedo, edge, begin, end, name, centerAfterCreation);
1087  // check if insertion has to be commited
1088  if (insertedAdditionals) {
1089  insertedAdditionals->commitElementInsertion(additionalCreated);
1090  }
1091  return true;
1092  }
1093  }
1094  return false;
1095 }
1096 
1097 
1098 bool
1099 GNEAdditionalHandler::parseAndBuildTAZ(GNEViewNet* viewNet, bool allowUndoRedo, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
1100  bool abort = false;
1101  // parse attributes of Vaporizer
1102  const std::string id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_TAZ, SUMO_ATTR_ID, abort);
1103  const PositionVector shape = GNEAttributeCarrier::parseAttributeFromXML<PositionVector>(attrs, id, SUMO_TAG_TAZ, SUMO_ATTR_SHAPE, abort);
1104  RGBColor color = GNEAttributeCarrier::parseAttributeFromXML<RGBColor>(attrs, id, SUMO_TAG_TAZ, SUMO_ATTR_COLOR, abort);
1105  // parse Netedit attributes
1106  bool blockMovement = false;
1108  blockMovement = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_TAZ, GNE_ATTR_BLOCK_MOVEMENT, abort);
1109  }
1110  // check edges
1111  std::vector<std::string> edgeIDs;
1112  if (attrs.hasAttribute(SUMO_ATTR_EDGES)) {
1113  std::string parsedAttribute = attrs.get<std::string>(SUMO_ATTR_EDGES, id.c_str(), abort, false);
1114  edgeIDs = GNEAttributeCarrier::parse<std::vector<std::string> >(parsedAttribute);
1115  }
1116  // check if all edge IDs are valid
1117  std::vector<GNEEdge*> edges;
1118  for (auto i : edgeIDs) {
1119  GNEEdge* edge = viewNet->getNet()->retrieveEdge(i, false);
1120  if (edge == nullptr) {
1121  WRITE_WARNING("Invalid " + toString(SUMO_TAG_EDGE) + " with ID = '" + i + "' within taz '" + id + "'.");
1122  abort = true;
1123  } else {
1124  edges.push_back(edge);
1125  }
1126  }
1127  // Continue if all parameters were successfully loaded
1128  if (!abort) {
1129  // check that all parameters are valid
1130  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_TAZ, id, false) != nullptr) {
1131  WRITE_WARNING("There is another " + toString(SUMO_TAG_TAZ) + " with the same ID='" + id + "'.");
1132  } else {
1133  // save ID of last created element
1134  GNEAdditional* additionalCreated = buildTAZ(viewNet, allowUndoRedo, id, shape, color, edges, blockMovement);
1135  // check if insertion has to be commited
1136  if (insertedAdditionals) {
1137  insertedAdditionals->commitElementInsertion(additionalCreated);
1138  }
1139  return true;
1140  }
1141  }
1142  return false;
1143 }
1144 
1145 
1146 bool
1147 GNEAdditionalHandler::parseAndBuildTAZSource(GNEViewNet* viewNet, bool allowUndoRedo, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
1148  bool abort = false;
1149  // parse attributes of Vaporizer
1150  const std::string edgeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_TAZSOURCE, SUMO_ATTR_ID, abort);
1151  const double departWeight = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, edgeID, SUMO_TAG_TAZSOURCE, SUMO_ATTR_WEIGHT, abort);
1152  // Continue if all parameters were successfully loaded
1153  if (!abort) {
1154  // get edge and TAZ
1155  GNEEdge* edge = viewNet->getNet()->retrieveEdge(edgeID, false);
1156  GNEAdditional* TAZ = nullptr;
1157  // obtain parent depending if we're loading or creating it using GNEAdditionalFrame
1158  if (insertedAdditionals) {
1159  TAZ = insertedAdditionals->retrieveParentAdditional(viewNet, SUMO_TAG_TAZ);
1160  } else {
1161  bool ok = true;
1162  TAZ = viewNet->getNet()->retrieveAdditional(SUMO_TAG_TAZ, attrs.get<std::string>(GNE_ATTR_PARENT, "", ok));
1163  }
1164  // check that all parameters are valid
1165  if (edge == nullptr) {
1166  WRITE_WARNING("The edge '" + edgeID + "' to use within the " + toString(SUMO_TAG_TAZSOURCE) + " is not known.");
1167  } else if (TAZ == nullptr) {
1168  WRITE_WARNING("A " + toString(SUMO_TAG_TAZSOURCE) + " must be declared within the definition of a " + toString(SUMO_TAG_TAZ) + ".");
1169  } else {
1170  // save ID of last created element
1171  GNEAdditional* additionalCreated = buildTAZSource(viewNet, allowUndoRedo, TAZ, edge, departWeight);
1172  // check if insertion has to be commited
1173  if (insertedAdditionals) {
1174  insertedAdditionals->commitElementInsertion(additionalCreated);
1175  }
1176  return true;
1177  }
1178  }
1179  return false;
1180 }
1181 
1182 
1183 bool
1184 GNEAdditionalHandler::parseAndBuildTAZSink(GNEViewNet* viewNet, bool allowUndoRedo, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
1185  bool abort = false;
1186  // parse attributes of Vaporizer
1187  const std::string edgeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_TAZSINK, SUMO_ATTR_ID, abort);
1188  const double arrivalWeight = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, edgeID, SUMO_TAG_TAZSINK, SUMO_ATTR_WEIGHT, abort);
1189  // Continue if all parameters were successfully loaded
1190  if (!abort) {
1191  // get edge and TAZ
1192  GNEEdge* edge = viewNet->getNet()->retrieveEdge(edgeID, false);
1193  GNEAdditional* TAZ = nullptr;
1194  // obtain parent depending if we're loading or creating it using GNEAdditionalFrame
1195  if (insertedAdditionals) {
1196  TAZ = insertedAdditionals->retrieveParentAdditional(viewNet, SUMO_TAG_TAZ);
1197  } else {
1198  bool ok = true;
1199  TAZ = viewNet->getNet()->retrieveAdditional(SUMO_TAG_TAZ, attrs.get<std::string>(GNE_ATTR_PARENT, "", ok));
1200  }
1201  // check that all parameters are valid
1202  if (edge == nullptr) {
1203  WRITE_WARNING("The edge '" + edgeID + "' to use within the " + toString(SUMO_TAG_TAZSINK) + " is not known.");
1204  } else if (TAZ == nullptr) {
1205  WRITE_WARNING("A " + toString(SUMO_TAG_TAZSINK) + " must be declared within the definition of a " + toString(SUMO_TAG_TAZ) + ".");
1206  } else {
1207  // save ID of last created element
1208  GNEAdditional* additionalCreated = buildTAZSink(viewNet, allowUndoRedo, TAZ, edge, arrivalWeight);
1209  // check if insertion has to be commited
1210  if (insertedAdditionals) {
1211  insertedAdditionals->commitElementInsertion(additionalCreated);
1212  }
1213  return true;
1214  }
1215  }
1216  return false;
1217 }
1218 
1219 
1220 bool
1221 GNEAdditionalHandler::parseAndBuildRouteProbe(GNEViewNet* viewNet, bool allowUndoRedo, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
1222  bool abort = false;
1223  // parse attributes of RouteProbe
1224  std::string id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_ROUTEPROBE, SUMO_ATTR_ID, abort);
1225  std::string edgeId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_ROUTEPROBE, SUMO_ATTR_EDGE, abort);
1226  std::string freq = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_ROUTEPROBE, SUMO_ATTR_FREQUENCY, abort);
1227  std::string name = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_ROUTEPROBE, SUMO_ATTR_NAME, abort);
1228  std::string file = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_ROUTEPROBE, SUMO_ATTR_FILE, abort);
1229  SUMOTime begin = GNEAttributeCarrier::parseAttributeFromXML<SUMOTime>(attrs, id, SUMO_TAG_ROUTEPROBE, SUMO_ATTR_BEGIN, abort);
1230  // extra check for center element after creation
1231  bool centerAfterCreation = attrs.hasAttribute(GNE_ATTR_CENTER_AFTER_CREATION);
1232  // Continue if all parameters were sucesfully loaded
1233  if (!abort) {
1234  // get edge
1235  GNEEdge* edge = viewNet->getNet()->retrieveEdge(edgeId, false);
1236  // check that all elements are valid
1237  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_ROUTEPROBE, id, false) != nullptr) {
1238  WRITE_WARNING("There is another " + toString(SUMO_TAG_ROUTEPROBE) + " with the same ID='" + id + "'.");
1239  } else if (edge == nullptr) {
1240  // Write error if lane isn't valid
1241  WRITE_WARNING("The edge '" + edgeId + "' to use within the " + toString(SUMO_TAG_ROUTEPROBE) + " '" + id + "' is not known.");
1242  } else {
1243  // Freq needs an extra check, because it can be empty
1244  if (GNEAttributeCarrier::canParse<double>(freq)) {
1245  if (GNEAttributeCarrier::parse<double>(freq) < 0) {
1246  WRITE_WARNING(toString(SUMO_ATTR_FREQUENCY) + "of " + toString(SUMO_TAG_ROUTEPROBE) + "'" + id + "' cannot be negative.");
1247  freq = "";
1248  }
1249  } else {
1250  if (freq.empty()) {
1251  WRITE_WARNING(toString(SUMO_ATTR_FREQUENCY) + "of " + toString(SUMO_TAG_ROUTEPROBE) + "'" + id + "' cannot be parsed to float.");
1252  }
1253  freq = "";
1254  }
1255  // save ID of last created element
1256  GNEAdditional* additionalCreated = buildRouteProbe(viewNet, allowUndoRedo, id, edge, freq, name, file, begin, centerAfterCreation);
1257  // check if insertion has to be commited
1258  if (insertedAdditionals) {
1259  insertedAdditionals->commitElementInsertion(additionalCreated);
1260  }
1261  return true;
1262  }
1263  }
1264  return false;
1265 }
1266 
1267 
1268 bool
1269 GNEAdditionalHandler::parseAndBuildCalibratorFlow(GNEViewNet* viewNet, bool allowUndoRedo, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
1270  bool abort = false;
1271  // parse attributes of calibrator flows
1272  std::string vehicleTypeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_TYPE, abort);
1273  std::string routeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_ROUTE, abort);
1274  std::string vehsPerHour = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_VEHSPERHOUR, abort);
1275  std::string speed = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_SPEED, abort);
1276  RGBColor color = GNEAttributeCarrier::parseAttributeFromXML<RGBColor>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_COLOR, abort);
1277  std::string departLane = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_DEPARTLANE, abort);
1278  std::string departPos = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_DEPARTPOS, abort);
1279  std::string departSpeed = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_DEPARTSPEED, abort);
1280  std::string arrivalLane = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_ARRIVALLANE, abort);
1281  std::string arrivalPos = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_ARRIVALPOS, abort);
1282  std::string arrivalSpeed = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_ARRIVALSPEED, abort);
1283  std::string line = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_LINE, abort);
1284  int personNumber = GNEAttributeCarrier::parseAttributeFromXML<int>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_PERSON_NUMBER, abort);
1285  int containerNumber = GNEAttributeCarrier::parseAttributeFromXML<int>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_CONTAINER_NUMBER, abort);
1286  bool reroute = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_REROUTE, abort);
1287  std::string departPosLat = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_DEPARTPOS_LAT, abort);
1288  std::string arrivalPosLat = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_ARRIVALPOS_LAT, abort);
1289  SUMOTime begin = GNEAttributeCarrier::parseAttributeFromXML<SUMOTime>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_BEGIN, abort);
1290  SUMOTime end = GNEAttributeCarrier::parseAttributeFromXML<SUMOTime>(attrs, "", SUMO_TAG_FLOW_CALIBRATOR, SUMO_ATTR_END, abort);
1291  // Continue if all parameters were sucesfully loaded
1292  if (!abort) {
1293  // obtain route, vehicle type and calibrator parent
1294  GNEDemandElement* route = viewNet->getNet()->retrieveDemandElement(SUMO_TAG_ROUTE, routeID, false);
1295  GNEDemandElement* vtype = viewNet->getNet()->retrieveDemandElement(SUMO_TAG_VTYPE, vehicleTypeID, false);
1296  GNEAdditional* calibrator = nullptr;
1297  // obtain parent depending if we're loading or creating it using GNEAdditionalFrame
1298  if (insertedAdditionals) {
1299  calibrator = insertedAdditionals->retrieveParentAdditional(viewNet, SUMO_TAG_CALIBRATOR);
1300  } else {
1301  bool ok = true;
1302  calibrator = viewNet->getNet()->retrieveAdditional(SUMO_TAG_CALIBRATOR, attrs.get<std::string>(GNE_ATTR_PARENT, "", ok));
1303  }
1304  // check that all elements are valid
1305  if (route == nullptr) {
1306  WRITE_WARNING(toString(SUMO_TAG_FLOW_CALIBRATOR) + " cannot be created; their " + toString(SUMO_TAG_ROUTE) + " with ID = '" + routeID + "' doesn't exist");
1307  abort = true;
1308  } else if (vtype == nullptr) {
1309  WRITE_WARNING(toString(SUMO_TAG_FLOW_CALIBRATOR) + " cannot be created; their " + toString(SUMO_TAG_VTYPE) + " with ID = '" + vehicleTypeID + "' doesn't exist");
1310  abort = true;
1311  } else if ((vehsPerHour.empty()) && (speed.empty())) {
1312  WRITE_WARNING(toString(SUMO_TAG_FLOW_CALIBRATOR) + " cannot be created; At least parameters " + toString(SUMO_ATTR_VEHSPERHOUR) + " or " + toString(SUMO_ATTR_SPEED) + " has to be defined");
1313  abort = true;
1314  } else if (calibrator != nullptr) {
1315  // save ID of last created element
1316  GNEAdditional* additionalCreated = buildCalibratorFlow(viewNet, allowUndoRedo, calibrator, route, vtype, vehsPerHour, speed, color, departLane, departPos, departSpeed, arrivalLane, arrivalPos, arrivalSpeed,
1317  line, personNumber, containerNumber, reroute, departPosLat, arrivalPosLat, begin, end);
1318  // check if insertion has to be commited
1319  if (insertedAdditionals) {
1320  insertedAdditionals->commitElementInsertion(additionalCreated);
1321  }
1322  return true;
1323  }
1324  }
1325  return false;
1326 }
1327 
1328 
1329 void
1331  bool abort = false;
1332  // parse attributes of polygons
1333  std::string polygonID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_POLY, SUMO_ATTR_ID, abort);
1334  PositionVector shape = GNEAttributeCarrier::parseAttributeFromXML<PositionVector>(attrs, polygonID, SUMO_TAG_POLY, SUMO_ATTR_SHAPE, abort);
1335  double layer = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, polygonID, SUMO_TAG_POLY, SUMO_ATTR_LAYER, abort);
1336  bool fill = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, "", SUMO_TAG_POLY, SUMO_ATTR_FILL, abort);
1337  double lineWidth = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, polygonID, SUMO_TAG_POLY, SUMO_ATTR_LINEWIDTH, abort);
1338  std::string type = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, polygonID, SUMO_TAG_POLY, SUMO_ATTR_TYPE, abort);
1339  RGBColor color = GNEAttributeCarrier::parseAttributeFromXML<RGBColor>(attrs, polygonID, SUMO_TAG_POLY, SUMO_ATTR_COLOR, abort);
1340  double angle = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, polygonID, SUMO_TAG_POLY, SUMO_ATTR_ANGLE, abort);
1341  std::string imgFile = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, polygonID, SUMO_TAG_POLY, SUMO_ATTR_IMGFILE, abort);
1342  bool relativePath = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, polygonID, SUMO_TAG_POLY, SUMO_ATTR_RELATIVEPATH, abort);
1343  // check if ID is valid
1344  if (SUMOXMLDefinitions::isValidTypeID(polygonID) == false) {
1345  WRITE_WARNING("Invalid characters for polygon ID");
1346  abort = true;
1347  }
1348  // Continue if all parameters were sucesfully loaded
1349  if (!abort) {
1350  // check if shape must be loaded as geo attribute
1351  bool geo = false;
1353  if (attrs.getOpt<bool>(SUMO_ATTR_GEO, polygonID.c_str(), abort, false)) {
1354  geo = true;
1355  bool success = true;
1356  for (int i = 0; i < (int)shape.size(); i++) {
1357  success &= gch->x2cartesian_const(shape[i]);
1358  }
1359  if (!success) {
1360  WRITE_WARNING("Unable to project coordinates for polygon '" + polygonID + "'.");
1361  return;
1362  }
1363  }
1364  // check if img file is absolute
1365  if (imgFile != "" && !FileHelpers::isAbsolute(imgFile)) {
1366  imgFile = FileHelpers::getConfigurationRelative(getFileName(), imgFile);
1367  }
1368  // create polygon, or show an error if polygon already exists
1369  if (!myShapeContainer.addPolygon(polygonID, type, color, layer, angle, imgFile, relativePath, shape, geo, fill, lineWidth, false)) {
1370  WRITE_WARNING("Polygon with ID '" + polygonID + "' already exists.");
1371  } else {
1372  // update myLastParameterised with the last inserted Polygon
1374  }
1375  }
1376 }
1377 
1378 
1379 bool
1381  bool abort = false;
1382  // parse attributes of VSS
1383  std::string id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_VSS, SUMO_ATTR_ID, abort);
1384  std::string name = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_VSS, SUMO_ATTR_NAME, abort);
1385  GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_VSS, SUMO_ATTR_FILE, abort); // deprecated
1386  std::string lanesIDs = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_VSS, SUMO_ATTR_LANES, abort);
1387  Position pos = GNEAttributeCarrier::parseAttributeFromXML<Position>(attrs, id, SUMO_TAG_VSS, SUMO_ATTR_POSITION, abort);
1388  // parse Netedit attributes
1389  bool blockMovement = false;
1391  blockMovement = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_VSS, GNE_ATTR_BLOCK_MOVEMENT, abort);
1392  }
1393  // Continue if all parameters were sucesfully loaded
1394  if (!abort) {
1395  // obtain lanes
1396  std::vector<GNELane*> lanes;
1397  if (GNEAttributeCarrier::canParse<std::vector<GNELane*> >(viewNet->getNet(), lanesIDs, true)) {
1398  lanes = GNEAttributeCarrier::parse<std::vector<GNELane*> >(viewNet->getNet(), lanesIDs);
1399  }
1400  // check that all elements are valid
1401  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_VSS, id, false) != nullptr) {
1402  WRITE_WARNING("There is another " + toString(SUMO_TAG_VSS) + " with the same ID='" + id + "'.");
1403  } else if (lanes.size() == 0) {
1404  WRITE_WARNING("A Variable Speed Sign needs at least one lane.");
1405  } else {
1406  // save ID of last created element
1407  GNEAdditional* additionalCreated = buildVariableSpeedSign(viewNet, allowUndoRedo, id, pos, lanes, name, blockMovement);
1408  // check if insertion has to be commited
1409  if (insertedAdditionals) {
1410  insertedAdditionals->commitElementInsertion(additionalCreated);
1411  }
1412  return true;
1413  }
1414  }
1415  return false;
1416 }
1417 
1418 
1419 bool
1421  bool abort = false;
1422  // Load step values
1423  double time = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, "", SUMO_TAG_STEP, SUMO_ATTR_TIME, abort);
1424  double speed = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, "", SUMO_TAG_STEP, SUMO_ATTR_SPEED, abort);
1425  // Continue if all parameters were sucesfully loaded
1426  if (!abort) {
1427  // get Variable Speed Signal
1428  GNEAdditional* variableSpeedSign = nullptr;
1429  // obtain parent depending if we're loading or creating it using GNEAdditionalFrame
1430  if (insertedAdditionals) {
1431  variableSpeedSign = insertedAdditionals->retrieveParentAdditional(viewNet, SUMO_TAG_VSS);
1432  } else {
1433  bool ok = true;
1434  variableSpeedSign = viewNet->getNet()->retrieveAdditional(SUMO_TAG_VSS, attrs.get<std::string>(GNE_ATTR_PARENT, "", ok));
1435  }
1436  // check that all parameters are valid
1437  if (variableSpeedSign != nullptr) {
1438  // save ID of last created element
1439  GNEAdditional* additionalCreated = buildVariableSpeedSignStep(viewNet, allowUndoRedo, variableSpeedSign, time, speed);
1440  // check if insertion has to be commited
1441  if (insertedAdditionals) {
1442  insertedAdditionals->commitElementInsertion(additionalCreated);
1443  }
1444  return true;
1445  }
1446  }
1447  return false;
1448 }
1449 
1450 
1451 bool
1452 GNEAdditionalHandler::parseAndBuildRerouter(GNEViewNet* viewNet, bool allowUndoRedo, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
1453  bool abort = false;
1454  // parse attributes of Rerouter
1455  std::string id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_REROUTER, SUMO_ATTR_ID, abort);
1456  std::string edgesIDs = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_REROUTER, SUMO_ATTR_EDGES, abort);
1457  std::string name = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_REROUTER, SUMO_ATTR_NAME, abort);
1458  std::string file = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_REROUTER, SUMO_ATTR_FILE, abort);
1459  double probability = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, SUMO_TAG_REROUTER, SUMO_ATTR_PROB, abort);
1460  bool off = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_REROUTER, SUMO_ATTR_OFF, abort);
1461  SUMOTime timeThreshold = attrs.getOpt<SUMOTime>(SUMO_ATTR_HALTING_TIME_THRESHOLD, id.c_str(), abort, 0);
1462  const std::string vTypes = attrs.getOpt<std::string>(SUMO_ATTR_VTYPES, id.c_str(), abort, "");
1463  Position pos = GNEAttributeCarrier::parseAttributeFromXML<Position>(attrs, id, SUMO_TAG_REROUTER, SUMO_ATTR_POSITION, abort);
1464  // parse Netedit attributes
1465  bool blockMovement = false;
1467  blockMovement = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_REROUTER, GNE_ATTR_BLOCK_MOVEMENT, abort);
1468  }
1469  // Continue if all parameters were sucesfully loaded
1470  if (!abort) {
1471  // obtain edges
1472  std::vector<GNEEdge*> edges;
1473  if (GNEAttributeCarrier::canParse<std::vector<GNEEdge*> >(viewNet->getNet(), edgesIDs, true)) {
1474  edges = GNEAttributeCarrier::parse<std::vector<GNEEdge*> >(viewNet->getNet(), edgesIDs);
1475  }
1476  // check that all elements are valid
1477  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_REROUTER, id, false) != nullptr) {
1478  WRITE_WARNING("There is another " + toString(SUMO_TAG_REROUTER) + " with the same ID='" + id + "'.");
1479  } else if (edges.size() == 0) {
1480  WRITE_WARNING("A rerouter needs at least one Edge");
1481  } else {
1482  // save ID of last created element
1483  GNEAdditional* additionalCreated = buildRerouter(viewNet, allowUndoRedo, id, pos, edges, probability, name,
1484  file, off, timeThreshold, vTypes, blockMovement);
1485  // check if insertion has to be commited
1486  if (insertedAdditionals) {
1487  insertedAdditionals->commitElementInsertion(additionalCreated);
1488  }
1489  return true;
1490  }
1491  }
1492  return false;
1493 }
1494 
1495 
1496 bool
1498  bool abort = false;
1499  // parse attributes of Rerouter
1500  SUMOTime begin = GNEAttributeCarrier::parseAttributeFromXML<SUMOTime>(attrs, "", SUMO_TAG_INTERVAL, SUMO_ATTR_BEGIN, abort);
1501  SUMOTime end = GNEAttributeCarrier::parseAttributeFromXML<SUMOTime>(attrs, "", SUMO_TAG_INTERVAL, SUMO_ATTR_END, abort);
1502  // Continue if all parameters were sucesfully loaded
1503  if (!abort) {
1504  // obtain rerouter
1505  GNEAdditional* rerouter;
1506  // obtain parent depending if we're loading or creating it using GNEAdditionalFrame
1507  if (insertedAdditionals) {
1508  rerouter = insertedAdditionals->retrieveParentAdditional(viewNet, SUMO_TAG_REROUTER);
1509  } else {
1510  bool ok = true;
1511  rerouter = viewNet->getNet()->retrieveAdditional(SUMO_TAG_REROUTER, attrs.get<std::string>(GNE_ATTR_PARENT, "", ok));
1512  }
1513  // special case for load multiple intervals in the same rerouter
1514  if (rerouter == nullptr) {
1515  GNEAdditional* lastInsertedRerouterInterval = nullptr;
1516  // obtain parent depending if we're loading or creating it using GNEAdditionalFrame
1517  if (insertedAdditionals) {
1518  lastInsertedRerouterInterval = insertedAdditionals->retrieveParentAdditional(viewNet, SUMO_TAG_INTERVAL);
1519  } else {
1520  bool ok = true;
1521  lastInsertedRerouterInterval = viewNet->getNet()->retrieveAdditional(SUMO_TAG_INTERVAL, attrs.get<std::string>(GNE_ATTR_PARENT, "", ok));
1522  }
1523  if (lastInsertedRerouterInterval) {
1524  rerouter = lastInsertedRerouterInterval->getParentAdditionals().at(0);
1525  }
1526  }
1527  // check that rerouterInterval can be created
1528  if (begin >= end) {
1529  WRITE_WARNING(toString(SUMO_TAG_INTERVAL) + " cannot be created; Attribute " + toString(SUMO_ATTR_END) + " must be greather than " + toString(SUMO_ATTR_BEGIN) + ".");
1530  } else if (rerouter != nullptr) {
1531  // save ID of last created element
1532  GNEAdditional* additionalCreated = buildRerouterInterval(viewNet, allowUndoRedo, rerouter, begin, end);
1533  // check if insertion has to be commited
1534  if (insertedAdditionals) {
1535  insertedAdditionals->commitElementInsertion(additionalCreated);
1536  }
1537  return true;
1538  }
1539  }
1540  return false;
1541 }
1542 
1543 
1544 bool
1546  bool abort = false;
1547  // parse attributes of Rerouter
1548  std::string laneID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_CLOSING_LANE_REROUTE, SUMO_ATTR_ID, abort);
1549  std::string allow = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_CLOSING_LANE_REROUTE, SUMO_ATTR_ALLOW, abort);
1550  std::string disallow = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_CLOSING_LANE_REROUTE, SUMO_ATTR_DISALLOW, abort);
1551  // Continue if all parameters were sucesfully loaded
1552  if (!abort) {
1553  // obtain lane and rerouter interval
1554  GNELane* lane = viewNet->getNet()->retrieveLane(laneID, false, true);
1555  GNEAdditional* rerouterInterval = nullptr;
1556  // obtain parent depending if we're loading or creating it using GNEAdditionalFrame
1557  if (insertedAdditionals) {
1558  rerouterInterval = insertedAdditionals->retrieveParentAdditional(viewNet, SUMO_TAG_INTERVAL);
1559  } else {
1560  bool ok = true;
1561  rerouterInterval = viewNet->getNet()->retrieveAdditional(SUMO_TAG_INTERVAL, attrs.get<std::string>(GNE_ATTR_PARENT, "", ok));
1562  }
1563  // check that all elements are valid
1564  if (lane == nullptr) {
1565  WRITE_WARNING("The lane '" + laneID + "' to use within the " + toString(SUMO_TAG_CLOSING_LANE_REROUTE) + " is not known.");
1566  } else if (rerouterInterval != nullptr) {
1567  // save ID of last created element
1568  GNEAdditional* additionalCreated = buildClosingLaneReroute(viewNet, allowUndoRedo, rerouterInterval, lane, parseVehicleClasses(allow, disallow));
1569  // check if insertion has to be commited
1570  if (insertedAdditionals) {
1571  insertedAdditionals->commitElementInsertion(additionalCreated);
1572  }
1573  return true;
1574  }
1575  }
1576  return false;
1577 }
1578 
1579 
1580 bool
1582  bool abort = false;
1583  // parse attributes of Rerouter
1584  std::string edgeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_CLOSING_REROUTE, SUMO_ATTR_ID, abort);
1585  std::string allow = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_CLOSING_REROUTE, SUMO_ATTR_ALLOW, abort);
1586  std::string disallow = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_CLOSING_REROUTE, SUMO_ATTR_DISALLOW, abort);
1587  // Continue if all parameters were sucesfully loaded
1588  if (!abort) {
1589  // obtain edge and rerouter interval
1590  GNEEdge* edge = viewNet->getNet()->retrieveEdge(edgeID, false);
1591  GNEAdditional* rerouterInterval = nullptr;
1592  // obtain parent depending if we're loading or creating it using GNEAdditionalFrame
1593  if (insertedAdditionals) {
1594  rerouterInterval = insertedAdditionals->retrieveParentAdditional(viewNet, SUMO_TAG_INTERVAL);
1595  } else {
1596  bool ok = true;
1597  rerouterInterval = viewNet->getNet()->retrieveAdditional(SUMO_TAG_INTERVAL, attrs.get<std::string>(GNE_ATTR_PARENT, "", ok));
1598  }
1599  // check that all elements are valid
1600  if (edge == nullptr) {
1601  WRITE_WARNING("The edge '" + edgeID + "' to use within the " + toString(SUMO_TAG_CLOSING_REROUTE) + " is not known.");
1602  } else if (rerouterInterval != nullptr) {
1603  // save ID of last created element
1604  GNEAdditional* additionalCreated = buildClosingReroute(viewNet, allowUndoRedo, rerouterInterval, edge, parseVehicleClasses(allow, disallow));
1605  // check if insertion has to be commited
1606  if (insertedAdditionals) {
1607  insertedAdditionals->commitElementInsertion(additionalCreated);
1608  }
1609  return true;
1610  }
1611  }
1612  return false;
1613 }
1614 
1615 
1616 bool
1618  bool abort = false;
1619  // parse attributes of Rerouter
1620  std::string edgeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_DEST_PROB_REROUTE, SUMO_ATTR_ID, abort);
1621  double probability = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, "", SUMO_TAG_DEST_PROB_REROUTE, SUMO_ATTR_PROB, abort);
1622  // Continue if all parameters were sucesfully loaded
1623  if (!abort) {
1624  // obtain edge and rerouter interval
1625  GNEEdge* edge = viewNet->getNet()->retrieveEdge(edgeID, false);
1626  GNEAdditional* rerouterInterval = nullptr;
1627  // obtain parent depending if we're loading or creating it using GNEAdditionalFrame
1628  if (insertedAdditionals) {
1629  rerouterInterval = insertedAdditionals->retrieveParentAdditional(viewNet, SUMO_TAG_INTERVAL);
1630  } else {
1631  bool ok = true;
1632  rerouterInterval = viewNet->getNet()->retrieveAdditional(SUMO_TAG_INTERVAL, attrs.get<std::string>(GNE_ATTR_PARENT, "", ok));
1633  }
1634  // check that all elements are valid
1635  if (edge == nullptr) {
1636  WRITE_WARNING("The edge '" + edgeID + "' to use within the " + toString(SUMO_TAG_DEST_PROB_REROUTE) + " is not known.");
1637  } else if (rerouterInterval != nullptr) {
1638  // save ID of last created element
1639  GNEAdditional* additionalCreated = builDestProbReroute(viewNet, allowUndoRedo, rerouterInterval, edge, probability);
1640  // check if insertion has to be commited
1641  if (insertedAdditionals) {
1642  insertedAdditionals->commitElementInsertion(additionalCreated);
1643  }
1644  return true;
1645  }
1646  }
1647  return false;
1648 }
1649 
1650 
1651 bool
1653  bool abort = false;
1654  // parse attributes of Rerouter
1655  std::string parkingAreaID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_PARKING_ZONE_REROUTE, SUMO_ATTR_ID, abort);
1656  double probability = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, "", SUMO_TAG_PARKING_ZONE_REROUTE, SUMO_ATTR_PROB, abort);
1657  bool visible = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, "", SUMO_TAG_PARKING_ZONE_REROUTE, SUMO_ATTR_VISIBLE, abort);
1658  // Continue if all parameters were sucesfully loaded
1659  if (!abort) {
1660  // obtain edge and rerouter interval
1661  GNEAdditional* parkingArea = viewNet->getNet()->retrieveAdditional(SUMO_TAG_PARKING_AREA, parkingAreaID, false);
1662  GNEAdditional* rerouterInterval = nullptr;
1663  // obtain parent depending if we're loading or creating it using GNEAdditionalFrame
1664  if (insertedAdditionals) {
1665  rerouterInterval = insertedAdditionals->retrieveParentAdditional(viewNet, SUMO_TAG_INTERVAL);
1666  } else {
1667  bool ok = true;
1668  rerouterInterval = viewNet->getNet()->retrieveAdditional(SUMO_TAG_INTERVAL, attrs.get<std::string>(GNE_ATTR_PARENT, "", ok));
1669  }
1670  // check that all elements are valid
1671  if (parkingArea == nullptr) {
1672  WRITE_WARNING("The parkingArea '" + parkingAreaID + "' to use within the " + toString(SUMO_TAG_PARKING_ZONE_REROUTE) + " is not known.");
1673  } else if (rerouterInterval != nullptr) {
1674  // save ID of last created element
1675  GNEAdditional* additionalCreated = builParkingAreaReroute(viewNet, allowUndoRedo, rerouterInterval, parkingArea, probability, visible);
1676  // check if insertion has to be commited
1677  if (insertedAdditionals) {
1678  insertedAdditionals->commitElementInsertion(additionalCreated);
1679  }
1680  return true;
1681  }
1682  }
1683  return false;
1684 }
1685 
1686 
1687 bool
1689  bool abort = false;
1690  // parse attributes of Rerouter
1691  std::string routeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_ROUTE_PROB_REROUTE, SUMO_ATTR_ID, abort);
1692  double probability = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, "", SUMO_TAG_ROUTE_PROB_REROUTE, SUMO_ATTR_PROB, abort);
1693  // Continue if all parameters were sucesfully loaded
1694  if (!abort) {
1695  // obtain rerouter interval
1696  GNEAdditional* rerouterInterval = nullptr;
1697  // obtain parent depending if we're loading or creating it using GNEAdditionalFrame
1698  if (insertedAdditionals) {
1699  rerouterInterval = insertedAdditionals->retrieveParentAdditional(viewNet, SUMO_TAG_INTERVAL);
1700  } else {
1701  bool ok = true;
1702  rerouterInterval = viewNet->getNet()->retrieveAdditional(SUMO_TAG_INTERVAL, attrs.get<std::string>(GNE_ATTR_PARENT, "", ok));
1703  }
1704  // check that all elements are valid
1705  if (rerouterInterval != nullptr) {
1706  // save ID of last created element
1707  GNEAdditional* additionalCreated = buildRouteProbReroute(viewNet, allowUndoRedo, rerouterInterval, routeID, probability);
1708  // check if insertion has to be commited
1709  if (insertedAdditionals) {
1710  insertedAdditionals->commitElementInsertion(additionalCreated);
1711  }
1712  return true;
1713  }
1714  }
1715  return false;
1716 }
1717 
1718 
1719 bool
1720 GNEAdditionalHandler::parseAndBuildBusStop(GNEViewNet* viewNet, bool allowUndoRedo, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
1721  bool abort = false;
1722  // parse attributes of bus stop
1723  std::string id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_BUS_STOP, SUMO_ATTR_ID, abort);
1724  std::string laneId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_BUS_STOP, SUMO_ATTR_LANE, abort);
1725  std::string startPos = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_BUS_STOP, SUMO_ATTR_STARTPOS, abort);
1726  std::string endPos = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_BUS_STOP, SUMO_ATTR_ENDPOS, abort);
1727  std::string name = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_BUS_STOP, SUMO_ATTR_NAME, abort);
1728  std::vector<std::string> lines = GNEAttributeCarrier::parseAttributeFromXML<std::vector<std::string> >(attrs, id, SUMO_TAG_BUS_STOP, SUMO_ATTR_LINES, abort);
1729  const int personCapacity = GNEAttributeCarrier::parseAttributeFromXML<int>(attrs, id, SUMO_TAG_BUS_STOP, SUMO_ATTR_PERSON_CAPACITY, abort);
1730  bool friendlyPosition = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_BUS_STOP, SUMO_ATTR_FRIENDLY_POS, abort);
1731  // parse Netedit attributes
1732  bool blockMovement = false;
1733  if (attrs.hasAttribute(GNE_ATTR_BLOCK_MOVEMENT)) {
1734  blockMovement = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_BUS_STOP, GNE_ATTR_BLOCK_MOVEMENT, abort);
1735  }
1736  // Continue if all parameters were sucesfully loaded
1737  if (!abort) {
1738  // get pointer to lane
1739  GNELane* lane = viewNet->getNet()->retrieveLane(laneId, false, true);
1740  // check that all elements are valid
1741  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_BUS_STOP, id, false) != nullptr) {
1742  WRITE_WARNING("There is another " + toString(SUMO_TAG_BUS_STOP) + " with the same ID='" + id + "'.");
1743  } else if (lane == nullptr) {
1744  // Write error if lane isn't valid
1745  WRITE_WARNING("The lane '" + laneId + "' to use within the " + toString(SUMO_TAG_BUS_STOP) + " '" + id + "' is not known.");
1746  } else {
1747  // declare variables for start and end position
1748  double startPosDouble = 0;
1749  double endPosDouble = lane->getParentEdge()->getNBEdge()->getFinalLength();
1750  const double stoppingPlaceLength = (endPosDouble - startPosDouble);
1751  int parametersSet = 0;
1752  // check if startPos and endPos were defined
1753  if (GNEAttributeCarrier::canParse<double>(startPos)) {
1754  startPosDouble = GNEAttributeCarrier::parse<double>(startPos);
1755  parametersSet |= STOPPINGPLACE_STARTPOS_SET;
1756  }
1757  if (GNEAttributeCarrier::canParse<double>(endPos)) {
1758  endPosDouble = GNEAttributeCarrier::parse<double>(endPos);
1759  parametersSet |= STOPPINGPLACE_ENDPOS_SET;
1760  }
1761  // check if stoppingPlace has to be adjusted
1762  SUMORouteHandler::StopPos checkStopPosResult = SUMORouteHandler::checkStopPos(startPosDouble, endPosDouble, lane->getParentEdge()->getNBEdge()->getFinalLength(), POSITION_EPS, friendlyPosition);
1763  // update start and end positions depending of checkStopPosResult
1764  if (checkStopPosResult == SUMORouteHandler::StopPos::STOPPOS_INVALID_STARTPOS) {
1765  startPosDouble = 0;
1766  endPosDouble = stoppingPlaceLength;
1767  } else if (checkStopPosResult == SUMORouteHandler::StopPos::STOPPOS_INVALID_ENDPOS) {
1768  startPosDouble = lane->getParentEdge()->getNBEdge()->getFinalLength() - stoppingPlaceLength;
1769  endPosDouble = lane->getParentEdge()->getNBEdge()->getFinalLength();
1770  } else if (checkStopPosResult == SUMORouteHandler::StopPos::STOPPOS_INVALID_LANELENGTH) {
1771  // Write error if position isn't valid
1772  WRITE_WARNING("Invalid position for " + toString(SUMO_TAG_BUS_STOP) + " with ID = '" + id + "'.");
1773  return false;
1774  }
1775  // save ID of last created element
1776  GNEAdditional* additionalCreated = buildBusStop(viewNet, allowUndoRedo, id, lane, startPosDouble, endPosDouble, parametersSet,
1777  name, lines, personCapacity, friendlyPosition, blockMovement);
1778  // check if insertion has to be commited
1779  if (insertedAdditionals) {
1780  insertedAdditionals->commitElementInsertion(additionalCreated);
1781  }
1782  return true;
1783  }
1784  }
1785  return false;
1786 }
1787 
1788 
1789 bool
1790 GNEAdditionalHandler::parseAndBuildContainerStop(GNEViewNet* viewNet, bool allowUndoRedo, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
1791  bool abort = false;
1792  // parse attributes of container stop
1793  std::string id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_CONTAINER_STOP, SUMO_ATTR_ID, abort);
1794  std::string laneId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_CONTAINER_STOP, SUMO_ATTR_LANE, abort);
1795  std::string startPos = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_CONTAINER_STOP, SUMO_ATTR_STARTPOS, abort);
1796  std::string endPos = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_CONTAINER_STOP, SUMO_ATTR_ENDPOS, abort);
1797  std::string name = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_CONTAINER_STOP, SUMO_ATTR_NAME, abort);
1798  std::vector<std::string> lines = GNEAttributeCarrier::parseAttributeFromXML<std::vector<std::string> >(attrs, id, SUMO_TAG_CONTAINER_STOP, SUMO_ATTR_LINES, abort);
1799  bool friendlyPosition = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_CONTAINER_STOP, SUMO_ATTR_FRIENDLY_POS, abort);
1800  // parse Netedit attributes
1801  bool blockMovement = false;
1802  if (attrs.hasAttribute(GNE_ATTR_BLOCK_MOVEMENT)) {
1803  blockMovement = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_CONTAINER_STOP, GNE_ATTR_BLOCK_MOVEMENT, abort);
1804  }
1805  // Continue if all parameters were sucesfully loaded
1806  if (!abort) {
1807  // get pointer to lane
1808  GNELane* lane = viewNet->getNet()->retrieveLane(laneId, false, true);
1809  // check that all elements are valid
1810  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_CONTAINER_STOP, id, false) != nullptr) {
1811  WRITE_WARNING("There is another " + toString(SUMO_TAG_CONTAINER_STOP) + " with the same ID='" + id + "'.");
1812  } else if (lane == nullptr) {
1813  // Write error if lane isn't valid
1814  WRITE_WARNING("The lane '" + laneId + "' to use within the " + toString(SUMO_TAG_CONTAINER_STOP) + " '" + id + "' is not known.");
1815  } else {
1816  // declare variables for start and end position
1817  double startPosDouble = 0;
1818  double endPosDouble = lane->getParentEdge()->getNBEdge()->getFinalLength();
1819  const double stoppingPlaceLength = (endPosDouble - startPosDouble);
1820  int parametersSet = 0;
1821  // check if startPos and endPos were defined
1822  if (GNEAttributeCarrier::canParse<double>(startPos)) {
1823  startPosDouble = GNEAttributeCarrier::parse<double>(startPos);
1824  parametersSet |= STOPPINGPLACE_STARTPOS_SET;
1825  }
1826  if (GNEAttributeCarrier::canParse<double>(endPos)) {
1827  endPosDouble = GNEAttributeCarrier::parse<double>(endPos);
1828  parametersSet |= STOPPINGPLACE_ENDPOS_SET;
1829  }
1830  // check if stoppingPlace has to be adjusted
1831  SUMORouteHandler::StopPos checkStopPosResult = SUMORouteHandler::checkStopPos(startPosDouble, endPosDouble, lane->getParentEdge()->getNBEdge()->getFinalLength(), POSITION_EPS, friendlyPosition);
1832  // update start and end positions depending of checkStopPosResult
1833  if (checkStopPosResult == SUMORouteHandler::StopPos::STOPPOS_INVALID_STARTPOS) {
1834  startPosDouble = 0;
1835  endPosDouble = stoppingPlaceLength;
1836  } else if (checkStopPosResult == SUMORouteHandler::StopPos::STOPPOS_INVALID_ENDPOS) {
1837  startPosDouble = lane->getParentEdge()->getNBEdge()->getFinalLength() - stoppingPlaceLength;
1838  endPosDouble = lane->getParentEdge()->getNBEdge()->getFinalLength();
1839  } else if (checkStopPosResult == SUMORouteHandler::StopPos::STOPPOS_INVALID_LANELENGTH) {
1840  // Write error if position isn't valid
1841  WRITE_WARNING("Invalid position for " + toString(SUMO_TAG_CONTAINER_STOP) + " with ID = '" + id + "'.");
1842  return false;
1843  }
1844  // save ID of last created element
1845  GNEAdditional* additionalCreated = buildContainerStop(viewNet, allowUndoRedo, id, lane, startPosDouble, endPosDouble, parametersSet,
1846  name, lines, friendlyPosition, blockMovement);
1847  // check if insertion has to be commited
1848  if (insertedAdditionals) {
1849  insertedAdditionals->commitElementInsertion(additionalCreated);
1850  }
1851  return true;
1852  }
1853  }
1854  return false;
1855 }
1856 
1857 
1858 bool
1859 GNEAdditionalHandler::parseAndBuildAccess(GNEViewNet* viewNet, bool allowUndoRedo, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
1860  bool abort = false;
1861  // parse attributes of Entry
1862  std::string laneId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_ACCESS, SUMO_ATTR_LANE, abort);
1863  std::string position = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_ACCESS, SUMO_ATTR_POSITION, abort);
1864  std::string length = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_ACCESS, SUMO_ATTR_LENGTH, abort);
1865  bool friendlyPos = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, "", SUMO_TAG_ACCESS, SUMO_ATTR_FRIENDLY_POS, abort);
1866  // parse Netedit attributes
1867  bool blockMovement = false;
1869  blockMovement = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, "", SUMO_TAG_ACCESS, GNE_ATTR_BLOCK_MOVEMENT, abort);
1870  }
1871  // Check if parsing of parameters was correct
1872  if (!abort) {
1873  double posDouble = GNEAttributeCarrier::parse<double>(position);
1874  // get lane and busStop parent
1875  GNELane* lane = viewNet->getNet()->retrieveLane(laneId, false, true);
1876  GNEAdditional* busStop = nullptr;
1877  // obtain parent depending if we're loading or creating it using GNEAdditionalFrame
1878  if (insertedAdditionals) {
1879  busStop = insertedAdditionals->retrieveParentAdditional(viewNet, SUMO_TAG_BUS_STOP);
1880  } else {
1881  bool ok = true;
1882  busStop = viewNet->getNet()->retrieveAdditional(SUMO_TAG_BUS_STOP, attrs.get<std::string>(GNE_ATTR_PARENT, "", ok));
1883  }
1884  // check that all parameters are valid
1885  if (lane == nullptr) {
1886  WRITE_WARNING("The lane '" + laneId + "' to use within the " + toString(SUMO_TAG_ACCESS) + " is not known.");
1887  } else if (busStop == nullptr) {
1888  WRITE_WARNING("A " + toString(SUMO_TAG_ACCESS) + " must be declared within the definition of a " + toString(SUMO_TAG_BUS_STOP) + ".");
1889  } else if (!checkAndFixDetectorPosition(posDouble, lane->getLaneShapeLength(), friendlyPos)) {
1890  WRITE_WARNING("Invalid position for " + toString(SUMO_TAG_ACCESS) + ".");
1891  } else if (!accessCanBeCreated(busStop, lane->getParentEdge())) {
1892  WRITE_WARNING("Edge '" + lane->getParentEdge()->getID() + "' already has an Access for busStop '" + busStop->getID() + "'");
1893  } else {
1894  // save ID of last created element
1895  GNEAdditional* additionalCreated = buildAccess(viewNet, allowUndoRedo, busStop, lane, posDouble, length, friendlyPos, blockMovement);
1896  // check if insertion has to be commited
1897  if (insertedAdditionals) {
1898  insertedAdditionals->commitElementInsertion(additionalCreated);
1899  }
1900  return true;
1901  }
1902  }
1903  return false;
1904 }
1905 
1906 
1907 bool
1909  bool abort = false;
1910  // parse attributes of charging station
1911  std::string id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_CHARGING_STATION, SUMO_ATTR_ID, abort);
1912  std::string laneId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_CHARGING_STATION, SUMO_ATTR_LANE, abort);
1913  std::string startPos = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_CHARGING_STATION, SUMO_ATTR_STARTPOS, abort);
1914  std::string endPos = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_CHARGING_STATION, SUMO_ATTR_ENDPOS, abort);
1915  std::string name = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_CHARGING_STATION, SUMO_ATTR_NAME, abort);
1916  double chargingPower = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, SUMO_TAG_CHARGING_STATION, SUMO_ATTR_CHARGINGPOWER, abort);
1917  double efficiency = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, SUMO_TAG_CHARGING_STATION, SUMO_ATTR_EFFICIENCY, abort);
1918  bool chargeInTransit = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_CHARGING_STATION, SUMO_ATTR_CHARGEINTRANSIT, abort);
1919  SUMOTime chargeDelay = GNEAttributeCarrier::parseAttributeFromXML<SUMOTime>(attrs, id, SUMO_TAG_CHARGING_STATION, SUMO_ATTR_CHARGEDELAY, abort);
1920  bool friendlyPosition = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_CHARGING_STATION, SUMO_ATTR_FRIENDLY_POS, abort);
1921  // parse Netedit attributes
1922  bool blockMovement = false;
1924  blockMovement = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_CHARGING_STATION, GNE_ATTR_BLOCK_MOVEMENT, abort);
1925  }
1926  // Continue if all parameters were sucesfully loaded
1927  if (!abort) {
1928  // get pointer to lane
1929  GNELane* lane = viewNet->getNet()->retrieveLane(laneId, false, true);
1930  // check that all elements are valid
1931  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_CHARGING_STATION, id, false) != nullptr) {
1932  WRITE_WARNING("There is another " + toString(SUMO_TAG_CHARGING_STATION) + " with the same ID='" + id + "'.");
1933  } else if (lane == nullptr) {
1934  // Write error if lane isn't valid
1935  WRITE_WARNING("The lane '" + laneId + "' to use within the " + toString(SUMO_TAG_CHARGING_STATION) + " '" + id + "' is not known.");
1936  } else {
1937  // declare variables for start and end position
1938  double startPosDouble = 0;
1939  double endPosDouble = lane->getParentEdge()->getNBEdge()->getFinalLength();
1940  const double stoppingPlaceLength = (endPosDouble - startPosDouble);
1941  int parametersSet = 0;
1942  // check if startPos and endPos were defined
1943  if (GNEAttributeCarrier::canParse<double>(startPos)) {
1944  startPosDouble = GNEAttributeCarrier::parse<double>(startPos);
1945  parametersSet |= STOPPINGPLACE_STARTPOS_SET;
1946  }
1947  if (GNEAttributeCarrier::canParse<double>(endPos)) {
1948  endPosDouble = GNEAttributeCarrier::parse<double>(endPos);
1949  parametersSet |= STOPPINGPLACE_ENDPOS_SET;
1950  }
1951  // check if stoppingPlace has to be adjusted
1952  SUMORouteHandler::StopPos checkStopPosResult = SUMORouteHandler::checkStopPos(startPosDouble, endPosDouble, lane->getParentEdge()->getNBEdge()->getFinalLength(), POSITION_EPS, friendlyPosition);
1953  // update start and end positions depending of checkStopPosResult
1954  if (checkStopPosResult == SUMORouteHandler::StopPos::STOPPOS_INVALID_STARTPOS) {
1955  startPosDouble = 0;
1956  endPosDouble = stoppingPlaceLength;
1957  } else if (checkStopPosResult == SUMORouteHandler::StopPos::STOPPOS_INVALID_ENDPOS) {
1958  startPosDouble = lane->getParentEdge()->getNBEdge()->getFinalLength() - stoppingPlaceLength;
1959  endPosDouble = lane->getParentEdge()->getNBEdge()->getFinalLength();
1960  } else if (checkStopPosResult == SUMORouteHandler::StopPos::STOPPOS_INVALID_LANELENGTH) {
1961  // Write error if position isn't valid
1962  WRITE_WARNING("Invalid position for " + toString(SUMO_TAG_CHARGING_STATION) + " with ID = '" + id + "'.");
1963  return false;
1964  }
1965  // save ID of last created element
1966  GNEAdditional* additionalCreated = buildChargingStation(viewNet, allowUndoRedo, id, lane, startPosDouble, endPosDouble, parametersSet,
1967  name, chargingPower, efficiency, chargeInTransit, chargeDelay, friendlyPosition, blockMovement);
1968  // check if insertion has to be commited
1969  if (insertedAdditionals) {
1970  insertedAdditionals->commitElementInsertion(additionalCreated);
1971  }
1972  return true;
1973  }
1974  }
1975  return false;
1976 }
1977 
1978 
1979 bool
1980 GNEAdditionalHandler::parseAndBuildParkingArea(GNEViewNet* viewNet, bool allowUndoRedo, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
1981  bool abort = false;
1982  // parse attributes of charging station
1983  std::string id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_PARKING_AREA, SUMO_ATTR_ID, abort);
1984  std::string laneId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_PARKING_AREA, SUMO_ATTR_LANE, abort);
1985  std::string startPos = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_PARKING_AREA, SUMO_ATTR_STARTPOS, abort);
1986  std::string endPos = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_PARKING_AREA, SUMO_ATTR_ENDPOS, abort);
1987  std::string name = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_PARKING_AREA, SUMO_ATTR_NAME, abort);
1988  bool friendlyPosition = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_PARKING_AREA, SUMO_ATTR_FRIENDLY_POS, abort);
1989  int roadSideCapacity = GNEAttributeCarrier::parseAttributeFromXML<int>(attrs, id, SUMO_TAG_PARKING_AREA, SUMO_ATTR_ROADSIDE_CAPACITY, abort);
1990  bool onRoad = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_PARKING_AREA, SUMO_ATTR_ONROAD, abort);
1991  double width = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, SUMO_TAG_PARKING_AREA, SUMO_ATTR_WIDTH, abort);
1992  std::string length = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_PARKING_AREA, SUMO_ATTR_LENGTH, abort);
1993  double angle = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, SUMO_TAG_PARKING_AREA, SUMO_ATTR_ANGLE, abort);
1994  // parse Netedit attributes
1995  bool blockMovement = false;
1997  blockMovement = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_PARKING_AREA, GNE_ATTR_BLOCK_MOVEMENT, abort);
1998  }
1999  // Continue if all parameters were sucesfully loaded
2000  if (!abort) {
2001  // get pointer to lane
2002  GNELane* lane = viewNet->getNet()->retrieveLane(laneId, false, true);
2003  // check that all elements are valid
2004  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_PARKING_AREA, id, false) != nullptr) {
2005  WRITE_WARNING("There is another " + toString(SUMO_TAG_PARKING_AREA) + " with the same ID='" + id + "'.");
2006  } else if (lane == nullptr) {
2007  // Write error if lane isn't valid
2008  WRITE_WARNING("The lane '" + laneId + "' to use within the " + toString(SUMO_TAG_PARKING_AREA) + " '" + id + "' is not known.");
2009  } else {
2010  // declare variables for start and end position
2011  double startPosDouble = 0;
2012  double endPosDouble = lane->getParentEdge()->getNBEdge()->getFinalLength();
2013  const double stoppingPlaceLength = (endPosDouble - startPosDouble);
2014  int parametersSet = 0;
2015  // check if startPos and endPos were defined
2016  if (GNEAttributeCarrier::canParse<double>(startPos)) {
2017  startPosDouble = GNEAttributeCarrier::parse<double>(startPos);
2018  parametersSet |= STOPPINGPLACE_STARTPOS_SET;
2019  }
2020  if (GNEAttributeCarrier::canParse<double>(endPos)) {
2021  endPosDouble = GNEAttributeCarrier::parse<double>(endPos);
2022  parametersSet |= STOPPINGPLACE_ENDPOS_SET;
2023  }
2024  // check if stoppingPlace has to be adjusted
2025  SUMORouteHandler::StopPos checkStopPosResult = SUMORouteHandler::checkStopPos(startPosDouble, endPosDouble, lane->getParentEdge()->getNBEdge()->getFinalLength(), POSITION_EPS, friendlyPosition);
2026  // update start and end positions depending of checkStopPosResult
2027  if (checkStopPosResult == SUMORouteHandler::StopPos::STOPPOS_INVALID_STARTPOS) {
2028  startPosDouble = 0;
2029  endPosDouble = stoppingPlaceLength;
2030  } else if (checkStopPosResult == SUMORouteHandler::StopPos::STOPPOS_INVALID_ENDPOS) {
2031  startPosDouble = lane->getParentEdge()->getNBEdge()->getFinalLength() - stoppingPlaceLength;
2032  endPosDouble = lane->getParentEdge()->getNBEdge()->getFinalLength();
2033  } else if (checkStopPosResult == SUMORouteHandler::StopPos::STOPPOS_INVALID_LANELENGTH) {
2034  // Write error if position isn't valid
2035  WRITE_WARNING("Invalid position for " + toString(SUMO_TAG_PARKING_AREA) + " with ID = '" + id + "'.");
2036  return false;
2037  }
2038  // save ID of last created element
2039  GNEAdditional* additionalCreated = buildParkingArea(viewNet, allowUndoRedo, id, lane, startPosDouble, endPosDouble, parametersSet,
2040  name, friendlyPosition, roadSideCapacity, onRoad, width, length, angle, blockMovement);
2041  // check if insertion has to be commited
2042  if (insertedAdditionals) {
2043  insertedAdditionals->commitElementInsertion(additionalCreated);
2044  }
2045  return true;
2046  }
2047  }
2048  return false;
2049 }
2050 
2051 
2052 bool
2053 GNEAdditionalHandler::parseAndBuildParkingSpace(GNEViewNet* viewNet, bool allowUndoRedo, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
2054  bool abort = false;
2055  // parse attributes of Parking Spaces
2056  Position pos = GNEAttributeCarrier::parseAttributeFromXML<Position>(attrs, "", SUMO_TAG_PARKING_SPACE, SUMO_ATTR_POSITION, abort);
2057  double width = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, "", SUMO_TAG_PARKING_SPACE, SUMO_ATTR_WIDTH, abort);
2058  double length = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, "", SUMO_TAG_PARKING_SPACE, SUMO_ATTR_LENGTH, abort);
2059  double angle = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, "", SUMO_TAG_PARKING_SPACE, SUMO_ATTR_ANGLE, abort);
2060  // parse Netedit attributes
2061  bool blockMovement = false;
2063  blockMovement = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, "", SUMO_TAG_PARKING_SPACE, GNE_ATTR_BLOCK_MOVEMENT, abort);
2064  }
2065  // Continue if all parameters were sucesfully loaded
2066  if (!abort) {
2067  // get Parking Area Parent
2068  GNEAdditional* parkingAreaParent = nullptr;
2069  // obtain parent depending if we're loading or creating it using GNEAdditionalFrame
2070  if (insertedAdditionals) {
2071  parkingAreaParent = insertedAdditionals->retrieveParentAdditional(viewNet, SUMO_TAG_PARKING_AREA);
2072  } else {
2073  bool ok = true;
2074  parkingAreaParent = viewNet->getNet()->retrieveAdditional(SUMO_TAG_PARKING_AREA, attrs.get<std::string>(GNE_ATTR_PARENT, "", ok));
2075  }
2076  // check that Parking Area Parent exists
2077  if (parkingAreaParent != nullptr) {
2078  // save ID of last created element
2079  GNEAdditional* additionalCreated = buildParkingSpace(viewNet, allowUndoRedo, parkingAreaParent, pos, width, length, angle, blockMovement);
2080  // check if insertion has to be commited
2081  if (insertedAdditionals) {
2082  insertedAdditionals->commitElementInsertion(additionalCreated);
2083  }
2084  return true;
2085  }
2086  }
2087  return false;
2088 }
2089 
2090 
2091 bool
2092 GNEAdditionalHandler::parseAndBuildCalibrator(GNEViewNet* viewNet, bool allowUndoRedo, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
2093  bool abort = false;
2094  // due there is two differents calibrators, has to be parsed in a different way
2095  std::string edgeID, laneId, id;
2096  // change tag depending of XML parmeters
2097  if (attrs.hasAttribute(SUMO_ATTR_EDGE)) {
2098  id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_CALIBRATOR, SUMO_ATTR_ID, abort);
2099  edgeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_CALIBRATOR, SUMO_ATTR_EDGE, abort);
2100  std::string outfile = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_CALIBRATOR, SUMO_ATTR_OUTPUT, abort);
2101  double position = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, SUMO_TAG_CALIBRATOR, SUMO_ATTR_POSITION, abort);
2102  std::string name = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_CALIBRATOR, SUMO_ATTR_NAME, abort);
2103  SUMOTime freq = GNEAttributeCarrier::parseAttributeFromXML<SUMOTime>(attrs, id, SUMO_TAG_CALIBRATOR, SUMO_ATTR_FREQUENCY, abort);
2104  std::string routeProbe = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_CALIBRATOR, SUMO_ATTR_ROUTEPROBE, abort);
2105  // extra check for center element after creation
2106  bool centerAfterCreation = attrs.hasAttribute(GNE_ATTR_CENTER_AFTER_CREATION);
2107  // Continue if all parameters were sucesfully loaded
2108  if (!abort) {
2109  // get pointer and edge
2110  GNEEdge* edge = viewNet->getNet()->retrieveEdge(edgeID, false);
2111  // check that all elements are valid
2112  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_CALIBRATOR, id, false) != nullptr) {
2113  WRITE_WARNING("There is another " + toString(SUMO_TAG_CALIBRATOR) + " with the same ID='" + id + "'.");
2114  } else if (edge == nullptr) {
2115  WRITE_WARNING("The edge '" + edgeID + "' to use within the " + toString(SUMO_TAG_CALIBRATOR) + " '" + id + "' is not known.");
2116  } else {
2117  // save ID of last created element
2118  GNEAdditional* additionalCreated = buildCalibrator(viewNet, allowUndoRedo, id, edge, position, name, outfile, freq, routeProbe, centerAfterCreation);
2119  // check if insertion has to be commited
2120  if (insertedAdditionals) {
2121  insertedAdditionals->commitElementInsertion(additionalCreated);
2122  }
2123  return true;
2124  }
2125  }
2126  } else if (attrs.hasAttribute(SUMO_ATTR_LANE)) {
2127  id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_LANECALIBRATOR, SUMO_ATTR_ID, abort);
2128  laneId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_LANECALIBRATOR, SUMO_ATTR_LANE, abort);
2129  std::string outfile = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_LANECALIBRATOR, SUMO_ATTR_OUTPUT, abort);
2130  double position = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, SUMO_TAG_LANECALIBRATOR, SUMO_ATTR_POSITION, abort);
2131  std::string name = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_LANECALIBRATOR, SUMO_ATTR_NAME, abort);
2132  SUMOTime freq = GNEAttributeCarrier::parseAttributeFromXML<SUMOTime>(attrs, id, SUMO_TAG_LANECALIBRATOR, SUMO_ATTR_FREQUENCY, abort);
2133  std::string routeProbe = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_LANECALIBRATOR, SUMO_ATTR_ROUTEPROBE, abort);
2134  // extra check for center element after creation
2135  bool centerAfterCreation = attrs.hasAttribute(GNE_ATTR_CENTER_AFTER_CREATION);
2136  // Continue if all parameters were sucesfully loaded
2137  if (!abort) {
2138  // get pointer to lane
2139  GNELane* lane = viewNet->getNet()->retrieveLane(laneId, false, true);
2140  // check that all elements are valid
2141  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_LANECALIBRATOR, id, false) != nullptr) {
2142  WRITE_WARNING("There is another " + toString(SUMO_TAG_CALIBRATOR) + " with the same ID='" + id + "'.");
2143  } else if (lane == nullptr) {
2144  WRITE_WARNING("The lane '" + laneId + "' to use within the " + toString(SUMO_TAG_CALIBRATOR) + " '" + id + "' is not known.");
2145  } else {
2146  // save ID of last created element
2147  GNEAdditional* additionalCreated = buildCalibrator(viewNet, allowUndoRedo, id, lane, position, name, outfile, freq, routeProbe, centerAfterCreation);
2148  // check if insertion has to be commited
2149  if (insertedAdditionals) {
2150  insertedAdditionals->commitElementInsertion(additionalCreated);
2151  }
2152  return true;
2153  }
2154  }
2155  } else {
2156  WRITE_WARNING("additional " + toString(SUMO_TAG_CALIBRATOR) + " must have either a lane or an edge attribute.");
2157  }
2158  return false;
2159 }
2160 
2161 
2162 bool
2163 GNEAdditionalHandler::parseAndBuildDetectorE1(GNEViewNet* viewNet, bool allowUndoRedo, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
2164  bool abort = false;
2165  // parse attributes of E1
2166  std::string id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_E1DETECTOR, SUMO_ATTR_ID, abort);
2167  std::string laneId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_E1DETECTOR, SUMO_ATTR_LANE, abort);
2168  double position = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, SUMO_TAG_E1DETECTOR, SUMO_ATTR_POSITION, abort);
2169  SUMOTime frequency = GNEAttributeCarrier::parseAttributeFromXML<SUMOTime>(attrs, id, SUMO_TAG_E1DETECTOR, SUMO_ATTR_FREQUENCY, abort);
2170  std::string file = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_E1DETECTOR, SUMO_ATTR_FILE, abort);
2171  std::string vehicleTypes = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_E1DETECTOR, SUMO_ATTR_VTYPES, abort);
2172  std::string name = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_E1DETECTOR, SUMO_ATTR_NAME, abort);
2173  bool friendlyPos = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_E1DETECTOR, SUMO_ATTR_FRIENDLY_POS, abort);
2174  // parse Netedit attributes
2175  bool blockMovement = false;
2177  blockMovement = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_E1DETECTOR, GNE_ATTR_BLOCK_MOVEMENT, abort);
2178  }
2179  // Continue if all parameters were sucesfully loaded
2180  if (!abort) {
2181  // get pointer to lane
2182  GNELane* lane = viewNet->getNet()->retrieveLane(laneId, false, true);
2183  // check that all elements are valid
2184  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_E1DETECTOR, id, false) != nullptr) {
2185  WRITE_WARNING("There is another " + toString(SUMO_TAG_E1DETECTOR) + " with the same ID='" + id + "'.");
2186  } else if (lane == nullptr) {
2187  // Write error if lane isn't valid
2188  WRITE_WARNING("The lane '" + laneId + "' to use within the " + toString(SUMO_TAG_E1DETECTOR) + " '" + id + "' is not known.");
2189  } else if (!checkAndFixDetectorPosition(position, lane->getLaneShapeLength(), friendlyPos)) {
2190  WRITE_WARNING("Invalid position for " + toString(SUMO_TAG_E1DETECTOR) + " with ID = '" + id + "'.");
2191  } else {
2192  // save ID of last created element
2193  GNEAdditional* additionalCreated = buildDetectorE1(viewNet, allowUndoRedo, id, lane, position, frequency, file, vehicleTypes, name, friendlyPos, blockMovement);
2194  // check if insertion has to be commited
2195  if (insertedAdditionals) {
2196  insertedAdditionals->commitElementInsertion(additionalCreated);
2197  }
2198  return true;
2199  }
2200  }
2201  return false;
2202 }
2203 
2204 
2205 bool
2206 GNEAdditionalHandler::parseAndBuildDetectorE2(GNEViewNet* viewNet, bool allowUndoRedo, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
2207  // Tag E2 detectors can build either E2 single lanes or E2 multilanes, depending of attribute "lanes"
2209  bool abort = false;
2210  // start parsing ID
2211  std::string id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", E2Tag, SUMO_ATTR_ID, abort);
2212  // parse attributes of E2 SingleLanes
2213  std::string laneId = (E2Tag == SUMO_TAG_E2DETECTOR) ? GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, E2Tag, SUMO_ATTR_LANE, abort) : "";
2214  double length = (E2Tag == SUMO_TAG_E2DETECTOR) ? GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, E2Tag, SUMO_ATTR_LENGTH, abort) : 0;
2215  // parse attributes of E2 Multilanes
2216  std::string laneIds = (E2Tag == SUMO_TAG_E2DETECTOR_MULTILANE) ? GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, E2Tag, SUMO_ATTR_LANES, abort) : "";
2217  double endPos = (E2Tag == SUMO_TAG_E2DETECTOR_MULTILANE) ? GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, E2Tag, SUMO_ATTR_ENDPOS, abort) : 0;
2218  // parse common attributes
2219  double position = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, E2Tag, SUMO_ATTR_POSITION, abort);
2220  SUMOTime frequency = GNEAttributeCarrier::parseAttributeFromXML<SUMOTime>(attrs, id, E2Tag, SUMO_ATTR_FREQUENCY, abort);
2221  std::string file = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, E2Tag, SUMO_ATTR_FILE, abort);
2222  std::string vehicleTypes = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, E2Tag, SUMO_ATTR_VTYPES, abort);
2223  std::string name = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, E2Tag, SUMO_ATTR_NAME, abort);
2224  SUMOTime haltingTimeThreshold = GNEAttributeCarrier::parseAttributeFromXML<SUMOTime>(attrs, id, E2Tag, SUMO_ATTR_HALTING_TIME_THRESHOLD, abort);
2225  double haltingSpeedThreshold = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, E2Tag, SUMO_ATTR_HALTING_SPEED_THRESHOLD, abort);
2226  double jamDistThreshold = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, E2Tag, SUMO_ATTR_JAM_DIST_THRESHOLD, abort);
2227  bool friendlyPos = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, E2Tag, SUMO_ATTR_FRIENDLY_POS, abort);
2228  // parse Netedit attributes
2229  bool blockMovement = false;
2231  blockMovement = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, E2Tag, GNE_ATTR_BLOCK_MOVEMENT, abort);
2232  }
2233  // cont attribute is deprecated
2234  GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, E2Tag, SUMO_ATTR_CONT, abort);
2235  // Continue if all parameters were sucesfully loaded
2236  if (!abort) {
2237  // check if at leas lane or laneIDS are defined
2238  if (laneId.empty() && laneIds.empty()) {
2239  WRITE_WARNING("A " + toString(E2Tag) + " needs at least a lane or a list of lanes.");
2240  } else {
2241  // get pointer to lane
2242  GNELane* lane = viewNet->getNet()->retrieveLane(laneId, false, true);
2243  // get list of lanes
2244  std::vector<GNELane*> lanes;
2245  bool laneConsecutives = true;
2246  if (GNEAttributeCarrier::canParse<std::vector<GNELane*> >(viewNet->getNet(), laneIds, false)) {
2247  lanes = GNEAttributeCarrier::parse<std::vector<GNELane*> >(viewNet->getNet(), laneIds);
2248  // check if lanes are consecutives
2249  laneConsecutives = GNEAttributeCarrier::lanesConsecutives(lanes);
2250  }
2251  // check that all elements are valid
2252  if (viewNet->getNet()->retrieveAdditional(E2Tag, id, false) != nullptr) {
2253  // write error if neither lane nor lane aren't defined
2254  WRITE_WARNING("There is another " + toString(E2Tag) + " with the same ID='" + id + "'.");
2255  } else if (attrs.hasAttribute(SUMO_ATTR_LANE) && (lane == nullptr)) {
2256  // Write error if lane isn't valid
2257  WRITE_WARNING("The lane '" + laneId + "' to use within the " + toString(E2Tag) + " '" + id + "' is not known.");
2258  } else if (attrs.hasAttribute(SUMO_ATTR_LANES) && lanes.empty()) {
2259  // Write error if lane isn't valid
2260  WRITE_WARNING("The list of lanes cannot be empty.");
2261  } else if (attrs.hasAttribute(SUMO_ATTR_LANES) && lanes.empty()) {
2262  // Write error if lane isn't valid
2263  WRITE_WARNING("The list of lanes '" + laneIds + "' to use within the " + toString(E2Tag) + " '" + id + "' isn't valid.");
2264  } else if (!lanes.empty() && !laneConsecutives) {
2265  WRITE_WARNING("The lanes '" + laneIds + "' to use within the " + toString(E2Tag) + " '" + id + "' aren't consecutives.");
2266  } else if (lane && !fixE2DetectorPosition(position, length, lane->getParentEdge()->getNBEdge()->getFinalLength(), friendlyPos)) {
2267  WRITE_WARNING("Invalid position for " + toString(E2Tag) + " with ID = '" + id + "'.");
2268  } else if (!lanes.empty() && !fixE2DetectorPosition(position, length, lanes.front()->getParentEdge()->getNBEdge()->getFinalLength(), friendlyPos)) {
2269  WRITE_WARNING("Invalid position for " + toString(E2Tag) + " with ID = '" + id + "'.");
2270  } else if (!lanes.empty() && !fixE2DetectorPosition(endPos, length, lanes.back()->getParentEdge()->getNBEdge()->getFinalLength(), friendlyPos)) {
2271  WRITE_WARNING("Invalid end position for " + toString(E2Tag) + " with ID = '" + id + "'.");
2272  } else if (lane) {
2273  // save ID of last created element
2274  GNEAdditional* additionalCreated = buildSingleLaneDetectorE2(viewNet, allowUndoRedo, id, lane, position, length, frequency, file, vehicleTypes,
2275  name, haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold, friendlyPos, blockMovement);
2276  // check if insertion has to be commited
2277  if (insertedAdditionals) {
2278  insertedAdditionals->commitElementInsertion(additionalCreated);
2279  }
2280  return true;
2281  } else {
2282  // save ID of last created element
2283  GNEAdditional* additionalCreated = buildMultiLaneDetectorE2(viewNet, allowUndoRedo, id, lanes, position, endPos, frequency, file, vehicleTypes,
2284  name, haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold, friendlyPos, blockMovement);
2285  // check if insertion has to be commited
2286  if (insertedAdditionals) {
2287  insertedAdditionals->commitElementInsertion(additionalCreated);
2288  }
2289  return true;
2290  }
2291  }
2292  }
2293  return false;
2294 }
2295 
2296 
2297 bool
2298 GNEAdditionalHandler::parseAndBuildDetectorE3(GNEViewNet* viewNet, bool allowUndoRedo, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
2299  bool abort = false;
2300  // parse attributes of E3
2301  std::string id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_E3DETECTOR, SUMO_ATTR_ID, abort);
2302  SUMOTime frequency = GNEAttributeCarrier::parseAttributeFromXML<SUMOTime>(attrs, id, SUMO_TAG_E3DETECTOR, SUMO_ATTR_FREQUENCY, abort);
2303  std::string file = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_E3DETECTOR, SUMO_ATTR_FILE, abort);
2304  std::string vehicleTypes = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_E3DETECTOR, SUMO_ATTR_VTYPES, abort);
2305  std::string name = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_E3DETECTOR, SUMO_ATTR_NAME, abort);
2306  SUMOTime haltingTimeThreshold = GNEAttributeCarrier::parseAttributeFromXML<SUMOTime>(attrs, id, SUMO_TAG_E3DETECTOR, SUMO_ATTR_HALTING_TIME_THRESHOLD, abort);
2307  double haltingSpeedThreshold = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, SUMO_TAG_E3DETECTOR, SUMO_ATTR_HALTING_SPEED_THRESHOLD, abort);
2308  Position pos = GNEAttributeCarrier::parseAttributeFromXML<Position>(attrs, id, SUMO_TAG_E3DETECTOR, SUMO_ATTR_POSITION, abort);
2309  // parse Netedit attributes
2310  bool blockMovement = false;
2312  blockMovement = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_E3DETECTOR, GNE_ATTR_BLOCK_MOVEMENT, abort);
2313  }
2314  // Continue if all parameters were sucesfully loaded
2315  if (!abort) {
2316  // check that all elements are valid
2317  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_E3DETECTOR, id, false) != nullptr) {
2318  WRITE_WARNING("There is another " + toString(SUMO_TAG_E3DETECTOR) + " with the same ID='" + id + "'.");
2319  } else {
2320  // save ID of last created element
2321  GNEAdditional* additionalCreated = buildDetectorE3(viewNet, allowUndoRedo, id, pos, frequency, file, vehicleTypes, name, haltingTimeThreshold, haltingSpeedThreshold, blockMovement);
2322  // check if insertion has to be commited
2323  if (insertedAdditionals) {
2324  insertedAdditionals->commitElementInsertion(additionalCreated);
2325  }
2326  return true;
2327  }
2328  }
2329  return false;
2330 }
2331 
2332 
2333 bool
2334 GNEAdditionalHandler::parseAndBuildDetectorEntry(GNEViewNet* viewNet, bool allowUndoRedo, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
2335  bool abort = false;
2336  // parse attributes of Entry
2337  std::string laneId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_DET_ENTRY, SUMO_ATTR_LANE, abort);
2338  double position = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, "", SUMO_TAG_DET_ENTRY, SUMO_ATTR_POSITION, abort);
2339  bool friendlyPos = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, "", SUMO_TAG_DET_ENTRY, SUMO_ATTR_FRIENDLY_POS, abort);
2340  // parse Netedit attributes
2341  bool blockMovement = false;
2343  blockMovement = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, "", SUMO_TAG_DET_ENTRY, GNE_ATTR_BLOCK_MOVEMENT, abort);
2344  }
2345  // Check if parsing of parameters was correct
2346  if (!abort) {
2347  // get lane and E3 parent
2348  GNELane* lane = viewNet->getNet()->retrieveLane(laneId, false, true);
2349  GNEAdditional* E3Parent = nullptr;
2350  // obtain parent depending if we're loading or creating it using GNEAdditionalFrame
2351  if (insertedAdditionals) {
2352  E3Parent = insertedAdditionals->retrieveParentAdditional(viewNet, SUMO_TAG_E3DETECTOR);
2353  } else {
2354  bool ok = true;
2355  E3Parent = viewNet->getNet()->retrieveAdditional(SUMO_TAG_E3DETECTOR, attrs.get<std::string>(GNE_ATTR_PARENT, "", ok));
2356  }
2357  // check that all parameters are valid
2358  if (lane == nullptr) {
2359  WRITE_WARNING("The lane '" + laneId + "' to use within the " + toString(SUMO_TAG_DET_ENTRY) + " is not known.");
2360  } else if (!checkAndFixDetectorPosition(position, lane->getLaneShapeLength(), friendlyPos)) {
2361  WRITE_WARNING("Invalid position for " + toString(SUMO_TAG_DET_ENTRY) + ".");
2362  } else if (E3Parent) {
2363  // save ID of last created element
2364  GNEAdditional* additionalCreated = buildDetectorEntry(viewNet, allowUndoRedo, E3Parent, lane, position, friendlyPos, blockMovement);
2365  // check if insertion has to be commited
2366  if (insertedAdditionals) {
2367  insertedAdditionals->commitElementInsertion(additionalCreated);
2368  }
2369  return true;
2370  }
2371  }
2372  return false;
2373 }
2374 
2375 
2376 bool
2377 GNEAdditionalHandler::parseAndBuildDetectorExit(GNEViewNet* viewNet, bool allowUndoRedo, const SUMOSAXAttributes& attrs, HierarchyInsertedAdditionals* insertedAdditionals) {
2378  bool abort = false;
2379  // parse attributes of Exit
2380  std::string laneId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_DET_EXIT, SUMO_ATTR_LANE, abort);
2381  double position = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, "", SUMO_TAG_DET_EXIT, SUMO_ATTR_POSITION, abort);
2382  bool friendlyPos = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, "", SUMO_TAG_DET_EXIT, SUMO_ATTR_FRIENDLY_POS, abort);
2383  // parse Netedit attributes
2384  bool blockMovement = false;
2386  blockMovement = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, "", SUMO_TAG_DET_EXIT, GNE_ATTR_BLOCK_MOVEMENT, abort);
2387  }
2388  // Check if parsing of parameters was correct
2389  if (!abort) {
2390  // get lane and E3 parent
2391  GNELane* lane = viewNet->getNet()->retrieveLane(laneId, false, true);
2392  GNEAdditional* E3Parent = nullptr;
2393  // obtain parent depending if we're loading or creating it using GNEAdditionalFrame
2394  if (insertedAdditionals) {
2395  E3Parent = insertedAdditionals->retrieveParentAdditional(viewNet, SUMO_TAG_E3DETECTOR);
2396  } else {
2397  bool ok = true;
2398  E3Parent = viewNet->getNet()->retrieveAdditional(SUMO_TAG_E3DETECTOR, attrs.get<std::string>(GNE_ATTR_PARENT, "", ok));
2399  }
2400  // check that all parameters are valid
2401  if (lane == nullptr) {
2402  WRITE_WARNING("The lane '" + laneId + "' to use within the " + toString(SUMO_TAG_DET_EXIT) + " is not known.");
2403  } else if (!checkAndFixDetectorPosition(position, lane->getLaneShapeLength(), friendlyPos)) {
2404  WRITE_WARNING("Invalid position for " + toString(SUMO_TAG_DET_EXIT) + ".");
2405  } else if (E3Parent) {
2406  // save ID of last created element
2407  GNEAdditional* additionalCreated = buildDetectorExit(viewNet, allowUndoRedo, E3Parent, lane, position, friendlyPos, blockMovement);
2408  // check if insertion has to be commited
2409  if (insertedAdditionals) {
2410  insertedAdditionals->commitElementInsertion(additionalCreated);
2411  }
2412  return true;
2413  }
2414  }
2415  return false;
2416 }
2417 
2418 
2419 bool
2421  bool abort = false;
2422  // parse attributes of E1Instant
2423  std::string id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_INSTANT_INDUCTION_LOOP, SUMO_ATTR_ID, abort);
2424  std::string laneId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_INSTANT_INDUCTION_LOOP, SUMO_ATTR_LANE, abort);
2425  double position = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, SUMO_TAG_INSTANT_INDUCTION_LOOP, SUMO_ATTR_POSITION, abort);
2426  std::string file = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_INSTANT_INDUCTION_LOOP, SUMO_ATTR_FILE, abort);
2427  std::string vehicleTypes = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_INSTANT_INDUCTION_LOOP, SUMO_ATTR_VTYPES, abort);
2428  std::string name = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, SUMO_TAG_INSTANT_INDUCTION_LOOP, SUMO_ATTR_NAME, abort);
2429  bool friendlyPos = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_INSTANT_INDUCTION_LOOP, SUMO_ATTR_FRIENDLY_POS, abort);
2430  // parse Netedit attributes
2431  bool blockMovement = false;
2433  blockMovement = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, SUMO_TAG_INSTANT_INDUCTION_LOOP, GNE_ATTR_BLOCK_MOVEMENT, abort);
2434  }
2435  // Continue if all parameters were sucesfully loaded
2436  if (!abort) {
2437  // get pointer to lane
2438  GNELane* lane = viewNet->getNet()->retrieveLane(laneId, false, true);
2439  // check that all elements are valid
2440  if (viewNet->getNet()->retrieveAdditional(SUMO_TAG_INSTANT_INDUCTION_LOOP, id, false) != nullptr) {
2441  WRITE_WARNING("There is another " + toString(SUMO_TAG_INSTANT_INDUCTION_LOOP) + " with the same ID='" + id + "'.");
2442  } else if (lane == nullptr) {
2443  // Write error if lane isn't valid
2444  WRITE_WARNING("The lane '" + laneId + "' to use within the " + toString(SUMO_TAG_INSTANT_INDUCTION_LOOP) + " '" + id + "' is not known.");
2445  } else if (!checkAndFixDetectorPosition(position, lane->getLaneShapeLength(), friendlyPos)) {
2446  WRITE_WARNING("Invalid position for " + toString(SUMO_TAG_INSTANT_INDUCTION_LOOP) + " with ID = '" + id + "'.");
2447  } else {
2448  // save ID of last created element
2449  GNEAdditional* additionalCreated = buildDetectorE1Instant(viewNet, allowUndoRedo, id, lane, position, file, vehicleTypes, name, friendlyPos, blockMovement);
2450  // check if insertion has to be commited
2451  if (insertedAdditionals) {
2452  insertedAdditionals->commitElementInsertion(additionalCreated);
2453  }
2454  return true;
2455  }
2456  }
2457  return false;
2458 }
2459 
2460 // ===========================================================================
2461 // private method definitions
2462 // ===========================================================================
2463 
2464 void
2466  bool abort = false;
2467  // parse attributes of POIs
2468  std::string POIID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_POI, SUMO_ATTR_ID, abort);
2469  // POIs can be defined using a X,Y position,...
2470  Position pos = attrs.hasAttribute(SUMO_ATTR_X) ? GNEAttributeCarrier::parseAttributeFromXML<Position>(attrs, POIID, SUMO_TAG_POI, SUMO_ATTR_POSITION, abort) : Position::INVALID;
2471  // ... a Lon-Lat,...
2472  double lon = attrs.hasAttribute(SUMO_ATTR_LON) ? GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, POIID, SUMO_TAG_POI, SUMO_ATTR_LON, abort) : GNEAttributeCarrier::INVALID_POSITION;
2473  double lat = attrs.hasAttribute(SUMO_ATTR_LAT) ? GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, POIID, SUMO_TAG_POI, SUMO_ATTR_LAT, abort) : GNEAttributeCarrier::INVALID_POSITION;
2474  // .. or as Lane-PosLane
2475  std::string laneID = attrs.hasAttribute(SUMO_ATTR_LANE) ? GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, POIID, SUMO_TAG_POILANE, SUMO_ATTR_LANE, abort) : "";
2476  double lanePos = attrs.hasAttribute(SUMO_ATTR_POSITION) ? GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, POIID, SUMO_TAG_POILANE, SUMO_ATTR_POSITION, abort) : GNEAttributeCarrier::INVALID_POSITION;
2477  double lanePosLat = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, POIID, SUMO_TAG_POILANE, SUMO_ATTR_POSITION_LAT, abort);
2478  // continue with common parameters
2479  double layer = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, POIID, SUMO_TAG_POI, SUMO_ATTR_LAYER, abort);
2480  std::string type = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, POIID, SUMO_TAG_POI, SUMO_ATTR_TYPE, abort);
2481  RGBColor color = GNEAttributeCarrier::parseAttributeFromXML<RGBColor>(attrs, POIID, SUMO_TAG_POI, SUMO_ATTR_COLOR, abort);
2482  double angle = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, POIID, SUMO_TAG_POI, SUMO_ATTR_ANGLE, abort);
2483  std::string imgFile = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, POIID, SUMO_TAG_POI, SUMO_ATTR_IMGFILE, abort);
2484  bool relativePath = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, POIID, SUMO_TAG_POI, SUMO_ATTR_RELATIVEPATH, abort);
2485  double width = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, POIID, SUMO_TAG_POI, SUMO_ATTR_WIDTH, abort);
2486  double height = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, POIID, SUMO_TAG_POI, SUMO_ATTR_HEIGHT, abort);
2487  // check if ID is valid
2488  if (SUMOXMLDefinitions::isValidTypeID(POIID) == false) {
2489  WRITE_WARNING("Invalid characters for POI ID");
2490  abort = true;
2491  }
2492  // Continue if all parameters were sucesfully loaded
2493  if (!abort) {
2494  // check if img file is absolute
2495  if (imgFile != "" && !FileHelpers::isAbsolute(imgFile)) {
2496  imgFile = FileHelpers::getConfigurationRelative(getFileName(), imgFile);
2497  }
2498  // check if lane exist
2499  if (laneID != "" && !myViewNet->getNet()->retrieveLane(laneID, false)) {
2500  WRITE_WARNING("The lane '" + laneID + "' to use within the PoI '" + POIID + "' is not known.");
2501  return;
2502  }
2503  // check position
2504  bool useGeo = false;
2505  // if position is invalid, then is either a POILane or a GEOPoi
2506  if (pos == Position::INVALID) {
2507  // try computing x,y from lane,pos
2508  if (laneID != "") {
2509  // if LaneID is defined, then is a POILane
2510  pos = getLanePos(POIID, laneID, lanePos, lanePosLat);
2511  } else {
2512  // try computing x,y from lon,lat
2514  WRITE_WARNING("Either (x, y), (lon, lat) or (lane, pos) must be specified for PoI '" + POIID + "'.");
2515  return;
2516  } else if (!GeoConvHelper::getFinal().usingGeoProjection()) {
2517  WRITE_WARNING("(lon, lat) is specified for PoI '" + POIID + "' but no geo-conversion is specified for the network.");
2518  return;
2519  }
2520  // set GEO Position
2521  pos.set(lon, lat);
2522  useGeo = true;
2523  if (!GeoConvHelper::getFinal().x2cartesian_const(pos)) {
2524  WRITE_WARNING("Unable to project coordinates for PoI '" + POIID + "'.");
2525  return;
2526  }
2527  }
2528  }
2529  // create POI, or show an error if POI already exists
2530  if (!myShapeContainer.addPOI(POIID, type, color, pos, useGeo, laneID, lanePos, lanePosLat, layer, angle, imgFile, relativePath, width, height, false)) {
2531  WRITE_WARNING("POI with ID '" + POIID + "' already exists.");
2532  } else {
2533  // update myLastParameterised with the last inserted POI
2535  }
2536  }
2537 }
2538 
2539 
2540 void
2542  // we have two cases: if we're parsing a Shape or we're parsing an Additional
2543  if (getLastParameterised()) {
2544  bool ok = true;
2545  std::string key;
2546  if (attrs.hasAttribute(SUMO_ATTR_KEY)) {
2547  // obtain key
2548  key = attrs.get<std::string>(SUMO_ATTR_KEY, nullptr, ok);
2549  if (key.empty()) {
2550  WRITE_WARNING("Error parsing key from shape parameter. Key cannot be empty");
2551  ok = false;
2552  }
2554  WRITE_WARNING("Error parsing key from shape parameter. Key contains invalid characters");
2555  ok = false;
2556  }
2557  } else {
2558  WRITE_WARNING("Error parsing key from shape parameter. Key doesn't exist");
2559  ok = false;
2560  }
2561  // circumventing empty string test
2562  const std::string val = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
2564  WRITE_WARNING("Error parsing value from shape parameter. Value contains invalid characters");
2565  ok = false;
2566  }
2567  // set parameter in last inserted additional
2568  if (ok) {
2569  WRITE_DEBUG("Inserting parameter '" + key + "|" + val + "' into shape.");
2570  getLastParameterised()->setParameter(key, val);
2571  }
2573  // first check if given additional supports parameters
2575  bool ok = true;
2576  std::string key;
2577  if (attrs.hasAttribute(SUMO_ATTR_KEY)) {
2578  // obtain key
2579  key = attrs.get<std::string>(SUMO_ATTR_KEY, nullptr, ok);
2580  if (key.empty()) {
2581  WRITE_WARNING("Error parsing key from additional parameter. Key cannot be empty");
2582  ok = false;
2583  }
2585  WRITE_WARNING("Error parsing key from additional parameter. Key contains invalid characters");
2586  ok = false;
2587  }
2588  } else {
2589  WRITE_WARNING("Error parsing key from additional parameter. Key doesn't exist");
2590  ok = false;
2591  }
2592  // circumventing empty string test
2593  const std::string val = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
2595  WRITE_WARNING("Error parsing value from additional parameter. Value contains invalid characters");
2596  ok = false;
2597  }
2598  // set parameter in last inserted additional
2599  if (ok) {
2600  WRITE_DEBUG("Inserting parameter '" + key + "|" + val + "' into additional " + myHierarchyInsertedAdditionals.getLastInsertedAdditional()->getTagStr() + ".");
2602  }
2603  } else {
2604  WRITE_WARNING("Additionals of type '" + myHierarchyInsertedAdditionals.getLastInsertedAdditional()->getTagStr() + "' doesn't support parameters");
2605  }
2606  } else {
2607  WRITE_WARNING("Parameters has to be declared within the definition of an additional or a shape element");
2608  }
2609 }
2610 
2611 // ===========================================================================
2612 // GNEAdditionalHandler::HierarchyInsertedAdditionals method definitions
2613 // ===========================================================================
2614 
2615 void
2617  myInsertedElements.push_back(std::make_pair(tag, nullptr));
2618 }
2619 
2620 
2621 void
2623  myInsertedElements.back().second = additional;
2624 }
2625 
2626 
2627 void
2629  if (!myInsertedElements.empty()) {
2630  myInsertedElements.pop_back();
2631  }
2632 }
2633 
2634 
2637  if (myInsertedElements.size() < 2) {
2638  // currently we're finding parent additional in the additional XML root
2639  WRITE_WARNING("A " + toString(myInsertedElements.back().first) + " must be declared within the definition of a " + toString(expectedTag) + ".");
2640  return nullptr;
2641  } else {
2642  if (myInsertedElements.size() < 2) {
2643  // additional was hierarchically bad loaded, then return nullptr
2644  return nullptr;
2645  } else if ((myInsertedElements.end() - 2)->second == nullptr) {
2646  WRITE_WARNING(toString(expectedTag) + " parent of " + toString((myInsertedElements.end() - 1)->first) + " was not loaded sucesfully.");
2647  // parent additional wasn't sucesfully loaded, then return nullptr
2648  return nullptr;
2649  }
2650  GNEAdditional* retrievedAdditional = viewNet->getNet()->retrieveAdditional((myInsertedElements.end() - 2)->first, (myInsertedElements.end() - 2)->second->getID(), false);
2651  if (retrievedAdditional == nullptr) {
2652  // additional doesn't exist
2653  WRITE_WARNING("A " + toString((myInsertedElements.end() - 1)->first) + " must be declared within the definition of a " + toString(expectedTag) + ".");
2654  return nullptr;
2655  } else if (retrievedAdditional->getTagProperty().getTag() != expectedTag) {
2656  // invalid parent additional
2657  WRITE_WARNING("A " + toString((myInsertedElements.end() - 1)->first) + " cannot be declared within the definition of a " + retrievedAdditional->getTagStr() + ".");
2658  return nullptr;
2659  } else {
2660  return retrievedAdditional;
2661  }
2662  }
2663 }
2664 
2665 
2668  // ierate in reverse mode over myInsertedElements to obtain last inserted additional
2669  for (std::vector<std::pair<SumoXMLTag, GNEAdditional*> >::const_reverse_iterator i = myInsertedElements.rbegin(); i != myInsertedElements.rend(); i++) {
2670  // we need to avoid Tag Param because isn't an additional
2671  if (i->first != SUMO_TAG_PARAM) {
2672  return i->second;
2673  }
2674  }
2675  return nullptr;
2676 }
2677 
2678 /****************************************************************************/
GNENet::insertAdditional
void insertAdditional(GNEAdditional *additional)
Insert a additional element int GNENet container.
Definition: GNENet.cpp:2709
SUMO_TAG_TRAIN_STOP
A train stop (alias for bus stop)
Definition: SUMOXMLDefinitions.h:99
GNEAdditionalHandler::buildVariableSpeedSignStep
static GNEAdditional * buildVariableSpeedSignStep(GNEViewNet *viewNet, bool allowUndoRedo, GNEAdditional *VSSParent, double time, double speed)
Builds a VariableSpeedSign Step.
Definition: GNEAdditionalHandler.cpp:781
SUMOXMLDefinitions::isValidAttribute
static bool isValidAttribute(const std::string &value)
whether the given string is a valid attribute for a certain key (for example, a name)
Definition: SUMOXMLDefinitions.cpp:995
GNEAdditionalHandler::parseAndBuildVaporizer
static bool parseAndBuildVaporizer(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Builds a Vaporizer.
Definition: GNEAdditionalHandler.cpp:1064
GNEAccess
Definition: GNEAccess.h:38
GNEAdditionalHandler::fixE2DetectorPosition
static bool fixE2DetectorPosition(double &pos, double &length, const double laneLength, const bool friendlyPos)
check if the position of a detector over a lane is valid
Definition: GNEAdditionalHandler.cpp:1001
SUMO_ATTR_TYPE
Definition: SUMOXMLDefinitions.h:381
SUMO_ATTR_ANGLE
Definition: SUMOXMLDefinitions.h:794
GNETAZ::updateGeometry
void updateGeometry()
update pre-computed geometry information
Definition: GNETAZ.cpp:68
GNEHierarchicalChildElements::addChildAdditional
void addChildAdditional(GNEAdditional *additional)
Definition: GNEHierarchicalChildElements.cpp:95
GNEDetectorE2::checkE2MultilaneIntegrity
void checkE2MultilaneIntegrity()
check if E2 is valid (all of their lanes are connected, it must called after every operation which in...
Definition: GNEDetectorE2.cpp:306
GNEVariableSpeedSign.h
GNENet::retrieveAdditional
GNEAdditional * retrieveAdditional(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named additional.
Definition: GNENet.cpp:2183
XMLSubSys::runParser
static bool runParser(GenericSAXHandler &handler, const std::string &file, const bool isNet=false)
Runs the given handler on the given file; returns if everything's ok.
Definition: XMLSubSys.cpp:112
GNEDetectorEntryExit.h
GNEDemandElement
An Element which don't belongs to GNENet but has influency in the simulation.
Definition: GNEDemandElement.h:55
GNEAdditionalHandler::buildDetectorE1Instant
static GNEAdditional * buildDetectorE1Instant(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, GNELane *lane, double pos, const std::string &filename, const std::string &vehicleTypes, const std::string &name, bool friendlyPos, bool blockMovement)
Builds a Instant Induction Loop Detector (E1Instant)
Definition: GNEAdditionalHandler.cpp:500
SUMOSAXAttributes::hasAttribute
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
SUMO_TAG_LANECALIBRATOR
A calibrator placed over lane (used in netedit)
Definition: SUMOXMLDefinitions.h:93
GNEDetectorE2
Definition: GNEDetectorE2.h:34
GNEAdditional
An Element which don't belongs to GNENet but has influency in the simulation.
Definition: GNEAdditional.h:48
SUMO_ATTR_HALTING_SPEED_THRESHOLD
Definition: SUMOXMLDefinitions.h:751
GNERouteProbe::getPositionInView
Position getPositionInView() const
Returns position of additional in view.
Definition: GNERouteProbe.cpp:80
GNEParkingAreaReroute.h
SUMO_ATTR_IMGFILE
Definition: SUMOXMLDefinitions.h:792
GNEAttributeCarrier::getID
const std::string getID() const
function to support debugging
Definition: GNEAttributeCarrier.cpp:1289
SUMO_ATTR_DISALLOW
Definition: SUMOXMLDefinitions.h:783
WRITE_WARNING
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:275
GNEAdditionalHandler::buildVaporizer
static GNEAdditional * buildVaporizer(GNEViewNet *viewNet, bool allowUndoRedo, GNEEdge *edge, SUMOTime start, SUMOTime endTime, const std::string &name, bool centerAfterCreation)
Builds a vaporizer (lane speed additional)
Definition: GNEAdditionalHandler.cpp:798
ShapeHandler::myLastParameterised
Parameterised * myLastParameterised
element to receive parameters
Definition: ShapeHandler.h:126
SUMO_TAG_POLY
begin/end of the description of a polygon
Definition: SUMOXMLDefinitions.h:57
ShapeHandler::getLastParameterised
Parameterised * getLastParameterised() const
get last parameterised object
Definition: ShapeHandler.cpp:267
GNEAdditionalHandler::parseAndBuildDetectorEntry
static bool parseAndBuildDetectorEntry(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a Entry detector.
Definition: GNEAdditionalHandler.cpp:2334
GNEAdditionalHandler::parseAndBuildCalibrator
static bool parseAndBuildCalibrator(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a mesoscopic or microscopic calibrator.
Definition: GNEAdditionalHandler.cpp:2092
GNERerouterInterval
Definition: GNERerouterInterval.h:45
SUMOSAXAttributes::getString
virtual std::string getString(int id) const =0
Returns the string-value of the named (by its enum-value) attribute.
SUMO_ATTR_LENGTH
Definition: SUMOXMLDefinitions.h:393
GNEAdditionalHandler::parseAndBuildVariableSpeedSign
static bool parseAndBuildVariableSpeedSign(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a Variable Speed Signal (GNEViewNet* viewNet, bool allowUndoRedo,...
Definition: GNEAdditionalHandler.cpp:1380
GeoConvHelper::x2cartesian_const
bool x2cartesian_const(Position &from) const
Converts the given coordinate into a cartesian using the previous initialisation.
Definition: GeoConvHelper.cpp:417
Boundary::ymin
double ymin() const
Returns minimum y-coordinate.
Definition: Boundary.cpp:130
GNEVariableSpeedSignStep
Definition: GNEVariableSpeedSignStep.h:40
GNEAdditionalHandler::parseAndBuildDetectorExit
static bool parseAndBuildDetectorExit(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a Exit detector.
Definition: GNEAdditionalHandler.cpp:2377
GNEUndoList::p_end
void p_end()
End undo command sub-group. If the sub-group is still empty, it will be deleted; otherwise,...
Definition: GNEUndoList.cpp:79
GNELane::getParentEdge
GNEEdge * getParentEdge() const
Returns underlying parent edge.
Definition: GNELane.cpp:1371
Position::INVALID
static const Position INVALID
used to indicate that a position is valid
Definition: Position.h:284
OptionsCont.h
GNEAdditionalHandler::buildCalibrator
static GNEAdditional * buildCalibrator(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, GNELane *lane, double pos, const std::string &name, const std::string &outfile, SUMOTime freq, const std::string &routeprobe, bool centerAfterCreation)
builds a microscopic calibrator over a lane
Definition: GNEAdditionalHandler.cpp:520
GNENet::disableUpdateGeometry
void disableUpdateGeometry()
disable update geometry of elements after inserting or removing an element in net
Definition: GNENet.cpp:2682
SUMO_TAG_PARAM
parameter associated to a certain key
Definition: SUMOXMLDefinitions.h:169
GNERouteProbe.h
SUMO_ATTR_LINE
Definition: SUMOXMLDefinitions.h:775
GNEAdditionalHandler::buildBusStop
static GNEAdditional * buildBusStop(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, GNELane *lane, const double startPos, const double endPos, const int parametersSet, const std::string &name, const std::vector< std::string > &lines, int personCapacity, bool friendlyPosition, bool blockMovement)
Builds a bus stop.
Definition: GNEAdditionalHandler.cpp:240
GNEAdditionalHandler::myStartElement
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
Definition: GNEAdditionalHandler.cpp:81
SUMOSAXAttributes::get
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
Definition: SUMOSAXAttributes.h:492
GNEAdditionalHandler::buildMultiLaneDetectorE2
static GNEAdditional * buildMultiLaneDetectorE2(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, const std::vector< GNELane * > &lanes, double pos, double endPos, SUMOTime freq, const std::string &filename, const std::string &vehicleTypes, const std::string &name, SUMOTime timeThreshold, double speedThreshold, double jamThreshold, bool friendlyPos, bool blockMovement)
Builds a multi-lane Area Detector (E2)
Definition: GNEAdditionalHandler.cpp:407
SUMO_TAG_TAZSOURCE
a source within a district (connection road)
Definition: SUMOXMLDefinitions.h:135
GNEChange_Additional
Definition: GNEChange_Additional.h:44
SUMO_TAG_CONTAINER_STOP
A container stop.
Definition: SUMOXMLDefinitions.h:105
GNEAdditionalHandler::GNEAdditionalHandler
GNEAdditionalHandler(const std::string &file, GNEViewNet *viewNet, GNEAdditional *additionalParent=nullptr)
Constructor.
Definition: GNEAdditionalHandler.cpp:64
GNETAZ::updateParentAdditional
void updateParentAdditional()
update TAZ after add or remove a Source/sink, or change their weight
Definition: GNETAZ.cpp:485
FileHelpers::getConfigurationRelative
static std::string getConfigurationRelative(const std::string &configPath, const std::string &path)
Returns the second path as a relative path to the first file.
Definition: FileHelpers.cpp:115
SUMO_ATTR_ARRIVALPOS_LAT
Definition: SUMOXMLDefinitions.h:438
SUMO_ATTR_OFF
Definition: SUMOXMLDefinitions.h:764
SUMO_TAG_LANE_AREA_DETECTOR
alternative tag for e2 detector
Definition: SUMOXMLDefinitions.h:71
GUISUMOAbstractView::centerTo
virtual void centerTo(GUIGlID id, bool applyZoom, double zoomDist=20)
centers to the chosen artifact
Definition: GUISUMOAbstractView.cpp:789
GNEAdditionalHandler::buildSingleLaneDetectorE2
static GNEAdditional * buildSingleLaneDetectorE2(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, GNELane *lane, double pos, double length, SUMOTime freq, const std::string &filename, const std::string &vehicleTypes, const std::string &name, SUMOTime timeThreshold, double speedThreshold, double jamThreshold, bool friendlyPos, bool blockMovement)
Builds a single-lane Area Detector (E2)
Definition: GNEAdditionalHandler.cpp:386
GNEAdditionalHandler::getPosition
double getPosition(double pos, GNELane &lane, bool friendlyPos, const std::string &additionalID)
extracts the position, checks whether it shall be mirrored and checks whether it is within the lane.
Definition: GNEAdditionalHandler.cpp:972
SUMO_TAG_LANE
begin/end of the description of a single lane
Definition: SUMOXMLDefinitions.h:49
SUMOTime
long long int SUMOTime
Definition: SUMOTime.h:34
GNEAdditionalHandler::parseAndBuildRerouterInterval
static bool parseAndBuildRerouterInterval(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a Rerouter Interval.
Definition: GNEAdditionalHandler.cpp:1497
SUMO_ATTR_EDGE
Definition: SUMOXMLDefinitions.h:423
SUMO_ATTR_LINES
Definition: SUMOXMLDefinitions.h:776
GNEVariableSpeedSign
Definition: GNEVariableSpeedSign.h:39
GNEAdditionalHandler::builDestProbReroute
static GNEAdditional * builDestProbReroute(GNEViewNet *viewNet, bool allowUndoRedo, GNEAdditional *rerouterIntervalParent, GNEEdge *newEdgeDestination, double probability)
Definition: GNEAdditionalHandler.cpp:683
Boundary::xmax
double xmax() const
Returns maximum x-coordinate.
Definition: Boundary.cpp:124
GNEAdditionalHandler::parseAndBuildRerouterParkingAreaReroute
static bool parseAndBuildRerouterParkingAreaReroute(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a parkingAreaReroute.
Definition: GNEAdditionalHandler.cpp:1652
GNENet::retrieveDemandElement
GNEDemandElement * retrieveDemandElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named demand element.
Definition: GNENet.cpp:2316
SUMO_ATTR_COLOR
A color information.
Definition: SUMOXMLDefinitions.h:704
STOPPINGPLACE_STARTPOS_SET
const int STOPPINGPLACE_STARTPOS_SET
Definition: GNEStoppingPlace.h:29
OptionsCont::getOptions
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:57
SUMO_TAG_POI
begin/end of the description of a Point of interest
Definition: SUMOXMLDefinitions.h:53
GNEViewNet
Definition: GNEViewNet.h:42
GNEAdditionalHandler::buildRouteProbReroute
static GNEAdditional * buildRouteProbReroute(GNEViewNet *viewNet, bool allowUndoRedo, GNEAdditional *rerouterIntervalParent, const std::string &newRouteId, double probability)
Definition: GNEAdditionalHandler.cpp:717
SUMO_ATTR_SPEED
Definition: SUMOXMLDefinitions.h:384
GNEAdditionalHandler::checkOverlappingRerouterIntervals
static bool checkOverlappingRerouterIntervals(GNEAdditional *rerouter, SUMOTime newBegin, SUMOTime newEnd)
check if an overlapping is produced in rerouter if a interval with certain begin and end is inserted
Definition: GNEAdditionalHandler.cpp:1035
SUMO_ATTR_ARRIVALPOS
Definition: SUMOXMLDefinitions.h:437
SUMO_ATTR_ID
Definition: SUMOXMLDefinitions.h:378
GNEAdditionalHandler::buildDetectorExit
static GNEAdditional * buildDetectorExit(GNEViewNet *viewNet, bool allowUndoRedo, GNEAdditional *E3Parent, GNELane *lane, double pos, bool friendlyPos, bool blockMovement)
Builds a exit detector (E3)
Definition: GNEAdditionalHandler.cpp:476
SUMO_TAG_DET_ENTRY
an e3 entry point
Definition: SUMOXMLDefinitions.h:81
SUMO_TAG_NOTHING
invalid tag
Definition: SUMOXMLDefinitions.h:43
GNEDetectorE1
Definition: GNEDetectorE1.h:34
SUMO_ATTR_LANE
Definition: SUMOXMLDefinitions.h:637
GNECalibrator::getPositionInView
Position getPositionInView() const
Returns position of additional in view.
Definition: GNECalibrator.cpp:98
SUMO_ATTR_ROUTEPROBE
Definition: SUMOXMLDefinitions.h:670
GNEAdditional::setAttribute
virtual void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)=0
method for setting the attribute and letting the object perform additional changes
SUMO_TAG_VTYPE
description of a vehicle type
Definition: SUMOXMLDefinitions.h:121
SUMO_ATTR_ENDPOS
Definition: SUMOXMLDefinitions.h:798
STOPPINGPLACE_ENDPOS_SET
const int STOPPINGPLACE_ENDPOS_SET
Definition: GNEStoppingPlace.h:30
GNEAdditionalHandler::buildClosingReroute
static GNEAdditional * buildClosingReroute(GNEViewNet *viewNet, bool allowUndoRedo, GNEAdditional *rerouterIntervalParent, GNEEdge *closedEdge, SVCPermissions permissions)
Definition: GNEAdditionalHandler.cpp:666
GNERerouter
Definition: GNERerouter.h:39
PositionVector
A list of positions.
Definition: PositionVector.h:45
SUMO_ATTR_CHARGEINTRANSIT
Allow/disallow charge in transit in Charging Stations.
Definition: SUMOXMLDefinitions.h:473
GNE_ATTR_CENTER_AFTER_CREATION
flag to center camera after element creation
Definition: SUMOXMLDefinitions.h:1009
SUMO_TAG_PARKING_SPACE
A parking space for a single vehicle within a parking area.
Definition: SUMOXMLDefinitions.h:109
GNEClosingLaneReroute.h
GeoConvHelper
static methods for processing the coordinates conversion for the current net
Definition: GeoConvHelper.h:55
GNEAdditionalHandler::parseAndBuildDetectorE1
static bool parseAndBuildDetectorE1(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a induction loop detector (GNEViewNet* viewNet, bool allowUndoRedo,...
Definition: GNEAdditionalHandler.cpp:2163
SUMO_ATTR_FILE
Definition: SUMOXMLDefinitions.h:664
SumoXMLTag
SumoXMLTag
Numbers representing SUMO-XML - element names.
Definition: SUMOXMLDefinitions.h:41
ShapeHandler::myGeoConvHelper
const GeoConvHelper * myGeoConvHelper
geo-conversion to use during loading
Definition: ShapeHandler.h:129
GNEAttributeCarrier::TagProperties::getTag
SumoXMLTag getTag() const
get Tag vinculated with this attribute Property
Definition: GNEAttributeCarrier.cpp:523
GNEAdditionalHandler::buildParkingSpace
static GNEAdditional * buildParkingSpace(GNEViewNet *viewNet, bool allowUndoRedo, GNEAdditional *parkingAreaParent, Position pos, double width, double length, double angle, bool blockMovement)
Builds a Parking Space.
Definition: GNEAdditionalHandler.cpp:350
SUMORouteHandler::checkStopPos
static StopPos checkStopPos(double &startPos, double &endPos, const double laneLength, const double minLength, const bool friendlyPos)
check start and end position of a stop
Definition: SUMORouteHandler.cpp:283
SUMO_ATTR_WEIGHT
Definition: SUMOXMLDefinitions.h:421
NBEdge
The representation of a single edge during network building.
Definition: NBEdge.h:91
GNERouteProbe
Representation of a RouteProbe in netedit.
Definition: GNERouteProbe.h:34
GNEAdditionalHandler::parseAndBuildRerouterRouteProbReroute
static bool parseAndBuildRerouterRouteProbReroute(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a Route Prob Reroute.
Definition: GNEAdditionalHandler.cpp:1688
FileHelpers::getFilePath
static std::string getFilePath(const std::string &path)
Removes the file information from the given path.
Definition: FileHelpers.cpp:76
SUMO_ATTR_BEGIN
weights: time range begin
Definition: SUMOXMLDefinitions.h:678
SUMO_ATTR_CHARGEDELAY
Delay in the charge of charging stations.
Definition: SUMOXMLDefinitions.h:475
GNECalibratorFlow.h
GNEChange_Additional.h
GNEEdge
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:51
SUMO_ATTR_PERSON_NUMBER
Definition: SUMOXMLDefinitions.h:651
GNEViewNet::getNet
GNENet * getNet() const
get the net object
Definition: GNEViewNet.cpp:1014
SUMO_TAG_PARKING_ZONE_REROUTE
entry for an alternative parking zone
Definition: SUMOXMLDefinitions.h:198
GNEChargingStation
Definition: GNEChargingStation.h:31
parseVehicleClasses
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
Definition: SUMOVehicleClass.cpp:222
GNEAdditionalHandler::buildAdditional
static bool buildAdditional(GNEViewNet *viewNet, bool allowUndoRedo, SumoXMLTag tag, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Build additionals.
Definition: GNEAdditionalHandler.cpp:168
GNEHierarchicalParentElements::getParentAdditionals
const std::vector< GNEAdditional * > & getParentAdditionals() const
get parent additionals
Definition: GNEHierarchicalParentElements.cpp:85
GNEAdditionalHandler::parseAndBuildParkingSpace
static bool parseAndBuildParkingSpace(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a parking space.
Definition: GNEAdditionalHandler.cpp:2053
SUMO_TAG_DEST_PROB_REROUTE
probability of destiny of a reroute
Definition: SUMOXMLDefinitions.h:190
GNEParkingArea
A lane area vehicles can park at (netedit-version)
Definition: GNEParkingArea.h:34
RGBColor
Definition: RGBColor.h:39
GNERerouterInterval.h
SUMO_ATTR_LINEWIDTH
Definition: SUMOXMLDefinitions.h:715
SUMO_ATTR_ARRIVALSPEED
Definition: SUMOXMLDefinitions.h:439
ShapeHandler::setDefaults
void setDefaults(const std::string &prefix, const RGBColor &color, const double layer, const bool fill=false)
set default values
Definition: ShapeHandler.cpp:285
GNEAdditionalHandler::parseAndBuildContainerStop
static bool parseAndBuildContainerStop(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a container stop.
Definition: GNEAdditionalHandler.cpp:1790
GNEDetectorE3.h
SUMO_ATTR_CHARGINGPOWER
Definition: SUMOXMLDefinitions.h:469
SUMO_ATTR_PROB
Definition: SUMOXMLDefinitions.h:629
GNETAZ.h
GNEAttributeCarrier::getTagProperty
const TagProperties & getTagProperty() const
get Tag Property assigned to this object
Definition: GNEAttributeCarrier.cpp:1273
GNEAdditionalHandler::buildDetectorE1
static GNEAdditional * buildDetectorE1(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, GNELane *lane, double pos, SUMOTime freq, const std::string &filename, const std::string &vehicleTypes, const std::string &name, bool friendlyPos, bool blockMovement)
Builds a induction loop detector (E1)
Definition: GNEAdditionalHandler.cpp:366
GNEAdditionalHandler::parseAndBuildRerouterClosingLaneReroute
static bool parseAndBuildRerouterClosingLaneReroute(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a Closing Lane reroute.
Definition: GNEAdditionalHandler.cpp:1545
SUMO_ATTR_STARTPOS
Definition: SUMOXMLDefinitions.h:797
SUMO_TAG_CHARGING_STATION
A Charging Station.
Definition: SUMOXMLDefinitions.h:111
GNEAdditionalHandler::buildDetectorEntry
static GNEAdditional * buildDetectorEntry(GNEViewNet *viewNet, bool allowUndoRedo, GNEAdditional *E3Parent, GNELane *lane, double pos, bool friendlyPos, bool blockMovement)
Builds a entry detector (E3)
Definition: GNEAdditionalHandler.cpp:452
Boundary::xmin
double xmin() const
Returns minimum x-coordinate.
Definition: Boundary.cpp:118
GNEAttributeCarrier::lanesConsecutives
static bool lanesConsecutives(const std::vector< GNELane * > &lanes)
check if lanes are consecutives
Definition: GNEAttributeCarrier.cpp:1136
GeoConvHelper::getFinal
static const GeoConvHelper & getFinal()
the coordinate transformation for writing the location element and for tracking the original coordina...
Definition: GeoConvHelper.h:105
SVCPermissions
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
Definition: SUMOVehicleClass.h:218
TIME2STEPS
#define TIME2STEPS(x)
Definition: SUMOTime.h:58
XMLSubSys::setValidation
static void setValidation(const std::string &validationScheme, const std::string &netValidationScheme)
Enables or disables validation.
Definition: XMLSubSys.cpp:58
SUMO_TAG_POILANE
begin/end of the description of a Point of interest over Lane (used by Netedit)
Definition: SUMOXMLDefinitions.h:55
SUMO_TAG_VSS
A variable speed sign.
Definition: SUMOXMLDefinitions.h:89
GNEAccess.h
GNEAdditionalHandler::parseAndBuildRerouter
static bool parseAndBuildRerouter(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a rerouter.
Definition: GNEAdditionalHandler.cpp:1452
GNEEdge::getNBEdge
NBEdge * getNBEdge() const
returns the internal NBEdge
Definition: GNEEdge.cpp:631
GNEParkingSpace.h
GNEDetectorE1.h
GNEAdditionalHandler::parseAndBuildDetectorE3
static bool parseAndBuildDetectorE3(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a multi entry exit detector (GNEViewNet* viewNet, bool allowUndoRedo,...
Definition: GNEAdditionalHandler.cpp:2298
ShapeHandler::myEndElement
virtual void myEndElement(int element)
Called when a closing tag occurs.
Definition: ShapeHandler.cpp:104
Position::set
void set(double x, double y)
set positions x and y
Definition: Position.h:86
GNEAdditionalHandler::parseAndBuildChargingStation
static bool parseAndBuildChargingStation(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a charging station.
Definition: GNEAdditionalHandler.cpp:1908
GNEClosingReroute
Definition: GNEClosingReroute.h:40
SUMO_ATTR_DEPARTPOS_LAT
Definition: SUMOXMLDefinitions.h:434
GNERouteProbReroute
Definition: GNERouteProbReroute.h:42
GNEAdditionalHandler::parseAndBuildTAZSink
static bool parseAndBuildTAZSink(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Builds a TAZ Sink.
Definition: GNEAdditionalHandler.cpp:1184
GNEViewNet.h
GNEAdditionalHandler.h
SUMO_ATTR_CONT
Definition: SUMOXMLDefinitions.h:748
SUMO_ATTR_WIDTH
Definition: SUMOXMLDefinitions.h:386
SUMO_ATTR_DEPARTSPEED
Definition: SUMOXMLDefinitions.h:435
SUMO_ATTR_ROUTE
Definition: SUMOXMLDefinitions.h:440
GNEAdditionalHandler::buildRerouter
static GNEAdditional * buildRerouter(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, Position pos, const std::vector< GNEEdge * > &edges, double prob, const std::string &name, const std::string &file, bool off, SUMOTime timeThreshold, const std::string &vTypes, bool blockMovement)
builds a rerouter
Definition: GNEAdditionalHandler.cpp:590
GNENet::enableUpdateGeometry
void enableUpdateGeometry()
Definition: GNENet.cpp:2676
SUMO_ATTR_EDGES
the edges of a route
Definition: SUMOXMLDefinitions.h:427
Boundary
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:41
SUMO_ATTR_DEPARTLANE
Definition: SUMOXMLDefinitions.h:432
SUMO_TAG_PARKING_AREA
A parking area.
Definition: SUMOXMLDefinitions.h:107
GNEAdditionalHandler::parseAndBuildCalibratorFlow
static bool parseAndBuildCalibratorFlow(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses flow values of Calibrators.
Definition: GNEAdditionalHandler.cpp:1269
SUMO_ATTR_LAYER
A layer number.
Definition: SUMOXMLDefinitions.h:712
SUMO_TAG_EDGE
begin/end of the description of an edge
Definition: SUMOXMLDefinitions.h:47
GNEDetectorE1Instant.h
ProcessError
Definition: UtilExceptions.h:39
SUMO_TAG_STEP
trigger: a step description
Definition: SUMOXMLDefinitions.h:157
SUMO_ATTR_PERSON_CAPACITY
Definition: SUMOXMLDefinitions.h:649
GNECalibrator
Definition: GNECalibrator.h:41
SUMO_ATTR_CONTAINER_NUMBER
Definition: SUMOXMLDefinitions.h:652
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:38
GNEAdditionalHandler::HierarchyInsertedAdditionals::getLastInsertedAdditional
GNEAdditional * getLastInsertedAdditional() const
return last additional inserted
Definition: GNEAdditionalHandler.cpp:2667
SUMO_TAG_ROUTE_PROB_REROUTE
probability of route of a reroute
Definition: SUMOXMLDefinitions.h:196
Boundary::add
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
Definition: Boundary.cpp:78
GNEEdge.h
GNEViewNet::getUndoList
GNEUndoList * getUndoList() const
get the undoList object
Definition: GNEViewNet.cpp:1020
GNEAdditionalHandler::buildDetectorE3
static GNEAdditional * buildDetectorE3(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, Position pos, SUMOTime freq, const std::string &filename, const std::string &vehicleTypes, const std::string &name, SUMOTime timeThreshold, double speedThreshold, bool blockMovement)
Builds a multi entry exit detector (E3)
Definition: GNEAdditionalHandler.cpp:432
GNETAZ
Definition: GNETAZ.h:34
RGBColor::RED
static const RGBColor RED
named colors
Definition: RGBColor.h:189
GNEVariableSpeedSignStep.h
SUMO_TAG_REROUTER
A rerouter.
Definition: SUMOXMLDefinitions.h:95
GNEDetectorE3
Definition: GNEDetectorE3.h:34
GNELane::getLaneShapeLength
double getLaneShapeLength() const
returns the length of the lane's shape
Definition: GNELane.cpp:803
GNEAdditionalHandler::~GNEAdditionalHandler
~GNEAdditionalHandler()
Destructor.
Definition: GNEAdditionalHandler.cpp:77
SUMOSAXAttributes::getOpt
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue, bool report=true) const
Tries to read given attribute assuming it is an int.
Definition: SUMOSAXAttributes.h:518
GNEAdditionalHandler::buildTAZSource
static GNEAdditional * buildTAZSource(GNEViewNet *viewNet, bool allowUndoRedo, GNEAdditional *TAZ, GNEEdge *edge, double departWeight)
Builds a TAZSource (Traffic Assignment Zone)
Definition: GNEAdditionalHandler.cpp:859
GNETAZ::setAttribute
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
method for setting the attribute and letting the object perform additional changes
Definition: GNETAZ.cpp:416
GNEAdditionalHandler::myHierarchyInsertedAdditionals
HierarchyInsertedAdditionals myHierarchyInsertedAdditionals
HierarchyInsertedAdditionals used for insert children.
Definition: GNEAdditionalHandler.h:741
GNEVaporizer::getPositionInView
Position getPositionInView() const
Returns position of additional in view.
Definition: GNEVaporizer.cpp:74
GNEDetectorE2.h
GNEAdditionalHandler::buildAccess
static GNEAdditional * buildAccess(GNEViewNet *viewNet, bool allowUndoRedo, GNEAdditional *busStop, GNELane *lane, double pos, const std::string &length, bool friendlyPos, bool blockMovement)
Builds an Access.
Definition: GNEAdditionalHandler.cpp:261
GNEEdge::getLanes
const std::vector< GNELane * > & getLanes() const
returns a reference to the lane vector
Definition: GNEEdge.cpp:874
SUMO_TAG_CLOSING_REROUTE
reroute of type closing
Definition: SUMOXMLDefinitions.h:192
GNEAdditionalHandler::HierarchyInsertedAdditionals
Stack used to save the last inserted element.
Definition: GNEAdditionalHandler.h:51
GNEParkingSpace
vehicle space used by GNEParkingAreas
Definition: GNEParkingSpace.h:38
SUMO_ATTR_TIME
trigger: the time of the step
Definition: SUMOXMLDefinitions.h:676
SUMO_ATTR_RELATIVEPATH
Definition: SUMOXMLDefinitions.h:793
SUMO_ATTR_FRIENDLY_POS
Definition: SUMOXMLDefinitions.h:765
GNELane.h
GNEBusStop
A lane area vehicles can halt at (netedit-version)
Definition: GNEBusStop.h:34
GNEAttributeCarrier::canParse
static bool canParse(const std::string &string)
true if a value of type T can be parsed from string
Definition: GNEAttributeCarrier.h:636
NBHelpers::interpretLaneID
static void interpretLaneID(const std::string &lane_id, std::string &edge_id, int &index)
parses edge-id and index from lane-id
Definition: NBHelpers.cpp:120
SUMO_ATTR_FREQUENCY
Definition: SUMOXMLDefinitions.h:662
SUMO_ATTR_POSITION
Definition: SUMOXMLDefinitions.h:660
GNECalibratorFlow
Definition: GNECalibratorFlow.h:40
SUMO_ATTR_FILL
Fill the polygon.
Definition: SUMOXMLDefinitions.h:714
NBEdge::getLanes
const std::vector< NBEdge::Lane > & getLanes() const
Returns the lane definitions.
Definition: NBEdge.h:656
GNEContainerStop.h
GNEAdditionalHandler::HierarchyInsertedAdditionals::myInsertedElements
std::vector< std::pair< SumoXMLTag, GNEAdditional * > > myInsertedElements
vector used as stack
Definition: GNEAdditionalHandler.h:70
GNEClosingLaneReroute
Definition: GNEClosingLaneReroute.h:41
SUMO_TAG_E2DETECTOR_MULTILANE
an e2 detector over multiple lanes (used by Netedit)
Definition: SUMOXMLDefinitions.h:69
GNEAdditionalHandler::getLanePos
Position getLanePos(const std::string &poiID, const std::string &laneID, double lanePos, double lanePosLat)
get lane position
Definition: GNEAdditionalHandler.cpp:148
GNEAttributeCarrier::INVALID_POSITION
static const double INVALID_POSITION
invalid double position
Definition: GNEAttributeCarrier.h:608
ShapeContainer::getPOIs
const POIs & getPOIs() const
Returns all pois.
Definition: ShapeContainer.h:154
SUMO_ATTR_LANES
Definition: SUMOXMLDefinitions.h:638
SUMO_TAG_TAZ
a traffic assignment zone
Definition: SUMOXMLDefinitions.h:133
GNEAdditionalHandler::parseAndBuildBusStop
static bool parseAndBuildBusStop(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a bus stop.
Definition: GNEAdditionalHandler.cpp:1720
ShapeContainer::addPolygon
virtual bool addPolygon(const std::string &id, const std::string &type, const RGBColor &color, double layer, double angle, const std::string &imgFile, bool relativePath, const PositionVector &shape, bool geo, bool fill, double lineWidth, bool ignorePruning=false)
Builds a polygon using the given values and adds it to the container.
Definition: ShapeContainer.cpp:64
NBEdge::getLength
double getLength() const
Returns the computed length of the edge.
Definition: NBEdge.h:545
SUMO_ATTR_HEIGHT
Definition: SUMOXMLDefinitions.h:789
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:47
SUMO_TAG_BUS_STOP
A bus stop.
Definition: SUMOXMLDefinitions.h:97
SUMO_TAG_ENTRY_EXIT_DETECTOR
alternative tag for e3 detector
Definition: SUMOXMLDefinitions.h:75
SUMO_TAG_TAZSINK
a sink within a district (connection road)
Definition: SUMOXMLDefinitions.h:137
GNEAdditionalHandler::builParkingAreaReroute
static GNEAdditional * builParkingAreaReroute(GNEViewNet *viewNet, bool allowUndoRedo, GNEAdditional *rerouterIntervalParent, GNEAdditional *newParkignArea, double probability, bool visible)
Definition: GNEAdditionalHandler.cpp:700
GNEAdditionalHandler::buildRerouterInterval
static GNEAdditional * buildRerouterInterval(GNEViewNet *viewNet, bool allowUndoRedo, GNEAdditional *rerouterParent, SUMOTime begin, SUMOTime end)
builds a rerouter interval
Definition: GNEAdditionalHandler.cpp:628
SUMO_ATTR_ROADSIDE_CAPACITY
Definition: SUMOXMLDefinitions.h:772
SUMO_ATTR_HALTING_TIME_THRESHOLD
Definition: SUMOXMLDefinitions.h:750
SUMOXMLDefinitions::isValidTypeID
static bool isValidTypeID(const std::string &value)
whether the given string is a valid id for an edge or vehicle type
Definition: SUMOXMLDefinitions.cpp:979
GNEDestProbReroute
Definition: GNEDestProbReroute.h:41
SUMO_ATTR_OUTPUT
Definition: SUMOXMLDefinitions.h:788
SUMO_TAG_FLOW_CALIBRATOR
a flow definition within in Calibrator (used in NETEDIT)
Definition: SUMOXMLDefinitions.h:153
ShapeHandler::myShapeContainer
ShapeContainer & myShapeContainer
reference to shape container in which all Shares are being added
Definition: ShapeHandler.h:111
GNEVaporizer.h
GNEClosingReroute.h
GNEAdditionalHandler::parseAndBuildTAZSource
static bool parseAndBuildTAZSource(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Builds a TAZ Source.
Definition: GNEAdditionalHandler.cpp:1147
SUMO_ATTR_VTYPES
Definition: SUMOXMLDefinitions.h:632
SUMO_ATTR_REROUTE
Definition: SUMOXMLDefinitions.h:648
SUMO_ATTR_LAT
Definition: SUMOXMLDefinitions.h:815
GenericSAXHandler::getFileName
const std::string & getFileName() const
returns the current file name
Definition: GenericSAXHandler.cpp:74
SUMO_TAG_VAPORIZER
vaporizer of vehicles
Definition: SUMOXMLDefinitions.h:218
GNEParkingArea.h
GNEAdditionalHandler::parseAndBuildRerouterDestProbReroute
static bool parseAndBuildRerouterDestProbReroute(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a Destiny Prob Reroute.
Definition: GNEAdditionalHandler.cpp:1617
SUMO_ATTR_KEY
Definition: SUMOXMLDefinitions.h:408
GNEDestProbReroute.h
GNEAdditionalHandler::myEndElement
void myEndElement(int element)
Called when a closing tag occurs.
Definition: GNEAdditionalHandler.cpp:112
GNE_ATTR_BLOCK_MOVEMENT
block movement of a graphic element
Definition: SUMOXMLDefinitions.h:981
SUMO_ATTR_VISIBLE
Definition: SUMOXMLDefinitions.h:896
SUMORouteHandler.h
NamedObjectCont::get
T get(const std::string &id) const
Retrieves an item.
Definition: NamedObjectCont.h:98
GNEAdditionalHandler::parseAndBuildDetectorE2
static bool parseAndBuildDetectorE2(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a lane area detector (GNEViewNet* viewNet, bool allowUndoRedo,...
Definition: GNEAdditionalHandler.cpp:2206
SUMO_ATTR_VALUE
Definition: SUMOXMLDefinitions.h:779
GNETAZSourceSink.h
SUMO_ATTR_EFFICIENCY
Eficiency of the charge in Charging Stations.
Definition: SUMOXMLDefinitions.h:471
GNEAdditionalHandler::buildParkingArea
static GNEAdditional * buildParkingArea(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, GNELane *lane, const double startPos, const double endPos, const int parametersSet, const std::string &name, bool friendlyPosition, int roadSideCapacity, bool onRoad, double width, const std::string &length, double angle, bool blockMovement)
Builds a Parking Area.
Definition: GNEAdditionalHandler.cpp:329
GNEReferenceCounter::incRef
void incRef(const std::string &debugMsg="")
Increarse reference.
Definition: GNEReferenceCounter.h:67
SUMO_ATTR_ONROAD
Definition: SUMOXMLDefinitions.h:773
GNEDetectorEntryExit
Definition: GNEDetectorEntryExit.h:38
GNEAdditionalHandler::parseAndBuildRerouterClosingReroute
static bool parseAndBuildRerouterClosingReroute(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a Closing Reroute.
Definition: GNEAdditionalHandler.cpp:1581
GNERerouter.h
GNEBusStop.h
SUMO_ATTR_ALLOW
Definition: SUMOXMLDefinitions.h:782
SUMO_ATTR_POSITION_LAT
Definition: SUMOXMLDefinitions.h:661
GNECalibrator.h
GNEVaporizer
Representation of a vaporizer in netedit.
Definition: GNEVaporizer.h:34
Parameterised::setParameter
void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
Definition: Parameterised.cpp:46
FileHelpers::isAbsolute
static bool isAbsolute(const std::string &path)
Returns the information whether the given path is absolute.
Definition: FileHelpers.cpp:129
SUMO_TAG_ROUTEPROBE
a routeprobe detector
Definition: SUMOXMLDefinitions.h:115
GNENet::retrieveEdge
GNEEdge * retrieveEdge(const std::string &id, bool failHard=true)
get edge by id
Definition: GNENet.cpp:1069
GNEAttributeCarrier::TagProperties::hasParameters
bool hasParameters() const
return true if Tag correspond to an element that supports parameters "key1=value1|key2=value2|....
Definition: GNEAttributeCarrier.cpp:858
SUMO_ATTR_JAM_DIST_THRESHOLD
Definition: SUMOXMLDefinitions.h:752
NBEdge::getFinalLength
double getFinalLength() const
get length that will be assigned to the lanes in the final network
Definition: NBEdge.cpp:3682
ShapeContainer::addPOI
virtual bool addPOI(const std::string &id, const std::string &type, const RGBColor &color, const Position &pos, bool geo, const std::string &lane, double posOverLane, double posLat, double layer, double angle, const std::string &imgFile, bool relativePath, double width, double height, bool ignorePruning=false)
Builds a POI using the given values and adds it to the container.
Definition: ShapeContainer.cpp:145
GNEAdditionalHandler::parseAndBuildVariableSpeedSignStep
static bool parseAndBuildVariableSpeedSignStep(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a Variable Speed Signal Step.
Definition: GNEAdditionalHandler.cpp:1420
SUMO_TAG_ROUTE
begin/end of the description of a route
Definition: SUMOXMLDefinitions.h:125
GNENet::retrieveLane
GNELane * retrieveLane(const std::string &id, bool failHard=true, bool checkVolatileChange=false)
get lane by id
Definition: GNENet.cpp:1228
SUMO_TAG_E3DETECTOR
an e3 detector
Definition: SUMOXMLDefinitions.h:73
config.h
ShapeHandler
The XML-Handler for network loading.
Definition: ShapeHandler.h:49
GNEAdditionalHandler::buildChargingStation
static GNEAdditional * buildChargingStation(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, GNELane *lane, const double startPos, const double endPos, const int parametersSet, const std::string &name, double chargingPower, double efficiency, bool chargeInTransit, SUMOTime chargeDelay, bool friendlyPosition, bool blockMovement)
Builds a charging Station.
Definition: GNEAdditionalHandler.cpp:308
SUMO_TAG_CLOSING_LANE_REROUTE
lane of a reroute of type closing
Definition: SUMOXMLDefinitions.h:194
GNEAdditionalHandler::HierarchyInsertedAdditionals::popElement
void popElement()
pop last inserted element (used only in function myEndElement)
Definition: GNEAdditionalHandler.cpp:2628
GNEAdditionalHandler::parseAndBuildParkingArea
static bool parseAndBuildParkingArea(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a parking area.
Definition: GNEAdditionalHandler.cpp:1980
SUMO_ATTR_END
weights: time range end
Definition: SUMOXMLDefinitions.h:680
GNEAdditionalHandler::parseAndBuildTAZ
static bool parseAndBuildTAZ(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Builds a TAZ.
Definition: GNEAdditionalHandler.cpp:1099
GNEContainerStop
A lane area vehicles can halt at (netedit-version)
Definition: GNEContainerStop.h:34
SUMO_ATTR_DEPARTPOS
Definition: SUMOXMLDefinitions.h:433
SUMO_TAG_INTERVAL
an aggreagated-output interval
Definition: SUMOXMLDefinitions.h:159
GNEAdditionalHandler::HierarchyInsertedAdditionals::commitElementInsertion
void commitElementInsertion(GNEAdditional *additionalCreated)
commit element insertion (used to save last correct created element)
Definition: GNEAdditionalHandler.cpp:2622
SUMORouteHandler::StopPos
StopPos
enum for stops
Definition: SUMORouteHandler.h:53
GNEAttributeCarrier::getTagStr
const std::string & getTagStr() const
get tag assigned to this object in string format
Definition: GNEAttributeCarrier.cpp:1267
GNEDetectorE1Instant
Definition: GNEDetectorE1Instant.h:34
SUMO_ATTR_NAME
Definition: SUMOXMLDefinitions.h:380
ShapeContainer::getPolygons
const Polygons & getPolygons() const
Returns all polygons.
Definition: ShapeContainer.h:149
GNEAdditionalHandler::buildClosingLaneReroute
static GNEAdditional * buildClosingLaneReroute(GNEViewNet *viewNet, bool allowUndoRedo, GNEAdditional *rerouterIntervalParent, GNELane *closedLane, SVCPermissions permissions)
Definition: GNEAdditionalHandler.cpp:649
SUMO_ATTR_VEHSPERHOUR
Definition: SUMOXMLDefinitions.h:786
GNEAdditionalHandler::accessCanBeCreated
static bool accessCanBeCreated(GNEAdditional *busStopParent, GNEEdge *edge)
check if a GNEAccess can be created in a certain Edge
Definition: GNEAdditionalHandler.cpp:1019
SUMO_TAG_ACCESS
An access point for a train stop.
Definition: SUMOXMLDefinitions.h:103
GNEAdditionalHandler::buildCalibratorFlow
static GNEAdditional * buildCalibratorFlow(GNEViewNet *viewNet, bool allowUndoRedo, GNEAdditional *calibratorParent, GNEDemandElement *route, GNEDemandElement *vType, const std::string &vehsPerHour, const std::string &speed, const RGBColor &color, const std::string &departLane, const std::string &departPos, const std::string &departSpeed, const std::string &arrivalLane, const std::string &arrivalPos, const std::string &arrivalSpeed, const std::string &line, int personNumber, int containerNumber, bool reroute, const std::string &departPosLat, const std::string &arrivalPosLat, SUMOTime begin, SUMOTime end)
builds a calibrator flow
Definition: GNEAdditionalHandler.cpp:568
SUMO_TAG_INDUCTION_LOOP
alternative tag for e1 detector
Definition: SUMOXMLDefinitions.h:65
SUMO_ATTR_LON
Definition: SUMOXMLDefinitions.h:814
GNEAdditionalHandler
Builds additional objects for GNENet (busStops, chargingStations, detectors, etc.....
Definition: GNEAdditionalHandler.h:47
GNEAdditionalHandler::parseAndBuildDetectorE1Instant
static bool parseAndBuildDetectorE1Instant(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds a Instant induction loop detector (GNEViewNet* viewNet,...
Definition: GNEAdditionalHandler.cpp:2420
SUMO_TAG_CALIBRATOR
A calibrator placed over edge.
Definition: SUMOXMLDefinitions.h:91
GNEAdditionalHandler::HierarchyInsertedAdditionals::insertElement
void insertElement(SumoXMLTag tag)
insert new element (called only in function myStartElement)
Definition: GNEAdditionalHandler.cpp:2616
GNEUndoList::p_begin
void p_begin(const std::string &description)
Begin undo command sub-group. This begins a new group of commands that are treated as a single comman...
Definition: GNEUndoList.cpp:72
GNEAdditionalHandler::parseAndBuildPOI
void parseAndBuildPOI(const SUMOSAXAttributes &attrs)
Parses his values and builds a POI.
Definition: GNEAdditionalHandler.cpp:2465
GNERouteProbReroute.h
GNEAdditionalHandler::buildRouteProbe
static GNEAdditional * buildRouteProbe(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, GNEEdge *edge, const std::string &freq, const std::string &name, const std::string &file, SUMOTime begin, bool centerAfterCreation)
builds a Route probe
Definition: GNEAdditionalHandler.cpp:734
SUMO_TAG_E1DETECTOR
an e1 detector
Definition: SUMOXMLDefinitions.h:63
GNEAdditionalHandler::buildVariableSpeedSign
static GNEAdditional * buildVariableSpeedSign(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, Position pos, const std::vector< GNELane * > &destLanes, const std::string &name, bool blockMovement)
Builds a VariableSpeedSign (lane speed additional)
Definition: GNEAdditionalHandler.cpp:758
SUMOSAXAttributes
Encapsulated SAX-Attributes.
Definition: SUMOSAXAttributes.h:56
SUMO_ATTR_SHAPE
edge: the shape in xml-definition
Definition: SUMOXMLDefinitions.h:690
GNEChargingStation.h
GNEAdditionalHandler::myViewNet
GNEViewNet * myViewNet
pointer to View's Net
Definition: GNEAdditionalHandler.h:738
SUMO_ATTR_X
Definition: SUMOXMLDefinitions.h:398
SUMO_TAG_E2DETECTOR
an e2 detector
Definition: SUMOXMLDefinitions.h:67
POSITION_EPS
#define POSITION_EPS
Definition: config.h:172
GNEAdditionalHandler::buildContainerStop
static GNEAdditional * buildContainerStop(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, GNELane *lane, const double startPos, const double endPos, const int parametersSet, const std::string &name, const std::vector< std::string > &lines, bool friendlyPosition, bool blockMovement)
Builds a container stop.
Definition: GNEAdditionalHandler.cpp:287
WRITE_ERROR
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:283
GNEParkingAreaReroute
Definition: GNEParkingAreaReroute.h:42
SUMO_TAG_DET_EXIT
an e3 exit point
Definition: SUMOXMLDefinitions.h:83
GNELane
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:45
GNEAdditionalHandler::checkAndFixDetectorPosition
static bool checkAndFixDetectorPosition(double &pos, const double laneLength, const bool friendlyPos)
check if the position of a detector over a lane is valid
Definition: GNEAdditionalHandler.cpp:987
SUMO_ATTR_ARRIVALLANE
Definition: SUMOXMLDefinitions.h:436
GNEAdditionalHandler::parseAndBuildPoly
void parseAndBuildPoly(const SUMOSAXAttributes &attrs)
Parses his values and builds a Poly.
Definition: GNEAdditionalHandler.cpp:1330
WRITE_MESSAGE
#define WRITE_MESSAGE(msg)
Definition: MsgHandler.h:277
GNEAdditionalHandler::buildTAZSink
static GNEAdditional * buildTAZSink(GNEViewNet *viewNet, bool allowUndoRedo, GNEAdditional *TAZ, GNEEdge *edge, double arrivalWeight)
Builds a TAZSink (Traffic Assignment Zone)
Definition: GNEAdditionalHandler.cpp:916
GNEAdditionalHandler::parseAndBuildRouteProbe
static bool parseAndBuildRouteProbe(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses his values and builds routeProbe.
Definition: GNEAdditionalHandler.cpp:1221
Shape::DEFAULT_LAYER_POI
static const double DEFAULT_LAYER_POI
Definition: Shape.h:45
GNEAdditionalHandler::HierarchyInsertedAdditionals::retrieveParentAdditional
GNEAdditional * retrieveParentAdditional(GNEViewNet *viewNet, SumoXMLTag expectedTag) const
retrieve parent additional correspond to current status of myInsertedElements
Definition: GNEAdditionalHandler.cpp:2636
WRITE_DEBUG
#define WRITE_DEBUG(msg)
Definition: MsgHandler.h:284
GNEHierarchicalChildElements::getChildAdditionals
const std::vector< GNEAdditional * > & getChildAdditionals() const
return child additionals
Definition: GNEHierarchicalChildElements.cpp:131
SUMO_ATTR_GEO
Definition: SUMOXMLDefinitions.h:816
GNETAZ::getTAZShape
const PositionVector & getTAZShape() const
get TAZ shape
Definition: GNETAZ.cpp:62
GNEAdditionalHandler::parseParameter
void parseParameter(const SUMOSAXAttributes &attrs)
Parse parameter and insert it in the last created additional.
Definition: GNEAdditionalHandler.cpp:2541
GNENet.h
GNEAdditionalHandler::parseAndBuildAccess
static bool parseAndBuildAccess(GNEViewNet *viewNet, bool allowUndoRedo, const SUMOSAXAttributes &attrs, HierarchyInsertedAdditionals *insertedAdditionals)
Parses values and adds access to the current bus stop.
Definition: GNEAdditionalHandler.cpp:1859
SUMO_TAG_INSTANT_INDUCTION_LOOP
An instantenous induction loop.
Definition: SUMOXMLDefinitions.h:87
XMLSubSys.h
GNEUndoList.h
Boundary::ymax
double ymax() const
Returns maximum y-coordinate.
Definition: Boundary.cpp:136
GNE_ATTR_PARENT
parent of an additional element
Definition: SUMOXMLDefinitions.h:987
GNETAZSourceSink
Definition: GNETAZSourceSink.h:40
GNEAdditionalHandler::buildTAZ
static GNEAdditional * buildTAZ(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, const PositionVector &shape, const RGBColor &color, const std::vector< GNEEdge * > &edges, bool blockMovement)
Builds a TAZ (Traffic Assignment Zone)
Definition: GNEAdditionalHandler.cpp:818