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

package/geos_c.xcframework/Info.plist

@@ -10,7 +10,7 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64-simulator</string>
 			<key>LibraryPath</key>
 			<string>libgeos_c.a</string>
 			<key>SupportedArchitectures</key>
@@ -19,6 +19,8 @@
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
@@ -26,7 +28,7 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>libgeos_c.a</string>
 			<key>SupportedArchitectures</key>
@@ -35,8 +37,6 @@
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/geos_c.xcframework/ios-arm64/Headers/geos/algorithm/Angle.h

@@ -218,6 +218,34 @@ public:
     ///
     static double normalizePositive(double angle);
 
+    /// Returns true if angle x is within the counterclockwise
+    /// arc from angle a to angle b
+    ///
+    /// @param angle angle to test
+    /// @param from starting angle of arc
+    /// @param to ending angle of arc
+    ///
+    /// @return true if `angle` is within [from, to]
+    static bool isWithinCCW(double angle, double from, double to);
+
+    /// Return which of the two provided angles would be encountered first when moving
+    /// counterclockwise from the specified start angle.
+    ///
+    /// @param from the starting angle
+    /// @param a the first candidate angle
+    /// @param b the second candidate angle
+    ///
+    /// @return a or b
+    static double nextCCW(double from, double a, double b);
+
+    /// Return the fraction of an angle as a fraction of a larger angle
+    ///
+    /// @param x an angle between a and b
+    /// @param a the starting angle
+    /// @param b the ending angle
+    ///
+    /// @return a value in the range [0, 1]
+    static double fractionCCW(double x, double a, double b);
 
     /// Computes the unoriented smallest difference between two angles.
     ///

package/geos_c.xcframework/ios-arm64/Headers/geos/algorithm/CircularArcIntersector.h

@@ -0,0 +1,146 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2024-2025 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 <array>
+#include <cstdint>
+
+#include <geos/export.h>
+#include <geos/algorithm/LineIntersector.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CircularArc.h>
+
+namespace geos::algorithm {
+
+class GEOS_DLL CircularArcIntersector {
+public:
+    using CoordinateXY = geom::CoordinateXY;
+    using CoordinateXYZM = geom::CoordinateXYZM;
+    using CircularArc = geom::CircularArc;
+    using Envelope = geom::Envelope;
+
+    enum intersection_type : uint8_t {
+        NO_INTERSECTION = 0,
+        ONE_POINT_INTERSECTION = 1,
+        TWO_POINT_INTERSECTION = 2,
+        COCIRCULAR_INTERSECTION = 3,
+    };
+
+    explicit CircularArcIntersector(const geom::PrecisionModel* pm = nullptr)
+        : precisionModel(pm)
+    {}
+
+    intersection_type getResult() const
+    {
+        return result;
+    }
+
+    const CoordinateXYZM& getPoint(std::uint8_t i) const
+    {
+        return intPt[i];
+    }
+
+    const CircularArc& getArc(std::uint8_t i) const
+    {
+        return intArc[i];
+    }
+
+    std::uint8_t getNumPoints() const
+    {
+        return nPt;
+    }
+
+    std::uint8_t getNumArcs() const
+    {
+        return nArc;
+    }
+
+    /** Determines whether and where a circular arc intersects a line segment.
+     *
+     * Sets the appropriate value of intersection_type and stores the intersection points, if any.
+     *
+     * @param arc The circular arc
+     * @param seq A CoordinateSequence containing the points of the line segment
+     * @param pos0 The index of the first point in the line segment
+     * @param pos1 The index of the second point in the line segment
+     * @param useSegEndpoints Whether to preferentially take Z/M values from
+     *        the endpoints of the line segment rather than the arc.
+     */
+    void intersects(const CircularArc& arc, const geom::CoordinateSequence& seq, std::size_t pos0, std::size_t pos1, bool useSegEndpoints);
+
+    /** Determines whether and where two circular arcs intersect.
+     *
+     * 	Sets the appropriate value of intersection_type and stores the intersection
+     *  points and/or arcs, if any.
+     */
+    void intersects(const CircularArc& arc1, const CircularArc& arc2);
+
+    /** Determines whether and where two line segments intersect
+     *
+     * 	Sets the appropriate value of intersection_type and stores the intersection
+     *  points, if any.
+     */
+    void intersects(const geom::CoordinateSequence& p, std::size_t p0, std::size_t p1,
+                    const geom::CoordinateSequence& q, std::size_t q0, std::size_t q1);
+
+private:
+    void reset() {
+        nPt = 0;
+        nArc = 0;
+    }
+
+    /** Add an arc intersection of two cocircular arcs between the specified angles.
+     *
+     * The input arcs are provided so that Z/M values can be assigned to the created arc.
+     * When the endpoints of the new arc correspond with those of the inputs, Z/M values
+     * will be preferentially taken from arc1.
+     */
+    void addCocircularIntersection(double startAngle, double endAngle, int orientation, const CircularArc& arc1, const CircularArc& arc2);
+
+    /** Add a point intersection between two arcs.
+     *
+     * The input arcs are provided so that Z/M values can be assigned to the intersection point.
+     * When the intersection point corresponds matches one of the input arc endpoints,
+     * Z/M values will be taken from that endpoint, with arc1 having priority over arc2.
+     * If the intersection point does not equal the endpoint of either arc, its Z/M values
+     * will be interpolated.
+     */
+    void addArcArcIntersectionPoint(const CoordinateXY& computedIntPt, const CircularArc& arc1, const CircularArc& arc2);
+
+    /** Add a point intersection between an arc and a segment.
+     *
+     * The input arc and segment are provided so that Z/M values can be assigned to the intersection point.
+     * When the intersection point corresponds to the arc or segment endpoints, Z/M values
+     * will be taken from that endpoint. Priority will be given to the arc endpoints unless
+     * `useSegEndpoint` is true. If the intersection point does not equal the endpoint of the arc
+     * or the segment, its Z/M values will be interpolated.
+     */
+    void addArcSegmentIntersectionPoint(const CoordinateXY& computedIntPt, const CircularArc& lhs,
+        const geom::CoordinateSequence& seq, std::size_t pos0, std::size_t pos1, bool useSegEndpoints);
+
+    void computeCocircularIntersection(const CircularArc& arc1, const CircularArc& arc2);
+
+    /** Checks whether the provided point has already been recorded as an intersection point. */
+    bool hasIntersection(const geom::CoordinateXY& p) const;
+
+    std::array<CoordinateXYZM, 2> intPt;
+    std::array<CircularArc, 2> intArc;
+    const geom::PrecisionModel* precisionModel;
+    intersection_type result = NO_INTERSECTION;
+    std::uint8_t nPt = 0;
+    std::uint8_t nArc = 0;
+};
+
+}

