Eclipse SUMO - Simulation of Urban MObility
GNEDemandElementPlan.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 // Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials are made available under the
5 // terms of the Eclipse Public License 2.0 which is available at
6 // https://www.eclipse.org/legal/epl-2.0/
7 // This Source Code may also be made available under the following Secondary
8 // Licenses when the conditions for such availability set forth in the Eclipse
9 // Public License 2.0 are satisfied: GNU General Public License, version 2
10 // or later which is available at
11 // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 /****************************************************************************/
18 // An auxiliar, asbtract class for plan elements
19 /****************************************************************************/
20 
21 #include <utils/gui/windows/GUIAppEnum.h>
22 #include <netedit/changes/GNEChange_Attribute.h>
23 #include <netedit/GNENet.h>
24 #include <netedit/GNEUndoList.h>
25 #include <netedit/GNEViewNet.h>
26 #include <utils/gui/div/GLHelper.h>
27 #include <utils/gui/div/GUIDesigns.h>
28 
29 #include "GNEDemandElementPlan.h"
30 #include "GNERoute.h"
31 
32 // ===========================================================================
33 // static definitions
34 // ===========================================================================
35 
36 const double GNEDemandElementPlan::myArrivalPositionDiameter = SUMO_const_halfLaneWidth;
37 
38 // ===========================================================================
39 // GNEDemandElement method definitions
40 // ===========================================================================
41 
42 std::pair<SumoXMLTag, GUIIcon>
43 GNEDemandElementPlan::getWalkTagIcon(const CommonXMLStructure::PlanParameters& planParameters) {
44  if (planParameters.isSingleEdgePlan()) {
45  return std::make_pair(GNE_TAG_WALK_EDGE_EDGE, GUIIcon::WALK_EDGE);
46  } else if (planParameters.consecutiveEdges.size() > 0) {
47  return std::make_pair(GNE_TAG_WALK_EDGES, GUIIcon::WALK_EDGES);
48  } else if (!planParameters.toRoute.empty()) {
49  return std::make_pair(GNE_TAG_WALK_ROUTE, GUIIcon::WALK_ROUTE);
50  } else if (!planParameters.fromEdge.empty()) {
51  if (!planParameters.toEdge.empty()) {
52  return std::make_pair(GNE_TAG_WALK_EDGE_EDGE, GUIIcon::WALK_EDGE);
53  } else if (!planParameters.toTAZ.empty()) {
54  return std::make_pair(GNE_TAG_WALK_EDGE_TAZ, GUIIcon::WALK_TAZ);
55  } else if (!planParameters.toJunction.empty()) {
56  return std::make_pair(GNE_TAG_WALK_EDGE_JUNCTION, GUIIcon::WALK_JUNCTION);
57  } else if (!planParameters.toBusStop.empty()) {
58  return std::make_pair(GNE_TAG_WALK_EDGE_BUSSTOP, GUIIcon::WALK_BUSSTOP);
59  } else if (!planParameters.toTrainStop.empty()) {
60  return std::make_pair(GNE_TAG_WALK_EDGE_TRAINSTOP, GUIIcon::WALK_TRAINSTOP);
61  } else if (!planParameters.toContainerStop.empty()) {
62  return std::make_pair(GNE_TAG_WALK_EDGE_CONTAINERSTOP, GUIIcon::WALK_CONTAINERSTOP);
63  } else if (!planParameters.toChargingStation.empty()) {
64  return std::make_pair(GNE_TAG_WALK_EDGE_CHARGINGSTATION, GUIIcon::WALK_CHARGINGSTATION);
65  } else if (!planParameters.toParkingArea.empty()) {
66  return std::make_pair(GNE_TAG_WALK_EDGE_PARKINGAREA, GUIIcon::WALK_PARKINGAREA);
67  } else {
68  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
69  }
70  } else if (!planParameters.fromTAZ.empty()) {
71  if (!planParameters.toEdge.empty()) {
72  return std::make_pair(GNE_TAG_WALK_TAZ_EDGE, GUIIcon::WALK_EDGE);
73  } else if (!planParameters.toTAZ.empty()) {
74  return std::make_pair(GNE_TAG_WALK_TAZ_TAZ, GUIIcon::WALK_TAZ);
75  } else if (!planParameters.toJunction.empty()) {
76  return std::make_pair(GNE_TAG_WALK_TAZ_JUNCTION, GUIIcon::WALK_JUNCTION);
77  } else if (!planParameters.toBusStop.empty()) {
78  return std::make_pair(GNE_TAG_WALK_TAZ_BUSSTOP, GUIIcon::WALK_BUSSTOP);
79  } else if (!planParameters.toTrainStop.empty()) {
80  return std::make_pair(GNE_TAG_WALK_TAZ_TRAINSTOP, GUIIcon::WALK_TRAINSTOP);
81  } else if (!planParameters.toContainerStop.empty()) {
82  return std::make_pair(GNE_TAG_WALK_TAZ_CONTAINERSTOP, GUIIcon::WALK_CONTAINERSTOP);
83  } else if (!planParameters.toChargingStation.empty()) {
84  return std::make_pair(GNE_TAG_WALK_TAZ_CHARGINGSTATION, GUIIcon::WALK_CHARGINGSTATION);
85  } else if (!planParameters.toParkingArea.empty()) {
86  return std::make_pair(GNE_TAG_WALK_TAZ_PARKINGAREA, GUIIcon::WALK_PARKINGAREA);
87  } else {
88  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
89  }
90  } else if (!planParameters.fromJunction.empty()) {
91  if (!planParameters.toEdge.empty()) {
92  return std::make_pair(GNE_TAG_WALK_JUNCTION_EDGE, GUIIcon::WALK_EDGE);
93  } else if (!planParameters.toTAZ.empty()) {
94  return std::make_pair(GNE_TAG_WALK_JUNCTION_TAZ, GUIIcon::WALK_TAZ);
95  } else if (!planParameters.toJunction.empty()) {
96  return std::make_pair(GNE_TAG_WALK_JUNCTION_JUNCTION, GUIIcon::WALK_JUNCTION);
97  } else if (!planParameters.toBusStop.empty()) {
98  return std::make_pair(GNE_TAG_WALK_JUNCTION_BUSSTOP, GUIIcon::WALK_BUSSTOP);
99  } else if (!planParameters.toTrainStop.empty()) {
100  return std::make_pair(GNE_TAG_WALK_JUNCTION_TRAINSTOP, GUIIcon::WALK_TRAINSTOP);
101  } else if (!planParameters.toContainerStop.empty()) {
102  return std::make_pair(GNE_TAG_WALK_JUNCTION_CONTAINERSTOP, GUIIcon::WALK_CONTAINERSTOP);
103  } else if (!planParameters.toChargingStation.empty()) {
104  return std::make_pair(GNE_TAG_WALK_JUNCTION_CHARGINGSTATION, GUIIcon::WALK_CHARGINGSTATION);
105  } else if (!planParameters.toParkingArea.empty()) {
106  return std::make_pair(GNE_TAG_WALK_JUNCTION_PARKINGAREA, GUIIcon::WALK_PARKINGAREA);
107  } else {
108  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
109  }
110  } else if (!planParameters.fromBusStop.empty()) {
111  if (!planParameters.toEdge.empty()) {
112  return std::make_pair(GNE_TAG_WALK_BUSSTOP_EDGE, GUIIcon::WALK_EDGE);
113  } else if (!planParameters.toTAZ.empty()) {
114  return std::make_pair(GNE_TAG_WALK_BUSSTOP_TAZ, GUIIcon::WALK_TAZ);
115  } else if (!planParameters.toJunction.empty()) {
116  return std::make_pair(GNE_TAG_WALK_BUSSTOP_JUNCTION, GUIIcon::WALK_JUNCTION);
117  } else if (!planParameters.toBusStop.empty()) {
118  return std::make_pair(GNE_TAG_WALK_BUSSTOP_BUSSTOP, GUIIcon::WALK_BUSSTOP);
119  } else if (!planParameters.toTrainStop.empty()) {
120  return std::make_pair(GNE_TAG_WALK_BUSSTOP_TRAINSTOP, GUIIcon::WALK_TRAINSTOP);
121  } else if (!planParameters.toContainerStop.empty()) {
122  return std::make_pair(GNE_TAG_WALK_BUSSTOP_CONTAINERSTOP, GUIIcon::WALK_CONTAINERSTOP);
123  } else if (!planParameters.toChargingStation.empty()) {
124  return std::make_pair(GNE_TAG_WALK_BUSSTOP_CHARGINGSTATION, GUIIcon::WALK_CHARGINGSTATION);
125  } else if (!planParameters.toParkingArea.empty()) {
126  return std::make_pair(GNE_TAG_WALK_BUSSTOP_PARKINGAREA, GUIIcon::WALK_PARKINGAREA);
127  } else {
128  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
129  }
130  } else if (!planParameters.fromTrainStop.empty()) {
131  if (!planParameters.toEdge.empty()) {
132  return std::make_pair(GNE_TAG_WALK_TRAINSTOP_EDGE, GUIIcon::WALK_EDGE);
133  } else if (!planParameters.toTAZ.empty()) {
134  return std::make_pair(GNE_TAG_WALK_TRAINSTOP_TAZ, GUIIcon::WALK_TAZ);
135  } else if (!planParameters.toJunction.empty()) {
136  return std::make_pair(GNE_TAG_WALK_TRAINSTOP_JUNCTION, GUIIcon::WALK_JUNCTION);
137  } else if (!planParameters.toBusStop.empty()) {
138  return std::make_pair(GNE_TAG_WALK_TRAINSTOP_BUSSTOP, GUIIcon::WALK_BUSSTOP);
139  } else if (!planParameters.toTrainStop.empty()) {
140  return std::make_pair(GNE_TAG_WALK_TRAINSTOP_TRAINSTOP, GUIIcon::WALK_TRAINSTOP);
141  } else if (!planParameters.toContainerStop.empty()) {
142  return std::make_pair(GNE_TAG_WALK_TRAINSTOP_CONTAINERSTOP, GUIIcon::WALK_CONTAINERSTOP);
143  } else if (!planParameters.toChargingStation.empty()) {
144  return std::make_pair(GNE_TAG_WALK_TRAINSTOP_CHARGINGSTATION, GUIIcon::WALK_CHARGINGSTATION);
145  } else if (!planParameters.toParkingArea.empty()) {
146  return std::make_pair(GNE_TAG_WALK_TRAINSTOP_PARKINGAREA, GUIIcon::WALK_PARKINGAREA);
147  } else {
148  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
149  }
150  } else if (!planParameters.fromContainerStop.empty()) {
151  if (!planParameters.toEdge.empty()) {
152  return std::make_pair(GNE_TAG_WALK_CONTAINERSTOP_EDGE, GUIIcon::WALK_EDGE);
153  } else if (!planParameters.toTAZ.empty()) {
154  return std::make_pair(GNE_TAG_WALK_CONTAINERSTOP_TAZ, GUIIcon::WALK_TAZ);
155  } else if (!planParameters.toJunction.empty()) {
156  return std::make_pair(GNE_TAG_WALK_CONTAINERSTOP_JUNCTION, GUIIcon::WALK_JUNCTION);
157  } else if (!planParameters.toBusStop.empty()) {
158  return std::make_pair(GNE_TAG_WALK_CONTAINERSTOP_BUSSTOP, GUIIcon::WALK_BUSSTOP);
159  } else if (!planParameters.toTrainStop.empty()) {
160  return std::make_pair(GNE_TAG_WALK_CONTAINERSTOP_TRAINSTOP, GUIIcon::WALK_TRAINSTOP);
161  } else if (!planParameters.toContainerStop.empty()) {
162  return std::make_pair(GNE_TAG_WALK_CONTAINERSTOP_CONTAINERSTOP, GUIIcon::WALK_CONTAINERSTOP);
163  } else if (!planParameters.toChargingStation.empty()) {
164  return std::make_pair(GNE_TAG_WALK_CONTAINERSTOP_CHARGINGSTATION, GUIIcon::WALK_CHARGINGSTATION);
165  } else if (!planParameters.toParkingArea.empty()) {
166  return std::make_pair(GNE_TAG_WALK_CONTAINERSTOP_PARKINGAREA, GUIIcon::WALK_PARKINGAREA);
167  } else {
168  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
169  }
170  } else if (!planParameters.fromChargingStation.empty()) {
171  if (!planParameters.toEdge.empty()) {
172  return std::make_pair(GNE_TAG_WALK_CHARGINGSTATION_EDGE, GUIIcon::WALK_EDGE);
173  } else if (!planParameters.toTAZ.empty()) {
174  return std::make_pair(GNE_TAG_WALK_CHARGINGSTATION_TAZ, GUIIcon::WALK_TAZ);
175  } else if (!planParameters.toJunction.empty()) {
176  return std::make_pair(GNE_TAG_WALK_CHARGINGSTATION_JUNCTION, GUIIcon::WALK_JUNCTION);
177  } else if (!planParameters.toBusStop.empty()) {
178  return std::make_pair(GNE_TAG_WALK_CHARGINGSTATION_BUSSTOP, GUIIcon::WALK_BUSSTOP);
179  } else if (!planParameters.toTrainStop.empty()) {
180  return std::make_pair(GNE_TAG_WALK_CHARGINGSTATION_TRAINSTOP, GUIIcon::WALK_TRAINSTOP);
181  } else if (!planParameters.toContainerStop.empty()) {
182  return std::make_pair(GNE_TAG_WALK_CHARGINGSTATION_CONTAINERSTOP, GUIIcon::WALK_CONTAINERSTOP);
183  } else if (!planParameters.toChargingStation.empty()) {
184  return std::make_pair(GNE_TAG_WALK_CHARGINGSTATION_CHARGINGSTATION, GUIIcon::WALK_CHARGINGSTATION);
185  } else if (!planParameters.toParkingArea.empty()) {
186  return std::make_pair(GNE_TAG_WALK_CHARGINGSTATION_PARKINGAREA, GUIIcon::WALK_PARKINGAREA);
187  } else {
188  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
189  }
190  } else if (!planParameters.fromParkingArea.empty()) {
191  if (!planParameters.toEdge.empty()) {
192  return std::make_pair(GNE_TAG_WALK_PARKINGAREA_EDGE, GUIIcon::WALK_EDGE);
193  } else if (!planParameters.toTAZ.empty()) {
194  return std::make_pair(GNE_TAG_WALK_PARKINGAREA_TAZ, GUIIcon::WALK_TAZ);
195  } else if (!planParameters.toJunction.empty()) {
196  return std::make_pair(GNE_TAG_WALK_PARKINGAREA_JUNCTION, GUIIcon::WALK_JUNCTION);
197  } else if (!planParameters.toBusStop.empty()) {
198  return std::make_pair(GNE_TAG_WALK_PARKINGAREA_BUSSTOP, GUIIcon::WALK_BUSSTOP);
199  } else if (!planParameters.toTrainStop.empty()) {
200  return std::make_pair(GNE_TAG_WALK_PARKINGAREA_TRAINSTOP, GUIIcon::WALK_TRAINSTOP);
201  } else if (!planParameters.toContainerStop.empty()) {
202  return std::make_pair(GNE_TAG_WALK_PARKINGAREA_CONTAINERSTOP, GUIIcon::WALK_CONTAINERSTOP);
203  } else if (!planParameters.toChargingStation.empty()) {
204  return std::make_pair(GNE_TAG_WALK_PARKINGAREA_CHARGINGSTATION, GUIIcon::WALK_CHARGINGSTATION);
205  } else if (!planParameters.toParkingArea.empty()) {
206  return std::make_pair(GNE_TAG_WALK_PARKINGAREA_PARKINGAREA, GUIIcon::WALK_PARKINGAREA);
207  } else {
208  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
209  }
210  } else {
211  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
212  }
213 }
214 
215 
216 std::pair<SumoXMLTag, GUIIcon>
217 GNEDemandElementPlan::getPersonTripTagIcon(const CommonXMLStructure::PlanParameters& planParameters) {
218  if (planParameters.isSingleEdgePlan()) {
219  return std::make_pair(GNE_TAG_PERSONTRIP_EDGE_EDGE, GUIIcon::PERSONTRIP_EDGE);
220  } else if (!planParameters.fromEdge.empty()) {
221  if (!planParameters.toEdge.empty()) {
222  return std::make_pair(GNE_TAG_PERSONTRIP_EDGE_EDGE, GUIIcon::PERSONTRIP_EDGE);
223  } else if (!planParameters.toTAZ.empty()) {
224  return std::make_pair(GNE_TAG_PERSONTRIP_EDGE_TAZ, GUIIcon::PERSONTRIP_TAZ);
225  } else if (!planParameters.toJunction.empty()) {
226  return std::make_pair(GNE_TAG_PERSONTRIP_EDGE_JUNCTION, GUIIcon::PERSONTRIP_JUNCTION);
227  } else if (!planParameters.toBusStop.empty()) {
228  return std::make_pair(GNE_TAG_PERSONTRIP_EDGE_BUSSTOP, GUIIcon::PERSONTRIP_BUSSTOP);
229  } else if (!planParameters.toTrainStop.empty()) {
230  return std::make_pair(GNE_TAG_PERSONTRIP_EDGE_TRAINSTOP, GUIIcon::PERSONTRIP_TRAINSTOP);
231  } else if (!planParameters.toContainerStop.empty()) {
232  return std::make_pair(GNE_TAG_PERSONTRIP_EDGE_CONTAINERSTOP, GUIIcon::PERSONTRIP_CONTAINERSTOP);
233  } else if (!planParameters.toChargingStation.empty()) {
234  return std::make_pair(GNE_TAG_PERSONTRIP_EDGE_CHARGINGSTATION, GUIIcon::PERSONTRIP_CHARGINGSTATION);
235  } else if (!planParameters.toParkingArea.empty()) {
236  return std::make_pair(GNE_TAG_PERSONTRIP_EDGE_PARKINGAREA, GUIIcon::PERSONTRIP_PARKINGAREA);
237  } else {
238  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
239  }
240  } else if (!planParameters.fromTAZ.empty()) {
241  if (!planParameters.toEdge.empty()) {
242  return std::make_pair(GNE_TAG_PERSONTRIP_TAZ_EDGE, GUIIcon::PERSONTRIP_EDGE);
243  } else if (!planParameters.toTAZ.empty()) {
244  return std::make_pair(GNE_TAG_PERSONTRIP_TAZ_TAZ, GUIIcon::PERSONTRIP_TAZ);
245  } else if (!planParameters.toJunction.empty()) {
246  return std::make_pair(GNE_TAG_PERSONTRIP_TAZ_JUNCTION, GUIIcon::PERSONTRIP_JUNCTION);
247  } else if (!planParameters.toBusStop.empty()) {
248  return std::make_pair(GNE_TAG_PERSONTRIP_TAZ_BUSSTOP, GUIIcon::PERSONTRIP_BUSSTOP);
249  } else if (!planParameters.toTrainStop.empty()) {
250  return std::make_pair(GNE_TAG_PERSONTRIP_TAZ_TRAINSTOP, GUIIcon::PERSONTRIP_TRAINSTOP);
251  } else if (!planParameters.toContainerStop.empty()) {
252  return std::make_pair(GNE_TAG_PERSONTRIP_TAZ_CONTAINERSTOP, GUIIcon::PERSONTRIP_CONTAINERSTOP);
253  } else if (!planParameters.toChargingStation.empty()) {
254  return std::make_pair(GNE_TAG_PERSONTRIP_TAZ_CHARGINGSTATION, GUIIcon::PERSONTRIP_CHARGINGSTATION);
255  } else if (!planParameters.toParkingArea.empty()) {
256  return std::make_pair(GNE_TAG_PERSONTRIP_TAZ_PARKINGAREA, GUIIcon::PERSONTRIP_PARKINGAREA);
257  } else {
258  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
259  }
260  } else if (!planParameters.fromJunction.empty()) {
261  if (!planParameters.toEdge.empty()) {
262  return std::make_pair(GNE_TAG_PERSONTRIP_JUNCTION_EDGE, GUIIcon::PERSONTRIP_EDGE);
263  } else if (!planParameters.toTAZ.empty()) {
264  return std::make_pair(GNE_TAG_PERSONTRIP_JUNCTION_TAZ, GUIIcon::PERSONTRIP_TAZ);
265  } else if (!planParameters.toJunction.empty()) {
266  return std::make_pair(GNE_TAG_PERSONTRIP_JUNCTION_JUNCTION, GUIIcon::PERSONTRIP_JUNCTION);
267  } else if (!planParameters.toBusStop.empty()) {
268  return std::make_pair(GNE_TAG_PERSONTRIP_JUNCTION_BUSSTOP, GUIIcon::PERSONTRIP_BUSSTOP);
269  } else if (!planParameters.toTrainStop.empty()) {
270  return std::make_pair(GNE_TAG_PERSONTRIP_JUNCTION_TRAINSTOP, GUIIcon::PERSONTRIP_TRAINSTOP);
271  } else if (!planParameters.toContainerStop.empty()) {
272  return std::make_pair(GNE_TAG_PERSONTRIP_JUNCTION_CONTAINERSTOP, GUIIcon::PERSONTRIP_CONTAINERSTOP);
273  } else if (!planParameters.toChargingStation.empty()) {
274  return std::make_pair(GNE_TAG_PERSONTRIP_JUNCTION_CHARGINGSTATION, GUIIcon::PERSONTRIP_CHARGINGSTATION);
275  } else if (!planParameters.toParkingArea.empty()) {
276  return std::make_pair(GNE_TAG_PERSONTRIP_JUNCTION_PARKINGAREA, GUIIcon::PERSONTRIP_PARKINGAREA);
277  } else {
278  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
279  }
280  } else if (!planParameters.fromBusStop.empty()) {
281  if (!planParameters.toEdge.empty()) {
282  return std::make_pair(GNE_TAG_PERSONTRIP_BUSSTOP_EDGE, GUIIcon::PERSONTRIP_EDGE);
283  } else if (!planParameters.toTAZ.empty()) {
284  return std::make_pair(GNE_TAG_PERSONTRIP_BUSSTOP_TAZ, GUIIcon::PERSONTRIP_TAZ);
285  } else if (!planParameters.toJunction.empty()) {
286  return std::make_pair(GNE_TAG_PERSONTRIP_BUSSTOP_JUNCTION, GUIIcon::PERSONTRIP_JUNCTION);
287  } else if (!planParameters.toBusStop.empty()) {
288  return std::make_pair(GNE_TAG_PERSONTRIP_BUSSTOP_BUSSTOP, GUIIcon::PERSONTRIP_BUSSTOP);
289  } else if (!planParameters.toTrainStop.empty()) {
290  return std::make_pair(GNE_TAG_PERSONTRIP_BUSSTOP_TRAINSTOP, GUIIcon::PERSONTRIP_TRAINSTOP);
291  } else if (!planParameters.toContainerStop.empty()) {
292  return std::make_pair(GNE_TAG_PERSONTRIP_BUSSTOP_CONTAINERSTOP, GUIIcon::PERSONTRIP_CONTAINERSTOP);
293  } else if (!planParameters.toChargingStation.empty()) {
294  return std::make_pair(GNE_TAG_PERSONTRIP_BUSSTOP_CHARGINGSTATION, GUIIcon::PERSONTRIP_CHARGINGSTATION);
295  } else if (!planParameters.toParkingArea.empty()) {
296  return std::make_pair(GNE_TAG_PERSONTRIP_BUSSTOP_PARKINGAREA, GUIIcon::PERSONTRIP_PARKINGAREA);
297  } else {
298  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
299  }
300  } else if (!planParameters.fromTrainStop.empty()) {
301  if (!planParameters.toEdge.empty()) {
302  return std::make_pair(GNE_TAG_PERSONTRIP_TRAINSTOP_EDGE, GUIIcon::PERSONTRIP_EDGE);
303  } else if (!planParameters.toTAZ.empty()) {
304  return std::make_pair(GNE_TAG_PERSONTRIP_TRAINSTOP_TAZ, GUIIcon::PERSONTRIP_TAZ);
305  } else if (!planParameters.toJunction.empty()) {
306  return std::make_pair(GNE_TAG_PERSONTRIP_TRAINSTOP_JUNCTION, GUIIcon::PERSONTRIP_JUNCTION);
307  } else if (!planParameters.toBusStop.empty()) {
308  return std::make_pair(GNE_TAG_PERSONTRIP_TRAINSTOP_BUSSTOP, GUIIcon::PERSONTRIP_BUSSTOP);
309  } else if (!planParameters.toTrainStop.empty()) {
310  return std::make_pair(GNE_TAG_PERSONTRIP_TRAINSTOP_TRAINSTOP, GUIIcon::PERSONTRIP_TRAINSTOP);
311  } else if (!planParameters.toContainerStop.empty()) {
312  return std::make_pair(GNE_TAG_PERSONTRIP_TRAINSTOP_CONTAINERSTOP, GUIIcon::PERSONTRIP_CONTAINERSTOP);
313  } else if (!planParameters.toChargingStation.empty()) {
314  return std::make_pair(GNE_TAG_PERSONTRIP_TRAINSTOP_CHARGINGSTATION, GUIIcon::PERSONTRIP_CHARGINGSTATION);
315  } else if (!planParameters.toParkingArea.empty()) {
316  return std::make_pair(GNE_TAG_PERSONTRIP_TRAINSTOP_PARKINGAREA, GUIIcon::PERSONTRIP_PARKINGAREA);
317  } else {
318  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
319  }
320  } else if (!planParameters.fromContainerStop.empty()) {
321  if (!planParameters.toEdge.empty()) {
322  return std::make_pair(GNE_TAG_PERSONTRIP_CONTAINERSTOP_EDGE, GUIIcon::PERSONTRIP_EDGE);
323  } else if (!planParameters.toTAZ.empty()) {
324  return std::make_pair(GNE_TAG_PERSONTRIP_CONTAINERSTOP_TAZ, GUIIcon::PERSONTRIP_TAZ);
325  } else if (!planParameters.toJunction.empty()) {
326  return std::make_pair(GNE_TAG_PERSONTRIP_CONTAINERSTOP_JUNCTION, GUIIcon::PERSONTRIP_JUNCTION);
327  } else if (!planParameters.toBusStop.empty()) {
328  return std::make_pair(GNE_TAG_PERSONTRIP_CONTAINERSTOP_BUSSTOP, GUIIcon::PERSONTRIP_BUSSTOP);
329  } else if (!planParameters.toTrainStop.empty()) {
330  return std::make_pair(GNE_TAG_PERSONTRIP_CONTAINERSTOP_TRAINSTOP, GUIIcon::PERSONTRIP_TRAINSTOP);
331  } else if (!planParameters.toContainerStop.empty()) {
332  return std::make_pair(GNE_TAG_PERSONTRIP_CONTAINERSTOP_CONTAINERSTOP, GUIIcon::PERSONTRIP_CONTAINERSTOP);
333  } else if (!planParameters.toChargingStation.empty()) {
334  return std::make_pair(GNE_TAG_PERSONTRIP_CONTAINERSTOP_CHARGINGSTATION, GUIIcon::PERSONTRIP_CHARGINGSTATION);
335  } else if (!planParameters.toParkingArea.empty()) {
336  return std::make_pair(GNE_TAG_PERSONTRIP_CONTAINERSTOP_PARKINGAREA, GUIIcon::PERSONTRIP_PARKINGAREA);
337  } else {
338  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
339  }
340  } else if (!planParameters.fromChargingStation.empty()) {
341  if (!planParameters.toEdge.empty()) {
342  return std::make_pair(GNE_TAG_PERSONTRIP_CHARGINGSTATION_EDGE, GUIIcon::PERSONTRIP_EDGE);
343  } else if (!planParameters.toTAZ.empty()) {
344  return std::make_pair(GNE_TAG_PERSONTRIP_CHARGINGSTATION_TAZ, GUIIcon::PERSONTRIP_TAZ);
345  } else if (!planParameters.toJunction.empty()) {
346  return std::make_pair(GNE_TAG_PERSONTRIP_CHARGINGSTATION_JUNCTION, GUIIcon::PERSONTRIP_JUNCTION);
347  } else if (!planParameters.toBusStop.empty()) {
348  return std::make_pair(GNE_TAG_PERSONTRIP_CHARGINGSTATION_BUSSTOP, GUIIcon::PERSONTRIP_BUSSTOP);
349  } else if (!planParameters.toTrainStop.empty()) {
350  return std::make_pair(GNE_TAG_PERSONTRIP_CHARGINGSTATION_TRAINSTOP, GUIIcon::PERSONTRIP_TRAINSTOP);
351  } else if (!planParameters.toContainerStop.empty()) {
352  return std::make_pair(GNE_TAG_PERSONTRIP_CHARGINGSTATION_CONTAINERSTOP, GUIIcon::PERSONTRIP_CONTAINERSTOP);
353  } else if (!planParameters.toChargingStation.empty()) {
354  return std::make_pair(GNE_TAG_PERSONTRIP_CHARGINGSTATION_CHARGINGSTATION, GUIIcon::PERSONTRIP_CHARGINGSTATION);
355  } else if (!planParameters.toParkingArea.empty()) {
356  return std::make_pair(GNE_TAG_PERSONTRIP_CHARGINGSTATION_PARKINGAREA, GUIIcon::PERSONTRIP_PARKINGAREA);
357  } else {
358  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
359  }
360  } else if (!planParameters.fromParkingArea.empty()) {
361  if (!planParameters.toEdge.empty()) {
362  return std::make_pair(GNE_TAG_PERSONTRIP_PARKINGAREA_EDGE, GUIIcon::PERSONTRIP_EDGE);
363  } else if (!planParameters.toTAZ.empty()) {
364  return std::make_pair(GNE_TAG_PERSONTRIP_PARKINGAREA_TAZ, GUIIcon::PERSONTRIP_TAZ);
365  } else if (!planParameters.toJunction.empty()) {
366  return std::make_pair(GNE_TAG_PERSONTRIP_PARKINGAREA_JUNCTION, GUIIcon::PERSONTRIP_JUNCTION);
367  } else if (!planParameters.toBusStop.empty()) {
368  return std::make_pair(GNE_TAG_PERSONTRIP_PARKINGAREA_BUSSTOP, GUIIcon::PERSONTRIP_BUSSTOP);
369  } else if (!planParameters.toTrainStop.empty()) {
370  return std::make_pair(GNE_TAG_PERSONTRIP_PARKINGAREA_TRAINSTOP, GUIIcon::PERSONTRIP_TRAINSTOP);
371  } else if (!planParameters.toContainerStop.empty()) {
372  return std::make_pair(GNE_TAG_PERSONTRIP_PARKINGAREA_CONTAINERSTOP, GUIIcon::PERSONTRIP_CONTAINERSTOP);
373  } else if (!planParameters.toChargingStation.empty()) {
374  return std::make_pair(GNE_TAG_PERSONTRIP_PARKINGAREA_CHARGINGSTATION, GUIIcon::PERSONTRIP_CHARGINGSTATION);
375  } else if (!planParameters.toParkingArea.empty()) {
376  return std::make_pair(GNE_TAG_PERSONTRIP_PARKINGAREA_PARKINGAREA, GUIIcon::PERSONTRIP_PARKINGAREA);
377  } else {
378  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
379  }
380  } else {
381  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
382  }
383 }
384 
385 
386 std::pair<SumoXMLTag, GUIIcon>
387 GNEDemandElementPlan::getRideTagIcon(const CommonXMLStructure::PlanParameters& planParameters) {
388  if (planParameters.isSingleEdgePlan()) {
389  return std::make_pair(GNE_TAG_RIDE_EDGE_EDGE, GUIIcon::RIDE_EDGE);
390  } else if (!planParameters.fromEdge.empty()) {
391  if (!planParameters.toEdge.empty()) {
392  return std::make_pair(GNE_TAG_RIDE_EDGE_EDGE, GUIIcon::RIDE_EDGE);
393  } else if (!planParameters.toTAZ.empty()) {
394  return std::make_pair(GNE_TAG_RIDE_EDGE_TAZ, GUIIcon::RIDE_TAZ);
395  } else if (!planParameters.toJunction.empty()) {
396  return std::make_pair(GNE_TAG_RIDE_EDGE_JUNCTION, GUIIcon::RIDE_JUNCTION);
397  } else if (!planParameters.toBusStop.empty()) {
398  return std::make_pair(GNE_TAG_RIDE_EDGE_BUSSTOP, GUIIcon::RIDE_BUSSTOP);
399  } else if (!planParameters.toTrainStop.empty()) {
400  return std::make_pair(GNE_TAG_RIDE_EDGE_TRAINSTOP, GUIIcon::RIDE_TRAINSTOP);
401  } else if (!planParameters.toContainerStop.empty()) {
402  return std::make_pair(GNE_TAG_RIDE_EDGE_CONTAINERSTOP, GUIIcon::RIDE_CONTAINERSTOP);
403  } else if (!planParameters.toChargingStation.empty()) {
404  return std::make_pair(GNE_TAG_RIDE_EDGE_CHARGINGSTATION, GUIIcon::RIDE_CHARGINGSTATION);
405  } else if (!planParameters.toParkingArea.empty()) {
406  return std::make_pair(GNE_TAG_RIDE_EDGE_PARKINGAREA, GUIIcon::RIDE_PARKINGAREA);
407  } else {
408  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
409  }
410  } else if (!planParameters.fromTAZ.empty()) {
411  if (!planParameters.toEdge.empty()) {
412  return std::make_pair(GNE_TAG_RIDE_TAZ_EDGE, GUIIcon::RIDE_EDGE);
413  } else if (!planParameters.toTAZ.empty()) {
414  return std::make_pair(GNE_TAG_RIDE_TAZ_TAZ, GUIIcon::RIDE_TAZ);
415  } else if (!planParameters.toJunction.empty()) {
416  return std::make_pair(GNE_TAG_RIDE_TAZ_JUNCTION, GUIIcon::RIDE_JUNCTION);
417  } else if (!planParameters.toBusStop.empty()) {
418  return std::make_pair(GNE_TAG_RIDE_TAZ_BUSSTOP, GUIIcon::RIDE_BUSSTOP);
419  } else if (!planParameters.toTrainStop.empty()) {
420  return std::make_pair(GNE_TAG_RIDE_TAZ_TRAINSTOP, GUIIcon::RIDE_TRAINSTOP);
421  } else if (!planParameters.toContainerStop.empty()) {
422  return std::make_pair(GNE_TAG_RIDE_TAZ_CONTAINERSTOP, GUIIcon::RIDE_CONTAINERSTOP);
423  } else if (!planParameters.toChargingStation.empty()) {
424  return std::make_pair(GNE_TAG_RIDE_TAZ_CHARGINGSTATION, GUIIcon::RIDE_CHARGINGSTATION);
425  } else if (!planParameters.toParkingArea.empty()) {
426  return std::make_pair(GNE_TAG_RIDE_TAZ_PARKINGAREA, GUIIcon::RIDE_PARKINGAREA);
427  } else {
428  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
429  }
430  } else if (!planParameters.fromJunction.empty()) {
431  if (!planParameters.toEdge.empty()) {
432  return std::make_pair(GNE_TAG_RIDE_JUNCTION_EDGE, GUIIcon::RIDE_EDGE);
433  } else if (!planParameters.toTAZ.empty()) {
434  return std::make_pair(GNE_TAG_RIDE_JUNCTION_TAZ, GUIIcon::RIDE_TAZ);
435  } else if (!planParameters.toJunction.empty()) {
436  return std::make_pair(GNE_TAG_RIDE_JUNCTION_JUNCTION, GUIIcon::RIDE_JUNCTION);
437  } else if (!planParameters.toBusStop.empty()) {
438  return std::make_pair(GNE_TAG_RIDE_JUNCTION_BUSSTOP, GUIIcon::RIDE_BUSSTOP);
439  } else if (!planParameters.toTrainStop.empty()) {
440  return std::make_pair(GNE_TAG_RIDE_JUNCTION_TRAINSTOP, GUIIcon::RIDE_TRAINSTOP);
441  } else if (!planParameters.toContainerStop.empty()) {
442  return std::make_pair(GNE_TAG_RIDE_JUNCTION_CONTAINERSTOP, GUIIcon::RIDE_CONTAINERSTOP);
443  } else if (!planParameters.toChargingStation.empty()) {
444  return std::make_pair(GNE_TAG_RIDE_JUNCTION_CHARGINGSTATION, GUIIcon::RIDE_CHARGINGSTATION);
445  } else if (!planParameters.toParkingArea.empty()) {
446  return std::make_pair(GNE_TAG_RIDE_JUNCTION_PARKINGAREA, GUIIcon::RIDE_PARKINGAREA);
447  } else {
448  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
449  }
450  } else if (!planParameters.fromBusStop.empty()) {
451  if (!planParameters.toEdge.empty()) {
452  return std::make_pair(GNE_TAG_RIDE_BUSSTOP_EDGE, GUIIcon::RIDE_EDGE);
453  } else if (!planParameters.toTAZ.empty()) {
454  return std::make_pair(GNE_TAG_RIDE_BUSSTOP_TAZ, GUIIcon::RIDE_TAZ);
455  } else if (!planParameters.toJunction.empty()) {
456  return std::make_pair(GNE_TAG_RIDE_BUSSTOP_JUNCTION, GUIIcon::RIDE_JUNCTION);
457  } else if (!planParameters.toBusStop.empty()) {
458  return std::make_pair(GNE_TAG_RIDE_BUSSTOP_BUSSTOP, GUIIcon::RIDE_BUSSTOP);
459  } else if (!planParameters.toTrainStop.empty()) {
460  return std::make_pair(GNE_TAG_RIDE_BUSSTOP_TRAINSTOP, GUIIcon::RIDE_TRAINSTOP);
461  } else if (!planParameters.toContainerStop.empty()) {
462  return std::make_pair(GNE_TAG_RIDE_BUSSTOP_CONTAINERSTOP, GUIIcon::RIDE_CONTAINERSTOP);
463  } else if (!planParameters.toChargingStation.empty()) {
464  return std::make_pair(GNE_TAG_RIDE_BUSSTOP_CHARGINGSTATION, GUIIcon::RIDE_CHARGINGSTATION);
465  } else if (!planParameters.toParkingArea.empty()) {
466  return std::make_pair(GNE_TAG_RIDE_BUSSTOP_PARKINGAREA, GUIIcon::RIDE_PARKINGAREA);
467  } else {
468  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
469  }
470  } else if (!planParameters.fromTrainStop.empty()) {
471  if (!planParameters.toEdge.empty()) {
472  return std::make_pair(GNE_TAG_RIDE_TRAINSTOP_EDGE, GUIIcon::RIDE_EDGE);
473  } else if (!planParameters.toTAZ.empty()) {
474  return std::make_pair(GNE_TAG_RIDE_TRAINSTOP_TAZ, GUIIcon::RIDE_TAZ);
475  } else if (!planParameters.toJunction.empty()) {
476  return std::make_pair(GNE_TAG_RIDE_TRAINSTOP_JUNCTION, GUIIcon::RIDE_JUNCTION);
477  } else if (!planParameters.toBusStop.empty()) {
478  return std::make_pair(GNE_TAG_RIDE_TRAINSTOP_BUSSTOP, GUIIcon::RIDE_BUSSTOP);
479  } else if (!planParameters.toTrainStop.empty()) {
480  return std::make_pair(GNE_TAG_RIDE_TRAINSTOP_TRAINSTOP, GUIIcon::RIDE_TRAINSTOP);
481  } else if (!planParameters.toContainerStop.empty()) {
482  return std::make_pair(GNE_TAG_RIDE_TRAINSTOP_CONTAINERSTOP, GUIIcon::RIDE_CONTAINERSTOP);
483  } else if (!planParameters.toChargingStation.empty()) {
484  return std::make_pair(GNE_TAG_RIDE_TRAINSTOP_CHARGINGSTATION, GUIIcon::RIDE_CHARGINGSTATION);
485  } else if (!planParameters.toParkingArea.empty()) {
486  return std::make_pair(GNE_TAG_RIDE_TRAINSTOP_PARKINGAREA, GUIIcon::RIDE_PARKINGAREA);
487  } else {
488  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
489  }
490  } else if (!planParameters.fromContainerStop.empty()) {
491  if (!planParameters.toEdge.empty()) {
492  return std::make_pair(GNE_TAG_RIDE_CONTAINERSTOP_EDGE, GUIIcon::RIDE_EDGE);
493  } else if (!planParameters.toTAZ.empty()) {
494  return std::make_pair(GNE_TAG_RIDE_CONTAINERSTOP_TAZ, GUIIcon::RIDE_TAZ);
495  } else if (!planParameters.toJunction.empty()) {
496  return std::make_pair(GNE_TAG_RIDE_CONTAINERSTOP_JUNCTION, GUIIcon::RIDE_JUNCTION);
497  } else if (!planParameters.toBusStop.empty()) {
498  return std::make_pair(GNE_TAG_RIDE_CONTAINERSTOP_BUSSTOP, GUIIcon::RIDE_BUSSTOP);
499  } else if (!planParameters.toTrainStop.empty()) {
500  return std::make_pair(GNE_TAG_RIDE_CONTAINERSTOP_TRAINSTOP, GUIIcon::RIDE_TRAINSTOP);
501  } else if (!planParameters.toContainerStop.empty()) {
502  return std::make_pair(GNE_TAG_RIDE_CONTAINERSTOP_CONTAINERSTOP, GUIIcon::RIDE_CONTAINERSTOP);
503  } else if (!planParameters.toChargingStation.empty()) {
504  return std::make_pair(GNE_TAG_RIDE_CONTAINERSTOP_CHARGINGSTATION, GUIIcon::RIDE_CHARGINGSTATION);
505  } else if (!planParameters.toParkingArea.empty()) {
506  return std::make_pair(GNE_TAG_RIDE_CONTAINERSTOP_PARKINGAREA, GUIIcon::RIDE_PARKINGAREA);
507  } else {
508  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
509  }
510  } else if (!planParameters.fromChargingStation.empty()) {
511  if (!planParameters.toEdge.empty()) {
512  return std::make_pair(GNE_TAG_RIDE_CHARGINGSTATION_EDGE, GUIIcon::RIDE_EDGE);
513  } else if (!planParameters.toTAZ.empty()) {
514  return std::make_pair(GNE_TAG_RIDE_CHARGINGSTATION_TAZ, GUIIcon::RIDE_TAZ);
515  } else if (!planParameters.toJunction.empty()) {
516  return std::make_pair(GNE_TAG_RIDE_CHARGINGSTATION_JUNCTION, GUIIcon::RIDE_JUNCTION);
517  } else if (!planParameters.toBusStop.empty()) {
518  return std::make_pair(GNE_TAG_RIDE_CHARGINGSTATION_BUSSTOP, GUIIcon::RIDE_BUSSTOP);
519  } else if (!planParameters.toTrainStop.empty()) {
520  return std::make_pair(GNE_TAG_RIDE_CHARGINGSTATION_TRAINSTOP, GUIIcon::RIDE_TRAINSTOP);
521  } else if (!planParameters.toContainerStop.empty()) {
522  return std::make_pair(GNE_TAG_RIDE_CHARGINGSTATION_CONTAINERSTOP, GUIIcon::RIDE_CONTAINERSTOP);
523  } else if (!planParameters.toChargingStation.empty()) {
524  return std::make_pair(GNE_TAG_RIDE_CHARGINGSTATION_CHARGINGSTATION, GUIIcon::RIDE_CHARGINGSTATION);
525  } else if (!planParameters.toParkingArea.empty()) {
526  return std::make_pair(GNE_TAG_RIDE_CHARGINGSTATION_PARKINGAREA, GUIIcon::RIDE_PARKINGAREA);
527  } else {
528  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
529  }
530  } else if (!planParameters.fromParkingArea.empty()) {
531  if (!planParameters.toEdge.empty()) {
532  return std::make_pair(GNE_TAG_RIDE_PARKINGAREA_EDGE, GUIIcon::RIDE_EDGE);
533  } else if (!planParameters.toTAZ.empty()) {
534  return std::make_pair(GNE_TAG_RIDE_PARKINGAREA_TAZ, GUIIcon::RIDE_TAZ);
535  } else if (!planParameters.toJunction.empty()) {
536  return std::make_pair(GNE_TAG_RIDE_PARKINGAREA_JUNCTION, GUIIcon::RIDE_JUNCTION);
537  } else if (!planParameters.toBusStop.empty()) {
538  return std::make_pair(GNE_TAG_RIDE_PARKINGAREA_BUSSTOP, GUIIcon::RIDE_BUSSTOP);
539  } else if (!planParameters.toTrainStop.empty()) {
540  return std::make_pair(GNE_TAG_RIDE_PARKINGAREA_TRAINSTOP, GUIIcon::RIDE_TRAINSTOP);
541  } else if (!planParameters.toContainerStop.empty()) {
542  return std::make_pair(GNE_TAG_RIDE_PARKINGAREA_CONTAINERSTOP, GUIIcon::RIDE_CONTAINERSTOP);
543  } else if (!planParameters.toChargingStation.empty()) {
544  return std::make_pair(GNE_TAG_RIDE_PARKINGAREA_CHARGINGSTATION, GUIIcon::RIDE_CHARGINGSTATION);
545  } else if (!planParameters.toParkingArea.empty()) {
546  return std::make_pair(GNE_TAG_RIDE_PARKINGAREA_PARKINGAREA, GUIIcon::RIDE_PARKINGAREA);
547  } else {
548  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
549  }
550  } else {
551  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
552  }
553 }
554 
555 
556 std::pair<SumoXMLTag, GUIIcon>
557 GNEDemandElementPlan::getTransportTagIcon(const CommonXMLStructure::PlanParameters& planParameters) {
558  if (planParameters.isSingleEdgePlan()) {
559  return std::make_pair(GNE_TAG_TRANSPORT_EDGE_EDGE, GUIIcon::TRANSPORT_EDGE);
560  } else if (!planParameters.fromEdge.empty()) {
561  if (!planParameters.toEdge.empty()) {
562  return std::make_pair(GNE_TAG_TRANSPORT_EDGE_EDGE, GUIIcon::TRANSPORT_EDGE);
563  } else if (!planParameters.toTAZ.empty()) {
564  return std::make_pair(GNE_TAG_TRANSPORT_EDGE_TAZ, GUIIcon::TRANSPORT_TAZ);
565  } else if (!planParameters.toJunction.empty()) {
566  return std::make_pair(GNE_TAG_TRANSPORT_EDGE_JUNCTION, GUIIcon::TRANSPORT_JUNCTION);
567  } else if (!planParameters.toBusStop.empty()) {
568  return std::make_pair(GNE_TAG_TRANSPORT_EDGE_BUSSTOP, GUIIcon::TRANSPORT_BUSSTOP);
569  } else if (!planParameters.toTrainStop.empty()) {
570  return std::make_pair(GNE_TAG_TRANSPORT_EDGE_TRAINSTOP, GUIIcon::TRANSPORT_TRAINSTOP);
571  } else if (!planParameters.toContainerStop.empty()) {
572  return std::make_pair(GNE_TAG_TRANSPORT_EDGE_CONTAINERSTOP, GUIIcon::TRANSPORT_CONTAINERSTOP);
573  } else if (!planParameters.toChargingStation.empty()) {
574  return std::make_pair(GNE_TAG_TRANSPORT_EDGE_CHARGINGSTATION, GUIIcon::TRANSPORT_CHARGINGSTATION);
575  } else if (!planParameters.toParkingArea.empty()) {
576  return std::make_pair(GNE_TAG_TRANSPORT_EDGE_PARKINGAREA, GUIIcon::TRANSPORT_PARKINGAREA);
577  } else {
578  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
579  }
580  } else if (!planParameters.fromTAZ.empty()) {
581  if (!planParameters.toEdge.empty()) {
582  return std::make_pair(GNE_TAG_TRANSPORT_TAZ_EDGE, GUIIcon::TRANSPORT_EDGE);
583  } else if (!planParameters.toTAZ.empty()) {
584  return std::make_pair(GNE_TAG_TRANSPORT_TAZ_TAZ, GUIIcon::TRANSPORT_TAZ);
585  } else if (!planParameters.toJunction.empty()) {
586  return std::make_pair(GNE_TAG_TRANSPORT_TAZ_JUNCTION, GUIIcon::TRANSPORT_JUNCTION);
587  } else if (!planParameters.toBusStop.empty()) {
588  return std::make_pair(GNE_TAG_TRANSPORT_TAZ_BUSSTOP, GUIIcon::TRANSPORT_BUSSTOP);
589  } else if (!planParameters.toTrainStop.empty()) {
590  return std::make_pair(GNE_TAG_TRANSPORT_TAZ_TRAINSTOP, GUIIcon::TRANSPORT_TRAINSTOP);
591  } else if (!planParameters.toContainerStop.empty()) {
592  return std::make_pair(GNE_TAG_TRANSPORT_TAZ_CONTAINERSTOP, GUIIcon::TRANSPORT_CONTAINERSTOP);
593  } else if (!planParameters.toChargingStation.empty()) {
594  return std::make_pair(GNE_TAG_TRANSPORT_TAZ_CHARGINGSTATION, GUIIcon::TRANSPORT_CHARGINGSTATION);
595  } else if (!planParameters.toParkingArea.empty()) {
596  return std::make_pair(GNE_TAG_TRANSPORT_TAZ_PARKINGAREA, GUIIcon::TRANSPORT_PARKINGAREA);
597  } else {
598  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
599  }
600  } else if (!planParameters.fromJunction.empty()) {
601  if (!planParameters.toEdge.empty()) {
602  return std::make_pair(GNE_TAG_TRANSPORT_JUNCTION_EDGE, GUIIcon::TRANSPORT_EDGE);
603  } else if (!planParameters.toTAZ.empty()) {
604  return std::make_pair(GNE_TAG_TRANSPORT_JUNCTION_TAZ, GUIIcon::TRANSPORT_TAZ);
605  } else if (!planParameters.toJunction.empty()) {
606  return std::make_pair(GNE_TAG_TRANSPORT_JUNCTION_JUNCTION, GUIIcon::TRANSPORT_JUNCTION);
607  } else if (!planParameters.toBusStop.empty()) {
608  return std::make_pair(GNE_TAG_TRANSPORT_JUNCTION_BUSSTOP, GUIIcon::TRANSPORT_BUSSTOP);
609  } else if (!planParameters.toTrainStop.empty()) {
610  return std::make_pair(GNE_TAG_TRANSPORT_JUNCTION_TRAINSTOP, GUIIcon::TRANSPORT_TRAINSTOP);
611  } else if (!planParameters.toContainerStop.empty()) {
612  return std::make_pair(GNE_TAG_TRANSPORT_JUNCTION_CONTAINERSTOP, GUIIcon::TRANSPORT_CONTAINERSTOP);
613  } else if (!planParameters.toChargingStation.empty()) {
614  return std::make_pair(GNE_TAG_TRANSPORT_JUNCTION_CHARGINGSTATION, GUIIcon::TRANSPORT_CHARGINGSTATION);
615  } else if (!planParameters.toParkingArea.empty()) {
616  return std::make_pair(GNE_TAG_TRANSPORT_JUNCTION_PARKINGAREA, GUIIcon::TRANSPORT_PARKINGAREA);
617  } else {
618  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
619  }
620  } else if (!planParameters.fromBusStop.empty()) {
621  if (!planParameters.toEdge.empty()) {
622  return std::make_pair(GNE_TAG_TRANSPORT_BUSSTOP_EDGE, GUIIcon::TRANSPORT_EDGE);
623  } else if (!planParameters.toTAZ.empty()) {
624  return std::make_pair(GNE_TAG_TRANSPORT_BUSSTOP_TAZ, GUIIcon::TRANSPORT_TAZ);
625  } else if (!planParameters.toJunction.empty()) {
626  return std::make_pair(GNE_TAG_TRANSPORT_BUSSTOP_JUNCTION, GUIIcon::TRANSPORT_JUNCTION);
627  } else if (!planParameters.toBusStop.empty()) {
628  return std::make_pair(GNE_TAG_TRANSPORT_BUSSTOP_BUSSTOP, GUIIcon::TRANSPORT_BUSSTOP);
629  } else if (!planParameters.toTrainStop.empty()) {
630  return std::make_pair(GNE_TAG_TRANSPORT_BUSSTOP_TRAINSTOP, GUIIcon::TRANSPORT_TRAINSTOP);
631  } else if (!planParameters.toContainerStop.empty()) {
632  return std::make_pair(GNE_TAG_TRANSPORT_BUSSTOP_CONTAINERSTOP, GUIIcon::TRANSPORT_CONTAINERSTOP);
633  } else if (!planParameters.toChargingStation.empty()) {
634  return std::make_pair(GNE_TAG_TRANSPORT_BUSSTOP_CHARGINGSTATION, GUIIcon::TRANSPORT_CHARGINGSTATION);
635  } else if (!planParameters.toParkingArea.empty()) {
636  return std::make_pair(GNE_TAG_TRANSPORT_BUSSTOP_PARKINGAREA, GUIIcon::TRANSPORT_PARKINGAREA);
637  } else {
638  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
639  }
640  } else if (!planParameters.fromTrainStop.empty()) {
641  if (!planParameters.toEdge.empty()) {
642  return std::make_pair(GNE_TAG_TRANSPORT_TRAINSTOP_EDGE, GUIIcon::TRANSPORT_EDGE);
643  } else if (!planParameters.toTAZ.empty()) {
644  return std::make_pair(GNE_TAG_TRANSPORT_TRAINSTOP_TAZ, GUIIcon::TRANSPORT_TAZ);
645  } else if (!planParameters.toJunction.empty()) {
646  return std::make_pair(GNE_TAG_TRANSPORT_TRAINSTOP_JUNCTION, GUIIcon::TRANSPORT_JUNCTION);
647  } else if (!planParameters.toBusStop.empty()) {
648  return std::make_pair(GNE_TAG_TRANSPORT_TRAINSTOP_BUSSTOP, GUIIcon::TRANSPORT_BUSSTOP);
649  } else if (!planParameters.toTrainStop.empty()) {
650  return std::make_pair(GNE_TAG_TRANSPORT_TRAINSTOP_TRAINSTOP, GUIIcon::TRANSPORT_TRAINSTOP);
651  } else if (!planParameters.toContainerStop.empty()) {
652  return std::make_pair(GNE_TAG_TRANSPORT_TRAINSTOP_CONTAINERSTOP, GUIIcon::TRANSPORT_CONTAINERSTOP);
653  } else if (!planParameters.toChargingStation.empty()) {
654  return std::make_pair(GNE_TAG_TRANSPORT_TRAINSTOP_CHARGINGSTATION, GUIIcon::TRANSPORT_CHARGINGSTATION);
655  } else if (!planParameters.toParkingArea.empty()) {
656  return std::make_pair(GNE_TAG_TRANSPORT_TRAINSTOP_PARKINGAREA, GUIIcon::TRANSPORT_PARKINGAREA);
657  } else {
658  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
659  }
660  } else if (!planParameters.fromContainerStop.empty()) {
661  if (!planParameters.toEdge.empty()) {
662  return std::make_pair(GNE_TAG_TRANSPORT_CONTAINERSTOP_EDGE, GUIIcon::TRANSPORT_EDGE);
663  } else if (!planParameters.toTAZ.empty()) {
664  return std::make_pair(GNE_TAG_TRANSPORT_CONTAINERSTOP_TAZ, GUIIcon::TRANSPORT_TAZ);
665  } else if (!planParameters.toJunction.empty()) {
666  return std::make_pair(GNE_TAG_TRANSPORT_CONTAINERSTOP_JUNCTION, GUIIcon::TRANSPORT_JUNCTION);
667  } else if (!planParameters.toBusStop.empty()) {
668  return std::make_pair(GNE_TAG_TRANSPORT_CONTAINERSTOP_BUSSTOP, GUIIcon::TRANSPORT_BUSSTOP);
669  } else if (!planParameters.toTrainStop.empty()) {
670  return std::make_pair(GNE_TAG_TRANSPORT_CONTAINERSTOP_TRAINSTOP, GUIIcon::TRANSPORT_TRAINSTOP);
671  } else if (!planParameters.toContainerStop.empty()) {
672  return std::make_pair(GNE_TAG_TRANSPORT_CONTAINERSTOP_CONTAINERSTOP, GUIIcon::TRANSPORT_CONTAINERSTOP);
673  } else if (!planParameters.toChargingStation.empty()) {
674  return std::make_pair(GNE_TAG_TRANSPORT_CONTAINERSTOP_CHARGINGSTATION, GUIIcon::TRANSPORT_CHARGINGSTATION);
675  } else if (!planParameters.toParkingArea.empty()) {
676  return std::make_pair(GNE_TAG_TRANSPORT_CONTAINERSTOP_PARKINGAREA, GUIIcon::TRANSPORT_PARKINGAREA);
677  } else {
678  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
679  }
680  } else if (!planParameters.fromChargingStation.empty()) {
681  if (!planParameters.toEdge.empty()) {
682  return std::make_pair(GNE_TAG_TRANSPORT_CHARGINGSTATION_EDGE, GUIIcon::TRANSPORT_EDGE);
683  } else if (!planParameters.toTAZ.empty()) {
684  return std::make_pair(GNE_TAG_TRANSPORT_CHARGINGSTATION_TAZ, GUIIcon::TRANSPORT_TAZ);
685  } else if (!planParameters.toJunction.empty()) {
686  return std::make_pair(GNE_TAG_TRANSPORT_CHARGINGSTATION_JUNCTION, GUIIcon::TRANSPORT_JUNCTION);
687  } else if (!planParameters.toBusStop.empty()) {
688  return std::make_pair(GNE_TAG_TRANSPORT_CHARGINGSTATION_BUSSTOP, GUIIcon::TRANSPORT_BUSSTOP);
689  } else if (!planParameters.toTrainStop.empty()) {
690  return std::make_pair(GNE_TAG_TRANSPORT_CHARGINGSTATION_TRAINSTOP, GUIIcon::TRANSPORT_TRAINSTOP);
691  } else if (!planParameters.toContainerStop.empty()) {
692  return std::make_pair(GNE_TAG_TRANSPORT_CHARGINGSTATION_CONTAINERSTOP, GUIIcon::TRANSPORT_CONTAINERSTOP);
693  } else if (!planParameters.toChargingStation.empty()) {
694  return std::make_pair(GNE_TAG_TRANSPORT_CHARGINGSTATION_CHARGINGSTATION, GUIIcon::TRANSPORT_CHARGINGSTATION);
695  } else if (!planParameters.toParkingArea.empty()) {
696  return std::make_pair(GNE_TAG_TRANSPORT_CHARGINGSTATION_PARKINGAREA, GUIIcon::TRANSPORT_PARKINGAREA);
697  } else {
698  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
699  }
700  } else if (!planParameters.fromParkingArea.empty()) {
701  if (!planParameters.toEdge.empty()) {
702  return std::make_pair(GNE_TAG_TRANSPORT_PARKINGAREA_EDGE, GUIIcon::TRANSPORT_EDGE);
703  } else if (!planParameters.toTAZ.empty()) {
704  return std::make_pair(GNE_TAG_TRANSPORT_PARKINGAREA_TAZ, GUIIcon::TRANSPORT_TAZ);
705  } else if (!planParameters.toJunction.empty()) {
706  return std::make_pair(GNE_TAG_TRANSPORT_PARKINGAREA_JUNCTION, GUIIcon::TRANSPORT_JUNCTION);
707  } else if (!planParameters.toBusStop.empty()) {
708  return std::make_pair(GNE_TAG_TRANSPORT_PARKINGAREA_BUSSTOP, GUIIcon::TRANSPORT_BUSSTOP);
709  } else if (!planParameters.toTrainStop.empty()) {
710  return std::make_pair(GNE_TAG_TRANSPORT_PARKINGAREA_TRAINSTOP, GUIIcon::TRANSPORT_TRAINSTOP);
711  } else if (!planParameters.toContainerStop.empty()) {
712  return std::make_pair(GNE_TAG_TRANSPORT_PARKINGAREA_CONTAINERSTOP, GUIIcon::TRANSPORT_CONTAINERSTOP);
713  } else if (!planParameters.toChargingStation.empty()) {
714  return std::make_pair(GNE_TAG_TRANSPORT_PARKINGAREA_CHARGINGSTATION, GUIIcon::TRANSPORT_CHARGINGSTATION);
715  } else if (!planParameters.toParkingArea.empty()) {
716  return std::make_pair(GNE_TAG_TRANSPORT_PARKINGAREA_PARKINGAREA, GUIIcon::TRANSPORT_PARKINGAREA);
717  } else {
718  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
719  }
720  } else {
721  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
722  }
723 }
724 
725 
726 std::pair<SumoXMLTag, GUIIcon>
727 GNEDemandElementPlan::getTranshipTagIcon(const CommonXMLStructure::PlanParameters& planParameters) {
728  if (planParameters.isSingleEdgePlan()) {
729  return std::make_pair(GNE_TAG_TRANSHIP_EDGE_EDGE, GUIIcon::TRANSHIP_EDGE);
730  } else if (planParameters.consecutiveEdges.size() > 0) {
731  return std::make_pair(GNE_TAG_TRANSHIP_EDGES, GUIIcon::TRANSHIP_EDGES);
732  } else if (!planParameters.fromEdge.empty()) {
733  if (!planParameters.toEdge.empty()) {
734  return std::make_pair(GNE_TAG_TRANSHIP_EDGE_EDGE, GUIIcon::TRANSHIP_EDGE);
735  } else if (!planParameters.toTAZ.empty()) {
736  return std::make_pair(GNE_TAG_TRANSHIP_EDGE_TAZ, GUIIcon::TRANSHIP_TAZ);
737  } else if (!planParameters.toJunction.empty()) {
738  return std::make_pair(GNE_TAG_TRANSHIP_EDGE_JUNCTION, GUIIcon::TRANSHIP_JUNCTION);
739  } else if (!planParameters.toBusStop.empty()) {
740  return std::make_pair(GNE_TAG_TRANSHIP_EDGE_BUSSTOP, GUIIcon::TRANSHIP_BUSSTOP);
741  } else if (!planParameters.toTrainStop.empty()) {
742  return std::make_pair(GNE_TAG_TRANSHIP_EDGE_TRAINSTOP, GUIIcon::TRANSHIP_TRAINSTOP);
743  } else if (!planParameters.toContainerStop.empty()) {
744  return std::make_pair(GNE_TAG_TRANSHIP_EDGE_CONTAINERSTOP, GUIIcon::TRANSHIP_CONTAINERSTOP);
745  } else if (!planParameters.toChargingStation.empty()) {
746  return std::make_pair(GNE_TAG_TRANSHIP_EDGE_CHARGINGSTATION, GUIIcon::TRANSHIP_CHARGINGSTATION);
747  } else if (!planParameters.toParkingArea.empty()) {
748  return std::make_pair(GNE_TAG_TRANSHIP_EDGE_PARKINGAREA, GUIIcon::TRANSHIP_PARKINGAREA);
749  } else {
750  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
751  }
752  } else if (!planParameters.fromTAZ.empty()) {
753  if (!planParameters.toEdge.empty()) {
754  return std::make_pair(GNE_TAG_TRANSHIP_TAZ_EDGE, GUIIcon::TRANSHIP_EDGE);
755  } else if (!planParameters.toTAZ.empty()) {
756  return std::make_pair(GNE_TAG_TRANSHIP_TAZ_TAZ, GUIIcon::TRANSHIP_TAZ);
757  } else if (!planParameters.toJunction.empty()) {
758  return std::make_pair(GNE_TAG_TRANSHIP_TAZ_JUNCTION, GUIIcon::TRANSHIP_JUNCTION);
759  } else if (!planParameters.toBusStop.empty()) {
760  return std::make_pair(GNE_TAG_TRANSHIP_TAZ_BUSSTOP, GUIIcon::TRANSHIP_BUSSTOP);
761  } else if (!planParameters.toTrainStop.empty()) {
762  return std::make_pair(GNE_TAG_TRANSHIP_TAZ_TRAINSTOP, GUIIcon::TRANSHIP_TRAINSTOP);
763  } else if (!planParameters.toContainerStop.empty()) {
764  return std::make_pair(GNE_TAG_TRANSHIP_TAZ_CONTAINERSTOP, GUIIcon::TRANSHIP_CONTAINERSTOP);
765  } else if (!planParameters.toChargingStation.empty()) {
766  return std::make_pair(GNE_TAG_TRANSHIP_TAZ_CHARGINGSTATION, GUIIcon::TRANSHIP_CHARGINGSTATION);
767  } else if (!planParameters.toParkingArea.empty()) {
768  return std::make_pair(GNE_TAG_TRANSHIP_TAZ_PARKINGAREA, GUIIcon::TRANSHIP_PARKINGAREA);
769  } else {
770  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
771  }
772  } else if (!planParameters.fromJunction.empty()) {
773  if (!planParameters.toEdge.empty()) {
774  return std::make_pair(GNE_TAG_TRANSHIP_JUNCTION_EDGE, GUIIcon::TRANSHIP_EDGE);
775  } else if (!planParameters.toTAZ.empty()) {
776  return std::make_pair(GNE_TAG_TRANSHIP_JUNCTION_TAZ, GUIIcon::TRANSHIP_TAZ);
777  } else if (!planParameters.toJunction.empty()) {
778  return std::make_pair(GNE_TAG_TRANSHIP_JUNCTION_JUNCTION, GUIIcon::TRANSHIP_JUNCTION);
779  } else if (!planParameters.toBusStop.empty()) {
780  return std::make_pair(GNE_TAG_TRANSHIP_JUNCTION_BUSSTOP, GUIIcon::TRANSHIP_BUSSTOP);
781  } else if (!planParameters.toTrainStop.empty()) {
782  return std::make_pair(GNE_TAG_TRANSHIP_JUNCTION_TRAINSTOP, GUIIcon::TRANSHIP_TRAINSTOP);
783  } else if (!planParameters.toContainerStop.empty()) {
784  return std::make_pair(GNE_TAG_TRANSHIP_JUNCTION_CONTAINERSTOP, GUIIcon::TRANSHIP_CONTAINERSTOP);
785  } else if (!planParameters.toChargingStation.empty()) {
786  return std::make_pair(GNE_TAG_TRANSHIP_JUNCTION_CHARGINGSTATION, GUIIcon::TRANSHIP_CHARGINGSTATION);
787  } else if (!planParameters.toParkingArea.empty()) {
788  return std::make_pair(GNE_TAG_TRANSHIP_JUNCTION_PARKINGAREA, GUIIcon::TRANSHIP_PARKINGAREA);
789  } else {
790  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
791  }
792  } else if (!planParameters.fromBusStop.empty()) {
793  if (!planParameters.toEdge.empty()) {
794  return std::make_pair(GNE_TAG_TRANSHIP_BUSSTOP_EDGE, GUIIcon::TRANSHIP_EDGE);
795  } else if (!planParameters.toTAZ.empty()) {
796  return std::make_pair(GNE_TAG_TRANSHIP_BUSSTOP_TAZ, GUIIcon::TRANSHIP_TAZ);
797  } else if (!planParameters.toJunction.empty()) {
798  return std::make_pair(GNE_TAG_TRANSHIP_BUSSTOP_JUNCTION, GUIIcon::TRANSHIP_JUNCTION);
799  } else if (!planParameters.toBusStop.empty()) {
800  return std::make_pair(GNE_TAG_TRANSHIP_BUSSTOP_BUSSTOP, GUIIcon::TRANSHIP_BUSSTOP);
801  } else if (!planParameters.toTrainStop.empty()) {
802  return std::make_pair(GNE_TAG_TRANSHIP_BUSSTOP_TRAINSTOP, GUIIcon::TRANSHIP_TRAINSTOP);
803  } else if (!planParameters.toContainerStop.empty()) {
804  return std::make_pair(GNE_TAG_TRANSHIP_BUSSTOP_CONTAINERSTOP, GUIIcon::TRANSHIP_CONTAINERSTOP);
805  } else if (!planParameters.toChargingStation.empty()) {
806  return std::make_pair(GNE_TAG_TRANSHIP_BUSSTOP_CHARGINGSTATION, GUIIcon::TRANSHIP_CHARGINGSTATION);
807  } else if (!planParameters.toParkingArea.empty()) {
808  return std::make_pair(GNE_TAG_TRANSHIP_BUSSTOP_PARKINGAREA, GUIIcon::TRANSHIP_PARKINGAREA);
809  } else {
810  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
811  }
812  } else if (!planParameters.fromTrainStop.empty()) {
813  if (!planParameters.toEdge.empty()) {
814  return std::make_pair(GNE_TAG_TRANSHIP_TRAINSTOP_EDGE, GUIIcon::TRANSHIP_EDGE);
815  } else if (!planParameters.toTAZ.empty()) {
816  return std::make_pair(GNE_TAG_TRANSHIP_TRAINSTOP_TAZ, GUIIcon::TRANSHIP_TAZ);
817  } else if (!planParameters.toJunction.empty()) {
818  return std::make_pair(GNE_TAG_TRANSHIP_TRAINSTOP_JUNCTION, GUIIcon::TRANSHIP_JUNCTION);
819  } else if (!planParameters.toBusStop.empty()) {
820  return std::make_pair(GNE_TAG_TRANSHIP_TRAINSTOP_BUSSTOP, GUIIcon::TRANSHIP_BUSSTOP);
821  } else if (!planParameters.toTrainStop.empty()) {
822  return std::make_pair(GNE_TAG_TRANSHIP_TRAINSTOP_TRAINSTOP, GUIIcon::TRANSHIP_TRAINSTOP);
823  } else if (!planParameters.toContainerStop.empty()) {
824  return std::make_pair(GNE_TAG_TRANSHIP_TRAINSTOP_CONTAINERSTOP, GUIIcon::TRANSHIP_CONTAINERSTOP);
825  } else if (!planParameters.toChargingStation.empty()) {
826  return std::make_pair(GNE_TAG_TRANSHIP_TRAINSTOP_CHARGINGSTATION, GUIIcon::TRANSHIP_CHARGINGSTATION);
827  } else if (!planParameters.toParkingArea.empty()) {
828  return std::make_pair(GNE_TAG_TRANSHIP_TRAINSTOP_PARKINGAREA, GUIIcon::TRANSHIP_PARKINGAREA);
829  } else {
830  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
831  }
832  } else if (!planParameters.fromContainerStop.empty()) {
833  if (!planParameters.toEdge.empty()) {
834  return std::make_pair(GNE_TAG_TRANSHIP_CONTAINERSTOP_EDGE, GUIIcon::TRANSHIP_EDGE);
835  } else if (!planParameters.toTAZ.empty()) {
836  return std::make_pair(GNE_TAG_TRANSHIP_CONTAINERSTOP_TAZ, GUIIcon::TRANSHIP_TAZ);
837  } else if (!planParameters.toJunction.empty()) {
838  return std::make_pair(GNE_TAG_TRANSHIP_CONTAINERSTOP_JUNCTION, GUIIcon::TRANSHIP_JUNCTION);
839  } else if (!planParameters.toBusStop.empty()) {
840  return std::make_pair(GNE_TAG_TRANSHIP_CONTAINERSTOP_BUSSTOP, GUIIcon::TRANSHIP_BUSSTOP);
841  } else if (!planParameters.toTrainStop.empty()) {
842  return std::make_pair(GNE_TAG_TRANSHIP_CONTAINERSTOP_TRAINSTOP, GUIIcon::TRANSHIP_TRAINSTOP);
843  } else if (!planParameters.toContainerStop.empty()) {
844  return std::make_pair(GNE_TAG_TRANSHIP_CONTAINERSTOP_CONTAINERSTOP, GUIIcon::TRANSHIP_CONTAINERSTOP);
845  } else if (!planParameters.toChargingStation.empty()) {
846  return std::make_pair(GNE_TAG_TRANSHIP_CONTAINERSTOP_CHARGINGSTATION, GUIIcon::TRANSHIP_CHARGINGSTATION);
847  } else if (!planParameters.toParkingArea.empty()) {
848  return std::make_pair(GNE_TAG_TRANSHIP_CONTAINERSTOP_PARKINGAREA, GUIIcon::TRANSHIP_PARKINGAREA);
849  } else {
850  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
851  }
852  } else if (!planParameters.fromChargingStation.empty()) {
853  if (!planParameters.toEdge.empty()) {
854  return std::make_pair(GNE_TAG_TRANSHIP_CHARGINGSTATION_EDGE, GUIIcon::TRANSHIP_EDGE);
855  } else if (!planParameters.toTAZ.empty()) {
856  return std::make_pair(GNE_TAG_TRANSHIP_CHARGINGSTATION_TAZ, GUIIcon::TRANSHIP_TAZ);
857  } else if (!planParameters.toJunction.empty()) {
858  return std::make_pair(GNE_TAG_TRANSHIP_CHARGINGSTATION_JUNCTION, GUIIcon::TRANSHIP_JUNCTION);
859  } else if (!planParameters.toBusStop.empty()) {
860  return std::make_pair(GNE_TAG_TRANSHIP_CHARGINGSTATION_BUSSTOP, GUIIcon::TRANSHIP_BUSSTOP);
861  } else if (!planParameters.toTrainStop.empty()) {
862  return std::make_pair(GNE_TAG_TRANSHIP_CHARGINGSTATION_TRAINSTOP, GUIIcon::TRANSHIP_TRAINSTOP);
863  } else if (!planParameters.toContainerStop.empty()) {
864  return std::make_pair(GNE_TAG_TRANSHIP_CHARGINGSTATION_CONTAINERSTOP, GUIIcon::TRANSHIP_CONTAINERSTOP);
865  } else if (!planParameters.toChargingStation.empty()) {
866  return std::make_pair(GNE_TAG_TRANSHIP_CHARGINGSTATION_CHARGINGSTATION, GUIIcon::TRANSHIP_CHARGINGSTATION);
867  } else if (!planParameters.toParkingArea.empty()) {
868  return std::make_pair(GNE_TAG_TRANSHIP_CHARGINGSTATION_PARKINGAREA, GUIIcon::TRANSHIP_PARKINGAREA);
869  } else {
870  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
871  }
872  } else if (!planParameters.fromParkingArea.empty()) {
873  if (!planParameters.toEdge.empty()) {
874  return std::make_pair(GNE_TAG_TRANSHIP_PARKINGAREA_EDGE, GUIIcon::TRANSHIP_EDGE);
875  } else if (!planParameters.toTAZ.empty()) {
876  return std::make_pair(GNE_TAG_TRANSHIP_PARKINGAREA_TAZ, GUIIcon::TRANSHIP_TAZ);
877  } else if (!planParameters.toJunction.empty()) {
878  return std::make_pair(GNE_TAG_TRANSHIP_PARKINGAREA_JUNCTION, GUIIcon::TRANSHIP_JUNCTION);
879  } else if (!planParameters.toBusStop.empty()) {
880  return std::make_pair(GNE_TAG_TRANSHIP_PARKINGAREA_BUSSTOP, GUIIcon::TRANSHIP_BUSSTOP);
881  } else if (!planParameters.toTrainStop.empty()) {
882  return std::make_pair(GNE_TAG_TRANSHIP_PARKINGAREA_TRAINSTOP, GUIIcon::TRANSHIP_TRAINSTOP);
883  } else if (!planParameters.toContainerStop.empty()) {
884  return std::make_pair(GNE_TAG_TRANSHIP_PARKINGAREA_CONTAINERSTOP, GUIIcon::TRANSHIP_CONTAINERSTOP);
885  } else if (!planParameters.toChargingStation.empty()) {
886  return std::make_pair(GNE_TAG_TRANSHIP_PARKINGAREA_CHARGINGSTATION, GUIIcon::TRANSHIP_CHARGINGSTATION);
887  } else if (!planParameters.toParkingArea.empty()) {
888  return std::make_pair(GNE_TAG_TRANSHIP_PARKINGAREA_PARKINGAREA, GUIIcon::TRANSHIP_PARKINGAREA);
889  } else {
890  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
891  }
892  } else {
893  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
894  }
895 }
896 
897 
898 std::pair<SumoXMLTag, GUIIcon>
899 GNEDemandElementPlan::getPersonStopTagIcon(const CommonXMLStructure::PlanParameters& planParameters) {
900  if (!planParameters.toEdge.empty()) {
901  return std::make_pair(GNE_TAG_STOPPERSON_EDGE, GUIIcon::STOPELEMENT);
902  } else if (!planParameters.toBusStop.empty()) {
903  return std::make_pair(GNE_TAG_STOPPERSON_BUSSTOP, GUIIcon::STOPELEMENT);
904  } else if (!planParameters.toTrainStop.empty()) {
905  return std::make_pair(GNE_TAG_STOPPERSON_TRAINSTOP, GUIIcon::STOPELEMENT);
906  } else if (!planParameters.toContainerStop.empty()) {
907  return std::make_pair(GNE_TAG_STOPPERSON_CONTAINERSTOP, GUIIcon::STOPELEMENT);
908  } else if (!planParameters.toChargingStation.empty()) {
909  return std::make_pair(GNE_TAG_STOPPERSON_CHARGINGSTATION, GUIIcon::STOPELEMENT);
910  } else if (!planParameters.toParkingArea.empty()) {
911  return std::make_pair(GNE_TAG_STOPPERSON_PARKINGAREA, GUIIcon::STOPELEMENT);
912  } else {
913  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
914  }
915 }
916 
917 
918 std::pair<SumoXMLTag, GUIIcon>
919 GNEDemandElementPlan::getContainerStopTagIcon(const CommonXMLStructure::PlanParameters& planParameters) {
920  if (!planParameters.toEdge.empty()) {
921  return std::make_pair(GNE_TAG_STOPCONTAINER_EDGE, GUIIcon::STOPELEMENT);
922  } else if (!planParameters.toBusStop.empty()) {
923  return std::make_pair(GNE_TAG_STOPCONTAINER_BUSSTOP, GUIIcon::STOPELEMENT);
924  } else if (!planParameters.toTrainStop.empty()) {
925  return std::make_pair(GNE_TAG_STOPCONTAINER_TRAINSTOP, GUIIcon::STOPELEMENT);
926  } else if (!planParameters.toContainerStop.empty()) {
927  return std::make_pair(GNE_TAG_STOPCONTAINER_CONTAINERSTOP, GUIIcon::STOPELEMENT);
928  } else if (!planParameters.toChargingStation.empty()) {
929  return std::make_pair(GNE_TAG_STOPCONTAINER_CHARGINGSTATION, GUIIcon::STOPELEMENT);
930  } else if (!planParameters.toParkingArea.empty()) {
931  return std::make_pair(GNE_TAG_STOPCONTAINER_PARKINGAREA, GUIIcon::STOPELEMENT);
932  } else {
933  return std::make_pair(SUMO_TAG_NOTHING, GUIIcon::EMPTY);
934  }
935 }
936 
937 
938 GNEDemandElementPlan::GNEDemandElementPlan(GNEDemandElement* planElement, const double departPosition, const double arrivalPosition) :
939  myDepartPosition(departPosition),
940  myArrivalPosition(arrivalPosition),
941  myPlanElement(planElement) {
942  // update centering boundary without updating grid
943  updatePlanCenteringBoundary(false);
944 }
945 
946 
947 GNEMoveOperation*
948 GNEDemandElementPlan::getPlanMoveOperation() {
949  // get tag property
950  const auto& tagProperty = myPlanElement->getTagProperty();
951  // only move personTrips defined over edges
952  if (tagProperty.planToEdge() || tagProperty.planConsecutiveEdges() || tagProperty.planEdge()) {
953  // get geometry end pos
954  const Position geometryEndPos = getPlanAttributePosition(GNE_ATTR_PLAN_GEOMETRY_ENDPOS);
955  // calculate circle width squared
956  const double circleWidthSquared = myArrivalPositionDiameter * myArrivalPositionDiameter;
957  // check if we clicked over a geometry end pos
958  if (myPlanElement->myNet->getViewNet()->getPositionInformation().distanceSquaredTo2D(geometryEndPos) <= ((circleWidthSquared + 2))) {
959  // continue depending of parent edges
960  if (myPlanElement->getParentEdges().size() > 0) {
961  return new GNEMoveOperation(myPlanElement, myPlanElement->getParentEdges().back()->getLaneByAllowedVClass(myPlanElement->getVClass()), myArrivalPosition, false);
962  } else {
963  return new GNEMoveOperation(myPlanElement, myPlanElement->getParentDemandElements().at(1)->getParentEdges().back()->getLaneByAllowedVClass(myPlanElement->getVClass()), myArrivalPosition, false);
964  }
965  }
966  }
967  return nullptr;
968 }
969 
970 
971 void
972 GNEDemandElementPlan::writeLocationAttributes(OutputDevice& device) const {
973  const auto& tagProperty = myPlanElement->getTagProperty();
974  // write attributes depending of parent elements
975  if (tagProperty.planConsecutiveEdges()) {
976  device.writeAttr(SUMO_ATTR_EDGES, myPlanElement->parseIDs(myPlanElement->getParentEdges()));
977  } else if (tagProperty.planRoute()) {
978  device.writeAttr(SUMO_ATTR_ROUTE, myPlanElement->getParentDemandElements().at(1)->getID());
979  } else if (tagProperty.planEdge()) {
980  device.writeAttr(SUMO_ATTR_EDGE, myPlanElement->getParentEdges().front()->getID());
981  } else if (tagProperty.planBusStop()) {
982  device.writeAttr(SUMO_ATTR_BUS_STOP, myPlanElement->getParentStoppingPlaces().front()->getID());
983  } else if (tagProperty.planTrainStop()) {
984  device.writeAttr(SUMO_ATTR_TRAIN_STOP, myPlanElement->getParentStoppingPlaces().front()->getID());
985  } else if (tagProperty.planContainerStop()) {
986  device.writeAttr(SUMO_ATTR_CONTAINER_STOP, myPlanElement->getParentStoppingPlaces().front()->getID());
987  } else if (tagProperty.planChargingStation()) {
988  device.writeAttr(SUMO_ATTR_CHARGING_STATION, myPlanElement->getParentStoppingPlaces().front()->getID());
989  } else if (tagProperty.planParkingArea()) {
990  device.writeAttr(SUMO_ATTR_PARKING_AREA, myPlanElement->getParentStoppingPlaces().front()->getID());
991  } else {
992  // write from attribute (if this is the first element)
993  if (myPlanElement->getParentDemandElements().at(0)->getPreviousChildDemandElement(myPlanElement) == nullptr) {
994  // check if write edge or junction
995  if (tagProperty.planFromEdge()) {
996  device.writeAttr(SUMO_ATTR_FROM, myPlanElement->getParentEdges().front()->getID());
997  } else if (tagProperty.planFromTAZ()) {
998  device.writeAttr(SUMO_ATTR_FROM_TAZ, myPlanElement->getParentTAZs().front()->getID());
999  } else if (tagProperty.planFromJunction()) {
1000  device.writeAttr(SUMO_ATTR_FROM_JUNCTION, myPlanElement->getParentJunctions().front()->getID());
1001  }
1002  // origin stopping places are transformed into an intial stop stage (see writeOriginStop)
1003  }
1004  // continue writting to attribute
1005  if (tagProperty.planToEdge()) {
1006  device.writeAttr(SUMO_ATTR_TO, myPlanElement->getParentEdges().back()->getID());
1007  } else if (tagProperty.planToJunction()) {
1008  device.writeAttr(SUMO_ATTR_TO_JUNCTION, myPlanElement->getParentJunctions().back()->getID());
1009  } else if (tagProperty.planToTAZ()) {
1010  device.writeAttr(SUMO_ATTR_TO_TAZ, myPlanElement->getParentTAZs().back()->getID());
1011  } else if (tagProperty.planToBusStop()) {
1012  device.writeAttr(SUMO_ATTR_BUS_STOP, myPlanElement->getParentStoppingPlaces().back()->getID());
1013  } else if (tagProperty.planToTrainStop()) {
1014  device.writeAttr(SUMO_ATTR_TRAIN_STOP, myPlanElement->getParentStoppingPlaces().back()->getID());
1015  } else if (tagProperty.planToContainerStop()) {
1016  device.writeAttr(SUMO_ATTR_CONTAINER_STOP, myPlanElement->getParentStoppingPlaces().back()->getID());
1017  } else if (tagProperty.planToChargingStation()) {
1018  device.writeAttr(SUMO_ATTR_CHARGING_STATION, myPlanElement->getParentStoppingPlaces().back()->getID());
1019  } else if (tagProperty.planToParkingArea()) {
1020  device.writeAttr(SUMO_ATTR_PARKING_AREA, myPlanElement->getParentStoppingPlaces().back()->getID());
1021  }
1022  }
1023  // check if write depart position
1024  if (tagProperty.hasAttribute(SUMO_ATTR_DEPARTPOS) && (myDepartPosition > 0)) {
1025  device.writeAttr(SUMO_ATTR_DEPARTPOS, myDepartPosition);
1026  }
1027  // check if write arrival position
1028  if (tagProperty.hasAttribute(SUMO_ATTR_ARRIVALPOS) && (myArrivalPosition > 0)) {
1029  device.writeAttr(SUMO_ATTR_ARRIVALPOS, myArrivalPosition);
1030  }
1031  // check if write end position
1032  if (tagProperty.hasAttribute(SUMO_ATTR_ENDPOS)) {
1033  device.writeAttr(SUMO_ATTR_ENDPOS, myArrivalPosition);
1034  }
1035 }
1036 
1037 
1038 void
1039 GNEDemandElementPlan::writeOriginStop(OutputDevice& device) const {
1040  const auto& tagProperty = myPlanElement->getTagProperty();
1041  // write an extra stop element with duration 0 over a stopping place (if this is the first element)
1042  if (tagProperty.planFromStoppingPlace()
1043  && myPlanElement->getParentDemandElements().at(0)->getPreviousChildDemandElement(myPlanElement) == nullptr) {
1044  device.openTag(SUMO_TAG_STOP);
1045  const std::string stopID = myPlanElement->getParentStoppingPlaces().front()->getID();
1046  if (tagProperty.planFromBusStop()) {
1047  device.writeAttr(SUMO_ATTR_BUS_STOP, stopID);
1048  } else if (tagProperty.planFromTrainStop()) {
1049  device.writeAttr(SUMO_ATTR_TRAIN_STOP, stopID);
1050  } else if (tagProperty.planFromContainerStop()) {
1051  device.writeAttr(SUMO_ATTR_CONTAINER_STOP, stopID);
1052  } else if (tagProperty.planFromChargingStation()) {
1053  device.writeAttr(SUMO_ATTR_CHARGING_STATION, stopID);
1054  } else if (tagProperty.planFromParkingArea()) {
1055  device.writeAttr(SUMO_ATTR_PARKING_AREA, stopID);
1056  }
1057  device.writeAttr(SUMO_ATTR_DURATION, 0);
1058  device.closeTag();
1059  }
1060 }
1061 
1062 
1063 GUIGLObjectPopupMenu*
1064 GNEDemandElementPlan::getPlanPopUpMenu(GUIMainWindow& app, GUISUMOAbstractView& parent) {
1065  GUIGLObjectPopupMenu* ret = new GUIGLObjectPopupMenu(app, parent, *myPlanElement);
1066  // build header
1067  myPlanElement->buildPopupHeader(ret, app);
1068  // build menu command for center button and copy cursor position to clipboard
1069  myPlanElement->buildCenterPopupEntry(ret);
1070  myPlanElement->buildPositionCopyEntry(ret, app);
1071  // build menu commands for names
1072  GUIDesigns::buildFXMenuCommand(ret, "Copy " + myPlanElement->getTagStr() + " name to clipboard", nullptr, ret, MID_COPY_NAME);
1073  GUIDesigns::buildFXMenuCommand(ret, "Copy " + myPlanElement->getTagStr() + " typed name to clipboard", nullptr, ret, MID_COPY_TYPED_NAME);
1074  new FXMenuSeparator(ret);
1075  // build selection and show parameters menu
1076  myPlanElement->getNet()->getViewNet()->buildSelectionACPopupEntry(ret, myPlanElement);
1077  myPlanElement->buildShowParamsPopupEntry(ret);
1078  GUIDesigns::buildFXMenuCommand(ret, ("Cursor position in view: " + toString(getPlanPositionInView().x()) + "," + toString(getPlanPositionInView().y())).c_str(), nullptr, nullptr, 0);
1079  return ret;
1080 }
1081 
1082 
1083 GNELane*
1084 GNEDemandElementPlan::getFirstPlanPathLane() const {
1085  // get tag property
1086  const auto& tagProperty = myPlanElement->getTagProperty();
1087  // get vclass
1088  auto vClass = myPlanElement->getVClass();
1089  // continue depending of parents
1090  if (tagProperty.planRoute()) {
1091  // route
1092  return myPlanElement->getParentDemandElements().at(1)->getParentEdges().front()->getLaneByAllowedVClass(vClass);
1093  } else if (tagProperty.planConsecutiveEdges() || tagProperty.planFromEdge() || tagProperty.planEdge()) {
1094  // edges
1095  return myPlanElement->getParentEdges().front()->getLaneByAllowedVClass(vClass);
1096  } else if (tagProperty.planStoppingPlace() || tagProperty.planFromStoppingPlace() || tagProperty.planToStoppingPlace()) {
1097  // additional
1098  return myPlanElement->getParentStoppingPlaces().front()->getParentLanes().front();
1099  } else {
1100  // in other cases (TAZ, junctions, etc.) return null
1101  return nullptr;
1102  }
1103 }
1104 
1105 
1106 GNELane*
1107 GNEDemandElementPlan::getLastPlanPathLane() const {
1108  // get tag property
1109  const auto& tagProperty = myPlanElement->getTagProperty();
1110  // get vclass
1111  auto vClass = myPlanElement->getVClass();
1112  // check parents
1113  if (tagProperty.planRoute()) {
1114  // route
1115  return myPlanElement->getParentDemandElements().at(1)->getParentEdges().back()->getLaneByAllowedVClass(vClass);
1116  } else if (tagProperty.planConsecutiveEdges() || tagProperty.planToEdge() || tagProperty.planEdge()) {
1117  // edges
1118  return myPlanElement->getParentEdges().back()->getLaneByAllowedVClass(vClass);
1119  } else if (tagProperty.planStoppingPlace() || tagProperty.planFromStoppingPlace() || tagProperty.planToStoppingPlace()) {
1120  // additional
1121  return myPlanElement->getParentStoppingPlaces().back()->getParentLanes().front()->getParentEdge()->getLaneByAllowedVClass(vClass);
1122  } else {
1123  // in other cases (TAZ, junctions, etc.) return null
1124  return nullptr;
1125  }
1126 }
1127 
1128 
1129 void
1130 GNEDemandElementPlan::computePlanPathElement() {
1131  // get tag property
1132  const auto& tagProperty = myPlanElement->getTagProperty();
1133  // get vClass
1134  auto vClass = myPlanElement->getVClass();
1135  // get path manager
1136  auto pathManager = myPlanElement->getNet()->getPathManager();
1137  // continue depending of parents
1138  if (tagProperty.planRoute()) {
1139  // calculate consecutive path using route edges
1140  pathManager->calculateConsecutivePathEdges(myPlanElement, vClass, myPlanElement->getParentDemandElements().at(1)->getParentEdges());
1141  } else if (tagProperty.planConsecutiveEdges()) {
1142  // calculate consecutive path using edges
1143  pathManager->calculateConsecutivePathEdges(myPlanElement, vClass, myPlanElement->getParentEdges());
1144  } else if (myPlanElement->myTagProperty.planFromJunction() && myPlanElement->myTagProperty.planToJunction()) {
1145  // calculate path using junctions
1146  pathManager->calculatePath(myPlanElement, vClass, myPlanElement->getParentJunctions().front(), myPlanElement->getParentJunctions().back());
1147  } else if (myPlanElement->myTagProperty.planFromJunction()) {
1148  // declare last lane
1149  GNELane* lastLane = nullptr;
1150  if (myPlanElement->myTagProperty.planStoppingPlace()) {
1151  lastLane = myPlanElement->getParentStoppingPlaces().back()->getParentLanes().back();
1152  } else if (myPlanElement->myTagProperty.planToStoppingPlace()) {
1153  lastLane = myPlanElement->getParentStoppingPlaces().back()->getParentLanes().front();
1154  } else if (myPlanElement->myTagProperty.planToEdge()) {
1155  lastLane = myPlanElement->getParentEdges().back()->getLaneByAllowedVClass(vClass);
1156  }
1157  // calculate path
1158  if (lastLane) {
1159  pathManager->calculatePath(myPlanElement, vClass, myPlanElement->getParentJunctions().front(), lastLane);
1160  }
1161  } else if (myPlanElement->myTagProperty.planToJunction()) {
1162  // declare first lane
1163  GNELane* firstLane = nullptr;
1164  if (myPlanElement->myTagProperty.planStoppingPlace()) {
1165  firstLane = myPlanElement->getParentStoppingPlaces().front()->getParentLanes().back();
1166  } else if (myPlanElement->myTagProperty.planFromStoppingPlace()) {
1167  firstLane = myPlanElement->getParentStoppingPlaces().front()->getParentLanes().front();
1168  } else if (myPlanElement->myTagProperty.planFromEdge()) {
1169  firstLane = myPlanElement->getParentEdges().front()->getLaneByAllowedVClass(vClass);
1170  }
1171  // calculate path
1172  if (firstLane) {
1173  pathManager->calculatePath(myPlanElement, vClass, firstLane, myPlanElement->getParentJunctions().back());
1174  }
1175  } else {
1176  // declare first edge
1177  GNELane* firstLane = nullptr;
1178  if (myPlanElement->myTagProperty.planFromEdge()) {
1179  firstLane = myPlanElement->getParentEdges().front()->getLaneByAllowedVClass(vClass);
1180  } else if (myPlanElement->myTagProperty.planStoppingPlace()) {
1181  firstLane = myPlanElement->getParentStoppingPlaces().front()->getParentLanes().back();
1182  } else if (myPlanElement->myTagProperty.planFromStoppingPlace()) {
1183  firstLane = myPlanElement->getParentStoppingPlaces().front()->getParentLanes().front();
1184  }
1185  // declare last lane
1186  GNELane* lastLane = nullptr;
1187  if (myPlanElement->myTagProperty.planToEdge()) {
1188  lastLane = myPlanElement->getParentEdges().back()->getLaneByAllowedVClass(vClass);
1189  } else if (myPlanElement->myTagProperty.planStoppingPlace()) {
1190  lastLane = myPlanElement->getParentStoppingPlaces().back()->getParentLanes().back();
1191  } else if (myPlanElement->myTagProperty.planToStoppingPlace()) {
1192  lastLane = myPlanElement->getParentStoppingPlaces().back()->getParentLanes().front();
1193  }
1194  if (firstLane && lastLane) {
1195  pathManager->calculatePath(myPlanElement, vClass, firstLane, lastLane);
1196  } else if (firstLane) {
1197  pathManager->calculateConsecutivePathLanes(myPlanElement, {firstLane});
1198  } else if (lastLane) {
1199  pathManager->calculateConsecutivePathLanes(myPlanElement, {lastLane});
1200  }
1201  }
1202  // update geometry
1203  updatePlanGeometry();
1204 }
1205 
1206 
1207 void
1208 GNEDemandElementPlan::updatePlanGeometry() {
1209  // get tag property
1210  const auto& tagProperty = myPlanElement->getTagProperty();
1211  // check if plan start or end in a TAZ (becase in this case has to be inserted in RTREE
1212  if (tagProperty.planFromTAZ() || tagProperty.planToTAZ()) {
1213  // declare first and last positions
1214  Position firstPos = Position::INVALID;
1215  Position lastPos = Position::INVALID;
1216  // set first position
1217  if (tagProperty.planFromEdge()) {
1218  // from junction
1219  firstPos = myPlanElement->getFirstPathLane()->getLaneShape().back();
1220  } else if (tagProperty.planFromJunction()) {
1221  // from junction
1222  firstPos = myPlanElement->getParentJunctions().front()->getPositionInView();
1223  } else if (tagProperty.planFromStoppingPlace()) {
1224  // end of stoppingPlace lane shape
1225  firstPos = myPlanElement->getParentStoppingPlaces().front()->getParentLanes().front()->getLaneShape().back();
1226  } else if (tagProperty.planFromTAZ()) {
1227  // from TAZ
1228  if (myPlanElement->getParentTAZs().front()->getAttribute(SUMO_ATTR_CENTER).empty()) {
1229  firstPos = myPlanElement->getParentTAZs().front()->getAttributePosition(GNE_ATTR_TAZ_CENTROID);
1230  } else {
1231  firstPos = myPlanElement->getParentTAZs().front()->getAttributePosition(SUMO_ATTR_CENTER);
1232  }
1233  }
1234  // set last position
1235  if (tagProperty.planToEdge()) {
1236  // from junction
1237  lastPos = myPlanElement->getLastPathLane()->getLaneShape().back();
1238  } else if (tagProperty.planToJunction()) {
1239  // from junction
1240  lastPos = myPlanElement->getParentJunctions().back()->getPositionInView();
1241  } else if (tagProperty.planToStoppingPlace()) {
1242  // end of stoppingPlace lane shape
1243  lastPos = myPlanElement->getParentStoppingPlaces().back()->getParentLanes().front()->getLaneShape().front();
1244  } else if (tagProperty.planToTAZ()) {
1245  // from TAZ
1246  if (myPlanElement->getParentTAZs().back()->getAttribute(SUMO_ATTR_CENTER).empty()) {
1247  lastPos = myPlanElement->getParentTAZs().back()->getAttributePosition(GNE_ATTR_TAZ_CENTROID);
1248  } else {
1249  lastPos = myPlanElement->getParentTAZs().back()->getAttributePosition(SUMO_ATTR_CENTER);
1250  }
1251  }
1252  // use both position to calculate a line
1253  if ((firstPos != Position::INVALID) && (lastPos != Position::INVALID)) {
1254  myPlanElement->myDemandElementGeometry.updateGeometry({firstPos, lastPos});
1255  } else {
1256  myPlanElement->myDemandElementGeometry.clearGeometry();
1257  }
1258  }
1259  // update centering boundary
1260  updatePlanCenteringBoundary(true);
1261  // update child demand elements
1262  for (const auto& demandElement : myPlanElement->getChildDemandElements()) {
1263  demandElement->updateGeometry();
1264  }
1265 }
1266 
1267 
1268 Boundary
1269 GNEDemandElementPlan::getPlanCenteringBoundary() const {
1270  return myPlanBoundary;
1271 }
1272 
1273 
1274 void
1275 GNEDemandElementPlan::updatePlanCenteringBoundary(const bool updateGrid) {
1276  // remove additional from grid
1277  if (myPlanBoundary.isInitialised() && updateGrid) {
1278  myPlanElement->getNet()->removeGLObjectFromGrid(myPlanElement);
1279  }
1280  myPlanBoundary = myPlanElement->getDemandElementGeometry().getShape().getBoxBoundary();
1281  // if this element is over route, add their boundary
1282  if (myPlanElement->getParentDemandElements().size() > 1) {
1283  myPlanBoundary.add(myPlanElement->getParentDemandElements().at(1)->getCenteringBoundary());
1284  }
1285  // add the combination of all parent edges's boundaries
1286  for (const auto& edge : myPlanElement->getParentEdges()) {
1287  myPlanBoundary.add(edge->getCenteringBoundary());
1288  }
1289  // add the combination of all parent edges's boundaries
1290  for (const auto& junction : myPlanElement->getParentJunctions()) {
1291  myPlanBoundary.add(junction->getCenteringBoundary());
1292  }
1293  // add the combination of all parent additional's boundaries (stoppingPlaces and TAZs)
1294  for (const auto& additional : myPlanElement->getParentAdditionals()) {
1295  if (additional->getTagProperty().getTag() == SUMO_TAG_TAZ) {
1296  if (additional->getAttribute(SUMO_ATTR_CENTER).empty()) {
1297  myPlanBoundary.add(additional->getAttributePosition(GNE_ATTR_TAZ_CENTROID));
1298  } else {
1299  myPlanBoundary.add(additional->getAttributePosition(SUMO_ATTR_CENTER));
1300  }
1301  } else {
1302  myPlanBoundary.add(additional->getCenteringBoundary());
1303  }
1304  }
1305  // check if is valid
1306  if (myPlanBoundary.isInitialised()) {
1307  myPlanBoundary.grow(5);
1308  }
1309  // add additional into RTREE again
1310  if (myPlanBoundary.isInitialised() && updateGrid) {
1311  myPlanElement->getNet()->addGLObjectIntoGrid(myPlanElement);
1312  }
1313 }
1314 
1315 
1316 Position
1317 GNEDemandElementPlan::getPlanPositionInView() const {
1318  // get tag property
1319  const auto& tagProperty = myPlanElement->getTagProperty();
1320  // continue depending of parents
1321  if (tagProperty.planRoute()) {
1322  // route
1323  return myPlanElement->getParentDemandElements().at(1)->getPositionInView();
1324  } else if (tagProperty.isPlanStop()) {
1325  return myPlanElement->getDemandElementGeometry().getShape().front();
1326  } else if (tagProperty.planFromEdge() || tagProperty.planConsecutiveEdges() || tagProperty.planEdge()) {
1327  // first edge
1328  return myPlanElement->getParentEdges().front()->getPositionInView();
1329  } else if (tagProperty.planFromJunction()) {
1330  // first junction
1331  return myPlanElement->getParentJunctions().front()->getPositionInView();
1332  } else if (tagProperty.planStoppingPlace() || tagProperty.planFromStoppingPlace()) {
1333  // first additional
1334  return myPlanElement->getParentStoppingPlaces().front()->getPositionInView();
1335  } else if (tagProperty.planFromTAZ()) {
1336  if (myPlanElement->getParentTAZs().front()->getAttribute(SUMO_ATTR_CENTER).empty()) {
1337  return myPlanElement->getParentTAZs().front()->getAttributePosition(GNE_ATTR_TAZ_CENTROID);
1338  } else {
1339  return myPlanElement->getParentTAZs().front()->getAttributePosition(SUMO_ATTR_CENTER);
1340  }
1341  } else {
1342  // return parent position
1343  return Position(0, 0);
1344  }
1345 }
1346 
1347 
1348 std::string
1349 GNEDemandElementPlan::getPlanAttribute(SumoXMLAttr key) const {
1350  // continue depending of key
1351  switch (key) {
1352  // Common plan attributes
1353  case SUMO_ATTR_ID:
1354  case GNE_ATTR_PARENT:
1355  return myPlanElement->getParentDemandElements().at(0)->getID();
1356  case GNE_ATTR_SELECTED:
1357  return toString(myPlanElement->isAttributeCarrierSelected());
1358  case SUMO_ATTR_DEPARTPOS:
1359  if (myDepartPosition < 0) {
1360  return "";
1361  } else {
1362  return toString(myDepartPosition);
1363  }
1364  case SUMO_ATTR_ENDPOS:
1365  case SUMO_ATTR_ARRIVALPOS:
1366  if (myArrivalPosition < 0) {
1367  return "";
1368  } else {
1369  return toString(myArrivalPosition);
1370  }
1371  // route
1372  case SUMO_ATTR_ROUTE:
1373  return myPlanElement->getParentDemandElements().at(1)->getID();
1374  // edges
1375  case SUMO_ATTR_EDGE:
1376  case SUMO_ATTR_EDGES:
1377  return myPlanElement->parseIDs(myPlanElement->getParentEdges());
1378  // stoppingPlaces (single and back)
1379  case SUMO_ATTR_BUS_STOP:
1380  case SUMO_ATTR_TRAIN_STOP:
1381  case SUMO_ATTR_CONTAINER_STOP:
1382  case SUMO_ATTR_CHARGING_STATION:
1383  case SUMO_ATTR_PARKING_AREA:
1384  return myPlanElement->getParentStoppingPlaces().back()->getID();
1385  // from elements
1386  case SUMO_ATTR_FROM:
1387  return myPlanElement->getParentEdges().front()->getID();
1388  case SUMO_ATTR_FROM_JUNCTION:
1389  return myPlanElement->getParentJunctions().front()->getID();
1390  case SUMO_ATTR_FROM_TAZ:
1391  return myPlanElement->getParentTAZs().front()->getID();
1392  case GNE_ATTR_FROM_BUSSTOP:
1393  case GNE_ATTR_FROM_TRAINSTOP:
1394  case GNE_ATTR_FROM_CONTAINERSTOP:
1395  case GNE_ATTR_FROM_CHARGINGSTATION:
1396  case GNE_ATTR_FROM_PARKINGAREA:
1397  return myPlanElement->getParentStoppingPlaces().front()->getID();
1398  // to elements
1399  case SUMO_ATTR_TO:
1400  return myPlanElement->getParentEdges().back()->getID();
1401  case SUMO_ATTR_TO_JUNCTION:
1402  return myPlanElement->getParentJunctions().back()->getID();
1403  case SUMO_ATTR_TO_TAZ:
1404  return myPlanElement->getParentTAZs().back()->getID();
1405  default:
1406  throw InvalidArgument(myPlanElement->getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
1407  }
1408 }
1409 
1410 
1411 double
1412 GNEDemandElementPlan::getPlanAttributeDouble(SumoXMLAttr key) const {
1413  // get tag property
1414  const auto& tagProperty = myPlanElement->getTagProperty();
1415  // declare plan parent
1416  const auto planParent = myPlanElement->getParentDemandElements().at(0);
1417  // continue depending of key
1418  switch (key) {
1419  case GNE_ATTR_PLAN_GEOMETRY_STARTPOS: {
1420  if (tagProperty.planStoppingPlace()) {
1421  // use startpos of stoppingPlace parent (stops)
1422  return myPlanElement->getParentStoppingPlaces().front()->getAttributeDouble(SUMO_ATTR_STARTPOS);
1423  } else if (tagProperty.planFromStoppingPlace()) {
1424  // use end position of stoppingPlace parent (for plans that starts in stoppingPlaces)
1425  return myPlanElement->getParentStoppingPlaces().front()->getAttributeDouble(SUMO_ATTR_ENDPOS);
1426  } else if (tagProperty.planFromTAZ()) {
1427  return 0;
1428  } else if (tagProperty.planFromJunction()) {
1429  return -1;
1430  } else {
1431  // get previous plan element
1432  const auto previousPlan = planParent->getPreviousChildDemandElement(myPlanElement);
1433  // continue depending of previous plan
1434  if (previousPlan) {
1435  // use previous plan end position (normally the arrival position)
1436  const auto posOverLane = previousPlan->getAttributeDouble(GNE_ATTR_PLAN_GEOMETRY_ENDPOS);
1437  // if posOverLane is -1, means that previousPlan ends in the end of lane.
1438  if (posOverLane == -1) {
1439  // INVALID_DOUBLE will put the startPositio at the end of line
1440  return INVALID_DOUBLE;
1441  } else {
1442  return previousPlan->getAttributeDouble(GNE_ATTR_PLAN_GEOMETRY_ENDPOS);
1443  }
1444  } else {
1445  // use depart position defined in parent (person or container)
1446  return planParent->getAttributeDouble(SUMO_ATTR_DEPARTPOS);
1447  }
1448  }
1449  }
1450  case GNE_ATTR_PLAN_GEOMETRY_ENDPOS:
1451  // continue depending of parents
1452  if (tagProperty.planStoppingPlace()) {
1453  // use end position of the stoppingPlace (stops)
1454  return myPlanElement->getParentStoppingPlaces().back()->getAttributeDouble(SUMO_ATTR_ENDPOS);
1455  } else if (tagProperty.planToStoppingPlace()) {
1456  // use start position of the stoppingPlace (for elements that ends in stoppingPlaces)
1457  return myPlanElement->getParentStoppingPlaces().back()->getAttributeDouble(SUMO_ATTR_STARTPOS);
1458  } else if (tagProperty.planToJunction() || tagProperty.planToTAZ()) {
1459  // junctions and TAZs return always -1
1460  return -1;
1461  } else if ((tagProperty.isPlanStopPerson() || tagProperty.isPlanStopContainer()) && tagProperty.planEdge()) {
1462  // elements that ends in stop always uses the end (arrival) position of the stops over edges
1463  return myArrivalPosition;
1464  } else {
1465  // check if next plan is a stop over edge
1466  const auto nextPlan = planParent->getNextChildDemandElement(myPlanElement);
1467  if (nextPlan && (nextPlan->getTagProperty().isPlanStopPerson() ||
1468  nextPlan->getTagProperty().isPlanStopContainer()) &&
1469  nextPlan->getTagProperty().planEdge()) {
1470  // if next plan is an stop over stoppingPlaces, use ends of stoppingPlace
1471  return nextPlan->getAttributeDouble(GNE_ATTR_PLAN_GEOMETRY_ENDPOS);
1472  } else {
1473  // use arrival position
1474  return myArrivalPosition;
1475  }
1476  }
1477  case SUMO_ATTR_DEPARTPOS:
1478  return myDepartPosition;
1479  case SUMO_ATTR_ENDPOS:
1480  case SUMO_ATTR_ARRIVALPOS:
1481  return myArrivalPosition;
1482  default:
1483  throw InvalidArgument(myPlanElement->getTagStr() + " doesn't have a doubleattribute of type '" + toString(key) + "'");
1484  }
1485 }
1486 
1487 
1488 Position
1489 GNEDemandElementPlan::getPlanAttributePosition(SumoXMLAttr key) const {
1490  // get tag property
1491  const auto& tagProperty = myPlanElement->getTagProperty();
1492  // declare plan parent
1493  const auto planParent = myPlanElement->getParentDemandElements().at(0);
1494  // continue depending of key
1495  switch (key) {
1496  case GNE_ATTR_PLAN_GEOMETRY_STARTPOS: {
1497  // get previous plan
1498  const auto previousPlan = planParent->getPreviousChildDemandElement(myPlanElement);
1499  if (previousPlan && previousPlan->getTagProperty().isPlanStop() && previousPlan->getTagProperty().planStoppingPlace()) {
1500  return previousPlan->getParentStoppingPlaces().front()->getAdditionalGeometry().getShape().back();
1501  }
1502  // continue depending of from element
1503  if (tagProperty.planStoppingPlace()) {
1504  return myPlanElement->getParentStoppingPlaces().front()->getAdditionalGeometry().getShape().front();
1505  } else if (tagProperty.planFromStoppingPlace()) {
1506  return myPlanElement->getParentStoppingPlaces().front()->getAdditionalGeometry().getShape().back();
1507  } else if (tagProperty.planFromJunction()) {
1508  // junction view position
1509  return myPlanElement->getParentJunctions().front()->getPositionInView();
1510  } else if (tagProperty.planFromTAZ()) {
1511  if (myPlanElement->getParentTAZs().front()->getAttribute(SUMO_ATTR_CENTER).empty()) {
1512  return myPlanElement->getParentTAZs().front()->getAttributePosition(GNE_ATTR_TAZ_CENTROID);
1513  } else {
1514  return myPlanElement->getParentTAZs().front()->getAttributePosition(SUMO_ATTR_CENTER);
1515  }
1516  } else if (tagProperty.planConsecutiveEdges() || tagProperty.planRoute() || tagProperty.planFromEdge()) {
1517  // get first path lane
1518  const auto firstLane = myPlanElement->getFirstPathLane();
1519  // check if first lane exists
1520  if (firstLane == nullptr) {
1521  return Position::INVALID;
1522  }
1523  // declare lane position
1524  double lanePosition = 0;
1525  // continue depending of conditions
1526  if (previousPlan) {
1527  // use previous geometry end position
1528  lanePosition = previousPlan->getAttributeDouble(GNE_ATTR_PLAN_GEOMETRY_ENDPOS);
1529  } else {
1530  // use departPos defined in planParent
1531  lanePosition = planParent->getAttributeDouble(SUMO_ATTR_DEPARTPOS);
1532  }
1533  // get lane shape
1534  const auto& laneShape = firstLane->getLaneShape();
1535  // continue depending of lane position
1536  if (lanePosition <= 0) {
1537  return laneShape.front();
1538  } else if (lanePosition >= laneShape.length2D()) {
1539  return laneShape.back();
1540  } else {
1541  return laneShape.positionAtOffset2D(lanePosition);
1542  }
1543  } else {
1544  return Position::INVALID;
1545  }
1546  }
1547  case GNE_ATTR_PLAN_GEOMETRY_ENDPOS: {
1548  // check parents
1549  if (tagProperty.planToJunction()) {
1550  // junctions
1551  return myPlanElement->getParentJunctions().back()->getPositionInView();
1552  } else if (tagProperty.planStoppingPlace()) {
1553  // get additional back shape (stops)
1554  return myPlanElement->getParentStoppingPlaces().back()->getAdditionalGeometry().getShape().back();
1555  } else if (tagProperty.planToStoppingPlace()) {
1556  // get additional front shape
1557  return myPlanElement->getParentStoppingPlaces().back()->getAdditionalGeometry().getShape().front();
1558  } else if (tagProperty.planToTAZ()) {
1559  // taz
1560  if (myPlanElement->getParentTAZs().back()->getAttribute(SUMO_ATTR_CENTER).empty()) {
1561  return myPlanElement->getParentTAZs().back()->getAttributePosition(GNE_ATTR_TAZ_CENTROID);
1562  } else {
1563  return myPlanElement->getParentTAZs().back()->getAttributePosition(SUMO_ATTR_CENTER);
1564  }
1565  } else if (tagProperty.planConsecutiveEdges() || tagProperty.planRoute() || tagProperty.planFromEdge()) {
1566  // get next plan
1567  const auto nextPlan = planParent->getNextChildDemandElement(myPlanElement);
1568  // if next plan exist, then use their first lane (needed to maintain connectivity with rides)
1569  const auto lastLane = nextPlan ? nextPlan->getFirstPathLane() : myPlanElement->getLastPathLane();
1570  // check if last lane exists
1571  if (lastLane == nullptr) {
1572  return Position::INVALID;
1573  }
1574  // get lane shape
1575  const auto& laneShape = lastLane->getLaneShape();
1576  // continue depending of arrival position
1577  if (nextPlan && nextPlan->getTagProperty().isPlanStop()) {
1578  return nextPlan->getAttributePosition(GNE_ATTR_PLAN_GEOMETRY_ENDPOS);
1579  } else if (myArrivalPosition == 0) {
1580  return laneShape.front();
1581  } else if ((myArrivalPosition == -1) || (myArrivalPosition >= laneShape.length2D())) {
1582  return laneShape.back();
1583  } else {
1584  return laneShape.positionAtOffset2D(myArrivalPosition);
1585  }
1586  } else {
1587  return Position::INVALID;
1588  }
1589  }
1590  default:
1591  throw InvalidArgument(myPlanElement->getTagStr() + " doesn't have a position attribute of type '" + toString(key) + "'");
1592  }
1593 }
1594 
1595 
1596 void
1597 GNEDemandElementPlan::setPlanAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) {
1598  // continue depending of key
1599  switch (key) {
1600  // common attributes
1601  case SUMO_ATTR_DEPARTPOS:
1602  case SUMO_ATTR_ARRIVALPOS:
1603  case SUMO_ATTR_ENDPOS:
1604  case GNE_ATTR_PARENT:
1605  case GNE_ATTR_SELECTED:
1606  GNEChange_Attribute::changeAttribute(myPlanElement, key, value, undoList);
1607  break;
1608  default:
1609  throw InvalidArgument(myPlanElement->getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
1610  }
1611 }
1612 
1613 
1614 bool
1615 GNEDemandElementPlan::isPlanValid(SumoXMLAttr key, const std::string& value) {
1616  // continue depending of key
1617  switch (key) {
1618  // common attributes
1619  case GNE_ATTR_PARENT:
1620  return false;
1621  case SUMO_ATTR_DEPARTPOS:
1622  case SUMO_ATTR_ARRIVALPOS:
1623  if (value.empty()) {
1624  return true;
1625  } else if (GNEAttributeCarrier::canParse<double>(value)) {
1626  return GNEAttributeCarrier::parse<double>(value) >= 0;
1627  } else {
1628  return false;
1629  }
1630  case SUMO_ATTR_ENDPOS:
1631  return GNEAttributeCarrier::canParse<double>(value);
1632  case GNE_ATTR_SELECTED:
1633  return GNEAttributeCarrier::canParse<bool>(value);
1634  default:
1635  throw InvalidArgument(myPlanElement->getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
1636  }
1637 }
1638 
1639 
1640 bool
1641 GNEDemandElementPlan::isPlanAttributeEnabled(SumoXMLAttr key) const {
1642  switch (key) {
1643  // edges
1644  case SUMO_ATTR_EDGES:
1645  // edge
1646  case SUMO_ATTR_EDGE:
1647  // route
1648  case SUMO_ATTR_ROUTE:
1649  // from
1650  case SUMO_ATTR_FROM:
1651  case SUMO_ATTR_FROM_JUNCTION:
1652  case SUMO_ATTR_FROM_TAZ:
1653  case GNE_ATTR_FROM_BUSSTOP:
1654  case GNE_ATTR_FROM_TRAINSTOP:
1655  case GNE_ATTR_FROM_CONTAINERSTOP:
1656  case GNE_ATTR_FROM_CHARGINGSTATION:
1657  case GNE_ATTR_FROM_PARKINGAREA:
1658  // to
1659  case SUMO_ATTR_TO:
1660  case SUMO_ATTR_TO_JUNCTION:
1661  case SUMO_ATTR_TO_TAZ:
1662  case SUMO_ATTR_BUS_STOP:
1663  case SUMO_ATTR_TRAIN_STOP:
1664  case SUMO_ATTR_CONTAINER_STOP:
1665  case SUMO_ATTR_CHARGING_STATION:
1666  case SUMO_ATTR_PARKING_AREA:
1667  // depart pos (temporal, probably will be removed)
1668  case SUMO_ATTR_DEPARTPOS:
1669  return false;
1670  default:
1671  return true;
1672  }
1673 }
1674 
1675 
1676 void
1677 GNEDemandElementPlan::setPlanAttribute(SumoXMLAttr key, const std::string& value) {
1678  switch (key) {
1679  // from-to attributes (needed if we're replacing junction by geometry points and similar operations)
1680  case SUMO_ATTR_FROM:
1681  myPlanElement->replaceFirstParentEdge(value);
1682  break;
1683  case SUMO_ATTR_TO:
1684  myPlanElement->replaceLastParentEdge(value);
1685  break;
1686  // Common plan attributes
1687  case GNE_ATTR_PARENT:
1688  replacePlanParent(value);
1689  break;
1690  case SUMO_ATTR_DEPARTPOS:
1691  if (value.empty()) {
1692  myDepartPosition = -1;
1693  } else {
1694  myDepartPosition = GNEAttributeCarrier::parse<double>(value);
1695  }
1696  break;
1697  case SUMO_ATTR_ENDPOS:
1698  case SUMO_ATTR_ARRIVALPOS:
1699  if (value.empty()) {
1700  myArrivalPosition = -1;
1701  } else {
1702  myArrivalPosition = GNEAttributeCarrier::parse<double>(value);
1703  }
1704  break;
1705  case GNE_ATTR_SELECTED:
1706  if (GNEAttributeCarrier::parse<bool>(value)) {
1707  myPlanElement->selectAttributeCarrier();
1708  } else {
1709  myPlanElement->unselectAttributeCarrier();
1710  }
1711  // check if compute geometry and path
1712  if (!myPlanElement->isTemplate()) {
1713  myPlanElement->updateGeometry();
1714  myPlanElement->computePathElement();
1715  }
1716  break;
1717  default:
1718  throw InvalidArgument(myPlanElement->getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
1719  }
1720 }
1721 
1722 
1723 std::string
1724 GNEDemandElementPlan::getPlanHierarchyName() const {
1725  // get tag property
1726  const auto& tagProperty = myPlanElement->getTagProperty();
1727  // declare result
1728  std::string result;
1729  // clear result
1730  int index = 0;
1731  while (tagProperty.getTagStr().at(index) != ':') {
1732  result.push_back(tagProperty.getTagStr().at(index));
1733  index++;
1734  }
1735  result += ": ";
1736  // continue depending of attributes
1737  if (tagProperty.planConsecutiveEdges()) {
1738  // edges
1739  return result + myPlanElement->getParentEdges().front()->getID() + " ... " + myPlanElement->getParentEdges().back()->getID();
1740  } else if (tagProperty.planRoute()) {
1741  // route
1742  return result + myPlanElement->getParentDemandElements().at(1)->getID();
1743  } else if (tagProperty.planEdge()) {
1744  // edge
1745  return result + myPlanElement->getParentEdges().front()->getID();
1746  } else if (tagProperty.planStoppingPlace()) {
1747  // stoppingPlace
1748  return myPlanElement->getParentStoppingPlaces().front()->getID();
1749  } else {
1750  // stoppingPlace
1751  if (tagProperty.planFromStoppingPlace()) {
1752  result += myPlanElement->getParentStoppingPlaces().front()->getID();
1753  }
1754  // TAZ
1755  if (tagProperty.planFromTAZ()) {
1756  result += myPlanElement->getParentTAZs().front()->getID();
1757  }
1758  // junction
1759  if (tagProperty.planFromJunction()) {
1760  result += myPlanElement->getParentJunctions().front()->getID();
1761  }
1762  // edge
1763  if (tagProperty.planFromEdge()) {
1764  result += myPlanElement->getParentEdges().front()->getID();
1765  }
1766  // arrow
1767  result += " -> ";
1768  // stoppingPlace
1769  if (tagProperty.planToStoppingPlace()) {
1770  result += myPlanElement->getParentStoppingPlaces().back()->getID();
1771  }
1772  // TAZ
1773  if (tagProperty.planToTAZ()) {
1774  result += myPlanElement->getParentTAZs().back()->getID();
1775  }
1776  // junction
1777  if (tagProperty.planToJunction()) {
1778  result += myPlanElement->getParentJunctions().back()->getID();
1779  }
1780  // edge
1781  if (tagProperty.planToEdge()) {
1782  result += myPlanElement->getParentEdges().back()->getID();
1783  }
1784  return result;
1785  }
1786 }
1787 
1788 
1789 bool
1790 GNEDemandElementPlan::checkDrawPersonPlan() const {
1791  // get view net
1792  auto viewNet = myPlanElement->getNet()->getViewNet();
1793  // check conditions
1794  if (viewNet->getEditModes().isCurrentSupermodeNetwork() &&
1795  viewNet->getNetworkViewOptions().showDemandElements() &&
1796  viewNet->getDemandViewOptions().showAllPersonPlans()) {
1797  // show all person plans in network mode
1798  return true;
1799  } else if (viewNet->getEditModes().isCurrentSupermodeDemand() &&
1800  viewNet->getDemandViewOptions().showAllPersonPlans()) {
1801  // show all person plans
1802  return true;
1803  } else if (viewNet->getEditModes().isCurrentSupermodeDemand() && myPlanElement->isAttributeCarrierSelected()) {
1804  // show selected
1805  return true;
1806  } else if (viewNet->isAttributeCarrierInspected(myPlanElement->getParentDemandElements().front())) {
1807  // person parent is inspected
1808  return true;
1809  } else if (viewNet->getDemandViewOptions().getLockedPerson() == myPlanElement->getParentDemandElements().front()) {
1810  // person parent is locked
1811  return true;
1812  } else if (viewNet->getInspectedAttributeCarriers().empty()) {
1813  // nothing is inspected
1814  return false;
1815  } else {
1816  // get inspected AC
1817  const GNEAttributeCarrier* AC = viewNet->getInspectedAttributeCarriers().front();
1818  // check condition
1819  if (AC->getTagProperty().isPlanPerson() && AC->getAttribute(GNE_ATTR_PARENT) == myPlanElement->getAttribute(GNE_ATTR_PARENT)) {
1820  // common person parent
1821  return true;
1822  } else {
1823  // all conditions are false
1824  return false;
1825  }
1826  }
1827 }
1828 
1829 
1830 bool
1831 GNEDemandElementPlan::checkDrawContainerPlan() const {
1832  // get view net
1833  auto viewNet = myPlanElement->getNet()->getViewNet();
1834  // check conditions
1835  if (viewNet->getEditModes().isCurrentSupermodeNetwork() &&
1836  viewNet->getNetworkViewOptions().showDemandElements() &&
1837  viewNet->getDemandViewOptions().showAllContainerPlans()) {
1838  // show all container plans in network mode
1839  return true;
1840  } else if (viewNet->getEditModes().isCurrentSupermodeDemand() &&
1841  viewNet->getDemandViewOptions().showAllContainerPlans()) {
1842  // show all container plans
1843  return true;
1844  } else if (viewNet->getEditModes().isCurrentSupermodeDemand() && myPlanElement->isAttributeCarrierSelected()) {
1845  // show selected
1846  return true;
1847  } else if (viewNet->isAttributeCarrierInspected(myPlanElement->getParentDemandElements().front())) {
1848  // container parent is inspected
1849  return true;
1850  } else if (viewNet->getDemandViewOptions().getLockedContainer() == myPlanElement->getParentDemandElements().front()) {
1851  // container parent is locked
1852  return true;
1853  } else if (viewNet->getInspectedAttributeCarriers().empty()) {
1854  // nothing is inspected
1855  return false;
1856  } else {
1857  // get inspected AC
1858  const GNEAttributeCarrier* AC = viewNet->getInspectedAttributeCarriers().front();
1859  // check condition
1860  if (AC->getTagProperty().isPlanContainer() && AC->getAttribute(GNE_ATTR_PARENT) == myPlanElement->getAttribute(GNE_ATTR_PARENT)) {
1861  // common container parent
1862  return true;
1863  } else {
1864  // all conditions are false
1865  return false;
1866  }
1867  }
1868 }
1869 
1870 
1871 void
1872 GNEDemandElementPlan::drawPlanGL(const bool drawPlan, const GUIVisualizationSettings& s, const RGBColor& planColor, const RGBColor& planSelectedColor) const {
1873  // get plan parent
1874  const GNEDemandElement* planParent = myPlanElement->getParentDemandElements().front();
1875  // get tag property
1876  const auto& tagProperty = myPlanElement->getTagProperty();
1877  // get plan geometry
1878  auto& planGeometry = myPlanElement->myDemandElementGeometry;
1879  // draw relations between TAZs
1880  if (drawPlan && (planGeometry.getShape().size() > 0)) {
1881  // draw boundary
1882  if (s.drawBoundaries) {
1883  GLHelper::drawBoundary(s, getPlanCenteringBoundary());
1884  }
1885  // get detail level
1886  const auto d = s.getDetailLevel(1);
1887  // get viewNet
1888  auto viewNet = myPlanElement->getNet()->getViewNet();
1889  // get inspected attribute carriers
1890  const auto& inspectedACs = viewNet->getInspectedAttributeCarriers();
1891  // get inspected plan
1892  const GNEAttributeCarrier* planInspected = (inspectedACs.size() > 0) ? inspectedACs.front() : nullptr;
1893  // check if draw with double width
1894  const bool drawHalfWidth = ((planInspected != myPlanElement) && (planInspected != planParent) && !gViewObjectsHandler.isElementSelected(myPlanElement));
1895  // calculate path width
1896  double pathWidth = s.widthSettings.walkWidth;
1897  if (tagProperty.isPlanRide()) {
1898  pathWidth = s.widthSettings.rideWidth;
1899  } else if (tagProperty.isPlanPersonTrip()) {
1900  pathWidth = s.widthSettings.personTripWidth;
1901  }
1902  // draw geometry only if we'rent in drawForObjectUnderCursor mode
1903  if ((tagProperty.isPlanPerson() && s.checkDrawPerson(d, myPlanElement->isAttributeCarrierSelected())) ||
1904  (tagProperty.isPlanContainer() && s.checkDrawContainer(d, myPlanElement->isAttributeCarrierSelected()))) {
1905  // push matrix
1906  GLHelper::pushMatrix();
1907  // translate to front
1908  viewNet->drawTranslateFrontAttributeCarrier(myPlanElement, GLO_TAZ + 1);
1909  // set color
1910  GLHelper::setColor(myPlanElement->drawUsingSelectColor() ? planSelectedColor : planColor);
1911  // draw line
1912  GUIGeometry::drawGeometry(d, planGeometry, pathWidth * (drawHalfWidth ? 1 : 2));
1913  if (drawHalfWidth) {
1914  GLHelper::drawTriangleAtEnd(planGeometry.getShape().front(), planGeometry.getShape().back(), 0.5, 0.5, 0.5);
1915  } else {
1916  GLHelper::drawTriangleAtEnd(planGeometry.getShape().front(), planGeometry.getShape().back(), 1, 1, 1);
1917  }
1918  // pop matrix
1919  GLHelper::popMatrix();
1920  // draw dotted contour
1921  myPlanContour.drawDottedContours(s, d, myPlanElement, s.dottedContourSettings.segmentWidth, true);
1922  }
1923  // calculate contour and draw dotted geometry
1924  myPlanContour.calculateContourExtrudedShape(s, d, myPlanElement, planGeometry.getShape(), pathWidth * 2, 1, true, true, 0);
1925  // calculate contour for end
1926  myPlanContourEnd.calculateContourCircleShape(s, d, myPlanElement, planGeometry.getShape().back(), 1, 1);
1927  }
1928  // check if draw plan parent
1929  if (planParent->getPreviousChildDemandElement(myPlanElement) == nullptr) {
1930  planParent->drawGL(s);
1931  }
1932 }
1933 
1934 
1935 void
1936 GNEDemandElementPlan::drawPlanLanePartial(const bool drawPlan, const GUIVisualizationSettings& s, const GNEPathManager::Segment* segment,
1937  const double offsetFront, const double planWidth, const RGBColor& planColor, const RGBColor& planSelectedColor) const {
1938  // get view net
1939  auto viewNet = myPlanElement->getNet()->getViewNet();
1940  // get tag property
1941  const auto& tagProperty = myPlanElement->getTagProperty();
1942  // get plan parent
1943  const GNEDemandElement* planParent = myPlanElement->getParentDemandElements().front();
1944  // check if draw plan element can be drawn
1945  if (drawPlan && segment->getLane() && myPlanElement->getNet()->getPathManager()->getPathDraw()->checkDrawPathGeometry(s, segment->getLane(), tagProperty.getTag())) {
1946  // draw boundary
1947  if (tagProperty.isPlacedInRTree() && s.drawBoundaries) {
1948  GLHelper::drawBoundary(s, getPlanCenteringBoundary());
1949  }
1950  // get detail level
1951  const auto d = s.getDetailLevel(1);
1952  // get inspected attribute carriers
1953  const auto& inspectedACs = viewNet->getInspectedAttributeCarriers();
1954  // get inspected plan
1955  const GNEAttributeCarrier* planInspected = (inspectedACs.size() > 0) ? inspectedACs.front() : nullptr;
1956  // declare path geometry
1957  GUIGeometry planGeometry;
1958  // update pathGeometry depending of first and last segment
1959  if (segment->isFirstSegment() && segment->isLastSegment()) {
1960  if (tagProperty.planFromTAZ()) {
1961  planGeometry.updateGeometry(segment->getLane()->getLaneGeometry().getShape(),
1962  getPlanAttributeDouble(GNE_ATTR_PLAN_GEOMETRY_STARTPOS),
1963  Position::INVALID,
1964  getPlanAttributeDouble(GNE_ATTR_PLAN_GEOMETRY_ENDPOS),
1965  getPlanAttributePosition(GNE_ATTR_PLAN_GEOMETRY_ENDPOS));
1966  } else if (tagProperty.planToTAZ()) {
1967  planGeometry.updateGeometry(segment->getLane()->getLaneGeometry().getShape(),
1968  getPlanAttributeDouble(GNE_ATTR_PLAN_GEOMETRY_STARTPOS),
1969  getPlanAttributePosition(GNE_ATTR_PLAN_GEOMETRY_STARTPOS),
1970  getPlanAttributeDouble(GNE_ATTR_PLAN_GEOMETRY_ENDPOS),
1971  Position::INVALID);
1972  } else {
1973  planGeometry.updateGeometry(segment->getLane()->getLaneGeometry().getShape(),
1974  getPlanAttributeDouble(GNE_ATTR_PLAN_GEOMETRY_STARTPOS),
1975  getPlanAttributePosition(GNE_ATTR_PLAN_GEOMETRY_STARTPOS),
1976  getPlanAttributeDouble(GNE_ATTR_PLAN_GEOMETRY_ENDPOS),
1977  getPlanAttributePosition(GNE_ATTR_PLAN_GEOMETRY_ENDPOS));
1978  }
1979  } else if (segment->isFirstSegment()) {
1980  planGeometry.updateGeometry(segment->getLane()->getLaneGeometry().getShape(),
1981  getPlanAttributeDouble(GNE_ATTR_PLAN_GEOMETRY_STARTPOS),
1982  getPlanAttributePosition(GNE_ATTR_PLAN_GEOMETRY_STARTPOS),
1983  -1,
1984  Position::INVALID);
1985  } else if (segment->isLastSegment()) {
1986  planGeometry.updateGeometry(segment->getLane()->getLaneGeometry().getShape(),
1987  -1,
1988  Position::INVALID,
1989  getPlanAttributeDouble(GNE_ATTR_PLAN_GEOMETRY_ENDPOS),
1990  getPlanAttributePosition(GNE_ATTR_PLAN_GEOMETRY_ENDPOS));
1991  } else {
1992  planGeometry = segment->getLane()->getLaneGeometry();
1993  }
1994  // calculate path width double
1995  const double drawingWidth = s.addSize.getExaggeration(s, segment->getLane()) * planWidth * 2;
1996  // check if draw with double width
1997  const bool drawHalfWidth = ((planInspected != myPlanElement) && (planInspected != planParent) && !gViewObjectsHandler.isElementSelected(myPlanElement));
1998  // get end pos radius
1999  const double endPosRadius = getEndPosRadius(s, segment, drawHalfWidth);
2000  // draw geometry only if we'rent in drawForObjectUnderCursor mode
2001  if ((tagProperty.isPlanPerson() && s.checkDrawPerson(d, myPlanElement->isAttributeCarrierSelected())) ||
2002  (tagProperty.isPlanContainer() && s.checkDrawContainer(d, myPlanElement->isAttributeCarrierSelected()))) {
2003  // Add a draw matrix
2004  GLHelper::pushMatrix();
2005  // Start with the drawing of the area traslating matrix to origin
2006  viewNet->drawTranslateFrontAttributeCarrier(myPlanElement, myPlanElement->getType(), offsetFront);
2007  // Set color
2008  GLHelper::setColor(myPlanElement->drawUsingSelectColor() ? planSelectedColor : planColor);
2009  // draw geometry depending of drawWithDoubleWidth
2010  GUIGeometry::drawGeometry(d, planGeometry, drawingWidth * (drawHalfWidth ? 0.5 : 1));
2011  // draw red arrows
2012  drawFromArrow(s, segment->getLane(), segment);
2013  drawToArrow(s, segment->getLane(), segment);
2014  // Pop last matrix
2015  GLHelper::popMatrix();
2016  // Draw name if isn't being drawn for selecting
2017  myPlanElement->drawName(myPlanElement->getCenteringBoundary().getCenter(), s.scale, s.addName);
2018  // draw dotted contour
2019  segment->getContour()->drawDottedContours(s, d, myPlanElement, s.dottedContourSettings.segmentWidth, true);
2020  // draw TAZ Center dotted contour
2021  myPlanContourEnd.drawDottedContours(s, d, myPlanElement, s.dottedContourSettings.segmentWidth, true);
2022  }
2023  // declare trim geometry to draw
2024  const auto& shape = (segment->isFirstSegment() || segment->isLastSegment()) ? planGeometry.getShape() : segment->getLane()->getLaneShape();
2025  // calculate contour and draw dotted geometry (always with double width)
2026  if (segment->isFirstSegment()) {
2027  segment->getContour()->calculateContourExtrudedShape(s, d, myPlanElement, shape, drawingWidth, 1, true, false, 0);
2028  } else if (segment->isLastSegment()) {
2029  segment->getContour()->calculateContourExtrudedShape(s, d, myPlanElement, shape, drawingWidth, 1, false, false, 0);
2030  // calculate contour for end
2031  myPlanContourEnd.calculateContourCircleShape(s, d, myPlanElement, getPlanAttributePosition(GNE_ATTR_PLAN_GEOMETRY_ENDPOS), 2 * endPosRadius, 1);
2032  } else {
2033  segment->getContour()->calculateContourExtrudedShape(s, d, myPlanElement, shape, drawingWidth, 1, false, false, 0);
2034  }
2035  }
2036  // check if draw plan parent
2037  if (planParent->getPreviousChildDemandElement(myPlanElement) == nullptr) {
2038  planParent->drawGL(s);
2039  }
2040 }
2041 
2042 
2043 void
2044 GNEDemandElementPlan::drawPlanJunctionPartial(const bool drawPlan, const GUIVisualizationSettings& s, const GNEPathManager::Segment* segment,
2045  const double offsetFront, const double planWidth, const RGBColor& planColor, const RGBColor& planSelectedColor) const {
2046  // get view net
2047  auto viewNet = myPlanElement->getNet()->getViewNet();
2048  // get tag property
2049  const auto& tagProperty = myPlanElement->getTagProperty();
2050  // get plan parent
2051  const GNEDemandElement* planParent = myPlanElement->getParentDemandElements().front();
2052  // check if draw plan elements can be drawn
2053  if (drawPlan && myPlanElement->getNet()->getPathManager()->getPathDraw()->checkDrawPathGeometry(s, segment, tagProperty.getTag())) {
2054  // draw boundary
2055  if (tagProperty.isPlacedInRTree() && s.drawBoundaries) {
2056  GLHelper::drawBoundary(s, getPlanCenteringBoundary());
2057  }
2058  // get detail level
2059  const auto d = s.getDetailLevel(1);
2060  // get inspected attribute carriers
2061  const auto& inspectedACs = viewNet->getInspectedAttributeCarriers();
2062  // get inspected plan
2063  const GNEAttributeCarrier* planInspected = (inspectedACs.size() > 0) ? inspectedACs.front() : nullptr;
2064  // calculate path width double
2065  const double pathWidthDouble = s.addSize.getExaggeration(s, segment->getLane()) * planWidth * 2;
2066  // check if draw with double width
2067  const bool drawWithDoubleWidth = ((planInspected == myPlanElement) || (planInspected == planParent) || gViewObjectsHandler.isElementSelected(myPlanElement));
2068  // draw geometry only if we'rent in drawForObjectUnderCursor mode
2069  if (!s.drawForViewObjectsHandler) {
2070  // push a draw matrix
2071  GLHelper::pushMatrix();
2072  // Start with the drawing of the area traslating matrix to origin
2073  viewNet->drawTranslateFrontAttributeCarrier(myPlanElement, myPlanElement->getType(), offsetFront);
2074  // Set plan color
2075  GLHelper::setColor(myPlanElement->drawUsingSelectColor() ? planSelectedColor : planColor);
2076  // check if draw lane2lane connection or a red line
2077  if (segment->getPreviousLane() && segment->getNextLane()) {
2078  if (segment->getPreviousLane()->getLane2laneConnections().exist(segment->getNextLane())) {
2079  // obtain lane2lane geometry
2080  const GUIGeometry& lane2laneGeometry = segment->getPreviousLane()->getLane2laneConnections().getLane2laneGeometry(segment->getNextLane());
2081  // draw lane2lane
2082  GUIGeometry::drawGeometry(d, lane2laneGeometry, pathWidthDouble * (drawWithDoubleWidth ? 1 : 0.5));
2083  } else {
2084  // Set invalid plan color
2085  GLHelper::setColor(RGBColor::RED);
2086  // draw line between end of first shape and first position of second shape
2087  GLHelper::drawBoxLines({segment->getPreviousLane()->getLaneShape().back(), segment->getNextLane()->getLaneShape().front()}, (0.5 * pathWidthDouble * (drawWithDoubleWidth ? 1 : 0.5)));
2088  }
2089  } else if (segment->getPreviousLane()) {
2090  // draw line between center of junction and last lane shape
2091  GLHelper::drawBoxLines({segment->getPreviousLane()->getLaneShape().back(), myPlanElement->getParentJunctions().back()->getPositionInView()}, pathWidthDouble * (drawWithDoubleWidth ? 1 : 0.5));
2092  } else if (segment->getNextLane()) {
2093  // draw line between center of junction and first lane shape
2094  GLHelper::drawBoxLines({myPlanElement->getParentJunctions().front()->getPositionInView(), segment->getNextLane()->getLaneShape().front()}, pathWidthDouble * (drawWithDoubleWidth ? 1 : 0.5));
2095  }
2096  // Pop last matrix
2097  GLHelper::popMatrix();
2098  // draw lock icon
2099  GNEViewNetHelper::LockIcon::drawLockIcon(d, myPlanElement, myPlanElement->getType(), myPlanElement->getPositionInView(), 0.5);
2100  // draw dotted contour
2101  segment->getContour()->drawDottedContours(s, d, myPlanElement, s.dottedContourSettings.segmentWidth, true);
2102  }
2103  // check if shape dotted contour has to be drawn
2104  if (segment->getPreviousLane() && segment->getNextLane()) {
2105  if (segment->getPreviousLane()->getLane2laneConnections().exist(segment->getNextLane())) {
2106  // get shape
2107  const auto& shape = segment->getPreviousLane()->getLane2laneConnections().getLane2laneGeometry(segment->getNextLane()).getShape();
2108  // calculate contour and draw dotted geometry (always with double width)
2109  segment->getContour()->calculateContourExtrudedShape(s, d, myPlanElement, shape, pathWidthDouble, 1, false, false, 0);
2110  }
2111  } else if (segment->getPreviousLane()) {
2112  segment->getContour()->calculateContourExtrudedShape(s, d, myPlanElement, {segment->getPreviousLane()->getLaneShape().back(), myPlanElement->getParentJunctions().back()->getPositionInView()},
2113  pathWidthDouble, 1, false, true, 0);
2114  } else if (segment->getNextLane()) {
2115  segment->getContour()->calculateContourExtrudedShape(s, d, myPlanElement, {myPlanElement->getParentJunctions().front()->getPositionInView(), segment->getNextLane()->getLaneShape().front()},
2116  pathWidthDouble, 1, true, false, 0);
2117  }
2118  }
2119  // check if draw plan parent
2120  if (planParent->getPreviousChildDemandElement(myPlanElement) == nullptr) {
2121  planParent->drawGL(s);
2122  }
2123 }
2124 
2125 
2126 GNEDemandElement::Problem
2127 GNEDemandElementPlan::isPlanPersonValid() const {
2128  // get previous plan
2129  const auto previousPlan = myPlanElement->getParentDemandElements().at(0)->getPreviousChildDemandElement(myPlanElement);
2130  if (previousPlan) {
2131  // get previous lane
2132  const auto previousLastLane = previousPlan->getLastPathLane();
2133  // get first lane
2134  const auto firstLane = myPlanElement->getFirstPathLane();
2135  // compare edges
2136  if (previousLastLane && firstLane && (previousLastLane->getParentEdge() != firstLane->getParentEdge())) {
2137  return GNEDemandElement::Problem::DISCONNECTED_PLAN;
2138  }
2139  // in the future, check more elements
2140  }
2141  // get next child
2142  const auto nextPlan = myPlanElement->getParentDemandElements().at(0)->getNextChildDemandElement(myPlanElement);
2143  if (nextPlan) {
2144  // get previous lane
2145  const auto nextFirstLane = nextPlan->getFirstPathLane();
2146  // get first lane
2147  const auto lastLane = myPlanElement->getLastPathLane();
2148  // compare edges
2149  if (nextFirstLane && lastLane && (nextFirstLane->getParentEdge() != lastLane->getParentEdge())) {
2150  return GNEDemandElement::Problem::DISCONNECTED_PLAN;
2151  }
2152  // in the future, check more elements
2153  }
2154  // all ok, then return true
2155  return GNEDemandElement::Problem::OK;
2156 }
2157 
2158 
2159 std::string
2160 GNEDemandElementPlan::getPersonPlanProblem() const {
2161  // get previous plan
2162  const auto previousPlan = myPlanElement->getParentDemandElements().at(0)->getPreviousChildDemandElement(myPlanElement);
2163  if (previousPlan) {
2164  // get previous lane
2165  const auto previousLastLane = previousPlan->getLastPathLane();
2166  // get first lane
2167  const auto firstLane = myPlanElement->getLastPathLane();
2168  // compare edges
2169  if (previousLastLane && firstLane && (previousLastLane->getParentEdge() != firstLane->getParentEdge())) {
2170  return TLF("Edge '%' is not consecutive with edge '%'", previousLastLane->getParentEdge()->getID(), firstLane->getParentEdge()->getID());
2171  }
2172  // in the future, check more elements
2173  }
2174  // get next child
2175  const auto nextPlan = myPlanElement->getParentDemandElements().at(0)->getNextChildDemandElement(myPlanElement);
2176  if (nextPlan) {
2177  // get previous lane
2178  const auto nextFirstLane = nextPlan->getFirstPathLane();
2179  // get first lane
2180  const auto lastLane = myPlanElement->getLastPathLane();
2181  // compare edges
2182  if (nextFirstLane && lastLane && (nextFirstLane->getParentEdge() != lastLane->getParentEdge())) {
2183  return TLF("Edge '%' is not consecutive with edge '%'", nextFirstLane->getParentEdge()->getID(), lastLane->getParentEdge()->getID());
2184  }
2185  // in the future, check more elements
2186  }
2187  // undefined problem
2188  return "undefined problem";
2189 }
2190 
2191 
2192 double
2193 GNEDemandElementPlan::getEndPosRadius(const GUIVisualizationSettings& s, const GNEPathManager::Segment* segment, const bool drawHalfWidth) const {
2194  // check if myPlanElement is the last segment
2195  if (segment->isLastSegment()) {
2196  // calculate circle width
2197  const double circleRadius = (drawHalfWidth ? myArrivalPositionDiameter * 0.5 : myArrivalPositionDiameter);
2198  return circleRadius * MIN2((double)0.5, s.laneWidthExaggeration);
2199  } else {
2200  return -1;
2201  }
2202 }
2203 
2204 
2205 void
2206 GNEDemandElementPlan::drawFromArrow(const GUIVisualizationSettings& s, const GNELane* lane, const GNEPathManager::Segment* segment) const {
2207  // draw ifcurrent amd next segment is placed over lanes
2208  if (segment->getNextLane()) {
2209  // get firstPosition (last position of current lane shape)
2210  const Position from = lane->getLaneShape().back();
2211  // get lastPosition (first position of next lane shape)
2212  const Position to = segment->getNextLane()->getLaneShape().front();
2213  // push draw matrix
2214  GLHelper::pushMatrix();
2215  // move front
2216  glTranslated(0, 0, 4);
2217  // draw child line
2218  GUIGeometry::drawChildLine(s, from, to, RGBColor::RED, myPlanElement->isAttributeCarrierSelected(), .05);
2219  // pop draw matrix
2220  GLHelper::popMatrix();
2221  }
2222 }
2223 
2224 
2225 void
2226 GNEDemandElementPlan::drawToArrow(const GUIVisualizationSettings& s, const GNELane* lane, const GNEPathManager::Segment* segment) const {
2227  // draw the line if previos segment and current segment is placed over lanes
2228  if (segment->getPreviousLane()) {
2229  // get firstPosition (last position of current lane shape)
2230  const Position from = lane->getLaneShape().front();
2231  // get lastPosition (first position of next lane shape)
2232  const Position to = segment->getPreviousLane()->getLaneShape().back();
2233  // push draw matrix
2234  GLHelper::pushMatrix();
2235  // move front
2236  glTranslated(0, 0, 4);
2237  // draw child line
2238  GUIGeometry::drawChildLine(s, from, to, RGBColor::RED, myPlanElement->isAttributeCarrierSelected(), .05);
2239  // pop draw matrix
2240  GLHelper::popMatrix();
2241  }
2242 }
2243 
2244 
2245 void
2246 GNEDemandElementPlan::drawEndPosition(const GUIVisualizationSettings& s, const GUIVisualizationSettings::Detail d, const double endPosRadius) const {
2247  // check if myPlanElement is the last segment
2248  if (!s.drawForRectangleSelection && (endPosRadius > 0)) {
2249  const Position geometryEndPos = getPlanAttributePosition(GNE_ATTR_PLAN_GEOMETRY_ENDPOS);
2250  // push draw matrix
2251  GLHelper::pushMatrix();
2252  // translate to pos and move to
2253  glTranslated(geometryEndPos.x(), geometryEndPos.y(), 4);
2254  // resolution of drawn circle depending of the zoom (To improve smothness)
2255  GLHelper::drawFilledCircleDetailled(d, endPosRadius);
2256  // pop draw matrix
2257  GLHelper::popMatrix();
2258  }
2259 }
2260 
2261 
2262 bool
2263 GNEDemandElementPlan::replacePlanParent(const std::string& newParentID) {
2264  std::vector<SumoXMLTag> tags;
2265  if (myPlanElement->myTagProperty.isPlanPerson()) {
2266  tags.push_back(SUMO_TAG_PERSON);
2267  tags.push_back(SUMO_TAG_PERSONFLOW);
2268  } else {
2269  tags.push_back(SUMO_TAG_CONTAINER);
2270  tags.push_back(SUMO_TAG_CONTAINERFLOW);
2271  }
2272  // search new parent and set it
2273  for (const auto& tag : tags) {
2274  if (myPlanElement->getNet()->getAttributeCarriers()->retrieveDemandElement(tag, newParentID, false) != nullptr) {
2275  myPlanElement->replaceDemandElementParent(tag, newParentID, 0);
2276  return true;
2277  }
2278  }
2279  throw ProcessError("Invalid new parent ID");
2280 }
2281 
2282 /****************************************************************************/
GNEChange_Attribute.h
MID_COPY_TYPED_NAME
@ MID_COPY_TYPED_NAME
Copy typed object name - popup entry.
Definition: GUIAppEnum.h:455
MID_COPY_NAME
@ MID_COPY_NAME
Copy object name - popup entry.
Definition: GUIAppEnum.h:453
GLO_TAZ
@ GLO_TAZ
Traffic Assignment Zones (TAZs)
Definition: GUIGlObjectTypes.h:244
gViewObjectsHandler
GUIViewObjectsHandler gViewObjectsHandler
Definition: GUIGlobalViewObjectsHandler.cpp:28
GUIIcon::RIDE_JUNCTION
@ RIDE_JUNCTION
GUIIcon::RIDE_CHARGINGSTATION
@ RIDE_CHARGINGSTATION
GUIIcon::WALK_CONTAINERSTOP
@ WALK_CONTAINERSTOP
GUIIcon::PERSONTRIP_JUNCTION
@ PERSONTRIP_JUNCTION
GUIIcon::TRANSHIP_BUSSTOP
@ TRANSHIP_BUSSTOP
GUIIcon::TRANSHIP_CHARGINGSTATION
@ TRANSHIP_CHARGINGSTATION
GUIIcon::TRANSHIP_TRAINSTOP
@ TRANSHIP_TRAINSTOP
GUIIcon::TRANSHIP_TAZ
@ TRANSHIP_TAZ
GUIIcon::PERSONTRIP_TRAINSTOP
@ PERSONTRIP_TRAINSTOP
GUIIcon::WALK_TRAINSTOP
@ WALK_TRAINSTOP
GUIIcon::PERSONTRIP_BUSSTOP
@ PERSONTRIP_BUSSTOP
GUIIcon::TRANSPORT_TRAINSTOP
@ TRANSPORT_TRAINSTOP
GUIIcon::TRANSHIP_PARKINGAREA
@ TRANSHIP_PARKINGAREA
GUIIcon::TRANSPORT_CONTAINERSTOP
@ TRANSPORT_CONTAINERSTOP
GUIIcon::PERSONTRIP_CHARGINGSTATION
@ PERSONTRIP_CHARGINGSTATION
GUIIcon::TRANSHIP_EDGE
@ TRANSHIP_EDGE
GUIIcon::TRANSHIP_EDGES
@ TRANSHIP_EDGES
GUIIcon::PERSONTRIP_CONTAINERSTOP
@ PERSONTRIP_CONTAINERSTOP
GUIIcon::WALK_BUSSTOP
@ WALK_BUSSTOP
GUIIcon::TRANSHIP_CONTAINERSTOP
@ TRANSHIP_CONTAINERSTOP
GUIIcon::TRANSPORT_EDGE
@ TRANSPORT_EDGE
GUIIcon::RIDE_BUSSTOP
@ RIDE_BUSSTOP
GUIIcon::RIDE_CONTAINERSTOP
@ RIDE_CONTAINERSTOP
GUIIcon::WALK_CHARGINGSTATION
@ WALK_CHARGINGSTATION
GUIIcon::WALK_PARKINGAREA
@ WALK_PARKINGAREA
GUIIcon::TRANSPORT_CHARGINGSTATION
@ TRANSPORT_CHARGINGSTATION
GUIIcon::TRANSPORT_BUSSTOP
@ TRANSPORT_BUSSTOP
GUIIcon::TRANSPORT_PARKINGAREA
@ TRANSPORT_PARKINGAREA
GUIIcon::PERSONTRIP_PARKINGAREA
@ PERSONTRIP_PARKINGAREA
GUIIcon::RIDE_PARKINGAREA
@ RIDE_PARKINGAREA
GUIIcon::RIDE_TRAINSTOP
@ RIDE_TRAINSTOP
GUIIcon::TRANSPORT_TAZ
@ TRANSPORT_TAZ
GUIIcon::PERSONTRIP_TAZ
@ PERSONTRIP_TAZ
GUIIcon::PERSONTRIP_EDGE
@ PERSONTRIP_EDGE
GUIIcon::TRANSHIP_JUNCTION
@ TRANSHIP_JUNCTION
GUIIcon::WALK_JUNCTION
@ WALK_JUNCTION
GUIIcon::TRANSPORT_JUNCTION
@ TRANSPORT_JUNCTION
TLF
#define TLF(string,...)
Definition: MsgHandler.h:317
GNE_TAG_RIDE_CHARGINGSTATION_CHARGINGSTATION
@ GNE_TAG_RIDE_CHARGINGSTATION_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:637
GNE_TAG_TRANSHIP_TAZ_TAZ
@ GNE_TAG_TRANSHIP_TAZ_TAZ
Definition: SUMOXMLDefinitions.h:730
GNE_TAG_TRANSPORT_CONTAINERSTOP_TRAINSTOP
@ GNE_TAG_TRANSPORT_CONTAINERSTOP_TRAINSTOP
Definition: SUMOXMLDefinitions.h:700
GNE_TAG_TRANSPORT_CONTAINERSTOP_BUSSTOP
@ GNE_TAG_TRANSPORT_CONTAINERSTOP_BUSSTOP
Definition: SUMOXMLDefinitions.h:699
GNE_TAG_TRANSHIP_PARKINGAREA_BUSSTOP
@ GNE_TAG_TRANSHIP_PARKINGAREA_BUSSTOP
Definition: SUMOXMLDefinitions.h:780
GNE_TAG_TRANSPORT_TAZ_CONTAINERSTOP
@ GNE_TAG_TRANSPORT_TAZ_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:669
GNE_TAG_TRANSHIP_PARKINGAREA_CHARGINGSTATION
@ GNE_TAG_TRANSHIP_PARKINGAREA_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:783
GNE_TAG_RIDE_EDGE_TAZ
@ GNE_TAG_RIDE_EDGE_TAZ
Definition: SUMOXMLDefinitions.h:584
GNE_TAG_WALK_BUSSTOP_BUSSTOP
@ GNE_TAG_WALK_BUSSTOP_BUSSTOP
Definition: SUMOXMLDefinitions.h:543
GNE_TAG_TRANSPORT_JUNCTION_CHARGINGSTATION
@ GNE_TAG_TRANSPORT_JUNCTION_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:678
GNE_TAG_TRANSHIP_JUNCTION_EDGE
@ GNE_TAG_TRANSHIP_JUNCTION_EDGE
Definition: SUMOXMLDefinitions.h:737
GNE_TAG_PERSONTRIP_EDGE_EDGE
@ GNE_TAG_PERSONTRIP_EDGE_EDGE
Definition: SUMOXMLDefinitions.h:451
GNE_TAG_PERSONTRIP_TAZ_EDGE
@ GNE_TAG_PERSONTRIP_TAZ_EDGE
Definition: SUMOXMLDefinitions.h:459
GNE_TAG_TRANSHIP_JUNCTION_CONTAINERSTOP
@ GNE_TAG_TRANSHIP_JUNCTION_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:742
GNE_TAG_PERSONTRIP_EDGE_CONTAINERSTOP
@ GNE_TAG_PERSONTRIP_EDGE_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:456
GNE_TAG_WALK_EDGE_TAZ
@ GNE_TAG_WALK_EDGE_TAZ
Definition: SUMOXMLDefinitions.h:517
GNE_TAG_WALK_PARKINGAREA_CHARGINGSTATION
@ GNE_TAG_WALK_PARKINGAREA_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:578
GNE_TAG_WALK_CHARGINGSTATION_JUNCTION
@ GNE_TAG_WALK_CHARGINGSTATION_JUNCTION
Definition: SUMOXMLDefinitions.h:566
GNE_TAG_RIDE_CHARGINGSTATION_TAZ
@ GNE_TAG_RIDE_CHARGINGSTATION_TAZ
Definition: SUMOXMLDefinitions.h:632
GNE_TAG_PERSONTRIP_CONTAINERSTOP_TAZ
@ GNE_TAG_PERSONTRIP_CONTAINERSTOP_TAZ
Definition: SUMOXMLDefinitions.h:492
GNE_TAG_RIDE_CONTAINERSTOP_BUSSTOP
@ GNE_TAG_RIDE_CONTAINERSTOP_BUSSTOP
Definition: SUMOXMLDefinitions.h:626
GNE_TAG_TRANSPORT_BUSSTOP_JUNCTION
@ GNE_TAG_TRANSPORT_BUSSTOP_JUNCTION
Definition: SUMOXMLDefinitions.h:682
GNE_TAG_RIDE_BUSSTOP_BUSSTOP
@ GNE_TAG_RIDE_BUSSTOP_BUSSTOP
Definition: SUMOXMLDefinitions.h:610
GNE_TAG_WALK_PARKINGAREA_CONTAINERSTOP
@ GNE_TAG_WALK_PARKINGAREA_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:577
GNE_TAG_PERSONTRIP_TAZ_CONTAINERSTOP
@ GNE_TAG_PERSONTRIP_TAZ_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:464
GNE_TAG_TRANSHIP_CHARGINGSTATION_BUSSTOP
@ GNE_TAG_TRANSHIP_CHARGINGSTATION_BUSSTOP
Definition: SUMOXMLDefinitions.h:772
GNE_TAG_PERSONTRIP_CHARGINGSTATION_TRAINSTOP
@ GNE_TAG_PERSONTRIP_CHARGINGSTATION_TRAINSTOP
Definition: SUMOXMLDefinitions.h:503
GNE_TAG_PERSONTRIP_EDGE_JUNCTION
@ GNE_TAG_PERSONTRIP_EDGE_JUNCTION
Definition: SUMOXMLDefinitions.h:453
GNE_TAG_TRANSPORT_CHARGINGSTATION_JUNCTION
@ GNE_TAG_TRANSPORT_CHARGINGSTATION_JUNCTION
Definition: SUMOXMLDefinitions.h:706
GNE_TAG_TRANSHIP_TRAINSTOP_CHARGINGSTATION
@ GNE_TAG_TRANSHIP_TRAINSTOP_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:759
GNE_TAG_RIDE_CONTAINERSTOP_CONTAINERSTOP
@ GNE_TAG_RIDE_CONTAINERSTOP_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:628
GNE_TAG_TRANSHIP_TRAINSTOP_EDGE
@ GNE_TAG_TRANSHIP_TRAINSTOP_EDGE
Definition: SUMOXMLDefinitions.h:753
GNE_TAG_WALK_TAZ_BUSSTOP
@ GNE_TAG_WALK_TAZ_BUSSTOP
Definition: SUMOXMLDefinitions.h:527
GNE_TAG_PERSONTRIP_EDGE_PARKINGAREA
@ GNE_TAG_PERSONTRIP_EDGE_PARKINGAREA
Definition: SUMOXMLDefinitions.h:458
GNE_TAG_PERSONTRIP_TRAINSTOP_EDGE
@ GNE_TAG_PERSONTRIP_TRAINSTOP_EDGE
Definition: SUMOXMLDefinitions.h:483
GNE_TAG_PERSONTRIP_TRAINSTOP_CONTAINERSTOP
@ GNE_TAG_PERSONTRIP_TRAINSTOP_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:488
GNE_TAG_PERSONTRIP_PARKINGAREA_TRAINSTOP
@ GNE_TAG_PERSONTRIP_PARKINGAREA_TRAINSTOP
Definition: SUMOXMLDefinitions.h:511
GNE_TAG_STOPCONTAINER_TRAINSTOP
@ GNE_TAG_STOPCONTAINER_TRAINSTOP
Definition: SUMOXMLDefinitions.h:790
GNE_TAG_RIDE_JUNCTION_BUSSTOP
@ GNE_TAG_RIDE_JUNCTION_BUSSTOP
Definition: SUMOXMLDefinitions.h:602
GNE_TAG_RIDE_PARKINGAREA_CONTAINERSTOP
@ GNE_TAG_RIDE_PARKINGAREA_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:644
GNE_TAG_PERSONTRIP_CHARGINGSTATION_PARKINGAREA
@ GNE_TAG_PERSONTRIP_CHARGINGSTATION_PARKINGAREA
Definition: SUMOXMLDefinitions.h:506
GNE_TAG_PERSONTRIP_TRAINSTOP_PARKINGAREA
@ GNE_TAG_PERSONTRIP_TRAINSTOP_PARKINGAREA
Definition: SUMOXMLDefinitions.h:490
GNE_TAG_TRANSPORT_TAZ_PARKINGAREA
@ GNE_TAG_TRANSPORT_TAZ_PARKINGAREA
Definition: SUMOXMLDefinitions.h:671
GNE_TAG_PERSONTRIP_TAZ_CHARGINGSTATION
@ GNE_TAG_PERSONTRIP_TAZ_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:465
GNE_TAG_RIDE_CONTAINERSTOP_EDGE
@ GNE_TAG_RIDE_CONTAINERSTOP_EDGE
Definition: SUMOXMLDefinitions.h:623
GNE_TAG_TRANSHIP_TAZ_EDGE
@ GNE_TAG_TRANSHIP_TAZ_EDGE
Definition: SUMOXMLDefinitions.h:729
GNE_TAG_WALK_BUSSTOP_CHARGINGSTATION
@ GNE_TAG_WALK_BUSSTOP_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:546
GNE_TAG_PERSONTRIP_BUSSTOP_EDGE
@ GNE_TAG_PERSONTRIP_BUSSTOP_EDGE
Definition: SUMOXMLDefinitions.h:475
GNE_TAG_WALK_TRAINSTOP_CHARGINGSTATION
@ GNE_TAG_WALK_TRAINSTOP_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:554
SUMO_TAG_TAZ
@ SUMO_TAG_TAZ
a traffic assignment zone
Definition: SUMOXMLDefinitions.h:181
GNE_TAG_WALK_PARKINGAREA_TRAINSTOP
@ GNE_TAG_WALK_PARKINGAREA_TRAINSTOP
Definition: SUMOXMLDefinitions.h:576
GNE_TAG_WALK_PARKINGAREA_PARKINGAREA
@ GNE_TAG_WALK_PARKINGAREA_PARKINGAREA
Definition: SUMOXMLDefinitions.h:579
GNE_TAG_TRANSPORT_EDGE_TRAINSTOP
@ GNE_TAG_TRANSPORT_EDGE_TRAINSTOP
Definition: SUMOXMLDefinitions.h:660
GNE_TAG_WALK_BUSSTOP_TRAINSTOP
@ GNE_TAG_WALK_BUSSTOP_TRAINSTOP
Definition: SUMOXMLDefinitions.h:544
GNE_TAG_TRANSHIP_EDGE_CHARGINGSTATION
@ GNE_TAG_TRANSHIP_EDGE_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:727
GNE_TAG_PERSONTRIP_TAZ_TRAINSTOP
@ GNE_TAG_PERSONTRIP_TAZ_TRAINSTOP
Definition: SUMOXMLDefinitions.h:463
GNE_TAG_TRANSPORT_CONTAINERSTOP_CHARGINGSTATION
@ GNE_TAG_TRANSPORT_CONTAINERSTOP_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:702
GNE_TAG_TRANSPORT_CHARGINGSTATION_TAZ
@ GNE_TAG_TRANSPORT_CHARGINGSTATION_TAZ
Definition: SUMOXMLDefinitions.h:705
GNE_TAG_WALK_TAZ_CONTAINERSTOP
@ GNE_TAG_WALK_TAZ_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:529
GNE_TAG_WALK_PARKINGAREA_JUNCTION
@ GNE_TAG_WALK_PARKINGAREA_JUNCTION
Definition: SUMOXMLDefinitions.h:574
GNE_TAG_WALK_CONTAINERSTOP_EDGE
@ GNE_TAG_WALK_CONTAINERSTOP_EDGE
Definition: SUMOXMLDefinitions.h:556
GNE_TAG_TRANSHIP_JUNCTION_BUSSTOP
@ GNE_TAG_TRANSHIP_JUNCTION_BUSSTOP
Definition: SUMOXMLDefinitions.h:740
GNE_TAG_PERSONTRIP_EDGE_CHARGINGSTATION
@ GNE_TAG_PERSONTRIP_EDGE_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:457
GNE_TAG_TRANSPORT_EDGE_PARKINGAREA
@ GNE_TAG_TRANSPORT_EDGE_PARKINGAREA
Definition: SUMOXMLDefinitions.h:663
GNE_TAG_TRANSPORT_TRAINSTOP_JUNCTION
@ GNE_TAG_TRANSPORT_TRAINSTOP_JUNCTION
Definition: SUMOXMLDefinitions.h:690
GNE_TAG_TRANSHIP_PARKINGAREA_JUNCTION
@ GNE_TAG_TRANSHIP_PARKINGAREA_JUNCTION
Definition: SUMOXMLDefinitions.h:779
GNE_TAG_TRANSHIP_BUSSTOP_CHARGINGSTATION
@ GNE_TAG_TRANSHIP_BUSSTOP_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:751
GNE_TAG_TRANSPORT_TAZ_TRAINSTOP
@ GNE_TAG_TRANSPORT_TAZ_TRAINSTOP
Definition: SUMOXMLDefinitions.h:668
GNE_TAG_WALK_EDGE_PARKINGAREA
@ GNE_TAG_WALK_EDGE_PARKINGAREA
Definition: SUMOXMLDefinitions.h:523
GNE_TAG_TRANSPORT_EDGE_BUSSTOP
@ GNE_TAG_TRANSPORT_EDGE_BUSSTOP
Definition: SUMOXMLDefinitions.h:659
GNE_TAG_TRANSPORT_CONTAINERSTOP_EDGE
@ GNE_TAG_TRANSPORT_CONTAINERSTOP_EDGE
Definition: SUMOXMLDefinitions.h:696
GNE_TAG_TRANSPORT_CHARGINGSTATION_PARKINGAREA
@ GNE_TAG_TRANSPORT_CHARGINGSTATION_PARKINGAREA
Definition: SUMOXMLDefinitions.h:711
SUMO_TAG_NOTHING
@ SUMO_TAG_NOTHING
invalid tag, must be the last one
Definition: SUMOXMLDefinitions.h:797
GNE_TAG_WALK_PARKINGAREA_EDGE
@ GNE_TAG_WALK_PARKINGAREA_EDGE
Definition: SUMOXMLDefinitions.h:572
GNE_TAG_TRANSHIP_EDGE_EDGE
@ GNE_TAG_TRANSHIP_EDGE_EDGE
Definition: SUMOXMLDefinitions.h:721
GNE_TAG_RIDE_TAZ_EDGE
@ GNE_TAG_RIDE_TAZ_EDGE
Definition: SUMOXMLDefinitions.h:591
GNE_TAG_RIDE_TRAINSTOP_JUNCTION
@ GNE_TAG_RIDE_TRAINSTOP_JUNCTION
Definition: SUMOXMLDefinitions.h:617
GNE_TAG_WALK_EDGES
@ GNE_TAG_WALK_EDGES
Definition: SUMOXMLDefinitions.h:580
GNE_TAG_RIDE_TRAINSTOP_CONTAINERSTOP
@ GNE_TAG_RIDE_TRAINSTOP_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:620
GNE_TAG_TRANSPORT_JUNCTION_PARKINGAREA
@ GNE_TAG_TRANSPORT_JUNCTION_PARKINGAREA
Definition: SUMOXMLDefinitions.h:679
GNE_TAG_RIDE_CHARGINGSTATION_EDGE
@ GNE_TAG_RIDE_CHARGINGSTATION_EDGE
Definition: SUMOXMLDefinitions.h:631
GNE_TAG_RIDE_CHARGINGSTATION_CONTAINERSTOP
@ GNE_TAG_RIDE_CHARGINGSTATION_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:636
GNE_TAG_WALK_CONTAINERSTOP_CHARGINGSTATION
@ GNE_TAG_WALK_CONTAINERSTOP_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:562
SUMO_TAG_CONTAINERFLOW
@ SUMO_TAG_CONTAINERFLOW
Definition: SUMOXMLDefinitions.h:373
GNE_TAG_TRANSHIP_PARKINGAREA_CONTAINERSTOP
@ GNE_TAG_TRANSHIP_PARKINGAREA_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:782
GNE_TAG_TRANSPORT_TRAINSTOP_TAZ
@ GNE_TAG_TRANSPORT_TRAINSTOP_TAZ
Definition: SUMOXMLDefinitions.h:689
GNE_TAG_WALK_BUSSTOP_JUNCTION
@ GNE_TAG_WALK_BUSSTOP_JUNCTION
Definition: SUMOXMLDefinitions.h:542
GNE_TAG_TRANSHIP_CHARGINGSTATION_TRAINSTOP
@ GNE_TAG_TRANSHIP_CHARGINGSTATION_TRAINSTOP
Definition: SUMOXMLDefinitions.h:773
GNE_TAG_TRANSHIP_EDGE_CONTAINERSTOP
@ GNE_TAG_TRANSHIP_EDGE_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:726
GNE_TAG_WALK_CONTAINERSTOP_JUNCTION
@ GNE_TAG_WALK_CONTAINERSTOP_JUNCTION
Definition: SUMOXMLDefinitions.h:558
GNE_TAG_TRANSPORT_PARKINGAREA_PARKINGAREA
@ GNE_TAG_TRANSPORT_PARKINGAREA_PARKINGAREA
Definition: SUMOXMLDefinitions.h:719
GNE_TAG_RIDE_EDGE_JUNCTION
@ GNE_TAG_RIDE_EDGE_JUNCTION
Definition: SUMOXMLDefinitions.h:585
GNE_TAG_TRANSPORT_CHARGINGSTATION_TRAINSTOP
@ GNE_TAG_TRANSPORT_CHARGINGSTATION_TRAINSTOP
Definition: SUMOXMLDefinitions.h:708
GNE_TAG_TRANSPORT_TRAINSTOP_TRAINSTOP
@ GNE_TAG_TRANSPORT_TRAINSTOP_TRAINSTOP
Definition: SUMOXMLDefinitions.h:692
GNE_TAG_RIDE_PARKINGAREA_TAZ
@ GNE_TAG_RIDE_PARKINGAREA_TAZ
Definition: SUMOXMLDefinitions.h:640
GNE_TAG_WALK_CHARGINGSTATION_TRAINSTOP
@ GNE_TAG_WALK_CHARGINGSTATION_TRAINSTOP
Definition: SUMOXMLDefinitions.h:568
GNE_TAG_PERSONTRIP_BUSSTOP_CONTAINERSTOP
@ GNE_TAG_PERSONTRIP_BUSSTOP_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:480
GNE_TAG_TRANSPORT_TRAINSTOP_CONTAINERSTOP
@ GNE_TAG_TRANSPORT_TRAINSTOP_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:693
GNE_TAG_PERSONTRIP_PARKINGAREA_TAZ
@ GNE_TAG_PERSONTRIP_PARKINGAREA_TAZ
Definition: SUMOXMLDefinitions.h:508
GNE_TAG_STOPCONTAINER_EDGE
@ GNE_TAG_STOPCONTAINER_EDGE
Definition: SUMOXMLDefinitions.h:788
GNE_TAG_WALK_TRAINSTOP_TAZ
@ GNE_TAG_WALK_TRAINSTOP_TAZ
Definition: SUMOXMLDefinitions.h:549
GNE_TAG_PERSONTRIP_PARKINGAREA_JUNCTION
@ GNE_TAG_PERSONTRIP_PARKINGAREA_JUNCTION
Definition: SUMOXMLDefinitions.h:509
GNE_TAG_TRANSPORT_JUNCTION_BUSSTOP
@ GNE_TAG_TRANSPORT_JUNCTION_BUSSTOP
Definition: SUMOXMLDefinitions.h:675
GNE_TAG_TRANSHIP_JUNCTION_PARKINGAREA
@ GNE_TAG_TRANSHIP_JUNCTION_PARKINGAREA
Definition: SUMOXMLDefinitions.h:744
GNE_TAG_STOPCONTAINER_PARKINGAREA
@ GNE_TAG_STOPCONTAINER_PARKINGAREA
Definition: SUMOXMLDefinitions.h:793
GNE_TAG_PERSONTRIP_CONTAINERSTOP_TRAINSTOP
@ GNE_TAG_PERSONTRIP_CONTAINERSTOP_TRAINSTOP
Definition: SUMOXMLDefinitions.h:495
GNE_TAG_TRANSPORT_CHARGINGSTATION_CONTAINERSTOP
@ GNE_TAG_TRANSPORT_CHARGINGSTATION_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:709
GNE_TAG_TRANSPORT_TRAINSTOP_CHARGINGSTATION
@ GNE_TAG_TRANSPORT_TRAINSTOP_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:694
GNE_TAG_TRANSPORT_PARKINGAREA_CONTAINERSTOP
@ GNE_TAG_TRANSPORT_PARKINGAREA_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:717
GNE_TAG_STOPPERSON_BUSSTOP
@ GNE_TAG_STOPPERSON_BUSSTOP
Definition: SUMOXMLDefinitions.h:650
GNE_TAG_TRANSPORT_BUSSTOP_CONTAINERSTOP
@ GNE_TAG_TRANSPORT_BUSSTOP_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:685
SUMO_TAG_STOP
@ SUMO_TAG_STOP
stop for vehicles
Definition: SUMOXMLDefinitions.h:224
GNE_TAG_PERSONTRIP_BUSSTOP_TRAINSTOP
@ GNE_TAG_PERSONTRIP_BUSSTOP_TRAINSTOP
Definition: SUMOXMLDefinitions.h:479
GNE_TAG_RIDE_PARKINGAREA_BUSSTOP
@ GNE_TAG_RIDE_PARKINGAREA_BUSSTOP
Definition: SUMOXMLDefinitions.h:642
GNE_TAG_PERSONTRIP_CHARGINGSTATION_TAZ
@ GNE_TAG_PERSONTRIP_CHARGINGSTATION_TAZ
Definition: SUMOXMLDefinitions.h:500
GNE_TAG_RIDE_TAZ_TRAINSTOP
@ GNE_TAG_RIDE_TAZ_TRAINSTOP
Definition: SUMOXMLDefinitions.h:595
GNE_TAG_PERSONTRIP_CONTAINERSTOP_EDGE
@ GNE_TAG_PERSONTRIP_CONTAINERSTOP_EDGE
Definition: SUMOXMLDefinitions.h:491
GNE_TAG_TRANSHIP_CONTAINERSTOP_PARKINGAREA
@ GNE_TAG_TRANSHIP_CONTAINERSTOP_PARKINGAREA
Definition: SUMOXMLDefinitions.h:768
GNE_TAG_PERSONTRIP_JUNCTION_BUSSTOP
@ GNE_TAG_PERSONTRIP_JUNCTION_BUSSTOP
Definition: SUMOXMLDefinitions.h:470
GNE_TAG_TRANSHIP_BUSSTOP_CONTAINERSTOP
@ GNE_TAG_TRANSHIP_BUSSTOP_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:750
GNE_TAG_PERSONTRIP_CHARGINGSTATION_BUSSTOP
@ GNE_TAG_PERSONTRIP_CHARGINGSTATION_BUSSTOP
Definition: SUMOXMLDefinitions.h:502
GNE_TAG_TRANSPORT_PARKINGAREA_EDGE
@ GNE_TAG_TRANSPORT_PARKINGAREA_EDGE
Definition: SUMOXMLDefinitions.h:712
GNE_TAG_PERSONTRIP_TRAINSTOP_TAZ
@ GNE_TAG_PERSONTRIP_TRAINSTOP_TAZ
Definition: SUMOXMLDefinitions.h:484
GNE_TAG_RIDE_PARKINGAREA_JUNCTION
@ GNE_TAG_RIDE_PARKINGAREA_JUNCTION
Definition: SUMOXMLDefinitions.h:641
GNE_TAG_TRANSHIP_PARKINGAREA_TRAINSTOP
@ GNE_TAG_TRANSHIP_PARKINGAREA_TRAINSTOP
Definition: SUMOXMLDefinitions.h:781
GNE_TAG_RIDE_JUNCTION_JUNCTION
@ GNE_TAG_RIDE_JUNCTION_JUNCTION
Definition: SUMOXMLDefinitions.h:601
GNE_TAG_WALK_BUSSTOP_CONTAINERSTOP
@ GNE_TAG_WALK_BUSSTOP_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:545
GNE_TAG_RIDE_BUSSTOP_TAZ
@ GNE_TAG_RIDE_BUSSTOP_TAZ
Definition: SUMOXMLDefinitions.h:608
GNE_TAG_PERSONTRIP_TAZ_PARKINGAREA
@ GNE_TAG_PERSONTRIP_TAZ_PARKINGAREA
Definition: SUMOXMLDefinitions.h:466
GNE_TAG_TRANSHIP_BUSSTOP_JUNCTION
@ GNE_TAG_TRANSHIP_BUSSTOP_JUNCTION
Definition: SUMOXMLDefinitions.h:747
GNE_TAG_RIDE_JUNCTION_PARKINGAREA
@ GNE_TAG_RIDE_JUNCTION_PARKINGAREA
Definition: SUMOXMLDefinitions.h:606
GNE_TAG_TRANSPORT_EDGE_TAZ
@ GNE_TAG_TRANSPORT_EDGE_TAZ
Definition: SUMOXMLDefinitions.h:657
GNE_TAG_PERSONTRIP_CONTAINERSTOP_PARKINGAREA
@ GNE_TAG_PERSONTRIP_CONTAINERSTOP_PARKINGAREA
Definition: SUMOXMLDefinitions.h:498
GNE_TAG_WALK_JUNCTION_PARKINGAREA
@ GNE_TAG_WALK_JUNCTION_PARKINGAREA
Definition: SUMOXMLDefinitions.h:539
GNE_TAG_TRANSHIP_EDGE_TAZ
@ GNE_TAG_TRANSHIP_EDGE_TAZ
Definition: SUMOXMLDefinitions.h:722
GNE_TAG_RIDE_TRAINSTOP_TAZ
@ GNE_TAG_RIDE_TRAINSTOP_TAZ
Definition: SUMOXMLDefinitions.h:616
GNE_TAG_RIDE_TRAINSTOP_CHARGINGSTATION
@ GNE_TAG_RIDE_TRAINSTOP_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:621
GNE_TAG_WALK_CHARGINGSTATION_BUSSTOP
@ GNE_TAG_WALK_CHARGINGSTATION_BUSSTOP
Definition: SUMOXMLDefinitions.h:567
GNE_TAG_PERSONTRIP_JUNCTION_TRAINSTOP
@ GNE_TAG_PERSONTRIP_JUNCTION_TRAINSTOP
Definition: SUMOXMLDefinitions.h:471
GNE_TAG_RIDE_JUNCTION_TRAINSTOP
@ GNE_TAG_RIDE_JUNCTION_TRAINSTOP
Definition: SUMOXMLDefinitions.h:603
GNE_TAG_WALK_CONTAINERSTOP_TAZ
@ GNE_TAG_WALK_CONTAINERSTOP_TAZ
Definition: SUMOXMLDefinitions.h:557
GNE_TAG_PERSONTRIP_TRAINSTOP_BUSSTOP
@ GNE_TAG_PERSONTRIP_TRAINSTOP_BUSSTOP
Definition: SUMOXMLDefinitions.h:486
GNE_TAG_TRANSHIP_BUSSTOP_EDGE
@ GNE_TAG_TRANSHIP_BUSSTOP_EDGE
Definition: SUMOXMLDefinitions.h:745
GNE_TAG_TRANSHIP_TRAINSTOP_JUNCTION
@ GNE_TAG_TRANSHIP_TRAINSTOP_JUNCTION
Definition: SUMOXMLDefinitions.h:755
GNE_TAG_TRANSPORT_CHARGINGSTATION_CHARGINGSTATION
@ GNE_TAG_TRANSPORT_CHARGINGSTATION_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:710
GNE_TAG_TRANSHIP_EDGE_JUNCTION
@ GNE_TAG_TRANSHIP_EDGE_JUNCTION
Definition: SUMOXMLDefinitions.h:723
GNE_TAG_PERSONTRIP_BUSSTOP_JUNCTION
@ GNE_TAG_PERSONTRIP_BUSSTOP_JUNCTION
Definition: SUMOXMLDefinitions.h:477
GNE_TAG_TRANSHIP_EDGES
@ GNE_TAG_TRANSHIP_EDGES
Definition: SUMOXMLDefinitions.h:785
GNE_TAG_TRANSHIP_TAZ_TRAINSTOP
@ GNE_TAG_TRANSHIP_TAZ_TRAINSTOP
Definition: SUMOXMLDefinitions.h:733
GNE_TAG_WALK_JUNCTION_CONTAINERSTOP
@ GNE_TAG_WALK_JUNCTION_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:537
GNE_TAG_STOPCONTAINER_CONTAINERSTOP
@ GNE_TAG_STOPCONTAINER_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:791
GNE_TAG_RIDE_TAZ_CONTAINERSTOP
@ GNE_TAG_RIDE_TAZ_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:596
GNE_TAG_RIDE_BUSSTOP_TRAINSTOP
@ GNE_TAG_RIDE_BUSSTOP_TRAINSTOP
Definition: SUMOXMLDefinitions.h:611
GNE_TAG_TRANSHIP_CHARGINGSTATION_EDGE
@ GNE_TAG_TRANSHIP_CHARGINGSTATION_EDGE
Definition: SUMOXMLDefinitions.h:769
GNE_TAG_PERSONTRIP_EDGE_TRAINSTOP
@ GNE_TAG_PERSONTRIP_EDGE_TRAINSTOP
Definition: SUMOXMLDefinitions.h:455
GNE_TAG_RIDE_BUSSTOP_EDGE
@ GNE_TAG_RIDE_BUSSTOP_EDGE
Definition: SUMOXMLDefinitions.h:607
GNE_TAG_RIDE_TRAINSTOP_BUSSTOP
@ GNE_TAG_RIDE_TRAINSTOP_BUSSTOP
Definition: SUMOXMLDefinitions.h:618
GNE_TAG_TRANSPORT_CONTAINERSTOP_TAZ
@ GNE_TAG_TRANSPORT_CONTAINERSTOP_TAZ
Definition: SUMOXMLDefinitions.h:697
GNE_TAG_WALK_TRAINSTOP_EDGE
@ GNE_TAG_WALK_TRAINSTOP_EDGE
Definition: SUMOXMLDefinitions.h:548
GNE_TAG_RIDE_EDGE_EDGE
@ GNE_TAG_RIDE_EDGE_EDGE
Definition: SUMOXMLDefinitions.h:583
GNE_TAG_PERSONTRIP_PARKINGAREA_EDGE
@ GNE_TAG_PERSONTRIP_PARKINGAREA_EDGE
Definition: SUMOXMLDefinitions.h:507
GNE_TAG_TRANSPORT_BUSSTOP_CHARGINGSTATION
@ GNE_TAG_TRANSPORT_BUSSTOP_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:686
GNE_TAG_RIDE_JUNCTION_CONTAINERSTOP
@ GNE_TAG_RIDE_JUNCTION_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:604
GNE_TAG_TRANSPORT_PARKINGAREA_TAZ
@ GNE_TAG_TRANSPORT_PARKINGAREA_TAZ
Definition: SUMOXMLDefinitions.h:713
GNE_TAG_PERSONTRIP_PARKINGAREA_CONTAINERSTOP
@ GNE_TAG_PERSONTRIP_PARKINGAREA_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:512
GNE_TAG_PERSONTRIP_TRAINSTOP_TRAINSTOP
@ GNE_TAG_PERSONTRIP_TRAINSTOP_TRAINSTOP
Definition: SUMOXMLDefinitions.h:487
GNE_TAG_TRANSPORT_EDGE_EDGE
@ GNE_TAG_TRANSPORT_EDGE_EDGE
Definition: SUMOXMLDefinitions.h:656
GNE_TAG_WALK_EDGE_TRAINSTOP
@ GNE_TAG_WALK_EDGE_TRAINSTOP
Definition: SUMOXMLDefinitions.h:520
GNE_TAG_WALK_TAZ_CHARGINGSTATION
@ GNE_TAG_WALK_TAZ_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:530
GNE_TAG_TRANSPORT_EDGE_CONTAINERSTOP
@ GNE_TAG_TRANSPORT_EDGE_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:661
GNE_TAG_STOPCONTAINER_BUSSTOP
@ GNE_TAG_STOPCONTAINER_BUSSTOP
Definition: SUMOXMLDefinitions.h:789
GNE_TAG_WALK_JUNCTION_TAZ
@ GNE_TAG_WALK_JUNCTION_TAZ
Definition: SUMOXMLDefinitions.h:533
GNE_TAG_WALK_JUNCTION_CHARGINGSTATION
@ GNE_TAG_WALK_JUNCTION_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:538
GNE_TAG_WALK_CHARGINGSTATION_TAZ
@ GNE_TAG_WALK_CHARGINGSTATION_TAZ
Definition: SUMOXMLDefinitions.h:565
GNE_TAG_PERSONTRIP_TAZ_BUSSTOP
@ GNE_TAG_PERSONTRIP_TAZ_BUSSTOP
Definition: SUMOXMLDefinitions.h:462
GNE_TAG_RIDE_PARKINGAREA_CHARGINGSTATION
@ GNE_TAG_RIDE_PARKINGAREA_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:645
GNE_TAG_RIDE_BUSSTOP_JUNCTION
@ GNE_TAG_RIDE_BUSSTOP_JUNCTION
Definition: SUMOXMLDefinitions.h:609
GNE_TAG_PERSONTRIP_CHARGINGSTATION_JUNCTION
@ GNE_TAG_PERSONTRIP_CHARGINGSTATION_JUNCTION
Definition: SUMOXMLDefinitions.h:501
GNE_TAG_PERSONTRIP_CHARGINGSTATION_CHARGINGSTATION
@ GNE_TAG_PERSONTRIP_CHARGINGSTATION_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:505
GNE_TAG_WALK_JUNCTION_JUNCTION
@ GNE_TAG_WALK_JUNCTION_JUNCTION
Definition: SUMOXMLDefinitions.h:534
GNE_TAG_TRANSPORT_BUSSTOP_TAZ
@ GNE_TAG_TRANSPORT_BUSSTOP_TAZ
Definition: SUMOXMLDefinitions.h:681
GNE_TAG_RIDE_JUNCTION_CHARGINGSTATION
@ GNE_TAG_RIDE_JUNCTION_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:605
GNE_TAG_TRANSPORT_PARKINGAREA_TRAINSTOP
@ GNE_TAG_TRANSPORT_PARKINGAREA_TRAINSTOP
Definition: SUMOXMLDefinitions.h:716
SUMO_TAG_CONTAINER
@ SUMO_TAG_CONTAINER
Definition: SUMOXMLDefinitions.h:370
GNE_TAG_TRANSHIP_PARKINGAREA_TAZ
@ GNE_TAG_TRANSHIP_PARKINGAREA_TAZ
Definition: SUMOXMLDefinitions.h:778
GNE_TAG_TRANSHIP_PARKINGAREA_PARKINGAREA
@ GNE_TAG_TRANSHIP_PARKINGAREA_PARKINGAREA
Definition: SUMOXMLDefinitions.h:784
GNE_TAG_WALK_CONTAINERSTOP_PARKINGAREA
@ GNE_TAG_WALK_CONTAINERSTOP_PARKINGAREA
Definition: SUMOXMLDefinitions.h:563
GNE_TAG_TRANSHIP_TAZ_PARKINGAREA
@ GNE_TAG_TRANSHIP_TAZ_PARKINGAREA
Definition: SUMOXMLDefinitions.h:736
GNE_TAG_WALK_EDGE_EDGE
@ GNE_TAG_WALK_EDGE_EDGE
Definition: SUMOXMLDefinitions.h:516
GNE_TAG_PERSONTRIP_TAZ_TAZ
@ GNE_TAG_PERSONTRIP_TAZ_TAZ
Definition: SUMOXMLDefinitions.h:460
GNE_TAG_TRANSPORT_CONTAINERSTOP_JUNCTION
@ GNE_TAG_TRANSPORT_CONTAINERSTOP_JUNCTION
Definition: SUMOXMLDefinitions.h:698
GNE_TAG_TRANSHIP_TAZ_BUSSTOP
@ GNE_TAG_TRANSHIP_TAZ_BUSSTOP
Definition: SUMOXMLDefinitions.h:732
GNE_TAG_TRANSPORT_TAZ_EDGE
@ GNE_TAG_TRANSPORT_TAZ_EDGE
Definition: SUMOXMLDefinitions.h:664
GNE_TAG_TRANSHIP_CHARGINGSTATION_CHARGINGSTATION
@ GNE_TAG_TRANSHIP_CHARGINGSTATION_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:775
GNE_TAG_RIDE_EDGE_CHARGINGSTATION
@ GNE_TAG_RIDE_EDGE_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:589
GNE_TAG_TRANSPORT_TAZ_TAZ
@ GNE_TAG_TRANSPORT_TAZ_TAZ
Definition: SUMOXMLDefinitions.h:665
GNE_TAG_PERSONTRIP_CHARGINGSTATION_EDGE
@ GNE_TAG_PERSONTRIP_CHARGINGSTATION_EDGE
Definition: SUMOXMLDefinitions.h:499
GNE_TAG_PERSONTRIP_EDGE_BUSSTOP
@ GNE_TAG_PERSONTRIP_EDGE_BUSSTOP
Definition: SUMOXMLDefinitions.h:454
GNE_TAG_TRANSPORT_EDGE_JUNCTION
@ GNE_TAG_TRANSPORT_EDGE_JUNCTION
Definition: SUMOXMLDefinitions.h:658
GNE_TAG_WALK_CHARGINGSTATION_CONTAINERSTOP
@ GNE_TAG_WALK_CHARGINGSTATION_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:569
GNE_TAG_TRANSPORT_TAZ_BUSSTOP
@ GNE_TAG_TRANSPORT_TAZ_BUSSTOP
Definition: SUMOXMLDefinitions.h:667
GNE_TAG_WALK_BUSSTOP_PARKINGAREA
@ GNE_TAG_WALK_BUSSTOP_PARKINGAREA
Definition: SUMOXMLDefinitions.h:547
GNE_TAG_WALK_CHARGINGSTATION_PARKINGAREA
@ GNE_TAG_WALK_CHARGINGSTATION_PARKINGAREA
Definition: SUMOXMLDefinitions.h:571
GNE_TAG_TRANSPORT_JUNCTION_JUNCTION
@ GNE_TAG_TRANSPORT_JUNCTION_JUNCTION
Definition: SUMOXMLDefinitions.h:674
GNE_TAG_PERSONTRIP_CHARGINGSTATION_CONTAINERSTOP
@ GNE_TAG_PERSONTRIP_CHARGINGSTATION_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:504
GNE_TAG_TRANSHIP_BUSSTOP_TRAINSTOP
@ GNE_TAG_TRANSHIP_BUSSTOP_TRAINSTOP
Definition: SUMOXMLDefinitions.h:749
GNE_TAG_PERSONTRIP_BUSSTOP_TAZ
@ GNE_TAG_PERSONTRIP_BUSSTOP_TAZ
Definition: SUMOXMLDefinitions.h:476
GNE_TAG_RIDE_TAZ_PARKINGAREA
@ GNE_TAG_RIDE_TAZ_PARKINGAREA
Definition: SUMOXMLDefinitions.h:598
GNE_TAG_WALK_CONTAINERSTOP_BUSSTOP
@ GNE_TAG_WALK_CONTAINERSTOP_BUSSTOP
Definition: SUMOXMLDefinitions.h:559
GNE_TAG_RIDE_CHARGINGSTATION_PARKINGAREA
@ GNE_TAG_RIDE_CHARGINGSTATION_PARKINGAREA
Definition: SUMOXMLDefinitions.h:638
GNE_TAG_RIDE_CHARGINGSTATION_BUSSTOP
@ GNE_TAG_RIDE_CHARGINGSTATION_BUSSTOP
Definition: SUMOXMLDefinitions.h:634
GNE_TAG_PERSONTRIP_CONTAINERSTOP_CONTAINERSTOP
@ GNE_TAG_PERSONTRIP_CONTAINERSTOP_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:496
GNE_TAG_TRANSHIP_CONTAINERSTOP_TAZ
@ GNE_TAG_TRANSHIP_CONTAINERSTOP_TAZ
Definition: SUMOXMLDefinitions.h:762
GNE_TAG_TRANSPORT_CHARGINGSTATION_EDGE
@ GNE_TAG_TRANSPORT_CHARGINGSTATION_EDGE
Definition: SUMOXMLDefinitions.h:704
GNE_TAG_PERSONTRIP_BUSSTOP_CHARGINGSTATION
@ GNE_TAG_PERSONTRIP_BUSSTOP_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:481
GNE_TAG_WALK_BUSSTOP_EDGE
@ GNE_TAG_WALK_BUSSTOP_EDGE
Definition: SUMOXMLDefinitions.h:540
GNE_TAG_RIDE_JUNCTION_TAZ
@ GNE_TAG_RIDE_JUNCTION_TAZ
Definition: SUMOXMLDefinitions.h:600
GNE_TAG_TRANSPORT_TRAINSTOP_BUSSTOP
@ GNE_TAG_TRANSPORT_TRAINSTOP_BUSSTOP
Definition: SUMOXMLDefinitions.h:691
GNE_TAG_WALK_JUNCTION_TRAINSTOP
@ GNE_TAG_WALK_JUNCTION_TRAINSTOP
Definition: SUMOXMLDefinitions.h:536
GNE_TAG_RIDE_TAZ_TAZ
@ GNE_TAG_RIDE_TAZ_TAZ
Definition: SUMOXMLDefinitions.h:592
GNE_TAG_TRANSHIP_EDGE_TRAINSTOP
@ GNE_TAG_TRANSHIP_EDGE_TRAINSTOP
Definition: SUMOXMLDefinitions.h:725
GNE_TAG_TRANSHIP_TRAINSTOP_TRAINSTOP
@ GNE_TAG_TRANSHIP_TRAINSTOP_TRAINSTOP
Definition: SUMOXMLDefinitions.h:757
GNE_TAG_RIDE_PARKINGAREA_PARKINGAREA
@ GNE_TAG_RIDE_PARKINGAREA_PARKINGAREA
Definition: SUMOXMLDefinitions.h:646
GNE_TAG_WALK_TRAINSTOP_PARKINGAREA
@ GNE_TAG_WALK_TRAINSTOP_PARKINGAREA
Definition: SUMOXMLDefinitions.h:555
GNE_TAG_RIDE_EDGE_BUSSTOP
@ GNE_TAG_RIDE_EDGE_BUSSTOP
Definition: SUMOXMLDefinitions.h:586
GNE_TAG_WALK_TAZ_JUNCTION
@ GNE_TAG_WALK_TAZ_JUNCTION
Definition: SUMOXMLDefinitions.h:526
GNE_TAG_RIDE_TAZ_JUNCTION
@ GNE_TAG_RIDE_TAZ_JUNCTION
Definition: SUMOXMLDefinitions.h:593
GNE_TAG_PERSONTRIP_JUNCTION_PARKINGAREA
@ GNE_TAG_PERSONTRIP_JUNCTION_PARKINGAREA
Definition: SUMOXMLDefinitions.h:474
GNE_TAG_TRANSPORT_BUSSTOP_TRAINSTOP
@ GNE_TAG_TRANSPORT_BUSSTOP_TRAINSTOP
Definition: SUMOXMLDefinitions.h:684
GNE_TAG_TRANSPORT_TRAINSTOP_PARKINGAREA
@ GNE_TAG_TRANSPORT_TRAINSTOP_PARKINGAREA
Definition: SUMOXMLDefinitions.h:695
GNE_TAG_TRANSPORT_PARKINGAREA_JUNCTION
@ GNE_TAG_TRANSPORT_PARKINGAREA_JUNCTION
Definition: SUMOXMLDefinitions.h:714
GNE_TAG_STOPPERSON_CONTAINERSTOP
@ GNE_TAG_STOPPERSON_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:652
GNE_TAG_WALK_BUSSTOP_TAZ
@ GNE_TAG_WALK_BUSSTOP_TAZ
Definition: SUMOXMLDefinitions.h:541
GNE_TAG_RIDE_CONTAINERSTOP_CHARGINGSTATION
@ GNE_TAG_RIDE_CONTAINERSTOP_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:629
GNE_TAG_TRANSPORT_CONTAINERSTOP_CONTAINERSTOP
@ GNE_TAG_TRANSPORT_CONTAINERSTOP_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:701
GNE_TAG_PERSONTRIP_BUSSTOP_BUSSTOP
@ GNE_TAG_PERSONTRIP_BUSSTOP_BUSSTOP
Definition: SUMOXMLDefinitions.h:478
GNE_TAG_TRANSHIP_BUSSTOP_PARKINGAREA
@ GNE_TAG_TRANSHIP_BUSSTOP_PARKINGAREA
Definition: SUMOXMLDefinitions.h:752
GNE_TAG_PERSONTRIP_JUNCTION_JUNCTION
@ GNE_TAG_PERSONTRIP_JUNCTION_JUNCTION
Definition: SUMOXMLDefinitions.h:469
GNE_TAG_TRANSHIP_CONTAINERSTOP_JUNCTION
@ GNE_TAG_TRANSHIP_CONTAINERSTOP_JUNCTION
Definition: SUMOXMLDefinitions.h:763
GNE_TAG_WALK_TAZ_TAZ
@ GNE_TAG_WALK_TAZ_TAZ
Definition: SUMOXMLDefinitions.h:525
GNE_TAG_WALK_TRAINSTOP_BUSSTOP
@ GNE_TAG_WALK_TRAINSTOP_BUSSTOP
Definition: SUMOXMLDefinitions.h:551
GNE_TAG_TRANSHIP_JUNCTION_TRAINSTOP
@ GNE_TAG_TRANSHIP_JUNCTION_TRAINSTOP
Definition: SUMOXMLDefinitions.h:741
GNE_TAG_WALK_TAZ_EDGE
@ GNE_TAG_WALK_TAZ_EDGE
Definition: SUMOXMLDefinitions.h:524
GNE_TAG_PERSONTRIP_TAZ_JUNCTION
@ GNE_TAG_PERSONTRIP_TAZ_JUNCTION
Definition: SUMOXMLDefinitions.h:461
GNE_TAG_WALK_EDGE_CHARGINGSTATION
@ GNE_TAG_WALK_EDGE_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:522
GNE_TAG_TRANSPORT_JUNCTION_TAZ
@ GNE_TAG_TRANSPORT_JUNCTION_TAZ
Definition: SUMOXMLDefinitions.h:673
GNE_TAG_TRANSPORT_PARKINGAREA_BUSSTOP
@ GNE_TAG_TRANSPORT_PARKINGAREA_BUSSTOP
Definition: SUMOXMLDefinitions.h:715
GNE_TAG_RIDE_EDGE_TRAINSTOP
@ GNE_TAG_RIDE_EDGE_TRAINSTOP
Definition: SUMOXMLDefinitions.h:587
GNE_TAG_TRANSHIP_TAZ_JUNCTION
@ GNE_TAG_TRANSHIP_TAZ_JUNCTION
Definition: SUMOXMLDefinitions.h:731
SUMO_TAG_PERSON
@ SUMO_TAG_PERSON
Definition: SUMOXMLDefinitions.h:355
GNE_TAG_TRANSHIP_JUNCTION_CHARGINGSTATION
@ GNE_TAG_TRANSHIP_JUNCTION_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:743
GNE_TAG_WALK_TRAINSTOP_CONTAINERSTOP
@ GNE_TAG_WALK_TRAINSTOP_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:553
GNE_TAG_WALK_JUNCTION_BUSSTOP
@ GNE_TAG_WALK_JUNCTION_BUSSTOP
Definition: SUMOXMLDefinitions.h:535
GNE_TAG_TRANSHIP_JUNCTION_JUNCTION
@ GNE_TAG_TRANSHIP_JUNCTION_JUNCTION
Definition: SUMOXMLDefinitions.h:739
GNE_TAG_PERSONTRIP_CONTAINERSTOP_JUNCTION
@ GNE_TAG_PERSONTRIP_CONTAINERSTOP_JUNCTION
Definition: SUMOXMLDefinitions.h:493
GNE_TAG_WALK_JUNCTION_EDGE
@ GNE_TAG_WALK_JUNCTION_EDGE
Definition: SUMOXMLDefinitions.h:532
GNE_TAG_PERSONTRIP_BUSSTOP_PARKINGAREA
@ GNE_TAG_PERSONTRIP_BUSSTOP_PARKINGAREA
Definition: SUMOXMLDefinitions.h:482
GNE_TAG_TRANSHIP_CONTAINERSTOP_TRAINSTOP
@ GNE_TAG_TRANSHIP_CONTAINERSTOP_TRAINSTOP
Definition: SUMOXMLDefinitions.h:765
GNE_TAG_PERSONTRIP_PARKINGAREA_BUSSTOP
@ GNE_TAG_PERSONTRIP_PARKINGAREA_BUSSTOP
Definition: SUMOXMLDefinitions.h:510
GNE_TAG_RIDE_CHARGINGSTATION_JUNCTION
@ GNE_TAG_RIDE_CHARGINGSTATION_JUNCTION
Definition: SUMOXMLDefinitions.h:633
GNE_TAG_RIDE_BUSSTOP_CHARGINGSTATION
@ GNE_TAG_RIDE_BUSSTOP_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:613
GNE_TAG_TRANSPORT_JUNCTION_TRAINSTOP
@ GNE_TAG_TRANSPORT_JUNCTION_TRAINSTOP
Definition: SUMOXMLDefinitions.h:676
GNE_TAG_WALK_EDGE_CONTAINERSTOP
@ GNE_TAG_WALK_EDGE_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:521
GNE_TAG_WALK_TRAINSTOP_JUNCTION
@ GNE_TAG_WALK_TRAINSTOP_JUNCTION
Definition: SUMOXMLDefinitions.h:550
GNE_TAG_TRANSHIP_CHARGINGSTATION_PARKINGAREA
@ GNE_TAG_TRANSHIP_CHARGINGSTATION_PARKINGAREA
Definition: SUMOXMLDefinitions.h:776
GNE_TAG_STOPPERSON_CHARGINGSTATION
@ GNE_TAG_STOPPERSON_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:653
GNE_TAG_TRANSHIP_CHARGINGSTATION_TAZ
@ GNE_TAG_TRANSHIP_CHARGINGSTATION_TAZ
Definition: SUMOXMLDefinitions.h:770
GNE_TAG_TRANSPORT_BUSSTOP_EDGE
@ GNE_TAG_TRANSPORT_BUSSTOP_EDGE
Definition: SUMOXMLDefinitions.h:680
GNE_TAG_TRANSHIP_CONTAINERSTOP_BUSSTOP
@ GNE_TAG_TRANSHIP_CONTAINERSTOP_BUSSTOP
Definition: SUMOXMLDefinitions.h:764
GNE_TAG_WALK_PARKINGAREA_TAZ
@ GNE_TAG_WALK_PARKINGAREA_TAZ
Definition: SUMOXMLDefinitions.h:573
GNE_TAG_PERSONTRIP_JUNCTION_EDGE
@ GNE_TAG_PERSONTRIP_JUNCTION_EDGE
Definition: SUMOXMLDefinitions.h:467
GNE_TAG_RIDE_CONTAINERSTOP_PARKINGAREA
@ GNE_TAG_RIDE_CONTAINERSTOP_PARKINGAREA
Definition: SUMOXMLDefinitions.h:630
GNE_TAG_RIDE_CHARGINGSTATION_TRAINSTOP
@ GNE_TAG_RIDE_CHARGINGSTATION_TRAINSTOP
Definition: SUMOXMLDefinitions.h:635
GNE_TAG_STOPPERSON_TRAINSTOP
@ GNE_TAG_STOPPERSON_TRAINSTOP
Definition: SUMOXMLDefinitions.h:651
GNE_TAG_TRANSPORT_CHARGINGSTATION_BUSSTOP
@ GNE_TAG_TRANSPORT_CHARGINGSTATION_BUSSTOP
Definition: SUMOXMLDefinitions.h:707
GNE_TAG_PERSONTRIP_PARKINGAREA_CHARGINGSTATION
@ GNE_TAG_PERSONTRIP_PARKINGAREA_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:513
GNE_TAG_TRANSHIP_CHARGINGSTATION_CONTAINERSTOP
@ GNE_TAG_TRANSHIP_CHARGINGSTATION_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:774
GNE_TAG_TRANSHIP_EDGE_BUSSTOP
@ GNE_TAG_TRANSHIP_EDGE_BUSSTOP
Definition: SUMOXMLDefinitions.h:724
GNE_TAG_RIDE_BUSSTOP_PARKINGAREA
@ GNE_TAG_RIDE_BUSSTOP_PARKINGAREA
Definition: SUMOXMLDefinitions.h:614
GNE_TAG_WALK_EDGE_JUNCTION
@ GNE_TAG_WALK_EDGE_JUNCTION
Definition: SUMOXMLDefinitions.h:518
GNE_TAG_RIDE_PARKINGAREA_EDGE
@ GNE_TAG_RIDE_PARKINGAREA_EDGE
Definition: SUMOXMLDefinitions.h:639
GNE_TAG_PERSONTRIP_JUNCTION_TAZ
@ GNE_TAG_PERSONTRIP_JUNCTION_TAZ
Definition: SUMOXMLDefinitions.h:468
GNE_TAG_TRANSHIP_PARKINGAREA_EDGE
@ GNE_TAG_TRANSHIP_PARKINGAREA_EDGE
Definition: SUMOXMLDefinitions.h:777
GNE_TAG_TRANSPORT_PARKINGAREA_CHARGINGSTATION
@ GNE_TAG_TRANSPORT_PARKINGAREA_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:718
GNE_TAG_TRANSHIP_TRAINSTOP_CONTAINERSTOP
@ GNE_TAG_TRANSHIP_TRAINSTOP_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:758
GNE_TAG_PERSONTRIP_JUNCTION_CONTAINERSTOP
@ GNE_TAG_PERSONTRIP_JUNCTION_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:472
GNE_TAG_WALK_TRAINSTOP_TRAINSTOP
@ GNE_TAG_WALK_TRAINSTOP_TRAINSTOP
Definition: SUMOXMLDefinitions.h:552
GNE_TAG_WALK_CHARGINGSTATION_EDGE
@ GNE_TAG_WALK_CHARGINGSTATION_EDGE
Definition: SUMOXMLDefinitions.h:564
GNE_TAG_TRANSHIP_EDGE_PARKINGAREA
@ GNE_TAG_TRANSHIP_EDGE_PARKINGAREA
Definition: SUMOXMLDefinitions.h:728
GNE_TAG_WALK_EDGE_BUSSTOP
@ GNE_TAG_WALK_EDGE_BUSSTOP
Definition: SUMOXMLDefinitions.h:519
GNE_TAG_PERSONTRIP_PARKINGAREA_PARKINGAREA
@ GNE_TAG_PERSONTRIP_PARKINGAREA_PARKINGAREA
Definition: SUMOXMLDefinitions.h:514
GNE_TAG_TRANSHIP_TRAINSTOP_BUSSTOP
@ GNE_TAG_TRANSHIP_TRAINSTOP_BUSSTOP
Definition: SUMOXMLDefinitions.h:756
GNE_TAG_TRANSHIP_BUSSTOP_BUSSTOP
@ GNE_TAG_TRANSHIP_BUSSTOP_BUSSTOP
Definition: SUMOXMLDefinitions.h:748
GNE_TAG_TRANSPORT_TRAINSTOP_EDGE
@ GNE_TAG_TRANSPORT_TRAINSTOP_EDGE
Definition: SUMOXMLDefinitions.h:688
GNE_TAG_PERSONTRIP_TRAINSTOP_CHARGINGSTATION
@ GNE_TAG_PERSONTRIP_TRAINSTOP_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:489
GNE_TAG_TRANSPORT_EDGE_CHARGINGSTATION
@ GNE_TAG_TRANSPORT_EDGE_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:662
GNE_TAG_TRANSHIP_CONTAINERSTOP_CONTAINERSTOP
@ GNE_TAG_TRANSHIP_CONTAINERSTOP_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:766
GNE_TAG_WALK_CONTAINERSTOP_TRAINSTOP
@ GNE_TAG_WALK_CONTAINERSTOP_TRAINSTOP
Definition: SUMOXMLDefinitions.h:560
GNE_TAG_RIDE_EDGE_PARKINGAREA
@ GNE_TAG_RIDE_EDGE_PARKINGAREA
Definition: SUMOXMLDefinitions.h:590
GNE_TAG_TRANSHIP_CHARGINGSTATION_JUNCTION
@ GNE_TAG_TRANSHIP_CHARGINGSTATION_JUNCTION
Definition: SUMOXMLDefinitions.h:771
GNE_TAG_RIDE_BUSSTOP_CONTAINERSTOP
@ GNE_TAG_RIDE_BUSSTOP_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:612
GNE_TAG_WALK_TAZ_TRAINSTOP
@ GNE_TAG_WALK_TAZ_TRAINSTOP
Definition: SUMOXMLDefinitions.h:528
GNE_TAG_PERSONTRIP_CONTAINERSTOP_CHARGINGSTATION
@ GNE_TAG_PERSONTRIP_CONTAINERSTOP_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:497
GNE_TAG_RIDE_JUNCTION_EDGE
@ GNE_TAG_RIDE_JUNCTION_EDGE
Definition: SUMOXMLDefinitions.h:599
GNE_TAG_TRANSHIP_TRAINSTOP_PARKINGAREA
@ GNE_TAG_TRANSHIP_TRAINSTOP_PARKINGAREA
Definition: SUMOXMLDefinitions.h:760
GNE_TAG_PERSONTRIP_CONTAINERSTOP_BUSSTOP
@ GNE_TAG_PERSONTRIP_CONTAINERSTOP_BUSSTOP
Definition: SUMOXMLDefinitions.h:494
GNE_TAG_TRANSHIP_JUNCTION_TAZ
@ GNE_TAG_TRANSHIP_JUNCTION_TAZ
Definition: SUMOXMLDefinitions.h:738
GNE_TAG_TRANSPORT_JUNCTION_CONTAINERSTOP
@ GNE_TAG_TRANSPORT_JUNCTION_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:677
GNE_TAG_TRANSPORT_TAZ_CHARGINGSTATION
@ GNE_TAG_TRANSPORT_TAZ_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:670
GNE_TAG_TRANSPORT_TAZ_JUNCTION
@ GNE_TAG_TRANSPORT_TAZ_JUNCTION
Definition: SUMOXMLDefinitions.h:666
GNE_TAG_RIDE_TRAINSTOP_TRAINSTOP
@ GNE_TAG_RIDE_TRAINSTOP_TRAINSTOP
Definition: SUMOXMLDefinitions.h:619
GNE_TAG_TRANSPORT_JUNCTION_EDGE
@ GNE_TAG_TRANSPORT_JUNCTION_EDGE
Definition: SUMOXMLDefinitions.h:672
GNE_TAG_TRANSPORT_BUSSTOP_BUSSTOP
@ GNE_TAG_TRANSPORT_BUSSTOP_BUSSTOP
Definition: SUMOXMLDefinitions.h:683
GNE_TAG_WALK_PARKINGAREA_BUSSTOP
@ GNE_TAG_WALK_PARKINGAREA_BUSSTOP
Definition: SUMOXMLDefinitions.h:575
GNE_TAG_RIDE_CONTAINERSTOP_TAZ
@ GNE_TAG_RIDE_CONTAINERSTOP_TAZ
Definition: SUMOXMLDefinitions.h:624
GNE_TAG_STOPCONTAINER_CHARGINGSTATION
@ GNE_TAG_STOPCONTAINER_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:792
GNE_TAG_TRANSPORT_BUSSTOP_PARKINGAREA
@ GNE_TAG_TRANSPORT_BUSSTOP_PARKINGAREA
Definition: SUMOXMLDefinitions.h:687
GNE_TAG_WALK_TAZ_PARKINGAREA
@ GNE_TAG_WALK_TAZ_PARKINGAREA
Definition: SUMOXMLDefinitions.h:531
GNE_TAG_TRANSHIP_TAZ_CHARGINGSTATION
@ GNE_TAG_TRANSHIP_TAZ_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:735
GNE_TAG_TRANSHIP_BUSSTOP_TAZ
@ GNE_TAG_TRANSHIP_BUSSTOP_TAZ
Definition: SUMOXMLDefinitions.h:746
GNE_TAG_PERSONTRIP_TRAINSTOP_JUNCTION
@ GNE_TAG_PERSONTRIP_TRAINSTOP_JUNCTION
Definition: SUMOXMLDefinitions.h:485
GNE_TAG_RIDE_CONTAINERSTOP_TRAINSTOP
@ GNE_TAG_RIDE_CONTAINERSTOP_TRAINSTOP
Definition: SUMOXMLDefinitions.h:627
GNE_TAG_RIDE_TAZ_CHARGINGSTATION
@ GNE_TAG_RIDE_TAZ_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:597
GNE_TAG_STOPPERSON_EDGE
@ GNE_TAG_STOPPERSON_EDGE
Definition: SUMOXMLDefinitions.h:649
GNE_TAG_RIDE_CONTAINERSTOP_JUNCTION
@ GNE_TAG_RIDE_CONTAINERSTOP_JUNCTION
Definition: SUMOXMLDefinitions.h:625
GNE_TAG_PERSONTRIP_JUNCTION_CHARGINGSTATION
@ GNE_TAG_PERSONTRIP_JUNCTION_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:473
GNE_TAG_RIDE_PARKINGAREA_TRAINSTOP
@ GNE_TAG_RIDE_PARKINGAREA_TRAINSTOP
Definition: SUMOXMLDefinitions.h:643
GNE_TAG_TRANSPORT_CONTAINERSTOP_PARKINGAREA
@ GNE_TAG_TRANSPORT_CONTAINERSTOP_PARKINGAREA
Definition: SUMOXMLDefinitions.h:703
GNE_TAG_TRANSHIP_CONTAINERSTOP_CHARGINGSTATION
@ GNE_TAG_TRANSHIP_CONTAINERSTOP_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:767
GNE_TAG_WALK_ROUTE
@ GNE_TAG_WALK_ROUTE
Definition: SUMOXMLDefinitions.h:581
GNE_TAG_PERSONTRIP_EDGE_TAZ
@ GNE_TAG_PERSONTRIP_EDGE_TAZ
Definition: SUMOXMLDefinitions.h:452
GNE_TAG_RIDE_TAZ_BUSSTOP
@ GNE_TAG_RIDE_TAZ_BUSSTOP
Definition: SUMOXMLDefinitions.h:594
GNE_TAG_WALK_CONTAINERSTOP_CONTAINERSTOP
@ GNE_TAG_WALK_CONTAINERSTOP_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:561
GNE_TAG_RIDE_TRAINSTOP_PARKINGAREA
@ GNE_TAG_RIDE_TRAINSTOP_PARKINGAREA
Definition: SUMOXMLDefinitions.h:622
SUMO_TAG_PERSONFLOW
@ SUMO_TAG_PERSONFLOW
Definition: SUMOXMLDefinitions.h:359
GNE_TAG_TRANSHIP_CONTAINERSTOP_EDGE
@ GNE_TAG_TRANSHIP_CONTAINERSTOP_EDGE
Definition: SUMOXMLDefinitions.h:761
GNE_TAG_WALK_CHARGINGSTATION_CHARGINGSTATION
@ GNE_TAG_WALK_CHARGINGSTATION_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:570
GNE_TAG_TRANSHIP_TRAINSTOP_TAZ
@ GNE_TAG_TRANSHIP_TRAINSTOP_TAZ
Definition: SUMOXMLDefinitions.h:754
GNE_TAG_RIDE_EDGE_CONTAINERSTOP
@ GNE_TAG_RIDE_EDGE_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:588
GNE_TAG_STOPPERSON_PARKINGAREA
@ GNE_TAG_STOPPERSON_PARKINGAREA
Definition: SUMOXMLDefinitions.h:654
GNE_TAG_RIDE_TRAINSTOP_EDGE
@ GNE_TAG_RIDE_TRAINSTOP_EDGE
Definition: SUMOXMLDefinitions.h:615
GNE_TAG_TRANSHIP_TAZ_CONTAINERSTOP
@ GNE_TAG_TRANSHIP_TAZ_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:734
SumoXMLAttr
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
Definition: SUMOXMLDefinitions.h:808
SUMO_ATTR_STARTPOS
@ SUMO_ATTR_STARTPOS
Definition: SUMOXMLDefinitions.h:1549
GNE_ATTR_FROM_TRAINSTOP
@ GNE_ATTR_FROM_TRAINSTOP
Definition: SUMOXMLDefinitions.h:1820
GNE_ATTR_FROM_BUSSTOP
@ GNE_ATTR_FROM_BUSSTOP
Definition: SUMOXMLDefinitions.h:1819
GNE_ATTR_PLAN_GEOMETRY_STARTPOS
@ GNE_ATTR_PLAN_GEOMETRY_STARTPOS
person/container geometry start position
Definition: SUMOXMLDefinitions.h:1808
SUMO_ATTR_FROM_JUNCTION
@ SUMO_ATTR_FROM_JUNCTION
Definition: SUMOXMLDefinitions.h:1341
SUMO_ATTR_CONTAINER_STOP
@ SUMO_ATTR_CONTAINER_STOP
Definition: SUMOXMLDefinitions.h:1509
SUMO_ATTR_PARKING_AREA
@ SUMO_ATTR_PARKING_AREA
Definition: SUMOXMLDefinitions.h:1510
SUMO_ATTR_EDGE
@ SUMO_ATTR_EDGE
Definition: SUMOXMLDefinitions.h:866
SUMO_ATTR_BUS_STOP
@ SUMO_ATTR_BUS_STOP
Definition: SUMOXMLDefinitions.h:1507
SUMO_ATTR_TRAIN_STOP
@ SUMO_ATTR_TRAIN_STOP
Definition: SUMOXMLDefinitions.h:1508
SUMO_ATTR_ENDPOS
@ SUMO_ATTR_ENDPOS
Definition: SUMOXMLDefinitions.h:1550
SUMO_ATTR_TO_JUNCTION
@ SUMO_ATTR_TO_JUNCTION
Definition: SUMOXMLDefinitions.h:1342
GNE_ATTR_PARENT
@ GNE_ATTR_PARENT
parent of an additional element
Definition: SUMOXMLDefinitions.h:1760
SUMO_ATTR_ARRIVALPOS
@ SUMO_ATTR_ARRIVALPOS
Definition: SUMOXMLDefinitions.h:957
GNE_ATTR_SELECTED
@ GNE_ATTR_SELECTED
element is selected
Definition: SUMOXMLDefinitions.h:1748
GNE_ATTR_TAZ_CENTROID
@ GNE_ATTR_TAZ_CENTROID
TAZ Center (uses to return the TAZ centroid if center is not defined)
Definition: SUMOXMLDefinitions.h:1816
SUMO_ATTR_EDGES
@ SUMO_ATTR_EDGES
the edges of a route
Definition: SUMOXMLDefinitions.h:946
SUMO_ATTR_CHARGING_STATION
@ SUMO_ATTR_CHARGING_STATION
Definition: SUMOXMLDefinitions.h:1514
SUMO_ATTR_DEPARTPOS
@ SUMO_ATTR_DEPARTPOS
Definition: SUMOXMLDefinitions.h:952
GNE_ATTR_FROM_PARKINGAREA
@ GNE_ATTR_FROM_PARKINGAREA
Definition: SUMOXMLDefinitions.h:1823
GNE_ATTR_FROM_CONTAINERSTOP
@ GNE_ATTR_FROM_CONTAINERSTOP
Definition: SUMOXMLDefinitions.h:1821
SUMO_ATTR_TO_TAZ
@ SUMO_ATTR_TO_TAZ
Definition: SUMOXMLDefinitions.h:1347
SUMO_ATTR_CENTER
@ SUMO_ATTR_CENTER
Definition: SUMOXMLDefinitions.h:919
SUMO_ATTR_TO
@ SUMO_ATTR_TO
Definition: SUMOXMLDefinitions.h:1336
SUMO_ATTR_FROM
@ SUMO_ATTR_FROM
Definition: SUMOXMLDefinitions.h:1335
SUMO_ATTR_FROM_TAZ
@ SUMO_ATTR_FROM_TAZ
Definition: SUMOXMLDefinitions.h:1346
GNE_ATTR_FROM_CHARGINGSTATION
@ GNE_ATTR_FROM_CHARGINGSTATION
Definition: SUMOXMLDefinitions.h:1822
GNE_ATTR_PLAN_GEOMETRY_ENDPOS
@ GNE_ATTR_PLAN_GEOMETRY_ENDPOS
person/container geometry end position
Definition: SUMOXMLDefinitions.h:1810
SUMO_ATTR_ROUTE
@ SUMO_ATTR_ROUTE
Definition: SUMOXMLDefinitions.h:892
SUMO_ATTR_ID
@ SUMO_ATTR_ID
Definition: SUMOXMLDefinitions.h:900
SUMO_ATTR_DURATION
@ SUMO_ATTR_DURATION
Definition: SUMOXMLDefinitions.h:1366
INVALID_DOUBLE
const double INVALID_DOUBLE
invalid double
Definition: StdDefs.h:64
MIN2
T MIN2(T a, T b)
Definition: StdDefs.h:76
SUMO_const_halfLaneWidth
const double SUMO_const_halfLaneWidth
Definition: StdDefs.h:49
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
Boundary
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:39
Boundary::getCenter
Position getCenter() const
Returns the center of the boundary.
Definition: Boundary.cpp:112
Boundary::add
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
Definition: Boundary.cpp:78
Boundary::isInitialised
bool isInitialised() const
check if Boundary is Initialised
Definition: Boundary.cpp:235
Boundary::grow
Boundary & grow(double by)
extends the boundary by the given amount
Definition: Boundary.cpp:319
CommonXMLStructure::PlanParameters
plan parameters (used for group all from-to parameters related with plans)
Definition: CommonXMLStructure.h:44
CommonXMLStructure::PlanParameters::fromJunction
std::string fromJunction
from junction
Definition: CommonXMLStructure.h:73
CommonXMLStructure::PlanParameters::fromContainerStop
std::string fromContainerStop
from containerStop
Definition: CommonXMLStructure.h:97
CommonXMLStructure::PlanParameters::toTrainStop
std::string toTrainStop
to trainStop
Definition: CommonXMLStructure.h:94
CommonXMLStructure::PlanParameters::fromTrainStop
std::string fromTrainStop
from trainStop
Definition: CommonXMLStructure.h:91
CommonXMLStructure::PlanParameters::toParkingArea
std::string toParkingArea
to parkingArea
Definition: CommonXMLStructure.h:112
CommonXMLStructure::PlanParameters::fromBusStop
std::string fromBusStop
from busStop
Definition: CommonXMLStructure.h:85
CommonXMLStructure::PlanParameters::consecutiveEdges
std::vector< std::string > consecutiveEdges
consecutive edges
Definition: CommonXMLStructure.h:70
CommonXMLStructure::PlanParameters::isSingleEdgePlan
bool isSingleEdgePlan() const
check if this is a single-edge plan
Definition: CommonXMLStructure.cpp:106
CommonXMLStructure::PlanParameters::fromChargingStation
std::string fromChargingStation
from chargingStation
Definition: CommonXMLStructure.h:103
CommonXMLStructure::PlanParameters::toChargingStation
std::string toChargingStation
to chargingStation
Definition: CommonXMLStructure.h:106
CommonXMLStructure::PlanParameters::fromParkingArea
std::string fromParkingArea
from parkingArea
Definition: CommonXMLStructure.h:109
CommonXMLStructure::PlanParameters::toContainerStop
std::string toContainerStop
to containerStop
Definition: CommonXMLStructure.h:100
GLHelper::setColor
static void setColor(const RGBColor &c)
Sets the gl-color to this value.
Definition: GLHelper.cpp:654
GLHelper::drawTriangleAtEnd
static void drawTriangleAtEnd(const Position &p1, const Position &p2, double tLength, double tWidth, const double extraOffset=0)
Draws a triangle at the end of the given line.
Definition: GLHelper.cpp:629
GLHelper::popMatrix
static void popMatrix()
pop matrix
Definition: GLHelper.cpp:130
GLHelper::drawBoxLines
static void drawBoxLines(const PositionVector &geom, const std::vector< double > &rots, const std::vector< double > &lengths, double width, int cornerDetail=0, double offset=0)
Draws thick lines.
Definition: GLHelper.cpp:347
GLHelper::drawBoundary
static void drawBoundary(const GUIVisualizationSettings &s, const Boundary &b)
Draw a boundary (used for debugging)
Definition: GLHelper.cpp:967
GLHelper::drawFilledCircleDetailled
static void drawFilledCircleDetailled(const GUIVisualizationSettings::Detail d, const double radius)
Draws a filled circle around (0,0) depending of level of detail.
Definition: GLHelper.cpp:539
GLHelper::pushMatrix
static void pushMatrix()
push matrix
Definition: GLHelper.cpp:117
GNEAttributeCarrier::isAttributeCarrierSelected
bool isAttributeCarrierSelected() const
check if attribute carrier is selected
Definition: GNEAttributeCarrier.cpp:99
GNEAttributeCarrier::getTagStr
const std::string & getTagStr() const
get tag assigned to this object in string format
Definition: GNEAttributeCarrier.cpp:619
GNEAttributeCarrier::getTagProperty
const GNETagProperties & getTagProperty() const
get tagProperty associated with this Attribute Carrier
Definition: GNEAttributeCarrier.cpp:646
GNEAttributeCarrier::isTemplate
bool isTemplate() const
check if this AC is template
Definition: GNEAttributeCarrier.cpp:640
GNEAttributeCarrier::unselectAttributeCarrier
void unselectAttributeCarrier(const bool changeFlag=true)
unselect attribute carrier using GUIGlobalSelection
Definition: GNEAttributeCarrier.cpp:88
GNEAttributeCarrier::drawUsingSelectColor
bool drawUsingSelectColor() const
check if attribute carrier must be drawn using selecting color.
Definition: GNEAttributeCarrier.cpp:105
GNEAttributeCarrier::myNet
GNENet * myNet
pointer to net
Definition: GNEAttributeCarrier.h:343
GNEAttributeCarrier::getNet
GNENet * getNet() const
get pointer to net
Definition: GNEAttributeCarrier.cpp:71
GNEAttributeCarrier::parseIDs
static std::string parseIDs(const std::vector< T > &ACs)
parses a list of specific Attribute Carriers into a string of IDs
GNEAttributeCarrier::selectAttributeCarrier
void selectAttributeCarrier(const bool changeFlag=true)
select attribute carrier using GUIGlobalSelection
Definition: GNEAttributeCarrier.cpp:77
GNEAttributeCarrier::getAttribute
virtual std::string getAttribute(SumoXMLAttr key) const =0
GNEAttributeCarrier::myTagProperty
const GNETagProperties & myTagProperty
reference to tagProperty associated with this attribute carrier
Definition: GNEAttributeCarrier.h:340
GNEChange_Attribute::changeAttribute
static void changeAttribute(GNEAttributeCarrier *AC, SumoXMLAttr key, const std::string &value, GNEUndoList *undoList, const bool force=false)
change attribute
Definition: GNEChange_Attribute.cpp:38
GNEContour::calculateContourExtrudedShape
void calculateContourExtrudedShape(const GUIVisualizationSettings &s, const GUIVisualizationSettings::Detail d, const GUIGlObject *glObject, const PositionVector &shape, const double extrusionWidth, const double scale, const bool closeFirstExtrem, const bool closeLastExtrem, const double offset) const
calculate contour extruded (used in elements formed by a central shape)
Definition: GNEContour.cpp:88
GNEContour::calculateContourCircleShape
void calculateContourCircleShape(const GUIVisualizationSettings &s, const GUIVisualizationSettings::Detail d, const GUIGlObject *glObject, const Position &pos, double radius, const double scale) const
calculate contour (circle elements)
Definition: GNEContour.cpp:117
GNEContour::drawDottedContours
void drawDottedContours(const GUIVisualizationSettings &s, const GUIVisualizationSettings::Detail d, const GNEAttributeCarrier *AC, const double lineWidth, const bool addOffset) const
drawing contour functions
Definition: GNEContour.cpp:265
GNEDemandElement::updateGeometry
virtual void updateGeometry()=0
update pre-computed geometry information
GNEDemandElement::getVClass
virtual SUMOVehicleClass getVClass() const =0
obtain VClass related with this demand element
GNEDemandElement::replaceDemandElementParent
void replaceDemandElementParent(SumoXMLTag tag, const std::string &value, const int parentIndex)
replace demand element parent
Definition: GNEDemandElement.cpp:601
GNEDemandElement::myDemandElementGeometry
GUIGeometry myDemandElementGeometry
demand element geometry (also called "stacked geometry")
Definition: GNEDemandElement.h:349
GNEDemandElement::getLastPathLane
virtual GNELane * getLastPathLane() const =0
get last path lane
GNEDemandElement::replaceLastParentEdge
void replaceLastParentEdge(const std::string &value)
replace the last parent edge
Definition: GNEDemandElement.cpp:574
GNEDemandElement::getAttribute
virtual std::string getAttribute(SumoXMLAttr key) const =0
GNEDemandElement::computePathElement
virtual void computePathElement()=0
compute pathElement
GNEDemandElement::getFirstPathLane
virtual GNELane * getFirstPathLane() const =0
get first path lane
GNEDemandElement::replaceFirstParentEdge
void replaceFirstParentEdge(const std::string &value)
replace the first parent edge
Definition: GNEDemandElement.cpp:565
GNEDemandElement::getPositionInView
virtual Position getPositionInView() const =0
Returns position of demand element in view.
GNEDemandElement::getDemandElementGeometry
const GUIGeometry & getDemandElementGeometry()
get demand element geometry (stacked)
Definition: GNEDemandElement.cpp:95
GNEDemandElement::Problem
Problem
enum class for demandElement problems
Definition: GNEDemandElement.h:60
GNEDemandElement::getPreviousChildDemandElement
GNEDemandElement * getPreviousChildDemandElement(const GNEDemandElement *demandElement) const
get previous child demand element to the given demand element
Definition: GNEDemandElement.cpp:101
GNEDemandElement::drawGL
virtual void drawGL(const GUIVisualizationSettings &s) const =0
Draws the object.
GNEDemandElementPlan::getPersonTripTagIcon
static std::pair< SumoXMLTag, GUIIcon > getPersonTripTagIcon(const CommonXMLStructure::PlanParameters &planParameters)
get the personTrip tag and icon for the combination
Definition: GNEDemandElementPlan.cpp:217
GNEDemandElementPlan::myPlanBoundary
Boundary myPlanBoundary
plan boundary
Definition: GNEDemandElementPlan.h:76
GNEDemandElementPlan::isPlanValid
bool isPlanValid(SumoXMLAttr key, const std::string &value)
check if plan attribute is valid
Definition: GNEDemandElementPlan.cpp:1615
GNEDemandElementPlan::getPlanCenteringBoundary
Boundary getPlanCenteringBoundary() const
get plan centering boundary
Definition: GNEDemandElementPlan.cpp:1269
GNEDemandElementPlan::getPlanPositionInView
Position getPlanPositionInView() const
Returns position of additional in view.
Definition: GNEDemandElementPlan.cpp:1317
GNEDemandElementPlan::getPersonPlanProblem
std::string getPersonPlanProblem() const
get plan problem
Definition: GNEDemandElementPlan.cpp:2160
GNEDemandElementPlan::getContainerStopTagIcon
static std::pair< SumoXMLTag, GUIIcon > getContainerStopTagIcon(const CommonXMLStructure::PlanParameters &planParameters)
get the container stop tag and icon for the combination
Definition: GNEDemandElementPlan.cpp:919
GNEDemandElementPlan::computePlanPathElement
void computePlanPathElement()
compute plan pathElement
Definition: GNEDemandElementPlan.cpp:1130
GNEDemandElementPlan::getPlanAttributePosition
Position getPlanAttributePosition(SumoXMLAttr key) const
get plan attribute position
Definition: GNEDemandElementPlan.cpp:1489
GNEDemandElementPlan::isPlanPersonValid
GNEDemandElement::Problem isPlanPersonValid() const
check if plan is valid
Definition: GNEDemandElementPlan.cpp:2127
GNEDemandElementPlan::getRideTagIcon
static std::pair< SumoXMLTag, GUIIcon > getRideTagIcon(const CommonXMLStructure::PlanParameters &planParameters)
get the ride tag and icon for the combination
Definition: GNEDemandElementPlan.cpp:387
GNEDemandElementPlan::drawPlanLanePartial
void drawPlanLanePartial(const bool drawPlan, const GUIVisualizationSettings &s, const GNEPathManager::Segment *segment, const double offsetFront, const double planWidth, const RGBColor &planColor, const RGBColor &planSelectedColor) const
draw plan partial lane
Definition: GNEDemandElementPlan.cpp:1936
GNEDemandElementPlan::myPlanContourEnd
GNEContour myPlanContourEnd
variable used for draw contour end
Definition: GNEDemandElementPlan.h:73
GNEDemandElementPlan::getPlanPopUpMenu
GUIGLObjectPopupMenu * getPlanPopUpMenu(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own popup-menu.
Definition: GNEDemandElementPlan.cpp:1064
GNEDemandElementPlan::drawPlanJunctionPartial
void drawPlanJunctionPartial(const bool drawPlan, const GUIVisualizationSettings &s, const GNEPathManager::Segment *segment, const double offsetFront, const double planWidth, const RGBColor &planColor, const RGBColor &planSelectedColor) const
draw plan partial junction
Definition: GNEDemandElementPlan.cpp:2044
GNEDemandElementPlan::GNEDemandElementPlan
GNEDemandElementPlan(GNEDemandElement *planElement, const double departPosition, const double arrivalPosition)
constructor
Definition: GNEDemandElementPlan.cpp:938
GNEDemandElementPlan::drawFromArrow
void drawFromArrow(const GUIVisualizationSettings &s, const GNELane *lane, const GNEPathManager::Segment *segment) const
draw from arrow
Definition: GNEDemandElementPlan.cpp:2206
GNEDemandElementPlan::getPlanHierarchyName
std::string getPlanHierarchyName() const
get plan Hierarchy Name (Used in AC Hierarchy)
Definition: GNEDemandElementPlan.cpp:1724
GNEDemandElementPlan::drawEndPosition
void drawEndPosition(const GUIVisualizationSettings &s, const GUIVisualizationSettings::Detail d, const double endPosRadius) const
draw to arrow
Definition: GNEDemandElementPlan.cpp:2246
GNEDemandElementPlan::writeLocationAttributes
void writeLocationAttributes(OutputDevice &device) const
write plan element common attributes
Definition: GNEDemandElementPlan.cpp:972
GNEDemandElementPlan::checkDrawPersonPlan
bool checkDrawPersonPlan() const
check if person plan can be drawn
Definition: GNEDemandElementPlan.cpp:1790
GNEDemandElementPlan::getPersonStopTagIcon
static std::pair< SumoXMLTag, GUIIcon > getPersonStopTagIcon(const CommonXMLStructure::PlanParameters &planParameters)
get the person stop tag and icon for the combination
Definition: GNEDemandElementPlan.cpp:899
GNEDemandElementPlan::myPlanContour
GNEContour myPlanContour
variable used for draw central contour
Definition: GNEDemandElementPlan.h:70
GNEDemandElementPlan::getPlanMoveOperation
GNEMoveOperation * getPlanMoveOperation()
get move operation
Definition: GNEDemandElementPlan.cpp:948
GNEDemandElementPlan::drawToArrow
void drawToArrow(const GUIVisualizationSettings &s, const GNELane *lane, const GNEPathManager::Segment *segment) const
draw to arrow
Definition: GNEDemandElementPlan.cpp:2226
GNEDemandElementPlan::getPlanAttributeDouble
double getPlanAttributeDouble(SumoXMLAttr key) const
get plan attribute double
Definition: GNEDemandElementPlan.cpp:1412
GNEDemandElementPlan::setPlanAttribute
void setPlanAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
set plan attribute
Definition: GNEDemandElementPlan.cpp:1597
GNEDemandElementPlan::myArrivalPosition
double myArrivalPosition
arrival position (used in all plans over edges)
Definition: GNEDemandElementPlan.h:187
GNEDemandElementPlan::myDepartPosition
double myDepartPosition
depart position (used in tranships)
Definition: GNEDemandElementPlan.h:184
GNEDemandElementPlan::getWalkTagIcon
static std::pair< SumoXMLTag, GUIIcon > getWalkTagIcon(const CommonXMLStructure::PlanParameters &planParameters)
get the walk tag and icon for the combination
Definition: GNEDemandElementPlan.cpp:43
GNEDemandElementPlan::myArrivalPositionDiameter
static const double myArrivalPositionDiameter
arrival position diameter
Definition: GNEDemandElementPlan.h:209
GNEDemandElementPlan::getPlanAttribute
std::string getPlanAttribute(SumoXMLAttr key) const
get plan attribute string
Definition: GNEDemandElementPlan.cpp:1349
GNEDemandElementPlan::isPlanAttributeEnabled
bool isPlanAttributeEnabled(SumoXMLAttr key) const
check if plan attribute is enabled
Definition: GNEDemandElementPlan.cpp:1641
GNEDemandElementPlan::checkDrawContainerPlan
bool checkDrawContainerPlan() const
check if container plan can be drawn
Definition: GNEDemandElementPlan.cpp:1831
GNEDemandElementPlan::getTranshipTagIcon
static std::pair< SumoXMLTag, GUIIcon > getTranshipTagIcon(const CommonXMLStructure::PlanParameters &planParameters)
get the tranship tag and icon for the combination
Definition: GNEDemandElementPlan.cpp:727
GNEDemandElementPlan::getLastPlanPathLane
GNELane * getLastPlanPathLane() const
get last plan path lane
Definition: GNEDemandElementPlan.cpp:1107
GNEDemandElementPlan::myPlanElement
GNEDemandElement * myPlanElement
pointer to plan element
Definition: GNEDemandElementPlan.h:206
GNEDemandElementPlan::updatePlanCenteringBoundary
void updatePlanCenteringBoundary(const bool updateGrid)
update plan centering boundary
Definition: GNEDemandElementPlan.cpp:1275
GNEDemandElementPlan::drawPlanGL
void drawPlanGL(const bool drawPlan, const GUIVisualizationSettings &s, const RGBColor &planColor, const RGBColor &planSelectedColor) const
draw plan
Definition: GNEDemandElementPlan.cpp:1872
GNEDemandElementPlan::updatePlanGeometry
void updatePlanGeometry()
update pre-computed geometry information
Definition: GNEDemandElementPlan.cpp:1208
GNEDemandElementPlan::getFirstPlanPathLane
GNELane * getFirstPlanPathLane() const
get first plan path lane
Definition: GNEDemandElementPlan.cpp:1084
GNEDemandElementPlan::writeOriginStop
void writeOriginStop(OutputDevice &device) const
write initial stop stage if plan starts at a stopping place
Definition: GNEDemandElementPlan.cpp:1039
GNEDemandElementPlan::replacePlanParent
bool replacePlanParent(const std::string &newParentID)
replace plan parent
Definition: GNEDemandElementPlan.cpp:2263
GNEDemandElementPlan::getEndPosRadius
double getEndPosRadius(const GUIVisualizationSettings &s, const GNEPathManager::Segment *segment, const bool drawHalfWidth) const
get end position radius
Definition: GNEDemandElementPlan.cpp:2193
GNEDemandElementPlan::getTransportTagIcon
static std::pair< SumoXMLTag, GUIIcon > getTransportTagIcon(const CommonXMLStructure::PlanParameters &planParameters)
get the transport tag and icon for the combination
Definition: GNEDemandElementPlan.cpp:557
GNEHierarchicalElement::getParentJunctions
const std::vector< GNEJunction * > & getParentJunctions() const
get parent junctions
Definition: GNEHierarchicalElement.cpp:111
GNEHierarchicalElement::getChildDemandElements
const std::vector< GNEDemandElement * > & getChildDemandElements() const
return child demand elements
Definition: GNEHierarchicalElement.cpp:195
GNEHierarchicalElement::getParentStoppingPlaces
const std::vector< GNEAdditional * > getParentStoppingPlaces() const
get parent stoppingPlaces (used by plans)
Definition: GNEHierarchicalElement.cpp:135
GNEHierarchicalElement::getParentTAZs
const std::vector< GNEAdditional * > getParentTAZs() const
get parent TAZs (used by plans)
Definition: GNEHierarchicalElement.cpp:147
GNEHierarchicalElement::getParentDemandElements
const std::vector< GNEDemandElement * > & getParentDemandElements() const
get parent demand elements
Definition: GNEHierarchicalElement.cpp:159
GNEHierarchicalElement::getParentAdditionals
const std::vector< GNEAdditional * > & getParentAdditionals() const
get parent additionals
Definition: GNEHierarchicalElement.cpp:129
GNEHierarchicalElement::getParentEdges
const std::vector< GNEEdge * > & getParentEdges() const
get parent edges
Definition: GNEHierarchicalElement.cpp:117
GNELane2laneConnection::exist
bool exist(const GNELane *toLane) const
check if exist a lane2lane geometry for the given toLane
Definition: GNELane2laneConnection.cpp:73
GNELane2laneConnection::getLane2laneGeometry
const GUIGeometry & getLane2laneGeometry(const GNELane *toLane) const
get lane2lane geometry
Definition: GNELane2laneConnection.cpp:79
GNELane
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:46
GNELane::getLaneShape
const PositionVector & getLaneShape() const
get elements shape
Definition: GNELane.cpp:214
GNELane::getLane2laneConnections
const GNELane2laneConnection & getLane2laneConnections() const
get Lane2laneConnection struct
Definition: GNELane.cpp:657
GNELane::getLaneGeometry
const GUIGeometry & getLaneGeometry() const
get lane geometry
Definition: GNELane.cpp:208
GNEMoveOperation
move operation
Definition: GNEMoveElement.h:40
GNENetHelper::AttributeCarriers::retrieveDemandElement
GNEDemandElement * retrieveDemandElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named demand element.
Definition: GNENetHelper.cpp:1344
GNENet::addGLObjectIntoGrid
void addGLObjectIntoGrid(GNEAttributeCarrier *AC)
add GL Object into net
Definition: GNENet.cpp:1368
GNENet::removeGLObjectFromGrid
void removeGLObjectFromGrid(GNEAttributeCarrier *AC)
add GL Object into net
Definition: GNENet.cpp:1378
GNENet::getAttributeCarriers
GNENetHelper::AttributeCarriers * getAttributeCarriers() const
get all attribute carriers used in this net
Definition: GNENet.cpp:123
GNENet::getPathManager
GNEPathManager * getPathManager()
get path manager
Definition: GNENet.cpp:135
GNENet::getViewNet
GNEViewNet * getViewNet() const
get view net
Definition: GNENet.cpp:2136
GNEPathManager::PathDraw::checkDrawPathGeometry
bool checkDrawPathGeometry(const GUIVisualizationSettings &s, const GNELane *lane, SumoXMLTag tag)
check if path element geometry must be drawn in the given lane
Definition: GNEPathManager.cpp:565
GNEPathManager::Segment::getPreviousLane
const GNELane * getPreviousLane() const
get previous lane
Definition: GNEPathManager.cpp:128
GNEPathManager::Segment::getContour
GNEContour * getContour() const
getcontour associated with segment
Definition: GNEPathManager.cpp:98
GNEPathManager::Segment::getNextLane
const GNELane * getNextLane() const
get next lane
Definition: GNEPathManager.cpp:138
GNEPathManager::Segment::getLane
const GNELane * getLane() const
get lane associated with this segment
Definition: GNEPathManager.cpp:122
GNEPathManager::Segment::isLastSegment
bool isLastSegment() const
check if segment is the last path's segment
Definition: GNEPathManager.cpp:110
GNEPathManager::Segment::isFirstSegment
bool isFirstSegment() const
check if segment is the first path's segment
Definition: GNEPathManager.cpp:104
GNEPathManager::getPathDraw
PathDraw * getPathDraw()
obtain instance of PathDraw
Definition: GNEPathManager.cpp:673
GNEPathManager::calculateConsecutivePathEdges
void calculateConsecutivePathEdges(PathElement *pathElement, SUMOVehicleClass vClass, const std::vector< GNEEdge * > edges)
calculate consecutive path edges
Definition: GNEPathManager.cpp:752
GNETagProperties::planFromJunction
bool planFromJunction() const
return true if tag correspond to a plan that starts in junction
Definition: GNETagProperties.cpp:584
GNETagProperties::planToStoppingPlace
bool planToStoppingPlace() const
return true if tag correspond to a plan that ends in stoppingPlace
Definition: GNETagProperties.cpp:674
GNETagProperties::planStoppingPlace
bool planStoppingPlace() const
return true if tag correspond to a plan placed in stoppingPlace
Definition: GNETagProperties.cpp:556
GNETagProperties::planToJunction
bool planToJunction() const
return true if tag correspond to a plan that starts in junction
Definition: GNETagProperties.cpp:639
GNETagProperties::planFromStoppingPlace
bool planFromStoppingPlace() const
return true if tag correspond to a plan that starts in stoppingPlace
Definition: GNETagProperties.cpp:620
GNETagProperties::planFromEdge
bool planFromEdge() const
return true if tag correspond to a plan that starts in edge
Definition: GNETagProperties.cpp:572
GNETagProperties::isPlanContainer
bool isPlanContainer() const
return true if tag correspond to a container plan
Definition: GNETagProperties.cpp:412
GNETagProperties::isPlanPerson
bool isPlanPerson() const
return true if tag correspond to a person plan
Definition: GNETagProperties.cpp:406
GNETagProperties::planToEdge
bool planToEdge() const
return true if tag correspond to a plan that starts in edge
Definition: GNETagProperties.cpp:627
GNEViewNet::getInspectedAttributeCarriers
const std::vector< GNEAttributeCarrier * > & getInspectedAttributeCarriers() const
get inspected attribute carriers
Definition: GNEViewNet.cpp:1867
GNEViewNet::buildSelectionACPopupEntry
void buildSelectionACPopupEntry(GUIGLObjectPopupMenu *ret, GNEAttributeCarrier *AC)
Builds an entry which allows to (de)select the object.
Definition: GNEViewNet.cpp:553
GUIDesigns::buildFXMenuCommand
static FXMenuCommand * buildFXMenuCommand(FXComposite *p, const std::string &text, FXIcon *icon, FXObject *tgt, FXSelector sel, const bool disable=false)
build menu command
Definition: GUIDesigns.cpp:42
GUIGLObjectPopupMenu
The popup menu of a globject.
Definition: GUIGLObjectPopupMenu.h:45
GUIGeometry::clearGeometry
void clearGeometry()
clear geometry
Definition: GUIGeometry.cpp:184
GUIGeometry::drawGeometry
static void drawGeometry(const GUIVisualizationSettings::Detail d, const GUIGeometry &geometry, const double width, double offset=0)
draw geometry
Definition: GUIGeometry.cpp:277
GUIGeometry::drawChildLine
static void drawChildLine(const GUIVisualizationSettings &s, const Position &child, const Position &parent, const RGBColor &color, const bool drawEntire, const double lineWidth)
draw line between child and parent (used in netedit)
Definition: GUIGeometry.cpp:457
GUIGeometry::getShape
const PositionVector & getShape() const
The shape of the additional element.
Definition: GUIGeometry.cpp:211
GUIGeometry::updateGeometry
void updateGeometry(const PositionVector &shape)
update entire geometry
Definition: GUIGeometry.cpp:59
GUIGlObject::buildShowParamsPopupEntry
void buildShowParamsPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to open the parameter window.
Definition: GUIGlObject.cpp:317
GUIGlObject::getCenteringBoundary
virtual Boundary getCenteringBoundary() const =0
GUIGlObject::buildCenterPopupEntry
void buildCenterPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to center to the object.
Definition: GUIGlObject.cpp:285
GUIGlObject::buildPopupHeader
void buildPopupHeader(GUIGLObjectPopupMenu *ret, GUIMainWindow &app, bool addSeparator=true)
Builds the header.
Definition: GUIGlObject.cpp:273
GUIGlObject::getType
GUIGlObjectType getType() const
Returns the type of the object as coded in GUIGlObjectType.
Definition: GUIGlObject.h:156
GUIGlObject::buildPositionCopyEntry
void buildPositionCopyEntry(GUIGLObjectPopupMenu *ret, const GUIMainWindow &app) const
Builds an entry which allows to copy the cursor position if geo projection is used,...
Definition: GUIGlObject.cpp:335
GUIGlObject::drawName
void drawName(const Position &pos, const double scale, const GUIVisualizationTextSettings &settings, const double angle=0, bool forceShow=false) const
draw name of item
Definition: GUIGlObject.cpp:435
GUISUMOAbstractView::getPositionInformation
virtual Position getPositionInformation() const
Returns the cursor's x/y position within the network.
Definition: GUISUMOAbstractView.cpp:199
GUIViewObjectsHandler::isElementSelected
bool isElementSelected(const GUIGlObject *GLObject) const
check if element was already selected
Definition: GUIViewObjectsHandler.cpp:86
GUIVisualizationSettings
Stores the information about how to visualize structures.
Definition: GUIVisualizationSettings.h:584
GUIVisualizationSettings::addName
GUIVisualizationTextSettings addName
Definition: GUIVisualizationSettings.h:936
GUIVisualizationSettings::drawBoundaries
bool drawBoundaries
enable or disable draw boundaries
Definition: GUIVisualizationSettings.h:1040
GUIVisualizationSettings::drawForRectangleSelection
bool drawForRectangleSelection
whether drawing is performed for the purpose of selecting objects using a rectangle
Definition: GUIVisualizationSettings.h:1049
GUIVisualizationSettings::addSize
GUIVisualizationSizeSettings addSize
Definition: GUIVisualizationSettings.h:934
GUIVisualizationSettings::widthSettings
GUIVisualizationWidthSettings widthSettings
width settings
Definition: GUIVisualizationSettings.h:1116
GUIVisualizationSettings::getDetailLevel
Detail getDetailLevel(const double exaggeration) const
return the detail level
Definition: GUIVisualizationSettings.cpp:2570
GUIVisualizationSettings::laneWidthExaggeration
double laneWidthExaggeration
The lane exaggeration (upscale thickness)
Definition: GUIVisualizationSettings.h:777
GUIVisualizationSettings::checkDrawContainer
bool checkDrawContainer(Detail d, const bool selected) const
check if draw container
Definition: GUIVisualizationSettings.cpp:760
GUIVisualizationSettings::dottedContourSettings
GUIVisualizationDottedContourSettings dottedContourSettings
dotted contour settings
Definition: GUIVisualizationSettings.h:1113
GUIVisualizationSettings::scale
double scale
information about a lane's width (temporary, used for a single view)
Definition: GUIVisualizationSettings.h:1034
GUIVisualizationSettings::drawForViewObjectsHandler
bool drawForViewObjectsHandler
whether drawing is performed for the purpose of selecting objects in view using ViewObjectsHandler
Definition: GUIVisualizationSettings.h:1046
GUIVisualizationSettings::checkDrawPerson
bool checkDrawPerson(Detail d, const bool selected) const
check if draw person
Definition: GUIVisualizationSettings.cpp:746
OutputDevice
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
OutputDevice::openTag
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
Definition: OutputDevice.cpp:267
OutputDevice::writeAttr
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:254
OutputDevice::closeTag
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
Definition: OutputDevice.cpp:281
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
Position::distanceSquaredTo2D
double distanceSquaredTo2D(const Position &p2) const
returns the square of the distance to another position (Only using x and y positions)
Definition: Position.h:281
Position::INVALID
static const Position INVALID
used to indicate that a position is valid
Definition: Position.h:322
Position::x
double x() const
Returns the x-position.
Definition: Position.h:55
Position::y
double y() const
Returns the y-position.
Definition: Position.h:60
PositionVector::getBoxBoundary
Boundary getBoxBoundary() const
Returns a boundary enclosing this list of lines.
Definition: PositionVector.cpp:425
RGBColor::RED
static const RGBColor RED
named colors
Definition: RGBColor.h:185
GNEViewNetHelper::LockIcon::drawLockIcon
static void drawLockIcon(const GUIVisualizationSettings::Detail d, const GNEAttributeCarrier *AC, GUIGlObjectType type, const Position position, const double exaggeration, const double size=0.5, const double offsetx=0, const double offsety=0)
draw lock icon
Definition: GNEViewNetHelper.cpp:3965
GUIVisualizationDottedContourSettings::segmentWidth
static const double segmentWidth
width of dotted contour segments
Definition: GUIVisualizationSettings.h:509
GUIVisualizationSizeSettings::getExaggeration
double getExaggeration(const GUIVisualizationSettings &s, const GUIGlObject *o, double factor=20) const
return the drawing size including exaggeration and constantSize values
Definition: GUIVisualizationSettings.cpp:344
GUIVisualizationWidthSettings::personTripWidth
double personTripWidth
width for person trips
Definition: GUIVisualizationSettings.h:550