Eclipse SUMO - Simulation of Urban MObility
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
GNEDemandElementFlow.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2025 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// An auxiliar, asbtract class for flow elements (vehicles, person and containers)
19/****************************************************************************/
20
21#include <netedit/GNETagProperties.h>
22#include <netedit/GNEUndoList.h>
23#include <netedit/changes/GNEChange_Attribute.h>
24#include <netedit/changes/GNEChange_ToggleAttribute.h>
25#include <utils/gui/div/GLHelper.h>
26
27#include "GNEDemandElementFlow.h"
28
29// ===========================================================================
30// member method definitions
31// ===========================================================================
32
33GNEDemandElementFlow::GNEDemandElementFlow(GNEDemandElement* flowElement) {
34 // set default flow attributes
35 setDefaultFlowAttributes(flowElement);
36}
37
38
39GNEDemandElementFlow::GNEDemandElementFlow(GNEDemandElement* flowElement, const SUMOVehicleParameter& vehicleParameters) :
40 SUMOVehicleParameter(vehicleParameters) {
41 // set default flow attributes
42 setDefaultFlowAttributes(flowElement);
43}
44
45
46GNEDemandElementFlow::~GNEDemandElementFlow() {}
47
48
49void
50GNEDemandElementFlow::drawFlowLabel(const Position& position, const double rotation, const double width,
51 const double length, const double exaggeration) const {
52 // declare contour width
53 const double contourWidth = (0.05 * exaggeration);
54 // Push matrix
55 GLHelper::pushMatrix();
56 // Traslate to bot
57 glTranslated(position.x(), position.y(), GLO_VEHICLELABELS);
58 // glTranslated(position.x(), position.y(), GLO_ROUTE + getType() + 0.1 + GLO_PERSONFLOW + 0.1);
59 glRotated(rotation, 0, 0, -1);
60 glTranslated(-1 * ((width * 0.5 * exaggeration) + (0.35 * exaggeration)) - 0.05, 0, 0);
61 // draw external box
62 GLHelper::setColor(RGBColor::GREY);
63 GLHelper::drawBoxLine(Position(), Position(), 0, (length * exaggeration), 0.3 * exaggeration);
64 // draw internal box
65 glTranslated(0, 0, 0.1);
66 GLHelper::setColor(RGBColor::CYAN);
67 GLHelper::drawBoxLine(Position(0, -contourWidth), Position(0, -contourWidth), 0, (length * exaggeration) - (contourWidth * 2), (0.3 * exaggeration) - contourWidth);
68 // draw stack label
69 GLHelper::drawText("Flow", Position(0, length * exaggeration * -0.5), (.1 * exaggeration), (0.6 * exaggeration), RGBColor::BLACK, 90, 0, -1);
70 // pop draw matrix
71 GLHelper::popMatrix();
72}
73
74
75void
76GNEDemandElementFlow::writeFlowAttributes(const GNEDemandElement* flowElement, OutputDevice& device) const {
77 // get xph attribute
78 SumoXMLAttr xph = SUMO_ATTR_VEHSPERHOUR;
79 if (flowElement->getTagProperty()->isPerson()) {
80 xph = SUMO_ATTR_PERSONSPERHOUR;
81 } else if (flowElement->getTagProperty()->isContainer()) {
82 xph = SUMO_ATTR_CONTAINERSPERHOUR;
83 }
84 // first check that we're writting a flow
85 if (flowElement->getTagProperty()->isFlow()) {
86 // write routeFlow values depending if it was set
87 if (isFlowAttributeEnabled(SUMO_ATTR_END)) {
88 device.writeAttr(SUMO_ATTR_END, getFlowAttribute(flowElement, SUMO_ATTR_END));
89 }
90 if (isFlowAttributeEnabled(SUMO_ATTR_NUMBER)) {
91 device.writeAttr(SUMO_ATTR_NUMBER, getFlowAttribute(flowElement, SUMO_ATTR_NUMBER));
92 }
93 if (isFlowAttributeEnabled(xph)) {
94 device.writeAttr(xph, getFlowAttribute(flowElement, xph));
95 }
96 if (isFlowAttributeEnabled(SUMO_ATTR_PERIOD)) {
97 device.writeAttr(SUMO_ATTR_PERIOD, getFlowAttribute(flowElement, SUMO_ATTR_PERIOD));
98 }
99 if (isFlowAttributeEnabled(GNE_ATTR_POISSON)) {
100 device.writeAttr(SUMO_ATTR_PERIOD, "exp(" + getFlowAttribute(flowElement, GNE_ATTR_POISSON) + ")");
101 }
102 if (isFlowAttributeEnabled(SUMO_ATTR_PROB)) {
103 device.writeAttr(SUMO_ATTR_PROB, getFlowAttribute(flowElement, SUMO_ATTR_PROB));
104 }
105 }
106}
107
108
109std::string
110GNEDemandElementFlow::getFlowAttribute(const GNEDemandElement* flowElement, SumoXMLAttr key) const {
111 switch (key) {
112 case SUMO_ATTR_DEPART:
113 case SUMO_ATTR_BEGIN:
114 if (departProcedure == DepartDefinition::TRIGGERED) {
115 return "triggered";
116 } else if (departProcedure == DepartDefinition::CONTAINER_TRIGGERED) {
117 return "containerTriggered";
118 } else if (departProcedure == DepartDefinition::NOW) {
119 return "now";
120 } else if (departProcedure == DepartDefinition::SPLIT) {
121 return "split";
122 } else if (departProcedure == DepartDefinition::BEGIN) {
123 return "begin";
124 } else {
125 return time2string(depart);
126 }
127 case SUMO_ATTR_END:
128 return time2string(repetitionEnd);
129 case SUMO_ATTR_VEHSPERHOUR:
130 case SUMO_ATTR_PERSONSPERHOUR:
131 case SUMO_ATTR_CONTAINERSPERHOUR:
132 return adjustDecimalValue(3600 / STEPS2TIME(repetitionOffset), 2);
133 case SUMO_ATTR_PERIOD:
134 return time2string(repetitionOffset);
135 case GNE_ATTR_POISSON:
136 return adjustDecimalValue(poissonRate, 10);
137 case SUMO_ATTR_PROB:
138 return adjustDecimalValue(repetitionProbability, 20);
139 case SUMO_ATTR_NUMBER:
140 return toString(repetitionNumber);
141 case GNE_ATTR_FLOW_TERMINATE:
142 if (isFlowAttributeEnabled(SUMO_ATTR_END)) {
143 if (isFlowAttributeEnabled(SUMO_ATTR_NUMBER)) {
144 return toString(SUMO_ATTR_END) + "-" + toString(SUMO_ATTR_NUMBER);
145 } else {
146 return toString(SUMO_ATTR_END);
147 }
148 } else if (isFlowAttributeEnabled(SUMO_ATTR_NUMBER)) {
149 return toString(SUMO_ATTR_NUMBER);
150 } else {
151 return "invalid terminate";
152 }
153 case GNE_ATTR_FLOW_SPACING:
154 if (flowElement->getTagProperty()->hasAttribute(SUMO_ATTR_VEHSPERHOUR) && isFlowAttributeEnabled(SUMO_ATTR_VEHSPERHOUR)) {
155 return toString(SUMO_ATTR_VEHSPERHOUR);
156 } else if (flowElement->getTagProperty()->hasAttribute(SUMO_ATTR_PERSONSPERHOUR) && isFlowAttributeEnabled(SUMO_ATTR_PERSONSPERHOUR)) {
157 return toString(SUMO_ATTR_PERSONSPERHOUR);
158 } else if (flowElement->getTagProperty()->hasAttribute(SUMO_ATTR_CONTAINERSPERHOUR) && isFlowAttributeEnabled(SUMO_ATTR_CONTAINERSPERHOUR)) {
159 return toString(SUMO_ATTR_CONTAINERSPERHOUR);
160 } else if (isFlowAttributeEnabled(SUMO_ATTR_PERIOD)) {
161 return toString(SUMO_ATTR_PERIOD);
162 } else if (isFlowAttributeEnabled(SUMO_ATTR_PROB)) {
163 return toString(SUMO_ATTR_PROB);
164 } else if (isFlowAttributeEnabled(GNE_ATTR_POISSON)) {
165 return toString(GNE_ATTR_POISSON);
166 } else {
167 return "invalid flow spacing";
168 }
169 default:
170 return flowElement->getCommonAttribute(this, key);
171 }
172}
173
174
175double
176GNEDemandElementFlow::getFlowAttributeDouble(SumoXMLAttr key) const {
177 switch (key) {
178 case SUMO_ATTR_DEPART:
179 case SUMO_ATTR_BEGIN:
180 return STEPS2TIME(depart);
181 default:
182 throw InvalidArgument("Flow doesn't have a double attribute of type '" + toString(key) + "'");
183 }
184}
185
186
187void
188GNEDemandElementFlow::setFlowAttribute(GNEDemandElement* flowElement, SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) {
189 switch (key) {
190 case SUMO_ATTR_DEPART:
191 case SUMO_ATTR_BEGIN:
192 case SUMO_ATTR_END:
193 case SUMO_ATTR_NUMBER:
194 case SUMO_ATTR_VEHSPERHOUR:
195 case SUMO_ATTR_PERSONSPERHOUR:
196 case SUMO_ATTR_CONTAINERSPERHOUR:
197 case SUMO_ATTR_PERIOD:
198 case GNE_ATTR_POISSON:
199 case SUMO_ATTR_PROB:
200 case GNE_ATTR_FLOW_TERMINATE:
201 case GNE_ATTR_FLOW_SPACING:
202 GNEChange_Attribute::changeAttribute(flowElement, key, value, undoList);
203 break;
204 default:
205 return flowElement->setCommonAttribute(key, value, undoList);
206 break;
207 }
208}
209
210
211bool
212GNEDemandElementFlow::isValidFlowAttribute(GNEDemandElement* flowElement, SumoXMLAttr key, const std::string& value) {
213 // declare string error
214 std::string error;
215 switch (key) {
216 case SUMO_ATTR_DEPART:
217 case SUMO_ATTR_BEGIN: {
218 SUMOTime dummyDepart;
219 DepartDefinition dummyDepartProcedure;
220 parseDepart(value, flowElement->getTagProperty()->getTagStr(), id, dummyDepart, dummyDepartProcedure, error);
221 // if error is empty, given value is valid
222 return error.empty();
223 }
224 case SUMO_ATTR_END:
225 if (GNEAttributeCarrier::canParse<SUMOTime>(value)) {
226 return (GNEAttributeCarrier::parse<SUMOTime>(value) >= 0);
227 } else {
228 return false;
229 }
230 case SUMO_ATTR_VEHSPERHOUR:
231 case SUMO_ATTR_PERSONSPERHOUR:
232 case SUMO_ATTR_CONTAINERSPERHOUR:
233 case SUMO_ATTR_PERIOD:
234 case GNE_ATTR_POISSON:
235 if (GNEAttributeCarrier::canParse<double>(value)) {
236 return (GNEAttributeCarrier::parse<double>(value) > 0);
237 } else {
238 return false;
239 }
240 case SUMO_ATTR_PROB:
241 if (GNEAttributeCarrier::canParse<double>(value)) {
242 const double prob = GNEAttributeCarrier::parse<double>(value);
243 return ((prob >= 0) && (prob <= 1));
244 } else {
245 return false;
246 }
247 case SUMO_ATTR_NUMBER:
248 if (GNEAttributeCarrier::canParse<int>(value)) {
249 return (GNEAttributeCarrier::parse<int>(value) >= 0);
250 } else {
251 return false;
252 }
253 case GNE_ATTR_FLOW_TERMINATE:
254 case GNE_ATTR_FLOW_SPACING: {
255 const auto& flowValues = flowElement->getTagProperty()->getAttributeProperties(key)->getDiscreteValues();
256 if (std::find(flowValues.begin(), flowValues.end(), value) != flowValues.end()) {
257 return true;
258 } else {
259 return false;
260 }
261 }
262 default:
263 return flowElement->isCommonValid(key, value);
264 }
265}
266
267
268void
269GNEDemandElementFlow::enableFlowAttribute(GNEDemandElement* flowElement, SumoXMLAttr key, GNEUndoList* undoList) {
270 switch (key) {
271 case SUMO_ATTR_END:
272 case SUMO_ATTR_NUMBER:
273 case SUMO_ATTR_VEHSPERHOUR:
274 case SUMO_ATTR_PERSONSPERHOUR:
275 case SUMO_ATTR_CONTAINERSPERHOUR:
276 case SUMO_ATTR_PERIOD:
277 case GNE_ATTR_POISSON:
278 case SUMO_ATTR_PROB:
279 undoList->add(new GNEChange_ToggleAttribute(flowElement, key, true), true);
280 return;
281 default:
282 throw InvalidArgument(flowElement->getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
283 }
284}
285
286
287void
288GNEDemandElementFlow::disableFlowAttribute(GNEDemandElement* flowElement, SumoXMLAttr key, GNEUndoList* undoList) {
289 switch (key) {
290 case SUMO_ATTR_END:
291 case SUMO_ATTR_NUMBER:
292 case SUMO_ATTR_VEHSPERHOUR:
293 case SUMO_ATTR_PERSONSPERHOUR:
294 case SUMO_ATTR_CONTAINERSPERHOUR:
295 case SUMO_ATTR_PERIOD:
296 case GNE_ATTR_POISSON:
297 case SUMO_ATTR_PROB:
298 undoList->add(new GNEChange_ToggleAttribute(flowElement, key, false), true);
299 return;
300 default:
301 throw InvalidArgument(flowElement->getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
302 }
303}
304
305
306bool
307GNEDemandElementFlow::isFlowAttributeEnabled(SumoXMLAttr key) const {
308 switch (key) {
309 case SUMO_ATTR_END:
310 return (parametersSet & VEHPARS_END_SET) != 0;
311 case SUMO_ATTR_NUMBER:
312 return (parametersSet & VEHPARS_NUMBER_SET) != 0;
313 case SUMO_ATTR_VEHSPERHOUR:
314 case SUMO_ATTR_PERSONSPERHOUR:
315 case SUMO_ATTR_CONTAINERSPERHOUR:
316 return (parametersSet & VEHPARS_VPH_SET) != 0;
317 case SUMO_ATTR_PERIOD:
318 return (parametersSet & VEHPARS_PERIOD_SET) != 0;
319 case GNE_ATTR_POISSON:
320 return (parametersSet & VEHPARS_POISSON_SET) != 0;
321 case SUMO_ATTR_PROB:
322 return (parametersSet & VEHPARS_PROB_SET) != 0;
323 case GNE_ATTR_FLOW_SPACING:
324 return !isFlowAttributeEnabled(SUMO_ATTR_END) || !isFlowAttributeEnabled(SUMO_ATTR_NUMBER);
325 default:
326 return true;
327 }
328}
329
330
331void
332GNEDemandElementFlow::setFlowAttribute(GNEDemandElement* flowElement, SumoXMLAttr key, const std::string& value) {
333 // declare string error
334 std::string error;
335 switch (key) {
336 case SUMO_ATTR_DEPART:
337 case SUMO_ATTR_BEGIN: {
338 parseDepart(value, flowElement->getTagProperty()->getTagStr(), id, depart, departProcedure, error);
339 break;
340 }
341 case SUMO_ATTR_END:
342 repetitionEnd = string2time(value);
343 break;
344 case SUMO_ATTR_VEHSPERHOUR:
345 case SUMO_ATTR_PERSONSPERHOUR:
346 case SUMO_ATTR_CONTAINERSPERHOUR:
347 repetitionOffset = TIME2STEPS(3600 / GNEAttributeCarrier::parse<double>(value));
348 poissonRate = GNEAttributeCarrier::parse<double>(value) / 3600;
349 break;
350 case SUMO_ATTR_PERIOD:
351 repetitionOffset = string2time(value);
352 poissonRate = 1 / STEPS2TIME(repetitionOffset);
353 break;
354 case GNE_ATTR_POISSON:
355 poissonRate = GNEAttributeCarrier::parse<double>(value);
356 repetitionOffset = TIME2STEPS(1 / poissonRate);
357 break;
358 case SUMO_ATTR_PROB:
359 repetitionProbability = GNEAttributeCarrier::parse<double>(value);
360 break;
361 case SUMO_ATTR_NUMBER:
362 repetitionNumber = GNEAttributeCarrier::parse<int>(value);
363 break;
364 case GNE_ATTR_FLOW_TERMINATE:
365 if (value == (toString(SUMO_ATTR_END) + "-" + toString(SUMO_ATTR_NUMBER))) {
366 toggleFlowAttribute(SUMO_ATTR_END, true);
367 toggleFlowAttribute(SUMO_ATTR_NUMBER, true);
368 // in this special case, disable other spacing
369 toggleFlowAttribute(SUMO_ATTR_VEHSPERHOUR, false);
370 toggleFlowAttribute(SUMO_ATTR_PERIOD, false);
371 toggleFlowAttribute(GNE_ATTR_POISSON, false);
372 toggleFlowAttribute(SUMO_ATTR_PROB, false);
373 } else {
374 // if previously end-number was enabled, enable perHour
375 if (isFlowAttributeEnabled(SUMO_ATTR_END) && isFlowAttributeEnabled(SUMO_ATTR_NUMBER)) {
376 toggleFlowAttribute(SUMO_ATTR_VEHSPERHOUR, true);
377 }
378 if (value == toString(SUMO_ATTR_END)) {
379 toggleFlowAttribute(SUMO_ATTR_END, true);
380 toggleFlowAttribute(SUMO_ATTR_NUMBER, false);
381 } else if (value == toString(SUMO_ATTR_NUMBER)) {
382 toggleFlowAttribute(SUMO_ATTR_END, false);
383 toggleFlowAttribute(SUMO_ATTR_NUMBER, true);
384 }
385 }
386 break;
387 case GNE_ATTR_FLOW_SPACING:
388 if ((value == toString(SUMO_ATTR_VEHSPERHOUR)) ||
389 (value == toString(SUMO_ATTR_PERSONSPERHOUR)) ||
390 (value == toString(SUMO_ATTR_CONTAINERSPERHOUR))) {
391 toggleFlowAttribute(SUMO_ATTR_VEHSPERHOUR, true);
392 toggleFlowAttribute(SUMO_ATTR_PERIOD, false);
393 toggleFlowAttribute(GNE_ATTR_POISSON, false);
394 toggleFlowAttribute(SUMO_ATTR_PROB, false);
395 } else if (value == toString(SUMO_ATTR_PERIOD)) {
396 toggleFlowAttribute(SUMO_ATTR_VEHSPERHOUR, false);
397 toggleFlowAttribute(SUMO_ATTR_PERIOD, true);
398 toggleFlowAttribute(GNE_ATTR_POISSON, false);
399 toggleFlowAttribute(SUMO_ATTR_PROB, false);
400 } else if (value == toString(GNE_ATTR_POISSON)) {
401 toggleFlowAttribute(SUMO_ATTR_VEHSPERHOUR, false);
402 toggleFlowAttribute(SUMO_ATTR_PERIOD, false);
403 toggleFlowAttribute(GNE_ATTR_POISSON, true);
404 toggleFlowAttribute(SUMO_ATTR_PROB, false);
405 } else if (value == toString(SUMO_ATTR_PROB)) {
406 toggleFlowAttribute(SUMO_ATTR_VEHSPERHOUR, false);
407 toggleFlowAttribute(SUMO_ATTR_PERIOD, false);
408 toggleFlowAttribute(GNE_ATTR_POISSON, false);
409 toggleFlowAttribute(SUMO_ATTR_PROB, true);
410 }
411 break;
412 default:
413 flowElement->setCommonAttribute(this, key, value);
414 break;
415 }
416}
417
418
419void
420GNEDemandElementFlow::toggleFlowAttribute(const SumoXMLAttr attribute, const bool value) {
421 // modify parameters depending of given Flow attribute
422 if (value) {
423 switch (attribute) {
424 case SUMO_ATTR_END:
425 parametersSet |= VEHPARS_END_SET;
426 break;
427 case SUMO_ATTR_NUMBER:
428 parametersSet |= VEHPARS_NUMBER_SET;
429 break;
430 case SUMO_ATTR_VEHSPERHOUR:
431 case SUMO_ATTR_PERSONSPERHOUR:
432 case SUMO_ATTR_CONTAINERSPERHOUR:
433 parametersSet |= VEHPARS_VPH_SET;
434 break;
435 case SUMO_ATTR_PERIOD:
436 parametersSet |= VEHPARS_PERIOD_SET;
437 break;
438 case GNE_ATTR_POISSON:
439 parametersSet |= VEHPARS_POISSON_SET;
440 break;
441 case SUMO_ATTR_PROB:
442 parametersSet |= VEHPARS_PROB_SET;
443 break;
444 default:
445 break;
446 }
447 } else {
448 switch (attribute) {
449 case SUMO_ATTR_END:
450 parametersSet &= ~VEHPARS_END_SET;
451 break;
452 case SUMO_ATTR_NUMBER:
453 parametersSet &= ~VEHPARS_NUMBER_SET;
454 break;
455 case SUMO_ATTR_VEHSPERHOUR:
456 case SUMO_ATTR_PERSONSPERHOUR:
457 case SUMO_ATTR_CONTAINERSPERHOUR:
458 parametersSet &= ~VEHPARS_VPH_SET;
459 break;
460 case SUMO_ATTR_PERIOD:
461 parametersSet &= ~VEHPARS_PERIOD_SET;
462 break;
463 case GNE_ATTR_POISSON:
464 parametersSet &= ~VEHPARS_POISSON_SET;
465 break;
466 case SUMO_ATTR_PROB:
467 parametersSet &= ~VEHPARS_PROB_SET;
468 break;
469 default:
470 break;
471 }
472 }
473}
474
475
476void
477GNEDemandElementFlow::setDefaultFlowAttributes(GNEDemandElement* flowElement) {
478 // first check that this demand element is a flow
479 if (flowElement->getTagProperty()->isFlow()) {
480 // end
481 if ((parametersSet & VEHPARS_END_SET) == 0) {
482 setFlowAttribute(flowElement, SUMO_ATTR_END, flowElement->getTagProperty()->getDefaultStringValue(SUMO_ATTR_END));
483 }
484 // number
485 if ((parametersSet & VEHPARS_NUMBER_SET) == 0) {
486 setFlowAttribute(flowElement, SUMO_ATTR_NUMBER, flowElement->getTagProperty()->getDefaultStringValue(SUMO_ATTR_NUMBER));
487 }
488 // vehicles/person/container per hour
489 if (((parametersSet & VEHPARS_PERIOD_SET) == 0) &&
490 ((parametersSet & VEHPARS_POISSON_SET) == 0) &&
491 ((parametersSet & VEHPARS_VPH_SET) == 0)) {
492 setFlowAttribute(flowElement, SUMO_ATTR_PERIOD, flowElement->getTagProperty()->getDefaultStringValue(SUMO_ATTR_PERIOD));
493 }
494 // probability
495 if ((parametersSet & VEHPARS_PROB_SET) == 0) {
496 setFlowAttribute(flowElement, SUMO_ATTR_PROB, flowElement->getTagProperty()->getDefaultStringValue(SUMO_ATTR_PROB));
497 }
498 // poisson
499 if (repetitionOffset < 0) {
500 toggleFlowAttribute(SUMO_ATTR_PERIOD, false);
501 toggleFlowAttribute(GNE_ATTR_POISSON, true);
502 setFlowAttribute(flowElement, GNE_ATTR_POISSON, toString(poissonRate));
503 } else {
504 setFlowAttribute(flowElement, SUMO_ATTR_PERIOD, time2string(repetitionOffset));
505 }
506 }
507}
508
509std::string
510GNEDemandElementFlow::adjustDecimalValue(const double value, const int precission) const {
511 // obtain value in string format with 20 decimals precision
512 auto valueStr = toString(value, precission);
513 // now clear all zeros
514 while (valueStr.size() > 1) {
515 if (valueStr.back() == '0') {
516 valueStr.pop_back();
517 } else if (valueStr.back() == '.') {
518 valueStr.pop_back();
519 return valueStr;
520 } else {
521 return valueStr;
522 }
523 }
524 return valueStr;
525}
526
527/****************************************************************************/
GNEChange_Attribute.h
GNEChange_ToggleAttribute.h
SUMOTime
long long int SUMOTime
Definition GUI.h:36
GLO_VEHICLELABELS
@ GLO_VEHICLELABELS
stack and flow labels (used in netedit)
Definition GUIGlObjectTypes.h:297
string2time
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition SUMOTime.cpp:46
time2string
std::string time2string(SUMOTime t, bool humanReadable)
convert SUMOTime to string (independently of global format setting)
Definition SUMOTime.cpp:91
STEPS2TIME
#define STEPS2TIME(x)
Definition SUMOTime.h:55
TIME2STEPS
#define TIME2STEPS(x)
Definition SUMOTime.h:57
VEHPARS_END_SET
const long long int VEHPARS_END_SET
Definition SUMOVehicleParameter.h:48
VEHPARS_PERIOD_SET
const long long int VEHPARS_PERIOD_SET
Definition SUMOVehicleParameter.h:50
VEHPARS_POISSON_SET
const long long int VEHPARS_POISSON_SET
Definition SUMOVehicleParameter.h:53
VEHPARS_PROB_SET
const long long int VEHPARS_PROB_SET
Definition SUMOVehicleParameter.h:52
VEHPARS_VPH_SET
const long long int VEHPARS_VPH_SET
Definition SUMOVehicleParameter.h:51
VEHPARS_NUMBER_SET
const long long int VEHPARS_NUMBER_SET
Definition SUMOVehicleParameter.h:49
DepartDefinition
DepartDefinition
Possible ways to depart.
Definition SUMOVehicleParameter.h:116
DepartDefinition::BEGIN
@ BEGIN
The departure is at simulation start.
DepartDefinition::NOW
@ NOW
The vehicle is discarded if emission fails (not fully implemented yet)
DepartDefinition::SPLIT
@ SPLIT
The departure is triggered by a train split.
DepartDefinition::CONTAINER_TRIGGERED
@ CONTAINER_TRIGGERED
The departure is container triggered.
DepartDefinition::TRIGGERED
@ TRIGGERED
The departure is person triggered.
SumoXMLAttr
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
Definition SUMOXMLDefinitions.h:847
SUMO_ATTR_NUMBER
@ SUMO_ATTR_NUMBER
Definition SUMOXMLDefinitions.h:1421
SUMO_ATTR_DEPART
@ SUMO_ATTR_DEPART
Definition SUMOXMLDefinitions.h:996
SUMO_ATTR_VEHSPERHOUR
@ SUMO_ATTR_VEHSPERHOUR
Definition SUMOXMLDefinitions.h:1593
SUMO_ATTR_BEGIN
@ SUMO_ATTR_BEGIN
weights: time range begin
Definition SUMOXMLDefinitions.h:1436
GNE_ATTR_POISSON
@ GNE_ATTR_POISSON
poisson definition (used in flow)
Definition SUMOXMLDefinitions.h:1861
SUMO_ATTR_CONTAINERSPERHOUR
@ SUMO_ATTR_CONTAINERSPERHOUR
Definition SUMOXMLDefinitions.h:1595
SUMO_ATTR_PERIOD
@ SUMO_ATTR_PERIOD
Definition SUMOXMLDefinitions.h:1399
SUMO_ATTR_END
@ SUMO_ATTR_END
weights: time range end
Definition SUMOXMLDefinitions.h:1438
SUMO_ATTR_PROB
@ SUMO_ATTR_PROB
Definition SUMOXMLDefinitions.h:1377
GNE_ATTR_FLOW_SPACING
@ GNE_ATTR_FLOW_SPACING
flow spacing
Definition SUMOXMLDefinitions.h:1879
GNE_ATTR_FLOW_TERMINATE
@ GNE_ATTR_FLOW_TERMINATE
flow terminating
Definition SUMOXMLDefinitions.h:1877
SUMO_ATTR_PERSONSPERHOUR
@ SUMO_ATTR_PERSONSPERHOUR
Definition SUMOXMLDefinitions.h:1594
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition ToString.h:46
GLHelper::setColor
static void setColor(const RGBColor &c)
Sets the gl-color to this value.
Definition GLHelper.cpp:649
GLHelper::popMatrix
static void popMatrix()
pop matrix
Definition GLHelper.cpp:131
GLHelper::drawBoxLine
static void drawBoxLine(const Position &beg, double rot, double visLength, double width, double offset=0)
Draws a thick line.
Definition GLHelper.cpp:296
GLHelper::pushMatrix
static void pushMatrix()
push matrix
Definition GLHelper.cpp:118
GLHelper::drawText
static void drawText(const std::string &text, const Position &pos, const double layer, const double size, const RGBColor &col=RGBColor::BLACK, const double angle=0, const int align=0, double width=-1)
Definition GLHelper.cpp:748
GNEAttributeCarrier::getCommonAttribute
std::string getCommonAttribute(const Parameterised *parameterised, SumoXMLAttr key) const
Definition GNEAttributeCarrier.cpp:894
GNEAttributeCarrier::setCommonAttribute
void setCommonAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
Definition GNEAttributeCarrier.cpp:924
GNEAttributeCarrier::getTagStr
const std::string & getTagStr() const
get tag assigned to this object in string format
Definition GNEAttributeCarrier.cpp:856
GNEAttributeCarrier::getTagProperty
const GNETagProperties * getTagProperty() const
get tagProperty associated with this Attribute Carrier
Definition GNEAttributeCarrier.cpp:879
GNEAttributeCarrier::isCommonValid
bool isCommonValid(SumoXMLAttr key, const std::string &value) const
Definition GNEAttributeCarrier.cpp:954
GNEChange_Attribute::changeAttribute
static void changeAttribute(GNEAttributeCarrier *AC, SumoXMLAttr key, const std::string &value, GNEUndoList *undoList, const bool force=false)
change attribute
Definition GNEChange_Attribute.cpp:41
GNEChange_ToggleAttribute
the function-object for an editing operation (abstract base)
Definition GNEChange_ToggleAttribute.h:32
GNEDemandElementFlow::toggleFlowAttribute
void toggleFlowAttribute(const SumoXMLAttr attribute, const bool value)
toggle flow parameters (used in toggleAttribute(...) function of vehicles, persons and containers
Definition GNEDemandElementFlow.cpp:420
GNEDemandElementFlow::drawFlowLabel
void drawFlowLabel(const Position &position, const double rotation, const double width, const double length, const double exaggeration) const
draw flow label
Definition GNEDemandElementFlow.cpp:50
GNEDemandElementFlow::getFlowAttribute
std::string getFlowAttribute(const GNEDemandElement *flowElement, SumoXMLAttr key) const
inherited from GNEAttributeCarrier and adapted to GNEDemandElementFlow
Definition GNEDemandElementFlow.cpp:110
GNEDemandElementFlow::disableFlowAttribute
void disableFlowAttribute(GNEDemandElement *flowElement, SumoXMLAttr key, GNEUndoList *undoList)
Definition GNEDemandElementFlow.cpp:288
GNEDemandElementFlow::isFlowAttributeEnabled
bool isFlowAttributeEnabled(SumoXMLAttr key) const
Definition GNEDemandElementFlow.cpp:307
GNEDemandElementFlow::getFlowAttributeDouble
double getFlowAttributeDouble(SumoXMLAttr key) const
Definition GNEDemandElementFlow.cpp:176
GNEDemandElementFlow::GNEDemandElementFlow
GNEDemandElementFlow(GNEDemandElement *flowElement)
constructor
Definition GNEDemandElementFlow.cpp:33
GNEDemandElementFlow::isValidFlowAttribute
bool isValidFlowAttribute(GNEDemandElement *flowElement, SumoXMLAttr key, const std::string &value)
Definition GNEDemandElementFlow.cpp:212
GNEDemandElementFlow::writeFlowAttributes
void writeFlowAttributes(const GNEDemandElement *flowElement, OutputDevice &device) const
write flow attributes
Definition GNEDemandElementFlow.cpp:76
GNEDemandElementFlow::adjustDecimalValue
std::string adjustDecimalValue(const double value, const int precission) const
adjust decimal value
Definition GNEDemandElementFlow.cpp:510
GNEDemandElementFlow::enableFlowAttribute
void enableFlowAttribute(GNEDemandElement *flowElement, SumoXMLAttr key, GNEUndoList *undoList)
Definition GNEDemandElementFlow.cpp:269
GNEDemandElementFlow::setFlowAttribute
void setFlowAttribute(GNEDemandElement *flowElement, SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
Definition GNEDemandElementFlow.cpp:188
GNEDemandElementFlow::setDefaultFlowAttributes
void setDefaultFlowAttributes(GNEDemandElement *flowElement)
set flow default attributes
Definition GNEDemandElementFlow.cpp:477
GNETagProperties::isContainer
bool isContainer() const
return true if tag correspond to a container element
Definition GNETagProperties.cpp:629
GNETagProperties::isFlow
bool isFlow() const
return true if tag correspond to a flow element
Definition GNETagProperties.cpp:617
GNETagProperties::getTagStr
const std::string & getTagStr() const
get Tag vinculated with this attribute Property in String Format (used to avoid multiple calls to toS...
Definition GNETagProperties.cpp:83
GNETagProperties::getAttributeProperties
const std::vector< const GNEAttributeProperties * > & getAttributeProperties() const
get all attribute properties
Definition GNETagProperties.cpp:337
GNETagProperties::hasAttribute
bool hasAttribute(SumoXMLAttr attr) const
check if current TagProperties owns the attribute "attr"
Definition GNETagProperties.cpp:372
GNETagProperties::isPerson
bool isPerson() const
return true if tag correspond to a person element
Definition GNETagProperties.cpp:623
GNETagProperties::getDefaultStringValue
const std::string & getDefaultStringValue(SumoXMLAttr attr) const
default values
Definition GNETagProperties.cpp:247
GNEUndoList::add
void add(GNEChange *command, bool doit=false, bool merge=true)
Add new command, executing it if desired. The new command will be merged with the previous command if...
Definition GNEUndoList.cpp:345
OutputDevice
Static storage of an output device and its base (abstract) implementation.
Definition OutputDevice.h:61
OutputDevice::writeAttr
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition OutputDevice.h:254
Position
A point in 2D or 3D with translation and scaling methods.
Definition Position.h:37
Position::x
double x() const
Returns the x-position.
Definition Position.h:52
Position::y
double y() const
Returns the y-position.
Definition Position.h:57
RGBColor::GREY
static const RGBColor GREY
Definition RGBColor.h:197
RGBColor::CYAN
static const RGBColor CYAN
Definition RGBColor.h:192
RGBColor::BLACK
static const RGBColor BLACK
Definition RGBColor.h:196
SUMOVehicleParameter
Structure representing possible vehicle parameter.
Definition SUMOVehicleParameter.h:337
SUMOVehicleParameter::repetitionProbability
double repetitionProbability
The probability for emitting a vehicle per second.
Definition SUMOVehicleParameter.h:776
SUMOVehicleParameter::repetitionOffset
SUMOTime repetitionOffset
The time offset between vehicle reinsertions.
Definition SUMOVehicleParameter.h:770
SUMOVehicleParameter::parametersSet
long long int parametersSet
Information for the router which parameter were set, TraCI may modify this (when changing color)
Definition SUMOVehicleParameter.h:826
SUMOVehicleParameter::poissonRate
double poissonRate
The rate for emitting vehicles with a poisson distribution.
Definition SUMOVehicleParameter.h:779
SUMOVehicleParameter::repetitionEnd
SUMOTime repetitionEnd
The time at which the flow ends (only needed when using repetitionProbability)
Definition SUMOVehicleParameter.h:782
SUMOVehicleParameter::parseDepart
static bool parseDepart(const std::string &val, const std::string &element, const std::string &id, SUMOTime &depart, DepartDefinition &dd, std::string &error, const std::string &attr="departure")
Validates a given depart value.
Definition SUMOVehicleParameter.cpp:346
SUMOVehicleParameter::departProcedure
DepartDefinition departProcedure
Information how the vehicle shall choose the depart time.
Definition SUMOVehicleParameter.h:693