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

package/geos.xcframework/ios-arm64-simulator/Headers/geos/operation/union/UnaryUnionOp.h

@@ -28,6 +28,7 @@
 #include <geos/geom/Polygon.h>
 #include <geos/geom/util/GeometryExtracter.h>
 #include <geos/operation/union/CascadedPolygonUnion.h>
+#include <geos/util/Progress.h>
 
 #include <geos/util.h>
 
@@ -93,7 +94,8 @@ public:
     Union(const T& geoms)
     {
         UnaryUnionOp op(geoms);
-        return op.Union();
+        geos::util::ProgressFunction* progressFunction = nullptr;
+        return op.Union(progressFunction);
     }
 
     template <class T>
@@ -102,14 +104,15 @@ public:
           geom::GeometryFactory& geomFact)
     {
         UnaryUnionOp op(geoms, geomFact);
-        return op.Union();
+        geos::util::ProgressFunction* progressFunction = nullptr;
+        return op.Union(progressFunction);
     }
 
     static std::unique_ptr<geom::Geometry>
-    Union(const geom::Geometry& geom)
+    Union(const geom::Geometry& geom, geos::util::ProgressFunction* progressFunction)
     {
         UnaryUnionOp op(geom);
-        return op.Union();
+        return op.Union(progressFunction);
     }
 
     template <class T>
@@ -150,7 +153,7 @@ public:
      * @return an empty GEOMETRYCOLLECTION if no geometries were provided
      *         in the input
      */
-    std::unique_ptr<geom::Geometry> Union();
+    std::unique_ptr<geom::Geometry> Union(geos::util::ProgressFunction* progressFunction);
 
 private:
 
@@ -168,21 +171,7 @@ private:
         }
     }
 
-    void
-    extract(const geom::Geometry& geom)
-    {
-        util::ensureNoCurvedComponents(geom);
-
-        using namespace geom::util;
-
-        if(! geomFact) {
-            geomFact = geom.getFactory();
-        }
-
-        GeometryExtracter::extract<geom::Polygon>(geom, polygons);
-        GeometryExtracter::extract<geom::LineString>(geom, lines);
-        GeometryExtracter::extract<geom::Point>(geom, points);
-    }
+    void extract(const geom::Geometry& geom);
 
     /**
      * Computes a unary union with no extra optimization,
@@ -214,14 +203,14 @@ private:
      * @return the union of the input(s)
      * @return null if both inputs are null
      */