package/geos_c.xcframework/ios-arm64/Headers/geos/algorithm/CircularArcs.h

@@ -16,7 +16,16 @@
 
 #include <geos/export.h>
 #include <geos/geom/Coordinate.h>
-#include <geos/geom/Envelope.h>
+
+#include <array>
+#include <optional>
+
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+class Envelope;
+}
+}
 
 namespace geos {
 namespace algorithm {
@@ -28,10 +37,240 @@ public:
     static geom::CoordinateXY getCenter(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1,
                                         const geom::CoordinateXY& p2);
 
+    static double getAngle(const geom::CoordinateXY& pt, const geom::CoordinateXY& center);
+
+    static geom::CoordinateXY getDirectionPoint(const geom::CoordinateXY& center, double radius, double theta, bool isCCW);
+
+    static double getMidpointAngle(double theta0, double theta2, bool isCCW);
+
+    static geom::CoordinateXY getMidpoint(const geom::CoordinateXY& p0, const geom::CoordinateXY& p2, const geom::CoordinateXY& center, double radius, bool isCCW);
+
     /// Expand an envelope to include an arc defined by three points
     static void expandEnvelope(geom::Envelope& e, const geom::CoordinateXY& p0, const geom::CoordinateXY& p1,
                                const geom::CoordinateXY& p2);
-};
 
+    /// Return the point defined by a circle center, radius, and angle
+    static geom::CoordinateXY createPoint(const geom::CoordinateXY& center, double radius, double theta);
+
+    /** Interpolate Z/M values for a point added to an arc.
+     *
+     * Interpolation will be performed between [p0, p1] or [p1, p2] depending on
+     * the position of the supplied point.
+     *
+     * @param seq CoordinateSequence containing the arc points
+     * @param i0 Index of the first point in the arc
+     * @param center The center point of the circle defining the arc
+     * @param isCCW Whether the arc is counterclockwise
+     * @param pt The point to interpolate Z/M values for
+     * @param z The interpolated Z value
+     * @param m The interpolated M value
+     */
+    static void interpolateZM(const geom::CoordinateSequence &seq, size_t i0, const geom::CoordinateXY &center, bool isCCW, geom::CoordinateXY &pt, double
+                              &z, double &m);
+
+    /** Determines whether and where a circle intersects a line.
+     *
+     * @param center The center point of the circle
+     * @param r The radius of the circle
+     * @param p0 One point defining a line of infinite length
+     * @param p1 Second point defining a line of infinite length
+     * @param isect0 Set to the first intersection point, if it exists
+     * @param isect1 Set to the second intersection point, if it exists
+     * @return The number of intersection points
+     */
+    static int
+    circleIntersectsLine(const geom::CoordinateXY& center, double r,
+                         const geom::CoordinateXY& p0, const geom::CoordinateXY& p1,
+                         geom::CoordinateXY& isect0, geom::CoordinateXY& isect1);
+
+    /** Determines whether and where a circle intersects a line segment.
+     *
+     * @param center The center point of the circle
+     * @param r The radius of the circle
+     * @param p0 The first point of the line segment
+     * @param p1 The second point of the line segment
+     * @param isect0 Set to the first intersection point, if it exists
+     * @param isect1 Set to the second intersection point, if it exists
+     * @return The number of intersection points
+     */
+    static int
+    circleIntersectsSegment(const geom::CoordinateXY& center, double r,
+                            const geom::CoordinateXY& p0, const geom::CoordinateXY& p1,
+                            geom::CoordinateXY& isect0, geom::CoordinateXY& isect1);
+
+    /** Returns whether an angle is included between two other angles.
+     *
+     * @param t0 starting angle (radians)
+     * @param t2 ending engle (radians)
+     * @param isCCW whether the interval from t0 to t2 is counterclockwise
+     * @param theta angle to test (radians)
+     * @return true if theta is included between t0 and t2
+     */
+    static bool
+    containsAngle(double t0, double t2, bool isCCW, double theta);
+
+    /** Returns whether a point on a circle is included between two arc endpoints.
+     *  It is assumed that the point lies on the circle; this is not tested.
+     *
+     * @param center The center coordinate of the circle
+     * @param p0 The first arc endpoint
+     * @param p2 The second arc endpoint
+     * @param isCCW Whether the arc between p0 and p2 is counterclockwise
+     * @param q The point to check for inclusion
+     * @return true if q is on the arc, false otherwise
+     */
+    static bool
+    containsPointOnCircle(const geom::CoordinateXY& center,
+                          const geom::CoordinateXY& p0, const geom::CoordinateXY& p2, bool isCCW,
+                          const geom::CoordinateXY& q);
+
+    /** Calculates the distance between an arc and a point.
+     *
+     * @param c The center coordinate of the circle
+     * @param r The radius of the circle
+     * @param p0 The first arc endpoint
+     * @param p2 The second arc endpoint
+     * @param isCCW Whether the arc between p0 and p2 is counterclockwise
+     * @param q The point to calculate distance to
+     * @return the distance between the arc and the point
+     */
+    static double
+    distanceArcPoint(const geom::CoordinateXY& c, double r,
+                     const geom::CoordinateXY& p0, const geom::CoordinateXY& p2, bool isCCW,
+                     const geom::CoordinateXY& q);
+
+    /** Calculates the distance between an arc and a line segment.
+     * @param c The center coordinate of the circle
+     * @param r The radius of the circle
+     * @param p0 The first arc endpoint
+     * @param p2 The second arc endpoint
+     * @param isCCW Whether the arc between p0 and p2 is counterclockwise
+     * @param q0 The first point of the line segment
+     * @param q1 The second point of the line segment
+     * @return the distance between the arc and the line segment
+     */
+    static double
+    distanceArcSegment(const geom::CoordinateXY& c, double r,
+                       const geom::CoordinateXY& p0, const geom::CoordinateXY& p2, bool isCCW,
+                       const geom::CoordinateXY& q0, const geom::CoordinateXY& q1);
+
+    /** Calculates the distance between two arcs.
+     *
+     * @param ca the center coordinate of the first arc's circle
+     * @param ra the radius of the first arc's circle
+     * @param a0 the first endpoint of the first arc
+     * @param a2 the second endpoint of the first arc
+     * @param aCCW whether the first arc is counterclockwise
+     * @param cb the center coordinate of the second arc's circle
+     * @param rb the radius of the second arc's circle
+     * @param b0 the first endpoint of the second arc
+     * @param b2 the second endpoint of the second arc
+     * @param bCCW whether the second arc is counterclockwise
+     * @return the distance between the two arcs
+     */
+    static double
+    distanceArcArc(const geom::CoordinateXY& ca, double ra,
+                   const geom::CoordinateXY& a0, const geom::CoordinateXY& a2, bool aCCW,
+                   const geom::CoordinateXY& cb, double rb,
+                   const geom::CoordinateXY& b0, const geom::CoordinateXY& b2, bool bCCW);
+
+    /** Return the closest point on an arc to a specified point.
+     *
+     * @param c the center of the arc
+     * @param r the radius of the arc
+     * @param p0 the first endpoint of the arc
+     * @param p2 the second endpoint of the arc
+     * @param isCCW whether the arc is counterclockwise
+     * @param q the point to find the closest point to
+     * @return the closest point on the arc to the specified point
+     */
+    static geom::CoordinateXY
+    closestPointArcPoint(const geom::CoordinateXY& c, double r,
+                         const geom::CoordinateXY& p0, const geom::CoordinateXY& p2,
+                         bool isCCW, const geom::CoordinateXY &q);
+
+    /** Return the pair of points having the shortest distance between an arc and a line segment
+     *
+     * @param c the center of the arc
+     * @param r the radius of the arc
+     * @param p0 the first endpoint of the arc
+     * @param p2 the second endpoint of the arc
+     * @param isCCW whether the arc is counterclockwise
+     * @param q0 the first endpoint of the line segment
+     * @param q1 the second endpoint of the line segment
+     * @return array whose first element is a point on the arc and second element is a point on the line segment
+     */
+    static std::array<geom::CoordinateXY, 2>
+    closestPointsArcSegment(const geom::CoordinateXY& c, double r,
+                            const geom::CoordinateXY& p0, const geom::CoordinateXY& p2, bool isCCW, const geom::CoordinateXY& q0, const geom::CoordinateXY& q1);
+
+
+    /** Return the pair of points having the shortest distance between two arcs
+     *
+     * @param ca the center of the first arc
+     * @param ra the radius of the first arc
+     * @param a0 the first endpoint of the first arc
+     * @param a2 the second endpoint of the first arc
+     * @param aCCW whether the first arc is counterclockwise
+     * @param cb the center of the second arc
+     * @param rb the radius of the second arc
+     * @param b0 the first endpoint of the second arc
+     * @param b2 the second endpoint of the second arc
+     * @param bCCW whether the second arc is counterclockwise
+     * @return array whose first element is a point on the first arc and second element is a point on the second arc
+     */
+    static std::array<geom::CoordinateXY, 2> closestPointsArcArc(const geom::CoordinateXY& ca,
+        double ra,
+        const geom::CoordinateXY& a0,
+        const geom::CoordinateXY& a2,
+        bool aCCW,
+        const geom::CoordinateXY& cb,
+        double rb,
+        const geom::CoordinateXY& b0,
+        const geom::CoordinateXY& b2,
+        bool bCCW);
+
+    /** Returns a single XY point of intersection between two cocircular arcs, if one exists.
+     *
+     * To identify all intersection point(s) and/or arc(s), with handling of Z and M ordinates, use CircularArcIntersector.
+     *
+     * @param center the center coordinate of the arcs
+     * @param radius the radius of the arcs
+     * @param a0 the first endpoint of the first arc
+     * @param a2 the second endpoint of the first arc
+     * @param aCCW whether the first arc is counterclockwise
+     * @param b0 the first endpoint of the second arc
+     * @param b2 the second endpoint of the second arc
+     * @param bCCW whether the second arc is counterclockwise
+     * @return a point of intersection between the two arcs, if one exists
+     */
+    static std::optional<geom::CoordinateXY>
+    cocircularArcsIntersectionPoint(const geom::CoordinateXY& center, double radius,
+                                    const geom::CoordinateXY& a0, const geom::CoordinateXY& a2, bool aCCW,
+                                    const geom::CoordinateXY& b0, const geom::CoordinateXY& b2, bool bCCW);
+
+    /** Returns a single point of intersection between two arcs, if one exists.
+     *
+     * To identify all intersection point(s) and/or arc(s), with handling of Z and M ordinates, use CircularArcIntersector.
+     *
+     * @param ca the center of the first arc
+     * @param ra the radius of the first arc
+     * @param a0 the first endpoint of the first arc
+     * @param a2 the second endpoint of the first arc
+     * @param aCCW whether the first arc is counterclockwise
+     * @param cb the center of the second arc
+     * @param rb the radius of the second arc
+     * @param b0 the first endpoint of the second arc
+     * @param b2 the second endpoint of the second arc
+     * @param bCCW whether the second arc is counterclockwise
+     * @return a point of intersection between the two arcs, if one exists
+     */
+    static std::optional<geom::CoordinateXY>
+    arcIntersectionPoint(const geom::CoordinateXY& ca, double ra,
+                         const geom::CoordinateXY& a0, const geom::CoordinateXY& a2, bool aCCW,
+                         const geom::CoordinateXY& cb, double rb,
+                         const geom::CoordinateXY& b0, const geom::CoordinateXY& b2, bool bCCW);
+
+};
 }
 }

