@crossbind/port-geos-ios 2.0.0-beta.50

package/geos.xcframework/ios-arm64/Headers/geos/geomgraph/EdgeEnd.h

@@ -0,0 +1,187 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ *
+ * 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: geomgraph/EdgeEnd.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>  // for p0,p1
+#include <geos/geomgraph/Label.h>  // for composition
+
+#include <string>
+
+// Forward declarations
+namespace geos {
+namespace algorithm {
+class BoundaryNodeRule;
+}
+namespace geomgraph {
+class Edge;
+class Node;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/** \brief
+ * Models the end of an edge incident on a node.
+ *
+ * EdgeEnds have a direction
+ * determined by the direction of the ray from the initial
+ * point to the next point.
+ * EdgeEnds are comparable under the ordering
+ * "a has a greater angle with the x-axis than b".
+ * This ordering is used to sort EdgeEnds around a node.
+ */
+class GEOS_DLL EdgeEnd /* non-final */ {
+
+public:
+
+    friend std::ostream& operator<< (std::ostream&, const EdgeEnd&);
+
+    EdgeEnd();
+
+    virtual
+    ~EdgeEnd() {}
+
+    /**
+     * NOTES:
+     *  - Copies the given Label
+     *  - keeps a pointer to given Edge, make sure it's
+     *    not deleted before the EdgeEnd.
+     *  - copies given Coordinates (maybe we should avoid that)
+     */
+    EdgeEnd(Edge* newEdge, const geom::Coordinate& newP0,
+            const geom::Coordinate& newP1,
+            const Label& newLabel);
+
+    /**
+     * NOTES:
+     *  - keeps a pointer to given Edge, make sure it's
+     *    not deleted before the EdgeEnd.
+     *  - copies given Coordinates (maybe we should avoid that)
+     */
+    EdgeEnd(Edge* newEdge, const geom::Coordinate& newP0,
+            const geom::Coordinate& newP1);
+
+    Edge*
+    getEdge()
+    {
+        return edge;
+    }
+    //virtual Edge* getEdge() { return edge; }
+
+    Label&
+    getLabel()
+    {
+        return label;
+    }
+
+    const Label&
+    getLabel() const
+    {
+        return label;
+    }
+
+    geom::Coordinate& getCoordinate() {
+        return p0;
+    }
+
+    const geom::Coordinate&
+    getCoordinate() const
+    {
+        return p0;
+    }
+
+    geom::Coordinate& getDirectedCoordinate();
+
+    int getQuadrant();
+
+    double getDx();
+
+    double getDy();
+
+    void setNode(Node* newNode);
+
+    Node* getNode();
+
+    int compareTo(const EdgeEnd* e) const;
+
+    /**
+     * Implements the total order relation:
+     *
+     *    a has a greater angle with the positive x-axis than b
+     *
+     * Using the obvious algorithm of simply computing the angle
+     * is not robust, since the angle calculation is obviously
+     * susceptible to roundoff.
+     * A robust algorithm is:
+     * - first compare the quadrant.  If the quadrants
+     *   are different, it it trivial to determine which vector
+     *   is "greater".
+     * - if the vectors lie in the same quadrant, the
+     *   computeOrientation function can be used to decide
+     *   the relative orientation of the vectors.
+     */
+    int compareDirection(const EdgeEnd* e) const;
+
+    virtual void computeLabel(const algorithm::BoundaryNodeRule& bnr);
+
+    virtual std::string print() const;
+
+protected:
+
+    Edge* edge;// the parent edge of this edge end
+
+    Label label;
+
+    EdgeEnd(Edge* newEdge);
+
+    void init(const geom::Coordinate& newP0,
+                      const geom::Coordinate& newP1);
+
+private:
+
+    /// the node this edge end originates at
+    Node* node;
+
+    /// points of initial line segment. FIXME: do we need a copy here ?
+    geom::Coordinate p0, p1;
+
+    /// the direction vector for this edge from its starting point
+    double dx, dy;
+
+    int quadrant;
+};
+
+std::ostream& operator<< (std::ostream&, const EdgeEnd&);
+
+struct GEOS_DLL  EdgeEndLT {
+    bool
+    operator()(const EdgeEnd* s1, const EdgeEnd* s2) const
+    {
+        return s1->compareTo(s2) < 0;
+    }
+};
+
+} // namespace geos.geomgraph
+} // namespace geos
+

package/geos.xcframework/ios-arm64/Headers/geos/geomgraph/EdgeEndStar.h

