/// <summary>
/// Returns a path
/// </summary>
/// <returns>a path or null if the target is not reachable from the source</returns>
internal IEnumerable <VisibilityVertex> GetPath()
{
var pq = new GenericBinaryHeapPriorityQueue <VisibilityVertex>();
foreach (var v in sources)
{
v.Distance = 0;
pq.Enqueue(v, 0);
}
while (!pq.IsEmpty())
{
_current = pq.Dequeue();
if (targets.Contains(_current))
{
break;
}
foreach (var e in _current.OutEdges.Where(PassableOutEdge))
{
ProcessNeighbor(pq, e, e.Target);
}
foreach (var e in _current.InEdges.Where(PassableInEdge))
{
ProcessNeighbor(pq, e, e.Source);
}
}
return(_visGraph.PreviosVertex(_current) == null ? null : CalculatePath());
}
List <SdBoneEdge> RouteOnKnownSourceTargetVertices(Point pathDirection, bool lookingForMonotonePath)
{
LowestCostToTarget = Double.PositiveInfinity;
ClosestTargetVertex = null;
while (Queue.Count > 0)
{
double hu;
SdVertex bestNode = Queue.Dequeue(out hu);
if (hu >= LowestCostToTarget)
{
continue;
}
//update the rest
for (int i = 0; i < bestNode.OutBoneEdges.Count; i++)
{
var outBoneEdge = bestNode.OutBoneEdges[i];
if (outBoneEdge.IsPassable)
{
ProcessOutcomingBoneEdge(bestNode, outBoneEdge, pathDirection, lookingForMonotonePath);
}
}
for (int i = 0; i < bestNode.InBoneEdges.Count; i++)
{
var inBoneEdge = bestNode.InBoneEdges[i];
if (inBoneEdge.IsPassable)
{
ProcessIncomingBoneEdge(bestNode, inBoneEdge, pathDirection, lookingForMonotonePath);
}
}
}
return(GetPathAndUpdateRelatedCosts());
}
/// <summary>
/// Grow hubs
/// </summary>
bool GrowHubs(bool useHalfEdgesAsIdealR)
{
var queue = new GenericBinaryHeapPriorityQueue <Station>();
foreach (var v in metroGraphData.VirtualNodes())
{
queue.Enqueue(v, -CalculatePotential(v, useHalfEdgesAsIdealR));
}
bool progress = false;
//choose a hub with the greatest potential
while (!queue.IsEmpty())
{
double hu;
Station v = queue.Dequeue(out hu);
if (hu >= 0)
{
break;
}
//grow the hub
if (TryGrowHub(v, useHalfEdgesAsIdealR))
{
queue.Enqueue(v, -CalculatePotential(v, useHalfEdgesAsIdealR));
progress = true;
}
}
return(progress);
}
/// <summary>
/// Returns a path
/// </summary>
/// <returns>a path or null if the target is not reachable from the source</returns>
internal IEnumerable<VisibilityVertex> GetPath(bool shrinkEdgeLength) {
var pq = new GenericBinaryHeapPriorityQueue<VisibilityVertex>();
_source.Distance = 0;
_target.Distance = double.PositiveInfinity;
pq.Enqueue(_source, H(_source));
while (!pq.IsEmpty()) {
double hu;
var u = pq.Dequeue(out hu);
if (hu >= _target.Distance)
break;
foreach (var e in u.OutEdges) {
if (PassableOutEdge(e)) {
var v = e.Target;
ProcessNeighbor(pq, u, e, v);
}
}
foreach (var e in u.InEdges) {
if (PassableInEdge(e)) {
var v = e.Source;
ProcessNeighbor(pq, u, e, v);
}
}
}
return _visGraph.PreviosVertex(_target) == null
? null
: CalculatePath(shrinkEdgeLength);
}
internal void Run()
{
source.Cost = 0;
source.Processed = true;
q.Enqueue(source, 0);
while (q.Count > 0)
{
double cost;
var n = q.Dequeue(out cost);
ProcessNode(n);
}
}
/// <summary>
/// Returns a path
/// </summary>
/// <returns>a path or null if the target is not reachable from the source</returns>
internal IEnumerable <VisibilityVertex> GetPath(bool shrinkEdgeLength)
{
var pq = new GenericBinaryHeapPriorityQueue <VisibilityVertex>();
_source.Distance = 0;
_target.Distance = double.PositiveInfinity;
pq.Enqueue(_source, H(_source));
while (!pq.IsEmpty())
{
double hu;
var u = pq.Dequeue(out hu);
if (hu >= _target.Distance)
{
break;
}
foreach (var e in u.OutEdges)
{
if (PassableOutEdge(e))
{
var v = e.Target;
if (u != _source && u.isReal)
{
ProcessNeighbor(pq, u, e, v, 1000);
}
else
{
ProcessNeighbor(pq, u, e, v);
}
}
}
foreach (var e in u.InEdges)
{
if (PassableInEdge(e))
{
var v = e.Source;
ProcessNeighbor(pq, u, e, v);
}
}
}
return(_visGraph.PreviosVertex(_target) == null
? null
: CalculatePath(shrinkEdgeLength));
}
IEnumerable <Edge> SearchForPath()
{
while (queue.Count > 0)
{
double costPlus;
var node = queue.Dequeue(out costPlus);
if (costPlus >= costToTarget)
{
break;
}
double cost = node == source ? 0 : prev[node].Item2;
ProcessVertex(node, cost);
}
IEnumerable <Edge> ret = RecoverPath();
return(ret);
}
/// <summary>
/// Returns a path
/// </summary>
/// <returns>a path or null if the target is not reachable from the source</returns>
internal IEnumerable<VisibilityVertex> GetPath() {
var pq = new GenericBinaryHeapPriorityQueue<VisibilityVertex>();
source.Distance = 0;
pq.Enqueue(source, 0);
while (!pq.IsEmpty()) {
current = pq.Dequeue();
if (targets.Contains(current))
break;
foreach (var e in current.OutEdges.Where(PassableOutEdge))
ProcessNeighbor(pq, e, e.Target);
foreach (var e in current.InEdges.Where(PassableInEdge))
ProcessNeighbor(pq, e, e.Source);
}
return _visGraph.PreviosVertex(current) == null ? null : CalculatePath();
}
/// <summary>
/// Grow hubs
/// </summary>
bool GrowHubs(bool useHalfEdgesAsIdealR) {
var queue = new GenericBinaryHeapPriorityQueue<Station>();
foreach (var v in metroGraphData.VirtualNodes()) {
queue.Enqueue(v, -CalculatePotential(v, useHalfEdgesAsIdealR));
}
bool progress = false;
//choose a hub with the greatest potential
while (!queue.IsEmpty()) {
double hu;
Station v = queue.Dequeue(out hu);
if (hu >= 0)
break;
//grow the hub
if (TryGrowHub(v, useHalfEdgesAsIdealR)) {
queue.Enqueue(v, -CalculatePotential(v, useHalfEdgesAsIdealR));
progress = true;
}
}
return progress;
}
internal VertexEntry GetPathWithCost(VertexEntry[] sourceVertexEntries, VisibilityVertexRectilinear source, double adjustmentToSourceCost,
VertexEntry[] targetVertexEntries, VisibilityVertexRectilinear target, double adjustmentToTargetCost,
double priorBestCost)
{
this.upperBoundOnCost = priorBestCost;
this.sourceCostAdjustment = adjustmentToSourceCost;
this.targetCostAdjustment = adjustmentToTargetCost;
DevTracePrintSourceAndTarget(source, target);
if (!InitPath(sourceVertexEntries, source, target))
{
this.DevTraceShowPath(source, null);
return(null);
}
while (queue.Count > 0)
{
this.TestPreDequeue();
var bestEntry = queue.Dequeue();
var bestVertex = bestEntry.Vertex;
if (bestVertex == Target)
{
this.DevTraceShowPath(source, bestEntry);
if (targetVertexEntries == null)
{
Cleanup();
return(bestEntry);
}
// We'll never get a duplicate entry direction here; we either relaxed the cost via UpdateEntryToNeighborIfNeeded
// before we dequeued it, or it was closed. So, we simply remove the direction from the valid target entry directions
// and if we get to none, we're done. We return a null path until the final stage.
#if SHARPKIT //http://code.google.com/p/sharpkit/issues/detail?id=368 property assignment not working with &= operator
this.EntryDirectionsToTarget = this.EntryDirectionsToTarget & ~bestEntry.Direction;
#else
this.EntryDirectionsToTarget &= ~bestEntry.Direction;
#endif
if (this.EntryDirectionsToTarget == Direction.None)
{
this.Target.VertexEntries.CopyTo(targetVertexEntries, 0);
Cleanup();
return(null);
}
this.upperBoundOnCost = Math.Min(this.MultistageAdjustedCostBound(bestEntry.Cost), this.upperBoundOnCost);
continue;
}
// It's safe to close this after removing it from the queue. Any updateEntryIfNeeded that changes it must come
// while it is still on the queue; it is removed from the queue only if it has the lowest cost path, and we have
// no negative path weights, so any other path that might try to extend to it after this cannot have a lower cost.
bestEntry.IsClosed = true;
// PerfNote: Array.ForEach is optimized, but don't use .Where.
foreach (var bendNeighbor in this.nextNeighbors)
{
bendNeighbor.Clear();
}
var preferredBendDir = Right(bestEntry.Direction);
this.ExtendPathAlongInEdges(bestEntry, bestVertex.InEdges, preferredBendDir);
this.ExtendPathAlongOutEdges(bestEntry, bestVertex.OutEdges, preferredBendDir);
foreach (var bendNeighbor in this.nextNeighbors)
{
if (bendNeighbor.Vertex != null)
{
this.ExtendPathToNeighborVertex(bestEntry, bendNeighbor.Vertex, bendNeighbor.Weight);
}
}
this.DevTraceShowAllPartialPaths(source, bestEntry);
}
// Either there is no path to the target, or we have abandoned the path due to exceeding priorBestCost.
if ((targetVertexEntries != null) && (this.Target.VertexEntries != null))
{
this.Target.VertexEntries.CopyTo(targetVertexEntries, 0);
}
this.DevTraceShowPath(source, null);
Cleanup();
return(null);
}