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

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/noding/SegmentString.h

@@ -21,9 +21,11 @@
 #pragma once
 
 #include <geos/export.h>
+#include <geos/algorithm/Length.h>
 #include <geos/geom/Coordinate.h>
 #include <geos/geom/CoordinateSequence.h>
 #include <geos/noding/Octant.h>
+#include <geos/noding/PathString.h>
 
 #include <vector>
 
@@ -44,7 +46,7 @@ namespace noding { // geos.noding
  * SegmentStrings can carry a context object, which is useful
  * for preserving topological or parentage information.
  */
-class GEOS_DLL SegmentString {
+class GEOS_DLL SegmentString : public PathString {
 public:
     typedef std::vector<const SegmentString*> ConstVect;
     typedef std::vector<SegmentString*> NonConstVect;
@@ -57,58 +59,40 @@ public:
     /// @param newContext the context associated to this SegmentString
     /// @param newSeq coordinates of this SegmentString
     ///
-    SegmentString(const void* newContext, geom::CoordinateSequence* newSeq)
-        :
-        seq(newSeq),
-        context(newContext)
+    SegmentString(const void* newContext, const std::shared_ptr<const geom::CoordinateSequence>& newSeq)
+        : PathString(newContext),
+        seq(newSeq)
     {}
 
-    virtual
-    ~SegmentString() {}
-
-    /** \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;
-    }
+    ~SegmentString() override = default;
 
     std::size_t size() const {
+        // FIXME: Remove this method, or make consistent with getSize
         return seq->size();
     }
 
+    std::size_t getSize() const override{
+        return seq->size() - 1;
+    }
+
     template<typename CoordType = geom::Coordinate>
     const CoordType& getCoordinate(std::size_t i) const {
         return seq->getAt<CoordType>(i);
     }
 
+    double getLength() const override {
+        return algorithm::Length::ofLine(seq.get());
+    }
+
     /// \brief
     /// Return a pointer to the CoordinateSequence associated
     /// with this SegmentString.
-    ///
-    /// @note The CoordinateSequence is owned by this SegmentString!
-    ///
-    const geom::CoordinateSequence* getCoordinates() const {
+    const std::shared_ptr<const geom::CoordinateSequence>& getCoordinates() const override {
         return seq;
     }
 
-    geom::CoordinateSequence* getCoordinates() {
-        return seq;
+    void setCoordinates(const std::shared_ptr<const geom::CoordinateSequence>& newSeq) {
+        seq = newSeq;
     }
 
     /** \brief
@@ -171,14 +155,16 @@ public:
         return seq->front<geom::CoordinateXY>().equals(seq->back<geom::CoordinateXY>());
     }
 
+    static std::vector<SegmentString*> toRawPointerVector(const std::vector<std::unique_ptr<SegmentString>> & segStrings);
+
+    static std::vector<SegmentString*> toRawPointerVector(const std::vector<std::unique_ptr<PathString>> & segStrings);
+
     virtual std::ostream& print(std::ostream& os) const;
 
 protected:
-    geom::CoordinateSequence* seq;
+    std::shared_ptr<const geom::CoordinateSequence> seq;
 
 private:
-    const void* context;
-
     static int safeOctant(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1)
     {
         if(p0.equals2D(p1)) {

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/noding/SegmentStringUtil.h

@@ -55,8 +55,8 @@ public:
         geom::util::LinearComponentExtracter::getLines(*g, lines);
 
         for(const geom::LineString* line : lines) {
-            auto pts = line->getCoordinatesRO();
-            segStr.push_back(new BasicSegmentString(const_cast<geom::CoordinateSequence*>(pts), g));
+            const auto& pts = line->getSharedCoordinates();
+            segStr.push_back(new BasicSegmentString(pts, g));
         }
     }
 

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/noding/SimpleNoder.h

@@ -22,22 +22,20 @@
 
 #include <vector>
 
-#include <geos/noding/SinglePassNoder.h>
-#include <geos/noding/NodedSegmentString.h> // for inlined (FIXME)
+#include <geos/noding/ArcNoder.h>
 
 // Forward declarations
 namespace geos {
 namespace noding {
-//class SegmentString;
+class PathString;
 }
 }
 
 namespace geos {
 namespace noding { // geos.noding
 
-
 /** \brief
- * Nodes a set of {@link SegmentString}s by
+ * Nodes a set of {@link SegmentString}s and/or {@link ArcString}s by
  * performing a brute-force comparison of every segment to every other one.
  *
  * This has n^2 performance, so is too slow for use on large numbers
@@ -45,24 +43,21 @@ namespace noding { // geos.noding
  *
  * @version 1.7
  */
-class GEOS_DLL SimpleNoder: public SinglePassNoder {
+class GEOS_DLL SimpleNoder: public ArcNoder {
 private:
-    std::vector<SegmentString*>* nodedSegStrings;
-    virtual void computeIntersects(SegmentString* e0, SegmentString* e1);
+    std::vector<PathString*> nodedSegStrings;
+    void computeIntersects(PathString& e0, PathString& e1);
 
 public:
-    SimpleNoder(SegmentIntersector* nSegInt = nullptr)
-        :
-        SinglePassNoder(nSegInt)
-    {}
 
-    void computeNodes(std::vector<SegmentString*>* inputSegmentStrings) override;
+    using ArcNoder::ArcNoder;
+
+    void computePathNodes(const std::vector<PathString*>& inputSegmentStrings) override;
 
-    std::vector<SegmentString*>*
-    getNodedSubstrings() const override
-    {
-        return NodedSegmentString::getNodedSubstrings(*nodedSegStrings);
-    }
+    std::vector<std::unique_ptr<PathString>> getNodedPaths() override;
+
+private:
+    std::vector<PathString*> m_pathStrings;
 };
 
 } // namespace geos.noding

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/noding/SinglePassNoder.h

@@ -15,9 +15,6 @@
 #pragma once
 
 #include <geos/export.h>
-
-#include <vector>
-
 #include <geos/noding/Noder.h>
 
 // Forward declarations
@@ -42,8 +39,6 @@ namespace noding { // geos.noding
  *
  * Last port: noding/SinglePassNoder.java rev. 1.3 (JTS-1.7)
  *
- * TODO: Noder inheritance (that's just an interface!)
- *
  */
 class GEOS_DLL SinglePassNoder : public Noder { // implements Noder
 
@@ -74,22 +69,6 @@ public:
         segInt = newSegInt;
     }
 
-    /** \brief
-     * Computes the noding for a collection of {@link SegmentString}s.
-     *
-     * @param segStrings a collection of {@link SegmentString}s to node
-     */
-    void computeNodes(std::vector<SegmentString*>* segStrings) override = 0;
-
-    /** \brief
-     * Returns a Collection of fully noded {@link SegmentString}s.
-     *
-     * The SegmentStrings have the same context as their parent.
-     *
-     * @return a Collection of SegmentStrings
-     */
-    std::vector<SegmentString*>* getNodedSubstrings() const override = 0;
-
 };
 
 } // namespace geos.noding

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/noding/ValidatingNoder.h

@@ -17,6 +17,7 @@
 
 #include <geos/export.h>
 #include <geos/noding/Noder.h>
+#include <geos/noding/SegmentString.h>
 
 #include <memory> // for unique_ptr
 
@@ -51,7 +52,7 @@ class GEOS_DLL ValidatingNoder : public Noder {
 
 private:
 
-    std::vector<SegmentString*>* nodedSS;
+    std::vector<std::unique_ptr<SegmentString>> nodedSS;
     noding::Noder& noder;
 
 
@@ -61,11 +62,17 @@ public:
         : noder(noderArg)
         {}
 
-    void computeNodes(std::vector<SegmentString*>* segStrings) override;
+    ~ValidatingNoder() override;
 
-    void validate();
+    void computeNodes(const std::vector<SegmentString*>& segStrings) override;
 
-    std::vector<SegmentString*>* getNodedSubstrings() const override;
+    void validate() const;
+
+    std::vector<std::unique_ptr<SegmentString>> getNodedSubstrings() override;
+
+    // Declare type as noncopyable
+    ValidatingNoder(ValidatingNoder const&) = delete;
+    ValidatingNoder& operator=(ValidatingNoder const&) = delete;
 
 };
 

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/noding/snap/SnappingNoder.h

@@ -24,6 +24,7 @@
 #include <geos/geom/CoordinateSequence.h>
 #include <geos/geom/Envelope.h>
 #include <geos/noding/Noder.h>
+#include <geos/noding/SegmentString.h>
 #include <geos/noding/snap/SnappingPointIndex.h>
 
 
@@ -71,17 +72,17 @@ private:
     // Members
     double snapTolerance;
     SnappingPointIndex snapIndex;
-    std::vector<SegmentString*>* nodedResult;
+    std::vector<std::unique_ptr<SegmentString>> nodedResult;
 
     // Methods
 
-    void seedSnapIndex(std::vector<SegmentString*>& segStrings);
+    void seedSnapIndex(const std::vector<SegmentString*>& segStrings);
 
-    void snapVertices(std::vector<SegmentString*>& segStrings, std::vector<SegmentString*>& nodedStrings);
+    void snapVertices(const std::vector<SegmentString*>& segStrings, std::vector<SegmentString*>& nodedStrings);
 
-    SegmentString* snapVertices(SegmentString* ss);
+    std::unique_ptr<SegmentString> snapVertices(const SegmentString* ss);
 
-    std::unique_ptr<geom::CoordinateSequence> snap(const geom::CoordinateSequence* cs);
+    std::shared_ptr<geom::CoordinateSequence> snap(const geom::CoordinateSequence *cs);
 
     /**
     * Computes all interior intersections in the collection of {@link SegmentString}s,
@@ -91,7 +92,7 @@ private:
     *
     * @return a list of Coordinates for the intersections
     */
-    std::unique_ptr<std::vector<SegmentString*>> snapIntersections(std::vector<SegmentString*>& inputSS);
+    std::vector<std::unique_ptr<SegmentString>> snapIntersections(std::vector<SegmentString*>& inputSS);
 
 
 public:
@@ -108,9 +109,9 @@ public:
     /**
     * @return a Collection of NodedSegmentStrings representing the substrings
     */
-    std::vector<SegmentString*>* getNodedSubstrings() const override;
+    std::vector<std::unique_ptr<SegmentString>> getNodedSubstrings() override;
 
-    void computeNodes(std::vector<SegmentString*>* inputSegStrings) override;
+    void computeNodes(const std::vector<SegmentString*>& inputSegStrings) override;
 
 
 };

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/noding/snapround/MCIndexSnapRounder.h

@@ -83,13 +83,13 @@ public:
         li.setPrecisionModel(&pm);
     }
 
-    std::vector<SegmentString*>*
-    getNodedSubstrings() const override
+    std::vector<std::unique_ptr<SegmentString>>
+    getNodedSubstrings() override
     {
-        return NodedSegmentString::getNodedSubstrings(*nodedSegStrings);
+        return NodedSegmentString::getNodedSubstrings(nodedSegStrings);
     }
 
-    void computeNodes(std::vector<SegmentString*>* segStrings) override;
+    void computeNodes(const std::vector<SegmentString*>& segStrings) override;
 
     /**
      * Computes nodes introduced as a result of
@@ -99,7 +99,7 @@ public:
      *        NOTE: they *must* be instances of NodedSegmentString, or
      * 	            an assertion will fail.
      */
-    void computeVertexSnaps(std::vector<SegmentString*>& edges);
+    void computeVertexSnaps(const std::vector<SegmentString*>& edges);
 
 private:
 
@@ -110,11 +110,11 @@ private:
 
     double scaleFactor;
 
-    std::vector<SegmentString*>* nodedSegStrings;
+    std::vector<SegmentString*> nodedSegStrings;
 
     std::unique_ptr<MCIndexPointSnapper> pointSnapper;
 
-    void snapRound(MCIndexNoder& noder, std::vector<SegmentString*>* segStrings);
+    void snapRound(MCIndexNoder& noder, const std::vector<SegmentString*>& segStrings);
 
 
     /**
@@ -125,7 +125,7 @@ private:
      *
      */
     void findInteriorIntersections(MCIndexNoder& noder,
-                                   std::vector<SegmentString*>* segStrings,
+                                   const std::vector<SegmentString*>& segStrings,
                                    std::vector<geom::Coordinate>& intersections);
 
     /**

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/noding/snapround/SnapRoundingNoder.h

@@ -83,7 +83,7 @@ private:
     std::vector<SegmentString*> snappedResult;
 
     // Methods
-    void snapRound(std::vector<SegmentString*>& inputSegStrings, std::vector<SegmentString*>& resultNodedSegments);
+    void snapRound(const std::vector<SegmentString*>& inputSegStrings, std::vector<SegmentString*>& resultNodedSegments);
 
     /**
     * Creates HotPixels for each vertex in the input segStrings.
@@ -92,14 +92,14 @@ private:
     * if they interact with other segments (or they are already
     * created as intersection nodes).
     */
-    void addVertexPixels(std::vector<SegmentString*>& segStrings);
+    void addVertexPixels(const std::vector<SegmentString*>& segStrings);
 
     /**
     * Detects interior intersections in the collection of {@link SegmentString}s,
     * and adds nodes for them to the segment strings.
     * Also creates HotPixel nodes for the intersection points.
     */
-    void addIntersectionPixels(std::vector<SegmentString*>& segStrings);
+    void addIntersectionPixels(const std::vector<SegmentString*>& segStrings);
 
     /**
     * Gets a list of the rounded coordinates.
@@ -148,13 +148,13 @@ public:
     /**
     * @return a Collection of NodedSegmentStrings representing the substrings
     */
-    std::vector<SegmentString*>* getNodedSubstrings() const override;
+    std::vector<std::unique_ptr<SegmentString>> getNodedSubstrings() override;
 
     /**
     * Computes the nodes in the snap-rounding line arrangement.
     * The nodes are added to the {@link NodedSegmentString}s provided as the input.
     */
-    void computeNodes(std::vector<SegmentString*>* inputSegStrings) override; //override
+    void computeNodes(const std::vector<SegmentString*>& inputSegStrings) override; //override
 
 };
 

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/operation/BoundaryOp.h

