Merge pull request #1782 from joto/geom-simplify-multilinestring

Add implementation of simplify function for multilinestrings

Author: lonvia

src/geom-from-osm.cpp

@@ -29,7 +29,14 @@ geometry_t create_point(osmium::Node const &node)
     return geometry_t{point_t{node.location()}};
 }
 
-static void fill_point_list(point_list_t *list,
+/**
+ * Fill point list with locations from nodes list. Consecutive identical
+ * locations are collapsed into a single point.
+ *
+ * Returns true if the result is a valid linestring, i.e. it has more than
+ * one point.
+ */
+static bool fill_point_list(point_list_t *list,
                             osmium::NodeRefList const &nodes)
 {
     osmium::Location last{};
@@ -41,16 +48,15 @@ static void fill_point_list(point_list_t *list,
             last = loc;
         }
     }
+
+    return list->size() > 1;
 }
 
 void create_linestring(geometry_t *geom, osmium::Way const &way)
 {
     auto &line = geom->set<linestring_t>();
 
-    fill_point_list(&line, way.nodes());
-
-    // Return nullgeom_t if the line geometry is invalid
-    if (line.size() <= 1U) {
+    if (!fill_point_list(&line, way.nodes())) {
         geom->reset();
     }
 }
@@ -134,16 +140,14 @@ void create_multilinestring(geometry_t *geom,
     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) {
+        if (!fill_point_list(&line, way.nodes())) {
             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) {
+            if (fill_point_list(&line, way.nodes())) {
                 multiline.add_geometry(std::move(line));
             }
         }
@@ -228,8 +232,7 @@ void create_collection(geometry_t *geom, osmium::memory::Buffer const &buffer)
             auto const &way = static_cast<osmium::Way const &>(obj);
             geometry_t item;
             auto &line = item.set<linestring_t>();
-            fill_point_list(&line, way.nodes());
-            if (line.size() >= 2U) {
+            if (fill_point_list(&line, way.nodes())) {
                 collection.add_geometry(std::move(item));
             }
         }

src/geom-functions.cpp

@@ -727,24 +727,52 @@ geometry_t centroid(geometry_t const &geom)
     return output;
 }
 
-void simplify(geometry_t *output, geometry_t const &input, double tolerance)
+/****************************************************************************/
+
+static bool simplify(linestring_t *output, linestring_t const &input,
+                     double tolerance)
 {
-    if (!input.is_linestring()) {
-        output->reset();
-        return;
+    boost::geometry::simplify(input, *output, tolerance);
+
+    // Linestrings with less then 2 points are invalid. Older boost::geometry
+    // versions will generate a "line" with two identical points. We are
+    // paranoid here and remove all duplicate points and then check that we
+    // have at least 2 points.
+    output->remove_duplicates();
+    return output->size() > 1;
+}
+
+static bool simplify(multilinestring_t *output, multilinestring_t const &input,
+                     double tolerance)
+{
+    for (auto const &ls : input) {
+        linestring_t simplified_ls;
+        if (simplify(&simplified_ls, ls, tolerance)) {
+            output->add_geometry(std::move(simplified_ls));
+        }
     }
+    return output->num_geometries() > 0;
+}
 
-    auto &ls = output->set<linestring_t>();
+template <typename T>
+static bool simplify(T * /*output*/, T const & /*input*/, double /*tolerance*/)
+{
+    return false;
+}
+
+void simplify(geometry_t *output, geometry_t const &input, double tolerance)
+{
     output->set_srid(input.srid());
 
-    boost::geometry::simplify(input.get<linestring_t>(), ls, tolerance);
+    input.visit([&](auto const &input) {
+        using inner_type =
+            std::remove_const_t<std::remove_reference_t<decltype(input)>>;
+        auto &out = output->set<inner_type>();
 
-    // Linestrings with less then 2 nodes are invalid. Older boost::geometry
-    // versions will generate a "line" with two identical points which the
-    // second check finds.
-    if (ls.size() < 2 || ls[0] == ls[1]) {
-        output->reset();
-    }
+        if (!simplify(&out, input, tolerance)) {
+            output->reset();
+        }
+    });
 }
 
 geometry_t simplify(geometry_t const &input, double tolerance)

src/geom.cpp

@@ -14,6 +14,12 @@
 
 namespace geom {
 
+void point_list_t::remove_duplicates()
+{
+    auto const it = std::unique(begin(), end());
+    erase(it, end());
+}
+
 bool operator==(polygon_t const &a, polygon_t const &b) noexcept
 {
     return (a.outer() == b.outer()) && (a.inners() == b.inners());

src/geom.hpp

@@ -90,7 +90,15 @@ class point_t
 
 }; // class point_t
 
-/// This type is used as the basis for linestrings and rings.
+/**
+ * This type is used as the basis for linestrings and rings.
+ *
+ * Point lists should not contain consecutive duplicate points. You can
+ * use the remove_duplicates() function to remove them if needed. (OGC validity
+ * only requires there to be at least two different points in a linestring, but
+ * we are more strict here to make sure we don't have to handle that anomaly
+ * later on.)
+ */
 class point_list_t : public std::vector<point_t>
 {
 public:
@@ -105,6 +113,9 @@ class point_list_t : public std::vector<point_t>
     : std::vector<point_t>(list.begin(), list.end())
     {}
 
+    /// Collapse consecutive identical points into a single point (in-place).
+    void remove_duplicates();
+
 }; // class point_list_t
 
 class linestring_t : public point_list_t

tests/test-geom-linestrings.cpp

@@ -39,6 +39,15 @@ TEST_CASE("geom::linestring_t", "[NoDB]")
     REQUIRE(ls1.num_geometries() == 1);
 }
 
+TEST_CASE("remove duplicate points in linestring", "[NoDB]")
+{
+    geom::linestring_t ls{{1, 1}, {1, 2}, {1, 2}, {2, 2}};
+    REQUIRE(ls.size() == 4);
+    ls.remove_duplicates();
+    REQUIRE(ls.size() == 3);
+    REQUIRE(ls == geom::linestring_t{{1, 1}, {1, 2}, {2, 2}});
+}
+
 TEST_CASE("line geometry", "[NoDB]")
 {
     geom::geometry_t const geom{geom::linestring_t{{1, 1}, {2, 2}}};
@@ -278,3 +287,30 @@ TEST_CASE("geom::simplify of a loop", "[NoDB]")
         REQUIRE(geom.is_null());
     }
 }
+
+TEST_CASE("geom::simplify of straight line", "[NoDB]")
+{
+    geom::geometry_t const input{geom::linestring_t{{1, 1}, {1, 2}, {1, 3}}};
+
+    SECTION("small tolerance simplifies linestring")
+    {
+        auto const geom = geom::simplify(input, 0.5);
+
+        REQUIRE(geom.is_linestring());
+        auto const &l = geom.get<geom::linestring_t>();
+        REQUIRE(l.size() == 2);
+        REQUIRE(l[0] == input.get<geom::linestring_t>()[0]);
+        REQUIRE(l[1] == input.get<geom::linestring_t>()[2]);
+    }
+
+    SECTION("large tolerance also simplifies linestring")
+    {
+        auto const geom = geom::simplify(input, 10.0);
+
+        REQUIRE(geom.is_linestring());
+        auto const &l = geom.get<geom::linestring_t>();
+        REQUIRE(l.size() == 2);
+        REQUIRE(l[0] == input.get<geom::linestring_t>()[0]);
+        REQUIRE(l[1] == input.get<geom::linestring_t>()[2]);
+    }
+}

tests/test-geom-multilinestrings.cpp

@@ -299,3 +299,45 @@ TEST_CASE("create_multilinestring from P shape with closed way", "[NoDB]")
     REQUIRE(ml[0] == expected[0]);
     REQUIRE(ml[1] == expected[1]);
 }
