Basic support for Mapbox / OSRM endpoint

web-api/src/main/java/com/graphhopper/http/WebHelper.java

@@ -102,16 +102,20 @@ public static String encodePolyline(PointList poly) {
     }
 
     public static String encodePolyline(PointList poly, boolean includeElevation) {
+        return encodePolyline(poly, includeElevation, 1e5);
+    }
+
+    public static String encodePolyline(PointList poly, boolean includeElevation, double precision) {
         StringBuilder sb = new StringBuilder();
         int size = poly.getSize();
         int prevLat = 0;
         int prevLon = 0;
         int prevEle = 0;
         for (int i = 0; i < size; i++) {
-            int num = (int) Math.floor(poly.getLatitude(i) * 1e5);
+            int num = (int) Math.floor(poly.getLatitude(i) * precision);
             encodeNumber(sb, num - prevLat);
             prevLat = num;
-            num = (int) Math.floor(poly.getLongitude(i) * 1e5);
+            num = (int) Math.floor(poly.getLongitude(i) * precision);
             encodeNumber(sb, num - prevLon);
             prevLon = num;
             if (includeElevation) {

web-bundle/src/main/java/com/graphhopper/http/GraphHopperBundle.java

@@ -55,10 +55,7 @@
 import org.glassfish.hk2.utilities.binding.AbstractBinder;
 
 import javax.inject.Inject;
-import javax.ws.rs.WebApplicationException;
 import javax.ws.rs.ext.WriterInterceptor;
-import javax.ws.rs.ext.WriterInterceptorContext;
-import java.io.IOException;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
@@ -265,6 +262,7 @@ public void stop() throws Exception {
 
     private void runRegularGraphHopper(CmdArgs configuration, Environment environment) {
         final GraphHopperManaged graphHopperManaged = new GraphHopperManaged(configuration, environment.getObjectMapper());
+        final TranslationMap translationMap = graphHopperManaged.getGraphHopper().getTranslationMap();
         environment.lifecycle().manage(graphHopperManaged);
         environment.jersey().register(new AbstractBinder() {
             @Override
@@ -273,6 +271,7 @@ protected void configure() {
                 bind(graphHopperManaged).to(GraphHopperManaged.class);
                 bind(graphHopperManaged.getGraphHopper()).to(GraphHopper.class);
                 bind(graphHopperManaged.getGraphHopper()).to(GraphHopperAPI.class);
+                bind(translationMap).to(TranslationMap.class);
 
                 bindFactory(HasElevation.class).to(Boolean.class).named("hasElevation");
                 bindFactory(LocationIndexFactory.class).to(LocationIndex.class);
@@ -288,6 +287,7 @@ protected void configure() {
         }
         environment.jersey().register(NearestResource.class);
         environment.jersey().register(RouteResource.class);
+        environment.jersey().register(MapboxResource.class);
         environment.jersey().register(IsochroneResource.class);
         environment.jersey().register(I18NResource.class);
         environment.jersey().register(InfoResource.class);

web-bundle/src/main/java/com/graphhopper/resources/MapboxResource.java

@@ -0,0 +1,181 @@
+/*
+ *  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.resources;
+
+import com.graphhopper.GHRequest;
+import com.graphhopper.GHResponse;
+import com.graphhopper.GraphHopperAPI;
+import com.graphhopper.util.StopWatch;
+import com.graphhopper.util.TranslationMap;
+import com.graphhopper.util.shapes.GHPoint;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.inject.Inject;
+import javax.servlet.http.HttpServletRequest;
+import javax.ws.rs.*;
+import javax.ws.rs.container.ContainerRequestContext;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriInfo;
+import java.util.ArrayList;
+import java.util.List;
+
+import static com.graphhopper.util.Parameters.Routing.*;
+
+/**
+ * Provides an endpoint that is compatible with the Mapbox API v5
+ *
+ * See: https://www.mapbox.com/api-documentation/#directions
+ *
+ * @author Robin Boldt
+ */
+@Path("mapbox/directions/v5/mapbox")
+public class MapboxResource {
+
+    private static final Logger logger = LoggerFactory.getLogger(MapboxResource.class);
+
+    private final GraphHopperAPI graphHopper;
+    private final TranslationMap translationMap;
+
+    @Inject
+    public MapboxResource(GraphHopperAPI graphHopper, TranslationMap translationMap) {
+        this.graphHopper = graphHopper;
+        this.translationMap = translationMap;
+    }
+
+    @GET
+    @Path("/{profile}/{coordinatesArray: .*}")
+    @Produces({MediaType.APPLICATION_JSON})
+    public Response doGet(
+            @Context HttpServletRequest httpReq,
+            @Context UriInfo uriInfo,
+            @Context ContainerRequestContext rc,
+            @QueryParam("steps") @DefaultValue("false") boolean enableInstructions,
+            @QueryParam("voice_instructions") @DefaultValue("false") boolean voiceInstructions,
+            @QueryParam("banner_instructions") @DefaultValue("false") boolean bannerInstructions,
+            @QueryParam("roundabout_exits") @DefaultValue("false") boolean roundaboutExits,
+            @QueryParam("voice_units") @DefaultValue("metric") String voiceUnits,
+            @QueryParam("overview") @DefaultValue("simplified") String overview,
+            @QueryParam("geometries") @DefaultValue("polyline") String geometries,
+            @QueryParam("language") @DefaultValue("en") String localeStr,
+            @QueryParam("heading") List<Double> favoredHeadings,
+            @PathParam("profile") String profile) {
+
+        /*
+            Mapbox always uses fastest or priority weighting, except for walking, it's shortest
+            https://www.mapbox.com/api-documentation/#directions
+         */
+        final String weighting = "fastest";
+
+        /*
+            Currently, the MapboxResponseConverter is pretty limited.
+            Therefore, we enforce these values to make sure the client does not receive an unexpected answer.
+         */
+        if (!geometries.equals("polyline6"))
+            throw new IllegalArgumentException("Currently, we only support polyline6");
+        if (!enableInstructions)
+            throw new IllegalArgumentException("Currently, you need to enable steps");
+        if (!roundaboutExits)
+            throw new IllegalArgumentException("Roundabout exits have to be enabled right now");
+        if (!voiceUnits.equals("metric"))
+            throw new IllegalArgumentException("Voice units only support metric right now");
+        if (!voiceInstructions)
+            throw new IllegalArgumentException("You need to enable voice instructions right now");
+        if (!bannerInstructions)
+            throw new IllegalArgumentException("You need to enable banner instructions right now");
+
+        double minPathPrecision = 1;
+        if (overview.equals("full"))
+            minPathPrecision = 0;
+
+        String vehicleStr = convertProfileToGraphHopperVehicleString(profile);
+        List<GHPoint> requestPoints = getPointsFromRequest(httpReq, profile);
+
+        StopWatch sw = new StopWatch().start();
+
+        // TODO: initialization with heading/bearings
+        // TODO: how should we use the "continue_straight" parameter? This is analog to pass_through, would require disabling CH
+
+        GHRequest request = new GHRequest(requestPoints);
+        request.setVehicle(vehicleStr).
+                setWeighting(weighting).
+                setLocale(localeStr).
+                getHints().
+                put(CALC_POINTS, true).
+                put(INSTRUCTIONS, enableInstructions).
+                put(WAY_POINT_MAX_DISTANCE, minPathPrecision);
+
+        GHResponse ghResponse = graphHopper.route(request);
+
+        float took = sw.stop().getSeconds();
+        String infoStr = httpReq.getRemoteAddr() + " " + httpReq.getLocale() + " " + httpReq.getHeader("User-Agent");
+        String logStr = httpReq.getQueryString() + " " + infoStr + " " + requestPoints + ", took:"
+                + took + ", " + weighting + ", " + vehicleStr;
+
+        if (ghResponse.hasErrors()) {
+            logger.error(logStr + ", errors:" + ghResponse.getErrors());
+            // Mapbox specifies 422 return type for input errors
+            return Response.status(422).entity(MapboxResponseConverter.convertFromGHResponseError(ghResponse)).
+                    header("X-GH-Took", "" + Math.round(took * 1000)).
+                    build();
+        } else {
+            return Response.ok(MapboxResponseConverter.convertFromGHResponse(ghResponse, translationMap, request.getLocale())).
+                    header("X-GH-Took", "" + Math.round(took * 1000)).
+                    build();
+        }
+    }
+
+    /**
+     * This method is parsing the request URL String. Unfortunately it seems that there is no better options right now.
+     * See: https://stackoverflow.com/q/51420380/1548788
+     *
+     * The url looks like: ".../{profile}/1.522438,42.504606;1.527209,42.504776;1.526113,42.505144;1.527218,42.50529?.."
+     */
+    private List<GHPoint> getPointsFromRequest(HttpServletRequest httpServletRequest, String profile) {
+
+        String url = httpServletRequest.getRequestURI();
+        url = url.replaceFirst("/mapbox/directions/v5/mapbox/" + profile + "/", "");
+        url = url.replaceAll("\\?[*]", "");
+
+        String[] pointStrings = url.split(";");
+
+        List<GHPoint> points = new ArrayList<>(pointStrings.length);
+        for (int i = 0; i < pointStrings.length; i++) {
+            points.add(GHPoint.fromStringLonLat(pointStrings[i]));
+        }
+
+        return points;
+    }
+
+    private String convertProfileToGraphHopperVehicleString(String profile) {
+        switch (profile) {
+            case "driving":
+                // driving-traffic is mapped to regular car as well
+            case "driving-traffic":
+                return "car";
+            case "walking":
+                return "foot";
+            case "cycling":
+                return "bike";
+            default:
+                throw new IllegalArgumentException("Not supported profile: " + profile);
+        }
+    }
+}