@@ -24,8 +24,11 @@
 
 namespace geos {
 namespace geom {
+class Curve;
 class LineString;
+class MultiCurve;
 class MultiLineString;
+class GeometryCollection;
 }
 }
 
@@ -108,11 +111,11 @@ private:
   const geom::GeometryFactory& m_geomFact;
   const algorithm::BoundaryNodeRule& m_bnRule;
 
-  std::unique_ptr<geom::Geometry> boundaryMultiLineString(const geom::MultiLineString& mLine);
+  std::unique_ptr<geom::Geometry> boundaryMultiCurve(const geom::GeometryCollection& mLine);
 
-  std::unique_ptr<geom::CoordinateSequence> computeBoundaryCoordinates(const geom::MultiLineString& mLine);
+  std::unique_ptr<geom::CoordinateSequence> computeBoundaryCoordinates(const geom::GeometryCollection& mLine) const;
 
-  std::unique_ptr<geom::Geometry> boundaryLineString(const geom::LineString& line);
+  std::unique_ptr<geom::Geometry> boundaryCurve(const geom::Curve& line) const;
 };
 
 }

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/operation/buffer/BufferCurveSetBuilder.h

@@ -104,7 +104,7 @@ private:
      *
      * @param coord is raw offset curve, ownership transferred here
      */
