Extends shapes to store bounding boxes

.pkg

@@ -9,7 +9,7 @@
 [geo]
   [email protected]:motis-project/geo.git
   branch=master
-  commit=0a14addf42e91b267906a156c9c2564935c03eaf
+  commit=cee17208dba98f5f3ddaf78d0bfff9c083557ba3
 [utl]
   [email protected]:motis-project/utl.git
   branch=master

include/nigiri/common/interval.h

@@ -47,8 +47,8 @@ struct interval {
       t_ -= x;
       return *this;
     }
-    iterator operator+(difference_type const x) const { return *this += x; }
-    iterator operator-(difference_type const x) const { return *this -= x; }
+    iterator operator+(difference_type const x) const { return {t_ + x}; }
+    iterator operator-(difference_type const x) const { return {t_ - x}; }
     friend difference_type operator-(iterator const& a, iterator const& b) {
       return static_cast<difference_type>(cista::to_idx(a.t_) -
                                           cista::to_idx(b.t_));

include/nigiri/loader/gtfs/shape_prepare.h

@@ -1,18 +1,43 @@
 #pragma once
 
-#include "nigiri/loader/gtfs/shape.h"
+#include "geo/box.h"
+
 #include "nigiri/loader/gtfs/trip.h"
+#include "nigiri/types.h"
 
 namespace nigiri {
+struct shape_loader_state;
 struct shapes_storage;
 struct timetable;
 }  // namespace nigiri
 
 namespace nigiri::loader::gtfs {
 
-void calculate_shape_offsets(timetable const&,
-                             shapes_storage&,
-                             vector_map<gtfs_trip_idx_t, trip> const&,
-                             shape_loader_state const&);
+struct shape_prepare {
+  struct shape_results {
+    struct result {
+      explicit result(stop_seq_t const* stop_seq,
+                      std::vector<double> const* distances);
+      stop_seq_t const* stop_seq_;
+      std::vector<double> const* distances_;
+      shape_offset_idx_t offset_idx_;
+      std::vector<geo::box> boxes_;
+    };
+
+    shape_idx_t shape_idx_;
+    std::vector<result> results_;
+  };
+
+  shape_prepare(shape_loader_state const&,
+                vector_map<gtfs_trip_idx_t, trip> const&,
+                shapes_storage&);
+  void calculate_results(timetable const&, shape_loader_state const&);
+  void write_trip_shape_offsets(vector_map<gtfs_trip_idx_t, trip> const&) const;
+  void write_route_boxes(timetable const&) const;
+  shape_idx_t index_offset_;
+  std::vector<shape_results> shape_results_;
+  shapes_storage& shapes_;
+  bool results_ready_;
+};
 
 }  // namespace nigiri::loader::gtfs

include/nigiri/shapes_storage.h

@@ -1,10 +1,12 @@
 #pragma once
 
 #include <filesystem>
+#include <optional>
 #include <span>
 
 #include "cista/containers/pair.h"
 
+#include "geo/box.h"
 #include "geo/latlng.h"
 
 #include "nigiri/types.h"
@@ -23,6 +25,8 @@ struct shapes_storage {
   shape_offset_idx_t add_offsets(std::vector<shape_offset_t> const&);
   void add_trip_shape_offsets(
       trip_idx_t, cista::pair<shape_idx_t, shape_offset_idx_t> const&);
+  geo::box get_bounding_box(route_idx_t) const;
+  std::optional<geo::box> get_bounding_box(route_idx_t, std::size_t) const;
 
   cista::mmap::protection mode_;
   std::filesystem::path p_;
@@ -31,6 +35,7 @@ struct shapes_storage {
   mm_vecvec<shape_offset_idx_t, shape_offset_t, std::uint64_t> offsets_;
   mm_vec_map<trip_idx_t, cista::pair<shape_idx_t, shape_offset_idx_t>>
       trip_offset_indices_;
+  mm_vecvec<route_idx_t, geo::box, std::uint64_t> boxes_;
 };
 
 }  // namespace nigiri

src/loader/gtfs/load_timetable.cc

@@ -3,6 +3,7 @@
 #include <charconv>
 #include <filesystem>
 #include <numeric>
+#include <optional>
 #include <string>
 
 #include "utl/get_or_create.h"
@@ -261,8 +262,15 @@ void load_timetable(loader_config const& config,
                               {source_file_idx, trp.from_line_, trp.to_line_},
                               train_nr, stop_seq_numbers);
     }
-    if (shapes_data != nullptr) {
-      calculate_shape_offsets(tt, *shapes_data, trip_data.data_, shape_states);
+
+    auto shape_results =
+        (shapes_data == nullptr)
+            ? std::nullopt
+            : std::make_optional(
+                  shape_prepare{shape_states, trip_data.data_, *shapes_data});
+    if (shape_results.has_value()) {
+      shape_results->calculate_results(tt, std::move(shape_states));
+      shape_results->write_trip_shape_offsets(trip_data.data_);
     }
 
     auto const timer = scoped_timer{"loader.gtfs.routes.build"};
@@ -367,6 +375,11 @@ void load_timetable(loader_config const& config,
       progress_tracker->increment();
     }
 
+    // Build bounding boxes
+    if (shape_results.has_value()) {
+      shape_results->write_route_boxes(tt);
+    }
+
     // Build location_routes map
     for (auto l = tt.location_routes_.size(); l != tt.n_locations(); ++l) {
       tt.location_routes_.emplace_back(location_routes[location_idx_t{l}]);