@crossbind/port-geos-linuxmusl 0.0.0-stage → 2.0.0-beta.63

package/dist/prebuilt/linuxmusl-x64-mt-release/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/linuxmusl-x64-mt-release/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

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/union/PointGeometryUnion.h

@@ -0,0 +1,73 @@
+/**********************************************************************
+ *
+ * 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: operation/union/PointGeometryUnion.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <vector>
+#include <algorithm>
+#include <memory>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class GeometryFactory;
+class Geometry;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace geounion {  // geos::operation::geounion
+
+/**
+ * \brief
+ * Computes the union of a puntal geometry with another
+ * arbitrary [Geometry](@ref geom::Geometry).
+ *
+ * Does not copy any component geometries.
+ *
+ */
+class GEOS_DLL PointGeometryUnion {
+public:
+
+    static std::unique_ptr<geom::Geometry> Union(
+        const geom::Geometry& pointGeom,
+        const geom::Geometry& otherGeom);
+
+
+    PointGeometryUnion(const geom::Geometry& pointGeom,
+                       const geom::Geometry& otherGeom);
+
+    std::unique_ptr<geom::Geometry> Union() const;
+
+private:
+    const geom::Geometry& pointGeom;
+    const geom::Geometry& otherGeom;
+    const geom::GeometryFactory* geomFact;
+
+    // Declared as non-copyable
+    PointGeometryUnion(const PointGeometryUnion& other);
+    PointGeometryUnion& operator=(const PointGeometryUnion& rhs);
+};
+
+} // namespace geos::operation::union
+} // namespace geos::operation
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/union/UnaryUnionOp.h

