Flex: Allow creating point geometry from way

Ways can have a single node (or multiple nodes at the same location) in
which case we can't build a proper linestring. This doesn't happen very
often and is always an error in the data. This adds the functionality to
flex Lua code to run as_point() on a way geometry which creates a point
geometry from the first node.

This is mostly intended for the use case where we want to create a point
from invalid ways to help fix them. It can also be used if you just need
any point in that linestring for a rough position or so.

Author: joto

src/geom-from-osm.cpp

@@ -19,11 +19,18 @@
 
 namespace geom {
 
+void create_point(geometry_t *geom, osmium::Location const &location)
+{
+    if (location.valid()) {
+        auto &point = geom->set<point_t>();
+        point.set_x(location.lon());
+        point.set_y(location.lat());
+    }
+}
+
 void create_point(geometry_t *geom, osmium::Node const &node)
 {
-    auto &point = geom->set<point_t>();
-    point.set_x(node.location().lon());
-    point.set_y(node.location().lat());
+    create_point(geom, node.location());
 }
 
 geometry_t create_point(osmium::Node const &node)

src/geom-from-osm.hpp

@@ -27,6 +27,15 @@
 
 namespace geom {
 
+/**
+ * Create a point geometry from a location. If the location is not valid,
+ * the output will not be changed.
+ *
+ * \param geom Pointer to an existing geometry which will be used as output.
+ * \param location The input location.
+ */
+void create_point(geometry_t *geom, osmium::Location const &location);
+
 /**
  * Create a point geometry from a node.
  *

src/output-flex.cpp

@@ -454,12 +454,24 @@ int output_flex_t::app_get_bbox()
 
 int output_flex_t::app_as_point()
 {
-    check_context_and_state("as_point", "node",
-                            m_calling_context != calling_context::process_node);
+    check_context_and_state(
+        "as_point", "node/way",
+        m_calling_context != calling_context::process_node &&
+            m_calling_context != calling_context::process_way);
 
     auto *geom = create_lua_geometry_object(lua_state());
-    geom::create_point(geom, *m_context_node);
 
+    if (m_calling_context == calling_context::process_node) {
+        geom::create_point(geom, *m_context_node);
+        return 1;
+    }
+
+    m_way_cache.add_nodes(middle());
+
+    auto const &nodes = m_way_cache.get().nodes();
+    if (!nodes.empty()) {
+        geom::create_point(geom, nodes[0].location());
+    }
     return 1;
 }
 

tests/bdd/flex/geometry-linestring.feature

@@ -16,14 +16,16 @@ Feature: Creating linestring features from way
                 { column = 'sgeom', type = 'linestring', projection = 4326 },
                 { column = 'mgeom', type = 'multilinestring', projection = 4326 },
                 { column = 'xgeom', type = 'multilinestring', projection = 4326 },
+                { column = 'pgeom', type = 'point', projection = 4326 },
             })
 
             function osm2pgsql.process_way(object)
                 if object.tags.highway == 'motorway' then
                     lines:insert({
                         sgeom = object:as_linestring(),
                         mgeom = object:as_multilinestring(),
-                        xgeom = object:as_linestring()
+                        xgeom = object:as_linestring(),
+                        pgeom = object:as_point(),
                     })
                 end
             end
@@ -32,9 +34,9 @@ Feature: Creating linestring features from way
         When running osm2pgsql flex
 
         Then table osm2pgsql_test_lines contains exactly
-            | way_id | ST_AsText(sgeom) | ST_AsText(mgeom) | ST_AsText(xgeom) |
-            | 20     | 1, 2, 3          | [ 1, 2, 3 ]      | [ 1, 2, 3 ]      |
-            | 21     | 4, 5             | [ 4, 5 ]         | [ 4, 5 ]         |
+            | way_id | ST_AsText(sgeom) | ST_AsText(mgeom) | ST_AsText(xgeom) | ST_AsText(pgeom) |
+            | 20     | 1, 2, 3          | [ 1, 2, 3 ]      | [ 1, 2, 3 ]      | 1                |
+            | 21     | 4, 5             | [ 4, 5 ]         | [ 4, 5 ]         | 4                |
 
     Scenario:
         Given the grid

tests/test-geom-linestrings.cpp

@@ -115,6 +115,50 @@ TEST_CASE("create_linestring from invalid OSM data", "[NoDB]")
     REQUIRE(geom.is_null());
 }
 
+TEST_CASE("create_point from OSM way data", "[NoDB]")
+{
+    test_buffer_t buffer;
+    buffer.add_way("w20 Nn1x1y1,n2x2y2");
+
+    auto const &nodes = buffer.buffer().get<osmium::Way>(0).nodes();
+    geom::geometry_t geom;
+    geom::create_point(&geom, nodes[0].location());
+
+    REQUIRE(geom.is_point());
+    REQUIRE(geometry_type(geom) == "POINT");
+    REQUIRE(dimension(geom) == 0);
+    REQUIRE(num_geometries(geom) == 1);
+    REQUIRE(geom.get<geom::point_t>() == geom::point_t{1, 1});
+}
+
+TEST_CASE("create_point from OSM data without locations", "[NoDB]")
+{
+    test_buffer_t buffer;
+    buffer.add_way("w20 Nn1,n2");
+
+    auto const &nodes = buffer.buffer().get<osmium::Way>(0).nodes();
+    geom::geometry_t geom;
+    geom::create_point(&geom, nodes[0].location());
+
+    REQUIRE(geom.is_null());
+}
+
+TEST_CASE("create_point from way with single node", "[NoDB]")
+{
+    test_buffer_t buffer;
+    buffer.add_way("w20 Nn1x1y1");
+
+    auto const &nodes = buffer.buffer().get<osmium::Way>(0).nodes();
+    geom::geometry_t geom;
+    geom::create_point(&geom, nodes[0].location());
+
+    REQUIRE(geom.is_point());
+    REQUIRE(geometry_type(geom) == "POINT");
+    REQUIRE(dimension(geom) == 0);
+    REQUIRE(num_geometries(geom) == 1);
+    REQUIRE(geom.get<geom::point_t>() == geom::point_t{1, 1});
+}
+
 TEST_CASE("geom::segmentize w/o split", "[NoDB]")
 {
     geom::linestring_t const expected{{0, 0}, {1, 2}, {2, 2}};

tests/test-geom-points.cpp

@@ -42,6 +42,20 @@ TEST_CASE("geom::point_t from location", "[NoDB]")
     REQUIRE(p == geom::point_t{3.141, 2.718});
 }
 
+TEST_CASE("geom::point_t from location with create_point", "[NoDB]")
+{
+    osmium::Location const location{1.1, 2.2};
+
+    geom::geometry_t geom;
+    geom::create_point(&geom, location);
+    REQUIRE(geom.is_point());
+
+    auto const &p = geom.get<geom::point_t>();
+    REQUIRE(p.x() == Approx(1.1));
+    REQUIRE(p.y() == Approx(2.2));
+    REQUIRE(p == geom::point_t{1.1, 2.2});
+}
+
 TEST_CASE("create_point from OSM data", "[NoDB]")
 {
     test_buffer_t buffer;