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

package/geos.xcframework/ios-arm64/Headers/geos/algorithm/LineToCurveConverter.h

@@ -0,0 +1,74 @@
+/**********************************************************************
+*
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2025-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 <geos/geom/util/CurveBuilder.h>
+
+#include <memory>
+
+namespace geos::algorithm {
+    class LineToCurveParams;
+}
+
+namespace geos::geom {
+    class CircularArc;
+    class CoordinateSequence;
+    class Curve;
+    class GeometryFactory;
+    class LineString;
+    class SimpleCurve;
+}
+
+namespace geos::algorithm {
+
+class GEOS_DLL LineToCurveConverter {
+
+public:
+
+    /** Construct a curved geometry from the provided LineString. The provided LineToCurveParams will be used
+     *  to determine when successive vertices of the LineString can be interpreted as a circular arc.
+     */
+    static std::unique_ptr<geom::Curve> getCurved(const geom::LineString& ls, const LineToCurveParams& params);
+
+private:
+
+    explicit LineToCurveConverter(const geom::GeometryFactory& factory, bool outputZ, bool outputM);
+
+    std::unique_ptr<geom::Curve> compute(const geom::LineString& ls, const LineToCurveParams& params);
+
+    void addArc(const geom::CircularArc& arc, std::size_t stop);
+
+    void addLineCoords(const geom::CoordinateSequence& points, std::size_t from, std::size_t to);
+
+    /*
+
+    void finishArc();
+
+    void finishLine();
+
+    std::shared_ptr<geom::CoordinateSequence> lineCoords;
+    std::shared_ptr<geom::CoordinateSequence> arcCoords;
+    std::vector<std::unique_ptr<geom::SimpleCurve>> curves;
+    const geom::GeometryFactory& factory;
+    */
+    geom::util::CurveBuilder curveBuilder;
+
+    /// Declared as non-copyable
+    LineToCurveConverter(const LineToCurveConverter& other);
+    LineToCurveConverter& operator=(const LineToCurveConverter& rhs);
+};
+
+}

package/geos.xcframework/ios-arm64/Headers/geos/algorithm/LineToCurveParams.h