@@ -0,0 +1,217 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ *
+ * 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: geomgraph/EdgeEndStar.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geomgraph/EdgeEnd.h>  // for EdgeEndLT
+#include <geos/geom/Location.h>
+#include <geos/geom/Coordinate.h>  // for p0,p1
+
+#include <array>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+#include <algorithm> // for inlines (find)
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
+#endif
+
+// Forward declarations
+namespace geos {
+namespace algorithm {
+class BoundaryNodeRule;
+}
+namespace geomgraph {
+class GeometryGraph;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+
+/** \brief
+ * A EdgeEndStar is an ordered list of EdgeEnds around a node.
+ *
+ * They are maintained in CCW order (starting with the positive x-axis)
+ * around the node for efficient lookup and topology building.
+ *
+ * @version 1.4
+ */
+class GEOS_DLL EdgeEndStar /* non-final */ {
+public:
+
+    typedef std::set<EdgeEnd*, EdgeEndLT> container;
+
+    typedef container::iterator iterator;
+    typedef container::const_iterator const_iterator;
+    typedef container::reverse_iterator reverse_iterator;
+
+    EdgeEndStar();
+
+    virtual
+    ~EdgeEndStar() {}
+
+    /** \brief
+     * Insert a EdgeEnd into this EdgeEndStar
+     */
+    virtual void insert(EdgeEnd* e) = 0;
+
+    /**
+     * @return the coordinate for the node this star is based at
+     *         or NULL if this is still an unbound star.
+     * Be aware that the returned pointer will point to
+     * a Coordinate owned by the specific EdgeEnd happening
+     * to be the first in the star (ordered CCW)
+     */
+    geom::Coordinate& getCoordinate();
+
+    const geom::Coordinate& getCoordinate() const;
+
+    std::size_t getDegree();
+
+    iterator begin();
+
+    iterator end();
+
+    reverse_iterator rbegin();
+
+    reverse_iterator rend();
+
+    const_iterator
+    begin() const
+    {
+        return edgeMap.begin();
+    }
+
+    const_iterator
+    end() const
+    {
+        return edgeMap.end();
+    }
+
+    container& getEdges();
+
+    EdgeEnd* getNextCW(EdgeEnd* ee);
+
+    virtual void computeLabelling(const std::vector<std::unique_ptr<GeometryGraph>>&geomGraph);
+    // throw(TopologyException *);
+
+    bool isAreaLabelsConsistent(const GeometryGraph& geomGraph);
+
+    void propagateSideLabels(uint32_t geomIndex);
+    // throw(TopologyException *);
+
+    //virtual int findIndex(EdgeEnd *eSearch);
+    iterator find(EdgeEnd* eSearch);
+
+    virtual std::string print() const;
+
+protected:
+
+    /** \brief
+     * A map which maintains the edges in sorted order
+     * around the node
+     */
+    EdgeEndStar::container edgeMap;
+
+    /** \brief
+     * Insert an EdgeEnd into the map.
+     */
+    void
+    insertEdgeEnd(EdgeEnd* e)
+    {
+        edgeMap.insert(e);
+    }
+
+private:
+
+    geom::Location getLocation(uint32_t geomIndex,
+                                       const geom::Coordinate&p,
+                                       const std::vector<std::unique_ptr<GeometryGraph>>&geom);
+
+    /** \brief
+     * The location of the point for this star in
+     * Geometry i Areas
+     */
+    std::array<geom::Location, 2> ptInAreaLocation;
+
+    void computeEdgeEndLabels(const algorithm::BoundaryNodeRule&);
+
+    bool checkAreaLabelsConsistent(uint32_t geomIndex);
+
+};
+
+inline std::size_t
+EdgeEndStar::getDegree()
+{
+    return edgeMap.size();
+}
+
+inline EdgeEndStar::iterator
+EdgeEndStar::begin()
+{
+    return edgeMap.begin();
+}
+
+inline EdgeEndStar::container&
+EdgeEndStar::getEdges()
+{
+    return edgeMap;
+}
+
+inline EdgeEndStar::reverse_iterator
+EdgeEndStar::rend()
+{
+    return edgeMap.rend();
+}
+
+inline EdgeEndStar::iterator
+EdgeEndStar::end()
+{
+    return edgeMap.end();
+}
+
+inline EdgeEndStar::reverse_iterator
+EdgeEndStar::rbegin()
+{
+    return edgeMap.rbegin();
+}
+
+inline EdgeEndStar::iterator
+EdgeEndStar::find(EdgeEnd* eSearch)
+{
+    return edgeMap.find(eSearch);
+}
+
+std::ostream& operator<< (std::ostream&, const EdgeEndStar&);
+
+} // namespace geos.geomgraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/geos.xcframework/ios-arm64/Headers/geos/geomgraph/EdgeIntersection.h

@@ -0,0 +1,149 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2009-2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ *
+ * 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: geomgraph/EdgeIntersection.java rev. 1.5 (JTS-1.10)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geom/Coordinate.h> // for composition and inlines
+
+#include <ostream>
+
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/** \brief
+ * Represents a point on an edge which intersects with another edge.
+ *
+ * The intersection may either be a single point, or a line segment
+ * (in which case this point is the start of the line segment)
+ * The intersection point must be precise.
+ *
+ */
+class GEOS_DLL EdgeIntersection final {
+public:
+
+    // the point of intersection
+    geom::Coordinate coord;
+
+    // the edge distance of this point along the containing line segment
+    double dist;
+
+    // the index of the containing line segment in the parent edge
+    std::size_t segmentIndex;
+
+    EdgeIntersection(const geom::Coordinate& newCoord,
+                     std::size_t newSegmentIndex, double newDist)
+        :
+        coord(newCoord),
+        dist(newDist),
+        segmentIndex(newSegmentIndex)
+    {}
+
+    bool
+    isEndPoint(std::size_t maxSegmentIndex) const
+    {
+        if(segmentIndex == 0 && dist == 0.0) {
+            return true;
+        }
+        if(segmentIndex == maxSegmentIndex) {
+            return true;
+        }
+        return false;
+    }
+
+    const geom::Coordinate&
+    getCoordinate() const
+    {
+        return coord;
+    }
+
+    size_t
+    getSegmentIndex() const
+    {
+        return segmentIndex;
+    }
+
+    double
+    getDistance() const
+    {
+        return dist;
+    }
+
+    bool operator==(const EdgeIntersection& other) const {
+        return segmentIndex == other.segmentIndex &&
+            dist == other.dist;
+
+        // We don't check the coordinate, consistent with operator<
+    }
+
+};
+
+/// Strict weak ordering operator for EdgeIntersection
+///
+/// This is the C++ equivalent of JTS's compareTo
+inline bool
+operator< (const EdgeIntersection& ei1, const EdgeIntersection& ei2)
+{
+    if(ei1.segmentIndex < ei2.segmentIndex) {
+        return true;
+    }
+    if(ei1.segmentIndex == ei2.segmentIndex) {
+        if(ei1.dist < ei2.dist) {
+            return true;
+        }
+
+        // TODO: check if the Coordinate matches, or this will
+        //       be a robustness issue in computing distance
+        //       See http://trac.osgeo.org/geos/ticket/350
+    }
+    return false;
+}
+
+// @deprecated, use strict weak ordering operator
+struct GEOS_DLL  EdgeIntersectionLessThen {
+    bool
+    operator()(const EdgeIntersection* ei1,
+               const EdgeIntersection* ei2) const
+    {
+        return *ei1 < *ei2;
+    }
+
+    bool
+    operator()(const EdgeIntersection& ei1,
+               const EdgeIntersection& ei2) const
+    {
+        return ei1 < ei2;
+    }
+};
+
+/// Output operator
+inline std::ostream&
+operator<< (std::ostream& os, const EdgeIntersection& e)
+{
+    os << e.coord << " seg # = " << e.segmentIndex << " dist = " << e.dist;
+    return os;
+}
+
+} // namespace geos.geomgraph
+} // namespace geos
+

