@crossbind/port-geos-ios 2.0.0-beta.53 → 2.0.0-beta.58

package/geos_c.xcframework/ios-arm64/Headers/geos/operation/polygonize/Polygonizer.h

@@ -72,7 +72,7 @@ namespace polygonize { // geos::operation::polygonize
  * - <b>Invalid Ring Lines</b> - edges which form rings which are invalid
  *   (e.g. the component lines contain a self-intersection)
  *
- *   The Polygonizer constructor allows extracting only polygons which form a
+ *   The Polygonizer constructor allows extracting only (Curve)Polygons which form a
  *   valid polygonal result.
  *   The set of extracted polygons is guaranteed to be edge-disjoint.
  *   This is useful when it is known that the input lines form a valid
@@ -84,23 +84,23 @@ private:
     /**
      * Add every linear element in a geometry into the polygonizer graph.
      */
-    class GEOS_DLL LineStringAdder: public geom::GeometryComponentFilter {
+    class GEOS_DLL SimpleCurveAdder: public geom::GeometryComponentFilter {
     public:
         Polygonizer* pol;
-        explicit LineStringAdder(Polygonizer* p);
+        explicit SimpleCurveAdder(Polygonizer* p);
         //void filter_rw(geom::Geometry *g);
         void filter_ro(const geom::Geometry* g) override;
     };
 
     // default factory
-    LineStringAdder lineStringAdder;
+    SimpleCurveAdder lineStringAdder;
 
     /**
-     * Add a linestring to the graph of polygon edges.
+     * Add a curve to the graph of polygon edges.
      *
-     * @param line the {@link LineString} to add
+     * @param line the {@link SimpleCurve} to add
      */
-    void add(const geom::LineString* line);
+    void add(const geom::SimpleCurve* line);
 
     /**
      * Perform the polygonization, if it has not already been carried out.
@@ -116,11 +116,11 @@ private:
      * discarding rings which correspond to outer rings and hence contain
      * duplicate linework.
      */
-    std::vector<std::unique_ptr<geom::LineString>> extractInvalidLines(
-            std::vector<EdgeRing*>& invalidRings);
+    static std::vector<std::unique_ptr<geom::Curve> > extractInvalidLines(
+        std::vector<EdgeRing *> &invalidRings);
 
     /**
-     * Tests if a invalid ring should be included in
+     * Tests if an invalid ring should be included in
      * the list of reported invalid rings.
      *
      * Rings are included only if they contain
@@ -134,7 +134,7 @@ private:
      * @param invalidRing the ring to test
      * @return true if the ring should be included
      */
-    bool isIncludedInvalid(EdgeRing* invalidRing);
+    static bool isIncludedInvalid(const EdgeRing* invalidRing);
 
     void findShellsAndHoles(const std::vector<EdgeRing*>& edgeRingList);
 
@@ -142,7 +142,7 @@ private:
 
     static void findOuterShells(std::vector<EdgeRing*>& shellList);
 
-    static std::vector<std::unique_ptr<geom::Polygon>> extractPolygons(std::vector<EdgeRing*> & shellList, bool includeAll);
+    static std::vector<std::unique_ptr<geom::Surface>> extractPolygons(std::vector<EdgeRing*> & shellList, bool includeAll);
 
     bool extractOnlyPolygonal;
     bool computed;
@@ -152,13 +152,13 @@ protected:
     std::unique_ptr<PolygonizeGraph> graph;
 
     // initialize with empty collections, in case nothing is computed
-    std::vector<const geom::LineString*> dangles;
-    std::vector<const geom::LineString*> cutEdges;
-    std::vector<std::unique_ptr<geom::LineString>> invalidRingLines;
+    std::vector<const geom::SimpleCurve*> dangles;
+    std::vector<const geom::SimpleCurve*> cutEdges;
+    std::vector<std::unique_ptr<geom::Curve>> invalidRingLines;
 
     std::vector<EdgeRing*> holeList;
     std::vector<EdgeRing*> shellList;
-    std::vector<std::unique_ptr<geom::Polygon>> polyList;
+    std::vector<std::unique_ptr<geom::Surface>> polyList;
 
 public:
 
@@ -203,22 +203,34 @@ public:
     void add(const geom::Geometry* g);
 
     /** \brief
-     * Gets the list of polygons formed by the polygonization.
+     * Gets the list of Polygons formed by the polygonization.
+     * Any CurvePolygons formed will be omitted. This function
+     * is provided for backward-compatibility with callers
+     * expecting a return type of Polygon.
      *
-     * Ownership of vector is transferred to caller, subsequent
-     * calls will return NULL.
+     * Ownership of geometries is transferred to caller. Subsequent
+     * calls will return an empty vector.
      * @return a collection of Polygons
      */
     std::vector<std::unique_ptr<geom::Polygon>> getPolygons();
 
+    /** \brief
+     * Gets the list of (Curve)Polygons formed by the polygonization.
+     *
+     * Ownership of geometries is transferred to caller. Subsequent
+     * calls will return an empty vector.
+     * @return a collection of Polygons
+     */
+    std::vector<std::unique_ptr<geom::Surface>> getSurfaces();
+
     /** \brief
      * Get the list of dangling lines found during polygonization.
      *
      * @return a (possibly empty) collection of pointers to
-     *         the input LineStrings which are dangles.
+     *         the input LineStrings or CircularStrings which are dangles.
      *
      */
-    const std::vector<const geom::LineString*>& getDangles();
+    const std::vector<const geom::SimpleCurve*>& getDangles();
 
     bool hasDangles();
 
@@ -226,10 +238,10 @@ public:
      * Get the list of cut edges found during polygonization.
      *
      * @return a (possibly empty) collection of pointers to
-     *         the input LineStrings which are cut edges.
+     *         the input LineStrings or CircularStrings which are cut edges.
      *
      */
-    const std::vector<const geom::LineString*>& getCutEdges();
+    const std::vector<const geom::SimpleCurve*>& getCutEdges();
 
     bool hasCutEdges();
 
@@ -238,17 +250,17 @@ public:
      * polygonization.
      *
      * @return a (possibly empty) collection of pointers to
-     *         the input LineStrings which form invalid rings
+     *         the invalid rings
      *
      */
-    const std::vector<std::unique_ptr<geom::LineString>>& getInvalidRingLines();
+    const std::vector<std::unique_ptr<geom::Curve>>& getInvalidRingLines();
 
     bool hasInvalidRingLines();
 
     bool allInputsFormPolygons();
 
-// This seems to be needed by    GCC 2.95.4
-    friend class Polygonizer::LineStringAdder;
+// This seems to be needed by GCC 2.95.4
+    friend class Polygonizer::SimpleCurveAdder;
 };
 
 } // namespace geos::operation::polygonize

