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

package/geos_c.xcframework/ios-arm64/Headers/geos/operation/distance/FacetSequence.h

@@ -18,21 +18,27 @@
 
 #pragma once
 
-#include <geos/geom/CoordinateSequence.h>
 #include <geos/geom/Envelope.h>
 #include <geos/geom/Coordinate.h>
-#include <geos/geom/LineSegment.h>
-#include <geos/operation/distance/GeometryLocation.h>
+
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+}
+}
 
 namespace geos {
 namespace operation {
 namespace distance {
+
 class FacetSequence {
+
 private:
+
     const geom::CoordinateSequence* pts;
     const std::size_t start;
     const std::size_t end;
-    const geom::Geometry* geom;
+
     /*
     * Unlike JTS, we store the envelope in the FacetSequence so
     * that it has a clear owner.  This is helpful when making a
@@ -41,25 +47,24 @@ private:
     geom::Envelope env;
 
     double computeDistanceLineLine(const FacetSequence& facetSeq,
-                                   std::vector<GeometryLocation> *locs) const;
+                                   std::vector<geom::Coordinate> *locs) const;
 
     double computeDistancePointLine(const geom::Coordinate& pt,
                                     const FacetSequence& facetSeq,
-                                    std::vector<GeometryLocation> *locs) const;
+                                    std::vector<geom::Coordinate> *locs) const;
 
     void updateNearestLocationsPointLine(const geom::Coordinate& pt,
-                                         const FacetSequence& facetSeq, std::size_t i,
                                          const geom::Coordinate& q0, const geom::Coordinate &q1,
-                                         std::vector<GeometryLocation> *locs) const;
+                                         std::vector<geom::Coordinate> *locs) const;
 
-    void updateNearestLocationsLineLine(std::size_t i, const geom::Coordinate& p0, const geom::Coordinate& p1,
-                                        const FacetSequence& facetSeq,
-                                        std::size_t j, const geom::Coordinate& q0, const geom::Coordinate &q1,
-                                        std::vector<GeometryLocation> *locs) const;
+    void updateNearestLocationsLineLine(const geom::Coordinate& p0, const geom::Coordinate& p1,
+                                        const geom::Coordinate& q0, const geom::Coordinate &q1,
+                                        std::vector<geom::Coordinate> *locs) const;
 
     void computeEnvelope();
 
 public:
+
     const geom::Envelope* getEnvelope() const;
 
     const geom::Coordinate* getCoordinate(std::size_t index) const;
@@ -72,9 +77,14 @@ public:
 
     FacetSequence(const geom::CoordinateSequence* pts, std::size_t start, std::size_t end);
 
-    FacetSequence(const geom::Geometry* geom, const geom::CoordinateSequence* pts, std::size_t start, std::size_t end);
-
-    std::vector<GeometryLocation> nearestLocations(const FacetSequence& facetSeq) const;
+    /**
+     * Computes the locations of the nearest points between this sequence
+     * and another sequence.
+     * The locations are presented in the same order as the input sequences.
+     *
+     * @return a pair of {@link Coordinate}s for the nearest points
+     */
+    std::vector<geom::Coordinate> nearestLocations(const FacetSequence& facetSeq) const;
 
 };
 

package/geos_c.xcframework/ios-arm64/Headers/geos/operation/distance/FacetSequenceTreeBuilder.h

@@ -18,25 +18,32 @@
 
 #pragma once
 
-#include <geos/index/ItemVisitor.h>
 #include <geos/index/strtree/TemplateSTRtree.h>
-#include <geos/geom/Geometry.h>
-#include <geos/geom/CoordinateSequence.h>
 #include <geos/operation/distance/FacetSequence.h>
 
+
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+class Geometry;
+}
+}
+
 namespace geos {
 namespace operation {
 namespace distance {
+
 class GEOS_DLL FacetSequenceTreeBuilder {
+
 private:
+
     // 6 seems to be a good facet sequence size
     static const std::size_t FACET_SEQUENCE_SIZE = 6;
 
     // Seems to be better to use a minimum node capacity
     static const std::size_t STR_TREE_NODE_CAPACITY = 4;
 
-    static void addFacetSequences(const geom::Geometry* geom,
-                                  const geom::CoordinateSequence* pts,
+    static void addFacetSequences(const geom::CoordinateSequence* pts,
                                   std::vector<FacetSequence> & sections);
     static std::vector<FacetSequence> computeFacetSequences(const geom::Geometry* g);
 
@@ -55,6 +62,7 @@ private:
     };
 
 public:
+
     /** \brief
      * Return a tree of FacetSequences constructed from the supplied Geometry.
      *
@@ -63,6 +71,7 @@ public:
      */
     static std::unique_ptr<geos::index::strtree::TemplateSTRtree<const FacetSequence*>> build(const geom::Geometry* g);
 };
+
 }
 }
 }

package/geos_c.xcframework/ios-arm64/Headers/geos/operation/distance/GeometryLocation.h

@@ -94,7 +94,7 @@ public:
     /**
      * Returns the geometry component on (or in) which this location occurs.
      */
-    const geom::Geometry* getGeometryComponent();
+    const geom::Geometry* getGeometryComponent() const;
 
     /**
      * Returns the segment index for this location.
@@ -104,20 +104,20 @@ public:
      *
      * @return the segment index for the location, or INSIDE_AREA
      */
-    std::size_t getSegmentIndex();
+    std::size_t getSegmentIndex() const;
 
     /**
      * Returns the geom::Coordinate of this location.
      */
-    geom::CoordinateXY& getCoordinate();
+    const geom::CoordinateXY& getCoordinate() const;
 
     /** \brief
      * Tests whether this location represents a point
      * inside an area geometry.
      */
-    bool isInsideArea();
+    bool isInsideArea() const;
 
-    std::string toString();
+    std::string toString() const;
 };
 
 } // namespace geos::operation::distance