@@ -0,0 +1,79 @@
+/**********************************************************************
+*
+ * 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 <geos/constants.h>
+#include <geos/util/IllegalArgumentException.h>
+
+namespace geos::algorithm {
+
+class GEOS_DLL LineToCurveParams {
+
+public:
+
+    // Get the radius tolerance. For p[x] to be considered a continuation of the same arc,
+    // its radius must be within tol * the arc radius as computed from p[0], p[1], p[2].
+    double getRadiusTolerance() const {
+        return radiusTolerance;
+    }
+
+    // Get the maximum angle in degrees between successive vertices, measured from the circle center.
+    double getMaxAngleDegrees() const {
+        return maxAngleRadians * 180 / MATH_PI;
+    }
+
+    // Get the maximum angle in radians between two successive vertices, measured from the circle center.
+    double getMaxAngleRadians() const {
+        return maxAngleRadians;
+    }
+
+    // Get the maximum difference in sequentially calculated angles along the same arc.
+    double getMaxAngleDifferenceRadians() const {
+        return maxAngleDifferenceRadians;
+    }
+
+    void setRadiusTolerance(double tol) {
+        if (!(tol > 0)) {
+            throw geos::util::IllegalArgumentException("Radius tolerance must be positive");
+        }
+        radiusTolerance = tol;
+    }
+
+    void setMaxAngleDifferenceRadians(double tol) {
+        if (!(tol > 0)) {
+            throw geos::util::IllegalArgumentException("Angle tolerance must be positive");
+        }
+        maxAngleDifferenceRadians = tol;
+    }
+
+    void setMaxAngleDifferenceDegrees(double tol) {
+        setMaxAngleDifferenceRadians(tol * MATH_PI / 180.0);
+    }
+
+    void setMaxStepDegrees(double tol) {
+        if (!(tol > 0)) {
+            throw util::IllegalArgumentException("Angle step tolerance must be positive");
+        }
+        maxAngleRadians = tol * MATH_PI / 180.0;
+    }
+
+private:
+    double radiusTolerance{1e-6};
+    double maxAngleRadians{45.01 * MATH_PI / 180.0};
+    double maxAngleDifferenceRadians{0.01};
+};
+
+}

package/geos.xcframework/ios-arm64/Headers/geos/algorithm/PointLocator.h

@@ -25,12 +25,16 @@
 // Forward declarations
 namespace geos {
 namespace geom {
+class CircularString;
+class CompoundCurve;
 class CoordinateXY;
+class Curve;
 class Geometry;
 class LinearRing;
 class LineString;
 class Polygon;
 class Point;
+class Surface;
 }
 }
 
@@ -96,9 +100,13 @@ private:
 
     geom::Location locate(const geom::CoordinateXY& p, const geom::LineString* l);
 
-    geom::Location locateInPolygonRing(const geom::CoordinateXY& p, const geom::LinearRing* ring);
+    geom::Location locate(const geom::CoordinateXY& p, const geom::CircularString* cs);
 
-    geom::Location locate(const geom::CoordinateXY& p, const geom::Polygon* poly);
+    geom::Location locate(const geom::CoordinateXY& p, const geom::CompoundCurve* cs);
+
+    static geom::Location locateInPolygonRing(const geom::CoordinateXY& p, const geom::Curve* ring);
+
+    static geom::Location locate(const geom::CoordinateXY& p, const geom::Surface* poly);
 
 };
 

package/geos.xcframework/ios-arm64/Headers/geos/algorithm/RayCrossingCounter.h

@@ -113,9 +113,7 @@ public:
     void countSegment(const geom::CoordinateXY& p1,
                       const geom::CoordinateXY& p2);
 
-    void countArc(const geom::CoordinateXY& p1,
-                  const geom::CoordinateXY& p2,
-                  const geom::CoordinateXY& p3);
+    void countArc(const geom::CircularArc& arc);
 
     /** \brief
      *  Counts all segments or arcs in the sequence

package/geos.xcframework/ios-arm64/Headers/geos/algorithm/distance/DiscreteHausdorffDistance.h

@@ -96,7 +96,7 @@ public:
 
     static double distance(const geom::Geometry& g0,
                            const geom::Geometry& g1, double densifyFrac);
-
+   
     DiscreteHausdorffDistance(const geom::Geometry& p_g0,
                               const geom::Geometry& p_g1)
         :
@@ -130,7 +130,7 @@ public:
         return ptDist.getDistance();
     }
 
-    const std::array<geom::CoordinateXY, 2>
+    const std::array<geom::CoordinateXY, 2>&
     getCoordinates() const
     {
         return ptDist.getCoordinates();

package/geos.xcframework/ios-arm64/Headers/geos/algorithm/distance/DistanceToPoint.h

@@ -18,6 +18,7 @@
 
 #pragma once
 
+#include <geos/export.h>
 #include <geos/geom/LineSegment.h> // for composition
 
 namespace geos {
@@ -43,7 +44,7 @@ namespace distance { // geos::algorithm::distance
  *
  * Also computes two points which are separated by the distance.
  */
-class DistanceToPoint {
+class GEOS_DLL DistanceToPoint {
 public:
 
     DistanceToPoint() {}

package/geos.xcframework/ios-arm64/Headers/geos/coverage/CoverageCleaner.h

@@ -288,7 +288,7 @@ public:
 
     /**
      * Sets the maximum width of the gaps that will be filled and merged.
-     * The width of a gap is twice the radius of the Maximum Inscribed Circle in the gap polygon,
+     * The width of a gap is the diameter of the Maximum Inscribed Circle in the gap polygon.
      * A width of zero prevents gaps from being merged.
      *
      * @param maxWidth the maximum gap width to merge
@@ -323,8 +323,8 @@ public:
      */
     std::vector<const Polygon*> getMergedGaps();
 
-    std::unique_ptr<Geometry> toGeometry(
-        std::vector<SegmentString*>& segStrings,
+    static std::unique_ptr<Geometry> toGeometry(
+        std::vector<std::unique_ptr<SegmentString>>& segStrings,
         const GeometryFactory* geomFact);
 
     std::unique_ptr<Geometry> node(

package/geos.xcframework/ios-arm64/Headers/geos/coverage/CoverageEdge.h

@@ -56,7 +56,7 @@ class GEOS_DLL CoverageEdge {
 private:
 
     // Members
-    std::unique_ptr<CoordinateSequence> m_pts;
+    std::shared_ptr<const CoordinateSequence> m_pts;
     std::size_t m_ringCount ;
     bool m_isFreeRing = true;
 
@@ -119,7 +119,7 @@ public:
         const GeometryFactory* geomFactory);
 
     std::unique_ptr<LineString> toLineString(
-        const GeometryFactory* geomFactory);
+        const GeometryFactory* geomFactory) const;
 
     /* public */
     void incRingCount()
@@ -144,14 +144,14 @@ public:
         return m_isFreeRing;
     }
 
-    void setCoordinates(const CoordinateSequence* pts)
+    void setCoordinates(const std::shared_ptr<const CoordinateSequence>& pts)
     {
-        m_pts = pts->clone();
+        m_pts = pts;
     }
 
-    const CoordinateSequence* getCoordinates() const
+    const std::shared_ptr<const CoordinateSequence>& getCoordinates() const
     {
-        return m_pts.get();
+        return m_pts;
     }
 
     const Coordinate& getEndCoordinate() const

package/geos.xcframework/ios-arm64/Headers/geos/coverage/CoverageEdges.h

@@ -0,0 +1,61 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2026 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>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+}
+}
+
+namespace geos {      // geos
+namespace coverage { // geos::coverage
+
+/**
+ * Utility to extract unique edges from a polygonal coverage.
+ *
+ * @author Paul Ramsey
+ *
+ */
+class GEOS_DLL CoverageEdges {
+public:
+
+    /**
+    * Returns a MultiLineString representing the unique edges of a polygonal coverage.
+    *
+    * @param coverage a vector of polygons in the coverage
+    * @param type selection type: 0 = ALL, 1 = EXTERIOR (non-shared), 2 = INTERIOR (shared)
+    * @return a MultiLineString of unique edges
+    */
+    static std::unique_ptr<geom::Geometry> GetEdges(const std::vector<const geom::Geometry*>& coverage, int type = 0);
+
+    /**
+    * Returns a MultiLineString representing the unique edges of a polygonal coverage.
+    *
+    * @param coverage a GeometryCollection or MultiPolygon representing the coverage
+    * @param type selection type: 0 = ALL, 1 = EXTERIOR (non-shared), 2 = INTERIOR (shared)
+    * @return a MultiLineString of unique edges
+    */
+    static std::unique_ptr<geom::Geometry> GetEdges(const geom::Geometry* coverage, int type = 0);
+
+};
+
+} // namespace geos::coverage
+} // namespace geos

