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

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

@@ -0,0 +1,157 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2013 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: algorithm/Centroid.java r728 (JTS-0.13+)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h> // for composition
+#include <memory> // for std::unique_ptr
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class Polygon;
+class CoordinateSequence;
+}
+}
+
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Computes the centroid of a [Geometry](@ref geom::Geometry) of any dimension.
+ *
+ * If the geometry is nomimally of higher dimension, but contains only
+ * components having a lower effective dimension (i.e. zero length or area),
+ * the centroid will be computed appropriately.
+ *
+ * ### Algorithm #
+ *
+ * - **Dimension = 2** - Based on the usual algorithm for calculating
+ *     the centroid as a weighted sum of the centroids
+ *     of a decomposition of the area into (possibly overlapping) triangles.
+ *     The algorithm has been extended to handle holes and multi-polygons.
+ *     See http://www.faqs.org/faqs/graphics/algorithms-faq/
+ *     for further details of the basic approach.
+ * - **Dimension = 1** - Computes the average of the midpoints
+ *     of all line segments weighted by the segment length.
+ * - **Dimension = 0** - Compute the average coordinate over all points.
+ *
+ * If the input geometries are empty, a `null` Coordinate is returned.
+ *
+ */
+class GEOS_DLL Centroid {
+
+public:
+
+    /** \brief
+     * Computes the centroid point of a geometry.
+     *
+     * @param geom the geometry to use
+     * @param cent will be set to the centroid point, if any
+     *
+     * @return `true` if a centroid could be computed,
+     *         `false` otherwise (empty geom)
+     */
+    static bool getCentroid(const geom::Geometry& geom, geom::CoordinateXY& cent);
+
+    /** \brief
+     * Creates a new instance for computing the centroid of a geometry
+     */
+    Centroid(const geom::Geometry& geom)
+        :
+        areasum2(0.0),
+        totalLength(0.0),
+        ptCount(0)
+    {
+        add(geom);
+    }
+
+    /** \brief
+     * Gets the computed centroid.
+     *
+     * @param cent will be set to the centroid point, if any
+     *
+     * @return `true` if a centroid could be computed,
+     *         `false` otherwise (empty geom)
+     */
+    bool getCentroid(geom::CoordinateXY& cent) const;
+
+private:
+
+    std::unique_ptr<geom::CoordinateXY> areaBasePt;
+    geom::CoordinateXY triangleCent3;
+    geom::CoordinateXY cg3;
+    geom::CoordinateXY lineCentSum;
+    geom::CoordinateXY ptCentSum;
+    double areasum2;
+    double totalLength;
+    int ptCount;
+
+    /**
+     * Adds a Geometry to the centroid total.
+     *
+     * @param geom the geometry to add
+     */
+    void add(const geom::Geometry& geom);
+
+    void setAreaBasePoint(const geom::CoordinateXY& basePt);
+
+    void add(const geom::Polygon& poly);
+
+    void addShell(const geom::CoordinateSequence& pts);
+
+    void addHole(const geom::CoordinateSequence& pts);
+
+    void addTriangle(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1, const geom::CoordinateXY& p2,
+                     bool isPositiveArea);
+
+    /**
+     * Computes three times the centroid of the triangle p1-p2-p3.
+     * The factor of 3 is
+     * left in to permit division to be avoided until later.
+     */
+    static void centroid3(const geom::CoordinateXY& p1, const geom::CoordinateXY& p2, const geom::CoordinateXY& p3,
+                          geom::CoordinateXY& c);
+
+    /**
+     * Returns twice the signed area of the triangle p1-p2-p3.
+     * The area is positive if the triangle is oriented CCW, and negative if CW.
+     */
+    static double area2(const geom::CoordinateXY& p1, const geom::CoordinateXY& p2, const geom::CoordinateXY& p3);
+
+    /**
+     * Adds the line segments defined by an array of coordinates
+     * to the linear centroid accumulators.
+     *
+     * @param pts an array of {@link Coordinate}s
+     */
+    void addLineSegments(const geom::CoordinateSequence& pts);
+
+    /**
+     * Adds a point to the point centroid accumulator.
+     * @param pt a {@link Coordinate}
+     */
+    void addPoint(const geom::CoordinateXY& pt);
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+

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

@@ -0,0 +1,146 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2024-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 <array>
+#include <cstdint>
+
+#include <geos/export.h>
+#include <geos/algorithm/LineIntersector.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CircularArc.h>
+
+namespace geos::algorithm {
+
+class GEOS_DLL CircularArcIntersector {
+public:
+    using CoordinateXY = geom::CoordinateXY;
+    using CoordinateXYZM = geom::CoordinateXYZM;
+    using CircularArc = geom::CircularArc;
+    using Envelope = geom::Envelope;
+
+    enum intersection_type : uint8_t {
+        NO_INTERSECTION = 0,
+        ONE_POINT_INTERSECTION = 1,
+        TWO_POINT_INTERSECTION = 2,
+        COCIRCULAR_INTERSECTION = 3,
+    };
+
+    explicit CircularArcIntersector(const geom::PrecisionModel* pm = nullptr)
+        : precisionModel(pm)
+    {}
+
+    intersection_type getResult() const
+    {
+        return result;
+    }
+
+    const CoordinateXYZM& getPoint(std::uint8_t i) const
+    {
+        return intPt[i];
+    }
+
+    const CircularArc& getArc(std::uint8_t i) const
+    {
+        return intArc[i];
+    }
+
+    std::uint8_t getNumPoints() const
+    {
+        return nPt;
+    }
+
+    std::uint8_t getNumArcs() const
+    {
+        return nArc;
+    }
+
+    /** Determines whether and where a circular arc intersects a line segment.
+     *
+     * Sets the appropriate value of intersection_type and stores the intersection points, if any.
+     *
+     * @param arc The circular arc
+     * @param seq A CoordinateSequence containing the points of the line segment
+     * @param pos0 The index of the first point in the line segment
+     * @param pos1 The index of the second point in the line segment
+     * @param useSegEndpoints Whether to preferentially take Z/M values from
+     *        the endpoints of the line segment rather than the arc.
+     */
+    void intersects(const CircularArc& arc, const geom::CoordinateSequence& seq, std::size_t pos0, std::size_t pos1, bool useSegEndpoints);
+
+    /** Determines whether and where two circular arcs intersect.
+     *
+     * 	Sets the appropriate value of intersection_type and stores the intersection
+     *  points and/or arcs, if any.
+     */
+    void intersects(const CircularArc& arc1, const CircularArc& arc2);
+
+    /** Determines whether and where two line segments intersect
+     *
+     * 	Sets the appropriate value of intersection_type and stores the intersection
+     *  points, if any.
+     */
+    void intersects(const geom::CoordinateSequence& p, std::size_t p0, std::size_t p1,
+                    const geom::CoordinateSequence& q, std::size_t q0, std::size_t q1);
+
+private:
+    void reset() {
+        nPt = 0;
+        nArc = 0;
+    }
+
+    /** Add an arc intersection of two cocircular arcs between the specified angles.
+     *
+     * The input arcs are provided so that Z/M values can be assigned to the created arc.
+     * When the endpoints of the new arc correspond with those of the inputs, Z/M values
+     * will be preferentially taken from arc1.
+     */
+    void addCocircularIntersection(double startAngle, double endAngle, int orientation, const CircularArc& arc1, const CircularArc& arc2);
+
+    /** Add a point intersection between two arcs.
+     *
+     * The input arcs are provided so that Z/M values can be assigned to the intersection point.
+     * When the intersection point corresponds matches one of the input arc endpoints,
+     * Z/M values will be taken from that endpoint, with arc1 having priority over arc2.
+     * If the intersection point does not equal the endpoint of either arc, its Z/M values
+     * will be interpolated.
+     */
+    void addArcArcIntersectionPoint(const CoordinateXY& computedIntPt, const CircularArc& arc1, const CircularArc& arc2);
+
+    /** Add a point intersection between an arc and a segment.
+     *
+     * The input arc and segment are provided so that Z/M values can be assigned to the intersection point.
+     * When the intersection point corresponds to the arc or segment endpoints, Z/M values
+     * will be taken from that endpoint. Priority will be given to the arc endpoints unless
+     * `useSegEndpoint` is true. If the intersection point does not equal the endpoint of the arc
+     * or the segment, its Z/M values will be interpolated.
+     */
+    void addArcSegmentIntersectionPoint(const CoordinateXY& computedIntPt, const CircularArc& lhs,
+        const geom::CoordinateSequence& seq, std::size_t pos0, std::size_t pos1, bool useSegEndpoints);
+
+    void computeCocircularIntersection(const CircularArc& arc1, const CircularArc& arc2);
+
+    /** Checks whether the provided point has already been recorded as an intersection point. */
+    bool hasIntersection(const geom::CoordinateXY& p) const;
+
+    std::array<CoordinateXYZM, 2> intPt;
+    std::array<CircularArc, 2> intArc;
+    const geom::PrecisionModel* precisionModel;
+    intersection_type result = NO_INTERSECTION;
+    std::uint8_t nPt = 0;
+    std::uint8_t nArc = 0;
+};
+
+}

package/dist/prebuilt/linuxmusl-x64-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);
+
+};
+}
+}