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>
22 #include <netedit/GNEViewParent.h>
29 
30 #include "GNEAttributeCarrier.h"
31 
32 
33 // ===========================================================================
34 // static members
35 // ===========================================================================
36 
37 std::map<SumoXMLTag, GNETagProperties> GNEAttributeCarrier::myTagProperties;
38 const std::string GNEAttributeCarrier::FEATURE_LOADED = "loaded";
39 const std::string GNEAttributeCarrier::FEATURE_GUESSED = "guessed";
40 const std::string GNEAttributeCarrier::FEATURE_MODIFIED = "modified";
41 const std::string GNEAttributeCarrier::FEATURE_APPROVED = "approved";
43 
44 
45 // ===========================================================================
46 // method definitions
47 // ===========================================================================
48 
50  myTagProperty(getTagProperty(tag)),
51  myNet(net),
52  mySelected(false),
53  myIsTemplate(false) {
54 }
55 
56 
58 
59 
60 GNENet*
62  return myNet;
63 }
64 
65 
66 void
69  gSelected.select(getGUIGlObject()->getGlID());
70  if (changeFlag) {
71  mySelected = true;
72  }
73  }
74 }
75 
76 
77 void
80  gSelected.deselect(getGUIGlObject()->getGlID());
81  if (changeFlag) {
82  mySelected = false;
83  }
84  }
85 }
86 
87 
88 bool
90  return mySelected;
91 }
92 
93 
94 bool
96  // get flag for network element
98  // check supermode network
99  if ((networkElement && myNet->getViewNet()->getEditModes().isCurrentSupermodeNetwork()) ||
102  return mySelected;
103  } else {
104  return false;
105  }
106 }
107 
108 
109 void
111  for (const auto& attrProperty : myTagProperty) {
112  if (attrProperty.hasDefaultValue()) {
113  setAttribute(attrProperty.getAttr(), attrProperty.getDefaultValue());
114  if (attrProperty.isActivatable()) {
115  toogleAttribute(attrProperty.getAttr(), attrProperty.getDefaultActivated(), -1);
116  }
117  }
118  }
119 }
120 
121 
122 template<> int
123 GNEAttributeCarrier::parse(const std::string& string) {
124  return StringUtils::toInt(string);
125 }
126 
127 
128 template<> double
129 GNEAttributeCarrier::parse(const std::string& string) {
130  return StringUtils::toDouble(string);
131 }
132 
133 
134 template<> SUMOTime
135 GNEAttributeCarrier::parse(const std::string& string) {
136  SUMOTime time = string2time(string);
137  if (time < 0) {
138  throw TimeFormatException("SUMOTIME cannot be negative");
139  } else {
140  return time;
141  }
142 }
143 
144 
145 template<> bool
146 GNEAttributeCarrier::parse(const std::string& string) {
147  return StringUtils::toBool(string);
148 }
149 
150 
151 template<> std::string
152 GNEAttributeCarrier::parse(const std::string& string) {
153  return string;
154 }
155 
156 
157 template<> SUMOVehicleClass
158 GNEAttributeCarrier::parse(const std::string& string) {
159  if (string.size() == 0) {
160  throw EmptyData();
161  } else if (!SumoVehicleClassStrings.hasString(string)) {
162  return SVC_IGNORING;
163  } else {
164  return SumoVehicleClassStrings.get(string);
165  }
166 }
167 
168 
169 template<> RGBColor
170 GNEAttributeCarrier::parse(const std::string& string) {
171  if (string.empty()) {
172  return RGBColor(false);
173  } else {
174  return RGBColor::parseColor(string);
175  }
176 }
177 
178 
179 template<> Position
180 GNEAttributeCarrier::parse(const std::string& string) {
181  if (string.size() == 0) {
182  throw EmptyData();
183  } else {
184  bool ok = true;
185  PositionVector pos = GeomConvHelper::parseShapeReporting(string, "user-supplied position", 0, ok, false, false);
186  if (!ok || (pos.size() != 1)) {
187  throw NumberFormatException("(Position) " + string);
188  } else {
189  return pos[0];
190  }
191  }
192 }
193 
194 
195 template<> PositionVector
196 GNEAttributeCarrier::parse(const std::string& string) {
197  PositionVector posVector;
198  // empty string are allowed (It means empty position vector)
199  if (string.empty()) {
200  return posVector;
201  } else {
202  bool ok = true;
203  posVector = GeomConvHelper::parseShapeReporting(string, "user-supplied shape", 0, ok, false, true);
204  if (!ok) {
205  throw NumberFormatException("(Position List) " + string);
206  } else {
207  return posVector;
208  }
209  }
210 }
211 
212 
213 template<> SUMOVehicleShape
214 GNEAttributeCarrier::parse(const std::string& string) {
215  if ((string == "unknown") || (!SumoVehicleShapeStrings.hasString(string))) {
217  } else {
218  return SumoVehicleShapeStrings.get(string);
219  }
220 }
221 
222 
223 template<> std::vector<std::string>
224 GNEAttributeCarrier::parse(const std::string& string) {
225  return StringTokenizer(string).getVector();
226 }
227 
228 
229 template<> std::set<std::string>
230 GNEAttributeCarrier::parse(const std::string& string) {
231  std::vector<std::string> vectorString = StringTokenizer(string).getVector();
232  std::set<std::string> solution;
233  for (const auto& i : vectorString) {
234  solution.insert(i);
235  }
236  return solution;
237 }
238 
239 
240 template<> std::vector<int>
241 GNEAttributeCarrier::parse(const std::string& string) {
242  std::vector<std::string> parsedValues = parse<std::vector<std::string> >(string);
243  std::vector<int> parsedIntValues;
244  for (const auto& i : parsedValues) {
245  parsedIntValues.push_back(parse<int>(i));
246  }
247  return parsedIntValues;
248 }
249 
250 
251 template<> std::vector<double>
252 GNEAttributeCarrier::parse(const std::string& string) {
253  std::vector<std::string> parsedValues = parse<std::vector<std::string> >(string);
254  std::vector<double> parsedDoubleValues;
255  for (const auto& i : parsedValues) {
256  parsedDoubleValues.push_back(parse<double>(i));
257  }
258  return parsedDoubleValues;
259 }
260 
261 
262 template<> std::vector<bool>
263 GNEAttributeCarrier::parse(const std::string& string) {
264  std::vector<std::string> parsedValues = parse<std::vector<std::string> >(string);
265  std::vector<bool> parsedBoolValues;
266  for (const auto& i : parsedValues) {
267  parsedBoolValues.push_back(parse<bool>(i));
268  }
269  return parsedBoolValues;
270 }
271 
272 
273 template<> std::vector<GNEEdge*>
274 GNEAttributeCarrier::parse(GNENet* net, const std::string& value) {
275  // Declare string vector
276  std::vector<std::string> edgeIds = GNEAttributeCarrier::parse<std::vector<std::string> > (value);
277  std::vector<GNEEdge*> parsedEdges;
278  // Iterate over edges IDs, retrieve Edges and add it into parsedEdges
279  for (const auto& i : edgeIds) {
280  GNEEdge* retrievedEdge = net->getAttributeCarriers()->retrieveEdge(i, false);
281  if (retrievedEdge) {
282  parsedEdges.push_back(net->getAttributeCarriers()->retrieveEdge(i));
283  } else {
284  throw FormatException("Error parsing parameter " + toString(SUMO_ATTR_EDGES) + ". " + toString(SUMO_TAG_EDGE) + " '" + i + "' doesn't exist");
285  }
286  }
287  return parsedEdges;
288 }
289 
290 
291 template<> std::vector<GNELane*>
292 GNEAttributeCarrier::parse(GNENet* net, const std::string& value) {
293  // Declare string vector
294  std::vector<std::string> laneIds = GNEAttributeCarrier::parse<std::vector<std::string> > (value);
295  std::vector<GNELane*> parsedLanes;
296  // Iterate over lanes IDs, retrieve Lanes and add it into parsedLanes
297  for (const auto& i : laneIds) {
298  GNELane* retrievedLane = net->getAttributeCarriers()->retrieveLane(i, false);
299  if (retrievedLane) {
300  parsedLanes.push_back(net->getAttributeCarriers()->retrieveLane(i));
301  } else {
302  throw FormatException("Error parsing parameter " + toString(SUMO_ATTR_LANES) + ". " + toString(SUMO_TAG_LANE) + " '" + i + "' doesn't exist");
303  }
304  }
305  return parsedLanes;
306 }
307 
308 
309 template<> std::string
310 GNEAttributeCarrier::parseIDs(const std::vector<GNEEdge*>& ACs) {
311  // obtain ID's of edges and return their join
312  std::vector<std::string> edgeIDs;
313  for (const auto& i : ACs) {
314  edgeIDs.push_back(i->getID());
315  }
316  return joinToString(edgeIDs, " ");
317 }
318 
319 
320 template<> std::string
321 GNEAttributeCarrier::parseIDs(const std::vector<GNELane*>& ACs) {
322  // obtain ID's of lanes and return their join
323  std::vector<std::string> laneIDs;
324  for (const auto& i : ACs) {
325  laneIDs.push_back(i->getID());
326  }
327  return joinToString(laneIDs, " ");
328 }
329 
330 
331 bool
332 GNEAttributeCarrier::lanesConsecutives(const std::vector<GNELane*>& lanes) {
333  // we need at least two lanes
334  if (lanes.size() > 1) {
335  // now check that lanes are consecutives (not neccesary connected)
336  int currentLane = 0;
337  while (currentLane < ((int)lanes.size() - 1)) {
338  int nextLane = -1;
339  // iterate over outgoing edges of destiny juntion of edge's lane
340  for (int i = 0; (i < (int)lanes.at(currentLane)->getParentEdge()->getToJunction()->getGNEOutgoingEdges().size()) && (nextLane == -1); i++) {
341  // iterate over lanes of outgoing edges of destiny juntion of edge's lane
342  for (int j = 0; (j < (int)lanes.at(currentLane)->getParentEdge()->getToJunction()->getGNEOutgoingEdges().at(i)->getLanes().size()) && (nextLane == -1); j++) {
343  // check if lane correspond to the next lane of "lanes"
344  if (lanes.at(currentLane)->getParentEdge()->getToJunction()->getGNEOutgoingEdges().at(i)->getLanes().at(j) == lanes.at(currentLane + 1)) {
345  nextLane = currentLane;
346  }
347  }
348  }
349  if (nextLane == -1) {
350  return false;
351  } else {
352  currentLane++;
353  }
354  }
355  return true;
356  } else {
357  return false;
358  }
359 }
360 
361 
362 template<> std::string
364  std::string result;
365  // Generate an string using the following structure: "key1=value1|key2=value2|...
366  for (const auto& parameter : getACParametersMap()) {
367  result += parameter.first + "=" + parameter.second + "|";
368  }
369  // remove the last "|"
370  if (!result.empty()) {
371  result.pop_back();
372  }
373  return result;
374 }
375 
376 
377 template<> std::vector<std::pair<std::string, std::string> >
379  std::vector<std::pair<std::string, std::string> > result;
380  // Generate a vector string using the following structure: "<key1,value1>, <key2, value2>,...
381  for (const auto& parameter : getACParametersMap()) {
382  result.push_back(std::make_pair(parameter.first, parameter.second));
383  }
384  return result;
385 }
386 
387 
388 void
389 GNEAttributeCarrier::setACParameters(const std::string& parameters, GNEUndoList* undoList) {
390  // declare map
391  std::map<std::string, std::string> parametersMap;
392  // separate value in a vector of string using | as separator
393  StringTokenizer parametersTokenizer(parameters, "|", true);
394  // iterate over all values
395  while (parametersTokenizer.hasNext()) {
396  // obtain key and value and save it in myParameters
397  const std::vector<std::string> keyValue = StringTokenizer(parametersTokenizer.next(), "=", true).getVector();
398  if (keyValue.size() == 2) {
399  parametersMap[keyValue.front()] = keyValue.back();
400  }
401  }
402  // set setACParameters map
403  setACParameters(parametersMap, undoList);
404 }
405 
406 
407 void
408 GNEAttributeCarrier::setACParameters(const std::vector<std::pair<std::string, std::string> >& parameters, GNEUndoList* undoList) {
409  // declare parametersMap
410  std::map<std::string, std::string> parametersMap;
411  // Generate an string using the following structure: "key1=value1|key2=value2|...
412  for (const auto& parameter : parameters) {
413  parametersMap[parameter.first] = parameter.second;
414  }
415  // set setACParameters map
416  setACParameters(parametersMap, undoList);
417 }
418 
419 
420 void
421 GNEAttributeCarrier::setACParameters(const std::map<std::string, std::string>& parameters, GNEUndoList* undoList) {
422  // declare result string
423  std::string paramsStr;
424  // Generate an string using the following structure: "key1=value1|key2=value2|...
425  for (const auto& parameter : parameters) {
426  paramsStr += parameter.first + "=" + parameter.second + "|";
427  }
428  // remove the last "|"
429  if (!paramsStr.empty()) {
430  paramsStr.pop_back();
431  }
432  // set parameters
433  setAttribute(GNE_ATTR_PARAMETERS, paramsStr, undoList);
434 }
435 
436 
437 void
438 GNEAttributeCarrier::addACParameters(const std::string& key, const std::string& attribute, GNEUndoList* undoList) {
439  // get parametersMap
440  std::map<std::string, std::string> parametersMap = getACParametersMap();
441  // add (or update) attribute
442  parametersMap[key] = attribute;
443  // set attribute
444  setACParameters(parametersMap, undoList);
445 }
446 
447 
448 void
449 GNEAttributeCarrier::removeACParametersKeys(const std::vector<std::string>& keepKeys, GNEUndoList* undoList) {
450  // declare parametersMap
451  std::map<std::string, std::string> newParametersMap;
452  // iterate over parameters map
453  for (const auto& parameter : getACParametersMap()) {
454  // copy to newParametersMap if key is in keepKeys
455  if (std::find(keepKeys.begin(), keepKeys.end(), parameter.first) != keepKeys.end()) {
456  newParametersMap.insert(parameter);
457  }
458  }
459  // set newParametersMap map
460  setACParameters(newParametersMap, undoList);
461 }
462 
463 
464 std::string
466  switch (key) {
467  // Crossings
470  return "No TLS";
471  // connections
472  case SUMO_ATTR_DIR: {
473  // special case for connection directions
474  std::string direction = getAttribute(key);
475  if (direction == "s") {
476  return "Straight (s)";
477  } else if (direction == "t") {
478  return "Turn (t))";
479  } else if (direction == "l") {
480  return "Left (l)";
481  } else if (direction == "r") {
482  return "Right (r)";
483  } else if (direction == "L") {
484  return "Partially left (L)";
485  } else if (direction == "R") {
486  return "Partially right (R)";
487  } else if (direction == "invalid") {
488  return "No direction (Invalid))";
489  } else {
490  return "undefined";
491  }
492  }
493  case SUMO_ATTR_STATE: {
494  // special case for connection states
495  std::string state = getAttribute(key);
496  if (state == "-") {
497  return "Dead end (-)";
498  } else if (state == "=") {
499  return "equal (=)";
500  } else if (state == "m") {
501  return "Minor link (m)";
502  } else if (state == "M") {
503  return "Major link (M)";
504  } else if (state == "O") {
505  return "TLS controller off (O)";
506  } else if (state == "o") {
507  return "TLS yellow flashing (o)";
508  } else if (state == "y") {
509  return "TLS yellow minor link (y)";
510  } else if (state == "Y") {
511  return "TLS yellow major link (Y)";
512  } else if (state == "r") {
513  return "TLS red (r)";
514  } else if (state == "g") {
515  return "TLS green minor (g)";
516  } else if (state == "G") {
517  return "TLS green major (G)";
518  } else {
519  return "undefined";
520  }
521  }
522  // flows
525  case SUMO_ATTR_PERIOD:
526  case SUMO_ATTR_PROB:
527  case SUMO_ATTR_END:
528  case SUMO_ATTR_NUMBER:
532  return "not together with number and period or probability";
533  } else {
534  return "not together with end and period or probability";
535  }
538  return "not together with number and period or probability";
539  } else {
540  return "not together with end and period or probability";
541  }
542  } else if (isAttributeEnabled(SUMO_ATTR_PERIOD)) {
544  return "not together with number and vehsPerHour or probability";
545  } else {
546  return "not together with end and vehsPerHour or probability";
547  }
548  } else if (isAttributeEnabled(SUMO_ATTR_PROB)) {
550  return "not together with number and vehsPerHour or period";
551  } else {
552  return "not together with end and vehsPerHour or period";
553  }
555  return "not together with end and number";
556  }
557  }
558  return "0";
559  default:
560  return getAttribute(key);
561  }
562 }
563 
564 
565 std::string
567  return getAttribute(key);
568 }
569 
570 
571 const std::string&
573  return myTagProperty.getTagStr();
574 }
575 
576 
577 FXIcon*
579  // define on first access
580  if (myTagProperties.size() == 0) {
582  }
584 }
585 
586 
587 bool
589  return myIsTemplate;
590 }
591 
592 
593 const GNETagProperties&
595  return myTagProperty;
596 }
597 
598 // ===========================================================================
599 // static methods
600 // ===========================================================================
601 
602 const GNETagProperties&
604  // define on first access
605  if (myTagProperties.size() == 0) {
607  }
608  // check that tag is defined
609  if (myTagProperties.count(tag) == 0) {
610  throw ProcessError("TagProperty for tag '" + toString(tag) + "' not defined");
611  } else {
612  return myTagProperties.at(tag);
613  }
614 }
615 
616 
617 const std::vector<GNETagProperties>
618 GNEAttributeCarrier::getTagPropertiesByType(const int tagPropertyCategory) {
619  std::vector<GNETagProperties> allowedTags;
620  // define on first access
621  if (myTagProperties.size() == 0) {
623  }
624  if (tagPropertyCategory & GNETagProperties::NETWORKELEMENT) {
625  // fill networkElements tags
626  for (const auto& tagProperty : myTagProperties) {
627  if (tagProperty.second.isNetworkElement()) {
628  allowedTags.push_back(tagProperty.second);
629  }
630  }
631  }
632  if (tagPropertyCategory & GNETagProperties::ADDITIONALELEMENT) {
633  // fill additional tags
634  for (const auto& tagProperty : myTagProperties) {
635  // avoid symbols (It will be implemented in #7355)
636  if (!tagProperty.second.isSymbol() && tagProperty.second.isAdditionalElement()) {
637  allowedTags.push_back(tagProperty.second);
638  }
639  }
640  }
641  if (tagPropertyCategory & GNETagProperties::SYMBOL) {
642  // fill symbol tags
643  for (const auto& tagProperty : myTagProperties) {
644  if (tagProperty.second.isSymbol()) {
645  allowedTags.push_back(tagProperty.second);
646  }
647  }
648  }
649  if (tagPropertyCategory & GNETagProperties::SHAPE) {
650  // fill shape tags
651  for (const auto& tagProperty : myTagProperties) {
652  if (tagProperty.second.isShape()) {
653  allowedTags.push_back(tagProperty.second);
654  }
655  }
656  }
657  if (tagPropertyCategory & GNETagProperties::TAZELEMENT) {
658  // fill taz tags
659  for (const auto& tagProperty : myTagProperties) {
660  if (tagProperty.second.isTAZElement()) {
661  allowedTags.push_back(tagProperty.second);
662  }
663  }
664  }
665  if (tagPropertyCategory & GNETagProperties::DEMANDELEMENT) {
666  // fill demand tags
667  for (const auto& tagProperty : myTagProperties) {
668  if (tagProperty.second.isDemandElement()) {
669  allowedTags.push_back(tagProperty.second);
670  }
671  }
672  }
673  if (tagPropertyCategory & GNETagProperties::ROUTE) {
674  // fill route tags
675  for (const auto& tagProperty : myTagProperties) {
676  if (tagProperty.second.isRoute()) {
677  allowedTags.push_back(tagProperty.second);
678  }
679  }
680  }
681  if (tagPropertyCategory & GNETagProperties::VEHICLE) {
682  // fill vehicle tags
683  for (const auto& tagProperty : myTagProperties) {
684  if (tagProperty.second.isVehicle()) {
685  allowedTags.push_back(tagProperty.second);
686  }
687  }
688  }
689  if (tagPropertyCategory & GNETagProperties::STOP) {
690  // fill stop tags
691  for (const auto& tagProperty : myTagProperties) {
692  if (tagProperty.second.isStop()) {
693  allowedTags.push_back(tagProperty.second);
694  }
695  }
696  }
697  if (tagPropertyCategory & GNETagProperties::PERSON) {
698  // fill person tags
699  for (const auto& tagProperty : myTagProperties) {
700  if (tagProperty.second.isPerson()) {
701  allowedTags.push_back(tagProperty.second);
702  }
703  }
704  }
705  if (tagPropertyCategory & GNETagProperties::PERSONPLAN) {
706  // fill person plan tags
707  for (const auto& tagProperty : myTagProperties) {
708  if (tagProperty.second.isPersonPlan()) {
709  allowedTags.push_back(tagProperty.second);
710  }
711  }
712  }
713  if (tagPropertyCategory & GNETagProperties::PERSONTRIP) {
714  // fill demand tags
715  for (const auto& tagProperty : myTagProperties) {
716  if (tagProperty.second.isPersonTrip()) {
717  allowedTags.push_back(tagProperty.second);
718  }
719  }
720  }
721  if (tagPropertyCategory & GNETagProperties::WALK) {
722  // fill demand tags
723  for (const auto& tagProperty : myTagProperties) {
724  if (tagProperty.second.isWalk()) {
725  allowedTags.push_back(tagProperty.second);
726  }
727  }
728  }
729  if (tagPropertyCategory & GNETagProperties::RIDE) {
730  // fill demand tags
731  for (const auto& tagProperty : myTagProperties) {
732  if (tagProperty.second.isRide()) {
733  allowedTags.push_back(tagProperty.second);
734  }
735  }
736  }
737  if (tagPropertyCategory & GNETagProperties::STOPPERSON) {
738  // fill demand tags
739  for (const auto& tagProperty : myTagProperties) {
740  if (tagProperty.second.isStopPerson()) {
741  allowedTags.push_back(tagProperty.second);
742  }
743  }
744  }
745  if (tagPropertyCategory & GNETagProperties::GENERICDATA) {
746  // fill generic data tags
747  for (const auto& tagProperty : myTagProperties) {
748  if (tagProperty.second.isGenericData()) {
749  allowedTags.push_back(tagProperty.second);
750  }
751  }
752  }
753  if (tagPropertyCategory & GNETagProperties::CONTAINER) {
754  // fill container tags
755  for (const auto& tagProperty : myTagProperties) {
756  if (tagProperty.second.isContainer()) {
757  allowedTags.push_back(tagProperty.second);
758  }
759  }
760  }
761  if (tagPropertyCategory & GNETagProperties::CONTAINERPLAN) {
762  // fill container plan tags
763  for (const auto& tagProperty : myTagProperties) {
764  if (tagProperty.second.isContainerPlan()) {
765  allowedTags.push_back(tagProperty.second);
766  }
767  }
768  }
769  if (tagPropertyCategory & GNETagProperties::TRANSPORT) {
770  // fill demand tags
771  for (const auto& tagProperty : myTagProperties) {
772  if (tagProperty.second.isTransportPlan()) {
773  allowedTags.push_back(tagProperty.second);
774  }
775  }
776  }
777  if (tagPropertyCategory & GNETagProperties::TRANSHIP) {
778  // fill demand tags
779  for (const auto& tagProperty : myTagProperties) {
780  if (tagProperty.second.isTranshipPlan()) {
781  allowedTags.push_back(tagProperty.second);
782  }
783  }
784  }
785  if (tagPropertyCategory & GNETagProperties::STOPCONTAINER) {
786  // fill demand tags
787  for (const auto& tagProperty : myTagProperties) {
788  if (tagProperty.second.isStopContainer()) {
789  allowedTags.push_back(tagProperty.second);
790  }
791  }
792  }
793  return allowedTags;
794 }
795 
796 // ===========================================================================
797 // private
798 // ===========================================================================
799 
800 void
802  for (const auto& attrProperty : myTagProperty) {
803  if (attrProperty.hasDefaultValue()) {
804  setAttribute(attrProperty.getAttr(), attrProperty.getDefaultValue());
805  }
806  }
807 }
808 
809 
810 void
812  // fill all groups of ACs
814  fillAdditionals();
815  fillShapes();
816  fillTAZElements();
817  // demand
821  // persons
827  // containers
832  //data
834  // check integrity of all Tags (function checkTagIntegrity() throws an exception if there is an inconsistency)
835  for (const auto& tagProperty : myTagProperties) {
836  tagProperty.second.checkTagIntegrity();
837  }
838 }
839 
840 
841 void
843  // declare empty GNEAttributeProperties
844  GNEAttributeProperties attrProperty;
845  // obtain Node Types except SumoXMLNodeType::DEAD_END_DEPRECATED
846  const OptionsCont& oc = OptionsCont::getOptions();
847  std::vector<std::string> nodeTypes = SUMOXMLDefinitions::NodeTypes.getStrings();
848  nodeTypes.erase(std::find(nodeTypes.begin(), nodeTypes.end(), toString(SumoXMLNodeType::DEAD_END_DEPRECATED)));
849  nodeTypes.erase(std::find(nodeTypes.begin(), nodeTypes.end(), toString(SumoXMLNodeType::DEAD_END)));
850  nodeTypes.erase(std::find(nodeTypes.begin(), nodeTypes.end(), toString(SumoXMLNodeType::INTERNAL)));
851  // fill networkElement ACs
852  SumoXMLTag currentTag = SUMO_TAG_JUNCTION;
853  {
854  // set values of tag
855  myTagProperties[currentTag] = GNETagProperties(currentTag,
858  GUIIcon::JUNCTION, currentTag);
859  // set values of attributes
860  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
862  "The id of the node");
863  myTagProperties[currentTag].addAttribute(attrProperty);
864 
866  GNEAttributeProperties::STRING | GNEAttributeProperties::UNIQUE | GNEAttributeProperties::POSITION | GNEAttributeProperties::UPDATEGEOMETRY, // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
867  "The x-y-z position of the node on the plane in meters");
868  myTagProperties[currentTag].addAttribute(attrProperty);
869 
870  attrProperty = GNEAttributeProperties(SUMO_ATTR_TYPE,
872  "An optional type for the node");
873  attrProperty.setDiscreteValues(nodeTypes);
874  myTagProperties[currentTag].addAttribute(attrProperty);
875 
878  "A custom shape for that node");
879  myTagProperties[currentTag].addAttribute(attrProperty);
880 
883  "Optional turning radius (for all corners) for that node in meters",
884  "1.5");
885  myTagProperties[currentTag].addAttribute(attrProperty);
886 
889  "Whether the junction-blocking-heuristic should be activated at this node",
890  "1");
891  myTagProperties[currentTag].addAttribute(attrProperty);
892 
895  "How to compute right of way rules at this node",
897  attrProperty.setDiscreteValues(SUMOXMLDefinitions::RightOfWayValues.getStrings());
898  myTagProperties[currentTag].addAttribute(attrProperty);
899 
902  "Whether this junction is at the fringe of the network",
904  attrProperty.setDiscreteValues(SUMOXMLDefinitions::FringeTypeValues.getStrings());
905  myTagProperties[currentTag].addAttribute(attrProperty);
906 
907  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
909  "Optional name of " + toString(currentTag));
910  myTagProperties[currentTag].addAttribute(attrProperty);
911 
914  "An optional type for the traffic light algorithm");
916  myTagProperties[currentTag].addAttribute(attrProperty);
917 
920  "An optional layout for the traffic light plan");
925  myTagProperties[currentTag].addAttribute(attrProperty);
926 
927  attrProperty = GNEAttributeProperties(SUMO_ATTR_TLID,
929  "An optional id for the traffic light program");
930  myTagProperties[currentTag].addAttribute(attrProperty);
931  }
932  currentTag = SUMO_TAG_TYPE;
933  {
934  // set values of tag
935  myTagProperties[currentTag] = GNETagProperties(currentTag,
938  GUIIcon::EDGETYPE, currentTag);
939  // set values of attributes
940  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
942  "The id of the edge");
943  myTagProperties[currentTag].addAttribute(attrProperty);
944 
947  "The number of lanes of the edge",
948  toString(oc.getInt("default.lanenumber")));
949  myTagProperties[currentTag].addAttribute(attrProperty);
950 
953  "The maximum speed allowed on the edge in m/s",
954  toString(oc.getFloat("default.speed")));
955  myTagProperties[currentTag].addAttribute(attrProperty);
956 
959  "Explicitly allows the given vehicle classes (not given will be not allowed)",
960  "all");
961  myTagProperties[currentTag].addAttribute(attrProperty);
962 
965  "Explicitly disallows the given vehicle classes (not given will be allowed)");
966  myTagProperties[currentTag].addAttribute(attrProperty);
967 
970  "The spreadType defines how to compute the lane geometry from the edge geometry (used for visualization)",
973  myTagProperties[currentTag].addAttribute(attrProperty);
974 
977  "The priority of the edge",
978  toString(oc.getInt("default.priority")));
979  myTagProperties[currentTag].addAttribute(attrProperty);
980 
983  "Lane width for all lanes of this edge in meters (used for visualization)",
984  "-1");
985  myTagProperties[currentTag].addAttribute(attrProperty);
986  /*
987  implement in #9725
988 
989  attrProperty = GNEAttributeProperties(SUMO_ATTR_SIDEWALKWIDTH,
990  GNEAttributeProperties::FLOAT,
991  "The width of the sidewalk that should be added as an additional lane");
992  myTagProperties[currentTag].addAttribute(attrProperty);
993 
994  attrProperty = GNEAttributeProperties(SUMO_ATTR_BIKELANEWIDTH,
995  GNEAttributeProperties::FLOAT,
996  "The width of the bike lane that should be added as an additional lane");
997  myTagProperties[currentTag].addAttribute(attrProperty);
998  */
999  }
1000  currentTag = SUMO_TAG_LANETYPE;
1001  {
1002  // set values of tag
1003  myTagProperties[currentTag] = GNETagProperties(currentTag,
1006  GUIIcon::LANETYPE, currentTag);
1007  // set values of attributes
1008  attrProperty = GNEAttributeProperties(SUMO_ATTR_SPEED,
1010  "The maximum speed allowed on the lane in m/s",
1011  toString(oc.getFloat("default.speed")));
1012  myTagProperties[currentTag].addAttribute(attrProperty);
1013 
1014  attrProperty = GNEAttributeProperties(SUMO_ATTR_ALLOW,
1016  "Explicitly allows the given vehicle classes (not given will be not allowed)",
1017  "all");
1018  myTagProperties[currentTag].addAttribute(attrProperty);
1019 
1022  "Explicitly disallows the given vehicle classes (not given will be allowed)");
1023  myTagProperties[currentTag].addAttribute(attrProperty);
1024 
1025  attrProperty = GNEAttributeProperties(SUMO_ATTR_WIDTH,
1027  "Lane width for all lanes of this lane in meters (used for visualization)",
1028  "-1");
1029  myTagProperties[currentTag].addAttribute(attrProperty);
1030  }
1031  currentTag = SUMO_TAG_EDGE;
1032  {
1033  // set values of tag
1034  myTagProperties[currentTag] = GNETagProperties(currentTag,
1037  GUIIcon::EDGE, currentTag);
1038  // set values of attributes
1039  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1041  "The id of the edge");
1042  myTagProperties[currentTag].addAttribute(attrProperty);
1043 
1044  attrProperty = GNEAttributeProperties(SUMO_ATTR_FROM,
1046  "The name of a node within the nodes-file the edge shall start at");
1047  myTagProperties[currentTag].addAttribute(attrProperty);
1048 
1049  attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
1051  "The name of a node within the nodes-file the edge shall end at");
1052  myTagProperties[currentTag].addAttribute(attrProperty);
1053 
1054  attrProperty = GNEAttributeProperties(SUMO_ATTR_SPEED,
1056  "The maximum speed allowed on the edge in m/s",
1057  toString(oc.getFloat("default.speed")));
1058  myTagProperties[currentTag].addAttribute(attrProperty);
1059 
1062  "The priority of the edge",
1063  toString(oc.getInt("default.priority")));
1064  myTagProperties[currentTag].addAttribute(attrProperty);
1065 
1068  "The number of lanes of the edge",
1069  toString(oc.getInt("default.lanenumber")));
1070  myTagProperties[currentTag].addAttribute(attrProperty);
1071 
1072  attrProperty = GNEAttributeProperties(SUMO_ATTR_TYPE,
1074  "The name of a type within the SUMO edge type file");
1075  myTagProperties[currentTag].addAttribute(attrProperty);
1076 
1077  attrProperty = GNEAttributeProperties(SUMO_ATTR_ALLOW,
1079  "Explicitly allows the given vehicle classes (not given will be not allowed)",
1080  "all");
1081  myTagProperties[currentTag].addAttribute(attrProperty);
1082 
1085  "Explicitly disallows the given vehicle classes (not given will be allowed)");
1086  myTagProperties[currentTag].addAttribute(attrProperty);
1087 
1088  attrProperty = GNEAttributeProperties(SUMO_ATTR_SHAPE,
1090  "If the shape is given it should start and end with the positions of the from-node and to-node");
1091  myTagProperties[currentTag].addAttribute(attrProperty);
1092 
1095  "The length of the edge in meter");
1096  myTagProperties[currentTag].addAttribute(attrProperty);
1097 
1100  "The spreadType defines how to compute the lane geometry from the edge geometry (used for visualization)",
1103  myTagProperties[currentTag].addAttribute(attrProperty);
1104 
1105  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
1107  "street name (need not be unique, used for visualization)");
1108  myTagProperties[currentTag].addAttribute(attrProperty);
1109 
1110  attrProperty = GNEAttributeProperties(SUMO_ATTR_WIDTH,
1112  "Lane width for all lanes of this edge in meters (used for visualization)",
1113  "-1");
1114  myTagProperties[currentTag].addAttribute(attrProperty);
1115 
1118  "Move the stop line back from the intersection by the given amount",
1119  "0.00");
1120  myTagProperties[currentTag].addAttribute(attrProperty);
1121 
1124  "Custom position in which shape start (by default position of junction from)");
1125  myTagProperties[currentTag].addAttribute(attrProperty);
1126 
1129  "Custom position in which shape end (by default position of junction from)");
1130  myTagProperties[currentTag].addAttribute(attrProperty);
1131 
1132  attrProperty = GNEAttributeProperties(GNE_ATTR_BIDIR,
1133  GNEAttributeProperties::BOOL | GNEAttributeProperties::DEFAULTVALUE, // virtual attribute to check of this edge is part of a bidirectional railway (cannot be edited)
1134  "Show if edge is bidireccional",
1135  "0");
1136  myTagProperties[currentTag].addAttribute(attrProperty);
1137 
1140  "0.00");
1141  myTagProperties[currentTag].addAttribute(attrProperty);
1142 
1145  "The stop offset as positive value in meters",
1146  "0.00");
1147  myTagProperties[currentTag].addAttribute(attrProperty);
1148 
1151  "Specifies, for which vehicle classes the stopOffset does NOT apply.",
1152  "");
1153  attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
1154  myTagProperties[currentTag].addAttribute(attrProperty);
1155  }
1156  currentTag = SUMO_TAG_LANE;
1157  {
1158  // set values of tag
1159  myTagProperties[currentTag] = GNETagProperties(currentTag,
1161  0,
1162  GUIIcon::LANE, currentTag);
1163  // set values of attributes
1164  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1166  "ID of lane (Automatic, non editable)");
1167  myTagProperties[currentTag].addAttribute(attrProperty);
1168 
1169  attrProperty = GNEAttributeProperties(SUMO_ATTR_INDEX,
1171  "The enumeration index of the lane (0 is the rightmost lane, <NUMBER_LANES>-1 is the leftmost one)");
1172  myTagProperties[currentTag].addAttribute(attrProperty);
1173 
1174  attrProperty = GNEAttributeProperties(SUMO_ATTR_SPEED,
1176  "Speed in meters per second",
1177  "13.89");
1178  myTagProperties[currentTag].addAttribute(attrProperty);
1179 
1180  attrProperty = GNEAttributeProperties(SUMO_ATTR_ALLOW,
1182  "Explicitly allows the given vehicle classes (not given will be not allowed)",
1183  "all");
1184  myTagProperties[currentTag].addAttribute(attrProperty);
1185 
1188  "Explicitly disallows the given vehicle classes (not given will be allowed)");
1189  myTagProperties[currentTag].addAttribute(attrProperty);
1190 
1191  attrProperty = GNEAttributeProperties(SUMO_ATTR_WIDTH,
1193  "Width in meters (used for visualization)",
1194  "-1");
1195  myTagProperties[currentTag].addAttribute(attrProperty);
1196 
1199  "Move the stop line back from the intersection by the given amount",
1200  "0.00");
1201  myTagProperties[currentTag].addAttribute(attrProperty);
1202 
1205  "Enable or disable lane as acceleration lane",
1206  "0.00");
1207  myTagProperties[currentTag].addAttribute(attrProperty);
1208 
1211  "If the shape is given it overrides the computation based on edge shape");
1212  myTagProperties[currentTag].addAttribute(attrProperty);
1213 
1216  "If given, this defines the opposite direction lane");
1217  myTagProperties[currentTag].addAttribute(attrProperty);
1218 
1221  "Permit changing left only for to the given vehicle classes",
1222  "all");
1223  attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
1224  myTagProperties[currentTag].addAttribute(attrProperty);
1225 
1228  "Permit changing right only for to the given vehicle classes",
1229  "all");
1230  attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
1231  myTagProperties[currentTag].addAttribute(attrProperty);
1232 
1233  attrProperty = GNEAttributeProperties(SUMO_ATTR_TYPE,
1235  "Lane type description (optional)");
1236  myTagProperties[currentTag].addAttribute(attrProperty);
1237 
1240  "The stop offset as positive value in meters",
1241  "0.00");
1242  myTagProperties[currentTag].addAttribute(attrProperty);
1243 
1246  "Specifies, for which vehicle classes the stopOffset does NOT apply.",
1247  "");
1248  attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
1249  myTagProperties[currentTag].addAttribute(attrProperty);
1250  }
1251  currentTag = SUMO_TAG_CROSSING;
1252  {
1253  // set values of tag
1254  myTagProperties[currentTag] = GNETagProperties(currentTag,
1256  0,
1257  GUIIcon::CROSSING, currentTag);
1258  // set values of attributes
1259  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1261  "The ID of Crossing");
1262  myTagProperties[currentTag].addAttribute(attrProperty);
1263 
1264  attrProperty = GNEAttributeProperties(SUMO_ATTR_EDGES,
1266  "The (road) edges which are crossed");
1267  myTagProperties[currentTag].addAttribute(attrProperty);
1268 
1271  "Whether the pedestrians have priority over the vehicles (automatically set to true at tls-controlled intersections)",
1272  "0");
1273  myTagProperties[currentTag].addAttribute(attrProperty);
1274 
1275  attrProperty = GNEAttributeProperties(SUMO_ATTR_WIDTH,
1277  "The width of the crossings",
1278  toString(OptionsCont::getOptions().getFloat("default.crossing-width")));
1279  myTagProperties[currentTag].addAttribute(attrProperty);
1280 
1283  "sets the tls-index for this crossing",
1284  "-1");
1285  myTagProperties[currentTag].addAttribute(attrProperty);
1286 
1289  "sets the opposite-direction tls-index for this crossing",
1290  "-1");
1291  myTagProperties[currentTag].addAttribute(attrProperty);
1292 
1295  "Overrids default shape of pedestrian crossing");
1296  myTagProperties[currentTag].addAttribute(attrProperty);
1297  }
1298  currentTag = SUMO_TAG_CONNECTION;
1299  {
1300  // set values of tag
1301  myTagProperties[currentTag] = GNETagProperties(currentTag,
1303  0,
1304  GUIIcon::CONNECTION, currentTag);
1305  // set values of attributes
1306  attrProperty = GNEAttributeProperties(SUMO_ATTR_FROM,
1308  "The name of the edge the vehicles leave");
1309  myTagProperties[currentTag].addAttribute(attrProperty);
1310 
1311  attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
1313  "The name of the edge the vehicles may reach when leaving 'from'");
1314  myTagProperties[currentTag].addAttribute(attrProperty);
1315 
1318  "the lane index of the incoming lane (numbers starting with 0)");
1319  myTagProperties[currentTag].addAttribute(attrProperty);
1320 
1323  "the lane index of the outgoing lane (numbers starting with 0)");
1324  myTagProperties[currentTag].addAttribute(attrProperty);
1325 
1326  attrProperty = GNEAttributeProperties(SUMO_ATTR_PASS,
1328  "if set, vehicles which pass this (lane-2-lane) connection) will not wait",
1329  "0");
1330  myTagProperties[currentTag].addAttribute(attrProperty);
1331 
1334  "if set to false, vehicles which pass this (lane-2-lane) connection) will not worry about blocking the intersection",
1335  "0");
1336  myTagProperties[currentTag].addAttribute(attrProperty);
1337 
1340  "If set to a more than 0 value, an internal junction will be built at this position (in m) from the start of the internal lane for this connection",
1342  myTagProperties[currentTag].addAttribute(attrProperty);
1343 
1346  "If set to true, This connection will not be TLS-controlled despite its node being controlled",
1347  "0");
1348  myTagProperties[currentTag].addAttribute(attrProperty);
1349 
1352  "Vision distance between vehicles",
1354  myTagProperties[currentTag].addAttribute(attrProperty);
1355 
1358  "sets index of this connection within the controlling trafficlight",
1359  "-1");
1360  myTagProperties[currentTag].addAttribute(attrProperty);
1361 
1364  "sets index for the internal junction of this connection within the controlling trafficlight",
1365  "-1");
1366  myTagProperties[currentTag].addAttribute(attrProperty);
1367 
1368  attrProperty = GNEAttributeProperties(SUMO_ATTR_ALLOW,
1370  "Explicitly allows the given vehicle classes (not given will be not allowed)",
1371  "all");
1372  myTagProperties[currentTag].addAttribute(attrProperty);
1373 
1376  "Explicitly disallows the given vehicle classes (not given will be allowed)");
1377  myTagProperties[currentTag].addAttribute(attrProperty);
1378 
1379  attrProperty = GNEAttributeProperties(SUMO_ATTR_SPEED,
1381  "sets custom speed limit for the connection",
1383  myTagProperties[currentTag].addAttribute(attrProperty);
1384 
1387  "sets custom length for the connection",
1389  myTagProperties[currentTag].addAttribute(attrProperty);
1390 
1393  "sets custom shape for the connection");
1394  myTagProperties[currentTag].addAttribute(attrProperty);
1395 
1398  "Permit changing left only for to the given vehicle classes",
1399  "all");
1400  attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
1401  myTagProperties[currentTag].addAttribute(attrProperty);
1402 
1405  "Permit changing right only for to the given vehicle classes",
1406  "all");
1407  attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
1408  myTagProperties[currentTag].addAttribute(attrProperty);
1409 
1412  "if set to true, vehicles will make a turn in 2 steps",
1413  "0");
1414  myTagProperties[currentTag].addAttribute(attrProperty);
1415 
1416  attrProperty = GNEAttributeProperties(SUMO_ATTR_TYPE,
1418  "set a custom edge type (for applying vClass-specific speed restrictions)");
1419  myTagProperties[currentTag].addAttribute(attrProperty);
1420 
1421 
1422  attrProperty = GNEAttributeProperties(SUMO_ATTR_DIR,
1424  "turning direction for this connection (computed)");
1425  myTagProperties[currentTag].addAttribute(attrProperty);
1426 
1427  attrProperty = GNEAttributeProperties(SUMO_ATTR_STATE,
1429  "link state for this connection (computed)");
1430  myTagProperties[currentTag].addAttribute(attrProperty);
1431  }
1432  currentTag = GNE_TAG_INTERNAL_LANE;
1433  {
1434  // set values of tag
1435  myTagProperties[currentTag] = GNETagProperties(currentTag,
1437  0,
1438  GUIIcon::JUNCTION, currentTag);
1439  // internal lanes does't have attributes
1440  }
1441 }
1442 
1443 
1444 void
1446  // declare empty GNEAttributeProperties
1447  GNEAttributeProperties attrProperty;
1448  // fill additional elements
1449  SumoXMLTag currentTag = SUMO_TAG_BUS_STOP;
1450  {
1451  // set values of tag
1452  myTagProperties[currentTag] = GNETagProperties(currentTag,
1455  GUIIcon::BUSSTOP, currentTag, {}, FXRGBA(240, 255, 205, 255));
1456  // set values of attributes
1457  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1459  "The id of bus stop");
1460  myTagProperties[currentTag].addAttribute(attrProperty);
1461 
1462  attrProperty = GNEAttributeProperties(SUMO_ATTR_LANE,
1464  "The name of the lane the bus stop shall be located at");
1465  myTagProperties[currentTag].addAttribute(attrProperty);
1466 
1469  "The begin position on the lane (the lower position on the lane) in meters");
1470 
1471  myTagProperties[currentTag].addAttribute(attrProperty);
1474  "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
1475  myTagProperties[currentTag].addAttribute(attrProperty);
1476 
1477  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
1479  "Name of " + toString(currentTag));
1480  myTagProperties[currentTag].addAttribute(attrProperty);
1481 
1484  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
1485  "0");
1486  myTagProperties[currentTag].addAttribute(attrProperty);
1487 
1488  attrProperty = GNEAttributeProperties(SUMO_ATTR_LINES,
1490  "Meant to be the names of the bus lines that stop at this bus stop. This is only used for visualization purposes");
1491  myTagProperties[currentTag].addAttribute(attrProperty);
1492 
1495  "Larger numbers of persons trying to enter will create an upstream jam on the sidewalk",
1496  "6");
1497  myTagProperties[currentTag].addAttribute(attrProperty);
1498 
1501  "Optional space definition for vehicles that park at this stop",
1502  "0.00");
1503  myTagProperties[currentTag].addAttribute(attrProperty);
1504 
1505  attrProperty = GNEAttributeProperties(SUMO_ATTR_COLOR,
1507  "The RGBA color with which the busStop shall be displayed");
1508  myTagProperties[currentTag].addAttribute(attrProperty);
1509 
1510  }
1511  currentTag = SUMO_TAG_TRAIN_STOP;
1512  {
1513  // set values of tag
1514  myTagProperties[currentTag] = GNETagProperties(currentTag,
1517  GUIIcon::TRAINSTOP, currentTag, {}, FXRGBA(240, 255, 205, 255));
1518  // set values of attributes
1519  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1521  "The id of train stop");
1522  myTagProperties[currentTag].addAttribute(attrProperty);
1523 
1524  attrProperty = GNEAttributeProperties(SUMO_ATTR_LANE,
1526  "The name of the lane the train stop shall be located at");
1527  myTagProperties[currentTag].addAttribute(attrProperty);
1528 
1531  "The begin position on the lane (the lower position on the lane) in meters");
1532 
1533  myTagProperties[currentTag].addAttribute(attrProperty);
1536  "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
1537  myTagProperties[currentTag].addAttribute(attrProperty);
1538 
1539  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
1541  "Name of " + toString(currentTag));
1542  myTagProperties[currentTag].addAttribute(attrProperty);
1543 
1546  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
1547  "0");
1548  myTagProperties[currentTag].addAttribute(attrProperty);
1549 
1550  attrProperty = GNEAttributeProperties(SUMO_ATTR_LINES,
1552  "Meant to be the names of the train lines that stop at this train stop. This is only used for visualization purposes");
1553  myTagProperties[currentTag].addAttribute(attrProperty);
1554 
1557  "Larger numbers of persons trying to enter will create an upstream jam on the sidewalk",
1558  "6");
1559  myTagProperties[currentTag].addAttribute(attrProperty);
1560 
1563  "Optional space definition for vehicles that park at this stop",
1564  "0.00");
1565  myTagProperties[currentTag].addAttribute(attrProperty);
1566 
1567  attrProperty = GNEAttributeProperties(SUMO_ATTR_COLOR,
1569  "The RGBA color with which the trainStop shall be displayed");
1570  myTagProperties[currentTag].addAttribute(attrProperty);
1571 
1572  }
1573  currentTag = SUMO_TAG_ACCESS;
1574  {
1575  // set values of tag
1576  myTagProperties[currentTag] = GNETagProperties(currentTag,
1579  GUIIcon::ACCESS, currentTag, {SUMO_TAG_BUS_STOP, SUMO_TAG_TRAIN_STOP}, FXRGBA(240, 255, 205, 255));
1580  // set values of attributes
1581  attrProperty = GNEAttributeProperties(SUMO_ATTR_LANE,
1583  "The name of the lane the stop access shall be located at");
1584  myTagProperties[currentTag].addAttribute(attrProperty);
1585 
1588  "The position on the lane (the lower position on the lane) in meters",
1589  "0.00");
1590  myTagProperties[currentTag].addAttribute(attrProperty);
1591 
1594  "The walking length of the access in meters",
1595  "-1.00");
1596  myTagProperties[currentTag].addAttribute(attrProperty);
1597 
1600  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
1601  "0");
1602  myTagProperties[currentTag].addAttribute(attrProperty);
1603 
1604  }
1605  currentTag = SUMO_TAG_CONTAINER_STOP;
1606  {
1607  // set values of tag
1608  myTagProperties[currentTag] = GNETagProperties(currentTag,
1611  GUIIcon::CONTAINERSTOP, currentTag, {}, FXRGBA(240, 255, 205, 255));
1612  // set values of attributes
1613  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1615  "The id of container stop");
1616  myTagProperties[currentTag].addAttribute(attrProperty);
1617 
1618  attrProperty = GNEAttributeProperties(SUMO_ATTR_LANE,
1620  "The name of the lane the container stop shall be located at");
1621  myTagProperties[currentTag].addAttribute(attrProperty);
1622 
1625  "The begin position on the lane (the lower position on the lane) in meters");
1626  myTagProperties[currentTag].addAttribute(attrProperty);
1627 
1630  "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
1631  myTagProperties[currentTag].addAttribute(attrProperty);
1632 
1633  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
1635  "Name of " + toString(currentTag));
1636  myTagProperties[currentTag].addAttribute(attrProperty);
1637 
1640  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
1641  "0");
1642  myTagProperties[currentTag].addAttribute(attrProperty);
1643 
1644  attrProperty = GNEAttributeProperties(SUMO_ATTR_LINES,
1646  "meant to be the names of the bus lines that stop at this container stop. This is only used for visualization purposes");
1647  myTagProperties[currentTag].addAttribute(attrProperty);
1648 
1651  "Larger numbers of container trying to enter will create an upstream jam on the sidewalk",
1652  "6");
1653  myTagProperties[currentTag].addAttribute(attrProperty);
1654 
1657  "Optional space definition for vehicles that park at this stop",
1658  "0.00");
1659  myTagProperties[currentTag].addAttribute(attrProperty);
1660 
1661  attrProperty = GNEAttributeProperties(SUMO_ATTR_COLOR,
1663  "The RGBA color with which the containerStop shall be displayed");
1664  myTagProperties[currentTag].addAttribute(attrProperty);
1665  }
1666  currentTag = SUMO_TAG_CHARGING_STATION;
1667  {
1668  // set values of tag
1669  myTagProperties[currentTag] = GNETagProperties(currentTag,
1672  GUIIcon::CHARGINGSTATION, currentTag, {}, FXRGBA(240, 255, 205, 255));
1673  // set values of attributes
1674  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1676  "The id of charging station");
1677  myTagProperties[currentTag].addAttribute(attrProperty);
1678 
1679  attrProperty = GNEAttributeProperties(SUMO_ATTR_LANE,
1681  "Lane of the charging station location");
1682  myTagProperties[currentTag].addAttribute(attrProperty);
1683 
1686  "Begin position in the specified lane");
1687  myTagProperties[currentTag].addAttribute(attrProperty);
1688 
1691  "End position in the specified lane");
1692  myTagProperties[currentTag].addAttribute(attrProperty);
1693 
1694  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
1696  "Name of " + toString(currentTag));
1697  myTagProperties[currentTag].addAttribute(attrProperty);
1698 
1701  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
1702  "0");
1703  myTagProperties[currentTag].addAttribute(attrProperty);
1704 
1707  "Charging power in W",
1708  "22000.00");
1709  myTagProperties[currentTag].addAttribute(attrProperty);
1710 
1713  "Charging efficiency [0,1]",
1714  "0.95");
1715  attrProperty.setRange(0, 1);
1716  myTagProperties[currentTag].addAttribute(attrProperty);
1717 
1720  "Enable or disable charge in transit, i.e. vehicle must or must not to stop for charging",
1721  "0");
1722  myTagProperties[currentTag].addAttribute(attrProperty);
1723 
1726  "Time delay after the vehicles has reached / stopped on the charging station, before the energy transfer (charging) begins",
1727  "0.00");
1728  myTagProperties[currentTag].addAttribute(attrProperty);
1729  }
1730  currentTag = SUMO_TAG_PARKING_AREA;
1731  {
1732  // set values of tag
1733  myTagProperties[currentTag] = GNETagProperties(currentTag,
1736  GUIIcon::PARKINGAREA, currentTag, {}, FXRGBA(240, 255, 205, 255));
1737  // set values of attributes
1738  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1740  "The id of ParkingArea");
1741  myTagProperties[currentTag].addAttribute(attrProperty);
1742 
1743  attrProperty = GNEAttributeProperties(SUMO_ATTR_LANE,
1745  "The name of the lane the Parking Area shall be located at");
1746  myTagProperties[currentTag].addAttribute(attrProperty);
1747 
1750  "The begin position on the lane (the lower position on the lane) in meters");
1751  myTagProperties[currentTag].addAttribute(attrProperty);
1752 
1755  "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
1756  myTagProperties[currentTag].addAttribute(attrProperty);
1757 
1760  "Lane position in that vehicle must depart when leaves parkingArea");
1761  myTagProperties[currentTag].addAttribute(attrProperty);
1762 
1763  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
1765  "Name of " + toString(currentTag));
1766  myTagProperties[currentTag].addAttribute(attrProperty);
1767 
1770  " The number of parking spaces for road-side parking",
1771  "0");
1772  myTagProperties[currentTag].addAttribute(attrProperty);
1773 
1776  "If set, vehicles will park on the road lane and thereby reducing capacity",
1777  "0");
1778  myTagProperties[currentTag].addAttribute(attrProperty);
1779 
1782  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
1783  "0");
1784  myTagProperties[currentTag].addAttribute(attrProperty);
1785 
1786  attrProperty = GNEAttributeProperties(SUMO_ATTR_WIDTH,
1788  "The width of the road-side parking spaces",
1790  myTagProperties[currentTag].addAttribute(attrProperty);
1791 
1794  "The length of the road-side parking spaces. By default (endPos - startPos) / roadsideCapacity",
1795  "0.00");
1796  myTagProperties[currentTag].addAttribute(attrProperty);
1797 
1798  attrProperty = GNEAttributeProperties(SUMO_ATTR_ANGLE,
1800  "The angle of the road-side parking spaces relative to the lane angle, positive means clockwise",
1801  "0.00");
1802  myTagProperties[currentTag].addAttribute(attrProperty);
1803 
1804  }
1805  currentTag = SUMO_TAG_PARKING_SPACE;
1806  {
1807  // set values of tag
1808  myTagProperties[currentTag] = GNETagProperties(currentTag,
1811  GUIIcon::PARKINGSPACE, currentTag, {SUMO_TAG_PARKING_AREA}, FXRGBA(240, 255, 205, 255));
1812  // set values of attributes
1814  GNEAttributeProperties::STRING | GNEAttributeProperties::UNIQUE | GNEAttributeProperties::POSITION | GNEAttributeProperties::UPDATEGEOMETRY, // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
1815  "The x-y-z position of the node on the plane in meters");
1816  myTagProperties[currentTag].addAttribute(attrProperty);
1817 
1818  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
1820  "Name of " + toString(currentTag));
1821  myTagProperties[currentTag].addAttribute(attrProperty);
1822 
1823  attrProperty = GNEAttributeProperties(SUMO_ATTR_WIDTH,
1825  "The width of the road-side parking spaces");
1826  myTagProperties[currentTag].addAttribute(attrProperty);
1827 
1830  "The length of the road-side parking spaces");
1831  myTagProperties[currentTag].addAttribute(attrProperty);
1832 
1833  attrProperty = GNEAttributeProperties(SUMO_ATTR_ANGLE,
1835  "The angle of the road-side parking spaces relative to the lane angle, positive means clockwise");
1836  myTagProperties[currentTag].addAttribute(attrProperty);
1837 
1838  attrProperty = GNEAttributeProperties(SUMO_ATTR_SLOPE,
1840  "The slope of the road-side parking spaces",
1841  "0.00");
1842  myTagProperties[currentTag].addAttribute(attrProperty);
1843 
1844  }
1845  currentTag = SUMO_TAG_E1DETECTOR;
1846  {
1847  // set values of tag
1848  myTagProperties[currentTag] = GNETagProperties(currentTag,
1850  0,
1851  GUIIcon::E1, currentTag, {}, FXRGBA(240, 238, 249, 255));
1852  // set values of attributes
1853  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1855  "The id of E1");
1856  myTagProperties[currentTag].addAttribute(attrProperty);
1857 
1858  attrProperty = GNEAttributeProperties(SUMO_ATTR_LANE,
1860  "The id of the lane the detector shall be laid on. The lane must be a part of the network used");
1861  myTagProperties[currentTag].addAttribute(attrProperty);
1862 
1865  "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");
1866  myTagProperties[currentTag].addAttribute(attrProperty);
1867 
1870  "The aggregation period the values the detector collects shall be summed up",
1871  "300.00");
1872  myTagProperties[currentTag].addAttribute(attrProperty);
1873 
1874  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
1876  "Name of " + toString(currentTag));
1877  myTagProperties[currentTag].addAttribute(attrProperty);
1878 
1879  attrProperty = GNEAttributeProperties(SUMO_ATTR_FILE,
1881  "The path to the output file");
1882  myTagProperties[currentTag].addAttribute(attrProperty);
1883 
1886  "Space separated list of vehicle type ids to consider");
1887  myTagProperties[currentTag].addAttribute(attrProperty);
1888 
1891  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
1892  "0");
1893  myTagProperties[currentTag].addAttribute(attrProperty);
1894  }
1895  currentTag = SUMO_TAG_E2DETECTOR;
1896  {
1897  // set values of tag
1898  myTagProperties[currentTag] = GNETagProperties(currentTag,
1900  0,
1901  GUIIcon::E2, currentTag, {}, FXRGBA(240, 238, 249, 255));
1902  // set "file" as deprecated attribute
1903  myTagProperties[currentTag].addDeprecatedAttribute(SUMO_ATTR_CONT);
1904  // set values of attributes
1905  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1907  "The id of E2");
1908  myTagProperties[currentTag].addAttribute(attrProperty);
1909 
1910  attrProperty = GNEAttributeProperties(SUMO_ATTR_LANE,
1912  "The id of the lane the detector shall be laid on. The lane must be a part of the network used");
1913  myTagProperties[currentTag].addAttribute(attrProperty);
1914 
1917  "The position on the lane the detector shall be laid on in meters");
1918  myTagProperties[currentTag].addAttribute(attrProperty);
1919 
1922  "The length of the detector in meters",
1923  "10.00");
1924  myTagProperties[currentTag].addAttribute(attrProperty);
1925 
1928  "The aggregation period the values the detector collects shall be summed up",
1929  "300.00");
1930  myTagProperties[currentTag].addAttribute(attrProperty);
1931 
1932  attrProperty = GNEAttributeProperties(SUMO_ATTR_TLID,
1934  "The traffic light that triggers aggregation when switching");
1935  myTagProperties[currentTag].addAttribute(attrProperty);
1936 
1937  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
1939  "Name of " + toString(currentTag));
1940  myTagProperties[currentTag].addAttribute(attrProperty);
1941 
1942  attrProperty = GNEAttributeProperties(SUMO_ATTR_FILE,
1944  "The path to the output file");
1945  myTagProperties[currentTag].addAttribute(attrProperty);
1946 
1949  "Space separated list of vehicle type ids to consider");
1950  myTagProperties[currentTag].addAttribute(attrProperty);
1951 
1954  "The time-based threshold that describes how much time has to pass until a vehicle is recognized as halting)",
1955  "1.00");
1956  myTagProperties[currentTag].addAttribute(attrProperty);
1957 
1960  "The speed-based threshold that describes how slow a vehicle has to be to be recognized as halting) in m/s",
1961  "1.39");
1962  myTagProperties[currentTag].addAttribute(attrProperty);
1963 
1966  "The minimum distance to the next standing vehicle in order to make this vehicle count as a participant to the jam) in m",
1967  "10.00");
1968  myTagProperties[currentTag].addAttribute(attrProperty);
1969 
1972  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
1973  "0");
1974  myTagProperties[currentTag].addAttribute(attrProperty);
1975  }
1976  currentTag = GNE_TAG_E2DETECTOR_MULTILANE;
1977  {
1978  // set values of tag
1979  myTagProperties[currentTag] = GNETagProperties(currentTag,
1981  0,
1982  GUIIcon::E2, SUMO_TAG_E2DETECTOR, {}, FXRGBA(240, 238, 249, 255));
1983  // set "file" as deprecated attribute
1984  myTagProperties[currentTag].addDeprecatedAttribute(SUMO_ATTR_CONT);
1985  // set values of attributes
1986  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
1988  "The id of Multilane E2");
1989  myTagProperties[currentTag].addAttribute(attrProperty);
1990 
1991  attrProperty = GNEAttributeProperties(SUMO_ATTR_LANES,
1993  "The list of secuencial lane ids in which the detector shall be laid on");
1994  myTagProperties[currentTag].addAttribute(attrProperty);
1995 
1998  "The position on the lane the detector shall be laid on in meters");
1999  myTagProperties[currentTag].addAttribute(attrProperty);
2000 
2003  "The end position on the lane the detector shall be laid on in meters");
2004  myTagProperties[currentTag].addAttribute(attrProperty);
2005 
2008  "The aggregation period the values the detector collects shall be summed up",
2009  "300.00");
2010  myTagProperties[currentTag].addAttribute(attrProperty);
2011 
2012  attrProperty = GNEAttributeProperties(SUMO_ATTR_TLID,
2014  "The traffic light that triggers aggregation when switching");
2015  myTagProperties[currentTag].addAttribute(attrProperty);
2016 
2017  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
2019  "Name of " + toString(currentTag));
2020  myTagProperties[currentTag].addAttribute(attrProperty);
2021 
2022  attrProperty = GNEAttributeProperties(SUMO_ATTR_FILE,
2024  "The path to the output file");
2025  myTagProperties[currentTag].addAttribute(attrProperty);
2026 
2029  "Space separated list of vehicle type ids to consider");
2030  myTagProperties[currentTag].addAttribute(attrProperty);
2031 
2034  "The time-based threshold that describes how much time has to pass until a vehicle is recognized as halting)",
2035  "1.00");
2036  myTagProperties[currentTag].addAttribute(attrProperty);
2037 
2040  "The speed-based threshold that describes how slow a vehicle has to be to be recognized as halting) in m/s",
2041  "1.39");
2042  myTagProperties[currentTag].addAttribute(attrProperty);
2043 
2046  "The minimum distance to the next standing vehicle in order to make this vehicle count as a participant to the jam) in m",
2047  "10.00");
2048  myTagProperties[currentTag].addAttribute(attrProperty);
2049 
2052  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
2053  "0");
2054  myTagProperties[currentTag].addAttribute(attrProperty);
2055 
2056  }
2057  currentTag = SUMO_TAG_E3DETECTOR;
2058  {
2059  // set values of tag
2060  myTagProperties[currentTag] = GNETagProperties(currentTag,
2063  GUIIcon::E3, currentTag, {}, FXRGBA(240, 238, 249, 255));
2064  // set values of attributes
2065  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2067  "The id of E3");
2068  myTagProperties[currentTag].addAttribute(attrProperty);
2069 
2072  "X-Y position of detector in editor (Only used in NETEDIT)",
2073  "0,0"); // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
2074  myTagProperties[currentTag].addAttribute(attrProperty);
2075 
2078  "The aggregation period the values the detector collects shall be summed up",
2079  "300.00");
2080  myTagProperties[currentTag].addAttribute(attrProperty);
2081 
2082  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
2084  "Name of " + toString(currentTag));
2085  myTagProperties[currentTag].addAttribute(attrProperty);
2086 
2087  attrProperty = GNEAttributeProperties(SUMO_ATTR_FILE,
2089  "The path to the output file");
2090  myTagProperties[currentTag].addAttribute(attrProperty);
2091 
2094  "Space separated list of vehicle type ids to consider");
2095  myTagProperties[currentTag].addAttribute(attrProperty);
2096 
2099  "The time-based threshold that describes how much time has to pass until a vehicle is recognized as halting) in s",
2100  "1.00");
2101  myTagProperties[currentTag].addAttribute(attrProperty);
2102 
2105  "The speed-based threshold that describes how slow a vehicle has to be to be recognized as halting) in m/s",
2106  "1.39");
2107  myTagProperties[currentTag].addAttribute(attrProperty);
2108  }
2109  currentTag = SUMO_TAG_DET_ENTRY;
2110  {
2111  // set values of tag
2112  myTagProperties[currentTag] = GNETagProperties(currentTag,
2115  GUIIcon::E3ENTRY, currentTag, {SUMO_TAG_E3DETECTOR}, FXRGBA(240, 238, 249, 255));
2116  // set values of attributes
2117  attrProperty = GNEAttributeProperties(SUMO_ATTR_LANE,
2119  "The id of the lane the detector shall be laid on. The lane must be a part of the network used");
2120  myTagProperties[currentTag].addAttribute(attrProperty);
2121 
2124  "The position on the lane the detector shall be laid on in meters");
2125  myTagProperties[currentTag].addAttribute(attrProperty);
2126 
2129  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
2130  "0");
2131  myTagProperties[currentTag].addAttribute(attrProperty);
2132 
2133  }
2134  currentTag = SUMO_TAG_DET_EXIT;
2135  {
2136  // set values of tag
2137  myTagProperties[currentTag] = GNETagProperties(currentTag,
2140  GUIIcon::E3EXIT, currentTag, {SUMO_TAG_E3DETECTOR}, FXRGBA(240, 238, 249, 255));
2141  // set values of attributes
2142  attrProperty = GNEAttributeProperties(SUMO_ATTR_LANE,
2144  "The id of the lane the detector shall be laid on. The lane must be a part of the network used");
2145  myTagProperties[currentTag].addAttribute(attrProperty);
2146 
2149  "The position on the lane the detector shall be laid on in meters");
2150  myTagProperties[currentTag].addAttribute(attrProperty);
2151 
2154  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
2155  "0");
2156  myTagProperties[currentTag].addAttribute(attrProperty);
2157 
2158  }
2159  currentTag = SUMO_TAG_INSTANT_INDUCTION_LOOP;
2160  {
2161  // set values of tag
2162  myTagProperties[currentTag] = GNETagProperties(currentTag,
2164  0,
2165  GUIIcon::E1INSTANT, currentTag, {}, FXRGBA(240, 238, 249, 255));
2166  // set values of attributes
2167  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2169  "The id of Instant Induction Loop (E1Instant)");
2170  myTagProperties[currentTag].addAttribute(attrProperty);
2171 
2172  attrProperty = GNEAttributeProperties(SUMO_ATTR_LANE,
2174  "The id of the lane the detector shall be laid on. The lane must be a part of the network used");
2175  myTagProperties[currentTag].addAttribute(attrProperty);
2176 
2179  "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");
2180  myTagProperties[currentTag].addAttribute(attrProperty);
2181 
2182  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
2184  "Name of " + toString(currentTag));
2185  myTagProperties[currentTag].addAttribute(attrProperty);
2186 
2187  attrProperty = GNEAttributeProperties(SUMO_ATTR_FILE,
2189  "The path to the output file");
2190  myTagProperties[currentTag].addAttribute(attrProperty);
2191 
2194  "Space separated list of vehicle type ids to consider");
2195  myTagProperties[currentTag].addAttribute(attrProperty);
2196 
2199  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
2200  "0");
2201  myTagProperties[currentTag].addAttribute(attrProperty);
2202 
2203  }
2204  currentTag = SUMO_TAG_VSS;
2205  {
2206  // set values of tag
2207  myTagProperties[currentTag] = GNETagProperties(currentTag,
2210  GUIIcon::VARIABLESPEEDSIGN, currentTag, {}, FXRGBA(210, 233, 255, 255));
2211  // set "file" as deprecated attribute
2212  myTagProperties[currentTag].addDeprecatedAttribute(SUMO_ATTR_FILE);
2213  // set values of attributes
2214  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2216  "The id of Variable Speed Signal");
2217  myTagProperties[currentTag].addAttribute(attrProperty);
2218 
2221  "X-Y position of detector in editor (Only used in NETEDIT)",
2222  "0,0"); // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
2223  myTagProperties[currentTag].addAttribute(attrProperty);
2224 
2225  attrProperty = GNEAttributeProperties(SUMO_ATTR_LANES,
2227  "List of Variable Speed Sign lanes");
2228  myTagProperties[currentTag].addAttribute(attrProperty);
2229 
2230  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
2232  "Name of " + toString(currentTag));
2233  myTagProperties[currentTag].addAttribute(attrProperty);
2234 
2237  "Space separated list of vehicle type ids to consider (empty to affect all types)");
2238  myTagProperties[currentTag].addAttribute(attrProperty);
2239  }
2240  currentTag = GNE_TAG_VSS_SYMBOL;
2241  {
2242  // set values of tag
2243  myTagProperties[currentTag] = GNETagProperties(currentTag,
2246  GUIIcon::LANE, currentTag, {SUMO_TAG_VSS}, FXRGBA(210, 233, 255, 255));
2247  }
2248  currentTag = SUMO_TAG_STEP;
2249  {
2250  // set values of tag
2251  myTagProperties[currentTag] = GNETagProperties(currentTag,
2254  GUIIcon::VSSSTEP, currentTag, {SUMO_TAG_VSS}, FXRGBA(210, 233, 255, 255));
2255  // set values of attributes
2256  attrProperty = GNEAttributeProperties(SUMO_ATTR_TIME,
2258  "Time");
2259  myTagProperties[currentTag].addAttribute(attrProperty);
2260 
2261  attrProperty = GNEAttributeProperties(SUMO_ATTR_SPEED,
2263  "Speed",
2264  "13.89");
2265  myTagProperties[currentTag].addAttribute(attrProperty);
2266  }
2267  currentTag = SUMO_TAG_CALIBRATOR;
2268  {
2269  // set values of tag
2270  myTagProperties[currentTag] = GNETagProperties(currentTag,
2273  GUIIcon::CALIBRATOR, currentTag, {}, FXRGBA(253, 255, 206, 255));
2274  // set values of attributes
2275  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2277  "The id of Calibrator");
2278  myTagProperties[currentTag].addAttribute(attrProperty);
2279 
2280  attrProperty = GNEAttributeProperties(SUMO_ATTR_EDGE,
2282  "The id of edge in the simulation network");
2283  myTagProperties[currentTag].addAttribute(attrProperty);
2284 
2287  "The position of the calibrator on the specified lane",
2288  "0.00");
2289  myTagProperties[currentTag].addAttribute(attrProperty);
2290 
2293  "The aggregation interval in which to calibrate the flows. Default is step-length",
2294  "1.00");
2295  myTagProperties[currentTag].addAttribute(attrProperty);
2296 
2297  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
2299  "Name of " + toString(currentTag));
2300  myTagProperties[currentTag].addAttribute(attrProperty);
2301 
2304  "The id of the routeProbe element from which to determine the route distribution for generated vehicles");
2305  myTagProperties[currentTag].addAttribute(attrProperty);
2306 
2309  "The output file for writing calibrator information or NULL");
2310  myTagProperties[currentTag].addAttribute(attrProperty);
2311 
2314  "A threshold value to detect and clear unexpected jamming",
2315  "0.50");
2316  myTagProperties[currentTag].addAttribute(attrProperty);
2317 
2320  "space separated list of vehicle type ids to consider (empty to affect all types)");
2321  myTagProperties[currentTag].addAttribute(attrProperty);
2322  }
2323  currentTag = SUMO_TAG_LANECALIBRATOR;
2324  {
2325  // set values of tag
2326  myTagProperties[currentTag] = GNETagProperties(currentTag,
2329  GUIIcon::CALIBRATOR, SUMO_TAG_CALIBRATOR, {}, FXRGBA(253, 255, 206, 255));
2330  // set values of attributes
2331  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2333  "The id of Calibrator");
2334  myTagProperties[currentTag].addAttribute(attrProperty);
2335 
2336  attrProperty = GNEAttributeProperties(SUMO_ATTR_LANE,
2338  "The id of lane in the simulation network");
2339  myTagProperties[currentTag].addAttribute(attrProperty);
2340 
2343  "The position of the calibrator on the specified lane",
2344  "0.00");
2345  myTagProperties[currentTag].addAttribute(attrProperty);
2346 
2349  "The aggregation interval in which to calibrate the flows. Default is step-length",
2350  "1.00");
2351  myTagProperties[currentTag].addAttribute(attrProperty);
2352 
2353  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
2355  "Name of " + toString(currentTag));
2356  myTagProperties[currentTag].addAttribute(attrProperty);
2357 
2360  "The id of the routeProbe element from which to determine the route distribution for generated vehicles");
2361  myTagProperties[currentTag].addAttribute(attrProperty);
2362 
2365  "The output file for writing calibrator information or NULL");
2366  myTagProperties[currentTag].addAttribute(attrProperty);
2367 
2370  "A threshold value to detect and clear unexpected jamming",
2371  "0.50");
2372  myTagProperties[currentTag].addAttribute(attrProperty);
2373 
2376  "space separated list of vehicle type ids to consider (empty to affect all types)");
2377  myTagProperties[currentTag].addAttribute(attrProperty);
2378  }
2379  currentTag = GNE_TAG_FLOW_CALIBRATOR;
2380  {
2381  // set values of tag
2382  myTagProperties[currentTag] = GNETagProperties(currentTag,
2385  GUIIcon::FLOW, SUMO_TAG_FLOW, {SUMO_TAG_CALIBRATOR}, FXRGBA(253, 255, 206, 255));
2386  // set values of attributes
2387  attrProperty = GNEAttributeProperties(SUMO_ATTR_ROUTE,
2389  "The id of the route the vehicle shall drive along");
2390  myTagProperties[currentTag].addAttribute(attrProperty);
2391 
2392  attrProperty = GNEAttributeProperties(SUMO_ATTR_BEGIN,
2394  "First " + toString(currentTag) + " departure time",
2395  "0");
2396  myTagProperties[currentTag].addAttribute(attrProperty);
2397 
2398  attrProperty = GNEAttributeProperties(SUMO_ATTR_END,
2400  "End of departure interval",
2401  "3600");
2402  myTagProperties[currentTag].addAttribute(attrProperty);
2403 
2404  // fill common vehicle attributes
2405  fillCommonVehicleAttributes(currentTag);
2406 
2407  // optional attributes (at least one must be defined)
2408  attrProperty = GNEAttributeProperties(SUMO_ATTR_TYPE,
2410  "The id of the vehicle type to use for this " + toString(currentTag),
2412  myTagProperties[currentTag].addAttribute(attrProperty);
2413 
2416  "Number of " + toString(currentTag) + "s per hour, equally spaced",
2417  "1800");
2418  myTagProperties[currentTag].addAttribute(attrProperty);
2419 
2420  attrProperty = GNEAttributeProperties(SUMO_ATTR_SPEED,
2422  "Speed of " + toString(currentTag) + "s",
2423  "15.0");
2424  myTagProperties[currentTag].addAttribute(attrProperty);
2425  }
2426  currentTag = SUMO_TAG_REROUTER;
2427  {
2428  // set values of tag
2429  myTagProperties[currentTag] = GNETagProperties(currentTag,
2432  GUIIcon::REROUTER, currentTag, {}, FXRGBA(255, 213, 213, 255));
2433 
2434  // set values of attributes
2435  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2437  "The id of Rerouter");
2438  myTagProperties[currentTag].addAttribute(attrProperty);
2439 
2440  attrProperty = GNEAttributeProperties(SUMO_ATTR_EDGES,
2442  "An edge id or a list of edge ids where vehicles shall be rerouted");
2443  myTagProperties[currentTag].addAttribute(attrProperty);
2444 
2447  "X,Y position in editor (Only used in NETEDIT)",
2448  "0,0"); // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
2449  myTagProperties[currentTag].addAttribute(attrProperty);
2450 
2451  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
2453  "Name of " + toString(currentTag));
2454  myTagProperties[currentTag].addAttribute(attrProperty);
2455 
2456  attrProperty = GNEAttributeProperties(SUMO_ATTR_FILE,
2458  "The path to the definition file (alternatively, the intervals may defined as children of the rerouter)");
2459  myTagProperties[currentTag].addAttribute(attrProperty);
2460 
2461  attrProperty = GNEAttributeProperties(SUMO_ATTR_PROB,
2463  "The probability for vehicle rerouting (0-1)",
2464  "1.00");
2465  myTagProperties[currentTag].addAttribute(attrProperty);
2466 
2469  "The waiting time threshold (in s) that must be reached to activate rerouting (default -1 which disables the threshold)",
2470  "0.00");
2471  myTagProperties[currentTag].addAttribute(attrProperty);
2472 
2475  "The list of vehicle types that shall be affected by this rerouter (empty to affect all types)");
2476  myTagProperties[currentTag].addAttribute(attrProperty);
2477 
2478  attrProperty = GNEAttributeProperties(SUMO_ATTR_OFF,
2480  "Whether the router should be inactive initially (and switched on in the gui)",
2481  "0");
2482  myTagProperties[currentTag].addAttribute(attrProperty);
2483  }
2484  currentTag = GNE_TAG_REROUTER_SYMBOL;
2485  {
2486  // set values of tag
2487  myTagProperties[currentTag] = GNETagProperties(currentTag,
2490  GUIIcon::EDGE, currentTag, {GNE_TAG_REROUTER_SYMBOL}, FXRGBA(255, 213, 213, 255));
2491  }
2492  currentTag = SUMO_TAG_INTERVAL;
2493  {
2494  // set values of tag
2495  myTagProperties[currentTag] = GNETagProperties(currentTag,
2498  GUIIcon::REROUTERINTERVAL, currentTag, {SUMO_TAG_REROUTER}, FXRGBA(255, 213, 213, 255));
2499  // set values of attributes
2500  attrProperty = GNEAttributeProperties(SUMO_ATTR_BEGIN,
2502  "Begin",
2503  "0");
2504  myTagProperties[currentTag].addAttribute(attrProperty);
2505 
2506  attrProperty = GNEAttributeProperties(SUMO_ATTR_END,
2508  "End",
2509  "3600");
2510  myTagProperties[currentTag].addAttribute(attrProperty);
2511  }
2512  currentTag = SUMO_TAG_CLOSING_REROUTE;
2513  {
2514  // set values of tag
2515  myTagProperties[currentTag] = GNETagProperties(currentTag,
2518  GUIIcon::CLOSINGREROUTE, currentTag, {SUMO_TAG_INTERVAL}, FXRGBA(255, 213, 213, 255));
2519  // set values of attributes
2520  attrProperty = GNEAttributeProperties(SUMO_ATTR_EDGE,
2522  "Edge ID");
2523  attrProperty.setSynonym(SUMO_ATTR_ID);
2524  myTagProperties[currentTag].addAttribute(attrProperty);
2525 
2526  attrProperty = GNEAttributeProperties(SUMO_ATTR_ALLOW,
2528  "allowed vehicles");
2529  myTagProperties[currentTag].addAttribute(attrProperty);
2530 
2533  "disallowed vehicles");
2534  myTagProperties[currentTag].addAttribute(attrProperty);
2535  }
2536  currentTag = SUMO_TAG_CLOSING_LANE_REROUTE;
2537  {
2538  // set values of tag
2539  myTagProperties[currentTag] = GNETagProperties(currentTag,
2542  GUIIcon::CLOSINGLANEREROUTE, currentTag, {SUMO_TAG_INTERVAL}, FXRGBA(255, 213, 213, 255));
2543  // set values of attributes
2544  attrProperty = GNEAttributeProperties(SUMO_ATTR_LANE,
2546  "Lane ID");
2547  attrProperty.setSynonym(SUMO_ATTR_ID);
2548  myTagProperties[currentTag].addAttribute(attrProperty);
2549 
2550  attrProperty = GNEAttributeProperties(SUMO_ATTR_ALLOW,
2552  "allowed vehicles");
2553  myTagProperties[currentTag].addAttribute(attrProperty);
2554 
2557  "disallowed vehicles");
2558  myTagProperties[currentTag].addAttribute(attrProperty);
2559  }
2560  currentTag = SUMO_TAG_DEST_PROB_REROUTE;
2561  {
2562  // set values of tag
2563  myTagProperties[currentTag] = GNETagProperties(currentTag,
2566  GUIIcon::DESTPROBREROUTE, currentTag, {SUMO_TAG_INTERVAL}, FXRGBA(255, 213, 213, 255));
2567  // set values of attributes
2568  attrProperty = GNEAttributeProperties(SUMO_ATTR_EDGE,
2570  "Edge ID");
2571  attrProperty.setSynonym(SUMO_ATTR_ID);
2572  myTagProperties[currentTag].addAttribute(attrProperty);
2573 
2574  attrProperty = GNEAttributeProperties(SUMO_ATTR_PROB,
2576  "SUMO Probability",
2577  "1.00");
2578  myTagProperties[currentTag].addAttribute(attrProperty);
2579  }
2580  currentTag = SUMO_TAG_PARKING_AREA_REROUTE;
2581  {
2582  // set values of tag
2583  myTagProperties[currentTag] = GNETagProperties(currentTag,
2586  GUIIcon::PARKINGZONEREROUTE, currentTag, {SUMO_TAG_INTERVAL}, FXRGBA(255, 213, 213, 255));
2587  // set values of attributes
2590  "ParkingArea ID");
2591  attrProperty.setSynonym(SUMO_ATTR_ID);
2592  myTagProperties[currentTag].addAttribute(attrProperty);
2593 
2594  attrProperty = GNEAttributeProperties(SUMO_ATTR_PROB,
2596  "SUMO Probability",
2597  "1.00");
2598  myTagProperties[currentTag].addAttribute(attrProperty);
2599 
2602  "Enable or disable visibility for parking area reroutes",
2603  "1");
2604  myTagProperties[currentTag].addAttribute(attrProperty);
2605  }
2606  currentTag = SUMO_TAG_ROUTE_PROB_REROUTE;
2607  {
2608  // set values of tag
2609  myTagProperties[currentTag] = GNETagProperties(currentTag,
2612  GUIIcon::ROUTEPROBREROUTE, currentTag, {SUMO_TAG_INTERVAL}, FXRGBA(255, 213, 213, 255));
2613  // set values of attributes
2614  attrProperty = GNEAttributeProperties(SUMO_ATTR_ROUTE,
2616  "Route");
2617  attrProperty.setSynonym(SUMO_ATTR_ID);
2618  myTagProperties[currentTag].addAttribute(attrProperty);
2619 
2620  attrProperty = GNEAttributeProperties(SUMO_ATTR_PROB,
2622  "SUMO Probability",
2623  "1.00");
2624  myTagProperties[currentTag].addAttribute(attrProperty);
2625  }
2626  currentTag = SUMO_TAG_ROUTEPROBE;
2627  {
2628  // set values of tag
2629  myTagProperties[currentTag] = GNETagProperties(currentTag,
2632  GUIIcon::ROUTEPROBE, currentTag, {}, FXRGBA(240, 240, 240, 255));
2633  // set values of attributes
2634  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2636  "The id of RouteProbe");
2637  myTagProperties[currentTag].addAttribute(attrProperty);
2638 
2639  attrProperty = GNEAttributeProperties(SUMO_ATTR_EDGE,
2641  "The id of an edge in the simulation network");
2642  myTagProperties[currentTag].addAttribute(attrProperty);
2643 
2646  "The frequency in which to report the distribution",
2647  "3600.00");
2648  myTagProperties[currentTag].addAttribute(attrProperty);
2649 
2650  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
2652  "Name of " + toString(currentTag));
2653  myTagProperties[currentTag].addAttribute(attrProperty);
2654 
2655  attrProperty = GNEAttributeProperties(SUMO_ATTR_FILE,
2657  "The file for generated output");
2658  myTagProperties[currentTag].addAttribute(attrProperty);
2659 
2660  attrProperty = GNEAttributeProperties(SUMO_ATTR_BEGIN,
2662  "The time at which to start generating output",
2663  "0");
2664  myTagProperties[currentTag].addAttribute(attrProperty);
2665  }
2666  currentTag = SUMO_TAG_VAPORIZER;
2667  {
2668  // set values of tag
2669  myTagProperties[currentTag] = GNETagProperties(currentTag,
2672  GUIIcon::VAPORIZER, currentTag, {}, FXRGBA(240, 240, 240, 255));
2673  // set values of attributes
2674  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2676  "Edge in which vaporizer is placed");
2677  myTagProperties[currentTag].addAttribute(attrProperty);
2678 
2679  attrProperty = GNEAttributeProperties(SUMO_ATTR_BEGIN,
2681  "Start Time",
2682  "0");
2683  myTagProperties[currentTag].addAttribute(attrProperty);
2684 
2685  attrProperty = GNEAttributeProperties(SUMO_ATTR_END,
2687  "End Time",
2688  "3600");
2689  myTagProperties[currentTag].addAttribute(attrProperty);
2690 
2691  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
2693  "Name of " + toString(currentTag));
2694  myTagProperties[currentTag].addAttribute(attrProperty);
2695  }
2696 }
2697 
2698 
2699 void
2701  // declare empty GNEAttributeProperties
2702  GNEAttributeProperties attrProperty;
2703  // fill shape ACs
2704  SumoXMLTag currentTag = SUMO_TAG_POLY;
2705  {
2706  // set values of tag
2707  myTagProperties[currentTag] = GNETagProperties(currentTag,
2710  GUIIcon::POLY, currentTag);
2711  // set values of attributes
2712  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2714  "The id of the polygon");
2715  myTagProperties[currentTag].addAttribute(attrProperty);
2716 
2717  attrProperty = GNEAttributeProperties(SUMO_ATTR_SHAPE,
2719  "The shape of the polygon");
2720  myTagProperties[currentTag].addAttribute(attrProperty);
2721 
2722  attrProperty = GNEAttributeProperties(SUMO_ATTR_COLOR,
2724  "The RGBA color with which the polygon shall be displayed",
2725  "red");
2726  myTagProperties[currentTag].addAttribute(attrProperty);
2727 
2728  attrProperty = GNEAttributeProperties(SUMO_ATTR_FILL,
2730  "An information whether the polygon shall be filled",
2731  "0");
2732  myTagProperties[currentTag].addAttribute(attrProperty);
2733 
2736  "The default line width for drawing an unfilled polygon",
2737  "1");
2738  myTagProperties[currentTag].addAttribute(attrProperty);
2739 
2740  attrProperty = GNEAttributeProperties(SUMO_ATTR_LAYER,
2742  "The layer in which the polygon lies",
2744  myTagProperties[currentTag].addAttribute(attrProperty);
2745 
2746  attrProperty = GNEAttributeProperties(SUMO_ATTR_TYPE,
2748  "A typename for the polygon",
2750  myTagProperties[currentTag].addAttribute(attrProperty);
2751 
2752  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
2754  "Name of " + toString(currentTag));
2755  myTagProperties[currentTag].addAttribute(attrProperty);
2756 
2759  "A bitmap to use for rendering this polygon",
2761  myTagProperties[currentTag].addAttribute(attrProperty);
2762 
2765  "Enable or disable use image file as a relative path",
2767  myTagProperties[currentTag].addAttribute(attrProperty);
2768 
2769  attrProperty = GNEAttributeProperties(SUMO_ATTR_ANGLE,
2771  "Angle of rendered image in degree",
2773  myTagProperties[currentTag].addAttribute(attrProperty);
2774  }
2775  currentTag = SUMO_TAG_POI;
2776  {
2777  // set values of tag
2778  myTagProperties[currentTag] = GNETagProperties(currentTag,
2781  GUIIcon::POI, currentTag);
2782  // set values of attributes
2783  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2785  "The id of the " + toString(currentTag));
2786  myTagProperties[currentTag].addAttribute(attrProperty);
2787 
2789  GNEAttributeProperties::STRING | GNEAttributeProperties::POSITION | GNEAttributeProperties::UNIQUE | GNEAttributeProperties::UPDATEGEOMETRY, // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
2790  "The position in view");
2791  myTagProperties[currentTag].addAttribute(attrProperty);
2792 
2793  attrProperty = GNEAttributeProperties(SUMO_ATTR_COLOR,
2795  "The color with which the " + toString(currentTag) + " shall be displayed",
2796  "red");
2797  myTagProperties[currentTag].addAttribute(attrProperty);
2798 
2799  attrProperty = GNEAttributeProperties(SUMO_ATTR_TYPE,
2801  "A typename for the " + toString(currentTag),
2803  myTagProperties[currentTag].addAttribute(attrProperty);
2804 
2805  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
2807  "Name of " + toString(currentTag));
2808  myTagProperties[currentTag].addAttribute(attrProperty);
2809 
2810  attrProperty = GNEAttributeProperties(SUMO_ATTR_LAYER,
2812  "The layer of the " + toString(currentTag) + " for drawing and selecting",
2814  myTagProperties[currentTag].addAttribute(attrProperty);
2815 
2816  attrProperty = GNEAttributeProperties(SUMO_ATTR_WIDTH,
2818  "Width of rendered image in meters",
2820  myTagProperties[currentTag].addAttribute(attrProperty);
2821 
2824  "Height of rendered image in meters",
2826  myTagProperties[currentTag].addAttribute(attrProperty);
2827 
2830  "A bitmap to use for rendering this " + toString(currentTag),
2832  myTagProperties[currentTag].addAttribute(attrProperty);
2833 
2836  "Enable or disable use image file as a relative path",
2838  myTagProperties[currentTag].addAttribute(attrProperty);
2839 
2840  attrProperty = GNEAttributeProperties(SUMO_ATTR_ANGLE,
2842  "Angle of rendered image in degree",
2844  myTagProperties[currentTag].addAttribute(attrProperty);
2845  }
2846  currentTag = GNE_TAG_POILANE;
2847  {
2848  // set values of tag
2849  myTagProperties[currentTag] = GNETagProperties(currentTag,
2851  0,
2853  // set values of attributes
2854  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2856  "The id of the " + toString(currentTag));
2857  myTagProperties[currentTag].addAttribute(attrProperty);
2858 
2859  attrProperty = GNEAttributeProperties(SUMO_ATTR_LANE,
2861  "The name of the lane at which the " + toString(currentTag) + " is located at");
2862  myTagProperties[currentTag].addAttribute(attrProperty);
2863 
2866  "The position on the named lane or in the net in meters at which the " + toString(currentTag) + " is located at");
2867  myTagProperties[currentTag].addAttribute(attrProperty);
2868 
2871  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
2872  "0");
2873  myTagProperties[currentTag].addAttribute(attrProperty);
2874 
2877  "The lateral offset on the named lane at which the " + toString(currentTag) + " is located at",
2878  "0.00");
2879  myTagProperties[currentTag].addAttribute(attrProperty);
2880 
2881  attrProperty = GNEAttributeProperties(SUMO_ATTR_COLOR,
2883  "The color with which the " + toString(currentTag) + " shall be displayed",
2884  "red");
2885  myTagProperties[currentTag].addAttribute(attrProperty);
2886 
2887  attrProperty = GNEAttributeProperties(SUMO_ATTR_TYPE,
2889  "A typename for the " + toString(currentTag),
2891  myTagProperties[currentTag].addAttribute(attrProperty);
2892 
2893  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
2895  "Name of " + toString(currentTag));
2896  myTagProperties[currentTag].addAttribute(attrProperty);
2897 
2898  attrProperty = GNEAttributeProperties(SUMO_ATTR_LAYER,
2900  "The layer of the " + toString(currentTag) + " for drawing and selecting",
2902  myTagProperties[currentTag].addAttribute(attrProperty);
2903 
2904  attrProperty = GNEAttributeProperties(SUMO_ATTR_WIDTH,
2906  "Width of rendered image in meters",
2908  myTagProperties[currentTag].addAttribute(attrProperty);
2909 
2912  "Height of rendered image in meters",
2914  myTagProperties[currentTag].addAttribute(attrProperty);
2915 
2918  "A bitmap to use for rendering this " + toString(currentTag),
2920  myTagProperties[currentTag].addAttribute(attrProperty);
2921 
2924  "Enable or disable use image file as a relative path",
2926  myTagProperties[currentTag].addAttribute(attrProperty);
2927 
2928  attrProperty = GNEAttributeProperties(SUMO_ATTR_ANGLE,
2930  "Angle of rendered image in degree",
2932  myTagProperties[currentTag].addAttribute(attrProperty);
2933  }
2934  currentTag = GNE_TAG_POIGEO;
2935  {
2936  // set values of tag
2937  myTagProperties[currentTag] = GNETagProperties(currentTag,
2941  // set values of attributes
2942  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
2944  "The id of the " + toString(currentTag));
2945  myTagProperties[currentTag].addAttribute(attrProperty);
2946 
2947  // set values of attributes
2948  attrProperty = GNEAttributeProperties(SUMO_ATTR_LON,
2950  "The longitud position of the parking vehicle on the view");
2951  myTagProperties[currentTag].addAttribute(attrProperty);
2952 
2953  attrProperty = GNEAttributeProperties(SUMO_ATTR_LAT,
2955  "The latitud position of the parking vehicle on the view");
2956  myTagProperties[currentTag].addAttribute(attrProperty);
2957 
2958  attrProperty = GNEAttributeProperties(SUMO_ATTR_COLOR,
2960  "The color with which the " + toString(currentTag) + " shall be displayed",
2961  "red");
2962  myTagProperties[currentTag].addAttribute(attrProperty);
2963 
2964  attrProperty = GNEAttributeProperties(SUMO_ATTR_TYPE,
2966  "A typename for the " + toString(currentTag),
2968  myTagProperties[currentTag].addAttribute(attrProperty);
2969 
2970  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
2972  "Name of " + toString(currentTag));
2973  myTagProperties[currentTag].addAttribute(attrProperty);
2974 
2975  attrProperty = GNEAttributeProperties(SUMO_ATTR_LAYER,
2977  "The layer of the " + toString(currentTag) + " for drawing and selecting",
2979  myTagProperties[currentTag].addAttribute(attrProperty);
2980 
2981  attrProperty = GNEAttributeProperties(SUMO_ATTR_WIDTH,
2983  "Width of rendered image in meters",
2985  myTagProperties[currentTag].addAttribute(attrProperty);
2986 
2989  "Height of rendered image in meters",
2991  myTagProperties[currentTag].addAttribute(attrProperty);
2992 
2995  "A bitmap to use for rendering this " + toString(currentTag),
2997  myTagProperties[currentTag].addAttribute(attrProperty);
2998 
3001  "Enable or disable use image file as a relative path",
3003  myTagProperties[currentTag].addAttribute(attrProperty);
3004 
3005  attrProperty = GNEAttributeProperties(SUMO_ATTR_ANGLE,
3007  "Angle of rendered image in degree",
3009  myTagProperties[currentTag].addAttribute(attrProperty);
3010  }
3011 }
3012 
3013 
3014 void
3016  // declare empty GNEAttributeProperties
3017  GNEAttributeProperties attrProperty;
3018  // fill TAZ ACs
3019  SumoXMLTag currentTag = SUMO_TAG_TAZ;
3020  {
3021  // set values of tag
3022  myTagProperties[currentTag] = GNETagProperties(currentTag,
3025  GUIIcon::TAZ, currentTag);
3026  // set values of attributes
3027  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3029  "The id of the TAZ");
3030  myTagProperties[currentTag].addAttribute(attrProperty);
3031 
3032  attrProperty = GNEAttributeProperties(SUMO_ATTR_SHAPE,
3034  "The shape of the TAZ");
3035  myTagProperties[currentTag].addAttribute(attrProperty);
3036 
3039  "TAZ center");
3040  myTagProperties[currentTag].addAttribute(attrProperty);
3041 
3042  attrProperty = GNEAttributeProperties(SUMO_ATTR_FILL,
3044  "An information whether the TAZ shall be filled",
3045  "0");
3046  myTagProperties[currentTag].addAttribute(attrProperty);
3047 
3048  attrProperty = GNEAttributeProperties(SUMO_ATTR_COLOR,
3050  "The RGBA color with which the TAZ shall be displayed",
3051  "red");
3052  myTagProperties[currentTag].addAttribute(attrProperty);
3053 
3054  attrProperty = GNEAttributeProperties(SUMO_ATTR_NAME,
3056  "Name of " + toString(currentTag));
3057  myTagProperties[currentTag].addAttribute(attrProperty);
3058  }
3059  currentTag = SUMO_TAG_TAZSOURCE;
3060  {
3061  // set values of tag
3062  myTagProperties[currentTag] = GNETagProperties(currentTag,
3065  GUIIcon::TAZEDGE, currentTag, {SUMO_TAG_TAZ});
3066  // set values of attributes
3067  attrProperty = GNEAttributeProperties(SUMO_ATTR_EDGE,
3069  "The id of edge in the simulation network");
3070  attrProperty.setSynonym(SUMO_ATTR_ID);
3071  myTagProperties[currentTag].addAttribute(attrProperty);
3072 
3075  "Depart weight associated to this Edge",
3076  "1");
3077  myTagProperties[currentTag].addAttribute(attrProperty);
3078  }
3079  currentTag = SUMO_TAG_TAZSINK;
3080  {
3081  // set values of tag
3082  myTagProperties[currentTag] = GNETagProperties(currentTag,
3085  GUIIcon::TAZEDGE, currentTag, {SUMO_TAG_TAZ});
3086  // set values of attributes
3087  attrProperty = GNEAttributeProperties(SUMO_ATTR_EDGE,
3089  "The id of edge in the simulation network");
3090  attrProperty.setSynonym(SUMO_ATTR_ID);
3091  myTagProperties[currentTag].addAttribute(attrProperty);
3092 
3095  "Arrival weight associated to this Edget",
3096  "1");
3097  myTagProperties[currentTag].addAttribute(attrProperty);
3098  }
3099 }
3100 
3101 
3102 void
3104  // declare empty GNEAttributeProperties
3105  GNEAttributeProperties attrProperty;
3106 
3107  // fill demand elements
3108  SumoXMLTag currentTag = SUMO_TAG_ROUTE;
3109  {
3110  // set values of tag
3111  myTagProperties[currentTag] = GNETagProperties(currentTag,
3113  0,
3114  GUIIcon::ROUTE, currentTag);
3115 
3116  // set values of attributes
3117  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3119  "The id of Route");
3120  myTagProperties[currentTag].addAttribute(attrProperty);
3121 
3122  attrProperty = GNEAttributeProperties(SUMO_ATTR_EDGES,
3124  "The edges the vehicle shall drive along, given as their ids, separated using spaces");
3125  myTagProperties[currentTag].addAttribute(attrProperty);
3126 
3127  attrProperty = GNEAttributeProperties(SUMO_ATTR_COLOR,
3129  "This route's color");
3130  myTagProperties[currentTag].addAttribute(attrProperty);
3131 
3134  "The number of times that the edges of this route shall be repeated",
3135  "0");
3136  myTagProperties[currentTag].addAttribute(attrProperty);
3137 
3140  "When defining a repeating route with stops and those stops use the until attribute, the times will be shifted forward by 'cycleTime' on each repeat",
3141  "0");
3142  myTagProperties[currentTag].addAttribute(attrProperty);
3143  }
3144  currentTag = GNE_TAG_ROUTE_EMBEDDED;
3145  {
3146  // set values of tag
3147  myTagProperties[currentTag] = GNETagProperties(currentTag,
3151 
3152  // set values of attributes
3153  attrProperty = GNEAttributeProperties(SUMO_ATTR_EDGES,
3155  "The edges the vehicle shall drive along, given as their ids, separated using spaces");
3156  myTagProperties[currentTag].addAttribute(attrProperty);
3157 
3158  attrProperty = GNEAttributeProperties(SUMO_ATTR_COLOR,
3160  "This route's color");
3161  myTagProperties[currentTag].addAttribute(attrProperty);
3162 
3165  "The number of times that the edges of this route shall be repeated",
3166  "0");
3167  myTagProperties[currentTag].addAttribute(attrProperty);
3168 
3171  "When defining a repeating route with stops and those stops use the until attribute, the times will be shifted forward by 'cycleTime' on each repeat",
3172  "0");
3173  myTagProperties[currentTag].addAttribute(attrProperty);
3174  }
3175  currentTag = SUMO_TAG_VTYPE_DISTRIBUTION;
3176  {
3177  // set values of tag
3178  myTagProperties[currentTag] = GNETagProperties(currentTag,
3181  GUIIcon::VTYPEDISTRIBUTION, currentTag);
3182 
3183  // set values of attributes
3184  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3186  "The id of VehicleType distribution");
3187  myTagProperties[currentTag].addAttribute(attrProperty);
3188  }
3189  currentTag = SUMO_TAG_VTYPE;
3190  {
3191  // set values of tag
3192  myTagProperties[currentTag] = GNETagProperties(currentTag,
3195  GUIIcon::VTYPE, currentTag);
3196 
3197  // set values of attributes
3198  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3200  "The id of VehicleType");
3201  myTagProperties[currentTag].addAttribute(attrProperty);
3202 
3205  "Vehicle Type Distribution");
3206  myTagProperties[currentTag].addAttribute(attrProperty);
3207 
3210  "An abstract vehicle class",
3211  "passenger");
3212  attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
3213  myTagProperties[currentTag].addAttribute(attrProperty);
3214 
3215  attrProperty = GNEAttributeProperties(SUMO_ATTR_COLOR,
3217  "This vehicle type's color",
3218  "");
3219  myTagProperties[currentTag].addAttribute(attrProperty);
3220 
3223  "The vehicle's netto-length (length) [m]");
3224  myTagProperties[currentTag].addAttribute(attrProperty);
3225 
3228  "Empty space after leader [m]");
3229  myTagProperties[currentTag].addAttribute(attrProperty);
3230 
3233  "The vehicle's maximum velocity [m/s]");
3234  myTagProperties[currentTag].addAttribute(attrProperty);
3235 
3238  "The vehicles expected multiplicator for lane speed limits (or a distribution specifier)");
3239  myTagProperties[currentTag].addAttribute(attrProperty);
3240 
3243  "An abstract emission class");
3245  myTagProperties[currentTag].addAttribute(attrProperty);
3246 
3249  "How this vehicle is rendered");
3250  attrProperty.setDiscreteValues(SumoVehicleShapeStrings.getStrings());
3251  myTagProperties[currentTag].addAttribute(attrProperty);
3252 
3253  attrProperty = GNEAttributeProperties(SUMO_ATTR_WIDTH,
3255  "The vehicle's width [m] (only used for drawing)",
3256  "1.8");
3257  myTagProperties[currentTag].addAttribute(attrProperty);
3258 
3261  "The vehicle's height [m] (only used for drawing)",
3262  "1.5");
3263  myTagProperties[currentTag].addAttribute(attrProperty);
3264 
3267  "Image file for rendering vehicles of this type (should be grayscale to allow functional coloring)");
3268  myTagProperties[currentTag].addAttribute(attrProperty);
3269 
3272  "The model used for changing lanes",
3273  "default");
3274  attrProperty.setDiscreteValues(SUMOXMLDefinitions::LaneChangeModels.getStrings());
3275  myTagProperties[currentTag].addAttribute(attrProperty);
3276 
3279  "The model used for car following",
3280  "Krauss");
3281  attrProperty.setDiscreteValues(SUMOXMLDefinitions::CarFollowModels.getStrings());
3282  myTagProperties[currentTag].addAttribute(attrProperty);
3283 
3286  "The number of persons (excluding an autonomous driver) the vehicle can transport");
3287  myTagProperties[currentTag].addAttribute(attrProperty);
3288 
3291  "The number of containers the vehicle can transport");
3292  myTagProperties[currentTag].addAttribute(attrProperty);
3293 
3296  "The time required by a person to board the vehicle",
3297  "0.50");
3298  myTagProperties[currentTag].addAttribute(attrProperty);
3299 
3302  "The time required to load a container onto the vehicle",
3303  "90.00");
3304  myTagProperties[currentTag].addAttribute(attrProperty);
3305 
3308  "The preferred lateral alignment when using the sublane-model",
3309  "center");
3311  myTagProperties[currentTag].addAttribute(attrProperty);
3312 
3315  "The minimum lateral gap at a speed difference of 50km/h when using the sublane-model",
3316  "0.12");
3317  myTagProperties[currentTag].addAttribute(attrProperty);
3318 
3321  "The maximum lateral speed when using the sublane-model",
3322  "1.00");
3323  myTagProperties[currentTag].addAttribute(attrProperty);
3324 
3327  "The interval length for which vehicle performs its decision logic (acceleration and lane-changing)",
3328  toString(OptionsCont::getOptions().getFloat("default.action-step-length")));
3329  myTagProperties[currentTag].addAttribute(attrProperty);
3330 
3331  attrProperty = GNEAttributeProperties(SUMO_ATTR_PROB,
3333  "The probability when being added to a distribution without an explicit probability",
3335  myTagProperties[currentTag].addAttribute(attrProperty);
3336 
3339  "3D model file for this class",
3340  "");
3341  myTagProperties[currentTag].addAttribute(attrProperty);
3342 
3345  "Carriage lengths");
3346  myTagProperties[currentTag].addAttribute(attrProperty);
3347 
3350  "Locomotive lengths");
3351  myTagProperties[currentTag].addAttribute(attrProperty);
3352 
3355  "GAP between carriages",
3356  "1");
3357  myTagProperties[currentTag].addAttribute(attrProperty);
3358 
3359  // fill VType Car Following Model Values (implemented in a separated function to improve code legibility)
3360  fillCarFollowingModelAttributes(currentTag);
3361 
3362  // fill VType Junction Model Parameters (implemented in a separated function to improve code legibility)
3363  fillJunctionModelAttributes(currentTag);
3364 
3365  // fill VType Lane Change Model Parameters (implemented in a separated function to improve code legibility)
3366  fillLaneChangingModelAttributes(currentTag);
3367  }
3368 }
3369 
3370 
3371 void
3373  // declare empty GNEAttributeProperties
3374  GNEAttributeProperties attrProperty;
3375  // fill vehicle ACs
3376  SumoXMLTag currentTag = SUMO_TAG_TRIP;
3377  {
3378  // set values of tag
3379  myTagProperties[currentTag] = GNETagProperties(currentTag,
3381  0,
3382  GUIIcon::TRIP, currentTag, {}, FXRGBA(240, 238, 249, 255));
3383  myTagProperties[currentTag].setFieldString("trip (from-to edges)");
3384 
3385  // set values of attributes
3386  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3388  "The name of " + toString(currentTag) + "s that will be generated using this trip definition");
3389  myTagProperties[currentTag].addAttribute(attrProperty);
3390 
3391  attrProperty = GNEAttributeProperties(SUMO_ATTR_TYPE,
3393  "The id of the " + toString(currentTag) + " type to use for this " + toString(currentTag),
3395  myTagProperties[currentTag].addAttribute(attrProperty);
3396 
3397  attrProperty = GNEAttributeProperties(SUMO_ATTR_FROM,
3399  "The name of the edge the " + toString(currentTag) + " starts at");
3400  myTagProperties[currentTag].addAttribute(attrProperty);
3401 
3402  attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
3404  "The name of the edge the " + toString(currentTag) + " ends at");
3405  myTagProperties[currentTag].addAttribute(attrProperty);
3406 
3407  attrProperty = GNEAttributeProperties(SUMO_ATTR_VIA,
3409  "List of intermediate edge ids which shall be part of the " + toString(currentTag));
3410  myTagProperties[currentTag].addAttribute(attrProperty);
3411 
3412  // add common attributes
3413  fillCommonVehicleAttributes(currentTag);
3414 
3417  "The departure time of the (first) " + toString(currentTag) + " which is generated using this " + toString(currentTag) + " definition",
3418  "0.00");
3419  myTagProperties[currentTag].addAttribute(attrProperty);
3420  }
3421  currentTag = GNE_TAG_TRIP_JUNCTIONS;
3422  {
3423  // set values of tag
3424  myTagProperties[currentTag] = GNETagProperties(currentTag,
3426  0,
3427  GUIIcon::TRIP_JUNCTIONS, SUMO_TAG_TRIP, {}, FXRGBA(240, 238, 249, 255));
3428  myTagProperties[currentTag].setFieldString("trip (from-to junctions)");
3429 
3430  // set values of attributes
3431  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3433  "The name of " + toString(currentTag) + "s that will be generated using this trip definition");
3434  myTagProperties[currentTag].addAttribute(attrProperty);
3435 
3436  attrProperty = GNEAttributeProperties(SUMO_ATTR_TYPE,
3438  "The id of the " + toString(currentTag) + " type to use for this " + toString(currentTag),
3440  myTagProperties[currentTag].addAttribute(attrProperty);
3441 
3444  "The name of the junction the " + toString(currentTag) + " starts at");
3445  myTagProperties[currentTag].addAttribute(attrProperty);
3446 
3449  "The name of the junction the " + toString(currentTag) + " ends at");
3450  myTagProperties[currentTag].addAttribute(attrProperty);
3451 
3452  // add common attributes
3453  fillCommonVehicleAttributes(currentTag);
3454 
3457  "The departure time of the (first) " + toString(currentTag) + " which is generated using this " + toString(currentTag) + " definition",
3458  "0.00");
3459  myTagProperties[currentTag].addAttribute(attrProperty);
3460  }
3461  currentTag = SUMO_TAG_VEHICLE;
3462  {
3463  // set values of tag
3464  myTagProperties[currentTag] = GNETagProperties(currentTag,
3466  0,
3467  GUIIcon::VEHICLE, currentTag, {}, FXRGBA(240, 238, 249, 255));
3468  myTagProperties[currentTag].setFieldString("vehicle (over route)");
3469 
3470  // set values of attributes
3471  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3473  "The name of the " + toString(currentTag));
3474  myTagProperties[currentTag].addAttribute(attrProperty);
3475 
3476  attrProperty = GNEAttributeProperties(SUMO_ATTR_TYPE,
3478  "The id of the vehicle type to use for this " + toString(currentTag),
3480  myTagProperties[currentTag].addAttribute(attrProperty);
3481 
3482  attrProperty = GNEAttributeProperties(SUMO_ATTR_ROUTE,
3484  "The id of the route the " + toString(currentTag) + " shall drive along");
3485  myTagProperties[currentTag].addAttribute(attrProperty);
3486 
3489  "The index of the edge within route the " + toString(currentTag) + " starts at");
3490  myTagProperties[currentTag].addAttribute(attrProperty);
3491 
3494  "The index of the edge within route the " + toString(currentTag) + " ends at");
3495  myTagProperties[currentTag].addAttribute(attrProperty);
3496 
3497  // add common attributes
3498  fillCommonVehicleAttributes(currentTag);
3499 
3502  "The time step at which the " + toString(currentTag) + " shall enter the network",
3503  "0.00");
3504  myTagProperties[currentTag].addAttribute(attrProperty);
3505  }
3506  currentTag = GNE_TAG_VEHICLE_WITHROUTE;
3507  {
3508  // set values of tag
3509  myTagProperties[currentTag] = GNETagProperties(currentTag,
3512  GUIIcon::VEHICLE, SUMO_TAG_VEHICLE, {}, FXRGBA(240, 238, 249, 255));
3513  myTagProperties[currentTag].setFieldString("vehicle (embedded route)");
3514 
3515  // set values of attributes
3516  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3518  "The name of the " + toString(SUMO_TAG_VEHICLE));
3519  myTagProperties[currentTag].addAttribute(attrProperty);
3520 
3521  attrProperty = GNEAttributeProperties(SUMO_ATTR_TYPE,
3523  "The id of the vehicle type to use for this " + toString(SUMO_TAG_VEHICLE),
3525  myTagProperties[currentTag].addAttribute(attrProperty);
3526 
3529  "The index of the edge within route the " + toString(currentTag) + " starts at");
3530  myTagProperties[currentTag].addAttribute(attrProperty);
3531 
3534  "The index of the edge within route the " + toString(currentTag) + " ends at");
3535  myTagProperties[currentTag].addAttribute(attrProperty);
3536 
3537  // add common attributes
3538  fillCommonVehicleAttributes(currentTag);
3539 
3542  "The time step at which the " + toString(SUMO_TAG_VEHICLE) + " shall enter the network",
3543  "0.00");
3544  myTagProperties[currentTag].addAttribute(attrProperty);
3545  }
3546  currentTag = SUMO_TAG_FLOW;
3547  {
3548  // set values of tag
3549  myTagProperties[currentTag] = GNETagProperties(currentTag,
3551  0,
3552  GUIIcon::FLOW, currentTag, {}, FXRGBA(210, 233, 255, 255));
3553  myTagProperties[currentTag].setFieldString("flow (from-to edges)");
3554 
3555  // set values of attributes
3556  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3558  "The name of the " + toString(currentTag));
3559  myTagProperties[currentTag].addAttribute(attrProperty);
3560 
3561  attrProperty = GNEAttributeProperties(SUMO_ATTR_TYPE,
3563  "The id of the " + toString(currentTag) + " type to use for this " + toString(currentTag),
3565  myTagProperties[currentTag].addAttribute(attrProperty);
3566 
3567  attrProperty = GNEAttributeProperties(SUMO_ATTR_FROM,
3569  "The name of the edge the " + toString(currentTag) + " starts at");
3570  myTagProperties[currentTag].addAttribute(attrProperty);
3571 
3572  attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
3574  "The name of the edge the " + toString(currentTag) + " ends at");
3575  myTagProperties[currentTag].addAttribute(attrProperty);
3576 
3577  attrProperty = GNEAttributeProperties(SUMO_ATTR_VIA,
3579  "List of intermediate edge ids which shall be part of the " + toString(currentTag));
3580  myTagProperties[currentTag].addAttribute(attrProperty);
3581 
3582  // add common attributes
3583  fillCommonVehicleAttributes(currentTag);
3584 
3585  // add flow attributes
3587  }
3588  currentTag = GNE_TAG_FLOW_JUNCTIONS;
3589  {
3590  // set values of tag
3591  myTagProperties[currentTag] = GNETagProperties(currentTag,
3593  0,
3594  GUIIcon::FLOW_JUNCTIONS, SUMO_TAG_FLOW, {}, FXRGBA(210, 233, 255, 255));
3595  myTagProperties[currentTag].setFieldString("flow (from-to junctions)");
3596 
3597  // set values of attributes
3598  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3600  "The name of the " + toString(currentTag));
3601  myTagProperties[currentTag].addAttribute(attrProperty);
3602 
3603  attrProperty = GNEAttributeProperties(SUMO_ATTR_TYPE,
3605  "The id of the " + toString(currentTag) + " type to use for this " + toString(currentTag),
3607  myTagProperties[currentTag].addAttribute(attrProperty);
3608 
3611  "The name of the junction the " + toString(currentTag) + " starts at");
3612  myTagProperties[currentTag].addAttribute(attrProperty);
3613 
3616  "The name of the junction the " + toString(currentTag) + " ends at");
3617  myTagProperties[currentTag].addAttribute(attrProperty);
3618 
3619  // add common attributes
3620  fillCommonVehicleAttributes(currentTag);
3621 
3622  // add flow attributes
3624  }
3625  currentTag = GNE_TAG_FLOW_ROUTE;
3626  {
3627  // set values of tag
3628  myTagProperties[currentTag] = GNETagProperties(currentTag,
3630  0,
3631  GUIIcon::ROUTEFLOW, SUMO_TAG_FLOW, {}, FXRGBA(210, 233, 255, 255));
3632  myTagProperties[currentTag].setFieldString("flow (over route)");
3633 
3634  // set values of attributes
3635  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3637  "The name of the " + toString(currentTag));
3638  myTagProperties[currentTag].addAttribute(attrProperty);
3639 
3640  attrProperty = GNEAttributeProperties(SUMO_ATTR_TYPE,
3642  "The id of the " + toString(currentTag) + " type to use for this " + toString(currentTag),
3644  myTagProperties[currentTag].addAttribute(attrProperty);
3645 
3646  attrProperty = GNEAttributeProperties(SUMO_ATTR_ROUTE,
3648  "The id of the route the " + toString(currentTag) + " shall drive along");
3649  myTagProperties[currentTag].addAttribute(attrProperty);
3650 
3653  "The index of the edge within route the " + toString(currentTag) + " starts at");
3654  myTagProperties[currentTag].addAttribute(attrProperty);
3655 
3658  "The index of the edge within route the " + toString(currentTag) + " ends at");
3659  myTagProperties[currentTag].addAttribute(attrProperty);
3660 
3661  // add common attributes
3662  fillCommonVehicleAttributes(currentTag);
3663 
3664  // add flow attributes
3666  }
3667  currentTag = GNE_TAG_FLOW_WITHROUTE;
3668  {
3669  // set values of tag
3670  myTagProperties[currentTag] = GNETagProperties(currentTag,
3673  GUIIcon::ROUTEFLOW, SUMO_TAG_FLOW, {}, FXRGBA(210, 233, 255, 255));
3674  myTagProperties[currentTag].setFieldString("flow (embedded route)");
3675 
3676  // set values of attributes
3677  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
3679  "The name of the " + toString(SUMO_TAG_FLOW));
3680  myTagProperties[currentTag].addAttribute(attrProperty);
3681 
3682  attrProperty = GNEAttributeProperties(SUMO_ATTR_TYPE,
3684  "The id of the " + toString(currentTag) + " type to use for this " + toString(SUMO_TAG_FLOW),
3686  myTagProperties[currentTag].addAttribute(attrProperty);
3687 
3690  "The index of the edge within route the " + toString(currentTag) + " starts at");
3691  myTagProperties[currentTag].addAttribute(attrProperty);
3692 
3695  "The index of the edge within route the " + toString(currentTag) + " ends at");
3696  myTagProperties[currentTag].addAttribute(attrProperty);
3697 
3698  // add common attributes
3699  fillCommonVehicleAttributes(currentTag);
3700 
3701  // add flow attributes
3703  }
3704  /* currently disabled. See #5259
3705  currentTag = SUMO_TAG_TRIP_TAZ;
3706  {
3707  // set values of tag
3708  myTagProperties[currentTag] = GNETagProperties(currentTag,
3709  GNETagProperties::DEMANDELEMENT | GNETagProperties::VEHICLE,
3710  GNETagProperties::DRAWABLE,
3711  GUIIcon::TRIP);
3712  }
3713  */
3714 }
3715 
3716 
3717 void
3719  // declare empty GNEAttributeProperties
3720  GNEAttributeProperties attrProperty;
3721  // fill stops ACs
3722  SumoXMLTag currentTag = SUMO_TAG_STOP_LANE;
3723  {
3724  // set values of tag
3725  myTagProperties[currentTag] = GNETagProperties(currentTag,
3729  // set values of attributes
3730  attrProperty = GNEAttributeProperties(SUMO_ATTR_LANE,
3732  "The name of the lane the stop shall be located at");
3733  myTagProperties[currentTag].addAttribute(attrProperty);
3734 
3737  "The begin position on the lane (the lower position on the lane) in meters");
3738  myTagProperties[currentTag].addAttribute(attrProperty);
3739 
3742  "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
3743  myTagProperties[currentTag].addAttribute(attrProperty);
3744 
3747  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
3748  "0");
3749  myTagProperties[currentTag].addAttribute(attrProperty);
3750 
3753  "The lateral offset on the named lane at which the vehicle must stop",
3754  "");
3755  myTagProperties[currentTag].addAttribute(attrProperty);
3756 
3757  // fill common stop attributes
3758  fillCommonStopAttributes(currentTag);
3759  }
3760  currentTag = SUMO_TAG_STOP_BUSSTOP;
3761  {
3762  // set values of tag
3763  myTagProperties[currentTag] = GNETagProperties(currentTag,
3767  // set values of attributes
3770  "BusStop associated with this stop");
3771  myTagProperties[currentTag].addAttribute(attrProperty);
3772 
3773  // fill common stop attributes
3774  fillCommonStopAttributes(currentTag);
3775  }
3776  currentTag = SUMO_TAG_STOP_CONTAINERSTOP;
3777  {
3778  // set values of tag
3779  myTagProperties[currentTag] = GNETagProperties(currentTag,
3783  // set values of attributes
3786  "ContainerStop associated with this stop");
3787  myTagProperties[currentTag].addAttribute(attrProperty);
3788 
3789  // fill common stop attributes
3790  fillCommonStopAttributes(currentTag);
3791  }
3792  currentTag = SUMO_TAG_STOP_CHARGINGSTATION;
3793  {
3794  // set values of tag
3795  myTagProperties[currentTag] = GNETagProperties(currentTag,
3799  // set values of attributes
3802  "ChargingStation associated with this stop");
3803  myTagProperties[currentTag].addAttribute(attrProperty);
3804 
3805  // fill common stop attributes
3806  fillCommonStopAttributes(currentTag);
3807  }
3808  currentTag = SUMO_TAG_STOP_PARKINGAREA;
3809  {
3810  // set values of tag
3811  myTagProperties[currentTag] = GNETagProperties(currentTag,
3815  // set values of attributes
3818  "ParkingArea associated with this stop");
3819  myTagProperties[currentTag].addAttribute(attrProperty);
3820 
3821  // fill common stop attributes (no parking)
3822  fillCommonStopAttributes(currentTag);
3823  }
3824 }
3825 
3826 
3827 void
3829  // declare empty GNEAttributeProperties
3830  GNEAttributeProperties attrProperty;
3831  // fill vehicle ACs
3832  SumoXMLTag currentTag = SUMO_TAG_PERSON;
3833  {
3834  // set values of tag
3835  myTagProperties[currentTag] = GNETagProperties(currentTag,
3837  0,
3838  GUIIcon::PERSON, currentTag);
3839 
3840  // add flow attributes
3841  fillCommonPersonAttributes(currentTag);
3842 
3843  // set specific attribute depart (note: Persons doesn't support triggered and containerTriggered values)
3846  "The time step at which the " + toString(currentTag) + " shall enter the network",
3847  "0.00");
3848  myTagProperties[currentTag].addAttribute(attrProperty);
3849 
3850  }
3851  currentTag = SUMO_TAG_PERSONFLOW;
3852  {
3853  // set values of tag
3854  myTagProperties[currentTag] = GNETagProperties(currentTag,
3856  0,
3857  GUIIcon::PERSONFLOW, currentTag);
3858 
3859  // add flow attributes
3860  fillCommonPersonAttributes(currentTag);
3861 
3862  // add flow attributes
3864  }
3865 }
3866 
3867 
3868 void
3870  // declare empty GNEAttributeProperties
3871  GNEAttributeProperties attrProperty;
3872  // fill vehicle ACs
3873  SumoXMLTag currentTag = SUMO_TAG_CONTAINER;
3874  {
3875  // set values of tag
3876  myTagProperties[currentTag] = GNETagProperties(currentTag,
3878  0,
3879  GUIIcon::CONTAINER, currentTag);
3880 
3881  // add flow attributes
3882  fillCommonContainerAttributes(currentTag);
3883  }
3884  currentTag = SUMO_TAG_CONTAINERFLOW;
3885  {
3886  // set values of tag
3887  myTagProperties[currentTag] = GNETagProperties(currentTag,
3889  0,
3890  GUIIcon::CONTAINERFLOW, currentTag);
3891 
3892  // add common container attribute
3893  fillCommonContainerAttributes(currentTag);
3894 
3895  // add flow attributes
3897  }
3898 }
3899 
3900 
3901 void
3903  // declare empty GNEAttributeProperties
3904  GNEAttributeProperties attrProperty;
3905  // fill walks
3906  SumoXMLTag currentTag = GNE_TAG_TRANSPORT_EDGE;
3907  {
3908  // set values of tag
3909  myTagProperties[currentTag] = GNETagProperties(currentTag,
3913  // from edge
3914  attrProperty = GNEAttributeProperties(SUMO_ATTR_FROM,
3916  "The name of the edge the " + toString(currentTag) + " starts at");
3917  myTagProperties[currentTag].addAttribute(attrProperty);
3918  // to edge
3919  attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
3921  "The name of the edge the " + toString(currentTag) + " ends at");
3922  myTagProperties[currentTag].addAttribute(attrProperty);
3923  // lines
3924  attrProperty = GNEAttributeProperties(SUMO_ATTR_LINES,
3926  "list of vehicle alternatives to take for the " + toString(currentTag),
3927  "");
3928  myTagProperties[currentTag].addAttribute(attrProperty);
3929  // arrival position
3932  "arrival position on the destination edge",
3933  "-1");
3934  myTagProperties[currentTag].addAttribute(attrProperty);
3935  }
3936  currentTag = GNE_TAG_TRANSPORT_CONTAINERSTOP;
3937  {
3938  // set values of tag
3939  myTagProperties[currentTag] = GNETagProperties(currentTag,
3943  // from edge
3944  attrProperty = GNEAttributeProperties(SUMO_ATTR_FROM,
3946  "The name of the edge the " + toString(currentTag) + " starts at");
3947  myTagProperties[currentTag].addAttribute(attrProperty);
3948  // lines
3949  attrProperty = GNEAttributeProperties(SUMO_ATTR_LINES,
3951  "list of vehicle alternatives to take for the " + toString(currentTag),
3952  "");
3953  myTagProperties[currentTag].addAttribute(attrProperty);
3954  // to busStop
3957  "Id of the destination " + toString(SUMO_TAG_BUS_STOP));
3958  myTagProperties[currentTag].addAttribute(attrProperty);
3959  }
3960 }
3961 
3962 
3963 void
3965  // declare empty GNEAttributeProperties
3966  GNEAttributeProperties attrProperty;
3967  // fill walks
3968  SumoXMLTag currentTag = GNE_TAG_TRANSHIP_EDGE;
3969  {
3970  // set values of tag
3971  myTagProperties[currentTag] = GNETagProperties(currentTag,
3975  // from edge
3976  attrProperty = GNEAttributeProperties(SUMO_ATTR_FROM,
3978  "The name of the edge the " + toString(currentTag) + " starts at");
3979  myTagProperties[currentTag].addAttribute(attrProperty);
3980  // to edge
3981  attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
3983  "The name of the edge the " + toString(currentTag) + " ends at");
3984  myTagProperties[currentTag].addAttribute(attrProperty);
3985  // speed
3986  attrProperty = GNEAttributeProperties(SUMO_ATTR_SPEED,
3988  "speed of the container for this tranship in m/s",
3989  "1.39");
3990  myTagProperties[currentTag].addAttribute(attrProperty);
3991  // depart pos
3994  "The position at which the " + toString(currentTag) + " shall enter the net",
3995  "0");
3996  myTagProperties[currentTag].addAttribute(attrProperty);
3997  // arrival position
4000  "arrival position on the destination edge",
4001  "-1");
4002  myTagProperties[currentTag].addAttribute(attrProperty);
4003  }
4004  currentTag = GNE_TAG_TRANSHIP_CONTAINERSTOP;
4005  {
4006  // set values of tag
4007  myTagProperties[currentTag] = GNETagProperties(currentTag,
4011  // from edge
4012  attrProperty = GNEAttributeProperties(SUMO_ATTR_FROM,
4014  "The name of the edge the " + toString(currentTag) + " starts at");
4015  myTagProperties[currentTag].addAttribute(attrProperty);
4016  // to busStop
4019  "Id of the destination " + toString(SUMO_TAG_BUS_STOP));
4020  myTagProperties[currentTag].addAttribute(attrProperty);
4021  // speed
4022  attrProperty = GNEAttributeProperties(SUMO_ATTR_SPEED,
4024  "speed of the container for this tranship in m/s",
4025  "1.39");
4026  myTagProperties[currentTag].addAttribute(attrProperty);
4027  // depart pos
4030  "The position at which the " + toString(currentTag) + " shall enter the net",
4031  "0");
4032  myTagProperties[currentTag].addAttribute(attrProperty);
4033  }
4034  currentTag = GNE_TAG_TRANSHIP_EDGES;
4035  {
4036  // set values of tag
4037  myTagProperties[currentTag] = GNETagProperties(currentTag,
4041  // edges
4042  attrProperty = GNEAttributeProperties(SUMO_ATTR_EDGES,
4044  "id of the edges to walk");
4045  myTagProperties[currentTag].addAttribute(attrProperty);
4046  // speed
4047  attrProperty = GNEAttributeProperties(SUMO_ATTR_SPEED,
4049  "speed of the container for this tranship in m/s",
4050  "1.39");
4051  myTagProperties[currentTag].addAttribute(attrProperty);
4052  // depart pos
4055  "The position at which the " + toString(currentTag) + " shall enter the net",
4056  "0");
4057  myTagProperties[currentTag].addAttribute(attrProperty);
4058  // arrival pos
4061  "Arrival position on the destination edge",
4062  "-1");
4063  myTagProperties[currentTag].addAttribute(attrProperty);
4064  }
4065 }
4066 
4067 
4068 void
4070  // declare empty GNEAttributeProperties
4071  GNEAttributeProperties attrProperty;
4072  // fill vehicle ACs
4074  {
4075  // set values of tag
4076  myTagProperties[currentTag] = GNETagProperties(currentTag,
4080 
4081  // set values of attributes
4082  attrProperty = GNEAttributeProperties(SUMO_ATTR_EDGE,
4084  "The name of the edge the stop shall be located at");
4085  myTagProperties[currentTag].addAttribute(attrProperty);
4086 
4089  "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
4090  myTagProperties[currentTag].addAttribute(attrProperty);
4091 
4094  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
4095  "0");
4096  myTagProperties[currentTag].addAttribute(attrProperty);
4097 
4100  "Minimum duration for stopping",
4101  "60");
4102  attrProperty.setDefaultActivated(true);
4103  myTagProperties[currentTag].addAttribute(attrProperty);
4104 
4105  attrProperty = GNEAttributeProperties(SUMO_ATTR_UNTIL,
4107  "The time step at which the route continues",
4108  "0.00");
4109  myTagProperties[currentTag].addAttribute(attrProperty);
4110 
4113  "Activity displayed for stopped container in GUI and output files ",
4114  "waiting");
4115  myTagProperties[currentTag].addAttribute(attrProperty);
4116  }
4118  {
4119  // set values of tag
4120  myTagProperties[currentTag] = GNETagProperties(currentTag,
4124 
4125  // set values of attributes
4128  "ContainerStop associated with this stop");
4129  myTagProperties[currentTag].addAttribute(attrProperty);
4130 
4133  "Minimum duration for stopping",
4134  "60");
4135  myTagProperties[currentTag].addAttribute(attrProperty);
4136 
4137  attrProperty = GNEAttributeProperties(SUMO_ATTR_UNTIL,
4139  "The time step at which the route continues",
4140  "0.00");
4141  myTagProperties[currentTag].addAttribute(attrProperty);
4142 
4145  "Activity displayed for stopped container in GUI and output files ",
4146  "waiting");
4147  myTagProperties[currentTag].addAttribute(attrProperty);
4148  }
4149 }
4150 
4151 
4152 void
4154  // declare empty GNEAttributeProperties
4155  GNEAttributeProperties attrProperty;
4156  // fill person trips
4157  SumoXMLTag currentTag = GNE_TAG_PERSONTRIP_EDGE;
4158  {
4159  // set values of tag
4160  myTagProperties[currentTag] = GNETagProperties(currentTag,
4164  // from edge
4165  attrProperty = GNEAttributeProperties(SUMO_ATTR_FROM,
4167  "The name of the edge the " + toString(currentTag) + " starts at");
4168  myTagProperties[currentTag].addAttribute(attrProperty);
4169  // to edge
4170  attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
4172  "The name of the edge the " + toString(currentTag) + " ends at");
4173  myTagProperties[currentTag].addAttribute(attrProperty);
4174  // arrival position
4177  "arrival position on the destination edge",
4178  "-1");
4179  myTagProperties[currentTag].addAttribute(attrProperty);
4180  // vTypes
4183  "List of possible vehicle types to take");
4184  myTagProperties[currentTag].addAttribute(attrProperty);
4185  // modes
4186  attrProperty = GNEAttributeProperties(SUMO_ATTR_MODES,
4188  "List of possible traffic modes. Walking is always possible regardless of this value");
4189  myTagProperties[currentTag].addAttribute(attrProperty);
4190  }
4191  currentTag = GNE_TAG_PERSONTRIP_BUSSTOP;
4192  {
4193  // set values of tag
4194  myTagProperties[currentTag] = GNETagProperties(currentTag,
4198  // from edge
4199  attrProperty = GNEAttributeProperties(SUMO_ATTR_FROM,
4201  "The name of the edge the " + toString(currentTag) + " starts at");
4202  myTagProperties[currentTag].addAttribute(attrProperty);
4203  // to busStop
4206  "Id of the destination " + toString(SUMO_TAG_BUS_STOP));
4207  myTagProperties[currentTag].addAttribute(attrProperty);
4208  // vTypes
4211  "List of possible vehicle types to take");
4212  myTagProperties[currentTag].addAttribute(attrProperty);
4213  // modes
4214  attrProperty = GNEAttributeProperties(SUMO_ATTR_MODES,
4216  "List of possible traffic modes. Walking is always possible regardless of this value");
4217  myTagProperties[currentTag].addAttribute(attrProperty);
4218  }
4219  currentTag = GNE_TAG_PERSONTRIP_JUNCTIONS;
4220  {
4221  // set values of tag
4222  myTagProperties[currentTag] = GNETagProperties(currentTag,
4226  // from edge
4229  "The name of the junction the " + toString(currentTag) + " starts at");
4230  myTagProperties[currentTag].addAttribute(attrProperty);
4231  // to edge
4234  "The name of the junction the " + toString(currentTag) + " ends at");
4235  myTagProperties[currentTag].addAttribute(attrProperty);
4236  // vTypes
4239  "List of possible vehicle types to take");
4240  myTagProperties[currentTag].addAttribute(attrProperty);
4241  // modes
4242  attrProperty = GNEAttributeProperties(SUMO_ATTR_MODES,
4244  "List of possible traffic modes. Walking is always possible regardless of this value");
4245  myTagProperties[currentTag].addAttribute(attrProperty);
4246  }
4247 }
4248 
4249 
4250 void
4252  // declare empty GNEAttributeProperties
4253  GNEAttributeProperties attrProperty;
4254  // fill walks
4255  SumoXMLTag currentTag = GNE_TAG_WALK_EDGE;
4256  {
4257  // set values of tag
4258  myTagProperties[currentTag] = GNETagProperties(currentTag,
4261  GUIIcon::WALK_FROMTO, SUMO_TAG_WALK, { SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW }, FXRGBA(240, 255, 205, 255));
4262  // from edge
4263  attrProperty = GNEAttributeProperties(SUMO_ATTR_FROM,
4265  "The name of the edge the " + toString(currentTag) + " starts at");
4266  myTagProperties[currentTag].addAttribute(attrProperty);
4267  // to edge
4268  attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
4270  "The name of the edge the " + toString(currentTag) + " ends at");
4271  myTagProperties[currentTag].addAttribute(attrProperty);
4272  // arrival position
4275  "arrival position on the destination edge",
4276  "-1");
4277  myTagProperties[currentTag].addAttribute(attrProperty);
4278  }
4279  currentTag = GNE_TAG_WALK_BUSSTOP;
4280  {
4281  // set values of tag
4282  myTagProperties[currentTag] = GNETagProperties(currentTag,
4285  GUIIcon::WALK_BUSSTOP, SUMO_TAG_WALK, { SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW }, FXRGBA(240, 255, 205, 255));
4286  // from edge
4287  attrProperty = GNEAttributeProperties(SUMO_ATTR_FROM,
4289  "The name of the edge the " + toString(currentTag) + " starts at");
4290  myTagProperties[currentTag].addAttribute(attrProperty);
4291  // to busStop
4294  "Id of the destination " + toString(SUMO_TAG_BUS_STOP));
4295  myTagProperties[currentTag].addAttribute(attrProperty);
4296  }
4297  currentTag = GNE_TAG_WALK_EDGES;
4298  {
4299  // set values of tag
4300  myTagProperties[currentTag] = GNETagProperties(currentTag,
4303  GUIIcon::WALK_EDGES, SUMO_TAG_WALK, {SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW}, FXRGBA(240, 255, 205, 255));
4304  // edges
4305  attrProperty = GNEAttributeProperties(SUMO_ATTR_EDGES,
4307  "id of the edges to walk");
4308  myTagProperties[currentTag].addAttribute(attrProperty);
4309  // arrival pos
4312  "Arrival position on the destination edge",
4313  "-1");
4314  myTagProperties[currentTag].addAttribute(attrProperty);
4315  }
4316  currentTag = GNE_TAG_WALK_ROUTE;
4317  {
4318  // set values of tag
4319  myTagProperties[currentTag] = GNETagProperties(currentTag,
4322  GUIIcon::WALK_ROUTE, SUMO_TAG_WALK, {SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW}, FXRGBA(240, 255, 205, 255));
4323  // route
4324  attrProperty = GNEAttributeProperties(SUMO_ATTR_ROUTE,
4326  "The id of the route to walk");
4327  myTagProperties[currentTag].addAttribute(attrProperty);
4328  // arrival pos
4331  "Arrival position on the destination edge",
4332  "-1");
4333  myTagProperties[currentTag].addAttribute(attrProperty);
4334  }
4335 
4336  currentTag = GNE_TAG_WALK_JUNCTIONS;
4337  {
4338  // set values of tag
4339  myTagProperties[currentTag] = GNETagProperties(currentTag,
4342  GUIIcon::WALK_JUNCTIONS, SUMO_TAG_WALK, { SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW }, FXRGBA(240, 255, 205, 255));
4343  // from edge
4346  "The name of the junction the " + toString(currentTag) + " starts at");
4347  myTagProperties[currentTag].addAttribute(attrProperty);
4348  // to edge
4351  "The name of the junction the " + toString(currentTag) + " ends at");
4352  myTagProperties[currentTag].addAttribute(attrProperty);
4353  }
4354 }
4355 
4356 
4357 void
4359  // declare empty GNEAttributeProperties
4360  GNEAttributeProperties attrProperty;
4361  // fill rides
4362  SumoXMLTag currentTag = GNE_TAG_RIDE_EDGE;
4363  {
4364  // set values of tag
4365  myTagProperties[currentTag] = GNETagProperties(currentTag,
4368  GUIIcon::RIDE_BUSSTOP, SUMO_TAG_RIDE, { SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW }, FXRGBA(210, 233, 255, 255));
4369  // from edge
4370  attrProperty = GNEAttributeProperties(SUMO_ATTR_FROM,
4372  "The name of the edge the " + toString(currentTag) + " starts at");
4373  myTagProperties[currentTag].addAttribute(attrProperty);
4374  // to edge
4375  attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
4377  "The name of the edge the " + toString(currentTag) + " ends at");
4378  myTagProperties[currentTag].addAttribute(attrProperty);
4379  // arrival position
4382  "arrival position on the destination edge",
4383  "-1");
4384  myTagProperties[currentTag].addAttribute(attrProperty);
4385  // lines
4386  attrProperty = GNEAttributeProperties(SUMO_ATTR_LINES,
4388  "list of vehicle alternatives to take for the " + toString(currentTag),
4389  "ANY");
4390  myTagProperties[currentTag].addAttribute(attrProperty);
4391  }
4392  currentTag = GNE_TAG_RIDE_BUSSTOP;
4393  {
4394  // set values of tag
4395  myTagProperties[currentTag] = GNETagProperties(currentTag,
4398  GUIIcon::RIDE_BUSSTOP, SUMO_TAG_RIDE, { SUMO_TAG_PERSON, SUMO_TAG_PERSONFLOW }, FXRGBA(210, 233, 255, 255));
4399  // from edge
4400  attrProperty = GNEAttributeProperties(SUMO_ATTR_FROM,
4402  "The name of the edge the " + toString(currentTag) + " starts at");
4403  myTagProperties[currentTag].addAttribute(attrProperty);
4404  // to busStop
4407  "Id of the destination " + toString(SUMO_TAG_BUS_STOP));
4408  myTagProperties[currentTag].addAttribute(attrProperty);
4409  // lines
4410  attrProperty = GNEAttributeProperties(SUMO_ATTR_LINES,
4412  "list of vehicle alternatives to take for the " + toString(currentTag),
4413  "ANY");
4414  myTagProperties[currentTag].addAttribute(attrProperty);
4415  }
4416 }
4417 
4418 
4419 void
4421  // declare empty GNEAttributeProperties
4422  GNEAttributeProperties attrProperty;
4423  // fill vehicle ACs
4424  SumoXMLTag currentTag = GNE_TAG_STOPPERSON_EDGE;
4425  {
4426  // set values of tag
4427  myTagProperties[currentTag] = GNETagProperties(currentTag,
4431 
4432  // set values of attributes
4433  attrProperty = GNEAttributeProperties(SUMO_ATTR_EDGE,
4435  "The name of the edge the stop shall be located at");
4436  myTagProperties[currentTag].addAttribute(attrProperty);
4437 
4440  "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
4441  myTagProperties[currentTag].addAttribute(attrProperty);
4442 
4445  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
4446  "0");
4447  myTagProperties[currentTag].addAttribute(attrProperty);
4448 
4451  "Minimum duration for stopping",
4452  "60");
4453  attrProperty.setDefaultActivated(true);
4454  myTagProperties[currentTag].addAttribute(attrProperty);
4455 
4456  attrProperty = GNEAttributeProperties(SUMO_ATTR_UNTIL,
4458  "The time step at which the route continues",
4459  "0.00");
4460  myTagProperties[currentTag].addAttribute(attrProperty);
4461 
4464  "Activity displayed for stopped person in GUI and output files ",
4465  "waiting");
4466  myTagProperties[currentTag].addAttribute(attrProperty);
4467  }
4468  currentTag = GNE_TAG_STOPPERSON_BUSSTOP;
4469  {
4470  // set values of tag
4471  myTagProperties[currentTag] = GNETagProperties(currentTag,
4475 
4476  // set values of attributes
4479  "BusStop associated with this stop");
4480  myTagProperties[currentTag].addAttribute(attrProperty);
4481 
4484  "Minimum duration for stopping",
4485  "60");
4486  attrProperty.setDefaultActivated(true);
4487  myTagProperties[currentTag].addAttribute(attrProperty);
4488 
4489  attrProperty = GNEAttributeProperties(SUMO_ATTR_UNTIL,
4491  "The time step at which the route continues",
4492  "0.00");
4493  myTagProperties[currentTag].addAttribute(attrProperty);
4494 
4497  "Activity displayed for stopped person in GUI and output files ",
4498  "waiting");
4499  myTagProperties[currentTag].addAttribute(attrProperty);
4500  }
4501 }
4502 
4503 
4504 void
4506  // declare empty GNEAttributeProperties
4507  GNEAttributeProperties attrProperty;
4508  attrProperty = GNEAttributeProperties(SUMO_ATTR_COLOR,
4510  "This " + toString(currentTag) + "'s color",
4511  "yellow");
4512  myTagProperties[currentTag].addAttribute(attrProperty);
4513 
4516  "The lane on which the " + toString(currentTag) + " shall be inserted",
4517  "first");
4518  myTagProperties[currentTag].addAttribute(attrProperty);
4519 
4521  GNEAttributeProperties::STRING | GNEAttributeProperties::DEFAULTVALUE | GNEAttributeProperties::UPDATEGEOMETRY /* GNEAttributeProperties::MULTIDISCRETE (Currently disabled) */,
4522  "The position at which the " + toString(currentTag) + " shall enter the net",
4523  "base");
4524  myTagProperties[currentTag].addAttribute(attrProperty);
4525 
4527  GNEAttributeProperties::STRING | GNEAttributeProperties::DEFAULTVALUE /* GNEAttributeProperties::MULTIDISCRETE (Currently disabled) */,
4528  "The speed with which the " + toString(currentTag) + " shall enter the network",
4529  "0.00");
4530  myTagProperties[currentTag].addAttribute(attrProperty);
4531 
4533  GNEAttributeProperties::STRING | GNEAttributeProperties::DEFAULTVALUE | GNEAttributeProperties::UPDATEGEOMETRY /* GNEAttributeProperties::MULTIDISCRETE (Currently disabled) */,
4534  "The lane at which the " + toString(currentTag) + " shall leave the network",
4535  "current");
4536  myTagProperties[currentTag].addAttribute(attrProperty);
4537 
4539  GNEAttributeProperties::STRING | GNEAttributeProperties::DEFAULTVALUE | GNEAttributeProperties::UPDATEGEOMETRY /* GNEAttributeProperties::MULTIDISCRETE (Currently disabled) */,
4540  "The position at which the " + toString(currentTag) + " shall leave the network",
4541  "max");
4542  myTagProperties[currentTag].addAttribute(attrProperty);
4543 
4545  GNEAttributeProperties::STRING | GNEAttributeProperties::DEFAULTVALUE /* GNEAttributeProperties::MULTIDISCRETE (Currently disabled) */,
4546  "The speed with which the " + toString(currentTag) + " shall leave the network",
4547  "current");
4548  myTagProperties[currentTag].addAttribute(attrProperty);
4549 
4550  attrProperty = GNEAttributeProperties(SUMO_ATTR_LINE,
4552  "A string specifying the id of a public transport line which can be used when specifying person rides");
4553  myTagProperties[currentTag].addAttribute(attrProperty);
4554 
4557  "The number of occupied seats when the " + toString(currentTag) + " is inserted",
4558  "0");
4559  myTagProperties[currentTag].addAttribute(attrProperty);
4560 
4563  "The number of occupied container places when the " + toString(currentTag) + " is inserted",
4564  "0");
4565  myTagProperties[currentTag].addAttribute(attrProperty);
4566 
4569  "The lateral position on the departure lane at which the " + toString(currentTag) + " shall enter the net",
4570  "center");
4571  myTagProperties[currentTag].addAttribute(attrProperty);
4572 
4575  "The lateral position on the arrival lane at which the " + toString(currentTag) + " shall arrive",
4576  "center");
4577  myTagProperties[currentTag].addAttribute(attrProperty);
4578 }
4579 
4580 
4581 void
4583  // declare empty GNEAttributeProperties
4584  GNEAttributeProperties attrProperty;
4585 
4586  attrProperty = GNEAttributeProperties(SUMO_ATTR_BEGIN,
4588  "First " + toString(currentTag) + " departure time",
4589  "0");
4590  myTagProperties[currentTag].addAttribute(attrProperty);
4591 
4592  attrProperty = GNEAttributeProperties(SUMO_ATTR_END,
4594  "End of departure interval",
4595  "3600");
4596  myTagProperties[currentTag].addAttribute(attrProperty);
4597 
4600  "probability for emitting a " + toString(currentTag) + " each second (not together with vehsPerHour or period)",
4601  "1800");
4602  myTagProperties[currentTag].addAttribute(attrProperty);
4603 
4604  attrProperty = GNEAttributeProperties(perHour,
4606  "Number of " + toString(currentTag) + "s per hour, equally spaced (not together with period or probability)",
4607  "1800");
4608  myTagProperties[currentTag].addAttribute(attrProperty);
4609 
4612  "Insert equally spaced " + toString(currentTag) + "s at that period (not together with vehsPerHour or probability)",
4613  "2");
4614  myTagProperties[currentTag].addAttribute(attrProperty);
4615 
4616  attrProperty = GNEAttributeProperties(SUMO_ATTR_PROB,
4618  "probability for emitting a " + toString(currentTag) + " each second (not together with vehsPerHour or period)",
4619  "0.5");
4620  myTagProperties[currentTag].addAttribute(attrProperty);
4621 }
4622 
4623 
4624 void
4626  // declare empty GNEAttributeProperties
4627  GNEAttributeProperties attrProperty;
4628 
4629  attrProperty = GNEAttributeProperties(SUMO_ATTR_ACCEL,
4631  "The acceleration ability of vehicles of this type [m/s^2]",
4632  "2.60");
4633  myTagProperties[currentTag].addAttribute(attrProperty);
4634 
4635  attrProperty = GNEAttributeProperties(SUMO_ATTR_DECEL,
4637  "The deceleration ability of vehicles of this type [m/s^2]",
4638  "4.50");
4639  myTagProperties[currentTag].addAttribute(attrProperty);
4640 
4643  "The apparent deceleration of the vehicle as used by the standard model [m/s^2]",
4644  "4.50");
4645  myTagProperties[currentTag].addAttribute(attrProperty);
4646 
4649  "The maximal physically possible deceleration for the vehicle [m/s^2]",
4650  "4.50");
4651  myTagProperties[currentTag].addAttribute(attrProperty);
4652 
4653  attrProperty = GNEAttributeProperties(SUMO_ATTR_SIGMA,
4655  "Car-following model parameter",
4656  "0.50");
4657  attrProperty.setRange(0, 1);
4658  myTagProperties[currentTag].addAttribute(attrProperty);
4659 
4660  attrProperty = GNEAttributeProperties(SUMO_ATTR_TAU,
4662  "Car-following model parameter",
4663  "1.00");
4664  myTagProperties[currentTag].addAttribute(attrProperty);
4665 
4666  attrProperty = GNEAttributeProperties(SUMO_ATTR_TMP1,
4668  "SKRAUSSX parameter 1",
4669  "");
4670  myTagProperties[currentTag].addAttribute(attrProperty);
4671 
4672  attrProperty = GNEAttributeProperties(SUMO_ATTR_TMP2,
4674  "SKRAUSSX parameter 2",
4675  "");
4676  myTagProperties[currentTag].addAttribute(attrProperty);
4677 
4678  attrProperty = GNEAttributeProperties(SUMO_ATTR_TMP3,
4680  "SKRAUSSX parameter 3",
4681  "");
4682  myTagProperties[currentTag].addAttribute(attrProperty);
4683 
4684  attrProperty = GNEAttributeProperties(SUMO_ATTR_TMP4,
4686  "SKRAUSSX parameter 4",
4687  "");
4688  myTagProperties[currentTag].addAttribute(attrProperty);
4689 
4690  attrProperty = GNEAttributeProperties(SUMO_ATTR_TMP5,
4692  "SKRAUSSX parameter 5",
4693  "");
4694  myTagProperties[currentTag].addAttribute(attrProperty);
4695 
4698  "EIDM Look ahead / preview parameter [s]",
4699  "4.00");
4700  myTagProperties[currentTag].addAttribute(attrProperty);
4701 
4704  "EIDM AP Reaction Time parameter [s]",
4705  "0.50");
4706  myTagProperties[currentTag].addAttribute(attrProperty);
4707 
4710  "EIDM Wiener Process parameter for the Driving Error [s]",
4711  "3.00");
4712  myTagProperties[currentTag].addAttribute(attrProperty);
4713 
4716  "EIDM Wiener Process parameter for the Estimation Error [s]",
4717  "10.00");
4718  myTagProperties[currentTag].addAttribute(attrProperty);
4719 
4722  "EIDM Coolness parameter of the Enhanced IDM [-]",
4723  "0.99");
4724  attrProperty.setRange(0, 1);
4725  myTagProperties[currentTag].addAttribute(attrProperty);
4726 
4729  "EIDM leader speed estimation error parameter [-]",
4730  "0.02");
4731  myTagProperties[currentTag].addAttribute(attrProperty);
4732 
4735  "EIDM gap estimation error parameter [-]",
4736  "0.10");
4737  myTagProperties[currentTag].addAttribute(attrProperty);
4738 
4741  "EIDM driving error parameter [-]",
4742  "0.10");
4743  myTagProperties[currentTag].addAttribute(attrProperty);
4744 
4747  "EIDM maximal jerk parameter [m/s^3]",
4748  "3.00");
4749  myTagProperties[currentTag].addAttribute(attrProperty);
4750 
4753  "EIDM maximal negative acceleration between two Action Points (threshold) [m/s^2]",
4754  "1.00");
4755  myTagProperties[currentTag].addAttribute(attrProperty);
4756 
4759  "EIDM Time parameter untill vehicle reaches amax after startup/driveoff [s]",
4760  "1.20");
4761  myTagProperties[currentTag].addAttribute(attrProperty);
4762 
4765  "EIDM Flatness parameter of startup/driveoff curve [-]",
4766  "2.00");
4767  myTagProperties[currentTag].addAttribute(attrProperty);
4768 
4771  "EIDM Shift parameter of startup/driveoff curve [-]",
4772  "0.70");
4773  myTagProperties[currentTag].addAttribute(attrProperty);
4774 
4777  "EIDM parameter if model shall include vehicle dynamics into the acceleration calculation [0/1]",
4778  "0");
4779  myTagProperties[currentTag].addAttribute(attrProperty);
4780 
4783  "EIDM parameter how many vehicles are taken into the preview calculation of the driver (at least always 1!) [-]",
4784  "0");
4785  myTagProperties[currentTag].addAttribute(attrProperty);
4786 
4789  "Peter Wagner 2009 parameter",
4790  "");
4791  myTagProperties[currentTag].addAttribute(attrProperty);
4792 
4795  "Peter Wagner 2009 parameter",
4796  "");
4797  myTagProperties[currentTag].addAttribute(attrProperty);
4798 
4801  "IDMM parameter",
4802  "");
4803  myTagProperties[currentTag].addAttribute(attrProperty);
4804 
4807  "IDMM parameter",
4808  "");
4809  myTagProperties[currentTag].addAttribute(attrProperty);
4810 
4813  "Wiedemann parameter",
4814  "");
4815  myTagProperties[currentTag].addAttribute(attrProperty);
4816 
4819  "Wiedemann parameter",
4820  "");
4821  myTagProperties[currentTag].addAttribute(attrProperty);
4822 
4825  "MinGap factor parameter",
4826  "");
4827  myTagProperties[currentTag].addAttribute(attrProperty);
4828 
4829  attrProperty = GNEAttributeProperties(SUMO_ATTR_K,
4831  "K parameter",
4832  "");
4833  myTagProperties[currentTag].addAttribute(attrProperty);
4834 
4835 
4838  "Kerner Phi parameter",
4839  "");
4840  myTagProperties[currentTag].addAttribute(attrProperty);
4841 
4844  "IDM Delta parameter",
4845  "");
4846  myTagProperties[currentTag].addAttribute(attrProperty);
4847 
4850  "IDM Stepping parameter",
4851  "");
4852  myTagProperties[currentTag].addAttribute(attrProperty);
4853 
4856  "Train Types",
4857  "NGT400");
4858  attrProperty.setDiscreteValues(SUMOXMLDefinitions::TrainTypes.getStrings());
4859  myTagProperties[currentTag].addAttribute(attrProperty);
4860 }
4861 
4862 
4863 void
4865  // declare empty GNEAttributeProperties
4866  GNEAttributeProperties attrProperty;
4869  "Minimum distance to pedestrians that are walking towards the conflict point with the ego vehicle.",
4870  "10");
4871  myTagProperties[currentTag].addAttribute(attrProperty);
4872 
4875  "The accumulated waiting time after which a vehicle will drive onto an intersection even though this might cause jamming.",
4876  "-1");
4877  myTagProperties[currentTag].addAttribute(attrProperty);
4878 
4881  "This value causes vehicles to violate a yellow light if the duration of the yellow phase is lower than the given threshold.",
4882  "-1");
4883  myTagProperties[currentTag].addAttribute(attrProperty);
4884 
4887  "This value causes vehicles to violate a red light if the duration of the red phase is lower than the given threshold.",
4888  "-1");
4889  myTagProperties[currentTag].addAttribute(attrProperty);
4890 
4893  "This value causes vehicles affected by jmDriveAfterRedTime to slow down when violating a red light.",
4894  "0.0");
4895  myTagProperties[currentTag].addAttribute(attrProperty);
4896 
4899  "This value causes vehicles to ignore foe vehicles that have right-of-way with the given probability.",
4900  "0.0");
4901  myTagProperties[currentTag].addAttribute(attrProperty);
4902 
4905  "This value is used in conjunction with jmIgnoreFoeProb. Only vehicles with a speed below or equal to the given value may be ignored.",
4906  "0.0");
4907  myTagProperties[currentTag].addAttribute(attrProperty);
4908 
4911  "This value configures driving imperfection (dawdling) while passing a minor link.",
4912  "0.0");
4913  myTagProperties[currentTag].addAttribute(attrProperty);
4914 
4917  "This value defines the minimum time gap when passing ahead of a prioritized vehicle. ",
4918  "1");
4919  myTagProperties[currentTag].addAttribute(attrProperty);
4920 
4923  "Willingess of drivers to impede vehicles with higher priority",
4924  "0.0");
4925  myTagProperties[currentTag].addAttribute(attrProperty);
4926 }
4927 
4928 
4929 void
4931  // declare empty GNEAttributeProperties
4932  GNEAttributeProperties attrProperty;
4933 
4936  "The eagerness for performing strategic lane changing. Higher values result in earlier lane-changing.",
4937  "1.0");
4938  myTagProperties[currentTag].addAttribute(attrProperty);
4939 
4942  "The willingness for performing cooperative lane changing. Lower values result in reduced cooperation.",
4943  "1.0");
4944  myTagProperties[currentTag].addAttribute(attrProperty);
4945 
4948  "The eagerness for performing lane changing to gain speed. Higher values result in more lane-changing.",
4949  "1.0");
4950  myTagProperties[currentTag].addAttribute(attrProperty);
4951 
4954  "The eagerness for following the obligation to keep right. Higher values result in earlier lane-changing.",
4955  "1.0");
4956  myTagProperties[currentTag].addAttribute(attrProperty);
4957 
4960  "The eagerness for using the configured lateral alignment within the lane. Higher values result in increased willingness to sacrifice speed for alignment.",
4961  "1.0");
4962  myTagProperties[currentTag].addAttribute(attrProperty);
4963 
4966  "The eagerness for overtaking through the opposite-direction lane. Higher values result in more lane-changing.",
4967  "1.0");
4968  myTagProperties[currentTag].addAttribute(attrProperty);
4969 
4972  "Willingness to encroach laterally on other drivers.",
4973  "0.00");
4974  myTagProperties[currentTag].addAttribute(attrProperty);
4975 
4978  "Minimum lateral gap when encroaching laterally on other drives (alternative way to define lcPushy)",
4979  "0.00");
4980  myTagProperties[currentTag].addAttribute(attrProperty);
4981 
4984  "Willingness to accept lower front and rear gaps on the target lane.",
4985  "1.0");
4986  myTagProperties[currentTag].addAttribute(attrProperty);
4987 
4990  "Dynamic factor for modifying lcAssertive and lcPushy.",
4991  "0.00");
4992  myTagProperties[currentTag].addAttribute(attrProperty);
4993 
4996  "Time to reach maximum impatience (of 1). Impatience grows whenever a lane-change manoeuvre is blocked.",
4997  "infinity");
4998  myTagProperties[currentTag].addAttribute(attrProperty);
4999 
5002  "Maximum lateral acceleration per second.",
5003  "1.0");
5004  myTagProperties[currentTag].addAttribute(attrProperty);
5005 
5008  "Factor for configuring the strategic lookahead distance when a change to the left is necessary (relative to right lookahead).",
5009  "2.0");
5010  myTagProperties[currentTag].addAttribute(attrProperty);
5011 
5014  "Factor for configuring the treshold asymmetry when changing to the left or to the right for speed gain.",
5015  "0.1");
5016  myTagProperties[currentTag].addAttribute(attrProperty);
5017 
5020  "Upper bound on lateral speed when standing.",
5021  "0.00");
5022  myTagProperties[currentTag].addAttribute(attrProperty);
5023 
5026  "Upper bound on lateral speed while moving computed as lcMaxSpeedLatStanding + lcMaxSpeedLatFactor * getSpeed()",
5027  "1.00");
5028  myTagProperties[currentTag].addAttribute(attrProperty);
5029 
5032  "Distance to an upcoming turn on the vehicles route, below which the alignment should be dynamically adapted to match the turn direction.",
5033  "0.00");
5034  myTagProperties[currentTag].addAttribute(attrProperty);
5035 
5038  "The probability for violating rules gainst overtaking on the right.",
5039  "0.00");
5040  myTagProperties[currentTag].addAttribute(attrProperty);
5041 
5042  /*
5043  attrProperty = GNEAttributeProperties(SUMO_ATTR_LCA_EXPERIMENTAL1,
5044  GNEAttributeProperties::FLOAT | GNEAttributeProperties::POSITIVE | GNEAttributeProperties::DEFAULTVALUE | GNEAttributeProperties::EXTENDED,
5045  "XXXXX",
5046  "0.00");
5047  myTagProperties[currentTag].addAttribute(attrProperty);
5048  */
5049 }
5050 
5051 
5052 void
5054  // declare empty GNEAttributeProperties
5055  GNEAttributeProperties attrProperty;
5056 
5057  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
5059  "The name of the " + toString(currentTag));
5060  myTagProperties[currentTag].addAttribute(attrProperty);
5061 
5062  attrProperty = GNEAttributeProperties(SUMO_ATTR_TYPE,
5064  "The id of the " + toString(currentTag) + " type to use for this " + toString(currentTag) +
5066  myTagProperties[currentTag].addAttribute(attrProperty);
5067 
5068  attrProperty = GNEAttributeProperties(SUMO_ATTR_COLOR,
5070  "This " + toString(currentTag) + "'s color",
5071  "yellow");
5072  myTagProperties[currentTag].addAttribute(attrProperty);
5073 
5076  "The position at which the " + toString(currentTag) + " shall enter the net",
5077  "base");
5078  myTagProperties[currentTag].addAttribute(attrProperty);
5079 }
5080 
5081 
5082 void
5084  // declare empty GNEAttributeProperties
5085  GNEAttributeProperties attrProperty;
5086 
5087  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
5089  "The name of the " + toString(currentTag));
5090  myTagProperties[currentTag].addAttribute(attrProperty);
5091 
5094  "The time step at which the " + toString(currentTag) + " shall enter the network",
5095  "0.00");
5096  myTagProperties[currentTag].addAttribute(attrProperty);
5097 }
5098 
5099 
5100 void
5102  // declare empty GNEAttributeProperties
5103  GNEAttributeProperties attrProperty;
5104 
5107  "Minimum duration for stopping",
5108  "60");
5109  attrProperty.setDefaultActivated(true);
5110  myTagProperties[currentTag].addAttribute(attrProperty);
5111 
5112  attrProperty = GNEAttributeProperties(SUMO_ATTR_UNTIL,
5114  "The time step at which the route continues",
5115  "0.00");
5116  myTagProperties[currentTag].addAttribute(attrProperty);
5117 
5120  "If set to a non-negative time value, then the stop duration can be extended at most by the extension value in seconds",
5121  "0");
5122  myTagProperties[currentTag].addAttribute(attrProperty);
5123 
5126  "Whether a person or container or bth may end the stop",
5127  "false");
5128  attrProperty.setDiscreteValues({"false", "person", "container", "join"});
5129  myTagProperties[currentTag].addAttribute(attrProperty);
5130 
5133  "List of persons that must board the vehicle before it may continue");
5134  myTagProperties[currentTag].addAttribute(attrProperty);
5135 
5138  "whether the vehicle stops on the road or beside ",
5139  "false");
5140  myTagProperties[currentTag].addAttribute(attrProperty);
5141 
5144  "Activity displayed for stopped person in GUI and output files ",
5145  "waiting");
5146  myTagProperties[currentTag].addAttribute(attrProperty);
5147 
5148  /*
5149  Attribute currently disabled. It will be implemented in #6011
5150  attrProperty = GNEAttributeProperties(SUMO_ATTR_TRIP_ID,
5151  GNEAttributeProperties::STRING | GNEAttributeProperties::DEFAULTVALUE,
5152  "Value used for trips that uses this stop");
5153  myTagProperties[currentTag].addAttribute(attrProperty);
5154  */
5155 }
5156 
5157 
5158 void
5160  // declare empty GNEAttributeProperties
5161  GNEAttributeProperties attrProperty;
5162  // fill data set element
5163  SumoXMLTag currentTag = SUMO_TAG_DATASET;
5164  {
5165  // set values of tag
5166  myTagProperties[currentTag] = GNETagProperties(currentTag,
5169  GUIIcon::DATASET, currentTag);
5170 
5171  // set values of attributes
5172  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
5174  "Data set ID");
5175  myTagProperties[currentTag].addAttribute(attrProperty);
5176 
5177  }
5178  // fill data interval element
5179  currentTag = SUMO_TAG_DATAINTERVAL;
5180  {
5181  // set values of tag
5182  myTagProperties[currentTag] = GNETagProperties(currentTag,
5185  GUIIcon::DATAINTERVAL, currentTag, {SUMO_TAG_DATASET});
5186 
5187  // set values of attributes
5188  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
5190  "Interval ID");
5191  myTagProperties[currentTag].addAttribute(attrProperty);
5192 
5193  // set values of attributes
5194  attrProperty = GNEAttributeProperties(SUMO_ATTR_BEGIN,
5196  "First " + toString(currentTag) + " departure time",
5197  "0");
5198  myTagProperties[currentTag].addAttribute(attrProperty);
5199 
5200  attrProperty = GNEAttributeProperties(SUMO_ATTR_END,
5202  "End of departure interval",
5203  "3600");
5204  myTagProperties[currentTag].addAttribute(attrProperty);
5205  }
5206  // fill edge data element
5207  currentTag = SUMO_TAG_MEANDATA_EDGE;
5208  {
5209  // set values of tag
5210  myTagProperties[currentTag] = GNETagProperties(currentTag,
5213  GUIIcon::EDGEDATA, currentTag, {SUMO_TAG_DATAINTERVAL});
5214 
5215  // set values of attributes
5216  attrProperty = GNEAttributeProperties(SUMO_ATTR_ID,
5218  "edge ID");
5219  myTagProperties[currentTag].addAttribute(attrProperty);
5220  }
5221  currentTag = SUMO_TAG_EDGEREL;
5222  {
5223  // set values of tag
5224  myTagProperties[currentTag] = GNETagProperties(currentTag,
5228 
5229  // set values of attributes
5230  attrProperty = GNEAttributeProperties(SUMO_ATTR_FROM,
5232  "The name of the edge the " + toString(currentTag) + " starts at");
5233  myTagProperties[currentTag].addAttribute(attrProperty);
5234 
5235  attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
5237  "The name of the edge the " + toString(currentTag) + " ends at");
5238  myTagProperties[currentTag].addAttribute(attrProperty);
5239  }
5240  currentTag = SUMO_TAG_TAZREL;
5241  {
5242  // set values of tag
5243  myTagProperties[currentTag] = GNETagProperties(currentTag,
5247 
5248  // set values of attributes
5249  attrProperty = GNEAttributeProperties(SUMO_ATTR_FROM,
5251  "The name of the TAZ the " + toString(currentTag) + " starts at");
5252  myTagProperties[currentTag].addAttribute(attrProperty);
5253 
5254  attrProperty = GNEAttributeProperties(SUMO_ATTR_TO,
5256  "The name of the TAZ the " + toString(currentTag) + " ends at");
5257  myTagProperties[currentTag].addAttribute(attrProperty);
5258  }
5259 }
5260 
5261 /****************************************************************************/
GUISelectedStorage gSelected
A global holder of selected objects.
@ PARKINGSPACE
@ PERSONTRIP_JUNCTIONS
@ CONTAINERFLOW
@ PERSONTRIP_BUSSTOP
@ CLOSINGREROUTE
@ CONTAINERSTOP
@ TRANSPORT_CONTAINERSTOP
@ TRANSHIP_EDGES
@ WALK_JUNCTIONS
@ TRIP_JUNCTIONS
@ DATAINTERVAL
@ FLOW_JUNCTIONS
@ ROUTEPROBREROUTE
@ CHARGINGSTATION
@ WALK_BUSSTOP
@ TRANSHIP_CONTAINERSTOP
@ PARKINGZONEREROUTE
@ CLOSINGLANEREROUTE
@ RIDE_BUSSTOP
@ DESTPROBREROUTE
@ PERSONTRIP_FROMTO
@ REROUTERINTERVAL
@ VTYPEDISTRIBUTION
@ VARIABLESPEEDSIGN
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition: SUMOTime.cpp:45
long long int SUMOTime
Definition: SUMOTime.h:32
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_IGNORING
vehicles ignoring classes
const double DEFAULT_VEH_PROB
SUMOVehicleShape
Definition of vehicle classes to differ between different appearences.
@ UNKNOWN
not defined
const std::string DEFAULT_VTYPE_ID
SumoXMLTag
Numbers representing SUMO-XML - element names.
@ GNE_TAG_TRIP_JUNCTIONS
a trip between junctions (used in NETEDIT)
@ 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
@ SUMO_TAG_DATAINTERVAL
@ SUMO_TAG_ROUTEPROBE
a routeprobe detector
@ GNE_TAG_TRANSPORT_CONTAINERSTOP
@ SUMO_TAG_TAZ
a traffic assignment zone
@ SUMO_TAG_E2DETECTOR
an e2 detector
@ 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_STOPCONTAINER_EDGE
@ SUMO_TAG_BUS_STOP
A bus stop.
@ SUMO_TAG_POI
begin/end of the description of a Point of interest
@ GNE_TAG_FLOW_CALIBRATOR
a flow definition within in Calibrator
@ SUMO_TAG_LANECALIBRATOR
A calibrator placed over lane (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)
@ 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_ROUTE_PROB_REROUTE
probability of route of a reroute
@ SUMO_TAG_DET_ENTRY
an e3 entry point
@ GNE_TAG_E2DETECTOR_MULTILANE
an e2 detector over multiple lanes (placed here due create Additional Frame)
@ 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_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)
@ SUMO_TAG_DEST_PROB_REROUTE
probability of destiny of a reroute
@ GNE_TAG_POILANE
Point of interest over Lane.
@ SUMO_TAG_DATASET
@ SUMO_TAG_E1DETECTOR
an e1 detector
@ 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
@ 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)
@ GNE_TAG_RIDE_BUSSTOP
@ SUMO_TAG_CALIBRATOR
A calibrator placed over edge.
@ SUMO_TAG_E3DETECTOR
an 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_CONT
@ 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_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_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
@ 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_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_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_JM_IGNORE_FOE_PROB
@ GNE_ATTR_TO_BUSSTOP
to busStop (used by personPlans)
@ SUMO_ATTR_TLTYPE
node: the type of traffic light
@ SUMO_ATTR_CHARGEINTRANSIT
Allow/disallow charge in transit in Charging Stations.
@ 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_FREQUENCY
@ SUMO_ATTR_CENTER
@ SUMO_ATTR_PASS
@ SUMO_ATTR_DEPARTSPEED
@ SUMO_ATTR_ANGLE
@ SUMO_ATTR_ENDOFFSET
@ SUMO_ATTR_MINGAP_LAT
@ GNE_ATTR_SHAPE_END
last coordinate of edge shape
@ SUMO_ATTR_EMERGENCYDECEL
@ SUMO_ATTR_TO
@ SUMO_ATTR_FROM
@ SUMO_ATTR_HEIGHT
@ SUMO_ATTR_END
weights: time range end
@ 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_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_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_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_CF_WIEDEMANN_ESTIMATION
@ SUMO_ATTR_RELATIVEPATH
@ SUMO_ATTR_PERSONSPERHOUR
@ SUMO_ATTR_LCA_SPEEDGAINRIGHT
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:269
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
bool isAttributeCarrierSelected() const
check if attribute carrier is selected
static void fillCommonStopAttributes(SumoXMLTag currentTag)
fill stop person attributes
GNEAttributeCarrier(const SumoXMLTag tag, GNENet *net)
Constructor.
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 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 fillAdditionals()
fill additional elements
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
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
void removeACParametersKeys(const std::vector< std::string > &keepKeys, GNEUndoList *undoList)
remove keys
const std::string & getTagStr() const
get tag assigned to this object in string format
virtual void toogleAttribute(SumoXMLAttr key, const bool value, const int previousParameters)=0
method for enable or disable the attribute and nothing else (used in GNEChange_EnableAttribute)
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
get GUIGlObject associated with this AttributeCarrier
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 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
FXIcon * getIcon() const
get FXIcon associated to this AC
virtual const std::map< std::string, std::string > & getACParametersMap() const =0
virtual bool isAttributeEnabled(SumoXMLAttr key) const =0
static bool lanesConsecutives(const std::vector< GNELane * > &lanes)
check if lanes are consecutives
void resetDefaultValues()
reset attribute carrier to their default values
static void fillPersonPlanWalks()
fill person plan walks
static void fillTAZElements()
fill TAZ elements
GNENet * myNet
pointer to net
static void fillCommonContainerAttributes(SumoXMLTag currentTag)
fill common container attributes (used by container and containerFlows)
static void fillCommonFlowAttributes(SumoXMLTag currentTag, SumoXMLAttr perHour)
fill common flow attributes (used by flows, routeFlows and personFlows)
static void fillJunctionModelAttributes(SumoXMLTag currentTag)
fill Junction Model Attributes of Vehicle/Person Types
static void fillShapes()
fill shape elements
GNENet * getNet() const
get pointer to net
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 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
bool isFlowDefinition() const
return true if atribute is part of a flow definition
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:125
GNEViewNet * getViewNet() const
get view net
Definition: GNENet.cpp:1964
bool isShape() const
return true if tag correspond to a shape
bool isTAZElement() const
return true if tag correspond to a TAZ element
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...
const GNEAttributeProperties & getAttributeProperties(SumoXMLAttr attr) const
get attribute (throw error if doesn't exist)
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
bool hasAttribute(SumoXMLAttr attr) const
check if current TagProperties owns the attribute "attr"
const GNEViewNetHelper::EditModes & getEditModes() const
get edit modes
Definition: GNEViewNet.cpp:513
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:364
static const double UNSPECIFIED_CONTPOS
unspecified internal junction position
Definition: NBEdge.h:358
static const double UNSPECIFIED_VISIBILITY_DISTANCE
unspecified foe visibility for connections
Definition: NBEdge.h:361
static const double UNSPECIFIED_SPEED
unspecified lane speed
Definition: NBEdge.h:355
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:58
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 RGBColor parseColor(std::string coldef)
Parses a color information.
Definition: RGBColor.cpp:236
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< 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:47
static const double DEFAULT_LAYER
Definition: Shape.h:42
static const double DEFAULT_LAYER_POI
Definition: Shape.h:44
static const double DEFAULT_IMG_WIDTH
Definition: Shape.h:48
static const std::string DEFAULT_IMG_FILE
Definition: Shape.h:46
static const double DEFAULT_ANGLE
Definition: Shape.h:45
static const double DEFAULT_IMG_HEIGHT
Definition: Shape.h:49
static const std::string DEFAULT_TYPE
Definition: Shape.h:41
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