package/geos_c.xcframework/ios-arm64/Headers/geos/operation/distance/IndexedFacetDistance.h

@@ -94,18 +94,15 @@ public:
     /// \return true of the geometry lies within the specified distance
     bool isWithinDistance(const geom::Geometry* g, double maxDistance) const;
 
-    /// \brief Computes the nearest locations on the base geometry and the given geometry.
-    ///
-    /// \param g the geometry to compute the nearest location to
-    /// \return the nearest locations
-    std::vector<GeometryLocation> nearestLocations(const geom::Geometry* g) const;
+    static bool isWithinDistance(const geom::Geometry* g1, const geom::Geometry* g2, double distance);
 
-    /// \brief Compute the nearest locations on the target geometry and the given geometry.
+    /// \brief Computes the nearest points on the base geometry and the given geometry.
     ///
     /// \param g the geometry to compute the nearest point to
     /// \return the nearest points
     std::unique_ptr<geom::CoordinateSequence> nearestPoints(const geom::Geometry* g) const;
 
+
 private:
     struct FacetDistance {
         double operator()(const FacetSequence* a, const FacetSequence* b) const

package/geos_c.xcframework/ios-arm64/Headers/geos/operation/grid/Cell.h

@@ -40,6 +40,9 @@ class Cell
     {
     }
 
+    /// Get all points that fall on the specified side of this cell.
+    void getEdgePoints(Side s, std::vector<geom::CoordinateXY>& points) const;
+
     const geom::Envelope& box() const { return m_box; }
 
     double getWidth() const;
@@ -76,13 +79,18 @@ class Cell
      * @param c             Coordinate to process
      * @param prev_original The last *uninterpolated* coordinate preceding `c` in the
      *                      boundary being processed
+     * @param exitOnBoundary Whether to exit the cell if `c` lies on the boundary. This is needed to ensure that
+     *                       exit nodes are added to both polygons whose shared boundary is coincident with the
+     *                       Cell boundary. If these nodes are not needed (for example, in the area-only case),
+     *                       it is more efficient to _not_ exit the cell.
+     * @param parentage an optional pointer indicating the source of the coordinate.
      *
      * @return `true` if the Coordinate was inside this cell, `false` otherwise
      */
-    bool take(const geom::CoordinateXY& c, const geom::CoordinateXY* prev_original = nullptr);
+    bool take(const geom::CoordinateXY& c, const geom::CoordinateXY* prev_original, bool exitOnBoundary, const void* parentage);
 
   private:
-    std::vector<const std::vector<geom::CoordinateXY>*> getCoordLists() const;
+    std::vector<const Traversal*> getTraversals() const;
 
     enum class Location
     {
@@ -95,9 +103,9 @@ class Cell
 
     std::vector<Traversal> m_traversals;
 
-    Side side(const geom::CoordinateXY& c) const;
+    Side getSide(const geom::CoordinateXY& c) const;
 
-    Location location(const geom::CoordinateXY& c) const;
+    Location getLocation(const geom::CoordinateXY& c) const;
 
     /// If no Traversals have been started or the most recent Traversal has been completed,
     /// return a new Traversal. Otherwise, return the most recent Traversal.

package/geos_c.xcframework/ios-arm64/Headers/geos/operation/grid/Grid.h

@@ -20,8 +20,6 @@
 
 #include <geos/geom/Envelope.h>
 
-constexpr double DEFAULT_GRID_COMPAT_TOL = 1e-6;
-
 namespace geos::operation::grid {
 struct infinite_extent
 {
@@ -33,26 +31,40 @@ struct bounded_extent
     static constexpr size_t padding = 0;
 };
 
+/**
+ * @brief The Grid class represents a grid of constant-size rectangular cells that covers a specified envelope.
+ *        The width of the cells may be different from the height. If the Grid has an "infinite" extent rather than
+ *        a "bounded" extent, then an extra row and column will be added on all side of the grid. The size of the cells
+ *        in these columns may be larger than those in the primary grid, such that the extended grid covers a "domain"
+ *        that is larger than the extent of the regular grid.
+ */
 template<typename extent_tag>
-class Grid
+class GEOS_DLL Grid
 {
 
   public:
+    /// Construct a bounded grid covering a specified extent.
     Grid(const geom::Envelope& extent, double dx, double dy)
       : m_extent{ extent }
       , m_domain{}
       , m_dx{ dx }
       , m_dy{ dy }
+      , m_xOrig { extent.getMinX() }
+      , m_yOrig { extent.getMaxY() }
       , m_num_rows{ 2 * extent_tag::padding + (extent.getMaxY() > extent.getMinY() ? static_cast<size_t>(std::round(extent.getHeight() / dy)) : 0) }
       , m_num_cols{ 2 * extent_tag::padding + (extent.getMaxX() > extent.getMinX() ? static_cast<size_t>(std::round(extent.getWidth() / dx)) : 0) } {
         static_assert(std::is_same_v<extent_tag, bounded_extent>);
     }
 
+    /// Construct an infinite grid covering a specified extent with regularly-sized cells, and adding a row and column
+    /// of variably-sized cells to each edge of the primary grid such that the specified domain is covered.
     Grid(const geom::Envelope& extent, double dx, double dy, const geom::Envelope& domain)
       : m_extent{ extent }
       , m_domain{ domain }
       , m_dx{ dx }
       , m_dy{ dy }
+      , m_xOrig { extent.getMinX() }
+      , m_yOrig { extent.getMaxY() }
       , m_num_rows{ 2 * extent_tag::padding + (extent.getMaxY() > extent.getMinY() ? static_cast<size_t>(std::round(extent.getHeight() / dy)) : 0) }
       , m_num_cols{ 2 * extent_tag::padding + (extent.getMaxX() > extent.getMinX() ? static_cast<size_t>(std::round(extent.getWidth() / dx)) : 0) }
     {
@@ -69,6 +81,7 @@ class Grid
         }
     }
 
+    /// Get the column in which the specified x coordinate would fall.
     size_t getColumn(double x) const
     {
         if (extent_tag::padding) {
@@ -94,6 +107,7 @@ class Grid
           getColumn(m_extent.getMaxX()));
     }
 
+    /// Get the row in which the specified y coordinate would fall.
     size_t getRow(double y) const
     {
         if (extent_tag::padding) {
@@ -119,6 +133,8 @@ class Grid
           getRow(m_extent.getMinY()));
     }
 
+    /// Get the cell index in which the specified x and y values would fall. Cells are indexed from left-to-right,
+    /// then top-to-bottom.
     std::size_t getCell(double x, double y) const
     {
         return getRow(y) * getNumCols() + getColumn(x);
@@ -146,15 +162,36 @@ class Grid
 
     const geom::Envelope& getExtent() const { return m_extent; }
 
+    /// Return the number of rows by which another grid is offset from this Grid. It is assumed that the two
+    /// grids have the same resolution, and that the maximum y value of the other grid is less than or equal
+    /// to the maximum y value of this grid.
     size_t getRowOffset(const Grid& other) const { return static_cast<size_t>(std::round(std::abs(other.m_extent.getMaxY() - m_extent.getMaxY()) / m_dy)); }
 
+    /// Return the number of columns by which another grid is offset from this Grid. It is assumed that the two
+    /// grids have the same resolution, and that the minimum x value of the other grid is greater than or equal
+    /// to the minimum x value of this grid.
     size_t getColOffset(const Grid& other) const { return static_cast<size_t>(std::round(std::abs(m_extent.getMinX() - other.m_extent.getMinX()) / m_dx)); }
 
+    /// Get the x coordinate at the center of the specified column.
     double getColX(size_t col) const { return m_extent.getMinX() + (static_cast<double>(col - extent_tag::padding) + 0.5) * m_dx; }
 
+    /// Get the y coordinate at the center of the specified row.
     double getRowY(size_t row) const { return m_extent.getMaxY() - (static_cast<double>(row - extent_tag::padding) + 0.5) * m_dy; }
 
-    Grid<extent_tag> shrinkToFit(const geom::Envelope& b) const
+    Grid crop(const geom::Envelope& e) const
+    {
+        if (m_extent.intersects(e)) {
+            return shrinkToFit(e.intersection(m_extent));
+        } else {
+            return makeEmpty();
+        }
+    }
+
+    /// Reduce the size of the grid to contain only the provided Envelope
+    /// If calcExtentFromNewGrid is true, then the xmax and ymin of the new
+    /// grid will be calculated relative to the origin point of the original grid
+    /// rather than the newly cropped grid.
+    Grid<extent_tag> shrinkToFit(const geom::Envelope& b, bool calcExtentFromNewGrid=true) const
     {
         if (b.getArea() == 0) {
             return makeEmpty();
@@ -171,8 +208,8 @@ class Grid
         double snapped_xmin = m_extent.getMinX() + static_cast<double>(col0 - extent_tag::padding) * m_dx;
         double snapped_ymax = m_extent.getMaxY() - static_cast<double>(row1 - extent_tag::padding) * m_dy;
 
-        // Make sure x0 and y1 are within the reduced extent. Because of
-        // floating point round-off errors, this is not always the case.
+        // Make sure snapped_xmin and snapped_ymax are within the reduced extent.
+        // Because of floating point round-off errors, this is not always the case.
         if (b.getMinX() < snapped_xmin) {
             snapped_xmin -= m_dx;
             col0--;
@@ -201,14 +238,17 @@ class Grid
             num_cols--;
         }
 
+        const double snapped_xmax = m_extent.getMinX() + static_cast<double>(col0 + num_cols - extent_tag::padding) * m_dx;
+        const double snapped_ymin = m_extent.getMaxY() - static_cast<double>(row1 + num_rows - extent_tag::padding) * m_dy;
+
         // Perform offsets relative to the new xmin, ymax origin
         // points. If this is not done, then floating point roundoff
         // error can cause progressive shrink() calls with the same
         // inputs to produce different results.
         geom::Envelope reduced_box = {
             snapped_xmin,
-            std::max(snapped_xmin + static_cast<double>(num_cols) * m_dx, b.getMaxX()),
-            std::min(snapped_ymax - static_cast<double>(num_rows) * m_dy, b.getMinY()),
+            calcExtentFromNewGrid ? std::max(snapped_xmin + static_cast<double>(num_cols) * m_dx, b.getMaxX()) : snapped_xmax,
+            calcExtentFromNewGrid ? std::min(snapped_ymax - static_cast<double>(num_rows) * m_dy, b.getMinY()) : snapped_ymin,
             snapped_ymax
         };
 
@@ -232,22 +272,29 @@ class Grid
         }
 
         if constexpr (std::is_same_v<extent_tag, bounded_extent>) {
-            Grid<extent_tag> reduced{ reduced_box, m_dx, m_dy };
-
-        if (b.getMinX() < reduced.xmin() || b.getMinY() < reduced.ymin() || b.getMaxX() > reduced.xmax() || b.getMaxY() > reduced.ymax()) {
-            throw std::runtime_error("Shrink operation failed.");
-        }
-
+            Grid<extent_tag> reduced{reduced_box, m_dx, m_dy};
+
+            if (!calcExtentFromNewGrid) {
+                reduced.m_xOrig = m_xOrig;
+                reduced.m_yOrig = m_yOrig;
+                reduced.m_skipRows = reduced.getRowOffset(*this);
+                reduced.m_skipCols = reduced.getColOffset(*this);
+            } else if (!reduced.getExtent().contains(b)) {
+                throw std::runtime_error("Shrink operation failed.");
+            }
             return reduced;
         } else {
-            Grid<extent_tag> reduced{ reduced_box, m_dx, m_dy , m_domain };
-
-        if (b.getMinX() < reduced.xmin() || b.getMinY() < reduced.ymin() || b.getMaxX() > reduced.xmax() || b.getMaxY() > reduced.ymax()) {
-            throw std::runtime_error("Shrink operation failed.");
-        }
-
+            Grid<extent_tag> reduced{reduced_box, m_dx, m_dy, m_domain};
+
+            if (!calcExtentFromNewGrid) {
+                reduced.m_xOrig = m_xOrig;
+                reduced.m_yOrig = m_yOrig;
+                reduced.m_skipRows = reduced.getRowOffset(*this);
+                reduced.m_skipCols = reduced.getColOffset(*this);
+            }else if (!reduced.getExtent().contains(b)) {
+                throw std::runtime_error("Shrink operation failed.");
+            }
             return reduced;
-
         }
     }
 
@@ -272,8 +319,18 @@ class Grid
     double m_dx;
     double m_dy;
 
+    double m_xOrig; // origin point that is distinct from xmin of m_extent. Used to allow a subgrid to calculate
+                    // sub-envelopes that exactly match those of the parent grid
+    double m_yOrig;
+
+    size_t m_skipRows{0}; // number of rows to skip when computing a cell envelope using m_yOrig
+    size_t m_skipCols{0}; // number of cols to skip when computing a cell envelope using m_xOrig
+
     size_t m_num_rows;
     size_t m_num_cols;
+
+    friend Grid<infinite_extent> make_infinite(const Grid<bounded_extent>&, const geom::Envelope&);
+    friend Grid<bounded_extent> make_finite(const Grid<infinite_extent>&);
 };
 
 Grid<infinite_extent>

package/geos_c.xcframework/ios-arm64/Headers/geos/operation/grid/GridIntersection.h

@@ -45,13 +45,13 @@ class GEOS_DLL GridIntersection
      * @brief Compute the fraction of each cell in a rectangular grid that is covered by a Geometry.
      *        A matrix can be provided to which the fractions will be added.
      */
-    GridIntersection(const Grid<bounded_extent>& raster_grid, const geom::Geometry& g, std::shared_ptr<Matrix<float>> cov = nullptr);
+    GridIntersection(const Grid<bounded_extent>& raster_grid, const geom::Geometry& g, const std::shared_ptr<Matrix<float>>& cov = nullptr);
 
     /**
      * @brief Compute the fraction of each cell in a rectangular grid that is covered by an Envelope.
      *        A matrix can be provided to which the fractions will be added.
      */
-    GridIntersection(const Grid<bounded_extent>& raster_grid, const geom::Envelope& box, std::shared_ptr<Matrix<float>> cov = nullptr);
+    GridIntersection(const Grid<bounded_extent>& raster_grid, const geom::Envelope& box, const std::shared_ptr<Matrix<float>>& cov = nullptr);
 
     /**
      * @brief Return the intersection result matrix
@@ -60,14 +60,25 @@ class GEOS_DLL GridIntersection
 
     /**
      * @brief Partition a polygonal geometry by a grid
+     * @param grid the Grid by which the polygon should be partitioned. The Grid does not need to cover the polygon.
+     * @param g a polygonal geometry
+     * @param includeExterior whether the result should contain any portions of the input that fall outside the grid.
+     * @return a GeometryCollection containing the partitioned polygon.
      */
-    static std::unique_ptr<geom::Geometry> subdividePolygon(const Grid<bounded_extent>& p_grid, const geom::Geometry& g, bool includeExterior);
+    static std::unique_ptr<geom::Geometry> subdividePolygon(const Grid<bounded_extent>& grid, const geom::Geometry& g, bool includeExterior);
 
+    /**
+     * @brief Calculate the fraction of each cell in a Grid that is covered by a polygon.
+     * @param grid the Grid for which coverage fractions should be returned
+     * @param g a polygonal or linear geometry
+     * @return a matrix having the same number of rows and columns as the grid, whose values contain either the
+     *         fraction of the cell area (for polygonal inputs) or the length of the intersection (for linear inputs)
+     */
     static std::shared_ptr<Matrix<float>>
-    getIntersectionFractions(const Grid<bounded_extent>& raster_grid, const geom::Geometry& g);
+    getIntersectionFractions(const Grid<bounded_extent>& grid, const geom::Geometry& g);
 
     static std::shared_ptr<Matrix<float>>
-    getIntersectionFractions(const Grid<bounded_extent>& raster_grid, const geom::Envelope& box);
+    getIntersectionFractions(const Grid<bounded_extent>& grid, const geom::Envelope& box);
 
     /**
      * @brief Determines the bounding box of the raster-vector intersection. Considers the bounding boxes

package/geos_c.xcframework/ios-arm64/Headers/geos/operation/grid/PerimeterDistance.h

@@ -38,12 +38,23 @@ class GEOS_DLL PerimeterDistance {
 
     /** Calculates the counter-clockwise distance between two locations on the perimeter
      *  of an Envelope. The locations are specified as clockwise distances from the
-     *  lower left corner of the Envelope, consistent with the `perimeter_distance`
+     *  lower left corner of the Envelope, consistent with the `getPerimeterDistance`
      *  function.
      */
     static double
     getPerimeterDistanceCCW(double measure1, double measure2, double perimeter);
 
-};
+    /** Tests whether measure x would be passed when traveling from a to b in a CCW
+     * direction.
+     */
+    static bool
+    isBetweenCCW(double x, double a, double b);
 
+    /** Tests whether the perimeter distance of c1 is less than the perimeter distance of c2, in a
+     *  robust way.
+     */
+    static bool
+    isLessThan(const geom::Envelope& e, const geom::CoordinateXY& c1, const geom::CoordinateXY& c2);
+
+};
 }

