Add config option preparation_profile to allow cross-querying in hybrid mode (graphhopper#1983)

easbar · web-flow · commit 7bee0e42ac6b · 2020-04-14T12:33:09.000+02:00
diff --git a/api/src/main/java/com/graphhopper/config/LMProfileConfig.java b/api/src/main/java/com/graphhopper/config/LMProfileConfig.java
@@ -28,6 +28,7 @@
  */
 public class LMProfileConfig {
     private String profile = "";
+    private String preparationProfile = "this";
     private double maximumLMWeight = -1;
 
     private LMProfileConfig() {
@@ -47,17 +48,35 @@ void setProfile(String profile) {
         this.profile = profile;
     }
 
+    public boolean usesOtherPreparation() {
+        return !preparationProfile.equals("this");
+    }
+
+    public String getPreparationProfile() {
+        return preparationProfile;
+    }
+
+    public LMProfileConfig setPreparationProfile(String preparationProfile) {
+        validateProfileName(preparationProfile);
+        if (maximumLMWeight >= 0)
+            throw new IllegalArgumentException("Using non-default maximum_lm_weight and preparation_profile at the same time is not allowed");
+        this.preparationProfile = preparationProfile;
+        return this;
+    }
+
     public double getMaximumLMWeight() {
         return maximumLMWeight;
     }
 
     public LMProfileConfig setMaximumLMWeight(double maximumLMWeight) {
+        if (usesOtherPreparation())
+            throw new IllegalArgumentException("Using non-default maximum_lm_weight and preparation_profile at the same time is not allowed");
         this.maximumLMWeight = maximumLMWeight;
         return this;
     }
 
     @Override
     public String toString() {
-        return profile + "|maximum_lm_weight=" + maximumLMWeight;
+        return profile + "|preparation_profile=" + preparationProfile + "|maximum_lm_weight=" + maximumLMWeight;
     }
 }
diff --git a/config-example.yml b/config-example.yml
@@ -63,6 +63,12 @@ graphhopper:
   # Hybrid mode:
   # Similar to speed mode, the hybrid mode (Landmarks, LM) also speeds up routing by doing calculating auxiliary data
   # in advance. Its not as fast as speed mode, but more flexible.
+  #
+  # Advanced usage: It is possible to use the same preparation for multiple profiles which saves memory and preparation
+  # time. To do this use e.g. `preparation_profile: my_other_profile` where `my_other_profile` is the name of another
+  # profile for which an LM profile exists. Important: This only will give correct routing results if the weights
+  # calculated for the profile are equal or larger (for every edge) than those calculated for the profile that was used
+  # for the preparation (`my_other_profile`)
   profiles_lm: []
 
   ##### Elevation #####
diff --git a/core/src/main/java/com/graphhopper/GraphHopper.java b/core/src/main/java/com/graphhopper/GraphHopper.java
@@ -837,15 +837,26 @@ private void checkProfilesConsistency() {
                 throw new IllegalArgumentException("CH profile references unknown profile '" + chConfig.getProfile() + "'");
             }
         }
-        Set<String> lmProfileSet = new LinkedHashSet<>(lmPreparationHandler.getLMProfileConfigs().size());
+        Map<String, LMProfileConfig> lmProfileMap = new LinkedHashMap<>(lmPreparationHandler.getLMProfileConfigs().size());
         for (LMProfileConfig lmConfig : lmPreparationHandler.getLMProfileConfigs()) {
-            boolean added = lmProfileSet.add(lmConfig.getProfile());
-            if (!added) {
-                throw new IllegalArgumentException("Duplicate LM reference to profile '" + lmConfig.getProfile() + "'");
+            LMProfileConfig previous = lmProfileMap.put(lmConfig.getProfile(), lmConfig);
+            if (previous != null) {
+                throw new IllegalArgumentException("Multiple LM profiles are using the same profile '" + lmConfig.getProfile() + "'");
             }
             if (!profilesByName.containsKey(lmConfig.getProfile())) {
                 throw new IllegalArgumentException("LM profile references unknown profile '" + lmConfig.getProfile() + "'");
             }
+            if (lmConfig.usesOtherPreparation() && !profilesByName.containsKey(lmConfig.getPreparationProfile())) {
+                throw new IllegalArgumentException("LM profile references unknown preparation profile '" + lmConfig.getPreparationProfile() + "'");
+            }
+        }
+        for (LMProfileConfig lmConfig : lmPreparationHandler.getLMProfileConfigs()) {
+            if (lmConfig.usesOtherPreparation() && !lmProfileMap.containsKey(lmConfig.getPreparationProfile())) {
+                throw new IllegalArgumentException("Unknown LM preparation profile '" + lmConfig.getPreparationProfile() + "' in LM profile '" + lmConfig.getProfile() + "' cannot be used as preparation_profile");
+            }
+            if (lmConfig.usesOtherPreparation() && lmProfileMap.get(lmConfig.getPreparationProfile()).usesOtherPreparation()) {
+                throw new IllegalArgumentException("Cannot use '" + lmConfig.getPreparationProfile() + "' as preparation_profile for LM profile '" + lmConfig.getProfile() + "', because it uses another profile for preparation itself.");
+            }
         }
     }
 
@@ -861,7 +872,15 @@ public RoutingAlgorithmFactory getAlgorithmFactory(String profile, boolean disab
         if (chPreparationHandler.isEnabled() && !disableCH) {
             return chPreparationHandler.getAlgorithmFactory(profile);
         } else if (lmPreparationHandler.isEnabled() && !disableLM) {
-            return lmPreparationHandler.getAlgorithmFactory(profile);
+            for (LMProfileConfig lmp : lmPreparationHandler.getLMProfileConfigs()) {
+                if (lmp.getProfile().equals(profile)) {
+                    return lmp.usesOtherPreparation()
+                            // cross-querying
+                            ? lmPreparationHandler.getAlgorithmFactory(lmp.getPreparationProfile())
+                            : lmPreparationHandler.getAlgorithmFactory(lmp.getProfile());
+                }
+            }
+            throw new IllegalArgumentException("Cannot find LM preparation for the requested profile: '" + profile + "'");
         } else {
             return new RoutingAlgorithmFactorySimple();
         }
@@ -895,11 +914,13 @@ private void initLMPreparationHandler() {
             return;
 
         for (LMProfileConfig lmConfig : lmPreparationHandler.getLMProfileConfigs()) {
+            if (lmConfig.usesOtherPreparation())
+                continue;
             ProfileConfig profile = profilesByName.get(lmConfig.getProfile());
             // Note that we have to make sure the weighting used for LM preparation does not include turn costs, because
             // the LM preparation is running node-based and the landmark weights will be wrong if there are non-zero
             // turn costs, see discussion in #1960
-            // Running the preparation without turn costs can also be useful to allow e.g. changing the u_turn_costs per
+            // Running the preparation without turn costs is also useful to allow e.g. changing the u_turn_costs per
             // request (we have to use the minimum weight settings (= no turn costs) for the preparation)
             Weighting weighting = createWeighting(profile, new PMap(), true);
             lmPreparationHandler.addLMProfile(new LMProfile(profile.getName(), weighting));
@@ -1015,14 +1036,12 @@ public List<Path> calcPaths(GHRequest request, GHResponse ghRsp) {
         try {
             if (!request.getVehicle().isEmpty())
                 throw new IllegalArgumentException("GHRequest may no longer contain a vehicle, use the profile parameter instead, see #1958");
-            // todo: #1980, weighting should be also forbidden
-//            if (!request.getWeighting().isEmpty())
-//                throw new IllegalArgumentException("GHRequest may no longer contain a weighting, use the profile parameter instead, see #1958");
+            if (!request.getWeighting().isEmpty())
+                throw new IllegalArgumentException("GHRequest may no longer contain a weighting, use the profile parameter instead, see #1958");
             if (request.getHints().has(Routing.TURN_COSTS))
                 throw new IllegalArgumentException("GHRequest may no longer contain the turn_costs=true/false parameter, use the profile parameter instead, see #1958");
-            // todo: #1980, edge based should also be forbidden
-//            if (request.getHints().has(Routing.EDGE_BASED))
-//                throw new IllegalArgumentException("GHRequest may no longer contain the edge_based=true/false parameter, use the profile parameter instead, see #1958");
+            if (request.getHints().has(Routing.EDGE_BASED))
+                throw new IllegalArgumentException("GHRequest may no longer contain the edge_based=true/false parameter, use the profile parameter instead, see #1958");
 
             // todo later: do not allow things like short_fastest.distance_factor or u_turn_costs unless CH is disabled and only under certain conditions for LM
 
diff --git a/core/src/main/java/com/graphhopper/routing/lm/LMPreparationHandler.java b/core/src/main/java/com/graphhopper/routing/lm/LMPreparationHandler.java
@@ -130,6 +130,8 @@ public LMPreparationHandler setLMProfileConfigs(Collection<LMProfileConfig> lmPr
         this.lmProfileConfigs.clear();
         this.maximumWeights.clear();
         for (LMProfileConfig config : lmProfileConfigs) {
+            if (config.usesOtherPreparation())
+                continue;
             maximumWeights.put(config.getProfile(), config.getMaximumLMWeight());
         }
         this.lmProfileConfigs.addAll(lmProfileConfigs);
diff --git a/core/src/test/java/com/graphhopper/GraphHopperProfileConfigTest.java b/core/src/test/java/com/graphhopper/GraphHopperProfileConfigTest.java
@@ -160,9 +160,63 @@ public void duplicateLMProfile_error() {
             public void run() {
                 hopper.load(GH_LOCATION);
             }
-        }, "Duplicate LM reference to profile 'profile'");
+        }, "Multiple LM profiles are using the same profile 'profile'");
     }
 
+    @Test
+    public void unknownLMPreparationProfile_error() {
+        final GraphHopper hopper = createHopper(EncodingManager.create("car"));
+        hopper.setProfiles(new ProfileConfig("profile").setVehicle("car"));
+        hopper.getLMPreparationHandler().setLMProfileConfigs(
+                new LMProfileConfig("profile").setPreparationProfile("xyz")
+        );
+        assertIllegalArgument(new Runnable() {
+            @Override
+            public void run() {
+                hopper.load(GH_LOCATION);
+            }
+        }, "LM profile references unknown preparation profile 'xyz'");
+    }
+
+    @Test
+    public void lmPreparationProfileChain_error() {
+        final GraphHopper hopper = createHopper(EncodingManager.create("car,bike,foot"));
+        hopper.setProfiles(
+                new ProfileConfig("profile1").setVehicle("car"),
+                new ProfileConfig("profile2").setVehicle("bike"),
+                new ProfileConfig("profile3").setVehicle("foot")
+        );
+        hopper.getLMPreparationHandler().setLMProfileConfigs(
+                new LMProfileConfig("profile1"),
+                new LMProfileConfig("profile2").setPreparationProfile("profile1"),
+                new LMProfileConfig("profile3").setPreparationProfile("profile2")
+        );
+        assertIllegalArgument(new Runnable() {
+            @Override
+            public void run() {
+                hopper.load(GH_LOCATION);
+            }
+        }, "Cannot use 'profile2' as preparation_profile for LM profile 'profile3', because it uses another profile for preparation itself.");
+    }
+
+    @Test
+    public void noLMProfileForPreparationProfile_error() {
+        final GraphHopper hopper = createHopper(EncodingManager.create("car,bike,foot"));
+        hopper.setProfiles(
+                new ProfileConfig("profile1").setVehicle("car"),
+                new ProfileConfig("profile2").setVehicle("bike"),
+                new ProfileConfig("profile3").setVehicle("foot")
+        );
+        hopper.getLMPreparationHandler().setLMProfileConfigs(
+                new LMProfileConfig("profile1").setPreparationProfile("profile2")
+        );
+        assertIllegalArgument(new Runnable() {
+            @Override
+            public void run() {
+                hopper.load(GH_LOCATION);
+            }
+        }, "Unknown LM preparation profile 'profile2' in LM profile 'profile1' cannot be used as preparation_profile");
+    }
 
     private GraphHopper createHopper(EncodingManager encodingManager) {
         final GraphHopper hopper = new GraphHopper();
diff --git a/reader-osm/src/test/java/com/graphhopper/GraphHopperIT.java b/reader-osm/src/test/java/com/graphhopper/GraphHopperIT.java
@@ -1356,6 +1356,54 @@ public void testFlexMode_631() {
         // note: combining hybrid & speed mode is currently not possible and should be avoided: #1082
     }
 
+    @Test
+    public void testCrossQuery() {
+        final String profile1 = "p1";
+        final String profile2 = "p2";
+        final String profile3 = "p3";
+        final String vehicle = "car";
+        GraphHopper hopper = createGraphHopper(vehicle).
+                setOSMFile(MONACO).
+                setProfiles(
+                        new ProfileConfig(profile1).setVehicle("car").setWeighting("short_fastest").putHint("short_fastest.distance_factor", 0.07),
+                        new ProfileConfig(profile2).setVehicle("car").setWeighting("short_fastest").putHint("short_fastest.distance_factor", 0.10),
+                        new ProfileConfig(profile3).setVehicle("car").setWeighting("short_fastest").putHint("short_fastest.distance_factor", 0.15)
+                ).
+                setStoreOnFlush(true);
+
+        hopper.getLMPreparationHandler().
+                setLMProfileConfigs(
+                        // we have an LM setup for each profile, but only one LM preparation that we use for all of them!
+                        // this works because profile1's weight is the lowest for every edge
+                        new LMProfileConfig(profile1),
+                        new LMProfileConfig(profile2).setPreparationProfile(profile1),
+                        new LMProfileConfig(profile3).setPreparationProfile(profile1)
+                ).
+                setDisablingAllowed(true);
+        hopper.importOrLoad();
+
+        // flex
+        testCrossQueryAssert(profile1, hopper, 528.3, 152, true);
+        testCrossQueryAssert(profile2, hopper, 636.0, 150, true);
+        testCrossQueryAssert(profile3, hopper, 815.4, 146, true);
+
+        // LM (should be the same as flex, but with less visited nodes!)
+        testCrossQueryAssert(profile1, hopper, 528.3, 106, false);
+        testCrossQueryAssert(profile2, hopper, 636.0, 78, false);
+        // this is actually interesting: the number of visited nodes *increases* once again (while it strictly decreases
+        // with rising distance factor for flex): cross-querying 'works', but performs *worse*, because the landmarks
+        // were not customized for the weighting in use. Creating a separate LM preparation for profile3 yields 74
+        // instead of 124 visited nodes (not shown here)
+        testCrossQueryAssert(profile3, hopper, 815.4, 124, false);
+    }
+
+    private void testCrossQueryAssert(String profile, GraphHopper hopper, double expectedWeight, int expectedVisitedNodes, boolean disableLM) {
+        GHResponse response = hopper.route(new GHRequest(43.727687, 7.418737, 43.74958, 7.436566).setProfile(profile).putHint("lm.disable", disableLM));
+        assertEquals(expectedWeight, response.getBest().getRouteWeight(), 0.1);
+        int visitedNodes = response.getHints().getInt("visited_nodes.sum", 0);
+        assertEquals(expectedVisitedNodes, visitedNodes);
+    }
+
     @Test
     public void testCreateWeightingHintsMerging() {
         final String profile = "profile";
diff --git a/tools/src/main/java/com/graphhopper/tools/Measurement.java b/tools/src/main/java/com/graphhopper/tools/Measurement.java
@@ -304,11 +304,10 @@ private GraphHopperConfig createConfigFromArgs(PMap args) {
         ghConfig.setCHProfiles(chProfiles);
         List<LMProfileConfig> lmProfiles = new ArrayList<>();
         if (useLM) {
-            // as currently we do not allow cross-querying LM with turn costs=true/false we have to add both
-            // profiles and this currently leads to two identical LM preparations
             lmProfiles.add(new LMProfileConfig("profile_no_tc"));
             if (turnCosts)
-                lmProfiles.add(new LMProfileConfig("profile_tc"));
+                // no need for a second LM preparation, we can do cross queries here
+                lmProfiles.add(new LMProfileConfig("profile_tc").setPreparationProfile("profile_no_tc"));
         }
         ghConfig.setLMProfiles(lmProfiles);
         return ghConfig;
diff --git a/web-bundle/src/main/java/com/graphhopper/resources/RouteResource.java b/web-bundle/src/main/java/com/graphhopper/resources/RouteResource.java
@@ -245,10 +245,9 @@ private void enableEdgeBasedIfThereAreCurbsides(List<String> curbsides, GHReques
 
     private void removeLegacyParameters(GHRequest request) {
         // these parameters should only be used to resolve the profile, but should not be passed to GraphHopper
-        // todo: #1980, these parameters should be removed as well?!
-//        request.getHints().setWeighting("");
+        request.getHints().setWeighting("");
         request.getHints().setVehicle("");
-//        request.getHints().remove("edge_based");
+        request.getHints().remove("edge_based");
         request.getHints().remove("turn_costs");
     }
 
diff --git a/web/src/test/java/com/graphhopper/http/resources/RouteResourceTurnCostsTest.java b/web/src/test/java/com/graphhopper/http/resources/RouteResourceTurnCostsTest.java
@@ -68,8 +68,9 @@ private static GraphHopperServerTestConfiguration createConfig() {
                         new CHProfileConfig("my_car_no_turn_costs")
                 ))
                 .setLMProfiles(Arrays.asList(
-                        new LMProfileConfig("my_car_turn_costs"),
-                        new LMProfileConfig("my_car_no_turn_costs")
+                        new LMProfileConfig("my_car_no_turn_costs"),
+                        // no need for a second LM preparation: we can just cross query here
+                        new LMProfileConfig("my_car_turn_costs").setPreparationProfile("my_car_no_turn_costs")
                 ));
         return config;
     }

Original file line number	Diff line number	Diff line change
`@@ -130,6 +130,8 @@ public LMPreparationHandler setLMProfileConfigs(Collection<LMProfileConfig> lmPr`
`130`	`130`	`this.lmProfileConfigs.clear();`
`131`	`131`	`this.maximumWeights.clear();`
`132`	`132`	`for (LMProfileConfig config : lmProfileConfigs) {`
	`133`	`+ if (config.usesOtherPreparation())`
	`134`	`+ continue;`
`133`	`135`	`maximumWeights.put(config.getProfile(), config.getMaximumLMWeight());`
`134`	`136`	`}`
`135`	`137`	`this.lmProfileConfigs.addAll(lmProfileConfigs);`