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

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

@@ -0,0 +1,100 @@
+/**********************************************************************
+ *
+ * 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/HCoordinate.java r386 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <iosfwd>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+
+/** \brief
+ * Represents a homogeneous coordinate in a 2-D coordinate space.
+ *
+ * HCoordinate are used as a clean way
+ * of computing intersections between line segments.
+ */
+class GEOS_DLL HCoordinate {
+
+public:
+
+    friend std::ostream& operator<< (std::ostream& o, const HCoordinate& c);
+
+    /** \brief
+     * Computes the (approximate) intersection point between two line
+     * segments using homogeneous coordinates.
+     *
+     * @note this algorithm is  not numerically stable; i.e. it can
+     * produce intersection points which lie outside the envelope of the
+     * line segments themselves. In order to increase the precision of
+     * the calculation input points should be normalized before
+     * passing them to this routine.
+     */
+    static void intersection(const geom::Coordinate& p1,
+                             const geom::Coordinate& p2,
+                             const geom::Coordinate& q1,
+                             const geom::Coordinate& q2,
+                             geom::Coordinate& ret);
+
+    double x, y, w;
+
+    HCoordinate();
+
+    HCoordinate(double _x, double _y, double _w);
+
+    HCoordinate(const geom::Coordinate& p);
+
+    /** \brief
+     * Constructs a homogeneous coordinate which is the intersection
+     * of the lines define by the homogeneous coordinates represented
+     * by two [Coordinates](@ref geom::Coordinate).
+     *
+     * @param p1
+     * @param p2
+     */
+    HCoordinate(const geom::Coordinate& p1, const geom::Coordinate& p2);
+
+    HCoordinate(const geom::Coordinate& p1, const geom::Coordinate& p2,
+                const geom::Coordinate& q1, const geom::Coordinate& q2);
+
+    HCoordinate(const HCoordinate& p1, const HCoordinate& p2);
+
+    double getX() const;
+
+    double getY() const;
+
+    void getCoordinate(geom::Coordinate& ret) const;
+
+};
+
+std::ostream& operator<< (std::ostream& o, const HCoordinate& c);
+
+} // namespace geos::algorithm
+} // namespace geos
+

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

