Enable travis

.travis.yml

@@ -17,6 +17,7 @@ notifications:
 branches:
   only:
     - master
+    - "5.8"
     # enable building tags
     - /^v\d+\.\d+(\.\d+)?(-\S*)?$/
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "osrm",
-  "version": "5.8.0-latest.1",
+  "version": "5.8.0",
   "private": false,
   "description": "The Open Source Routing Machine is a high performance routing engine written in C++14 designed to run on OpenStreetMap data.",
   "dependencies": {

src/engine/plugins/tile.cpp

@@ -831,6 +831,51 @@ void encodeVectorTile(const datafacade::ContiguousInternalMemoryDataFacadeBase &
                 values_writer.add_float(util::vector_tile::VARIANT_TYPE_FLOAT, value);
             }
         }
+
+        // OSM Node tile layer
+        {
+            protozero::pbf_writer point_layer_writer(tile_writer, util::vector_tile::LAYER_TAG);
+            point_layer_writer.add_uint32(util::vector_tile::VERSION_TAG, 2);       // version
+            point_layer_writer.add_string(util::vector_tile::NAME_TAG, "osmnodes"); // name
+            point_layer_writer.add_uint32(util::vector_tile::EXTENT_TAG,
+                                          util::vector_tile::EXTENT); // extent
+
+            std::vector<NodeID> internal_nodes;
+            internal_nodes.reserve(edges.size() * 2);
+            for (const auto &edge : edges)
+            {
+                internal_nodes.push_back(edge.u);
+                internal_nodes.push_back(edge.v);
+            }
+            std::sort(internal_nodes.begin(), internal_nodes.end());
+            auto new_end = std::unique(internal_nodes.begin(), internal_nodes.end());
+            internal_nodes.resize(new_end - internal_nodes.begin());
+
+            for (const auto &internal_node : internal_nodes)
+            {
+                const auto coord = facade.GetCoordinateOfNode(internal_node);
+                const auto tile_point = coordinatesToTilePoint(coord, tile_bbox);
+                if (!boost::geometry::within(point_t(tile_point.x, tile_point.y), clip_box))
+                {
+                    continue;
+                }
+                protozero::pbf_writer feature_writer(point_layer_writer,
+                                                     util::vector_tile::FEATURE_TAG);
+                // Field 3 is the "geometry type" field.  Value 1 is "point"
+                feature_writer.add_enum(util::vector_tile::GEOMETRY_TAG,
+                                        util::vector_tile::GEOMETRY_TYPE_POINT); // geometry type
+                const auto osmid =
+                    static_cast<OSMNodeID::value_type>(facade.GetOSMNodeIDOfNode(internal_node));
+                feature_writer.add_uint64(util::vector_tile::ID_TAG, osmid); // id
+                // There are no additional properties, just the ID and the geometry
+                {
+                    // Add the geometry as the last field in this feature
+                    protozero::packed_field_uint32 geometry(
+                        feature_writer, util::vector_tile::FEATURE_GEOMETRIES_TAG);
+                    encodePoint(tile_point, geometry);
+                }
+            }
+        }
     }
     // protozero serializes data during object destructors, so once the scope closes,
     // our result buffer will have all the tile data encoded into it.

unit_tests/library/tile.cpp

@@ -11,6 +11,7 @@
 #include "osrm/osrm.hpp"
 #include "osrm/status.hpp"
 
+#include "util/typedefs.hpp"
 #include "util/vector_tile.hpp"
 
 #include <protozero/pbf_reader.hpp>
@@ -20,23 +21,38 @@
 
 BOOST_AUTO_TEST_SUITE(tile)
 
-template <typename algorithm> void test_tile(algorithm &osrm)
+void validate_value(protozero::pbf_reader value)
 {
     using namespace osrm;
+    while (value.next())
+    {
+        switch (value.tag())
+        {
+        case util::vector_tile::VARIANT_TYPE_BOOL:
+            value.get_bool();
+            break;
+        case util::vector_tile::VARIANT_TYPE_DOUBLE:
+            value.get_double();
+            break;
+        case util::vector_tile::VARIANT_TYPE_FLOAT:
+            value.get_float();
+            break;
+        case util::vector_tile::VARIANT_TYPE_STRING:
+            value.get_string();
+            break;
+        case util::vector_tile::VARIANT_TYPE_UINT64:
+            value.get_uint64();
+            break;
+        case util::vector_tile::VARIANT_TYPE_SINT64:
+            value.get_sint64();
+            break;
+        }
+    }
+}
 
