public void AddModel(Model model)
{
if (_storage.ContainsKey(model.Segment) == false)
_storage.Add(model.Segment, model);
else
_storage[model.Segment] = model;
}
/// <summary>
/// Performs analysis of the travel times on the specific segment and creates it's model
/// </summary>
/// <param name="travelTimes"></param>
/// <param name="segment"></param>
/// <returns></returns>
public Model Analyze(IEnumerable<TravelTime> travelTimes, SegmentInfo segment)
{
List<TravelTime> filteredTravelTimes = new List<TravelTime>();
foreach (var tt in travelTimes) {
if (tt.Stops.Where(stop => stop.Length.TotalMinutes > Properties.Settings.Default.MaximalAllowedStopLength).Count() > 0)
continue;
filteredTravelTimes.Add(tt);
}
if (filteredTravelTimes.Count < Properties.Settings.Default.FreeflowMinimalCount)
return null;
Model result = new Model();
result.Segment = segment;
// Free-flow time
result.FreeFlowTravelTime = EstimateFreeFlowTime(filteredTravelTimes);
// traffic signals delay
if (_map.Nodes[segment.NodeToID].Tags.ContainsTag("highway") && _map.Nodes[segment.NodeToID].Tags["highway"].Value == "traffic_signals") {
result.TrafficSignalsDelay = EstimateTafficSignalsDelay(filteredTravelTimes, segment);
}
// traffic delay
EstimateTrafficDelay(filteredTravelTimes, result);
return result;
}
/// <summary>
/// Estimates traffic delay from the collection of travel times
/// </summary>
/// <param name="travelTimes"></param>
/// <param name="model"></param>
void EstimateTrafficDelay(IEnumerable<TravelTime> travelTimes, Model model)
{
List<TravelTimeDelay> delays = new List<TravelTimeDelay>();
foreach (var traveltime in travelTimes) {
double delay = 0;
if (model.TrafficSignalsDelay.Probability > 0 && traveltime.Stops.Count > 0)
delay = traveltime.TotalTravelTime.TotalSeconds - model.FreeFlowTravelTime - traveltime.Stops.Last().Length.TotalSeconds;
else
delay = traveltime.TotalTravelTime.TotalSeconds - model.FreeFlowTravelTime;
delay = Math.Max(0, delay);
delays.Add(new TravelTimeDelay() { TravelTime = traveltime, Delay = delay });
}
// avg delay as median of delays
delays.Sort(new Comparison<TravelTimeDelay>((TravelTimeDelay td1, TravelTimeDelay td2) => td1.Delay.CompareTo(td2.Delay)));
model.AvgDelay = delays[delays.Count / 2].Delay;
TrafficDelayMap delaysMap = new TrafficDelayMap(Properties.Settings.Default.ModelResolution, model.FreeFlowTravelTime);
List<List<TravelTimeDelay>> travelTimeClusters = null;
DBScan<TravelTimeDelay> clusterAnalyzer = new DBScan<TravelTimeDelay>(new DBScan<TravelTimeDelay>.FindNeighbours(FindNeighbours));
for (int i = _parameters.Length -1; i >= 0; i--) {
_parametersIndex = i;
int desiredClusterSize = (int)Math.Max(Properties.Settings.Default.MinimalClusterSize, travelTimes.Count() * Properties.Settings.Default.ClusterSizePercentage / 100.0);
int clusterSize = Math.Min(travelTimes.Count(), desiredClusterSize);
travelTimeClusters = clusterAnalyzer.ClusterAnalysis(delays, clusterSize);
foreach (var cluster in travelTimeClusters) {
TrafficDelayInfo delayInfo = new TrafficDelayInfo();
if (_parameters[_parametersIndex].Dates == DatesHandling.Any)
delayInfo.AppliesTo = DayOfWeek.Any;
else if (_parameters[_parametersIndex].Dates == DatesHandling.WeekendWorkdays)
delayInfo.AppliesTo = (DayOfWeek.Workday & DayOfWeekHelper.FromDate(cluster[0].TravelTime.TimeStart)) > 0 ? DayOfWeek.Workday : DayOfWeek.Weekend;
else
delayInfo.AppliesTo = DayOfWeekHelper.FromDate(cluster[0].TravelTime.TimeStart);
cluster.Sort(new Comparison<TravelTimeDelay>((TravelTimeDelay td1, TravelTimeDelay td2) => td1.Delay.CompareTo(td2.Delay)));
delayInfo.Delay = cluster.Sum(tt => tt.Delay) / cluster.Count;
delayInfo.From = cluster.Min(tt => tt.TravelTime.TimeStart.TimeOfDay).Subtract(new TimeSpan(0, _parameters[_parametersIndex].MembersTimeDifference / 2, 0));
if (delayInfo.From < new TimeSpan(0))
delayInfo.From = new TimeSpan(0);
delayInfo.To = cluster.Max(tt => tt.TravelTime.TimeEnd.TimeOfDay).Add(new TimeSpan(0, _parameters[_parametersIndex].MembersTimeDifference / 2, 0));
if (delayInfo.To > new TimeSpan(23, 59, 59)) {
delayInfo.To = new TimeSpan(23, 59, 59);
}
delaysMap.AddDelay(delayInfo.From, delayInfo.To, delayInfo.AppliesTo, delayInfo.Delay);
}
if (travelTimeClusters.Sum(cluster => cluster.Count) > Properties.Settings.Default.ClusterAnalysisStopPercentage * delays.Count / 100)
break;
}
model.TrafficDelay.AddRange(delaysMap.GetDelays());
}
private void ReadModel()
{
SegmentInfo segment = new SegmentInfo();
string attFrom = _xmlReader.GetAttribute("node-from");
if (attFrom == null)
throw new XmlException("Attribute 'from' is missing.");
segment.NodeFromID = int.Parse(attFrom);
string attTo = _xmlReader.GetAttribute("node-to");
if (attTo == null)
throw new XmlException("Attribute 'to' is missing.");
segment.NodeToID = int.Parse(attTo);
string attWay = _xmlReader.GetAttribute("way");
if (attFrom == null)
throw new XmlException("Attribute 'way' is missing.");
segment.WayID = int.Parse(attWay);
Model model = new Model();
model.Segment = segment;
string attFreeFlow = _xmlReader.GetAttribute("freeflow");
if(attFreeFlow == null)
throw new XmlException("Attribute 'freeflow' is missing.");
model.FreeFlowTravelTime = double.Parse(attFreeFlow, System.Globalization.CultureInfo.InvariantCulture);
string attAvgDelay = _xmlReader.GetAttribute("avg-delay");
if (attAvgDelay == null)
throw new XmlException("Attribute 'avg-delay' is missing.");
model.AvgDelay = double.Parse(attAvgDelay, System.Globalization.CultureInfo.InvariantCulture);
string attSignalsDelay = _xmlReader.GetAttribute("signals-delay");
string attSignalProbability = _xmlReader.GetAttribute("signals-prob");
if (attSignalsDelay != null && attSignalProbability != null)
model.TrafficSignalsDelay = new TrafficSignalsDelayInfo() {
Length = double.Parse(attSignalsDelay, System.Globalization.CultureInfo.InvariantCulture),
Probability = double.Parse(attSignalProbability, System.Globalization.CultureInfo.InvariantCulture)
};
if (false == _xmlReader.IsEmptyElement) {
_xmlReader.Read();
while (_xmlReader.NodeType != XmlNodeType.EndElement) {
switch (_xmlReader.NodeType) {
case XmlNodeType.Element:
switch (_xmlReader.Name) {
case "traffic-delay":
model.TrafficDelay.Add(ReadTrafficDelay());
continue;
default:
_xmlReader.Skip();
continue;
}
default:
_xmlReader.Skip();
break;
}
}
}
_storage.Add(segment, model);
_xmlReader.Skip();
}