package/geos_c.xcframework/ios-arm64/Headers/geos/operation/relateng/RelateGeometry.h

@@ -87,7 +87,6 @@ private:
      */
     std::vector<std::unique_ptr<const RelateSegmentString>> segStringTempStore;
     std::vector<std::unique_ptr<const RelateSegmentString>> segStringPermStore;
-    std::vector<std::unique_ptr<CoordinateSequence>> csStore;
 
 
     // Methods
@@ -133,11 +132,11 @@ private:
         std::vector<const SegmentString*>& segStrings,
         std::vector<std::unique_ptr<const RelateSegmentString>>& segStore);
 
-    const CoordinateSequence* orientAndRemoveRepeated(
-        const CoordinateSequence* cs, bool orientCW);
+    static std::shared_ptr<const CoordinateSequence> orientAndRemoveRepeated(
+        const std::shared_ptr<const CoordinateSequence>& cs, bool orientCW);
 
-    const CoordinateSequence* removeRepeated(
-        const CoordinateSequence* cs);
+    static std::shared_ptr<const CoordinateSequence> removeRepeated(
+        const std::shared_ptr<const CoordinateSequence>& cs);
 
 public:
 

package/geos_c.xcframework/ios-arm64/Headers/geos/operation/relateng/RelateSegmentString.h

@@ -62,14 +62,14 @@ private:
 
     // Constructor
     RelateSegmentString(
-        const CoordinateSequence* pts,
+        std::shared_ptr<const CoordinateSequence> pts,
         bool isA,
         int dimension,
         int id,
         int ringId,
         const Geometry* poly,
         const RelateGeometry* inputGeom)
-        : BasicSegmentString(const_cast<CoordinateSequence*>(pts), nullptr)
+        : BasicSegmentString(pts, nullptr)
         , m_isA(isA)
         , m_dimension(dimension)
         , m_id(id)
@@ -82,7 +82,7 @@ private:
     // Methods
 
     static const RelateSegmentString* createSegmentString(
-        const CoordinateSequence* pts,
+        const std::shared_ptr<const CoordinateSequence>& pts,
         bool isA, int dim, int elementId, int ringId,
         const Geometry* poly, const RelateGeometry* parent);
 
@@ -111,14 +111,14 @@ private:
 public:
 
     static const RelateSegmentString* createLine(
-        const CoordinateSequence* pts,
+        const std::shared_ptr<const CoordinateSequence> &pts,
         bool isA, int elementId,
-        const RelateGeometry* parent);
+        const RelateGeometry *parent);
 
     static const RelateSegmentString* createRing(
-        const CoordinateSequence* pts,
+        const std::shared_ptr<const CoordinateSequence> &pts,
         bool isA, int elementId, int ringId,
-        const Geometry* poly, const RelateGeometry* parent);
+        const Geometry *poly, const RelateGeometry *parent);
 
     inline bool isA() const {
         return m_isA;
@@ -132,7 +132,7 @@ public:
         return m_parentPolygonal;
     }
 
