CoverageSimplify: add progress callback and add GEOSCoverageSimplifyVWWithProgress_r()

capi/geos_c.cpp

@@ -2061,5 +2061,15 @@ extern "C" {
         return GEOSCoverageSimplifyVW_r(handle, input, tolerance, preserveBoundary);
     }
 
+    Geometry*
+    GEOSCoverageSimplifyVWWithProgress(const Geometry* input, double tolerance,
+                                       int preserveBoundary,
+                                       GEOSProgressCallback_r progressFunc,
+                                       void* progressUserData)
+    {
+        return GEOSCoverageSimplifyVWWithProgress_r(
+            handle, input, tolerance, preserveBoundary, progressFunc, progressUserData);
+    }
+
 
 } /* extern "C" */

capi/geos_c.h.in

@@ -117,6 +117,21 @@ typedef void (*GEOSMessageHandler)(GEOS_PRINTF_FORMAT const char *fmt, ...)
 */
 typedef void (*GEOSMessageHandler_r)(const char *message, void *userdata);
 
+
+/**
+ * A GEOS progression callback function.
+ *
+ * Such function takes a progression ratio, and an optional message.
+ *
+ * \param progressRatio Progression ratio (between 0 and 1)
+ * \param message Information message (can be NULL)
+ * \param userdata the user data pointer that was passed to GEOS together with
+ * this callback.
+ */
+typedef void (*GEOSProgressCallback_r)(double progressRatio,
+                                       const char* message, void* userdata);
+
+
 /*
 * When we're included by geos_c.cpp, these types are #defined to the
 * C++ definitions via preprocessor. We don't touch them to allow the
@@ -886,6 +901,16 @@ GEOSCoverageSimplifyVW_r(
     double tolerance,
     int preserveBoundary);
 
+/** \see GEOSCoverageSimplifyVWWithProgress */
+extern GEOSGeometry GEOS_DLL *
+GEOSCoverageSimplifyVWWithProgress_r(
+    GEOSContextHandle_t extHandle,
+    const GEOSGeometry* input,
+    double tolerance,
+    int preserveBoundary,
+    GEOSProgressCallback_r progressFunc,
+    void* progressUserData);
+
 /** \see GEOSCoverageCleanParams_create */
 extern GEOSCoverageCleanParams GEOS_DLL *
 GEOSCoverageCleanParams_create_r(
@@ -1076,6 +1101,13 @@ extern GEOSGeometry GEOS_DLL *GEOSUnaryUnion_r(
     GEOSContextHandle_t handle,
     const GEOSGeometry* g);
 
+/** \see GEOSUnaryUnion */
+extern GEOSGeometry GEOS_DLL *GEOSUnaryUnionWithProgress_r(
+    GEOSContextHandle_t handle,
+    const GEOSGeometry* g,
+    GEOSProgressCallback_r progressFunc,
+    void* progressUserData);
+
 /** \see GEOSUnaryUnionPrec */
 extern GEOSGeometry GEOS_DLL *GEOSUnaryUnionPrec_r(
     GEOSContextHandle_t handle,
@@ -4321,6 +4353,40 @@ extern GEOSGeometry GEOS_DLL * GEOSCoverageSimplifyVW(
     double tolerance,
     int preserveBoundary);
 
+/**
+* Operates on a coverage (represented as a list of polygonal geometry
+* with exactly matching edge geometry) to apply a Visvalingam–Whyatt
+* simplification to the edges, reducing complexity in proportion with
+* the provided tolerance, while retaining a valid coverage (no edges
+* will cross or touch after the simplification).
+* Geometries never disappear, but they may be simplified down to just
+* a triangle. Also, some invalid geoms (such as Polygons which have too
+* few non-repeated points) will be returned unchanged.
+* If the input dataset is not a valid coverage due to overlaps,
+* it will still be simplified, but invalid topology such as crossing
+* edges will still be invalid.
+*
+* \param input The polygonal coverage to access,
+*        stored in a geometry collection. All members must be POLYGON
+*        or MULTIPOLYGON.
+* \param tolerance A tolerance parameter in linear units.
+* \param preserveBoundary Use 1 to preserve the outside edges
+*        of the coverage without simplification,
+*        0 to allow them to be simplified.
+* \param progressFunc Progress callback (or null)
+* \param progressUserData User data passed to progress callback (can be null)
+* \return A collection containing the simplified geometries, or null
+*         on error.
+*
+* \since 3.14
+*/
+extern GEOSGeometry GEOS_DLL * GEOSCoverageSimplifyVWWithProgress(
+    const GEOSGeometry* input,
+    double tolerance,
+    int preserveBoundary,
+    GEOSProgressCallback_r progressFunc,
+    void* progressUserData);
+
 /**
 * Create a default GEOSCoverageCleanParams object for controlling
 * the way invalid polygon interactions are repaird by \ref GEOSCoverageCleanWithParams.
@@ -5328,7 +5394,7 @@ extern char GEOS_DLL GEOSIntersects(const GEOSGeometry* g1, const GEOSGeometry*
 extern char GEOS_DLL GEOSCrosses(const GEOSGeometry* g1, const GEOSGeometry* g2);
 
 /**
-* Tests if geometry g1 is completely within g2, 
+* Tests if geometry g1 is completely within g2,
 * but not wholly contained in the boundary of g2.
 * \param g1 Input geometry
 * \param g2 Input geometry

capi/geos_ts_c.cpp

@@ -114,6 +114,7 @@
 #include <geos/util/Interrupt.h>
 #include <geos/util/UniqueCoordinateArrayFilter.h>
 #include <geos/util/Machine.h>
+#include <geos/util/Progress.h>
 #include <geos/version.h>
 
 // This should go away
@@ -1666,6 +1667,24 @@
         });
     }
 
+    Geometry*
+    GEOSUnaryUnionWithProgress_r(GEOSContextHandle_t extHandle, const Geometry* g,
+                                 GEOSProgressCallback_r progressFunc,
+                                 void* progressUserData)
+    {
+        geos::util::ProgressFunction progressFunction(
+            [progressFunc, progressUserData](double progress, const char* message)
+        {
+            progressFunc(progress, message, progressUserData);
+        });
+
+        return execute(extHandle, [&]() {
+            std::unique_ptr<Geometry> g3(g->Union(&progressFunction));
+            g3->setSRID(g->getSRID());
+            return g3.release();
+        });
+    }
+
     Geometry*
     GEOSUnaryUnionPrec_r(GEOSContextHandle_t extHandle, const Geometry* g1, double gridSize)
     {
@@ -4522,6 +4541,25 @@
         double tolerance,
         int preserveBoundary)
     {
+        return GEOSCoverageSimplifyVWWithProgress_r(extHandle, input, tolerance,
+                                                    preserveBoundary,
+                                                    nullptr, nullptr);
+    }
+
+    Geometry*
+    GEOSCoverageSimplifyVWWithProgress_r(GEOSContextHandle_t extHandle,
+        const Geometry* input,
+        double tolerance,
+        int preserveBoundary,
+        GEOSProgressCallback_r progressFunc,
+        void* progressUserData)
+    {
+        geos::util::ProgressFunction progressFunction(
+            [progressFunc, progressUserData](double progress, const char* message)
+        {
+            progressFunc(progress, message, progressUserData);
+        });
+
         using geos::coverage::CoverageSimplifier;
 
         return execute(extHandle, [&]() -> Geometry* {
@@ -4536,10 +4574,10 @@
             CoverageSimplifier cov(coverage);
             std::vector<std::unique_ptr<Geometry>> simple;
             if (preserveBoundary == 1) {
-                simple = cov.simplifyInner(tolerance);
+                simple = cov.simplifyInner(tolerance, progressFunc ? progressFunction : geos::util::defaultProgress);
             }
             else if (preserveBoundary == 0) {
-                simple = cov.simplify(tolerance);
+                simple = cov.simplify(tolerance, progressFunc ? progressFunction : geos::util::defaultProgress);
             }
             else return nullptr;
 

include/geos/coverage/CoverageBoundarySegmentFinder.h

@@ -20,6 +20,7 @@
 #include <geos/geom/Coordinate.h>
 #include <geos/geom/LineSegment.h>
 #include <geos/export.h>
+#include <geos/util/Progress.h>
 
 namespace geos {
 namespace geom {
@@ -57,7 +58,9 @@ class CoverageBoundarySegmentFinder : public geos::geom::CoordinateSequenceFilte
 
 
     static LineSegment::UnorderedSet
-        findBoundarySegments(const std::vector<const Geometry*>& geoms);
+        findBoundarySegments(const std::vector<const Geometry*>& geoms,
+                             const util::ProgressFunction& progressFunction = util::defaultProgress);
+
 
     static bool isBoundarySegment(
         const LineSegment::UnorderedSet& boundarySegs,

include/geos/coverage/CoverageEdge.h

@@ -20,6 +20,7 @@
 #include <geos/geom/CoordinateSequence.h>
 #include <geos/geom/LineSegment.h>
 #include <geos/util.h>
+#include <geos/util/Progress.h>
 
 // Forward declarations
 namespace geos {
@@ -116,7 +117,8 @@ class GEOS_DLL CoverageEdge {
 
     static std::unique_ptr<MultiLineString> createLines(
         const std::vector<CoverageEdge*>& edges,
-        const GeometryFactory* geomFactory);
+        const GeometryFactory* geomFactory,
+        const util::ProgressFunction& progressFunction = util::defaultProgress);
 
     std::unique_ptr<LineString> toLineString(
         const GeometryFactory* geomFactory);

include/geos/coverage/CoverageRingEdges.h

@@ -18,6 +18,7 @@
 #include <geos/geom/Coordinate.h>
 #include <geos/geom/LineSegment.h>
 #include <geos/coverage/CoverageEdge.h> // to materialize CoverageEdge
+#include <geos/util/Progress.h>
 
 #include <set>
 #include <map>
@@ -72,10 +73,11 @@
 
 public:
 
-    CoverageRingEdges(const std::vector<const Geometry*>& coverage)
+    CoverageRingEdges(const std::vector<const Geometry*>& coverage,
+                      const util::ProgressFunction& progressFunction = util::defaultProgress)
         : m_coverage(coverage)
     {
-        build();
+        build(progressFunction);
     };
 
 
@@ -96,14 +98,15 @@
     /**
     * Recreates the polygon coverage from the current edge values.
     *
+    * @param progressFunction Progress function or null
     * @return an array of polygonal geometries representing the coverage
     */
-    std::vector<std::unique_ptr<Geometry>> buildCoverage() const;
+    std::vector<std::unique_ptr<Geometry>> buildCoverage(const util::ProgressFunction& progressFunction = util::defaultProgress) const;
 
 
 private:
 
-    void build();
+    void build(const util::ProgressFunction& progressFunction = util::defaultProgress);
 
     void addRingEdges(
         const LinearRing* ring,
@@ -140,10 +143,12 @@
         const CoordinateSequence& ring);
 
     Coordinate::UnorderedSet findMultiRingNodes(
-        const std::vector<const Geometry*>& coverage);
+        const std::vector<const Geometry*>& coverage,
+        const util::ProgressFunction& progressFunction = util::defaultProgress);
 
     Coordinate::UnorderedSet findBoundaryNodes(
-        LineSegment::UnorderedSet& lineSegments);
+        LineSegment::UnorderedSet& lineSegments,
+        const util::ProgressFunction& progressFunction = util::defaultProgress);
 
     std::unique_ptr<Geometry> buildPolygonal(
         const Geometry* geom) const;