-    std::unique_ptr<geom::Geometry> unionWithNull(
+    static std::unique_ptr<geom::Geometry> unionWithNull(
         std::unique_ptr<geom::Geometry> g0,
         std::unique_ptr<geom::Geometry> g1
         );
 
     // Members
-    std::vector<const geom::Polygon*> polygons;
-    std::vector<const geom::LineString*> lines;
+    std::vector<const geom::Surface*> polygons;
+    std::vector<const geom::Curve*> lines;
     std::vector<const geom::Point*> points;
 
     const geom::GeometryFactory* geomFact;

package/geos.xcframework/ios-arm64-simulator/Headers/geos/operation/valid/IsSimpleOp.h

@@ -129,11 +129,11 @@ private:
 
     bool isSimpleLinearGeometry(const geom::Geometry& geom);
 
-    static std::vector<std::unique_ptr<geos::geom::CoordinateSequence>>
+    static std::vector<std::shared_ptr<const geos::geom::CoordinateSequence>>
         removeRepeatedPts(const geom::Geometry& geom);
 
     static std::vector<std::unique_ptr<noding::SegmentString>>
-        createSegmentStrings(std::vector<std::unique_ptr<geos::geom::CoordinateSequence>>& seqs);
+        createSegmentStrings(std::vector<std::shared_ptr<const geos::geom::CoordinateSequence>>& seqs);
 
     class NonSimpleIntersectionFinder : public noding::SegmentIntersector
     {

package/geos.xcframework/ios-arm64-simulator/Headers/geos/operation/valid/PolygonTopologyAnalyzer.h

@@ -55,11 +55,6 @@ private:
     // can pass around pointers with abandon
     std::deque<PolygonRing> polyRingStore;
     std::deque<noding::BasicSegmentString> segStringStore;
-    // when building SegmentStrings we sometimes want
-    // to use deduped CoordinateSequences so we will
-    // keep the deduped ones here so they get cleaned
-    // up when processing is complete
-    std::vector<std::unique_ptr<CoordinateSequence>> coordSeqStore;
 
     PolygonRing* createPolygonRing(const LinearRing* p_ring);
     PolygonRing* createPolygonRing(const LinearRing* p_ring, int p_index, PolygonRing* p_shell);

package/geos.xcframework/ios-arm64-simulator/Headers/geos/operation/valid/RepeatedPointRemover.h

@@ -48,6 +48,13 @@ namespace valid {
                 const geom::CoordinateSequence* seq,
                 double tolerance = 0.0);
 
+        static std::unique_ptr<geom::CoordinateSequence>
+            removeRepeatedOrInvalidPoints(
+                const geom::CoordinateSequence* seq,
+                double tolerance = 0.0) {
+                return removeRepeatedAndInvalidPoints(seq, tolerance);
+            };
+
         static std::unique_ptr<geom::Geometry>
             removeRepeatedPoints(
                 const geom::Geometry* geom,

package/geos.xcframework/ios-arm64-simulator/Headers/geos/planargraph/DirectedEdge.h

@@ -54,11 +54,11 @@ public:
 
 protected:
     Edge* parentEdge;
-    Node* from;
-    Node* to;
-    geom::Coordinate p0, p1;
+    Node* const from;
+    Node* const to;
+    const geom::CoordinateXY p0, p1;
     DirectedEdge* sym;  // optional
-    bool edgeDirection;
+    const bool edgeDirection;
     int quadrant;
     double angle;
 public:
@@ -104,7 +104,7 @@ public:
      *                         parent Edge (if any)
      */
     DirectedEdge(Node* newFrom, Node* newTo,
-                 const geom::Coordinate& directionPt,
+                 const geom::CoordinateXY& directionPt,
                  bool newEdgeDirection);
 
     /**
@@ -129,7 +129,7 @@ public:
      * \brief Returns a point to which an imaginary line is drawn
      * from the from-node to specify this DirectedEdge's orientation.
      */
-    const geom::Coordinate& getDirectionPt() const;
+    const geom::CoordinateXY& getDirectionPt() const;
 
     /**
      * \brief Returns whether the direction of the parent Edge (if any)
@@ -140,18 +140,20 @@ public:
     /**
      * \brief Returns the node from which this DirectedEdge leaves.
      */
-    Node* getFromNode() const;
+    const Node* getFromNode() const;
+    Node* getFromNode();
 
     /**
      * \brief Returns the node to which this DirectedEdge goes.
      */
-    Node* getToNode() const;
+    const Node* getToNode() const;
+    Node* getToNode();
 
     /**
      * \brief
      * Returns the coordinate of the from-node.
      */
-    geom::Coordinate& getCoordinate() const;
+    const geom::CoordinateXY& getCoordinate() const;
 
     /**
      * \brief
@@ -185,7 +187,7 @@ public:
      * A robust algorithm is:
      *
      * - first compare the quadrants.
-     *   If the quadrants are different, it it
+     *   If the quadrants are different, it is
      *   trivial to determine which std::vector is "greater".
      * - if the vectors lie in the same quadrant, the robust
      *   Orientation::index(Coordinate, Coordinate, Coordinate)
@@ -206,7 +208,7 @@ public:
      * A robust algorithm is:
      *
      * - first compare the quadrants.
-     *   If the quadrants are different, it it trivial to determine
+     *   If the quadrants are different, it is trivial to determine
      *   which std::vector is "greater".
      * - if the vectors lie in the same quadrant, the robust
      *   Orientation::index(Coordinate, Coordinate, Coordinate)

package/geos.xcframework/ios-arm64-simulator/Headers/geos/planargraph/DirectedEdgeStar.h

@@ -27,7 +27,7 @@
 // Forward declarations
 namespace geos {
 namespace geom {
-class Coordinate;
+class CoordinateXY;
 }
 namespace planargraph {
 class DirectedEdge;
@@ -104,27 +104,27 @@ public:
      * \brief Returns the coordinate for the node at which this
      * star is based
      */
-    geom::Coordinate& getCoordinate() const;
+    const geom::CoordinateXY& getCoordinate() const;
 
     /**
      * \brief Returns the DirectedEdges, in ascending order
      * by angle with the positive x-axis.
      */
-    std::vector<DirectedEdge*>& getEdges();
+    std::vector<DirectedEdge*>& getEdges() const;
 
     /**
      * \brief Returns the zero-based index of the given Edge,
      * after sorting in ascending order by angle with the
      * positive x-axis.
      */
-    int getIndex(const Edge* edge);
+    int getIndex(const Edge* edge) const;
 
     /**
      * \brief Returns the zero-based index of the given DirectedEdge,
      * after sorting in ascending order
      * by angle with the positive x-axis.
      */
-    int getIndex(const DirectedEdge* dirEdge);
+    int getIndex(const DirectedEdge* dirEdge) const;
 
     /**
      * \brief Returns the remainder when i is divided by the number of
@@ -137,7 +137,7 @@ public:
      * of the given DirectedEdge (which must be a member of this
      * DirectedEdgeStar).
      */
-    DirectedEdge* getNextEdge(DirectedEdge* dirEdge);
+    DirectedEdge* getNextEdge(DirectedEdge* dirEdge) const;
 };
 
 } // namespace geos::planargraph

package/geos.xcframework/ios-arm64-simulator/Headers/geos/planargraph/Edge.h

@@ -19,6 +19,7 @@
 
 #include <geos/planargraph/GraphComponent.h> // for inheritance
 
+#include <array>
 #include <vector> // for typedefs
 #include <set> // for typedefs
 #include <iosfwd> // ostream
@@ -72,7 +73,7 @@ public:
 protected:
 
     /** \brief The two DirectedEdges associated with this Edge */
-    std::vector<DirectedEdge*> dirEdge;
+    std::array<DirectedEdge*, 2> dirEdge;
 
 public:
 

package/geos.xcframework/ios-arm64-simulator/Headers/geos/planargraph/Node.h

@@ -45,10 +45,10 @@ class GEOS_DLL Node: public GraphComponent {
 protected:
 
     /// The location of this Node
-    geom::Coordinate pt;
+    geom::CoordinateXY pt;
 
     /// The collection of DirectedEdges that leave this Node
-    DirectedEdgeStar* deStar;
+    DirectedEdgeStar deStar;
 
 public:
 
@@ -57,43 +57,23 @@ public:
     /** \brief
      * Returns all Edges that connect the two nodes (which are
      * assumed to be different).
-     *
-     * Note: returned vector is newly allocated, ownership to
-     * the caller.
      */
-    static std::vector<Edge*>* getEdgesBetween(Node* node0,
-            Node* node1);
+    static std::vector<Edge*> getEdgesBetween(const Node* node0,
+            const Node* node1);
 
     /// Constructs a Node with the given location.
-    Node(const geom::Coordinate& newPt)
+    explicit Node(const geom::CoordinateXY& newPt)
         :
         pt(newPt)
-    {
-        deStar = new DirectedEdgeStar();
-    }
-
-    ~Node() override
-    {
-        delete deStar;
-    }
-
-    /**
-     * \brief
-     * Constructs a Node with the given location and
-     * collection of outgoing DirectedEdges.
-     * Takes ownership of the given DirectedEdgeStar!!
-     */
-    Node(geom::Coordinate& newPt, DirectedEdgeStar* newDeStar)
-        :
-        pt(newPt),
-        deStar(newDeStar)
     {}
 
+    ~Node() override = default;
+
     /**
      * \brief Returns the location of this Node.
      */
-    geom::Coordinate&
-    getCoordinate()
+    const geom::CoordinateXY&
+    getCoordinate() const
     {
         return pt;
     }
@@ -104,7 +84,7 @@ public:
     void
     addOutEdge(DirectedEdge* de)
     {
-        deStar->add(de);
+        deStar.add(de);
     }
 
     /**
@@ -114,12 +94,13 @@ public:
     DirectedEdgeStar*
     getOutEdges()
     {
-        return deStar;
+        return &deStar;
     }
+
     const DirectedEdgeStar*
     getOutEdges() const
     {
-        return deStar;
+        return &deStar;
     }
 
     /**
@@ -128,7 +109,7 @@ public:
     size_t
     getDegree() const
     {
-        return deStar->getDegree();
+        return deStar.getDegree();
     }
 
     /**
@@ -139,7 +120,7 @@ public:
     int
     getIndex(Edge* edge)
     {
-        return deStar->getIndex(edge);
+        return deStar.getIndex(edge);
     }
 
 private:

package/geos.xcframework/ios-arm64-simulator/Headers/geos/planargraph/NodeMap.h

@@ -46,7 +46,7 @@ namespace planargraph { // geos.planargraph
  */
 class GEOS_DLL NodeMap {
 public:
-    typedef std::map<geom::Coordinate, Node*, geom::CoordinateLessThan> container;
+    typedef std::map<geom::CoordinateXY, Node*, geom::CoordinateLessThan> container;
 private:
     container nodeMap;
 public:
@@ -72,14 +72,14 @@ public:
      * Removes the Node at the given location, and returns it
      * (or null if no Node was there).
      */
-    Node* remove(geom::Coordinate& pt);
+    Node* remove(const geom::CoordinateXY& pt);
 
     /**
      * \brief
      * Returns the Node at the given location,
      * or null if no Node was there.
      */
-    Node* find(const geom::Coordinate& coord);
+    Node* find(const geom::CoordinateXY& coord);
 
     /**
      * \brief

package/geos.xcframework/ios-arm64-simulator/Headers/geos/planargraph/PlanarGraph.h

@@ -123,7 +123,7 @@ public:
      * or null if no Node was there.
      */
     Node*
-    findNode(const geom::Coordinate& pt)
+    findNode(const geom::CoordinateXY& pt)
     {
         return nodeMap.find(pt);
     }

package/geos.xcframework/ios-arm64-simulator/Headers/geos/precision/GeometryPrecisionReducer.h

@@ -68,9 +68,7 @@ private:
     bool useAreaReducer;
     bool isPointwise;
 
-    std::unique_ptr<geom::Geometry> fixPolygonalTopology(const geom::Geometry& geom);
-
-    geom::GeometryFactory::Ptr createFactory(
+    static geom::GeometryFactory::Ptr createFactory(
         const geom::GeometryFactory& oldGF,
         const geom::PrecisionModel& newPM);
 

package/geos.xcframework/ios-arm64-simulator/Headers/geos/precision/PointwisePrecisionReducerTransformer.h

@@ -44,7 +44,7 @@ private:
     const geom::PrecisionModel& targetPM;
 
     std::unique_ptr<geom::CoordinateSequence> reducePointwise(
-        const geom::CoordinateSequence* coordinates);
+        const geom::CoordinateSequence* coordinates) const;
 
 public:
 

package/geos.xcframework/ios-arm64-simulator/Headers/geos/precision/PrecisionReducerTransformer.h

@@ -50,9 +50,9 @@ private:
     const geom::PrecisionModel& targetPM;
     bool isRemoveCollapsed;
 
-    std::unique_ptr<geom::Geometry> reduceArea(const geom::Geometry* geom);
+    std::unique_ptr<geom::Geometry> reduceArea(const geom::Geometry* geom) const;
 
-    void extend(
+    static void extend(
         geom::CoordinateSequence& coords,
         std::size_t minLength);
 

package/geos.xcframework/ios-arm64-simulator/Headers/geos/shape/GeometricShapeBuilder.h

@@ -0,0 +1,83 @@
+/**********************************************************************
+*
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2016 Martin Davis
+ *
+ * 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.
+ *
+ **********************************************************************
+ *
+ * Last port: shape/GeometricShapeBuilder.java c2e8e1d069
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Envelope.h>
+#include <geos/geom/GeometryFactory.h>
+#include <geos/geom/LineSegment.h>
+
+#include <cstddef>
+#include <memory>
+
+namespace geos {
+namespace shape {
+
+class GEOS_DLL GeometricShapeBuilder {
+public:
+    GeometricShapeBuilder();
+    explicit GeometricShapeBuilder(const geom::GeometryFactory* gf);
+
+    virtual ~GeometricShapeBuilder() = default;
+
+    /**
+     * Sets the extent as an envelope.
+     *
+     * @param env the extent envelope
+     */
+    void setExtent(const geom::Envelope& env);
+
+    /**
+     * Gets the extent envelope.
+     *
+     * @return the extent envelope
+     */
+    const geom::Envelope& getExtent() const;
+
+    geom::CoordinateXY getCentre() const;
+
+    double getDiameter() const;
+
+    double getRadius() const;
+
+    geom::LineSegment getSquareBaseLine() const;
+
+    geom::Envelope getSquareExtent() const;
+
+    /**
+     * Sets the total number of points in the created {@link Geometry}.
+     * The created geometry will have no more than this number of points,
+     * unless more are needed to create a valid geometry.
+     */
+    void setNumPoints(std::size_t n);
+
+    virtual std::unique_ptr<geom::Geometry> getGeometry() = 0;
+
+protected:
+    geom::CoordinateXY createCoord(double x, double y) const;
+
+    const geom::GeometryFactory* geometryFactory;
+    geom::Envelope extent;
+    std::size_t numPts;
+};
+
+} // namespace shape
+} // namespace geos

package/geos.xcframework/ios-arm64-simulator/Headers/geos/shape/random/RandomPointsBuilder.h

@@ -0,0 +1,65 @@
+/**********************************************************************
+*
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2016 Martin Davis
+ *
+ * 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.
+ *
+ **********************************************************************
+ *
+ * Last port: shape/random/RandomPointsBuilder.java e92970e3c0
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/algorithm/locate/PointOnGeometryLocator.h>
+#include <geos/geom/Envelope.h>
+#include <geos/geom/Geometry.h>
+#include <geos/shape/GeometricShapeBuilder.h>
+
+#include <memory>
+#include <random>
+
+namespace geos::shape::random {
+
+ /**
+  * Creates random point sets contained in a
+  * region defined by either a rectangular or a polygonal extent.
+  *
+  * @author mbdavis
+  *
+  */
+class GEOS_DLL RandomPointsBuilder : public GeometricShapeBuilder {
+public:
+
+    explicit RandomPointsBuilder(const geom::GeometryFactory* gf);
+
+    using GeometricShapeBuilder::setExtent;
+
+    void setExtent(const geom::Geometry& mask);
+
+    std::unique_ptr<geom::Geometry> getGeometry() override;
+
+protected:
+
+    bool isInExtent(const geom::CoordinateXY& p) const;
+
+    geom::CoordinateXY createRandomCoord(const geom::Envelope& env);
+
+    std::unique_ptr<geom::Geometry> maskPoly;
+private:
+    std::unique_ptr<algorithm::locate::PointOnGeometryLocator> extentLocator;
+    std::random_device rd;
+    std::mt19937 rng;
+    std::uniform_real_distribution<double> dist{0, 1};
+};
+
+}

