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

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/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 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_c.xcframework/ios-arm64_arm64e_x86_64-simulator/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/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/planargraph/DirectedEdgeStar.h

@@ -1,149 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2001-2002 Vivid Solutions Inc.
- * Copyright (C) 2005-2006 Refractions Research 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.
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <vector>
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
-#endif
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Coordinate;
-}
-namespace planargraph {
-class DirectedEdge;
-class Edge;
-}
-}
-
-namespace geos {
-namespace planargraph { // geos.planargraph
-
-/// A sorted collection of DirectedEdge which leave a Node in a PlanarGraph.
-class GEOS_DLL DirectedEdgeStar {
-protected:
-
-private:
-    /**
-     * \brief The underlying list of outgoing DirectedEdges
-     */
-    mutable std::vector<DirectedEdge*> outEdges;
-    mutable bool sorted;
-    void sortEdges() const;
-
-public:
-    /**
-     * \brief Constructs a DirectedEdgeStar with no edges.
-     */
-    DirectedEdgeStar(): sorted(false) {}
-
-    virtual
-    ~DirectedEdgeStar() {}
-
-    /**
-     * \brief Adds a new member to this DirectedEdgeStar.
-     */
-    void add(DirectedEdge* de);
-
-    /**
-     * \brief Drops a member of this DirectedEdgeStar.
-     */
-    void remove(DirectedEdge* de);
-
-    /**
-     * \brief Returns an Iterator over the DirectedEdges,
-     * in ascending order by angle with the positive x-axis.
-     */
-    std::vector<DirectedEdge*>::iterator
-    iterator()
-    {
-        return begin();
-    }
-    /// Returns an iterator to first DirectedEdge
-    std::vector<DirectedEdge*>::iterator begin();
-
-    /// Returns an iterator to one-past last DirectedEdge
-    std::vector<DirectedEdge*>::iterator end();
-
-    /// Returns an const_iterator to first DirectedEdge
-    std::vector<DirectedEdge*>::const_iterator begin() const;
-
-    /// Returns an const_iterator to one-past last DirectedEdge
-    std::vector<DirectedEdge*>::const_iterator end() const;
-
-    /**
-     * \brief Returns the number of edges around the Node associated
-     * with this DirectedEdgeStar.
-     */
-    std::size_t
-    getDegree() const
-    {
-        return outEdges.size();
-    }
-
-    /**
-     * \brief Returns the coordinate for the node at wich this
-     * star is based
-     */
-    geom::Coordinate& getCoordinate() const;
-
-    /**
-     * \brief Returns the DirectedEdges, in ascending order
-     * by angle with the positive x-axis.
-     */
-    std::vector<DirectedEdge*>& getEdges();
-
-    /**
-     * \brief Returns the zero-based index of the given Edge,
-     * after sorting in ascending order by angle with the
-     * positive x-axis.
-     */
-    int getIndex(const Edge* edge);
-
-    /**
-     * \brief Returns the zero-based index of the given DirectedEdge,
-     * after sorting in ascending order
-     * by angle with the positive x-axis.
-     */
-    int getIndex(const DirectedEdge* dirEdge);
-
-    /**
-     * \brief Returns the remainder when i is divided by the number of
-     * edges in this DirectedEdgeStar.
-     */
-    unsigned int getIndex(int i) const;
-
-    /**
-     * \brief Returns the DirectedEdge on the left-hand side
-     * of the given DirectedEdge (which must be a member of this
-     * DirectedEdgeStar).
-     */
-    DirectedEdge* getNextEdge(DirectedEdge* dirEdge);
-};
-
-} // namespace geos::planargraph
-} // namespace geos
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-