@@ -0,0 +1,232 @@
+/**********************************************************************
+ *
+ * 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: operation/union/UnaryUnionOp.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include <geos/export.h>
+#include <geos/geom/GeometryFactory.h>
+#include <geos/geom/Point.h>
+#include <geos/geom/LineString.h>
+#include <geos/geom/Polygon.h>
+#include <geos/geom/util/GeometryExtracter.h>
+#include <geos/operation/union/CascadedPolygonUnion.h>
+#include <geos/util/Progress.h>
+
+#include <geos/util.h>
+
+#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 GeometryFactory;
+class Geometry;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace geounion {  // geos::operation::geounion
+
+/** \brief
+ * Unions a collection of Geometry or a single Geometry
+ * (which may be a collection) together.
+ *
+ * By using this special-purpose operation over a collection of
+ * geometries it is possible to take advantage of various optimizations
+ * to improve performance.
+ * Heterogeneous [GeometryCollections](@ref geom::GeometryCollection)
+ * are fully supported.
+ *
+ * The result obeys the following contract:
+ *
+ * - Unioning a set of overlapping [Polygons](@ref geom::Polygon) has the effect
+ *   of merging the areas (i.e. the same effect as
+ *   iteratively unioning all individual polygons together).
+ * - Unioning a set of [LineStrings](@ref geom::LineString) has the effect of
+ *   **fully noding** and **dissolving** the input linework.
+ *   In this context "fully noded" means that there will be a node or
+ *   endpoint in the output for every endpoint or line segment crossing
+ *   in the input.
+ *   "Dissolved" means that any duplicate (e.g. coincident) line segments
+ *   or portions of line segments will be reduced to a single line segment
+ *   in the output.
+ *   This is consistent with the semantics of the
+ *   [Geometry::Union(Geometry* )](@ref geom::Geometry::Union())
+ *   operation. If **merged** linework is required, the
+ *   [LineMerger](@ref operation::linemerge::LineMerger) class
+ *   can be used.
+ * - Unioning a set of [Points](@ref geom::Point) has the effect of merging
+ *   all identical points (producing a set with no duplicates).
+ *
+ * `UnaryUnion` always operates on the individual components of
+ * MultiGeometries.
+ * So it is possible to use it to "clean" invalid self-intersecting
+ * MultiPolygons (although the polygon components must all still be
+ * individually valid.)
+ */
+class GEOS_DLL UnaryUnionOp {
+public:
+
+    template <typename T>
+    static std::unique_ptr<geom::Geometry>
+    Union(const T& geoms)
+    {
+        UnaryUnionOp op(geoms);
+        geos::util::ProgressFunction* progressFunction = nullptr;
+        return op.Union(progressFunction);
+    }
+
+    template <class T>
+    static std::unique_ptr<geom::Geometry>
+    Union(const T& geoms,
+          geom::GeometryFactory& geomFact)
+    {
+        UnaryUnionOp op(geoms, geomFact);
+        geos::util::ProgressFunction* progressFunction = nullptr;
+        return op.Union(progressFunction);
+    }
+
+    static std::unique_ptr<geom::Geometry>
+    Union(const geom::Geometry& geom, geos::util::ProgressFunction* progressFunction)
+    {
+        UnaryUnionOp op(geom);
+        return op.Union(progressFunction);
+    }
+
+    template <class T>
+    UnaryUnionOp(const T& geoms, geom::GeometryFactory& geomFactIn)
+        : geomFact(&geomFactIn)
+        , unionFunction(&defaultUnionFunction)
+    {
+        extractGeoms(geoms);
+    }
+
+    template <class T>
+    UnaryUnionOp(const T& geoms)
+        : geomFact(nullptr)
+        , unionFunction(&defaultUnionFunction)
+    {
+        extractGeoms(geoms);
+    }
+
+    UnaryUnionOp(const geom::Geometry& geom)
+        : geomFact(geom.getFactory())
+        , unionFunction(&defaultUnionFunction)
+    {
+        extract(geom);
+    }
+
+    void setUnionFunction(UnionStrategy* unionFun)
+    {
+        unionFunction = unionFun;
+    }
+
+    /**
+     * \brief
+     * Gets the union of the input geometries.
+     *
+     * If no input geometries were provided, an empty GEOMETRYCOLLECTION is returned.
+     *
+     * @return a Geometry containing the union
+     * @return an empty GEOMETRYCOLLECTION if no geometries were provided
+     *         in the input
+     */
+    std::unique_ptr<geom::Geometry> Union(geos::util::ProgressFunction* progressFunction);
+
+private:
+
+    template <typename T>
+    void
+    extractGeoms(const T& geoms)
+    {
+        for(typename T::const_iterator
+                i = geoms.begin(),
+                e = geoms.end();
+                i != e;
+                ++i) {
+            const geom::Geometry* geom = *i;
+            extract(*geom);
+        }
+    }
+
+    void extract(const geom::Geometry& geom);
+
+    /**
+     * Computes a unary union with no extra optimization,
+     * and no short-circuiting.
+     * Due to the way the overlay operations
+     * are implemented, this is still efficient in the case of linear
+     * and puntal geometries.
+     * Uses robust version of overlay operation
+     * to ensure identical behaviour to the <tt>union(Geometry)</tt> operation.
+     *
+     * @param g0 a geometry
+     * @return the union of the input geometry
+     */
+    std::unique_ptr<geom::Geometry>
+    unionNoOpt(const geom::Geometry& g0)
+    {
+        if(! empty.get()) {
+            empty = geomFact->createEmptyGeometry();
+        }
+        return unionFunction->Union(&g0, empty.get());
+    }
+
+    /**
+     * Computes the union of two geometries,
+     * either of both of which may be null.
+     *
+     * @param g0 a Geometry (ownership transferred)
+     * @param g1 a Geometry (ownership transferred)
+     * @return the union of the input(s)
+     * @return null if both inputs are null
+     */
+    static std::unique_ptr<geom::Geometry> unionWithNull(
+        std::unique_ptr<geom::Geometry> g0,
+        std::unique_ptr<geom::Geometry> g1
+        );
+
+    // Members
+    std::vector<const geom::Surface*> polygons;
+    std::vector<const geom::Curve*> lines;
+    std::vector<const geom::Point*> points;
+
+    const geom::GeometryFactory* geomFact;
+    std::unique_ptr<geom::Geometry> empty;
+
+    UnionStrategy* unionFunction;
+    ClassicUnionStrategy defaultUnionFunction;
+
+};
+
+
+} // namespace geos::operation::union
+} // namespace geos::operation
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/union/UnionStrategy.h

