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

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/valid/ConsistentAreaTester.h

@@ -0,0 +1,137 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ *
+ * 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.
+ *
+ **********************************************************************
+ *
+ * Last port: operation/valid/ConsistentAreaTester.java rev. 1.14 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geom/Coordinate.h> // for composition
+#include <geos/algorithm/LineIntersector.h> // for composition
+#include <geos/operation/relate/RelateNodeGraph.h> // for composition
+
+// Forward declarations
+namespace geos {
+namespace algorithm {
+class LineIntersector;
+}
+namespace geomgraph {
+class GeometryGraph;
+}
+namespace operation {
+namespace relate {
+class RelateNodeGraph;
+}
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace valid { // geos::operation::valid
+
+/** \brief
+ * Checks that a geomgraph::GeometryGraph representing an area
+ * (a geom::Polygon or geom::MultiPolygon)
+ * has consistent semantics for area geometries.
+ * This check is required for any reasonable polygonal model
+ * (including the OGC-SFS model, as well as models which allow ring
+ * self-intersection at single points)
+ *
+ * Checks include:
+ *
+ *  - test for rings which properly intersect
+ *    (but not for ring self-intersection, or intersections at vertices)
+ *  - test for consistent labelling at all node points
+ *    (this detects vertex intersections with invalid topology,
+ *    i.e. where the exterior side of an edge lies in the interior of the area)
+ *  - test for duplicate rings
+ *
+ * If an inconsistency is found the location of the problem
+ * is recorded and is available to the caller.
+ *
+ */
+class GEOS_DLL ConsistentAreaTester {
+private:
+
+    algorithm::LineIntersector li;
+
+    /// Not owned
+    geomgraph::GeometryGraph* geomGraph;
+
+    relate::RelateNodeGraph nodeGraph;
+
+    /// the intersection point found (if any)
+    geom::Coordinate invalidPoint;
+
+    /**
+     * Check all nodes to see if their labels are consistent.
+     * If any are not, return false
+     */
+    bool isNodeEdgeAreaLabelsConsistent();
+
+public:
+
+    /**
+     * Creates a new tester for consistent areas.
+     *
+     * @param newGeomGraph the topology graph of the area geometry.
+     *                     Caller keeps responsibility for its deletion
+     */
+    ConsistentAreaTester(geomgraph::GeometryGraph* newGeomGraph);
+
+    ~ConsistentAreaTester() = default;
+
+    /**
+     * @return the intersection point, or <code>null</code>
+     *         if none was found
+     */
+    geom::Coordinate& getInvalidPoint();
+
+    /** \brief
+     * Check all nodes to see if their labels are consistent with
+     * area topology.
+     *
+     * @return <code>true</code> if this area has a consistent node
+     *         labelling
+     */
+    bool isNodeConsistentArea();
+
+    /**
+     * Checks for two duplicate rings in an area.
+     * Duplicate rings are rings that are topologically equal
+     * (that is, which have the same sequence of points up to point order).
+     * If the area is topologically consistent (determined by calling the
+     * <code>isNodeConsistentArea</code>,
+     * duplicate rings can be found by checking for EdgeBundles which contain
+     * more than one geomgraph::EdgeEnd.
+     * (This is because topologically consistent areas cannot have two rings sharing
+     * the same line segment, unless the rings are equal).
+     * The start point of one of the equal rings will be placed in
+     * invalidPoint.
+     *
+     * @return true if this area Geometry is topologically consistent but has two duplicate rings
+     */
+    bool hasDuplicateRings();
+};
+
+
+
+} // namespace geos::operation::valid
+} // namespace geos::operation
+} // namespace geos
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/valid/IndexedNestedHoleTester.h

@@ -0,0 +1,83 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021 Paul Ramsey <pramsey@cleverelephant.ca>
+ * Copyright (C) 2021 Martin Davis
+ *
+ * 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/export.h>
+#include <geos/index/strtree/TemplateSTRtree.h>
+
+#include <memory>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class Polygon;
+class LinearRing;
+}
+}
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace valid {     // geos.operation.valid
+
+using geos::geom::Polygon;
+using geos::geom::LinearRing;
+using geos::geom::CoordinateXY;
+
+
+class GEOS_DLL IndexedNestedHoleTester {
+
+private:
+
+    const Polygon* polygon;
+    index::strtree::TemplateSTRtree<const LinearRing*> index;
+    CoordinateXY nestedPt;
+
+    void loadIndex();
+
+
+public:
+
+    IndexedNestedHoleTester(const Polygon* p_polygon)
+        : polygon(p_polygon)
+    {
+        loadIndex();
+    }
+
+    /**
+    * Gets a point on a nested hole, if one exists.
+    *
+    * @return a point on a nested hole, or null if none are nested
+    */
+    const CoordinateXY& getNestedPoint() { return nestedPt; }
+
+    /**
+    * Tests if any hole is nested (contained) within another hole.
+    * This is invalid.
+    * The nested point will be set to reflect this.
+    * @return true if some hole is nested
+    */
+    bool isNested();
+
+};
+
+
+
+} // namespace geos.operation.valid
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/valid/IndexedNestedPolygonTester.h