+
+TEST_CASE("create_multilinestring and simplify", "[NoDB]")
+{
+    test_buffer_t buffer;
+    buffer.add_way("w20 Nn10x1y1,n11x1y2,n12x1y3");
+    buffer.add_way("w21 Nn12x1y3,n13x2y3,n11x1y2");
+
+    auto const geom =
+        geom::create_multilinestring(buffer.buffer());
+
+    REQUIRE(geom.is_multilinestring());
+    REQUIRE(geom.srid() == 4326);
+    auto const &mls = geom.get<geom::multilinestring_t>();
+    REQUIRE(mls.num_geometries() == 2);
+    REQUIRE(mls[0] == geom::linestring_t{{1, 1}, {1, 2}, {1, 3}});
+    REQUIRE(mls[1] == geom::linestring_t{{1, 3}, {2, 3}, {1, 2}});
+
+    SECTION("simplify with small tolerance")
+    {
+        auto const simplified_geom = geom::simplify(geom, 0.1);
+        REQUIRE(simplified_geom.is_multilinestring());
+        REQUIRE(simplified_geom.srid() == 4326);
+        auto const &simplified_mls =
+            simplified_geom.get<geom::multilinestring_t>();
+        REQUIRE(simplified_mls.num_geometries() == 2);
+        REQUIRE(simplified_mls[0] == geom::linestring_t{{1, 1}, {1, 3}});
+        REQUIRE(simplified_mls[1] ==
+                geom::linestring_t{{1, 3}, {2, 3}, {1, 2}});
+    }
+
+    SECTION("simplify with large tolerance")
+    {
+        auto const simplified_geom = geom::simplify(geom, 10.0);
+        REQUIRE(simplified_geom.is_multilinestring());
+        REQUIRE(simplified_geom.srid() == 4326);
+        auto const &simplified_mls =
+            simplified_geom.get<geom::multilinestring_t>();
+        REQUIRE(simplified_mls.num_geometries() == 2);
+        REQUIRE(simplified_mls[0] == geom::linestring_t{{1, 1}, {1, 3}});
+        REQUIRE(simplified_mls[1] == geom::linestring_t{{1, 3}, {1, 2}});
+    }
+}