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

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

@@ -0,0 +1,317 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2019      Nicklas Larsson
+ *
+ * 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
+
+namespace geos {
+
+/// \brief
+/// Contains classes and interfaces implementing fundamental computational
+/// geometry algorithms.
+///
+/// ### Robustness
+///
+/// Geometrical algorithms involve a combination of combinatorial and numerical
+/// computation. As with all numerical computation using finite-precision
+/// numbers, the algorithms chosen are susceptible to problems of robustness.
+/// A robustness problem occurs when a numerical calculation produces an
+/// incorrect answer for some inputs due to round-off errors.  Robustness
+/// problems are especially serious in geometric computation, since they can
+/// result in errors during topology building.
+///
+/// There are many approaches to dealing with the problem of robustness in
+/// geometrical computation. Not surprisingly, most robust algorithms are
+/// substantially more complex and less performant than the non-robust
+/// versions. Fortunately, JTS is sensitive to robustness problems in only a
+/// few key functions (such as line intersection and the point-in-polygon
+/// test). There are efficient robust algorithms available for these
+/// functions, and these algorithms are implemented in JTS.
+///
+/// ### Computational Performance
+///
+/// Runtime performance is an important consideration for a production-quality
+/// implementation of geometric algorithms. The most computationally intensive
+/// algorithm used in JTS is intersection detection. JTS methods need to
+/// determine both all intersection between the line segments in a single
+/// Geometry (self-intersection) and all intersections between the line
+/// segments of two different Geometries.
+///
+/// The obvious naive algorithm for intersection detection (comparing every
+/// segment with every other) has unacceptably slow performance. There is a
+/// large literature of faster algorithms for intersection detection.
+/// Unfortunately, many of them involve substantial code complexity. JTS tries
+/// to balance code simplicity with performance gains. It uses some simple
+/// techniques to produce substantial performance gains for common types of
+/// input data.
+///
+/// ### Package Specification
+///
+/// - Java Topology Suite Technical Specifications
+/// - <A HREF="http://www.opengis.org/techno/specs.htm">
+///       OpenGIS Simple Features Specification for SQL</A>
+    namespace algorithm { // geos::algorithm
+
+    /// Classes to compute distance metrics between geometries.
+    namespace distance {}
+
+    /// Classes which determine the Location of points in geometries.
+    namespace locate {}
+} // namespace geos::algorithm
+
+namespace geom { // geos.geom
+
+    /// \brief
+    /// Contains classes and interfaces implementing algorithms that optimize
+    /// the performance of repeated calls to specific geometric operations.
+    namespace prep {}
+
+    /// \brief
+    /// Provides classes that parse and modify Geometry objects.
+    namespace util {}
+} // namespace geos.geom
+
+/// \brief
+/// Contains classes that implement topology graphs.
+///
+/// The Java Topology Suite (JTS) is a Java API that implements a core set of
+/// spatial data operations using an explicit precision model and robust
+/// geometric algorithms. JTS is int ended to be used in the development of
+/// applications that support the validation, cleaning, integration and
+/// querying of spatial datasets.
+///
+/// JTS attempts to implement the OpenGIS Simple Features Specification (SFS)
+/// as accurately as possible.  In some cases the SFS is unclear or omits a
+/// specification; in this case JTS attempts to choose a reasonable and
+/// consistent alternative.  Differences from and elaborations of the SFS are
+/// documented in this specification.
+///
+/// ### Package Specification
+///
+/// - Java Topology Suite Technical Specifications
+/// - <A HREF="http://www.opengis.org/techno/specs.htm">
+///   OpenGIS Simple Features Specification for SQL</A>
+namespace geomgraph { // geos.geomgraph
+
+    /// \brief
+    /// Contains classes that implement indexes for performing noding on
+    /// geometry graph edges.
+    namespace index {}
+} // namespace geos.geomgraph
+
+
+/// Provides classes for various kinds of spatial indexes.
+namespace index { // geos.index
+
+    /// Contains classes that implement a Binary Interval Tree index
+    namespace bintree {}
+
+    /// Contains classes that implement Monotone Chains
+    namespace chain {}
+
+    /// \brief Contains classes that implement a static index on a set of
+    /// 1-dimensional intervals, using an R-Tree packed based on the order of
+    /// the interval midpoints.
+    namespace intervalrtree {}
+
+    /// Contains classes that implement a Quadtree spatial index
+    namespace quadtree {}
+
+    /// \brief Contains 2-D and 1-D versions of the Sort-Tile-Recursive (STR)
+    /// tree, a query-only R-tree.
+    namespace strtree {}
+
+    /// \brief Contains classes which implement a sweepline algorithm for
+    /// scanning geometric data structures.
+    namespace sweepline {}
+} // namespace geos.index
+
+/// \brief
+/// Contains the interfaces for converting JTS objects to and from other
+/// formats.
+///
+/// The Java Topology Suite (JTS) is a Java API that implements a core set of
+/// spatial data operations using an explicit precision model and robust
+/// geometric algorithms. JTS is intended to be used in the devel opment of
+/// applications that support the validation, cleaning, integration and
+/// querying of spatial data sets.
+///
+/// JTS attempts to implement the OpenGIS Simple Features Specification (SFS)
+/// as accurately as possible.  In some cases the SFS is unclear or omits a
+/// specification; in this case JTS attempts to choose a reasonable and
+/// consistent alternative.  Differences from and elaborations of the SFS are
+/// documented in this specification.
+///
+/// ### Package Specification
+///
+/// - Java Topology Suite Technical Specifications
+/// - <A HREF="http://www.opengis.org/techno/specs.htm">
+///   OpenGIS Simple Features Specification for SQL</A>
+///
+namespace io {}
+
+/// \brief Contains classes and interfaces implementing linear referencing on
+/// linear geometries.
+namespace linearref {}
+
+/// \brief Classes to compute nodings for arrangements of line segments and
+/// line segment sequences.
+namespace noding { // geos.noding
+
+    /// \brief Contains classes to implement the Snap Rounding algorithm for
+    /// noding linestrings.
+    namespace snapround {}
+} // namespace geos.noding
+
+/// Provides classes for implementing operations on geometries.
+namespace operation { // geos.operation
+
+    /// Provides classes for computing buffers of geometries
+    namespace buffer {}
+
+    /// Provides classes for computing the distance between geometries.
+    namespace distance {}
+
+    /// \brief Provides classes for computing the intersection of a Geometry
+    /// and a clipping Rectangle.
+    namespace intersection {}
+
+    /// Line merging package.
+    namespace linemerge {}
+
+    /// \brief
+    /// Contains classes that perform a topological overlay to compute boolean
+    /// spatial functions.
+    ///
+    /// The Overlay Algorithm is used in spatial analysis methods for computing
+    /// set-theoretic operations (boolean combinations) of input
+    /// [Geometrys](\ref geom::Geometry).
+    /// The algorithm for computing the overlay uses the intersection operations
+    /// supported by topology graphs. To compute an overlay it is necessary to
+    /// explicitly compute the resultant graph formed by the computed
+    /// intersections.
+    ///
+    /// The algorithm to compute a set-theoretic spatial analysis method has the
+    /// following steps:
+    ///
+    /// - Build topology graphs of the two input geometries. For each geometry
+    ///   all self-intersection nodes are computed and added to the graph.
+    /// - Compute nodes for all intersections between edges and nodes of the
+    ///   graphs.
+    /// - Compute the labeling for the computed nodes by merging the labels from
+    ///   the input graphs.
+    /// - Compute new edges between the compute intersection nodes.
+    ///   Label the edges appropriately.
+    /// - Build the resultant graph from the new nodes and edges.
+    /// - Compute the labeling for isolated components of the graph. Add the
+    ///   isolated components to the resultant graph.
+    /// - Compute the result of the boolean combination by selecting the node
+    ///   and edges with the appropriate labels. Polygonize areas and sew linear
+    ///   geometries together.
+    ///
+    /// ### Package Specification
+    ///
+    /// - Java Topology Suite Technical Specifications
+    /// - <A HREF="http://www.opengis.org/techno/specs.htm">
+    ///   OpenGIS Simple Features Specification for SQL</A>
+    namespace overlay {}
+
+    /// An API for polygonizing sets of lines.
+    namespace polygonize {}
+
+    /// \brief Classes which implement topological predicates optimized for
+    /// particular kinds of geometries.
+    namespace predicate {}
+
+    /// \brief Contains classes to implement the computation of the spatial
+    /// relationships of `Geometry`s.
+    ///
+    /// The `relate` algorithm computes the `IntersectionMatrix` describing the
+    /// relationship of two `Geometry`s. The algorithm for computing `relate`
+    /// uses the intersection operations supported by topology graphs. Although
+    /// the `relate` result depends on the resultant graph formed by the
+    /// computed intersections, there is no need to explicitly compute the
+    /// entire graph. It is sufficient to compute the local structure of the
+    /// graph at each intersection node.
+    ///
+    /// The algorithm to compute `relate` has the following steps:
+    ///
+    /// - Build topology graphs of the two input geometries. For each geometry
+    ///   all self-intersection nodes are computed and added to the graph.
+    /// - Compute nodes for all intersections between edges and nodes of the
+    ///   graphs.
+    /// - Compute the labeling for the computed nodes by merging the labels
+    ///   from the input graphs.
+    /// - Compute the labeling for isolated components of the graph (see below)
+    /// - Compute the `IntersectionMatrix` from the labels on the nodes and
+    ///   edges.
+    ///
+    /// ### Labeling isolated components
+    ///
+    /// Isolated components are components (edges or nodes) of an input
+    /// `Geometry` which do not contain any intersections with the other input
+    /// `Geometry`. The topological relationship of these components to the
+    /// other input `Geometry` must be computed in order to determine the
+    /// complete labeling of the component. This can be done by testing whether
+    /// the component lies in the interior or exterior of the other `Geometry`.
+    /// If the other `Geometry` is 1-dimensional, the isolated component must
+    /// lie in the exterior (since otherwise it would have an intersection with
+    /// an edge of the `Geometry`). If the other `Geometry` is 2-dimensional,
+    /// a Point-In-Polygon test can be used to determine whether the isolated
+    /// component is in the interior or exterior.
+    ///
+    /// ### Package Specification
+    ///
+    /// - Java Topology Suite Technical Specifications
+    /// - <A HREF="http://www.opengis.org/techno/specs.htm">
+    ///    OpenGIS Simple Features Specification for SQL</A>
+    namespace relate {}
+
+    /// Find shared paths among two linear Geometry objects.
+    namespace sharedpaths {}
+
+    /// Classes to perform efficient unioning of collections of geometries.
+    namespace geounion {}
+
+    /// Provides classes for testing the validity of geometries.
+    namespace valid {}
+} // namespace geos.operation
+
+/// Contains classes to implement a planar graph data structure.
+namespace planargraph { // geos::planargraph
+
+    /// Planargraph algorithms.
+    namespace algorithm {}
+} // namespace geos::planargraph
+
+/// Provides classes for manipulating the precision model of Geometries.
+namespace precision {}
+
+/// Classes which implement algorithms for simplifying or generalizing geometries.
+namespace simplify {}
+
+/// Classes to compute Delaunay triangulations.
+namespace triangulate { // geos.triangulate
+
+    /// \brief Classes to implement a topological subdivision of quadeges, to
+    /// support creating triangulations and Voronoi diagrams.
+    namespace quadedge {}
+} // namespace geos.triangulate
+
+/// Utility classes for GEOS.
+namespace util {}
+
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/noding/ArcIntersectionAdder.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/algorithm/CircularArcIntersector.h>
+#include <geos/noding/ArcIntersector.h>
+
+namespace geos::noding {
+
+class GEOS_DLL ArcIntersectionAdder : public ArcIntersector {
+
+public:
+    explicit ArcIntersectionAdder(algorithm::CircularArcIntersector& cai) :
+        m_intersector(cai) {}
+
+    void processIntersections(ArcString& e0, std::size_t segIndex0, ArcString& e1, std::size_t segIndex1) override;
+
+    void processIntersections(ArcString& e0, std::size_t segIndex0, SegmentString& e1, std::size_t segIndex1) override;
+
+    void processIntersections(SegmentString& e0, std::size_t segIndex0, SegmentString& e1, std::size_t segIndex1) override;
+
+private:
+    static bool isAdjacentSegments(std::size_t i1, std::size_t i2);
+
+    bool isTrivialIntersection(const PathString* e0, std::size_t segIndex0,
+                               const PathString* e1, std::size_t segIndex1) const;
+
+    algorithm::CircularArcIntersector& m_intersector;
+};
+
+}

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/noding/ArcIntersector.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/SegmentString.h>
+
+namespace geos::noding {
+
+class GEOS_DLL ArcIntersector {
+public:
+    virtual void processIntersections(ArcString& e0, std::size_t arcIndex0,
+                                      ArcString& e1, std::size_t arcIndex1) = 0;
+    virtual void processIntersections(SegmentString& e0, std::size_t segIndex0,
+                                      SegmentString& e1, std::size_t segIndex1) = 0;
+    virtual void processIntersections(ArcString& e0, std::size_t arcIndex0,
+                                      SegmentString& e1, std::size_t segIndex1) = 0;
+
+    virtual void processIntersections(SegmentString& e0, std::size_t segIndex0,
+                                      ArcString& e1, std::size_t arcIndex1) {
+        processIntersections(e1, arcIndex1, e0, segIndex0);
+    }
+
+    virtual bool isDone() const {
+        return false;
+    }
+
+    virtual ~ArcIntersector() = default;
+};
+
+}

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

@@ -0,0 +1,53 @@
+/**********************************************************************
+ *
+ * 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/ArcIntersector.h>
+#include <geos/noding/Noder.h>
+
+namespace geos::noding {
+class PathString;
+}
+
+namespace geos::noding {
+
+class GEOS_DLL ArcNoder : public Noder {
+
+public:
+    ArcNoder() = default;
+
+    explicit ArcNoder(ArcIntersector& intersector) :
+        m_intersector(&intersector) {}
+
+    ~ArcNoder() override;
+
+    void setArcIntersector(ArcIntersector& arcIntersector) {
+        m_intersector = &arcIntersector;
+    }
+
+    void computeNodes(const std::vector<SegmentString*>& segStrings) override;
+
+    std::vector<std::unique_ptr<SegmentString>> getNodedSubstrings() override;
+
+    void computePathNodes(const std::vector<PathString*>& inputPaths) override = 0;
+
+    std::vector<std::unique_ptr<PathString>> getNodedPaths() override = 0;
+
+protected:
+    ArcIntersector* m_intersector{nullptr};
+};
+
+}

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

@@ -0,0 +1,72 @@
+/**********************************************************************
+*
+ * 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/CircularArc.h>
+#include <geos/noding/PathString.h>
+
+#include <vector>
+
+namespace geos::noding {
+
+/** \brief
+ *  An interface for classes which represent a sequence of contiguous
+ *  circular arcs, analogous to the SegmentString for contiguous line
+ *  segments.
+ */
+class GEOS_DLL ArcString : public PathString {
+public:
+    explicit ArcString(std::vector<geom::CircularArc> arcs) : m_arcs(std::move(arcs)) {
+    }
+
+    ArcString(std::vector<geom::CircularArc> arcs, const std::shared_ptr<const geom::CoordinateSequence>& seq, const void* p_context)
+        : PathString(p_context),
+          m_arcs(std::move(arcs)),
+          m_seq(seq)
+    {}
+
+    std::size_t getSize() const override {
+        return m_arcs.size();
+    }
+
+    double getLength() const override {
+        double tot = 0;
+        for (const auto &arc: m_arcs) {
+            tot += arc.getLength();
+        }
+        return tot;
+    }
+
+    const geom::CircularArc &getArc(std::size_t i) const {
+        return m_arcs[i];
+    }
+
+    auto begin() const {
+        return m_arcs.begin();
+    }
+
+    auto end() const {
+        return m_arcs.end();
+    }
+
+    const std::shared_ptr<const geom::CoordinateSequence>& getCoordinates() const override;
+
+protected:
+    std::vector<geom::CircularArc> m_arcs;
+    std::shared_ptr<const geom::CoordinateSequence> m_seq;
+};
+
+}

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