@@ -0,0 +1,111 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021 Paul Ramsey <pramsey@cleverelephant.ca>
+ * Copyright (C) 2021 Martin Davis
+ *
+ * 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/export.h>
+#include <geos/index/strtree/TemplateSTRtree.h>
+#include <geos/algorithm/locate/IndexedPointInAreaLocator.h>
+
+#include <memory>
+#include <map>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class Polygon;
+class LinearRing;
+class MultiPolygon;
+}
+}
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace valid {     // geos.operation.valid
+
+using geos::geom::Polygon;
+using geos::geom::MultiPolygon;
+using geos::geom::LinearRing;
+using geos::geom::CoordinateXY;
+using algorithm::locate::IndexedPointInAreaLocator;
+using index::strtree::TemplateSTRtree;
+
+class GEOS_DLL IndexedNestedPolygonTester {
+
+private:
+
+    const MultiPolygon* multiPoly;
+    TemplateSTRtree<const Polygon*> index;
+    // std::vector<IndexedPointInAreaLocator> locators;
+    std::map<const Polygon*, IndexedPointInAreaLocator> locators;
+    CoordinateXY nestedPt;
+
+    void loadIndex();
+
+    IndexedPointInAreaLocator& getLocator(const Polygon* poly);
+
+    bool findNestedPoint(const LinearRing* shell,
+        const Polygon* possibleOuterPoly,
+        IndexedPointInAreaLocator& locator,
+        CoordinateXY& coordNested);
+
+    /**
+    * Finds a point of a shell segment which lies inside a polygon, if any.
+    * The shell is assume to touch the polyon only at shell vertices,
+    * and does not cross the polygon.
+    *
+    * @param the shell to test
+    * @param the polygon to test against
+    * @param coordNested return parametr for found coordinate
+    * @return an interior segment point, or null if the shell is nested correctly
+    */
+    static bool findIncidentSegmentNestedPoint(
+        const LinearRing* shell,
+        const Polygon* poly,
+        CoordinateXY& coordNested);
+
+    // Declare type as noncopyable
+    IndexedNestedPolygonTester(const IndexedNestedPolygonTester& other) = delete;
+    IndexedNestedPolygonTester& operator=(const IndexedNestedPolygonTester& rhs) = delete;
+
+public:
+
+    IndexedNestedPolygonTester(const MultiPolygon* p_multiPoly);
+
+    /**
+    * Gets a point on a nested polygon, if one exists.
+    *
+    * @return a point on a nested polygon, or null if none are nested
+    */
+    const CoordinateXY& getNestedPoint() const { return nestedPt; }
+
+    /**
+    * Tests if any polygon is nested (contained) within another polygon.
+    * This is invalid.
+    * The nested point will be set to reflect this.
+    * @return true if some polygon is nested
+    */
+    bool isNested();
+
+
+};
+
+
+
+} // namespace geos.operation.valid
+} // namespace geos.operation
+} // namespace geos

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/valid/IsSimpleOp.h

