@cpp.js/package-geos 1.0.0-beta.20

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/noding/SegmentNode.h

@@ -0,0 +1,161 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2006      Refractions Research 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: noding/SegmentNode.java 4667170ea (JTS-1.17)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/noding/SegmentPointComparator.h>
+#include <geos/noding/SegmentString.h>
+
+#include <vector>
+#include <iostream>
+
+namespace geos {
+namespace noding { // geos.noding
+
+/**
+ * \brief
+ * Represents an intersection point between two NodedSegmentString.
+ *
+ * Final class.
+ */
+class GEOS_DLL SegmentNode {
+private:
+    int segmentOctant;
+
+    bool isInteriorVar;
+
+public:
+    friend std::ostream& operator<< (std::ostream& os, const SegmentNode& n);
+
+    /// the point of intersection (own copy)
+    geom::CoordinateXYZM coord;
+
+    /// the index of the containing line segment in the parent edge
+    std::size_t segmentIndex;
+
+    /// Construct a node on the given NodedSegmentString
+    ///
+    /// @param ss the parent NodedSegmentString
+    ///
+    /// @param nCoord the coordinate of the intersection, will be copied
+    ///
+    /// @param nSegmentIndex the index of the segment on parent
+    ///                      NodedSegmentString
+    ///        where the Node is located.
+    ///
+    /// @param nSegmentOctant
+    ///
+    template<typename CoordType>
+    SegmentNode(const SegmentString& ss,
+        const CoordType& nCoord,
+        std::size_t nSegmentIndex, int nSegmentOctant)
+        : segmentOctant(nSegmentOctant)
+        , coord(nCoord)
+        , segmentIndex(nSegmentIndex)
+    {
+        // Number of points in NodedSegmentString is one-more number of segments
+        assert(segmentIndex < ss.size());
+        isInteriorVar = !coord.equals2D(ss.getCoordinate(segmentIndex));
+    }
+
+    ~SegmentNode() {}
+
+    /// \brief
+    /// Return true if this Node is *internal* (not on the boundary)
+    /// of the corresponding segment. Currently only the *first*
+    /// segment endpoint is checked, actually.
+    ///
+    bool
+    isInterior() const
+    {
+        return isInteriorVar;
+    }
+
+    bool isEndPoint(unsigned int maxSegmentIndex) const
+    {
+        if(segmentIndex == 0 && ! isInteriorVar) {
+            return true;
+        }
+        if(segmentIndex == maxSegmentIndex) {
+            return true;
+        }
+        return false;
+    };
+
+    /**
+     * @return -1 this EdgeIntersection is located before
+     *            the argument location
+     * @return 0 this EdgeIntersection is at the argument location
+     * @return 1 this EdgeIntersection is located after the
+     *           argument location
+     */
+    int compareTo(const SegmentNode& other) const
+    {
+        if (segmentIndex < other.segmentIndex) {
+            return -1;
+        }
+        if (segmentIndex > other.segmentIndex) {
+            return 1;
+        }
+
+        if (coord.equals2D(other.coord)) {
+
+            return 0;
+        }
+
+        // an exterior node is the segment start point,
+        // so always sorts first
+        // this guards against a robustness problem
+        // where the octants are not reliable
+        if (!isInteriorVar) return -1;
+        if (!other.isInteriorVar) return 1;
+
+        return SegmentPointComparator::compare(
+            segmentOctant, coord,
+            other.coord);
+    };
+
+};
+
+// std::ostream& operator<< (std::ostream& os, const SegmentNode& n);
+
+struct GEOS_DLL SegmentNodeLT {
+    bool
+    operator()(SegmentNode* s1, SegmentNode* s2) const
+    {
+        return s1->compareTo(*s2) < 0;
+    }
+
+    bool
+    operator()(const SegmentNode& s1, const SegmentNode& s2) const
+    {
+        return s1.compareTo(s2) < 0;
+    }
+};
+
+
+} // namespace geos.noding
+} // namespace geos
+
+
+
+
+
+

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/noding/SegmentNodeList.h