-    // This tile should contain most of monaco
+void validate_feature_layer(protozero::pbf_reader &layer_message)
-    TileParameters params{17059, 11948, 15};
+{
-
+    using namespace osrm;
-    std::string result;
-    const auto rc = osrm.Tile(params, result);
-    BOOST_CHECK(rc == Status::Ok);
-
-    BOOST_CHECK(result.size() > 114000);
-
-    protozero::pbf_reader tile_message(result);
-    tile_message.next();
-    BOOST_CHECK_EQUAL(tile_message.tag(), util::vector_tile::LAYER_TAG); // must be a layer
-    protozero::pbf_reader layer_message = tile_message.get_message();
 
     const auto check_feature = [](protozero::pbf_reader feature_message) {
         feature_message.next(); // advance parser to first entry
@@ -81,33 +97,6 @@ template <typename algorithm> void test_tile(algorithm &osrm)
         BOOST_CHECK_GT(std::distance(geometry_iter_pair.begin(), geometry_iter_pair.end()), 1);
     };
 
-    const auto check_value = [](protozero::pbf_reader value) {
-        while (value.next())
-        {
-            switch (value.tag())
-            {
-            case util::vector_tile::VARIANT_TYPE_BOOL:
-                value.get_bool();
-                break;
-            case util::vector_tile::VARIANT_TYPE_DOUBLE:
-                value.get_double();
-                break;
-            case util::vector_tile::VARIANT_TYPE_FLOAT:
-                value.get_float();
-                break;
-            case util::vector_tile::VARIANT_TYPE_STRING:
-                value.get_string();
-                break;
-            case util::vector_tile::VARIANT_TYPE_UINT64:
-                value.get_uint64();
-                break;
-            case util::vector_tile::VARIANT_TYPE_SINT64:
-                value.get_sint64();
-                break;
-            }
-        }
-    };
-
     auto number_of_speed_keys = 0u;
     auto number_of_speed_values = 0u;
 
@@ -132,7 +121,7 @@ template <typename algorithm> void test_tile(algorithm &osrm)
             number_of_speed_keys++;
             break;
         case util::vector_tile::VARIANT_TAG:
-            check_value(layer_message.get_message());
+            validate_value(layer_message.get_message());
             number_of_speed_values++;
             break;
         default:
@@ -143,9 +132,11 @@ template <typename algorithm> void test_tile(algorithm &osrm)
 
     BOOST_CHECK_EQUAL(number_of_speed_keys, 7);
     BOOST_CHECK_GT(number_of_speed_values, 128); // speed value resolution
+}
 
