/// <summary>
/// Called left before the contraction.
/// </summary>
/// <param name="vertex"></param>
/// <param name="edges"></param>
void pre_processor_OnBeforeContractionEvent(uint vertex, List <Edge <CHEdgeData> > edges)
{
// create a new CHRouter
var router = new CHRouter();
// calculate all the routes between the neighbours of the contracted vertex.
var pathsBeforeContraction = new Dictionary <uint, Dictionary <uint, PathSegment <long> > >();
_pathsBeforeContraction.Add(vertex, pathsBeforeContraction);
foreach (var from in edges)
{
// initialize the from-list.
var fromList = new PathSegmentVisitList();
fromList.UpdateVertex(new PathSegment <long>(from.Neighbour));
// initalize the from dictionary.
var fromDic = new Dictionary <uint, PathSegment <long> >();
pathsBeforeContraction[from.Neighbour] = fromDic;
foreach (var to in edges)
{
// initialize the to-list.
var toList = new PathSegmentVisitList();
toList.UpdateVertex(new PathSegment <long>(to.Neighbour));
// calculate the route.
fromDic[to.Neighbour] = router.Calculate(_data, _interpreter,
Vehicle.Car, fromList, toList, double.MaxValue, null);;
}
}
}
/// <summary>
/// Called left before the contraction.
/// </summary>
/// <param name="vertex"></param>
/// <param name="edges"></param>
void pre_processor_OnBeforeContractionEvent(uint vertex, KeyValuePair <uint, CHEdgeData>[] edges)
{
// create a new CHRouter
var router = new CHRouter(_data);
// calculate all the routes between the neighbours of the contracted vertex.
_pathsBeforeContraction =
new Dictionary <uint, Dictionary <uint, PathSegment <long> > >();
foreach (KeyValuePair <uint, CHEdgeData> from in edges)
{
// initialize the from-list.
var fromList = new PathSegmentVisitList();
fromList.UpdateVertex(new PathSegment <long>(from.Key));
// initalize the from dictionary.
var fromDic = new Dictionary <uint, PathSegment <long> >();
_pathsBeforeContraction[from.Key] = fromDic;
foreach (KeyValuePair <uint, CHEdgeData> to in edges)
{
// initialize the to-list.
var toList = new PathSegmentVisitList();
toList.UpdateVertex(new PathSegment <long>(to.Key));
// calculate the route.
PathSegment <long> route = router.Calculate(_data, _interpreter,
OsmSharp.Routing.Vehicle.Car, fromList, toList, double.MaxValue);
fromDic[to.Key] = route;
}
}
}
/// <summary>
/// Called right after the contraction.
/// </summary>
/// <param name="vertex"></param>
/// <param name="edges"></param>
void pre_processor_OnAfterContractionEvent(uint vertex, KeyValuePair <uint, CHEdgeData>[] edges)
{
// create a new CHRouter
var router = new CHRouter(_data);
// calculate all the routes between the neighbours of the contracted vertex.
foreach (KeyValuePair <uint, CHEdgeData> from in edges)
{
// initialize the from-list.
var fromList = new PathSegmentVisitList();
fromList.UpdateVertex(new PathSegment <long>(from.Key));
// initalize the from dictionary.
Dictionary <uint, PathSegment <long> > fromDic = _pathsBeforeContraction[from.Key];
foreach (KeyValuePair <uint, CHEdgeData> to in edges)
{
// initialize the to-list.
var toList = new PathSegmentVisitList();
toList.UpdateVertex(new PathSegment <long>(to.Key));
// calculate the route.
PathSegment <long> route = router.Calculate(_data, _interpreter, OsmSharp.Routing.Vehicle.Car, fromList, toList, double.MaxValue);
if ((fromDic[to.Key] == null && route != null) ||
(fromDic[to.Key] != null && route == null) ||
((fromDic[to.Key] != null && route != null) && fromDic[to.Key] != route))
{ // the route match!
Assert.Fail("Routes are different before/after contraction!");
}
}
}
}
/// <summary>
/// Calculates a shortest path between the source vertex and any of the targets and returns the shortest.
/// </summary>
/// <param name="graph"></param>
/// <param name="interpreter"></param>
/// <param name="vehicle"></param>
/// <param name="from"></param>
/// <param name="targets"></param>
/// <param name="max"></param>
/// <returns></returns>
public PathSegment <long> CalculateToClosest(IBasicRouterDataSource <LiveEdge> graph, IRoutingInterpreter interpreter,
Vehicle vehicle, PathSegmentVisitList from, PathSegmentVisitList[] targets, double max)
{
PathSegment <long>[] result = this.DoCalculation(graph, interpreter, vehicle,
from, targets, max, false, false);
if (result != null && result.Length == 1)
{
return(result[0]);
}
return(null);
}
/// <summary>
/// Calculates the shortest path from the given vertex to the given vertex given the weights in the graph.
/// </summary>
/// <param name="vehicle"></param>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="graph"></param>
/// <param name="interpreter"></param>
/// <param name="max"></param>
/// <returns></returns>
public double CalculateWeight(IBasicRouterDataSource <LiveEdge> graph, IRoutingInterpreter interpreter, Vehicle vehicle,
PathSegmentVisitList from, PathSegmentVisitList to, double max)
{
PathSegment <long> closest = this.CalculateToClosest(graph, interpreter, vehicle, from,
new PathSegmentVisitList[] { to }, max);
if (closest != null)
{
return(closest.Weight);
}
return(double.MaxValue);
}
/// <summary>
/// Calculates all points that are at or close to the given weight.
/// </summary>
/// <param name="graph"></param>
/// <param name="interpreter"></param>
/// <param name="vehicle"></param>
/// <param name="source"></param>
/// <param name="weight"></param>
/// <param name="forward"></param>
/// <returns></returns>
public HashSet <long> CalculateRange(IBasicRouterDataSource <LiveEdge> graph, IRoutingInterpreter interpreter,
Vehicle vehicle, PathSegmentVisitList source, double weight, bool forward)
{
PathSegment <long>[] result = this.DoCalculation(graph, interpreter, vehicle,
source, new PathSegmentVisitList[0], weight, false, true, forward);
var resultVertices = new HashSet <long>();
for (int idx = 0; idx < result.Length; idx++)
{
resultVertices.Add(result[idx].VertexId);
}
return(resultVertices);
}
/// <summary>
/// Returns true if the search can move beyond the given weight.
/// </summary>
/// <param name="graph"></param>
/// <param name="interpreter"></param>
/// <param name="vehicle"></param>
/// <param name="source"></param>
/// <param name="weight"></param>
/// <returns></returns>
public bool CheckConnectivity(IBasicRouterDataSource <LiveEdge> graph, IRoutingInterpreter interpreter, Vehicle vehicle,
PathSegmentVisitList source, double weight)
{
HashSet <long> range = this.CalculateRange(graph, interpreter, vehicle, source, weight, true);
if (range.Count > 0)
{
range = this.CalculateRange(graph, interpreter, vehicle, source, weight, false);
if (range.Count > 0)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Calculates all routes from a given source to all given targets.
/// </summary>
/// <param name="graph"></param>
/// <param name="interpreter"></param>
/// <param name="vehicle"></param>
/// <param name="source"></param>
/// <param name="targets"></param>
/// <param name="max"></param>
/// <returns></returns>
public double[] CalculateOneToManyWeight(IBasicRouterDataSource <LiveEdge> graph, IRoutingInterpreter interpreter, Vehicle vehicle,
PathSegmentVisitList source, PathSegmentVisitList[] targets, double max)
{
PathSegment <long>[] many = this.DoCalculation(graph, interpreter, vehicle,
source, targets, max, false, false);
var weights = new double[many.Length];
for (int idx = 0; idx < many.Length; idx++)
{
if (many[idx] != null)
{
weights[idx] = many[idx].Weight;
}
else
{
weights[idx] = double.MaxValue;
}
}
return(weights);
}
/// <summary>
/// Calculates the shortest path from the given vertex to the given vertex given the weights in the graph.
/// </summary>
/// <param name="vehicle"></param>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="graph"></param>
/// <param name="interpreter"></param>
/// <param name="max"></param>
/// <returns></returns>
public PathSegment <long> Calculate(IBasicRouterDataSource <LiveEdge> graph, IRoutingInterpreter interpreter,
Vehicle vehicle, PathSegmentVisitList from, PathSegmentVisitList to, double max)
{
return(this.CalculateToClosest(graph, interpreter, vehicle, from,
new PathSegmentVisitList[] { to }, max));
}
/// <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>
/// Does forward dykstra calculation(s) with several options.
/// </summary>
/// <param name="graph"></param>
/// <param name="interpreter"></param>
/// <param name="vehicle"></param>
/// <param name="source"></param>
/// <param name="targets"></param>
/// <param name="weight"></param>
/// <param name="stopAtFirst"></param>
/// <param name="returnAtWeight"></param>
/// <returns></returns>
private PathSegment <long>[] DoCalculation(IBasicRouterDataSource <LiveEdge> graph, IRoutingInterpreter interpreter,
Vehicle vehicle, PathSegmentVisitList source, PathSegmentVisitList[] targets, double weight,
bool stopAtFirst, bool returnAtWeight)
{
return(this.DoCalculation(graph, interpreter, vehicle, source, targets, weight, stopAtFirst, returnAtWeight, true));
}
/// <summary>
/// Calculates all points that are at or close to the given weight.
/// </summary>
/// <param name="graph"></param>
/// <param name="interpreter"></param>
/// <param name="vehicle"></param>
/// <param name="source"></param>
/// <param name="weight"></param>
/// <returns></returns>
public HashSet <long> CalculateRange(IBasicRouterDataSource <LiveEdge> graph, IRoutingInterpreter interpreter,
Vehicle vehicle, PathSegmentVisitList source, double weight)
{
return(this.CalculateRange(graph, interpreter, vehicle, source, weight, true));
}
/// <summary>
/// Called right after the contraction.
/// </summary>
/// <param name="vertex"></param>
/// <param name="edges"></param>
void pre_processor_OnAfterContractionEvent(uint vertex, List <Edge <CHEdgeData> > edges)
{
// get dictionary for vertex.
var pathsBeforeContraction = _pathsBeforeContraction[vertex];
// create a new CHRouter
var router = new CHRouter();
// calculate all the routes between the neighbours of the contracted vertex.
foreach (var from in edges)
{
// initialize the from-list.
var fromList = new PathSegmentVisitList();
fromList.UpdateVertex(new PathSegment <long>(from.Neighbour));
// initalize the from dictionary.
var fromDic = pathsBeforeContraction[from.Neighbour];
foreach (var to in edges)
{
// initialize the to-list.
var toList = new PathSegmentVisitList();
toList.UpdateVertex(new PathSegment <long>(to.Neighbour));
// calculate the route.
var route = router.Calculate(_data, _interpreter, Vehicle.Car, fromList, toList, double.MaxValue, null);
if ((fromDic[to.Neighbour] == null && route != null) ||
(fromDic[to.Neighbour] != null && route == null))
{ // the route match!
Assert.Fail("Routes are different before/after contraction!");
}
else if (fromDic[to.Neighbour] != null && route != null)
{
this.ComparePaths(fromDic[to.Neighbour], route);
}
}
}
if (_referenceRouter != null)
{ // do crazy verification!
var chRouter = Router.CreateCHFrom(_data, router, new OsmRoutingInterpreter());
// loop over all nodes and resolve their locations.
var resolvedReference = new RouterPoint[_data.VertexCount - 1];
var resolved = new RouterPoint[_data.VertexCount - 1];
for (uint idx = 1; idx < _data.VertexCount; idx++)
{ // resolve each vertex.
float latitude, longitude;
if (_data.GetVertex(idx, out latitude, out longitude))
{
resolvedReference[idx - 1] = _referenceRouter.Resolve(Vehicle.Car, new GeoCoordinate(latitude, longitude));
resolved[idx - 1] = chRouter.Resolve(Vehicle.Car, new GeoCoordinate(latitude, longitude));
}
Assert.IsNotNull(resolvedReference[idx - 1]);
Assert.IsNotNull(resolved[idx - 1]);
Assert.AreEqual(resolvedReference[idx - 1].Location.Latitude,
resolved[idx - 1].Location.Latitude, 0.0001);
Assert.AreEqual(resolvedReference[idx - 1].Location.Longitude,
resolved[idx - 1].Location.Longitude, 0.0001);
}
// limit tests to a fixed number.
int maxTestCount = 100;
int testEveryOther = (resolved.Length * resolved.Length) / maxTestCount;
testEveryOther = System.Math.Max(testEveryOther, 1);
// check all the routes having the same weight(s).
for (int fromIdx = 0; fromIdx < resolved.Length; fromIdx++)
{
for (int toIdx = 0; toIdx < resolved.Length; toIdx++)
{
int testNumber = fromIdx * resolved.Length + toIdx;
if (testNumber % testEveryOther == 0)
{
Route referenceRoute = _referenceRouter.Calculate(Vehicle.Car,
resolvedReference[fromIdx], resolvedReference[toIdx]);
Route route = chRouter.Calculate(Vehicle.Car,
resolved[fromIdx], resolved[toIdx]);
if (referenceRoute != null)
{
Assert.IsNotNull(referenceRoute);
Assert.IsNotNull(route);
this.CompareRoutes(referenceRoute, route);
}
}
}
}
}
_pathsBeforeContraction.Remove(vertex);
}
/// <summary>
/// Calculates all points that are at or close to the given weight.
/// </summary>
/// <param name="graph"></param>
/// <param name="interpreter"></param>
/// <param name="vehicle"></param>
/// <param name="source"></param>
/// <param name="weight"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public HashSet <long> CalculateRange(IBasicRouterDataSource <LiveEdge> graph, IRoutingInterpreter interpreter,
Vehicle vehicle, PathSegmentVisitList source, double weight, Dictionary <string, object> parameters)
{
return(this.CalculateRange(graph, interpreter, vehicle, source, weight, true, null));
}
/// <summary>
/// Calculates the shortest path from the given vertex to the given vertex given the weights in the graph.
/// </summary>
/// <param name="vehicle"></param>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="graph"></param>
/// <param name="interpreter"></param>
/// <param name="max"></param>
/// <returns></returns>
public PathSegment <long> Calculate(IDynamicGraphReadOnly <LiveEdge> graph, IRoutingInterpreter interpreter,
Vehicle vehicle, PathSegmentVisitList from, PathSegmentVisitList to, double max)
{
return(this.CalculateToClosest(graph, interpreter, vehicle, from,
new PathSegmentVisitList[] { to }, max));
}
