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-2020 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>
25 
26 #include "GNEPerson.h"
27 #include "GNEPersonTrip.h"
28 #include "GNERide.h"
29 #include "GNERoute.h"
30 #include "GNERouteHandler.h"
31 #include "GNEStop.h"
32 #include "GNEPersonStop.h"
33 #include "GNEVehicle.h"
34 #include "GNEVehicleType.h"
35 #include "GNEWalk.h"
36 
37 
38 // ===========================================================================
39 // member method definitions
40 // ===========================================================================
41 
42 // ---------------------------------------------------------------------------
43 // GNERouteHandler::RouteParameter - methods
44 // ---------------------------------------------------------------------------
45 
47  loadedID(false),
48  vClass(SVC_PASSENGER),
49  color(RGBColor::BLACK) {
50 }
51 
52 
54  routeID(originalDemandElement->getTagProperty().isRoute() ?
55  originalDemandElement->getID() :
56  originalDemandElement->getNet()->generateDemandElementID(SUMO_TAG_ROUTE)),
57  loadedID(false),
58  edges(originalDemandElement->getParentEdges()),
59  vClass(originalDemandElement->getVClass()),
60  color(originalDemandElement->getColor()) {
61 }
62 
63 
64 void
65 GNERouteHandler::RouteParameter::setEdges(GNENet* net, const std::string& edgeIDs) {
66  // clear edges
67  edges.clear();
68  // obtain edges (And show warnings if isn't valid)
69  if (GNEAttributeCarrier::canParse<std::vector<GNEEdge*> >(net, edgeIDs, true)) {
70  edges = GNEAttributeCarrier::parse<std::vector<GNEEdge*> >(net, edgeIDs);
71  }
72 }
73 
74 
75 void
76 GNERouteHandler::RouteParameter::setEdges(GNENet* net, const std::string& vehicleID, const std::string& fromID, const std::string& toID, const std::string& viaIDs) {
77  // clear edges
78  edges.clear();
79  // only continue if at least one of the edges is defined
80  if (fromID.size() + toID.size() > 0) {
81  // obtain from and to edges
82  GNEEdge* from = net->retrieveEdge(fromID, false);
83  GNEEdge* to = net->retrieveEdge(toID, false);
84  // check if edges are valid
85  if (from == nullptr) {
86  WRITE_ERROR("Invalid from-edge '" + fromID + "' used in trip '" + vehicleID + "'.");
87  } else if (to == nullptr) {
88  WRITE_ERROR("Invalid to-edge '" + toID + "' used in trip '" + vehicleID + "'.");
89  } else if (!GNEAttributeCarrier::canParse<std::vector<GNEEdge*> >(net, viaIDs, false)) {
90  WRITE_ERROR("Invalid 'via' edges used in trip '" + vehicleID + "'.");
91  } else {
92  // obtain via
93  std::vector<GNEEdge*> viaEdges = GNEAttributeCarrier::parse<std::vector<GNEEdge*> >(net, viaIDs);
94  // build edges (from - via - to)
95  edges.push_back(from);
96  for (const auto& i : viaEdges) {
97  edges.push_back(i);
98  }
99  // check that from and to edge are different
100  if (from != to) {
101  edges.push_back(to);
102  }
103  }
104  }
105 }
106 
107 
108 void
110  edges.clear();
111 }
112 
113 // ---------------------------------------------------------------------------
114 // GNERouteHandler - methods
115 // ---------------------------------------------------------------------------
116 
117 GNERouteHandler::GNERouteHandler(const std::string& file, GNENet* net, bool undoDemandElements) :
118  SUMORouteHandler(file, "", false),
119  myNet(net),
120  myUndoDemandElements(undoDemandElements),
122  myAbort(false) {
123 }
124 
125 
127 
128 
129 bool
130 GNERouteHandler::isVehicleIdDuplicated(GNENet* net, const std::string& id) {
131  // declare vehicle tags vector
133  for (const auto& vehicleTag : vehicleTags) {
134  if (net->retrieveDemandElement(vehicleTag, id, false) != nullptr) {
135  WRITE_ERROR("There is another " + toString(vehicleTag) + " with the same ID='" + id + "'.");
136  return true;
137  }
138  }
139  return false;
140 }
141 
142 
143 bool
144 GNERouteHandler::isPersonIdDuplicated(GNENet* net, const std::string& id) {
145  for (SumoXMLTag personTag : std::vector<SumoXMLTag>({SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW})) {
146  if (net->retrieveDemandElement(personTag, id, false) != nullptr) {
147  WRITE_ERROR("There is another " + toString(personTag) + " with the same ID='" + id + "'.");
148  return true;
149  }
150  }
151  return false;
152 }
153 
154 
155 void
156 GNERouteHandler::buildRoute(GNENet* net, bool undoDemandElements, const RouteParameter& routeParameters, const std::vector<SUMOVehicleParameter::Stop>& activeStops) {
157  // create GNERoute
158  GNEDemandElement* route = new GNERoute(net, routeParameters);
159  if (undoDemandElements) {
160  net->getViewNet()->getUndoList()->p_begin("add " + route->getTagStr());
161  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(route, true), true);
162  // iterate over stops of myActiveRouteStops and create stops associated with it
163  for (const auto& i : activeStops) {
164  buildStop(net, true, i, route);
165  }
166  net->getViewNet()->getUndoList()->p_end();
167  } else {
169  for (const auto& i : routeParameters.edges) {
170  i->addChildElement(route);
171  }
172  route->incRef("buildRoute");
173  // iterate over stops of myActiveRouteStops and create stops associated with it
174  for (const auto& i : activeStops) {
175  buildStop(net, false, i, route);
176  }
177  }
178 }
179 
180 void
181 GNERouteHandler::buildVehicleOverRoute(GNENet* net, bool undoDemandElements, const SUMOVehicleParameter& vehicleParameters) {
182  // first check if ID is duplicated
183  if (!isVehicleIdDuplicated(net, vehicleParameters.id)) {
184  // obtain routes and vtypes
185  GNEDemandElement* vType = net->retrieveDemandElement(SUMO_TAG_VTYPE, vehicleParameters.vtypeid, false);
186  GNEDemandElement* route = net->retrieveDemandElement(SUMO_TAG_ROUTE, vehicleParameters.routeid, false);
187  if (vType == nullptr) {
188  WRITE_ERROR("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
189  } else if (route == nullptr) {
190  WRITE_ERROR("Invalid route '" + vehicleParameters.routeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
191  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && (vehicleParameters.departLaneProcedure == DepartLaneDefinition::GIVEN) && ((int)route->getParentEdges().front()->getLanes().size() < vehicleParameters.departLane)) {
192  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
193  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DepartSpeedDefinition::GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
194  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
195  } else {
196  // create vehicle using vehicleParameters
197  GNEDemandElement* vehicle = new GNEVehicle(net, vType, route, vehicleParameters);
198  if (undoDemandElements) {
199  net->getViewNet()->getUndoList()->p_begin("add " + vehicle->getTagStr());
200  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(vehicle, true), true);
201  // iterate over stops of vehicleParameters and create stops associated with it
202  for (const auto& i : vehicleParameters.stops) {
203  buildStop(net, true, i, vehicle);
204  }
205  net->getViewNet()->getUndoList()->p_end();
206  } else {
207  net->getAttributeCarriers()->insertDemandElement(vehicle);
208  // set vehicle as child of vType and Route
209  vType->addChildElement(vehicle);
210  route->addChildElement(vehicle);
211  vehicle->incRef("buildVehicleOverRoute");
212  // iterate over stops of vehicleParameters and create stops associated with it
213  for (const auto& i : vehicleParameters.stops) {
214  buildStop(net, false, i, vehicle);
215  }
216  }
217  }
218  }
219 }
220 
221 
222 void
223 GNERouteHandler::buildFlowOverRoute(GNENet* net, bool undoDemandElements, const SUMOVehicleParameter& vehicleParameters) {
224  // first check if ID is duplicated
225  if (!isVehicleIdDuplicated(net, vehicleParameters.id)) {
226  // obtain routes and vtypes
227  GNEDemandElement* vType = net->retrieveDemandElement(SUMO_TAG_VTYPE, vehicleParameters.vtypeid, false);
228  GNEDemandElement* route = net->retrieveDemandElement(SUMO_TAG_ROUTE, vehicleParameters.routeid, false);
229  if (vType == nullptr) {
230  WRITE_ERROR("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
231  } else if (route == nullptr) {
232  WRITE_ERROR("Invalid route '" + vehicleParameters.routeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
233  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && (vehicleParameters.departLaneProcedure == DepartLaneDefinition::GIVEN) && ((int)route->getParentEdges().front()->getLanes().size() < vehicleParameters.departLane)) {
234  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
235  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DepartSpeedDefinition::GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
236  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
237  } else {
238  // create flow or trips using vehicleParameters
239  GNEDemandElement* flow = new GNEVehicle(net, vType, route, vehicleParameters);
240  if (undoDemandElements) {
241  net->getViewNet()->getUndoList()->p_begin("add " + flow->getTagStr());
242  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(flow, true), true);
243  // iterate over stops of vehicleParameters and create stops associated with it
244  for (const auto& i : vehicleParameters.stops) {
245  buildStop(net, true, i, flow);
246  }
247  net->getViewNet()->getUndoList()->p_end();
248  } else {
250  // set flow as child of vType and Route
251  vType->addChildElement(flow);
252  route->addChildElement(flow);
253  flow->incRef("buildFlowOverRoute");
254  // iterate over stops of vehicleParameters and create stops associated with it
255  for (const auto& i : vehicleParameters.stops) {
256  buildStop(net, false, i, flow);
257  }
258  }
259  }
260  }
261 }
262 
263 
264 void
265 GNERouteHandler::buildVehicleEmbeddedRoute(GNENet* net, bool undoDemandElements, SUMOVehicleParameter vehicleParameters, const std::vector<GNEEdge*>& edges) {
266  // first check if ID is duplicated
267  if (!isVehicleIdDuplicated(net, vehicleParameters.id) && (edges.size() > 0)) {
268  // obtain vType
269  GNEDemandElement* vType = net->retrieveDemandElement(SUMO_TAG_VTYPE, vehicleParameters.vtypeid, false);
270  if (vType == nullptr) {
271  WRITE_ERROR("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
272  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && (vehicleParameters.departLaneProcedure == DepartLaneDefinition::GIVEN) && ((int)edges.front()->getLanes().size() < vehicleParameters.departLane)) {
273  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
274  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DepartSpeedDefinition::GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
275  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
276  } else {
277  // declare route parameters and fill it
278  GNERouteHandler::RouteParameter embeddedRouteParameters;
279  // use the same vehicle ID
280  embeddedRouteParameters.routeID = vehicleParameters.id;
281  // set edges
282  embeddedRouteParameters.edges = edges;
283  // set color
284  embeddedRouteParameters.color = RGBColor::CYAN;
285  // due vehicle was loaded without a route, change tag
286  vehicleParameters.tag = GNE_TAG_VEHICLE_WITHROUTE;
287  // create vehicle or trips using myTemporalVehicleParameter without a route
288  GNEDemandElement* vehicle = new GNEVehicle(net, vType, vehicleParameters);
289  // creaste embedded route
290  GNEDemandElement* embeddedRoute = new GNERoute(net, vehicle, embeddedRouteParameters);
291  // add both to net depending of myUndoDemandElements
292  if (undoDemandElements) {
293  net->getViewNet()->getUndoList()->p_begin("add vehicle and " + embeddedRoute->getTagStr());
294  // add both in net using undoList
295  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(vehicle, true), true);
296  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(embeddedRoute, true), true);
297  net->getViewNet()->getUndoList()->p_end();
298  } else {
299  // add vehicleOrRouteFlow in net and in their vehicle type parent
300  net->getAttributeCarriers()->insertDemandElement(vehicle);
301  // set vehicle as child of vType
302  vType->addChildElement(vehicle);
303  vehicle->incRef("buildVehicleWithEmbeddedRoute");
304  // add route manually in net, and in all of their edges and in vehicleOrRouteFlow
305  net->getAttributeCarriers()->insertDemandElement(embeddedRoute);
306  for (const auto& edge : edges) {
307  edge->addChildElement(vehicle);
308  }
309  // set route as child of vehicle
310  vehicle->addChildElement(embeddedRoute);
311  embeddedRoute->incRef("buildVehicleWithEmbeddedRoute");
312  }
313  }
314  }
315 }
316 
317 
318 void
319 GNERouteHandler::buildFlowEmbeddedRoute(GNENet* net, bool undoDemandElements, SUMOVehicleParameter vehicleParameters, const std::vector<GNEEdge*>& edges) {
320  // first check if ID is duplicated
321  if (!isVehicleIdDuplicated(net, vehicleParameters.id) && edges.size() > 0) {
322  // obtain vType
323  GNEDemandElement* vType = net->retrieveDemandElement(SUMO_TAG_VTYPE, vehicleParameters.vtypeid, false);
324  if (vType == nullptr) {
325  WRITE_ERROR("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
326  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && (vehicleParameters.departLaneProcedure == DepartLaneDefinition::GIVEN) && ((int)edges.front()->getLanes().size() < vehicleParameters.departLane)) {
327  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
328  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DepartSpeedDefinition::GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
329  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
330  } else {
331  // declare route parameters and fill it
332  GNERouteHandler::RouteParameter embeddedRouteParameters;
333  // use the same vehicle ID
334  embeddedRouteParameters.routeID = vehicleParameters.id;
335  // set edges
336  embeddedRouteParameters.edges = edges;
337  // set color
338  embeddedRouteParameters.color = RGBColor::CYAN;
339  // due vehicle was loaded without a route, change tag
340  vehicleParameters.tag = GNE_TAG_FLOW_WITHROUTE;
341  // create vehicle or trips using myTemporalVehicleParameter without a route
342  GNEDemandElement* flow = new GNEVehicle(net, vType, vehicleParameters);
343  // creaste embedded route
344  GNEDemandElement* embeddedRoute = new GNERoute(net, flow, embeddedRouteParameters);
345  // add both to net depending of myUndoDemandElements
346  if (undoDemandElements) {
347  net->getViewNet()->getUndoList()->p_begin("add vehicle and " + embeddedRoute->getTagStr());
348  // add both in net using undoList
349  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(flow, true), true);
350  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(embeddedRoute, true), true);
351  net->getViewNet()->getUndoList()->p_end();
352  } else {
353  // add vehicleOrRouteFlow in net and in their vehicle type parent
355  // set vehicle as child of vType
356  vType->addChildElement(flow);
357  flow->incRef("buildFlowWithEmbeddedRoute");
358  // add route manually in net, and in all of their edges and in vehicleOrRouteFlow
359  net->getAttributeCarriers()->insertDemandElement(embeddedRoute);
360  for (const auto& edge : edges) {
361  edge->addChildElement(flow);
362  }
363  // set route as child of flow
364  flow->addChildElement(embeddedRoute);
365  embeddedRoute->incRef("buildFlowWithEmbeddedRoute");
366  }
367  }
368  }
369 }
370 
371 
372 void
373 GNERouteHandler::buildTrip(GNENet* net, bool undoDemandElements, const SUMOVehicleParameter& vehicleParameters, GNEEdge* fromEdge, GNEEdge* toEdge, const std::vector<GNEEdge*>& via) {
374  // check if exist another vehicle with the same ID (note: Vehicles, Flows and Trips share namespace)
375  if (!isVehicleIdDuplicated(net, vehicleParameters.id)) {
376  // obtain vtypes
377  GNEDemandElement* vType = net->retrieveDemandElement(SUMO_TAG_VTYPE, vehicleParameters.vtypeid, false);
378  if (vType == nullptr) {
379  WRITE_ERROR("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
380  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && ((vehicleParameters.departLaneProcedure == DepartLaneDefinition::GIVEN)) && ((int)fromEdge->getLanes().size() < vehicleParameters.departLane)) {
381  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
382  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DepartSpeedDefinition::GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
383  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
384  } else {
385  // add "via" edges in vehicleParameters
386  for (const auto& viaEdge : via) {
387  vehicleParameters.via.push_back(viaEdge->getID());
388  }
389  // create trip or flow using tripParameters
390  GNEDemandElement* trip = new GNEVehicle(net, vType, fromEdge, toEdge, via, vehicleParameters);
391  if (undoDemandElements) {
392  net->getViewNet()->getUndoList()->p_begin("add " + trip->getTagStr());
393  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(trip, true), true);
394  // iterate over stops of vehicleParameters and create stops associated with it
395  for (const auto& i : vehicleParameters.stops) {
396  buildStop(net, true, i, trip);
397  }
398  net->getViewNet()->getUndoList()->p_end();
399  } else {
401  // set vehicle as child of vType
402  vType->addChildElement(trip);
403  trip->incRef("buildTrip");
404  // add reference in all edges
405  fromEdge->addChildElement(trip);
406  toEdge->addChildElement(trip);
407  for (const auto& viaEdge : via) {
408  viaEdge->addChildElement(trip);
409  }
410  // iterate over stops of vehicleParameters and create stops associated with it
411  for (const auto& i : vehicleParameters.stops) {
412  buildStop(net, false, i, trip);
413  }
414  }
415  }
416  }
417 }
418 
419 
420 void
421 GNERouteHandler::buildFlow(GNENet* net, bool undoDemandElements, const SUMOVehicleParameter& vehicleParameters, GNEEdge* fromEdge, GNEEdge* toEdge, const std::vector<GNEEdge*>& via) {
422  // Check tag
423  assert(vehicleParameters.tag == SUMO_TAG_FLOW);
424  // check if exist another vehicle with the same ID (note: Vehicles, Flows and Trips share namespace)
425  if (!isVehicleIdDuplicated(net, vehicleParameters.id)) {
426  // obtain vtypes
427  GNEDemandElement* vType = net->retrieveDemandElement(SUMO_TAG_VTYPE, vehicleParameters.vtypeid, false);
428  if (vType == nullptr) {
429  WRITE_ERROR("Invalid vehicle type '" + vehicleParameters.vtypeid + "' used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'.");
430  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTLANE_SET) && (vehicleParameters.departLaneProcedure == DepartLaneDefinition::GIVEN) && ((int)fromEdge->getLanes().size() < vehicleParameters.departLane)) {
431  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departLane) + " is greater than number of lanes");
432  } else if (vehicleParameters.wasSet(VEHPARS_DEPARTSPEED_SET) && (vehicleParameters.departSpeedProcedure == DepartSpeedDefinition::GIVEN) && (vType->getAttributeDouble(SUMO_ATTR_MAXSPEED) < vehicleParameters.departSpeed)) {
433  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(vehicleParameters.tag) + " '" + vehicleParameters.id + "'. " + toString(vehicleParameters.departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
434  } else {
435  // add "via" edges in vehicleParameters
436  for (const auto& viaEdge : via) {
437  vehicleParameters.via.push_back(viaEdge->getID());
438  }
439  // create trip or flow using tripParameters
440  GNEDemandElement* flow = new GNEVehicle(net, vType, fromEdge, toEdge, via, vehicleParameters);
441  if (undoDemandElements) {
442  net->getViewNet()->getUndoList()->p_begin("add " + flow->getTagStr());
443  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(flow, true), true);
444  // iterate over stops of vehicleParameters and create stops associated with it
445  for (const auto& i : vehicleParameters.stops) {
446  buildStop(net, true, i, flow);
447  }
448  net->getViewNet()->getUndoList()->p_end();
449  } else {
451  // set vehicle as child of vType
452  vType->addChildElement(flow);
453  flow->incRef("buildFlow");
454  // add reference in all edges
455  fromEdge->addChildElement(flow);
456  toEdge->addChildElement(flow);
457  for (const auto& viaEdge : via) {
458  viaEdge->addChildElement(flow);
459  }
460  // iterate over stops of vehicleParameters and create stops associated with it
461  for (const auto& i : vehicleParameters.stops) {
462  buildStop(net, false, i, flow);
463  }
464  }
465  }
466  }
467 }
468 
469 
470 void
471 GNERouteHandler::buildStop(GNENet* net, bool undoDemandElements, const SUMOVehicleParameter::Stop& stopParameters, GNEDemandElement* stopParent) {
472  // declare pointers to parent elements
473  GNEAdditional* stoppingPlace = nullptr;
474  GNELane* lane = nullptr;
475  // GNEEdge* edge = nullptr;
476  SumoXMLTag stopTagType = SUMO_TAG_NOTHING;
477  bool validParentDemandElement = true;
478  if (stopParameters.busstop.size() > 0) {
479  stoppingPlace = net->retrieveAdditional(SUMO_TAG_BUS_STOP, stopParameters.busstop, false);
480  // distinguish between stop for vehicles and stops for persons
481  if (stopParent->getTagProperty().isPerson()) {
482  stopTagType = GNE_TAG_PERSONSTOP_BUSSTOP;
483  } else {
484  stopTagType = SUMO_TAG_STOP_BUSSTOP;
485  }
486  } else if (stopParameters.containerstop.size() > 0) {
487  stoppingPlace = net->retrieveAdditional(SUMO_TAG_CONTAINER_STOP, stopParameters.containerstop, false);
488  // distinguish between stop for vehicles and stops for persons
489  if (stopParent->getTagProperty().isPerson()) {
490  WRITE_ERROR("Persons don't support stops at container stops");
491  validParentDemandElement = false;
492  } else {
493  stopTagType = SUMO_TAG_STOP_CONTAINERSTOP;
494  }
495  } else if (stopParameters.chargingStation.size() > 0) {
496  stoppingPlace = net->retrieveAdditional(SUMO_TAG_CHARGING_STATION, stopParameters.chargingStation, false);
497  // distinguish between stop for vehicles and stops for persons
498  if (stopParent->getTagProperty().isPerson()) {
499  WRITE_ERROR("Persons don't support stops at charging stations");
500  validParentDemandElement = false;
501  } else {
502  stopTagType = SUMO_TAG_STOP_CHARGINGSTATION;
503  }
504  } else if (stopParameters.parkingarea.size() > 0) {
505  stoppingPlace = net->retrieveAdditional(SUMO_TAG_PARKING_AREA, stopParameters.parkingarea, false);
506  // distinguish between stop for vehicles and stops for persons
507  if (stopParent->getTagProperty().isPerson()) {
508  WRITE_ERROR("Persons don't support stops at parking areas");
509  validParentDemandElement = false;
510  } else {
511  stopTagType = SUMO_TAG_STOP_PARKINGAREA;
512  }
513  } else if (stopParameters.lane.size() > 0) {
514  lane = net->retrieveLane(stopParameters.lane, false);
515  stopTagType = SUMO_TAG_STOP_LANE;
516  } else if (stopParameters.edge.size() > 0) {
517  // edge = net->retrieveEdge(stopParameters.lane, false);
518  stopTagType = GNE_TAG_PERSONSTOP_EDGE;
519  }
520  // first check that parent is valid
521  if (validParentDemandElement) {
522  // check if values are correct
523  if (stoppingPlace && lane) {
524  WRITE_ERROR("A stop must be defined either over a stoppingPlace or over a lane");
525  } else if (!stoppingPlace && !lane) {
526  WRITE_ERROR("A stop requires a stoppingPlace or a lane");
527  } else if (stoppingPlace) {
528  // create stop using stopParameters and stoppingPlace
529  GNEDemandElement* stop = new GNEStop(stopTagType, net, stopParameters, stoppingPlace, stopParent);
530  // add it depending of undoDemandElements
531  if (undoDemandElements) {
532  net->getViewNet()->getUndoList()->p_begin("add " + stop->getTagStr());
533  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(stop, true), true);
534  net->getViewNet()->getUndoList()->p_end();
535  } else {
537  stoppingPlace->addChildElement(stop);
538  stopParent->addChildElement(stop);
539  stop->incRef("buildStoppingPlaceStop");
540  }
541  } else {
542  // create stop using stopParameters and lane
543  GNEDemandElement* stop = new GNEStop(net, stopParameters, lane, stopParent);
544  // add it depending of undoDemandElements
545  if (undoDemandElements) {
546  net->getViewNet()->getUndoList()->p_begin("add " + stop->getTagStr());
547  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(stop, true), true);
548  net->getViewNet()->getUndoList()->p_end();
549  } else {
551  lane->addChildElement(stop);
552  stopParent->addChildElement(stop);
553  stop->incRef("buildLaneStop");
554  }
555  }
556  }
557 }
558 
559 
560 void
561 GNERouteHandler::buildPerson(GNENet* net, bool undoDemandElements, const SUMOVehicleParameter& personParameters) {
562  // first check if ID is duplicated
563  if (!isPersonIdDuplicated(net, personParameters.id)) {
564  // obtain routes and vtypes
565  GNEDemandElement* pType = net->retrieveDemandElement(SUMO_TAG_PTYPE, personParameters.vtypeid, false);
566  if (pType == nullptr) {
567  WRITE_ERROR("Invalid person type '" + personParameters.vtypeid + "' used in " + toString(personParameters.tag) + " '" + personParameters.id + "'.");
568  } else {
569  // create person using personParameters
570  GNEDemandElement* person = new GNEPerson(SUMO_TAG_PERSON, net, pType, personParameters);
571  if (undoDemandElements) {
572  net->getViewNet()->getUndoList()->p_begin("add " + person->getTagStr());
573  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(person, true), true);
574  net->getViewNet()->getUndoList()->p_end();
575  } else {
577  // set person as child of pType and Route
578  pType->addChildElement(person);
579  person->incRef("buildPerson");
580  }
581  }
582  }
583 }
584 
585 
586 void
587 GNERouteHandler::buildPersonFlow(GNENet* net, bool undoDemandElements, const SUMOVehicleParameter& personFlowParameters) {
588  // first check if ID is duplicated
589  if (!isPersonIdDuplicated(net, personFlowParameters.id)) {
590  // obtain routes and vtypes
591  GNEDemandElement* pType = net->retrieveDemandElement(SUMO_TAG_PTYPE, personFlowParameters.vtypeid, false);
592  if (pType == nullptr) {
593  WRITE_ERROR("Invalid personFlow type '" + personFlowParameters.vtypeid + "' used in " + toString(personFlowParameters.tag) + " '" + personFlowParameters.id + "'.");
594  } else {
595  // create personFlow using personFlowParameters
596  GNEDemandElement* personFlow = new GNEPerson(SUMO_TAG_PERSONFLOW, net, pType, personFlowParameters);
597  if (undoDemandElements) {
598  net->getViewNet()->getUndoList()->p_begin("add " + personFlow->getTagStr());
599  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(personFlow, true), true);
600  net->getViewNet()->getUndoList()->p_end();
601  } else {
602  net->getAttributeCarriers()->insertDemandElement(personFlow);
603  // set personFlow as child of pType and Route
604  pType->addChildElement(personFlow);
605  personFlow->incRef("buildPersonFlow");
606  }
607  }
608  }
609 }
610 
611 
612 bool
614  // get view net
615  GNEViewNet* viewNet = personParent->getNet()->getViewNet();
616  // Declare map to keep attributes from myPersonPlanAttributes
617  std::map<SumoXMLAttr, std::string> valuesMap = personPlanAttributes->getAttributesAndValues(true);
618  // get attributes
619  const std::vector<std::string> types = GNEAttributeCarrier::parse<std::vector<std::string> >(valuesMap[SUMO_ATTR_VTYPES]);
620  const std::vector<std::string> modes = GNEAttributeCarrier::parse<std::vector<std::string> >(valuesMap[SUMO_ATTR_MODES]);
621  const std::vector<std::string> lines = GNEAttributeCarrier::parse<std::vector<std::string> >(valuesMap[SUMO_ATTR_LINES]);
622  const double arrivalPos = (valuesMap.count(SUMO_ATTR_ARRIVALPOS) > 0) ? GNEAttributeCarrier::parse<double>(valuesMap[SUMO_ATTR_ARRIVALPOS]) : 0;
623  // get stop parameters
624  SUMOVehicleParameter::Stop stopParameters;
625  // get edges
626  GNEEdge* fromEdge = (pathCreator->getSelectedEdges().size() > 0) ? pathCreator->getSelectedEdges().front() : nullptr;
627  GNEEdge* toEdge = (pathCreator->getSelectedEdges().size() > 0) ? pathCreator->getSelectedEdges().back() : nullptr;
628  // get busStops
629  GNEAdditional* fromBusStop = pathCreator->getFromStoppingPlace(SUMO_TAG_BUS_STOP);
630  GNEAdditional* toBusStop = pathCreator->getToStoppingPlace(SUMO_TAG_BUS_STOP);
631  // get path edges
632  std::vector<GNEEdge*> edges;
633  for (const auto& path : pathCreator->getPath()) {
634  for (const auto& edge : path.getSubPath()) {
635  edges.push_back(edge);
636  }
637  }
638  // get route
639  GNEDemandElement* route = pathCreator->getRoute();
640  // check what PersonPlan we're creating
641  switch (tag) {
642  // Person Trips
644  // check if person trip edge->edge can be created
645  if (fromEdge && toEdge) {
646  buildPersonTrip(viewNet->getNet(), true, personParent, fromEdge, toEdge, nullptr, nullptr, arrivalPos, types, modes);
647  return true;
648  } else {
649  viewNet->setStatusBarText("A person trip from edge to edge needs two edges");
650  }
651  break;
652  }
654  // check if person trip edge->busStop can be created
655  if (fromEdge && toBusStop) {
656  buildPersonTrip(viewNet->getNet(), true, personParent, fromEdge, nullptr, nullptr, toBusStop, arrivalPos, types, modes);
657  return true;
658  } else {
659  viewNet->setStatusBarText("A ride from edge to bussTop needs an edge and a busSTop");
660  }
661  break;
662  }
664  // check if person trip busStop->edge can be created
665  if (fromBusStop && toEdge) {
666  buildPersonTrip(viewNet->getNet(), true, personParent, nullptr, toEdge, fromBusStop, nullptr, arrivalPos, types, modes);
667  return true;
668  } else {
669  viewNet->setStatusBarText("A ride from busStop to edge needs a busStop and an edge");
670  }
671  break;
672  }
674  // check if person trip busStop->busStop can be created
675  if (fromBusStop && toBusStop) {
676  buildPersonTrip(viewNet->getNet(), true, personParent, nullptr, nullptr, fromBusStop, toBusStop, arrivalPos, types, modes);
677  return true;
678  } else {
679  viewNet->setStatusBarText("A person trip from busStop to busStop needs two busStops");
680  }
681  break;
682  }
683  // Walks
684  case GNE_TAG_WALK_EDGE_EDGE: {
685  // check if walk edge->edge can be created
686  if (fromEdge && toEdge) {
687  buildWalk(viewNet->getNet(), true, personParent, fromEdge, toEdge, nullptr, nullptr, {}, nullptr, arrivalPos);
688  return true;
689  } else {
690  viewNet->setStatusBarText("A walk from edge to edge needs two edges");
691  }
692  break;
693  }
695  // check if walk edge->busStop can be created
696  if (fromEdge && toBusStop) {
697  buildWalk(viewNet->getNet(), true, personParent, fromEdge, nullptr, nullptr, toBusStop, {}, nullptr, arrivalPos);
698  return true;
699  } else {
700  viewNet->setStatusBarText("A ride from edge to bussTop needs an edge and a busSTop");
701  }
702  break;
703  }
705  // check if walk busStop->edge can be created
706  if (fromBusStop && toEdge) {
707  buildWalk(viewNet->getNet(), true, personParent, nullptr, toEdge, fromBusStop, nullptr, {}, nullptr, arrivalPos);
708  return true;
709  } else {
710  viewNet->setStatusBarText("A ride from busStop to edge needs a busStop and an edge");
711  }
712  break;
713  }
715  // check if walk busStop->busStop can be created
716  if (fromBusStop && toBusStop) {
717  buildWalk(viewNet->getNet(), true, personParent, nullptr, nullptr, fromBusStop, toBusStop, {}, nullptr, arrivalPos);
718  return true;
719  } else {
720  viewNet->setStatusBarText("A walk from busStop to busStop needs two busStops");
721  }
722  break;
723  }
724  case GNE_TAG_WALK_EDGES: {
725  // check if walk edges can be created
726  if (edges.size() > 0) {
727  buildWalk(viewNet->getNet(), true, personParent, nullptr, nullptr, nullptr, nullptr, edges, nullptr, arrivalPos);
728  return true;
729  } else {
730  viewNet->setStatusBarText("A walk with edges attribute needs a list of edges");
731  }
732  break;
733  }
734  case GNE_TAG_WALK_ROUTE: {
735  // check if walk edges can be created
736  if (route) {
737  buildWalk(viewNet->getNet(), true, personParent, nullptr, nullptr, nullptr, nullptr, {}, route, arrivalPos);
738  return true;
739  } else {
740  viewNet->setStatusBarText("A route walk needs a route");
741  }
742  break;
743  }
744  // Rides
745  case GNE_TAG_RIDE_EDGE_EDGE: {
746  // check if ride edge->edge can be created
747  if (fromEdge && toEdge) {
748  buildRide(viewNet->getNet(), true, personParent, fromEdge, toEdge, nullptr, nullptr, arrivalPos, lines);
749  return true;
750  } else {
751  viewNet->setStatusBarText("A ride from edge to edge needs two edges");
752  }
753  break;
754  }
756  // check if ride edge->busStop can be created
757  if (fromEdge && toBusStop) {
758  buildRide(viewNet->getNet(), true, personParent, fromEdge, nullptr, nullptr, toBusStop, arrivalPos, lines);
759  return true;
760  } else {
761  viewNet->setStatusBarText("A ride from edge to busStop needs an edge and a busStop");
762  }
763  break;
764  }
766  // check if ride busStop->edge can be created
767  if (fromBusStop && toEdge) {
768  buildRide(viewNet->getNet(), true, personParent, nullptr, toEdge, fromBusStop, nullptr, arrivalPos, lines);
769  return true;
770  } else {
771  viewNet->setStatusBarText("A ride from busStop to edge needs a busStop and an edge");
772  }
773  break;
774  }
776  // check if ride busStop->busStop can be created
777  if (fromBusStop && toBusStop) {
778  buildRide(viewNet->getNet(), true, personParent, nullptr, nullptr, fromBusStop, toBusStop, arrivalPos, lines);
779  return true;
780  } else {
781  viewNet->setStatusBarText("A ride from busStop to busStop needs two busStops");
782  }
783  break;
784  }
785  // stops
787  // check if ride busStop->busStop can be created
788  if (fromEdge) {
789  buildPersonStop(viewNet->getNet(), true, personParent, fromEdge, nullptr, stopParameters);
790  return true;
791  } else {
792  viewNet->setStatusBarText("A stop has to be placed over an edge");
793  }
794  break;
795  }
797  // check if ride busStop->busStop can be created
798  if (fromBusStop) {
799  buildPersonStop(viewNet->getNet(), true, personParent, nullptr, fromBusStop, stopParameters);
800  return true;
801  } else {
802  viewNet->setStatusBarText("A stop has to be placed over a busStop");
803  }
804  break;
805  }
806  default:
807  throw InvalidArgument("Invalid person plan tag");
808  }
809  // person plan wasn't created, then return false
810  return false;
811 }
812 
813 
814 void
815 GNERouteHandler::buildPersonTrip(GNENet* net, bool undoDemandElements, GNEDemandElement* personParent, GNEEdge* fromEdge, GNEEdge* toEdge,
816  GNEAdditional* busStopFrom, GNEAdditional* busStopTo, double arrivalPos, const std::vector<std::string>& types, const std::vector<std::string>& modes) {
817  // declare person trip
818  GNEDemandElement* personTrip = nullptr;
819  // create person trip depending of parameters
820  if (fromEdge && toEdge) {
821  // create person trip edge->edge
822  personTrip = new GNEPersonTrip(net, personParent, fromEdge, toEdge, arrivalPos, types, modes);
823  // add element using undo list or directly, depending of undoDemandElements flag
824  if (undoDemandElements) {
825  net->getViewNet()->getUndoList()->p_begin("add " + toString(GNE_TAG_PERSONTRIP_EDGE_EDGE) + " within person '" + personParent->getID() + "'");
826  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(personTrip, true), true);
827  net->getViewNet()->getUndoList()->p_end();
828  } else {
829  // insert person trip
830  net->getAttributeCarriers()->insertDemandElement(personTrip);
831  // set references in children
832  personParent->addChildElement(personTrip);
833  fromEdge->addChildElement(personTrip);
834  toEdge->addChildElement(personTrip);
835  // include reference
836  personTrip->incRef("buildPersonTrip");
837  }
838  } else if (fromEdge && busStopTo) {
839  // create person trip edge->busStop
840  personTrip = new GNEPersonTrip(net, personParent, fromEdge, busStopTo, arrivalPos, types, modes);
841  // add element using undo list or directly, depending of undoDemandElements flag
842  if (undoDemandElements) {
843  net->getViewNet()->getUndoList()->p_begin("add " + toString(GNE_TAG_PERSONTRIP_EDGE_BUSSTOP) + " within person '" + personParent->getID() + "'");
844  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(personTrip, true), true);
845  net->getViewNet()->getUndoList()->p_end();
846  } else {
847  // insert person trip
848  net->getAttributeCarriers()->insertDemandElement(personTrip);
849  // set references in children
850  personParent->addChildElement(personTrip);
851  fromEdge->addChildElement(personTrip);
852  busStopTo->addChildElement(personTrip);
853  // include reference
854  personTrip->incRef("buildPersonTrip");
855  }
856  } else if (busStopFrom && toEdge) {
857  // create person trip busStop->edge
858  personTrip = new GNEPersonTrip(net, personParent, busStopFrom, toEdge, arrivalPos, types, modes);
859  // add element using undo list or directly, depending of undoDemandElements flag
860  if (undoDemandElements) {
861  net->getViewNet()->getUndoList()->p_begin("add " + toString(GNE_TAG_PERSONTRIP_BUSSTOP_EDGE) + " within person '" + personParent->getID() + "'");
862  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(personTrip, true), true);
863  net->getViewNet()->getUndoList()->p_end();
864  } else {
865  // insert person trip
866  net->getAttributeCarriers()->insertDemandElement(personTrip);
867  // set references in children
868  personParent->addChildElement(personTrip);
869  busStopFrom->addChildElement(personTrip);
870  toEdge->addChildElement(personTrip);
871  // include reference
872  personTrip->incRef("buildPersonTrip");
873  }
874  } else if (busStopFrom && busStopTo) {
875  // create person trip busStop->busStop
876  personTrip = new GNEPersonTrip(net, personParent, busStopFrom, busStopTo, arrivalPos, types, modes);
877  // add element using undo list or directly, depending of undoDemandElements flag
878  if (undoDemandElements) {
879  net->getViewNet()->getUndoList()->p_begin("add " + toString(GNE_TAG_PERSONTRIP_BUSSTOP_BUSSTOP) + " within person '" + personParent->getID() + "'");
880  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(personTrip, true), true);
881  net->getViewNet()->getUndoList()->p_end();
882  } else {
883  // insert person trip
884  net->getAttributeCarriers()->insertDemandElement(personTrip);
885  // set references in children
886  personParent->addChildElement(personTrip);
887  busStopFrom->addChildElement(personTrip);
888  busStopTo->addChildElement(personTrip);
889  // include reference
890  personTrip->incRef("buildPersonTrip");
891  }
892  }
893  // update geometry
894  personParent->updateGeometry();
895 }
896 
897 
898 void
899 GNERouteHandler::buildWalk(GNENet* net, bool undoDemandElements, GNEDemandElement* personParent, GNEEdge* fromEdge, GNEEdge* toEdge,
900  GNEAdditional* busStopFrom, GNEAdditional* busStopTo, const std::vector<GNEEdge*>& edges, GNEDemandElement* route, double arrivalPos) {
901  // declare walk
902  GNEDemandElement* walk = nullptr;
903  // create walk depending of parameters
904  if (fromEdge && toEdge) {
905  // create walk edge->edge
906  walk = new GNEWalk(net, personParent, fromEdge, toEdge, arrivalPos);
907  // add element using undo list or directly, depending of undoDemandElements flag
908  if (undoDemandElements) {
909  net->getViewNet()->getUndoList()->p_begin("add " + toString(GNE_TAG_WALK_EDGE_EDGE) + " within person '" + personParent->getID() + "'");
910  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(walk, true), true);
911  net->getViewNet()->getUndoList()->p_end();
912  } else {
913  // insert walk
915  // set references in children
916  personParent->addChildElement(walk);
917  fromEdge->addChildElement(walk);
918  toEdge->addChildElement(walk);
919  // include reference
920  walk->incRef("buildWalk");
921  }
922  } else if (fromEdge && busStopTo) {
923  // create walk edge->busStop
924  walk = new GNEWalk(net, personParent, fromEdge, busStopTo, arrivalPos);
925  // add element using undo list or directly, depending of undoDemandElements flag
926  if (undoDemandElements) {
927  net->getViewNet()->getUndoList()->p_begin("add " + toString(GNE_TAG_WALK_EDGE_BUSSTOP) + " within person '" + personParent->getID() + "'");
928  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(walk, true), true);
929  net->getViewNet()->getUndoList()->p_end();
930  } else {
931  // insert walk
933  // set references in children
934  personParent->addChildElement(walk);
935  fromEdge->addChildElement(walk);
936  busStopTo->addChildElement(walk);
937  // include reference
938  walk->incRef("buildWalk");
939  }
940  } else if (busStopFrom && toEdge) {
941  // create walk busStop->edge
942  walk = new GNEWalk(net, personParent, busStopFrom, toEdge, arrivalPos);
943  // add element using undo list or directly, depending of undoDemandElements flag
944  if (undoDemandElements) {
945  net->getViewNet()->getUndoList()->p_begin("add " + toString(GNE_TAG_WALK_BUSSTOP_EDGE) + " within person '" + personParent->getID() + "'");
946  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(walk, true), true);
947  net->getViewNet()->getUndoList()->p_end();
948  } else {
949  // insert walk
951  // set references in children
952  personParent->addChildElement(walk);
953  busStopFrom->addChildElement(walk);
954  toEdge->addChildElement(walk);
955  // include reference
956  walk->incRef("buildWalk");
957  }
958  } else if (busStopFrom && busStopTo) {
959  // create walk busStop->busStop
960  walk = new GNEWalk(net, personParent, busStopFrom, busStopTo, arrivalPos);
961  // add element using undo list or directly, depending of undoDemandElements flag
962  if (undoDemandElements) {
963  net->getViewNet()->getUndoList()->p_begin("add " + toString(GNE_TAG_WALK_BUSSTOP_BUSSTOP) + " within person '" + personParent->getID() + "'");
964  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(walk, true), true);
965  net->getViewNet()->getUndoList()->p_end();
966  } else {
967  // insert walk
969  // set references in children
970  personParent->addChildElement(walk);
971  busStopFrom->addChildElement(walk);
972  busStopTo->addChildElement(walk);
973  // include reference
974  walk->incRef("buildWalk");
975  }
976  } else if (edges.size() > 0) {
977  // create walk edges
978  walk = new GNEWalk(net, personParent, edges, arrivalPos);
979  // add element using undo list or directly, depending of undoDemandElements flag
980  if (undoDemandElements) {
981  net->getViewNet()->getUndoList()->p_begin("add " + toString(GNE_TAG_WALK_EDGES) + " within person '" + personParent->getID() + "'");
982  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(walk, true), true);
983  net->getViewNet()->getUndoList()->p_end();
984  } else {
985  // insert walk
987  // set references in children
988  personParent->addChildElement(walk);
989  for (const auto& edge : edges) {
990  edge->addChildElement(walk);
991  }
992  // include reference
993  walk->incRef("buildWalk");
994  }
995  } else if (route) {
996  // create walk edges
997  walk = new GNEWalk(net, personParent, route, arrivalPos);
998  // add element using undo list or directly, depending of undoDemandElements flag
999  if (undoDemandElements) {
1000  net->getViewNet()->getUndoList()->p_begin("add " + toString(GNE_TAG_WALK_ROUTE) + " within person '" + personParent->getID() + "'");
1001  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(walk, true), true);
1002  net->getViewNet()->getUndoList()->p_end();
1003  } else {
1004  // insert walk
1006  // set references in children
1007  personParent->addChildElement(walk);
1008  route->addChildElement(walk);
1009  // include reference
1010  walk->incRef("buildWalk");
1011  }
1012  }
1013  // update geometry
1014  personParent->updateGeometry();
1015 }
1016 
1017 
1018 void
1019 GNERouteHandler::buildRide(GNENet* net, bool undoDemandElements, GNEDemandElement* personParent, GNEEdge* fromEdge, GNEEdge* toEdge,
1020  GNEAdditional* busStopFrom, GNEAdditional* busStopTo, double arrivalPos, const std::vector<std::string>& lines) {
1021  // declare ride
1022  GNEDemandElement* ride = nullptr;
1023  // create ride depending of parameters
1024  if (fromEdge && toEdge) {
1025  // create ride edge->edge
1026  ride = new GNERide(net, personParent, fromEdge, toEdge, arrivalPos, lines);
1027  // add element using undo list or directly, depending of undoDemandElements flag
1028  if (undoDemandElements) {
1029  net->getViewNet()->getUndoList()->p_begin("add " + toString(GNE_TAG_RIDE_EDGE_EDGE) + " within person '" + personParent->getID() + "'");
1030  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(ride, true), true);
1031  net->getViewNet()->getUndoList()->p_end();
1032  } else {
1033  // insert ride
1035  // set references in children
1036  personParent->addChildElement(ride);
1037  fromEdge->addChildElement(ride);
1038  toEdge->addChildElement(ride);
1039  // include reference
1040  ride->incRef("buildRide");
1041  }
1042  } else if (fromEdge && busStopTo) {
1043  // create ride edge->busStop
1044  ride = new GNERide(net, personParent, fromEdge, busStopTo, arrivalPos, lines);
1045  // add element using undo list or directly, depending of undoDemandElements flag
1046  if (undoDemandElements) {
1047  net->getViewNet()->getUndoList()->p_begin("add " + toString(GNE_TAG_RIDE_EDGE_BUSSTOP) + " within person '" + personParent->getID() + "'");
1048  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(ride, true), true);
1049  net->getViewNet()->getUndoList()->p_end();
1050  } else {
1051  // insert ride
1053  // set references in children
1054  personParent->addChildElement(ride);
1055  fromEdge->addChildElement(ride);
1056  busStopTo->addChildElement(ride);
1057  // include reference
1058  ride->incRef("buildRide");
1059  }
1060  } else if (busStopFrom && toEdge) {
1061  // create ride busStop->edge
1062  ride = new GNERide(net, personParent, busStopFrom, toEdge, arrivalPos, lines);
1063  // add element using undo list or directly, depending of undoDemandElements flag
1064  if (undoDemandElements) {
1065  net->getViewNet()->getUndoList()->p_begin("add " + toString(GNE_TAG_RIDE_BUSSTOP_EDGE) + " within person '" + personParent->getID() + "'");
1066  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(ride, true), true);
1067  net->getViewNet()->getUndoList()->p_end();
1068  } else {
1069  // insert ride
1071  // set references in children
1072  personParent->addChildElement(ride);
1073  busStopFrom->addChildElement(ride);
1074  toEdge->addChildElement(ride);
1075  // include reference
1076  ride->incRef("buildRide");
1077  }
1078  } else if (busStopFrom && busStopTo) {
1079  // create ride busStop->busStop
1080  ride = new GNERide(net, personParent, busStopFrom, busStopTo, arrivalPos, lines);
1081  // add element using undo list or directly, depending of undoDemandElements flag
1082  if (undoDemandElements) {
1083  net->getViewNet()->getUndoList()->p_begin("add " + toString(GNE_TAG_RIDE_BUSSTOP_BUSSTOP) + " within person '" + personParent->getID() + "'");
1084  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(ride, true), true);
1085  net->getViewNet()->getUndoList()->p_end();
1086  } else {
1087  // insert ride
1089  // set references in children
1090  personParent->addChildElement(ride);
1091  busStopFrom->addChildElement(ride);
1092  busStopTo->addChildElement(ride);
1093  // include reference
1094  ride->incRef("buildRide");
1095  }
1096  }
1097  // update geometry
1098  personParent->updateGeometry();
1099 }
1100 
1101 
1102 void
1103 GNERouteHandler::buildPersonStop(GNENet* net, bool undoDemandElements, GNEDemandElement* personParent, GNEEdge* edge, GNEAdditional* busStop, const SUMOVehicleParameter::Stop& stopParameters) {
1104  // declare personStop
1105  GNEDemandElement* personStop = nullptr;
1106  // create personStop depending of parameters
1107  if (edge) {
1108  // create personStop over edge
1109  personStop = new GNEPersonStop(net, personParent, edge, stopParameters);
1110  // add element using undo list or directly, depending of undoDemandElements flag
1111  if (undoDemandElements) {
1112  net->getViewNet()->getUndoList()->p_begin("add " + toString(GNE_TAG_PERSONSTOP_EDGE) + " within person '" + personParent->getID() + "'");
1113  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(personStop, true), true);
1114  net->getViewNet()->getUndoList()->p_end();
1115  } else {
1116  // insert personStop
1117  net->getAttributeCarriers()->insertDemandElement(personStop);
1118  // set references in children
1119  personParent->addChildElement(personStop);
1120  edge->addChildElement(personStop);
1121  // include reference
1122  personStop->incRef("buildPersonStop");
1123  }
1124  } else if (busStop) {
1125  // create personStop over busStop
1126  personStop = new GNEPersonStop(net, personParent, busStop, stopParameters);
1127  // add element using undo list or directly, depending of undoDemandElements flag
1128  if (undoDemandElements) {
1129  net->getViewNet()->getUndoList()->p_begin("add " + toString(GNE_TAG_PERSONSTOP_BUSSTOP) + " within person '" + personParent->getID() + "'");
1130  net->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(personStop, true), true);
1131  net->getViewNet()->getUndoList()->p_end();
1132  } else {
1133  // insert personStop
1134  net->getAttributeCarriers()->insertDemandElement(personStop);
1135  // set references in children
1136  personParent->addChildElement(personStop);
1137  busStop->addChildElement(personStop);
1138  // include reference
1139  personStop->incRef("buildPersonStop");
1140  }
1141  }
1142  // update geometry
1143  personParent->updateGeometry();
1144 }
1145 
1146 
1147 void
1148 GNERouteHandler::transformToVehicle(GNEVehicle* originalVehicle, bool createEmbeddedRoute) {
1149  // get original vehicle tag
1150  SumoXMLTag tag = originalVehicle->getTagProperty().getTag();
1151  // get pointer to net
1152  GNENet* net = originalVehicle->getNet();
1153  // obtain vehicle parameters
1154  SUMOVehicleParameter vehicleParameters = *originalVehicle;
1155  // declare route parameters
1156  RouteParameter routeParameters;
1157  // set "yellow" as original route color
1158  routeParameters.color = RGBColor::YELLOW;
1159  // obtain edges depending of tag
1160  if ((tag == GNE_TAG_FLOW_ROUTE) || (tag == SUMO_TAG_VEHICLE)) {
1161  // get route edges
1162  routeParameters.edges = originalVehicle->getParentDemandElements().back()->getParentEdges();
1163  // get original route color
1164  routeParameters.color = originalVehicle->getParentDemandElements().back()->getColor();
1165  } else if ((tag == GNE_TAG_VEHICLE_WITHROUTE) || (tag == GNE_TAG_FLOW_WITHROUTE)) {
1166  // get embedded route edges
1167  routeParameters.edges = originalVehicle->getChildDemandElements().front()->getParentEdges();
1168  } else if ((tag == SUMO_TAG_TRIP) || (tag == SUMO_TAG_FLOW)) {
1169  // calculate path using from-via-to edges
1170  routeParameters.edges = originalVehicle->getNet()->getPathCalculator()->calculatePath(originalVehicle->getVClass(), originalVehicle->getParentEdges());
1171  }
1172  // only continue if edges are valid
1173  if (routeParameters.edges.empty()) {
1174  // declare header
1175  const std::string header = "Problem transforming to vehicle";
1176  // declare message
1177  const std::string message = "Vehicle cannot be transformed. Invalid number of edges";
1178  // write warning
1179  WRITE_DEBUG("Opened FXMessageBox " + header);
1180  // open message box
1181  FXMessageBox::warning(originalVehicle->getNet()->getViewNet()->getApp(), MBOX_OK, header.c_str(), "%s", message.c_str());
1182  // write warning if netedit is running in testing mode
1183  WRITE_DEBUG("Closed FXMessageBox " + header);
1184  } else {
1185  // begin undo-redo operation
1186  net->getViewNet()->getUndoList()->p_begin("transform " + originalVehicle->getTagStr() + " to " + toString(SUMO_TAG_VEHICLE));
1187  // first delete vehicle
1188  net->deleteDemandElement(originalVehicle, net->getViewNet()->getUndoList());
1189  // check if new vehicle must have an embedded route
1190  if (createEmbeddedRoute) {
1191  // change tag in vehicle parameters
1192  vehicleParameters.tag = GNE_TAG_VEHICLE_WITHROUTE;
1193  // create a vehicle with embebbed routes
1194  buildVehicleEmbeddedRoute(net, true, vehicleParameters, routeParameters.edges);
1195  } else {
1196  // change tag in vehicle parameters
1197  vehicleParameters.tag = SUMO_TAG_VEHICLE;
1198  // generate a new route id
1199  routeParameters.routeID = net->generateDemandElementID(SUMO_TAG_ROUTE);
1200  // build route
1201  buildRoute(net, true, routeParameters, {});
1202  // set route ID in vehicle parameters
1203  vehicleParameters.routeid = routeParameters.routeID;
1204  // create vehicle
1205  buildVehicleOverRoute(net, true, vehicleParameters);
1206  }
1207  // end undo-redo operation
1208  net->getViewNet()->getUndoList()->p_end();
1209  }
1210 }
1211 
1212 
1213 void
1214 GNERouteHandler::transformToRouteFlow(GNEVehicle* originalVehicle, bool createEmbeddedRoute) {
1215  // get original vehicle tag
1216  SumoXMLTag tag = originalVehicle->getTagProperty().getTag();
1217  // get pointer to net
1218  GNENet* net = originalVehicle->getNet();
1219  // obtain vehicle parameters
1220  SUMOVehicleParameter vehicleParameters = *originalVehicle;
1221  // declare route parameters
1222  RouteParameter routeParameters;
1223  // set "yellow" as original route color
1224  routeParameters.color = RGBColor::YELLOW;
1225  // obtain edges depending of tag
1226  if ((tag == GNE_TAG_FLOW_ROUTE) || (tag == SUMO_TAG_VEHICLE)) {
1227  // get route edges
1228  routeParameters.edges = originalVehicle->getParentDemandElements().back()->getParentEdges();
1229  // get original route color
1230  routeParameters.color = originalVehicle->getParentDemandElements().back()->getColor();
1231  } else if ((tag == GNE_TAG_VEHICLE_WITHROUTE) || (tag == GNE_TAG_FLOW_WITHROUTE)) {
1232  // get embedded route edges
1233  routeParameters.edges = originalVehicle->getChildDemandElements().front()->getParentEdges();
1234  } else if ((tag == SUMO_TAG_TRIP) || (tag == SUMO_TAG_FLOW)) {
1235  // calculate path using from-via-to edges
1236  routeParameters.edges = originalVehicle->getNet()->getPathCalculator()->calculatePath(originalVehicle->getVClass(), originalVehicle->getParentEdges());
1237  }
1238  // only continue if edges are valid
1239  if (routeParameters.edges.empty()) {
1240  // declare header
1241  const std::string header = "Problem transforming to vehicle";
1242  // declare message
1243  const std::string message = "Vehicle cannot be transformed. Invalid number of edges";
1244  // write warning
1245  WRITE_DEBUG("Opened FXMessageBox " + header);
1246  // open message box
1247  FXMessageBox::warning(originalVehicle->getNet()->getViewNet()->getApp(), MBOX_OK, header.c_str(), "%s", message.c_str());
1248  // write warning if netedit is running in testing mode
1249  WRITE_DEBUG("Closed FXMessageBox " + header);
1250  } else {
1251  // begin undo-redo operation
1252  net->getViewNet()->getUndoList()->p_begin("transform " + originalVehicle->getTagStr() + " to " + toString(SUMO_TAG_VEHICLE));
1253  // first delete vehicle
1254  net->deleteDemandElement(originalVehicle, net->getViewNet()->getUndoList());
1255  // change depart
1256  if ((vehicleParameters.tag == SUMO_TAG_TRIP) || (vehicleParameters.tag == SUMO_TAG_VEHICLE) || (vehicleParameters.tag == GNE_TAG_VEHICLE_WITHROUTE)) {
1257  // set end
1258  vehicleParameters.repetitionEnd = vehicleParameters.depart + 3600;
1259  // set number
1260  vehicleParameters.repetitionNumber = 1800;
1261  vehicleParameters.parametersSet |= VEHPARS_NUMBER_SET;
1262  // unset parameters
1263  vehicleParameters.parametersSet &= ~VEHPARS_END_SET;
1264  vehicleParameters.parametersSet &= ~VEHPARS_VPH_SET;
1265  vehicleParameters.parametersSet &= ~VEHPARS_PERIOD_SET;
1266  vehicleParameters.parametersSet &= ~VEHPARS_PROB_SET;
1267  }
1268  // check if new vehicle must have an embedded route
1269  if (createEmbeddedRoute) {
1270  // change tag in vehicle parameters
1271  vehicleParameters.tag = GNE_TAG_FLOW_WITHROUTE;
1272  // create a flow with embebbed routes
1273  buildFlowEmbeddedRoute(net, true, vehicleParameters, routeParameters.edges);
1274  } else {
1275  // change tag in vehicle parameters
1276  vehicleParameters.tag = GNE_TAG_FLOW_ROUTE;
1277  // generate a new route id
1278  routeParameters.routeID = net->generateDemandElementID(SUMO_TAG_ROUTE);
1279  // build route
1280  buildRoute(net, true, routeParameters, {});
1281  // set route ID in vehicle parameters
1282  vehicleParameters.routeid = routeParameters.routeID;
1283  // create flow
1284  buildFlowOverRoute(net, true, vehicleParameters);
1285  }
1286  // end undo-redo operation
1287  net->getViewNet()->getUndoList()->p_end();
1288  }
1289 }
1290 
1291 
1292 void
1294  // get original vehicle tag
1295  SumoXMLTag tag = originalVehicle->getTagProperty().getTag();
1296  // get pointer to net
1297  GNENet* net = originalVehicle->getNet();
1298  // obtain vehicle parameters
1299  SUMOVehicleParameter vehicleParameters = *originalVehicle;
1300  // get route
1301  GNEDemandElement* route = nullptr;
1302  // declare edges
1303  std::vector<GNEEdge*> edges;
1304  // obtain edges depending of tag
1305  if ((tag == SUMO_TAG_VEHICLE) || (tag == GNE_TAG_FLOW_ROUTE)) {
1306  // set route
1307  route = originalVehicle->getParentDemandElements().back();
1308  // get route edges
1309  edges = route->getParentEdges();
1310  } else if ((tag == GNE_TAG_VEHICLE_WITHROUTE) || (tag == GNE_TAG_FLOW_WITHROUTE)) {
1311  // get embedded route edges
1312  edges = originalVehicle->getChildDemandElements().front()->getParentEdges();
1313  } else if ((tag == SUMO_TAG_TRIP) || (tag == SUMO_TAG_FLOW)) {
1314  // just take parent edges (from and to)
1315  edges = originalVehicle->getParentEdges();
1316  }
1317  // only continue if edges are valid
1318  if (edges.size() < 2) {
1319  // declare header
1320  const std::string header = "Problem transforming to vehicle";
1321  // declare message
1322  const std::string message = "Vehicle cannot be transformed. Invalid number of edges";
1323  // write warning
1324  WRITE_DEBUG("Opened FXMessageBox " + header);
1325  // open message box
1326  FXMessageBox::warning(originalVehicle->getNet()->getViewNet()->getApp(), MBOX_OK, header.c_str(), "%s", message.c_str());
1327  // write warning if netedit is running in testing mode
1328  WRITE_DEBUG("Closed FXMessageBox " + header);
1329  } else {
1330  // begin undo-redo operation
1331  net->getViewNet()->getUndoList()->p_begin("transform " + originalVehicle->getTagStr() + " to " + toString(SUMO_TAG_TRIP));
1332  // first delete vehicle
1333  net->deleteDemandElement(originalVehicle, net->getViewNet()->getUndoList());
1334  // check if route has to be deleted
1335  if (route && route->getChildDemandElements().empty()) {
1336  net->deleteDemandElement(route, net->getViewNet()->getUndoList());
1337  }
1338  // change tag in vehicle parameters
1339  vehicleParameters.tag = SUMO_TAG_TRIP;
1340  // create trip
1341  buildTrip(net, true, vehicleParameters, edges.front(), edges.back(), {});
1342  // end undo-redo operation
1343  net->getViewNet()->getUndoList()->p_end();
1344  }
1345 }
1346 
1347 
1348 void
1350  // get original vehicle tag
1351  SumoXMLTag tag = originalVehicle->getTagProperty().getTag();
1352  // get pointer to net
1353  GNENet* net = originalVehicle->getNet();
1354  // obtain vehicle parameters
1355  SUMOVehicleParameter vehicleParameters = *originalVehicle;
1356  // declare route
1357  GNEDemandElement* route = nullptr;
1358  // declare edges
1359  std::vector<GNEEdge*> edges;
1360  // obtain edges depending of tag
1361  if ((tag == SUMO_TAG_VEHICLE) || (tag == GNE_TAG_FLOW_ROUTE)) {
1362  // set route
1363  route = originalVehicle->getParentDemandElements().back();
1364  // get route edges
1365  edges = route->getParentEdges();
1366  } else if ((tag == GNE_TAG_VEHICLE_WITHROUTE) || (tag == GNE_TAG_FLOW_WITHROUTE)) {
1367  // get embedded route edges
1368  edges = originalVehicle->getChildDemandElements().front()->getParentEdges();
1369  } else if ((tag == SUMO_TAG_TRIP) || (tag == SUMO_TAG_FLOW)) {
1370  // just take parent edges (from and to)
1371  edges = originalVehicle->getParentEdges();
1372  }
1373  // only continue if edges are valid
1374  if (edges.empty()) {
1375  // declare header
1376  const std::string header = "Problem transforming to vehicle";
1377  // declare message
1378  const std::string message = "Vehicle cannot be transformed. Invalid number of edges";
1379  // write warning
1380  WRITE_DEBUG("Opened FXMessageBox " + header);
1381  // open message box
1382  FXMessageBox::warning(originalVehicle->getNet()->getViewNet()->getApp(), MBOX_OK, header.c_str(), "%s", message.c_str());
1383  // write warning if netedit is running in testing mode
1384  WRITE_DEBUG("Closed FXMessageBox " + header);
1385  } else {
1386  // begin undo-redo operation
1387  net->getViewNet()->getUndoList()->p_begin("transform " + originalVehicle->getTagStr() + " to " + toString(SUMO_TAG_VEHICLE));
1388  // first delete vehicle
1389  net->deleteDemandElement(originalVehicle, net->getViewNet()->getUndoList());
1390  // check if route has to be deleted
1391  if (route && route->getChildDemandElements().empty()) {
1392  net->deleteDemandElement(route, net->getViewNet()->getUndoList());
1393  }
1394  // change depart
1395  if ((vehicleParameters.tag == SUMO_TAG_TRIP) || (vehicleParameters.tag == SUMO_TAG_VEHICLE) || (vehicleParameters.tag == GNE_TAG_VEHICLE_WITHROUTE)) {
1396  // set end
1397  vehicleParameters.repetitionEnd = vehicleParameters.depart + 3600;
1398  // set number
1399  vehicleParameters.repetitionNumber = 1800;
1400  vehicleParameters.parametersSet |= VEHPARS_NUMBER_SET;
1401  // unset parameters
1402  vehicleParameters.parametersSet &= ~VEHPARS_END_SET;
1403  vehicleParameters.parametersSet &= ~VEHPARS_VPH_SET;
1404  vehicleParameters.parametersSet &= ~VEHPARS_PERIOD_SET;
1405  vehicleParameters.parametersSet &= ~VEHPARS_PROB_SET;
1406  }
1407  // change tag in vehicle parameters
1408  vehicleParameters.tag = SUMO_TAG_FLOW;
1409  // create flow
1410  buildFlow(net, true, vehicleParameters, edges.front(), edges.back(), {});
1411  // end undo-redo operation
1412  net->getViewNet()->getUndoList()->p_end();
1413  }
1414 }
1415 
1416 
1417 void
1419  //
1420 }
1421 
1422 
1423 void
1425  //
1426 }
1427 
1428 
1429 void
1430 GNERouteHandler::setFlowParameters(const SumoXMLAttr attribute, int& parameters) {
1431  // modify parametersSetCopy depending of given Flow attribute
1432  switch (attribute) {
1433  case SUMO_ATTR_END: {
1434  // give more priority to end
1435  parameters = VEHPARS_END_SET | VEHPARS_NUMBER_SET;
1436  break;
1437  }
1438  case SUMO_ATTR_NUMBER:
1439  parameters ^= VEHPARS_END_SET;
1440  parameters |= VEHPARS_NUMBER_SET;
1441  break;
1442  case SUMO_ATTR_VEHSPERHOUR:
1443  case SUMO_ATTR_PERSONSPERHOUR: {
1444  // give more priority to end
1445  if ((parameters & VEHPARS_END_SET) && (parameters & VEHPARS_NUMBER_SET)) {
1446  parameters = VEHPARS_END_SET;
1447  } else if (parameters & VEHPARS_END_SET) {
1448  parameters = VEHPARS_END_SET;
1449  } else if (parameters & VEHPARS_NUMBER_SET) {
1450  parameters = VEHPARS_NUMBER_SET;
1451  }
1452  // set VehsPerHour
1453  parameters |= VEHPARS_VPH_SET;
1454  break;
1455  }
1456  case SUMO_ATTR_PERIOD: {
1457  // give more priority to end
1458  if ((parameters & VEHPARS_END_SET) && (parameters & VEHPARS_NUMBER_SET)) {
1459  parameters = VEHPARS_END_SET;
1460  } else if (parameters & VEHPARS_END_SET) {
1461  parameters = VEHPARS_END_SET;
1462  } else if (parameters & VEHPARS_NUMBER_SET) {
1463  parameters = VEHPARS_NUMBER_SET;
1464  }
1465  // set period
1466  parameters |= VEHPARS_PERIOD_SET;
1467  break;
1468  }
1469  case SUMO_ATTR_PROB: {
1470  // give more priority to end
1471  if ((parameters & VEHPARS_END_SET) && (parameters & VEHPARS_NUMBER_SET)) {
1472  parameters = VEHPARS_END_SET;
1473  } else if (parameters & VEHPARS_END_SET) {
1474  parameters = VEHPARS_END_SET;
1475  } else if (parameters & VEHPARS_NUMBER_SET) {
1476  parameters = VEHPARS_NUMBER_SET;
1477  }
1478  // set probability
1479  parameters |= VEHPARS_PROB_SET;
1480  break;
1481  }
1482  default:
1483  break;
1484  }
1485 }
1486 
1487 // ===========================================================================
1488 // protected
1489 // ===========================================================================
1490 
1491 void
1493  // currently unused
1494 }
1495 
1496 
1497 void
1499  // currently unused
1500 }
1501 
1502 
1503 void
1505  // change abort flag
1506  myAbort = false;
1507  // check if route has ID (due embebbed routes)
1508  if (attrs.hasAttribute(SUMO_ATTR_ID)) {
1509  myRouteParameter.routeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, "", SUMO_TAG_ROUTE, SUMO_ATTR_ID, myAbort);
1510  myRouteParameter.loadedID = true;
1511  } else {
1512  myRouteParameter.routeID.clear();
1513  myRouteParameter.loadedID = false;
1514  }
1515  // parse other attributes
1516  myRouteParameter.setEdges(myNet, GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, myRouteParameter.routeID, SUMO_TAG_ROUTE, SUMO_ATTR_EDGES, myAbort));
1517  myRouteParameter.color = GNEAttributeCarrier::parseAttributeFromXML<RGBColor>(attrs, myRouteParameter.routeID, SUMO_TAG_ROUTE, SUMO_ATTR_COLOR, myAbort);
1518 }
1519 
1520 
1521 void
1523  // change abort flag
1524  myAbort = false;
1525  // parse flow attributes
1527  GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, myVehicleParameter->id, SUMO_TAG_FLOW, SUMO_ATTR_FROM, myAbort),
1528  GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, myVehicleParameter->id, SUMO_TAG_FLOW, SUMO_ATTR_TO, myAbort),
1529  GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, myVehicleParameter->id, SUMO_TAG_FLOW, SUMO_ATTR_VIA, myAbort));
1530 }
1531 
1532 
1533 void
1535  // clear edges
1537 }
1538 
1539 
1540 void
1542  // change abort flag
1543  myAbort = false;
1544  // parse trips attributes
1546  GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, myVehicleParameter->id, SUMO_TAG_TRIP, SUMO_ATTR_FROM, myAbort),
1547  GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, myVehicleParameter->id, SUMO_TAG_TRIP, SUMO_ATTR_TO, myAbort),
1548  GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, myVehicleParameter->id, SUMO_TAG_TRIP, SUMO_ATTR_VIA, myAbort));
1549 }
1550 
1551 
1552 void
1553 GNERouteHandler::closeRoute(const bool /* mayBeDisconnected */) {
1554  // first copy parameters from SUMORouteHanlder to myRouteParameter
1556  // clear loaded parameters after set
1558  // we have two possibilities: Either create a route with their own ID, or create a route within a vehicle
1559  if (myVehicleParameter) {
1560  // extra warning for embebbed routes
1561  if (myRouteParameter.loadedID) {
1562  WRITE_WARNING("Attribute ID ignored in embedded routes");
1563  }
1564  // check edges
1565  if (myRouteParameter.edges.size() == 0) {
1566  WRITE_ERROR("A route needs at least one edge. Vehicle with ID='" + myVehicleParameter->id + "' cannot be created");
1568  // obtain vType
1570  if (vType == nullptr) {
1571  WRITE_ERROR("Invalid vehicle type '" + myVehicleParameter->vtypeid + "' used in " + toString(myVehicleParameter->tag) + " '" + myVehicleParameter->id + "'.");
1573  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTLANE) + " used in " + toString(myVehicleParameter->tag) + " '" + myVehicleParameter->id + "'. " + toString(myVehicleParameter->departLane) + " is greater than number of lanes");
1575  WRITE_ERROR("Invalid " + toString(SUMO_ATTR_DEPARTSPEED) + " used in " + toString(myVehicleParameter->tag) + " '" + myVehicleParameter->id + "'. " + toString(myVehicleParameter->departSpeed) + " is greater than vType" + toString(SUMO_ATTR_MAXSPEED));
1576  } else {
1577  // due vehicle was loaded without a route, change tag
1579  // create vehicle or trips using myTemporalVehicleParameter without a route
1581  // creaste embedded route
1583  // add both to net depending of myUndoDemandElements
1584  if (myUndoDemandElements) {
1585  myNet->getViewNet()->getUndoList()->p_begin("add vehicle and " + embeddedRoute->getTagStr());
1586  // add both in net using undoList
1588  myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(embeddedRoute, true), true);
1589  // iterate over stops of myActiveRouteStops and create stops associated with it
1590  for (const auto& i : myActiveRouteStops) {
1592  }
1593  } else {
1594  // add vehicleOrRouteFlow in net and in their vehicle type parent
1597  myLoadedVehicleWithEmbebbedRoute->incRef("buildVehicleAndRoute");
1598  // add route manually in net, and in all of their edges and in vehicleOrRouteFlow
1599  myNet->getAttributeCarriers()->insertDemandElement(embeddedRoute);
1600  for (const auto& i : myRouteParameter.edges) {
1601  i->addChildElement(myLoadedVehicleWithEmbebbedRoute);
1602  }
1604  embeddedRoute->incRef("buildVehicleAndRoute");
1605  // iterate over stops of myActiveRouteStops and create stops associated with it
1606  for (const auto& i : myActiveRouteStops) {
1608  }
1609  }
1610  }
1611  }
1612  } else if (myRouteParameter.loadedID == false) {
1613  WRITE_ERROR(toString(SUMO_TAG_ROUTE) + " needs a valid ID.");
1615  WRITE_ERROR(toString(SUMO_TAG_ROUTE) + " ID='" + myRouteParameter.routeID + "' contains invalid characters.");
1616  } else if (myNet->retrieveDemandElement(SUMO_TAG_ROUTE, myRouteParameter.routeID, false) != nullptr) {
1617  WRITE_ERROR("There is another " + toString(SUMO_TAG_ROUTE) + " with the same ID='" + myRouteParameter.routeID + "'.");
1618  } else if (myRouteParameter.edges.size() == 0) {
1619  WRITE_ERROR("A route needs at least one edge.");
1620  } else {
1621  // build route
1623  }
1624 }
1625 
1626 
1627 void
1629  // currently unused
1630 }
1631 
1632 
1633 void
1635  // currently unused
1636 }
1637 
1638 
1639 void
1641  // first check if we're closing a vehicle with embebbed routes and stops
1644  // check if current command group size has to be ended
1646  myNet->getViewNet()->getUndoList()->p_end();
1647  }
1648  } else {
1649  // now check if myVehicleParameter was sucesfully created
1650  if (myVehicleParameter) {
1651  // build vehicle over route
1653  }
1654  }
1655 }
1656 
1657 
1658 void
1660  // first check that VType was sucesfully created
1661  if (myCurrentVType) {
1662  // first check if we're creating a vType or a pType
1664  // check if loaded vType/pType is a default vtype
1666  // overwrite default vehicle type
1668  } else if (myNet->retrieveDemandElement(vTypeTag, myCurrentVType->id, false) != nullptr) {
1669  WRITE_ERROR("There is another " + toString(vTypeTag) + " with the same ID='" + myCurrentVType->id + "'.");
1670  } else {
1671  // create vType/pType using myCurrentVType
1672  GNEDemandElement* vType = new GNEVehicleType(myNet, *myCurrentVType, vTypeTag);
1673  if (myUndoDemandElements) {
1674  myNet->getViewNet()->getUndoList()->p_begin("add " + vType->getTagStr());
1675  myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(vType, true), true);
1676  myNet->getViewNet()->getUndoList()->p_end();
1677  } else {
1679  vType->incRef("buildVType");
1680  }
1681  }
1682  }
1683 }
1684 
1685 
1686 void
1688  // first check if myVehicleParameter was sucesfully created
1689  if (myVehicleParameter) {
1690  // first check if ID is duplicated
1692  // obtain ptype
1694  if (pType == nullptr) {
1695  WRITE_ERROR("Invalid person type '" + myVehicleParameter->vtypeid + "' used in " + toString(myVehicleParameter->tag) + " '" + myVehicleParameter->vtypeid + "'.");
1696  } else if (myPersonValues.checkPersonPlanValues()) {
1697  // create person using personParameters
1698  GNEPerson* person = new GNEPerson(SUMO_TAG_PERSON, myNet, pType, *myVehicleParameter);
1699  // begin undo-list creation
1700  myNet->getViewNet()->getUndoList()->p_begin("add " + person->getTagStr());
1701  // add person
1702  myNet->getViewNet()->getUndoList()->add(new GNEChange_DemandElement(person, true), true);
1703  // iterate over all personplan children and add it
1704  for (const auto& personPlanValue : myPersonValues.myPersonPlanValues) {
1705  switch (personPlanValue.tag) {
1706  // Person Trips
1708  buildPersonTrip(myNet, true, person, personPlanValue.fromEdge, personPlanValue.toEdge, nullptr, nullptr,
1709  personPlanValue.arrivalPos, personPlanValue.vTypes, personPlanValue.modes);
1710  break;
1711  }
1713  buildPersonTrip(myNet, true, person, personPlanValue.fromEdge, nullptr, nullptr, personPlanValue.toBusStop,
1714  personPlanValue.arrivalPos, personPlanValue.vTypes, personPlanValue.modes);
1715  break;
1716  }
1718  buildPersonTrip(myNet, true, person, nullptr, personPlanValue.toEdge, personPlanValue.fromBusStop, nullptr,
1719  personPlanValue.arrivalPos, personPlanValue.vTypes, personPlanValue.modes);
1720  break;
1721  }
1723  buildPersonTrip(myNet, true, person, nullptr, nullptr, personPlanValue.fromBusStop, personPlanValue.toBusStop,
1724  personPlanValue.arrivalPos, personPlanValue.vTypes, personPlanValue.modes);
1725  break;
1726  }
1727  // Walks
1728  case GNE_TAG_WALK_EDGE_EDGE: {
1729  buildWalk(myNet, true, person, personPlanValue.fromEdge, personPlanValue.toEdge, nullptr, nullptr, {}, nullptr,
1730  personPlanValue.arrivalPos);
1731  break;
1732  }
1734  buildWalk(myNet, true, person, personPlanValue.fromEdge, nullptr, nullptr, personPlanValue.toBusStop, {}, nullptr,
1735  personPlanValue.arrivalPos);
1736  break;
1737  }
1739  buildWalk(myNet, true, person, nullptr, personPlanValue.toEdge, personPlanValue.fromBusStop, nullptr, {}, nullptr,
1740  personPlanValue.arrivalPos);
1741  break;
1742  }
1744  buildWalk(myNet, true, person, nullptr, nullptr, personPlanValue.fromBusStop, personPlanValue.toBusStop, {}, nullptr,
1745  personPlanValue.arrivalPos);
1746  break;
1747  }
1748  case GNE_TAG_WALK_EDGES: {
1749  buildWalk(myNet, true, person, nullptr, nullptr, nullptr, nullptr, personPlanValue.edges, nullptr,
1750  personPlanValue.arrivalPos);
1751  break;
1752  }
1753  case GNE_TAG_WALK_ROUTE: {
1754  buildWalk(myNet, true, person, nullptr, nullptr, nullptr, nullptr, {}, personPlanValue.route,
1755  personPlanValue.arrivalPos);
1756  break;
1757  }
1758  // Rides
1759  case GNE_TAG_RIDE_EDGE_EDGE: {
1760  buildRide(myNet, true, person, personPlanValue.fromEdge, personPlanValue.toEdge, nullptr, nullptr,
1761  personPlanValue.arrivalPos, personPlanValue.lines);
1762  break;
1763  }
1765  buildRide(myNet, true, person, personPlanValue.fromEdge, nullptr, nullptr, personPlanValue.toBusStop,
1766  personPlanValue.arrivalPos, personPlanValue.lines);
1767  break;
1768  }
1770  buildRide(myNet, true, person, nullptr, personPlanValue.toEdge, personPlanValue.fromBusStop, nullptr,
1771  personPlanValue.arrivalPos, personPlanValue.lines);
1772  break;
1773  }
1775  buildRide(myNet, true, person, nullptr, nullptr, personPlanValue.fromBusStop, personPlanValue.toBusStop,
1776  personPlanValue.arrivalPos, personPlanValue.lines);
1777  break;
1778  }
1780  case GNE_TAG_PERSONSTOP_EDGE: {
1781  buildStop(myNet, true, personPlanValue.stopParameters, person);
1782  break;
1783  }
1784  default:
1785  throw InvalidArgument("Invalid person plan tag");
1786  }
1787  }
1788  // finish creation
1789  myNet->getViewNet()->getUndoList()->p_end();
1790  }
1791  }
1792  }
1793  // clear person plan values
1795 }
1796 
1797 void
1799  // first check if myVehicleParameter was sucesfully created
1800  if (myVehicleParameter) {
1801  // build person flow
1803  }
1804 }
1805 
1806 void
1808  // currently unused
1809 }
1810 
1811 
1812 void
1814  // first check if we're closing a flow with embebbed routes and stops
1817  // check if current command group size has to be ended
1819  myNet->getViewNet()->getUndoList()->p_end();
1820  }
1821  } else if (myVehicleParameter) {
1822  // check if we're creating a flow or a routeFlow over route
1823  if (!myVehicleParameter->routeid.empty()) {
1824  // change tag
1826  // build flow over route
1828  } else if (myRouteParameter.edges.size() > 1) {
1829  // extract via edges
1830  std::vector<GNEEdge*> viaEdges;
1831  for (int i = 1; i < ((int)myRouteParameter.edges.size() - 1); i++) {
1832  viaEdges.push_back(myRouteParameter.edges.at(i));
1833  }
1834  // build flow from-via-to
1835  buildFlow(myNet, true, *myVehicleParameter, myRouteParameter.edges.front(), myRouteParameter.edges.back(), viaEdges);
1836  }
1837  }
1838 }
1839 
1840 
1841 void
1843  // first check if myVehicleParameter was sucesfully created
1844  if (myVehicleParameter && (myRouteParameter.edges.size() > 1)) {
1845  // force reroute
1847  // extract via edges
1848  std::vector<GNEEdge*> viaEdges;
1849  for (int i = 1; i < ((int)myRouteParameter.edges.size() - 1); i++) {
1850  viaEdges.push_back(myRouteParameter.edges.at(i));
1851  }
1852  // build trip
1853  buildTrip(myNet, true, *myVehicleParameter, myRouteParameter.edges.front(), myRouteParameter.edges.back(), viaEdges);
1854  }
1855 }
1856 
1857 
1858 void
1860  // declare a personStop
1861  PersonPlansValues stop;
1862  std::string errorSuffix;
1863  if (myVehicleParameter != nullptr) {
1864  errorSuffix = " in " + toString(myVehicleParameter->tag) + " '" + myVehicleParameter->id + "'.";
1865  } else {
1866  errorSuffix = " in route '" + myActiveRouteID + "'.";
1867  }
1868  // try to parse stop
1869  myAbort = parseStop(stop.stopParameters, attrs, errorSuffix, MsgHandler::getErrorInstance());
1870  if (!myAbort) {
1871  return;
1872  }
1873  // try to parse the assigned bus stop
1874  if (stop.stopParameters.busstop != "") {
1875  // ok, we have a busStop
1877  if (bs == nullptr) {
1878  WRITE_ERROR(toString(SUMO_TAG_BUS_STOP) + " '" + stop.stopParameters.busstop + "' is not known" + errorSuffix);
1879  return;
1880  }
1881  // save lane
1883  // save stoping place in stop
1884  stop.busStop = bs;
1885  // set tag
1886  stop.tag = SUMO_TAG_STOP_BUSSTOP;
1887  // special case for persons
1890  }
1891  } else if (stop.stopParameters.containerstop != "") {
1892  // special case for persons
1894  WRITE_ERROR("Persons don't support " + toString(SUMO_TAG_CONTAINER_STOP) + "s");
1895  return;
1896  }
1897  // ok, we have a containerStop
1899  if (cs == nullptr) {
1900  WRITE_ERROR(toString(SUMO_TAG_CONTAINER_STOP) + " '" + stop.stopParameters.containerstop + "' is not known" + errorSuffix);
1901  return;
1902  }
1903  // save lane
1905  // save stoping place in stop
1906  stop.containerStop = cs;
1907  // set tag
1909 
1910  } else if (stop.stopParameters.chargingStation != "") {
1911  // special case for persons
1913  WRITE_ERROR("Persons don't support " + toString(SUMO_TAG_CHARGING_STATION) + "s");
1914  return;
1915  }
1916  // ok, we have a chargingStation
1918  if (cs == nullptr) {
1919  WRITE_ERROR(toString(SUMO_TAG_CHARGING_STATION) + " '" + stop.stopParameters.chargingStation + "' is not known" + errorSuffix);
1920  return;
1921  }
1922  // save lane
1924  // save stoping place in stop
1925  stop.chargingStation = cs;
1926  // set tag
1928  } else if (stop.stopParameters.parkingarea != "") {
1929  // special case for persons
1931  WRITE_ERROR("Persons don't support " + toString(SUMO_TAG_PARKING_AREA) + "s");
1932  return;
1933  }
1934  // ok, we have a parkingArea
1936  if (pa == nullptr) {
1937  WRITE_ERROR(toString(SUMO_TAG_PARKING_AREA) + " '" + stop.stopParameters.parkingarea + "' is not known" + errorSuffix);
1938  return;
1939  }
1940  // save lane
1942  // save stoping place in stop
1943  stop.parkingArea = pa;
1944  // set tag
1946  } else {
1947  // no, the lane and the position should be given
1948  // get the lane
1949  stop.stopParameters.lane = attrs.getOpt<std::string>(SUMO_ATTR_LANE, nullptr, myAbort, "");
1950  stop.lane = myNet->retrieveLane(stop.stopParameters.lane, false);
1951  // check if lane is valid
1952  if (myAbort && stop.stopParameters.lane != "") {
1953  if (stop.lane == nullptr) {
1954  WRITE_ERROR("The lane '" + stop.stopParameters.lane + "' for a stop is not known" + errorSuffix);
1955  return;
1956  }
1957  } else {
1958  WRITE_ERROR("A stop must be placed over a " + toString(SUMO_TAG_BUS_STOP) + ", a " + toString(SUMO_TAG_CONTAINER_STOP) +
1959  ", a " + toString(SUMO_TAG_CHARGING_STATION) + ", a " + toString(SUMO_TAG_PARKING_AREA) + " or a " + toString(SUMO_TAG_LANE) + errorSuffix);
1960  return;
1961  }
1962  // calculate start and end position
1963  stop.stopParameters.endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, nullptr, myAbort, stop.lane->getLaneParametricLength());
1964  if (attrs.hasAttribute(SUMO_ATTR_POSITION)) {
1965  WRITE_ERROR("Deprecated attribute 'pos' in description of stop" + errorSuffix);
1966  stop.stopParameters.endPos = attrs.getOpt<double>(SUMO_ATTR_POSITION, nullptr, myAbort, stop.stopParameters.endPos);
1967  }
1968  stop.stopParameters.startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, nullptr, myAbort, MAX2(0., stop.stopParameters.endPos - 2 * POSITION_EPS));
1969  stop.stopParameters.friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, nullptr, myAbort, false);
1971  WRITE_ERROR("Invalid start or end position for stop on lane '" + stop.stopParameters.lane + "'" + errorSuffix);
1972  return;
1973  }
1974  // set tag
1975  stop.tag = SUMO_TAG_STOP_LANE;
1976  // special case for persons
1979  }
1980  }
1981  // now create or store stop
1984  } else if (myVehicleParameter != nullptr) {
1986  myPersonValues.myPersonPlanValues.push_back(stop);
1987  } else {
1988  myVehicleParameter->stops.push_back(stop.stopParameters);
1989  }
1990  } else {
1991  myActiveRouteStops.push_back(stop.stopParameters);
1992  }
1993 }
1994 
1995 
1996 void
1998  // add person trip
2000 }
2001 
2002 
2003 void
2005  // add person walk
2007 }
2008 
2009 
2010 void
2012  // add person ride
2014 }
2015 
2016 
2017 void
2019  // currently unused
2020 }
2021 
2022 
2023 void
2025  // currently unused
2026 }
2027 
2028 
2029 void
2031  // currently unused
2032 }
2033 
2034 
2035 void
2037  // currently unused
2038 }
2039 
2040 // ===========================================================================
2041 // private members
2042 // ===========================================================================
2043 
2045  tag(SUMO_TAG_NOTHING),
2046  fromEdge(nullptr),
2047  toEdge(nullptr),
2048  fromBusStop(nullptr),
2049  toBusStop(nullptr),
2050  route(nullptr),
2051  arrivalPos(-1),
2052  edgeStop(nullptr),
2053  busStop(nullptr),
2054  containerStop(nullptr),
2055  chargingStation(nullptr),
2056  parkingArea(nullptr),
2057  lane(nullptr) {
2058 }
2059 
2060 
2061 void
2063  // set GNE Tag depending of parameters
2064  if (fromEdge && toEdge) {
2065  // edge->edge
2066  if (tag == SUMO_TAG_PERSONTRIP) {
2068  } else if (tag == SUMO_TAG_WALK) {
2069  tag = GNE_TAG_WALK_EDGE_EDGE;
2070  } else if (tag == SUMO_TAG_RIDE) {
2071  tag = GNE_TAG_RIDE_EDGE_EDGE;
2072  }
2073  } else if (fromEdge && toBusStop) {
2074  // edge->busStop
2075  if (tag == SUMO_TAG_PERSONTRIP) {
2077  } else if (tag == SUMO_TAG_WALK) {
2079  } else if (tag == SUMO_TAG_RIDE) {
2081  }
2082  } else if (fromBusStop && toEdge) {
2083  // busStop->edge
2084  if (tag == SUMO_TAG_PERSONTRIP) {
2086  } else if (tag == SUMO_TAG_WALK) {
2088  } else if (tag == SUMO_TAG_RIDE) {
2090  }
2091  } else if (fromBusStop && toBusStop) {
2092  // busStop->busStop
2093  if (tag == SUMO_TAG_PERSONTRIP) {
2095  } else if (tag == SUMO_TAG_WALK) {
2097  } else if (tag == SUMO_TAG_RIDE) {
2099  }
2100  } else if (edges.size() > 0) {
2101  // walk edges
2102  tag = GNE_TAG_WALK_EDGES;
2103  } else if (route) {
2104  // walk route
2105  tag = GNE_TAG_WALK_EDGES;
2106  } else if (edgeStop || lane) {
2107  // person stop lane
2109  } else {
2110  throw ProcessError("invalid combination");
2111  }
2112 }
2113 
2114 
2115 bool
2117  bool correct = false;
2118  // edge->edge
2119  if (fromEdge && toEdge) {
2120  correct = true;
2121  }
2122  // edge->busStop
2123  if (fromEdge && toBusStop) {
2124  if (correct) {
2125  return false;
2126  } else {
2127  correct = true;
2128  }
2129  }
2130  // busStop->edge
2131  if (fromBusStop && toEdge) {
2132  if (correct) {
2133  return false;
2134  } else {
2135  correct = true;
2136  }
2137  }
2138  // busStop->busStop
2139  if (fromBusStop && toBusStop) {
2140  if (correct) {
2141  return false;
2142  } else {
2143  correct = true;
2144  }
2145  }
2146  // edges
2147  if (edges.size() > 0) {
2148  if (correct) {
2149  return false;
2150  } else {
2151  correct = true;
2152  }
2153  }
2154  // route
2155  if (route) {
2156  if (correct) {
2157  return false;
2158  } else {
2159  correct = true;
2160  }
2161  }
2162  // edge
2163  if (edgeStop) {
2164  if (correct) {
2165  return false;
2166  } else {
2167  correct = true;
2168  }
2169  }
2170  return correct;
2171 }
2172 
2173 
2174 bool
2176  // edge->edge
2177  if (fromEdge && toEdge) {
2178  return true;
2179  }
2180  // edge->busStop
2181  if (fromEdge && toBusStop) {
2182  return true;
2183  }
2184  // busStop->edge
2185  if (fromBusStop && toEdge) {
2186  return true;
2187  }
2188  // busStop->busStop
2189  if (fromBusStop && toBusStop) {
2190  return true;
2191  }
2192  // edges
2193  if (edges.size() > 0) {
2194  return true;
2195  }
2196  // route
2197  if (route) {
2198  return true;
2199  }
2200  // edge
2201  if (edgeStop) {
2202  return true;
2203  }
2204  return false;
2205 }
2206 
2207 
2208 GNEEdge*
2210  if (fromEdge) {
2211  return fromEdge;
2212  } else if (toEdge) {
2213  return toEdge;
2214  } else if (fromBusStop) {
2215  return fromBusStop->getParentLanes().front()->getParentEdge();
2216  } else if (toBusStop) {
2217  return toBusStop->getParentLanes().front()->getParentEdge();
2218  } else if (route) {
2219  return route->getParentEdges().back();
2220  } else if (edges.size() > 0) {
2221  return edges.back();
2222  } else if (edgeStop) {
2223  return edgeStop;
2224  } else {
2225  return nullptr;
2226  }
2227 }
2228 
2229 
2230 bool
2232  // change abort flag
2233  bool abort = false;
2234  // declare person plan values
2235  PersonPlansValues personPlansValuesLoaded;
2236  // set tag
2237  personPlansValuesLoaded.tag = tag;
2238  // get from edge
2239  if (attrs.hasAttribute(SUMO_ATTR_FROM)) {
2240  // parse edge ID
2241  const std::string edgeStr = attrs.get<std::string>(SUMO_ATTR_FROM, "", abort, false);
2242  if (abort) {
2243  return false;
2244  } else {
2245  // retrieve edge
2246  personPlansValuesLoaded.fromEdge = net->retrieveEdge(edgeStr, false);
2247  // check if edge is valid
2248  if (personPlansValuesLoaded.fromEdge == nullptr) {
2249  return false;
2250  }
2251  }
2252  }
2253  // get to edge
2254  if (attrs.hasAttribute(SUMO_ATTR_TO)) {
2255  // parse edge ID
2256  const std::string edgeStr = attrs.get<std::string>(SUMO_ATTR_TO, "", abort, false);
2257  if (abort) {
2258  return false;
2259  } else {
2260  // retrieve edge
2261  personPlansValuesLoaded.toEdge = net->retrieveEdge(edgeStr, false);
2262  // check if edge is valid
2263  if (personPlansValuesLoaded.toEdge == nullptr) {
2264  return false;
2265  }
2266  }
2267  }
2268  // get to busStop
2269  if (attrs.hasAttribute(SUMO_ATTR_BUS_STOP)) {
2270  // parse busStop ID
2271  const std::string busStopStr = attrs.get<std::string>(SUMO_ATTR_BUS_STOP, "", abort, false);
2272  if (abort) {
2273  return false;
2274  } else {
2275  // retrieve busStop
2276  personPlansValuesLoaded.toBusStop = net->retrieveAdditional(SUMO_TAG_BUS_STOP, busStopStr, false);
2277  // check if busStop is valid
2278  if (personPlansValuesLoaded.toBusStop == nullptr) {
2279  return false;
2280  }
2281  }
2282  }
2283  // get edges
2284  if (attrs.hasAttribute(SUMO_ATTR_EDGES)) {
2285  // parse edges
2286  const std::string edgeIDs = attrs.get<std::string>(SUMO_ATTR_EDGES, "", abort, false);
2287  if (!abort && GNEAttributeCarrier::canParse<std::vector<GNEEdge*> >(net, edgeIDs, true)) {
2288  personPlansValuesLoaded.edges = GNEAttributeCarrier::parse<std::vector<GNEEdge*> >(net, edgeIDs);
2289  // check that edges aren't empty
2290  if (personPlansValuesLoaded.edges.empty()) {
2291  return false;
2292  }
2293  } else {
2294  return false;
2295  }
2296  }
2297  // get to route
2298  if (attrs.hasAttribute(SUMO_ATTR_ROUTE)) {
2299  // parse route ID
2300  const std::string routeStr = attrs.get<std::string>(SUMO_ATTR_ROUTE, "", abort, false);
2301  if (abort) {
2302  return false;
2303  } else {
2304  // retrieve route
2305  personPlansValuesLoaded.route = net->retrieveDemandElement(SUMO_TAG_ROUTE, routeStr, false);
2306  // check if route is valid
2307  if (personPlansValuesLoaded.route == nullptr) {
2308  return false;
2309  }
2310  }
2311  }
2312  // get vTypes
2313  if (attrs.hasAttribute(SUMO_ATTR_VTYPES)) {
2314  const std::string vTypes = attrs.get<std::string>(SUMO_ATTR_VTYPES, "", abort, false);
2315  if (!abort) {
2316  personPlansValuesLoaded.vTypes = GNEAttributeCarrier::parse<std::vector<std::string> >(vTypes);
2317  }
2318  }
2319  // get vTypes
2320  if (attrs.hasAttribute(SUMO_ATTR_VTYPES)) {
2321  const std::string vTypes = attrs.get<std::string>(SUMO_ATTR_VTYPES, "", abort, false);
2322  if (!abort) {
2323  personPlansValuesLoaded.vTypes = GNEAttributeCarrier::parse<std::vector<std::string> >(vTypes);
2324  }
2325  }
2326  // get modes
2327  if (attrs.hasAttribute(SUMO_ATTR_MODES)) {
2328  const std::string modes = attrs.get<std::string>(SUMO_ATTR_MODES, "", abort, false);
2329  if (!abort) {
2330  personPlansValuesLoaded.modes = GNEAttributeCarrier::parse<std::vector<std::string> >(modes);
2331  /* check modes */
2332  }
2333  }
2334  // get lines
2335  if (attrs.hasAttribute(SUMO_ATTR_LINES)) {
2336  const std::string lines = attrs.get<std::string>(SUMO_ATTR_LINES, "", abort, false);
2337  if (!abort) {
2338  personPlansValuesLoaded.lines = GNEAttributeCarrier::parse<std::vector<std::string> >(lines);
2339  /* check modes */
2340  }
2341  }
2342  // get arrival position
2343  if (attrs.hasAttribute(SUMO_ATTR_ARRIVALPOS)) {
2344  const std::string arrivalPosStr = attrs.get<std::string>(SUMO_ATTR_ARRIVALPOS, "", abort, false);
2345  if (!abort && GNEAttributeCarrier::canParse<double>(arrivalPosStr)) {
2346  personPlansValuesLoaded.arrivalPos = GNEAttributeCarrier::parse<double>(arrivalPosStr);
2347  }
2348  }
2349  // get lane stop
2350  if (attrs.hasAttribute(SUMO_ATTR_LANE)) {
2351  // parse lane ID
2352  const std::string laneStr = attrs.get<std::string>(SUMO_ATTR_LANE, "", abort, false);
2353  if (abort) {
2354  return false;
2355  } else {
2356  // retrieve lane
2357  const GNELane* lane = net->retrieveLane(laneStr, false);
2358  if (lane) {
2359  // get parent edge
2360  personPlansValuesLoaded.edgeStop = lane->getParentEdge();
2361  } else {
2362  return false;
2363  }
2364  }
2365  }
2366  // add personPlansValuesLoaded in myPersonPlanValues
2367  myPersonPlanValues.push_back(personPlansValuesLoaded);
2368  return true;
2369 }
2370 
2371 
2372 bool
2374  if (myPersonPlanValues.empty()) {
2375  return false;
2376  } else {
2377  // check first element
2378  if (!myPersonPlanValues.front().isFirstPersonPlan()) {
2379  return false;
2380  }
2381  // update tag of first element
2382  myPersonPlanValues.front().updateGNETag();
2383  // set tags and update person plan values
2384  for (int i = 1; i < (int)myPersonPlanValues.size(); i++) {
2385  // get current and previous plan
2386  PersonPlansValues& previousPlan = myPersonPlanValues.at(i - 1);
2387  PersonPlansValues& currentPlan = myPersonPlanValues.at(i);
2388  // set previous element in current plan
2389  if (previousPlan.toEdge) {
2390  currentPlan.fromEdge = previousPlan.toEdge;
2391  } else if (previousPlan.toBusStop) {
2392  currentPlan.fromBusStop = previousPlan.toBusStop;
2393  } else if (previousPlan.edges.size() > 0) {
2394  currentPlan.fromEdge = previousPlan.edges.back();
2395  } else if (previousPlan.route) {
2396  currentPlan.fromEdge = previousPlan.route->getParentEdges().back();
2397  } else if (previousPlan.edgeStop) {
2398  currentPlan.fromEdge = previousPlan.edgeStop;
2399  } else if (previousPlan.lane) {
2400  currentPlan.fromEdge = previousPlan.lane->getParentEdge();
2401  } else if (previousPlan.busStop) {
2402  currentPlan.fromBusStop = previousPlan.busStop;
2403  }
2404  // update GNETag
2405  currentPlan.updateGNETag();
2406  }
2407  return 1;
2408  }
2409 }
2410 
2411 /****************************************************************************/
#define WRITE_DEBUG(msg)
Definition: MsgHandler.h:286
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:284
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:276
@ SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
@ SVC_PEDESTRIAN
pedestrian
const std::string DEFAULT_PEDTYPE_ID
const std::string DEFAULT_VTYPE_ID
const std::string DEFAULT_BIKETYPE_ID
const int VEHPARS_PROB_SET
const int VEHPARS_VPH_SET
const int VEHPARS_END_SET
@ GIVEN
The lane is given.
@ GIVEN
The speed is given.
const int VEHPARS_DEPARTLANE_SET
const int VEHPARS_NUMBER_SET
const int VEHPARS_FORCE_REROUTE
const int VEHPARS_DEPARTSPEED_SET
const int VEHPARS_PERIOD_SET
SumoXMLTag
Numbers representing SUMO-XML - element names.
@ GNE_TAG_WALK_BUSSTOP_BUSSTOP
@ GNE_TAG_PERSONTRIP_EDGE_EDGE
@ GNE_TAG_PERSONSTOP_BUSSTOP
@ GNE_TAG_RIDE_BUSSTOP_BUSSTOP
@ SUMO_TAG_STOP_CONTAINERSTOP
stop placed over a containerStop (used in netedit)
@ GNE_TAG_PERSONTRIP_BUSSTOP_EDGE
@ SUMO_TAG_CHARGING_STATION
A Charging Station.
@ SUMO_TAG_VTYPE
description of a vehicle type
@ SUMO_TAG_WALK
@ SUMO_TAG_NOTHING
invalid tag
@ GNE_TAG_WALK_EDGES
@ SUMO_TAG_CONTAINER_STOP
A container stop.
@ 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)
@ SUMO_TAG_BUS_STOP
A bus stop.
@ 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_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)
@ GNE_TAG_RIDE_BUSSTOP_EDGE
@ SUMO_TAG_PARKING_AREA
A parking area.
@ GNE_TAG_RIDE_EDGE_EDGE
@ GNE_TAG_PERSONSTOP_EDGE
@ GNE_TAG_WALK_EDGE_EDGE
@ SUMO_TAG_ROUTE
begin/end of the description of a route
@ SUMO_TAG_RIDE
@ GNE_TAG_PERSONTRIP_EDGE_BUSSTOP
@ SUMO_TAG_STOP_BUSSTOP
stop placed over a busStop (used in netedit)
@ SUMO_TAG_LANE
begin/end of the description of a single lane
@ GNE_TAG_WALK_BUSSTOP_EDGE
@ GNE_TAG_VEHICLE_WITHROUTE
@ GNE_TAG_RIDE_EDGE_BUSSTOP
@ GNE_TAG_PERSONTRIP_BUSSTOP_BUSSTOP
@ SUMO_TAG_PERSON
@ SUMO_TAG_PERSONTRIP
@ SUMO_TAG_STOP_PARKINGAREA
stop placed over a parking area (used in netedit)
@ GNE_TAG_WALK_EDGE_BUSSTOP
@ SUMO_TAG_PTYPE
description of a person type (used in NETEDIT)
@ GNE_TAG_WALK_ROUTE
@ SUMO_TAG_PERSONFLOW
@ SUMO_TAG_TRIP
a single trip definition (used by router)
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
@ SUMO_ATTR_STARTPOS
@ SUMO_ATTR_LINES
@ SUMO_ATTR_NUMBER
@ SUMO_ATTR_LANE
@ SUMO_ATTR_VEHSPERHOUR
@ SUMO_ATTR_VIA
@ SUMO_ATTR_BUS_STOP
@ SUMO_ATTR_ENDPOS
@ SUMO_ATTR_ARRIVALPOS
@ SUMO_ATTR_EDGES
the edges of a route
@ SUMO_ATTR_MODES
@ SUMO_ATTR_VTYPES
@ 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_FRIENDLY_POS
@ SUMO_ATTR_ROUTE
@ SUMO_ATTR_COLOR
A color information.
@ SUMO_ATTR_MAXSPEED
@ SUMO_ATTR_ID
@ SUMO_ATTR_POSITION
@ SUMO_ATTR_PERSONSPERHOUR
T MAX2(T a, T b)
Definition: StdDefs.h:79
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:44
An Element which don't belongs to GNENet but has influency in the simulation.
Definition: GNEAdditional.h:47
virtual std::string getAttribute(SumoXMLAttr key) const =0
const std::string & getTagStr() const
get tag assigned to this object in string format
const GNETagProperties & getTagProperty() const
get Tag Property assigned to this object
static bool canParse(const std::string &string)
true if a value of type T can be parsed from string
GNENet * getNet() const
get pointer to net
An Element which don't belongs to GNENet but has influency in the simulation.
virtual void updateGeometry()=0
update pre-computed geometry information
virtual double getAttributeDouble(SumoXMLAttr key) const =0
const std::string & getID() const
get ID
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:49
const std::vector< GNELane * > & getLanes() const
returns a reference to the lane vector
Definition: GNEEdge.cpp:723
std::map< SumoXMLAttr, std::string > getAttributesAndValues(bool includeAll) const
get attributes and their values
std::vector< GNEEdge * > getSelectedEdges() const
get current selected additionals
const std::vector< Path > & getPath() const
get path route
GNEDemandElement * getRoute() const
get route
GNEAdditional * getToStoppingPlace(SumoXMLTag expectedTag) const
get to stoppingPlace
GNEAdditional * getFromStoppingPlace(SumoXMLTag expectedTag) const
get from stoppingPlace
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
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:45
double getLaneParametricLength() const
returns the parameteric length of the lane
Definition: GNELane.cpp:751
GNEEdge * getParentEdge() const
get arent edge
Definition: GNELane.cpp:111
void insertDemandElement(GNEDemandElement *demandElement)
Insert a demand element element int GNENet container.
std::vector< GNEEdge * > calculatePath(const SUMOVehicleClass vClass, const std::vector< GNEEdge * > &partialEdges) const
calculate Dijkstra path between a list of partial edges
A NBNetBuilder extended by visualisation and editing capabilities.
Definition: GNENet.h:40
GNELane * retrieveLane(const std::string &id, bool failHard=true, bool checkVolatileChange=false)
get lane by id
Definition: GNENet.cpp:1337
GNEEdge * retrieveEdge(const std::string &id, bool failHard=true) const
get edge by id
Definition: GNENet.cpp:1141
void deleteDemandElement(GNEDemandElement *demandElement, GNEUndoList *undoList)
remove demand element
Definition: GNENet.cpp:578
GNENetHelper::PathCalculator * getPathCalculator()
obtain instance of PathCalculator
Definition: GNENet.cpp:136
GNENetHelper::AttributeCarriers * getAttributeCarriers() const
retrieve all attribute carriers of Net
Definition: GNENet.cpp:130
std::string generateDemandElementID(SumoXMLTag tag) const
generate demand element id
Definition: GNENet.cpp:2539
GNEAdditional * retrieveAdditional(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named additional.
Definition: GNENet.cpp:2316
GNEDemandElement * retrieveDemandElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named demand element.
Definition: GNENet.cpp:2435
GNEViewNet * getViewNet() const
get view net
Definition: GNENet.cpp:2245
void incRef(const std::string &debugMsg="")
Increarse reference.
void closePerson()
Ends the processing of a person.
static void buildVehicleOverRoute(GNENet *net, bool undoDemandElements, const SUMOVehicleParameter &vehicleParameters)
build a vehicle over an existent route
static void buildRide(GNENet *net, bool undoDemandElements, GNEDemandElement *personParent, GNEEdge *fromEdge, GNEEdge *toEdge, GNEAdditional *busStopFrom, GNEAdditional *busStopTo, double arrivalPos, const std::vector< std::string > &lines)
build ride
RouteParameter myRouteParameter
NETEDIT Route Parameters.
void addStop(const SUMOSAXAttributes &attrs)
Processing of a stop.
void addTranship(const SUMOSAXAttributes &attrs)
Processing of a tranship.
bool myAbort
flag used for parsing values
static void buildFlowEmbeddedRoute(GNENet *net, bool undoDemandElements, SUMOVehicleParameter vehicleParameters, const std::vector< GNEEdge * > &edges)
build flow with a embedded route
static void buildPersonTrip(GNENet *net, bool undoDemandElements, GNEDemandElement *personParent, GNEEdge *fromEdge, GNEEdge *toEdge, GNEAdditional *busStopFrom, GNEAdditional *busStopTo, double arrivalPos, const std::vector< std::string > &types, const std::vector< std::string > &modes)
build person trip
void closeFlow()
Ends the processing of a routeFlow.
void addTransport(const SUMOSAXAttributes &attrs)
Processing of a transport.
void closeVehicleTypeDistribution()
closes (ends) the building of a distribution
static void buildPerson(GNENet *net, bool undoDemandElements, const SUMOVehicleParameter &personParameters)
void addContainer(const SUMOSAXAttributes &attrs)
Processing of a container.
static void transformToRouteFlow(GNEVehicle *originalVehicle, bool createEmbeddedRoute)
transform routeFlow over an existent route
GNENet * myNet
pointer to GNENet
void openRouteFlow(const SUMOSAXAttributes &attrs)
opens a routeFlow for reading
static bool isPersonIdDuplicated(GNENet *net, const std::string &id)
check if there is already a person (Person or PersonFlow) with the given ID
void closeContainer()
Ends the processing of a container.
static void buildRoute(GNENet *net, bool undoDemandElements, const RouteParameter &routeParameters, const std::vector< SUMOVehicleParameter::Stop > &activeStops)
build route
void closePersonFlow()
Ends the processing of a personFlow.
static void transformToFlow(GNEVehicle *originalVehicle)
transform to flow
void addPersonTrip(const SUMOSAXAttributes &attrs)
add a routing request for a walking or intermodal person
void closeVehicle()
Ends the processing of a vehicle.
void openRouteDistribution(const SUMOSAXAttributes &attrs)
opens a route distribution for reading
static void buildPersonStop(GNENet *net, bool undoDemandElements, GNEDemandElement *personParent, GNEEdge *edge, GNEAdditional *busStop, const SUMOVehicleParameter::Stop &stopParameters)
build stop
static void buildWalk(GNENet *net, bool undoDemandElements, GNEDemandElement *personParent, GNEEdge *fromEdge, GNEEdge *toEdge, GNEAdditional *busStopFrom, GNEAdditional *busStopTo, const std::vector< GNEEdge * > &edges, GNEDemandElement *route, double arrivalPos)
build walk
void addWalk(const SUMOSAXAttributes &attrs)
add a fully specified walk
void closeRoute(const bool mayBeDisconnected=false)
static void buildPersonFlow(GNENet *net, bool undoDemandElements, const SUMOVehicleParameter &personFlowParameters)
build person flow
void addPerson(const SUMOSAXAttributes &attrs)
Processing of a person.
void openRoute(const SUMOSAXAttributes &attrs)
opens a route for reading
static void setFlowParameters(const SumoXMLAttr attribute, int &parameters)
configure flow parameters
static bool isVehicleIdDuplicated(GNENet *net, const std::string &id)
check if there is already a vehicle (Vehicle, Trip, Flow or Flow) with the given ID
GNERouteHandler(const std::string &file, GNENet *net, bool undoDemandElements=true)
Constructor.
void openTrip(const SUMOSAXAttributes &attrs)
opens a trip for reading
PersonValue myPersonValues
NETEDIT person values.
void closeRouteDistribution()
closes (ends) the building of a distribution
static bool buildPersonPlan(SumoXMLTag tag, GNEDemandElement *personParent, GNEFrameAttributesModuls::AttributesCreator *personPlanAttributes, GNEFrameModuls::PathCreator *pathCreator)
void openFlow(const SUMOSAXAttributes &attrs)
opens a routeFlow for reading
static void transformToTrip(GNEVehicle *originalVehicle)
transform to trip
static void transformToPerson(GNEPerson *originalPerson)
transform person functions
void closeVType()
Ends the processing of a vehicle Type.
bool myUndoDemandElements
flag to check if created demand elements must be undo and redo
~GNERouteHandler()
Destructor.
GNEDemandElement * myLoadedVehicleWithEmbebbedRoute
Pointer to loaded vehicle with embebbed route (needed for GNEStops)
static void buildStop(GNENet *net, bool undoDemandElements, const SUMOVehicleParameter::Stop &stopParameters, GNEDemandElement *stopParent)
build stop
void closeTrip()
Ends the processing of a trip.
void addRide(const SUMOSAXAttributes &attrs)
Processing of a ride.
static void buildVehicleEmbeddedRoute(GNENet *net, bool undoDemandElements, SUMOVehicleParameter vehicleParameters, const std::vector< GNEEdge * > &edges)
build vehicle with a embedded route
void openVehicleTypeDistribution(const SUMOSAXAttributes &attrs)
opens a type distribution for reading
static void transformToPersonFlow(GNEPerson *originalPerson)
transform routeFlow over an existent route
static void buildFlowOverRoute(GNENet *net, bool undoDemandElements, const SUMOVehicleParameter &vehicleParameters)
build a flow over an existent route
static void buildFlow(GNENet *net, bool undoDemandElements, const SUMOVehicleParameter &vehicleParameters, GNEEdge *fromEdge, GNEEdge *toEdge, const std::vector< GNEEdge * > &via)
build flow
static void transformToVehicle(GNEVehicle *originalVehicle, bool createEmbeddedRoute)
transform vehicle functions
static void buildTrip(GNENet *net, bool undoDemandElements, const SUMOVehicleParameter &vehicleParameters, GNEEdge *fromEdge, GNEEdge *toEdge, const std::vector< GNEEdge * > &via)
build trip
SumoXMLTag getTag() const
get Tag vinculated with this attribute Property
bool isPerson() const
return true if tag correspond to a person element
void p_begin(const std::string &description)
Begin undo command sub-group. This begins a new group of commands that are treated as a single comman...
Definition: GNEUndoList.cpp:71
int currentCommandGroupSize() const
get size of current CommandGroup
void p_end()
End undo command sub-group. If the sub-group is still empty, it will be deleted; otherwise,...
Definition: GNEUndoList.cpp:78
SUMOVehicleClass getVClass() const
Definition: GNEVehicle.cpp:466
static void overwriteVType(GNEDemandElement *vType, SUMOVTypeParameter *newVTypeParameter, GNEUndoList *undoList)
overwrite all values of GNEVehicleType with a SUMOVTypeParameter
GNENet * getNet() const
get the net object
GNEUndoList * getUndoList() const
get the undoList object
void setStatusBarText(const std::string &text)
set staturBar text
Definition: GNEViewNet.cpp:575
static MsgHandler * getErrorInstance()
Returns the instance to add errors to.
Definition: MsgHandler.cpp:80
void clearParameter()
Clears the parameter map.
static const RGBColor YELLOW
Definition: RGBColor.h:183
static const RGBColor CYAN
Definition: RGBColor.h:184
Parser for routes during their loading.
bool parseStop(SUMOVehicleParameter::Stop &stop, const SUMOSAXAttributes &attrs, std::string errorSuffix, MsgHandler *const errorOutput)
parses attributes common to all stops
std::vector< SUMOVehicleParameter::Stop > myActiveRouteStops
List of the stops on the parsed route.
std::string myActiveRouteID
The id of the current route.
Parameterised myLoadedParameterised
Parameterised used for saving loaded generic parameters that aren't saved in Vehicles or Vehicle Type...
SUMOVehicleParameter * myVehicleParameter
Parameter of the current vehicle, trip, person, container or flow.
SUMOVTypeParameter * myCurrentVType
The currently parsed vehicle type.
static StopPos checkStopPos(double &startPos, double &endPos, const double laneLength, const double minLength, const bool friendlyPos)
check start and end position of a stop
Encapsulated SAX-Attributes.
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue, bool report=true) const
Tries to read given attribute assuming it is an int.
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
SUMOVehicleClass vehicleClass
The vehicle's class.
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.
bool friendlyPos
enable or disable friendly position (used by NETEDIT)
std::string parkingarea
(Optional) parking area if one is assigned to the stop
double startPos
The stopping position start.
std::string chargingStation
(Optional) charging station if one is assigned to the stop
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
Structure representing possible vehicle parameter.
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.
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.
double arrivalPos
(optional) The position the vehicle shall arrive on
std::string routeid
The vehicle's route id.
std::string id
The vehicle's id.
std::vector< Stop > stops
List of the stops the vehicle will make, TraCI may add entries here.
bool wasSet(int what) const
Returns whether the given parameter was set.
static bool isValidVehicleID(const std::string &value)
whether the given string is a valid id for a vehicle or flow
struct used for load person plans (Rides, Walks, etc.)
GNEEdge * getLastEdge() const
return last valid edge (used to create consecutive person plans)
std::vector< std::string > vTypes
vehicle types
GNEAdditional * chargingStation
charging station (stop)
bool isFirstPersonPlan() const
is first person plan
std::vector< std::string > lines
lines
GNEAdditional * fromBusStop
from busStop
std::vector< GNEEdge * > edges
list of edges
GNEAdditional * busStop
bus stop (stop)
SUMOVehicleParameter::Stop stopParameters
stop parameters
GNEAdditional * parkingArea
parking area (stop)
std::vector< std::string > modes
modes
GNEDemandElement * route
arrival route
GNEAdditional * toBusStop
to busStop
GNEAdditional * containerStop
container stop (stop)
bool checkIntegrity() const
check integrity
std::vector< PersonPlansValues > myPersonPlanValues
container for person trips loaded values
bool addPersonValue(GNENet *net, SumoXMLTag tag, const SUMOSAXAttributes &attrs)
add person plan value (
bool checkPersonPlanValues()
check person plan loaded (this will change tags, set begin and end elements, etc.)
struct for saving route parameters
bool loadedID
flag to check if route was loaded
std::string routeID
string for saving parsed Route ID
std::vector< GNEEdge * > edges
edges
RGBColor color
string for saving parsed route colors
Parameterised parameters
parameters
void setEdges(GNENet *net, const std::string &edgeIDs)
set edges (list of consecutive edges)