GH# 74: Snap to streets

bay-area/config-local.yml

@@ -52,6 +52,7 @@ graphhopper:
       vehicle: bike2
       weighting: fastest
       use_ferries: false
+      snap_preventions: footway
     - name: foot
       vehicle: foot
       weighting: fastest

bay-area/config.yml

@@ -52,6 +52,7 @@ graphhopper:
     - name: bike2
       vehicle: bike2
       weighting: fastest
+      snap_preventions: footway
       turn_costs: true
       u_turn_costs: 10
       use_ferries: false

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

@@ -8,6 +8,7 @@
 
 import java.util.List;
 
+import static com.graphhopper.routing.ev.RoadClass.FOOTWAY;
 import static com.graphhopper.routing.ev.RoadClass.MOTORWAY;
 import static com.graphhopper.routing.ev.RoadClass.TRUNK;
 import static com.graphhopper.routing.ev.RoadEnvironment.*;
@@ -18,7 +19,7 @@ public class SnapPreventionEdgeFilter implements EdgeFilter {
     private final EnumEncodedValue<RoadClass> rcEnc;
     private final EdgeFilter filter;
     private boolean avoidMotorway = false, avoidTrunk;
-    private boolean avoidTunnel, avoidBridge, avoidFerry, avoidFord;
+    private boolean avoidTunnel, avoidBridge, avoidFerry, avoidFord, avoidFootway;
 
     public SnapPreventionEdgeFilter(EdgeFilter filter, EnumEncodedValue<RoadClass> rcEnc,
                                     EnumEncodedValue<RoadEnvironment> reEnc, List<String> snapPreventions) {
@@ -27,12 +28,16 @@ public SnapPreventionEdgeFilter(EdgeFilter filter, EnumEncodedValue<RoadClass> r
         this.rcEnc = rcEnc;
 
         for (String roadClassOrRoadEnv : snapPreventions) {
-            if ("motorway".equals(roadClassOrRoadEnv)) {
-                avoidMotorway = true;
-                continue;
-            } else if ("trunk".equals(roadClassOrRoadEnv)) {
-                avoidTrunk = true;
-                continue;
+            switch (roadClassOrRoadEnv) {
+                case "motorway":
+                    avoidMotorway = true;
+                    continue;
+                case "trunk":
+                    avoidTrunk = true;
+                    continue;
+                case "footway":
+                    avoidFootway = true;
+                    continue;
             }
 
             RoadEnvironment rc = RoadEnvironment.find(roadClassOrRoadEnv);
@@ -52,6 +57,7 @@ else if (rc == FORD)
     @Override
     public boolean accept(EdgeIteratorState edgeState) {
         return filter.accept(edgeState)
+                && !(avoidFootway && edgeState.get(rcEnc) == FOOTWAY)
                 && !(avoidMotorway && edgeState.get(rcEnc) == MOTORWAY)
                 && !(avoidTrunk && edgeState.get(rcEnc) == TRUNK)
                 && !(avoidTunnel && edgeState.get(reEnc) == TUNNEL)

core/src/test/java/com/graphhopper/routing/util/SnapPreventionEdgeFilterTest.java

@@ -20,7 +20,9 @@ public void accept() {
         EncodingManager em = new EncodingManager.Builder().build();
         EnumEncodedValue<RoadClass> rcEnc = em.getEnumEncodedValue(RoadClass.KEY, RoadClass.class);
         EnumEncodedValue<RoadEnvironment> reEnc = em.getEnumEncodedValue(RoadEnvironment.KEY, RoadEnvironment.class);
-        SnapPreventionEdgeFilter filter = new SnapPreventionEdgeFilter(trueFilter, rcEnc, reEnc, Arrays.asList("motorway", "ferry"));
+        SnapPreventionEdgeFilter filter = new SnapPreventionEdgeFilter(
+                trueFilter, rcEnc, reEnc,
+                Arrays.asList("motorway", "ferry", "footway"));
 
         IntsRef intsRef = em.createEdgeFlags();
         assertTrue(filter.accept(GHUtility.createMockedEdgeIteratorState(1, intsRef)));
@@ -33,5 +35,8 @@ public void accept() {
         assertTrue(filter.accept(GHUtility.createMockedEdgeIteratorState(1, intsRef)));
         rcEnc.setEnum(false, intsRef, RoadClass.MOTORWAY);
         assertFalse(filter.accept(GHUtility.createMockedEdgeIteratorState(1, intsRef)));
+        rcEnc.setEnum(false, intsRef, RoadClass.FOOTWAY);
+        assertFalse(filter.accept(
+                GHUtility.createMockedEdgeIteratorState(1, intsRef)));
     }
-}
+}

reader-gtfs/src/main/java/com/graphhopper/gtfs/PtRouterImpl.java

@@ -18,6 +18,8 @@
 
 package com.graphhopper.gtfs;
 
+import static java.util.Comparator.comparingLong;
+
 import com.conveyal.gtfs.GTFSFeed;
 import com.google.transit.realtime.GtfsRealtime;
 import com.graphhopper.GHResponse;
@@ -26,26 +28,39 @@
 import com.graphhopper.config.Profile;
 import com.graphhopper.routing.DefaultWeightingFactory;
 import com.graphhopper.routing.WeightingFactory;
+import com.graphhopper.routing.ev.EnumEncodedValue;
+import com.graphhopper.routing.ev.RoadClass;
+import com.graphhopper.routing.ev.RoadEnvironment;
 import com.graphhopper.routing.ev.Subnetwork;
 import com.graphhopper.routing.querygraph.QueryGraph;
 import com.graphhopper.routing.util.DefaultSnapFilter;
 import com.graphhopper.routing.util.EdgeFilter;
+import com.graphhopper.routing.util.EncodingManager;
+import com.graphhopper.routing.util.SnapPreventionEdgeFilter;
 import com.graphhopper.routing.weighting.FastestWeighting;
 import com.graphhopper.routing.weighting.Weighting;
 import com.graphhopper.storage.GraphHopperStorage;
 import com.graphhopper.storage.index.LocationIndex;
-import com.graphhopper.util.*;
+import com.graphhopper.util.PMap;
+import com.graphhopper.util.PointList;
+import com.graphhopper.util.StopWatch;
+import com.graphhopper.util.Translation;
+import com.graphhopper.util.TranslationMap;
 import com.graphhopper.util.details.PathDetailsBuilderFactory;
 import com.graphhopper.util.exceptions.ConnectionNotFoundException;
 import com.graphhopper.util.exceptions.MaximumNodesExceededException;
-
-import javax.inject.Inject;
 import java.time.Instant;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
-
-import static java.util.Comparator.comparingLong;
+import javax.inject.Inject;
 
 public final class PtRouterImpl implements PtRouter {
 
@@ -161,7 +176,8 @@ private class RequestHandler {
             String connectingProfileName = request.getConnectingProfile() != null ? request.getConnectingProfile() : config.getString("pt.connecting_profile", "foot");
             connectingProfile = config.getProfileByName(connectingProfileName).get();
             connectingWeighting = weightingFactory.createWeighting(connectingProfile, new PMap(), false);
-            connectingSnapFilter = new DefaultSnapFilter(new FastestWeighting(graphHopperStorage.getEncodingManager().getEncoder(connectingProfile.getVehicle())), graphHopperStorage.getEncodingManager().getBooleanEncodedValue(Subnetwork.key(connectingProfile.getVehicle())));
+            connectingSnapFilter = makeConnectingSnapFilter(graphHopperStorage,
+                    connectingProfile);
             includeElevation = request.getEnableElevation();
             includeEdges = request.getIncludeEdges();
         }
@@ -350,6 +366,28 @@ private boolean profileFinished(MultiCriteriaLabelSetting router, List<Label> di
             // In turn, we must also think of this virtual walk solution in the other test (where we check if all labels are closed).
         }
 
+        private EdgeFilter makeConnectingSnapFilter(
+                GraphHopperStorage ghStorage, Profile connectingProfile) {
+            EdgeFilter snapFilter = new DefaultSnapFilter(new FastestWeighting(
+                    ghStorage.getEncodingManager()
+                            .getEncoder(connectingProfile.getVehicle())),
+                    ghStorage.getEncodingManager()
+                            .getBooleanEncodedValue(Subnetwork.key(
+                                    connectingProfile.getVehicle())));
+            if (connectingProfile.getHints().has("snap_preventions")) {
+                List<String> snapPreventions = List.of(
+                        connectingProfile.getHints()
+                                .getString("snap_preventions", "").split(","));
+                EncodingManager encodingManager =
+                        graphHopperStorage.getEncodingManager();
+                final EnumEncodedValue<RoadClass> roadClassEnc = encodingManager.getEnumEncodedValue(
+                        RoadClass.KEY, RoadClass.class);
+                final EnumEncodedValue<RoadEnvironment> roadEnvEnc = encodingManager.getEnumEncodedValue(
+                        RoadEnvironment.KEY, RoadEnvironment.class);
+                return new SnapPreventionEdgeFilter(snapFilter, roadClassEnc,
+                        roadEnvEnc, snapPreventions);
+            }
+            return snapFilter;
+        }
     }
-
 }