@@ -0,0 +1,299 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ * Copyright (C) 2009 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2021 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 <memory>
+
+#include <geos/algorithm/LineIntersector.h>
+#include <geos/algorithm/BoundaryNodeRule.h>
+#include <geos/noding/SegmentIntersector.h>
+
+// Forward declarations
+namespace geos {
+namespace noding {
+class SegmentString;
+class BasicSegmentString;
+}
+namespace algorithm {
+class BoundaryNodeRule;
+}
+namespace geom {
+class LineString;
+class LinearRing;
+class MultiLineString;
+class MultiPoint;
+class Geometry;
+class Polygon;
+class GeometryCollection;
+}
+}
+
+
+namespace geos {      // geos
+namespace operation { // geos.operation
+namespace valid {     // geos.operation.valid
+
+/**
+ * Tests whether a Geometry is simple as defined by the OGC SFS specification.
+ *
+ * Simplicity is defined for each geom::Geometry type as follows:
+ *
+ *   * geom::Point geometries are simple.
+ *   * geom::MultiPoint geometries are simple if every point is unique
+ *   * geom::LineString geometries are simple if they do not self-intersect at interior points
+ *     (i.e. points other than the endpoints).
+ *   * geom::MultiLineString geometries are simple if
+ *     their elements are simple and they intersect only at points
+ *     which are boundary points of both elements.
+ *     (The notion of boundary points can be user-specified - see below).
+ *   * Polygonal geometries have no definition of simplicity.
+ *     The isSimple code checks if all polygon rings are simple.
+ *     (Note: this means that isSimple cannot be used to test
+ *     for ALL self-intersections in Polygons.
+ *     In order to check if a Polygonal geometry has self-intersections,
+ *     use geom::Geometry::isValid()).
+ *   * geom::GeometryCollection geometries are simple if all their elements are simple.
+ *   * Empty geometries are simple
+ *
+ * For linear geometries the evaluation of simplicity
+ * can be customized by supplying a BoundaryNodeRule
+ * to define how boundary points are determined.
+ * The default is the SFS-standard.
+ *
+ * Note that under the Mod-2 rule, closed LineStrings (rings)
+ * have no boundary.
+ * This means that an intersection at their endpoints makes the geometry non-simple.
+ * If it is required to test whether a set of LineStrings touch
+ * only at their endpoints, use BoundaryNodeRule::getBoundaryEndPoint().
+ * For example, this can be used to validate that a collection of lines
+ * form a topologically valid linear network.
+ *
+ * By default this class finds a single non-simple location.
+ * To find all non-simple locations, set setFindAllLocations(bool)
+ * before calling isSimple(), and retrieve the locations
+ * via getNonSimpleLocations().
+ * This can be used to find all intersection points in a linear network.
+ *
+ * @see BoundaryNodeRule
+ */
+class GEOS_DLL IsSimpleOp {
+
+private:
+
+    const geom::Geometry& inputGeom;
+    bool isClosedEndpointsInInterior = true;
+    bool isFindAllLocations = false;
+    bool isSimpleResult = false;
+    std::vector<geom::CoordinateXY> nonSimplePts;
+    bool computed = false;
+
+    void compute();
+
+    bool computeSimple(const geom::Geometry& geom);
+
+    bool isSimpleMultiPoint(const geom::MultiPoint& mp);
+
+    /**
+    * Computes simplicity for polygonal geometries.
+    * Polygonal geometries are simple if and only if
+    * all of their component rings are simple.
+    *
+    * @param geom a Polygonal geometry
+    * @return true if the geometry is simple
+    */
+    bool isSimplePolygonal(const geom::Geometry& geom);
+
+    /**
+    * Semantics for GeometryCollection is
+    * simple iff all components are simple.
+    *
+    * @param geom
+    * @return true if the geometry is simple
+    */
+    bool isSimpleGeometryCollection(const geom::Geometry& geom);
+
+    bool isSimpleLinearGeometry(const geom::Geometry& geom);
+
+    static std::vector<std::unique_ptr<geos::geom::CoordinateSequence>>
+        removeRepeatedPts(const geom::Geometry& geom);
+
+    static std::vector<std::unique_ptr<noding::SegmentString>>
+        createSegmentStrings(std::vector<std::unique_ptr<geos::geom::CoordinateSequence>>& seqs);
+
+    class NonSimpleIntersectionFinder : public noding::SegmentIntersector
+    {
+
+    private:
+
+        bool isClosedEndpointsInInterior;
+        bool isFindAll = false;
+
+        std::vector<geom::CoordinateXY>& intersectionPts;
+        algorithm::LineIntersector li;
+
+        // bool hasInteriorInt;
+        // bool hasInteriorVertexInt;
+        // bool hasEqualSegments;
+        // bool hasInteriorEndpointInt;
+
+        bool findIntersection(
+            noding::SegmentString* ss0, std::size_t segIndex0,
+            noding::SegmentString* ss1, std::size_t segIndex1,
+            const geom::CoordinateXY& p00, const geom::CoordinateXY& p01,
+            const geom::CoordinateXY& p10, const geom::CoordinateXY& p11);
+
+        /**
+        * Tests whether an intersection vertex is an endpoint of a segment string.
+        *
+        * @param ss the segmentString
+        * @param ssIndex index of segment in segmentString
+        * @param li the line intersector
+        * @param liSegmentIndex index of segment in intersector
+        * @return true if the intersection vertex is an endpoint
+        */
+        bool isIntersectionEndpoint(
+            const noding::SegmentString* ss, std::size_t ssIndex,
+            const algorithm::LineIntersector& li, std::size_t liSegmentIndex) const;
+
+        /**
+        * Finds the vertex index in a segment of an intersection
+        * which is known to be a vertex.
+        *
+        * @param li the line intersector
+        * @param segmentIndex the intersection segment index
+        * @return the vertex index (0 or 1) in the segment vertex of the intersection point
+        */
+        std::size_t intersectionVertexIndex(
+            const algorithm::LineIntersector& li, std::size_t segmentIndex) const;
+
+    public:
+
+        NonSimpleIntersectionFinder(
+            bool p_isClosedEndpointsInInterior,
+            bool p_isFindAll,
+            std::vector<geom::CoordinateXY>& p_intersectionPts)
+        : isClosedEndpointsInInterior(p_isClosedEndpointsInInterior)
+        , isFindAll(p_isFindAll)
+        , intersectionPts(p_intersectionPts)
+        {};
+
+        /**
+        * Tests whether an intersection was found.
+        *
+        * @return true if an intersection was found
+        */
+        bool hasIntersection() const;
+
+        void processIntersections(
+            noding::SegmentString* ss0, std::size_t segIndex0,
+            noding::SegmentString* ss1, std::size_t segIndex1) override;
+
+        bool isDone() const override;
+
+    }; // NonSimpleIntersectionFinder
+
+
+public:
+
+    IsSimpleOp(const geom::Geometry* geom)
+        : IsSimpleOp(*geom)
+        {};
+
+    /**
+    * Creates a simplicity checker using the default SFS Mod-2 Boundary Node Rule
+    *
+    * @param geom the geometry to test
+    */
+    IsSimpleOp(const geom::Geometry& geom)
+        : IsSimpleOp(geom, algorithm::BoundaryNodeRule::getBoundaryRuleMod2())
+        {};
+
+    /**
+    * Creates a simplicity checker using a given {@link algorithm::BoundaryNodeRule}
+    *
+    * @param geom the geometry to test
+    * @param p_boundaryNodeRule the boundary node rule to use.
+    */
+    IsSimpleOp(const geom::Geometry& geom, const algorithm::BoundaryNodeRule& p_boundaryNodeRule)
+        : inputGeom(geom)
+        , isClosedEndpointsInInterior(! p_boundaryNodeRule.isInBoundary(2))
+        , isFindAllLocations(false)
+        , computed(false)
+        {};
+
+    /**
+    * Tests whether a geometry is simple.
+    *
+    * @param geom the geometry to test
+    * @return true if the geometry is simple
+    */
+    static bool isSimple(const geom::Geometry& geom);
+
+    static bool isSimple(const geom::Geometry* geom) {
+        if (!geom) return false;
+        return isSimple(*geom);
+    }
+
+    /**
+    * Gets a non-simple location in a geometry, if any.
+    *
+    * @param geom the input geometry
+    * @return a non-simple location, or null if the geometry is simple
+    */
+    geom::CoordinateXY getNonSimpleLocation(const geom::Geometry& geom);
+
+    /**
+    * Sets whether all non-simple intersection points
+    * will be found.
+    *
+    * @param isFindAll whether to find all non-simple points
+    */
+    void setFindAllLocations(bool isFindAll);
+
+    /**
+    * Tests whether the geometry is simple.
+    *
+    * @return true if the geometry is simple
+    */
+    bool isSimple();
+
+    /**
+    * Gets the coordinate for an location where the geometry
+    * fails to be simple.
+    * (i.e. where it has a non-boundary self-intersection).
+    *
+    * @return a coordinate for the location of the non-boundary self-intersection
+    * or null if the geometry is simple
+    */
+    geom::CoordinateXY getNonSimpleLocation();
+
+    /**
+    * Gets all non-simple intersection locations.
+    *
+    * @return a list of the coordinates of non-simple locations
+    */
+    const std::vector<geom::CoordinateXY>& getNonSimpleLocations();
+
+
+
+}; // IsSimpleOp
+
+
+} // namespace geos.operation.valid
+} // namespace geos.operation
+} // namespace geos