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

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

@@ -0,0 +1,122 @@
+/**********************************************************************
+ *
+ * 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/Orientation.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 the orientation of basic geometric structures
+ * including point triplets (triangles) and rings.
+ *
+ * Orientation is a fundamental property of planar geometries
+ * (and more generally geometry on two-dimensional manifolds).
+ *
+ * Orientation is notoriously subject to numerical precision errors
+ * in the case of collinear or nearly collinear points.
+ * JTS uses extended-precision arithmetic to increase
+ * the robustness of the computation.
+ *
+ * @author Martin Davis
+ */
+class GEOS_DLL Orientation {
+public:
+
+    /* A value that indicates an orientation or turn */
+    enum {
+        CLOCKWISE = -1,
+        COLLINEAR = 0,
+        COUNTERCLOCKWISE = 1,
+        RIGHT = -1,
+        LEFT = 1,
+        STRAIGHT = 0
+    };
+
+    /** \brief
+     * Returns the orientation index of the direction of the point q relative to
+     * a directed infinite line specified by p1-p2.
+     *
+     * The index indicates whether the point lies to the
+     * `Orientation::LEFT` or `Orientation::RIGHT`
+     * of the line, or lies on it `Orientation::COLLINEAR`.
+     * The index also indicates the orientation of the triangle formed
+     * by the three points
+     * ( `Orientation::COUNTERCLOCKWISE`,
+     * `Orientation::CLOCKWISE`, or `Orientation::STRAIGHT` )
+     */
+    static int index(const geom::CoordinateXY& p1, const geom::CoordinateXY& p2,
+                     const geom::CoordinateXY& q);
+
+    /**
+    * Computes whether a ring defined by a geom::CoordinateSequence is
+    * oriented counter-clockwise.
+    *
+    *  * The list of points is assumed to have the first and last points equal.
+    *  * This handles coordinate lists which contain repeated points.
+    *  * This handles rings which contain collapsed segments
+    *    (in particular, along the top of the ring).
+    *
+    * This algorithm is guaranteed to work with valid rings.
+    * It also works with "mildly invalid" rings
+    * which contain collapsed (coincident) flat segments along the top of the ring.
+    * If the ring is "more" invalid (e.g. self-crosses or touches),
+    * the computed result may not be correct.
+    *
+    * @param ring a CoordinateSequence forming a ring (with first and last point identical)
+    * @return true if the ring is oriented counter-clockwise.
+    * @throws IllegalArgumentException if there are too few points to determine orientation (< 4)
+    */
+    static bool isCCW(const geom::CoordinateSequence* ring);
+
+    /**
+    * Tests if a ring defined by a CoordinateSequence is
+    * oriented counter-clockwise, using the signed area of the ring.
+    *
+    *  * The list of points is assumed to have the first and last points equal.
+    *  * This handles coordinate lists which contain repeated points.
+    *  * This handles rings which contain collapsed segments
+    *    (in particular, along the top of the ring).
+    *  * This handles rings which are invalid due to self-intersection
+    *
+    * This algorithm is guaranteed to work with valid rings.
+    * For invalid rings (containing self-intersections),
+    * the algorithm determines the orientation of
+    * the largest enclosed area (including overlaps).
+    * This provides a more useful result in some situations, such as buffering.
+    *
+    * However, this approach may be less accurate in the case of
+    * rings with almost zero area.
+    * (Note that the orientation of rings with zero area is essentially
+    * undefined, and hence non-deterministic.)
+    *
+    * @param ring a CoordinateSequence forming a ring (with first and last point identical)
+    * @return true if the ring is oriented counter-clockwise.
+    */
+    static bool isCCWArea(const geom::CoordinateSequence* ring);
+
+};
+
+
+} // namespace geos::algorithm
+} // namespace geos
+

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

