@crossbind/port-geos-linuxmusl 0.0.0-stage → 2.0.0-beta.64

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/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::shared_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<std::unique_ptr<SegmentString>>& edgeList);
+
+    void
+    addSplitEdges(std::vector<std::unique_ptr<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/linuxmusl-arm64-mt-release/include/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::CoordinateXY& p0,
+            const geom::CoordinateXY& 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/linuxmusl-arm64-mt-release/include/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 GEOS_DLL 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
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/noding/SegmentString.h

@@ -0,0 +1,185 @@
+/**********************************************************************
+ *
+ * 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: noding/SegmentString.java r430 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+#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>
+
+// Forward declarations
+namespace geos {
+namespace algorithm {
+class LineIntersector;
+}
+}
+
+namespace geos {
+namespace noding { // geos.noding
+
+/** \brief
+ * An interface for classes which represent a sequence of contiguous
+ * line segments.
+ *
+ * SegmentStrings can carry a context object, which is useful
+ * for preserving topological or parentage information.
+ */
+class GEOS_DLL SegmentString : public PathString {
+public:
+    typedef std::vector<const SegmentString*> ConstVect;
+    typedef std::vector<SegmentString*> NonConstVect;
+
+    friend std::ostream& operator<< (std::ostream& os,
+                                     const SegmentString& ss);
+
+    /// \brief Construct a SegmentString.
+    ///
+    /// @param newContext the context associated to this SegmentString
+    /// @param newSeq coordinates of this SegmentString
+    ///
+    SegmentString(const void* newContext, const std::shared_ptr<const geom::CoordinateSequence>& newSeq)
+        : PathString(newContext),
+        seq(newSeq)
+    {}
+
+    ~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.
+    const std::shared_ptr<const geom::CoordinateSequence>& getCoordinates() const override {
+        return seq;
+    }
+
+    void setCoordinates(const std::shared_ptr<const geom::CoordinateSequence>& newSeq) {
+        seq = newSeq;
+    }
+
+    /** \brief
+     * Gets the octant of the segment starting at vertex index.
+     *
+     * @param index the index of the vertex starting the segment.
+     *              Must not be the last index in the vertex list
+     * @return the octant of the segment at the vertex
+     */
+    int getSegmentOctant(std::size_t index) const
+    {
+        if (index >= size() - 1) {
+            return -1;
+        }
+        return safeOctant(seq->getAt<geom::CoordinateXY>(index),
+                          seq->getAt<geom::CoordinateXY>(index + 1));
+    };
+
+    static int getSegmentOctant(const SegmentString& ss, std::size_t index) {
+        return ss.getSegmentOctant(index);
+    }
+
+    /**
+     * Gets the next vertex in a ring from a vertex index.
+     *
+     * @param index the vertex index
+     * @return the next vertex in the ring
+     *
+     * @see isClosed
+     */
+    const geom::CoordinateXY& nextInRing(std::size_t index) const
+    {
+        std::size_t nextIndex = index + 1;
+        if (nextIndex > size() - 1) {
+            nextIndex = 1;
+        }
+        return getCoordinate(nextIndex);
+    }
+
+    /**
+     * Gets the previous vertex in a ring from a vertex index.
+     *
+     * @param index the vertex index
+     * @return the previous vertex in the ring
+     *
+     * @see isClosed
+     */
+    const geom::CoordinateXY& prevInRing(std::size_t index) const
+    {
+        std::size_t prevIndex;
+        if (index == 0)
+            prevIndex = size() - 2;
+        else
+            prevIndex = index - 1;
+        return getCoordinate( prevIndex );
+    }
+
+
+    bool isClosed() const {
+        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:
+    std::shared_ptr<const geom::CoordinateSequence> seq;
+
+private:
+    static int safeOctant(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1)
+    {
+        if(p0.equals2D(p1)) {
+            return 0;
+        }
+        return Octant::octant(p0, p1);
+    };
+
+    // Declare type as noncopyable
+    SegmentString(const SegmentString& other) = delete;
+    SegmentString& operator=(const SegmentString& rhs) = delete;
+};
+
+std::ostream& operator<< (std::ostream& os, const SegmentString& ss);
+
+} // namespace geos.noding
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/noding/SegmentStringUtil.h

@@ -0,0 +1,67 @@
+/**********************************************************************
+ *
+ * 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/SegmentStringUtil.java rev. 1.2 (JTS-1.9)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/noding/BasicSegmentString.h>
+#include <geos/noding/NodedSegmentString.h>
+#include <geos/geom/LineString.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/util/LinearComponentExtracter.h>
+
+namespace geos {
+namespace noding { // geos::noding
+
+/** \brief
+ * Utility methods for processing {@link SegmentString}s.
+ *
+ * @author Martin Davis
+ *
+ */
+class SegmentStringUtil {
+public:
+    /** \brief
+     * Extracts all linear components from a given [Geometry](@ref geom::Geometry)
+     * to [SegmentStrings](@ref SegmentString)
+     *
+     * The SegmentString data item is set to be the source Geometry.
+     *
+     * @param g the geometry to extract from
+     * @param segStr a List of SegmentStrings (output parameter).
+     *               Ownership of elements pushed to the vector
+     *               is transferred to caller.
+     */
+    static void
+    extractSegmentStrings(const geom::Geometry* g,
+                          SegmentString::ConstVect& segStr)
+    {
+        geom::LineString::ConstVect lines;
+        geom::util::LinearComponentExtracter::getLines(*g, lines);
+
+        for(const geom::LineString* line : lines) {
+            const auto& pts = line->getSharedCoordinates();
+            segStr.push_back(new BasicSegmentString(pts, g));
+        }
+    }
+
+};
+
+} // geos::noding
+} // geos
+