-    tile_message.next();
+void validate_turn_layer(protozero::pbf_reader &layer_message)
-    layer_message = tile_message.get_message();
+{
+    using namespace osrm;
 
     const auto check_turn_feature = [](protozero::pbf_reader feature_message) {
         feature_message.next(); // advance parser to first entry
@@ -202,7 +193,7 @@ template <typename algorithm> void test_tile(algorithm &osrm)
             number_of_turn_keys++;
             break;
         case util::vector_tile::VARIANT_TAG:
-            check_value(layer_message.get_message());
+            validate_value(layer_message.get_message());
             break;
         default:
             BOOST_CHECK(false); // invalid tag
@@ -214,11 +205,95 @@ template <typename algorithm> void test_tile(algorithm &osrm)
     BOOST_CHECK(number_of_turns_found > 700);
 }
 
+void validate_node_layer(protozero::pbf_reader &layer_message)
+{
+    using namespace osrm;
+    auto number_of_nodes_found = 0u;
+
+    const auto check_osmnode_feature = [](protozero::pbf_reader feature_message) {
+        feature_message.next(); // advance parser to first entry
+        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::GEOMETRY_TAG);
+        BOOST_CHECK_EQUAL(feature_message.get_enum(), util::vector_tile::GEOMETRY_TYPE_POINT);
+
+        feature_message.next(); // advance to next entry
+        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::ID_TAG);
+        feature_message.get_uint64(); // id
+
+        feature_message.next(); // advance to next entry
+        // Note - on this layer, there should be no feature attributes, the next thing
+        // we get should be the geometry
+        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::FEATURE_GEOMETRIES_TAG);
+        auto geometry_iter_pair = feature_message.get_packed_uint32();
+        BOOST_CHECK_GT(std::distance(geometry_iter_pair.begin(), geometry_iter_pair.end()), 1);
+    };
+
+    while (layer_message.next())
+    {
+        switch (layer_message.tag())
+        {
+        case util::vector_tile::VERSION_TAG:
+            BOOST_CHECK_EQUAL(layer_message.get_uint32(), 2);
+            break;
+        case util::vector_tile::NAME_TAG:
+            BOOST_CHECK_EQUAL(layer_message.get_string(), "osmnodes");
+            break;
+        case util::vector_tile::EXTENT_TAG:
+            BOOST_CHECK_EQUAL(layer_message.get_uint32(), util::vector_tile::EXTENT);
+            break;
+        case util::vector_tile::FEATURE_TAG:
+            check_osmnode_feature(layer_message.get_message());
+            number_of_nodes_found++;
+            break;
+        case util::vector_tile::KEY_TAG:
+            BOOST_CHECK(false); // There should be no properties on node features
+            break;
+        case util::vector_tile::VARIANT_TAG:
+            BOOST_CHECK(false); // There should be no properties on node features
+            break;
+        default:
+            BOOST_CHECK(false); // invalid tag
+            break;
+        }
+    }
+    BOOST_CHECK_EQUAL(number_of_nodes_found, 1791);
+}
+
+void validate_tile(const osrm::OSRM &osrm)
+{
+    using namespace osrm;
+
+    // This tile should contain most of monaco
+    TileParameters params{17059, 11948, 15};
+
+    std::string result;
+    const auto rc = osrm.Tile(params, result);
+    BOOST_CHECK(rc == Status::Ok);
+
+    BOOST_CHECK(result.size() > 114000);
+
+    protozero::pbf_reader tile_message(result);
+
+    tile_message.next();
+    BOOST_CHECK_EQUAL(tile_message.tag(), util::vector_tile::LAYER_TAG); // must be a layer
+    protozero::pbf_reader layer_message = tile_message.get_message();
+    validate_feature_layer(layer_message);
+
+    tile_message.next();
+    BOOST_CHECK_EQUAL(tile_message.tag(), util::vector_tile::LAYER_TAG); // must be a layer
+    layer_message = tile_message.get_message();
+    validate_turn_layer(layer_message);
+
+    tile_message.next();
+    BOOST_CHECK_EQUAL(tile_message.tag(), util::vector_tile::LAYER_TAG); // must be a layer
+    layer_message = tile_message.get_message();
+    validate_node_layer(layer_message);
+}
+
 BOOST_AUTO_TEST_CASE(test_tile_ch)
 {
     using namespace osrm;
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CH);
-    test_tile(osrm);
+    validate_tile(osrm);
 }
 
 BOOST_AUTO_TEST_CASE(test_tile_corech)
@@ -226,17 +301,17 @@ BOOST_AUTO_TEST_CASE(test_tile_corech)
     using namespace osrm;
     auto osrm =
         getOSRM(OSRM_TEST_DATA_DIR "/corech/monaco.osrm", osrm::EngineConfig::Algorithm::CoreCH);
-    test_tile(osrm);
+    validate_tile(osrm);
 }
 
 BOOST_AUTO_TEST_CASE(test_tile_mld)
 {
     using namespace osrm;
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/mld/monaco.osrm", osrm::EngineConfig::Algorithm::MLD);
-    test_tile(osrm);
+    validate_tile(osrm);
 }
 
-template <typename algorithm> void test_tile_turns(algorithm &osrm)
+void test_tile_turns(const osrm::OSRM &osrm)
 {
     using namespace osrm;
 
@@ -423,7 +498,7 @@ BOOST_AUTO_TEST_CASE(test_tile_turns_mld)
     test_tile_turns(osrm);
 }
 
-template <typename algorithm> void test_tile_speeds(algorithm &osrm)
+void test_tile_speeds(const osrm::OSRM &osrm)
 {
     using namespace osrm;
 
@@ -613,4 +688,109 @@ BOOST_AUTO_TEST_CASE(test_tile_speeds_mld)
     test_tile_speeds(osrm);
 }
 