package/geos.xcframework/ios-arm64-simulator/Headers/geos/simplify/DouglasPeuckerSimplifier.h

@@ -68,7 +68,7 @@ public:
      */
     void setDistanceTolerance(double tolerance);
 
-    std::unique_ptr<geom::Geometry> getResultGeometry();
+    std::unique_ptr<geom::Geometry> getResultGeometry() const;
 
 
 private:

package/geos.xcframework/ios-arm64-simulator/Headers/geos/triangulate/polygon/PolygonHoleJoiner.h

@@ -74,8 +74,8 @@ private:
     const Polygon* inputPolygon;
 
     //-- normalized, sorted and noded polygon rings
-    std::unique_ptr<CoordinateSequence> shellRing;
-    std::vector<std::unique_ptr<CoordinateSequence>> holeRings;
+    std::shared_ptr<const CoordinateSequence> shellRing;
+    std::vector<std::shared_ptr<const CoordinateSequence>> holeRings;
 
     //-- indicates whether a hole should be testing for touching
     std::vector<bool> isHoleTouchingHint;
@@ -97,7 +97,7 @@ private:
 
 
     void extractOrientedRings(const Polygon* polygon);
-    static std::unique_ptr<CoordinateSequence> extractOrientedRing(const LinearRing* ring, bool isCW);
+    static std::shared_ptr<const CoordinateSequence> extractOrientedRing(const LinearRing* ring, bool isCW);
     void nodeRings();
     void joinHoles();
 

