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

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/noding/FastNodingValidator.h

@@ -60,13 +60,16 @@ class FastNodingValidator {
 
 public:
 
-    FastNodingValidator(std::vector<noding::SegmentString*>& newSegStrings)
+    FastNodingValidator(const std::vector<std::unique_ptr<SegmentString>>& newSegStrings)
         :
         li(), // robust...
-        segStrings(newSegStrings),
         segInt(),
         isValidVar(true)
     {
+        segStrings.resize(newSegStrings.size());
+        for (std::size_t i = 0; i < newSegStrings.size(); ++i) {
+            segStrings[i] = newSegStrings[i].get();
+        }
     }
 
     /** \brief
@@ -102,7 +105,7 @@ private:
 
     geos::algorithm::LineIntersector li;
 
-    std::vector<noding::SegmentString*>& segStrings;
+    std::vector<SegmentString*> segStrings;
 
     std::unique_ptr<NodingIntersectionFinder> segInt;
 

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/noding/GeometryNoder.h

@@ -25,10 +25,14 @@
 
 // Forward declarations
 namespace geos {
+namespace algorithm {
+class CircularArcIntersector;
+}
 namespace geom {
 class Geometry;
 }
 namespace noding {
+class ArcIntersectionAdder;
 class Noder;
 }
 }
@@ -41,29 +45,46 @@ public:
 
     static std::unique_ptr<geom::Geometry> node(const geom::Geometry& geom);
 
+    static std::unique_ptr<geom::Geometry> node(const geom::Geometry& geom1, const geom::Geometry& geom2);
+
     GeometryNoder(const geom::Geometry& g);
 
+    GeometryNoder(const geom::Geometry& g1, const geom::Geometry& g2);
+
+    ~GeometryNoder();
+
     std::unique_ptr<geom::Geometry> getNoded();
 
-private:
+    void setOnlyFirstGeomEdges(bool onlyFirstGeomEdges);
+
+    void setPreserveCompoundCurves(bool preserve);
 
-    const geom::Geometry& argGeom;
+    // Declare type as noncopyable
+    GeometryNoder(GeometryNoder const&) = delete;
+    GeometryNoder& operator=(GeometryNoder const&) = delete;
 
-    SegmentString::NonConstVect lineList;
+private:
 
-    static void extractSegmentStrings(const geom::Geometry& g,
-                                      SegmentString::NonConstVect& to);
+    bool isInResult(const PathString& ps) const;
 
-    Noder& getNoder();
+    const geom::Geometry* argGeom1;
+    const geom::Geometry* argGeom2;
+    const bool argGeomHasCurves;
+    bool argGeomHasCompoundCurves;
+    bool onlyFirstGeomEdges;
+    bool preserveCompoundCurves;
 
     std::unique_ptr<Noder> noder;
+    std::unique_ptr<algorithm::CircularArcIntersector> m_cai;
+    std::unique_ptr<ArcIntersectionAdder> m_aia;
+
+    void extractPathStrings(const geom::Geometry& g, std::vector<std::unique_ptr<PathString>>& to);
 
-    std::unique_ptr<geom::Geometry> toGeometry(SegmentString::NonConstVect& noded);
+    Noder& getNoder();
+
+    std::unique_ptr<geom::Geometry> toGeometry(std::vector<std::unique_ptr<PathString>>& noded) const;
 
-    GeometryNoder(GeometryNoder const&); /*= delete*/
-    GeometryNoder& operator=(GeometryNoder const&); /*= delete*/
 };
 
 } // namespace geos.noding
 } // namespace geos
-

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/noding/IteratedNoder.h

@@ -57,14 +57,14 @@ private:
 
     const geom::PrecisionModel* pm;
     algorithm::LineIntersector li;
-    std::vector<SegmentString*>* nodedSegStrings;
+    std::vector<std::unique_ptr<SegmentString>> nodedSegStrings;
     int maxIter;
 
     /**
      * Node the input segment strings once
      * and create the split edges between the nodes
      */
-    void node(std::vector<SegmentString*>* segStrings,
+    void node(const std::vector<SegmentString*>& segStrings,
               int& numInteriorIntersections,
               geom::CoordinateXY& intersectionPoint);
 
@@ -96,10 +96,10 @@ public:
         maxIter = n;
     }
 
