Feature#480 maximum speed

CHANGELOG.md

@@ -5,6 +5,8 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 
 ## [Unreleased]
 ### Added
+* New `maximum_speed` parameter to the driving profiles of the directions API, for specifying a speed limit, above a certain threshold set in the config file.
+
 ### Fixed
 ### Changed
 ### Deprecated

openrouteservice-api-tests/src/test/java/org/heigit/ors/v2/services/routing/ResultTest.java

@@ -1222,6 +1222,28 @@ public void testOptimizedAndTurnRestrictions() {
                 .statusCode(200);
     }
 
+    @Test
+    public void testMaximumSpeed() {
+        JSONObject body = new JSONObject();
+        body.put("coordinates", constructCoords("8.63348,49.41766|8.6441,49.4672"));
+        body.put("preference", getParameter("preference"));
+        body.put("maximum_speed",80);
+
+        //Test that the distance of the computed route.
+        given()
+                .header("Accept", "application/json")
+                .header("Content-Type", "application/json")
+                .pathParam("profile", "driving-car")
+                .body(body.toString())
+                .when()
+                .post(getEndPointPath() + "/{profile}")
+                .then()
+                .assertThat()
+                .body("any { it.key == 'routes' }", is(true))
+                .body("routes[0].summary.duration", is(1694.8f))
+                .statusCode(200);
+    }
+
     @Test
     public void testNoBearings() {
         JSONObject body = new JSONObject();

openrouteservice/src/main/java/org/heigit/ors/api/requests/routing/RouteRequest.java

@@ -57,6 +57,8 @@ public class RouteRequest {
     public static final String PARAM_SIMPLIFY_GEOMETRY = "geometry_simplify";
     public static final String PARAM_SKIP_SEGMENTS = "skip_segments";
     public static final String PARAM_ALTERNATIVE_ROUTES = "alternative_routes";
+    public static final String PARAM_MAXIMUM_SPEED = "maximum_speed";
+
 
     @ApiModelProperty(name = PARAM_ID, value = "Arbitrary identification string of the request reflected in the meta information.",
             example = "routing_request")
@@ -245,6 +247,11 @@ public class RouteRequest {
     @JsonIgnore
     private boolean hasAlternativeRoutes = false;
 
+    @ApiModelProperty(name = PARAM_MAXIMUM_SPEED, value = "The maximum speed specified by user.", example = "90")
+    @JsonProperty(PARAM_MAXIMUM_SPEED)
+    private double maximumSpeed;
+    @JsonIgnore
+    private boolean hasMaximumSpeed = false;
 
     @JsonCreator
     public RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates) {
@@ -504,6 +511,15 @@ public void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes
         hasAlternativeRoutes = true;
     }
 
+    public void setMaximumSpeed(Double maximumSpeed) {
+        this.maximumSpeed = maximumSpeed;
+        hasMaximumSpeed = true;
+    }
+
+    public double getMaximumSpeed() {
+        return maximumSpeed;
+    }
+
     public boolean hasIncludeRoundaboutExitInfo() {
         return hasIncludeRoundaboutExitInfo;
     }
@@ -575,4 +591,8 @@ public boolean hasSimplifyGeometry() {
     public boolean hasSkipSegments() { return hasSkipSegments;}
 
     public boolean hasAlternativeRoutes() { return hasAlternativeRoutes; }
+
+    public boolean hasMaximumSpeed() {
+        return hasMaximumSpeed;
+    }
 }

openrouteservice/src/main/java/org/heigit/ors/routing/RouteSearchParameters.java

@@ -81,6 +81,9 @@ public class RouteSearchParameters {
     private int roundTripPoints = 2;
     private long roundTripSeed = -1;
 
+    private double maximumSpeed;
+    private boolean hasMaximumSpeed = false;
+
     private String options;
 
     public int getProfileType() {
@@ -527,6 +530,19 @@ public long getRoundTripSeed() {
         return roundTripSeed;
     }
 
+    public double getMaximumSpeed() {
+        return maximumSpeed;
+    }
+
+    public void setMaximumSpeed(double maximumSpeed) {
+        this.maximumSpeed = maximumSpeed;
+        hasMaximumSpeed = true;
+    }
+
+    public boolean hasMaximumSpeed() {
+        return hasMaximumSpeed;
+    }
+
     public boolean isProfileTypeDriving() {
         return RoutingProfileType.isDriving(this.getProfileType());
     }
@@ -543,7 +559,7 @@ public boolean requiresDynamicPreprocessedWeights() {
             || getConsiderTurnRestrictions()
             || isProfileTypeHeavyVehicle() && getVehicleType() > 0
             || isProfileTypeDriving() && hasParameters(VehicleParameters.class)
-        ;
+            || hasMaximumSpeed();
     }
 
     /**

openrouteservice/src/main/java/org/heigit/ors/routing/RoutingProfile.java

@@ -887,6 +887,10 @@ else if (bearings[1] == null)
                 req.getHints().put("alternative_route.max_share_factor", searchParams.getAlternativeRoutesShareFactor());
             }
 
+            if(searchParams.hasMaximumSpeed()){
+                req.getHints().put("maximum_speed", searchParams.getMaximumSpeed());
+            }
+
             if (directedSegment) {
                 resp = mGraphHopper.constructFreeHandRoute(req);
             } else {

openrouteservice/src/main/java/org/heigit/ors/routing/RoutingProfileManager.java

@@ -576,6 +576,10 @@ public RoutingProfile getRouteProfile(RoutingRequest req, boolean oneToMany) thr
             }
         }
 
+        if(searchParams.getMaximumSpeed() !=0 & searchParams.getMaximumSpeed() < config.getMaximumSpeedLowerBound()){
+            throw new RuntimeException("The maximum speed must not be lower than " + config.getMaximumSpeedLowerBound() + " km/h.");
+        }
+
         return rp;
     }
 

openrouteservice/src/main/java/org/heigit/ors/routing/RoutingRequest.java

@@ -43,6 +43,7 @@ public class RoutingRequest extends ServiceRequest {
     private boolean continueStraight = false;
 	private List<Integer> skipSegments = new ArrayList<>();
 	private boolean includeCountryInfo = false;
+	private double maximumSpeed;
 
 	private String responseFormat = "json";
 
@@ -207,10 +208,18 @@ public boolean getIncludeCountryInfo() {
 		return includeCountryInfo;
 	}
 
-	public void setIncludeCountryInfo(boolean includeCountryInfo) {
+	public void setIncludeCountryInfo(boolean includeCountryImnfo) {
 		this.includeCountryInfo = includeCountryInfo;
 	}
 
+	public void setMaximumSpeed(double maximumSpeed){
+		this.maximumSpeed = maximumSpeed;
+	}
+
+	public double getMaximumSpeed(){
+		return maximumSpeed;
+	}
+
 	public void setResponseFormat(String responseFormat) {
 		if (!Helper.isEmpty(responseFormat)) {
 			this.responseFormat = responseFormat;

openrouteservice/src/main/java/org/heigit/ors/routing/configuration/RouteProfileConfiguration.java

@@ -56,6 +56,8 @@ public class RouteProfileConfiguration {
 	private int locationIndexResolution = 500;
 	private int locationIndexSearchIterations = 4;
 
+	private double maximumSpeedLowerBound = 80;
+
 	public RouteProfileConfiguration() {
 		extStorages = new HashMap<>();
 		graphBuilders = new HashMap<>();
@@ -356,4 +358,12 @@ public int getLocationIndexSearchIterations() {
 	public void setLocationIndexSearchIterations(int locationIndexSearchIterations) {
 		this.locationIndexSearchIterations = locationIndexSearchIterations;
 	}
+
+	public void setMaximumSpeedLowerBound(double maximumSpeedLowerBound){
+		this.maximumSpeedLowerBound = maximumSpeedLowerBound;
+	}
+
+	public double getMaximumSpeedLowerBound(){
+		return maximumSpeedLowerBound;
+	}
 }

openrouteservice/src/main/java/org/heigit/ors/routing/graphhopper/extensions/GraphProcessContext.java

@@ -37,6 +37,7 @@ public class GraphProcessContext {
 	private GraphBuilder[] arrGraphBuilders;
 	private List<GraphStorageBuilder> storageBuilders;
 	private GraphStorageBuilder[] arrStorageBuilders;
+	private double maximumSpeedLowerBound;
 
 	public GraphProcessContext(RouteProfileConfiguration config) throws Exception {
 		bbox = config.getExtent();
@@ -59,6 +60,8 @@ public GraphProcessContext(RouteProfileConfiguration config) throws Exception {
 				arrGraphBuilders = graphBuilders.toArray(arrGraphBuilders);
 			}
 		}
+
+		maximumSpeedLowerBound = config.getMaximumSpeedLowerBound();
 	}
 
 	public void init(GraphHopper gh) {
@@ -208,4 +211,8 @@ public void finish() {
 			}
 		}
 	}
+
+	public double getMaximumSpeedLowerBound(){
+		return maximumSpeedLowerBound;
+	}
 }

openrouteservice/src/main/java/org/heigit/ors/routing/graphhopper/extensions/ORSGraphHopper.java

@@ -47,6 +47,8 @@
 import org.heigit.ors.routing.graphhopper.extensions.edgefilters.core.AvoidFeaturesCoreEdgeFilter;
 import org.heigit.ors.routing.graphhopper.extensions.edgefilters.core.HeavyVehicleCoreEdgeFilter;
 import org.heigit.ors.routing.graphhopper.extensions.edgefilters.core.WheelchairCoreEdgeFilter;
+import org.heigit.ors.routing.graphhopper.extensions.edgefilters.core.MaximumSpeedCoreEdgeFilter;
+import org.heigit.ors.routing.graphhopper.extensions.weighting.MaximumSpeedWeighting;
 import org.heigit.ors.routing.graphhopper.extensions.util.ORSParameters;
 import org.heigit.ors.util.CoordTools;
 import org.slf4j.Logger;
@@ -76,6 +78,8 @@ public class ORSGraphHopper extends GraphHopper {
 
 	private final CoreLMAlgoFactoryDecorator coreLMFactoryDecorator = new CoreLMAlgoFactoryDecorator();
 
+	private double maximumSpeedLowerBound;
+
 	public ORSGraphHopper(GraphProcessContext procCntx) {
 		processContext = procCntx;
 		forDesktop();
@@ -85,6 +89,8 @@ public ORSGraphHopper(GraphProcessContext procCntx) {
 		algoDecorators.add(getCHFactoryDecorator());
 		algoDecorators.add(getLMFactoryDecorator());
 		processContext.init(this);
+		maximumSpeedLowerBound = procCntx.getMaximumSpeedLowerBound();
+
 	}
 
 
@@ -97,6 +103,7 @@ public GraphHopper init(CmdArgs args) {
 		GraphHopper ret = super.init(args);
 		minNetworkSize = args.getInt("prepare.min_network_size", minNetworkSize);
 		minOneWayNetworkSize = args.getInt("prepare.min_one_way_network_size", minOneWayNetworkSize);
+
 		return ret;
 	}
 
@@ -323,10 +330,17 @@ else if (ALT_ROUTE.equalsIgnoreCase(algoStr))
 					throw new IllegalArgumentException(
 							"The max_visited_nodes parameter has to be below or equal to:" + getMaxVisitedNodes());
 
+
+				if(hints.has("maximum_speed")) {
+					weighting = new MaximumSpeedWeighting(encoder, hints, weighting, maximumSpeedLowerBound);
+				}
+
+
 				int uTurnCosts = hints.getInt(Parameters.Routing.U_TURN_COSTS, INFINITE_U_TURN_COSTS);
 				weighting = createTurnWeighting(queryGraph, weighting, tMode, uTurnCosts);
 				if (weighting instanceof TurnWeighting)
 	                ((TurnWeighting)weighting).setInORS(true);
+
 				AlgorithmOptions algoOpts = AlgorithmOptions.start().algorithm(algoStr).traversalMode(tMode)
 						.weighting(weighting).maxVisitedNodes(maxVisitedNodesForRequest).hints(hints).build();
 
@@ -523,6 +537,17 @@ public void postProcessing() {
 			coreEdgeFilter.add(new WheelchairCoreEdgeFilter(gs));
 		}
 
+		/* Maximum Speed Filter */
+		if ((routingProfileCategory & RoutingProfileCategory.DRIVING) !=0 ) {
+			FlagEncoder flagEncoder = null;
+			if(encodingManager.hasEncoder("heavyvehicle"))
+				flagEncoder = getEncodingManager().getEncoder("heavyvehicle");
+			else if(encodingManager.hasEncoder("car-ors"))
+				flagEncoder = getEncodingManager().getEncoder("car-ors");
+
+			coreEdgeFilter.add(new MaximumSpeedCoreEdgeFilter(flagEncoder, maximumSpeedLowerBound));
+		}
+
 		/* End filter sequence initialization */
 
 		//Create the core

openrouteservice/src/main/java/org/heigit/ors/routing/graphhopper/extensions/ORSWeightingFactory.java

@@ -18,10 +18,8 @@
 import com.graphhopper.routing.util.HintsMap;
 import com.graphhopper.routing.util.TraversalMode;
 import com.graphhopper.routing.weighting.*;
-import com.graphhopper.storage.Graph;
 import com.graphhopper.storage.GraphHopperStorage;
 import com.graphhopper.storage.TurnCostExtension;
-import com.graphhopper.storage.index.LocationIndex;
 import com.graphhopper.util.Helper;
 import com.graphhopper.util.PMap;
 import com.graphhopper.util.Parameters;

openrouteservice/src/main/java/org/heigit/ors/routing/graphhopper/extensions/core/PrepareCore.java

@@ -509,11 +509,11 @@ public RoutingAlgorithm createAlgo(Graph graph, AlgorithmOptions opts) {
         String algoStr = ASTAR_BI;
 
         if (ASTAR_BI.equals(algoStr)) {
-            CoreALT tmpAlgo = new CoreALT(graph, prepareWeighting, traversalMode);
+            CoreALT tmpAlgo = new CoreALT(graph,new PreparationWeighting(opts.getWeighting()), traversalMode);
             tmpAlgo.setApproximation(RoutingAlgorithmFactorySimple.getApproximation(ASTAR_BI, opts, graph.getNodeAccess()));
             algo = tmpAlgo;
         } else if (DIJKSTRA_BI.equals(algoStr)) {
-            algo = new CoreDijkstra(graph, prepareWeighting, traversalMode);
+            algo = new CoreDijkstra(graph, new PreparationWeighting(opts.getWeighting()), traversalMode);
         } else {
             throw new IllegalArgumentException("Algorithm " + opts.getAlgorithm()
                     + " not supported for Contraction Hierarchies. Try with ch.disable=true");

openrouteservice/src/main/java/org/heigit/ors/routing/graphhopper/extensions/edgefilters/core/MaximumSpeedCoreEdgeFilter.java

@@ -0,0 +1,51 @@
+/*  This file is part of Openrouteservice.
+ *
+ *  Openrouteservice is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1
+ *  of the License, or (at your option) any later version.
+
+ *  This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU Lesser General Public License for more details.
+
+ *  You should have received a copy of the GNU Lesser General Public License along with this library;
+ *  if not, see <https://www.gnu.org/licenses/>.
+ */
+package org.heigit.ors.routing.graphhopper.extensions.edgefilters.core;
+
+import com.graphhopper.routing.profiles.DecimalEncodedValue;
+import com.graphhopper.routing.util.EdgeFilter;
+import com.graphhopper.util.EdgeIteratorState;
+import com.graphhopper.routing.util.FlagEncoder;
+import org.heigit.ors.config.AppConfig;
+
+/**
+ * This class includes in the core all edges with speed more than the one set in the app.config file max_speed.
+ *
+ * @author Athanasios Kogios
+ */
+
+public class MaximumSpeedCoreEdgeFilter implements EdgeFilter {
+    private double maximumSpeedLowerBound;
+    private double maxSpeed =  ((AppConfig.getGlobal().getServiceParameter("routing.profiles.default_params","maximum_speed_lower_bound")) != null)
+            ?   Double.parseDouble(AppConfig.getGlobal().getServiceParameter("routing.profiles.default_params","maximum_speed_lower_bound"))
+            : maximumSpeedLowerBound; //If there is a maximum_speed value in the app.config we use that. If not we set a default of 80.
+
+    private final DecimalEncodedValue avSpeedEnc;
+
+    public MaximumSpeedCoreEdgeFilter(FlagEncoder flagEncoder, double maximumSpeedLowerBound) {
+        this.maximumSpeedLowerBound = maximumSpeedLowerBound;
+        this.avSpeedEnc = flagEncoder.getAverageSpeedEnc();
+    }
+
+    @Override
+    public boolean accept(EdgeIteratorState edge) {
+        if ( (edge.get(avSpeedEnc) > maxSpeed) || (edge.getReverse(avSpeedEnc)) > maxSpeed ) {
+            //If the max speed of the road is greater than that of the limit include it in the core.
+            return false;
+        } else {
+            return true;
+        }
+    }
+}
+