Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
GNEVType.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2023 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>
27
28#include "GNEVType.h"
30
31
32// ===========================================================================
33// member method definitions
34// ===========================================================================
35
38 GNEPathManager::PathElement::Options::DEMAND_ELEMENT, {}, {}, {}, {}, {}, {}),
40 myDefaultVehicleType(true),
41 myDefaultVehicleTypeModified(false) {
42 // reset default values
43 resetDefaultValues();
44 // init Rail Visualization Parameters
45 initRailVisualizationParameters();
46}
47
48
49GNEVType::GNEVType(GNENet* net, const std::string& vTypeID, const SUMOVehicleClass& defaultVClass) :
51 GNEPathManager::PathElement::Options::DEMAND_ELEMENT, {}, {}, {}, {}, {}, {}),
52 SUMOVTypeParameter(vTypeID),
53 myDefaultVehicleType(true),
54 myDefaultVehicleTypeModified(false) {
55 // set default vehicle class
56 vehicleClass = defaultVClass;
57 // init Rail Visualization Parameters
58 initRailVisualizationParameters();
59}
60
61
62GNEVType::GNEVType(GNENet* net, const SUMOVTypeParameter& vTypeParameter) :
63 GNEDemandElement(vTypeParameter.id, net, GLO_VTYPE, SUMO_TAG_VTYPE, GUIIconSubSys::getIcon(GUIIcon::VTYPE),
64 GNEPathManager::PathElement::Options::DEMAND_ELEMENT, {}, {}, {}, {}, {}, {}),
65 SUMOVTypeParameter(vTypeParameter),
66 myDefaultVehicleType(false),
67 myDefaultVehicleTypeModified(false) {
68 // init Rail Visualization Parameters
69 initRailVisualizationParameters();
70}
71
72
73GNEVType::GNEVType(GNENet* net, const std::string& vTypeID, GNEVType* vTypeOriginal) :
74 GNEDemandElement(vTypeID, net, GLO_VTYPE, vTypeOriginal->getTagProperty().getTag(), GUIIconSubSys::getIcon(GUIIcon::VTYPE),
75 GNEPathManager::PathElement::Options::DEMAND_ELEMENT, {}, {}, {}, {}, {}, {}),
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
95void
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
115std::string
117 return "";
118}
119
120
121void
123 // nothing to fix
124}
125
126
129 return vehicleClass;
130}
131
132
133const RGBColor&
135 return color;
136}
137
138
139void
141 // update geometry of all childrens
142 for (const auto& i : getChildDemandElements()) {
143 i->updateGeometry();
144 }
145}
146
147
150 return Position();
151}
152
153
154std::string
156 return myNet->getMicrosimID();
157}
158
159
162 // Vehicle Types doesn't have boundaries
163 return Boundary(-0.1, -0.1, 0.1, 0.1);
164}
165
166
167void
168GNEVType::splitEdgeGeometry(const double /*splitPosition*/, const GNENetworkElement* /*originalElement*/, const GNENetworkElement* /*newElement*/, GNEUndoList* /*undoList*/) {
169 // geometry of this element cannot be splitted
170}
171
172
173void
175 // Vehicle Types aren't draw
176}
177
178
179void
181 // nothing to compute
182}
183
184
185void
186GNEVType::drawPartialGL(const GUIVisualizationSettings& /*s*/, const GNELane* /*lane*/, const GNEPathManager::Segment* /*segment*/, const double /*offsetFront*/) const {
187 // vehicleTypes don't use drawPartialGL
188}
189
190
191void
192GNEVType::drawPartialGL(const GUIVisualizationSettings& /*s*/, const GNELane* /*fromLane*/, const GNELane* /*toLane*/, const GNEPathManager::Segment* /*segment*/, const double /*offsetFront*/) const {
193 // vehicleTypes don't use drawPartialGL
194}
195
196
197GNELane*
199 // vehicle types don't use lanes
200 return nullptr;
201}
202
203
204GNELane*
206 // vehicle types don't use lanes
207 return nullptr;
208}
209
210
211std::string
213 // obtain default values depending of vehicle class
214 VClassDefaultValues defaultValues(vehicleClass);
215 switch (key) {
216 case SUMO_ATTR_ID:
217 return getMicrosimID();
218 // CFM Attributes
219 case SUMO_ATTR_ACCEL:
220 case SUMO_ATTR_DECEL:
223 case SUMO_ATTR_SIGMA:
224 case SUMO_ATTR_TAU:
225 // this CFM has default values
227 // JM Attributes
237 // this JM has default values
241 return toString(impatience);
242 } else {
244 }
245 // LCM Attributes
266 /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
268 //
295 case SUMO_ATTR_TMP1:
296 case SUMO_ATTR_TMP2:
297 case SUMO_ATTR_TMP3:
298 case SUMO_ATTR_TMP4:
299 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 }
327 return toString(maxSpeed);
328 } else {
329 return toString(defaultValues.maxSpeed);
330 }
333 return toString(speedFactor);
334 } else {
335 return toString(defaultValues.speedFactor);
336 }
340 } else {
341 return toString(defaultValues.desiredMaxSpeed);
342 }
345 return toString(personCapacity);
346 } else {
347 return toString(defaultValues.personCapacity);
348 }
352 } else {
353 return toString(defaultValues.containerCapacity);
354 }
357 return osgFile;
358 } else {
359 return defaultValues.osgFile;
360 }
361 case SUMO_ATTR_COLOR:
363 return toString(color);
364 } else {
365 return "";
366 }
367 case SUMO_ATTR_VCLASS:
369 return toString(vehicleClass);
370 } else {
372 }
376 } else {
377 return PollutantsInterface::getName(defaultValues.emissionClass);
378 }
382 } else {
383 return getVehicleShapeName(defaultValues.shape);
384 }
385 case SUMO_ATTR_WIDTH:
387 return toString(width);
388 } else {
389 return toString(defaultValues.width);
390 }
391 case SUMO_ATTR_HEIGHT:
393 return toString(height);
394 } else {
395 return toString(defaultValues.height);
396 }
399 return imgFile;
400 } else {
402 }
406 } else {
408 }
412 } else {
414 }
418 } else {
420 }
424 } else {
426 }
431 } else {
433 }
434 } else {
435 return toString(defaultValues.latAlignmentProcedure);
436 }
439 return toString(minGapLat);
440 } else {
442 }
445 return toString(maxSpeedLat);
446 } else {
448 }
452 } else {
454 }
455 case SUMO_ATTR_PROB:
458 } else {
460 }
463 return toString(carriageLength);
464 } else {
465 return toString(defaultValues.carriageLength);
466 }
470 } else {
471 return toString(defaultValues.locomotiveLength);
472 }
475 return toString(carriageGap);
476 } else {
478 }
480 std::string distributionIDs;
481 for (const auto &distribution : myDistributions) {
482 distributionIDs.append(distribution.first + " ");
483 }
484 // remove last space
485 if (distributionIDs.size() > 0) {
486 distributionIDs.pop_back();
487 }
488 return distributionIDs;
489 }
491 std::string distributionProbabilities;
492 for (const auto &distribution : myDistributions) {
493 distributionProbabilities.append(toString(distribution.second) + " ");
494 }
495 // remove last space
496 if (distributionProbabilities.size() > 0) {
497 distributionProbabilities.pop_back();
498 }
499 return distributionProbabilities;
500 }
504 return getParametersStr();
505 // other
511 } else {
512 return False;
513 }
514 default:
515 throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
516 }
517}
518
519
520double
522 // obtain default values depending of vehicle class
523 VClassDefaultValues defaultValues(vehicleClass);
524 switch (key) {
525 case SUMO_ATTR_LENGTH:
527 return length;
528 } else {
529 return defaultValues.length;
530 }
531 case SUMO_ATTR_MINGAP:
533 return minGap;
534 } else {
535 return defaultValues.minGap;
536 }
537 case SUMO_ATTR_WIDTH:
539 return width;
540 } else {
541 return defaultValues.width;
542 }
543 case SUMO_ATTR_HEIGHT:
545 return height;
546 } else {
547 return defaultValues.height;
548 }
551 return maxSpeed;
552 } else {
553 return defaultValues.maxSpeed;
554 }
555 default:
556 throw InvalidArgument(getTagStr() + " doesn't have a double attribute of type '" + toString(key) + "'");
557 }
558}
559
560
563 throw InvalidArgument(getTagStr() + " doesn't have a Position attribute of type '" + toString(key) + "'");
564}
565
566
567void
568GNEVType::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) {
569 GNEChange_Attribute* vTypeChangeAttributeForced = nullptr;
570 if (value == getAttribute(key)) {
571 return; //avoid needless changes, later logic relies on the fact that attributes have changed
572 }
573 switch (key) {
574 case SUMO_ATTR_ID:
575 undoList->changeAttribute(new GNEChange_Attribute(this, key, value));
576 break;
577 // CFM Attributes
578 case SUMO_ATTR_ACCEL:
579 case SUMO_ATTR_DECEL:
582 case SUMO_ATTR_SIGMA:
583 case SUMO_ATTR_TAU:
585 case SUMO_ATTR_TMP1:
586 case SUMO_ATTR_TMP2:
587 case SUMO_ATTR_TMP3:
588 case SUMO_ATTR_TMP4:
589 case SUMO_ATTR_TMP5:
612 case SUMO_ATTR_K:
625 // JM Attributes
636 // LCM Attributes
657 /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
658 //
659 case SUMO_ATTR_LENGTH:
660 case SUMO_ATTR_MINGAP:
664 case SUMO_ATTR_COLOR:
665 case SUMO_ATTR_VCLASS:
668 case SUMO_ATTR_WIDTH:
669 case SUMO_ATTR_HEIGHT:
681 case SUMO_ATTR_PROB:
690 // if we change the original value of a default vehicle Type, change also flag "myDefaultVehicleType"
692 vTypeChangeAttributeForced = new GNEChange_Attribute(this, GNE_ATTR_DEFAULT_VTYPE_MODIFIED, "true");
693 // force change
694 vTypeChangeAttributeForced->forceChange();
695 undoList->changeAttribute(vTypeChangeAttributeForced);
696 }
697 vTypeChangeAttributeForced = new GNEChange_Attribute(this, key, value);
698 // force change
699 vTypeChangeAttributeForced->forceChange();
700 undoList->changeAttribute(vTypeChangeAttributeForced);
701 break;
703 vTypeChangeAttributeForced = new GNEChange_Attribute(this, GNE_ATTR_DEFAULT_VTYPE_MODIFIED, "true");
704 // force change
705 vTypeChangeAttributeForced->forceChange();
706 undoList->changeAttribute(vTypeChangeAttributeForced);
707 break;
708 default:
709 throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
710 }
711}
712
713
714bool
715GNEVType::isValid(SumoXMLAttr key, const std::string& value) {
716 // a empty value is always valid except for IDs
717 if ((key != SUMO_ATTR_ID) && value.empty()) {
718 return true;
719 }
720 switch (key) {
721 case SUMO_ATTR_ID:
722 if (value == getID()) {
723 return true;
724 } else if (SUMOXMLDefinitions::isValidVehicleID(value)) {
726 } else {
727 return false;
728 }
729 // CFM Attributes
730 case SUMO_ATTR_SIGMA:
731 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
732 case SUMO_ATTR_ACCEL:
733 case SUMO_ATTR_DECEL:
736 case SUMO_ATTR_TAU:
738 case SUMO_ATTR_TMP1:
739 case SUMO_ATTR_TMP2:
740 case SUMO_ATTR_TMP3:
741 case SUMO_ATTR_TMP4:
742 case SUMO_ATTR_TMP5:
749 case SUMO_ATTR_K:
762 return canParse<double>(value);
764 return canParse<bool>(value);
766 return canParse<int>(value) && (parse<int>(value) >= 0);
768 return canParse<double>(value) && (parse<double>(value) >= 1);
770 return canParse<double>(value) && (parse<double>(value) >= 1);
772 return canParse<double>(value) && (parse<double>(value) >= 0);
774 return canParse<double>(value) && (parse<double>(value) >= 1);
776 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
778 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
780 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
782 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
784 return canParse<double>(value) && (parse<double>(value) >= 1);
786 return canParse<double>(value) && (parse<double>(value) >= 0);
788 return canParse<double>(value) && (parse<double>(value) >= 0);
790 return canParse<double>(value) && (parse<double>(value) >= 1) && (parse<double>(value) <= 5);
792 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1.5);
794 // rail string
796 // JM Attributes
798 return canParse<double>(value) && (parse<double>(value) >= 0);
800 return canParse<double>(value) && (parse<double>(value) >= -1);
802 return canParse<double>(value) && (parse<double>(value) >= -1);
804 return canParse<double>(value) && (parse<double>(value) >= -1);
806 return canParse<double>(value) && (parse<double>(value) >= 0);
808 return canParse<double>(value) && (parse<double>(value) >= 0);
810 return canParse<double>(value) && (parse<double>(value) >= 0);
812 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
814 return canParse<double>(value) && (parse<double>(value) >= 0);
816 return canParse<double>(value) && (parse<double>(value) >= 0);
817 // LCM Attributes
825 return canParse<double>(value);
829 case SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE: // 0 mean disabled
830 case SUMO_ATTR_LCA_TIME_TO_IMPATIENCE: // 0 mean disabled
831 case SUMO_ATTR_LCA_OVERTAKE_RIGHT: // 0 mean disabled
832 return canParse<double>(value) && (parse<double>(value) >= 0);
838 return canParse<double>(value) && (parse<double>(value) > 0);
840 return canParse<double>(value) && (parse<double>(value) >= 0 || parse<double>(value) == -1);
842 return canParse<double>(value) && (parse<double>(value) >= -1) && (parse<double>(value) <= 1);
843 /* case SUMO_ATTR_LCA_EXPERIMENTAL1:
844 return true;
845 */
846 //
847 case SUMO_ATTR_LENGTH:
848 return canParse<double>(value) && (parse<double>(value) > 0);
849 case SUMO_ATTR_MINGAP:
850 return canParse<double>(value) && (parse<double>(value) >= 0);
852 return canParse<double>(value) && (parse<double>(value) >= 0);
856 return canParse<double>(value) && (parse<double>(value) >= 0);
857 case SUMO_ATTR_COLOR:
858 if (value.empty()) {
859 return true;
860 } else {
861 return canParse<RGBColor>(value);
862 }
863 case SUMO_ATTR_VCLASS:
864 return canParseVehicleClasses(value);
866 // check if given value correspond to a string of PollutantsInterface::getAllClassesStr()
867 for (const auto& eClass : PollutantsInterface::getAllClassesStr()) {
868 if (value == eClass) {
869 return true;
870 }
871 }
872 return false;
874 if (value == "all") {
875 return false;
876 } else {
877 return canParseVehicleShape(value);
878 }
879 case SUMO_ATTR_WIDTH:
880 return canParse<double>(value);
881 case SUMO_ATTR_HEIGHT:
882 return canParse<double>(value);
890 return canParse<int>(value);
892 return canParse<int>(value);
894 return canParse<double>(value);
896 return canParse<double>(value);
900 return canParse<double>(value);
902 return canParse<double>(value);
904 return canParse<double>(value) && (parse<double>(value) >= 0);
905 case SUMO_ATTR_PROB:
906 return canParse<double>(value) && (parse<double>(value) >= 0);
910 return canParse<double>(value) && (parse<double>(value) >= -1);
912 return canParse<double>(value) && (parse<double>(value) >= -1);
914 return canParse<double>(value) && (parse<double>(value) >= 0);
916 if (value.empty()) {
917 return true;
918 } else {
919 auto typeDistributionIDs = StringTokenizer(value).getVector();
920 // check every id
921 for (const auto &typeDistributionID : typeDistributionIDs) {
922 if (myNet->getAttributeCarriers()->retrieveDemandElement(SUMO_TAG_VTYPE_DISTRIBUTION, typeDistributionID, false) == nullptr) {
923 return false;
924 }
925 }
926 // all ids OK
927 return true;
928 }
930 auto typeDistributionProbs = StringTokenizer(value).getVector();
931 // first check that we have the same number of distributions and probabilities
932 if (typeDistributionProbs.size() != myDistributions.size()) {
933 return false;
934 } else {
935 // check every probability
936 for (const auto &typeDistributionProb : typeDistributionProbs) {
937 if (canParse<double>(typeDistributionProb)) {
938 const auto prob = parse<double>(typeDistributionProb);
939 if ((prob < 0) || (prob > 1)) {
940 return false;
941 }
942 } else {
943 return false;
944 }
945 }
946 // all probabilities ok
947 return true;
948 }
949 }
951 return canParse<bool>(value);
956 return canParse<bool>(value);
957 } else {
958 return false;
959 }
960 default:
961 throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
962 }
963}
964
965
966bool
968 switch (key) {
969 case SUMO_ATTR_ID:
970 if (id == DEFAULT_VTYPE_ID
971 || id == DEFAULT_PEDTYPE_ID
972 || id == DEFAULT_BIKETYPE_ID
973 || id == DEFAULT_TAXITYPE_ID
974 || id == DEFAULT_RAILTYPE_ID) {
975 return false;
976 } else {
977 return true;
978 }
979 case SUMO_ATTR_LENGTH:
981 case SUMO_ATTR_MINGAP:
1002 return (myDistributions.size() > 0);
1003 default:
1004 return true;
1005 }
1006}
1007
1008
1009std::string
1011 return getTagStr();
1012}
1013
1014
1015std::string
1017 return getTagStr() + ": " + getAttribute(SUMO_ATTR_ID) ;
1018}
1019
1020
1021const Parameterised::Map&
1023 return getParametersMap();
1024}
1025
1026
1027void
1029 // open undo list and overwrite all values of default VType
1030 undoList->begin(vType->getTagProperty().getGUIIcon(), "update default " + vType->getTagStr() + " '" + DEFAULT_VTYPE_ID + "'");
1031 // CFM values
1032 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_ACCEL, "").empty()) {
1033 vType->setAttribute(SUMO_ATTR_ACCEL, toString(newVTypeParameter.getCFParam(SUMO_ATTR_ACCEL, 0)), undoList);
1034 }
1035 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_DECEL, "").empty()) {
1036 vType->setAttribute(SUMO_ATTR_DECEL, toString(newVTypeParameter.getCFParam(SUMO_ATTR_DECEL, 0)), undoList);
1037 }
1038 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_APPARENTDECEL, "").empty()) {
1039 vType->setAttribute(SUMO_ATTR_APPARENTDECEL, toString(newVTypeParameter.getCFParam(SUMO_ATTR_APPARENTDECEL, 0)), undoList);
1040 }
1041 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_EMERGENCYDECEL, "").empty()) {
1042 vType->setAttribute(SUMO_ATTR_EMERGENCYDECEL, toString(newVTypeParameter.getCFParam(SUMO_ATTR_EMERGENCYDECEL, 0)), undoList);
1043 }
1044 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_SIGMA, "").empty()) {
1045 vType->setAttribute(SUMO_ATTR_SIGMA, toString(newVTypeParameter.getCFParam(SUMO_ATTR_SIGMA, 0)), undoList);
1046 }
1047 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TAU, "").empty()) {
1048 vType->setAttribute(SUMO_ATTR_TAU, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TAU, 0)), undoList);
1049 }
1050 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_COLLISION_MINGAP_FACTOR, "").empty()) {
1052 }
1053 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP1, "").empty()) {
1054 vType->setAttribute(SUMO_ATTR_TMP1, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP1, 0)), undoList);
1055 }
1056 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP2, "").empty()) {
1057 vType->setAttribute(SUMO_ATTR_TMP2, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP2, 0)), undoList);
1058 }
1059 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP3, "").empty()) {
1060 vType->setAttribute(SUMO_ATTR_TMP3, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP3, 0)), undoList);
1061 }
1062 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP4, "").empty()) {
1063 vType->setAttribute(SUMO_ATTR_TMP4, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP4, 0)), undoList);
1064 }
1065 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP5, "").empty()) {
1066 vType->setAttribute(SUMO_ATTR_TMP5, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP5, 0)), undoList);
1067 }
1068 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS, "").empty()) {
1070 }
1071 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW, "").empty()) {
1073 }
1074 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD, "").empty()) {
1076 }
1077 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE, "").empty()) {
1079 }
1080 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_REACTION, "").empty()) {
1082 }
1083 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE, "").empty()) {
1085 }
1086 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_C_COOLNESS, "").empty()) {
1088 }
1089 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_SIG_LEADER, "").empty()) {
1091 }
1092 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_SIG_GAP, "").empty()) {
1094 }
1095 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_SIG_ERROR, "").empty()) {
1097 }
1098 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_JERK_MAX, "").empty()) {
1100 }
1101 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_EPSILON_ACC, "").empty()) {
1103 }
1104 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_ACC_MAX, "").empty()) {
1106 }
1107 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_M_FLATNESS, "").empty()) {
1109 }
1110 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_M_BEGIN, "").empty()) {
1112 }
1113 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_W99_CC1, "").empty()) {
1114 vType->setAttribute(SUMO_ATTR_CF_W99_CC1, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_W99_CC1, 0)), undoList);
1115 }
1116 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_W99_CC2, "").empty()) {
1117 vType->setAttribute(SUMO_ATTR_CF_W99_CC2, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_W99_CC2, 0)), undoList);
1118 }
1119 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_W99_CC3, "").empty()) {
1120 vType->setAttribute(SUMO_ATTR_CF_W99_CC3, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_W99_CC3, 0)), undoList);
1121 }
1122 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_W99_CC4, "").empty()) {
1123 vType->setAttribute(SUMO_ATTR_CF_W99_CC4, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_W99_CC4, 0)), undoList);
1124 }
1125 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_W99_CC5, "").empty()) {
1126 vType->setAttribute(SUMO_ATTR_CF_W99_CC5, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_W99_CC5, 0)), undoList);
1127 }
1128 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_W99_CC6, "").empty()) {
1129 vType->setAttribute(SUMO_ATTR_CF_W99_CC6, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_W99_CC6, 0)), undoList);
1130 }
1131 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_W99_CC7, "").empty()) {
1132 vType->setAttribute(SUMO_ATTR_CF_W99_CC7, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_W99_CC7, 0)), undoList);
1133 }
1134 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_W99_CC8, "").empty()) {
1135 vType->setAttribute(SUMO_ATTR_CF_W99_CC8, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_W99_CC8, 0)), undoList);
1136 }
1137 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_W99_CC9, "").empty()) {
1138 vType->setAttribute(SUMO_ATTR_CF_W99_CC9, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_W99_CC9, 0)), undoList);
1139 }
1140 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_PWAGNER2009_TAULAST, "").empty()) {
1142 }
1143 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_PWAGNER2009_APPROB, "").empty()) {
1145 }
1146 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_IDMM_ADAPT_FACTOR, "").empty()) {
1148 }
1149 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_IDMM_ADAPT_TIME, "").empty()) {
1151 }
1152 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_WIEDEMANN_SECURITY, "").empty()) {
1154 }
1155 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_WIEDEMANN_ESTIMATION, "").empty()) {
1157 }
1158 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TRAIN_TYPE, "").empty()) {
1159 vType->setAttribute(SUMO_ATTR_TRAIN_TYPE, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TRAIN_TYPE, 0)), undoList);
1160 }
1161 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_K, "").empty()) {
1162 vType->setAttribute(SUMO_ATTR_K, toString(newVTypeParameter.getCFParam(SUMO_ATTR_K, 0)), undoList);
1163 }
1164 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_KERNER_PHI, "").empty()) {
1165 vType->setAttribute(SUMO_ATTR_CF_KERNER_PHI, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_KERNER_PHI, 0)), undoList);
1166 }
1167 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_IDM_DELTA, "").empty()) {
1168 vType->setAttribute(SUMO_ATTR_CF_IDM_DELTA, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_IDM_DELTA, 0)), undoList);
1169 }
1170 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_IDM_STEPPING, "").empty()) {
1172 }
1173 // JM values
1174 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_CROSSING_GAP, "").empty()) {
1176 }
1177 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME, "").empty()) {
1179 }
1180 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME, "").empty()) {
1182 }
1183 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME, "").empty()) {
1185 }
1186 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_DRIVE_RED_SPEED, "").empty()) {
1188 }
1189 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_IGNORE_FOE_PROB, "").empty()) {
1191 }
1192 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_IGNORE_FOE_SPEED, "").empty()) {
1194 }
1195 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_SIGMA_MINOR, "").empty()) {
1196 vType->setAttribute(SUMO_ATTR_JM_SIGMA_MINOR, toString(newVTypeParameter.getJMParam(SUMO_ATTR_JM_SIGMA_MINOR, 0)), undoList);
1197 }
1198 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_TIMEGAP_MINOR, "").empty()) {
1200 }
1201 if (newVTypeParameter.wasSet(VTYPEPARS_IMPATIENCE_SET)) {
1202 vType->setAttribute(SUMO_ATTR_IMPATIENCE, toString(newVTypeParameter.impatience), undoList);
1203 }
1204 // LCM values
1205 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_STRATEGIC_PARAM, "").empty()) {
1207 }
1208 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_COOPERATIVE_PARAM, "").empty()) {
1210 }
1211 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_SPEEDGAIN_PARAM, "").empty()) {
1213 }
1214 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_KEEPRIGHT_PARAM, "").empty()) {
1216 }
1217 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_SUBLANE_PARAM, "").empty()) {
1219 }
1220 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_OPPOSITE_PARAM, "").empty()) {
1222 }
1223 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_PUSHY, "").empty()) {
1224 vType->setAttribute(SUMO_ATTR_LCA_PUSHY, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_PUSHY, 0)), undoList);
1225 }
1226 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_PUSHYGAP, "").empty()) {
1227 vType->setAttribute(SUMO_ATTR_LCA_PUSHYGAP, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_PUSHYGAP, 0)), undoList);
1228 }
1229 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_ASSERTIVE, "").empty()) {
1230 vType->setAttribute(SUMO_ATTR_LCA_ASSERTIVE, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_ASSERTIVE, 0)), undoList);
1231 }
1232 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_IMPATIENCE, "").empty()) {
1233 vType->setAttribute(SUMO_ATTR_LCA_IMPATIENCE, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_IMPATIENCE, 0)), undoList);
1234 }
1235 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_TIME_TO_IMPATIENCE, "").empty()) {
1237 }
1238 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_ACCEL_LAT, "").empty()) {
1239 vType->setAttribute(SUMO_ATTR_LCA_ACCEL_LAT, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_ACCEL_LAT, 0)), undoList);
1240 }
1241 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_LOOKAHEADLEFT, "").empty()) {
1243 }
1244 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_SPEEDGAINRIGHT, "").empty()) {
1246 }
1247 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_MAXSPEEDLATSTANDING, "").empty()) {
1249 }
1250 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_MAXSPEEDLATFACTOR, "").empty()) {
1252 }
1253 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE, "").empty()) {
1255 }
1256 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_OVERTAKE_RIGHT, "").empty()) {
1258 }
1259 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME, "").empty()) {
1261 }
1262 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR, "").empty()) {
1264 }
1265 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_EXPERIMENTAL1, "").empty()) {
1267 }
1268 // vType parameters
1269 if (newVTypeParameter.wasSet(VTYPEPARS_VEHICLECLASS_SET)) {
1270 vType->setAttribute(SUMO_ATTR_VCLASS, toString(newVTypeParameter.vehicleClass), undoList);
1271 }
1272 if (newVTypeParameter.wasSet(VTYPEPARS_LENGTH_SET)) {
1273 vType->setAttribute(SUMO_ATTR_LENGTH, toString(newVTypeParameter.length), undoList);
1274 }
1275 if (newVTypeParameter.wasSet(VTYPEPARS_MINGAP_SET)) {
1276 vType->setAttribute(SUMO_ATTR_MINGAP, toString(newVTypeParameter.minGap), undoList);
1277 }
1278 if (newVTypeParameter.wasSet(VTYPEPARS_MAXSPEED_SET)) {
1279 vType->setAttribute(SUMO_ATTR_MAXSPEED, toString(newVTypeParameter.maxSpeed), undoList);
1280 }
1281 if (newVTypeParameter.wasSet(VTYPEPARS_SPEEDFACTOR_SET)) {
1282 vType->setAttribute(SUMO_ATTR_SPEEDFACTOR, toString(newVTypeParameter.speedFactor), undoList);
1283 }
1284 if (newVTypeParameter.wasSet(VTYPEPARS_DESIRED_MAXSPEED_SET)) {
1285 vType->setAttribute(SUMO_ATTR_DESIRED_MAXSPEED, toString(newVTypeParameter.desiredMaxSpeed), undoList);
1286 }
1287 if (newVTypeParameter.wasSet(VTYPEPARS_COLOR_SET)) {
1288 vType->setAttribute(SUMO_ATTR_COLOR, toString(newVTypeParameter.color), undoList);
1289 }
1290 if (newVTypeParameter.wasSet(VTYPEPARS_EMISSIONCLASS_SET)) {
1292 }
1293 if (newVTypeParameter.wasSet(VTYPEPARS_SHAPE_SET)) {
1294 vType->setAttribute(SUMO_ATTR_GUISHAPE, getVehicleShapeName(newVTypeParameter.shape), undoList);
1295 }
1296 if (newVTypeParameter.wasSet(VTYPEPARS_WIDTH_SET)) {
1297 vType->setAttribute(SUMO_ATTR_WIDTH, toString(newVTypeParameter.width), undoList);
1298 }
1299 if (newVTypeParameter.wasSet(VTYPEPARS_HEIGHT_SET)) {
1300 vType->setAttribute(SUMO_ATTR_HEIGHT, toString(newVTypeParameter.height), undoList);
1301 }
1302 if (newVTypeParameter.wasSet(VTYPEPARS_IMGFILE_SET)) {
1303 vType->setAttribute(SUMO_ATTR_IMGFILE, toString(newVTypeParameter.imgFile), undoList);
1304 }
1305 if (newVTypeParameter.wasSet(VTYPEPARS_LANE_CHANGE_MODEL_SET)) {
1306 vType->setAttribute(SUMO_ATTR_LANE_CHANGE_MODEL, SUMOXMLDefinitions::LaneChangeModels.getString(newVTypeParameter.lcModel), undoList);
1307 }
1308 if (newVTypeParameter.wasSet(VTYPEPARS_CAR_FOLLOW_MODEL)) {
1309 vType->setAttribute(SUMO_ATTR_CAR_FOLLOW_MODEL, SUMOXMLDefinitions::CarFollowModels.getString(newVTypeParameter.cfModel), undoList);
1310 }
1311 if (newVTypeParameter.wasSet(VTYPEPARS_PERSON_CAPACITY)) {
1312 vType->setAttribute(SUMO_ATTR_PERSON_CAPACITY, toString(newVTypeParameter.personCapacity), undoList);
1313 }
1314 if (newVTypeParameter.wasSet(VTYPEPARS_CONTAINER_CAPACITY)) {
1315 vType->setAttribute(SUMO_ATTR_CONTAINER_CAPACITY, toString(newVTypeParameter.containerCapacity), undoList);
1316 }
1317 if (newVTypeParameter.wasSet(VTYPEPARS_BOARDING_DURATION)) {
1318 vType->setAttribute(SUMO_ATTR_BOARDING_DURATION, toString(newVTypeParameter.boardingDuration), undoList);
1319 }
1320 if (newVTypeParameter.wasSet(VTYPEPARS_LOADING_DURATION)) {
1321 vType->setAttribute(SUMO_ATTR_LOADING_DURATION, toString(newVTypeParameter.loadingDuration), undoList);
1322 }
1323 if (newVTypeParameter.wasSet(VTYPEPARS_LATALIGNMENT_SET)) {
1324 if (newVTypeParameter.latAlignmentProcedure != LatAlignmentDefinition::GIVEN) {
1325 vType->setAttribute(SUMO_ATTR_LATALIGNMENT, toString(newVTypeParameter.latAlignmentProcedure), undoList);
1326 } else {
1327 vType->setAttribute(SUMO_ATTR_LATALIGNMENT, toString(newVTypeParameter.latAlignmentOffset), undoList);
1328 }
1329 }
1330 if (newVTypeParameter.wasSet(VTYPEPARS_MINGAP_LAT_SET)) {
1331 vType->setAttribute(SUMO_ATTR_MINGAP_LAT, toString(newVTypeParameter.minGapLat), undoList);
1332 }
1333 if (newVTypeParameter.wasSet(VTYPEPARS_MAXSPEED_LAT_SET)) {
1334 vType->setAttribute(SUMO_ATTR_MAXSPEED_LAT, toString(newVTypeParameter.maxSpeedLat), undoList);
1335 }
1336 if (newVTypeParameter.wasSet(VTYPEPARS_ACTIONSTEPLENGTH_SET)) {
1337 vType->setAttribute(SUMO_ATTR_ACTIONSTEPLENGTH, toString(newVTypeParameter.actionStepLength), undoList);
1338 }
1339 if (newVTypeParameter.wasSet(VTYPEPARS_PROBABILITY_SET)) {
1340 vType->setAttribute(SUMO_ATTR_PROB, toString(newVTypeParameter.defaultProbability), undoList);
1341 }
1342 if (newVTypeParameter.wasSet(VTYPEPARS_OSGFILE_SET)) {
1343 vType->setAttribute(SUMO_ATTR_OSGFILE, toString(newVTypeParameter.osgFile), undoList);
1344 }
1345 if (newVTypeParameter.knowsParameter(toString(SUMO_ATTR_CARRIAGE_LENGTH))) {
1347 }
1348 if (newVTypeParameter.knowsParameter(toString(SUMO_ATTR_LOCOMOTIVE_LENGTH))) {
1350 }
1351 if (newVTypeParameter.knowsParameter(toString(SUMO_ATTR_CARRIAGE_GAP))) {
1352 vType->setAttribute(SUMO_ATTR_CARRIAGE_GAP, newVTypeParameter.getParameter(toString(SUMO_ATTR_CARRIAGE_GAP), ""), undoList);
1353 }
1354 // parse parameters
1355 std::string parametersStr;
1356 // Generate an string using the following structure: "key1=value1|key2=value2|...
1357 for (const auto& parameter : newVTypeParameter.getParametersMap()) {
1358 parametersStr += parameter.first + "=" + parameter.second + "|";
1359 }
1360 // remove the last "|"
1361 if (!parametersStr.empty()) {
1362 parametersStr.pop_back();
1363 }
1364 if (parametersStr != vType->getAttribute(GNE_ATTR_PARAMETERS)) {
1365 vType->setAttribute(GNE_ATTR_PARAMETERS, parametersStr, undoList);
1366 }
1367 // close undo list
1368 undoList->end();
1369}
1370
1371// ===========================================================================
1372// private
1373// ===========================================================================
1374
1375void
1376GNEVType::setAttribute(SumoXMLAttr key, const std::string& value) {
1377 // obtain default values depending of vehicle class
1378 VClassDefaultValues defaultValues(vehicleClass);
1379 switch (key) {
1380 case SUMO_ATTR_ID:
1381 // update microsimID
1382 setMicrosimID(value);
1383 // manually change VType parameters ID
1384 id = value;
1385 break;
1386 // CFM Attributes
1387 case SUMO_ATTR_ACCEL:
1388 case SUMO_ATTR_DECEL:
1391 case SUMO_ATTR_SIGMA:
1392 case SUMO_ATTR_TAU:
1394 case SUMO_ATTR_TMP1:
1395 case SUMO_ATTR_TMP2:
1396 case SUMO_ATTR_TMP3:
1397 case SUMO_ATTR_TMP4:
1398 case SUMO_ATTR_TMP5:
1406 case SUMO_ATTR_K:
1410 // empty values means that value isn't set
1411 if (value.empty()) {
1412 const auto it = cfParameter.find(key);
1413 if (it != cfParameter.end()) {
1414 cfParameter.erase(it);
1415 }
1416 } else {
1417 cfParameter[key] = value;
1418 }
1419 break;
1444 // empty or default values means that value isn't set
1445 if (value.empty() || (canParse<double>(value) && (parse<double>(value) == parse<double>(myTagProperty.getDefaultValue(key))))) {
1446 const auto it = cfParameter.find(key);
1447 if (it != cfParameter.end()) {
1448 cfParameter.erase(it);
1449 }
1450 } else {
1451 cfParameter[key] = value;
1452 }
1453 break;
1454 // JM Attributes
1464 // empty values means that value isn't set
1465 if (value.empty()) {
1466 const auto it = jmParameter.find(key);
1467 if (it != jmParameter.end()) {
1468 jmParameter.erase(it);
1469 }
1470 } else {
1471 jmParameter[key] = value;
1472 }
1473 break;
1475 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1476 impatience = parse<double>(value);
1477 // mark parameter as set
1479 } else {
1480 // set default value
1481 impatience = parse<double>(myTagProperty.getDefaultValue(key));
1482 // unset parameter
1483 parametersSet &= ~VTYPEPARS_IMPATIENCE_SET;
1484 }
1485 break;
1486 // LCM Attributes
1502
1503 /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
1504 // empty values means that value isn't set
1505 if (value.empty()) {
1506 const auto it = lcParameter.find(key);
1507 if (it != lcParameter.end()) {
1508 lcParameter.erase(it);
1509 }
1510 } else {
1511 lcParameter[key] = value;
1512 }
1513 break;
1515 // empty or -1 value means that value isn't set
1516 if (value.empty() || (canParse<double>(value) && (parse<double>(value) == -1))) {
1517 const auto it = lcParameter.find(key);
1518 if (it != lcParameter.end()) {
1519 lcParameter.erase(it);
1520 }
1521 } else {
1522 lcParameter[key] = value;
1523 }
1524 break;
1529 // empty or null values means that value isn't set
1530 if (value.empty() || (canParse<double>(value) && (parse<double>(value) == 0))) {
1531 const auto it = lcParameter.find(key);
1532 if (it != lcParameter.end()) {
1533 lcParameter.erase(it);
1534 }
1535 } else {
1536 lcParameter[key] = value;
1537 }
1538 break;
1539 //
1540 case SUMO_ATTR_LENGTH:
1541 if (!value.empty() && (value != toString(defaultValues.length))) {
1542 length = parse<double>(value);
1543 // mark parameter as set
1545 } else {
1546 // set default value
1547 length = defaultValues.length;
1548 // unset parameter
1549 parametersSet &= ~VTYPEPARS_LENGTH_SET;
1550 }
1551 break;
1552 case SUMO_ATTR_MINGAP:
1553 if (!value.empty() && (value != toString(defaultValues.minGap))) {
1554 minGap = parse<double>(value);
1555 // mark parameter as set
1557 } else {
1558 // set default value
1559 minGap = defaultValues.minGap;
1560 // unset parameter
1561 parametersSet &= ~VTYPEPARS_MINGAP_SET;
1562 }
1563 break;
1564 case SUMO_ATTR_MAXSPEED:
1565 if (!value.empty() && (value != toString(defaultValues.maxSpeed))) {
1566 maxSpeed = parse<double>(value);
1567 // mark parameter as set
1569 } else {
1570 // set default value
1571 maxSpeed = defaultValues.maxSpeed;
1572 // unset parameter
1573 parametersSet &= ~VTYPEPARS_MAXSPEED_SET;
1574 }
1575 break;
1577 if (!value.empty() && (value != toString(defaultValues.speedFactor))) {
1578 speedFactor.parse(value, false);
1579 // mark parameter as set
1581 } else {
1582 // set default value
1583 speedFactor.parse(toString(defaultValues.speedFactor), false);
1584 // unset parameter
1585 parametersSet &= ~VTYPEPARS_SPEEDFACTOR_SET;
1586 }
1587 break;
1589 if (!value.empty() && (value != toString(defaultValues.desiredMaxSpeed))) {
1590 desiredMaxSpeed = parse<double>(value);
1591 // mark parameter as set
1593 } else {
1594 // set default value
1595 desiredMaxSpeed = defaultValues.desiredMaxSpeed;
1596 // unset parameter
1597 parametersSet &= ~VTYPEPARS_DESIRED_MAXSPEED_SET;
1598 }
1599 break;
1600 case SUMO_ATTR_COLOR:
1601 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1602 color = parse<RGBColor>(value);
1603 // mark parameter as set
1605 } else {
1606 // unset parameter
1607 parametersSet &= ~VTYPEPARS_COLOR_SET;
1608 }
1609 break;
1610 case SUMO_ATTR_VCLASS:
1611 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1613 // mark parameter as set
1615 } else {
1616 // set default value
1618 // unset parameter
1619 parametersSet &= ~VTYPEPARS_VEHICLECLASS_SET;
1620 }
1621 // update default values
1622 updateDefaultVClassAttributes(defaultValues);
1623 break;
1625 if (!value.empty() && (value != toString(defaultValues.emissionClass))) {
1627 // mark parameter as set
1629 } else {
1630 // set default value
1631 emissionClass = defaultValues.emissionClass;
1632 // unset parameter
1633 parametersSet &= ~VTYPEPARS_EMISSIONCLASS_SET;
1634 }
1635 break;
1636 case SUMO_ATTR_GUISHAPE:
1637 if (!value.empty() && (value != SumoVehicleShapeStrings.getString(defaultValues.shape))) {
1638 shape = getVehicleShapeID(value);
1639 // mark parameter as set
1641 } else {
1642 // set default value
1643 shape = defaultValues.shape;
1644 // unset parameter
1645 parametersSet &= ~VTYPEPARS_SHAPE_SET;
1646 }
1647 break;
1648 case SUMO_ATTR_WIDTH:
1649 if (!value.empty() && (value != toString(defaultValues.width))) {
1650 width = parse<double>(value);
1651 // mark parameter as set
1653 } else {
1654 // set default value
1655 width = defaultValues.width;
1656 // unset parameter
1657 parametersSet &= ~VTYPEPARS_WIDTH_SET;
1658 }
1659 break;
1660 case SUMO_ATTR_HEIGHT:
1661 if (!value.empty() && (value != toString(defaultValues.height))) {
1662 height = parse<double>(value);
1663 // mark parameter as set
1665 } else {
1666 // set default value
1667 height = defaultValues.height;
1668 // unset parameter
1669 parametersSet &= ~VTYPEPARS_HEIGHT_SET;
1670 }
1671 break;
1672 case SUMO_ATTR_IMGFILE:
1673 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1674 imgFile = value;
1675 // mark parameter as set
1677 } else {
1678 // set default value
1680 // unset parameter
1681 parametersSet &= ~VTYPEPARS_IMGFILE_SET;
1682 }
1683 break;
1685 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1687 // mark parameter as set
1689 } else {
1690 // set default value
1692 // unset parameter
1693 parametersSet &= ~VTYPEPARS_LANE_CHANGE_MODEL_SET;
1694 }
1695 break;
1697 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1699 // mark parameter as set
1701 } else {
1702 // set default value
1704 // unset parameter
1705 parametersSet &= ~VTYPEPARS_CAR_FOLLOW_MODEL;
1706 }
1707 break;
1709 if (!value.empty() && (value != toString(defaultValues.personCapacity))) {
1710 personCapacity = parse<int>(value);
1711 // mark parameter as set
1713 } else {
1714 // set default value
1715 personCapacity = defaultValues.personCapacity;
1716 // unset parameter
1717 parametersSet &= ~VTYPEPARS_PERSON_CAPACITY;
1718 }
1719 break;
1721 if (!value.empty() && (value != toString(defaultValues.containerCapacity))) {
1722 containerCapacity = parse<int>(value);
1723 // mark parameter as set
1725 } else {
1726 // set default value
1727 containerCapacity = defaultValues.containerCapacity;
1728 // unset parameter
1729 parametersSet &= ~VTYPEPARS_CONTAINER_CAPACITY;
1730 }
1731 break;
1733 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1735 // mark parameter as set
1737 } else {
1738 // set default value
1740 // unset parameter
1741 parametersSet &= ~VTYPEPARS_BOARDING_DURATION;
1742 }
1743 break;
1745 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1747 // mark parameter as set
1749 } else {
1750 // set default value
1752 // unset parameter
1753 parametersSet &= ~VTYPEPARS_LOADING_DURATION;
1754 }
1755 break;
1757 if (!value.empty() && (value != toString(defaultValues.latAlignmentProcedure))) {
1759 // mark parameter as set
1761 } else {
1762 // set default value
1764 // unset parameter
1765 parametersSet &= ~VTYPEPARS_LATALIGNMENT_SET;
1766 }
1767 break;
1769 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1770 minGapLat = parse<double>(value);
1771 // mark parameter as set
1773 } else {
1774 // set default value
1775 minGapLat = parse<double>(myTagProperty.getDefaultValue(key));
1776 // unset parameter
1777 parametersSet &= ~VTYPEPARS_MINGAP_LAT_SET;
1778 }
1779 break;
1781 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1782 maxSpeedLat = parse<double>(value);
1783 // mark parameter as set
1785 } else {
1786 // set default value
1787 maxSpeedLat = parse<double>(myTagProperty.getDefaultValue(key));
1788 // unset parameter
1789 parametersSet &= ~VTYPEPARS_MAXSPEED_LAT_SET;
1790 }
1791 break;
1793 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1795 // mark parameter as set
1797 } else {
1798 // set default value
1800 // unset parameter
1801 parametersSet &= ~VTYPEPARS_ACTIONSTEPLENGTH_SET;
1802 }
1803 break;
1804 case SUMO_ATTR_PROB:
1805 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1806 defaultProbability = parse<double>(value);
1807 // mark parameter as set
1809 } else {
1810 // set default value
1811 defaultProbability = parse<double>(myTagProperty.getDefaultValue(key));
1812 // unset parameter
1813 parametersSet &= ~VTYPEPARS_PROBABILITY_SET;
1814 }
1815 break;
1816 case SUMO_ATTR_OSGFILE:
1817 if (!value.empty() && (value != defaultValues.osgFile)) {
1818 osgFile = value;
1819 // mark parameter as set
1821 } else {
1822 // set default value
1823 osgFile = defaultValues.osgFile;
1824 // unset parameter
1825 parametersSet &= ~VTYPEPARS_OSGFILE_SET;
1826 }
1827 break;
1829 if (!value.empty() && (value != toString(defaultValues.carriageLength))) {
1830 carriageLength = parse<double>(value);
1831 // mark parameter as set
1833 // set parameter in SUMOVTypeParameter (needed for writting in XML)
1835 } else {
1836 // set default value
1837 carriageLength = defaultValues.carriageLength;
1838 // unset parameter
1839 parametersSet &= ~VTYPEPARS_CARRIAGE_LENGTH_SET;
1840 // remove from params (needed for writting in XML)
1842 }
1843 break;
1845 if (!value.empty() && (value != toString(defaultValues.containerCapacity))) {
1846 locomotiveLength = parse<double>(value);
1847 // mark parameter as set
1849 // set parameter in SUMOVTypeParameter (needed for writting in XML)
1851 } else {
1852 // set default value
1853 locomotiveLength = defaultValues.locomotiveLength;
1854 // unset parameter
1855 parametersSet &= ~VTYPEPARS_LOCOMOTIVE_LENGTH_SET;
1856 // remove from params (needed for writting in XML)
1858 }
1859 break;
1861 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1862 carriageGap = parse<double>(value);
1863 // mark parameter as set
1865 // set parameter in SUMOVTypeParameter (needed for writting in XML)
1867 } else {
1868 // set default value
1869 carriageGap = parse<double>(myTagProperty.getDefaultValue(key));
1870 // unset parameter
1871 parametersSet &= ~VTYPEPARS_CARRIAGE_GAP_SET;
1872 // remove from params (needed for writting in XML)
1874 }
1875 break;
1877 // make a copy of distributions
1878 const auto copyDistributions = myDistributions;
1879 // clear distributions
1880 myDistributions.clear();
1881 // obtain IDS
1882 const auto typeDistributionIDs = StringTokenizer(value).getVector();
1883 // iterate over IDs, add into map, and check if previously there is a probability defined
1884 for (const auto &typeDistributionID : typeDistributionIDs) {
1885 if (copyDistributions.count(typeDistributionID) > 0) {
1886 myDistributions[typeDistributionID] = copyDistributions.at(typeDistributionID);
1887 } else {
1888 myDistributions[typeDistributionID] = 1.0;
1889 }
1890 }
1891 break;
1892 }
1894 // obtain probabilities
1895 const auto typeDistributionProbs = StringTokenizer(value).getVector();
1896 int index = 0;
1897 // add every probability to their distribution
1898 for (auto &distribution : myDistributions) {
1899 distribution.second = parse<double>(typeDistributionProbs.at(index));
1900 index++;
1901 }
1902 break;
1903 }
1904 case GNE_ATTR_SELECTED:
1905 if (parse<bool>(value)) {
1907 } else {
1909 }
1910 break;
1912 setParametersStr(value);
1913 break;
1915 myDefaultVehicleTypeModified = parse<bool>(value);
1916 break;
1917 default:
1918 throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
1919 }
1920 // check if geometry must be marked as deprecated
1923 }
1924}
1925
1926
1927void
1929 // vehicleTypes cannot be moved
1930}
1931
1932
1933void
1934GNEVType::commitMoveShape(const GNEMoveResult& /*moveResult*/, GNEUndoList* /*undoList*/) {
1935 // vehicleTypes cannot be moved
1936}
1937
1938
1939void
1942 length = defaultValues.length;
1943 }
1945 minGap = defaultValues.minGap;
1946 }
1948 maxSpeed = defaultValues.maxSpeed;
1949 }
1951 width = defaultValues.width;
1952 }
1954 height = defaultValues.height;
1955 }
1957 shape = defaultValues.shape;
1958 }
1960 emissionClass = defaultValues.emissionClass;
1961 }
1963 speedFactor = defaultValues.speedFactor;
1964 }
1966 desiredMaxSpeed = defaultValues.desiredMaxSpeed;
1967 }
1969 personCapacity = defaultValues.personCapacity;
1970 }
1972 containerCapacity = defaultValues.containerCapacity;
1973 }
1975 osgFile = defaultValues.osgFile;
1976 }
1978 carriageLength = defaultValues.carriageLength;
1979 }
1981 locomotiveLength = defaultValues.locomotiveLength;
1982 }
1983}
1984
1985/****************************************************************************/
@ GLO_VTYPE
@bief vTypes
GUIIcon
An enumeration of icons used by the gui applications.
Definition GUIIcons.h:33
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition SUMOTime.cpp:46
std::string time2string(SUMOTime t, bool humanReadable)
convert SUMOTime to string (independently of global format setting)
Definition SUMOTime.cpp:69
const long long int VTYPEPARS_SHAPE_SET
const long long int VTYPEPARS_LOADING_DURATION
const long long int VTYPEPARS_PERSON_CAPACITY
const long long int VTYPEPARS_CAR_FOLLOW_MODEL
const long long int VTYPEPARS_WIDTH_SET
const long long int VTYPEPARS_CARRIAGE_LENGTH_SET
const long long int VTYPEPARS_ACTIONSTEPLENGTH_SET
const long long int VTYPEPARS_MAXSPEED_LAT_SET
const long long int VTYPEPARS_MAXSPEED_SET
const long long int VTYPEPARS_EMISSIONCLASS_SET
const long long int VTYPEPARS_LATALIGNMENT_SET
const long long int VTYPEPARS_COLOR_SET
const long long int VTYPEPARS_LANE_CHANGE_MODEL_SET
const long long int VTYPEPARS_DESIRED_MAXSPEED_SET
const long long int VTYPEPARS_OSGFILE_SET
const long long int VTYPEPARS_SPEEDFACTOR_SET
const long long int VTYPEPARS_CARRIAGE_GAP_SET
const long long int VTYPEPARS_MINGAP_SET
const long long int VTYPEPARS_PROBABILITY_SET
const long long int VTYPEPARS_HEIGHT_SET
const long long int VTYPEPARS_BOARDING_DURATION
@ GIVEN
The alignment as offset is given.
const long long int VTYPEPARS_VEHICLECLASS_SET
const long long int VTYPEPARS_IMPATIENCE_SET
const long long int VTYPEPARS_LENGTH_SET
const long long int VTYPEPARS_IMGFILE_SET
const long long int VTYPEPARS_CONTAINER_CAPACITY
const long long int VTYPEPARS_MINGAP_LAT_SET
const long long int VTYPEPARS_LOCOMOTIVE_LENGTH_SET
bool canParseVehicleShape(const std::string &shape)
Checks whether the given string contains only known vehicle shape.
StringBijection< SUMOVehicleShape > SumoVehicleShapeStrings(sumoVehicleShapeStringInitializer, SUMOVehicleShape::UNKNOWN, false)
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
SUMOVehicleShape getVehicleShapeID(const std::string &name)
Returns the class id of the shape class given by its name.
bool canParseVehicleClasses(const std::string &classes)
Checks whether the given string contains only known vehicle classes.
std::string getVehicleShapeName(SUMOVehicleShape id)
Returns the class name of the shape class given by its id.
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
const std::string DEFAULT_TAXITYPE_ID
const std::string DEFAULT_RAILTYPE_ID
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_W99_CC9
@ SUMO_ATTR_CF_EIDM_T_ACC_MAX
@ SUMO_ATTR_CF_EIDM_EPSILON_ACC
@ SUMO_ATTR_CF_W99_CC5
@ 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_CF_W99_CC8
@ 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_DESIRED_MAXSPEED
@ 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_CF_W99_CC3
@ SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR
@ 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_CF_W99_CC2
@ SUMO_ATTR_CF_W99_CC4
@ SUMO_ATTR_JM_SIGMA_MINOR
@ SUMO_ATTR_CF_W99_CC6
@ 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
@ GNE_ATTR_VTYPE_DISTRIBUTION_PROBABILITY
vehicle type distribution
@ 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_CF_W99_CC7
@ SUMO_ATTR_LCA_STRATEGIC_PARAM
@ SUMO_ATTR_CF_W99_CC1
@ SUMO_ATTR_TAU
@ SUMO_ATTR_IMGFILE
@ SUMO_ATTR_WIDTH
@ SUMO_ATTR_PERSON_CAPACITY
@ SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME
@ 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
const std::string getID() const
get ID (all Attribute Carriers have one)
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
static const std::string False
true value in string format(used for comparing boolean values in getAttribute(...))
const GNETagProperties & myTagProperty
reference to tagProperty associated with this attribute carrier
bool requireUpdateGeometry() const
return true if attribute requires a update geometry in setAttribute(...)
the function-object for an editing operation (abstract base)
void forceChange()
force change
An Element which don't belong to GNENet but has influence in the simulation.
virtual std::string getAttribute(SumoXMLAttr key) const =0
bool demandElementExist(const std::string &id, const std::vector< SumoXMLTag > tags) const
check if the given demand element exist
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::vector< GNEDemandElement * > & getChildDemandElements() const
return child demand elements
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition GNELane.h: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:120
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 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
std::string getHierarchyName() const
get Hierarchy Name (Used in AC Hierarchy)
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 isValid(SumoXMLAttr key, const std::string &value)
method for checking if the key and their conrrespond attribute are valids
Definition GNEVType.cpp:715
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:186
bool isAttributeEnabled(SumoXMLAttr key) const
Definition GNEVType.cpp:967
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:568
static void overwriteVType(GNEDemandElement *vType, const SUMOVTypeParameter newVTypeParameter, GNEUndoList *undoList)
overwrite all values of GNEVType with a SUMOVTypeParameter
void updateDefaultVClassAttributes(const VClassDefaultValues &defaultValues)
function called after set new VClass
void commitMoveShape(const GNEMoveResult &moveResult, GNEUndoList *undoList)
commit move shape
GNELane * getFirstPathLane() const
get first path lane
Definition GNEVType.cpp:198
GNELane * getLastPathLane() const
get last path lane
Definition GNEVType.cpp:205
void splitEdgeGeometry(const double splitPosition, const GNENetworkElement *originalElement, const GNENetworkElement *newElement, GNEUndoList *undoList)
split geometry
Definition GNEVType.cpp:168
void writeDemandElement(OutputDevice &device) const
write 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:195
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 Parameterised::Map & getACParametersMap() const
get parameters map
void fixDemandElementProblem()
fix demand element problem
Definition GNEVType.cpp:122
void setMoveShape(const GNEMoveResult &moveResult)
set move shape
GNEVType(GNENet *net)
default constructor
Definition GNEVType.cpp:36
Position getAttributePosition(SumoXMLAttr key) const
Definition GNEVType.cpp:562
double getAttributeDouble(SumoXMLAttr key) const
Definition GNEVType.cpp:521
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
Definition GNEVType.cpp:174
std::string getAttribute(SumoXMLAttr key) const
inherited from GNEAttributeCarrier
Definition GNEVType.cpp:212
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
Definition GNEVType.cpp:161
std::map< std::string, double > myDistributions
vType distributions
Definition GNEVType.h:201
void computePathElement()
compute pathElement
Definition GNEVType.cpp:180
std::string getPopUpID() const
get PopPup ID (Used in AC Hierarchy)
SUMOVehicleClass getVClass() const
Definition GNEVType.cpp:128
bool myDefaultVehicleTypeModified
flag to check if this default GNEVType was modified
Definition GNEVType.h:198
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.
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.
std::map< std::string, std::string > Map
parameters map
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.
const Parameterised::Map & getParametersMap() const
Returns the inner key/value map.
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".
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....
bool wasSet(long long int what) const
Returns whether the given parameter was set.
double height
This class' height.
double desiredMaxSpeed
The vehicle type's desired maximum speed [m/s].
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].
RGBColor color
The color.
long long int parametersSet
Information for the router which parameter were set.
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.
double getLCParam(const SumoXMLAttr attr, const double defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
std::string osgFile
3D model file for this class
double maxSpeed
The vehicle type's (technical) maximum speed [m/s].
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.
double getJMParam(const SumoXMLAttr attr, const double defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
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
const std::string & getString(const T key) const
bool hasString(const std::string &str) const
T get(const std::string &str) const
std::vector< std::string > getVector()
return vector of strings
struct for default values that depend of VClass
int personCapacity
The person capacity of the vehicle.
double carriageLength
the length of train carriages
double desiredMaxSpeed
The vehicle type's desired maximum speed [m/s].
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] (technical limit, not subject to speed deviation)
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.
LatAlignmentDefinition latAlignmentProcedure
the lateral alignment procedure
double locomotiveLength
the length of train locomotive