@crossbind/port-geos-linuxmusl 0.0.0-bootstrap.0 → 2.0.0-beta.63

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

@@ -0,0 +1,146 @@
+/**********************************************************************
+ *
+ * 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/SegmentSetMutualIntersector.h> // inherited
+#include <geos/index/chain/MonotoneChainOverlapAction.h> // inherited
+#include <geos/index/chain/MonotoneChain.h> // inherited
+#include <geos/index/strtree/TemplateSTRtree.h> // inherited
+
+namespace geos {
+namespace geom {
+    class Envelope;
+}
+namespace index {
+    class SpatialIndex;
+}
+namespace noding {
+    class SegmentString;
+    class SegmentIntersector;
+}
+}
+
+//using namespace geos::index::strtree;
+
+namespace geos {
+namespace noding { // geos::noding
+
+/** \brief
+ * Intersects two sets of [SegmentStrings](@ref SegmentString) using a index based
+ * on [MonotoneChains](@ref index::chain::MonotoneChain) and a
+ * [SpatialIndex](@ref index::SpatialIndex).
+ *
+ * @version 1.7
+ */
+class GEOS_DLL MCIndexSegmentSetMutualIntersector : public SegmentSetMutualIntersector {
+public:
+
+    MCIndexSegmentSetMutualIntersector(double p_tolerance)
+        : monoChains()
+        , indexCounter(0)
+        , processCounter(0)
+        , nOverlaps(0)
+        , overlapTolerance(p_tolerance)
+        , indexBuilt(false)
+        , envelope(nullptr)
+    {}
+
+    MCIndexSegmentSetMutualIntersector(const geom::Envelope* p_envelope)
+        : monoChains()
+        , indexCounter(0)
+        , processCounter(0)
+        , nOverlaps(0)
+        , overlapTolerance(0.0)
+        , indexBuilt(false)
+        , envelope(p_envelope)
+    {}
+
+    MCIndexSegmentSetMutualIntersector()
+        : MCIndexSegmentSetMutualIntersector(0.0)
+    {}
+
+    ~MCIndexSegmentSetMutualIntersector() override
+    {};
+
+    index::SpatialIndex*
+    getIndex()
+    {
+        return &index;
+    }
+
+    void setBaseSegments(SegmentString::ConstVect* segStrings) override;
+
+    // NOTE: re-populates the MonotoneChain vector with newly created chains
+    void process(SegmentString::ConstVect* segStrings) override;
+
+    class SegmentOverlapAction : public index::chain::MonotoneChainOverlapAction {
+    private:
+        SegmentIntersector& si;
+
+        // Declare type as noncopyable
+        SegmentOverlapAction(const SegmentOverlapAction& other) = delete;
+        SegmentOverlapAction& operator=(const SegmentOverlapAction& rhs) = delete;
+
+    public:
+        SegmentOverlapAction(SegmentIntersector& p_si) :
+            index::chain::MonotoneChainOverlapAction(), si(p_si)
+        {}
+
+        void overlap(const index::chain::MonotoneChain& mc1, std::size_t start1,
+                     const index::chain::MonotoneChain& mc2, std::size_t start2) override;
+    };
+
+    /**
+     * Disable copy construction and assignment. Apparently needed to make this
+     * class compile under MSVC. (See https://stackoverflow.com/q/29565299)
+     */
+    MCIndexSegmentSetMutualIntersector(const MCIndexSegmentSetMutualIntersector&) = delete;
+    MCIndexSegmentSetMutualIntersector& operator=(const MCIndexSegmentSetMutualIntersector&) = delete;
+
+private:
+
+    typedef std::vector<index::chain::MonotoneChain> MonoChains;
+    MonoChains monoChains;
+
+    /*
+     * The index::SpatialIndex used should be something that supports
+     * envelope (range) queries efficiently (such as a index::quadtree::Quadtree
+     * or index::strtree::STRtree).
+     */
+    index::strtree::TemplateSTRtree<const index::chain::MonotoneChain*> index;
+    int indexCounter;
+    int processCounter;
+    // statistics
+    int nOverlaps;
+    double overlapTolerance;
+
+    /* memory management helper, holds MonotoneChain objects used
+     * in the SpatialIndex. It's cleared when the SpatialIndex is
+     */
+    bool indexBuilt;
+    MonoChains indexChains;
+    const geom::Envelope* envelope;
+
+    void addToIndex(SegmentString* segStr);
+
+    void intersectChains();
+
+    void addToMonoChains(SegmentString* segStr);
+
+};
+
+} // namespace geos::noding
+} // namespace geos
+

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

