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

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/grid/GridIntersection.h

@@ -0,0 +1,117 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2018-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 <memory>
+
+#include <geos/geom/Geometry.h>
+#include <geos/operation/grid/Grid.h>
+#include <geos/operation/grid/Matrix.h>
+
+namespace geos::geom {
+    class Geometry;
+    class LineString;
+}
+
+namespace geos::operation::grid {
+
+class Cell;
+
+/**
+ * @brief The GridIntersection class computes and stores information about intersection of a Grid and a Geometry.
+ *        For a polygonal geometry, the fraction of each grid cell covered by polygon is stored.
+ *        For a linear geometry, the length of the line in each grid cell is stored.
+ *
+ *        Intersection information returned as `Raster` with an equivalent resolution to the input `Grid`. The spatial
+ *        extent may be reduced from the input `Grid.`
+ */
+class GEOS_DLL GridIntersection
+{
+
+  public:
+    /**
+     * @brief Compute the fraction of each cell in a rectangular grid that is covered by a Geometry.
+     *        A matrix can be provided to which the fractions will be added.
+     */
+    GridIntersection(const Grid<bounded_extent>& raster_grid, const geom::Geometry& g, const std::shared_ptr<Matrix<float>>& cov = nullptr);
+
+    /**
+     * @brief Compute the fraction of each cell in a rectangular grid that is covered by an Envelope.
+     *        A matrix can be provided to which the fractions will be added.
+     */
+    GridIntersection(const Grid<bounded_extent>& raster_grid, const geom::Envelope& box, const std::shared_ptr<Matrix<float>>& cov = nullptr);
+
+    /**
+     * @brief Return the intersection result matrix
+     */
+    std::shared_ptr<Matrix<float>> getResults() { return m_results; }
+
+    /**
+     * @brief Partition a polygonal geometry by a grid
+     * @param grid the Grid by which the polygon should be partitioned. The Grid does not need to cover the polygon.
+     * @param g a polygonal geometry
+     * @param includeExterior whether the result should contain any portions of the input that fall outside the grid.
+     * @return a GeometryCollection containing the partitioned polygon.
+     */
+    static std::unique_ptr<geom::Geometry> subdividePolygon(const Grid<bounded_extent>& grid, const geom::Geometry& g, bool includeExterior);
+
+    /**
+     * @brief Calculate the fraction of each cell in a Grid that is covered by a polygon.
+     * @param grid the Grid for which coverage fractions should be returned
+     * @param g a polygonal or linear geometry
+     * @return a matrix having the same number of rows and columns as the grid, whose values contain either the
+     *         fraction of the cell area (for polygonal inputs) or the length of the intersection (for linear inputs)
+     */
+    static std::shared_ptr<Matrix<float>>
+    getIntersectionFractions(const Grid<bounded_extent>& grid, const geom::Geometry& g);
+
+    static std::shared_ptr<Matrix<float>>
+    getIntersectionFractions(const Grid<bounded_extent>& grid, const geom::Envelope& box);
+
+    /**
+     * @brief Determines the bounding box of the raster-vector intersection. Considers the bounding boxes
+     *        of individual polygon components separately to avoid unnecessary computation for sparse
+     *        multi-polygons.
+     *
+     * @param raster_extent Envelope representing the extent of the vector
+     * @param geometry Geometry to be processed
+     *
+     * @return the portion of `raster_extent` that intersects one or more `component_boxes`
+     */
+    static geom::Envelope
+    processingRegion(const geom::Envelope& raster_extent, const geom::Geometry& geometry);
+
+  private:
+    void process(const geom::Geometry& g);
+
+    void processLine(const geom::LineString& ls, bool exterior_ring);
+
+    void processRectangularRing(const geom::Envelope& box, bool exterior_ring);
+
+    void addRingResults(size_t i0, size_t j0, const Matrix<float>& areas, bool exterior_ring);
+
+    void setAreal(bool areal);
+
+    static Matrix<float> collectAreas(const Matrix<std::unique_ptr<Cell>>& cells,
+                                      const Grid<bounded_extent>& finite_ring_grid,
+                                      const geom::Geometry& g);
+
+    Grid<infinite_extent> m_geometry_grid;
+    std::shared_ptr<Matrix<float>> m_results;
+    bool m_first_geom;
+    bool m_areal;
+};
+
+}

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/grid/Matrix.h

