Eclipse SUMO - Simulation of Urban MObility
GNEVehicleType.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 // Definition of Vehicle Types in NETEDIT
16 /****************************************************************************/
17 
18 // ===========================================================================
19 // included modules
20 // ===========================================================================
21 
22 #include <netedit/GNENet.h>
23 #include <netedit/GNEViewNet.h>
24 #include <netedit/GNEUndoList.h>
25 #include <netedit/GNEViewParent.h>
31 
32 #include "GNEVehicleType.h"
33 
34 
35 // ===========================================================================
36 // member method definitions
37 // ===========================================================================
38 
39 
40 GNEVehicleType::GNEVehicleType(GNEViewNet* viewNet, const std::string& vTypeID, const SUMOVehicleClass& defaultVClass, SumoXMLTag tag) :
41  GNEDemandElement(vTypeID, viewNet, GLO_VTYPE, tag, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}),
42  SUMOVTypeParameter(vTypeID),
43  myDefaultVehicleType(true),
44 myDefaultVehicleTypeModified(false) {
45  // set default vehicle class
46  vehicleClass = defaultVClass;
47  parametersSet |= VTYPEPARS_VEHICLECLASS_SET;
48  // init Rail Visualization Parameters
49  initRailVisualizationParameters();
50 }
51 
52 
54  GNEDemandElement(vTypeParameter.id, viewNet, GLO_VTYPE, tag, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}),
55 SUMOVTypeParameter(vTypeParameter),
56 myDefaultVehicleType(false),
57 myDefaultVehicleTypeModified(false) {
58  // if we're creating a Person Type, set manually VClass
59  if (tag == SUMO_TAG_PTYPE) {
60  vehicleClass = SVC_PEDESTRIAN;
61  parametersSet |= VTYPEPARS_VEHICLECLASS_SET;
62  }
63  // init Rail Visualization Parameters
64  initRailVisualizationParameters();
65 }
66 
67 
68 GNEVehicleType::GNEVehicleType(GNEViewNet* viewNet, const std::string& vTypeID, GNEVehicleType* vTypeOriginal) :
69  GNEDemandElement(vTypeID, viewNet, GLO_VTYPE, vTypeOriginal->getTagProperty().getTag(), {}, {}, {}, {}, {}, {}, {}, {}, {}, {}),
70 SUMOVTypeParameter(*vTypeOriginal),
71 myDefaultVehicleType(false),
72 myDefaultVehicleTypeModified(false) {
73  // change manually the ID (to avoid to use the ID of vTypeOriginal)
74  id = vTypeID;
75  // init Rail Visualization Parameters
76  initRailVisualizationParameters();
77 }
78 
79 
81 
82 
83 void
85  // only write default vehicle types if it was modified
88  write(device);
89  }
90  } else {
91  write(device);
92  }
93 }
94 
95 
96 GNEEdge*
98  return nullptr;
99 }
100 
101 
102 GNEEdge*
104  return nullptr;
105 }
106 
107 
110  return vehicleClass;
111 }
112 
113 
114 const RGBColor&
116  return color;
117 }
118 
119 
120 void
122  // Nothing to compute
123 }
124 
125 
126 void
128  // VTypes cannot be moved
129 }
130 
131 
132 void
134  // VTypes cannot be moved
135 }
136 
137 
138 void
140  // VTypes cannot be moved
141 }
142 
143 
144 void
146  // VTypes cannot be moved
147 }
148 
149 
150 void
152  // Currently this additional doesn't own a Geometry
153 }
154 
155 
156 Position
158  return Position();
159 }
160 
161 
162 std::string
164  return myViewNet->getNet()->getMicrosimID();
165 }
166 
167 
168 Boundary
170  // Vehicle Types doesn't have boundaries
171  return Boundary(-0.1, -0.1, 0.1, 0.1);
172 }
173 
174 
175 void
177  // Vehicle Types aren't draw
178 }
179 
180 
181 void
183  if (!myViewNet) {
184  throw ProcessError("ViewNet cannot be nullptr");
185  } else {
187  // add object of list into selected objects
189  if (changeFlag) {
190  mySelected = true;
191  }
192  }
193 }
194 
195 
196 void
198  if (!myViewNet) {
199  throw ProcessError("ViewNet cannot be nullptr");
200  } else {
202  // remove object of list of selected objects
204  if (changeFlag) {
205  mySelected = false;
206 
207  }
208  }
209 }
210 
211 
212 std::string
214  // obtain default values depending of vehicle class
215  VClassDefaultValues defaultValues(vehicleClass);
216  switch (key) {
217  case SUMO_ATTR_ID:
218  return getDemandElementID();
219  // CFM Attributes
220  case SUMO_ATTR_ACCEL:
221  case SUMO_ATTR_DECEL:
224  case SUMO_ATTR_SIGMA:
225  case SUMO_ATTR_TAU:
226  // this CFM has default values
228  // JM Attributes
238  // this JM has default values
242  return toString(impatience);
243  } else {
245  }
246  // LCM Attributes
253  case SUMO_ATTR_LCA_PUSHY:
265  /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
267  //
269  case SUMO_ATTR_TMP1:
270  case SUMO_ATTR_TMP2:
271  case SUMO_ATTR_TMP3:
272  case SUMO_ATTR_TMP4:
273  case SUMO_ATTR_TMP5:
281  case SUMO_ATTR_K:
285  return getCFParamString(key, "");
286  // Mutable values
287  case SUMO_ATTR_LENGTH:
289  return toString(length);
290  } else {
291  return toString(defaultValues.length);
292  }
293  case SUMO_ATTR_MINGAP:
295  return toString(minGap);
296  } else {
297  return toString(defaultValues.minGap);
298  }
299  case SUMO_ATTR_MAXSPEED:
301  return toString(maxSpeed);
302  } else {
303  return toString(defaultValues.maxSpeed);
304  }
307  return toString(speedFactor.getParameter()[0]);
308  } else {
309  return toString(defaultValues.speedFactor.getParameter()[0]);
310  }
311  case SUMO_ATTR_SPEEDDEV:
313  return toString(speedFactor.getParameter()[1]);
314  } else {
315  return toString(defaultValues.speedFactor.getParameter()[1]);
316  }
319  return toString(personCapacity);
320  } else {
321  return toString(defaultValues.personCapacity);
322  }
325  return toString(containerCapacity);
326  } else {
327  return toString(defaultValues.containerCapacity);
328  }
329  case SUMO_ATTR_OSGFILE:
331  return osgFile;
332  } else {
333  return defaultValues.osgFile;
334  }
335  case SUMO_ATTR_COLOR:
337  return toString(color);
338  } else {
339  return "";
340  }
341  case SUMO_ATTR_VCLASS:
343  return toString(vehicleClass);
344  } else {
346  }
350  } else {
351  return PollutantsInterface::getName(defaultValues.emissionClass);
352  }
353  case SUMO_ATTR_GUISHAPE:
355  return getVehicleShapeName(shape);
356  } else {
357  return getVehicleShapeName(defaultValues.shape);
358  }
359  case SUMO_ATTR_WIDTH:
361  return toString(width);
362  } else {
363  return toString(defaultValues.width);
364  }
365  case SUMO_ATTR_HEIGHT:
367  return toString(height);
368  } else {
369  return toString(defaultValues.height);
370  }
371  case SUMO_ATTR_IMGFILE:
373  return imgFile;
374  } else {
376  }
380  } else {
382  }
386  } else {
388  }
392  } else {
394  }
398  } else {
400  }
403  return toString(latAlignment);
404  } else {
406  }
409  return toString(minGapLat);
410  } else {
412  }
415  return toString(maxSpeedLat);
416  } else {
418  }
421  return toString(actionStepLength);
422  } else {
424  }
425  case SUMO_ATTR_PROB:
428  } else {
430  }
433  return toString(hasDriverState);
434  } else {
436  }
439  return toString(carriageLength);
440  } else {
441  return toString(defaultValues.carriageLength);
442  }
445  return toString(locomotiveLength);
446  } else {
447  return toString(defaultValues.locomotiveLength);
448  }
451  return toString(carriageGap);
452  } else {
454  }
455  case GNE_ATTR_GENERIC:
456  return getGenericParametersStr();
462  if (myDefaultVehicleType) {
464  } else {
465  return toString(false);
466  }
467  default:
468  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
469  }
470 }
471 
472 
473 double
475  // obtain default values depending of vehicle class
476  VClassDefaultValues defaultValues(vehicleClass);
477  switch (key) {
478  case SUMO_ATTR_LENGTH:
480  return length;
481  } else {
482  return defaultValues.length;
483  }
484  case SUMO_ATTR_MINGAP:
486  return minGap;
487  } else {
488  return defaultValues.minGap;
489  }
490  case SUMO_ATTR_WIDTH:
492  return width;
493  } else {
494  return defaultValues.width;
495  }
496  case SUMO_ATTR_HEIGHT:
498  return height;
499  } else {
500  return defaultValues.height;
501  }
502  case SUMO_ATTR_MAXSPEED:
504  return maxSpeed;
505  } else {
506  return defaultValues.maxSpeed;
507  }
508  default:
509  throw InvalidArgument(getTagStr() + " doesn't have a double attribute of type '" + toString(key) + "'");
510  }
511 }
512 
513 
514 void
515 GNEVehicleType::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) {
516  if (value == getAttribute(key)) {
517  return; //avoid needless changes, later logic relies on the fact that attributes have changed
518  }
519  switch (key) {
520  case SUMO_ATTR_ID:
521  undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), key, value));
522  break;
523  // CFM Attributes
524  case SUMO_ATTR_ACCEL:
525  case SUMO_ATTR_DECEL:
528  case SUMO_ATTR_SIGMA:
529  case SUMO_ATTR_TAU:
531  case SUMO_ATTR_TMP1:
532  case SUMO_ATTR_TMP2:
533  case SUMO_ATTR_TMP3:
534  case SUMO_ATTR_TMP4:
535  case SUMO_ATTR_TMP5:
543  case SUMO_ATTR_K:
547  // JM Attributes
558  // LCM Attributes
565  case SUMO_ATTR_LCA_PUSHY:
577  /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
578  //
579  case SUMO_ATTR_LENGTH:
580  case SUMO_ATTR_MINGAP:
581  case SUMO_ATTR_MAXSPEED:
583  case SUMO_ATTR_SPEEDDEV:
584  case SUMO_ATTR_COLOR:
585  case SUMO_ATTR_VCLASS:
587  case SUMO_ATTR_GUISHAPE:
588  case SUMO_ATTR_WIDTH:
589  case SUMO_ATTR_HEIGHT:
590  case SUMO_ATTR_IMGFILE:
601  case SUMO_ATTR_PROB:
603  case SUMO_ATTR_OSGFILE:
607  case GNE_ATTR_GENERIC:
608  // if we change the original value of a default vehicle Type, change also flag "myDefaultVehicleType"
609  if (myDefaultVehicleType) {
610  undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), true, GNE_ATTR_DEFAULT_VTYPE_MODIFIED, "true"));
611  }
612  undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), true, key, value));
613  break;
615  undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), true, key, value));
616  break;
617  default:
618  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
619  }
620 }
621 
622 
623 bool
624 GNEVehicleType::isValid(SumoXMLAttr key, const std::string& value) {
625  // a empty value is always valid except for IDs
626  if ((key != SUMO_ATTR_ID) && value.empty()) {
627  return true;
628  }
629 
630  switch (key) {
631  case SUMO_ATTR_ID:
632  // Vtypes and PTypes shares namespace
634  (myViewNet->getNet()->retrieveDemandElement(SUMO_TAG_VTYPE, value, false) == nullptr) &&
635  (myViewNet->getNet()->retrieveDemandElement(SUMO_TAG_PTYPE, value, false) == nullptr)) {
636  return true;
637  } else {
638  return false;
639  }
640  // CFM Attributes
641  case SUMO_ATTR_SIGMA:
642  return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
643  case SUMO_ATTR_ACCEL:
644  case SUMO_ATTR_DECEL:
647  case SUMO_ATTR_TAU:
649  case SUMO_ATTR_TMP1:
650  case SUMO_ATTR_TMP2:
651  case SUMO_ATTR_TMP3:
652  case SUMO_ATTR_TMP4:
653  case SUMO_ATTR_TMP5:
660  case SUMO_ATTR_K:
664  return canParse<double>(value);
666  // rail string
668  // JM Attributes
670  return canParse<double>(value) && (parse<double>(value) >= 0);
672  return canParse<double>(value) && (parse<double>(value) >= -1);
674  return canParse<double>(value) && (parse<double>(value) >= -1);
676  return canParse<double>(value) && (parse<double>(value) >= -1);
678  return canParse<double>(value) && (parse<double>(value) >= 0);
680  return canParse<double>(value) && (parse<double>(value) >= 0);
682  return canParse<double>(value) && (parse<double>(value) >= 0);
684  return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
686  return canParse<double>(value) && (parse<double>(value) >= 0);
688  return canParse<double>(value) && (parse<double>(value) >= 0);
689  // LCM Attributes
696  case SUMO_ATTR_LCA_PUSHY:
697  return canParse<double>(value);
701  case SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE: // 0 mean disabled
702  case SUMO_ATTR_LCA_TIME_TO_IMPATIENCE: // 0 mean disabled
703  case SUMO_ATTR_LCA_OVERTAKE_RIGHT: // 0 mean disabled
704  return canParse<double>(value) && (parse<double>(value) >= 0);
710  return canParse<double>(value) && (parse<double>(value) > 0);
711  /* case SUMO_ATTR_LCA_EXPERIMENTAL1:
712  return true;
713  */
714  //
715  case SUMO_ATTR_LENGTH:
716  return canParse<double>(value) && (parse<double>(value) > 0);
717  case SUMO_ATTR_MINGAP:
718  return canParse<double>(value) && (parse<double>(value) >= 0);
719  case SUMO_ATTR_MAXSPEED:
720  return canParse<double>(value) && (parse<double>(value) >= 0);
722  return canParse<double>(value) && (parse<double>(value) >= 0);
723  case SUMO_ATTR_SPEEDDEV:
724  return canParse<double>(value) && (parse<double>(value) >= 0);
725  case SUMO_ATTR_COLOR:
726  if (value.empty()) {
727  return true;
728  } else {
729  return canParse<RGBColor>(value);
730  }
731  case SUMO_ATTR_VCLASS:
732  return canParseVehicleClasses(value);
734  // check if given value correspond to a string of PollutantsInterface::getAllClassesStr()
735  for (const auto& i : PollutantsInterface::getAllClassesStr()) {
736  if (value == i) {
737  return true;
738  }
739  }
740  return false;
741  case SUMO_ATTR_GUISHAPE:
742  if (value == "all") {
743  return false;
744  } else {
745  return canParseVehicleShape(value);
746  }
747  case SUMO_ATTR_WIDTH:
748  return canParse<double>(value);
749  case SUMO_ATTR_HEIGHT:
750  return canParse<double>(value);
751  case SUMO_ATTR_IMGFILE:
758  return canParse<int>(value);
760  return canParse<int>(value);
762  return canParse<double>(value);
764  return canParse<double>(value);
768  return canParse<double>(value);
770  return canParse<double>(value);
772  return canParse<double>(value) && (parse<double>(value) >= 0);
773  case SUMO_ATTR_PROB:
774  return canParse<double>(value) && (parse<double>(value) >= 0);
776  return canParse<bool>(value);
777  case SUMO_ATTR_OSGFILE:
780  return canParse<double>(value) && (parse<double>(value) >= -1);
782  return canParse<double>(value) && (parse<double>(value) >= -1);
784  return canParse<double>(value) && (parse<double>(value) >= 0);
785  case GNE_ATTR_GENERIC:
786  return isGenericParametersValid(value);
788  if (myDefaultVehicleType) {
789  return canParse<bool>(value);
790  } else {
791  return false;
792  }
793  default:
794  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
795  }
796 }
797 
798 
799 void
801 
802 }
803 
804 bool
806  switch (key) {
807  case SUMO_ATTR_LENGTH:
809  case SUMO_ATTR_MINGAP:
811  case SUMO_ATTR_MAXSPEED:
815  case SUMO_ATTR_SPEEDDEV:
821  case SUMO_ATTR_OSGFILE:
829  default:
830  return true;
831  }
832 }
833 
834 
835 std::string
837  return getTagStr();
838 }
839 
840 
841 std::string
843  return getTagStr() + ": " + getAttribute(SUMO_ATTR_ID) ;
844 }
845 
846 
847 void
849  // open undo list and overwritte all values of default VType
850  undoList->p_begin("update default " + vType->getTagStr() + " '" + DEFAULT_VTYPE_ID + "'");
851  // CFM values
852  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_ACCEL, "").empty()) {
853  vType->setAttribute(SUMO_ATTR_ACCEL, toString(newVTypeParameter->getCFParam(SUMO_ATTR_ACCEL, 0)), undoList);
854  }
855  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_DECEL, "").empty()) {
856  vType->setAttribute(SUMO_ATTR_DECEL, toString(newVTypeParameter->getCFParam(SUMO_ATTR_DECEL, 0)), undoList);
857  }
858  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_APPARENTDECEL, "").empty()) {
859  vType->setAttribute(SUMO_ATTR_APPARENTDECEL, toString(newVTypeParameter->getCFParam(SUMO_ATTR_APPARENTDECEL, 0)), undoList);
860  }
861  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_EMERGENCYDECEL, "").empty()) {
862  vType->setAttribute(SUMO_ATTR_EMERGENCYDECEL, toString(newVTypeParameter->getCFParam(SUMO_ATTR_EMERGENCYDECEL, 0)), undoList);
863  }
864  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_SIGMA, "").empty()) {
865  vType->setAttribute(SUMO_ATTR_SIGMA, toString(newVTypeParameter->getCFParam(SUMO_ATTR_SIGMA, 0)), undoList);
866  }
867  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TAU, "").empty()) {
868  vType->setAttribute(SUMO_ATTR_TAU, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TAU, 0)), undoList);
869  }
870  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_COLLISION_MINGAP_FACTOR, "").empty()) {
872  }
873  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TMP1, "").empty()) {
874  vType->setAttribute(SUMO_ATTR_TMP1, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TMP1, 0)), undoList);
875  }
876  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TMP2, "").empty()) {
877  vType->setAttribute(SUMO_ATTR_TMP2, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TMP2, 0)), undoList);
878  }
879  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TMP3, "").empty()) {
880  vType->setAttribute(SUMO_ATTR_TMP3, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TMP3, 0)), undoList);
881  }
882  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TMP4, "").empty()) {
883  vType->setAttribute(SUMO_ATTR_TMP4, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TMP4, 0)), undoList);
884  }
885  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TMP5, "").empty()) {
886  vType->setAttribute(SUMO_ATTR_TMP5, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TMP5, 0)), undoList);
887  }
888  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_PWAGNER2009_TAULAST, "").empty()) {
890  }
891  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_PWAGNER2009_APPROB, "").empty()) {
893  }
894  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_IDMM_ADAPT_FACTOR, "").empty()) {
896  }
897  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_IDMM_ADAPT_TIME, "").empty()) {
899  }
900  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_WIEDEMANN_SECURITY, "").empty()) {
902  }
903  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_WIEDEMANN_ESTIMATION, "").empty()) {
905  }
906  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TRAIN_TYPE, "").empty()) {
907  vType->setAttribute(SUMO_ATTR_TRAIN_TYPE, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TRAIN_TYPE, 0)), undoList);
908  }
909  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_K, "").empty()) {
910  vType->setAttribute(SUMO_ATTR_K, toString(newVTypeParameter->getCFParam(SUMO_ATTR_K, 0)), undoList);
911  }
912  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_KERNER_PHI, "").empty()) {
913  vType->setAttribute(SUMO_ATTR_CF_KERNER_PHI, toString(newVTypeParameter->getCFParam(SUMO_ATTR_CF_KERNER_PHI, 0)), undoList);
914  }
915  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_IDM_DELTA, "").empty()) {
916  vType->setAttribute(SUMO_ATTR_CF_IDM_DELTA, toString(newVTypeParameter->getCFParam(SUMO_ATTR_CF_IDM_DELTA, 0)), undoList);
917  }
918  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_IDM_STEPPING, "").empty()) {
919  vType->setAttribute(SUMO_ATTR_CF_IDM_STEPPING, toString(newVTypeParameter->getCFParam(SUMO_ATTR_CF_IDM_STEPPING, 0)), undoList);
920  }
921  // JM values
922  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_CROSSING_GAP, "").empty()) {
923  vType->setAttribute(SUMO_ATTR_JM_CROSSING_GAP, toString(newVTypeParameter->getCFParam(SUMO_ATTR_JM_CROSSING_GAP, 0)), undoList);
924  }
925  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME, "").empty()) {
927  }
928  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME, "").empty()) {
930  }
931  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME, "").empty()) {
933  }
934  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_DRIVE_RED_SPEED, "").empty()) {
936  }
937  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_IGNORE_FOE_PROB, "").empty()) {
939  }
940  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_IGNORE_FOE_SPEED, "").empty()) {
942  }
943  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_SIGMA_MINOR, "").empty()) {
944  vType->setAttribute(SUMO_ATTR_JM_SIGMA_MINOR, toString(newVTypeParameter->getCFParam(SUMO_ATTR_JM_SIGMA_MINOR, 0)), undoList);
945  }
946  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_TIMEGAP_MINOR, "").empty()) {
947  vType->setAttribute(SUMO_ATTR_JM_TIMEGAP_MINOR, toString(newVTypeParameter->getCFParam(SUMO_ATTR_JM_TIMEGAP_MINOR, 0)), undoList);
948  }
949  if (newVTypeParameter->wasSet(VTYPEPARS_IMPATIENCE_SET)) {
950  vType->setAttribute(SUMO_ATTR_IMPATIENCE, toString(newVTypeParameter->impatience), undoList);
951  }
952  // LCM values
953  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_STRATEGIC_PARAM, "").empty()) {
955  }
956  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_COOPERATIVE_PARAM, "").empty()) {
958  }
959  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_SPEEDGAIN_PARAM, "").empty()) {
961  }
962  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_KEEPRIGHT_PARAM, "").empty()) {
964  }
965  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_SUBLANE_PARAM, "").empty()) {
967  }
968  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_OPPOSITE_PARAM, "").empty()) {
970  }
971  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_PUSHY, "").empty()) {
972  vType->setAttribute(SUMO_ATTR_LCA_PUSHY, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_PUSHY, 0)), undoList);
973  }
974  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_PUSHYGAP, "").empty()) {
975  vType->setAttribute(SUMO_ATTR_LCA_PUSHYGAP, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_PUSHYGAP, 0)), undoList);
976  }
977  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_ASSERTIVE, "").empty()) {
978  vType->setAttribute(SUMO_ATTR_LCA_ASSERTIVE, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_ASSERTIVE, 0)), undoList);
979  }
980  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_IMPATIENCE, "").empty()) {
981  vType->setAttribute(SUMO_ATTR_LCA_IMPATIENCE, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_IMPATIENCE, 0)), undoList);
982  }
983  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_TIME_TO_IMPATIENCE, "").empty()) {
985  }
986  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_ACCEL_LAT, "").empty()) {
987  vType->setAttribute(SUMO_ATTR_LCA_ACCEL_LAT, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_ACCEL_LAT, 0)), undoList);
988  }
989  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_LOOKAHEADLEFT, "").empty()) {
991  }
992  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_SPEEDGAINRIGHT, "").empty()) {
994  }
995  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_MAXSPEEDLATSTANDING, "").empty()) {
997  }
998  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_MAXSPEEDLATFACTOR, "").empty()) {
1000  }
1001  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE, "").empty()) {
1003  }
1004  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_OVERTAKE_RIGHT, "").empty()) {
1006  }
1007  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_EXPERIMENTAL1, "").empty()) {
1008  vType->setAttribute(SUMO_ATTR_LCA_EXPERIMENTAL1, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_EXPERIMENTAL1, 0)), undoList);
1009  }
1010  //
1011  if (newVTypeParameter->wasSet(VTYPEPARS_LENGTH_SET)) {
1012  vType->setAttribute(SUMO_ATTR_LENGTH, toString(newVTypeParameter->length), undoList);
1013  }
1014  if (newVTypeParameter->wasSet(VTYPEPARS_MINGAP_SET)) {
1015  vType->setAttribute(SUMO_ATTR_MINGAP, toString(newVTypeParameter->minGap), undoList);
1016  }
1017  if (newVTypeParameter->wasSet(VTYPEPARS_MAXSPEED_SET)) {
1018  vType->setAttribute(SUMO_ATTR_MAXSPEED, toString(newVTypeParameter->maxSpeed), undoList);
1019  }
1020  if (newVTypeParameter->wasSet(VTYPEPARS_SPEEDFACTOR_SET)) {
1021  vType->setAttribute(SUMO_ATTR_SPEEDFACTOR, toString(newVTypeParameter->speedFactor.getParameter()[0]), undoList);
1022  }
1023  if (newVTypeParameter->wasSet(VTYPEPARS_SPEEDFACTOR_SET)) {
1024  vType->setAttribute(SUMO_ATTR_SPEEDDEV, toString(newVTypeParameter->speedFactor.getParameter()[1]), undoList);
1025  }
1026  if (newVTypeParameter->wasSet(VTYPEPARS_COLOR_SET)) {
1027  vType->setAttribute(SUMO_ATTR_COLOR, toString(newVTypeParameter->color), undoList);
1028  }
1029  if (newVTypeParameter->wasSet(VTYPEPARS_EMISSIONCLASS_SET)) {
1030  vType->setAttribute(SUMO_ATTR_EMISSIONCLASS, PollutantsInterface::getName(newVTypeParameter->emissionClass), undoList);
1031  }
1032  if (newVTypeParameter->wasSet(VTYPEPARS_SHAPE_SET)) {
1033  vType->setAttribute(SUMO_ATTR_GUISHAPE, getVehicleShapeName(newVTypeParameter->shape), undoList);
1034  }
1035  if (newVTypeParameter->wasSet(VTYPEPARS_WIDTH_SET)) {
1036  vType->setAttribute(SUMO_ATTR_WIDTH, toString(newVTypeParameter->width), undoList);
1037  }
1038  if (newVTypeParameter->wasSet(VTYPEPARS_HEIGHT_SET)) {
1039  vType->setAttribute(SUMO_ATTR_HEIGHT, toString(newVTypeParameter->height), undoList);
1040  }
1041  if (newVTypeParameter->wasSet(VTYPEPARS_IMGFILE_SET)) {
1042  vType->setAttribute(SUMO_ATTR_IMGFILE, toString(newVTypeParameter->imgFile), undoList);
1043  }
1044  if (newVTypeParameter->wasSet(VTYPEPARS_LANE_CHANGE_MODEL_SET)) {
1045  vType->setAttribute(SUMO_ATTR_LANE_CHANGE_MODEL, SUMOXMLDefinitions::LaneChangeModels.getString(newVTypeParameter->lcModel), undoList);
1046  }
1047  if (newVTypeParameter->wasSet(VTYPEPARS_CAR_FOLLOW_MODEL)) {
1048  vType->setAttribute(SUMO_ATTR_CAR_FOLLOW_MODEL, SUMOXMLDefinitions::CarFollowModels.getString(newVTypeParameter->cfModel), undoList);
1049  }
1050  if (newVTypeParameter->wasSet(VTYPEPARS_PERSON_CAPACITY)) {
1051  vType->setAttribute(SUMO_ATTR_PERSON_CAPACITY, toString(newVTypeParameter->personCapacity), undoList);
1052  }
1053  if (newVTypeParameter->wasSet(VTYPEPARS_CONTAINER_CAPACITY)) {
1054  vType->setAttribute(SUMO_ATTR_CONTAINER_CAPACITY, toString(newVTypeParameter->containerCapacity), undoList);
1055  }
1056  if (newVTypeParameter->wasSet(VTYPEPARS_BOARDING_DURATION)) {
1057  vType->setAttribute(SUMO_ATTR_BOARDING_DURATION, toString(newVTypeParameter->boardingDuration), undoList);
1058  }
1059  if (newVTypeParameter->wasSet(VTYPEPARS_LOADING_DURATION)) {
1060  vType->setAttribute(SUMO_ATTR_LOADING_DURATION, toString(newVTypeParameter->loadingDuration), undoList);
1061  }
1062  if (newVTypeParameter->wasSet(VTYPEPARS_LATALIGNMENT_SET)) {
1063  vType->setAttribute(SUMO_ATTR_LATALIGNMENT, toString(newVTypeParameter->latAlignment), undoList);
1064  }
1065  if (newVTypeParameter->wasSet(VTYPEPARS_MINGAP_LAT_SET)) {
1066  vType->setAttribute(SUMO_ATTR_MINGAP_LAT, toString(newVTypeParameter->minGapLat), undoList);
1067  }
1068  if (newVTypeParameter->wasSet(VTYPEPARS_MAXSPEED_LAT_SET)) {
1069  vType->setAttribute(SUMO_ATTR_MAXSPEED_LAT, toString(newVTypeParameter->maxSpeedLat), undoList);
1070  }
1071  if (newVTypeParameter->wasSet(VTYPEPARS_ACTIONSTEPLENGTH_SET)) {
1072  vType->setAttribute(SUMO_ATTR_ACTIONSTEPLENGTH, toString(newVTypeParameter->actionStepLength), undoList);
1073  }
1074  if (newVTypeParameter->wasSet(VTYPEPARS_HASDRIVERSTATE_SET)) {
1075  vType->setAttribute(SUMO_ATTR_HASDRIVERSTATE, toString(newVTypeParameter->hasDriverState), undoList);
1076  }
1077  if (newVTypeParameter->wasSet(VTYPEPARS_PROBABILITY_SET)) {
1078  vType->setAttribute(SUMO_ATTR_PROB, toString(newVTypeParameter->defaultProbability), undoList);
1079  }
1080  if (newVTypeParameter->wasSet(VTYPEPARS_OSGFILE_SET)) {
1081  vType->setAttribute(SUMO_ATTR_OSGFILE, toString(newVTypeParameter->osgFile), undoList);
1082  }
1083  if (newVTypeParameter->knowsParameter(toString(SUMO_ATTR_CARRIAGE_LENGTH))) {
1084  vType->setAttribute(SUMO_ATTR_CARRIAGE_LENGTH, newVTypeParameter->getParameter(toString(SUMO_ATTR_CARRIAGE_LENGTH), ""), undoList);
1085  }
1086  if (newVTypeParameter->knowsParameter(toString(SUMO_ATTR_LOCOMOTIVE_LENGTH))) {
1088  }
1089  if (newVTypeParameter->knowsParameter(toString(SUMO_ATTR_CARRIAGE_GAP))) {
1090  vType->setAttribute(SUMO_ATTR_CARRIAGE_GAP, newVTypeParameter->getParameter(toString(SUMO_ATTR_CARRIAGE_GAP), ""), undoList);
1091  }
1092  // parse generic parameters
1093  std::string genericParametersStr;
1094  // Generate an string using the following structure: "key1=value1|key2=value2|...
1095  for (auto i : newVTypeParameter->getParametersMap()) {
1096  genericParametersStr += i.first + "=" + i.second + "|";
1097  }
1098  // remove the last "|"
1099  if (!genericParametersStr.empty()) {
1100  genericParametersStr.pop_back();
1101  }
1102  if (genericParametersStr != vType->getGenericParametersStr()) {
1103  vType->setAttribute(GNE_ATTR_GENERIC, genericParametersStr, undoList);
1104  }
1105  // close undo list
1106  undoList->p_end();
1107 }
1108 
1109 
1110 void
1112  if (SUMOVTypeParameter::knowsParameter("carriageLength")) {
1115  } else if (wasSet(VTYPEPARS_SHAPE_SET)) {
1116  switch (shape) {
1117  case SVS_BUS_FLEXIBLE:
1118  carriageLength = 8.25; // 16.5 overall, 2 modules http://de.wikipedia.org/wiki/Ikarus_180
1119  carriageGap = 0;
1120  break;
1121  case SVS_RAIL:
1122  carriageLength = 24.5; // http://de.wikipedia.org/wiki/UIC-Y-Wagen_%28DR%29
1123  break;
1124  case SVS_RAIL_CAR:
1125  carriageLength = 16.85; // 67.4m overall, 4 carriages http://de.wikipedia.org/wiki/DB-Baureihe_423
1126  break;
1127  case SVS_RAIL_CARGO:
1128  carriageLength = 13.86; // UIC 571-1 http://de.wikipedia.org/wiki/Flachwagen
1129  break;
1130  case SVS_TRUCK_SEMITRAILER:
1131  carriageLength = 13.5;
1132  locomotiveLength = 2.5;
1133  carriageGap = 0.5;
1134  break;
1135  case SVS_TRUCK_1TRAILER:
1136  carriageLength = 6.75;
1137  locomotiveLength = 2.5 + 6.75;
1138  carriageGap = 0.5;
1139  break;
1140  default:
1141  break;
1142  }
1143  }
1144  if (SUMOVTypeParameter::knowsParameter("locomotiveLength")) {
1147  } else if (locomotiveLength <= 0) {
1149  }
1150  if (SUMOVTypeParameter::knowsParameter("carriageGap")) {
1153  }
1154 }
1155 
1156 
1157 std::string
1159  std::string result;
1160  // Generate an string using the following structure: "key1=value1|key2=value2|...
1161  for (auto i : getParametersMap()) {
1162  result += i.first + "=" + i.second + "|";
1163  }
1164  // remove the last "|"
1165  if (!result.empty()) {
1166  result.pop_back();
1167  }
1168  return result;
1169 }
1170 
1171 
1172 std::vector<std::pair<std::string, std::string> >
1174  std::vector<std::pair<std::string, std::string> > result;
1175  // iterate over parameters map and fill result
1176  for (auto i : getParametersMap()) {
1177  result.push_back(std::make_pair(i.first, i.second));
1178  }
1179  return result;
1180 }
1181 
1182 
1183 void
1184 GNEVehicleType::setGenericParametersStr(const std::string& value) {
1185  // clear parameters
1186  clearParameter();
1187  // separate value in a vector of string using | as separator
1188  std::vector<std::string> parsedValues;
1189  StringTokenizer stValues(value, "|", true);
1190  while (stValues.hasNext()) {
1191  parsedValues.push_back(stValues.next());
1192  }
1193  // check that parsed values (A=B)can be parsed in generic parameters
1194  for (auto i : parsedValues) {
1195  std::vector<std::string> parsedParameters;
1196  StringTokenizer stParam(i, "=", true);
1197  while (stParam.hasNext()) {
1198  parsedParameters.push_back(stParam.next());
1199  }
1200  // Check that parsed parameters are exactly two and contains valid chracters
1201  if (parsedParameters.size() == 2 && SUMOXMLDefinitions::isValidGenericParameterKey(parsedParameters.front()) && SUMOXMLDefinitions::isValidGenericParameterValue(parsedParameters.back())) {
1202  setParameter(parsedParameters.front(), parsedParameters.back());
1203  }
1204  }
1205 }
1206 
1207 // ===========================================================================
1208 // private
1209 // ===========================================================================
1210 
1211 void
1212 GNEVehicleType::setAttribute(SumoXMLAttr key, const std::string& value) {
1213  // obtain default values depending of vehicle class
1214  VClassDefaultValues defaultValues(vehicleClass);
1215  switch (key) {
1216  case SUMO_ATTR_ID:
1217  changeDemandElementID(value);
1218  id = value;
1219  break;
1220  // CFM Attributes
1221  case SUMO_ATTR_ACCEL:
1222  case SUMO_ATTR_DECEL:
1225  case SUMO_ATTR_SIGMA:
1226  case SUMO_ATTR_TAU:
1228  case SUMO_ATTR_TMP1:
1229  case SUMO_ATTR_TMP2:
1230  case SUMO_ATTR_TMP3:
1231  case SUMO_ATTR_TMP4:
1232  case SUMO_ATTR_TMP5:
1239  case SUMO_ATTR_TRAIN_TYPE:
1240  case SUMO_ATTR_K:
1244  // empty values means that value isn't set
1245  if (value.empty()) {
1246  const auto it = cfParameter.find(key);
1247  if (it != cfParameter.end()) {
1248  cfParameter.erase(it);
1249  }
1250  } else {
1251  cfParameter[key] = value;
1252  }
1253  break;
1254  // JM Attributes
1264  // empty values means that value isn't set
1265  if (value.empty()) {
1266  const auto it = jmParameter.find(key);
1267  if (it != jmParameter.end()) {
1268  jmParameter.erase(it);
1269  }
1270  } else {
1271  jmParameter[key] = value;
1272  }
1273  break;
1274  case SUMO_ATTR_IMPATIENCE:
1275  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1276  impatience = parse<double>(value);
1277  // mark parameter as set
1279  } else {
1280  // set default value
1281  impatience = parse<double>(myTagProperty.getDefaultValue(key));
1282  // unset parameter
1284  }
1285  break;
1286  // LCM Attributes
1293  case SUMO_ATTR_LCA_PUSHY:
1302 
1303  /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
1304  // empty values means that value isn't set
1305  if (value.empty()) {
1306  const auto it = lcParameter.find(key);
1307  if (it != lcParameter.end()) {
1308  lcParameter.erase(it);
1309  }
1310  } else {
1311  lcParameter[key] = value;
1312  }
1313  break;
1317  // empty or null values means that value isn't set
1318  if (value.empty() || (canParse<double>(value) && (parse<double>(value) == 0))) {
1319  const auto it = lcParameter.find(key);
1320  if (it != lcParameter.end()) {
1321  lcParameter.erase(it);
1322  }
1323  } else {
1324  lcParameter[key] = value;
1325  }
1326  break;
1327  //
1328  case SUMO_ATTR_LENGTH:
1329  if (!value.empty() && (value != toString(defaultValues.length))) {
1330  length = parse<double>(value);
1331  // mark parameter as set
1333  } else {
1334  // set default value
1335  length = defaultValues.length;
1336  // unset parameter
1338  }
1339  break;
1340  case SUMO_ATTR_MINGAP:
1341  if (!value.empty() && (value != toString(defaultValues.minGap))) {
1342  minGap = parse<double>(value);
1343  // mark parameter as set
1345  } else {
1346  // set default value
1347  minGap = defaultValues.minGap;
1348  // unset parameter
1350  }
1351  break;
1352  case SUMO_ATTR_MAXSPEED:
1353  if (!value.empty() && (value != toString(defaultValues.maxSpeed))) {
1354  maxSpeed = parse<double>(value);
1355  // mark parameter as set
1357  } else {
1358  // set default value
1359  maxSpeed = defaultValues.maxSpeed;
1360  // unset parameter
1362  }
1363  break;
1364  case SUMO_ATTR_SPEEDFACTOR:
1365  if (!value.empty() && (value != toString(defaultValues.speedFactor.getParameter()[0]))) {
1366  speedFactor.getParameter()[0] = parse<double>(value);
1367  // mark parameter as set
1369  } else {
1370  // set default value
1371  speedFactor.getParameter()[0] = defaultValues.speedFactor.getParameter()[0];
1372  // unset parameter
1374  }
1375  break;
1376  case SUMO_ATTR_SPEEDDEV:
1377  if (!value.empty() && (value != toString(defaultValues.speedFactor.getParameter()[1]))) {
1378  speedFactor.getParameter()[1] = parse<double>(value);
1379  // mark parameter as set
1381  } else {
1382  // set default value
1383  speedFactor.getParameter()[1] = defaultValues.speedFactor.getParameter()[1];
1384  // unset parameter
1386  }
1387  break;
1388  case SUMO_ATTR_COLOR:
1389  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1390  color = parse<RGBColor>(value);
1391  // mark parameter as set
1393  } else {
1394  // unset parameter
1396  }
1397  break;
1398  case SUMO_ATTR_VCLASS:
1399  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1401  // mark parameter as set
1403  } else {
1404  // set default value
1406  // unset parameter
1408  }
1409  // update default values
1410  updateDefaultVClassAttributes(defaultValues);
1411  break;
1413  if (!value.empty() && (value != toString(defaultValues.emissionClass))) {
1415  // mark parameter as set
1417  } else {
1418  // set default value
1419  emissionClass = defaultValues.emissionClass;
1420  // unset parameter
1422  }
1423  break;
1424  case SUMO_ATTR_GUISHAPE:
1425  if (!value.empty() && (value != toString(defaultValues.shape))) {
1426  shape = getVehicleShapeID(value);
1427  // mark parameter as set
1429  } else {
1430  // set default value
1431  shape = defaultValues.shape;
1432  // unset parameter
1434  }
1435  break;
1436  case SUMO_ATTR_WIDTH:
1437  if (!value.empty() && (value != toString(defaultValues.width))) {
1438  width = parse<double>(value);
1439  // mark parameter as set
1441  } else {
1442  // set default value
1443  width = defaultValues.width;
1444  // unset parameter
1446  }
1447  break;
1448  case SUMO_ATTR_HEIGHT:
1449  if (!value.empty() && (value != toString(defaultValues.height))) {
1450  height = parse<double>(value);
1451  // mark parameter as set
1453  } else {
1454  // set default value
1455  height = defaultValues.height;
1456  // unset parameter
1458  }
1459  break;
1460  case SUMO_ATTR_IMGFILE:
1461  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1462  imgFile = value;
1463  // mark parameter as set
1465  } else {
1466  // set default value
1468  // unset parameter
1470  }
1471  break;
1473  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1475  // mark parameter as set
1477  } else {
1478  // set default value
1480  // unset parameter
1482  }
1483  break;
1485  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1487  // mark parameter as set
1489  } else {
1490  // set default value
1492  // unset parameter
1494  }
1495  break;
1497  if (!value.empty() && (value != toString(defaultValues.personCapacity))) {
1498  personCapacity = parse<int>(value);
1499  // mark parameter as set
1501  } else {
1502  // set default value
1503  personCapacity = defaultValues.personCapacity;
1504  // unset parameter
1506  }
1507  break;
1509  if (!value.empty() && (value != toString(defaultValues.containerCapacity))) {
1510  containerCapacity = parse<int>(value);
1511  // mark parameter as set
1513  } else {
1514  // set default value
1515  containerCapacity = defaultValues.containerCapacity;
1516  // unset parameter
1518  }
1519  break;
1521  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1522  boardingDuration = string2time(value);
1523  // mark parameter as set
1525  } else {
1526  // set default value
1528  // unset parameter
1530  }
1531  break;
1533  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1534  loadingDuration = string2time(value);
1535  // mark parameter as set
1537  } else {
1538  // set default value
1540  // unset parameter
1542  }
1543  break;
1545  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1547  // mark parameter as set
1549  } else {
1550  // set default value
1552  // unset parameter
1554  }
1555  break;
1556  case SUMO_ATTR_MINGAP_LAT:
1557  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1558  minGapLat = parse<double>(value);
1559  // mark parameter as set
1561  } else {
1562  // set default value
1563  minGapLat = parse<double>(myTagProperty.getDefaultValue(key));
1564  // unset parameter
1566  }
1567  break;
1569  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1570  maxSpeedLat = parse<double>(value);
1571  // mark parameter as set
1573  } else {
1574  // set default value
1575  maxSpeedLat = parse<double>(myTagProperty.getDefaultValue(key));
1576  // unset parameter
1578  }
1579  break;
1581  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1582  actionStepLength = string2time(value);
1583  // mark parameter as set
1585  } else {
1586  // set default value
1588  // unset parameter
1590  }
1591  break;
1592  case SUMO_ATTR_PROB:
1593  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1594  defaultProbability = parse<double>(value);
1595  // mark parameter as set
1597  } else {
1598  // set default value
1599  defaultProbability = parse<double>(myTagProperty.getDefaultValue(key));
1600  // unset parameter
1602  }
1603  break;
1605  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1606  hasDriverState = parse<bool>(value);
1607  // mark parameter as set
1609  } else {
1610  // set default value
1611  hasDriverState = parse<bool>(myTagProperty.getDefaultValue(key));
1612  // unset parameter
1614  }
1615  break;
1616  case SUMO_ATTR_OSGFILE:
1617  if (!value.empty() && (value != defaultValues.osgFile)) {
1618  osgFile = value;
1619  // mark parameter as set
1621  } else {
1622  // set default value
1623  osgFile = defaultValues.osgFile;
1624  // unset parameter
1626  }
1627  break;
1629  if (!value.empty() && (value != toString(defaultValues.carriageLength))) {
1630  carriageLength = parse<double>(value);
1631  // mark parameter as set
1633  // set parameter in SUMOVTypeParameter (needed for writting in XML)
1635  } else {
1636  // set default value
1637  carriageLength = defaultValues.carriageLength;
1638  // unset parameter
1640  // remove from params (needed for writting in XML)
1642  }
1643  break;
1645  if (!value.empty() && (value != toString(defaultValues.containerCapacity))) {
1646  locomotiveLength = parse<double>(value);
1647  // mark parameter as set
1649  // set parameter in SUMOVTypeParameter (needed for writting in XML)
1651  } else {
1652  // set default value
1653  locomotiveLength = defaultValues.locomotiveLength;
1654  // unset parameter
1656  // remove from params (needed for writting in XML)
1658  }
1659  break;
1661  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1662  carriageGap = parse<double>(value);
1663  // mark parameter as set
1665  // set parameter in SUMOVTypeParameter (needed for writting in XML)
1667  } else {
1668  // set default value
1669  carriageGap = parse<double>(myTagProperty.getDefaultValue(key));
1670  // unset parameter
1672  // remove from params (needed for writting in XML)
1674  }
1675  break;
1676  case GNE_ATTR_GENERIC:
1677  setGenericParametersStr(value);
1678  break;
1680  myDefaultVehicleTypeModified = parse<bool>(value);
1681  break;
1682  default:
1683  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
1684  }
1685 }
1686 
1687 
1688 void
1689 GNEVehicleType::setEnabledAttribute(const int /*enabledAttributes*/) {
1690  //
1691 }
1692 
1693 
1694 void
1696  if (!wasSet(VTYPEPARS_LENGTH_SET)) {
1697  length = defaultValues.length;
1698  }
1699  if (!wasSet(VTYPEPARS_MINGAP_SET)) {
1700  minGap = defaultValues.minGap;
1701  }
1703  maxSpeed = defaultValues.maxSpeed;
1704  }
1705  if (!wasSet(VTYPEPARS_WIDTH_SET)) {
1706  width = defaultValues.width;
1707  }
1708  if (!wasSet(VTYPEPARS_HEIGHT_SET)) {
1709  height = defaultValues.height;
1710  }
1711  if (!wasSet(VTYPEPARS_SHAPE_SET)) {
1712  shape = defaultValues.shape;
1713  }
1715  emissionClass = defaultValues.emissionClass;
1716  }
1718  speedFactor = defaultValues.speedFactor;
1719  }
1721  personCapacity = defaultValues.personCapacity;
1722  }
1724  containerCapacity = defaultValues.containerCapacity;
1725  }
1726  if (!wasSet(VTYPEPARS_OSGFILE_SET)) {
1727  osgFile = defaultValues.osgFile;
1728  }
1730  carriageLength = defaultValues.carriageLength;
1731  }
1733  locomotiveLength = defaultValues.locomotiveLength;
1734  }
1735 }
1736 
1737 /****************************************************************************/
GNEVehicleType::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: GNEVehicleType.cpp:515
VTYPEPARS_LATALIGNMENT_SET
const int VTYPEPARS_LATALIGNMENT_SET
Definition: SUMOVTypeParameter.h:67
GNEViewParent::getSelectorFrame
GNESelectorFrame * getSelectorFrame() const
get frame for GNE_NMODE_SELECT
Definition: GNEViewParent.cpp:185
SUMO_ATTR_MAXSPEED
Definition: SUMOXMLDefinitions.h:442
GNEDemandElement::myViewNet
GNEViewNet * myViewNet
The GNEViewNet this demand element element belongs.
Definition: GNEDemandElement.h:469
SUMO_ATTR_OSGFILE
Definition: SUMOXMLDefinitions.h:788
GNEVehicleType::writeDemandElement
void writeDemandElement(OutputDevice &device) const
writte demand element element into a xml file
Definition: GNEVehicleType.cpp:84
SUMO_ATTR_BOARDING_DURATION
Definition: SUMOXMLDefinitions.h:462
VTYPEPARS_HASDRIVERSTATE_SET
const int VTYPEPARS_HASDRIVERSTATE_SET
Definition: SUMOVTypeParameter.h:70
SUMO_ATTR_LCA_SPEEDGAIN_PARAM
Definition: SUMOXMLDefinitions.h:590
SVC_PEDESTRIAN
pedestrian
Definition: SUMOVehicleClass.h:157
SUMOVehicleClass
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
Definition: SUMOVehicleClass.h:134
SUMOXMLDefinitions::LaneChangeModels
static StringBijection< LaneChangeModel > LaneChangeModels
lane change models
Definition: SUMOXMLDefinitions.h:1390
SUMOVTypeParameter::lcParameter
SubParams lcParameter
Lane-changing parameter.
Definition: SUMOVTypeParameter.h:285
SUMO_ATTR_CF_WIEDEMANN_ESTIMATION
Definition: SUMOXMLDefinitions.h:839
GNEDemandElement
An Element which don't belongs to GNENet but has influency in the simulation.
Definition: GNEDemandElement.h:54
SUMOVTypeParameter::VClassDefaultValues::carriageLength
double carriageLength
the length of train carriages
Definition: SUMOVTypeParameter.h:127
VTYPEPARS_CARRIAGE_LENGTH_SET
const int VTYPEPARS_CARRIAGE_LENGTH_SET
Definition: SUMOVTypeParameter.h:71
GNEVehicleType::getToEdge
GNEEdge * getToEdge() const
obtain to edge of this demand element
Definition: GNEVehicleType.cpp:103
SUMOVTypeParameter::locomotiveLength
double locomotiveLength
Definition: SUMOVTypeParameter.h:304
GNEVehicleType::unselectAttributeCarrier
void unselectAttributeCarrier(bool changeFlag=true)
unselect attribute carrier using GUIGlobalSelection
Definition: GNEVehicleType.cpp:197
SUMOVTypeParameter::length
double length
The physical vehicle length.
Definition: SUMOVTypeParameter.h:213
SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME
Definition: SUMOXMLDefinitions.h:615
GNEAttributeCarrier::mySelected
bool mySelected
boolean to check if this AC is selected (instead of GUIGlObjectStorage)
Definition: GNEAttributeCarrier.h:795
getVehicleClassID
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
Definition: SUMOVehicleClass.cpp:201
SUMO_ATTR_IMGFILE
Definition: SUMOXMLDefinitions.h:789
VTYPEPARS_MINGAP_SET
const int VTYPEPARS_MINGAP_SET
Definition: SUMOVTypeParameter.h:47
GNEVehicleType::getVClass
SUMOVehicleClass getVClass() const
obtain VClass related with this demand element
Definition: GNEVehicleType.cpp:109
SUMO_ATTR_MINGAP_LAT
Definition: SUMOXMLDefinitions.h:445
SUMO_ATTR_CF_IDMM_ADAPT_FACTOR
Definition: SUMOXMLDefinitions.h:835
DEFAULT_PEDTYPE_ID
const std::string DEFAULT_PEDTYPE_ID
SUMO_ATTR_LATALIGNMENT
Definition: SUMOXMLDefinitions.h:444
SUMO_ATTR_LENGTH
Definition: SUMOXMLDefinitions.h:394
SUMO_ATTR_LCA_COOPERATIVE_PARAM
Definition: SUMOXMLDefinitions.h:589
SUMOXMLDefinitions::isValidFilename
static bool isValidFilename(const std::string &value)
whether the given string is a valid attribute for a filename (for example, a name)
Definition: SUMOXMLDefinitions.cpp:994
SUMO_ATTR_CF_IDM_STEPPING
Definition: SUMOXMLDefinitions.h:834
OutputDevice
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:64
GNEVehicleType::setEnabledAttribute
void setEnabledAttribute(const int enabledAttributes)
method for enabling the attribute and nothing else (used in GNEChange_EnableAttribute)
Definition: GNEVehicleType.cpp:1689
SUMOVTypeParameter::actionStepLength
SUMOTime actionStepLength
The vehicle type's default actionStepLength [ms], i.e. the interval between two control actions....
Definition: SUMOVTypeParameter.h:223
SUMO_ATTR_MAXSPEED_LAT
Definition: SUMOXMLDefinitions.h:443
SUMOVTypeParameter::VClassDefaultValues::emissionClass
SUMOEmissionClass emissionClass
The emission class of this vehicle.
Definition: SUMOVTypeParameter.h:112
GNEVehicleType::getParentName
std::string getParentName() const
Returns the name of the parent object.
Definition: GNEVehicleType.cpp:163
StringBijection::getString
const std::string & getString(const T key) const
Definition: StringBijection.h:107
GNEUndoList::p_end
void p_end()
End undo command sub-group. If the sub-group is still empty, it will be deleted; otherwise,...
Definition: GNEUndoList.cpp:80
StringTokenizer::hasNext
bool hasNext()
returns the information whether further substrings exist
Definition: StringTokenizer.cpp:95
GNEVehicleType::~GNEVehicleType
~GNEVehicleType()
destructor
Definition: GNEVehicleType.cpp:80
SUMOVTypeParameter::cfModel
SumoXMLTag cfModel
The enum-representation of the car-following model to use.
Definition: SUMOVTypeParameter.h:276
SUMO_ATTR_TMP2
Definition: SUMOXMLDefinitions.h:551
StringUtils::toDouble
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
Definition: StringUtils.cpp:313
VTYPEPARS_BOARDING_DURATION
const int VTYPEPARS_BOARDING_DURATION
Definition: SUMOVTypeParameter.h:62
SUMO_ATTR_SPEEDFACTOR
Definition: SUMOXMLDefinitions.h:456
GNEVehicleType::updateGeometry
void updateGeometry()
update pre-computed geometry information
Definition: GNEVehicleType.cpp:151
SUMOVTypeParameter::impatience
double impatience
The vehicle's impatience (willingness to obstruct others)
Definition: SUMOVTypeParameter.h:241
GUIGlobalSelection.h
SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME
Definition: SUMOXMLDefinitions.h:612
SUMO_ATTR_TMP1
Definition: SUMOXMLDefinitions.h:550
SUMOVTypeParameter::osgFile
std::string osgFile
3D model file for this class
Definition: SUMOVTypeParameter.h:268
SUMO_ATTR_CF_PWAGNER2009_APPROB
Definition: SUMOXMLDefinitions.h:832
VTYPEPARS_MINGAP_LAT_SET
const int VTYPEPARS_MINGAP_LAT_SET
Definition: SUMOVTypeParameter.h:68
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
GNEVehicleType::myDefaultVehicleType
bool myDefaultVehicleType
flag to check if this GNEVehicleType is a default vehicle Type (For Vehicles, Pedestrians....
Definition: GNEVehicleType.h:195
SUMO_ATTR_LOADING_DURATION
Definition: SUMOXMLDefinitions.h:463
GNENet::retrieveDemandElement
GNEDemandElement * retrieveDemandElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named demand element.
Definition: GNENet.cpp:2266
SUMO_TAG_PTYPE
description of a person type (used in NETEDIT)
Definition: SUMOXMLDefinitions.h:124
SUMO_ATTR_COLOR
A color information.
Definition: SUMOXMLDefinitions.h:701
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
VTYPEPARS_OSGFILE_SET
const int VTYPEPARS_OSGFILE_SET
Definition: SUMOVTypeParameter.h:57
SUMOVTypeParameter::carriageLength
double carriageLength
the length of train carriages and locomotive
Definition: SUMOVTypeParameter.h:303
SUMO_ATTR_CONTAINER_CAPACITY
Definition: SUMOXMLDefinitions.h:648
SUMO_ATTR_SPEEDDEV
Definition: SUMOXMLDefinitions.h:457
SUMO_ATTR_ID
Definition: SUMOXMLDefinitions.h:379
SUMOVTypeParameter::shape
SUMOVehicleShape shape
This class' shape.
Definition: SUMOVTypeParameter.h:265
VTYPEPARS_PROBABILITY_SET
const int VTYPEPARS_PROBABILITY_SET
Definition: SUMOVTypeParameter.h:49
SUMO_ATTR_CF_IDM_DELTA
Definition: SUMOXMLDefinitions.h:833
SUMO_TAG_VTYPE
description of a vehicle type
Definition: SUMOXMLDefinitions.h:122
PollutantsInterface::getName
static std::string getName(const SUMOEmissionClass c)
Checks whether the string describes a known vehicle class.
Definition: PollutantsInterface.cpp:100
SUMOVTypeParameter::VClassDefaultValues::length
double length
The physical vehicle length.
Definition: SUMOVTypeParameter.h:94
SUMO_ATTR_LCA_MAXSPEEDLATFACTOR
Definition: SUMOXMLDefinitions.h:603
SUMO_ATTR_LCA_KEEPRIGHT_PARAM
Definition: SUMOXMLDefinitions.h:591
SUMO_ATTR_LANE_CHANGE_MODEL
Definition: SUMOXMLDefinitions.h:458
getVehicleShapeName
std::string getVehicleShapeName(SUMOVehicleShape id)
Returns the class name of the shape class given by its id.
Definition: SUMOVehicleClass.cpp:359
SUMO_ATTR_TMP5
Definition: SUMOXMLDefinitions.h:554
SUMO_ATTR_TMP3
Definition: SUMOXMLDefinitions.h:552
VTYPEPARS_LOCOMOTIVE_LENGTH_SET
const int VTYPEPARS_LOCOMOTIVE_LENGTH_SET
Definition: SUMOVTypeParameter.h:72
SUMOVTypeParameter::containerCapacity
int containerCapacity
The container capacity of the vehicle.
Definition: SUMOVTypeParameter.h:247
SumoXMLTag
SumoXMLTag
Numbers representing SUMO-XML - element names.
Definition: SUMOXMLDefinitions.h:42
SUMO_ATTR_JM_IGNORE_FOE_PROB
Definition: SUMOXMLDefinitions.h:617
SUMO_ATTR_LCA_EXPERIMENTAL1
Definition: SUMOXMLDefinitions.h:606
SUMO_ATTR_JM_TIMEGAP_MINOR
Definition: SUMOXMLDefinitions.h:619
SVS_BUS_FLEXIBLE
render as a flexible city bus
Definition: SUMOVehicleClass.h:87
SUMO_ATTR_HASDRIVERSTATE
Definition: SUMOXMLDefinitions.h:450
Parameterised::getParameter
const std::string getParameter(const std::string &key, const std::string &defaultValue="") const
Returns the value for a given key.
Definition: Parameterised.cpp:71
VTYPEPARS_CAR_FOLLOW_MODEL
const int VTYPEPARS_CAR_FOLLOW_MODEL
Definition: SUMOVTypeParameter.h:65
SUMO_ATTR_JM_IGNORE_FOE_SPEED
Definition: SUMOXMLDefinitions.h:616
SUMOXMLDefinitions::CarFollowModels
static StringBijection< SumoXMLTag > CarFollowModels
car following models
Definition: SUMOXMLDefinitions.h:1393
SUMO_ATTR_LCA_PUSHYGAP
Definition: SUMOXMLDefinitions.h:595
SUMO_ATTR_LCA_MAXSPEEDLATSTANDING
Definition: SUMOXMLDefinitions.h:602
GNEEdge
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:50
GNEAttributeCarrier::GNEChange_Attribute
friend class GNEChange_Attribute
declare friend class
Definition: GNEAttributeCarrier.h:57
SUMOVTypeParameter::wasSet
bool wasSet(int what) const
Returns whether the given parameter was set.
Definition: SUMOVTypeParameter.h:150
SUMOVTypeParameter::parametersSet
int parametersSet
Information for the router which parameter were set.
Definition: SUMOVTypeParameter.h:308
GNEUndoList::p_add
void p_add(GNEChange_Attribute *cmd)
special method, avoid empty changes, always execute
Definition: GNEUndoList.cpp:132
VTYPEPARS_MAXSPEED_LAT_SET
const int VTYPEPARS_MAXSPEED_LAT_SET
Definition: SUMOVTypeParameter.h:66
GNEDemandElement::changeDemandElementID
void changeDemandElementID(const std::string &newID)
change ID of demand element
Definition: GNEDemandElement.cpp:540
GNEViewNet::getNet
GNENet * getNet() const
get the net object
Definition: GNEViewNet.cpp:927
SUMO_ATTR_LCA_SUBLANE_PARAM
Definition: SUMOXMLDefinitions.h:592
RGBColor
Definition: RGBColor.h:40
Parameterised::getParametersMap
const std::map< std::string, std::string > & getParametersMap() const
Returns the inner key/value map.
Definition: Parameterised.cpp:105
SUMO_ATTR_APPARENTDECEL
Definition: SUMOXMLDefinitions.h:449
Distribution_Parameterized::getParameter
std::vector< double > & getParameter()
Returns the parameters of this distribution.
Definition: Distribution_Parameterized.cpp:111
GNEVehicleType::endGeometryMoving
void endGeometryMoving()
end geometry movement
Definition: GNEVehicleType.cpp:133
canParseVehicleClasses
bool canParseVehicleClasses(const std::string &classes)
Checks whether the given string contains only known vehicle classes.
Definition: SUMOVehicleClass.cpp:252
SUMO_ATTR_PROB
Definition: SUMOXMLDefinitions.h:627
SUMO_ATTR_DECEL
Definition: SUMOXMLDefinitions.h:447
VTYPEPARS_LANE_CHANGE_MODEL_SET
const int VTYPEPARS_LANE_CHANGE_MODEL_SET
Definition: SUMOVTypeParameter.h:60
SUMOVTypeParameter::imgFile
std::string imgFile
Image file for this class.
Definition: SUMOVTypeParameter.h:271
SUMOVTypeParameter::getLCParamString
std::string getLCParamString(const SumoXMLAttr attr, const std::string &defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition: SUMOVTypeParameter.cpp:436
SUMO_ATTR_COLLISION_MINGAP_FACTOR
Definition: SUMOXMLDefinitions.h:461
SUMO_ATTR_ACCEL
Definition: SUMOXMLDefinitions.h:446
SUMOVTypeParameter::VClassDefaultValues::containerCapacity
int containerCapacity
The container capacity of the vehicle.
Definition: SUMOVTypeParameter.h:121
GUISelectedStorage::select
void select(GUIGlID id, bool update=true)
Adds the object with the given id.
Definition: GUISelectedStorage.cpp:114
SUMOVTypeParameter::height
double height
This class' height.
Definition: SUMOVTypeParameter.h:262
PollutantsInterface.h
SUMO_ATTR_LCA_OPPOSITE_PARAM
Definition: SUMOXMLDefinitions.h:593
GNEVehicleType
Definition: GNEVehicleType.h:37
SUMOVTypeParameter
Structure representing possible vehicle parameter.
Definition: SUMOVTypeParameter.h:86
GNE_ATTR_DEFAULT_VTYPE_MODIFIED
Flag to check if a default VType was modified.
Definition: SUMOXMLDefinitions.h:1004
canParseVehicleShape
bool canParseVehicleShape(const std::string &shape)
Checks whether the given string contains only known vehicle shape.
Definition: SUMOVehicleClass.cpp:353
SUMOVTypeParameter::jmParameter
SubParams jmParameter
Junction-model parameter.
Definition: SUMOVTypeParameter.h:288
GNEVehicleType::getCenteringBoundary
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
Definition: GNEVehicleType.cpp:169
StringBijection::get
T get(const std::string &str) const
Definition: StringBijection.h:98
SUMOVTypeParameter::cfParameter
SubParams cfParameter
Car-following parameter.
Definition: SUMOVTypeParameter.h:282
StringTokenizer
Definition: StringTokenizer.h:62
SUMOVTypeParameter::defaultProbability
double defaultProbability
The probability when being added to a distribution without an explicit probability.
Definition: SUMOVTypeParameter.h:226
DEFAULT_VTYPE_ID
const std::string DEFAULT_VTYPE_ID
SUMOVTypeParameter::VClassDefaultValues::maxSpeed
double maxSpeed
The vehicle type's maximum speed [m/s].
Definition: SUMOVTypeParameter.h:100
GNEVehicleType::getFromEdge
GNEEdge * getFromEdge() const
Definition: GNEVehicleType.cpp:97
GNEVehicleType::startGeometryMoving
void startGeometryMoving()
Definition: GNEVehicleType.cpp:127
GNEViewNet.h
SUMO_ATTR_LCA_SPEEDGAINRIGHT
Definition: SUMOXMLDefinitions.h:601
SUMO_ATTR_WIDTH
Definition: SUMOXMLDefinitions.h:387
GNEVehicleType::GNEVehicleType
GNEVehicleType(GNEViewNet *viewNet, const std::string &vTypeID, const SUMOVehicleClass &defaultVClass, SumoXMLTag tag)
constructor for default VTypes
Definition: GNEVehicleType.cpp:40
GUIGlObject::getGlID
GUIGlID getGlID() const
Returns the numerical id of the object.
Definition: GUIGlObject.cpp:150
Boundary
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:42
GLO_VTYPE
Definition: GUIGlObjectTypes.h:111
SUMO_ATTR_JM_DRIVE_RED_SPEED
Definition: SUMOXMLDefinitions.h:614
GNEVehicleType::selectAttributeCarrier
void selectAttributeCarrier(bool changeFlag=true)
inherited from GNEAttributeCarrier
Definition: GNEVehicleType.cpp:182
VTYPEPARS_ACTIONSTEPLENGTH_SET
const int VTYPEPARS_ACTIONSTEPLENGTH_SET
Definition: SUMOVTypeParameter.h:69
SVS_RAIL_CARGO
render as a cargo train
Definition: SUMOVehicleClass.h:95
ProcessError
Definition: UtilExceptions.h:40
SUMO_ATTR_PERSON_CAPACITY
Definition: SUMOXMLDefinitions.h:647
SUMOVTypeParameter::VClassDefaultValues::width
double width
This class' width.
Definition: SUMOVTypeParameter.h:103
VTYPEPARS_CARRIAGE_GAP_SET
const int VTYPEPARS_CARRIAGE_GAP_SET
Definition: SUMOVTypeParameter.h:73
SUMO_ATTR_LCA_LOOKAHEADLEFT
Definition: SUMOXMLDefinitions.h:600
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:39
GNEVehicleType::commitGeometryMoving
void commitGeometryMoving(GNEUndoList *undoList)
commit geometry changes in the attributes of an element after use of moveGeometry(....
Definition: GNEVehicleType.cpp:145
SUMOVTypeParameter::boardingDuration
SUMOTime boardingDuration
The time a person needs to board the vehicle.
Definition: SUMOVTypeParameter.h:250
SUMOVTypeParameter::VClassDefaultValues::minGap
double minGap
This class' free space in front of the vehicle itself.
Definition: SUMOVTypeParameter.h:97
GNEAttributeCarrier::myTagProperty
const TagProperties & myTagProperty
the xml tag to which this attribute carrier corresponds
Definition: GNEAttributeCarrier.h:792
SUMOVTypeParameter::minGap
double minGap
This class' free space in front of the vehicle itself.
Definition: SUMOVTypeParameter.h:216
SUMO_ATTR_LCA_OVERTAKE_RIGHT
Definition: SUMOXMLDefinitions.h:605
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
SUMOVTypeParameter::getJMParamString
std::string getJMParamString(const SumoXMLAttr attr, const std::string defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition: SUMOVTypeParameter.cpp:462
SUMO_ATTR_LCA_STRATEGIC_PARAM
Definition: SUMOXMLDefinitions.h:588
SUMOVTypeParameter::width
double width
This class' width.
Definition: SUMOVTypeParameter.h:259
GNEVehicleType::compute
void compute()
compute demand element
Definition: GNEVehicleType.cpp:121
SUMO_ATTR_JM_SIGMA_MINOR
Definition: SUMOXMLDefinitions.h:618
SUMOVTypeParameter::maxSpeedLat
double maxSpeedLat
The vehicle type's maximum lateral speed [m/s].
Definition: SUMOVTypeParameter.h:294
SUMOVTypeParameter::getCFParam
double getCFParam(const SumoXMLAttr attr, const double defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition: SUMOVTypeParameter.cpp:406
SUMOVTypeParameter::maxSpeed
double maxSpeed
The vehicle type's maximum speed [m/s].
Definition: SUMOVTypeParameter.h:219
GNE_ATTR_DEFAULT_VTYPE
Flag to check if VType is a default VType.
Definition: SUMOXMLDefinitions.h:1002
SUMOVTypeParameter::personCapacity
int personCapacity
The person capacity of the vehicle.
Definition: SUMOVTypeParameter.h:244
SUMOVTypeParameter::VClassDefaultValues::shape
SUMOVehicleShape shape
This class' shape.
Definition: SUMOVTypeParameter.h:109
SUMOVTypeParameter::hasDriverState
bool hasDriverState
Whether vehicles of this type are equipped with a driver (i.e. MSDriverState))
Definition: SUMOVTypeParameter.h:279
VTYPEPARS_SPEEDFACTOR_SET
const int VTYPEPARS_SPEEDFACTOR_SET
Definition: SUMOVTypeParameter.h:50
SUMO_ATTR_LCA_IMPATIENCE
Definition: SUMOXMLDefinitions.h:597
SUMOVTypeParameter::write
void write(OutputDevice &dev) const
Writes the vtype.
Definition: SUMOVTypeParameter.cpp:301
SVS_RAIL_CAR
render as a (city) rail without locomotive
Definition: SUMOVehicleClass.h:93
string2time
SUMOTime string2time(const std::string &r)
Definition: SUMOTime.cpp:42
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
SUMO_ATTR_LCA_ASSERTIVE
Definition: SUMOXMLDefinitions.h:596
GNEDemandElement::getGenericParametersStr
virtual std::string getGenericParametersStr() const =0
return generic parameters in string format
GNEVehicleType::getPopUpID
std::string getPopUpID() const
get PopPup ID (Used in AC Hierarchy)
Definition: GNEVehicleType.cpp:836
GNEVehicleType::enableAttribute
void enableAttribute(SumoXMLAttr key, GNEUndoList *undoList)
Definition: GNEVehicleType.cpp:800
SUMO_ATTR_CF_WIEDEMANN_SECURITY
Definition: SUMOXMLDefinitions.h:838
SUMO_ATTR_CARRIAGE_GAP
Definition: SUMOXMLDefinitions.h:1011
GNEDemandElement::setAttribute
virtual void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)=0
method for setting the attribute and letting the object perform demand element changes
SUMOVTypeParameter::speedFactor
Distribution_Parameterized speedFactor
The factor by which the maximum speed may deviate from the allowed max speed on the street.
Definition: SUMOVTypeParameter.h:229
GNEVehicleType::getHierarchyName
std::string getHierarchyName() const
get Hierarchy Name (Used in AC Hierarchy)
Definition: GNEVehicleType.cpp:842
PollutantsInterface::getClassByName
static SUMOEmissionClass getClassByName(const std::string &eClass, const SUMOVehicleClass vc=SVC_IGNORING)
Checks whether the string describes a known vehicle class.
Definition: PollutantsInterface.cpp:54
GNEViewParent.h
SUMOVTypeParameter::VClassDefaultValues::osgFile
std::string osgFile
3D model file for this class
Definition: SUMOVTypeParameter.h:124
SUMO_ATTR_JM_CROSSING_GAP
Definition: SUMOXMLDefinitions.h:611
VTYPEPARS_LOADING_DURATION
const int VTYPEPARS_LOADING_DURATION
Definition: SUMOVTypeParameter.h:64
SUMOVTypeParameter::VClassDefaultValues::locomotiveLength
double locomotiveLength
the length of train locomotive
Definition: SUMOVTypeParameter.h:130
SUMO_ATTR_HEIGHT
Definition: SUMOXMLDefinitions.h:786
GNEVehicleType::getGenericParameters
std::vector< std::pair< std::string, std::string > > getGenericParameters() const
return generic parameters as vector of pairs format
Definition: GNEVehicleType.cpp:1173
VTYPEPARS_CONTAINER_CAPACITY
const int VTYPEPARS_CONTAINER_CAPACITY
Definition: SUMOVTypeParameter.h:63
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:48
GNE_ATTR_GENERIC
generic attribute
Definition: SUMOXMLDefinitions.h:986
GNEVehicleType::getColor
const RGBColor & getColor() const
get color
Definition: GNEVehicleType.cpp:115
SUMO_ATTR_CF_PWAGNER2009_TAULAST
Definition: SUMOXMLDefinitions.h:831
GNEVehicleType::getAttributeDouble
double getAttributeDouble(SumoXMLAttr key) const
Definition: GNEVehicleType.cpp:474
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
SUMOVTypeParameter::carriageGap
double carriageGap
Definition: SUMOVTypeParameter.h:305
SUMO_ATTR_TRAIN_TYPE
Definition: SUMOXMLDefinitions.h:583
SUMO_ATTR_SIGMA
Definition: SUMOXMLDefinitions.h:548
GNEVehicleType::setGenericParametersStr
void setGenericParametersStr(const std::string &value)
set generic parameters in string format
Definition: GNEVehicleType.cpp:1184
SUMOVTypeParameter::latAlignment
LateralAlignment latAlignment
The vehicles desired lateral alignment.
Definition: SUMOVTypeParameter.h:297
SUMO_ATTR_CAR_FOLLOW_MODEL
Definition: SUMOXMLDefinitions.h:459
SUMO_ATTR_IMPATIENCE
Definition: SUMOXMLDefinitions.h:793
Parameterised::unsetParameter
void unsetParameter(const std::string &key)
Removes a parameter.
Definition: Parameterised.cpp:51
SUMOXMLDefinitions::TrainTypes
static StringBijection< TrainType > TrainTypes
train types
Definition: SUMOXMLDefinitions.h:1402
SUMO_ATTR_LCA_TIME_TO_IMPATIENCE
Definition: SUMOXMLDefinitions.h:598
InvalidArgument
Definition: UtilExceptions.h:57
SUMO_ATTR_GUISHAPE
Definition: SUMOXMLDefinitions.h:787
SUMOVTypeParameter::VClassDefaultValues
struct for default values that depend of VClass
Definition: SUMOVTypeParameter.h:89
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
SUMO_ATTR_K
Definition: SUMOXMLDefinitions.h:816
GNEVehicleType::isValid
bool isValid(SumoXMLAttr key, const std::string &value)
method for checking if the key and their conrrespond attribute are valids
Definition: GNEVehicleType.cpp:624
VTYPEPARS_PERSON_CAPACITY
const int VTYPEPARS_PERSON_CAPACITY
Definition: SUMOVTypeParameter.h:61
SUMO_ATTR_CARRIAGE_LENGTH
Definition: SUMOXMLDefinitions.h:1009
GNEVehicleType::initRailVisualizationParameters
void initRailVisualizationParameters()
init Rail Visualization Parameters
Definition: GNEVehicleType.cpp:1111
GNEVehicleType::overwriteVType
static void overwriteVType(GNEDemandElement *vType, SUMOVTypeParameter *newVTypeParameter, GNEUndoList *undoList)
overwrite all values of GNEVehicleType with a SUMOVTypeParameter
Definition: GNEVehicleType.cpp:848
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
SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME
Definition: SUMOXMLDefinitions.h:613
VTYPEPARS_HEIGHT_SET
const int VTYPEPARS_HEIGHT_SET
Definition: SUMOVTypeParameter.h:55
SUMO_ATTR_EMERGENCYDECEL
Definition: SUMOXMLDefinitions.h:448
SVS_TRUCK_SEMITRAILER
render as a semi-trailer transport vehicle ("Sattelschlepper")
Definition: SUMOVehicleClass.h:79
SUMO_ATTR_VCLASS
Definition: SUMOXMLDefinitions.h:452
Parameterised::setParameter
void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
Definition: Parameterised.cpp:45
GNEVehicleType::getGenericParametersStr
std::string getGenericParametersStr() const
return generic parameters in string format
Definition: GNEVehicleType.cpp:1158
SUMOVTypeParameter::VClassDefaultValues::personCapacity
int personCapacity
The person capacity of the vehicle.
Definition: SUMOVTypeParameter.h:118
GNEVehicleType::moveGeometry
void moveGeometry(const Position &offset)
change the position of the element geometry without saving in undoList
Definition: GNEVehicleType.cpp:139
SUMOVTypeParameter::lcModel
LaneChangeModel lcModel
The lane-change model to use.
Definition: SUMOVTypeParameter.h:291
Parameterised::clearParameter
void clearParameter()
Clears the parameter map.
Definition: Parameterised.cpp:99
VTYPEPARS_IMGFILE_SET
const int VTYPEPARS_IMGFILE_SET
Definition: SUMOVTypeParameter.h:58
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
SUMOVTypeParameter::getCFParamString
std::string getCFParamString(const SumoXMLAttr attr, const std::string defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition: SUMOVTypeParameter.cpp:416
GNEVehicleType::updateDefaultVClassAttributes
void updateDefaultVClassAttributes(const VClassDefaultValues &defaultValues)
function called after set new VClass
Definition: GNEVehicleType.cpp:1695
StringBijection::hasString
bool hasString(const std::string &str) const
Definition: StringBijection.h:117
GNEVehicleType::isAttributeEnabled
bool isAttributeEnabled(SumoXMLAttr key) const
Definition: GNEVehicleType.cpp:805
SUMO_ATTR_ACTIONSTEPLENGTH
Definition: SUMOXMLDefinitions.h:451
GNEVehicleType.h
StringTokenizer.h
SUMOVTypeParameter::loadingDuration
SUMOTime loadingDuration
The time a container needs to get loaded on the vehicle.
Definition: SUMOVTypeParameter.h:253
SUMOVTypeParameter::color
RGBColor color
The color.
Definition: SUMOVTypeParameter.h:235
SUMO_ATTR_LOCOMOTIVE_LENGTH
Definition: SUMOXMLDefinitions.h:1010
PollutantsInterface::getAllClassesStr
static const std::vector< std::string > & getAllClassesStr()
Get all SUMOEmissionClass in string format.
Definition: PollutantsInterface.cpp:83
SVS_TRUCK_1TRAILER
render as a transport vehicle with one trailer
Definition: SUMOVehicleClass.h:81
GNEVehicleType::getPositionInView
Position getPositionInView() const
Returns position of additional in view.
Definition: GNEVehicleType.cpp:157
VTYPEPARS_LENGTH_SET
const int VTYPEPARS_LENGTH_SET
Definition: SUMOVTypeParameter.h:46
SUMO_ATTR_TMP4
Definition: SUMOXMLDefinitions.h:553
SUMOXMLDefinitions::LateralAlignments
static StringBijection< LateralAlignment > LateralAlignments
lateral alignments
Definition: SUMOXMLDefinitions.h:1396
GNEVehicleType::myDefaultVehicleTypeModified
bool myDefaultVehicleTypeModified
flag to check if this default GNEVehicleType was modified
Definition: GNEVehicleType.h:198
GNESelectorFrame::LockGLObjectTypes::removeLockedObject
void removeLockedObject(const GUIGlObjectType type)
set object unselected
Definition: GNESelectorFrame.cpp:574
GNEAttributeCarrier::getTagStr
const std::string & getTagStr() const
get tag assigned to this object in string format
Definition: GNEAttributeCarrier.cpp:1165
SUMOVTypeParameter::emissionClass
SUMOEmissionClass emissionClass
The emission class of this vehicle.
Definition: SUMOVTypeParameter.h:232
GNEUndoList
Definition: GNEUndoList.h:49
GUIVisualizationSettings
Stores the information about how to visualize structures.
Definition: GUIVisualizationSettings.h:346
VTYPEPARS_EMISSIONCLASS_SET
const int VTYPEPARS_EMISSIONCLASS_SET
Definition: SUMOVTypeParameter.h:51
VTYPEPARS_COLOR_SET
const int VTYPEPARS_COLOR_SET
Definition: SUMOVTypeParameter.h:52
VTYPEPARS_SHAPE_SET
const int VTYPEPARS_SHAPE_SET
Definition: SUMOVTypeParameter.h:56
SUMOVTypeParameter::VClassDefaultValues::height
double height
This class' height.
Definition: SUMOVTypeParameter.h:106
GNEUndoList::p_begin
void p_begin(const std::string &description)
Begin undo command sub-group. This begins a new group of commands that are treated as a single comman...
Definition: GNEUndoList.cpp:73
SumoXMLAttr
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
Definition: SUMOXMLDefinitions.h:373
DEFAULT_BIKETYPE_ID
const std::string DEFAULT_BIKETYPE_ID
VTYPEPARS_WIDTH_SET
const int VTYPEPARS_WIDTH_SET
Definition: SUMOVTypeParameter.h:54
GUIGlObject::getMicrosimID
virtual const std::string & getMicrosimID() const
Returns the id of the object as known to microsim.
Definition: GUIGlObject.cpp:164
GNEVehicleType::drawGL
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
Definition: GNEVehicleType.cpp:176
SUMOVTypeParameter::vehicleClass
SUMOVehicleClass vehicleClass
The vehicle's class.
Definition: SUMOVTypeParameter.h:238
VTYPEPARS_IMPATIENCE_SET
const int VTYPEPARS_IMPATIENCE_SET
Definition: SUMOVTypeParameter.h:59
SUMO_ATTR_EMISSIONCLASS
Definition: SUMOXMLDefinitions.h:792
SUMOVTypeParameter::VClassDefaultValues::speedFactor
Distribution_Parameterized speedFactor
The factor by which the maximum speed may deviate from the allowed max speed on the street.
Definition: SUMOVTypeParameter.h:115
VTYPEPARS_MAXSPEED_SET
const int VTYPEPARS_MAXSPEED_SET
Definition: SUMOVTypeParameter.h:48
GNEChange_Attribute.h
GNENet.h
SUMO_ATTR_LCA_PUSHY
Definition: SUMOXMLDefinitions.h:594
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
GNESelectorFrame::getLockGLObjectTypes
LockGLObjectTypes * getLockGLObjectTypes() const
get selected items Modul
Definition: GNESelectorFrame.cpp:460
GNEVehicleType::getAttribute
std::string getAttribute(SumoXMLAttr key) const
Definition: GNEVehicleType.cpp:213
Parameterised::knowsParameter
bool knowsParameter(const std::string &key) const
Returns whether the parameter is known.
Definition: Parameterised.cpp:65
VTYPEPARS_VEHICLECLASS_SET
const int VTYPEPARS_VEHICLECLASS_SET
Definition: SUMOVTypeParameter.h:53
SUMO_ATTR_CF_KERNER_PHI
Definition: SUMOXMLDefinitions.h:837
GNEUndoList.h
SUMO_ATTR_TAU
Definition: SUMOXMLDefinitions.h:549
SUMO_ATTR_CF_IDMM_ADAPT_TIME
Definition: SUMOXMLDefinitions.h:836
SUMO_ATTR_LCA_ACCEL_LAT
Definition: SUMOXMLDefinitions.h:599
SUMOVTypeParameter::minGapLat
double minGapLat
The vehicle type's minimum lateral gap [m].
Definition: SUMOVTypeParameter.h:300
SVS_RAIL
render as a rail
Definition: SUMOVehicleClass.h:91
SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE
Definition: SUMOXMLDefinitions.h:604
GNESelectorFrame::LockGLObjectTypes::addedLockedObject
void addedLockedObject(const GUIGlObjectType type)
set object selected
Definition: GNESelectorFrame.cpp:568