@@ -0,0 +1,73 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 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 <geos/export.h>
+
+#include <memory>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace geounion {  // geos::operation::geounion
+
+/**
+ * A strategy class that adapts UnaryUnion to different
+ * kinds of overlay algorithms.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL UnionStrategy {
+
+public:
+
+    virtual ~UnionStrategy() {};
+
+    /**
+    * Computes the union of two geometries.
+    * This method may throw a {@link util::TopologyException}
+    * if one is encountered
+    */
+    virtual std::unique_ptr<geom::Geometry> Union(const geom::Geometry*, const geom::Geometry*) = 0;
+
+    virtual std::unique_ptr<geom::Geometry> Union(std::unique_ptr<geom::Geometry> &&,
+                                                  std::unique_ptr<geom::Geometry> &&);
+
+    /**
+    * 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 operation::union::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.
+    */
+    virtual bool isFloatingPrecision() const = 0;
+
+
+};
+
+} // namespace geos::operation::geounion
+} // namespace geos::operation
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/valid/ConsistentAreaTester.h

@@ -0,0 +1,137 @@
+/**********************************************************************
+ *
+ * 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: operation/valid/ConsistentAreaTester.java rev. 1.14 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geom/Coordinate.h> // for composition
+#include <geos/algorithm/LineIntersector.h> // for composition
+#include <geos/operation/relate/RelateNodeGraph.h> // for composition
+
+// Forward declarations
+namespace geos {
+namespace algorithm {
+class LineIntersector;
+}
+namespace geomgraph {
+class GeometryGraph;
+}
+namespace operation {
+namespace relate {
+class RelateNodeGraph;
+}
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace valid { // geos::operation::valid
+
+/** \brief
+ * Checks that a geomgraph::GeometryGraph representing an area
+ * (a geom::Polygon or geom::MultiPolygon)
+ * has consistent semantics for area geometries.
+ * This check is required for any reasonable polygonal model
+ * (including the OGC-SFS model, as well as models which allow ring
+ * self-intersection at single points)
+ *
+ * Checks include:
+ *
+ *  - test for rings which properly intersect
+ *    (but not for ring self-intersection, or intersections at vertices)
+ *  - test for consistent labelling at all node points
+ *    (this detects vertex intersections with invalid topology,
+ *    i.e. where the exterior side of an edge lies in the interior of the area)
+ *  - test for duplicate rings
+ *
+ * If an inconsistency is found the location of the problem
+ * is recorded and is available to the caller.
+ *
+ */
+class GEOS_DLL ConsistentAreaTester {
+private:
+
+    algorithm::LineIntersector li;
+
+    /// Not owned
+    geomgraph::GeometryGraph* geomGraph;
+
+    relate::RelateNodeGraph nodeGraph;
+
+    /// the intersection point found (if any)
+    geom::Coordinate invalidPoint;
+
+    /**
+     * Check all nodes to see if their labels are consistent.
+     * If any are not, return false
+     */
+    bool isNodeEdgeAreaLabelsConsistent();
+
+public:
+
+    /**
+     * Creates a new tester for consistent areas.
+     *
+     * @param newGeomGraph the topology graph of the area geometry.
+     *                     Caller keeps responsibility for its deletion
+     */
+    ConsistentAreaTester(geomgraph::GeometryGraph* newGeomGraph);
+
+    ~ConsistentAreaTester() = default;
+
+    /**
+     * @return the intersection point, or <code>null</code>
+     *         if none was found
+     */
+    geom::Coordinate& getInvalidPoint();
+
+    /** \brief
+     * Check all nodes to see if their labels are consistent with
+     * area topology.
+     *
+     * @return <code>true</code> if this area has a consistent node
+     *         labelling
+     */
+    bool isNodeConsistentArea();
+
+    /**
+     * Checks for two duplicate rings in an area.
+     * Duplicate rings are rings that are topologically equal
+     * (that is, which have the same sequence of points up to point order).
+     * If the area is topologically consistent (determined by calling the
+     * <code>isNodeConsistentArea</code>,
+     * duplicate rings can be found by checking for EdgeBundles which contain
+     * more than one geomgraph::EdgeEnd.
+     * (This is because topologically consistent areas cannot have two rings sharing
+     * the same line segment, unless the rings are equal).
+     * The start point of one of the equal rings will be placed in
+     * invalidPoint.
+     *
+     * @return true if this area Geometry is topologically consistent but has two duplicate rings
+     */
+    bool hasDuplicateRings();
+};
+
+
+
+} // namespace geos::operation::valid
+} // namespace geos::operation
+} // namespace geos
+