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

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e/Headers/geos/operation/relate/RelateNodeGraph.h

@@ -0,0 +1,98 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 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.
+ *
+ **********************************************************************
+ *
+ * Last port: operation/relate/RelateNodeGraph.java rev. 1.11 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geomgraph/NodeMap.h>
+
+#include <map>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+struct CoordinateLessThan;
+}
+namespace geomgraph {
+//class EdgeEndStar;
+class Node;
+class GeometryGraph;
+class EdgeEnd;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace relate { // geos::operation::relate
+
+/** \brief
+ * Implements the simple graph of Nodes and geomgraph::EdgeEnd which is all that is
+ * required to determine topological relationships between Geometries.
+ *
+ * Also supports building a topological graph of a single Geometry, to
+ * allow verification of valid topology.
+ *
+ * It is <b>not</b> necessary to create a fully linked
+ * PlanarGraph to determine relationships, since it is sufficient
+ * to know how the Geometries interact locally around the nodes.
+ * In fact, this is not even feasible, since it is not possible to compute
+ * exact intersection points, and hence the topology around those nodes
+ * cannot be computed robustly.
+ * The only Nodes that are created are for improper intersections;
+ * that is, nodes which occur at existing vertices of the Geometries.
+ * Proper intersections (e.g. ones which occur between the interior of
+ * line segments)
+ * have their topology determined implicitly, without creating a geomgraph::Node object
+ * to represent them.
+ *
+ */
+class GEOS_DLL RelateNodeGraph {
+
+public:
+
+    RelateNodeGraph();
+
+    virtual ~RelateNodeGraph();
+
+    geomgraph::NodeMap::container& getNodeMap();
+
+    void build(geomgraph::GeometryGraph* geomGraph);
+
+    void computeIntersectionNodes(geomgraph::GeometryGraph* geomGraph,
+                                  uint8_t argIndex);
+
+    void copyNodesAndLabels(geomgraph::GeometryGraph* geomGraph, uint8_t argIndex);
+
+    void insertEdgeEnds(std::vector<std::unique_ptr<geomgraph::EdgeEnd>>& ee);
+
+private:
+
+    geomgraph::NodeMap* nodes;
+
+    RelateNodeGraph(const RelateNodeGraph&) = delete;
+    RelateNodeGraph& operator=(const RelateNodeGraph&) = delete;
+
+};
+
+
+} // namespace geos:operation:relate
+} // namespace geos:operation
+} // namespace geos

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e/Headers/geos/operation/relate/RelateOp.h