-    void addCurve(geom::CoordinateSequence* coord, geom::Location leftLoc,
+    void addCurve(std::unique_ptr<geom::CoordinateSequence> coord, geom::Location leftLoc,
                   geom::Location rightLoc);
 
     void add(const geom::Geometry& g);
@@ -279,7 +279,7 @@ public:
     /// @param leftLoc left location
     /// @param rightLoc right location
     ///
-    void addCurves(const std::vector<geom::CoordinateSequence*>& lineList,
+    void addCurves(std::vector<std::unique_ptr<geom::CoordinateSequence>>& lineList,
                    geom::Location leftLoc, geom::Location rightLoc);
 
     /**

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/operation/buffer/OffsetCurveBuilder.h

@@ -117,11 +117,10 @@ public:
      * @param distance offset distance
      * @param lineList the std::vector to which the newly created
      *                 CoordinateSequences will be pushed_back.
-     *                 Caller is responsible to delete these new elements.
      */
     void getLineCurve(const CoordinateSequence* inputPts,
         double distance,
-        std::vector<CoordinateSequence*>& lineList);
+        std::vector<std::unique_ptr<CoordinateSequence>>& lineList);
 
     /**
     * This method handles single points as well as LineStrings.
@@ -156,7 +155,7 @@ public:
      * @note This is a GEOS extension.
      */
     void getSingleSidedLineCurve(const CoordinateSequence* inputPts,
-                                 double distance, std::vector<CoordinateSequence*>& lineList,
+                                 double distance, std::vector<std::unique_ptr<CoordinateSequence>>& lineList,
                                  bool leftSide, bool rightSide) ;
 
     /** \brief
@@ -171,7 +170,7 @@ public:
      */
     void getRingCurve(const CoordinateSequence* inputPts, int side,
                       double distance,
-                      std::vector<CoordinateSequence*>& lineList);
+                      std::vector<std::unique_ptr<CoordinateSequence>>& lineList);
 
     /**
     * This method handles the degenerate cases of single points and lines,
@@ -189,7 +188,7 @@ public:
 
     void getOffsetCurve(const CoordinateSequence* inputPts,
                         double p_distance,
-                        std::vector<CoordinateSequence*>& lineList);
+                        std::vector<std::unique_ptr<CoordinateSequence>>& lineList);
 
     std::unique_ptr<CoordinateSequence> getOffsetCurve(
         const CoordinateSequence* inputPts,

package/geos_c.xcframework/ios-arm64-simulator/Headers/geos/operation/buffer/OffsetSegmentGenerator.h

@@ -101,9 +101,9 @@ public:
     /// FIXME: refactor memory management of this
     ///
     void
-    getCoordinates(std::vector<geom::CoordinateSequence*>& to)
+    getCoordinates(std::vector<std::unique_ptr<geom::CoordinateSequence>>& to)
     {
-        to.push_back(segList.getCoordinates());
+        to.emplace_back(segList.getCoordinates());
     }
 
     std::unique_ptr<geom::CoordinateSequence>
@@ -144,7 +144,8 @@ public:
     /// Add an end cap around point p1, terminating a line segment
     /// coming from p0
     void addLineEndCap(const geom::Coordinate& p0,
-                       const geom::Coordinate& p1);
+                       const geom::Coordinate& p1,
+                       const geom::Coordinate& p2);
 
     void
     addSegments(const geom::CoordinateSequence& pts, bool isForward)

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

@@ -37,11 +37,14 @@
 // Forward declarations
 namespace geos {
 namespace geom {
+class CircularString;
 class Coordinate;
 class Polygon;
 class LineString;
 class Point;
 class Geometry;
+class SimpleCurve;
+class Surface;
 }
 }
 
@@ -104,7 +107,15 @@ public:
                                  double distance);
 
     /**
-     * Compute the the nearest points of two geometries.
+     * Report the locations of the nearest points in the input geometries.
+     * The locations are presented in the same order as the input geometries.
+     *
+     * @return a pair of {@link GeometryLocation}s for the nearest points
+     */
+    const std::array<GeometryLocation, 2>& nearestLocations();
+
+    /**
+     * Compute the nearest points of two geometries.
      *
      * The points are presented in the same order as the input Geometries.
      *
@@ -183,7 +194,7 @@ private:
     void computeContainmentDistance();
 
     void computeInside(std::vector<GeometryLocation> & locs,
-                       const std::vector<const geom::Polygon*>& polys,
+                       const std::vector<const geom::Surface*>& polys,
                        std::array<GeometryLocation, 2> & locPtPoly);
 
 
@@ -194,8 +205,8 @@ private:
     void computeFacetDistance();
 
     void computeMinDistanceLines(
-        const std::vector<const geom::LineString*>& lines0,
-        const std::vector<const geom::LineString*>& lines1,
+        const std::vector<const geom::SimpleCurve*>& lines0,
+        const std::vector<const geom::SimpleCurve*>& lines1,
         std::array<GeometryLocation, 2> & locGeom);
 
     void computeMinDistancePoints(
@@ -204,17 +215,33 @@ private:
         std::array<GeometryLocation, 2> & locGeom);
 
     void computeMinDistanceLinesPoints(
-        const std::vector<const geom::LineString*>& lines0,
+        const std::vector<const geom::SimpleCurve*>& lines0,
         const std::vector<const geom::Point*>& points1,
         std::array<GeometryLocation, 2> & locGeom);
 
+    void computeMinDistance(const geom::CircularString* cs0,
+                            const geom::LineString* line1,
+                            std::array<GeometryLocation, 2> & locGeom);
+
+    void computeMinDistance(const geom::LineString* line0,
+                            const geom::CircularString* cs1,
+                            std::array<GeometryLocation, 2> & locGeom);
+
     void computeMinDistance(const geom::LineString* line0,
                             const geom::LineString* line1,
                             std::array<GeometryLocation, 2> & locGeom);
 
+    void computeMinDistance(const geom::CircularString* cs0,
+                            const geom::CircularString* cs1,
+                            std::array<GeometryLocation, 2> & locGeom);
+
     void computeMinDistance(const geom::LineString* line,
                             const geom::Point* pt,
                             std::array<GeometryLocation, 2> & locGeom);
+
+    void computeMinDistance(const geom::CircularString* cs,
+                            const geom::Point* pt,
+                            std::array<GeometryLocation, 2> & locGeom);
 };