package/geos.xcframework/ios-arm64/Headers/geos/geomgraph/EdgeIntersectionList.h

@@ -0,0 +1,129 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ *
+ * 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: geomgraph/EdgeIntersectionList.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <algorithm>
+#include <vector>
+#include <string>
+
+#include <geos/geomgraph/EdgeIntersection.h> // for EdgeIntersectionLessThen
+#include <geos/geom/Coordinate.h> // for CoordinateLessThan
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
+#endif
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+namespace geomgraph {
+class Edge;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+
+/** \brief
+ * A list of edge intersections along an Edge.
+ *
+ * Implements splitting an edge with intersections
+ * into multiple resultant edges.
+ */
+class GEOS_DLL EdgeIntersectionList final {
+public:
+    // Instead of storing edge intersections in a set, as JTS does, we store them
+    // in a vector and then sort the vector if needed before iterating among the
+    // edges. This is much faster.
+    using container = std::vector<EdgeIntersection>;
+    using const_iterator = container::const_iterator;
+
+private:
+    mutable container nodeMap;
+    mutable bool sorted;
+
+public:
+
+    const Edge* edge;
+    EdgeIntersectionList(const Edge* edge);
+    ~EdgeIntersectionList() = default;
+
+    /*
+     * Adds an intersection into the list, if it isn't already there.
+     * The input segmentIndex and dist are expected to be normalized.
+     * @return the EdgeIntersection found or added
+     */
+    void add(const geom::Coordinate& coord, std::size_t segmentIndex, double dist);
+
+    const_iterator
+    begin() const
+    {
+        if (!sorted) {
+            std::sort(nodeMap.begin(), nodeMap.end());
+            nodeMap.erase(std::unique(nodeMap.begin(), nodeMap.end()), nodeMap.end());
+            sorted = true;
+        }
+
+        return nodeMap.begin();
+    }
+    const_iterator
+    end() const
+    {
+        return nodeMap.end();
+    }
+
+    bool isEmpty() const;
+    bool isIntersection(const geom::Coordinate& pt) const;
+
+    /*
+     * Adds entries for the first and last points of the edge to the list
+     */
+    void addEndpoints();
+
+    /**
+     * Creates new edges for all the edges that the intersections in this
+     * list split the parent edge into.
+     * Adds the edges to the input list (this is so a single list
+     * can be used to accumulate all split edges for a Geometry).
+     *
+     * @param edgeList a list of EdgeIntersections
+     */
+    void addSplitEdges(std::vector<Edge*>* edgeList);
+
+    Edge* createSplitEdge(const EdgeIntersection* ei0, const EdgeIntersection* ei1);
+    std::string print() const;
+};
+
+std::ostream& operator<< (std::ostream&, const EdgeIntersectionList&);
+
+} // namespace geos.geomgraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+