include/geos/coverage/CoverageSimplifier.h

@@ -19,6 +19,7 @@
 #include <vector>
 #include <memory>
 #include <geos/export.h>
+#include <geos/util/Progress.h>
 
 
 namespace geos {
@@ -87,15 +88,18 @@ class GEOS_DLL CoverageSimplifier {
     *
     * @param coverage a set of polygonal geometries forming a coverage
     * @param tolerance the simplification tolerance
+    * @param progressFunction Progress function
     * @return the simplified polygons
     */
     static std::vector<std::unique_ptr<Geometry>> simplify(
         std::vector<const Geometry*>& coverage,
-        double tolerance);
+        double tolerance,
+        const util::ProgressFunction& progressFunction = util::defaultProgress);
 
     static std::vector<std::unique_ptr<Geometry>> simplify(
         const std::vector<std::unique_ptr<Geometry>>& coverage,
-        double tolerance);
+        double tolerance,
+        const util::ProgressFunction& progressFunction = util::defaultProgress);
 
     /**
     * Simplifies the inner boundaries of a set of polygonal geometries forming a coverage,
@@ -104,35 +108,40 @@ class GEOS_DLL CoverageSimplifier {
     *
     * @param coverage a set of polygonal geometries forming a coverage
     * @param tolerance the simplification tolerance
+    * @param progressFunction Progress function
     * @return the simplified polygons
     */
     static std::vector<std::unique_ptr<Geometry>> simplifyInner(
         std::vector<const Geometry*>& coverage,
-        double tolerance);
+        double tolerance,
+        const util::ProgressFunction& progressFunction = util::defaultProgress);
 
     static std::vector<std::unique_ptr<Geometry>> simplifyInner(
         const std::vector<std::unique_ptr<Geometry>>& coverage,
-        double tolerance);
+        double tolerance,
+        const util::ProgressFunction& progressFunction = util::defaultProgress);
 
     /**
     * Computes the simplified coverage, preserving the coverage topology.
     *
     * @param tolerance the simplification tolerance
+    * @param progressFunction Progress function
     * @return the simplified polygons
     */
     std::vector<std::unique_ptr<Geometry>> simplify(
-        double tolerance);
+        double tolerance, const util::ProgressFunction& progressFunction = util::defaultProgress);
 
     /**
     * Computes the inner-boundary simplified coverage,
     * preserving the coverage topology,
     * and leaving outer boundary edges unchanged.
     *
     * @param tolerance the simplification tolerance
+    * @param progressFunction Progress function
     * @return the simplified polygons
     */
     std::vector<std::unique_ptr<Geometry>> simplifyInner(
-        double tolerance);
+        double tolerance, const util::ProgressFunction& progressFunction = util::defaultProgress);
 
 
 private:
@@ -145,7 +154,8 @@ class GEOS_DLL CoverageSimplifier {
     void simplifyEdges(
         std::vector<CoverageEdge*> edges,
         const MultiLineString* constraints,
-        double tolerance);
+        double tolerance,
+        const util::ProgressFunction& progressFunction);
 
     void setCoordinates(
         std::vector<CoverageEdge*>& edges,