@@ -0,0 +1,40 @@
+/**********************************************************************
+ *
+ * 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>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+class GEOS_DLL PointInRing {
+public:
+    virtual
+    ~PointInRing() {}
+    virtual bool isInside(const geom::Coordinate& pt) = 0;
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+
+

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

@@ -0,0 +1,107 @@
+/**********************************************************************
+ *
+ * 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/PointLocation.java @ 2017-09-04
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Location.h>
+#include <vector>
+
+namespace geos {
+
+namespace geom {
+class Coordinate;
+class CoordinateXY;
+class CoordinateSequence;
+class Curve;
+}
+
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Functions for locating points within basic geometric
+ * structures such as lines and rings.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL PointLocation {
+public:
+
+    /** \brief
+     * Tests whether a point lies on a line segment.
+     * 
+     * @param p the point to test
+     * @param p0 a point of the line segment
+     * @param p1 a point of the line segment
+     * @return true if the point lies on the line segment
+     */
+    static bool isOnSegment(const geom::CoordinateXY& p, const geom::CoordinateXY& p0, const geom::CoordinateXY& p1);
+
+    /** \brief
+     * Tests whether a point lies on the line defined by a
+     * [CoordinateSequence](@ref geom::CoordinateSequence).
+     *
+     * @param p the point to test
+     * @param line the line coordinates
+     * @return true if the point is a vertex of the line or lies in the interior
+     *         of a line segment in the line
+     */
+    static bool isOnLine(const geom::CoordinateXY& p, const geom::CoordinateSequence* line);
+
+    /** \brief
+     * Tests whether a point lies inside or on a ring.
+     *
+     * The ring may be oriented in either direction. A point lying exactly
+     * on the ring boundary is considered to be inside the ring.
+     *
+     * This method does **not** first check the point against the envelope of
+     * the ring.
+     *
+     * @param p point to check for ring inclusion
+     * @param ring an array of coordinates representing the ring (which must have
+     *             first point identical to last point)
+     * @return `true` if p is inside ring
+     *
+     * @see RayCrossingCounter::locatePointInRing()
+     */
+    static bool isInRing(const geom::CoordinateXY& p, const std::vector<const geom::Coordinate*>& ring);
+    static bool isInRing(const geom::CoordinateXY& p, const geom::CoordinateSequence* ring);
+
+    /** \brief
+     * Determines whether a point lies in the interior, on the boundary, or in the
+     * exterior of a ring. The ring may be oriented in either direction.
+     *
+     * This method does *not* first check the point against the envelope of
+     * the ring.
+     *
+     * @param p point to check for ring inclusion
+     * @param ring an array of coordinates representing the ring (which must have
+     *             first point identical to last point)
+     * @return the [Location](@ref geom::Location) of p relative to the ring
+     */
+    static geom::Location locateInRing(const geom::CoordinateXY& p, const std::vector<const geom::Coordinate*>& ring);
+    static geom::Location locateInRing(const geom::CoordinateXY& p, const geom::CoordinateSequence& ring);
+    static geom::Location locateInRing(const geom::CoordinateXY& p, const geom::Curve& ring);
+
+};
+
+
+} // namespace geos::algorithm
+} // namespace geos
+

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

