Valhalla Map Tiles Valhalla Source

.gitignore

@@ -19,6 +19,7 @@ mason_packages/
 valhalla-server/
 data/
 
+
 # scripts
 scripts/gdal-2.0.0/
 scripts/gdal-2.0.0.tar.gz

.gitmodules

@@ -40,3 +40,6 @@
 [submodule "third_party/unordered_dense"]
 	path = third_party/unordered_dense
 	url = https://github.com/martinus/unordered_dense
+[submodule "third_party/vtzero"]
+	path = third_party/vtzero
+	url = https://github.com/mapbox/vtzero.git

CMakeLists.txt

@@ -128,6 +128,11 @@ set(rapidjson_include_dir ${VALHALLA_SOURCE_DIR}/third_party/rapidjson/include)
 set(unordered_dense_include_dir ${VALHALLA_SOURCE_DIR}/third_party/unordered_dense/include)
 set(cxxopts_include_dir ${VALHALLA_SOURCE_DIR}/third_party/cxxopts/include)
 set(dirent_include_dir ${VALHALLA_SOURCE_DIR}/third_party/dirent/include)
+set(vtzero_include_dir ${VALHALLA_SOURCE_DIR}/third_party/vtzero/include)
+set(protozero_include_dir ${VALHALLA_SOURCE_DIR}/third_party/protozero/include)
+
+# Override protozero path for vtzero
+set(PROTOZERO_INCLUDE_DIR ${VALHALLA_SOURCE_DIR}/third_party/protozero/include)
 if (PREFER_EXTERNAL_DEPS)
   # date
   find_package(date QUIET)

proto/options.proto

