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