@@ -0,0 +1,134 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 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.
+ *
+ **********************************************************************
+ *
+ * Last port: operation/relate/RelateOp.java rev. 1.19 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geom/IntersectionMatrix.h>
+#include <geos/operation/GeometryGraphOperation.h> // for inheritance
+#include <geos/operation/relate/RelateComputer.h> // for composition
+
+// Forward declarations
+namespace geos {
+namespace algorithm {
+class BoundaryNodeRule;
+}
+namespace geom {
+class Geometry;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace relate { // geos::operation::relate
+
+/** \brief
+ * Implements the SFS `relate()` operation on two
+ * geom::Geometry objects.
+ *
+ * This class supports specifying a custom algorithm::BoundaryNodeRule
+ * to be used during the relate computation.
+ *
+ * @note Custom Boundary Node Rules do not (currently)
+ * affect the results of other Geometry methods (such
+ * as [Geometry::getBoundary()](@ref geom::Geometry::getBoundary() const)).
+ * The results of these methods may not be consistent with the relationship
+ * computed by a custom Boundary Node Rule.
+ *
+ */
+class GEOS_DLL RelateOp: public GeometryGraphOperation {
+
+public:
+
+    /** \brief
+     * Computes the geom::IntersectionMatrix for the spatial relationship
+     * between two geom::Geometry objects, using the default (OGC SFS)
+     * Boundary Node Rule
+     *
+     * @param a a Geometry to test. Ownership left to caller.
+     * @param b a Geometry to test. Ownership left to caller.
+     *
+     * @return the IntersectonMatrix for the spatial relationship
+     *         between the geometries. Ownership transferred.
+     */
+    static std::unique_ptr<geom::IntersectionMatrix> relate(
+        const geom::Geometry* a,
+        const geom::Geometry* b);
+
+    /** \brief
+     * Computes the geom::IntersectionMatrix for the spatial relationship
+     * between two geom::Geometry objects, using a specified
+     * Boundary Node Rule.
+     *
+     * @param a a Geometry to test. Ownership left to caller.
+     * @param b a Geometry to test. Ownership left to caller.
+     * @param boundaryNodeRule the Boundary Node Rule to use.
+     *
+     * @return the IntersectonMatrix for the spatial relationship
+     *         between the geometries. Ownership transferred.
+     */
+    static std::unique_ptr<geom::IntersectionMatrix> relate(
+        const geom::Geometry* a,
+        const geom::Geometry* b,
+        const algorithm::BoundaryNodeRule& boundaryNodeRule);
+
+    /** \brief
+     * Creates a new Relate operation, using the default (OGC SFS)
+     * Boundary Node Rule.
+     *
+     * @param g0 a Geometry to relate. Ownership left to caller.
+     * @param g1 another Geometry to relate. Ownership to caller.
+     */
+    RelateOp(const geom::Geometry* g0,
+             const geom::Geometry* g1);
+
+    /** \brief
+     * Creates a new Relate operation with a specified
+     * Boundary Node Rule.
+     *
+     * @param g0 a Geometry to relate. Ownership left to caller.
+     * @param g1 another Geometry to relate. Ownership to caller.
+     * @param boundaryNodeRule the Boundary Node Rule to use
+     */
+    RelateOp(const geom::Geometry* g0,
+             const geom::Geometry* g1,
+             const algorithm::BoundaryNodeRule& boundaryNodeRule);
+
+    ~RelateOp() override = default;
+
+    /** \brief
+     * Gets the IntersectionMatrix for the spatial relationship
+     * between the input geometries.
+     *
+     * @return the geom::IntersectionMatrix for the spatial
+     *         relationship between the input geometries.
+     *         Ownership transferred.
+     */
+    std::unique_ptr<geom::IntersectionMatrix> getIntersectionMatrix();
+
+private:
+
+    RelateComputer relateComp;
+};
+
+
+} // namespace geos:operation:relate
+} // namespace geos:operation
+} // namespace geos

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e/Headers/geos/operation/sharedpaths/SharedPathsOp.h

