public Model GetModel(SegmentInfo segment)
{
if (_storage.ContainsKey(segment))
return _storage[segment];
else
return null;
}
/// <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>
/// Creates a new instance of the TravelTime object
/// </summary>
/// <param name="start"></param>
/// <param name="end"></param>
/// <param name="points"></param>
public TravelTime(SegmentInfo segment, DateTime start, DateTime end)
{
_segment = segment;
_timeStart = start;
_timeEnd = end;
_stops = new List<Stop>();
}
public void FromMatchedTrackIgnoresFirstAndLastIncompleteSegments()
{
OSMDB track = new OSMDB();
track.Load(new MemoryStream(TestData.osm_2_complete_segments));
var target = TravelTime.FromMatchedTrack(track).ToList();
Assert.Equal(2, target.Count());
SegmentInfo expectedFirstSegment = new SegmentInfo() { NodeFromID = 411888806, NodeToID = 415814332, WayID = 36881783 };
SegmentInfo expectedSecondSegment = new SegmentInfo() { NodeFromID = 415814332, NodeToID = 74165639, WayID = 36881783 };
Assert.Equal(expectedFirstSegment, target[0].Segment);
Assert.Equal(expectedSecondSegment, target[1].Segment);
}
/// <summary>
/// Creates a new instance ot the TravelTime object
/// </summary>
/// <param name="segment"></param>
/// <param name="start"></param>
/// <param name="end"></param>
/// <param name="stops"></param>
public TravelTime(SegmentInfo segment, DateTime start, DateTime end, IEnumerable<Stop> stops)
{
_segment = segment;
_timeStart = start;
_timeEnd = end;
_stops = new List<Stop>();
_stops.AddRange(stops);
}
/// <summary>
/// Creates a list of travel times from the matched track
/// </summary>
/// <param name="track"></param>
/// <returns></returns>
public static IEnumerable<TravelTime> FromMatchedTrack(OSMDB track)
{
List<TravelTime> result = new List<TravelTime>();
var orderedWays = track.Ways.OrderBy(way => int.Parse(way.Tags["order"].Value)).ToList();
//Find start of the first segment
int index = 0;
while (index < orderedWays.Count && track.Nodes[orderedWays[index].Nodes[0]].Tags.ContainsTag("crossroad") == false)
index++;
while (index < orderedWays.Count) {
int startNodeId = int.Parse(track.Nodes[orderedWays[index].Nodes[0]].Tags["node-id"].Value);
DateTime segmentStartTime = DateTime.MinValue;
if (track.Nodes[orderedWays[index].Nodes[0]].Tags.ContainsTag("time"))
segmentStartTime = DateTime.Parse(track.Nodes[orderedWays[index].Nodes[0]].Tags["time"].Value);
else
segmentStartTime = InterpolateStartTime(track, orderedWays, index);
List<GPXPoint> points = new List<GPXPoint>();
points.Add(new GPXPoint(track.Nodes[orderedWays[index].Nodes[0]].Latitude, track.Nodes[orderedWays[index].Nodes[0]].Longitude, segmentStartTime));
while (index < orderedWays.Count && track.Nodes[orderedWays[index].Nodes.Last()].Tags.ContainsTag("crossroad") == false) {
if (track.Nodes[orderedWays[index].Nodes.Last()].Tags.ContainsTag("time")) {
points.Add(new GPXPoint(track.Nodes[orderedWays[index].Nodes.Last()].Latitude, track.Nodes[orderedWays[index].Nodes.Last()].Longitude,
DateTime.Parse(track.Nodes[orderedWays[index].Nodes.Last()].Tags["time"].Value)));
}
index++;
}
if (index < orderedWays.Count) {
int endNodeId = int.Parse(track.Nodes[orderedWays[index].Nodes.Last()].Tags["node-id"].Value);
DateTime segmentEndTime = DateTime.MinValue;
if (track.Nodes[orderedWays[index].Nodes.Last()].Tags.ContainsTag("time"))
segmentEndTime = DateTime.Parse(track.Nodes[orderedWays[index].Nodes.Last()].Tags["time"].Value);
else
segmentEndTime = InterpolateEndTime(track, orderedWays, index);
points.Add(new GPXPoint(track.Nodes[orderedWays[index].Nodes.Last()].Latitude, track.Nodes[orderedWays[index].Nodes.Last()].Longitude, segmentEndTime));
int wayId = int.Parse(orderedWays[index].Tags["way-id"].Value);
SegmentInfo segment = new SegmentInfo() { NodeFromID = startNodeId, NodeToID = endNodeId, WayID = wayId };
List<double> avgSpeeds = new List<double>();
for (int i = 0; i < points.Count -1; i++) {
avgSpeeds.Add(Calculations.GetDistance2D(points[i], points[i + 1]) / (points[i + 1].Time - points[i].Time).TotalSeconds);
}
TravelTime tt = new TravelTime(segment, segmentStartTime, segmentEndTime);
int ii = 0;
while (ii < avgSpeeds.Count) {
if (avgSpeeds[ii] < 1.0) {
Stop stop = new Stop() { From = points[ii].Time };
while (ii < avgSpeeds.Count && avgSpeeds[ii] < 1.0)
ii++;
stop.To = points[ii].Time;
tt.Stops.Add(stop);
}
ii++;
}
result.Add(tt);
index++;
}
}
return result;
}
void WriteSegment(SegmentInfo segment)
{
_xmlWriter.WriteStartElement("segment");
_xmlWriter.WriteAttributeString("from", segment.NodeFromID.ToString());
_xmlWriter.WriteAttributeString("to", segment.NodeToID.ToString());
_xmlWriter.WriteAttributeString("way", segment.WayID.ToString());
foreach (var traveltime in _storage[segment]) {
WriteTravelTime(traveltime);
}
_xmlWriter.WriteEndElement();
}
private TravelTime ReadTravelTime(SegmentInfo segment)
{
string attStart = _xmlReader.GetAttribute("start");
if (attStart == null)
throw new XmlException("Attribute 'start' is missing.");
DateTime start = DateTime.Parse(attStart);
string attEnd = _xmlReader.GetAttribute("end");
if (attStart == null)
throw new XmlException("Attribute 'end' is missing.");
DateTime end = DateTime.Parse(attEnd);
List<Stop> stops = new List<Stop>();
if (false == _xmlReader.IsEmptyElement) {
_xmlReader.Read();
while (_xmlReader.NodeType != XmlNodeType.EndElement) {
switch (_xmlReader.NodeType) {
case XmlNodeType.Element:
switch (_xmlReader.Name) {
case "stop":
stops.Add(ReadStop());
continue;
default:
_xmlReader.Skip();
continue;
}
default:
_xmlReader.Skip();
break;
}
}
}
_xmlReader.Skip();
return new TravelTime(segment, start, end, stops);
}
/// <summary>
/// Returns collection of travel times for the specific segmnet
/// </summary>
/// <param name="segment"></param>
/// <returns></returns>
public IEnumerable<TravelTime> GetTravelTimes(SegmentInfo segment)
{
return _storage[segment];
}
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();
}
/// <summary>
/// Creates a list of travel times from the matched track
/// </summary>
/// <param name="track"></param>
/// <returns></returns>
public static IEnumerable <TravelTime> FromMatchedTrack(OSMDB track)
{
List <TravelTime> result = new List <TravelTime>();
var orderedWays = track.Ways.OrderBy(way => int.Parse(way.Tags["order"].Value)).ToList();
//Find start of the first segment
int index = 0;
while (index < orderedWays.Count && track.Nodes[orderedWays[index].Nodes[0]].Tags.ContainsTag("crossroad") == false)
{
index++;
}
while (index < orderedWays.Count)
{
int startNodeId = int.Parse(track.Nodes[orderedWays[index].Nodes[0]].Tags["node-id"].Value);
DateTime segmentStartTime = DateTime.MinValue;
if (track.Nodes[orderedWays[index].Nodes[0]].Tags.ContainsTag("time"))
{
segmentStartTime = DateTime.Parse(track.Nodes[orderedWays[index].Nodes[0]].Tags["time"].Value);
}
else
{
segmentStartTime = InterpolateStartTime(track, orderedWays, index);
}
List <GPXPoint> points = new List <GPXPoint>();
points.Add(new GPXPoint(track.Nodes[orderedWays[index].Nodes[0]].Latitude, track.Nodes[orderedWays[index].Nodes[0]].Longitude, segmentStartTime));
while (index < orderedWays.Count && track.Nodes[orderedWays[index].Nodes.Last()].Tags.ContainsTag("crossroad") == false)
{
if (track.Nodes[orderedWays[index].Nodes.Last()].Tags.ContainsTag("time"))
{
points.Add(new GPXPoint(track.Nodes[orderedWays[index].Nodes.Last()].Latitude, track.Nodes[orderedWays[index].Nodes.Last()].Longitude,
DateTime.Parse(track.Nodes[orderedWays[index].Nodes.Last()].Tags["time"].Value)));
}
index++;
}
if (index < orderedWays.Count)
{
int endNodeId = int.Parse(track.Nodes[orderedWays[index].Nodes.Last()].Tags["node-id"].Value);
DateTime segmentEndTime = DateTime.MinValue;
if (track.Nodes[orderedWays[index].Nodes.Last()].Tags.ContainsTag("time"))
{
segmentEndTime = DateTime.Parse(track.Nodes[orderedWays[index].Nodes.Last()].Tags["time"].Value);
}
else
{
segmentEndTime = InterpolateEndTime(track, orderedWays, index);
}
points.Add(new GPXPoint(track.Nodes[orderedWays[index].Nodes.Last()].Latitude, track.Nodes[orderedWays[index].Nodes.Last()].Longitude, segmentEndTime));
int wayId = int.Parse(orderedWays[index].Tags["way-id"].Value);
SegmentInfo segment = new SegmentInfo()
{
NodeFromID = startNodeId, NodeToID = endNodeId, WayID = wayId
};
List <double> avgSpeeds = new List <double>();
for (int i = 0; i < points.Count - 1; i++)
{
avgSpeeds.Add(Calculations.GetDistance2D(points[i], points[i + 1]) / (points[i + 1].Time - points[i].Time).TotalSeconds);
}
TravelTime tt = new TravelTime(segment, segmentStartTime, segmentEndTime);
int ii = 0;
while (ii < avgSpeeds.Count)
{
if (avgSpeeds[ii] < 1.0)
{
Stop stop = new Stop()
{
From = points[ii].Time
};
while (ii < avgSpeeds.Count && avgSpeeds[ii] < 1.0)
{
ii++;
}
stop.To = points[ii].Time;
tt.Stops.Add(stop);
}
ii++;
}
result.Add(tt);
index++;
}
}
return(result);
}
void WriteModel(SegmentInfo segment)
{
Model model = _storage[segment];
if (model.FreeFlowTravelTime == 0)
return;
_xmlWriter.WriteStartElement("model");
_xmlWriter.WriteAttributeString("node-from", segment.NodeFromID.ToString());
_xmlWriter.WriteAttributeString("node-to", segment.NodeToID.ToString());
_xmlWriter.WriteAttributeString("way", segment.WayID.ToString());
_xmlWriter.WriteAttributeString("freeflow", model.FreeFlowTravelTime.ToString("F1", System.Globalization.CultureInfo.InvariantCulture));
_xmlWriter.WriteAttributeString("avg-delay", model.AvgDelay.ToString("F1", System.Globalization.CultureInfo.InvariantCulture));
if (model.TrafficSignalsDelay.Probability > 0) {
_xmlWriter.WriteAttributeString("signals-delay", model.TrafficSignalsDelay.Length.ToString("F1", System.Globalization.CultureInfo.InvariantCulture));
_xmlWriter.WriteAttributeString("signals-prob", model.TrafficSignalsDelay.Probability.ToString("F2", System.Globalization.CultureInfo.InvariantCulture));
}
foreach (var delay in model.TrafficDelay) {
WriteDelay(delay);
}
_xmlWriter.WriteEndElement();
}
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();
}
public void FromMatchedTrackProcessesTrackThatStartsAndEndsWithCompleteSegments()
{
OSMDB track = new OSMDB();
track.Load(new MemoryStream(TestData.osm_2_segments_without_incolmpete_parts));
var target = TravelTime.FromMatchedTrack(track).ToList();
Assert.Equal(2, target.Count());
SegmentInfo expectedFirstSegment = new SegmentInfo() { NodeFromID = 411888806, NodeToID = 415814332, WayID = 36881783 };
SegmentInfo expectedSecondSegment = new SegmentInfo() { NodeFromID = 415814332, NodeToID = 74165639, WayID = 36881783 };
Assert.Equal(expectedFirstSegment, target[0].Segment);
Assert.Equal(expectedSecondSegment, target[1].Segment);
}
/// <summary>
/// Estimates traffic signals delay from the collection of travel times
/// </summary>
/// <param name="travelTimes"></param>
/// <param name="segment"></param>
/// <returns></returns>
TrafficSignalsDelayInfo EstimateTafficSignalsDelay(IEnumerable<TravelTime> travelTimes, SegmentInfo segment)
{
int totalStops = travelTimes.Where(tt => tt.Stops.Count > 0).Count();
double totalStopsLength = travelTimes.Where(tt => tt.Stops.Count > 0).Sum(tt => tt.Stops.Last().Length.TotalSeconds);
if (totalStops > 0)
return new TrafficSignalsDelayInfo() { Probability = (double)totalStops / travelTimes.Count(), Length = totalStopsLength / totalStops };
else
return new TrafficSignalsDelayInfo() { Probability = 0, Length = 0 };
}
/// <summary>
/// Reads an OSMTag from the XmlTextReader and reurn it.
/// </summary>
/// <returns>The OSMTag read form the XmlTextReader</returns>
private void ReadSegment()
{
SegmentInfo segment = new SegmentInfo();
string attFrom = _xmlReader.GetAttribute("from");
if (attFrom == null)
throw new XmlException("Attribute 'from' is missing.");
segment.NodeFromID = int.Parse(attFrom);
string attTo = _xmlReader.GetAttribute("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);
_storage.Add(segment, new List<TravelTime>());
if (false == _xmlReader.IsEmptyElement) {
_xmlReader.Read();
while (_xmlReader.NodeType != XmlNodeType.EndElement) {
switch (_xmlReader.NodeType) {
case XmlNodeType.Element:
switch (_xmlReader.Name) {
case "travel-time":
_storage[segment].Add(ReadTravelTime(segment));
continue;
default:
_xmlReader.Skip();
continue;
}
default:
_xmlReader.Skip();
break;
}
}
}
_xmlReader.Skip();
}
public void FromMatchedTrackProcessesTrackWithManySegmentsSegments()
{
OSMDB track = new OSMDB();
track.Load(new MemoryStream(TestData.osm_5_segments));
var target = TravelTime.FromMatchedTrack(track).ToList();
Assert.Equal(5, target.Count());
SegmentInfo expectedFirstSegment = new SegmentInfo() { NodeFromID = 411888806, NodeToID = 415814332, WayID = 36881783 };
SegmentInfo expectedSecondSegment = new SegmentInfo() { NodeFromID = 415814332, NodeToID = 74165639, WayID = 36881783 };
SegmentInfo expectedThirdSegment = new SegmentInfo() { NodeFromID = 74165639, NodeToID = 320275336, WayID = 29115419 };
SegmentInfo expectedFourthSegment = new SegmentInfo() { NodeFromID = 320275336, NodeToID = 415814335, WayID = 29115419 };
SegmentInfo expectedFifthSegment = new SegmentInfo() { NodeFromID = 415814335, NodeToID = 415814327, WayID = 29115419 };
Assert.Equal(expectedFirstSegment, target[0].Segment);
Assert.Equal(expectedSecondSegment, target[1].Segment);
Assert.Equal(expectedThirdSegment, target[2].Segment);
Assert.Equal(expectedFourthSegment, target[3].Segment);
Assert.Equal(expectedFifthSegment, target[4].Segment);
}