-    std::vector<SegmentString*>*
-    getNodedSubstrings() const override
+    std::vector<std::unique_ptr<SegmentString>>
+    getNodedSubstrings() override
     {
-        return nodedSegStrings;
+        return std::move(nodedSegStrings);
     }
 
 
@@ -112,7 +112,11 @@ public:
      * @param inputSegmentStrings a collection of SegmentStrings to be noded
      * @throws TopologyException if the iterated noding fails to converge.
      */
-    void computeNodes(std::vector<SegmentString*>* inputSegmentStrings) override; // throw(GEOSException);
+    void computeNodes(const std::vector<SegmentString*>& inputSegmentStrings) override; // throw(GEOSException);
+
+    // Declare type as noncopyable
+    IteratedNoder(IteratedNoder const&) = delete;
+    IteratedNoder& operator=(IteratedNoder const&) = delete;
 };
 
 } // namespace geos::noding

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/noding/MCIndexNoder.h

@@ -67,7 +67,7 @@ class GEOS_DLL MCIndexNoder : public SinglePassNoder {
 private:
     std::vector<index::chain::MonotoneChain> monoChains;
     index::strtree::TemplateSTRtree<const index::chain::MonotoneChain*> index;
-    std::vector<SegmentString*>* nodedSegStrings;
+    std::vector<SegmentString*> nodedSegStrings;
     // statistics
     int nOverlaps;
     double overlapTolerance;
@@ -81,7 +81,6 @@ public:
 
     MCIndexNoder(SegmentIntersector* nSegInt = nullptr, double p_overlapTolerance = 0.0)
         : SinglePassNoder(nSegInt)
-        , nodedSegStrings(nullptr)
         , nOverlaps(0)
         , overlapTolerance(p_overlapTolerance)
         , indexBuilt(false)
@@ -102,13 +101,13 @@ public:
         return index;
     }
 
-    std::vector<SegmentString*>* getNodedSubstrings() const override
+    std::vector<std::unique_ptr<SegmentString>> getNodedSubstrings() override
     {
-        assert(nodedSegStrings); // must have called computeNodes before!
-        return NodedSegmentString::getNodedSubstrings(*nodedSegStrings);
+        //assert(nodedSegStrings); // must have called computeNodes before!
+        return NodedSegmentString::getNodedSubstrings(nodedSegStrings);
     }
 
