CoverageSimplify: add progress callback and add GEOSCoverageSimplifyVWWithProgress_r()

Author: rouault

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,23 @@ typedef void (*GEOSMessageHandler)(GEOS_PRINTF_FORMAT const char *fmt, ...)
 */
 typedef void (*GEOSMessageHandler_r)(const char *message, void *userdata);
 
+
+/**
+ * A GEOS progression and cancel function.
+ *
+ * Such function takes a progression ratio, and an optional
+ * message, and returns true if computation must continue, or false if it
+ * must be interrupted.
+ *
+ * \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.
+ * \return TRUE if processing must continue, or FALSE to interrupt it.
+ */
+typedef int (*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 +903,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(
@@ -4321,6 +4348,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 +5389,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
@@ -4522,6 +4523,25 @@ extern "C" {
         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)
+        {
+            return progressFunc(progress, message, progressUserData);
+        };
+
         using geos::coverage::CoverageSimplifier;
 
         return execute(extHandle, [&]() -> Geometry* {
@@ -4536,10 +4556,10 @@ extern "C" {
             CoverageSimplifier cov(coverage);
             std::vector<std::unique_ptr<Geometry>> simple;
             if (preserveBoundary == 1) {
-                simple = cov.simplifyInner(tolerance);
+                simple = cov.simplifyInner(tolerance, progressFunc ? &progressFunction : nullptr);
             }
             else if (preserveBoundary == 0) {
-                simple = cov.simplify(tolerance);
+                simple = cov.simplify(tolerance, progressFunc ? &progressFunction : nullptr);
             }
             else return nullptr;
 

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, or nullptr.
     * @return the simplified polygons
     */
     static std::vector<std::unique_ptr<Geometry>> simplify(
         std::vector<const Geometry*>& coverage,
-        double tolerance);
+        double tolerance,
+        geos::util::ProgressFunction* progressFunction);
 
     static std::vector<std::unique_ptr<Geometry>> simplify(
         const std::vector<std::unique_ptr<Geometry>>& coverage,
-        double tolerance);
+        double tolerance,
+        geos::util::ProgressFunction* progressFunction);
 
     /**
     * 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, or nullptr.
     * @return the simplified polygons
     */
     static std::vector<std::unique_ptr<Geometry>> simplifyInner(
         std::vector<const Geometry*>& coverage,
-        double tolerance);
+        double tolerance,
+        geos::util::ProgressFunction* progressFunction);
 
     static std::vector<std::unique_ptr<Geometry>> simplifyInner(
         const std::vector<std::unique_ptr<Geometry>>& coverage,
-        double tolerance);
+        double tolerance,
+        geos::util::ProgressFunction* progressFunction);
 
     /**
     * Computes the simplified coverage, preserving the coverage topology.
     *
     * @param tolerance the simplification tolerance
+    * @param progressFunction Progress function, or nullptr.
     * @return the simplified polygons
     */
     std::vector<std::unique_ptr<Geometry>> simplify(
-        double tolerance);
+        double tolerance, geos::util::ProgressFunction* progressFunction);
 
     /**
     * 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, or nullptr.
     * @return the simplified polygons
     */
     std::vector<std::unique_ptr<Geometry>> simplifyInner(
-        double tolerance);
+        double tolerance, geos::util::ProgressFunction* progressFunction);
 
 
 private:
@@ -145,7 +154,8 @@ class GEOS_DLL CoverageSimplifier {
     void simplifyEdges(
         std::vector<CoverageEdge*> edges,
         const MultiLineString* constraints,
-        double tolerance);
+        double tolerance,
+        geos::util::ProgressFunction* progressFunction);
 
     void setCoordinates(
         std::vector<CoverageEdge*>& edges,

include/geos/coverage/TPVWSimplifier.h

@@ -21,6 +21,7 @@
 #include <geos/simplify/LinkedLine.h>
 #include <geos/coverage/Corner.h>
 #include <geos/export.h>
+#include <geos/util/Progress.h>
 
 
 namespace geos {
@@ -164,11 +165,13 @@ class GEOS_DLL TPVWSimplifier
     *
     * @param lines the lines to simplify
     * @param distanceTolerance the simplification tolerance
+    * @param progressFunction Progress function, or nullptr.
     * @return the simplified lines
     */
     static std::unique_ptr<MultiLineString> simplify(
         const MultiLineString* lines,
-        double distanceTolerance);
+        double distanceTolerance,
+        geos::util::ProgressFunction* progressFunction);
 
     /**
     * Simplifies a set of lines, preserving the topology of the lines between
@@ -181,13 +184,15 @@ class GEOS_DLL TPVWSimplifier
     * @param freeRings flags indicating which ring edges do not have node endpoints
     * @param constraintLines the linear constraints
     * @param distanceTolerance the simplification tolerance
+    * @param progressFunction Progress function, or nullptr.
     * @return the simplified lines
     */
     static std::unique_ptr<MultiLineString> simplify(
         const MultiLineString* lines,
         std::vector<bool>& freeRings,
         const MultiLineString* constraintLines,
-        double distanceTolerance);
+        double distanceTolerance,
+        geos::util::ProgressFunction* progressFunction);
 
     // Constructor
     TPVWSimplifier(const MultiLineString* lines,
@@ -209,7 +214,7 @@ class GEOS_DLL TPVWSimplifier
 
     void setConstraints(const MultiLineString* constraints);
 
-    std::unique_ptr<MultiLineString> simplify();
+    std::unique_ptr<MultiLineString> simplify(geos::util::ProgressFunction* progressFunction);
 
     std::vector<Edge> createEdges(
         const MultiLineString* lines,

include/geos/util/Progress.h

@@ -0,0 +1,63 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2025 Even Rouault <even.rouault@spatialys.com>
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Public Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <functional>
+
+#include <geos/export.h>
+
+namespace geos {
+namespace util { // geos::util
+
+/** Signature of a progression and cancel function.
+ *
+ * Such function takes a progression ratio (between 0 and 1), and an optional
+ * message, and returns true if computation must continue, or false if it
+ * must be interrupted.
+ */
+typedef std::function<bool(double, const char*)> ProgressFunction;
+
+/** Do progress function related processing for an iteration loop of iterCount iterations.
+ *
+ * This function will invoke (*progressFunction) every notificationInterval
+ *iteration.
+ *
+ * This function will return, or throw a geos::util::InterruptedException.
+ *
+ * A typical use is:
+ * \code
+ * const size_t notificationInterval = std::max<size_t>(1, iterCount / 100);
+ * for (size_t i = 0, iNotify = 0; i < iterCount; ++i) {
+ *     // do something useful
+ *     if (progressFunction) {
+ *         geos::util::ProgressFunctionIteration(*progressFunction, i, iterCount, iNotify, notificationInterval);
+ *     }
+ * }
+ * if (progressFunction) {
+ *   (*progressFunction)(1.0, nullptr);
+ * }
+ * \endcode
+ *
+ * @param progressFunction Progress function
+ * @param i Current index of loop iteration.
+ * @param iterCount Total number of loop iteration.
+ * @param iNotify Notification counter, updated by this function. Must be set by the caller (before the loop) to 0.
+ * @param notificationInterval Notification interval (e.g. iterCount / 100).
+ */
+void ProgressFunctionIteration(ProgressFunction& progressFunction, size_t i, size_t iterCount, size_t& iNotify, size_t notificationInterval);
+
+} // namespace geos::util
+} // namespace geos
+