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

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/geomgraph/TopologyLocation.h

@@ -0,0 +1,238 @@
+/**********************************************************************
+ *
+ * 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: geomgraph/TopologyLocation.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Location.h>
+#include <geos/geom/Position.h>
+
+#include <vector>
+#include <array>
+#include <string>
+#include <cassert>
+#include <cstdint>
+
+#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
+
+using geos::geom::Position;
+using geos::geom::Location;
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/** \brief
+ * A TopologyLocation is the labelling of a
+ * GraphComponent's topological relationship to a single Geometry.
+ *
+ * If the parent component is an area edge, each side and the edge itself
+ * have a topological location.  These locations are named
+ *
+ *  - ON: on the edge
+ *  - LEFT: left-hand side of the edge
+ *  - RIGHT: right-hand side
+ *
+ * If the parent component is a line edge or node, there is a single
+ * topological relationship attribute, ON.
+ *
+ * The possible values of a topological location are
+ * {Location::NONE, Location::EXTERIOR, Location::BOUNDARY, Location::INTERIOR}
+ *
+ * The labelling is stored in an array location[j] where
+ * where j has the values ON, LEFT, RIGHT
+ */
+class GEOS_DLL TopologyLocation {
+
+public:
+
+    friend std::ostream& operator<< (std::ostream&, const TopologyLocation&);
+
+    TopologyLocation() = default;
+
+    /** \brief
+     * Constructs a TopologyLocation specifying how points on, to the
+     * left of, and to the right of some GraphComponent relate to some
+     * Geometry.
+     *
+     * Possible values for the
+     * parameters are Location::NONE, Location::EXTERIOR, Location::BOUNDARY,
+     * and Location::INTERIOR.
+     *
+     * @see Location
+     */
+    TopologyLocation(Location on, Location left, Location right)
+        : locationSize(3)
+    {
+        location[Position::ON] = on;
+        location[Position::LEFT] = left;
+        location[Position::RIGHT] = right;
+    }
+
+    TopologyLocation(Location on)
+        : locationSize(1)
+    {
+        location.fill(Location::NONE);
+        location[Position::ON] = on;
+    };
+
+    TopologyLocation(const TopologyLocation& gl)
+        : location(gl.location)
+        , locationSize(gl.locationSize)
+        {};
+
+    TopologyLocation& operator= (const TopologyLocation& gl)
+    {
+        location = gl.location;
+        locationSize = gl.locationSize;
+        return *this;
+    };
+
+    Location get(std::size_t posIndex) const
+    {
+        // should be an assert() instead ?
+        if(posIndex < locationSize) {
+            return location[posIndex];
+        }
+        return Location::NONE;
+    };
+
+    /**
+     * @return true if all locations are Location::NONE
+     */
+    bool isNull() const
+    {
+        for(std::size_t i = 0; i < locationSize; ++i) {
+            if(location[i] != Location::NONE) {
+                return false;
+            }
+        }
+        return true;
+    };
+
+    /**
+     * @return true if any locations is Location::NONE
+     */
+    bool isAnyNull() const
+    {
+        for(std::size_t i = 0; i < locationSize; ++i) {
+            if(location[i] == Location::NONE) {
+                return true;
+            }
+        }
+        return false;
+    };
+
+    bool isEqualOnSide(const TopologyLocation& le, uint32_t locIndex) const
+    {
+        return location[locIndex] == le.location[locIndex];
+    };
+
+    bool isArea() const
+    {
+        return locationSize > 1;
+    };
+
+    bool isLine() const
+    {
+        return locationSize == 1;
+    };
+
+    void flip()
+    {
+        if(locationSize <= 1) {
+            return;
+        }
+        std::swap(location[Position::LEFT], location[Position::RIGHT]);
+    };
+
+    void setAllLocations(Location locValue)
+    {
+        location.fill(locValue);
+    };
+
+
+    void setAllLocationsIfNull(Location locValue)
+    {
+        for(std::size_t i = 0; i < locationSize; ++i) {
+            if(location[i] == Location::NONE) {
+                location[i] = locValue;
+            }
+        }
+    };
+
+    void setLocation(std::size_t locIndex, Location locValue)
+    {
+        location[locIndex] = locValue;
+    };
+
+    void setLocation(Location locValue)
+    {
+        setLocation(Position::ON, locValue);
+    };
+
+    const std::array<Location, 3>& getLocations() const
+    {
+        return location;
+    };
+
+    void setLocations(Location on, Location left, Location right)
+    {
+        assert(locationSize >= 3);
+        location[Position::ON] = on;
+        location[Position::LEFT] = left;
+        location[Position::RIGHT] = right;
+    };
+
+    bool allPositionsEqual(Location loc) const
+    {
+        for(std::size_t i = 0; i < locationSize; ++i) {
+            if(location[i] != loc) {
+                return false;
+            }
+        }
+        return true;
+    };
+
+    /** \brief
+     * merge updates only the UNDEF attributes of this object
+     * with the attributes of another.
+     */
+    void merge(const TopologyLocation& gl);
+
+    std::string toString() const;
+
+
+private:
+
+    std::array<geom::Location, 3> location;
+    std::uint8_t locationSize;
+
+};
+
+std::ostream& operator<< (std::ostream&, const TopologyLocation&);
+
+} // namespace geos.geomgraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/geomgraph/index/EdgeSetIntersector.h

