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

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

@@ -1,161 +0,0 @@
-/**********************************************************************
- *
- * 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 transferred.
-    ///
-    /// @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 transferred.
-    ///
-    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 transferred.
-    ///
-    /// @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 transferred.
-    ///
-    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/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/operation/union/CascadedPolygonUnion.h

@@ -1,246 +0,0 @@
-/**********************************************************************
- *
- * 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>buffer(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/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/operation/union/CoverageUnion.h

@@ -1,65 +0,0 @@
-/**********************************************************************
- *
- * 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;
-    };
-
-}
-}
-}

package/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/operation/union/DisjointSubsetUnion.h

@@ -1,49 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2022 ISciences LLC
- *
- * 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/Geometry.h>
-#include <geos/operation/cluster/DisjointOperation.h>
-#include <geos/operation/cluster/GeometryIntersectsClusterFinder.h>
-#include <geos/operation/overlayng/OverlayNGRobust.h>
-
-namespace geos {
-namespace operation {
-namespace geounion {
-
-class GEOS_DLL DisjointSubsetUnion {
-public:
-    /** Perform a unary union on a geometry by combining the results of
-     *  unary unions performed on its disjoint subsets.
-     *
-     * @brief Union
-     * @param g the geometry to union
-     * @return result geometry
-     */
-    static std::unique_ptr<geom::Geometry> Union(const geom::Geometry* g) {
-        operation::cluster::GeometryIntersectsClusterFinder f;
-        operation::cluster::DisjointOperation op(f);
-        op.setSplitInputs(true);
-
-        return op.processDisjointSubsets(*g, [](const geom::Geometry& subset) {
-            return subset.Union();
-        });
-    }
-};
-
-}
-}
-}

package/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/operation/union/OverlapUnion.h

@@ -1,139 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2011 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, generalization of CascadedPolygonUnion
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <vector>
-#include <algorithm>
-#include <unordered_set>
-
-#include <geos/geom/Geometry.h>
-#include <geos/operation/union/UnionStrategy.h>
-#include <geos/operation/union/CascadedPolygonUnion.h>
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Envelope;
-class LineSegment;
-}
-}
-
-namespace geos {
-namespace operation { // geos::operation
-namespace geounion {  // geos::operation::geounion
-
-/** \brief
- * Unions MultiPolygons efficiently by using full topological union only
- * for polygons which may overlap by virtue of intersecting the common
- * area of the inputs.
- *
- * Other polygons are simply combined with the union result, which is much
- * more performant.
- *
- * This situation is likely to occur during cascaded polygon union,
- * since the partitioning of polygons is done heuristically
- * and thus may group disjoint polygons which can lie far apart.
- * It may also occur in real world data which contains many disjoint polygons
- * (e.g. polygons representing parcels on different street blocks).
- *
- * # Algorithm
- *
- * The overlap region is determined as the common envelope of intersection.
- * The input polygons are partitioned into two sets:
- *
- * * Overlapping: Polygons which intersect the overlap region, and thus potentially overlap each other
- * * Disjoint: Polygons which are disjoint from (lie wholly outside) the overlap region
- *
- * The Overlapping set is fully unioned, and then combined with the Disjoint set.
- * Performing a simple combine works because
- * the disjoint polygons do not interact with each
- * other (since the inputs are valid MultiPolygons).
- * They also do not interact with the Overlapping polygons,
- * since they are outside their envelope.
- *
- * # Verification
- *
- * In the general case the Overlapping set of polygons will
- * extend beyond the overlap envelope.  This means that the union result
- * will extend beyond the overlap region.
- * There is a small chance that the topological
- * union of the overlap region will shift the result linework enough
- * that the result geometry intersects one of the Disjoint geometries.
- * This case is detected and if it occurs
- * is remedied by falling back to performing a full union of the original inputs.
- * Detection is done by a fairly efficient comparison of edge segments which
- * extend beyond the overlap region.  If any segments have changed
- * then there is a risk of introduced intersections, and full union is performed.
- *
- * This situation has not been observed in JTS using floating precision,
- * but it could happen due to snapping.  It has been observed
- * in other APIs (e.g. GEOS) due to more aggressive snapping.
- * And it will be more likely to happen if a snap-rounding overlay is used.
- *
- * DEPRECATED: This optimization has been removed, since it impairs performance.
- *
- * @author mbdavis
- *
- */
-class GEOS_DLL OverlapUnion {
-
-public:
-
-    OverlapUnion(const geom::Geometry* p_g0, const geom::Geometry* p_g1, geounion::UnionStrategy* unionFun)
-        : g0(p_g0)
-        , g1(p_g1)
-        , unionFunction(unionFun)
-        , geomFactory(p_g0->getFactory())
-        , isUnionSafe(false)
-        {};
-
-    OverlapUnion(const geom::Geometry* p_g0, const geom::Geometry* p_g1)
-        : OverlapUnion(p_g0, p_g1, &defaultUnionFunction)
-        {};
-
-
-    std::unique_ptr<geom::Geometry> doUnion();
-
-private:
-
-    const geom::Geometry* g0;
-    const geom::Geometry* g1;
-    geounion::UnionStrategy* unionFunction;
-    const geom::GeometryFactory* geomFactory;
-    bool isUnionSafe;
-
-    geounion::ClassicUnionStrategy defaultUnionFunction;
-
-    static geom::Envelope overlapEnvelope(const geom::Geometry* geom0, const geom::Geometry* geom1);
-    std::unique_ptr<geom::Geometry> extractByEnvelope(const geom::Envelope& env, const geom::Geometry* geom, std::vector<std::unique_ptr<geom::Geometry>>& disjointGeoms);
-    static std::unique_ptr<geom::Geometry> combine(std::unique_ptr<geom::Geometry>& unionGeom, std::vector<std::unique_ptr<geom::Geometry>>& disjointPolys);
-    std::unique_ptr<geom::Geometry> unionFull(const geom::Geometry* geom0, const geom::Geometry* geom1);
-    static std::unique_ptr<geom::Geometry> unionBuffer(const geom::Geometry* geom0, const geom::Geometry* geom1);
-    bool isBorderSegmentsSame(const geom::Geometry* result, const geom::Envelope& env);
-    static bool isEqual(std::vector<geom::LineSegment>& segs0, std::vector<geom::LineSegment>& segs1);
-    std::vector<geom::LineSegment> extractBorderSegments(const geom::Geometry* geom0, const geom::Geometry* geom1, const geom::Envelope& env);
-    void extractBorderSegments(const geom::Geometry* geom, const geom::Envelope& penv, std::vector<geom::LineSegment>& psegs);
-
-};
-
-} // namespace geos::operation::union
-} // namespace geos::operation
-} // namespace geos