Merge branch 'master' into client_hc_vehicle_to_profile

Author: easbar

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,3 @@
+Please read [our contributing guide](https://github.com/graphhopper/graphhopper/blob/master/CONTRIBUTING.md) and note that also your contribution falls under the Apache License 2.0 as outlined there.
+
+Your first contribution should include a change where you add yourself to the CONTRIBUTORS.md file.

CONTRIBUTING.md

@@ -25,19 +25,8 @@ appear on your fork its github page afterwards.
 
 ## License Agreement
 
-For contributions like pull requests, bug fixes and translations please read 
-the <a href="https://graphhopper.com/agreements/individual-cla.html">GraphHopper License Agreement</a>, which includes our
-<a href="https://graphhopper.com/agreements/cccoc.html">contributor covenant code of conduct</a>.
-<a href="https://graphhopper.com/#contact">Send us</a> an email with the signed print out of this CLA. Or, if you prefer
-the faster electronically method via signaturit.com, please send us an email with a request for this - 
-keep in mind that this requires storing your Email there.
-
-For companies that would like that their developers work for us, we need an additional [corporate CLA signed](https://graphhopper.com/agreements/corporate-cla.html).
-
-Note, our CLA does not influence your rights on your contribution but it makes sure for others that you agree to the Apache License, Version 2.
-After this you'll appear in the <a href="CONTRIBUTORS.md">contributors list</a> and your pull request can also be discussed technically.
-
-Read more in [this issue](https://github.com/graphhopper/graphhopper/pull/1129#issuecomment-375820168) why it is not that easy to make this CLA-signing process simpler for first-time contributors and maintainers.
+All contributions like pull requests, bug fixes, documentation changes and translations fall under the Apache License and contributors agree to our
+<a href="https://www.graphhopper.com/code-of-conduct/">contributor covenant code of conduct</a>.
 
 ## Code formatting
 

CONTRIBUTORS.md

@@ -1,9 +1,6 @@
 # Contributors
 
-Most of the contributors are mentioned at Github as [Members](https://github.com/graphhopper?tab=members) or [Contributors](https://github.com/graphhopper/graphhopper/contributors). 
-
-Contributors that agree to the [project its CLA](https://www.graphhopper.com/individual-contributor-license-agreement/)
-state this as a comment via a separate, signed commit.
+Most of the contributors are mentioned at Github as [Members](https://github.com/graphhopper?tab=members) or [Contributors](https://github.com/graphhopper/graphhopper/contributors).
 
 Here is an overview:
 

config-example.yml

@@ -123,7 +123,7 @@ graphhopper:
 
   # In many cases the road network consists of independent components without any routes going in between. In
   # the most simple case you can imagine an island without a bridge or ferry connection. The following parameter
-  # allows setting a minimum size (number of nodes) for such detached components. This can be used to reduce the number
+  # allows setting a minimum size (number of edges) for such detached components. This can be used to reduce the number
   # of cases where a connection between locations might not be found.
   prepare.min_network_size: 200
 

core/src/main/java/com/graphhopper/GraphHopper.java

@@ -1106,7 +1106,7 @@ private List<PrepareJob> buildSubnetworkRemovalJobs() {
                 TurnCostProvider turnCostProvider = new DefaultTurnCostProvider(encoder, ghStorage.getTurnCostStorage(), 0);
                 jobs.add(new PrepareJob(encoder.toString(), encoder.getAccessEnc(), turnCostProvider));
             } else {
-                jobs.add(new PrepareJob(encoder.toString(), encoder.getAccessEnc(), null));
+                jobs.add(new PrepareJob(encoder.toString(), encoder.getAccessEnc(), TurnCostProvider.NO_TURN_COST_PROVIDER));
             }
         }
         return jobs;

core/src/main/java/com/graphhopper/routing/AlgorithmOptions.java

@@ -18,91 +18,53 @@
 package com.graphhopper.routing;
 
 import com.graphhopper.routing.util.TraversalMode;
-import com.graphhopper.routing.weighting.Weighting;
 import com.graphhopper.util.PMap;
 import com.graphhopper.util.Parameters;
 
 /**
- * The algorithm options. Create an immutable object via:
- * <pre>
- * AlgorithmOptions algoOpts = AlgorithmOptions.start().
- *        algorithm(Parameters.Algorithms.DIJKSTRA).
- *        weighting(weighting).
- *        build();
- * </pre>
- * <p>
- *
  * @author Peter Karich
  */
 public class AlgorithmOptions {
-    private final PMap hints = new PMap(5);
+    private PMap hints = new PMap();
     private String algorithm = Parameters.Algorithms.DIJKSTRA_BI;
-    private Weighting weighting;
     private TraversalMode traversalMode = TraversalMode.NODE_BASED;
     private int maxVisitedNodes = Integer.MAX_VALUE;
 
-    private AlgorithmOptions() {
+    public AlgorithmOptions() {
     }
 
-    /**
-     * Default traversal mode NODE_BASED is used.
-     */
-    public AlgorithmOptions(String algorithm, Weighting weighting) {
-        this.algorithm = algorithm;
-        this.weighting = weighting;
+    public AlgorithmOptions(AlgorithmOptions b) {
+        setAlgorithm(b.getAlgorithm());
+        setTraversalMode(b.getTraversalMode());
+        setMaxVisitedNodes(b.getMaxVisitedNodes());
+        setHints(b.getHints());
     }
 
-    public AlgorithmOptions(String algorithm, Weighting weighting, TraversalMode tMode) {
+    public AlgorithmOptions setAlgorithm(String algorithm) {
         this.algorithm = algorithm;
-        this.weighting = weighting;
-        this.traversalMode = tMode;
+        return this;
     }
 
-    /**
-     * This method starts the building process for AlgorithmOptions.
-     */
-    public static Builder start() {
-        return new Builder();
+    public AlgorithmOptions setTraversalMode(TraversalMode traversalMode) {
+        this.traversalMode = traversalMode;
+        return this;
     }
 
-    /**
-     * This method clones the specified AlgorithmOption object with the possibility for further
-     * changes.
-     */
-    public static Builder start(AlgorithmOptions opts) {
-        Builder b = new Builder();
-        if (opts.algorithm != null)
-            b.algorithm(opts.getAlgorithm());
-        if (opts.traversalMode != null)
-            b.traversalMode(opts.getTraversalMode());
-        if (opts.weighting != null)
-            b.weighting(opts.getWeighting());
-        if (opts.maxVisitedNodes >= 0)
-            b.maxVisitedNodes(opts.maxVisitedNodes);
-        if (!opts.hints.isEmpty())
-            b.hints(opts.hints);
+    public AlgorithmOptions setMaxVisitedNodes(int maxVisitedNodes) {
+        this.maxVisitedNodes = maxVisitedNodes;
+        return this;
+    }
 
-        return b;
+    public AlgorithmOptions setHints(PMap pMap) {
+        this.hints = new PMap(pMap);
+        return this;
     }
 
-    /**
-     * @return the traversal mode, where node-based is the default.
-     */
     public TraversalMode getTraversalMode() {
         return traversalMode;
     }
 
-    public boolean hasWeighting() {
-        return weighting != null;
-    }
-
-    public Weighting getWeighting() {
-        assertNotNull(weighting, "weighting");
-        return weighting;
-    }
-
     public String getAlgorithm() {
-        assertNotNull(algorithm, "algorithm");
         return algorithm;
     }
 
@@ -114,57 +76,9 @@ public PMap getHints() {
         return hints;
     }
 
-    private void assertNotNull(Object optionValue, String optionName) {
-        if (optionValue == null)
-            throw new NullPointerException("Option '" + optionName + "' must NOT be null");
-    }
-
     @Override
     public String toString() {
-        return algorithm + ", " + weighting + ", " + traversalMode;
+        return algorithm + ", " + traversalMode;
     }
 
-    public static class Builder {
-        private AlgorithmOptions opts = new AlgorithmOptions();
-        private boolean buildCalled;
-
-        public Builder traversalMode(TraversalMode traversalMode) {
-            if (traversalMode == null)
-                throw new IllegalArgumentException("null as traversal mode is not allowed");
-
-            this.opts.traversalMode = traversalMode;
-            return this;
-        }
-
-        public Builder weighting(Weighting weighting) {
-            this.opts.weighting = weighting;
-            return this;
-        }
-
-        /**
-         * For possible values see {@link Parameters.Algorithms}
-         */
-        public Builder algorithm(String algorithm) {
-            this.opts.algorithm = algorithm;
-            return this;
-        }
-
-        public Builder maxVisitedNodes(int maxVisitedNodes) {
-            this.opts.maxVisitedNodes = maxVisitedNodes;
-            return this;
-        }
-
-        public Builder hints(PMap hints) {
-            this.opts.hints.putAll(hints);
-            return this;
-        }
-
-        public AlgorithmOptions build() {
-            if (buildCalled)
-                throw new IllegalStateException("Cannot call AlgorithmOptions.Builder.build() twice");
-
-            buildCalled = true;
-            return opts;
-        }
-    }
 }

core/src/main/java/com/graphhopper/routing/FlexiblePathCalculator.java

@@ -20,6 +20,7 @@
 
 import com.carrotsearch.hppc.cursors.IntCursor;
 import com.graphhopper.routing.querygraph.QueryGraph;
+import com.graphhopper.routing.weighting.Weighting;
 import com.graphhopper.util.Parameters;
 import com.graphhopper.util.StopWatch;
 
@@ -31,13 +32,15 @@
 public class FlexiblePathCalculator implements PathCalculator {
     private final QueryGraph queryGraph;
     private final RoutingAlgorithmFactory algoFactory;
+    private Weighting weighting;
     private AlgorithmOptions algoOpts;
     private String debug;
     private int visitedNodes;
 
-    public FlexiblePathCalculator(QueryGraph queryGraph, RoutingAlgorithmFactory algoFactory, AlgorithmOptions algoOpts) {
+    public FlexiblePathCalculator(QueryGraph queryGraph, RoutingAlgorithmFactory algoFactory, Weighting weighting, AlgorithmOptions algoOpts) {
         this.queryGraph = queryGraph;
         this.algoFactory = algoFactory;
+        this.weighting = weighting;
         this.algoOpts = algoOpts;
     }
 
@@ -49,7 +52,7 @@ public List<Path> calcPaths(int from, int to, EdgeRestrictions edgeRestrictions)
 
     private RoutingAlgorithm createAlgo() {
         StopWatch sw = new StopWatch().start();
-        RoutingAlgorithm algo = algoFactory.createAlgo(queryGraph, algoOpts);
+        RoutingAlgorithm algo = algoFactory.createAlgo(queryGraph, weighting, algoOpts);
         debug = ", algoInit:" + (sw.stop().getNanos() / 1000) + " μs";
         return algo;
     }
@@ -97,11 +100,11 @@ public int getVisitedNodes() {
         return visitedNodes;
     }
 
-    public AlgorithmOptions getAlgoOpts() {
-        return algoOpts;
+    public Weighting getWeighting() {
+        return weighting;
     }
 
-    public void setAlgoOpts(AlgorithmOptions algoOpts) {
-        this.algoOpts = algoOpts;
+    public void setWeighting(Weighting weighting) {
+        this.weighting = weighting;
     }
 }

core/src/main/java/com/graphhopper/routing/RoundTripRouting.java

@@ -152,12 +152,10 @@ private static class RoundTripCalculator {
         RoundTripCalculator(FlexiblePathCalculator pathCalculator) {
             this.pathCalculator = pathCalculator;
             // we make the path calculator use our avoid edges weighting
-            AvoidEdgesWeighting avoidPreviousPathsWeighting = new AvoidEdgesWeighting(pathCalculator.getAlgoOpts().getWeighting())
+            AvoidEdgesWeighting avoidPreviousPathsWeighting = new AvoidEdgesWeighting(pathCalculator.getWeighting())
                     .setEdgePenaltyFactor(5);
             avoidPreviousPathsWeighting.setAvoidedEdges(previousEdges);
-            AlgorithmOptions algoOpts = AlgorithmOptions.start(pathCalculator.getAlgoOpts()).
-                    weighting(avoidPreviousPathsWeighting).build();
-            pathCalculator.setAlgoOpts(algoOpts);
+            pathCalculator.setWeighting(avoidPreviousPathsWeighting);
         }
 
         Path calcPath(int from, int to) {

core/src/main/java/com/graphhopper/routing/Router.java

@@ -121,13 +121,11 @@ public GHResponse route(GHRequest request) {
             PMap requestHints = new PMap(request.getHints());
             requestHints.putObject(CustomModel.KEY, request.getCustomModel());
             Weighting weighting = createWeighting(profile, requestHints, request.getPoints(), disableCH);
-            AlgorithmOptions algoOpts = AlgorithmOptions.start().
-                    algorithm(request.getAlgorithm()).
-                    traversalMode(traversalMode).
-                    weighting(weighting).
-                    maxVisitedNodes(maxVisitedNodesForRequest).
-                    hints(request.getHints()).
-                    build();
+            AlgorithmOptions algoOpts = new AlgorithmOptions().
+                    setAlgorithm(request.getAlgorithm()).
+                    setTraversalMode(traversalMode).
+                    setMaxVisitedNodes(maxVisitedNodesForRequest).
+                    setHints(request.getHints());
 
             if (ROUND_TRIP.equalsIgnoreCase(request.getAlgorithm())) {
                 return routeRoundTrip(request, algoOpts, weighting, profile, disableLM);
@@ -158,13 +156,10 @@ protected GHResponse routeRoundTrip(GHRequest request, AlgorithmOptions algoOpts
         ghRsp.addDebugInfo("idLookup:" + sw.stop().getSeconds() + "s");
 
         // use A* for round trips
-        AlgorithmOptions roundTripAlgoOpts = AlgorithmOptions
-                .start(algoOpts)
-                .algorithm(Parameters.Algorithms.ASTAR_BI)
-                .build();
+        AlgorithmOptions roundTripAlgoOpts = new AlgorithmOptions(algoOpts).setAlgorithm(Parameters.Algorithms.ASTAR_BI);
         roundTripAlgoOpts.getHints().putObject(Parameters.Algorithms.AStarBi.EPSILON, 2);
         QueryGraph queryGraph = QueryGraph.create(ghStorage, qResults);
-        FlexiblePathCalculator pathCalculator = createFlexiblePathCalculator(queryGraph, profile, roundTripAlgoOpts, disableLM);
+        FlexiblePathCalculator pathCalculator = createFlexiblePathCalculator(queryGraph, profile, weighting, roundTripAlgoOpts, disableLM);
 
         RoundTripRouting.Result result = RoundTripRouting.calcPaths(qResults, pathCalculator);
         // we merge the different legs of the roundtrip into one response path
@@ -183,7 +178,7 @@ protected GHResponse routeAlt(GHRequest request, AlgorithmOptions algoOpts, Weig
         List<Snap> qResults = ViaRouting.lookup(encodingManager, request.getPoints(), weighting, locationIndex, request.getSnapPreventions(), request.getPointHints());
         ghRsp.addDebugInfo("idLookup:" + sw.stop().getSeconds() + "s");
         QueryGraph queryGraph = QueryGraph.create(ghStorage, qResults);
-        PathCalculator pathCalculator = createPathCalculator(queryGraph, profile, algoOpts, disableCH, disableLM);
+        PathCalculator pathCalculator = createPathCalculator(queryGraph, profile, weighting, algoOpts, disableCH, disableLM);
 
         if (passThrough)
             throw new IllegalArgumentException("Alternative paths and " + PASS_THROUGH + " at the same time is currently not supported");
@@ -214,7 +209,7 @@ protected GHResponse routeVia(GHRequest request, AlgorithmOptions algoOpts, Weig
         // (base) query graph used to resolve headings, curbsides etc. this is not necessarily the same thing as
         // the (possibly implementation specific) query graph used by PathCalculator
         QueryGraph queryGraph = QueryGraph.create(ghStorage, qResults);
-        PathCalculator pathCalculator = createPathCalculator(queryGraph, profile, algoOpts, disableCH, disableLM);
+        PathCalculator pathCalculator = createPathCalculator(queryGraph, profile, weighting, algoOpts, disableCH, disableLM);
         ViaRouting.Result result = ViaRouting.calcPaths(request.getPoints(), queryGraph, qResults, weighting, pathCalculator, request.getCurbsides(), forceCurbsides, request.getHeadings(), passThrough);
 
         if (request.getPoints().size() != result.paths.size() + 1)
@@ -249,22 +244,22 @@ private Weighting createWeighting(Profile profile, PMap requestHints, List<GHPoi
         }
     }
 
-    private PathCalculator createPathCalculator(QueryGraph queryGraph, Profile profile, AlgorithmOptions algoOpts, boolean disableCH, boolean disableLM) {
+    private PathCalculator createPathCalculator(QueryGraph queryGraph, Profile profile, Weighting weighting, AlgorithmOptions algoOpts, boolean disableCH, boolean disableLM) {
         if (chEnabled && !disableCH) {
             PMap opts = new PMap(algoOpts.getHints());
             opts.putObject(ALGORITHM, algoOpts.getAlgorithm());
             opts.putObject(MAX_VISITED_NODES, algoOpts.getMaxVisitedNodes());
             return createCHPathCalculator(queryGraph, profile, opts);
         } else {
-            return createFlexiblePathCalculator(queryGraph, profile, algoOpts, disableLM);
+            return createFlexiblePathCalculator(queryGraph, profile, weighting, algoOpts, disableLM);
         }
     }
 
     private PathCalculator createCHPathCalculator(QueryGraph queryGraph, Profile profile, PMap opts) {
         return new CHPathCalculator(new CHRoutingAlgorithmFactory(getRoutingCHGraph(profile.getName()), queryGraph), opts);
     }
 
-    private FlexiblePathCalculator createFlexiblePathCalculator(QueryGraph queryGraph, Profile profile, AlgorithmOptions algoOpts, boolean disableLM) {
+    private FlexiblePathCalculator createFlexiblePathCalculator(QueryGraph queryGraph, Profile profile, Weighting weighting, AlgorithmOptions algoOpts, boolean disableLM) {
         RoutingAlgorithmFactory algorithmFactory;
         // for now do not allow mixing CH&LM #1082,#1889
         if (lmEnabled && !disableLM) {
@@ -277,7 +272,7 @@ private FlexiblePathCalculator createFlexiblePathCalculator(QueryGraph queryGrap
         } else {
             algorithmFactory = new RoutingAlgorithmFactorySimple();
         }
-        return new FlexiblePathCalculator(queryGraph, algorithmFactory, algoOpts);
+        return new FlexiblePathCalculator(queryGraph, algorithmFactory, weighting, algoOpts);
     }
 
     private RoutingCHGraph getRoutingCHGraph(String profileName) {

core/src/main/java/com/graphhopper/routing/RoutingAlgorithmFactory.java

@@ -17,6 +17,7 @@
  */
 package com.graphhopper.routing;
 
+import com.graphhopper.routing.weighting.Weighting;
 import com.graphhopper.storage.Graph;
 
 /**
@@ -28,5 +29,5 @@ public interface RoutingAlgorithmFactory {
     /**
      * This method creates an algorithm out of this factory based on the specified opts and graph.
      */
-    RoutingAlgorithm createAlgo(Graph g, AlgorithmOptions opts);
+    RoutingAlgorithm createAlgo(Graph g, Weighting w, AlgorithmOptions opts);
 }