Add bike elevation profiles

README.md

@@ -131,7 +131,7 @@ The current set of routing profiles can be found in the [`include/osr/routing/pr
 
   - `resolve_start_node(ways::routing, way_idx_t, node_idx_t, level_t, direction, Fn&& f)`: resolves all nodes that belong to this particular (`way_idx_t`, `node_idx_t`, `level_t`, `direction`) combination. `Fn f` will be called with each `node`. It's the task of the profile to give the routing algorithm and entry point to its overlay graph.
   - `resolve_all(ways::routing, node_ix_t, level_t, Fn&& f)`: Same as `resolve_start_node`, just without the condition that `way_idx_t` has to match.
-  - `adjacent<SearcHdir, WithBlocked, Fn>(ways::routing, node, bitvec<node_idx_t> blocked, Fn&& f)`: Calls `Fn f` with each adjacent neighbor of the given `node`. This is used in the shortest path algorithm to expand a node and visit all its neighbors. This takes a runtime provided bit vector `blocked` into account where bit `i` indicates if `i` can be visited or not. This allows us to dynamically block nodes depending on the routing query.
+  - `adjacent<SearcHdir, WithBlocked, Fn>(ways::routing, node, bitvec<node_idx_t>* blocked, sharing_data*, elevation_storage*, Fn&& f)`: Calls `Fn f` with each adjacent neighbor of the given `node`. This is used in the shortest path algorithm to expand a node and visit all its neighbors. This takes a runtime provided bit vector `blocked` into account where bit `i` indicates if `i` can be visited or not. This allows us to dynamically block nodes depending on the routing query.
 
 As we can see, each profile can define its own overlay graph on top of the data model. This gives us the flexibility to define a routing for anything we want from pedestrians or wheelchair users over cars, trucks, trains to ships without any additional memory overhead. Even combined profiles (e.g. walking, taking a bike, walking) can be implemented. Commonly, routing engines have to have a graph for each profile which makes it quite expensive (in terms of memory) to add a new profile on a global routing server. With our approach, a new profile doesn't come with extra costs.
 

exe/backend/include/osr/backend/http_server.h

@@ -5,6 +5,7 @@
 
 #include "boost/asio/io_context.hpp"
 
+#include "osr/elevation_storage.h"
 #include "osr/lookup.h"
 #include "osr/platforms.h"
 #include "osr/ways.h"
@@ -17,6 +18,7 @@ struct http_server {
               ways const&,
               lookup const&,
               platforms const*,
+              elevation_storage const*,
               std::string const& static_file_path);
   ~http_server();
   http_server(http_server const&) = delete;

exe/backend/src/http_server.cc

@@ -76,12 +76,14 @@ struct http_server::impl {
        ways const& g,
        lookup const& l,
        platforms const* pl,
+       elevation_storage const* elevations,
        std::string const& static_file_path)
       : ioc_{ios},
         thread_pool_{thread_pool},
         w_{g},
         l_{l},
         pl_{pl},
+        elevations_{elevations},
         server_{ioc_} {
     try {
       if (!static_file_path.empty() && fs::is_directory(static_file_path)) {
@@ -115,7 +117,8 @@ struct http_server::impl {
     auto const max_it = q.find("max");
     auto const max = static_cast<cost_t>(
         max_it == q.end() ? 3600 : max_it->value().as_int64());
-    auto const p = route(w_, l_, profile, from, to, max, dir, 100);
+    auto const p = route(w_, l_, profile, from, to, max, dir, 100, nullptr,
+                         nullptr, elevations_);
     if (!p.has_value()) {
       cb(json_response(req, "could not find a valid path",
                        http::status::not_found));
@@ -189,7 +192,15 @@ struct http_server::impl {
       case search_profile::kWheelchair:
         send_graph_response<foot<true, elevator_tracking>>(req, cb, gj);
         break;
-      case search_profile::kBike: send_graph_response<bike>(req, cb, gj); break;
+      case search_profile::kBike:
+        send_graph_response<bike<kElevationNoCost>>(req, cb, gj);
+        break;
+      case search_profile::kBikeElevationLow:
+        send_graph_response<bike<kElevationLowCost>>(req, cb, gj);
+        break;
+      case search_profile::kBikeElevationHigh:
+        send_graph_response<bike<kElevationHighCost>>(req, cb, gj);
+        break;
       case search_profile::kCar: send_graph_response<car>(req, cb, gj); break;
       case search_profile::kCarParking:
         send_graph_response<car_parking<false>>(req, cb, gj);
@@ -352,6 +363,7 @@ struct http_server::impl {
   ways const& w_;
   lookup const& l_;
   platforms const* pl_;
+  elevation_storage const* elevations_;
   web_server server_;
   bool serve_static_files_{false};
   std::string static_file_path_;
@@ -362,8 +374,10 @@ http_server::http_server(boost::asio::io_context& ioc,
                          ways const& w,
                          lookup const& l,
                          platforms const* pl,
+                         elevation_storage const* elevation,
                          std::string const& static_file_path)
-    : impl_(new impl(ioc, thread_pool, w, l, pl, static_file_path)) {}
+    : impl_(new impl(ioc, thread_pool, w, l, pl, elevation, static_file_path)) {
+}
 
 http_server::~http_server() = default;
 

exe/backend/src/main.cc

@@ -13,6 +13,7 @@
 #include "net/stop_handler.h"
 
 #include "osr/backend/http_server.h"
+#include "osr/elevation_storage.h"
 #include "osr/lookup.h"
 #include "osr/platforms.h"
 #include "osr/ways.h"
@@ -89,12 +90,14 @@ int main(int argc, char const* argv[]) {
   if (pl != nullptr) {
     pl->build_rtree(w);
   }
+  auto const elevations = elevation_storage::try_open(opt.data_dir_);
 
   auto const l = lookup{w, opt.data_dir_, cista::mmap::protection::READ};
 
   auto ioc = boost::asio::io_context{};
   auto pool = boost::asio::io_context{};
-  auto server = http_server{ioc, pool, w, l, pl.get(), opt.static_file_path_};
+  auto server = http_server{
+      ioc, pool, w, l, pl.get(), elevations.get(), opt.static_file_path_};
 
   auto work_guard = boost::asio::make_work_guard(pool);
   auto threads = std::vector<std::thread>(std::max(1U, opt.threads_));

exe/benchmark.cc

@@ -16,6 +16,7 @@
 
 #include "utl/timer.h"
 
+#include "osr/elevation_storage.h"
 #include "osr/lookup.h"
 #include "osr/routing/dijkstra.h"
 #include "osr/routing/profile.h"
@@ -124,6 +125,7 @@ int main(int argc, char const* argv[]) {
   }
 
   auto const w = ways{opt.data_dir_, cista::mmap::protection::READ};
+  auto const elevations = elevation_storage::try_open(opt.data_dir_);
 
   auto threads = std::vector<std::thread>(std::max(1U, opt.threads_));
   auto results = std::vector<benchmark_result>{};
@@ -144,8 +146,8 @@ int main(int argc, char const* argv[]) {
               node_idx_t{cista::hash_combine(h, ++n, i.load()) % w.n_nodes()};
           d.reset(opt.max_dist_);
           set_start<T>(d, w, start);
-          d.template run<direction::kForward, false>(w, *w.r_, opt.max_dist_,
-                                                     nullptr, nullptr);
+          d.template run<direction::kForward, false>(
+              w, *w.r_, opt.max_dist_, nullptr, nullptr, elevations.get());
           auto const end_time = std::chrono::steady_clock::now();
           {
             auto const guard = std::lock_guard{m};
@@ -168,5 +170,8 @@ int main(int argc, char const* argv[]) {
   };
 
   run_benchmark.template operator()<car>("car");
-  run_benchmark.template operator()<bike>("bike");
+  run_benchmark.template operator()<bike<kElevationNoCost>>(
+      "bike (no elevation costs)");
+  run_benchmark.template operator()<bike<kElevationHighCost>>(
+      "bike (high elevation costs)");
 }

exe/extract.cc

@@ -18,10 +18,11 @@ struct config : public conf::configuration {
       : configuration{"Options"}, in_{std::move(in)}, out_{std::move(out)} {
     param(in_, "in,i", "OpenStreetMap .osm.pbf input path");
     param(out_, "out,o", "output directory");
+    param(elevation_data_, "elevation_data,e", "directory with elevation data");
     param(with_platforms_, "with_platforms,p", "extract platform info");
   }
 
-  std::filesystem::path in_, out_;
+  std::filesystem::path in_, out_, elevation_data_;
   bool with_platforms_{false};
 };
 
@@ -44,5 +45,5 @@ int main(int ac, char const** av) {
   utl::activate_progress_tracker("osr");
   auto const silencer = utl::global_progress_bars{false};
 
-  extract(c.with_platforms_, c.in_, c.out_);
+  extract(c.with_platforms_, c.in_, c.out_, c.elevation_data_);
 }

include/osr/elevation_storage.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <cstdint>
+#include <filesystem>
+#include <memory>
+
+#include "cista/mmap.h"
+
+#include "osr/types.h"
+#include "osr/ways.h"
+
+namespace osr {
+
+constexpr elevation_t NO_ELEVATION_DATA = -32767;
+
+namespace preprocessing::elevation {
+struct provider;
+}
+
+struct elevation_storage {
+  struct elevation {
+    elevation& operator+=(elevation const&);
+    elevation swap() const;
+    elevation_t up_;
+    elevation_t down_;
+  };
+  struct encoding {
+    using coding = std::uint8_t;
+    explicit encoding(elevation const&);
+    encoding() = default;
+    elevation decode() const;
+    explicit operator bool() const;
+    coding up_ : 4 {};
+    coding down_ : 4 {};
+  };
+  elevation_storage(std::filesystem::path const&,
+                    cista::mmap::protection const mode);
+  static std::unique_ptr<elevation_storage> try_open(
+      std::filesystem::path const&);
+  void set_elevations(ways const&, preprocessing::elevation::provider const&);
+  elevation get_elevations(way_idx_t const way,
+                           std::uint16_t const segment) const;
+
+  mm_paged_vecvec<way_idx_t, encoding> elevations_;
+};
+
+elevation_storage::elevation get_elevations(elevation_storage const*,
+                                            way_idx_t const way,
+                                            std::uint16_t const segment);
+
+}  // namespace osr

include/osr/extract/extract.h

@@ -4,6 +4,7 @@ namespace osr {
 
 void extract(bool with_platforms,
              std::filesystem::path const& in,
-             std::filesystem::path const& out);
+             std::filesystem::path const& out,
+             std::filesystem::path const& elevation_dir);
 
 }  // namespace osr

include/osr/point.h

@@ -23,6 +23,10 @@ struct point {
     return {l.x(), l.y()};
   }
 
+  static point from_latlng(double lat, double lng) {
+    return from_location(osmium::Location(lng, lat));
+  }
+
   osmium::Location as_location() const { return osmium::Location{lat_, lng_}; }
 
   geo::latlng as_latlng() const {

include/osr/preprocessing/elevation/dem_driver.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <vector>
+
+#include "cista/containers/rtree.h"
+
+#include "osr/point.h"
+#include "osr/preprocessing/elevation/dem_tile.h"
+#include "osr/preprocessing/elevation/step_size.h"
+#include "osr/types.h"
+
+namespace fs = std::filesystem;
+
+namespace osr::preprocessing::elevation {
+
+struct dem_driver {
+  dem_driver() = default;
+  bool add_tile(fs::path const&);
+  ::osr::elevation_t get(::osr::point const&) const;
+  step_size get_step_size() const;
+  elevation_tile_idx_t get_tile_idx(point const&) const;
+  std::size_t n_tiles() const;
+
+  cista::raw::rtree<std::size_t> rtree_{};
+  std::vector<dem_tile> tiles_{};
+};
+
+}  // namespace osr::preprocessing::elevation

include/osr/preprocessing/elevation/dem_tile.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <cstdint>
+#include <filesystem>
+#include <memory>
+
+#include "osr/point.h"
+#include "osr/preprocessing/elevation/shared.h"
+#include "osr/preprocessing/elevation/step_size.h"
+#include "osr/types.h"
+
+namespace fs = std::filesystem;
+
+namespace osr::preprocessing::elevation {
+
+enum class pixel_type : std::uint8_t { int16, float32 };
+
+union pixel_value {
+  std::int16_t int16_;
+  float float32_;
+};
+
+struct dem_tile {
+  explicit dem_tile(fs::path const& filename);
+  ~dem_tile();
+  dem_tile(dem_tile&& grid) noexcept;
+  dem_tile(dem_tile const&) = delete;
+  dem_tile& operator=(dem_tile const&) = delete;
+  dem_tile& operator=(dem_tile&&) = delete;
+
+  ::osr::elevation_t get(::osr::point const&) const;
+  coord_box get_coord_box() const;
+
+  pixel_value get_raw(::osr::point const&) const;
+  pixel_type get_pixel_type() const;
+  step_size get_step_size() const;
+
+private:
+  struct impl;
+  std::unique_ptr<impl> impl_;
+};
+
+}  // namespace osr::preprocessing::elevation

include/osr/preprocessing/elevation/hgt_driver.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <optional>
+#include <variant>
+#include <vector>
+
+#include "cista/containers/rtree.h"
+
+#include "osr/point.h"
+#include "osr/preprocessing/elevation/hgt_tile.h"
+#include "osr/preprocessing/elevation/shared.h"
+#include "osr/preprocessing/elevation/step_size.h"
+#include "osr/types.h"
+
+namespace fs = std::filesystem;
+
+namespace osr::preprocessing::elevation {
+
+static_assert(IsTile<hgt_tile<3601>>);
+static_assert(IsTile<hgt_tile<1201>>);
+
+struct hgt_driver {
+  using hgt_tile_t = std::variant<hgt_tile<3601>, hgt_tile<1201>>;
+
+  hgt_driver() = default;
+  bool add_tile(fs::path const&);
+  ::osr::elevation_t get(::osr::point const&) const;
+  step_size get_step_size() const;
+  elevation_tile_idx_t get_tile_idx(::osr::point const&) const;
+  std::size_t n_tiles() const;
+  static std::optional<hgt_tile_t> open(fs::path const&);
+
+  cista::raw::rtree<std::size_t> rtree_;
+  std::vector<hgt_tile_t> tiles_;
+};
+
+}  // namespace osr::preprocessing::elevation

include/osr/preprocessing/elevation/hgt_tile.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <string>
+
+#include "osr/point.h"
+#include "osr/preprocessing/elevation/shared.h"
+#include "osr/preprocessing/elevation/step_size.h"
+#include "osr/types.h"
+
+namespace osr::preprocessing::elevation {
+
+template <std::size_t RasterSize>
+struct hgt_tile {
+  constexpr static auto const kBytesPerPixel = std::size_t{2U};
+
+  explicit hgt_tile(std::string const& filename,
+                    std::int8_t const lat,
+                    std::int16_t const lng);
+  ~hgt_tile();
+  hgt_tile(hgt_tile&& grid) noexcept;
+  hgt_tile(hgt_tile const&) = delete;
+  hgt_tile& operator=(hgt_tile const&) = delete;
+  hgt_tile& operator=(hgt_tile&&) = delete;
+
+  ::osr::elevation_t get(::osr::point const&) const;
+
+  step_size get_step_size() const;
+
+  coord_box get_coord_box() const;
+
+  static constexpr std::size_t file_size() {
+    return RasterSize * RasterSize * kBytesPerPixel;
+  }
+
+private:
+  struct impl;
+  std::unique_ptr<impl> impl_;
+};
+
+extern template struct hgt_tile<3601U>;
+extern template struct hgt_tile<1201U>;
+
+}  // namespace osr::preprocessing::elevation