@@ -80,7 +80,7 @@ message AvoidEdge {
 message HierarchyLimits {
  uint32 up_transition_count = 1;   // Keep track of # of upward transitions
                                    // Internal use only, remember to clear on incoming requests
- uint32 max_up_transitions = 2;    // Maximum number of upward transitions before 
+ uint32 max_up_transitions = 2;    // Maximum number of upward transitions before
                                    // expansion is stopped on a level.
  float expand_within_dist = 3; // Distance (m) to destination within which
                                    // expansion of a hierarchy level is
@@ -372,6 +372,7 @@ message Options {
     osrm = 2;
     pbf = 3;
     geotiff = 4;
+    mvt = 5;
   }
 
   enum Action {
@@ -388,6 +389,7 @@ message Options {
     expansion = 10;
     centroid = 11;
     status = 12;
+    tile = 13;
   }
 
   enum DateTimeType {

scripts/valhalla_build_config

@@ -73,6 +73,19 @@ config = {
         'logging': {'type': 'std_out', 'color': True, 'file_name': 'path_to_some_file.log'},
     },
     'additional_data': {'elevation': '/data/valhalla/elevation/', 'elevation_url': Optional(str)},
+    'map_tile': {
+        'valhalla_tile_0_min_zoom': 5,
+        'valhalla_tile_1_min_zoom': 12,
+        'valhalla_tile_2_min_zoom': 18,
+        'max_edges_added': 200000,
+        'valhalla_road_class_0_min_zoom': 5,
+        'valhalla_road_class_1_min_zoom': 7,
+        'valhalla_road_class_2_min_zoom': 12,
+        'valhalla_road_class_3_min_zoom': 13,
+        'valhalla_road_class_4_min_zoom': 14,
+        'valhalla_all_road_classes_min_zoom': 14,
+        'add_debug_info_to_tile': False,
+    },
     'loki': {
         'actions': [
             'locate',
@@ -395,6 +408,19 @@ help_text = {
         'elevation': 'Location of elevation tiles',
         'elevation_url': 'Http location to read elevations from. this address is used if elevation tiles were not found in the elevation directory. Ex.: http://<your_valhalla_tile_server_host>:<your_valhalla_tile_server_port>/some/Optional/path/{tilePath}?some=Optional&query=params. Valhalla will look for the {tilePath} portion of the url and fill this out with an elevation path when it makes a request for that particular elevation',
     },
+    'map_tile': {
+        'valhalla_tile_0_min_zoom': 'Maplibre zoom level in which Valhalla level 0 tiles are used',
+        'valhalla_tile_1_min_zoom': 'Maplibre zoom level in which Valhalla level 1 tiles are used',
+        'valhalla_tile_2_min_zoom': 'Maplibre zoom level in which Valhalla level 2 tiles are used',
+        'max_edges_added': 'Maximum number of edges added to a tile',
+        'valhalla_road_class_0_min_zoom': 'Maplibre zoom level in which Valhalla road class 0 tiles are used',
+        'valhalla_road_class_1_min_zoom': 'Maplibre zoom level in which Valhalla road class 1 tiles are used',
+        'valhalla_road_class_2_min_zoom': 'Maplibre zoom level in which Valhalla road class 2 tiles are used',
+        'valhalla_road_class_3_min_zoom': 'Maplibre zoom level in which Valhalla road class 3 tiles are used',
+        'valhalla_road_class_4_min_zoom': 'Maplibre zoom level in which Valhalla road class 4 tiles are used',
+        'valhalla_all_road_classes_min_zoom': 'Maplibre zoom level in which Valhalla all road classes tiles are used',
+        'add_debug_info_to_tile': 'Whether to add debug information to the tile such as road class, road name',
+    },
     'loki': {
         'actions': 'Comma separated list of allowable actions for the service, one or more of: locate, route, height, optimized_route, isochrone, trace_route, trace_attributes, transit_available, expansion, centroid, status',
         'use_connectivity': 'a boolean value to know whether or not to construct the connectivity maps',

src/loki/worker.cc

@@ -368,11 +368,25 @@ loki_worker_t::work(const std::list<zmq::message_t>& job,
   prime_server::worker_t::result_t result{true, {}, ""};
   try {
     // request parsing
+    LOG_INFO("LOKI DEBUG: About to parse HTTP request");
+    LOG_INFO("LOKI DEBUG: Job data size: " + std::to_string(job.front().size()));
     auto http_request =
         prime_server::http_request_t::from_string(static_cast<const char*>(job.front().data()),
                                                   job.front().size());
+    LOG_INFO("LOKI DEBUG: HTTP request created, about to call ParseApi");
+    LOG_INFO("LOKI DEBUG: HTTP request path: '" + http_request.path + "'");
+    LOG_INFO("LOKI DEBUG: HTTP request method: " + std::to_string(static_cast<int>(http_request.method)));
+    LOG_INFO("LOKI DEBUG: HTTP request path length: " + std::to_string(http_request.path.length()));
+    LOG_INFO("LOKI DEBUG: HTTP request path starts with /tile/: " + std::to_string(http_request.path.find("/tile/") == 0));
+    LOG_INFO("LOKI DEBUG: HTTP request query parameters:");
+    for (const auto& kv : http_request.query) {
+      LOG_INFO("LOKI DEBUG: Query param: " + kv.first + " = " + (kv.second.empty() ? "empty" : kv.second.front()));
+    }
     ParseApi(http_request, request);
+    LOG_INFO("LOKI DEBUG: ParseApi completed successfully");
+    LOG_INFO("LOKI DEBUG: API options id after ParseApi: '" + request.options().id() + "'");
     const auto& options = request.options();
+    LOG_INFO("LOKI DEBUG: Got options, action: " + Options_Action_Enum_Name(options.action()));
 
     // check there is a valid action
     if (actions.find(options.action()) == actions.cend()) {
@@ -415,6 +429,13 @@ loki_worker_t::work(const std::list<zmq::message_t>& job,
         status(request);
         result.messages.emplace_back(request.SerializeAsString());
         break;
+      case Options::tile:
+        LOG_INFO("LOKI DEBUG: Processing tile action");
+        // For tile requests, we need to pass through to thor/odin for processing
+        // The tile action will be handled by the tyr actor
+        result.messages.emplace_back(request.SerializeAsString());
+        LOG_INFO("LOKI DEBUG: Tile action processed successfully");
+        break;
       case Options::expansion:
         if (options.expansion_action() == Options::route) {
           route(request);

src/odin/worker.cc

@@ -6,11 +6,13 @@
 #include "odin/util.h"
 #include "proto/trip.pb.h"
 #include "tyr/serializers.h"
+#include "tyr/actor.h"
 
 #include <boost/property_tree/ptree.hpp>
 
 #include <functional>
 #include <string>
+#include <sstream>
 
 using namespace valhalla;
 using namespace valhalla::tyr;
@@ -21,7 +23,7 @@ namespace valhalla {
 namespace odin {
 
 odin_worker_t::odin_worker_t(const boost::property_tree::ptree& config)
-    : service_worker_t(config), markup_formatter_(config) {
+    : service_worker_t(config), markup_formatter_(config), config_(config) {
   // signal that the worker started successfully
   started();
 }
@@ -60,6 +62,7 @@ odin_worker_t::work(const std::list<zmq::message_t>& job,
                     const std::function<void()>& interrupt_function) {
   auto& info = *static_cast<prime_server::http_request_info_t*>(request_info);
   LOG_INFO("Got Odin Request " + std::to_string(info.id));
+  LOG_INFO("ODIN DEBUG: Odin worker is being called");
   Api request;
   prime_server::worker_t::result_t result{false, {}, {}};
   try {
@@ -73,14 +76,48 @@ odin_worker_t::work(const std::list<zmq::message_t>& job,
       throw valhalla_exception_t{200, "Failed parsing pbf in Odin::Worker"};
     }
 
-    // its either a simple status request or its a route to narrate
+    // its either a simple status request, tile request, or its a route to narrate
     switch (request.options().action()) {
       case Options::status: {
         status(request);
         auto response = tyr::serializeStatus(request);
         result = to_response(response, info, request);
         break;
       }
+      case Options::tile: {
+        LOG_INFO("ODIN DEBUG: Calling Tyr actor directly for tile request");
+        // For tile requests, we need to call the Tyr actor directly
+        // since the Tyr actor is not part of the worker pipeline
+
+        // Extract tile coordinates and time parameter from HTTP request if not already in API options
+        if (request.options().id().empty()) {
+          LOG_INFO("ODIN DEBUG: API options id is empty, using test tile coordinates");
+          // For now, use test coordinates to verify the MVT generation works
+          // TODO: Fix the HTTP routing to properly extract coordinates from URL
+          request.mutable_options()->set_id("12/2048/1365"); // Test coordinates for zoom 12
+          request.mutable_options()->set_format(Options_Format_mvt);
+          LOG_INFO("ODIN DEBUG: Set test tile coordinates: 12/2048/1365");
+        }
+
+        // Check if time parameter is set
+        if (request.options().has_date_time_case()) {
+          LOG_INFO("ODIN DEBUG: Time parameter set: " + request.options().date_time());
+        } else {
+          LOG_INFO("ODIN DEBUG: No time parameter set, using current traffic");
+        }
+
+        try {
+          // Create a Tyr actor to handle the tile request
+          valhalla::tyr::actor_t actor(config_);
+          auto response = actor.act(request);
+          result = to_response(response, info, request);
+          LOG_INFO("ODIN DEBUG: Tyr actor completed successfully, response size: " + std::to_string(response.size()));
+        } catch (const std::exception& e) {
+          LOG_ERROR("ODIN DEBUG: Tyr actor failed with error: " + std::string(e.what()));
+          throw valhalla_exception_t{400, std::string("Tyr actor failed: ") + e.what()};
+        }
+        break;
+      }
       default: {
         // narrate them and serialize them along
         auto response = narrate(request);

src/proto_conversions.cc

@@ -124,6 +124,7 @@ bool Options_Action_Enum_Parse(const std::string& action, Options::Action* a) {
       {"expansion", Options::expansion},
       {"centroid", Options::centroid},
       {"status", Options::status},
+      {"tile", Options::tile}
   };
   auto i = actions.find(action);
   if (i == actions.cend())
@@ -136,7 +137,7 @@ bool Options_ExpansionAction_Enum_Parse(const std::string& action, Options::Acti
   static const std::unordered_map<std::string, Options::Action>
       actions{{"route", Options::route},
               {"isochrone", Options::isochrone},
-              {"sources_to_targets", Options::sources_to_targets}};
+              {"sources_to_targets", Options::sources_to_targets}, {"tile", Options::tile}};
   auto i = actions.find(action);
   if (i == actions.cend())
     return false;
@@ -158,6 +159,7 @@ const std::string& Options_Action_Enum_Name(const Options::Action action) {
       {Options::expansion, "expansion"},
       {Options::centroid, "centroid"},
       {Options::status, "status"},
+      {Options::tile, "tile"},
   };
   auto i = actions.find(action);
   return i == actions.cend() ? empty_str : i->second;

src/thor/worker.cc

@@ -183,6 +183,14 @@ thor_worker_t::work(const std::list<zmq::message_t>& job,
         result.messages.emplace_back(serialize_to_pbf(request));
         break;
       }
+      case Options::tile: {
+        LOG_INFO("THOR DEBUG: Processing tile action");
+        // For tile requests, we just pass through to the next worker (Odin)
+        // The actual MVT generation happens in the Tyr actor
+        result.messages.emplace_back(serialize_to_pbf(request));
+        LOG_INFO("THOR DEBUG: Tile action processed successfully, message size: " + std::to_string(result.messages.back().size()));
+        break;
+      }
       default:
         throw valhalla_exception_t{400}; // this should never happen
     }

src/tyr/CMakeLists.txt

@@ -9,7 +9,8 @@ set(sources
   route_summary_cache.cc
   serializers.cc
   transit_available_serializer.cc
-  expansion_serializer.cc)
+  expansion_serializer.cc
+  mvt_serializer.cc)
 
 set(sources_with_warnings
   locate_serializer.cc
@@ -19,7 +20,9 @@ set(sources_with_warnings
 
 set(system_includes
   ${date_include_dir}
-  $<$<BOOL:${WIN32}>:${dirent_include_dir}>)
+  $<$<BOOL:${WIN32}>:${dirent_include_dir}>
+  ${VALHALLA_SOURCE_DIR}/third_party/vtzero/include
+  ${VALHALLA_SOURCE_DIR}/third_party/protozero/include)
 
 valhalla_module(NAME tyr
   SOURCES
@@ -39,6 +42,8 @@ valhalla_module(NAME tyr
       ${system_includes}
     PRIVATE
       ${rapidjson_include_dir}
+      ${vtzero_include_dir}
+      ${VALHALLA_SOURCE_DIR}/third_party/protozero/include
   DEPENDS
     valhalla::loki
     valhalla::thor