Move more logic out of Main and into GraphUtils

Author: Plastix

src/main/java/io/github/plastix/GraphUtils.java

@@ -1,19 +1,29 @@
 package io.github.plastix;
 
 import com.graphhopper.routing.util.DefaultEdgeFilter;
+import com.graphhopper.routing.util.EncodingManager;
 import com.graphhopper.routing.util.FlagEncoder;
 import com.graphhopper.storage.Graph;
+import com.graphhopper.storage.index.LocationIndex;
+import com.graphhopper.storage.index.QueryResult;
 import com.graphhopper.util.EdgeExplorer;
 import com.graphhopper.util.EdgeIterator;
+import com.graphhopper.util.EdgeIteratorState;
 
 public class GraphUtils {
 
+    private Params params;
     private Graph graph;
+    private LocationIndex locationIndex;
     private FlagEncoder flagEncoder;
+    private BikePriorityWeighting weighting;
 
-    GraphUtils(Graph graph, FlagEncoder flagEncoder) {
+    GraphUtils(Graph graph, LocationIndex locationIndex, EncodingManager encodingManager, Params params) {
         this.graph = graph;
-        this.flagEncoder = flagEncoder;
+        this.locationIndex = locationIndex;
+        this.flagEncoder = encodingManager.getEncoder(params.getVehicle());
+        this.params = params;
+        weighting = new BikePriorityWeighting(flagEncoder);
     }
 
     public EdgeIterator outgoingEdges(int node) {
@@ -36,4 +46,25 @@ public EdgeExplorer getEdgeExplorer() {
         return graph.createEdgeExplorer(new DefaultEdgeFilter(flagEncoder));
     }
 
+    public double getArcScore(EdgeIteratorState edge) {
+        return weighting.calcWeight(edge, false, edge.getEdge());
+    }
+
+    public int getStartNode() {
+        QueryResult result = locationIndex.findClosest(params.getStartLat(), params.getStartLon(),
+                new DefaultEdgeFilter(flagEncoder));
+        if(!result.isValid()) {
+            throw new RuntimeException("Unable to find node at start lat/lon!");
+        }
+        return result.getClosestNode();
+
+    }
+
+    public boolean isForward(EdgeIteratorState edge) {
+        return edge.isForward(flagEncoder);
+    }
+
+    public boolean isBackward(EdgeIteratorState edge) {
+        return edge.isBackward(flagEncoder);
+    }
 }

src/main/java/io/github/plastix/Main.java

@@ -4,12 +4,8 @@
 import com.graphhopper.GraphHopper;
 import com.graphhopper.reader.osm.GraphHopperOSM;
 import com.graphhopper.routing.util.AllEdgesIterator;
-import com.graphhopper.routing.util.DefaultEdgeFilter;
 import com.graphhopper.routing.util.EncodingManager;
-import com.graphhopper.routing.util.FlagEncoder;
-import com.graphhopper.routing.weighting.Weighting;
 import com.graphhopper.storage.Graph;
-import com.graphhopper.storage.index.QueryResult;
 import com.graphhopper.util.EdgeIterator;
 import gurobi.*;
 
@@ -22,8 +18,6 @@ public class Main {
     private static GraphHopper hopper;
     private static Graph graph;
     private static GraphUtils graphUtils;
-    private static Weighting score;
-    private static FlagEncoder flagEncoder;
 
     // Solver variables
     private static GRBEnv env;
@@ -32,7 +26,7 @@ public class Main {
     private static void setupSolver() throws GRBException {
         env = new GRBEnv("osm.log");
         model = new GRBModel(env);
-        Vars vars = new Vars(graph, model, flagEncoder);
+        Vars vars = new Vars(graph, model, graphUtils);
 
         // (1a)
         // Objective maximizes total collected score of all roads
@@ -44,7 +38,7 @@ private static void setupSolver() throws GRBException {
 
         AllEdgesIterator edges = graph.getAllEdges();
         while(edges.next()) {
-            double edgeScore = score.calcWeight(edges, false, edges.getEdge());
+            double edgeScore = graphUtils.getArcScore(edges);
             double edgeDist = edges.getDistance();
 
             GRBVar forward = vars.getArc(edges);
@@ -136,18 +130,8 @@ private static void loadOSM() {
         hopper.importOrLoad();
 
         graph = hopper.getGraphHopperStorage().getBaseGraph();
-        flagEncoder = encodingManager.getEncoder(params.getVehicle());
-        score = new BikePriorityWeighting(flagEncoder);
-        graphUtils = new GraphUtils(graph, flagEncoder);
-
-        QueryResult result = hopper.getLocationIndex().findClosest(params.getStartLat(), params.getStartLon(),
-                new DefaultEdgeFilter(flagEncoder));
-        if(!result.isValid()) {
-            System.out.println("Unable to find starting node near lat/lon points!");
-            System.exit(1);
-        }
-
-        START_NODE_ID = result.getClosestNode();
+        graphUtils = new GraphUtils(graph, hopper.getLocationIndex(), encodingManager, params);
+        START_NODE_ID = graphUtils.getStartNode();
 
         AllEdgesIterator edges = graph.getAllEdges();
         int nonTraversable = 0;

src/main/java/io/github/plastix/Vars.java

@@ -1,7 +1,6 @@
 package io.github.plastix;
 
 import com.graphhopper.routing.util.AllEdgesIterator;
-import com.graphhopper.routing.util.FlagEncoder;
 import com.graphhopper.storage.Graph;
 import com.graphhopper.util.EdgeIterator;
 import gurobi.GRB;
@@ -14,7 +13,7 @@
 public class Vars {
 
     private Graph graph;
-    private FlagEncoder flagEncoder;
+    private GraphUtils graphUtils;
     private GRBModel model;
 
     // arcs[arcId][0] = forwardArc
@@ -23,10 +22,10 @@ public class Vars {
     private GRBVar[] verts;
     private int[] arcBaseIds;
 
-    Vars(Graph graph, GRBModel model, FlagEncoder flagEncoder) throws GRBException {
+    Vars(Graph graph, GRBModel model, GraphUtils graphUtils) throws GRBException {
         this.graph = graph;
         this.model = model;
-        this.flagEncoder = flagEncoder;
+        this.graphUtils = graphUtils;
         addVarsToModel();
     }
 
@@ -60,11 +59,11 @@ private void addVarsToModel() throws GRBException {
             arcs[edgeId][0] = forward;
             arcs[edgeId][1] = backward;
 
-            if(!edges.isForward(flagEncoder)) {
+            if(!graphUtils.isForward(edges)) {
                 forward.set(GRB.DoubleAttr.UB, 0);
             }
 
-            if(!edges.isBackward(flagEncoder)) {
+            if(!graphUtils.isBackward(edges)) {
                 backward.set(GRB.DoubleAttr.UB, 0);
             }
         }