TPVWSimplifier::simplify(): finer grain progress report

Author: rouault

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,8 @@ class CoverageBoundarySegmentFinder : public geos::geom::CoordinateSequenceFilte
 
 
     static LineSegment::UnorderedSet
-        findBoundarySegments(const std::vector<const Geometry*>& geoms);
+        findBoundarySegments(const std::vector<const Geometry*>& geoms,
+                             geos::util::ProgressFunction* progressFunction);
 
     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,
+        geos::util::ProgressFunction* progressFunction);
 
     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 @@ class GEOS_DLL CoverageRingEdges {
 
 public:
 
-    CoverageRingEdges(const std::vector<const Geometry*>& coverage)
+    CoverageRingEdges(const std::vector<const Geometry*>& coverage,
+                      geos::util::ProgressFunction* progressFunction)
         : m_coverage(coverage)
     {
-        build();
+        build(progressFunction);
     };
 
 
@@ -96,14 +98,15 @@ class GEOS_DLL CoverageRingEdges {
     /**
     * 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(geos::util::ProgressFunction* progressFunction) const;
 
 
 private:
 
-    void build();
+    void build(geos::util::ProgressFunction* progressFunction);
 
     void addRingEdges(
         const LinearRing* ring,
@@ -140,10 +143,12 @@ class GEOS_DLL CoverageRingEdges {
         const CoordinateSequence& ring);
 
     Coordinate::UnorderedSet findMultiRingNodes(
-        const std::vector<const Geometry*>& coverage);
+        const std::vector<const Geometry*>& coverage,
+        geos::util::ProgressFunction* progressFunction);
 
     Coordinate::UnorderedSet findBoundaryNodes(
-        LineSegment::UnorderedSet& lineSegments);
+        LineSegment::UnorderedSet& lineSegments,
+        geos::util::ProgressFunction* progressFunction);
 
     std::unique_ptr<Geometry> buildPolygonal(
         const Geometry* geom) const;

include/geos/coverage/VertexRingCounter.h

@@ -19,6 +19,7 @@
 #include <geos/geom/CoordinateSequenceFilter.h>
 #include <geos/geom/Coordinate.h>
 #include <geos/export.h>
+#include <geos/util/Progress.h>
 
 namespace geos {
 namespace geom {
@@ -54,7 +55,8 @@ class VertexRingCounter : public geos::geom::CoordinateSequenceFilter
 
     static void count(
         const std::vector<const Geometry*>& geoms,
-        std::map<Coordinate, std::size_t>& counts);
+        std::map<Coordinate, std::size_t>& counts,
+        geos::util::ProgressFunction* progressFunction);
 
 private:
 

src/coverage/CoverageBoundarySegmentFinder.cpp

@@ -28,12 +28,22 @@ namespace coverage { // geos.coverage
 // public static
 LineSegment::UnorderedSet
 CoverageBoundarySegmentFinder::findBoundarySegments(
-    const std::vector<const Geometry*>& geoms)
+    const std::vector<const Geometry*>& geoms,
+    geos::util::ProgressFunction* progressFunction)
 {
     LineSegment::UnorderedSet segs;
     CoverageBoundarySegmentFinder finder(segs);
-    for (const Geometry* geom : geoms) {
+    const size_t iterCount = geoms.size();
+    const size_t notificationInterval = std::max<size_t>(1, iterCount / 100);
+    for (size_t i = 0, iNotify = 0; i < iterCount; ++i) {
+        const Geometry* geom = geoms[i];
         geom->apply_ro(finder);
+        if (progressFunction) {
+            geos::util::ProgressFunctionIteration(*progressFunction, i, iterCount, iNotify, notificationInterval);
+        }
+    }
+    if (progressFunction) {
+        (*progressFunction)(1.0, nullptr);
     }
     return segs;
 }

src/coverage/CoverageEdge.cpp

@@ -55,13 +55,23 @@ CoverageEdge::createEdge(const CoordinateSequence& ring,
 std::unique_ptr<MultiLineString>
 CoverageEdge::createLines(
     const std::vector<CoverageEdge*>& edges,
-    const GeometryFactory* geomFactory)
+    const GeometryFactory* geomFactory,
+    geos::util::ProgressFunction* progressFunction)
 {
     std::vector<std::unique_ptr<LineString>> lines;
-    for (const CoverageEdge* edge : edges) {
+    const size_t iterCount = edges.size();
+    const size_t notificationInterval = std::max<size_t>(1, iterCount / 100);
+    for (size_t i = 0, iNotify = 0; i < iterCount; ++i) {
+        const CoverageEdge* edge = edges[i];
         auto cs = edge->getCoordinates()->clone();
         auto ls = geomFactory->createLineString(std::move(cs));
         lines.push_back(std::move(ls));
+        if (progressFunction) {
+            geos::util::ProgressFunctionIteration(*progressFunction, i, iterCount, iNotify, notificationInterval);
+        }
+    }
+    if (progressFunction) {
+        (*progressFunction)(1.0, nullptr);
     }
     return geomFactory->createMultiLineString(std::move(lines));
 }

src/coverage/CoverageRingEdges.cpp

@@ -61,15 +61,47 @@ CoverageRingEdges::selectEdges(std::size_t ringCount) const
 
 /* private */
 void
-CoverageRingEdges::build()
+CoverageRingEdges::build(geos::util::ProgressFunction* progressFunction)
 {
-    Coordinate::UnorderedSet nodes = findMultiRingNodes(m_coverage);
-    LineSegment::UnorderedSet boundarySegs = CoverageBoundarySegmentFinder::findBoundarySegments(m_coverage);
-    Coordinate::UnorderedSet boundaryNodes = findBoundaryNodes(boundarySegs);
+    constexpr double RATIO_FIRST_PASS = 0.1;
+    constexpr double RATIO_SECOND_PASS = 0.2;
+    constexpr double RATIO_THIRD_PASS = 0.9;
+    constexpr double RATIO_FOURTH_PASS = 1.0;
+    geos::util::ProgressFunction subProgress;
+    if (progressFunction)
+    {
+        subProgress = geos::util::CreateScaledProgressFunction(
+            0, RATIO_FIRST_PASS, *progressFunction);
+    }
+    Coordinate::UnorderedSet nodes = findMultiRingNodes(m_coverage, progressFunction ? &subProgress : nullptr);
+
+    if (progressFunction)
+    {
+        subProgress = geos::util::CreateScaledProgressFunction(
+            RATIO_FIRST_PASS, RATIO_SECOND_PASS, *progressFunction);
+    }
+    LineSegment::UnorderedSet boundarySegs = CoverageBoundarySegmentFinder::findBoundarySegments(
+        m_coverage, progressFunction ? &subProgress : nullptr);
+
+    if (progressFunction)
+    {
+        subProgress = geos::util::CreateScaledProgressFunction(
+            RATIO_SECOND_PASS, RATIO_THIRD_PASS, *progressFunction);
+    }
+    Coordinate::UnorderedSet boundaryNodes = findBoundaryNodes(
+        boundarySegs, progressFunction ? &subProgress : nullptr);
     nodes.insert(boundaryNodes.begin(), boundaryNodes.end());
 
+    if (progressFunction)
+    {
+        subProgress = geos::util::CreateScaledProgressFunction(
+            RATIO_THIRD_PASS, RATIO_FOURTH_PASS, *progressFunction);
+    }
     std::map<LineSegment, CoverageEdge*> uniqueEdgeMap;
-    for (const Geometry* geom : m_coverage) {
+    const size_t iterCount = m_coverage.size();
+    const size_t notificationInterval = std::max<size_t>(1, iterCount / 100);
+    for (size_t i = 0, iNotify = 0; i < iterCount; ++i) {
+        const Geometry* geom = m_coverage[i];
         for (std::size_t ipoly = 0; ipoly < geom->getNumGeometries(); ipoly++) {
             util::ensureNoCurvedComponents(geom->getGeometryN(ipoly));
 
@@ -91,6 +123,13 @@ CoverageRingEdges::build()
                 addRingEdges(hole, nodes, boundarySegs, uniqueEdgeMap);
             }
         }
+
+        if (progressFunction) {
+            geos::util::ProgressFunctionIteration(subProgress, i, iterCount, iNotify, notificationInterval);
+        }
+    }
+    if (progressFunction) {
+        (*progressFunction)(1.0, nullptr);
     }
 }
 
@@ -254,54 +293,117 @@ CoverageRingEdges::next(std::size_t index, const CoordinateSequence& ring)
 
 /* private */
 Coordinate::UnorderedSet
-CoverageRingEdges::findMultiRingNodes(const std::vector<const Geometry*>& coverage)
+CoverageRingEdges::findMultiRingNodes(const std::vector<const Geometry*>& coverage,
+                                      geos::util::ProgressFunction* progressFunction)
 {
     std::map<Coordinate, std::size_t> vertexRingCount;
-    VertexRingCounter::count(coverage, vertexRingCount);
+    geos::util::ProgressFunction subProgress;
+    if (progressFunction)
+    {
+        subProgress = geos::util::CreateScaledProgressFunction(
+            0, 0.5, *progressFunction);
+    }
+
+    VertexRingCounter::count(coverage, vertexRingCount, progressFunction ? &subProgress : nullptr);
     Coordinate::UnorderedSet nodes;
     // for (Coordinate v : vertexCount.keySet()) {
     //     if (vertexCount.get(v) > 2) {
     //         nodes.add(v);
     //     }
     // }
+    const size_t iterCount = vertexRingCount.size();
+    const size_t notificationInterval = std::max<size_t>(1, iterCount / 100);
+    size_t i = 0, iNotify = 0;
+    if (progressFunction)
+    {
+        subProgress = geos::util::CreateScaledProgressFunction(
+            0.5, 1.0, *progressFunction);
+    }
     for (const auto &mapPair : vertexRingCount) {
         const Coordinate& v = mapPair.first;
         std::size_t count = mapPair.second;
         if (count > 2)
             nodes.insert(v);
+        if (progressFunction) {
+            geos::util::ProgressFunctionIteration(subProgress, i, iterCount, iNotify, notificationInterval);
+        }
+        ++i;
+    }
+    if (progressFunction) {
+        (*progressFunction)(1.0, nullptr);
     }
     return nodes;
 }
 
 
 /* private */
 Coordinate::UnorderedSet
-CoverageRingEdges::findBoundaryNodes(LineSegment::UnorderedSet& boundarySegments)
+CoverageRingEdges::findBoundaryNodes(LineSegment::UnorderedSet& boundarySegments,
+                                     geos::util::ProgressFunction* progressFunction)
 {
     std::unordered_map<Coordinate, std::size_t, Coordinate::HashCode> counter;
-    for (const LineSegment& seg : boundarySegments) {
-        counter[seg.p0] += 1;
-        counter[seg.p1] += 1;
+    geos::util::ProgressFunction subProgress;
+    if (progressFunction)
+    {
+        subProgress = geos::util::CreateScaledProgressFunction(
+            0, 0.5, *progressFunction);
+    }
+    {
+        const size_t iterCount = boundarySegments.size();
+        const size_t notificationInterval = std::max<size_t>(1, iterCount / 100);
+        size_t i = 0, iNotify = 0;
+        for (const LineSegment& seg : boundarySegments) {
+            counter[seg.p0] += 1;
+            counter[seg.p1] += 1;
+            if (progressFunction) {
+                geos::util::ProgressFunctionIteration(subProgress, i, iterCount, iNotify, notificationInterval);
+            }
+            ++i;
+        }
     }
 
+    if (progressFunction)
+    {
+        subProgress = geos::util::CreateScaledProgressFunction(
+            0.5, 1.0, *progressFunction);
+    }
     Coordinate::UnorderedSet nodes;
+    const size_t iterCount = counter.size();
+    const size_t notificationInterval = std::max<size_t>(1, iterCount / 100);
+    size_t i = 0, iNotify = 0;
     for (const auto& c : counter) {
         const Coordinate& v = c.first;
         std::size_t count = c.second;
         if (count > 2)
             nodes.insert(v);
+        if (progressFunction) {
+            geos::util::ProgressFunctionIteration(subProgress, i, iterCount, iNotify, notificationInterval);
+        }
+        ++i;
+    }
+    if (progressFunction) {
+        (*progressFunction)(1.0, nullptr);
     }
     return nodes;
 }
 
 
 /* public */
 std::vector<std::unique_ptr<Geometry>>
-CoverageRingEdges::buildCoverage() const
+CoverageRingEdges::buildCoverage(geos::util::ProgressFunction* progressFunction) const
 {
     std::vector<std::unique_ptr<Geometry>> result;
-    for (const Geometry* geom : m_coverage) {
+    const size_t iterCount = m_coverage.size();
+    const size_t notificationInterval = std::max<size_t>(1, iterCount / 100);
+    for (size_t i = 0, iNotify = 0; i < iterCount; ++i) {
+        const Geometry* geom = m_coverage[i];
         result.push_back(buildPolygonal(geom));
+        if (progressFunction) {
+            geos::util::ProgressFunctionIteration(*progressFunction, i, iterCount, iNotify, notificationInterval);
+        }
+    }
+    if (progressFunction) {
+        (*progressFunction)(1.0, nullptr);
     }
     return result;
 }