Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
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
36const double GNEDemandElementPlan::myArrivalPositionDiameter = SUMO_const_halfLaneWidth;
37
38// ===========================================================================
39// GNEDemandElement method definitions
40// ===========================================================================
41
42std::pair<SumoXMLTag, GUIIcon>
43GNEDemandElementPlan::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
216std::pair<SumoXMLTag, GUIIcon>
217GNEDemandElementPlan::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
386std::pair<SumoXMLTag, GUIIcon>
387GNEDemandElementPlan::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
556std::pair<SumoXMLTag, GUIIcon>
557GNEDemandElementPlan::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
726std::pair<SumoXMLTag, GUIIcon>
727GNEDemandElementPlan::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
898std::pair<SumoXMLTag, GUIIcon>
899GNEDemandElementPlan::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
918std::pair<SumoXMLTag, GUIIcon>
919GNEDemandElementPlan::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
938GNEDemandElementPlan::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
947GNEMoveOperation*
948GNEDemandElementPlan::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
971void
972GNEDemandElementPlan::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
1038void
1039GNEDemandElementPlan::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
1063GUIGLObjectPopupMenu*
1064GNEDemandElementPlan::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
1083GNELane*
1084GNEDemandElementPlan::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
1106GNELane*
1107GNEDemandElementPlan::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
1129void
1130GNEDemandElementPlan::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()->getDemandPathManager();
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
1207void
1208GNEDemandElementPlan::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
1268Boundary
1272
1273
1274void
1275GNEDemandElementPlan::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
1316Position
1317GNEDemandElementPlan::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
1348std::string
1349GNEDemandElementPlan::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
1411double
1412GNEDemandElementPlan::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
1488Position
1489GNEDemandElementPlan::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
1596void
1597GNEDemandElementPlan::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
1614bool
1615GNEDemandElementPlan::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
1640bool
1641GNEDemandElementPlan::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
1676void
1677GNEDemandElementPlan::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
1723std::string
1724GNEDemandElementPlan::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
1789bool
1790GNEDemandElementPlan::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
1830bool
1831GNEDemandElementPlan::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
1871void
1872GNEDemandElementPlan::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.isObjectSelected(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(), myPlanElement->getType(), pathWidth * 2, 1, true, true, 0);
1925 // calculate contour for end
1926 myPlanContourEnd.calculateContourCircleShape(s, d, myPlanElement, planGeometry.getShape().back(), 1, myPlanElement->getType(), 1);
1927 }
1928 // check if draw plan parent
1929 if (planParent->getPreviousChildDemandElement(myPlanElement) == nullptr) {
1930 planParent->drawGL(s);
1931 }
1932}
1933
1934
1935void
1936GNEDemandElementPlan::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()->getDemandPathManager()->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.isObjectSelected(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, myPlanElement->getType(), drawingWidth, 1, true, false, 0);
2028 } else if (segment->isLastSegment()) {
2029 segment->getContour()->calculateContourExtrudedShape(s, d, myPlanElement, shape, myPlanElement->getType(), drawingWidth, 1, false, false, 0);
2030 // calculate contour for end
2031 myPlanContourEnd.calculateContourCircleShape(s, d, myPlanElement, getPlanAttributePosition(GNE_ATTR_PLAN_GEOMETRY_ENDPOS), 2 * endPosRadius, myPlanElement->getType(), 1);
2032 } else {
2033 segment->getContour()->calculateContourExtrudedShape(s, d, myPlanElement, shape, myPlanElement->getType(), 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
2043void
2044GNEDemandElementPlan::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()->getDemandPathManager()->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.isObjectSelected(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, myPlanElement->getType(), 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 myPlanElement->getType(), 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 myPlanElement->getType(), 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
2126GNEDemandElement::Problem
2127GNEDemandElementPlan::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
2159std::string
2160GNEDemandElementPlan::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
2192double
2193GNEDemandElementPlan::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
2205void
2206GNEDemandElementPlan::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
2225void
2226GNEDemandElementPlan::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
2245void
2246GNEDemandElementPlan::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
2262bool
2263GNEDemandElementPlan::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:246
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:642
GNE_TAG_TRANSHIP_TAZ_TAZ
@ GNE_TAG_TRANSHIP_TAZ_TAZ
Definition SUMOXMLDefinitions.h:735
GNE_TAG_TRANSPORT_CONTAINERSTOP_TRAINSTOP
@ GNE_TAG_TRANSPORT_CONTAINERSTOP_TRAINSTOP
Definition SUMOXMLDefinitions.h:705
GNE_TAG_TRANSPORT_CONTAINERSTOP_BUSSTOP
@ GNE_TAG_TRANSPORT_CONTAINERSTOP_BUSSTOP
Definition SUMOXMLDefinitions.h:704
GNE_TAG_TRANSHIP_PARKINGAREA_BUSSTOP
@ GNE_TAG_TRANSHIP_PARKINGAREA_BUSSTOP
Definition SUMOXMLDefinitions.h:785
GNE_TAG_TRANSPORT_TAZ_CONTAINERSTOP
@ GNE_TAG_TRANSPORT_TAZ_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:674
GNE_TAG_TRANSHIP_PARKINGAREA_CHARGINGSTATION
@ GNE_TAG_TRANSHIP_PARKINGAREA_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:788
GNE_TAG_RIDE_EDGE_TAZ
@ GNE_TAG_RIDE_EDGE_TAZ
Definition SUMOXMLDefinitions.h:589
GNE_TAG_WALK_BUSSTOP_BUSSTOP
@ GNE_TAG_WALK_BUSSTOP_BUSSTOP
Definition SUMOXMLDefinitions.h:548
GNE_TAG_TRANSPORT_JUNCTION_CHARGINGSTATION
@ GNE_TAG_TRANSPORT_JUNCTION_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:683
GNE_TAG_TRANSHIP_JUNCTION_EDGE
@ GNE_TAG_TRANSHIP_JUNCTION_EDGE
Definition SUMOXMLDefinitions.h:742
GNE_TAG_PERSONTRIP_EDGE_EDGE
@ GNE_TAG_PERSONTRIP_EDGE_EDGE
Definition SUMOXMLDefinitions.h:456
GNE_TAG_PERSONTRIP_TAZ_EDGE
@ GNE_TAG_PERSONTRIP_TAZ_EDGE
Definition SUMOXMLDefinitions.h:464
GNE_TAG_TRANSHIP_JUNCTION_CONTAINERSTOP
@ GNE_TAG_TRANSHIP_JUNCTION_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:747
GNE_TAG_PERSONTRIP_EDGE_CONTAINERSTOP
@ GNE_TAG_PERSONTRIP_EDGE_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:461
GNE_TAG_WALK_EDGE_TAZ
@ GNE_TAG_WALK_EDGE_TAZ
Definition SUMOXMLDefinitions.h:522
GNE_TAG_WALK_PARKINGAREA_CHARGINGSTATION
@ GNE_TAG_WALK_PARKINGAREA_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:583
GNE_TAG_WALK_CHARGINGSTATION_JUNCTION
@ GNE_TAG_WALK_CHARGINGSTATION_JUNCTION
Definition SUMOXMLDefinitions.h:571
GNE_TAG_RIDE_CHARGINGSTATION_TAZ
@ GNE_TAG_RIDE_CHARGINGSTATION_TAZ
Definition SUMOXMLDefinitions.h:637
GNE_TAG_PERSONTRIP_CONTAINERSTOP_TAZ
@ GNE_TAG_PERSONTRIP_CONTAINERSTOP_TAZ
Definition SUMOXMLDefinitions.h:497
GNE_TAG_RIDE_CONTAINERSTOP_BUSSTOP
@ GNE_TAG_RIDE_CONTAINERSTOP_BUSSTOP
Definition SUMOXMLDefinitions.h:631
GNE_TAG_TRANSPORT_BUSSTOP_JUNCTION
@ GNE_TAG_TRANSPORT_BUSSTOP_JUNCTION
Definition SUMOXMLDefinitions.h:687
GNE_TAG_RIDE_BUSSTOP_BUSSTOP
@ GNE_TAG_RIDE_BUSSTOP_BUSSTOP
Definition SUMOXMLDefinitions.h:615
GNE_TAG_WALK_PARKINGAREA_CONTAINERSTOP
@ GNE_TAG_WALK_PARKINGAREA_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:582
GNE_TAG_PERSONTRIP_TAZ_CONTAINERSTOP
@ GNE_TAG_PERSONTRIP_TAZ_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:469
GNE_TAG_TRANSHIP_CHARGINGSTATION_BUSSTOP
@ GNE_TAG_TRANSHIP_CHARGINGSTATION_BUSSTOP
Definition SUMOXMLDefinitions.h:777
GNE_TAG_PERSONTRIP_CHARGINGSTATION_TRAINSTOP
@ GNE_TAG_PERSONTRIP_CHARGINGSTATION_TRAINSTOP
Definition SUMOXMLDefinitions.h:508
GNE_TAG_PERSONTRIP_EDGE_JUNCTION
@ GNE_TAG_PERSONTRIP_EDGE_JUNCTION
Definition SUMOXMLDefinitions.h:458
GNE_TAG_TRANSPORT_CHARGINGSTATION_JUNCTION
@ GNE_TAG_TRANSPORT_CHARGINGSTATION_JUNCTION
Definition SUMOXMLDefinitions.h:711
GNE_TAG_TRANSHIP_TRAINSTOP_CHARGINGSTATION
@ GNE_TAG_TRANSHIP_TRAINSTOP_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:764
GNE_TAG_RIDE_CONTAINERSTOP_CONTAINERSTOP
@ GNE_TAG_RIDE_CONTAINERSTOP_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:633
GNE_TAG_TRANSHIP_TRAINSTOP_EDGE
@ GNE_TAG_TRANSHIP_TRAINSTOP_EDGE
Definition SUMOXMLDefinitions.h:758
GNE_TAG_WALK_TAZ_BUSSTOP
@ GNE_TAG_WALK_TAZ_BUSSTOP
Definition SUMOXMLDefinitions.h:532
GNE_TAG_PERSONTRIP_EDGE_PARKINGAREA
@ GNE_TAG_PERSONTRIP_EDGE_PARKINGAREA
Definition SUMOXMLDefinitions.h:463
GNE_TAG_PERSONTRIP_TRAINSTOP_EDGE
@ GNE_TAG_PERSONTRIP_TRAINSTOP_EDGE
Definition SUMOXMLDefinitions.h:488
GNE_TAG_PERSONTRIP_TRAINSTOP_CONTAINERSTOP
@ GNE_TAG_PERSONTRIP_TRAINSTOP_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:493
GNE_TAG_PERSONTRIP_PARKINGAREA_TRAINSTOP
@ GNE_TAG_PERSONTRIP_PARKINGAREA_TRAINSTOP
Definition SUMOXMLDefinitions.h:516
GNE_TAG_STOPCONTAINER_TRAINSTOP
@ GNE_TAG_STOPCONTAINER_TRAINSTOP
Definition SUMOXMLDefinitions.h:795
GNE_TAG_RIDE_JUNCTION_BUSSTOP
@ GNE_TAG_RIDE_JUNCTION_BUSSTOP
Definition SUMOXMLDefinitions.h:607
GNE_TAG_RIDE_PARKINGAREA_CONTAINERSTOP
@ GNE_TAG_RIDE_PARKINGAREA_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:649
GNE_TAG_PERSONTRIP_CHARGINGSTATION_PARKINGAREA
@ GNE_TAG_PERSONTRIP_CHARGINGSTATION_PARKINGAREA
Definition SUMOXMLDefinitions.h:511
GNE_TAG_PERSONTRIP_TRAINSTOP_PARKINGAREA
@ GNE_TAG_PERSONTRIP_TRAINSTOP_PARKINGAREA
Definition SUMOXMLDefinitions.h:495
GNE_TAG_TRANSPORT_TAZ_PARKINGAREA
@ GNE_TAG_TRANSPORT_TAZ_PARKINGAREA
Definition SUMOXMLDefinitions.h:676
GNE_TAG_PERSONTRIP_TAZ_CHARGINGSTATION
@ GNE_TAG_PERSONTRIP_TAZ_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:470
GNE_TAG_RIDE_CONTAINERSTOP_EDGE
@ GNE_TAG_RIDE_CONTAINERSTOP_EDGE
Definition SUMOXMLDefinitions.h:628
GNE_TAG_TRANSHIP_TAZ_EDGE
@ GNE_TAG_TRANSHIP_TAZ_EDGE
Definition SUMOXMLDefinitions.h:734
GNE_TAG_WALK_BUSSTOP_CHARGINGSTATION
@ GNE_TAG_WALK_BUSSTOP_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:551
GNE_TAG_PERSONTRIP_BUSSTOP_EDGE
@ GNE_TAG_PERSONTRIP_BUSSTOP_EDGE
Definition SUMOXMLDefinitions.h:480
GNE_TAG_WALK_TRAINSTOP_CHARGINGSTATION
@ GNE_TAG_WALK_TRAINSTOP_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:559
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:581
GNE_TAG_WALK_PARKINGAREA_PARKINGAREA
@ GNE_TAG_WALK_PARKINGAREA_PARKINGAREA
Definition SUMOXMLDefinitions.h:584
GNE_TAG_TRANSPORT_EDGE_TRAINSTOP
@ GNE_TAG_TRANSPORT_EDGE_TRAINSTOP
Definition SUMOXMLDefinitions.h:665
GNE_TAG_WALK_BUSSTOP_TRAINSTOP
@ GNE_TAG_WALK_BUSSTOP_TRAINSTOP
Definition SUMOXMLDefinitions.h:549
GNE_TAG_TRANSHIP_EDGE_CHARGINGSTATION
@ GNE_TAG_TRANSHIP_EDGE_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:732
GNE_TAG_PERSONTRIP_TAZ_TRAINSTOP
@ GNE_TAG_PERSONTRIP_TAZ_TRAINSTOP
Definition SUMOXMLDefinitions.h:468
GNE_TAG_TRANSPORT_CONTAINERSTOP_CHARGINGSTATION
@ GNE_TAG_TRANSPORT_CONTAINERSTOP_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:707
GNE_TAG_TRANSPORT_CHARGINGSTATION_TAZ
@ GNE_TAG_TRANSPORT_CHARGINGSTATION_TAZ
Definition SUMOXMLDefinitions.h:710
GNE_TAG_WALK_TAZ_CONTAINERSTOP
@ GNE_TAG_WALK_TAZ_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:534
GNE_TAG_WALK_PARKINGAREA_JUNCTION
@ GNE_TAG_WALK_PARKINGAREA_JUNCTION
Definition SUMOXMLDefinitions.h:579
GNE_TAG_WALK_CONTAINERSTOP_EDGE
@ GNE_TAG_WALK_CONTAINERSTOP_EDGE
Definition SUMOXMLDefinitions.h:561
GNE_TAG_TRANSHIP_JUNCTION_BUSSTOP
@ GNE_TAG_TRANSHIP_JUNCTION_BUSSTOP
Definition SUMOXMLDefinitions.h:745
GNE_TAG_PERSONTRIP_EDGE_CHARGINGSTATION
@ GNE_TAG_PERSONTRIP_EDGE_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:462
GNE_TAG_TRANSPORT_EDGE_PARKINGAREA
@ GNE_TAG_TRANSPORT_EDGE_PARKINGAREA
Definition SUMOXMLDefinitions.h:668
GNE_TAG_TRANSPORT_TRAINSTOP_JUNCTION
@ GNE_TAG_TRANSPORT_TRAINSTOP_JUNCTION
Definition SUMOXMLDefinitions.h:695
GNE_TAG_TRANSHIP_PARKINGAREA_JUNCTION
@ GNE_TAG_TRANSHIP_PARKINGAREA_JUNCTION
Definition SUMOXMLDefinitions.h:784
GNE_TAG_TRANSHIP_BUSSTOP_CHARGINGSTATION
@ GNE_TAG_TRANSHIP_BUSSTOP_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:756
GNE_TAG_TRANSPORT_TAZ_TRAINSTOP
@ GNE_TAG_TRANSPORT_TAZ_TRAINSTOP
Definition SUMOXMLDefinitions.h:673
GNE_TAG_WALK_EDGE_PARKINGAREA
@ GNE_TAG_WALK_EDGE_PARKINGAREA
Definition SUMOXMLDefinitions.h:528
GNE_TAG_TRANSPORT_EDGE_BUSSTOP
@ GNE_TAG_TRANSPORT_EDGE_BUSSTOP
Definition SUMOXMLDefinitions.h:664
GNE_TAG_TRANSPORT_CONTAINERSTOP_EDGE
@ GNE_TAG_TRANSPORT_CONTAINERSTOP_EDGE
Definition SUMOXMLDefinitions.h:701
GNE_TAG_TRANSPORT_CHARGINGSTATION_PARKINGAREA
@ GNE_TAG_TRANSPORT_CHARGINGSTATION_PARKINGAREA
Definition SUMOXMLDefinitions.h:716
SUMO_TAG_NOTHING
@ SUMO_TAG_NOTHING
invalid tag, must be the last one
Definition SUMOXMLDefinitions.h:802
GNE_TAG_WALK_PARKINGAREA_EDGE
@ GNE_TAG_WALK_PARKINGAREA_EDGE
Definition SUMOXMLDefinitions.h:577
GNE_TAG_TRANSHIP_EDGE_EDGE
@ GNE_TAG_TRANSHIP_EDGE_EDGE
Definition SUMOXMLDefinitions.h:726
GNE_TAG_RIDE_TAZ_EDGE
@ GNE_TAG_RIDE_TAZ_EDGE
Definition SUMOXMLDefinitions.h:596
GNE_TAG_RIDE_TRAINSTOP_JUNCTION
@ GNE_TAG_RIDE_TRAINSTOP_JUNCTION
Definition SUMOXMLDefinitions.h:622
GNE_TAG_WALK_EDGES
@ GNE_TAG_WALK_EDGES
Definition SUMOXMLDefinitions.h:585
GNE_TAG_RIDE_TRAINSTOP_CONTAINERSTOP
@ GNE_TAG_RIDE_TRAINSTOP_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:625
GNE_TAG_TRANSPORT_JUNCTION_PARKINGAREA
@ GNE_TAG_TRANSPORT_JUNCTION_PARKINGAREA
Definition SUMOXMLDefinitions.h:684
GNE_TAG_RIDE_CHARGINGSTATION_EDGE
@ GNE_TAG_RIDE_CHARGINGSTATION_EDGE
Definition SUMOXMLDefinitions.h:636
GNE_TAG_RIDE_CHARGINGSTATION_CONTAINERSTOP
@ GNE_TAG_RIDE_CHARGINGSTATION_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:641
GNE_TAG_WALK_CONTAINERSTOP_CHARGINGSTATION
@ GNE_TAG_WALK_CONTAINERSTOP_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:567
SUMO_TAG_CONTAINERFLOW
@ SUMO_TAG_CONTAINERFLOW
Definition SUMOXMLDefinitions.h:378
GNE_TAG_TRANSHIP_PARKINGAREA_CONTAINERSTOP
@ GNE_TAG_TRANSHIP_PARKINGAREA_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:787
GNE_TAG_TRANSPORT_TRAINSTOP_TAZ
@ GNE_TAG_TRANSPORT_TRAINSTOP_TAZ
Definition SUMOXMLDefinitions.h:694
GNE_TAG_WALK_BUSSTOP_JUNCTION
@ GNE_TAG_WALK_BUSSTOP_JUNCTION
Definition SUMOXMLDefinitions.h:547
GNE_TAG_TRANSHIP_CHARGINGSTATION_TRAINSTOP
@ GNE_TAG_TRANSHIP_CHARGINGSTATION_TRAINSTOP
Definition SUMOXMLDefinitions.h:778
GNE_TAG_TRANSHIP_EDGE_CONTAINERSTOP
@ GNE_TAG_TRANSHIP_EDGE_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:731
GNE_TAG_WALK_CONTAINERSTOP_JUNCTION
@ GNE_TAG_WALK_CONTAINERSTOP_JUNCTION
Definition SUMOXMLDefinitions.h:563
GNE_TAG_TRANSPORT_PARKINGAREA_PARKINGAREA
@ GNE_TAG_TRANSPORT_PARKINGAREA_PARKINGAREA
Definition SUMOXMLDefinitions.h:724
GNE_TAG_RIDE_EDGE_JUNCTION
@ GNE_TAG_RIDE_EDGE_JUNCTION
Definition SUMOXMLDefinitions.h:590
GNE_TAG_TRANSPORT_CHARGINGSTATION_TRAINSTOP
@ GNE_TAG_TRANSPORT_CHARGINGSTATION_TRAINSTOP
Definition SUMOXMLDefinitions.h:713
GNE_TAG_TRANSPORT_TRAINSTOP_TRAINSTOP
@ GNE_TAG_TRANSPORT_TRAINSTOP_TRAINSTOP
Definition SUMOXMLDefinitions.h:697
GNE_TAG_RIDE_PARKINGAREA_TAZ
@ GNE_TAG_RIDE_PARKINGAREA_TAZ
Definition SUMOXMLDefinitions.h:645
GNE_TAG_WALK_CHARGINGSTATION_TRAINSTOP
@ GNE_TAG_WALK_CHARGINGSTATION_TRAINSTOP
Definition SUMOXMLDefinitions.h:573
GNE_TAG_PERSONTRIP_BUSSTOP_CONTAINERSTOP
@ GNE_TAG_PERSONTRIP_BUSSTOP_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:485
GNE_TAG_TRANSPORT_TRAINSTOP_CONTAINERSTOP
@ GNE_TAG_TRANSPORT_TRAINSTOP_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:698
GNE_TAG_PERSONTRIP_PARKINGAREA_TAZ
@ GNE_TAG_PERSONTRIP_PARKINGAREA_TAZ
Definition SUMOXMLDefinitions.h:513
GNE_TAG_STOPCONTAINER_EDGE
@ GNE_TAG_STOPCONTAINER_EDGE
Definition SUMOXMLDefinitions.h:793
GNE_TAG_WALK_TRAINSTOP_TAZ
@ GNE_TAG_WALK_TRAINSTOP_TAZ
Definition SUMOXMLDefinitions.h:554
GNE_TAG_PERSONTRIP_PARKINGAREA_JUNCTION
@ GNE_TAG_PERSONTRIP_PARKINGAREA_JUNCTION
Definition SUMOXMLDefinitions.h:514
GNE_TAG_TRANSPORT_JUNCTION_BUSSTOP
@ GNE_TAG_TRANSPORT_JUNCTION_BUSSTOP
Definition SUMOXMLDefinitions.h:680
GNE_TAG_TRANSHIP_JUNCTION_PARKINGAREA
@ GNE_TAG_TRANSHIP_JUNCTION_PARKINGAREA
Definition SUMOXMLDefinitions.h:749
GNE_TAG_STOPCONTAINER_PARKINGAREA
@ GNE_TAG_STOPCONTAINER_PARKINGAREA
Definition SUMOXMLDefinitions.h:798
GNE_TAG_PERSONTRIP_CONTAINERSTOP_TRAINSTOP
@ GNE_TAG_PERSONTRIP_CONTAINERSTOP_TRAINSTOP
Definition SUMOXMLDefinitions.h:500
GNE_TAG_TRANSPORT_CHARGINGSTATION_CONTAINERSTOP
@ GNE_TAG_TRANSPORT_CHARGINGSTATION_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:714
GNE_TAG_TRANSPORT_TRAINSTOP_CHARGINGSTATION
@ GNE_TAG_TRANSPORT_TRAINSTOP_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:699
GNE_TAG_TRANSPORT_PARKINGAREA_CONTAINERSTOP
@ GNE_TAG_TRANSPORT_PARKINGAREA_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:722
GNE_TAG_STOPPERSON_BUSSTOP
@ GNE_TAG_STOPPERSON_BUSSTOP
Definition SUMOXMLDefinitions.h:655
GNE_TAG_TRANSPORT_BUSSTOP_CONTAINERSTOP
@ GNE_TAG_TRANSPORT_BUSSTOP_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:690
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:484
GNE_TAG_RIDE_PARKINGAREA_BUSSTOP
@ GNE_TAG_RIDE_PARKINGAREA_BUSSTOP
Definition SUMOXMLDefinitions.h:647
GNE_TAG_PERSONTRIP_CHARGINGSTATION_TAZ
@ GNE_TAG_PERSONTRIP_CHARGINGSTATION_TAZ
Definition SUMOXMLDefinitions.h:505
GNE_TAG_RIDE_TAZ_TRAINSTOP
@ GNE_TAG_RIDE_TAZ_TRAINSTOP
Definition SUMOXMLDefinitions.h:600
GNE_TAG_PERSONTRIP_CONTAINERSTOP_EDGE
@ GNE_TAG_PERSONTRIP_CONTAINERSTOP_EDGE
Definition SUMOXMLDefinitions.h:496
GNE_TAG_TRANSHIP_CONTAINERSTOP_PARKINGAREA
@ GNE_TAG_TRANSHIP_CONTAINERSTOP_PARKINGAREA
Definition SUMOXMLDefinitions.h:773
GNE_TAG_PERSONTRIP_JUNCTION_BUSSTOP
@ GNE_TAG_PERSONTRIP_JUNCTION_BUSSTOP
Definition SUMOXMLDefinitions.h:475
GNE_TAG_TRANSHIP_BUSSTOP_CONTAINERSTOP
@ GNE_TAG_TRANSHIP_BUSSTOP_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:755
GNE_TAG_PERSONTRIP_CHARGINGSTATION_BUSSTOP
@ GNE_TAG_PERSONTRIP_CHARGINGSTATION_BUSSTOP
Definition SUMOXMLDefinitions.h:507
GNE_TAG_TRANSPORT_PARKINGAREA_EDGE
@ GNE_TAG_TRANSPORT_PARKINGAREA_EDGE
Definition SUMOXMLDefinitions.h:717
GNE_TAG_PERSONTRIP_TRAINSTOP_TAZ
@ GNE_TAG_PERSONTRIP_TRAINSTOP_TAZ
Definition SUMOXMLDefinitions.h:489
GNE_TAG_RIDE_PARKINGAREA_JUNCTION
@ GNE_TAG_RIDE_PARKINGAREA_JUNCTION
Definition SUMOXMLDefinitions.h:646
GNE_TAG_TRANSHIP_PARKINGAREA_TRAINSTOP
@ GNE_TAG_TRANSHIP_PARKINGAREA_TRAINSTOP
Definition SUMOXMLDefinitions.h:786
GNE_TAG_RIDE_JUNCTION_JUNCTION
@ GNE_TAG_RIDE_JUNCTION_JUNCTION
Definition SUMOXMLDefinitions.h:606
GNE_TAG_WALK_BUSSTOP_CONTAINERSTOP
@ GNE_TAG_WALK_BUSSTOP_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:550
GNE_TAG_RIDE_BUSSTOP_TAZ
@ GNE_TAG_RIDE_BUSSTOP_TAZ
Definition SUMOXMLDefinitions.h:613
GNE_TAG_PERSONTRIP_TAZ_PARKINGAREA
@ GNE_TAG_PERSONTRIP_TAZ_PARKINGAREA
Definition SUMOXMLDefinitions.h:471
GNE_TAG_TRANSHIP_BUSSTOP_JUNCTION
@ GNE_TAG_TRANSHIP_BUSSTOP_JUNCTION
Definition SUMOXMLDefinitions.h:752
GNE_TAG_RIDE_JUNCTION_PARKINGAREA
@ GNE_TAG_RIDE_JUNCTION_PARKINGAREA
Definition SUMOXMLDefinitions.h:611
GNE_TAG_TRANSPORT_EDGE_TAZ
@ GNE_TAG_TRANSPORT_EDGE_TAZ
Definition SUMOXMLDefinitions.h:662
GNE_TAG_PERSONTRIP_CONTAINERSTOP_PARKINGAREA
@ GNE_TAG_PERSONTRIP_CONTAINERSTOP_PARKINGAREA
Definition SUMOXMLDefinitions.h:503
GNE_TAG_WALK_JUNCTION_PARKINGAREA
@ GNE_TAG_WALK_JUNCTION_PARKINGAREA
Definition SUMOXMLDefinitions.h:544
GNE_TAG_TRANSHIP_EDGE_TAZ
@ GNE_TAG_TRANSHIP_EDGE_TAZ
Definition SUMOXMLDefinitions.h:727
GNE_TAG_RIDE_TRAINSTOP_TAZ
@ GNE_TAG_RIDE_TRAINSTOP_TAZ
Definition SUMOXMLDefinitions.h:621
GNE_TAG_RIDE_TRAINSTOP_CHARGINGSTATION
@ GNE_TAG_RIDE_TRAINSTOP_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:626
GNE_TAG_WALK_CHARGINGSTATION_BUSSTOP
@ GNE_TAG_WALK_CHARGINGSTATION_BUSSTOP
Definition SUMOXMLDefinitions.h:572
GNE_TAG_PERSONTRIP_JUNCTION_TRAINSTOP
@ GNE_TAG_PERSONTRIP_JUNCTION_TRAINSTOP
Definition SUMOXMLDefinitions.h:476
GNE_TAG_RIDE_JUNCTION_TRAINSTOP
@ GNE_TAG_RIDE_JUNCTION_TRAINSTOP
Definition SUMOXMLDefinitions.h:608
GNE_TAG_WALK_CONTAINERSTOP_TAZ
@ GNE_TAG_WALK_CONTAINERSTOP_TAZ
Definition SUMOXMLDefinitions.h:562
GNE_TAG_PERSONTRIP_TRAINSTOP_BUSSTOP
@ GNE_TAG_PERSONTRIP_TRAINSTOP_BUSSTOP
Definition SUMOXMLDefinitions.h:491
GNE_TAG_TRANSHIP_BUSSTOP_EDGE
@ GNE_TAG_TRANSHIP_BUSSTOP_EDGE
Definition SUMOXMLDefinitions.h:750
GNE_TAG_TRANSHIP_TRAINSTOP_JUNCTION
@ GNE_TAG_TRANSHIP_TRAINSTOP_JUNCTION
Definition SUMOXMLDefinitions.h:760
GNE_TAG_TRANSPORT_CHARGINGSTATION_CHARGINGSTATION
@ GNE_TAG_TRANSPORT_CHARGINGSTATION_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:715
GNE_TAG_TRANSHIP_EDGE_JUNCTION
@ GNE_TAG_TRANSHIP_EDGE_JUNCTION
Definition SUMOXMLDefinitions.h:728
GNE_TAG_PERSONTRIP_BUSSTOP_JUNCTION
@ GNE_TAG_PERSONTRIP_BUSSTOP_JUNCTION
Definition SUMOXMLDefinitions.h:482
GNE_TAG_TRANSHIP_EDGES
@ GNE_TAG_TRANSHIP_EDGES
Definition SUMOXMLDefinitions.h:790
GNE_TAG_TRANSHIP_TAZ_TRAINSTOP
@ GNE_TAG_TRANSHIP_TAZ_TRAINSTOP
Definition SUMOXMLDefinitions.h:738
GNE_TAG_WALK_JUNCTION_CONTAINERSTOP
@ GNE_TAG_WALK_JUNCTION_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:542
GNE_TAG_STOPCONTAINER_CONTAINERSTOP
@ GNE_TAG_STOPCONTAINER_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:796
GNE_TAG_RIDE_TAZ_CONTAINERSTOP
@ GNE_TAG_RIDE_TAZ_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:601
GNE_TAG_RIDE_BUSSTOP_TRAINSTOP
@ GNE_TAG_RIDE_BUSSTOP_TRAINSTOP
Definition SUMOXMLDefinitions.h:616
GNE_TAG_TRANSHIP_CHARGINGSTATION_EDGE
@ GNE_TAG_TRANSHIP_CHARGINGSTATION_EDGE
Definition SUMOXMLDefinitions.h:774
GNE_TAG_PERSONTRIP_EDGE_TRAINSTOP
@ GNE_TAG_PERSONTRIP_EDGE_TRAINSTOP
Definition SUMOXMLDefinitions.h:460
GNE_TAG_RIDE_BUSSTOP_EDGE
@ GNE_TAG_RIDE_BUSSTOP_EDGE
Definition SUMOXMLDefinitions.h:612
GNE_TAG_RIDE_TRAINSTOP_BUSSTOP
@ GNE_TAG_RIDE_TRAINSTOP_BUSSTOP
Definition SUMOXMLDefinitions.h:623
GNE_TAG_TRANSPORT_CONTAINERSTOP_TAZ
@ GNE_TAG_TRANSPORT_CONTAINERSTOP_TAZ
Definition SUMOXMLDefinitions.h:702
GNE_TAG_WALK_TRAINSTOP_EDGE
@ GNE_TAG_WALK_TRAINSTOP_EDGE
Definition SUMOXMLDefinitions.h:553
GNE_TAG_RIDE_EDGE_EDGE
@ GNE_TAG_RIDE_EDGE_EDGE
Definition SUMOXMLDefinitions.h:588
GNE_TAG_PERSONTRIP_PARKINGAREA_EDGE
@ GNE_TAG_PERSONTRIP_PARKINGAREA_EDGE
Definition SUMOXMLDefinitions.h:512
GNE_TAG_TRANSPORT_BUSSTOP_CHARGINGSTATION
@ GNE_TAG_TRANSPORT_BUSSTOP_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:691
GNE_TAG_RIDE_JUNCTION_CONTAINERSTOP
@ GNE_TAG_RIDE_JUNCTION_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:609
GNE_TAG_TRANSPORT_PARKINGAREA_TAZ
@ GNE_TAG_TRANSPORT_PARKINGAREA_TAZ
Definition SUMOXMLDefinitions.h:718
GNE_TAG_PERSONTRIP_PARKINGAREA_CONTAINERSTOP
@ GNE_TAG_PERSONTRIP_PARKINGAREA_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:517
GNE_TAG_PERSONTRIP_TRAINSTOP_TRAINSTOP
@ GNE_TAG_PERSONTRIP_TRAINSTOP_TRAINSTOP
Definition SUMOXMLDefinitions.h:492
GNE_TAG_TRANSPORT_EDGE_EDGE
@ GNE_TAG_TRANSPORT_EDGE_EDGE
Definition SUMOXMLDefinitions.h:661
GNE_TAG_WALK_EDGE_TRAINSTOP
@ GNE_TAG_WALK_EDGE_TRAINSTOP
Definition SUMOXMLDefinitions.h:525
GNE_TAG_WALK_TAZ_CHARGINGSTATION
@ GNE_TAG_WALK_TAZ_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:535
GNE_TAG_TRANSPORT_EDGE_CONTAINERSTOP
@ GNE_TAG_TRANSPORT_EDGE_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:666
GNE_TAG_STOPCONTAINER_BUSSTOP
@ GNE_TAG_STOPCONTAINER_BUSSTOP
Definition SUMOXMLDefinitions.h:794
GNE_TAG_WALK_JUNCTION_TAZ
@ GNE_TAG_WALK_JUNCTION_TAZ
Definition SUMOXMLDefinitions.h:538
GNE_TAG_WALK_JUNCTION_CHARGINGSTATION
@ GNE_TAG_WALK_JUNCTION_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:543
GNE_TAG_WALK_CHARGINGSTATION_TAZ
@ GNE_TAG_WALK_CHARGINGSTATION_TAZ
Definition SUMOXMLDefinitions.h:570
GNE_TAG_PERSONTRIP_TAZ_BUSSTOP
@ GNE_TAG_PERSONTRIP_TAZ_BUSSTOP
Definition SUMOXMLDefinitions.h:467
GNE_TAG_RIDE_PARKINGAREA_CHARGINGSTATION
@ GNE_TAG_RIDE_PARKINGAREA_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:650
GNE_TAG_RIDE_BUSSTOP_JUNCTION
@ GNE_TAG_RIDE_BUSSTOP_JUNCTION
Definition SUMOXMLDefinitions.h:614
GNE_TAG_PERSONTRIP_CHARGINGSTATION_JUNCTION
@ GNE_TAG_PERSONTRIP_CHARGINGSTATION_JUNCTION
Definition SUMOXMLDefinitions.h:506
GNE_TAG_PERSONTRIP_CHARGINGSTATION_CHARGINGSTATION
@ GNE_TAG_PERSONTRIP_CHARGINGSTATION_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:510
GNE_TAG_WALK_JUNCTION_JUNCTION
@ GNE_TAG_WALK_JUNCTION_JUNCTION
Definition SUMOXMLDefinitions.h:539
GNE_TAG_TRANSPORT_BUSSTOP_TAZ
@ GNE_TAG_TRANSPORT_BUSSTOP_TAZ
Definition SUMOXMLDefinitions.h:686
GNE_TAG_RIDE_JUNCTION_CHARGINGSTATION
@ GNE_TAG_RIDE_JUNCTION_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:610
GNE_TAG_TRANSPORT_PARKINGAREA_TRAINSTOP
@ GNE_TAG_TRANSPORT_PARKINGAREA_TRAINSTOP
Definition SUMOXMLDefinitions.h:721
SUMO_TAG_CONTAINER
@ SUMO_TAG_CONTAINER
Definition SUMOXMLDefinitions.h:375
GNE_TAG_TRANSHIP_PARKINGAREA_TAZ
@ GNE_TAG_TRANSHIP_PARKINGAREA_TAZ
Definition SUMOXMLDefinitions.h:783
GNE_TAG_TRANSHIP_PARKINGAREA_PARKINGAREA
@ GNE_TAG_TRANSHIP_PARKINGAREA_PARKINGAREA
Definition SUMOXMLDefinitions.h:789
GNE_TAG_WALK_CONTAINERSTOP_PARKINGAREA
@ GNE_TAG_WALK_CONTAINERSTOP_PARKINGAREA
Definition SUMOXMLDefinitions.h:568
GNE_TAG_TRANSHIP_TAZ_PARKINGAREA
@ GNE_TAG_TRANSHIP_TAZ_PARKINGAREA
Definition SUMOXMLDefinitions.h:741
GNE_TAG_WALK_EDGE_EDGE
@ GNE_TAG_WALK_EDGE_EDGE
Definition SUMOXMLDefinitions.h:521
GNE_TAG_PERSONTRIP_TAZ_TAZ
@ GNE_TAG_PERSONTRIP_TAZ_TAZ
Definition SUMOXMLDefinitions.h:465
GNE_TAG_TRANSPORT_CONTAINERSTOP_JUNCTION
@ GNE_TAG_TRANSPORT_CONTAINERSTOP_JUNCTION
Definition SUMOXMLDefinitions.h:703
GNE_TAG_TRANSHIP_TAZ_BUSSTOP
@ GNE_TAG_TRANSHIP_TAZ_BUSSTOP
Definition SUMOXMLDefinitions.h:737
GNE_TAG_TRANSPORT_TAZ_EDGE
@ GNE_TAG_TRANSPORT_TAZ_EDGE
Definition SUMOXMLDefinitions.h:669
GNE_TAG_TRANSHIP_CHARGINGSTATION_CHARGINGSTATION
@ GNE_TAG_TRANSHIP_CHARGINGSTATION_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:780
GNE_TAG_RIDE_EDGE_CHARGINGSTATION
@ GNE_TAG_RIDE_EDGE_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:594
GNE_TAG_TRANSPORT_TAZ_TAZ
@ GNE_TAG_TRANSPORT_TAZ_TAZ
Definition SUMOXMLDefinitions.h:670
GNE_TAG_PERSONTRIP_CHARGINGSTATION_EDGE
@ GNE_TAG_PERSONTRIP_CHARGINGSTATION_EDGE
Definition SUMOXMLDefinitions.h:504
GNE_TAG_PERSONTRIP_EDGE_BUSSTOP
@ GNE_TAG_PERSONTRIP_EDGE_BUSSTOP
Definition SUMOXMLDefinitions.h:459
GNE_TAG_TRANSPORT_EDGE_JUNCTION
@ GNE_TAG_TRANSPORT_EDGE_JUNCTION
Definition SUMOXMLDefinitions.h:663
GNE_TAG_WALK_CHARGINGSTATION_CONTAINERSTOP
@ GNE_TAG_WALK_CHARGINGSTATION_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:574
GNE_TAG_TRANSPORT_TAZ_BUSSTOP
@ GNE_TAG_TRANSPORT_TAZ_BUSSTOP
Definition SUMOXMLDefinitions.h:672
GNE_TAG_WALK_BUSSTOP_PARKINGAREA
@ GNE_TAG_WALK_BUSSTOP_PARKINGAREA
Definition SUMOXMLDefinitions.h:552
GNE_TAG_WALK_CHARGINGSTATION_PARKINGAREA
@ GNE_TAG_WALK_CHARGINGSTATION_PARKINGAREA
Definition SUMOXMLDefinitions.h:576
GNE_TAG_TRANSPORT_JUNCTION_JUNCTION
@ GNE_TAG_TRANSPORT_JUNCTION_JUNCTION
Definition SUMOXMLDefinitions.h:679
GNE_TAG_PERSONTRIP_CHARGINGSTATION_CONTAINERSTOP
@ GNE_TAG_PERSONTRIP_CHARGINGSTATION_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:509
GNE_TAG_TRANSHIP_BUSSTOP_TRAINSTOP
@ GNE_TAG_TRANSHIP_BUSSTOP_TRAINSTOP
Definition SUMOXMLDefinitions.h:754
GNE_TAG_PERSONTRIP_BUSSTOP_TAZ
@ GNE_TAG_PERSONTRIP_BUSSTOP_TAZ
Definition SUMOXMLDefinitions.h:481
GNE_TAG_RIDE_TAZ_PARKINGAREA
@ GNE_TAG_RIDE_TAZ_PARKINGAREA
Definition SUMOXMLDefinitions.h:603
GNE_TAG_WALK_CONTAINERSTOP_BUSSTOP
@ GNE_TAG_WALK_CONTAINERSTOP_BUSSTOP
Definition SUMOXMLDefinitions.h:564
GNE_TAG_RIDE_CHARGINGSTATION_PARKINGAREA
@ GNE_TAG_RIDE_CHARGINGSTATION_PARKINGAREA
Definition SUMOXMLDefinitions.h:643
GNE_TAG_RIDE_CHARGINGSTATION_BUSSTOP
@ GNE_TAG_RIDE_CHARGINGSTATION_BUSSTOP
Definition SUMOXMLDefinitions.h:639
GNE_TAG_PERSONTRIP_CONTAINERSTOP_CONTAINERSTOP
@ GNE_TAG_PERSONTRIP_CONTAINERSTOP_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:501
GNE_TAG_TRANSHIP_CONTAINERSTOP_TAZ
@ GNE_TAG_TRANSHIP_CONTAINERSTOP_TAZ
Definition SUMOXMLDefinitions.h:767
GNE_TAG_TRANSPORT_CHARGINGSTATION_EDGE
@ GNE_TAG_TRANSPORT_CHARGINGSTATION_EDGE
Definition SUMOXMLDefinitions.h:709
GNE_TAG_PERSONTRIP_BUSSTOP_CHARGINGSTATION
@ GNE_TAG_PERSONTRIP_BUSSTOP_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:486
GNE_TAG_WALK_BUSSTOP_EDGE
@ GNE_TAG_WALK_BUSSTOP_EDGE
Definition SUMOXMLDefinitions.h:545
GNE_TAG_RIDE_JUNCTION_TAZ
@ GNE_TAG_RIDE_JUNCTION_TAZ
Definition SUMOXMLDefinitions.h:605
GNE_TAG_TRANSPORT_TRAINSTOP_BUSSTOP
@ GNE_TAG_TRANSPORT_TRAINSTOP_BUSSTOP
Definition SUMOXMLDefinitions.h:696
GNE_TAG_WALK_JUNCTION_TRAINSTOP
@ GNE_TAG_WALK_JUNCTION_TRAINSTOP
Definition SUMOXMLDefinitions.h:541
GNE_TAG_RIDE_TAZ_TAZ
@ GNE_TAG_RIDE_TAZ_TAZ
Definition SUMOXMLDefinitions.h:597
GNE_TAG_TRANSHIP_EDGE_TRAINSTOP
@ GNE_TAG_TRANSHIP_EDGE_TRAINSTOP
Definition SUMOXMLDefinitions.h:730
GNE_TAG_TRANSHIP_TRAINSTOP_TRAINSTOP
@ GNE_TAG_TRANSHIP_TRAINSTOP_TRAINSTOP
Definition SUMOXMLDefinitions.h:762
GNE_TAG_RIDE_PARKINGAREA_PARKINGAREA
@ GNE_TAG_RIDE_PARKINGAREA_PARKINGAREA
Definition SUMOXMLDefinitions.h:651
GNE_TAG_WALK_TRAINSTOP_PARKINGAREA
@ GNE_TAG_WALK_TRAINSTOP_PARKINGAREA
Definition SUMOXMLDefinitions.h:560
GNE_TAG_RIDE_EDGE_BUSSTOP
@ GNE_TAG_RIDE_EDGE_BUSSTOP
Definition SUMOXMLDefinitions.h:591
GNE_TAG_WALK_TAZ_JUNCTION
@ GNE_TAG_WALK_TAZ_JUNCTION
Definition SUMOXMLDefinitions.h:531
GNE_TAG_RIDE_TAZ_JUNCTION
@ GNE_TAG_RIDE_TAZ_JUNCTION
Definition SUMOXMLDefinitions.h:598
GNE_TAG_PERSONTRIP_JUNCTION_PARKINGAREA
@ GNE_TAG_PERSONTRIP_JUNCTION_PARKINGAREA
Definition SUMOXMLDefinitions.h:479
GNE_TAG_TRANSPORT_BUSSTOP_TRAINSTOP
@ GNE_TAG_TRANSPORT_BUSSTOP_TRAINSTOP
Definition SUMOXMLDefinitions.h:689
GNE_TAG_TRANSPORT_TRAINSTOP_PARKINGAREA
@ GNE_TAG_TRANSPORT_TRAINSTOP_PARKINGAREA
Definition SUMOXMLDefinitions.h:700
GNE_TAG_TRANSPORT_PARKINGAREA_JUNCTION
@ GNE_TAG_TRANSPORT_PARKINGAREA_JUNCTION
Definition SUMOXMLDefinitions.h:719
GNE_TAG_STOPPERSON_CONTAINERSTOP
@ GNE_TAG_STOPPERSON_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:657
GNE_TAG_WALK_BUSSTOP_TAZ
@ GNE_TAG_WALK_BUSSTOP_TAZ
Definition SUMOXMLDefinitions.h:546
GNE_TAG_RIDE_CONTAINERSTOP_CHARGINGSTATION
@ GNE_TAG_RIDE_CONTAINERSTOP_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:634
GNE_TAG_TRANSPORT_CONTAINERSTOP_CONTAINERSTOP
@ GNE_TAG_TRANSPORT_CONTAINERSTOP_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:706
GNE_TAG_PERSONTRIP_BUSSTOP_BUSSTOP
@ GNE_TAG_PERSONTRIP_BUSSTOP_BUSSTOP
Definition SUMOXMLDefinitions.h:483
GNE_TAG_TRANSHIP_BUSSTOP_PARKINGAREA
@ GNE_TAG_TRANSHIP_BUSSTOP_PARKINGAREA
Definition SUMOXMLDefinitions.h:757
GNE_TAG_PERSONTRIP_JUNCTION_JUNCTION
@ GNE_TAG_PERSONTRIP_JUNCTION_JUNCTION
Definition SUMOXMLDefinitions.h:474
GNE_TAG_TRANSHIP_CONTAINERSTOP_JUNCTION
@ GNE_TAG_TRANSHIP_CONTAINERSTOP_JUNCTION
Definition SUMOXMLDefinitions.h:768
GNE_TAG_WALK_TAZ_TAZ
@ GNE_TAG_WALK_TAZ_TAZ
Definition SUMOXMLDefinitions.h:530
GNE_TAG_WALK_TRAINSTOP_BUSSTOP
@ GNE_TAG_WALK_TRAINSTOP_BUSSTOP
Definition SUMOXMLDefinitions.h:556
GNE_TAG_TRANSHIP_JUNCTION_TRAINSTOP
@ GNE_TAG_TRANSHIP_JUNCTION_TRAINSTOP
Definition SUMOXMLDefinitions.h:746
GNE_TAG_WALK_TAZ_EDGE
@ GNE_TAG_WALK_TAZ_EDGE
Definition SUMOXMLDefinitions.h:529
GNE_TAG_PERSONTRIP_TAZ_JUNCTION
@ GNE_TAG_PERSONTRIP_TAZ_JUNCTION
Definition SUMOXMLDefinitions.h:466
GNE_TAG_WALK_EDGE_CHARGINGSTATION
@ GNE_TAG_WALK_EDGE_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:527
GNE_TAG_TRANSPORT_JUNCTION_TAZ
@ GNE_TAG_TRANSPORT_JUNCTION_TAZ
Definition SUMOXMLDefinitions.h:678
GNE_TAG_TRANSPORT_PARKINGAREA_BUSSTOP
@ GNE_TAG_TRANSPORT_PARKINGAREA_BUSSTOP
Definition SUMOXMLDefinitions.h:720
GNE_TAG_RIDE_EDGE_TRAINSTOP
@ GNE_TAG_RIDE_EDGE_TRAINSTOP
Definition SUMOXMLDefinitions.h:592
GNE_TAG_TRANSHIP_TAZ_JUNCTION
@ GNE_TAG_TRANSHIP_TAZ_JUNCTION
Definition SUMOXMLDefinitions.h:736
SUMO_TAG_PERSON
@ SUMO_TAG_PERSON
Definition SUMOXMLDefinitions.h:360
GNE_TAG_TRANSHIP_JUNCTION_CHARGINGSTATION
@ GNE_TAG_TRANSHIP_JUNCTION_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:748
GNE_TAG_WALK_TRAINSTOP_CONTAINERSTOP
@ GNE_TAG_WALK_TRAINSTOP_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:558
GNE_TAG_WALK_JUNCTION_BUSSTOP
@ GNE_TAG_WALK_JUNCTION_BUSSTOP
Definition SUMOXMLDefinitions.h:540
GNE_TAG_TRANSHIP_JUNCTION_JUNCTION
@ GNE_TAG_TRANSHIP_JUNCTION_JUNCTION
Definition SUMOXMLDefinitions.h:744
GNE_TAG_PERSONTRIP_CONTAINERSTOP_JUNCTION
@ GNE_TAG_PERSONTRIP_CONTAINERSTOP_JUNCTION
Definition SUMOXMLDefinitions.h:498
GNE_TAG_WALK_JUNCTION_EDGE
@ GNE_TAG_WALK_JUNCTION_EDGE
Definition SUMOXMLDefinitions.h:537
GNE_TAG_PERSONTRIP_BUSSTOP_PARKINGAREA
@ GNE_TAG_PERSONTRIP_BUSSTOP_PARKINGAREA
Definition SUMOXMLDefinitions.h:487
GNE_TAG_TRANSHIP_CONTAINERSTOP_TRAINSTOP
@ GNE_TAG_TRANSHIP_CONTAINERSTOP_TRAINSTOP
Definition SUMOXMLDefinitions.h:770
GNE_TAG_PERSONTRIP_PARKINGAREA_BUSSTOP
@ GNE_TAG_PERSONTRIP_PARKINGAREA_BUSSTOP
Definition SUMOXMLDefinitions.h:515
GNE_TAG_RIDE_CHARGINGSTATION_JUNCTION
@ GNE_TAG_RIDE_CHARGINGSTATION_JUNCTION
Definition SUMOXMLDefinitions.h:638
GNE_TAG_RIDE_BUSSTOP_CHARGINGSTATION
@ GNE_TAG_RIDE_BUSSTOP_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:618
GNE_TAG_TRANSPORT_JUNCTION_TRAINSTOP
@ GNE_TAG_TRANSPORT_JUNCTION_TRAINSTOP
Definition SUMOXMLDefinitions.h:681
GNE_TAG_WALK_EDGE_CONTAINERSTOP
@ GNE_TAG_WALK_EDGE_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:526
GNE_TAG_WALK_TRAINSTOP_JUNCTION
@ GNE_TAG_WALK_TRAINSTOP_JUNCTION
Definition SUMOXMLDefinitions.h:555
GNE_TAG_TRANSHIP_CHARGINGSTATION_PARKINGAREA
@ GNE_TAG_TRANSHIP_CHARGINGSTATION_PARKINGAREA
Definition SUMOXMLDefinitions.h:781
GNE_TAG_STOPPERSON_CHARGINGSTATION
@ GNE_TAG_STOPPERSON_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:658
GNE_TAG_TRANSHIP_CHARGINGSTATION_TAZ
@ GNE_TAG_TRANSHIP_CHARGINGSTATION_TAZ
Definition SUMOXMLDefinitions.h:775
GNE_TAG_TRANSPORT_BUSSTOP_EDGE
@ GNE_TAG_TRANSPORT_BUSSTOP_EDGE
Definition SUMOXMLDefinitions.h:685
GNE_TAG_TRANSHIP_CONTAINERSTOP_BUSSTOP
@ GNE_TAG_TRANSHIP_CONTAINERSTOP_BUSSTOP
Definition SUMOXMLDefinitions.h:769
GNE_TAG_WALK_PARKINGAREA_TAZ
@ GNE_TAG_WALK_PARKINGAREA_TAZ
Definition SUMOXMLDefinitions.h:578
GNE_TAG_PERSONTRIP_JUNCTION_EDGE
@ GNE_TAG_PERSONTRIP_JUNCTION_EDGE
Definition SUMOXMLDefinitions.h:472
GNE_TAG_RIDE_CONTAINERSTOP_PARKINGAREA
@ GNE_TAG_RIDE_CONTAINERSTOP_PARKINGAREA
Definition SUMOXMLDefinitions.h:635
GNE_TAG_RIDE_CHARGINGSTATION_TRAINSTOP
@ GNE_TAG_RIDE_CHARGINGSTATION_TRAINSTOP
Definition SUMOXMLDefinitions.h:640
GNE_TAG_STOPPERSON_TRAINSTOP
@ GNE_TAG_STOPPERSON_TRAINSTOP
Definition SUMOXMLDefinitions.h:656
GNE_TAG_TRANSPORT_CHARGINGSTATION_BUSSTOP
@ GNE_TAG_TRANSPORT_CHARGINGSTATION_BUSSTOP
Definition SUMOXMLDefinitions.h:712
GNE_TAG_PERSONTRIP_PARKINGAREA_CHARGINGSTATION
@ GNE_TAG_PERSONTRIP_PARKINGAREA_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:518
GNE_TAG_TRANSHIP_CHARGINGSTATION_CONTAINERSTOP
@ GNE_TAG_TRANSHIP_CHARGINGSTATION_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:779
GNE_TAG_TRANSHIP_EDGE_BUSSTOP
@ GNE_TAG_TRANSHIP_EDGE_BUSSTOP
Definition SUMOXMLDefinitions.h:729
GNE_TAG_RIDE_BUSSTOP_PARKINGAREA
@ GNE_TAG_RIDE_BUSSTOP_PARKINGAREA
Definition SUMOXMLDefinitions.h:619
GNE_TAG_WALK_EDGE_JUNCTION
@ GNE_TAG_WALK_EDGE_JUNCTION
Definition SUMOXMLDefinitions.h:523
GNE_TAG_RIDE_PARKINGAREA_EDGE
@ GNE_TAG_RIDE_PARKINGAREA_EDGE
Definition SUMOXMLDefinitions.h:644
GNE_TAG_PERSONTRIP_JUNCTION_TAZ
@ GNE_TAG_PERSONTRIP_JUNCTION_TAZ
Definition SUMOXMLDefinitions.h:473
GNE_TAG_TRANSHIP_PARKINGAREA_EDGE
@ GNE_TAG_TRANSHIP_PARKINGAREA_EDGE
Definition SUMOXMLDefinitions.h:782
GNE_TAG_TRANSPORT_PARKINGAREA_CHARGINGSTATION
@ GNE_TAG_TRANSPORT_PARKINGAREA_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:723
GNE_TAG_TRANSHIP_TRAINSTOP_CONTAINERSTOP
@ GNE_TAG_TRANSHIP_TRAINSTOP_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:763
GNE_TAG_PERSONTRIP_JUNCTION_CONTAINERSTOP
@ GNE_TAG_PERSONTRIP_JUNCTION_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:477
GNE_TAG_WALK_TRAINSTOP_TRAINSTOP
@ GNE_TAG_WALK_TRAINSTOP_TRAINSTOP
Definition SUMOXMLDefinitions.h:557
GNE_TAG_WALK_CHARGINGSTATION_EDGE
@ GNE_TAG_WALK_CHARGINGSTATION_EDGE
Definition SUMOXMLDefinitions.h:569
GNE_TAG_TRANSHIP_EDGE_PARKINGAREA
@ GNE_TAG_TRANSHIP_EDGE_PARKINGAREA
Definition SUMOXMLDefinitions.h:733
GNE_TAG_WALK_EDGE_BUSSTOP
@ GNE_TAG_WALK_EDGE_BUSSTOP
Definition SUMOXMLDefinitions.h:524
GNE_TAG_PERSONTRIP_PARKINGAREA_PARKINGAREA
@ GNE_TAG_PERSONTRIP_PARKINGAREA_PARKINGAREA
Definition SUMOXMLDefinitions.h:519
GNE_TAG_TRANSHIP_TRAINSTOP_BUSSTOP
@ GNE_TAG_TRANSHIP_TRAINSTOP_BUSSTOP
Definition SUMOXMLDefinitions.h:761
GNE_TAG_TRANSHIP_BUSSTOP_BUSSTOP
@ GNE_TAG_TRANSHIP_BUSSTOP_BUSSTOP
Definition SUMOXMLDefinitions.h:753
GNE_TAG_TRANSPORT_TRAINSTOP_EDGE
@ GNE_TAG_TRANSPORT_TRAINSTOP_EDGE
Definition SUMOXMLDefinitions.h:693
GNE_TAG_PERSONTRIP_TRAINSTOP_CHARGINGSTATION
@ GNE_TAG_PERSONTRIP_TRAINSTOP_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:494
GNE_TAG_TRANSPORT_EDGE_CHARGINGSTATION
@ GNE_TAG_TRANSPORT_EDGE_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:667
GNE_TAG_TRANSHIP_CONTAINERSTOP_CONTAINERSTOP
@ GNE_TAG_TRANSHIP_CONTAINERSTOP_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:771
GNE_TAG_WALK_CONTAINERSTOP_TRAINSTOP
@ GNE_TAG_WALK_CONTAINERSTOP_TRAINSTOP
Definition SUMOXMLDefinitions.h:565
GNE_TAG_RIDE_EDGE_PARKINGAREA
@ GNE_TAG_RIDE_EDGE_PARKINGAREA
Definition SUMOXMLDefinitions.h:595
GNE_TAG_TRANSHIP_CHARGINGSTATION_JUNCTION
@ GNE_TAG_TRANSHIP_CHARGINGSTATION_JUNCTION
Definition SUMOXMLDefinitions.h:776
GNE_TAG_RIDE_BUSSTOP_CONTAINERSTOP
@ GNE_TAG_RIDE_BUSSTOP_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:617
GNE_TAG_WALK_TAZ_TRAINSTOP
@ GNE_TAG_WALK_TAZ_TRAINSTOP
Definition SUMOXMLDefinitions.h:533
GNE_TAG_PERSONTRIP_CONTAINERSTOP_CHARGINGSTATION
@ GNE_TAG_PERSONTRIP_CONTAINERSTOP_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:502
GNE_TAG_RIDE_JUNCTION_EDGE
@ GNE_TAG_RIDE_JUNCTION_EDGE
Definition SUMOXMLDefinitions.h:604
GNE_TAG_TRANSHIP_TRAINSTOP_PARKINGAREA
@ GNE_TAG_TRANSHIP_TRAINSTOP_PARKINGAREA
Definition SUMOXMLDefinitions.h:765
GNE_TAG_PERSONTRIP_CONTAINERSTOP_BUSSTOP
@ GNE_TAG_PERSONTRIP_CONTAINERSTOP_BUSSTOP
Definition SUMOXMLDefinitions.h:499
GNE_TAG_TRANSHIP_JUNCTION_TAZ
@ GNE_TAG_TRANSHIP_JUNCTION_TAZ
Definition SUMOXMLDefinitions.h:743
GNE_TAG_TRANSPORT_JUNCTION_CONTAINERSTOP
@ GNE_TAG_TRANSPORT_JUNCTION_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:682
GNE_TAG_TRANSPORT_TAZ_CHARGINGSTATION
@ GNE_TAG_TRANSPORT_TAZ_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:675
GNE_TAG_TRANSPORT_TAZ_JUNCTION
@ GNE_TAG_TRANSPORT_TAZ_JUNCTION
Definition SUMOXMLDefinitions.h:671
GNE_TAG_RIDE_TRAINSTOP_TRAINSTOP
@ GNE_TAG_RIDE_TRAINSTOP_TRAINSTOP
Definition SUMOXMLDefinitions.h:624
GNE_TAG_TRANSPORT_JUNCTION_EDGE
@ GNE_TAG_TRANSPORT_JUNCTION_EDGE
Definition SUMOXMLDefinitions.h:677
GNE_TAG_TRANSPORT_BUSSTOP_BUSSTOP
@ GNE_TAG_TRANSPORT_BUSSTOP_BUSSTOP
Definition SUMOXMLDefinitions.h:688
GNE_TAG_WALK_PARKINGAREA_BUSSTOP
@ GNE_TAG_WALK_PARKINGAREA_BUSSTOP
Definition SUMOXMLDefinitions.h:580
GNE_TAG_RIDE_CONTAINERSTOP_TAZ
@ GNE_TAG_RIDE_CONTAINERSTOP_TAZ
Definition SUMOXMLDefinitions.h:629
GNE_TAG_STOPCONTAINER_CHARGINGSTATION
@ GNE_TAG_STOPCONTAINER_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:797
GNE_TAG_TRANSPORT_BUSSTOP_PARKINGAREA
@ GNE_TAG_TRANSPORT_BUSSTOP_PARKINGAREA
Definition SUMOXMLDefinitions.h:692
GNE_TAG_WALK_TAZ_PARKINGAREA
@ GNE_TAG_WALK_TAZ_PARKINGAREA
Definition SUMOXMLDefinitions.h:536
GNE_TAG_TRANSHIP_TAZ_CHARGINGSTATION
@ GNE_TAG_TRANSHIP_TAZ_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:740
GNE_TAG_TRANSHIP_BUSSTOP_TAZ
@ GNE_TAG_TRANSHIP_BUSSTOP_TAZ
Definition SUMOXMLDefinitions.h:751
GNE_TAG_PERSONTRIP_TRAINSTOP_JUNCTION
@ GNE_TAG_PERSONTRIP_TRAINSTOP_JUNCTION
Definition SUMOXMLDefinitions.h:490
GNE_TAG_RIDE_CONTAINERSTOP_TRAINSTOP
@ GNE_TAG_RIDE_CONTAINERSTOP_TRAINSTOP
Definition SUMOXMLDefinitions.h:632
GNE_TAG_RIDE_TAZ_CHARGINGSTATION
@ GNE_TAG_RIDE_TAZ_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:602
GNE_TAG_STOPPERSON_EDGE
@ GNE_TAG_STOPPERSON_EDGE
Definition SUMOXMLDefinitions.h:654
GNE_TAG_RIDE_CONTAINERSTOP_JUNCTION
@ GNE_TAG_RIDE_CONTAINERSTOP_JUNCTION
Definition SUMOXMLDefinitions.h:630
GNE_TAG_PERSONTRIP_JUNCTION_CHARGINGSTATION
@ GNE_TAG_PERSONTRIP_JUNCTION_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:478
GNE_TAG_RIDE_PARKINGAREA_TRAINSTOP
@ GNE_TAG_RIDE_PARKINGAREA_TRAINSTOP
Definition SUMOXMLDefinitions.h:648
GNE_TAG_TRANSPORT_CONTAINERSTOP_PARKINGAREA
@ GNE_TAG_TRANSPORT_CONTAINERSTOP_PARKINGAREA
Definition SUMOXMLDefinitions.h:708
GNE_TAG_TRANSHIP_CONTAINERSTOP_CHARGINGSTATION
@ GNE_TAG_TRANSHIP_CONTAINERSTOP_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:772
GNE_TAG_WALK_ROUTE
@ GNE_TAG_WALK_ROUTE
Definition SUMOXMLDefinitions.h:586
GNE_TAG_PERSONTRIP_EDGE_TAZ
@ GNE_TAG_PERSONTRIP_EDGE_TAZ
Definition SUMOXMLDefinitions.h:457
GNE_TAG_RIDE_TAZ_BUSSTOP
@ GNE_TAG_RIDE_TAZ_BUSSTOP
Definition SUMOXMLDefinitions.h:599
GNE_TAG_WALK_CONTAINERSTOP_CONTAINERSTOP
@ GNE_TAG_WALK_CONTAINERSTOP_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:566
GNE_TAG_RIDE_TRAINSTOP_PARKINGAREA
@ GNE_TAG_RIDE_TRAINSTOP_PARKINGAREA
Definition SUMOXMLDefinitions.h:627
SUMO_TAG_PERSONFLOW
@ SUMO_TAG_PERSONFLOW
Definition SUMOXMLDefinitions.h:364
GNE_TAG_TRANSHIP_CONTAINERSTOP_EDGE
@ GNE_TAG_TRANSHIP_CONTAINERSTOP_EDGE
Definition SUMOXMLDefinitions.h:766
GNE_TAG_WALK_CHARGINGSTATION_CHARGINGSTATION
@ GNE_TAG_WALK_CHARGINGSTATION_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:575
GNE_TAG_TRANSHIP_TRAINSTOP_TAZ
@ GNE_TAG_TRANSHIP_TRAINSTOP_TAZ
Definition SUMOXMLDefinitions.h:759
GNE_TAG_RIDE_EDGE_CONTAINERSTOP
@ GNE_TAG_RIDE_EDGE_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:593
GNE_TAG_STOPPERSON_PARKINGAREA
@ GNE_TAG_STOPPERSON_PARKINGAREA
Definition SUMOXMLDefinitions.h:659
GNE_TAG_RIDE_TRAINSTOP_EDGE
@ GNE_TAG_RIDE_TRAINSTOP_EDGE
Definition SUMOXMLDefinitions.h:620
GNE_TAG_TRANSHIP_TAZ_CONTAINERSTOP
@ GNE_TAG_TRANSHIP_TAZ_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:739
SumoXMLAttr
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
Definition SUMOXMLDefinitions.h:813
SUMO_ATTR_STARTPOS
@ SUMO_ATTR_STARTPOS
Definition SUMOXMLDefinitions.h:1565
GNE_ATTR_FROM_TRAINSTOP
@ GNE_ATTR_FROM_TRAINSTOP
Definition SUMOXMLDefinitions.h:1837
GNE_ATTR_FROM_BUSSTOP
@ GNE_ATTR_FROM_BUSSTOP
Definition SUMOXMLDefinitions.h:1836
GNE_ATTR_PLAN_GEOMETRY_STARTPOS
@ GNE_ATTR_PLAN_GEOMETRY_STARTPOS
person/container geometry start position
Definition SUMOXMLDefinitions.h:1825
SUMO_ATTR_FROM_JUNCTION
@ SUMO_ATTR_FROM_JUNCTION
Definition SUMOXMLDefinitions.h:1356
SUMO_ATTR_CONTAINER_STOP
@ SUMO_ATTR_CONTAINER_STOP
Definition SUMOXMLDefinitions.h:1525
SUMO_ATTR_PARKING_AREA
@ SUMO_ATTR_PARKING_AREA
Definition SUMOXMLDefinitions.h:1526
SUMO_ATTR_EDGE
@ SUMO_ATTR_EDGE
Definition SUMOXMLDefinitions.h:871
SUMO_ATTR_BUS_STOP
@ SUMO_ATTR_BUS_STOP
Definition SUMOXMLDefinitions.h:1523
SUMO_ATTR_TRAIN_STOP
@ SUMO_ATTR_TRAIN_STOP
Definition SUMOXMLDefinitions.h:1524
SUMO_ATTR_ENDPOS
@ SUMO_ATTR_ENDPOS
Definition SUMOXMLDefinitions.h:1566
SUMO_ATTR_TO_JUNCTION
@ SUMO_ATTR_TO_JUNCTION
Definition SUMOXMLDefinitions.h:1357
GNE_ATTR_PARENT
@ GNE_ATTR_PARENT
parent of an additional element
Definition SUMOXMLDefinitions.h:1777
SUMO_ATTR_ARRIVALPOS
@ SUMO_ATTR_ARRIVALPOS
Definition SUMOXMLDefinitions.h:969
GNE_ATTR_SELECTED
@ GNE_ATTR_SELECTED
element is selected
Definition SUMOXMLDefinitions.h:1765
GNE_ATTR_TAZ_CENTROID
@ GNE_ATTR_TAZ_CENTROID
TAZ Center (uses to return the TAZ centroid if center is not defined)
Definition SUMOXMLDefinitions.h:1833
SUMO_ATTR_EDGES
@ SUMO_ATTR_EDGES
the edges of a route
Definition SUMOXMLDefinitions.h:958
SUMO_ATTR_CHARGING_STATION
@ SUMO_ATTR_CHARGING_STATION
Definition SUMOXMLDefinitions.h:1530
SUMO_ATTR_DEPARTPOS
@ SUMO_ATTR_DEPARTPOS
Definition SUMOXMLDefinitions.h:964
GNE_ATTR_FROM_PARKINGAREA
@ GNE_ATTR_FROM_PARKINGAREA
Definition SUMOXMLDefinitions.h:1840
GNE_ATTR_FROM_CONTAINERSTOP
@ GNE_ATTR_FROM_CONTAINERSTOP
Definition SUMOXMLDefinitions.h:1838
SUMO_ATTR_TO_TAZ
@ SUMO_ATTR_TO_TAZ
Definition SUMOXMLDefinitions.h:1362
SUMO_ATTR_CENTER
@ SUMO_ATTR_CENTER
Definition SUMOXMLDefinitions.h:931
SUMO_ATTR_TO
@ SUMO_ATTR_TO
Definition SUMOXMLDefinitions.h:1351
SUMO_ATTR_FROM
@ SUMO_ATTR_FROM
Definition SUMOXMLDefinitions.h:1350
SUMO_ATTR_FROM_TAZ
@ SUMO_ATTR_FROM_TAZ
Definition SUMOXMLDefinitions.h:1361
GNE_ATTR_FROM_CHARGINGSTATION
@ GNE_ATTR_FROM_CHARGINGSTATION
Definition SUMOXMLDefinitions.h:1839
GNE_ATTR_PLAN_GEOMETRY_ENDPOS
@ GNE_ATTR_PLAN_GEOMETRY_ENDPOS
person/container geometry end position
Definition SUMOXMLDefinitions.h:1827
SUMO_ATTR_ROUTE
@ SUMO_ATTR_ROUTE
Definition SUMOXMLDefinitions.h:897
SUMO_ATTR_ID
@ SUMO_ATTR_ID
Definition SUMOXMLDefinitions.h:912
SUMO_ATTR_DURATION
@ SUMO_ATTR_DURATION
Definition SUMOXMLDefinitions.h:1381
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:259
Boundary::grow
Boundary & grow(double by)
extends the boundary by the given amount
Definition Boundary.cpp:343
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::fromTrainStop
std::string fromTrainStop
from trainStop
Definition CommonXMLStructure.h:91
CommonXMLStructure::PlanParameters::toParkingArea
std::string toParkingArea
to parkingArea
Definition CommonXMLStructure.h:112
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:966
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:41
GNEContour::calculateContourExtrudedShape
void calculateContourExtrudedShape(const GUIVisualizationSettings &s, const GUIVisualizationSettings::Detail d, const GUIGlObject *glObject, const PositionVector &shape, const double layer, 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:89
GNEContour::calculateContourCircleShape
void calculateContourCircleShape(const GUIVisualizationSettings &s, const GUIVisualizationSettings::Detail d, const GUIGlObject *glObject, const Position &pos, double radius, const double layer, 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
draw dotted contours (basics, select, delete, inspect...)
Definition GNEContour.cpp:306
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::getLastPathLane
virtual GNELane * getLastPathLane() const =0
get last path lane
GNEDemandElement::getFirstPathLane
virtual GNELane * getFirstPathLane() const =0
get first path lane
GNEDemandElement::myDemandElementGeometry
GUIGeometry myDemandElementGeometry
demand element geometry (also called "stacked geometry")
Definition GNEDemandElement.h:349
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::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:664
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:1378
GNENet::removeGLObjectFromGrid
void removeGLObjectFromGrid(GNEAttributeCarrier *AC)
add GL Object into net
Definition GNENet.cpp:1388
GNENet::getDemandPathManager
GNEPathManager * getDemandPathManager()
get demand path manager
Definition GNENet.cpp:142
GNENet::getAttributeCarriers
GNENetHelper::AttributeCarriers * getAttributeCarriers() const
get all attribute carriers used in this net
Definition GNENet.cpp:125
GNENet::getViewNet
GNEViewNet * getViewNet() const
get view net
Definition GNENet.cpp:2147
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:568
GNEPathManager::Segment::getPreviousLane
const GNELane * getPreviousLane() const
get previous lane
Definition GNEPathManager.cpp:131
GNEPathManager::Segment::getContour
GNEContour * getContour() const
getcontour associated with segment
Definition GNEPathManager.cpp:101
GNEPathManager::Segment::getNextLane
const GNELane * getNextLane() const
get next lane
Definition GNEPathManager.cpp:141
GNEPathManager::Segment::getLane
const GNELane * getLane() const
get lane associated with this segment
Definition GNEPathManager.cpp:125
GNEPathManager::Segment::isLastSegment
bool isLastSegment() const
check if segment is the last path's segment
Definition GNEPathManager.cpp:113
GNEPathManager::Segment::isFirstSegment
bool isFirstSegment() const
check if segment is the first path's segment
Definition GNEPathManager.cpp:107
GNEPathManager::getPathDraw
PathDraw * getPathDraw()
obtain instance of PathDraw
Definition GNEPathManager.cpp:676
GNEPathManager::calculateConsecutivePathEdges
void calculateConsecutivePathEdges(PathElement *pathElement, SUMOVehicleClass vClass, const std::vector< GNEEdge * > &edges, const int firstLaneIndex=-1, const int lastLaneIndex=-1)
calculate consecutive path edges
Definition GNEPathManager.cpp:755
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:1897
GNEViewNet::buildSelectionACPopupEntry
void buildSelectionACPopupEntry(GUIGLObjectPopupMenu *ret, GNEAttributeCarrier *AC)
Builds an entry which allows to (de)select the object.
Definition GNEViewNet.cpp:584
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:318
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:286
GUIGlObject::buildPopupHeader
void buildPopupHeader(GUIGLObjectPopupMenu *ret, GUIMainWindow &app, bool addSeparator=true)
Builds the header.
Definition GUIGlObject.cpp:274
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:336
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:436
GUISUMOAbstractView::getPositionInformation
virtual Position getPositionInformation() const
Returns the cursor's x/y position within the network.
Definition GUISUMOAbstractView.cpp:199
GUIViewObjectsHandler::isObjectSelected
bool isObjectSelected(const GUIGlObject *GLObject) const
check if element was already selected
Definition GUIViewObjectsHandler.cpp:338
GUIVisualizationSettings
Stores the information about how to visualize structures.
Definition GUIVisualizationSettings.h:584
GUIVisualizationSettings::addName
GUIVisualizationTextSettings addName
Definition GUIVisualizationSettings.h:939
GUIVisualizationSettings::drawBoundaries
bool drawBoundaries
enable or disable draw boundaries
Definition GUIVisualizationSettings.h:1055
GUIVisualizationSettings::drawForRectangleSelection
bool drawForRectangleSelection
whether drawing is performed for the purpose of selecting objects using a rectangle
Definition GUIVisualizationSettings.h:1064
GUIVisualizationSettings::addSize
GUIVisualizationSizeSettings addSize
Definition GUIVisualizationSettings.h:937
GUIVisualizationSettings::widthSettings
GUIVisualizationWidthSettings widthSettings
width settings
Definition GUIVisualizationSettings.h:1131
GUIVisualizationSettings::getDetailLevel
Detail getDetailLevel(const double exaggeration) const
return the detail level
Definition GUIVisualizationSettings.cpp:2726
GUIVisualizationSettings::laneWidthExaggeration
double laneWidthExaggeration
The lane exaggeration (upscale thickness)
Definition GUIVisualizationSettings.h:780
GUIVisualizationSettings::checkDrawContainer
bool checkDrawContainer(Detail d, const bool selected) const
check if draw container
Definition GUIVisualizationSettings.cpp:917
GUIVisualizationSettings::dottedContourSettings
GUIVisualizationDottedContourSettings dottedContourSettings
dotted contour settings
Definition GUIVisualizationSettings.h:1128
GUIVisualizationSettings::scale
double scale
information about a lane's width (temporary, used for a single view)
Definition GUIVisualizationSettings.h:1049
GUIVisualizationSettings::drawForViewObjectsHandler
bool drawForViewObjectsHandler
whether drawing is performed for the purpose of selecting objects in view using ViewObjectsHandler
Definition GUIVisualizationSettings.h:1061
GUIVisualizationSettings::checkDrawPerson
bool checkDrawPerson(Detail d, const bool selected) const
check if draw person
Definition GUIVisualizationSettings.cpp:897
OutputDevice
Static storage of an output device and its base (abstract) implementation.
Definition OutputDevice.h:61
OutputDevice::writeAttr
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition OutputDevice.h:254
OutputDevice::openTag
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
Definition OutputDevice.cpp:267
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:3971
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