Eclipse SUMO - Simulation of Urban MObility
GNEVehicleType.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
14 // Definition of Vehicle Types in NETEDIT
15 /****************************************************************************/
16 
17 // ===========================================================================
18 // included modules
19 // ===========================================================================
20 
21 #include <netedit/GNENet.h>
22 #include <netedit/GNEViewNet.h>
23 #include <netedit/GNEUndoList.h>
24 #include <netedit/GNEViewParent.h>
30 
31 #include "GNEVehicleType.h"
32 
33 
34 // ===========================================================================
35 // member method definitions
36 // ===========================================================================
37 
38 
39 GNEVehicleType::GNEVehicleType(GNEViewNet* viewNet, const std::string& vTypeID, const SUMOVehicleClass& defaultVClass, SumoXMLTag tag) :
40  GNEDemandElement(vTypeID, viewNet, GLO_VTYPE, tag, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}),
41  SUMOVTypeParameter(vTypeID),
42  myDefaultVehicleType(true),
43 myDefaultVehicleTypeModified(false) {
44  // set default vehicle class
45  vehicleClass = defaultVClass;
46  parametersSet |= VTYPEPARS_VEHICLECLASS_SET;
47  // init Rail Visualization Parameters
48  initRailVisualizationParameters();
49 }
50 
51 
53  GNEDemandElement(vTypeParameter.id, viewNet, GLO_VTYPE, tag, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}),
54 SUMOVTypeParameter(vTypeParameter),
55 myDefaultVehicleType(false),
56 myDefaultVehicleTypeModified(false) {
57  // if we're creating a Person Type, set manually VClass
58  if (tag == SUMO_TAG_PTYPE) {
59  vehicleClass = SVC_PEDESTRIAN;
60  parametersSet |= VTYPEPARS_VEHICLECLASS_SET;
61  }
62  // init Rail Visualization Parameters
63  initRailVisualizationParameters();
64 }
65 
66 
67 GNEVehicleType::GNEVehicleType(GNEViewNet* viewNet, const std::string& vTypeID, GNEVehicleType* vTypeOriginal) :
68  GNEDemandElement(vTypeID, viewNet, GLO_VTYPE, vTypeOriginal->getTagProperty().getTag(), {}, {}, {}, {}, {}, {}, {}, {}, {}, {}),
69 SUMOVTypeParameter(*vTypeOriginal),
70 myDefaultVehicleType(false),
71 myDefaultVehicleTypeModified(false) {
72  // change manually the ID (to avoid to use the ID of vTypeOriginal)
73  id = vTypeID;
74  // init Rail Visualization Parameters
75  initRailVisualizationParameters();
76 }
77 
78 
80 
81 
82 void
84  // only write default vehicle types if it was modified
87  write(device);
88  }
89  } else {
90  write(device);
91  }
92 }
93 
94 
95 GNEEdge*
97  return nullptr;
98 }
99 
100 
101 GNEEdge*
103  return nullptr;
104 }
105 
106 
109  return vehicleClass;
110 }
111 
112 
113 const RGBColor&
115  return color;
116 }
117 
118 
119 void
121  // VTypes cannot be moved
122 }
123 
124 
125 void
127  // VTypes cannot be moved
128 }
129 
130 
131 void
133  // VTypes cannot be moved
134 }
135 
136 
137 void
139  // VTypes cannot be moved
140 }
141 
142 
143 void
145  // update geometry of all childrens
146  for (const auto& i : getChildDemandElements()) {
147  i->updateGeometry();
148  }
149 }
150 
151 
152 void
154  // update geometry of all childrens
155  for (const auto& i : getChildDemandElements()) {
156  i->updatePartialGeometry(edge);
157  }
158 }
159 
160 
161 void
163  // nothing to compute
164 }
165 
166 
167 void
169  // nothing to invalidate
170 }
171 
172 
173 Position
175  return Position();
176 }
177 
178 
179 std::string
181  return myViewNet->getNet()->getMicrosimID();
182 }
183 
184 
185 Boundary
187  // Vehicle Types doesn't have boundaries
188  return Boundary(-0.1, -0.1, 0.1, 0.1);
189 }
190 
191 
192 void
193 GNEVehicleType::splitEdgeGeometry(const double /*splitPosition*/, const GNENetElement* /*originalElement*/, const GNENetElement* /*newElement*/, GNEUndoList* /*undoList*/) {
194  // geometry of this element cannot be splitted
195 }
196 
197 
198 void
200  // Vehicle Types aren't draw
201 }
202 
203 
204 void
206  if (!myViewNet) {
207  throw ProcessError("ViewNet cannot be nullptr");
208  } else {
210  // add object of list into selected objects
212  if (changeFlag) {
213  mySelected = true;
214  }
215  }
216 }
217 
218 
219 void
221  if (!myViewNet) {
222  throw ProcessError("ViewNet cannot be nullptr");
223  } else {
225  // remove object of list of selected objects
227  if (changeFlag) {
228  mySelected = false;
229 
230  }
231  }
232 }
233 
234 
235 std::string
237  // obtain default values depending of vehicle class
238  VClassDefaultValues defaultValues(vehicleClass);
239  switch (key) {
240  case SUMO_ATTR_ID:
241  return getDemandElementID();
242  // CFM Attributes
243  case SUMO_ATTR_ACCEL:
244  case SUMO_ATTR_DECEL:
247  case SUMO_ATTR_SIGMA:
248  case SUMO_ATTR_TAU:
249  // this CFM has default values
251  // JM Attributes
261  // this JM has default values
265  return toString(impatience);
266  } else {
268  }
269  // LCM Attributes
276  case SUMO_ATTR_LCA_PUSHY:
288  /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
290  //
292  case SUMO_ATTR_TMP1:
293  case SUMO_ATTR_TMP2:
294  case SUMO_ATTR_TMP3:
295  case SUMO_ATTR_TMP4:
296  case SUMO_ATTR_TMP5:
304  case SUMO_ATTR_K:
308  return getCFParamString(key, "");
309  // Mutable values
310  case SUMO_ATTR_LENGTH:
312  return toString(length);
313  } else {
314  return toString(defaultValues.length);
315  }
316  case SUMO_ATTR_MINGAP:
318  return toString(minGap);
319  } else {
320  return toString(defaultValues.minGap);
321  }
322  case SUMO_ATTR_MAXSPEED:
324  return toString(maxSpeed);
325  } else {
326  return toString(defaultValues.maxSpeed);
327  }
330  return toString(speedFactor.getParameter()[0]);
331  } else {
332  return toString(defaultValues.speedFactor.getParameter()[0]);
333  }
334  case SUMO_ATTR_SPEEDDEV:
336  return toString(speedFactor.getParameter()[1]);
337  } else {
338  return toString(defaultValues.speedFactor.getParameter()[1]);
339  }
342  return toString(personCapacity);
343  } else {
344  return toString(defaultValues.personCapacity);
345  }
348  return toString(containerCapacity);
349  } else {
350  return toString(defaultValues.containerCapacity);
351  }
352  case SUMO_ATTR_OSGFILE:
354  return osgFile;
355  } else {
356  return defaultValues.osgFile;
357  }
358  case SUMO_ATTR_COLOR:
360  return toString(color);
361  } else {
362  return "";
363  }
364  case SUMO_ATTR_VCLASS:
366  return toString(vehicleClass);
367  } else {
369  }
373  } else {
374  return PollutantsInterface::getName(defaultValues.emissionClass);
375  }
376  case SUMO_ATTR_GUISHAPE:
378  return getVehicleShapeName(shape);
379  } else {
380  return getVehicleShapeName(defaultValues.shape);
381  }
382  case SUMO_ATTR_WIDTH:
384  return toString(width);
385  } else {
386  return toString(defaultValues.width);
387  }
388  case SUMO_ATTR_HEIGHT:
390  return toString(height);
391  } else {
392  return toString(defaultValues.height);
393  }
394  case SUMO_ATTR_IMGFILE:
396  return imgFile;
397  } else {
399  }
403  } else {
405  }
409  } else {
411  }
415  } else {
417  }
421  } else {
423  }
426  return toString(latAlignment);
427  } else {
429  }
432  return toString(minGapLat);
433  } else {
435  }
438  return toString(maxSpeedLat);
439  } else {
441  }
444  return toString(actionStepLength);
445  } else {
447  }
448  case SUMO_ATTR_PROB:
451  } else {
453  }
456  return toString(carriageLength);
457  } else {
458  return toString(defaultValues.carriageLength);
459  }
462  return toString(locomotiveLength);
463  } else {
464  return toString(defaultValues.locomotiveLength);
465  }
468  return toString(carriageGap);
469  } else {
471  }
472  case GNE_ATTR_PARAMETERS:
473  return getParametersStr();
479  if (myDefaultVehicleType) {
481  } else {
482  return toString(false);
483  }
484  default:
485  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
486  }
487 }
488 
489 
490 double
492  // obtain default values depending of vehicle class
493  VClassDefaultValues defaultValues(vehicleClass);
494  switch (key) {
495  case SUMO_ATTR_LENGTH:
497  return length;
498  } else {
499  return defaultValues.length;
500  }
501  case SUMO_ATTR_MINGAP:
503  return minGap;
504  } else {
505  return defaultValues.minGap;
506  }
507  case SUMO_ATTR_WIDTH:
509  return width;
510  } else {
511  return defaultValues.width;
512  }
513  case SUMO_ATTR_HEIGHT:
515  return height;
516  } else {
517  return defaultValues.height;
518  }
519  case SUMO_ATTR_MAXSPEED:
521  return maxSpeed;
522  } else {
523  return defaultValues.maxSpeed;
524  }
525  default:
526  throw InvalidArgument(getTagStr() + " doesn't have a double attribute of type '" + toString(key) + "'");
527  }
528 }
529 
530 
531 void
532 GNEVehicleType::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) {
533  if (value == getAttribute(key)) {
534  return; //avoid needless changes, later logic relies on the fact that attributes have changed
535  }
536  switch (key) {
537  case SUMO_ATTR_ID:
538  undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), key, value));
539  break;
540  // CFM Attributes
541  case SUMO_ATTR_ACCEL:
542  case SUMO_ATTR_DECEL:
545  case SUMO_ATTR_SIGMA:
546  case SUMO_ATTR_TAU:
548  case SUMO_ATTR_TMP1:
549  case SUMO_ATTR_TMP2:
550  case SUMO_ATTR_TMP3:
551  case SUMO_ATTR_TMP4:
552  case SUMO_ATTR_TMP5:
560  case SUMO_ATTR_K:
564  // JM Attributes
575  // LCM Attributes
582  case SUMO_ATTR_LCA_PUSHY:
594  /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
595  //
596  case SUMO_ATTR_LENGTH:
597  case SUMO_ATTR_MINGAP:
598  case SUMO_ATTR_MAXSPEED:
600  case SUMO_ATTR_SPEEDDEV:
601  case SUMO_ATTR_COLOR:
602  case SUMO_ATTR_VCLASS:
604  case SUMO_ATTR_GUISHAPE:
605  case SUMO_ATTR_WIDTH:
606  case SUMO_ATTR_HEIGHT:
607  case SUMO_ATTR_IMGFILE:
618  case SUMO_ATTR_PROB:
619  case SUMO_ATTR_OSGFILE:
623  case GNE_ATTR_PARAMETERS:
624  // if we change the original value of a default vehicle Type, change also flag "myDefaultVehicleType"
625  if (myDefaultVehicleType) {
626  undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), true, GNE_ATTR_DEFAULT_VTYPE_MODIFIED, "true"));
627  }
628  undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), true, key, value));
629  break;
631  undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), true, key, value));
632  break;
633  default:
634  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
635  }
636 }
637 
638 
639 bool
640 GNEVehicleType::isValid(SumoXMLAttr key, const std::string& value) {
641  // a empty value is always valid except for IDs
642  if ((key != SUMO_ATTR_ID) && value.empty()) {
643  return true;
644  }
645  switch (key) {
646  case SUMO_ATTR_ID:
647  // Vtypes and PTypes shares namespace
649  (myViewNet->getNet()->retrieveDemandElement(SUMO_TAG_VTYPE, value, false) == nullptr) &&
650  (myViewNet->getNet()->retrieveDemandElement(SUMO_TAG_PTYPE, value, false) == nullptr)) {
651  return true;
652  } else {
653  return false;
654  }
655  // CFM Attributes
656  case SUMO_ATTR_SIGMA:
657  return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
658  case SUMO_ATTR_ACCEL:
659  case SUMO_ATTR_DECEL:
662  case SUMO_ATTR_TAU:
664  case SUMO_ATTR_TMP1:
665  case SUMO_ATTR_TMP2:
666  case SUMO_ATTR_TMP3:
667  case SUMO_ATTR_TMP4:
668  case SUMO_ATTR_TMP5:
675  case SUMO_ATTR_K:
679  return canParse<double>(value);
681  // rail string
683  // JM Attributes
685  return canParse<double>(value) && (parse<double>(value) >= 0);
687  return canParse<double>(value) && (parse<double>(value) >= -1);
689  return canParse<double>(value) && (parse<double>(value) >= -1);
691  return canParse<double>(value) && (parse<double>(value) >= -1);
693  return canParse<double>(value) && (parse<double>(value) >= 0);
695  return canParse<double>(value) && (parse<double>(value) >= 0);
697  return canParse<double>(value) && (parse<double>(value) >= 0);
699  return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
701  return canParse<double>(value) && (parse<double>(value) >= 0);
703  return canParse<double>(value) && (parse<double>(value) >= 0);
704  // LCM Attributes
711  case SUMO_ATTR_LCA_PUSHY:
712  return canParse<double>(value);
716  case SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE: // 0 mean disabled
717  case SUMO_ATTR_LCA_TIME_TO_IMPATIENCE: // 0 mean disabled
718  case SUMO_ATTR_LCA_OVERTAKE_RIGHT: // 0 mean disabled
719  return canParse<double>(value) && (parse<double>(value) >= 0);
725  return canParse<double>(value) && (parse<double>(value) > 0);
726  /* case SUMO_ATTR_LCA_EXPERIMENTAL1:
727  return true;
728  */
729  //
730  case SUMO_ATTR_LENGTH:
731  return canParse<double>(value) && (parse<double>(value) > 0);
732  case SUMO_ATTR_MINGAP:
733  return canParse<double>(value) && (parse<double>(value) >= 0);
734  case SUMO_ATTR_MAXSPEED:
735  return canParse<double>(value) && (parse<double>(value) >= 0);
737  return canParse<double>(value) && (parse<double>(value) >= 0);
738  case SUMO_ATTR_SPEEDDEV:
739  return canParse<double>(value) && (parse<double>(value) >= 0);
740  case SUMO_ATTR_COLOR:
741  if (value.empty()) {
742  return true;
743  } else {
744  return canParse<RGBColor>(value);
745  }
746  case SUMO_ATTR_VCLASS:
747  return canParseVehicleClasses(value);
749  // check if given value correspond to a string of PollutantsInterface::getAllClassesStr()
750  for (const auto& i : PollutantsInterface::getAllClassesStr()) {
751  if (value == i) {
752  return true;
753  }
754  }
755  return false;
756  case SUMO_ATTR_GUISHAPE:
757  if (value == "all") {
758  return false;
759  } else {
760  return canParseVehicleShape(value);
761  }
762  case SUMO_ATTR_WIDTH:
763  return canParse<double>(value);
764  case SUMO_ATTR_HEIGHT:
765  return canParse<double>(value);
766  case SUMO_ATTR_IMGFILE:
773  return canParse<int>(value);
775  return canParse<int>(value);
777  return canParse<double>(value);
779  return canParse<double>(value);
783  return canParse<double>(value);
785  return canParse<double>(value);
787  return canParse<double>(value) && (parse<double>(value) >= 0);
788  case SUMO_ATTR_PROB:
789  return canParse<double>(value) && (parse<double>(value) >= 0);
790  case SUMO_ATTR_OSGFILE:
793  return canParse<double>(value) && (parse<double>(value) >= -1);
795  return canParse<double>(value) && (parse<double>(value) >= -1);
797  return canParse<double>(value) && (parse<double>(value) >= 0);
798  case GNE_ATTR_PARAMETERS:
799  return Parameterised::areParametersValid(value);
801  if (myDefaultVehicleType) {
802  return canParse<bool>(value);
803  } else {
804  return false;
805  }
806  default:
807  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
808  }
809 }
810 
811 
812 void
814  // nothing to enable
815 }
816 
817 
818 void
820  // nothing to disable
821 }
822 
823 
824 bool
826  switch (key) {
827  case SUMO_ATTR_ID:
828  if ((id == DEFAULT_VTYPE_ID) || (id == DEFAULT_PEDTYPE_ID) || (id == DEFAULT_BIKETYPE_ID)) {
829  return false;
830  } else {
831  return true;
832  }
833  case SUMO_ATTR_LENGTH:
835  case SUMO_ATTR_MINGAP:
837  case SUMO_ATTR_MAXSPEED:
841  case SUMO_ATTR_SPEEDDEV:
847  case SUMO_ATTR_OSGFILE:
855  default:
856  return true;
857  }
858 }
859 
860 
861 std::string
863  return getTagStr();
864 }
865 
866 
867 std::string
869  return getTagStr() + ": " + getAttribute(SUMO_ATTR_ID) ;
870 }
871 
872 
873 void
875  // open undo list and overwritte all values of default VType
876  undoList->p_begin("update default " + vType->getTagStr() + " '" + DEFAULT_VTYPE_ID + "'");
877  // CFM values
878  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_ACCEL, "").empty()) {
879  vType->setAttribute(SUMO_ATTR_ACCEL, toString(newVTypeParameter->getCFParam(SUMO_ATTR_ACCEL, 0)), undoList);
880  }
881  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_DECEL, "").empty()) {
882  vType->setAttribute(SUMO_ATTR_DECEL, toString(newVTypeParameter->getCFParam(SUMO_ATTR_DECEL, 0)), undoList);
883  }
884  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_APPARENTDECEL, "").empty()) {
885  vType->setAttribute(SUMO_ATTR_APPARENTDECEL, toString(newVTypeParameter->getCFParam(SUMO_ATTR_APPARENTDECEL, 0)), undoList);
886  }
887  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_EMERGENCYDECEL, "").empty()) {
888  vType->setAttribute(SUMO_ATTR_EMERGENCYDECEL, toString(newVTypeParameter->getCFParam(SUMO_ATTR_EMERGENCYDECEL, 0)), undoList);
889  }
890  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_SIGMA, "").empty()) {
891  vType->setAttribute(SUMO_ATTR_SIGMA, toString(newVTypeParameter->getCFParam(SUMO_ATTR_SIGMA, 0)), undoList);
892  }
893  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TAU, "").empty()) {
894  vType->setAttribute(SUMO_ATTR_TAU, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TAU, 0)), undoList);
895  }
896  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_COLLISION_MINGAP_FACTOR, "").empty()) {
898  }
899  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TMP1, "").empty()) {
900  vType->setAttribute(SUMO_ATTR_TMP1, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TMP1, 0)), undoList);
901  }
902  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TMP2, "").empty()) {
903  vType->setAttribute(SUMO_ATTR_TMP2, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TMP2, 0)), undoList);
904  }
905  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TMP3, "").empty()) {
906  vType->setAttribute(SUMO_ATTR_TMP3, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TMP3, 0)), undoList);
907  }
908  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TMP4, "").empty()) {
909  vType->setAttribute(SUMO_ATTR_TMP4, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TMP4, 0)), undoList);
910  }
911  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TMP5, "").empty()) {
912  vType->setAttribute(SUMO_ATTR_TMP5, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TMP5, 0)), undoList);
913  }
914  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_PWAGNER2009_TAULAST, "").empty()) {
916  }
917  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_PWAGNER2009_APPROB, "").empty()) {
919  }
920  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_IDMM_ADAPT_FACTOR, "").empty()) {
922  }
923  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_IDMM_ADAPT_TIME, "").empty()) {
925  }
926  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_WIEDEMANN_SECURITY, "").empty()) {
928  }
929  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_WIEDEMANN_ESTIMATION, "").empty()) {
931  }
932  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_TRAIN_TYPE, "").empty()) {
933  vType->setAttribute(SUMO_ATTR_TRAIN_TYPE, toString(newVTypeParameter->getCFParam(SUMO_ATTR_TRAIN_TYPE, 0)), undoList);
934  }
935  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_K, "").empty()) {
936  vType->setAttribute(SUMO_ATTR_K, toString(newVTypeParameter->getCFParam(SUMO_ATTR_K, 0)), undoList);
937  }
938  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_KERNER_PHI, "").empty()) {
939  vType->setAttribute(SUMO_ATTR_CF_KERNER_PHI, toString(newVTypeParameter->getCFParam(SUMO_ATTR_CF_KERNER_PHI, 0)), undoList);
940  }
941  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_IDM_DELTA, "").empty()) {
942  vType->setAttribute(SUMO_ATTR_CF_IDM_DELTA, toString(newVTypeParameter->getCFParam(SUMO_ATTR_CF_IDM_DELTA, 0)), undoList);
943  }
944  if (!newVTypeParameter->getCFParamString(SUMO_ATTR_CF_IDM_STEPPING, "").empty()) {
945  vType->setAttribute(SUMO_ATTR_CF_IDM_STEPPING, toString(newVTypeParameter->getCFParam(SUMO_ATTR_CF_IDM_STEPPING, 0)), undoList);
946  }
947  // JM values
948  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_CROSSING_GAP, "").empty()) {
949  vType->setAttribute(SUMO_ATTR_JM_CROSSING_GAP, toString(newVTypeParameter->getCFParam(SUMO_ATTR_JM_CROSSING_GAP, 0)), undoList);
950  }
951  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME, "").empty()) {
953  }
954  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME, "").empty()) {
956  }
957  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME, "").empty()) {
959  }
960  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_DRIVE_RED_SPEED, "").empty()) {
962  }
963  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_IGNORE_FOE_PROB, "").empty()) {
965  }
966  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_IGNORE_FOE_SPEED, "").empty()) {
968  }
969  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_SIGMA_MINOR, "").empty()) {
970  vType->setAttribute(SUMO_ATTR_JM_SIGMA_MINOR, toString(newVTypeParameter->getCFParam(SUMO_ATTR_JM_SIGMA_MINOR, 0)), undoList);
971  }
972  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_JM_TIMEGAP_MINOR, "").empty()) {
973  vType->setAttribute(SUMO_ATTR_JM_TIMEGAP_MINOR, toString(newVTypeParameter->getCFParam(SUMO_ATTR_JM_TIMEGAP_MINOR, 0)), undoList);
974  }
975  if (newVTypeParameter->wasSet(VTYPEPARS_IMPATIENCE_SET)) {
976  vType->setAttribute(SUMO_ATTR_IMPATIENCE, toString(newVTypeParameter->impatience), undoList);
977  }
978  // LCM values
979  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_STRATEGIC_PARAM, "").empty()) {
981  }
982  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_COOPERATIVE_PARAM, "").empty()) {
984  }
985  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_SPEEDGAIN_PARAM, "").empty()) {
987  }
988  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_KEEPRIGHT_PARAM, "").empty()) {
990  }
991  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_SUBLANE_PARAM, "").empty()) {
993  }
994  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_OPPOSITE_PARAM, "").empty()) {
996  }
997  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_PUSHY, "").empty()) {
998  vType->setAttribute(SUMO_ATTR_LCA_PUSHY, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_PUSHY, 0)), undoList);
999  }
1000  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_PUSHYGAP, "").empty()) {
1001  vType->setAttribute(SUMO_ATTR_LCA_PUSHYGAP, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_PUSHYGAP, 0)), undoList);
1002  }
1003  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_ASSERTIVE, "").empty()) {
1004  vType->setAttribute(SUMO_ATTR_LCA_ASSERTIVE, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_ASSERTIVE, 0)), undoList);
1005  }
1006  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_IMPATIENCE, "").empty()) {
1007  vType->setAttribute(SUMO_ATTR_LCA_IMPATIENCE, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_IMPATIENCE, 0)), undoList);
1008  }
1009  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_TIME_TO_IMPATIENCE, "").empty()) {
1011  }
1012  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_ACCEL_LAT, "").empty()) {
1013  vType->setAttribute(SUMO_ATTR_LCA_ACCEL_LAT, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_ACCEL_LAT, 0)), undoList);
1014  }
1015  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_LOOKAHEADLEFT, "").empty()) {
1016  vType->setAttribute(SUMO_ATTR_LCA_LOOKAHEADLEFT, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_LOOKAHEADLEFT, 0)), undoList);
1017  }
1018  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_SPEEDGAINRIGHT, "").empty()) {
1020  }
1021  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_MAXSPEEDLATSTANDING, "").empty()) {
1023  }
1024  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_MAXSPEEDLATFACTOR, "").empty()) {
1026  }
1027  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE, "").empty()) {
1029  }
1030  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_OVERTAKE_RIGHT, "").empty()) {
1032  }
1033  if (!newVTypeParameter->getJMParamString(SUMO_ATTR_LCA_EXPERIMENTAL1, "").empty()) {
1034  vType->setAttribute(SUMO_ATTR_LCA_EXPERIMENTAL1, toString(newVTypeParameter->getCFParam(SUMO_ATTR_LCA_EXPERIMENTAL1, 0)), undoList);
1035  }
1036  //
1037  if (newVTypeParameter->wasSet(VTYPEPARS_LENGTH_SET)) {
1038  vType->setAttribute(SUMO_ATTR_LENGTH, toString(newVTypeParameter->length), undoList);
1039  }
1040  if (newVTypeParameter->wasSet(VTYPEPARS_MINGAP_SET)) {
1041  vType->setAttribute(SUMO_ATTR_MINGAP, toString(newVTypeParameter->minGap), undoList);
1042  }
1043  if (newVTypeParameter->wasSet(VTYPEPARS_MAXSPEED_SET)) {
1044  vType->setAttribute(SUMO_ATTR_MAXSPEED, toString(newVTypeParameter->maxSpeed), undoList);
1045  }
1046  if (newVTypeParameter->wasSet(VTYPEPARS_SPEEDFACTOR_SET)) {
1047  vType->setAttribute(SUMO_ATTR_SPEEDFACTOR, toString(newVTypeParameter->speedFactor.getParameter()[0]), undoList);
1048  }
1049  if (newVTypeParameter->wasSet(VTYPEPARS_SPEEDFACTOR_SET)) {
1050  vType->setAttribute(SUMO_ATTR_SPEEDDEV, toString(newVTypeParameter->speedFactor.getParameter()[1]), undoList);
1051  }
1052  if (newVTypeParameter->wasSet(VTYPEPARS_COLOR_SET)) {
1053  vType->setAttribute(SUMO_ATTR_COLOR, toString(newVTypeParameter->color), undoList);
1054  }
1055  if (newVTypeParameter->wasSet(VTYPEPARS_EMISSIONCLASS_SET)) {
1056  vType->setAttribute(SUMO_ATTR_EMISSIONCLASS, PollutantsInterface::getName(newVTypeParameter->emissionClass), undoList);
1057  }
1058  if (newVTypeParameter->wasSet(VTYPEPARS_SHAPE_SET)) {
1059  vType->setAttribute(SUMO_ATTR_GUISHAPE, getVehicleShapeName(newVTypeParameter->shape), undoList);
1060  }
1061  if (newVTypeParameter->wasSet(VTYPEPARS_WIDTH_SET)) {
1062  vType->setAttribute(SUMO_ATTR_WIDTH, toString(newVTypeParameter->width), undoList);
1063  }
1064  if (newVTypeParameter->wasSet(VTYPEPARS_HEIGHT_SET)) {
1065  vType->setAttribute(SUMO_ATTR_HEIGHT, toString(newVTypeParameter->height), undoList);
1066  }
1067  if (newVTypeParameter->wasSet(VTYPEPARS_IMGFILE_SET)) {
1068  vType->setAttribute(SUMO_ATTR_IMGFILE, toString(newVTypeParameter->imgFile), undoList);
1069  }
1070  if (newVTypeParameter->wasSet(VTYPEPARS_LANE_CHANGE_MODEL_SET)) {
1071  vType->setAttribute(SUMO_ATTR_LANE_CHANGE_MODEL, SUMOXMLDefinitions::LaneChangeModels.getString(newVTypeParameter->lcModel), undoList);
1072  }
1073  if (newVTypeParameter->wasSet(VTYPEPARS_CAR_FOLLOW_MODEL)) {
1074  vType->setAttribute(SUMO_ATTR_CAR_FOLLOW_MODEL, SUMOXMLDefinitions::CarFollowModels.getString(newVTypeParameter->cfModel), undoList);
1075  }
1076  if (newVTypeParameter->wasSet(VTYPEPARS_PERSON_CAPACITY)) {
1077  vType->setAttribute(SUMO_ATTR_PERSON_CAPACITY, toString(newVTypeParameter->personCapacity), undoList);
1078  }
1079  if (newVTypeParameter->wasSet(VTYPEPARS_CONTAINER_CAPACITY)) {
1080  vType->setAttribute(SUMO_ATTR_CONTAINER_CAPACITY, toString(newVTypeParameter->containerCapacity), undoList);
1081  }
1082  if (newVTypeParameter->wasSet(VTYPEPARS_BOARDING_DURATION)) {
1083  vType->setAttribute(SUMO_ATTR_BOARDING_DURATION, toString(newVTypeParameter->boardingDuration), undoList);
1084  }
1085  if (newVTypeParameter->wasSet(VTYPEPARS_LOADING_DURATION)) {
1086  vType->setAttribute(SUMO_ATTR_LOADING_DURATION, toString(newVTypeParameter->loadingDuration), undoList);
1087  }
1088  if (newVTypeParameter->wasSet(VTYPEPARS_LATALIGNMENT_SET)) {
1089  vType->setAttribute(SUMO_ATTR_LATALIGNMENT, toString(newVTypeParameter->latAlignment), undoList);
1090  }
1091  if (newVTypeParameter->wasSet(VTYPEPARS_MINGAP_LAT_SET)) {
1092  vType->setAttribute(SUMO_ATTR_MINGAP_LAT, toString(newVTypeParameter->minGapLat), undoList);
1093  }
1094  if (newVTypeParameter->wasSet(VTYPEPARS_MAXSPEED_LAT_SET)) {
1095  vType->setAttribute(SUMO_ATTR_MAXSPEED_LAT, toString(newVTypeParameter->maxSpeedLat), undoList);
1096  }
1097  if (newVTypeParameter->wasSet(VTYPEPARS_ACTIONSTEPLENGTH_SET)) {
1098  vType->setAttribute(SUMO_ATTR_ACTIONSTEPLENGTH, toString(newVTypeParameter->actionStepLength), undoList);
1099  }
1100  if (newVTypeParameter->wasSet(VTYPEPARS_PROBABILITY_SET)) {
1101  vType->setAttribute(SUMO_ATTR_PROB, toString(newVTypeParameter->defaultProbability), undoList);
1102  }
1103  if (newVTypeParameter->wasSet(VTYPEPARS_OSGFILE_SET)) {
1104  vType->setAttribute(SUMO_ATTR_OSGFILE, toString(newVTypeParameter->osgFile), undoList);
1105  }
1106  if (newVTypeParameter->knowsParameter(toString(SUMO_ATTR_CARRIAGE_LENGTH))) {
1107  vType->setAttribute(SUMO_ATTR_CARRIAGE_LENGTH, newVTypeParameter->getParameter(toString(SUMO_ATTR_CARRIAGE_LENGTH), ""), undoList);
1108  }
1109  if (newVTypeParameter->knowsParameter(toString(SUMO_ATTR_LOCOMOTIVE_LENGTH))) {
1111  }
1112  if (newVTypeParameter->knowsParameter(toString(SUMO_ATTR_CARRIAGE_GAP))) {
1113  vType->setAttribute(SUMO_ATTR_CARRIAGE_GAP, newVTypeParameter->getParameter(toString(SUMO_ATTR_CARRIAGE_GAP), ""), undoList);
1114  }
1115  // parse parameters
1116  std::string parametersStr;
1117  // Generate an string using the following structure: "key1=value1|key2=value2|...
1118  for (auto i : newVTypeParameter->getParametersMap()) {
1119  parametersStr += i.first + "=" + i.second + "|";
1120  }
1121  // remove the last "|"
1122  if (!parametersStr.empty()) {
1123  parametersStr.pop_back();
1124  }
1125  if (parametersStr != vType->getAttribute(GNE_ATTR_PARAMETERS)) {
1126  vType->setAttribute(GNE_ATTR_PARAMETERS, parametersStr, undoList);
1127  }
1128  // close undo list
1129  undoList->p_end();
1130 }
1131 
1132 
1133 void
1135  if (SUMOVTypeParameter::knowsParameter("carriageLength")) {
1138  } else if (wasSet(VTYPEPARS_SHAPE_SET)) {
1139  switch (shape) {
1140  case SVS_BUS_FLEXIBLE:
1141  carriageLength = 8.25; // 16.5 overall, 2 modules http://de.wikipedia.org/wiki/Ikarus_180
1142  carriageGap = 0;
1143  break;
1144  case SVS_RAIL:
1145  carriageLength = 24.5; // http://de.wikipedia.org/wiki/UIC-Y-Wagen_%28DR%29
1146  break;
1147  case SVS_RAIL_CAR:
1148  carriageLength = 16.85; // 67.4m overall, 4 carriages http://de.wikipedia.org/wiki/DB-Baureihe_423
1149  break;
1150  case SVS_RAIL_CARGO:
1151  carriageLength = 13.86; // UIC 571-1 http://de.wikipedia.org/wiki/Flachwagen
1152  break;
1153  case SVS_TRUCK_SEMITRAILER:
1154  carriageLength = 13.5;
1155  locomotiveLength = 2.5;
1156  carriageGap = 0.5;
1157  break;
1158  case SVS_TRUCK_1TRAILER:
1159  carriageLength = 6.75;
1160  locomotiveLength = 2.5 + 6.75;
1161  carriageGap = 0.5;
1162  break;
1163  default:
1164  break;
1165  }
1166  }
1167  if (SUMOVTypeParameter::knowsParameter("locomotiveLength")) {
1170  } else if (locomotiveLength <= 0) {
1172  }
1173  if (SUMOVTypeParameter::knowsParameter("carriageGap")) {
1176  }
1177 }
1178 
1179 // ===========================================================================
1180 // private
1181 // ===========================================================================
1182 
1183 void
1184 GNEVehicleType::setAttribute(SumoXMLAttr key, const std::string& value) {
1185  // obtain default values depending of vehicle class
1186  VClassDefaultValues defaultValues(vehicleClass);
1187  switch (key) {
1188  case SUMO_ATTR_ID:
1189  changeDemandElementID(value);
1190  id = value;
1191  break;
1192  // CFM Attributes
1193  case SUMO_ATTR_ACCEL:
1194  case SUMO_ATTR_DECEL:
1197  case SUMO_ATTR_SIGMA:
1198  case SUMO_ATTR_TAU:
1200  case SUMO_ATTR_TMP1:
1201  case SUMO_ATTR_TMP2:
1202  case SUMO_ATTR_TMP3:
1203  case SUMO_ATTR_TMP4:
1204  case SUMO_ATTR_TMP5:
1211  case SUMO_ATTR_TRAIN_TYPE:
1212  case SUMO_ATTR_K:
1216  // empty values means that value isn't set
1217  if (value.empty()) {
1218  const auto it = cfParameter.find(key);
1219  if (it != cfParameter.end()) {
1220  cfParameter.erase(it);
1221  }
1222  } else {
1223  cfParameter[key] = value;
1224  }
1225  break;
1226  // JM Attributes
1236  // empty values means that value isn't set
1237  if (value.empty()) {
1238  const auto it = jmParameter.find(key);
1239  if (it != jmParameter.end()) {
1240  jmParameter.erase(it);
1241  }
1242  } else {
1243  jmParameter[key] = value;
1244  }
1245  break;
1246  case SUMO_ATTR_IMPATIENCE:
1247  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1248  impatience = parse<double>(value);
1249  // mark parameter as set
1251  } else {
1252  // set default value
1253  impatience = parse<double>(myTagProperty.getDefaultValue(key));
1254  // unset parameter
1256  }
1257  break;
1258  // LCM Attributes
1265  case SUMO_ATTR_LCA_PUSHY:
1274 
1275  /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
1276  // empty values means that value isn't set
1277  if (value.empty()) {
1278  const auto it = lcParameter.find(key);
1279  if (it != lcParameter.end()) {
1280  lcParameter.erase(it);
1281  }
1282  } else {
1283  lcParameter[key] = value;
1284  }
1285  break;
1289  // empty or null values means that value isn't set
1290  if (value.empty() || (canParse<double>(value) && (parse<double>(value) == 0))) {
1291  const auto it = lcParameter.find(key);
1292  if (it != lcParameter.end()) {
1293  lcParameter.erase(it);
1294  }
1295  } else {
1296  lcParameter[key] = value;
1297  }
1298  break;
1299  //
1300  case SUMO_ATTR_LENGTH:
1301  if (!value.empty() && (value != toString(defaultValues.length))) {
1302  length = parse<double>(value);
1303  // mark parameter as set
1305  } else {
1306  // set default value
1307  length = defaultValues.length;
1308  // unset parameter
1310  }
1311  break;
1312  case SUMO_ATTR_MINGAP:
1313  if (!value.empty() && (value != toString(defaultValues.minGap))) {
1314  minGap = parse<double>(value);
1315  // mark parameter as set
1317  } else {
1318  // set default value
1319  minGap = defaultValues.minGap;
1320  // unset parameter
1322  }
1323  break;
1324  case SUMO_ATTR_MAXSPEED:
1325  if (!value.empty() && (value != toString(defaultValues.maxSpeed))) {
1326  maxSpeed = parse<double>(value);
1327  // mark parameter as set
1329  } else {
1330  // set default value
1331  maxSpeed = defaultValues.maxSpeed;
1332  // unset parameter
1334  }
1335  break;
1336  case SUMO_ATTR_SPEEDFACTOR:
1337  if (!value.empty() && (value != toString(defaultValues.speedFactor.getParameter()[0]))) {
1338  speedFactor.getParameter()[0] = parse<double>(value);
1339  // mark parameter as set
1341  } else {
1342  // set default value
1343  speedFactor.getParameter()[0] = defaultValues.speedFactor.getParameter()[0];
1344  // unset parameter
1346  }
1347  break;
1348  case SUMO_ATTR_SPEEDDEV:
1349  if (!value.empty() && (value != toString(defaultValues.speedFactor.getParameter()[1]))) {
1350  speedFactor.getParameter()[1] = parse<double>(value);
1351  // mark parameter as set
1353  } else {
1354  // set default value
1355  speedFactor.getParameter()[1] = defaultValues.speedFactor.getParameter()[1];
1356  // unset parameter
1358  }
1359  break;
1360  case SUMO_ATTR_COLOR:
1361  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1362  color = parse<RGBColor>(value);
1363  // mark parameter as set
1365  } else {
1366  // unset parameter
1368  }
1369  break;
1370  case SUMO_ATTR_VCLASS:
1371  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1373  // mark parameter as set
1375  } else {
1376  // set default value
1378  // unset parameter
1380  }
1381  // update default values
1382  updateDefaultVClassAttributes(defaultValues);
1383  break;
1385  if (!value.empty() && (value != toString(defaultValues.emissionClass))) {
1387  // mark parameter as set
1389  } else {
1390  // set default value
1391  emissionClass = defaultValues.emissionClass;
1392  // unset parameter
1394  }
1395  break;
1396  case SUMO_ATTR_GUISHAPE:
1397  if (!value.empty() && (value != toString(defaultValues.shape))) {
1398  shape = getVehicleShapeID(value);
1399  // mark parameter as set
1401  } else {
1402  // set default value
1403  shape = defaultValues.shape;
1404  // unset parameter
1406  }
1407  break;
1408  case SUMO_ATTR_WIDTH:
1409  if (!value.empty() && (value != toString(defaultValues.width))) {
1410  width = parse<double>(value);
1411  // mark parameter as set
1413  } else {
1414  // set default value
1415  width = defaultValues.width;
1416  // unset parameter
1418  }
1419  break;
1420  case SUMO_ATTR_HEIGHT:
1421  if (!value.empty() && (value != toString(defaultValues.height))) {
1422  height = parse<double>(value);
1423  // mark parameter as set
1425  } else {
1426  // set default value
1427  height = defaultValues.height;
1428  // unset parameter
1430  }
1431  break;
1432  case SUMO_ATTR_IMGFILE:
1433  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1434  imgFile = value;
1435  // mark parameter as set
1437  } else {
1438  // set default value
1440  // unset parameter
1442  }
1443  break;
1445  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1447  // mark parameter as set
1449  } else {
1450  // set default value
1452  // unset parameter
1454  }
1455  break;
1457  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1459  // mark parameter as set
1461  } else {
1462  // set default value
1464  // unset parameter
1466  }
1467  break;
1469  if (!value.empty() && (value != toString(defaultValues.personCapacity))) {
1470  personCapacity = parse<int>(value);
1471  // mark parameter as set
1473  } else {
1474  // set default value
1475  personCapacity = defaultValues.personCapacity;
1476  // unset parameter
1478  }
1479  break;
1481  if (!value.empty() && (value != toString(defaultValues.containerCapacity))) {
1482  containerCapacity = parse<int>(value);
1483  // mark parameter as set
1485  } else {
1486  // set default value
1487  containerCapacity = defaultValues.containerCapacity;
1488  // unset parameter
1490  }
1491  break;
1493  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1494  boardingDuration = string2time(value);
1495  // mark parameter as set
1497  } else {
1498  // set default value
1500  // unset parameter
1502  }
1503  break;
1505  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1506  loadingDuration = string2time(value);
1507  // mark parameter as set
1509  } else {
1510  // set default value
1512  // unset parameter
1514  }
1515  break;
1517  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1519  // mark parameter as set
1521  } else {
1522  // set default value
1524  // unset parameter
1526  }
1527  break;
1528  case SUMO_ATTR_MINGAP_LAT:
1529  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1530  minGapLat = parse<double>(value);
1531  // mark parameter as set
1533  } else {
1534  // set default value
1535  minGapLat = parse<double>(myTagProperty.getDefaultValue(key));
1536  // unset parameter
1538  }
1539  break;
1541  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1542  maxSpeedLat = parse<double>(value);
1543  // mark parameter as set
1545  } else {
1546  // set default value
1547  maxSpeedLat = parse<double>(myTagProperty.getDefaultValue(key));
1548  // unset parameter
1550  }
1551  break;
1553  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1554  actionStepLength = string2time(value);
1555  // mark parameter as set
1557  } else {
1558  // set default value
1560  // unset parameter
1562  }
1563  break;
1564  case SUMO_ATTR_PROB:
1565  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1566  defaultProbability = parse<double>(value);
1567  // mark parameter as set
1569  } else {
1570  // set default value
1571  defaultProbability = parse<double>(myTagProperty.getDefaultValue(key));
1572  // unset parameter
1574  }
1575  break;
1576  case SUMO_ATTR_OSGFILE:
1577  if (!value.empty() && (value != defaultValues.osgFile)) {
1578  osgFile = value;
1579  // mark parameter as set
1581  } else {
1582  // set default value
1583  osgFile = defaultValues.osgFile;
1584  // unset parameter
1586  }
1587  break;
1589  if (!value.empty() && (value != toString(defaultValues.carriageLength))) {
1590  carriageLength = parse<double>(value);
1591  // mark parameter as set
1593  // set parameter in SUMOVTypeParameter (needed for writting in XML)
1595  } else {
1596  // set default value
1597  carriageLength = defaultValues.carriageLength;
1598  // unset parameter
1600  // remove from params (needed for writting in XML)
1602  }
1603  break;
1605  if (!value.empty() && (value != toString(defaultValues.containerCapacity))) {
1606  locomotiveLength = parse<double>(value);
1607  // mark parameter as set
1609  // set parameter in SUMOVTypeParameter (needed for writting in XML)
1611  } else {
1612  // set default value
1613  locomotiveLength = defaultValues.locomotiveLength;
1614  // unset parameter
1616  // remove from params (needed for writting in XML)
1618  }
1619  break;
1621  if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1622  carriageGap = parse<double>(value);
1623  // mark parameter as set
1625  // set parameter in SUMOVTypeParameter (needed for writting in XML)
1627  } else {
1628  // set default value
1629  carriageGap = parse<double>(myTagProperty.getDefaultValue(key));
1630  // unset parameter
1632  // remove from params (needed for writting in XML)
1634  }
1635  break;
1636  case GNE_ATTR_PARAMETERS:
1637  setParametersStr(value);
1638  break;
1640  myDefaultVehicleTypeModified = parse<bool>(value);
1641  break;
1642  default:
1643  throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
1644  }
1645  // check if geometry must be marked as deprecated
1647  updateGeometry();
1648  }
1649 }
1650 
1651 
1652 void
1653 GNEVehicleType::setEnabledAttribute(const int /*enabledAttributes*/) {
1654  //
1655 }
1656 
1657 
1658 void
1660  if (!wasSet(VTYPEPARS_LENGTH_SET)) {
1661  length = defaultValues.length;
1662  }
1663  if (!wasSet(VTYPEPARS_MINGAP_SET)) {
1664  minGap = defaultValues.minGap;
1665  }
1667  maxSpeed = defaultValues.maxSpeed;
1668  }
1669  if (!wasSet(VTYPEPARS_WIDTH_SET)) {
1670  width = defaultValues.width;
1671  }
1672  if (!wasSet(VTYPEPARS_HEIGHT_SET)) {
1673  height = defaultValues.height;
1674  }
1675  if (!wasSet(VTYPEPARS_SHAPE_SET)) {
1676  shape = defaultValues.shape;
1677  }
1679  emissionClass = defaultValues.emissionClass;
1680  }
1682  speedFactor = defaultValues.speedFactor;
1683  }
1685  personCapacity = defaultValues.personCapacity;
1686  }
1688  containerCapacity = defaultValues.containerCapacity;
1689  }
1690  if (!wasSet(VTYPEPARS_OSGFILE_SET)) {
1691  osgFile = defaultValues.osgFile;
1692  }
1694  carriageLength = defaultValues.carriageLength;
1695  }
1697  locomotiveLength = defaultValues.locomotiveLength;
1698  }
1699 }
1700 
1701 /****************************************************************************/
GNEVehicleType::setAttribute
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
method for setting the attribute and letting the object perform demand element changes
Definition: GNEVehicleType.cpp:532
VTYPEPARS_LATALIGNMENT_SET
const int VTYPEPARS_LATALIGNMENT_SET
Definition: SUMOVTypeParameter.h:66
GNEViewParent::getSelectorFrame
GNESelectorFrame * getSelectorFrame() const
get frame for GNE_NMODE_SELECT
Definition: GNEViewParent.cpp:186
SUMO_ATTR_MAXSPEED
@ SUMO_ATTR_MAXSPEED
Definition: SUMOXMLDefinitions.h:441
GNEDemandElement::myViewNet
GNEViewNet * myViewNet
The GNEViewNet this demand element element belongs.
Definition: GNEDemandElement.h:376
SUMO_ATTR_OSGFILE
@ SUMO_ATTR_OSGFILE
Definition: SUMOXMLDefinitions.h:791
GNEVehicleType::writeDemandElement
void writeDemandElement(OutputDevice &device) const
writte demand element element into a xml file
Definition: GNEVehicleType.cpp:83
SUMO_ATTR_BOARDING_DURATION
@ SUMO_ATTR_BOARDING_DURATION
Definition: SUMOXMLDefinitions.h:460
SUMO_ATTR_LCA_SPEEDGAIN_PARAM
@ SUMO_ATTR_LCA_SPEEDGAIN_PARAM
Definition: SUMOXMLDefinitions.h:590
SVC_PEDESTRIAN
@ SVC_PEDESTRIAN
pedestrian
Definition: SUMOVehicleClass.h:156
SUMOVehicleClass
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
Definition: SUMOVehicleClass.h:133
SUMOXMLDefinitions::LaneChangeModels
static StringBijection< LaneChangeModel > LaneChangeModels
lane change models
Definition: SUMOXMLDefinitions.h:1395
SUMOVTypeParameter::lcParameter
SubParams lcParameter
Lane-changing parameter.
Definition: SUMOVTypeParameter.h:284
SUMO_ATTR_CF_WIEDEMANN_ESTIMATION
@ SUMO_ATTR_CF_WIEDEMANN_ESTIMATION
Definition: SUMOXMLDefinitions.h:842
GNEDemandElement
An Element which don't belongs to GNENet but has influency in the simulation.
Definition: GNEDemandElement.h:55
SUMOVTypeParameter::VClassDefaultValues::carriageLength
double carriageLength
the length of train carriages
Definition: SUMOVTypeParameter.h:127
GNEVehicleType::disableAttribute
void disableAttribute(SumoXMLAttr key, GNEUndoList *undoList)
Definition: GNEVehicleType.cpp:819
VTYPEPARS_CARRIAGE_LENGTH_SET
const int VTYPEPARS_CARRIAGE_LENGTH_SET
Definition: SUMOVTypeParameter.h:70
GNEVehicleType::getToEdge
GNEEdge * getToEdge() const
obtain to edge of this demand element
Definition: GNEVehicleType.cpp:102
Parameterised::getParametersStr
std::string getParametersStr() const
Returns the inner key/value map in string format "key1=value1|key2=value2|...|keyN=valueN".
Definition: Parameterised.cpp:112
SUMOVTypeParameter::locomotiveLength
double locomotiveLength
Definition: SUMOVTypeParameter.h:303
GNEVehicleType::unselectAttributeCarrier
void unselectAttributeCarrier(bool changeFlag=true)
unselect attribute carrier using GUIGlobalSelection
Definition: GNEVehicleType.cpp:220
SUMOVTypeParameter::length
double length
The physical vehicle length.
Definition: SUMOVTypeParameter.h:215
SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME
@ SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME
Definition: SUMOXMLDefinitions.h:617
GNEAttributeCarrier::mySelected
bool mySelected
boolean to check if this AC is selected (instead of GUIGlObjectStorage)
Definition: GNEAttributeCarrier.h:788
getVehicleClassID
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
Definition: SUMOVehicleClass.cpp:200
SUMO_ATTR_IMGFILE
@ SUMO_ATTR_IMGFILE
Definition: SUMOXMLDefinitions.h:792
VTYPEPARS_MINGAP_SET
const int VTYPEPARS_MINGAP_SET
Definition: SUMOVTypeParameter.h:46
GNEVehicleType::getVClass
SUMOVehicleClass getVClass() const
obtain VClass related with this demand element
Definition: GNEVehicleType.cpp:108
SUMO_ATTR_MINGAP_LAT
@ SUMO_ATTR_MINGAP_LAT
Definition: SUMOXMLDefinitions.h:444
SUMO_ATTR_CF_IDMM_ADAPT_FACTOR
@ SUMO_ATTR_CF_IDMM_ADAPT_FACTOR
Definition: SUMOXMLDefinitions.h:838
DEFAULT_PEDTYPE_ID
const std::string DEFAULT_PEDTYPE_ID
SUMO_ATTR_LATALIGNMENT
@ SUMO_ATTR_LATALIGNMENT
Definition: SUMOXMLDefinitions.h:443
SUMO_ATTR_LENGTH
@ SUMO_ATTR_LENGTH
Definition: SUMOXMLDefinitions.h:393
GNEHierarchicalChildElements::getChildDemandElements
const std::vector< GNEDemandElement * > & getChildDemandElements() const
return child demand elements
Definition: GNEHierarchicalChildElements.cpp:296
SUMO_ATTR_LCA_COOPERATIVE_PARAM
@ SUMO_ATTR_LCA_COOPERATIVE_PARAM
Definition: SUMOXMLDefinitions.h:589
SUMOXMLDefinitions::isValidFilename
static bool isValidFilename(const std::string &value)
whether the given string is a valid attribute for a filename (for example, a name)
Definition: SUMOXMLDefinitions.cpp:1001
SUMO_ATTR_CF_IDM_STEPPING
@ SUMO_ATTR_CF_IDM_STEPPING
Definition: SUMOXMLDefinitions.h:837
OutputDevice
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:63
GNEVehicleType::setEnabledAttribute
void setEnabledAttribute(const int enabledAttributes)
method for enabling the attribute and nothing else (used in GNEChange_EnableAttribute)
Definition: GNEVehicleType.cpp:1653
SUMOVTypeParameter::actionStepLength
SUMOTime actionStepLength
The vehicle type's default actionStepLength [ms], i.e. the interval between two control actions....
Definition: SUMOVTypeParameter.h:225
SUMO_ATTR_MAXSPEED_LAT
@ SUMO_ATTR_MAXSPEED_LAT
Definition: SUMOXMLDefinitions.h:442
SUMOVTypeParameter::VClassDefaultValues::emissionClass
SUMOEmissionClass emissionClass
The emission class of this vehicle.
Definition: SUMOVTypeParameter.h:112
GNEVehicleType::getParentName
std::string getParentName() const
Returns the name of the parent object.
Definition: GNEVehicleType.cpp:180
StringBijection::getString
const std::string & getString(const T key) const
Definition: StringBijection.h:106
GNEUndoList::p_end
void p_end()
End undo command sub-group. If the sub-group is still empty, it will be deleted; otherwise,...
Definition: GNEUndoList.cpp:79
GNEVehicleType::~GNEVehicleType
~GNEVehicleType()
destructor
Definition: GNEVehicleType.cpp:79
SUMOVTypeParameter::cfModel
SumoXMLTag cfModel
The enum-representation of the car-following model to use.
Definition: SUMOVTypeParameter.h:278
SUMO_ATTR_TMP2
@ SUMO_ATTR_TMP2
Definition: SUMOXMLDefinitions.h:551
StringUtils::toDouble
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
Definition: StringUtils.cpp:345
VTYPEPARS_BOARDING_DURATION
const int VTYPEPARS_BOARDING_DURATION
Definition: SUMOVTypeParameter.h:61
SUMO_ATTR_SPEEDFACTOR
@ SUMO_ATTR_SPEEDFACTOR
Definition: SUMOXMLDefinitions.h:454
GNEVehicleType::updateGeometry
void updateGeometry()
update pre-computed geometry information
Definition: GNEVehicleType.cpp:144
SUMOVTypeParameter::impatience
double impatience
The vehicle's impatience (willingness to obstruct others)
Definition: SUMOVTypeParameter.h:243
GUIGlobalSelection.h
SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME
@ SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME
Definition: SUMOXMLDefinitions.h:614
SUMO_ATTR_TMP1
@ SUMO_ATTR_TMP1
Definition: SUMOXMLDefinitions.h:550
SUMOVTypeParameter::osgFile
std::string osgFile
3D model file for this class
Definition: SUMOVTypeParameter.h:270
SUMO_ATTR_CF_PWAGNER2009_APPROB
@ SUMO_ATTR_CF_PWAGNER2009_APPROB
Definition: SUMOXMLDefinitions.h:835
VTYPEPARS_MINGAP_LAT_SET
const int VTYPEPARS_MINGAP_LAT_SET
Definition: SUMOVTypeParameter.h:67
GNEVehicleType::myDefaultVehicleType
bool myDefaultVehicleType
flag to check if this GNEVehicleType is a default vehicle Type (For Vehicles, Pedestrians....
Definition: GNEVehicleType.h:197
SUMO_ATTR_LOADING_DURATION
@ SUMO_ATTR_LOADING_DURATION
Definition: SUMOXMLDefinitions.h:461
GNENet::retrieveDemandElement
GNEDemandElement * retrieveDemandElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named demand element.
Definition: GNENet.cpp:2316
SUMO_TAG_PTYPE
@ SUMO_TAG_PTYPE
description of a person type (used in NETEDIT)
Definition: SUMOXMLDefinitions.h:123
SUMO_ATTR_COLOR
@ SUMO_ATTR_COLOR
A color information.
Definition: SUMOXMLDefinitions.h:704
GNEViewNet
Definition: GNEViewNet.h:42
VTYPEPARS_OSGFILE_SET
const int VTYPEPARS_OSGFILE_SET
Definition: SUMOVTypeParameter.h:56
SUMOVTypeParameter::carriageLength
double carriageLength
the length of train carriages and locomotive
Definition: SUMOVTypeParameter.h:302
SUMO_ATTR_CONTAINER_CAPACITY
@ SUMO_ATTR_CONTAINER_CAPACITY
Definition: SUMOXMLDefinitions.h:650
SUMO_ATTR_SPEEDDEV
@ SUMO_ATTR_SPEEDDEV
Definition: SUMOXMLDefinitions.h:455
SUMO_ATTR_ID
@ SUMO_ATTR_ID
Definition: SUMOXMLDefinitions.h:378
SUMOVTypeParameter::shape
SUMOVehicleShape shape
This class' shape.
Definition: SUMOVTypeParameter.h:267
VTYPEPARS_PROBABILITY_SET
const int VTYPEPARS_PROBABILITY_SET
Definition: SUMOVTypeParameter.h:48
SUMO_ATTR_CF_IDM_DELTA
@ SUMO_ATTR_CF_IDM_DELTA
Definition: SUMOXMLDefinitions.h:836
SUMO_TAG_VTYPE
@ SUMO_TAG_VTYPE
description of a vehicle type
Definition: SUMOXMLDefinitions.h:121
PollutantsInterface::getName
static std::string getName(const SUMOEmissionClass c)
Checks whether the string describes a known vehicle class.
Definition: PollutantsInterface.cpp:99
SUMOVTypeParameter::VClassDefaultValues::length
double length
The physical vehicle length.
Definition: SUMOVTypeParameter.h:94
SUMO_ATTR_LCA_MAXSPEEDLATFACTOR
@ SUMO_ATTR_LCA_MAXSPEEDLATFACTOR
Definition: SUMOXMLDefinitions.h:603
SUMO_ATTR_LCA_KEEPRIGHT_PARAM
@ SUMO_ATTR_LCA_KEEPRIGHT_PARAM
Definition: SUMOXMLDefinitions.h:591
SUMO_ATTR_LANE_CHANGE_MODEL
@ SUMO_ATTR_LANE_CHANGE_MODEL
Definition: SUMOXMLDefinitions.h:456
getVehicleShapeName
std::string getVehicleShapeName(SUMOVehicleShape id)
Returns the class name of the shape class given by its id.
Definition: SUMOVehicleClass.cpp:358
SUMO_ATTR_TMP5
@ SUMO_ATTR_TMP5
Definition: SUMOXMLDefinitions.h:554
SUMO_ATTR_TMP3
@ SUMO_ATTR_TMP3
Definition: SUMOXMLDefinitions.h:552
VTYPEPARS_LOCOMOTIVE_LENGTH_SET
const int VTYPEPARS_LOCOMOTIVE_LENGTH_SET
Definition: SUMOVTypeParameter.h:71
GNEVehicleType::splitEdgeGeometry
void splitEdgeGeometry(const double splitPosition, const GNENetElement *originalElement, const GNENetElement *newElement, GNEUndoList *undoList)
split geometry
Definition: GNEVehicleType.cpp:193
SUMOVTypeParameter::containerCapacity
int containerCapacity
The container capacity of the vehicle.
Definition: SUMOVTypeParameter.h:249
GNEVehicleType::computePath
void computePath()
compute path
Definition: GNEVehicleType.cpp:162
SumoXMLTag
SumoXMLTag
Numbers representing SUMO-XML - element names.
Definition: SUMOXMLDefinitions.h:41
GNEAttributeCarrier::AttributeProperties::requireUpdateGeometry
bool requireUpdateGeometry() const
return true if atribute requires a update geometry in setAttribute(...)
Definition: GNEAttributeCarrier.cpp:472
SUMO_ATTR_JM_IGNORE_FOE_PROB
@ SUMO_ATTR_JM_IGNORE_FOE_PROB
Definition: SUMOXMLDefinitions.h:619
SUMO_ATTR_LCA_EXPERIMENTAL1
@ SUMO_ATTR_LCA_EXPERIMENTAL1
Definition: SUMOXMLDefinitions.h:608
SUMO_ATTR_JM_TIMEGAP_MINOR
@ SUMO_ATTR_JM_TIMEGAP_MINOR
Definition: SUMOXMLDefinitions.h:621
SVS_BUS_FLEXIBLE
@ SVS_BUS_FLEXIBLE
render as a flexible city bus
Definition: SUMOVehicleClass.h:86
Parameterised::getParameter
const std::string getParameter(const std::string &key, const std::string &defaultValue="") const
Returns the value for a given key.
Definition: Parameterised.cpp:72
VTYPEPARS_CAR_FOLLOW_MODEL
const int VTYPEPARS_CAR_FOLLOW_MODEL
Definition: SUMOVTypeParameter.h:64
SUMO_ATTR_JM_IGNORE_FOE_SPEED
@ SUMO_ATTR_JM_IGNORE_FOE_SPEED
Definition: SUMOXMLDefinitions.h:618
SUMOXMLDefinitions::CarFollowModels
static StringBijection< SumoXMLTag > CarFollowModels
car following models
Definition: SUMOXMLDefinitions.h:1398
SUMO_ATTR_LCA_PUSHYGAP
@ SUMO_ATTR_LCA_PUSHYGAP
Definition: SUMOXMLDefinitions.h:595
GNEAttributeCarrier::TagProperties::hasAttribute
bool hasAttribute(SumoXMLAttr attr) const
check if current TagProperties owns the attribute attr
Definition: GNEAttributeCarrier.cpp:680
SUMO_ATTR_LCA_MAXSPEEDLATSTANDING
@ SUMO_ATTR_LCA_MAXSPEEDLATSTANDING
Definition: SUMOXMLDefinitions.h:602
GNEEdge
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:51
GNEAttributeCarrier::GNEChange_Attribute
friend class GNEChange_Attribute
declare friend class
Definition: GNEAttributeCarrier.h:57
SUMOVTypeParameter::wasSet
bool wasSet(int what) const
Returns whether the given parameter was set.
Definition: SUMOVTypeParameter.h:150
SUMOVTypeParameter::parametersSet
int parametersSet
Information for the router which parameter were set.
Definition: SUMOVTypeParameter.h:307
GNEUndoList::p_add
void p_add(GNEChange_Attribute *cmd)
special method, avoid empty changes, always execute
Definition: GNEUndoList.cpp:131
VTYPEPARS_MAXSPEED_LAT_SET
const int VTYPEPARS_MAXSPEED_LAT_SET
Definition: SUMOVTypeParameter.h:65
GNEDemandElement::changeDemandElementID
void changeDemandElementID(const std::string &newID)
change ID of demand element
Definition: GNEDemandElement.cpp:385
GNEViewNet::getNet
GNENet * getNet() const
get the net object
Definition: GNEViewNet.cpp:1014
SUMO_ATTR_LCA_SUBLANE_PARAM
@ SUMO_ATTR_LCA_SUBLANE_PARAM
Definition: SUMOXMLDefinitions.h:592
RGBColor
Definition: RGBColor.h:39
Parameterised::getParametersMap
const std::map< std::string, std::string > & getParametersMap() const
Returns the inner key/value map.
Definition: Parameterised.cpp:106
SUMO_ATTR_APPARENTDECEL
@ SUMO_ATTR_APPARENTDECEL
Definition: SUMOXMLDefinitions.h:448
Distribution_Parameterized::getParameter
std::vector< double > & getParameter()
Returns the parameters of this distribution.
Definition: Distribution_Parameterized.cpp:110
GNEVehicleType::endGeometryMoving
void endGeometryMoving()
end geometry movement
Definition: GNEVehicleType.cpp:126
canParseVehicleClasses
bool canParseVehicleClasses(const std::string &classes)
Checks whether the given string contains only known vehicle classes.
Definition: SUMOVehicleClass.cpp:251
SUMO_ATTR_PROB
@ SUMO_ATTR_PROB
Definition: SUMOXMLDefinitions.h:629
SUMO_ATTR_DECEL
@ SUMO_ATTR_DECEL
Definition: SUMOXMLDefinitions.h:446
VTYPEPARS_LANE_CHANGE_MODEL_SET
const int VTYPEPARS_LANE_CHANGE_MODEL_SET
Definition: SUMOVTypeParameter.h:59
SUMOVTypeParameter::imgFile
std::string imgFile
Image file for this class.
Definition: SUMOVTypeParameter.h:273
SUMOVTypeParameter::getLCParamString
std::string getLCParamString(const SumoXMLAttr attr, const std::string &defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition: SUMOVTypeParameter.cpp:488
SUMO_ATTR_COLLISION_MINGAP_FACTOR
@ SUMO_ATTR_COLLISION_MINGAP_FACTOR
Definition: SUMOXMLDefinitions.h:459
SUMO_ATTR_ACCEL
@ SUMO_ATTR_ACCEL
Definition: SUMOXMLDefinitions.h:445
SUMOVTypeParameter::VClassDefaultValues::containerCapacity
int containerCapacity
The container capacity of the vehicle.
Definition: SUMOVTypeParameter.h:121
GUISelectedStorage::select
void select(GUIGlID id, bool update=true)
Adds the object with the given id.
Definition: GUISelectedStorage.cpp:113
SUMOVTypeParameter::height
double height
This class' height.
Definition: SUMOVTypeParameter.h:264
PollutantsInterface.h
SUMO_ATTR_LCA_OPPOSITE_PARAM
@ SUMO_ATTR_LCA_OPPOSITE_PARAM
Definition: SUMOXMLDefinitions.h:593
GNEDemandElement::getAttribute
virtual std::string getAttribute(SumoXMLAttr key) const =0
GNEVehicleType
Definition: GNEVehicleType.h:36
SUMOVTypeParameter
Structure representing possible vehicle parameter.
Definition: SUMOVTypeParameter.h:86
GNE_ATTR_DEFAULT_VTYPE_MODIFIED
@ GNE_ATTR_DEFAULT_VTYPE_MODIFIED
Flag to check if a default VType was modified.
Definition: SUMOXMLDefinitions.h:1007
canParseVehicleShape
bool canParseVehicleShape(const std::string &shape)
Checks whether the given string contains only known vehicle shape.
Definition: SUMOVehicleClass.cpp:352
SUMOVTypeParameter::jmParameter
SubParams jmParameter
Junction-model parameter.
Definition: SUMOVTypeParameter.h:287
GNEVehicleType::getCenteringBoundary
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
Definition: GNEVehicleType.cpp:186
StringBijection::get
T get(const std::string &str) const
Definition: StringBijection.h:97
SUMOVTypeParameter::cfParameter
SubParams cfParameter
Car-following parameter.
Definition: SUMOVTypeParameter.h:281
SUMOVTypeParameter::defaultProbability
double defaultProbability
The probability when being added to a distribution without an explicit probability.
Definition: SUMOVTypeParameter.h:228
DEFAULT_VTYPE_ID
const std::string DEFAULT_VTYPE_ID
SUMOVTypeParameter::VClassDefaultValues::maxSpeed
double maxSpeed
The vehicle type's maximum speed [m/s].
Definition: SUMOVTypeParameter.h:100
GNEVehicleType::getFromEdge
GNEEdge * getFromEdge() const
Definition: GNEVehicleType.cpp:96
GNEVehicleType::startGeometryMoving
void startGeometryMoving()
Definition: GNEVehicleType.cpp:120
GNEViewNet.h
SUMO_ATTR_LCA_SPEEDGAINRIGHT
@ SUMO_ATTR_LCA_SPEEDGAINRIGHT
Definition: SUMOXMLDefinitions.h:601
SUMO_ATTR_WIDTH
@ SUMO_ATTR_WIDTH
Definition: SUMOXMLDefinitions.h:386
GNEVehicleType::GNEVehicleType
GNEVehicleType(GNEViewNet *viewNet, const std::string &vTypeID, const SUMOVehicleClass &defaultVClass, SumoXMLTag tag)
constructor for default VTypes
Definition: GNEVehicleType.cpp:39
GUIGlObject::getGlID
GUIGlID getGlID() const
Returns the numerical id of the object.
Definition: GUIGlObject.cpp:149
Boundary
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:41
GLO_VTYPE
@ GLO_VTYPE
Definition: GUIGlObjectTypes.h:110
SUMO_ATTR_JM_DRIVE_RED_SPEED
@ SUMO_ATTR_JM_DRIVE_RED_SPEED
Definition: SUMOXMLDefinitions.h:616
GNEVehicleType::selectAttributeCarrier
void selectAttributeCarrier(bool changeFlag=true)
inherited from GNEAttributeCarrier
Definition: GNEVehicleType.cpp:205
GNE_ATTR_PARAMETERS
@ GNE_ATTR_PARAMETERS
parameters "key1=value1|key2=value2|...|keyN=valueN"
Definition: SUMOXMLDefinitions.h:989
VTYPEPARS_ACTIONSTEPLENGTH_SET
const int VTYPEPARS_ACTIONSTEPLENGTH_SET
Definition: SUMOVTypeParameter.h:68
SVS_RAIL_CARGO
@ SVS_RAIL_CARGO
render as a cargo train
Definition: SUMOVehicleClass.h:94
ProcessError
Definition: UtilExceptions.h:39
SUMO_ATTR_PERSON_CAPACITY
@ SUMO_ATTR_PERSON_CAPACITY
Definition: SUMOXMLDefinitions.h:649
SUMOVTypeParameter::VClassDefaultValues::width
double width
This class' width.
Definition: SUMOVTypeParameter.h:103
VTYPEPARS_CARRIAGE_GAP_SET
const int VTYPEPARS_CARRIAGE_GAP_SET
Definition: SUMOVTypeParameter.h:72
SUMO_ATTR_LCA_LOOKAHEADLEFT
@ SUMO_ATTR_LCA_LOOKAHEADLEFT
Definition: SUMOXMLDefinitions.h:600
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:38
GNEVehicleType::commitGeometryMoving
void commitGeometryMoving(GNEUndoList *undoList)
commit geometry changes in the attributes of an element after use of moveGeometry(....
Definition: GNEVehicleType.cpp:138
SUMOVTypeParameter::boardingDuration
SUMOTime boardingDuration
The time a person needs to board the vehicle.
Definition: SUMOVTypeParameter.h:252
SUMOVTypeParameter::VClassDefaultValues::minGap
double minGap
This class' free space in front of the vehicle itself.
Definition: SUMOVTypeParameter.h:97
GNEAttributeCarrier::myTagProperty
const TagProperties & myTagProperty
the xml tag to which this attribute carrier corresponds
Definition: GNEAttributeCarrier.h:785
SUMOVTypeParameter::minGap
double minGap
This class' free space in front of the vehicle itself.
Definition: SUMOVTypeParameter.h:218
SUMO_ATTR_LCA_OVERTAKE_RIGHT
@ SUMO_ATTR_LCA_OVERTAKE_RIGHT
Definition: SUMOXMLDefinitions.h:605
time2string
std::string time2string(SUMOTime t)
Definition: SUMOTime.cpp:67
SUMOVTypeParameter::getJMParamString
std::string getJMParamString(const SumoXMLAttr attr, const std::string defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition: SUMOVTypeParameter.cpp:514
SUMO_ATTR_LCA_STRATEGIC_PARAM
@ SUMO_ATTR_LCA_STRATEGIC_PARAM
Definition: SUMOXMLDefinitions.h:588
SUMOVTypeParameter::width
double width
This class' width.
Definition: SUMOVTypeParameter.h:261
SUMO_ATTR_JM_SIGMA_MINOR
@ SUMO_ATTR_JM_SIGMA_MINOR
Definition: SUMOXMLDefinitions.h:620
SUMOVTypeParameter::maxSpeedLat
double maxSpeedLat
The vehicle type's maximum lateral speed [m/s].
Definition: SUMOVTypeParameter.h:293
SUMOVTypeParameter::getCFParam
double getCFParam(const SumoXMLAttr attr, const double defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition: SUMOVTypeParameter.cpp:458
SUMOVTypeParameter::maxSpeed
double maxSpeed
The vehicle type's maximum speed [m/s].
Definition: SUMOVTypeParameter.h:221
GNENetElement
Definition: GNENetElement.h:43
GNE_ATTR_DEFAULT_VTYPE
@ GNE_ATTR_DEFAULT_VTYPE
Flag to check if VType is a default VType.
Definition: SUMOXMLDefinitions.h:1005
SUMOVTypeParameter::personCapacity
int personCapacity
The person capacity of the vehicle.
Definition: SUMOVTypeParameter.h:246
SUMOVTypeParameter::VClassDefaultValues::shape
SUMOVehicleShape shape
This class' shape.
Definition: SUMOVTypeParameter.h:109
VTYPEPARS_SPEEDFACTOR_SET
const int VTYPEPARS_SPEEDFACTOR_SET
Definition: SUMOVTypeParameter.h:49
SUMO_ATTR_LCA_IMPATIENCE
@ SUMO_ATTR_LCA_IMPATIENCE
Definition: SUMOXMLDefinitions.h:597
SUMOVTypeParameter::write
void write(OutputDevice &dev) const
Writes the vtype.
Definition: SUMOVTypeParameter.cpp:348
SVS_RAIL_CAR
@ SVS_RAIL_CAR
render as a (city) rail without locomotive
Definition: SUMOVehicleClass.h:92
string2time
SUMOTime string2time(const std::string &r)
Definition: SUMOTime.cpp:44
SUMO_ATTR_LCA_ASSERTIVE
@ SUMO_ATTR_LCA_ASSERTIVE
Definition: SUMOXMLDefinitions.h:596
GNEVehicleType::updatePartialGeometry
void updatePartialGeometry(const GNEEdge *edge)
partial update pre-computed geometry information
Definition: GNEVehicleType.cpp:153
GNEVehicleType::invalidatePath
void invalidatePath()
invalidate path
Definition: GNEVehicleType.cpp:168
GNEVehicleType::getPopUpID
std::string getPopUpID() const
get PopPup ID (Used in AC Hierarchy)
Definition: GNEVehicleType.cpp:862
GNEVehicleType::enableAttribute
void enableAttribute(SumoXMLAttr key, GNEUndoList *undoList)
Definition: GNEVehicleType.cpp:813
SUMO_ATTR_CF_WIEDEMANN_SECURITY
@ SUMO_ATTR_CF_WIEDEMANN_SECURITY
Definition: SUMOXMLDefinitions.h:841
SUMO_ATTR_CARRIAGE_GAP
@ SUMO_ATTR_CARRIAGE_GAP
Definition: SUMOXMLDefinitions.h:1016
GNEDemandElement::setAttribute
virtual void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)=0
method for setting the attribute and letting the object perform demand element changes
SUMOVTypeParameter::speedFactor
Distribution_Parameterized speedFactor
The factor by which the maximum speed may deviate from the allowed max speed on the street.
Definition: SUMOVTypeParameter.h:231
GNEVehicleType::getHierarchyName
std::string getHierarchyName() const
get Hierarchy Name (Used in AC Hierarchy)
Definition: GNEVehicleType.cpp:868
PollutantsInterface::getClassByName
static SUMOEmissionClass getClassByName(const std::string &eClass, const SUMOVehicleClass vc=SVC_IGNORING)
Checks whether the string describes a known vehicle class.
Definition: PollutantsInterface.cpp:53
Parameterised::setParametersStr
void setParametersStr(const std::string &paramsString)
set the inner key/value map in string format "key1=value1|key2=value2|...|keyN=valueN"
Definition: Parameterised.cpp:139
GNEViewParent.h
SUMOVTypeParameter::VClassDefaultValues::osgFile
std::string osgFile
3D model file for this class
Definition: SUMOVTypeParameter.h:124
SUMO_ATTR_JM_CROSSING_GAP
@ SUMO_ATTR_JM_CROSSING_GAP
Definition: SUMOXMLDefinitions.h:613
VTYPEPARS_LOADING_DURATION
const int VTYPEPARS_LOADING_DURATION
Definition: SUMOVTypeParameter.h:63
SUMOVTypeParameter::VClassDefaultValues::locomotiveLength
double locomotiveLength
the length of train locomotive
Definition: SUMOVTypeParameter.h:130
SUMO_ATTR_HEIGHT
@ SUMO_ATTR_HEIGHT
Definition: SUMOXMLDefinitions.h:789
VTYPEPARS_CONTAINER_CAPACITY
const int VTYPEPARS_CONTAINER_CAPACITY
Definition: SUMOVTypeParameter.h:62
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:47
GNEVehicleType::getColor
const RGBColor & getColor() const
get color
Definition: GNEVehicleType.cpp:114
SUMO_ATTR_CF_PWAGNER2009_TAULAST
@ SUMO_ATTR_CF_PWAGNER2009_TAULAST
Definition: SUMOXMLDefinitions.h:834
GNEVehicleType::getAttributeDouble
double getAttributeDouble(SumoXMLAttr key) const
Definition: GNEVehicleType.cpp:491
GNESelectorFrame.h
GNEAttributeCarrier::TagProperties::getDefaultValue
const std::string & getDefaultValue(SumoXMLAttr attr) const
return the default value of the attribute of an element
Definition: GNEAttributeCarrier.cpp:574
SUMOVTypeParameter::carriageGap
double carriageGap
Definition: SUMOVTypeParameter.h:304
SUMO_ATTR_TRAIN_TYPE
@ SUMO_ATTR_TRAIN_TYPE
Definition: SUMOXMLDefinitions.h:583
SUMO_ATTR_SIGMA
@ SUMO_ATTR_SIGMA
Definition: SUMOXMLDefinitions.h:548
SUMOVTypeParameter::latAlignment
LateralAlignment latAlignment
The vehicles desired lateral alignment.
Definition: SUMOVTypeParameter.h:296
SUMO_ATTR_CAR_FOLLOW_MODEL
@ SUMO_ATTR_CAR_FOLLOW_MODEL
Definition: SUMOXMLDefinitions.h:457
SUMO_ATTR_IMPATIENCE
@ SUMO_ATTR_IMPATIENCE
Definition: SUMOXMLDefinitions.h:796
Parameterised::areParametersValid
static bool areParametersValid(const std::string &value, bool report=false)
check if given string can be parsed to a parameters map "key1=value1|key2=value2|....
Definition: Parameterised.cpp:166
Parameterised::unsetParameter
void unsetParameter(const std::string &key)
Removes a parameter.
Definition: Parameterised.cpp:52
SUMOXMLDefinitions::TrainTypes
static StringBijection< TrainType > TrainTypes
train types
Definition: SUMOXMLDefinitions.h:1407
SUMO_ATTR_LCA_TIME_TO_IMPATIENCE
@ SUMO_ATTR_LCA_TIME_TO_IMPATIENCE
Definition: SUMOXMLDefinitions.h:598
InvalidArgument
Definition: UtilExceptions.h:56
SUMO_ATTR_GUISHAPE
@ SUMO_ATTR_GUISHAPE
Definition: SUMOXMLDefinitions.h:790
SUMOVTypeParameter::VClassDefaultValues
struct for default values that depend of VClass
Definition: SUMOVTypeParameter.h:89
SUMOXMLDefinitions::isValidVehicleID
static bool isValidVehicleID(const std::string &value)
whether the given string is a valid id for a vehicle or flow
Definition: SUMOXMLDefinitions.cpp:973
SUMO_ATTR_K
@ SUMO_ATTR_K
Definition: SUMOXMLDefinitions.h:819
GNEVehicleType::isValid
bool isValid(SumoXMLAttr key, const std::string &value)
method for checking if the key and their conrrespond attribute are valids
Definition: GNEVehicleType.cpp:640
VTYPEPARS_PERSON_CAPACITY
const int VTYPEPARS_PERSON_CAPACITY
Definition: SUMOVTypeParameter.h:60
SUMO_ATTR_CARRIAGE_LENGTH
@ SUMO_ATTR_CARRIAGE_LENGTH
Definition: SUMOXMLDefinitions.h:1014
GNEVehicleType::initRailVisualizationParameters
void initRailVisualizationParameters()
init Rail Visualization Parameters
Definition: GNEVehicleType.cpp:1134
GNEVehicleType::overwriteVType
static void overwriteVType(GNEDemandElement *vType, SUMOVTypeParameter *newVTypeParameter, GNEUndoList *undoList)
overwrite all values of GNEVehicleType with a SUMOVTypeParameter
Definition: GNEVehicleType.cpp:874
gSelected
GUISelectedStorage gSelected
A global holder of selected objects.
Definition: GUIGlobalSelection.cpp:33
GNEDemandElement::getDemandElementID
const std::string & getDemandElementID() const
returns DemandElement ID
Definition: GNEDemandElement.cpp:369
SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME
@ SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME
Definition: SUMOXMLDefinitions.h:615
VTYPEPARS_HEIGHT_SET
const int VTYPEPARS_HEIGHT_SET
Definition: SUMOVTypeParameter.h:54
SUMO_ATTR_EMERGENCYDECEL
@ SUMO_ATTR_EMERGENCYDECEL
Definition: SUMOXMLDefinitions.h:447
SVS_TRUCK_SEMITRAILER
@ SVS_TRUCK_SEMITRAILER
render as a semi-trailer transport vehicle ("Sattelschlepper")
Definition: SUMOVehicleClass.h:78
SUMO_ATTR_VCLASS
@ SUMO_ATTR_VCLASS
Definition: SUMOXMLDefinitions.h:450
Parameterised::setParameter
void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
Definition: Parameterised.cpp:46
SUMOVTypeParameter::VClassDefaultValues::personCapacity
int personCapacity
The person capacity of the vehicle.
Definition: SUMOVTypeParameter.h:118
GNEVehicleType::moveGeometry
void moveGeometry(const Position &offset)
change the position of the element geometry without saving in undoList
Definition: GNEVehicleType.cpp:132
SUMOVTypeParameter::lcModel
LaneChangeModel lcModel
The lane-change model to use.
Definition: SUMOVTypeParameter.h:290
VTYPEPARS_IMGFILE_SET
const int VTYPEPARS_IMGFILE_SET
Definition: SUMOVTypeParameter.h:57
getVehicleShapeID
SUMOVehicleShape getVehicleShapeID(const std::string &name)
Returns the class id of the shape class given by its name.
Definition: SUMOVehicleClass.cpp:342
SUMO_ATTR_MINGAP
@ SUMO_ATTR_MINGAP
Definition: SUMOXMLDefinitions.h:458
GNEAttributeCarrier::TagProperties::getAttributeProperties
const AttributeProperties & getAttributeProperties(SumoXMLAttr attr) const
get attribute (throw error if doesn't exist)
Definition: GNEAttributeCarrier.cpp:623
SUMOVTypeParameter::getCFParamString
std::string getCFParamString(const SumoXMLAttr attr, const std::string defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition: SUMOVTypeParameter.cpp:468
GNEVehicleType::updateDefaultVClassAttributes
void updateDefaultVClassAttributes(const VClassDefaultValues &defaultValues)
function called after set new VClass
Definition: GNEVehicleType.cpp:1659
StringBijection::hasString
bool hasString(const std::string &str) const
Definition: StringBijection.h:116
GNEVehicleType::isAttributeEnabled
bool isAttributeEnabled(SumoXMLAttr key) const
Definition: GNEVehicleType.cpp:825
SUMO_ATTR_ACTIONSTEPLENGTH
@ SUMO_ATTR_ACTIONSTEPLENGTH
Definition: SUMOXMLDefinitions.h:449
GNEVehicleType.h
StringTokenizer.h
SUMOVTypeParameter::loadingDuration
SUMOTime loadingDuration
The time a container needs to get loaded on the vehicle.
Definition: SUMOVTypeParameter.h:255
SUMOVTypeParameter::color
RGBColor color
The color.
Definition: SUMOVTypeParameter.h:237
SUMO_ATTR_LOCOMOTIVE_LENGTH
@ SUMO_ATTR_LOCOMOTIVE_LENGTH
Definition: SUMOXMLDefinitions.h:1015
PollutantsInterface::getAllClassesStr
static const std::vector< std::string > & getAllClassesStr()
Get all SUMOEmissionClass in string format.
Definition: PollutantsInterface.cpp:82
SVS_TRUCK_1TRAILER
@ SVS_TRUCK_1TRAILER
render as a transport vehicle with one trailer
Definition: SUMOVehicleClass.h:80
GNEVehicleType::getPositionInView
Position getPositionInView() const
Returns position of additional in view.
Definition: GNEVehicleType.cpp:174
VTYPEPARS_LENGTH_SET
const int VTYPEPARS_LENGTH_SET
Definition: SUMOVTypeParameter.h:45
SUMO_ATTR_TMP4
@ SUMO_ATTR_TMP4
Definition: SUMOXMLDefinitions.h:553
SUMOXMLDefinitions::LateralAlignments
static StringBijection< LateralAlignment > LateralAlignments
lateral alignments
Definition: SUMOXMLDefinitions.h:1401
GNEVehicleType::myDefaultVehicleTypeModified
bool myDefaultVehicleTypeModified
flag to check if this default GNEVehicleType was modified
Definition: GNEVehicleType.h:200
GNESelectorFrame::LockGLObjectTypes::removeLockedObject
void removeLockedObject(const GUIGlObjectType type)
set object unselected
Definition: GNESelectorFrame.cpp:573
GNEAttributeCarrier::getTagStr
const std::string & getTagStr() const
get tag assigned to this object in string format
Definition: GNEAttributeCarrier.cpp:1267
SUMOVTypeParameter::emissionClass
SUMOEmissionClass emissionClass
The emission class of this vehicle.
Definition: SUMOVTypeParameter.h:234
GNEUndoList
Definition: GNEUndoList.h:48
GUIVisualizationSettings
Stores the information about how to visualize structures.
Definition: GUIVisualizationSettings.h:345
VTYPEPARS_EMISSIONCLASS_SET
const int VTYPEPARS_EMISSIONCLASS_SET
Definition: SUMOVTypeParameter.h:50
VTYPEPARS_COLOR_SET
const int VTYPEPARS_COLOR_SET
Definition: SUMOVTypeParameter.h:51
VTYPEPARS_SHAPE_SET
const int VTYPEPARS_SHAPE_SET
Definition: SUMOVTypeParameter.h:55
SUMOVTypeParameter::VClassDefaultValues::height
double height
This class' height.
Definition: SUMOVTypeParameter.h:106
GNEUndoList::p_begin
void p_begin(const std::string &description)
Begin undo command sub-group. This begins a new group of commands that are treated as a single comman...
Definition: GNEUndoList.cpp:72
SumoXMLAttr
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
Definition: SUMOXMLDefinitions.h:372
DEFAULT_BIKETYPE_ID
const std::string DEFAULT_BIKETYPE_ID
VTYPEPARS_WIDTH_SET
const int VTYPEPARS_WIDTH_SET
Definition: SUMOVTypeParameter.h:53
GUIGlObject::getMicrosimID
virtual const std::string & getMicrosimID() const
Returns the id of the object as known to microsim.
Definition: GUIGlObject.cpp:163
GNEVehicleType::drawGL
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
Definition: GNEVehicleType.cpp:199
SUMOVTypeParameter::vehicleClass
SUMOVehicleClass vehicleClass
The vehicle's class.
Definition: SUMOVTypeParameter.h:240
VTYPEPARS_IMPATIENCE_SET
const int VTYPEPARS_IMPATIENCE_SET
Definition: SUMOVTypeParameter.h:58
SUMO_ATTR_EMISSIONCLASS
@ SUMO_ATTR_EMISSIONCLASS
Definition: SUMOXMLDefinitions.h:795
SUMOVTypeParameter::VClassDefaultValues::speedFactor
Distribution_Parameterized speedFactor
The factor by which the maximum speed may deviate from the allowed max speed on the street.
Definition: SUMOVTypeParameter.h:115
VTYPEPARS_MAXSPEED_SET
const int VTYPEPARS_MAXSPEED_SET
Definition: SUMOVTypeParameter.h:47
GNEChange_Attribute.h
GNENet.h
SUMO_ATTR_LCA_PUSHY
@ SUMO_ATTR_LCA_PUSHY
Definition: SUMOXMLDefinitions.h:594
GUISelectedStorage::deselect
void deselect(GUIGlID id)
Deselects the object with the given id.
Definition: GUISelectedStorage.cpp:130
GNEViewNet::getViewParent
GNEViewParent * getViewParent() const
get the net object
Definition: GNEViewNet.cpp:1008
GNESelectorFrame::getLockGLObjectTypes
LockGLObjectTypes * getLockGLObjectTypes() const
get selected items Modul
Definition: GNESelectorFrame.cpp:459
GNEVehicleType::getAttribute
std::string getAttribute(SumoXMLAttr key) const
Definition: GNEVehicleType.cpp:236
Parameterised::knowsParameter
bool knowsParameter(const std::string &key) const
Returns whether the parameter is known.
Definition: Parameterised.cpp:66
VTYPEPARS_VEHICLECLASS_SET
const int VTYPEPARS_VEHICLECLASS_SET
Definition: SUMOVTypeParameter.h:52
SUMO_ATTR_CF_KERNER_PHI
@ SUMO_ATTR_CF_KERNER_PHI
Definition: SUMOXMLDefinitions.h:840
GNEUndoList.h
SUMO_ATTR_TAU
@ SUMO_ATTR_TAU
Definition: SUMOXMLDefinitions.h:549
SUMO_ATTR_CF_IDMM_ADAPT_TIME
@ SUMO_ATTR_CF_IDMM_ADAPT_TIME
Definition: SUMOXMLDefinitions.h:839
SUMO_ATTR_LCA_ACCEL_LAT
@ SUMO_ATTR_LCA_ACCEL_LAT
Definition: SUMOXMLDefinitions.h:599
SUMOVTypeParameter::minGapLat
double minGapLat
The vehicle type's minimum lateral gap [m].
Definition: SUMOVTypeParameter.h:299
SVS_RAIL
@ SVS_RAIL
render as a rail
Definition: SUMOVehicleClass.h:90
SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE
@ SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE
Definition: SUMOXMLDefinitions.h:604
GNESelectorFrame::LockGLObjectTypes::addedLockedObject
void addedLockedObject(const GUIGlObjectType type)
set object selected
Definition: GNESelectorFrame.cpp:567