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

package/dist/prebuilt/Android-arm64-v8a/include/geos/geom/CompoundCurve.h

@@ -0,0 +1,121 @@
+/**********************************************************************
+ *
+ * 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/geom/SimpleCurve.h>
+#include <geos/util.h>
+#include <vector>
+
+namespace geos {
+namespace geom {
+
+class GEOS_DLL CompoundCurve : public Curve {
+    friend class GeometryFactory;
+
+public:
+    using Curve::apply_ro;
+    using Curve::apply_rw;
+
+    void apply_ro(CoordinateFilter* filter) const override;
+
+    void apply_ro(CoordinateSequenceFilter& filter) const override;
+
+    void apply_rw(CoordinateSequenceFilter& filter) override;
+
+    void apply_rw(const CoordinateFilter* filter) override;
+
+    int compareToSameClass(const Geometry* geom) const override;
+
+    std::unique_ptr<CompoundCurve> clone() const;
+
+    bool equalsExact(const Geometry* other, double tolerance = 0)
+    const override;
+
+    bool equalsIdentical(const Geometry* other) const override;
+
+    std::unique_ptr<Geometry> getBoundary() const override;
+
+    const CoordinateXY* getCoordinate() const override;
+
+    uint8_t getCoordinateDimension() const override;
+
+    std::unique_ptr<CoordinateSequence> getCoordinates() const override;
+
+    /// Returns the nth section of the CompoundCurve
+    const SimpleCurve* getCurveN(std::size_t) const override;
+
+    const Envelope* getEnvelopeInternal() const override
+    {
+        return &envelope;
+    }
+
+    std::string getGeometryType() const override;
+
+    GeometryTypeId getGeometryTypeId() const override;
+
+    double getLength() const override;
+
+    /// Returns the number of sections in the CompoundCurve
+    std::size_t getNumCurves() const override;
+
+    std::size_t getNumPoints() const override;
+
+    bool hasCurvedComponents() const override;
+
+    bool hasM() const override;
+
+    bool hasZ() const override;
+
+    bool isClosed() const override;
+
+    bool isEmpty() const override;
+
+    void normalize() override;
+
+    std::unique_ptr<CompoundCurve> reverse() const;
+
+protected:
+    /// Construct a CompoundCurve, taking ownership of the
+    /// provided CoordinateSequence
+    CompoundCurve(std::vector<std::unique_ptr<SimpleCurve>>&&,
+                  const GeometryFactory&);
+
+    CompoundCurve(const CompoundCurve&);
+
+    CompoundCurve& operator=(const CompoundCurve&);
+
+    CompoundCurve* cloneImpl() const override;
+
+    Envelope computeEnvelopeInternal() const;
+
+    void geometryChangedAction() override
+    {
+        envelope = computeEnvelopeInternal();
+    }
+
+    int getSortIndex() const override
+    {
+        return SORTINDEX_COMPOUNDCURVE;
+    }
+
+    CompoundCurve* reverseImpl() const override;
+
+private:
+    std::vector<std::unique_ptr<SimpleCurve>> curves;
+    Envelope envelope;
+};
+
+}
+}

package/dist/prebuilt/Android-arm64-v8a/include/geos/geom/Coordinate.h

@@ -22,6 +22,7 @@
 #include <vector> // for typedefs
 #include <string>
 #include <limits>
+#include <map>
 
 #ifdef _MSC_VER
 #pragma warning(push)
@@ -222,6 +223,7 @@ private:
 public:
     /// A set of const Coordinate pointers
     typedef std::set<const Coordinate*, CoordinateLessThan> ConstSet;
+    typedef std::set<const CoordinateXY*, CoordinateLessThan> ConstXYSet;
 
     /// A vector of const Coordinate pointers
     typedef std::vector<const Coordinate*> ConstVect;
@@ -232,6 +234,9 @@ public:
     /// A vector of Coordinate objects (real object, not pointers)
     typedef std::vector<Coordinate> Vect;
 
+    /// A map of const Coordinate pointers to integers
+    typedef std::map<const CoordinateXY*, int, CoordinateLessThan> ConstIntMap;
+
     /// z-coordinate
     double z;
 

package/dist/prebuilt/Android-arm64-v8a/include/geos/geom/CoordinateFilter.h

@@ -45,6 +45,11 @@ public:
     virtual
     ~CoordinateFilter() {}
 
+    virtual bool isDone() const
+    {
+        return false;
+    }
+
     /** \brief
      * Performs an operation on `coord`.
      *

package/dist/prebuilt/Android-arm64-v8a/include/geos/geom/CoordinateList.h

@@ -46,7 +46,7 @@ namespace geom { // geos::geom
 
 /** \brief
  * A list of {@link Coordinate}s, which may
- * be set to prevent repeated coordinates from occuring in the list.
+ * be set to prevent repeated coordinates from occurring in the list.
  *
  * Use this class when fast insertions and removal at arbitrary
  * position is needed.

package/dist/prebuilt/Android-arm64-v8a/include/geos/geom/CoordinateSequence.h

@@ -197,20 +197,6 @@ public:
         return m_vect.empty();
     }
 
-    /// Returns <code>true</code> if there is 1 coordinate and if it is null.
-    bool isNullPoint() const {
-        if (size() != 1) {
-            return false;
-        }
-        switch(getCoordinateType()) {
-            case CoordinateType::XY: return getAt<CoordinateXY>(0).isNull();
-            case CoordinateType::XYZ: return getAt<Coordinate>(0).isNull();
-            case CoordinateType::XYZM: return getAt<CoordinateXYZM>(0).isNull();
-            case CoordinateType::XYM: return getAt<CoordinateXYM>(0).isNull();
-            default: return false;
-        }
-    }
-
     /** \brief
     * Tests whether an a {@link CoordinateSequence} forms a ring,
     * by checking length and closure. Self-intersection is not checked.
@@ -635,10 +621,30 @@ public:
     template<typename Filter>
     void apply_rw(const Filter* filter) {
         switch(getCoordinateType()) {
-            case CoordinateType::XY:    for (auto& c : items<CoordinateXY>())   { filter->filter_rw(&c); } break;
-            case CoordinateType::XYZ:   for (auto& c : items<Coordinate>())     { filter->filter_rw(&c); } break;
-            case CoordinateType::XYM:   for (auto& c : items<CoordinateXYM>())  { filter->filter_rw(&c); } break;
-            case CoordinateType::XYZM:  for (auto& c : items<CoordinateXYZM>()) { filter->filter_rw(&c); } break;
+            case CoordinateType::XY:
+                for (auto& c : items<CoordinateXY>()) {
+                    if (filter->isDone()) break;
+                    filter->filter_rw(&c);
+                }
+                break;
+            case CoordinateType::XYZ:
+                for (auto& c : items<Coordinate>()) {
+                    if (filter->isDone()) break;
+                    filter->filter_rw(&c);
+                }
+                break;
+            case CoordinateType::XYM:
+                for (auto& c : items<CoordinateXYM>()) {
+                    if (filter->isDone()) break;
+                    filter->filter_rw(&c);
+                }
+                break;
+            case CoordinateType::XYZM:
+                for (auto& c : items<CoordinateXYZM>()) {
+                    if (filter->isDone()) break;
+                    filter->filter_rw(&c);
+                }
+                break;
         }
         m_hasdim = m_hasz = false; // re-check (see http://trac.osgeo.org/geos/ticket/435)
     }
@@ -646,10 +652,30 @@ public:
     template<typename Filter>
     void apply_ro(Filter* filter) const {
         switch(getCoordinateType()) {
-            case CoordinateType::XY:    for (const auto& c : items<CoordinateXY>())   { filter->filter_ro(&c); } break;
-            case CoordinateType::XYZ:   for (const auto& c : items<Coordinate>())     { filter->filter_ro(&c); } break;
-            case CoordinateType::XYM:   for (const auto& c : items<CoordinateXYM>())  { filter->filter_ro(&c); } break;
-            case CoordinateType::XYZM:  for (const auto& c : items<CoordinateXYZM>()) { filter->filter_ro(&c); } break;
+            case CoordinateType::XY:
+                for (const auto& c : items<CoordinateXY>()) {
+                    if (filter->isDone()) break;
+                    filter->filter_ro(&c);
+                }
+                break;
+            case CoordinateType::XYZ:
+                for (const auto& c : items<Coordinate>()) {
+                    if (filter->isDone()) break;
+                    filter->filter_ro(&c);
+                }
+                break;
+            case CoordinateType::XYM:
+                for (const auto& c : items<CoordinateXYM>()) {
+                    if (filter->isDone()) break;
+                    filter->filter_ro(&c);
+                }
+                break;
+            case CoordinateType::XYZM:
+                for (const auto& c : items<CoordinateXYZM>()) {
+                    if (filter->isDone()) break;
+                    filter->filter_ro(&c);
+                }
+                break;
         }
     }
 

package/dist/prebuilt/Android-arm64-v8a/include/geos/geom/CoordinateSequences.h

@@ -37,7 +37,7 @@ private:
 public:
     ///
     /// \brief binaryDispatch calls a functor template, explicitly providing the backing types of two CoordinateSequences. The
-    /// CoordinateSequences are not provided to the functor as arguments but can be provided along with any other arugments
+    /// CoordinateSequences are not provided to the functor as arguments but can be provided along with any other arguments
     /// through the `args` argument.
     template<typename F, class... Args>
     static void binaryDispatch(const CoordinateSequence& seq1, const CoordinateSequence& seq2, F& fun, Args... args)

package/dist/prebuilt/Android-arm64-v8a/include/geos/geom/Curve.h

@@ -0,0 +1,71 @@
+/**********************************************************************
+ *
+ * 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/geom/Geometry.h>
+
+namespace geos {
+namespace geom {
+
+class SimpleCurve;
+
+class GEOS_DLL Curve : public Geometry {
+
+public:
+    using Geometry::apply_ro;
+    using Geometry::apply_rw;
+
+    void apply_ro(GeometryComponentFilter* filter) const override;
+
+    void apply_ro(GeometryFilter* filter) const override;
+
+    void apply_rw(GeometryComponentFilter* filter) override;
+
+    void apply_rw(GeometryFilter* filter) override;
+
+    /**
+     * \brief
+     * Returns Dimension::False for a closed Curve,
+     * 0 otherwise (Curve boundary is a MultiPoint)
+     */
+    int
+    getBoundaryDimension() const override
+    {
+        return isClosed() ? Dimension::False : 0;
+    }
+
+    /// Returns line dimension (1)
+    Dimension::DimensionType getDimension() const override
+    {
+        return Dimension::L; // line
+    }
+
+    /// Returns true if the first and last coordinate in the Curve are the same
+    virtual bool isClosed() const = 0;
+
+    /// Returns true if the curve is closed and simple
+    bool isRing() const;
+
+    virtual std::size_t getNumCurves() const = 0;
+
+    virtual const SimpleCurve* getCurveN(std::size_t) const = 0;
+
+protected:
+    Curve(const GeometryFactory& factory) : Geometry(&factory) {}
+
+};
+
+}
+}

package/dist/prebuilt/Android-arm64-v8a/include/geos/geom/CurvePolygon.h

@@ -0,0 +1,58 @@
+/**********************************************************************
+ *
+ * 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/geom/SurfaceImpl.h>
+
+namespace geos {
+namespace geom {
+
+class GEOS_DLL CurvePolygon : public SurfaceImpl<Curve> {
+    friend class GeometryFactory;
+
+public:
+    ~CurvePolygon() override = default;
+
+    double getArea() const override;
+
+    std::unique_ptr<Geometry> getBoundary() const override;
+
+    std::unique_ptr<CoordinateSequence> getCoordinates() const override;
+
+    std::string getGeometryType() const override;
+
+    GeometryTypeId getGeometryTypeId() const override;
+
+    bool hasCurvedComponents() const override;
+
+    void normalize() override;
+
+protected:
+    using SurfaceImpl::SurfaceImpl;
+
+    Geometry* cloneImpl() const override;
+
+    int
+    getSortIndex() const override
+    {
+        return SORTINDEX_CURVEPOLYGON;
+    }
+
+    Geometry* reverseImpl() const override;
+};
+
+
+}
+}

package/dist/prebuilt/Android-arm64-v8a/include/geos/geom/Envelope.h

@@ -48,7 +48,8 @@ class Coordinate;
  * It is often used to represent the bounding box of a Geometry,
  * e.g. the minimum and maximum x and y values of the Coordinates.
  *
- * Note that Envelopes support infinite or half-infinite regions, by using
+ * Envelopes allow null values, which are represented with NaN values for ordinates.
+ * Envelopes support infinite or half-infinite regions, by using
  * the values of `Double_POSITIVE_INFINITY` and `Double_NEGATIVE_INFINITY`.
  *
  * When Envelope objects are created or initialized, the supplies extent
@@ -301,8 +302,8 @@ public:
     }
 
     /** \brief
-     * Returns the Envelope maximum y-value. `min y > max y` indicates
-     * that this is a null Envelope.
+     * Returns the Envelope maximum y-value. 
+     * Null envelopes do not have maximum values.
      */
     double getMaxY() const
     {
@@ -311,8 +312,8 @@ public:
     };
 
     /** \brief
-     * Returns the Envelope maximum x-value. `min x > max x` indicates
-     * that this is a null Envelope.
+     * Returns the Envelope maximum x-value. 
+     * Null envelopes do not have maximum values.
      */
     double getMaxX() const
     {
@@ -321,8 +322,8 @@ public:
     };
 
     /** \brief
-     * Returns the Envelope minimum y-value. `min y > max y` indicates
-     * that this is a null Envelope.
+     * Returns the Envelope minimum y-value. 
+     * Null envelopes do not have maximum values.
      */
     double getMinY() const
     {
@@ -331,8 +332,8 @@ public:
     };
 
     /** \brief
-     * Returns the Envelope minimum x-value. `min x > max x` indicates
-     * that this is a null Envelope.
+     * Returns the Envelope minimum x-value. 
+     * Null envelopes do not have maximum values.
      */
     double getMinX() const
     {
@@ -371,7 +372,7 @@ public:
      * @param result the envelope representing the intersection of
      *               the envelopes (this will be the null envelope
      *               if either argument is null, or they do not intersect)
-     * @return false if not intersection is found
+     * @return false if no intersection is found
      */
     bool intersection(const Envelope& env, Envelope& result) const;
 

package/dist/prebuilt/Android-arm64-v8a/include/geos/geom/Geometry.h

@@ -34,6 +34,7 @@
 #include <geos/geom/Envelope.h>
 #include <geos/geom/Dimension.h> // for Dimension::DimensionType
 #include <geos/geom/GeometryComponentFilter.h> // for inheritance
+#include <geos/geom/CoordinateSequence.h> // to materialize CoordinateSequence
 
 #include <algorithm>
 #include <string>
@@ -70,7 +71,7 @@ namespace geos { // geos
 namespace geom { // geos::geom
 
 /// Geometry types
-enum GeometryTypeId {
+enum GeometryTypeId : int {
     /// a point
     GEOS_POINT,
     /// a linestring
@@ -86,7 +87,12 @@ enum GeometryTypeId {
     /// a collection of polygons
     GEOS_MULTIPOLYGON,
     /// a collection of heterogeneus geometries
-    GEOS_GEOMETRYCOLLECTION
+    GEOS_GEOMETRYCOLLECTION,
+    GEOS_CIRCULARSTRING,
+    GEOS_COMPOUNDCURVE,
+    GEOS_CURVEPOLYGON,
+    GEOS_MULTICURVE,
+    GEOS_MULTISURFACE,
 };
 
 enum GeometrySortIndex {
@@ -97,7 +103,12 @@ enum GeometrySortIndex {
     SORTINDEX_MULTILINESTRING = 4,
     SORTINDEX_POLYGON = 5,
     SORTINDEX_MULTIPOLYGON = 6,
-    SORTINDEX_GEOMETRYCOLLECTION = 7
+    SORTINDEX_GEOMETRYCOLLECTION = 7,
+    SORTINDEX_CIRCULARSTRING = 8,
+    SORTINDEX_COMPOUNDCURVE = 9,
+    SORTINDEX_CURVEPOLYGON = 10,
+    SORTINDEX_MULTICURVE = 11,
+    SORTINDEX_MULTISURFACE = 12,
 };
 
 /**
@@ -299,11 +310,19 @@ public:
     /// Return a string representation of this Geometry type
     virtual std::string getGeometryType() const = 0; //Abstract
 
+    /// Returns whether the Geometry contains curved components
+    virtual bool hasCurvedComponents() const;
+
     /// Return an integer representation of this Geometry type
     virtual GeometryTypeId getGeometryTypeId() const = 0; //Abstract
 
-    /// Returns the number of geometries in this collection
-    /// (or 1 if this is not a collection)
+    /**
+     * \brief Returns the number of geometries in this collection,
+     * or 1 if this is not a collection.
+     *
+     * Empty collection or multi-geometry types return 0,
+     * and empty simple geometry types return 1.
+     */
     virtual std::size_t
     getNumGeometries() const
     {
@@ -593,11 +612,7 @@ public:
      * @see Geometry#within
      * @see Geometry#covers
      */
-    bool
-    coveredBy(const Geometry* g) const
-    {
-        return g->covers(this);
-    }
+    bool coveredBy(const Geometry* g) const;
 
 
     /// Returns the Well-known Text representation of this Geometry.
@@ -914,11 +929,34 @@ protected:
 
     virtual int compareToSameClass(const Geometry* geom) const = 0; //Abstract
 
-    int compare(std::vector<Coordinate> a, std::vector<Coordinate> b) const;
+    template<typename T>
+    static int compare(const T& a, const T& b)
+    {
+        std::size_t i = 0;
+        std::size_t j = 0;
+        while(i < a.size() && j < b.size()) {
+            const auto& aGeom = *a[i];
+            const auto& bGeom = *b[j];
+
+            int comparison = aGeom.compareTo(&bGeom);
+            if(comparison != 0) {
+                return comparison;
+            }
+
+            i++;
+            j++;
+        }
 
-    int compare(std::vector<Geometry*> a, std::vector<Geometry*> b) const;
+        if(i < a.size()) {
+            return 1;
+        }
 
-    int compare(const std::vector<std::unique_ptr<Geometry>> & a, const std::vector<std::unique_ptr<Geometry>> & b) const;
+        if(j < b.size()) {
+            return -1;
+        }
+
+        return 0;
+    }
 
     bool equal(const CoordinateXY& a, const CoordinateXY& b,
                double tolerance) const;

package/dist/prebuilt/Android-arm64-v8a/include/geos/geom/GeometryCollection.h

@@ -246,6 +246,9 @@ protected:
 
     int compareToSameClass(const Geometry* gc) const override;
 
+    bool hasCurvedComponents() const override;
+
+
 };
 
 } // namespace geos::geom