@cpp.js/package-geos 1.0.0-beta.20

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/algorithm/PointLocation.h

@@ -0,0 +1,89 @@
+/**********************************************************************
+ *
+ * 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/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/Location.h>
+
+namespace geos {
+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 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);
+
+};
+
+
+} // namespace geos::algorithm
+} // namespace geos
+

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/algorithm/PointLocator.h

@@ -0,0 +1,108 @@
+/**********************************************************************
+ *
+ * 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 CoordinateXY;
+class Geometry;
+class LinearRing;
+class LineString;
+class Polygon;
+class Point;
+}
+}
+
+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 locateInPolygonRing(const geom::CoordinateXY& p, const geom::LinearRing* ring);
+
+    geom::Location locate(const geom::CoordinateXY& p, const geom::Polygon* poly);
+
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+
+

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/algorithm/PolygonNodeTopology.h

@@ -0,0 +1,117 @@
+/**********************************************************************
+ *
+ * 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;
+}
+}
+
+using geos::geom::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 {
+
+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);
+
+
+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);
+
+    /**
+    * 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/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/algorithm/RayCrossingCounter.h

@@ -0,0 +1,153 @@
+/**********************************************************************
+ *
+ * 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 <vector>
+
+// forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class CoordinateXY;
+class CoordinateSequence;
+}
+}
+
+
+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);
+
+    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);
+
+    /** \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; };
+
+};
+
+} // geos::algorithm
+} // geos

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/algorithm/Rectangle.h

@@ -0,0 +1,96 @@
+/**********************************************************************
+ *
+ * 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;
+}
+}
+
+using geos::geom::CoordinateXY;
+using geos::geom::GeometryFactory;
+using geos::geom::LineSegment;
+using geos::geom::Polygon;
+
+namespace geos {
+namespace algorithm {
+
+class GEOS_DLL Rectangle {
+
+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/geos_c.xcframework/ios-arm64_arm64e/Headers/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/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/algorithm/SimplePointInRing.h

@@ -0,0 +1,44 @@
+/**********************************************************************
+ *
+ * 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/algorithm/PointInRing.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class LinearRing;
+class CoordinateSequence;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+class GEOS_DLL SimplePointInRing: public PointInRing {
+public:
+    SimplePointInRing(geom::LinearRing* ring);
+    ~SimplePointInRing() override = default;
+    bool isInside(const geom::Coordinate& pt) override;
+private:
+    const geom::CoordinateSequence* pts;
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+