Allow u-turns only at dead ends

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

@@ -25,6 +25,7 @@
 import com.graphhopper.jackson.Jackson;
 import com.graphhopper.reader.dem.*;
 import com.graphhopper.reader.osm.OSMReader;
+import com.graphhopper.reader.osm.PrepareDeadEnds;
 import com.graphhopper.reader.osm.RestrictionTagParser;
 import com.graphhopper.reader.osm.conditional.DateRangeParser;
 import com.graphhopper.routing.*;
@@ -40,6 +41,7 @@
 import com.graphhopper.routing.util.*;
 import com.graphhopper.routing.util.countryrules.CountryRuleFactory;
 import com.graphhopper.routing.util.parsers.*;
+import com.graphhopper.routing.weighting.AbstractAdjustedWeighting;
 import com.graphhopper.routing.weighting.Weighting;
 import com.graphhopper.routing.weighting.custom.CustomWeighting;
 import com.graphhopper.storage.*;
@@ -1409,14 +1411,45 @@ protected void cleanUp() {
         preparation.doWork();
         properties.put("profiles", getProfilesString());
         logger.info("nodes: " + Helper.nf(baseGraph.getNodes()) + ", edges: " + Helper.nf(baseGraph.getEdges()));
+
+        logger.info("Start marking dead-ends");
+        StopWatch sw = StopWatch.started();
+        PrepareDeadEnds prepareDeadEnds = new PrepareDeadEnds(baseGraph);
+        for (Profile profile : profilesByName.values()) {
+            if (profile.isTurnCosts()) {
+                BooleanEncodedValue deadEndEnc = encodingManager.getTurnBooleanEncodedValue(DeadEnd.key(profile.getVehicle()));
+                BooleanEncodedValue subnetworkEnc = encodingManager.getBooleanEncodedValue(Subnetwork.key(profile.getName()));
+                // We disable turn costs for the dead-end search.
+                Weighting weighting = createWeighting(profile, new PMap(), true);
+                prepareDeadEnds.findDeadEndUTurns(weighting, deadEndEnc, subnetworkEnc);
+            }
+        }
+        logger.info("Finished marking dead-ends, took: " + sw.stop().getSeconds() + "s");
     }
 
+
+
     private List<PrepareJob> buildSubnetworkRemovalJobs() {
         List<PrepareJob> jobs = new ArrayList<>();
         for (Profile profile : profilesByName.values()) {
-            // if turn costs are enabled use u-turn costs of zero as we only want to make sure the graph is fully connected assuming finite u-turn costs
-            Weighting weighting = createWeighting(profile, new PMap().putObject(Parameters.Routing.U_TURN_COSTS, 0));
-            jobs.add(new PrepareJob(encodingManager.getBooleanEncodedValue(Subnetwork.key(profile.getName())), weighting));
+            Weighting weighting = createWeighting(profile, new PMap());
+            Weighting w = new AbstractAdjustedWeighting(weighting) {
+                @Override
+                public double calcTurnWeight(int inEdge, int viaNode, int outEdge) {
+                    // We only want to make sure the graph is fully connected assuming finite u-turn
+                    // costs. Here we have to set it to zero explicitly, because otherwise the
+                    // u-turn costs would be infinite everywhere except at dead-ends. But we run the
+                    // dead-end detection after the subnetwork search.
+                    if (inEdge == outEdge) return 0;
+                    return weighting.calcTurnWeight(inEdge, viaNode, outEdge);
+                }
+
+                @Override
+                public String getName() {
+                    return weighting.getName();
+                }
+            };
+            jobs.add(new PrepareJob(encodingManager.getBooleanEncodedValue(Subnetwork.key(profile.getName())), w));
         }
         return jobs;
     }

core/src/main/java/com/graphhopper/reader/osm/PrepareDeadEnds.java

