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

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/algorithm/LineToCurveConverter.h

@@ -0,0 +1,74 @@
+/**********************************************************************
+*
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2025-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/util/CurveBuilder.h>
+
+#include <memory>
+
+namespace geos::algorithm {
+    class LineToCurveParams;
+}
+
+namespace geos::geom {
+    class CircularArc;
+    class CoordinateSequence;
+    class Curve;
+    class GeometryFactory;
+    class LineString;
+    class SimpleCurve;
+}
+
+namespace geos::algorithm {
+
+class GEOS_DLL LineToCurveConverter {
+
+public:
+
+    /** Construct a curved geometry from the provided LineString. The provided LineToCurveParams will be used
+     *  to determine when successive vertices of the LineString can be interpreted as a circular arc.
+     */
+    static std::unique_ptr<geom::Curve> getCurved(const geom::LineString& ls, const LineToCurveParams& params);
+
+private:
+
+    explicit LineToCurveConverter(const geom::GeometryFactory& factory, bool outputZ, bool outputM);
+
+    std::unique_ptr<geom::Curve> compute(const geom::LineString& ls, const LineToCurveParams& params);
+
+    void addArc(const geom::CircularArc& arc, std::size_t stop);
+
+    void addLineCoords(const geom::CoordinateSequence& points, std::size_t from, std::size_t to);
+
+    /*
+
+    void finishArc();
+
+    void finishLine();
+
+    std::shared_ptr<geom::CoordinateSequence> lineCoords;
+    std::shared_ptr<geom::CoordinateSequence> arcCoords;
+    std::vector<std::unique_ptr<geom::SimpleCurve>> curves;
+    const geom::GeometryFactory& factory;
+    */
+    geom::util::CurveBuilder curveBuilder;
+
+    /// Declared as non-copyable
+    LineToCurveConverter(const LineToCurveConverter& other);
+    LineToCurveConverter& operator=(const LineToCurveConverter& rhs);
+};
+
+}

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/algorithm/LineToCurveParams.h