@@ -0,0 +1,161 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2010      Sandro Santilli <strk@kbt.io>
+ *
+ * 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: original work
+ *
+ * Developed by Sandro Santilli (strk@kbt.io)
+ * for Faunalia (http://www.faunalia.it)
+ * with funding from Regione Toscana - Settore SISTEMA INFORMATIVO
+ * TERRITORIALE ED AMBIENTALE - for the project: "Sviluppo strumenti
+ * software per il trattamento di dati geografici basati su QuantumGIS
+ * e Postgis (CIG 0494241492)"
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h> // for GEOS_DLL
+
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class LineString;
+class Geometry;
+class GeometryFactory;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos.operation
+
+/// Find shared paths among two linear Geometry objects.
+namespace sharedpaths { // geos.operation.sharedpaths
+
+/** \brief
+ * Find shared paths among two linear Geometry objects
+ *
+ * For each shared path report if it direction is the same
+ * or opposite.
+ *
+ * Paths reported as shared are given in the direction they
+ * appear in the first geometry.
+ *
+ * \remark Developed by Sandro Santilli (strk@kbt.io)
+ * for Faunalia (http://www.faunalia.it)
+ * with funding from Regione Toscana - Settore SISTEMA INFORMATIVO
+ * TERRITORIALE ED AMBIENTALE - for the project: "Sviluppo strumenti
+ * software per il trattamento di dati geografici basati su QuantumGIS
+ * e Postgis (CIG 0494241492)"
+ *
+ */
+class GEOS_DLL SharedPathsOp {
+public:
+
+    /// LineString vector (list of edges)
+    typedef std::vector<geom::LineString*> PathList;
+
+    /// Find paths shared between two linear geometries
+    ///
+    /// @param g1
+    ///   First geometry. Must be linear.
+    ///
+    /// @param g2
+    ///   Second geometry. Must be linear.
+    ///
+    /// @param sameDirection
+    ///   Shared edges having the same direction are pushed
+    ///   onto this vector. They'll be of type LineString.
+    ///   Ownership of the edges is tranferred.
+    ///
+    /// @param oppositeDirection
+    ///   Shared edges having the opposite direction are pushed
+    ///   onto this vector. They'll be of type geom::LineString.
+    ///   Ownership of the edges is tranferred.
+    ///
+    static void sharedPathsOp(const geom::Geometry& g1,
+                              const geom::Geometry& g2,
+                              PathList& sameDirection,
+                              PathList& oppositeDirection);
+
+    /// Constructor
+    ///
+    /// @param g1
+    ///   First geometry. Must be linear.
+    ///
+    /// @param g2
+    ///   Second geometry. Must be linear.
+    ///
+    SharedPathsOp(const geom::Geometry& g1, const geom::Geometry& g2);
+
+    /// Get shared paths
+    ///
+    /// @param sameDirection
+    ///   Shared edges having the same direction are pushed
+    ///   onto this vector. They'll be of type geom::LineString.
+    ///   Ownership of the edges is tranferred.
+    ///
+    /// @param oppositeDirection
+    ///   Shared edges having the opposite direction are pushed
+    ///   onto this vector. They'll be of type geom::LineString.
+    ///   Ownership of the edges is tranferred.
+    ///
+    void getSharedPaths(PathList& sameDirection, PathList& oppositeDirection);
+
+    /// Delete all edges in the list
+    static void clearEdges(PathList& from);
+
+private:
+
+    /// Get all the linear intersections
+    ///
+    /// Ownership of linestring pushed to the given container
+    /// is transferred to caller. See clearEdges for a deep
+    /// release if you need one.
+    ///
+    void findLinearIntersections(PathList& to);
+
+    /// Check if the given edge goes forward or backward on the given line.
+    ///
+    /// PRECONDITION: It is assumed the edge fully lays on the geometry
+    ///
+    bool isForward(const geom::LineString& edge,
+                   const geom::Geometry& geom);
+
+    /// Check if the given edge goes in the same direction over
+    /// the two geometries.
+    bool
+    isSameDirection(const geom::LineString& edge)
+    {
+        return (isForward(edge, _g1) == isForward(edge, _g2));
+    }
+
+    /// Throw an IllegalArgumentException if the geom is not linear
+    void checkLinealInput(const geom::Geometry& g);
+
+    const geom::Geometry& _g1;
+    const geom::Geometry& _g2;
+    const geom::GeometryFactory& _gf;
+
+    // Declare type as noncopyable
+    SharedPathsOp(const SharedPathsOp& other) = delete;
+    SharedPathsOp& operator=(const SharedPathsOp& rhs) = delete;
+
+};
+
+} // namespace geos.operation.sharedpaths
+} // namespace geos.operation
+} // namespace geos

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e/Headers/geos/operation/union/CascadedPolygonUnion.h