-    void computeNodes(std::vector<SegmentString*>* inputSegmentStrings) override;
+    void computeNodes(const std::vector<SegmentString*>& inputSegmentStrings) override;
 
     class SegmentOverlapAction : public index::chain::MonotoneChainOverlapAction {
     public:

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/noding/NodableArcString.h

@@ -0,0 +1,44 @@
+/**********************************************************************
+*
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 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 <geos/export.h>
+#include <geos/noding/ArcString.h>
+#include <geos/noding/NodablePath.h>
+
+namespace geos::noding {
+
+class GEOS_DLL NodableArcString : public ArcString, public NodablePath {
+
+public:
+    NodableArcString(std::vector<geom::CircularArc> arcs, const std::shared_ptr<const geom::CoordinateSequence>& coords, bool constructZ, bool constructM, const void* context);
+
+    std::unique_ptr<ArcString> clone() const;
+
+    using NodablePath::addIntersection;
+
+    void addIntersection(const geom::CoordinateXYZM& intPt, size_t segmentIndex) override {
+        m_adds[segmentIndex].push_back(intPt);
+    }
+
+    void getNoded(std::vector<std::unique_ptr<ArcString>>& splitArcs);
+
+private:
+    std::map<size_t, std::vector<geom::CoordinateXYZM>> m_adds;
+    bool m_constructZ = false;
+    bool m_constructM = false;
+};
+
+}

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/noding/NodablePath.h

@@ -0,0 +1,40 @@
+/**********************************************************************
+*
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 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 <geos/export.h>
+#include <geos/geom/Coordinate.h>
+
+namespace geos::noding {
+
+/// A NodablePath represents a PathString to which coordinates can be added.
+class GEOS_DLL NodablePath {
+public:
+    virtual void addIntersection( const geom::Coordinate& intPt, size_t pathIndex) {
+        addIntersection(geom::CoordinateXYZM{intPt}, pathIndex);
+    }
+
+    virtual void addIntersection( const geom::CoordinateXYM& intPt, size_t pathIndex) {
+        addIntersection(geom::CoordinateXYZM{intPt}, pathIndex);
+    }
+
+    virtual void addIntersection(const geom::CoordinateXY& intPt, size_t pathIndex) {
+        addIntersection(geom::CoordinateXYZM{intPt}, pathIndex);
+    }
+
+    virtual void addIntersection(const geom::CoordinateXYZM& intPt, size_t pathIndex) =0;
+};
+
+}

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/noding/NodableSegmentString.h

@@ -37,7 +37,7 @@ class GEOS_DLL NodableSegmentString : public SegmentString {
 private:
 protected:
 public:
-    NodableSegmentString(const void* newContext, geom::CoordinateSequence* newSeq)
+    NodableSegmentString(const void* newContext, const std::shared_ptr<const geom::CoordinateSequence>& newSeq)
         :
         SegmentString(newContext, newSeq)
     { }

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/noding/NodedSegmentString.h

@@ -62,7 +62,7 @@ public:
     template <class II>
     static void
     getNodedSubstrings(II from, II too_far,
-                       SegmentString::NonConstVect* resultEdgelist)
+                       std::vector<std::unique_ptr<SegmentString>>& resultEdgelist)
     {
         for(II i = from; i != too_far; ++i) {
             NodedSegmentString* nss = dynamic_cast<NodedSegmentString*>(*i);
@@ -73,18 +73,17 @@ public:
 
     template <class C>
     static void
-    getNodedSubstrings(C* segStrings,
-                       SegmentString::NonConstVect* resultEdgelist)
+    getNodedSubstrings(const C& segStrings,
+                       std::vector<std::unique_ptr<SegmentString>>& resultEdgelist)
     {
-        getNodedSubstrings(segStrings->begin(), segStrings->end(), resultEdgelist);
+        getNodedSubstrings(segStrings.begin(), segStrings.end(), resultEdgelist);
     }
 
     static void getNodedSubstrings(const SegmentString::NonConstVect& segStrings,
-                                   SegmentString::NonConstVect* resultEdgeList);
+                                   std::vector<std::unique_ptr<SegmentString>>& resultEdgeList);
 
-    /// Returns allocated object
-    static SegmentString::NonConstVect* getNodedSubstrings(
-        const SegmentString::NonConstVect& segStrings);
+    static std::vector<std::unique_ptr<SegmentString>> getNodedSubstrings(
+        const std::vector<SegmentString*>& segStrings);
 
     std::unique_ptr<geom::CoordinateSequence> getNodedCoordinates();
 
@@ -103,29 +102,25 @@ public:
      * @param newContext the user-defined data of this segment string
      *                   (may be null)
      */
-    NodedSegmentString(geom::CoordinateSequence* newPts, bool constructZ, bool constructM, const void* newContext)
+    NodedSegmentString(const std::shared_ptr<const geom::CoordinateSequence>& newPts, bool constructZ, bool constructM, const void* newContext)
         : NodableSegmentString(newContext, newPts)
         , nodeList(*this, constructZ, constructM)
     {}
 
     NodedSegmentString(SegmentString* ss, bool constructZ, bool constructM)
-        : NodableSegmentString(ss->getData(), ss->getCoordinates()->clone().release())
+        : NodableSegmentString(ss->getData(), ss->getCoordinates())
         , nodeList(*this, constructZ, constructM)
     {}
 
     ~NodedSegmentString() override {
-        delete seq;
     }
 
     SegmentNodeList& getNodeList();
 
     const SegmentNodeList& getNodeList() const;
 
-    std::unique_ptr<geom::CoordinateSequence> releaseCoordinates();
-
     std::ostream& print(std::ostream& os) const override;
 
-
     /** \brief
      * Add {@link SegmentNode}s for one or both
      * intersections found for a segment of an edge to the edge

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/noding/Noder.h

@@ -16,12 +16,13 @@
 
 #include <geos/export.h>
 
+#include <memory>
 #include <vector>
-#include <iostream>
 
 // Forward declarations
 namespace geos {
 namespace noding {
+class PathString;
 class SegmentString;
 }
 }
@@ -40,8 +41,6 @@ namespace noding { // geos.noding
  *
  * Last port: noding/Noder.java rev. 1.8 (JTS-1.7)
  *
- * TODO: this was really an interface, we should avoid making it a Base class
- *
  */
 class GEOS_DLL Noder {
 public:
@@ -53,19 +52,24 @@ public:
      *
      * @param segStrings a collection of {@link SegmentString}s to node
      *        The caller remains responsible for releasing the memory
-     *        associated with the container and its elements.
+     *        associated with the SegmentStrings.
      */
-    virtual void computeNodes(std::vector<SegmentString*>* segStrings) = 0;
+    virtual void computeNodes(const std::vector<SegmentString*>& segStrings) = 0;
 
     /** \brief
      * Returns a collection of fully noded [SegmentStrings](@ref SegmentString).
      * The SegmentStrings have the same context as their parent.
      *
-     * @return a newly allocated std::vector of newly allocated
-     *         SegmentStrings (copies of input, if needs be).
-     *         Caller is responsible to delete container and elements.
+     * @return a std::vector of SegmentStrings (copies of input, if needs be).
+     *         Caller is responsible to delete elements of container.
+     *         This method may only be called once.
      */
-    virtual std::vector<SegmentString*>* getNodedSubstrings() const = 0;
+    virtual std::vector<std::unique_ptr<SegmentString>> getNodedSubstrings() = 0;
+
+    virtual void computePathNodes(const std::vector<PathString*>& inputPaths);
+
+    virtual std::vector<std::unique_ptr<PathString>> getNodedPaths();
+
 
     virtual
     ~Noder() {}

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/noding/NodingValidator.h

@@ -45,7 +45,7 @@ namespace noding { // geos.noding
 class GEOS_DLL NodingValidator {
 private:
     algorithm::LineIntersector li;
-    const std::vector<SegmentString*>& segStrings;
+    std::vector<SegmentString*> segStrings;
 
     /**
      * Checks if a segment string contains a segment
@@ -93,9 +93,13 @@ private:
 
 public:
 
-    NodingValidator(const std::vector<SegmentString*>& newSegStrings):
-        segStrings(newSegStrings)
-    {}
+    NodingValidator(const std::vector<std::unique_ptr<SegmentString>>& newSegStrings)
+    {
+        segStrings.resize(newSegStrings.size());
+        for (size_t i = 0; i < newSegStrings.size(); ++i) {
+            segStrings[i] = newSegStrings[i].get();
+        }
+    }
 
     ~NodingValidator() {}
 

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/noding/Octant.h

@@ -33,11 +33,11 @@ namespace noding { // geos.noding
  *
  * Octants are numbered as follows:
  *
- *   2|1
- * 3  |  0
+ *  \2|1/
+ * 3 \|/ 0
  * ---+--
- * 4  |  7
- *   5|6
+ * 4 /|\ 7
+ *  /5|6\
  *
  * If line segments lie along a coordinate axis, the octant is the lower of the two
  * possible values.

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/noding/PathString.h

@@ -0,0 +1,76 @@
+/**********************************************************************
+*
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 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 <geos/export.h>
+
+#include <cstddef>
+#include <memory>
+#include <vector>
+
+namespace geos::geom {
+    class CoordinateSequence;
+}
+
+namespace geos::noding {
+
+/// A PathString represents a contiguous line/arc to be used as an input or output
+/// of a noding process.
+class GEOS_DLL PathString {
+public:
+    explicit PathString(const void* p_context = nullptr) : context(p_context) {}
+
+    virtual ~PathString() = default;
+
+    virtual std::size_t getSize() const = 0;
+
+    virtual double getLength() const = 0;
+
+    /** \brief
+     * Gets the user-defined data for this segment string.
+     *
+     * @return the user-defined data
+     */
+    const void*
+    getData() const
+    {
+        return context;
+    }
+
+    /** \brief
+     * Sets the user-defined data for this segment string.
+     *
+     * @param data an Object containing user-defined data
+     */
+    void
+    setData(const void* data)
+    {
+        context = data;
+    }
+
+    /// \brief
+    /// Return a pointer to the CoordinateSequence associated
+    /// with this PathString.
+    virtual const std::shared_ptr<const geom::CoordinateSequence>& getCoordinates() const = 0;
+
+    std::vector<PathString*>
+    static toRawPointerVector(const std::vector<std::unique_ptr<PathString>> & segStrings);
+
+private:
+
+    const void* context;
+};
+
+}

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/noding/ScaledNoder.h

@@ -77,9 +77,9 @@ public:
 
     ~ScaledNoder() override;
 
-    std::vector<SegmentString*>* getNodedSubstrings() const override;
+    std::vector<std::unique_ptr<SegmentString>> getNodedSubstrings() override;
 
-    void computeNodes(std::vector<SegmentString*>* inputSegStr) override;
+    void computeNodes(const std::vector<SegmentString*>& inputSegStr) override;
 
     //void filter(Coordinate& c);
 
@@ -104,9 +104,9 @@ private:
 
     bool isScaled;
 
-    void rescale(std::vector<SegmentString*>& segStrings) const;
+    void rescale(std::vector<std::unique_ptr<SegmentString>>& segStrings) const;
 
-    void scale(std::vector<SegmentString*>& segStrings) const;
+    void scale(const std::vector<SegmentString*>& segStrings) const;
 
     class Scaler;
 

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/noding/SegmentExtractingNoder.h

@@ -53,15 +53,15 @@ class GEOS_DLL SegmentExtractingNoder : public Noder {
 
 private:
 
-    std::vector<SegmentString*>* segList;
+    std::vector<std::unique_ptr<SegmentString>> segList;
 
     void extractSegments(
         const std::vector<SegmentString*>& inputSegs,
-        std::vector<SegmentString*>& outputSegs);
+        std::vector<std::unique_ptr<SegmentString>>& outputSegs);
 
     void extractSegments(
         const SegmentString* ss,
-        std::vector<SegmentString*>& outputSegs);
+        std::vector<std::unique_ptr<SegmentString>>& outputSegs);
 
 
 public:
@@ -69,17 +69,19 @@ public:
     /**
     * Creates a new segment-extracting noder.
     */
-    SegmentExtractingNoder() : segList(nullptr)
-        {};
+    SegmentExtractingNoder() = default;
 
-    void computeNodes(std::vector<SegmentString*>* segStrings) override;
+    void computeNodes(const std::vector<SegmentString*>& segStrings) override;
 
     /**
     * @return a Collection of SegmentString representing the
     * substrings. Caller takes ownership over vector and contents.
     */
-    std::vector<SegmentString*>* getNodedSubstrings() const override;
+    std::vector<std::unique_ptr<SegmentString>> getNodedSubstrings() override;
 
+    // Declare type as noncopyable
+    SegmentExtractingNoder(SegmentExtractingNoder const&) = delete;
+    SegmentExtractingNoder& operator=(SegmentExtractingNoder const&) = delete;
 
 };
 

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/noding/SegmentNodeList.h

