Implements a vector tileserver so you can see what's going on inside

OSRM.

include/engine/datafacade/datafacade_base.hpp

@@ -76,6 +76,9 @@ template <class EdgeDataT> class BaseDataFacade
 
     virtual extractor::TravelMode GetTravelModeForEdgeID(const unsigned id) const = 0;
 
+    virtual std::vector<RTreeLeaf> GetEdgesInBox(const util::FixedPointCoordinate & south_west,
+                                                 const util::FixedPointCoordinate & north_east) = 0;
+
     virtual std::vector<PhantomNodeWithDistance>
     NearestPhantomNodesInRange(const util::FixedPointCoordinate input_coordinate,
                                const float max_distance,

include/engine/datafacade/internal_datafacade.hpp

@@ -15,6 +15,7 @@
 #include "util/range_table.hpp"
 #include "util/graph_loader.hpp"
 #include "util/simple_logger.hpp"
+#include "util/rectangle.hpp"
 
 #include "osrm/coordinate.hpp"
 
@@ -357,6 +358,20 @@ template <class EdgeDataT> class InternalDataFacade final : public BaseDataFacad
         return m_travel_mode_list.at(id);
     }
 
+    std::vector<RTreeLeaf> GetEdgesInBox(const util::FixedPointCoordinate & south_west,
+                                         const util::FixedPointCoordinate & north_east)
+        override final
+    {
+        if (!m_static_rtree.get())
+        {
+            LoadRTree();
+            BOOST_ASSERT(m_geospatial_query.get());
+        }
+        util::RectangleInt2D bbox = {south_west.lon, north_east.lon,
+                                     south_west.lat, north_east.lat};
+        return m_geospatial_query->Search(bbox);
+    }
+
     std::vector<PhantomNodeWithDistance>
     NearestPhantomNodesInRange(const util::FixedPointCoordinate input_coordinate,
                                const float max_distance,

include/engine/datafacade/shared_datafacade.hpp

@@ -13,6 +13,7 @@
 #include "util/static_rtree.hpp"
 #include "util/make_unique.hpp"
 #include "util/simple_logger.hpp"
+#include "util/rectangle.hpp"
 
 #include <cstddef>
 
@@ -407,6 +408,20 @@ template <class EdgeDataT> class SharedDataFacade final : public BaseDataFacade<
         return m_travel_mode_list.at(id);
     }
 
