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

package/geos.xcframework/ios-arm64_arm64e/Headers/geos/operation/valid/IndexedNestedPolygonTester.h

@@ -1,111 +0,0 @@
-/**********************************************************************
- *
- * 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 parameter 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/geos.xcframework/ios-arm64_arm64e/Headers/geos/operation/valid/IsSimpleOp.h

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

package/geos.xcframework/ios-arm64_arm64e/Headers/geos/operation/valid/IsValidOp.h

@@ -1,307 +0,0 @@
-/**********************************************************************
- *
- * 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/operation/valid/PolygonTopologyAnalyzer.h>
-#include <geos/operation/valid/TopologyValidationError.h>
-#include <geos/util.h>
-
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class CoordinateXY;
-class Geometry;
-class Point;
-class MultiPoint;
-class LineString;
-class LinearRing;
-class Polygon;
-class MultiPolygon;
-class GeometryCollection;
-}
-namespace algorithm {
-namespace locate {
-class IndexedPointInAreaLocator;
-}
-}
-}
-
-
-namespace geos {      // geos.
-namespace operation { // geos.operation
-namespace valid {     // geos.operation.valid
-
-/**
- * Implements the algorithms required to compute the <code>isValid()</code> method
- * for Geometry.
- * See the documentation for the various geometry types for a specification of validity.
- *
- * @version 1.7
- */
-class GEOS_DLL IsValidOp {
-
-private:
-
-    static constexpr int MIN_SIZE_LINESTRING = 2;
-    static constexpr int MIN_SIZE_RING = 4;
-
-    /**
-    * The geometry being validated
-    */
-    const geom::Geometry* inputGeometry;
-    /**
-    * If the following condition is true GEOS will validate
-    * inverted shells and exverted holes (the ESRI SDE model)
-    */
-    bool isInvertedRingValid = false;
-    std::unique_ptr<TopologyValidationError> validErr;
-
-    bool hasInvalidError()
-    {
-        return validErr != nullptr;
-    }
-
-    void logInvalid(int code, const geom::CoordinateXY& pt);
-
-    bool isValidGeometry(const geom::Geometry* g);
-
-    /**
-     * Tests validity of a Point.
-     */
-    bool isValid(const geom::Point* g);
-
-    /**
-     * Tests validity of a MultiPoint.
-     */
-    bool isValid(const geom::MultiPoint* g);
-
-    /**
-     * Tests validity of a LineString.
-     * Almost anything goes for linestrings!
-     */
-    bool isValid(const geom::LineString* g);
-
-    /**
-     * Tests validity of a LinearRing.
-     */
-    bool isValid(const geom::LinearRing* g);
-
-    /**
-     * Tests the validity of a polygon.
-     * Sets the validErr flag.
-     */
-    bool isValid(const geom::Polygon* g);
-
-    /**
-     * Tests validity of a MultiPolygon.
-     *
-     * @param g
-     * @return
-     */
-    bool isValid(const geom::MultiPolygon* g);
-
-    /**
-     * Tests validity of a GeometryCollection.
-     *
-     * @param gc
-     * @return
-     */
-    bool isValid(const geom::GeometryCollection* gc);
-
-    void checkCoordinatesValid(const geom::CoordinateSequence* coords);
-    void checkCoordinatesValid(const geom::Polygon* poly);
-    void checkRingClosed(const geom::LinearRing* ring);
-    void checkRingsClosed(const geom::Polygon* poly);
-    void checkRingsPointSize(const geom::Polygon* poly);
-    void checkRingPointSize(const geom::LinearRing* ring);
-
-    /**
-     * Check the number of non-repeated points is at least a given size.
-     *
-     * @param line
-     * @param minSize
-     */
-    void checkTooFewPoints(const geom::LineString* line, std::size_t minSize);
-
-    /**
-     * Test if the number of non-repeated points in a line
-     * is at least a given minimum size.
-     *
-     * @param line the line to test
-     * @param minSize the minimum line size
-     * @return true if the line has the required number of non-repeated points
-     */
-    bool isNonRepeatedSizeAtLeast(const geom::LineString* line, std::size_t minSize);
-
-    void checkAreaIntersections(PolygonTopologyAnalyzer& areaAnalyzer);
-
-    /**
-     * Check whether a ring self-intersects (except at its endpoints).
-     *
-     * @param ring the linear ring to check
-     */
-    void checkRingSimple(const geom::LinearRing* ring);
-
-
-    /**
-     * Tests that each hole is inside the polygon shell.
-     * This routine assumes that the holes have previously been tested
-     * to ensure that all vertices lie on the shell or on the same side of it
-     * (i.e. that the hole rings do not cross the shell ring).
-     * Given this, a simple point-in-polygon test of a single point in the hole can be used,
-     * provided the point is chosen such that it does not lie on the shell.
-     *
-     * @param poly the polygon to be tested for hole inclusion
-     */
-    void checkHolesInShell(const geom::Polygon* poly);
-
-    /**
-     * Checks if a polygon hole lies inside its shell
-     * and if not returns a point indicating this.
-     * The hole is known to be wholly inside or outside the shell,
-     * so it suffices to find a single point which is interior or exterior,
-     * or check the edge topology at a point on the boundary of the shell.
-     *
-     * @param hole the hole to test
-     * @param shell the polygon shell to test against
-     * @return a hole point outside the shell, or null if it is inside
-     */
-    const CoordinateXY* findHoleOutsideShellPoint(
-        const geom::LinearRing* hole,
-        const geom::LinearRing* shell);
-
-    /**
-     * Checks if any polygon hole is nested inside another.
-     * Assumes that holes do not cross (overlap),
-     * This is checked earlier.
-     *
-     * @param poly the polygon with holes to test
-     */
-    void checkHolesNotNested(const geom::Polygon* poly);
-
-    /**
-     * Checks that no element polygon is in the interior of another element polygon.
-     *
-     * Preconditions:
-     *
-     *  * shells do not partially overlap
-     *  * shells do not touch along an edge
-     *  * no duplicate rings exist
-     *
-     * These have been confirmed by the PolygonTopologyAnalyzer.
-     */
-    void checkShellsNotNested(const geom::MultiPolygon* mp);
-
-    void checkInteriorConnected(PolygonTopologyAnalyzer& areaAnalyzer);
-
-
-public:
-
-    /**
-     * Creates a new validator for a geometry.
-     *
-     * @param p_inputGeometry the geometry to validate
-     */
-    IsValidOp(const geom::Geometry* p_inputGeometry)
-        : inputGeometry(p_inputGeometry)
-        , validErr(nullptr)
-        {};
-
-    /**
-     * Sets whether polygons using <b>Self-Touching Rings</b> to form
-     * holes are reported as valid.
-     * If this flag is set, the following Self-Touching conditions
-     * are treated as being valid:
-     *
-     *  * the shell ring self-touches to create a hole touching the shell
-     *  * a hole ring self-touches to create two holes touching at a point
-     *
-     * The default (following the OGC SFS standard)
-     * is that this condition is not valid (false).
-     *
-     * Self-Touching Rings which disconnect the
-     * the polygon interior are still considered to be invalid
-     * (these are <b>invalid</b> under the SFS, and many other
-     * spatial models as well).
-     * This includes:
-     *
-     *  * exverted ("bow-tie") shells which self-touch at a single point
-     *  * inverted shells with the inversion touching the shell at another point
-     *  * exverted holes with exversion touching the hole at another point
-     *  * inverted ("C-shaped") holes which self-touch at a single point causing an island to be formed
-     *  * inverted shells or exverted holes which form part of a chain of touching rings
-     *    (which disconnect the interior)
-     *
-     * @param p_isValid states whether geometry with this condition is valid
-     */
-    void setSelfTouchingRingFormingHoleValid(bool p_isValid)
-    {
-        isInvertedRingValid = p_isValid;
-    };
-
-    /**
-     * Tests whether a Geometry is valid.
-     * @param geom the Geometry to test
-     * @return true if the geometry is valid
-     */
-    static bool isValid(const geom::Geometry* geom)
-    {
-        IsValidOp ivo(geom);
-        return ivo.isValid();
-    };
-
-    static bool isValid(const geom::CoordinateXY& coord)
-    {
-        return isValid(&coord);
-    }
-
-    /**
-     * Tests the validity of the input geometry.
-     *
-     * @return true if the geometry is valid
-     */
-    bool isValid();
-
-    /**
-     * Checks whether a coordinate is valid for processing.
-     * Coordinates are valid if their x and y ordinates are in the
-     * range of the floating point representation.
-     *
-     * @param coord the coordinate to validate
-     * @return <code>true</code> if the coordinate is valid
-     */
-    static bool isValid(const geom::CoordinateXY* coord);
-
-    /**
-     * Computes the validity of the geometry,
-     * and if not valid returns the validation error for the geometry,
-     * or null if the geometry is valid.
-     *
-     * @return the validation error, if the geometry is invalid
-     * or null if the geometry is valid
-     */
-    const TopologyValidationError* getValidationError();
-
-
-};
-
-
-} // namespace geos.operation.valid
-} // namespace geos.operation
-} // namespace geos