Eclipse SUMO - Simulation of Urban MObility
GNEVType.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2001-2022 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
18// Definition of Vehicle Types in NETEDIT
19/****************************************************************************/
20#include <netedit/GNENet.h>
21#include <netedit/GNEViewNet.h>
22#include <netedit/GNEUndoList.h>
26
27#include "GNEVType.h"
29
30
31// ===========================================================================
32// member method definitions
33// ===========================================================================
34
37 GNEPathManager::PathElement::Options::DEMAND_ELEMENT, {}, {}, {}, {}, {}, {}),
39 myDefaultVehicleType(true),
40myDefaultVehicleTypeModified(false) {
41 // reset default values
42 resetDefaultValues();
43 // init Rail Visualization Parameters
44 initRailVisualizationParameters();
45}
46
47
48GNEVType::GNEVType(GNENet* net, const std::string& vTypeID, const SUMOVehicleClass& defaultVClass) :
50 GNEPathManager::PathElement::Options::DEMAND_ELEMENT, {}, {}, {}, {}, {}, {}),
51SUMOVTypeParameter(vTypeID),
52myDefaultVehicleType(true),
53myDefaultVehicleTypeModified(false) {
54 // set default vehicle class
55 vehicleClass = defaultVClass;
56 // init Rail Visualization Parameters
57 initRailVisualizationParameters();
58}
59
60
61GNEVType::GNEVType(GNENet* net, const SUMOVTypeParameter& vTypeParameter) :
62 GNEDemandElement(vTypeParameter.id, net, GLO_VTYPE, SUMO_TAG_VTYPE, GUIIconSubSys::getIcon(GUIIcon::VTYPE),
63 GNEPathManager::PathElement::Options::DEMAND_ELEMENT, {}, {}, {}, {}, {}, {}),
64SUMOVTypeParameter(vTypeParameter),
65myDefaultVehicleType(false),
66myDefaultVehicleTypeModified(false) {
67 // init Rail Visualization Parameters
68 initRailVisualizationParameters();
69}
70
71
72GNEVType::GNEVType(GNENet* net, const std::string& vTypeID, GNEVType* vTypeOriginal) :
73 GNEDemandElement(vTypeID, net, GLO_VTYPE, vTypeOriginal->getTagProperty().getTag(), GUIIconSubSys::getIcon(GUIIcon::VTYPE),
74 GNEPathManager::PathElement::Options::DEMAND_ELEMENT, {}, {}, {}, {}, {}, {}),
75SUMOVTypeParameter(*vTypeOriginal),
76myDefaultVehicleType(false),
77myDefaultVehicleTypeModified(false) {
78 // change manually the ID (to avoid to use the ID of vTypeOriginal)
79 id = vTypeID;
80 // init Rail Visualization Parameters
81 initRailVisualizationParameters();
82}
83
84
86
87
90 return nullptr;
91}
92
93
94void
96 // only write default vehicle types if it was modified
99 write(device);
100 }
101 } else {
102 write(device);
103 }
104}
105
106
109 // currently vTypes don't have problems
111}
112
113
114std::string
116 return "";
117}
118
119
120void
122 // nothing to fix
123}
124
125
128 return vehicleClass;
129}
130
131
132const RGBColor&
134 return color;
135}
136
137
138void
140 // update geometry of all childrens
141 for (const auto& i : getChildDemandElements()) {
142 i->updateGeometry();
143 }
144}
145
146
149 return Position();
150}
151
152
153std::string
155 return myNet->getMicrosimID();
156}
157
158
159double
161 return 1;
162}
163
164
167 // Vehicle Types doesn't have boundaries
168 return Boundary(-0.1, -0.1, 0.1, 0.1);
169}
170
171
172void
173GNEVType::splitEdgeGeometry(const double /*splitPosition*/, const GNENetworkElement* /*originalElement*/, const GNENetworkElement* /*newElement*/, GNEUndoList* /*undoList*/) {
174 // geometry of this element cannot be splitted
175}
176
177
178void
180 // Vehicle Types aren't draw
181}
182
183
184void
186 // nothing to compute
187}
188
189
190void
191GNEVType::drawPartialGL(const GUIVisualizationSettings& /*s*/, const GNELane* /*lane*/, const GNEPathManager::Segment* /*segment*/, const double /*offsetFront*/) const {
192 // vehicleTypes don't use drawPartialGL
193}
194
195
196void
197GNEVType::drawPartialGL(const GUIVisualizationSettings& /*s*/, const GNELane* /*fromLane*/, const GNELane* /*toLane*/, const GNEPathManager::Segment* /*segment*/, const double /*offsetFront*/) const {
198 // vehicleTypes don't use drawPartialGL
199}
200
201
202GNELane*
204 // vehicle types don't use lanes
205 return nullptr;
206}
207
208
209GNELane*
211 // vehicle types don't use lanes
212 return nullptr;
213}
214
215
216std::string
218 // obtain default values depending of vehicle class
219 VClassDefaultValues defaultValues(vehicleClass);
220 switch (key) {
221 case SUMO_ATTR_ID:
222 return getMicrosimID();
224 if (getParentDemandElements().empty()) {
225 return "";
226 } else {
227 return getParentDemandElements().front()->getID();
228 }
229 // CFM Attributes
230 case SUMO_ATTR_ACCEL:
231 case SUMO_ATTR_DECEL:
234 case SUMO_ATTR_SIGMA:
235 case SUMO_ATTR_TAU:
236 // this CFM has default values
238 // JM Attributes
248 // this JM has default values
252 return toString(impatience);
253 } else {
255 }
256 // LCM Attributes
277 /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
279 //
297 case SUMO_ATTR_TMP1:
298 case SUMO_ATTR_TMP2:
299 case SUMO_ATTR_TMP3:
300 case SUMO_ATTR_TMP4:
301 case SUMO_ATTR_TMP5:
309 case SUMO_ATTR_K:
313 return getCFParamString(key, "");
314 // Mutable values
315 case SUMO_ATTR_LENGTH:
317 return toString(length);
318 } else {
319 return toString(defaultValues.length);
320 }
321 case SUMO_ATTR_MINGAP:
323 return toString(minGap);
324 } else {
325 return toString(defaultValues.minGap);
326 }
329 return toString(maxSpeed);
330 } else {
331 return toString(defaultValues.maxSpeed);
332 }
335 return toString(speedFactor);
336 } else {
337 return toString(defaultValues.speedFactor);
338 }
342 } else {
343 return toString(defaultValues.desiredMaxSpeed);
344 }
347 return toString(personCapacity);
348 } else {
349 return toString(defaultValues.personCapacity);
350 }
354 } else {
355 return toString(defaultValues.containerCapacity);
356 }
359 return osgFile;
360 } else {
361 return defaultValues.osgFile;
362 }
363 case SUMO_ATTR_COLOR:
365 return toString(color);
366 } else {
367 return "";
368 }
369 case SUMO_ATTR_VCLASS:
371 return toString(vehicleClass);
372 } else {
374 }
378 } else {
379 return PollutantsInterface::getName(defaultValues.emissionClass);
380 }
384 } else {
385 return getVehicleShapeName(defaultValues.shape);
386 }
387 case SUMO_ATTR_WIDTH:
389 return toString(width);
390 } else {
391 return toString(defaultValues.width);
392 }
393 case SUMO_ATTR_HEIGHT:
395 return toString(height);
396 } else {
397 return toString(defaultValues.height);
398 }
401 return imgFile;
402 } else {
404 }
408 } else {
410 }
414 } else {
416 }
420 } else {
422 }
426 } else {
428 }
433 } else {
435 }
436 } else {
437 return toString(defaultValues.latAlignmentProcedure);
438 }
441 return toString(minGapLat);
442 } else {
444 }
447 return toString(maxSpeedLat);
448 } else {
450 }
454 } else {
456 }
457 case SUMO_ATTR_PROB:
460 } else {
462 }
465 return toString(carriageLength);
466 } else {
467 return toString(defaultValues.carriageLength);
468 }
472 } else {
473 return toString(defaultValues.locomotiveLength);
474 }
477 return toString(carriageGap);
478 } else {
480 }
484 return getParametersStr();
485 // other
491 } else {
492 return False;
493 }
494 default:
495 throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
496 }
497}
498
499
500double
502 // obtain default values depending of vehicle class
503 VClassDefaultValues defaultValues(vehicleClass);
504 switch (key) {
505 case SUMO_ATTR_LENGTH:
507 return length;
508 } else {
509 return defaultValues.length;
510 }
511 case SUMO_ATTR_MINGAP:
513 return minGap;
514 } else {
515 return defaultValues.minGap;
516 }
517 case SUMO_ATTR_WIDTH:
519 return width;
520 } else {
521 return defaultValues.width;
522 }
523 case SUMO_ATTR_HEIGHT:
525 return height;
526 } else {
527 return defaultValues.height;
528 }
531 return maxSpeed;
532 } else {
533 return defaultValues.maxSpeed;
534 }
535 default:
536 throw InvalidArgument(getTagStr() + " doesn't have a double attribute of type '" + toString(key) + "'");
537 }
538}
539
540
543 throw InvalidArgument(getTagStr() + " doesn't have a Position attribute of type '" + toString(key) + "'");
544}
545
546
547void
548GNEVType::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) {
549 GNEChange_Attribute* vTypeChangeAttributeForced = nullptr;
550 if (value == getAttribute(key)) {
551 return; //avoid needless changes, later logic relies on the fact that attributes have changed
552 }
553 switch (key) {
554 case SUMO_ATTR_ID:
555 undoList->changeAttribute(new GNEChange_Attribute(this, key, value));
556 break;
558 editVTypeDistribution(value, undoList);
559 break;
560 // CFM Attributes
561 case SUMO_ATTR_ACCEL:
562 case SUMO_ATTR_DECEL:
565 case SUMO_ATTR_SIGMA:
566 case SUMO_ATTR_TAU:
568 case SUMO_ATTR_TMP1:
569 case SUMO_ATTR_TMP2:
570 case SUMO_ATTR_TMP3:
571 case SUMO_ATTR_TMP4:
572 case SUMO_ATTR_TMP5:
595 case SUMO_ATTR_K:
599 // JM Attributes
610 // LCM Attributes
631 /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
632 //
633 case SUMO_ATTR_LENGTH:
634 case SUMO_ATTR_MINGAP:
638 case SUMO_ATTR_COLOR:
639 case SUMO_ATTR_VCLASS:
642 case SUMO_ATTR_WIDTH:
643 case SUMO_ATTR_HEIGHT:
655 case SUMO_ATTR_PROB:
662 // if we change the original value of a default vehicle Type, change also flag "myDefaultVehicleType"
664 vTypeChangeAttributeForced = new GNEChange_Attribute(this, GNE_ATTR_DEFAULT_VTYPE_MODIFIED, "true");
665 // force change
666 vTypeChangeAttributeForced->forceChange();
667 undoList->changeAttribute(vTypeChangeAttributeForced);
668 }
669 vTypeChangeAttributeForced = new GNEChange_Attribute(this, key, value);
670 // force change
671 vTypeChangeAttributeForced->forceChange();
672 undoList->changeAttribute(vTypeChangeAttributeForced);
673 break;
675 vTypeChangeAttributeForced = new GNEChange_Attribute(this, GNE_ATTR_DEFAULT_VTYPE_MODIFIED, "true");
676 // force change
677 vTypeChangeAttributeForced->forceChange();
678 undoList->changeAttribute(vTypeChangeAttributeForced);
679 break;
680 default:
681 throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
682 }
683}
684
685
686bool
687GNEVType::isValid(SumoXMLAttr key, const std::string& value) {
688 // a empty value is always valid except for IDs
689 if ((key != SUMO_ATTR_ID) && value.empty()) {
690 return true;
691 }
692 switch (key) {
693 case SUMO_ATTR_ID:
694 // Vtypes and PTypes shares namespace
695 if (value == getID()) {
696 return true;
697 } else if (SUMOXMLDefinitions::isValidVehicleID(value) && (myNet->getAttributeCarriers()->retrieveDemandElement(SUMO_TAG_VTYPE, value, false) == nullptr)) {
698 return true;
699 } else {
700 return false;
701 }
703 if (value.empty()) {
704 return true;
705 } else {
707 }
708 // CFM Attributes
709 case SUMO_ATTR_SIGMA:
710 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
711 case SUMO_ATTR_ACCEL:
712 case SUMO_ATTR_DECEL:
715 case SUMO_ATTR_TAU:
717 case SUMO_ATTR_TMP1:
718 case SUMO_ATTR_TMP2:
719 case SUMO_ATTR_TMP3:
720 case SUMO_ATTR_TMP4:
721 case SUMO_ATTR_TMP5:
728 case SUMO_ATTR_K:
732 return canParse<double>(value);
734 return canParse<bool>(value);
736 return canParse<int>(value) && (parse<int>(value) >= 0);
738 return canParse<double>(value) && (parse<double>(value) >= 1);
740 return canParse<double>(value) && (parse<double>(value) >= 1);
742 return canParse<double>(value) && (parse<double>(value) >= 0);
744 return canParse<double>(value) && (parse<double>(value) >= 1);
746 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
748 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
750 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
752 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
754 return canParse<double>(value) && (parse<double>(value) >= 1);
756 return canParse<double>(value) && (parse<double>(value) >= 0);
758 return canParse<double>(value) && (parse<double>(value) >= 0);
760 return canParse<double>(value) && (parse<double>(value) >= 1) && (parse<double>(value) <= 5);
762 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1.5);
764 // rail string
766 // JM Attributes
768 return canParse<double>(value) && (parse<double>(value) >= 0);
770 return canParse<double>(value) && (parse<double>(value) >= -1);
772 return canParse<double>(value) && (parse<double>(value) >= -1);
774 return canParse<double>(value) && (parse<double>(value) >= -1);
776 return canParse<double>(value) && (parse<double>(value) >= 0);
778 return canParse<double>(value) && (parse<double>(value) >= 0);
780 return canParse<double>(value) && (parse<double>(value) >= 0);
782 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
784 return canParse<double>(value) && (parse<double>(value) >= 0);
786 return canParse<double>(value) && (parse<double>(value) >= 0);
787 // LCM Attributes
795 return canParse<double>(value);
799 case SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE: // 0 mean disabled
800 case SUMO_ATTR_LCA_TIME_TO_IMPATIENCE: // 0 mean disabled
801 case SUMO_ATTR_LCA_OVERTAKE_RIGHT: // 0 mean disabled
802 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 || parse<double>(value) == -1);
812 return canParse<double>(value) && (parse<double>(value) >= -1) && (parse<double>(value) <= 1);
813 /* case SUMO_ATTR_LCA_EXPERIMENTAL1:
814 return true;
815 */
816 //
817 case SUMO_ATTR_LENGTH:
818 return canParse<double>(value) && (parse<double>(value) > 0);
819 case SUMO_ATTR_MINGAP:
820 return canParse<double>(value) && (parse<double>(value) >= 0);
822 return canParse<double>(value) && (parse<double>(value) >= 0);
826 return canParse<double>(value) && (parse<double>(value) >= 0);
827 case SUMO_ATTR_COLOR:
828 if (value.empty()) {
829 return true;
830 } else {
831 return canParse<RGBColor>(value);
832 }
833 case SUMO_ATTR_VCLASS:
834 return canParseVehicleClasses(value);
836 // check if given value correspond to a string of PollutantsInterface::getAllClassesStr()
837 for (const auto& eClass : PollutantsInterface::getAllClassesStr()) {
838 if (value == eClass) {
839 return true;
840 }
841 }
842 return false;
844 if (value == "all") {
845 return false;
846 } else {
847 return canParseVehicleShape(value);
848 }
849 case SUMO_ATTR_WIDTH:
850 return canParse<double>(value);
851 case SUMO_ATTR_HEIGHT:
852 return canParse<double>(value);
860 return canParse<int>(value);
862 return canParse<int>(value);
864 return canParse<double>(value);
866 return canParse<double>(value);
870 return canParse<double>(value);
872 return canParse<double>(value);
874 return canParse<double>(value) && (parse<double>(value) >= 0);
875 case SUMO_ATTR_PROB:
876 return canParse<double>(value) && (parse<double>(value) >= 0);
880 return canParse<double>(value) && (parse<double>(value) >= -1);
882 return canParse<double>(value) && (parse<double>(value) >= -1);
884 return canParse<double>(value) && (parse<double>(value) >= 0);
886 return canParse<bool>(value);
891 return canParse<bool>(value);
892 } else {
893 return false;
894 }
895 default:
896 throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
897 }
898}
899
900
901bool
903 switch (key) {
904 case SUMO_ATTR_ID:
905 if ((id == DEFAULT_VTYPE_ID) || (id == DEFAULT_PEDTYPE_ID) || (id == DEFAULT_BIKETYPE_ID)) {
906 return false;
907 } else {
908 return true;
909 }
910 case SUMO_ATTR_LENGTH:
912 case SUMO_ATTR_MINGAP:
932 default:
933 return true;
934 }
935}
936
937
938std::string
940 return getTagStr();
941}
942
943
944std::string
946 return getTagStr() + ": " + getAttribute(SUMO_ATTR_ID) ;
947}
948
949
952 return getParametersMap();
953}
954
955
956void
957GNEVType::overwriteVType(GNEDemandElement* vType, const SUMOVTypeParameter newVTypeParameter, GNEUndoList* undoList) {
958 // open undo list and overwrite all values of default VType
959 undoList->begin(vType->getTagProperty().getGUIIcon(), "update default " + vType->getTagStr() + " '" + DEFAULT_VTYPE_ID + "'");
960 // CFM values
961 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_ACCEL, "").empty()) {
962 vType->setAttribute(SUMO_ATTR_ACCEL, toString(newVTypeParameter.getCFParam(SUMO_ATTR_ACCEL, 0)), undoList);
963 }
964 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_DECEL, "").empty()) {
965 vType->setAttribute(SUMO_ATTR_DECEL, toString(newVTypeParameter.getCFParam(SUMO_ATTR_DECEL, 0)), undoList);
966 }
967 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_APPARENTDECEL, "").empty()) {
968 vType->setAttribute(SUMO_ATTR_APPARENTDECEL, toString(newVTypeParameter.getCFParam(SUMO_ATTR_APPARENTDECEL, 0)), undoList);
969 }
970 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_EMERGENCYDECEL, "").empty()) {
971 vType->setAttribute(SUMO_ATTR_EMERGENCYDECEL, toString(newVTypeParameter.getCFParam(SUMO_ATTR_EMERGENCYDECEL, 0)), undoList);
972 }
973 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_SIGMA, "").empty()) {
974 vType->setAttribute(SUMO_ATTR_SIGMA, toString(newVTypeParameter.getCFParam(SUMO_ATTR_SIGMA, 0)), undoList);
975 }
976 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TAU, "").empty()) {
977 vType->setAttribute(SUMO_ATTR_TAU, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TAU, 0)), undoList);
978 }
979 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_COLLISION_MINGAP_FACTOR, "").empty()) {
981 }
982 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP1, "").empty()) {
983 vType->setAttribute(SUMO_ATTR_TMP1, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP1, 0)), undoList);
984 }
985 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP2, "").empty()) {
986 vType->setAttribute(SUMO_ATTR_TMP2, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP2, 0)), undoList);
987 }
988 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP3, "").empty()) {
989 vType->setAttribute(SUMO_ATTR_TMP3, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP3, 0)), undoList);
990 }
991 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP4, "").empty()) {
992 vType->setAttribute(SUMO_ATTR_TMP4, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP4, 0)), undoList);
993 }
994 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP5, "").empty()) {
995 vType->setAttribute(SUMO_ATTR_TMP5, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP5, 0)), undoList);
996 }
997 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS, "").empty()) {
999 }
1000 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW, "").empty()) {
1002 }
1003 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD, "").empty()) {
1005 }
1006 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE, "").empty()) {
1008 }
1009 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_REACTION, "").empty()) {
1011 }
1012 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE, "").empty()) {
1014 }
1015 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_C_COOLNESS, "").empty()) {
1017 }
1018 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_SIG_LEADER, "").empty()) {
1020 }
1021 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_SIG_GAP, "").empty()) {
1023 }
1024 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_SIG_ERROR, "").empty()) {
1026 }
1027 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_JERK_MAX, "").empty()) {
1029 }
1030 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_EPSILON_ACC, "").empty()) {
1032 }
1033 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_ACC_MAX, "").empty()) {
1035 }
1036 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_M_FLATNESS, "").empty()) {
1038 }
1039 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_M_BEGIN, "").empty()) {
1041 }
1042 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_PWAGNER2009_TAULAST, "").empty()) {
1044 }
1045 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_PWAGNER2009_APPROB, "").empty()) {
1047 }
1048 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_IDMM_ADAPT_FACTOR, "").empty()) {
1050 }
1051 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_IDMM_ADAPT_TIME, "").empty()) {
1053 }
1054 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_WIEDEMANN_SECURITY, "").empty()) {
1056 }
1057 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_WIEDEMANN_ESTIMATION, "").empty()) {
1059 }
1060 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TRAIN_TYPE, "").empty()) {
1061 vType->setAttribute(SUMO_ATTR_TRAIN_TYPE, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TRAIN_TYPE, 0)), undoList);
1062 }
1063 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_K, "").empty()) {
1064 vType->setAttribute(SUMO_ATTR_K, toString(newVTypeParameter.getCFParam(SUMO_ATTR_K, 0)), undoList);
1065 }
1066 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_KERNER_PHI, "").empty()) {
1067 vType->setAttribute(SUMO_ATTR_CF_KERNER_PHI, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_KERNER_PHI, 0)), undoList);
1068 }
1069 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_IDM_DELTA, "").empty()) {
1070 vType->setAttribute(SUMO_ATTR_CF_IDM_DELTA, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_IDM_DELTA, 0)), undoList);
1071 }
1072 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_IDM_STEPPING, "").empty()) {
1074 }
1075 // JM values
1076 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_CROSSING_GAP, "").empty()) {
1078 }
1079 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME, "").empty()) {
1081 }
1082 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME, "").empty()) {
1084 }
1085 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME, "").empty()) {
1087 }
1088 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_DRIVE_RED_SPEED, "").empty()) {
1090 }
1091 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_IGNORE_FOE_PROB, "").empty()) {
1093 }
1094 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_IGNORE_FOE_SPEED, "").empty()) {
1096 }
1097 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_SIGMA_MINOR, "").empty()) {
1098 vType->setAttribute(SUMO_ATTR_JM_SIGMA_MINOR, toString(newVTypeParameter.getJMParam(SUMO_ATTR_JM_SIGMA_MINOR, 0)), undoList);
1099 }
1100 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_TIMEGAP_MINOR, "").empty()) {
1102 }
1103 if (newVTypeParameter.wasSet(VTYPEPARS_IMPATIENCE_SET)) {
1104 vType->setAttribute(SUMO_ATTR_IMPATIENCE, toString(newVTypeParameter.impatience), undoList);
1105 }
1106 // LCM values
1107 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_STRATEGIC_PARAM, "").empty()) {
1109 }
1110 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_COOPERATIVE_PARAM, "").empty()) {
1112 }
1113 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_SPEEDGAIN_PARAM, "").empty()) {
1115 }
1116 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_KEEPRIGHT_PARAM, "").empty()) {
1118 }
1119 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_SUBLANE_PARAM, "").empty()) {
1121 }
1122 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_OPPOSITE_PARAM, "").empty()) {
1124 }
1125 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_PUSHY, "").empty()) {
1126 vType->setAttribute(SUMO_ATTR_LCA_PUSHY, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_PUSHY, 0)), undoList);
1127 }
1128 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_PUSHYGAP, "").empty()) {
1129 vType->setAttribute(SUMO_ATTR_LCA_PUSHYGAP, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_PUSHYGAP, 0)), undoList);
1130 }
1131 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_ASSERTIVE, "").empty()) {
1132 vType->setAttribute(SUMO_ATTR_LCA_ASSERTIVE, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_ASSERTIVE, 0)), undoList);
1133 }
1134 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_IMPATIENCE, "").empty()) {
1135 vType->setAttribute(SUMO_ATTR_LCA_IMPATIENCE, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_IMPATIENCE, 0)), undoList);
1136 }
1137 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_TIME_TO_IMPATIENCE, "").empty()) {
1139 }
1140 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_ACCEL_LAT, "").empty()) {
1141 vType->setAttribute(SUMO_ATTR_LCA_ACCEL_LAT, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_ACCEL_LAT, 0)), undoList);
1142 }
1143 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_LOOKAHEADLEFT, "").empty()) {
1145 }
1146 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_SPEEDGAINRIGHT, "").empty()) {
1148 }
1149 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_MAXSPEEDLATSTANDING, "").empty()) {
1151 }
1152 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_MAXSPEEDLATFACTOR, "").empty()) {
1154 }
1155 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE, "").empty()) {
1157 }
1158 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_OVERTAKE_RIGHT, "").empty()) {
1160 }
1161 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME, "").empty()) {
1163 }
1164 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR, "").empty()) {
1166 }
1167 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_EXPERIMENTAL1, "").empty()) {
1169 }
1170 //
1171 if (newVTypeParameter.wasSet(VTYPEPARS_LENGTH_SET)) {
1172 vType->setAttribute(SUMO_ATTR_LENGTH, toString(newVTypeParameter.length), undoList);
1173 }
1174 if (newVTypeParameter.wasSet(VTYPEPARS_MINGAP_SET)) {
1175 vType->setAttribute(SUMO_ATTR_MINGAP, toString(newVTypeParameter.minGap), undoList);
1176 }
1177 if (newVTypeParameter.wasSet(VTYPEPARS_MAXSPEED_SET)) {
1178 vType->setAttribute(SUMO_ATTR_MAXSPEED, toString(newVTypeParameter.maxSpeed), undoList);
1179 }
1180 if (newVTypeParameter.wasSet(VTYPEPARS_SPEEDFACTOR_SET)) {
1181 vType->setAttribute(SUMO_ATTR_SPEEDFACTOR, toString(newVTypeParameter.speedFactor), undoList);
1182 }
1183 if (newVTypeParameter.wasSet(VTYPEPARS_DESIRED_MAXSPEED_SET)) {
1184 vType->setAttribute(SUMO_ATTR_DESIRED_MAXSPEED, toString(newVTypeParameter.desiredMaxSpeed), undoList);
1185 }
1186 if (newVTypeParameter.wasSet(VTYPEPARS_COLOR_SET)) {
1187 vType->setAttribute(SUMO_ATTR_COLOR, toString(newVTypeParameter.color), undoList);
1188 }
1189 if (newVTypeParameter.wasSet(VTYPEPARS_EMISSIONCLASS_SET)) {
1191 }
1192 if (newVTypeParameter.wasSet(VTYPEPARS_SHAPE_SET)) {
1193 vType->setAttribute(SUMO_ATTR_GUISHAPE, getVehicleShapeName(newVTypeParameter.shape), undoList);
1194 }
1195 if (newVTypeParameter.wasSet(VTYPEPARS_WIDTH_SET)) {
1196 vType->setAttribute(SUMO_ATTR_WIDTH, toString(newVTypeParameter.width), undoList);
1197 }
1198 if (newVTypeParameter.wasSet(VTYPEPARS_HEIGHT_SET)) {
1199 vType->setAttribute(SUMO_ATTR_HEIGHT, toString(newVTypeParameter.height), undoList);
1200 }
1201 if (newVTypeParameter.wasSet(VTYPEPARS_IMGFILE_SET)) {
1202 vType->setAttribute(SUMO_ATTR_IMGFILE, toString(newVTypeParameter.imgFile), undoList);
1203 }
1204 if (newVTypeParameter.wasSet(VTYPEPARS_LANE_CHANGE_MODEL_SET)) {
1205 vType->setAttribute(SUMO_ATTR_LANE_CHANGE_MODEL, SUMOXMLDefinitions::LaneChangeModels.getString(newVTypeParameter.lcModel), undoList);
1206 }
1207 if (newVTypeParameter.wasSet(VTYPEPARS_CAR_FOLLOW_MODEL)) {
1208 vType->setAttribute(SUMO_ATTR_CAR_FOLLOW_MODEL, SUMOXMLDefinitions::CarFollowModels.getString(newVTypeParameter.cfModel), undoList);
1209 }
1210 if (newVTypeParameter.wasSet(VTYPEPARS_PERSON_CAPACITY)) {
1211 vType->setAttribute(SUMO_ATTR_PERSON_CAPACITY, toString(newVTypeParameter.personCapacity), undoList);
1212 }
1213 if (newVTypeParameter.wasSet(VTYPEPARS_CONTAINER_CAPACITY)) {
1214 vType->setAttribute(SUMO_ATTR_CONTAINER_CAPACITY, toString(newVTypeParameter.containerCapacity), undoList);
1215 }
1216 if (newVTypeParameter.wasSet(VTYPEPARS_BOARDING_DURATION)) {
1217 vType->setAttribute(SUMO_ATTR_BOARDING_DURATION, toString(newVTypeParameter.boardingDuration), undoList);
1218 }
1219 if (newVTypeParameter.wasSet(VTYPEPARS_LOADING_DURATION)) {
1220 vType->setAttribute(SUMO_ATTR_LOADING_DURATION, toString(newVTypeParameter.loadingDuration), undoList);
1221 }
1222 if (newVTypeParameter.wasSet(VTYPEPARS_LATALIGNMENT_SET)) {
1223 if (newVTypeParameter.latAlignmentProcedure != LatAlignmentDefinition::GIVEN) {
1224 vType->setAttribute(SUMO_ATTR_LATALIGNMENT, toString(newVTypeParameter.latAlignmentProcedure), undoList);
1225 } else {
1226 vType->setAttribute(SUMO_ATTR_LATALIGNMENT, toString(newVTypeParameter.latAlignmentOffset), undoList);
1227 }
1228 }
1229 if (newVTypeParameter.wasSet(VTYPEPARS_MINGAP_LAT_SET)) {
1230 vType->setAttribute(SUMO_ATTR_MINGAP_LAT, toString(newVTypeParameter.minGapLat), undoList);
1231 }
1232 if (newVTypeParameter.wasSet(VTYPEPARS_MAXSPEED_LAT_SET)) {
1233 vType->setAttribute(SUMO_ATTR_MAXSPEED_LAT, toString(newVTypeParameter.maxSpeedLat), undoList);
1234 }
1235 if (newVTypeParameter.wasSet(VTYPEPARS_ACTIONSTEPLENGTH_SET)) {
1236 vType->setAttribute(SUMO_ATTR_ACTIONSTEPLENGTH, toString(newVTypeParameter.actionStepLength), undoList);
1237 }
1238 if (newVTypeParameter.wasSet(VTYPEPARS_PROBABILITY_SET)) {
1239 vType->setAttribute(SUMO_ATTR_PROB, toString(newVTypeParameter.defaultProbability), undoList);
1240 }
1241 if (newVTypeParameter.wasSet(VTYPEPARS_OSGFILE_SET)) {
1242 vType->setAttribute(SUMO_ATTR_OSGFILE, toString(newVTypeParameter.osgFile), undoList);
1243 }
1244 if (newVTypeParameter.knowsParameter(toString(SUMO_ATTR_CARRIAGE_LENGTH))) {
1246 }
1247 if (newVTypeParameter.knowsParameter(toString(SUMO_ATTR_LOCOMOTIVE_LENGTH))) {
1249 }
1250 if (newVTypeParameter.knowsParameter(toString(SUMO_ATTR_CARRIAGE_GAP))) {
1251 vType->setAttribute(SUMO_ATTR_CARRIAGE_GAP, newVTypeParameter.getParameter(toString(SUMO_ATTR_CARRIAGE_GAP), ""), undoList);
1252 }
1253 // parse parameters
1254 std::string parametersStr;
1255 // Generate an string using the following structure: "key1=value1|key2=value2|...
1256 for (const auto& parameter : newVTypeParameter.getParametersMap()) {
1257 parametersStr += parameter.first + "=" + parameter.second + "|";
1258 }
1259 // remove the last "|"
1260 if (!parametersStr.empty()) {
1261 parametersStr.pop_back();
1262 }
1263 if (parametersStr != vType->getAttribute(GNE_ATTR_PARAMETERS)) {
1264 vType->setAttribute(GNE_ATTR_PARAMETERS, parametersStr, undoList);
1265 }
1266 if (parametersStr != vType->getAttribute(GNE_ATTR_VTYPE_DISTRIBUTION)) {
1267 vType->setAttribute(GNE_ATTR_VTYPE_DISTRIBUTION, parametersStr, undoList);
1268 }
1269 // close undo list
1270 undoList->end();
1271}
1272
1273// ===========================================================================
1274// protected
1275// ===========================================================================
1276
1277void
1278GNEVType::editVTypeDistribution(const std::string& vTypeDistributionID, GNEUndoList* undoList) {
1279 if (vTypeDistributionID.empty()) {
1280 // first check if previosly this vType has a vTypeDistribution
1281 if (getParentDemandElements().size() > 0) {
1282 // get parent vTypeDistribution
1283 GNEDemandElement* vTypeDistribution = getParentDemandElements().front();
1284 // check if this is the last vType of the vTypeDistribution
1285 if (vTypeDistribution->getChildDemandElements().size() == 1) {
1286 // ask if remove vTypeDistribution
1287 if (askRemoveVTypeDistribution(vTypeDistribution->getID())) {
1289 // clear attribute
1291 // remove vType Distribution
1292 undoList->add(new GNEChange_DemandElement(vTypeDistribution, false), true);
1293 undoList->end();
1294 }
1295 } else {
1296 // clear attribute
1298 }
1299 }
1300 } else {
1301 // check if vTypeDistribution exist
1302 const auto vTypeDistribution = myNet->getAttributeCarriers()->retrieveDemandElement(SUMO_TAG_VTYPE_DISTRIBUTION, vTypeDistributionID, false);
1303 // get current vTypeDistribution parent
1304 const auto vTypeDistributionParent = (getParentDemandElements().size() > 0) ? getParentDemandElements().front() : nullptr;
1305 if (vTypeDistribution) {
1306 // add in vTypeDistribution
1307 undoList->changeAttribute(new GNEChange_Attribute(this, GNE_ATTR_VTYPE_DISTRIBUTION, vTypeDistributionID));
1308 } else if (vTypeDistributionParent && (vTypeDistributionParent->getChildDemandElements().size() == 1)) {
1309 // ask if remove vTypeDistribution
1310 if (askRemoveVTypeDistribution(vTypeDistributionParent->getID())) {
1312 // clear attribute
1314 // remove old vTypeDistribution
1315 undoList->add(new GNEChange_DemandElement(vTypeDistributionParent, false), true);
1316 // create newTypeDistribution
1317 undoList->add(new GNEChange_DemandElement(new GNEVTypeDistribution(myNet, vTypeDistributionID, -1), true), true);
1318 // set new vTypeDistribution
1319 undoList->changeAttribute(new GNEChange_Attribute(this, GNE_ATTR_VTYPE_DISTRIBUTION, vTypeDistributionID));
1320 undoList->end();
1321 }
1322 } else {
1324 // create newTypeDistribution
1325 undoList->add(new GNEChange_DemandElement(new GNEVTypeDistribution(myNet, vTypeDistributionID, -1), true), true);
1326 // set new vTypeDistribution
1327 undoList->changeAttribute(new GNEChange_Attribute(this, GNE_ATTR_VTYPE_DISTRIBUTION, vTypeDistributionID));
1328 undoList->end();
1329 }
1330 }
1331}
1332
1333
1334bool
1335GNEVType::askAddVTypeDistribution(const std::string& vTypeDistribution) const {
1336 // show warning in gui testing debug mode
1337 WRITE_DEBUG("Opening FXMessageBox 'add vTypeDistribution'");
1338 // Ask confirmation to user
1339 const FXuint answer = FXMessageBox::question(myNet->getViewNet()->getApp(), MBOX_YES_NO,
1340 ("Add " + toString(SUMO_TAG_VTYPE_DISTRIBUTION) + "s").c_str(), "%s",
1341 (toString(SUMO_TAG_VTYPE_DISTRIBUTION) + " '" + vTypeDistribution + "' doesn't exist. Create?").c_str());
1342 if (answer == 1) { // 1:yes, 2:no, 4:esc
1343 WRITE_DEBUG("Closed FXMessageBox 'add vTypeDistribution' with 'yes'");
1344 return true;
1345 } else {
1346 // write warning if netedit is running in testing mode
1347 if (answer == 2) {
1348 WRITE_DEBUG("Closed FXMessageBox 'add vTypeDistribution' with 'No'");
1349 return false;
1350 } else {
1351 WRITE_DEBUG("Closed FXMessageBox 'add vTypeDistribution' with 'ESC'");
1352 return false;
1353 }
1354 }
1355}
1356
1357
1358bool
1359GNEVType::askRemoveVTypeDistribution(const std::string& vTypeDistribution) const {
1360 // show warning in gui testing debug mode
1361 WRITE_DEBUG("Opening FXMessageBox 'remove vTypeDistribution'");
1362 // Ask confirmation to user
1363 const FXuint answer = FXMessageBox::question(myNet->getViewNet()->getApp(), MBOX_YES_NO,
1364 ("Remove " + toString(SUMO_TAG_VTYPE_DISTRIBUTION)).c_str(), "%s",
1365 ("Changing attribute will remove " + toString(SUMO_TAG_VTYPE_DISTRIBUTION) + " '" + vTypeDistribution + "'. Continue?").c_str());
1366 if (answer == 1) { // 1:yes, 2:no, 4:esc
1367 WRITE_DEBUG("Closed FXMessageBox 'remove vTypeDistribution' with 'yes'");
1368 return true;
1369 } else {
1370 // write warning if netedit is running in testing mode
1371 if (answer == 2) {
1372 WRITE_DEBUG("Closed FXMessageBox 'remove vTypeDistribution' with 'No'");
1373 return false;
1374 } else {
1375 WRITE_DEBUG("Closed FXMessageBox 'remove vTypeDistribution' with 'ESC'");
1376 return false;
1377 }
1378 }
1379}
1380
1381// ===========================================================================
1382// private
1383// ===========================================================================
1384
1385void
1386GNEVType::setAttribute(SumoXMLAttr key, const std::string& value) {
1387 // obtain default values depending of vehicle class
1388 VClassDefaultValues defaultValues(vehicleClass);
1389 switch (key) {
1390 case SUMO_ATTR_ID:
1391 // update microsimID
1392 setMicrosimID(value);
1393 // manually change VType parameters ID
1394 id = value;
1395 break;
1398 break;
1399 // CFM Attributes
1400 case SUMO_ATTR_ACCEL:
1401 case SUMO_ATTR_DECEL:
1404 case SUMO_ATTR_SIGMA:
1405 case SUMO_ATTR_TAU:
1407 case SUMO_ATTR_TMP1:
1408 case SUMO_ATTR_TMP2:
1409 case SUMO_ATTR_TMP3:
1410 case SUMO_ATTR_TMP4:
1411 case SUMO_ATTR_TMP5:
1419 case SUMO_ATTR_K:
1423 // empty values means that value isn't set
1424 if (value.empty()) {
1425 const auto it = cfParameter.find(key);
1426 if (it != cfParameter.end()) {
1427 cfParameter.erase(it);
1428 }
1429 } else {
1430 cfParameter[key] = value;
1431 }
1432 break;
1448 // empty or default values means that value isn't set
1449 if (value.empty() || (canParse<double>(value) && (parse<double>(value) == parse<double>(myTagProperty.getDefaultValue(key))))) {
1450 const auto it = cfParameter.find(key);
1451 if (it != cfParameter.end()) {
1452 cfParameter.erase(it);
1453 }
1454 } else {
1455 cfParameter[key] = value;
1456 }
1457 break;
1458 // JM Attributes
1468 // empty values means that value isn't set
1469 if (value.empty()) {
1470 const auto it = jmParameter.find(key);
1471 if (it != jmParameter.end()) {
1472 jmParameter.erase(it);
1473 }
1474 } else {
1475 jmParameter[key] = value;
1476 }
1477 break;
1479 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1480 impatience = parse<double>(value);
1481 // mark parameter as set
1483 } else {
1484 // set default value
1485 impatience = parse<double>(myTagProperty.getDefaultValue(key));
1486 // unset parameter
1487 parametersSet &= ~VTYPEPARS_IMPATIENCE_SET;
1488 }
1489 break;
1490 // LCM Attributes
1506
1507 /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
1508 // empty values means that value isn't set
1509 if (value.empty()) {
1510 const auto it = lcParameter.find(key);
1511 if (it != lcParameter.end()) {
1512 lcParameter.erase(it);
1513 }
1514 } else {
1515 lcParameter[key] = value;
1516 }
1517 break;
1519 // empty or -1 value means that value isn't set
1520 if (value.empty() || (canParse<double>(value) && (parse<double>(value) == -1))) {
1521 const auto it = lcParameter.find(key);
1522 if (it != lcParameter.end()) {
1523 lcParameter.erase(it);
1524 }
1525 } else {
1526 lcParameter[key] = value;
1527 }
1528 break;
1533 // empty or null values means that value isn't set
1534 if (value.empty() || (canParse<double>(value) && (parse<double>(value) == 0))) {
1535 const auto it = lcParameter.find(key);
1536 if (it != lcParameter.end()) {
1537 lcParameter.erase(it);
1538 }
1539 } else {
1540 lcParameter[key] = value;
1541 }
1542 break;
1543 //
1544 case SUMO_ATTR_LENGTH:
1545 if (!value.empty() && (value != toString(defaultValues.length))) {
1546 length = parse<double>(value);
1547 // mark parameter as set
1549 } else {
1550 // set default value
1551 length = defaultValues.length;
1552 // unset parameter
1553 parametersSet &= ~VTYPEPARS_LENGTH_SET;
1554 }
1555 break;
1556 case SUMO_ATTR_MINGAP:
1557 if (!value.empty() && (value != toString(defaultValues.minGap))) {
1558 minGap = parse<double>(value);
1559 // mark parameter as set
1561 } else {
1562 // set default value
1563 minGap = defaultValues.minGap;
1564 // unset parameter
1565 parametersSet &= ~VTYPEPARS_MINGAP_SET;
1566 }
1567 break;
1568 case SUMO_ATTR_MAXSPEED:
1569 if (!value.empty() && (value != toString(defaultValues.maxSpeed))) {
1570 maxSpeed = parse<double>(value);
1571 // mark parameter as set
1573 } else {
1574 // set default value
1575 maxSpeed = defaultValues.maxSpeed;
1576 // unset parameter
1577 parametersSet &= ~VTYPEPARS_MAXSPEED_SET;
1578 }
1579 break;
1581 if (!value.empty() && (value != toString(defaultValues.speedFactor))) {
1582 speedFactor.parse(value, false);
1583 // mark parameter as set
1585 } else {
1586 // set default value
1587 speedFactor.parse(toString(defaultValues.speedFactor), false);
1588 // unset parameter
1589 parametersSet &= ~VTYPEPARS_SPEEDFACTOR_SET;
1590 }
1591 break;
1593 if (!value.empty() && (value != toString(defaultValues.desiredMaxSpeed))) {
1594 desiredMaxSpeed = parse<double>(value);
1595 // mark parameter as set
1597 } else {
1598 // set default value
1599 desiredMaxSpeed = defaultValues.desiredMaxSpeed;
1600 // unset parameter
1601 parametersSet &= ~VTYPEPARS_DESIRED_MAXSPEED_SET;
1602 }
1603 break;
1604 case SUMO_ATTR_COLOR:
1605 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1606 color = parse<RGBColor>(value);
1607 // mark parameter as set
1609 } else {
1610 // unset parameter
1611 parametersSet &= ~VTYPEPARS_COLOR_SET;
1612 }
1613 break;
1614 case SUMO_ATTR_VCLASS:
1615 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1617 // mark parameter as set
1619 } else {
1620 // set default value
1622 // unset parameter
1623 parametersSet &= ~VTYPEPARS_VEHICLECLASS_SET;
1624 }
1625 // update default values
1626 updateDefaultVClassAttributes(defaultValues);
1627 break;
1629 if (!value.empty() && (value != toString(defaultValues.emissionClass))) {
1631 // mark parameter as set
1633 } else {
1634 // set default value
1635 emissionClass = defaultValues.emissionClass;
1636 // unset parameter
1637 parametersSet &= ~VTYPEPARS_EMISSIONCLASS_SET;
1638 }
1639 break;
1640 case SUMO_ATTR_GUISHAPE:
1641 if (!value.empty() && (value != SumoVehicleShapeStrings.getString(defaultValues.shape))) {
1642 shape = getVehicleShapeID(value);
1643 // mark parameter as set
1645 } else {
1646 // set default value
1647 shape = defaultValues.shape;
1648 // unset parameter
1649 parametersSet &= ~VTYPEPARS_SHAPE_SET;
1650 }
1651 break;
1652 case SUMO_ATTR_WIDTH:
1653 if (!value.empty() && (value != toString(defaultValues.width))) {
1654 width = parse<double>(value);
1655 // mark parameter as set
1657 } else {
1658 // set default value
1659 width = defaultValues.width;
1660 // unset parameter
1661 parametersSet &= ~VTYPEPARS_WIDTH_SET;
1662 }
1663 break;
1664 case SUMO_ATTR_HEIGHT:
1665 if (!value.empty() && (value != toString(defaultValues.height))) {
1666 height = parse<double>(value);
1667 // mark parameter as set
1669 } else {
1670 // set default value
1671 height = defaultValues.height;
1672 // unset parameter
1673 parametersSet &= ~VTYPEPARS_HEIGHT_SET;
1674 }
1675 break;
1676 case SUMO_ATTR_IMGFILE:
1677 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1678 imgFile = value;
1679 // mark parameter as set
1681 } else {
1682 // set default value
1684 // unset parameter
1685 parametersSet &= ~VTYPEPARS_IMGFILE_SET;
1686 }
1687 break;
1689 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1691 // mark parameter as set
1693 } else {
1694 // set default value
1696 // unset parameter
1697 parametersSet &= ~VTYPEPARS_LANE_CHANGE_MODEL_SET;
1698 }
1699 break;
1701 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1703 // mark parameter as set
1705 } else {
1706 // set default value
1708 // unset parameter
1709 parametersSet &= ~VTYPEPARS_CAR_FOLLOW_MODEL;
1710 }
1711 break;
1713 if (!value.empty() && (value != toString(defaultValues.personCapacity))) {
1714 personCapacity = parse<int>(value);
1715 // mark parameter as set
1717 } else {
1718 // set default value
1719 personCapacity = defaultValues.personCapacity;
1720 // unset parameter
1721 parametersSet &= ~VTYPEPARS_PERSON_CAPACITY;
1722 }
1723 break;
1725 if (!value.empty() && (value != toString(defaultValues.containerCapacity))) {
1726 containerCapacity = parse<int>(value);
1727 // mark parameter as set
1729 } else {
1730 // set default value
1731 containerCapacity = defaultValues.containerCapacity;
1732 // unset parameter
1733 parametersSet &= ~VTYPEPARS_CONTAINER_CAPACITY;
1734 }
1735 break;
1737 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1739 // mark parameter as set
1741 } else {
1742 // set default value
1744 // unset parameter
1745 parametersSet &= ~VTYPEPARS_BOARDING_DURATION;
1746 }
1747 break;
1749 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1751 // mark parameter as set
1753 } else {
1754 // set default value
1756 // unset parameter
1757 parametersSet &= ~VTYPEPARS_LOADING_DURATION;
1758 }
1759 break;
1761 if (!value.empty() && (value != toString(defaultValues.latAlignmentProcedure))) {
1763 // mark parameter as set
1765 } else {
1766 // set default value
1768 // unset parameter
1769 parametersSet &= ~VTYPEPARS_LATALIGNMENT_SET;
1770 }
1771 break;
1773 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1774 minGapLat = parse<double>(value);
1775 // mark parameter as set
1777 } else {
1778 // set default value
1779 minGapLat = parse<double>(myTagProperty.getDefaultValue(key));
1780 // unset parameter
1781 parametersSet &= ~VTYPEPARS_MINGAP_LAT_SET;
1782 }
1783 break;
1785 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1786 maxSpeedLat = parse<double>(value);
1787 // mark parameter as set
1789 } else {
1790 // set default value
1791 maxSpeedLat = parse<double>(myTagProperty.getDefaultValue(key));
1792 // unset parameter
1793 parametersSet &= ~VTYPEPARS_MAXSPEED_LAT_SET;
1794 }
1795 break;
1797 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1799 // mark parameter as set
1801 } else {
1802 // set default value
1804 // unset parameter
1805 parametersSet &= ~VTYPEPARS_ACTIONSTEPLENGTH_SET;
1806 }
1807 break;
1808 case SUMO_ATTR_PROB:
1809 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1810 defaultProbability = parse<double>(value);
1811 // mark parameter as set
1813 } else {
1814 // set default value
1815 defaultProbability = parse<double>(myTagProperty.getDefaultValue(key));
1816 // unset parameter
1817 parametersSet &= ~VTYPEPARS_PROBABILITY_SET;
1818 }
1819 break;
1820 case SUMO_ATTR_OSGFILE:
1821 if (!value.empty() && (value != defaultValues.osgFile)) {
1822 osgFile = value;
1823 // mark parameter as set
1825 } else {
1826 // set default value
1827 osgFile = defaultValues.osgFile;
1828 // unset parameter
1829 parametersSet &= ~VTYPEPARS_OSGFILE_SET;
1830 }
1831 break;
1833 if (!value.empty() && (value != toString(defaultValues.carriageLength))) {
1834 carriageLength = parse<double>(value);
1835 // mark parameter as set
1837 // set parameter in SUMOVTypeParameter (needed for writting in XML)
1839 } else {
1840 // set default value
1841 carriageLength = defaultValues.carriageLength;
1842 // unset parameter
1843 parametersSet &= ~VTYPEPARS_CARRIAGE_LENGTH_SET;
1844 // remove from params (needed for writting in XML)
1846 }
1847 break;
1849 if (!value.empty() && (value != toString(defaultValues.containerCapacity))) {
1850 locomotiveLength = parse<double>(value);
1851 // mark parameter as set
1853 // set parameter in SUMOVTypeParameter (needed for writting in XML)
1855 } else {
1856 // set default value
1857 locomotiveLength = defaultValues.locomotiveLength;
1858 // unset parameter
1859 parametersSet &= ~VTYPEPARS_LOCOMOTIVE_LENGTH_SET;
1860 // remove from params (needed for writting in XML)
1862 }
1863 break;
1865 if (!value.empty() && (value != myTagProperty.getDefaultValue(key))) {
1866 carriageGap = parse<double>(value);
1867 // mark parameter as set
1869 // set parameter in SUMOVTypeParameter (needed for writting in XML)
1871 } else {
1872 // set default value
1873 carriageGap = parse<double>(myTagProperty.getDefaultValue(key));
1874 // unset parameter
1875 parametersSet &= ~VTYPEPARS_CARRIAGE_GAP_SET;
1876 // remove from params (needed for writting in XML)
1878 }
1879 break;
1880 case GNE_ATTR_SELECTED:
1881 if (parse<bool>(value)) {
1883 } else {
1885 }
1886 break;
1888 setParametersStr(value);
1889 break;
1891 myDefaultVehicleTypeModified = parse<bool>(value);
1892 break;
1893 default:
1894 throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
1895 }
1896 // check if geometry must be marked as deprecated
1899 }
1900}
1901
1902
1903void
1905 // vehicleTypes cannot be moved
1906}
1907
1908
1909void
1910GNEVType::commitMoveShape(const GNEMoveResult& /*moveResult*/, GNEUndoList* /*undoList*/) {
1911 // vehicleTypes cannot be moved
1912}
1913
1914
1915void
1918 length = defaultValues.length;
1919 }
1921 minGap = defaultValues.minGap;
1922 }
1924 maxSpeed = defaultValues.maxSpeed;
1925 }
1927 width = defaultValues.width;
1928 }
1930 height = defaultValues.height;
1931 }
1933 shape = defaultValues.shape;
1934 }
1936 emissionClass = defaultValues.emissionClass;
1937 }
1939 speedFactor = defaultValues.speedFactor;
1940 }
1942 desiredMaxSpeed = defaultValues.desiredMaxSpeed;
1943 }
1945 personCapacity = defaultValues.personCapacity;
1946 }
1948 containerCapacity = defaultValues.containerCapacity;
1949 }
1951 osgFile = defaultValues.osgFile;
1952 }
1954 carriageLength = defaultValues.carriageLength;
1955 }
1957 locomotiveLength = defaultValues.locomotiveLength;
1958 }
1959}
1960
1961/****************************************************************************/
@ GLO_VTYPE
@bief vTypes
GUIIcon
An enumeration of icons used by the gui applications.
Definition: GUIIcons.h:33
@ VTYPEDISTRIBUTION
#define WRITE_DEBUG(msg)
Definition: MsgHandler.h:276
std::string time2string(SUMOTime t)
convert SUMOTime to string
Definition: SUMOTime.cpp:68
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition: SUMOTime.cpp:45
const 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_PEDTYPE_ID
const std::string DEFAULT_VTYPE_ID
const std::string DEFAULT_BIKETYPE_ID
@ SUMO_TAG_VTYPE
description of a vehicle/person/container type
@ SUMO_TAG_VTYPE_DISTRIBUTION
distribution of a vehicle type
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
@ SUMO_ATTR_TMP4
@ SUMO_ATTR_CF_EIDM_T_ACC_MAX
@ SUMO_ATTR_CF_EIDM_EPSILON_ACC
@ SUMO_ATTR_LCA_PUSHY
@ SUMO_ATTR_EMISSIONCLASS
@ SUMO_ATTR_JM_IGNORE_FOE_SPEED
@ SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME
@ SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD
@ SUMO_ATTR_CF_WIEDEMANN_SECURITY
@ SUMO_ATTR_LCA_ASSERTIVE
@ SUMO_ATTR_TRAIN_TYPE
@ SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS
@ SUMO_ATTR_CF_IDMM_ADAPT_TIME
@ SUMO_ATTR_LANE_CHANGE_MODEL
@ SUMO_ATTR_CF_KERNER_PHI
@ SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE
@ SUMO_ATTR_CF_EIDM_C_COOLNESS
@ SUMO_ATTR_CF_EIDM_SIG_ERROR
@ SUMO_ATTR_LCA_PUSHYGAP
@ SUMO_ATTR_LCA_LOOKAHEADLEFT
@ SUMO_ATTR_APPARENTDECEL
@ SUMO_ATTR_MAXSPEED_LAT
@ SUMO_ATTR_LCA_SPEEDGAIN_PARAM
@ SUMO_ATTR_TMP3
@ SUMO_ATTR_ACTIONSTEPLENGTH
@ GNE_ATTR_SELECTED
element is selected
@ SUMO_ATTR_LCA_IMPATIENCE
@ SUMO_ATTR_MINGAP
@ GNE_ATTR_VTYPE_DISTRIBUTION
vehicle type distribution
@ GNE_ATTR_PARAMETERS
parameters "key1=value1|key2=value2|...|keyN=valueN"
@ SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME
@ SUMO_ATTR_TMP2
@ SUMO_ATTR_LOADING_DURATION
@ SUMO_ATTR_CF_IDM_DELTA
@ SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW
@ SUMO_ATTR_LCA_MAXSPEEDLATFACTOR
@ GNE_ATTR_DEFAULT_VTYPE
Flag to check if VType is a default VType.
@ SUMO_ATTR_CF_EIDM_T_REACTION
@ SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE
@ SUMO_ATTR_CF_PWAGNER2009_TAULAST
@ SUMO_ATTR_CF_EIDM_SIG_GAP
@ SUMO_ATTR_CAR_FOLLOW_MODEL
@ SUMO_ATTR_CF_EIDM_JERK_MAX
@ SUMO_ATTR_DECEL
@ SUMO_ATTR_LCA_MAXSPEEDLATSTANDING
@ SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME
@ SUMO_ATTR_LCA_KEEPRIGHT_PARAM
@ SUMO_ATTR_GUISHAPE
@ SUMO_ATTR_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_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_JM_SIGMA_MINOR
@ SUMO_ATTR_PROB
@ SUMO_ATTR_CF_EIDM_M_BEGIN
@ SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE
@ SUMO_ATTR_SPEEDFACTOR
@ SUMO_ATTR_CF_EIDM_SIG_LEADER
@ SUMO_ATTR_LENGTH
@ SUMO_ATTR_COLOR
A color information.
@ SUMO_ATTR_CF_PWAGNER2009_APPROB
@ SUMO_ATTR_MAXSPEED
@ SUMO_ATTR_ID
@ SUMO_ATTR_SIGMA
@ GNE_ATTR_DEFAULT_VTYPE_MODIFIED
Flag to check if a default VType was modified.
@ SUMO_ATTR_K
@ SUMO_ATTR_TMP1
@ SUMO_ATTR_OSGFILE
@ SUMO_ATTR_LCA_OVERTAKE_RIGHT
@ SUMO_ATTR_LCA_ACCEL_LAT
@ SUMO_ATTR_LCA_STRATEGIC_PARAM
@ SUMO_ATTR_TAU
@ SUMO_ATTR_IMGFILE
@ SUMO_ATTR_WIDTH
@ SUMO_ATTR_PERSON_CAPACITY
@ SUMO_ATTR_LCA_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 atribute requires a update geometry in setAttribute(...)
the function-object for an editing operation (abstract base)
void forceChange()
force change
An Element which don't belong to GNENet but has influence in the simulation.
virtual std::string getAttribute(SumoXMLAttr key) const =0
void setVTypeDistributionParent(const std::string &value)
set VTypeDistribution parent
virtual void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)=0
method for setting the attribute and letting the object perform demand element changes
Problem
enum class for demandElement problems
const std::vector< GNEDemandElement * > & getChildDemandElements() const
return child demand elements
const std::vector< GNEDemandElement * > & getParentDemandElements() const
get parent demand elements
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:46
move operation
move result
GNEDemandElement * retrieveDemandElement(SumoXMLTag type, const std::string &id, bool hardFail=true) const
Returns the named demand element.
A NBNetBuilder extended by visualisation and editing capabilities.
Definition: GNENet.h:42
GNENetHelper::AttributeCarriers * getAttributeCarriers() const
get all attribute carriers used in this net
Definition: GNENet.cpp:132
GNEViewNet * getViewNet() const
get view net
Definition: GNENet.cpp:1987
const GNEAttributeProperties & getAttributeProperties(SumoXMLAttr attr) const
get attribute (throw error if doesn't exist)
GUIIcon getGUIIcon() const
get GUI icon associated to this Tag
const std::string & getDefaultValue(SumoXMLAttr attr) const
return the default value of the attribute of an element
bool hasAttribute(SumoXMLAttr attr) const
check if current TagProperties owns the attribute "attr"
void end()
End undo command sub-group. If the sub-group is still empty, it will be deleted; otherwise,...
void begin(GUIIcon icon, const std::string &description)
Begin undo command sub-group with current supermode. This begins a new group of commands that are tre...
void add(GNEChange *command, bool doit=false, bool merge=true)
Add new command, executing it if desired. The new command will be merged with the previous command if...
void changeAttribute(GNEChange_Attribute *change)
special method for change attributes, avoid empty changes, always execute
Problem isDemandElementValid() const
check if current demand element is valid to be writed into XML
Definition: GNEVType.cpp:108
double getExaggeration(const GUIVisualizationSettings &s) const
return exaggeration associated with this GLObject
Definition: GNEVType.cpp:160
std::string getHierarchyName() const
get Hierarchy Name (Used in AC Hierarchy)
Definition: GNEVType.cpp:945
void updateGeometry()
update pre-computed geometry information
Definition: GNEVType.cpp:139
std::string getParentName() const
Returns the name of the parent object.
Definition: GNEVType.cpp:154
~GNEVType()
destructor
Definition: GNEVType.cpp:85
bool askRemoveVTypeDistribution(const std::string &vTypeDistribution) const
ask if remove vTypeDistribution
Definition: GNEVType.cpp:1359
bool isValid(SumoXMLAttr key, const std::string &value)
method for checking if the key and their conrrespond attribute are valids
Definition: GNEVType.cpp:687
bool askAddVTypeDistribution(const std::string &vTypeDistribution) const
ask if add vTypeDistribution
Definition: GNEVType.cpp:1335
GNEMoveOperation * getMoveOperation()
get move operation
Definition: GNEVType.cpp:89
Position getPositionInView() const
Returns position of additional in view.
Definition: GNEVType.cpp:148
void drawPartialGL(const GUIVisualizationSettings &s, const GNELane *lane, const GNEPathManager::Segment *segment, const double offsetFront) const
Draws partial object.
Definition: GNEVType.cpp:191
bool isAttributeEnabled(SumoXMLAttr key) const
Definition: GNEVType.cpp:902
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:548
static void overwriteVType(GNEDemandElement *vType, const SUMOVTypeParameter newVTypeParameter, GNEUndoList *undoList)
overwrite all values of GNEVType with a SUMOVTypeParameter
Definition: GNEVType.cpp:957
void updateDefaultVClassAttributes(const VClassDefaultValues &defaultValues)
function called after set new VClass
Definition: GNEVType.cpp:1916
void commitMoveShape(const GNEMoveResult &moveResult, GNEUndoList *undoList)
commit move shape
Definition: GNEVType.cpp:1910
GNELane * getFirstPathLane() const
get first path lane
Definition: GNEVType.cpp:203
GNELane * getLastPathLane() const
get last path lane
Definition: GNEVType.cpp:210
void splitEdgeGeometry(const double splitPosition, const GNENetworkElement *originalElement, const GNENetworkElement *newElement, GNEUndoList *undoList)
split geometry
Definition: GNEVType.cpp:173
void writeDemandElement(OutputDevice &device) const
write demand element element into a xml file
Definition: GNEVType.cpp:95
bool myDefaultVehicleType
flag to check if this GNEVType is a default vehicle Type (For Vehicles, Pedestrians....
Definition: GNEVType.h:198
const RGBColor & getColor() const
get color
Definition: GNEVType.cpp:133
std::string getDemandElementProblem() const
return a string with the current demand element problem
Definition: GNEVType.cpp:115
const Parameterised::Map & getACParametersMap() const
get parameters map
Definition: GNEVType.cpp:951
void fixDemandElementProblem()
fix demand element problem
Definition: GNEVType.cpp:121
void setMoveShape(const GNEMoveResult &moveResult)
set move shape
Definition: GNEVType.cpp:1904
GNEVType(GNENet *net)
default constructor
Definition: GNEVType.cpp:35
Position getAttributePosition(SumoXMLAttr key) const
Definition: GNEVType.cpp:542
double getAttributeDouble(SumoXMLAttr key) const
Definition: GNEVType.cpp:501
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
Definition: GNEVType.cpp:179
std::string getAttribute(SumoXMLAttr key) const
inherited from GNEAttributeCarrier
Definition: GNEVType.cpp:217
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
Definition: GNEVType.cpp:166
void computePathElement()
compute pathElement
Definition: GNEVType.cpp:185
std::string getPopUpID() const
get PopPup ID (Used in AC Hierarchy)
Definition: GNEVType.cpp:939
SUMOVehicleClass getVClass() const
Definition: GNEVType.cpp:127
void editVTypeDistribution(const std::string &vTypeDistributionID, GNEUndoList *undoList)
edit vType distribution
Definition: GNEVType.cpp:1278
bool myDefaultVehicleTypeModified
flag to check if this default GNEVType was modified
Definition: GNEVType.h:201
const std::string & getMicrosimID() const
Returns the id of the object as known to microsim.
Definition: GUIGlObject.h:141
virtual void setMicrosimID(const std::string &newID)
Changes the microsimID of the object.
Stores the information about how to visualize structures.
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
static bool areParametersValid(const std::string &value, bool report=false, const std::string kvsep="=", const std::string sep="|")
check if given string can be parsed to a parameters map "key1=value1|key2=value2|....
void unsetParameter(const std::string &key)
Removes a parameter.
std::map< std::string, std::string > Map
parameters map
Definition: Parameterised.h:45
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
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