@@ -0,0 +1,185 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2018-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 <cstring>
+#include <iomanip>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace geos::operation::grid {
+
+template<typename T>
+class Matrix
+{
+
+  public:
+    using value_type = T;
+
+    Matrix(size_t rows, size_t cols, std::shared_ptr<T[]> data)
+        : m_data{ data }
+        , m_rows{ rows }
+        , m_cols{ cols }
+    {}
+
+    Matrix(size_t rows, size_t cols)
+      : m_rows{ rows }
+      , m_cols{ cols }
+    {
+        if (m_rows > 0 && m_cols > 0) {
+            // new T[]() initializes to zero
+            m_data = std::shared_ptr<T[]>(new T[m_rows * m_cols]());
+        }
+    }
+
+    Matrix(size_t rows, size_t cols, T value)
+      : m_rows{ rows }
+      , m_cols{ cols }
+    {
+        if (m_rows > 0 && m_cols > 0) {
+            // new T[] does not initialize
+            m_data = std::shared_ptr<T[]>(new T[m_rows * m_cols]);
+        }
+
+        std::fill(m_data.get(), m_data.get() + m_rows * m_cols, value);
+    }
+
+    explicit Matrix(const std::vector<std::vector<T>>& data)
+      : m_rows{ data.size() }
+      , m_cols{ data[0].size() }
+    {
+        m_data = std::shared_ptr<T[]>(new T[m_rows * m_cols]());
+
+        auto lastpos = m_data.get();
+        for (auto& row : data) {
+            lastpos = std::copy(row.begin(), row.end(), lastpos);
+        }
+    }
+
+    Matrix(Matrix<T>&& m) noexcept
+      : m_rows{ m.getNumRows() }
+      , m_cols{ m.getNumCols() }
+    {
+        m_data = std::move(m.m_data);
+    }
+
+    T& operator()(size_t row, size_t col)
+    {
+        check(row, col);
+        return m_data.get()[row * m_cols + col];
+    }
+
+    const T& operator()(size_t row, size_t col) const
+    {
+        check(row, col);
+        return m_data.get()[row * m_cols + col];
+    }
+
+    bool operator!=(const Matrix<T>& other) const {
+        return !(*this == other);
+    }
+
+    bool operator==(const Matrix<T>& other) const
+    {
+        if (m_rows != other.m_rows) {
+            return false;
+        }
+        if (m_cols != other.m_cols) {
+            return false;
+        }
+
+        return 0 == memcmp(m_data.get(), other.m_data.get(), m_rows * m_cols * sizeof(T));
+    }
+
+    void increment(size_t row, size_t col, const T& val)
+    {
+        check(row, col);
+        m_data.get()[row * m_cols + col] += val;
+    }
+
+    size_t getNumRows() const { return m_rows; }
+    size_t getNumCols() const { return m_cols; }
+
+    T* row(size_t row)
+    {
+        return &(m_data[row * m_cols]);
+    }
+
+    T* data()
+    {
+        return m_data.get();
+    }
+
+    const T* data() const
+    {
+        return m_data.get();
+    }
+
+    T* release()
+    {
+        return m_data.release();
+    }
+
+    const T* begin() const {
+        return m_data.get();
+    }
+
+    const T* end() const {
+        return m_data.get() + m_rows * m_cols;
+    }
+
+#ifdef MATRIX_CHECK_BOUNDS
+    void check(size_t row, size_t col) const
+    {
+        if (row + 1 > m_rows) {
+            throw std::out_of_range("Row " + std::to_string(row) + " is out of range.");
+        }
+        if (col + 1 > m_cols) {
+            throw std::out_of_range("Col " + std::to_string(col) + " is out of range.");
+        }
+    }
+#else
+    void check(size_t, size_t) const
+    {
+    }
+#endif
+
+  private:
+    std::shared_ptr<T[]> m_data;
+
+    size_t m_rows;
+    size_t m_cols;
+};
+
+template<typename T>
+std::ostream&
+operator<<(std::ostream& os, const Matrix<T>& m)
+{
+    for (size_t i = 0; i < m.getNumRows(); i++) {
+        for (size_t j = 0; j < m.getNumCols(); j++) {
+            if (m(i, j) != 0) {
+                os << std::right << std::fixed << std::setw(10) << std::setprecision(6) << m(i, j) << " ";
+            } else {
+                os << "           ";
+            }
+        }
+        os << std::endl;
+    }
+
+    return os;
+}
+
+}

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/grid/PerimeterDistance.h

@@ -0,0 +1,60 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2018-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>
+
+namespace geos::geom {
+    class CoordinateXY;
+    class Envelope;
+}
+
+namespace geos::operation::grid {
+
+class GEOS_DLL PerimeterDistance {
+    public:
+
+    /** Calculates the clockwise distance along the edge of an Envelope
+     *  from the lower left corner of the Envelope to a supplied Coordinate
+     *  lying exactly on the boundary of the Envelope.
+     */
+    static double
+    getPerimeterDistance(const geom::Envelope& env, const geom::CoordinateXY& c);
+
+    static double
+    getPerimeterDistance(double xmin, double ymin, double xmax, double ymax, double x, double y);
+
+    /** Calculates the counter-clockwise distance between two locations on the perimeter
+     *  of an Envelope. The locations are specified as clockwise distances from the
+     *  lower left corner of the Envelope, consistent with the `getPerimeterDistance`
+     *  function.
+     */
+    static double
+    getPerimeterDistanceCCW(double measure1, double measure2, double perimeter);
+
+    /** Tests whether measure x would be passed when traveling from a to b in a CCW
+     * direction.
+     */
+    static bool
+    isBetweenCCW(double x, double a, double b);
+
+    /** Tests whether the perimeter distance of c1 is less than the perimeter distance of c2, in a
+     *  robust way.
+     */
+    static bool
+    isLessThan(const geom::Envelope& e, const geom::CoordinateXY& c1, const geom::CoordinateXY& c2);
+
+};
+}

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/grid/Side.h

