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

package/geos.xcframework/ios-arm64/Headers/geos/geom/CircularArc.h

@@ -3,7 +3,7 @@
  * GEOS - Geometry Engine Open Source
  * http://geos.osgeo.org
  *
- * Copyright (C) 2024 ISciences, LLC
+ * 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
@@ -16,10 +16,15 @@
 
 #include <geos/export.h>
 #include <geos/geom/Coordinate.h>
+#include <geos/geom/LineSegment.h>
 #include <geos/geom/Quadrant.h>
 #include <geos/algorithm/CircularArcs.h>
 #include <geos/algorithm/Orientation.h>
-#include <geos/triangulate/quadedge/TrianglePredicate.h>
+
+// Forward declarations
+namespace geos::algorithm {
+class CurveToLineParams;
+}
 
 namespace geos {
 namespace geom {
@@ -29,119 +34,164 @@ namespace geom {
 class GEOS_DLL CircularArc {
 public:
 
-    using CoordinateXY = geom::CoordinateXY;
+    /// Create an empty CircularArc backed by a null CoordinateSequence. A CircularArc created in this way will
+    /// crash if methods are called on it, but a default constructor is necessary to construct std::array<CircularArc, >
+    CircularArc();
 
-    CircularArc(const CoordinateXY& q0, const CoordinateXY& q1, const CoordinateXY& q2)
-        : p0(q0)
-        , p1(q1)
-        , p2(q2)
-        , m_center_known(false)
-        , m_radius_known(false)
-        , m_orientation_known(false)
-    {}
+    /// Create a CircularArc that refers to points in the provided CoordinateSequence. The CoordinateSequence is not
+    /// owned by the CircularArc and should remain reachable for the lifetime of the CircularArc.
+    /// The center, radius, and orientation can be specified to avoid lossy re-computation. They are not checked for
+    /// consistency with the references coordinates.
+    CircularArc(const CoordinateSequence&, std::size_t pos);
+    CircularArc(const CoordinateSequence&, std::size_t pos, const CoordinateXY& center, double radius, int orientation);
 
-    const CoordinateXY& p0;
-    const CoordinateXY& p1;
-    const CoordinateXY& p2;
+    /// Create a CircularArc that refers to points in the provided CoordinateSequence.
+    /// Ownership of the CoordinateSequence is transferred to the CircularArc.
+    /// The center, radius, and orientation can be specified to avoid lossy re-computation. They are not checked for
+    /// consistency with the references coordinates.
+    CircularArc(std::unique_ptr<CoordinateSequence>, std::size_t pos);
+    CircularArc(std::unique_ptr<CoordinateSequence>, std::size_t pos, const CoordinateXY& center, double radius, int orientation);
 
-    /// Return the orientation of the arc as one of:
-    /// - algorithm::Orientation::CLOCKWISE,
-    /// - algorithm::Orientation::COUNTERCLOCKWISE
-    /// - algorithm::Orientation::COLLINEAR
-    int orientation() const {
-        if (!m_orientation_known) {
-            m_orientation = algorithm::Orientation::index(p0, p1, p2);
-            m_orientation_known = true;
-        }
-        return m_orientation;
+    CircularArc(const CircularArc& other);
+
+    CircularArc(CircularArc&&) noexcept;
+
+    CircularArc& operator=(const CircularArc& other);
+    CircularArc& operator=(CircularArc&&) noexcept;
+
+    ~CircularArc();
+
+    /// Create a CircularArc from the given coordinates, automatically allocating a CoordinateSequence to store them.
+    /// Typically, it is more efficient to create a larger CoordinateSequence that multiple CircularArcs refer to.
+    /// However, the "create" methods are convenient for writing tests.
+    template<typename CoordType>
+    static CircularArc create(const CoordType& p0, const CoordType& p1, const CoordType& p2)
+    {
+        auto seq = std::make_unique<CoordinateSequence>(3, CoordType::template has<Ordinate::Z>(), CoordType::template has<Ordinate::M>());
+        seq->setAt(p0, 0);
+        seq->setAt(p1, 1);
+        seq->setAt(p2, 2);
+
+        CircularArc ret(std::move(seq), 0);
+
+        return ret;
     }
 
+    static CircularArc create(const CoordinateXY& p0, const CoordinateXY& p2, const CoordinateXY& center, double radius, int orientation);
+    static CircularArc create(const Coordinate& p0, const Coordinate& p2, const CoordinateXY& center, double radius, int orientation);
+    static CircularArc create(const CoordinateXYM& p0, const CoordinateXYM& p2, const CoordinateXY& center, double radius, int orientation);
+    static CircularArc create(const CoordinateXYZM& p0, const CoordinateXYZM& p2, const CoordinateXY& center, double radius, int orientation);
+
+    /// Return the inner angle of the sector associated with this arc
+    double getAngle() const;
+
+    /// Return the area enclosed by the arc p0-p1-p2 and the line segment p2-p0
+    double getArea() const;
+
     /// Return the center point of the circle associated with this arc
     const CoordinateXY& getCenter() const {
         if (!m_center_known) {
-            m_center = algorithm::CircularArcs::getCenter(p0, p1, p2);
+            if (isCCW()) {
+                m_center = algorithm::CircularArcs::getCenter(p0(), p1(), p2());
+            } else {
+                m_center = algorithm::CircularArcs::getCenter(p2(), p1(), p0());
+            }
             m_center_known = true;
         }
 
         return m_center;
     }
 
-    /// Return the radius of the circle associated with this arc
-    double getRadius() const {
-        if (!m_radius_known) {
-            m_radius = getCenter().distance(p0);
-            m_radius_known = true;
-        }
-
-        return m_radius;
+    const CoordinateSequence* getCoordinateSequence() const {
+        return m_seq;
     }
 
-    /// Return whether this arc forms a complete circle
-    bool isCircle() const {
-        return p0.equals(p2);
+    std::size_t getCoordinatePosition() const {
+        return m_pos;
     }
 
-    /// Returns whether this arc forms a straight line (p0, p1, and p2 are collinear)
-    bool isLinear() const {
-        return std::isnan(getRadius());
-    }
+    /// Computes a direction point suitable for ordering arcs with the same
+    /// origin point. The direction point is located at a distance R along the
+    /// line tangent to the arc at the origin point.
+    CoordinateXY getDirectionPoint() const;
 
-    /// Return the inner angle of the sector associated with this arc
-    double getAngle() const {
-        if (isCircle()) {
-            return 2*MATH_PI;
-        }
+    CoordinateXY getReverseDirectionPoint() const;
 
-        /// Even Rouault:
-        /// potential optimization?: using crossproduct(p0 - center, p2 - center) = radius * radius * sin(angle)
-        /// could yield the result by just doing a single asin(), instead of 2 atan2()
-        /// actually one should also likely compute dotproduct(p0 - center, p2 - center) = radius * radius * cos(angle),
-        /// and thus angle = atan2(crossproduct(p0 - center, p2 - center) , dotproduct(p0 - center, p2 - center) )
-        auto t0 = theta0();
-        auto t2 = theta2();
+    Envelope getEnvelope() const;
 
-        if (orientation() == algorithm::Orientation::COUNTERCLOCKWISE) {
-            std::swap(t0, t2);
-        }
+    /// Return the length of the arc
+    double getLength() const;
+
+    /// Add linearized points representing this arc to the provided CoordinateSequence.
+    /// The origin point of the arc will NOT be added.
+    void addLinearizedPoints(CoordinateSequence& seq, const algorithm::CurveToLineParams& params) const;
 
-        if (t0 < t2) {
-            t0 += 2*MATH_PI;
+    /// Return the orientation of the arc as one of:
+    /// - algorithm::Orientation::CLOCKWISE,
+    /// - algorithm::Orientation::COUNTERCLOCKWISE
+    /// - algorithm::Orientation::COLLINEAR
+    int getOrientation() const {
+        if (!m_orientation_known) {
+            m_orientation = algorithm::Orientation::index(p0(), p1(), p2());
+            m_orientation_known = true;
         }
+        return m_orientation;
+    }
 
-        auto diff = t0-t2;
+    /// Return the radius of the circle associated with this arc
+    double getRadius() const {
+        if (!m_radius_known) {
+            if (isCCW()) {
+                m_radius = getCenter().distance(p0());
+            } else {
+                m_radius = getCenter().distance(p2());
+            }
+            m_radius_known = true;
+        }
 
-        return diff;
+        return m_radius;
     }
 
-    /// Return the length of the arc
-    double getLength() const {
-        if (isLinear()) {
-            return p0.distance(p2);
-        }
+    /// Return the distance from the centerpoint of the arc to the line segment formed by the end points of the arc.
+    double getSagitta() const {
+        CoordinateXY midpoint = algorithm::CircularArcs::getMidpoint(p0(), p2(), getCenter(), getRadius(), isCCW());
+        return algorithm::Distance::pointToSegment(midpoint, p0(), p2());
+    }
 
-        return getAngle()*getRadius();
+    bool isCCW() const {
+        return getOrientation() == algorithm::Orientation::COUNTERCLOCKWISE;
     }
 
-    /// Return the area enclosed by the arc p0-p1-p2 and the line segment p2-p0
-    double getArea() const {
-        if (isLinear()) {
-            return 0;
-        }
+    /// Return whether this arc forms a complete circle
+    bool isCircle() const {
+        return p0().equals(p2());
+    }
 
-        auto R = getRadius();
-        auto theta = getAngle();
-        return R*R/2*(theta - std::sin(theta));
+    /// Returns whether this arc forms a straight line (p0, p1, and p2 are collinear)
+    bool isLinear() const {
+        return !std::isfinite(getRadius());
     }
 
     /// Return the angle of p0
     double theta0() const {
-        return std::atan2(p0.y - getCenter().y, p0.x - getCenter().x);
+        return algorithm::CircularArcs::getAngle(p0(), getCenter());
+    }
+
+    /// Return the angle of p1
+    double theta1() const {
+        return algorithm::CircularArcs::getAngle(p1(), getCenter());
     }
 
     /// Return the angle of p2
     double theta2() const {
-        return std::atan2(p2.y - getCenter().y, p2.x - getCenter().x);
+        return algorithm::CircularArcs::getAngle(p2(), getCenter());
     }
+    /// Check to see if a given angle lies on this arc
+    bool containsAngle(double theta) const;
+
+    /// Check to see if a coordinate lies on the arc, after testing whether
+    /// it lies on the circle.
+    bool containsPoint(const CoordinateXY& q) const;
 
     /// Check to see if a coordinate lies on the arc
     /// Only the angle is checked, so it is assumed that the point lies on
@@ -151,67 +201,21 @@ public:
         return containsAngle(theta);
     }
 
-    /// Check to see if a coordinate lies on the arc, after testing whether
-    /// it lies on the circle.
-    bool containsPoint(const CoordinateXY& q) {
-        if (q == p0 || q == p1 || q == p2) {
-            return true;
-        }
-
-        auto dist = std::abs(q.distance(getCenter()) - getRadius());
-
-        if (dist > 1e-8) {
-            return false;
-        }
-
-        if (triangulate::quadedge::TrianglePredicate::isInCircleNormalized(p0, p1, p2, q) != geom::Location::BOUNDARY) {
-            return false;
-        }
-
-        return containsPointOnCircle(q);
-    }
-
-    /// Check to see if a given angle lies on this arc
-    bool containsAngle(double theta) const {
-        auto t0 = theta0();
-        auto t2 = theta2();
+    CoordinateXY closestPoint(const CoordinateXY& p) const;
+    std::array<CoordinateXY, 2> closestPoints(const CoordinateXY& p1, const CoordinateXY& p2) const;
+    std::array<CoordinateXY, 2> closestPoints(const CircularArc& other) const;
 
-        if (theta == t0 || theta == t2) {
-            return true;
-        }
+    double distance(const CoordinateXY& p) const;
+    double distance(const CoordinateXY& p1, const CoordinateXY& p2) const;
+    double distance(const CircularArc& other) const;
 
-        if (orientation() == algorithm::Orientation::COUNTERCLOCKWISE) {
-            std::swap(t0, t2);
-        }
+    CircularArc reverse() const;
 
-        t2 -= t0;
-        theta -= t0;
+    // Split an arc at a specified point.
+    // The point is assumed to be on the arc.
+    //std::pair<CircularArc, CircularArc> splitAtPoint(const CoordinateXY& q) const;
 
-        if (t2 < 0) {
-            t2 += 2*MATH_PI;
-        }
-        if (theta < 0) {
-            theta += 2*MATH_PI;
-        }
-
-        return theta >= t2;
-    }
-
-    /// Return true if the arc is pointing positive in the y direction
-    /// at the location of a specified point. The point is assumed to
-    /// be on the arc.
-    bool isUpwardAtPoint(const CoordinateXY& q) const {
-        auto quad = geom::Quadrant::quadrant(getCenter(), q);
-        bool isUpward;
-
-        if (orientation() == algorithm::Orientation::CLOCKWISE) {
-            isUpward = (quad == geom::Quadrant::SW || quad == geom::Quadrant::NW);
-        } else {
-            isUpward = (quad == geom::Quadrant::SE || quad == geom::Quadrant::NE);
-        }
-
-        return isUpward;
-    }
+    bool equals(const CircularArc& other, double tol) const;
 
     class Iterator {
     public:
@@ -224,7 +228,7 @@ public:
         Iterator(const CircularArc& arc, int i) : m_arc(arc), m_i(i) {}
 
         reference operator*() const {
-            return m_i == 0 ? m_arc.p0 : (m_i == 1 ? m_arc.p1 : m_arc.p2);
+            return m_i == 0 ? m_arc.p0() : (m_i == 1 ? m_arc.p1() : m_arc.p2());
         }
 
         Iterator& operator++() {
@@ -260,13 +264,39 @@ public:
         return Iterator(*this, 3);
     }
 
+    template<typename T=CoordinateXY>
+    const T& p0() const {
+        return m_seq->getAt<T>(m_pos);
+    }
+
+    template<typename T=CoordinateXY>
+    const T& p1() const {
+        return m_seq->getAt<T>(m_pos + 1);
+    }
+
+    template<typename T=CoordinateXY>
+    const T& p2() const {
+        return m_seq->getAt<T>(m_pos + 2);
+    }
+
+    std::string toString() const;
+
+    template<typename F>
+    auto applyAt(std::size_t i, F&& f) const {
+        return m_seq->applyAt(m_pos + i, f);
+    }
+
 private:
+    const CoordinateSequence* m_seq;
+    std::size_t m_pos;
+
     mutable CoordinateXY m_center;
     mutable double m_radius;
     mutable int m_orientation;
     mutable bool m_center_known = false;
     mutable bool m_radius_known = false;
     mutable bool m_orientation_known = false;
+    bool m_own_coordinates;
 };
 
 }

package/geos.xcframework/ios-arm64/Headers/geos/geom/CircularString.h

@@ -14,6 +14,8 @@
 
 #pragma once
 
+#include <geos/geom/CircularArc.h>
+#include <geos/geom/LineString.h>
 #include <geos/geom/SimpleCurve.h>
 
 namespace geos {
@@ -30,6 +32,8 @@ public:
 
     std::unique_ptr<CircularString> clone() const;
 
+    const std::vector<CircularArc>& getArcs() const;
+
     std::string getGeometryType() const override;
 
     GeometryTypeId getGeometryTypeId() const override;
@@ -41,15 +45,24 @@ public:
         return true;
     }
 
+    bool hasCurvedTypes() const override
+    {
+        return true;
+    }
+
     bool isCurved() const override {
         return true;
     }
 
+    void normalize() override;
+
     std::unique_ptr<CircularString> reverse() const
     {
         return std::unique_ptr<CircularString>(reverseImpl());
     }
 
+    std::unique_ptr<Curve> getCurved(const algorithm::LineToCurveParams&) const;
+
 protected:
 
     /// \brief
@@ -58,6 +71,9 @@ protected:
     CircularString(std::unique_ptr<CoordinateSequence>&& pts,
                    const GeometryFactory& newFactory);
 
+    CircularString(const std::shared_ptr<const CoordinateSequence>& pts,
+                   const GeometryFactory& newFactory);
+
     CircularString* cloneImpl() const override
     {
         return new CircularString(*this);
@@ -68,16 +84,29 @@ protected:
         envelope = computeEnvelopeInternal(false);
     }
 
+    CircularString* getCurvedImpl(const algorithm::LineToCurveParams&) const override {
+        return cloneImpl();
+    }
+
+    LineString* getLinearizedImpl(const algorithm::CurveToLineParams&) const override;
+
     int
     getSortIndex() const override
     {
-        return SORTINDEX_LINESTRING;
+        return SORTINDEX_CIRCULARSTRING;
     };
 
     CircularString* reverseImpl() const override;
 
     void validateConstruction();
 
+private:
+    void createArcs() const;
+
+    void normalizeClosed();
+
+    mutable std::vector<CircularArc> arcs;
+
 };
 
 

package/geos.xcframework/ios-arm64/Headers/geos/geom/CompoundCurve.h

@@ -14,6 +14,7 @@
 
 #pragma once
 
+#include <geos/geom/LineString.h>
 #include <geos/geom/SimpleCurve.h>
 #include <geos/util.h>
 #include <vector>
@@ -56,6 +57,10 @@ public:
     /// Returns the nth section of the CompoundCurve
     const SimpleCurve* getCurveN(std::size_t) const override;
 
+    const CoordinateXY& getEndCoordinate() const override;
+
+    std::unique_ptr<Point> getEndPoint() const override;
+
     const Envelope* getEnvelopeInternal() const override
     {
         return &envelope;
@@ -72,8 +77,18 @@ public:
 
     std::size_t getNumPoints() const override;
 
+    std::unique_ptr<Point> getPointN(std::size_t n) const override;
+
+    const CoordinateXY& getStartCoordinate() const override;
+
+    std::unique_ptr<Point> getStartPoint() const override;
+
     bool hasCurvedComponents() const override;
 
+    bool hasCurvedTypes() const override {
+        return true;
+    }
+
     bool hasM() const override;
 
     bool hasZ() const override;
@@ -107,6 +122,10 @@ protected:
         envelope = computeEnvelopeInternal();
     }
 
+    LineString* getLinearizedImpl(const algorithm::CurveToLineParams&) const override;
+
+    CompoundCurve* getCurvedImpl(const algorithm::LineToCurveParams&) const override { return cloneImpl(); }
+
     int getSortIndex() const override
     {
         return SORTINDEX_COMPOUNDCURVE;
@@ -115,6 +134,10 @@ protected:
     CompoundCurve* reverseImpl() const override;
 
 private:
+    void normalizeClosed();
+
+    void reverseInPlace();
+
     std::vector<std::unique_ptr<SimpleCurve>> curves;
     Envelope envelope;
 };

package/geos.xcframework/ios-arm64/Headers/geos/geom/Coordinate.h

@@ -78,6 +78,9 @@ public:
     template<Ordinate>
     double get() const;
 
+    template<Ordinate>
+    static constexpr bool has();
+
     /// x-coordinate
     double x;
 
@@ -255,6 +258,9 @@ public:
         , z(DEFAULT_Z)
         {};
 
+    template<Ordinate>
+    static constexpr bool has();
+
     template<Ordinate>
     double get() const;
 
@@ -308,6 +314,9 @@ public:
 
     double m;
 
+    template<Ordinate>
+    static constexpr bool has();
+
     template<Ordinate>
     double get() const;
 
@@ -366,6 +375,9 @@ public:
 
     double m;
 
+    template<Ordinate>
+    static constexpr bool has();
+
     template<Ordinate>
     double get() const;
 
@@ -463,6 +475,30 @@ inline bool operator<(const CoordinateXY& a, const CoordinateXY& b)
 
 // Generic accessors, XY
 
+template<>
+constexpr bool CoordinateXY::has<Ordinate::X>()
+{
+    return true;
+}
+
+template<>
+constexpr bool CoordinateXY::has<Ordinate::Y>()
+{
+    return true;
+}
+
+template<>
+constexpr bool CoordinateXY::has<Ordinate::Z>()
+{
+    return false;
+}
+
+template<>
+constexpr bool CoordinateXY::has<Ordinate::M>()
+{
+    return false;
+}
+
 template<>
 inline double CoordinateXY::get<Ordinate::X>() const
 {
@@ -489,6 +525,30 @@ inline double CoordinateXY::get<Ordinate::M>() const
 
 // Generic accessors, XYZ
 
+template<>
+constexpr bool Coordinate::has<Ordinate::X>()
+{
+    return true;
+}
+
+template<>
+constexpr bool Coordinate::has<Ordinate::Y>()
+{
+    return true;
+}
+
+template<>
+constexpr bool Coordinate::has<Ordinate::Z>()
+{
+    return true;
+}
+
+template<>
+constexpr bool Coordinate::has<Ordinate::M>()
+{
+    return false;
+}
+
 template<>
 inline double Coordinate::get<Ordinate::X>() const
 {
@@ -515,6 +575,30 @@ inline double Coordinate::get<Ordinate::M>() const
 
 // Generic accessors, XYM
 
+template<>
+constexpr bool CoordinateXYM::has<Ordinate::X>()
+{
+    return true;
+}
+
+template<>
+constexpr bool CoordinateXYM::has<Ordinate::Y>()
+{
+    return true;
+}
+
+template<>
+constexpr bool CoordinateXYM::has<Ordinate::Z>()
+{
+    return false;
+}
+
+template<>
+constexpr bool CoordinateXYM::has<Ordinate::M>()
+{
+    return true;
+}
+
 template<>
 inline double CoordinateXYM::get<Ordinate::X>() const
 {
@@ -541,6 +625,30 @@ inline double CoordinateXYM::get<Ordinate::M>() const
 
 // Generic accessors, XYZM
 
+template<>
+constexpr bool CoordinateXYZM::has<Ordinate::X>()
+{
+    return true;
+}
+
+template<>
+constexpr bool CoordinateXYZM::has<Ordinate::Y>()
+{
+    return true;
+}
+
+template<>
+constexpr bool CoordinateXYZM::has<Ordinate::Z>()
+{
+    return true;
+}
+
+template<>
+constexpr bool CoordinateXYZM::has<Ordinate::M>()
+{
+    return true;
+}
+
 template<>
 inline double CoordinateXYZM::get<Ordinate::X>() const
 {