//includes end
public static List <TPoint2D> Approximate(Trajectory2D trajectory, double epsilon)
{
var approximation = Approximate(trajectory, 0, trajectory.Count - 1, epsilon);
approximation.Add(trajectory.Last());
return(approximation);
}
//excludes end
public static List <TPoint2D> Approximate(Trajectory2D trajectory, int start, int end, double epsilon)
{
var firstPoint = trajectory[start];
var lastPoint = trajectory[end];
var approximation = new List <TPoint2D>();
if (end > start)
{
double distance;
var split = GetSplit(trajectory, start, end, out distance);
if (distance > epsilon)
{
var firstHalf = Approximate(trajectory, start, split, epsilon);
var lastHalf = Approximate(trajectory, split, end, epsilon);
approximation.AddRange(firstHalf);
approximation.AddRange(lastHalf);
}
else
{
approximation.Add(firstPoint);
//newTrajectory.Add(lastPoint);
}
}
else
{
approximation.Add(firstPoint);
//newTrajectory.Add(lastPoint);
}
return(approximation);
}
private ShortcutGraph(Trajectory2D Trajectory, JDictionary <Shortcut, int> shortcutWeights) : this(Trajectory)
{
foreach (var pair in shortcutWeights)
{
AddShortcut(pair.Key, pair.Value);
}
}
public void LookAtTrajectory(Trajectory2D trajectory)
{
if (trajectory.Count > 0)
{
var bb = trajectory.BuildBoundingBox();
gMap.SetZoomToFitRect(new RectLatLng(bb.MaxY, bb.MinX, bb.Width, bb.Height));
}
}
public MSSInput(Trajectory2D Trajectory, List <double> Epsilons) : base(Trajectory, Epsilons)
{
this.Epsilons = Epsilons;
PrunedPoints = new HashSet <TPoint2D>();
SearchIntervals = null;
Cumulative = false;
}
public SPFInput(Trajectory2D Trajectory, IShortcutSet ShortcutSet, TPoint2D Source, JHashSet <TPoint2D> Targets, bool CreatePath = true)
{
this.Trajectory = Trajectory;
this.ShortcutSet = ShortcutSet;
this.Source = Source;
this.Targets = Targets;
this.CreatePath = CreatePath;
}
public override void Compute(MSInput input, out MSOutput output)
{
output = new MSOutput();
var trajectory = input.Trajectory;
ShortcutProvider.Init(input, output, false);
LinkedList <TPoint2D> prevShortestPath = null;
for (var level = input.NumLevels; level >= 1; level--)
{
var epsilon = input.GetEpsilon(level);
var levelShortcuts = ShortcutProvider.GetShortcuts(level, epsilon);
LinkedList <TPoint2D> shortestPath;
if (prevShortestPath == null)
{
var pointPath = ShortestPathProvider.FindShortestPath(levelShortcuts, trajectory.First(), trajectory.Last());
shortestPath = pointPath.Points;
}
else
{
shortestPath = new LinkedList <TPoint2D>();
var prevPoint = trajectory.First();
foreach (var point in prevShortestPath)
{
if (point == trajectory.First())
{
continue;
}
var pointPath = ShortestPathProvider.FindShortestPath(levelShortcuts, prevPoint, point);
foreach (var p in pointPath.Points)
{
shortestPath.AddLast(p);
}
prevPoint = point;
}
}
shortestPath.AddFirst(trajectory.First());
var newTrajectory = new Trajectory2D(shortestPath);
//report shortest path
//output.LogObject("Level Shortest Path", levelTrajectory);
output.LogLine("Level " + level + " trajectory found. Length: " + newTrajectory.Count);
output.SetTrajectoryAtLevel(level, newTrajectory);
prevShortestPath = shortestPath;
ShortcutProvider.SetSearchIntervals(shortestPath);
}
}
public ShortcutIntervalSet(Trajectory2D trajectory)
{
Trajectory = trajectory;
IntervalMap = new JDictionary <TPoint2D, LinkedList <Interval> >();
foreach (var point in Trajectory)
{
IntervalMap[point] = new LinkedList <Interval>();
}
}
public void DrawTrajectory(Trajectory2D trajectory)
{
var points = trajectory.Select(point => new PointLatLng(point.Y, point.X)).ToList();
var route = new GMapRoute(points, "points")
{
Stroke = { Color = Color.Black, Width = 2 }
};
routesOverlay.Routes.Add(route);
}
protected void DrawTrajectoryEdges(Trajectory2D trajectory, float lineWidth, Color color)
{
GL.LineWidth(lineWidth);
GL.Color3(color);
GL.Begin(PrimitiveType.LineStrip);
foreach (TPoint2D p in trajectory)
{
GL.Vertex3(p.X, p.Y, -1f);
}
GL.End();
}
public static double GetMinEpsilon(Trajectory2D trajectory, int start, int end)
{
var maxDistance = 0.0;
for (var k = start + 1; k < end; k++)
{
var point = trajectory[k];
maxDistance = Math.Max(maxDistance, Geometry2D.Distance(trajectory[start], trajectory[end], point));
}
return(maxDistance);
}
public ShortcutGraph(Trajectory2D trajectory)
{
Trajectory = trajectory;
pointNodeMapping = new Dictionary <TPoint2D, DataNode <TPoint2D> >();
Shortcuts = new JDictionary <Shortcut, Edge>();
foreach (var point in Trajectory)
{
pointNodeMapping.Add(point, new DataNode <TPoint2D>(point));
}
}
protected TrajectoryCanvas()
{
MouseDown += HandleMouseDown;
MouseUp += HandleMouseUp;
MouseMove += HandleMouseMove;
MouseWheel += HandleMouseWheel;
WorldOriginChanged += () => focusedTrajectory = null;
ZoomFactorChanged += () => focusedTrajectory = null;
DraggingWorld = false;
}
private Trajectory2D GetSubTrajectory(Trajectory2D trajectory, int start, int end, int downSampleAmount)
{
var newTrajectory = new Trajectory2D();
var originalCount = end - start + 1;
for (var i = 0; i <= downSampleAmount - 1; i++)
{
var offset = (int)Math.Floor(((double)(((long)i) * (originalCount - 1))) / (downSampleAmount - 1));
var newPoint = trajectory[start - 1 + offset];
newTrajectory.AppendPoint(newPoint.X, newPoint.Y);
}
return(newTrajectory);
}
protected void LookAtTrajectory(Trajectory2D trajectory)
{
if (trajectory.Count > 0)
{
BoundingBox2D boundingBox = trajectory.BuildBoundingBox();
LookAt(boundingBox.Center.X, boundingBox.Center.Y, 1.1 * boundingBox.Width, 1.1 * boundingBox.Height);
focusedTrajectory = trajectory;
}
else
{
focusedTrajectory = null;
}
}
public override void Compute(MSInput input, out MSOutput output)
{
output = new MSOutput();
var trajectory = input.Trajectory;
List <TPoint2D> prevApproximation = null;
for (var level = input.NumLevels; level >= 1; level--)
{
var epsilon = input.GetEpsilon(level);
List <TPoint2D> approximation;
if (prevApproximation == null)
{
approximation = Approximator.Approximate(trajectory, epsilon);
}
else
{
approximation = new List <TPoint2D>();
var prevPoint = trajectory.First();
for (var i = 1; i < prevApproximation.Count; i++)
{
var point = prevApproximation[i];
//excludes the end point
var subApproximation = Approximator.Approximate(trajectory, prevPoint.Index, point.Index, epsilon);
approximation.AddRange(subApproximation);
prevPoint = point;
}
approximation.Add(trajectory.Last());
}
var newTrajectory = new Trajectory2D();
foreach (var point in approximation)
{
newTrajectory.AppendPoint(point.X, point.Y);
}
//report shortest path
//output.LogObject("Level Shortest Path", levelTrajectory);
output.LogLine("Level " + level + " trajectory found. Length: " + newTrajectory.Count);
output.SetTrajectoryAtLevel(level, newTrajectory);
prevApproximation = approximation;
}
}
protected void DrawTrajectoryPoints(Trajectory2D trajectory, double radius, int numSegments, Func <TPoint2D, Color> colorFunc, Func <TPoint2D, int> nameFunc = null)
{
foreach (var p in trajectory)
{
if (nameFunc != null)
{
DrawPoint(p, radius, numSegments, colorFunc(p), nameFunc(p));
}
else
{
DrawPoint(p, radius, numSegments, colorFunc(p));
}
}
}
public ShortcutGraph(Trajectory2D Trajectory, bool containsTrivialShortcuts = false, int initWeight = 1) : this(Trajectory)
{
TPoint2D prevPoint = null;
if (!containsTrivialShortcuts)
{
return;
}
foreach (var point in Trajectory)
{
if (prevPoint != null)
{
AddShortcut(new Shortcut(prevPoint, point), initWeight);
}
prevPoint = point;
}
}
public override void Compute(MSInput input, out MSOutput output)
{
output = new MSOutput();
var trajectory = input.Trajectory;
ShortcutProvider.Init(input, output, false);
ICollection <TPoint2D> prevShortestPath = trajectory;
for (var level = 1; level <= input.NumLevels; level++)
{
var epsilon = input.GetEpsilon(level);
var levelShortcuts = ShortcutProvider.GetShortcuts(level, epsilon);
var levelShortestPath = ShortestPathProvider.FindShortestPath(levelShortcuts, trajectory.First(), trajectory.Last()).Points;
levelShortestPath.AddFirst(trajectory.First());
//O(n)
var levelTrajectory = new Trajectory2D(levelShortestPath);
//O(n)
var levelShortestPathSet = new HashSet <TPoint2D>(levelShortestPath);
//report level trajectory
output.SetTrajectoryAtLevel(level, levelTrajectory);
//prune shortcutgraph and shortcuts
//only consider points that are not the first/last
foreach (var point in prevShortestPath)
{
//O(1)
if (!levelShortestPathSet.Contains(point))
{
//remove shortcuts from shortcut set
ShortcutProvider.RemovePoint(point);
}
}
prevShortestPath = levelShortestPath;
}
}
public override void Compute(MSInput input, out MSOutput output)
{
output = new MSOutput();
var trajectory = input.Trajectory;
var prevTrajectory = trajectory;
for (var level = 1; level <= input.NumLevels; level++)
{
var epsilon = input.GetEpsilon(level);
var approximation = Approximator.Approximate(prevTrajectory, epsilon);
var newTrajectory = new Trajectory2D(approximation);
//report shortest path
//output.LogObject("Level Shortest Path", levelTrajectory);
output.LogLine("Level " + level + " trajectory found. Length: " + approximation.Count);
output.SetTrajectoryAtLevel(level, newTrajectory);
prevTrajectory = newTrajectory;
}
}
private void CalculateTrajectory(bool lookAtTrajectory = true)
{
if (trajectoryTable.SelectedRows.Count == 0)
{
return;
}
var fileTrajectoryName = (string)trajectoryTable.SelectedRows[0].Cells[0].Value;
var fileTrajectory = trajectories[fileTrajectoryName];
var newTrajectory = GetSubTrajectory(fileTrajectory, (int)fromPointChooser.Value, (int)toPointChooser.Value, (int)downSampleToChooser.Value);
trajectoryGMap.DrawSingleTrajectory(newTrajectory);
if (lookAtTrajectory)
{
trajectoryGMap.LookAtTrajectory(newTrajectory);
}
ChosenTrajectory = newTrajectory;
ChosenTrajectoryName = fileTrajectoryName + " starting from point " + (int)fromPointChooser.Value + " to point " + (int)toPointChooser.Value + " downsampled to " + (int)downSampleToChooser.Value;
}
public static int GetSplit(Trajectory2D trajectory, int start, int end, out double maxDistance)
{
maxDistance = 0.0;
var split = -1;
var startPoint = trajectory[start];
var endPoint = trajectory[end];
for (var k = start + 1; k < end; k++)
{
var point = trajectory[k];
var dist = Geometry2D.Distance(startPoint, endPoint, point);
if (dist > maxDistance)
{
maxDistance = dist;
split = k;
}
}
return(split);
}
public override void Compute(MSInput input, out MSOutput output)
{
output = new MSOutput();
var trajectory = input.Trajectory;
ShortcutProvider.Init(input, output, false);
for (var level = 1; level <= input.NumLevels; level++)
{
var epsilon = input.GetEpsilon(level);
var levelShortcuts = ShortcutProvider.GetShortcuts(level, epsilon);
var shortestPath = ShortestPathProvider.FindShortestPath(levelShortcuts, trajectory.First(), trajectory.Last()).Points;
shortestPath.AddFirst(trajectory.First());
//O(n)
var levelTrajectory = new Trajectory2D(shortestPath);
output.SetTrajectoryAtLevel(level, levelTrajectory);
}
}
public override void Compute(MSInput input, out MSOutput output)
{
output = new MSOutput();
var trajectory = input.Trajectory;
ShortcutProvider.Init(input, output, false);
var onDemandShortcutProvider = (ShortcutsOnDemand)ShortcutProvider;
var prevTrajectory = trajectory;
for (var level = 1; level <= input.NumLevels; level++)
{
var epsilon = input.GetEpsilon(level);
var shortcutAlgo = onDemandShortcutProvider.Algorithm;
var shortcutInput = new MSSInput(prevTrajectory, new List <double> {
epsilon
});
MSSOutput shortcutOutput;
shortcutAlgo.Compute(shortcutInput, out shortcutOutput);
var levelShortcuts = shortcutOutput.GetShortcuts(1);
output.LogObject("Number of shortcuts found on level " + level, levelShortcuts.Count);
var levelShortestPath = ShortestPathProvider.FindShortestPath(levelShortcuts, prevTrajectory.First(), prevTrajectory.Last()).Points;
levelShortestPath.AddFirst(prevTrajectory.First());
//O(n)
var levelTrajectory = new Trajectory2D(levelShortestPath);
//report level trajectory
output.SetTrajectoryAtLevel(level, levelTrajectory);
prevTrajectory = levelTrajectory;
}
}
public void DrawSingleTrajectory(Trajectory2D trajectory)
{
ClearTrajectories();
DrawTrajectory(trajectory);
}
public IntervalsRangeTree(ShortcutIntervalSet shortcutIntervals, Trajectory2D trajectory, TPoint2D target) : base(OrderIndexes, MinimizeDistance, null)
{
RangeInitializer = point =>
{
if (point == target)
{
return(new PathStep(point, 0));
}
PathStep bestStep = null;
foreach (var range in shortcutIntervals.GetIntervals(point))
{
PathStep step;
bool stepFound;
if (range.Start.Index > target.Index)
{
break;
}
//if (false)
if (range.Count < Math.Ceiling(Math.Log(Size, 2)))
{
PathStep tempBest = null;
for (var i = range.Start.Index; i <= range.End.Index; i++)
{
PathStep tempStep;
var nodeExists = TryGetNodeData(trajectory[i], out tempStep);
if (!nodeExists)
{
continue;
}
if (tempBest == null || tempStep.Distance < tempBest.Distance)
{
tempBest = tempStep;
}
}
stepFound = tempBest != null;
step = tempBest;
}
else
{
stepFound = TryFindRangeData((min, max) =>
{
if (min.Index >= range.Start.Index && max.Index <= range.End.Index)
{
return(1);
}
if (min.Index > range.End.Index || max.Index < range.Start.Index)
{
return(-1);
}
return(0);
}, out step);
}
if (!stepFound)
{
continue;
}
if (bestStep == null || step.Distance < bestStep.Distance)
{
bestStep = step;
}
}
if (bestStep == null)
{
return(new PathStep(point, int.MaxValue));
}
return(new PathStep(point, bestStep.Distance + 1, bestStep));
};
}
private ShortcutIntervalSet(Trajectory2D Trajectory, JDictionary <TPoint2D, LinkedList <Interval> > intervalMap)
{
this.Trajectory = Trajectory;
this.IntervalMap = intervalMap;
}
public static Dictionary <string, Trajectory2D> ReadTrajectories(string fileName, bool findOnlyOne = false)
{
var trajectories = new Dictionary <string, Trajectory2D>();
using (StreamReader reader = new StreamReader(fileName))
{
//pass past column headers
var firstLine = reader.ReadLine();
if (firstLine == null)
{
return(null);
}
var columns = firstLine.Split(',');
var trajectoryIdCol = columns.ToList().FindIndex(str => str == "individual-local-identifier");
var longitudeCol = columns.ToList().FindIndex(str => str == "location-long");
var latitudeCol = columns.ToList().FindIndex(str => str == "location-lat");
//correct columns not foud
if (trajectoryIdCol == -1 || longitudeCol == -1 || latitudeCol == -1)
{
return(null);
}
//id of first trajectory in the data
string lastTrajectoryId = null;
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
//end of stream reached
if (line == null)
{
break;
}
var trajectoryId = line.Split(',')[trajectoryIdCol].Replace("\"", "");
Debug.Assert(trajectoryId != null, "trajectoryId != null");
//new trajectory reached
if (trajectoryId != lastTrajectoryId)
{
trajectories[trajectoryId] = new Trajectory2D();
//first trajectory has been processed fully
if (findOnlyOne && lastTrajectoryId != null)
{
break;
}
lastTrajectoryId = trajectoryId;
}
var longitudeStr = line.Split(',')[longitudeCol].Replace(',', '.');
var latitudeStr = line.Split(',')[latitudeCol].Replace(',', '.');
//rare artifact where longitude and latitude is missing
if (longitudeStr == "" || latitudeStr == "")
{
continue;
}
var longitude = Convert.ToSingle(longitudeStr, CultureInfo.InvariantCulture);
var latitude = Convert.ToSingle(latitudeStr, CultureInfo.InvariantCulture);
//longitude as x, latitude as y
trajectories[trajectoryId].AppendPoint(longitude, latitude);
}
}
return(trajectories);
}
public override IShortcutSet Create(Trajectory2D trajectory)
{
return(new ShortcutGraph(trajectory));
}
protected override void RenderWorld()
{
Trajectory2D trajectory = output.GetTrajectoryAtLevel(currentLevel);
DrawTrajectoryEdges(trajectory, 2.5f, Color.Red);
}
