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) {
131  GNERouteHandler::transformToVehicle(myVehicle, false);
132  } else if (obj == myTransformToVehicleWithEmbeddedRoute) {
133  GNERouteHandler::transformToVehicle(myVehicle, true);
134  } else if (obj == myTransformToRouteFlow) {
135  GNERouteHandler::transformToRouteFlow(myVehicle, false);
136  } else if (obj == myTransformToRouteFlowWithEmbeddedRoute) {
137  GNERouteHandler::transformToRouteFlow(myVehicle, true);
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),
155  myTransformToVehicleWithEmbeddedRoute(nullptr),
156  myTransformToRouteFlow(nullptr),
157  myTransformToRouteFlowWithEmbeddedRoute(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) {
242  } else if (obj == myTransformAllVehiclesToVehicleWithEmbeddedRoute) {
244  } else if (obj == myTransformAllVehiclesToRouteFlow) {
246  } else if (obj == myTransformAllVehiclesToRouteFlowWithEmbeddedRoute) {
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) {
1438  connectionShape = con->customShape;
1439  } else if (NBEdgeFrom->getToNode()->getShape().area() > 4) {
1440  if (con->shape.size() != 0) {
1441  connectionShape = con->shape;
1442  // only append via shape if it exists
1443  if (con->haveVia) {
1444  connectionShape.append(con->viaShape);
1445  }
1446  } else {
1447  // Calculate shape so something can be drawn immidiately
1448  connectionShape = NBEdgeFrom->getToNode()->computeSmoothShape(
1449  laneFrom->getGeometry().shape,
1450  laneTo->getGeometry().shape,
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 /****************************************************************************/
GUIGlObject::getType
GUIGlObjectType getType() const
Returns the type of the object as coded in GUIGlObjectType.
Definition: GUIGlObject.cpp:181
NBEdge::append
void append(NBEdge *continuation)
append another edge
Definition: NBEdge.cpp:3056
GNEViewParent::getSelectorFrame
GNESelectorFrame * getSelectorFrame() const
get frame for GNE_NMODE_SELECT
Definition: GNEViewParent.cpp:185
SUMO_ATTR_MAXSPEED
Definition: SUMOXMLDefinitions.h:442
GNEVehicle::getAttributeDouble
double getAttributeDouble(SumoXMLAttr key) const
Definition: GNEVehicle.cpp:1067
GNEDemandElement::myViewNet
GNEViewNet * myViewNet
The GNEViewNet this demand element element belongs.
Definition: GNEDemandElement.h:469
GUIVisualizationDetailSettings::vehicleBoxes
static const double vehicleBoxes
details for draw person as boxes
Definition: GUIVisualizationSettings.h:323
SUMO_ATTR_TYPE
Definition: SUMOXMLDefinitions.h:382
SUMOVehicleParameter::personNumber
int personNumber
The static number of persons in the vehicle when it departs (not including boarding persons)
Definition: SUMOVehicleParameter.h:644
RGBColor::DEFAULT_COLOR
static const RGBColor DEFAULT_COLOR
The default color (for vehicle types and vehicles)
Definition: RGBColor.h:204
GNEVehicle::ConnectionGeometry
struct used for calculating routes
Definition: GNEVehicle.h:330
SUMOVehicleClass
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
Definition: SUMOVehicleClass.h:134
SUMOVehicleParameter::containerNumber
int containerNumber
The static number of containers in the vehicle when it departs.
Definition: SUMOVehicleParameter.h:647
GNERouteHandler::transformToVehicle
static void transformToVehicle(GNEVehicle *originalVehicle, bool createEmbeddedRoute)
transform vehicle functions
Definition: GNERouteHandler.cpp:851
SUMOVehicleParameter::wasSet
bool wasSet(int what) const
Returns whether the given parameter was set.
Definition: SUMOVehicleParameter.h:306
GNEDemandElement
An Element which don't belongs to GNENet but has influency in the simulation.
Definition: GNEDemandElement.h:54
GLHelper::drawTextSettings
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
SUMO_ATTR_DEPART
Definition: SUMOXMLDefinitions.h:432
MIN2
T MIN2(T a, T b)
Definition: StdDefs.h:74
ArrivalPosDefinition
ArrivalPosDefinition
Possible ways to choose the arrival position.
Definition: SUMOVehicleParameter.h:224
SUMOVehicleParameter::parametersSet
int parametersSet
Information for the router which parameter were set, TraCI may modify this (whe changing color)
Definition: SUMOVehicleParameter.h:650
GNEVehicle::startGeometryMoving
void startGeometryMoving()
Definition: GNEVehicle.cpp:524
GNEAttributeCarrier::mySelected
bool mySelected
boolean to check if this AC is selected (instead of GUIGlObjectStorage)
Definition: GNEAttributeCarrier.h:795
GNEVehicle::selectAttributeCarrier
void selectAttributeCarrier(bool changeFlag=true)
inherited from GNEAttributeCarrier
Definition: GNEVehicle.cpp:909
GNEAttributeCarrier::getID
const std::string getID() const
function to support debugging
Definition: GNEAttributeCarrier.cpp:1187
GNEVehicle::updateGeometry
void updateGeometry()
update pre-computed geometry information
Definition: GNEVehicle.cpp:548
GUISUMOAbstractView
Definition: GUISUMOAbstractView.h:73
GNEDemandElement::getRouteCalculatorInstance
static RouteCalculator * getRouteCalculatorInstance()
obtain instance of RouteCalculator
Definition: GNEDemandElement.cpp:435
ICON_TRIP
Definition: GUIIcons.h:296
SUMOVehicleParameter::arrivalSpeedProcedure
ArrivalSpeedDefinition arrivalSpeedProcedure
Information how the vehicle's end speed shall be chosen.
Definition: SUMOVehicleParameter.h:531
GUIGLObjectPopupMenu::insertMenuPaneChild
void insertMenuPaneChild(FXMenuPane *child)
Insert a sub-menu pane in this GUIGLObjectPopupMenu.
Definition: GUIGLObjectPopupMenu.cpp:80
GNEDemandElement::DemandElementSegmentGeometry::calculatePartialShapeRotationsAndLengths
void calculatePartialShapeRotationsAndLengths()
calculate partial shape, rotations and lengths
Definition: GNEDemandElement.cpp:161
SUMO_ATTR_LENGTH
Definition: SUMOXMLDefinitions.h:394
SUMOVehicleParameter::color
RGBColor color
The vehicle's color, TraCI may change this.
Definition: SUMOVehicleParameter.h:471
Boundary::ymin
double ymin() const
Returns minimum y-coordinate.
Definition: Boundary.cpp:131
GNEVehicle::GNESelectedVehiclesPopupMenu::~GNESelectedVehiclesPopupMenu
~GNESelectedVehiclesPopupMenu()
Destructor.
Definition: GNEVehicle.cpp:215
SUMOVehicleParameter::getArrivalPos
std::string getArrivalPos() const
obtain arrival pos parameter in string format
Definition: SUMOVehicleParameter.cpp:697
OutputDevice
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:64
GUIGlObject::drawName
void drawName(const Position &pos, const double scale, const GUIVisualizationTextSettings &settings, const double angle=0) const
draw name of item
Definition: GUIGlObject.cpp:355
SUMOVehicleParameter::getDepartSpeed
std::string getDepartSpeed() const
obtain depart speed parameter in string format
Definition: SUMOVehicleParameter.cpp:652
ICON_FLOW
Definition: GUIIcons.h:297
GUIVisualizationSettings::angle
double angle
The current view rotation angle.
Definition: GUIVisualizationSettings.h:403
GNEVehicle::getGenericParametersStr
std::string getGenericParametersStr() const
return generic parameters in string format
Definition: GNEVehicle.cpp:1577
GNEDemandElement::DemandElementSegmentGeometry::insertEdgeSegment
void insertEdgeSegment(const GNEDemandElement *element, const GNEEdge *edge, const Position pos, const bool visible, const bool valid)
insert edge segment
Definition: GNEDemandElement.cpp:133
StringTokenizer::hasNext
bool hasNext()
returns the information whether further substrings exist
Definition: StringTokenizer.cpp:95
GNEVehicle::myToEdge
GNEEdge * myToEdge
to edge (used by flows and trips)
Definition: GNEVehicle.h:365
GNEDemandElement::DemandElementSegmentGeometry::clearDemandElementSegmentGeometry
void clearDemandElementSegmentGeometry()
clear demand element geometry
Definition: GNEDemandElement.cpp:154
GUIBaseVehicleHelper::drawAction_drawVehicleAsPoly
static void drawAction_drawVehicleAsPoly(const GUIVisualizationSettings &s, const SUMOVehicleShape shape, const double width, const double length, int carriageIndex=-1)
draw vehicle as a polygon
Definition: GUIBaseVehicleHelper.cpp:144
SUMOVehicleParameter::departSpeed
double departSpeed
(optional) The initial speed of the vehicle
Definition: SUMOVehicleParameter.h:500
SUMO_ATTR_LINE
Definition: SUMOXMLDefinitions.h:772
GNEAttributeCarrier::GNEChange_EnableAttribute
friend class GNEChange_EnableAttribute
Definition: GNEAttributeCarrier.h:58
SUMOVehicleParameter::vtypeid
std::string vtypeid
The vehicle's type id.
Definition: SUMOVehicleParameter.h:468
VEHPARS_NUMBER_SET
const int VEHPARS_NUMBER_SET
Definition: SUMOVehicleParameter.h:52
SUMOVehicleParameter::departPosProcedure
DepartPosDefinition departPosProcedure
Information how the vehicle shall choose the departure position.
Definition: SUMOVehicleParameter.h:491
GNEVehicle::setAttribute
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
method for setting the attribute and letting the object perform demand element changes
Definition: GNEVehicle.cpp:1073
GNERouteHandler::transformToTrip
static void transformToTrip(GNEVehicle *originalVehicle)
transform to trip
Definition: GNERouteHandler.cpp:971
SUMOVehicleParameter::repetitionOffset
SUMOTime repetitionOffset
The time offset between vehicle reinsertions.
Definition: SUMOVehicleParameter.h:544
SUMOVehicleParameter::parseDepartSpeed
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.
Definition: SUMOVehicleParameter.cpp:357
GNEVehicle::GNESelectedVehiclesPopupMenu::myTransformToRouteFlowWithEmbeddedRoute
FXMenuCommand * myTransformToRouteFlowWithEmbeddedRoute
menu command for transform to route flow with an embedded route
Definition: GNEVehicle.h:124
SUMO_ATTR_ARRIVALPOS_LAT
Definition: SUMOXMLDefinitions.h:439
GUIGlobalSelection.h
NBNode::computeSmoothShape
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
SUMOVehicleParameter::parseDepartLane
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.
Definition: SUMOVehicleParameter.cpp:250
SUMO_ATTR_PERIOD
Definition: SUMOXMLDefinitions.h:643
GNEVehicle::getFromEdge
GNEEdge * getFromEdge() const
Definition: GNEVehicle.cpp:452
NBEdge::getConnectionsFromLane
std::vector< Connection > getConnectionsFromLane(int lane, NBEdge *to=nullptr, int toLane=-1) const
Returns connections from a given lane.
Definition: NBEdge.cpp:1127
DepartPosLatDefinition
DepartPosLatDefinition
Definition: SUMOVehicleParameter.h:160
ArrivalPosLatDefinition
ArrivalPosLatDefinition
Possible ways to choose the departure position.
Definition: SUMOVehicleParameter.h:244
FXDEFMAP
FXDEFMAP(GNEVehicle::GNESingleVehiclePopupMenu) GNESingleVehiclePopupMenuMap[]
GNEAttributeCarrier::isGenericParametersValid
static bool isGenericParametersValid(const std::string &value)
check if given string can be parsed to a map/list of generic parameters
Definition: GNEAttributeCarrier.cpp:1354
SUMOTime
long long int SUMOTime
Definition: SUMOTime.h:35
GNEVehicle::isDemandElementValid
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
DepartDefinition
DepartDefinition
Possible ways to depart.
Definition: SUMOVehicleParameter.h:94
VEHPARS_ARRIVALSPEED_SET
const int VEHPARS_ARRIVALSPEED_SET
Definition: SUMOVehicleParameter.h:59
Boundary::xmax
double xmax() const
Returns maximum x-coordinate.
Definition: Boundary.cpp:125
GNENet::retrieveDemandElement
GNEDemandElement * retrieveDemandElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named demand element.
Definition: GNENet.cpp:2266
SUMO_ATTR_COLOR
A color information.
Definition: SUMOXMLDefinitions.h:701
ArrivalLaneDefinition
ArrivalLaneDefinition
Possible ways to choose the arrival lane.
Definition: SUMOVehicleParameter.h:208
OptionsCont::getOptions
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:58
GNEVehicle::getBegin
std::string getBegin() const
get begin time of demand element
Definition: GNEVehicle.cpp:328
SUMOVehicleParameter::departProcedure
DepartDefinition departProcedure
Information how the vehicle shall choose the depart time.
Definition: SUMOVehicleParameter.h:479
GNEViewNetHelper::NetworkViewOptions::showDemandElements
bool showDemandElements() const
check if show demand elements checkbox is enabled
Definition: GNEViewNetHelper.cpp:1615
StringTokenizer::next
std::string next()
returns the next substring when it exists. Otherwise the behaviour is undefined
Definition: StringTokenizer.cpp:100
GNEViewNet
Definition: GNEViewNet.h:43
GLO_FLOW
a flow
Definition: GUIGlObjectTypes.h:146
GNEVehicle::getPositionInView
Position getPositionInView() const
Returns position of demand element in view.
Definition: GNEVehicle.cpp:719
GNEHierarchicalElementParents::getEdgeParents
const std::vector< GNEEdge * > & getEdgeParents() const
get edge parents
Definition: GNEHierarchicalElementParents.cpp:150
SUMOVehicleParameter::parseArrivalPosLat
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.
Definition: SUMOVehicleParameter.cpp:451
SUMO_ATTR_ARRIVALPOS
Definition: SUMOXMLDefinitions.h:438
SUMO_ATTR_ID
Definition: SUMOXMLDefinitions.h:379
PositionVector::length
double length() const
Returns the length.
Definition: PositionVector.cpp:476
GNEDemandElement::getViewNet
GNEViewNet * getViewNet() const
Returns a pointer to GNEViewNet in which demand element element is located.
Definition: GNEDemandElement.cpp:408
SUMOVehicleParameter
Structure representing possible vehicle parameter.
Definition: SUMOVehicleParameter.h:291
GLO_VEHICLE
Definition: GUIGlObjectTypes.h:142
GNERouteHandler::transformToFlow
static void transformToFlow(GNEVehicle *originalVehicle)
transform to flow
Definition: GNERouteHandler.cpp:1031
GLHelper.h
MID_COPY_NAME
Copy object name - popup entry.
Definition: GUIAppEnum.h:369
GUIVisualizationSettings::vehicleSize
GUIVisualizationSizeSettings vehicleSize
Definition: GUIVisualizationSettings.h:511
NBEdge::getPermissions
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
Definition: NBEdge.cpp:3441
GUIVisualizationSettings::vehicleColorer
GUIColorer vehicleColorer
The vehicle colorer.
Definition: GUIVisualizationSettings.h:490
SUMO_TAG_VTYPE
description of a vehicle type
Definition: SUMOXMLDefinitions.h:122
GNEVehicle::~GNEVehicle
~GNEVehicle()
destructor
Definition: GNEVehicle.cpp:324
GNEVehicle::ConnectionGeometry::calculateConnectionShape
void calculateConnectionShape()
calculate connection shape (note: Only calculated if 'con' isn't nullptr)
Definition: GNEVehicle.cpp:1431
GUIGLObjectPopupMenu
The popup menu of a globject.
Definition: GUIGLObjectPopupMenu.h:48
GUIIconSubSys::getIcon
static FXIcon * getIcon(GUIIcon which)
returns a icon previously defined in the enum GUIIcon
Definition: GUIIconSubSys.cpp:602
GNEVehicle::getVClass
SUMOVehicleClass getVClass() const
obtain VClass related with this demand element
Definition: GNEVehicle.cpp:484
SUMOVehicleParameter::parseArrivalPos
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.
Definition: SUMOVehicleParameter.cpp:421
GNEVehicle::GNESelectedVehiclesPopupMenu::GNESelectedVehiclesPopupMenu
GNESelectedVehiclesPopupMenu()
default constructor needed by FOX
Definition: GNEVehicle.h:105
GLHelper::setColor
static void setColor(const RGBColor &c)
Sets the gl-color to this value.
Definition: GLHelper.cpp:616
GUIVisualizationSettings::drawMinGap
bool drawMinGap
Information whether the minimum gap shall be drawn.
Definition: GUIVisualizationSettings.h:502
GNEVehicle::enableAttribute
void enableAttribute(SumoXMLAttr key, GNEUndoList *undoList)
Definition: GNEVehicle.cpp:1300
SumoXMLTag
SumoXMLTag
Numbers representing SUMO-XML - element names.
Definition: SUMOXMLDefinitions.h:42
SUMOVehicleParameter::depart
SUMOTime depart
Definition: SUMOVehicleParameter.h:476
GUIVisualizationDetailSettings::vehicleShapes
static const double vehicleShapes
details for draw person as shapes
Definition: GUIVisualizationSettings.h:326
VEHPARS_PROB_SET
const int VEHPARS_PROB_SET
Definition: SUMOVehicleParameter.h:55
GNEVehicle::setColor
void setColor(const GUIVisualizationSettings &s) const
sets the color according to the currente settings
Definition: GNEVehicle.cpp:1468
VEHPARS_DEPARTSPEED_SET
const int VEHPARS_DEPARTSPEED_SET
Definition: SUMOVehicleParameter.h:50
GNEAttributeCarrier::TagProperties::getTag
SumoXMLTag getTag() const
get Tag vinculated with this attribute Property
Definition: GNEAttributeCarrier.cpp:521
GNENetElement::NetElementGeometry::shape
PositionVector shape
The shape of the netElement element.
Definition: GNENetElement.h:57
GUIVisualizationTextSettings::scaledSize
double scaledSize(double scale, double constFactor=0.1) const
get scale size
Definition: GUIVisualizationSettings.cpp:195
GNEVehicle::getPopUpID
std::string getPopUpID() const
get PopPup ID (Used in AC Hierarchy)
Definition: GNEVehicle.cpp:1381
NBEdge
The representation of a single edge during network building.
Definition: NBEdge.h:86
OutputDevice::closeTag
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
Definition: OutputDevice.cpp:254
GUIAppEnum.h
GNEVehicle::GNESelectedVehiclesPopupMenu
class used in GUIGLObjectPopupMenu for single vehicle transformations
Definition: GNEVehicle.h:85
GNEVehicle::myFromEdge
GNEEdge * myFromEdge
from edge (used by flows and trips)
Definition: GNEVehicle.h:362
SUMOVehicleParameter::tag
SumoXMLTag tag
The vehicle tag.
Definition: SUMOVehicleParameter.h:459
SUMOVehicleParameter::getDepartPosLat
std::string getDepartPosLat() const
obtain depart pos lat parameter in string format
Definition: SUMOVehicleParameter.cpp:619
SUMO_ATTR_BEGIN
weights: time range begin
Definition: SUMOXMLDefinitions.h:675
SUMO_ATTR_TO
Definition: SUMOXMLDefinitions.h:638
MAX2
T MAX2(T a, T b)
Definition: StdDefs.h:80
GNEEdge
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:50
VEHPARS_ARRIVALLANE_SET
const int VEHPARS_ARRIVALLANE_SET
Definition: SUMOVehicleParameter.h:57
GNEAttributeCarrier::GNEChange_Attribute
friend class GNEChange_Attribute
declare friend class
Definition: GNEAttributeCarrier.h:57
VEHPARS_ROUTE_SET
const int VEHPARS_ROUTE_SET
Definition: SUMOVehicleParameter.h:56
SUMO_ATTR_PERSON_NUMBER
Definition: SUMOXMLDefinitions.h:649
GNEUndoList::p_add
void p_add(GNEChange_Attribute *cmd)
special method, avoid empty changes, always execute
Definition: GNEUndoList.cpp:132
GNEDemandElement::changeDemandElementID
void changeDemandElementID(const std::string &newID)
change ID of demand element
Definition: GNEDemandElement.cpp:540
SUMOVehicleParameter::line
std::string line
The vehicle's line (mainly for public transport)
Definition: SUMOVehicleParameter.h:555
GNEViewNet::getNet
GNENet * getNet() const
get the net object
Definition: GNEViewNet.cpp:927
GNEAttributeCarrier::TagProperties::getTagSynonym
SumoXMLTag getTagSynonym() const
get tag synonym
Definition: GNEAttributeCarrier.cpp:668
GNEVehicle::GNESelectedVehiclesPopupMenu::myTransformToFlow
FXMenuCommand * myTransformToFlow
menu command for transform to flow
Definition: GNEVehicle.h:130
OutputDevice::writeAttr
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:256
RGBColor
Definition: RGBColor.h:40
GNENetElement::NetElementGeometry::shapeRotations
std::vector< double > shapeRotations
The rotations of the single shape parts.
Definition: GNENetElement.h:60
SUMO_TAG_ROUTEFLOW
a flow definition nusing a route instead of a from-to edges route (used in NETEDIT)
Definition: SUMOXMLDefinitions.h:152
SUMO_ATTR_ARRIVALSPEED
Definition: SUMOXMLDefinitions.h:440
Parameterised::getParametersMap
const std::map< std::string, std::string > & getParametersMap() const
Returns the inner key/value map.
Definition: Parameterised.cpp:105
NBEdge::getToNode
NBNode * getToNode() const
Returns the destination node of the edge.
Definition: NBEdge.h:486
GNEVehicle::ConnectionGeometry::ConnectionGeometry
ConnectionGeometry()
default constructor (by default unused)
Definition: GNEVehicle.cpp:1460
GNEDemandElement::DemandElementSegmentGeometry::begin
std::vector< Segment >::const_iterator begin() const
begin iterator
Definition: GNEDemandElement.cpp:185
GNEDemandElement::DemandElementSegmentGeometry::insertJunctionSegment
void insertJunctionSegment(const GNEDemandElement *element, const GNEJunction *junction, const Position pos, const bool visible, const bool valid)
insert junction segment
Definition: GNEDemandElement.cpp:147
SUMO_TAG_FLOW
a flow definitio nusing a from-to edges instead of a route (used by router)
Definition: SUMOXMLDefinitions.h:150
SUMO_ATTR_PROB
Definition: SUMOXMLDefinitions.h:627
VEHPARS_ARRIVALPOS_SET
const int VEHPARS_ARRIVALPOS_SET
Definition: SUMOVehicleParameter.h:58
GUIVisualizationSettings::detailSettings
GUIVisualizationDetailSettings detailSettings
detail settings
Definition: GUIVisualizationSettings.h:655
GNEAttributeCarrier::getTagProperty
const TagProperties & getTagProperty() const
get Tag Property assigned to this object
Definition: GNEAttributeCarrier.cpp:1171
SUMOVehicleParameter::arrivalLaneProcedure
ArrivalLaneDefinition arrivalLaneProcedure
Information how the vehicle shall choose the lane to arrive on.
Definition: SUMOVehicleParameter.h:513
SUMOVehicleParameter::parseDepartPosLat
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.
Definition: SUMOVehicleParameter.cpp:321
Boundary::xmin
double xmin() const
Returns minimum x-coordinate.
Definition: Boundary.cpp:119
GUISelectedStorage::select
void select(GUIGlID id, bool update=true)
Adds the object with the given id.
Definition: GUISelectedStorage.cpp:114
SUMOVehicleParameter::getArrivalPosLat
std::string getArrivalPosLat() const
obtain arrival pos lat parameter in string format
Definition: SUMOVehicleParameter.cpp:721
TIME2STEPS
#define TIME2STEPS(x)
Definition: SUMOTime.h:59
SUMOVehicleParameter::getDepart
std::string getDepart() const
obtain depart parameter in string format
Definition: SUMOVehicleParameter.cpp:547
GUIPropertySchemeStorage::getScheme
T & getScheme()
Definition: GUIPropertySchemeStorage.h:80
GNEVehicle::getColor
const RGBColor & getColor() const
get color
Definition: GNEVehicle.cpp:490
GNEViewNet::buildSelectionACPopupEntry
void buildSelectionACPopupEntry(GUIGLObjectPopupMenu *ret, GNEAttributeCarrier *AC)
Builds an entry which allows to (de)select the object.
Definition: GNEViewNet.cpp:331
GNEVehicle::isAttributeEnabled
bool isAttributeEnabled(SumoXMLAttr key) const
Definition: GNEVehicle.cpp:1362
Position::distanceTo
double distanceTo(const Position &p2) const
returns the euclidean distance in 3 dimension
Definition: Position.h:234
VEHPARS_COLOR_SET
const int VEHPARS_COLOR_SET
Definition: SUMOVehicleParameter.h:46
GNEVehicle::GNESelectedVehiclesPopupMenu::myTransformToTrip
FXMenuCommand * myTransformToTrip
menu command for transform to trip
Definition: GNEVehicle.h:127
DEPART_SPEED_GIVEN
The speed is given.
Definition: SUMOVehicleParameter.h:190
SUMOVehicleShape
SUMOVehicleShape
Definition of vehicle classes to differ between different appearences.
Definition: SUMOVehicleClass.h:51
SUMOVehicleParameter::parseArrivalLane
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.
Definition: SUMOVehicleParameter.cpp:392
StringTokenizer
Definition: StringTokenizer.h:62
GNEVehicle::fixDemandElementProblem
void fixDemandElementProblem()
fix demand element problem (by default throw an exception, has to be reimplemented in children)
Definition: GNEVehicle.cpp:446
GNEViewNet::getNetworkViewOptions
const GNEViewNetHelper::NetworkViewOptions & getNetworkViewOptions() const
get network view options
Definition: GNEViewNet.cpp:411
ICON_VEHICLE
Definition: GUIIcons.h:295
DEFAULT_VTYPE_ID
const std::string DEFAULT_VTYPE_ID
SUMO_ATTR_DEPARTPOS_LAT
Definition: SUMOXMLDefinitions.h:435
DEPART_LANE_GIVEN
The lane is given.
Definition: SUMOVehicleParameter.h:116
GNEViewNet.h
GNEVehicle::getGenericParameters
std::vector< std::pair< std::string, std::string > > getGenericParameters() const
return generic parameters as vector of pairs format
Definition: GNEVehicle.cpp:1592
STEPS2TIME
#define STEPS2TIME(x)
Definition: SUMOTime.h:57
PositionVector::positionAtOffset
Position positionAtOffset(double pos, double lateralOffset=0) const
Returns the position at the given length.
Definition: PositionVector.cpp:246
SUMO_ATTR_WIDTH
Definition: SUMOXMLDefinitions.h:387
GNENet::retrieveDemandElements
std::vector< GNEDemandElement * > retrieveDemandElements(bool onlySelected=false) const
return all demand elements
Definition: GNENet.cpp:2278
SUMO_ATTR_DEPARTSPEED
Definition: SUMOXMLDefinitions.h:436
SUMOVehicleParameter::id
std::string id
The vehicle's id.
Definition: SUMOVehicleParameter.h:462
SUMO_ATTR_ROUTE
Definition: SUMOXMLDefinitions.h:441
GUIGlObject::getGlID
GUIGlID getGlID() const
Returns the numerical id of the object.
Definition: GUIGlObject.cpp:150
GNEViewNet::getDottedAC
const GNEAttributeCarrier * getDottedAC() const
get AttributeCarrier under cursor
Definition: GNEViewNet.cpp:939
Boundary
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:42
SUMO_ATTR_DEPARTLANE
Definition: SUMOXMLDefinitions.h:433
GNEVehicle::getDemandElementProblem
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
GNEVehicle::GNESingleVehiclePopupMenu::~GNESingleVehiclePopupMenu
~GNESingleVehiclePopupMenu()
Destructor.
Definition: GNEVehicle.cpp:125
GNEVehicle::getAttribute
std::string getAttribute(SumoXMLAttr key) const
Definition: GNEVehicle.cpp:940
NBEdge::getNumLanes
int getNumLanes() const
Returns the number of lanes.
Definition: NBEdge.h:465
SUMOVehicleParameter::repetitionProbability
double repetitionProbability
The probability for emitting a vehicle per second.
Definition: SUMOVehicleParameter.h:547
VEHPARS_VIA_SET
const int VEHPARS_VIA_SET
Definition: SUMOVehicleParameter.h:69
GNEVehicle::compute
void compute()
compute demand element
Definition: GNEVehicle.cpp:496
SUMO_TAG_EDGE
begin/end of the description of an edge
Definition: SUMOXMLDefinitions.h:48
SUMOVehicleParameter::arrivalPos
double arrivalPos
(optional) The position the vehicle shall arrive on
Definition: SUMOVehicleParameter.h:516
VEHPARS_LINE_SET
const int VEHPARS_LINE_SET
Definition: SUMOVehicleParameter.h:60
GLHelper::drawShapeDottedContourRectangle
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
RGBColor::BLUE
static const RGBColor BLUE
Definition: RGBColor.h:192
GUIVisualizationSettings::scale
double scale
information about a lane's width (temporary, used for a single view)
Definition: GUIVisualizationSettings.h:623
ProcessError
Definition: UtilExceptions.h:40
GNEHierarchicalElementParents::changeDemandElementParent
void changeDemandElementParent(GNEShape *shapeTobeChanged, const std::string &newDemandElementParentID, int demandElementParentIndex)
change first demand element parent of a shape
Definition: GNEHierarchicalElementParents.cpp:531
GNEViewNetHelper::EditModes::currentSupermode
Supermode currentSupermode
the current supermode
Definition: GNEViewNetHelper.h:309
GUIVisualizationSettings::vehicleName
GUIVisualizationTextSettings vehicleName
Definition: GUIVisualizationSettings.h:514
GLO_ROUTE
Definition: GUIGlObjectTypes.h:116
SUMOVehicleParameter::arrivalPosProcedure
ArrivalPosDefinition arrivalPosProcedure
Information how the vehicle shall choose the arrival position.
Definition: SUMOVehicleParameter.h:519
SUMO_ATTR_CONTAINER_NUMBER
Definition: SUMOXMLDefinitions.h:650
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:39
GLO_TRIP
a trip
Definition: GUIGlObjectTypes.h:144
Position::x
double x() const
Returns the x-position.
Definition: Position.h:57
Boundary::add
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
Definition: Boundary.cpp:79
GNEEdge.h
GNEAttributeCarrier::myTagProperty
const TagProperties & myTagProperty
the xml tag to which this attribute carrier corresponds
Definition: GNEAttributeCarrier.h:792
time2string
std::string time2string(SUMOTime t)
Definition: SUMOTime.cpp:65
SUMOXMLDefinitions::isValidGenericParameterKey
static bool isValidGenericParameterKey(const std::string &value)
whether the given string is a valid key for a generic parameter
Definition: SUMOXMLDefinitions.cpp:1034
GNEDemandElement::isAttributeCarrierSelected
bool isAttributeCarrierSelected() const
check if attribute carrier is selected
Definition: GNEDemandElement.cpp:555
GNEViewNet::getDemandViewOptions
const GNEViewNetHelper::DemandViewOptions & getDemandViewOptions() const
get demand view options
Definition: GNEViewNet.cpp:417
SUMOVehicleParameter::arrivalPosLat
double arrivalPosLat
(optional) The lateral position the vehicle shall arrive on
Definition: SUMOVehicleParameter.h:522
SUMOVehicleParameter::parseArrivalSpeed
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.
Definition: SUMOVehicleParameter.cpp:481
SUMOVehicleParameter::parseDepart
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.
Definition: SUMOVehicleParameter.cpp:219
RGBColor::RED
static const RGBColor RED
named colors
Definition: RGBColor.h:190
VEHPARS_ARRIVALPOSLAT_SET
const int VEHPARS_ARRIVALPOSLAT_SET
Definition: SUMOVehicleParameter.h:68
GNEVehicle::GNESelectedVehiclesPopupMenu::myTransformToRouteFlow
FXMenuCommand * myTransformToRouteFlow
menu command for transform to route flow
Definition: GNEVehicle.h:121
GUIBaseVehicleHelper.h
GNENet::updateDemandElementBegin
void updateDemandElementBegin(const std::string &oldBegin, GNEDemandElement *demandElement)
update demand element begin in container
Definition: GNENet.cpp:2328
RGBColor::fromHSV
static RGBColor fromHSV(double h, double s, double v)
Converts the given hsv-triplet to rgb, inspired by http://alvyray.com/Papers/CG/hsv2rgb....
Definition: RGBColor.cpp:299
GNEVehicle::isValid
bool isValid(SumoXMLAttr key, const std::string &value)
method for checking if the key and their conrrespond attribute are valids
Definition: GNEVehicle.cpp:1120
GUIVisualizationTextSettings::show
bool show
flag show
Definition: GUIVisualizationSettings.h:69
GUIBaseVehicleHelper::drawAction_drawVehicleAsBoxPlus
static void drawAction_drawVehicleAsBoxPlus(const double width, const double length)
draw vehicle as a Box
Definition: GUIBaseVehicleHelper.cpp:112
GNEVehicle::getToEdge
GNEEdge * getToEdge() const
obtain to edge of this demand element
Definition: GNEVehicle.cpp:468
GUISUMOAbstractView::getPositionInformation
Position getPositionInformation() const
Returns the cursor's x/y position within the network.
Definition: GUISUMOAbstractView.cpp:188
SUMOVehicleParameter::arrivalLane
int arrivalLane
Definition: SUMOVehicleParameter.h:510
GNEVehicle::getCenteringBoundary
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
Definition: GNEVehicle.cpp:768
GNERouteHandler::transformToRouteFlow
static void transformToRouteFlow(GNEVehicle *originalVehicle, bool createEmbeddedRoute)
transform routeFlow over an existent route
Definition: GNERouteHandler.cpp:911
ICON_ROUTEFLOW
Definition: GUIIcons.h:298
GNEEdge::getLanes
const std::vector< GNELane * > & getLanes() const
returns a reference to the lane vector
Definition: GNEEdge.cpp:840
SUMOVehicleParameter::getDepartPos
std::string getDepartPos() const
obtain depart pos parameter in string format
Definition: SUMOVehicleParameter.cpp:589
SUMO_TAG_VEHICLE
description of a vehicle
Definition: SUMOXMLDefinitions.h:120
SUMOVehicleParameter::getDepartLane
std::string getDepartLane() const
obtain depart lane parameter in string format
Definition: SUMOVehicleParameter.cpp:559
GNEVehicle::GNESelectedVehiclesPopupMenu::myTransformAllVehiclesToVehicleWithEmbeddedRoute
FXMenuCommand * myTransformAllVehiclesToVehicleWithEmbeddedRoute
menu command for transform all selected vehicles to vehicle with an embedded route
Definition: GNEVehicle.h:136
string2time
SUMOTime string2time(const std::string &r)
Definition: SUMOTime.cpp:42
VEHPARS_VPH_SET
const int VEHPARS_VPH_SET
Definition: SUMOVehicleParameter.h:54
GNELane.h
SUMOVehicleParameter::departPosLat
double departPosLat
(optional) The lateral position the vehicle shall depart from
Definition: SUMOVehicleParameter.h:494
GNENetElement::getGeometry
const NetElementGeometry & getGeometry() const
Definition: GNENetElement.cpp:95
SUMOXMLDefinitions::isValidGenericParameterValue
static bool isValidGenericParameterValue(const std::string &value)
whether the given string is a valid value for a generic parameter
Definition: SUMOXMLDefinitions.cpp:1041
GNEChange_EnableAttribute.h
VEHPARS_DEPARTLANE_SET
const int VEHPARS_DEPARTLANE_SET
Definition: SUMOVehicleParameter.h:48
MSDevice_BTreceiver.h
GNENet::getViewNet
GNEViewNet * getViewNet() const
get view net
Definition: GNENet.cpp:2067
Position::distanceSquaredTo2D
double distanceSquaredTo2D(const Position &p2) const
returns the square of the distance to another position (Only using x and y positions)
Definition: Position.h:249
GUIGlObject::buildPopupHeader
void buildPopupHeader(GUIGLObjectPopupMenu *ret, GUIMainWindow &app, bool addSeparator=true)
Builds the header.
Definition: GUIGlObject.cpp:208
SUMOVehicleParameter::write
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.
Definition: SUMOVehicleParameter.cpp:66
GUIVisualizationSettings::colorSettings
GUIVisualizationColorSettings colorSettings
color settings
Definition: GUIVisualizationSettings.h:649
SUMO_ATTR_FROM
Definition: SUMOXMLDefinitions.h:637
GNEVehicle::GNESelectedVehiclesPopupMenu::myTransformAllVehiclesToRouteFlow
FXMenuCommand * myTransformAllVehiclesToRouteFlow
menu command for transform all selected vehicles to route flow
Definition: GNEVehicle.h:139
GNEDemandElement::DemandElementSegmentGeometry::geometryDeprecated
bool geometryDeprecated
mark geometry as deprecated (used to avoid multiple updates)
Definition: GNEDemandElement.h:147
GNEVehicle::setGenericParametersStr
void setGenericParametersStr(const std::string &value)
set generic parameters in string format
Definition: GNEVehicle.cpp:1603
DepartLaneDefinition
DepartLaneDefinition
Possible ways to choose a lane on depart.
Definition: SUMOVehicleParameter.h:112
GUIVisualizationDetailSettings::vehicleTriangles
static const double vehicleTriangles
details for draw person as triangles
Definition: GUIVisualizationSettings.h:320
SUMOVehicleParameter::repetitionEnd
SUMOTime repetitionEnd
The time at which the flow ends (only needed when using repetitionProbability)
Definition: SUMOVehicleParameter.h:550
GNEViewParent.h
GNEViewNetHelper::DemandViewOptions::showNonInspectedDemandElements
bool showNonInspectedDemandElements(const GNEDemandElement *demandElement) const
check if non inspected element has to be hidden
Definition: GNEViewNetHelper.cpp:1740
SUMOVehicleParameter::departLane
int departLane
(optional) The lane the vehicle shall depart from (index in edge)
Definition: SUMOVehicleParameter.h:482
GNENet::getBoundary
const Boundary & getBoundary() const
returns the bounder of the network
Definition: GNENet.cpp:186
GLIncludes.h
GNEVehicle::getHierarchyName
std::string getHierarchyName() const
get Hierarchy Name (Used in AC Hierarchy)
Definition: GNEVehicle.cpp:1387
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:48
GNE_ATTR_GENERIC
generic attribute
Definition: SUMOXMLDefinitions.h:986
VEHPARS_VTYPE_SET
const int VEHPARS_VTYPE_SET
Definition: SUMOVehicleParameter.h:47
NBNode::getShape
const PositionVector & getShape() const
retrieve the junction shape
Definition: NBNode.cpp:2143
GNEVehicle::commitGeometryMoving
void commitGeometryMoving(GNEUndoList *undoList)
commit geometry changes in the attributes of an element after use of moveGeometry(....
Definition: GNEVehicle.cpp:542
GNEDemandElement::DemandElementSegmentGeometry::insertEdgeLengthRotSegment
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...
Definition: GNEDemandElement.cpp:140
GNEDemandElement::RouteCalculator::areEdgesConsecutives
bool areEdgesConsecutives(SUMOVehicleClass vClass, GNEEdge *from, GNEEdge *to) const
check if exist a route between the two given consecutives edges
Definition: GNEDemandElement.cpp:282
GNESelectorFrame.h
GNEAttributeCarrier::TagProperties::getDefaultValue
const std::string & getDefaultValue(SumoXMLAttr attr) const
return the default value of the attribute of an element
Definition: GNEAttributeCarrier.cpp:572
SUMOVehicleParameter::departLaneProcedure
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
Definition: SUMOVehicleParameter.h:485
VEHPARS_DEPARTPOSLAT_SET
const int VEHPARS_DEPARTPOSLAT_SET
Definition: SUMOVehicleParameter.h:67
GNEDemandElement::myDemandElementSegmentGeometry
DemandElementSegmentGeometry myDemandElementSegmentGeometry
demand element segment geometry
Definition: GNEDemandElement.h:475
GNEHierarchicalElementParents::getDemandElementParents
const std::vector< GNEDemandElement * > & getDemandElementParents() const
return vector of demand elements that have as Parent this edge (For example, Calibrators)
Definition: GNEHierarchicalElementParents.cpp:115
SUMO_ATTR_VIA
Definition: SUMOXMLDefinitions.h:720
GUIMainWindow
Definition: GUIMainWindow.h:47
Position::y
double y() const
Returns the y-position.
Definition: Position.h:62
SUMOVehicleParameter::via
std::vector< std::string > via
List of the via-edges the vehicle must visit.
Definition: SUMOVehicleParameter.h:641
GNEVehicle::writeDemandElement
void writeDemandElement(OutputDevice &device) const
writte demand element element into a xml file
Definition: GNEVehicle.cpp:347
SUMOXMLDefinitions::isValidTypeID
static bool isValidTypeID(const std::string &value)
whether the given string is a valid id for an edge or vehicle type
Definition: SUMOXMLDefinitions.cpp:976
Boundary::getCenter
Position getCenter() const
Returns the center of the boundary.
Definition: Boundary.cpp:113
GNEVehicle::GNESelectedVehiclesPopupMenu::myTransformAllVehiclesToTrip
FXMenuCommand * myTransformAllVehiclesToTrip
menu command for transform all selected vehicles to trip
Definition: GNEVehicle.h:145
M_PI
#define M_PI
Definition: odrSpiral.cpp:40
GNEAttributeCarrier::TagProperties::hasTagSynonym
bool hasTagSynonym() const
return true if tag correspond to an element that will be written in XML with another tag
Definition: GNEAttributeCarrier.cpp:838
GNEVehicle::GNEVehicle
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
SUMO_ATTR_REROUTE
Definition: SUMOXMLDefinitions.h:646
VEHPARS_CONTAINER_NUMBER_SET
const int VEHPARS_CONTAINER_NUMBER_SET
Definition: SUMOVehicleParameter.h:66
GNE_SUPERMODE_DEMAND
Demanding mode (Routes, Vehicles etc..)
Definition: GNEViewNetHelper.h:49
VEHPARS_DEPARTPOS_SET
const int VEHPARS_DEPARTPOS_SET
Definition: SUMOVehicleParameter.h:49
InvalidArgument
Definition: UtilExceptions.h:57
GLHelper::drawBoxLine
static void drawBoxLine(const Position &beg, double rot, double visLength, double width, double offset=0)
Draws a thick line.
Definition: GLHelper.cpp:136
SUMO_ATTR_GUISHAPE
Definition: SUMOXMLDefinitions.h:787
VEHPARS_PERSON_NUMBER_SET
const int VEHPARS_PERSON_NUMBER_SET
Definition: SUMOVehicleParameter.h:65
SUMOXMLDefinitions::isValidNetID
static bool isValidNetID(const std::string &value)
whether the given string is a valid id for a network element
Definition: SUMOXMLDefinitions.cpp:964
SUMOXMLDefinitions::isValidVehicleID
static bool isValidVehicleID(const std::string &value)
whether the given string is a valid id for a vehicle or flow
Definition: SUMOXMLDefinitions.cpp:970
GNEVehicle::GNESelectedVehiclesPopupMenu::onCmdTransform
long onCmdTransform(FXObject *obj, FXSelector, void *)
Called to transform the current vehicle to another vehicle type.
Definition: GNEVehicle.cpp:219
GNEVehicle::GNESelectedVehiclesPopupMenu::myTransformToVehicleWithEmbeddedRoute
FXMenuCommand * myTransformToVehicleWithEmbeddedRoute
menu command for transform to vehicle with an embedded route
Definition: GNEVehicle.h:118
GNEVehicle::setEnabledAttribute
void setEnabledAttribute(const int enabledAttributes)
method for enabling the attribute and nothing else (used in GNEChange_EnableAttribute)
Definition: GNEVehicle.cpp:1882
GUIGlObject::buildShowParamsPopupEntry
void buildShowParamsPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to open the parameter window.
Definition: GUIGlObject.cpp:249
DepartPosDefinition
DepartPosDefinition
Possible ways to choose the departure position.
Definition: SUMOVehicleParameter.h:136
gSelected
GUISelectedStorage gSelected
A global holder of selected objects.
Definition: GUIGlobalSelection.cpp:34
GNEDemandElement::getDemandElementID
const std::string & getDemandElementID() const
returns DemandElement ID
Definition: GNEDemandElement.cpp:524
GUIGlObject::buildCenterPopupEntry
void buildCenterPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to center to the object.
Definition: GUIGlObject.cpp:217
GUIGlObject::buildPositionCopyEntry
void buildPositionCopyEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to copy the cursor position if geo projection is used,...
Definition: GUIGlObject.cpp:267
GNEVehicle
Definition: GNEVehicle.h:36
SUMOVehicleParameter::arrivalPosLatProcedure
ArrivalPosLatDefinition arrivalPosLatProcedure
Information how the vehicle shall choose the lateral arrival position.
Definition: SUMOVehicleParameter.h:525
Parameterised::setParameter
void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
Definition: Parameterised.cpp:45
GNENet::retrieveEdge
GNEEdge * retrieveEdge(const std::string &id, bool failHard=true)
get edge by id
Definition: GNENet.cpp:1020
GNEVehicle::getParentName
std::string getParentName() const
Returns the name of the parent object.
Definition: GNEVehicle.cpp:756
SUMO_TAG_ROUTE
begin/end of the description of a route
Definition: SUMOXMLDefinitions.h:126
GNEVehicle::GNESelectedVehiclesPopupMenu::myTransformToVehicle
FXMenuCommand * myTransformToVehicle
menu command for transform to vehicle
Definition: GNEVehicle.h:115
Parameterised::clearParameter
void clearParameter()
Clears the parameter map.
Definition: Parameterised.cpp:99
getVehicleShapeID
SUMOVehicleShape getVehicleShapeID(const std::string &name)
Returns the class id of the shape class given by its name.
Definition: SUMOVehicleClass.cpp:343
SUMO_ATTR_MINGAP
Definition: SUMOXMLDefinitions.h:460
GNEVehicle::getPopUpMenu
GUIGLObjectPopupMenu * getPopUpMenu(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own popup-menu.
Definition: GNEVehicle.cpp:735
GNEVehicle.h
GUIVisualizationSettings::personName
GUIVisualizationTextSettings personName
Definition: GUIVisualizationSettings.h:532
GNEVehicle::GNESingleVehiclePopupMenu
class used in GUIGLObjectPopupMenu for single vehicle transformations
Definition: GNEVehicle.h:40
GNEDemandElement::RouteCalculator::calculateDijkstraRoute
std::vector< GNEEdge * > calculateDijkstraRoute(SUMOVehicleClass vClass, const std::vector< GNEEdge * > &partialEdges) const
calculate Dijkstra route between a list of partial edges
Definition: GNEDemandElement.cpp:225
GNE_ATTR_SELECTED
element is selected
Definition: SUMOXMLDefinitions.h:968
MID_GNE_VEHICLE_TRANSFORM
transform vehicle to another vehicle type (ej: flow to trip)
Definition: GUIAppEnum.h:935
StringTokenizer.h
GNEViewNet::getEditModes
const GNEViewNetHelper::EditModes & getEditModes() const
get edit modes
Definition: GNEViewNet.cpp:399
SUMO_ATTR_END
weights: time range end
Definition: SUMOXMLDefinitions.h:677
Boundary::grow
Boundary & grow(double by)
extends the boundary by the given amount
Definition: Boundary.cpp:301
DepartSpeedDefinition
DepartSpeedDefinition
Possible ways to choose the departure speed.
Definition: SUMOVehicleParameter.h:186
GUIVisualizationSettings::drawDetail
bool drawDetail(const double detail, const double exaggeration) const
check if details can be drawn for the given GUIVisualizationDetailSettings and current scale and exxa...
Definition: GUIVisualizationSettings.cpp:1621
VEHPARS_PERIOD_SET
const int VEHPARS_PERIOD_SET
Definition: SUMOVehicleParameter.h:53
GNEVehicle::GNESingleVehiclePopupMenu::onCmdTransform
long onCmdTransform(FXObject *obj, FXSelector, void *)
Called to transform the current vehicle to another vehicle type.
Definition: GNEVehicle.cpp:129
GNEVehicle::GNESelectedVehiclesPopupMenu::myTransformAllVehiclesToVehicle
FXMenuCommand * myTransformAllVehiclesToVehicle
menu command for transform all selected vehicles to vehicle
Definition: GNEVehicle.h:133
SUMO_ATTR_DEPARTPOS
Definition: SUMOXMLDefinitions.h:434
GNESelectorFrame::LockGLObjectTypes::removeLockedObject
void removeLockedObject(const GUIGlObjectType type)
set object unselected
Definition: GNESelectorFrame.cpp:574
GNEVehicle::GNESelectedVehiclesPopupMenu::myTransformAllVehiclesToRouteFlowWithEmbeddedRoute
FXMenuCommand * myTransformAllVehiclesToRouteFlowWithEmbeddedRoute
menu command for transform all selected vehicles to route flow with an embedded route
Definition: GNEVehicle.h:142
GNEAttributeCarrier::getTagStr
const std::string & getTagStr() const
get tag assigned to this object in string format
Definition: GNEAttributeCarrier.cpp:1165
GNEUndoList
Definition: GNEUndoList.h:49
SUMO_ATTR_VEHSPERHOUR
Definition: SUMOXMLDefinitions.h:783
GNEVehicle::drawGL
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
Definition: GNEVehicle.cpp:777
MID_COPY_TYPED_NAME
Copy typed object name - popup entry.
Definition: GUIAppEnum.h:371
SUMOVehicleParameter::parseDepartPos
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.
Definition: SUMOVehicleParameter.cpp:287
GNEVehicle::moveGeometry
void moveGeometry(const Position &offset)
change the position of the element geometry without saving in undoList
Definition: GNEVehicle.cpp:536
GUIVisualizationSettings
Stores the information about how to visualize structures.
Definition: GUIVisualizationSettings.h:346
SUMOVehicleParameter::departPosLatProcedure
DepartPosLatDefinition departPosLatProcedure
Information how the vehicle shall choose the lateral departure position.
Definition: SUMOVehicleParameter.h:497
SUMOVehicleParameter::repetitionNumber
int repetitionNumber
Definition: SUMOVehicleParameter.h:538
GNEHierarchicalElementParents::changeEdgeParents
void changeEdgeParents(GNEShape *elementChild, const std::string &newEdgeIDs)
change edge parents of a shape
Definition: GNEHierarchicalElementParents.cpp:340
VEHPARS_END_SET
const int VEHPARS_END_SET
Definition: SUMOVehicleParameter.h:51
GNEVehicle::GNESelectedVehiclesPopupMenu::myTransformAllVehiclesToFlow
FXMenuCommand * myTransformAllVehiclesToFlow
menu command for transform all selected vehicles to flow
Definition: GNEVehicle.h:148
NBEdge::Connection
A structure which describes a connection between edges or lanes.
Definition: NBEdge.h:184
GNEHierarchicalElementChildren::getDemandElementChildren
const std::vector< GNEDemandElement * > & getDemandElementChildren() const
return vector of demand elements that have as Parent this edge (For example, Calibrators)
Definition: GNEHierarchicalElementChildren.cpp:297
SUMOVehicleParameter::getArrivalLane
std::string getArrivalLane() const
obtain arrival lane parameter in string format
Definition: SUMOVehicleParameter.cpp:679
SumoXMLAttr
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
Definition: SUMOXMLDefinitions.h:373
NBNode.h
GUIVisualizationColorSettings::selectedVehicleColor
RGBColor selectedVehicleColor
vehicle selection color
Definition: GUIVisualizationSettings.h:154
SUMO_ATTR_NUMBER
Definition: SUMOXMLDefinitions.h:664
PositionVector::area
double area() const
Returns the area (0 for non-closed)
Definition: PositionVector.cpp:502
GLO_ROUTEFLOW
a routeFlow
Definition: GUIGlObjectTypes.h:148
SUMOVehicleParameter::getArrivalSpeed
std::string getArrivalSpeed() const
obtain arrival speed parameter in string format
Definition: SUMOVehicleParameter.cpp:745
GUIPropertyScheme::getColor
const T getColor(const double value) const
Definition: GUIPropertyScheme.h:111
GNELane
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:46
SUMO_ATTR_ARRIVALLANE
Definition: SUMOXMLDefinitions.h:437
GNEVehicle::endGeometryMoving
void endGeometryMoving()
end geometry movement
Definition: GNEVehicle.cpp:530
GNEDemandElement::drawUsingSelectColor
bool drawUsingSelectColor() const
check if attribute carrier must be drawn using selecting color.
Definition: GNEDemandElement.cpp:561
GNEChange_Attribute.h
GNENet.h
GUIBaseVehicleHelper::drawAction_drawVehicleAsTrianglePlus
static void drawAction_drawVehicleAsTrianglePlus(const double width, const double length)
draw vehicle as a triangle
Definition: GUIBaseVehicleHelper.cpp:127
GUIPropertySchemeStorage::getActive
int getActive() const
Definition: GUIPropertySchemeStorage.h:76
SUMOVehicleParameter::departPos
double departPos
(optional) The position the vehicle shall depart from
Definition: SUMOVehicleParameter.h:488
SUMOVehicleParameter::departSpeedProcedure
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle's initial speed shall be chosen.
Definition: SUMOVehicleParameter.h:503
GUIVisualizationSizeSettings::getExaggeration
double getExaggeration(const GUIVisualizationSettings &s, const GUIGlObject *o, double factor=20) const
return the drawing size including exaggeration and constantSize values
Definition: GUIVisualizationSettings.cpp:212
SUMO_TAG_TRIP
a single trip definition (used by router)
Definition: SUMOXMLDefinitions.h:146
GUISelectedStorage::deselect
void deselect(GUIGlID id)
Deselects the object with the given id.
Definition: GUISelectedStorage.cpp:131
GNEViewNet::getViewParent
GNEViewParent * getViewParent() const
get the net object
Definition: GNEViewNet.cpp:921
GNERouteHandler.h
GNESelectorFrame::getLockGLObjectTypes
LockGLObjectTypes * getLockGLObjectTypes() const
get selected items Modul
Definition: GNESelectorFrame.cpp:460
RGBColor::WHITE
static const RGBColor WHITE
Definition: RGBColor.h:197
GNEUndoList.h
Boundary::ymax
double ymax() const
Returns maximum y-coordinate.
Definition: Boundary.cpp:137
GNEVehicle::unselectAttributeCarrier
void unselectAttributeCarrier(bool changeFlag=true)
unselect attribute carrier using GUIGlobalSelection
Definition: GNEVehicle.cpp:924
SUMOVehicleParameter::arrivalSpeed
double arrivalSpeed
(optional) The final speed of the vehicle (not used yet)
Definition: SUMOVehicleParameter.h:528
GUIPropertySchemeStorage< GUIColorScheme >
GNENetElement::NetElementGeometry::shapeLengths
std::vector< double > shapeLengths
The lengths of the single shape parts.
Definition: GNENetElement.h:63
GUIVisualizationSettings::drawForSelecting
bool drawForSelecting
whether drawing is performed for the purpose of selecting objects
Definition: GUIVisualizationSettings.h:635
NBEdge::getTurnDestination
NBEdge * getTurnDestination(bool possibleDestination=false) const
Definition: NBEdge.cpp:3116
ArrivalSpeedDefinition
ArrivalSpeedDefinition
Possible ways to choose the arrival speed.
Definition: SUMOVehicleParameter.h:264
GNESelectorFrame::LockGLObjectTypes::addedLockedObject
void addedLockedObject(const GUIGlObjectType type)
set object selected
Definition: GNESelectorFrame.cpp:568