@@ -0,0 +1,61 @@
+/*
+ *  Licensed to GraphHopper GmbH under one or more contributor
+ *  license agreements. See the NOTICE file distributed with this work for
+ *  additional information regarding copyright ownership.
+ *
+ *  GraphHopper GmbH licenses this file to you under the Apache License,
+ *  Version 2.0 (the "License"); you may not use this file except in
+ *  compliance with the License. You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package com.graphhopper.reader.osm;
+
+import com.graphhopper.routing.ev.BooleanEncodedValue;
+import com.graphhopper.routing.weighting.Weighting;
+import com.graphhopper.storage.BaseGraph;
+import com.graphhopper.util.EdgeExplorer;
+import com.graphhopper.util.EdgeIterator;
+import com.graphhopper.util.GHUtility;
+
+public class PrepareDeadEnds {
+    private final BaseGraph baseGraph;
+
+    public PrepareDeadEnds(BaseGraph baseGraph) {
+        this.baseGraph = baseGraph;
+    }
+
+    public void findDeadEndUTurns(Weighting weighting, BooleanEncodedValue deadEndEnc, BooleanEncodedValue subnetworkEnc) {
+        EdgeExplorer inExplorer = baseGraph.createEdgeExplorer();
+        EdgeExplorer outExplorer = baseGraph.createEdgeExplorer();
+        for (int node = 0; node < baseGraph.getNodes(); node++) {
+            EdgeIterator fromEdge = inExplorer.setBaseNode(node);
+            OUTER:
+            while (fromEdge.next()) {
+                if (Double.isFinite(weighting.calcEdgeWeight(fromEdge, true))) {
+                    boolean subnetworkFrom = fromEdge.get(subnetworkEnc);
+                    EdgeIterator toEdge = outExplorer.setBaseNode(node);
+                    while (toEdge.next()) {
+                        if (toEdge.getEdge() != fromEdge.getEdge()
+                                && Double.isFinite(GHUtility.calcWeightWithTurnWeight(weighting, toEdge, false, fromEdge.getEdge()))
+                                && subnetworkFrom == toEdge.get(subnetworkEnc))
+                            continue OUTER;
+                    }
+                    // the only way to continue from fromEdge is a u-turn. this is a dead-end u-turn
+                    setDeadEndUTurn(baseGraph, deadEndEnc, fromEdge.getEdge(), node);
+                }
+            }
+        }
+    }
+
+    private void setDeadEndUTurn(BaseGraph baseGraph, BooleanEncodedValue deadEndEnc, int fromEdge, int viaNode) {
+        baseGraph.getTurnCostStorage().set(deadEndEnc, fromEdge, viaNode, fromEdge, true);
+    }
+}

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

@@ -59,10 +59,11 @@ public Weighting createWeighting(Profile profile, PMap requestHints, boolean dis
         TurnCostProvider turnCostProvider;
         if (profile.isTurnCosts() && !disableTurnCosts) {
             BooleanEncodedValue turnRestrictionEnc = encodingManager.getTurnBooleanEncodedValue(TurnRestriction.key(vehicle));
-            if (turnRestrictionEnc == null)
+            BooleanEncodedValue deadEndEnc = encodingManager.getTurnBooleanEncodedValue(DeadEnd.key(vehicle));
+            if (turnRestrictionEnc == null || deadEndEnc == null)
                 throw new IllegalArgumentException("Vehicle " + vehicle + " does not support turn costs");
             int uTurnCosts = hints.getInt(Parameters.Routing.U_TURN_COSTS, INFINITE_U_TURN_COSTS);
-            turnCostProvider = new DefaultTurnCostProvider(turnRestrictionEnc, graph.getTurnCostStorage(), uTurnCosts);
+            turnCostProvider = new DefaultTurnCostProvider(turnRestrictionEnc, deadEndEnc, graph.getTurnCostStorage(), uTurnCosts);
         } else {
             turnCostProvider = NO_TURN_COST_PROVIDER;
         }

core/src/main/java/com/graphhopper/routing/ev/DeadEnd.java

@@ -0,0 +1,32 @@
+/*
+ *  Licensed to GraphHopper GmbH under one or more contributor
+ *  license agreements. See the NOTICE file distributed with this work for
+ *  additional information regarding copyright ownership.
+ *
+ *  GraphHopper GmbH licenses this file to you under the Apache License,
+ *  Version 2.0 (the "License"); you may not use this file except in
+ *  compliance with the License. You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package com.graphhopper.routing.ev;
+
+import static com.graphhopper.routing.util.EncodingManager.getKey;
+
+public class DeadEnd {
+
+    public static String key(String prefix) {
+        return getKey(prefix, "dead_end");
+    }
+
+    public static BooleanEncodedValue create(String name) {
+        return new SimpleBooleanEncodedValue(key(name), false);
+    }
+}

core/src/main/java/com/graphhopper/routing/util/VehicleEncodedValues.java

@@ -34,6 +34,7 @@ public class VehicleEncodedValues {
     private final DecimalEncodedValue avgSpeedEnc;
     private final DecimalEncodedValue priorityEnc;
     private final BooleanEncodedValue turnRestrictionEnc;
+    private final BooleanEncodedValue deadEndEnc;
 
     public static VehicleEncodedValues foot(PMap properties) {
         String name = properties.getString("name", "foot");
@@ -45,7 +46,8 @@ public static VehicleEncodedValues foot(PMap properties) {
         DecimalEncodedValue speedEnc = VehicleSpeed.create(name, speedBits, speedFactor, speedTwoDirections);
         DecimalEncodedValue priorityEnc = VehiclePriority.create(name, 4, PriorityCode.getFactor(1), false);
         BooleanEncodedValue turnRestrictionEnc = turnCosts ? TurnRestriction.create(name) : null;
-        return new VehicleEncodedValues(name, accessEnc, speedEnc, priorityEnc, turnRestrictionEnc);
+        BooleanEncodedValue deadEndEnc = turnCosts ? DeadEnd.create(name) : null;
+        return new VehicleEncodedValues(name, accessEnc, speedEnc, priorityEnc, turnRestrictionEnc, deadEndEnc);
     }
 
     public static VehicleEncodedValues wheelchair(PMap properties) {
@@ -67,7 +69,8 @@ public static VehicleEncodedValues bike(PMap properties) {
         DecimalEncodedValue speedEnc = VehicleSpeed.create(name, speedBits, speedFactor, speedTwoDirections);
         DecimalEncodedValue priorityEnc = VehiclePriority.create(name, 4, PriorityCode.getFactor(1), false);
         BooleanEncodedValue turnRestrictionEnc = turnCosts ? TurnRestriction.create(name) : null;
-        return new VehicleEncodedValues(name, accessEnc, speedEnc, priorityEnc, turnRestrictionEnc);
+        BooleanEncodedValue deadEndEnc = turnCosts ? DeadEnd.create(name) : null;
+        return new VehicleEncodedValues(name, accessEnc, speedEnc, priorityEnc, turnRestrictionEnc, deadEndEnc);
     }
 
     public static VehicleEncodedValues racingbike(PMap properties) {
@@ -86,7 +89,8 @@ public static VehicleEncodedValues car(PMap properties) {
         BooleanEncodedValue accessEnc = VehicleAccess.create(name);
         DecimalEncodedValue speedEnc = VehicleSpeed.create(name, speedBits, speedFactor, true);
         BooleanEncodedValue turnRestrictionEnc = turnCosts ? TurnRestriction.create(name) : null;
-        return new VehicleEncodedValues(name, accessEnc, speedEnc, null, turnRestrictionEnc);
+        BooleanEncodedValue deadEndEnc = turnCosts ? DeadEnd.create(name) : null;
+        return new VehicleEncodedValues(name, accessEnc, speedEnc, null, turnRestrictionEnc, deadEndEnc);
     }
 
     public static VehicleEncodedValues roads(PMap properties) {
@@ -98,16 +102,18 @@ public static VehicleEncodedValues roads(PMap properties) {
         BooleanEncodedValue accessEnc = VehicleAccess.create(name);
         DecimalEncodedValue speedEnc = VehicleSpeed.create(name, speedBits, speedFactor, speedTwoDirections);
         BooleanEncodedValue turnRestrictionEnc = turnCosts ? TurnRestriction.create(name) : null;
-        return new VehicleEncodedValues(name, accessEnc, speedEnc, null, turnRestrictionEnc);
+        BooleanEncodedValue deadEndEnc = turnCosts ? DeadEnd.create(name) : null;
+        return new VehicleEncodedValues(name, accessEnc, speedEnc, null, turnRestrictionEnc, deadEndEnc);
     }
 
     public VehicleEncodedValues(String name, BooleanEncodedValue accessEnc, DecimalEncodedValue avgSpeedEnc,
-                                DecimalEncodedValue priorityEnc, BooleanEncodedValue turnRestrictionEnc) {
+                                DecimalEncodedValue priorityEnc, BooleanEncodedValue turnRestrictionEnc, BooleanEncodedValue deadEndEnc) {
         this.name = name;
         this.accessEnc = accessEnc;
         this.avgSpeedEnc = avgSpeedEnc;
         this.priorityEnc = priorityEnc;
         this.turnRestrictionEnc = turnRestrictionEnc;
+        this.deadEndEnc = deadEndEnc;
     }
 
     public void createEncodedValues(List<EncodedValue> registerNewEncodedValue) {
@@ -122,6 +128,8 @@ public void createEncodedValues(List<EncodedValue> registerNewEncodedValue) {
     public void createTurnCostEncodedValues(List<EncodedValue> registerNewTurnCostEncodedValues) {
         if (turnRestrictionEnc != null)
             registerNewTurnCostEncodedValues.add(turnRestrictionEnc);
+        if (deadEndEnc != null)
+            registerNewTurnCostEncodedValues.add(deadEndEnc);
     }
 
     public BooleanEncodedValue getAccessEnc() {
@@ -140,6 +148,10 @@ public BooleanEncodedValue getTurnRestrictionEnc() {
         return turnRestrictionEnc;
     }
 
+    public BooleanEncodedValue getDeadEndEnc() {
+        return deadEndEnc;
+    }
+
     public String getName() {
         return name;
     }

core/src/main/java/com/graphhopper/routing/weighting/DefaultTurnCostProvider.java

@@ -26,19 +26,20 @@
 
 public class DefaultTurnCostProvider implements TurnCostProvider {
     private final BooleanEncodedValue turnRestrictionEnc;
+    private final BooleanEncodedValue deadEndEnc;
     private final TurnCostStorage turnCostStorage;
     private final int uTurnCostsInt;
     private final double uTurnCosts;
 
-    public DefaultTurnCostProvider(BooleanEncodedValue turnRestrictionEnc, TurnCostStorage turnCostStorage) {
-        this(turnRestrictionEnc, turnCostStorage, Weighting.INFINITE_U_TURN_COSTS);
+    public DefaultTurnCostProvider(BooleanEncodedValue turnRestrictionEnc, BooleanEncodedValue deadEndEnc, TurnCostStorage turnCostStorage) {
+        this(turnRestrictionEnc, deadEndEnc, turnCostStorage, Weighting.INFINITE_U_TURN_COSTS);
     }
 
     /**
      * @param uTurnCosts the costs of a u-turn in seconds, for {@link Weighting#INFINITE_U_TURN_COSTS} the u-turn costs
-     *                   will be infinite
+     *                   will be infinite. u-turns are only allowed at dead ends.
      */
