Optionally wrap polygon geometries in multipolygons

When you have an area table in the flex output, you always had to use
the "geometry" column type for the geometry column, because ways are
turned into polygons and multipolygon relations are turned into polygons
or multipolygons. The common type for these is the generic "geometry".

With this change, declaring a geometry column as type "multipolygon" now
works. All polygon geometries are automatically wrapped in a
multipolygon before adding them to the database. Depending on what you
are doing this might be want you want or not. It will make the
geometries larger, but it also makes the data more consistent and so
easier to work with and some software can only handle this consistent
data.

See #1316

Author: joto

src/geom-transform.cpp

@@ -89,46 +89,47 @@ bool geom_transform_area_t::set_param(char const *name, lua_State *lua_state)
 bool geom_transform_area_t::is_compatible_with(
     table_column_type geom_type) const noexcept
 {
-    if (m_multi) {
-        return geom_type == table_column_type::multipolygon ||
-               geom_type == table_column_type::geometry;
-    }
-
     return geom_type == table_column_type::polygon ||
+           geom_type == table_column_type::multipolygon ||
            geom_type == table_column_type::geometry;
 }
 
 geom::osmium_builder_t::wkbs_t
 geom_transform_area_t::run(geom::osmium_builder_t *builder,
-                           table_column_type /*target_geom_type*/,
+                           table_column_type target_geom_type,
                            osmium::Way *way) const
 {
     assert(builder);
     assert(way);
 
+    geom::osmium_builder_t::wkbs_t result;
+
     if (!way->is_closed()) {
-        return {};
+        return result;
     }
 
-    geom::osmium_builder_t::wkbs_t result;
     result.push_back(builder->get_wkb_polygon(*way));
 
     if (result.front().empty()) {
         result.clear();
+    } else if (target_geom_type == table_column_type::multipolygon) {
+        builder->wrap_in_multipolygon(&result);
     }
 
     return result;
 }
 
 geom::osmium_builder_t::wkbs_t
 geom_transform_area_t::run(geom::osmium_builder_t *builder,
-                           table_column_type /*target_geom_type*/,
+                           table_column_type target_geom_type,
                            osmium::Relation const &relation,
                            osmium::memory::Buffer const &buffer) const
 {
     assert(builder);
 
-    return builder->get_wkb_multipolygon(relation, buffer, m_multi);
+    bool const wrap_multi = target_geom_type == table_column_type::multipolygon;
+
+    return builder->get_wkb_multipolygon(relation, buffer, m_multi, wrap_multi);
 }
 
 std::unique_ptr<geom_transform_t> create_geom_transform(char const *type)

src/osmium-builder.cpp