-    NodeSection* createNodeSection(std::size_t segIndex, const CoordinateXY intPt) const;
+    NodeSection* createNodeSection(std::size_t segIndex, const CoordinateXY &intPt) const;
 
     /**
      * Tests if a segment intersection point has that segment as its

package/geos_c.xcframework/ios-arm64/Headers/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/geos_c.xcframework/ios-arm64/Headers/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/geos_c.xcframework/ios-arm64/Headers/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/geos_c.xcframework/ios-arm64/Headers/geos/operation/union/CascadedPolygonUnion.h

@@ -25,13 +25,14 @@
 #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 Polygon;
+class Surface;
 class MultiPolygon;
 class Envelope;
 }
@@ -102,7 +103,7 @@ private:
  */
 class GEOS_DLL CascadedPolygonUnion {
 private:
-    std::vector<geom::Polygon*>* inputPolys;
+    const std::vector<const geom::Surface*>& inputPolys;
     geom::GeometryFactory const* geomFactory;
 
     /**
@@ -115,23 +116,23 @@ private:
     static int const STRTREE_NODE_CAPACITY = 4;
 
     /** \brief
-     * Computes a [Geometry](@ref geom::Geometry) containing only polygonal components.
+     * Computes a [Geometry](@ref geom::Geometry) containing only
+     * surface components (dimension == 2).
      *
-     * Extracts the [Polygons](@ref geom::Polygon) from the input
+     * Extracts the [Surfaces](@ref geom::Surface) from the input
      * and returns them as an appropriate polygonal geometry.
      *
-     * If the input is already `Polygonal`, it is returned unchanged.
+     * If the input is already a surface, it is returned unchanged.
      *
-     * A particular use case is to filter out non-polygonal components
+     * A particular use case is to filter out non-surface components
      * returned from an overlay operation.
      *
      * @param g the geometry to filter
-     * @return a Polygonal geometry
+     * @return a Surface geometry
      */
-    static std::unique_ptr<geom::Geometry> restrictToPolygons(std::unique_ptr<geom::Geometry> g);
+    static std::unique_ptr<geom::Geometry> restrictToSurfaces(std::unique_ptr<geom::Geometry> g);
 
 public:
-    CascadedPolygonUnion();
 
     /** \brief
      * Computes the union of a collection of polygonal [Geometrys](@ref geom::Geometry).
@@ -139,27 +140,28 @@ public:
      * @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);
+    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 polygonal [Geometrys](@ref geom::Geometry).
+     * Computes the union of a set of surface [Geometrys](@ref geom::Geometry).
      *
-     * @tparam T an iterator yielding something castable to const Polygon *
+     * @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)
+    Union(T start, T end, UnionStrategy *unionStrategy, geos::util::ProgressFunction* progressFunction)
     {
-        std::vector<geom::Polygon*> polys;
+        std::vector<const geom::Surface*> 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));
+            const auto* p = dynamic_cast<const geom::Surface*>(*i);
+            polys.push_back(p);
         }
-        return Union(&polys, unionStrategy);
+        return Union(polys, unionStrategy, progressFunction);
     }
 
     /** \brief
@@ -167,23 +169,24 @@ public:
      *
      * @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);
+    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 polygonal [Geometrys](@ref geom::Geometry).
+     * @param polys a collection of surface [Geometrys](@ref geom::Geometry).
      *              Ownership of elements *and* vector are left to caller.
      */
-    CascadedPolygonUnion(std::vector<geom::Polygon*>* polys)
+    explicit CascadedPolygonUnion(const std::vector<const geom::Surface*>& polys)
         : inputPolys(polys)
         , geomFactory(nullptr)
         , unionFunction(&defaultUnionFunction)
     {}
 
-    CascadedPolygonUnion(std::vector<geom::Polygon*>* polys, UnionStrategy* unionFun)
+    CascadedPolygonUnion(const std::vector<const geom::Surface*>& polys, UnionStrategy* unionFun)
         : inputPolys(polys)
         , geomFactory(nullptr)
         , unionFunction(unionFun)
@@ -192,10 +195,11 @@ public:
     /** \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();
+    std::unique_ptr<geom::Geometry> Union(geos::util::ProgressFunction* progressFunction);
 
 private:
 
@@ -211,7 +215,11 @@ private:
      * @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::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,
@@ -224,7 +232,7 @@ private:
      */
     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> &&);
+    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.