Merge pull request #1705 from joto/geom-improvements

Geometry processing improvements

Author: lonvia

.github/actions/win-install/action.yml

@@ -5,7 +5,7 @@ runs:
 
   steps:
     - name: Install packages
-      run: vcpkg install bzip2:x64-windows expat:x64-windows zlib:x64-windows proj4:x64-windows boost-system:x64-windows boost-filesystem:x64-windows boost-property-tree:x64-windows lua:x64-windows libpq:x64-windows
+      run: vcpkg install bzip2:x64-windows expat:x64-windows zlib:x64-windows proj4:x64-windows boost-geometry:x64-windows boost-system:x64-windows boost-filesystem:x64-windows boost-property-tree:x64-windows lua:x64-windows libpq:x64-windows
       shell: bash
 
     - name: Install psycopg2 and beahve

README.md

@@ -48,7 +48,8 @@ Required libraries are
 * [proj](https://proj.org/)
 * [bzip2](http://www.bzip.org/)
 * [zlib](https://www.zlib.net/)
-* [Boost libraries](https://www.boost.org/), including system and filesystem
+* [Boost libraries](https://www.boost.org/), including geometry, system and
+  filesystem
 * [PostgreSQL](https://www.postgresql.org/) client libraries
 * [Lua](https://www.lua.org/) (Optional, used for Lua tag transforms
   and the flex output)

src/geom-boost-adaptor.hpp

@@ -0,0 +1,86 @@
+#ifndef OSM2PGSQL_GEOM_BOOST_ADAPTOR_HPP
+#define OSM2PGSQL_GEOM_BOOST_ADAPTOR_HPP
+
+/**
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ *
+ * This file is part of osm2pgsql (https://osm2pgsql.org/).
+ *
+ * Copyright (C) 2006-2022 by the osm2pgsql developer community.
+ * For a full list of authors see the git log.
+ */
+
+#include "geom.hpp"
+
+#include <boost/geometry.hpp>
+#include <boost/geometry/geometries/register/linestring.hpp>
+#include <boost/geometry/geometries/register/multi_linestring.hpp>
+#include <boost/geometry/geometries/register/multi_point.hpp>
+#include <boost/geometry/geometries/register/multi_polygon.hpp>
+#include <boost/geometry/geometries/register/point.hpp>
+#include <boost/geometry/geometries/register/ring.hpp>
+
+BOOST_GEOMETRY_REGISTER_POINT_2D_GET_SET(geom::point_t, double, cs::cartesian,
+                                         x, y, set_x, set_y)
+BOOST_GEOMETRY_REGISTER_LINESTRING(geom::linestring_t)
+BOOST_GEOMETRY_REGISTER_RING(geom::ring_t)
+
+BOOST_GEOMETRY_REGISTER_MULTI_POINT(geom::multipoint_t)
+BOOST_GEOMETRY_REGISTER_MULTI_LINESTRING(geom::multilinestring_t)
+BOOST_GEOMETRY_REGISTER_MULTI_POLYGON(geom::multipolygon_t)
+
+namespace boost {
+namespace geometry {
+namespace traits {
+template <>
+struct point_order<::geom::ring_t>
+{
+    static const order_selector value = counterclockwise;
+};
+
+template <>
+struct tag<::geom::polygon_t>
+{
+    using type = polygon_tag;
+};
+template <>
+struct ring_const_type<::geom::polygon_t>
+{
+    using type = ::geom::ring_t const &;
+};
+template <>
+struct ring_mutable_type<::geom::polygon_t>
+{
+    using type = ::geom::ring_t &;
+};
+template <>
+struct interior_const_type<::geom::polygon_t>
+{
+    using type = std::vector<::geom::ring_t> const;
+};
+template <>
+struct interior_mutable_type<::geom::polygon_t>
+{
+    using type = std::vector<::geom::ring_t>;
+};
+
+template <>
+struct exterior_ring<::geom::polygon_t>
+{
+    // NOLINTNEXTLINE(google-runtime-references)
+    static auto &get(::geom::polygon_t &p) { return p.outer(); }
+    static auto &get(::geom::polygon_t const &p) { return p.outer(); }
+};
+
+template <>
+struct interior_rings<::geom::polygon_t>
+{
+    // NOLINTNEXTLINE(google-runtime-references)
+    static auto get(::geom::polygon_t &p) { return p.inners(); }
+    static auto get(::geom::polygon_t const &p) { return p.inners(); }
+};
+} // namespace traits
+} // namespace geometry
+} // namespace boost
+
+#endif // OSM2PGSQL_GEOM_BOOST_ADAPTOR_HPP

src/geom-functions.cpp

@@ -7,6 +7,7 @@
  * For a full list of authors see the git log.
  */
 
+#include "geom-boost-adaptor.hpp"
 #include "geom-functions.hpp"
 
 #include <algorithm>
@@ -30,6 +31,32 @@ point_t interpolate(point_t p1, point_t p2, double frac) noexcept
                    frac * (p1.y() - p2.y()) + p2.y()};
 }
 
+std::string_view geometry_type(geometry_t const &geom)
+{
+    using namespace std::literals::string_view_literals;
+    return geom.visit(overloaded{
+        [&](geom::nullgeom_t const & /*input*/) { return "NULL"sv; },
+        [&](geom::point_t const & /*input*/) { return "POINT"sv; },
+        [&](geom::linestring_t const & /*input*/) { return "LINESTRING"sv; },
+        [&](geom::polygon_t const & /*input*/) { return "POLYGON"sv; },
+        [&](geom::multipoint_t const & /*input*/) { return "MULTIPOINT"sv; },
+        [&](geom::multilinestring_t const & /*input*/) {
+            return "MULTILINESTRING"sv;
+        },
+        [&](geom::multipolygon_t const & /*input*/) {
+            return "MULTIPOLYGON"sv;
+        },
+        [&](geom::collection_t const & /*input*/) {
+            return "GEOMETRYCOLLECTION"sv;
+        }});
+}
+
+std::size_t num_geometries(geometry_t const &geom)
+{
+    return geom.visit(
+        overloaded{[&](auto const &input) { return input.num_geometries(); }});
+}
+
 namespace {
 
 class transform_visitor
@@ -274,7 +301,7 @@ double area(geometry_t const &geom)
         }
     }
 
-    return total;
+    return std::abs(total);
 }
 
 namespace {
@@ -519,4 +546,19 @@ geometry_t line_merge(geometry_t geom)
     return output;
 }
 
+geometry_t centroid(geometry_t const &geom)
+{
+    geom::geometry_t output{point_t{}, geom.srid()};
+    auto &center = output.get<point_t>();
+
+    geom.visit(overloaded{
+        [&](geom::nullgeom_t const & /*input*/) { output.reset(); },
+        [&](geom::collection_t const & /*input*/) {
+            throw std::runtime_error{"not implemented yet"};
+        },
+        [&](auto const &input) { boost::geometry::centroid(input, center); }});
+
+    return output;
+}
+
 } // namespace geom

src/geom-functions.hpp

@@ -13,6 +13,7 @@
 #include "geom.hpp"
 #include "reprojection.hpp"
 
+#include <string_view>
 #include <utility>
 #include <vector>
 
@@ -51,6 +52,18 @@ void for_each_segment(point_list_t const &list, FUNC&& func)
     }
 }
 
