CoverageCleaner.h

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (c) 2025 Martin Davis
 * Copyright (C) 2025 Paul Ramsey <pramsey@cleverelephant.ca>
 *
 * 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 <geos/index/strtree/TemplateSTRtree.h>
#include <geos/coverage/CleanCoverage.h>
#include <geos/geom/Envelope.h>
#include <geos/constants.h>
#include <geos/export.h>
 
#include <vector>
#include <memory>
#include <map>
 
 
// Forward declarations
namespace geos {
namespace geom {
    class Coordinate;
    class CoordinateSequence;
    class Geometry;
    class GeometryFactory;
    class LineString;
    class LinearRing;
    class Polygon;
}
namespace index {
}
namespace noding {
    class SegmentString;
}
namespace coverage {
    class CleanCoverage;
}
}
 
namespace geos {         // geos.
namespace coverage { // geos.coverage
 
 
class GEOS_DLL CoverageCleaner {
 
    using Coordinate = geos::geom::Coordinate;
    using CoordinateSequence = geos::geom::CoordinateSequence;
    using Geometry = geos::geom::Geometry;
    using GeometryFactory = geos::geom::GeometryFactory;
    using Point = geos::geom::Point;
    using Polygon = geos::geom::Polygon;
    using LineString = geos::geom::LineString;
    using LinearRing = geos::geom::LinearRing;
    using Envelope = geos::geom::Envelope;
    using SegmentString = geos::noding::SegmentString;
 
public:
 
    static constexpr int MERGE_LONGEST_BORDER = 0;
    static constexpr int MERGE_MAX_AREA       = 1;
    static constexpr int MERGE_MIN_AREA       = 2;
    static constexpr int MERGE_MIN_INDEX      = 3;
 
private:
 
    std::vector<const Geometry*> coverage;
    const GeometryFactory* geomFactory;
    double snappingDistance;
 
    double gapMaximumWidth = 0.0;
    int overlapMergeStrategy = MERGE_LONGEST_BORDER;
    std::unique_ptr<index::strtree::TemplateSTRtree<std::size_t>> covIndex;
    std::vector<std::unique_ptr<Polygon>> resultants;
    std::unique_ptr<CleanCoverage> cleanCov;
    std::map<std::size_t, std::vector<std::size_t>> overlapParentMap;
    std::vector<const Polygon*> overlaps;
    std::vector<const Polygon*> gaps;
    std::vector<const Polygon*> mergableGaps;
 
    static constexpr double DEFAULT_SNAPPING_FACTOR = 1.0e8;
 
 
    static double computeDefaultSnappingDistance(
        std::vector<const Geometry*>& geoms);
 
    static Envelope extent(std::vector<const Geometry*>& geoms);
 
    void mergeOverlaps(
        std::map<std::size_t, std::vector<std::size_t>>& overlapMap);
 
    std::unique_ptr<CleanCoverage::MergeStrategy> mergeStrategy(
        int mergeStrategyId);
 
    void computeResultants(double tolerance);
 
    void createCoverageIndex();
 
    void classifyResult(std::vector<std::unique_ptr<Polygon>>& rs);
 
    void classifyResultant(std::size_t resultIndex, const Polygon* resPoly);
 
    static bool covers(const Geometry* poly, const Point* intPt);
 
    std::vector<const Polygon*> findMergableGaps(
        std::vector<const Polygon*> gaps);
 
    bool isMergableGap(const Polygon* gap);
 
    static std::vector<std::unique_ptr<geom::Polygon>> polygonize(
        const Geometry* cleanEdges);
 
    static bool isPolygonal(const Geometry* geom);
 
    static std::vector<const Polygon*> toPolygonArray(
        const Geometry* geom);
 
 
public:
 
    CoverageCleaner(std::vector<const Geometry*>& coverage);
 
    static std::vector<std::unique_ptr<Geometry>> clean(
        std::vector<const Geometry*>& coverage,
        double snapDistance,
        int mergeStrategy,
        double maxWidth);
 
    static std::vector<std::unique_ptr<Geometry>> clean(
        std::vector<const Geometry*>& coverage,
        double snapDistance,
        double maxWidth);
 
    static std::vector<std::unique_ptr<Geometry>> cleanOverlapGap(
        std::vector<const Geometry*>& coverage,
        int mergeStrategy,
        double maxWidth);
 
    static std::vector<std::unique_ptr<Geometry>> cleanGapWidth(
        std::vector<const Geometry*>& coverage,
        double maxWidth);
 
    void setSnappingDistance(double snapDistance);
 
    void setOverlapMergeStrategy(int mergeStrategy);
 
    void setGapMaximumWidth(double maxWidth);
 
    void clean();
 
    std::vector<std::unique_ptr<Geometry>> getResult();
 
    std::vector<const Polygon*> getOverlaps();
 
    std::vector<const Polygon*> getMergedGaps();
 
    std::unique_ptr<Geometry> toGeometry(
        std::vector<SegmentString*>& segStrings,
        const GeometryFactory* geomFact);
 
    std::unique_ptr<Geometry> node(
        std::vector<const Geometry*>& coverage,
        double snapDistance);
 
    CoverageCleaner(const CoverageCleaner&) = delete;
    CoverageCleaner& operator=(const CoverageCleaner&) = delete;
 
};
 
} // namespace geos.coverage
} // namespace geos