|
public static GetNodeSimulation ( ushort nodeId ) : |
||
| nodeId | ushort | |
| 리턴 | ||
public void SkipStep(bool setLights = true)
{
if (!isMasterNode())
{
return;
}
var newCurrentStep = (CurrentStep + 1) % NumSteps();
foreach (ushort slaveNodeId in NodeGroup)
{
TrafficLightSimulation slaveSim = TrafficLightSimulation.GetNodeSimulation(slaveNodeId);
if (slaveSim == null || !slaveSim.IsTimedLight())
{
continue;
}
slaveSim.TimedLight.Steps[CurrentStep].SetStepDone();
slaveSim.TimedLight.CurrentStep = newCurrentStep;
slaveSim.TimedLight.Steps[newCurrentStep].Start();
if (setLights)
{
slaveSim.TimedLight.Steps[newCurrentStep].SetLights();
}
}
}
internal TimedTrafficLights MasterLights()
{
TrafficLightSimulation masterSim = TrafficLightSimulation.GetNodeSimulation(masterNodeId);
if (masterSim == null || !masterSim.IsTimedLight())
{
return(null);
}
return(masterSim.TimedLight);
}
public void SetLights()
{
// set lights
foreach (ushort slaveNodeId in NodeGroup)
{
TrafficLightSimulation slaveSim = TrafficLightSimulation.GetNodeSimulation(slaveNodeId);
if (slaveSim == null || !slaveSim.IsTimedLight())
{
//TrafficLightSimulation.RemoveNodeFromSimulation(slaveNodeId, false); // we iterate over NodeGroup!!
continue;
}
slaveSim.TimedLight.Steps[CurrentStep].SetLights();
}
}
/// <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);
}
/// <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);
}
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];
}
}
}
public void SimulationStep()
{
var currentFrame = Singleton <SimulationManager> .instance.m_currentFrameIndex >> 5;
#if DEBUGTTL
Log._Debug($"TTL SimStep: currentFrame={currentFrame} lastSimulationStep={lastSimulationStep}");
#endif
if (lastSimulationStep >= currentFrame)
{
#if DEBUGTTL
Log._Debug($"TTL SimStep: *STOP* lastSimulationStep >= currentFrame");
#endif
return;
}
lastSimulationStep = currentFrame;
if (!isMasterNode() || !IsStarted())
{
#if DEBUGTTL
Log._Debug($"TTL SimStep: *STOP* isMasterNode={isMasterNode()} IsStarted={IsStarted()}");
#endif
return;
}
if (!housekeeping(false))
{
#if DEBUGTTL
Log.Warning($"TTL SimStep: *STOP* Housekeeping detected that this timed traffic light has become invalid: {NodeId}.");
#endif
Stop();
return;
}
if (!Steps[CurrentStep].isValid())
{
#if DEBUGTTL
Log._Debug($"TTL SimStep: *STOP* current step ({CurrentStep}) is not valid.");
#endif
TrafficLightSimulation.RemoveNodeFromSimulation(NodeId, false);
return;
}
#if DEBUGTTL
Log._Debug($"TTL SimStep: Setting lights (1)");
#endif
SetLights();
if (!Steps[CurrentStep].StepDone(true))
{
#if DEBUGTTL
Log._Debug($"TTL SimStep: *STOP* current step ({CurrentStep}) is not done.");
#endif
return;
}
// step is done
#if DEBUGTTL
Log._Debug($"TTL SimStep: Setting lights (2)");
#endif
SetLights();
if (!Steps[CurrentStep].isEndTransitionDone())
{
#if DEBUGTTL
Log._Debug($"TTL SimStep: *STOP* current step ({CurrentStep}): end transition is not done.");
#endif
return;
}
// ending transition (yellow) finished
#if DEBUGTTL
Log._Debug($"TTL SimStep: ending transition done. NodeGroup={string.Join(", ", NodeGroup.Select(x => x.ToString()).ToArray())}, nodeId={NodeId}, NumSteps={NumSteps()}");
#endif
// change step
var newCurrentStep = (CurrentStep + 1) % NumSteps();
foreach (ushort slaveNodeId in NodeGroup)
{
TrafficLightSimulation slaveSim = TrafficLightSimulation.GetNodeSimulation(slaveNodeId);
if (slaveSim == null || !slaveSim.IsTimedLight())
{
continue;
}
slaveSim.TimedLight.CurrentStep = newCurrentStep;
slaveSim.TimedLight.Steps[newCurrentStep].Start();
slaveSim.TimedLight.Steps[newCurrentStep].SetLights();
}
}