Add method to limit Dijkstra by radius

agouge · agouge · commit 62cc779ed131 · 2013-10-16T20:18:13.000+02:00
diff --git a/pom.xml b/pom.xml
@@ -4,7 +4,7 @@
 
     <groupId>org.javanetworkanalyzer</groupId>
     <artifactId>java-network-analyzer</artifactId>
-    <version>0.1.2</version>
+    <version>0.1.3-SNAPSHOT</version>
     <packaging>bundle</packaging>
 
     <name>Java-Network-Analyzer</name>
diff --git a/src/main/java/org/javanetworkanalyzer/alg/Dijkstra.java b/src/main/java/org/javanetworkanalyzer/alg/Dijkstra.java
@@ -26,6 +26,7 @@
 
 import org.javanetworkanalyzer.data.VDijkstra;
 import org.javanetworkanalyzer.model.EdgeSPT;
+import org.javanetworkanalyzer.model.TraversalGraph;
 import org.jgrapht.DirectedGraph;
 import org.jgrapht.Graph;
 import org.jgrapht.Graphs;
@@ -52,6 +53,11 @@ public class Dijkstra<V extends VDijkstra, E extends EdgeSPT>
      * have the same length.
      */
     protected static final double TOLERANCE = 0.000000001;
+    /**
+     * Distance of the node furthest away in the shortest path tree thus far.
+     */
+    private double largestDistanceSoFar = 0.0;
+
 
     /**
      * Constructor.
@@ -70,10 +76,20 @@ public Dijkstra(Graph<V, E> graph) {
      */
     @Override
     public void calculate(V startNode) {
+        calculate(startNode, Double.POSITIVE_INFINITY);
+    }
 
+    /**
+     * Does a Dijkstra search from the given start node to all other nodes,
+     * limiting the search by the given radius.
+     *
+     * @param startNode Start node
+     * @param radius    Radius by which to limit the search
+     */
+    public void calculate(V startNode, double radius) {
         init(startNode);
 
-        while (!queue.isEmpty()) {
+        while (!queue.isEmpty() && largestDistanceSoFar < radius) {
             // Extract the minimum element.
             V u = queue.poll();
             // Do any pre-relax step.
@@ -150,6 +166,7 @@ protected void shortestPathSoFarUpdate(V startNode, V u, V v, Double uvWeight,
         v.addPredecessorEdge(e);
         // Set the distance
         v.setDistance(u.getDistance() + uvWeight);
+        largestDistanceSoFar = v.getDistance();
         // Update the queue.
         queue.remove(v);
         queue.add(v);
@@ -188,6 +205,46 @@ public int compare(V v1, V v2) {
                 });
     }
 
+    /**
+     * Returns the SPT from the last start node {@link #calculate} was called on,
+     * limited by the given radius. The shortest path "tree" we return may
+     * contain multiple shortest paths.
+     *
+     * @param radius The radius to limit by
+     * @return The SPT/traversal graph from the last start node {@link #calculate}
+     *         was called on
+     */
+    public TraversalGraph<V, E> reconstructTraversalGraphLimitedByRadius(double radius) {
+
+        if (currentStartNode == null) {
+            throw new IllegalStateException("You must call #calculate before " +
+                    "reconstructing the traversal graph.");
+        }
+
+        TraversalGraph<V, E> traversalGraph = new TraversalGraph<V, E>(
+                graph.getEdgeFactory(), currentStartNode);
+        for (V v : graph.vertexSet()) {
+            Set<E> predEdges = (Set<E>) v.getPredecessorEdges();
+            for (E e : predEdges) {
+                V source = graph.getEdgeSource(e);
+                V target = graph.getEdgeTarget(e);
+                if (source.getDistance() < radius && target.getDistance() < radius) {
+                    traversalGraph.addVertex(source);
+                    traversalGraph.addVertex(target);
+                    if (v.equals(source)) {
+                        traversalGraph.addEdge(target, source).setBaseGraphEdge(e);
+                    } else if (v.equals(target)) {
+                        traversalGraph.addEdge(source, target).setBaseGraphEdge(e);
+                    } else {
+                        throw new IllegalStateException("A vertex has a predecessor " +
+                                "edge not ending on itself.");
+                    }
+                }
+            }
+        }
+        return traversalGraph;
+    }
+
     /**
      * Performs a Dijkstra search from the source, stopping once the target is
      * found.
diff --git a/src/main/java/org/javanetworkanalyzer/alg/GraphSearchAlgorithm.java b/src/main/java/org/javanetworkanalyzer/alg/GraphSearchAlgorithm.java
@@ -53,7 +53,7 @@ public abstract class GraphSearchAlgorithm<V extends VPred, E extends EdgeSPT>
     /**
      * Current start node
      */
-    private V currentStartNode;
+    protected V currentStartNode;
 
     /**
      * Constructor. The user can specify whether SPTs/traversal graphs are