@@ -47,6 +47,26 @@ void add_nodes_to_builder(osmium::builder::WayNodeListBuilder &builder,
 
 namespace geom {
 
+void osmium_builder_t::wrap_in_multipolygon(
+    osmium_builder_t::wkbs_t *geometries)
+{
+    assert(!geometries->empty());
+
+    m_writer.multipolygon_start();
+    for (auto const &p : *geometries) {
+        m_writer.add_sub_geometry(p);
+    }
+    (*geometries)[0] = m_writer.multipolygon_finish(geometries->size());
+    geometries->resize(1);
+}
+
+void osmium_builder_t::wrap_in_multipolygon(osmium_builder_t::wkb_t *geometry)
+{
+    m_writer.multipolygon_start();
+    m_writer.add_sub_geometry(*geometry);
+    *geometry = m_writer.multipolygon_finish(1);
+}
+
 osmium_builder_t::wkb_t
 osmium_builder_t::get_wkb_node(osmium::Location const &loc) const
 {
@@ -145,28 +165,45 @@ osmium_builder_t::get_wkb_polygon(osmium::Way const &way)
 
     auto const wkbs = create_polygons(m_buffer.get<osmium::Area>(0));
 
-    return wkbs.empty() ? wkb_t() : wkbs[0];
+    return wkbs.empty() ? wkb_t{} : wkbs[0];
 }
 
 osmium_builder_t::wkbs_t
 osmium_builder_t::get_wkb_multipolygon(osmium::Relation const &rel,
                                        osmium::memory::Buffer const &ways,
-                                       bool build_multigeoms)
+                                       bool build_multigeoms, bool wrap_multi)
 {
-    wkbs_t ret;
     osmium::area::AssemblerConfig area_config;
     area_config.ignore_invalid_locations = true;
     osmium::area::GeomAssembler assembler{area_config};
 
     m_buffer.clear();
+
+    wkbs_t ret;
     if (assembler(rel, ways, m_buffer)) {
+        auto const &area = m_buffer.get<osmium::Area>(0);
+
+        // This returns a vector of one or more polygons
+        ret = create_polygons(area);
+        assert(!ret.empty());
+
         if (build_multigeoms) {
-            ret.push_back(create_multipolygon(m_buffer.get<osmium::Area>(0)));
+            if (ret.size() > 1) {
+                // wrap all polygons into a single multipolygon
+                wrap_in_multipolygon(&ret);
+            } else if (wrap_multi) {
+                // wrap single polygon into a multipolygon
+                wrap_in_multipolygon(&ret[0]);
+            }
         } else {
-            ret = create_polygons(m_buffer.get<osmium::Area>(0));
+            if (wrap_multi) {
+                for (auto &wkb : ret) {
+                    // wrap each polygon into its own multipolygon
+                    wrap_in_multipolygon(&wkb);
+                }
+            }
         }
     }
-
     return ret;
 }
 
@@ -345,31 +382,6 @@ size_t osmium_builder_t::add_mp_points(osmium::NodeRefList const &nodes)
     return num_points;
 }
 
-osmium_builder_t::wkb_t
-osmium_builder_t::create_multipolygon(osmium::Area const &area)
-{
-    wkb_t ret;
-
-    auto const polys = create_polygons(area);
-
-    switch (polys.size()) {
-    case 0:
-        break; //nothing
-    case 1:
-        ret = polys[0];
-        break;
-    default:
-        m_writer.multipolygon_start();
-        for (auto const &p : polys) {
-            m_writer.add_sub_geometry(p);
-        }
-        ret = m_writer.multipolygon_finish(polys.size());
-        break;
-    }
-
-    return ret;
-}
-
 osmium_builder_t::wkbs_t
 osmium_builder_t::create_polygons(osmium::Area const &area)
 {

src/osmium-builder.hpp

@@ -30,13 +30,24 @@ class osmium_builder_t
 
     wkbs_t get_wkb_multipolygon(osmium::Relation const &rel,
                                 osmium::memory::Buffer const &ways,
-                                bool build_multigeoms);
+                                bool build_multigeoms, bool wrap_multi = false);
 
     wkbs_t get_wkb_multiline(osmium::memory::Buffer const &ways,
                              double split_at);
 
+    /**
+     * Wrap the geometries (must be one or more polygons) in the parameter
+     * into a single multipolygon which is returned in-place in geometries.
+     */
+    void wrap_in_multipolygon(wkbs_t *geometries);
+
+    /**
+     * Wrap the polygon geometry in the parameter into a multipolygon which
+     * is returned in-place in geometry.
+     */
+    void wrap_in_multipolygon(wkb_t *geometry);
+
 private:
-    wkb_t create_multipolygon(osmium::Area const &area);
     wkbs_t create_polygons(osmium::Area const &area);
     size_t add_mp_points(osmium::NodeRefList const &nodes);
 

tests/CMakeLists.txt

@@ -80,6 +80,7 @@ if (HAVE_LUA)
     set_test(test-output-flex-invalid-geom)
     set_test(test-output-flex-line)
     set_test(test-output-flex-lua-fail)