package/geos_c.xcframework/ios-arm64/Headers/geos/operation/grid/Side.h

@@ -27,7 +27,28 @@ enum class Side
     BOTTOM
 };
 
-std::ostream&
-operator<<(std::ostream& os, const Side& s);
+inline std::ostream&
+operator<<(std::ostream& os, const Side& s)
+{
+    switch (s) {
+        case Side::NONE:
+            os << "none";
+            return os;
+        case Side::LEFT:
+            os << "left";
+            return os;
+        case Side::RIGHT:
+            os << "right";
+            return os;
+        case Side::TOP:
+            os << "top";
+            return os;
+        case Side::BOTTOM:
+            os << "bottom";
+            return os;
+    }
+
+    return os; // unreachable statement needed for -Werror=return-type
+}
 
 }

package/geos_c.xcframework/ios-arm64/Headers/geos/operation/grid/Traversal.h

@@ -14,11 +14,12 @@
 
 #pragma once
 
-#include <vector>
-
+#include <geos/export.h>
 #include <geos/geom/Coordinate.h>
 #include <geos/operation/grid/Side.h>
 
+#include <vector>
+
 namespace geos::operation::grid {
 
 /**
@@ -26,17 +27,20 @@ namespace geos::operation::grid {
  *        within a grid cell, as well as the `Side` from which the line
  *        entered and exited the cell.
  */
-class Traversal
+class GEOS_DLL Traversal
 {
   public:
     Traversal()
       : m_entry{ Side::NONE }
       , m_exit{ Side::NONE }
+      , m_parentage{ nullptr }
     {
     }
 
     bool isClosedRing() const;
 
+    bool isClosedRingWithArea() const;
+
     bool isEmpty() const;
 
     bool isEntered() const;
@@ -48,7 +52,7 @@ class Traversal
     bool hasMultipleUniqueCoordinates() const;
 
     /// Begin a Traversal on the specified `Side`
-    void enter(const geom::CoordinateXY& c, Side s);
+    void enter(const geom::CoordinateXY& c, Side s, const void* parentage);
 
     /// Complete a Traversal on the specified `Side`
     void exit(const geom::CoordinateXY& c, Side s);
@@ -57,6 +61,8 @@ class Traversal
 
     Side getExitSide() const { return m_exit; }
 
+    const geom::CoordinateXY& getFirstCoordinate() const;
+
     const geom::CoordinateXY& getLastCoordinate() const;
 
     const geom::CoordinateXY& getExitCoordinate() const;
@@ -67,10 +73,13 @@ class Traversal
 
     const std::vector<geom::CoordinateXY>& getCoordinates() const { return m_coords; }
 
+    const void* getParentage() const { return m_parentage; }
+
   private:
     std::vector<geom::CoordinateXY> m_coords;
     Side m_entry;
     Side m_exit;
+    const void* m_parentage;
 };
 
 }

