void ProcessNeighbor(GenericBinaryHeapPriorityQueue <VisibilityVertex> pq, VisibilityEdge l,
VisibilityVertex v)
{
var len = l.Length;
var c = _current.Distance + len;
if (c >= upperBound)
{
return;
}
if (targets.Contains(v))
{
upperBound = c;
closestTarget = v;
}
if (v != sources && _visGraph.PreviosVertex(v) == null)
{
v.Distance = c;
_visGraph.SetPreviousEdge(v, l);
pq.Enqueue(v, c);
}
else if (c < v.Distance)
{
//This condition should never hold for the dequeued nodes.
//However because of a very rare case of an epsilon error it might!
//In this case DecreasePriority will fail to find "v" and the algorithm will continue working.
//Since v is not in the queue changing its .Distance will not mess up the queue.
//Changing v.Prev is fine since we come up with a path with an insignificantly
//smaller distance.
v.Distance = c;
_visGraph.SetPreviousEdge(v, l);
pq.DecreasePriority(v, c);
}
}
void ProcessBoneEdge(SdVertex v, SdVertex queueCandidate, SdBoneEdge boneEdge)
{
double newCost = GetEdgeAdditionalCost(boneEdge, v.Cost);
if (queueCandidate.Cost <= newCost)
{
return;
}
queueCandidate.Cost = newCost;
queueCandidate.PrevEdge = boneEdge;
if (Queue.ContainsElement(queueCandidate))
{
Queue.DecreasePriority(queueCandidate, newCost);
}
else
{
if (queueCandidate.IsTargetOfRouting)
{
double costToTarget = 0;
if (CurrentEdgeGeometry.TargetPort is ClusterBoundaryPort)
{
costToTarget = LengthCoefficient * (queueCandidate.Point - CurrentEdgeGeometry.TargetPort.Location).Length;
}
if (newCost + costToTarget < LowestCostToTarget)
{
LowestCostToTarget = newCost + costToTarget;
ClosestTargetVertex = queueCandidate;
}
return; //do not enqueue the target vertices
}
Enqueue(queueCandidate);
}
}
void ProcessEdge(Edge edge, LgNodeInfo otherVert, double cost)
{
if (otherVert.Processed)
{
return;
}
var len = (edge.Source.Center - edge.Target.Center).Length;
double newCost = len + cost;
if (newCost >= otherVert.Cost)
{
return;
}
otherVert.Prev = edge;
if (otherVert.Cost == double.PositiveInfinity)
{
otherVert.Cost = newCost;
q.Enqueue(otherVert, newCost);
}
else
{
otherVert.Cost = newCost;
q.DecreasePriority(otherVert, newCost);
}
}
void ProcessNeighbor(GenericBinaryHeapPriorityQueue <VisibilityVertex> pq, VisibilityVertex u, VisibilityEdge l, VisibilityVertex v)
{
var len = l.Length;
var c = u.Distance + len;
if (v != source && _visGraph.PreviosVertex(v) == null)
{
v.Distance = c;
_visGraph.SetPreviousEdge(v, l);
if (v != target)
{
pq.Enqueue(v, H(v));
}
}
else if (c < v.Distance) //This condition should never hold for the dequeued nodes.
//However because of a very rare case of an epsilon error it might!
//In this case DecreasePriority will fail to find "v" and the algorithm will continue working.
//Since v is not in the queue changing its .Distance will not influence other nodes.
//Changing v.Prev is fine since we come up with the path with an insignificantly
//smaller distance.
{
v.Distance = c;
_visGraph.SetPreviousEdge(v, l);
if (v != target)
{
pq.DecreasePriority(v, H(v));
}
}
}
private void UpdateEntryToNeighborVertexIfNeeded(VertexEntry bestEntry, VertexEntry neigEntry, double weight)
{
int numberOfBends;
double length;
var dirToNeighbor = GetLengthAndNumberOfBendsToNeighborVertex(bestEntry, neigEntry.Vertex, weight, out numberOfBends, out length);
if (CombinedCost(length, numberOfBends) < CombinedCost(neigEntry.Length, neigEntry.NumberOfBends))
{
var newCost = this.TotalCostFromSourceToVertex(length, numberOfBends) + HeuristicDistanceFromVertexToTarget(neigEntry.Vertex.Point, dirToNeighbor);
neigEntry.ResetEntry(bestEntry, length, numberOfBends, newCost);
queue.DecreasePriority(neigEntry, newCost);
}
}
void ProcessNeighbor(GenericBinaryHeapPriorityQueue <VisibilityVertex> pq, VisibilityVertex u, VisibilityEdge l, VisibilityVertex v, int penalty)
{
var len = l.Length + penalty;
var c = u.Distance + len;
/*
* if (_visGraph.visVertexToId[l.Source] < _g.N || _visGraph.visVertexToId[l.Target] < _g.N)
* {
* if (!(l.Source == _source || l.Target == _source || l.Source == _target || l.Target == _target))
* {
* c = 500;
* }
* }
*/
// (v != _source && _visGraph.PreviosVertex(v) == null)
if (v != _source && _visGraph.PreviosVertex(v) == null)
{
v.Distance = c;
_visGraph.SetPreviousEdge(v, l);
if (v != _target)
{
pq.Enqueue(v, H(v));
}
}
else if (v != _source && c < v.Distance)
{ //This condition should never hold for the dequeued nodes.
//However because of a very rare case of an epsilon error it might!
//In this case DecreasePriority will fail to find "v" and the algorithm will continue working.
//Since v is not in the queue changing its .Distance will not influence other nodes.
//Changing v.Prev is fine since we come up with the path with an insignificantly
//smaller distance.
var prevV = _visGraph.PreviosVertex(v);
v.Distance = c;
_visGraph.SetPreviousEdge(v, l);
if (v != _target)
{
pq.DecreasePriority(v, H(v));
}
}
}
void ProcessNeighbor(GenericBinaryHeapPriorityQueue<VisibilityVertex> pq, VisibilityEdge l,
VisibilityVertex v) {
var len = l.Length;
var c = current.Distance + len;
if (c >= upperBound)
return;
if (targets.Contains(v)) {
upperBound = c;
closestTarget = v;
}
if (v != source && _visGraph.PreviosVertex(v) == null) {
v.Distance = c;
_visGraph.SetPreviousEdge(v, l);
pq.Enqueue(v, c);
} else if (c < v.Distance) {
//This condition should never hold for the dequeued nodes.
//However because of a very rare case of an epsilon error it might!
//In this case DecreasePriority will fail to find "v" and the algorithm will continue working.
//Since v is not in the queue changing its .Distance will not mess up the queue.
//Changing v.Prev is fine since we come up with a path with an insignificantly
//smaller distance.
v.Distance = c;
_visGraph.SetPreviousEdge(v, l);
pq.DecreasePriority(v, c);
}
}
void ProcessNeighbor(GenericBinaryHeapPriorityQueue<VisibilityVertex> pq, VisibilityVertex u, VisibilityEdge l, VisibilityVertex v) {
var len = l.Length;
var c = u.Distance + len;
// (v != _source && _visGraph.PreviosVertex(v) == null)
if (v != _source && _visGraph.PreviosVertex(v) == null) {
v.Distance = c;
_visGraph.SetPreviousEdge(v, l);
if (v != _target) {
pq.Enqueue(v, H(v));
}
} else if (v != _source && c < v.Distance) { //This condition should never hold for the dequeued nodes.
//However because of a very rare case of an epsilon error it might!
//In this case DecreasePriority will fail to find "v" and the algorithm will continue working.
//Since v is not in the queue changing its .Distance will not influence other nodes.
//Changing v.Prev is fine since we come up with the path with an insignificantly
//smaller distance.
var prevV = _visGraph.PreviosVertex(v);
v.Distance = c;
_visGraph.SetPreviousEdge(v, l);
if (v != _target)
pq.DecreasePriority(v, H(v));
}
}