@@ -0,0 +1,116 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2005-2011 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/PointLocator.java 95fbe34b (JTS-1.15.2-SNAPSHOT)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Location.h> // for inlines
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class CircularString;
+class CompoundCurve;
+class CoordinateXY;
+class Curve;
+class Geometry;
+class LinearRing;
+class LineString;
+class Polygon;
+class Point;
+class Surface;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/**
+ * \class PointLocator
+ *
+ * \brief
+ * Computes the topological relationship (Location)
+ * of a single point to a Geometry.
+ *
+ * The algorithm obeys the SFS boundaryDetermination rule to correctly determine
+ * whether the point lies on the boundary or not.
+ *
+ * Notes:
+ *	- instances of this class are not reentrant.
+ *	- LinearRing objects do not enclose any area
+ *	  (points inside the ring are still in the EXTERIOR of the ring.)
+ *
+ */
+class GEOS_DLL PointLocator {
+public:
+    PointLocator() {}
+    ~PointLocator() {}
+
+    /**
+     * Computes the topological relationship (Location) of a single point
+     * to a Geometry. It handles both single-element and multi-element Geometries.
+     * The algorithm for multi-part Geometriestakes into account the SFS
+     * Boundary Determination rule.
+     *
+     * @return the Location of the point relative to the input Geometry
+     */
+    geom::Location locate(const geom::CoordinateXY& p, const geom::Geometry* geom);
+
+    /**
+     * Convenience method to test a point for intersection with
+     * a Geometry
+     *
+     * @param p the coordinate to test
+     * @param geom the Geometry to test
+     * @return <code>true</code> if the point is in the interior or boundary of the Geometry
+     */
+    bool
+    intersects(const geom::CoordinateXY& p, const geom::Geometry* geom)
+    {
+        return locate(p, geom) != geom::Location::EXTERIOR;
+    }
+
+private:
+
+    bool isIn;         // true if the point lies in or on any Geometry element
+
+    int numBoundaries;    // the number of sub-elements whose boundaries the point lies in
+
+    void computeLocation(const geom::CoordinateXY& p, const geom::Geometry* geom);
+
+    void updateLocationInfo(geom::Location loc);
+
+    geom::Location locate(const geom::CoordinateXY& p, const geom::Point* pt);
+
+    geom::Location locate(const geom::CoordinateXY& p, const geom::LineString* l);
+
+    geom::Location locate(const geom::CoordinateXY& p, const geom::CircularString* cs);
+
+    geom::Location locate(const geom::CoordinateXY& p, const geom::CompoundCurve* cs);
+
+    static geom::Location locateInPolygonRing(const geom::CoordinateXY& p, const geom::Curve* ring);
+
+    static geom::Location locate(const geom::CoordinateXY& p, const geom::Surface* poly);
+
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+
+

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

@@ -0,0 +1,147 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://libgeos.org
+ *
+ * Copyright (c) 2021 Martin Davis
+ * Copyright (C) 2022 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>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class CoordinateXY;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/**
+ * Functions to compute topological information
+ * about nodes (ring intersections) in polygonal geometry.
+ *
+ * @author mdavis
+ *
+ */
+class GEOS_DLL PolygonNodeTopology {
+    using CoordinateXY = geos::geom::CoordinateXY;
+
+public:
+
+    /*
+    * Check if the segments at a node between two rings (or one ring) cross.
+    * The node is topologically valid if the rings do not cross.
+    * This function assumes that the segments are not collinear.
+    *
+    * @param nodePt the node location
+    * @param a0 the previous segment endpoint in a ring
+    * @param a1 the next segment endpoint in a ring
+    * @param b0 the previous segment endpoint in the other ring
+    * @param b1 the next segment endpoint in the other ring
+    * @return true if the rings cross at the node
+    */
+    static bool
+    isCrossing(const CoordinateXY* nodePt,
+        const CoordinateXY* a0, const CoordinateXY* a1,
+        const CoordinateXY* b0, const CoordinateXY* b1);
+
+
+    /**
+    * Tests whether an segment node-b lies in the interior or exterior
+    * of a corner of a ring formed by the two segments a0-node-a1.
+    * The ring interior is assumed to be on the right of the corner
+    * (i.e. a CW shell or CCW hole).
+    * The test segment must not be collinear with the corner segments.
+    *
+    * @param nodePt the node location
+    * @param a0 the first vertex of the corner
+    * @param a1 the second vertex of the corner
+    * @param b the other vertex of the test segment
+    * @return true if the segment is interior to the ring corner
+    */
+    static bool isInteriorSegment(const CoordinateXY* nodePt,
+        const CoordinateXY* a0, const CoordinateXY* a1, const CoordinateXY* b);
+
+    /**
+    * Compares the angles of two vectors
+    * relative to the positive X-axis at their origin.
+    * Angles increase CCW from the X-axis.
+    *
+    * @param origin the origin of the vectors
+    * @param p the endpoint of the vector P
+    * @param q the endpoint of the vector Q
+    * @return a negative integer, zero, or a positive integer as this vector P has angle less than, equal to, or greater than vector Q
+    */
+    static int compareAngle(
+        const CoordinateXY* origin,
+        const CoordinateXY* p,
+        const CoordinateXY* q);
+
+
+private:
+
+    /**
+    * Tests if an edge p is between edges e0 and e1,
+    * where the edges all originate at a common origin.
+    * The "inside" of e0 and e1 is the arc which does not include the origin.
+    * The edges are assumed to be distinct (non-collinear).
+    *
+    * @param origin the origin
+    * @param p the destination point of edge p
+    * @param e0 the destination point of edge e0
+    * @param e1 the destination point of edge e1
+    * @return true if p is between e0 and e1
+    */
+    static bool isBetween(const CoordinateXY* origin,
+        const CoordinateXY* p,
+        const CoordinateXY* e0, const CoordinateXY* e1);
+
+    /**
+    * Compares whether an edge p is between or outside the edges e0 and e1,
+    * where the edges all originate at a common origin.
+    * The "inside" of e0 and e1 is the arc which does not include
+    * the positive X-axis at the origin.
+    * If p is collinear with an edge 0 is returned.
+    *
+    * @param origin the origin
+    * @param p the destination point of edge p
+    * @param e0 the destination point of edge e0
+    * @param e1 the destination point of edge e1
+    * @return a negative integer, zero or positive integer as the vector P lies outside, collinear with, or inside the vectors E0 and E1
+    */
+    static int compareBetween(const CoordinateXY* origin, const CoordinateXY* p,
+        const CoordinateXY* e0, const CoordinateXY* e1);
+
+
+    /**
+    * Tests if the angle with the origin of a vector P is greater than that of the
+    * vector Q.
+    *
+    * @param origin the origin of the vectors
+    * @param p the endpoint of the vector P
+    * @param q the endpoint of the vector Q
+    * @return true if vector P has angle greater than Q
+    */
+    static bool isAngleGreater(const CoordinateXY* origin, const CoordinateXY* p, const CoordinateXY* q);
+
+    static int quadrant(const CoordinateXY* origin, const CoordinateXY* p);
+
+
+};
+
+
+} // namespace geos::algorithm
+} // namespace geos
+

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

