Eclipse SUMO - Simulation of Urban MObility
GNERouteHandler.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2001-2022 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// Builds demand objects for netedit
19/****************************************************************************/
20#include <config.h>
21#include <netedit/GNENet.h>
22#include <netedit/GNEUndoList.h>
23#include <netedit/GNEViewNet.h>
28
29#include "GNEContainer.h"
30#include "GNEPerson.h"
31#include "GNEPersonTrip.h"
32#include "GNERide.h"
33#include "GNERoute.h"
34#include "GNERouteHandler.h"
35#include "GNEStop.h"
36#include "GNETranship.h"
37#include "GNETransport.h"
38#include "GNEVehicle.h"
39#include "GNEVType.h"
41#include "GNEWalk.h"
42
43
44// ===========================================================================
45// member method definitions
46// ===========================================================================
47
48GNERouteHandler::GNERouteHandler(const std::string& file, GNENet* net, const bool allowUndoRedo, const bool overwrite) :
49 RouteHandler(file, false),
50 myNet(net),
51 myPlanObject(new CommonXMLStructure::SumoBaseObject(nullptr)),
52 myAllowUndoRedo(allowUndoRedo),
53 myOverwrite(overwrite) {
54}
55
56
58 delete myPlanObject;
59}
60
61
62void
64 // check vTypeDistribution
65 const bool vTypeDistribution = sumoBaseObject->getParentSumoBaseObject() && (sumoBaseObject->getParentSumoBaseObject()->getTag() == SUMO_TAG_VTYPE_DISTRIBUTION);
66 // check if loaded type is a default type
67 if (DEFAULT_VTYPES.count(vTypeParameter.id) > 0) {
68 // overwrite default vehicle type
70 } else if (!checkDuplicatedDemandElement(SUMO_TAG_VTYPE, vTypeParameter.id)) {
71 writeError("There is another " + toString(SUMO_TAG_VTYPE) + " with the same ID='" + vTypeParameter.id + "'.");
72 } else {
73 // create vType/pType using myCurrentVType
74 GNEDemandElement* vType = new GNEVType(myNet, vTypeParameter);
75 if (myAllowUndoRedo) {
76 myNet->getViewNet()->getUndoList()->begin(GUIIcon::VTYPE, "add " + vType->getTagStr() + " '" + vTypeParameter.id + "'");
78 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(vType, true), true);
79 // check if place this vType within a vTypeDistribution
80 if (vTypeDistribution) {
82 }
84 } else {
86 if (vTypeDistribution) {
88 }
89 vType->incRef("buildVType");
90 }
91 }
92}
93
94
95void
97 const int deterministic, const std::vector<std::string>& vTypes) {
98 // first check conditions
100 writeError("There is another " + toString(SUMO_TAG_VTYPE) + " with the same ID='" + id + "'.");
101 } else if (vTypes.empty() && sumoBaseObject->getSumoBaseObjectChildren().empty()) {
103 } else {
104 bool checkVTypesOK = true;
105 // check vTypes
106 for (const auto& vType : vTypes) {
107 if (myNet->getAttributeCarriers()->retrieveDemandElement(SUMO_TAG_VTYPE, vType, false) == nullptr) {
108 writeError(toString(SUMO_TAG_VTYPE) + " with id '" + vType + "' doesn't exist in " + toString(SUMO_TAG_VTYPE_DISTRIBUTION) + " '" + id + "'");
109 checkVTypesOK = false;
110 }
111 }
112 // now check childrens
113 for (const auto& child : sumoBaseObject->getSumoBaseObjectChildren()) {
114 if (child->hasStringAttribute(SUMO_ATTR_ID) == false) {
115 writeError("Invalid definition for " + toString(SUMO_TAG_VTYPE) + " in " + toString(SUMO_TAG_VTYPE_DISTRIBUTION) + " '" + id + "'");
116 checkVTypesOK = false;
117 } else if (myNet->getAttributeCarriers()->retrieveDemandElement(SUMO_TAG_VTYPE, child->getStringAttribute(SUMO_ATTR_ID), false) != nullptr) {
118 writeError(toString(SUMO_TAG_VTYPE) + " with id '" + child->getStringAttribute(SUMO_ATTR_ID) + "' cannot be created in " + toString(SUMO_TAG_VTYPE_DISTRIBUTION) + " '" + id + "'");
119 checkVTypesOK = false;
120 }
121 }
122 // if all ok, then create vTypeDistribution
123 if (checkVTypesOK) {
124 GNEVTypeDistribution* vTypeDistribution = new GNEVTypeDistribution(myNet, id, deterministic);
125 if (myAllowUndoRedo) {
126 myNet->getViewNet()->getUndoList()->begin(GUIIcon::VTYPEDISTRIBUTION, "add " + vTypeDistribution->getTagStr() + " '" + id + "'");
128 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(vTypeDistribution, true), true);
129 // set this vTypeDistribution as parent of the other vTypes
130 for (const auto& vTypeID : vTypes) {
133 }
135 } else {
136 myNet->getAttributeCarriers()->insertDemandElement(vTypeDistribution);
137 vTypeDistribution->incRef("buildVType");
138 for (const auto& vTypeID : vTypes) {
141 }
142 }
143 }
144 }
145}
146
147
148void
149GNERouteHandler::buildRoute(const CommonXMLStructure::SumoBaseObject* /*sumoBaseObject*/, const std::string& id, SUMOVehicleClass vClass,
150 const std::vector<std::string>& edgeIDs, const RGBColor& color, const int repeat, const SUMOTime cycleTime,
151 const Parameterised::Map& routeParameters) {
152 // parse edges
153 const auto edges = parseEdges(SUMO_TAG_ROUTE, edgeIDs);
154 // check conditions
156 writeError("There is another " + toString(SUMO_TAG_ROUTE) + " with the same ID='" + id + "'.");
157 } else if (edges.size() > 0) {
158 // create GNERoute
159 GNEDemandElement* route = new GNERoute(myNet, id, vClass, edges, color, repeat, cycleTime, routeParameters);
160 if (myAllowUndoRedo) {
161 myNet->getViewNet()->getUndoList()->begin(GUIIcon::ROUTE, "add " + route->getTagStr() + " '" + id + "'");
163 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(route, true), true);
165 } else {
167 for (const auto& edge : edges) {
168 edge->addChildElement(route);
169 }
170 route->incRef("buildRoute");
171 }
172 }
173}
174
175
176void
177GNERouteHandler::buildEmbeddedRoute(const CommonXMLStructure::SumoBaseObject* sumoBaseObject, const std::vector<std::string>& edgeIDs,
178 const RGBColor& color, const int repeat, const SUMOTime cycleTime, const Parameterised::Map& routeParameters) {
179 // first create vehicle/flow
180 const SUMOVehicleParameter& vehicleParameters = sumoBaseObject->getParentSumoBaseObject()->getVehicleParameter();
181 const SumoXMLTag vehicleTag = (sumoBaseObject->getParentSumoBaseObject()->getTag() == SUMO_TAG_VEHICLE) ? GNE_TAG_VEHICLE_WITHROUTE :
183 sumoBaseObject->getParentSumoBaseObject()->getTag();
184 // parse route edges
185 const auto edges = parseEdges(SUMO_TAG_ROUTE, edgeIDs);
186 // check if ID is duplicated
187 if ((edges.size() > 0) && !isVehicleIdDuplicated(vehicleParameters.id)) {
188 // obtain routes and vtypes
190 if (vType == nullptr) {
191 writeError("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
192 } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && (vehicleParameters.departLaneProcedure == DepartLaneDefinition::GIVEN) && ((int)edges.front()->getLanes().size() < vehicleParameters.departLane)) {
193 writeError("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
194 } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DepartSpeedDefinition::GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
195 writeError("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
196 } else {
197 // create vehicle using vehicleParameters
198 GNEDemandElement* vehicle = new GNEVehicle(vehicleTag, myNet, vType, vehicleParameters);
199 // create embedded route
200 GNEDemandElement* route = new GNERoute(myNet, vehicle, edges, color, repeat, cycleTime, routeParameters);
201 if (myAllowUndoRedo) {
202 myNet->getViewNet()->getUndoList()->begin(GUIIcon::ROUTE, "add " + route->getTagStr() + " in '" + vehicle->getID() + "'");
204 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(vehicle, true), true);
205 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(route, true), true);
207 } else {
210 vType->addChildElement(vehicle);
211 vehicle->addChildElement(route);
212 for (const auto& edge : edges) {
213 edge->addChildElement(route);
214 }
215 route->incRef("buildRoute");
216 }
217 // compute path
218 vehicle->computePathElement();
219 }
220 }
221}
222
223
224void
225GNERouteHandler::buildRouteDistribution(const CommonXMLStructure::SumoBaseObject* /*sumoBaseObject*/, const std::string& /*id*/) {
226 // unsuported
227 writeError("NETEDIT doesn't support route distributions");
228}
229
230
231void
233 // first check if ID is duplicated
234 if (!isVehicleIdDuplicated(vehicleParameters.id)) {
235 // obtain routes and vtypes
238 if (vType == nullptr) {
239 writeError("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
240 } else if (route == nullptr) {
241 writeError("Invalid route '" + vehicleParameters.routeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
242 } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && (vehicleParameters.departLaneProcedure == DepartLaneDefinition::GIVEN) && ((int)route->getParentEdges().front()->getLanes().size() < vehicleParameters.departLane)) {
243 writeError("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
244 } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DepartSpeedDefinition::GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
245 writeError("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
246 } else {
247 // create vehicle using vehicleParameters
248 GNEDemandElement* vehicle = new GNEVehicle(SUMO_TAG_VEHICLE, myNet, vType, route, vehicleParameters);
249 if (myAllowUndoRedo) {
250 myNet->getViewNet()->getUndoList()->begin(vehicle->getTagProperty().getGUIIcon(), "add " + vehicle->getTagStr() + " '" + vehicleParameters.id + "'");
252 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(vehicle, true), true);
254 } else {
256 // set vehicle as child of vType and Route
257 vType->addChildElement(vehicle);
258 route->addChildElement(vehicle);
259 vehicle->incRef("buildVehicleOverRoute");
260 }
261 // compute path
262 vehicle->computePathElement();
263 }
264 }
265}
266
267
268void
270 // first check if ID is duplicated
271 if (!isVehicleIdDuplicated(vehicleParameters.id)) {
272 // obtain routes and vtypes
275 if (vType == nullptr) {
276 writeError("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
277 } else if (route == nullptr) {
278 writeError("Invalid route '" + vehicleParameters.routeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
279 } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && (vehicleParameters.departLaneProcedure == DepartLaneDefinition::GIVEN) && ((int)route->getParentEdges().front()->getLanes().size() < vehicleParameters.departLane)) {
280 writeError("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
281 } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DepartSpeedDefinition::GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
282 writeError("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
283 } else {
284 // create flow or trips using vehicleParameters
285 GNEDemandElement* flow = new GNEVehicle(GNE_TAG_FLOW_ROUTE, myNet, vType, route, vehicleParameters);
286 if (myAllowUndoRedo) {
287 myNet->getViewNet()->getUndoList()->begin(flow->getTagProperty().getGUIIcon(), "add " + flow->getTagStr() + " '" + vehicleParameters.id + "'");
289 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(flow, true), true);
291 } else {
293 // set flow as child of vType and Route
294 vType->addChildElement(flow);
295 route->addChildElement(flow);
296 flow->incRef("buildFlowOverRoute");
297 }
298 // compute path
299 flow->computePathElement();
300 }
301 }
302}
303
304
305void
307 const std::string& fromEdgeID, const std::string& toEdgeID, const std::vector<std::string>& viaIDs) {
308 // parse edges
309 const auto fromEdge = parseEdge(SUMO_TAG_TRIP, fromEdgeID);
310 const auto toEdge = parseEdge(SUMO_TAG_TRIP, toEdgeID);
311 const auto via = parseEdges(SUMO_TAG_TRIP, viaIDs);
312 // check if exist another vehicle with the same ID (note: Vehicles, Flows and Trips share namespace)
313 if (fromEdge && toEdge && !isVehicleIdDuplicated(vehicleParameters.id)) {
314 // obtain vtypes
316 if (vType == nullptr) {
317 writeError("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
318 } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && ((vehicleParameters.departLaneProcedure == DepartLaneDefinition::GIVEN)) && ((int)fromEdge->getLanes().size() < vehicleParameters.departLane)) {
319 writeError("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
320 } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DepartSpeedDefinition::GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
321 writeError("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
322 } else {
323 // add "via" edges in vehicleParameters
324 for (const auto& viaEdge : via) {
325 vehicleParameters.via.push_back(viaEdge->getID());
326 }
327 // create trip or flow using tripParameters
328 GNEDemandElement* trip = new GNEVehicle(SUMO_TAG_TRIP, myNet, vType, fromEdge, toEdge, via, vehicleParameters);
329 if (myAllowUndoRedo) {
330 myNet->getViewNet()->getUndoList()->begin(trip->getTagProperty().getGUIIcon(), "add " + trip->getTagStr() + " '" + vehicleParameters.id + "'");
332 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(trip, true), true);
334 } else {
336 // set vehicle as child of vType
337 vType->addChildElement(trip);
338 trip->incRef("buildTrip");
339 // add reference in all edges
340 fromEdge->addChildElement(trip);
341 toEdge->addChildElement(trip);
342 for (const auto& viaEdge : via) {
343 viaEdge->addChildElement(trip);
344 }
345 }
346 // compute path
347 trip->computePathElement();
348 }
349 }
350}
351
352
353void
355 const std::string& fromJunctionID, const std::string& toJunctionID) {
356 // parse junctions
357 const auto fromJunction = parseJunction(SUMO_TAG_TRIP, fromJunctionID);
358 const auto toJunction = parseJunction(SUMO_TAG_TRIP, toJunctionID);
359 // check if exist another vehicle with the same ID (note: Vehicles, Flows and Trips share namespace)
360 if (fromJunction && toJunction && !isVehicleIdDuplicated(vehicleParameters.id)) {
361 // obtain vtypes
363 if (vType == nullptr) {
364 writeError("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
365 } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && ((vehicleParameters.departLaneProcedure == DepartLaneDefinition::GIVEN)) && (vehicleParameters.departLane > 0)) {
366 writeError("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
367 } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DepartSpeedDefinition::GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
368 writeError("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
369 } else {
370 // create trip using vehicleParameters
371 GNEDemandElement* flow = new GNEVehicle(GNE_TAG_TRIP_JUNCTIONS, myNet, vType, fromJunction, toJunction, vehicleParameters);
372 if (myAllowUndoRedo) {
373 myNet->getViewNet()->getUndoList()->begin(flow->getTagProperty().getGUIIcon(), "add " + flow->getTagStr() + " '" + vehicleParameters.id + "'");
375 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(flow, true), true);
377 } else {
379 // set vehicle as child of vType
380 vType->addChildElement(flow);
381 flow->incRef("buildFlow");
382 // add reference in all junctions
383 fromJunction->addChildElement(flow);
384 toJunction->addChildElement(flow);
385 }
386 // compute path
387 flow->computePathElement();
388 }
389 }
390}
391
392void
394 const std::string& fromEdgeID, const std::string& toEdgeID, const std::vector<std::string>& viaIDs) {
395 // parse edges
396 const auto fromEdge = parseEdge(SUMO_TAG_FLOW, fromEdgeID);
397 const auto toEdge = parseEdge(SUMO_TAG_FLOW, toEdgeID);
398 const auto via = parseEdges(SUMO_TAG_FLOW, viaIDs);
399 // check if exist another vehicle with the same ID (note: Vehicles, Flows and Trips share namespace)
400 if (fromEdge && toEdge && !isVehicleIdDuplicated(vehicleParameters.id)) {
401 // obtain vtypes
403 if (vType == nullptr) {
404 writeError("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
405 } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && (vehicleParameters.departLaneProcedure == DepartLaneDefinition::GIVEN) && ((int)fromEdge->getLanes().size() < vehicleParameters.departLane)) {
406 writeError("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
407 } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DepartSpeedDefinition::GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
408 writeError("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
409 } else {
410 // add "via" edges in vehicleParameters
411 for (const auto& viaEdge : via) {
412 vehicleParameters.via.push_back(viaEdge->getID());
413 }
414 // create trip or flow using tripParameters
415 GNEDemandElement* flow = new GNEVehicle(SUMO_TAG_FLOW, myNet, vType, fromEdge, toEdge, via, vehicleParameters);
416 if (myAllowUndoRedo) {
417 myNet->getViewNet()->getUndoList()->begin(flow->getTagProperty().getGUIIcon(), "add " + flow->getTagStr() + " '" + vehicleParameters.id + "'");
419 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(flow, true), true);
421 } else {
423 // set vehicle as child of vType
424 vType->addChildElement(flow);
425 flow->incRef("buildFlow");
426 // add reference in all edges
427 fromEdge->addChildElement(flow);
428 toEdge->addChildElement(flow);
429 for (const auto& viaEdge : via) {
430 viaEdge->addChildElement(flow);
431 }
432 }
433 // compute path
434 flow->computePathElement();
435 }
436 }
437}
438
439
440void
442 const std::string& fromJunctionID, const std::string& toJunctionID) {
443 // parse junctions
444 const auto fromJunction = parseJunction(SUMO_TAG_TRIP, fromJunctionID);
445 const auto toJunction = parseJunction(SUMO_TAG_TRIP, toJunctionID);
446 // check if exist another vehicle with the same ID (note: Vehicles, Flows and Trips share namespace)
447 if (fromJunction && toJunction && !isVehicleIdDuplicated(vehicleParameters.id)) {
448 // obtain vtypes
450 if (vType == nullptr) {
451 writeError("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
452 } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && ((vehicleParameters.departLaneProcedure == DepartLaneDefinition::GIVEN)) && (vehicleParameters.departLane > 0)) {
453 writeError("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
454 } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DepartSpeedDefinition::GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
455 writeError("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
456 } else {
457 // create flow using vehicleParameters
458 GNEDemandElement* flow = new GNEVehicle(GNE_TAG_FLOW_JUNCTIONS, myNet, vType, fromJunction, toJunction, vehicleParameters);
459 if (myAllowUndoRedo) {
460 myNet->getViewNet()->getUndoList()->begin(flow->getTagProperty().getGUIIcon(), "add " + flow->getTagStr() + " '" + vehicleParameters.id + "'");
462 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(flow, true), true);
464 } else {
466 // set vehicle as child of vType
467 vType->addChildElement(flow);
468 flow->incRef("buildFlow");
469 // add reference in all junctions
470 fromJunction->addChildElement(flow);
471 toJunction->addChildElement(flow);
472 }
473 // compute path
474 flow->computePathElement();
475 }
476 }
477}
478
479
480void
482 // first check if ID is duplicated
483 if (!isPersonIdDuplicated(personParameters.id)) {
484 // obtain type
486 if (type == nullptr) {
487 writeError("Invalid person type '" + personParameters.vtypeid + "' used in " + toString(personParameters.tag) + " '" + personParameters.id + "'.");
488 } else {
489 // create person using personParameters
490 GNEDemandElement* person = new GNEPerson(SUMO_TAG_PERSON, myNet, type, personParameters);
491 if (myAllowUndoRedo) {
492 myNet->getViewNet()->getUndoList()->begin(person->getTagProperty().getGUIIcon(), "add " + person->getTagStr() + " '" + personParameters.id + "'");
494 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(person, true), true);
496 } else {
498 // set person as child of type
499 type->addChildElement(person);
500 person->incRef("buildPerson");
501 }
502 }
503 }
504}
505
506
507void
508GNERouteHandler::buildPersonFlow(const CommonXMLStructure::SumoBaseObject* /*sumoBaseObject*/, const SUMOVehicleParameter& personFlowParameters) {
509 // first check if ID is duplicated
510 if (!isPersonIdDuplicated(personFlowParameters.id)) {
511 // obtain type
513 if (type == nullptr) {
514 writeError("Invalid personFlow type '" + personFlowParameters.vtypeid + "' used in " + toString(personFlowParameters.tag) + " '" + personFlowParameters.id + "'.");
515 } else {
516 // create personFlow using personFlowParameters
517 GNEDemandElement* personFlow = new GNEPerson(SUMO_TAG_PERSONFLOW, myNet, type, personFlowParameters);
518 if (myAllowUndoRedo) {
519 myNet->getViewNet()->getUndoList()->begin(personFlow->getTagProperty().getGUIIcon(), "add " + personFlow->getTagStr() + " '" + personFlowParameters.id + "'");
521 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(personFlow, true), true);
523 } else {
525 // set personFlow as child of type
526 type->addChildElement(personFlow);
527 personFlow->incRef("buildPersonFlow");
528 }
529 }
530 }
531}
532
533
534void
535GNERouteHandler::buildPersonTrip(const CommonXMLStructure::SumoBaseObject* sumoBaseObject, const std::string& fromEdgeID, const std::string& toEdgeID,
536 const std::string& fromJunctionID, const std::string& toJunctionID, const std::string& toBusStopID, double arrivalPos,
537 const std::vector<std::string>& types, const std::vector<std::string>& modes, const std::vector<std::string>& lines) {
538 // get previous plan edge
539 const auto previousEdge = getPreviousPlanEdge(true, sumoBaseObject);
540 // parse parents
541 GNEDemandElement* personParent = getPersonParent(sumoBaseObject);
542 GNEEdge* fromEdge = myNet->getAttributeCarriers()->retrieveEdge(fromEdgeID, false);
543 GNEEdge* toEdge = myNet->getAttributeCarriers()->retrieveEdge(toEdgeID, false);
544 GNEJunction* fromJunction = myNet->getAttributeCarriers()->retrieveJunction(fromJunctionID, false);
545 GNEJunction* toJunction = myNet->getAttributeCarriers()->retrieveJunction(toJunctionID, false);
547 // check from edge
548 if ((fromEdge == nullptr) && previousEdge) {
549 fromEdge = previousEdge;
550 }
551 // check from junction
552 if (fromJunction == nullptr) {
553 if (previousEdge) {
554 fromJunction = previousEdge->getToJunction();
555 } else {
556 fromJunction = getPreviousPlanJunction(true, sumoBaseObject);
557 }
558 }
559 // check conditions
560 if (personParent) {
561 if (fromEdge && toEdge) {
562 // create personTrip from->to (edges)
563 GNEDemandElement* personTrip = new GNEPersonTrip(myNet, personParent, fromEdge, toEdge, arrivalPos, types, modes, lines);
564 if (myAllowUndoRedo) {
565 myNet->getViewNet()->getUndoList()->begin(personTrip->getTagProperty().getGUIIcon(), "add " + personTrip->getTagStr() + " in '" + personParent->getID() + "'");
567 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(personTrip, true), true);
569 } else {
571 // set child references
572 personParent->addChildElement(personTrip);
573 fromEdge->addChildElement(personTrip);
574 toEdge->addChildElement(personTrip);
575 personTrip->incRef("buildPersonTripFromTo");
576 }
577 } else if (fromEdge && toBusStop) {
578 // create personTrip from->busStop
579 GNEDemandElement* personTrip = new GNEPersonTrip(myNet, personParent, fromEdge, toBusStop, arrivalPos, types, modes, lines);
580 if (myAllowUndoRedo) {
581 myNet->getViewNet()->getUndoList()->begin(personTrip->getTagProperty().getGUIIcon(), "add " + personTrip->getTagStr() + " in '" + personParent->getID() + "'");
583 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(personTrip, true), true);
585 } else {
587 // set child references
588 personParent->addChildElement(personTrip);
589 fromEdge->addChildElement(personTrip);
590 toBusStop->addChildElement(personTrip);
591 personTrip->incRef("buildPersonTripFromBusStop");
592 }
593 } else if (fromJunction && toJunction) {
594 // create personTrip from->to (junctions)
595 GNEDemandElement* personTrip = new GNEPersonTrip(myNet, personParent, fromJunction, toJunction, arrivalPos, types, modes, lines);
596 if (myAllowUndoRedo) {
597 myNet->getViewNet()->getUndoList()->begin(personTrip->getTagProperty().getGUIIcon(), "add " + personTrip->getTagStr() + " in '" + personParent->getID() + "'");
599 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(personTrip, true), true);
601 } else {
603 // set child references
604 personParent->addChildElement(personTrip);
605 fromJunction->addChildElement(personTrip);
606 toJunction->addChildElement(personTrip);
607 personTrip->incRef("buildPersonTripFromTo");
608 }
609 }
610 }
611}
612
613
614void
615GNERouteHandler::buildWalk(const CommonXMLStructure::SumoBaseObject* sumoBaseObject, const std::string& fromEdgeID, const std::string& toEdgeID,
616 const std::string& fromJunctionID, const std::string& toJunctionID, const std::string& toBusStopID,
617 const std::vector<std::string>& edgeIDs, const std::string& routeID, double arrivalPos) {
618 // get previous plan edge
619 const auto previousEdge = getPreviousPlanEdge(true, sumoBaseObject);
620 // parse parents
621 GNEDemandElement* personParent = getPersonParent(sumoBaseObject);
622 GNEEdge* fromEdge = myNet->getAttributeCarriers()->retrieveEdge(fromEdgeID, false);
623 GNEEdge* toEdge = myNet->getAttributeCarriers()->retrieveEdge(toEdgeID, false);
624 GNEJunction* fromJunction = myNet->getAttributeCarriers()->retrieveJunction(fromJunctionID, false);
625 GNEJunction* toJunction = myNet->getAttributeCarriers()->retrieveJunction(toJunctionID, false);
628 std::vector<GNEEdge*> edges = parseEdges(SUMO_TAG_WALK, edgeIDs);
629 // avoid consecutive duplicated edges
630 edges.erase(std::unique(edges.begin(), edges.end()), edges.end());
631 // check from edge
632 if ((fromEdge == nullptr) && previousEdge) {
633 fromEdge = previousEdge;
634 }
635 // check from junction
636 if (fromJunction == nullptr) {
637 if (previousEdge) {
638 fromJunction = previousEdge->getToJunction();
639 } else {
640 fromJunction = getPreviousPlanJunction(true, sumoBaseObject);
641 }
642 }
643 // check conditions
644 if (personParent) {
645 if (edges.size() > 0) {
646 // create walk edges
647 GNEDemandElement* walk = new GNEWalk(myNet, personParent, edges, arrivalPos);
648 if (myAllowUndoRedo) {
649 myNet->getViewNet()->getUndoList()->begin(walk->getTagProperty().getGUIIcon(), "add " + walk->getTagStr() + " '" + personParent->getID() + "'");
651 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(walk, true), true);
653 } else {
655 // set child references
656 personParent->addChildElement(walk);
657 for (const auto& edge : edges) {
658 edge->addChildElement(walk);
659 }
660 walk->incRef("buildWalkEdges");
661 }
662 } else if (route) {
663 // create walk over route
664 GNEDemandElement* walk = new GNEWalk(myNet, personParent, route, arrivalPos);
665 if (myAllowUndoRedo) {
666 myNet->getViewNet()->getUndoList()->begin(walk->getTagProperty().getGUIIcon(), "add " + walk->getTagStr() + " in '" + personParent->getID() + "'");
668 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(walk, true), true);
670 } else {
672 // set child references
673 personParent->addChildElement(walk);
674 route->addChildElement(walk);
675 walk->incRef("buildWalkRoute");
676 }
677 } else if (fromEdge && toEdge) {
678 // create walk from->to (edges)
679 GNEDemandElement* walk = new GNEWalk(myNet, personParent, fromEdge, toEdge, arrivalPos);
680 if (myAllowUndoRedo) {
681 myNet->getViewNet()->getUndoList()->begin(walk->getTagProperty().getGUIIcon(), "add " + walk->getTagStr() + " in '" + personParent->getID() + "'");
683 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(walk, true), true);
685 } else {
687 // set child references
688 personParent->addChildElement(walk);
689 fromEdge->addChildElement(walk);
690 toEdge->addChildElement(walk);
691 walk->incRef("buildWalkFromTo");
692 }
693 } else if (fromEdge && toBusStop) {
694 // create walk from->busStop
695 GNEDemandElement* walk = new GNEWalk(myNet, personParent, fromEdge, toBusStop, arrivalPos);
696 if (myAllowUndoRedo) {
697 myNet->getViewNet()->getUndoList()->begin(walk->getTagProperty().getGUIIcon(), "add " + walk->getTagStr() + " in '" + personParent->getID() + "'");
699 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(walk, true), true);
701 } else {
703 // set child references
704 personParent->addChildElement(walk);
705 fromEdge->addChildElement(walk);
706 toBusStop->addChildElement(walk);
707 walk->incRef("buildWalkFromBusStop");
708 }
709 } else if (fromJunction && toJunction) {
710 // create walk from->to (junction)
711 GNEDemandElement* walk = new GNEWalk(myNet, personParent, fromJunction, toJunction, arrivalPos);
712 if (myAllowUndoRedo) {
713 myNet->getViewNet()->getUndoList()->begin(walk->getTagProperty().getGUIIcon(), "add " + walk->getTagStr() + " in '" + personParent->getID() + "'");
715 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(walk, true), true);
717 } else {
719 // set child references
720 personParent->addChildElement(walk);
721 fromJunction->addChildElement(walk);
722 toJunction->addChildElement(walk);
723 walk->incRef("buildWalkFromTo");
724 }
725 }
726 }
727}
728
729
730void
731GNERouteHandler::buildRide(const CommonXMLStructure::SumoBaseObject* sumoBaseObject, const std::string& fromEdgeID, const std::string& toEdgeID,
732 const std::string& toBusStopID, double arrivalPos, const std::vector<std::string>& lines) {
733 // get previous plan edge
734 const auto previousEdge = getPreviousPlanEdge(true, sumoBaseObject);
735 // parse parents
736 GNEDemandElement* personParent = getPersonParent(sumoBaseObject);
737 GNEEdge* fromEdge = myNet->getAttributeCarriers()->retrieveEdge(fromEdgeID, false);
738 GNEEdge* toEdge = myNet->getAttributeCarriers()->retrieveEdge(toEdgeID, false);
740 // check from edge
741 if ((fromEdge == nullptr) && previousEdge) {
742 fromEdge = previousEdge;
743 }
744 // check conditions
745 if (personParent && fromEdge) {
746 if (toEdge) {
747 // create ride from->to
748 GNEDemandElement* ride = new GNERide(myNet, personParent, fromEdge, toEdge, arrivalPos, lines);
749 if (myAllowUndoRedo) {
750 myNet->getViewNet()->getUndoList()->begin(ride->getTagProperty().getGUIIcon(), "add " + ride->getTagStr() + " in '" + personParent->getID() + "'");
752 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(ride, true), true);
754 } else {
756 // set child references
757 personParent->addChildElement(ride);
758 fromEdge->addChildElement(ride);
759 toEdge->addChildElement(ride);
760 ride->incRef("buildRideFromTo");
761 }
762 } else if (toBusStop) {
763 // create ride from->busStop
764 GNEDemandElement* ride = new GNERide(myNet, personParent, fromEdge, toBusStop, arrivalPos, lines);
765 if (myAllowUndoRedo) {
766 myNet->getViewNet()->getUndoList()->begin(ride->getTagProperty().getGUIIcon(), "add " + ride->getTagStr() + " in '" + personParent->getID() + "'");
768 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(ride, true), true);
770 } else {
772 // set child references
773 personParent->addChildElement(ride);
774 fromEdge->addChildElement(ride);
775 toBusStop->addChildElement(ride);
776 ride->incRef("buildRideFromBusStop");
777 }
778 }
779 }
780}
781
782
783void
785 // first check if ID is duplicated
786 if (!isContainerIdDuplicated(containerParameters.id)) {
787 // obtain type
789 if (type == nullptr) {
790 writeError("Invalid container type '" + containerParameters.vtypeid + "' used in " + toString(containerParameters.tag) + " '" + containerParameters.id + "'.");
791 } else {
792 // create container using containerParameters
793 GNEDemandElement* container = new GNEContainer(SUMO_TAG_CONTAINER, myNet, type, containerParameters);
794 if (myAllowUndoRedo) {
795 myNet->getViewNet()->getUndoList()->begin(GUIIcon::CONTAINER, "add " + container->getTagStr() + " '" + container->getID() + "'");
797 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(container, true), true);
799 } else {
801 // set container as child of type
802 type->addChildElement(container);
803 container->incRef("buildContainer");
804 }
805 }
806 }
807}
808
809
810void
811GNERouteHandler::buildContainerFlow(const CommonXMLStructure::SumoBaseObject* /*sumoBaseObject*/, const SUMOVehicleParameter& containerFlowParameters) {
812 // first check if ID is duplicated
813 if (!isContainerIdDuplicated(containerFlowParameters.id)) {
814 // obtain type
815 GNEDemandElement* type = myNet->getAttributeCarriers()->retrieveDemandElement(SUMO_TAG_VTYPE, containerFlowParameters.vtypeid, false);
816 if (type == nullptr) {
817 writeError("Invalid containerFlow type '" + containerFlowParameters.vtypeid + "' used in " + toString(containerFlowParameters.tag) + " '" + containerFlowParameters.id + "'.");
818 } else {
819 // create containerFlow using containerFlowParameters
820 GNEDemandElement* containerFlow = new GNEContainer(SUMO_TAG_CONTAINERFLOW, myNet, type, containerFlowParameters);
821 if (myAllowUndoRedo) {
822 myNet->getViewNet()->getUndoList()->begin(GUIIcon::CONTAINERFLOW, "add " + containerFlow->getTagStr() + " '" + containerFlow->getID() + "'");
824 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(containerFlow, true), true);
826 } else {
828 // set containerFlow as child of type
829 type->addChildElement(containerFlow);
830 containerFlow->incRef("buildContainerFlow");
831 }
832 }
833 }
834}
835
836
837void
838GNERouteHandler::buildTransport(const CommonXMLStructure::SumoBaseObject* sumoBaseObject, const std::string& fromEdgeID, const std::string& toEdgeID,
839 const std::string& toContainerStopID, const std::vector<std::string>& lines, const double arrivalPos) {
840 // get previous plan edge
841 const auto previousEdge = getPreviousPlanEdge(false, sumoBaseObject);
842 // first parse parents
843 GNEDemandElement* containerParent = getContainerParent(sumoBaseObject);
844 GNEEdge* fromEdge = myNet->getAttributeCarriers()->retrieveEdge(fromEdgeID, false);
845 GNEEdge* toEdge = myNet->getAttributeCarriers()->retrieveEdge(toEdgeID, false);
846 GNEAdditional* toContainerStop = myNet->getAttributeCarriers()->retrieveAdditional(SUMO_TAG_CONTAINER_STOP, toContainerStopID, false);
847 // check from edge
848 if ((fromEdge == nullptr) && previousEdge) {
849 fromEdge = previousEdge;
850 }
851 // check conditions
852 if (containerParent && fromEdge) {
853 if (toEdge) {
854 // create transport from->to
855 GNEDemandElement* transport = new GNETransport(myNet, containerParent, fromEdge, toEdge, lines, arrivalPos);
856 if (myAllowUndoRedo) {
857 myNet->getViewNet()->getUndoList()->begin(transport->getTagProperty().getGUIIcon(), "add " + transport->getTagStr() + " in '" + containerParent->getID() + "'");
859 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(transport, true), true);
861 } else {
863 // set child references
864 containerParent->addChildElement(transport);
865 fromEdge->addChildElement(transport);
866 toEdge->addChildElement(transport);
867 transport->incRef("buildTransportFromTo");
868 }
869 } else if (toContainerStop) {
870 // create transport from->containerStop
871 GNEDemandElement* transport = new GNETransport(myNet, containerParent, fromEdge, toContainerStop, lines, arrivalPos);
872 if (myAllowUndoRedo) {
873 myNet->getViewNet()->getUndoList()->begin(transport->getTagProperty().getGUIIcon(), "add " + transport->getTagStr() + " in '" + containerParent->getID() + "'");
875 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(transport, true), true);
877 } else {
879 // set child references
880 containerParent->addChildElement(transport);
881 fromEdge->addChildElement(transport);
882 toContainerStop->addChildElement(transport);
883 transport->incRef("buildTransportFromContainerStop");
884 }
885 }
886 }
887}
888
889
890void
891GNERouteHandler::buildTranship(const CommonXMLStructure::SumoBaseObject* sumoBaseObject, const std::string& fromEdgeID, const std::string& toEdgeID,
892 const std::string& toContainerStopID, const std::vector<std::string>& edgeIDs, const double speed, const double departPosition, const double arrivalPosition) {
893 // get previous plan edge
894 const auto previousEdge = getPreviousPlanEdge(false, sumoBaseObject);
895 // first parse parents
896 GNEDemandElement* containerParent = getContainerParent(sumoBaseObject);
897 GNEEdge* fromEdge = myNet->getAttributeCarriers()->retrieveEdge(fromEdgeID, false);
898 GNEEdge* toEdge = myNet->getAttributeCarriers()->retrieveEdge(toEdgeID, false);
899 GNEAdditional* toContainerStop = myNet->getAttributeCarriers()->retrieveAdditional(SUMO_TAG_CONTAINER_STOP, toContainerStopID, false);
900 std::vector<GNEEdge*> edges = parseEdges(SUMO_TAG_WALK, edgeIDs);
901 // avoid consecutive duplicated edges
902 edges.erase(std::unique(edges.begin(), edges.end()), edges.end());
903 // check from edge
904 if ((fromEdge == nullptr) && previousEdge) {
905 fromEdge = previousEdge;
906 }
907 // check conditions
908 if (containerParent && (fromEdge || (edges.size() > 0))) {
909 if (edges.size() > 0) {
910 // create tranship edges
911 GNEDemandElement* tranship = new GNETranship(myNet, containerParent, edges, speed, departPosition, arrivalPosition);
912 if (myAllowUndoRedo) {
913 myNet->getViewNet()->getUndoList()->begin(tranship->getTagProperty().getGUIIcon(), "add " + tranship->getTagStr() + " in '" + containerParent->getID() + "'");
915 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(tranship, true), true);
917 } else {
919 // set child references
920 containerParent->addChildElement(tranship);
921 for (const auto& edge : edges) {
922 edge->addChildElement(tranship);
923 }
924 tranship->incRef("buildTranshipEdges");
925 }
926 } else if (toEdge) {
927 // create tranship from->to
928 GNEDemandElement* tranship = new GNETranship(myNet, containerParent, fromEdge, toEdge, speed, departPosition, arrivalPosition);
929 if (myAllowUndoRedo) {
930 myNet->getViewNet()->getUndoList()->begin(tranship->getTagProperty().getGUIIcon(), "add " + tranship->getTagStr() + " in '" + containerParent->getID() + "'");
932 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(tranship, true), true);
934 } else {
936 // set child references
937 containerParent->addChildElement(tranship);
938 fromEdge->addChildElement(tranship);
939 toEdge->addChildElement(tranship);
940 tranship->incRef("buildTranshipFromTo");
941 }
942 } else if (toContainerStop) {
943 // create tranship from->containerStop
944 GNEDemandElement* tranship = new GNETranship(myNet, containerParent, fromEdge, toContainerStop, speed, departPosition, arrivalPosition);
945 if (myAllowUndoRedo) {
946 myNet->getViewNet()->getUndoList()->begin(tranship->getTagProperty().getGUIIcon(), "add " + tranship->getTagStr() + " '" + containerParent->getID() + "'");
948 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(tranship, true), true);
950 } else {
952 // set child references
953 containerParent->addChildElement(tranship);
954 fromEdge->addChildElement(tranship);
955 toContainerStop->addChildElement(tranship);
956 tranship->incRef("buildTranshipFromContainerStop");
957 }
958 }
959 }
960}
961
962
963void
965 // get obj parent
966 const auto objParent = sumoBaseObject->getParentSumoBaseObject();
967 // set tag
968 SumoXMLTag tag = objParent->getTag();
969 if (!objParent->hasStringAttribute(SUMO_ATTR_ROUTE) && !objParent->hasStringAttribute(SUMO_ATTR_FROM) && !objParent->hasStringAttribute(SUMO_ATTR_TO)) {
970 if (tag == SUMO_TAG_VEHICLE) {
972 } else if (tag == SUMO_TAG_FLOW) {
974 }
975 }
976 // special case for flows over route
977 if (objParent->hasStringAttribute(SUMO_ATTR_ROUTE) && (objParent->getTag() == SUMO_TAG_FLOW)) {
978 tag = GNE_TAG_FLOW_ROUTE;
979 }
980 // get stop parent
981 GNEDemandElement* stopParent = myNet->getAttributeCarriers()->retrieveDemandElement(tag, objParent->getStringAttribute(SUMO_ATTR_ID), false);
982 // check if stopParent exist
983 if (stopParent) {
984 // flag for waypoint (is like a stop, but with extra attribute speed)
985 bool waypoint = false;
986 // avoid waypoints for person and containers
987 if (!stopParent->getTagProperty().isPerson() && !stopParent->getTagProperty().isContainer()) {
988 waypoint = (sumoBaseObject->getStopParameter().parametersSet & STOP_SPEED_SET) || (sumoBaseObject->getStopParameter().speed > 0);
989 }
990 // declare pointers to parent elements
991 GNEAdditional* stoppingPlace = nullptr;
992 GNELane* lane = nullptr;
993 GNEEdge* edge = nullptr;
994 // declare stopTagType
995 SumoXMLTag stopTagType = SUMO_TAG_NOTHING;
996 bool validParentDemandElement = true;
997 // check conditions
998 if (stopParameters.busstop.size() > 0) {
999 stoppingPlace = myNet->getAttributeCarriers()->retrieveAdditional(SUMO_TAG_BUS_STOP, stopParameters.busstop, false);
1000 stopTagType = waypoint ? GNE_TAG_WAYPOINT_BUSSTOP : SUMO_TAG_STOP_BUSSTOP;
1001 // containers cannot stops in busStops
1002 if (stopParent->getTagProperty().isContainer()) {
1003 writeError("Containers don't support stops at busStops");
1004 validParentDemandElement = false;
1005 }
1006 } else if (stopParameters.containerstop.size() > 0) {
1007 stoppingPlace = myNet->getAttributeCarriers()->retrieveAdditional(SUMO_TAG_CONTAINER_STOP, stopParameters.containerstop, false);
1009 // persons cannot stops in containerStops
1010 if (stopParent->getTagProperty().isPerson()) {
1011 writeError("Persons don't support stops at containerStops");
1012 validParentDemandElement = false;
1013 }
1014 } else if (stopParameters.chargingStation.size() > 0) {
1017 // check person and containers
1018 if (stopParent->getTagProperty().isPerson()) {
1019 writeError("Persons don't support stops at chargingStations");
1020 validParentDemandElement = false;
1021 } else if (stopParent->getTagProperty().isContainer()) {
1022 writeError("Containers don't support stops at chargingStations");
1023 validParentDemandElement = false;
1024 }
1025 } else if (stopParameters.parkingarea.size() > 0) {
1026 stoppingPlace = myNet->getAttributeCarriers()->retrieveAdditional(SUMO_TAG_PARKING_AREA, stopParameters.parkingarea, false);
1028 // check person and containers
1029 if (stopParent->getTagProperty().isPerson()) {
1030 writeError("Persons don't support stops at parkingAreas");
1031 validParentDemandElement = false;
1032 } else if (stopParent->getTagProperty().isContainer()) {
1033 writeError("Containers don't support stops at parkingAreas");
1034 validParentDemandElement = false;
1035 }
1036 } else if (stopParameters.lane.size() > 0) {
1037 lane = myNet->getAttributeCarriers()->retrieveLane(stopParameters.lane, false);
1038 stopTagType = waypoint ? GNE_TAG_WAYPOINT_LANE : SUMO_TAG_STOP_LANE;
1039 } else if (stopParameters.edge.size() > 0) {
1040 edge = myNet->getAttributeCarriers()->retrieveEdge(stopParameters.edge, false);
1041 // check vehicles
1042 if (stopParent->getTagProperty().isVehicle()) {
1043 writeError("vehicles don't support stops at edges");
1044 validParentDemandElement = false;
1045 }
1046 }
1047 // overwrite lane with edge parent if we're handling a personStop
1048 if (lane && (stopParent->getTagProperty().isPerson() || stopParent->getTagProperty().isContainer())) {
1049 edge = lane->getParentEdge();
1050 lane = nullptr;
1051 }
1052 // first check that parent is valid
1053 if (validParentDemandElement) {
1054 // check if values are correct
1055 if (stoppingPlace && lane && edge) {
1056 writeError("A stop must be defined either over a stoppingPlace, a edge or a lane");
1057 } else if (!stoppingPlace && !lane && !edge) {
1058 writeError("A stop requires only a stoppingPlace, edge or lane");
1059 } else if (stoppingPlace) {
1060 // create stop using stopParameters and stoppingPlace
1061 GNEDemandElement* stop = nullptr;
1062 if (stopParent->getTagProperty().isPerson()) {
1063 stop = new GNEStop(GNE_TAG_STOPPERSON_BUSSTOP, myNet, stopParent, stoppingPlace, stopParameters);
1064 } else if (stopParent->getTagProperty().isContainer()) {
1065 stop = new GNEStop(GNE_TAG_STOPCONTAINER_CONTAINERSTOP, myNet, stopParent, stoppingPlace, stopParameters);
1066 } else {
1067 stop = new GNEStop(stopTagType, myNet, stopParent, stoppingPlace, stopParameters);
1068 }
1069 // add it depending of undoDemandElements
1070 if (myAllowUndoRedo) {
1071 myNet->getViewNet()->getUndoList()->begin(stop->getTagProperty().getGUIIcon(), "add " + stop->getTagStr() + " in '" + stopParent->getID() + "'");
1073 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(stop, true), true);
1075 } else {
1077 stoppingPlace->addChildElement(stop);
1078 stopParent->addChildElement(stop);
1079 stop->incRef("buildStoppingPlaceStop");
1080 }
1081 } else if (lane) {
1082 // create stop using stopParameters and lane (only for vehicles)
1083 GNEDemandElement* stop = new GNEStop(stopTagType, myNet, stopParent, lane, stopParameters);
1084 // add it depending of undoDemandElements
1085 if (myAllowUndoRedo) {
1086 myNet->getViewNet()->getUndoList()->begin(stop->getTagProperty().getGUIIcon(), "add " + stop->getTagStr() + " in '" + stopParent->getID() + "'");
1088 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(stop, true), true);
1090 } else {
1092 lane->addChildElement(stop);
1093 stopParent->addChildElement(stop);
1094 stop->incRef("buildLaneStop");
1095 }
1096 } else {
1097 // create stop using stopParameters and edge
1098 GNEDemandElement* stop = nullptr;
1099 if (stopParent->getTagProperty().isPerson()) {
1100 stop = new GNEStop(GNE_TAG_STOPPERSON_EDGE, myNet, stopParent, edge, stopParameters);
1101 } else {
1102 stop = new GNEStop(GNE_TAG_STOPCONTAINER_EDGE, myNet, stopParent, edge, stopParameters);
1103 }
1104 // add it depending of undoDemandElements
1105 if (myAllowUndoRedo) {
1106 myNet->getViewNet()->getUndoList()->begin(stop->getTagProperty().getGUIIcon(), "add " + stop->getTagStr() + " in '" + stopParent->getID() + "'");
1108 myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(stop, true), true);
1110 } else {
1112 edge->addChildElement(stop);
1113 stopParent->addChildElement(stop);
1114 stop->incRef("buildLaneStop");
1115 }
1116 }
1117 }
1118 }
1119}
1120
1121
1122bool
1124 GNEPathCreator* pathCreator, const bool centerAfterCreation) {
1125 // clear and set person object
1127 myPlanObject->setTag(personParent->getTagProperty().getTag());
1129 // declare personPlan object
1131 personPlanObject->setTag(tag);
1132 // get person plan attributes
1133 personPlanAttributes->getAttributesAndValues(personPlanObject, true);
1134 // get attributes
1135 const std::vector<std::string> types = personPlanObject->hasStringListAttribute(SUMO_ATTR_VTYPES) ? personPlanObject->getStringListAttribute(SUMO_ATTR_VTYPES) : std::vector<std::string>();
1136 const std::vector<std::string> modes = personPlanObject->hasStringListAttribute(SUMO_ATTR_MODES) ? personPlanObject->getStringListAttribute(SUMO_ATTR_MODES) : std::vector<std::string>();
1137 const std::vector<std::string> lines = personPlanObject->hasStringListAttribute(SUMO_ATTR_LINES) ? personPlanObject->getStringListAttribute(SUMO_ATTR_LINES) : std::vector<std::string>();
1138 const double arrivalPos = personPlanObject->hasDoubleAttribute(SUMO_ATTR_ARRIVALPOS) ? personPlanObject->getDoubleAttribute(SUMO_ATTR_ARRIVALPOS) : -1;
1139 // get stop parameters
1140 SUMOVehicleParameter::Stop stopParameters;
1141 // fill stops parameters
1142 if ((tag == GNE_TAG_STOPPERSON_BUSSTOP) || (tag == GNE_TAG_STOPPERSON_EDGE)) {
1143 stopParameters.actType = personPlanObject->getStringAttribute(SUMO_ATTR_ACTTYPE);
1144 if (personPlanObject->hasTimeAttribute(SUMO_ATTR_DURATION)) {
1145 stopParameters.duration = personPlanObject->getTimeAttribute(SUMO_ATTR_DURATION);
1146 stopParameters.parametersSet |= STOP_DURATION_SET;
1147 }
1148 if (personPlanObject->hasTimeAttribute(SUMO_ATTR_UNTIL)) {
1149 stopParameters.until = personPlanObject->getTimeAttribute(SUMO_ATTR_UNTIL);
1150 stopParameters.parametersSet |= STOP_UNTIL_SET;
1151 }
1152 }
1153 // get edges
1154 GNEEdge* fromEdge = (pathCreator->getSelectedEdges().size() > 0) ? pathCreator->getSelectedEdges().front() : nullptr;
1155 GNEEdge* toEdge = (pathCreator->getSelectedEdges().size() > 0) ? pathCreator->getSelectedEdges().back() : nullptr;
1156 // get junctions
1157 GNEJunction* fromJunction = (pathCreator->getSelectedJunctions().size() > 0) ? pathCreator->getSelectedJunctions().front() : nullptr;
1158 GNEJunction* toJunction = (pathCreator->getSelectedJunctions().size() > 0) ? pathCreator->getSelectedJunctions().back() : nullptr;
1159 // get busStop
1160 GNEAdditional* toBusStop = pathCreator->getToStoppingPlace(SUMO_TAG_BUS_STOP);
1161 // get path edges
1162 std::vector<std::string> edges;
1163 for (const auto& path : pathCreator->getPath()) {
1164 for (const auto& edge : path.getSubPath()) {
1165 edges.push_back(edge->getID());
1166 }
1167 }
1168 // get route
1169 GNEDemandElement* route = pathCreator->getRoute();
1170 // check what PersonPlan we're creating
1171 switch (tag) {
1172 // Person Trips
1174 // check if person trip busStop->edge can be created
1175 if (fromEdge && toEdge) {
1176 buildPersonTrip(personPlanObject, fromEdge->getID(), toEdge->getID(), "", "", "", arrivalPos, types, modes, lines);
1177 } else {
1178 myNet->getViewNet()->setStatusBarText("A person trip from edge to edge needs two edges edge");
1179 return false;
1180 }
1181 break;
1182 }
1184 // check if person trip busStop->busStop can be created
1185 if (fromEdge && toBusStop) {
1186 buildPersonTrip(personPlanObject, fromEdge->getID(), "", "", "", toBusStop->getID(), arrivalPos, types, modes, lines);
1187 } else {
1188 myNet->getViewNet()->setStatusBarText("A person trip from edge to busStop needs one edge and one busStop");
1189 return false;
1190 }
1191 break;
1192 }
1194 // check if person trip busStop->junction can be created
1195 if (fromJunction && toJunction) {
1196 buildPersonTrip(personPlanObject, "", "", fromJunction->getID(), toJunction->getID(), "", arrivalPos, types, modes, lines);
1197 } else {
1198 myNet->getViewNet()->setStatusBarText("A person trip from junction to junction needs two junctions junction");
1199 return false;
1200 }
1201 break;
1202 }
1203 // Walks
1204 case GNE_TAG_WALK_EDGE: {
1205 // check if transport busStop->edge can be created
1206 if (fromEdge && toEdge) {
1207 buildWalk(personPlanObject, fromEdge->getID(), toEdge->getID(), "", "", "", {}, "", arrivalPos);
1208 } else {
1209 myNet->getViewNet()->setStatusBarText("A ride from busStop to edge needs a busStop and an edge");
1210 return false;
1211 }
1212 break;
1213 }
1214 case GNE_TAG_WALK_BUSSTOP: {
1215 // check if transport busStop->busStop can be created
1216 if (fromEdge && toBusStop) {
1217 buildWalk(personPlanObject, fromEdge->getID(), "", "", "", toBusStop->getID(), {}, "", arrivalPos);
1218 } else {
1219 myNet->getViewNet()->setStatusBarText("A transport from busStop to busStop needs two busStops");
1220 return false;
1221 }
1222 break;
1223 }
1224 case GNE_TAG_WALK_EDGES: {
1225 // check if transport edges can be created
1226 if (edges.size() > 0) {
1227 buildWalk(personPlanObject, "", "", "", "", "", edges, "", arrivalPos);
1228 } else {
1229 myNet->getViewNet()->setStatusBarText("A transport with edges attribute needs a list of edges");
1230 return false;
1231 }
1232 break;
1233 }
1234 case GNE_TAG_WALK_ROUTE: {
1235 // check if transport edges can be created
1236 if (route) {
1237 buildWalk(personPlanObject, "", "", "", "", "", {}, route->getID(), arrivalPos);
1238 } else {
1239 myNet->getViewNet()->setStatusBarText("A route transport needs a route");
1240 return false;
1241 }
1242 break;
1243 }
1245 // check if transport busStop->junction can be created
1246 if (fromJunction && toJunction) {
1247 buildWalk(personPlanObject, "", "", fromJunction->getID(), toJunction->getID(), "", {}, "", arrivalPos);
1248 } else {
1249 myNet->getViewNet()->setStatusBarText("A ride from busStop to junction needs a busStop and an junction");
1250 return false;
1251 }
1252 break;
1253 }
1254 // Rides
1255 case GNE_TAG_RIDE_EDGE: {
1256 // check if ride busStop->edge can be created
1257 if (fromEdge && toEdge) {
1258 buildRide(personPlanObject, fromEdge->getID(), toEdge->getID(), "", arrivalPos, lines);
1259 } else {
1260 myNet->getViewNet()->setStatusBarText("A ride from edge to edge needs two edges edge");
1261 return false;
1262 }
1263 break;
1264 }
1265 case GNE_TAG_RIDE_BUSSTOP: {
1266 // check if ride busStop->busStop can be created
1267 if (fromEdge && toBusStop) {
1268 buildRide(personPlanObject, fromEdge->getID(), "", toBusStop->getID(), arrivalPos, lines);
1269 } else {
1270 myNet->getViewNet()->setStatusBarText("A ride from edge to busStop needs one edge and one busStop");
1271 return false;
1272 }
1273 break;
1274 }
1275 // stops
1277 // check if ride busStop->busStop can be created
1278 if (fromEdge) {
1279 stopParameters.edge = fromEdge->getID();
1280 stopParameters.endPos = fromEdge->getLanes().front()->getLaneShape().nearest_offset_to_point2D(myNet->getViewNet()->getPositionInformation());
1281 stopParameters.parametersSet |= STOP_END_SET;
1282 buildStop(personPlanObject, stopParameters);
1283 } else {
1284 myNet->getViewNet()->setStatusBarText("A stop has to be placed over an edge");
1285 return false;
1286 }
1287 break;
1288 }
1290 // check if ride busStop->busStop can be created
1291 if (toBusStop) {
1292 stopParameters.busstop = toBusStop->getID();
1293 buildStop(personPlanObject, stopParameters);
1294 } else {
1295 myNet->getViewNet()->setStatusBarText("A stop has to be placed over a busStop");
1296 return false;
1297 }
1298 break;
1299 }
1300 default:
1301 throw InvalidArgument("Invalid person plan tag");
1302 }
1303 // get person
1304 const auto person = myNet->getAttributeCarriers()->retrieveDemandElement(personPlanObject->getParentSumoBaseObject()->getTag(),
1305 personPlanObject->getParentSumoBaseObject()->getStringAttribute(SUMO_ATTR_ID), false);
1306 if (person) {
1307 // compute person (and all person plans)
1308 person->computePathElement();
1309 // center view after creation
1310 if (centerAfterCreation && !myNet->getViewNet()->getVisibleBoundary().around(person->getPositionInView())) {
1311 myNet->getViewNet()->centerTo(person->getPositionInView(), false);
1312 }
1313 }
1314 return true;
1315}
1316
1317
1318bool
1319GNERouteHandler::buildContainerPlan(SumoXMLTag tag, GNEDemandElement* containerParent, GNEAttributesCreator* containerPlanAttributes, GNEPathCreator* pathCreator, const bool centerAfterCreation) {
1320 // clear and set planObject
1322 myPlanObject->setTag(containerParent->getTagProperty().getTag());
1323 myPlanObject->addStringAttribute(SUMO_ATTR_ID, containerParent->getID());
1324 // declare containerPlan object
1326 containerPlanObject->setTag(tag);
1327 // get attributes and values
1328 containerPlanAttributes->getAttributesAndValues(containerPlanObject, true);
1329 // get attributes
1330 const std::vector<std::string> lines = containerPlanObject->hasStringListAttribute(SUMO_ATTR_LINES) ? containerPlanObject->getStringListAttribute(SUMO_ATTR_LINES) : std::vector<std::string>();
1331 const double speed = containerPlanObject->hasDoubleAttribute(SUMO_ATTR_SPEED) ? containerPlanObject->getDoubleAttribute(SUMO_ATTR_SPEED) : 1.39;
1332 const double departPos = containerPlanObject->hasDoubleAttribute(SUMO_ATTR_DEPARTPOS) ? containerPlanObject->getDoubleAttribute(SUMO_ATTR_DEPARTPOS) : -1;
1333 const double arrivalPos = containerPlanObject->hasDoubleAttribute(SUMO_ATTR_ARRIVALPOS) ? containerPlanObject->getDoubleAttribute(SUMO_ATTR_ARRIVALPOS) : -1;
1334 // get stop parameters
1335 SUMOVehicleParameter::Stop stopParameters;
1336 // fill stops parameters
1338 stopParameters.actType = containerPlanObject->getStringAttribute(SUMO_ATTR_ACTTYPE);
1339 if (containerPlanObject->hasTimeAttribute(SUMO_ATTR_DURATION)) {
1340 stopParameters.duration = containerPlanObject->getTimeAttribute(SUMO_ATTR_DURATION);
1341 stopParameters.parametersSet |= STOP_DURATION_SET;
1342 }
1343 if (containerPlanObject->hasTimeAttribute(SUMO_ATTR_UNTIL)) {
1344 stopParameters.until = containerPlanObject->getTimeAttribute(SUMO_ATTR_UNTIL);
1345 stopParameters.parametersSet |= STOP_UNTIL_SET;
1346 }
1347 }
1348 // get edges
1349 GNEEdge* fromEdge = (pathCreator->getSelectedEdges().size() > 0) ? pathCreator->getSelectedEdges().front() : nullptr;
1350 GNEEdge* toEdge = (pathCreator->getSelectedEdges().size() > 0) ? pathCreator->getSelectedEdges().back() : nullptr;
1351 // get containerStop
1352 GNEAdditional* toContainerStop = pathCreator->getToStoppingPlace(SUMO_TAG_CONTAINER_STOP);
1353 // get path edges
1354 std::vector<std::string> edges;
1355 for (const auto& path : pathCreator->getPath()) {
1356 for (const auto& edge : path.getSubPath()) {
1357 edges.push_back(edge->getID());
1358 }
1359 }
1360 // check what ContainerPlan we're creating
1361 switch (tag) {
1362 // Transports
1364 // check if transport busStop->edge can be created
1365 if (fromEdge && toEdge) {
1366 buildTransport(containerPlanObject, fromEdge->getID(), toEdge->getID(), "", lines, arrivalPos);
1367 } else {
1368 myNet->getViewNet()->setStatusBarText("A ride from busStop to edge needs a busStop and an edge");
1369 return false;
1370 }
1371 break;
1372 }
1374 // check if transport busStop->busStop can be created
1375 if (fromEdge && toContainerStop) {
1376 buildTransport(containerPlanObject, fromEdge->getID(), "", toContainerStop->getID(), lines, arrivalPos);
1377 } else {
1378 myNet->getViewNet()->setStatusBarText("A transport from busStop to busStop needs two busStops");
1379 return false;
1380 }
1381 break;
1382 }
1383 // Tranships
1384 case GNE_TAG_TRANSHIP_EDGE: {
1385 // check if tranship busStop->edge can be created
1386 if (fromEdge && toEdge) {
1387 buildTranship(containerPlanObject, fromEdge->getID(), toEdge->getID(), "", {}, speed, departPos, arrivalPos);
1388 } else {
1389 myNet->getViewNet()->setStatusBarText("A ride from busStop to edge needs a busStop and an edge");
1390 return false;
1391 }
1392 break;
1393 }
1395 // check if tranship busStop->busStop can be created
1396 if (fromEdge && toContainerStop) {
1397 buildTranship(containerPlanObject, fromEdge->getID(), "", toContainerStop->getID(), {}, speed, departPos, arrivalPos);
1398 } else {
1399 myNet->getViewNet()->setStatusBarText("A tranship from busStop to busStop needs two busStops");
1400 return false;
1401 }
1402 break;
1403 }
1405 // check if tranship edges can be created
1406 if (edges.size() > 0) {
1407 buildTranship(containerPlanObject, "", "", "", edges, speed, departPos, arrivalPos);
1408 } else {
1409 myNet->getViewNet()->setStatusBarText("A tranship with edges attribute needs a list of edges");
1410 return false;
1411 }
1412 break;
1413 }
1414 // stops
1416 // check if ride busStop->busStop can be created
1417 if (fromEdge) {
1418 stopParameters.edge = fromEdge->getID();
1419 stopParameters.endPos = fromEdge->getLanes().front()->getLaneShape().nearest_offset_to_point2D(myNet->getViewNet()->getPositionInformation());
1420 stopParameters.parametersSet |= STOP_END_SET;
1421 buildStop(containerPlanObject, stopParameters);
1422 } else {
1423 myNet->getViewNet()->setStatusBarText("A stop has to be placed over an edge");
1424 return false;
1425 }
1426 break;
1427 }
1429 // check if ride busStop->busStop can be created
1430 if (toContainerStop) {
1431 stopParameters.containerstop = toContainerStop->getID();
1432 buildStop(containerPlanObject, stopParameters);
1433 } else {
1434 myNet->getViewNet()->setStatusBarText("A stop has to be placed over a busStop");
1435 return false;
1436 }
1437 break;
1438 }
1439 default:
1440 throw InvalidArgument("Invalid container plan tag");
1441 }
1442 // get container
1443 const auto container = myNet->getAttributeCarriers()->retrieveDemandElement(containerPlanObject->getParentSumoBaseObject()->getTag(),
1444 containerPlanObject->getParentSumoBaseObject()->getStringAttribute(SUMO_ATTR_ID), false);
1445 if (container) {
1446 // compute container (and all container plans)
1447 container->computePathElement();
1448 // center view after creation
1449 if (centerAfterCreation && !myNet->getViewNet()->getVisibleBoundary().around(container->getPositionInView())) {
1450 myNet->getViewNet()->centerTo(container->getPositionInView(), false);
1451 }
1452 }
1453 return true;
1454}
1455
1456
1457bool
1459 // declare vehicle tags vector
1461 for (const auto& vehicleTag : vehicleTags) {
1462 if (!checkDuplicatedDemandElement(vehicleTag, id)) {
1463 writeError("There is another " + toString(vehicleTag) + " with the same ID='" + id + "'.");
1464 return true;
1465 }
1466 }
1467 return false;
1468}
1469
1470
1471bool
1473 for (SumoXMLTag personTag : std::vector<SumoXMLTag>({SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW})) {
1474 if (!checkDuplicatedDemandElement(personTag, id)) {
1475 writeError("There is another " + toString(personTag) + " with the same ID='" + id + "'.");
1476 return true;
1477 }
1478 }
1479 return false;
1480}
1481
1482
1483bool
1485 for (SumoXMLTag containerTag : std::vector<SumoXMLTag>({SUMO_TAG_CONTAINER, SUMO_TAG_CONTAINERFLOW})) {
1486 if (!checkDuplicatedDemandElement(containerTag, id)) {
1487 writeError("There is another " + toString(containerTag) + " with the same ID='" + id + "'.");
1488 return true;
1489 }
1490 }
1491 return false;
1492}
1493
1494
1495void
1496GNERouteHandler::transformToVehicle(GNEVehicle* originalVehicle, bool createEmbeddedRoute) {
1497 // get original vehicle tag
1498 SumoXMLTag tag = originalVehicle->getTagProperty().getTag();
1499 // get pointer to net
1500 GNENet* net = originalVehicle->getNet();
1501 // check if transform after creation
1502 const bool inspectAfterTransform = net->getViewNet()->isAttributeCarrierInspected(originalVehicle);
1503 // declare route handler
1504 GNERouteHandler routeHandler("", net, true, false);
1505 // make a copy of the vehicle parameters
1506 SUMOVehicleParameter vehicleParameters = *originalVehicle;
1507 // obtain vClass
1508 const auto vClass = originalVehicle->getVClass();
1509 // set "yellow" as original route color
1510 RGBColor routeColor = RGBColor::YELLOW;
1511 // declare edges
1512 std::vector<GNEEdge*> routeEdges;
1513 // obtain edges depending of tag
1514 if ((tag == GNE_TAG_FLOW_ROUTE) || (tag == SUMO_TAG_VEHICLE)) {
1515 // get route edges
1516 routeEdges = originalVehicle->getParentDemandElements().back()->getParentEdges();
1517 // get original route color
1518 routeColor = originalVehicle->getParentDemandElements().back()->getColor();
1519 } else if (originalVehicle->getTagProperty().hasEmbeddedRoute()) {
1520 // get embedded route edges
1521 routeEdges = originalVehicle->getChildDemandElements().front()->getParentEdges();
1522 } else if ((tag == SUMO_TAG_TRIP) || (tag == SUMO_TAG_FLOW)) {
1523 // calculate path using from-via-to edges
1524 routeEdges = originalVehicle->getNet()->getPathManager()->getPathCalculator()->calculateDijkstraPath(originalVehicle->getVClass(), originalVehicle->getParentEdges());
1525 }
1526 // declare edge IDs
1527 std::vector<std::string> edgeIDs;
1528 for (const auto& edge : routeEdges) {
1529 edgeIDs.push_back(edge->getID());
1530 }
1531 // only continue if edges are valid
1532 if (routeEdges.empty()) {
1533 // declare header
1534 const std::string header = "Problem transforming to vehicle";
1535 // declare message
1536 const std::string message = "Vehicle cannot be transformed. Invalid number of edges";
1537 // write warning
1538 WRITE_DEBUG("Opened FXMessageBox " + header);
1539 // open message box
1540 FXMessageBox::warning(originalVehicle->getNet()->getViewNet()->getApp(), MBOX_OK, header.c_str(), "%s", message.c_str());
1541 // write warning if netedit is running in testing mode
1542 WRITE_DEBUG("Closed FXMessageBox " + header);
1543 } else {
1544 // begin undo-redo operation
1545 net->getViewNet()->getUndoList()->begin(originalVehicle->getTagProperty().getGUIIcon(), "transform " + originalVehicle->getTagStr() + " to " + toString(SUMO_TAG_VEHICLE));
1546 // first delete vehicle
1547 net->deleteDemandElement(originalVehicle, net->getViewNet()->getUndoList());
1548 // check if new vehicle must have an embedded route
1549 if (createEmbeddedRoute) {
1550 // change tag in vehicle parameters
1551 vehicleParameters.tag = GNE_TAG_VEHICLE_WITHROUTE;
1552 // create a flow with embebbed routes
1554 CommonXMLStructure::SumoBaseObject* routeBaseOBject = new CommonXMLStructure::SumoBaseObject(vehicleBaseOBject);
1555 // fill parameters
1556 vehicleBaseOBject->setTag(SUMO_TAG_VEHICLE);
1557 vehicleBaseOBject->addStringAttribute(SUMO_ATTR_ID, vehicleParameters.id);
1558 vehicleBaseOBject->setVehicleParameter(&vehicleParameters);
1559 // build embedded route
1560 routeHandler.buildEmbeddedRoute(routeBaseOBject, edgeIDs, RGBColor::INVISIBLE, false, 0, {});
1561 // delete vehicle base object
1562 delete vehicleBaseOBject;
1563 } else {
1564 // change tag in vehicle parameters
1565 vehicleParameters.tag = SUMO_TAG_VEHICLE;
1566 // generate route ID
1567 const std::string routeID = net->getAttributeCarriers()->generateDemandElementID(SUMO_TAG_ROUTE);
1568 // build route
1569 routeHandler.buildRoute(nullptr, routeID, vClass, edgeIDs, routeColor, false, 0, {});
1570 // set route ID in vehicle parameters
1571 vehicleParameters.routeid = routeID;
1572 // create vehicle
1573 routeHandler.buildVehicleOverRoute(nullptr, vehicleParameters);
1574 }
1575 // end undo-redo operation
1576 net->getViewNet()->getUndoList()->end();
1577 // check if inspect
1578 if (inspectAfterTransform) {
1579 // get created element
1580 auto transformedVehicle = net->getAttributeCarriers()->retrieveDemandElement(vehicleParameters.tag, vehicleParameters.id);
1581 // inspect it
1582 net->getViewNet()->getViewParent()->getInspectorFrame()->inspectSingleElement(transformedVehicle);
1583 }
1584 }
1585}
1586
1587
1588void
1589GNERouteHandler::transformToRouteFlow(GNEVehicle* originalVehicle, bool createEmbeddedRoute) {
1590 // get original vehicle tag
1591 SumoXMLTag tag = originalVehicle->getTagProperty().getTag();
1592 // get pointer to net
1593 GNENet* net = originalVehicle->getNet();
1594 // check if transform after creation
1595 const bool inspectAfterTransform = net->getViewNet()->isAttributeCarrierInspected(originalVehicle);
1596 // declare route handler
1597 GNERouteHandler routeHandler("", net, true, false);
1598 // obtain vehicle parameters
1599 SUMOVehicleParameter vehicleParameters = *originalVehicle;
1600 // obtain vClass
1601 const auto vClass = originalVehicle->getVClass();
1602 // set "yellow" as original route color
1603 RGBColor routeColor = RGBColor::YELLOW;
1604 // declare edges
1605 std::vector<GNEEdge*> routeEdges;
1606 // obtain edges depending of tag
1607 if ((tag == GNE_TAG_FLOW_ROUTE) || (tag == SUMO_TAG_VEHICLE)) {
1608 // get route edges
1609 routeEdges = originalVehicle->getParentDemandElements().back()->getParentEdges();
1610 // get original route color
1611 routeColor = originalVehicle->getParentDemandElements().back()->getColor();
1612 } else if (originalVehicle->getTagProperty().hasEmbeddedRoute()) {
1613 // get embedded route edges
1614 routeEdges = originalVehicle->getChildDemandElements().front()->getParentEdges();
1615 } else if ((tag == SUMO_TAG_TRIP) || (tag == SUMO_TAG_FLOW)) {
1616 // calculate path using from-via-to edges
1617 routeEdges = originalVehicle->getNet()->getPathManager()->getPathCalculator()->calculateDijkstraPath(originalVehicle->getVClass(), originalVehicle->getParentEdges());
1618 }
1619 // declare edge IDs
1620 std::vector<std::string> edgeIDs;
1621 for (const auto& edge : routeEdges) {
1622 edgeIDs.push_back(edge->getID());
1623 }
1624 // only continue if edges are valid
1625 if (routeEdges.empty()) {
1626 // declare header
1627 const std::string header = "Problem transforming to vehicle";
1628 // declare message
1629 const std::string message = "Vehicle cannot be transformed. Invalid number of edges";
1630 // write warning
1631 WRITE_DEBUG("Opened FXMessageBox " + header);
1632 // open message box
1633 FXMessageBox::warning(originalVehicle->getNet()->getViewNet()->getApp(), MBOX_OK, header.c_str(), "%s", message.c_str());
1634 // write warning if netedit is running in testing mode
1635 WRITE_DEBUG("Closed FXMessageBox " + header);
1636 } else {
1637 // begin undo-redo operation
1638 net->getViewNet()->getUndoList()->begin(originalVehicle->getTagProperty().getGUIIcon(), "transform " + originalVehicle->getTagStr() + " to " + toString(SUMO_TAG_VEHICLE));
1639 // first delete vehicle
1640 net->deleteDemandElement(originalVehicle, net->getViewNet()->getUndoList());
1641 // change depart
1642 if ((vehicleParameters.tag == SUMO_TAG_TRIP) || (vehicleParameters.tag == SUMO_TAG_VEHICLE) || (vehicleParameters.tag == GNE_TAG_VEHICLE_WITHROUTE)) {
1643 // get template flow
1645 // set flow parameters
1646 vehicleParameters.repetitionEnd = vehicleParameters.depart + string2time("3600");
1647 vehicleParameters.repetitionNumber = GNEAttributeCarrier::parse<int>(templateFlow->getAttribute(SUMO_ATTR_NUMBER));
1648 vehicleParameters.repetitionOffset = string2time(templateFlow->getAttribute(SUMO_ATTR_PERIOD));
1649 vehicleParameters.repetitionProbability = GNEAttributeCarrier::parse<double>(templateFlow->getAttribute(SUMO_ATTR_PROB));
1650 // by default, number and end enabled
1651 vehicleParameters.parametersSet = GNEAttributeCarrier::parse<int>(templateFlow->getAttribute(GNE_ATTR_FLOWPARAMETERS));
1652 }
1653 // check if new vehicle must have an embedded route
1654 if (createEmbeddedRoute) {
1655 // change tag in vehicle parameters
1656 vehicleParameters.tag = GNE_TAG_FLOW_WITHROUTE;
1657 // create a flow with embebbed routes
1659 CommonXMLStructure::SumoBaseObject* routeBaseOBject = new CommonXMLStructure::SumoBaseObject(vehicleBaseOBject);
1660 // fill parameters
1661 vehicleBaseOBject->setTag(SUMO_TAG_FLOW);
1662 vehicleBaseOBject->addStringAttribute(SUMO_ATTR_ID, vehicleParameters.id);
1663 vehicleBaseOBject->setVehicleParameter(&vehicleParameters);
1664 // build embedded route
1665 routeHandler.buildEmbeddedRoute(routeBaseOBject, edgeIDs, RGBColor::INVISIBLE, false, 0, {});
1666 // delete vehicle base object
1667 delete vehicleBaseOBject;
1668 } else {
1669 // change tag in vehicle parameters
1670 vehicleParameters.tag = GNE_TAG_FLOW_ROUTE;
1671 // generate a new route id
1672 const std::string routeID = net->getAttributeCarriers()->generateDemandElementID(SUMO_TAG_ROUTE);
1673 // build route
1674 routeHandler.buildRoute(nullptr, routeID, vClass, edgeIDs, routeColor, false, 0, {});
1675 // set route ID in vehicle parameters
1676 vehicleParameters.routeid = routeID;
1677 // create vehicle
1678 routeHandler.buildFlowOverRoute(nullptr, vehicleParameters);
1679 }
1680 // end undo-redo operation
1681 net->getViewNet()->getUndoList()->end();
1682 // check if inspect
1683 if (inspectAfterTransform) {
1684 // get created element
1685 auto transformedVehicle = net->getAttributeCarriers()->retrieveDemandElement(vehicleParameters.tag, vehicleParameters.id);
1686 // inspect it
1687 net->getViewNet()->getViewParent()->getInspectorFrame()->inspectSingleElement(transformedVehicle);
1688 }
1689 }
1690}
1691
1692
1693void
1695 // get original vehicle tag
1696 SumoXMLTag tag = originalVehicle->getTagProperty().getTag();
1697 // get pointer to net
1698 GNENet* net = originalVehicle->getNet();
1699 // check if transform after creation
1700 const bool inspectAfterTransform = net->getViewNet()->isAttributeCarrierInspected(originalVehicle);
1701 // declare route handler
1702 GNERouteHandler routeHandler("", net, true, false);
1703 // obtain vehicle parameters
1704 SUMOVehicleParameter vehicleParameters = *originalVehicle;
1705 // get route
1706 GNEDemandElement* route = nullptr;
1707 // declare edges
1708 std::vector<GNEEdge*> edges;
1709 // obtain edges depending of tag
1710 if ((tag == SUMO_TAG_VEHICLE) || (tag == GNE_TAG_FLOW_ROUTE)) {
1711 // set route
1712 route = originalVehicle->getParentDemandElements().back();
1713 // get route edges
1714 edges = route->getParentEdges();
1715 } else if (originalVehicle->getTagProperty().hasEmbeddedRoute()) {
1716 // get embedded route edges
1717 edges = originalVehicle->getChildDemandElements().front()->getParentEdges();
1718 } else if ((tag == SUMO_TAG_TRIP) || (tag == SUMO_TAG_FLOW)) {
1719 // just take parent edges (from and to)
1720 edges = originalVehicle->getParentEdges();
1721 }
1722 // only continue if edges are valid
1723 if (edges.size() < 2) {
1724 // declare header
1725 const std::string header = "Problem transforming to vehicle";
1726 // declare message
1727 const std::string message = "Vehicle cannot be transformed. Invalid number of edges";
1728 // write warning
1729 WRITE_DEBUG("Opened FXMessageBox " + header);
1730 // open message box
1731 FXMessageBox::warning(originalVehicle->getNet()->getViewNet()->getApp(), MBOX_OK, header.c_str(), "%s", message.c_str());
1732 // write warning if netedit is running in testing mode
1733 WRITE_DEBUG("Closed FXMessageBox " + header);
1734 } else {
1735 // begin undo-redo operation
1736 net->getViewNet()->getUndoList()->begin(originalVehicle->getTagProperty().getGUIIcon(), "transform " + originalVehicle->getTagStr() + " to " + toString(SUMO_TAG_TRIP));
1737 // first delete vehicle
1738 net->deleteDemandElement(originalVehicle, net->getViewNet()->getUndoList());
1739 // check if route has to be deleted
1740 if (route && route->getChildDemandElements().empty()) {
1741 net->deleteDemandElement(route, net->getViewNet()->getUndoList());
1742 }
1743 // change tag in vehicle parameters
1744 vehicleParameters.tag = SUMO_TAG_TRIP;
1745 // create trip
1746 routeHandler.buildTrip(nullptr, vehicleParameters, edges.front()->getID(), edges.back()->getID(), {});
1747 // end undo-redo operation
1748 net->getViewNet()->getUndoList()->end();
1749 // check if inspect
1750 if (inspectAfterTransform) {
1751 // get created element
1752 auto transformedVehicle = net->getAttributeCarriers()->retrieveDemandElement(vehicleParameters.tag, vehicleParameters.id);
1753 // inspect it
1754 net->getViewNet()->getViewParent()->getInspectorFrame()->inspectSingleElement(transformedVehicle);
1755 }
1756 }
1757}
1758
1759
1760void
1762 // get original vehicle tag
1763 SumoXMLTag tag = originalVehicle->getTagProperty().getTag();
1764 // get pointer to net
1765 GNENet* net = originalVehicle->getNet();
1766 // check if transform after creation
1767 const bool inspectAfterTransform = net->getViewNet()->isAttributeCarrierInspected(originalVehicle);
1768 // declare route handler
1769 GNERouteHandler routeHandler("", net, true, false);
1770 // obtain vehicle parameters
1771 SUMOVehicleParameter vehicleParameters = *originalVehicle;
1772 // declare route
1773 GNEDemandElement* route = nullptr;
1774 // declare edges
1775 std::vector<GNEEdge*> edges;
1776 // obtain edges depending of tag
1777 if ((tag == SUMO_TAG_VEHICLE) || (tag == GNE_TAG_FLOW_ROUTE)) {
1778 // set route
1779 route = originalVehicle->getParentDemandElements().back();
1780 // get route edges
1781 edges = route->getParentEdges();
1782 } else if (originalVehicle->getTagProperty().hasEmbeddedRoute()) {
1783 // get embedded route edges
1784 edges = originalVehicle->getChildDemandElements().front()->getParentEdges();
1785 } else if ((tag == SUMO_TAG_TRIP) || (tag == SUMO_TAG_FLOW)) {
1786 // just take parent edges (from and to)
1787 edges = originalVehicle->getParentEdges();
1788 }
1789 // only continue if edges are valid
1790 if (edges.empty()) {
1791 // declare header
1792 const std::string header = "Problem transforming to vehicle";
1793 // declare message
1794 const std::string message = "Vehicle cannot be transformed. Invalid number of edges";
1795 // write warning
1796 WRITE_DEBUG("Opened FXMessageBox " + header);
1797 // open message box
1798 FXMessageBox::warning(originalVehicle->getNet()->getViewNet()->getApp(), MBOX_OK, header.c_str(), "%s", message.c_str());
1799 // write warning if netedit is running in testing mode
1800 WRITE_DEBUG("Closed FXMessageBox " + header);
1801 } else {
1802 // begin undo-redo operation
1803 net->getViewNet()->getUndoList()->begin(originalVehicle->getTagProperty().getGUIIcon(), "transform " + originalVehicle->getTagStr() + " to " + toString(SUMO_TAG_VEHICLE));
1804 // first delete vehicle
1805 net->deleteDemandElement(originalVehicle, net->getViewNet()->getUndoList());
1806 // check if route has to be deleted
1807 if (route && route->getChildDemandElements().empty()) {
1808 net->deleteDemandElement(route, net->getViewNet()->getUndoList());
1809 }
1810 // change depart
1811 if ((vehicleParameters.tag == SUMO_TAG_TRIP) || (vehicleParameters.tag == SUMO_TAG_VEHICLE) || (vehicleParameters.tag == GNE_TAG_VEHICLE_WITHROUTE)) {
1812 // get template flow
1814 // set flow parameters
1815 vehicleParameters.repetitionEnd = vehicleParameters.depart + string2time("3600");
1816 vehicleParameters.repetitionNumber = GNEAttributeCarrier::parse<int>(templateFlow->getAttribute(SUMO_ATTR_NUMBER));
1817 vehicleParameters.repetitionOffset = string2time(templateFlow->getAttribute(SUMO_ATTR_PERIOD));
1818 vehicleParameters.repetitionProbability = GNEAttributeCarrier::parse<double>(templateFlow->getAttribute(SUMO_ATTR_PROB));
1819 // by default, number and end enabled
1820 vehicleParameters.parametersSet = GNEAttributeCarrier::parse<int>(templateFlow->getAttribute(GNE_ATTR_FLOWPARAMETERS));
1821 }
1822 // change tag in vehicle parameters
1823 vehicleParameters.tag = SUMO_TAG_FLOW;
1824 // create flow
1825 routeHandler.buildFlow(nullptr, vehicleParameters, edges.front()->getID(), edges.back()->getID(), {});
1826 // end undo-redo operation
1827 net->getViewNet()->getUndoList()->end();
1828 // check if inspect
1829 if (inspectAfterTransform) {
1830 // get created element
1831 auto transformedVehicle = net->getAttributeCarriers()->retrieveDemandElement(vehicleParameters.tag, vehicleParameters.id);
1832 // inspect it
1833 net->getViewNet()->getViewParent()->getInspectorFrame()->inspectSingleElement(transformedVehicle);
1834 }
1835 }
1836}
1837
1838
1839void
1841 // get pointer to net
1842 GNENet* net = originalPerson->getNet();
1843 // check if transform after creation
1844 const bool inspectAfterTransform = net->getViewNet()->isAttributeCarrierInspected(originalPerson);
1845 // declare route handler
1846 GNERouteHandler routeHandler("", net, true, false);
1847 // obtain person parameters
1848 SUMOVehicleParameter personParameters = *originalPerson;
1849 // get person plans
1850 const auto personPlans = originalPerson->getChildDemandElements();
1851 // save ID
1852 const auto ID = personParameters.id;
1853 // set dummy ID
1854 personParameters.id = "%dummyID%";
1855 // begin undo-redo operation
1856 net->getViewNet()->getUndoList()->begin(originalPerson->getTagProperty().getGUIIcon(), "transform " + originalPerson->getTagStr() + " to " + toString(SUMO_TAG_PERSON));
1857 // create personFlow
1858 routeHandler.buildPerson(nullptr, personParameters);
1859 // move all person plans to new person
1860 for (const auto& personPlan : personPlans) {
1861 personPlan->setAttribute(GNE_ATTR_PARENT, "%dummyID%", net->getViewNet()->getUndoList());
1862 }
1863 // delete original person plan
1864 net->deleteDemandElement(originalPerson, net->getViewNet()->getUndoList());
1865 // restore ID of new person plan
1866 auto newPerson = net->getAttributeCarriers()->retrieveDemandElement(SUMO_TAG_PERSON, "%dummyID%");
1867 newPerson->setAttribute(SUMO_ATTR_ID, ID, net->getViewNet()->getUndoList());
1868 // finish undoList
1869 net->getViewNet()->getUndoList()->end();
1870 // check if inspect
1871 if (inspectAfterTransform) {
1872 // get created element
1873 auto transformedPerson = net->getAttributeCarriers()->retrieveDemandElement(personParameters.tag, personParameters.id);
1874 // inspect it
1875 net->getViewNet()->getViewParent()->getInspectorFrame()->inspectSingleElement(transformedPerson);
1876 }
1877}
1878
1879
1880void
1882 // get pointer to net
1883 GNENet* net = originalPerson->getNet();
1884 // check if transform after creation
1885 const bool inspectAfterTransform = net->getViewNet()->isAttributeCarrierInspected(originalPerson);
1886 // declare route handler
1887 GNERouteHandler routeHandler("", net, true, false);
1888 // obtain person parameters
1889 SUMOVehicleParameter personParameters = *originalPerson;
1890 // get person plans
1891 const auto personPlans = originalPerson->getChildDemandElements();
1892 // save ID
1893 const auto ID = personParameters.id;
1894 // set dummy ID
1895 personParameters.id = "%dummyID%";
1896 // begin undo-redo operation
1897 net->getViewNet()->getUndoList()->begin(originalPerson->getTagProperty().getGUIIcon(), "transform " + originalPerson->getTagStr() + " to " + toString(SUMO_TAG_PERSONFLOW));
1898 // create personFlow
1899 routeHandler.buildPersonFlow(nullptr, personParameters);
1900 // move all person plans to new person
1901 for (const auto& personPlan : personPlans) {
1902 personPlan->setAttribute(GNE_ATTR_PARENT, "%dummyID%", net->getViewNet()->getUndoList());
1903 }
1904 // delete original person plan
1905 net->deleteDemandElement(originalPerson, net->getViewNet()->getUndoList());
1906 // restore ID of new person plan
1907 auto newPerson = net->getAttributeCarriers()->retrieveDemandElement(SUMO_TAG_PERSONFLOW, "%dummyID%");
1908 newPerson->setAttribute(SUMO_ATTR_ID, ID, net->getViewNet()->getUndoList());
1909 // enable attributes
1910 newPerson->enableAttribute(SUMO_ATTR_END, net->getViewNet()->getUndoList());
1911 newPerson->enableAttribute(SUMO_ATTR_PERSONSPERHOUR, net->getViewNet()->getUndoList());
1912 // finish undoList
1913 net->getViewNet()->getUndoList()->end();
1914 // check if inspect
1915 if (inspectAfterTransform) {
1916 // get created element
1917 auto transformedPerson = net->getAttributeCarriers()->retrieveDemandElement(personParameters.tag, personParameters.id);
1918 // inspect it
1919 net->getViewNet()->getViewParent()->getInspectorFrame()->inspectSingleElement(transformedPerson);
1920 }
1921}
1922
1923
1924void
1926 // get pointer to net
1927 GNENet* net = originalContainer->getNet();
1928 // check if transform after creation
1929 const bool inspectAfterTransform = net->getViewNet()->isAttributeCarrierInspected(originalContainer);
1930 // declare route handler
1931 GNERouteHandler routeHandler("", net, true, false);
1932 // obtain container parameters
1933 SUMOVehicleParameter containerParameters = *originalContainer;
1934 // get container plans
1935 const auto containerPlans = originalContainer->getChildDemandElements();
1936 // save ID
1937 const auto ID = containerParameters.id;
1938 // set dummy ID
1939 containerParameters.id = "%dummyID%";
1940 // begin undo-redo operation
1941 net->getViewNet()->getUndoList()->begin(originalContainer->getTagProperty().getGUIIcon(), "transform " + originalContainer->getTagStr() + " to " + toString(SUMO_TAG_CONTAINER));
1942 // create containerFlow
1943 routeHandler.buildContainer(nullptr, containerParameters);
1944 // move all container plans to new container
1945 for (const auto& containerPlan : containerPlans) {
1946 containerPlan->setAttribute(GNE_ATTR_PARENT, "%dummyID%", net->getViewNet()->getUndoList());
1947 }
1948 // delete original container plan
1949 net->deleteDemandElement(originalContainer, net->getViewNet()->getUndoList());
1950 // restore ID of new container plan
1951 auto newContainer = net->getAttributeCarriers()->retrieveDemandElement(SUMO_TAG_CONTAINER, "%dummyID%");
1952 newContainer->setAttribute(SUMO_ATTR_ID, ID, net->getViewNet()->getUndoList());
1953 // finish undoList
1954 net->getViewNet()->getUndoList()->end();
1955 // check if inspect
1956 if (inspectAfterTransform) {
1957 // get created element
1958 auto transformedContainer = net->getAttributeCarriers()->retrieveDemandElement(containerParameters.tag, containerParameters.id);
1959 // inspect it
1960 net->getViewNet()->getViewParent()->getInspectorFrame()->inspectSingleElement(transformedContainer);
1961 }
1962}
1963
1964
1965void
1967 // get pointer to net
1968 GNENet* net = originalContainer->getNet();
1969 // check if transform after creation
1970 const bool inspectAfterTransform = net->getViewNet()->isAttributeCarrierInspected(originalContainer);
1971 // declare route handler
1972 GNERouteHandler routeHandler("", net, true, false);
1973 // obtain container parameters
1974 SUMOVehicleParameter containerParameters = *originalContainer;
1975 // get container plans
1976 const auto containerPlans = originalContainer->getChildDemandElements();
1977 // save ID
1978 const auto ID = containerParameters.id;
1979 // set dummy ID
1980 containerParameters.id = "%dummyID%";
1981 // begin undo-redo operation
1982 net->getViewNet()->getUndoList()->begin(originalContainer->getTagProperty().getGUIIcon(), "transform " + originalContainer->getTagStr() + " to " + toString(SUMO_TAG_CONTAINERFLOW));
1983 // create containerFlow
1984 routeHandler.buildContainerFlow(nullptr, containerParameters);
1985 // move all container plans to new container
1986 for (const auto& containerPlan : containerPlans) {
1987 containerPlan->setAttribute(GNE_ATTR_PARENT, "%dummyID%", net->getViewNet()->getUndoList());
1988 }
1989 // delete original container plan
1990 net->deleteDemandElement(originalContainer, net->getViewNet()->getUndoList());
1991 // restore ID of new container plan
1992 auto newContainer = net->getAttributeCarriers()->retrieveDemandElement(SUMO_TAG_CONTAINERFLOW, "%dummyID%");
1993 newContainer->setAttribute(SUMO_ATTR_ID, ID, net->getViewNet()->getUndoList());
1994 // enable attributes
1995 newContainer->enableAttribute(SUMO_ATTR_END, net->getViewNet()->getUndoList());
1996 newContainer->enableAttribute(SUMO_ATTR_CONTAINERSPERHOUR, net->getViewNet()->getUndoList());
1997 // finish undoList
1998 net->getViewNet()->getUndoList()->end();
1999 // check if inspect
2000 if (inspectAfterTransform) {
2001 // get created element
2002 auto transformedContainer = net->getAttributeCarriers()->retrieveDemandElement(containerParameters.tag, containerParameters.id);
2003 // inspect it
2004 net->getViewNet()->getViewParent()->getInspectorFrame()->inspectSingleElement(transformedContainer);
2005 }
2006}
2007
2008// ===========================================================================
2009// protected
2010// ===========================================================================
2011
2013GNERouteHandler::parseJunction(const SumoXMLTag tag, const std::string& junctionID) {
2014 GNEJunction* junction = myNet->getAttributeCarriers()->retrieveJunction(junctionID, false);
2015 // empty junctions aren't allowed. If junction is empty, write error, clear junctions and stop
2016 if (junction == nullptr) {
2017 writeError("Could not build " + toString(tag) + " in netedit; " + toString(SUMO_TAG_JUNCTION) + " doesn't exist.");
2018 }
2019 return junction;
2020}
2021
2022
2023GNEEdge*
2024GNERouteHandler::parseEdge(const SumoXMLTag tag, const std::string& edgeID) {
2025 GNEEdge* edge = myNet->getAttributeCarriers()->retrieveEdge(edgeID, false);
2026 // empty edges aren't allowed. If edge is empty, write error, clear edges and stop
2027 if (edge == nullptr) {
2028 writeError("Could not build " + toString(tag) + " in netedit; " + toString(SUMO_TAG_EDGE) + " doesn't exist.");
2029 }
2030 return edge;
2031}
2032
2033
2034std::vector<GNEEdge*>
2035GNERouteHandler::parseEdges(const SumoXMLTag tag, const std::vector<std::string>& edgeIDs) {
2036 std::vector<GNEEdge*> edges;
2037 for (const auto& edgeID : edgeIDs) {
2038 GNEEdge* edge = myNet->getAttributeCarriers()->retrieveEdge(edgeID, false);
2039 // empty edges aren't allowed. If edge is empty, write error, clear edges and stop
2040 if (edge == nullptr) {
2041 writeError("Could not build " + toString(tag) + " in netedit; " + toString(SUMO_TAG_EDGE) + " doesn't exist.");
2042 edges.clear();
2043 return edges;
2044 } else {
2045 edges.push_back(edge);
2046 }
2047 }
2048 return edges;
2049}
2050
2051
2054 // check that sumoBaseObject has parent
2055 if (sumoBaseObject->getParentSumoBaseObject() == nullptr) {
2056 return nullptr;
2057 }
2058 if ((sumoBaseObject->getParentSumoBaseObject()->getTag() != SUMO_TAG_PERSON) &&
2059 (sumoBaseObject->getParentSumoBaseObject()->getTag() != SUMO_TAG_PERSONFLOW)) {
2060 return nullptr;
2061 }
2062 // try it with person
2064 // if empty, try it with personFlow
2065 if (personParent == nullptr) {
2067 } else {
2068 return personParent;
2069 }
2070}
2071
2072
2075 // check that sumoBaseObject has parent
2076 if (sumoBaseObject->getParentSumoBaseObject() == nullptr) {
2077 return nullptr;
2078 }
2079 if ((sumoBaseObject->getParentSumoBaseObject()->getTag() != SUMO_TAG_CONTAINER) &&
2080 (sumoBaseObject->getParentSumoBaseObject()->getTag() != SUMO_TAG_CONTAINERFLOW)) {
2081 return nullptr;
2082 }
2083 // try it with container
2085 // if empty, try it with containerFlow
2086 if (containerParent == nullptr) {
2088 } else {
2089 return containerParent;
2090 }
2091}
2092
2093
2094GNEEdge*
2096 if (obj->getParentSumoBaseObject() == nullptr) {
2097 // no parent defined
2098 return nullptr;
2099 }
2100 // get parent object
2102 // check person/container conditions
2103 if (person && (parentObject->getTag() != SUMO_TAG_PERSON) && (parentObject->getTag() != SUMO_TAG_PERSONFLOW)) {
2104 // invalid parent
2105 return nullptr;
2106 }
2107 if (!person && (parentObject->getTag() != SUMO_TAG_CONTAINER) && (parentObject->getTag() != SUMO_TAG_CONTAINERFLOW)) {
2108 // invalid parent
2109 return nullptr;
2110 }
2111 // search previous child
2112 const auto it = std::find(parentObject->getSumoBaseObjectChildren().begin(), parentObject->getSumoBaseObjectChildren().end(), obj);
2113 if (it == parentObject->getSumoBaseObjectChildren().begin()) {
2114 return nullptr;
2115 }
2116 // get last children
2117 const CommonXMLStructure::SumoBaseObject* previousPlan = *(it - 1);
2118 // check conditions
2119 if (person && (previousPlan->getTag() != SUMO_TAG_WALK) && (previousPlan->getTag() != SUMO_TAG_RIDE) &&
2120 (previousPlan->getTag() != SUMO_TAG_PERSONTRIP) && (previousPlan->getTag() != SUMO_TAG_STOP)) {
2121 // invalid last child
2122 return nullptr;
2123 }
2124 if (!person && (previousPlan->getTag() != SUMO_TAG_TRANSPORT) && (previousPlan->getTag() != SUMO_TAG_TRANSHIP)) {
2125 // invalid last child
2126 return nullptr;
2127 }
2128 // ends in an edge (only for stops)
2129 if (previousPlan->hasStringAttribute(SUMO_ATTR_EDGE)) {
2131 }
2132 // ends in a lane (only for stops)
2133 if (previousPlan->hasStringAttribute(SUMO_ATTR_LANE)) {
2134 const auto lane = myNet->getAttributeCarriers()->retrieveLane(previousPlan->getStringAttribute(SUMO_ATTR_LANE), false);
2135 if (lane) {
2136 return lane->getParentEdge();
2137 } else {
2138 return nullptr;
2139 }
2140 }
2141 // ends in a route (walk)
2142 if (previousPlan->hasStringAttribute(SUMO_ATTR_ROUTE) &&
2143 !previousPlan->getStringAttribute(SUMO_ATTR_ROUTE).empty()) {
2145 if (route) {
2146 return route->getParentEdges().back();
2147 } else {
2148 return nullptr;
2149 }
2150 }
2151 // ends in a list of edges (walk)
2152 if (previousPlan->hasStringListAttribute(SUMO_ATTR_EDGES) &&
2153 !previousPlan->getStringListAttribute(SUMO_ATTR_EDGES).empty()) {
2154 return myNet->getAttributeCarriers()->retrieveEdge(previousPlan->getStringListAttribute(SUMO_ATTR_EDGES).back(), false);
2155 }
2156 // ends in a "to" edge
2157 if (previousPlan->hasStringAttribute(SUMO_ATTR_TO) &&
2158 !previousPlan->getStringAttribute(SUMO_ATTR_TO).empty()) {
2159 return myNet->getAttributeCarriers()->retrieveEdge(previousPlan->getStringAttribute(SUMO_ATTR_TO), false);
2160 }
2161 // ends in a "busStop"
2162 if (previousPlan->hasStringAttribute(SUMO_ATTR_BUS_STOP) &&
2163 !previousPlan->getStringAttribute(SUMO_ATTR_BUS_STOP).empty()) {
2165 if (busStop) {
2166 return busStop->getParentLanes().front()->getParentEdge();
2167 } else {
2168 return nullptr;
2169 }
2170 }
2171 // ends in a "containerStop"
2172 if (previousPlan->hasStringAttribute(SUMO_ATTR_CONTAINER_STOP) &&
2173 !previousPlan->getStringAttribute(SUMO_ATTR_CONTAINER_STOP).empty()) {
2175 if (containerStop) {
2176 return containerStop->getParentLanes().front()->getParentEdge();
2177 } else {
2178 return nullptr;
2179 }
2180 }
2181 return nullptr;
2182}
2183
2184
2187 if (obj->getParentSumoBaseObject() == nullptr) {
2188 // no parent defined
2189 return nullptr;
2190 }
2191 // get parent object
2193 // search previous child
2194 const auto it = std::find(parentObject->getSumoBaseObjectChildren().begin(), parentObject->getSumoBaseObjectChildren().end(), obj);
2195 if (it == parentObject->getSumoBaseObjectChildren().begin()) {
2196 return nullptr;
2197 }
2198 // get last child
2199 const CommonXMLStructure::SumoBaseObject* previousPersonPlan = *(it - 1);
2200 // ends in an junction (only for stops)
2201 if (previousPersonPlan->hasStringAttribute(SUMO_ATTR_TOJUNCTION)) {
2203 }
2204 return nullptr;
2205}
2206
2207
2208bool
2210 // retrieve demand element
2211 auto demandElement = myNet->getAttributeCarriers()->retrieveDemandElement(tag, id, false);
2212 // if demand exist, check if overwrite (delete)
2213 if (demandElement) {
2214 if (myAllowUndoRedo == false) {
2215 // only overwrite if allow undo-redo
2216 return false;
2217 } else if (myOverwrite) {
2218 // update demand to overwrite
2219 myDemandToOverwrite = demandElement;
2220 return true;
2221 } else {
2222 // duplicated demand
2223 return false;
2224 }
2225 } else {
2226 // demand with these id doesn't exist, then all ok
2227 return true;
2228 }
2229}
2230
2231
2232void
2234 if (myDemandToOverwrite) {
2235 // remove element
2237 // reset pointer
2238 myDemandToOverwrite = nullptr;
2239 }
2240}
2241
2242/****************************************************************************/
long long int SUMOTime
Definition: GUI.h:36
@ CONTAINERFLOW
@ VTYPEDISTRIBUTION
#define WRITE_DEBUG(msg)
Definition: MsgHandler.h:276
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition: SUMOTime.cpp:45
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
const std::set< std::string > DEFAULT_VTYPES
const int STOP_DURATION_SET
@ GIVEN
The lane is given.
const int STOP_SPEED_SET
const int STOP_UNTIL_SET
@ GIVEN
The speed is given.
const int VEHPARS_DEPARTLANE_SET
const int STOP_END_SET
const int VEHPARS_DEPARTSPEED_SET
SumoXMLTag
Numbers representing SUMO-XML - element names.
@ GNE_TAG_TRIP_JUNCTIONS
a trip between junctions (used in NETEDIT)
@ SUMO_TAG_STOP_CONTAINERSTOP
stop placed over a containerStop (used in netedit)
@ GNE_TAG_PERSONTRIP_JUNCTIONS
@ GNE_TAG_WAYPOINT_PARKINGAREA
waypoint placed over a parking area (used in netedit)
@ GNE_TAG_TRANSPORT_CONTAINERSTOP
@ SUMO_TAG_CHARGING_STATION
A Charging Station.
@ SUMO_TAG_VTYPE
description of a vehicle/person/container type
@ SUMO_TAG_WALK
@ GNE_TAG_PERSONTRIP_BUSSTOP
@ SUMO_TAG_NOTHING
invalid tag
@ SUMO_TAG_TRANSHIP
@ GNE_TAG_WALK_EDGES
@ SUMO_TAG_CONTAINER_STOP
A container stop.
@ SUMO_TAG_CONTAINERFLOW
@ SUMO_TAG_STOP_CHARGINGSTATION
stop placed over a charging station (used in netedit)
@ SUMO_TAG_STOP_LANE
stop placed over a lane (used in netedit)
@ GNE_TAG_WAYPOINT_CONTAINERSTOP
waypoint placed over a containerStop (used in netedit)
@ GNE_TAG_STOPCONTAINER_EDGE
@ GNE_TAG_WAYPOINT_BUSSTOP
waypoint placed over a busStop (used in netedit)
@ SUMO_TAG_BUS_STOP
A bus stop.
@ GNE_TAG_WAYPOINT_CHARGINGSTATION
waypoint placed over a charging station (used in netedit)
@ GNE_TAG_STOPPERSON_BUSSTOP
@ SUMO_TAG_STOP
stop for vehicles
@ SUMO_TAG_VEHICLE
description of a vehicle
@ GNE_TAG_FLOW_ROUTE
a flow definition using a route instead of a from-to edges route (used in NETEDIT)
@ GNE_TAG_FLOW_JUNCTIONS
a flow between junctions (used in NETEDIT)
@ GNE_TAG_TRANSHIP_EDGES
@ GNE_TAG_STOPCONTAINER_CONTAINERSTOP
@ GNE_TAG_FLOW_WITHROUTE
description of a vehicle with an embedded route (used in NETEDIT)
@ SUMO_TAG_FLOW
a flow definitio nusing a from-to edges instead of a route (used by router)
@ SUMO_TAG_PARKING_AREA
A parking area.
@ SUMO_TAG_TRANSPORT
@ SUMO_TAG_CONTAINER
@ SUMO_TAG_JUNCTION
begin/end of the description of a junction
@ GNE_TAG_WALK_BUSSTOP
@ SUMO_TAG_ROUTE
begin/end of the description of a route
@ SUMO_TAG_RIDE
@ GNE_TAG_RIDE_EDGE
@ SUMO_TAG_STOP_BUSSTOP
stop placed over a busStop (used in netedit)
@ SUMO_TAG_VTYPE_DISTRIBUTION
distribution of a vehicle type
@ GNE_TAG_TRANSHIP_EDGE
@ GNE_TAG_WALK_JUNCTIONS
@ GNE_TAG_VEHICLE_WITHROUTE
description of a vehicle with an embedded route (used in NETEDIT)
@ GNE_TAG_WAYPOINT_LANE
waypoint placed over a lane (used in netedit)
@ SUMO_TAG_PERSON
@ SUMO_TAG_PERSONTRIP
@ SUMO_TAG_STOP_PARKINGAREA
stop placed over a parking area (used in netedit)
@ GNE_TAG_WALK_EDGE
@ GNE_TAG_PERSONTRIP_EDGE
@ GNE_TAG_RIDE_BUSSTOP
@ GNE_TAG_STOPPERSON_EDGE
@ GNE_TAG_WALK_ROUTE
@ SUMO_TAG_PERSONFLOW
@ SUMO_TAG_TRIP
a single trip definition (used by router)
@ GNE_TAG_TRANSHIP_CONTAINERSTOP
@ SUMO_TAG_EDGE
begin/end of the description of an edge
@ GNE_TAG_TRANSPORT_EDGE
@ SUMO_ATTR_LINES
@ SUMO_ATTR_NUMBER
@ SUMO_ATTR_LANE
@ SUMO_ATTR_SPEED
@ SUMO_ATTR_CONTAINER_STOP
@ SUMO_ATTR_EDGE
@ SUMO_ATTR_BUS_STOP
@ GNE_ATTR_FLOWPARAMETERS
flow parameters (integer for mask end, number, etc...)
@ GNE_ATTR_PARENT
parent of an additional element
@ SUMO_ATTR_ARRIVALPOS
@ SUMO_ATTR_ACTTYPE
@ GNE_ATTR_VTYPE_DISTRIBUTION
vehicle type distribution
@ SUMO_ATTR_EDGES
the edges of a route
@ SUMO_ATTR_CONTAINERSPERHOUR
@ SUMO_ATTR_MODES
@ SUMO_ATTR_VTYPES
@ SUMO_ATTR_DEPARTPOS
@ SUMO_ATTR_PERIOD
@ SUMO_ATTR_DEPARTSPEED
@ SUMO_ATTR_TO
@ SUMO_ATTR_FROM
@ SUMO_ATTR_END
weights: time range end
@ SUMO_ATTR_DEPARTLANE
@ SUMO_ATTR_PROB
@ SUMO_ATTR_ROUTE
@ SUMO_ATTR_MAXSPEED
@ SUMO_ATTR_ID
@ SUMO_ATTR_UNTIL
@ SUMO_ATTR_DURATION
@ SUMO_ATTR_TOJUNCTION
@ SUMO_ATTR_PERSONSPERHOUR
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
bool around(const Position &p, double offset=0) const
Returns whether the AbstractPoly the given coordinate.
Definition: Boundary.cpp:172
const SUMOVehicleParameter::Stop & getStopParameter() const
get stop parameters
SUMOTime getTimeAttribute(const SumoXMLAttr attr) const
get time attribute
bool hasStringAttribute(const SumoXMLAttr attr) const
has function
void setTag(const SumoXMLTag tag)
set SumoBaseObject tag
SumoBaseObject * getParentSumoBaseObject() const
get pointer to mySumoBaseObjectParent SumoBaseObject (if is null, then is the root)
bool hasTimeAttribute(const SumoXMLAttr attr) const
check if current SumoBaseObject has the given time attribute
bool hasDoubleAttribute(const SumoXMLAttr attr) const
check if current SumoBaseObject has the given double attribute
void setVehicleParameter(const SUMOVehicleParameter *vehicleParameter)
set vehicle parameters
void addStringAttribute(const SumoXMLAttr attr, const std::string &value)
double getDoubleAttribute(const SumoXMLAttr attr) const
get double attribute
const SUMOVehicleParameter & getVehicleParameter() const
get vehicle parameters
const std::vector< std::string > & getStringListAttribute(const SumoXMLAttr attr) const
get string list attribute
bool hasStringListAttribute(const SumoXMLAttr attr) const
check if current SumoBaseObject has the given string list attribute
void clear()
clear SumoBaseObject
const std::string & getStringAttribute(const SumoXMLAttr attr) const
get string attribute
const std::vector< SumoBaseObject * > & getSumoBaseObjectChildren() const
get SumoBaseObject children
An Element which don't belong to GNENet but has influence in the simulation.
Definition: GNEAdditional.h:48
const std::string getID() const
get ID (all Attribute Carriers have one)
const std::string & getTagStr() const
get tag assigned to this object in string format
const GNETagProperties & getTagProperty() const
get tagProperty associated with this Attribute Carrier
GNENet * getNet() const
get pointer to net
void getAttributesAndValues(CommonXMLStructure::SumoBaseObject *baseObject, bool includeAll) const
get attributes and their values
An Element which don't belong to GNENet but has influence in the simulation.
virtual double getAttributeDouble(SumoXMLAttr key) const =0
virtual void computePathElement()=0
compute pathElement
virtual void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)=0
method for setting the attribute and letting the object perform demand element changes
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:53
const std::vector< GNELane * > & getLanes() const
returns a reference to the lane vector
Definition: GNEEdge.cpp:839
void addChildElement(T *element)
add child element
const std::vector< GNEDemandElement * > & getChildDemandElements() const
return child demand elements
const std::vector< GNEDemandElement * > & getParentDemandElements() const
get parent demand elements
const std::vector< GNEEdge * > & getParentEdges() const
get parent edges
const std::vector< GNELane * > & getParentLanes() const
get parent lanes
void inspectSingleElement(GNEAttributeCarrier *AC)
Inspect a single element.
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:46
GNEEdge * getParentEdge() const
get parent edge
Definition: GNELane.cpp:124
GNELane * retrieveLane(const std::string &id, bool hardFail=true, bool checkVolatileChange=false) const
get lane by id
std::string generateDemandElementID(SumoXMLTag tag) const
generate demand element id
GNEAdditional * retrieveAdditional(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named additional.
GNEJunction * retrieveJunction(const std::string &id, bool hardFail=true) const
get junction by id
void insertDemandElement(GNEDemandElement *demandElement)
Insert a demand element element int GNENet container.
GNEEdge * retrieveEdge(const std::string &id, bool hardFail=true) const
get edge by id
GNEDemandElement * retrieveDemandElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named demand element.
A NBNetBuilder extended by visualisation and editing capabilities.
Definition: GNENet.h:42
void deleteDemandElement(GNEDemandElement *demandElement, GNEUndoList *undoList)
remove demand element
Definition: GNENet.cpp:650
GNENetHelper::AttributeCarriers * getAttributeCarriers() const
get all attribute carriers used in this net
Definition: GNENet.cpp:132
GNEPathManager * getPathManager()
get path manager
Definition: GNENet.cpp:138
GNEViewNet * getViewNet() const
get view net
Definition: GNENet.cpp:1987
GNEAdditional * getToStoppingPlace(SumoXMLTag expectedTag) const
get to stoppingPlace
const std::vector< GNEJunction * > & getSelectedJunctions() const
get current selected junctions
const std::vector< GNEEdge * > & getSelectedEdges() const
get current selected edges
GNEDemandElement * getRoute() const
get route
const std::vector< Path > & getPath() const
get path route
std::vector< GNEEdge * > calculateDijkstraPath(const SUMOVehicleClass vClass, const std::vector< GNEEdge * > &partialEdges) const
calculate Dijkstra path between a list of partial edges
PathCalculator * getPathCalculator()
obtain instance of PathCalculator
void incRef(const std::string &debugMsg="")
Increase reference.
Builds trigger objects for GNENet (busStops, chargingStations, detectors, etc..)
bool isContainerIdDuplicated(const std::string &id)
check if there is already a container (Container or ContainerFlow) with the given ID
const bool myOverwrite
check if overwrite
bool isVehicleIdDuplicated(const std::string &id)
check if there is already a vehicle (Vehicle, Trip, Flow or Flow) with the given ID
void buildContainerFlow(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &containerFlowParameters)
build container flow
void buildRouteDistribution(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id)
build route distribution
bool checkDuplicatedDemandElement(const SumoXMLTag tag, const std::string &id)
check if given ID correspond to a duplicated demand element
CommonXMLStructure::SumoBaseObject * myPlanObject
pointer for person and container plans
GNEDemandElement * getPersonParent(const CommonXMLStructure::SumoBaseObject *sumoBaseObject) const
get person parent
GNEJunction * parseJunction(const SumoXMLTag tag, const std::string &junctionID)
parse junction
const bool myAllowUndoRedo
allow undo/redo
GNEEdge * getPreviousPlanEdge(const bool person, const CommonXMLStructure::SumoBaseObject *obj) const
get previos person/container plan edge
void overwriteDemandElement()
remove overwrited demand element
void buildPerson(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &personParameters)
build person
static void transformToRouteFlow(GNEVehicle *originalVehicle, bool createEmbeddedRoute)
transform routeFlow over an existent route
void buildFlow(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &vehicleParameters, const std::string &fromEdgeID, const std::string &toEdgeID, const std::vector< std::string > &viaIDs)
build flow
GNENet * myNet
pointer to GNENet
void buildWalk(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &fromEdgeID, const std::string &toEdgeID, const std::string &fromJunctionID, const std::string &toJunctionID, const std::string &toBusStopID, const std::vector< std::string > &edgeIDs, const std::string &routeID, double arrivalPos)
build walk
bool isPersonIdDuplicated(const std::string &id)
check if there is already a person (Person or PersonFlow) with the given ID
void buildTrip(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &vehicleParameters, const std::string &fromEdgeID, const std::string &toEdgeID, const std::vector< std::string > &viaIDs)
build trip
static void transformToContainerFlow(GNEContainer *originalContainer)
transform routeFlow over an existent route
void buildVehicleOverRoute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &vehicleParameters)
build a vehicle over an existent route
void buildTransport(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &fromEdgeID, const std::string &toEdgeID, const std::string &toBusStopID, const std::vector< std::string > &lines, const double arrivalPos)
build transport
static void transformToFlow(GNEVehicle *originalVehicle)
transform to flow
GNEEdge * parseEdge(const SumoXMLTag tag, const std::string &edgeID)
parse edge
void buildFlowOverRoute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &vehicleParameters)
build a flow over an existent route
GNEJunction * getPreviousPlanJunction(const bool person, const CommonXMLStructure::SumoBaseObject *obj) const
get previos person/container plan junction
void buildRoute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, SUMOVehicleClass vClass, const std::vector< std::string > &edgeIDs, const RGBColor &color, const int repeat, const SUMOTime cycleTime, const Parameterised::Map &routeParameters)
build route
void buildPersonTrip(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &fromEdgeID, const std::string &toEdgeID, const std::string &fromJunctionID, const std::string &toJunctionID, const std::string &toBusStopID, double arrivalPos, const std::vector< std::string > &types, const std::vector< std::string > &modes, const std::vector< std::string > &lines)
build person trip
void buildVType(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVTypeParameter &vTypeParameter)
build vType
bool buildPersonPlan(SumoXMLTag tag, GNEDemandElement *personParent, GNEAttributesCreator *personPlanAttributes, GNEPathCreator *pathCreator, const bool centerAfterCreation)
build person plan
void buildTranship(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &fromEdgeID, const std::string &toEdgeID, const std::string &toBusStopID, const std::vector< std::string > &edgeIDs, const double speed, const double departPosition, const double arrivalPosition)
build tranship
static void transformToTrip(GNEVehicle *originalVehicle)
transform to trip
bool buildContainerPlan(SumoXMLTag tag, GNEDemandElement *containerParent, GNEAttributesCreator *containerPlanAttributes, GNEPathCreator *pathCreator, const bool centerAfterCreation)
build container plan
static void transformToPerson(GNEPerson *originalPerson)
transform person functions
virtual ~GNERouteHandler()
Destructor.
void buildRide(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &fromEdgeID, const std::string &toEdgeID, const std::string &toBusStopID, double arrivalPos, const std::vector< std::string > &lines)
build ride
void buildEmbeddedRoute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::vector< std::string > &edgeIDs, const RGBColor &color, const int repeat, const SUMOTime cycleTime, const Parameterised::Map &routeParameters)
build embedded route
void buildPersonFlow(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &personFlowParameters)
build person flow
std::vector< GNEEdge * > parseEdges(const SumoXMLTag tag, const std::vector< std::string > &edgeIDs)
parse edges
GNEDemandElement * getContainerParent(const CommonXMLStructure::SumoBaseObject *sumoBaseObject) const
get container parent
void buildStop(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter::Stop &stopParameters)
build stop
static void transformToContainer(GNEContainer *originalContainer)
transform container functions
void buildContainer(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &containerParameters)
build container
static void transformToPersonFlow(GNEPerson *originalPerson)
transform routeFlow over an existent route
GNEDemandElement * myDemandToOverwrite
demand to overwrite (using undor-redo
void buildVTypeDistribution(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const int deterministic, const std::vector< std::string > &vTypes)
build vType distribution
GNERouteHandler(const std::string &file, GNENet *net, const bool allowUndoRedo, const bool overwrite)
Constructor.
static void transformToVehicle(GNEVehicle *originalVehicle, bool createEmbeddedRoute)
transform vehicle functions
bool isContainer() const
return true if tag correspond to a container element
bool hasEmbeddedRoute() const
return true if tag correspond to an element that owns an embedded route
bool isVehicle() const
return true if tag correspond to a vehicle element
GUIIcon getGUIIcon() const
get GUI icon associated to this Tag
SumoXMLTag getTag() const
get Tag vinculated with this attribute Property
bool isPerson() const
return true if tag correspond to a person element
GNEAttributeCarrier * getTemplateAC(SumoXMLTag ACTag) const
get templateAC
void end()
End undo command sub-group. If the sub-group is still empty, it will be deleted; otherwise,...
void begin(GUIIcon icon, const std::string &description)
Begin undo command sub-group with current supermode. This begins a new group of commands that are tre...
void add(GNEChange *command, bool doit=false, bool merge=true)
Add new command, executing it if desired. The new command will be merged with the previous command if...
static void overwriteVType(GNEDemandElement *vType, const SUMOVTypeParameter newVTypeParameter, GNEUndoList *undoList)
overwrite all values of GNEVType with a SUMOVTypeParameter
Definition: GNEVType.cpp:957
GNETagSelector * getVehicleTagSelector() const
get vehicle tag selector (needed for transform vehicles)
SUMOVehicleClass getVClass() const
Definition: GNEVehicle.cpp:592
GNEViewParent * getViewParent() const
get the net object
GNEUndoList * getUndoList() const
get the undoList object
bool isAttributeCarrierInspected(const GNEAttributeCarrier *AC) const
check if attribute carrier is being inspected
void setStatusBarText(const std::string &text)
set statusBar text
Definition: GNEViewNet.cpp:768
GNEVehicleFrame * getVehicleFrame() const
get frame for DEMAND_VEHICLE
GNEInspectorFrame * getInspectorFrame() const
get frame for inspect elements
Boundary getVisibleBoundary() const
get visible boundary
virtual void centerTo(GUIGlID id, bool applyZoom, double zoomDist=20)
centers to the chosen artifact
virtual Position getPositionInformation() const
Returns the cursor's x/y position within the network.
std::map< std::string, std::string > Map
parameters map
Definition: Parameterised.h:45
static const RGBColor YELLOW
Definition: RGBColor.h:188
static const RGBColor INVISIBLE
Definition: RGBColor.h:195
void writeError(const std::string &error)
write error and enable error creating element
Structure representing possible vehicle parameter.
std::string id
The vehicle type's id.
Definition of vehicle stop (position and duration)
std::string edge
The edge to stop at (used only in NETEDIT)
std::string lane
The lane to stop at.
double speed
the speed at which this stop counts as reached (waypoint mode)
std::string parkingarea
(Optional) parking area if one is assigned to the stop
std::string chargingStation
(Optional) charging station if one is assigned to the stop
int parametersSet
Information for the output which parameter were set.
SUMOTime until
The time at which the vehicle may continue its journey.
std::string actType
act Type (only used by Persons) (used by NETEDIT)
double endPos
The stopping position end.
std::string busstop
(Optional) bus stop if one is assigned to the stop
std::string containerstop
(Optional) container stop if one is assigned to the stop
SUMOTime duration
The stopping duration.
Structure representing possible vehicle parameter.
double repetitionProbability
The probability for emitting a vehicle per second.
int parametersSet
Information for the router which parameter were set, TraCI may modify this (when changing color)
int departLane
(optional) The lane the vehicle shall depart from (index in edge)
double departSpeed
(optional) The initial speed of the vehicle
SumoXMLTag tag
The vehicle tag.
std::string vtypeid
The vehicle's type id.
SUMOTime repetitionOffset
The time offset between vehicle reinsertions.
std::vector< std::string > via
List of the via-edges the vehicle must visit.
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
SUMOTime repetitionEnd
The time at which the flow ends (only needed when using repetitionProbability)
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle's initial speed shall be chosen.
std::string routeid
The vehicle's route id.
std::string id
The vehicle's id.
bool wasSet(int what) const
Returns whether the given parameter was set.