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

package/dist/prebuilt/linuxmusl-x64-mt-release/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/linuxmusl-x64-mt-release/include/geos/operation/spanning/SpanningTree.h

@@ -0,0 +1,59 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2026 Paul Ramsey
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Public Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Curve;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace spanning { // geos::operation::spanning
+
+/** \brief
+ * Constructs a Minimum Spanning Tree (MST) from a set of Curves.
+ *
+ * The input is a vector of Curves (LineString, CircularString, CompoundCurve)
+ * which form the edges of a graph.
+ * The nodes of the graph are the endpoints of the Curves.
+ * Coincident endpoints are treated as the same node.
+ *
+ * The algorithm uses Kruskal's algorithm to find the MST.
+ */
+class GEOS_DLL SpanningTree {
+
+public:
+    
+    /** \brief
+     * Computes the Minimum Spanning Tree of the given Curves.
+     *
+     * @param curves Input vector of Curves.
+     * @param result Output vector of size_t. 0 if the edge is not in the MST.
+     *               Values > 0 indicate the component ID of the subtree the edge belongs to.
+     *               The vector will be resized to match the input size.
+     */
+    static void mst(const std::vector<const geom::Curve*>& curves, std::vector<std::size_t>& result);
+
+};
+
+} // namespace geos::operation::spanning
+} // namespace geos::operation
+} // namespace geos

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/split/GeometrySplitter.h

@@ -0,0 +1,64 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2026 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 <memory>
+
+namespace geos::geom {
+class Curve;
+class Geometry;
+class Point;
+}
+
+namespace geos::operation::split {
+
+class GEOS_DLL GeometrySplitter {
+
+public:
+    /** Split a geometry.
+     *
+     * The geometry to be split must be a (Multi)LineString or (Multi)Polygon.
+     *
+     * The split geometry may contain any number of (Multi)Point, (Multi)LineString, or
+     * (Multi)Polygon elements.
+     *
+     * @param geom geometry to be split
+     * @param splitGeom "blade" and/or points defining where the geometry will be split
+     * @return a GeometryCollection containing the split parts
+     */
+    static std::unique_ptr<geom::Geometry>
+    split(const geom::Geometry& geom, const geom::Geometry& splitGeom);
+
+private:
+
+    static std::unique_ptr<geom::Geometry>
+    splitLinealWithEdge(const geom::Geometry& geom, const geom::Geometry& edge);
+
+    static std::unique_ptr<geom::Geometry>
+    splitPolygonalWithEdge(const geom::Geometry& geom, const geom::Geometry& edge);
+
+    static std::unique_ptr<geom::Geometry>
+    splitCurveWithPoint(const geom::Curve& g, const geom::Point& point);
+
+    static std::unique_ptr<geom::Geometry>
+    splitAtPoints(const geom::Geometry& geom, const geom::Geometry& splitPoints);
+
+    class SplitWithPointTransformer;
+
+    static constexpr double POINT_TO_LINE_TOLERANCE = 1e-10;
+};
+
+}

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/split/SplitLinealAtPoint.h

@@ -0,0 +1,90 @@
+/**********************************************************************
+*
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2026 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 <memory>
+#include <utility>
+
+// Forward declarations
+namespace geos::geom {
+class CircularString;
+class CompoundCurve;
+class CoordinateXY;
+class Curve;
+class LineString;
+class SimpleCurve;
+}
+
+namespace geos::operation::split {
+
+class GEOS_DLL SplitLinealAtPoint {
+
+public:
+    /** Split a curve into two sections at a specified vertex.
+     *
+     * If the vertex is the first or last vertex of the geometry, one of the returned
+     * geometries will be empty.
+     *
+     * If the input geometry is a CircularString, the vertex must be an endpoint of an arc.
+     *
+     * @param sc the curve to split
+     * @param i the index of the vertex to split at.
+     * @return a pair of split geometries.
+     */
+    static std::pair<std::unique_ptr<geom::SimpleCurve>, std::unique_ptr<geom::SimpleCurve>>
+    splitSimpleCurveAtVertex(const geom::SimpleCurve& sc, std::size_t i);
+
+    /** Split a SimpleCurve into two sections at an arbitrary point.
+     *
+     * @param sc the curve to split
+     * @param i the index of the vertex of the section (segment or arc) that contains pt
+     * @param pt the splitting point
+     * @return a pair of split geometries.
+     */
+    static std::pair<std::unique_ptr<geom::SimpleCurve>, std::unique_ptr<geom::SimpleCurve>>
+    splitSimpleCurveAtPoint(const geom::SimpleCurve &sc, std::size_t i, const geom::CoordinateXY &pt);
+
+    /** Split a CompoundCurve into two sections at an arbitrary point.
+     *
+     * @param sc the curve to split
+     * @param i the component that contains the splitting vertex
+     * @param j the index of the vertex of the section (segment or arc) that contains pt
+     * @param pt the splitting point
+     * @return a pair of split geometries.
+     */
+    static std::pair<std::unique_ptr<geom::Curve>, std::unique_ptr<geom::Curve>>
+    splitCompoundCurveAtPoint(const geom::CompoundCurve &sc, std::size_t i, std::size_t j, const geom::CoordinateXY &pt);
+
+    /** Split a CircularString into two sections at an arbitrary point. */
+    static std::pair<std::unique_ptr<geom::CircularString>, std::unique_ptr<geom::CircularString>>
+    splitCircularStringAtPoint(const geom::CircularString &ls, std::size_t i, const geom::CoordinateXY &pt);
+
+    /** Split CircularString into two sections at vertex i.
+     *  The vertex must be an endpoint of an arc. */
+    static std::pair<std::unique_ptr<geom::CircularString>, std::unique_ptr<geom::CircularString>>
+    splitCircularStringAtVertex(const geom::CircularString &cs, std::size_t i);
+
+    /** Split a LineString into two sections at an arbitrary point. */
+    static std::pair<std::unique_ptr<geom::LineString>, std::unique_ptr<geom::LineString>>
+    splitLineStringAtPoint(const geom::LineString &ls, std::size_t i, const geom::CoordinateXY &pt);
+
+    /** Split LineString into two sections at vertex i */
+    static std::pair<std::unique_ptr<geom::LineString>, std::unique_ptr<geom::LineString>>
+    splitLineStringAtVertex(const geom::LineString &ls, std::size_t i);
+
+};
+
+}

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