@@ -0,0 +1,246 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 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.
+ *
+ **********************************************************************
+ *
+ * Last port: operation/union/CascadedPolygonUnion.java r487 (JTS-1.12+)
+ * Includes custom code to deal with https://trac.osgeo.org/geos/ticket/837
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/operation/union/UnionStrategy.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class GeometryFactory;
+class Geometry;
+class Polygon;
+class MultiPolygon;
+class Envelope;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace geounion {  // geos::operation::geounion
+
+
+/**
+* \brief
+* Implementation of UnionStrategy that provides overlay using
+* the first generation overlay routines.
+*/
+class GEOS_DLL ClassicUnionStrategy : public UnionStrategy {
+
+public:
+
+    ClassicUnionStrategy() {};
+
+    /**
+    * Computes the union of two geometries.
+    * This method may throw a {@link util::TopologyException}
+    * if one is encountered
+    */
+    std::unique_ptr<geom::Geometry> Union(const geom::Geometry*, const geom::Geometry*) override;
+
+    /**
+    * Indicates whether the union function operates using
+    * a floating (full) precision model.
+    * If this is the case, then the unary union code
+    * can make use of the {@link OverlapUnion} performance optimization,
+    * and perhaps other optimizations as well.
+    * Otherwise, the union result extent may not be the same as the extent of the inputs,
+    * which prevents using some optimizations.
+    */
+    bool isFloatingPrecision() const override;
+
+private:
+
+    /**
+    * An alternative way of unioning polygonal geometries
+    * by using <code>bufer(0)</code>.
+    * Only worth using if regular overlay union fails.
+    */
+    std::unique_ptr<geom::Geometry> unionPolygonsByBuffer(const geom::Geometry* g0, const geom::Geometry* g1);
+
+};
+
+
+
+/**
+ * \brief
+ * Provides an efficient method of unioning a collection of polygonal geometries.
+ *
+ * This algorithm is faster and likely more robust than the simple iterated
+ * approach of repeatedly unioning each polygon to a result geometry.
+ *
+ * The `buffer(0)` trick is sometimes faster, but can be less robust and
+ * can sometimes take an exceptionally long time to complete.
+ * This is particularly the case where there is a high degree of overlap
+ * between the polygons.  In this case, `buffer(0)` is forced to compute
+ * with *all* line segments from the outset, whereas cascading can eliminate
+ * many segments at each stage of processing.
+ * The best case for buffer(0) is the trivial case where there is `no` overlap
+ * between the input geometries. However, this case is likely rare in practice.
+ */
+class GEOS_DLL CascadedPolygonUnion {
+private:
+    std::vector<geom::Polygon*>* inputPolys;
+    geom::GeometryFactory const* geomFactory;
+
+    /**
+     * The effectiveness of the index is somewhat sensitive
+     * to the node capacity.
+     * Testing indicates that a smaller capacity is better.
+     * For an STRtree, 4 is probably a good number (since
+     * this produces 2x2 "squares").
+     */
+    static int const STRTREE_NODE_CAPACITY = 4;
+
+    /** \brief
+     * Computes a [Geometry](@ref geom::Geometry) containing only polygonal components.
+     *
+     * Extracts the [Polygons](@ref geom::Polygon) from the input
+     * and returns them as an appropriate polygonal geometry.
+     *
+     * If the input is already `Polygonal`, it is returned unchanged.
+     *
+     * A particular use case is to filter out non-polygonal components
+     * returned from an overlay operation.
+     *
+     * @param g the geometry to filter
+     * @return a Polygonal geometry
+     */
+    static std::unique_ptr<geom::Geometry> restrictToPolygons(std::unique_ptr<geom::Geometry> g);
+
+public:
+    CascadedPolygonUnion();
+
+    /** \brief
+     * Computes the union of a collection of polygonal [Geometrys](@ref geom::Geometry).
+     *
+     * @param polys a collection of polygonal [Geometrys](@ref geom::Geometry).
+     *              ownership of elements *and* vector are left to caller.
+     */
+    static std::unique_ptr<geom::Geometry> Union(std::vector<geom::Polygon*>* polys);
+    static std::unique_ptr<geom::Geometry> Union(std::vector<geom::Polygon*>* polys, UnionStrategy* unionFun);
+
+    /** \brief
+     * Computes the union of a set of polygonal [Geometrys](@ref geom::Geometry).
+     *
+     * @tparam T an iterator yielding something castable to const Polygon *
+     * @param start start iterator
+     * @param end end iterator
+     * @param unionStrategy strategy to apply
+     */
+    template <class T>
+    static std::unique_ptr<geom::Geometry>
+    Union(T start, T end, UnionStrategy *unionStrategy)
+    {
+        std::vector<geom::Polygon*> polys;
+        for(T i = start; i != end; ++i) {
+            const geom::Polygon* p = dynamic_cast<const geom::Polygon*>(*i);
+            polys.push_back(const_cast<geom::Polygon*>(p));
+        }
+        return Union(&polys, unionStrategy);
+    }
+
+    /** \brief
+     * Computes the union of a collection of polygonal [Geometrys](@ref geom::Geometry).
+     *
+     * @param polys a collection of polygonal [Geometrys](@ref geom::Geometry).
+     *              Ownership of elements *and* vector are left to caller.
+     */
+    static std::unique_ptr<geom::Geometry> Union(const geom::MultiPolygon* polys);
+
+    /** \brief
+     * Creates a new instance to union the given collection of
+     * [Geometrys](@ref geom::Geometry).
+     *
+     * @param polys a collection of polygonal [Geometrys](@ref geom::Geometry).
+     *              Ownership of elements *and* vector are left to caller.
+     */
+    CascadedPolygonUnion(std::vector<geom::Polygon*>* polys)
+        : inputPolys(polys)
+        , geomFactory(nullptr)
+        , unionFunction(&defaultUnionFunction)
+    {}
+
+    CascadedPolygonUnion(std::vector<geom::Polygon*>* polys, UnionStrategy* unionFun)
+        : inputPolys(polys)
+        , geomFactory(nullptr)
+        , unionFunction(unionFun)
+    {}
+
+    /** \brief
+     * Computes the union of the input geometries.
+     *
+     * @return the union of the input geometries
+     * @return `null` if no input geometries were provided
+     */
+    std::unique_ptr<geom::Geometry> Union();
+
+private:
+
+    UnionStrategy* unionFunction;
+    ClassicUnionStrategy defaultUnionFunction;
+
+    /**
+     * Unions a section of a list using a recursive binary union on each half
+     * of the section.
+     *
+     * @param geoms the list of geometries containing the section to union
+     * @param start the start index of the section
+     * @param end the index after the end of the section
+     * @return the union of the list section
+     */
+    std::unique_ptr<geom::Geometry> binaryUnion(const std::vector<const geom::Geometry*> & geoms, std::size_t start, std::size_t end);
+
+    /**
+     * Computes the union of two geometries,
+     * either of both of which may be null.
+     *
+     * @param g0 a Geometry
+     * @param g1 a Geometry
+     * @return the union of the input(s)
+     * @return null if both inputs are null
+     */
+    std::unique_ptr<geom::Geometry> unionSafe(const geom::Geometry* g0, const geom::Geometry* g1) const;
+
+    std::unique_ptr<geom::Geometry> unionSafe(std::unique_ptr<geom::Geometry> &&, std::unique_ptr<geom::Geometry> &&);
+
+    /**
+     * Encapsulates the actual unioning of two polygonal geometries.
+     *
+     * @param g0
+     * @param g1
+     * @return
+     */
+    std::unique_ptr<geom::Geometry> unionActual(const geom::Geometry* g0, const geom::Geometry* g1) const;
+
+    std::unique_ptr<geom::Geometry> unionActual(std::unique_ptr<geom::Geometry> &&, std::unique_ptr<geom::Geometry> &&) const;
+};
+
+
+
+
+
+} // namespace geos::operation::union
+} // namespace geos::operation
+} // namespace geos
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e/Headers/geos/operation/union/CoverageUnion.h

