Add and use expire_config_t struct

This commit introduces a new struct expire_config_t which collects some
configuration options for expire. All functions that calculate which
tiles to expire from some geometry now get an instance of this struct
as parameter.

Config parameters are:
* `buffer` decides how far around the actual geometries the tiles
  should be expired. This replaces the "tile_expiry_leeway" constant.
  It is always set to 0.1 (= 10% of tile size) as before and can
  currently not be changed.
* `mode` is a new enum setting. It can be "full_area", "boundary_only",
  or "hybrid". Currently always set to "full_area" or "hybrid" based
  on `--expire-bbox-size` for backwards compatibility and can not be
  changed.
* `full_area_limit` used to be a setting "max_bbox" in the expire_tiles
  class. It is set by the `--expire-bbox-size=SIZE` option. It specifies
  the max width and height for a polygon bbox to expire the whole bbox
  of the polygon, not just the boundary (default 20000).

From here on the expire_tiles class is only responsible for actually
keeping a list of expired tiles while the config which tiles are to
be expired is added dynamically when the actual expiry happens. This
will allow us in the future to have different layers with different
expiry options feed into the same expired tile list.

Author: joto

src/expire-config.hpp

@@ -0,0 +1,41 @@
+#ifndef OSM2PGSQL_FLEX_EXPIRE_CONFIG_HPP
+#define OSM2PGSQL_FLEX_EXPIRE_CONFIG_HPP
+
+/**
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ *
+ * This file is part of osm2pgsql (https://osm2pgsql.org/).
+ *
+ * Copyright (C) 2006-2023 by the osm2pgsql developer community.
+ * For a full list of authors see the git log.
+ */
+
+#include <cstdlib>
+
+enum class expire_mode
+{
+    full_area, // Expire all tiles covered by polygon.
+    boundary_only, // Expire only tiles covered by polygon boundary.
+    hybrid // "full_area" or "boundary_only" mode depending on full_area_limit.
+};
+
+/**
+ * These are the options used for tile expiry calculations.
+ */
+struct expire_config_t
+{
+    /// Buffer around expired feature as fraction of the tile size.
+    double buffer = 0.1;
+
+    /**
+     * Maximum width/heigth of bbox of a (multi)polygon before hybrid mode
+     * expiry switches from full-area to boundary-only expire.
+     */
+    double full_area_limit = 0.0;
+
+    /// Expire mode.
+    expire_mode mode = expire_mode::full_area;
+
+}; // struct expire_config_t
+
+#endif // OSM2PGSQL_FLEX_EXPIRE_CONFIG_HPP

src/expire-tiles.cpp

@@ -34,13 +34,10 @@
 #include "tile.hpp"
 #include "wkb.hpp"
 
-// How many tiles worth of space to leave either side of a changed feature
-static constexpr double const tile_expiry_leeway = 0.1;
-
-expire_tiles::expire_tiles(uint32_t max_zoom, double max_bbox,
+expire_tiles::expire_tiles(uint32_t max_zoom,
                            std::shared_ptr<reprojection> projection)
-: m_projection(std::move(projection)), m_max_bbox(max_bbox),
-  m_maxzoom(max_zoom), m_map_width(1U << m_maxzoom)
+: m_projection(std::move(projection)), m_maxzoom(max_zoom),
+  m_map_width(1U << m_maxzoom)
 {}
 
 void expire_tiles::expire_tile(uint32_t x, uint32_t y)
@@ -71,68 +68,93 @@ geom::point_t expire_tiles::coords_to_tile(geom::point_t const &point)
             m_map_width * (0.5 - c.y() / tile_t::earth_circumference)};
 }
 
-void expire_tiles::from_point_list(geom::point_list_t const &list)
+void expire_tiles::from_point_list(geom::point_list_t const &list,
+                                   expire_config_t const &expire_config)
 {
     for_each_segment(list, [&](geom::point_t const &a, geom::point_t const &b) {
-        from_line(a, b);
+        from_line(a, b, expire_config);
     });
 }
 