+    set_test(test-output-flex-multigeom)
     set_test(test-output-flex-nodes)
     set_test(test-output-flex-nogeom)
     set_test(test-output-flex-uni)

tests/data/test_output_flex_multigeom.lua

@@ -0,0 +1,32 @@
+
+local polygons = osm2pgsql.define_table{
+    name = 'osm2pgsql_test_polygon',
+    ids = { type = 'area', id_column = 'osm_id' },
+    columns = {
+        { column = 'name', type = 'text' },
+        { column = 'geom', type = test.type }
+    }
+}
+
+function is_empty(some_table)
+    return next(some_table) == nil
+end
+
+function osm2pgsql.process_way(object)
+    if is_empty(object.tags) then
+        return
+    end
+
+    polygons:add_row({
+        name = object.tags.name,
+        geom = { create = 'area' }
+    })
+end
+
+function osm2pgsql.process_relation(object)
+    polygons:add_row({
+        name = object.tags.name,
+        geom = { create = 'area', multi = test.multi }
+    })
+end
+

tests/data/test_output_flex_multigeom.osm

@@ -0,0 +1,51 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<osm version="0.6">
+  <node id="10" lat="0" lon="0"/>
+  <node id="11" lat="0" lon="1"/>
+  <node id="12" lat="1" lon="1"/>
+  <node id="13" lat="1" lon="0"/>
+
+  <node id="14" lat="2" lon="2"/>
+  <node id="15" lat="2" lon="3"/>
+  <node id="16" lat="3" lon="3"/>
+  <node id="17" lat="3" lon="2"/>
+
+  <way id="20">
+    <nd ref="10"/>
+    <nd ref="11"/>
+    <nd ref="12"/>
+    <nd ref="13"/>
+    <nd ref="10"/>
+    <tag k="natural" v="water"/>
+    <tag k="name" v="poly"/>
+  </way>
+
+  <way id="21">
+    <nd ref="10"/>
+    <nd ref="11"/>
+    <nd ref="12"/>
+    <nd ref="13"/>
+    <nd ref="10"/>
+  </way>
+  <way id="22">
+    <nd ref="14"/>
+    <nd ref="15"/>
+    <nd ref="16"/>
+    <nd ref="17"/>
+    <nd ref="14"/>
+  </way>
+
+  <relation id="30">
+    <member type="way" ref="21" role="outer"/>
+    <tag k="type" v="multipolygon"/>
+    <tag k="natural" v="water"/>
+    <tag k="name" v="poly"/>
+  </relation>
+  <relation id="31">
+    <member type="way" ref="21" role="outer"/>
+    <member type="way" ref="22" role="outer"/>
+    <tag k="type" v="multipolygon"/>
+    <tag k="natural" v="water"/>
+    <tag k="name" v="multi"/>
+  </relation>
+</osm>

tests/data/test_output_flex_multigeom_geometry_false.lua

@@ -0,0 +1,5 @@
+
+test = { type = 'geometry', multi = false }
+
+dofile(os.getenv('SRCPATH') .. '/data/test_output_flex_multigeom.lua')
+

tests/data/test_output_flex_multigeom_geometry_true.lua

@@ -0,0 +1,5 @@
+
+test = { type = 'geometry', multi = true }
+
+dofile(os.getenv('SRCPATH') .. '/data/test_output_flex_multigeom.lua')
+

tests/data/test_output_flex_multigeom_multipolygon_false.lua

@@ -0,0 +1,5 @@
+
+test = { type = 'multipolygon', multi = false }
+
+dofile(os.getenv('SRCPATH') .. '/data/test_output_flex_multigeom.lua')
+

tests/data/test_output_flex_multigeom_multipolygon_true.lua

@@ -0,0 +1,5 @@
+
+test = { type = 'multipolygon', multi = true }
+
+dofile(os.getenv('SRCPATH') .. '/data/test_output_flex_multigeom.lua')
+