@@ -0,0 +1,68 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geomgraph {
+class Edge;
+namespace index {
+class SegmentIntersector;
+}
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos::geomgraph
+namespace index { // geos::geomgraph::index
+
+/** \brief
+ * An EdgeSetIntersector computes all the intersections between the edges in the set.
+ *
+ * \note This is derived from a Java interface.
+ */
+class GEOS_DLL EdgeSetIntersector {
+public:
+    /** \brief
+     * Computes all self-intersections between edges in a set of edges,
+     * allowing client to choose whether self-intersections are computed.
+     *
+     * @param edges a list of edges to test for intersections
+     * @param si the SegmentIntersector to use
+     * @param testAllSegments true if self-intersections are to be tested as well
+     */
+    virtual void computeIntersections(std::vector<Edge*>* edges,
+                                      SegmentIntersector* si, bool testAllSegments) = 0;
+
+    /** \brief
+     * Computes all mutual intersections between two sets of edges
+     */
+    virtual void computeIntersections(std::vector<Edge*>* edges0,
+                                      std::vector<Edge*>* edges1,
+                                      SegmentIntersector* si) = 0;
+
+    virtual
+    ~EdgeSetIntersector() {}
+};
+
+
+} // namespace geos.geomgraph.index
+} // namespace geos.geomgraph
+} // namespace geos
+

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/geomgraph/index/MonotoneChain.h

@@ -0,0 +1,72 @@
+/**********************************************************************
+ *
+ * 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: geomgraph/index/MonotoneChain.java rev. 1.3 (JTS-1.7)
+ *
+ **********************************************************************/
+
+#pragma once
+
+
+#include <geos/export.h>
+#include <geos/geomgraph/index/SweepLineEventObj.h> // for inheritance
+#include <geos/geomgraph/index/MonotoneChainEdge.h> // for inline
+#include <geos/geomgraph/index/MonotoneChain.h>
+
+// Forward declarations
+namespace geos {
+namespace geomgraph {
+namespace index {
+class SegmentIntersector;
+}
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos::geomgraph
+namespace index { // geos::geomgraph::index
+
+/**
+ * A chain in a MonotoneChainEdge
+ */
+class GEOS_DLL MonotoneChain: public SweepLineEventOBJ {
+private:
+    MonotoneChainEdge* mce;
+    std::size_t chainIndex;
+
+    MonotoneChain(const MonotoneChain& other) = delete;
+    MonotoneChain& operator=(const MonotoneChain& rhs) = delete;
+
+public:
+
+    MonotoneChain(MonotoneChainEdge* newMce, std::size_t newChainIndex):
+        mce(newMce),
+        chainIndex(newChainIndex)
+    {}
+
+    ~MonotoneChain() override {}
+
+    void
+    computeIntersections(MonotoneChain* mc, SegmentIntersector* si)
+    {
+        mce->computeIntersectsForChain(chainIndex, *(mc->mce), mc->chainIndex, *si);
+    }
+};
+
+
+} // namespace geos.geomgraph.index
+} // namespace geos.geomgraph
+} // namespace geos
+

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/geomgraph/index/MonotoneChainEdge.h