+/**
+ * Return the type of a geometry as string: NULL, (MULTI)POINT,
+ * (MULTI)LINESTRING, (MULTI)POLYGON, or GEOMETRYCOLLECTION.
+ */
+std::string_view geometry_type(geometry_t const &geom);
+
+/**
+ * Return the number of geometries in this geometry. For the null geometry
+ * this is always 0, for other non-multi geometries this is always 1.
+ */
+std::size_t num_geometries(geometry_t const &geom);
+
 /**
  * Transform a geometry in 4326 into some other projection.
  *
@@ -105,6 +118,14 @@ std::vector<geometry_t> split_multi(geometry_t geom, bool split_multi = true);
  */
 geometry_t line_merge(geometry_t geom);
 
+/**
+ * Calculate the centroid of a geometry.
+ *
+ * \param geom Input geometry.
+ * \returns Resulting point geometry.
+ */
+geometry_t centroid(geometry_t const &geom);
+
 } // namespace geom
 
 #endif // OSM2PGSQL_GEOM_FUNCTIONS_HPP

src/geom.cpp

@@ -23,4 +23,16 @@ bool operator!=(point_list_t const &a, point_list_t const &b) noexcept
     return !(a == b);
 }
 
+bool operator==(polygon_t const &a, polygon_t const &b) noexcept
+{
+    return (a.outer() == b.outer()) &&
+           std::equal(a.inners().cbegin(), a.inners().cend(),
+                      b.inners().cbegin(), b.inners().cend());
+}
+
+bool operator!=(polygon_t const &a, polygon_t const &b) noexcept
+{
+    return !(a == b);
+}
+
 } // namespace geom