@@ -0,0 +1,253 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2006      Refractions Research 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: noding/SegmentNodeList.java rev. 1.8 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <cassert>
+#include <iostream>
+#include <vector>
+#include <set>
+#include <memory>
+
+#include <geos/noding/SegmentNode.h> // for composition
+
+#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 CoordinateSequence;
+}
+namespace noding {
+class SegmentString;
+class NodedSegmentString;
+}
+}
+
+namespace geos {
+namespace noding { // geos::noding
+
+/** \brief
+ * A list of the SegmentNode present along a
+ * NodedSegmentString.
+ */
+class GEOS_DLL SegmentNodeList {
+private:
+    // Since we are adding frequently to the SegmentNodeList and
+    // iterating infrequently, it is faster to store all the
+    // SegmentNodes in a vector and sort/remove duplicates
+    // before iteration, rather than storing them in a set
+    // and continuously maintaining a sorted order.
+    mutable std::vector<SegmentNode> nodeMap;
+    mutable bool ready = false;
+
+    bool constructZ;
+    bool constructM;
+
+    void prepare() const;
+
+    // the parent edge
+    const NodedSegmentString& edge;
+
+    /**
+     * Checks the correctness of the set of split edges corresponding
+     * to this edge
+     *
+     * @param splitEdges the split edges for this edge (in order)
+     */
+    void checkSplitEdgesCorrectness(const std::vector<SegmentString*>& splitEdges) const;
+
+    /**
+     * Create a new "split edge" with the section of points between
+     * (and including) the two intersections.
+     * The label for the new edge is the same as the label for the
+     * parent edge.
+     *
+     * ownership of return value is transferred
+     */
+    std::unique_ptr<SegmentString> createSplitEdge(const SegmentNode* ei0, const SegmentNode* ei1) const;
+
+    /**
+    * Extracts the points for a split edge running between two nodes.
+    * The extracted points should contain no duplicate points.
+    * There should always be at least two points extracted
+    * (which will be the given nodes).
+    *
+    * @param ei0 the start node of the split edge
+    * @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;
+
+    /**
+     * Adds nodes for any collapsed edge pairs.
+     * Collapsed edge pairs can be caused by inserted nodes, or they
+     * can be pre-existing in the edge vertex list.
+     * In order to provide the correct fully noded semantics,
+     * the vertex at the base of a collapsed pair must also be added
+     * as a node.
+     */
+    void addCollapsedNodes();
+
+    /**
+ /    * Adds nodes for any collapsed edge pairs
+     * which are pre-existing in the vertex list.
+     */
+    void findCollapsesFromExistingVertices(
+        std::vector<std::size_t>& collapsedVertexIndexes) const;
+
+    /**
+     * Adds nodes for any collapsed edge pairs caused by inserted nodes
+     * Collapsed edge pairs occur when the same coordinate is inserted
+     * as a node both before and after an existing edge vertex.
+     * To provide the correct fully noded semantics,
+     * the vertex must be added as a node as well.
+     */
+    void findCollapsesFromInsertedNodes(
+        std::vector<std::size_t>& collapsedVertexIndexes) const;
+
+    static bool findCollapseIndex(const SegmentNode& ei0, const SegmentNode& ei1,
+                           size_t& collapsedVertexIndex);
+
+    void addEdgeCoordinates(const SegmentNode* ei0, const SegmentNode* ei1, geom::CoordinateSequence& coordList) const;
+
+public:
+
+    // Declare type as noncopyable
+    SegmentNodeList(const SegmentNodeList& other) = delete;
+    SegmentNodeList& operator=(const SegmentNodeList& rhs) = delete;
+
+    friend std::ostream& operator<< (std::ostream& os, const SegmentNodeList& l);
+
+    using container = decltype(nodeMap);
+    using iterator = container::iterator;
+    using const_iterator = container::const_iterator;
+
+    explicit SegmentNodeList(const NodedSegmentString& newEdge,
+                             bool p_constructZ,
+                             bool p_constructM)
+        : constructZ(p_constructZ)
+        , constructM(p_constructM)
+        , edge(newEdge) {}
+
+    ~SegmentNodeList() = default;
+
+    const NodedSegmentString&
+    getEdge() const
+    {
+        return edge;
+    }
+
+    bool getConstructZ() const {
+        return constructZ;
+    }
+
+    bool getConstructM() const {
+        return constructM;
+    }
+
+    /**
+     * Adds an intersection into the list, if it isn't already there.
+     * The input segmentIndex is expected to be normalized.
+     *
+     * @param intPt the intersection Coordinate, will be copied
+     * @param segmentIndex
+     */
+    template<typename CoordType>
+    void add(const CoordType& intPt, std::size_t segmentIndex) {
+        // Cast edge to SegmentString to avoid circular dependency between NodedSegmentString and SegmentNodeList
+        nodeMap.emplace_back(edge, intPt, segmentIndex, reinterpret_cast<const SegmentString&>(edge).getSegmentOctant(segmentIndex));
+        ready = false;
+    }
+
+    /// Return the number of nodes in this list
+    size_t
+    size() const
+    {
+        prepare();
+        return nodeMap.size();
+    }
+
+    iterator begin() {
+        prepare();
+        return nodeMap.begin();
+    }
+
+    const_iterator begin() const {
+        prepare();
+        return nodeMap.begin();
+    }
+
+    iterator end() {
+        prepare();
+        return nodeMap.end();
+    }
+
+    const_iterator end() const {
+        prepare();
+        return nodeMap.end();
+    }
+
+    /**
+     * 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).
+     */
+    void addSplitEdges(std::vector<SegmentString*>& edgeList);
+
+    void
+    addSplitEdges(std::vector<SegmentString*>* edgeList)
+    {
+        assert(edgeList);
+        addSplitEdges(*edgeList);
+    }
+
+    /**
+    * Gets the list of coordinates for the fully noded segment string,
+    * including all original segment string vertices and vertices
+    * introduced by nodes in this list.
+    * Repeated coordinates are collapsed.
+    *
+    * @return an array of Coordinates
+    *
+    */
+    std::unique_ptr<geom::CoordinateSequence> getSplitCoordinates();
+
+
+};
+
+std::ostream& operator<< (std::ostream& os, const SegmentNodeList& l);
+
+} // namespace geos::noding
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/noding/SegmentPointComparator.h

@@ -0,0 +1,120 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2006      Refractions Research 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: noding/SegmentPointComparator.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+#include <cassert>
+
+namespace geos {
+namespace noding { // geos.noding
+
+/** \brief
+ * Implements a robust method of comparing the relative position of two
+ * points along the same segment.
+ *
+ * The coordinates are assumed to lie "near" the segment.
+ * This means that this algorithm will only return correct results
+ * if the input coordinates
+ * have the same precision and correspond to rounded values
+ * of exact coordinates lying on the segment.
+ *
+ */
+class GEOS_DLL SegmentPointComparator {
+
+public:
+
+    /** \brief
+     * Compares two Coordinates for their relative position along a
+     * segment lying in the specified Octant.
+     *
+     * @return -1 node0 occurs first
+     * @return 0 the two nodes are equal
+     * @return 1 node1 occurs first
+     */
+    static int
+    compare(int octant, const geom::Coordinate& p0,
+            const geom::Coordinate& p1)
+    {
+        // nodes can only be equal if their coordinates are equal
+        if(p0.equals2D(p1)) {
+            return 0;
+        }
+
+        int xSign = relativeSign(p0.x, p1.x);
+        int ySign = relativeSign(p0.y, p1.y);
+
+        switch(octant) {
+        case 0:
+            return compareValue(xSign, ySign);
+        case 1:
+            return compareValue(ySign, xSign);
+        case 2:
+            return compareValue(ySign, -xSign);
+        case 3:
+            return compareValue(-xSign, ySign);
+        case 4:
+            return compareValue(-xSign, -ySign);
+        case 5:
+            return compareValue(-ySign, -xSign);
+        case 6:
+            return compareValue(-ySign, xSign);
+        case 7:
+            return compareValue(xSign, -ySign);
+        }
+        assert(0); // invalid octant value
+        return 0;
+
+    }
+
+    static int
+    relativeSign(double x0, double x1)
+    {
+        if(x0 < x1) {
+            return -1;
+        }
+        if(x0 > x1) {
+            return 1;
+        }
+        return 0;
+    }
+
+    static int
+    compareValue(int compareSign0, int compareSign1)
+    {
+        if(compareSign0 < 0) {
+            return -1;
+        }
+        if(compareSign0 > 0) {
+            return 1;
+        }
+        if(compareSign1 < 0) {
+            return -1;
+        }
+        if(compareSign1 > 0) {
+            return 1;
+        }
+        return 0;
+    }
+
+};
+
+} // namespace geos.noding
+} // namespace geos
+

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/noding/SegmentSetMutualIntersector.h

@@ -0,0 +1,80 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2006 Refractions Research 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.
+ *
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/noding/SegmentString.h>
+#include <geos/noding/SegmentIntersector.h>
+
+namespace geos {
+namespace noding { // geos::noding
+
+/** \brief
+ * An intersector for the red-blue intersection problem.
+ *
+ * In this class of line arrangement problem,
+ * two disjoint sets of linestrings are provided.
+ * It is assumed that within
+ * each set, no two linestrings intersect except possibly at their endpoints.
+ * Implementations can take advantage of this fact to optimize processing.
+ *
+ * @author Martin Davis
+ * @version 1.10
+ */
+class SegmentSetMutualIntersector {
+public:
+
+    SegmentSetMutualIntersector()
+        : segInt(nullptr)
+    {}
+
+    virtual
+    ~SegmentSetMutualIntersector() {}
+
+    /**
+     * Sets the SegmentIntersector to use with this intersector.
+     * The SegmentIntersector will either record or add intersection nodes
+     * for the input segment strings.
+     *
+     * @param si the segment intersector to use
+     */
+    void
+    setSegmentIntersector(SegmentIntersector* si)
+    {
+        segInt = si;
+    }
+
+    /**
+     *
+     * @param segStrings a collection of [SegmentStrings](@ref SegmentString) to node
+     */
+    virtual void setBaseSegments(SegmentString::ConstVect* segStrings) = 0;
+
+    /**
+     * Computes the intersections for two collections of [SegmentStrings](@ref SegmentString).
+     *
+     * @param segStrings a collection of [SegmentStrings](@ref SegmentString) to node
+     */
+    virtual void process(SegmentString::ConstVect* segStrings) = 0;
+
+protected:
+
+    SegmentIntersector* segInt;
+
+};
+
+} // geos::noding
+} // geos
+