@@ -0,0 +1,256 @@
+/**********************************************************************
+ *
+ * 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 <vector>
+
+#include <geos/export.h>
+
+#include <geos/operation/union/UnionStrategy.h>
+#include <geos/util/Progress.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class GeometryFactory;
+class Geometry;
+class Surface;
+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:
+    const std::vector<const geom::Surface*>& 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
+     * surface components (dimension == 2).
+     *
+     * Extracts the [Surfaces](@ref geom::Surface) from the input
+     * and returns them as an appropriate polygonal geometry.
+     *
+     * If the input is already a surface, it is returned unchanged.
+     *
+     * A particular use case is to filter out non-surface components
+     * returned from an overlay operation.
+     *
+     * @param g the geometry to filter
+     * @return a Surface geometry
+     */
+    static std::unique_ptr<geom::Geometry> restrictToSurfaces(std::unique_ptr<geom::Geometry> g);
+
+public:
+
+    /** \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 std::vector<const geom::Surface*>& polys);
+    static std::unique_ptr<geom::Geometry> Union(const std::vector<const geom::Surface*>& polys, UnionStrategy* unionFun, geos::util::ProgressFunction* progressFunction);
+
+    /** \brief
+     * Computes the union of a set of surface [Geometrys](@ref geom::Geometry).
+     *
+     * @tparam T an iterator yielding something castable to const Surface*
+     * @param start start iterator
+     * @param end end iterator
+     * @param unionStrategy strategy to apply
+     * @param progressFunction progress function
+     */
+    template <class T>
+    static std::unique_ptr<geom::Geometry>
+    Union(T start, T end, UnionStrategy *unionStrategy, geos::util::ProgressFunction* progressFunction)
+    {
+        std::vector<const geom::Surface*> polys;
+        for(T i = start; i != end; ++i) {
+            const auto* p = dynamic_cast<const geom::Surface*>(*i);
+            polys.push_back(p);
+        }
+        return Union(polys, unionStrategy, progressFunction);
+    }
+
+    /** \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.
+     * @param progressFunction progress function
+     */
+    static std::unique_ptr<geom::Geometry> Union(const geom::MultiPolygon* polys, geos::util::ProgressFunction* progressFunction);
+
+    /** \brief
+     * Creates a new instance to union the given collection of
+     * [Geometrys](@ref geom::Geometry).
+     *
+     * @param polys a collection of surface [Geometrys](@ref geom::Geometry).
+     *              Ownership of elements *and* vector are left to caller.
+     */
+    explicit CascadedPolygonUnion(const std::vector<const geom::Surface*>& polys)
+        : inputPolys(polys)
+        , geomFactory(nullptr)
+        , unionFunction(&defaultUnionFunction)
+    {}
+
+    CascadedPolygonUnion(const std::vector<const geom::Surface*>& polys, UnionStrategy* unionFun)
+        : inputPolys(polys)
+        , geomFactory(nullptr)
+        , unionFunction(unionFun)
+    {}
+
+    /** \brief
+     * Computes the union of the input geometries.
+     *
+     * @param progressFunction progress function
+     * @return the union of the input geometries
+     * @return `null` if no input geometries were provided
+     */
+    std::unique_ptr<geom::Geometry> Union(geos::util::ProgressFunction* progressFunction);
+
+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,
+        std::function<void()>* unitProgress);
+
+    /**
+     * 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> &&) const;
+
+    /**
+     * 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/linuxmusl-x64-mt-release/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;
+    }
+}
+
+namespace geos {
+namespace operation {
+namespace geounion {
+
+    class GEOS_DLL CoverageUnion {
+        using Geometry = geos::geom::Geometry;
+        using GeometryFactory = geos::geom::GeometryFactory;
+        using Polygon = geos::geom::Polygon;
+        using LineString = geos::geom::LineString;
+        using LinearRing = geos::geom::LinearRing;
+        using LineSegment = geos::geom::LineSegment;
+
+
+    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;
+    };
+
+}
+}
+}