Merge pull request #1743 from joto/geom-more-details

Some more work in the geometries

Author: lonvia

src/flex-lua-geom.cpp

@@ -119,6 +119,20 @@ static int geom_is_null(lua_State *lua_state)
     return 1;
 }
 
+static int geom_line_merge(lua_State *lua_state)
+{
+    auto const *const input_geometry = unpack_geometry(lua_state);
+
+    try {
+        auto *geom = create_lua_geometry_object(lua_state);
+        geom::line_merge(geom, *input_geometry);
+    } catch (...) {
+        return luaL_error(lua_state, "Unknown error in 'line_merge()'.\n");
+    }
+
+    return 1;
+}
+
 static int geom_num_geometries(lua_State *lua_state)
 {
     auto const *const input_geometry = unpack_geometry(lua_state);
@@ -215,6 +229,7 @@ void init_geometry_class(lua_State *lua_state)
     luaX_add_table_func(lua_state, "geometry_n", geom_geometry_n);
     luaX_add_table_func(lua_state, "geometry_type", geom_geometry_type);
     luaX_add_table_func(lua_state, "is_null", geom_is_null);
+    luaX_add_table_func(lua_state, "line_merge", geom_line_merge);
     luaX_add_table_func(lua_state, "num_geometries", geom_num_geometries);
     luaX_add_table_func(lua_state, "segmentize", geom_segmentize);
     luaX_add_table_func(lua_state, "simplify", geom_simplify);

src/geom-from-osm.cpp

@@ -96,27 +96,37 @@ geometry_t create_polygon(osmium::Way const &way)
 }
 
 void create_multilinestring(geometry_t *geom,
-                            osmium::memory::Buffer const &ways)
+                            osmium::memory::Buffer const &ways_buffer,
+                            bool force_multi)
 {
-    auto &mls = geom->set<multilinestring_t>();
-
-    for (auto const &way : ways.select<osmium::Way>()) {
-        linestring_t line;
+    auto ways = ways_buffer.select<osmium::Way>();
+    if (ways.size() == 1 && !force_multi) {
+        auto &line = geom->set<linestring_t>();
+        auto &way = *ways.begin();
         fill_point_list(&line, way.nodes());
-        if (line.size() >= 2U) {
-            mls.add_geometry(std::move(line));
+        if (line.size() < 2U) {
+            geom->reset();
+        }
+    } else {
+        auto &multiline = geom->set<multilinestring_t>();
+        for (auto const &way : ways) {
+            linestring_t line;
+            fill_point_list(&line, way.nodes());
+            if (line.size() >= 2U) {
+                multiline.add_geometry(std::move(line));
+            }
+        }
+        if (multiline.num_geometries() == 0) {
+            geom->reset();
         }
-    }
-
-    if (mls.num_geometries() == 0) {
-        geom->reset();
     }
 }
 
-geometry_t create_multilinestring(osmium::memory::Buffer const &ways)
+geometry_t create_multilinestring(osmium::memory::Buffer const &ways,
+                                  bool force_multi)
 {
     geometry_t geom{};
-    create_multilinestring(&geom, ways);
+    create_multilinestring(&geom, ways, force_multi);
     return geom;
 }
 

src/geom-from-osm.hpp

@@ -101,7 +101,8 @@ void create_polygon(geometry_t *geom, osmium::Way const &way);
  * \param ways Buffer containing all the input ways.
  */
 void create_multilinestring(geometry_t *geom,
-                            osmium::memory::Buffer const &ways);
+                            osmium::memory::Buffer const &ways,
+                            bool force_multi = true);
 
 /**
  * Create a multilinestring geometry from a bunch of ways (usually this
@@ -115,7 +116,8 @@ void create_multilinestring(geometry_t *geom,
  * \returns The created geometry.
  */
 [[nodiscard]] geometry_t
-create_multilinestring(osmium::memory::Buffer const &ways);
+create_multilinestring(osmium::memory::Buffer const &ways,
+                       bool force_multi = true);
 
 /**
  * Create a (multi)polygon geometry from a relation and member ways.

src/geom-functions.cpp

@@ -448,6 +448,11 @@ static void add_nodes_to_linestring(linestring_t *linestring, ITERATOR it,
 
 void line_merge(geometry_t *output, geometry_t const &input)
 {
+    if (input.is_linestring()) {
+        *output = input;
+        return;
+    }
+
     if (!input.is_multilinestring()) {
         output->reset();
         return;

src/geom-functions.hpp

@@ -159,19 +159,23 @@ double area(geometry_t const &geom);
 std::vector<geometry_t> split_multi(geometry_t &&geom, bool split_multi = true);
 
 /**
- * Merge lines in a multilinestring end-to-end as far as possible. Always
- * returns a multilinestring unless there is an error or the input geometry
- * is a nullgeom_t, in which case nullgeom_t is returned.
+ * Merge lines in a multilinestring end-to-end as far as possible.
+ *
+ * * Returns a multilinestring if the input is a multilinestring.
+ * * Returns a copy of the input if it is a linestring.
+ * * Returns nullgeom_t otherwise.
  *
  * \param output Pointer to output geometry.
  * \param input Input geometry.
  */
 void line_merge(geometry_t *output, geometry_t const &input);
 
 /**
- * Merge lines in a multilinestring end-to-end as far as possible. Always
- * returns a multilinestring unless there is an error or the input geometry
- * is a nullgeom_t, in which case nullgeom_t is returned.
+ * Merge lines in a multilinestring end-to-end as far as possible.
+ *
+ * * Returns a multilinestring if the input is a multilinestring.
+ * * Returns a copy of the input if it is a linestring.
+ * * Returns nullgeom_t otherwise.
  *
  * \param input Input geometry.
  * \returns Result multilinestring.

src/output-flex.cpp

@@ -885,23 +885,43 @@ int output_flex_t::app_as_polygon()
 
 int output_flex_t::app_as_multilinestring()
 {
-    check_context_and_state("as_multilinestring", "process_relation() function",
-                            m_calling_context !=
-                                calling_context::process_relation);
+    check_context_and_state(
+        "as_multilinestring", "process_way/relation() functions",
+        m_calling_context != calling_context::process_way &&
+            m_calling_context != calling_context::process_relation);
+
+    if (m_calling_context == calling_context::process_way) {
+        m_way_cache.add_nodes(middle());
+
+        auto *geom = create_lua_geometry_object(lua_state());
+        geom::create_linestring(geom, m_way_cache.get());
+        return 1;
+    }
 
     m_relation_cache.add_members(middle());
 
     auto *geom = create_lua_geometry_object(lua_state());
-    geom::create_multilinestring(geom, m_relation_cache.members_buffer());
+    geom::create_multilinestring(geom, m_relation_cache.members_buffer(),
+                                 false);
 
     return 1;
 }
 
 int output_flex_t::app_as_multipolygon()
 {
-    check_context_and_state("as_multipolygon", "process_relation() function",
-                            m_calling_context !=
-                                calling_context::process_relation);
+    check_context_and_state(
+        "as_multipolygon", "process_way/relation() functions",
+        m_calling_context != calling_context::process_way &&
+            m_calling_context != calling_context::process_relation);
+
+    if (m_calling_context == calling_context::process_way) {
+        m_way_cache.add_nodes(middle());
+
+        auto *geom = create_lua_geometry_object(lua_state());
+        geom::create_polygon(geom, m_way_cache.get());
+
+        return 1;
+    }
 
     m_relation_cache.add_members(middle());
 

tests/bdd/flex/geometry-multilinestring.feature

@@ -0,0 +1,83 @@
+Feature: Creating (multi)linestring features from way and relations
+
+    Scenario:
+        Given the grid
+            | 1 | 2 |   |
+            | 4 |   | 3 |
+            |   | 5 | 6 |
+        And the OSM data
+            """
+            w20 Thighway=motorway Nn1,n2,n3
+            w21 Thighway=motorway Nn4,n5,n6
+            r30 Ttype=route,route=road Mw20@
+            r31 Ttype=route,route=road Mw20@,w21@
+            """
+        And the lua style
+            """
+            local lines = osm2pgsql.define_table({
+                name = 'osm2pgsql_test_lines',
+                ids = { type = 'any', id_column = 'osm_id', type_column = 'osm_type' },
+                columns = {
+                    { column = 'geom', type = 'geometry', projection = 4326 },
+                }
+            })
+
+            function osm2pgsql.process_way(object)
+                if object.tags.highway == 'motorway' then
+                    lines:insert({
+                        geom = object:as_multilinestring()
+                    })
+                end
+            end
+
+            function osm2pgsql.process_relation(object)
+                if object.tags.type == 'route' then
+                    lines:insert({
+                        geom = object:as_multilinestring()
+                    })
+                end
+            end
+            """
+        When running osm2pgsql flex
+
+        Then table osm2pgsql_test_lines contains exactly
+            | osm_type | osm_id | ST_GeometryType(geom) | ST_AsText(ST_GeometryN(geom, 1)) | ST_AsText(ST_GeometryN(geom, 2)) |
+            | W        | 20     | ST_LineString         | 1, 2, 3                          | NULL                             |
+            | W        | 21     | ST_LineString         | 4, 5, 6                          | NULL                             |
+            | R        | 30     | ST_LineString         | 1, 2, 3                          | NULL                             |
+            | R        | 31     | ST_MultiLineString    | 1, 2, 3                          | 4, 5, 6                          |
+
+    Scenario:
+        Given the grid
+            | 1 | 2 |   |   |
+            |   |   | 3 | 4 |
+        And the OSM data
+            """
+            w20 Thighway=motorway Nn1,n2
+            w21 Thighway=motorway Nn2,n3
+            w22 Thighway=motorway Nn3,n4
+            r30 Ttype=route,route=road Mw20@,w21@
+            r31 Ttype=route,route=road Mw20@,w22@
+            """
+        And the lua style
+            """
+            local roads = osm2pgsql.define_relation_table('osm2pgsql_test_roads', {
+                { column = 'geom', type = 'geometry', projection = 4326 },
+                { column = 'merged', type = 'geometry', projection = 4326 }
+            })
+
+            function osm2pgsql.process_relation(object)
+                local g = object:as_multilinestring()
+                roads:insert({
+                    geom = g,
+                    merged = g:line_merge()
+                })
+            end
+            """
+        When running osm2pgsql flex
+
+        Then table osm2pgsql_test_roads contains exactly
+            | relation_id | ST_GeometryType(geom) | ST_GeometryType(merged) | ST_AsText(ST_GeometryN(merged, 1)) | ST_AsText(ST_GeometryN(merged, 2)) |
+            | 30          | ST_MultiLineString    | ST_MultiLineString      | 1, 2, 3                            | NULL                               |
+            | 31          | ST_MultiLineString    | ST_MultiLineString      | 1, 2                               | 3, 4                               |
+

tests/bdd/flex/geometry-processing.feature

@@ -74,7 +74,7 @@ Feature: Tests for Lua geometry processing functions
                     geomsimple = object:as_linestring():simplify(0.1)
                 })
 
-                local g = object:as_polygon()
+                local g = object:as_multipolygon()
                 tables.polygons:insert({
                     name = object.tags.name,
                     geom = g,

tests/test-geom-multilinestrings.cpp

@@ -36,6 +36,26 @@ TEST_CASE("create_multilinestring with single line", "[NoDB]")
     REQUIRE(ml[0] == expected);
 }
 
+TEST_CASE("create_multilinestring with single line and no force_multi",
+          "[NoDB]")
+{
+    geom::linestring_t const expected{{1, 1}, {2, 1}};
+
+    test_buffer_t buffer;
+    buffer.add_way("w20 Nn10x1y1,n11x2y1");
+
+    auto const geom =
+        geom::line_merge(geom::create_multilinestring(buffer.buffer(), false));
+
+    REQUIRE(geom.is_linestring());
+    REQUIRE(geometry_type(geom) == "LINESTRING");
+    REQUIRE(num_geometries(geom) == 1);
+    REQUIRE(area(geom) == Approx(0.0));
+    auto const &l = geom.get<geom::linestring_t>();
+    REQUIRE(l.num_geometries() == 1);
+    REQUIRE(l == expected);
+}
+
 TEST_CASE("create_multilinestring with single line forming a ring", "[NoDB]")
 {
     geom::linestring_t const expected{{1, 1}, {2, 1}, {2, 2}, {1, 1}};