@@ -0,0 +1,54 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2018-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 <iostream>
+
+namespace geos::operation::grid {
+
+enum class Side
+{
+    NONE,
+    LEFT,
+    RIGHT,
+    TOP,
+    BOTTOM
+};
+
+inline std::ostream&
+operator<<(std::ostream& os, const Side& s)
+{
+    switch (s) {
+        case Side::NONE:
+            os << "none";
+            return os;
+        case Side::LEFT:
+            os << "left";
+            return os;
+        case Side::RIGHT:
+            os << "right";
+            return os;
+        case Side::TOP:
+            os << "top";
+            return os;
+        case Side::BOTTOM:
+            os << "bottom";
+            return os;
+    }
+
+    return os; // unreachable statement needed for -Werror=return-type
+}
+
+}

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/grid/Traversal.h

@@ -0,0 +1,85 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2018-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>
+#include <geos/operation/grid/Side.h>
+
+#include <vector>
+
+namespace geos::operation::grid {
+
+/**
+ * @brief The Traversal class records the coordinates of a line that are
+ *        within a grid cell, as well as the `Side` from which the line
+ *        entered and exited the cell.
+ */
+class GEOS_DLL Traversal
+{
+  public:
+    Traversal()
+      : m_entry{ Side::NONE }
+      , m_exit{ Side::NONE }
+      , m_parentage{ nullptr }
+    {
+    }
+
+    bool isClosedRing() const;
+
+    bool isClosedRingWithArea() const;
+
+    bool isEmpty() const;
+
+    bool isEntered() const;
+
+    bool isExited() const;
+
+    bool isTraversed() const;
+
+    bool hasMultipleUniqueCoordinates() const;
+
+    /// Begin a Traversal on the specified `Side`
+    void enter(const geom::CoordinateXY& c, Side s, const void* parentage);
+
+    /// Complete a Traversal on the specified `Side`
+    void exit(const geom::CoordinateXY& c, Side s);
+
+    Side getEntrySide() const { return m_entry; }
+
+    Side getExitSide() const { return m_exit; }
+
+    const geom::CoordinateXY& getFirstCoordinate() const;
+
+    const geom::CoordinateXY& getLastCoordinate() const;
+
+    const geom::CoordinateXY& getExitCoordinate() const;
+
+    void add(const geom::CoordinateXY& c);
+
+    void forceExit(Side s) { m_exit = s; }
+
+    const std::vector<geom::CoordinateXY>& getCoordinates() const { return m_coords; }
+
+    const void* getParentage() const { return m_parentage; }
+
+  private:
+    std::vector<geom::CoordinateXY> m_coords;
+    Side m_entry;
+    Side m_exit;
+    const void* m_parentage;
+};
+
+}

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/grid/TraversalAreas.h

@@ -0,0 +1,55 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2018-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 <vector>
+
+namespace geos::operation::grid {
+
+class Traversal;
+
+class GEOS_DLL TraversalAreas {
+public:
+    /**
+     * @brief Return the total area of counter-clockwise closed rings formed by this box and the provided Coordinate sequences
+     *
+     * @param box boundary of the area to consider (Cell)
+     * @param coord_lists vector of Coordinate vectors representing points that traverse `box`. Either the first and
+     *                    last coordinate of each vector must lie on the boundary of `box`, or the coordinates
+     *                    must form a closed ring that does not intersect the boundary of `box.` Clockwise-oriented
+     *                    closed rings will be considered holes.
+     * @return total area
+     */
+    static double
+    getLeftHandArea(const geom::Envelope& box, const std::vector<const Traversal*>& coord_lists);
+
+    /**
+     * @brief Return an areal geometry representing the closed rings formed by this box and the provided Coordinate sequences
+     *
+     * @param gfact GeometryFactory to create result geometry
+     * @param box boundary of the area to consider (Cell)
+     * @param coord_lists vector of Coordinate vectors representing points that traverse `box`. Either the first and
+     *                    last coordinate of each vector must lie on the boundary of `box`, or the coordinates
+     *                    must form a closed ring that does not intersect the boundary of `box.` Clockwise-oriented
+     *                    closed rings will be considered holes.
+     * @return a Polygon or MultiPolygon geometry
+     */
+    static std::unique_ptr<geom::Geometry>
+    getLeftHandRings(const geom::GeometryFactory& gfact, const geom::Envelope& box, const std::vector<const Traversal*>& coord_lists);
+
+};
+
+}