@@ -0,0 +1,44 @@
+/**********************************************************************
+*
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2025 ISciences, LLC
+ *
+ * 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/export.h>
+#include <geos/noding/ArcString.h>
+#include <geos/noding/NodablePath.h>
+
+namespace geos::noding {
+
+class GEOS_DLL NodableArcString : public ArcString, public NodablePath {
+
+public:
+    NodableArcString(std::vector<geom::CircularArc> arcs, const std::shared_ptr<const geom::CoordinateSequence>& coords, bool constructZ, bool constructM, const void* context);
+
+    std::unique_ptr<ArcString> clone() const;
+
+    using NodablePath::addIntersection;
+
+    void addIntersection(const geom::CoordinateXYZM& intPt, size_t segmentIndex) override {
+        m_adds[segmentIndex].push_back(intPt);
+    }
+
+    void getNoded(std::vector<std::unique_ptr<ArcString>>& splitArcs);
+
+private:
+    std::map<size_t, std::vector<geom::CoordinateXYZM>> m_adds;
+    bool m_constructZ = false;
+    bool m_constructM = false;
+};
+
+}

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

@@ -0,0 +1,40 @@
+/**********************************************************************
+*
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2025 ISciences, LLC
+ *
+ * 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/export.h>
+#include <geos/geom/Coordinate.h>
+
+namespace geos::noding {
+
+/// A NodablePath represents a PathString to which coordinates can be added.
+class GEOS_DLL NodablePath {
+public:
+    virtual void addIntersection( const geom::Coordinate& intPt, size_t pathIndex) {
+        addIntersection(geom::CoordinateXYZM{intPt}, pathIndex);
+    }
+
+    virtual void addIntersection( const geom::CoordinateXYM& intPt, size_t pathIndex) {
+        addIntersection(geom::CoordinateXYZM{intPt}, pathIndex);
+    }
+
+    virtual void addIntersection(const geom::CoordinateXY& intPt, size_t pathIndex) {
+        addIntersection(geom::CoordinateXYZM{intPt}, pathIndex);
+    }
+
+    virtual void addIntersection(const geom::CoordinateXYZM& intPt, size_t pathIndex) =0;
+};
+
+}

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

@@ -0,0 +1,56 @@
+/**********************************************************************
+ *
+ * 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/export.h>
+#include <geos/noding/SegmentString.h> // for inheritance
+
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+}
+
+namespace geos {
+namespace noding { // geos::noding
+
+/** \brief
+ * An interface for classes which support adding nodes to
+ * a segment string.
+ *
+ * @author Martin Davis
+ */
+class GEOS_DLL NodableSegmentString : public SegmentString {
+private:
+protected:
+public:
+    NodableSegmentString(const void* newContext, const std::shared_ptr<const geom::CoordinateSequence>& newSeq)
+        :
+        SegmentString(newContext, newSeq)
+    { }
+
+    /**
+     * Adds an intersection node for a given point and segment to this segment string.
+     *
+     * @param intPt the location of the intersection
+     * @param segmentIndex the index of the segment containing the intersection
+     */
+    //virtual void addIntersection( const geom::Coordinate * intPt, int segmentIndex) =0;
+};
+
+} // namespace geos::noding
+} // namespace geos
+

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

