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-2020 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials are made available under the
5 // terms of the Eclipse Public License 2.0 which is available at
6 // https://www.eclipse.org/legal/epl-2.0/
7 // This Source Code may also be made available under the following Secondary
8 // Licenses when the conditions for such availability set forth in the Eclipse
9 // Public License 2.0 are satisfied: GNU General Public License, version 2
10 // or later which is available at
11 // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 /****************************************************************************/
18 // Definition of Vehicle Types in NETEDIT
19 /****************************************************************************/
20 #include <netedit/GNENet.h>
21 #include <netedit/GNEUndoList.h>
24 
25 #include "GNEVehicleType.h"
26 
27 
28 // ===========================================================================
29 // member method definitions
30 // ===========================================================================
31 
32 
33 GNEVehicleType::GNEVehicleType(GNENet* net, const std::string& vTypeID, const SUMOVehicleClass& defaultVClass, SumoXMLTag tag) :
34  GNEDemandElement(vTypeID, net, GLO_VTYPE, tag,
35 {}, {}, {}, {}, {}, {}, {}, {}),
36 SUMOVTypeParameter(vTypeID),
37 myDefaultVehicleType(true),
38 myDefaultVehicleTypeModified(false) {
39  // set default vehicle class
40  vehicleClass = defaultVClass;
41  parametersSet |= VTYPEPARS_VEHICLECLASS_SET;
42  // init Rail Visualization Parameters
43  initRailVisualizationParameters();
44 }
45 
46 
48  GNEDemandElement(vTypeParameter.id, net, GLO_VTYPE, tag,
49 {}, {}, {}, {}, {}, {}, {}, {}),
50 SUMOVTypeParameter(vTypeParameter),
51 myDefaultVehicleType(false),
52 myDefaultVehicleTypeModified(false) {
53  // if we're creating a Person Type, set manually VClass
54  if (tag == SUMO_TAG_PTYPE) {
55  vehicleClass = SVC_PEDESTRIAN;
56  parametersSet |= VTYPEPARS_VEHICLECLASS_SET;
57  }
58  // init Rail Visualization Parameters
59  initRailVisualizationParameters();
60 }
61 
62 
63 GNEVehicleType::GNEVehicleType(GNENet* net, const std::string& vTypeID, GNEVehicleType* vTypeOriginal) :
64  GNEDemandElement(vTypeID, net, GLO_VTYPE, vTypeOriginal->getTagProperty().getTag(),
65 {}, {}, {}, {}, {}, {}, {}, {}),
66 SUMOVTypeParameter(*vTypeOriginal),
67 myDefaultVehicleType(false),
68 myDefaultVehicleTypeModified(false) {
69  // change manually the ID (to avoid to use the ID of vTypeOriginal)
70  id = vTypeID;
71  // init Rail Visualization Parameters
72  initRailVisualizationParameters();
73 }
74 
75 
77 
78 
79 void
81  // only write default vehicle types if it was modified
84  write(device);
85  }
86  } else {
87  write(device);
88  }
89 }
90 
91 
94  return vehicleClass;
95 }
96 
97 
98 const RGBColor&
100  return color;
101 }
102 
103 
104 void
106  // VTypes cannot be moved
107 }
108 
109 
110 void
112  // VTypes cannot be moved
113 }
114 
115 
116 void
118  // VTypes cannot be moved
119 }
120 
121 
122 void
124  // VTypes cannot be moved
125 }
126 
127 
128 void
130  // update geometry of all childrens
131  for (const auto& i : getChildDemandElements()) {
132  i->updateGeometry();
133  }
134 }
135 
136 
137 void
139  // nothing to compute
140 }
141 
142 
143 void
145  // nothing to invalidate
146 }
147 
148 
149 Position
151  return Position();
152 }
153 
154 
155 std::string
157  return myNet->getMicrosimID();
158 }
159 
160 
161 Boundary
163  // Vehicle Types doesn't have boundaries
164  return Boundary(-0.1, -0.1, 0.1, 0.1);
165 }
166 
167 
168 void
169 GNEVehicleType::splitEdgeGeometry(const double /*splitPosition*/, const GNENetworkElement* /*originalElement*/, const GNENetworkElement* /*newElement*/, GNEUndoList* /*undoList*/) {
170  // geometry of this element cannot be splitted
171 }
172 
173 
174 void
176  // Vehicle Types aren't draw
177 }
178 
179 
180 void
181 GNEVehicleType::drawPartialGL(const GUIVisualizationSettings& /*s*/, const GNELane* /*lane*/, const double /*offsetFront*/) const {
182  // vehicleTypes don't use drawPartialGL
183 }
184 
185 
186 void
187 GNEVehicleType::drawPartialGL(const GUIVisualizationSettings& /*s*/, const GNELane* /* fromLane */, const GNELane* /* toLane */, const double /*offsetFront*/) const {
188  // vehicleTypes don't use drawPartialGL
189 }
190 
191 
192 std::string
194  // obtain default values depending of vehicle class
195  VClassDefaultValues defaultValues(vehicleClass);
196  switch (key) {
197  case SUMO_ATTR_ID:
198  return getID();
199  // CFM Attributes
200  case SUMO_ATTR_ACCEL:
201  case SUMO_ATTR_DECEL:
204  case SUMO_ATTR_SIGMA:
205  case SUMO_ATTR_TAU:
206  // this CFM has default values
208  // JM Attributes
218  // this JM has default values
222  return toString(impatience);
223  } else {
225  }
226  // LCM Attributes
233  case SUMO_ATTR_LCA_PUSHY:
245  /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
247  //
249  case SUMO_ATTR_TMP1:
250  case SUMO_ATTR_TMP2:
251  case SUMO_ATTR_TMP3:
252  case SUMO_ATTR_TMP4:
253  case SUMO_ATTR_TMP5:
261  case SUMO_ATTR_K:
265  return getCFParamString(key, "");
266  // Mutable values
267  case SUMO_ATTR_LENGTH:
269  return toString(length);
270  } else {
271  return toString(defaultValues.length);
272  }
273  case SUMO_ATTR_MINGAP:
275  return toString(minGap);
276  } else {
277  return toString(defaultValues.minGap);
278  }
279  case SUMO_ATTR_MAXSPEED:
281  return toString(maxSpeed);
282  } else {
283  return toString(defaultValues.maxSpeed);
284  }
287  return toString(speedFactor.getParameter()[0]);
288  } else {
289  return toString(defaultValues.speedFactor.getParameter()[0]);
290  }
291  case SUMO_ATTR_SPEEDDEV:
293  return toString(speedFactor.getParameter()[1]);
294  } else {
295  return toString(defaultValues.speedFactor.getParameter()[1]);
296  }
299  return toString(personCapacity);
300  } else {
301  return toString(defaultValues.personCapacity);
302  }
305  return toString(containerCapacity);
306  } else {
307  return toString(defaultValues.containerCapacity);
308  }
309  case SUMO_ATTR_OSGFILE:
311  return osgFile;
312  } else {
313  return defaultValues.osgFile;
314  }
315  case SUMO_ATTR_COLOR:
317  return toString(color);
318  } else {
319  return "";
320  }
321  case SUMO_ATTR_VCLASS:
323  return toString(vehicleClass);
324  } else {
326  }
330  } else {
331  return PollutantsInterface::getName(defaultValues.emissionClass);
332  }
333  case SUMO_ATTR_GUISHAPE:
335  return getVehicleShapeName(shape);
336  } else {
337  return getVehicleShapeName(defaultValues.shape);
338  }
339  case SUMO_ATTR_WIDTH:
341  return toString(width);
342  } else {
343  return toString(defaultValues.width);
344  }
345  case SUMO_ATTR_HEIGHT:
347  return toString(height);
348  } else {
349  return toString(defaultValues.height);
350  }
351  case SUMO_ATTR_IMGFILE:
353  return imgFile;
354  } else {
356  }
360  } else {
362  }
366  } else {
368  }
372  } else {
374  }
378  } else {
380  }
383  return toString(latAlignment);
384  } else {
386  }
389  return toString(minGapLat);
390  } else {
392  }
395  return toString(maxSpeedLat);
396  } else {
398  }
401  return toString(actionStepLength);
402  } else {
404  }
405  case SUMO_ATTR_PROB:
408  } else {
410  }
413  return toString(carriageLength);
414  } else {
415  return toString(defaultValues.carriageLength);
416  }
419  return toString(locomotiveLength);
420  } else {
421  return toString(defaultValues.locomotiveLength);
422  }
425  return toString(carriageGap);
426  } else {
428  }
429  case GNE_ATTR_PARAMETERS:
430  return getParametersStr();
432  return toString((getID() == DEFAULT_VTYPE_ID) ||
433  (getID() == DEFAULT_PEDTYPE_ID) ||
434  (getID() == DEFAULT_BIKETYPE_ID));
436  if (myDefaultVehicleType) {
438  } else {
439  return toString(false);
440  }
441  default:
442  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
443  }
444 }
445 
446 
447 double
449  // obtain default values depending of vehicle class
450  VClassDefaultValues defaultValues(vehicleClass);
451  switch (key) {
452  case SUMO_ATTR_LENGTH:
454  return length;
455  } else {
456  return defaultValues.length;
457  }
458  case SUMO_ATTR_MINGAP:
460  return minGap;
461  } else {
462  return defaultValues.minGap;
463  }
464  case SUMO_ATTR_WIDTH:
466  return width;
467  } else {
468  return defaultValues.width;
469  }
470  case SUMO_ATTR_HEIGHT:
472  return height;
473  } else {
474  return defaultValues.height;
475  }
476  case SUMO_ATTR_MAXSPEED:
478  return maxSpeed;
479  } else {
480  return defaultValues.maxSpeed;
481  }
482  default:
483  throw InvalidArgument(getTagStr() + " doesn't have a double attribute of type '" + toString(key) + "'");
484  }
485 }
486 
487 
488 void
489 GNEVehicleType::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) {
490  GNEChange_Attribute* vTypeChangeAttributeForced = nullptr;
491  if (value == getAttribute(key)) {
492  return; //avoid needless changes, later logic relies on the fact that attributes have changed
493  }
494  switch (key) {
495  case SUMO_ATTR_ID:
496  undoList->p_add(new GNEChange_Attribute(this, key, value));
497  break;
498  // CFM Attributes
499  case SUMO_ATTR_ACCEL:
500  case SUMO_ATTR_DECEL:
503  case SUMO_ATTR_SIGMA:
504  case SUMO_ATTR_TAU:
506  case SUMO_ATTR_TMP1:
507  case SUMO_ATTR_TMP2:
508  case SUMO_ATTR_TMP3:
509  case SUMO_ATTR_TMP4:
510  case SUMO_ATTR_TMP5:
518  case SUMO_ATTR_K:
522  // JM Attributes
533  // LCM Attributes
540  case SUMO_ATTR_LCA_PUSHY:
552  /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
553  //
554  case SUMO_ATTR_LENGTH:
555  case SUMO_ATTR_MINGAP:
556  case SUMO_ATTR_MAXSPEED:
558  case SUMO_ATTR_SPEEDDEV:
559  case SUMO_ATTR_COLOR:
560  case SUMO_ATTR_VCLASS:
562  case SUMO_ATTR_GUISHAPE:
563  case SUMO_ATTR_WIDTH:
564  case SUMO_ATTR_HEIGHT:
565  case SUMO_ATTR_IMGFILE:
576  case SUMO_ATTR_PROB:
577  case SUMO_ATTR_OSGFILE:
581  case GNE_ATTR_PARAMETERS:
582  // if we change the original value of a default vehicle Type, change also flag "myDefaultVehicleType"
583  if (myDefaultVehicleType) {
584  vTypeChangeAttributeForced = new GNEChange_Attribute(this, GNE_ATTR_DEFAULT_VTYPE_MODIFIED, "true");
585  // force change
586  vTypeChangeAttributeForced->forceChange();
587  undoList->p_add(vTypeChangeAttributeForced);
588  }
589  vTypeChangeAttributeForced = new GNEChange_Attribute(this, key, value);
590  // force change
591  vTypeChangeAttributeForced->forceChange();
592  undoList->p_add(vTypeChangeAttributeForced);
593  break;
595  vTypeChangeAttributeForced = new GNEChange_Attribute(this, GNE_ATTR_DEFAULT_VTYPE_MODIFIED, "true");
596  // force change
597  vTypeChangeAttributeForced->forceChange();
598  undoList->p_add(vTypeChangeAttributeForced);
599  break;
600  default:
601  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
602  }
603 }
604 
605 
606 bool
607 GNEVehicleType::isValid(SumoXMLAttr key, const std::string& value) {
608  // a empty value is always valid except for IDs
609  if ((key != SUMO_ATTR_ID) && value.empty()) {
610  return true;
611  }
612  switch (key) {
613  case SUMO_ATTR_ID:
614  // Vtypes and PTypes shares namespace
616  (myNet->retrieveDemandElement(SUMO_TAG_VTYPE, value, false) == nullptr) &&
617  (myNet->retrieveDemandElement(SUMO_TAG_PTYPE, value, false) == nullptr)) {
618  return true;
619  } else {
620  return false;
621  }
622  // CFM Attributes
623  case SUMO_ATTR_SIGMA:
624  return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
625  case SUMO_ATTR_ACCEL:
626  case SUMO_ATTR_DECEL:
629  case SUMO_ATTR_TAU:
631  case SUMO_ATTR_TMP1:
632  case SUMO_ATTR_TMP2:
633  case SUMO_ATTR_TMP3:
634  case SUMO_ATTR_TMP4:
635  case SUMO_ATTR_TMP5:
642  case SUMO_ATTR_K:
646  return canParse<double>(value);
648  // rail string
650  // JM Attributes
652  return canParse<double>(value) && (parse<double>(value) >= 0);
654  return canParse<double>(value) && (parse<double>(value) >= -1);
656  return canParse<double>(value) && (parse<double>(value) >= -1);
658  return canParse<double>(value) && (parse<double>(value) >= -1);
660  return canParse<double>(value) && (parse<double>(value) >= 0);
662  return canParse<double>(value) && (parse<double>(value) >= 0);
664  return canParse<double>(value) && (parse<double>(value) >= 0);
666  return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
668  return canParse<double>(value) && (parse<double>(value) >= 0);
670  return canParse<double>(value) && (parse<double>(value) >= 0);
671  // LCM Attributes
678  case SUMO_ATTR_LCA_PUSHY:
679  return canParse<double>(value);
683  case SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE: // 0 mean disabled
684  case SUMO_ATTR_LCA_TIME_TO_IMPATIENCE: // 0 mean disabled
685  case SUMO_ATTR_LCA_OVERTAKE_RIGHT: // 0 mean disabled
686  return canParse<double>(value) && (parse<double>(value) >= 0);
692  return canParse<double>(value) && (parse<double>(value) > 0);
693  /* case SUMO_ATTR_LCA_EXPERIMENTAL1:
694  return true;
695  */
696  //
697  case SUMO_ATTR_LENGTH:
698  return canParse<double>(value) && (parse<double>(value) > 0);
699  case SUMO_ATTR_MINGAP:
700  return canParse<double>(value) && (parse<double>(value) >= 0);
701  case SUMO_ATTR_MAXSPEED:
702  return canParse<double>(value) && (parse<double>(value) >= 0);
704  return canParse<double>(value) && (parse<double>(value) >= 0);
705  case SUMO_ATTR_SPEEDDEV:
706  return canParse<double>(value) && (parse<double>(value) >= 0);
707  case SUMO_ATTR_COLOR:
708  if (value.empty()) {
709  return true;
710  } else {
711  return canParse<RGBColor>(value);
712  }
713  case SUMO_ATTR_VCLASS:
714  return canParseVehicleClasses(value);
716  // check if given value correspond to a string of PollutantsInterface::getAllClassesStr()
717  for (const auto& i : PollutantsInterface::getAllClassesStr()) {
718  if (value == i) {
719  return true;
720  }
721  }
722  return false;
723  case SUMO_ATTR_GUISHAPE:
724  if (value == "all") {
725  return false;
726  } else {
727  return canParseVehicleShape(value);
728  }
729  case SUMO_ATTR_WIDTH:
730  return canParse<double>(value);
731  case SUMO_ATTR_HEIGHT:
732  return canParse<double>(value);
733  case SUMO_ATTR_IMGFILE:
740  return canParse<int>(value);
742  return canParse<int>(value);
744  return canParse<double>(value);
746  return canParse<double>(value);
750  return canParse<double>(value);
752  return canParse<double>(value);
754  return canParse<double>(value) && (parse<double>(value) >= 0);
755  case SUMO_ATTR_PROB:
756  return canParse<double>(value) && (parse<double>(value) >= 0);
757  case SUMO_ATTR_OSGFILE:
760  return canParse<double>(value) && (parse<double>(value) >= -1);
762  return canParse<double>(value) && (parse<double>(value) >= -1);
764  return canParse<double>(value) && (parse<double>(value) >= 0);
765  case GNE_ATTR_PARAMETERS:
766  return Parameterised::areParametersValid(value);
768  if (myDefaultVehicleType) {
769  return canParse<bool>(value);
770  } else {
771  return false;
772  }
773  default:
774  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
775  }
776 }
777 
778 
779 void
781  // nothing to enable
782 }
783 
784 
785 void
787  // nothing to disable
788 }
789 
790 
791 bool
793  switch (key) {
794  case SUMO_ATTR_ID:
795  if ((id == DEFAULT_VTYPE_ID) || (id == DEFAULT_PEDTYPE_ID) || (id == DEFAULT_BIKETYPE_ID)) {
796  return false;
797  } else {
798  return true;
799  }
800  case SUMO_ATTR_LENGTH:
802  case SUMO_ATTR_MINGAP:
804  case SUMO_ATTR_MAXSPEED:
808  case SUMO_ATTR_SPEEDDEV:
814  case SUMO_ATTR_OSGFILE:
822  default:
823  return true;
824  }
825 }
826 
827 
828 std::string
830  return getTagStr();
831 }
832 
833 
834 std::string
836  return getTagStr() + ": " + getAttribute(SUMO_ATTR_ID) ;
837 }
838 
839 
840 const std::map<std::string, std::string>&
842  return getParametersMap();
843 }
844 
845 
846 void
848  // open undo list and overwritte all values of default VType
849  undoList->p_begin("update default " + vType->getTagStr() + " '" + DEFAULT_VTYPE_ID + "'");
850  // CFM values
851  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_ACCEL, "").empty()) {
852  vType->setAttribute(SUMO_ATTR_ACCEL, toString(newVTypeParameter->getCFParam(SUMO_ATTR_ACCEL, 0)), undoList);
853  }
854  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_DECEL, "").empty()) {
855  vType->setAttribute(SUMO_ATTR_DECEL, toString(newVTypeParameter->getCFParam(SUMO_ATTR_DECEL, 0)), undoList);
856  }
857  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_APPARENTDECEL, "").empty()) {
858  vType->setAttribute(SUMO_ATTR_APPARENTDECEL, toString(newVTypeParameter->getCFParam(SUMO_ATTR_APPARENTDECEL, 0)), undoList);
859  }
860  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_EMERGENCYDECEL, "").empty()) {
861  vType->setAttribute(SUMO_ATTR_EMERGENCYDECEL, toString(newVTypeParameter->getCFParam(SUMO_ATTR_EMERGENCYDECEL, 0)), undoList);
862  }
863  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_SIGMA, "").empty()) {
864  vType->setAttribute(SUMO_ATTR_SIGMA, toString(newVTypeParameter->getCFParam(SUMO_ATTR_SIGMA, 0)), undoList);
865  }
866  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TAU, "").empty()) {
867  vType->setAttribute(SUMO_ATTR_TAU, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TAU, 0)), undoList);
868  }
869  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_COLLISION_MINGAP_FACTOR, "").empty()) {
871  }
872  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TMP1, "").empty()) {
873  vType->setAttribute(SUMO_ATTR_TMP1, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TMP1, 0)), undoList);
874  }
875  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TMP2, "").empty()) {
876  vType->setAttribute(SUMO_ATTR_TMP2, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TMP2, 0)), undoList);
877  }
878  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TMP3, "").empty()) {
879  vType->setAttribute(SUMO_ATTR_TMP3, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TMP3, 0)), undoList);
880  }
881  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TMP4, "").empty()) {
882  vType->setAttribute(SUMO_ATTR_TMP4, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TMP4, 0)), undoList);
883  }
884  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TMP5, "").empty()) {
885  vType->setAttribute(SUMO_ATTR_TMP5, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TMP5, 0)), undoList);
886  }
887  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_PWAGNER2009_TAULAST, "").empty()) {
889  }
890  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_PWAGNER2009_APPROB, "").empty()) {
892  }
893  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_IDMM_ADAPT_FACTOR, "").empty()) {
895  }
896  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_IDMM_ADAPT_TIME, "").empty()) {
898  }
899  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_WIEDEMANN_SECURITY, "").empty()) {
901  }
902  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_WIEDEMANN_ESTIMATION, "").empty()) {
904  }
905  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TRAIN_TYPE, "").empty()) {
906  vType->setAttribute(SUMO_ATTR_TRAIN_TYPE, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TRAIN_TYPE, 0)), undoList);
907  }
908  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_K, "").empty()) {
909  vType->setAttribute(SUMO_ATTR_K, toString(newVTypeParameter->getCFParam(SUMO_ATTR_K, 0)), undoList);
910  }
911  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_KERNER_PHI, "").empty()) {
912  vType->setAttribute(SUMO_ATTR_CF_KERNER_PHI, toString(newVTypeParameter->getCFParam(SUMO_ATTR_CF_KERNER_PHI, 0)), undoList);
913  }
914  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_IDM_DELTA, "").empty()) {
915  vType->setAttribute(SUMO_ATTR_CF_IDM_DELTA, toString(newVTypeParameter->getCFParam(SUMO_ATTR_CF_IDM_DELTA, 0)), undoList);
916  }
917  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_IDM_STEPPING, "").empty()) {
918  vType->setAttribute(SUMO_ATTR_CF_IDM_STEPPING, toString(newVTypeParameter->getCFParam(SUMO_ATTR_CF_IDM_STEPPING, 0)), undoList);
919  }
920  // JM values
921  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_CROSSING_GAP, "").empty()) {
922  vType->setAttribute(SUMO_ATTR_JM_CROSSING_GAP, toString(newVTypeParameter->getCFParam(SUMO_ATTR_JM_CROSSING_GAP, 0)), undoList);
923  }
924  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME, "").empty()) {
926  }
927  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME, "").empty()) {
929  }
930  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME, "").empty()) {
932  }
933  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_DRIVE_RED_SPEED, "").empty()) {
935  }
936  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_IGNORE_FOE_PROB, "").empty()) {
938  }
939  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_IGNORE_FOE_SPEED, "").empty()) {
941  }
942  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_SIGMA_MINOR, "").empty()) {
943  vType->setAttribute(SUMO_ATTR_JM_SIGMA_MINOR, toString(newVTypeParameter->getCFParam(SUMO_ATTR_JM_SIGMA_MINOR, 0)), undoList);
944  }
945  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_TIMEGAP_MINOR, "").empty()) {
946  vType->setAttribute(SUMO_ATTR_JM_TIMEGAP_MINOR, toString(newVTypeParameter->getCFParam(SUMO_ATTR_JM_TIMEGAP_MINOR, 0)), undoList);
947  }
948  if (newVTypeParameter->wasSet(VTYPEPARS_IMPATIENCE_SET)) {
949  vType->setAttribute(SUMO_ATTR_IMPATIENCE, toString(newVTypeParameter->impatience), undoList);
950  }
951  // LCM values
952  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_STRATEGIC_PARAM, "").empty()) {
954  }
955  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_COOPERATIVE_PARAM, "").empty()) {
957  }
958  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_SPEEDGAIN_PARAM, "").empty()) {
960  }
961  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_KEEPRIGHT_PARAM, "").empty()) {
963  }
964  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_SUBLANE_PARAM, "").empty()) {
966  }
967  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_OPPOSITE_PARAM, "").empty()) {
969  }
970  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_PUSHY, "").empty()) {
971  vType->setAttribute(SUMO_ATTR_LCA_PUSHY, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_PUSHY, 0)), undoList);
972  }
973  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_PUSHYGAP, "").empty()) {
974  vType->setAttribute(SUMO_ATTR_LCA_PUSHYGAP, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_PUSHYGAP, 0)), undoList);
975  }
976  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_ASSERTIVE, "").empty()) {
977  vType->setAttribute(SUMO_ATTR_LCA_ASSERTIVE, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_ASSERTIVE, 0)), undoList);
978  }
979  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_IMPATIENCE, "").empty()) {
980  vType->setAttribute(SUMO_ATTR_LCA_IMPATIENCE, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_IMPATIENCE, 0)), undoList);
981  }
982  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_TIME_TO_IMPATIENCE, "").empty()) {
984  }
985  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_ACCEL_LAT, "").empty()) {
986  vType->setAttribute(SUMO_ATTR_LCA_ACCEL_LAT, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_ACCEL_LAT, 0)), undoList);
987  }
988  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_LOOKAHEADLEFT, "").empty()) {
990  }
991  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_SPEEDGAINRIGHT, "").empty()) {
993  }
994  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_MAXSPEEDLATSTANDING, "").empty()) {
996  }
997  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_MAXSPEEDLATFACTOR, "").empty()) {
999  }
1000  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE, "").empty()) {
1002  }
1003  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_OVERTAKE_RIGHT, "").empty()) {
1005  }
1006  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_EXPERIMENTAL1, "").empty()) {
1007  vType->setAttribute(SUMO_ATTR_LCA_EXPERIMENTAL1, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_EXPERIMENTAL1, 0)), undoList);
1008  }
1009  //
1010  if (newVTypeParameter->wasSet(VTYPEPARS_LENGTH_SET)) {
1011  vType->setAttribute(SUMO_ATTR_LENGTH, toString(newVTypeParameter->length), undoList);
1012  }
1013  if (newVTypeParameter->wasSet(VTYPEPARS_MINGAP_SET)) {
1014  vType->setAttribute(SUMO_ATTR_MINGAP, toString(newVTypeParameter->minGap), undoList);
1015  }
1016  if (newVTypeParameter->wasSet(VTYPEPARS_MAXSPEED_SET)) {
1017  vType->setAttribute(SUMO_ATTR_MAXSPEED, toString(newVTypeParameter->maxSpeed), undoList);
1018  }
1019  if (newVTypeParameter->wasSet(VTYPEPARS_SPEEDFACTOR_SET)) {
1020  vType->setAttribute(SUMO_ATTR_SPEEDFACTOR, toString(newVTypeParameter->speedFactor.getParameter()[0]), undoList);
1021  }
1022  if (newVTypeParameter->wasSet(VTYPEPARS_SPEEDFACTOR_SET)) {
1023  vType->setAttribute(SUMO_ATTR_SPEEDDEV, toString(newVTypeParameter->speedFactor.getParameter()[1]), undoList);
1024  }
1025  if (newVTypeParameter->wasSet(VTYPEPARS_COLOR_SET)) {
1026  vType->setAttribute(SUMO_ATTR_COLOR, toString(newVTypeParameter->color), undoList);
1027  }
1028  if (newVTypeParameter->wasSet(VTYPEPARS_EMISSIONCLASS_SET)) {
1029  vType->setAttribute(SUMO_ATTR_EMISSIONCLASS, PollutantsInterface::getName(newVTypeParameter->emissionClass), undoList);
1030  }
1031  if (newVTypeParameter->wasSet(VTYPEPARS_SHAPE_SET)) {
1032  vType->setAttribute(SUMO_ATTR_GUISHAPE, getVehicleShapeName(newVTypeParameter->shape), undoList);
1033  }
1034  if (newVTypeParameter->wasSet(VTYPEPARS_WIDTH_SET)) {
1035  vType->setAttribute(SUMO_ATTR_WIDTH, toString(newVTypeParameter->width), undoList);
1036  }
1037  if (newVTypeParameter->wasSet(VTYPEPARS_HEIGHT_SET)) {
1038  vType->setAttribute(SUMO_ATTR_HEIGHT, toString(newVTypeParameter->height), undoList);
1039  }
1040  if (newVTypeParameter->wasSet(VTYPEPARS_IMGFILE_SET)) {
1041  vType->setAttribute(SUMO_ATTR_IMGFILE, toString(newVTypeParameter->imgFile), undoList);
1042  }
1043  if (newVTypeParameter->wasSet(VTYPEPARS_LANE_CHANGE_MODEL_SET)) {
1044  vType->setAttribute(SUMO_ATTR_LANE_CHANGE_MODEL, SUMOXMLDefinitions::LaneChangeModels.getString(newVTypeParameter->lcModel), undoList);
1045  }
1046  if (newVTypeParameter->wasSet(VTYPEPARS_CAR_FOLLOW_MODEL)) {
1047  vType->setAttribute(SUMO_ATTR_CAR_FOLLOW_MODEL, SUMOXMLDefinitions::CarFollowModels.getString(newVTypeParameter->cfModel), undoList);
1048  }
1049  if (newVTypeParameter->wasSet(VTYPEPARS_PERSON_CAPACITY)) {
1050  vType->setAttribute(SUMO_ATTR_PERSON_CAPACITY, toString(newVTypeParameter->personCapacity), undoList);
1051  }
1052  if (newVTypeParameter->wasSet(VTYPEPARS_CONTAINER_CAPACITY)) {
1053  vType->setAttribute(SUMO_ATTR_CONTAINER_CAPACITY, toString(newVTypeParameter->containerCapacity), undoList);
1054  }
1055  if (newVTypeParameter->wasSet(VTYPEPARS_BOARDING_DURATION)) {
1056  vType->setAttribute(SUMO_ATTR_BOARDING_DURATION, toString(newVTypeParameter->boardingDuration), undoList);
1057  }
1058  if (newVTypeParameter->wasSet(VTYPEPARS_LOADING_DURATION)) {
1059  vType->setAttribute(SUMO_ATTR_LOADING_DURATION, toString(newVTypeParameter->loadingDuration), undoList);
1060  }
1061  if (newVTypeParameter->wasSet(VTYPEPARS_LATALIGNMENT_SET)) {
1062  vType->setAttribute(SUMO_ATTR_LATALIGNMENT, toString(newVTypeParameter->latAlignment), undoList);
1063  }
1064  if (newVTypeParameter->wasSet(VTYPEPARS_MINGAP_LAT_SET)) {
1065  vType->setAttribute(SUMO_ATTR_MINGAP_LAT, toString(newVTypeParameter->minGapLat), undoList);
1066  }
1067  if (newVTypeParameter->wasSet(VTYPEPARS_MAXSPEED_LAT_SET)) {
1068  vType->setAttribute(SUMO_ATTR_MAXSPEED_LAT, toString(newVTypeParameter->maxSpeedLat), undoList);
1069  }
1070  if (newVTypeParameter->wasSet(VTYPEPARS_ACTIONSTEPLENGTH_SET)) {
1071  vType->setAttribute(SUMO_ATTR_ACTIONSTEPLENGTH, toString(newVTypeParameter->actionStepLength), undoList);
1072  }
1073  if (newVTypeParameter->wasSet(VTYPEPARS_PROBABILITY_SET)) {
1074  vType->setAttribute(SUMO_ATTR_PROB, toString(newVTypeParameter->defaultProbability), undoList);
1075  }
1076  if (newVTypeParameter->wasSet(VTYPEPARS_OSGFILE_SET)) {
1077  vType->setAttribute(SUMO_ATTR_OSGFILE, toString(newVTypeParameter->osgFile), undoList);
1078  }
1079  if (newVTypeParameter->knowsParameter(toString(SUMO_ATTR_CARRIAGE_LENGTH))) {
1080  vType->setAttribute(SUMO_ATTR_CARRIAGE_LENGTH, newVTypeParameter->getParameter(toString(SUMO_ATTR_CARRIAGE_LENGTH), ""), undoList);
1081  }
1082  if (newVTypeParameter->knowsParameter(toString(SUMO_ATTR_LOCOMOTIVE_LENGTH))) {
1084  }
1085  if (newVTypeParameter->knowsParameter(toString(SUMO_ATTR_CARRIAGE_GAP))) {
1086  vType->setAttribute(SUMO_ATTR_CARRIAGE_GAP, newVTypeParameter->getParameter(toString(SUMO_ATTR_CARRIAGE_GAP), ""), undoList);
1087  }
1088  // parse parameters
1089  std::string parametersStr;
1090  // Generate an string using the following structure: "key1=value1|key2=value2|...
1091  for (auto i : newVTypeParameter->getParametersMap()) {
1092  parametersStr += i.first + "=" + i.second + "|";
1093  }
1094  // remove the last "|"
1095  if (!parametersStr.empty()) {
1096  parametersStr.pop_back();
1097  }
1098  if (parametersStr != vType->getAttribute(GNE_ATTR_PARAMETERS)) {
1099  vType->setAttribute(GNE_ATTR_PARAMETERS, parametersStr, undoList);
1100  }
1101  // close undo list
1102  undoList->p_end();
1103 }
1104 
1105 
1106 void
1108  if (SUMOVTypeParameter::knowsParameter("carriageLength")) {
1111  } else if (wasSet(VTYPEPARS_SHAPE_SET)) {
1112  switch (shape) {
1113  case SVS_BUS_FLEXIBLE:
1114  carriageLength = 8.25; // 16.5 overall, 2 modules http://de.wikipedia.org/wiki/Ikarus_180
1115  carriageGap = 0;
1116  break;
1117  case SVS_RAIL:
1118  carriageLength = 24.5; // http://de.wikipedia.org/wiki/UIC-Y-Wagen_%28DR%29
1119  break;
1120  case SVS_RAIL_CAR:
1121  carriageLength = 16.85; // 67.4m overall, 4 carriages http://de.wikipedia.org/wiki/DB-Baureihe_423
1122  break;
1123  case SVS_RAIL_CARGO:
1124  carriageLength = 13.86; // UIC 571-1 http://de.wikipedia.org/wiki/Flachwagen
1125  break;
1126  case SVS_TRUCK_SEMITRAILER:
1127  carriageLength = 13.5;
1128  locomotiveLength = 2.5;
1129  carriageGap = 0.5;
1130  break;
1131  case SVS_TRUCK_1TRAILER:
1132  carriageLength = 6.75;
1133  locomotiveLength = 2.5 + 6.75;
1134  carriageGap = 0.5;
1135  break;
1136  default:
1137  break;
1138  }
1139  }
1140  if (SUMOVTypeParameter::knowsParameter("locomotiveLength")) {
1143  } else if (locomotiveLength <= 0) {
1145  }
1146  if (SUMOVTypeParameter::knowsParameter("carriageGap")) {
1149  }
1150 }
1151 
1152 // ===========================================================================
1153 // private
1154 // ===========================================================================
1155 
1156 void
1157 GNEVehicleType::setAttribute(SumoXMLAttr key, const std::string& value) {
1158  // obtain default values depending of vehicle class
1159  VClassDefaultValues defaultValues(vehicleClass);
1160  switch (key) {
1161  case SUMO_ATTR_ID:
1162  myNet->getAttributeCarriers()->updateID(this, value);
1163  // manually change VType parameters ID
1164  id = value;
1165  break;
1166  // CFM Attributes
1167  case SUMO_ATTR_ACCEL:
1168  case SUMO_ATTR_DECEL:
1171  case SUMO_ATTR_SIGMA:
1172  case SUMO_ATTR_TAU:
1174  case SUMO_ATTR_TMP1:
1175  case SUMO_ATTR_TMP2:
1176  case SUMO_ATTR_TMP3:
1177  case SUMO_ATTR_TMP4:
1178  case SUMO_ATTR_TMP5:
1185  case SUMO_ATTR_TRAIN_TYPE:
1186  case SUMO_ATTR_K:
1190  // empty values means that value isn't set
1191  if (value.empty()) {
1192  const auto it = cfParameter.find(key);
1193  if (it != cfParameter.end()) {
1194  cfParameter.erase(it);
1195  }
1196  } else {
1197  cfParameter[key] = value;
1198  }
1199  break;
1200  // JM Attributes
1210  // empty values means that value isn't set
1211  if (value.empty()) {
1212  const auto it = jmParameter.find(key);
1213  if (it != jmParameter.end()) {
1214  jmParameter.erase(it);
1215  }
1216  } else {
1217  jmParameter[key] = value;
1218  }
1219  break;
1220  case SUMO_ATTR_IMPATIENCE:
1221  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1222  impatience = parse<double>(value);
1223  // mark parameter as set
1225  } else {
1226  // set default value
1227  impatience = parse<double>(myTagProperty.getDefaultValue(key));
1228  // unset parameter
1230  }
1231  break;
1232  // LCM Attributes
1239  case SUMO_ATTR_LCA_PUSHY:
1248 
1249  /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
1250  // empty values means that value isn't set
1251  if (value.empty()) {
1252  const auto it = lcParameter.find(key);
1253  if (it != lcParameter.end()) {
1254  lcParameter.erase(it);
1255  }
1256  } else {
1257  lcParameter[key] = value;
1258  }
1259  break;
1263  // empty or null values means that value isn't set
1264  if (value.empty() || (canParse<double>(value) && (parse<double>(value) == 0))) {
1265  const auto it = lcParameter.find(key);
1266  if (it != lcParameter.end()) {
1267  lcParameter.erase(it);
1268  }
1269  } else {
1270  lcParameter[key] = value;
1271  }
1272  break;
1273  //
1274  case SUMO_ATTR_LENGTH:
1275  if (!value.empty() && (value != toString(defaultValues.length))) {
1276  length = parse<double>(value);
1277  // mark parameter as set
1279  } else {
1280  // set default value
1281  length = defaultValues.length;
1282  // unset parameter
1284  }
1285  break;
1286  case SUMO_ATTR_MINGAP:
1287  if (!value.empty() && (value != toString(defaultValues.minGap))) {
1288  minGap = parse<double>(value);
1289  // mark parameter as set
1291  } else {
1292  // set default value
1293  minGap = defaultValues.minGap;
1294  // unset parameter
1296  }
1297  break;
1298  case SUMO_ATTR_MAXSPEED:
1299  if (!value.empty() && (value != toString(defaultValues.maxSpeed))) {
1300  maxSpeed = parse<double>(value);
1301  // mark parameter as set
1303  } else {
1304  // set default value
1305  maxSpeed = defaultValues.maxSpeed;
1306  // unset parameter
1308  }
1309  break;
1310  case SUMO_ATTR_SPEEDFACTOR:
1311  if (!value.empty() && (value != toString(defaultValues.speedFactor.getParameter()[0]))) {
1312  speedFactor.getParameter()[0] = parse<double>(value);
1313  // mark parameter as set
1315  } else {
1316  // set default value
1317  speedFactor.getParameter()[0] = defaultValues.speedFactor.getParameter()[0];
1318  // unset parameter
1320  }
1321  break;
1322  case SUMO_ATTR_SPEEDDEV:
1323  if (!value.empty() && (value != toString(defaultValues.speedFactor.getParameter()[1]))) {
1324  speedFactor.getParameter()[1] = parse<double>(value);
1325  // mark parameter as set
1327  } else {
1328  // set default value
1329  speedFactor.getParameter()[1] = defaultValues.speedFactor.getParameter()[1];
1330  // unset parameter
1332  }
1333  break;
1334  case SUMO_ATTR_COLOR:
1335  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1336  color = parse<RGBColor>(value);
1337  // mark parameter as set
1339  } else {
1340  // unset parameter
1342  }
1343  break;
1344  case SUMO_ATTR_VCLASS:
1345  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1347  // mark parameter as set
1349  } else {
1350  // set default value
1352  // unset parameter
1354  }
1355  // update default values
1356  updateDefaultVClassAttributes(defaultValues);
1357  break;
1359  if (!value.empty() && (value != toString(defaultValues.emissionClass))) {
1361  // mark parameter as set
1363  } else {
1364  // set default value
1365  emissionClass = defaultValues.emissionClass;
1366  // unset parameter
1368  }
1369  break;
1370  case SUMO_ATTR_GUISHAPE:
1371  if (!value.empty() && (value != toString(defaultValues.shape))) {
1372  shape = getVehicleShapeID(value);
1373  // mark parameter as set
1375  } else {
1376  // set default value
1377  shape = defaultValues.shape;
1378  // unset parameter
1380  }
1381  break;
1382  case SUMO_ATTR_WIDTH:
1383  if (!value.empty() && (value != toString(defaultValues.width))) {
1384  width = parse<double>(value);
1385  // mark parameter as set
1387  } else {
1388  // set default value
1389  width = defaultValues.width;
1390  // unset parameter
1392  }
1393  break;
1394  case SUMO_ATTR_HEIGHT:
1395  if (!value.empty() && (value != toString(defaultValues.height))) {
1396  height = parse<double>(value);
1397  // mark parameter as set
1399  } else {
1400  // set default value
1401  height = defaultValues.height;
1402  // unset parameter
1404  }
1405  break;
1406  case SUMO_ATTR_IMGFILE:
1407  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1408  imgFile = value;
1409  // mark parameter as set
1411  } else {
1412  // set default value
1414  // unset parameter
1416  }
1417  break;
1419  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1421  // mark parameter as set
1423  } else {
1424  // set default value
1426  // unset parameter
1428  }
1429  break;
1431  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1433  // mark parameter as set
1435  } else {
1436  // set default value
1438  // unset parameter
1440  }
1441  break;
1443  if (!value.empty() && (value != toString(defaultValues.personCapacity))) {
1444  personCapacity = parse<int>(value);
1445  // mark parameter as set
1447  } else {
1448  // set default value
1449  personCapacity = defaultValues.personCapacity;
1450  // unset parameter
1452  }
1453  break;
1455  if (!value.empty() && (value != toString(defaultValues.containerCapacity))) {
1456  containerCapacity = parse<int>(value);
1457  // mark parameter as set
1459  } else {
1460  // set default value
1461  containerCapacity = defaultValues.containerCapacity;
1462  // unset parameter
1464  }
1465  break;
1467  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1468  boardingDuration = string2time(value);
1469  // mark parameter as set
1471  } else {
1472  // set default value
1474  // unset parameter
1476  }
1477  break;
1479  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1480  loadingDuration = string2time(value);
1481  // mark parameter as set
1483  } else {
1484  // set default value
1486  // unset parameter
1488  }
1489  break;
1491  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1493  // mark parameter as set
1495  } else {
1496  // set default value
1498  // unset parameter
1500  }
1501  break;
1502  case SUMO_ATTR_MINGAP_LAT:
1503  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1504  minGapLat = parse<double>(value);
1505  // mark parameter as set
1507  } else {
1508  // set default value
1509  minGapLat = parse<double>(myTagProperty.getDefaultValue(key));
1510  // unset parameter
1512  }
1513  break;
1515  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1516  maxSpeedLat = parse<double>(value);
1517  // mark parameter as set
1519  } else {
1520  // set default value
1521  maxSpeedLat = parse<double>(myTagProperty.getDefaultValue(key));
1522  // unset parameter
1524  }
1525  break;
1527  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1528  actionStepLength = string2time(value);
1529  // mark parameter as set
1531  } else {
1532  // set default value
1534  // unset parameter
1536  }
1537  break;
1538  case SUMO_ATTR_PROB:
1539  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1540  defaultProbability = parse<double>(value);
1541  // mark parameter as set
1543  } else {
1544  // set default value
1545  defaultProbability = parse<double>(myTagProperty.getDefaultValue(key));
1546  // unset parameter
1548  }
1549  break;
1550  case SUMO_ATTR_OSGFILE:
1551  if (!value.empty() && (value != defaultValues.osgFile)) {
1552  osgFile = value;
1553  // mark parameter as set
1555  } else {
1556  // set default value
1557  osgFile = defaultValues.osgFile;
1558  // unset parameter
1560  }
1561  break;
1563  if (!value.empty() && (value != toString(defaultValues.carriageLength))) {
1564  carriageLength = parse<double>(value);
1565  // mark parameter as set
1567  // set parameter in SUMOVTypeParameter (needed for writting in XML)
1569  } else {
1570  // set default value
1571  carriageLength = defaultValues.carriageLength;
1572  // unset parameter
1574  // remove from params (needed for writting in XML)
1576  }
1577  break;
1579  if (!value.empty() && (value != toString(defaultValues.containerCapacity))) {
1580  locomotiveLength = parse<double>(value);
1581  // mark parameter as set
1583  // set parameter in SUMOVTypeParameter (needed for writting in XML)
1585  } else {
1586  // set default value
1587  locomotiveLength = defaultValues.locomotiveLength;
1588  // unset parameter
1590  // remove from params (needed for writting in XML)
1592  }
1593  break;
1595  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1596  carriageGap = parse<double>(value);
1597  // mark parameter as set
1599  // set parameter in SUMOVTypeParameter (needed for writting in XML)
1601  } else {
1602  // set default value
1603  carriageGap = parse<double>(myTagProperty.getDefaultValue(key));
1604  // unset parameter
1606  // remove from params (needed for writting in XML)
1608  }
1609  break;
1610  case GNE_ATTR_PARAMETERS:
1611  setParametersStr(value);
1612  break;
1614  myDefaultVehicleTypeModified = parse<bool>(value);
1615  break;
1616  default:
1617  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
1618  }
1619  // check if geometry must be marked as deprecated
1621  updateGeometry();
1622  }
1623 }
1624 
1625 
1626 void
1627 GNEVehicleType::setEnabledAttribute(const int /*enabledAttributes*/) {
1628  //
1629 }
1630 
1631 
1632 void
1634  if (!wasSet(VTYPEPARS_LENGTH_SET)) {
1635  length = defaultValues.length;
1636  }
1637  if (!wasSet(VTYPEPARS_MINGAP_SET)) {
1638  minGap = defaultValues.minGap;
1639  }
1641  maxSpeed = defaultValues.maxSpeed;
1642  }
1643  if (!wasSet(VTYPEPARS_WIDTH_SET)) {
1644  width = defaultValues.width;
1645  }
1646  if (!wasSet(VTYPEPARS_HEIGHT_SET)) {
1647  height = defaultValues.height;
1648  }
1649  if (!wasSet(VTYPEPARS_SHAPE_SET)) {
1650  shape = defaultValues.shape;
1651  }
1653  emissionClass = defaultValues.emissionClass;
1654  }
1656  speedFactor = defaultValues.speedFactor;
1657  }
1659  personCapacity = defaultValues.personCapacity;
1660  }
1662  containerCapacity = defaultValues.containerCapacity;
1663  }
1664  if (!wasSet(VTYPEPARS_OSGFILE_SET)) {
1665  osgFile = defaultValues.osgFile;
1666  }
1668  carriageLength = defaultValues.carriageLength;
1669  }
1671  locomotiveLength = defaultValues.locomotiveLength;
1672  }
1673 }
1674 
1675 
1676 /****************************************************************************/
@ GLO_VTYPE
@bief vTypes
std::string time2string(SUMOTime t)
convert SUMOTime to string
Definition: SUMOTime.cpp:68
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition: SUMOTime.cpp:45
const int VTYPEPARS_MAXSPEED_SET
const int VTYPEPARS_PERSON_CAPACITY
const int VTYPEPARS_HEIGHT_SET
const int VTYPEPARS_VEHICLECLASS_SET
const int VTYPEPARS_COLOR_SET
const int VTYPEPARS_SPEEDFACTOR_SET
const int VTYPEPARS_BOARDING_DURATION
const int VTYPEPARS_IMPATIENCE_SET
const int VTYPEPARS_LATALIGNMENT_SET
const int VTYPEPARS_LENGTH_SET
const int VTYPEPARS_CARRIAGE_LENGTH_SET
const int VTYPEPARS_OSGFILE_SET
const int VTYPEPARS_LOCOMOTIVE_LENGTH_SET
const int VTYPEPARS_LANE_CHANGE_MODEL_SET
const int VTYPEPARS_MINGAP_SET
const int VTYPEPARS_IMGFILE_SET
const int VTYPEPARS_SHAPE_SET
const int VTYPEPARS_ACTIONSTEPLENGTH_SET
const int VTYPEPARS_LOADING_DURATION
const int VTYPEPARS_CONTAINER_CAPACITY
const int VTYPEPARS_CARRIAGE_GAP_SET
const int VTYPEPARS_MAXSPEED_LAT_SET
const int VTYPEPARS_EMISSIONCLASS_SET
const int VTYPEPARS_PROBABILITY_SET
const int VTYPEPARS_CAR_FOLLOW_MODEL
const int VTYPEPARS_MINGAP_LAT_SET
const int VTYPEPARS_WIDTH_SET
bool canParseVehicleShape(const std::string &shape)
Checks whether the given string contains only known vehicle shape.
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
SUMOVehicleShape getVehicleShapeID(const std::string &name)
Returns the class id of the shape class given by its name.
bool canParseVehicleClasses(const std::string &classes)
Checks whether the given string contains only known vehicle classes.
std::string getVehicleShapeName(SUMOVehicleShape id)
Returns the class name of the shape class given by its id.
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
@ SVC_PEDESTRIAN
pedestrian
const std::string DEFAULT_PEDTYPE_ID
@ SVS_TRUCK_SEMITRAILER
render as a semi-trailer transport vehicle ("Sattelschlepper")
@ SVS_RAIL
render as a rail
@ SVS_BUS_FLEXIBLE
render as a flexible city bus
@ SVS_RAIL_CARGO
render as a cargo train
@ SVS_RAIL_CAR
render as a (city) rail without locomotive
@ SVS_TRUCK_1TRAILER
render as a transport vehicle with one trailer
const std::string DEFAULT_VTYPE_ID
const std::string DEFAULT_BIKETYPE_ID
SumoXMLTag
Numbers representing SUMO-XML - element names.
@ SUMO_TAG_VTYPE
description of a vehicle type
@ SUMO_TAG_PTYPE
description of a person type (used in NETEDIT)
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
@ SUMO_ATTR_TMP4
@ SUMO_ATTR_LCA_PUSHY
@ SUMO_ATTR_EMISSIONCLASS
@ SUMO_ATTR_JM_IGNORE_FOE_SPEED
@ SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME
@ SUMO_ATTR_CF_WIEDEMANN_SECURITY
@ SUMO_ATTR_LCA_ASSERTIVE
@ SUMO_ATTR_TRAIN_TYPE
@ SUMO_ATTR_CF_IDMM_ADAPT_TIME
@ SUMO_ATTR_LANE_CHANGE_MODEL
@ SUMO_ATTR_CF_KERNER_PHI
@ SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE
@ SUMO_ATTR_LCA_PUSHYGAP
@ SUMO_ATTR_LCA_LOOKAHEADLEFT
@ SUMO_ATTR_APPARENTDECEL
@ SUMO_ATTR_MAXSPEED_LAT
@ SUMO_ATTR_LCA_SPEEDGAIN_PARAM
@ SUMO_ATTR_TMP3
@ SUMO_ATTR_ACTIONSTEPLENGTH
@ SUMO_ATTR_LCA_IMPATIENCE
@ SUMO_ATTR_MINGAP
@ GNE_ATTR_PARAMETERS
parameters "key1=value1|key2=value2|...|keyN=valueN"
@ SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME
@ SUMO_ATTR_TMP2
@ SUMO_ATTR_LOADING_DURATION
@ SUMO_ATTR_CF_IDM_DELTA
@ SUMO_ATTR_LCA_MAXSPEEDLATFACTOR
@ GNE_ATTR_DEFAULT_VTYPE
Flag to check if VType is a default VType.
@ SUMO_ATTR_CF_PWAGNER2009_TAULAST
@ SUMO_ATTR_CAR_FOLLOW_MODEL
@ SUMO_ATTR_DECEL
@ SUMO_ATTR_LCA_MAXSPEEDLATSTANDING
@ SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME
@ SUMO_ATTR_LCA_KEEPRIGHT_PARAM
@ SUMO_ATTR_GUISHAPE
@ SUMO_ATTR_JM_IGNORE_FOE_PROB
@ SUMO_ATTR_CONTAINER_CAPACITY
@ SUMO_ATTR_LCA_COOPERATIVE_PARAM
@ SUMO_ATTR_LCA_OPPOSITE_PARAM
@ SUMO_ATTR_MINGAP_LAT
@ SUMO_ATTR_EMERGENCYDECEL
@ SUMO_ATTR_HEIGHT
@ SUMO_ATTR_LCA_SUBLANE_PARAM
@ SUMO_ATTR_JM_CROSSING_GAP
@ SUMO_ATTR_CARRIAGE_LENGTH
@ SUMO_ATTR_LATALIGNMENT
@ SUMO_ATTR_CF_IDM_STEPPING
@ SUMO_ATTR_CF_IDMM_ADAPT_FACTOR
@ SUMO_ATTR_IMPATIENCE
@ SUMO_ATTR_COLLISION_MINGAP_FACTOR
@ SUMO_ATTR_VCLASS
@ SUMO_ATTR_ACCEL
@ SUMO_ATTR_BOARDING_DURATION
@ SUMO_ATTR_JM_SIGMA_MINOR
@ SUMO_ATTR_PROB
@ SUMO_ATTR_SPEEDFACTOR
@ SUMO_ATTR_LENGTH
@ SUMO_ATTR_COLOR
A color information.
@ SUMO_ATTR_CF_PWAGNER2009_APPROB
@ SUMO_ATTR_MAXSPEED
@ SUMO_ATTR_ID
@ SUMO_ATTR_SIGMA
@ GNE_ATTR_DEFAULT_VTYPE_MODIFIED
Flag to check if a default VType was modified.
@ SUMO_ATTR_K
@ SUMO_ATTR_TMP1
@ SUMO_ATTR_OSGFILE
@ SUMO_ATTR_LCA_OVERTAKE_RIGHT
@ SUMO_ATTR_LCA_ACCEL_LAT
@ SUMO_ATTR_LCA_STRATEGIC_PARAM
@ SUMO_ATTR_TAU
@ SUMO_ATTR_IMGFILE
@ SUMO_ATTR_WIDTH
@ SUMO_ATTR_PERSON_CAPACITY
@ SUMO_ATTR_LCA_EXPERIMENTAL1
@ SUMO_ATTR_LOCOMOTIVE_LENGTH
@ SUMO_ATTR_TMP5
@ SUMO_ATTR_JM_DRIVE_RED_SPEED
@ SUMO_ATTR_LCA_TIME_TO_IMPATIENCE
@ SUMO_ATTR_JM_TIMEGAP_MINOR
@ SUMO_ATTR_CARRIAGE_GAP
@ SUMO_ATTR_SPEEDDEV
@ SUMO_ATTR_CF_WIEDEMANN_ESTIMATION
@ SUMO_ATTR_LCA_SPEEDGAINRIGHT
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:44
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:39
std::vector< double > & getParameter()
Returns the parameters of this distribution.
friend class GNEChange_Attribute
declare friend class
const std::string & getTagStr() const
get tag assigned to this object in string format
GNENet * myNet
pointer to net
const GNETagProperties & myTagProperty
the xml tag to which this attribute carrier corresponds
bool requireUpdateGeometry() const
return true if atribute requires a update geometry in setAttribute(...)
the function-object for an editing operation (abstract base)
void forceChange()
force change
An Element which don't belongs to GNENet but has influency in the simulation.
virtual std::string getAttribute(SumoXMLAttr key) const =0
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
const std::string & getID() const
get ID
const std::vector< GNEDemandElement * > & getChildDemandElements() const
return child demand elements
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:45
void updateID(GNEAttributeCarrier *AC, const std::string newID)
update ID
A NBNetBuilder extended by visualisation and editing capabilities.
Definition: GNENet.h:40
GNENetHelper::AttributeCarriers * getAttributeCarriers() const
retrieve all attribute carriers of Net
Definition: GNENet.cpp:130
GNEDemandElement * retrieveDemandElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named demand element.
Definition: GNENet.cpp:2435
const GNEAttributeProperties & getAttributeProperties(SumoXMLAttr attr) const
get attribute (throw error if doesn't exist)
const std::string & getDefaultValue(SumoXMLAttr attr) const
return the default value of the attribute of an element
bool hasAttribute(SumoXMLAttr attr) const
check if current TagProperties owns the attribute "attr"
void p_add(GNEChange_Attribute *cmd)
special method, avoid empty changes, always execute
void p_begin(const std::string &description)
Begin undo command sub-group. This begins a new group of commands that are treated as a single comman...
Definition: GNEUndoList.cpp:71
void p_end()
End undo command sub-group. If the sub-group is still empty, it will be deleted; otherwise,...
Definition: GNEUndoList.cpp:78
double getAttributeDouble(SumoXMLAttr key) const
static void overwriteVType(GNEDemandElement *vType, SUMOVTypeParameter *newVTypeParameter, GNEUndoList *undoList)
overwrite all values of GNEVehicleType with a SUMOVTypeParameter
bool isValid(SumoXMLAttr key, const std::string &value)
method for checking if the key and their conrrespond attribute are valids
std::string getAttribute(SumoXMLAttr key) const
inherited from GNEAttributeCarrier
Position getPositionInView() const
Returns position of additional in view.
void moveGeometry(const Position &offset)
change the position of the element geometry without saving in undoList
GNEVehicleType(GNENet *net, const std::string &vTypeID, const SUMOVehicleClass &defaultVClass, SumoXMLTag tag)
constructor for default VTypes
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
method for setting the attribute and letting the object perform demand element changes
void commitGeometryMoving(GNEUndoList *undoList)
commit geometry changes in the attributes of an element after use of moveGeometry(....
const std::map< std::string, std::string > & getACParametersMap() const
get parameters map
bool myDefaultVehicleType
flag to check if this GNEVehicleType is a default vehicle Type (For Vehicles, Pedestrians....
void drawPartialGL(const GUIVisualizationSettings &s, const GNELane *lane, const double offsetFront) const
Draws partial object.
void splitEdgeGeometry(const double splitPosition, const GNENetworkElement *originalElement, const GNENetworkElement *newElement, GNEUndoList *undoList)
split geometry
void enableAttribute(SumoXMLAttr key, GNEUndoList *undoList)
SUMOVehicleClass getVClass() const
void initRailVisualizationParameters()
init Rail Visualization Parameters
void writeDemandElement(OutputDevice &device) const
writte demand element element into a xml file
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
void updateDefaultVClassAttributes(const VClassDefaultValues &defaultValues)
function called after set new VClass
std::string getHierarchyName() const
get Hierarchy Name (Used in AC Hierarchy)
void setEnabledAttribute(const int enabledAttributes)
method for enabling the attribute and nothing else (used in GNEChange_EnableAttribute)
std::string getParentName() const
Returns the name of the parent object.
std::string getPopUpID() const
get PopPup ID (Used in AC Hierarchy)
void updateGeometry()
update pre-computed geometry information
void startGeometryMoving()
void endGeometryMoving()
end geometry movement
const RGBColor & getColor() const
get color
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
void invalidatePath()
invalidate path
bool myDefaultVehicleTypeModified
flag to check if this default GNEVehicleType was modified
void disableAttribute(SumoXMLAttr key, GNEUndoList *undoList)
void computePath()
compute path
bool isAttributeEnabled(SumoXMLAttr key) const
~GNEVehicleType()
destructor
virtual const std::string & getMicrosimID() const
Returns the id of the object as known to microsim.
Stores the information about how to visualize structures.
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:60
void unsetParameter(const std::string &key)
Removes a parameter.
static bool areParametersValid(const std::string &value, bool report=false, ParameterisedAttrType attrType=ParameterisedAttrType::STRING, const std::string kvsep="=", const std::string sep="|")
check if given string can be parsed to a parameters map "key1=value1|key2=value2|....
void setParametersStr(const std::string &paramsString, const std::string kvsep="=", const std::string sep="|")
set the inner key/value map in string format "key1=value1|key2=value2|...|keyN=valueN"
const std::string getParameter(const std::string &key, const std::string defaultValue="") const
Returns the value for a given key.
virtual void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
std::string getParametersStr(const std::string kvsep="=", const std::string sep="|") const
Returns the inner key/value map in string format "key1=value1|key2=value2|...|keyN=valueN".
const std::map< std::string, std::string > & getParametersMap() const
Returns the inner key/value map.
bool knowsParameter(const std::string &key) const
Returns whether the parameter is known.
static std::string getName(const SUMOEmissionClass c)
Checks whether the string describes a known vehicle class.
static const std::vector< std::string > & getAllClassesStr()
Get all SUMOEmissionClass in string format.
static SUMOEmissionClass getClassByName(const std::string &eClass, const SUMOVehicleClass vc=SVC_IGNORING)
Checks whether the string describes a known vehicle class.
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:36
Structure representing possible vehicle parameter.
double width
This class' width.
SubParams cfParameter
Car-following parameter.
void write(OutputDevice &dev) const
Writes the vtype.
double defaultProbability
The probability when being added to a distribution without an explicit probability.
SUMOTime actionStepLength
The vehicle type's default actionStepLength [ms], i.e. the interval between two control actions....
double height
This class' height.
SUMOEmissionClass emissionClass
The emission class of this vehicle.
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.
double carriageLength
the length of train carriages and locomotive
double length
The physical vehicle length.
double maxSpeedLat
The vehicle type's maximum lateral speed [m/s].
LateralAlignment latAlignment
The vehicles desired lateral alignment.
bool wasSet(int what) const
Returns whether the given parameter was set.
RGBColor color
The color.
double minGap
This class' free space in front of the vehicle itself.
std::string imgFile
Image file for this class.
SUMOVehicleShape shape
This class' shape.
int personCapacity
The person capacity of the vehicle.
Distribution_Parameterized speedFactor
The factor by which the maximum speed may deviate from the allowed max speed on the street.
std::string osgFile
3D model file for this class
double maxSpeed
The vehicle type's maximum speed [m/s].
int parametersSet
Information for the router which parameter were set.
int containerCapacity
The container capacity of the vehicle.
SUMOTime boardingDuration
The time a person needs to board the vehicle.
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.
double minGapLat
The vehicle type's minimum lateral gap [m].
SUMOVehicleClass vehicleClass
The vehicle's class.
SUMOTime loadingDuration
The time a container needs to get loaded on the vehicle.
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.
SumoXMLTag cfModel
The enum-representation of the car-following model to use.
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.
SubParams lcParameter
Lane-changing parameter.
SubParams jmParameter
Junction-model parameter.
double impatience
The vehicle's impatience (willingness to obstruct others)
LaneChangeModel lcModel
The lane-change model to use.
static StringBijection< SumoXMLTag > CarFollowModels
car following models
static bool isValidVehicleID(const std::string &value)
whether the given string is a valid id for a vehicle or flow
static bool isValidFilename(const std::string &value)
whether the given string is a valid attribute for a filename (for example, a name)
static StringBijection< TrainType > TrainTypes
train types
static StringBijection< LaneChangeModel > LaneChangeModels
lane change models
static StringBijection< LateralAlignment > LateralAlignments
lateral alignments
bool hasString(const std::string &str) const
const std::string & getString(const T key) const
T get(const std::string &str) const
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
struct for default values that depend of VClass
int personCapacity
The person capacity of the vehicle.
double carriageLength
the length of train carriages
std::string osgFile
3D model file for this class
SUMOEmissionClass emissionClass
The emission class of this vehicle.
double minGap
This class' free space in front of the vehicle itself.
int containerCapacity
The container capacity of the vehicle.
double maxSpeed
The vehicle type's maximum speed [m/s].
Distribution_Parameterized speedFactor
The factor by which the maximum speed may deviate from the allowed max speed on the street.
double length
The physical vehicle length.
SUMOVehicleShape shape
This class' shape.
double locomotiveLength
the length of train locomotive