package/geos.xcframework/ios-arm64/Headers/geos/coverage/CoveragePolygonValidator.h

@@ -204,7 +204,6 @@ private:
     double gapWidth = 0.0;
     std::vector<std::unique_ptr<CoveragePolygon>> m_adjCovPolygons;
     std::deque<CoverageRing> coverageRingStore;
-    std::vector<std::unique_ptr<CoordinateSequence>> localCoordinateSequences;
     std::deque<CoverageRingSegment> coverageRingSegmentStore;
 
     typedef std::unordered_map<CoverageRingSegment*, CoverageRingSegment*, CoverageRingSegment::CoverageRingSegHash, CoverageRingSegment::CoverageRingSegEq> CoverageRingSegmentMap;

package/geos.xcframework/ios-arm64/Headers/geos/coverage/CoverageRing.h

@@ -78,7 +78,7 @@ private:
 
 public:
 
-    CoverageRing(CoordinateSequence* pts, bool interiorOnRight);
+    CoverageRing(const std::shared_ptr<const CoordinateSequence>& pts, bool interiorOnRight);
 
     CoverageRing(const LinearRing* ring, bool isShell);
 

package/geos.xcframework/ios-arm64/Headers/geos/coverage/CoverageSimplifier.h

@@ -19,6 +19,7 @@
 #include <vector>
 #include <memory>
 #include <geos/export.h>
+#include <geos/util/Progress.h>
 
 
 namespace geos {
@@ -87,15 +88,18 @@ public:
     *
     * @param coverage a set of polygonal geometries forming a coverage
     * @param tolerance the simplification tolerance
+    * @param progressFunction Progress function, or nullptr.
     * @return the simplified polygons
     */
     static std::vector<std::unique_ptr<Geometry>> simplify(
         std::vector<const Geometry*>& coverage,
-        double tolerance);
+        double tolerance,
+        geos::util::ProgressFunction* progressFunction = nullptr);
 
     static std::vector<std::unique_ptr<Geometry>> simplify(
         const std::vector<std::unique_ptr<Geometry>>& coverage,
-        double tolerance);
+        double tolerance,
+        geos::util::ProgressFunction* progressFunction = nullptr);
 
     /**
     * Simplifies the inner boundaries of a set of polygonal geometries forming a coverage,
@@ -104,24 +108,28 @@ public:
     *
     * @param coverage a set of polygonal geometries forming a coverage
     * @param tolerance the simplification tolerance
+    * @param progressFunction Progress function, or nullptr.
     * @return the simplified polygons
     */
     static std::vector<std::unique_ptr<Geometry>> simplifyInner(
         std::vector<const Geometry*>& coverage,
-        double tolerance);
+        double tolerance,
+        geos::util::ProgressFunction* progressFunction);
 
     static std::vector<std::unique_ptr<Geometry>> simplifyInner(
         const std::vector<std::unique_ptr<Geometry>>& coverage,
-        double tolerance);
+        double tolerance,
+        geos::util::ProgressFunction* progressFunction);
 
     /**
     * Computes the simplified coverage, preserving the coverage topology.
     *
     * @param tolerance the simplification tolerance
+    * @param progressFunction Progress function, or nullptr.
     * @return the simplified polygons
     */
     std::vector<std::unique_ptr<Geometry>> simplify(
-        double tolerance);
+        double tolerance, geos::util::ProgressFunction* progressFunction);
 
     /**
     * Computes the inner-boundary simplified coverage,
@@ -129,10 +137,11 @@ public:
     * and leaving outer boundary edges unchanged.
     *
     * @param tolerance the simplification tolerance
+    * @param progressFunction Progress function, or nullptr.
     * @return the simplified polygons
     */
     std::vector<std::unique_ptr<Geometry>> simplifyInner(
-        double tolerance);
+        double tolerance, geos::util::ProgressFunction* progressFunction);
 
 
 private:
