/// <summary>
/// Searches the data for a point on an edge closest to the given coordinate.
/// </summary>
/// <param name="graph"></param>
/// <param name="vehicle"></param>
/// <param name="coordinate"></param>
/// <param name="delta"></param>
/// <param name="matcher"></param>
/// <param name="pointTags"></param>
/// <param name="interpreter"></param>
/// <param name="verticesOnly"></param>
public SearchClosestResult SearchClosest(IBasicRouterDataSource <TEdgeData> graph, IRoutingInterpreter interpreter, Vehicle vehicle,
GeoCoordinate coordinate, float delta, IEdgeMatcher matcher, TagsCollection pointTags, bool verticesOnly)
{
var closestWithMatch = new SearchClosestResult(double.MaxValue, 0);
var closestWithoutMatch = new SearchClosestResult(double.MaxValue, 0);
double searchBoxSize = delta;
// create the search box.
var searchBox = new GeoCoordinateBox(new GeoCoordinate(
coordinate.Latitude - searchBoxSize, coordinate.Longitude - searchBoxSize),
new GeoCoordinate(
coordinate.Latitude + searchBoxSize, coordinate.Longitude + searchBoxSize));
// get the arcs from the data source.
KeyValuePair <uint, KeyValuePair <uint, TEdgeData> >[] arcs = graph.GetArcs(searchBox);
if (!verticesOnly)
{ // find both closest arcs and vertices.
// loop over all.
foreach (KeyValuePair <uint, KeyValuePair <uint, TEdgeData> > arc in arcs)
{
TagsCollection arcTags = graph.TagsIndex.Get(arc.Value.Value.Tags);
bool canBeTraversed = vehicle.CanTraverse(arcTags);
if (canBeTraversed)
{ // the edge can be traversed.
// test the two points.
float fromLatitude, fromLongitude;
float toLatitude, toLongitude;
double distance;
if (graph.GetVertex(arc.Key, out fromLatitude, out fromLongitude) &&
graph.GetVertex(arc.Value.Key, out toLatitude, out toLongitude))
{ // return the vertex.
var fromCoordinates = new GeoCoordinate(fromLatitude, fromLongitude);
distance = coordinate.Distance(fromCoordinates);
if (distance < 0.00001)
{ // the distance is smaller than the tolerance value.
closestWithoutMatch = new SearchClosestResult(
distance, arc.Key);
if (matcher == null ||
(pointTags == null || pointTags.Count == 0) ||
matcher.MatchWithEdge(vehicle, pointTags, arcTags))
{
closestWithMatch = new SearchClosestResult(
distance, arc.Key);
break;
}
}
if (distance < closestWithoutMatch.Distance)
{ // the distance is smaller for the without match.
closestWithoutMatch = new SearchClosestResult(
distance, arc.Key);
}
if (distance < closestWithMatch.Distance)
{ // the distance is smaller for the with match.
if (matcher == null ||
(pointTags == null || pointTags.Count == 0) ||
matcher.MatchWithEdge(vehicle, pointTags, graph.TagsIndex.Get(arc.Value.Value.Tags)))
{
closestWithMatch = new SearchClosestResult(
distance, arc.Key);
}
}
var toCoordinates = new GeoCoordinate(toLatitude, toLongitude);
distance = coordinate.Distance(toCoordinates);
if (distance < closestWithoutMatch.Distance)
{ // the distance is smaller for the without match.
closestWithoutMatch = new SearchClosestResult(
distance, arc.Value.Key);
}
if (distance < closestWithMatch.Distance)
{ // the distance is smaller for the with match.
if (matcher == null ||
(pointTags == null || pointTags.Count == 0) ||
matcher.MatchWithEdge(vehicle, pointTags, arcTags))
{
closestWithMatch = new SearchClosestResult(
distance, arc.Value.Key);
}
}
// create a line.
double distanceTotal = fromCoordinates.Distance(toCoordinates);
if (distanceTotal > 0)
{ // the from/to are not the same location.
var line = new GeoCoordinateLine(fromCoordinates, toCoordinates, true, true);
distance = line.Distance(coordinate);
if (distance < closestWithoutMatch.Distance)
{ // the distance is smaller.
PointF2D projectedPoint =
line.ProjectOn(coordinate);
// calculate the position.
if (projectedPoint != null)
{ // calculate the distance
double distancePoint = fromCoordinates.Distance(projectedPoint);
double position = distancePoint / distanceTotal;
closestWithoutMatch = new SearchClosestResult(
distance, arc.Key, arc.Value.Key, position);
}
}
if (distance < closestWithMatch.Distance)
{
PointF2D projectedPoint =
line.ProjectOn(coordinate);
// calculate the position.
if (projectedPoint != null)
{ // calculate the distance
double distancePoint = fromCoordinates.Distance(projectedPoint);
double position = distancePoint / distanceTotal;
if (matcher == null ||
(pointTags == null || pointTags.Count == 0) ||
matcher.MatchWithEdge(vehicle, pointTags, arcTags))
{
closestWithMatch = new SearchClosestResult(
distance, arc.Key, arc.Value.Key, position);
}
}
}
}
}
}
}
}
else
{ // only find closest vertices.
// loop over all.
foreach (KeyValuePair <uint, KeyValuePair <uint, TEdgeData> > arc in arcs)
{
float fromLatitude, fromLongitude;
float toLatitude, toLongitude;
if (graph.GetVertex(arc.Key, out fromLatitude, out fromLongitude) &&
graph.GetVertex(arc.Value.Key, out toLatitude, out toLongitude))
{
var vertexCoordinate = new GeoCoordinate(fromLatitude, fromLongitude);
double distance = coordinate.Distance(vertexCoordinate);
if (distance < closestWithoutMatch.Distance)
{ // the distance found is closer.
closestWithoutMatch = new SearchClosestResult(
distance, arc.Key);
}
vertexCoordinate = new GeoCoordinate(toLatitude, toLongitude);
distance = coordinate.Distance(vertexCoordinate);
if (distance < closestWithoutMatch.Distance)
{ // the distance found is closer.
closestWithoutMatch = new SearchClosestResult(
distance, arc.Value.Key);
}
}
}
}
// return the best result.
if (closestWithMatch.Distance < double.MaxValue)
{
return(closestWithMatch);
}
return(closestWithoutMatch);
}
/// <summary>
/// Does dykstra calculation(s) with several options.
/// </summary>
/// <param name="graph"></param>
/// <param name="interpreter"></param>
/// <param name="vehicle"></param>
/// <param name="sourceList"></param>
/// <param name="targetList"></param>
/// <param name="weight"></param>
/// <param name="stopAtFirst"></param>
/// <param name="returnAtWeight"></param>
/// <param name="forward"></param>
/// <returns></returns>
private PathSegment <long>[] DoCalculation(IBasicRouterDataSource <LiveEdge> graph, IRoutingInterpreter interpreter, Vehicle vehicle,
PathSegmentVisitList sourceList, PathSegmentVisitList[] targetList, double weight,
bool stopAtFirst, bool returnAtWeight, bool forward)
{
// make copies of the target and source visitlist.
PathSegmentVisitList source = sourceList.Clone() as PathSegmentVisitList;
PathSegmentVisitList[] targets = new PathSegmentVisitList[targetList.Length];
for (int targetIdx = 0; targetIdx < targetList.Length; targetIdx++)
{
targets[targetIdx] = targetList[targetIdx].Clone() as PathSegmentVisitList;
}
// initialize the result data structures.
var segmentsAtWeight = new List <PathSegment <long> >();
var segmentsToTarget = new PathSegment <long> [targets.Length]; // the resulting target segments.
long foundTargets = 0;
// intialize dykstra data structures.
IPriorityQueue <PathSegment <long> > heap = new BinairyHeap <PathSegment <long> >();
var chosenVertices = new HashSet <long>();
var labels = new Dictionary <long, IList <RoutingLabel> >();
foreach (long vertex in source.GetVertices())
{
labels[vertex] = new List <RoutingLabel>();
PathSegment <long> path = source.GetPathTo(vertex);
heap.Push(path, (float)path.Weight);
}
// set the from node as the current node and put it in the correct data structures.
// intialize the source's neighbours.
PathSegment <long> current = heap.Pop();
while (current != null &&
chosenVertices.Contains(current.VertexId))
{ // keep dequeuing.
current = heap.Pop();
}
// test each target for the source.
// test each source for any of the targets.
var pathsFromSource = new Dictionary <long, PathSegment <long> >();
foreach (long sourceVertex in source.GetVertices())
{ // get the path to the vertex.
PathSegment <long> sourcePath = source.GetPathTo(sourceVertex); // get the source path.
sourcePath = sourcePath.From;
while (sourcePath != null)
{ // add the path to the paths from source.
pathsFromSource[sourcePath.VertexId] = sourcePath;
sourcePath = sourcePath.From;
}
}
// loop over all targets
for (int idx = 0; idx < targets.Length; idx++)
{ // check for each target if there are paths to the source.
foreach (long targetVertex in targets[idx].GetVertices())
{
PathSegment <long> targetPath = targets[idx].GetPathTo(targetVertex); // get the target path.
targetPath = targetPath.From;
while (targetPath != null)
{ // add the path to the paths from source.
PathSegment <long> pathFromSource;
if (pathsFromSource.TryGetValue(targetPath.VertexId, out pathFromSource))
{ // a path is found.
// get the existing path if any.
PathSegment <long> existing = segmentsToTarget[idx];
if (existing == null)
{ // a path did not exist yet!
segmentsToTarget[idx] = targetPath.Reverse().ConcatenateAfter(pathFromSource);
foundTargets++;
}
else if (existing.Weight > targetPath.Weight + pathFromSource.Weight)
{ // a new path is found with a lower weight.
segmentsToTarget[idx] = targetPath.Reverse().ConcatenateAfter(pathFromSource);
}
}
targetPath = targetPath.From;
}
}
}
if (foundTargets == targets.Length && targets.Length > 0)
{ // routing is finished!
return(segmentsToTarget.ToArray());
}
if (stopAtFirst)
{ // only one entry is needed.
if (foundTargets > 0)
{ // targets found, return the shortest!
PathSegment <long> shortest = null;
foreach (PathSegment <long> foundTarget in segmentsToTarget)
{
if (shortest == null)
{
shortest = foundTarget;
}
else if (foundTarget != null &&
shortest.Weight > foundTarget.Weight)
{
shortest = foundTarget;
}
}
segmentsToTarget = new PathSegment <long> [1];
segmentsToTarget[0] = shortest;
return(segmentsToTarget);
}
else
{ // not targets found yet!
segmentsToTarget = new PathSegment <long> [1];
}
}
// test for identical start/end point.
for (int idx = 0; idx < targets.Length; idx++)
{
PathSegmentVisitList target = targets[idx];
if (returnAtWeight)
{ // add all the reached vertices larger than weight to the results.
if (current.Weight > weight)
{
PathSegment <long> toPath = target.GetPathTo(current.VertexId);
toPath.Reverse();
toPath = toPath.ConcatenateAfter(current);
segmentsAtWeight.Add(toPath);
}
}
else if (target.Contains(current.VertexId))
{ // the current is a target!
PathSegment <long> toPath = target.GetPathTo(current.VertexId);
toPath = toPath.Reverse();
toPath = toPath.ConcatenateAfter(current);
if (stopAtFirst)
{ // stop at the first occurance.
segmentsToTarget[0] = toPath;
return(segmentsToTarget);
}
else
{ // normal one-to-many; add to the result.
// check if routing is finished.
if (segmentsToTarget[idx] == null)
{ // make sure only the first route is set.
foundTargets++;
segmentsToTarget[idx] = toPath;
if (foundTargets == targets.Length)
{ // routing is finished!
return(segmentsToTarget.ToArray());
}
}
else if (segmentsToTarget[idx].Weight > toPath.Weight)
{ // check if the second, third or later is shorter.
segmentsToTarget[idx] = toPath;
}
}
}
}
// start OsmSharp.Routing.
KeyValuePair <uint, LiveEdge>[] arcs = graph.GetArcs(
Convert.ToUInt32(current.VertexId));
chosenVertices.Add(current.VertexId);
// loop until target is found and the route is the shortest!
while (true)
{
// get the current labels list (if needed).
IList <RoutingLabel> currentLabels = null;
if (interpreter.Constraints != null)
{ // there are constraints, get the labels.
currentLabels = labels[current.VertexId];
labels.Remove(current.VertexId);
}
float latitude, longitude;
graph.GetVertex(Convert.ToUInt32(current.VertexId), out latitude, out longitude);
var currentCoordinates = new GeoCoordinate(latitude, longitude);
// update the visited nodes.
foreach (KeyValuePair <uint, LiveEdge> neighbour in arcs)
{
// check the tags against the interpreter.
TagsCollection tags = graph.TagsIndex.Get(neighbour.Value.Tags);
if (vehicle.CanTraverse(tags))
{ // it's ok; the edge can be traversed by the given vehicle.
bool?oneWay = vehicle.IsOneWay(tags);
bool canBeTraversedOneWay = (!oneWay.HasValue || oneWay.Value == neighbour.Value.Forward);
if ((current.From == null ||
interpreter.CanBeTraversed(current.From.VertexId, current.VertexId, neighbour.Key)) && // test for turning restrictions.
canBeTraversedOneWay &&
!chosenVertices.Contains(neighbour.Key))
{ // the neigbour is forward and is not settled yet!
// check the labels (if needed).
bool constraintsOk = true;
if (interpreter.Constraints != null)
{ // check if the label is ok.
RoutingLabel neighbourLabel = interpreter.Constraints.GetLabelFor(
graph.TagsIndex.Get(neighbour.Value.Tags));
// only test labels if there is a change.
if (currentLabels.Count == 0 || !neighbourLabel.Equals(currentLabels[currentLabels.Count - 1]))
{ // labels are different, test them!
constraintsOk = interpreter.Constraints.ForwardSequenceAllowed(currentLabels,
neighbourLabel);
if (constraintsOk)
{ // update the labels.
var neighbourLabels = new List <RoutingLabel>(currentLabels);
neighbourLabels.Add(neighbourLabel);
labels[neighbour.Key] = neighbourLabels;
}
}
else
{ // set the same label(s).
labels[neighbour.Key] = currentLabels;
}
}
if (constraintsOk)
{ // all constraints are validated or there are none.
graph.GetVertex(Convert.ToUInt32(neighbour.Key), out latitude, out longitude);
var neighbourCoordinates = new GeoCoordinate(latitude, longitude);
// calculate the weight.
double weightToNeighbour = vehicle.Weight(tags, currentCoordinates, neighbourCoordinates);
// calculate neighbours weight.
double totalWeight = current.Weight + weightToNeighbour;
// update the visit list;
var neighbourRoute = new PathSegment <long>(neighbour.Key, totalWeight, current);
heap.Push(neighbourRoute, (float)neighbourRoute.Weight);
}
}
}
}
// while the visit list is not empty.
current = null;
if (heap.Count > 0)
{
// choose the next vertex.
current = heap.Pop();
while (current != null &&
chosenVertices.Contains(current.VertexId))
{ // keep dequeuing.
current = heap.Pop();
}
if (current != null)
{
chosenVertices.Add(current.VertexId);
}
}
while (current != null && current.Weight > weight)
{
if (returnAtWeight)
{ // add all the reached vertices larger than weight to the results.
segmentsAtWeight.Add(current);
}
// choose the next vertex.
current = heap.Pop();
while (current != null &&
chosenVertices.Contains(current.VertexId))
{ // keep dequeuing.
current = heap.Pop();
}
}
if (current == null)
{ // route is not found, there are no vertices left
// or the search whent outside of the max bounds.
break;
}
// check target.
for (int idx = 0; idx < targets.Length; idx++)
{
PathSegmentVisitList target = targets[idx];
if (target.Contains(current.VertexId))
{ // the current is a target!
PathSegment <long> toPath = target.GetPathTo(current.VertexId);
toPath = toPath.Reverse();
toPath = toPath.ConcatenateAfter(current);
if (stopAtFirst)
{ // stop at the first occurance.
segmentsToTarget[0] = toPath;
return(segmentsToTarget);
}
else
{ // normal one-to-many; add to the result.
// check if routing is finished.
if (segmentsToTarget[idx] == null)
{ // make sure only the first route is set.
segmentsToTarget[idx] = toPath;
}
else if (segmentsToTarget[idx].Weight > toPath.Weight)
{ // check if the second, third or later is shorter.
segmentsToTarget[idx] = toPath;
}
// remove this vertex from this target's paths.
target.Remove(current.VertexId);
// if this target is empty it's optimal route has been found.
if (target.Count == 0)
{ // now the shortest route has been found for sure!
foundTargets++;
if (foundTargets == targets.Length)
{ // routing is finished!
return(segmentsToTarget.ToArray());
}
}
}
}
}
// get the neigbours of the current node.
arcs = graph.GetArcs(Convert.ToUInt32(current.VertexId));
}
// return the result.
if (!returnAtWeight)
{
return(segmentsToTarget.ToArray());
}
return(segmentsAtWeight.ToArray());
}
/// <summary>
/// Implements a very simple dykstra version.
/// </summary>
/// <param name="graph"></param>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="via"></param>
/// <param name="max_weight"></param>
/// <param name="max_settles"></param>
/// <returns></returns>
private float CalculateWeight(IBasicRouterDataSource <CHEdgeData> graph, uint from, uint to, uint via, float max_weight, int max_settles)
{
int max_hops = 5;
float weight = float.MaxValue;
// creates the settled list.
HashSet <uint> settled = new HashSet <uint>();
settled.Add(via);
// creates the priorty queue.
BinairyHeap <SettledVertex> heap = new BinairyHeap <SettledVertex>();
heap.Push(new SettledVertex(from, 0, 0), 0);
// keep looping until the queue is empty or the target is found!
while (heap.Count > 0)
{
// pop the first customer.
SettledVertex current = heap.Pop();
if (!settled.Contains(current.VertexId))
{ // the current vertex has net been settled.
settled.Add(current.VertexId); // settled the vertex.
// test stop conditions.
if (current.VertexId == to)
{ // target is found!
return(current.Weight);
}
// test the hop count.
if (current.Hops < max_hops)
{ // the neighbours will only increase hops!
if (settled.Count >= max_settles)
{ // do not continue searching.
return(float.MaxValue);
}
// get the neighbours.
KeyValuePair <uint, CHEdgeData>[] neighbours = graph.GetArcs(current.VertexId);
for (int idx = 0; idx < neighbours.Length; idx++)
{
if (neighbours[idx].Value.Forward && (neighbours[idx].Key == to || !settled.Contains(neighbours[idx].Key)))
{
SettledVertex neighbour = new SettledVertex(neighbours[idx].Key,
neighbours[idx].Value.Weight + current.Weight, current.Hops + 1);
if (neighbour.Weight < max_weight)
{
if (neighbours[idx].Key == to)
{
return(neighbour.Weight);
}
heap.Push(neighbour, neighbour.Weight);
}
}
}
}
}
}
return(weight);
}
/// <summary>
/// Builds the scene.
/// </summary>
/// <param name="map"></param>
/// <param name="zoomFactor"></param>
/// <param name="center"></param>
/// <param name="view"></param>
private void BuildScene(Map map, float zoomFactor, GeoCoordinate center, View2D view)
{
// get the indexed object at this zoom.
HashSet <ArcId> interpretedObjects;
if (!_interpretedObjects.TryGetValue((int)zoomFactor, out interpretedObjects))
{
interpretedObjects = new HashSet <ArcId> ();
_interpretedObjects.Add((int)zoomFactor, interpretedObjects);
}
// build the boundingbox.
var viewBox = view.OuterBox;
var box = new GeoCoordinateBox(map.Projection.ToGeoCoordinates(viewBox.Min [0], viewBox.Min [1]),
map.Projection.ToGeoCoordinates(viewBox.Max [0], viewBox.Max [1]));
foreach (var requestedBox in _requestedBoxes)
{
if (requestedBox.Contains(box))
{
return;
}
}
_requestedBoxes.Add(box);
//// set the scene backcolor.
//SimpleColor? color = _styleInterpreter.GetCanvasColor ();
//_scene.BackColor = color.HasValue
// ? color.Value.Value
// : SimpleColor.FromArgb (0, 255, 255, 255).Value;
// get data.
foreach (var arc in _dataSource.GetArcs(box))
{
// translate each object into scene object.
var arcId = new ArcId()
{
Vertex1 = arc.Key,
Vertex2 = arc.Value.Key
};
if (!interpretedObjects.Contains(arcId))
{
interpretedObjects.Add(arcId);
// create nodes.
float latitude, longitude;
_dataSource.GetVertex(arcId.Vertex1, out latitude, out longitude);
var node1 = CompleteNode.Create(arcId.Vertex1);
node1.Coordinate = new GeoCoordinate(latitude, longitude);
_dataSource.GetVertex(arcId.Vertex2, out latitude, out longitude);
var node2 = CompleteNode.Create(arcId.Vertex2);
node2.Coordinate = new GeoCoordinate(latitude, longitude);
// create way.
var way = CompleteWay.Create(-1);
if (arc.Value.Value.Forward)
{
way.Nodes.Add(node1);
way.Nodes.Add(node2);
}
else
{
way.Nodes.Add(node2);
way.Nodes.Add(node1);
}
way.Tags.AddOrReplace(_dataSource.TagsIndex.Get(arc.Value.Value.Tags));
_styleInterpreter.Translate(_scene, map.Projection, way);
interpretedObjects.Add(arcId);
}
}
}
/// <summary>
/// Implements a very simple dykstra version.
/// </summary>
/// <param name="graph"></param>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="via"></param>
/// <param name="max_weight"></param>
/// <param name="max_settles"></param>
/// <returns></returns>
private float CalculateWeight(IBasicRouterDataSource<CHEdgeData> graph, uint from, uint to, uint via, float max_weight, int max_settles)
{
int max_hops = 5;
float weight = float.MaxValue;
// creates the settled list.
HashSet<uint> settled = new HashSet<uint>();
settled.Add(via);
// creates the priorty queue.
BinairyHeap<SettledVertex> heap = new BinairyHeap<SettledVertex>();
heap.Push(new SettledVertex(from, 0, 0), 0);
// keep looping until the queue is empty or the target is found!
while (heap.Count > 0)
{
// pop the first customer.
SettledVertex current = heap.Pop();
if (!settled.Contains(current.VertexId))
{ // the current vertex has net been settled.
settled.Add(current.VertexId); // settled the vertex.
// test stop conditions.
if (current.VertexId == to)
{ // target is found!
return current.Weight;
}
// test the hop count.
if (current.Hops < max_hops)
{ // the neighbours will only increase hops!
if (settled.Count >= max_settles)
{ // do not continue searching.
return float.MaxValue;
}
// get the neighbours.
KeyValuePair<uint, CHEdgeData>[] neighbours = graph.GetArcs(current.VertexId);
for (int idx = 0; idx < neighbours.Length; idx++)
{
if (neighbours[idx].Value.Forward && (neighbours[idx].Key == to || !settled.Contains(neighbours[idx].Key)))
{
SettledVertex neighbour = new SettledVertex(neighbours[idx].Key,
neighbours[idx].Value.Weight + current.Weight, current.Hops + 1);
if (neighbour.Weight < max_weight)
{
if (neighbours[idx].Key == to)
{
return neighbour.Weight;
}
heap.Push(neighbour, neighbour.Weight);
}
}
}
}
}
}
return weight;
}
