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

package/geos.xcframework/ios-arm64/Headers/geos/operation/overlayng/OverlayEdgeRing.h

@@ -28,10 +28,11 @@ class PointOnGeometryLocator;
 }
 namespace geom {
 class Coordinate;
+class CoordinateXY;
 class CoordinateSequence;
+class Curve;
 class GeometryFactory;
-class LinearRing;
-class Polygon;
+class Surface;
 }
 namespace operation {
 namespace overlayng {
@@ -46,10 +47,11 @@ namespace overlayng { // geos.operation.overlayng
 
 class GEOS_DLL OverlayEdgeRing {
     using Coordinate = geos::geom::Coordinate;
+    using CoordinateXY = geos::geom::CoordinateXY;
     using CoordinateSequence = geos::geom::CoordinateSequence;
     using GeometryFactory = geos::geom::GeometryFactory;
-    using LinearRing = geos::geom::LinearRing;
-    using Polygon = geos::geom::Polygon;
+    using Curve = geos::geom::Curve;
+    using Surface = geos::geom::Surface;
     using PointOnGeometryLocator = algorithm::locate::PointOnGeometryLocator;
     using IndexedPointInAreaLocator = algorithm::locate::IndexedPointInAreaLocator;
 
@@ -57,33 +59,36 @@ private:
 
     // Members
     OverlayEdge* startEdge;
-    std::unique_ptr<LinearRing> ring;
+    std::unique_ptr<Curve> ring;
     bool m_isHole;
-    std::unique_ptr<IndexedPointInAreaLocator> locator;
+    mutable std::unique_ptr<PointOnGeometryLocator> locator;
     OverlayEdgeRing* shell;
     // a list of EdgeRings which are holes in this EdgeRing
     std::vector<OverlayEdgeRing*> holes;
 
     // Methods
-    void computeRingPts(OverlayEdge* start, CoordinateSequence& pts);
-    void computeRing(std::unique_ptr<CoordinateSequence> && ringPts, const GeometryFactory* geometryFactory);
+    void computeRing(OverlayEdge* start, const GeometryFactory* geometryFactory);
+    std::unique_ptr<Curve> computeRingGeometry(OverlayEdge* start, const GeometryFactory* geometryFactory) const;
 
     /**
     * Computes the list of coordinates which are contained in this ring.
     * The coordinates are computed once only and cached.
     * @return an array of the {@link Coordinate}s in this ring
     */
-    const CoordinateSequence& getCoordinates();
-    PointOnGeometryLocator* getLocator();
+    PointOnGeometryLocator* getLocator() const;
     static void closeRing(CoordinateSequence& pts);
+    bool contains(const OverlayEdgeRing& otherRing) const;
+    bool isPointInOrOut(const OverlayEdgeRing& otherRing) const;
 
 
 public:
 
     OverlayEdgeRing(OverlayEdge* start, const GeometryFactory* geometryFactory);
 
-    std::unique_ptr<LinearRing> getRing();
-    const LinearRing* getRingPtr() const;
+    std::unique_ptr<Curve> getRing();
+    const Curve* getRingPtr() const;
+
+    const geom::Envelope& getEnvelope() const;
 
     /**
     * Tests whether this ring is a hole.
@@ -114,15 +119,15 @@ public:
 
     void addHole(OverlayEdgeRing* ring);
 
-    bool isInRing(const Coordinate& pt);
+    geom::Location locate(const CoordinateXY& pt) const;
 
-    const Coordinate& getCoordinate();
+    const Coordinate& getCoordinate() const;
 
     /**
     * Computes the {@link Polygon} formed by this ring and any contained holes.
     * @return the {@link Polygon} formed by this ring and its holes.
     */
-    std::unique_ptr<Polygon> toPolygon(const GeometryFactory* factory);
+    std::unique_ptr<Surface> toSurface(const GeometryFactory* factory);
 
     OverlayEdge* getEdge();
 
@@ -144,7 +149,7 @@ public:
     * @return containing EdgeRing, if there is one
     * or null if no containing EdgeRing is found
     */
-    OverlayEdgeRing* findEdgeRingContaining(const std::vector<OverlayEdgeRing*>& erList);
+    OverlayEdgeRing* findEdgeRingContaining(const std::vector<OverlayEdgeRing*>& erList) const;
 
 
 };

package/geos.xcframework/ios-arm64/Headers/geos/operation/overlayng/OverlayGraph.h

@@ -51,33 +51,32 @@ namespace overlayng { // geos.operation.overlayng
  */
 class GEOS_DLL OverlayGraph {
     using Coordinate = geos::geom::Coordinate;
+    using CoordinateXY = geos::geom::CoordinateXY;
     using CoordinateSequence = geos::geom::CoordinateSequence;
 
 private:
 
     // Members
-    std::unordered_map<Coordinate, OverlayEdge*, geom::Coordinate::HashCode> nodeMap;
+    std::unordered_map<CoordinateXY, OverlayEdge*, geom::Coordinate::HashCode> nodeMap;
     std::vector<OverlayEdge*> edges;
 
     // Locally store the OverlayEdge and OverlayLabel
     std::deque<OverlayEdge> ovEdgeQue;
     std::deque<OverlayLabel> ovLabelQue;
 
-    std::vector<std::unique_ptr<const geom::CoordinateSequence>> csQue;
-
     // Methods
 
     /**
     * Create and add HalfEdge pairs to map and vector containers,
     * using local std::deque storage for objects.
     */
-    OverlayEdge* createEdgePair(const CoordinateSequence* pts, OverlayLabel* lbl);
+    OverlayEdge* createEdgePair(const std::shared_ptr<const CoordinateSequence> &pts, OverlayLabel *lbl, bool isCurved);
 
     /**
     * Create a single OverlayEdge in local std::deque storage, and return the
     * pointer.
     */
-    OverlayEdge* createOverlayEdge(const CoordinateSequence* pts, OverlayLabel* lbl, bool direction);
+    OverlayEdge* createOverlayEdge(const std::shared_ptr<const CoordinateSequence> &pts, OverlayLabel *lbl, bool direction, bool isCurved);
 
     void insert(OverlayEdge* e);
 

package/geos.xcframework/ios-arm64/Headers/geos/operation/overlayng/OverlayMixedPoints.h

@@ -40,6 +40,9 @@ namespace locate {
 class PointOnGeometryLocator;
 }
 }
+namespace noding {
+class Noder;
+}
 }
 
 namespace geos {      // geos.
@@ -74,6 +77,7 @@ namespace overlayng { // geos.operation.overlayng
  * @author Martin Davis
  */
 class GEOS_DLL OverlayMixedPoints {
+    using Curve = geos::geom::Curve;
     using GeometryFactory = geos::geom::GeometryFactory;
     using PrecisionModel = geos::geom::PrecisionModel;
     using Geometry = geos::geom::Geometry;
@@ -83,6 +87,8 @@ class GEOS_DLL OverlayMixedPoints {
     using Point = geos::geom::Point;
     using Polygon = geos::geom::Polygon;
     using LineString = geos::geom::LineString;
+    using Noder = geos::noding::Noder;
+    using Surface = geos::geom::Surface;
     using PointOnGeometryLocator = algorithm::locate::PointOnGeometryLocator;
 
 private:
@@ -94,6 +100,7 @@ private:
     const Geometry* geomNonPointInput;
     const GeometryFactory* geometryFactory;
     bool isPointRHS;
+    Noder* noder;
 
     std::unique_ptr<Geometry> geomNonPoint;
     int geomNonPointDim;
@@ -121,19 +128,19 @@ private:
 
     std::unique_ptr<Geometry> copyNonPoint() const;
 
-    std::unique_ptr<CoordinateSequence> extractCoordinates(const Geometry* points, const PrecisionModel* pm) const;
+    static std::unique_ptr<CoordinateSequence> extractCoordinates(const Geometry* points, const PrecisionModel* pm);
 
-    std::vector<std::unique_ptr<Polygon>> extractPolygons(const Geometry* geom) const;
+    static std::vector<std::unique_ptr<Surface>> extractPolygons(const Geometry* geom);
 
-    std::vector<std::unique_ptr<LineString>> extractLines(const Geometry* geom) const;
+    static std::vector<std::unique_ptr<Curve>> extractLines(const Geometry* geom);
 
 
 
 public:
 
-    OverlayMixedPoints(int p_opCode, const Geometry* geom0, const Geometry* geom1, const PrecisionModel* p_pm);
+    OverlayMixedPoints(int p_opCode, const Geometry* geom0, const Geometry* geom1, const PrecisionModel* p_pm, Noder* p_noder);
 
-    static std::unique_ptr<Geometry> overlay(int opCode, const Geometry* geom0, const Geometry* geom1, const PrecisionModel* pm);
+    static std::unique_ptr<Geometry> overlay(int opCode, const Geometry* geom0, const Geometry* geom1, const PrecisionModel* pm, Noder* p_noder);
 
     std::unique_ptr<Geometry> getResult();
 

package/geos.xcframework/ios-arm64/Headers/geos/operation/overlayng/OverlayUtil.h

@@ -14,10 +14,10 @@
 
 #pragma once
 
-#include <geos/geom/Point.h>
-#include <geos/geom/Polygon.h>
-#include <geos/geom/LineString.h>
+#include <geos/geom/Curve.h>
 #include <geos/geom/Geometry.h>
+#include <geos/geom/Point.h>
+#include <geos/geom/Surface.h>
 
 #include <geos/export.h>
 
@@ -55,10 +55,10 @@ class GEOS_DLL OverlayUtil {
     using Geometry = geos::geom::Geometry;
     using Coordinate = geos::geom::Coordinate;
     using CoordinateSequence = geos::geom::CoordinateSequence;
+    using Curve = geos::geom::Curve;
     using Envelope = geos::geom::Envelope;
     using Point = geos::geom::Point;
-    using LineString = geos::geom::LineString;
-    using Polygon = geos::geom::Polygon;
+    using Surface = geos::geom::Surface;
     using GeometryFactory = geos::geom::GeometryFactory;
     using PrecisionModel = geos::geom::PrecisionModel;
 
@@ -172,8 +172,8 @@ public:
     * Creates an overlay result geometry for homogeneous or mixed components.
     */
     static std::unique_ptr<Geometry> createResultGeometry(
-        std::vector<std::unique_ptr<Polygon>>& resultPolyList,
-        std::vector<std::unique_ptr<LineString>>& resultLineList,
+        std::vector<std::unique_ptr<Surface>>& resultPolyList,
+        std::vector<std::unique_ptr<Curve>>& resultLineList,
         std::vector<std::unique_ptr<Point>>& resultPointList,
         const GeometryFactory* geometryFactory);
 
@@ -205,6 +205,9 @@ public:
     */
     static bool round(const Point* pt, const PrecisionModel* pm, Coordinate& rsltCoord);
 
+    static geom::CoordinateXY
+    getDirectionPoint(const CoordinateSequence& pts, bool forward, bool isCurved);
+
     template<typename T>
     static void moveGeometry(std::vector<std::unique_ptr<T>>& inGeoms, std::vector<std::unique_ptr<Geometry>>& outGeoms)
     {

package/geos.xcframework/ios-arm64/Headers/geos/operation/overlayng/PolygonBuilder.h

@@ -29,7 +29,7 @@ namespace geos {
 namespace geom {
 class GeometryFactory;
 class Geometry;
-class Polygon;
+class Surface;
 }
 namespace operation {
 namespace overlayng {
@@ -55,7 +55,7 @@ private:
     // Storage
     std::vector<std::unique_ptr<OverlayEdgeRing>> vecOER;
 
-    std::vector<std::unique_ptr<geom::Polygon>> computePolygons(const std::vector<OverlayEdgeRing*>& shellList) const;
+    std::vector<std::unique_ptr<geom::Surface>> computePolygons(const std::vector<OverlayEdgeRing*>& shellList) const;
 
     void buildRings(const std::vector<OverlayEdge*>& resultAreaEdges);
 
@@ -138,7 +138,7 @@ public:
     PolygonBuilder& operator=(const PolygonBuilder&) = delete;
 
     // Methods
-    std::vector<std::unique_ptr<geom::Polygon>> getPolygons() const;
+    std::vector<std::unique_ptr<geom::Surface>> getPolygons() const;
     std::vector<OverlayEdgeRing*> getShellRings() const;
 
 

package/geos.xcframework/ios-arm64/Headers/geos/operation/overlayng/RingClipper.h

@@ -61,6 +61,7 @@ namespace overlayng { // geos.operation.overlayng
  */
 class GEOS_DLL RingClipper {
     using Coordinate = geos::geom::Coordinate;
+    using CoordinateXY = geos::geom::CoordinateXY;
     using CoordinateSequence = geos::geom::CoordinateSequence;
     using Envelope = geos::geom::Envelope;
 
@@ -87,10 +88,10 @@ private:
     * with an edge of the clip box.
     * The segment must be known to intersect the edge.
     */
-    void intersection(const Coordinate& a, const Coordinate& b, int edgeIndex, Coordinate& rsltPt) const;
-    double intersectionLineY(const Coordinate& a, const Coordinate& b, double y) const;
-    double intersectionLineX(const Coordinate& a, const Coordinate& b, double x) const;
-    bool isInsideEdge(const Coordinate& p, int edgeIndex) const;
+    void intersection(const CoordinateXY& a, const CoordinateXY& b, int edgeIndex, CoordinateXY& rsltPt) const;
+    static double intersectionLineY(const CoordinateXY& a, const CoordinateXY& b, double y);
+    static double intersectionLineX(const CoordinateXY& a, const CoordinateXY& b, double x);
+    bool isInsideEdge(const CoordinateXY& p, int edgeIndex) const;
 
 
 public:

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

@@ -20,7 +20,7 @@
 #pragma once
 
 #include <geos/export.h>
-#include <geos/algorithm/locate/IndexedPointInAreaLocator.h>
+#include <geos/algorithm/locate/PointOnGeometryLocator.h>
 #include <geos/operation/polygonize/PolygonizeDirectedEdge.h>
 #include <geos/geom/Geometry.h>
 #include <geos/geom/LinearRing.h>
@@ -38,6 +38,7 @@
 // Forward declarations
 namespace geos {
 namespace geom {
+class Curve;
 class LineString;
 class CoordinateSequence;
 class GeometryFactory;
@@ -64,11 +65,10 @@ private:
     DeList deList;
 
     // cache the following data for efficiency
-    std::unique_ptr<geom::LinearRing> ring;
-    std::unique_ptr<geom::CoordinateSequence> ringPts;
-    std::unique_ptr<algorithm::locate::PointOnGeometryLocator> ringLocator;
+    mutable std::unique_ptr<geom::Curve> ring;
+    mutable std::unique_ptr<algorithm::locate::PointOnGeometryLocator> ringLocator;
 
-    std::unique_ptr<std::vector<std::unique_ptr<geom::LinearRing>>> holes;
+    std::vector<std::unique_ptr<geom::Curve>> holes;
 
     EdgeRing* shell = nullptr;
     bool is_hole;
@@ -78,24 +78,18 @@ private:
     bool is_included = false;
     bool visitedByUpdateIncludedRecursive = false;
 
-    /** \brief
-     * Computes the list of coordinates which are contained in this ring.
-     * The coordinates are computed once only and cached.
-     *
-     * @return an array of the Coordinate in this ring
-     */
-    const geom::CoordinateSequence* getCoordinates();
+    const geom::Envelope& getEnvelope() const {
+        return *getRingInternal()->getEnvelopeInternal();
+    }
 
     static void addEdge(const geom::CoordinateSequence* coords,
                         bool isForward,
                         geom::CoordinateSequence* coordList);
 
-    algorithm::locate::PointOnGeometryLocator* getLocator() {
-        if (ringLocator == nullptr) {
-            ringLocator.reset(new algorithm::locate::IndexedPointInAreaLocator(*getRingInternal()));
-        }
-        return ringLocator.get();
-    }
+    algorithm::locate::PointOnGeometryLocator* getLocator() const;
+
+    bool contains(const EdgeRing& otherRing) const;
+    bool isPointInOrOut(const EdgeRing& otherRing) const;
 
 public:
     /** \brief
@@ -123,7 +117,7 @@ public:
      * @return containing EdgeRing, if there is one
      * @return null if no containing EdgeRing is found
      */
-    EdgeRing* findEdgeRingContaining(const std::vector<EdgeRing*> & erList);
+    EdgeRing* findEdgeRingContaining(const std::vector<EdgeRing*> & erList) const;
 
     /**
      * \brief
@@ -147,7 +141,7 @@ public:
      * @return a Coordinate reference from <code>testPts</code> which is
      * not in <code>pts</code>, or <code>Coordinate::nullCoord</code>
      */
-    static const geom::Coordinate& ptNotInList(
+    static const geom::CoordinateXY& ptNotInList(
         const geom::CoordinateSequence* testPts,
         const geom::CoordinateSequence* pts);
 
@@ -159,7 +153,7 @@ public:
      * @param pts an array of Coordinate to test
      * @return <code>true</code> if the point is in the array
      */
-    static bool isInList(const geom::Coordinate& pt,
+    static bool isInList(const geom::CoordinateXY& pt,
                          const geom::CoordinateSequence* pts);
 
     explicit EdgeRing(const geom::GeometryFactory* newFactory);
@@ -177,7 +171,7 @@ public:
     /** \brief
      * Tests whether this ring is a hole.
      *
-     * Due to the way the edges in the polyongization graph are linked,
+     * Due to the way the edges in the polygonization graph are linked,
      * a ring is a hole if it is oriented counter-clockwise.
      * @return <code>true</code> if this ring is a hole
      */
@@ -285,7 +279,7 @@ public:
      *
      * @param hole the LinearRing forming the hole.
      */
-    void addHole(geom::LinearRing* hole);
+    void addHole(std::unique_ptr<geom::Curve> hole);
 
     void addHole(EdgeRing* holeER);
 
@@ -297,7 +291,7 @@ public:
      *
      * @return the Polygon formed by this ring and its holes.
      */
-    std::unique_ptr<geom::Polygon> getPolygon();
+    std::unique_ptr<geom::Surface> getPolygon();
 
     /** \brief
      * Tests if the LinearRing ring formed by this edge ring
@@ -308,35 +302,23 @@ public:
     void computeValid();
 
     /** \brief
-     * Gets the coordinates for this ring as a LineString.
-     *
-     * Used to return the coordinates in this ring
-     * as a valid geometry, when it has been detected that the ring
-     * is topologically invalid.
-     * @return a LineString containing the coordinates in this ring
-     */
-    std::unique_ptr<geom::LineString> getLineString();
-
-    /** \brief
-     * Returns this ring as a LinearRing, or null if an Exception
+     * Returns this ring or null if an Exception
      * occurs while creating it (such as a topology problem).
      *
-     * Ownership of ring is retained by the object.
-     * Details of problems are written to standard output.
+     * Ownership of the ring is retained by the object.
      */
-    geom::LinearRing* getRingInternal();
+    const geom::Curve* getRingInternal() const;
 
     /** \brief
-     * Returns this ring as a LinearRing, or null if an Exception
+     * Returns this ring or null if an Exception
      * occurs while creating it (such as a topology problem).
      *
-     * Details of problems are written to standard output.
-     * Caller gets ownership of ring.
+     * Caller gets ownership of the ring.
      */
-    std::unique_ptr<geom::LinearRing> getRingOwnership();
+    std::unique_ptr<geom::Curve> getRingOwnership();
 
-    bool isInRing(const geom::Coordinate & pt) {
-        return geom::Location::EXTERIOR != getLocator()->locate(&pt);
+    geom::Location locate(const geom::CoordinateXY& pt) const {
+        return getLocator()->locate(&pt);
     }
 };
 

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

@@ -76,7 +76,7 @@ public:
      */
     PolygonizeDirectedEdge(planargraph::Node* newFrom,
                            planargraph::Node* newTo,
-                           const geom::Coordinate& newDirectionPt,
+                           const geom::CoordinateXY& newDirectionPt,
                            bool nEdgeDirection);
 
     /*

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

@@ -26,7 +26,7 @@
 // Forward declarations
 namespace geos {
 namespace geom {
-class LineString;
+class SimpleCurve;
 }
 }
 
@@ -42,14 +42,14 @@ namespace polygonize { // geos::operation::polygonize
 class GEOS_DLL PolygonizeEdge: public planargraph::Edge {
 private:
     // Externally owned
-    const geom::LineString* line;
+    const geom::SimpleCurve* line;
 public:
 
     // Keep the given pointer (won't do anything to it)
-    PolygonizeEdge(const geom::LineString* newLine);
+    PolygonizeEdge(const geom::SimpleCurve* newLine);
 
     // Just return what it was given initially
-    const geom::LineString* getLine();
+    const geom::SimpleCurve* getLine() const;
 };
 
 } // namespace geos::operation::polygonize

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

@@ -33,10 +33,12 @@
 // Forward declarations
 namespace geos {
 namespace geom {
-class LineString;
-class GeometryFactory;
+class CircularString;
 class Coordinate;
 class CoordinateSequence;
+class GeometryFactory;
+class LineString;
+class SimpleCurve;
 }
 namespace planargraph {
 class Node;
@@ -94,6 +96,13 @@ public:
      */
     void addEdge(const geom::LineString* line);
 
+    /**
+     * \brief
+     * Add a CircularString forming an edge of the polygon graph.
+     * @param geom the CircularString to add
+     */
+    void addEdge(const geom::CircularString* geom);
+
     /**
      * \brief
      * Computes the EdgeRings formed by the edges in this graph.
@@ -108,12 +117,12 @@ public:
      * \brief
      * Finds and removes all cut edges from the graph.
      *
-     * @param cutLines : the list of the LineString forming the removed
+     * @param cutLines : the list of the geometries forming the removed
      *                   cut edges will be pushed here.
      *
      * TODO: document ownership of the returned LineStrings
      */
-    void deleteCutEdges(std::vector<const geom::LineString*>& cutLines);
+    void deleteCutEdges(std::vector<const geom::SimpleCurve*>& cutLines);
 
     /** \brief
      * Marks all edges from the graph which are "dangles".
@@ -124,10 +133,10 @@ public:
      * In order to handle large recursion depths efficiently,
      * an explicit recursion stack is used
      *
-     * @param dangleLines : the LineStrings that formed dangles will
+     * @param dangleLines : the geometries that formed dangles will
      *                      be push_back'ed here
      */
-    void deleteDangles(std::vector<const geom::LineString*>& dangleLines);
+    void deleteDangles(std::vector<const geom::SimpleCurve*>& dangleLines);
 
 private:
 
@@ -137,7 +146,7 @@ private:
 
     const geom::GeometryFactory* factory;
 
-    planargraph::Node* getNode(const geom::Coordinate& pt);
+    planargraph::Node* getNode(const geom::CoordinateXY& pt);
 
     void computeNextCWEdges();