@cpp.js/package-geos 1.0.0-beta.21 → 1.0.0-beta.23

package/dist/prebuilt/Android-x86_64/include/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 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/dist/prebuilt/Android-x86_64/include/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>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/dist/prebuilt/Android-x86_64/include/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;
+    };
+
+}
+}
+}

package/dist/prebuilt/Android-x86_64/include/geos/operation/union/DisjointSubsetUnion.h

@@ -0,0 +1,49 @@
+/**********************************************************************
+ *
+ * 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/dist/prebuilt/Android-x86_64/include/geos/operation/union/OverlapUnion.h

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