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