@@ -0,0 +1,79 @@
+/**********************************************************************
+*
+ * 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/constants.h>
+#include <geos/util/IllegalArgumentException.h>
+
+namespace geos::algorithm {
+
+class GEOS_DLL LineToCurveParams {
+
+public:
+
+    // Get the radius tolerance. For p[x] to be considered a continuation of the same arc,
+    // its radius must be within tol * the arc radius as computed from p[0], p[1], p[2].
+    double getRadiusTolerance() const {
+        return radiusTolerance;
+    }
+
+    // Get the maximum angle in degrees between successive vertices, measured from the circle center.
+    double getMaxAngleDegrees() const {
+        return maxAngleRadians * 180 / MATH_PI;
+    }
+
+    // Get the maximum angle in radians between two successive vertices, measured from the circle center.
+    double getMaxAngleRadians() const {
+        return maxAngleRadians;
+    }
+
+    // Get the maximum difference in sequentially calculated angles along the same arc.
+    double getMaxAngleDifferenceRadians() const {
+        return maxAngleDifferenceRadians;
+    }
+
+    void setRadiusTolerance(double tol) {
+        if (!(tol > 0)) {
+            throw geos::util::IllegalArgumentException("Radius tolerance must be positive");
+        }
+        radiusTolerance = tol;
+    }
+
+    void setMaxAngleDifferenceRadians(double tol) {
+        if (!(tol > 0)) {
+            throw geos::util::IllegalArgumentException("Angle tolerance must be positive");
+        }
+        maxAngleDifferenceRadians = tol;
+    }
+
+    void setMaxAngleDifferenceDegrees(double tol) {
+        setMaxAngleDifferenceRadians(tol * MATH_PI / 180.0);
+    }
+
+    void setMaxStepDegrees(double tol) {
+        if (!(tol > 0)) {
+            throw util::IllegalArgumentException("Angle step tolerance must be positive");
+        }
+        maxAngleRadians = tol * MATH_PI / 180.0;
+    }
+
+private:
+    double radiusTolerance{1e-6};
+    double maxAngleRadians{45.01 * MATH_PI / 180.0};
+    double maxAngleDifferenceRadians{0.01};
+};
+
+}

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/algorithm/MinimumAreaRectangle.h

@@ -0,0 +1,157 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2023 Paul Ramsey <pramsey@cleverelephant.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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <vector>
+#include <memory>
+
+// Forward declarations
+namespace geos {
+	namespace geom {
+        class CoordinateSequence;
+        class CoordinateXY;
+        class Geometry;
+        class GeometryFactory;
+        class LineSegment;
+        class LineString;
+        class Polygon;
+	}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+
+/**
+ * Computes the minimum-area rectangle enclosing a Geometry.
+ * Unlike the Envelope, the rectangle may not be axis-parallel.
+ *
+ * The first step in the algorithm is computing the convex hull of the Geometry.
+ * If the input Geometry is known to be convex, a hint can be supplied to
+ * avoid this computation.
+ *
+ * In degenerate cases the minimum enclosing geometry
+ * may be a LineString or a Point.
+ *
+ * The minimum-area enclosing rectangle does not necessarily
+ * have the minimum possible width.
+ * Use MinimumDiameter to compute this.
+ *
+ * @see MinimumDiameter
+ * @see ConvexHull
+ *
+ */
+class GEOS_DLL MinimumAreaRectangle {
+    using CoordinateSequence = geos::geom::CoordinateSequence;
+    using CoordinateXY = geos::geom::CoordinateXY;
+    using Geometry = geos::geom::Geometry;
+    using GeometryFactory = geos::geom::GeometryFactory;
+    using LineSegment = geos::geom::LineSegment;
+    using LineString = geos::geom::LineString;
+    using Polygon = geos::geom::Polygon;
+
+private:
+
+    // Members
+    const Geometry* m_inputGeom;
+    bool m_isConvex;
+
+    // Methods
+    std::unique_ptr<Geometry> getMinimumRectangle();
+
+    std::unique_ptr<Geometry> computeConvex(const Geometry* convexGeom);
+
+    /**
+    * Computes the minimum-area rectangle for a convex ring of Coordinate.
+    *
+    * This algorithm uses the "dual rotating calipers" technique.
+    * Performance is linear in the number of segments.
+    *
+    * @param ring the convex ring to scan
+    */
+    std::unique_ptr<Polygon> computeConvexRing(const CoordinateSequence* ring);
+
+    std::size_t findFurthestVertex(
+        const CoordinateSequence* pts,
+        const LineSegment& baseSeg,
+        std::size_t startIndex,
+        int orient);
+
+    bool isFurtherOrEqual(double d1, double d2, int orient);
+
+    static double orientedDistance(
+        const LineSegment& seg,
+        const CoordinateXY& p,
+        int orient);
+
+    static std::size_t getNextIndex(
+        const CoordinateSequence* ring,
+        std::size_t index);
+
+    /**
+    * Creates a line of maximum extent from the provided vertices
+    * @param pts the vertices
+    * @param factory the geometry factory
+    * @return the line of maximum extent
+    */
+    static std::unique_ptr<LineString> computeMaximumLine(
+        const CoordinateSequence* pts,
+        const GeometryFactory* factory);
+
+
+public:
+
+    /**
+    * Compute a minimum-area rectangle for a given Geometry.
+    *
+    * @param inputGeom a Geometry
+    */
+    MinimumAreaRectangle(const Geometry* inputGeom)
+        : m_inputGeom(inputGeom)
+        , m_isConvex(false)
+        {};
+
+    /**
+    * Compute a minimum rectangle for a Geometry,
+    * with a hint if the geometry is convex
+    * (e.g. a convex Polygon or LinearRing,
+    * or a two-point LineString, or a Point).
+    *
+    * @param inputGeom a Geometry which is convex
+    * @param isConvex true if the input geometry is convex
+    */
+    MinimumAreaRectangle(const Geometry* inputGeom, bool isConvex)
+        : m_inputGeom(inputGeom)
+        , m_isConvex(isConvex)
+        {};
+
+    /**
+    * Gets the minimum-area rectangular Polygon which encloses the input geometry.
+    * If the convex hull of the input is degenerate (a line or point)
+    * a LineString or Point is returned.
+    *
+    * @param geom the geometry
+    * @return the minimum rectangle enclosing the geometry
+    */
+    static std::unique_ptr<Geometry> getMinimumRectangle(const Geometry* geom);
+
+};
+
+
+} // namespace geos::algorithm
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/algorithm/MinimumBoundingCircle.h