+    std::vector<RTreeLeaf> GetEdgesInBox(const util::FixedPointCoordinate & south_west,
+                                         const util::FixedPointCoordinate & north_east)
+        override final
+    {
+        if (!m_static_rtree.get() || CURRENT_TIMESTAMP != m_static_rtree->first)
+        {
+            LoadRTree();
+            BOOST_ASSERT(m_geospatial_query.get());
+        }
+        util::RectangleInt2D bbox = {south_west.lon, north_east.lon,
+                                     south_west.lat, north_east.lat};
+        return m_geospatial_query->Search(bbox);
+    }
+
     std::vector<PhantomNodeWithDistance>
     NearestPhantomNodesInRange(const util::FixedPointCoordinate input_coordinate,
                                const float max_distance,

include/engine/geospatial_query.hpp

@@ -5,6 +5,7 @@
 #include "util/typedefs.hpp"
 #include "engine/phantom_node.hpp"
 #include "util/bearing.hpp"
+#include "util/rectangle.hpp"
 
 #include "osrm/coordinate.hpp"
 
@@ -32,6 +33,14 @@ template <typename RTreeT> class GeospatialQuery
     {
     }
 
+    std::vector<EdgeData>
+    Search(const util::RectangleInt2D & bbox)
+    {
+        return rtree.SearchInBox(bbox);
+
+    }
+
+
     // Returns nearest PhantomNodes in the given bearing range within max_distance.
     // Does not filter by small/big component!
     std::vector<PhantomNodeWithDistance>

include/engine/plugins/tile.hpp

@@ -0,0 +1,349 @@
+#ifndef TILEPLUGIN_HPP
+#define TILEPLUGIN_HPP
+
+#include "engine/plugins/plugin_base.hpp"
+#include "osrm/json_container.hpp"
+#include "util/tile_bbox.hpp"
+
+#include <protozero/varint.hpp>
+#include <protozero/pbf_writer.hpp>
+
+#include <string>
+#include <cmath>
+
+/*
+ * This plugin generates Mapbox Vector tiles that show the internal
+ * routing geometry and speed values on all road segments.
+ * You can use this along with a vector-tile viewer, like Mapbox GL,
+ * to display maps that show the exact road network that
+ * OSRM is routing.  This is very useful for debugging routing
+ * errors
+ */
+namespace osrm
+{
+namespace engine
+{
+namespace plugins
+{
+
+// from mapnik/well_known_srs.hpp
+static const double EARTH_RADIUS = 6378137.0;
+static const double EARTH_DIAMETER = EARTH_RADIUS * 2.0;
+static const double EARTH_CIRCUMFERENCE = EARTH_DIAMETER * M_PI;
+static const double MAXEXTENT = EARTH_CIRCUMFERENCE / 2.0;
+static const double M_PI_by2 = M_PI / 2;
+static const double D2R = M_PI / 180;
+static const double R2D = 180 / M_PI;
+static const double M_PIby360 = M_PI / 360;
+static const double MAXEXTENTby180 = MAXEXTENT / 180;
+static const double MAX_LATITUDE = R2D * (2 * std::atan(std::exp(180 * D2R)) - M_PI_by2);
+
+
+// from mapnik-vector-tile
+namespace detail_pbf {
+
+    inline unsigned encode_length(unsigned len)
+    {
+        return (len << 3u) | 2u;
+    }
+}
+
+inline void lonlat2merc(double & x, double & y)
+{
+    if (x > 180) x = 180;
+    else if (x < -180) x = -180;
+    if (y > MAX_LATITUDE) y = MAX_LATITUDE;
+    else if (y < -MAX_LATITUDE) y = -MAX_LATITUDE;
+    x = x * MAXEXTENTby180;
+    y = std::log(std::tan((90 + y) * M_PIby360)) * R2D;
+    y = y * MAXEXTENTby180;
+}
+
+const static int tile_size_ = 256;
+
+void from_pixels(double shift, double & x, double & y)
+{
+    double b = shift/2.0;
+    x = (x - b)/(shift/360.0);
+    double g = (y - b)/-(shift/(2 * M_PI));
+    y = R2D * (2.0 * std::atan(std::exp(g)) - M_PI_by2);
+}
+
+void xyz(int x,
+         int y,
+         int z,
+         double & minx,
+         double & miny,
+         double & maxx,
+         double & maxy)
+{
+    minx = x * tile_size_;
+    miny = (y + 1.0) * tile_size_;
+    maxx = (x + 1.0) * tile_size_;
+    maxy = y * tile_size_;
+    double shift = std::pow(2.0,z) * tile_size_;
+    from_pixels(shift,minx,miny);
+    from_pixels(shift,maxx,maxy);
+    lonlat2merc(minx,miny);
+    lonlat2merc(maxx,maxy);
+}
+
+void xyz2wsg84(int x,
+         int y,
+         int z,
+         double & minx,
+         double & miny,
+         double & maxx,
+         double & maxy)
+{
+    minx = x * tile_size_;
+    miny = (y + 1.0) * tile_size_;
+    maxx = (x + 1.0) * tile_size_;
+    maxy = y * tile_size_;
+    double shift = std::pow(2.0,z) * tile_size_;
+    from_pixels(shift,minx,miny);
+    from_pixels(shift,maxx,maxy);
+}
+
+
+
+
+
+// emulates mapbox::box2d
+class bbox {
+ public:
+    double minx;
+    double miny;
+    double maxx;
+    double maxy;
+    bbox(double _minx,double _miny,double _maxx,double _maxy) :
+      minx(_minx),
+      miny(_miny),
+      maxx(_maxx),
+      maxy(_maxy) { }
+
+    double width() const {
+        return maxx - minx;
+    }
+
+    double height() const {
+        return maxy - miny;
+    }
+};
+
+// should start using core geometry class across mapnik, osrm, mapbox-gl-native
+class point_type_d {
+ public:
+    double x;
+    double y;
+    point_type_d(double _x, double _y) :
+      x(_x),
+      y(_y) {
+
+    }
+};
+
+class point_type_i {
+ public:
+    std::int64_t x;
+    std::int64_t y;
+    point_type_i(std::int64_t _x, std::int64_t _y) :
+      x(_x),
+      y(_y) {
+
+    }
+};
+
+using line_type = std::vector<point_type_i>;
+using line_typed = std::vector<point_type_d>;
+
+// from mapnik-vector-tile
+inline bool encode_linestring(line_type line,
+                       protozero::packed_field_uint32 & geometry,
+                       int32_t & start_x,
+                       int32_t & start_y) {
+    std::size_t line_size = line.size();
+    //line_size -= detail_pbf::repeated_point_count(line);
+    if (line_size < 2)
+    {
+        return false;
+    }
+
+    unsigned line_to_length = static_cast<unsigned>(line_size) - 1;
+
+    auto pt = line.begin();
+    geometry.add_element(9); // move_to | (1 << 3)
+    geometry.add_element(protozero::encode_zigzag32(pt->x - start_x));
+    geometry.add_element(protozero::encode_zigzag32(pt->y - start_y));
+    start_x = pt->x;
+    start_y = pt->y;
+    geometry.add_element(detail_pbf::encode_length(line_to_length));
+    for (++pt; pt != line.end(); ++pt)
+    {
+        int32_t dx = pt->x - start_x;
+        int32_t dy = pt->y - start_y;
+        /*if (dx == 0 && dy == 0)
+        {
+            continue;
+        }*/
+        geometry.add_element(protozero::encode_zigzag32(dx));
+        geometry.add_element(protozero::encode_zigzag32(dy));
+        start_x = pt->x;
+        start_y = pt->y;
+    }
+    return true;
+}
+
+template <class DataFacadeT> class TilePlugin final : public BasePlugin
+{
+  public:
+    explicit TilePlugin(DataFacadeT *facade) : facade(facade), descriptor_string("tile") {}
+
+    const std::string GetDescriptor() const override final { return descriptor_string; }
+
+    Status HandleRequest(const RouteParameters &route_parameters,
+                         util::json::Object &json_result) override final
+    {
+
+        const unsigned tile_extent = 4096;
+        double min_lon, min_lat, max_lon, max_lat;
+
+        xyz2wsg84(route_parameters.x, route_parameters.y, route_parameters.z, min_lon, min_lat, max_lon, max_lat);
+
+        FixedPointCoordinate southwest = { static_cast<int32_t>(min_lat * COORDINATE_PRECISION), static_cast<int32_t>(min_lon * COORDINATE_PRECISION) };
+        FixedPointCoordinate northeast = { static_cast<int32_t>(max_lat * COORDINATE_PRECISION), static_cast<int32_t>(max_lon * COORDINATE_PRECISION) };
+
+        auto edges = facade->GetEdgesInBox(southwest, northeast);
+
+        xyz(route_parameters.x, route_parameters.y, route_parameters.z, min_lon, min_lat, max_lon, max_lat);
+
+        bbox tile_bbox(min_lon, min_lat, max_lon, max_lat);
+
+        std::string buffer;
+        protozero::pbf_writer tile_writer(buffer);
+        {
+            protozero::pbf_writer layer_writer(tile_writer,3);
+            // TODO: don't write a layer if there are no features
+            layer_writer.add_uint32(15,2); // version
+            layer_writer.add_string(1,"speeds"); // name
+            layer_writer.add_uint32(5,4096); // extent
+
+            std::vector<double> speeds;
+            std::vector<bool> is_smalls;
+            {
+                unsigned id = 1;
+                for (const auto & edge : edges)
+                {
+                    const auto a = facade->GetCoordinateOfNode(edge.u);
+                    const auto b = facade->GetCoordinateOfNode(edge.v);
+                    double length = osrm::util::coordinate_calculation::haversineDistance( a.lon, a.lat, b.lon, b.lat );
+                    if (edge.forward_weight != 0 && edge.forward_edge_based_node_id != SPECIAL_NODEID) {
+                        std::int32_t start_x = 0;
+                        std::int32_t start_y = 0;
+
+                        line_typed geo_line;
+                        geo_line.emplace_back(a.lon / COORDINATE_PRECISION, a.lat / COORDINATE_PRECISION);
+                        geo_line.emplace_back(b.lon / COORDINATE_PRECISION, b.lat / COORDINATE_PRECISION);
+
+                        double speed = round(length / edge.forward_weight * 10 )  * 3.6;
+
+                        speeds.push_back(speed);
+                        is_smalls.push_back(edge.component.is_tiny);
+
+                        line_type tile_line;
+                        for (auto const & pt : geo_line) {
+                            double px_merc = pt.x;
+                            double py_merc = pt.y;
+                            lonlat2merc(px_merc,py_merc);
+                            // convert to integer tile coordinat
+                            std::int64_t px = std::round((px_merc - tile_bbox.minx) * tile_extent/16 / tile_bbox.width());
+                            std::int64_t py = std::round((tile_bbox.maxy - py_merc) * tile_extent/16 / tile_bbox.height());
+                            tile_line.emplace_back(px*tile_extent/256,py*tile_extent/256);
+                        }
+
+                        protozero::pbf_writer feature_writer(layer_writer,2);
+                        feature_writer.add_enum(3,2); // geometry type
+                        feature_writer.add_uint64(1,id++); // id
+                        {
+                            protozero::packed_field_uint32 field(feature_writer, 2);
+                            field.add_element(0); // "speed" tag key offset
+                            field.add_element((speeds.size()-1)*2); // "speed" tag value offset
+                            field.add_element(1); // "is_small" tag key offset
+                            field.add_element((is_smalls.size()-1)*2+1); // "is_small" tag value offset
+                        }
+                        {
+                            protozero::packed_field_uint32 geometry(feature_writer,4);
+                            encode_linestring(tile_line,geometry,start_x,start_y);
+                        }
+                    }
+                    if (edge.reverse_weight != 0 && edge.reverse_edge_based_node_id != SPECIAL_NODEID) {
+                        std::int32_t start_x = 0;
+                        std::int32_t start_y = 0;
+
+                        line_typed geo_line;
+                        geo_line.emplace_back(b.lon / COORDINATE_PRECISION, b.lat / COORDINATE_PRECISION);
+                        geo_line.emplace_back(a.lon / COORDINATE_PRECISION, a.lat / COORDINATE_PRECISION);
+
+                        double speed = round(length / edge.reverse_weight * 10 ) * 3.6;
+
+                        speeds.push_back(speed);
+                        is_smalls.push_back(edge.component.is_tiny);
+
+                        line_type tile_line;
+                        for (auto const & pt : geo_line) {
+                            double px_merc = pt.x;
+                            double py_merc = pt.y;
+                            lonlat2merc(px_merc,py_merc);
+                            // convert to integer tile coordinat
+                            std::int64_t px = std::round((px_merc - tile_bbox.minx) * tile_extent/16 / tile_bbox.width());
+                            std::int64_t py = std::round((tile_bbox.maxy - py_merc) * tile_extent/16 / tile_bbox.height());
+                            tile_line.emplace_back(px*tile_extent/256,py*tile_extent/256);
+                        }
+
+                        protozero::pbf_writer feature_writer(layer_writer,2);
+                        feature_writer.add_enum(3,2); // geometry type
+                        feature_writer.add_uint64(1,id++); // id
+                        {
+                            protozero::packed_field_uint32 field(feature_writer, 2);
+                            field.add_element(0); // "speed" tag key offset
+                            field.add_element((speeds.size()-1)*2); // "speed" tag value offset
+                            field.add_element(1); // "is_small" tag key offset
+                            field.add_element((is_smalls.size()-1)*2+1); // "is_small" tag value offset
+                        }
+                        {
+                            protozero::packed_field_uint32 geometry(feature_writer,4);
+                            encode_linestring(tile_line,geometry,start_x,start_y);
+                        }
+                    }
+
+                }
+            }
+            layer_writer.add_string(3,"speed");
+            layer_writer.add_string(3,"is_small");
+
+            for (size_t i=0; i<speeds.size(); i++) {
+                {
+                    protozero::pbf_writer values_writer(layer_writer,4);
+                    values_writer.add_double(3, speeds[i]);
+                }
+                {
+                    protozero::pbf_writer values_writer(layer_writer,4);
+                    values_writer.add_bool(7, is_smalls[i]);
+                }
+            }
+        }
+
+        json_result.values["pbf"] = buffer;
+
+        return Status::Ok;
+    }
+
+  private:
+    DataFacadeT *facade;
+    std::string descriptor_string;
+};
+}
+}
+}
+
+#endif /* TILEPLUGIN_HPP */

include/engine/route_parameters.hpp

@@ -92,6 +92,10 @@ struct RouteParameters
 
     void SetCoordinatesFromGeometry(const std::string &geometry_string);
 
+    void SetX(const int &x);
+    void SetZ(const int &z);
+    void SetY(const int &y);
+
     short zoom_level;
     bool print_instructions;
     bool alternate_route;
@@ -115,6 +119,9 @@ struct RouteParameters
     std::vector<FixedPointCoordinate> coordinates;
     std::vector<bool> is_destination;
     std::vector<bool> is_source;
+    int z;
+    int x;
+    int y;
 };
 }
 }