-    public DefaultTurnCostProvider(BooleanEncodedValue turnRestrictionEnc, TurnCostStorage turnCostStorage, int uTurnCosts) {
+    public DefaultTurnCostProvider(BooleanEncodedValue turnRestrictionEnc, BooleanEncodedValue deadEndEnc, TurnCostStorage turnCostStorage, int uTurnCosts) {
         if (uTurnCosts < 0 && uTurnCosts != INFINITE_U_TURN_COSTS) {
             throw new IllegalArgumentException("u-turn costs must be positive, or equal to " + INFINITE_U_TURN_COSTS + " (=infinite costs)");
         }
@@ -49,27 +50,28 @@ public DefaultTurnCostProvider(BooleanEncodedValue turnRestrictionEnc, TurnCostS
         }
         // if null the TurnCostProvider can be still useful for edge-based routing
         this.turnRestrictionEnc = turnRestrictionEnc;
+        this.deadEndEnc = deadEndEnc;
         this.turnCostStorage = turnCostStorage;
     }
 
     public BooleanEncodedValue getTurnRestrictionEnc() {
         return turnRestrictionEnc;
     }
 
+    public BooleanEncodedValue getDeadEndEnc() {
+        return deadEndEnc;
+    }
+
     @Override
     public double calcTurnWeight(int edgeFrom, int nodeVia, int edgeTo) {
-        if (!EdgeIterator.Edge.isValid(edgeFrom) || !EdgeIterator.Edge.isValid(edgeTo)) {
+        if (!EdgeIterator.Edge.isValid(edgeFrom) || !EdgeIterator.Edge.isValid(edgeTo))
+            return 0;
+        if (turnCostStorage.get(turnRestrictionEnc, edgeFrom, nodeVia, edgeTo))
+            return Double.POSITIVE_INFINITY;
+        else if (edgeFrom == edgeTo)
+            return turnCostStorage.get(deadEndEnc, edgeFrom, nodeVia, edgeTo) ? uTurnCosts : Double.POSITIVE_INFINITY;
+        else
             return 0;
-        }
-        double tCost = 0;
-        if (edgeFrom == edgeTo) {
-            // note that the u-turn costs overwrite any turn costs set in TurnCostStorage
-            tCost = uTurnCosts;
-        } else {
-            if (turnRestrictionEnc != null)
-                tCost = turnCostStorage.get(turnRestrictionEnc, edgeFrom, nodeVia, edgeTo) ? Double.POSITIVE_INFINITY : 0;
-        }
-        return tCost;
     }
 
     @Override

core/src/main/java/com/graphhopper/util/Constants.java

@@ -65,7 +65,7 @@ public class Constants {
     public static final int VERSION_SHORTCUT = 9;
     public static final int VERSION_NODE_CH = 0;
     public static final int VERSION_GEOMETRY = 6;
-    public static final int VERSION_TURN_COSTS = 0;
+    public static final int VERSION_TURN_COSTS = 1;
     public static final int VERSION_LOCATION_IDX = 5;
     public static final int VERSION_KV_STORAGE = 2;
     /**