@@ -97,7 +97,7 @@ private:
     * @param ei1 the end node of the split edge
     * @return the points for the split edge
     */
-    std::unique_ptr<geom::CoordinateSequence> createSplitEdgePts(const SegmentNode* ei0, const SegmentNode* ei1) const;
+    std::shared_ptr<geom::CoordinateSequence> createSplitEdgePts(const SegmentNode *ei0, const SegmentNode *ei1) const;
 
     /**
      * Adds nodes for any collapsed edge pairs.
@@ -219,10 +219,10 @@ public:
      * Adds the edges to the input list (this is so a single list
      * can be used to accumulate all split edges for a Geometry).
      */
-    void addSplitEdges(std::vector<SegmentString*>& edgeList);
+    void addSplitEdges(std::vector<std::unique_ptr<SegmentString>>& edgeList);
 
     void
-    addSplitEdges(std::vector<SegmentString*>* edgeList)
+    addSplitEdges(std::vector<std::unique_ptr<SegmentString>>* edgeList)
     {
         assert(edgeList);
         addSplitEdges(*edgeList);

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/noding/SegmentPointComparator.h

@@ -49,8 +49,8 @@ public:
      * @return 1 node1 occurs first
      */
     static int
-    compare(int octant, const geom::Coordinate& p0,
-            const geom::Coordinate& p1)
+    compare(int octant, const geom::CoordinateXY& p0,
+            const geom::CoordinateXY& p1)
     {
         // nodes can only be equal if their coordinates are equal
         if(p0.equals2D(p1)) {