@cpp.js/package-geos 1.0.0 → 2.0.0-beta.1

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/coverage/CoveragePolygonValidator.h

@@ -1,381 +0,0 @@
-/**********************************************************************
- *
- * 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/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/coverage/CoverageRing.h

@@ -1,205 +0,0 @@
-/**********************************************************************
- *
- * 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
-
-
-
-
-