-void expire_tiles::from_geometry(geom::point_t const &geom)
+void expire_tiles::from_geometry(geom::point_t const &geom,
+                                 expire_config_t const &expire_config)
 {
     geom::box_t const box = geom::envelope(geom);
-    from_bbox(box);
+    from_bbox(box, expire_config);
 }
 
-void expire_tiles::from_geometry(geom::linestring_t const &geom)
+void expire_tiles::from_geometry(geom::linestring_t const &geom,
+                                 expire_config_t const &expire_config)
 {
-    from_point_list(geom);
+    from_point_list(geom, expire_config);
 }
 
-void expire_tiles::from_polygon_boundary(geom::polygon_t const &geom)
+void expire_tiles::from_polygon_boundary(geom::polygon_t const &geom,
+                                         expire_config_t const &expire_config)
 {
-    from_point_list(geom.outer());
+    from_point_list(geom.outer(), expire_config);
     for (auto const &inner : geom.inners()) {
-        from_point_list(inner);
+        from_point_list(inner, expire_config);
     }
 }
 
-void expire_tiles::from_geometry(geom::polygon_t const &geom)
+void expire_tiles::from_geometry(geom::polygon_t const &geom,
+                                 expire_config_t const &expire_config)
 {
+    if (expire_config.mode == expire_mode::boundary_only) {
+        from_polygon_boundary(geom, expire_config);
+        return;
+    }
+
     geom::box_t const box = geom::envelope(geom);
-    if (from_bbox(box)) {
+    if (from_bbox(box, expire_config)) {
         /* Bounding box too big - just expire tiles on the boundary */
-        from_polygon_boundary(geom);
+        from_polygon_boundary(geom, expire_config);
+    }
+}
+
+void expire_tiles::from_polygon_boundary(geom::multipolygon_t const &geom,
+                                         expire_config_t const &expire_config)
+{
+    for (auto const &sgeom : geom) {
+        from_polygon_boundary(sgeom, expire_config);
     }
 }
 
-void expire_tiles::from_geometry(geom::multipolygon_t const &geom)
+void expire_tiles::from_geometry(geom::multipolygon_t const &geom,
+                                 expire_config_t const &expire_config)
 {
+    if (expire_config.mode == expire_mode::boundary_only) {
+        from_polygon_boundary(geom, expire_config);
+        return;
+    }
+
     geom::box_t const box = geom::envelope(geom);
-    if (from_bbox(box)) {
+    if (from_bbox(box, expire_config)) {
         /* Bounding box too big - just expire tiles on the boundary */
-        for (auto const &sgeom : geom) {
-            from_polygon_boundary(sgeom);
-        }
+        from_polygon_boundary(geom, expire_config);
     }
 }
 
-void expire_tiles::from_geometry(geom::geometry_t const &geom)
+void expire_tiles::from_geometry(geom::geometry_t const &geom,
+                                 expire_config_t const &expire_config)
 {
-    geom.visit([&](auto const &g) { from_geometry(g); });
+    geom.visit([&](auto const &g) { from_geometry(g, expire_config); });
 }
 
-void expire_tiles::from_geometry_if_3857(geom::geometry_t const &geom)
+void expire_tiles::from_geometry_if_3857(geom::geometry_t const &geom,
+                                         expire_config_t const &expire_config)
 {
     if (geom.srid() == 3857) {
-        from_geometry(geom);
+        from_geometry(geom, expire_config);
     }
 }
 
 /*
  * Expire tiles that a line crosses
  */
-void expire_tiles::from_line(geom::point_t const &a, geom::point_t const &b)
+void expire_tiles::from_line(geom::point_t const &a, geom::point_t const &b,
+                             expire_config_t const &expire_config)
 {
     auto tilec_a = coords_to_tile(a);
     auto tilec_b = coords_to_tile(b);
@@ -175,11 +197,11 @@ void expire_tiles::from_line(geom::point_t const &a, geom::point_t const &b)
         if (y1 > y2) {
             std::swap(y1, y2);
         }
-        for (int x = x1 - tile_expiry_leeway; x <= x2 + tile_expiry_leeway;
+        for (int x = x1 - expire_config.buffer; x <= x2 + expire_config.buffer;
              ++x) {
             uint32_t const norm_x = normalise_tile_x_coord(x);
-            for (int y = y1 - tile_expiry_leeway; y <= y2 + tile_expiry_leeway;
-                 ++y) {
+            for (int y = y1 - expire_config.buffer;
+                 y <= y2 + expire_config.buffer; ++y) {
                 if (y >= 0) {
                     expire_tile(norm_x, static_cast<uint32_t>(y));
                 }
@@ -191,7 +213,8 @@ void expire_tiles::from_line(geom::point_t const &a, geom::point_t const &b)
 /*
  * Expire tiles within a bounding box
  */
-int expire_tiles::from_bbox(geom::box_t const &box)
+int expire_tiles::from_bbox(geom::box_t const &box,
+                            expire_config_t const &expire_config)
 {
     if (!enabled()) {
         return 0;
@@ -203,28 +226,32 @@ int expire_tiles::from_bbox(geom::box_t const &box)
         /* Over half the planet's width within the bounding box - assume the
            box crosses the international date line and split it into two boxes */
         int ret = from_bbox({-tile_t::half_earth_circumference, box.min_y(),
-                             box.min_x(), box.max_y()});
+                             box.min_x(), box.max_y()},
+                            expire_config);
         ret += from_bbox({box.max_x(), box.min_y(),
-                          tile_t::half_earth_circumference, box.max_y()});
+                          tile_t::half_earth_circumference, box.max_y()},
+                         expire_config);
         return ret;
     }
 
-    if (width > m_max_bbox || height > m_max_bbox) {
+    if (expire_config.mode == expire_mode::hybrid &&
+        (width > expire_config.full_area_limit ||
+         height > expire_config.full_area_limit)) {
         return -1;
     }
 
     /* Convert the box's Mercator coordinates into tile coordinates */
     auto const tmp_min = coords_to_tile({box.min_x(), box.max_y()});
     int const min_tile_x =
-        std::clamp(int(tmp_min.x() - tile_expiry_leeway), 0, m_map_width);
+        std::clamp(int(tmp_min.x() - expire_config.buffer), 0, m_map_width);
     int const min_tile_y =
-        std::clamp(int(tmp_min.y() - tile_expiry_leeway), 0, m_map_width);
+        std::clamp(int(tmp_min.y() - expire_config.buffer), 0, m_map_width);
 
     auto const tmp_max = coords_to_tile({box.max_x(), box.min_y()});
     int const max_tile_x =
-        std::clamp(int(tmp_max.x() + tile_expiry_leeway), 0, m_map_width);
+        std::clamp(int(tmp_max.x() + expire_config.buffer), 0, m_map_width);
     int const max_tile_y =
-        std::clamp(int(tmp_max.y() + tile_expiry_leeway), 0, m_map_width);
+        std::clamp(int(tmp_max.y() + expire_config.buffer), 0, m_map_width);
 
     for (int iterator_x = min_tile_x; iterator_x <= max_tile_x; ++iterator_x) {
         uint32_t const norm_x = normalise_tile_x_coord(iterator_x);
@@ -286,12 +313,13 @@ std::size_t output_tiles_to_file(quadkey_list_t const &tiles_at_maxzoom,
     return count;
 }
 
-int expire_from_result(expire_tiles *expire, pg_result_t const &result)
+int expire_from_result(expire_tiles *expire, pg_result_t const &result,
+                       expire_config_t const &expire_config)
 {
     auto const num_tuples = result.num_tuples();
 
     for (int i = 0; i < num_tuples; ++i) {
-        expire->from_geometry(ewkb_to_geom(result.get(i, 0)));
+        expire->from_geometry(ewkb_to_geom(result.get(i, 0)), expire_config);
     }
 
     return num_tuples;

src/expire-tiles.hpp

@@ -16,6 +16,7 @@
 #include <utility>
 #include <vector>
 
+#include "expire-config.hpp"
 #include "geom.hpp"
 #include "geom-box.hpp"
 #include "logging.hpp"
@@ -28,32 +29,48 @@ class reprojection;
 class expire_tiles
 {
 public:
-    expire_tiles(uint32_t max_zoom, double max_bbox,
-                 std::shared_ptr<reprojection> projection);
+    expire_tiles(uint32_t max_zoom, std::shared_ptr<reprojection> projection);
 
     bool enabled() const noexcept { return m_maxzoom != 0; }
 
-    void from_polygon_boundary(geom::polygon_t const &geom);
+    void from_polygon_boundary(geom::polygon_t const &geom,
+                               expire_config_t const &expire_config);
 
-    void from_geometry(geom::nullgeom_t const & /*geom*/) {}
-    void from_geometry(geom::point_t const &geom);
-    void from_geometry(geom::linestring_t const &geom);
-    void from_geometry(geom::polygon_t const &geom);
-    void from_geometry(geom::multipolygon_t const &geom);
+    void from_polygon_boundary(geom::multipolygon_t const &geom,
+                               expire_config_t const &expire_config);
+
+    void from_geometry(geom::nullgeom_t const & /*geom*/,
+                       expire_config_t const & /*expire_config*/)
+    {}
+
+    void from_geometry(geom::point_t const &geom,
+                       expire_config_t const &expire_config);
+
+    void from_geometry(geom::linestring_t const &geom,
+                       expire_config_t const &expire_config);
+
+    void from_geometry(geom::polygon_t const &geom,
+                       expire_config_t const &expire_config);
+
+    void from_geometry(geom::multipolygon_t const &geom,
+                       expire_config_t const &expire_config);
 
     template <typename T>
-    void from_geometry(geom::multigeometry_t<T> const &geom)
+    void from_geometry(geom::multigeometry_t<T> const &geom,
+                       expire_config_t const &expire_config)
     {
         for (auto const &sgeom : geom) {
-            from_geometry(sgeom);
+            from_geometry(sgeom, expire_config);
         }
     }
 
-    void from_geometry(geom::geometry_t const &geom);
+    void from_geometry(geom::geometry_t const &geom,
+                       expire_config_t const &expire_config);
 
-    void from_geometry_if_3857(geom::geometry_t const &geom);
+    void from_geometry_if_3857(geom::geometry_t const &geom,
+                               expire_config_t const &expire_config);
 
-    int from_bbox(geom::box_t const &box);
+    int from_bbox(geom::box_t const &box, expire_config_t const &expire_config);
 
     /**
      * Get tiles as a vector of quadkeys and remove them from the expire_tiles
@@ -81,10 +98,14 @@ class expire_tiles
      * \param y y index of the tile to be expired.
      */
     void expire_tile(uint32_t x, uint32_t y);
+
     uint32_t normalise_tile_x_coord(int x) const;
-    void from_line(geom::point_t const &a, geom::point_t const &b);
 
-    void from_point_list(geom::point_list_t const &list);
+    void from_line(geom::point_t const &a, geom::point_t const &b,
+                   expire_config_t const &expire_config);
+
+    void from_point_list(geom::point_list_t const &list,
+                         expire_config_t const &expire_config);
 
     /// This is where we collect all the expired tiles.
     std::unordered_set<quadkey_t> m_dirty_tiles;
@@ -94,7 +115,6 @@ class expire_tiles
 
     std::shared_ptr<reprojection> m_projection;
 
-    double m_max_bbox;
     uint32_t m_maxzoom;
     int m_map_width;
 
@@ -107,9 +127,11 @@ class expire_tiles
  * \param result Result of a database query into some table returning the
  *               geometries. (This is usually done using the "get_wkb"
  *               prepared statement.)
+ * \param expire_config Configuration for expiry.
  * \return The number of tuples in the result or -1 if expire is disabled.
  */
-int expire_from_result(expire_tiles *expire, pg_result_t const &result);
+int expire_from_result(expire_tiles *expire, pg_result_t const &result,
+                       expire_config_t const &expire_config);
 
 /**
  * Iterate over tiles and call output function for each tile on all requested