@@ -0,0 +1,213 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 Paul Ramsey <pramsey@cleverelephant.ca>
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 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/NodedSegmentString.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/algorithm/LineIntersector.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h> // for inlines
+#include <geos/noding/NodedSegmentString.h>
+#include <geos/noding/NodableSegmentString.h> // for inheritance
+#include <geos/noding/SegmentNode.h>
+#include <geos/noding/SegmentNodeList.h>
+#include <geos/noding/SegmentString.h>
+#include <geos/util/IllegalArgumentException.h>
+
+#include <cstddef>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251 4355) // warning C4355: 'this' : used in base member initializer list
+#endif
+
+namespace geos {
+namespace noding { // geos::noding
+
+/** \brief
+ * Represents a list of contiguous line segments,
+ * and supports noding the segments.
+ *
+ * The line segments are represented by an array of [Coordinates](@ref geom::Coordinate).
+ * Intended to optimize the noding of contiguous segments by
+ * reducing the number of allocated objects.
+ * SegmentStrings can carry a context object, which is useful
+ * for preserving topological or parentage information.
+ * All noded substrings are initialized with the same context object.
+ *
+ */
+class GEOS_DLL NodedSegmentString : public NodableSegmentString {
+public:
+
+    // TODO: provide a templated method using an output iterator
+    template <class II>
+    static void
+    getNodedSubstrings(II from, II too_far,
+                       std::vector<std::unique_ptr<SegmentString>>& resultEdgelist)
+    {
+        for(II i = from; i != too_far; ++i) {
+            NodedSegmentString* nss = dynamic_cast<NodedSegmentString*>(*i);
+            assert(nss);
+            nss->getNodeList().addSplitEdges(resultEdgelist);
+        }
+    }
+
+    template <class C>
+    static void
+    getNodedSubstrings(const C& segStrings,
+                       std::vector<std::unique_ptr<SegmentString>>& resultEdgelist)
+    {
+        getNodedSubstrings(segStrings.begin(), segStrings.end(), resultEdgelist);
+    }
+
+    static void getNodedSubstrings(const SegmentString::NonConstVect& segStrings,
+                                   std::vector<std::unique_ptr<SegmentString>>& resultEdgeList);
+
+    static std::vector<std::unique_ptr<SegmentString>> getNodedSubstrings(
+        const std::vector<SegmentString*>& segStrings);
+
+    std::unique_ptr<geom::CoordinateSequence> getNodedCoordinates();
+
+    bool hasNodes() const
+    {
+        return nodeList.size() > 0;
+    }
+
+    /** \brief
+     * Creates a new segment string from a list of vertices.
+     *
+     * @param newPts CoordinateSequence representing the string,
+     *               ownership transferred.
+     * @param constructZ should newly-constructed coordinates store Z values?
+     * @param constructM should newly-constructed coordinates store M values?
+     * @param newContext the user-defined data of this segment string
+     *                   (may be null)
+     */
+    NodedSegmentString(const std::shared_ptr<const geom::CoordinateSequence>& newPts, bool constructZ, bool constructM, const void* newContext)
+        : NodableSegmentString(newContext, newPts)
+        , nodeList(*this, constructZ, constructM)
+    {}
+
+    NodedSegmentString(SegmentString* ss, bool constructZ, bool constructM)
+        : NodableSegmentString(ss->getData(), ss->getCoordinates())
+        , nodeList(*this, constructZ, constructM)
+    {}
+
+    ~NodedSegmentString() override {
+    }
+
+    SegmentNodeList& getNodeList();
+
+    const SegmentNodeList& getNodeList() const;
+
+    std::ostream& print(std::ostream& os) const override;
+
+    /** \brief
+     * Add {@link SegmentNode}s for one or both
+     * intersections found for a segment of an edge to the edge
+     * intersection list.
+     */
+    void addIntersections(algorithm::LineIntersector* li,
+        std::size_t segmentIndex, std::size_t geomIndex)
+    {
+        for (std::size_t i = 0, n = li->getIntersectionNum(); i < n; ++i) {
+            addIntersection(li, segmentIndex, geomIndex, i);
+        }
+    };
+
+    /** \brief
+     * Add an SegmentNode for intersection intIndex.
+     *
+     * An intersection that falls exactly on a vertex
+     * of the SegmentString is normalized
+     * to use the higher of the two possible segmentIndexes
+     */
+    void addIntersection(algorithm::LineIntersector* li,
+        std::size_t segmentIndex,
+        std::size_t geomIndex, std::size_t intIndex)
+    {
+        ::geos::ignore_unused_variable_warning(geomIndex);
+
+        const auto& intPt = li->getIntersection(intIndex);
+        addIntersection(intPt, segmentIndex);
+    };
+
+    /** \brief
+     * Add an SegmentNode for intersection intIndex.
+     *
+     * An intersection that falls exactly on a vertex of the
+     * edge is normalized
+     * to use the higher of the two possible segmentIndexes
+     */
+    template<typename CoordType>
+    void addIntersection(const CoordType& intPt,
+        std::size_t segmentIndex)
+    {
+        std::size_t normalizedSegmentIndex = segmentIndex;
+
+        if (segmentIndex > size() - 2) {
+            throw util::IllegalArgumentException("SegmentString::addIntersection: SegmentIndex out of range");
+        }
+
+        // normalize the intersection point location
+        auto nextSegIndex = normalizedSegmentIndex + 1;
+        if (nextSegIndex < size()) {
+            const auto& nextPt = getCoordinate<geom::CoordinateXY>(nextSegIndex);
+
+            // Normalize segment index if intPt falls on vertex
+            // The check for point equality is 2D only -
+            // Z values are ignored
+            if(intPt.equals2D(nextPt)) {
+                normalizedSegmentIndex = nextSegIndex;
+            }
+        }
+
+        /*
+         * Add the intersection point to edge intersection list
+         * (unless the node is already known)
+         */
+        nodeList.add(intPt, normalizedSegmentIndex);
+    }
+
+private:
+
+    SegmentNodeList nodeList;
+
+};
+
+} // namespace geos::noding
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+
+
+
+
+
+
+
+
+
+

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

@@ -0,0 +1,83 @@
+/**********************************************************************
+ *
+ * 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/export.h>
+
+#include <memory>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace noding {
+class PathString;
+class SegmentString;
+}
+}
+
+namespace geos {
+namespace noding { // geos.noding
+
+
+/** \brief
+ * Computes all intersections between segments in a set of SegmentString.
+ *
+ * Intersections found are represented as [SegmentNodes](@ref SegmentNode) and
+ * added to the [SegmentStrings](@ref SegmentString) in which they occur.
+ * As a final step in the noding a new set of segment strings split
+ * at the nodes may be returned.
+ *
+ * Last port: noding/Noder.java rev. 1.8 (JTS-1.7)
+ *
+ */
+class GEOS_DLL Noder {
+public:
+    /** \brief
+     * Computes the noding for a collection of [SegmentStrings](@ref SegmentString).
+     *
+     * Some Noders may add all these nodes to the input SegmentStrings;
+     * others may only add some or none at all.
+     *
+     * @param segStrings a collection of {@link SegmentString}s to node
+     *        The caller remains responsible for releasing the memory
+     *        associated with the SegmentStrings.
+     */
+    virtual void computeNodes(const std::vector<SegmentString*>& segStrings) = 0;
+
+    /** \brief
+     * Returns a collection of fully noded [SegmentStrings](@ref SegmentString).
+     * The SegmentStrings have the same context as their parent.
+     *
+     * @return a std::vector of SegmentStrings (copies of input, if needs be).
+     *         Caller is responsible to delete elements of container.
+     *         This method may only be called once.
+     */
+    virtual std::vector<std::unique_ptr<SegmentString>> getNodedSubstrings() = 0;
+
+    virtual void computePathNodes(const std::vector<PathString*>& inputPaths);
+
+    virtual std::vector<std::unique_ptr<PathString>> getNodedPaths();
+
+
+    virtual
+    ~Noder() {}
+
+protected:
+    Noder() {}
+};
+
+} // namespace geos.noding
+} // namespace geos
+