package/geos_c.xcframework/ios-arm64/Headers/geos/operation/grid/TraversalAreas.h

@@ -19,6 +19,8 @@
 
 namespace geos::operation::grid {
 
+class Traversal;
+
 class GEOS_DLL TraversalAreas {
 public:
     /**
@@ -32,7 +34,7 @@ public:
      * @return total area
      */
     static double
-    getLeftHandArea(const geom::Envelope& box, const std::vector<const std::vector<geom::CoordinateXY>*>& coord_lists);
+    getLeftHandArea(const geom::Envelope& box, const std::vector<const Traversal*>& coord_lists);
 
     /**
      * @brief Return an areal geometry representing the closed rings formed by this box and the provided Coordinate sequences
@@ -46,7 +48,7 @@ public:
      * @return a Polygon or MultiPolygon geometry
      */
     static std::unique_ptr<geom::Geometry>
-    getLeftHandRings(const geom::GeometryFactory& gfact, const geom::Envelope& box, const std::vector<const std::vector<geom::CoordinateXY>*>& coord_lists);
+    getLeftHandRings(const geom::GeometryFactory& gfact, const geom::Envelope& box, const std::vector<const Traversal*>& coord_lists);
 
 };
 

package/geos_c.xcframework/ios-arm64/Headers/geos/operation/linemerge/EdgeString.h

@@ -32,6 +32,7 @@
 // Forward declarations
 namespace geos {
 namespace geom {
+class Curve;
 class GeometryFactory;
 class CoordinateSequence;
 class LineString;
@@ -56,7 +57,6 @@ class GEOS_DLL EdgeString {
 private:
     const geom::GeometryFactory* factory;
     std::vector<LineMergeDirectedEdge*> directedEdges;
-    std::unique_ptr<geom::CoordinateSequence> getCoordinates() const;
 public:
     /**
      * \brief
@@ -73,9 +73,9 @@ public:
     void add(LineMergeDirectedEdge* directedEdge);
 
     /**
-     * Converts this EdgeString into a LineString.
+     * Converts this EdgeString into a Curve.
      */
-    std::unique_ptr<geom::LineString> toLineString() const;
+    std::unique_ptr<geom::Curve> getGeometry() const;
 };
 
 } // namespace geos::operation::linemerge