Eclipse SUMO - Simulation of Urban MObility
GNEVehicle.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-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
15 // Representation of vehicles in NETEDIT
16 /****************************************************************************/
17 
18 // ===========================================================================
19 // included modules
20 // ===========================================================================
21 
22 #include <cmath>
24 #include <netbuild/NBNode.h>
25 #include <netedit/GNENet.h>
26 #include <netedit/GNEUndoList.h>
27 #include <netedit/GNEViewNet.h>
28 #include <netedit/GNEViewParent.h>
35 #include <utils/gui/div/GLHelper.h>
40 
41 #include "GNEVehicle.h"
42 #include "GNERouteHandler.h"
43 
44 
45 // ===========================================================================
46 // FOX callback mapping
47 // ===========================================================================
48 FXDEFMAP(GNEVehicle::GNESingleVehiclePopupMenu) GNESingleVehiclePopupMenuMap[] = {
50 };
51 
52 FXDEFMAP(GNEVehicle::GNESelectedVehiclesPopupMenu) GNESelectedVehiclesPopupMenuMap[] = {
54 };
55 
56 // Object implementation
57 FXIMPLEMENT(GNEVehicle::GNESingleVehiclePopupMenu, GUIGLObjectPopupMenu, GNESingleVehiclePopupMenuMap, ARRAYNUMBER(GNESingleVehiclePopupMenuMap))
58 FXIMPLEMENT(GNEVehicle::GNESelectedVehiclesPopupMenu, GUIGLObjectPopupMenu, GNESelectedVehiclesPopupMenuMap, ARRAYNUMBER(GNESelectedVehiclesPopupMenuMap))
59 
60 // ===========================================================================
61 // GNEVehicle::GNESingleVehiclePopupMenu
62 // ===========================================================================
63 
65  GUIGLObjectPopupMenu(app, parent, *vehicle),
66  myVehicle(vehicle),
67  myTransformToVehicle(nullptr),
68  myTransformToVehicleWithEmbeddedRoute(nullptr),
69  myTransformToRouteFlow(nullptr),
70  myTransformToRouteFlowWithEmbeddedRoute(nullptr),
71  myTransformToTrip(nullptr),
72  myTransformToFlow(nullptr) {
73  // build header
74  myVehicle->buildPopupHeader(this, app);
75  // build menu command for center button and copy cursor position to clipboard
76  myVehicle->buildCenterPopupEntry(this);
77  myVehicle->buildPositionCopyEntry(this, false);
78  // buld menu commands for names
79  new FXMenuCommand(this, ("Copy " + myVehicle->getTagStr() + " name to clipboard").c_str(), nullptr, this, MID_COPY_NAME);
80  new FXMenuCommand(this, ("Copy " + myVehicle->getTagStr() + " typed name to clipboard").c_str(), nullptr, this, MID_COPY_TYPED_NAME);
81  new FXMenuSeparator(this);
82  // build selection and show parameters menu
83  myVehicle->getViewNet()->buildSelectionACPopupEntry(this, myVehicle);
84  myVehicle->buildShowParamsPopupEntry(this);
85  // add transform functions only in demand mode
86  if (myVehicle->getViewNet()->getEditModes().currentSupermode == GNE_SUPERMODE_DEMAND) {
87  // Get icons
88  FXIcon* vehicleIcon = GUIIconSubSys::getIcon(ICON_VEHICLE);
89  FXIcon* tripIcon = GUIIconSubSys::getIcon(ICON_TRIP);
90  FXIcon* routeFlowIcon = GUIIconSubSys::getIcon(ICON_ROUTEFLOW);
91  FXIcon* flowIcon = GUIIconSubSys::getIcon(ICON_FLOW);
92  // create menu pane for transform operations
93  FXMenuPane* transformOperation = new FXMenuPane(this);
94  this->insertMenuPaneChild(transformOperation);
95  new FXMenuCascade(this, "transform to", nullptr, transformOperation);
96  // Create menu comands for all transform
97  myTransformToVehicle = new FXMenuCommand(transformOperation, "Vehicle", vehicleIcon, this, MID_GNE_VEHICLE_TRANSFORM);
98  myTransformToVehicleWithEmbeddedRoute = new FXMenuCommand(transformOperation, "Vehicle (embedded route)", vehicleIcon, this, MID_GNE_VEHICLE_TRANSFORM);
99  myTransformToRouteFlow = new FXMenuCommand(transformOperation, "RouteFlow", routeFlowIcon, this, MID_GNE_VEHICLE_TRANSFORM);
100  myTransformToRouteFlowWithEmbeddedRoute = new FXMenuCommand(transformOperation, "RouteFlow (embedded route)", routeFlowIcon, this, MID_GNE_VEHICLE_TRANSFORM);
101  myTransformToTrip = new FXMenuCommand(transformOperation, "Trip", tripIcon, this, MID_GNE_VEHICLE_TRANSFORM);
102  myTransformToFlow = new FXMenuCommand(transformOperation, "Flow", flowIcon, this, MID_GNE_VEHICLE_TRANSFORM);
103  // check what menu command has to be disabled
104  if (myVehicle->getTagProperty().getTag() == SUMO_TAG_VEHICLE) {
105  if (myVehicle->getDemandElementParents().size() > 1) {
106  myTransformToVehicle->disable();
107  } else {
108  myTransformToVehicleWithEmbeddedRoute->disable();
109  }
110  } else if (myVehicle->getTagProperty().getTag() == SUMO_TAG_ROUTEFLOW) {
111  if (myVehicle->getDemandElementParents().size() > 1) {
112  myTransformToRouteFlow->disable();
113  } else {
114  myTransformToRouteFlowWithEmbeddedRoute->disable();
115  }
116  } else if (myVehicle->getTagProperty().getTag() == SUMO_TAG_TRIP) {
117  myTransformToTrip->disable();
118  } else if (myVehicle->getTagProperty().getTag() == SUMO_TAG_FLOW) {
119  myTransformToFlow->disable();
120  }
121  }
122 }
123 
124 
126 
127 
128 long
129 GNEVehicle::GNESingleVehiclePopupMenu::onCmdTransform(FXObject* obj, FXSelector, void*) {
130  if (obj == myTransformToVehicle) {
132  } else if (obj == myTransformToVehicleWithEmbeddedRoute) {
134  } else if (obj == myTransformToRouteFlow) {
136  } else if (obj == myTransformToRouteFlowWithEmbeddedRoute) {
138  } else if (obj == myTransformToTrip) {
140  } else if (obj == myTransformToFlow) {
142  }
143  return 1;
144 }
145 
146 // ===========================================================================
147 // GNEVehicle::GNESelectedVehiclesPopupMenu
148 // ===========================================================================
149 
150 GNEVehicle::GNESelectedVehiclesPopupMenu::GNESelectedVehiclesPopupMenu(GNEVehicle* vehicle, const std::vector<GNEVehicle*>& selectedVehicle, GUIMainWindow& app, GUISUMOAbstractView& parent) :
151  GUIGLObjectPopupMenu(app, parent, *vehicle),
152  mySelectedVehicles(selectedVehicle),
153  myVehicleTag(vehicle->getTagProperty().getTag()),
154  myTransformToVehicle(nullptr),
156  myTransformToRouteFlow(nullptr),
158  myTransformToTrip(nullptr),
159  myTransformToFlow(nullptr),
160  myTransformAllVehiclesToVehicle(nullptr),
161  myTransformAllVehiclesToVehicleWithEmbeddedRoute(nullptr),
162  myTransformAllVehiclesToRouteFlow(nullptr),
163  myTransformAllVehiclesToRouteFlowWithEmbeddedRoute(nullptr),
164  myTransformAllVehiclesToTrip(nullptr),
165  myTransformAllVehiclesToFlow(nullptr) {
166  // build header
167  vehicle->buildPopupHeader(this, app);
168  // build menu command for center button and copy cursor position to clipboard
169  vehicle->buildCenterPopupEntry(this);
170  vehicle->buildPositionCopyEntry(this, false);
171  // buld menu commands for names
172  new FXMenuCommand(this, ("Copy " + vehicle->getTagStr() + " name to clipboard").c_str(), nullptr, this, MID_COPY_NAME);
173  new FXMenuCommand(this, ("Copy " + vehicle->getTagStr() + " typed name to clipboard").c_str(), nullptr, this, MID_COPY_TYPED_NAME);
174  new FXMenuSeparator(this);
175  // build selection and show parameters menu
176  vehicle->getViewNet()->buildSelectionACPopupEntry(this, vehicle);
177  vehicle->buildShowParamsPopupEntry(this);
178  // add transform functions only in demand mode
180  // Get icons
181  FXIcon* vehicleIcon = GUIIconSubSys::getIcon(ICON_VEHICLE);
182  FXIcon* tripIcon = GUIIconSubSys::getIcon(ICON_TRIP);
183  FXIcon* routeFlowIcon = GUIIconSubSys::getIcon(ICON_ROUTEFLOW);
184  FXIcon* flowIcon = GUIIconSubSys::getIcon(ICON_FLOW);
185  // create menu pane for transform operations
186  FXMenuPane* transformOperation = new FXMenuPane(this);
187  this->insertMenuPaneChild(transformOperation);
188  new FXMenuCascade(this, "transform to", nullptr, transformOperation);
189  // Create menu comands for all transform
190  myTransformToVehicle = new FXMenuCommand(transformOperation,
191  ("Vehicles (Only " + vehicle->getTagStr() + ")").c_str(), vehicleIcon, this, MID_GNE_VEHICLE_TRANSFORM);
192  myTransformToVehicleWithEmbeddedRoute = new FXMenuCommand(transformOperation,
193  ("Vehicles (embedded route, only " + vehicle->getTagStr() + ")").c_str(), vehicleIcon, this, MID_GNE_VEHICLE_TRANSFORM);
194  myTransformToRouteFlow = new FXMenuCommand(transformOperation,
195  ("RouteFlows (Only " + vehicle->getTagStr() + ")").c_str(), routeFlowIcon, this, MID_GNE_VEHICLE_TRANSFORM);
196  myTransformToRouteFlowWithEmbeddedRoute = new FXMenuCommand(transformOperation,
197  ("RouteFlows (embedded route, only " + vehicle->getTagStr() + ")").c_str(), routeFlowIcon, this, MID_GNE_VEHICLE_TRANSFORM);
198  myTransformToTrip = new FXMenuCommand(transformOperation,
199  ("Trips (Only " + vehicle->getTagStr() + ")").c_str(), tripIcon, this, MID_GNE_VEHICLE_TRANSFORM);
200  myTransformToFlow = new FXMenuCommand(transformOperation,
201  ("Flows (Only " + vehicle->getTagStr() + ")").c_str(), flowIcon, this, MID_GNE_VEHICLE_TRANSFORM);
202  // create separator
203  new FXMenuSeparator(transformOperation);
204  // Create menu comands for all transform all vehicles
205  myTransformAllVehiclesToVehicle = new FXMenuCommand(transformOperation, "Vehicles", vehicleIcon, this, MID_GNE_VEHICLE_TRANSFORM);
206  myTransformAllVehiclesToVehicleWithEmbeddedRoute = new FXMenuCommand(transformOperation, "Vehicles (embedded route)", vehicleIcon, this, MID_GNE_VEHICLE_TRANSFORM);
207  myTransformAllVehiclesToRouteFlow = new FXMenuCommand(transformOperation, "RouteFlows", routeFlowIcon, this, MID_GNE_VEHICLE_TRANSFORM);
208  myTransformAllVehiclesToRouteFlowWithEmbeddedRoute = new FXMenuCommand(transformOperation, "RouteFlows (embedded route)", routeFlowIcon, this, MID_GNE_VEHICLE_TRANSFORM);
209  myTransformAllVehiclesToTrip = new FXMenuCommand(transformOperation, "Trips", tripIcon, this, MID_GNE_VEHICLE_TRANSFORM);
210  myTransformAllVehiclesToFlow = new FXMenuCommand(transformOperation, "Flows", flowIcon, this, MID_GNE_VEHICLE_TRANSFORM);
211  }
212 }
213 
214 
216 
217 
218 long
220  // iterate over all selected vehicles
221  for (const auto& i : mySelectedVehicles) {
222  if ((obj == myTransformToVehicle) &&
223  (i->getTagProperty().getTag() == myVehicleTag)) {
225  } else if ((obj == myTransformToVehicleWithEmbeddedRoute) &&
226  (i->getTagProperty().getTag() == myVehicleTag)) {
228  } else if ((obj == myTransformToRouteFlow) &&
229  (i->getTagProperty().getTag() == myVehicleTag)) {
231  } else if ((obj == myTransformToRouteFlowWithEmbeddedRoute) &&
232  (i->getTagProperty().getTag() == myVehicleTag)) {
234  } else if ((obj == myTransformToTrip) &&
235  (i->getTagProperty().getTag() == myVehicleTag)) {
237  } else if ((obj == myTransformToFlow) &&
238  (i->getTagProperty().getTag() == myVehicleTag)) {
240  } else if (obj == myTransformAllVehiclesToVehicle) {
244  } else if (obj == myTransformAllVehiclesToRouteFlow) {
248  } else if (obj == myTransformAllVehiclesToTrip) {
250  } else if (obj == myTransformAllVehiclesToFlow) {
252  }
253  }
254  return 1;
255 }
256 
257 // ===========================================================================
258 // member method definitions
259 // ===========================================================================
260 
261 GNEVehicle::GNEVehicle(SumoXMLTag tag, GNEViewNet* viewNet, const std::string& vehicleID, GNEDemandElement* vehicleType, GNEDemandElement* route) :
262  GNEDemandElement(vehicleID, viewNet, (tag == SUMO_TAG_ROUTEFLOW) ? GLO_ROUTEFLOW : GLO_VEHICLE, tag,
263 {}, {}, {}, {}, {vehicleType, route}, {}, {}, {}, {}, {}),
265 myFromEdge(nullptr),
266 myToEdge(nullptr) {
267  // SUMOVehicleParameter ID has to be set manually
268  id = vehicleID;
269  // set manually vtypeID (needed for saving)
270  vtypeid = vehicleType->getID();
271 }
272 
273 
274 GNEVehicle::GNEVehicle(GNEViewNet* viewNet, GNEDemandElement* vehicleType, GNEDemandElement* route, const SUMOVehicleParameter& vehicleParameters) :
275  GNEDemandElement(vehicleParameters.id, viewNet, (vehicleParameters.tag == SUMO_TAG_ROUTEFLOW) ? GLO_ROUTEFLOW : GLO_VEHICLE, vehicleParameters.tag,
276 {}, {}, {}, {}, {vehicleType, route}, {}, {}, {}, {}, {}),
277 SUMOVehicleParameter(vehicleParameters),
278 myFromEdge(nullptr),
279 myToEdge(nullptr) {
280  // SUMOVehicleParameter ID has to be set manually
281  id = vehicleParameters.id;
282  // set manually vtypeID (needed for saving)
283  vtypeid = vehicleType->getID();
284 }
285 
286 
287 GNEVehicle::GNEVehicle(GNEViewNet* viewNet, GNEDemandElement* vehicleType, const SUMOVehicleParameter& vehicleParameters) :
288  GNEDemandElement(vehicleParameters.id, viewNet, (vehicleParameters.tag == SUMO_TAG_ROUTEFLOW) ? GLO_ROUTEFLOW : GLO_VEHICLE, vehicleParameters.tag,
289 {}, {}, {}, {}, {vehicleType}, {}, {}, {}, {}, {}),
290 SUMOVehicleParameter(vehicleParameters),
291 myFromEdge(nullptr),
292 myToEdge(nullptr) {
293  // SUMOVehicleParameter ID has to be set manually
294  id = vehicleParameters.id;
295  // reset routeid
296  routeid.clear();
297  // set manually vtypeID (needed for saving)
298  vtypeid = vehicleType->getID();
299 }
300 
301 
302 GNEVehicle::GNEVehicle(SumoXMLTag tag, GNEViewNet* viewNet, const std::string& vehicleID, GNEDemandElement* vehicleType, GNEEdge* fromEdge, GNEEdge* toEdge) :
303  GNEDemandElement(vehicleID, viewNet, (tag == SUMO_TAG_FLOW) ? GLO_FLOW : GLO_TRIP, tag,
304 {}, {}, {}, {}, {vehicleType}, {}, {}, {}, {}, {}),
306 myFromEdge(fromEdge),
307 myToEdge(toEdge) {
308  // recompute vehicle
309  compute();
310 }
311 
312 
313 GNEVehicle::GNEVehicle(GNEViewNet* viewNet, GNEDemandElement* vehicleType, GNEEdge* fromEdge, GNEEdge* toEdge, const SUMOVehicleParameter& vehicleParameters) :
314  GNEDemandElement(vehicleParameters.id, viewNet, (vehicleParameters.tag == SUMO_TAG_FLOW) ? GLO_FLOW : GLO_TRIP, vehicleParameters.tag,
315 {}, {}, {}, {}, {vehicleType}, {}, {}, {}, {}, {}),
316 SUMOVehicleParameter(vehicleParameters),
317 myFromEdge(fromEdge),
318 myToEdge(toEdge) {
319  // recompute vehicle
320  compute();
321 }
322 
323 
325 
326 
327 std::string
329  // obtain depart depending if is a Vehicle, trip or routeFlow
330  std::string departStr;
332  departStr = toString(depart);
333  } else {
334  departStr = getDepart();
335  }
336  // we need to handle depart as a tuple of 20 numbers (format: 000000...00<departTime>)
337  departStr.reserve(20 - departStr.size());
338  // add 0s at the beginning of departStr until we have 20 numbers
339  for (int i = (int)departStr.size(); i < 20; i++) {
340  departStr.insert(departStr.begin(), '0');
341  }
342  return departStr;
343 }
344 
345 
346 void
348  // obtain tag depending if tagProperty has a synonym
350  // attribute VType musn't be written if is DEFAULT_VTYPE_ID
351  if (getDemandElementParents().at(0)->getID() == DEFAULT_VTYPE_ID) {
352  // unset VType parameter
354  // write vehicle attributes (VType will not be written)
355  write(device, OptionsCont::getOptions(), synonymTag);
356  // set VType parameter again
358  } else {
359  // write vehicle attributes, including VType
360  write(device, OptionsCont::getOptions(), synonymTag, getDemandElementParents().at(0)->getID());
361  }
362  // write specific attribute depeding of tag property
364  // write manually route
366  }
367  // write from, to and edge vias
369  // write manually from/to edges (it correspond to fron and back edge parents)
370  device.writeAttr(SUMO_ATTR_FROM, getEdgeParents().front()->getID());
371  device.writeAttr(SUMO_ATTR_TO, getEdgeParents().back()->getID());
372  // only write via if there isn't empty
373  if (via.size() > 0) {
374  device.writeAttr(SUMO_ATTR_VIA, via);
375  }
376  }
377  // write specific routeFlow/flow attributes
379  // write routeFlow values depending if it was set
382  }
385  }
388  }
391  }
394  }
395  }
396  // write demand element children associated to this vehicle
397  for (const auto& i : getDemandElementChildren()) {
398  i->writeDemandElement(device);
399  }
400  // close vehicle tag
401  device.closeTag();
402 }
403 
404 
405 bool
407  // only trips or flows can have problems
409  // check if from and to are the same edges
410  if ((getEdgeParents().size() == 2) && (getEdgeParents().at(0) == getEdgeParents().at(1))) {
411  return true;
412  }
413  // check if exist at least a connection between every edge
414  for (int i = 1; i < (int)getEdgeParents().size(); i++) {
416  return false;
417  }
418  }
419  // there is connections bewteen all edges, then return true
420  return true;
421  } else {
422  return true;
423  }
424 }
425 
426 
427 std::string
429  // only trips or flows can have problems
431  // check if exist at least a connection between every edge
432  for (int i = 1; i < (int)getEdgeParents().size(); i++) {
434  return ("Edge '" + getEdgeParents().at((int)i - 1)->getID() + "' and edge '" + getEdgeParents().at(i)->getID() + "' aren't consecutives");
435  }
436  }
437  // there is connections bewteen all edges, then all ok
438  return "";
439  } else {
440  return "";
441  }
442 }
443 
444 
445 void
447 
448 }
449 
450 
451 GNEEdge*
453  if (getDemandElementParents().size() == 2) {
454  // oobtain edge of route
455  return getDemandElementParents().at(1)->getFromEdge();
456  } else if (getEdgeParents().size() > 0) {
457  return getEdgeParents().front();
458  } else if (getDemandElementChildren().size() > 0) {
459  // obtain edge of embedded route
460  return getDemandElementChildren().at(0)->getFromEdge();
461  } else {
462  throw ProcessError("Undefined from edge");
463  }
464 }
465 
466 
467 GNEEdge*
469  if (getDemandElementParents().size() == 2) {
470  // oobtain edge of route
471  return getDemandElementParents().at(1)->getToEdge();
472  } else if (getEdgeParents().size() > 0) {
473  return getEdgeParents().back();
474  } else if (getDemandElementChildren().size() > 0) {
475  // obtain edge of embedded route
476  return getDemandElementChildren().at(0)->getToEdge();
477  } else {
478  throw ProcessError("Undefined to edge");
479  }
480 }
481 
482 
485  return getDemandElementParents().front()->getVClass();
486 }
487 
488 
489 const RGBColor&
491  return color;
492 }
493 
494 
495 void
497  // only recompute flows and trips
498  if (myFromEdge && myToEdge) {
499  // declare a from-via-to edges vector
500  std::vector<std::string> FromViaToEdges;
501  // add from edge
502  FromViaToEdges.push_back(myFromEdge->getID());
503  // add via edges
504  FromViaToEdges.insert(FromViaToEdges.end(), via.begin(), via.end());
505  // add to edge
506  FromViaToEdges.push_back(myToEdge->getID());
507  // calculate route
508  std::vector<GNEEdge*> route = getRouteCalculatorInstance()->calculateDijkstraRoute(myViewNet->getNet(), getDemandElementParents().at(0)->getVClass(), FromViaToEdges);
509  // check if rute is valid
510  if (route.size() > 0) {
511  changeEdgeParents(this, route);
512  } else {
513  changeEdgeParents(this, getEdgeParents().front()->getID() + " " + toString(via) + " " + getEdgeParents().back()->getID());
514  }
515  // mark geometry as deprecated
517  // update geometry
518  updateGeometry();
519  }
520 }
521 
522 
523 void
525  // Vehicles cannot be moved
526 }
527 
528 
529 void
531  // Vehicles cannot be moved
532 }
533 
534 
535 void
537  // Vehicles cannot be moved
538 }
539 
540 
541 void
543  // Vehicles cannot be moved
544 }
545 
546 
547 void
549  // first check if geometry is deprecated
551  // clear geometry
553  // calculate depending if both from and to edges are the same
554  if (getEdgeParents().size() == 1) {
555  // obtain first allowed lane
556  GNELane* lane = getEdgeParents().front()->getLaneByVClass(getVClass());
557  // if there isn't allowed lane, then use first lane
558  if (lane == nullptr) {
559  lane = getEdgeParents().front()->getLanes().front();
560  }
561  // add lane geometry
562  for (int i = 0; i < ((int)lane->getGeometry().shape.size() - 1); i++) {
564  lane->getGeometry().shape[i],
565  lane->getGeometry().shapeLengths[i],
566  lane->getGeometry().shapeRotations[i], true, true);
567  }
568  } else {
569  // declare a matrix to save found connections
570  std::vector<std::vector<ConnectionGeometry> > connectionGeometryMatrix;
571  // iterate over edge parents
572  for (int i = 0; i < ((int)getEdgeParents().size() - 1); i++) {
573  // add a new connection vector in matrix
574  connectionGeometryMatrix.push_back(std::vector<ConnectionGeometry>());
575  // obtain NBEdges from both edges
576  NBEdge* nbFrom = getEdgeParents().at(i)->getNBEdge();
577  NBEdge* nbTo = getEdgeParents().at(i + 1)->getNBEdge();
578  // iterate over all connections of NBFrom
579  for (NBEdge::Connection c : nbFrom->getConnectionsFromLane(-1, nbTo, -1)) {
580  //check if given VClass is allowed for from and to lanes
581  if ((nbFrom->getPermissions(c.fromLane) & nbTo->getPermissions(c.toLane) & getVClass()) == getVClass()) {
582  // save connectionGeometry in Matrix
583  connectionGeometryMatrix.at(i).push_back(ConnectionGeometry(&c,
584  getEdgeParents().at(i)->getLanes().at(c.fromLane),
585  getEdgeParents().at(i + 1)->getLanes().at(c.toLane)));
586  }
587  }
588  }
589  // now filter connection geometry matrix
590  std::vector<ConnectionGeometry> connectionGeometriesFiltered;
591  // iterate over connection geometry matrix
592  for (int i = 0; i < (int)connectionGeometryMatrix.size(); i++) {
593  // declare two "columns" (only to improve code legibility)
594  const auto& currentColumn = connectionGeometryMatrix.at(i);
595  const auto& nextColumn = ((i + 1) < (int)connectionGeometryMatrix.size()) ? connectionGeometryMatrix.at(i + 1) : std::vector<ConnectionGeometry>();
596  // obtain two from and to lanes
597  const GNELane* laneFrom = getEdgeParents().at(i)->getLaneByVClass(getVClass());
598  const GNELane* laneTo = getEdgeParents().at(i + 1)->getLaneByVClass(getVClass());
599  // check if current matrix column has a connection geometry
600  if (currentColumn.empty()) {
601  // insert a connection Geometry without NBEdge::Connection
602  connectionGeometriesFiltered.push_back(ConnectionGeometry(laneFrom, laneTo));
603  } else if (currentColumn.size() == 1) {
604  // Nothing to filter
605  connectionGeometriesFiltered.push_back(currentColumn.front());
606  } else {
607  // declare a flag to stop loops
608  bool stop = false;
609  // iterate over all connections and take the first connection that have the same from and to edge
610  for (auto currentConnection = currentColumn.begin(); currentConnection != currentColumn.end() && !stop; currentConnection++) {
611  // obtain previous and next lanes
612  const GNELane* previousLane = (connectionGeometriesFiltered.size() > 0) ? connectionGeometriesFiltered.back().laneTo : nullptr;
613  // check if previous lane exist
614  if (previousLane) {
615  // first case: exist a previous lane. Then try to find a connection between previousLane and next connection
616  for (auto nextConnection = nextColumn.cbegin(); (nextConnection != nextColumn.cend()) && !stop; nextConnection++) {
617  if ((previousLane == currentConnection->laneFrom) && (currentConnection->laneTo == nextConnection->laneFrom)) {
618  connectionGeometriesFiltered.push_back(*currentConnection);
619  stop = true;
620  }
621  }
622  } else {
623  // first case: doesn't exist a previous lane. Then try to find a connection with next connection with the same lane
624  for (auto nextConnection = nextColumn.cbegin(); (nextConnection != nextColumn.cend()) && !stop; nextConnection++) {
625  if (currentConnection->laneTo == nextConnection->laneFrom) {
626  connectionGeometriesFiltered.push_back(*currentConnection);
627  stop = true;
628  }
629  }
630  }
631  }
632  // if none was found, insert a connection Geometry without NBEdge::Connection
633  if (!stop) {
634  connectionGeometriesFiltered.push_back(ConnectionGeometry(laneFrom, laneTo));
635  }
636  }
637  }
638  // now iterate over all filtered connections to calculate shape segments
639  for (auto connectionGeometry = connectionGeometriesFiltered.begin(); connectionGeometry != connectionGeometriesFiltered.end(); connectionGeometry++) {
640  // first calculate connection shape
641  connectionGeometry->calculateConnectionShape();
642  // check if this is the first geometry connection
643  if (connectionGeometry == connectionGeometriesFiltered.begin()) {
644  // obtain lane geometry
645  auto laneGeometry = (connectionGeometry->laneFrom) ? connectionGeometry->laneFrom->getGeometry() : getEdgeParents().at(0)->getLaneByVClass(getVClass())->getGeometry();
646  // add lane shape in segments geometry
647  for (int i = 0; i < (int)laneGeometry.shape.size(); i++) {
648  if (i < (int)laneGeometry.shape.size() - 1) {
650  laneGeometry.shape[i],
651  laneGeometry.shapeLengths[i],
652  laneGeometry.shapeRotations[i], true, true);
653  } else {
655  laneGeometry.shape[i], true, true);
656  }
657  }
658  }
659  // check if connection exist
660  if (connectionGeometry->con) {
661  // add connection shape in in segments geometry
662  for (const auto& connectionShapePos : connectionGeometry->connectionShape) {
663  myDemandElementSegmentGeometry.insertJunctionSegment(this, connectionGeometry->laneFrom->getParentEdge().getGNEJunctionDestiny(), connectionShapePos, true, true);
664  }
665  // add lane shape in segments geometry using laneTo of current correnction
666  for (int i = 0; i < (int)connectionGeometry->laneTo->getGeometry().shape.size(); i++) {
667  if (i < (int)connectionGeometry->laneTo->getGeometry().shape.size() - 1) {
668  myDemandElementSegmentGeometry.insertEdgeLengthRotSegment(this, &connectionGeometry->laneTo->getParentEdge(),
669  connectionGeometry->laneTo->getGeometry().shape[i],
670  connectionGeometry->laneTo->getGeometry().shapeLengths[i],
671  connectionGeometry->laneTo->getGeometry().shapeRotations[i], true, true);
672  } else {
673  myDemandElementSegmentGeometry.insertEdgeSegment(this, &connectionGeometry->laneTo->getParentEdge(),
674  connectionGeometry->laneTo->getGeometry().shape[i], true, true);
675  }
676  }
677  } else if ((connectionGeometry + 1) != connectionGeometriesFiltered.end()) {
678  // add lane shape in segments geometry using laneFrom of next connection
679  for (int i = 0; i < (int)(connectionGeometry + 1)->laneFrom->getGeometry().shape.size(); i++) {
680  if (i < (int)(connectionGeometry + 1)->laneFrom->getGeometry().shape.size() - 1) {
681  myDemandElementSegmentGeometry.insertEdgeLengthRotSegment(this, &(connectionGeometry + 1)->laneFrom->getParentEdge(),
682  (connectionGeometry + 1)->laneFrom->getGeometry().shape[i],
683  (connectionGeometry + 1)->laneFrom->getGeometry().shapeLengths[i],
684  (connectionGeometry + 1)->laneFrom->getGeometry().shapeRotations[i], true, true);
685  } else {
686  myDemandElementSegmentGeometry.insertEdgeSegment(this, &(connectionGeometry + 1)->laneFrom->getParentEdge(),
687  (connectionGeometry + 1)->laneFrom->getGeometry().shape[i], true, true);
688  }
689  }
690  } else {
691  // due this is the last shape, add lane shape in segments geometry using laneTo of current connection geometry
692  for (int i = 0; i < (int)connectionGeometry->laneTo->getGeometry().shape.size(); i++) {
693  if (i < (int)connectionGeometry->laneTo->getGeometry().shape.size() - 1) {
694  myDemandElementSegmentGeometry.insertEdgeLengthRotSegment(this, &connectionGeometry->laneTo->getParentEdge(),
695  connectionGeometry->laneTo->getGeometry().shape[i],
696  connectionGeometry->laneTo->getGeometry().shapeLengths[i],
697  connectionGeometry->laneTo->getGeometry().shapeRotations[i], true, true);
698  } else {
699  myDemandElementSegmentGeometry.insertEdgeSegment(this, &connectionGeometry->laneTo->getParentEdge(),
700  connectionGeometry->laneTo->getGeometry().shape[i], true, true);
701  }
702  }
703  }
704  }
705  }
706  // calculate entire shape, rotations and lengths
708  // update demand element childrens
709  for (const auto& i : getDemandElementChildren()) {
710  i->updateGeometry();
711  }
712  // set geometry as non-deprecated
714  }
715 }
716 
717 
718 Position
720  // obtain lane
721  GNELane* lane = getFromEdge()->getLanes().front();
722  // get position depending of lane's lenght
723  if (lane->getGeometry().shape.length() < 2.5) {
724  return lane->getGeometry().shape.front();
725  } else {
726  Position A = lane->getGeometry().shape.positionAtOffset(2.5);
727  Position B = lane->getGeometry().shape.positionAtOffset(2.5);
728  // return Middle point
729  return Position((A.x() + B.x()) / 2, (A.y() + B.y()) / 2);
730  }
731 }
732 
733 
737  // obtain all selected vehicles
738  std::vector<GNEDemandElement*> selectedDemandElements = myViewNet->getNet()->retrieveDemandElements(true);
739  std::vector<GNEVehicle*> selectedVehicles;
740  selectedVehicles.reserve(selectedDemandElements.size());
741  for (const auto& i : selectedDemandElements) {
742  if (i->getTagProperty().isVehicle()) {
743  selectedVehicles.push_back(dynamic_cast<GNEVehicle*>(i));
744  }
745  }
746  // return a GNESelectedVehiclesPopupMenu
747  return new GNESelectedVehiclesPopupMenu(this, selectedVehicles, app, parent);
748  } else {
749  // return a GNESingleVehiclePopupMenu
750  return new GNESingleVehiclePopupMenu(this, app, parent);
751  }
752 }
753 
754 
755 std::string
758  return getDemandElementParents().at(1)->getID();
759  } else if ((myTagProperty.getTag() == SUMO_TAG_TRIP) || (myTagProperty.getTag() == SUMO_TAG_FLOW)) {
760  return getEdgeParents().front()->getID();
761  } else {
762  throw ProcessError("Invalid vehicle tag");
763  }
764 }
765 
766 
767 Boundary
769  Boundary vehicleBoundary;
770  vehicleBoundary.add(getFromEdge()->getLanes().front()->getGeometry().shape.front());
771  vehicleBoundary.grow(20);
772  return vehicleBoundary;
773 }
774 
775 
776 void
778  // only drawn in super mode demand
780  // declare common attributes
781  const double exaggeration = s.vehicleSize.getExaggeration(s, this);
782  const double width = getDemandElementParents().at(0)->getAttributeDouble(SUMO_ATTR_WIDTH);
783  const double length = getDemandElementParents().at(0)->getAttributeDouble(SUMO_ATTR_LENGTH);
784  double vehicleSizeSquared = width * length * exaggeration * width * length * exaggeration;
785  // declare a flag to check if glPushName() / glPopName() has to be added (needed due GNEEdge::drawGL(...))
786  const bool pushName = (myTagProperty.getTag() != SUMO_TAG_FLOW) && (myTagProperty.getTag() != SUMO_TAG_TRIP);
787  // obtain Position an rotation (it depend of their parents)
788  Position vehiclePosition;
789  double vehicleRotation = 0;
790  if (getDemandElementParents().size() == 2) {
791  // obtain position and rotation of first edge route
792  vehiclePosition = getDemandElementParents().at(1)->getDemandElementSegmentGeometry().begin()->pos;
793  vehicleRotation = getDemandElementParents().at(1)->getDemandElementSegmentGeometry().begin()->rotation;
794  } else if (getEdgeParents().size() > 0) {
795  // obtain position and rotation of segments geometry
796  vehiclePosition = myDemandElementSegmentGeometry.begin()->pos;
797  vehicleRotation = myDemandElementSegmentGeometry.begin()->rotation;
798  } else if (getDemandElementChildren().size() > 0) {
799  // obtain position and rotation of embedded route
800  vehiclePosition = getDemandElementChildren().at(0)->getDemandElementSegmentGeometry().begin()->pos;
801  vehicleRotation = getDemandElementChildren().at(0)->getDemandElementSegmentGeometry().begin()->rotation;
802  }
803  // first check if if mouse is enought near to this vehicle to draw it
804  if (s.drawForSelecting && (myViewNet->getPositionInformation().distanceSquaredTo2D(vehiclePosition) >= (vehicleSizeSquared + 2))) {
805  // first push name
806  if (pushName) {
807  glPushName(getGlID());
808  }
809  // push draw matrix
810  glPushMatrix();
811  // translate to drawing position
812  glTranslated(vehiclePosition.x(), vehiclePosition.y(), GLO_ROUTE + getType() + 0.1);
813  glRotated(vehicleRotation, 0, 0, 1);
814  // extra translation needed to draw vehicle over edge (to avoid selecting problems)
815  glTranslated(0, (-1) * length, 0);
816  GLHelper::drawBoxLine(Position(0, 1), 0, 2, 1);
817  // Pop last matrix
818  glPopMatrix();
819  // pop name
820  if (pushName) {
821  glPopName();
822  }
823  } else {
825  // first push name
826  if (pushName) {
827  glPushName(getGlID());
828  }
829  // push draw matrix
830  glPushMatrix();
831  // translate to drawing position
832  glTranslated(vehiclePosition.x(), vehiclePosition.y(), GLO_ROUTE + getType() + 0.1);
833  glRotated(vehicleRotation, 0, 0, 1);
834  // extra translation needed to draw vehicle over edge (to avoid selecting problems)
835  glTranslated(0, (-1) * length, 0);
836  // set lane color
837  setColor(s);
838  double upscaleLength = exaggeration;
839  if ((exaggeration > 1) && (length > 5)) {
840  // reduce the length/width ratio because this is not usefull at high zoom
841  upscaleLength = MAX2(1.0, upscaleLength * (5 + sqrt(length - 5)) / length);
842  }
843  glScaled(exaggeration, upscaleLength, 1);
844  // check if we're drawing in selecting mode
845  if (s.drawForSelecting) {
846  // draw vehicle as a box and don't draw the rest of details
848  } else {
849  // draw the vehicle depending of detail level
850  if (s.drawDetail(s.detailSettings.vehicleShapes, exaggeration)) {
852  } else if (s.drawDetail(s.detailSettings.vehicleBoxes, exaggeration)) {
854  } else if (s.drawDetail(s.detailSettings.vehicleTriangles, exaggeration)) {
856  }
857 
858  /*
859  switch (s.vehicleQuality) {
860  case 0:
861  GUIBaseVehicleHelper::drawAction_drawVehicleAsTrianglePlus(width, length);
862  break;
863  case 1:
864  GUIBaseVehicleHelper::drawAction_drawVehicleAsBoxPlus(width, length);
865  break;
866  default:
867  GUIBaseVehicleHelper::drawAction_drawVehicleAsPoly(s, shape, width, length);
868  break;
869  }
870  */
871  // check if min gap has to be drawn
872  if (s.drawMinGap) {
873  const double minGap = -1 * getDemandElementParents().at(0)->getAttributeDouble(SUMO_ATTR_MINGAP);
874  glColor3d(0., 1., 0.);
875  glBegin(GL_LINES);
876  glVertex2d(0., 0);
877  glVertex2d(0., minGap);
878  glVertex2d(-.5, minGap);
879  glVertex2d(.5, minGap);
880  glEnd();
881  }
882  // drawing name at GLO_MAX fails unless translating z
883  glTranslated(0, MIN2(length / 2, double(5)), -getType());
884  glScaled(1 / exaggeration, 1 / upscaleLength, 1);
885  glRotated(-1 * vehicleRotation, 0, 0, 1);
887  // draw line
888  if (s.vehicleName.show && line != "") {
889  glTranslated(0, 0.6 * s.vehicleName.scaledSize(s.scale), 0);
890  GLHelper::drawTextSettings(s.vehicleName, "line:" + line, Position(0, 0), s.scale, s.angle);
891  }
892  }
893  // pop draw matrix
894  glPopMatrix();
895  // check if dotted contour has to be drawn
896  if (myViewNet->getDottedAC() == this) {
897  GLHelper::drawShapeDottedContourRectangle(s, getType(), vehiclePosition, width, length, vehicleRotation, 0, length / (-2));
898  }
899  // pop name
900  if (pushName) {
901  glPopName();
902  }
903  }
904  }
905 }
906 
907 
908 void
910  if (!myViewNet) {
911  throw ProcessError("ViewNet cannot be nullptr");
912  } else {
914  // add object of list into selected objects
916  if (changeFlag) {
917  mySelected = true;
918  }
919  }
920 }
921 
922 
923 void
925  if (!myViewNet) {
926  throw ProcessError("ViewNet cannot be nullptr");
927  } else {
929  // remove object of list of selected objects
931  if (changeFlag) {
932  mySelected = false;
933 
934  }
935  }
936 }
937 
938 
939 std::string
941  // declare string error
942  std::string error;
943  switch (key) {
944  case SUMO_ATTR_ID:
945  return getDemandElementID();
946  case SUMO_ATTR_TYPE:
947  return getDemandElementParents().at(0)->getID();
948  case SUMO_ATTR_COLOR:
949  if (wasSet(VEHPARS_COLOR_SET)) {
950  return toString(color);
951  } else {
953  }
956  return getDepartLane();
957  } else {
959  }
960  case SUMO_ATTR_DEPARTPOS:
962  return getDepartPos();
963  } else {
965  }
968  return getDepartSpeed();
969  } else {
971  }
974  return getArrivalLane();
975  } else {
977  }
980  return getArrivalPos();
981  } else {
983  }
986  return getArrivalSpeed();
987  } else {
989  }
990  case SUMO_ATTR_LINE:
991  if (wasSet(VEHPARS_LINE_SET)) {
992  return line;
993  } else {
995  }
998  return toString(personNumber);
999  } else {
1001  }
1004  return toString(containerNumber);
1005  } else {
1007  }
1008  case SUMO_ATTR_REROUTE:
1010  return "true";
1011  } else {
1012  return "false";
1013  }
1016  return getDepartPosLat();
1017  } else {
1019  }
1022  return getArrivalPosLat();
1023  } else {
1025  }
1026  // Specific of vehicles
1027  case SUMO_ATTR_DEPART:
1028  return toString(depart);
1029  case SUMO_ATTR_ROUTE:
1030  if (getDemandElementParents().size() == 2) {
1031  return getDemandElementParents().at(1)->getID();
1032  } else {
1033  return "";
1034  }
1035  // Specific of Trips
1036  case SUMO_ATTR_FROM:
1037  return getEdgeParents().front()->getID();
1038  case SUMO_ATTR_TO:
1039  return getEdgeParents().back()->getID();
1040  case SUMO_ATTR_VIA:
1041  return toString(via);
1042  // Specific of routeFlows
1043  case SUMO_ATTR_BEGIN:
1044  return time2string(depart);
1045  case SUMO_ATTR_END:
1046  return time2string(repetitionEnd);
1047  case SUMO_ATTR_VEHSPERHOUR:
1048  return toString(3600 / STEPS2TIME(repetitionOffset));
1049  case SUMO_ATTR_PERIOD:
1050  return time2string(repetitionOffset);
1051  case SUMO_ATTR_PROB:
1053  case SUMO_ATTR_NUMBER:
1054  return toString(repetitionNumber);
1055  //
1056  case GNE_ATTR_SELECTED:
1058  case GNE_ATTR_GENERIC:
1059  return getGenericParametersStr();
1060  default:
1061  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
1062  }
1063 }
1064 
1065 
1066 double
1068  return 0;
1069 }
1070 
1071 
1072 void
1073 GNEVehicle::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) {
1074  if (value == getAttribute(key)) {
1075  return; //avoid needless changes, later logic relies on the fact that attributes have changed
1076  }
1077  switch (key) {
1078  case SUMO_ATTR_ID:
1079  case SUMO_ATTR_TYPE:
1080  case SUMO_ATTR_COLOR:
1081  case SUMO_ATTR_DEPARTLANE:
1082  case SUMO_ATTR_DEPARTPOS:
1083  case SUMO_ATTR_DEPARTSPEED:
1084  case SUMO_ATTR_ARRIVALLANE:
1085  case SUMO_ATTR_ARRIVALPOS:
1087  case SUMO_ATTR_LINE:
1090  case SUMO_ATTR_REROUTE:
1093  // Specific of vehicles
1094  case SUMO_ATTR_DEPART:
1095  case SUMO_ATTR_ROUTE:
1096  // Specific of Trips
1097  case SUMO_ATTR_FROM:
1098  case SUMO_ATTR_TO:
1099  case SUMO_ATTR_VIA:
1100  //
1101  // Specific of routeFlows
1102  case SUMO_ATTR_BEGIN:
1103  case SUMO_ATTR_END:
1104  case SUMO_ATTR_NUMBER:
1105  case SUMO_ATTR_VEHSPERHOUR:
1106  case SUMO_ATTR_PERIOD:
1107  case SUMO_ATTR_PROB:
1108  //
1109  case GNE_ATTR_GENERIC:
1110  case GNE_ATTR_SELECTED:
1111  undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), key, value));
1112  break;
1113  default:
1114  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
1115  }
1116 }
1117 
1118 
1119 bool
1120 GNEVehicle::isValid(SumoXMLAttr key, const std::string& value) {
1121  // declare string error
1122  std::string error;
1123  switch (key) {
1124  case SUMO_ATTR_ID:
1125  // Vehicles, Trips and Flows share namespace
1127  (myViewNet->getNet()->retrieveDemandElement(SUMO_TAG_VEHICLE, value, false) == nullptr) &&
1128  (myViewNet->getNet()->retrieveDemandElement(SUMO_TAG_TRIP, value, false) == nullptr) &&
1129  (myViewNet->getNet()->retrieveDemandElement(SUMO_TAG_ROUTEFLOW, value, false) == nullptr) &&
1130  (myViewNet->getNet()->retrieveDemandElement(SUMO_TAG_FLOW, value, false) == nullptr)) {
1131  return true;
1132  } else {
1133  return false;
1134  }
1135  case SUMO_ATTR_TYPE:
1136  return SUMOXMLDefinitions::isValidTypeID(value) && (myViewNet->getNet()->retrieveDemandElement(SUMO_TAG_VTYPE, value, false) != nullptr);
1137  case SUMO_ATTR_COLOR:
1138  return canParse<RGBColor>(value);
1139  case SUMO_ATTR_DEPARTLANE: {
1140  int dummyDepartLane;
1141  DepartLaneDefinition dummyDepartLaneProcedure;
1142  parseDepartLane(value, toString(SUMO_TAG_VEHICLE), id, dummyDepartLane, dummyDepartLaneProcedure, error);
1143  // if error is empty, check if depart lane is correct
1144  if (error.empty()) {
1145  if (dummyDepartLaneProcedure != DEPART_LANE_GIVEN) {
1146  return true;
1147  } else {
1148  return dummyDepartLane < (int)getFromEdge()->getLanes().size();
1149  }
1150  } else {
1151  return false;
1152  }
1153  }
1154  case SUMO_ATTR_DEPARTPOS: {
1155  double dummyDepartPos;
1156  DepartPosDefinition dummyDepartPosProcedure;
1157  parseDepartPos(value, toString(SUMO_TAG_VEHICLE), id, dummyDepartPos, dummyDepartPosProcedure, error);
1158  // if error is empty, given value is valid
1159  return error.empty();
1160  }
1161  case SUMO_ATTR_DEPARTSPEED: {
1162  double dummyDepartSpeed;
1163  DepartSpeedDefinition dummyDepartSpeedProcedure;
1164  parseDepartSpeed(value, toString(SUMO_TAG_VEHICLE), id, dummyDepartSpeed, dummyDepartSpeedProcedure, error);
1165  // if error is empty, check if depart speed is correct
1166  if (error.empty()) {
1167  if (dummyDepartSpeedProcedure != DEPART_SPEED_GIVEN) {
1168  return true;
1169  } else {
1170  return (dummyDepartSpeed <= getDemandElementParents().at(0)->getAttributeDouble(SUMO_ATTR_MAXSPEED));
1171  }
1172  } else {
1173  return false;
1174  }
1175  }
1176  case SUMO_ATTR_ARRIVALLANE: {
1177  int dummyArrivalLane;
1178  ArrivalLaneDefinition dummyArrivalLaneProcedure;
1179  parseArrivalLane(value, toString(SUMO_TAG_VEHICLE), id, dummyArrivalLane, dummyArrivalLaneProcedure, error);
1180  // if error is empty, given value is valid
1181  return error.empty();
1182  }
1183  case SUMO_ATTR_ARRIVALPOS: {
1184  double dummyArrivalPos;
1185  ArrivalPosDefinition dummyArrivalPosProcedure;
1186  parseArrivalPos(value, toString(SUMO_TAG_VEHICLE), id, dummyArrivalPos, dummyArrivalPosProcedure, error);
1187  // if error is empty, given value is valid
1188  return error.empty();
1189  }
1190  case SUMO_ATTR_ARRIVALSPEED: {
1191  double dummyArrivalSpeed;
1192  ArrivalSpeedDefinition dummyArrivalSpeedProcedure;
1193  parseArrivalSpeed(value, toString(SUMO_TAG_VEHICLE), id, dummyArrivalSpeed, dummyArrivalSpeedProcedure, error);
1194  // if error is empty, given value is valid
1195  return error.empty();
1196  }
1197  case SUMO_ATTR_LINE:
1198  return true;
1200  return canParse<int>(value) && parse<int>(value) >= 0;
1202  return canParse<int>(value) && parse<int>(value) >= 0;
1203  case SUMO_ATTR_REROUTE:
1204  return true; // check
1205  case SUMO_ATTR_DEPARTPOS_LAT: {
1206  double dummyDepartPosLat;
1207  DepartPosLatDefinition dummyDepartPosLatProcedure;
1208  parseDepartPosLat(value, toString(SUMO_TAG_VEHICLE), id, dummyDepartPosLat, dummyDepartPosLatProcedure, error);
1209  // if error is empty, given value is valid
1210  return error.empty();
1211  }
1212  case SUMO_ATTR_ARRIVALPOS_LAT: {
1213  double dummyArrivalPosLat;
1214  ArrivalPosLatDefinition dummyArrivalPosLatProcedure;
1215  parseArrivalPosLat(value, toString(SUMO_TAG_VEHICLE), id, dummyArrivalPosLat, dummyArrivalPosLatProcedure, error);
1216  // if error is empty, given value is valid
1217  return error.empty();
1218  }
1219  // Specific of vehicles
1220  case SUMO_ATTR_DEPART: {
1221  SUMOTime dummyDepart;
1222  DepartDefinition dummyDepartProcedure;
1223  parseDepart(value, toString(SUMO_TAG_VEHICLE), id, dummyDepart, dummyDepartProcedure, error);
1224  // if error is empty, given value is valid
1225  return error.empty();
1226  }
1227  case SUMO_ATTR_ROUTE:
1228  if (getDemandElementParents().size() == 2) {
1229  return SUMOXMLDefinitions::isValidVehicleID(value) && (myViewNet->getNet()->retrieveDemandElement(SUMO_TAG_ROUTE, value, false) != nullptr);
1230  } else {
1231  return true;
1232  }
1233  // Specific of Trips
1234  case SUMO_ATTR_FROM:
1235  case SUMO_ATTR_TO:
1236  return SUMOXMLDefinitions::isValidNetID(value) && (myViewNet->getNet()->retrieveEdge(value, false) != nullptr);
1237  case SUMO_ATTR_VIA:
1238  if (value.empty()) {
1239  return true;
1240  } else {
1241  return canParse<std::vector<GNEEdge*> >(myViewNet->getNet(), value, false);
1242  }
1243  // Specific of routeFlows
1244  case SUMO_ATTR_BEGIN:
1245  if (canParse<double>(value)) {
1246  return (parse<double>(value) >= 0);
1247  } else {
1248  return false;
1249  }
1250  case SUMO_ATTR_END:
1251  if (value.empty()) {
1252  return true;
1253  } else if (canParse<double>(value)) {
1254  return (parse<double>(value) >= 0);
1255  } else {
1256  return false;
1257  }
1258  case SUMO_ATTR_VEHSPERHOUR:
1259  if (value.empty()) {
1260  return true;
1261  } else if (canParse<double>(value)) {
1262  return (parse<double>(value) > 0);
1263  } else {
1264  return false;
1265  }
1266  case SUMO_ATTR_PERIOD:
1267  if (value.empty()) {
1268  return true;
1269  } else if (canParse<double>(value)) {
1270  return (parse<double>(value) > 0);
1271  } else {
1272  return false;
1273  }
1274  case SUMO_ATTR_PROB:
1275  if (value.empty()) {
1276  return true;
1277  } else if (canParse<double>(value)) {
1278  return (parse<double>(value) >= 0);
1279  } else {
1280  return false;
1281  }
1282  case SUMO_ATTR_NUMBER:
1283  if (canParse<int>(value)) {
1284  return (parse<int>(value) >= 0);
1285  } else {
1286  return false;
1287  }
1288  //
1289  case GNE_ATTR_SELECTED:
1290  return canParse<bool>(value);
1291  case GNE_ATTR_GENERIC:
1292  return isGenericParametersValid(value);
1293  default:
1294  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
1295  }
1296 }
1297 
1298 
1299 void
1301  // obtain a copy of parameter sets
1302  int newParametersSet = parametersSet;
1303  // modify parametersSetCopy depending of attr
1304  switch (key) {
1305  case SUMO_ATTR_END: {
1306  // give more priority to end
1307  newParametersSet = VEHPARS_END_SET | VEHPARS_NUMBER_SET;
1308  break;
1309  }
1310  case SUMO_ATTR_NUMBER:
1311  newParametersSet ^= VEHPARS_END_SET;
1312  newParametersSet |= VEHPARS_NUMBER_SET;
1313  break;
1314  case SUMO_ATTR_VEHSPERHOUR: {
1315  // give more priority to end
1316  if ((newParametersSet & VEHPARS_END_SET) && (newParametersSet & VEHPARS_NUMBER_SET)) {
1317  newParametersSet = VEHPARS_END_SET;
1318  } else if (newParametersSet & VEHPARS_END_SET) {
1319  newParametersSet = VEHPARS_END_SET;
1320  } else if (newParametersSet & VEHPARS_NUMBER_SET) {
1321  newParametersSet = VEHPARS_NUMBER_SET;
1322  }
1323  // set VehsPerHour
1324  newParametersSet |= VEHPARS_VPH_SET;
1325  break;
1326  }
1327  case SUMO_ATTR_PERIOD: {
1328  // give more priority to end
1329  if ((newParametersSet & VEHPARS_END_SET) && (newParametersSet & VEHPARS_NUMBER_SET)) {
1330  newParametersSet = VEHPARS_END_SET;
1331  } else if (newParametersSet & VEHPARS_END_SET) {
1332  newParametersSet = VEHPARS_END_SET;
1333  } else if (newParametersSet & VEHPARS_NUMBER_SET) {
1334  newParametersSet = VEHPARS_NUMBER_SET;
1335  }
1336  // set period
1337  newParametersSet |= VEHPARS_PERIOD_SET;
1338  break;
1339  }
1340  case SUMO_ATTR_PROB: {
1341  // give more priority to end
1342  if ((newParametersSet & VEHPARS_END_SET) && (newParametersSet & VEHPARS_NUMBER_SET)) {
1343  newParametersSet = VEHPARS_END_SET;
1344  } else if (newParametersSet & VEHPARS_END_SET) {
1345  newParametersSet = VEHPARS_END_SET;
1346  } else if (newParametersSet & VEHPARS_NUMBER_SET) {
1347  newParametersSet = VEHPARS_NUMBER_SET;
1348  }
1349  // set probability
1350  newParametersSet |= VEHPARS_PROB_SET;
1351  break;
1352  }
1353  default:
1354  break;
1355  }
1356  // add GNEChange_EnableAttribute
1357  undoList->add(new GNEChange_EnableAttribute(this, myViewNet->getNet(), parametersSet, newParametersSet), true);
1358 }
1359 
1360 
1361 bool
1363  switch (key) {
1364  case SUMO_ATTR_END:
1365  return (parametersSet & VEHPARS_END_SET) != 0;
1366  case SUMO_ATTR_NUMBER:
1367  return (parametersSet & VEHPARS_NUMBER_SET) != 0;
1368  case SUMO_ATTR_VEHSPERHOUR:
1369  return (parametersSet & VEHPARS_VPH_SET) != 0;
1370  case SUMO_ATTR_PERIOD:
1371  return (parametersSet & VEHPARS_PERIOD_SET) != 0;
1372  case SUMO_ATTR_PROB:
1373  return (parametersSet & VEHPARS_PROB_SET) != 0;
1374  default:
1375  return true;
1376  };
1377 }
1378 
1379 
1380 std::string
1382  return getTagStr();
1383 }
1384 
1385 
1386 std::string
1388  // special case for Trips and flow
1390  // check if we're inspecting a Edge
1391  if (myViewNet->getNet()->getViewNet()->getDottedAC() &&
1393  // check if edge correspond to a "from", "to" or "via" edge
1394  if (getEdgeParents().front() == myViewNet->getNet()->getViewNet()->getDottedAC()) {
1395  return getTagStr() + ": " + getAttribute(SUMO_ATTR_ID) + " (from)";
1396  } else if (getEdgeParents().front() == myViewNet->getNet()->getViewNet()->getDottedAC()) {
1397  return getTagStr() + ": " + getAttribute(SUMO_ATTR_ID) + " (to)";
1398  } else {
1399  // iterate over via
1400  for (const auto& i : via) {
1401  if (i == myViewNet->getNet()->getViewNet()->getDottedAC()->getID()) {
1402  return getTagStr() + ": " + getAttribute(SUMO_ATTR_ID) + " (via)";
1403  }
1404  }
1405  }
1406  }
1407  }
1408  return getTagStr() + ": " + getAttribute(SUMO_ATTR_ID);
1409 }
1410 
1411 // ===========================================================================
1412 // protected
1413 // ===========================================================================
1414 
1415 
1417  con(_con),
1418  laneFrom(_laneFrom),
1419  laneTo(_laneTo) {
1420 }
1421 
1422 
1424  con(nullptr),
1425  laneFrom(_laneFrom),
1426  laneTo(_laneTo) {
1427 }
1428 
1429 
1430 void
1432  // only calculate shape if connection is valid
1433  if (con) {
1434  // get NBEdge from
1435  const NBEdge* NBEdgeFrom = laneFrom->getParentEdge().getNBEdge();
1436  // save connection shape in connectionShapes
1437  if (con->customShape.size() != 0) {
1439  } else if (NBEdgeFrom->getToNode()->getShape().area() > 4) {
1440  if (con->shape.size() != 0) {
1442  // only append via shape if it exists
1443  if (con->haveVia) {
1445  }
1446  } else {
1447  // Calculate shape so something can be drawn immidiately
1448  connectionShape = NBEdgeFrom->getToNode()->computeSmoothShape(
1451  5, NBEdgeFrom->getTurnDestination() == con->toEdge,
1452  (double) 5. * (double) NBEdgeFrom->getNumLanes(),
1453  (double) 5. * (double) con->toEdge->getNumLanes());
1454  }
1455  }
1456  }
1457 }
1458 
1459 
1461  con(nullptr),
1462  laneFrom(nullptr),
1463  laneTo(nullptr) {
1464 }
1465 
1466 
1467 void
1469  // change color
1470  if (drawUsingSelectColor()) {
1472  } else {
1473  // obtain vehicle color
1474  const GUIColorer& c = s.vehicleColorer;
1475  // set color depending of vehicle color active
1476  switch (c.getActive()) {
1477  case 0: {
1478  //test for emergency vehicle
1479  if (getDemandElementParents().at(0)->getAttribute(SUMO_ATTR_GUISHAPE) == "emergency") {
1481  break;
1482  }
1483  //test for firebrigade
1484  if (getDemandElementParents().at(0)->getAttribute(SUMO_ATTR_GUISHAPE) == "firebrigade") {
1486  break;
1487  }
1488  //test for police car
1489  if (getDemandElementParents().at(0)->getAttribute(SUMO_ATTR_GUISHAPE) == "police") {
1491  break;
1492  }
1493  if (wasSet(VEHPARS_COLOR_SET)) {
1495  break;
1496  }
1499  break;
1500  }
1503  } else {
1505  }
1506  break;
1507  }
1508  case 2: {
1509  if (wasSet(VEHPARS_COLOR_SET)) {
1511  } else {
1513  }
1514  break;
1515  }
1516  case 3: {
1517  if (getDemandElementParents().at(0)->isAttributeEnabled(SUMO_ATTR_COLOR)) {
1519  } else {
1521  }
1522  break;
1523  }
1524  case 4: {
1525  if (getDemandElementParents().at(1)->getColor() != RGBColor::DEFAULT_COLOR) {
1527  } else {
1529  }
1530  break;
1531  }
1532  case 5: {
1533  Position p = getDemandElementParents().at(1)->getEdgeParents().at(0)->getLanes().at(0)->getGeometry().shape[0];
1534  const Boundary& b = myViewNet->getNet()->getBoundary();
1535  Position center = b.getCenter();
1536  double hue = 180. + atan2(center.x() - p.x(), center.y() - p.y()) * 180. / M_PI;
1537  double sat = p.distanceTo(center) / center.distanceTo(Position(b.xmin(), b.ymin()));
1538  GLHelper::setColor(RGBColor::fromHSV(hue, sat, 1.));
1539  break;
1540  }
1541  case 6: {
1542  Position p = getDemandElementParents().at(1)->getEdgeParents().back()->getLanes().at(0)->getGeometry().shape[-1];
1543  const Boundary& b = myViewNet->getNet()->getBoundary();
1544  Position center = b.getCenter();
1545  double hue = 180. + atan2(center.x() - p.x(), center.y() - p.y()) * 180. / M_PI;
1546  double sat = p.distanceTo(center) / center.distanceTo(Position(b.xmin(), b.ymin()));
1547  GLHelper::setColor(RGBColor::fromHSV(hue, sat, 1.));
1548  break;
1549  }
1550  case 7: {
1551  Position pb = getDemandElementParents().at(1)->getEdgeParents().at(0)->getLanes().at(0)->getGeometry().shape[0];
1552  Position pe = getDemandElementParents().at(1)->getEdgeParents().back()->getLanes().at(0)->getGeometry().shape[-1];
1553  const Boundary& b = myViewNet->getNet()->getBoundary();
1554  double hue = 180. + atan2(pb.x() - pe.x(), pb.y() - pe.y()) * 180. / M_PI;
1555  Position minp(b.xmin(), b.ymin());
1556  Position maxp(b.xmax(), b.ymax());
1557  double sat = pb.distanceTo(pe) / minp.distanceTo(maxp);
1558  GLHelper::setColor(RGBColor::fromHSV(hue, sat, 1.));
1559  break;
1560  }
1561  case 29: { // color randomly (by pointer hash)
1562  std::hash<const GNEVehicle*> ptr_hash;
1563  const double hue = (double)(ptr_hash(this) % 360); // [0-360]
1564  const double sat = ((ptr_hash(this) / 360) % 67) / 100.0 + 0.33; // [0.33-1]
1565  GLHelper::setColor(RGBColor::fromHSV(hue, sat, 1.));
1566  break;
1567  }
1568  default: {
1570  }
1571  }
1572  }
1573 }
1574 
1575 
1576 std::string
1578  std::string result;
1579  // Generate an string using the following structure: "key1=value1|key2=value2|...
1580  for (auto i : getParametersMap()) {
1581  result += i.first + "=" + i.second + "|";
1582  }
1583  // remove the last "|"
1584  if (!result.empty()) {
1585  result.pop_back();
1586  }
1587  return result;
1588 }
1589 
1590 
1591 std::vector<std::pair<std::string, std::string> >
1593  std::vector<std::pair<std::string, std::string> > result;
1594  // iterate over parameters map and fill result
1595  for (auto i : getParametersMap()) {
1596  result.push_back(std::make_pair(i.first, i.second));
1597  }
1598  return result;
1599 }
1600 
1601 
1602 void
1603 GNEVehicle::setGenericParametersStr(const std::string& value) {
1604  // clear parameters
1605  clearParameter();
1606  // separate value in a vector of string using | as separator
1607  std::vector<std::string> parsedValues;
1608  StringTokenizer stValues(value, "|", true);
1609  while (stValues.hasNext()) {
1610  parsedValues.push_back(stValues.next());
1611  }
1612  // check that parsed values (A=B)can be parsed in generic parameters
1613  for (auto i : parsedValues) {
1614  std::vector<std::string> parsedParameters;
1615  StringTokenizer stParam(i, "=", true);
1616  while (stParam.hasNext()) {
1617  parsedParameters.push_back(stParam.next());
1618  }
1619  // Check that parsed parameters are exactly two and contains valid chracters
1620  if (parsedParameters.size() == 2 && SUMOXMLDefinitions::isValidGenericParameterKey(parsedParameters.front()) && SUMOXMLDefinitions::isValidGenericParameterValue(parsedParameters.back())) {
1621  setParameter(parsedParameters.front(), parsedParameters.back());
1622  }
1623  }
1624 }
1625 
1626 // ===========================================================================
1627 // private
1628 // ===========================================================================
1629 
1630 void
1631 GNEVehicle::setAttribute(SumoXMLAttr key, const std::string& value) {
1632  // declare string error
1633  std::string error;
1634  switch (key) {
1635  case SUMO_ATTR_ID:
1636  changeDemandElementID(value);
1637  // set manually vehicle ID (needed for saving)
1638  id = value;
1639  break;
1640  case SUMO_ATTR_TYPE:
1641  changeDemandElementParent(this, value, 0);
1642  // set manually vtypeID (needed for saving)
1643  vtypeid = value;
1644  break;
1645  case SUMO_ATTR_COLOR:
1646  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1647  color = parse<RGBColor>(value);
1648  // mark parameter as set
1650  } else {
1651  // set default value
1652  color = parse<RGBColor>(myTagProperty.getDefaultValue(key));
1653  // unset parameter
1655  }
1656  break;
1657  case SUMO_ATTR_DEPARTLANE:
1658  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1660  // mark parameter as set
1662  } else {
1663  // set default value
1665  // unset parameter
1667  }
1668  break;
1669  case SUMO_ATTR_DEPARTPOS:
1670  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1672  // mark parameter as set
1674  } else {
1675  // set default value
1677  // unset parameter
1679  }
1680  break;
1681  case SUMO_ATTR_DEPARTSPEED:
1682  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1684  // mark parameter as set
1686  } else {
1687  // set default value
1689  // unset parameter
1691  }
1692  break;
1693  case SUMO_ATTR_ARRIVALLANE:
1694  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1696  // mark parameter as set
1698  } else {
1699  // set default value
1701  // unset parameter
1703  }
1704  break;
1705  case SUMO_ATTR_ARRIVALPOS:
1706  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1708  // mark parameter as set
1710  } else {
1711  // set default value
1713  // unset parameter
1715  }
1716  break;
1718  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1720  // mark parameter as set
1722  } else {
1723  // set default value
1725  // unset parameter
1727  }
1728  break;
1729  case SUMO_ATTR_LINE:
1730  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1731  line = value;
1732  // mark parameter as set
1734  } else {
1735  // set default value
1737  // unset parameter
1739  }
1740  break;
1742  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1743  personNumber = parse<int>(value);
1744  // mark parameter as set
1746  } else {
1747  // set default value
1748  personNumber = parse<int>(myTagProperty.getDefaultValue(key));
1749  // unset parameter
1751  }
1752  break;
1754  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1755  containerNumber = parse<int>(value);
1756  // mark parameter as set
1758  } else {
1759  // set default value
1760  containerNumber = parse<int>(myTagProperty.getDefaultValue(key));
1761  // unset parameter
1763  }
1764  break;
1765  case SUMO_ATTR_REROUTE:
1766  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1767  // mark parameter as set
1769  } else {
1770  // unset parameter
1772  }
1773  break;
1775  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1777  // mark parameter as set
1779  } else {
1780  // set default value
1782  // unset parameter
1784  }
1785  break;
1787  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1789  // mark parameter as set
1791  } else {
1792  // set default value
1794  // unset parameter
1796  }
1798  break;
1799  // Specific of vehicles
1800  case SUMO_ATTR_DEPART: {
1801  std::string oldDepart = getBegin();
1803  myViewNet->getNet()->updateDemandElementBegin(oldDepart, this);
1804  break;
1805  }
1806  case SUMO_ATTR_ROUTE:
1807  if (getDemandElementParents().size() == 2) {
1808  changeDemandElementParent(this, value, 1);
1809  }
1810  break;
1811  // Specific of Trips and flow
1812  case SUMO_ATTR_FROM: {
1813  // update myFrom edge
1814  myFromEdge = myViewNet->getNet()->retrieveEdge(value);
1815  // compute path
1816  compute();
1817  break;
1818  }
1819  case SUMO_ATTR_TO: {
1820  // update myToEdge edge
1821  myToEdge = myViewNet->getNet()->retrieveEdge(value);
1822  // compute path
1823  compute();
1824  break;
1825  }
1826  case SUMO_ATTR_VIA: {
1827  if (!value.empty()) {
1828  // set new via edges
1829  via = parse< std::vector<std::string> >(value);
1830  // mark parameter as set
1832  } else {
1833  // clear via
1834  via.clear();
1835  // unset parameter
1837  }
1838  // compute path
1839  compute();
1840  break;
1841  }
1842  // Specific of routeFlows
1843  case SUMO_ATTR_BEGIN: {
1844  std::string oldBegin = getBegin();
1845  depart = string2time(value);
1846  myViewNet->getNet()->updateDemandElementBegin(oldBegin, this);
1847  break;
1848  }
1849  case SUMO_ATTR_END:
1850  repetitionEnd = string2time(value);
1851  break;
1852  case SUMO_ATTR_VEHSPERHOUR:
1853  repetitionOffset = TIME2STEPS(3600 / parse<double>(value));
1854  break;
1855  case SUMO_ATTR_PERIOD:
1856  repetitionOffset = string2time(value);
1857  break;
1858  case SUMO_ATTR_PROB:
1859  repetitionProbability = parse<double>(value);
1860  break;
1861  case SUMO_ATTR_NUMBER:
1862  repetitionNumber = parse<int>(value);
1863  break;
1864  //
1865  case GNE_ATTR_SELECTED:
1866  if (parse<bool>(value)) {
1868  } else {
1870  }
1871  break;
1872  case GNE_ATTR_GENERIC:
1873  setGenericParametersStr(value);
1874  break;
1875  default:
1876  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
1877  }
1878 }
1879 
1880 
1881 void
1882 GNEVehicle::setEnabledAttribute(const int enabledAttributes) {
1883  parametersSet = enabledAttributes;
1884 }
1885 
1886 /****************************************************************************/
bool mySelected
boolean to check if this AC is selected (instead of GUIGlObjectStorage)
const TagProperties & myTagProperty
the xml tag to which this attribute carrier corresponds
void compute()
compute demand element
Definition: GNEVehicle.cpp:496
bool hasTagSynonym() const
return true if tag correspond to an element that will be written in XML with another tag ...
std::string getParentName() const
Returns the name of the parent object.
Definition: GNEVehicle.cpp:756
std::vector< std::pair< std::string, std::string > > getGenericParameters() const
return generic parameters as vector of pairs format
Copy object name - popup entry.
Definition: GUIAppEnum.h:369
SUMOTime repetitionEnd
The time at which the flow ends (only needed when using repetitionProbability)
struct used for calculating routes
Definition: GNEVehicle.h:330
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:256
static const RGBColor BLUE
Definition: RGBColor.h:192
GUIGLObjectPopupMenu * getPopUpMenu(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own popup-menu.
Definition: GNEVehicle.cpp:735
double ymin() const
Returns minimum y-coordinate.
Definition: Boundary.cpp:131
std::vector< GNEEdge * > calculateDijkstraRoute(SUMOVehicleClass vClass, const std::vector< GNEEdge *> &partialEdges) const
calculate Dijkstra route between a list of partial edges
SumoXMLTag
Numbers representing SUMO-XML - element names.
void setGenericParametersStr(const std::string &value)
set generic parameters in string format
SUMOVehicleClass getVClass() const
obtain VClass related with this demand element
Definition: GNEVehicle.cpp:484
double xmax() const
Returns maximum x-coordinate.
Definition: Boundary.cpp:125
RGBColor color
The vehicle&#39;s color, TraCI may change this.
A structure which describes a connection between edges or lanes.
Definition: NBEdge.h:184
class used in GUIGLObjectPopupMenu for single vehicle transformations
Definition: GNEVehicle.h:85
static void transformToVehicle(GNEVehicle *originalVehicle, bool createEmbeddedRoute)
transform vehicle functions
GNEEdge * retrieveEdge(const std::string &id, bool failHard=true)
get edge by id
Definition: GNENet.cpp:1020
SumoXMLTag getTagSynonym() const
get tag synonym
long long int SUMOTime
Definition: SUMOTime.h:35
double scale
information about a lane&#39;s width (temporary, used for a single view)
void commitGeometryMoving(GNEUndoList *undoList)
commit geometry changes in the attributes of an element after use of moveGeometry(...)
Definition: GNEVehicle.cpp:542
description of a vehicle type
static bool parseArrivalPosLat(const std::string &val, const std::string &element, const std::string &id, double &pos, ArrivalPosLatDefinition &apd, std::string &error)
Validates a given arrivalPosLat value.
void addedLockedObject(const GUIGlObjectType type)
set object selected
PositionVector shape
The shape of the netElement element.
Definition: GNENetElement.h:57
GNEEdge * myFromEdge
from edge (used by flows and trips)
Definition: GNEVehicle.h:362
std::string next()
returns the next substring when it exists. Otherwise the behaviour is undefined
void append(const PositionVector &v, double sameThreshold=2.0)
NBEdge * toEdge
The edge the connections yields in.
Definition: NBEdge.h:206
FXMenuCommand * myTransformToTrip
menu command for transform to trip
Definition: GNEVehicle.h:127
std::string vtypeid
The vehicle&#39;s type id.
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
static void drawAction_drawVehicleAsBoxPlus(const double width, const double length)
draw vehicle as a Box
GUIVisualizationTextSettings personName
a flow definitio nusing a from-to edges instead of a route (used by router)
void startGeometryMoving()
Definition: GNEVehicle.cpp:524
ArrivalLaneDefinition
Possible ways to choose the arrival lane.
RGBColor selectedVehicleColor
vehicle selection color
ArrivalLaneDefinition arrivalLaneProcedure
Information how the vehicle shall choose the lane to arrive on.
static RGBColor fromHSV(double h, double s, double v)
Converts the given hsv-triplet to rgb, inspired by http://alvyray.com/Papers/CG/hsv2rgb.htm.
Definition: RGBColor.cpp:299
static const RGBColor WHITE
Definition: RGBColor.h:197
void moveGeometry(const Position &offset)
change the position of the element geometry without saving in undoList
Definition: GNEVehicle.cpp:536
a flow definition nusing a route instead of a from-to edges route (used in NETEDIT) ...
const int VEHPARS_PROB_SET
Stores the information about how to visualize structures.
std::string getArrivalSpeed() const
obtain arrival speed parameter in string format
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
void select(GUIGlID id, bool update=true)
Adds the object with the given id.
GNEViewParent * getViewParent() const
get the net object
Definition: GNEViewNet.cpp:921
double y() const
Returns the y-position.
Definition: Position.h:62
void endGeometryMoving()
end geometry movement
Definition: GNEVehicle.cpp:530
void fixDemandElementProblem()
fix demand element problem (by default throw an exception, has to be reimplemented in children) ...
Definition: GNEVehicle.cpp:446
const std::string & getDefaultValue(SumoXMLAttr attr) const
return the default value of the attribute of an element
The representation of a single edge during network building.
Definition: NBEdge.h:86
void writeDemandElement(OutputDevice &device) const
writte demand element element into a xml file
Definition: GNEVehicle.cpp:347
bool geometryDeprecated
mark geometry as deprecated (used to avoid multiple updates)
double repetitionProbability
The probability for emitting a vehicle per second.
static void transformToTrip(GNEVehicle *originalVehicle)
transform to trip
class used in GUIGLObjectPopupMenu for single vehicle transformations
Definition: GNEVehicle.h:40
static void drawTextSettings(const GUIVisualizationTextSettings &settings, const std::string &text, const Position &pos, const double scale, const double angle=0, const double layer=2048)
Definition: GLHelper.cpp:701
FXMenuCommand * myTransformToFlow
menu command for transform to flow
Definition: GNEVehicle.h:130
int parametersSet
Information for the router which parameter were set, TraCI may modify this (whe changing color) ...
std::string time2string(SUMOTime t)
Definition: SUMOTime.cpp:65
GUIVisualizationTextSettings vehicleName
double x() const
Returns the x-position.
Definition: Position.h:57
const RGBColor & getColor() const
get color
Definition: GNEVehicle.cpp:490
std::string getArrivalPosLat() const
obtain arrival pos lat parameter in string format
ArrivalPosLatDefinition arrivalPosLatProcedure
Information how the vehicle shall choose the lateral arrival position.
void setEnabledAttribute(const int enabledAttributes)
method for enabling the attribute and nothing else (used in GNEChange_EnableAttribute) ...
void insertEdgeLengthRotSegment(const GNEDemandElement *element, const GNEEdge *edge, const Position pos, double length, double rotation, const bool visible, const bool valid)
insert edge segment with length and rotation (used to avoid unnecessary calculation in calculateParti...
void buildCenterPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to center to the object.
weights: time range begin
double arrivalPosLat
(optional) The lateral position the vehicle shall arrive on
bool drawDetail(const double detail, const double exaggeration) const
check if details can be drawn for the given GUIVisualizationDetailSettings and current scale and exxa...
T MAX2(T a, T b)
Definition: StdDefs.h:80
std::string getDepartPosLat() const
obtain depart pos lat parameter in string format
NBEdge * getTurnDestination(bool possibleDestination=false) const
Definition: NBEdge.cpp:3116
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:46
const int VEHPARS_ARRIVALLANE_SET
void setColor(const GUIVisualizationSettings &s) const
sets the color according to the currente settings
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
FXMenuCommand * myTransformToVehicleWithEmbeddedRoute
menu command for transform to vehicle with an embedded route
Definition: GNEVehicle.h:69
ArrivalSpeedDefinition arrivalSpeedProcedure
Information how the vehicle&#39;s end speed shall be chosen.
void changeDemandElementID(const std::string &newID)
change ID of demand element
#define TIME2STEPS(x)
Definition: SUMOTime.h:59
void buildShowParamsPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to open the parameter window.
bool hasNext()
returns the information whether further substrings exist
std::string getDemandElementProblem() const
return a string with the current demand element problem (by default empty, can be reimplemented in ch...
Definition: GNEVehicle.cpp:428
DepartPosLatDefinition
GNESelectedVehiclesPopupMenu()
default constructor needed by FOX
Definition: GNEVehicle.h:105
ArrivalPosLatDefinition
Possible ways to choose the departure position.
const Boundary & getBoundary() const
returns the bounder of the network
Definition: GNENet.cpp:186
GNEVehicle(SumoXMLTag tag, GNEViewNet *viewNet, const std::string &vehicleID, GNEDemandElement *vehicleType, GNEDemandElement *route)
default constructor for vehicles and routeFlows without embedded routes
Definition: GNEVehicle.cpp:261
const int VEHPARS_NUMBER_SET
const std::string DEFAULT_VTYPE_ID
static bool isValidGenericParameterKey(const std::string &value)
whether the given string is a valid key for a generic parameter
void buildPositionCopyEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to copy the cursor position if geo projection is used, also builds an entry for copying the geo-position.
generic attribute
SumoXMLTag myVehicleTag
tag of clicked vehicle
Definition: GNEVehicle.h:112
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:42
static RouteCalculator * getRouteCalculatorInstance()
obtain instance of RouteCalculator
PositionVector customShape
custom shape for connection
Definition: NBEdge.h:233
begin/end of the description of a route
static const double vehicleShapes
details for draw person as shapes
GNEEdge * getToEdge() const
obtain to edge of this demand element
Definition: GNEVehicle.cpp:468
The speed is given.
SUMOTime repetitionOffset
The time offset between vehicle reinsertions.
std::string getHierarchyName() const
get Hierarchy Name (Used in AC Hierarchy)
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:58
const std::vector< GNEEdge * > & getEdgeParents() const
get edge parents
The lane is given.
friend class GNEChange_EnableAttribute
const std::vector< GNEDemandElement * > & getDemandElementChildren() const
return vector of demand elements that have as Parent this edge (For example, Calibrators) ...
const int VEHPARS_ARRIVALSPEED_SET
double area() const
Returns the area (0 for non-closed)
static void transformToFlow(GNEVehicle *originalVehicle)
transform to flow
PositionVector shape
shape of Connection
Definition: NBEdge.h:239
GUIColorer vehicleColorer
The vehicle colorer.
FXMenuCommand * myTransformToFlow
menu command for transform to flow
Definition: GNEVehicle.h:81
const GNELane * laneFrom
lane from
Definition: GNEVehicle.h:348
long onCmdTransform(FXObject *obj, FXSelector, void *)
Called to transform the current vehicle to another vehicle type.
Definition: GNEVehicle.cpp:129
void p_add(GNEChange_Attribute *cmd)
special method, avoid empty changes, always execute
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
method for setting the attribute and letting the object perform demand element changes ...
NBEdge * getNBEdge() const
returns the internal NBEdge
Definition: GNEEdge.cpp:625
double departSpeed
(optional) The initial speed of the vehicle
SUMOVehicleParameter()
Constructor.
bool drawUsingSelectColor() const
check if attribute carrier must be drawn using selecting color.
static void drawAction_drawVehicleAsTrianglePlus(const double width, const double length)
draw vehicle as a triangle
const GNELane * laneTo
lane to
Definition: GNEVehicle.h:351
GNEVehicle * myVehicle
current vehicle
Definition: GNEVehicle.h:63
std::vector< double > shapeRotations
The rotations of the single shape parts.
Definition: GNENetElement.h:60
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle&#39;s initial speed shall be chosen.
LockGLObjectTypes * getLockGLObjectTypes() const
get selected items Modul
static bool isValidGenericParameterValue(const std::string &value)
whether the given string is a valid value for a generic parameter
DepartLaneDefinition
Possible ways to choose a lane on depart.
GUIGlObjectType getType() const
Returns the type of the object as coded in GUIGlObjectType.
std::vector< GNEDemandElement * > retrieveDemandElements(bool onlySelected=false) const
return all demand elements
Definition: GNENet.cpp:2278
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:48
SumoXMLTag getTag() const
get Tag vinculated with this attribute Property
static void setColor(const RGBColor &c)
Sets the gl-color to this value.
Definition: GLHelper.cpp:616
GNEEdge & getParentEdge()
Returns underlying parent edge.
Definition: GNELane.cpp:1292
FXMenuCommand * myTransformAllVehiclesToRouteFlow
menu command for transform all selected vehicles to route flow
Definition: GNEVehicle.h:139
std::string routeid
The vehicle&#39;s route id.
DepartPosDefinition departPosProcedure
Information how the vehicle shall choose the departure position.
GNEDemandElement * retrieveDemandElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named demand element.
Definition: GNENet.cpp:2266
const int VEHPARS_DEPARTSPEED_SET
int getNumLanes() const
Returns the number of lanes.
Definition: NBEdge.h:465
std::string getDepartPos() const
obtain depart pos parameter in string format
const NBEdge::Connection * con
Pointer to NBEdge::Connection.
Definition: GNEVehicle.h:345
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:39
DemandElementSegmentGeometry myDemandElementSegmentGeometry
demand element segment geometry
std::string getAttribute(SumoXMLAttr key) const
Definition: GNEVehicle.cpp:940
Supermode currentSupermode
the current supermode
double scaledSize(double scale, double constFactor=0.1) const
get scale size
bool drawMinGap
Information whether the minimum gap shall be drawn.
static bool isGenericParametersValid(const std::string &value)
check if given string can be parsed to a map/list of generic parameters
void removeLockedObject(const GUIGlObjectType type)
set object unselected
static const RGBColor DEFAULT_COLOR
The default color (for vehicle types and vehicles)
Definition: RGBColor.h:204
FXMenuCommand * myTransformToRouteFlowWithEmbeddedRoute
menu command for transform to route flow with an embedded route
Definition: GNEVehicle.h:75
GNEEdge * getFromEdge() const
Definition: GNEVehicle.cpp:452
friend class GNEChange_Attribute
declare friend class
std::string getArrivalPos() const
obtain arrival pos parameter in string format
bool isAttributeEnabled(SumoXMLAttr key) const
void changeDemandElementParent(GNEShape *shapeTobeChanged, const std::string &newDemandElementParentID, int demandElementParentIndex)
change first demand element parent of a shape
std::string getPopUpID() const
get PopPup ID (Used in AC Hierarchy)
const int VEHPARS_DEPARTPOSLAT_SET
FXMenuCommand * myTransformToRouteFlowWithEmbeddedRoute
menu command for transform to route flow with an embedded route
Definition: GNEVehicle.h:124
#define STEPS2TIME(x)
Definition: SUMOTime.h:57
void calculatePartialShapeRotationsAndLengths()
calculate partial shape, rotations and lengths
const std::vector< GNELane * > & getLanes() const
returns a reference to the lane vector
Definition: GNEEdge.cpp:840
DepartDefinition departProcedure
Information how the vehicle shall choose the depart time.
SUMOTime string2time(const std::string &r)
Definition: SUMOTime.cpp:42
void write(OutputDevice &dev, const OptionsCont &oc, const SumoXMLTag tag=SUMO_TAG_VEHICLE, const std::string &typeID="") const
Writes the parameters as a beginning element.
const std::string & getDemandElementID() const
returns DemandElement ID
T MIN2(T a, T b)
Definition: StdDefs.h:74
long onCmdTransform(FXObject *obj, FXSelector, void *)
Called to transform the current vehicle to another vehicle type.
Definition: GNEVehicle.cpp:219
double xmin() const
Returns minimum x-coordinate.
Definition: Boundary.cpp:119
void drawName(const Position &pos, const double scale, const GUIVisualizationTextSettings &settings, const double angle=0) const
draw name of item
FXMenuCommand * myTransformToRouteFlow
menu command for transform to route flow
Definition: GNEVehicle.h:121
const int VEHPARS_ROUTE_SET
void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
GNESelectorFrame * getSelectorFrame() const
get frame for GNE_NMODE_SELECT
transform vehicle to another vehicle type (ej: flow to trip)
Definition: GUIAppEnum.h:935
Boundary & grow(double by)
extends the boundary by the given amount
Definition: Boundary.cpp:301
static bool parseArrivalLane(const std::string &val, const std::string &element, const std::string &id, int &lane, ArrivalLaneDefinition &ald, std::string &error)
Validates a given arrivalLane value.
FXMenuCommand * myTransformToTrip
menu command for transform to trip
Definition: GNEVehicle.h:78
void insertEdgeSegment(const GNEDemandElement *element, const GNEEdge *edge, const Position pos, const bool visible, const bool valid)
insert edge segment
const std::string getID() const
function to support debugging
double angle
The current view rotation angle.
PositionVector connectionShape
calculated connection shape
Definition: GNEVehicle.h:342
void clearDemandElementSegmentGeometry()
clear demand element geometry
const NetElementGeometry & getGeometry() const
const T getColor(const double value) const
void unselectAttributeCarrier(bool changeFlag=true)
unselect attribute carrier using GUIGlobalSelection
Definition: GNEVehicle.cpp:924
const int VEHPARS_PERIOD_SET
std::vector< GNEVehicle * > mySelectedVehicles
current selected vehicles
Definition: GNEVehicle.h:109
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
Definition: GNEVehicle.cpp:768
const int VEHPARS_COLOR_SET
int personNumber
The static number of persons in the vehicle when it departs (not including boarding persons) ...
static const double vehicleBoxes
details for draw person as boxes
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
Definition: NBEdge.cpp:3441
std::string getArrivalLane() const
obtain arrival lane parameter in string format
~GNEVehicle()
destructor
Definition: GNEVehicle.cpp:324
std::vector< double > shapeLengths
The lengths of the single shape parts.
Definition: GNENetElement.h:63
const int VEHPARS_END_SET
int departLane
(optional) The lane the vehicle shall depart from (index in edge)
std::string line
The vehicle&#39;s line (mainly for public transport)
const GNEViewNetHelper::NetworkViewOptions & getNetworkViewOptions() const
get network view options
Definition: GNEViewNet.cpp:411
begin/end of the description of an edge
double arrivalPos
(optional) The position the vehicle shall arrive on
DepartSpeedDefinition
Possible ways to choose the departure speed.
static void drawAction_drawVehicleAsPoly(const GUIVisualizationSettings &s, const SUMOVehicleShape shape, const double width, const double length, int carriageIndex=-1)
draw vehicle as a polygon
bool areEdgesConsecutives(SUMOVehicleClass vClass, GNEEdge *from, GNEEdge *to) const
check if exist a route between the two given consecutives edges
static bool isValidNetID(const std::string &value)
whether the given string is a valid id for a network element
const PositionVector & getShape() const
retrieve the junction shape
Definition: NBNode.cpp:2143
const int VEHPARS_VIA_SET
bool isAttributeCarrierSelected() const
check if attribute carrier is selected
void selectAttributeCarrier(bool changeFlag=true)
inherited from GNEAttributeCarrier
Definition: GNEVehicle.cpp:909
std::vector< std::string > via
List of the via-edges the vehicle must visit.
static void drawShapeDottedContourRectangle(const GUIVisualizationSettings &s, const int type, const Position &center, const double width, const double height, const double rotation=0, const double offsetX=0, const double offsetY=0)
draw a dotted contour around the given Position with certain width and height
Definition: GLHelper.cpp:555
const int VEHPARS_ARRIVALPOSLAT_SET
double departPosLat
(optional) The lateral position the vehicle shall depart from
const int VEHPARS_LINE_SET
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:50
GUIVisualizationDetailSettings detailSettings
detail settings
const int VEHPARS_ARRIVALPOS_SET
const std::vector< GNEDemandElement * > & getDemandElementParents() const
return vector of demand elements that have as Parent this edge (For example, Calibrators) ...
static const double vehicleTriangles
details for draw person as triangles
bool showNonInspectedDemandElements(const GNEDemandElement *demandElement) const
check if non inspected element has to be hidden
void enableAttribute(SumoXMLAttr key, GNEUndoList *undoList)
ConnectionGeometry()
default constructor (by default unused)
double departPos
(optional) The position the vehicle shall depart from
void updateDemandElementBegin(const std::string &oldBegin, GNEDemandElement *demandElement)
update demand element begin in container
Definition: GNENet.cpp:2328
bool showDemandElements() const
check if show demand elements checkbox is enabled
static const RGBColor RED
named colors
Definition: RGBColor.h:190
FXMenuCommand * myTransformAllVehiclesToTrip
menu command for transform all selected vehicles to trip
Definition: GNEVehicle.h:145
Structure representing possible vehicle parameter.
void deselect(GUIGlID id)
Deselects the object with the given id.
void buildSelectionACPopupEntry(GUIGLObjectPopupMenu *ret, GNEAttributeCarrier *AC)
Builds an entry which allows to (de)select the object.
Definition: GNEViewNet.cpp:331
double length() const
Returns the length.
static void transformToRouteFlow(GNEVehicle *originalVehicle, bool createEmbeddedRoute)
transform routeFlow over an existent route
std::string getDepartLane() const
obtain depart lane parameter in string format
double getAttributeDouble(SumoXMLAttr key) const
SUMOVehicleShape
Definition of vehicle classes to differ between different appearences.
PositionVector viaShape
shape of via
Definition: NBEdge.h:251
void updateGeometry()
update pre-computed geometry information
Definition: GNEVehicle.cpp:548
#define M_PI
Definition: odrSpiral.cpp:40
const GNEViewNetHelper::DemandViewOptions & getDemandViewOptions() const
get demand view options
Definition: GNEViewNet.cpp:417
static bool parseDepartPos(const std::string &val, const std::string &element, const std::string &id, double &pos, DepartPosDefinition &dpd, std::string &error)
Validates a given departPos value.
const GNEAttributeCarrier * getDottedAC() const
get AttributeCarrier under cursor
Definition: GNEViewNet.cpp:939
const std::string & getTagStr() const
get tag assigned to this object in string format
weights: time range end
Demanding mode (Routes, Vehicles etc..)
static bool parseDepartPosLat(const std::string &val, const std::string &element, const std::string &id, double &pos, DepartPosLatDefinition &dpd, std::string &error)
Validates a given departPosLat value.
static bool parseArrivalSpeed(const std::string &val, const std::string &element, const std::string &id, double &speed, ArrivalSpeedDefinition &asd, std::string &error)
Validates a given arrivalSpeed value.
FXMenuCommand * myTransformAllVehiclesToVehicleWithEmbeddedRoute
menu command for transform all selected vehicles to vehicle with an embedded route ...
Definition: GNEVehicle.h:136
element is selected
SumoXMLTag tag
The vehicle tag.
a routeFlow
FXMenuCommand * myTransformAllVehiclesToRouteFlowWithEmbeddedRoute
menu command for transform all selected vehicles to route flow with an embedded route ...
Definition: GNEVehicle.h:142
const int VEHPARS_DEPARTLANE_SET
The popup menu of a globject.
std::string getBegin() const
get begin time of demand element
Definition: GNEVehicle.cpp:328
static bool parseArrivalPos(const std::string &val, const std::string &element, const std::string &id, double &pos, ArrivalPosDefinition &apd, std::string &error)
Validates a given arrivalPos value.
double distanceSquaredTo2D(const Position &p2) const
returns the square of the distance to another position (Only using x and y positions) ...
Definition: Position.h:249
int containerNumber
The static number of containers in the vehicle when it departs.
static bool parseDepartSpeed(const std::string &val, const std::string &element, const std::string &id, double &speed, DepartSpeedDefinition &dsd, std::string &error)
Validates a given departSpeed value.
std::string getDepartSpeed() const
obtain depart speed parameter in string format
GNENet * getNet() const
get the net object
Definition: GNEViewNet.cpp:927
bool isDemandElementValid() const
check if current demand element is valid to be writed into XML (by default true, can be reimplemented...
Definition: GNEVehicle.cpp:406
const std::map< std::string, std::string > & getParametersMap() const
Returns the inner key/value map.
bool wasSet(int what) const
Returns whether the given parameter was set.
GNEEdge * myToEdge
to edge (used by flows and trips)
Definition: GNEVehicle.h:365
GUIGlID getGlID() const
Returns the numerical id of the object.
Position getCenter() const
Returns the center of the boundary.
Definition: Boundary.cpp:113
const int VEHPARS_VTYPE_SET
std::vector< Connection > getConnectionsFromLane(int lane, NBEdge *to=nullptr, int toLane=-1) const
Returns connections from a given lane.
Definition: NBEdge.cpp:1127
description of a vehicle
void insertMenuPaneChild(FXMenuPane *child)
Insert a sub-menu pane in this GUIGLObjectPopupMenu.
void changeEdgeParents(GNEShape *elementChild, const std::string &newEdgeIDs)
change edge parents of a shape
FXMenuCommand * myTransformToVehicleWithEmbeddedRoute
menu command for transform to vehicle with an embedded route
Definition: GNEVehicle.h:118
GNEViewNet * myViewNet
The GNEViewNet this demand element element belongs.
std::string getGenericParametersStr() const
return generic parameters in string format
SUMOVehicleShape getVehicleShapeID(const std::string &name)
Returns the class id of the shape class given by its name.
GNEViewNet * getViewNet() const
Returns a pointer to GNEViewNet in which demand element element is located.
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:64
double distanceTo(const Position &p2) const
returns the euclidean distance in 3 dimension
Definition: Position.h:234
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
const TagProperties & getTagProperty() const
get Tag Property assigned to this object
std::vector< Segment >::const_iterator begin() const
begin iterator
ArrivalPosDefinition
Possible ways to choose the arrival position.
void calculateConnectionShape()
calculate connection shape (note: Only calculated if &#39;con&#39; isn&#39;t nullptr)
Position getPositionInformation() const
Returns the cursor&#39;s x/y position within the network.
GUIVisualizationColorSettings colorSettings
color settings
GUIVisualizationSizeSettings vehicleSize
const int VEHPARS_VPH_SET
double arrivalSpeed
(optional) The final speed of the vehicle (not used yet)
a single trip definition (used by router)
std::string getDepart() const
obtain depart parameter in string format
static bool isValidTypeID(const std::string &value)
whether the given string is a valid id for an edge or vehicle type
const int VEHPARS_DEPARTPOS_SET
static void drawBoxLine(const Position &beg, double rot, double visLength, double width, double offset=0)
Draws a thick line.
Definition: GLHelper.cpp:136
Position getPositionInView() const
Returns position of demand element in view.
Definition: GNEVehicle.cpp:719
const int VEHPARS_PERSON_NUMBER_SET
ArrivalSpeedDefinition
Possible ways to choose the arrival speed.
FXMenuCommand * myTransformToVehicle
menu command for transform to vehicle
Definition: GNEVehicle.h:66
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
Definition: Boundary.cpp:79
FXMenuCommand * myTransformAllVehiclesToFlow
menu command for transform all selected vehicles to flow
Definition: GNEVehicle.h:148
FXMenuCommand * myTransformToVehicle
menu command for transform to vehicle
Definition: GNEVehicle.h:115
bool haveVia
check if Connection have a Via
Definition: NBEdge.h:245
bool isValid(SumoXMLAttr key, const std::string &value)
method for checking if the key and their conrrespond attribute are valids
bool drawForSelecting
whether drawing is performed for the purpose of selecting objects
const GNEViewNetHelper::EditModes & getEditModes() const
get edit modes
Definition: GNEViewNet.cpp:399
double ymax() const
Returns maximum y-coordinate.
Definition: Boundary.cpp:137
double getExaggeration(const GUIVisualizationSettings &s, const GUIGlObject *o, double factor=20) const
return the drawing size including exaggeration and constantSize values
DepartPosDefinition
Possible ways to choose the departure position.
FXDEFMAP(GNEVehicle::GNESingleVehiclePopupMenu) GNESingleVehiclePopupMenuMap[]
const int VEHPARS_CONTAINER_NUMBER_SET
PositionVector computeSmoothShape(const PositionVector &begShape, const PositionVector &endShape, int numPoints, bool isTurnaround, double extrapolateBeg, double extrapolateEnd, NBNode *recordError=0, int shapeFlag=0) const
Compute a smooth curve between the given geometries.
Definition: NBNode.cpp:504
Position positionAtOffset(double pos, double lateralOffset=0) const
Returns the position at the given length.
GUISelectedStorage gSelected
A global holder of selected objects.
Copy typed object name - popup entry.
Definition: GUIAppEnum.h:371
A color information.
static FXIcon * getIcon(GUIIcon which)
returns a icon previously defined in the enum GUIIcon
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
Definition: GNEVehicle.cpp:777
FXMenuCommand * myTransformAllVehiclesToVehicle
menu command for transform all selected vehicles to vehicle
Definition: GNEVehicle.h:133
NBNode * getToNode() const
Returns the destination node of the edge.
Definition: NBEdge.h:486
void insertJunctionSegment(const GNEDemandElement *element, const GNEJunction *junction, const Position pos, const bool visible, const bool valid)
insert junction segment
static bool isValidVehicleID(const std::string &value)
whether the given string is a valid id for a vehicle or flow
DepartDefinition
Possible ways to depart.
static bool parseDepart(const std::string &val, const std::string &element, const std::string &id, SUMOTime &depart, DepartDefinition &dd, std::string &error)
Validates a given depart value.
ArrivalPosDefinition arrivalPosProcedure
Information how the vehicle shall choose the arrival position.
std::string id
The vehicle&#39;s id.
void buildPopupHeader(GUIGLObjectPopupMenu *ret, GUIMainWindow &app, bool addSeparator=true)
Builds the header.
An Element which don&#39;t belongs to GNENet but has influency in the simulation.
GNEViewNet * getViewNet() const
get view net
Definition: GNENet.cpp:2067
FXMenuCommand * myTransformToRouteFlow
menu command for transform to route flow
Definition: GNEVehicle.h:72
void clearParameter()
Clears the parameter map.
static bool parseDepartLane(const std::string &val, const std::string &element, const std::string &id, int &lane, DepartLaneDefinition &dld, std::string &error)
Validates a given departLane value.
DepartPosLatDefinition departPosLatProcedure
Information how the vehicle shall choose the lateral departure position.