@@ -0,0 +1,171 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2006 Refractions Research 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/RayCrossingCounter.java rev. 1.2 (JTS-1.9)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Location.h>
+
+#include <array>
+#include <vector>
+
+// forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class CoordinateXY;
+class CoordinateSequence;
+class CircularArc;
+class Curve;
+}
+}
+
+
+namespace geos {
+namespace algorithm {
+
+/** \brief
+ * Counts the number of segments crossed by a horizontal ray extending to the
+ * right from a given point, in an incremental fashion.
+ *
+ * This can be used to determine whether a point lies in a polygonal geometry.
+ * The class determines the situation where the point lies exactly on a segment.
+ * When being used for Point-In-Polygon determination, this case allows
+ * short-circuiting the evaluation.
+ *
+ * This class handles polygonal geometries with any number of shells and holes.
+ * The orientation of the shell and hole rings is unimportant.
+ * In order to compute a correct location for a given polygonal geometry,
+ * it is essential that **all** segments are counted which
+ *
+ * - touch the ray
+ * - lie in in any ring which may contain the point
+ *
+ * The only exception is when the point-on-segment situation is detected, in
+ * which case no further processing is required.
+ * The implication of the above rule is that segments which can be a priori
+ * determined to *not* touch the ray (i.e. by a test of their bounding box or
+ * Y-extent) do not need to be counted. This allows for optimization by indexing.
+ *
+ * @author Martin Davis
+ */
+class GEOS_DLL RayCrossingCounter {
+private:
+    const geom::CoordinateXY& point;
+
+    std::size_t crossingCount;
+
+    // true if the test point lies on an input segment
+    bool isPointOnSegment;
+
+    // Declare type as noncopyable
+    RayCrossingCounter(const RayCrossingCounter& other) = delete;
+    RayCrossingCounter& operator=(const RayCrossingCounter& rhs) = delete;
+
+public:
+    /** \brief
+     * Determines the [Location](@ref geom::Location) of a point in a ring.
+     *
+     * This method is an exemplar of how to use this class.
+     *
+     * @param p the point to test
+     * @param ring an array of Coordinates forming a ring
+     * @return the location of the point in the ring
+     */
+    static geom::Location locatePointInRing(const geom::CoordinateXY& p,
+                                 const geom::CoordinateSequence& ring);
+
+    /// Semantically equal to the above, just different args encoding
+    static geom::Location locatePointInRing(const geom::CoordinateXY& p,
+                                 const std::vector<const geom::Coordinate*>& ring);
+
+    static geom::Location locatePointInRing(const geom::CoordinateXY& p,
+                                 const geom::Curve& ring);
+
+    RayCrossingCounter(const geom::CoordinateXY& p_point)
+        : point(p_point),
+          crossingCount(0),
+          isPointOnSegment(false)
+    { }
+
+    /** \brief
+     * Counts a segment
+     *
+     * @param p1 an endpoint of the segment
+     * @param p2 another endpoint of the segment
+     */
+    void countSegment(const geom::CoordinateXY& p1,
+                      const geom::CoordinateXY& p2);
+
+    void countArc(const geom::CircularArc& arc);
+
+    /** \brief
+     *  Counts all segments or arcs in the sequence
+     */
+    void processSequence(const geom::CoordinateSequence& seq, bool isLinear);
+
+    /** \brief
+     * Reports whether the point lies exactly on one of the supplied segments.
+     *
+     * This method may be called at any time as segments are processed.
+     * If the result of this method is `true`, no further segments need
+     * be supplied, since the result will never change again.
+     *
+     * @return `true` if the point lies exactly on a segment
+     */
+    bool
+    isOnSegment() const
+    {
+        return isPointOnSegment;
+    }
+
+    /** \brief
+     * Gets the [Location](@ref geom::Location) of the point relative to
+     * the ring, polygon or multipolygon from which the processed
+     * segments were provided.
+     *
+     * This method only determines the correct location
+     * if **all** relevant segments must have been processed.
+     *
+     * @return the Location of the point
+     */
+    geom::Location getLocation() const;
+
+    /** \brief
+     * Tests whether the point lies in or on the ring, polygon or
+     * multipolygon from which the processed segments were provided.
+     *
+     * This method only determines the correct location if **all** relevant
+     * segments must have been processed.
+     *
+     * @return `true` if the point lies in or on the supplied polygon
+     */
+    bool isPointInPolygon() const;
+
+    std::size_t getCount() const { return crossingCount; };
+
+    static bool shouldCountCrossing(const geom::CircularArc& arc, const geom::CoordinateXY& q);
+
+    static std::array<geom::CoordinateXY, 2>
+    pointsIntersectingHorizontalRay(const geom::CircularArc& arc, const geom::CoordinateXY& origin);
+
+};
+
+} // geos::algorithm
+} // geos