Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
GNEAttributeCarrier.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2023 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
18// Abstract Base class for gui objects which carry attributes
19/****************************************************************************/
20#include <netedit/GNENet.h>
21#include <netedit/GNEViewNet.h>
30
31#include "GNEAttributeCarrier.h"
32
33
34// ===========================================================================
35// static members
36// ===========================================================================
37
38std::map<SumoXMLTag, GNETagProperties> GNEAttributeCarrier::myTagProperties;
39const std::string GNEAttributeCarrier::FEATURE_LOADED = "loaded";
40const std::string GNEAttributeCarrier::FEATURE_GUESSED = "guessed";
41const std::string GNEAttributeCarrier::FEATURE_MODIFIED = "modified";
42const std::string GNEAttributeCarrier::FEATURE_APPROVED = "approved";
45const std::string GNEAttributeCarrier::True = toString(true);
46const std::string GNEAttributeCarrier::False = toString(false);
47
48
49// ===========================================================================
50// method definitions
51// ===========================================================================
52
54 myTagProperty(getTagProperty(tag)),
55 myNet(net),
56 mySelected(false),
57 myIsTemplate(false) {
58}
59
60
62
63
64const std::string
68
69
70GNENet*
72 return myNet;
73}
74
75
76void
79 gSelected.select(getGUIGlObject()->getGlID());
80 if (changeFlag) {
81 mySelected = true;
82 }
83 }
84}
85
86
87void
90 gSelected.deselect(getGUIGlObject()->getGlID());
91 if (changeFlag) {
92 mySelected = false;
93 }
94 }
95}
96
97
98bool
102
103
104bool
106 // get flag for network element
107 const bool networkElement = myTagProperty.isNetworkElement() || myTagProperty.isAdditionalElement();
108 // check supermode network
109 if ((networkElement && myNet->getViewNet()->getEditModes().isCurrentSupermodeNetwork()) ||
112 return mySelected;
113 } else {
114 return false;
115 }
116}
117
118
119void
121 for (const auto& attrProperty : myTagProperty) {
122 if (attrProperty.hasDefaultValue()) {
123 setAttribute(attrProperty.getAttr(), attrProperty.getDefaultValue());
124 if (attrProperty.isActivatable()) {
125 toggleAttribute(attrProperty.getAttr(), attrProperty.getDefaultActivated());
126 }
127 }
128 }
129}
130
131
132void
134 throw ProcessError(TL("Nothing to enable, implement in Children"));
135
136}
137
138
139void
141 throw ProcessError(TL("Nothing to disable, implement in Children"));
142}
143
144
145bool
147 // by default, all attributes are enabled
148 return true;
149}
150
151
152bool
154 // by default, all attributes aren't computed
155 return false;
156}
157
158
159template<> int
160GNEAttributeCarrier::parse(const std::string& string) {
161 return StringUtils::toInt(string);
162}
163
164
165template<> double
166GNEAttributeCarrier::parse(const std::string& string) {
167 return StringUtils::toDouble(string);
168}
169
170
171template<> SUMOTime
172GNEAttributeCarrier::parse(const std::string& string) {
173 return string2time(string);
174}
175
176
177template<> bool
178GNEAttributeCarrier::parse(const std::string& string) {
179 return StringUtils::toBool(string);
180}
181
182
183template<> std::string
184GNEAttributeCarrier::parse(const std::string& string) {
185 return string;
186}
187
188
189template<> SUMOVehicleClass
190GNEAttributeCarrier::parse(const std::string& string) {
191 if (string.size() == 0) {
192 throw EmptyData();
193 } else if (!SumoVehicleClassStrings.hasString(string)) {
194 return SVC_IGNORING;
195 } else {
196 return SumoVehicleClassStrings.get(string);
197 }
198}
199
200
201template<> RGBColor
202GNEAttributeCarrier::parse(const std::string& string) {
203 if (string.empty()) {
204 return RGBColor::INVISIBLE;
205 } else {
206 return RGBColor::parseColor(string);
207 }
208}
209
210
211template<> Position
212GNEAttributeCarrier::parse(const std::string& string) {
213 if (string.size() == 0) {
214 throw EmptyData();
215 } else {
216 bool ok = true;
217 PositionVector pos = GeomConvHelper::parseShapeReporting(string, "user-supplied position", 0, ok, false, false);
218 if (!ok || (pos.size() != 1)) {
219 throw NumberFormatException("(Position) " + string);
220 } else {
221 return pos[0];
222 }
223 }
224}
225
226
227template<> PositionVector
228GNEAttributeCarrier::parse(const std::string& string) {
229 PositionVector posVector;
230 // empty string are allowed (It means empty position vector)
231 if (string.empty()) {
232 return posVector;
233 } else {
234 bool ok = true;
235 posVector = GeomConvHelper::parseShapeReporting(string, "user-supplied shape", 0, ok, false, true);
236 if (!ok) {
237 throw NumberFormatException("(Position List) " + string);
238 } else {
239 return posVector;
240 }
241 }
242}
243
244
245template<> SUMOVehicleShape
246GNEAttributeCarrier::parse(const std::string& string) {
247 if ((string == "unknown") || (!SumoVehicleShapeStrings.hasString(string))) {
249 } else {
250 return SumoVehicleShapeStrings.get(string);
251 }
252}
253
254
255template<> std::vector<std::string>
256GNEAttributeCarrier::parse(const std::string& string) {
257 return StringTokenizer(string).getVector();
258}
259
260
261template<> std::set<std::string>
262GNEAttributeCarrier::parse(const std::string& string) {
263 std::vector<std::string> vectorString = StringTokenizer(string).getVector();
264 std::set<std::string> solution;
265 for (const auto& i : vectorString) {
266 solution.insert(i);
267 }
268 return solution;
269}
270
271
272template<> std::vector<int>
273GNEAttributeCarrier::parse(const std::string& string) {
274 std::vector<std::string> parsedValues = parse<std::vector<std::string> >(string);
275 std::vector<int> parsedIntValues;
276 for (const auto& i : parsedValues) {
277 parsedIntValues.push_back(parse<int>(i));
278 }
279 return parsedIntValues;
280}
281
282
283template<> std::vector<double>
284GNEAttributeCarrier::parse(const std::string& string) {
285 std::vector<std::string> parsedValues = parse<std::vector<std::string> >(string);
286 std::vector<double> parsedDoubleValues;
287 for (const auto& i : parsedValues) {
288 parsedDoubleValues.push_back(parse<double>(i));
289 }
290 return parsedDoubleValues;
291}
292
293
294template<> std::vector<bool>
295GNEAttributeCarrier::parse(const std::string& string) {
296 std::vector<std::string> parsedValues = parse<std::vector<std::string> >(string);
297 std::vector<bool> parsedBoolValues;
298 for (const auto& i : parsedValues) {
299 parsedBoolValues.push_back(parse<bool>(i));
300 }
301 return parsedBoolValues;
302}
303
304
305template<> std::vector<SumoXMLAttr>
306GNEAttributeCarrier::parse(const std::string& value) {
307 // Declare string vector
308 std::vector<std::string> attributesStr = GNEAttributeCarrier::parse<std::vector<std::string> > (value);
309 std::vector<SumoXMLAttr> attributes;
310 // Iterate over lanes IDs, retrieve Lanes and add it into parsedLanes
311 for (const auto& attributeStr : attributesStr) {
312 if (SUMOXMLDefinitions::Tags.hasString(attributeStr)) {
313 attributes.push_back(static_cast<SumoXMLAttr>(SUMOXMLDefinitions::Attrs.get(attributeStr)));
314 } else {
315 throw InvalidArgument("Error parsing attributes. Attribute '" + attributeStr + "' doesn't exist");
316 }
317 }
318 return attributes;
319}
320
321
322template<> std::vector<GNEEdge*>
323GNEAttributeCarrier::parse(GNENet* net, const std::string& value) {
324 // Declare string vector
325 std::vector<std::string> edgeIds = GNEAttributeCarrier::parse<std::vector<std::string> > (value);
326 std::vector<GNEEdge*> parsedEdges;
327 // Iterate over edges IDs, retrieve Edges and add it into parsedEdges
328 for (const auto& edgeID : edgeIds) {
329 GNEEdge* retrievedEdge = net->getAttributeCarriers()->retrieveEdge(edgeID, false);
330 if (retrievedEdge) {
331 parsedEdges.push_back(net->getAttributeCarriers()->retrieveEdge(edgeID));
332 } else {
333 throw FormatException("Error parsing parameter " + toString(SUMO_ATTR_EDGES) + ". " +
334 toString(SUMO_TAG_EDGE) + " '" + edgeID + "' doesn't exist");
335 }
336 }
337 return parsedEdges;
338}
339
340
341template<> std::vector<GNELane*>
342GNEAttributeCarrier::parse(GNENet* net, const std::string& value) {
343 // Declare string vector
344 std::vector<std::string> laneIds = GNEAttributeCarrier::parse<std::vector<std::string> > (value);
345 std::vector<GNELane*> parsedLanes;
346 // Iterate over lanes IDs, retrieve Lanes and add it into parsedLanes
347 for (const auto& laneID : laneIds) {
348 GNELane* retrievedLane = net->getAttributeCarriers()->retrieveLane(laneID, false);
349 if (retrievedLane) {
350 parsedLanes.push_back(net->getAttributeCarriers()->retrieveLane(laneID));
351 } else {
352 throw FormatException("Error parsing parameter " + toString(SUMO_ATTR_LANES) + ". " +
353 toString(SUMO_TAG_LANE) + " '" + laneID + "' doesn't exist");
354 }
355 }
356 return parsedLanes;
357}
358
359
360template<> std::string
361GNEAttributeCarrier::parseIDs(const std::vector<GNEEdge*>& ACs) {
362 // obtain ID's of edges and return their join
363 std::vector<std::string> edgeIDs;
364 for (const auto& i : ACs) {
365 edgeIDs.push_back(i->getID());
366 }
367 return joinToString(edgeIDs, " ");
368}
369
370
371template<> std::string
372GNEAttributeCarrier::parseIDs(const std::vector<GNELane*>& ACs) {
373 // obtain ID's of lanes and return their join
374 std::vector<std::string> laneIDs;
375 for (const auto& i : ACs) {
376 laneIDs.push_back(i->getID());
377 }
378 return joinToString(laneIDs, " ");
379}
380
381
382bool
383GNEAttributeCarrier::lanesConsecutives(const std::vector<GNELane*>& lanes) {
384 // we need at least two lanes
385 if (lanes.size() > 1) {
386 // now check that lanes are consecutives (not neccesary connected)
387 int currentLane = 0;
388 while (currentLane < ((int)lanes.size() - 1)) {
389 int nextLane = -1;
390 // iterate over outgoing edges of destiny juntion of edge's lane
391 for (int i = 0; (i < (int)lanes.at(currentLane)->getParentEdge()->getToJunction()->getGNEOutgoingEdges().size()) && (nextLane == -1); i++) {
392 // iterate over lanes of outgoing edges of destiny juntion of edge's lane
393 for (int j = 0; (j < (int)lanes.at(currentLane)->getParentEdge()->getToJunction()->getGNEOutgoingEdges().at(i)->getLanes().size()) && (nextLane == -1); j++) {
394 // check if lane correspond to the next lane of "lanes"
395 if (lanes.at(currentLane)->getParentEdge()->getToJunction()->getGNEOutgoingEdges().at(i)->getLanes().at(j) == lanes.at(currentLane + 1)) {
396 nextLane = currentLane;
397 }
398 }
399 }
400 if (nextLane == -1) {
401 return false;
402 } else {
403 currentLane++;
404 }
405 }
406 return true;
407 } else {
408 return false;
409 }
410}
411
412
413template<> std::string
415 std::string result;
416 // Generate an string using the following structure: "key1=value1|key2=value2|...
417 for (const auto& parameter : getACParametersMap()) {
418 result += parameter.first + "=" + parameter.second + "|";
419 }
420 // remove the last "|"
421 if (!result.empty()) {
422 result.pop_back();
423 }
424 return result;
425}
426
427
428template<> std::vector<std::pair<std::string, std::string> >
430 std::vector<std::pair<std::string, std::string> > result;
431 // Generate a vector string using the following structure: "<key1,value1>, <key2, value2>,...
432 for (const auto& parameter : getACParametersMap()) {
433 result.push_back(std::make_pair(parameter.first, parameter.second));
434 }
435 return result;
436}
437
438
439void
440GNEAttributeCarrier::setACParameters(const std::string& parameters, GNEUndoList* undoList) {
441 // declare map
442 Parameterised::Map parametersMap;
443 // separate value in a vector of string using | as separator
444 StringTokenizer parametersTokenizer(parameters, "|", true);
445 // iterate over all values
446 while (parametersTokenizer.hasNext()) {
447 // obtain key and value and save it in myParameters
448 const std::vector<std::string> keyValue = StringTokenizer(parametersTokenizer.next(), "=", true).getVector();
449 if (keyValue.size() == 2) {
450 parametersMap[keyValue.front()] = keyValue.back();
451 }
452 }
453 // set setACParameters map
454 setACParameters(parametersMap, undoList);
455}
456
457
458void
459GNEAttributeCarrier::setACParameters(const std::vector<std::pair<std::string, std::string> >& parameters, GNEUndoList* undoList) {
460 // declare parametersMap
461 Parameterised::Map parametersMap;
462 // Generate an string using the following structure: "key1=value1|key2=value2|...
463 for (const auto& parameter : parameters) {
464 parametersMap[parameter.first] = parameter.second;
465 }
466 // set setACParameters map
467 setACParameters(parametersMap, undoList);
468}
469
470
471void
473 // declare result string
474 std::string paramsStr;
475 // Generate an string using the following structure: "key1=value1|key2=value2|...
476 for (const auto& parameter : parameters) {
477 paramsStr += parameter.first + "=" + parameter.second + "|";
478 }
479 // remove the last "|"
480 if (!paramsStr.empty()) {
481 paramsStr.pop_back();
482 }
483 // set parameters
484 setAttribute(GNE_ATTR_PARAMETERS, paramsStr, undoList);
485}
486
487
488void
489GNEAttributeCarrier::addACParameters(const std::string& key, const std::string& attribute, GNEUndoList* undoList) {
490 // get parametersMap
491 Parameterised::Map parametersMap = getACParametersMap();
492 // add (or update) attribute
493 parametersMap[key] = attribute;
494 // set attribute
495 setACParameters(parametersMap, undoList);
496}
497
498
499void
500GNEAttributeCarrier::removeACParametersKeys(const std::vector<std::string>& keepKeys, GNEUndoList* undoList) {
501 // declare parametersMap
502 Parameterised::Map newParametersMap;
503 // iterate over parameters map
504 for (const auto& parameter : getACParametersMap()) {
505 // copy to newParametersMap if key is in keepKeys
506 if (std::find(keepKeys.begin(), keepKeys.end(), parameter.first) != keepKeys.end()) {
507 newParametersMap.insert(parameter);
508 }
509 }
510 // set newParametersMap map
511 setACParameters(newParametersMap, undoList);
512}
513
514
515std::string
517 switch (key) {
518 // Crossings
521 return "No TLS";
522 // connections
523 case SUMO_ATTR_DIR: {
524 // special case for connection directions
525 std::string direction = getAttribute(key);
526 if (direction == "s") {
527 return "Straight (s)";
528 } else if (direction == "t") {
529 return "Turn (t))";
530 } else if (direction == "l") {
531 return "Left (l)";
532 } else if (direction == "r") {
533 return "Right (r)";
534 } else if (direction == "L") {
535 return "Partially left (L)";
536 } else if (direction == "R") {
537 return "Partially right (R)";
538 } else if (direction == "invalid") {
539 return "No direction (Invalid))";
540 } else {
541 return "undefined";
542 }
543 }
544 case SUMO_ATTR_STATE: {
545 // special case for connection states
546 std::string state = getAttribute(key);
547 if (state == "-") {
548 return "Dead end (-)";
549 } else if (state == "=") {
550 return "equal (=)";
551 } else if (state == "m") {
552 return "Minor link (m)";
553 } else if (state == "M") {
554 return "Major link (M)";
555 } else if (state == "O") {
556 return "TLS controller off (O)";
557 } else if (state == "o") {
558 return "TLS yellow flashing (o)";
559 } else if (state == "y") {
560 return "TLS yellow minor link (y)";
561 } else if (state == "Y") {
562 return "TLS yellow major link (Y)";
563 } else if (state == "r") {
564 return "TLS red (r)";
565 } else if (state == "g") {
566 return "TLS green minor (g)";
567 } else if (state == "G") {
568 return "TLS green major (G)";
569 } else if (state == "Z") {
570 return "Zipper (Z)";
571 } else {
572 return "undefined";
573 }
574 }
576 return "no distribution set";
577 }
578 default:
579 return getAttribute(key);
580 }
581}
582
583
584std::string
588
589
590const std::string&
594
595
596FXIcon*
598 // define on first access
599 if (myTagProperties.size() == 0) {
601 }
602 // special case for vClass icons
605 } else {
607 }
608}
609
610
611bool
615
616
617const GNETagProperties&
621
622// ===========================================================================
623// static methods
624// ===========================================================================
625
626const GNETagProperties&
628 // define on first access
629 if (myTagProperties.size() == 0) {
631 }
632 // check that tag is defined
633 if (myTagProperties.count(tag) == 0) {
634 throw ProcessError(TLF("TagProperty for tag '%' not defined", toString(tag)));
635 } else {
636 return myTagProperties.at(tag);
637 }
638}
639
640
641const std::vector<GNETagProperties>
642GNEAttributeCarrier::getTagPropertiesByType(const int tagPropertyCategory) {
643 std::vector<GNETagProperties> allowedTags;
644 // define on first access
645 if (myTagProperties.size() == 0) {
647 }
648 if (tagPropertyCategory & GNETagProperties::NETWORKELEMENT) {
649 // fill networkElements tags
650 for (const auto& tagProperty : myTagProperties) {
651 if (tagProperty.second.isNetworkElement()) {
652 allowedTags.push_back(tagProperty.second);
653 }
654 }
655 }
656 if (tagPropertyCategory & GNETagProperties::ADDITIONALELEMENT) {
657 // fill additional tags (only with pure additionals)
658 for (const auto& tagProperty : myTagProperties) {
659 // avoid symbols (It will be implemented in #7355)
660 if (tagProperty.second.isAdditionalPureElement() && !tagProperty.second.isSymbol()) {
661 allowedTags.push_back(tagProperty.second);
662 }
663 }
664 }
665 if (tagPropertyCategory & GNETagProperties::SYMBOL) {
666 // fill symbol tags
667 for (const auto& tagProperty : myTagProperties) {
668 if (tagProperty.second.isSymbol()) {
669 allowedTags.push_back(tagProperty.second);
670 }
671 }
672 }
673 if (tagPropertyCategory & GNETagProperties::SHAPE) {
674 // fill shape tags
675 for (const auto& tagProperty : myTagProperties) {
676 if (tagProperty.second.isShapeElement()) {
677 allowedTags.push_back(tagProperty.second);
678 }
679 }
680 }
681 if (tagPropertyCategory & GNETagProperties::TAZELEMENT) {
682 // fill taz tags
683 for (const auto& tagProperty : myTagProperties) {
684 if (tagProperty.second.isTAZElement()) {
685 allowedTags.push_back(tagProperty.second);
686 }
687 }
688 }
689 if (tagPropertyCategory & GNETagProperties::WIRE) {
690 // fill wire tags
691 for (const auto& tagProperty : myTagProperties) {
692 if (tagProperty.second.isWireElement()) {
693 allowedTags.push_back(tagProperty.second);
694 }
695 }
696 }
697 if (tagPropertyCategory & GNETagProperties::DEMANDELEMENT) {
698 // fill demand tags
699 for (const auto& tagProperty : myTagProperties) {
700 if (tagProperty.second.isDemandElement()) {
701 allowedTags.push_back(tagProperty.second);
702 }
703 }
704 }
705 if (tagPropertyCategory & GNETagProperties::ROUTE) {
706 // fill route tags
707 for (const auto& tagProperty : myTagProperties) {
708 if (tagProperty.second.isRoute()) {
709 allowedTags.push_back(tagProperty.second);
710 }
711 }
712 }
713 if (tagPropertyCategory & GNETagProperties::VEHICLE) {
714 // fill vehicle tags
715 for (const auto& tagProperty : myTagProperties) {
716 if (tagProperty.second.isVehicle()) {
717 allowedTags.push_back(tagProperty.second);
718 }
719 }
720 }
721 if (tagPropertyCategory & GNETagProperties::STOP) {
722 // fill stop tags
723 for (const auto& tagProperty : myTagProperties) {
724 if (tagProperty.second.isStop()) {
725 allowedTags.push_back(tagProperty.second);
726 }
727 }
728 }
729 if (tagPropertyCategory & GNETagProperties::PERSON) {
730 // fill person tags
731 for (const auto& tagProperty : myTagProperties) {
732 if (tagProperty.second.isPerson()) {
733 allowedTags.push_back(tagProperty.second);
734 }
735 }
736 }
737 if (tagPropertyCategory & GNETagProperties::PERSONPLAN) {
738 // fill person plan tags
739 for (const auto& tagProperty : myTagProperties) {
740 if (tagProperty.second.isPersonPlan()) {
741 allowedTags.push_back(tagProperty.second);
742 }
743 }
744 }
745 if (tagPropertyCategory & GNETagProperties::PERSONTRIP) {
746 // fill demand tags
747 for (const auto& tagProperty : myTagProperties) {
748 if (tagProperty.second.isPersonTrip()) {
749 allowedTags.push_back(tagProperty.second);
750 }
751 }
752 }
753 if (tagPropertyCategory & GNETagProperties::WALK) {
754 // fill demand tags
755 for (const auto& tagProperty : myTagProperties) {
756 if (tagProperty.second.isWalk()) {
757 allowedTags.push_back(tagProperty.second);
758 }
759 }
760 }
761 if (tagPropertyCategory & GNETagProperties::RIDE) {
762 // fill demand tags
763 for (const auto& tagProperty : myTagProperties) {
764 if (tagProperty.second.isRide()) {
765 allowedTags.push_back(tagProperty.second);
766 }
767 }
768 }
769 if (tagPropertyCategory & GNETagProperties::STOPPERSON) {
770 // fill demand tags
771 for (const auto& tagProperty : myTagProperties) {
772 if (tagProperty.second.isStopPerson()) {
773 allowedTags.push_back(tagProperty.second);
774 }
775 }
776 }
777 if (tagPropertyCategory & GNETagProperties::GENERICDATA) {
778 // fill generic data tags
779 for (const auto& tagProperty : myTagProperties) {
780 if (tagProperty.second.isGenericData()) {
781 allowedTags.push_back(tagProperty.second);
782 }
783 }
784 }
785 if (tagPropertyCategory & GNETagProperties::MEANDATA) {
786 // fill generic data tags
787 for (const auto& tagProperty : myTagProperties) {
788 if (tagProperty.second.isMeanData()) {
789 allowedTags.push_back(tagProperty.second);
790 }
791 }
792 }
793 if (tagPropertyCategory & GNETagProperties::CONTAINER) {
794 // fill container tags
795 for (const auto& tagProperty : myTagProperties) {
796 if (tagProperty.second.isContainer()) {
797 allowedTags.push_back(tagProperty.second);
798 }
799 }
800 }
801 if (tagPropertyCategory & GNETagProperties::CONTAINERPLAN) {
802 // fill container plan tags
803 for (const auto& tagProperty : myTagProperties) {
804 if (tagProperty.second.isContainerPlan()) {
805 allowedTags.push_back(tagProperty.second);
806 }
807 }
808 }
809 if (tagPropertyCategory & GNETagProperties::TRANSPORT) {
810 // fill demand tags
811 for (const auto& tagProperty : myTagProperties) {
812 if (tagProperty.second.isTransportPlan()) {
813 allowedTags.push_back(tagProperty.second);
814 }
815 }
816 }
817 if (tagPropertyCategory & GNETagProperties::TRANSHIP) {
818 // fill demand tags
819 for (const auto& tagProperty : myTagProperties) {
820 if (tagProperty.second.isTranshipPlan()) {
821 allowedTags.push_back(tagProperty.second);
822 }
823 }
824 }
825 if (tagPropertyCategory & GNETagProperties::STOPCONTAINER) {
826 // fill demand tags
827 for (const auto& tagProperty : myTagProperties) {
828 if (tagProperty.second.isStopContainer()) {
829 allowedTags.push_back(tagProperty.second);
830 }
831 }
832 }
833 return allowedTags;
834}
835
836// ===========================================================================
837// private
838// ===========================================================================
839
840void
842 for (const auto& attrProperty : myTagProperty) {
843 if (attrProperty.hasDefaultValue()) {
844 setAttribute(attrProperty.getAttr(), attrProperty.getDefaultValue());
845 }
846 }
847}
848
849
850void
851GNEAttributeCarrier::toggleAttribute(SumoXMLAttr /*key*/, const bool /*value*/) {
852 throw ProcessError(TL("Nothing to toggle, implement in Children"));
853}
854
855
856void
858 // fill all groups of ACs
864 // demand
869 // persons
875 // containers
880 //data
882 // check integrity of all Tags (function checkTagIntegrity() throws an exception if there is an inconsistency)
883 for (const auto& tagProperty : myTagProperties) {
884 tagProperty.second.checkTagIntegrity();
885 }
886}
887
888
889void
891 // declare empty GNEAttributeProperties
892 GNEAttributeProperties attrProperty;
893 // obtain Node Types except SumoXMLNodeType::DEAD_END_DEPRECATED
894 const auto& neteditOptions = OptionsCont::getOptions();
895 std::vector<std::string> nodeTypes = SUMOXMLDefinitions::NodeTypes.getStrings();
896 nodeTypes.erase(std::find(nodeTypes.begin(), nodeTypes.end(), toString(SumoXMLNodeType::DEAD_END_DEPRECATED)));
897 nodeTypes.erase(std::find(nodeTypes.begin(), nodeTypes.end(), toString(SumoXMLNodeType::DEAD_END)));
898 nodeTypes.erase(std::find(nodeTypes.begin(), nodeTypes.end(), toString(SumoXMLNodeType::INTERNAL)));
899 // obtain TLTypes (note: avoid insert all TLTypes because some of them are experimental and not documented)
900 std::vector<std::string> TLTypes;
901 TLTypes.push_back(toString(TrafficLightType::STATIC));
902 TLTypes.push_back(toString(TrafficLightType::ACTUATED));
903 TLTypes.push_back(toString(TrafficLightType::DELAYBASED));
904 TLTypes.push_back(toString(TrafficLightType::NEMA));
905 // fill networkElement ACs
906 SumoXMLTag currentTag = SUMO_TAG_JUNCTION;
907 {
908 // set values of tag
909 myTagProperties[currentTag] = GNETagProperties(currentTag,
912 GUIIcon::JUNCTION, currentTag);
913 // set values of attributes
916 TL("The id of the node"));
917 myTagProperties[currentTag].addAttribute(attrProperty);
918
920 GNEAttributeProperties::STRING | GNEAttributeProperties::UNIQUE | GNEAttributeProperties::POSITION | GNEAttributeProperties::UPDATEGEOMETRY, // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
921 TL("The x-y-z position of the node on the plane in meters"));
922 myTagProperties[currentTag].addAttribute(attrProperty);
923
926 TL("An optional type for the node"));
927 attrProperty.setDiscreteValues(nodeTypes, true);
928 myTagProperties[currentTag].addAttribute(attrProperty);
929
932 TL("A custom shape for that node"));
933 myTagProperties[currentTag].addAttribute(attrProperty);
934
937 TL("Optional turning radius (for all corners) for that node in meters"),
938 "1.5");
939 myTagProperties[currentTag].addAttribute(attrProperty);
940
943 TL("Whether the junction-blocking-heuristic should be activated at this node"),
944 "1");
945 myTagProperties[currentTag].addAttribute(attrProperty);
946
949 TL("How to compute right of way rules at this node"),
951 attrProperty.setDiscreteValues(SUMOXMLDefinitions::RightOfWayValues.getStrings(), true);
952 myTagProperties[currentTag].addAttribute(attrProperty);
953
956 TL("Whether this junction is at the fringe of the network"),
958 attrProperty.setDiscreteValues(SUMOXMLDefinitions::FringeTypeValues.getStrings(), true);
959 myTagProperties[currentTag].addAttribute(attrProperty);
960
963 TL("Optional name of junction"));
964 myTagProperties[currentTag].addAttribute(attrProperty);
965
968 TL("An optional type for the traffic light algorithm"));
969 attrProperty.setDiscreteValues(TLTypes, true);
970 myTagProperties[currentTag].addAttribute(attrProperty);
971
974 TL("An optional layout for the traffic light plan"));
979 myTagProperties[currentTag].addAttribute(attrProperty);
980
983 TL("An optional id for the traffic light program"));
984 myTagProperties[currentTag].addAttribute(attrProperty);
985 }
986 currentTag = SUMO_TAG_TYPE;
987 {
988 // set values of tag
989 myTagProperties[currentTag] = GNETagProperties(currentTag,
992 GUIIcon::EDGETYPE, currentTag);
993 // set values of attributes
996 TL("The id of the edge"));
997 myTagProperties[currentTag].addAttribute(attrProperty);
998
1001 TL("The number of lanes of the edge"),
1002 toString(neteditOptions.getInt("default.lanenumber")));
1003 myTagProperties[currentTag].addAttribute(attrProperty);
1004
1007 TL("The maximum speed allowed on the edge in m/s"),
1008 toString(neteditOptions.getFloat("default.speed")));
1009 myTagProperties[currentTag].addAttribute(attrProperty);
1010
1013 TL("Explicitly allows the given vehicle classes (not given will be not allowed)"),
1014 "all");
1015 myTagProperties[currentTag].addAttribute(attrProperty);
1016
1019 TL("Explicitly disallows the given vehicle classes (not given will be allowed)"));
1020 myTagProperties[currentTag].addAttribute(attrProperty);
1021
1024 TL("The spreadType defines how to compute the lane geometry from the edge geometry (used for visualization)"),
1026 attrProperty.setDiscreteValues(SUMOXMLDefinitions::LaneSpreadFunctions.getStrings(), true);
1027 myTagProperties[currentTag].addAttribute(attrProperty);
1028
1031 TL("The priority of the edge"),
1032 toString(neteditOptions.getInt("default.priority")));
1033 myTagProperties[currentTag].addAttribute(attrProperty);
1034
1037 TL("Lane width for all lanes of this edge in meters (used for visualization)"),
1038 "-1");
1039 myTagProperties[currentTag].addAttribute(attrProperty);
1040
1043 TL("The width of the sidewalk that should be added as an additional lane"));
1044 myTagProperties[currentTag].addAttribute(attrProperty);
1045
1048 TL("The width of the bike lane that should be added as an additional lane"));
1049 myTagProperties[currentTag].addAttribute(attrProperty);
1050 }
1051 currentTag = SUMO_TAG_LANETYPE;
1052 {
1053 // set values of tag
1054 myTagProperties[currentTag] = GNETagProperties(currentTag,
1057 GUIIcon::LANETYPE, currentTag);
1058 // set values of attributes
1061 TL("The maximum speed allowed on the lane in m/s"),
1062 toString(neteditOptions.getFloat("default.speed")));
1063 myTagProperties[currentTag].addAttribute(attrProperty);
1064
1067 TL("Explicitly allows the given vehicle classes (not given will be not allowed)"),
1068 "all");
1069 myTagProperties[currentTag].addAttribute(attrProperty);
1070
1073 TL("Explicitly disallows the given vehicle classes (not given will be allowed)"));
1074 myTagProperties[currentTag].addAttribute(attrProperty);
1075
1078 TL("Lane width for all lanes of this lane in meters (used for visualization)"),
1079 "-1");
1080 myTagProperties[currentTag].addAttribute(attrProperty);
1081 }
1082 currentTag = SUMO_TAG_EDGE;
1083 {
1084 // set values of tag
1085 myTagProperties[currentTag] = GNETagProperties(currentTag,
1088 GUIIcon::EDGE, currentTag);
1089 // set values of attributes
1090 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1092 TL("Edge ID"));
1093 myTagProperties[currentTag].addAttribute(attrProperty);
1094
1097 TL("The name of a node within the nodes-file the edge shall start at"));
1098 myTagProperties[currentTag].addAttribute(attrProperty);
1099
1100 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
1102 TL("The name of a node within the nodes-file the edge shall end at"));
1103 myTagProperties[currentTag].addAttribute(attrProperty);
1104
1107 TL("The maximum speed allowed on the edge in m/s"),
1108 toString(neteditOptions.getFloat("default.speed")));
1109 myTagProperties[currentTag].addAttribute(attrProperty);
1110
1113 TL("The priority of the edge"),
1114 toString(neteditOptions.getInt("default.priority")));
1115 myTagProperties[currentTag].addAttribute(attrProperty);
1116
1119 TL("The number of lanes of the edge"),
1120 toString(neteditOptions.getInt("default.lanenumber")));
1121 myTagProperties[currentTag].addAttribute(attrProperty);
1122
1125 TL("The name of a type within the SUMO edge type file"));
1126 myTagProperties[currentTag].addAttribute(attrProperty);
1127
1130 TL("Explicitly allows the given vehicle classes (not given will be not allowed)"),
1131 "all");
1132 myTagProperties[currentTag].addAttribute(attrProperty);
1133
1136 TL("Explicitly disallows the given vehicle classes (not given will be allowed)"));
1137 myTagProperties[currentTag].addAttribute(attrProperty);
1138
1141 TL("If the shape is given it should start and end with the positions of the from-node and to-node"));
1142 myTagProperties[currentTag].addAttribute(attrProperty);
1143
1146 TL("The length of the edge in meter"));
1147 myTagProperties[currentTag].addAttribute(attrProperty);
1148
1151 TL("The spreadType defines how to compute the lane geometry from the edge geometry (used for visualization)"),
1153 attrProperty.setDiscreteValues(SUMOXMLDefinitions::LaneSpreadFunctions.getStrings(), true);
1154 myTagProperties[currentTag].addAttribute(attrProperty);
1155
1158 TL("street name (does not need to be unique, used for visualization)"));
1159 myTagProperties[currentTag].addAttribute(attrProperty);
1160
1163 TL("Lane width for all lanes of this edge in meters (used for visualization)"),
1164 "-1");
1165 myTagProperties[currentTag].addAttribute(attrProperty);
1166
1169 TL("Move the stop line back from the intersection by the given amount"),
1170 "0.00");
1171 myTagProperties[currentTag].addAttribute(attrProperty);
1172
1175 TL("Custom position in which shape start (by default position of junction from)"));
1176 myTagProperties[currentTag].addAttribute(attrProperty);
1177
1180 TL("Custom position in which shape end (by default position of junction from)"));
1181 myTagProperties[currentTag].addAttribute(attrProperty);
1182
1184 GNEAttributeProperties::BOOL | GNEAttributeProperties::DEFAULTVALUE, // virtual attribute to check of this edge is part of a bidirectional railway (cannot be edited)
1185 TL("Show if edge is bidirectional"),
1186 "0");
1187 myTagProperties[currentTag].addAttribute(attrProperty);
1188
1191 TL("Distance"),
1192 "0.00");
1193 myTagProperties[currentTag].addAttribute(attrProperty);
1194
1197 TL("The stop offset as positive value in meters"),
1198 "0.00");
1199 myTagProperties[currentTag].addAttribute(attrProperty);
1200
1203 TL("Specifies, for which vehicle classes the stopOffset does NOT apply."));
1204 attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings(), false);
1205 myTagProperties[currentTag].addAttribute(attrProperty);
1206 }
1207 currentTag = SUMO_TAG_LANE;
1208 {
1209 // set values of tag
1210 myTagProperties[currentTag] = GNETagProperties(currentTag,
1212 0,
1213 GUIIcon::LANE, currentTag);
1214 // set values of attributes
1215 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1217 TL("Lane ID (Automatic, non editable)"));
1218 myTagProperties[currentTag].addAttribute(attrProperty);
1219
1222 TL("The enumeration index of the lane (0 is the rightmost lane, <NUMBER_LANES>-1 is the leftmost one)"));
1223 myTagProperties[currentTag].addAttribute(attrProperty);
1224
1227 TL("Speed in meters per second"),
1228 "13.89");
1229 myTagProperties[currentTag].addAttribute(attrProperty);
1230
1233 TL("Explicitly allows the given vehicle classes (not given will be not allowed)"),
1234 "all");
1235 myTagProperties[currentTag].addAttribute(attrProperty);
1236
1239 TL("Explicitly disallows the given vehicle classes (not given will be allowed)"));
1240 myTagProperties[currentTag].addAttribute(attrProperty);
1241
1244 TL("Width in meters (used for visualization)"),
1245 "-1");
1246 myTagProperties[currentTag].addAttribute(attrProperty);
1247
1250 TL("Move the stop line back from the intersection by the given amount"),
1251 "0.00");
1252 myTagProperties[currentTag].addAttribute(attrProperty);
1253
1256 TL("Enable or disable lane as acceleration lane"),
1257 "0");
1258 myTagProperties[currentTag].addAttribute(attrProperty);
1259
1262 TL("If the shape is given it overrides the computation based on edge shape"));
1263 myTagProperties[currentTag].addAttribute(attrProperty);
1264
1267 TL("If given, this defines the opposite direction lane"));
1268 myTagProperties[currentTag].addAttribute(attrProperty);
1269
1272 TL("Permit changing left only for to the given vehicle classes"),
1273 "all");
1274 attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings(), true);
1275 myTagProperties[currentTag].addAttribute(attrProperty);
1276
1279 TL("Permit changing right only for to the given vehicle classes"),
1280 "all");
1281 attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings(), true);
1282 myTagProperties[currentTag].addAttribute(attrProperty);
1283
1286 TL("Lane type description (optional)"));
1287 myTagProperties[currentTag].addAttribute(attrProperty);
1288
1291 TL("The stop offset as positive value in meters"),
1292 "0.00");
1293 myTagProperties[currentTag].addAttribute(attrProperty);
1294
1297 TL("Specifies, for which vehicle classes the stopOffset does NOT apply."));
1298 attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings(), false);
1299 myTagProperties[currentTag].addAttribute(attrProperty);
1300 }
1301 currentTag = SUMO_TAG_CROSSING;
1302 {
1303 // set values of tag
1304 myTagProperties[currentTag] = GNETagProperties(currentTag,
1306 0,
1307 GUIIcon::CROSSING, currentTag);
1308 // set values of attributes
1309 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1311 TL("Crossing ID"));
1312 myTagProperties[currentTag].addAttribute(attrProperty);
1313
1316 TL("The (road) edges which are crossed"));
1317 myTagProperties[currentTag].addAttribute(attrProperty);
1318
1321 TL("Whether the pedestrians have priority over the vehicles (automatically set to true at tls-controlled intersections)"),
1322 "0");
1323 myTagProperties[currentTag].addAttribute(attrProperty);
1324
1327 TL("The width of the crossings"),
1328 toString(OptionsCont::getOptions().getFloat("default.crossing-width")));
1329 myTagProperties[currentTag].addAttribute(attrProperty);
1330
1333 TL("sets the tls-index for this crossing"),
1334 "-1");
1335 myTagProperties[currentTag].addAttribute(attrProperty);
1336
1339 TL("sets the opposite-direction tls-index for this crossing"),
1340 "-1");
1341 myTagProperties[currentTag].addAttribute(attrProperty);
1342
1345 TL("Overrides default shape of pedestrian crossing"));
1346 myTagProperties[currentTag].addAttribute(attrProperty);
1347 }
1348 currentTag = SUMO_TAG_WALKINGAREA;
1349 {
1350 // set values of tag
1351 myTagProperties[currentTag] = GNETagProperties(currentTag,
1354 GUIIcon::WALKINGAREA, currentTag);
1355 // set values of attributes
1356 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1358 TL("Walking Area ID"));
1359 myTagProperties[currentTag].addAttribute(attrProperty);
1360
1363 TL("The width of the WalkingArea"),
1364 toString(OptionsCont::getOptions().getFloat("default.sidewalk-width")));
1365 myTagProperties[currentTag].addAttribute(attrProperty);
1366
1369 TL("The length of the WalkingArea in meter"));
1370 myTagProperties[currentTag].addAttribute(attrProperty);
1371
1374 TL("Overrides default shape of pedestrian sidewalk"));
1375 myTagProperties[currentTag].addAttribute(attrProperty);
1376 }
1377 currentTag = SUMO_TAG_CONNECTION;
1378 {
1379 // set values of tag
1380 myTagProperties[currentTag] = GNETagProperties(currentTag,
1382 0,
1383 GUIIcon::CONNECTION, currentTag);
1384 // set values of attributes
1387 TL("The ID of the edge the vehicles leave"));
1388 myTagProperties[currentTag].addAttribute(attrProperty);
1389
1390 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
1392 TL("The ID of the edge the vehicles may reach when leaving 'from'"));
1393 myTagProperties[currentTag].addAttribute(attrProperty);
1394
1397 TL("the lane index of the incoming lane (numbers starting with 0)"));
1398 myTagProperties[currentTag].addAttribute(attrProperty);
1399
1402 TL("the lane index of the outgoing lane (numbers starting with 0)"));
1403 myTagProperties[currentTag].addAttribute(attrProperty);
1404
1407 TL("if set, vehicles which pass this (lane-2-lane) connection) will not wait"),
1408 "0");
1409 myTagProperties[currentTag].addAttribute(attrProperty);
1410
1413 TL("if set to false, vehicles which pass this (lane-2-lane) connection) will not worry about blocking the intersection"),
1414 "0");
1415 myTagProperties[currentTag].addAttribute(attrProperty);
1416
1419 TL("If set to a more than 0 value, an internal junction will be built at this position (in m)/n from the start of the internal lane for this connection"),
1421 myTagProperties[currentTag].addAttribute(attrProperty);
1422
1425 TL("If set to true, This connection will not be TLS-controlled despite its node being controlled"),
1426 "0");
1427 myTagProperties[currentTag].addAttribute(attrProperty);
1428
1431 TL("Vision distance between vehicles"),
1433 myTagProperties[currentTag].addAttribute(attrProperty);
1434
1437 TL("sets index of this connection within the controlling traffic light"),
1438 "-1");
1439 myTagProperties[currentTag].addAttribute(attrProperty);
1440
1443 TL("sets index for the internal junction of this connection within the controlling traffic light"),
1444 "-1");
1445 myTagProperties[currentTag].addAttribute(attrProperty);
1446
1449 TL("Explicitly allows the given vehicle classes (not given will be not allowed)"),
1450 "all");
1451 myTagProperties[currentTag].addAttribute(attrProperty);
1452
1455 TL("Explicitly disallows the given vehicle classes (not given will be allowed)"));
1456 myTagProperties[currentTag].addAttribute(attrProperty);
1457
1460 TL("sets custom speed limit for the connection"),
1462 myTagProperties[currentTag].addAttribute(attrProperty);
1463
1466 TL("sets custom length for the connection"),
1468 myTagProperties[currentTag].addAttribute(attrProperty);
1469
1472 TL("sets custom shape for the connection"));
1473 myTagProperties[currentTag].addAttribute(attrProperty);
1474
1477 TL("Permit changing left only for to the given vehicle classes"),
1478 "all");
1479 attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings(), true);
1480 myTagProperties[currentTag].addAttribute(attrProperty);
1481
1484 TL("Permit changing right only for to the given vehicle classes"),
1485 "all");
1486 attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings(), true);
1487 myTagProperties[currentTag].addAttribute(attrProperty);
1488
1491 TL("if set to true, vehicles will make a turn in 2 steps"),
1492 "0");
1493 myTagProperties[currentTag].addAttribute(attrProperty);
1494
1497 TL("set a custom edge type (for applying vClass-specific speed restrictions)"));
1498 myTagProperties[currentTag].addAttribute(attrProperty);
1499
1500
1503 TL("turning direction for this connection (computed)"));
1504 myTagProperties[currentTag].addAttribute(attrProperty);
1505
1508 TL("link state for this connection (computed)"));
1509 myTagProperties[currentTag].addAttribute(attrProperty);
1510 }
1511 currentTag = GNE_TAG_INTERNAL_LANE;
1512 {
1513 // set values of tag
1514 myTagProperties[currentTag] = GNETagProperties(currentTag,
1516 0,
1517 GUIIcon::JUNCTION, currentTag);
1518 // internal lanes does't have attributes
1519 }
1520}
1521
1522
1523void
1525 // declare empty GNEAttributeProperties
1526 GNEAttributeProperties attrProperty;
1527 // fill additional elements
1528 SumoXMLTag currentTag = SUMO_TAG_BUS_STOP;
1529 {
1530 // set values of tag
1531 myTagProperties[currentTag] = GNETagProperties(currentTag,
1534 GUIIcon::BUSSTOP, currentTag, {}, FXRGBA(240, 255, 205, 255));
1535 // set values of attributes
1536 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1538 TL("The id of bus stop"));
1539 myTagProperties[currentTag].addAttribute(attrProperty);
1540
1543 TL("The name of the lane the bus stop shall be located at"));
1544 myTagProperties[currentTag].addAttribute(attrProperty);
1545
1548 TL("The begin position on the lane (the lower position on the lane) in meters"));
1549
1550 myTagProperties[currentTag].addAttribute(attrProperty);
1553 TL("The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m"));
1554 myTagProperties[currentTag].addAttribute(attrProperty);
1555
1558 TL("Name of busStop"));
1559 myTagProperties[currentTag].addAttribute(attrProperty);
1560
1563 TL("If set, no error will be reported if element is placed behind the lane.") + std::string("\n") +
1564 TL("Instead, it will be placed 0.1 meters from the lanes end or at position 0.1") + std::string("\n") +
1565 TL("if the position was negative and larger than the lanes length after multiplication with - 1"),
1566 "0");
1567 myTagProperties[currentTag].addAttribute(attrProperty);
1568
1571 TL("Meant to be the names of the bus lines that stop at this bus stop. This is only used for visualization purposes"));
1572 myTagProperties[currentTag].addAttribute(attrProperty);
1573
1576 TL("Larger numbers of persons trying to enter will create an upstream jam on the sidewalk"),
1577 "6");
1578 myTagProperties[currentTag].addAttribute(attrProperty);
1579
1582 TL("Optional space definition for vehicles that park at this stop"),
1583 "0.00");
1584 myTagProperties[currentTag].addAttribute(attrProperty);
1585
1588 TL("The RGBA color with which the busStop shall be displayed"));
1589 myTagProperties[currentTag].addAttribute(attrProperty);
1590
1591 }
1592 currentTag = SUMO_TAG_TRAIN_STOP;
1593 {
1594 // set values of tag
1595 myTagProperties[currentTag] = GNETagProperties(currentTag,
1598 GUIIcon::TRAINSTOP, currentTag, {}, FXRGBA(240, 255, 205, 255));
1599 // set values of attributes
1600 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1602 TL("The id of train stop"));
1603 myTagProperties[currentTag].addAttribute(attrProperty);
1604
1607 TL("The name of the lane the train stop shall be located at"));
1608 myTagProperties[currentTag].addAttribute(attrProperty);
1609
1612 TL("The begin position on the lane (the lower position on the lane) in meters"));
1613
1614 myTagProperties[currentTag].addAttribute(attrProperty);
1617 TL("The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m"));
1618 myTagProperties[currentTag].addAttribute(attrProperty);
1619
1622 TL("Name of trainStop"));
1623 myTagProperties[currentTag].addAttribute(attrProperty);
1624
1627 TL("If set, no error will be reported if element is placed behind the lane.") + std::string("\n") +
1628 TL("Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,") + std::string("\n") +
1629 TL("if the position was negative and larger than the lanes length after multiplication with - 1"),
1630 "0");
1631 myTagProperties[currentTag].addAttribute(attrProperty);
1632
1635 TL("Meant to be the names of the train lines that stop at this train stop. This is only used for visualization purposes"));
1636 myTagProperties[currentTag].addAttribute(attrProperty);
1637
1640 TL("Larger numbers of persons trying to enter will create an upstream jam on the sidewalk"),
1641 "6");
1642 myTagProperties[currentTag].addAttribute(attrProperty);
1643
1646 TL("Optional space definition for vehicles that park at this stop"),
1647 "0.00");
1648 myTagProperties[currentTag].addAttribute(attrProperty);
1649
1652 TL("The RGBA color with which the trainStop shall be displayed"));
1653 myTagProperties[currentTag].addAttribute(attrProperty);
1654
1655 }
1656 currentTag = SUMO_TAG_ACCESS;
1657 {
1658 // set values of tag
1659 myTagProperties[currentTag] = GNETagProperties(currentTag,
1662 GUIIcon::ACCESS, currentTag, {SUMO_TAG_BUS_STOP, SUMO_TAG_TRAIN_STOP}, FXRGBA(240, 255, 205, 255));
1663 // set values of attributes
1666 TL("The name of the lane the stop access shall be located at"));
1667 myTagProperties[currentTag].addAttribute(attrProperty);
1668
1671 TL("The position on the lane (the lower position on the lane) in meters"),
1672 "0.00");
1673 myTagProperties[currentTag].addAttribute(attrProperty);
1674
1677 TL("The walking length of the access in meters"),
1678 "-1.00");
1679 myTagProperties[currentTag].addAttribute(attrProperty);
1680
1683 TL("If set, no error will be reported if element is placed behind the lane.") + std::string("\n") +
1684 TL("Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,") + std::string("\n") +
1685 TL("if the position was negative and larger than the lanes length after multiplication with - 1"),
1686 "0");
1687 myTagProperties[currentTag].addAttribute(attrProperty);
1688
1689 }
1690 currentTag = SUMO_TAG_CONTAINER_STOP;
1691 {
1692 // set values of tag
1693 myTagProperties[currentTag] = GNETagProperties(currentTag,
1696 GUIIcon::CONTAINERSTOP, currentTag, {}, FXRGBA(240, 255, 205, 255));
1697 // set values of attributes
1698 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1700 TL("The id of container stop"));
1701 myTagProperties[currentTag].addAttribute(attrProperty);
1702
1705 TL("The name of the lane the container stop shall be located at"));
1706 myTagProperties[currentTag].addAttribute(attrProperty);
1707
1710 TL("The begin position on the lane (the lower position on the lane) in meters"));
1711 myTagProperties[currentTag].addAttribute(attrProperty);
1712
1715 TL("The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m"));
1716 myTagProperties[currentTag].addAttribute(attrProperty);
1717
1720 TL("Name of containerStop"));
1721 myTagProperties[currentTag].addAttribute(attrProperty);
1722
1725 TL("If set, no error will be reported if element is placed behind the lane.") + std::string("\n") +
1726 TL("Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,") + std::string("\n") +
1727 TL("if the position was negative and larger than the lanes length after multiplication with - 1"),
1728 "0");
1729 myTagProperties[currentTag].addAttribute(attrProperty);
1730
1733 TL("meant to be the names of the bus lines that stop at this container stop. This is only used for visualization purposes"));
1734 myTagProperties[currentTag].addAttribute(attrProperty);
1735
1738 TL("Larger numbers of container trying to enter will create an upstream jam on the sidewalk"),
1739 "6");
1740 myTagProperties[currentTag].addAttribute(attrProperty);
1741
1744 TL("Optional space definition for vehicles that park at this stop"),
1745 "0.00");
1746 myTagProperties[currentTag].addAttribute(attrProperty);
1747
1750 TL("The RGBA color with which the containerStop shall be displayed"));
1751 myTagProperties[currentTag].addAttribute(attrProperty);
1752 }
1753 currentTag = SUMO_TAG_CHARGING_STATION;
1754 {
1755 // set values of tag
1756 myTagProperties[currentTag] = GNETagProperties(currentTag,
1759 GUIIcon::CHARGINGSTATION, currentTag, {}, FXRGBA(240, 255, 205, 255));
1760 // set values of attributes
1761 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1763 TL("The id of charging station"));
1764 myTagProperties[currentTag].addAttribute(attrProperty);
1765
1768 TL("Lane of the charging station location"));
1769 myTagProperties[currentTag].addAttribute(attrProperty);
1770
1773 TL("Begin position in the specified lane"));
1774 myTagProperties[currentTag].addAttribute(attrProperty);
1775
1778 TL("End position in the specified lane"));
1779 myTagProperties[currentTag].addAttribute(attrProperty);
1780
1783 TL("Name of chargingStation"));
1784 myTagProperties[currentTag].addAttribute(attrProperty);
1785
1788 TL("If set, no error will be reported if element is placed behind the lane.") + std::string("\n") +
1789 TL("Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,") + std::string("\n") +
1790 TL("if the position was negative and larger than the lanes length after multiplication with - 1"),
1791 "0");
1792 myTagProperties[currentTag].addAttribute(attrProperty);
1793
1796 TL("Charging power in W"),
1797 "22000.00");
1798 myTagProperties[currentTag].addAttribute(attrProperty);
1799
1802 TL("Charging efficiency [0,1]"),
1803 "0.95");
1804 attrProperty.setRange(0, 1);
1805 myTagProperties[currentTag].addAttribute(attrProperty);
1806
1809 TL("Enable or disable charge in transit, i.e. vehicle must or must not to stop for charging"),
1810 "0");
1811 myTagProperties[currentTag].addAttribute(attrProperty);
1812
1815 TL("Time delay after the vehicles has reached / stopped on the charging station, before the energy transfer (charging) begins"),
1816 "0.00");
1817 myTagProperties[currentTag].addAttribute(attrProperty);
1818 }
1819 currentTag = SUMO_TAG_PARKING_AREA;
1820 {
1821 // set values of tag
1822 myTagProperties[currentTag] = GNETagProperties(currentTag,
1825 GUIIcon::PARKINGAREA, currentTag, {}, FXRGBA(240, 255, 205, 255));
1826 // set values of attributes
1827 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1829 TL("The id of ParkingArea"));
1830 myTagProperties[currentTag].addAttribute(attrProperty);
1831
1834 TL("The name of the lane the Parking Area shall be located at"));
1835 myTagProperties[currentTag].addAttribute(attrProperty);
1836
1839 TL("The begin position on the lane (the lower position on the lane) in meters"));
1840 myTagProperties[currentTag].addAttribute(attrProperty);
1841
1844 TL("The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m"));
1845 myTagProperties[currentTag].addAttribute(attrProperty);
1846
1849 TL("Lane position in that vehicle must depart when leaves parkingArea"));
1850 myTagProperties[currentTag].addAttribute(attrProperty);
1851
1854 TL("Name of parkingArea"));
1855 myTagProperties[currentTag].addAttribute(attrProperty);
1856
1859 TL(" The number of parking spaces for road-side parking"),
1860 "0");
1861 myTagProperties[currentTag].addAttribute(attrProperty);
1862
1865 TL("If set, vehicles will park on the road lane and thereby reducing capacity"),
1866 "0");
1867 myTagProperties[currentTag].addAttribute(attrProperty);
1868
1871 TL("If set, no error will be reported if element is placed behind the lane.") + std::string("\n") +
1872 TL("Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,") + std::string("\n") +
1873 TL("if the position was negative and larger than the lanes length after multiplication with - 1"),
1874 "0");
1875 myTagProperties[currentTag].addAttribute(attrProperty);
1876
1879 TL("The width of the road-side parking spaces"),
1881 myTagProperties[currentTag].addAttribute(attrProperty);
1882
1885 TL("The length of the road-side parking spaces. By default (endPos - startPos) / roadsideCapacity"),
1886 "0.00");
1887 myTagProperties[currentTag].addAttribute(attrProperty);
1888
1891 TL("The angle of the road-side parking spaces relative to the lane angle, positive means clockwise"),
1892 "0.00");
1893 myTagProperties[currentTag].addAttribute(attrProperty);
1894
1897 TL("Enable or disable lefthand position"),
1898 "0");
1899 myTagProperties[currentTag].addAttribute(attrProperty);
1900
1901 }
1902 currentTag = SUMO_TAG_PARKING_SPACE;
1903 {
1904 // set values of tag
1905 myTagProperties[currentTag] = GNETagProperties(currentTag,
1908 GUIIcon::PARKINGSPACE, currentTag, {SUMO_TAG_PARKING_AREA}, FXRGBA(240, 255, 205, 255));
1909 // set values of attributes
1911 GNEAttributeProperties::STRING | GNEAttributeProperties::UNIQUE | GNEAttributeProperties::POSITION | GNEAttributeProperties::UPDATEGEOMETRY, // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
1912 TL("The x-y-z position of the node on the plane in meters"));
1913 myTagProperties[currentTag].addAttribute(attrProperty);
1914
1917 TL("Name of parking space"));
1918 myTagProperties[currentTag].addAttribute(attrProperty);
1919
1922 TL("The width of the road-side parking spaces"));
1923 myTagProperties[currentTag].addAttribute(attrProperty);
1924
1927 TL("The length of the road-side parking spaces"));
1928 myTagProperties[currentTag].addAttribute(attrProperty);
1929
1932 TL("The angle of the road-side parking spaces relative to the lane angle, positive means clockwise"));
1933 myTagProperties[currentTag].addAttribute(attrProperty);
1934
1937 TL("The slope of the road-side parking spaces"),
1938 "0.00");
1939 myTagProperties[currentTag].addAttribute(attrProperty);
1940
1941 }
1942 currentTag = SUMO_TAG_INDUCTION_LOOP;
1943 {
1944 // set values of tag
1945 myTagProperties[currentTag] = GNETagProperties(currentTag,
1947 0,
1948 GUIIcon::E1, currentTag, {}, FXRGBA(210, 233, 255, 255));
1949 // set values of attributes
1950 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1952 TL("The id of E1"));
1953 myTagProperties[currentTag].addAttribute(attrProperty);
1954
1957 TL("The id of the lane the detector shall be laid on. The lane must be a part of the network used"));
1958 myTagProperties[currentTag].addAttribute(attrProperty);
1959
1962 TL("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"));
1963 myTagProperties[currentTag].addAttribute(attrProperty);
1964
1967 TL("The aggregation period the values the detector collects shall be summed up"),
1968 "300.00");
1969 myTagProperties[currentTag].addAttribute(attrProperty);
1970
1973 TL("Name of induction loop"));
1974 myTagProperties[currentTag].addAttribute(attrProperty);
1975
1978 TL("The path to the output file"));
1979 myTagProperties[currentTag].addAttribute(attrProperty);
1980
1983 TL("Space separated list of vehicle type ids to consider"));
1984 myTagProperties[currentTag].addAttribute(attrProperty);
1985
1988 TL("If set, no error will be reported if element is placed behind the lane.") + std::string("\n") +
1989 TL("Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,") + std::string("\n") +
1990 TL("if the position was negative and larger than the lanes length after multiplication with - 1"),
1991 "0");
1992 myTagProperties[currentTag].addAttribute(attrProperty);
1993 }
1994 currentTag = SUMO_TAG_LANE_AREA_DETECTOR;
1995 {
1996 // set values of tag
1997 myTagProperties[currentTag] = GNETagProperties(currentTag,
1999 0,
2000 GUIIcon::E2, currentTag, {}, FXRGBA(210, 233, 255, 255));
2001 // set values of attributes
2002 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2004 TL("The id of E2"));
2005 myTagProperties[currentTag].addAttribute(attrProperty);
2006
2009 TL("The id of the lane the detector shall be laid on. The lane must be a part of the network used"));
2010 myTagProperties[currentTag].addAttribute(attrProperty);
2011
2014 TL("The position on the lane the detector shall be laid on in meters"));
2015 myTagProperties[currentTag].addAttribute(attrProperty);
2016
2019 TL("The length of the detector in meters"),
2020 "10.00");
2021 myTagProperties[currentTag].addAttribute(attrProperty);
2022
2025 TL("The aggregation period the values the detector collects shall be summed up"),
2026 "300.00");
2027 myTagProperties[currentTag].addAttribute(attrProperty);
2028
2031 TL("The traffic light that triggers aggregation when switching"));
2032 myTagProperties[currentTag].addAttribute(attrProperty);
2033
2036 TL("Name of lane area detector"));
2037 myTagProperties[currentTag].addAttribute(attrProperty);
2038
2041 TL("The path to the output file"));
2042 myTagProperties[currentTag].addAttribute(attrProperty);
2043
2046 TL("Space separated list of vehicle type ids to consider"));
2047 myTagProperties[currentTag].addAttribute(attrProperty);
2048
2051 TL("The time-based threshold that describes how much time has to pass until a vehicle is recognized as halting)"),
2052 "1.00");
2053 myTagProperties[currentTag].addAttribute(attrProperty);
2054
2057 TL("The speed-based threshold that describes how slow a vehicle has to be to be recognized as halting) in m/s"),
2058 "1.39");
2059 myTagProperties[currentTag].addAttribute(attrProperty);
2060
2063 TL("The minimum distance to the next standing vehicle in order to make this vehicle count as a participant to the jam) in m"),
2064 "10.00");
2065 myTagProperties[currentTag].addAttribute(attrProperty);
2066
2069 TL("If set, no error will be reported if element is placed behind the lane.") + std::string("\n") +
2070 TL("Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,") + std::string("\n") +
2071 TL("if the position was negative and larger than the lanes length after multiplication with - 1"),
2072 "0");
2073 myTagProperties[currentTag].addAttribute(attrProperty);
2074 }
2076 {
2077 // set values of tag
2078 myTagProperties[currentTag] = GNETagProperties(currentTag,
2080 0,
2081 GUIIcon::E2, SUMO_TAG_LANE_AREA_DETECTOR, {}, FXRGBA(210, 233, 255, 255));
2082 // set values of attributes
2083 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2085 TL("The id of Multilane E2"));
2086 myTagProperties[currentTag].addAttribute(attrProperty);
2087
2090 TL("The sequence of lane ids in which the detector shall be laid on"));
2091 myTagProperties[currentTag].addAttribute(attrProperty);
2092
2095 TL("The position on the lane the detector shall be laid on in meters"));
2096 myTagProperties[currentTag].addAttribute(attrProperty);
2097
2100 TL("The end position on the lane the detector shall be laid on in meters"));
2101 myTagProperties[currentTag].addAttribute(attrProperty);
2102
2105 TL("The aggregation period the values the detector collects shall be summed up"),
2106 "300.00");
2107 myTagProperties[currentTag].addAttribute(attrProperty);
2108
2111 TL("The traffic light that triggers aggregation when switching"));
2112 myTagProperties[currentTag].addAttribute(attrProperty);
2113
2116 TL("Name of Multilane E2 detector"));
2117 myTagProperties[currentTag].addAttribute(attrProperty);
2118
2121 TL("The path to the output file"));
2122 myTagProperties[currentTag].addAttribute(attrProperty);
2123
2126 TL("Space separated list of vehicle type ids to consider"));
2127 myTagProperties[currentTag].addAttribute(attrProperty);
2128
2131 TL("The time-based threshold that describes how much time has to pass until a vehicle is recognized as halting)"),
2132 "1.00");
2133 myTagProperties[currentTag].addAttribute(attrProperty);
2134
2137 TL("The speed-based threshold that describes how slow a vehicle has to be to be recognized as halting) in m/s"),
2138 "1.39");
2139 myTagProperties[currentTag].addAttribute(attrProperty);
2140
2143 TL("The minimum distance to the next standing vehicle in order to make this vehicle count as a participant to the jam) in m"),
2144 "10.00");
2145 myTagProperties[currentTag].addAttribute(attrProperty);
2146
2149 TL("If set, no error will be reported if element is placed behind the lane.") + std::string("\n") +
2150 TL("Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,") + std::string("\n") +
2151 TL("if the position was negative and larger than the lanes length after multiplication with - 1"),
2152 "0");
2153 myTagProperties[currentTag].addAttribute(attrProperty);
2154
2155 }
2156 currentTag = SUMO_TAG_ENTRY_EXIT_DETECTOR;
2157 {
2158 // set values of tag
2159 myTagProperties[currentTag] = GNETagProperties(currentTag,
2162 GUIIcon::E3, currentTag, {}, FXRGBA(210, 233, 255, 255));
2163 // set values of attributes
2164 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2166 TL("The id of E3"));
2167 myTagProperties[currentTag].addAttribute(attrProperty);
2168
2171 TL("X-Y position of detector in editor (Only used in netedit)"),
2172 "0,0"); // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
2173 myTagProperties[currentTag].addAttribute(attrProperty);
2174
2177 TL("The aggregation period the values the detector collects shall be summed up"),
2178 "300.00");
2179 myTagProperties[currentTag].addAttribute(attrProperty);
2180
2183 TL("Name of Entry Exit detector"));
2184 myTagProperties[currentTag].addAttribute(attrProperty);
2185
2188 TL("The path to the output file"));
2189 myTagProperties[currentTag].addAttribute(attrProperty);
2190
2193 TL("Space separated list of vehicle type ids to consider"));
2194 myTagProperties[currentTag].addAttribute(attrProperty);
2195
2198 TL("The time-based threshold that describes how much time has to pass until a vehicle is recognized as halting) in s"),
2199 "1.00");
2200 myTagProperties[currentTag].addAttribute(attrProperty);
2201
2204 TL("The speed-based threshold that describes how slow a vehicle has to be to be recognized as halting) in m/s"),
2205 "1.39");
2206 myTagProperties[currentTag].addAttribute(attrProperty);
2207 }
2208 currentTag = SUMO_TAG_DET_ENTRY;
2209 {
2210 // set values of tag
2211 myTagProperties[currentTag] = GNETagProperties(currentTag,
2214 GUIIcon::E3ENTRY, currentTag, {SUMO_TAG_ENTRY_EXIT_DETECTOR}, FXRGBA(210, 233, 255, 255));
2215 // set values of attributes
2218 TL("The id of the lane the detector shall be laid on. The lane must be a part of the network used"));
2219 myTagProperties[currentTag].addAttribute(attrProperty);
2220
2223 TL("The position on the lane the detector shall be laid on in meters"));
2224 myTagProperties[currentTag].addAttribute(attrProperty);
2225
2228 TL("If set, no error will be reported if element is placed behind the lane.") + std::string("\n") +
2229 TL("Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,") + std::string("\n") +
2230 TL("if the position was negative and larger than the lanes length after multiplication with - 1"),
2231 "0");
2232 myTagProperties[currentTag].addAttribute(attrProperty);
2233
2234 }
2235 currentTag = SUMO_TAG_DET_EXIT;
2236 {
2237 // set values of tag
2238 myTagProperties[currentTag] = GNETagProperties(currentTag,
2241 GUIIcon::E3EXIT, currentTag, {SUMO_TAG_ENTRY_EXIT_DETECTOR}, FXRGBA(210, 233, 255, 255));
2242 // set values of attributes
2245 TL("The id of the lane the detector shall be laid on. The lane must be a part of the network used"));
2246 myTagProperties[currentTag].addAttribute(attrProperty);
2247
2250 TL("The position on the lane the detector shall be laid on in meters"));
2251 myTagProperties[currentTag].addAttribute(attrProperty);
2252
2255 TL("If set, no error will be reported if element is placed behind the lane.") + std::string("\n") +
2256 TL("Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,") + std::string("\n") +
2257 TL("if the position was negative and larger than the lanes length after multiplication with - 1"),
2258 "0");
2259 myTagProperties[currentTag].addAttribute(attrProperty);
2260
2261 }
2263 {
2264 // set values of tag
2265 myTagProperties[currentTag] = GNETagProperties(currentTag,
2267 0,
2268 GUIIcon::E1INSTANT, currentTag, {}, FXRGBA(210, 233, 255, 255));
2269 // set values of attributes
2270 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2272 TL("The id of Instant Induction Loop (E1Instant)"));
2273 myTagProperties[currentTag].addAttribute(attrProperty);
2274
2277 TL("The id of the lane the detector shall be laid on. The lane must be a part of the network used"));
2278 myTagProperties[currentTag].addAttribute(attrProperty);
2279
2282 TL("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"));
2283 myTagProperties[currentTag].addAttribute(attrProperty);
2284
2287 TL("Name of instant induction loop"));
2288 myTagProperties[currentTag].addAttribute(attrProperty);
2289
2292 TL("The path to the output file"));
2293 myTagProperties[currentTag].addAttribute(attrProperty);
2294
2297 TL("Space separated list of vehicle type ids to consider"));
2298 myTagProperties[currentTag].addAttribute(attrProperty);
2299
2302 TL("If set, no error will be reported if element is placed behind the lane.") + std::string("\n") +
2303 TL("Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,") + std::string("\n") +
2304 TL("if the position was negative and larger than the lanes length after multiplication with - 1"),
2305 "0");
2306 myTagProperties[currentTag].addAttribute(attrProperty);
2307 }
2308 currentTag = SUMO_TAG_ROUTEPROBE;
2309 {
2310 // set values of tag
2311 myTagProperties[currentTag] = GNETagProperties(currentTag,
2314 GUIIcon::ROUTEPROBE, currentTag, {}, FXRGBA(210, 233, 255, 255));
2315 // set values of attributes
2316 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2318 TL("The id of RouteProbe"));
2319 myTagProperties[currentTag].addAttribute(attrProperty);
2320
2323 TL("The id of an edge in the simulation network"));
2324 myTagProperties[currentTag].addAttribute(attrProperty);
2325
2328 TL("The frequency in which to report the distribution"),
2329 "3600.00");
2330 myTagProperties[currentTag].addAttribute(attrProperty);
2331
2334 TL("Name of route probe"));
2335 myTagProperties[currentTag].addAttribute(attrProperty);
2336
2339 TL("The file for generated output"));
2340 myTagProperties[currentTag].addAttribute(attrProperty);
2341
2344 TL("The time at which to start generating output"),
2345 "0");
2346 myTagProperties[currentTag].addAttribute(attrProperty);
2347 }
2348 currentTag = SUMO_TAG_VSS;
2349 {
2350 // set values of tag
2351 myTagProperties[currentTag] = GNETagProperties(currentTag,
2354 GUIIcon::VARIABLESPEEDSIGN, currentTag, {}, FXRGBA(210, 233, 255, 255));
2355 // set values of attributes
2356 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2358 TL("The id of Variable Speed Signal"));
2359 myTagProperties[currentTag].addAttribute(attrProperty);
2360
2363 TL("X-Y position of detector in editor (Only used in netedit)"),
2364 "0,0"); // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
2365 myTagProperties[currentTag].addAttribute(attrProperty);
2366
2369 TL("List of Variable Speed Sign lanes"));
2370 myTagProperties[currentTag].addAttribute(attrProperty);
2371
2374 TL("Name of Variable Speed Signal"));
2375 myTagProperties[currentTag].addAttribute(attrProperty);
2376
2379 TL("Space separated list of vehicle type ids to consider (empty to affect all types)"));
2380 myTagProperties[currentTag].addAttribute(attrProperty);
2381 }
2382 currentTag = GNE_TAG_VSS_SYMBOL;
2383 {
2384 // set values of tag
2385 myTagProperties[currentTag] = GNETagProperties(currentTag,
2388 GUIIcon::LANE, currentTag, {SUMO_TAG_VSS}, FXRGBA(210, 233, 255, 255));
2389 }
2390 currentTag = SUMO_TAG_STEP;
2391 {
2392 // set values of tag
2393 myTagProperties[currentTag] = GNETagProperties(currentTag,
2396 GUIIcon::VSSSTEP, currentTag, {SUMO_TAG_VSS}, FXRGBA(210, 233, 255, 255));
2397 // set values of attributes
2400 TL("Time"));
2401 myTagProperties[currentTag].addAttribute(attrProperty);
2402
2405 TL("Speed"),
2406 "13.89");
2407 myTagProperties[currentTag].addAttribute(attrProperty);
2408 }
2409 currentTag = SUMO_TAG_CALIBRATOR;
2410 {
2411 // set values of tag
2412 myTagProperties[currentTag] = GNETagProperties(currentTag,
2415 GUIIcon::CALIBRATOR, currentTag, {}, FXRGBA(253, 255, 206, 255));
2416 // set values of attributes
2417 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2419 TL("The id of Calibrator"));
2420 myTagProperties[currentTag].addAttribute(attrProperty);
2421
2424 TL("The id of edge in the simulation network"));
2425 myTagProperties[currentTag].addAttribute(attrProperty);
2426
2429 TL("The position of the calibrator on the specified lane"),
2430 "0.00");
2431 myTagProperties[currentTag].addAttribute(attrProperty);
2432
2435 TL("The aggregation interval in which to calibrate the flows. Default is step-length"),
2436 "1.00");
2437 myTagProperties[currentTag].addAttribute(attrProperty);
2438
2441 TL("Name of Calibrator"));
2442 myTagProperties[currentTag].addAttribute(attrProperty);
2443
2446 TL("The id of the routeProbe element from which to determine the route distribution for generated vehicles"));
2447 myTagProperties[currentTag].addAttribute(attrProperty);
2448
2451 TL("The output file for writing calibrator information or NULL"));
2452 myTagProperties[currentTag].addAttribute(attrProperty);
2453
2456 TL("A threshold value to detect and clear unexpected jamming"),
2457 "0.50");
2458 myTagProperties[currentTag].addAttribute(attrProperty);
2459
2462 TL("space separated list of vehicle type ids to consider (empty to affect all types)"));
2463 myTagProperties[currentTag].addAttribute(attrProperty);
2464 }
2465 currentTag = GNE_TAG_CALIBRATOR_LANE;
2466 {
2467 // set values of tag
2468 myTagProperties[currentTag] = GNETagProperties(currentTag,
2471 GUIIcon::CALIBRATOR, SUMO_TAG_CALIBRATOR, {}, FXRGBA(253, 255, 206, 255));
2472 // set values of attributes
2473 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2475 TL("The id of Calibrator"));
2476 myTagProperties[currentTag].addAttribute(attrProperty);
2477
2480 TL("The id of lane in the simulation network"));
2481 myTagProperties[currentTag].addAttribute(attrProperty);
2482
2485 TL("The position of the calibrator on the specified lane"),
2486 "0.00");
2487 myTagProperties[currentTag].addAttribute(attrProperty);
2488
2491 TL("The aggregation interval in which to calibrate the flows. Default is step-length"),
2492 "1.00");
2493 myTagProperties[currentTag].addAttribute(attrProperty);
2494
2497 TL("Name of calibrator lane"));
2498 myTagProperties[currentTag].addAttribute(attrProperty);
2499
2502 TL("The id of the routeProbe element from which to determine the route distribution for generated vehicles"));
2503 myTagProperties[currentTag].addAttribute(attrProperty);
2504
2507 TL("The output file for writing calibrator information or NULL"));
2508 myTagProperties[currentTag].addAttribute(attrProperty);
2509
2512 TL("A threshold value to detect and clear unexpected jamming"),
2513 "0.50");
2514 myTagProperties[currentTag].addAttribute(attrProperty);
2515
2518 TL("space separated list of vehicle type ids to consider (empty to affect all types)"));
2519 myTagProperties[currentTag].addAttribute(attrProperty);
2520 }
2521 currentTag = GNE_TAG_CALIBRATOR_FLOW;
2522 {
2523 // set values of tag
2524 myTagProperties[currentTag] = GNETagProperties(currentTag,
2527 GUIIcon::FLOW, SUMO_TAG_FLOW, {SUMO_TAG_CALIBRATOR}, FXRGBA(253, 255, 206, 255));
2528 // set values of attributes
2531 TL("The id of the route the vehicle shall drive along"));
2532 myTagProperties[currentTag].addAttribute(attrProperty);
2533
2536 TL("First calibrator flow departure time"),
2537 "0");
2538 myTagProperties[currentTag].addAttribute(attrProperty);
2539
2542 TL("End of departure interval"),
2543 "3600");
2544 myTagProperties[currentTag].addAttribute(attrProperty);
2545
2546 // fill common vehicle attributes
2547 fillCommonVehicleAttributes(currentTag);
2548
2549 // optional attributes (at least one must be defined)
2552 TL("The id of the vehicle type to use for this calibrator flow"),
2554 myTagProperties[currentTag].addAttribute(attrProperty);
2555
2558 TL("Number of vehicles per hour, equally spaced"),
2559 "1800");
2560 myTagProperties[currentTag].addAttribute(attrProperty);
2561
2564 TL("Vehicle's speed"),
2565 "15.0");
2566 myTagProperties[currentTag].addAttribute(attrProperty);
2567 }
2568 currentTag = SUMO_TAG_REROUTER;
2569 {
2570 // set values of tag
2571 myTagProperties[currentTag] = GNETagProperties(currentTag,
2574 GUIIcon::REROUTER, currentTag, {}, FXRGBA(255, 213, 213, 255));
2575
2576 // set values of attributes
2577 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2579 TL("The id of Rerouter"));
2580 myTagProperties[currentTag].addAttribute(attrProperty);
2581
2584 TL("An edge id or a list of edge ids where vehicles shall be rerouted"));
2585 myTagProperties[currentTag].addAttribute(attrProperty);
2586
2589 TL("X,Y position in editor (Only used in netedit)"),
2590 "0,0"); // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
2591 myTagProperties[currentTag].addAttribute(attrProperty);
2592
2595 TL("Name of Rerouter"));
2596 myTagProperties[currentTag].addAttribute(attrProperty);
2597
2600 TL("The probability for vehicle rerouting (0-1)"),
2601 "1.00");
2602 myTagProperties[currentTag].addAttribute(attrProperty);
2603
2606 TL("The waiting time threshold (in s) that must be reached to activate rerouting (default -1 which disables the threshold)"),
2607 "0.00");
2608 myTagProperties[currentTag].addAttribute(attrProperty);
2609
2612 TL("The list of vehicle types that shall be affected by this rerouter (empty to affect all types)"));
2613 myTagProperties[currentTag].addAttribute(attrProperty);
2614
2617 TL("Whether the router should be inactive initially (and switched on in the gui)"),
2618 "0");
2619 myTagProperties[currentTag].addAttribute(attrProperty);
2620 }
2621 currentTag = GNE_TAG_REROUTER_SYMBOL;
2622 {
2623 // set values of tag
2624 myTagProperties[currentTag] = GNETagProperties(currentTag,
2627 GUIIcon::EDGE, currentTag, {GNE_TAG_REROUTER_SYMBOL}, FXRGBA(255, 213, 213, 255));
2628 }
2629 currentTag = SUMO_TAG_INTERVAL;
2630 {
2631 // set values of tag
2632 myTagProperties[currentTag] = GNETagProperties(currentTag,
2635 GUIIcon::REROUTERINTERVAL, currentTag, {SUMO_TAG_REROUTER}, FXRGBA(255, 213, 213, 255));
2636 // set values of attributes
2639 TL("Begin"),
2640 "0");
2641 myTagProperties[currentTag].addAttribute(attrProperty);
2642
2645 TL("End"),
2646 "3600");
2647 myTagProperties[currentTag].addAttribute(attrProperty);
2648 }
2649 currentTag = SUMO_TAG_CLOSING_REROUTE;
2650 {
2651 // set values of tag
2652 myTagProperties[currentTag] = GNETagProperties(currentTag,
2655 GUIIcon::CLOSINGREROUTE, currentTag, {SUMO_TAG_INTERVAL}, FXRGBA(255, 213, 213, 255));
2656 // set values of attributes
2659 TL("Edge ID"));
2660 attrProperty.setSynonym(SUMO_ATTR_ID);
2661 myTagProperties[currentTag].addAttribute(attrProperty);
2662
2665 TL("allowed vehicles"));
2666 myTagProperties[currentTag].addAttribute(attrProperty);
2667
2670 TL("disallowed vehicles"));
2671 myTagProperties[currentTag].addAttribute(attrProperty);
2672 }
2673 currentTag = SUMO_TAG_CLOSING_LANE_REROUTE;
2674 {
2675 // set values of tag
2676 myTagProperties[currentTag] = GNETagProperties(currentTag,
2679 GUIIcon::CLOSINGLANEREROUTE, currentTag, {SUMO_TAG_INTERVAL}, FXRGBA(255, 213, 213, 255));
2680 // set values of attributes
2683 TL("Lane ID"));
2684 attrProperty.setSynonym(SUMO_ATTR_ID);
2685 myTagProperties[currentTag].addAttribute(attrProperty);
2686
2689 TL("allowed vehicles"));
2690 myTagProperties[currentTag].addAttribute(attrProperty);
2691
2694 TL("disallowed vehicles"));
2695 myTagProperties[currentTag].addAttribute(attrProperty);
2696 }
2697 currentTag = SUMO_TAG_DEST_PROB_REROUTE;
2698 {
2699 // set values of tag
2700 myTagProperties[currentTag] = GNETagProperties(currentTag,
2703 GUIIcon::DESTPROBREROUTE, currentTag, {SUMO_TAG_INTERVAL}, FXRGBA(255, 213, 213, 255));
2704 // set values of attributes
2707 TL("Edge ID"));
2708 attrProperty.setSynonym(SUMO_ATTR_ID);
2709 myTagProperties[currentTag].addAttribute(attrProperty);
2710
2713 TL("SUMO Probability"),
2714 "1.00");
2715 myTagProperties[currentTag].addAttribute(attrProperty);
2716 }
2717 currentTag = SUMO_TAG_PARKING_AREA_REROUTE;
2718 {
2719 // set values of tag
2720 myTagProperties[currentTag] = GNETagProperties(currentTag,
2723 GUIIcon::PARKINGZONEREROUTE, currentTag, {SUMO_TAG_INTERVAL}, FXRGBA(255, 213, 213, 255));
2724 // set values of attributes
2727 TL("ParkingArea ID"));
2728 attrProperty.setSynonym(SUMO_ATTR_ID);
2729 myTagProperties[currentTag].addAttribute(attrProperty);
2730
2733 TL("SUMO Probability"),
2734 "1.00");
2735 myTagProperties[currentTag].addAttribute(attrProperty);
2736
2739 TL("Enable or disable visibility for parking area reroutes"),
2740 "1");
2741 myTagProperties[currentTag].addAttribute(attrProperty);
2742 }
2743 currentTag = SUMO_TAG_ROUTE_PROB_REROUTE;
2744 {
2745 // set values of tag
2746 myTagProperties[currentTag] = GNETagProperties(currentTag,
2749 GUIIcon::ROUTEPROBREROUTE, currentTag, {SUMO_TAG_INTERVAL}, FXRGBA(255, 213, 213, 255));
2750 // set values of attributes
2753 TL("Route"));
2754 attrProperty.setSynonym(SUMO_ATTR_ID);
2755 myTagProperties[currentTag].addAttribute(attrProperty);
2756
2759 TL("SUMO Probability"),
2760 "1.00");
2761 myTagProperties[currentTag].addAttribute(attrProperty);
2762 }
2763 currentTag = SUMO_TAG_VAPORIZER;
2764 {
2765 // set values of tag
2766 myTagProperties[currentTag] = GNETagProperties(currentTag,
2769 GUIIcon::VAPORIZER, currentTag, {}, FXRGBA(253, 255, 206, 255));
2770 // set values of attributes
2771 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2773 TL("Edge in which vaporizer is placed"));
2774 myTagProperties[currentTag].addAttribute(attrProperty);
2775
2778 TL("Start Time"),
2779 "0");
2780 myTagProperties[currentTag].addAttribute(attrProperty);
2781
2784 TL("End Time"),
2785 "3600");
2786 myTagProperties[currentTag].addAttribute(attrProperty);
2787
2790 TL("Name of vaporizer"));
2791 myTagProperties[currentTag].addAttribute(attrProperty);
2792 }
2793}
2794
2795
2796void
2798 // declare empty GNEAttributeProperties
2799 GNEAttributeProperties attrProperty;
2800 // fill shape ACs
2801 SumoXMLTag currentTag = SUMO_TAG_POLY;
2802 {
2803 // set values of tag
2804 myTagProperties[currentTag] = GNETagProperties(currentTag,
2807 GUIIcon::POLY, currentTag);
2808 // set values of attributes
2809 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2811 TL("The id of the polygon"));
2812 myTagProperties[currentTag].addAttribute(attrProperty);
2813
2816 TL("The shape of the polygon"));
2817 myTagProperties[currentTag].addAttribute(attrProperty);
2818
2821 TL("The RGBA color with which the polygon shall be displayed"),
2822 "red");
2823 myTagProperties[currentTag].addAttribute(attrProperty);
2824
2827 TL("An information whether the polygon shall be filled"),
2828 "0");
2829 myTagProperties[currentTag].addAttribute(attrProperty);
2830
2833 TL("The default line width for drawing an unfilled polygon"),
2834 "1");
2835 myTagProperties[currentTag].addAttribute(attrProperty);
2836
2839 TL("The layer in which the polygon lies"),
2841 myTagProperties[currentTag].addAttribute(attrProperty);
2842
2845 TL("A typename for the polygon"),
2847 myTagProperties[currentTag].addAttribute(attrProperty);
2848
2851 TL("Polygon's name"));
2852 myTagProperties[currentTag].addAttribute(attrProperty);
2853
2856 TL("A bitmap to use for rendering this polygon"),
2858 myTagProperties[currentTag].addAttribute(attrProperty);
2859
2862 TL("Enable or disable use image file as a relative path"),
2864 myTagProperties[currentTag].addAttribute(attrProperty);
2865
2868 TL("Angle of rendered image in degree"),
2870 myTagProperties[currentTag].addAttribute(attrProperty);
2871 }
2872 currentTag = SUMO_TAG_POI;
2873 {
2874 // set values of tag
2875 myTagProperties[currentTag] = GNETagProperties(currentTag,
2878 GUIIcon::POI, currentTag);
2879 // set values of attributes
2880 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2882 TL("The id of the POI"));
2883 myTagProperties[currentTag].addAttribute(attrProperty);
2884
2886 GNEAttributeProperties::STRING | GNEAttributeProperties::POSITION | GNEAttributeProperties::UNIQUE | GNEAttributeProperties::UPDATEGEOMETRY, // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
2887 TL("The position in view"));
2888 myTagProperties[currentTag].addAttribute(attrProperty);
2889
2892 TL("The color with which the POI shall be displayed"),
2893 "red");
2894 myTagProperties[currentTag].addAttribute(attrProperty);
2895
2898 TL("A typename for the POI"),
2900 myTagProperties[currentTag].addAttribute(attrProperty);
2901
2904 TL("Name of POI"));
2905 myTagProperties[currentTag].addAttribute(attrProperty);
2906
2909 TL("The layer of the POI for drawing and selecting"),
2911 myTagProperties[currentTag].addAttribute(attrProperty);
2912
2915 TL("Width of rendered image in meters"),
2917 myTagProperties[currentTag].addAttribute(attrProperty);
2918
2921 TL("Height of rendered image in meters"),
2923 myTagProperties[currentTag].addAttribute(attrProperty);
2924
2927 TL("A bitmap to use for rendering this POI"),
2929 myTagProperties[currentTag].addAttribute(attrProperty);
2930
2933 TL("Enable or disable use image file as a relative path"),
2935 myTagProperties[currentTag].addAttribute(attrProperty);
2936
2939 TL("Angle of rendered image in degree"),
2941 myTagProperties[currentTag].addAttribute(attrProperty);
2942 }
2943 currentTag = GNE_TAG_POILANE;
2944 {
2945 // set values of tag
2946 myTagProperties[currentTag] = GNETagProperties(currentTag,
2948 0,
2950 // set values of attributes
2951 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2953 TL("The id of the POI"));
2954 myTagProperties[currentTag].addAttribute(attrProperty);
2955
2958 TL("The name of the lane at which the POI is located at"));
2959 myTagProperties[currentTag].addAttribute(attrProperty);
2960
2963 TL("The position on the named lane or in the net in meters at which the POI is located at"));
2964 myTagProperties[currentTag].addAttribute(attrProperty);
2965
2968 TL("If set, no error will be reported if element is placed behind the lane.") + std::string("\n") +
2969 TL("Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,") + std::string("\n") +
2970 TL("if the position was negative and larger than the lanes length after multiplication with - 1"),
2971 "0");
2972 myTagProperties[currentTag].addAttribute(attrProperty);
2973
2976 TL("The lateral offset on the named lane at which the POI is located at"),
2977 "0.00");
2978 myTagProperties[currentTag].addAttribute(attrProperty);
2979
2982 TL("The color with which the POI shall be displayed"),
2983 "red");
2984 myTagProperties[currentTag].addAttribute(attrProperty);
2985
2988 TL("A typename for the POI"),
2990 myTagProperties[currentTag].addAttribute(attrProperty);
2991
2994 TL("Name of POI"));
2995 myTagProperties[currentTag].addAttribute(attrProperty);
2996
2999 TL("The layer of the POI for drawing and selecting"),
3001 myTagProperties[currentTag].addAttribute(attrProperty);
3002
3005 TL("Width of rendered image in meters"),
3007 myTagProperties[currentTag].addAttribute(attrProperty);
3008
3011 TL("Height of rendered image in meters"),
3013 myTagProperties[currentTag].addAttribute(attrProperty);
3014
3017 TL("A bitmap to use for rendering this POI"),
3019 myTagProperties[currentTag].addAttribute(attrProperty);
3020
3023 TL("Enable or disable use image file as a relative path"),
3025 myTagProperties[currentTag].addAttribute(attrProperty);
3026
3029 TL("Angle of rendered image in degree"),
3031 myTagProperties[currentTag].addAttribute(attrProperty);
3032 }
3033 currentTag = GNE_TAG_POIGEO;
3034 {
3035 // set values of tag
3036 myTagProperties[currentTag] = GNETagProperties(currentTag,
3040 // set values of attributes
3041 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3043 TL("The id of the POI"));
3044 myTagProperties[currentTag].addAttribute(attrProperty);
3045
3046 // set values of attributes
3049 TL("The longitude position of the parking vehicle on the view"));
3050 myTagProperties[currentTag].addAttribute(attrProperty);
3051
3054 TL("The latitude position of the parking vehicle on the view"));
3055 myTagProperties[currentTag].addAttribute(attrProperty);
3056
3059 TL("The color with which the POI shall be displayed"),
3060 "red");
3061 myTagProperties[currentTag].addAttribute(attrProperty);
3062
3065 TL("A typename for the POI"),
3067 myTagProperties[currentTag].addAttribute(attrProperty);
3068
3071 TL("Name of POI"));
3072 myTagProperties[currentTag].addAttribute(attrProperty);
3073
3076 TL("The layer of the POI for drawing and selecting"),
3078 myTagProperties[currentTag].addAttribute(attrProperty);
3079
3082 TL("Width of rendered image in meters"),
3084 myTagProperties[currentTag].addAttribute(attrProperty);
3085
3088 TL("Height of rendered image in meters"),
3090 myTagProperties[currentTag].addAttribute(attrProperty);
3091
3094 TL("A bitmap to use for rendering this POI"),
3096 myTagProperties[currentTag].addAttribute(attrProperty);
3097
3100 TL("Enable or disable use image file as a relative path"),
3102 myTagProperties[currentTag].addAttribute(attrProperty);
3103
3106 TL("Angle of rendered image in degree"),
3108 myTagProperties[currentTag].addAttribute(attrProperty);
3109 }
3110}
3111
3112
3113void
3115 // declare empty GNEAttributeProperties
3116 GNEAttributeProperties attrProperty;
3117 // fill TAZ ACs
3118 SumoXMLTag currentTag = SUMO_TAG_TAZ;
3119 {
3120 // set values of tag
3121 myTagProperties[currentTag] = GNETagProperties(currentTag,
3124 GUIIcon::TAZ, currentTag);
3125 // set values of attributes
3126 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3128 TL("The id of the TAZ"));
3129 myTagProperties[currentTag].addAttribute(attrProperty);
3130
3133 TL("The shape of the TAZ"));
3134 myTagProperties[currentTag].addAttribute(attrProperty);
3135
3138 TL("TAZ center"));
3139 myTagProperties[currentTag].addAttribute(attrProperty);
3140
3143 TL("An information whether the TAZ shall be filled"),
3144 "0");
3145 myTagProperties[currentTag].addAttribute(attrProperty);
3146
3149 TL("The RGBA color with which the TAZ shall be displayed"),
3150 "red");
3151 myTagProperties[currentTag].addAttribute(attrProperty);
3152
3155 TL("Name of POI"));
3156 myTagProperties[currentTag].addAttribute(attrProperty);
3157 }
3158 currentTag = SUMO_TAG_TAZSOURCE;
3159 {
3160 // set values of tag
3161 myTagProperties[currentTag] = GNETagProperties(currentTag,
3164 GUIIcon::TAZEDGE, currentTag, {SUMO_TAG_TAZ});
3165 // set values of attributes
3168 TL("The id of edge in the simulation network"));
3169 attrProperty.setSynonym(SUMO_ATTR_ID);
3170 myTagProperties[currentTag].addAttribute(attrProperty);
3171
3174 TL("Depart weight associated to this Edge"),
3175 "1");
3176 myTagProperties[currentTag].addAttribute(attrProperty);
3177 }
3178 currentTag = SUMO_TAG_TAZSINK;
3179 {
3180 // set values of tag
3181 myTagProperties[currentTag] = GNETagProperties(currentTag,
3184 GUIIcon::TAZEDGE, currentTag, {SUMO_TAG_TAZ});
3185 // set values of attributes
3188 TL("The id of edge in the simulation network"));
3189 attrProperty.setSynonym(SUMO_ATTR_ID);
3190 myTagProperties[currentTag].addAttribute(attrProperty);
3191
3194 TL("Arrival weight associated to this Edget"),
3195 "1");
3196 myTagProperties[currentTag].addAttribute(attrProperty);
3197 }
3198}
3199
3200
3201void
3203 // declare empty GNEAttributeProperties
3204 GNEAttributeProperties attrProperty;
3205
3206 // fill wire elements
3208 {
3209 // set tag properties
3210 myTagProperties[currentTag] = GNETagProperties(currentTag,
3213 GUIIcon::TRACTION_SUBSTATION, currentTag);
3214 // set attribute properties
3215 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3217 TL("Traction substation ID"));
3218 myTagProperties[currentTag].addAttribute(attrProperty);
3219
3222 TL("X-Y position of detector in editor (Only used in netedit)"),
3223 "0,0"); // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
3224 myTagProperties[currentTag].addAttribute(attrProperty);
3225
3228 TL("Voltage of at connection point for the overhead wire"),
3229 "600");
3230 myTagProperties[currentTag].addAttribute(attrProperty);
3231
3234 TL("Current limit of the feeder line"),
3235 "400");
3236 myTagProperties[currentTag].addAttribute(attrProperty);
3237 }
3238 currentTag = SUMO_TAG_OVERHEAD_WIRE_SECTION;
3239 {
3240 // set tag properties
3241 myTagProperties[currentTag] = GNETagProperties(currentTag,
3243 0,
3244 GUIIcon::OVERHEADWIRE, currentTag);
3245 // set attribute properties
3246 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3248 TL("Overhead wire segment ID"));
3249 myTagProperties[currentTag].addAttribute(attrProperty);
3250
3253 TL("Substation to which the circuit is connected"));
3254 myTagProperties[currentTag].addAttribute(attrProperty);
3255
3258 TL("List of consecutive lanes of the circuit"));
3259 myTagProperties[currentTag].addAttribute(attrProperty);
3260
3263 TL("Starting position in the specified lane"),
3264 "0.0");
3265 myTagProperties[currentTag].addAttribute(attrProperty);
3266
3269 TL("Ending position in the specified lane"),
3271 myTagProperties[currentTag].addAttribute(attrProperty);
3272
3275 TL("If set, no error will be reported if element is placed behind the lane.") + std::string("\n") +
3276 TL("Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,") + std::string("\n") +
3277 TL("if the position was negative and larger than the lanes length after multiplication with - 1"),
3278 "0");
3279 myTagProperties[currentTag].addAttribute(attrProperty);
3280
3283 TL("Inner lanes, where placing of overhead wire is restricted"));
3284 myTagProperties[currentTag].addAttribute(attrProperty);
3285 }
3286 currentTag = SUMO_TAG_OVERHEAD_WIRE_CLAMP;
3287 {
3288 // set tag properties
3289 myTagProperties[currentTag] = GNETagProperties(currentTag,
3291 0,
3292 GUIIcon::OVERHEADWIRE_CLAMP, currentTag);
3293 // set attribute properties
3294 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3296 TL("Overhead wire clamp ID"));
3297 myTagProperties[currentTag].addAttribute(attrProperty);
3298
3301 TL("ID of the overhead wire segment, to the start of which the overhead wire clamp is connected"));
3302 myTagProperties[currentTag].addAttribute(attrProperty);
3303
3306 TL("ID of the overhead wire segment lane of overheadWireIDStartClamp"));
3307 myTagProperties[currentTag].addAttribute(attrProperty);
3308
3311 TL("ID of the overhead wire segment, to the end of which the overhead wire clamp is connected"));
3312 myTagProperties[currentTag].addAttribute(attrProperty);
3313
3316 TL("ID of the overhead wire segment lane of overheadWireIDEndClamp"));
3317 myTagProperties[currentTag].addAttribute(attrProperty);
3318 }
3319}
3320
3321
3322void
3324 // declare empty GNEAttributeProperties
3325 GNEAttributeProperties attrProperty;
3326
3327 // fill demand elements
3328 SumoXMLTag currentTag = SUMO_TAG_ROUTE;
3329 {
3330 // set values of tag
3331 myTagProperties[currentTag] = GNETagProperties(currentTag,
3333 0,
3334 GUIIcon::ROUTE, currentTag);
3335
3336 // set values of attributes
3337 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3339 TL("The id of Route"));
3340 myTagProperties[currentTag].addAttribute(attrProperty);
3341
3344 TL("The edges the vehicle shall drive along, given as their ids, separated using spaces"));
3345 myTagProperties[currentTag].addAttribute(attrProperty);
3346
3349 TL("This route's color"));
3350 myTagProperties[currentTag].addAttribute(attrProperty);
3351
3354 TL("The number of times that the edges of this route shall be repeated"),
3355 "0");
3356 myTagProperties[currentTag].addAttribute(attrProperty);
3357
3360 TL("When defining a repeating route with stops and those stops use the until attribute,") + std::string("\n") +
3361 TL("the times will be shifted forward by 'cycleTime' on each repeat"),
3362 "0");
3363 myTagProperties[currentTag].addAttribute(attrProperty);
3364 }
3365 currentTag = GNE_TAG_ROUTE_EMBEDDED;
3366 {
3367 // set values of tag
3368 myTagProperties[currentTag] = GNETagProperties(currentTag,
3372
3373 // set values of attributes
3376 TL("The edges the vehicle shall drive along, given as their ids, separated using spaces"));
3377 myTagProperties[currentTag].addAttribute(attrProperty);
3378
3381 TL("This route's color"));
3382 myTagProperties[currentTag].addAttribute(attrProperty);
3383
3386 TL("The number of times that the edges of this route shall be repeated"),
3387 "0");
3388 myTagProperties[currentTag].addAttribute(attrProperty);
3389
3392 TL("When defining a repeating route with stops and those stops use the until attribute,") + std::string("\n") +
3393 TL("the times will be shifted forward by 'cycleTime' on each repeat"),
3394 "0");
3395 myTagProperties[currentTag].addAttribute(attrProperty);
3396 }
3397 currentTag = SUMO_TAG_VTYPE_DISTRIBUTION;
3398 {
3399 // set values of tag
3400 myTagProperties[currentTag] = GNETagProperties(currentTag,
3403 GUIIcon::VTYPEDISTRIBUTION, currentTag);
3404
3405 // set values of attributes
3406 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3408 TL("The id of VehicleType distribution"));
3409 myTagProperties[currentTag].addAttribute(attrProperty);
3410 }
3411 currentTag = SUMO_TAG_VTYPE;
3412 {
3413 // set values of tag
3414 myTagProperties[currentTag] = GNETagProperties(currentTag,
3417 GUIIcon::VTYPE, currentTag);
3418
3419 // set values of attributes
3420 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3422 TL("type ID"));
3423 myTagProperties[currentTag].addAttribute(attrProperty);
3424
3427 TL("Type distribution"));
3428 myTagProperties[currentTag].addAttribute(attrProperty);
3429
3432 TL("Type distribution probability"),
3433 "1.0");
3434 myTagProperties[currentTag].addAttribute(attrProperty);
3435
3438 TL("An abstract vehicle class"),
3439 "passenger");
3440 attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings(), false);
3441 myTagProperties[currentTag].addAttribute(attrProperty);
3442
3445 TL("This type's color"));
3446 myTagProperties[currentTag].addAttribute(attrProperty);
3447
3450 TL("The vehicle's netto-length (length) [m]"));
3451 myTagProperties[currentTag].addAttribute(attrProperty);
3452
3455 TL("Empty space after leader [m]"));
3456 myTagProperties[currentTag].addAttribute(attrProperty);
3457
3460 TL("The vehicle's maximum velocity [m/s]"));
3461 myTagProperties[currentTag].addAttribute(attrProperty);
3462
3465 TL("The vehicle's expected multiplicator for lane speed limits (or a distribution specifier)"));
3466 myTagProperties[currentTag].addAttribute(attrProperty);
3467
3470 TL("The vehicle's desired maximum velocity (interacts with speedFactor).") + std::string("\n") +
3471 TL("Applicable when no speed limit applies (bicycles, some motorways) [m/s]"));
3472 myTagProperties[currentTag].addAttribute(attrProperty);
3473
3476 TL("An abstract emission class"));
3478 myTagProperties[currentTag].addAttribute(attrProperty);
3479
3482 TL("How this vehicle is rendered"));
3483 attrProperty.setDiscreteValues(SumoVehicleShapeStrings.getStrings(), false);
3484 myTagProperties[currentTag].addAttribute(attrProperty);
3485
3488 TL("The vehicle's width [m] (only used for drawing)"),
3489 "1.8");
3490 myTagProperties[currentTag].addAttribute(attrProperty);
3491
3494 TL("The vehicle's height [m] (only used for drawing)"),
3495 "1.5");
3496 myTagProperties[currentTag].addAttribute(attrProperty);
3497
3500 TL("Image file for rendering vehicles of this type (should be grayscale to allow functional coloring)"));
3501 myTagProperties[currentTag].addAttribute(attrProperty);
3502
3505 TL("The model used for changing lanes"),
3506 "default");
3507 attrProperty.setDiscreteValues(SUMOXMLDefinitions::LaneChangeModels.getStrings(), true);
3508 myTagProperties[currentTag].addAttribute(attrProperty);
3509
3512 TL("The model used for car-following"),
3513 "Krauss");
3514 attrProperty.setDiscreteValues(SUMOXMLDefinitions::CarFollowModels.getStrings(), true);
3515 myTagProperties[currentTag].addAttribute(attrProperty);
3516
3519 TL("The number of persons (excluding an autonomous driver) the vehicle can transport"));
3520 myTagProperties[currentTag].addAttribute(attrProperty);
3521
3524 TL("The number of containers the vehicle can transport"));
3525 myTagProperties[currentTag].addAttribute(attrProperty);
3526
3529 TL("The time required by a person to board the vehicle"),
3530 "0.50");
3531 myTagProperties[currentTag].addAttribute(attrProperty);
3532
3535 TL("The time required to load a container onto the vehicle"),
3536 "90.00");
3537 myTagProperties[currentTag].addAttribute(attrProperty);
3538
3541 TL("The preferred lateral alignment when using the sublane-model"),
3542 "center");
3544 myTagProperties[currentTag].addAttribute(attrProperty);
3545
3548 TL("The minimum lateral gap at a speed difference of 50km/h when using the sublane-model"),
3549 "0.12");
3550 myTagProperties[currentTag].addAttribute(attrProperty);
3551
3554 TL("The maximum lateral speed when using the sublane-model"),
3555 "1.00");
3556 myTagProperties[currentTag].addAttribute(attrProperty);
3557
3560 TL("The interval length for which vehicle performs its decision logic (acceleration and lane-changing)"),
3561 toString(OptionsCont::getOptions().getFloat("default.action-step-length")));
3562 myTagProperties[currentTag].addAttribute(attrProperty);
3563
3566 TL("The probability when being added to a distribution without an explicit probability"),
3568 myTagProperties[currentTag].addAttribute(attrProperty);
3569
3572 TL("3D model file for this class"));
3573 myTagProperties[currentTag].addAttribute(attrProperty);
3574
3577 TL("Carriage lengths"));
3578 myTagProperties[currentTag].addAttribute(attrProperty);
3579
3582 TL("Locomotive lengths"));
3583 myTagProperties[currentTag].addAttribute(attrProperty);
3584
3587 TL("Gap between carriages"),
3588 "1");
3589 myTagProperties[currentTag].addAttribute(attrProperty);
3590
3591 // fill VType Car Following Model Values (implemented in a separated function to improve code legibility)
3593
3594 // fill VType Junction Model Parameters (implemented in a separated function to improve code legibility)
3595 fillJunctionModelAttributes(currentTag);
3596
3597 // fill VType Lane Change Model Parameters (implemented in a separated function to improve code legibility)
3599 }
3600}
3601
3602
3603void
3605 // declare empty GNEAttributeProperties
3606 GNEAttributeProperties attrProperty;
3607 // fill vehicle ACs
3608 SumoXMLTag currentTag = SUMO_TAG_TRIP;
3609 {
3610 // set values of tag
3611 myTagProperties[currentTag] = GNETagProperties(currentTag,
3613 0,
3614 GUIIcon::TRIP, currentTag, {}, FXRGBA(253, 255, 206, 255));
3615 myTagProperties[currentTag].setFieldString("trip (from-to edges)");
3616
3617 // set values of attributes
3618 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3620 TL("The ID of trip"));
3621 myTagProperties[currentTag].addAttribute(attrProperty);
3622
3625 TL("The id of the vehicle type to use for this trip"),
3627 myTagProperties[currentTag].addAttribute(attrProperty);
3628
3631 TL("The ID of the edge the trip starts at"));
3632 myTagProperties[currentTag].addAttribute(attrProperty);
3633
3634 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
3636 TL("The ID of the edge the trip ends at"));
3637 myTagProperties[currentTag].addAttribute(attrProperty);
3638
3641 TL("List of intermediate edge ids which shall be part of the trip"));
3642 myTagProperties[currentTag].addAttribute(attrProperty);
3643
3644 // add common attributes
3645 fillCommonVehicleAttributes(currentTag);
3646
3649 TL("The departure time of the (first) trip which is generated using this trip definition"),
3650 "0.00");
3651 myTagProperties[currentTag].addAttribute(attrProperty);
3652 }
3653 currentTag = GNE_TAG_TRIP_JUNCTIONS;
3654 {
3655 // set values of tag
3656 myTagProperties[currentTag] = GNETagProperties(currentTag,
3658 0,
3659 GUIIcon::TRIP_JUNCTIONS, SUMO_TAG_TRIP, {}, FXRGBA(255, 213, 213, 255));
3660 myTagProperties[currentTag].setFieldString("trip (from-to junctions)");
3661
3662 // set values of attributes
3663 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3665 TL("The id of trip"));
3666 myTagProperties[currentTag].addAttribute(attrProperty);
3667
3670 TL("The id of the vehicle type to use for this trip"),
3672 myTagProperties[currentTag].addAttribute(attrProperty);
3673
3676 TL("The name of the junction the trip starts at"));
3677 myTagProperties[currentTag].addAttribute(attrProperty);
3678
3681 TL("The name of the junction the trip ends at"));
3682 myTagProperties[currentTag].addAttribute(attrProperty);
3683
3684 // add common attributes
3685 fillCommonVehicleAttributes(currentTag);
3686
3689 TL("The departure time of the (first) trip which is generated using this trip definition"),
3690 "0.00");
3691 myTagProperties[currentTag].addAttribute(attrProperty);
3692 }
3693 currentTag = GNE_TAG_TRIP_TAZS;
3694 {
3695 // set values of tag
3696 myTagProperties[currentTag] = GNETagProperties(currentTag,
3698 0,
3699 GUIIcon::TRIP_TAZS, SUMO_TAG_TRIP, {}, FXRGBA(240, 255, 205, 255));
3700 myTagProperties[currentTag].setFieldString("trip (from-to TAZs)");
3701
3702 // set values of attributes
3703 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3705 TL("The id of trip"));
3706 myTagProperties[currentTag].addAttribute(attrProperty);
3707
3710 TL("The id of the vehicle type to use for this trip"),
3712 myTagProperties[currentTag].addAttribute(attrProperty);
3713
3716 TL("The name of the TAZ the trip starts at"));
3717 myTagProperties[currentTag].addAttribute(attrProperty);
3718
3721 TL("The name of the TAZ the trip ends at"));
3722 myTagProperties[currentTag].addAttribute(attrProperty);
3723
3724 // add common attributes
3725 fillCommonVehicleAttributes(currentTag);
3726
3729 TL("The departure time of the (first) trip which is generated using this trip definition"),
3730 "0.00");
3731 myTagProperties[currentTag].addAttribute(attrProperty);
3732 }
3733 currentTag = SUMO_TAG_VEHICLE;
3734 {
3735 // set values of tag
3736 myTagProperties[currentTag] = GNETagProperties(currentTag,
3738 0,
3739 GUIIcon::VEHICLE, currentTag, {}, FXRGBA(210, 233, 255, 255));
3740 myTagProperties[currentTag].setFieldString("vehicle (over route)");
3741
3742 // set values of attributes
3743 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3745 TL("The ID of the vehicle"));
3746 myTagProperties[currentTag].addAttribute(attrProperty);
3747
3750 TL("The id of the vehicle type to use for this vehicle"),
3752 myTagProperties[currentTag].addAttribute(attrProperty);
3753
3756 TL("The id of the route the vehicle shall drive along"));
3757 myTagProperties[currentTag].addAttribute(attrProperty);
3758
3761 TL("The index of the edge within route the vehicle starts at"));
3762 myTagProperties[currentTag].addAttribute(attrProperty);
3763
3766 TL("The index of the edge within route the vehicle ends at"));
3767 myTagProperties[currentTag].addAttribute(attrProperty);
3768
3769 // add common attributes
3770 fillCommonVehicleAttributes(currentTag);
3771
3774 TL("The time step at which the vehicle shall enter the network"),
3775 "0.00");
3776 myTagProperties[currentTag].addAttribute(attrProperty);
3777 }
3778 currentTag = GNE_TAG_VEHICLE_WITHROUTE;
3779 {
3780 // set values of tag
3781 myTagProperties[currentTag] = GNETagProperties(currentTag,
3784 GUIIcon::VEHICLE, SUMO_TAG_VEHICLE, {}, FXRGBA(210, 233, 255, 255));
3785 myTagProperties[currentTag].setFieldString("vehicle (embedded route)");
3786
3787 // set values of attributes
3788 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3790 TL("The ID of the vehicle"));
3791 myTagProperties[currentTag].addAttribute(attrProperty);
3792
3795 TL("The id of the vehicle type to use for this vehicle"),
3797 myTagProperties[currentTag].addAttribute(attrProperty);
3798
3801 TL("The index of the edge within route the vehicle starts at"));
3802 myTagProperties[currentTag].addAttribute(attrProperty);
3803
3806 TL("The index of the edge within route the vehicle ends at"));
3807 myTagProperties[currentTag].addAttribute(attrProperty);
3808
3809 // add common attributes
3810 fillCommonVehicleAttributes(currentTag);
3811
3814 TL("The time step at which the vehicle shall enter the network"),
3815 "0.00");
3816 myTagProperties[currentTag].addAttribute(attrProperty);
3817 }
3818 currentTag = SUMO_TAG_FLOW;
3819 {
3820 // set values of tag
3821 myTagProperties[currentTag] = GNETagProperties(currentTag,
3823 0,
3824 GUIIcon::FLOW, currentTag, {}, FXRGBA(253, 255, 206, 255));
3825 myTagProperties[currentTag].setFieldString("flow (from-to edges)");
3826
3827 // set values of attributes
3828 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3830 TL("The ID of the flow"));
3831 myTagProperties[currentTag].addAttribute(attrProperty);
3832
3835 TL("The id of the flow type to use for this flow"),
3837 myTagProperties[currentTag].addAttribute(attrProperty);
3838
3841 TL("The ID of the edge the flow starts at"));
3842 myTagProperties[currentTag].addAttribute(attrProperty);
3843
3844 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
3846 TL("The ID of the edge the flow ends at"));
3847 myTagProperties[currentTag].addAttribute(attrProperty);
3848
3851 TL("List of intermediate edge ids which shall be part of the flow"));
3852 myTagProperties[currentTag].addAttribute(attrProperty);
3853
3854 // add common attributes
3855 fillCommonVehicleAttributes(currentTag);
3856
3857 // add flow attributes
3859 }
3860 currentTag = GNE_TAG_FLOW_JUNCTIONS;
3861 {
3862 // set values of tag
3863 myTagProperties[currentTag] = GNETagProperties(currentTag,
3865 0,
3866 GUIIcon::FLOW_JUNCTIONS, SUMO_TAG_FLOW, {}, FXRGBA(255, 213, 213, 255));
3867 myTagProperties[currentTag].setFieldString("flow (from-to junctions)");
3868
3869 // set values of attributes
3870 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3872 TL("The id of the flow"));
3873 myTagProperties[currentTag].addAttribute(attrProperty);
3874
3877 TL("The id of the flow type to use for this flow"),
3879 myTagProperties[currentTag].addAttribute(attrProperty);
3880
3883 TL("The name of the junction the flow starts at"));
3884 myTagProperties[currentTag].addAttribute(attrProperty);
3885
3888 TL("The name of the junction the flow ends at"));
3889 myTagProperties[currentTag].addAttribute(attrProperty);
3890
3891 // add common attributes
3892 fillCommonVehicleAttributes(currentTag);
3893
3894 // add flow attributes
3896 }
3897 currentTag = GNE_TAG_FLOW_TAZS;
3898 {
3899 // set values of tag
3900 myTagProperties[currentTag] = GNETagProperties(currentTag,
3902 0,
3903 GUIIcon::FLOW_TAZS, SUMO_TAG_FLOW, {}, FXRGBA(240, 255, 205, 255));
3904 myTagProperties[currentTag].setFieldString("flow (from-to TAZs)");
3905
3906 // set values of attributes
3907 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3909 TL("The id of the flow"));
3910 myTagProperties[currentTag].addAttribute(attrProperty);
3911
3914 TL("The id of the flow type to use for this flow"),
3916 myTagProperties[currentTag].addAttribute(attrProperty);
3917
3920 TL("The name of the TAZ the flow starts at"));
3921 myTagProperties[currentTag].addAttribute(attrProperty);
3922
3925 TL("The name of the TAZ the flow ends at"));
3926 myTagProperties[currentTag].addAttribute(attrProperty);
3927
3928 // add common attributes
3929 fillCommonVehicleAttributes(currentTag);
3930
3931 // add flow attributes
3933 }
3934 currentTag = GNE_TAG_FLOW_ROUTE;
3935 {
3936 // set values of tag
3937 myTagProperties[currentTag] = GNETagProperties(currentTag,
3939 0,
3940 GUIIcon::ROUTEFLOW, SUMO_TAG_FLOW, {}, FXRGBA(210, 233, 255, 255));
3941 myTagProperties[currentTag].setFieldString("flow (over route)");
3942
3943 // set values of attributes
3944 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3946 TL("The id of the flow"));
3947 myTagProperties[currentTag].addAttribute(attrProperty);
3948
3951 TL("The id of the flow type to use for this flow"),
3953 myTagProperties[currentTag].addAttribute(attrProperty);
3954
3957 TL("The id of the route the flow shall drive along"));
3958 myTagProperties[currentTag].addAttribute(attrProperty);
3959
3962 TL("The index of the edge within route the flow starts at"));
3963 myTagProperties[currentTag].addAttribute(attrProperty);
3964
3967 TL("The index of the edge within route the flow ends at"));
3968 myTagProperties[currentTag].addAttribute(attrProperty);
3969
3970 // add common attributes
3971 fillCommonVehicleAttributes(currentTag);
3972
3973 // add flow attributes
3975 }
3976 currentTag = GNE_TAG_FLOW_WITHROUTE;
3977 {
3978 // set values of tag
3979 myTagProperties[currentTag] = GNETagProperties(currentTag,
3982 GUIIcon::ROUTEFLOW, SUMO_TAG_FLOW, {}, FXRGBA(210, 233, 255, 255));
3983 myTagProperties[currentTag].setFieldString("flow (embedded route)");
3984
3985 // set values of attributes
3986 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3988 TL("The name of the flow"));
3989 myTagProperties[currentTag].addAttribute(attrProperty);
3990
3993 TL("The id of the flow type to use for this flow"),
3995 myTagProperties[currentTag].addAttribute(attrProperty);
3996
3999 TL("The index of the edge within route the flow starts at"));
4000 myTagProperties[currentTag].addAttribute(attrProperty);
4001
4004 TL("The index of the edge within route the flow ends at"));
4005 myTagProperties[currentTag].addAttribute(attrProperty);
4006
4007 // add common attributes
4008 fillCommonVehicleAttributes(currentTag);
4009
4010 // add flow attributes
4012 }
4013 /* currently disabled. See #5259
4014 currentTag = GNE_TAG_TRIP_TAZ;
4015 {
4016 // set values of tag
4017 myTagProperties[currentTag] = GNETagProperties(currentTag,
4018 GNETagProperties::DEMANDELEMENT | GNETagProperties::VEHICLE,
4019 GNETagProperties::DRAWABLE,
4020 GUIIcon::TRIP);
4021 }
4022 */
4023}
4024
4025
4026void
4028 // declare empty GNEAttributeProperties
4029 GNEAttributeProperties attrProperty;
4030 // fill stops ACs
4031 SumoXMLTag currentTag = GNE_TAG_STOP_LANE;
4032 {
4033 // set values of tag
4034 myTagProperties[currentTag] = GNETagProperties(currentTag,
4038 // set values of attributes
4041 TL("The name of the lane the stop shall be located at"));
4042 myTagProperties[currentTag].addAttribute(attrProperty);
4043
4046 TL("The begin position on the lane (the lower position on the lane) in meters"));
4047 myTagProperties[currentTag].addAttribute(attrProperty);
4048
4051 TL("The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m"));
4052 myTagProperties[currentTag].addAttribute(attrProperty);
4053
4056 TL("If set, no error will be reported if element is placed behind the lane.") + std::string("\n") +
4057 TL("Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,") + std::string("\n") +
4058 TL("if the position was negative and larger than the lanes length after multiplication with - 1"),
4059 "0");
4060 myTagProperties[currentTag].addAttribute(attrProperty);
4061
4064 TL("The lateral offset on the named lane at which the vehicle must stop"));
4065 myTagProperties[currentTag].addAttribute(attrProperty);
4066
4067 // fill common stop attributes
4068 fillCommonStopAttributes(currentTag, false);
4069 }
4070 currentTag = GNE_TAG_STOP_BUSSTOP;
4071 {
4072 // set values of tag
4073 myTagProperties[currentTag] = GNETagProperties(currentTag,
4077 // set values of attributes
4080 TL("BusStop associated with this stop"));
4081 myTagProperties[currentTag].addAttribute(attrProperty);
4082
4083 // fill common stop attributes
4084 fillCommonStopAttributes(currentTag, false);
4085 }
4086 currentTag = GNE_TAG_STOP_TRAINSTOP;
4087 {
4088 // set values of tag
4089 myTagProperties[currentTag] = GNETagProperties(currentTag,
4093 // set values of attributes
4096 TL("TrainStop associated with this stop"));
4097 myTagProperties[currentTag].addAttribute(attrProperty);
4098
4099 // fill common stop attributes
4100 fillCommonStopAttributes(currentTag, false);
4101 }
4102 currentTag = GNE_TAG_STOP_CONTAINERSTOP;
4103 {
4104 // set values of tag
4105 myTagProperties[currentTag] = GNETagProperties(currentTag,
4109 // set values of attributes
4112 TL("ContainerStop associated with this stop"));
4113 myTagProperties[currentTag].addAttribute(attrProperty);
4114
4115 // fill common stop attributes
4116 fillCommonStopAttributes(currentTag, false);
4117 }
4118 currentTag = GNE_TAG_STOP_CHARGINGSTATION;
4119 {
4120 // set values of tag
4121 myTagProperties[currentTag] = GNETagProperties(currentTag,
4125 // set values of attributes
4128 TL("ChargingStation associated with this stop"));
4129 myTagProperties[currentTag].addAttribute(attrProperty);
4130
4131 // fill common stop attributes
4132 fillCommonStopAttributes(currentTag, false);
4133 }
4134 currentTag = GNE_TAG_STOP_PARKINGAREA;
4135 {
4136 // set values of tag
4137 myTagProperties[currentTag] = GNETagProperties(currentTag,
4141 // set values of attributes
4144 TL("ParkingArea associated with this stop"));
4145 myTagProperties[currentTag].addAttribute(attrProperty);
4146
4147 // fill common stop attributes (no parking)
4148 fillCommonStopAttributes(currentTag, false);
4149 }
4150}
4151
4152
4153void
4155 // declare empty GNEAttributeProperties
4156 GNEAttributeProperties attrProperty;
4157 // fill waypoints ACs
4158 SumoXMLTag currentTag = GNE_TAG_WAYPOINT_LANE;
4159 {
4160 // set values of tag
4161 myTagProperties[currentTag] = GNETagProperties(currentTag,
4165 // set values of attributes
4168 TL("The name of the lane the waypoint shall be located at"));
4169 myTagProperties[currentTag].addAttribute(attrProperty);
4170
4173 TL("The begin position on the lane (the lower position on the lane) in meters"));
4174 myTagProperties[currentTag].addAttribute(attrProperty);
4175
4178 TL("The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m"));
4179 myTagProperties[currentTag].addAttribute(attrProperty);
4180
4183 TL("If set, no error will be reported if element is placed behind the lane.") + std::string("\n") +
4184 TL("Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,") + std::string("\n") +
4185 TL("if the position was negative and larger than the lanes length after multiplication with - 1"),
4186 "0");
4187 myTagProperties[currentTag].addAttribute(attrProperty);
4188
4191 TL("The lateral offset on the named lane at which the vehicle must waypoint"));
4192 myTagProperties[currentTag].addAttribute(attrProperty);
4193
4194 // fill common waypoint (stop) attributes
4195 fillCommonStopAttributes(currentTag, true);
4196 }
4197 currentTag = GNE_TAG_WAYPOINT_BUSSTOP;
4198 {
4199 // set values of tag
4200 myTagProperties[currentTag] = GNETagProperties(currentTag,
4204 // set values of attributes
4207 TL("BusWaypoint associated with this waypoint"));
4208 myTagProperties[currentTag].addAttribute(attrProperty);
4209
4210 // fill common waypoint (stop) attributes
4211 fillCommonStopAttributes(currentTag, true);
4212 }
4213 currentTag = GNE_TAG_WAYPOINT_TRAINSTOP;
4214 {
4215 // set values of tag
4216 myTagProperties[currentTag] = GNETagProperties(currentTag,
4220 // set values of attributes
4223 TL("TrainWaypoint associated with this waypoint"));
4224 myTagProperties[currentTag].addAttribute(attrProperty);
4225
4226 // fill common waypoint (stop) attributes
4227 fillCommonStopAttributes(currentTag, true);
4228 }
4229 currentTag = GNE_TAG_WAYPOINT_CONTAINERSTOP;
4230 {
4231 // set values of tag
4232 myTagProperties[currentTag] = GNETagProperties(currentTag,
4236 // set values of attributes
4239 TL("ContainerWaypoint associated with this waypoint"));
4240 myTagProperties[currentTag].addAttribute(attrProperty);
4241
4242 // fill common waypoint (stop) attributes
4243 fillCommonStopAttributes(currentTag, true);
4244 }
4246 {
4247 // set values of tag
4248 myTagProperties[currentTag] = GNETagProperties(currentTag,
4252 // set values of attributes
4255 TL("ChargingStation associated with this waypoint"));
4256 myTagProperties[currentTag].addAttribute(attrProperty);
4257
4258 // fill common waypoint (stop) attributes
4259 fillCommonStopAttributes(currentTag, true);
4260 }
4261 currentTag = GNE_TAG_WAYPOINT_PARKINGAREA;
4262 {
4263 // set values of tag
4264 myTagProperties[currentTag] = GNETagProperties(currentTag,
4268 // set values of attributes
4271 TL("ParkingArea associated with this waypoint"));
4272 myTagProperties[currentTag].addAttribute(attrProperty);
4273
4274 // fill common waypoint (stop) attributes
4275 fillCommonStopAttributes(currentTag, true);
4276 }
4277}
4278
4279
4280void
4282 // declare empty GNEAttributeProperties
4283 GNEAttributeProperties attrProperty;
4284 // fill vehicle ACs
4285 SumoXMLTag currentTag = SUMO_TAG_PERSON;
4286 {
4287 // set values of tag
4288 myTagProperties[currentTag] = GNETagProperties(currentTag,
4290 0,
4291 GUIIcon::PERSON, currentTag);
4292
4293 // add flow attributes
4294 fillCommonPersonAttributes(currentTag);
4295
4296 // set specific attribute depart (note: Persons doesn't support triggered and containerTriggered values)
4299 TL("The time step at which the person shall enter the network"),
4300 "0.00");
4301 myTagProperties[currentTag].addAttribute(attrProperty);
4302
4303 }
4304 currentTag = SUMO_TAG_PERSONFLOW;
4305 {
4306 // set values of tag
4307 myTagProperties[currentTag] = GNETagProperties(currentTag,
4309 0,
4310 GUIIcon::PERSONFLOW, currentTag);
4311
4312 // add flow attributes
4313 fillCommonPersonAttributes(currentTag);
4314
4315 // add flow attributes
4317 }
4318}
4319
4320
4321void
4323 // declare empty GNEAttributeProperties
4324 GNEAttributeProperties attrProperty;
4325 // fill vehicle ACs
4326 SumoXMLTag currentTag = SUMO_TAG_CONTAINER;
4327 {
4328 // set values of tag
4329 myTagProperties[currentTag] = GNETagProperties(currentTag,
4331 0,
4332 GUIIcon::CONTAINER, currentTag);
4333
4334 // add flow attributes
4336
4339 TL("The time step at which the container shall enter the network"),
4340 "0.00");
4341 myTagProperties[currentTag].addAttribute(attrProperty);
4342 }
4343 currentTag = SUMO_TAG_CONTAINERFLOW;
4344 {
4345 // set values of tag
4346 myTagProperties[currentTag] = GNETagProperties(currentTag,
4348 0,
4349 GUIIcon::CONTAINERFLOW, currentTag);
4350
4351 // add common container attribute
4353
4354 // add flow attributes
4356 }
4357}
4358
4359
4360void
4362 // declare empty GNEAttributeProperties
4363 GNEAttributeProperties attrProperty;
4364 // fill walks
4366 {
4367 // set values of tag
4368 myTagProperties[currentTag] = GNETagProperties(currentTag,
4372 // from edge
4375 TL("The ID of the edge the transport starts at"));
4376 myTagProperties[currentTag].addAttribute(attrProperty);
4377 // to edge
4378 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
4380 TL("The ID of the edge the transport ends at"));
4381 myTagProperties[currentTag].addAttribute(attrProperty);
4382 // arrival position
4385 TL("arrival position on the destination edge"),
4386 "-1");
4387 myTagProperties[currentTag].addAttribute(attrProperty);
4388 // lines
4391 TL("list of vehicle alternatives to take for the transport"),
4392 "ANY");
4393 myTagProperties[currentTag].addAttribute(attrProperty);
4394 }
4396 {
4397 // set values of tag
4398 myTagProperties[currentTag] = GNETagProperties(currentTag,
4402 // from edge
4405 TL("The ID of the edge the transport starts at"));
4406 myTagProperties[currentTag].addAttribute(attrProperty);
4407 // to busStop
4410 TL("ID of the destination container stop"));
4411 myTagProperties[currentTag].addAttribute(attrProperty);
4412 // lines
4415 TL("list of vehicle alternatives to take for the transport"),
4416 "ANY");
4417 myTagProperties[currentTag].addAttribute(attrProperty);
4418 }
4419}
4420
4421
4422void
4424 // declare empty GNEAttributeProperties
4425 GNEAttributeProperties attrProperty;
4426 // fill walks
4427 SumoXMLTag currentTag = GNE_TAG_TRANSHIP_EDGE;
4428 {
4429 // set values of tag
4430 myTagProperties[currentTag] = GNETagProperties(currentTag,
4434 // from edge
4437 TL("The ID of the edge the tranship starts at"));
4438 myTagProperties[currentTag].addAttribute(attrProperty);
4439 // to edge
4440 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
4442 TL("The ID of the edge the tranship ends at"));
4443 myTagProperties[currentTag].addAttribute(attrProperty);
4444 // depart pos
4447 TL("The position at which the tranship shall enter the net"),
4448 "0");
4449 myTagProperties[currentTag].addAttribute(attrProperty);
4450 // arrival position
4453 TL("arrival position on the destination edge"),
4454 "-1");
4455 myTagProperties[currentTag].addAttribute(attrProperty);
4456 // speed
4459 TL("speed of the container for this tranship in m/s"),
4460 "1.39");
4461 myTagProperties[currentTag].addAttribute(attrProperty);
4462 }
4463 currentTag = GNE_TAG_TRANSHIP_CONTAINERSTOP;
4464 {
4465 // set values of tag
4466 myTagProperties[currentTag] = GNETagProperties(currentTag,
4470 // from edge
4473 TL("The name of the edge the tranship starts at"));
4474 myTagProperties[currentTag].addAttribute(attrProperty);
4475 // to busStop
4478 TL("Id of the destination container stop"));
4479 myTagProperties[currentTag].addAttribute(attrProperty);
4480 // depart pos
4483 TL("The position at which the tranship shall enter the net"),
4484 "0");
4485 myTagProperties[currentTag].addAttribute(attrProperty);
4486 // speed
4489 TL("speed of the container for this tranship in m/s"),
4490 "1.39");
4491 myTagProperties[currentTag].addAttribute(attrProperty);
4492 }
4493 currentTag = GNE_TAG_TRANSHIP_EDGES;
4494 {
4495 // set values of tag
4496 myTagProperties[currentTag] = GNETagProperties(currentTag,
4500 // edges
4503 TL("id of the edges to walk"));
4504 myTagProperties[currentTag].addAttribute(attrProperty);
4505 // depart pos
4508 TL("The position at which the tranship shall enter the net"),
4509 "0");
4510 myTagProperties[currentTag].addAttribute(attrProperty);
4511 // arrival pos
4514 TL("Arrival position on the destination edge"),
4515 "-1");
4516 myTagProperties[currentTag].addAttribute(attrProperty);
4517 // speed
4520 TL("speed of the container for this tranship in m/s"),
4521 "1.39");
4522 myTagProperties[currentTag].addAttribute(attrProperty);
4523 }
4524}
4525
4526
4527void
4529 // declare empty GNEAttributeProperties
4530 GNEAttributeProperties attrProperty;
4531 // fill vehicle ACs
4533 {
4534 // set values of tag
4535 myTagProperties[currentTag] = GNETagProperties(currentTag,
4539
4540 // set values of attributes
4543 TL("The ID of the edge the stop shall be located at"));
4544 myTagProperties[currentTag].addAttribute(attrProperty);
4545
4548 TL("The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m"));
4549 myTagProperties[currentTag].addAttribute(attrProperty);
4550
4553 TL("If set, no error will be reported if element is placed behind the lane.") + std::string("\n") +
4554 TL("Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,") + std::string("\n") +
4555 TL("if the position was negative and larger than the lanes length after multiplication with - 1"),
4556 "0");
4557 myTagProperties[currentTag].addAttribute(attrProperty);
4558
4561 TL("Minimum duration for stopping"),
4562 "60");
4563 attrProperty.setDefaultActivated(true);
4564 myTagProperties[currentTag].addAttribute(attrProperty);
4565
4568 TL("The time step at which the route continues"),
4569 "0.00");
4570 myTagProperties[currentTag].addAttribute(attrProperty);
4571
4574 TL("Activity displayed for stopped container in GUI and output files "));
4575 myTagProperties[currentTag].addAttribute(attrProperty);
4576 }
4578 {
4579 // set values of tag
4580 myTagProperties[currentTag] = GNETagProperties(currentTag,
4584
4585 // set values of attributes
4588 TL("ContainerStop associated with this stop"));
4589 myTagProperties[currentTag].addAttribute(attrProperty);
4590
4593 TL("Minimum duration for stopping"),
4594 "60");
4595 attrProperty.setDefaultActivated(true);
4596 myTagProperties[currentTag].addAttribute(attrProperty);
4597
4600 TL("The time step at which the route continues"),
4601 "0.00");
4602 myTagProperties[currentTag].addAttribute(attrProperty);
4603
4606 TL("Activity displayed for stopped container in GUI and output files "));
4607 myTagProperties[currentTag].addAttribute(attrProperty);
4608 }
4609}
4610
4611
4612void
4614 // declare empty GNEAttributeProperties
4615 GNEAttributeProperties attrProperty;
4616 // fill person trips
4618 {
4619 // set values of tag
4620 myTagProperties[currentTag] = GNETagProperties(currentTag,
4624 // from edge
4627 TL("The ID of the edge the person trip starts at"));
4628 myTagProperties[currentTag].addAttribute(attrProperty);
4629 // to edge
4630 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
4632 TL("The ID of the edge the person trip ends at"));
4633 myTagProperties[currentTag].addAttribute(attrProperty);
4634 // arrival position
4637 TL("arrival position on the destination edge"),
4638 "-1");
4639 myTagProperties[currentTag].addAttribute(attrProperty);
4640 // vTypes
4643 TL("List of possible vehicle types to take"));
4644 myTagProperties[currentTag].addAttribute(attrProperty);
4645 // modes
4648 TL("List of possible traffic modes. Walking is always possible regardless of this value"));
4649 myTagProperties[currentTag].addAttribute(attrProperty);
4650 // lines
4653 TL("list of vehicle alternatives to take for the person trip"),
4654 "ANY");
4655 myTagProperties[currentTag].addAttribute(attrProperty);
4656 }
4657 currentTag = GNE_TAG_PERSONTRIP_BUSSTOP;
4658 {
4659 // set values of tag
4660 myTagProperties[currentTag] = GNETagProperties(currentTag,
4664 // from edge
4667 TL("The ID of the edge the person trip starts at"));
4668 myTagProperties[currentTag].addAttribute(attrProperty);
4669 // to busStop
4672 TL("Id of the destination busStop"));
4673 myTagProperties[currentTag].addAttribute(attrProperty);
4674 // vTypes
4677 TL("List of possible vehicle types to take"));
4678 myTagProperties[currentTag].addAttribute(attrProperty);
4679 // modes
4682 TL("List of possible traffic modes. Walking is always possible regardless of this value"));
4683 myTagProperties[currentTag].addAttribute(attrProperty);
4684 // lines
4687 TL("list of vehicle alternatives to take for the person trip"),
4688 "ANY");
4689 myTagProperties[currentTag].addAttribute(attrProperty);
4690 }
4691 currentTag = GNE_TAG_PERSONTRIP_TRAINSTOP;
4692 {
4693 // set values of tag
4694 myTagProperties[currentTag] = GNETagProperties(currentTag,
4698 // from edge
4701 TL("The ID of the edge the person trip starts at"));
4702 myTagProperties[currentTag].addAttribute(attrProperty);
4703 // to trainStop
4706 TL("Id of the destination trainStop"));
4707 myTagProperties[currentTag].addAttribute(attrProperty);
4708 // vTypes
4711 TL("List of possible vehicle types to take"));
4712 myTagProperties[currentTag].addAttribute(attrProperty);
4713 // modes
4716 TL("List of possible traffic modes. Walking is always possible regardless of this value"));
4717 myTagProperties[currentTag].addAttribute(attrProperty);
4718 // lines
4721 TL("list of vehicle alternatives to take for the person trip"),
4722 "ANY");
4723 myTagProperties[currentTag].addAttribute(attrProperty);
4724 }
4725 currentTag = GNE_TAG_PERSONTRIP_JUNCTIONS;
4726 {
4727 // set values of tag
4728 myTagProperties[currentTag] = GNETagProperties(currentTag,
4732 // from edge
4735 TL("The name of the junction the person trip starts at"));
4736 myTagProperties[currentTag].addAttribute(attrProperty);
4737 // to edge
4740 TL("The name of the junction the person trip ends at"));
4741 myTagProperties[currentTag].addAttribute(attrProperty);
4742 // vTypes
4745 TL("List of possible vehicle types to take"));
4746 myTagProperties[currentTag].addAttribute(attrProperty);
4747 // modes
4750 TL("List of possible traffic modes. Walking is always possible regardless of this value"));
4751 myTagProperties[currentTag].addAttribute(attrProperty);
4752 // lines
4755 TL("list of vehicle alternatives to take for the person trip"),
4756 "ANY");
4757 myTagProperties[currentTag].addAttribute(attrProperty);
4758 }
4759}
4760
4761
4762void
4764 // declare empty GNEAttributeProperties
4765 GNEAttributeProperties attrProperty;
4766 // fill walks
4767 SumoXMLTag currentTag = GNE_TAG_WALK_EDGE;
4768 {
4769 // set values of tag
4770 myTagProperties[currentTag] = GNETagProperties(currentTag,
4773 GUIIcon::WALK_FROMTO, SUMO_TAG_WALK, { SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW }, FXRGBA(240, 255, 205, 255));
4774 // from edge
4777 TL("The ID of the edge the walk starts at"));
4778 myTagProperties[currentTag].addAttribute(attrProperty);
4779 // to edge
4780 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
4782 TL("The ID of the edge the walk ends at"));
4783 myTagProperties[currentTag].addAttribute(attrProperty);
4784 // arrival position
4787 TL("arrival position on the destination edge"),
4788 "-1");
4789 myTagProperties[currentTag].addAttribute(attrProperty);
4790 }
4791 currentTag = GNE_TAG_WALK_BUSSTOP;
4792 {
4793 // set values of tag
4794 myTagProperties[currentTag] = GNETagProperties(currentTag,
4797 GUIIcon::WALK_BUSSTOP, SUMO_TAG_WALK, { SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW }, FXRGBA(240, 255, 205, 255));
4798 // from edge
4801 TL("The ID of the edge the walk starts at"));
4802 myTagProperties[currentTag].addAttribute(attrProperty);
4803 // to busStop
4806 TL("Id of the destination bus stop"));
4807 myTagProperties[currentTag].addAttribute(attrProperty);
4808 }
4809 currentTag = GNE_TAG_WALK_TRAINSTOP;
4810 {
4811 // set values of tag
4812 myTagProperties[currentTag] = GNETagProperties(currentTag,
4816 // from edge
4819 TL("The ID of the edge the walk starts at"));
4820 myTagProperties[currentTag].addAttribute(attrProperty);
4821 // to trainStop
4824 TL("Id of the destination train stop"));
4825 myTagProperties[currentTag].addAttribute(attrProperty);
4826 }
4827 currentTag = GNE_TAG_WALK_EDGES;
4828 {
4829 // set values of tag
4830 myTagProperties[currentTag] = GNETagProperties(currentTag,
4833 GUIIcon::WALK_EDGES, SUMO_TAG_WALK, {SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW}, FXRGBA(240, 255, 205, 255));
4834 // edges
4837 TL("id of the edges to walk"));
4838 myTagProperties[currentTag].addAttribute(attrProperty);
4839 // arrival pos
4842 TL("Arrival position on the destination edge"),
4843 "-1");
4844 myTagProperties[currentTag].addAttribute(attrProperty);
4845 }
4846 currentTag = GNE_TAG_WALK_ROUTE;
4847 {
4848 // set values of tag
4849 myTagProperties[currentTag] = GNETagProperties(currentTag,
4852 GUIIcon::WALK_ROUTE, SUMO_TAG_WALK, {SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW}, FXRGBA(240, 255, 205, 255));
4853 // route
4856 TL("The id of the route to walk"));
4857 myTagProperties[currentTag].addAttribute(attrProperty);
4858 // arrival pos
4861 TL("Arrival position on the destination edge"),
4862 "-1");
4863 myTagProperties[currentTag].addAttribute(attrProperty);
4864 }
4865
4866 currentTag = GNE_TAG_WALK_JUNCTIONS;
4867 {
4868 // set values of tag
4869 myTagProperties[currentTag] = GNETagProperties(currentTag,
4873 // from edge
4876 TL("The name of the junction the walk starts at"));
4877 myTagProperties[currentTag].addAttribute(attrProperty);
4878 // to edge
4881 TL("The name of the junction the walk ends at"));
4882 myTagProperties[currentTag].addAttribute(attrProperty);
4883 }
4884}
4885
4886
4887void
4889 // declare empty GNEAttributeProperties
4890 GNEAttributeProperties attrProperty;
4891 // fill rides
4892 SumoXMLTag currentTag = GNE_TAG_RIDE_EDGE;
4893 {
4894 // set values of tag
4895 myTagProperties[currentTag] = GNETagProperties(currentTag,
4898 GUIIcon::RIDE_BUSSTOP, SUMO_TAG_RIDE, { SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW }, FXRGBA(210, 233, 255, 255));
4899 // from edge
4902 TL("The ID of the edge the ride starts at"));
4903 myTagProperties[currentTag].addAttribute(attrProperty);
4904 // to edge
4905 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
4907 TL("The ID of the edge the ride ends at"));
4908 myTagProperties[currentTag].addAttribute(attrProperty);
4909 // arrival position
4912 TL("arrival position on the destination edge"),
4913 "-1");
4914 myTagProperties[currentTag].addAttribute(attrProperty);
4915 // lines
4918 TL("list of vehicle alternatives to take for the ride"),
4919 "ANY");
4920 myTagProperties[currentTag].addAttribute(attrProperty);
4921 }
4922 currentTag = GNE_TAG_RIDE_BUSSTOP;
4923 {
4924 // set values of tag
4925 myTagProperties[currentTag] = GNETagProperties(currentTag,
4928 GUIIcon::RIDE_BUSSTOP, SUMO_TAG_RIDE, { SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW }, FXRGBA(210, 233, 255, 255));
4929 // from edge
4932 TL("The ID of the edge the ride starts at"));
4933 myTagProperties[currentTag].addAttribute(attrProperty);
4934 // to busStop
4937 TL("ID of the destination bus stop"));
4938 myTagProperties[currentTag].addAttribute(attrProperty);
4939 // lines
4942 TL("list of vehicle alternatives to take for the ride"),
4943 "ANY");
4944 myTagProperties[currentTag].addAttribute(attrProperty);
4945 }
4946 currentTag = GNE_TAG_RIDE_TRAINSTOP;
4947 {
4948 // set values of tag
4949 myTagProperties[currentTag] = GNETagProperties(currentTag,
4953 // from edge
4956 TL("The ID of the edge the ride starts at"));
4957 myTagProperties[currentTag].addAttribute(attrProperty);
4958 // to trainStop
4961 TL("ID of the destination train stop"));
4962 myTagProperties[currentTag].addAttribute(attrProperty);
4963 // lines
4966 TL("list of vehicle alternatives to take for the ride"),
4967 "ANY");
4968 myTagProperties[currentTag].addAttribute(attrProperty);
4969 }
4970}
4971
4972
4973void
4975 // declare empty GNEAttributeProperties
4976 GNEAttributeProperties attrProperty;
4977 // fill vehicle ACs
4979 {
4980 // set values of tag
4981 myTagProperties[currentTag] = GNETagProperties(currentTag,
4985
4986 // set values of attributes
4989 TL("The ID of the edge the stop shall be located at"));
4990 myTagProperties[currentTag].addAttribute(attrProperty);
4991
4994 TL("The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m"));
4995 myTagProperties[currentTag].addAttribute(attrProperty);
4996
4999 TL("If set, no error will be reported if element is placed behind the lane.") + std::string("\n") +
5000 TL("Instead, it will be placed 0.1 meters from the lanes end or at position 0.1,") + std::string("\n") +
5001 TL("if the position was negative and larger than the lanes length after multiplication with - 1"),
5002 "0");
5003 myTagProperties[currentTag].addAttribute(attrProperty);
5004
5007 TL("Minimum duration for stopping"),
5008 "60");
5009 attrProperty.setDefaultActivated(true);
5010 myTagProperties[currentTag].addAttribute(attrProperty);
5011
5014 TL("The time step at which the route continues"),
5015 "0.00");
5016 myTagProperties[currentTag].addAttribute(attrProperty);
5017
5020 TL("Activity displayed for stopped person in GUI and output files "));
5021 myTagProperties[currentTag].addAttribute(attrProperty);
5022 }
5023 currentTag = GNE_TAG_STOPPERSON_BUSSTOP;
5024 {
5025 // set values of tag
5026 myTagProperties[currentTag] = GNETagProperties(currentTag,
5030
5031 // set values of attributes
5034 TL("BusStop associated with this stop"));
5035 myTagProperties[currentTag].addAttribute(attrProperty);
5036
5039 TL("Minimum duration for stopping"),
5040 "60");
5041 attrProperty.setDefaultActivated(true);
5042 myTagProperties[currentTag].addAttribute(attrProperty);
5043
5046 TL("The time step at which the route continues"),
5047 "0.00");
5048 myTagProperties[currentTag].addAttribute(attrProperty);
5049
5052 TL("Activity displayed for stopped person in GUI and output files "));
5053 myTagProperties[currentTag].addAttribute(attrProperty);
5054 }
5055 currentTag = GNE_TAG_STOPPERSON_TRAINSTOP;
5056 {
5057 // set values of tag
5058 myTagProperties[currentTag] = GNETagProperties(currentTag,
5062
5063 // set values of attributes
5066 TL("TrainStop associated with this stop"));
5067 myTagProperties[currentTag].addAttribute(attrProperty);
5068
5071 TL("Minimum duration for stopping"),
5072 "60");
5073 attrProperty.setDefaultActivated(true);
5074 myTagProperties[currentTag].addAttribute(attrProperty);
5075
5078 TL("The time step at which the route continues"),
5079 "0.00");
5080 myTagProperties[currentTag].addAttribute(attrProperty);
5081
5084 TL("Activity displayed for stopped person in GUI and output files "));
5085 myTagProperties[currentTag].addAttribute(attrProperty);
5086 }
5087}
5088
5089
5090void
5092 // declare empty GNEAttributeProperties
5093 GNEAttributeProperties attrProperty;
5096 TL("This vehicle's color"),
5097 "yellow");
5098 myTagProperties[currentTag].addAttribute(attrProperty);
5099
5102 TL("The lane on which thevehicle shall be inserted"),
5103 "first");
5104 myTagProperties[currentTag].addAttribute(attrProperty);
5105
5108 TL("The position at which the vehicle shall enter the net"),
5109 "base");
5110 myTagProperties[currentTag].addAttribute(attrProperty);
5111
5114 TL("The speed with which the vehicle shall enter the network"),
5115 "0.00");
5116 myTagProperties[currentTag].addAttribute(attrProperty);
5117
5120 TL("The lane at which the vehicle shall leave the network"),
5121 "current");
5122 myTagProperties[currentTag].addAttribute(attrProperty);
5123
5126 TL("The position at which the vehicle shall leave the network"),
5127 "max");
5128 myTagProperties[currentTag].addAttribute(attrProperty);
5129
5132 TL("The speed with which the vehicle shall leave the network"),
5133 "current");
5134 myTagProperties[currentTag].addAttribute(attrProperty);
5135
5138 TL("A string specifying the id of a public transport line which can be used when specifying person rides"));
5139 myTagProperties[currentTag].addAttribute(attrProperty);
5140
5143 TL("The number of occupied seats when the vehicle is inserted"),
5144 "0");
5145 myTagProperties[currentTag].addAttribute(attrProperty);
5146
5149 TL("The number of occupied container places when the vehicle is inserted"),
5150 "0");
5151 myTagProperties[currentTag].addAttribute(attrProperty);
5152
5155 TL("The lateral position on the departure lane at which the vehicle shall enter the net"),
5156 "center");
5157 myTagProperties[currentTag].addAttribute(attrProperty);
5158
5161 TL("The lateral position on the arrival lane at which the vehicle shall arrive"),
5162 "center");
5163 myTagProperties[currentTag].addAttribute(attrProperty);
5164
5167 TL("Insertion checks"),
5169 myTagProperties[currentTag].addAttribute(attrProperty);
5170}
5171
5172
5173void
5175 // declare empty GNEAttributeProperties
5176 GNEAttributeProperties attrProperty;
5177
5180 TL("First flow departure time"),
5181 "0");
5182 myTagProperties[currentTag].addAttribute(attrProperty);
5183
5186 TL("End of departure interval"),
5187 "3600");
5188 myTagProperties[currentTag].addAttribute(attrProperty);
5189
5192 TL("probability for emitting a flow each second") + std::string("\n") +
5193 TL("(not together with vehsPerHour or period)"),
5194 "1800");
5195 myTagProperties[currentTag].addAttribute(attrProperty);
5196
5197 attrProperty = GNEAttributeProperties(perHour,
5199 TL("Number of flows per hour, equally spaced") + std::string("\n") +
5200 TL("(not together with period or probability or poisson)"),
5201 "1800");
5202 myTagProperties[currentTag].addAttribute(attrProperty);
5203
5206 TL("Insert equally spaced flows at that period") + std::string("\n") +
5207 TL("(not together with vehsPerHour or probability or poisson)"),
5208 "2");
5209 myTagProperties[currentTag].addAttribute(attrProperty);
5210
5213 TL("probability for emitting a flow each second") + std::string("\n") +
5214 TL("(not together with vehsPerHour or period or poisson)"),
5215 "0.5");
5216 myTagProperties[currentTag].addAttribute(attrProperty);
5217
5220 TL("Insert flow expected vehicles per second with poisson distributed insertion rate") + std::string("\n") +
5221 TL("(not together with period or vehsPerHour or probability)"),
5222 "0.5");
5223 myTagProperties[currentTag].addAttribute(attrProperty);
5224}
5225
5226
5227void
5229 // declare empty GNEAttributeProperties
5230 GNEAttributeProperties attrProperty;
5231
5234 TL("The acceleration ability of vehicles of this type [m/s^2]"),
5235 "2.60");
5236 myTagProperties[currentTag].addAttribute(attrProperty);
5237
5240 TL("The deceleration ability of vehicles of this type [m/s^2]"),
5241 "4.50");
5242 myTagProperties[currentTag].addAttribute(attrProperty);
5243
5246 TL("The apparent deceleration of the vehicle as used by the standard model [m/s^2]"),
5247 "4.50");
5248 myTagProperties[currentTag].addAttribute(attrProperty);
5249
5252 TL("The maximal physically possible deceleration for the vehicle [m/s^2]"),
5253 "4.50");
5254 myTagProperties[currentTag].addAttribute(attrProperty);
5255
5258 TL("Car-following model parameter"),
5259 "0.50");
5260 attrProperty.setRange(0, 1);
5261 myTagProperties[currentTag].addAttribute(attrProperty);
5262
5265 TL("Car-following model parameter"),
5266 "1.00");
5267 myTagProperties[currentTag].addAttribute(attrProperty);
5268
5271 TL("SKRAUSSX parameter 1"));
5272 myTagProperties[currentTag].addAttribute(attrProperty);
5273
5276 TL("SKRAUSSX parameter 2"));
5277 myTagProperties[currentTag].addAttribute(attrProperty);
5278
5281 TL("SKRAUSSX parameter 3"));
5282 myTagProperties[currentTag].addAttribute(attrProperty);
5283
5286 TL("SKRAUSSX parameter 4"));
5287 myTagProperties[currentTag].addAttribute(attrProperty);
5288
5291 TL("SKRAUSSX parameter 5"));
5292 myTagProperties[currentTag].addAttribute(attrProperty);
5293
5296 TL("EIDM Look ahead / preview parameter [s]"),
5297 "4.00");
5298 myTagProperties[currentTag].addAttribute(attrProperty);
5299
5302 TL("EIDM AP Reaction Time parameter [s]"),
5303 "0.50");
5304 myTagProperties[currentTag].addAttribute(attrProperty);
5305
5308 TL("EIDM Wiener Process parameter for the Driving Error [s]"),
5309 "3.00");
5310 myTagProperties[currentTag].addAttribute(attrProperty);
5311
5314 TL("EIDM Wiener Process parameter for the Estimation Error [s]"),
5315 "10.00");
5316 myTagProperties[currentTag].addAttribute(attrProperty);
5317
5320 TL("EIDM Coolness parameter of the Enhanced IDM [-]"),
5321 "0.99");
5322 attrProperty.setRange(0, 1);
5323 myTagProperties[currentTag].addAttribute(attrProperty);
5324
5327 TL("EIDM leader speed estimation error parameter [-]"),
5328 "0.02");
5329 myTagProperties[currentTag].addAttribute(attrProperty);
5330
5333 TL("EIDM gap estimation error parameter [-]"),
5334 "0.10");
5335 myTagProperties[currentTag].addAttribute(attrProperty);
5336
5339 TL("EIDM driving error parameter [-]"),
5340 "0.04");
5341 myTagProperties[currentTag].addAttribute(attrProperty);
5342
5345 TL("EIDM maximal jerk parameter [m/s^3]"),
5346 "3.00");
5347 myTagProperties[currentTag].addAttribute(attrProperty);
5348
5351 TL("EIDM maximal negative acceleration between two Action Points (threshold) [m/s^2]"),
5352 "1.00");
5353 myTagProperties[currentTag].addAttribute(attrProperty);
5354
5357 TL("EIDM Time parameter until vehicle reaches amax after startup/driveoff [s]"),
5358 "1.20");
5359 myTagProperties[currentTag].addAttribute(attrProperty);
5360
5363 TL("EIDM Flatness parameter of startup/driveoff curve [-]"),
5364 "2.00");
5365 myTagProperties[currentTag].addAttribute(attrProperty);
5366
5369 TL("EIDM Shift parameter of startup/driveoff curve [-]"),
5370 "0.70");
5371 myTagProperties[currentTag].addAttribute(attrProperty);
5372
5375 TL("EIDM parameter if model shall include vehicle dynamics into the acceleration calculation [0/1]"),
5376 "0");
5377 myTagProperties[currentTag].addAttribute(attrProperty);
5378
5381 TL("EIDM parameter how many vehicles are taken into the preview calculation of the driver (at least always 1!) [-]"),
5382 "0");
5383 myTagProperties[currentTag].addAttribute(attrProperty);
5384
5387 TL("Peter Wagner 2009 parameter"),
5388 "0");
5389 myTagProperties[currentTag].addAttribute(attrProperty);
5390
5393 TL("Peter Wagner 2009 parameter"),
5394 "0");
5395 myTagProperties[currentTag].addAttribute(attrProperty);
5396
5399 TL("IDMM parameter"),
5400 "0");
5401 myTagProperties[currentTag].addAttribute(attrProperty);
5402
5405 TL("IDMM parameter"),
5406 "0");
5407 myTagProperties[currentTag].addAttribute(attrProperty);
5408
5411 TL("W99 parameter"),
5412 "1.3");
5413 myTagProperties[currentTag].addAttribute(attrProperty);
5414
5417 TL("W99 parameter"),
5418 "8.0");
5419 myTagProperties[currentTag].addAttribute(attrProperty);
5420
5423 TL("W99 parameter"),
5424 "-12.0");
5425 myTagProperties[currentTag].addAttribute(attrProperty);
5426
5429 TL("W99 parameter"),
5430 "-0.25");
5431 myTagProperties[currentTag].addAttribute(attrProperty);
5432
5435 TL("W99 parameter"),
5436 "0.35");
5437 myTagProperties[currentTag].addAttribute(attrProperty);
5438
5441 TL("W99 parameter"),
5442 "6.0");
5443 myTagProperties[currentTag].addAttribute(attrProperty);
5444
5447 TL("W99 parameter"),
5448 "0.25");
5449 myTagProperties[currentTag].addAttribute(attrProperty);
5450
5453 TL("W99 parameter"),
5454 "2.0");
5455 myTagProperties[currentTag].addAttribute(attrProperty);
5456
5459 TL("W99 parameter"),
5460 "1.5");
5461 myTagProperties[currentTag].addAttribute(attrProperty);
5462
5465 TL("Wiedemann parameter"));
5466 myTagProperties[currentTag].addAttribute(attrProperty);
5467
5470 TL("Wiedemann parameter"));
5471 myTagProperties[currentTag].addAttribute(attrProperty);
5472
5475 TL("MinGap factor parameter"));
5476 myTagProperties[currentTag].addAttribute(attrProperty);
5477
5478 attrProperty = GNEAttributeProperties(SUMO_ATTR_K,
5480 TL("K parameter"));
5481 myTagProperties[currentTag].addAttribute(attrProperty);
5482
5485 TL("Kerner Phi parameter"));
5486 myTagProperties[currentTag].addAttribute(attrProperty);
5487
5490 TL("IDM Delta parameter"));
5491 myTagProperties[currentTag].addAttribute(attrProperty);
5492
5495 TL("IDM Stepping parameter"));
5496 myTagProperties[currentTag].addAttribute(attrProperty);
5497
5500 TL("Train Types"),
5501 "NGT400");
5502 attrProperty.setDiscreteValues(SUMOXMLDefinitions::TrainTypes.getStrings(), true);
5503 myTagProperties[currentTag].addAttribute(attrProperty);
5504}
5505
5506
5507void
5509 // declare empty GNEAttributeProperties
5510 GNEAttributeProperties attrProperty;
5513 TL("Minimum distance to pedestrians that are walking towards the conflict point with the ego vehicle."),
5514 "10");
5515 myTagProperties[currentTag].addAttribute(attrProperty);
5516
5519 TL("The accumulated waiting time after which a vehicle will drive onto an intersection even though this might cause jamming."),
5520 "-1");
5521 myTagProperties[currentTag].addAttribute(attrProperty);
5522
5525 TL("This value causes vehicles to violate a yellow light if the duration of the yellow phase is lower than the given threshold."),
5526 "-1");
5527 myTagProperties[currentTag].addAttribute(attrProperty);
5528
5531 TL("This value causes vehicles to violate a red light if the duration of the red phase is lower than the given threshold."),
5532 "-1");
5533 myTagProperties[currentTag].addAttribute(attrProperty);
5534
5537 TL("This value causes vehicles affected by jmDriveAfterRedTime to slow down when violating a red light."),
5538 "0.0");
5539 myTagProperties[currentTag].addAttribute(attrProperty);
5540
5543 TL("This value causes vehicles to ignore foe vehicles that have right-of-way with the given probability."),
5544 "0.0");
5545 myTagProperties[currentTag].addAttribute(attrProperty);
5546
5549 TL("This value is used in conjunction with jmIgnoreFoeProb.") + std::string("\n") +
5550 TL("Only vehicles with a speed below or equal to the given value may be ignored."),
5551 "0.0");
5552 myTagProperties[currentTag].addAttribute(attrProperty);
5553
5556 TL("This value configures driving imperfection (dawdling) while passing a minor link."),
5557 "0.0");
5558 myTagProperties[currentTag].addAttribute(attrProperty);
5559
5562 TL("This value defines the minimum time gap when passing ahead of a prioritized vehicle. "),
5563 "1");
5564 myTagProperties[currentTag].addAttribute(attrProperty);
5565
5568 TL("Willingess of drivers to impede vehicles with higher priority"),
5569 "0.0");
5570 myTagProperties[currentTag].addAttribute(attrProperty);
5571}
5572
5573
5574void
5576 // declare empty GNEAttributeProperties
5577 GNEAttributeProperties attrProperty;
5578
5581 TL("The eagerness for performing strategic lane changing. Higher values result in earlier lane-changing."),
5582 "1.0");
5583 myTagProperties[currentTag].addAttribute(attrProperty);
5584
5587 TL("The willingness for performing cooperative lane changing. Lower values result in reduced cooperation."),
5588 "1.0");
5589 myTagProperties[currentTag].addAttribute(attrProperty);
5590
5593 TL("The eagerness for performing lane changing to gain speed. Higher values result in more lane-changing."),
5594 "1.0");
5595 myTagProperties[currentTag].addAttribute(attrProperty);
5596
5599 TL("The eagerness for following the obligation to keep right. Higher values result in earlier lane-changing."),
5600 "1.0");
5601 myTagProperties[currentTag].addAttribute(attrProperty);
5602
5605 TL("The eagerness for using the configured lateral alignment within the lane.") + std::string("\n") +
5606 TL("Higher values result in increased willingness to sacrifice speed for alignment."),
5607 "1.0");
5608 myTagProperties[currentTag].addAttribute(attrProperty);
5609
5612 TL("The eagerness for overtaking through the opposite-direction lane. Higher values result in more lane-changing."),
5613 "1.0");
5614 myTagProperties[currentTag].addAttribute(attrProperty);
5615
5618 TL("Willingness to encroach laterally on other drivers."),
5619 "0.00");
5620 myTagProperties[currentTag].addAttribute(attrProperty);
5621
5624 TL("Minimum lateral gap when encroaching laterally on other drives (alternative way to define lcPushy)"),
5625 "0.00");
5626 myTagProperties[currentTag].addAttribute(attrProperty);
5627
5630 TL("Willingness to accept lower front and rear gaps on the target lane."),
5631 "1.0");
5632 myTagProperties[currentTag].addAttribute(attrProperty);
5633
5636 TL("Dynamic factor for modifying lcAssertive and lcPushy."),
5637 "0.00");
5638 myTagProperties[currentTag].addAttribute(attrProperty);
5639
5642 TL("Time to reach maximum impatience (of 1). Impatience grows whenever a lane-change manoeuvre is blocked."),
5643 "infinity");
5644 myTagProperties[currentTag].addAttribute(attrProperty);
5645
5648 TL("Maximum lateral acceleration per second."),
5649 "1.0");
5650 myTagProperties[currentTag].addAttribute(attrProperty);
5651
5654 TL("Factor for configuring the strategic lookahead distance when a change to the left is necessary (relative to right lookahead)."),
5655 "2.0");
5656 myTagProperties[currentTag].addAttribute(attrProperty);
5657
5660 TL("Factor for configuring the threshold asymmetry when changing to the left or to the right for speed gain."),
5661 "0.1");
5662 myTagProperties[currentTag].addAttribute(attrProperty);
5663
5666 TL("Upper bound on lateral speed when standing."),
5667 "0.00");
5668 myTagProperties[currentTag].addAttribute(attrProperty);
5669
5672 TL("Upper bound on lateral speed while moving computed as lcMaxSpeedLatStanding + lcMaxSpeedLatFactor * getSpeed()"),
5673 "1.00");
5674 myTagProperties[currentTag].addAttribute(attrProperty);
5675
5678 TL("Distance to an upcoming turn on the vehicles route, below which the alignment") + std::string("\n") +
5679 TL("should be dynamically adapted to match the turn direction."),
5680 "0.00");
5681 myTagProperties[currentTag].addAttribute(attrProperty);
5682
5685 TL("The probability for violating rules gainst overtaking on the right."),
5686 "0.00");
5687 myTagProperties[currentTag].addAttribute(attrProperty);
5688
5691 TL("Time threshold for the willingness to change right."),
5692 "-1");
5693 myTagProperties[currentTag].addAttribute(attrProperty);
5694
5697 TL("Speed difference factor for the eagerness of overtaking a neighbor vehicle before changing lanes (threshold = factor*speedlimit)."),
5698 "0.00");
5699 attrProperty.setRange(-1, 1);
5700 myTagProperties[currentTag].addAttribute(attrProperty);
5701
5702 /*
5703 attrProperty = GNEAttributeProperties(SUMO_ATTR_LCA_EXPERIMENTAL1,
5704 GNEAttributeProperties::FLOAT | GNEAttributeProperties::POSITIVE | GNEAttributeProperties::DEFAULTVALUE | GNEAttributeProperties::EXTENDED,
5705 "XXXXX"),
5706 "0.00"));
5707 myTagProperties[currentTag].addAttribute(attrProperty);
5708 */
5709}
5710
5711
5712void
5714 // declare empty GNEAttributeProperties
5715 GNEAttributeProperties attrProperty;
5716
5717 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
5719 TL("The name of the person"));
5720 myTagProperties[currentTag].addAttribute(attrProperty);
5721
5724 TL("The id of the person type to use for this person"),
5726 myTagProperties[currentTag].addAttribute(attrProperty);
5727
5730 TL("This person's color"),
5731 "yellow");
5732 myTagProperties[currentTag].addAttribute(attrProperty);
5733
5736 TL("The position at which the person shall enter the net"),
5737 "base");
5738 myTagProperties[currentTag].addAttribute(attrProperty);
5739}
5740
5741
5742void
5744 // declare empty GNEAttributeProperties
5745 GNEAttributeProperties attrProperty;
5746
5747 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
5749 TL("The name of the container"));
5750 myTagProperties[currentTag].addAttribute(attrProperty);
5751
5754 TL("The id of the container type to use for this container"),
5756 myTagProperties[currentTag].addAttribute(attrProperty);
5757
5760 TL("This container's color"),
5761 "yellow");
5762 myTagProperties[currentTag].addAttribute(attrProperty);
5763}
5764
5765
5766void
5768 // declare empty GNEAttributeProperties
5769 GNEAttributeProperties attrProperty;
5770
5773 TL("Minimum duration for stopping"),
5774 "60");
5775 attrProperty.setDefaultActivated(true);
5776 myTagProperties[currentTag].addAttribute(attrProperty);
5777
5780 TL("The time step at which the route continues"),
5781 "0.00");
5782 myTagProperties[currentTag].addAttribute(attrProperty);
5783
5786 TL("If set to a non-negative time value, then the stop duration can be extended at most by the extension value in seconds"),
5787 "0");
5788 myTagProperties[currentTag].addAttribute(attrProperty);
5789
5790 if (!waypoint) {
5793 TL("Whether a person or container or both may end the stop"),
5794 "0");
5795 attrProperty.setDiscreteValues({"0", "person", "container", "join"}, true);
5796 myTagProperties[currentTag].addAttribute(attrProperty);
5797
5800 TL("List of elements that must board the vehicle before it may continue"));
5801 myTagProperties[currentTag].addAttribute(attrProperty);
5802 }
5803
5806 TL("List of elements that can board the vehicle before it may continue"));
5807 myTagProperties[currentTag].addAttribute(attrProperty);
5808
5811 TL("Whether the vehicle stops on the road or beside"),
5812 "0");
5813 attrProperty.setDiscreteValues({"1", "0", "opportunistic"}, true);
5814 myTagProperties[currentTag].addAttribute(attrProperty);
5815
5818 TL("Activity displayed for stopped person in GUI and output files"));
5819 myTagProperties[currentTag].addAttribute(attrProperty);
5820
5823 TL("Parameter to be applied to the vehicle to track the trip id within a cyclical public transport route"));
5824 myTagProperties[currentTag].addAttribute(attrProperty);
5825
5828 TL("New line attribute to be set on the vehicle when reaching this stop (for cyclical public transport route)"));
5829 myTagProperties[currentTag].addAttribute(attrProperty);
5830
5831 if (waypoint) {
5834 TL("Speed to be kept while driving between startPos and endPos"),
5835 "0.00");
5836 myTagProperties[currentTag].addAttribute(attrProperty);
5837 } else {
5840 TL("Whether the stop may be skipped if no passengers wants to embark or disembark"),
5841 "0");
5842 myTagProperties[currentTag].addAttribute(attrProperty);
5843 }
5844
5847 TL("transfer time if there shall be a jump from this stop to the next route edge"),
5848 "-1");
5849 myTagProperties[currentTag].addAttribute(attrProperty);
5850}
5851
5852
5853void
5855 // declare empty GNEAttributeProperties
5856 GNEAttributeProperties attrProperty;
5857 // fill data set element
5858 SumoXMLTag currentTag = SUMO_TAG_DATASET;
5859 {
5860 // set values of tag
5861 myTagProperties[currentTag] = GNETagProperties(currentTag,
5864 GUIIcon::DATASET, currentTag);
5865
5866 // set values of attributes
5867 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
5869 TL("Data set ID"));
5870 myTagProperties[currentTag].addAttribute(attrProperty);
5871
5872 }
5873 // fill data interval element
5874 currentTag = SUMO_TAG_DATAINTERVAL;
5875 {
5876 // set values of tag
5877 myTagProperties[currentTag] = GNETagProperties(currentTag,
5881
5882 // set values of attributes
5883 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
5885 TL("Interval ID"));
5886 myTagProperties[currentTag].addAttribute(attrProperty);
5887
5888 // set values of attributes
5891 TL("Data interval begin time"),
5892 "0");
5893 myTagProperties[currentTag].addAttribute(attrProperty);
5894
5897 TL("Data interval end time"),
5898 "3600");
5899 myTagProperties[currentTag].addAttribute(attrProperty);
5900 }
5901 // fill edge data element
5902 currentTag = GNE_TAG_EDGEREL_SINGLE;
5903 {
5904 // set values of tag
5905 myTagProperties[currentTag] = GNETagProperties(currentTag,
5907 0,
5909
5910 // set values of attributes
5911 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
5913 TL("edge ID"));
5914 myTagProperties[currentTag].addAttribute(attrProperty);
5915 }
5916 currentTag = SUMO_TAG_EDGEREL;
5917 {
5918 // set values of tag
5919 myTagProperties[currentTag] = GNETagProperties(currentTag,
5921 0,
5922 GUIIcon::EDGERELDATA, currentTag);
5923
5924 // set values of attributes
5927 TL("The ID of the edge the edgeRel starts at"));
5928 myTagProperties[currentTag].addAttribute(attrProperty);
5929
5930 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
5932 TL("The ID of the edge the edgeRel ends at"));
5933 myTagProperties[currentTag].addAttribute(attrProperty);
5934 }
5935 currentTag = SUMO_TAG_TAZREL;
5936 {
5937 // set values of tag
5938 myTagProperties[currentTag] = GNETagProperties(currentTag,
5942
5943 // set values of attributes
5946 TL("The name of the TAZ the TAZRel starts at"));
5947 myTagProperties[currentTag].addAttribute(attrProperty);
5948
5949 attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
5951 TL("The name of the TAZ the TAZRel ends at"));
5952 myTagProperties[currentTag].addAttribute(attrProperty);
5953 }
5954 currentTag = SUMO_TAG_MEANDATA_EDGE;
5955 {
5956 // set values of tag
5957 myTagProperties[currentTag] = GNETagProperties(currentTag,
5960 GUIIcon::MEANDATAEDGE, currentTag);
5961
5962 // set values of attributes
5963 fillCommonMeanDataAttributes(currentTag);
5964
5965 }
5966 currentTag = SUMO_TAG_MEANDATA_LANE;
5967 {
5968 // set values of tag
5969 myTagProperties[currentTag] = GNETagProperties(currentTag,
5972 GUIIcon::MEANDATALANE, currentTag);
5973
5974 // set values of attributes
5975 fillCommonMeanDataAttributes(currentTag);
5976 }
5977}
5978
5979
5980void
5982 GNEAttributeProperties attrProperty;
5983 // fill all meanData attributes
5984 attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
5986 TL("The id of this set of measurements"));
5987 myTagProperties[currentTag].addAttribute(attrProperty);
5988
5991 TL("The path to the output file. The path may be relative"));
5992 myTagProperties[currentTag].addAttribute(attrProperty);
5993
5996 TL("The aggregation period the values the detector collects shall be summed up"));
5997 myTagProperties[currentTag].addAttribute(attrProperty);
5998
6001 TL("The time to start writing. If not given, the simulation's begin is used."));
6002 myTagProperties[currentTag].addAttribute(attrProperty);
6003
6006 TL("The time to end writing. If not given the simulation's end is used."));
6007 myTagProperties[currentTag].addAttribute(attrProperty);
6008
6011 TL("If set to true, edges/lanes which were not use by a vehicle during this period will not be written"),
6012 "default");
6013 attrProperty.setDiscreteValues({"1", "0", "default"}, true);
6014 myTagProperties[currentTag].addAttribute(attrProperty);
6015
6018 TL("If set, junction internal edges/lanes will be written as well"),
6019 "0");
6020 myTagProperties[currentTag].addAttribute(attrProperty);
6021
6024 TL("The maximum travel time in seconds to write if only very small movements occur"),
6025 "100000");
6026 myTagProperties[currentTag].addAttribute(attrProperty);
6027
6030 TL("Consider an edge/lane unused if it has at most this many sampled seconds"),
6031 "0");
6032 myTagProperties[currentTag].addAttribute(attrProperty);
6033
6036 TL("The maximum speed to consider a vehicle halting;"),
6037 "0.1");
6038 myTagProperties[currentTag].addAttribute(attrProperty);
6039
6042 TL("space separated list of vehicle type ids to consider"));
6043 myTagProperties[currentTag].addAttribute(attrProperty);
6044
6047 TL("whether aggregation should be performed over all vehicles that entered the edge/lane in the aggregation interval"),
6048 "0");
6049 myTagProperties[currentTag].addAttribute(attrProperty);
6050
6053 TL("Whether pedestrians shall be recorded instead of vehicles. Allowed value is walk"));
6054 myTagProperties[currentTag].addAttribute(attrProperty);
6055
6058 TL("List of attribute names that shall be written"));
6059 myTagProperties[currentTag].addAttribute(attrProperty);
6060
6063 TL("Restrict output to the given list of edge ids"));
6064 myTagProperties[currentTag].addAttribute(attrProperty);
6065
6068 TL("Restrict output to the given the list of edges given in file"));
6069 myTagProperties[currentTag].addAttribute(attrProperty);
6070
6073 TL("Whether the traffic statistic of all edges shall be aggregated into a single value"),
6074 "0");
6075 myTagProperties[currentTag].addAttribute(attrProperty);
6076}
6077
6078
6079void
6081 if (myTagProperties.size() == 0) {
6083 }
6084 // merge "virtual" netedit tags like '<walk: edge->edge'
6085 static std::map<SumoXMLTag, GNETagProperties> xmlTagProperties;
6086 for (const auto& item : myTagProperties) {
6087 if (xmlTagProperties.count(item.second.getXMLTag()) == 0) {
6088 xmlTagProperties[item.second.getXMLTag()] = item.second;
6089 } else {
6090 std::set<SumoXMLAttr> attrs;
6091 auto& old = xmlTagProperties[item.second.getXMLTag()];
6092 for (auto it = old.begin(); it != old.end(); it++) {
6093 attrs.insert(it->getAttr());
6094 }
6095 for (auto it = item.second.begin(); it != item.second.end(); it++) {
6096 if (attrs.count(it->getAttr()) == 0) {
6097 old.addAttribute(*it);
6098 }
6099 }
6100 }
6101 }
6102 const std::string opt = "attribute-help-output";
6105 dev << "# Netedit attribute help\n";
6106 for (const auto& item : xmlTagProperties) {
6107 if (item.second.begin() == item.second.end()) {
6108 // don't write elements without attributes, they are only used for internal purposes
6109 continue;
6110 }
6111 if (item.second.getParentTags().empty()) {
6112 dev << "\n## " << toString(item.first) << "\n";
6113 } else {
6114 if (item.first == SUMO_TAG_FLOW) {
6115 dev << "\n## " << toString(item.first) << "\n";
6116 dev << "also child element of ";
6117 } else {
6118 dev << "\n### " << toString(item.first) << "\n";
6119 dev << "child element of ";
6120 }
6121 bool sep = false;
6122 for (const auto& pTag : item.second.getParentTags()) {
6123 if (sep) {
6124 dev << ", ";
6125 } else {
6126 sep = true;
6127 }
6128 dev << "[" << toString(pTag) << "](#" << StringUtils::to_lower_case(toString(pTag)) << ")";
6129 }
6130 dev << "\n\n";
6131 }
6132 dev << "| Attribute | Type | Description |\n";
6133 dev << "|-----------|------|-------------|\n";
6134 for (const auto& attr : item.second) {
6135 dev << "|" << toString(attr.getAttr()) << "|"
6136 << attr.getDescription() << "|"
6137 << StringUtils::replace(attr.getDefinition(), "\n", " ");
6138 if (attr.getDefaultValue() != "") {
6139 dev << " *default:* **" << attr.getDefaultValue() << "**";
6140 }
6141 dev << "|\n";
6142 }
6143 }
6144}
6145
6146
6147/****************************************************************************/
long long int SUMOTime
Definition GUI.h:36
GUISelectedStorage gSelected
A global holder of selected objects.
@ PARKINGSPACE
@ PERSONTRIP_JUNCTIONS
@ MEANDATALANE
@ PERSONTRIP_TRAINSTOP
@ CONTAINERFLOW
@ WALK_TRAINSTOP
@ PERSONTRIP_BUSSTOP
@ CLOSINGREROUTE
@ MEANDATAEDGE
@ CONTAINERSTOP
@ TRANSPORT_CONTAINERSTOP
@ TRANSHIP_EDGES
@ WALK_JUNCTIONS
@ TRIP_JUNCTIONS
@ DATAINTERVAL
@ FLOW_JUNCTIONS
@ ROUTEPROBREROUTE
@ TRACTION_SUBSTATION
@ CHARGINGSTATION
@ WALK_BUSSTOP
@ TRANSHIP_CONTAINERSTOP
@ PARKINGZONEREROUTE
@ CLOSINGLANEREROUTE
@ RIDE_BUSSTOP
@ DESTPROBREROUTE
@ PERSONTRIP_FROMTO
@ REROUTERINTERVAL
@ VTYPEDISTRIBUTION
@ VARIABLESPEEDSIGN
@ OVERHEADWIRE
@ RIDE_TRAINSTOP
@ OVERHEADWIRE_CLAMP
#define TL(string)
Definition MsgHandler.h:287
#define TLF(string,...)
Definition MsgHandler.h:288
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition SUMOTime.cpp:46
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_IGNORING
vehicles ignoring classes
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
@ SUMO_TAG_TRACTION_SUBSTATION
A traction substation.
@ GNE_TAG_TRIP_TAZS
a single trip definition that uses TAZs
@ SUMO_TAG_INTERVAL
an aggreagated-output interval
@ SUMO_TAG_CLOSING_REROUTE
reroute of type closing
@ 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
@ 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
@ GNE_TAG_STOP_PARKINGAREA
stop placed over a parking area
@ 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.
@ GNE_TAG_STOP_BUSSTOP
stop placed over a busStop
@ SUMO_TAG_CONTAINERFLOW
@ SUMO_TAG_PARKING_AREA_REROUTE
entry for an alternative parking zone
@ GNE_TAG_WAYPOINT_TRAINSTOP
waypoint placed over a busStop
@ SUMO_TAG_TAZSINK
a sink within a district (connection road)
@ GNE_TAG_EDGEREL_SINGLE
@ GNE_TAG_WAYPOINT_CONTAINERSTOP
waypoint placed over a containerStop
@ GNE_TAG_STOPCONTAINER_EDGE
@ GNE_TAG_WAYPOINT_BUSSTOP
waypoint placed over a busStop
@ 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
@ GNE_TAG_STOPPERSON_BUSSTOP
@ GNE_TAG_INTERNAL_LANE
internal lane
@ SUMO_TAG_STOP
stop for vehicles
@ SUMO_TAG_MEANDATA_LANE
a lane based mean data detector
@ 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
@ 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
@ GNE_TAG_POIGEO
Point of interest over view with GEO attributes.
@ GNE_TAG_TRANSHIP_EDGES
@ SUMO_TAG_LANETYPE
lane type
@ GNE_TAG_STOP_CONTAINERSTOP
stop placed over a containerStop
@ GNE_TAG_STOPCONTAINER_CONTAINERSTOP
@ GNE_TAG_FLOW_WITHROUTE
description of a vehicle with an embedded route
@ SUMO_TAG_FLOW
a flow definition using from and to edges or a route
@ SUMO_TAG_CONNECTION
connectioon between two lanes
@ SUMO_TAG_PARKING_AREA
A parking area.
@ SUMO_TAG_TRANSPORT
@ SUMO_TAG_WALKINGAREA
walking area for pedestrians
@ GNE_TAG_PERSONTRIP_TRAINSTOP
@ SUMO_TAG_ROUTE_PROB_REROUTE
probability of route of a reroute
@ GNE_TAG_FLOW_TAZS
a flow between TAZs
@ 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_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
@ GNE_TAG_CALIBRATOR_FLOW
a flow definition within in Calibrator
@ SUMO_TAG_DEST_PROB_REROUTE
probability of destination of a reroute
@ GNE_TAG_POILANE
Point of interest over Lane.
@ SUMO_TAG_DATASET
@ GNE_TAG_WAYPOINT_LANE
waypoint placed over a lane
@ SUMO_TAG_PERSON
@ SUMO_TAG_DET_EXIT
an e3 exit point
@ SUMO_TAG_PERSONTRIP
@ SUMO_TAG_TYPE
type (edge)
@ GNE_TAG_WALK_TRAINSTOP
@ SUMO_TAG_VAPORIZER
vaporizer of vehicles
@ SUMO_TAG_LANE_AREA_DETECTOR
alternative tag for e2 detector
@ GNE_TAG_REROUTER_SYMBOL
Rerouter Symbol.
@ GNE_TAG_STOP_LANE
stop placed over a lane
@ GNE_TAG_STOPPERSON_TRAINSTOP
@ SUMO_TAG_TAZREL
a relation between two TAZs
@ GNE_TAG_RIDE_TRAINSTOP
@ 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_STOP_TRAINSTOP
stop placed over a trainStop
@ GNE_TAG_STOP_CHARGINGSTATION
stop placed over a charging station
@ GNE_TAG_PERSONTRIP_EDGE
@ GNE_TAG_ROUTE_EMBEDDED
embedded route
@ 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_W99_CC9
@ SUMO_ATTR_CF_EIDM_T_ACC_MAX
@ SUMO_ATTR_STARTPOS
@ SUMO_ATTR_CF_EIDM_EPSILON_ACC
@ SUMO_ATTR_PARKING
@ SUMO_ATTR_EXTENSION
@ SUMO_ATTR_CF_W99_CC5
@ 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
@ GNE_ATTR_TO_TRAINSTOP
to trainStop (used by personPlans)
@ 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_TRAIN_STOP
@ SUMO_ATTR_TRACK_VEHICLES
@ 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
@ SUMO_ATTR_WITH_INTERNAL
@ 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_AGGREGATE
@ SUMO_ATTR_HALTING_TIME_THRESHOLD
@ SUMO_ATTR_TMP2
@ SUMO_ATTR_CF_W99_CC8
@ 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_LEFTHAND
@ 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_MAX_TRAVELTIME
@ 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_TO_TAZ
@ 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_CF_W99_CC3
@ 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_FROM_TAZ
@ 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_BIKELANEWIDTH
@ 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_CF_W99_CC2
@ SUMO_ATTR_OUTPUT
@ SUMO_ATTR_CF_W99_CC4
@ SUMO_ATTR_JM_SIGMA_MINOR
@ SUMO_ATTR_CF_W99_CC6
@ SUMO_ATTR_CHARGINGPOWER
@ SUMO_ATTR_JUMP
@ 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_SIDEWALKWIDTH
@ SUMO_ATTR_SPEEDFACTOR
@ SUMO_ATTR_ONROAD
@ SUMO_ATTR_LAT
@ SUMO_ATTR_TO_LANE
@ SUMO_ATTR_MIN_SAMPLES
@ 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
@ GNE_ATTR_VTYPE_DISTRIBUTION_PROBABILITY
vehicle type distribution
@ 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_CF_W99_CC7
@ SUMO_ATTR_LCA_STRATEGIC_PARAM
@ SUMO_ATTR_CF_W99_CC1
@ 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_WRITE_ATTRIBUTES
@ 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_DETECT_PERSONS
@ SUMO_ATTR_EXCLUDE_EMPTY
@ SUMO_ATTR_CF_WIEDEMANN_ESTIMATION
@ SUMO_ATTR_EDGESFILE
@ SUMO_ATTR_RELATIVEPATH
@ SUMO_ATTR_PERSONSPERHOUR
@ SUMO_ATTR_LCA_SPEEDGAINRIGHT
const double INVALID_DOUBLE
invalid double
Definition StdDefs.h:64
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:283
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 writeAttributeHelp()
write machine readable attribute help to file
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 fillCommonMeanDataAttributes(SumoXMLTag currentTag)
fill stop person attributes
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
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 setDefaultActivated(const bool value)
set default activated value
void setRange(const double minimum, const double maximum)
set range
void setDiscreteValues(const std::vector< std::string > &discreteValues, bool showAll)
set discrete values
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:120
GNEViewNet * getViewNet() const
get view net
Definition GNENet.cpp:2030
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
void addAttribute(const GNEAttributeProperties &attributeProperty)
add attribute (duplicated attributed aren't allowed)
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)
void setFieldString(const std::string &fieldString)
set field that will be drawn in TextFields/ComboBox/etc,
const GNEViewNetHelper::EditModes & getEditModes() const
get edit modes
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:359
static const double UNSPECIFIED_CONTPOS
unspecified internal junction position
Definition NBEdge.h:353
static const double UNSPECIFIED_VISIBILITY_DISTANCE
unspecified foe visibility for connections
Definition NBEdge.h:356
static const double UNSPECIFIED_SPEED
unspecified lane speed
Definition NBEdge.h:347
static OptionsCont & getOptions()
Retrieves the options.
Static storage of an output device and its base (abstract) implementation.
static bool createDeviceByOption(const std::string &optionName, const std::string &rootElement="", const std::string &schemaFile="")
Creates the device using the output definition stored in the named option.
static OutputDevice & getDeviceByOption(const std::string &name)
Returns the device described by the option.
std::map< std::string, std::string > Map
parameters map
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< int > Tags
The names of SUMO-XML elements for use in netbuild.
static StringBijection< LaneChangeModel > LaneChangeModels
lane change models
static StringBijection< RightOfWay > RightOfWayValues
righ of way algorithms
static StringBijection< int > Attrs
The names of SUMO-XML attributes for use in netbuild.
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 std::string to_lower_case(const std::string &str)
Transfers the content to lower case.
static std::string replace(std::string str, const std::string &what, const std::string &by)
Replaces all occurrences of the second string by the third string within the first string.
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
static FXIcon * getVClassIcon(const SUMOVehicleClass vc)
returns icon associated to the given vClass
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