+void test_tile_nodes(const osrm::OSRM &osrm)
+{
+    using namespace osrm;
+
+    // Small tile so we can test all the values
+    // TileParameters params{272953, 191177, 19};
+    // TileParameters params{136477, 95580, 18};
+    // Small tile where we can test all the values
+    TileParameters params{272953, 191177, 19};
+
+    std::string result;
+    const auto rc = osrm.Tile(params, result);
+    BOOST_CHECK(rc == Status::Ok);
+
+    BOOST_CHECK_GT(result.size(), 128);
+
+    protozero::pbf_reader tile_message(result);
+    tile_message.next();
+    BOOST_CHECK_EQUAL(tile_message.tag(), util::vector_tile::LAYER_TAG); // must be a layer
+
+    // Skip the segments and turns layers
+    tile_message.skip();
+    tile_message.next();
+    tile_message.skip();
+
+    // Get the osmnodes layer
+    tile_message.next();
+    protozero::pbf_reader layer_message = tile_message.get_message();
+
+    std::vector<OSMNodeID::value_type> found_node_ids;
+
+    const auto check_feature = [&](protozero::pbf_reader feature_message) {
+        feature_message.next(); // advance parser to first entry
+        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::GEOMETRY_TAG);
+        BOOST_CHECK_EQUAL(feature_message.get_enum(), util::vector_tile::GEOMETRY_TYPE_POINT);
+
+        feature_message.next(); // advance to next entry
+        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::ID_TAG);
+        found_node_ids.push_back(feature_message.get_uint64()); // id
+
+        feature_message.next(); // advance to next entry
+        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::FEATURE_GEOMETRIES_TAG);
+        auto geometry_iter_pair = feature_message.get_packed_uint32();
+        BOOST_CHECK_GT(std::distance(geometry_iter_pair.begin(), geometry_iter_pair.end()), 1);
+    };
+
+    while (layer_message.next())
+    {
+        switch (layer_message.tag())
+        {
+        case util::vector_tile::VERSION_TAG:
+            BOOST_CHECK_EQUAL(layer_message.get_uint32(), 2);
+            break;
+        case util::vector_tile::NAME_TAG:
+            BOOST_CHECK_EQUAL(layer_message.get_string(), "osmnodes");
+            break;
+        case util::vector_tile::EXTENT_TAG:
+            BOOST_CHECK_EQUAL(layer_message.get_uint32(), util::vector_tile::EXTENT);
+            break;
+        case util::vector_tile::FEATURE_TAG:
+            check_feature(layer_message.get_message());
+            break;
+        case util::vector_tile::KEY_TAG:
+            BOOST_CHECK(false); // There should be no keys
+            break;
+        case util::vector_tile::VARIANT_TAG:
+            BOOST_CHECK(false); // There should be no values
+            break;
+        default:
+            BOOST_CHECK(false); // invalid tag
+            break;
+        }
+    }
+
+    std::sort(found_node_ids.begin(), found_node_ids.end());
+    const std::vector<OSMNodeID::value_type> expected_node_ids = {
+        25191722, 25191725, 357300400, 1737389138, 1737389140, 2241375220};
+    BOOST_CHECK(found_node_ids == expected_node_ids);
+}
+
+BOOST_AUTO_TEST_CASE(test_tile_nodes_ch)
+{
+    using namespace osrm;
+
+    auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CH);
+    test_tile_nodes(osrm);
+}
+
+BOOST_AUTO_TEST_CASE(test_tile_nodes_corech)
+{
+    using namespace osrm;
+
+    auto osrm =
+        getOSRM(OSRM_TEST_DATA_DIR "/corech/monaco.osrm", osrm::EngineConfig::Algorithm::CoreCH);
+    test_tile_nodes(osrm);
+}
+
+BOOST_AUTO_TEST_CASE(test_tile_nodes_mld)
+{
+    using namespace osrm;
+
+    auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/mld/monaco.osrm", osrm::EngineConfig::Algorithm::MLD);
+    test_tile_nodes(osrm);
+}
+
 BOOST_AUTO_TEST_SUITE_END()