@cpp.js/package-geos 1.0.0-beta.20

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e/Headers/geos/coverage/CoveragePolygonValidator.h

@@ -0,0 +1,381 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2022 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/noding/BasicSegmentString.h>
+#include <geos/geom/LineSegment.h>
+#include <geos/algorithm/locate/IndexedPointInAreaLocator.h>
+#include <geos/coverage/CoveragePolygon.h>
+#include <geos/coverage/CoverageRing.h>
+
+#include <unordered_map>
+#include <map>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class Envelope;
+class Geometry;
+class GeometryFactory;
+}
+}
+
+using geos::geom::Coordinate;
+using geos::geom::Envelope;
+using geos::geom::Geometry;
+using geos::geom::GeometryFactory;
+using geos::geom::LineSegment;
+using geos::algorithm::locate::IndexedPointInAreaLocator;
+
+namespace geos {      // geos
+namespace coverage { // geos::coverage
+
+
+/**
+ * Validates that a polygon forms a valid polygonal coverage
+ * with the set of polygons adjacent to it.
+ * If the polygon is coverage-valid an empty {@link geos::geom::LineString} is returned.
+ * Otherwise, the result is a linear geometry containing
+ * the polygon boundary linework causing the invalidity.
+ *
+ * A polygon is coverage-valid if:
+ *
+ *   * The polygon interior does not intersect the interior of other polygons.
+ *   * If the polygon boundary intersects another polygon boundary, the vertices
+ *     and line segments of the intersection match exactly.
+ *
+ * The algorithm detects the following coverage errors:
+ *
+ *   * the polygon is a duplicate of another one
+ *   * a polygon boundary segment equals an adjacent segment (with same orientation).
+ *     This determines that the polygons overlap
+ *   * a polygon boundary segment is collinear and overlaps an adjacent segment
+ *     but is not equal to it
+ *   * a polygon boundary segment touches an adjacent segment at a non-vertex point
+ *   * a polygon boundary segment crosses into an adjacent polygon
+ *   * a polygon boundary segment is in the interior of an adjacent polygon
+ *
+ * If any of these errors is present, the target polygon
+ * does not form a valid coverage with the adjacent polygons.
+ *
+ * The validity rules do not preclude gaps between coverage polygons.
+ * However, this class can detect narrow gaps,
+ * by specifying a maximum gap width using {@link #setGapWidth(double)}.
+ * Note that this will also identify narrow gaps separating disjoint coverage regions,
+ * and narrow gores.
+ * In some situations it may also produce false positives
+ * (i.e. linework identified as part of a gap which is wider than the given width).
+ * To fully identify gaps it maybe necessary to use {@link CoverageUnion} and analyze
+ * the holes in the result to see if they are acceptable.
+ *
+ * A polygon may be coverage-valid with respect to
+ * a set of surrounding polygons, but the collection as a whole may not
+ * form a clean coverage.  For example, the target polygon boundary may be fully matched
+ * by adjacent boundary segments, but the adjacent set contains polygons
+ * which are not coverage-valid relative to other ones in the set.
+ * A coverage is valid only if every polygon in the coverage is coverage-valid.
+ * Use {@link CoverageValidator} to validate an entire set of polygons.
+ *
+ * The adjacent set may contain polygons which do not intersect the target polygon.
+ * These are effectively ignored during validation (but may decrease performance).
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL CoveragePolygonValidator {
+
+private:
+
+    /**
+    * Models a segment in a CoverageRing.
+    * The segment is normalized so it can be compared with segments
+    * in any orientation.
+    * Records valid matching segments in a coverage,
+    * which must have opposite orientations.
+    * Also detects equal segments with identical
+    * orientation, and marks them as coverage-invalid.
+    */
+    class CoverageRingSegment : public LineSegment
+    {
+        public:
+
+            // Members
+            CoverageRing* ringForward;
+            std::size_t indexForward;
+            CoverageRing* ringOpp;
+            std::size_t indexOpp;
+
+            CoverageRingSegment(
+                const Coordinate& p_p0, const Coordinate& p_p1,
+                CoverageRing* p_ring, std::size_t p_index)
+                : LineSegment(p_p0, p_p1)
+                , ringForward(nullptr)
+                , indexForward(0)
+                , ringOpp(nullptr)
+                , indexOpp(0)
+            {
+                if (p_p1.compareTo(p_p0) < 0) {
+                    reverse();
+                    ringOpp = p_ring;
+                    indexOpp = p_index;
+                }
+                else {
+                    ringForward = p_ring;
+                    indexForward = p_index;
+                }
+            };
+
+            void match(const CoverageRingSegment* seg) {
+                bool isInvalid = checkInvalid(seg);
+                if (isInvalid) {
+                    return;
+                }
+                //-- record the match
+                if (ringForward == nullptr) {
+                    ringForward = seg->ringForward;
+                    indexForward = seg->indexForward;
+                }
+                else {
+                    ringOpp = seg->ringOpp;
+                    indexOpp = seg->indexOpp;
+                }
+                //-- mark ring segments as matched
+                ringForward->markMatched(indexForward);
+                ringOpp->markMatched(indexOpp);
+            }
+
+            bool checkInvalid(const CoverageRingSegment* seg) const {
+                if (ringForward != nullptr && seg->ringForward != nullptr) {
+                    ringForward->markInvalid(indexForward);
+                    seg->ringForward->markInvalid(seg->indexForward);
+                    return true;
+                }
+                if (ringOpp != nullptr && seg->ringOpp != nullptr) {
+                    ringOpp->markInvalid(indexOpp);
+                    seg->ringOpp->markInvalid(seg->indexOpp);
+                    return true;
+                }
+                return false;
+            }
+
+            struct CoverageRingSegHash {
+                std::size_t
+                operator() (CoverageRingSegment const* s) const {
+                    std::size_t h = std::hash<double>{}(s->p0.x);
+                    h ^= (std::hash<double>{}(s->p0.y) << 1);
+                    h ^= (std::hash<double>{}(s->p1.x) << 1);
+                    return h ^ (std::hash<double>{}(s->p1.y) << 1);
+                }
+            };
+
+            struct CoverageRingSegEq {
+                bool
+                operator() (CoverageRingSegment const* lhs, CoverageRingSegment const* rhs) const {
+                    return lhs->p0.x == rhs->p0.x
+                        && lhs->p0.y == rhs->p0.y
+                        && lhs->p1.x == rhs->p1.x
+                        && lhs->p1.y == rhs->p1.y;
+                }
+            };
+
+    };
+
+    // Members
+    const Geometry* targetGeom;
+    std::vector<const Geometry*> adjGeoms;
+    //std::vector<const Polygon*> m_adjPolygons;
+    const GeometryFactory* geomFactory;
+    double gapWidth = 0.0;
+    std::vector<std::unique_ptr<CoveragePolygon>> m_adjCovPolygons;
+    std::deque<CoverageRing> coverageRingStore;
+    std::vector<std::unique_ptr<CoordinateSequence>> localCoordinateSequences;
+    std::deque<CoverageRingSegment> coverageRingSegmentStore;
+
+    typedef std::unordered_map<CoverageRingSegment*, CoverageRingSegment*, CoverageRingSegment::CoverageRingSegHash, CoverageRingSegment::CoverageRingSegEq> CoverageRingSegmentMap;
+
+    // Declare type as noncopyable
+    CoveragePolygonValidator(const CoveragePolygonValidator& other) = delete;
+    CoveragePolygonValidator& operator=(const CoveragePolygonValidator& rhs) = delete;
+
+public:
+
+    /**
+    * Validates that a polygon is coverage-valid  against the
+    * surrounding polygons in a polygonal coverage.
+    *
+    * @param targetPolygon the polygon to validate
+    * @param adjPolygons the adjacent polygons
+    * @return a linear geometry containing the segments causing invalidity (if any)
+    */
+    static std::unique_ptr<Geometry> validate(
+        const Geometry* targetPolygon,
+        std::vector<const Geometry*>& adjPolygons);
+
+    /**
+    * Validates that a polygon is coverage-valid against the
+    * surrounding polygons in a polygonal coverage,
+    * and forms no gaps narrower than a specified width.
+    * <p>
+    * The set of surrounding polygons should include all polygons which
+    * are within the gap width distance of the target polygon.
+    *
+    * @param targetPolygon the polygon to validate
+    * @param adjPolygons a collection of the adjacent polygons
+    * @param gapWidth the maximum width of invalid gaps
+    * @return a linear geometry containing the segments causing invalidity (if any)
+    */
+    static std::unique_ptr<Geometry> validate(
+        const Geometry* targetPolygon,
+        std::vector<const Geometry*>& adjPolygons,
+        double gapWidth);
+
+    /**
+    * Create a new validator.
+    *
+    * If the gap width is specified, the set of surrounding polygons
+    * should include all polygons which
+    * are within the gap width distance of the target polygon.
+    *
+    * @param targetPolygon the geometry to validate
+    * @param adjPolygons the adjacent polygons in the polygonal coverage
+    */
+    CoveragePolygonValidator(
+        const Geometry* targetPolygon,
+        std::vector<const Geometry*>& adjPolygons);
+
+    /**
+    * Sets the maximum gap width, if narrow gaps are to be detected.
+    *
+    * @param p_gapWidth the maximum width of gaps to detect
+    */
+    void setGapWidth(double p_gapWidth);
+
+    /**
+    * Validates the coverage polygon against the set of adjacent polygons
+    * in the coverage.
+    *
+    * @return a linear geometry containing the segments causing invalidity (if any)
+    */
+    std::unique_ptr<Geometry> validate();
+
+private:
+
+    static std::vector<std::unique_ptr<CoveragePolygon>> 
+        toCoveragePolygons(const std::vector<const Polygon*> polygons);
+    static std::vector<const Polygon*> extractPolygons(std::vector<const Geometry*>& geoms);
+
+    /* private */
+    std::unique_ptr<Geometry> createEmptyResult();
+
+    /**
+    * Marks matched segments.
+    * This improves the efficiency of validity testing, since in valid coverages
+    * all segments (except exterior ones) are matched,
+    * and hence do not need to be tested further.
+    * Segments which are equal and have same orientation
+    * are detected and marked invalid.
+    * In fact, the entire target polygon may be matched and valid,
+    * which allows avoiding further tests.
+    * Segments matched between adjacent polygons are also marked valid,
+    * since this prevents them from being detected as misaligned,
+    * if this is being done.
+    *
+    * @param targetRings the target rings
+    * @param adjRings the adjacent rings
+    * @param targetEnv the tolerance envelope of the target
+    */
+    void markMatchedSegments(
+        std::vector<CoverageRing*>& targetRings,
+        std::vector<CoverageRing*>& adjRings,
+        const Envelope& targetEnv);
+
+    /**
+    * Adds ring segments to the segment map,
+    * and detects if they match an existing segment.
+    * Matched segments are marked.
+    *
+    * @param rings
+    * @param envLimit
+    * @param segmentMap
+    */
+    void markMatchedSegments(
+        std::vector<CoverageRing*>& rings,
+        const Envelope& envLimit,
+        CoverageRingSegmentMap& segmentMap);
+
+    CoverageRingSegment* createCoverageRingSegment(
+        CoverageRing* ring, std::size_t index);
+
+    /**
+    * Marks invalid target segments which cross an adjacent ring segment,
+    * lie partially in the interior of an adjacent ring,
+    * or are nearly collinear with an adjacent ring segment up to the distance tolerance
+    *
+    * @param targetRings the rings with segments to test
+    * @param adjRings the adjacent rings
+    * @param distanceTolerance the gap distance tolerance, if any
+    */
+    void markInvalidInteractingSegments(
+        std::vector<CoverageRing*>& targetRings,
+        std::vector<CoverageRing*>& adjRings,
+        double distanceTolerance);
+
+    /**
+    * Marks invalid target segments which are fully interior
+    * to an adjacent polygon.
+    *
+    * @param targetRings the rings with segments to test
+    * @param adjCovPolygons the adjacent polygons
+    */
+    void markInvalidInteriorSegments(
+        std::vector<CoverageRing*>& targetRings,
+        std::vector<std::unique_ptr<CoveragePolygon>>& adjCovPolygons);
+
+    void markInvalidInteriorSection(
+        CoverageRing& ring,
+        std::size_t iStart, 
+        std::size_t iEnd, 
+        std::vector<std::unique_ptr<CoveragePolygon>>& adjCovPolygons );
+
+    void markInvalidInteriorSegment(
+        CoverageRing& ring, std::size_t i, CoveragePolygon* adjPoly);
+
+    void checkTargetRings(
+        std::vector<CoverageRing*>& targetRings,
+        std::vector<CoverageRing*>& adjRngs,
+        const Envelope& targetEnv);
+
+    std::unique_ptr<Geometry> createInvalidLines(std::vector<CoverageRing*>& rings);
+
+    std::vector<CoverageRing*> createRings(const Geometry* geom);
+
+    std::vector<CoverageRing*> createRings(std::vector<const Polygon*>& polygons);
+
+    void createRings(const Polygon* poly, std::vector<CoverageRing*>& rings);
+
+    void addRing(
+        const LinearRing* ring,
+        bool isShell,
+        std::vector<CoverageRing*>& rings);
+
+    CoverageRing* createRing(const LinearRing* ring, bool isShell);
+
+
+
+};
+
+} // namespace geos::coverage
+} // namespace geos

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e/Headers/geos/coverage/CoverageRing.h

