72 myUndoAdditionals(undoAdditionals) {
167 const std::string edgeId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_EDGE, abort);
168 double startTime = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs,
"", tag,
SUMO_ATTR_STARTTIME, abort);
169 double endTime = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs,
"", tag,
SUMO_ATTR_END, abort);
179 }
else if (startTime > endTime) {
192 std::string
id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_ID, abort);
193 std::string edgeId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, tag,
SUMO_ATTR_EDGE, abort);
194 double freq = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_FREQUENCY, abort);
195 std::string file = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, tag,
SUMO_ATTR_FILE, abort,
false);
196 double begin = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_BEGIN, abort);
206 }
else if (edge == NULL) {
208 WRITE_WARNING(
"The edge '" + edgeId +
"' to use within the " +
toString(tag) +
" '" +
id +
"' is not known.");
220 std::string routeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_ID, abort);
221 std::string edgeIDs = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, routeID, tag,
SUMO_ATTR_EDGES, abort);
222 RGBColor color = GNEAttributeCarrier::parseAttributeFromXML<RGBColor>(attrs, routeID, tag,
SUMO_ATTR_COLOR, abort,
false);
226 std::vector<GNEEdge*> edges;
235 }
else if (calibrator == NULL) {
237 }
else if (edges.size() > 0) {
249 std::string vehicleTypeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_ID, abort);
250 double accel = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, vehicleTypeID, tag,
SUMO_ATTR_ACCEL, abort);
251 double decel = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, vehicleTypeID, tag,
SUMO_ATTR_DECEL, abort);
252 double sigma = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, vehicleTypeID, tag,
SUMO_ATTR_SIGMA, abort);
253 double tau = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, vehicleTypeID, tag,
SUMO_ATTR_TAU, abort);
254 double length = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, vehicleTypeID, tag,
SUMO_ATTR_LENGTH, abort);
255 double minGap = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, vehicleTypeID, tag,
SUMO_ATTR_MINGAP, abort);
256 double maxSpeed = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, vehicleTypeID, tag,
SUMO_ATTR_MAXSPEED, abort);
257 double speedFactor = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, vehicleTypeID, tag,
SUMO_ATTR_SPEEDFACTOR, abort);
258 double speedDev = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, vehicleTypeID, tag,
SUMO_ATTR_SPEEDDEV, abort);
259 RGBColor color = GNEAttributeCarrier::parseAttributeFromXML<RGBColor>(attrs, vehicleTypeID, tag,
SUMO_ATTR_COLOR, abort,
false);
261 std::string emissionClass = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, vehicleTypeID, tag,
SUMO_ATTR_EMISSIONCLASS, abort);
263 double width = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, vehicleTypeID, tag,
SUMO_ATTR_WIDTH, abort);
264 std::string filename = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, vehicleTypeID, tag,
SUMO_ATTR_IMGFILE, abort);
265 double impatience = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, vehicleTypeID, tag,
SUMO_ATTR_IMPATIENCE, abort);
266 std::string laneChangeModel = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, vehicleTypeID, tag,
SUMO_ATTR_LANE_CHANGE_MODEL, abort);
267 std::string carFollowModel = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, vehicleTypeID, tag,
SUMO_ATTR_CAR_FOLLOW_MODEL, abort);
268 int personCapacity = GNEAttributeCarrier::parseAttributeFromXML<int>(attrs, vehicleTypeID, tag,
SUMO_ATTR_PERSON_CAPACITY, abort);
269 int containerCapacity = GNEAttributeCarrier::parseAttributeFromXML<int>(attrs, vehicleTypeID, tag,
SUMO_ATTR_CONTAINER_CAPACITY, abort);
270 double boardingDuration = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, vehicleTypeID, tag,
SUMO_ATTR_BOARDING_DURATION, abort);
271 double loadingDuration = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, vehicleTypeID, tag,
SUMO_ATTR_LOADING_DURATION, abort);
272 std::string latAlignment = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, vehicleTypeID, tag,
SUMO_ATTR_LATALIGNMENT, abort);
273 double minGapLat = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, vehicleTypeID, tag,
SUMO_ATTR_MINGAP_LAT, abort);
274 double maxSpeedLat = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, vehicleTypeID, tag,
SUMO_ATTR_MAXSPEED_LAT, abort);
282 }
else if (calibrator == NULL) {
286 buildCalibratorVehicleType(
myViewNet,
true, calibrator, vehicleTypeID, accel, decel, sigma, tau, length, minGap, maxSpeed, speedFactor, speedDev,
287 color, vClass, emissionClass, shape, width, filename, impatience, laneChangeModel, carFollowModel, personCapacity,
288 containerCapacity, boardingDuration, loadingDuration, latAlignment, minGapLat, maxSpeedLat);
298 std::string flowID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_ID, abort);
299 std::string vehicleTypeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, flowID, tag,
SUMO_ATTR_TYPE, abort);
300 std::string routeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, flowID, tag,
SUMO_ATTR_ROUTE, abort);
301 RGBColor color = GNEAttributeCarrier::parseAttributeFromXML<RGBColor>(attrs, flowID, tag,
SUMO_ATTR_COLOR, abort,
false);
302 std::string departLane = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, flowID, tag,
SUMO_ATTR_DEPARTLANE, abort);
303 std::string departPos = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, flowID, tag,
SUMO_ATTR_DEPARTPOS, abort);
304 std::string departSpeed = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, flowID, tag,
SUMO_ATTR_DEPARTSPEED, abort);
305 std::string arrivalLane = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, flowID, tag,
SUMO_ATTR_ARRIVALLANE, abort);
306 std::string arrivalPos = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, flowID, tag,
SUMO_ATTR_ARRIVALPOS, abort);
307 std::string arrivalSpeed = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, flowID, tag,
SUMO_ATTR_ARRIVALSPEED, abort);
308 std::string line = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, flowID, tag,
SUMO_ATTR_LINE, abort);
309 int personNumber = GNEAttributeCarrier::parseAttributeFromXML<int>(attrs, flowID, tag,
SUMO_ATTR_PERSON_NUMBER, abort);
311 bool reroute = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, flowID, tag,
SUMO_ATTR_REROUTE, abort);
312 std::string departPosLat = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, flowID, tag,
SUMO_ATTR_DEPARTPOS_LAT, abort);
313 std::string arrivalPosLat = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, flowID, tag,
SUMO_ATTR_ARRIVALPOS_LAT, abort);
314 double begin = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, flowID, tag,
SUMO_ATTR_BEGIN, abort);
315 double end = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, flowID, tag,
SUMO_ATTR_END, abort);
316 double vehsPerHour = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, flowID, tag,
SUMO_ATTR_VEHSPERHOUR, abort);
317 double period = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, flowID, tag,
SUMO_ATTR_PERIOD, abort);
318 double probability = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, flowID, tag,
SUMO_ATTR_PROB, abort);
319 int number = GNEAttributeCarrier::parseAttributeFromXML<int>(attrs, flowID, tag,
SUMO_ATTR_NUMBER, abort);
331 }
else if (route == NULL) {
334 }
else if (vtype == NULL) {
337 }
else if (calibrator == NULL) {
340 buildCalibratorFlow(
myViewNet,
true, calibrator, flowID, route, vtype, color, departLane, departPos, departSpeed, arrivalLane, arrivalPos, arrivalSpeed,
341 line, personNumber, containerNumber, reroute, departPosLat, arrivalPosLat, begin, end, vehsPerHour, period, probability, number, flowType);
351 std::string
id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_ID, abort);
352 std::string file = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, tag,
SUMO_ATTR_FILE, abort,
false);
353 std::string lanesIDs = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, tag,
SUMO_ATTR_LANES, abort);
354 double posx = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_X, abort);
355 double posy = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_Y, abort);
361 std::vector<GNELane*> lanes;
370 myLastInsertedAdditionalParent = id;
379 double time = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs,
"", tag,
SUMO_ATTR_TIME, abort);
380 double speed = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs,
"", tag,
SUMO_ATTR_SPEED, abort);
386 if (variableSpeedSign == NULL) {
399 std::string
id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_ID, abort);
400 std::string edgesIDs = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, tag,
SUMO_ATTR_EDGES, abort);
401 std::string file = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, tag,
SUMO_ATTR_FILE, abort,
false);
402 double probability = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_PROB, abort);
403 bool off = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, tag,
SUMO_ATTR_OFF, abort);
405 double posx = attrs.getOpt<
double>(
SUMO_ATTR_X, 0, abort, 0);
406 double posy = attrs.getOpt<
double>(
SUMO_ATTR_Y, 0, abort, 0);
412 std::vector<GNEEdge*> edges;
421 myLastInsertedAdditionalParent = id;
431 double begin = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs,
"", tag,
SUMO_ATTR_BEGIN, abort);
432 double end = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs,
"", tag,
SUMO_ATTR_END, abort);
438 if (rerouter == NULL) {
452 std::string laneID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_ID, abort);
463 }
else if (rerouterInterval == NULL) {
476 std::string edgeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_ID, abort);
487 }
else if (rerouterInterval == NULL) {
500 std::string edgeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_ID, abort);
501 double probability = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs,
"", tag,
SUMO_ATTR_PROB, abort);
510 }
else if (rerouterInterval == NULL) {
523 std::string routeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_ID, abort);
524 double probability = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs,
"", tag,
SUMO_ATTR_PROB, abort);
530 if (rerouterInterval == NULL) {
543 std::string
id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_ID, abort);
544 std::string laneId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, tag,
SUMO_ATTR_LANE, abort);
545 double startPos = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_STARTPOS, abort);
546 double endPos = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_ENDPOS, abort);
547 std::string name = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, tag,
SUMO_ATTR_NAME, abort,
false);
548 std::vector<std::string> lines = GNEAttributeCarrier::parseAttributeFromXML<std::vector<std::string> >(attrs, id, tag,
SUMO_ATTR_LINES, abort,
false);
549 bool friendlyPosition = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, tag,
SUMO_ATTR_FRIENDLY_POS, abort,
false);
559 }
else if (lane == NULL) {
561 WRITE_WARNING(
"The lane '" + laneId +
"' to use within the " +
toString(tag) +
" '" +
id +
"' is not known.");
576 std::string
id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_ID, abort);
577 std::string laneId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, tag,
SUMO_ATTR_LANE, abort);
578 double startPos = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_STARTPOS, abort);
579 double endPos = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_ENDPOS, abort);
580 std::string name = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, tag,
SUMO_ATTR_NAME, abort,
false);
581 std::vector<std::string> lines = GNEAttributeCarrier::parseAttributeFromXML<std::vector<std::string> >(attrs, id, tag,
SUMO_ATTR_LINES, abort,
false);
582 bool friendlyPosition = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, tag,
SUMO_ATTR_FRIENDLY_POS, abort,
false);
592 }
else if (lane == NULL) {
594 WRITE_WARNING(
"The lane '" + laneId +
"' to use within the " +
toString(tag) +
" '" +
id +
"' is not known.");
609 std::string
id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_ID, abort);
610 std::string laneId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, tag,
SUMO_ATTR_LANE, abort);
611 double startPos = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_STARTPOS, abort);
612 double endPos = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_ENDPOS, abort);
613 std::string name = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, tag,
SUMO_ATTR_NAME, abort,
false);
614 double chargingPower = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_CHARGINGPOWER, abort);
615 double efficiency = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_EFFICIENCY, abort);
616 bool chargeInTransit = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, tag,
SUMO_ATTR_CHARGEINTRANSIT, abort);
617 double chargeDelay = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_CHARGEDELAY, abort);
618 bool friendlyPosition = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, tag,
SUMO_ATTR_FRIENDLY_POS, abort,
false);
628 }
else if (lane == NULL) {
630 WRITE_WARNING(
"The lane '" + laneId +
"' to use within the " +
toString(tag) +
" '" +
id +
"' is not known.");
635 buildChargingStation(
myViewNet,
myUndoAdditionals,
id, lane, startPos, endPos, name, chargingPower, efficiency, chargeInTransit, chargeDelay, friendlyPosition);
645 std::string edgeID, laneId, id;
652 id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", typeOfCalibrator,
SUMO_ATTR_ID, abort);
653 edgeID = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, typeOfCalibrator,
SUMO_ATTR_EDGE, abort,
false);
654 std::string outfile = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, typeOfCalibrator,
SUMO_ATTR_OUTPUT, abort,
false);
655 double position = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, typeOfCalibrator,
SUMO_ATTR_POSITION, abort);
656 double freq = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, typeOfCalibrator,
SUMO_ATTR_FREQUENCY, abort);
667 }
else if (edge == NULL) {
668 WRITE_WARNING(
"The edge '" + edgeID +
"' to use within the " +
toString(typeOfCalibrator) +
" '" +
id +
"' is not known.");
671 myLastInsertedAdditionalParent = id;
676 id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", typeOfCalibrator,
SUMO_ATTR_ID, abort);
677 laneId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, typeOfCalibrator,
SUMO_ATTR_LANE, abort,
false);
678 std::string outfile = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, typeOfCalibrator,
SUMO_ATTR_OUTPUT, abort,
false);
679 double position = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, typeOfCalibrator,
SUMO_ATTR_POSITION, abort);
680 double freq = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, typeOfCalibrator,
SUMO_ATTR_FREQUENCY, abort);
691 }
else if (lane == NULL) {
692 WRITE_WARNING(
"The lane '" + laneId +
"' to use within the " +
toString(typeOfCalibrator) +
" '" +
id +
"' is not known.");
695 myLastInsertedAdditionalParent = id;
708 std::string
id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_ID, abort);
709 std::string laneId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, tag,
SUMO_ATTR_LANE, abort);
710 double position = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_POSITION, abort);
711 double frequency = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_FREQUENCY, abort);
712 std::string file = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, tag,
SUMO_ATTR_FILE, abort,
false);
713 std::string vehicleTypes = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, tag,
SUMO_ATTR_VTYPES, abort,
false);
714 bool friendlyPos = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, tag,
SUMO_ATTR_FRIENDLY_POS, abort);
724 }
else if (lane == NULL) {
726 WRITE_WARNING(
"The lane '" + laneId +
"' to use within the " +
toString(tag) +
" '" +
id +
"' is not known.");
740 std::string
id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_ID, abort);
741 std::string laneId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, tag,
SUMO_ATTR_LANE, abort);
742 double position = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_POSITION, abort);
743 double frequency = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_FREQUENCY, abort);
744 std::string file = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, tag,
SUMO_ATTR_FILE, abort,
false);
745 double length = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_LENGTH, abort);
749 bool cont = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, tag,
SUMO_ATTR_CONT, abort);
750 bool friendlyPos = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs, id, tag,
SUMO_ATTR_FRIENDLY_POS, abort);
760 }
else if (lane == NULL) {
762 WRITE_WARNING(
"The lane '" + laneId +
"' to use within the " +
toString(tag) +
" '" +
id +
"' is not known.");
766 buildDetectorE2(
myViewNet,
myUndoAdditionals,
id, lane, position, length, frequency, file, cont, haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold, friendlyPos);
776 std::string
id = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_ID, abort);
777 double frequency = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_FREQUENCY, abort);
778 std::string file = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs, id, tag,
SUMO_ATTR_FILE, abort,
false);
781 double posx = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_X, abort);
782 double posy = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs, id, tag,
SUMO_ATTR_Y, abort);
792 myLastInsertedAdditionalParent = id;
802 std::string laneId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_LANE, abort);
803 double position = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs,
"", tag,
SUMO_ATTR_POSITION, abort);
804 bool friendlyPos = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs,
"", tag,
SUMO_ATTR_FRIENDLY_POS, abort);
813 }
else if (E3Parent == NULL) {
828 std::string laneId = GNEAttributeCarrier::parseAttributeFromXML<std::string>(attrs,
"", tag,
SUMO_ATTR_LANE, abort);
829 double position = GNEAttributeCarrier::parseAttributeFromXML<double>(attrs,
"", tag,
SUMO_ATTR_POSITION, abort);
830 bool friendlyPos = GNEAttributeCarrier::parseAttributeFromXML<bool>(attrs,
"", tag,
SUMO_ATTR_FRIENDLY_POS, abort);
839 }
else if (E3Parent == NULL) {
859 double endPos = GNEAttributeCarrier::parse<double>(values[
SUMO_ATTR_ENDPOS]);
861 std::vector<std::string> lines = GNEAttributeCarrier::parse<std::vector<std::string> >(values[
SUMO_ATTR_LINES]);
865 return buildBusStop(viewNet, allowUndoRedo,
id, lane, startPos, endPos, name, lines, friendlyPos);
875 double endPos = GNEAttributeCarrier::parse<double>(values[
SUMO_ATTR_ENDPOS]);
877 std::vector<std::string> lines = GNEAttributeCarrier::parse<std::vector<std::string> >(values[
SUMO_ATTR_LINES]);
881 return buildContainerStop(viewNet, allowUndoRedo,
id, lane, startPos, endPos, name, lines, friendlyPos);
891 double endPos = GNEAttributeCarrier::parse<double>(values[
SUMO_ATTR_ENDPOS]);
900 return buildChargingStation(viewNet, allowUndoRedo,
id, lane, startPos, endPos, name, chargingPower, efficiency, chargeInTransit, chargeDelay, friendlyPos);
916 return buildDetectorE1(viewNet, allowUndoRedo,
id, lane, pos, freq, filename, vehicleTypes, friendlyPos);
927 double length = GNEAttributeCarrier::parse<double>(values[
SUMO_ATTR_LENGTH]);
929 bool cont = GNEAttributeCarrier::parse<bool>(values[
SUMO_ATTR_CONT]);
936 return buildDetectorE2(viewNet, allowUndoRedo,
id, lane, pos, length, freq, filename, cont, timeThreshold, speedThreshold, jamThreshold, friendlyPos);
951 if (pos.size() == 1) {
952 return buildDetectorE3(viewNet, allowUndoRedo,
id, pos[0], freq, filename, timeThreshold, speedThreshold);
992 if (pos.size() == 1) {
1008 return buildCalibrator(viewNet, allowUndoRedo,
id, edge, pos, outfile, freq);
1023 return buildCalibrator(viewNet, allowUndoRedo,
id, lane, pos, outfile, freq);
1035 bool off = GNEAttributeCarrier::parse<bool>(values[
SUMO_ATTR_OFF]);
1036 double prob = GNEAttributeCarrier::parse<double>(values[
SUMO_ATTR_PROB]);
1040 if (pos.size() == 1) {
1041 return buildRerouter(viewNet, allowUndoRedo,
id, pos[0], edges, prob, file, off, timeThreshold);
1052 double begin = GNEAttributeCarrier::parse<double>(values[
SUMO_ATTR_BEGIN]);
1055 return buildRouteProbe(viewNet, allowUndoRedo,
id, edge, freq, filename, begin);
1064 double end = GNEAttributeCarrier::parse<double>(values[
SUMO_ATTR_END]);
1067 return buildVaporizer(viewNet, allowUndoRedo, edge, startTime, end);
1081 GNEBusStop* busStop =
new GNEBusStop(
id, lane, viewNet, startPos, endPos, name, lines, friendlyPosition);
1082 if (allowUndoRedo) {
1101 if (allowUndoRedo) {
1117 GNEAdditionalHandler::buildChargingStation(
GNEViewNet* viewNet,
bool allowUndoRedo,
const std::string&
id,
GNELane* lane,
double startPos,
double endPos,
const std::string& name,
double chargingPower,
double efficiency,
bool chargeInTransit,
double chargeDelay,
bool friendlyPosition) {
1119 GNEChargingStation* chargingStation =
new GNEChargingStation(
id, lane, viewNet, startPos, endPos, name, chargingPower, efficiency, chargeInTransit, chargeDelay, friendlyPosition);
1120 if (allowUndoRedo) {
1139 if (allowUndoRedo) {
1156 bool cont,
const double timeThreshold,
double speedThreshold,
double jamThreshold,
bool friendlyPos) {
1158 GNEDetectorE2* detectorE2 =
new GNEDetectorE2(
id, lane, viewNet, pos, length, freq, filename, cont, timeThreshold, speedThreshold, jamThreshold, friendlyPos);
1159 if (allowUndoRedo) {
1178 if (allowUndoRedo) {
1197 }
else if (E3Parent == NULL) {
1201 if (allowUndoRedo) {
1220 }
else if (E3Parent == NULL) {
1224 if (allowUndoRedo) {
1242 if (allowUndoRedo) {
1263 if (allowUndoRedo) {
1285 if (allowUndoRedo) {
1304 double accel,
double decel,
double sigma,
double tau,
double length,
double minGap,
double maxSpeed,
1305 double speedFactor,
double speedDev,
const RGBColor& color,
SUMOVehicleClass vClass,
const std::string& emissionClass,
1306 SUMOVehicleShape shape,
double width,
const std::string& filename,
double impatience,
const std::string& laneChangeModel,
1307 const std::string& carFollowModel,
int personCapacity,
int containerCapacity,
double boardingDuration,
1308 double loadingDuration,
const std::string& latAlignment,
double minGapLat,
double maxSpeedLat) {
1312 speedFactor, speedDev, color, vClass, emissionClass, shape, width, filename, impatience,
1313 laneChangeModel, carFollowModel, personCapacity, containerCapacity, boardingDuration,
1314 loadingDuration, latAlignment, minGapLat, maxSpeedLat);
1315 if (allowUndoRedo) {
1334 const std::string& departLane,
const std::string& departPos,
const std::string& departSpeed,
const std::string& arrivalLane,
1335 const std::string& arrivalPos,
const std::string& arrivalSpeed,
const std::string& line,
int personNumber,
int containerNumber,
bool reroute,
1336 const std::string& departPosLat,
const std::string& arrivalPosLat,
double begin,
double end,
double vehsPerHour,
double period,
1337 double probability,
int number,
int flowType) {
1342 arrivalLane, arrivalPos, arrivalSpeed, line, personNumber, containerNumber, reroute,
1343 departPosLat, arrivalPosLat, begin, end, vehsPerHour, period, probability, number, static_cast<GNECalibratorFlow::TypeOfFlow>(flowType));
1344 if (allowUndoRedo) {
1364 if (allowUndoRedo) {
1371 for (
auto i : edges) {
1372 i->addAdditionalParent(rerouter);
1390 if (allowUndoRedo) {
1400 delete rerouterInterval;
1411 if (allowUndoRedo) {
1427 if (allowUndoRedo) {
1443 if (allowUndoRedo) {
1459 if (allowUndoRedo) {
1474 if (allowUndoRedo) {
1495 if (allowUndoRedo) {
1502 for (
auto i : lanes) {
1503 i->addAdditionalParent(variableSpeedSign);
1518 if (allowUndoRedo) {
1532 if (allowUndoRedo) {
1574 WRITE_WARNING(
"The position of additional '" + additionalID +
"' lies beyond the lane's '" + lane.
getID() +
"' length.");
1583 if (minLength > laneLength) {
1587 startPos += laneLength;
1590 endPos += laneLength;
1592 if (endPos < minLength || endPos > laneLength) {
1596 if (endPos < minLength) {
1599 if (endPos > laneLength) {
1600 endPos = laneLength;
1603 if (startPos < 0 || startPos > endPos - minLength) {
1610 if (startPos > endPos - minLength) {
1611 startPos = endPos - minLength;
1619 if ((pos < 0) || (pos > laneLength)) {
1622 }
else if (pos < 0) {
1624 }
else if (pos > laneLength) {
1634 if ((vehsPerHour == -1) && (period == -1) && (probability == -1)) {
1639 int vehsPerHourDefined = (vehsPerHour != -1) ? 1 : 0;
1640 int periodDefined = (period != -1) ? 1 : 0;
1641 int probabilityDefined = (probability != -1) ? 1 : 0;
1643 if ((vehsPerHourDefined + periodDefined + probabilityDefined) != 1) {
1647 }
else if (vehsPerHourDefined == 1) {
1649 }
else if (periodDefined == 1) {
1651 }
else if (probabilityDefined == 1) {
1661 if ((pos < 0) || ((pos + length) > laneLength)) {
1664 }
else if (pos < 0) {
1666 }
else if (pos > laneLength) {
1669 }
else if ((pos + length) > laneLength) {
1670 length = laneLength - pos;
void insertCalibratorVehicleType(GNECalibratorVehicleType *vehicleType)
insert Calibrator VehicleType in net
void insertAdditional(GNEAdditional *additional)
Insert a additional element int GNENet container.
SumoXMLTag
Numbers representing SUMO-XML - element names.
int getTypeOfFlowDistribution(std::string flowID, double vehsPerHour, double period, double probability)
get a error message, if configuration of flow distribution is invalid
GNEEdge * retrieveEdge(const std::string &id, bool failHard=true)
get edge by id
alternative tag for e1 detector
static std::string getConfigurationRelative(const std::string &configPath, const std::string &path)
Returns the second path as a relative path to the first file.
description of a vehicle type
void parseAndBuildRerouterRouteProbReroute(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses his values and builds a Route Prob Reroute.
void removeRerouterInterval(GNERerouterInterval *rerouterInterval)
add rerouter interval
void parseAndBuildDetectorE1(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses his values and builds a induction loop detector (E1)
void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
begin/end of the description of a single lane
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
a flow definition (used by router)
void addDestProbReroute(GNEDestProbReroute *destProbReroute)
add destiny probability reroute
A calibrator placed over edge.
static bool buildVariableSpeedSign(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, Position pos, const std::vector< GNELane *> &destLanes, const std::string &file)
Builds a VariableSpeedSign (lane speed trigger)
void parseAndBuildChargingStation(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses his values and builds a charging station.
GNEAdditional * getAdditional(SumoXMLTag type, const std::string &id) const
Returns the named additional.
lane of a reroute of type closing
Allow/disallow charge in transit in Charging Stations.
const std::string & getFileName() const
returns the current file name
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
static bool builDestProbReroute(GNEViewNet *viewNet, bool allowUndoRedo, GNERerouterInterval *rerouterIntervalParent, GNEEdge *newEdgeDestination, double probability)
bool myUndoAdditionals
flag to check if created additionals must be undo and redo
static bool buildAdditional(GNEViewNet *viewNet, bool allowUndoRedo, SumoXMLTag tag, std::map< SumoXMLAttr, std::string > values)
Build additionals.
int getNumberOfOverlappedIntervals() const
get number of overlapped intervals
Representation of a RouteProbe in netedit.
GNERerouterInterval * getRerouterInterval(const std::string &rerouterIntervalID) const
weights: time range begin
static bool checkAndFixDetectorPositionPosition(double &pos, const double laneLength, const bool friendlyPos)
check if the position of a detector over a lane is valid
static bool buildClosingLaneReroute(GNEViewNet *viewNet, bool allowUndoRedo, GNERerouterInterval *rerouterIntervalParent, GNELane *closedLane, SVCPermissions allowedVehicles, SVCPermissions disallowedVehicles)
void parseAndBuildDetectorExit(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses his values and builds a Exit detector.
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
void p_begin(const std::string &description)
Begin undo command sub-group. This begins a new group of commands that are treated as a single comman...
static bool buildClosingReroute(GNEViewNet *viewNet, bool allowUndoRedo, GNERerouterInterval *rerouterIntervalParent, GNEEdge *closedEdge, SVCPermissions allowedVehicles, SVCPermissions disallowedVehicles)
static bool buildVaporizer(GNEViewNet *viewNet, bool allowUndoRedo, GNEEdge *edge, double startTime, double end)
Builds a vaporizer (lane speed trigger)
SAX-handler base for SUMO-files.
static std::vector< GNEEdge * > parseGNEEdges(GNENet *net, const std::string &value)
parse string into vector of GNEEdges
void addClosingReroute(GNEClosingReroute *closingReroute)
add closing reroute
double getPosition(double pos, GNELane &lane, bool friendlyPos, const std::string &additionalID)
extracts the position, checks whether it shall be mirrored and checks whether it is within the lane...
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list...
begin/end of the description of a route
static bool buildDetectorEntry(GNEViewNet *viewNet, bool allowUndoRedo, GNEDetectorE3 *E3Parent, GNELane *lane, double pos, bool friendlyPos)
Builds a entry detector (E3)
#define WRITE_WARNING(msg)
void parseAndBuildVariableSpeedSign(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses his values and builds a Variable Speed Signal (lane speed trigger)
void parseAndBuildDetectorE2(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses his values and builds a lane area detector (E2)
void addRerouterInterval(GNERerouterInterval *rerouterInterval)
add rerouter interval
GNEUndoList * getUndoList() const
get the undoList object
~GNEAdditionalHandler()
Destructor.
double getLaneParametricLength() const
returns the parameteric length of the lane
void parseAndBuildCalibratorVehicleType(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses vehicle type values of Calibrators.
static bool buildRouteProbReroute(GNEViewNet *viewNet, bool allowUndoRedo, GNERerouterInterval *rerouterIntervalParent, const std::string &newRouteId, double probability)
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
void addAdditionalChild(GNEAdditional *additional)
add additional child to this edge
void parseAndBuildRerouterInterval(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses his values and builds a Rerouter Interval.
Encapsulated SAX-Attributes.
static bool isAbsolute(const std::string &path)
Returns the information whether the given path is absolute.
void p_end()
End undo command sub-group. If the sub-group is still empty, it will be deleted; otherwise, the sub-group will be added as a new command into parent group. A matching begin() must have been called previously.
A point in 2D or 3D with translation and scaling methods.
static bool buildRouteProbe(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, GNEEdge *edge, double freq, const std::string &file, double begin)
builds a Route probe
GNEAdditionalHandler(const std::string &file, GNEViewNet *viewNet, bool undoAdditionals=true)
Constructor.
void insertCalibratorRoute(GNECalibratorRoute *route)
insert Calibrator Route in net
virtual void centerTo(GUIGlID id, bool applyZoom, double zoomDist=20)
centers to the chosen artifact
void parseAndBuildRerouter(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses his values and builds a rerouter.
A calibrator placed over lane (used in netedit)
Representation of a vaporizer in netedit.
static bool checkGNELanesValid(GNENet *net, const std::string &value, bool report)
check if a list of Lane IDs is valid
void parseAndBuildCalibratorRoute(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses route values of Calibrators.
void addCalibratorRoute(GNECalibratorRoute *route)
add calibrator route
static bool buildCalibratorRoute(GNEViewNet *viewNet, bool allowUndoRedo, GNECalibrator *calibratorParent, const std::string &routeID, const std::vector< GNEEdge *> &edges, const RGBColor &color)
std::string myLastInsertedAdditionalParent
ID of last inserted Additional parent (needed for additionasl that own a child)
A lane area vehicles can halt at (netedit-version)
static bool buildCalibratorVehicleType(GNEViewNet *viewNet, bool allowUndoRedo, GNECalibrator *calibratorParent, std::string vehicleTypeID, double accel, double decel, double sigma, double tau, double length, double minGap, double maxSpeed, double speedFactor, double speedDev, const RGBColor &color, SUMOVehicleClass vClass, const std::string &emissionClass, SUMOVehicleShape shape, double width, const std::string &filename, double impatience, const std::string &laneChangeModel, const std::string &carFollowModel, int personCapacity, int containerCapacity, double boardingDuration, double loadingDuration, const std::string &latAlignment, double minGapLat, double maxSpeedLat)
static bool buildDetectorE2(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, GNELane *lane, double pos, double length, double freq, const std::string &filename, bool cont, const double timeThreshold, double speedThreshold, double jamThreshold, bool friendlyPos)
Builds a lane Area Detector (E2)
void insertCalibratorFlow(GNECalibratorFlow *flow)
insert Calibrator Flow in net
probability of route of a reroute
probability of destiny of a reroute
const std::string getID() const
function to support debugging
static bool buildChargingStation(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, GNELane *lane, double startPos, double endPos, const std::string &name, double chargingPower, double efficiency, bool chargeInTransit, double chargeDelay, bool friendlyPosition)
Builds a charging Station.
GNEViewNet * myViewNet
pointer to View's Net
void addRouteProbReroute(GNERouteProbReroute *routeProbabilityReroute)
add reoute probability reroute
GNECalibratorRoute * retrieveCalibratorRoute(const std::string &id, bool hardFail=true) const
Returns the named calibrator route.
double getLaneShapeLength() const
returns the length of the lane's shape
void parseAndBuildDetectorE3(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses his values and builds a multi entry exit detector (E3)
static bool buildCalibrator(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, GNELane *lane, double pos, const std::string &outfile, double freq)
builds a microscopic calibrator over a lane
void parseAndBuildRouteProbe(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses his values and builds routeProbe.
static bool buildVariableSpeedSignStep(GNEViewNet *viewNet, bool allowUndoRedo, GNEVariableSpeedSign *VSSParent, double time, double speed)
Builds a VariableSpeedSign Step.
void parseAndBuildRerouterDestProbReroute(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses his values and builds a Destiny Prob Reroute.
A road/street connecting two junctions (netedit-version)
void addCalibratorVehicleType(GNECalibratorVehicleType *vehicleType)
add calibrator vehicleType
void parseAndBuildCalibrator(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses his values and builds a mesoscopic or microscopic calibrator.
void parseAndBuildVariableSpeedSignStep(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses his values and builds a Variable Speed Signal Step.
static bool buildContainerStop(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, GNELane *lane, double startPos, double endPos, const std::string &name, const std::vector< std::string > &lines, bool friendlyPosition)
Builds a container stop.
void addCalibratorFlow(GNECalibratorFlow *flow)
add calibrator flow
trigger: the time of the step
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue, bool report=true) const
Tries to read given attribute assuming it is an int.
A train stop (alias for bus stop)
void parseAndBuildBusStop(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses his values and builds a bus stop.
void parseAndBuildContainerStop(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses his values and builds a container stop.
SUMOVehicleShape
Definition of vehicle classes to differ between different appearences.
static bool fixE2DetectorPositionPosition(double &pos, double &length, const double laneLength, const bool friendlyPos)
check if the position of a detector over a lane is valid
void parseAndBuildCalibratorFlow(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses flow values of Calibrators.
GNEAdditional * retrieveAdditional(const std::string &id, bool hardFail=true) const
Returns the named additional.
void parseAndBuildVaporizer(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Builds a vaporization.
GNECalibratorVehicleType * retrieveCalibratorVehicleType(const std::string &id, bool hardFail=true) const
Returns the named calibrator vehicle type.
static bool buildRerouter(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, Position pos, const std::vector< GNEEdge *> &edges, double prob, const std::string &file, bool off, double timeThreshold)
builds a rerouter
void parseAndBuildRerouterClosingLaneReroute(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses his values and builds a Closing Lane reroute.
GNENet * getNet() const
get the net object
GUIGlID getGlID() const
Returns the numerical id of the object.
an aggreagated-output interval
Eficiency of the charge in Charging Stations.
parent of an additional element
static bool buildDetectorE3(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, Position pos, double freq, const std::string &filename, const double timeThreshold, double speedThreshold)
Builds a multi entry exit detector (E3)
Delay in the charge of charging stations.
void addAdditionalChild(GNEAdditional *additional)
add additional child to this additional
static std::vector< GNELane * > parseGNELanes(GNENet *net, const std::string &value)
parse string into vector of GNELanes
static bool buildBusStop(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, GNELane *lane, double startPos, double endPos, const std::string &name, const std::vector< std::string > &lines, bool friendlyPosition)
Builds a bus stop.
A lane area vehicles can halt at (netedit-version)
static bool checkGNEEdgesValid(GNENet *net, const std::string &value, bool report)
check if a list of edge IDs is valid
void addClosingLaneReroute(GNEClosingLaneReroute *closingLaneReroute)
add closing reroute
static bool fixStoppinPlacePosition(double &startPos, double &endPos, const double laneLength, const double minLength, const bool friendlyPos)
check if the position of an stoppingPlace over a lane is valid
GNELane * retrieveLane(const std::string &id, bool failHard=true, bool checkVolatileChange=false)
get lane by id
void parseAndBuildDetectorEntry(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses his values and builds a Entry detector.
alternative tag for e3 detector
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 occured errors.
alternative tag for e2 detector
static bool buildDetectorExit(GNEViewNet *viewNet, bool allowUndoRedo, GNEDetectorE3 *E3Parent, GNELane *lane, double pos, bool friendlyPos)
Builds a exit detector (E3)
void addVariableSpeedSignStep(GNEVariableSpeedSignStep *step)
insert a new step in variable speed signal
static bool buildCalibratorFlow(GNEViewNet *viewNet, bool allowUndoRedo, GNECalibrator *calibratorParent, const std::string &flowID, GNECalibratorRoute *route, GNECalibratorVehicleType *vtype, const RGBColor &color, const std::string &departLane, const std::string &departPos, const std::string &departSpeed, const std::string &arrivalLane, const std::string &arrivalPos, const std::string &arrivalSpeed, const std::string &line, int personNumber, int containerNumber, bool reroute, const std::string &departPosLat, const std::string &arrivalPosLat, double begin, double end, double vehsPerHour, double period, double probability, int number, int flowType)
static bool buildDetectorE1(GNEViewNet *viewNet, bool allowUndoRedo, const std::string &id, GNELane *lane, double pos, double freq, const std::string &filename, const std::string &vehicleTypes, bool friendlyPos)
Builds a induction loop detector (E1)
GNECalibratorFlow * retrieveCalibratorFlow(const std::string &id, bool hardFail=true) const
Returns the named calibrator flow.
trigger: a step description
static bool buildRerouterInterval(GNEViewNet *viewNet, bool allowUndoRedo, GNERerouter *rerouterParent, double begin, double end)
builds a rerouter interval
void parseAndBuildRerouterClosingReroute(const SUMOSAXAttributes &attrs, const SumoXMLTag &tag)
Parses his values and builds a Closing Reroute.
SumoXMLTag getTag() const
get XML Tag assigned to this object