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

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

@@ -0,0 +1,276 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2024 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 <array>
+#include <optional>
+
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+class Envelope;
+}
+}
+
+namespace geos {
+namespace algorithm {
+
+class GEOS_DLL CircularArcs {
+public:
+
+    /// Return the circle center of an arc defined by three points
+    static geom::CoordinateXY getCenter(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1,
+                                        const geom::CoordinateXY& p2);
+
+    static double getAngle(const geom::CoordinateXY& pt, const geom::CoordinateXY& center);
+
+    static geom::CoordinateXY getDirectionPoint(const geom::CoordinateXY& center, double radius, double theta, bool isCCW);
+
+    static double getMidpointAngle(double theta0, double theta2, bool isCCW);
+
+    static geom::CoordinateXY getMidpoint(const geom::CoordinateXY& p0, const geom::CoordinateXY& p2, const geom::CoordinateXY& center, double radius, bool isCCW);
+
+    /// Expand an envelope to include an arc defined by three points
+    static void expandEnvelope(geom::Envelope& e, const geom::CoordinateXY& p0, const geom::CoordinateXY& p1,
+                               const geom::CoordinateXY& p2);
+
+    /// Return the point defined by a circle center, radius, and angle
+    static geom::CoordinateXY createPoint(const geom::CoordinateXY& center, double radius, double theta);
+
+    /** Interpolate Z/M values for a point added to an arc.
+     *
+     * Interpolation will be performed between [p0, p1] or [p1, p2] depending on
+     * the position of the supplied point.
+     *
+     * @param seq CoordinateSequence containing the arc points
+     * @param i0 Index of the first point in the arc
+     * @param center The center point of the circle defining the arc
+     * @param isCCW Whether the arc is counterclockwise
+     * @param pt The point to interpolate Z/M values for
+     * @param z The interpolated Z value
+     * @param m The interpolated M value
+     */
+    static void interpolateZM(const geom::CoordinateSequence &seq, size_t i0, const geom::CoordinateXY &center, bool isCCW, geom::CoordinateXY &pt, double
+                              &z, double &m);
+
+    /** Determines whether and where a circle intersects a line.
+     *
+     * @param center The center point of the circle
+     * @param r The radius of the circle
+     * @param p0 One point defining a line of infinite length
+     * @param p1 Second point defining a line of infinite length
+     * @param isect0 Set to the first intersection point, if it exists
+     * @param isect1 Set to the second intersection point, if it exists
+     * @return The number of intersection points
+     */
+    static int
+    circleIntersectsLine(const geom::CoordinateXY& center, double r,
+                         const geom::CoordinateXY& p0, const geom::CoordinateXY& p1,
+                         geom::CoordinateXY& isect0, geom::CoordinateXY& isect1);
+
+    /** Determines whether and where a circle intersects a line segment.
+     *
+     * @param center The center point of the circle
+     * @param r The radius of the circle
+     * @param p0 The first point of the line segment
+     * @param p1 The second point of the line segment
+     * @param isect0 Set to the first intersection point, if it exists
+     * @param isect1 Set to the second intersection point, if it exists
+     * @return The number of intersection points
+     */
+    static int
+    circleIntersectsSegment(const geom::CoordinateXY& center, double r,
+                            const geom::CoordinateXY& p0, const geom::CoordinateXY& p1,
+                            geom::CoordinateXY& isect0, geom::CoordinateXY& isect1);
+
+    /** Returns whether an angle is included between two other angles.
+     *
+     * @param t0 starting angle (radians)
+     * @param t2 ending engle (radians)
+     * @param isCCW whether the interval from t0 to t2 is counterclockwise
+     * @param theta angle to test (radians)
+     * @return true if theta is included between t0 and t2
+     */
+    static bool
+    containsAngle(double t0, double t2, bool isCCW, double theta);
+
+    /** Returns whether a point on a circle is included between two arc endpoints.
+     *  It is assumed that the point lies on the circle; this is not tested.
+     *
+     * @param center The center coordinate of the circle
+     * @param p0 The first arc endpoint
+     * @param p2 The second arc endpoint
+     * @param isCCW Whether the arc between p0 and p2 is counterclockwise
+     * @param q The point to check for inclusion
+     * @return true if q is on the arc, false otherwise
+     */
+    static bool
+    containsPointOnCircle(const geom::CoordinateXY& center,
+                          const geom::CoordinateXY& p0, const geom::CoordinateXY& p2, bool isCCW,
+                          const geom::CoordinateXY& q);
+
+    /** Calculates the distance between an arc and a point.
+     *
+     * @param c The center coordinate of the circle
+     * @param r The radius of the circle
+     * @param p0 The first arc endpoint
+     * @param p2 The second arc endpoint
+     * @param isCCW Whether the arc between p0 and p2 is counterclockwise
+     * @param q The point to calculate distance to
+     * @return the distance between the arc and the point
+     */
+    static double
+    distanceArcPoint(const geom::CoordinateXY& c, double r,
+                     const geom::CoordinateXY& p0, const geom::CoordinateXY& p2, bool isCCW,
+                     const geom::CoordinateXY& q);
+
+    /** Calculates the distance between an arc and a line segment.
+     * @param c The center coordinate of the circle
+     * @param r The radius of the circle
+     * @param p0 The first arc endpoint
+     * @param p2 The second arc endpoint
+     * @param isCCW Whether the arc between p0 and p2 is counterclockwise
+     * @param q0 The first point of the line segment
+     * @param q1 The second point of the line segment
+     * @return the distance between the arc and the line segment
+     */
+    static double
+    distanceArcSegment(const geom::CoordinateXY& c, double r,
+                       const geom::CoordinateXY& p0, const geom::CoordinateXY& p2, bool isCCW,
+                       const geom::CoordinateXY& q0, const geom::CoordinateXY& q1);
+
+    /** Calculates the distance between two arcs.
+     *
+     * @param ca the center coordinate of the first arc's circle
+     * @param ra the radius of the first arc's circle
+     * @param a0 the first endpoint of the first arc
+     * @param a2 the second endpoint of the first arc
+     * @param aCCW whether the first arc is counterclockwise
+     * @param cb the center coordinate of the second arc's circle
+     * @param rb the radius of the second arc's circle
+     * @param b0 the first endpoint of the second arc
+     * @param b2 the second endpoint of the second arc
+     * @param bCCW whether the second arc is counterclockwise
+     * @return the distance between the two arcs
+     */
+    static double
+    distanceArcArc(const geom::CoordinateXY& ca, double ra,
+                   const geom::CoordinateXY& a0, const geom::CoordinateXY& a2, bool aCCW,
+                   const geom::CoordinateXY& cb, double rb,
+                   const geom::CoordinateXY& b0, const geom::CoordinateXY& b2, bool bCCW);
+
+    /** Return the closest point on an arc to a specified point.
+     *
+     * @param c the center of the arc
+     * @param r the radius of the arc
+     * @param p0 the first endpoint of the arc
+     * @param p2 the second endpoint of the arc
+     * @param isCCW whether the arc is counterclockwise
+     * @param q the point to find the closest point to
+     * @return the closest point on the arc to the specified point
+     */
+    static geom::CoordinateXY
+    closestPointArcPoint(const geom::CoordinateXY& c, double r,
+                         const geom::CoordinateXY& p0, const geom::CoordinateXY& p2,
+                         bool isCCW, const geom::CoordinateXY &q);
+
+    /** Return the pair of points having the shortest distance between an arc and a line segment
+     *
+     * @param c the center of the arc
+     * @param r the radius of the arc
+     * @param p0 the first endpoint of the arc
+     * @param p2 the second endpoint of the arc
+     * @param isCCW whether the arc is counterclockwise
+     * @param q0 the first endpoint of the line segment
+     * @param q1 the second endpoint of the line segment
+     * @return array whose first element is a point on the arc and second element is a point on the line segment
+     */
+    static std::array<geom::CoordinateXY, 2>
+    closestPointsArcSegment(const geom::CoordinateXY& c, double r,
+                            const geom::CoordinateXY& p0, const geom::CoordinateXY& p2, bool isCCW, const geom::CoordinateXY& q0, const geom::CoordinateXY& q1);
+
+
+    /** Return the pair of points having the shortest distance between two arcs
+     *
+     * @param ca the center of the first arc
+     * @param ra the radius of the first arc
+     * @param a0 the first endpoint of the first arc
+     * @param a2 the second endpoint of the first arc
+     * @param aCCW whether the first arc is counterclockwise
+     * @param cb the center of the second arc
+     * @param rb the radius of the second arc
+     * @param b0 the first endpoint of the second arc
+     * @param b2 the second endpoint of the second arc
+     * @param bCCW whether the second arc is counterclockwise
+     * @return array whose first element is a point on the first arc and second element is a point on the second arc
+     */
+    static std::array<geom::CoordinateXY, 2> closestPointsArcArc(const geom::CoordinateXY& ca,
+        double ra,
+        const geom::CoordinateXY& a0,
+        const geom::CoordinateXY& a2,
+        bool aCCW,
+        const geom::CoordinateXY& cb,
+        double rb,
+        const geom::CoordinateXY& b0,
+        const geom::CoordinateXY& b2,
+        bool bCCW);
+
+    /** Returns a single XY point of intersection between two cocircular arcs, if one exists.
+     *
+     * To identify all intersection point(s) and/or arc(s), with handling of Z and M ordinates, use CircularArcIntersector.
+     *
+     * @param center the center coordinate of the arcs
+     * @param radius the radius of the arcs
+     * @param a0 the first endpoint of the first arc
+     * @param a2 the second endpoint of the first arc
+     * @param aCCW whether the first arc is counterclockwise
+     * @param b0 the first endpoint of the second arc
+     * @param b2 the second endpoint of the second arc
+     * @param bCCW whether the second arc is counterclockwise
+     * @return a point of intersection between the two arcs, if one exists
+     */
+    static std::optional<geom::CoordinateXY>
+    cocircularArcsIntersectionPoint(const geom::CoordinateXY& center, double radius,
+                                    const geom::CoordinateXY& a0, const geom::CoordinateXY& a2, bool aCCW,
+                                    const geom::CoordinateXY& b0, const geom::CoordinateXY& b2, bool bCCW);
+
+    /** Returns a single point of intersection between two arcs, if one exists.
+     *
+     * To identify all intersection point(s) and/or arc(s), with handling of Z and M ordinates, use CircularArcIntersector.
+     *
+     * @param ca the center of the first arc
+     * @param ra the radius of the first arc
+     * @param a0 the first endpoint of the first arc
+     * @param a2 the second endpoint of the first arc
+     * @param aCCW whether the first arc is counterclockwise
+     * @param cb the center of the second arc
+     * @param rb the radius of the second arc
+     * @param b0 the first endpoint of the second arc
+     * @param b2 the second endpoint of the second arc
+     * @param bCCW whether the second arc is counterclockwise
+     * @return a point of intersection between the two arcs, if one exists
+     */
+    static std::optional<geom::CoordinateXY>
+    arcIntersectionPoint(const geom::CoordinateXY& ca, double ra,
+                         const geom::CoordinateXY& a0, const geom::CoordinateXY& a2, bool aCCW,
+                         const geom::CoordinateXY& cb, double rb,
+                         const geom::CoordinateXY& b0, const geom::CoordinateXY& b2, bool bCCW);
+
+};
+}
+}

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