@@ -0,0 +1,85 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Envelope.h> // for composition
+
+#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 CoordinateSequence;
+}
+namespace geomgraph {
+class Edge;
+namespace index {
+class SegmentIntersector;
+}
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos::geomgraph
+namespace index { // geos::geomgraph::index
+
+/// \brief MonotoneChains are a way of partitioning the segments of an edge to
+/// allow for fast searching of intersections.
+class GEOS_DLL MonotoneChainEdge {
+public:
+    //MonotoneChainEdge();
+    ~MonotoneChainEdge() = default;
+    MonotoneChainEdge(Edge* newE);
+    const geom::CoordinateSequence* getCoordinates();
+    std::vector<size_t>& getStartIndexes();
+    double getMinX(std::size_t chainIndex);
+    double getMaxX(std::size_t chainIndex);
+
+    void computeIntersects(const MonotoneChainEdge& mce,
+                           SegmentIntersector& si);
+
+    void computeIntersectsForChain(std::size_t chainIndex0,
+                                   const MonotoneChainEdge& mce, std::size_t chainIndex1,
+                                   SegmentIntersector& si);
+
+protected:
+    Edge* e;
+    const geom::CoordinateSequence* pts; // cache a reference to the coord array, for efficiency
+    // the lists of start/end indexes of the monotone chains.
+    // Includes the end point of the edge as a sentinel
+    std::vector<size_t> startIndex;
+    // these envelopes are created once and reused
+private:
+    void computeIntersectsForChain(std::size_t start0, std::size_t end0,
+                                   const MonotoneChainEdge& mce,
+                                   std::size_t start1, std::size_t end1,
+                                   SegmentIntersector& ei);
+
+    bool overlaps(std::size_t start0, std::size_t end0, const MonotoneChainEdge& mce, std::size_t start1, std::size_t end1);
+
+};
+
+} // namespace geos.geomgraph.index
+} // namespace geos.geomgraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/geomgraph/index/MonotoneChainIndexer.h

@@ -0,0 +1,71 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <vector>
+#include <geos/export.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos::geomgraph
+namespace index { // geos::geomgraph::index
+
+/// \brief MonotoneChains are a way of partitioning the segments of an edge to
+/// allow for fast searching of intersections.
+///
+/// Specifically, a sequence of contiguous line segments is a monotone chain
+/// iff all the vectors defined by the oriented segments lies in the same
+/// quadrant.
+///
+/// Monotone Chains have the following useful properties:
+///
+/// - the segments within a monotone chain will never intersect each other
+///
+/// - the envelope of any contiguous subset of the segments in a monotone chain
+///   is simply the envelope of the endpoints of the subset.
+///
+/// Property 1 means that there is no need to test pairs of segments from
+/// within the same monotone chain for intersection. Property 2 allows binary
+/// search to be used to find the intersection points of two monotone chains.
+/// For many types of real-world data, these properties eliminate a large
+/// number of segment comparisons, producing substantial speed gains.
+///
+/// \note Due to the efficient intersection test, there is no need to limit the
+/// size of chains to obtain fast performance.
+class GEOS_DLL MonotoneChainIndexer {
+
+public:
+
+    MonotoneChainIndexer() {}
+
+    void getChainStartIndices(const geom::CoordinateSequence*, std::vector<std::size_t>&);
+
+private:
+
+    std::size_t findChainEnd(const geom::CoordinateSequence* pts, std::size_t start);
+
+};
+
+} // namespace geos.geomgraph.index
+} // namespace geos.geomgraph
+} // namespace geos
+

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/geomgraph/index/SegmentIntersector.h

