graphhopper · karussell · Jun 17, 2019 · Oct 15, 2018 · Oct 15, 2018 · Oct 15, 2018
diff --git a/README.md b/README.md
@@ -205,3 +205,4 @@ Here is a list of the more detailed features including a link to the documentati
 * Do [map matching](https://github.com/graphhopper/map-matching) with GraphHopper
 * Calculate [isochrones](./docs/web/api-doc.md#isochrone) with GraphHopper
 * Show path details [#1142](https://github.com/graphhopper/graphhopper/pull/1142)
+ * GraphHopper can produce vector tiles for debugging purposes [#1572](https://github.com/graphhopper/graphhopper/pull/1572)
diff --git a/core/src/main/java/com/graphhopper/routing/util/EncodingManager.java b/core/src/main/java/com/graphhopper/routing/util/EncodingManager.java
@@ -666,9 +666,6 @@ public void applyWayTags(ReaderWay way, EdgeIteratorState edge) {
        }
    }

-    /**
-     * The returned list is never empty.
-     */
    public List<FlagEncoder> fetchEdgeEncoders() {
        return new ArrayList<FlagEncoder>(edgeEncoders);
    }

diff --git a/core/src/main/java/com/graphhopper/storage/index/LocationIndexTree.java b/core/src/main/java/com/graphhopper/storage/index/LocationIndexTree.java
@@ -66,8 +66,8 @@ public class LocationIndexTree implements LocationIndex {
    private final int MAGIC_INT;
    private final NodeAccess nodeAccess;
    protected DistanceCalc distCalc = Helper.DIST_PLANE;
-    protected SpatialKeyAlgo keyAlgo;
-    int maxRegionSearch = 4;
+    SpatialKeyAlgo keyAlgo;
+    private int maxRegionSearch = 4;
    private DistanceCalc preciseDistCalc = Helper.DIST_EARTH;
    private int[] entries;
    private byte[] shifts;
@@ -138,7 +138,7 @@ void prepareAlgo() {
        equalNormedDelta = distCalc.calcNormalizedDist(0.1);

        // now calculate the necessary maxDepth d for our current bounds
-        // if we assume a minimum resolution like 0.5km for a leaf-tile                
+        // if we assume a minimum resolution like 0.5km for a leaf-tile
        // n^(depth/2) = toMeter(dLon) / minResolution
        BBox bounds = graph.getBounds();
        if (graph.getNodes() == 0)
@@ -349,8 +349,8 @@ IntArrayList getEntries() {
    /**
     * This method fills the set with stored node IDs from the given spatial key part (a latitude-longitude prefix).
     */
-    final void fillIDs(long keyPart, int intIndex, GHIntHashSet set, int depth) {
-        long pointer = (long) intIndex << 2;
+    final void fillIDs(long keyPart, int intPointer, GHIntHashSet set, int depth) {
+        long pointer = (long) intPointer << 2;
        if (depth == entries.length) {
            int nextIntPointer = dataAccess.getInt(pointer);
            if (nextIntPointer < 0) {
@@ -385,7 +385,6 @@ final long createReverseKey(long key) {
    /**
     * calculate the distance to the nearest tile border for a given lat/lon coordinate in the
     * context of a spatial key tile.
-     * <p>
     */
    final double calculateRMin(double lat, double lon) {
        return calculateRMin(lat, lon, 0);
@@ -788,7 +787,7 @@ IntArrayList getResults() {

    // Space efficient sorted integer set. Suited for only a few entries.
    static class SortedIntSet extends IntArrayList {
-        public SortedIntSet(int capacity) {
+        SortedIntSet(int capacity) {
            super(capacity);
        }


diff --git a/core/src/test/java/com/graphhopper/storage/index/LocationIndexTreeTest.java b/core/src/test/java/com/graphhopper/storage/index/LocationIndexTreeTest.java
@@ -30,10 +30,7 @@
 import com.graphhopper.util.shapes.GHPoint;
 import org.junit.Test;

-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;

 import static org.junit.Assert.*;


diff --git a/isochrone/pom.xml b/isochrone/pom.xml
@@ -16,14 +16,19 @@
        <version>0.13-SNAPSHOT</version>
    </parent>

-
    <dependencies>
        <dependency>
            <groupId>com.graphhopper</groupId>
            <artifactId>graphhopper-reader-osm</artifactId>
            <version>${project.parent.version}</version>
        </dependency>

+        <dependency>
+            <groupId>com.wdtinc</groupId>
+            <artifactId>mapbox-vector-tile</artifactId>
+            <version>3.1.0</version>
+        </dependency>
+
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
@@ -44,7 +49,6 @@
            <scope>test</scope>
        </dependency>
    </dependencies>
-
 </project>


diff --git a/web-bundle/src/main/java/com/graphhopper/http/GraphHopperBundle.java b/web-bundle/src/main/java/com/graphhopper/http/GraphHopperBundle.java
@@ -281,6 +281,8 @@ protected void configure() {
        if (configuration.getBool("web.change_graph.enabled", false)) {
            environment.jersey().register(ChangeGraphResource.class);
        }
+
+        environment.jersey().register(MVTResource.class);
        environment.jersey().register(NearestResource.class);
        environment.jersey().register(RouteResource.class);
        environment.jersey().register(IsochroneResource.class);

diff --git a/web-bundle/src/main/java/com/graphhopper/http/GraphHopperManaged.java b/web-bundle/src/main/java/com/graphhopper/http/GraphHopperManaged.java
@@ -71,7 +71,7 @@ public void start() {
        graphHopper.importOrLoad();
        logger.info("loaded graph at:" + graphHopper.getGraphHopperLocation()
                + ", data_reader_file:" + graphHopper.getDataReaderFile()
-                + ", flag_encoders:" + graphHopper.getEncodingManager()
+                + ", encoded values:" + graphHopper.getEncodingManager().toEncodedValuesAsString()
                + ", " + graphHopper.getGraphHopperStorage().toDetailsString());
    }


diff --git a/web-bundle/src/main/java/com/graphhopper/resources/IsochroneResource.java b/web-bundle/src/main/java/com/graphhopper/resources/IsochroneResource.java
@@ -146,4 +146,4 @@ private Response jsonSuccessResponse(Object result, float took) {
        info.put("took", Math.round(took * 1000));
        return Response.ok(json).build();
    }
-}
+}
diff --git a/web-bundle/src/main/java/com/graphhopper/resources/MVTResource.java b/web-bundle/src/main/java/com/graphhopper/resources/MVTResource.java
@@ -0,0 +1,167 @@
+package com.graphhopper.resources;
+
+import com.graphhopper.GraphHopper;
+import com.graphhopper.routing.profiles.*;
+import com.graphhopper.routing.util.DefaultEdgeFilter;
+import com.graphhopper.routing.util.EncodingManager;
+import com.graphhopper.storage.NodeAccess;
+import com.graphhopper.storage.index.LocationIndexTree;
+import com.graphhopper.util.*;
+import com.graphhopper.util.shapes.BBox;
+import com.wdtinc.mapbox_vector_tile.VectorTile;
+import com.wdtinc.mapbox_vector_tile.adapt.jts.IGeometryFilter;
+import com.wdtinc.mapbox_vector_tile.adapt.jts.JtsAdapter;
+import com.wdtinc.mapbox_vector_tile.adapt.jts.TileGeomResult;
+import com.wdtinc.mapbox_vector_tile.adapt.jts.UserDataKeyValueMapConverter;
+import com.wdtinc.mapbox_vector_tile.build.MvtLayerBuild;
+import com.wdtinc.mapbox_vector_tile.build.MvtLayerParams;
+import com.wdtinc.mapbox_vector_tile.build.MvtLayerProps;
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.Envelope;
+import org.locationtech.jts.geom.GeometryFactory;
+import org.locationtech.jts.geom.LineString;
+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.core.Context;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriInfo;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+@Path("mvt")
+public class MVTResource {
+
+    private static final Logger logger = LoggerFactory.getLogger(MVTResource.class);
+    private static final MediaType PBF = new MediaType("application", "x-protobuf");
+    private final GraphHopper graphHopper;
+    private final EncodingManager encodingManager;
+
+    @Inject
+    public MVTResource(GraphHopper graphHopper, EncodingManager encodingManager) {
+        this.graphHopper = graphHopper;
+        this.encodingManager = encodingManager;
+    }
+
+    @GET
+    @Path("{z}/{x}/{y}.mvt")
+    @Produces("application/x-protobuf")
+    public Response doGetXyz(
+            @Context HttpServletRequest httpReq,
+            @Context UriInfo uriInfo,
+            @PathParam("z") int zInfo,
+            @PathParam("x") int xInfo,
+            @PathParam("y") int yInfo,
+            @QueryParam(Parameters.DETAILS.PATH_DETAILS) List<String> pathDetails) {
+
+        if (zInfo <= 9) {
+            VectorTile.Tile.Builder mvtBuilder = VectorTile.Tile.newBuilder();
+            return Response.fromResponse(Response.ok(mvtBuilder.build().toByteArray(), PBF).build())
+                    .header("X-GH-Took", "0")
+                    .build();
+        }
+
+        StopWatch totalSW = new StopWatch().start();
+        Coordinate nw = num2deg(xInfo, yInfo, zInfo);
+        Coordinate se = num2deg(xInfo + 1, yInfo + 1, zInfo);
+        LocationIndexTree locationIndex = (LocationIndexTree) graphHopper.getLocationIndex();
+        final NodeAccess na = graphHopper.getGraphHopperStorage().getNodeAccess();
+        EdgeExplorer edgeExplorer = graphHopper.getGraphHopperStorage().createEdgeExplorer(DefaultEdgeFilter.ALL_EDGES);
+        BBox bbox = new BBox(nw.x, se.x, se.y, nw.y);
+        if (!bbox.isValid())
+            throw new IllegalStateException("Invalid bbox " + bbox);
+
+        final GeometryFactory geometryFactory = new GeometryFactory();
+        VectorTile.Tile.Builder mvtBuilder = VectorTile.Tile.newBuilder();
+        final IGeometryFilter acceptAllGeomFilter = geometry -> true;
+        final Envelope tileEnvelope = new Envelope(se, nw);
+        final MvtLayerParams layerParams = new MvtLayerParams(256, 4096);
+        final UserDataKeyValueMapConverter converter = new UserDataKeyValueMapConverter();
+        if (!encodingManager.hasEncodedValue(RoadClass.KEY))
+            throw new IllegalStateException("You need to configure GraphHopper to store road_class, e.g. graph.encoded_values: road_class,max_speed,... ");
+
+        final EnumEncodedValue<RoadClass> roadClassEnc = encodingManager.getEnumEncodedValue(RoadClass.KEY, RoadClass.class);
+        final AtomicInteger edgeCounter = new AtomicInteger(0);
+        // in toFeatures addTags of the converter is called and layerProps is filled with keys&values => those need to be stored in the layerBuilder
+        // otherwise the decoding won't be successful and "undefined":"undefined" instead of "speed": 30 is the result
+        final MvtLayerProps layerProps = new MvtLayerProps();
+        final VectorTile.Tile.Layer.Builder layerBuilder = MvtLayerBuild.newLayerBuilder("roads", layerParams);
+
+        locationIndex.query(bbox, new LocationIndexTree.EdgeVisitor(edgeExplorer) {
+            @Override
+            public void onEdge(EdgeIteratorState edge, int nodeA, int nodeB) {
+                LineString lineString;
+                RoadClass rc = edge.get(roadClassEnc);
+                if (zInfo >= 14) {
+                    PointList pl = edge.fetchWayGeometry(3);
+                    lineString = pl.toLineString(false);
+                } else if (rc == RoadClass.MOTORWAY
+                        || zInfo > 10 && (rc == RoadClass.PRIMARY || rc == RoadClass.TRUNK)
+                        || zInfo > 11 && (rc == RoadClass.SECONDARY)
+                        || zInfo > 12) {
+                    double lat = na.getLatitude(nodeA);
+                    double lon = na.getLongitude(nodeA);
+                    double toLat = na.getLatitude(nodeB);
+                    double toLon = na.getLongitude(nodeB);
+                    lineString = geometryFactory.createLineString(new Coordinate[]{new Coordinate(lon, lat), new Coordinate(toLon, toLat)});
+                } else {
+                    // skip edge for certain zoom
+                    return;
+                }
+
+                edgeCounter.incrementAndGet();
+                Map<String, Object> map = new HashMap<>(2);
+                map.put("name", edge.getName());
+                for (String str : pathDetails) {
+                    // how to indicate an erroneous parameter?
+                    if (str.contains(",") || !encodingManager.hasEncodedValue(str))
+                        continue;
+
+                    EncodedValue ev = encodingManager.getEncodedValue(str, EncodedValue.class);
+                    if (ev instanceof EnumEncodedValue)
+                        map.put(ev.getName(), edge.get((EnumEncodedValue) ev).toString());
+                    else if (ev instanceof DecimalEncodedValue)
+                        map.put(ev.getName(), edge.get((DecimalEncodedValue) ev));
+                    else if (ev instanceof BooleanEncodedValue)
+                        map.put(ev.getName(), edge.get((BooleanEncodedValue) ev));
+                    else if (ev instanceof IntEncodedValue)
+                        map.put(ev.getName(), edge.get((IntEncodedValue) ev));
+                }
+
+                lineString.setUserData(map);
+
+                // doing some AffineTransformation
+                TileGeomResult tileGeom = JtsAdapter.createTileGeom(lineString, tileEnvelope, geometryFactory, layerParams, acceptAllGeomFilter);
+                List<VectorTile.Tile.Feature> features = JtsAdapter.toFeatures(tileGeom.mvtGeoms, layerProps, converter);
+                layerBuilder.addAllFeatures(features);
+            }
+
+            @Override
+            public void onTile(BBox bbox, int depth) {
+            }
+        });
+
+        MvtLayerBuild.writeProps(layerBuilder, layerProps);
+        mvtBuilder.addLayers(layerBuilder.build());
+        byte[] bytes = mvtBuilder.build().toByteArray();
+        totalSW.stop();
+        logger.debug("took: " + totalSW.getSeconds() + ", edges:" + edgeCounter.get());
+        return Response.ok(bytes, PBF).header("X-GH-Took", "" + totalSW.getSeconds() * 1000)
+                .build();
+    }
+
+    Coordinate num2deg(int xInfo, int yInfo, int zoom) {
+        double n = Math.pow(2, zoom);
+        double lonDeg = xInfo / n * 360.0 - 180.0;
+        // unfortunately latitude numbers goes from north to south
+        double latRad = Math.atan(Math.sinh(Math.PI * (1 - 2 * yInfo / n)));
+        double latDeg = Math.toDegrees(latRad);
+        return new Coordinate(lonDeg, latDeg);
+    }
+}
diff --git a/web/package.json b/web/package.json
@@ -24,6 +24,7 @@
    }
  },
  "dependencies": {
+    "leaflet.vectorgrid": "1.3.0",
    "browserify": "16.2.0",
    "browserify-swap": "0.2.2",
    "d3": "5.9.1",

diff --git a/web/src/main/resources/assets/js/config/tileLayers.js b/web/src/main/resources/assets/js/config/tileLayers.js
@@ -16,7 +16,7 @@ var lyrk = L.tileLayer('https://tiles.lyrk.org/' + (retinaTiles ? 'lr' : 'ls') +
    attribution: osmAttr + ', <a href="https://geodienste.lyrk.de/">Lyrk</a>'
 });

-var omniscale = L.tileLayer('https://maps.omniscale.net/v2/' +osAPIKey + '/style.default' + (retinaTiles ? '/hq.true' : '') + '/{z}/{x}/{y}.png', {
+var omniscale = L.tileLayer('https://maps.omniscale.net/v2/' +osAPIKey + '/style.default/{z}/{x}/{y}.png' + (retinaTiles ? '?hq=true' : ''), {
    layers: 'osm',
    attribution: osmAttr + ', &copy; <a href="https://maps.omniscale.com/">Omniscale</a>'
 });
@@ -85,13 +85,67 @@ var availableTileLayers = {
    "OpenStreetMap.de": osmde
 };

+var overlays;
+if(ghenv.environment === 'development') {
+    var omniscaleGray = L.tileLayer('https://maps.omniscale.net/v2/' +osAPIKey + '/style.grayscale/layers.world,buildings,landusages,labels/{z}/{x}/{y}.png?' + (retinaTiles ? '&hq=true' : ''), {
+        layers: 'osm',
+        attribution: osmAttr + ', &copy; <a href="https://maps.omniscale.com/">Omniscale</a>'
+    });
+    availableTileLayers["Omniscale Dev"] = omniscaleGray;
+
+    require('leaflet.vectorgrid');
+    overlays = {};
+    overlays["Local MVT"] = L.vectorGrid.protobuf("http://127.0.0.1:8989/mvt/{z}/{x}/{y}.mvt?details=max_speed&details=road_class&details=road_environment", {
+      rendererFactory: L.canvas.tile,
+      maxZoom: 20,
+      minZoom: 10,
+      vectorTileLayerStyles: {
+        'roads': function(properties, zoom) {
+            var color, opacity = 1, weight = 1, radius = 2, rc = properties.road_class;
+            // if(properties.speed < 30) console.log(properties)
+            if(rc == "motorway") {
+                color = '#dd504b'; // red
+                weight = 3;
+                radius = 6;
+            } else if(rc == "primary" || rc == "trunk") {
+                color = '#e2a012'; // orange
+                weight = 2;
+                radius = 6;
+            } else if(rc == "secondary") {
+                weight = 2;
+                color = '#f7c913'; // yellow
+            } else {
+                if(zoom <= 11) {
+                  // color = "white";
+                  color = "#aaa5a7"
+                  opacity = 0.2;
+                } else {
+                  color = "#aaa5a7"; /* gray */
+                }
+            }
+            return {
+                weight: weight,
+                color: color,
+                opacity: opacity,
+                radius: radius
+            }
+        },
+      },
+      interactive: true // use true to make sure that this VectorGrid fires mouse/pointer events
+    });
+}
+
 module.exports.activeLayerName = "Omniscale";
 module.exports.defaultLayer = omniscale;

 module.exports.getAvailableTileLayers = function () {
    return availableTileLayers;
 };

+module.exports.getOverlays = function () {
+    return overlays;
+};
+
 module.exports.selectLayer = function (layerName) {
    var defaultLayer = availableTileLayers[layerName];
    if (!defaultLayer)