@@ -0,0 +1,211 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2005-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: algorithm/ConvexHull.java r407 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <memory>
+#include <vector>
+#include <cassert>
+
+// FIXME: avoid using Coordinate:: typedefs to avoid full include
+#include <geos/algorithm/ConvexHull.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/Geometry.h>
+#include <geos/util/UniqueCoordinateArrayFilter.h>
+#include <geos/util/CoordinateArrayFilter.h>
+
+#include "geos/util.h"
+
+#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;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Computes the convex hull of a Geometry.
+ *
+ * The convex hull is the smallest convex Geometry that contains all the
+ * points in the input Geometry.
+ *
+ * Uses the Graham Scan algorithm.
+ *
+ * Last port: algorithm/ConvexHull.java rev. 1.26 (JTS-1.7)
+ *
+ */
+class GEOS_DLL ConvexHull {
+private:
+
+    static constexpr std::size_t TUNING_REDUCE_SIZE = 50;
+
+    const geom::Geometry* inputGeom;
+    const geom::GeometryFactory* geomFactory;
+    geom::Coordinate::ConstVect inputPts;
+
+    /// Create a CoordinateSequence from the Coordinate::ConstVect
+    /// This is needed to construct the geometries.
+    /// Here coordinate copies happen
+    /// The returned object is newly allocated !NO EXCEPTION SAFE!
+    std::unique_ptr<geom::CoordinateSequence> toCoordinateSequence(geom::Coordinate::ConstVect& cv);
+
+    void computeInnerOctolateralPts(
+        const geom::Coordinate::ConstVect& src,
+        geom::Coordinate::ConstVect& tgt);
+
+    bool computeInnerOctolateralRing(
+        const geom::Coordinate::ConstVect& src,
+        geom::Coordinate::ConstVect& tgt);
+
+    /**
+     * Uses a heuristic to reduce the number of points scanned
+     * to compute the hull.
+     * The heuristic is to find a polygon guaranteed to
+     * be in (or on) the hull, and eliminate all points inside it.
+     * A quadrilateral defined by the extremal points
+     * in the four orthogonal directions
+     * can be used, but even more inclusive is
+     * to use an octilateral defined by the points in the
+     * 8 cardinal directions.
+     *
+     * Note that even if the method used to determine the polygon
+     * vertices is not 100% robust, this does not affect the
+     * robustness of the convex hull.
+     *
+     * To satisfy the requirements of the Graham Scan algorithm,
+     * the resulting array has at least 3 entries.
+     *
+     * @param pts The vector of const Coordinate pointers
+     *            to be reduced (to at least 3 elements)
+     *
+     * WARNING: the parameter will be modified
+     *
+     */
+    void reduce(geom::Coordinate::ConstVect& pts);
+
+    /// parameter will be modified
+    void padArray3(geom::Coordinate::ConstVect& pts);
+
+    /// parameter will be modified
+    void preSort(geom::Coordinate::ConstVect& pts);
+
+    /**
+     * Given two points p and q compare them with respect to their radial
+     * ordering about point o.  First checks radial ordering.
+     * If points are collinear, the comparison is based
+     * on their distance to the origin.
+     *
+     * p < q iff
+     *
+     * - ang(o-p) < ang(o-q) (e.g. o-p-q is CCW)
+     * - or ang(o-p) == ang(o-q) && dist(o,p) < dist(o,q)
+     *
+     * @param o the origin
+     * @param p a point
+     * @param q another point
+     * @return -1, 0 or 1 depending on whether p is less than,
+     * equal to or greater than q
+     */
+    int polarCompare(const geom::Coordinate& o,
+                     const geom::Coordinate& p,
+                     const geom::Coordinate& q);
+
+    void grahamScan(const geom::Coordinate::ConstVect& c,
+                    geom::Coordinate::ConstVect& ps);
+
+    /**
+     * @param  vertices  the vertices of a linear ring,
+     *                   which may or may not be
+     *                   flattened (i.e. vertices collinear)
+     *
+     * @return           a 2-vertex LineString if the vertices are
+     *                   collinear; otherwise, a Polygon with unnecessary
+     *                   (collinear) vertices removed
+     */
+    std::unique_ptr<geom::Geometry> lineOrPolygon(const geom::Coordinate::ConstVect& vertices);
+
+    /**
+     * Write in 'cleaned' a version of 'input' with collinear
+     * vertices removed.
+     */
+    void cleanRing(const geom::Coordinate::ConstVect& input,
+                   geom::Coordinate::ConstVect& cleaned);
+
+    /**
+     * @return  whether the three coordinates are collinear
+     *          and c2 lies between c1 and c3 inclusive
+     */
+    bool isBetween(
+        const geom::Coordinate& c1,
+        const geom::Coordinate& c2,
+        const geom::Coordinate& c3);
+
+    bool extractUnique(geom::Coordinate::ConstVect& pts, std::size_t maxPts);
+    std::unique_ptr<geom::Geometry> createFewPointsResult();
+
+
+
+public:
+
+    /**
+     * Create a new convex hull construction for the input Geometry.
+     */
+    ConvexHull(const geom::Geometry* newGeometry)
+        : inputGeom(newGeometry)
+        , geomFactory(newGeometry->getFactory())
+    {
+      util::ensureNoCurvedComponents(inputGeom);
+    };
+
+    ~ConvexHull() {};
+
+    /**
+     * Returns a Geometry that represents the convex hull of
+     * the input geometry.
+     * The returned geometry contains the minimal number of points
+     * needed to represent the convex hull.
+     * In particular, no more than two consecutive points
+     * will be collinear.
+     *
+     * @return if the convex hull contains 3 or more points,
+     *         a Polygon; 2 points, a LineString;
+     *         1 point, a Point; 0 points, an empty GeometryCollection.
+     */
+    std::unique_ptr<geom::Geometry> getConvexHull();
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+

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

@@ -0,0 +1,76 @@
+/**********************************************************************
+*
+ * 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 <geos/export.h>
+#include <geos/geom/CircularArc.h>
+
+namespace geos::algorithm {
+
+class GEOS_DLL CurveToLineParams {
+
+public:
+
+    CurveToLineParams() :
+      m_maxStepDegrees(4.0),
+      m_maxDeviation(DoubleInfinity) {}
+
+    CurveToLineParams& setMaxStepDegrees(double value) {
+        if (!(value > 0)) {
+            throw util::IllegalArgumentException("Step size must be positive");
+        }
+
+        m_maxStepDegrees = value;
+
+        return *this;
+    }
+
+    CurveToLineParams& setMaxDeviation(double value) {
+        if (!(value > 0)) {
+            throw util::IllegalArgumentException("Max deviation must be positive");
+        }
+
+        m_maxDeviation = value;
+
+        return *this;
+    }
+
+    static CurveToLineParams maxDeviation(double dev) {
+        return CurveToLineParams()
+          .setMaxStepDegrees(DoubleInfinity)
+          .setMaxDeviation(dev);
+    }
+
+    static CurveToLineParams stepSizeDegrees(double stepSize) {
+        return CurveToLineParams()
+          .setMaxStepDegrees(stepSize)
+          .setMaxDeviation(DoubleInfinity);
+    }
+
+    double getStepSizeDegrees(const geom::CircularArc& arc) const {
+        const double deviationRatio = 1 - m_maxDeviation / arc.getRadius();
+        const double maxStepFromDeviation = deviationRatio < 0 ? 180 : std::acos(deviationRatio) * 360 / MATH_PI;
+
+        return std::min(m_maxStepDegrees, maxStepFromDeviation);
+    }
+
+private:
+
+    double m_maxStepDegrees;
+    double m_maxDeviation;
+
+};
+
+}

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

@@ -0,0 +1,116 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2018 Paul Ramsey <pramsey@cleverlephant.ca>
+ *
+ * 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: algorithm/Distance.java @ 2017-09-04
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Functions to compute distance between basic geometric structures.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL Distance {
+public:
+
+    /**
+     * Computes the distance from a line segment AB to a line segment CD
+     *
+     * Note: NON-ROBUST!
+     *
+     * @param A
+     *          a point of one line
+     * @param B
+     *          the second point of (must be different to A)
+     * @param C
+     *          one point of the line
+     * @param D
+     *          another point of the line (must be different to A)
+     */
+    // formerly distanceLineLine
+    static double segmentToSegment(
+        const geom::CoordinateXY& A,
+        const geom::CoordinateXY& B,
+        const geom::CoordinateXY& C,
+        const geom::CoordinateXY& D);
+
+    /**
+    * Computes the distance from a point to a sequence of line segments.
+    *
+    * @param p
+    *          a point
+    * @param seq
+    *          a sequence of contiguous line segments defined by their vertices
+    * @return the minimum distance between the point and the line segments
+    */
+    static double pointToSegmentString(
+        const geom::CoordinateXY& p,
+        const geom::CoordinateSequence* seq);
+
+    /**
+    * Computes the distance from a point p to a line segment AB
+    *
+    * Note: NON-ROBUST!
+    *
+    * @param p
+    *          the point to compute the distance for
+    * @param A
+    *          one point of the line
+    * @param B
+    *          another point of the line (must be different to A)
+    * @return the distance from p to line segment AB
+    */
+    // formerly distancePointLine
+    static double pointToSegment(
+        const geom::CoordinateXY& p,
+        const geom::CoordinateXY& A,
+        const geom::CoordinateXY& B);
+
+    /**
+    * Computes the perpendicular distance from a point p to the (infinite) line
+    * containing the points AB
+    *
+    * @param p
+    *          the point to compute the distance for
+    * @param A
+    *          one point of the line
+    * @param B
+    *          another point of the line (must be different to A)
+    * @return the distance from p to line AB
+    */
+    // formerly distancePointLinePerpendicular
+    static double pointToLinePerpendicular(
+        const geom::CoordinateXY& p,
+        const geom::CoordinateXY& A,
+        const geom::CoordinateXY& B);
+
+    static double pointToLinePerpendicularSigned(
+        const geom::CoordinateXY& p,
+        const geom::CoordinateXY& A,
+        const geom::CoordinateXY& B);
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+