@@ -0,0 +1,89 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2009 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.
+ *
+ **********************************************************************
+ *
+ * Last port: noding/BasicSegmentString.java rev. 1.1 (JTS-1.9)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/noding/BasicSegmentString.h>
+#include <geos/noding/Octant.h>
+#include <geos/noding/SegmentString.h> // for inheritance
+#include <geos/geom/CoordinateSequence.h> // for inlines (size())
+
+
+#include <vector>
+
+// Forward declarations
+
+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 BasicSegmentString : public SegmentString {
+
+public:
+
+    /// \brief Construct a BasicSegmentString.
+    ///
+    /// @param newPts CoordinateSequence representing the string, externally owned
+    /// @param newContext the context associated to this SegmentString
+    ///
+    BasicSegmentString(const std::shared_ptr<const geom::CoordinateSequence>& newPts,
+                       const void* newContext)
+        :
+        SegmentString(newContext, newPts)
+    {}
+
+    ~BasicSegmentString() override
+    {}
+
+    // see dox in SegmentString.h
+    std::ostream& print(std::ostream& os) const override;
+
+    /** \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 Octant::octant(getCoordinate(index), getCoordinate(index + 1));
+    };
+
+private:
+
+    // Declare type as noncopyable
+    BasicSegmentString(const BasicSegmentString& other) = delete;
+    BasicSegmentString& operator=(const BasicSegmentString& rhs) = delete;
+
+};
+
+} // namespace geos.noding
+} // namespace geos