@crossbind/port-geos-ios 2.0.0-beta.50

package/dist/prebuilt/ios-iphonesimulator-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/ios-iphonesimulator-mt-release/include/geos/operation/grid/PerimeterDistance.h

@@ -0,0 +1,49 @@
+/**********************************************************************
+ *
+ * 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 `perimeter_distance`
+     *  function.
+     */
+    static double
+    getPerimeterDistanceCCW(double measure1, double measure2, double perimeter);
+
+};
+
+}

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/operation/grid/Side.h

@@ -0,0 +1,33 @@
+/**********************************************************************
+ *
+ * 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
+};
+
+std::ostream&
+operator<<(std::ostream& os, const Side& s);
+
+}

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/operation/grid/Traversal.h

@@ -0,0 +1,76 @@
+/**********************************************************************
+ *
+ * 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 <vector>
+
+#include <geos/geom/Coordinate.h>
+#include <geos/operation/grid/Side.h>
+
+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 Traversal
+{
+  public:
+    Traversal()
+      : m_entry{ Side::NONE }
+      , m_exit{ Side::NONE }
+    {
+    }
+
+    bool isClosedRing() 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);
+
+    /// 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& 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; }
+
+  private:
+    std::vector<geom::CoordinateXY> m_coords;
+    Side m_entry;
+    Side m_exit;
+};
+
+}

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/operation/grid/TraversalAreas.h

@@ -0,0 +1,53 @@
+/**********************************************************************
+ *
+ * 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 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 std::vector<geom::CoordinateXY>*>& 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 std::vector<geom::CoordinateXY>*>& coord_lists);
+
+};
+
+}

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/operation/intersection/Rectangle.h

@@ -0,0 +1,236 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2014 Mika Heiskanen <mika.heiskanen@fmi.fi>
+ *
+ * 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>
+
+#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 GeometryFactory;
+class Geometry;
+class Polygon;
+class LinearRing;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace intersection { // geos::operation::intersection
+
+/**
+ * \brief Clipping rectangle
+ *
+ * A clipping rectangle defines the boundaries of the rectangle
+ * by defining the limiting x- and y-coordinates. The clipping
+ * rectangle must be non-empty. In addition, methods are provided
+ * for specifying the location of a given coordinate with respect
+ * to the clipping rectangle similarly to the Cohen-Sutherland
+ * clipping algorithm.
+ *
+ */
+
+class GEOS_DLL Rectangle {
+public:
+
+    /**
+     * \brief Construct a clipping rectangle
+     *
+     * @param x1 x-coordinate of the left edge
+     * @param y1 y-coordinate of the bottom edge
+     * @param x2 x-coordinate of the right edge
+     * @param y2 y-coordinate of the right edge
+     * @throws IllegalArgumentException if the rectangle is empty
+     */
+
+    Rectangle(double x1, double y1, double x2, double y2);
+
+    /**
+     * @return the minimum x-coordinate of the rectangle
+     */
+    double
+    xmin() const
+    {
+        return xMin;
+    }
+
+    /**
+     * @return the minimum y-coordinate of the rectangle
+     */
+
+    double
+    ymin() const
+    {
+        return yMin;
+    }
+
+
+    /**
+     * @return the maximum x-coordinate of the rectangle
+     */
+
+    double
+    xmax() const
+    {
+        return xMax;
+    }
+
+
+    /**
+     * @return the maximum y-coordinate of the rectangle
+     */
+
+    double
+    ymax() const
+    {
+        return yMax;
+    }
+
+    /**
+     * @return the rectangle as a polygon geometry
+     *
+     * @note Ownership transferred to caller
+     */
+    std::unique_ptr<geom::Polygon> toPolygon(const geom::GeometryFactory& f) const;
+
+    std::unique_ptr<geom::LinearRing> toLinearRing(const geom::GeometryFactory& f) const;
+
+    /**
+     * @brief Position with respect to a clipping rectangle
+     */
+
+    enum Position {
+        Inside    = 1,
+        Outside   = 2,
+
+        Left        = 4,
+        Top         = 8,
+        Right       = 16,
+        Bottom      = 32,
+
+        TopLeft     = Top | Left,               // 12
+        TopRight    = Top | Right,              // 24
+        BottomLeft  = Bottom | Left,            // 36
+        BottomRight = Bottom | Right            // 48
+    };
+
+    /**
+     * @brief Test if the given position is on a Rectangle edge
+     * @param pos Rectangle::Position
+     * @return `true`, if the position is on an edge
+     */
+
+    static bool
+    onEdge(Position pos)
+    {
+        return (pos > Outside);
+    }
+
+    /**
+     * @brief Test if the given positions are on the same Rectangle edge
+     * @param pos1 [Position](@ref Rectangle::Position) of first coordinate
+     * @param pos2 [Position](@ref Rectangle::Position) of second coordinate
+     * @return `true`, if the positions are on the same edge
+     */
+
+    static bool
+    onSameEdge(Position pos1, Position pos2)
+    {
+        return onEdge(Position(pos1 & pos2));
+    }
+
+    /**
+     * @brief Establish position of coordinate with respect to a Rectangle
+     * @param x x-coordinate
+     * @param y y-coordinate
+     * @return [Position](@ref Rectangle::Position) of the coordinate
+     */
+
+    Position
+    position(double x, double y) const
+    {
+        // We assume the point to be inside and test it first
+        if(x > xMin && x < xMax && y > yMin && y < yMax) {
+            return Inside;
+        }
+        // Next we assume the point to be outside and test it next
+        if(x < xMin || x > xMax || y < yMin || y > yMax) {
+            return Outside;
+        }
+        // Slower cases
+        unsigned int pos = 0;
+        if(x == xMin) {
+            pos |= Left;
+        }
+        else if(x == xMax) {
+            pos |= Right;
+        }
+        if(y == yMin) {
+            pos |= Bottom;
+        }
+        else if(y == yMax) {
+            pos |= Top;
+        }
+        return Position(pos);
+    }
+
+    /**
+     * @brief Next edge in clock-wise direction
+     * @param pos [Position](@ref Rectangle::Position)
+     * @return next [Position](@ref Rectangle::Position) in clock-wise direction
+     */
+
+    static Position
+    nextEdge(Position pos)
+    {
+        switch(pos) {
+        case BottomLeft:
+        case Left:
+            return Top;
+        case TopLeft:
+        case Top:
+            return Right;
+        case TopRight:
+        case Right:
+            return Bottom;
+        case BottomRight:
+        case Bottom:
+            return Left;
+        /* silences compiler warnings, Inside & Outside are not handled explicitly */
+        default:
+            return pos;
+        }
+    }
+
+private:
+
+    Rectangle();
+    double xMin;
+    double yMin;
+    double xMax;
+    double yMax;
+
+}; // class RectangleIntersection
+
+} // namespace geos::operation::intersection
+} // namespace geos::operation
+} // namespace geos
+