package/geos_c.xcframework/ios-arm64/Headers/geos/algorithm/CurveToLineParams.h

@@ -0,0 +1,76 @@
+/**********************************************************************
+*
+ * 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/geom/CircularArc.h>
+
+namespace geos::algorithm {
+
+class GEOS_DLL CurveToLineParams {
+
+public:
+
+    CurveToLineParams() :
+      m_maxStepDegrees(4.0),
+      m_maxDeviation(DoubleInfinity) {}
+
+    CurveToLineParams& setMaxStepDegrees(double value) {
+        if (!(value > 0)) {
+            throw util::IllegalArgumentException("Step size must be positive");
+        }
+
+        m_maxStepDegrees = value;
+
+        return *this;
+    }
+
+    CurveToLineParams& setMaxDeviation(double value) {
+        if (!(value > 0)) {
+            throw util::IllegalArgumentException("Max deviation must be positive");
+        }
+
+        m_maxDeviation = value;
+
+        return *this;
+    }
+
+    static CurveToLineParams maxDeviation(double dev) {
+        return CurveToLineParams()
+          .setMaxStepDegrees(DoubleInfinity)
+          .setMaxDeviation(dev);
+    }
+
+    static CurveToLineParams stepSizeDegrees(double stepSize) {
+        return CurveToLineParams()
+          .setMaxStepDegrees(stepSize)
+          .setMaxDeviation(DoubleInfinity);
+    }
+
+    double getStepSizeDegrees(const geom::CircularArc& arc) const {
+        const double deviationRatio = 1 - m_maxDeviation / arc.getRadius();
+        const double maxStepFromDeviation = deviationRatio < 0 ? 180 : std::acos(deviationRatio) * 360 / MATH_PI;
+
+        return std::min(m_maxStepDegrees, maxStepFromDeviation);
+    }
+
+private:
+
+    double m_maxStepDegrees;
+    double m_maxDeviation;
+
+};
+
+}

package/geos_c.xcframework/ios-arm64/Headers/geos/algorithm/Interpolate.h

@@ -160,7 +160,7 @@ public:
         return get<geom::Ordinate::M>(p, q);
     }
 
-    /// Return a coordinates's non-NaN Z value or interpolate it from two other coordinates if it is NaN.
+    /// Return a coordinate's non-NaN Z value or interpolate it from two other coordinates if it is NaN.
     template<typename C1, typename C2>
     static double
     zGetOrInterpolate(const C1& p, const C2& p1, const C2& p2)
@@ -168,7 +168,7 @@ public:
         return getOrInterpolate<geom::Ordinate::Z>(p, p1, p2);
     }
 
-    /// Return a coordinates's non-NaN M value or interpolate it from two other coordinates if it is NaN.
+    /// Return a coordinate's non-NaN M value or interpolate it from two other coordinates if it is NaN.
     template<typename C1, typename C2>
     static double
     mGetOrInterpolate(const C1& p, const C2& p1, const C2& p2)
@@ -176,6 +176,21 @@ public:
         return getOrInterpolate<geom::Ordinate::M>(p, p1, p2);
     }
 
+    static double
+    getOrAverage(double a, double b)
+    {
+        if (std::isnan(a)) {
+            return b;
+        }
+
+        if (std::isnan(b)) {
+            return a;
+        }
+
+        return 0.5*(a+b);
+    }
+
+
 };
 
 }

package/geos_c.xcframework/ios-arm64/Headers/geos/algorithm/LineIntersector.h

@@ -111,7 +111,7 @@ public:
      * @return <code>true</code> if either intersection point is in
      * the interior of the input segment
      */
-    bool isInteriorIntersection(std::size_t inputLineIndex)
+    bool isInteriorIntersection(std::size_t inputLineIndex) const
     {
         for(std::size_t i = 0; i < result; ++i) {
             if(!(intPt[i].equals2D(*inputLines[inputLineIndex][0])
@@ -161,6 +161,10 @@ public:
     void computeIntersection(const geom::CoordinateSequence& p, std::size_t p0,
                              const geom::CoordinateSequence& q, std::size_t q0);
 
+    /// Compute the intersection between two segments, given a sequence and indices of each endpoint
+    void computeIntersection(const geom::CoordinateSequence& p, std::size_t p0, std::size_t p1,
+                             const geom::CoordinateSequence& q, std::size_t q0, std::size_t q1);
+
     std::string toString() const;
 
     /**

package/geos_c.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);
+};
+
+}