@@ -0,0 +1,176 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <array>
+#include <vector>
+
+#include <geos/geom/Coordinate.h> // for composition
+
+#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 algorithm {
+class LineIntersector;
+}
+namespace geomgraph {
+class Node;
+class Edge;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos::geomgraph
+namespace index { // geos::geomgraph::index
+
+/// \brief Computes the intersection of line segments, and adds the
+/// intersection to the edges containing the segments.
+class GEOS_DLL SegmentIntersector {
+
+private:
+
+    /**
+     * These variables keep track of what types of intersections were
+     * found during ALL edges that have been intersected.
+     */
+    bool hasIntersectionVar;
+
+    bool hasProper;
+
+    bool hasProperInterior;
+
+    /// the proper intersection point found
+    geom::Coordinate properIntersectionPoint;
+
+    algorithm::LineIntersector* li;
+
+    bool includeProper;
+
+    bool recordIsolated;
+
+    int numIntersections;
+
+    /// Elements are externally owned
+    std::array<std::vector<Node*>*, 2> bdyNodes;
+
+    bool isTrivialIntersection(Edge* e0, std::size_t segIndex0, Edge* e1, std::size_t segIndex1);
+
+    bool isBoundaryPoint(algorithm::LineIntersector* p_li,
+                         std::array<std::vector<Node*>*, 2>& tstBdyNodes)
+    {
+        return isBoundaryPoint(p_li, tstBdyNodes[0]) || isBoundaryPoint(p_li, tstBdyNodes[1]);
+    };
+
+    bool isBoundaryPoint(algorithm::LineIntersector* li,
+                         std::vector<Node*>* tstBdyNodes);
+
+public:
+
+    static bool isAdjacentSegments(std::size_t i1, size_t i2)
+    {
+        return (i1 > i2 ? i1 - i2 : i2 - i1) == 1;
+    };
+
+    // testing only
+    int numTests;
+
+    //SegmentIntersector();
+
+    virtual
+    ~SegmentIntersector() {}
+
+    SegmentIntersector(algorithm::LineIntersector* newLi,
+                       bool newIncludeProper, bool newRecordIsolated)
+        :
+        hasIntersectionVar(false),
+        hasProper(false),
+        hasProperInterior(false),
+        li(newLi),
+        includeProper(newIncludeProper),
+        recordIsolated(newRecordIsolated),
+        numIntersections(0),
+        bdyNodes{{nullptr, nullptr}},
+        numTests(0)
+    {}
+
+    /// \brief
+    /// Parameters are externally owned.
+    /// Make sure they live for the whole lifetime of this object
+    void setBoundaryNodes(std::vector<Node*>* bdyNodes0,
+                          std::vector<Node*>* bdyNodes1)
+    {
+        bdyNodes[0] = bdyNodes0;
+        bdyNodes[1] = bdyNodes1;
+    };
+
+    /*
+    * @return the proper intersection point, or <code>null</code>
+    * if none was found
+    */
+    geom::Coordinate& getProperIntersectionPoint()
+    {
+        return properIntersectionPoint;
+    };
+
+    bool hasIntersection() const
+    {
+        return hasIntersectionVar;
+    };
+
+    /**
+     * A proper intersection is an intersection which is interior to at least two
+     * line segments.  Note that a proper intersection is not necessarily
+     * in the interior of the entire Geometry, since another edge may have
+     * an endpoint equal to the intersection, which according to SFS semantics
+     * can result in the point being on the Boundary of the Geometry.
+     */
+    bool hasProperIntersection() const
+    {
+        return hasProper;
+    };
+
+    /**
+     * A proper interior intersection is a proper intersection which is <b>not</b>
+     * contained in the set of boundary nodes set for this SegmentIntersector.
+     */
+    bool hasProperInteriorIntersection() const
+    {
+        return hasProperInterior;
+    };
+
+    void addIntersections(Edge* e0, std::size_t segIndex0, Edge* e1, std::size_t segIndex1);
+
+    bool getIsDone() const
+    {
+        return false;
+    };
+
+
+};
+
+} // namespace geos.geomgraph.index
+} // namespace geos.geomgraph
+} // namespace geos
+
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif