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

package/README.md

@@ -4,7 +4,10 @@
 <a href="https://www.npmjs.com/package/@cpp.js/package-geos">
     <img alt="NPM version" src="https://img.shields.io/npm/v/@cpp.js/package-geos?style=for-the-badge" />
 </a>
-<a href="https://github.com/OSGeo/libgeotiff/blob/master/libgeotiff/LICENSE">
+<a href="https://github.com/libgeos/geos">
+    <img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Funpkg.com%2F%40cpp.js%2Fpackage-geos%2Fpackage.json&query=%24.nativeVersion&style=for-the-badge&label=Geos" />
+</a>
+<a href="https://github.com/libgeos/geos/blob/main/COPYING">
     <img alt="License" src="https://img.shields.io/npm/l/%40cpp.js%2Fpackage-geos?style=for-the-badge" />
 </a>
 
@@ -42,6 +45,6 @@ std::string Native::sample() {
 ```
 
 ## License
-This project includes the precompiled geos library, which is distributed under the [LGPL License](https://github.com/OSGeo/libgeotiff/blob/master/libgeotiff/LICENSE).
+This project includes the precompiled geos library, which is distributed under the [LGPL License](https://github.com/libgeos/geos/blob/main/COPYING).
 
 GEOS Homepage: <https://github.com/libgeos/geos>

package/dist/prebuilt/Android-arm64-v8a/bin/geos-config

@@ -39,7 +39,7 @@ while test $# -gt 0; do
       echo ${prefix}
       ;;
     --version)
-      echo 3.12.2
+      echo 3.13.0
       ;;
     --libs)
       # TODO: make an alias for --clibs

package/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/Angle.h

@@ -216,6 +216,28 @@ public:
     ///         (in range [0, Pi] )
     ///
     static double diff(double ang1, double ang2);
+
+    /// \brief
+    /// Computes both sin and cos of an angle, snapping near-zero values
+    /// to zero.
+    ///
+    /// The angle does not need to be normalized. Unlike std::sin
+    /// and std::cos, this method will snap near-zero values to zero
+    /// for (e.g.) sin(pi) and cos(pi/2).
+    ///
+    /// @param ang the input angle (in radians)
+    /// @param rSin the result of sin(ang)
+    /// @param rCos the result of cos(ang)
+    ///
+    static inline void sinCosSnap(const double ang, double& rSin, double& rCos) {
+        // calculate both; may be optimized with FSINCOS instruction
+        rSin = std::sin(ang);
+        rCos = std::cos(ang);
+        // snap near-zero values
+        if (std::fabs(rSin) < 5e-16) rSin = 0.0;
+        if (std::fabs(rCos) < 5e-16) rCos = 0.0;
+    }
+
 };
 
 

package/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/Area.h

@@ -23,12 +23,19 @@
 #include <geos/geom/CoordinateSequence.h>
 
 namespace geos {
+
+namespace geom {
+class Curve;
+}
+
 namespace algorithm { // geos::algorithm
 
 
 class GEOS_DLL Area {
 public:
 
+    static double ofClosedCurve(const geom::Curve& ring);
+
     /**
     * Computes the area for a ring.
     *

package/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/BoundaryNodeRule.h

@@ -18,6 +18,8 @@
 
 #pragma once
 
+#include <string>
+
 #include <geos/export.h>
 
 // Forward declarations
@@ -55,6 +57,8 @@ public:
     virtual
     ~BoundaryNodeRule() {}
 
+    virtual std::string toString() const = 0;
+
     /** \brief
      * Tests whether a point that lies in `boundaryCount`
      * geometry component boundaries is considered to form part of

package/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/CGAlgorithmsDD.h

@@ -87,7 +87,7 @@ public:
      *
      * Uses an approach due to Jonathan Shewchuk, which is in the public domain.
      */
-    static int orientationIndexFilter(
+    static inline int orientationIndexFilter(
         double pax, double pay,
         double pbx, double pby,
         double pcx, double pcy)

package/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/CircularArcs.h

@@ -0,0 +1,37 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2024 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 <geos/geom/Envelope.h>
+
+namespace geos {
+namespace algorithm {
+
+class GEOS_DLL CircularArcs {
+public:
+
+    /// Return the circle center of an arc defined by three points
+    static geom::CoordinateXY getCenter(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1,
+                                        const geom::CoordinateXY& p2);
+
+    /// Expand an envelope to include an arc defined by three points
+    static void expandEnvelope(geom::Envelope& e, const geom::CoordinateXY& p0, const geom::CoordinateXY& p1,
+                               const geom::CoordinateXY& p2);
+};
+
+}
+}

package/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/ConvexHull.h

@@ -25,12 +25,15 @@
 #include <vector>
 #include <cassert>
 
-// FIXME: avoid using Cordinate:: typedefs to avoid full include
+// FIXME: avoid using Coordinate:: typedefs to avoid full include
 #include <geos/algorithm/ConvexHull.h>
 #include <geos/geom/Coordinate.h>
 #include <geos/geom/CoordinateSequence.h>
 #include <geos/geom/Geometry.h>
 #include <geos/util/UniqueCoordinateArrayFilter.h>
+#include <geos/util/CoordinateArrayFilter.h>
+
+#include "geos/util.h"
 
 #ifdef _MSC_VER
 #pragma warning(push)
@@ -60,27 +63,26 @@ namespace algorithm { // geos::algorithm
  */
 class GEOS_DLL ConvexHull {
 private:
+
+    static constexpr std::size_t TUNING_REDUCE_SIZE = 50;
+
+    const geom::Geometry* inputGeom;
     const geom::GeometryFactory* geomFactory;
     geom::Coordinate::ConstVect inputPts;
 
-    void
-    extractCoordinates(const geom::Geometry* geom)
-    {
-        util::UniqueCoordinateArrayFilter filter(inputPts);
-        geom->apply_ro(&filter);
-    }
-
     /// Create a CoordinateSequence from the Coordinate::ConstVect
     /// This is needed to construct the geometries.
     /// Here coordinate copies happen
     /// The returned object is newly allocated !NO EXCEPTION SAFE!
     std::unique_ptr<geom::CoordinateSequence> toCoordinateSequence(geom::Coordinate::ConstVect& cv);
 
-    void computeOctPts(const geom::Coordinate::ConstVect& src,
-                       geom::Coordinate::ConstVect& tgt);
+    void computeInnerOctolateralPts(
+        const geom::Coordinate::ConstVect& src,
+        geom::Coordinate::ConstVect& tgt);
 
-    bool computeOctRing(const geom::Coordinate::ConstVect& src,
-                        geom::Coordinate::ConstVect& tgt);
+    bool computeInnerOctolateralRing(
+        const geom::Coordinate::ConstVect& src,
+        geom::Coordinate::ConstVect& tgt);
 
     /**
      * Uses a heuristic to reduce the number of points scanned
@@ -132,7 +134,8 @@ private:
      * equal to or greater than q
      */
     int polarCompare(const geom::Coordinate& o,
-                     const geom::Coordinate& p, const geom::Coordinate& q);
+                     const geom::Coordinate& p,
+                     const geom::Coordinate& q);
 
     void grahamScan(const geom::Coordinate::ConstVect& c,
                     geom::Coordinate::ConstVect& ps);
@@ -150,7 +153,7 @@ private:
 
     /**
      * Write in 'cleaned' a version of 'input' with collinear
-     * vertexes removed.
+     * vertices removed.
      */
     void cleanRing(const geom::Coordinate::ConstVect& input,
                    geom::Coordinate::ConstVect& cleaned);
@@ -159,7 +162,15 @@ private:
      * @return  whether the three coordinates are collinear
      *          and c2 lies between c1 and c3 inclusive
      */
-    bool isBetween(const geom::Coordinate& c1, const geom::Coordinate& c2, const geom::Coordinate& c3);
+    bool isBetween(
+        const geom::Coordinate& c1,
+        const geom::Coordinate& c2,
+        const geom::Coordinate& c3);
+
+    bool extractUnique(geom::Coordinate::ConstVect& pts, std::size_t maxPts);
+    std::unique_ptr<geom::Geometry> createFewPointsResult();
+
+
 
 public:
 
@@ -167,9 +178,10 @@ public:
      * Create a new convex hull construction for the input Geometry.
      */
     ConvexHull(const geom::Geometry* newGeometry)
-        : geomFactory(newGeometry->getFactory())
+        : inputGeom(newGeometry)
+        , geomFactory(newGeometry->getFactory())
     {
-        extractCoordinates(newGeometry);
+      util::ensureNoCurvedComponents(inputGeom);
     };
 
     ~ConvexHull() {};

package/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/HCoordinate.h

@@ -72,7 +72,7 @@ public:
 
     /** \brief
      * Constructs a homogeneous coordinate which is the intersection
-     * of the lines define by the homogenous coordinates represented
+     * of the lines define by the homogeneous coordinates represented
      * by two [Coordinates](@ref geom::Coordinate).
      *
      * @param p1

package/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/LineIntersector.h

@@ -134,17 +134,6 @@ public:
         precisionModel = newPM;
     }
 
-    /// Compute the intersection of a point p and the line p1-p2.
-    ///
-    /// This function computes the boolean value of the hasIntersection test.
-    /// The actual value of the intersection (if there is one)
-    /// is equal to the value of <code>p</code>.
-    ///
-    void computeIntersection(const geom::CoordinateXY& p, const geom::CoordinateXY& p1, const geom::CoordinateXY& p2);
-
-    /// Same as above but doesn't compute intersection point. Faster.
-    static bool hasIntersection(const geom::CoordinateXY& p, const geom::CoordinateXY& p1, const geom::CoordinateXY& p2);
-
     enum intersection_type : uint8_t {
         /// Indicates that line segments do not intersect
         NO_INTERSECTION = 0,
@@ -600,8 +589,20 @@ private:
     {
         geom::CoordinateXYZM ptInt(Intersection::intersection(p1, p2, q1, q2));
         if (ptInt.isNull()) {
-            // FIXME need to cast to correct type in mixed-dimensionality case
-            ptInt = static_cast<const C1&>(nearestEndpoint(p1, p2, q1, q2));
+            const geom::CoordinateXY& nearest = nearestEndpoint(p1, p2, q1, q2);
+#if __cplusplus >= 201703L
+            if constexpr (std::is_same<C1, C2>::value) {
+#else
+            if (std::is_same<C1, C2>::value) {
+#endif
+                ptInt = static_cast<const C1&>(nearest);
+            } else {
+                if (&nearest == static_cast<const geom::CoordinateXY*>(&p1) || &nearest == static_cast<const geom::CoordinateXY*>(&p2)) {
+                    ptInt = static_cast<const C1&>(nearest);
+                } else {
+                    ptInt = static_cast<const C2&>(nearest);
+                }
+            }
         }
         return ptInt;
     }

package/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/PointLocation.h

@@ -19,11 +19,18 @@
 #pragma once
 
 #include <geos/export.h>
-#include <geos/geom/Coordinate.h>
-#include <geos/geom/CoordinateSequence.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
@@ -36,6 +43,16 @@ namespace algorithm { // geos::algorithm
 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).
@@ -80,6 +97,7 @@ public:
      */
     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);
 
 };
 

package/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/PolygonNodeTopology.h

@@ -76,6 +76,21 @@ public:
     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:
 
@@ -95,6 +110,23 @@ private:
         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.

package/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/RayCrossingCounter.h

@@ -22,6 +22,7 @@
 #include <geos/export.h>
 #include <geos/geom/Location.h>
 
+#include <array>
 #include <vector>
 
 // forward declarations
@@ -30,6 +31,8 @@ namespace geom {
 class Coordinate;
 class CoordinateXY;
 class CoordinateSequence;
+class CircularArc;
+class Curve;
 }
 }
 
@@ -92,6 +95,9 @@ public:
     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),
@@ -107,6 +113,15 @@ public:
     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.
      *
@@ -147,6 +162,11 @@ public:
 
     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

package/dist/prebuilt/Android-arm64-v8a/include/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/dist/prebuilt/Android-arm64-v8a/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>
+
+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;
+};
+
+}}}