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

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/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/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/PolygonNodeTopology.h

@@ -0,0 +1,149 @@
+/**********************************************************************
+ *
+ * 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);
+
+    /**
+    * 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/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/RayCrossingCounter.h

@@ -0,0 +1,173 @@
+/**********************************************************************
+ *
+ * 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::CoordinateXY& p1,
+                  const geom::CoordinateXY& p2,
+                  const geom::CoordinateXY& p3);
+
+    /** \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

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/construct/IndexedDistanceToPoint.h

@@ -0,0 +1,88 @@
+/**********************************************************************
+ *
+ * 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>
+
+using geos::geom::Geometry;
+using geos::geom::Point;
+using geos::operation::distance::IndexedFacetDistance;
+
+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 {
+
+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/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/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>
+
+using geos::geom::Geometry;
+using geos::geom::CoordinateXY;
+using geos::geom::Location;
+using geos::index::strtree::TemplateSTRtree;
+using geos::algorithm::locate::IndexedPointInAreaLocator;
+
+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 {
+
+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;
+};
+
+}}}