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

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/noding/BoundaryChainNoder.h

@@ -0,0 +1,201 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (c) Martin Davis 2022
+ *
+ * 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/Noder.h>     // for composition
+#include <geos/noding/SegmentString.h>     // for composition
+#include <geos/geom/LineSegment.h> // for composition
+#include <geos/noding/BasicSegmentString.h>
+
+#include <unordered_set>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+class Coordinate;
+}
+namespace noding {
+class NodedSegmentString;
+}
+}
+
+namespace geos {   // geos
+namespace noding { // geos::noding
+
+/**
+ * A noder which extracts chains of boundary segments
+ * as SegmentStrings from a polygonal coverage.
+ * Boundary segments are those which are not duplicated in the input polygonal coverage.
+ * Extracting chains of segments minimize the number of segment strings created,
+ * which produces a more efficient topological graph structure.
+ * <p>
+ * This enables fast overlay of polygonal coverages in CoverageUnion.
+ * Using this noder is faster than SegmentExtractingNoder
+ * and BoundarySegmentNoder.
+ * <p>
+ * No precision reduction is carried out.
+ * If that is required, another noder must be used (such as a snap-rounding noder),
+ * or the input must be precision-reduced beforehand.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL BoundaryChainNoder : public Noder {
+    using Coordinate = geos::geom::Coordinate;
+
+private:
+
+    class BoundaryChainMap {
+
+        private:
+
+            // Members
+            SegmentString* segString;
+            std::vector<bool> isBoundary;
+
+            static std::unique_ptr<SegmentString> createChain(
+                const SegmentString *segString,
+                std::size_t startIndex,
+                std::size_t endIndex,
+                bool constructZ,
+                bool constructM);
+
+            std::size_t findChainStart(std::size_t index) const;
+            std::size_t findChainEnd(std::size_t index) const;
+
+        public:
+
+            BoundaryChainMap(SegmentString* ss)
+                : segString(ss) {
+                    isBoundary.resize(ss->size()-1, false);
+                };
+
+            void setBoundarySegment(std::size_t index);
+            void createChains(std::vector<std::unique_ptr<SegmentString>> &chains, bool constructZ, bool constructM);
+    };
+
+    class Segment {
+    public:
+        Segment(const geom::CoordinateSequence& seq,
+            BoundaryChainMap& segMap,
+            std::size_t index)
+            : m_seq(seq)
+            , m_segMap(segMap)
+            , m_index(index)
+            , m_flip(seq.getAt<geom::CoordinateXY>(index).compareTo(seq.getAt<geom::CoordinateXY>(index + 1)) < 0)
+        {}
+
+        const geom::CoordinateXY& p0() const {
+            return m_seq.getAt<geom::CoordinateXY>(m_flip ? m_index : m_index + 1);
+        }
+
+        const geom::CoordinateXY& p1() const {
+            return m_seq.getAt<geom::CoordinateXY>(m_flip ? m_index + 1 : m_index);
+        }
+
+        void markBoundary() const {
+            m_segMap.setBoundarySegment(m_index);
+        };
+
+        bool operator==(const Segment& other) const {
+            return p0().equals2D(other.p0()) && p1().equals2D(other.p1());
+        }
+
+        struct HashCode {
+            std::size_t operator()(const Segment& s) const {
+                std::size_t h = std::hash<double>{}(s.p0().x);
+                h ^= (std::hash<double>{}(s.p0().y) << 1);
+                h ^= (std::hash<double>{}(s.p1().x) << 1);
+                h ^= (std::hash<double>{}(s.p1().y) << 1);
+                return h;
+            }
+        };
+
+    private:
+        const geom::CoordinateSequence& m_seq;
+        BoundaryChainMap& m_segMap;
+        std::size_t m_index;
+        bool m_flip;
+    };
+
+
+public:
+
+    using SegmentSet = std::unordered_set<Segment, Segment::HashCode>;
+
+    BoundaryChainNoder()
+        : m_constructZ(false)
+        , m_constructM(false)
+        {};
+
+    // Noder virtual methods
+    std::vector<std::unique_ptr<SegmentString>> getNodedSubstrings() override;
+    void computeNodes(const std::vector<SegmentString*>& inputSegStrings) override;
+
+
+private:
+
+    // Members
+    std::vector<std::unique_ptr<SegmentString>> m_chainList;
+    std::vector<std::unique_ptr<geom::CoordinateSequence>> m_substrings;
+    bool m_constructZ;
+    bool m_constructM;
+
+    // Methods
+    void addSegments(const std::vector<SegmentString*>& segStrings,
+        SegmentSet& segSet,
+        std::vector<BoundaryChainMap>& includedSegs);
+
+    static void addSegments(SegmentString* segString,
+        BoundaryChainMap& segInclude,
+        SegmentSet& segSet);
+
+    static bool segSetContains(
+        SegmentSet& segSet, Segment& seg);
+
+    static void markBoundarySegments(SegmentSet& segSet);
+
+    std::vector<std::unique_ptr<SegmentString>> extractChains(std::vector<BoundaryChainMap>& sections) const;
+
+    static Coordinate::UnorderedSet findNodePts(
+        const std::vector<std::unique_ptr<SegmentString>>& segStrings);
+
+    static std::vector<std::unique_ptr<SegmentString>> nodeChains(
+        std::vector<std::unique_ptr<SegmentString>> &chains,
+        const Coordinate::UnorderedSet &nodePts);
+
+    static void nodeChain(
+        std::unique_ptr<SegmentString> chain,
+        const Coordinate::UnorderedSet &nodePts,
+        std::vector<std::unique_ptr<SegmentString>> &nodedChains);
+
+    static std::size_t findNodeIndex(
+        const SegmentString* chain,
+        std::size_t start,
+        const Coordinate::UnorderedSet& nodePts);
+
+    static std::unique_ptr<BasicSegmentString> substring(
+        const SegmentString* segString,
+        std::size_t start, std::size_t end);
+
+    // Declared as non-copyable
+    BoundaryChainNoder(const BoundaryChainNoder& other);
+    BoundaryChainNoder& operator=(const BoundaryChainNoder& rhs);
+
+};
+
+} // namespace geos::noding
+} // namespace geos

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/noding/DirectionIndependentArcString.h

@@ -0,0 +1,52 @@
+/**********************************************************************
+*
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2026 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 <memory>
+#include <geos/export.h>
+
+
+namespace geos::noding {
+class ArcString;
+}
+
+namespace geos::noding {
+
+/// The DirectionIndependentArcString is a thin wrapper over an ArcString that provides specialized
+/// equality-testing and hashing functions. DirectionIndependentArcStrings are considered equal
+/// if they cover the same path, regardless of direction. The control points of arcs are not required
+/// to be identical, but must describe the same arc.
+class GEOS_DLL DirectionIndependentArcString {
+
+public:
+
+    explicit DirectionIndependentArcString(const ArcString& as) : m_as(as) {}
+
+    const ArcString& getArcString() const
+    {
+        return m_as;
+    }
+
+    bool operator==(const DirectionIndependentArcString& other) const;
+
+private:
+    const ArcString& m_as;
+};
+}
+
+template<>
+struct GEOS_DLL std::hash<geos::noding::DirectionIndependentArcString> {
+    std::size_t operator()(const geos::noding::DirectionIndependentArcString& as) const noexcept;
+};

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/noding/FastNodingValidator.h

@@ -0,0 +1,132 @@
+/**********************************************************************
+ *
+ * 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/FastNodingValidator.java rev. ??? (JTS-1.8)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/noding/NodingIntersectionFinder.h> // for composition
+#include <geos/algorithm/LineIntersector.h> // for composition
+
+#include <memory>
+#include <string>
+#include <cassert>
+
+// Forward declarations
+namespace geos {
+namespace noding {
+class SegmentString;
+}
+}
+
+namespace geos {
+namespace noding { // geos.noding
+
+/** \brief
+ * Validates that a collection of {@link SegmentString}s is correctly noded.
+ *
+ * Indexing is used to improve performance.
+ * By default validation stops after a single
+ * non-noded intersection is detected.
+ * Alternatively, it can be requested to detect all intersections by
+ * using `setFindAllIntersections(boolean)`.
+ *
+ * The validator does not check for topology collapse situations
+ * (e.g. where two segment strings are fully co-incident).
+ *
+ * The validator checks for the following situations which indicated incorrect noding:
+ *
+ * - Proper intersections between segments (i.e. the intersection is interior to both segments)
+ * - Intersections at an interior vertex (i.e. with an endpoint or another interior vertex)
+ *
+ * The client may either test the {@link #isValid()} condition,
+ * or request that a suitable [TopologyException](@ref util::TopologyException) be thrown.
+ *
+ */
+class FastNodingValidator {
+
+public:
+
+    FastNodingValidator(const std::vector<std::unique_ptr<SegmentString>>& newSegStrings)
+        :
+        li(), // robust...
+        segInt(),
+        isValidVar(true)
+    {
+        segStrings.resize(newSegStrings.size());
+        for (std::size_t i = 0; i < newSegStrings.size(); ++i) {
+            segStrings[i] = newSegStrings[i].get();
+        }
+    }
+
+    /** \brief
+     * Checks for an intersection and
+     * reports if one is found.
+     *
+     * @return true if the arrangement contains an interior intersection
+     */
+    bool
+    isValid()
+    {
+        execute();
+        return isValidVar;
+    }
+
+    /** \brief
+     * Returns an error message indicating the segments containing
+     * the intersection.
+     *
+     * @return an error message documenting the intersection location
+     */
+    std::string getErrorMessage() const;
+
+    /** \brief
+     * Checks for an intersection and throws
+     * a TopologyException if one is found.
+     *
+     * @throws TopologyException if an intersection is found
+     */
+    void checkValid();
+
+private:
+
+    geos::algorithm::LineIntersector li;
+
+    std::vector<SegmentString*> segStrings;
+
+    std::unique_ptr<NodingIntersectionFinder> segInt;
+
+    bool isValidVar;
+
+    void
+    execute()
+    {
+        if(segInt.get() != nullptr) {
+            return;
+        }
+        checkInteriorIntersections();
+    }
+
+    void checkInteriorIntersections();
+
+    // Declare type as noncopyable
+    FastNodingValidator(const FastNodingValidator& other) = delete;
+    FastNodingValidator& operator=(const FastNodingValidator& rhs) = delete;
+};
+
+} // namespace geos.noding
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/noding/FastSegmentSetIntersectionFinder.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.
+ *
+ *
+ **********************************************************************
+ *
+ * Last port: noding/FastSegmentSetIntersectionFinder.java r388 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/algorithm/LineIntersector.h>
+#include <geos/noding/SegmentString.h>
+#include <geos/noding/MCIndexSegmentSetMutualIntersector.h>
+
+#include <memory>
+
+//forward declarations
+namespace geos {
+namespace noding {
+class SegmentIntersectionDetector;
+class SegmentSetMutualIntersector;
+//class MCIndexSegmentSetMutualIntersector : public SegmentSetMutualIntersector;
+}
+}
+
+
+namespace geos {
+namespace noding { // geos::noding
+
+/** \brief
+ * Finds if two sets of [SegmentStrings](@ref noding::SegmentString) intersect.
+ *
+ * Uses indexing for fast performance and to optimize repeated tests
+ * against a target set of lines.
+ * Short-circuited to return as soon an intersection is found.
+ *
+ * @version 1.7
+ */
+class FastSegmentSetIntersectionFinder {
+private:
+    std::unique_ptr<MCIndexSegmentSetMutualIntersector> segSetMutInt;
+    std::unique_ptr<geos::algorithm::LineIntersector> lineIntersector;
+
+protected:
+public:
+    FastSegmentSetIntersectionFinder(SegmentString::ConstVect* baseSegStrings);
+
+    ~FastSegmentSetIntersectionFinder() = default;
+
+    /**
+     * Gets the segment set intersector used by this class.
+     * This allows other uses of the same underlying indexed structure.
+     *
+     * @return the segment set intersector used
+     */
+    const SegmentSetMutualIntersector*
+    getSegmentSetIntersector() const
+    {
+        return segSetMutInt.get();
+    }
+
+    bool intersects(SegmentString::ConstVect* segStrings);
+    bool intersects(SegmentString::ConstVect* segStrings, SegmentIntersectionDetector* intDetector);
+
+};
+
+} // geos::noding
+} // geos
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/noding/GeometryNoder.h

@@ -0,0 +1,90 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2012  Sandro Santilli <strk@kbt.io>
+ *
+ * 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.
+ *
+ **********************************************************************
+ *
+ * NOTE: this is not in JTS. JTS has a snapround/GeometryNoder though
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/noding/SegmentString.h> // for NonConstVect
+
+#include <memory> // for unique_ptr
+
+// Forward declarations
+namespace geos {
+namespace algorithm {
+class CircularArcIntersector;
+}
+namespace geom {
+class Geometry;
+}
+namespace noding {
+class ArcIntersectionAdder;
+class Noder;
+}
+}
+
+namespace geos {
+namespace noding { // geos.noding
+
+class GEOS_DLL GeometryNoder {
+public:
+
+    static std::unique_ptr<geom::Geometry> node(const geom::Geometry& geom);
+
+    static std::unique_ptr<geom::Geometry> node(const geom::Geometry& geom1, const geom::Geometry& geom2);
+
+    GeometryNoder(const geom::Geometry& g);
+
+    GeometryNoder(const geom::Geometry& g1, const geom::Geometry& g2);
+
+    ~GeometryNoder();
+
+    std::unique_ptr<geom::Geometry> getNoded();
+
+    void setOnlyFirstGeomEdges(bool onlyFirstGeomEdges);
+
+    void setPreserveCompoundCurves(bool preserve);
+
+    // Declare type as noncopyable
+    GeometryNoder(GeometryNoder const&) = delete;
+    GeometryNoder& operator=(GeometryNoder const&) = delete;
+
+private:
+
+    bool isInResult(const PathString& ps) const;
+
+    const geom::Geometry* argGeom1;
+    const geom::Geometry* argGeom2;
+    const bool argGeomHasCurves;
+    bool argGeomHasCompoundCurves;
+    bool onlyFirstGeomEdges;
+    bool preserveCompoundCurves;
+
+    std::unique_ptr<Noder> noder;
+    std::unique_ptr<algorithm::CircularArcIntersector> m_cai;
+    std::unique_ptr<ArcIntersectionAdder> m_aia;
+
+    void extractPathStrings(const geom::Geometry& g, std::vector<std::unique_ptr<PathString>>& to);
+
+    Noder& getNoder();
+
+    std::unique_ptr<geom::Geometry> toGeometry(std::vector<std::unique_ptr<PathString>>& noded) const;
+
+};
+
+} // namespace geos.noding
+} // namespace geos