@@ -0,0 +1,110 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2019 Martin Davis <mtnclimb@gmail.com>
+ *
+ * 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/InteriorPointArea.java (JTS-1.17+)
+ * https://github.com/locationtech/jts/commit/a140ca30cc51be4f65c950a30b0a8f51a6df75ba
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class Polygon;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Computes a point in the interior of an areal geometry.
+ * The point will lie in the geometry interior
+ * in all except certain pathological cases.
+ *
+ * <h2>Algorithm</h2>
+ * For each input polygon:
+ * <ul>
+ * <li>Determine a horizontal scan line on which the interior
+ * point will be located.
+ * To increase the chance of the scan line
+ * having non-zero-width intersection with the polygon
+ * the scan line Y ordinate is chosen to be near the centre of the polygon's
+ * Y extent but distinct from all of vertex Y ordinates.
+ * <li>Compute the sections of the scan line
+ * which lie in the interior of the polygon.
+ * <li>Choose the widest interior section
+ * and take its midpoint as the interior point.
+ * </ul>
+ * The final interior point is chosen as
+ * the one occurring in the widest interior section.
+ * <p>
+ * This algorithm is a tradeoff between performance
+ * and point quality (where points further from the geometry
+ * boundary are considered to be higher quality)
+ * Priority is given to performance.
+ * This means that the computed interior point
+ * may not be suitable for some uses
+ * (such as label positioning).
+ * <p>
+ * The algorithm handles some kinds of invalid/degenerate geometry,
+ * including zero-area and self-intersecting polygons.
+ * <p>
+ * Empty geometry is handled by returning a <code>null</code> point.
+ *
+ * <h3>KNOWN BUGS</h3>
+ * <ul>
+ * <li>If a fixed precision model is used, in some cases this method may return
+ * a point which does not lie in the interior.
+ * <li>If the input polygon is <i>extremely</i> narrow the computed point
+ * may not lie in the interior of the polygon.
+ * </ul>
+ */
+class GEOS_DLL InteriorPointArea {
+
+public:
+    /**
+     * Creates a new interior point finder
+     * for an areal geometry.
+     *
+     * @param g an areal geometry
+     */
+    InteriorPointArea(const geom::Geometry* g);
+
+    /**
+     * Gets the computed interior point.
+     *
+     * @return the coordinate of an interior point
+     *  or <code>null</code> if the input geometry is empty
+     */
+    bool getInteriorPoint(geom::Coordinate& ret) const;
+
+private:
+    geom::Coordinate interiorPoint;
+    double maxWidth;
+
+    void process(const geom::Geometry* geom);
+
+    void processPolygon(const geom::Polygon* polygon);
+
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+

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

@@ -0,0 +1,79 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************
+ *
+ * Last port: algorithm/InteriorPointLine.java r317 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class CoordinateSequence;
+}
+}
+
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Computes a point in the interior of an linear geometry.
+ *
+ * <h2>Algorithm</h2>
+ *
+ * - Find an interior vertex which is closest to
+ *   the centroid of the linestring.
+ * - If there is no interior vertex, find the endpoint which is
+ *   closest to the centroid.
+ */
+class GEOS_DLL InteriorPointLine {
+public:
+
+    InteriorPointLine(const geom::Geometry* g);
+    //Coordinate* getInteriorPoint() const;
+
+    bool getInteriorPoint(geom::Coordinate& ret) const;
+
+private:
+
+    bool hasInterior;
+
+    geom::Coordinate centroid;
+
+    double minDistance;
+
+    geom::Coordinate interiorPoint;
+
+    void addInterior(const geom::Geometry* geom);
+
+    void addInterior(const geom::CoordinateSequence* pts);
+
+    void addEndpoints(const geom::Geometry* geom);
+
+    void addEndpoints(const geom::CoordinateSequence* pts);
+
+    void add(const geom::Coordinate& point);
+
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+

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

@@ -0,0 +1,73 @@
+/**********************************************************************
+ *
+ * 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 <geos/geom/Coordinate.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/**
+ * \class InteriorPointPoint
+ * \brief
+ * Computes a point in the interior of an point geometry.
+ *
+ * Algorithm:
+ *
+ * Find a point which is closest to the centroid of the geometry.
+ */
+class GEOS_DLL InteriorPointPoint {
+private:
+
+    bool hasInterior;
+
+    geom::CoordinateXY centroid;
+
+    double minDistance;
+
+    geom::Coordinate interiorPoint;
+
+    /**
+     * Tests the point(s) defined by a Geometry for the best inside point.
+     * If a Geometry is not of dimension 0 it is not tested.
+     * @param geom the geometry to add
+     */
+    void add(const geom::Geometry* geom);
+
+    void add(const geom::CoordinateXY* point);
+
+public:
+
+    InteriorPointPoint(const geom::Geometry* g);
+
+    ~InteriorPointPoint() {}
+
+    bool getInteriorPoint(geom::CoordinateXY& ret) const;
+
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+
+

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

@@ -0,0 +1,197 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2016 Vivid Solutions Inc.
+ * Copyright (C) 2023 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 <cmath>
+
+namespace geos {
+namespace algorithm {
+
+class GEOS_DLL Interpolate {
+
+private:
+
+    template<geom::Ordinate Ord, typename CoordType>
+    static double
+    interpolate(const geom::CoordinateXY& p, const CoordType& p1, const CoordType& p2)
+    {
+        double p1z = p1.template get<Ord>();
+        double p2z = p2.template get<Ord>();
+
+        if (std::isnan(p1z)) {
+            return p2z; // may be NaN
+        }
+        if (std::isnan(p2z)) {
+            return p1z; // may be NaN
+        }
+        if (p.equals2D(p1)) {
+            return p1z; // not NaN
+        }
+        if (p.equals2D(p2)) {
+            return p2z; // not NaN
+        }
+        double dz = p2z - p1z;
+        if (dz == 0.0) {
+            return p1z;
+        }
+
+        // interpolate Z from distance of p along p1-p2
+        double dx = (p2.x - p1.x);
+        double dy = (p2.y - p1.y);
+        // seg has non-zero length since p1 < p < p2
+        double seglen = (dx * dx + dy * dy);
+        double xoff = (p.x - p1.x);
+        double yoff = (p.y - p1.y);
+        double plen = (xoff * xoff + yoff * yoff);
+        double frac = std::sqrt(plen / seglen);
+        double zoff = dz * frac;
+        double zInterpolated = p1z + zoff;
+
+        return zInterpolated;
+    }
+
+    template<geom::Ordinate Ord, typename C1, typename C2>
+    static double
+    interpolate(const geom::CoordinateXY& p, const C1& p1, const C1& p2, const C2& q1, const C2& q2)
+    {
+        double zp = interpolate<Ord>(p, p1, p2);
+        double zq = interpolate<Ord>(p, q1, q2);
+
+        if (std::isnan(zp)) {
+          return zq; // may be NaN
+        }
+        if (std::isnan(zq)) {
+          return zp; // may be NaN
+        }
+
+        return (zp + zq) / 2.0;
+    }
+
+    template<geom::Ordinate Ord, typename C1, typename C2>
+    static double
+    get(const C1& p, const C2& q)
+    {
+        double a = p.template get<Ord>();
+        double b = q.template get<Ord>();
+        if (std::isnan(a)) {
+            return b;
+        }
+        return a;
+    }
+
+    template<geom::Ordinate Ord, typename C1, typename C2>
+    static double
+    getOrInterpolate(const C1& p, const C2& p1, const C2& p2)
+    {
+        double z = p.template get<Ord>();
+        if (!std::isnan(z)) return z;
+        return interpolate<Ord>(p, p1, p2);
+    }
+
+    static double
+    interpolate(const geom::CoordinateXY& p, const geom::CoordinateXY& p1, const geom::CoordinateXY& p2)
+    {
+        (void) p; (void) p1; (void) p2;
+        return DoubleNotANumber;
+    }
+
+public:
+    /// Interpolate a Z value for a coordinate from two other coordinates.
+    template<typename CoordType>
+    static double
+    zInterpolate(const geom::CoordinateXY& p, const CoordType& p1, const CoordType& p2)
+    {
+        return interpolate<geom::Ordinate::Z>(p, p1, p2);
+    }
+
+    /// Calculate an average interpolated Z value from two pairs of other coordinates.
+    template<typename C1, typename C2>
+    static double
+    zInterpolate(const geom::CoordinateXY& p, const C1& p1, const C1& p2, const C2& q1, const C2& q2)
+    {
+        return interpolate<geom::Ordinate::Z>(p, p1, p2, q1, q2);
+    }
+
+    /// Interpolate an M value for a coordinate from two other coordinates.
+    template<typename CoordType>
+    static double
+    mInterpolate(const geom::CoordinateXY& p, const CoordType& p1, const CoordType& p2)
+    {
+        return interpolate<geom::Ordinate::M>(p, p1, p2);
+    }
+
+    /// Calculate an average interpolated M value from two pairs of other coordinates.
+    template<typename C1, typename C2>
+    static double
+    mInterpolate(const geom::CoordinateXY& p, const C1& p1, const C1& p2, const C2& q1, const C2& q2)
+    {
+        return interpolate<geom::Ordinate::M>(p, p1, p2, q1, q2);
+    }
+
+    /// Return the first non-NaN Z value from two coordinates, or NaN if both values are NaN.
+    template<typename C1, typename C2>
+    static double
+    zGet(const C1& p, const C2& q)
+    {
+        return get<geom::Ordinate::Z>(p, q);
+    }
+
+    /// Return the first non-NaN M value from two coordinates, or NaN if both values are NaN.
+    template<typename C1, typename C2>
+    static double
+    mGet(const C1& p, const C2& q)
+    {
+        return get<geom::Ordinate::M>(p, q);
+    }
+
+    /// Return a coordinate's non-NaN Z value or interpolate it from two other coordinates if it is NaN.
+    template<typename C1, typename C2>
+    static double
+    zGetOrInterpolate(const C1& p, const C2& p1, const C2& p2)
+    {
+        return getOrInterpolate<geom::Ordinate::Z>(p, p1, p2);
+    }
+
+    /// Return a coordinate's non-NaN M value or interpolate it from two other coordinates if it is NaN.
+    template<typename C1, typename C2>
+    static double
+    mGetOrInterpolate(const C1& p, const C2& p1, const C2& p2)
+    {
+        return getOrInterpolate<geom::Ordinate::M>(p, p1, p2);
+    }
+
+    static double
+    getOrAverage(double a, double b)
+    {
+        if (std::isnan(a)) {
+            return b;
+        }
+
+        if (std::isnan(b)) {
+            return a;
+        }
+
+        return 0.5*(a+b);
+    }
+
+
+};
+
+}
+}

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

@@ -0,0 +1,84 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2019 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+
+namespace geos {
+namespace algorithm {
+
+
+/** \brief
+ * Functions to compute intersection points between lines and line segments.
+ *
+ * In general it is not possible to compute
+ * the intersection point of two lines exactly, due to numerical roundoff.
+ * This is particularly true when the lines are nearly parallel.
+ * These routines uses numerical conditioning on the input values
+ * to ensure that the computed value is very close to the correct value.
+ *
+ * The Z-ordinate is ignored, and not populated.
+ */
+class GEOS_DLL Intersection {
+
+public:
+
+/** \brief
+ * Computes the intersection point of two lines.
+ * If the lines are parallel or collinear this case is detected
+ * and <code>null</code> is returned.
+ *
+ * @param p1 an endpoint of line 1
+ * @param p2 an endpoint of line 1
+ * @param q1 an endpoint of line 2
+ * @param q2 an endpoint of line 2
+ * @return the intersection point between the lines, if there is one,
+ * or null if the lines are parallel or collinear
+ *
+ * @see CGAlgorithmsDD#intersection(Coordinate, Coordinate, Coordinate, Coordinate)
+ */
+static geom::CoordinateXY intersection(const geom::CoordinateXY& p1, const geom::CoordinateXY& p2,
+                                       const geom::CoordinateXY& q1, const geom::CoordinateXY& q2);
+
+/**
+* Computes the intersection point of a line and a line segment (if any).
+* There will be no intersection point if:
+*
+*  * the segment does not intersect the line
+*  * the line or the segment are degenerate (have zero length)
+*
+* If the segment is collinear with the line the first segment endpoint is returned.
+*
+* @param line1 a point on the line
+* @param line2 a point on the line
+* @param seg1 an endpoint of the line segment
+* @param seg2 an endpoint of the line segment
+* @return the intersection point, or null if it is not possible to find an intersection
+*/
+static geom::CoordinateXY intersectionLineSegment(
+    const geom::CoordinateXY& line1,
+    const geom::CoordinateXY& line2,
+    const geom::CoordinateXY& seg1,
+    const geom::CoordinateXY& seg2);
+
+
+};
+
+
+} // namespace geos::algorithm
+} // namespace geos
+

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

@@ -0,0 +1,60 @@
+/**********************************************************************
+ *
+ * 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/Length.java @ 2017-09-04
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+
+#include <vector>
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Functions for computing length.
+ *
+ * @author Martin Davis
+ */
+class GEOS_DLL Length {
+public:
+
+    /**
+     * Computes the length of a linestring specified by a sequence of points.
+     *
+     * @param ring the points specifying the linestring
+     * @return the length of the linestring
+     */
+    static double ofLine(const geom::CoordinateSequence* ring);
+
+    /**
+     * Computes the length of a linestring specified by a sequence of points.
+     *
+     * @param ring the points specifying the linestring
+     * @return the length of the linestring
+     */
+    static double ofLine(const std::vector<geom::CoordinateXY>& ring);
+
+};
+
+
+} // namespace geos::algorithm
+} // namespace geos
+
+