@@ -0,0 +1,65 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2019 Daniel Baston <dbaston@gmail.com>
+ *
+ * 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/geom/LineSegment.h>
+#include <geos/geom/Geometry.h>
+
+#include <memory>
+
+namespace geos {
+    namespace geom {
+        class Polygon;
+        class LineString;
+        class LinearRing;
+        class GeometryFactory;
+    }
+}
+
+using geos::geom::Geometry;
+using geos::geom::GeometryFactory;
+using geos::geom::Polygon;
+using geos::geom::LineString;
+using geos::geom::LinearRing;
+using geos::geom::LineSegment;
+
+
+namespace geos {
+namespace operation {
+namespace geounion {
+
+    class GEOS_DLL CoverageUnion {
+    public:
+        static std::unique_ptr<Geometry> Union(const Geometry* geom);
+
+    private:
+        CoverageUnion() = default;
+
+        void extractRings(const Polygon* geom);
+        void extractRings(const Geometry* geom);
+        void extractSegments(const LineString* geom);
+        void sortRings();
+
+        std::unique_ptr<Geometry> polygonize(const GeometryFactory* gf);
+
+        std::vector<const LinearRing*> rings;
+        // std::unordered_set<geos::geom::LineSegment, geos::geom::LineSegment::HashCode> segments;
+        LineSegment::UnorderedSet segments;
+        static constexpr double AREA_PCT_DIFF_TOL = 1e-6;
+    };
+
+}
+}
+}