package/geos.xcframework/ios-arm64-simulator/Headers/geos/triangulate/polygon/PolygonNoder.h

@@ -66,8 +66,8 @@ class GEOS_DLL PolygonNoder {
 public:
 
     PolygonNoder(
-        std::unique_ptr<CoordinateSequence>& shellRing,
-        std::vector<std::unique_ptr<CoordinateSequence>>& holeRings);
+        const std::shared_ptr<const CoordinateSequence>& shellRing,
+        const std::vector<std::shared_ptr<const CoordinateSequence>>& holeRings);
 
     void node();
     bool isShellNoded();
@@ -91,11 +91,11 @@ private:
 
     // Methods
     NodedSegmentString*
-        createNodedSegString(std::unique_ptr<CoordinateSequence>& ringPts, std::size_t i);
+        createNodedSegString(const std::shared_ptr<const CoordinateSequence> &ringPts, std::size_t i);
 
     void createNodedSegmentStrings(
-        std::unique_ptr<CoordinateSequence>& shellRing,
-        std::vector<std::unique_ptr<CoordinateSequence>>& holeRings);
+        const std::shared_ptr<const CoordinateSequence> &shellRing,
+        const std::vector<std::shared_ptr<const CoordinateSequence>> &holeRings);
 
     /* Turn off copy constructors for MSVC */
     PolygonNoder(const PolygonNoder&) = delete;

package/geos.xcframework/ios-arm64-simulator/Headers/geos/triangulate/quadedge/TrianglePredicate.h

@@ -70,7 +70,7 @@ public:
      * Tests if a point is inside the circle defined by
      * the triangle with vertices a, b, c (oriented counter-clockwise).
      * This test uses simple
-     * double-precision arithmetic, and thus is not 10% robust.
+     * double-precision arithmetic, and thus is not 100% robust.
      * However, by using normalization to the origin
      * it provides improved robustness and increased performance.
      * <p>

package/geos.xcframework/ios-arm64-simulator/Headers/geos/util/Assert.h

@@ -39,6 +39,13 @@ public:
         isTrue(assertion, std::string());
     }
 
+    template<typename T>
+    static void
+    isNotNull(const T& ptr, const std::string& message)
+    {
+        isTrue(ptr != nullptr, message);
+    }
+
 
     static void equals(const geom::CoordinateXY& expectedValue,
                        const geom::CoordinateXY& actualValue,