@@ -0,0 +1,137 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2019 Paul Ramsey <pramsey@cleverelephant.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/MinimumBoundingCircle.java 2019-01-23
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/Geometry.h>
+#include <geos/geom/Point.h>
+#include <geos/geom/Triangle.h>
+
+#include <vector>
+
+// Forward declarations
+// namespace geos {
+// 	namespace geom {
+// 		class GeometryCollection;
+// 	}
+// }
+
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+class GEOS_DLL MinimumBoundingCircle {
+
+private:
+
+    // member variables
+    const geom::Geometry* input;
+    std::vector<geom::CoordinateXY> extremalPts;
+    geom::CoordinateXY centre;
+    double radius;
+
+    void computeCentre();
+    void compute();
+    void computeCirclePoints();
+    geom::CoordinateXY lowestPoint(std::vector<geom::CoordinateXY>& pts);
+    geom::CoordinateXY pointWitMinAngleWithX(std::vector<geom::CoordinateXY>& pts, geom::CoordinateXY& P);
+    geom::CoordinateXY pointWithMinAngleWithSegment(std::vector<geom::CoordinateXY>& pts,
+            geom::CoordinateXY& P, geom::CoordinateXY& Q);
+    std::vector<geom::CoordinateXY> farthestPoints(std::vector<geom::CoordinateXY>& pts);
+
+
+public:
+
+    MinimumBoundingCircle(const geom::Geometry* geom):
+        input(nullptr),
+        radius(0.0)
+    {
+        input = geom;
+        centre.setNull();
+    }
+
+    ~MinimumBoundingCircle() {};
+
+    /**
+    * Gets a geometry which represents the Minimum Bounding Circle.
+    * If the input is degenerate (empty or a single unique point),
+    * this method will return an empty geometry or a single Point geometry.
+    * Otherwise, a Polygon will be returned which approximates the
+    * Minimum Bounding Circle.
+    * (Note that because the computed polygon is only an approximation,
+    * it may not precisely contain all the input points.)
+    *
+    * @return a Geometry representing the Minimum Bounding Circle.
+    */
+    std::unique_ptr<geom::Geometry> getCircle();
+
+    /**
+    * Gets a geometry representing a line between the two farthest points
+    * in the input.
+    * These points will be two of the extremal points of the Minimum Bounding Circle.
+    * They also lie on the convex hull of the input.
+    *
+    * @return a LineString between the two farthest points of the input
+    * @return a empty LineString if the input is empty
+    * @return a Point if the input is a point
+    */
+    std::unique_ptr<geom::Geometry> getMaximumDiameter();
+
+    /**
+    * Gets a geometry representing the diameter of the computed Minimum Bounding
+    * Circle.
+    *
+    * @return the diameter LineString of the Minimum Bounding Circle
+    * @return a empty LineString if the input is empty
+    * @return a Point if the input is a point
+    */
+    std::unique_ptr<geom::Geometry> getDiameter();
+
+    /**
+    * Gets the extremal points which define the computed Minimum Bounding Circle.
+    * There may be zero, one, two or three of these points,
+    * depending on the number of points in the input
+    * and the geometry of those points.
+    *
+    * @return the points defining the Minimum Bounding Circle
+    */
+    std::vector<geom::CoordinateXY> getExtremalPoints();
+
+    /**
+    * Gets the centre point of the computed Minimum Bounding Circle.
+    *
+    * @return the centre point of the Minimum Bounding Circle
+    * @return null if the input is empty
+    */
+    geom::CoordinateXY getCentre();
+
+    /**
+    * Gets the radius of the computed Minimum Bounding Circle.
+    *
+    * @return the radius of the Minimum Bounding Circle
+    */
+    double getRadius();
+
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/algorithm/MinimumDiameter.h

@@ -0,0 +1,185 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2023 Paul Ramsey <pramsey@cleverelephant.ca>
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/LineSegment.h>
+
+#include <memory>
+#include <geos/export.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class GeometryFactory;
+class Geometry;
+class LineString;
+class CoordinateSequence;
+}
+}
+
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Computes the minimum diameter of a geom::Geometry
+ *
+ * The minimum diameter is defined to be the width of the smallest band that
+ * contains the geometry, where a band is a strip of the plane defined
+ * by two parallel lines. This can be thought of as the smallest hole
+ * that the geometry can be moved through, with a single rotation.
+ *
+ * The first step in the algorithm is computing the convex hull of the Geometry.
+ * If the input Geometry is known to be convex, a hint can be supplied to
+ * avoid this computation.
+ *
+ * This class can also be used to compute a line segment representing
+ * the minimum diameter, the supporting line segment of the minimum diameter,
+ * and a minimum-width rectangle of the input geometry.
+ * This rectangle will have width equal to the minimum diameter, and have
+ * one side parallel to the supporting segment.
+ *
+ * In degenerate cases the rectangle may be a LineString or a Point.
+ * (Note that this may not be the enclosing rectangle with minimum area;
+ * use MinimumAreaRectangle to compute this.)
+ *
+ * @see ConvexHull
+ * @see MinimumAreaRectangle
+ */
+class GEOS_DLL MinimumDiameter {
+private:
+    const geom::Geometry* inputGeom;
+    bool isConvex;
+
+    std::unique_ptr<geom::CoordinateSequence> convexHullPts;
+
+    geom::LineSegment minBaseSeg;
+    geom::Coordinate minWidthPt;
+    std::size_t minPtIndex;
+    double minWidth;
+    void computeMinimumDiameter();
+    void computeWidthConvex(const geom::Geometry* geom);
+
+    /**
+     * Compute the width information for a ring of Coordinate.
+     * Leaves the width information in the instance variables.
+     *
+     * @param pts
+     * @return
+     */
+    void computeConvexRingMinDiameter(const geom::CoordinateSequence* pts);
+
+    unsigned int findMaxPerpDistance(const geom::CoordinateSequence* pts,
+                                     const geom::LineSegment* seg, unsigned int startIndex);
+
+    static unsigned int getNextIndex(const geom::CoordinateSequence* pts,
+                                     unsigned int index);
+
+    static double computeC(double a, double b, const geom::Coordinate& p);
+
+    static geom::LineSegment computeSegmentForLine(double a, double b, double c);
+
+    static std::unique_ptr<geom::Geometry> computeMaximumLine(
+                        const geom::CoordinateSequence* pts,
+                        const geom::GeometryFactory* factory);
+
+public:
+    ~MinimumDiameter() = default;
+
+    /** \brief
+     * Compute a minimum diameter for a given [Geometry](@ref geom::Geometry).
+     *
+     * @param newInputGeom a Geometry
+     */
+    MinimumDiameter(const geom::Geometry* newInputGeom);
+
+    /** \brief
+     * Compute a minimum diameter for a given Geometry,
+     * with a hint if the Geometry is convex
+     * (e.g. a convex Polygon or LinearRing,
+     * or a two-point LineString, or a Point).
+     *
+     * @param newInputGeom a Geometry which is convex
+     * @param newIsConvex `true` if the input geometry is convex
+     */
+    MinimumDiameter(const geom::Geometry* newInputGeom,
+                    const bool newIsConvex);
+
+    /** \brief
+     * Gets the length of the minimum diameter of the input Geometry.
+     *
+     * @return the length of the minimum diameter
+     */
+    double getLength();
+
+    /** \brief
+     * Gets the geom::Coordinate forming one end of the minimum diameter.
+     *
+     * @return a coordinate forming one end of the minimum diameter
+     */
+    const geom::Coordinate& getWidthCoordinate();
+
+    /** \brief
+     * Gets the segment forming the base of the minimum diameter.
+     *
+     * @return the segment forming the base of the minimum diameter
+     */
+    std::unique_ptr<geom::LineString> getSupportingSegment();
+
+    /** \brief
+     * Gets a LineString which is a minimum diameter.
+     *
+     * @return a LineString which is a minimum diameter
+     */
+    std::unique_ptr<geom::LineString> getDiameter();
+
+    /** \brief
+     * Gets the rectangular Polygon which encloses the input geometry
+     * and is based on the minimum diameter supporting segment.
+     *
+     * The rectangle has width equal to the minimum diameter, and a longer
+     * length. If the convex hill of the input is degenerate (a line or point)
+     * a LineString or Point is returned.
+     * This is not necessarily the rectangle with minimum area.
+     * Use MinimumAreaRectangle to compute this.
+     *
+     * @return the the minimum-width rectangle enclosing the geometry
+     * @see MinimumAreaRectangle
+     */
+    std::unique_ptr<geom::Geometry> getMinimumRectangle();
+
+    /** \brief
+     * Gets the minimum rectangle enclosing a geometry.
+     *
+     * @param geom the geometry
+     * @return a rectangle enclosing the input (or a line or point if degenerate)
+     * @see MinimumAreaRectangle
+    */
+    static std::unique_ptr<geom::Geometry> getMinimumRectangle(geom::Geometry* geom);
+
+    /** \brief
+     * Gets the length of the minimum diameter enclosing a geometry.
+     * @param geom the geometry
+     * @return the length of the minimum diameter of the geometry
+     */
+    static std::unique_ptr<geom::Geometry> getMinimumDiameter(geom::Geometry* geom);
+
+};
+
+} // namespace geos::algorithm
+} // namespace geos

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/algorithm/NotRepresentableException.h

@@ -0,0 +1,43 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <string>
+#include <geos/util/GEOSException.h>
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/**
+ * \class NotRepresentableException
+ * \brief
+ * Indicates that a HCoordinate has been computed which is
+ * not representable on the Cartesian plane.
+ *
+ * @version 1.4
+ * @see HCoordinate
+ */
+class GEOS_DLL NotRepresentableException: public util::GEOSException {
+public:
+    NotRepresentableException();
+    NotRepresentableException(std::string msg);
+    ~NotRepresentableException() noexcept override {}
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+