@@ -145,7 +154,8 @@ private:
     void simplifyEdges(
         std::vector<CoverageEdge*> edges,
         const MultiLineString* constraints,
-        double tolerance);
+        double tolerance,
+        geos::util::ProgressFunction* progressFunction);
 
     void setCoordinates(
         std::vector<CoverageEdge*>& edges,

package/geos.xcframework/ios-arm64/Headers/geos/coverage/TPVWSimplifier.h

@@ -21,6 +21,7 @@
 #include <geos/simplify/LinkedLine.h>
 #include <geos/coverage/Corner.h>
 #include <geos/export.h>
+#include <geos/util/Progress.h>
 
 
 namespace geos {
@@ -164,11 +165,13 @@ public:
     *
     * @param lines the lines to simplify
     * @param distanceTolerance the simplification tolerance
+    * @param progressFunction Progress function, or nullptr.
     * @return the simplified lines
     */
     static std::unique_ptr<MultiLineString> simplify(
         const MultiLineString* lines,
-        double distanceTolerance);
+        double distanceTolerance,
+        geos::util::ProgressFunction* progressFunction);
 
     /**
     * Simplifies a set of lines, preserving the topology of the lines between
@@ -181,13 +184,15 @@ public:
     * @param freeRings flags indicating which ring edges do not have node endpoints
     * @param constraintLines the linear constraints
     * @param distanceTolerance the simplification tolerance
+    * @param progressFunction Progress function, or nullptr.
     * @return the simplified lines
     */
     static std::unique_ptr<MultiLineString> simplify(
         const MultiLineString* lines,
         std::vector<bool>& freeRings,
         const MultiLineString* constraintLines,
-        double distanceTolerance);
+        double distanceTolerance,
+        geos::util::ProgressFunction* progressFunction);
 
     // Constructor
     TPVWSimplifier(const MultiLineString* lines,
@@ -209,11 +214,12 @@ private:
 
     void setConstraints(const MultiLineString* constraints);
 
-    std::unique_ptr<MultiLineString> simplify();
+    std::unique_ptr<MultiLineString> simplify(geos::util::ProgressFunction* progressFunction);
 
     std::vector<Edge> createEdges(
         const MultiLineString* lines,
-        std::vector<bool>& freeRing);
+        std::vector<bool>& freeRing,
+        geos::util::ProgressFunction* progressFunction);
 
 
 }; // TPVWSimplifier

package/geos.xcframework/ios-arm64/Headers/geos/dissolve/LineDissolver.h

@@ -83,6 +83,8 @@ private:
     std::vector<std::unique_ptr<LineString>> lines;
     std::stack<HalfEdge*> nodeEdgeStack;
     DissolveHalfEdge* ringStartEdge = nullptr;
+    bool constructZ = false;
+    bool constructM = false;
 
 
     void computeResult();
@@ -136,7 +138,7 @@ private:
 
     void buildRing(HalfEdge* eStartRing);
 
-    void addLine(std::unique_ptr<CoordinateSequence>& cs);
+    void addLine(const std::shared_ptr<CoordinateSequence>& cs);
 
 
 public:

package/geos.xcframework/ios-arm64/Headers/geos/edgegraph/HalfEdge.h

@@ -109,7 +109,7 @@ protected:
     *
     * @return the direction point for the edge
     */
-    virtual const geom::CoordinateXYZM& directionPt() const { return dest(); };
+    virtual const geom::CoordinateXY& directionPt() const { return dest(); };
 
 
 public: