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

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

@@ -0,0 +1,95 @@
+/**********************************************************************
+ *
+ * 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 <geos/geom/LineSegment.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class GeometryFactory;
+class Polygon;
+}
+}
+
+namespace geos {
+namespace algorithm {
+
+class GEOS_DLL Rectangle {
+    using CoordinateXY = geos::geom::CoordinateXY;
+    using GeometryFactory = geos::geom::GeometryFactory;
+    using LineSegment = geos::geom::LineSegment;
+    using Polygon = geos::geom::Polygon;
+
+public:
+
+    /**
+    * Creates a rectangular {@link Polygon} from a base segment
+    * defining the position and orientation of one side of the rectangle, and
+    * three points defining the locations of the line segments
+    * forming the opposite, left and right sides of the rectangle.
+    * The base segment and side points must be presented so that the
+    * rectangle has CW orientation.
+    *
+    * The rectangle corners are computed as intersections of
+    * lines, which generally cannot produce exact values.
+    * If a rectangle corner is determined to coincide with a side point
+    * the side point value is used to avoid numerical inaccuracy.
+    *
+    * The first side of the constructed rectangle contains the base segment.
+    *
+    * @param baseRightPt the right point of the base segment
+    * @param baseLeftPt the left point of the base segment
+    * @param oppositePt the point defining the opposite side
+    * @param leftSidePt the point defining the left side
+    * @param rightSidePt the point defining the right side
+    * @param factory the geometry factory to use
+    * @return the rectangular polygon
+    */
+    static std::unique_ptr<Polygon>
+        createFromSidePts(
+            const CoordinateXY& baseRightPt,
+            const CoordinateXY& baseLeftPt,
+            const CoordinateXY& oppositePt,
+            const CoordinateXY& leftSidePt,
+            const CoordinateXY& rightSidePt,
+            const GeometryFactory* factory);
+
+private:
+
+    /**
+    * Computes the constant C in the standard line equation Ax + By = C
+    * from A and B and a point on the line.
+    *
+    * @param a the X coefficient
+    * @param b the Y coefficient
+    * @param p a point on the line
+    * @return the constant C
+    */
+    static double
+        computeLineEquationC(double a, double b, const CoordinateXY& p);
+
+    static LineSegment
+        createLineForStandardEquation(double a, double b, double c);
+
+};
+
+
+} // namespace geos::algorithm
+} // namespace geos
+
+

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

@@ -0,0 +1,66 @@
+/**********************************************************************
+ *
+ * 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/RobustDeterminant.java 1.15 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Implements an algorithm to compute the
+ * sign of a 2x2 determinant for double precision values robustly.
+ *
+ * It is a direct translation of code developed by Olivier Devillers.
+ *
+ * The original code carries the following copyright notice:
+ *
+ * <pre>
+ *************************************************************************
+ * The original code carries the following copyright notice:
+ * Author : Olivier Devillers
+ * Olivier.Devillers@sophia.inria.fr
+ * http:/www.inria.fr:/prisme/personnel/devillers/anglais/determinant.html
+ *
+ **************************************************************************
+ *              Copyright (c) 1995  by  INRIA Prisme Project
+ *                  BP 93 06902 Sophia Antipolis Cedex, France.
+ *                           All rights reserved
+ **********************************************************************
+ * </pre>
+ *
+ */
+class GEOS_DLL RobustDeterminant {
+public:
+
+    /** \brief
+     * Computes the sign of the determinant of the 2x2 matrix
+     * with the given entries, in a robust way.
+     *
+     * @return -1 if the determinant is negative,
+     * @return  1 if the determinant is positive,
+     * @return  0 if the determinant is 0.
+     */
+    static int signOfDet2x2(double x1, double y1, double x2, double y2);
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+

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

@@ -0,0 +1,122 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (c) 2020 Martin Davis
+ * Copyright (C) 2020 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/construct/ExactMaxInscribedCircle.java
+ * https://github.com/locationtech/jts/commit/8d5ced1b784d232e1eecf5df4b71873e8822336a
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/LineSegment.h>
+
+#include <array>
+// #include <queue>
+
+
+
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+class Geometry;
+class Polygon;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+namespace construct { // geos::algorithm::construct
+
+/**
+ * Computes the Maximum Inscribed Circle for some kinds of convex polygons.
+ * It determines the circle center point by computing Voronoi node points
+ * and testing them for distance to generating edges.
+ * This is more precise than iterated approximation,
+ * and faster for small polygons (such as triangles and convex quadrilaterals).
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL ExactMaxInscribedCircle {
+
+    using CoordinateSequence = geos::geom::CoordinateSequence;
+    using CoordinateXY = geos::geom::CoordinateXY;
+    using LineSegment = geos::geom::LineSegment;
+    using Polygon = geos::geom::Polygon;
+
+public:
+
+    ExactMaxInscribedCircle();
+
+    /**
+     * Tests whether a given geometry is supported by this class.
+     * Currently only triangles and convex quadrilaterals are supported.
+     *
+     * @param geom an areal geometry
+     * @return true if the geometry shape can be evaluated
+     */
+    static bool isSupported(const geom::Geometry* geom);
+
+    static std::pair<CoordinateXY, CoordinateXY> computeRadius(const Polygon* polygon);
+
+
+private:
+
+    static bool isTriangle(const Polygon* polygon);
+
+    static bool isQuadrilateral(const Polygon* polygon);
+
+    static std::pair<CoordinateXY, CoordinateXY> computeTriangle(const CoordinateSequence* ring);
+
+    /**
+     * The Voronoi nodes of a convex polygon occur at the intersection point
+     * of two bisectors of each triplet of edges.
+     * The Maximum Inscribed Circle center is the node
+     * is the farthest distance from the generating edges.
+     * For a quadrilateral there are 4 distinct edge triplets,
+     * at each edge with its adjacent edges.
+     *
+     * @param ring the polygon ring
+     * @return an array containing the incircle center and radius points
+     */
+    static std::pair<CoordinateXY, CoordinateXY> computeConvexQuadrilateral(const CoordinateSequence* ring);
+
+    static std::array<LineSegment, 4> computeBisectors(const CoordinateSequence* ptsCW,
+                                                       double diameter);
+
+    static CoordinateXY nearestEdgePt(const CoordinateSequence* ring,
+                                      const CoordinateXY& pt);
+
+    static LineSegment computeConvexBisector(const CoordinateSequence* pts,
+                                             std::size_t index, double len);
+
+    static bool isConvex(const Polygon* polygon);
+
+    static bool isConvex(const CoordinateSequence* ring);
+
+    static bool isConcave(const CoordinateXY& p0,
+                          const CoordinateXY& p1,
+                          const CoordinateXY& p2);
+
+    static bool isPointInConvexRing(const CoordinateSequence* ringCW,
+                                const CoordinateXY& p);
+
+};
+
+
+} // geos::algorithm::construct
+} // geos::algorithm
+} // geos

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

@@ -0,0 +1,87 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2023 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/construct/IndexedDistanceToPoint.java
+ * https://github.com/locationtech/jts/commit/d92f783163d9440fcc10c729143787bf7b9fe8f9
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/Geometry.h>
+#include <geos/geom/Point.h>
+#include <geos/algorithm/construct/IndexedPointInPolygonsLocator.h>
+#include <geos/operation/distance/IndexedFacetDistance.h>
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+namespace construct { // geos::algorithm::construct
+
+/**
+ * \brief Computes the distance between a point and a geometry
+ * (which may be a collection containing any type of geometry).
+ * 
+ * Also computes the pair of points containing the input
+ * point and the nearest point on the geometry.
+ * 
+ * \author Martin Davis
+ */
+class GEOS_DLL IndexedDistanceToPoint {
+    using Geometry = geos::geom::Geometry;
+    using Point = geos::geom::Point;
+    using IndexedFacetDistance = geos::operation::distance::IndexedFacetDistance;
+
+public:
+    /** 
+     * \brief Creates an instance to find the distance from points to a geometry.
+     * 
+     * \param geom the geometry to compute distances to
+     */
+    IndexedDistanceToPoint(const Geometry& geom);
+
+    /**
+     * \brief Computes the distance from the base geometry to the given point.
+     *
+     * \param pt the point to compute the distance to
+     *
+     * \return the computed distance
+     */
+    double distance(const Point& pt);
+
+    /**
+     * \brief Computes the nearest point on the geometry to the point.
+     * 
+     * The first location lies on the geometry, 
+     * and the second location is the provided point.
+     *
+     * \param pt the point to compute the nearest point for
+     *
+     * \return the points that are nearest
+     */
+    std::unique_ptr<geom::CoordinateSequence> nearestPoints(const Point& pt);
+
+private:
+    void init();
+
+    bool isInArea(const Point& pt);
+
+    //-- members
+    const Geometry& targetGeometry;
+    std::unique_ptr<operation::distance::IndexedFacetDistance> facetDistance;
+    std::unique_ptr<IndexedPointInPolygonsLocator> ptLocator;
+
+};
+
+}}}

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

@@ -0,0 +1,79 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2023 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/construct/IndexedDistanceToPoint.java
+ * https://github.com/locationtech/jts/commit/d92f783163d9440fcc10c729143787bf7b9fe8f9
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Geometry.h>
+#include <geos/geom/Location.h>
+#include <geos/index/strtree/TemplateSTRtree.h>
+#include <geos/algorithm/locate/IndexedPointInAreaLocator.h>
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+namespace construct { // geos::algorithm::construct
+
+/**
+ * \brief Determines the location of a point in the polygonal elements of a geometry.
+ * 
+ * Uses spatial indexing to provide efficient performance.
+ * 
+ * \author Martin Davis
+ */
+class GEOS_DLL IndexedPointInPolygonsLocator {
+    using Geometry = geos::geom::Geometry;
+    using CoordinateXY = geos::geom::CoordinateXY;
+    using Location = geos::geom::Location;
+    template<typename ItemType>
+    using TemplateSTRtree = geos::index::strtree::TemplateSTRtree<ItemType>;
+    using IndexedPointInAreaLocator = geos::algorithm::locate::IndexedPointInAreaLocator;
+
+public:
+    /** 
+     * \brief Creates an instance to locate a point in polygonal elements.
+     * 
+     * \param geom the geometry to locate in
+     */
+    IndexedPointInPolygonsLocator(const Geometry& geom);
+
+    /** \brief
+     * Determines the [Location](@ref geom::Location) of a point in 
+     * the polygonal elements of a
+     * [Geometry](@ref geom::Geometry).
+     *
+     * @param p the point to test
+     * @return the location of the point in the geometry
+     */
+    Location locate(const CoordinateXY* /*const*/ p);
+
+private:
+    void init();
+
+    // Declare type as noncopyable
+    IndexedPointInPolygonsLocator(const IndexedPointInPolygonsLocator& other) = delete;
+    IndexedPointInPolygonsLocator& operator=(const IndexedPointInPolygonsLocator& rhs) = delete;
+
+    //-- members
+    const Geometry& geom;
+    bool isInitialized;
+    TemplateSTRtree<IndexedPointInAreaLocator*> index;
+    std::vector<std::unique_ptr<IndexedPointInAreaLocator>> locators;
+};
+
+}}}

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

@@ -0,0 +1,239 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 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/construct/LargestEmptyCircle.java
+ * https://github.com/locationtech/jts/commit/98274a7ea9b40651e9de6323dc10fb2cac17a245
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Point.h>
+#include <geos/geom/Envelope.h>
+#include <geos/algorithm/construct/IndexedDistanceToPoint.h>
+#include <geos/algorithm/locate/IndexedPointInAreaLocator.h>
+#include <geos/operation/distance/IndexedFacetDistance.h>
+
+#include <memory>
+#include <queue>
+
+namespace geos {
+namespace geom {
+class Coordinate;
+class Envelope;
+class Geometry;
+class GeometryFactory;
+class LineString;
+class Point;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+namespace construct { // geos::algorithm::construct
+
+/**
+* Constructs the Largest Empty Circle for a set of obstacle geometries,
+* up to a specified tolerance. 
+* The obstacles may be any combination of point, linear and polygonal geometries.
+*
+* The Largest Empty Circle (LEC) is the largest circle 
+* whose interior does not intersect with any obstacle
+* and whose center lies within a polygonal boundary.
+* The circle center is the point in the interior of the boundary 
+* which has the farthest distance from the obstacles 
+* (up to the accuracy of the distance tolerance).
+* The circle itself is determined by the center point
+* and a point lying on an obstacle determining the circle radius.
+* 
+* The polygonal boundary may be supplied explicitly.
+* If it is not specified the convex hull of the obstacles is used as the boundary.
+* 
+* To compute an LEC which lies wholly within
+* a polygonal boundary, include the boundary of the polygon(s) as an obstacle.
+*
+* The implementation uses a successive-approximation technique
+* over a grid of square cells covering the obstacles and boundary.
+* The grid is refined using a branch-and-bound algorithm. Point
+* containment and distance are computed in a performant way
+* by using spatial indexes.
+*
+* \author Martin Davis
+*/
+class GEOS_DLL LargestEmptyCircle {
+    using IndexedFacetDistance = geos::operation::distance::IndexedFacetDistance;
+
+public:
+
+    /**
+    * Creates a new instance of a Largest Empty Circle construction.
+    * The obstacles may be any collection of points, lines and polygons.
+    * The constructed circle center lies within the convex hull of the obstacles.
+    *
+    * @param p_obstacles a geometry representing the obstacles
+    * @param p_tolerance the distance tolerance for computing the circle center point
+    */
+    LargestEmptyCircle(const geom::Geometry* p_obstacles, double p_tolerance);
+
+    /**
+    * Creates a new instance of a Largest Empty Circle construction,
+    * interior-disjoint to a set of obstacle geometries 
+    * and having its center within a polygonal boundary.
+    * The obstacles may be any collection of points, lines and polygons.
+    * If the boundary is null or empty the convex hull
+    * of the obstacles is used as the boundary.
+    *
+    * @param p_obstacles a geometry representing the obstacles
+    * @param p_boundary a polygonal geometry to contain the LEC center
+    * @param p_tolerance the distance tolerance for computing the circle center point
+    */
+    LargestEmptyCircle(const geom::Geometry* p_obstacles, const geom::Geometry* p_boundary, double p_tolerance);
+
+    ~LargestEmptyCircle() = default;
+
+    /**
+    * Computes the center point of the Largest Empty Circle
+    * within a set of obstacles, up to a given tolerance distance.
+    * The obstacles may be any collection of points, lines and polygons.
+    *
+    * @param p_obstacles a geometry representing the obstacles
+    * @param p_tolerance the distance tolerance for computing the center point
+    * @return the center point of the Largest Empty Circle
+    */
+    static std::unique_ptr<geom::Point> getCenter(const geom::Geometry* p_obstacles, double p_tolerance);
+
+    /**
+    * Computes a radius line of the Largest Empty Circle
+    * within a set of obstacles, up to a given distance tolerance.
+    * The obstacles may be any collection of points, lines and polygons.
+    *
+    * @param p_obstacles a geometry representing the obstacles
+    * @param p_tolerance the distance tolerance for computing the center point
+    * @return a line from the center of the circle to a point on the edge
+    */
+    static std::unique_ptr<geom::LineString> getRadiusLine(const geom::Geometry* p_obstacles, double p_tolerance);
+
+    std::unique_ptr<geom::Point> getCenter();
+    std::unique_ptr<geom::Point> getRadiusPoint();
+    std::unique_ptr<geom::LineString> getRadiusLine();
+
+
+private:
+
+    /* private members */
+    double tolerance;
+    const geom::Geometry* obstacles;
+    std::unique_ptr<geom::Geometry> boundary;
+    const geom::GeometryFactory* factory;
+    geom::Envelope gridEnv;
+    bool done;
+    std::unique_ptr<algorithm::locate::IndexedPointInAreaLocator> boundaryPtLocater;
+    IndexedDistanceToPoint obstacleDistance;
+    std::unique_ptr<IndexedFacetDistance> boundaryDistance;
+    geom::CoordinateXY centerPt;
+    geom::CoordinateXY radiusPt;
+
+    /**
+    * Computes the signed distance from a point to the constraints
+    * (obstacles and boundary).
+    * Points outside the boundary polygon are assigned a negative distance.
+    * Their containing cells will be last in the priority queue
+    * (but will still end up being tested since they may be refined).
+    *
+    * @param c the point to compute the distance for
+    * @return the signed distance to the constraints (negative indicates outside the boundary)
+    */
+    double distanceToConstraints(const geom::Coordinate& c);
+    double distanceToConstraints(double x, double y);
+    void initBoundary();
+    void compute();
+
+    /* private class */
+    class Cell {
+    private:
+        static constexpr double SQRT2 = 1.4142135623730951;
+        double x;
+        double y;
+        double hSize;
+        double distance;
+        double maxDist;
+
+    public:
+        Cell(double p_x, double p_y, double p_hSize, double p_distanceToConstraints)
+            : x(p_x)
+            , y(p_y)
+            , hSize(p_hSize)
+            , distance(p_distanceToConstraints)
+            , maxDist(p_distanceToConstraints + (p_hSize*SQRT2))
+        {};
+
+        geom::Envelope getEnvelope() const
+        {
+            geom::Envelope env(x-hSize, x+hSize, y-hSize, y+hSize);
+            return env;
+        }
+
+        bool isFullyOutside() const
+        {
+            return maxDist < 0.0;
+        }
+        bool isOutside() const
+        {
+            return distance < 0.0;
+        }
+        double getMaxDistance() const
+        {
+            return maxDist;
+        }
+        double getDistance() const
+        {
+            return distance;
+        }
+        double getHSize() const
+        {
+            return hSize;
+        }
+        double getX() const
+        {
+            return x;
+        }
+        double getY() const
+        {
+            return y;
+        }
+        bool operator< (const Cell& rhs) const
+        {
+            return maxDist < rhs.maxDist;
+        }
+        bool operator> (const Cell& rhs) const
+        {
+            return maxDist > rhs.maxDist;
+        }
+        bool operator==(const Cell& rhs) const
+        {
+            return maxDist == rhs.maxDist;
+        }
+    };
+
+    bool mayContainCircleCenter(const Cell& cell, const Cell& farthestCell);
+    void createInitialGrid(const geom::Envelope* env, std::priority_queue<Cell>& cellQueue);
+    Cell createCentroidCell(const geom::Geometry* geom);
+
+};
+
+
+} // geos::algorithm::construct
+} // geos::algorithm
+} // geos