@@ -0,0 +1,205 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2022 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/noding/BasicSegmentString.h>
+
+#include <deque>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class CoordinateSequence;
+class Geometry;
+class GeometryFactory;
+class LineString;
+class LinearRing;
+class Polygon;
+}
+}
+
+using geos::geom::Coordinate;
+using geos::geom::CoordinateSequence;
+using geos::geom::Geometry;
+using geos::geom::GeometryFactory;
+using geos::geom::Polygon;
+using geos::geom::LineString;
+using geos::geom::LinearRing;
+
+namespace geos {      // geos.
+namespace coverage { // geos.coverage
+
+class GEOS_DLL CoverageRing : public noding::BasicSegmentString {
+
+private:
+
+    // Members
+    bool m_isInteriorOnRight;
+    std::vector<bool> m_isInvalid;
+    std::vector<bool> m_isMatched;
+
+    std::size_t findInvalidStart(std::size_t index);
+
+    std::size_t findInvalidEnd(std::size_t index);
+
+    std::size_t nextMarkIndex(std::size_t index);
+
+    /**
+    * Creates a line from a sequence of ring segments between startIndex and endIndex (inclusive).
+    * If the endIndex < startIndex the sequence wraps around the ring endpoint.
+    *
+    * @param startIndex
+    * @param endIndex
+    * @param geomFactory
+    * @return a line representing the section
+    */
+    std::unique_ptr<LineString> createLine(
+        std::size_t startIndex,
+        std::size_t endIndex,
+        const GeometryFactory* geomFactory);
+
+    std::unique_ptr<CoordinateSequence> extractSection(
+        std::size_t startIndex, std::size_t endIndex);
+
+    std::unique_ptr<CoordinateSequence> extractSectionWrap(
+        std::size_t startIndex, std::size_t endIndex);
+
+public:
+
+    CoverageRing(CoordinateSequence* pts, bool interiorOnRight);
+
+    CoverageRing(const LinearRing* ring, bool isShell);
+
+    geom::Envelope getEnvelope(std::size_t start, std::size_t end);
+
+    /**
+    * Tests if all rings have known status (matched or invalid)
+    * for all segments.
+    *
+    * @param rings a list of rings
+    * @return true if all ring segments have known status
+    */
+    static bool isKnown(std::vector<CoverageRing*>& rings);
+
+    /**
+    * Reports if the ring has canonical orientation,
+    * with the polygon interior on the right (shell is CW).
+    *
+    * @return true if the polygon interior is on the right
+    */
+    bool isInteriorOnRight() const;
+
+    /**
+    * Marks a segment as invalid.
+    *
+    * @param i the segment index
+    */
+    void markInvalid(std::size_t index);
+
+    /**
+    * Marks a segment as matched.
+    *
+    * @param i the segment index
+    */
+    void markMatched(std::size_t index);
+
+    /**
+    * Tests if all segments in the ring have known status
+    * (matched or invalid).
+    *
+    * @return true if all segments have known status
+    */
+    bool isKnown() const;
+
+    /**
+    * Tests if a segment is marked invalid.
+    *
+    * @param index the segment index
+    * @return true if the segment is invalid
+    */
+    bool isInvalid(std::size_t i) const;
+
+    /**
+    * Tests whether all segments are invalid.
+    *
+    * @return true if all segments are invalid
+    */
+    bool isInvalid() const;
+
+    /**
+    * Tests whether any segment is invalid.
+    *
+    * @return true if some segment is invalid
+    */
+    bool hasInvalid() const;
+
+    /**
+    * Tests whether the validity state of a ring segment is known.
+    *
+    * @param i the index of the ring segment
+    * @return true if the segment validity state is known
+    */
+    bool isKnown(std::size_t i) const;
+
+    /**
+    * Finds the previous vertex in the ring which is distinct
+    * from a given coordinate value.
+    *
+    * @param index the index to start the search
+    * @param pt a coordinate value (which may not be a ring vertex)
+    * @return the previous distinct vertex in the ring
+    */
+    const Coordinate& findVertexPrev(std::size_t index, const Coordinate& pt) const;
+
+    /**
+    * Finds the next vertex in the ring which is distinct
+    * from a given coordinate value.
+    *
+    * @param index the index to start the search
+    * @param pt a coordinate value (which may not be a ring vertex)
+    * @return the next distinct vertex in the ring
+    */
+    const Coordinate& findVertexNext(std::size_t index, const Coordinate& pt) const;
+
+    /**
+    * Gets the index of the previous segment in the ring.
+    *
+    * @param index a segment index
+    * @return the index of the previous segment
+    */
+    std::size_t prev(std::size_t index) const;
+
+    /**
+    * Gets the index of the next segment in the ring.
+    *
+    * @param index a segment index
+    * @return the index of the next segment
+    */
+    std::size_t next(std::size_t index) const;
+
+    void createInvalidLines(
+        const GeometryFactory* geomFactory,
+        std::vector<std::unique_ptr<LineString>>& lines);
+
+};
+
+} // namespace geos.coverage
+} // namespace geos
+
+
+
+
+