public TimedTrafficLightsStep(TimedTrafficLights timedNode, int minTime, int maxTime, float waitFlowBalance, bool makeRed = false)
{
this.minTime = minTime;
this.maxTime = maxTime;
this.waitFlowBalance = waitFlowBalance;
this.timedNode = timedNode;
minFlow = Single.NaN;
maxWait = Single.NaN;
endTransitionStart = null;
stepDone = false;
NodeGeometry nodeGeometry = NodeGeometry.Get(timedNode.NodeId);
foreach (SegmentEndGeometry end in nodeGeometry.SegmentEndGeometries)
{
if (end == null)
{
continue;
}
addSegment(end.SegmentId, end.StartNode, makeRed);
}
calcMaxSegmentLength();
}
public TimedTrafficLightsStep(TimedTrafficLights timedNode, int minTime, int maxTime, float waitFlowBalance, bool makeRed = false)
{
this.minTime = minTime;
this.maxTime = maxTime;
this.waitFlowBalance = waitFlowBalance;
this.timedNode = timedNode;
minFlow = Single.NaN;
maxWait = Single.NaN;
endTransitionStart = null;
stepDone = false;
for (var s = 0; s < 8; s++)
{
var segmentId = Singleton <NetManager> .instance.m_nodes.m_buffer[timedNode.NodeId].GetSegment(s);
if (segmentId <= 0)
{
continue;
}
addSegment(segmentId, makeRed);
}
calcMaxSegmentLength();
}
public void DestroyTimedTrafficLight() {
if (TimedLight != null)
TimedLight.Stop();
TimedLight = null;
if (!IsManualLight())
destroyLiveSegments();
}
public void SetupTimedTrafficLight(List<ushort> nodeGroup) {
if (IsManualLight())
DestroyManualTrafficLight();
TimedLight = new TimedTrafficLights(nodeId, nodeGroup);
setupLiveSegments();
}
public void SetupTimedTrafficLight(List <ushort> nodeGroup)
{
if (IsManualLight())
{
DestroyManualTrafficLight();
}
TimedLight = new TimedTrafficLights(NodeId, nodeGroup);
}
internal bool isInStartTransition()
{
if (!timedNode.isMasterNode())
{
TimedTrafficLights masterLights = timedNode.MasterLights();
if (masterLights != null)
{
return(timedNode.MasterLights().Steps[timedNode.CurrentStep].isInStartTransition());
}
}
return(getCurrentFrame() == startFrame && !StepDone(false));
}
/// <summary>
/// Checks if the green-to-red (=yellow) phase is currently active
/// </summary>
/// <returns></returns>
internal bool isInEndTransition()
{
if (!timedNode.isMasterNode())
{
TimedTrafficLights masterLights = timedNode.MasterLights();
if (masterLights != null)
{
return(masterLights.Steps[timedNode.CurrentStep].isInEndTransition());
}
}
return(endTransitionStart != null && getCurrentFrame() <= endTransitionStart && StepDone(false));
}
public void DestroyTimedTrafficLight()
{
if (TimedLight != null)
{
TimedLight.Stop();
}
TimedLight = null;
if (!IsManualLight())
{
destroyLiveSegments();
}
}
/// <summary>
/// Checks if the green-to-red (=yellow) phase is currently active
/// </summary>
/// <returns></returns>
internal bool IsInEndTransition()
{
if (!timedNode.IsMasterNode())
{
TimedTrafficLights masterLights = timedNode.MasterLights();
return(masterLights.Steps[masterLights.CurrentStep].IsInEndTransition());
}
bool isStepDone = StepDone(false);
bool ret = endTransitionStart != null && getCurrentFrame() <= endTransitionStart && isStepDone;
#if DEBUGTTL
Log._Debug($"TimedTrafficLightsStep.isInEndTransition() called for master NodeId={timedNode.NodeId}. CurrentStep={timedNode.CurrentStep} getCurrentFrame()={getCurrentFrame()} endTransitionStart={endTransitionStart} isStepDone={isStepDone} ret={ret}");
#endif
return(ret);
}
internal bool isInStartTransition()
{
if (!timedNode.isMasterNode())
{
TimedTrafficLights masterLights = timedNode.MasterLights();
if (masterLights != null)
{
return(timedNode.MasterLights().Steps[timedNode.CurrentStep].isInStartTransition());
}
}
bool isStepDone = StepDone(false);
bool ret = getCurrentFrame() == startFrame && !isStepDone;
#if DEBUGTTL
Log._Debug($"TimedTrafficLightsStep.isInStartTransition() called for master NodeId={timedNode.NodeId}. CurrentStep={timedNode.CurrentStep} getCurrentFrame()={getCurrentFrame()} startFrame={startFrame} isStepDone={isStepDone} ret={ret}");
#endif
return(ret);
}
public TimedTrafficLightsStep(TimedTrafficLights timedNode, int minTime, int maxTime, float waitFlowBalance, List<ushort> groupNodeIds, bool makeRed=false) {
this.minTime = minTime;
this.maxTime = maxTime;
this.waitFlowBalance = waitFlowBalance;
this.timedNode = timedNode;
this.groupNodeIds = groupNodeIds;
minFlow = Single.NaN;
maxWait = Single.NaN;
endTransitionStart = null;
stepDone = false;
for (var s = 0; s < 8; s++) {
var segmentId = Singleton<NetManager>.instance.m_nodes.m_buffer[timedNode.NodeId].GetSegment(s);
if (segmentId <= 0)
continue;
addSegment(segmentId, makeRed);
}
calcMaxSegmentLength();
}
public bool StepDone(bool updateValues)
{
#if TRACE
Singleton <CodeProfiler> .instance.Start("TimedTrafficLightsStep.StepDone");
#endif
if (timedNode.IsInTestMode())
{
#if TRACE
Singleton <CodeProfiler> .instance.Stop("TimedTrafficLightsStep.StepDone");
#endif
return(false);
}
if (stepDone)
{
#if TRACE
Singleton <CodeProfiler> .instance.Stop("TimedTrafficLightsStep.StepDone");
#endif
return(true);
}
if (getCurrentFrame() >= startFrame + maxTime)
{
// maximum time reached. switch!
#if DEBUG
//Log.Message("step finished @ " + nodeId);
#endif
stepDone = true;
endTransitionStart = getCurrentFrame();
#if TRACE
Singleton <CodeProfiler> .instance.Stop("TimedTrafficLightsStep.StepDone");
#endif
return(stepDone);
}
if (getCurrentFrame() >= startFrame + minTime)
{
if (!timedNode.isMasterNode())
{
TimedTrafficLights masterLights = timedNode.MasterLights();
if (masterLights == null)
{
invalid = true;
stepDone = true;
endTransitionStart = getCurrentFrame();
#if TRACE
Singleton <CodeProfiler> .instance.Stop("TimedTrafficLightsStep.StepDone");
#endif
return(true);
}
bool done = masterLights.Steps[masterLights.CurrentStep].StepDone(updateValues);
#if DEBUG
//Log.Message("step finished (1) @ " + nodeId);
#endif
stepDone = done;
if (stepDone)
{
endTransitionStart = getCurrentFrame();
}
#if TRACE
Singleton <CodeProfiler> .instance.Stop("TimedTrafficLightsStep.StepDone");
#endif
return(stepDone);
}
else
{
// we are the master node
float wait, flow;
uint curFrame = getCurrentFrame();
if (lastFlowWaitCalc < curFrame)
{
if (!calcWaitFlow(out wait, out flow))
{
stepDone = true;
endTransitionStart = getCurrentFrame();
#if TRACE
Singleton <CodeProfiler> .instance.Stop("TimedTrafficLightsStep.StepDone");
#endif
return(stepDone);
}
else
{
lastFlowWaitCalc = curFrame;
}
}
else
{
flow = minFlow;
wait = maxWait;
}
float newFlow = minFlow;
float newWait = maxWait;
#if DEBUGMETRIC
newFlow = flow;
newWait = wait;
#else
if (Single.IsNaN(newFlow))
{
newFlow = flow;
}
else
{
newFlow = 0.1f * newFlow + 0.9f * flow; // some smoothing
}
if (Single.IsNaN(newWait))
{
newWait = 0;
}
else
{
newWait = 0.1f * newWait + 0.9f * wait; // some smoothing
}
#endif
// if more cars are waiting than flowing, we change the step
#if DEBUGMETRIC
bool done = false;
#else
bool done = newWait > 0 && newFlow < newWait;
#endif
if (updateValues)
{
minFlow = newFlow;
maxWait = newWait;
}
#if DEBUG
//Log.Message("step finished (2) @ " + nodeId);
#endif
if (updateValues)
{
stepDone = done;
}
if (stepDone)
{
endTransitionStart = getCurrentFrame();
}
#if TRACE
Singleton <CodeProfiler> .instance.Stop("TimedTrafficLightsStep.StepDone");
#endif
return(stepDone);
}
}
#if TRACE
Singleton <CodeProfiler> .instance.Stop("TimedTrafficLightsStep.StepDone");
#endif
return(false);
}
internal void Join(TimedTrafficLights otherTimedLight) {
if (NumSteps() < otherTimedLight.NumSteps()) {
// increase the number of steps at our timed lights
for (int i = NumSteps(); i < otherTimedLight.NumSteps(); ++i) {
TimedTrafficLightsStep otherStep = otherTimedLight.GetStep(i);
foreach (ushort slaveNodeId in NodeGroup) {
TrafficLightSimulation ourSim = TrafficLightSimulation.GetNodeSimulation(slaveNodeId);
if (ourSim == null || !ourSim.IsTimedLight())
continue;
TimedTrafficLights ourTimedLight = ourSim.TimedLight;
ourTimedLight.AddStep(otherStep.minTime, otherStep.maxTime, otherStep.waitFlowBalance, true);
}
}
} else {
// increase the number of steps at their timed lights
for (int i = otherTimedLight.NumSteps(); i < NumSteps(); ++i) {
TimedTrafficLightsStep ourStep = GetStep(i);
foreach (ushort slaveNodeId in otherTimedLight.NodeGroup) {
TrafficLightSimulation theirSim = TrafficLightSimulation.GetNodeSimulation(slaveNodeId);
if (theirSim == null || !theirSim.IsTimedLight())
continue;
TimedTrafficLights theirTimedLight = theirSim.TimedLight;
theirTimedLight.AddStep(ourStep.minTime, ourStep.maxTime, ourStep.waitFlowBalance, true);
}
}
}
// join groups and re-defined master node, determine mean min/max times & mean wait-flow-balances
HashSet<ushort> newNodeGroupSet = new HashSet<ushort>();
newNodeGroupSet.UnionWith(NodeGroup);
newNodeGroupSet.UnionWith(otherTimedLight.NodeGroup);
List<ushort> newNodeGroup = new List<ushort>(newNodeGroupSet);
ushort newMasterNodeId = newNodeGroup[0];
int[] minTimes = new int[NumSteps()];
int[] maxTimes = new int[NumSteps()];
float[] waitFlowBalances = new float[NumSteps()];
foreach (ushort timedNodeId in newNodeGroup) {
TrafficLightSimulation timedSim = TrafficLightSimulation.GetNodeSimulation(timedNodeId);
if (timedSim == null || !timedSim.IsTimedLight())
continue;
TimedTrafficLights timedLight = timedSim.TimedLight;
for (int i = 0; i < NumSteps(); ++i) {
minTimes[i] += timedLight.GetStep(i).minTime;
maxTimes[i] += timedLight.GetStep(i).maxTime;
waitFlowBalances[i] += timedLight.GetStep(i).waitFlowBalance;
}
timedLight.NodeGroup = newNodeGroup;
timedLight.masterNodeId = newMasterNodeId;
}
// build means
if (NumSteps() > 0) {
for (int i = 0; i < NumSteps(); ++i) {
minTimes[i] = Math.Max(1, minTimes[i] / newNodeGroup.Count);
maxTimes[i] = Math.Max(1, maxTimes[i] / newNodeGroup.Count);
waitFlowBalances[i] = Math.Max(0.001f, waitFlowBalances[i] / (float)newNodeGroup.Count);
}
}
// apply means & reset
foreach (ushort timedNodeId in newNodeGroup) {
TrafficLightSimulation timedSim = TrafficLightSimulation.GetNodeSimulation(timedNodeId);
if (timedSim == null || !timedSim.IsTimedLight())
continue;
TimedTrafficLights timedLight = timedSim.TimedLight;
timedLight.Stop();
timedLight.testMode = false;
timedLight.lastSimulationStep = 0;
for (int i = 0; i < NumSteps(); ++i) {
timedLight.GetStep(i).minTime = minTimes[i];
timedLight.GetStep(i).maxTime = maxTimes[i];
timedLight.GetStep(i).waitFlowBalance = waitFlowBalances[i];
}
}
}
/// <summary>
/// Calculates the current metrics for flowing and waiting vehicles
/// </summary>
/// <param name="wait"></param>
/// <param name="flow"></param>
/// <returns>true if the values could be calculated, false otherwise</returns>
public bool calcWaitFlow(out float wait, out float flow)
{
#if TRACE
Singleton <CodeProfiler> .instance.Start("TimedTrafficLightsStep.calcWaitFlow");
#endif
#if DEBUGMETRIC
bool debug = timedNode.NodeId == 3201;
#else
bool debug = false;
#endif
#if DEBUGMETRIC
if (debug)
{
Log.Warning($"TimedTrafficLightsStep.calcWaitFlow: ***START*** @ node {timedNode.NodeId}");
}
#endif
uint numFlows = 0;
uint numWaits = 0;
uint curMeanFlow = 0;
uint curMeanWait = 0;
// we are the master node. calculate traffic data
foreach (ushort timedNodeId in timedNode.NodeGroup)
{
TrafficLightSimulation sim = TrafficLightSimulation.GetNodeSimulation(timedNodeId);
if (sim == null || !sim.IsTimedLight())
{
continue;
}
TimedTrafficLights slaveTimedNode = sim.TimedLight;
if (slaveTimedNode.NumSteps() <= timedNode.CurrentStep)
{
for (int i = 0; i < slaveTimedNode.NumSteps(); ++i)
{
slaveTimedNode.GetStep(i).invalid = true;
}
continue;
}
TimedTrafficLightsStep slaveStep = slaveTimedNode.Steps[timedNode.CurrentStep];
//List<int> segmentIdsToDelete = new List<int>();
// minimum time reached. check traffic!
foreach (KeyValuePair <ushort, CustomSegmentLights> e in slaveStep.segmentLights)
{
var fromSegmentId = e.Key;
var segLights = e.Value;
// one of the traffic lights at this segment is green: count minimum traffic flowing through
SegmentEnd fromSeg = TrafficPriority.GetPrioritySegment(timedNodeId, fromSegmentId);
if (fromSeg == null)
{
#if DEBUGMETRIC
if (debug)
{
Log.Warning($"TimedTrafficLightsStep.calcWaitFlow: No priority segment @ seg. {fromSegmentId} found!");
}
#endif
//Log.Warning("stepDone(): prioSeg is null");
//segmentIdsToDelete.Add(fromSegmentId);
continue; // skip invalid segment
}
//bool startPhase = getCurrentFrame() <= startFrame + minTime + 2; // during start phase all vehicles on "green" segments are counted as flowing
ExtVehicleType validVehicleTypes = VehicleRestrictionsManager.GetAllowedVehicleTypes(fromSegmentId, timedNode.NodeId);
foreach (KeyValuePair <byte, ExtVehicleType> e2 in segLights.VehicleTypeByLaneIndex)
{
byte laneIndex = e2.Key;
ExtVehicleType vehicleType = e2.Value;
if (vehicleType != ExtVehicleType.None && (validVehicleTypes & vehicleType) == ExtVehicleType.None)
{
continue;
}
CustomSegmentLight segLight = segLights.GetCustomLight(laneIndex);
if (segLight == null)
{
Log.Warning($"Timed traffic light step: Failed to get custom light for vehicleType {vehicleType} @ seg. {fromSegmentId}, node {timedNode.NodeId}!");
continue;
}
#if DEBUGMETRIC
if (debug)
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: Checking lane {laneIndex} @ seg. {fromSegmentId}. Vehicle types: {vehicleType}");
}
#endif
Dictionary <ushort, uint> carsFlowingToSegmentMetric = null;
Dictionary <ushort, uint> allCarsToSegmentMetric = null;
try {
carsFlowingToSegmentMetric = fromSeg.GetVehicleMetricGoingToSegment(false, laneIndex, debug);
} catch (Exception ex) {
Log.Warning("calcWaitFlow (1): " + ex.ToString());
}
try {
allCarsToSegmentMetric = fromSeg.GetVehicleMetricGoingToSegment(true, laneIndex, debug);
} catch (Exception ex) {
Log.Warning("calcWaitFlow (2): " + ex.ToString());
}
if (carsFlowingToSegmentMetric == null)
{
continue;
}
// build directions from toSegment to fromSegment
Dictionary <ushort, Direction> directions = new Dictionary <ushort, Direction>();
foreach (KeyValuePair <ushort, uint> f in allCarsToSegmentMetric)
{
var toSegmentId = f.Key;
SegmentGeometry geometry = SegmentGeometry.Get(fromSegmentId);
Direction dir = geometry.GetDirection(toSegmentId, timedNodeId == geometry.StartNodeId());
directions[toSegmentId] = dir;
#if DEBUGMETRIC
if (debug)
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: Calculated direction for seg. {fromSegmentId} -> seg. {toSegmentId}: {dir}");
}
#endif
}
// calculate waiting/flowing traffic
foreach (KeyValuePair <ushort, uint> f in allCarsToSegmentMetric)
{
ushort toSegmentId = f.Key;
uint totalNormCarLength = f.Value;
uint totalFlowingNormCarLength = carsFlowingToSegmentMetric[f.Key];
#if DEBUGMETRIC
if (debug)
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: Total norm. car length of vehicles on lane {laneIndex} going to seg. {toSegmentId}: {totalNormCarLength}");
}
#endif
bool addToFlow = false;
switch (directions[toSegmentId])
{
case Direction.Turn:
addToFlow = TrafficPriority.IsLeftHandDrive() ? segLight.isRightGreen() : segLight.isLeftGreen();
break;
case Direction.Left:
addToFlow = segLight.isLeftGreen();
break;
case Direction.Right:
addToFlow = segLight.isRightGreen();
break;
case Direction.Forward:
default:
addToFlow = segLight.isForwardGreen();
break;
}
if (addToFlow)
{
++numFlows;
curMeanFlow += totalFlowingNormCarLength;
}
else
{
++numWaits;
curMeanWait += totalNormCarLength;
}
#if DEBUGMETRIC
if (debug)
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: Vehicles on lane {laneIndex} on seg. {fromSegmentId} going to seg. {toSegmentId} flowing? {addToFlow} curMeanFlow={curMeanFlow}, curMeanWait={curMeanWait}");
}
#endif
}
}
}
// delete invalid segments from step
/*foreach (int segmentId in segmentIdsToDelete) {
* slaveStep.segmentLightStates.Remove(segmentId);
* }*/
if (slaveStep.segmentLights.Count <= 0)
{
invalid = true;
flow = 0f;
wait = 0f;
#if TRACE
Singleton <CodeProfiler> .instance.Stop("TimedTrafficLightsStep.calcWaitFlow");
#endif
return(false);
}
}
#if DEBUGMETRIC
if (debug)
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: ### Calculation completed. numFlows={numFlows}, numWaits={numWaits}, curMeanFlow={curMeanFlow}, curMeanWait={curMeanWait}");
}
wait = curMeanWait;
flow = curMeanFlow;
#else
if (numFlows > 0)
{
curMeanFlow /= numFlows;
}
if (numWaits > 0)
{
curMeanWait /= numWaits;
}
float fCurMeanFlow = curMeanFlow;
fCurMeanFlow /= waitFlowBalance; // a value smaller than 1 rewards steady traffic currents
wait = (float)curMeanWait;
flow = fCurMeanFlow;
#endif
#if TRACE
Singleton <CodeProfiler> .instance.Stop("TimedTrafficLightsStep.calcWaitFlow");
#endif
return(true);
}
public bool StepDone(bool updateValues)
{
if (!timedNode.IsMasterNode())
{
TimedTrafficLights masterLights = timedNode.MasterLights();
return(masterLights.Steps[masterLights.CurrentStep].StepDone(updateValues));
}
// we are the master node
if (timedNode.IsInTestMode())
{
return(false);
}
if (stepDone)
{
return(true);
}
if (getCurrentFrame() >= startFrame + maxTime)
{
// maximum time reached. switch!
#if DEBUG
//Log.Message("step finished @ " + nodeId);
#endif
if (!stepDone && updateValues)
{
stepDone = true;
endTransitionStart = getCurrentFrame();
}
return(stepDone);
}
if (getCurrentFrame() >= startFrame + minTime)
{
float wait, flow;
uint curFrame = getCurrentFrame();
//Log._Debug($"TTL @ {timedNode.NodeId}: curFrame={curFrame} lastFlowWaitCalc={lastFlowWaitCalc}");
if (lastFlowWaitCalc < curFrame)
{
//Log._Debug($"TTL @ {timedNode.NodeId}: lastFlowWaitCalc<curFrame");
if (!calcWaitFlow(true, timedNode.CurrentStep, out wait, out flow))
{
//Log._Debug($"TTL @ {timedNode.NodeId}: calcWaitFlow failed!");
if (!stepDone && updateValues)
{
//Log._Debug($"TTL @ {timedNode.NodeId}: !stepDone && updateValues");
stepDone = true;
endTransitionStart = getCurrentFrame();
}
return(stepDone);
}
else
{
if (updateValues)
{
lastFlowWaitCalc = curFrame;
//Log._Debug($"TTL @ {timedNode.NodeId}: updated lastFlowWaitCalc=curFrame={curFrame}");
}
}
}
else
{
flow = minFlow;
wait = maxWait;
//Log._Debug($"TTL @ {timedNode.NodeId}: lastFlowWaitCalc>=curFrame wait={maxWait} flow={minFlow}");
}
float newFlow = minFlow;
float newWait = maxWait;
#if DEBUGMETRIC
newFlow = flow;
newWait = wait;
#else
if (Single.IsNaN(newFlow))
{
newFlow = flow;
}
else
{
newFlow = 0.1f * newFlow + 0.9f * flow; // some smoothing
}
if (Single.IsNaN(newWait))
{
newWait = 0;
}
else
{
newWait = 0.1f * newWait + 0.9f * wait; // some smoothing
}
#endif
// if more cars are waiting than flowing, we change the step
bool done = newWait > 0 && newFlow < newWait;
//Log._Debug($"TTL @ {timedNode.NodeId}: newWait={newWait} newFlow={newFlow} updateValues={updateValues} stepDone={stepDone} done={done}");
if (updateValues)
{
minFlow = newFlow;
maxWait = newWait;
//Log._Debug($"TTL @ {timedNode.NodeId}: updated minFlow=newFlow={minFlow} maxWait=newWait={maxWait}");
}
#if DEBUG
//Log.Message("step finished (2) @ " + nodeId);
#endif
if (updateValues && !stepDone && done)
{
stepDone = done;
endTransitionStart = getCurrentFrame();
}
return(stepDone);
}
return(false);
}
internal void Join(TimedTrafficLights otherTimedLight)
{
TrafficLightSimulationManager tlsMan = TrafficLightSimulationManager.Instance();
if (NumSteps() < otherTimedLight.NumSteps())
{
// increase the number of steps at our timed lights
for (int i = NumSteps(); i < otherTimedLight.NumSteps(); ++i)
{
TimedTrafficLightsStep otherStep = otherTimedLight.GetStep(i);
foreach (ushort slaveNodeId in NodeGroup)
{
TrafficLightSimulation ourSim = tlsMan.GetNodeSimulation(slaveNodeId);
if (ourSim == null || !ourSim.IsTimedLight())
{
continue;
}
TimedTrafficLights ourTimedLight = ourSim.TimedLight;
ourTimedLight.AddStep(otherStep.minTime, otherStep.maxTime, otherStep.waitFlowBalance, true);
}
}
}
else
{
// increase the number of steps at their timed lights
for (int i = otherTimedLight.NumSteps(); i < NumSteps(); ++i)
{
TimedTrafficLightsStep ourStep = GetStep(i);
foreach (ushort slaveNodeId in otherTimedLight.NodeGroup)
{
TrafficLightSimulation theirSim = tlsMan.GetNodeSimulation(slaveNodeId);
if (theirSim == null || !theirSim.IsTimedLight())
{
continue;
}
TimedTrafficLights theirTimedLight = theirSim.TimedLight;
theirTimedLight.AddStep(ourStep.minTime, ourStep.maxTime, ourStep.waitFlowBalance, true);
}
}
}
// join groups and re-defined master node, determine mean min/max times & mean wait-flow-balances
HashSet <ushort> newNodeGroupSet = new HashSet <ushort>();
newNodeGroupSet.UnionWith(NodeGroup);
newNodeGroupSet.UnionWith(otherTimedLight.NodeGroup);
List <ushort> newNodeGroup = new List <ushort>(newNodeGroupSet);
ushort newMasterNodeId = newNodeGroup[0];
int[] minTimes = new int[NumSteps()];
int[] maxTimes = new int[NumSteps()];
float[] waitFlowBalances = new float[NumSteps()];
foreach (ushort timedNodeId in newNodeGroup)
{
TrafficLightSimulation timedSim = tlsMan.GetNodeSimulation(timedNodeId);
if (timedSim == null || !timedSim.IsTimedLight())
{
continue;
}
TimedTrafficLights timedLight = timedSim.TimedLight;
for (int i = 0; i < NumSteps(); ++i)
{
minTimes[i] += timedLight.GetStep(i).minTime;
maxTimes[i] += timedLight.GetStep(i).maxTime;
waitFlowBalances[i] += timedLight.GetStep(i).waitFlowBalance;
}
timedLight.NodeGroup = newNodeGroup;
timedLight.masterNodeId = newMasterNodeId;
}
// build means
if (NumSteps() > 0)
{
for (int i = 0; i < NumSteps(); ++i)
{
minTimes[i] = Math.Max(1, minTimes[i] / newNodeGroup.Count);
maxTimes[i] = Math.Max(1, maxTimes[i] / newNodeGroup.Count);
waitFlowBalances[i] = Math.Max(0.001f, waitFlowBalances[i] / (float)newNodeGroup.Count);
}
}
// apply means & reset
foreach (ushort timedNodeId in newNodeGroup)
{
TrafficLightSimulation timedSim = tlsMan.GetNodeSimulation(timedNodeId);
if (timedSim == null || !timedSim.IsTimedLight())
{
continue;
}
TimedTrafficLights timedLight = timedSim.TimedLight;
timedLight.Stop();
timedLight.testMode = false;
timedLight.lastSimulationStep = 0;
for (int i = 0; i < NumSteps(); ++i)
{
timedLight.GetStep(i).minTime = minTimes[i];
timedLight.GetStep(i).maxTime = maxTimes[i];
timedLight.GetStep(i).waitFlowBalance = waitFlowBalances[i];
}
}
}
/// <summary>
/// Calculates the current metrics for flowing and waiting vehicles
/// </summary>
/// <param name="wait"></param>
/// <param name="flow"></param>
/// <returns>true if the values could be calculated, false otherwise</returns>
public bool calcWaitFlow(out float wait, out float flow)
{
#if DEBUG
bool debug = timedNode.NodeId == 17857;
#else
bool debug = false;
#endif
uint numFlows = 0;
uint numWaits = 0;
uint curMeanFlow = 0;
uint curMeanWait = 0;
// we are the master node. calculate traffic data
foreach (ushort timedNodeId in groupNodeIds)
{
TrafficLightSimulation sim = TrafficLightSimulation.GetNodeSimulation(timedNodeId);
if (sim == null || !sim.IsTimedLight())
{
continue;
}
TimedTrafficLights slaveTimedNode = sim.TimedLight;
if (slaveTimedNode.NumSteps() <= timedNode.CurrentStep)
{
for (int i = 0; i < slaveTimedNode.NumSteps(); ++i)
{
slaveTimedNode.GetStep(i).invalid = true;
}
continue;
}
TimedTrafficLightsStep slaveStep = slaveTimedNode.Steps[timedNode.CurrentStep];
//List<int> segmentIdsToDelete = new List<int>();
// minimum time reached. check traffic!
foreach (KeyValuePair <ushort, CustomSegmentLights> e in slaveStep.segmentLights)
{
var fromSegmentId = e.Key;
var segLights = e.Value;
// one of the traffic lights at this segment is green: count minimum traffic flowing through
SegmentEnd fromSeg = TrafficPriority.GetPrioritySegment(timedNodeId, fromSegmentId);
if (fromSeg == null)
{
//Log.Warning("stepDone(): prioSeg is null");
//segmentIdsToDelete.Add(fromSegmentId);
continue; // skip invalid segment
}
bool startPhase = getCurrentFrame() <= startFrame + minTime + 2; // during start phase all vehicles on "green" segments are counted as flowing
ExtVehicleType validVehicleTypes = VehicleRestrictionsManager.GetAllowedVehicleTypes(fromSegmentId, timedNode.NodeId);
foreach (ExtVehicleType vehicleType in segLights.VehicleTypes)
{
if (vehicleType != ExtVehicleType.None && (validVehicleTypes & vehicleType) == ExtVehicleType.None)
{
continue;
}
CustomSegmentLight segLight = segLights.GetCustomLight(vehicleType);
if (segLight == null)
{
Log.Warning($"Timed traffic light step: Failed to get custom light for vehicleType {vehicleType} @ seg. {fromSegmentId}, node {timedNode.NodeId}!");
continue;
}
Dictionary <ushort, uint>[] carsToSegmentMetrics = new Dictionary <ushort, uint> [startPhase ? 1: 2];
try {
carsToSegmentMetrics[0] = fromSeg.GetVehicleMetricGoingToSegment(null, vehicleType, segLights.SeparateVehicleTypes, debug);
} catch (Exception ex) {
Log.Warning("calcWaitFlow: " + ex.ToString());
}
if (!startPhase)
{
try {
carsToSegmentMetrics[1] = fromSeg.GetVehicleMetricGoingToSegment(0.1f, vehicleType, segLights.SeparateVehicleTypes, debug);
} catch (Exception ex) {
Log.Warning("calcWaitFlow: " + ex.ToString());
}
}
if (carsToSegmentMetrics[0] == null)
{
continue;
}
// build directions from toSegment to fromSegment
Dictionary <ushort, Direction> directions = new Dictionary <ushort, Direction>();
foreach (KeyValuePair <ushort, uint> f in carsToSegmentMetrics[0])
{
var toSegmentId = f.Key;
SegmentGeometry geometry = CustomRoadAI.GetSegmentGeometry(fromSegmentId);
Direction dir = geometry.GetDirection(toSegmentId, timedNodeId);
directions[toSegmentId] = dir;
}
// calculate waiting/flowing traffic
for (int i = 0; i < carsToSegmentMetrics.Length; ++i)
{
if (carsToSegmentMetrics[i] == null)
{
continue;
}
foreach (KeyValuePair <ushort, uint> f in carsToSegmentMetrics[i])
{
ushort toSegmentId = f.Key;
uint totalNormCarLength = f.Value;
bool addToFlow = false;
switch (directions[toSegmentId])
{
case Direction.Left:
if (segLight.isLeftGreen())
{
addToFlow = true;
}
break;
case Direction.Right:
if (segLight.isRightGreen())
{
addToFlow = true;
}
break;
case Direction.Forward:
default:
if (segLight.isForwardGreen())
{
addToFlow = true;
}
break;
}
if (addToFlow)
{
if (i > 0 || startPhase)
{
++numFlows;
curMeanFlow += totalNormCarLength;
}
}
else if (i == 0)
{
++numWaits;
curMeanWait += totalNormCarLength;
}
}
}
}
}
// delete invalid segments from step
/*foreach (int segmentId in segmentIdsToDelete) {
* slaveStep.segmentLightStates.Remove(segmentId);
* }*/
if (slaveStep.segmentLights.Count <= 0)
{
invalid = true;
flow = 0f;
wait = 0f;
return(false);
}
}
if (numFlows > 0)
{
curMeanFlow /= numFlows;
}
if (numWaits > 0)
{
curMeanWait /= numWaits;
}
float fCurMeanFlow = curMeanFlow;
fCurMeanFlow /= 100f * waitFlowBalance; // a value smaller than 1 rewards steady traffic currents
wait = (float)curMeanWait / 100f;
flow = fCurMeanFlow;
return(true);
}
public bool StepDone(bool updateValues)
{
if (timedNode.IsInTestMode())
{
return(false);
}
if (stepDone)
{
return(true);
}
if (getCurrentFrame() >= startFrame + maxTime)
{
// maximum time reached. switch!
#if DEBUG
//Log.Message("step finished @ " + nodeId);
#endif
stepDone = true;
endTransitionStart = getCurrentFrame();
return(stepDone);
}
if (getCurrentFrame() >= startFrame + minTime)
{
if (timedNode.masterNodeId != timedNode.NodeId)
{
TrafficLightSimulation masterSim = TrafficLightSimulation.GetNodeSimulation(timedNode.masterNodeId);
if (masterSim == null || !masterSim.IsTimedLight())
{
invalid = true;
stepDone = true;
endTransitionStart = getCurrentFrame();
return(true);
}
TimedTrafficLights masterTimedNode = masterSim.TimedLight;
bool done = masterTimedNode.Steps[masterTimedNode.CurrentStep].StepDone(updateValues);
#if DEBUG
//Log.Message("step finished (1) @ " + nodeId);
#endif
stepDone = done;
if (stepDone)
{
endTransitionStart = getCurrentFrame();
}
return(stepDone);
}
else
{
// we are the master node
float wait, flow;
uint curFrame = getCurrentFrame();
if (lastFlowWaitCalc < curFrame)
{
if (!calcWaitFlow(out wait, out flow))
{
stepDone = true;
endTransitionStart = getCurrentFrame();
return(stepDone);
}
else
{
lastFlowWaitCalc = curFrame;
}
}
else
{
flow = minFlow;
wait = maxWait;
}
float newFlow = minFlow;
float newWait = maxWait;
if (Single.IsNaN(newFlow))
{
newFlow = flow;
}
else
{
newFlow = 0.1f * newFlow + 0.9f * flow; // some smoothing
}
if (Single.IsNaN(newWait))
{
newWait = 0;
}
else
{
newWait = 0.1f * newWait + 0.9f * wait; // some smoothing
}
// if more cars are waiting than flowing, we change the step
bool done = newWait > 0 && newFlow < newWait;
if (updateValues)
{
minFlow = newFlow;
maxWait = newWait;
}
#if DEBUG
//Log.Message("step finished (2) @ " + nodeId);
#endif
if (updateValues)
{
stepDone = done;
}
if (stepDone)
{
endTransitionStart = getCurrentFrame();
}
return(stepDone);
}
}
return(false);
}
/// <summary>
/// Calculates the current metrics for flowing and waiting vehicles
/// </summary>
/// <param name="wait"></param>
/// <param name="flow"></param>
/// <returns>true if the values could be calculated, false otherwise</returns>
public bool calcWaitFlow(bool onlyMoving, int stepRefIndex, out float wait, out float flow)
{
uint numFlows = 0;
uint numWaits = 0;
uint curMeanFlow = 0;
uint curMeanWait = 0;
// TODO checking agains getCurrentFrame() is only valid if this is the current step
if (onlyMoving && getCurrentFrame() <= startFrame + minTime + 1) // during start phase all vehicles on "green" segments are counted as flowing
{
onlyMoving = false;
}
TrafficLightSimulationManager tlsMan = TrafficLightSimulationManager.Instance;
TrafficPriorityManager prioMan = TrafficPriorityManager.Instance;
foreach (ushort timedNodeId in timedNode.NodeGroup)
{
TrafficLightSimulation sim = tlsMan.GetNodeSimulation(timedNodeId);
if (sim == null || !sim.IsTimedLight())
{
continue;
}
TimedTrafficLights slaveTimedNode = sim.TimedLight;
TimedTrafficLightsStep slaveStep = slaveTimedNode.Steps[stepRefIndex];
//List<int> segmentIdsToDelete = new List<int>();
// minimum time reached. check traffic!
foreach (KeyValuePair <ushort, CustomSegmentLights> e in slaveStep.segmentLights)
{
var sourceSegmentId = e.Key;
var segLights = e.Value;
#if DEBUGMETRIC
bool debug = sourceSegmentId == 20857 && GlobalConfig.Instance.DebugSwitches[1];
#elif DEBUG
bool debug = GlobalConfig.Instance.DebugSwitches[7] && GlobalConfig.Instance.TTLDebugNodeId == timedNodeId;
#else
bool debug = false;
#endif
Dictionary <ushort, ArrowDirection> directions = null;
if (slaveStep.timedNode.Directions.ContainsKey(sourceSegmentId))
{
directions = slaveStep.timedNode.Directions[sourceSegmentId];
}
else
{
#if DEBUG
if (debug)
{
Log._Debug($"calcWaitFlow: No arrow directions defined for segment {sourceSegmentId} @ {timedNodeId}");
}
#endif
continue;
}
// one of the traffic lights at this segment is green: count minimum traffic flowing through
SegmentEnd sourceSegmentEnd = prioMan.GetPrioritySegment(timedNodeId, sourceSegmentId);
if (sourceSegmentEnd == null)
{
Log.Warning($"TimedTrafficLightsStep.calcWaitFlow: No priority segment @ seg. {sourceSegmentId} found!");
continue; // skip invalid segment
}
ExtVehicleType validVehicleTypes = VehicleRestrictionsManager.Instance.GetAllowedVehicleTypes(sourceSegmentId, timedNode.NodeId);
foreach (KeyValuePair <byte, ExtVehicleType> e2 in segLights.VehicleTypeByLaneIndex)
{
byte laneIndex = e2.Key;
ExtVehicleType vehicleType = e2.Value;
if (vehicleType != ExtVehicleType.None && (validVehicleTypes & vehicleType) == ExtVehicleType.None)
{
continue;
}
CustomSegmentLight segLight = segLights.GetCustomLight(laneIndex);
if (segLight == null)
{
Log.Warning($"Timed traffic light step: Failed to get custom light for vehicleType {vehicleType} @ seg. {sourceSegmentId}, node {timedNode.NodeId}!");
continue;
}
#if DEBUG
if (debug)
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: Checking lane {laneIndex} @ seg. {sourceSegmentId}. Vehicle types: {vehicleType}");
}
#endif
Dictionary <ushort, uint> carsFlowingToSegmentMetric = null;
Dictionary <ushort, uint> allCarsToSegmentMetric = null;
bool evalFlowingVehicles = segLight.IsAnyGreen(); // flowing vehicle need only to be evaluated if a light is green
if (evalFlowingVehicles && onlyMoving)
{
carsFlowingToSegmentMetric = sourceSegmentEnd.GetVehicleMetricGoingToSegment(false, laneIndex, debug);
}
allCarsToSegmentMetric = sourceSegmentEnd.GetVehicleMetricGoingToSegment(true, laneIndex, debug);
// calculate waiting/flowing traffic
foreach (KeyValuePair <ushort, uint> f in allCarsToSegmentMetric)
{
ushort targetSegmentId = f.Key;
uint totalNumCars = f.Value;
if (!directions.ContainsKey(targetSegmentId))
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: Direction undefined for target segment {targetSegmentId} @ {timedNodeId}");
continue;
}
if (evalFlowingVehicles)
{
uint totalNumFlowingCars = onlyMoving ? carsFlowingToSegmentMetric[f.Key] : totalNumCars;
#if DEBUG
if (debug)
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: Total num of flowing cars on seg. {sourceSegmentId}, lane {laneIndex} going to seg. {targetSegmentId}: {totalNumFlowingCars}");
}
#endif
bool addToFlow = false;
switch (directions[targetSegmentId])
{
case ArrowDirection.Turn:
addToFlow = TrafficPriorityManager.IsLeftHandDrive() ? segLight.IsRightGreen() : segLight.IsLeftGreen();
break;
case ArrowDirection.Left:
addToFlow = segLight.IsLeftGreen();
break;
case ArrowDirection.Right:
addToFlow = segLight.IsRightGreen();
break;
case ArrowDirection.Forward:
default:
addToFlow = segLight.IsMainGreen();
break;
}
if (addToFlow)
{
curMeanFlow += totalNumFlowingCars;
++numFlows;
}
else
{
curMeanWait += totalNumCars;
++numWaits;
}
}
else
{
curMeanWait += totalNumCars;
++numWaits;
}
#if DEBUG
if (debug)
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: Vehicles on lane {laneIndex} on seg. {sourceSegmentId} going to seg. {targetSegmentId} curMeanFlow={curMeanFlow}, curMeanWait={curMeanWait}, numFlows={numFlows}, numWaits={numWaits}");
}
#endif
}
}
}
}
/*if (numFlows > 0)
* curMeanFlow /= numFlows;
* if (numWaits > 0)
* curMeanWait /= numWaits;*/
float fCurMeanFlow = numFlows > 0 ? (float)curMeanFlow / (float)numFlows : 0;
float fCurMeanWait = numWaits > 0 ? (float)curMeanWait / (float)numWaits : 0;
fCurMeanFlow /= waitFlowBalance; // a value smaller than 1 rewards steady traffic currents
wait = (float)fCurMeanWait;
flow = fCurMeanFlow;
return(true);
}
public void SimulationStep()
{
// TODO [version 1.9] this method is currently called on each node, but should be called on the master node only
if (!IsMasterNode() || !IsStarted())
{
#if DEBUGTTL
Log._Debug($"TTL SimStep: *STOP* NodeId={NodeId} isMasterNode={isMasterNode()} IsStarted={IsStarted()}");
#endif
return;
}
// we are the master node
/*if (!housekeeping()) {
#if DEBUGTTL
* Log.Warning($"TTL SimStep: *STOP* NodeId={NodeId} Housekeeping detected that this timed traffic light has become invalid: {NodeId}.");
#endif
* Stop();
* return;
* }*/
#if DEBUGTTL
Log._Debug($"TTL SimStep: NodeId={NodeId} Setting lights (1)");
#endif
SetLights();
if (!Steps[CurrentStep].StepDone(true))
{
#if DEBUGTTL
Log._Debug($"TTL SimStep: *STOP* NodeId={NodeId} current step ({CurrentStep}) is not done.");
#endif
return;
}
// step is done
#if DEBUGTTL
Log._Debug($"TTL SimStep: NodeId={NodeId} Setting lights (2)");
#endif
#if DEBUG
bool debug = GlobalConfig.Instance.DebugSwitches[7] && GlobalConfig.Instance.TTLDebugNodeId == NodeId;
#endif
TrafficLightSimulationManager tlsMan = TrafficLightSimulationManager.Instance;
if (Steps[CurrentStep].NextStepRefIndex < 0)
{
#if DEBUG
if (debug)
{
Log._Debug($"Step {CurrentStep} is done at timed light {NodeId}. Determining next step.");
}
#endif
// next step has not yet identified yet. check for minTime=0 steps
int nextStepIndex = (CurrentStep + 1) % NumSteps();
if (Steps[nextStepIndex].minTime == 0)
{
// next step has minTime=0. calculate flow/wait ratios and compare.
int prevStepIndex = CurrentStep;
float maxWaitFlowDiff = Steps[CurrentStep].minFlow - Steps[CurrentStep].maxWait;
if (float.IsNaN(maxWaitFlowDiff))
{
maxWaitFlowDiff = float.MinValue;
}
int bestNextStepIndex = prevStepIndex;
#if DEBUG
if (debug)
{
Log._Debug($"Next step {nextStepIndex} has minTime = 0 at timed light {NodeId}. Old step {CurrentStep} has waitFlowDiff={maxWaitFlowDiff} (flow={Steps[CurrentStep].minFlow}, wait={Steps[CurrentStep].maxWait}).");
}
#endif
while (nextStepIndex != prevStepIndex)
{
float wait;
float flow;
Steps[nextStepIndex].calcWaitFlow(false, nextStepIndex, out wait, out flow);
float flowWaitDiff = flow - wait;
if (flowWaitDiff > maxWaitFlowDiff)
{
maxWaitFlowDiff = flowWaitDiff;
bestNextStepIndex = nextStepIndex;
}
#if DEBUG
if (debug)
{
Log._Debug($"Checking upcoming step {nextStepIndex} @ node {NodeId}: flow={flow} wait={wait} minTime={Steps[nextStepIndex].minTime}. bestWaitFlowDiff={bestNextStepIndex}, bestNextStepIndex={bestNextStepIndex}");
}
#endif
if (Steps[nextStepIndex].minTime != 0)
{
break;
}
nextStepIndex = (nextStepIndex + 1) % NumSteps();
}
if (bestNextStepIndex == CurrentStep)
{
#if DEBUG
if (debug)
{
Log._Debug($"Best next step {bestNextStepIndex} (wait/flow diff = {maxWaitFlowDiff}) equals CurrentStep @ node {NodeId}.");
}
#endif
// restart the current step
foreach (ushort slaveNodeId in NodeGroup)
{
TrafficLightSimulation slaveSim = tlsMan.GetNodeSimulation(slaveNodeId);
if (slaveSim == null || !slaveSim.IsTimedLight())
{
continue;
}
slaveSim.TimedLight.Steps[CurrentStep].Start(CurrentStep);
slaveSim.TimedLight.Steps[CurrentStep].UpdateLiveLights();
}
return;
}
else
{
#if DEBUG
if (debug)
{
Log._Debug($"Best next step {bestNextStepIndex} (wait/flow diff = {maxWaitFlowDiff}) does not equal CurrentStep @ node {NodeId}.");
}
#endif
// set next step reference index for assuring a correct end transition
foreach (ushort slaveNodeId in NodeGroup)
{
TrafficLightSimulation slaveSim = tlsMan.GetNodeSimulation(slaveNodeId);
if (slaveSim == null || !slaveSim.IsTimedLight())
{
continue;
}
TimedTrafficLights timedLights = slaveSim.TimedLight;
timedLights.Steps[CurrentStep].NextStepRefIndex = bestNextStepIndex;
}
}
}
else
{
Steps[CurrentStep].NextStepRefIndex = nextStepIndex;
}
}
SetLights(); // check if this is needed
if (!Steps[CurrentStep].IsEndTransitionDone())
{
#if DEBUGTTL
Log._Debug($"TTL SimStep: *STOP* NodeId={NodeId} current step ({CurrentStep}): end transition is not done.");
#endif
return;
}
// ending transition (yellow) finished
#if DEBUGTTL
Log._Debug($"TTL SimStep: NodeId={NodeId} ending transition done. NodeGroup={string.Join(", ", NodeGroup.Select(x => x.ToString()).ToArray())}, nodeId={NodeId}, NumSteps={NumSteps()}");
#endif
// change step
int newStepIndex = Steps[CurrentStep].NextStepRefIndex;
int oldStepIndex = CurrentStep;
foreach (ushort slaveNodeId in NodeGroup)
{
TrafficLightSimulation slaveSim = tlsMan.GetNodeSimulation(slaveNodeId);
if (slaveSim == null || !slaveSim.IsTimedLight())
{
continue;
}
TimedTrafficLights timedLights = slaveSim.TimedLight;
timedLights.CurrentStep = newStepIndex;
#if DEBUGTTL
Log._Debug($"TTL SimStep: NodeId={slaveNodeId} setting lgihts of next step: {CurrentStep}");
#endif
timedLights.Steps[oldStepIndex].NextStepRefIndex = -1;
timedLights.Steps[newStepIndex].Start(oldStepIndex);
timedLights.Steps[newStepIndex].UpdateLiveLights();
}
}
