Eclipse SUMO - Simulation of Urban MObility
GNEAttributeCarrier.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// Abstract Base class for gui objects which carry attributes
19/****************************************************************************/
20#include <netedit/GNENet.h>
21#include <netedit/GNEViewNet.h>
27
28#include "GNEAttributeCarrier.h"
29
30
31// ===========================================================================
32// static members
33// ===========================================================================
34
35std::map<SumoXMLTag, GNETagProperties> GNEAttributeCarrier::myTagProperties;
36const std::string GNEAttributeCarrier::FEATURE_LOADED = "loaded";
37const std::string GNEAttributeCarrier::FEATURE_GUESSED = "guessed";
38const std::string GNEAttributeCarrier::FEATURE_MODIFIED = "modified";
39const std::string GNEAttributeCarrier::FEATURE_APPROVED = "approved";
42const std::string GNEAttributeCarrier::True = toString(true);
43const std::string GNEAttributeCarrier::False = toString(false);
44
45
46// ===========================================================================
47// method definitions
48// ===========================================================================
49
51 myTagProperty(getTagProperty(tag)),
52 myNet(net),
53 mySelected(false),
54 myIsTemplate(false) {
55}
56
57
59
60
61const std::string
64}
65
66
67GNENet*
69 return myNet;
70}
71
72
73void
76 gSelected.select(getGUIGlObject()->getGlID());
77 if (changeFlag) {
78 mySelected = true;
79 }
80 }
81}
82
83
84void
87 gSelected.deselect(getGUIGlObject()->getGlID());
88 if (changeFlag) {
89 mySelected = false;
90 }
91 }
92}
93
94
95bool
97 return mySelected;
98}
99
100
101bool
103 // get flag for network element
104 const bool networkElement = myTagProperty.isNetworkElement() || myTagProperty.isAdditionalElement();
105 // check supermode network
106 if ((networkElement && myNet->getViewNet()->getEditModes().isCurrentSupermodeNetwork()) ||
109 return mySelected;
110 } else {
111 return false;
112 }
113}
114
115
116void
118 for (const auto& attrProperty : myTagProperty) {
119 if (attrProperty.hasDefaultValue()) {
120 setAttribute(attrProperty.getAttr(), attrProperty.getDefaultValue());
121 if (attrProperty.isActivatable()) {
122 toggleAttribute(attrProperty.getAttr(), attrProperty.getDefaultActivated());
123 }
124 }
125 }
126}
127
128
129void
131 throw ProcessError("Nothing to enable, implement in Children");
132
133}
134
135
136void
138 throw ProcessError("Nothing to disable, implement in Children");
139}
140
141
142bool
144 // by default, all attributes are enabled
145 return true;
146}
147
148
149bool
151 // by default, all attributes aren't computed
152 return false;
153}
154
155
156template<> int
157GNEAttributeCarrier::parse(const std::string& string) {
158 return StringUtils::toInt(string);
159}
160
161
162template<> double
163GNEAttributeCarrier::parse(const std::string& string) {
164 return StringUtils::toDouble(string);
165}
166
167
168template<> SUMOTime
169GNEAttributeCarrier::parse(const std::string& string) {
170 SUMOTime time = string2time(string);
171 if (time < 0) {
172 throw TimeFormatException("SUMOTIME cannot be negative");
173 } else {
174 return time;
175 }
176}
177
178
179template<> bool
180GNEAttributeCarrier::parse(const std::string& string) {
181 return StringUtils::toBool(string);
182}
183
184
185template<> std::string
186GNEAttributeCarrier::parse(const std::string& string) {
187 return string;
188}
189
190
191template<> SUMOVehicleClass
192GNEAttributeCarrier::parse(const std::string& string) {
193 if (string.size() == 0) {
194 throw EmptyData();
195 } else if (!SumoVehicleClassStrings.hasString(string)) {
196 return SVC_IGNORING;
197 } else {
198 return SumoVehicleClassStrings.get(string);
199 }
200}
201
202
203template<> RGBColor
204GNEAttributeCarrier::parse(const std::string& string) {
205 if (string.empty()) {
206 return RGBColor::INVISIBLE;
207 } else {
208 return RGBColor::parseColor(string);
209 }
210}
211
212
213template<> Position
214GNEAttributeCarrier::parse(const std::string& string) {
215 if (string.size() == 0) {
216 throw EmptyData();
217 } else {
218 bool ok = true;
219 PositionVector pos = GeomConvHelper::parseShapeReporting(string, "user-supplied position", 0, ok, false, false);
220 if (!ok || (pos.size() != 1)) {
221 throw NumberFormatException("(Position) " + string);
222 } else {
223 return pos[0];
224 }
225 }
226}
227
228
229template<> PositionVector
230GNEAttributeCarrier::parse(const std::string& string) {
231 PositionVector posVector;
232 // empty string are allowed (It means empty position vector)
233 if (string.empty()) {
234 return posVector;
235 } else {
236 bool ok = true;
237 posVector = GeomConvHelper::parseShapeReporting(string, "user-supplied shape", 0, ok, false, true);
238 if (!ok) {
239 throw NumberFormatException("(Position List) " + string);
240 } else {
241 return posVector;
242 }
243 }
244}
245
246
247template<> SUMOVehicleShape
248GNEAttributeCarrier::parse(const std::string& string) {
249 if ((string == "unknown") || (!SumoVehicleShapeStrings.hasString(string))) {
251 } else {
252 return SumoVehicleShapeStrings.get(string);
253 }
254}
255
256
257template<> std::vector<std::string>
258GNEAttributeCarrier::parse(const std::string& string) {
259 return StringTokenizer(string).getVector();
260}
261
262
263template<> std::set<std::string>
264GNEAttributeCarrier::parse(const std::string& string) {
265 std::vector<std::string> vectorString = StringTokenizer(string).getVector();
266 std::set<std::string> solution;
267 for (const auto& i : vectorString) {
268 solution.insert(i);
269 }
270 return solution;
271}
272
273
274template<> std::vector<int>
275GNEAttributeCarrier::parse(const std::string& string) {
276 std::vector<std::string> parsedValues = parse<std::vector<std::string> >(string);
277 std::vector<int> parsedIntValues;
278 for (const auto& i : parsedValues) {
279 parsedIntValues.push_back(parse<int>(i));
280 }
281 return parsedIntValues;
282}
283
284
285template<> std::vector<double>
286GNEAttributeCarrier::parse(const std::string& string) {
287 std::vector<std::string> parsedValues = parse<std::vector<std::string> >(string);
288 std::vector<double> parsedDoubleValues;
289 for (const auto& i : parsedValues) {
290 parsedDoubleValues.push_back(parse<double>(i));
291 }
292 return parsedDoubleValues;
293}
294
295
296template<> std::vector<bool>
297GNEAttributeCarrier::parse(const std::string& string) {
298 std::vector<std::string> parsedValues = parse<std::vector<std::string> >(string);
299 std::vector<bool> parsedBoolValues;
300 for (const auto& i : parsedValues) {
301 parsedBoolValues.push_back(parse<bool>(i));
302 }
303 return parsedBoolValues;
304}
305
306
307template<> std::vector<GNEEdge*>
308GNEAttributeCarrier::parse(GNENet* net, const std::string& value) {
309 // Declare string vector
310 std::vector<std::string> edgeIds = GNEAttributeCarrier::parse<std::vector<std::string> > (value);
311 std::vector<GNEEdge*> parsedEdges;
312 // Iterate over edges IDs, retrieve Edges and add it into parsedEdges
313 for (const auto& i : edgeIds) {
314 GNEEdge* retrievedEdge = net->getAttributeCarriers()->retrieveEdge(i, false);
315 if (retrievedEdge) {
316 parsedEdges.push_back(net->getAttributeCarriers()->retrieveEdge(i));
317 } else {
318 throw FormatException("Error parsing parameter " + toString(SUMO_ATTR_EDGES) + ". " + toString(SUMO_TAG_EDGE) + " '" + i + "' doesn't exist");
319 }
320 }
321 return parsedEdges;
322}
323
324
325template<> std::vector<GNELane*>
326GNEAttributeCarrier::parse(GNENet* net, const std::string& value) {
327 // Declare string vector
328 std::vector<std::string> laneIds = GNEAttributeCarrier::parse<std::vector<std::string> > (value);
329 std::vector<GNELane*> parsedLanes;
330 // Iterate over lanes IDs, retrieve Lanes and add it into parsedLanes
331 for (const auto& i : laneIds) {
332 GNELane* retrievedLane = net->getAttributeCarriers()->retrieveLane(i, false);
333 if (retrievedLane) {
334 parsedLanes.push_back(net->getAttributeCarriers()->retrieveLane(i));
335 } else {
336 throw FormatException("Error parsing parameter " + toString(SUMO_ATTR_LANES) + ". " + toString(SUMO_TAG_LANE) + " '" + i + "' doesn't exist");
337 }
338 }
339 return parsedLanes;
340}
341
342
343template<> std::string
344GNEAttributeCarrier::parseIDs(const std::vector<GNEEdge*>& ACs) {
345 // obtain ID's of edges and return their join
346 std::vector<std::string> edgeIDs;
347 for (const auto& i : ACs) {
348 edgeIDs.push_back(i->getID());
349 }
350 return joinToString(edgeIDs, " ");
351}
352
353
354template<> std::string
355GNEAttributeCarrier::parseIDs(const std::vector<GNELane*>& ACs) {
356 // obtain ID's of lanes and return their join
357 std::vector<std::string> laneIDs;
358 for (const auto& i : ACs) {
359 laneIDs.push_back(i->getID());
360 }
361 return joinToString(laneIDs, " ");
362}
363
364
365bool
366GNEAttributeCarrier::lanesConsecutives(const std::vector<GNELane*>& lanes) {
367 // we need at least two lanes
368 if (lanes.size() > 1) {
369 // now check that lanes are consecutives (not neccesary connected)
370 int currentLane = 0;
371 while (currentLane < ((int)lanes.size() - 1)) {
372 int nextLane = -1;
373 // iterate over outgoing edges of destiny juntion of edge's lane
374 for (int i = 0; (i < (int)lanes.at(currentLane)->getParentEdge()->getToJunction()->getGNEOutgoingEdges().size()) && (nextLane == -1); i++) {
375 // iterate over lanes of outgoing edges of destiny juntion of edge's lane
376 for (int j = 0; (j < (int)lanes.at(currentLane)->getParentEdge()->getToJunction()->getGNEOutgoingEdges().at(i)->getLanes().size()) && (nextLane == -1); j++) {
377 // check if lane correspond to the next lane of "lanes"
378 if (lanes.at(currentLane)->getParentEdge()->getToJunction()->getGNEOutgoingEdges().at(i)->getLanes().at(j) == lanes.at(currentLane + 1)) {
379 nextLane = currentLane;
380 }
381 }
382 }
383 if (nextLane == -1) {
384 return false;
385 } else {
386 currentLane++;
387 }
388 }
389 return true;
390 } else {
391 return false;
392 }
393}
394
395
396FXIcon*
398 switch (vc) {
399 case SVC_IGNORING:
401 case SVC_PRIVATE:
403 case SVC_EMERGENCY:
405 case SVC_AUTHORITY:
407 case SVC_ARMY:
409 case SVC_VIP:
411 case SVC_PEDESTRIAN:
413 case SVC_PASSENGER:
415 case SVC_HOV:
417 case SVC_TAXI:
419 case SVC_BUS:
421 case SVC_COACH:
423 case SVC_DELIVERY:
425 case SVC_TRUCK:
427 case SVC_TRAILER:
429 case SVC_MOTORCYCLE:
431 case SVC_MOPED:
433 case SVC_BICYCLE:
435 case SVC_E_VEHICLE:
437 case SVC_TRAM:
439 case SVC_RAIL_URBAN:
441 case SVC_RAIL:
445 case SVC_RAIL_FAST:
447 case SVC_SHIP:
449 case SVC_CUSTOM1:
451 case SVC_CUSTOM2:
453 default:
454 throw ProcessError("Invalid vClass");
455 }
456}
457
458
459template<> std::string
461 std::string result;
462 // Generate an string using the following structure: "key1=value1|key2=value2|...
463 for (const auto& parameter : getACParametersMap()) {
464 result += parameter.first + "=" + parameter.second + "|";
465 }
466 // remove the last "|"
467 if (!result.empty()) {
468 result.pop_back();
469 }
470 return result;
471}
472
473
474template<> std::vector<std::pair<std::string, std::string> >
476 std::vector<std::pair<std::string, std::string> > result;
477 // Generate a vector string using the following structure: "<key1,value1>, <key2, value2>,...
478 for (const auto& parameter : getACParametersMap()) {
479 result.push_back(std::make_pair(parameter.first, parameter.second));
480 }
481 return result;
482}
483
484
485void
486GNEAttributeCarrier::setACParameters(const std::string& parameters, GNEUndoList* undoList) {
487 // declare map
488 Parameterised::Map parametersMap;
489 // separate value in a vector of string using | as separator
490 StringTokenizer parametersTokenizer(parameters, "|", true);
491 // iterate over all values
492 while (parametersTokenizer.hasNext()) {
493 // obtain key and value and save it in myParameters
494 const std::vector<std::string> keyValue = StringTokenizer(parametersTokenizer.next(), "=", true).getVector();
495 if (keyValue.size() == 2) {
496 parametersMap[keyValue.front()] = keyValue.back();
497 }
498 }
499 // set setACParameters map
500 setACParameters(parametersMap, undoList);
501}
502
503
504void
505GNEAttributeCarrier::setACParameters(const std::vector<std::pair<std::string, std::string> >& parameters, GNEUndoList* undoList) {
506 // declare parametersMap
507 Parameterised::Map parametersMap;
508 // Generate an string using the following structure: "key1=value1|key2=value2|...
509 for (const auto& parameter : parameters) {
510 parametersMap[parameter.first] = parameter.second;
511 }
512 // set setACParameters map
513 setACParameters(parametersMap, undoList);
514}
515
516
517void
519 // declare result string
520 std::string paramsStr;
521 // Generate an string using the following structure: "key1=value1|key2=value2|...
522 for (const auto& parameter : parameters) {
523 paramsStr += parameter.first + "=" + parameter.second + "|";
524 }
525 // remove the last "|"
526 if (!paramsStr.empty()) {
527 paramsStr.pop_back();
528 }
529 // set parameters
530 setAttribute(GNE_ATTR_PARAMETERS, paramsStr, undoList);
531}
532
533
534void
535GNEAttributeCarrier::addACParameters(const std::string& key, const std::string& attribute, GNEUndoList* undoList) {
536 // get parametersMap
537 Parameterised::Map parametersMap = getACParametersMap();
538 // add (or update) attribute
539 parametersMap[key] = attribute;
540 // set attribute
541 setACParameters(parametersMap, undoList);
542}
543
544
545void
546GNEAttributeCarrier::removeACParametersKeys(const std::vector<std::string>& keepKeys, GNEUndoList* undoList) {
547 // declare parametersMap
548 Parameterised::Map newParametersMap;
549 // iterate over parameters map
550 for (const auto& parameter : getACParametersMap()) {
551 // copy to newParametersMap if key is in keepKeys
552 if (std::find(keepKeys.begin(), keepKeys.end(), parameter.first) != keepKeys.end()) {
553 newParametersMap.insert(parameter);
554 }
555 }
556 // set newParametersMap map
557 setACParameters(newParametersMap, undoList);
558}
559
560
561std::string
563 switch (key) {
564 // Crossings
567 return "No TLS";
568 // connections
569 case SUMO_ATTR_DIR: {
570 // special case for connection directions
571 std::string direction = getAttribute(key);
572 if (direction == "s") {
573 return "Straight (s)";
574 } else if (direction == "t") {
575 return "Turn (t))";
576 } else if (direction == "l") {
577 return "Left (l)";
578 } else if (direction == "r") {
579 return "Right (r)";
580 } else if (direction == "L") {
581 return "Partially left (L)";
582 } else if (direction == "R") {
583 return "Partially right (R)";
584 } else if (direction == "invalid") {
585 return "No direction (Invalid))";
586 } else {
587 return "undefined";
588 }
589 }
590 case SUMO_ATTR_STATE: {
591 // special case for connection states
592 std::string state = getAttribute(key);
593 if (state == "-") {
594 return "Dead end (-)";
595 } else if (state == "=") {
596 return "equal (=)";
597 } else if (state == "m") {
598 return "Minor link (m)";
599 } else if (state == "M") {
600 return "Major link (M)";
601 } else if (state == "O") {
602 return "TLS controller off (O)";
603 } else if (state == "o") {
604 return "TLS yellow flashing (o)";
605 } else if (state == "y") {
606 return "TLS yellow minor link (y)";
607 } else if (state == "Y") {
608 return "TLS yellow major link (Y)";
609 } else if (state == "r") {
610 return "TLS red (r)";
611 } else if (state == "g") {
612 return "TLS green minor (g)";
613 } else if (state == "G") {
614 return "TLS green major (G)";
615 } else if (state == "Z") {
616 return "Zipper (Z)";
617 } else {
618 return "undefined";
619 }
620 }
621 default:
622 return getAttribute(key);
623 }
624}
625
626
627std::string
629 return getAttribute(key);
630}
631
632
633const std::string&
635 return myTagProperty.getTagStr();
636}
637
638
639FXIcon*
641 // define on first access
642 if (myTagProperties.size() == 0) {
644 }
645 // special case for vClass icons
648 } else {
650 }
651}
652
653
654bool
656 return myIsTemplate;
657}
658
659
660const GNETagProperties&
662 return myTagProperty;
663}
664
665// ===========================================================================
666// static methods
667// ===========================================================================
668
669const GNETagProperties&
671 // define on first access
672 if (myTagProperties.size() == 0) {
674 }
675 // check that tag is defined
676 if (myTagProperties.count(tag) == 0) {
677 throw ProcessError("TagProperty for tag '" + toString(tag) + "' not defined");
678 } else {
679 return myTagProperties.at(tag);
680 }
681}
682
683
684const std::vector<GNETagProperties>
685GNEAttributeCarrier::getTagPropertiesByType(const int tagPropertyCategory) {
686 std::vector<GNETagProperties> allowedTags;
687 // define on first access
688 if (myTagProperties.size() == 0) {
690 }
691 if (tagPropertyCategory & GNETagProperties::NETWORKELEMENT) {
692 // fill networkElements tags
693 for (const auto& tagProperty : myTagProperties) {
694 if (tagProperty.second.isNetworkElement()) {
695 allowedTags.push_back(tagProperty.second);
696 }
697 }
698 }
699 if (tagPropertyCategory & GNETagProperties::ADDITIONALELEMENT) {
700 // fill additional tags (only with pure additionals)
701 for (const auto& tagProperty : myTagProperties) {
702 // avoid symbols (It will be implemented in #7355)
703 if (tagProperty.second.isAdditionalPureElement() && !tagProperty.second.isSymbol()) {
704 allowedTags.push_back(tagProperty.second);
705 }
706 }
707 }
708 if (tagPropertyCategory & GNETagProperties::SYMBOL) {
709 // fill symbol tags
710 for (const auto& tagProperty : myTagProperties) {
711 if (tagProperty.second.isSymbol()) {
712 allowedTags.push_back(tagProperty.second);
713 }
714 }
715 }
716 if (tagPropertyCategory & GNETagProperties::SHAPE) {
717 // fill shape tags
718 for (const auto& tagProperty : myTagProperties) {
719 if (tagProperty.second.isShapeElement()) {
720 allowedTags.push_back(tagProperty.second);
721 }
722 }
723 }
724 if (tagPropertyCategory & GNETagProperties::TAZELEMENT) {
725 // fill taz tags
726 for (const auto& tagProperty : myTagProperties) {
727 if (tagProperty.second.isTAZElement()) {
728 allowedTags.push_back(tagProperty.second);
729 }
730 }
731 }
732 if (tagPropertyCategory & GNETagProperties::WIRE) {
733 // fill wire tags
734 for (const auto& tagProperty : myTagProperties) {
735 if (tagProperty.second.isWireElement()) {
736 allowedTags.push_back(tagProperty.second);
737 }
738 }
739 }
740 if (tagPropertyCategory & GNETagProperties::DEMANDELEMENT) {
741 // fill demand tags
742 for (const auto& tagProperty : myTagProperties) {
743 if (tagProperty.second.isDemandElement()) {
744 allowedTags.push_back(tagProperty.second);
745 }
746 }
747 }
748 if (tagPropertyCategory & GNETagProperties::ROUTE) {
749 // fill route tags
750 for (const auto& tagProperty : myTagProperties) {
751 if (tagProperty.second.isRoute()) {
752 allowedTags.push_back(tagProperty.second);
753 }
754 }
755 }
756 if (tagPropertyCategory & GNETagProperties::VEHICLE) {
757 // fill vehicle tags
758 for (const auto& tagProperty : myTagProperties) {
759 if (tagProperty.second.isVehicle()) {
760 allowedTags.push_back(tagProperty.second);
761 }
762 }
763 }
764 if (tagPropertyCategory & GNETagProperties::STOP) {
765 // fill stop tags
766 for (const auto& tagProperty : myTagProperties) {
767 if (tagProperty.second.isStop()) {
768 allowedTags.push_back(tagProperty.second);
769 }
770 }
771 }
772 if (tagPropertyCategory & GNETagProperties::PERSON) {
773 // fill person tags
774 for (const auto& tagProperty : myTagProperties) {
775 if (tagProperty.second.isPerson()) {
776 allowedTags.push_back(tagProperty.second);
777 }
778 }
779 }
780 if (tagPropertyCategory & GNETagProperties::PERSONPLAN) {
781 // fill person plan tags
782 for (const auto& tagProperty : myTagProperties) {
783 if (tagProperty.second.isPersonPlan()) {
784 allowedTags.push_back(tagProperty.second);
785 }
786 }
787 }
788 if (tagPropertyCategory & GNETagProperties::PERSONTRIP) {
789 // fill demand tags
790 for (const auto& tagProperty : myTagProperties) {
791 if (tagProperty.second.isPersonTrip()) {
792 allowedTags.push_back(tagProperty.second);
793 }
794 }
795 }
796 if (tagPropertyCategory & GNETagProperties::WALK) {
797 // fill demand tags
798 for (const auto& tagProperty : myTagProperties) {
799 if (tagProperty.second.isWalk()) {
800 allowedTags.push_back(tagProperty.second);
801 }
802 }
803 }
804 if (tagPropertyCategory & GNETagProperties::RIDE) {
805 // fill demand tags
806 for (const auto& tagProperty : myTagProperties) {
807 if (tagProperty.second.isRide()) {
808 allowedTags.push_back(tagProperty.second);
809 }
810 }
811 }
812 if (tagPropertyCategory & GNETagProperties::STOPPERSON) {
813 // fill demand tags
814 for (const auto& tagProperty : myTagProperties) {
815 if (tagProperty.second.isStopPerson()) {
816 allowedTags.push_back(tagProperty.second);
817 }
818 }
819 }
820 if (tagPropertyCategory & GNETagProperties::GENERICDATA) {
821 // fill generic data tags
822 for (const auto& tagProperty : myTagProperties) {
823 if (tagProperty.second.isGenericData()) {
824 allowedTags.push_back(tagProperty.second);
825 }
826 }
827 }
828 if (tagPropertyCategory & GNETagProperties::CONTAINER) {
829 // fill container tags
830 for (const auto& tagProperty : myTagProperties) {
831 if (tagProperty.second.isContainer()) {
832 allowedTags.push_back(tagProperty.second);
833 }
834 }
835 }
836 if (tagPropertyCategory & GNETagProperties::CONTAINERPLAN) {
837 // fill container plan tags
838 for (const auto& tagProperty : myTagProperties) {
839 if (tagProperty.second.isContainerPlan()) {
840 allowedTags.push_back(tagProperty.second);
841 }
842 }
843 }
844 if (tagPropertyCategory & GNETagProperties::TRANSPORT) {
845 // fill demand tags
846 for (const auto& tagProperty : myTagProperties) {
847 if (tagProperty.second.isTransportPlan()) {
848 allowedTags.push_back(tagProperty.second);
849 }
850 }
851 }
852 if (tagPropertyCategory & GNETagProperties::TRANSHIP) {
853 // fill demand tags
854 for (const auto& tagProperty : myTagProperties) {
855 if (tagProperty.second.isTranshipPlan()) {
856 allowedTags.push_back(tagProperty.second);
857 }
858 }
859 }
860 if (tagPropertyCategory & GNETagProperties::STOPCONTAINER) {
861 // fill demand tags
862 for (const auto& tagProperty : myTagProperties) {
863 if (tagProperty.second.isStopContainer()) {
864 allowedTags.push_back(tagProperty.second);
865 }
866 }
867 }
868 return allowedTags;
869}
870
871// ===========================================================================
872// private
873// ===========================================================================
874
875void
877 for (const auto& attrProperty : myTagProperty) {
878 if (attrProperty.hasDefaultValue()) {
879 setAttribute(attrProperty.getAttr(), attrProperty.getDefaultValue());
880 }
881 }
882}
883
884
885void
886GNEAttributeCarrier::toggleAttribute(SumoXMLAttr /*key*/, const bool /*value*/) {
887 throw ProcessError("Nothing to toggle, implement in Children");
888}
889
890
891void
893 // fill all groups of ACs
899 // demand
904 // persons
910 // containers
915 //data
917 // check integrity of all Tags (function checkTagIntegrity() throws an exception if there is an inconsistency)
918 for (const auto& tagProperty : myTagProperties) {
919 tagProperty.second.checkTagIntegrity();
920 }
921}
922
923
924void
926 // declare empty GNEAttributeProperties
927 GNEAttributeProperties attrProperty;
928 // obtain Node Types except SumoXMLNodeType::DEAD_END_DEPRECATED
930 std::vector<std::string> nodeTypes = SUMOXMLDefinitions::NodeTypes.getStrings();
931 nodeTypes.erase(std::find(nodeTypes.begin(), nodeTypes.end(), toString(SumoXMLNodeType::DEAD_END_DEPRECATED)));
932 nodeTypes.erase(std::find(nodeTypes.begin(), nodeTypes.end(), toString(SumoXMLNodeType::DEAD_END)));
933 nodeTypes.erase(std::find(nodeTypes.begin(), nodeTypes.end(), toString(SumoXMLNodeType::INTERNAL)));
934 // obtain TLTypes (note: avoid insert all TLTypes because some of them are experimental and not documented)
935 std::vector<std::string> TLTypes;
936 TLTypes.push_back(toString(TrafficLightType::STATIC));
937 TLTypes.push_back(toString(TrafficLightType::ACTUATED));
938 TLTypes.push_back(toString(TrafficLightType::DELAYBASED));
939 TLTypes.push_back(toString(TrafficLightType::NEMA));
940 // fill networkElement ACs
941 SumoXMLTag currentTag = SUMO_TAG_JUNCTION;
942 {
943 // set values of tag
944 myTagProperties[currentTag] = GNETagProperties(currentTag,
947 GUIIcon::JUNCTION, currentTag);
948 // set values of attributes
951 "The id of the node");
952 myTagProperties[currentTag].addAttribute(attrProperty);
953
955 GNEAttributeProperties::STRING | GNEAttributeProperties::UNIQUE | GNEAttributeProperties::POSITION | GNEAttributeProperties::UPDATEGEOMETRY, // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
956 "The x-y-z position of the node on the plane in meters");
957 myTagProperties[currentTag].addAttribute(attrProperty);
958
961 "An optional type for the node");
962 attrProperty.setDiscreteValues(nodeTypes);
963 myTagProperties[currentTag].addAttribute(attrProperty);
964
967 "A custom shape for that node");
968 myTagProperties[currentTag].addAttribute(attrProperty);
969
972 "Optional turning radius (for all corners) for that node in meters",
973 "1.5");
974 myTagProperties[currentTag].addAttribute(attrProperty);
975
978 "Whether the junction-blocking-heuristic should be activated at this node",
979 "1");
980 myTagProperties[currentTag].addAttribute(attrProperty);
981
984 "How to compute right of way rules at this node",
987 myTagProperties[currentTag].addAttribute(attrProperty);
988
991 "Whether this junction is at the fringe of the network",
994 myTagProperties[currentTag].addAttribute(attrProperty);
995
998 "Optional name of " + toString(currentTag));
999 myTagProperties[currentTag].addAttribute(attrProperty);
1000
1003 "An optional type for the traffic light algorithm");
1004 attrProperty.setDiscreteValues(TLTypes);
1005 myTagProperties[currentTag].addAttribute(attrProperty);
1006
1009 "An optional layout for the traffic light plan");
1014 myTagProperties[currentTag].addAttribute(attrProperty);
1015
1018 "An optional id for the traffic light program");
1019 myTagProperties[currentTag].addAttribute(attrProperty);
1020 }
1021 currentTag = SUMO_TAG_TYPE;
1022 {
1023 // set values of tag
1024 myTagProperties[currentTag] = GNETagProperties(currentTag,
1027 GUIIcon::EDGETYPE, currentTag);
1028 // set values of attributes
1029 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1031 "The id of the edge");
1032 myTagProperties[currentTag].addAttribute(attrProperty);
1033
1036 "The number of lanes of the edge",
1037 toString(oc.getInt("default.lanenumber")));
1038 myTagProperties[currentTag].addAttribute(attrProperty);
1039
1042 "The maximum speed allowed on the edge in m/s",
1043 toString(oc.getFloat("default.speed")));
1044 myTagProperties[currentTag].addAttribute(attrProperty);
1045
1048 "Explicitly allows the given vehicle classes (not given will be not allowed)",
1049 "all");
1050 myTagProperties[currentTag].addAttribute(attrProperty);
1051
1054 "Explicitly disallows the given vehicle classes (not given will be allowed)");
1055 myTagProperties[currentTag].addAttribute(attrProperty);
1056
1059 "The spreadType defines how to compute the lane geometry from the edge geometry (used for visualization)",
1062 myTagProperties[currentTag].addAttribute(attrProperty);
1063
1066 "The priority of the edge",
1067 toString(oc.getInt("default.priority")));
1068 myTagProperties[currentTag].addAttribute(attrProperty);
1069
1072 "Lane width for all lanes of this edge in meters (used for visualization)",
1073 "-1");
1074 myTagProperties[currentTag].addAttribute(attrProperty);
1075 /*
1076 implement in #9725
1077
1078 attrProperty = GNEAttributeProperties(SUMO_ATTR_SIDEWALKWIDTH,
1079 GNEAttributeProperties::FLOAT,
1080 "The width of the sidewalk that should be added as an additional lane");
1081 myTagProperties[currentTag].addAttribute(attrProperty);
1082
1083 attrProperty = GNEAttributeProperties(SUMO_ATTR_BIKELANEWIDTH,
1084 GNEAttributeProperties::FLOAT,
1085 "The width of the bike lane that should be added as an additional lane");
1086 myTagProperties[currentTag].addAttribute(attrProperty);
1087 */
1088 }
1089 currentTag = SUMO_TAG_LANETYPE;
1090 {
1091 // set values of tag
1092 myTagProperties[currentTag] = GNETagProperties(currentTag,
1095 GUIIcon::LANETYPE, currentTag);
1096 // set values of attributes
1099 "The maximum speed allowed on the lane in m/s",
1100 toString(oc.getFloat("default.speed")));
1101 myTagProperties[currentTag].addAttribute(attrProperty);
1102
1105 "Explicitly allows the given vehicle classes (not given will be not allowed)",
1106 "all");
1107 myTagProperties[currentTag].addAttribute(attrProperty);
1108
1111 "Explicitly disallows the given vehicle classes (not given will be allowed)");
1112 myTagProperties[currentTag].addAttribute(attrProperty);
1113
1116 "Lane width for all lanes of this lane in meters (used for visualization)",
1117 "-1");
1118 myTagProperties[currentTag].addAttribute(attrProperty);
1119 }
1120 currentTag = SUMO_TAG_EDGE;
1121 {
1122 // set values of tag
1123 myTagProperties[currentTag] = GNETagProperties(currentTag,
1126 GUIIcon::EDGE, currentTag);
1127 // set values of attributes
1128 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1130 "Edge ID");
1131 myTagProperties[currentTag].addAttribute(attrProperty);
1132
1135 "The name of a node within the nodes-file the edge shall start at");
1136 myTagProperties[currentTag].addAttribute(attrProperty);
1137
1138 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
1140 "The name of a node within the nodes-file the edge shall end at");
1141 myTagProperties[currentTag].addAttribute(attrProperty);
1142
1145 "The maximum speed allowed on the edge in m/s",
1146 toString(oc.getFloat("default.speed")));
1147 myTagProperties[currentTag].addAttribute(attrProperty);
1148
1151 "The priority of the edge",
1152 toString(oc.getInt("default.priority")));
1153 myTagProperties[currentTag].addAttribute(attrProperty);
1154
1157 "The number of lanes of the edge",
1158 toString(oc.getInt("default.lanenumber")));
1159 myTagProperties[currentTag].addAttribute(attrProperty);
1160
1163 "The name of a type within the SUMO edge type file");
1164 myTagProperties[currentTag].addAttribute(attrProperty);
1165
1168 "Explicitly allows the given vehicle classes (not given will be not allowed)",
1169 "all");
1170 myTagProperties[currentTag].addAttribute(attrProperty);
1171
1174 "Explicitly disallows the given vehicle classes (not given will be allowed)");
1175 myTagProperties[currentTag].addAttribute(attrProperty);
1176
1179 "If the shape is given it should start and end with the positions of the from-node and to-node");
1180 myTagProperties[currentTag].addAttribute(attrProperty);
1181
1184 "The length of the edge in meter");
1185 myTagProperties[currentTag].addAttribute(attrProperty);
1186
1189 "The spreadType defines how to compute the lane geometry from the edge geometry (used for visualization)",
1192 myTagProperties[currentTag].addAttribute(attrProperty);
1193
1196 "street name (need not be unique, used for visualization)");
1197 myTagProperties[currentTag].addAttribute(attrProperty);
1198
1201 "Lane width for all lanes of this edge in meters (used for visualization)",
1202 "-1");
1203 myTagProperties[currentTag].addAttribute(attrProperty);
1204
1207 "Move the stop line back from the intersection by the given amount",
1208 "0.00");
1209 myTagProperties[currentTag].addAttribute(attrProperty);
1210
1213 "Custom position in which shape start (by default position of junction from)");
1214 myTagProperties[currentTag].addAttribute(attrProperty);
1215
1218 "Custom position in which shape end (by default position of junction from)");
1219 myTagProperties[currentTag].addAttribute(attrProperty);
1220
1222 GNEAttributeProperties::BOOL | GNEAttributeProperties::DEFAULTVALUE, // virtual attribute to check of this edge is part of a bidirectional railway (cannot be edited)
1223 "Show if edge is bidireccional",
1224 "0");
1225 myTagProperties[currentTag].addAttribute(attrProperty);
1226
1229 "0.00");
1230 myTagProperties[currentTag].addAttribute(attrProperty);
1231
1234 "The stop offset as positive value in meters",
1235 "0.00");
1236 myTagProperties[currentTag].addAttribute(attrProperty);
1237
1240 "Specifies, for which vehicle classes the stopOffset does NOT apply.",
1241 "");
1242 attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
1243 myTagProperties[currentTag].addAttribute(attrProperty);
1244 }
1245 currentTag = SUMO_TAG_LANE;
1246 {
1247 // set values of tag
1248 myTagProperties[currentTag] = GNETagProperties(currentTag,
1250 0,
1251 GUIIcon::LANE, currentTag);
1252 // set values of attributes
1253 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1255 "Lane ID (Automatic, non editable)");
1256 myTagProperties[currentTag].addAttribute(attrProperty);
1257
1260 "The enumeration index of the lane (0 is the rightmost lane, <NUMBER_LANES>-1 is the leftmost one)");
1261 myTagProperties[currentTag].addAttribute(attrProperty);
1262
1265 "Speed in meters per second",
1266 "13.89");
1267 myTagProperties[currentTag].addAttribute(attrProperty);
1268
1271 "Explicitly allows the given vehicle classes (not given will be not allowed)",
1272 "all");
1273 myTagProperties[currentTag].addAttribute(attrProperty);
1274
1277 "Explicitly disallows the given vehicle classes (not given will be allowed)");
1278 myTagProperties[currentTag].addAttribute(attrProperty);
1279
1282 "Width in meters (used for visualization)",
1283 "-1");
1284 myTagProperties[currentTag].addAttribute(attrProperty);
1285
1288 "Move the stop line back from the intersection by the given amount",
1289 "0.00");
1290 myTagProperties[currentTag].addAttribute(attrProperty);
1291
1294 "Enable or disable lane as acceleration lane",
1295 "0.00");
1296 myTagProperties[currentTag].addAttribute(attrProperty);
1297
1300 "If the shape is given it overrides the computation based on edge shape");
1301 myTagProperties[currentTag].addAttribute(attrProperty);
1302
1305 "If given, this defines the opposite direction lane");
1306 myTagProperties[currentTag].addAttribute(attrProperty);
1307
1310 "Permit changing left only for to the given vehicle classes",
1311 "all");
1312 attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
1313 myTagProperties[currentTag].addAttribute(attrProperty);
1314
1317 "Permit changing right only for to the given vehicle classes",
1318 "all");
1319 attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
1320 myTagProperties[currentTag].addAttribute(attrProperty);
1321
1324 "Lane type description (optional)");
1325 myTagProperties[currentTag].addAttribute(attrProperty);
1326
1329 "The stop offset as positive value in meters",
1330 "0.00");
1331 myTagProperties[currentTag].addAttribute(attrProperty);
1332
1335 "Specifies, for which vehicle classes the stopOffset does NOT apply.",
1336 "");
1337 attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
1338 myTagProperties[currentTag].addAttribute(attrProperty);
1339 }
1340 currentTag = SUMO_TAG_CROSSING;
1341 {
1342 // set values of tag
1343 myTagProperties[currentTag] = GNETagProperties(currentTag,
1345 0,
1346 GUIIcon::CROSSING, currentTag);
1347 // set values of attributes
1348 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1350 "Crossing ID");
1351 myTagProperties[currentTag].addAttribute(attrProperty);
1352
1355 "The (road) edges which are crossed");
1356 myTagProperties[currentTag].addAttribute(attrProperty);
1357
1360 "Whether the pedestrians have priority over the vehicles (automatically set to true at tls-controlled intersections)",
1361 "0");
1362 myTagProperties[currentTag].addAttribute(attrProperty);
1363
1366 "The width of the crossings",
1367 toString(OptionsCont::getOptions().getFloat("default.crossing-width")));
1368 myTagProperties[currentTag].addAttribute(attrProperty);
1369
1372 "sets the tls-index for this crossing",
1373 "-1");
1374 myTagProperties[currentTag].addAttribute(attrProperty);
1375
1378 "sets the opposite-direction tls-index for this crossing",
1379 "-1");
1380 myTagProperties[currentTag].addAttribute(attrProperty);
1381
1384 "Overrids default shape of pedestrian crossing");
1385 myTagProperties[currentTag].addAttribute(attrProperty);
1386 }
1387 currentTag = SUMO_TAG_WALKINGAREA;
1388 {
1389 // set values of tag
1390 myTagProperties[currentTag] = GNETagProperties(currentTag,
1393 GUIIcon::WALKINGAREA, currentTag);
1394 // set values of attributes
1395 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1397 "Walking Area ID");
1398 myTagProperties[currentTag].addAttribute(attrProperty);
1399
1402 "The width of the WalkingArea",
1403 toString(OptionsCont::getOptions().getFloat("default.sidewalk-width")));
1404 myTagProperties[currentTag].addAttribute(attrProperty);
1405
1408 "The length of the WalkingArea in meter");
1409 myTagProperties[currentTag].addAttribute(attrProperty);
1410
1413 "Overrids default shape of pedestrian sidelwak");
1414 myTagProperties[currentTag].addAttribute(attrProperty);
1415 }
1416 currentTag = SUMO_TAG_CONNECTION;
1417 {
1418 // set values of tag
1419 myTagProperties[currentTag] = GNETagProperties(currentTag,
1421 0,
1422 GUIIcon::CONNECTION, currentTag);
1423 // set values of attributes
1426 "The name of the edge the vehicles leave");
1427 myTagProperties[currentTag].addAttribute(attrProperty);
1428
1429 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
1431 "The name of the edge the vehicles may reach when leaving 'from'");
1432 myTagProperties[currentTag].addAttribute(attrProperty);
1433
1436 "the lane index of the incoming lane (numbers starting with 0)");
1437 myTagProperties[currentTag].addAttribute(attrProperty);
1438
1441 "the lane index of the outgoing lane (numbers starting with 0)");
1442 myTagProperties[currentTag].addAttribute(attrProperty);
1443
1446 "if set, vehicles which pass this (lane-2-lane) connection) will not wait",
1447 "0");
1448 myTagProperties[currentTag].addAttribute(attrProperty);
1449
1452 "if set to false, vehicles which pass this (lane-2-lane) connection) will not worry about blocking the intersection",
1453 "0");
1454 myTagProperties[currentTag].addAttribute(attrProperty);
1455
1458 "If set to a more than 0 value, an internal junction will be built at this position (in m)/n"
1459 "from the start of the internal lane for this connection",
1461 myTagProperties[currentTag].addAttribute(attrProperty);
1462
1465 "If set to true, This connection will not be TLS-controlled despite its node being controlled",
1466 "0");
1467 myTagProperties[currentTag].addAttribute(attrProperty);
1468
1471 "Vision distance between vehicles",
1473 myTagProperties[currentTag].addAttribute(attrProperty);
1474
1477 "sets index of this connection within the controlling trafficlight",
1478 "-1");
1479 myTagProperties[currentTag].addAttribute(attrProperty);
1480
1483 "sets index for the internal junction of this connection within the controlling trafficlight",
1484 "-1");
1485 myTagProperties[currentTag].addAttribute(attrProperty);
1486
1489 "Explicitly allows the given vehicle classes (not given will be not allowed)",
1490 "all");
1491 myTagProperties[currentTag].addAttribute(attrProperty);
1492
1495 "Explicitly disallows the given vehicle classes (not given will be allowed)");
1496 myTagProperties[currentTag].addAttribute(attrProperty);
1497
1500 "sets custom speed limit for the connection",
1502 myTagProperties[currentTag].addAttribute(attrProperty);
1503
1506 "sets custom length for the connection",
1508 myTagProperties[currentTag].addAttribute(attrProperty);
1509
1512 "sets custom shape for the connection");
1513 myTagProperties[currentTag].addAttribute(attrProperty);
1514
1517 "Permit changing left only for to the given vehicle classes",
1518 "all");
1519 attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
1520 myTagProperties[currentTag].addAttribute(attrProperty);
1521
1524 "Permit changing right only for to the given vehicle classes",
1525 "all");
1526 attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
1527 myTagProperties[currentTag].addAttribute(attrProperty);
1528
1531 "if set to true, vehicles will make a turn in 2 steps",
1532 "0");
1533 myTagProperties[currentTag].addAttribute(attrProperty);
1534
1537 "set a custom edge type (for applying vClass-specific speed restrictions)");
1538 myTagProperties[currentTag].addAttribute(attrProperty);
1539
1540
1543 "turning direction for this connection (computed)");
1544 myTagProperties[currentTag].addAttribute(attrProperty);
1545
1548 "link state for this connection (computed)");
1549 myTagProperties[currentTag].addAttribute(attrProperty);
1550 }
1551 currentTag = GNE_TAG_INTERNAL_LANE;
1552 {
1553 // set values of tag
1554 myTagProperties[currentTag] = GNETagProperties(currentTag,
1556 0,
1557 GUIIcon::JUNCTION, currentTag);
1558 // internal lanes does't have attributes
1559 }
1560}
1561
1562
1563void
1565 // declare empty GNEAttributeProperties
1566 GNEAttributeProperties attrProperty;
1567 // fill additional elements
1568 SumoXMLTag currentTag = SUMO_TAG_BUS_STOP;
1569 {
1570 // set values of tag
1571 myTagProperties[currentTag] = GNETagProperties(currentTag,
1574 GUIIcon::BUSSTOP, currentTag, {}, FXRGBA(240, 255, 205, 255));
1575 // set values of attributes
1576 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1578 "The id of bus stop");
1579 myTagProperties[currentTag].addAttribute(attrProperty);
1580
1583 "The name of the lane the bus stop shall be located at");
1584 myTagProperties[currentTag].addAttribute(attrProperty);
1585
1588 "The begin position on the lane (the lower position on the lane) in meters");
1589
1590 myTagProperties[currentTag].addAttribute(attrProperty);
1593 "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
1594 myTagProperties[currentTag].addAttribute(attrProperty);
1595
1598 "Name of " + toString(currentTag));
1599 myTagProperties[currentTag].addAttribute(attrProperty);
1600
1603 "If set, no error will be reported if element is placed behind the lane.\n"
1604 "Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,\n"
1605 "if the position was negative and larger than the lanes length after multiplication with - 1",
1606 "0");
1607 myTagProperties[currentTag].addAttribute(attrProperty);
1608
1611 "Meant to be the names of the bus lines that stop at this bus stop. This is only used for visualization purposes");
1612 myTagProperties[currentTag].addAttribute(attrProperty);
1613
1616 "Larger numbers of persons trying to enter will create an upstream jam on the sidewalk",
1617 "6");
1618 myTagProperties[currentTag].addAttribute(attrProperty);
1619
1622 "Optional space definition for vehicles that park at this stop",
1623 "0.00");
1624 myTagProperties[currentTag].addAttribute(attrProperty);
1625
1628 "The RGBA color with which the busStop shall be displayed");
1629 myTagProperties[currentTag].addAttribute(attrProperty);
1630
1631 }
1632 currentTag = SUMO_TAG_TRAIN_STOP;
1633 {
1634 // set values of tag
1635 myTagProperties[currentTag] = GNETagProperties(currentTag,
1638 GUIIcon::TRAINSTOP, currentTag, {}, FXRGBA(240, 255, 205, 255));
1639 // set values of attributes
1640 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1642 "The id of train stop");
1643 myTagProperties[currentTag].addAttribute(attrProperty);
1644
1647 "The name of the lane the train stop shall be located at");
1648 myTagProperties[currentTag].addAttribute(attrProperty);
1649
1652 "The begin position on the lane (the lower position on the lane) in meters");
1653
1654 myTagProperties[currentTag].addAttribute(attrProperty);
1657 "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
1658 myTagProperties[currentTag].addAttribute(attrProperty);
1659
1662 "Name of " + toString(currentTag));
1663 myTagProperties[currentTag].addAttribute(attrProperty);
1664
1667 "If set, no error will be reported if element is placed behind the lane.\n"
1668 "Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,\n"
1669 "if the position was negative and larger than the lanes length after multiplication with - 1",
1670 "0");
1671 myTagProperties[currentTag].addAttribute(attrProperty);
1672
1675 "Meant to be the names of the train lines that stop at this train stop. This is only used for visualization purposes");
1676 myTagProperties[currentTag].addAttribute(attrProperty);
1677
1680 "Larger numbers of persons trying to enter will create an upstream jam on the sidewalk",
1681 "6");
1682 myTagProperties[currentTag].addAttribute(attrProperty);
1683
1686 "Optional space definition for vehicles that park at this stop",
1687 "0.00");
1688 myTagProperties[currentTag].addAttribute(attrProperty);
1689
1692 "The RGBA color with which the trainStop shall be displayed");
1693 myTagProperties[currentTag].addAttribute(attrProperty);
1694
1695 }
1696 currentTag = SUMO_TAG_ACCESS;
1697 {
1698 // set values of tag
1699 myTagProperties[currentTag] = GNETagProperties(currentTag,
1702 GUIIcon::ACCESS, currentTag, {SUMO_TAG_BUS_STOP, SUMO_TAG_TRAIN_STOP}, FXRGBA(240, 255, 205, 255));
1703 // set values of attributes
1706 "The name of the lane the stop access shall be located at");
1707 myTagProperties[currentTag].addAttribute(attrProperty);
1708
1711 "The position on the lane (the lower position on the lane) in meters",
1712 "0.00");
1713 myTagProperties[currentTag].addAttribute(attrProperty);
1714
1717 "The walking length of the access in meters",
1718 "-1.00");
1719 myTagProperties[currentTag].addAttribute(attrProperty);
1720
1723 "If set, no error will be reported if element is placed behind the lane.\n"
1724 "Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,\n"
1725 "if the position was negative and larger than the lanes length after multiplication with - 1",
1726 "0");
1727 myTagProperties[currentTag].addAttribute(attrProperty);
1728
1729 }
1730 currentTag = SUMO_TAG_CONTAINER_STOP;
1731 {
1732 // set values of tag
1733 myTagProperties[currentTag] = GNETagProperties(currentTag,
1736 GUIIcon::CONTAINERSTOP, currentTag, {}, FXRGBA(240, 255, 205, 255));
1737 // set values of attributes
1738 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1740 "The id of container stop");
1741 myTagProperties[currentTag].addAttribute(attrProperty);
1742
1745 "The name of the lane the container stop shall be located at");
1746 myTagProperties[currentTag].addAttribute(attrProperty);
1747
1750 "The begin position on the lane (the lower position on the lane) in meters");
1751 myTagProperties[currentTag].addAttribute(attrProperty);
1752
1755 "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
1756 myTagProperties[currentTag].addAttribute(attrProperty);
1757
1760 "Name of " + toString(currentTag));
1761 myTagProperties[currentTag].addAttribute(attrProperty);
1762
1765 "If set, no error will be reported if element is placed behind the lane.\n"
1766 "Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,\n"
1767 "if the position was negative and larger than the lanes length after multiplication with - 1",
1768 "0");
1769 myTagProperties[currentTag].addAttribute(attrProperty);
1770
1773 "meant to be the names of the bus lines that stop at this container stop. This is only used for visualization purposes");
1774 myTagProperties[currentTag].addAttribute(attrProperty);
1775
1778 "Larger numbers of container trying to enter will create an upstream jam on the sidewalk",
1779 "6");
1780 myTagProperties[currentTag].addAttribute(attrProperty);
1781
1784 "Optional space definition for vehicles that park at this stop",
1785 "0.00");
1786 myTagProperties[currentTag].addAttribute(attrProperty);
1787
1790 "The RGBA color with which the containerStop shall be displayed");
1791 myTagProperties[currentTag].addAttribute(attrProperty);
1792 }
1793 currentTag = SUMO_TAG_CHARGING_STATION;
1794 {
1795 // set values of tag
1796 myTagProperties[currentTag] = GNETagProperties(currentTag,
1799 GUIIcon::CHARGINGSTATION, currentTag, {}, FXRGBA(240, 255, 205, 255));
1800 // set values of attributes
1801 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1803 "The id of charging station");
1804 myTagProperties[currentTag].addAttribute(attrProperty);
1805
1808 "Lane of the charging station location");
1809 myTagProperties[currentTag].addAttribute(attrProperty);
1810
1813 "Begin position in the specified lane");
1814 myTagProperties[currentTag].addAttribute(attrProperty);
1815
1818 "End position in the specified lane");
1819 myTagProperties[currentTag].addAttribute(attrProperty);
1820
1823 "Name of " + toString(currentTag));
1824 myTagProperties[currentTag].addAttribute(attrProperty);
1825
1828 "If set, no error will be reported if element is placed behind the lane.\n"
1829 "Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,\n"
1830 "if the position was negative and larger than the lanes length after multiplication with - 1",
1831 "0");
1832 myTagProperties[currentTag].addAttribute(attrProperty);
1833
1836 "Charging power in W",
1837 "22000.00");
1838 myTagProperties[currentTag].addAttribute(attrProperty);
1839
1842 "Charging efficiency [0,1]",
1843 "0.95");
1844 attrProperty.setRange(0, 1);
1845 myTagProperties[currentTag].addAttribute(attrProperty);
1846
1849 "Enable or disable charge in transit, i.e. vehicle must or must not to stop for charging",
1850 "0");
1851 myTagProperties[currentTag].addAttribute(attrProperty);
1852
1855 "Time delay after the vehicles has reached / stopped on the charging station, before the energy transfer (charging) begins",
1856 "0.00");
1857 myTagProperties[currentTag].addAttribute(attrProperty);
1858 }
1859 currentTag = SUMO_TAG_PARKING_AREA;
1860 {
1861 // set values of tag
1862 myTagProperties[currentTag] = GNETagProperties(currentTag,
1865 GUIIcon::PARKINGAREA, currentTag, {}, FXRGBA(240, 255, 205, 255));
1866 // set values of attributes
1867 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1869 "The id of ParkingArea");
1870 myTagProperties[currentTag].addAttribute(attrProperty);
1871
1874 "The name of the lane the Parking Area shall be located at");
1875 myTagProperties[currentTag].addAttribute(attrProperty);
1876
1879 "The begin position on the lane (the lower position on the lane) in meters");
1880 myTagProperties[currentTag].addAttribute(attrProperty);
1881
1884 "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
1885 myTagProperties[currentTag].addAttribute(attrProperty);
1886
1889 "Lane position in that vehicle must depart when leaves parkingArea");
1890 myTagProperties[currentTag].addAttribute(attrProperty);
1891
1894 "Name of " + toString(currentTag));
1895 myTagProperties[currentTag].addAttribute(attrProperty);
1896
1899 " The number of parking spaces for road-side parking",
1900 "0");
1901 myTagProperties[currentTag].addAttribute(attrProperty);
1902
1905 "If set, vehicles will park on the road lane and thereby reducing capacity",
1906 "0");
1907 myTagProperties[currentTag].addAttribute(attrProperty);
1908
1911 "If set, no error will be reported if element is placed behind the lane.\n"
1912 "Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,\n"
1913 "if the position was negative and larger than the lanes length after multiplication with - 1",
1914 "0");
1915 myTagProperties[currentTag].addAttribute(attrProperty);
1916
1919 "The width of the road-side parking spaces",
1921 myTagProperties[currentTag].addAttribute(attrProperty);
1922
1925 "The length of the road-side parking spaces. By default (endPos - startPos) / roadsideCapacity",
1926 "0.00");
1927 myTagProperties[currentTag].addAttribute(attrProperty);
1928
1931 "The angle of the road-side parking spaces relative to the lane angle, positive means clockwise",
1932 "0.00");
1933 myTagProperties[currentTag].addAttribute(attrProperty);
1934
1935 }
1936 currentTag = SUMO_TAG_PARKING_SPACE;
1937 {
1938 // set values of tag
1939 myTagProperties[currentTag] = GNETagProperties(currentTag,
1942 GUIIcon::PARKINGSPACE, currentTag, {SUMO_TAG_PARKING_AREA}, FXRGBA(240, 255, 205, 255));
1943 // set values of attributes
1945 GNEAttributeProperties::STRING | GNEAttributeProperties::UNIQUE | GNEAttributeProperties::POSITION | GNEAttributeProperties::UPDATEGEOMETRY, // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
1946 "The x-y-z position of the node on the plane in meters");
1947 myTagProperties[currentTag].addAttribute(attrProperty);
1948
1951 "Name of " + toString(currentTag));
1952 myTagProperties[currentTag].addAttribute(attrProperty);
1953
1956 "The width of the road-side parking spaces");
1957 myTagProperties[currentTag].addAttribute(attrProperty);
1958
1961 "The length of the road-side parking spaces");
1962 myTagProperties[currentTag].addAttribute(attrProperty);
1963
1966 "The angle of the road-side parking spaces relative to the lane angle, positive means clockwise");
1967 myTagProperties[currentTag].addAttribute(attrProperty);
1968
1971 "The slope of the road-side parking spaces",
1972 "0.00");
1973 myTagProperties[currentTag].addAttribute(attrProperty);
1974
1975 }
1976 currentTag = SUMO_TAG_INDUCTION_LOOP;
1977 {
1978 // set values of tag
1979 myTagProperties[currentTag] = GNETagProperties(currentTag,
1981 0,
1982 GUIIcon::E1, currentTag, {}, FXRGBA(210, 233, 255, 255));
1983 // set values of attributes
1984 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1986 "The id of E1");
1987 myTagProperties[currentTag].addAttribute(attrProperty);
1988
1991 "The id of the lane the detector shall be laid on. The lane must be a part of the network used");
1992 myTagProperties[currentTag].addAttribute(attrProperty);
1993
1996 "The position on the lane the detector shall be laid on in meters. The position must be a value between -1*lane's length and the lane's length");
1997 myTagProperties[currentTag].addAttribute(attrProperty);
1998
2001 "The aggregation period the values the detector collects shall be summed up",
2002 "300.00");
2003 myTagProperties[currentTag].addAttribute(attrProperty);
2004
2007 "Name of " + toString(currentTag));
2008 myTagProperties[currentTag].addAttribute(attrProperty);
2009
2012 "The path to the output file");
2013 myTagProperties[currentTag].addAttribute(attrProperty);
2014
2017 "Space separated list of vehicle type ids to consider");
2018 myTagProperties[currentTag].addAttribute(attrProperty);
2019
2022 "If set, no error will be reported if element is placed behind the lane.\n"
2023 "Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,\n"
2024 "if the position was negative and larger than the lanes length after multiplication with - 1",
2025 "0");
2026 myTagProperties[currentTag].addAttribute(attrProperty);
2027 }
2028 currentTag = SUMO_TAG_LANE_AREA_DETECTOR;
2029 {
2030 // set values of tag
2031 myTagProperties[currentTag] = GNETagProperties(currentTag,
2033 0,
2034 GUIIcon::E2, currentTag, {}, FXRGBA(210, 233, 255, 255));
2035 // set values of attributes
2036 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2038 "The id of E2");
2039 myTagProperties[currentTag].addAttribute(attrProperty);
2040
2043 "The id of the lane the detector shall be laid on. The lane must be a part of the network used");
2044 myTagProperties[currentTag].addAttribute(attrProperty);
2045
2048 "The position on the lane the detector shall be laid on in meters");
2049 myTagProperties[currentTag].addAttribute(attrProperty);
2050
2053 "The length of the detector in meters",
2054 "10.00");
2055 myTagProperties[currentTag].addAttribute(attrProperty);
2056
2059 "The aggregation period the values the detector collects shall be summed up",
2060 "300.00");
2061 myTagProperties[currentTag].addAttribute(attrProperty);
2062
2065 "The traffic light that triggers aggregation when switching");
2066 myTagProperties[currentTag].addAttribute(attrProperty);
2067
2070 "Name of " + toString(currentTag));
2071 myTagProperties[currentTag].addAttribute(attrProperty);
2072
2075 "The path to the output file");
2076 myTagProperties[currentTag].addAttribute(attrProperty);
2077
2080 "Space separated list of vehicle type ids to consider");
2081 myTagProperties[currentTag].addAttribute(attrProperty);
2082
2085 "The time-based threshold that describes how much time has to pass until a vehicle is recognized as halting)",
2086 "1.00");
2087 myTagProperties[currentTag].addAttribute(attrProperty);
2088
2091 "The speed-based threshold that describes how slow a vehicle has to be to be recognized as halting) in m/s",
2092 "1.39");
2093 myTagProperties[currentTag].addAttribute(attrProperty);
2094
2097 "The minimum distance to the next standing vehicle in order to make this vehicle count as a participant to the jam) in m",
2098 "10.00");
2099 myTagProperties[currentTag].addAttribute(attrProperty);
2100
2103 "If set, no error will be reported if element is placed behind the lane.\n"
2104 "Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,\n"
2105 "if the position was negative and larger than the lanes length after multiplication with - 1",
2106 "0");
2107 myTagProperties[currentTag].addAttribute(attrProperty);
2108 }
2110 {
2111 // set values of tag
2112 myTagProperties[currentTag] = GNETagProperties(currentTag,
2114 0,
2115 GUIIcon::E2, SUMO_TAG_LANE_AREA_DETECTOR, {}, FXRGBA(210, 233, 255, 255));
2116 // set values of attributes
2117 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2119 "The id of Multilane E2");
2120 myTagProperties[currentTag].addAttribute(attrProperty);
2121
2124 "The list of secuencial lane ids in which the detector shall be laid on");
2125 myTagProperties[currentTag].addAttribute(attrProperty);
2126
2129 "The position on the lane the detector shall be laid on in meters");
2130 myTagProperties[currentTag].addAttribute(attrProperty);
2131
2134 "The end position on the lane the detector shall be laid on in meters");
2135 myTagProperties[currentTag].addAttribute(attrProperty);
2136
2139 "The aggregation period the values the detector collects shall be summed up",
2140 "300.00");
2141 myTagProperties[currentTag].addAttribute(attrProperty);
2142
2145 "The traffic light that triggers aggregation when switching");
2146 myTagProperties[currentTag].addAttribute(attrProperty);
2147
2150 "Name of " + toString(currentTag));
2151 myTagProperties[currentTag].addAttribute(attrProperty);
2152
2155 "The path to the output file");
2156 myTagProperties[currentTag].addAttribute(attrProperty);
2157
2160 "Space separated list of vehicle type ids to consider");
2161 myTagProperties[currentTag].addAttribute(attrProperty);
2162
2165 "The time-based threshold that describes how much time has to pass until a vehicle is recognized as halting)",
2166 "1.00");
2167 myTagProperties[currentTag].addAttribute(attrProperty);
2168
2171 "The speed-based threshold that describes how slow a vehicle has to be to be recognized as halting) in m/s",
2172 "1.39");
2173 myTagProperties[currentTag].addAttribute(attrProperty);
2174
2177 "The minimum distance to the next standing vehicle in order to make this vehicle count as a participant to the jam) in m",
2178 "10.00");
2179 myTagProperties[currentTag].addAttribute(attrProperty);
2180
2183 "If set, no error will be reported if element is placed behind the lane.\n"
2184 "Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,\n"
2185 "if the position was negative and larger than the lanes length after multiplication with - 1",
2186 "0");
2187 myTagProperties[currentTag].addAttribute(attrProperty);
2188
2189 }
2190 currentTag = SUMO_TAG_ENTRY_EXIT_DETECTOR;
2191 {
2192 // set values of tag
2193 myTagProperties[currentTag] = GNETagProperties(currentTag,
2196 GUIIcon::E3, currentTag, {}, FXRGBA(210, 233, 255, 255));
2197 // set values of attributes
2198 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2200 "The id of E3");
2201 myTagProperties[currentTag].addAttribute(attrProperty);
2202
2205 "X-Y position of detector in editor (Only used in NETEDIT)",
2206 "0,0"); // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
2207 myTagProperties[currentTag].addAttribute(attrProperty);
2208
2211 "The aggregation period the values the detector collects shall be summed up",
2212 "300.00");
2213 myTagProperties[currentTag].addAttribute(attrProperty);
2214
2217 "Name of " + toString(currentTag));
2218 myTagProperties[currentTag].addAttribute(attrProperty);
2219
2222 "The path to the output file");
2223 myTagProperties[currentTag].addAttribute(attrProperty);
2224
2227 "Space separated list of vehicle type ids to consider");
2228 myTagProperties[currentTag].addAttribute(attrProperty);
2229
2232 "The time-based threshold that describes how much time has to pass until a vehicle is recognized as halting) in s",
2233 "1.00");
2234 myTagProperties[currentTag].addAttribute(attrProperty);
2235
2238 "The speed-based threshold that describes how slow a vehicle has to be to be recognized as halting) in m/s",
2239 "1.39");
2240 myTagProperties[currentTag].addAttribute(attrProperty);
2241 }
2242 currentTag = SUMO_TAG_DET_ENTRY;
2243 {
2244 // set values of tag
2245 myTagProperties[currentTag] = GNETagProperties(currentTag,
2248 GUIIcon::E3ENTRY, currentTag, {SUMO_TAG_ENTRY_EXIT_DETECTOR}, FXRGBA(210, 233, 255, 255));
2249 // set values of attributes
2252 "The id of the lane the detector shall be laid on. The lane must be a part of the network used");
2253 myTagProperties[currentTag].addAttribute(attrProperty);
2254
2257 "The position on the lane the detector shall be laid on in meters");
2258 myTagProperties[currentTag].addAttribute(attrProperty);
2259
2262 "If set, no error will be reported if element is placed behind the lane.\n"
2263 "Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,\n"
2264 "if the position was negative and larger than the lanes length after multiplication with - 1",
2265 "0");
2266 myTagProperties[currentTag].addAttribute(attrProperty);
2267
2268 }
2269 currentTag = SUMO_TAG_DET_EXIT;
2270 {
2271 // set values of tag
2272 myTagProperties[currentTag] = GNETagProperties(currentTag,
2275 GUIIcon::E3EXIT, currentTag, {SUMO_TAG_ENTRY_EXIT_DETECTOR}, FXRGBA(210, 233, 255, 255));
2276 // set values of attributes
2279 "The id of the lane the detector shall be laid on. The lane must be a part of the network used");
2280 myTagProperties[currentTag].addAttribute(attrProperty);
2281
2284 "The position on the lane the detector shall be laid on in meters");
2285 myTagProperties[currentTag].addAttribute(attrProperty);
2286
2289 "If set, no error will be reported if element is placed behind the lane.\n"
2290 "Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,\n"
2291 "if the position was negative and larger than the lanes length after multiplication with - 1",
2292 "0");
2293 myTagProperties[currentTag].addAttribute(attrProperty);
2294
2295 }
2297 {
2298 // set values of tag
2299 myTagProperties[currentTag] = GNETagProperties(currentTag,
2301 0,
2302 GUIIcon::E1INSTANT, currentTag, {}, FXRGBA(210, 233, 255, 255));
2303 // set values of attributes
2304 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2306 "The id of Instant Induction Loop (E1Instant)");
2307 myTagProperties[currentTag].addAttribute(attrProperty);
2308
2311 "The id of the lane the detector shall be laid on. The lane must be a part of the network used");
2312 myTagProperties[currentTag].addAttribute(attrProperty);
2313
2316 "The position on the lane the detector shall be laid on in meters. The position must be a value between -1*lane's length and the lane's length");
2317 myTagProperties[currentTag].addAttribute(attrProperty);
2318
2321 "Name of " + toString(currentTag));
2322 myTagProperties[currentTag].addAttribute(attrProperty);
2323
2326 "The path to the output file");
2327 myTagProperties[currentTag].addAttribute(attrProperty);
2328
2331 "Space separated list of vehicle type ids to consider");
2332 myTagProperties[currentTag].addAttribute(attrProperty);
2333
2336 "If set, no error will be reported if element is placed behind the lane.\n"
2337 "Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,\n"
2338 "if the position was negative and larger than the lanes length after multiplication with - 1",
2339 "0");
2340 myTagProperties[currentTag].addAttribute(attrProperty);
2341
2342 }
2343 currentTag = SUMO_TAG_VSS;
2344 {
2345 // set values of tag
2346 myTagProperties[currentTag] = GNETagProperties(currentTag,
2349 GUIIcon::VARIABLESPEEDSIGN, currentTag, {}, FXRGBA(210, 233, 255, 255));
2350 // set values of attributes
2351 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2353 "The id of Variable Speed Signal");
2354 myTagProperties[currentTag].addAttribute(attrProperty);
2355
2358 "X-Y position of detector in editor (Only used in NETEDIT)",
2359 "0,0"); // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
2360 myTagProperties[currentTag].addAttribute(attrProperty);
2361
2364 "List of Variable Speed Sign lanes");
2365 myTagProperties[currentTag].addAttribute(attrProperty);
2366
2369 "Name of " + toString(currentTag));
2370 myTagProperties[currentTag].addAttribute(attrProperty);
2371
2374 "Space separated list of vehicle type ids to consider (empty to affect all types)");
2375 myTagProperties[currentTag].addAttribute(attrProperty);
2376 }
2377 currentTag = GNE_TAG_VSS_SYMBOL;
2378 {
2379 // set values of tag
2380 myTagProperties[currentTag] = GNETagProperties(currentTag,
2383 GUIIcon::LANE, currentTag, {SUMO_TAG_VSS}, FXRGBA(210, 233, 255, 255));
2384 }
2385 currentTag = SUMO_TAG_STEP;
2386 {
2387 // set values of tag
2388 myTagProperties[currentTag] = GNETagProperties(currentTag,
2391 GUIIcon::VSSSTEP, currentTag, {SUMO_TAG_VSS}, FXRGBA(210, 233, 255, 255));
2392 // set values of attributes
2395 "Time");
2396 myTagProperties[currentTag].addAttribute(attrProperty);
2397
2400 "Speed",
2401 "13.89");
2402 myTagProperties[currentTag].addAttribute(attrProperty);
2403 }
2404 currentTag = SUMO_TAG_CALIBRATOR;
2405 {
2406 // set values of tag
2407 myTagProperties[currentTag] = GNETagProperties(currentTag,
2410 GUIIcon::CALIBRATOR, currentTag, {}, FXRGBA(253, 255, 206, 255));
2411 // set values of attributes
2412 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2414 "The id of Calibrator");
2415 myTagProperties[currentTag].addAttribute(attrProperty);
2416
2419 "The id of edge in the simulation network");
2420 myTagProperties[currentTag].addAttribute(attrProperty);
2421
2424 "The position of the calibrator on the specified lane",
2425 "0.00");
2426 myTagProperties[currentTag].addAttribute(attrProperty);
2427
2430 "The aggregation interval in which to calibrate the flows. Default is step-length",
2431 "1.00");
2432 myTagProperties[currentTag].addAttribute(attrProperty);
2433
2436 "Name of " + toString(currentTag));
2437 myTagProperties[currentTag].addAttribute(attrProperty);
2438
2441 "The id of the routeProbe element from which to determine the route distribution for generated vehicles");
2442 myTagProperties[currentTag].addAttribute(attrProperty);
2443
2446 "The output file for writing calibrator information or NULL");
2447 myTagProperties[currentTag].addAttribute(attrProperty);
2448
2451 "A threshold value to detect and clear unexpected jamming",
2452 "0.50");
2453 myTagProperties[currentTag].addAttribute(attrProperty);
2454
2457 "space separated list of vehicle type ids to consider (empty to affect all types)");
2458 myTagProperties[currentTag].addAttribute(attrProperty);
2459 }
2460 currentTag = GNE_TAG_CALIBRATOR_LANE;
2461 {
2462 // set values of tag
2463 myTagProperties[currentTag] = GNETagProperties(currentTag,
2466 GUIIcon::CALIBRATOR, SUMO_TAG_CALIBRATOR, {}, FXRGBA(253, 255, 206, 255));
2467 // set values of attributes
2468 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2470 "The id of Calibrator");
2471 myTagProperties[currentTag].addAttribute(attrProperty);
2472
2475 "The id of lane in the simulation network");
2476 myTagProperties[currentTag].addAttribute(attrProperty);
2477
2480 "The position of the calibrator on the specified lane",
2481 "0.00");
2482 myTagProperties[currentTag].addAttribute(attrProperty);
2483
2486 "The aggregation interval in which to calibrate the flows. Default is step-length",
2487 "1.00");
2488 myTagProperties[currentTag].addAttribute(attrProperty);
2489
2492 "Name of " + toString(currentTag));
2493 myTagProperties[currentTag].addAttribute(attrProperty);
2494
2497 "The id of the routeProbe element from which to determine the route distribution for generated vehicles");
2498 myTagProperties[currentTag].addAttribute(attrProperty);
2499
2502 "The output file for writing calibrator information or NULL");
2503 myTagProperties[currentTag].addAttribute(attrProperty);
2504
2507 "A threshold value to detect and clear unexpected jamming",
2508 "0.50");
2509 myTagProperties[currentTag].addAttribute(attrProperty);
2510
2513 "space separated list of vehicle type ids to consider (empty to affect all types)");
2514 myTagProperties[currentTag].addAttribute(attrProperty);
2515 }
2516 currentTag = GNE_TAG_CALIBRATOR_FLOW;
2517 {
2518 // set values of tag
2519 myTagProperties[currentTag] = GNETagProperties(currentTag,
2522 GUIIcon::FLOW, SUMO_TAG_FLOW, {SUMO_TAG_CALIBRATOR}, FXRGBA(253, 255, 206, 255));
2523 // set values of attributes
2526 "The id of the route the vehicle shall drive along");
2527 myTagProperties[currentTag].addAttribute(attrProperty);
2528
2531 "First " + toString(currentTag) + " departure time",
2532 "0");
2533 myTagProperties[currentTag].addAttribute(attrProperty);
2534
2537 "End of departure interval",
2538 "3600");
2539 myTagProperties[currentTag].addAttribute(attrProperty);
2540
2541 // fill common vehicle attributes
2542 fillCommonVehicleAttributes(currentTag);
2543
2544 // optional attributes (at least one must be defined)
2547 "The id of the vehicle type to use for this " + toString(currentTag),
2549 myTagProperties[currentTag].addAttribute(attrProperty);
2550
2553 "Number of " + toString(currentTag) + "s per hour, equally spaced",
2554 "1800");
2555 myTagProperties[currentTag].addAttribute(attrProperty);
2556
2559 "Speed of " + toString(currentTag) + "s",
2560 "15.0");
2561 myTagProperties[currentTag].addAttribute(attrProperty);
2562 }
2563 currentTag = SUMO_TAG_REROUTER;
2564 {
2565 // set values of tag
2566 myTagProperties[currentTag] = GNETagProperties(currentTag,
2569 GUIIcon::REROUTER, currentTag, {}, FXRGBA(255, 213, 213, 255));
2570
2571 // set values of attributes
2572 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2574 "The id of Rerouter");
2575 myTagProperties[currentTag].addAttribute(attrProperty);
2576
2579 "An edge id or a list of edge ids where vehicles shall be rerouted");
2580 myTagProperties[currentTag].addAttribute(attrProperty);
2581
2584 "X,Y position in editor (Only used in NETEDIT)",
2585 "0,0"); // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
2586 myTagProperties[currentTag].addAttribute(attrProperty);
2587
2590 "Name of " + toString(currentTag));
2591 myTagProperties[currentTag].addAttribute(attrProperty);
2592
2595 "The probability for vehicle rerouting (0-1)",
2596 "1.00");
2597 myTagProperties[currentTag].addAttribute(attrProperty);
2598
2601 "The waiting time threshold (in s) that must be reached to activate rerouting (default -1 which disables the threshold)",
2602 "0.00");
2603 myTagProperties[currentTag].addAttribute(attrProperty);
2604
2607 "The list of vehicle types that shall be affected by this rerouter (empty to affect all types)");
2608 myTagProperties[currentTag].addAttribute(attrProperty);
2609
2612 "Whether the router should be inactive initially (and switched on in the gui)",
2613 "0");
2614 myTagProperties[currentTag].addAttribute(attrProperty);
2615 }
2616 currentTag = GNE_TAG_REROUTER_SYMBOL;
2617 {
2618 // set values of tag
2619 myTagProperties[currentTag] = GNETagProperties(currentTag,
2622 GUIIcon::EDGE, currentTag, {GNE_TAG_REROUTER_SYMBOL}, FXRGBA(255, 213, 213, 255));
2623 }
2624 currentTag = SUMO_TAG_INTERVAL;
2625 {
2626 // set values of tag
2627 myTagProperties[currentTag] = GNETagProperties(currentTag,
2630 GUIIcon::REROUTERINTERVAL, currentTag, {SUMO_TAG_REROUTER}, FXRGBA(255, 213, 213, 255));
2631 // set values of attributes
2634 "Begin",
2635 "0");
2636 myTagProperties[currentTag].addAttribute(attrProperty);
2637
2640 "End",
2641 "3600");
2642 myTagProperties[currentTag].addAttribute(attrProperty);
2643 }
2644 currentTag = SUMO_TAG_CLOSING_REROUTE;
2645 {
2646 // set values of tag
2647 myTagProperties[currentTag] = GNETagProperties(currentTag,
2650 GUIIcon::CLOSINGREROUTE, currentTag, {SUMO_TAG_INTERVAL}, FXRGBA(255, 213, 213, 255));
2651 // set values of attributes
2654 "Edge ID");
2655 attrProperty.setSynonym(SUMO_ATTR_ID);
2656 myTagProperties[currentTag].addAttribute(attrProperty);
2657
2660 "allowed vehicles");
2661 myTagProperties[currentTag].addAttribute(attrProperty);
2662
2665 "disallowed vehicles");
2666 myTagProperties[currentTag].addAttribute(attrProperty);
2667 }
2668 currentTag = SUMO_TAG_CLOSING_LANE_REROUTE;
2669 {
2670 // set values of tag
2671 myTagProperties[currentTag] = GNETagProperties(currentTag,
2674 GUIIcon::CLOSINGLANEREROUTE, currentTag, {SUMO_TAG_INTERVAL}, FXRGBA(255, 213, 213, 255));
2675 // set values of attributes
2678 "Lane ID");
2679 attrProperty.setSynonym(SUMO_ATTR_ID);
2680 myTagProperties[currentTag].addAttribute(attrProperty);
2681
2684 "allowed vehicles");
2685 myTagProperties[currentTag].addAttribute(attrProperty);
2686
2689 "disallowed vehicles");
2690 myTagProperties[currentTag].addAttribute(attrProperty);
2691 }
2692 currentTag = SUMO_TAG_DEST_PROB_REROUTE;
2693 {
2694 // set values of tag
2695 myTagProperties[currentTag] = GNETagProperties(currentTag,
2698 GUIIcon::DESTPROBREROUTE, currentTag, {SUMO_TAG_INTERVAL}, FXRGBA(255, 213, 213, 255));
2699 // set values of attributes
2702 "Edge ID");
2703 attrProperty.setSynonym(SUMO_ATTR_ID);
2704 myTagProperties[currentTag].addAttribute(attrProperty);
2705
2708 "SUMO Probability",
2709 "1.00");
2710 myTagProperties[currentTag].addAttribute(attrProperty);
2711 }
2712 currentTag = SUMO_TAG_PARKING_AREA_REROUTE;
2713 {
2714 // set values of tag
2715 myTagProperties[currentTag] = GNETagProperties(currentTag,
2718 GUIIcon::PARKINGZONEREROUTE, currentTag, {SUMO_TAG_INTERVAL}, FXRGBA(255, 213, 213, 255));
2719 // set values of attributes
2722 "ParkingArea ID");
2723 attrProperty.setSynonym(SUMO_ATTR_ID);
2724 myTagProperties[currentTag].addAttribute(attrProperty);
2725
2728 "SUMO Probability",
2729 "1.00");
2730 myTagProperties[currentTag].addAttribute(attrProperty);
2731
2734 "Enable or disable visibility for parking area reroutes",
2735 "1");
2736 myTagProperties[currentTag].addAttribute(attrProperty);
2737 }
2738 currentTag = SUMO_TAG_ROUTE_PROB_REROUTE;
2739 {
2740 // set values of tag
2741 myTagProperties[currentTag] = GNETagProperties(currentTag,
2744 GUIIcon::ROUTEPROBREROUTE, currentTag, {SUMO_TAG_INTERVAL}, FXRGBA(255, 213, 213, 255));
2745 // set values of attributes
2748 "Route");
2749 attrProperty.setSynonym(SUMO_ATTR_ID);
2750 myTagProperties[currentTag].addAttribute(attrProperty);
2751
2754 "SUMO Probability",
2755 "1.00");
2756 myTagProperties[currentTag].addAttribute(attrProperty);
2757 }
2758 currentTag = SUMO_TAG_ROUTEPROBE;
2759 {
2760 // set values of tag
2761 myTagProperties[currentTag] = GNETagProperties(currentTag,
2764 GUIIcon::ROUTEPROBE, currentTag, {}, FXRGBA(253, 255, 206, 255));
2765 // set values of attributes
2766 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2768 "The id of RouteProbe");
2769 myTagProperties[currentTag].addAttribute(attrProperty);
2770
2773 "The id of an edge in the simulation network");
2774 myTagProperties[currentTag].addAttribute(attrProperty);
2775
2778 "The frequency in which to report the distribution",
2779 "3600.00");
2780 myTagProperties[currentTag].addAttribute(attrProperty);
2781
2784 "Name of " + toString(currentTag));
2785 myTagProperties[currentTag].addAttribute(attrProperty);
2786
2789 "The file for generated output");
2790 myTagProperties[currentTag].addAttribute(attrProperty);
2791
2794 "The time at which to start generating output",
2795 "0");
2796 myTagProperties[currentTag].addAttribute(attrProperty);
2797 }
2798 currentTag = SUMO_TAG_VAPORIZER;
2799 {
2800 // set values of tag
2801 myTagProperties[currentTag] = GNETagProperties(currentTag,
2804 GUIIcon::VAPORIZER, currentTag, {}, FXRGBA(253, 255, 206, 255));
2805 // set values of attributes
2806 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2808 "Edge in which vaporizer is placed");
2809 myTagProperties[currentTag].addAttribute(attrProperty);
2810
2813 "Start Time",
2814 "0");
2815 myTagProperties[currentTag].addAttribute(attrProperty);
2816
2819 "End Time",
2820 "3600");
2821 myTagProperties[currentTag].addAttribute(attrProperty);
2822
2825 "Name of " + toString(currentTag));
2826 myTagProperties[currentTag].addAttribute(attrProperty);
2827 }
2828}
2829
2830
2831void
2833 // declare empty GNEAttributeProperties
2834 GNEAttributeProperties attrProperty;
2835 // fill shape ACs
2836 SumoXMLTag currentTag = SUMO_TAG_POLY;
2837 {
2838 // set values of tag
2839 myTagProperties[currentTag] = GNETagProperties(currentTag,
2842 GUIIcon::POLY, currentTag);
2843 // set values of attributes
2844 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2846 "The id of the polygon");
2847 myTagProperties[currentTag].addAttribute(attrProperty);
2848
2851 "The shape of the polygon");
2852 myTagProperties[currentTag].addAttribute(attrProperty);
2853
2856 "The RGBA color with which the polygon shall be displayed",
2857 "red");
2858 myTagProperties[currentTag].addAttribute(attrProperty);
2859
2862 "An information whether the polygon shall be filled",
2863 "0");
2864 myTagProperties[currentTag].addAttribute(attrProperty);
2865
2868 "The default line width for drawing an unfilled polygon",
2869 "1");
2870 myTagProperties[currentTag].addAttribute(attrProperty);
2871
2874 "The layer in which the polygon lies",
2876 myTagProperties[currentTag].addAttribute(attrProperty);
2877
2880 "A typename for the polygon",
2882 myTagProperties[currentTag].addAttribute(attrProperty);
2883
2886 "Name of " + toString(currentTag));
2887 myTagProperties[currentTag].addAttribute(attrProperty);
2888
2891 "A bitmap to use for rendering this polygon",
2893 myTagProperties[currentTag].addAttribute(attrProperty);
2894
2897 "Enable or disable use image file as a relative path",
2899 myTagProperties[currentTag].addAttribute(attrProperty);
2900
2903 "Angle of rendered image in degree",
2905 myTagProperties[currentTag].addAttribute(attrProperty);
2906 }
2907 currentTag = SUMO_TAG_POI;
2908 {
2909 // set values of tag
2910 myTagProperties[currentTag] = GNETagProperties(currentTag,
2913 GUIIcon::POI, currentTag);
2914 // set values of attributes
2915 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2917 "The id of the " + toString(currentTag));
2918 myTagProperties[currentTag].addAttribute(attrProperty);
2919
2921 GNEAttributeProperties::STRING | GNEAttributeProperties::POSITION | GNEAttributeProperties::UNIQUE | GNEAttributeProperties::UPDATEGEOMETRY, // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
2922 "The position in view");
2923 myTagProperties[currentTag].addAttribute(attrProperty);
2924
2927 "The color with which the " + toString(currentTag) + " shall be displayed",
2928 "red");
2929 myTagProperties[currentTag].addAttribute(attrProperty);
2930
2933 "A typename for the " + toString(currentTag),
2935 myTagProperties[currentTag].addAttribute(attrProperty);
2936
2939 "Name of " + toString(currentTag));
2940 myTagProperties[currentTag].addAttribute(attrProperty);
2941
2944 "The layer of the " + toString(currentTag) + " for drawing and selecting",
2946 myTagProperties[currentTag].addAttribute(attrProperty);
2947
2950 "Width of rendered image in meters",
2952 myTagProperties[currentTag].addAttribute(attrProperty);
2953
2956 "Height of rendered image in meters",
2958 myTagProperties[currentTag].addAttribute(attrProperty);
2959
2962 "A bitmap to use for rendering this " + toString(currentTag),
2964 myTagProperties[currentTag].addAttribute(attrProperty);
2965
2968 "Enable or disable use image file as a relative path",
2970 myTagProperties[currentTag].addAttribute(attrProperty);
2971
2974 "Angle of rendered image in degree",
2976 myTagProperties[currentTag].addAttribute(attrProperty);
2977 }
2978 currentTag = GNE_TAG_POILANE;
2979 {
2980 // set values of tag
2981 myTagProperties[currentTag] = GNETagProperties(currentTag,
2983 0,
2985 // set values of attributes
2986 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2988 "The id of the " + toString(currentTag));
2989 myTagProperties[currentTag].addAttribute(attrProperty);
2990
2993 "The name of the lane at which the " + toString(currentTag) + " is located at");
2994 myTagProperties[currentTag].addAttribute(attrProperty);
2995
2998 "The position on the named lane or in the net in meters at which the " + toString(currentTag) + " is located at");
2999 myTagProperties[currentTag].addAttribute(attrProperty);
3000
3003 "If set, no error will be reported if element is placed behind the lane.\n"
3004 "Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,\n"
3005 "if the position was negative and larger than the lanes length after multiplication with - 1",
3006 "0");
3007 myTagProperties[currentTag].addAttribute(attrProperty);
3008
3011 "The lateral offset on the named lane at which the " + toString(currentTag) + " is located at",
3012 "0.00");
3013 myTagProperties[currentTag].addAttribute(attrProperty);
3014
3017 "The color with which the " + toString(currentTag) + " shall be displayed",
3018 "red");
3019 myTagProperties[currentTag].addAttribute(attrProperty);
3020
3023 "A typename for the " + toString(currentTag),
3025 myTagProperties[currentTag].addAttribute(attrProperty);
3026
3029 "Name of " + toString(currentTag));
3030 myTagProperties[currentTag].addAttribute(attrProperty);
3031
3034 "The layer of the " + toString(currentTag) + " for drawing and selecting",
3036 myTagProperties[currentTag].addAttribute(attrProperty);
3037
3040 "Width of rendered image in meters",
3042 myTagProperties[currentTag].addAttribute(attrProperty);
3043
3046 "Height of rendered image in meters",
3048 myTagProperties[currentTag].addAttribute(attrProperty);
3049
3052 "A bitmap to use for rendering this " + toString(currentTag),
3054 myTagProperties[currentTag].addAttribute(attrProperty);
3055
3058 "Enable or disable use image file as a relative path",
3060 myTagProperties[currentTag].addAttribute(attrProperty);
3061
3064 "Angle of rendered image in degree",
3066 myTagProperties[currentTag].addAttribute(attrProperty);
3067 }
3068 currentTag = GNE_TAG_POIGEO;
3069 {
3070 // set values of tag
3071 myTagProperties[currentTag] = GNETagProperties(currentTag,
3075 // set values of attributes
3076 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3078 "The id of the " + toString(currentTag));
3079 myTagProperties[currentTag].addAttribute(attrProperty);
3080
3081 // set values of attributes
3084 "The longitud position of the parking vehicle on the view");
3085 myTagProperties[currentTag].addAttribute(attrProperty);
3086
3089 "The latitud position of the parking vehicle on the view");
3090 myTagProperties[currentTag].addAttribute(attrProperty);
3091
3094 "The color with which the " + toString(currentTag) + " shall be displayed",
3095 "red");
3096 myTagProperties[currentTag].addAttribute(attrProperty);
3097
3100 "A typename for the " + toString(currentTag),
3102 myTagProperties[currentTag].addAttribute(attrProperty);
3103
3106 "Name of " + toString(currentTag));
3107 myTagProperties[currentTag].addAttribute(attrProperty);
3108
3111 "The layer of the " + toString(currentTag) + " for drawing and selecting",
3113 myTagProperties[currentTag].addAttribute(attrProperty);
3114
3117 "Width of rendered image in meters",
3119 myTagProperties[currentTag].addAttribute(attrProperty);
3120
3123 "Height of rendered image in meters",
3125 myTagProperties[currentTag].addAttribute(attrProperty);
3126
3129 "A bitmap to use for rendering this " + toString(currentTag),
3131 myTagProperties[currentTag].addAttribute(attrProperty);
3132
3135 "Enable or disable use image file as a relative path",
3137 myTagProperties[currentTag].addAttribute(attrProperty);
3138
3141 "Angle of rendered image in degree",
3143 myTagProperties[currentTag].addAttribute(attrProperty);
3144 }
3145}
3146
3147
3148void
3150 // declare empty GNEAttributeProperties
3151 GNEAttributeProperties attrProperty;
3152 // fill TAZ ACs
3153 SumoXMLTag currentTag = SUMO_TAG_TAZ;
3154 {
3155 // set values of tag
3156 myTagProperties[currentTag] = GNETagProperties(currentTag,
3159 GUIIcon::TAZ, currentTag);
3160 // set values of attributes
3161 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3163 "The id of the TAZ");
3164 myTagProperties[currentTag].addAttribute(attrProperty);
3165
3168 "The shape of the TAZ");
3169 myTagProperties[currentTag].addAttribute(attrProperty);
3170
3173 "TAZ center");
3174 myTagProperties[currentTag].addAttribute(attrProperty);
3175
3178 "An information whether the TAZ shall be filled",
3179 "0");
3180 myTagProperties[currentTag].addAttribute(attrProperty);
3181
3184 "The RGBA color with which the TAZ shall be displayed",
3185 "red");
3186 myTagProperties[currentTag].addAttribute(attrProperty);
3187
3190 "Name of " + toString(currentTag));
3191 myTagProperties[currentTag].addAttribute(attrProperty);
3192 }
3193 currentTag = SUMO_TAG_TAZSOURCE;
3194 {
3195 // set values of tag
3196 myTagProperties[currentTag] = GNETagProperties(currentTag,
3199 GUIIcon::TAZEDGE, currentTag, {SUMO_TAG_TAZ});
3200 // set values of attributes
3203 "The id of edge in the simulation network");
3204 attrProperty.setSynonym(SUMO_ATTR_ID);
3205 myTagProperties[currentTag].addAttribute(attrProperty);
3206
3209 "Depart weight associated to this Edge",
3210 "1");
3211 myTagProperties[currentTag].addAttribute(attrProperty);
3212 }
3213 currentTag = SUMO_TAG_TAZSINK;
3214 {
3215 // set values of tag
3216 myTagProperties[currentTag] = GNETagProperties(currentTag,
3219 GUIIcon::TAZEDGE, currentTag, {SUMO_TAG_TAZ});
3220 // set values of attributes
3223 "The id of edge in the simulation network");
3224 attrProperty.setSynonym(SUMO_ATTR_ID);
3225 myTagProperties[currentTag].addAttribute(attrProperty);
3226
3229 "Arrival weight associated to this Edget",
3230 "1");
3231 myTagProperties[currentTag].addAttribute(attrProperty);
3232 }
3233}
3234
3235
3236void
3238 // declare empty GNEAttributeProperties
3239 GNEAttributeProperties attrProperty;
3240
3241 // fill wire elements
3243 {
3244 // set tag properties
3245 myTagProperties[currentTag] = GNETagProperties(currentTag,
3248 GUIIcon::TRACTION_SUBSTATION, currentTag);
3249 // set attribute properties
3250 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3252 "Traction substation ID");
3253 myTagProperties[currentTag].addAttribute(attrProperty);
3254
3257 "X-Y position of detector in editor (Only used in NETEDIT)",
3258 "0,0"); // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
3259 myTagProperties[currentTag].addAttribute(attrProperty);
3260
3263 "Voltage of at connection point for the overhead wire",
3264 "600");
3265 myTagProperties[currentTag].addAttribute(attrProperty);
3266
3269 "Current limit of the feeder line",
3270 "400");
3271 myTagProperties[currentTag].addAttribute(attrProperty);
3272 }
3273 currentTag = SUMO_TAG_OVERHEAD_WIRE_SECTION;
3274 {
3275 // set tag properties
3276 myTagProperties[currentTag] = GNETagProperties(currentTag,
3278 0,
3279 GUIIcon::OVERHEADWIRE, currentTag);
3280 // set attribute properties
3281 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3283 "Overhead wire segment ID");
3284 myTagProperties[currentTag].addAttribute(attrProperty);
3285
3288 "Substation to which the circuit is connected");
3289 myTagProperties[currentTag].addAttribute(attrProperty);
3290
3293 "List of consecutive lanes of the circuit");
3294 myTagProperties[currentTag].addAttribute(attrProperty);
3295
3298 "Starting position in the specified lane",
3299 "0");
3300 myTagProperties[currentTag].addAttribute(attrProperty);
3301
3304 "Ending position in the specified lane",
3306 myTagProperties[currentTag].addAttribute(attrProperty);
3307
3310 "If set, no error will be reported if element is placed behind the lane.\n"
3311 "Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,\n"
3312 "if the position was negative and larger than the lanes length after multiplication with - 1",
3313 "0");
3314 myTagProperties[currentTag].addAttribute(attrProperty);
3315
3318 "Inner lanes, where placing of overhead wire is restricted");
3319 myTagProperties[currentTag].addAttribute(attrProperty);
3320 }
3321 currentTag = SUMO_TAG_OVERHEAD_WIRE_CLAMP;
3322 {
3323 // set tag properties
3324 myTagProperties[currentTag] = GNETagProperties(currentTag,
3326 0,
3327 GUIIcon::OVERHEADWIRE_CLAMP, currentTag);
3328 // set attribute properties
3329 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3331 "Overhead wire clamp ID");
3332 myTagProperties[currentTag].addAttribute(attrProperty);
3333
3336 "ID of the overhead wire segment, to the start of which the overhead wire clamp is connected");
3337 myTagProperties[currentTag].addAttribute(attrProperty);
3338
3341 "ID of the overhead wire segment lane of overheadWireIDStartClamp");
3342 myTagProperties[currentTag].addAttribute(attrProperty);
3343
3346 "ID of the overhead wire segment, to the end of which the overhead wire clamp is connected");
3347 myTagProperties[currentTag].addAttribute(attrProperty);
3348
3351 "ID of the overhead wire segment lane of overheadWireIDEndClamp");
3352 myTagProperties[currentTag].addAttribute(attrProperty);
3353 }
3354}
3355
3356
3357void
3359 // declare empty GNEAttributeProperties
3360 GNEAttributeProperties attrProperty;
3361
3362 // fill demand elements
3363 SumoXMLTag currentTag = SUMO_TAG_ROUTE;
3364 {
3365 // set values of tag
3366 myTagProperties[currentTag] = GNETagProperties(currentTag,
3368 0,
3369 GUIIcon::ROUTE, currentTag);
3370
3371 // set values of attributes
3372 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3374 "The id of Route");
3375 myTagProperties[currentTag].addAttribute(attrProperty);
3376
3379 "The edges the vehicle shall drive along, given as their ids, separated using spaces");
3380 myTagProperties[currentTag].addAttribute(attrProperty);
3381
3384 "This route's color");
3385 myTagProperties[currentTag].addAttribute(attrProperty);
3386
3389 "The number of times that the edges of this route shall be repeated",
3390 "0");
3391 myTagProperties[currentTag].addAttribute(attrProperty);
3392
3395 "When defining a repeating route with stops and those stops use the until attribute,\n"
3396 "the times will be shifted forward by 'cycleTime' on each repeat",
3397 "0");
3398 myTagProperties[currentTag].addAttribute(attrProperty);
3399 }
3400 currentTag = GNE_TAG_ROUTE_EMBEDDED;
3401 {
3402 // set values of tag
3403 myTagProperties[currentTag] = GNETagProperties(currentTag,
3407
3408 // set values of attributes
3411 "The edges the vehicle shall drive along, given as their ids, separated using spaces");
3412 myTagProperties[currentTag].addAttribute(attrProperty);
3413
3416 "This route's color");
3417 myTagProperties[currentTag].addAttribute(attrProperty);
3418
3421 "The number of times that the edges of this route shall be repeated",
3422 "0");
3423 myTagProperties[currentTag].addAttribute(attrProperty);
3424
3427 "When defining a repeating route with stops and those stops use the until attribute,\n"
3428 "the times will be shifted forward by 'cycleTime' on each repeat",
3429 "0");
3430 myTagProperties[currentTag].addAttribute(attrProperty);
3431 }
3432 currentTag = SUMO_TAG_VTYPE_DISTRIBUTION;
3433 {
3434 // set values of tag
3435 myTagProperties[currentTag] = GNETagProperties(currentTag,
3438 GUIIcon::VTYPEDISTRIBUTION, currentTag);
3439
3440 // set values of attributes
3441 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3443 "The id of VehicleType distribution");
3444 myTagProperties[currentTag].addAttribute(attrProperty);
3445
3446 /* Disabled until next release
3447 attrProperty = GNEAttributeProperties(SUMO_ATTR_DETERMINISTIC,
3448 GNEAttributeProperties::INT | GNEAttributeProperties::DEFAULTVALUE,
3449 "makes number of assigned cars exact for any multiples of N",
3450 "-1");
3451 myTagProperties[currentTag].addAttribute(attrProperty);
3452 */
3453 }
3454 currentTag = SUMO_TAG_VTYPE;
3455 {
3456 // set values of tag
3457 myTagProperties[currentTag] = GNETagProperties(currentTag,
3460 GUIIcon::VTYPE, currentTag);
3461
3462 // set values of attributes
3463 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3465 "The id of VehicleType");
3466 myTagProperties[currentTag].addAttribute(attrProperty);
3467
3470 "Vehicle Type Distribution");
3471 myTagProperties[currentTag].addAttribute(attrProperty);
3472
3475 "An abstract vehicle class",
3476 "passenger");
3477 attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
3478 myTagProperties[currentTag].addAttribute(attrProperty);
3479
3482 "This vehicle type's color",
3483 "");
3484 myTagProperties[currentTag].addAttribute(attrProperty);
3485
3488 "The vehicle's netto-length (length) [m]");
3489 myTagProperties[currentTag].addAttribute(attrProperty);
3490
3493 "Empty space after leader [m]");
3494 myTagProperties[currentTag].addAttribute(attrProperty);
3495
3498 "The vehicle's maximum velocity [m/s]");
3499 myTagProperties[currentTag].addAttribute(attrProperty);
3500
3503 "The vehicles expected multiplicator for lane speed limits (or a distribution specifier)");
3504 myTagProperties[currentTag].addAttribute(attrProperty);
3505
3508 "The vehicles desired maximum velocity (interacts with speedFactor).\n"
3509 "Applicable when no speed Limit applies (bicycles, some motorways) [m/s]");
3510 myTagProperties[currentTag].addAttribute(attrProperty);
3511
3514 "An abstract emission class");
3516 myTagProperties[currentTag].addAttribute(attrProperty);
3517
3520 "How this vehicle is rendered");
3521 attrProperty.setDiscreteValues(SumoVehicleShapeStrings.getStrings());
3522 myTagProperties[currentTag].addAttribute(attrProperty);
3523
3526 "The vehicle's width [m] (only used for drawing)",
3527 "1.8");
3528 myTagProperties[currentTag].addAttribute(attrProperty);
3529
3532 "The vehicle's height [m] (only used for drawing)",
3533 "1.5");
3534 myTagProperties[currentTag].addAttribute(attrProperty);
3535
3538 "Image file for rendering vehicles of this type (should be grayscale to allow functional coloring)");
3539 myTagProperties[currentTag].addAttribute(attrProperty);
3540
3543 "The model used for changing lanes",
3544 "default");
3546 myTagProperties[currentTag].addAttribute(attrProperty);
3547
3550 "The model used for car following",
3551 "Krauss");
3552 attrProperty.setDiscreteValues(SUMOXMLDefinitions::CarFollowModels.getStrings());
3553 myTagProperties[currentTag].addAttribute(attrProperty);
3554
3557 "The number of persons (excluding an autonomous driver) the vehicle can transport");
3558 myTagProperties[currentTag].addAttribute(attrProperty);
3559
3562 "The number of containers the vehicle can transport");
3563 myTagProperties[currentTag].addAttribute(attrProperty);
3564
3567 "The time required by a person to board the vehicle",
3568 "0.50");
3569 myTagProperties[currentTag].addAttribute(attrProperty);
3570
3573 "The time required to load a container onto the vehicle",
3574 "90.00");
3575 myTagProperties[currentTag].addAttribute(attrProperty);
3576
3579 "The preferred lateral alignment when using the sublane-model",
3580 "center");
3582 myTagProperties[currentTag].addAttribute(attrProperty);
3583
3586 "The minimum lateral gap at a speed difference of 50km/h when using the sublane-model",
3587 "0.12");
3588 myTagProperties[currentTag].addAttribute(attrProperty);
3589
3592 "The maximum lateral speed when using the sublane-model",
3593 "1.00");
3594 myTagProperties[currentTag].addAttribute(attrProperty);
3595
3598 "The interval length for which vehicle performs its decision logic (acceleration and lane-changing)",
3599 toString(OptionsCont::getOptions().getFloat("default.action-step-length")));
3600 myTagProperties[currentTag].addAttribute(attrProperty);
3601
3604 "The probability when being added to a distribution without an explicit probability",
3606 myTagProperties[currentTag].addAttribute(attrProperty);
3607
3610 "3D model file for this class",
3611 "");
3612 myTagProperties[currentTag].addAttribute(attrProperty);
3613
3616 "Carriage lengths");
3617 myTagProperties[currentTag].addAttribute(attrProperty);
3618
3621 "Locomotive lengths");
3622 myTagProperties[currentTag].addAttribute(attrProperty);
3623
3626 "GAP between carriages",
3627 "1");
3628 myTagProperties[currentTag].addAttribute(attrProperty);
3629
3630 // fill VType Car Following Model Values (implemented in a separated function to improve code legibility)
3632
3633 // fill VType Junction Model Parameters (implemented in a separated function to improve code legibility)
3634 fillJunctionModelAttributes(currentTag);
3635
3636 // fill VType Lane Change Model Parameters (implemented in a separated function to improve code legibility)
3638 }
3639}
3640
3641
3642void
3644 // declare empty GNEAttributeProperties
3645 GNEAttributeProperties attrProperty;
3646 // fill vehicle ACs
3647 SumoXMLTag currentTag = SUMO_TAG_TRIP;
3648 {
3649 // set values of tag
3650 myTagProperties[currentTag] = GNETagProperties(currentTag,
3652 0,
3653 GUIIcon::TRIP, currentTag, {}, FXRGBA(253, 255, 206, 255));
3654 myTagProperties[currentTag].setFieldString("trip (from-to edges)");
3655
3656 // set values of attributes
3657 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3659 "The name of " + toString(currentTag) + "s that will be generated using this trip definition");
3660 myTagProperties[currentTag].addAttribute(attrProperty);
3661
3664 "The id of the " + toString(currentTag) + " type to use for this " + toString(currentTag),
3666 myTagProperties[currentTag].addAttribute(attrProperty);
3667
3670 "The name of the edge the " + toString(currentTag) + " starts at");
3671 myTagProperties[currentTag].addAttribute(attrProperty);
3672
3673 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
3675 "The name of the edge the " + toString(currentTag) + " ends at");
3676 myTagProperties[currentTag].addAttribute(attrProperty);
3677
3680 "List of intermediate edge ids which shall be part of the " + toString(currentTag));
3681 myTagProperties[currentTag].addAttribute(attrProperty);
3682
3683 // add common attributes
3684 fillCommonVehicleAttributes(currentTag);
3685
3688 "The departure time of the (first) " + toString(currentTag) + " which is generated using this " + toString(currentTag) + " definition",
3689 "0.00");
3690 myTagProperties[currentTag].addAttribute(attrProperty);
3691 }
3692 currentTag = GNE_TAG_TRIP_JUNCTIONS;
3693 {
3694 // set values of tag
3695 myTagProperties[currentTag] = GNETagProperties(currentTag,
3697 0,
3698 GUIIcon::TRIP_JUNCTIONS, SUMO_TAG_TRIP, {}, FXRGBA(255, 213, 213, 255));
3699 myTagProperties[currentTag].setFieldString("trip (from-to junctions)");
3700
3701 // set values of attributes
3702 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3704 "The name of " + toString(currentTag) + "s that will be generated using this trip definition");
3705 myTagProperties[currentTag].addAttribute(attrProperty);
3706
3709 "The id of the " + toString(currentTag) + " type to use for this " + toString(currentTag),
3711 myTagProperties[currentTag].addAttribute(attrProperty);
3712
3715 "The name of the junction the " + toString(currentTag) + " starts at");
3716 myTagProperties[currentTag].addAttribute(attrProperty);
3717
3720 "The name of the junction the " + toString(currentTag) + " ends at");
3721 myTagProperties[currentTag].addAttribute(attrProperty);
3722
3723 // add common attributes
3724 fillCommonVehicleAttributes(currentTag);
3725
3728 "The departure time of the (first) " + toString(currentTag) + " which is generated using this " + toString(currentTag) + " definition",
3729 "0.00");
3730 myTagProperties[currentTag].addAttribute(attrProperty);
3731 }
3732 currentTag = SUMO_TAG_VEHICLE;
3733 {
3734 // set values of tag
3735 myTagProperties[currentTag] = GNETagProperties(currentTag,
3737 0,
3738 GUIIcon::VEHICLE, currentTag, {}, FXRGBA(210, 233, 255, 255));
3739 myTagProperties[currentTag].setFieldString("vehicle (over route)");
3740
3741 // set values of attributes
3742 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3744 "The name of the " + toString(currentTag));
3745 myTagProperties[currentTag].addAttribute(attrProperty);
3746
3749 "The id of the vehicle type to use for this " + toString(currentTag),
3751 myTagProperties[currentTag].addAttribute(attrProperty);
3752
3755 "The id of the route the " + toString(currentTag) + " shall drive along");
3756 myTagProperties[currentTag].addAttribute(attrProperty);
3757
3760 "The index of the edge within route the " + toString(currentTag) + " starts at");
3761 myTagProperties[currentTag].addAttribute(attrProperty);
3762
3765 "The index of the edge within route the " + toString(currentTag) + " ends at");
3766 myTagProperties[currentTag].addAttribute(attrProperty);
3767
3768 // add common attributes
3769 fillCommonVehicleAttributes(currentTag);
3770
3773 "The time step at which the " + toString(currentTag) + " shall enter the network",
3774 "0.00");
3775 myTagProperties[currentTag].addAttribute(attrProperty);
3776 }
3777 currentTag = GNE_TAG_VEHICLE_WITHROUTE;
3778 {
3779 // set values of tag
3780 myTagProperties[currentTag] = GNETagProperties(currentTag,
3783 GUIIcon::VEHICLE, SUMO_TAG_VEHICLE, {}, FXRGBA(210, 233, 255, 255));
3784 myTagProperties[currentTag].setFieldString("vehicle (embedded route)");
3785
3786 // set values of attributes
3787 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3789 "The name of the " + toString(SUMO_TAG_VEHICLE));
3790 myTagProperties[currentTag].addAttribute(attrProperty);
3791
3794 "The id of the vehicle type to use for this " + toString(SUMO_TAG_VEHICLE),
3796 myTagProperties[currentTag].addAttribute(attrProperty);
3797
3800 "The index of the edge within route the " + toString(currentTag) + " starts at");
3801 myTagProperties[currentTag].addAttribute(attrProperty);
3802
3805 "The index of the edge within route the " + toString(currentTag) + " ends at");
3806 myTagProperties[currentTag].addAttribute(attrProperty);
3807
3808 // add common attributes
3809 fillCommonVehicleAttributes(currentTag);
3810
3813 "The time step at which the " + toString(SUMO_TAG_VEHICLE) + " shall enter the network",
3814 "0.00");
3815 myTagProperties[currentTag].addAttribute(attrProperty);
3816 }
3817 currentTag = SUMO_TAG_FLOW;
3818 {
3819 // set values of tag
3820 myTagProperties[currentTag] = GNETagProperties(currentTag,
3822 0,
3823 GUIIcon::FLOW, currentTag, {}, FXRGBA(253, 255, 206, 255));
3824 myTagProperties[currentTag].setFieldString("flow (from-to edges)");
3825
3826 // set values of attributes
3827 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3829 "The name of the " + toString(currentTag));
3830 myTagProperties[currentTag].addAttribute(attrProperty);
3831
3834 "The id of the " + toString(currentTag) + " type to use for this " + toString(currentTag),
3836 myTagProperties[currentTag].addAttribute(attrProperty);
3837
3840 "The name of the edge the " + toString(currentTag) + " starts at");
3841 myTagProperties[currentTag].addAttribute(attrProperty);
3842
3843 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
3845 "The name of the edge the " + toString(currentTag) + " ends at");
3846 myTagProperties[currentTag].addAttribute(attrProperty);
3847
3850 "List of intermediate edge ids which shall be part of the " + toString(currentTag));
3851 myTagProperties[currentTag].addAttribute(attrProperty);
3852
3853 // add common attributes
3854 fillCommonVehicleAttributes(currentTag);
3855
3856 // add flow attributes
3858 }
3859 currentTag = GNE_TAG_FLOW_JUNCTIONS;
3860 {
3861 // set values of tag
3862 myTagProperties[currentTag] = GNETagProperties(currentTag,
3864 0,
3865 GUIIcon::FLOW_JUNCTIONS, SUMO_TAG_FLOW, {}, FXRGBA(255, 213, 213, 255));
3866 myTagProperties[currentTag].setFieldString("flow (from-to junctions)");
3867
3868 // set values of attributes
3869 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3871 "The name of the " + toString(currentTag));
3872 myTagProperties[currentTag].addAttribute(attrProperty);
3873
3876 "The id of the " + toString(currentTag) + " type to use for this " + toString(currentTag),
3878 myTagProperties[currentTag].addAttribute(attrProperty);
3879
3882 "The name of the junction the " + toString(currentTag) + " starts at");
3883 myTagProperties[currentTag].addAttribute(attrProperty);
3884
3887 "The name of the junction the " + toString(currentTag) + " ends at");
3888 myTagProperties[currentTag].addAttribute(attrProperty);
3889
3890 // add common attributes
3891 fillCommonVehicleAttributes(currentTag);
3892
3893 // add flow attributes
3895 }
3896 currentTag = GNE_TAG_FLOW_ROUTE;
3897 {
3898 // set values of tag
3899 myTagProperties[currentTag] = GNETagProperties(currentTag,
3901 0,
3902 GUIIcon::ROUTEFLOW, SUMO_TAG_FLOW, {}, FXRGBA(210, 233, 255, 255));
3903 myTagProperties[currentTag].setFieldString("flow (over route)");
3904
3905 // set values of attributes
3906 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3908 "The name of the " + toString(currentTag));
3909 myTagProperties[currentTag].addAttribute(attrProperty);
3910
3913 "The id of the " + toString(currentTag) + " type to use for this " + toString(currentTag),
3915 myTagProperties[currentTag].addAttribute(attrProperty);
3916
3919 "The id of the route the " + toString(currentTag) + " shall drive along");
3920 myTagProperties[currentTag].addAttribute(attrProperty);
3921
3924 "The index of the edge within route the " + toString(currentTag) + " starts at");
3925 myTagProperties[currentTag].addAttribute(attrProperty);
3926
3929 "The index of the edge within route the " + toString(currentTag) + " ends at");
3930 myTagProperties[currentTag].addAttribute(attrProperty);
3931
3932 // add common attributes
3933 fillCommonVehicleAttributes(currentTag);
3934
3935 // add flow attributes
3937 }
3938 currentTag = GNE_TAG_FLOW_WITHROUTE;
3939 {
3940 // set values of tag
3941 myTagProperties[currentTag] = GNETagProperties(currentTag,
3944 GUIIcon::ROUTEFLOW, SUMO_TAG_FLOW, {}, FXRGBA(210, 233, 255, 255));
3945 myTagProperties[currentTag].setFieldString("flow (embedded route)");
3946
3947 // set values of attributes
3948 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3950 "The name of the " + toString(SUMO_TAG_FLOW));
3951 myTagProperties[currentTag].addAttribute(attrProperty);
3952
3955 "The id of the " + toString(currentTag) + " type to use for this " + toString(SUMO_TAG_FLOW),
3957 myTagProperties[currentTag].addAttribute(attrProperty);
3958
3961 "The index of the edge within route the " + toString(currentTag) + " starts at");
3962 myTagProperties[currentTag].addAttribute(attrProperty);
3963
3966 "The index of the edge within route the " + toString(currentTag) + " ends at");
3967 myTagProperties[currentTag].addAttribute(attrProperty);
3968
3969 // add common attributes
3970 fillCommonVehicleAttributes(currentTag);
3971
3972 // add flow attributes
3974 }
3975 /* currently disabled. See #5259
3976 currentTag = SUMO_TAG_TRIP_TAZ;
3977 {
3978 // set values of tag
3979 myTagProperties[currentTag] = GNETagProperties(currentTag,
3980 GNETagProperties::DEMANDELEMENT | GNETagProperties::VEHICLE,
3981 GNETagProperties::DRAWABLE,
3982 GUIIcon::TRIP);
3983 }
3984 */
3985}
3986
3987
3988void
3990 // declare empty GNEAttributeProperties
3991 GNEAttributeProperties attrProperty;
3992 // fill stops ACs
3993 SumoXMLTag currentTag = SUMO_TAG_STOP_LANE;
3994 {
3995 // set values of tag
3996 myTagProperties[currentTag] = GNETagProperties(currentTag,
4000 // set values of attributes
4003 "The name of the lane the stop shall be located at");
4004 myTagProperties[currentTag].addAttribute(attrProperty);
4005
4008 "The begin position on the lane (the lower position on the lane) in meters");
4009 myTagProperties[currentTag].addAttribute(attrProperty);
4010
4013 "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
4014 myTagProperties[currentTag].addAttribute(attrProperty);
4015
4018 "If set, no error will be reported if element is placed behind the lane.\n"
4019 "Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,\n"
4020 "if the position was negative and larger than the lanes length after multiplication with - 1",
4021 "0");
4022 myTagProperties[currentTag].addAttribute(attrProperty);
4023
4026 "The lateral offset on the named lane at which the vehicle must stop",
4027 "");
4028 myTagProperties[currentTag].addAttribute(attrProperty);
4029
4030 // fill common stop attributes
4031 fillCommonStopAttributes(currentTag, false);
4032 }
4033 currentTag = SUMO_TAG_STOP_BUSSTOP;
4034 {
4035 // set values of tag
4036 myTagProperties[currentTag] = GNETagProperties(currentTag,
4040 // set values of attributes
4043 "BusStop associated with this stop");
4044 myTagProperties[currentTag].addAttribute(attrProperty);
4045
4046 // fill common stop attributes
4047 fillCommonStopAttributes(currentTag, false);
4048 }
4049 currentTag = SUMO_TAG_STOP_CONTAINERSTOP;
4050 {
4051 // set values of tag
4052 myTagProperties[currentTag] = GNETagProperties(currentTag,
4056 // set values of attributes
4059 "ContainerStop associated with this stop");
4060 myTagProperties[currentTag].addAttribute(attrProperty);
4061
4062 // fill common stop attributes
4063 fillCommonStopAttributes(currentTag, false);
4064 }
4065 currentTag = SUMO_TAG_STOP_CHARGINGSTATION;
4066 {
4067 // set values of tag
4068 myTagProperties[currentTag] = GNETagProperties(currentTag,
4072 // set values of attributes
4075 "ChargingStation associated with this stop");
4076 myTagProperties[currentTag].addAttribute(attrProperty);
4077
4078 // fill common stop attributes
4079 fillCommonStopAttributes(currentTag, false);
4080 }
4081 currentTag = SUMO_TAG_STOP_PARKINGAREA;
4082 {
4083 // set values of tag
4084 myTagProperties[currentTag] = GNETagProperties(currentTag,
4088 // set values of attributes
4091 "ParkingArea associated with this stop");
4092 myTagProperties[currentTag].addAttribute(attrProperty);
4093
4094 // fill common stop attributes (no parking)
4095 fillCommonStopAttributes(currentTag, false);
4096 }
4097}
4098
4099
4100void
4102 // declare empty GNEAttributeProperties
4103 GNEAttributeProperties attrProperty;
4104 // fill waypoints ACs
4105 SumoXMLTag currentTag = GNE_TAG_WAYPOINT_LANE;
4106 {
4107 // set values of tag
4108 myTagProperties[currentTag] = GNETagProperties(currentTag,
4112 // set values of attributes
4115 "The name of the lane the waypoint shall be located at");
4116 myTagProperties[currentTag].addAttribute(attrProperty);
4117
4120 "The begin position on the lane (the lower position on the lane) in meters");
4121 myTagProperties[currentTag].addAttribute(attrProperty);
4122
4125 "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
4126 myTagProperties[currentTag].addAttribute(attrProperty);
4127
4130 "If set, no error will be reported if element is placed behind the lane.\n"
4131 "Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,\n"
4132 "if the position was negative and larger than the lanes length after multiplication with - 1",
4133 "0");
4134 myTagProperties[currentTag].addAttribute(attrProperty);
4135
4138 "The lateral offset on the named lane at which the vehicle must waypoint",
4139 "");
4140 myTagProperties[currentTag].addAttribute(attrProperty);
4141
4142 // fill common waypoint (stop) attributes
4143 fillCommonStopAttributes(currentTag, true);
4144 }
4145 currentTag = GNE_TAG_WAYPOINT_BUSSTOP;
4146 {
4147 // set values of tag
4148 myTagProperties[currentTag] = GNETagProperties(currentTag,
4152 // set values of attributes
4155 "BusWaypoint associated with this waypoint");
4156 myTagProperties[currentTag].addAttribute(attrProperty);
4157
4158 // fill common waypoint (stop) attributes
4159 fillCommonStopAttributes(currentTag, true);
4160 }
4161 currentTag = GNE_TAG_WAYPOINT_CONTAINERSTOP;
4162 {
4163 // set values of tag
4164 myTagProperties[currentTag] = GNETagProperties(currentTag,
4167 GUIIcon::WAYPOINT, currentTag, {SUMO_TAG_ROUTE, SUMO_TAG_TRIP, SUMO_TAG_FLOW}, FXRGBA(240, 255, 205, 255));
4168 // set values of attributes
4171 "ContainerWaypoint associated with this waypoint");
4172 myTagProperties[currentTag].addAttribute(attrProperty);
4173
4174 // fill common waypoint (stop) attributes
4175 fillCommonStopAttributes(currentTag, true);
4176 }
4178 {
4179 // set values of tag
4180 myTagProperties[currentTag] = GNETagProperties(currentTag,
4184 // set values of attributes
4187 "ChargingStation associated with this waypoint");
4188 myTagProperties[currentTag].addAttribute(attrProperty);
4189
4190 // fill common waypoint (stop) attributes
4191 fillCommonStopAttributes(currentTag, true);
4192 }
4193 currentTag = GNE_TAG_WAYPOINT_PARKINGAREA;
4194 {
4195 // set values of tag
4196 myTagProperties[currentTag] = GNETagProperties(currentTag,
4200 // set values of attributes
4203 "ParkingArea associated with this waypoint");
4204 myTagProperties[currentTag].addAttribute(attrProperty);
4205
4206 // fill common waypoint (stop) attributes
4207 fillCommonStopAttributes(currentTag, true);
4208 }
4209}
4210
4211
4212void
4214 // declare empty GNEAttributeProperties
4215 GNEAttributeProperties attrProperty;
4216 // fill vehicle ACs
4217 SumoXMLTag currentTag = SUMO_TAG_PERSON;
4218 {
4219 // set values of tag
4220 myTagProperties[currentTag] = GNETagProperties(currentTag,
4222 0,
4223 GUIIcon::PERSON, currentTag);
4224
4225 // add flow attributes
4226 fillCommonPersonAttributes(currentTag);
4227
4228 // set specific attribute depart (note: Persons doesn't support triggered and containerTriggered values)
4231 "The time step at which the " + toString(currentTag) + " shall enter the network",
4232 "0.00");
4233 myTagProperties[currentTag].addAttribute(attrProperty);
4234
4235 }
4236 currentTag = SUMO_TAG_PERSONFLOW;
4237 {
4238 // set values of tag
4239 myTagProperties[currentTag] = GNETagProperties(currentTag,
4241 0,
4242 GUIIcon::PERSONFLOW, currentTag);
4243
4244 // add flow attributes
4245 fillCommonPersonAttributes(currentTag);
4246
4247 // add flow attributes
4249 }
4250}
4251
4252
4253void
4255 // declare empty GNEAttributeProperties
4256 GNEAttributeProperties attrProperty;
4257 // fill vehicle ACs
4258 SumoXMLTag currentTag = SUMO_TAG_CONTAINER;
4259 {
4260 // set values of tag
4261 myTagProperties[currentTag] = GNETagProperties(currentTag,
4263 0,
4264 GUIIcon::CONTAINER, currentTag);
4265
4266 // add flow attributes
4268
4271 "The time step at which the " + toString(currentTag) + " shall enter the network",
4272 "0.00");
4273 myTagProperties[currentTag].addAttribute(attrProperty);
4274 }
4275 currentTag = SUMO_TAG_CONTAINERFLOW;
4276 {
4277 // set values of tag
4278 myTagProperties[currentTag] = GNETagProperties(currentTag,
4280 0,
4281 GUIIcon::CONTAINERFLOW, currentTag);
4282
4283 // add common container attribute
4285
4286 // add flow attributes
4288 }
4289}
4290
4291
4292void
4294 // declare empty GNEAttributeProperties
4295 GNEAttributeProperties attrProperty;
4296 // fill walks
4298 {
4299 // set values of tag
4300 myTagProperties[currentTag] = GNETagProperties(currentTag,
4304 // from edge
4307 "The name of the edge the " + toString(currentTag) + " starts at");
4308 myTagProperties[currentTag].addAttribute(attrProperty);
4309 // to edge
4310 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
4312 "The name of the edge the " + toString(currentTag) + " ends at");
4313 myTagProperties[currentTag].addAttribute(attrProperty);
4314 // arrival position
4317 "arrival position on the destination edge",
4318 "-1");
4319 myTagProperties[currentTag].addAttribute(attrProperty);
4320 // lines
4323 "list of vehicle alternatives to take for the " + toString(currentTag),
4324 "ANY");
4325 myTagProperties[currentTag].addAttribute(attrProperty);
4326 }
4328 {
4329 // set values of tag
4330 myTagProperties[currentTag] = GNETagProperties(currentTag,
4334 // from edge
4337 "The name of the edge the " + toString(currentTag) + " starts at");
4338 myTagProperties[currentTag].addAttribute(attrProperty);
4339 // to busStop
4342 "Id of the destination " + toString(SUMO_TAG_BUS_STOP));
4343 myTagProperties[currentTag].addAttribute(attrProperty);
4344 // lines
4347 "list of vehicle alternatives to take for the " + toString(currentTag),
4348 "ANY");
4349 myTagProperties[currentTag].addAttribute(attrProperty);
4350 }
4351}
4352
4353
4354void
4356 // declare empty GNEAttributeProperties
4357 GNEAttributeProperties attrProperty;
4358 // fill walks
4359 SumoXMLTag currentTag = GNE_TAG_TRANSHIP_EDGE;
4360 {
4361 // set values of tag
4362 myTagProperties[currentTag] = GNETagProperties(currentTag,
4366 // from edge
4369 "The name of the edge the " + toString(currentTag) + " starts at");
4370 myTagProperties[currentTag].addAttribute(attrProperty);
4371 // to edge
4372 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
4374 "The name of the edge the " + toString(currentTag) + " ends at");
4375 myTagProperties[currentTag].addAttribute(attrProperty);
4376 // depart pos
4379 "The position at which the " + toString(currentTag) + " shall enter the net",
4380 "0");
4381 myTagProperties[currentTag].addAttribute(attrProperty);
4382 // arrival position
4385 "arrival position on the destination edge",
4386 "-1");
4387 myTagProperties[currentTag].addAttribute(attrProperty);
4388 // speed
4391 "speed of the container for this tranship in m/s",
4392 "1.39");
4393 myTagProperties[currentTag].addAttribute(attrProperty);
4394 }
4395 currentTag = GNE_TAG_TRANSHIP_CONTAINERSTOP;
4396 {
4397 // set values of tag
4398 myTagProperties[currentTag] = GNETagProperties(currentTag,
4402 // from edge
4405 "The name of the edge the " + toString(currentTag) + " starts at");
4406 myTagProperties[currentTag].addAttribute(attrProperty);
4407 // to busStop
4410 "Id of the destination " + toString(SUMO_TAG_BUS_STOP));
4411 myTagProperties[currentTag].addAttribute(attrProperty);
4412 // depart pos
4415 "The position at which the " + toString(currentTag) + " shall enter the net",
4416 "0");
4417 myTagProperties[currentTag].addAttribute(attrProperty);
4418 // speed
4421 "speed of the container for this tranship in m/s",
4422 "1.39");
4423 myTagProperties[currentTag].addAttribute(attrProperty);
4424 }
4425 currentTag = GNE_TAG_TRANSHIP_EDGES;
4426 {
4427 // set values of tag
4428 myTagProperties[currentTag] = GNETagProperties(currentTag,
4432 // edges
4435 "id of the edges to walk");
4436 myTagProperties[currentTag].addAttribute(attrProperty);
4437 // depart pos
4440 "The position at which the " + toString(currentTag) + " shall enter the net",
4441 "0");
4442 myTagProperties[currentTag].addAttribute(attrProperty);
4443 // arrival pos
4446 "Arrival position on the destination edge",
4447 "-1");
4448 myTagProperties[currentTag].addAttribute(attrProperty);
4449 // speed
4452 "speed of the container for this tranship in m/s",
4453 "1.39");
4454 myTagProperties[currentTag].addAttribute(attrProperty);
4455 }
4456}
4457
4458
4459void
4461 // declare empty GNEAttributeProperties
4462 GNEAttributeProperties attrProperty;
4463 // fill vehicle ACs
4465 {
4466 // set values of tag
4467 myTagProperties[currentTag] = GNETagProperties(currentTag,
4471
4472 // set values of attributes
4475 "The name of the edge the stop shall be located at");
4476 myTagProperties[currentTag].addAttribute(attrProperty);
4477
4480 "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
4481 myTagProperties[currentTag].addAttribute(attrProperty);
4482
4485 "If set, no error will be reported if element is placed behind the lane.\n"
4486 "Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,\n"
4487 "if the position was negative and larger than the lanes length after multiplication with - 1",
4488 "0");
4489 myTagProperties[currentTag].addAttribute(attrProperty);
4490
4493 "Minimum duration for stopping",
4494 "60");
4495 attrProperty.setDefaultActivated(true);
4496 myTagProperties[currentTag].addAttribute(attrProperty);
4497
4500 "The time step at which the route continues",
4501 "0.00");
4502 myTagProperties[currentTag].addAttribute(attrProperty);
4503
4506 "Activity displayed for stopped container in GUI and output files ");
4507 myTagProperties[currentTag].addAttribute(attrProperty);
4508 }
4510 {
4511 // set values of tag
4512 myTagProperties[currentTag] = GNETagProperties(currentTag,
4516
4517 // set values of attributes
4520 "ContainerStop associated with this stop");
4521 myTagProperties[currentTag].addAttribute(attrProperty);
4522
4525 "Minimum duration for stopping",
4526 "60");
4527 attrProperty.setDefaultActivated(true);
4528 myTagProperties[currentTag].addAttribute(attrProperty);
4529
4532 "The time step at which the route continues",
4533 "0.00");
4534 myTagProperties[currentTag].addAttribute(attrProperty);
4535
4538 "Activity displayed for stopped container in GUI and output files ");
4539 myTagProperties[currentTag].addAttribute(attrProperty);
4540 }
4541}
4542
4543
4544void
4546 // declare empty GNEAttributeProperties
4547 GNEAttributeProperties attrProperty;
4548 // fill person trips
4550 {
4551 // set values of tag
4552 myTagProperties[currentTag] = GNETagProperties(currentTag,
4556 // from edge
4559 "The name of the edge the " + toString(currentTag) + " starts at");
4560 myTagProperties[currentTag].addAttribute(attrProperty);
4561 // to edge
4562 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
4564 "The name of the edge the " + toString(currentTag) + " ends at");
4565 myTagProperties[currentTag].addAttribute(attrProperty);
4566 // arrival position
4569 "arrival position on the destination edge",
4570 "-1");
4571 myTagProperties[currentTag].addAttribute(attrProperty);
4572 // vTypes
4575 "List of possible vehicle types to take");
4576 myTagProperties[currentTag].addAttribute(attrProperty);
4577 // modes
4580 "List of possible traffic modes. Walking is always possible regardless of this value");
4581 myTagProperties[currentTag].addAttribute(attrProperty);
4582 // lines
4585 "list of vehicle alternatives to take for the " + toString(currentTag),
4586 "ANY");
4587 myTagProperties[currentTag].addAttribute(attrProperty);
4588 }
4589 currentTag = GNE_TAG_PERSONTRIP_BUSSTOP;
4590 {
4591 // set values of tag
4592 myTagProperties[currentTag] = GNETagProperties(currentTag,
4596 // from edge
4599 "The name of the edge the " + toString(currentTag) + " starts at");
4600 myTagProperties[currentTag].addAttribute(attrProperty);
4601 // to busStop
4604 "Id of the destination " + toString(SUMO_TAG_BUS_STOP));
4605 myTagProperties[currentTag].addAttribute(attrProperty);
4606 // vTypes
4609 "List of possible vehicle types to take");
4610 myTagProperties[currentTag].addAttribute(attrProperty);
4611 // modes
4614 "List of possible traffic modes. Walking is always possible regardless of this value");
4615 myTagProperties[currentTag].addAttribute(attrProperty);
4616 // lines
4619 "list of vehicle alternatives to take for the " + toString(currentTag),
4620 "ANY");
4621 myTagProperties[currentTag].addAttribute(attrProperty);
4622 }
4623 currentTag = GNE_TAG_PERSONTRIP_JUNCTIONS;
4624 {
4625 // set values of tag
4626 myTagProperties[currentTag] = GNETagProperties(currentTag,
4630 // from edge
4633 "The name of the junction the " + toString(currentTag) + " starts at");
4634 myTagProperties[currentTag].addAttribute(attrProperty);
4635 // to edge
4638 "The name of the junction the " + toString(currentTag) + " ends at");
4639 myTagProperties[currentTag].addAttribute(attrProperty);
4640 // vTypes
4643 "List of possible vehicle types to take");
4644 myTagProperties[currentTag].addAttribute(attrProperty);
4645 // modes
4648 "List of possible traffic modes. Walking is always possible regardless of this value");
4649 myTagProperties[currentTag].addAttribute(attrProperty);
4650 // lines
4653 "list of vehicle alternatives to take for the " + toString(currentTag),
4654 "ANY");
4655 myTagProperties[currentTag].addAttribute(attrProperty);
4656 }
4657}
4658
4659
4660void
4662 // declare empty GNEAttributeProperties
4663 GNEAttributeProperties attrProperty;
4664 // fill walks
4665 SumoXMLTag currentTag = GNE_TAG_WALK_EDGE;
4666 {
4667 // set values of tag
4668 myTagProperties[currentTag] = GNETagProperties(currentTag,
4671 GUIIcon::WALK_FROMTO, SUMO_TAG_WALK, { SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW }, FXRGBA(240, 255, 205, 255));
4672 // from edge
4675 "The name of the edge the " + toString(currentTag) + " starts at");
4676 myTagProperties[currentTag].addAttribute(attrProperty);
4677 // to edge
4678 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
4680 "The name of the edge the " + toString(currentTag) + " ends at");
4681 myTagProperties[currentTag].addAttribute(attrProperty);
4682 // arrival position
4685 "arrival position on the destination edge",
4686 "-1");
4687 myTagProperties[currentTag].addAttribute(attrProperty);
4688 }
4689 currentTag = GNE_TAG_WALK_BUSSTOP;
4690 {
4691 // set values of tag
4692 myTagProperties[currentTag] = GNETagProperties(currentTag,
4695 GUIIcon::WALK_BUSSTOP, SUMO_TAG_WALK, { SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW }, FXRGBA(240, 255, 205, 255));
4696 // from edge
4699 "The name of the edge the " + toString(currentTag) + " starts at");
4700 myTagProperties[currentTag].addAttribute(attrProperty);
4701 // to busStop
4704 "Id of the destination " + toString(SUMO_TAG_BUS_STOP));
4705 myTagProperties[currentTag].addAttribute(attrProperty);
4706 }
4707 currentTag = GNE_TAG_WALK_EDGES;
4708 {
4709 // set values of tag
4710 myTagProperties[currentTag] = GNETagProperties(currentTag,
4713 GUIIcon::WALK_EDGES, SUMO_TAG_WALK, {SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW}, FXRGBA(240, 255, 205, 255));
4714 // edges
4717 "id of the edges to walk");
4718 myTagProperties[currentTag].addAttribute(attrProperty);
4719 // arrival pos
4722 "Arrival position on the destination edge",
4723 "-1");
4724 myTagProperties[currentTag].addAttribute(attrProperty);
4725 }
4726 currentTag = GNE_TAG_WALK_ROUTE;
4727 {
4728 // set values of tag
4729 myTagProperties[currentTag] = GNETagProperties(currentTag,
4732 GUIIcon::WALK_ROUTE, SUMO_TAG_WALK, {SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW}, FXRGBA(240, 255, 205, 255));
4733 // route
4736 "The id of the route to walk");
4737 myTagProperties[currentTag].addAttribute(attrProperty);
4738 // arrival pos
4741 "Arrival position on the destination edge",
4742 "-1");
4743 myTagProperties[currentTag].addAttribute(attrProperty);
4744 }
4745
4746 currentTag = GNE_TAG_WALK_JUNCTIONS;
4747 {
4748 // set values of tag
4749 myTagProperties[currentTag] = GNETagProperties(currentTag,
4753 // from edge
4756 "The name of the junction the " + toString(currentTag) + " starts at");
4757 myTagProperties[currentTag].addAttribute(attrProperty);
4758 // to edge
4761 "The name of the junction the " + toString(currentTag) + " ends at");
4762 myTagProperties[currentTag].addAttribute(attrProperty);
4763 }
4764}
4765
4766
4767void
4769 // declare empty GNEAttributeProperties
4770 GNEAttributeProperties attrProperty;
4771 // fill rides
4772 SumoXMLTag currentTag = GNE_TAG_RIDE_EDGE;
4773 {
4774 // set values of tag
4775 myTagProperties[currentTag] = GNETagProperties(currentTag,
4778 GUIIcon::RIDE_BUSSTOP, SUMO_TAG_RIDE, { SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW }, FXRGBA(210, 233, 255, 255));
4779 // from edge
4782 "The name of the edge the " + toString(currentTag) + " starts at");
4783 myTagProperties[currentTag].addAttribute(attrProperty);
4784 // to edge
4785 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
4787 "The name of the edge the " + toString(currentTag) + " ends at");
4788 myTagProperties[currentTag].addAttribute(attrProperty);
4789 // arrival position
4792 "arrival position on the destination edge",
4793 "-1");
4794 myTagProperties[currentTag].addAttribute(attrProperty);
4795 // lines
4798 "list of vehicle alternatives to take for the " + toString(currentTag),
4799 "ANY");
4800 myTagProperties[currentTag].addAttribute(attrProperty);
4801 }
4802 currentTag = GNE_TAG_RIDE_BUSSTOP;
4803 {
4804 // set values of tag
4805 myTagProperties[currentTag] = GNETagProperties(currentTag,
4808 GUIIcon::RIDE_BUSSTOP, SUMO_TAG_RIDE, { SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW }, FXRGBA(210, 233, 255, 255));
4809 // from edge
4812 "The name of the edge the " + toString(currentTag) + " starts at");
4813 myTagProperties[currentTag].addAttribute(attrProperty);
4814 // to busStop
4817 "Id of the destination " + toString(SUMO_TAG_BUS_STOP));
4818 myTagProperties[currentTag].addAttribute(attrProperty);
4819 // lines
4822 "list of vehicle alternatives to take for the " + toString(currentTag),
4823 "ANY");
4824 myTagProperties[currentTag].addAttribute(attrProperty);
4825 }
4826}
4827
4828
4829void
4831 // declare empty GNEAttributeProperties
4832 GNEAttributeProperties attrProperty;
4833 // fill vehicle ACs
4835 {
4836 // set values of tag
4837 myTagProperties[currentTag] = GNETagProperties(currentTag,
4841
4842 // set values of attributes
4845 "The name of the edge the stop shall be located at");
4846 myTagProperties[currentTag].addAttribute(attrProperty);
4847
4850 "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
4851 myTagProperties[currentTag].addAttribute(attrProperty);
4852
4855 "If set, no error will be reported if element is placed behind the lane.\n"
4856 "Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,\n"
4857 "if the position was negative and larger than the lanes length after multiplication with - 1",
4858 "0");
4859 myTagProperties[currentTag].addAttribute(attrProperty);
4860
4863 "Minimum duration for stopping",
4864 "60");
4865 attrProperty.setDefaultActivated(true);
4866 myTagProperties[currentTag].addAttribute(attrProperty);
4867
4870 "The time step at which the route continues",
4871 "0.00");
4872 myTagProperties[currentTag].addAttribute(attrProperty);
4873
4876 "Activity displayed for stopped person in GUI and output files ");
4877 myTagProperties[currentTag].addAttribute(attrProperty);
4878 }
4879 currentTag = GNE_TAG_STOPPERSON_BUSSTOP;
4880 {
4881 // set values of tag
4882 myTagProperties[currentTag] = GNETagProperties(currentTag,
4886
4887 // set values of attributes
4890 "BusStop associated with this stop");
4891 myTagProperties[currentTag].addAttribute(attrProperty);
4892
4895 "Minimum duration for stopping",
4896 "60");
4897 attrProperty.setDefaultActivated(true);
4898 myTagProperties[currentTag].addAttribute(attrProperty);
4899
4902 "The time step at which the route continues",
4903 "0.00");
4904 myTagProperties[currentTag].addAttribute(attrProperty);
4905
4908 "Activity displayed for stopped person in GUI and output files ");
4909 myTagProperties[currentTag].addAttribute(attrProperty);
4910 }
4911}
4912
4913
4914void
4916 // declare empty GNEAttributeProperties
4917 GNEAttributeProperties attrProperty;
4920 "This " + toString(currentTag) + "'s color",
4921 "yellow");
4922 myTagProperties[currentTag].addAttribute(attrProperty);
4923
4926 "The lane on which the " + toString(currentTag) + " shall be inserted",
4927 "first");
4928 myTagProperties[currentTag].addAttribute(attrProperty);
4929
4932 "The position at which the " + toString(currentTag) + " shall enter the net",
4933 "base");
4934 myTagProperties[currentTag].addAttribute(attrProperty);
4935
4938 "The speed with which the " + toString(currentTag) + " shall enter the network",
4939 "0.00");
4940 myTagProperties[currentTag].addAttribute(attrProperty);
4941
4944 "The lane at which the " + toString(currentTag) + " shall leave the network",
4945 "current");
4946 myTagProperties[currentTag].addAttribute(attrProperty);
4947
4950 "The position at which the " + toString(currentTag) + " shall leave the network",
4951 "max");
4952 myTagProperties[currentTag].addAttribute(attrProperty);
4953
4956 "The speed with which the " + toString(currentTag) + " shall leave the network",
4957 "current");
4958 myTagProperties[currentTag].addAttribute(attrProperty);
4959
4962 "A string specifying the id of a public transport line which can be used when specifying person rides");
4963 myTagProperties[currentTag].addAttribute(attrProperty);
4964
4967 "The number of occupied seats when the " + toString(currentTag) + " is inserted",
4968 "0");
4969 myTagProperties[currentTag].addAttribute(attrProperty);
4970
4973 "The number of occupied container places when the " + toString(currentTag) + " is inserted",
4974 "0");
4975 myTagProperties[currentTag].addAttribute(attrProperty);
4976
4979 "The lateral position on the departure lane at which the " + toString(currentTag) + " shall enter the net",
4980 "center");
4981 myTagProperties[currentTag].addAttribute(attrProperty);
4982
4985 "The lateral position on the arrival lane at which the " + toString(currentTag) + " shall arrive",
4986 "center");
4987 myTagProperties[currentTag].addAttribute(attrProperty);
4988
4991 "Insertion checks",
4993 myTagProperties[currentTag].addAttribute(attrProperty);
4994}
4995
4996
4997void
4999 // declare empty GNEAttributeProperties
5000 GNEAttributeProperties attrProperty;
5001
5004 "First " + toString(currentTag) + " departure time",
5005 "0");
5006 myTagProperties[currentTag].addAttribute(attrProperty);
5007
5010 "End of departure interval",
5011 "3600");
5012 myTagProperties[currentTag].addAttribute(attrProperty);
5013
5016 "probability for emitting a " + toString(currentTag) + " each second\n"
5017 "(not together with vehsPerHour or period)",
5018 "1800");
5019 myTagProperties[currentTag].addAttribute(attrProperty);
5020
5021 attrProperty = GNEAttributeProperties(perHour,
5023 "Number of " + toString(currentTag) + "s per hour, equally spaced\n"
5024 "(not together with period or probability or poisson)",
5025 "1800");
5026 myTagProperties[currentTag].addAttribute(attrProperty);
5027
5030 "Insert equally spaced " + toString(currentTag) + "s at that period\n"
5031 "(not together with vehsPerHour or probability or poisson)",
5032 "2");
5033 myTagProperties[currentTag].addAttribute(attrProperty);
5034
5037 "probability for emitting a " + toString(currentTag) + " each second\n"
5038 "(not together with vehsPerHour or period or poisson)",
5039 "0.5");
5040 myTagProperties[currentTag].addAttribute(attrProperty);
5041
5044 "Insert " + toString(currentTag) + "s spaciated using a poisson distribution\n"
5045 "(not together with period or vehsPerHour or probability)",
5046 "2");
5047 myTagProperties[currentTag].addAttribute(attrProperty);
5048}
5049
5050
5051void
5053 // declare empty GNEAttributeProperties
5054 GNEAttributeProperties attrProperty;
5055
5058 "The acceleration ability of vehicles of this type [m/s^2]",
5059 "2.60");
5060 myTagProperties[currentTag].addAttribute(attrProperty);
5061
5064 "The deceleration ability of vehicles of this type [m/s^2]",
5065 "4.50");
5066 myTagProperties[currentTag].addAttribute(attrProperty);
5067
5070 "The apparent deceleration of the vehicle as used by the standard model [m/s^2]",
5071 "4.50");
5072 myTagProperties[currentTag].addAttribute(attrProperty);
5073
5076 "The maximal physically possible deceleration for the vehicle [m/s^2]",
5077 "4.50");
5078 myTagProperties[currentTag].addAttribute(attrProperty);
5079
5082 "Car-following model parameter",
5083 "0.50");
5084 attrProperty.setRange(0, 1);
5085 myTagProperties[currentTag].addAttribute(attrProperty);
5086
5089 "Car-following model parameter",
5090 "1.00");
5091 myTagProperties[currentTag].addAttribute(attrProperty);
5092
5095 "SKRAUSSX parameter 1",
5096 "");
5097 myTagProperties[currentTag].addAttribute(attrProperty);
5098
5101 "SKRAUSSX parameter 2",
5102 "");
5103 myTagProperties[currentTag].addAttribute(attrProperty);
5104
5107 "SKRAUSSX parameter 3",
5108 "");
5109 myTagProperties[currentTag].addAttribute(attrProperty);
5110
5113 "SKRAUSSX parameter 4",
5114 "");
5115 myTagProperties[currentTag].addAttribute(attrProperty);
5116
5119 "SKRAUSSX parameter 5",
5120 "");
5121 myTagProperties[currentTag].addAttribute(attrProperty);
5122
5125 "EIDM Look ahead / preview parameter [s]",
5126 "4.00");
5127 myTagProperties[currentTag].addAttribute(attrProperty);
5128
5131 "EIDM AP Reaction Time parameter [s]",
5132 "0.50");
5133 myTagProperties[currentTag].addAttribute(attrProperty);
5134
5137 "EIDM Wiener Process parameter for the Driving Error [s]",
5138 "3.00");
5139 myTagProperties[currentTag].addAttribute(attrProperty);
5140
5143 "EIDM Wiener Process parameter for the Estimation Error [s]",
5144 "10.00");
5145 myTagProperties[currentTag].addAttribute(attrProperty);
5146
5149 "EIDM Coolness parameter of the Enhanced IDM [-]",
5150 "0.99");
5151 attrProperty.setRange(0, 1);
5152 myTagProperties[currentTag].addAttribute(attrProperty);
5153
5156 "EIDM leader speed estimation error parameter [-]",
5157 "0.02");
5158 myTagProperties[currentTag].addAttribute(attrProperty);
5159
5162 "EIDM gap estimation error parameter [-]",
5163 "0.10");
5164 myTagProperties[currentTag].addAttribute(attrProperty);
5165
5168 "EIDM driving error parameter [-]",
5169 "0.04");
5170 myTagProperties[currentTag].addAttribute(attrProperty);
5171
5174 "EIDM maximal jerk parameter [m/s^3]",
5175 "3.00");
5176 myTagProperties[currentTag].addAttribute(attrProperty);
5177
5180 "EIDM maximal negative acceleration between two Action Points (threshold) [m/s^2]",
5181 "1.00");
5182 myTagProperties[currentTag].addAttribute(attrProperty);
5183
5186 "EIDM Time parameter untill vehicle reaches amax after startup/driveoff [s]",
5187 "1.20");
5188 myTagProperties[currentTag].addAttribute(attrProperty);
5189
5192 "EIDM Flatness parameter of startup/driveoff curve [-]",
5193 "2.00");
5194 myTagProperties[currentTag].addAttribute(attrProperty);
5195
5198 "EIDM Shift parameter of startup/driveoff curve [-]",
5199 "0.70");
5200 myTagProperties[currentTag].addAttribute(attrProperty);
5201
5204 "EIDM parameter if model shall include vehicle dynamics into the acceleration calculation [0/1]",
5205 "0");
5206 myTagProperties[currentTag].addAttribute(attrProperty);
5207
5210 "EIDM parameter how many vehicles are taken into the preview calculation of the driver (at least always 1!) [-]",
5211 "0");
5212 myTagProperties[currentTag].addAttribute(attrProperty);
5213
5216 "Peter Wagner 2009 parameter",
5217 "");
5218 myTagProperties[currentTag].addAttribute(attrProperty);
5219
5222 "Peter Wagner 2009 parameter",
5223 "");
5224 myTagProperties[currentTag].addAttribute(attrProperty);
5225
5228 "IDMM parameter",
5229 "");
5230 myTagProperties[currentTag].addAttribute(attrProperty);
5231
5234 "IDMM parameter",
5235 "");
5236 myTagProperties[currentTag].addAttribute(attrProperty);
5237
5240 "Wiedemann parameter",
5241 "");
5242 myTagProperties[currentTag].addAttribute(attrProperty);
5243
5246 "Wiedemann parameter",
5247 "");
5248 myTagProperties[currentTag].addAttribute(attrProperty);
5249
5252 "MinGap factor parameter",
5253 "");
5254 myTagProperties[currentTag].addAttribute(attrProperty);
5255
5256 attrProperty = GNEAttributeProperties(SUMO_ATTR_K,
5258 "K parameter",
5259 "");
5260 myTagProperties[currentTag].addAttribute(attrProperty);
5261
5262
5265 "Kerner Phi parameter",
5266 "");
5267 myTagProperties[currentTag].addAttribute(attrProperty);
5268
5271 "IDM Delta parameter",
5272 "");
5273 myTagProperties[currentTag].addAttribute(attrProperty);
5274
5277 "IDM Stepping parameter",
5278 "");
5279 myTagProperties[currentTag].addAttribute(attrProperty);
5280
5283 "Train Types",
5284 "NGT400");
5285 attrProperty.setDiscreteValues(SUMOXMLDefinitions::TrainTypes.getStrings());
5286 myTagProperties[currentTag].addAttribute(attrProperty);
5287}
5288
5289
5290void
5292 // declare empty GNEAttributeProperties
5293 GNEAttributeProperties attrProperty;
5296 "Minimum distance to pedestrians that are walking towards the conflict point with the ego vehicle.",
5297 "10");
5298 myTagProperties[currentTag].addAttribute(attrProperty);
5299
5302 "The accumulated waiting time after which a vehicle will drive onto an intersection even though this might cause jamming.",
5303 "-1");
5304 myTagProperties[currentTag].addAttribute(attrProperty);
5305
5308 "This value causes vehicles to violate a yellow light if the duration of the yellow phase is lower than the given threshold.",
5309 "-1");
5310 myTagProperties[currentTag].addAttribute(attrProperty);
5311
5314 "This value causes vehicles to violate a red light if the duration of the red phase is lower than the given threshold.",
5315 "-1");
5316 myTagProperties[currentTag].addAttribute(attrProperty);
5317
5320 "This value causes vehicles affected by jmDriveAfterRedTime to slow down when violating a red light.",
5321 "0.0");
5322 myTagProperties[currentTag].addAttribute(attrProperty);
5323
5326 "This value causes vehicles to ignore foe vehicles that have right-of-way with the given probability.",
5327 "0.0");
5328 myTagProperties[currentTag].addAttribute(attrProperty);
5329
5332 "This value is used in conjunction with jmIgnoreFoeProb.\n"
5333 "Only vehicles with a speed below or equal to the given value may be ignored.",
5334 "0.0");
5335 myTagProperties[currentTag].addAttribute(attrProperty);
5336
5339 "This value configures driving imperfection (dawdling) while passing a minor link.",
5340 "0.0");
5341 myTagProperties[currentTag].addAttribute(attrProperty);
5342
5345 "This value defines the minimum time gap when passing ahead of a prioritized vehicle. ",
5346 "1");
5347 myTagProperties[currentTag].addAttribute(attrProperty);
5348
5351 "Willingess of drivers to impede vehicles with higher priority",
5352 "0.0");
5353 myTagProperties[currentTag].addAttribute(attrProperty);
5354}
5355
5356
5357void
5359 // declare empty GNEAttributeProperties
5360 GNEAttributeProperties attrProperty;
5361
5364 "The eagerness for performing strategic lane changing. Higher values result in earlier lane-changing.",
5365 "1.0");
5366 myTagProperties[currentTag].addAttribute(attrProperty);
5367
5370 "The willingness for performing cooperative lane changing. Lower values result in reduced cooperation.",
5371 "1.0");
5372 myTagProperties[currentTag].addAttribute(attrProperty);
5373
5376 "The eagerness for performing lane changing to gain speed. Higher values result in more lane-changing.",
5377 "1.0");
5378 myTagProperties[currentTag].addAttribute(attrProperty);
5379
5382 "The eagerness for following the obligation to keep right. Higher values result in earlier lane-changing.",
5383 "1.0");
5384 myTagProperties[currentTag].addAttribute(attrProperty);
5385
5388 "The eagerness for using the configured lateral alignment within the lane.\n"
5389 "Higher values result in increased willingness to sacrifice speed for alignment.",
5390 "1.0");
5391 myTagProperties[currentTag].addAttribute(attrProperty);
5392
5395 "The eagerness for overtaking through the opposite-direction lane. Higher values result in more lane-changing.",
5396 "1.0");
5397 myTagProperties[currentTag].addAttribute(attrProperty);
5398
5401 "Willingness to encroach laterally on other drivers.",
5402 "0.00");
5403 myTagProperties[currentTag].addAttribute(attrProperty);
5404
5407 "Minimum lateral gap when encroaching laterally on other drives (alternative way to define lcPushy)",
5408 "0.00");
5409 myTagProperties[currentTag].addAttribute(attrProperty);
5410
5413 "Willingness to accept lower front and rear gaps on the target lane.",
5414 "1.0");
5415 myTagProperties[currentTag].addAttribute(attrProperty);
5416
5419 "Dynamic factor for modifying lcAssertive and lcPushy.",
5420 "0.00");
5421 myTagProperties[currentTag].addAttribute(attrProperty);
5422
5425 "Time to reach maximum impatience (of 1). Impatience grows whenever a lane-change manoeuvre is blocked.",
5426 "infinity");
5427 myTagProperties[currentTag].addAttribute(attrProperty);
5428
5431 "Maximum lateral acceleration per second.",
5432 "1.0");
5433 myTagProperties[currentTag].addAttribute(attrProperty);
5434
5437 "Factor for configuring the strategic lookahead distance when a change to the left is necessary (relative to right lookahead).",
5438 "2.0");
5439 myTagProperties[currentTag].addAttribute(attrProperty);
5440
5443 "Factor for configuring the treshold asymmetry when changing to the left or to the right for speed gain.",
5444 "0.1");
5445 myTagProperties[currentTag].addAttribute(attrProperty);
5446
5449 "Upper bound on lateral speed when standing.",
5450 "0.00");
5451 myTagProperties[currentTag].addAttribute(attrProperty);
5452
5455 "Upper bound on lateral speed while moving computed as lcMaxSpeedLatStanding + lcMaxSpeedLatFactor * getSpeed()",
5456 "1.00");
5457 myTagProperties[currentTag].addAttribute(attrProperty);
5458
5461 "Distance to an upcoming turn on the vehicles route, below which the alignment\n"
5462 "should be dynamically adapted to match the turn direction.",
5463 "0.00");
5464 myTagProperties[currentTag].addAttribute(attrProperty);
5465
5468 "The probability for violating rules gainst overtaking on the right.",
5469 "0.00");
5470 myTagProperties[currentTag].addAttribute(attrProperty);
5471
5474 "Time threshold for the willingness to change right.",
5475 "-1");
5476 myTagProperties[currentTag].addAttribute(attrProperty);
5477
5480 "Speed difference factor for the eagerness of overtaking a neighbor vehicle before changing lanes (threshold = factor*speedlimit).",
5481 "0.00");
5482 attrProperty.setRange(-1, 1);
5483 myTagProperties[currentTag].addAttribute(attrProperty);
5484
5485 /*
5486 attrProperty = GNEAttributeProperties(SUMO_ATTR_LCA_EXPERIMENTAL1,
5487 GNEAttributeProperties::FLOAT | GNEAttributeProperties::POSITIVE | GNEAttributeProperties::DEFAULTVALUE | GNEAttributeProperties::EXTENDED,
5488 "XXXXX",
5489 "0.00");
5490 myTagProperties[currentTag].addAttribute(attrProperty);
5491 */
5492}
5493
5494
5495void
5497 // declare empty GNEAttributeProperties
5498 GNEAttributeProperties attrProperty;
5499
5500 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
5502 "The name of the " + toString(currentTag));
5503 myTagProperties[currentTag].addAttribute(attrProperty);
5504
5507 "The id of the " + toString(currentTag) + " type to use for this " + toString(currentTag),
5509 myTagProperties[currentTag].addAttribute(attrProperty);
5510
5513 "This " + toString(currentTag) + "'s color",
5514 "yellow");
5515 myTagProperties[currentTag].addAttribute(attrProperty);
5516
5519 "The position at which the " + toString(currentTag) + " shall enter the net",
5520 "base");
5521 myTagProperties[currentTag].addAttribute(attrProperty);
5522}
5523
5524
5525void
5527 // declare empty GNEAttributeProperties
5528 GNEAttributeProperties attrProperty;
5529
5530 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
5532 "The name of the " + toString(currentTag));
5533 myTagProperties[currentTag].addAttribute(attrProperty);
5534
5537 "The id of the " + toString(currentTag) + " type to use for this " + toString(currentTag),
5539 myTagProperties[currentTag].addAttribute(attrProperty);
5540
5543 "This " + toString(currentTag) + "'s color",
5544 "yellow");
5545 myTagProperties[currentTag].addAttribute(attrProperty);
5546}
5547
5548
5549void
5551 // declare empty GNEAttributeProperties
5552 GNEAttributeProperties attrProperty;
5553
5556 "Minimum duration for stopping",
5557 "60");
5558 attrProperty.setDefaultActivated(true);
5559 myTagProperties[currentTag].addAttribute(attrProperty);
5560
5563 "The time step at which the route continues",
5564 "0.00");
5565 myTagProperties[currentTag].addAttribute(attrProperty);
5566
5569 "If set to a non-negative time value, then the stop duration can be extended at most by the extension value in seconds",
5570 "0");
5571 myTagProperties[currentTag].addAttribute(attrProperty);
5572
5575 "Whether a person or container or bth may end the stop",
5576 "false");
5577 attrProperty.setDiscreteValues({"false", "person", "container", "join"});
5578 myTagProperties[currentTag].addAttribute(attrProperty);
5579
5582 "List of elements that must board the vehicle before it may continue");
5583 myTagProperties[currentTag].addAttribute(attrProperty);
5584
5587 "List of elements that can board the vehicle before it may continue");
5588 myTagProperties[currentTag].addAttribute(attrProperty);
5589
5592 "Whether the vehicle stops on the road or beside",
5593 "false");
5594 attrProperty.setDiscreteValues({"true", "false", "opportunistic"});
5595 myTagProperties[currentTag].addAttribute(attrProperty);
5596
5599 "Activity displayed for stopped person in GUI and output files");
5600 myTagProperties[currentTag].addAttribute(attrProperty);
5601
5604 "Parameter to be applied to the vehicle to track the trip id within a cyclical public transport route");
5605 myTagProperties[currentTag].addAttribute(attrProperty);
5606
5609 "New line attribute to be set on the vehicle when reaching this stop (for cyclical public transport route)");
5610 myTagProperties[currentTag].addAttribute(attrProperty);
5611
5612 if (waypoint) {
5615 "Speed to be kept while driving between startPos and endPos",
5616 "0.00");
5617 myTagProperties[currentTag].addAttribute(attrProperty);
5618 } else {
5621 "Whether the stop may be skipped if no passengers wants to embark or disembark",
5622 "false");
5623 myTagProperties[currentTag].addAttribute(attrProperty);
5624 }
5625}
5626
5627
5628void
5630 // declare empty GNEAttributeProperties
5631 GNEAttributeProperties attrProperty;
5632 // fill data set element
5633 SumoXMLTag currentTag = SUMO_TAG_DATASET;
5634 {
5635 // set values of tag
5636 myTagProperties[currentTag] = GNETagProperties(currentTag,
5639 GUIIcon::DATASET, currentTag);
5640
5641 // set values of attributes
5642 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
5644 "Data set ID");
5645 myTagProperties[currentTag].addAttribute(attrProperty);
5646
5647 }
5648 // fill data interval element
5649 currentTag = SUMO_TAG_DATAINTERVAL;
5650 {
5651 // set values of tag
5652 myTagProperties[currentTag] = GNETagProperties(currentTag,
5656
5657 // set values of attributes
5658 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
5660 "Interval ID");
5661 myTagProperties[currentTag].addAttribute(attrProperty);
5662
5663 // set values of attributes
5666 "First " + toString(currentTag) + " departure time",
5667 "0");
5668 myTagProperties[currentTag].addAttribute(attrProperty);
5669
5672 "End of departure interval",
5673 "3600");
5674 myTagProperties[currentTag].addAttribute(attrProperty);
5675 }
5676 // fill edge data element
5677 currentTag = SUMO_TAG_MEANDATA_EDGE;
5678 {
5679 // set values of tag
5680 myTagProperties[currentTag] = GNETagProperties(currentTag,
5684
5685 // set values of attributes
5686 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
5688 "edge ID");
5689 myTagProperties[currentTag].addAttribute(attrProperty);
5690 }
5691 currentTag = SUMO_TAG_EDGEREL;
5692 {
5693 // set values of tag
5694 myTagProperties[currentTag] = GNETagProperties(currentTag,
5698
5699 // set values of attributes
5702 "The name of the edge the " + toString(currentTag) + " starts at");
5703 myTagProperties[currentTag].addAttribute(attrProperty);
5704
5705 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
5707 "The name of the edge the " + toString(currentTag) + " ends at");
5708 myTagProperties[currentTag].addAttribute(attrProperty);
5709 }
5710 currentTag = SUMO_TAG_TAZREL;
5711 {
5712 // set values of tag
5713 myTagProperties[currentTag] = GNETagProperties(currentTag,
5717
5718 // set values of attributes
5721 "The name of the TAZ the " + toString(currentTag) + " starts at");
5722 myTagProperties[currentTag].addAttribute(attrProperty);
5723
5724 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
5726 "The name of the TAZ the " + toString(currentTag) + " ends at");
5727 myTagProperties[currentTag].addAttribute(attrProperty);
5728 }
5729}
5730
5731/****************************************************************************/
long long int SUMOTime
Definition: GUI.h:36
GUISelectedStorage gSelected
A global holder of selected objects.
@ VCLASS_SMALL_TRUCK
@ VCLASS_SMALL_EMERGENCY
@ PARKINGSPACE
@ PERSONTRIP_JUNCTIONS
@ VCLASS_SMALL_COACH
@ CONTAINERFLOW
@ PERSONTRIP_BUSSTOP
@ VCLASS_SMALL_TAXI
@ VCLASS_SMALL_CUSTOM1
@ CLOSINGREROUTE
@ CONTAINERSTOP
@ VCLASS_SMALL_PASSENGER
@ TRANSPORT_CONTAINERSTOP
@ VCLASS_SMALL_RAIL_FAST
@ TRANSHIP_EDGES
@ WALK_JUNCTIONS
@ VCLASS_SMALL_ARMY
@ VCLASS_SMALL_RAIL_URBAN
@ VCLASS_SMALL_BUS
@ TRIP_JUNCTIONS
@ VCLASS_SMALL_AUTHORITY
@ DATAINTERVAL
@ FLOW_JUNCTIONS
@ VCLASS_SMALL_CUSTOM2
@ ROUTEPROBREROUTE
@ VCLASS_SMALL_VIP
@ TRACTION_SUBSTATION
@ VCLASS_SMALL_MOPED
@ CHARGINGSTATION
@ WALK_BUSSTOP
@ TRANSHIP_CONTAINERSTOP
@ VCLASS_SMALL_PRIVATE
@ PARKINGZONEREROUTE
@ CLOSINGLANEREROUTE
@ RIDE_BUSSTOP
@ VCLASS_SMALL_EVEHICLE
@ VCLASS_SMALL_SHIP
@ DESTPROBREROUTE
@ VCLASS_SMALL_BICYCLE
@ VCLASS_SMALL_RAIL
@ PERSONTRIP_FROMTO
@ REROUTERINTERVAL
@ VTYPEDISTRIBUTION
@ VCLASS_SMALL_TRAM
@ VARIABLESPEEDSIGN
@ VCLASS_SMALL_IGNORING
@ VCLASS_SMALL_DELIVERY
@ VCLASS_SMALL_HOV
@ VCLASS_SMALL_RAIL_ELECTRIC
@ OVERHEADWIRE
@ VCLASS_SMALL_MOTORCYCLE
@ OVERHEADWIRE_CLAMP
@ VCLASS_SMALL_TRAILER
@ VCLASS_SMALL_PEDESTRIAN
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition: SUMOTime.cpp:45
StringBijection< SUMOVehicleShape > SumoVehicleShapeStrings(sumoVehicleShapeStringInitializer, SUMOVehicleShape::UNKNOWN, false)
StringBijection< SUMOVehicleClass > SumoVehicleClassStrings(sumoVehicleClassStringInitializer, SVC_CUSTOM2, false)
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
@ SVC_SHIP
is an arbitrary ship
@ SVC_PRIVATE
private vehicles
@ SVC_VIP
vip vehicles
@ SVC_HOV
vehicle is a HOV
@ SVC_TRUCK
vehicle is a large transport vehicle
@ SVC_IGNORING
vehicles ignoring classes
@ SVC_CUSTOM2
is a user-defined type
@ SVC_RAIL
vehicle is a not electrified rail
@ SVC_COACH
vehicle is a coach
@ SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
@ SVC_BICYCLE
vehicle is a bicycle
@ SVC_RAIL_FAST
vehicle that is allowed to drive on high-speed rail tracks
@ SVC_TRAILER
vehicle is a large transport vehicle
@ SVC_CUSTOM1
is a user-defined type
@ SVC_ARMY
army vehicles
@ SVC_RAIL_ELECTRIC
rail vehicle that requires electrified tracks
@ SVC_DELIVERY
vehicle is a small delivery vehicle
@ SVC_RAIL_URBAN
vehicle is a city rail
@ SVC_MOTORCYCLE
vehicle is a motorcycle
@ SVC_EMERGENCY
public emergency vehicles
@ SVC_MOPED
vehicle is a moped
@ SVC_AUTHORITY
authorities vehicles
@ SVC_TRAM
vehicle is a light rail
@ SVC_TAXI
vehicle is a taxi
@ SVC_BUS
vehicle is a bus
@ SVC_E_VEHICLE
is an electric vehicle
@ SVC_PEDESTRIAN
pedestrian
const double DEFAULT_VEH_PROB
SUMOVehicleShape
Definition of vehicle classes to differ between different appearances.
@ UNKNOWN
not defined
const std::string DEFAULT_VTYPE_ID
const std::string DEFAULT_CONTAINERTYPE_ID
SumoXMLTag
Numbers representing SUMO-XML - element names.
@ GNE_TAG_TRIP_JUNCTIONS
a trip between junctions (used in NETEDIT)
@ SUMO_TAG_TRACTION_SUBSTATION
A traction substation.
@ SUMO_TAG_INTERVAL
an aggreagated-output interval
@ SUMO_TAG_CLOSING_REROUTE
reroute of type closing
@ SUMO_TAG_STOP_CONTAINERSTOP
stop placed over a containerStop (used in netedit)
@ GNE_TAG_PERSONTRIP_JUNCTIONS
@ SUMO_TAG_REROUTER
A rerouter.
@ SUMO_TAG_EDGEREL
a relation between two edges
@ GNE_TAG_WAYPOINT_PARKINGAREA
waypoint placed over a parking area (used in netedit)
@ SUMO_TAG_DATAINTERVAL
@ GNE_TAG_MULTI_LANE_AREA_DETECTOR
an e2 detector over multiple lanes (placed here due create Additional Frame)
@ SUMO_TAG_ROUTEPROBE
a routeprobe detector
@ GNE_TAG_TRANSPORT_CONTAINERSTOP
@ SUMO_TAG_TAZ
a traffic assignment zone
@ SUMO_TAG_CHARGING_STATION
A Charging Station.
@ SUMO_TAG_VTYPE
description of a vehicle/person/container type
@ SUMO_TAG_ACCESS
An access point for a train stop.
@ SUMO_TAG_WALK
@ GNE_TAG_PERSONTRIP_BUSSTOP
@ SUMO_TAG_TRANSHIP
@ GNE_TAG_WALK_EDGES
@ SUMO_TAG_CONTAINER_STOP
A container stop.
@ SUMO_TAG_CONTAINERFLOW
@ SUMO_TAG_PARKING_AREA_REROUTE
entry for an alternative parking zone
@ SUMO_TAG_STOP_CHARGINGSTATION
stop placed over a charging station (used in netedit)
@ SUMO_TAG_TAZSINK
a sink within a district (connection road)
@ SUMO_TAG_STOP_LANE
stop placed over a lane (used in netedit)
@ GNE_TAG_WAYPOINT_CONTAINERSTOP
waypoint placed over a containerStop (used in netedit)
@ GNE_TAG_STOPCONTAINER_EDGE
@ GNE_TAG_WAYPOINT_BUSSTOP
waypoint placed over a busStop (used in netedit)
@ SUMO_TAG_BUS_STOP
A bus stop.
@ SUMO_TAG_POI
begin/end of the description of a Point of interest
@ GNE_TAG_WAYPOINT_CHARGINGSTATION
waypoint placed over a charging station (used in netedit)
@ GNE_TAG_STOPPERSON_BUSSTOP
@ GNE_TAG_INTERNAL_LANE
@ SUMO_TAG_STOP
stop for vehicles
@ SUMO_TAG_STEP
trigger: a step description
@ SUMO_TAG_VEHICLE
description of a vehicle
@ GNE_TAG_FLOW_ROUTE
a flow definition using a route instead of a from-to edges route (used in NETEDIT)
@ SUMO_TAG_OVERHEAD_WIRE_CLAMP
An overhead wire clamp (connection of wires in opposite directions)
@ GNE_TAG_VSS_SYMBOL
VSS Symbol.
@ GNE_TAG_FLOW_JUNCTIONS
a flow between junctions (used in NETEDIT)
@ GNE_TAG_POIGEO
Point of interest over view with GEO attributes.
@ GNE_TAG_TRANSHIP_EDGES
@ SUMO_TAG_LANETYPE
lane type
@ GNE_TAG_STOPCONTAINER_CONTAINERSTOP
@ GNE_TAG_FLOW_WITHROUTE
description of a vehicle with an embedded route (used in NETEDIT)
@ SUMO_TAG_FLOW
a flow definitio nusing a from-to edges instead of a route (used by router)
@ SUMO_TAG_CONNECTION
connectio between two lanes
@ SUMO_TAG_PARKING_AREA
A parking area.
@ SUMO_TAG_TRANSPORT
@ SUMO_TAG_WALKINGAREA
walking area for pedestrians
@ SUMO_TAG_ROUTE_PROB_REROUTE
probability of route of a reroute
@ GNE_TAG_CALIBRATOR_LANE
A calibrator placed over lane.
@ SUMO_TAG_DET_ENTRY
an e3 entry point
@ SUMO_TAG_PARKING_SPACE
A parking space for a single vehicle within a parking area.
@ SUMO_TAG_CONTAINER
@ SUMO_TAG_JUNCTION
begin/end of the description of a junction
@ SUMO_TAG_CROSSING
crossing between edges for pedestrians
@ GNE_TAG_WALK_BUSSTOP
@ SUMO_TAG_ROUTE
begin/end of the description of a route
@ SUMO_TAG_MEANDATA_EDGE
an edge based mean data detector
@ SUMO_TAG_POLY
begin/end of the description of a polygon
@ SUMO_TAG_RIDE
@ SUMO_TAG_OVERHEAD_WIRE_SECTION
An overhead wire section.
@ SUMO_TAG_TRAIN_STOP
A train stop (alias for bus stop)
@ GNE_TAG_RIDE_EDGE
@ SUMO_TAG_STOP_BUSSTOP
stop placed over a busStop (used in netedit)
@ SUMO_TAG_VTYPE_DISTRIBUTION
distribution of a vehicle type
@ SUMO_TAG_LANE
begin/end of the description of a single lane
@ GNE_TAG_TRANSHIP_EDGE
@ SUMO_TAG_INSTANT_INDUCTION_LOOP
An instantenous induction loop.
@ GNE_TAG_WALK_JUNCTIONS
@ GNE_TAG_VEHICLE_WITHROUTE
description of a vehicle with an embedded route (used in NETEDIT)
@ GNE_TAG_CALIBRATOR_FLOW
a flow definition within in Calibrator
@ SUMO_TAG_DEST_PROB_REROUTE
probability of destiny of a reroute
@ GNE_TAG_POILANE
Point of interest over Lane.
@ SUMO_TAG_DATASET
@ GNE_TAG_WAYPOINT_LANE
waypoint placed over a lane (used in netedit)
@ SUMO_TAG_PERSON
@ SUMO_TAG_DET_EXIT
an e3 exit point
@ SUMO_TAG_PERSONTRIP
@ SUMO_TAG_TYPE
type (edge)
@ SUMO_TAG_VAPORIZER
vaporizer of vehicles
@ SUMO_TAG_LANE_AREA_DETECTOR
alternative tag for e2 detector
@ GNE_TAG_REROUTER_SYMBOL
Rerouter Symbol.
@ SUMO_TAG_STOP_PARKINGAREA
stop placed over a parking area (used in netedit)
@ SUMO_TAG_TAZREL
a relation between two TAZs
@ GNE_TAG_WALK_EDGE
@ SUMO_TAG_TAZSOURCE
a source within a district (connection road)
@ SUMO_TAG_CLOSING_LANE_REROUTE
lane of a reroute of type closing
@ GNE_TAG_PERSONTRIP_EDGE
@ GNE_TAG_ROUTE_EMBEDDED
embedded route (used in NETEDIT)
@ SUMO_TAG_INDUCTION_LOOP
alternative tag for e1 detector
@ GNE_TAG_RIDE_BUSSTOP
@ SUMO_TAG_CALIBRATOR
A calibrator placed over edge.
@ SUMO_TAG_ENTRY_EXIT_DETECTOR
alternative tag for e3 detector
@ SUMO_TAG_VSS
A variable speed sign.
@ GNE_TAG_STOPPERSON_EDGE
@ GNE_TAG_WALK_ROUTE
@ SUMO_TAG_PERSONFLOW
@ SUMO_TAG_TRIP
a single trip definition (used by router)
@ GNE_TAG_TRANSHIP_CONTAINERSTOP
@ SUMO_TAG_EDGE
begin/end of the description of an edge
@ GNE_TAG_TRANSPORT_EDGE
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
@ SUMO_ATTR_TMP4
@ SUMO_ATTR_CF_EIDM_T_ACC_MAX
@ SUMO_ATTR_STARTPOS
@ SUMO_ATTR_CF_EIDM_EPSILON_ACC
@ SUMO_ATTR_PARKING
@ SUMO_ATTR_EXTENSION
@ SUMO_ATTR_LCA_PUSHY
@ SUMO_ATTR_DISALLOW
@ SUMO_ATTR_LINES
@ SUMO_ATTR_NUMBER
@ SUMO_ATTR_ALLOW
@ SUMO_ATTR_ARRIVALSPEED
@ SUMO_ATTR_LANE
@ SUMO_ATTR_EMISSIONCLASS
@ SUMO_ATTR_JM_IGNORE_FOE_SPEED
@ SUMO_ATTR_ARRIVALLANE
@ SUMO_ATTR_DEPART
@ SUMO_ATTR_DEPARTEDGE
@ SUMO_ATTR_TLLINKINDEX2
link: the index of the opposite direction link of a pedestrian crossing
@ SUMO_ATTR_LON
@ GNE_ATTR_TO_CONTAINERSTOP
to busStop (used by containerPlans)
@ SUMO_ATTR_VEHSPERHOUR
@ SUMO_ATTR_ARRIVALEDGE
@ SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME
@ SUMO_ATTR_SPEED
@ GNE_ATTR_STOPOFFSET
stop offset (virtual, used by edge and lanes)
@ SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD
@ SUMO_ATTR_VIA
@ SUMO_ATTR_CF_WIEDEMANN_SECURITY
@ SUMO_ATTR_LCA_ASSERTIVE
@ SUMO_ATTR_RADIUS
The turning radius at an intersection in m.
@ SUMO_ATTR_TRAIN_TYPE
@ SUMO_ATTR_FILE
@ SUMO_ATTR_INDIRECT
Whether this connection is an indirect (left) turn.
@ SUMO_ATTR_CONTAINER_STOP
@ SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS
@ SUMO_ATTR_PARKING_AREA
@ GNE_ATTR_OPPOSITE
neighboring lane, simplified lane attr instead of child element
@ SUMO_ATTR_CF_IDMM_ADAPT_TIME
@ SUMO_ATTR_SUBSTATIONID
id of a traction substation substation
@ SUMO_ATTR_FROM_LANE
@ SUMO_ATTR_LANE_CHANGE_MODEL
@ SUMO_ATTR_CF_KERNER_PHI
@ SUMO_ATTR_EDGE
@ SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE
@ SUMO_ATTR_FROMJUNCTION
@ SUMO_ATTR_JAM_DIST_THRESHOLD
@ SUMO_ATTR_DEPARTPOS_LAT
@ SUMO_ATTR_PARKING_LENGTH
@ SUMO_ATTR_BUS_STOP
@ SUMO_ATTR_CF_EIDM_C_COOLNESS
@ SUMO_ATTR_CF_EIDM_SIG_ERROR
@ SUMO_ATTR_LCA_PUSHYGAP
@ SUMO_ATTR_ENDPOS
@ SUMO_ATTR_LCA_LOOKAHEADLEFT
@ SUMO_ATTR_APPARENTDECEL
@ SUMO_ATTR_VOLTAGE
voltage of the traction substation [V]
@ SUMO_ATTR_MAXSPEED_LAT
@ SUMO_ATTR_LCA_SPEEDGAIN_PARAM
@ SUMO_ATTR_ARRIVALPOS
@ SUMO_ATTR_TMP3
@ SUMO_ATTR_ACTTYPE
@ SUMO_ATTR_ACTIONSTEPLENGTH
@ SUMO_ATTR_TLLAYOUT
node: the layout of the traffic light program
@ SUMO_ATTR_CUSTOMSHAPE
whether a given shape is user-defined
@ SUMO_ATTR_LCA_IMPATIENCE
@ SUMO_ATTR_BEGIN
weights: time range begin
@ SUMO_ATTR_MINGAP
@ GNE_ATTR_VTYPE_DISTRIBUTION
vehicle type distribution
@ SUMO_ATTR_EDGES
the edges of a route
@ GNE_ATTR_POISSON
poisson definition (used in flow)
@ SUMO_ATTR_OFF
@ SUMO_ATTR_ROUTEPROBE
@ SUMO_ATTR_LINEWIDTH
@ GNE_ATTR_PARAMETERS
parameters "key1=value1|key2=value2|...|keyN=valueN"
@ SUMO_ATTR_POSITION_LAT
@ SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME
@ SUMO_ATTR_FRINGE
Fringe type of node.
@ SUMO_ATTR_OVERHEAD_WIRE_FORBIDDEN
forbidden lanes for overhead wire segment
@ SUMO_ATTR_CONTAINER_NUMBER
@ SUMO_ATTR_EXPECTED
@ SUMO_ATTR_HALTING_TIME_THRESHOLD
@ SUMO_ATTR_TMP2
@ SUMO_ATTR_PRIORITY
@ SUMO_ATTR_LINE
@ SUMO_ATTR_CHARGING_STATION
@ SUMO_ATTR_LOADING_DURATION
@ SUMO_ATTR_CF_IDM_DELTA
@ SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW
@ GNE_ATTR_STOPOEXCEPTION
stop exceptions (virtual, used by edge and lanes)
@ SUMO_ATTR_LCA_MAXSPEEDLATFACTOR
@ SUMO_ATTR_CONTAINERSPERHOUR
@ SUMO_ATTR_NUMLANES
@ SUMO_ATTR_LANES
@ SUMO_ATTR_CF_EIDM_T_REACTION
@ SUMO_ATTR_MODES
@ SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE
@ SUMO_ATTR_VTYPES
@ SUMO_ATTR_CF_PWAGNER2009_TAULAST
@ SUMO_ATTR_OVERHEAD_WIRECLAMP_END
id of the overhead wire, to the end of which the overhead wire clamp is connected
@ SUMO_ATTR_SHAPE
edge: the shape in xml-definition
@ SUMO_ATTR_DEPARTPOS
@ 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_WEIGHT
@ SUMO_ATTR_GUISHAPE
@ SUMO_ATTR_DESIRED_MAXSPEED
@ SUMO_ATTR_JM_IGNORE_FOE_PROB
@ GNE_ATTR_TO_BUSSTOP
to busStop (used by personPlans)
@ SUMO_ATTR_TLTYPE
node: the type of traffic light
@ SUMO_ATTR_OVERHEAD_WIRECLAMP_LANESTART
id of the overhead wire lane, to the start of which the overhead wire clamp is connected
@ SUMO_ATTR_CHARGEINTRANSIT
Allow/disallow charge in transit in Charging Stations.
@ SUMO_ATTR_OVERHEAD_WIRECLAMP_START
id of the overhead wire, to the start of which the overhead wire clamp is connected
@ SUMO_ATTR_ONDEMAND
@ SUMO_ATTR_CHANGE_LEFT
@ SUMO_ATTR_CONTAINER_CAPACITY
@ SUMO_ATTR_INDEX
@ SUMO_ATTR_FILL
Fill the polygon.
@ SUMO_ATTR_NAME
@ SUMO_ATTR_PERIOD
@ SUMO_ATTR_LAYER
A layer number.
@ SUMO_ATTR_LCA_COOPERATIVE_PARAM
@ SUMO_ATTR_SPREADTYPE
The information about how to spread the lanes from the given position.
@ SUMO_ATTR_LCA_OPPOSITE_PARAM
@ SUMO_ATTR_SLOPE
@ SUMO_ATTR_HALTING_SPEED_THRESHOLD
@ SUMO_ATTR_CENTER
@ SUMO_ATTR_PASS
@ SUMO_ATTR_DEPARTSPEED
@ SUMO_ATTR_ANGLE
@ SUMO_ATTR_ENDOFFSET
@ SUMO_ATTR_MINGAP_LAT
@ SUMO_ATTR_TRIP_ID
@ GNE_ATTR_SHAPE_END
last coordinate of edge shape
@ SUMO_ATTR_EMERGENCYDECEL
@ SUMO_ATTR_TO
@ SUMO_ATTR_FROM
@ SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR
@ SUMO_ATTR_HEIGHT
@ SUMO_ATTR_END
weights: time range end
@ SUMO_ATTR_PERMITTED
@ SUMO_ATTR_LCA_SUBLANE_PARAM
@ SUMO_ATTR_JM_CROSSING_GAP
@ SUMO_ATTR_ROADSIDE_CAPACITY
@ SUMO_ATTR_ACCELERATION
@ SUMO_ATTR_CARRIAGE_LENGTH
@ SUMO_ATTR_LATALIGNMENT
@ SUMO_ATTR_CF_IDM_STEPPING
@ SUMO_ATTR_DEPARTLANE
@ SUMO_ATTR_CF_IDMM_ADAPT_FACTOR
@ SUMO_ATTR_CURRENTLIMIT
current limit of the traction substation [A]
@ SUMO_ATTR_IMPATIENCE
@ SUMO_ATTR_COLLISION_MINGAP_FACTOR
@ SUMO_ATTR_CHANGE_RIGHT
@ SUMO_ATTR_TLID
link,node: the traffic light id responsible for this link
@ SUMO_ATTR_VCLASS
@ SUMO_ATTR_ACCEL
@ SUMO_ATTR_BOARDING_DURATION
@ SUMO_ATTR_DISTANCE
@ SUMO_ATTR_CF_EIDM_M_FLATNESS
@ SUMO_ATTR_OUTPUT
@ SUMO_ATTR_JM_SIGMA_MINOR
@ SUMO_ATTR_CHARGINGPOWER
@ SUMO_ATTR_PROB
@ SUMO_ATTR_CF_EIDM_M_BEGIN
@ GNE_ATTR_BIDIR
whether an edge is part of a bidirectional railway
@ SUMO_ATTR_FRIENDLY_POS
@ SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE
@ SUMO_ATTR_SPEEDFACTOR
@ SUMO_ATTR_ONROAD
@ SUMO_ATTR_LAT
@ SUMO_ATTR_TO_LANE
@ SUMO_ATTR_UNCONTROLLED
@ SUMO_ATTR_CF_EIDM_SIG_LEADER
@ SUMO_ATTR_TYPE
@ SUMO_ATTR_LENGTH
@ SUMO_ATTR_ROUTE
@ SUMO_ATTR_PERSON_NUMBER
@ SUMO_ATTR_COLOR
A color information.
@ SUMO_ATTR_EFFICIENCY
Eficiency of the charge in Charging Stations.
@ SUMO_ATTR_CF_PWAGNER2009_APPROB
@ SUMO_ATTR_MAXSPEED
@ SUMO_ATTR_ID
@ SUMO_ATTR_SIGMA
@ SUMO_ATTR_VISIBLE
@ SUMO_ATTR_UNTIL
@ SUMO_ATTR_RIGHT_OF_WAY
How to compute right of way.
@ SUMO_ATTR_K
@ SUMO_ATTR_TMP1
@ GNE_ATTR_SHAPE_START
first coordinate of edge shape
@ SUMO_ATTR_OSGFILE
@ SUMO_ATTR_LCA_OVERTAKE_RIGHT
@ SUMO_ATTR_ARRIVALPOS_LAT
@ SUMO_ATTR_LCA_ACCEL_LAT
@ SUMO_ATTR_LCA_STRATEGIC_PARAM
@ SUMO_ATTR_TAU
@ SUMO_ATTR_VISIBILITY_DISTANCE
foe visibility distance of a link
@ SUMO_ATTR_INSERTIONCHECKS
@ SUMO_ATTR_IMGFILE
@ SUMO_ATTR_TRIGGERED
@ SUMO_ATTR_DURATION
@ SUMO_ATTR_CONTPOS
@ SUMO_ATTR_WIDTH
@ SUMO_ATTR_DIR
The abstract direction of a link.
@ SUMO_ATTR_PERSON_CAPACITY
@ SUMO_ATTR_TLLINKINDEX
link: the index of the link within the traffic light
@ SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME
@ SUMO_ATTR_REPEAT
@ SUMO_ATTR_KEEP_CLEAR
Whether vehicles must keep the junction clear.
@ SUMO_ATTR_POSITION
@ SUMO_ATTR_LOCOMOTIVE_LENGTH
@ SUMO_ATTR_TMP5
@ SUMO_ATTR_CYCLETIME
@ SUMO_ATTR_STATE
The state of a link.
@ SUMO_ATTR_JM_DRIVE_RED_SPEED
@ SUMO_ATTR_CHARGEDELAY
Delay in the charge of charging stations.
@ SUMO_ATTR_LCA_TIME_TO_IMPATIENCE
@ SUMO_ATTR_JM_TIMEGAP_MINOR
@ SUMO_ATTR_TIME
trigger: the time of the step
@ SUMO_ATTR_CARRIAGE_GAP
@ SUMO_ATTR_TOJUNCTION
@ SUMO_ATTR_OVERHEAD_WIRECLAMP_LANEEND
id of the overhead wire lane, to the end of which the overhead wire clamp is connected
@ SUMO_ATTR_CF_WIEDEMANN_ESTIMATION
@ SUMO_ATTR_RELATIVEPATH
@ SUMO_ATTR_PERSONSPERHOUR
@ SUMO_ATTR_LCA_SPEEDGAINRIGHT
const double INVALID_DOUBLE
Definition: StdDefs.h:60
const double SUMO_const_laneWidth
Definition: StdDefs.h:48
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
Definition: ToString.h:282
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
virtual std::string getAttributeForSelection(SumoXMLAttr key) const
method for getting the attribute in the context of object selection
const std::string getID() const
get ID (all Attribute Carriers have one)
bool isAttributeCarrierSelected() const
check if attribute carrier is selected
virtual void enableAttribute(SumoXMLAttr key, GNEUndoList *undoList)
GNEAttributeCarrier(const SumoXMLTag tag, GNENet *net)
Constructor.
FXIcon * getACIcon() const
get FXIcon associated to this AC
static const std::vector< GNETagProperties > getTagPropertiesByType(const int tagPropertyCategory)
get tagProperties associated to the given GNETagProperties::TagType (NETWORKELEMENT,...
bool mySelected
boolean to check if this AC is selected (instead of GUIGlObjectStorage)
static void fillContainerStopElements()
fill container stop elements
static void fillVehicleElements()
fill vehicle elements
static void fillDemandElements()
fill demand elements
static void fillWaypointElements()
fill waypoint elements
static void fillPersonElements()
fill person elements
void setACParameters(const std::string &parameters, GNEUndoList *undoList)
set parameters (string)
static void fillDataElements()
fill Data elements
static void fillPersonPlanRides()
fill person plan rides
static void fillCommonStopAttributes(SumoXMLTag currentTag, const bool waypoint)
fill stop person attributes
static void fillLaneChangingModelAttributes(SumoXMLTag currentTag)
fill Junction Model Attributes of Vehicle/Person Types
void resetAttributes()
reset attributes to their default values without undo-redo (used in GNEFrameAttributeModules)
bool myIsTemplate
whether the current object is a template object (not drawn in the view)
static void fillAttributeCarriers()
fill Attribute Carriers
virtual void toggleAttribute(SumoXMLAttr key, const bool value)
method for enable or disable the attribute and nothing else (used in GNEChange_EnableAttribute)
static void fillAdditionalElements()
fill additional elements
static const std::string FEATURE_LOADED
static void fillCommonPersonAttributes(SumoXMLTag currentTag)
fill common person attributes (used by person and personFlows)
static void fillNetworkElements()
fill network elements
static void fillStopPersonElements()
fill stopPerson elements
static const std::string FEATURE_APPROVED
feature has been approved but not changed (i.e. after being reguessed)
static T parse(const std::string &string)
parses a value of type T from string (used for basic types: int, double, bool, etc....
std::string getAlternativeValueForDisabledAttributes(SumoXMLAttr key) const
virtual bool isAttributeComputed(SumoXMLAttr key) const
static void fillWireElements()
fill Wire elements
static const std::string True
true value in string format (used for comparing boolean values in getAttribute(......
void removeACParametersKeys(const std::vector< std::string > &keepKeys, GNEUndoList *undoList)
remove keys
static FXIcon * getVClassIcon(const SUMOVehicleClass vc)
returns icon associated to the given vClass
virtual bool isAttributeEnabled(SumoXMLAttr key) const
const std::string & getTagStr() const
get tag assigned to this object in string format
static const std::string FEATURE_GUESSED
feature has been reguessed (may still be unchanged be we can't tell (yet)
static void fillStopElements()
fill stop elements
const GNETagProperties & getTagProperty() const
get tagProperty associated with this Attribute Carrier
bool isTemplate() const
check if this AC is template
virtual const Parameterised::Map & getACParametersMap() const =0
void unselectAttributeCarrier(const bool changeFlag=true)
unselect attribute carrier using GUIGlobalSelection
bool drawUsingSelectColor() const
check if attribute carrier must be drawn using selecting color.
static void fillShapeElements()
fill shape elements
static void fillCommonVehicleAttributes(SumoXMLTag currentTag)
fill common vehicle attributes (used by vehicles, trips, routeFlows and flows)
void addACParameters(const std::string &key, const std::string &attribute, GNEUndoList *undoList)
add (or update attribute) key and attribute
static const Parameterised::Map PARAMETERS_EMPTY
empty parameter maps (used by ACs without parameters)
static bool lanesConsecutives(const std::vector< GNELane * > &lanes)
check if lanes are consecutives
void resetDefaultValues()
reset attribute carrier to their default values
static void fillPersonPlanWalks()
fill person plan walks
static void fillTAZElements()
fill TAZ elements
GNENet * myNet
pointer to net
static void fillCommonContainerAttributes(SumoXMLTag currentTag)
fill common container attributes (used by container and containerFlows)
static void fillCommonFlowAttributes(SumoXMLTag currentTag, SumoXMLAttr perHour)
fill common flow attributes (used by flows, routeFlows and personFlows)
static void fillJunctionModelAttributes(SumoXMLTag currentTag)
fill Junction Model Attributes of Vehicle/Person Types
GNENet * getNet() const
get pointer to net
virtual void disableAttribute(SumoXMLAttr key, GNEUndoList *undoList)
static void fillPersonPlanTrips()
fill person plan trips
static std::string parseIDs(const std::vector< T > &ACs)
parses a list of specific Attribute Carriers into a string of IDs
void selectAttributeCarrier(const bool changeFlag=true)
select attribute carrier using GUIGlobalSelection
static const std::string FEATURE_MODIFIED
feature has been manually modified (implies approval)
static const std::string False
true value in string format(used for comparing boolean values in getAttribute(...))
static void fillCarFollowingModelAttributes(SumoXMLTag currentTag)
fill Car Following Model of Vehicle/Person Types
static void fillContainerElements()
fill container elements
virtual void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)=0
T getACParameters() const
get parameters
virtual ~GNEAttributeCarrier()
Destructor.
virtual std::string getAttribute(SumoXMLAttr key) const =0
static void fillContainerTranshipElements()
fill container tranship elements
virtual GUIGlObject * getGUIGlObject()=0
const GNETagProperties & myTagProperty
reference to tagProperty associated with this attribute carrier
static std::map< SumoXMLTag, GNETagProperties > myTagProperties
map with the tags properties
static const size_t MAXNUMBEROFATTRIBUTES
max number of attributes allowed for every tag
static void fillContainerTransportElements()
fill container transport elements
void setDiscreteValues(const std::vector< std::string > &discreteValues)
set discrete values
void setDefaultActivated(const bool value)
set default activated value
void setRange(const double minimum, const double maximum)
set range
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:53
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:46
GNELane * retrieveLane(const std::string &id, bool hardFail=true, bool checkVolatileChange=false) const
get lane by id
GNEEdge * retrieveEdge(const std::string &id, bool hardFail=true) const
get edge by id
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
bool vClassIcon() const
return true if tag correspond to an element that has vClass icons
bool isGenericData() const
return true if tag correspond to a generic data element
const std::string & getTagStr() const
get Tag vinculated with this attribute Property in String Format (used to avoid multiple calls to toS...
bool isNetworkElement() const
return true if tag correspond to a network element
bool isSelectable() const
return true if tag correspond to a selectable element
GUIIcon getGUIIcon() const
get GUI icon associated to this Tag
bool isDemandElement() const
return true if tag correspond to a demand element
bool isAdditionalElement() const
return true if tag correspond to an additional element (note: this include TAZ, shapes and wires)
const GNEViewNetHelper::EditModes & getEditModes() const
get edit modes
Definition: GNEViewNet.cpp:632
static FXIcon * getIcon(const GUIIcon which)
returns a icon previously defined in the enum GUIIcon
void select(GUIGlID id, bool update=true)
Adds the object with the given id.
void deselect(GUIGlID id)
Deselects the object with the given id.
static PositionVector parseShapeReporting(const std::string &shpdef, const std::string &objecttype, const char *objectid, bool &ok, bool allowEmpty, bool report=true)
Builds a PositionVector from a string representation, reporting occurred errors.
static const double UNSPECIFIED_LOADED_LENGTH
no length override given
Definition: NBEdge.h:375
static const double UNSPECIFIED_CONTPOS
unspecified internal junction position
Definition: NBEdge.h:369
static const double UNSPECIFIED_VISIBILITY_DISTANCE
unspecified foe visibility for connections
Definition: NBEdge.h:372
static const double UNSPECIFIED_SPEED
unspecified lane speed
Definition: NBEdge.h:363
A storage for options typed value containers)
Definition: OptionsCont.h:89
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:59
std::map< std::string, std::string > Map
parameters map
Definition: Parameterised.h:45
static const std::vector< std::string > & getAllClassesStr()
Get all SUMOEmissionClass in string format.
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
A list of positions.
static const RGBColor INVISIBLE
Definition: RGBColor.h:195
static RGBColor parseColor(std::string coldef)
Parses a color information.
Definition: RGBColor.cpp:239
static std::vector< std::string > getLatAlignmentStrings()
return all valid strings for latAlignment
static StringBijection< LaneSpreadFunction > LaneSpreadFunctions
lane spread functions
static StringBijection< SumoXMLTag > CarFollowModels
car following models
static StringBijection< SumoXMLNodeType > NodeTypes
node types
static StringBijection< InsertionCheck > InsertionChecks
traffic light layouts
static StringBijection< TrainType > TrainTypes
train types
static StringBijection< LaneChangeModel > LaneChangeModels
lane change models
static StringBijection< RightOfWay > RightOfWayValues
righ of way algorithms
static StringBijection< FringeType > FringeTypeValues
fringe types
static const bool DEFAULT_RELATIVEPATH
Definition: Shape.h:48
static const double DEFAULT_LAYER
Definition: Shape.h:43
static const double DEFAULT_LAYER_POI
Definition: Shape.h:45
static const double DEFAULT_IMG_WIDTH
Definition: Shape.h:49
static const std::string DEFAULT_IMG_FILE
Definition: Shape.h:47
static const double DEFAULT_ANGLE
Definition: Shape.h:46
static const double DEFAULT_IMG_HEIGHT
Definition: Shape.h:50
static const std::string DEFAULT_TYPE
Definition: Shape.h:42
std::vector< std::string > getStrings() const
std::vector< std::string > getVector()
return vector of strings
bool hasNext()
returns the information whether further substrings exist
std::string next()
returns the next substring when it exists. Otherwise the behaviour is undefined
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
static int toInt(const std::string &sData)
converts a string into the integer value described by it by calling the char-type converter,...
static bool toBool(const std::string &sData)
converts a string into the bool value described by it by calling the char-type converter
bool isCurrentSupermodeDemand() const
@check if current supermode is Demand
bool isCurrentSupermodeData() const
@check if current supermode is Data
bool isCurrentSupermodeNetwork() const
@check if current supermode is Network