Eclipse SUMO - Simulation of Urban MObility
GNEVType.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-2022 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/GNEViewNet.h>
22 #include <netedit/GNEUndoList.h>
26 
27 #include "GNEVType.h"
28 #include "GNEVTypeDistribution.h"
29 
30 
31 // ===========================================================================
32 // member method definitions
33 // ===========================================================================
34 
36  GNEDemandElement("", net, GLO_VTYPE, SUMO_TAG_VTYPE, GNEPathManager::PathElement::Options::DEMAND_ELEMENT,
37 {}, {}, {}, {}, {}, {}, {}, {}),
39 myDefaultVehicleType(true),
40 myDefaultVehicleTypeModified(false) {
41  // reset default values
42  resetDefaultValues();
43  // init Rail Visualization Parameters
44  initRailVisualizationParameters();
45 }
46 
47 
48 GNEVType::GNEVType(GNENet* net, const std::string& vTypeID, const SUMOVehicleClass& defaultVClass) :
49  GNEDemandElement(vTypeID, net, GLO_VTYPE, SUMO_TAG_VTYPE, GNEPathManager::PathElement::Options::DEMAND_ELEMENT,
50 {}, {}, {}, {}, {}, {}, {}, {}),
51 SUMOVTypeParameter(vTypeID),
52 myDefaultVehicleType(true),
53 myDefaultVehicleTypeModified(false) {
54  // set default vehicle class
55  vehicleClass = defaultVClass;
56  parametersSet |= VTYPEPARS_VEHICLECLASS_SET;
57  // init Rail Visualization Parameters
58  initRailVisualizationParameters();
59 }
60 
61 
62 GNEVType::GNEVType(GNENet* net, const SUMOVTypeParameter& vTypeParameter) :
63  GNEDemandElement(vTypeParameter.id, net, GLO_VTYPE, SUMO_TAG_VTYPE, GNEPathManager::PathElement::Options::DEMAND_ELEMENT,
64 {}, {}, {}, {}, {}, {}, {}, {}),
65 SUMOVTypeParameter(vTypeParameter),
66 myDefaultVehicleType(false),
67 myDefaultVehicleTypeModified(false) {
68  // init Rail Visualization Parameters
69  initRailVisualizationParameters();
70 }
71 
72 
73 GNEVType::GNEVType(GNENet* net, const std::string& vTypeID, GNEVType* vTypeOriginal) :
74  GNEDemandElement(vTypeID, net, GLO_VTYPE, vTypeOriginal->getTagProperty().getTag(), GNEPathManager::PathElement::Options::DEMAND_ELEMENT,
75 {}, {}, {}, {}, {}, {}, {}, {}),
76 SUMOVTypeParameter(*vTypeOriginal),
77 myDefaultVehicleType(false),
78 myDefaultVehicleTypeModified(false) {
79  // change manually the ID (to avoid to use the ID of vTypeOriginal)
80  id = vTypeID;
81  // init Rail Visualization Parameters
82  initRailVisualizationParameters();
83 }
84 
85 
87 
88 
91  return nullptr;
92 }
93 
94 
95 void
97  // only write default vehicle types if it was modified
100  write(device);
101  }
102  } else {
103  write(device);
104  }
105 }
106 
107 
110  // currently vTypes don't have problems
112 }
113 
114 
115 std::string
117  return "";
118 }
119 
120 
121 void
123  // nothing to fix
124 }
125 
126 
129  return vehicleClass;
130 }
131 
132 
133 const RGBColor&
135  return color;
136 }
137 
138 
139 void
141  // update geometry of all childrens
142  for (const auto& i : getChildDemandElements()) {
143  i->updateGeometry();
144  }
145 }
146 
147 
148 Position
150  return Position();
151 }
152 
153 
154 std::string
156  return myNet->getMicrosimID();
157 }
158 
159 
160 double
162  return 1;
163 }
164 
165 
166 Boundary
168  // Vehicle Types doesn't have boundaries
169  return Boundary(-0.1, -0.1, 0.1, 0.1);
170 }
171 
172 
173 void
174 GNEVType::splitEdgeGeometry(const double /*splitPosition*/, const GNENetworkElement* /*originalElement*/, const GNENetworkElement* /*newElement*/, GNEUndoList* /*undoList*/) {
175  // geometry of this element cannot be splitted
176 }
177 
178 
179 void
181  // Vehicle Types aren't draw
182 }
183 
184 
185 void
187  // nothing to compute
188 }
189 
190 
191 void
192 GNEVType::drawPartialGL(const GUIVisualizationSettings& /*s*/, const GNELane* /*lane*/, const GNEPathManager::Segment* /*segment*/, const double /*offsetFront*/) const {
193  // vehicleTypes don't use drawPartialGL
194 }
195 
196 
197 void
198 GNEVType::drawPartialGL(const GUIVisualizationSettings& /*s*/, const GNELane* /*fromLane*/, const GNELane* /*toLane*/, const GNEPathManager::Segment* /*segment*/, const double /*offsetFront*/) const {
199  // vehicleTypes don't use drawPartialGL
200 }
201 
202 
203 GNELane*
205  // vehicle types don't use lanes
206  return nullptr;
207 }
208 
209 
210 GNELane*
212  // vehicle types don't use lanes
213  return nullptr;
214 }
215 
216 
217 std::string
219  // obtain default values depending of vehicle class
220  VClassDefaultValues defaultValues(vehicleClass);
221  switch (key) {
222  case SUMO_ATTR_ID:
223  return getID();
225  if (getParentDemandElements().empty()) {
226  return "";
227  } else {
228  return getParentDemandElements().front()->getID();
229  }
230  // CFM Attributes
231  case SUMO_ATTR_ACCEL:
232  case SUMO_ATTR_DECEL:
235  case SUMO_ATTR_SIGMA:
236  case SUMO_ATTR_TAU:
237  // this CFM has default values
239  // JM Attributes
249  // this JM has default values
253  return toString(impatience);
254  } else {
256  }
257  // LCM Attributes
264  case SUMO_ATTR_LCA_PUSHY:
276  /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
278  //
280  case SUMO_ATTR_TMP1:
281  case SUMO_ATTR_TMP2:
282  case SUMO_ATTR_TMP3:
283  case SUMO_ATTR_TMP4:
284  case SUMO_ATTR_TMP5:
307  case SUMO_ATTR_K:
311  return getCFParamString(key, "");
312  // Mutable values
313  case SUMO_ATTR_LENGTH:
315  return toString(length);
316  } else {
317  return toString(defaultValues.length);
318  }
319  case SUMO_ATTR_MINGAP:
321  return toString(minGap);
322  } else {
323  return toString(defaultValues.minGap);
324  }
325  case SUMO_ATTR_MAXSPEED:
327  return toString(maxSpeed);
328  } else {
329  return toString(defaultValues.maxSpeed);
330  }
333  return toString(speedFactor);
334  } else {
335  return toString(defaultValues.speedFactor);
336  }
339  return toString(personCapacity);
340  } else {
341  return toString(defaultValues.personCapacity);
342  }
345  return toString(containerCapacity);
346  } else {
347  return toString(defaultValues.containerCapacity);
348  }
349  case SUMO_ATTR_OSGFILE:
351  return osgFile;
352  } else {
353  return defaultValues.osgFile;
354  }
355  case SUMO_ATTR_COLOR:
357  return toString(color);
358  } else {
359  return "";
360  }
361  case SUMO_ATTR_VCLASS:
363  return toString(vehicleClass);
364  } else {
366  }
370  } else {
371  return PollutantsInterface::getName(defaultValues.emissionClass);
372  }
373  case SUMO_ATTR_GUISHAPE:
375  return getVehicleShapeName(shape);
376  } else {
377  return getVehicleShapeName(defaultValues.shape);
378  }
379  case SUMO_ATTR_WIDTH:
381  return toString(width);
382  } else {
383  return toString(defaultValues.width);
384  }
385  case SUMO_ATTR_HEIGHT:
387  return toString(height);
388  } else {
389  return toString(defaultValues.height);
390  }
391  case SUMO_ATTR_IMGFILE:
393  return imgFile;
394  } else {
396  }
400  } else {
402  }
406  } else {
408  }
412  } else {
414  }
418  } else {
420  }
425  } else {
427  }
428  } else {
430  }
433  return toString(minGapLat);
434  } else {
436  }
439  return toString(maxSpeedLat);
440  } else {
442  }
445  return toString(actionStepLength);
446  } else {
448  }
449  case SUMO_ATTR_PROB:
452  } else {
454  }
457  return toString(carriageLength);
458  } else {
459  return toString(defaultValues.carriageLength);
460  }
463  return toString(locomotiveLength);
464  } else {
465  return toString(defaultValues.locomotiveLength);
466  }
469  return toString(carriageGap);
470  } else {
472  }
473  case GNE_ATTR_SELECTED:
475  case GNE_ATTR_PARAMETERS:
476  return getParametersStr();
477  // other
479  return toString((getID() == DEFAULT_VTYPE_ID) ||
480  (getID() == DEFAULT_PEDTYPE_ID) ||
481  (getID() == DEFAULT_BIKETYPE_ID));
483  if (myDefaultVehicleType) {
485  } else {
486  return toString(false);
487  }
488  default:
489  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
490  }
491 }
492 
493 
494 double
496  // obtain default values depending of vehicle class
497  VClassDefaultValues defaultValues(vehicleClass);
498  switch (key) {
499  case SUMO_ATTR_LENGTH:
501  return length;
502  } else {
503  return defaultValues.length;
504  }
505  case SUMO_ATTR_MINGAP:
507  return minGap;
508  } else {
509  return defaultValues.minGap;
510  }
511  case SUMO_ATTR_WIDTH:
513  return width;
514  } else {
515  return defaultValues.width;
516  }
517  case SUMO_ATTR_HEIGHT:
519  return height;
520  } else {
521  return defaultValues.height;
522  }
523  case SUMO_ATTR_MAXSPEED:
525  return maxSpeed;
526  } else {
527  return defaultValues.maxSpeed;
528  }
529  default:
530  throw InvalidArgument(getTagStr() + " doesn't have a double attribute of type '" + toString(key) + "'");
531  }
532 }
533 
534 
535 Position
537  throw InvalidArgument(getTagStr() + " doesn't have a Position attribute of type '" + toString(key) + "'");
538 }
539 
540 
541 void
542 GNEVType::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) {
543  GNEChange_Attribute* vTypeChangeAttributeForced = nullptr;
544  if (value == getAttribute(key)) {
545  return; //avoid needless changes, later logic relies on the fact that attributes have changed
546  }
547  switch (key) {
548  case SUMO_ATTR_ID:
549  undoList->changeAttribute(new GNEChange_Attribute(this, key, value));
550  break;
552  editVTypeDistribution(value, undoList);
553  break;
554  // CFM Attributes
555  case SUMO_ATTR_ACCEL:
556  case SUMO_ATTR_DECEL:
559  case SUMO_ATTR_SIGMA:
560  case SUMO_ATTR_TAU:
562  case SUMO_ATTR_TMP1:
563  case SUMO_ATTR_TMP2:
564  case SUMO_ATTR_TMP3:
565  case SUMO_ATTR_TMP4:
566  case SUMO_ATTR_TMP5:
589  case SUMO_ATTR_K:
593  // JM Attributes
604  // LCM Attributes
611  case SUMO_ATTR_LCA_PUSHY:
623  /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
624  //
625  case SUMO_ATTR_LENGTH:
626  case SUMO_ATTR_MINGAP:
627  case SUMO_ATTR_MAXSPEED:
629  case SUMO_ATTR_COLOR:
630  case SUMO_ATTR_VCLASS:
632  case SUMO_ATTR_GUISHAPE:
633  case SUMO_ATTR_WIDTH:
634  case SUMO_ATTR_HEIGHT:
635  case SUMO_ATTR_IMGFILE:
646  case SUMO_ATTR_PROB:
647  case SUMO_ATTR_OSGFILE:
651  case GNE_ATTR_SELECTED:
652  case GNE_ATTR_PARAMETERS:
653  // if we change the original value of a default vehicle Type, change also flag "myDefaultVehicleType"
654  if (myDefaultVehicleType) {
655  vTypeChangeAttributeForced = new GNEChange_Attribute(this, GNE_ATTR_DEFAULT_VTYPE_MODIFIED, "true");
656  // force change
657  vTypeChangeAttributeForced->forceChange();
658  undoList->changeAttribute(vTypeChangeAttributeForced);
659  }
660  vTypeChangeAttributeForced = new GNEChange_Attribute(this, key, value);
661  // force change
662  vTypeChangeAttributeForced->forceChange();
663  undoList->changeAttribute(vTypeChangeAttributeForced);
664  break;
666  vTypeChangeAttributeForced = new GNEChange_Attribute(this, GNE_ATTR_DEFAULT_VTYPE_MODIFIED, "true");
667  // force change
668  vTypeChangeAttributeForced->forceChange();
669  undoList->changeAttribute(vTypeChangeAttributeForced);
670  break;
671  default:
672  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
673  }
674 }
675 
676 
677 bool
678 GNEVType::isValid(SumoXMLAttr key, const std::string& value) {
679  // a empty value is always valid except for IDs
680  if ((key != SUMO_ATTR_ID) && value.empty()) {
681  return true;
682  }
683  switch (key) {
684  case SUMO_ATTR_ID:
685  // Vtypes and PTypes shares namespace
687  return true;
688  } else {
689  return false;
690  }
692  if (value.empty()) {
693  return true;
694  } else {
696  }
697  // CFM Attributes
698  case SUMO_ATTR_SIGMA:
699  return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
700  case SUMO_ATTR_ACCEL:
701  case SUMO_ATTR_DECEL:
704  case SUMO_ATTR_TAU:
706  case SUMO_ATTR_TMP1:
707  case SUMO_ATTR_TMP2:
708  case SUMO_ATTR_TMP3:
709  case SUMO_ATTR_TMP4:
710  case SUMO_ATTR_TMP5:
732  case SUMO_ATTR_K:
736  return canParse<double>(value);
738  // rail string
740  // JM Attributes
742  return canParse<double>(value) && (parse<double>(value) >= 0);
744  return canParse<double>(value) && (parse<double>(value) >= -1);
746  return canParse<double>(value) && (parse<double>(value) >= -1);
748  return canParse<double>(value) && (parse<double>(value) >= -1);
750  return canParse<double>(value) && (parse<double>(value) >= 0);
752  return canParse<double>(value) && (parse<double>(value) >= 0);
754  return canParse<double>(value) && (parse<double>(value) >= 0);
756  return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
758  return canParse<double>(value) && (parse<double>(value) >= 0);
760  return canParse<double>(value) && (parse<double>(value) >= 0);
761  // LCM Attributes
768  case SUMO_ATTR_LCA_PUSHY:
769  return canParse<double>(value);
773  case SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE: // 0 mean disabled
774  case SUMO_ATTR_LCA_TIME_TO_IMPATIENCE: // 0 mean disabled
775  case SUMO_ATTR_LCA_OVERTAKE_RIGHT: // 0 mean disabled
776  return canParse<double>(value) && (parse<double>(value) >= 0);
782  return canParse<double>(value) && (parse<double>(value) > 0);
783  /* case SUMO_ATTR_LCA_EXPERIMENTAL1:
784  return true;
785  */
786  //
787  case SUMO_ATTR_LENGTH:
788  return canParse<double>(value) && (parse<double>(value) > 0);
789  case SUMO_ATTR_MINGAP:
790  return canParse<double>(value) && (parse<double>(value) >= 0);
791  case SUMO_ATTR_MAXSPEED:
792  return canParse<double>(value) && (parse<double>(value) >= 0);
795  case SUMO_ATTR_COLOR:
796  if (value.empty()) {
797  return true;
798  } else {
799  return canParse<RGBColor>(value);
800  }
801  case SUMO_ATTR_VCLASS:
802  return canParseVehicleClasses(value);
804  // check if given value correspond to a string of PollutantsInterface::getAllClassesStr()
805  for (const auto& eClass : PollutantsInterface::getAllClassesStr()) {
806  if (value == eClass) {
807  return true;
808  }
809  }
810  return false;
811  case SUMO_ATTR_GUISHAPE:
812  if (value == "all") {
813  return false;
814  } else {
815  return canParseVehicleShape(value);
816  }
817  case SUMO_ATTR_WIDTH:
818  return canParse<double>(value);
819  case SUMO_ATTR_HEIGHT:
820  return canParse<double>(value);
821  case SUMO_ATTR_IMGFILE:
828  return canParse<int>(value);
830  return canParse<int>(value);
832  return canParse<double>(value);
834  return canParse<double>(value);
838  return canParse<double>(value);
840  return canParse<double>(value);
842  return canParse<double>(value) && (parse<double>(value) >= 0);
843  case SUMO_ATTR_PROB:
844  return canParse<double>(value) && (parse<double>(value) >= 0);
845  case SUMO_ATTR_OSGFILE:
848  return canParse<double>(value) && (parse<double>(value) >= -1);
850  return canParse<double>(value) && (parse<double>(value) >= -1);
852  return canParse<double>(value) && (parse<double>(value) >= 0);
853  case GNE_ATTR_SELECTED:
854  return canParse<bool>(value);
855  case GNE_ATTR_PARAMETERS:
856  return Parameterised::areParametersValid(value);
858  if (myDefaultVehicleType) {
859  return canParse<bool>(value);
860  } else {
861  return false;
862  }
863  default:
864  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
865  }
866 }
867 
868 
869 void
871  // nothing to enable
872 }
873 
874 
875 void
877  // nothing to disable
878 }
879 
880 
881 bool
883  switch (key) {
884  case SUMO_ATTR_ID:
885  if ((id == DEFAULT_VTYPE_ID) || (id == DEFAULT_PEDTYPE_ID) || (id == DEFAULT_BIKETYPE_ID)) {
886  return false;
887  } else {
888  return true;
889  }
890  case SUMO_ATTR_LENGTH:
892  case SUMO_ATTR_MINGAP:
894  case SUMO_ATTR_MAXSPEED:
902  case SUMO_ATTR_OSGFILE:
910  default:
911  return true;
912  }
913 }
914 
915 
916 std::string
918  return getTagStr();
919 }
920 
921 
922 std::string
924  return getTagStr() + ": " + getAttribute(SUMO_ATTR_ID) ;
925 }
926 
927 
928 const std::map<std::string, std::string>&
930  return getParametersMap();
931 }
932 
933 
934 void
935 GNEVType::overwriteVType(GNEDemandElement* vType, const SUMOVTypeParameter newVTypeParameter, GNEUndoList* undoList) {
936  // open undo list and overwritte all values of default VType
937  undoList->begin(vType->getTagProperty().getGUIIcon(), "update default " + vType->getTagStr() + " '" + DEFAULT_VTYPE_ID + "'");
938  // CFM values
939  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_ACCEL, "").empty()) {
940  vType->setAttribute(SUMO_ATTR_ACCEL, toString(newVTypeParameter.getCFParam(SUMO_ATTR_ACCEL, 0)), undoList);
941  }
942  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_DECEL, "").empty()) {
943  vType->setAttribute(SUMO_ATTR_DECEL, toString(newVTypeParameter.getCFParam(SUMO_ATTR_DECEL, 0)), undoList);
944  }
945  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_APPARENTDECEL, "").empty()) {
946  vType->setAttribute(SUMO_ATTR_APPARENTDECEL, toString(newVTypeParameter.getCFParam(SUMO_ATTR_APPARENTDECEL, 0)), undoList);
947  }
948  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_EMERGENCYDECEL, "").empty()) {
949  vType->setAttribute(SUMO_ATTR_EMERGENCYDECEL, toString(newVTypeParameter.getCFParam(SUMO_ATTR_EMERGENCYDECEL, 0)), undoList);
950  }
951  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_SIGMA, "").empty()) {
952  vType->setAttribute(SUMO_ATTR_SIGMA, toString(newVTypeParameter.getCFParam(SUMO_ATTR_SIGMA, 0)), undoList);
953  }
954  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TAU, "").empty()) {
955  vType->setAttribute(SUMO_ATTR_TAU, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TAU, 0)), undoList);
956  }
957  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_COLLISION_MINGAP_FACTOR, "").empty()) {
959  }
960  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP1, "").empty()) {
961  vType->setAttribute(SUMO_ATTR_TMP1, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP1, 0)), undoList);
962  }
963  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP2, "").empty()) {
964  vType->setAttribute(SUMO_ATTR_TMP2, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP2, 0)), undoList);
965  }
966  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP3, "").empty()) {
967  vType->setAttribute(SUMO_ATTR_TMP3, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP3, 0)), undoList);
968  }
969  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP4, "").empty()) {
970  vType->setAttribute(SUMO_ATTR_TMP4, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP4, 0)), undoList);
971  }
972  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP5, "").empty()) {
973  vType->setAttribute(SUMO_ATTR_TMP5, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP5, 0)), undoList);
974  }
975  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS, "").empty()) {
977  }
978  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW, "").empty()) {
980  }
981  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD, "").empty()) {
983  }
984  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE, "").empty()) {
986  }
987  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_REACTION, "").empty()) {
989  }
990  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE, "").empty()) {
992  }
993  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_C_COOLNESS, "").empty()) {
995  }
996  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_SIG_LEADER, "").empty()) {
998  }
999  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_SIG_GAP, "").empty()) {
1000  vType->setAttribute(SUMO_ATTR_CF_EIDM_SIG_GAP, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_EIDM_SIG_GAP, 0)), undoList);
1001  }
1002  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_SIG_ERROR, "").empty()) {
1004  }
1005  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_JERK_MAX, "").empty()) {
1006  vType->setAttribute(SUMO_ATTR_CF_EIDM_JERK_MAX, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_EIDM_JERK_MAX, 0)), undoList);
1007  }
1008  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_EPSILON_ACC, "").empty()) {
1010  }
1011  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_ACC_MAX, "").empty()) {
1013  }
1014  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_M_FLATNESS, "").empty()) {
1016  }
1017  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_M_BEGIN, "").empty()) {
1018  vType->setAttribute(SUMO_ATTR_CF_EIDM_M_BEGIN, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_EIDM_M_BEGIN, 0)), undoList);
1019  }
1020  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_PWAGNER2009_TAULAST, "").empty()) {
1022  }
1023  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_PWAGNER2009_APPROB, "").empty()) {
1025  }
1026  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_IDMM_ADAPT_FACTOR, "").empty()) {
1028  }
1029  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_IDMM_ADAPT_TIME, "").empty()) {
1031  }
1032  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_WIEDEMANN_SECURITY, "").empty()) {
1034  }
1035  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_WIEDEMANN_ESTIMATION, "").empty()) {
1037  }
1038  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TRAIN_TYPE, "").empty()) {
1039  vType->setAttribute(SUMO_ATTR_TRAIN_TYPE, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TRAIN_TYPE, 0)), undoList);
1040  }
1041  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_K, "").empty()) {
1042  vType->setAttribute(SUMO_ATTR_K, toString(newVTypeParameter.getCFParam(SUMO_ATTR_K, 0)), undoList);
1043  }
1044  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_KERNER_PHI, "").empty()) {
1045  vType->setAttribute(SUMO_ATTR_CF_KERNER_PHI, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_KERNER_PHI, 0)), undoList);
1046  }
1047  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_IDM_DELTA, "").empty()) {
1048  vType->setAttribute(SUMO_ATTR_CF_IDM_DELTA, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_IDM_DELTA, 0)), undoList);
1049  }
1050  if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_IDM_STEPPING, "").empty()) {
1051  vType->setAttribute(SUMO_ATTR_CF_IDM_STEPPING, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_IDM_STEPPING, 0)), undoList);
1052  }
1053  // JM values
1054  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_CROSSING_GAP, "").empty()) {
1055  vType->setAttribute(SUMO_ATTR_JM_CROSSING_GAP, toString(newVTypeParameter.getCFParam(SUMO_ATTR_JM_CROSSING_GAP, 0)), undoList);
1056  }
1057  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME, "").empty()) {
1059  }
1060  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME, "").empty()) {
1062  }
1063  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME, "").empty()) {
1065  }
1066  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_DRIVE_RED_SPEED, "").empty()) {
1068  }
1069  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_IGNORE_FOE_PROB, "").empty()) {
1071  }
1072  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_IGNORE_FOE_SPEED, "").empty()) {
1074  }
1075  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_SIGMA_MINOR, "").empty()) {
1076  vType->setAttribute(SUMO_ATTR_JM_SIGMA_MINOR, toString(newVTypeParameter.getCFParam(SUMO_ATTR_JM_SIGMA_MINOR, 0)), undoList);
1077  }
1078  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_TIMEGAP_MINOR, "").empty()) {
1079  vType->setAttribute(SUMO_ATTR_JM_TIMEGAP_MINOR, toString(newVTypeParameter.getCFParam(SUMO_ATTR_JM_TIMEGAP_MINOR, 0)), undoList);
1080  }
1081  if (newVTypeParameter.wasSet(VTYPEPARS_IMPATIENCE_SET)) {
1082  vType->setAttribute(SUMO_ATTR_IMPATIENCE, toString(newVTypeParameter.impatience), undoList);
1083  }
1084  // LCM values
1085  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_STRATEGIC_PARAM, "").empty()) {
1087  }
1088  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_COOPERATIVE_PARAM, "").empty()) {
1090  }
1091  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_SPEEDGAIN_PARAM, "").empty()) {
1093  }
1094  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_KEEPRIGHT_PARAM, "").empty()) {
1096  }
1097  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_SUBLANE_PARAM, "").empty()) {
1099  }
1100  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_OPPOSITE_PARAM, "").empty()) {
1102  }
1103  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_PUSHY, "").empty()) {
1104  vType->setAttribute(SUMO_ATTR_LCA_PUSHY, toString(newVTypeParameter.getCFParam(SUMO_ATTR_LCA_PUSHY, 0)), undoList);
1105  }
1106  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_PUSHYGAP, "").empty()) {
1107  vType->setAttribute(SUMO_ATTR_LCA_PUSHYGAP, toString(newVTypeParameter.getCFParam(SUMO_ATTR_LCA_PUSHYGAP, 0)), undoList);
1108  }
1109  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_ASSERTIVE, "").empty()) {
1110  vType->setAttribute(SUMO_ATTR_LCA_ASSERTIVE, toString(newVTypeParameter.getCFParam(SUMO_ATTR_LCA_ASSERTIVE, 0)), undoList);
1111  }
1112  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_IMPATIENCE, "").empty()) {
1113  vType->setAttribute(SUMO_ATTR_LCA_IMPATIENCE, toString(newVTypeParameter.getCFParam(SUMO_ATTR_LCA_IMPATIENCE, 0)), undoList);
1114  }
1115  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_TIME_TO_IMPATIENCE, "").empty()) {
1117  }
1118  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_ACCEL_LAT, "").empty()) {
1119  vType->setAttribute(SUMO_ATTR_LCA_ACCEL_LAT, toString(newVTypeParameter.getCFParam(SUMO_ATTR_LCA_ACCEL_LAT, 0)), undoList);
1120  }
1121  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_LOOKAHEADLEFT, "").empty()) {
1123  }
1124  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_SPEEDGAINRIGHT, "").empty()) {
1126  }
1127  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_MAXSPEEDLATSTANDING, "").empty()) {
1129  }
1130  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_MAXSPEEDLATFACTOR, "").empty()) {
1132  }
1133  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE, "").empty()) {
1135  }
1136  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_OVERTAKE_RIGHT, "").empty()) {
1138  }
1139  if (!newVTypeParameter.getJMParamString(SUMO_ATTR_LCA_EXPERIMENTAL1, "").empty()) {
1141  }
1142  //
1143  if (newVTypeParameter.wasSet(VTYPEPARS_LENGTH_SET)) {
1144  vType->setAttribute(SUMO_ATTR_LENGTH, toString(newVTypeParameter.length), undoList);
1145  }
1146  if (newVTypeParameter.wasSet(VTYPEPARS_MINGAP_SET)) {
1147  vType->setAttribute(SUMO_ATTR_MINGAP, toString(newVTypeParameter.minGap), undoList);
1148  }
1149  if (newVTypeParameter.wasSet(VTYPEPARS_MAXSPEED_SET)) {
1150  vType->setAttribute(SUMO_ATTR_MAXSPEED, toString(newVTypeParameter.maxSpeed), undoList);
1151  }
1152  if (newVTypeParameter.wasSet(VTYPEPARS_SPEEDFACTOR_SET)) {
1153  vType->setAttribute(SUMO_ATTR_SPEEDFACTOR, toString(newVTypeParameter.speedFactor), undoList);
1154  }
1155  if (newVTypeParameter.wasSet(VTYPEPARS_COLOR_SET)) {
1156  vType->setAttribute(SUMO_ATTR_COLOR, toString(newVTypeParameter.color), undoList);
1157  }
1158  if (newVTypeParameter.wasSet(VTYPEPARS_EMISSIONCLASS_SET)) {
1160  }
1161  if (newVTypeParameter.wasSet(VTYPEPARS_SHAPE_SET)) {
1162  vType->setAttribute(SUMO_ATTR_GUISHAPE, getVehicleShapeName(newVTypeParameter.shape), undoList);
1163  }
1164  if (newVTypeParameter.wasSet(VTYPEPARS_WIDTH_SET)) {
1165  vType->setAttribute(SUMO_ATTR_WIDTH, toString(newVTypeParameter.width), undoList);
1166  }
1167  if (newVTypeParameter.wasSet(VTYPEPARS_HEIGHT_SET)) {
1168  vType->setAttribute(SUMO_ATTR_HEIGHT, toString(newVTypeParameter.height), undoList);
1169  }
1170  if (newVTypeParameter.wasSet(VTYPEPARS_IMGFILE_SET)) {
1171  vType->setAttribute(SUMO_ATTR_IMGFILE, toString(newVTypeParameter.imgFile), undoList);
1172  }
1173  if (newVTypeParameter.wasSet(VTYPEPARS_LANE_CHANGE_MODEL_SET)) {
1174  vType->setAttribute(SUMO_ATTR_LANE_CHANGE_MODEL, SUMOXMLDefinitions::LaneChangeModels.getString(newVTypeParameter.lcModel), undoList);
1175  }
1176  if (newVTypeParameter.wasSet(VTYPEPARS_CAR_FOLLOW_MODEL)) {
1177  vType->setAttribute(SUMO_ATTR_CAR_FOLLOW_MODEL, SUMOXMLDefinitions::CarFollowModels.getString(newVTypeParameter.cfModel), undoList);
1178  }
1179  if (newVTypeParameter.wasSet(VTYPEPARS_PERSON_CAPACITY)) {
1180  vType->setAttribute(SUMO_ATTR_PERSON_CAPACITY, toString(newVTypeParameter.personCapacity), undoList);
1181  }
1182  if (newVTypeParameter.wasSet(VTYPEPARS_CONTAINER_CAPACITY)) {
1183  vType->setAttribute(SUMO_ATTR_CONTAINER_CAPACITY, toString(newVTypeParameter.containerCapacity), undoList);
1184  }
1185  if (newVTypeParameter.wasSet(VTYPEPARS_BOARDING_DURATION)) {
1186  vType->setAttribute(SUMO_ATTR_BOARDING_DURATION, toString(newVTypeParameter.boardingDuration), undoList);
1187  }
1188  if (newVTypeParameter.wasSet(VTYPEPARS_LOADING_DURATION)) {
1189  vType->setAttribute(SUMO_ATTR_LOADING_DURATION, toString(newVTypeParameter.loadingDuration), undoList);
1190  }
1191  if (newVTypeParameter.wasSet(VTYPEPARS_LATALIGNMENT_SET)) {
1192  if (newVTypeParameter.latAlignmentProcedure != LatAlignmentDefinition::GIVEN) {
1193  vType->setAttribute(SUMO_ATTR_LATALIGNMENT, toString(newVTypeParameter.latAlignmentProcedure), undoList);
1194  } else {
1195  vType->setAttribute(SUMO_ATTR_LATALIGNMENT, toString(newVTypeParameter.latAlignmentOffset), undoList);
1196  }
1197  }
1198  if (newVTypeParameter.wasSet(VTYPEPARS_MINGAP_LAT_SET)) {
1199  vType->setAttribute(SUMO_ATTR_MINGAP_LAT, toString(newVTypeParameter.minGapLat), undoList);
1200  }
1201  if (newVTypeParameter.wasSet(VTYPEPARS_MAXSPEED_LAT_SET)) {
1202  vType->setAttribute(SUMO_ATTR_MAXSPEED_LAT, toString(newVTypeParameter.maxSpeedLat), undoList);
1203  }
1204  if (newVTypeParameter.wasSet(VTYPEPARS_ACTIONSTEPLENGTH_SET)) {
1205  vType->setAttribute(SUMO_ATTR_ACTIONSTEPLENGTH, toString(newVTypeParameter.actionStepLength), undoList);
1206  }
1207  if (newVTypeParameter.wasSet(VTYPEPARS_PROBABILITY_SET)) {
1208  vType->setAttribute(SUMO_ATTR_PROB, toString(newVTypeParameter.defaultProbability), undoList);
1209  }
1210  if (newVTypeParameter.wasSet(VTYPEPARS_OSGFILE_SET)) {
1211  vType->setAttribute(SUMO_ATTR_OSGFILE, toString(newVTypeParameter.osgFile), undoList);
1212  }
1213  if (newVTypeParameter.knowsParameter(toString(SUMO_ATTR_CARRIAGE_LENGTH))) {
1214  vType->setAttribute(SUMO_ATTR_CARRIAGE_LENGTH, newVTypeParameter.getParameter(toString(SUMO_ATTR_CARRIAGE_LENGTH), ""), undoList);
1215  }
1216  if (newVTypeParameter.knowsParameter(toString(SUMO_ATTR_LOCOMOTIVE_LENGTH))) {
1218  }
1219  if (newVTypeParameter.knowsParameter(toString(SUMO_ATTR_CARRIAGE_GAP))) {
1220  vType->setAttribute(SUMO_ATTR_CARRIAGE_GAP, newVTypeParameter.getParameter(toString(SUMO_ATTR_CARRIAGE_GAP), ""), undoList);
1221  }
1222  // parse parameters
1223  std::string parametersStr;
1224  // Generate an string using the following structure: "key1=value1|key2=value2|...
1225  for (const auto& parameter : newVTypeParameter.getParametersMap()) {
1226  parametersStr += parameter.first + "=" + parameter.second + "|";
1227  }
1228  // remove the last "|"
1229  if (!parametersStr.empty()) {
1230  parametersStr.pop_back();
1231  }
1232  if (parametersStr != vType->getAttribute(GNE_ATTR_PARAMETERS)) {
1233  vType->setAttribute(GNE_ATTR_PARAMETERS, parametersStr, undoList);
1234  }
1235  if (parametersStr != vType->getAttribute(GNE_ATTR_VTYPE_DISTRIBUTION)) {
1236  vType->setAttribute(GNE_ATTR_VTYPE_DISTRIBUTION, parametersStr, undoList);
1237  }
1238  // close undo list
1239  undoList->end();
1240 }
1241 
1242 // ===========================================================================
1243 // protected
1244 // ===========================================================================
1245 
1246 void
1247 GNEVType::editVTypeDistribution(const std::string& vTypeDistributionID, GNEUndoList* undoList) {
1248  if (vTypeDistributionID.empty()) {
1249  // first check if previosly this vType has a vTypeDistribution
1250  if (getParentDemandElements().size() > 0) {
1251  // get parent vTypeDistribution
1252  GNEDemandElement* vTypeDistribution = getParentDemandElements().front();
1253  // check if this is the last vType of the vTypeDistribution
1254  if (vTypeDistribution->getChildDemandElements().size() == 1) {
1255  // ask if remove vTypeDistribution
1256  if (askRemoveVTypeDistribution(vTypeDistribution->getID())) {
1258  // clear attribute
1260  // remove vType Distribution
1261  undoList->add(new GNEChange_DemandElement(vTypeDistribution, false), true);
1262  undoList->end();
1263  }
1264  } else {
1265  // clear attribute
1267  }
1268  }
1269  } else {
1270  // check if vTypeDistribution exist
1271  const auto vTypeDistribution = myNet->getAttributeCarriers()->retrieveDemandElement(SUMO_TAG_VTYPE_DISTRIBUTION, vTypeDistributionID, false);
1272  // get current vTypeDistribution parent
1273  const auto vTypeDistributionParent = (getParentDemandElements().size() > 0) ? getParentDemandElements().front() : nullptr;
1274  if (vTypeDistribution) {
1275  // add in vTypeDistribution
1276  undoList->changeAttribute(new GNEChange_Attribute(this, GNE_ATTR_VTYPE_DISTRIBUTION, vTypeDistributionID));
1277  } else if (vTypeDistributionParent && (vTypeDistributionParent->getChildDemandElements().size() == 1)) {
1278  // ask if remove vTypeDistribution
1279  if (askRemoveVTypeDistribution(vTypeDistributionParent->getID())) {
1281  // clear attribute
1283  // remove old vTypeDistribution
1284  undoList->add(new GNEChange_DemandElement(vTypeDistributionParent, false), true);
1285  // create newTypeDistribution
1286  undoList->add(new GNEChange_DemandElement(new GNEVTypeDistribution(myNet, vTypeDistributionID), true), true);
1287  // set new vTypeDistribution
1288  undoList->changeAttribute(new GNEChange_Attribute(this, GNE_ATTR_VTYPE_DISTRIBUTION, vTypeDistributionID));
1289  undoList->end();
1290  }
1291  } else {
1293  // create newTypeDistribution
1294  undoList->add(new GNEChange_DemandElement(new GNEVTypeDistribution(myNet, vTypeDistributionID), true), true);
1295  // set new vTypeDistribution
1296  undoList->changeAttribute(new GNEChange_Attribute(this, GNE_ATTR_VTYPE_DISTRIBUTION, vTypeDistributionID));
1297  undoList->end();
1298  }
1299  }
1300 }
1301 
1302 
1303 bool
1304 GNEVType::askAddVTypeDistribution(const std::string& vTypeDistribution) const {
1305  // show warning in gui testing debug mode
1306  WRITE_DEBUG("Opening FXMessageBox 'add vTypeDistribution'");
1307  // Ask confirmation to user
1308  const FXuint answer = FXMessageBox::question(myNet->getViewNet()->getApp(), MBOX_YES_NO,
1309  ("Add " + toString(SUMO_TAG_VTYPE_DISTRIBUTION) + "s").c_str(), "%s",
1310  (toString(SUMO_TAG_VTYPE_DISTRIBUTION) + " '" + vTypeDistribution + "' doesn't exist. Create?").c_str());
1311  if (answer == 1) { // 1:yes, 2:no, 4:esc
1312  WRITE_DEBUG("Closed FXMessageBox 'add vTypeDistribution' with 'yes'");
1313  return true;
1314  } else {
1315  // write warning if netedit is running in testing mode
1316  if (answer == 2) {
1317  WRITE_DEBUG("Closed FXMessageBox 'add vTypeDistribution' with 'No'");
1318  return false;
1319  } else {
1320  WRITE_DEBUG("Closed FXMessageBox 'add vTypeDistribution' with 'ESC'");
1321  return false;
1322  }
1323  }
1324 }
1325 
1326 
1327 bool
1328 GNEVType::askRemoveVTypeDistribution(const std::string& vTypeDistribution) const {
1329  // show warning in gui testing debug mode
1330  WRITE_DEBUG("Opening FXMessageBox 'remove vTypeDistribution'");
1331  // Ask confirmation to user
1332  const FXuint answer = FXMessageBox::question(myNet->getViewNet()->getApp(), MBOX_YES_NO,
1333  ("Remove " + toString(SUMO_TAG_VTYPE_DISTRIBUTION)).c_str(), "%s",
1334  ("Changing attribute will remove " + toString(SUMO_TAG_VTYPE_DISTRIBUTION) + " '" + vTypeDistribution + "'. Continue?").c_str());
1335  if (answer == 1) { // 1:yes, 2:no, 4:esc
1336  WRITE_DEBUG("Closed FXMessageBox 'remove vTypeDistribution' with 'yes'");
1337  return true;
1338  } else {
1339  // write warning if netedit is running in testing mode
1340  if (answer == 2) {
1341  WRITE_DEBUG("Closed FXMessageBox 'remove vTypeDistribution' with 'No'");
1342  return false;
1343  } else {
1344  WRITE_DEBUG("Closed FXMessageBox 'remove vTypeDistribution' with 'ESC'");
1345  return false;
1346  }
1347  }
1348 }
1349 
1350 // ===========================================================================
1351 // private
1352 // ===========================================================================
1353 
1354 void
1355 GNEVType::setAttribute(SumoXMLAttr key, const std::string& value) {
1356  // obtain default values depending of vehicle class
1357  VClassDefaultValues defaultValues(vehicleClass);
1358  switch (key) {
1359  case SUMO_ATTR_ID:
1360  // update microsimID
1361  setMicrosimID(value);
1362  // manually change VType parameters ID
1363  id = value;
1364  break;
1367  break;
1368  // CFM Attributes
1369  case SUMO_ATTR_ACCEL:
1370  case SUMO_ATTR_DECEL:
1373  case SUMO_ATTR_SIGMA:
1374  case SUMO_ATTR_TAU:
1376  case SUMO_ATTR_TMP1:
1377  case SUMO_ATTR_TMP2:
1378  case SUMO_ATTR_TMP3:
1379  case SUMO_ATTR_TMP4:
1380  case SUMO_ATTR_TMP5:
1402  case SUMO_ATTR_TRAIN_TYPE:
1403  case SUMO_ATTR_K:
1407  // empty values means that value isn't set
1408  if (value.empty()) {
1409  const auto it = cfParameter.find(key);
1410  if (it != cfParameter.end()) {
1411  cfParameter.erase(it);
1412  }
1413  } else {
1414  cfParameter[key] = value;
1415  }
1416  break;
1417  // JM Attributes
1427  // empty values means that value isn't set
1428  if (value.empty()) {
1429  const auto it = jmParameter.find(key);
1430  if (it != jmParameter.end()) {
1431  jmParameter.erase(it);
1432  }
1433  } else {
1434  jmParameter[key] = value;
1435  }
1436  break;
1437  case SUMO_ATTR_IMPATIENCE:
1438  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1439  impatience = parse<double>(value);
1440  // mark parameter as set
1442  } else {
1443  // set default value
1444  impatience = parse<double>(myTagProperty.getDefaultValue(key));
1445  // unset parameter
1447  }
1448  break;
1449  // LCM Attributes
1456  case SUMO_ATTR_LCA_PUSHY:
1465 
1466  /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
1467  // empty values means that value isn't set
1468  if (value.empty()) {
1469  const auto it = lcParameter.find(key);
1470  if (it != lcParameter.end()) {
1471  lcParameter.erase(it);
1472  }
1473  } else {
1474  lcParameter[key] = value;
1475  }
1476  break;
1480  // empty or null values means that value isn't set
1481  if (value.empty() || (canParse<double>(value) && (parse<double>(value) == 0))) {
1482  const auto it = lcParameter.find(key);
1483  if (it != lcParameter.end()) {
1484  lcParameter.erase(it);
1485  }
1486  } else {
1487  lcParameter[key] = value;
1488  }
1489  break;
1490  //
1491  case SUMO_ATTR_LENGTH:
1492  if (!value.empty() && (value != toString(defaultValues.length))) {
1493  length = parse<double>(value);
1494  // mark parameter as set
1496  } else {
1497  // set default value
1498  length = defaultValues.length;
1499  // unset parameter
1501  }
1502  break;
1503  case SUMO_ATTR_MINGAP:
1504  if (!value.empty() && (value != toString(defaultValues.minGap))) {
1505  minGap = parse<double>(value);
1506  // mark parameter as set
1508  } else {
1509  // set default value
1510  minGap = defaultValues.minGap;
1511  // unset parameter
1513  }
1514  break;
1515  case SUMO_ATTR_MAXSPEED:
1516  if (!value.empty() && (value != toString(defaultValues.maxSpeed))) {
1517  maxSpeed = parse<double>(value);
1518  // mark parameter as set
1520  } else {
1521  // set default value
1522  maxSpeed = defaultValues.maxSpeed;
1523  // unset parameter
1525  }
1526  break;
1527  case SUMO_ATTR_SPEEDFACTOR:
1528  if (!value.empty() && (value != toString(defaultValues.speedFactor))) {
1529  speedFactor.parse(value, false);
1530  // mark parameter as set
1532  } else {
1533  // set default value
1534  speedFactor.parse(toString(defaultValues.speedFactor), false);
1535  // unset parameter
1537  }
1538  break;
1539  case SUMO_ATTR_COLOR:
1540  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1541  color = parse<RGBColor>(value);
1542  // mark parameter as set
1544  } else {
1545  // unset parameter
1547  }
1548  break;
1549  case SUMO_ATTR_VCLASS:
1550  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1552  // mark parameter as set
1554  } else {
1555  // set default value
1557  // unset parameter
1559  }
1560  // update default values
1561  updateDefaultVClassAttributes(defaultValues);
1562  break;
1564  if (!value.empty() && (value != toString(defaultValues.emissionClass))) {
1566  // mark parameter as set
1568  } else {
1569  // set default value
1570  emissionClass = defaultValues.emissionClass;
1571  // unset parameter
1573  }
1574  break;
1575  case SUMO_ATTR_GUISHAPE:
1576  if (!value.empty() && (value != SumoVehicleShapeStrings.getString(defaultValues.shape))) {
1577  shape = getVehicleShapeID(value);
1578  // mark parameter as set
1580  } else {
1581  // set default value
1582  shape = defaultValues.shape;
1583  // unset parameter
1585  }
1586  break;
1587  case SUMO_ATTR_WIDTH:
1588  if (!value.empty() && (value != toString(defaultValues.width))) {
1589  width = parse<double>(value);
1590  // mark parameter as set
1592  } else {
1593  // set default value
1594  width = defaultValues.width;
1595  // unset parameter
1597  }
1598  break;
1599  case SUMO_ATTR_HEIGHT:
1600  if (!value.empty() && (value != toString(defaultValues.height))) {
1601  height = parse<double>(value);
1602  // mark parameter as set
1604  } else {
1605  // set default value
1606  height = defaultValues.height;
1607  // unset parameter
1609  }
1610  break;
1611  case SUMO_ATTR_IMGFILE:
1612  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1613  imgFile = value;
1614  // mark parameter as set
1616  } else {
1617  // set default value
1619  // unset parameter
1621  }
1622  break;
1624  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1626  // mark parameter as set
1628  } else {
1629  // set default value
1631  // unset parameter
1633  }
1634  break;
1636  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1638  // mark parameter as set
1640  } else {
1641  // set default value
1643  // unset parameter
1645  }
1646  break;
1648  if (!value.empty() && (value != toString(defaultValues.personCapacity))) {
1649  personCapacity = parse<int>(value);
1650  // mark parameter as set
1652  } else {
1653  // set default value
1654  personCapacity = defaultValues.personCapacity;
1655  // unset parameter
1657  }
1658  break;
1660  if (!value.empty() && (value != toString(defaultValues.containerCapacity))) {
1661  containerCapacity = parse<int>(value);
1662  // mark parameter as set
1664  } else {
1665  // set default value
1666  containerCapacity = defaultValues.containerCapacity;
1667  // unset parameter
1669  }
1670  break;
1672  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1673  boardingDuration = string2time(value);
1674  // mark parameter as set
1676  } else {
1677  // set default value
1679  // unset parameter
1681  }
1682  break;
1684  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1685  loadingDuration = string2time(value);
1686  // mark parameter as set
1688  } else {
1689  // set default value
1691  // unset parameter
1693  }
1694  break;
1696  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1698  // mark parameter as set
1700  } else {
1701  // set default value
1703  // unset parameter
1705  }
1706  break;
1707  case SUMO_ATTR_MINGAP_LAT:
1708  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1709  minGapLat = parse<double>(value);
1710  // mark parameter as set
1712  } else {
1713  // set default value
1714  minGapLat = parse<double>(myTagProperty.getDefaultValue(key));
1715  // unset parameter
1717  }
1718  break;
1720  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1721  maxSpeedLat = parse<double>(value);
1722  // mark parameter as set
1724  } else {
1725  // set default value
1726  maxSpeedLat = parse<double>(myTagProperty.getDefaultValue(key));
1727  // unset parameter
1729  }
1730  break;
1732  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1733  actionStepLength = string2time(value);
1734  // mark parameter as set
1736  } else {
1737  // set default value
1739  // unset parameter
1741  }
1742  break;
1743  case SUMO_ATTR_PROB:
1744  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1745  defaultProbability = parse<double>(value);
1746  // mark parameter as set
1748  } else {
1749  // set default value
1750  defaultProbability = parse<double>(myTagProperty.getDefaultValue(key));
1751  // unset parameter
1753  }
1754  break;
1755  case SUMO_ATTR_OSGFILE:
1756  if (!value.empty() && (value != defaultValues.osgFile)) {
1757  osgFile = value;
1758  // mark parameter as set
1760  } else {
1761  // set default value
1762  osgFile = defaultValues.osgFile;
1763  // unset parameter
1765  }
1766  break;
1768  if (!value.empty() && (value != toString(defaultValues.carriageLength))) {
1769  carriageLength = parse<double>(value);
1770  // mark parameter as set
1772  // set parameter in SUMOVTypeParameter (needed for writting in XML)
1774  } else {
1775  // set default value
1776  carriageLength = defaultValues.carriageLength;
1777  // unset parameter
1779  // remove from params (needed for writting in XML)
1781  }
1782  break;
1784  if (!value.empty() && (value != toString(defaultValues.containerCapacity))) {
1785  locomotiveLength = parse<double>(value);
1786  // mark parameter as set
1788  // set parameter in SUMOVTypeParameter (needed for writting in XML)
1790  } else {
1791  // set default value
1792  locomotiveLength = defaultValues.locomotiveLength;
1793  // unset parameter
1795  // remove from params (needed for writting in XML)
1797  }
1798  break;
1800  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1801  carriageGap = parse<double>(value);
1802  // mark parameter as set
1804  // set parameter in SUMOVTypeParameter (needed for writting in XML)
1806  } else {
1807  // set default value
1808  carriageGap = parse<double>(myTagProperty.getDefaultValue(key));
1809  // unset parameter
1811  // remove from params (needed for writting in XML)
1813  }
1814  break;
1815  case GNE_ATTR_SELECTED:
1816  if (parse<bool>(value)) {
1818  } else {
1820  }
1821  break;
1822  case GNE_ATTR_PARAMETERS:
1823  setParametersStr(value);
1824  break;
1826  myDefaultVehicleTypeModified = parse<bool>(value);
1827  break;
1828  default:
1829  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
1830  }
1831  // check if geometry must be marked as deprecated
1833  updateGeometry();
1834  }
1835 }
1836 
1837 
1838 void
1839 GNEVType::toogleAttribute(SumoXMLAttr /*key*/, const bool /*value*/, const int /*previousParameters*/) {
1840  // nothing to toogle
1841 }
1842 
1843 
1844 void
1845 GNEVType::setMoveShape(const GNEMoveResult& /*moveResult*/) {
1846  // vehicleTypes cannot be moved
1847 }
1848 
1849 
1850 void
1851 GNEVType::commitMoveShape(const GNEMoveResult& /*moveResult*/, GNEUndoList* /*undoList*/) {
1852  // vehicleTypes cannot be moved
1853 }
1854 
1855 
1856 void
1858  if (!wasSet(VTYPEPARS_LENGTH_SET)) {
1859  length = defaultValues.length;
1860  }
1861  if (!wasSet(VTYPEPARS_MINGAP_SET)) {
1862  minGap = defaultValues.minGap;
1863  }
1865  maxSpeed = defaultValues.maxSpeed;
1866  }
1867  if (!wasSet(VTYPEPARS_WIDTH_SET)) {
1868  width = defaultValues.width;
1869  }
1870  if (!wasSet(VTYPEPARS_HEIGHT_SET)) {
1871  height = defaultValues.height;
1872  }
1873  if (!wasSet(VTYPEPARS_SHAPE_SET)) {
1874  shape = defaultValues.shape;
1875  }
1877  emissionClass = defaultValues.emissionClass;
1878  }
1880  speedFactor = defaultValues.speedFactor;
1881  }
1883  personCapacity = defaultValues.personCapacity;
1884  }
1886  containerCapacity = defaultValues.containerCapacity;
1887  }
1888  if (!wasSet(VTYPEPARS_OSGFILE_SET)) {
1889  osgFile = defaultValues.osgFile;
1890  }
1892  carriageLength = defaultValues.carriageLength;
1893  }
1895  locomotiveLength = defaultValues.locomotiveLength;
1896  }
1897 }
1898 
1899 /****************************************************************************/
@ GLO_VTYPE
@bief vTypes
@ VTYPEDISTRIBUTION
#define WRITE_DEBUG(msg)
Definition: MsgHandler.h:290
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
@ GIVEN
The alignment as offset is given.
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.
StringBijection< SUMOVehicleShape > SumoVehicleShapeStrings(sumoVehicleShapeStringInitializer, SUMOVehicleShape::UNKNOWN, false)
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
const std::string DEFAULT_PEDTYPE_ID
const std::string DEFAULT_VTYPE_ID
const std::string DEFAULT_BIKETYPE_ID
@ SUMO_TAG_VTYPE
description of a vehicle/person/container type
@ SUMO_TAG_VTYPE_DISTRIBUTION
distribution of a vehicle type
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
@ SUMO_ATTR_TMP4
@ SUMO_ATTR_CF_EIDM_T_ACC_MAX
@ SUMO_ATTR_CF_EIDM_EPSILON_ACC
@ SUMO_ATTR_LCA_PUSHY
@ SUMO_ATTR_EMISSIONCLASS
@ SUMO_ATTR_JM_IGNORE_FOE_SPEED
@ SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME
@ SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD
@ SUMO_ATTR_CF_WIEDEMANN_SECURITY
@ SUMO_ATTR_LCA_ASSERTIVE
@ SUMO_ATTR_TRAIN_TYPE
@ SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS
@ SUMO_ATTR_CF_IDMM_ADAPT_TIME
@ SUMO_ATTR_LANE_CHANGE_MODEL
@ SUMO_ATTR_CF_KERNER_PHI
@ SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE
@ SUMO_ATTR_CF_EIDM_C_COOLNESS
@ SUMO_ATTR_CF_EIDM_SIG_ERROR
@ 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
@ GNE_ATTR_SELECTED
element is selected
@ SUMO_ATTR_LCA_IMPATIENCE
@ SUMO_ATTR_MINGAP
@ GNE_ATTR_VTYPE_DISTRIBUTION
vehicle type distribution
@ 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_CF_EIDM_MAX_VEH_PREVIEW
@ SUMO_ATTR_LCA_MAXSPEEDLATFACTOR
@ GNE_ATTR_DEFAULT_VTYPE
Flag to check if VType is a default VType.
@ SUMO_ATTR_CF_EIDM_T_REACTION
@ SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE
@ SUMO_ATTR_CF_PWAGNER2009_TAULAST
@ SUMO_ATTR_CF_EIDM_SIG_GAP
@ SUMO_ATTR_CAR_FOLLOW_MODEL
@ SUMO_ATTR_CF_EIDM_JERK_MAX
@ 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_CF_EIDM_M_FLATNESS
@ SUMO_ATTR_JM_SIGMA_MINOR
@ SUMO_ATTR_PROB
@ SUMO_ATTR_CF_EIDM_M_BEGIN
@ SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE
@ SUMO_ATTR_SPEEDFACTOR
@ SUMO_ATTR_CF_EIDM_SIG_LEADER
@ 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_CF_WIEDEMANN_ESTIMATION
@ SUMO_ATTR_LCA_SPEEDGAINRIGHT
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:39
void parse(const std::string &description, const bool hardFail)
Overwrite by parsable distribution description.
static bool isValidDescription(const std::string &description)
validate input description
bool isAttributeCarrierSelected() const
check if attribute carrier is selected
friend class GNEChange_Attribute
declare friend class
const std::string & getTagStr() const
get tag assigned to this object in string format
const GNETagProperties & getTagProperty() const
get tagProperty associated with this Attribute Carrier
void unselectAttributeCarrier(const bool changeFlag=true)
unselect attribute carrier using GUIGlobalSelection
GNENet * myNet
pointer to net
void selectAttributeCarrier(const bool changeFlag=true)
select attribute carrier using GUIGlobalSelection
const GNETagProperties & myTagProperty
reference to tagProperty associated with this attribute carrier
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
void setVTypeDistributionParent(const std::string &value)
set VTypeDistribution parent
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
Problem
enum class for demandElement problems
const std::string & getID() const
get ID
const std::vector< GNEDemandElement * > & getChildDemandElements() const
return child demand elements
const std::vector< GNEDemandElement * > & getParentDemandElements() const
get parent demand elements
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:46
move operation
move result
GNEDemandElement * retrieveDemandElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named demand element.
A NBNetBuilder extended by visualisation and editing capabilities.
Definition: GNENet.h:42
GNENetHelper::AttributeCarriers * getAttributeCarriers() const
get all attribute carriers used in this net
Definition: GNENet.cpp:125
GNEViewNet * getViewNet() const
get view net
Definition: GNENet.cpp:1964
const GNEAttributeProperties & getAttributeProperties(SumoXMLAttr attr) const
get attribute (throw error if doesn't exist)
GUIIcon getGUIIcon() const
get GUI icon associated to this Tag
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 end()
End undo command sub-group. If the sub-group is still empty, it will be deleted; otherwise,...
void begin(GUIIcon icon, const std::string &description)
Begin undo command sub-group with current supermode. This begins a new group of commands that are tre...
void add(GNEChange *command, bool doit=false, bool merge=true)
Add new command, executing it if desired. The new command will be merged with the previous command if...
void changeAttribute(GNEChange_Attribute *change)
special method for change attributes, avoid empty changes, always execute
Problem isDemandElementValid() const
check if current demand element is valid to be writed into XML
Definition: GNEVType.cpp:109
double getExaggeration(const GUIVisualizationSettings &s) const
return exaggeration asociated with this GLObject
Definition: GNEVType.cpp:161
std::string getHierarchyName() const
get Hierarchy Name (Used in AC Hierarchy)
Definition: GNEVType.cpp:923
void toogleAttribute(SumoXMLAttr key, const bool value, const int previousParameters)
method for enable or disable the attribute and nothing else (used in GNEChange_EnableAttribute)
Definition: GNEVType.cpp:1839
void updateGeometry()
update pre-computed geometry information
Definition: GNEVType.cpp:140
std::string getParentName() const
Returns the name of the parent object.
Definition: GNEVType.cpp:155
~GNEVType()
destructor
Definition: GNEVType.cpp:86
bool askRemoveVTypeDistribution(const std::string &vTypeDistribution) const
ask if remove vTypeDistribution
Definition: GNEVType.cpp:1328
bool isValid(SumoXMLAttr key, const std::string &value)
method for checking if the key and their conrrespond attribute are valids
Definition: GNEVType.cpp:678
bool askAddVTypeDistribution(const std::string &vTypeDistribution) const
ask if add vTypeDistribution
Definition: GNEVType.cpp:1304
GNEMoveOperation * getMoveOperation()
get move operation
Definition: GNEVType.cpp:90
Position getPositionInView() const
Returns position of additional in view.
Definition: GNEVType.cpp:149
void drawPartialGL(const GUIVisualizationSettings &s, const GNELane *lane, const GNEPathManager::Segment *segment, const double offsetFront) const
Draws partial object.
Definition: GNEVType.cpp:192
bool isAttributeEnabled(SumoXMLAttr key) const
Definition: GNEVType.cpp:882
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
method for setting the attribute and letting the object perform demand element changes
Definition: GNEVType.cpp:542
static void overwriteVType(GNEDemandElement *vType, const SUMOVTypeParameter newVTypeParameter, GNEUndoList *undoList)
overwrite all values of GNEVType with a SUMOVTypeParameter
Definition: GNEVType.cpp:935
void updateDefaultVClassAttributes(const VClassDefaultValues &defaultValues)
function called after set new VClass
Definition: GNEVType.cpp:1857
void commitMoveShape(const GNEMoveResult &moveResult, GNEUndoList *undoList)
commit move shape
Definition: GNEVType.cpp:1851
GNELane * getFirstPathLane() const
get first path lane
Definition: GNEVType.cpp:204
GNELane * getLastPathLane() const
get last path lane
Definition: GNEVType.cpp:211
void splitEdgeGeometry(const double splitPosition, const GNENetworkElement *originalElement, const GNENetworkElement *newElement, GNEUndoList *undoList)
split geometry
Definition: GNEVType.cpp:174
void writeDemandElement(OutputDevice &device) const
writte demand element element into a xml file
Definition: GNEVType.cpp:96
bool myDefaultVehicleType
flag to check if this GNEVType is a default vehicle Type (For Vehicles, Pedestrians....
Definition: GNEVType.h:212
const RGBColor & getColor() const
get color
Definition: GNEVType.cpp:134
std::string getDemandElementProblem() const
return a string with the current demand element problem
Definition: GNEVType.cpp:116
const std::map< std::string, std::string > & getACParametersMap() const
get parameters map
Definition: GNEVType.cpp:929
void fixDemandElementProblem()
fix demand element problem
Definition: GNEVType.cpp:122
void setMoveShape(const GNEMoveResult &moveResult)
set move shape
Definition: GNEVType.cpp:1845
GNEVType(GNENet *net)
default constructor
Definition: GNEVType.cpp:35
Position getAttributePosition(SumoXMLAttr key) const
Definition: GNEVType.cpp:536
double getAttributeDouble(SumoXMLAttr key) const
Definition: GNEVType.cpp:495
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
Definition: GNEVType.cpp:180
std::string getAttribute(SumoXMLAttr key) const
inherited from GNEAttributeCarrier
Definition: GNEVType.cpp:218
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
Definition: GNEVType.cpp:167
void computePathElement()
compute pathElement
Definition: GNEVType.cpp:186
std::string getPopUpID() const
get PopPup ID (Used in AC Hierarchy)
Definition: GNEVType.cpp:917
SUMOVehicleClass getVClass() const
Definition: GNEVType.cpp:128
void enableAttribute(SumoXMLAttr key, GNEUndoList *undoList)
Definition: GNEVType.cpp:870
void editVTypeDistribution(const std::string &vTypeDistributionID, GNEUndoList *undoList)
edit vType distribution
Definition: GNEVType.cpp:1247
void disableAttribute(SumoXMLAttr key, GNEUndoList *undoList)
Definition: GNEVType.cpp:876
bool myDefaultVehicleTypeModified
flag to check if this default GNEVType was modified
Definition: GNEVType.h:215
virtual const std::string & getMicrosimID() const
Returns the id of the object as known to microsim.
virtual void setMicrosimID(const std::string &newID)
Changes the microsimID of the object.
Stores the information about how to visualize structures.
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
static bool areParametersValid(const std::string &value, bool report=false, const std::string kvsep="=", const std::string sep="|")
check if given string can be parsed to a parameters map "key1=value1|key2=value2|....
void unsetParameter(const std::string &key)
Removes a parameter.
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"
virtual 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:37
Structure representing possible vehicle parameter.
static bool isValidLatAlignment(const std::string &val)
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.
double latAlignmentOffset
(optional) The vehicle's desired lateral alignment as offset in m from center line
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].
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.
LatAlignmentDefinition latAlignmentProcedure
Information on how the vehicle shall choose the lateral alignment.
SubParams jmParameter
Junction-model parameter.
double impatience
The vehicle's impatience (willingness to obstruct others)
LaneChangeModel lcModel
The lane-change model to use.
static bool parseLatAlignment(const std::string &val, double &lao, LatAlignmentDefinition &lad)
Parses and validates a given latAlignment value.
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
bool hasString(const std::string &str) const
const std::string & getString(const T key) const
T get(const std::string &str) const
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