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

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

@@ -26,6 +26,7 @@
 #include <geos/geom/MultiLineString.h>
 #include <geos/geom/MultiPolygon.h>
 #include <geos/geom/PrecisionModel.h>
+#include <geos/geom/Polygon.h>
 #include <geos/util/IllegalArgumentException.h>
 #include <geos/export.h>
 
@@ -36,6 +37,8 @@
 namespace geos {
 namespace geom {
 class Coordinate;
+class CircularString;
+class CompoundCurve;
 class CoordinateSequence;
 class Envelope;
 class Geometry;
@@ -43,9 +46,11 @@ class GeometryCollection;
 class LineString;
 class LinearRing;
 class MultiLineString;
+class MultiCurve;
 class MultiPoint;
 class MultiPolygon;
-class Polygon;
+class MultiSurface;
+class CurvePolygon;
 }
 }
 
@@ -121,7 +126,7 @@ public:
     static const GeometryFactory*
     getDefaultInstance();
 
-//Skipped a lot of list to array convertors
+//Skipped a lot of list to array converters
 
     static std::unique_ptr<Point> createPointFromInternalCoord(const Coordinate* coord,
                                         const Geometry* exemplar);
@@ -142,6 +147,7 @@ public:
 
     /// Creates an EMPTY Point
     std::unique_ptr<Point> createPoint(std::size_t coordinateDimension = 2) const;
+    std::unique_ptr<Point> createPoint(bool hasZ, bool hasM) const;
 
     /// Creates a Point using the given Coordinate
     std::unique_ptr<Point> createPoint(const Coordinate& coordinate) const;
@@ -159,7 +165,7 @@ public:
     std::unique_ptr<GeometryCollection> createGeometryCollection() const;
 
     /// Construct the EMPTY Geometry
-    std::unique_ptr<Geometry> createEmptyGeometry() const;
+    std::unique_ptr<Geometry> createEmptyGeometry(GeometryTypeId type = GEOS_GEOMETRYCOLLECTION, bool hasZ=false, bool hasM=false) const;
 
     /// Construct a GeometryCollection taking ownership of given arguments
     template<typename T>
@@ -187,6 +193,16 @@ public:
     std::unique_ptr<MultiLineString> createMultiLineString(
             std::vector<std::unique_ptr<Geometry>> && fromLines) const;
 
+    /// Construct an EMPTY MultiCurve
+    std::unique_ptr<MultiCurve> createMultiCurve() const;
+
+    /// Construct a MultiCurve taking ownership of given arguments
+    std::unique_ptr<MultiCurve> createMultiCurve(
+            std::vector<std::unique_ptr<Geometry>> && fromCurves) const;
+
+    std::unique_ptr<MultiCurve> createMultiCurve(
+            std::vector<std::unique_ptr<Curve>> && fromCurves) const;
+
     /// Construct an EMPTY MultiPolygon
     std::unique_ptr<MultiPolygon> createMultiPolygon() const;
 
@@ -201,8 +217,19 @@ public:
     std::unique_ptr<MultiPolygon> createMultiPolygon(
             std::vector<std::unique_ptr<Geometry>> && fromPolys) const;
 
+    /// Construct an EMPTY MultiSurface
+    std::unique_ptr<MultiSurface> createMultiSurface() const;
+
+    /// Construct a MultiSurface taking ownership of given arguments
+    std::unique_ptr<MultiSurface> createMultiSurface(
+            std::vector<std::unique_ptr<Geometry>> && from) const;
+
+    std::unique_ptr<MultiSurface> createMultiSurface(
+            std::vector<std::unique_ptr<Surface>> && from) const;
+
     /// Construct an EMPTY LinearRing
     std::unique_ptr<LinearRing> createLinearRing(std::size_t coordinateDimension = 2) const;
+    std::unique_ptr<LinearRing> createLinearRing(bool hasZ, bool hasM) const;
 
     /// Construct a LinearRing taking ownership of given arguments
     std::unique_ptr<LinearRing> createLinearRing(
@@ -244,6 +271,7 @@ public:
 
     /// Construct an EMPTY Polygon
     std::unique_ptr<Polygon> createPolygon(std::size_t coordinateDimension = 2) const;
+    std::unique_ptr<Polygon> createPolygon(bool hasZ, bool hasM) const;
 
     /// Construct a Polygon taking ownership of given arguments
     std::unique_ptr<Polygon> createPolygon(std::unique_ptr<LinearRing> && shell) const;
@@ -258,8 +286,19 @@ public:
     Polygon* createPolygon(const LinearRing& shell,
                            const std::vector<LinearRing*>& holes) const;
 
+
+    /// Construct an EMPTY CurvePolygon
+    std::unique_ptr<CurvePolygon> createCurvePolygon(bool hasZ, bool hasM) const;
+
+    /// Construct a CurvePolygon taking ownership of given arguments
+    std::unique_ptr<CurvePolygon> createCurvePolygon(std::unique_ptr<Curve>&& shell) const;
+
+    std::unique_ptr<CurvePolygon> createCurvePolygon(std::unique_ptr<Curve>&& shell,
+                                                     std::vector<std::unique_ptr<Curve>> && holes) const;
+
     /// Construct an EMPTY LineString
     std::unique_ptr<LineString> createLineString(std::size_t coordinateDimension = 2) const;
+    std::unique_ptr<LineString> createLineString(bool hasZ, bool hasM) const;
 
     /// Copy a LineString
     std::unique_ptr<LineString> createLineString(const LineString& ls) const;
@@ -272,6 +311,26 @@ public:
     std::unique_ptr<LineString> createLineString(
         const CoordinateSequence& coordinates) const;
 
+    /// Construct an EMPTY CircularString
+    std::unique_ptr<CircularString> createCircularString(bool hasZ, bool hasM) const;
+
+    /// Copy a CircularString
+    std::unique_ptr<CircularString> createCircularString(const CircularString& ls) const;
+
+    /// Construct a CircularString taking ownership of given argument
+    std::unique_ptr<CircularString> createCircularString(
+        std::unique_ptr<CoordinateSequence> && coordinates) const;
+
+    /// Construct a CircularString with a deep-copy of given argument
+    std::unique_ptr<CircularString> createCircularString(
+        const CoordinateSequence& coordinates) const;
+
+    /// Construct an EMPTY CompoundCurve
+    std::unique_ptr<CompoundCurve> createCompoundCurve() const;
+
+    /// Construct a CompoundCurve taking ownership of given argument
+    std::unique_ptr<CompoundCurve> createCompoundCurve(std::vector<std::unique_ptr<SimpleCurve>>&&) const;
+
     /**
     * Creates an empty atomic geometry of the given dimension.
     * If passed a dimension of -1 will create an empty {@link GeometryCollection}.
@@ -330,7 +389,7 @@ public:
 
     /// See buildGeometry(std::vector<Geometry *>&) for semantics
     //
-    /// Will clone the geometries accessible trough the iterator.
+    /// Will clone the geometries accessible through the iterator.
     ///
     /// @tparam T an iterator yielding something which casts to const Geometry*
     /// @param from start iterator

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

@@ -0,0 +1,110 @@
+/**********************************************************************
+ *
+ * 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
+
+namespace geos {
+namespace geom {
+
+class Curve;
+class CurvePolygon;
+class GeometryCollection;
+class LineString;
+class LinearRing;
+class MultiCurve;
+class MultiLineString;
+class MultiPoint;
+class MultiPolygon;
+class MultiSurface;
+class Point;
+class Polygon;
+class SimpleCurve;
+class Surface;
+
+// These structures allow templates to have compile-time access to a type's human-readable name.
+template<typename T>
+struct GeometryTypeName {};
+
+template<>
+struct GeometryTypeName<geom::Curve> {
+    static constexpr const char* name = "Curve";
+};
+
+template<>
+struct GeometryTypeName<geom::CurvePolygon> {
+    static constexpr const char* name = "CurvePolygon";
+};
+
+template<>
+struct GeometryTypeName<geom::GeometryCollection> {
+    static constexpr const char* name = "GeometryCollection";
+};
+
+template<>
+struct GeometryTypeName<geom::LineString> {
+    static constexpr const char* name = "LineString";
+};
+
+template<>
+struct GeometryTypeName<geom::LinearRing> {
+    static constexpr const char* name = "LinearRing";
+};
+
+template<>
+struct GeometryTypeName<geom::MultiCurve> {
+    static constexpr const char* name = "MultiCurve";
+};
+
+template<>
+struct GeometryTypeName<geom::MultiLineString> {
+    static constexpr const char* name = "MultiLineString";
+};
+
+template<>
+struct GeometryTypeName<geom::MultiPoint> {
+    static constexpr const char* name = "MultiPoint";
+};
+
+template<>
+struct GeometryTypeName<geom::MultiPolygon> {
+    static constexpr const char* name = "MultiPolygon";
+};
+
+template<>
+struct GeometryTypeName<geom::MultiSurface> {
+    static constexpr const char* name = "MultiSurface";
+};
+
+template<>
+struct GeometryTypeName<geom::Point> {
+    static constexpr const char* name = "Point";
+};
+
+template<>
+struct GeometryTypeName<geom::Polygon> {
+    static constexpr const char* name = "Polygon";
+};
+
+template<>
+struct GeometryTypeName<geom::SimpleCurve> {
+    static constexpr const char* name = "SimpleCurve";
+};
+
+template<>
+struct GeometryTypeName<geom::Surface> {
+    static constexpr const char* name = "Surface";
+};
+
+}
+}

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

@@ -61,7 +61,7 @@ public:
     IntersectionMatrix();
 
     /** \brief
-     * Overriden constructor.
+     * Overridden constructor.
      *
      * Creates an IntersectionMatrix with the given dimension symbols.
      *
@@ -226,7 +226,7 @@ public:
      *
      * @return the dimension value at the given matrix position.
      */
-    int get(geom::Location row, geom::Location column) const {
+    int get(Location row, Location column) const {
         return matrix[static_cast<size_t>(row)][static_cast<size_t>(column)];
     }
 
@@ -363,6 +363,7 @@ public:
      */
     std::string toString() const;
 
+
 private:
 
     static const int firstDim; // = 3;

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

@@ -246,10 +246,11 @@ public:
         return std::atan2(p1.y - p0.y, p1.x - p0.x);
     };
 
-    /// Computes the midpoint of the segment
-    //
-    /// @return the midpoint of the segment
-    ///
+    /** \brief
+     * Computes the midpoint of the segment
+     *
+     *  @return the midpoint of the segment
+     */
     CoordinateXY midPoint() const
     {
         return midPoint(p0, p1);
@@ -321,7 +322,8 @@ public:
     {
         ret = Coordinate(
             p0.x + segmentLengthFraction * (p1.x - p0.x),
-            p0.y + segmentLengthFraction * (p1.y - p0.y));
+            p0.y + segmentLengthFraction * (p1.y - p0.y),
+            p0.z + segmentLengthFraction * (p1.z - p0.z));
     };
 
     /** \brief

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

@@ -25,6 +25,7 @@
 #include <geos/geom/CoordinateSequence.h> // for proper use of unique_ptr<>
 #include <geos/geom/Envelope.h> // for proper use of unique_ptr<>
 #include <geos/geom/Dimension.h> // for Dimension::DimensionType
+#include <geos/geom/SimpleCurve.h>
 
 #include <string>
 #include <vector>
@@ -62,7 +63,7 @@ namespace geom { // geos::geom
  *  If these conditions are not met, the constructors throw
  *  an {@link util::IllegalArgumentException}.
  */
-class GEOS_DLL LineString: public Geometry {
+class GEOS_DLL LineString: public SimpleCurve {
 
 public:
 
@@ -85,111 +86,16 @@ public:
         return std::unique_ptr<LineString>(cloneImpl());
     }
 
-    std::unique_ptr<CoordinateSequence> getCoordinates() const override;
-
-    /// Returns a read-only pointer to internal CoordinateSequence
-    const CoordinateSequence* getCoordinatesRO() const;
-
-    virtual const Coordinate& getCoordinateN(std::size_t n) const;
-
-    /**
-     * \brief
-     * Take ownership of the CoordinateSequence managed by this geometry.
-     * After releasing the coordinates, the geometry should be considered
-     * in a moved-from state and should not be accessed.
-     * @return this Geometry's CoordinateSequence.
-     */
-    std::unique_ptr<CoordinateSequence> releaseCoordinates();
-
-    /// Returns line dimension (1)
-    Dimension::DimensionType getDimension() const override;
-
-    /**
-     * \brief
-     * Returns Dimension::False for a closed LineString,
-     * 0 otherwise (LineString boundary is a MultiPoint)
-     */
-    int getBoundaryDimension() const override;
-
-    /// Returns coordinate dimension.
-    uint8_t getCoordinateDimension() const override;
-
-    bool hasM() const override;
-
-    bool hasZ() const override;
-
-    /**
-     * \brief
-     * Returns a MultiPoint.
-     * Empty for closed LineString, a Point for each vertex otherwise.
-     */
-    std::unique_ptr<Geometry> getBoundary() const override;
-
-    bool isEmpty() const override;
-
-    std::size_t getNumPoints() const override;
-
-    virtual std::unique_ptr<Point> getPointN(std::size_t n) const;
-
-    /// \brief
-    /// Return the start point of the LineString
-    /// or NULL if this is an EMPTY LineString.
-    ///
-    virtual std::unique_ptr<Point> getStartPoint() const;
-
-    /// \brief
-    /// Return the end point of the LineString
-    /// or NULL if this is an EMPTY LineString.
-    ///
-    virtual std::unique_ptr<Point> getEndPoint() const;
-
-    virtual bool isClosed() const;
-
-    virtual bool isRing() const;
-
     std::string getGeometryType() const override;
 
     GeometryTypeId getGeometryTypeId() const override;
 
-    virtual bool isCoordinate(Coordinate& pt) const;
-
-    bool equalsExact(const Geometry* other, double tolerance = 0)
-    const override;
-
-    bool equalsIdentical(const Geometry* other) const override;
-
-    void apply_rw(const CoordinateFilter* filter) override;
-
-    void apply_ro(CoordinateFilter* filter) const override;
-
-    void apply_rw(GeometryFilter* filter) override;
-
-    void apply_ro(GeometryFilter* filter) const override;
-
-    void apply_rw(GeometryComponentFilter* filter) override;
-
-    void apply_ro(GeometryComponentFilter* filter) const override;
-
-    void apply_rw(CoordinateSequenceFilter& filter) override;
-
-    void apply_ro(CoordinateSequenceFilter& filter) const override;
-
-    /** \brief
-     * Normalizes a LineString.
-     *
-     * A normalized linestring
-     * has the first point which is not equal to its reflected point
-     * less than the reflected point.
-     */
-    void normalize() override;
-
-    //was protected
-    int compareToSameClass(const Geometry* ls) const override;
-
-    const CoordinateXY* getCoordinate() const override;
-
     double getLength() const override;
 
+    bool isCurved() const override {
+        return false;
+    }
+
     /**
      * Creates a LineString whose coordinates are in the reverse
      * order of this object's
@@ -198,10 +104,6 @@ public:
      */
     std::unique_ptr<LineString> reverse() const { return std::unique_ptr<LineString>(reverseImpl()); }
 
-    const Envelope* getEnvelopeInternal() const override {
-        return &envelope;
-    }
-
 protected:
 
     LineString(const LineString& ls);
@@ -216,28 +118,20 @@ protected:
 
     LineString* reverseImpl() const override;
 
-    Envelope computeEnvelopeInternal() const;
-
-    CoordinateSequence::Ptr points;
-
-    mutable Envelope envelope;
-
     int
     getSortIndex() const override
     {
         return SORTINDEX_LINESTRING;
     };
 
-    void geometryChangedAction() override {
-        envelope = computeEnvelopeInternal();
+    void geometryChangedAction() override
+    {
+        envelope = computeEnvelopeInternal(true);
     }
 
 private:
 
     void validateConstruction();
-    void normalizeClosed();
-
-
 };
 
 struct GEOS_DLL  LineStringLT {

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

@@ -0,0 +1,126 @@
+/**********************************************************************
+ *
+ * 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/Curve.h>
+#include <geos/geom/GeometryCollection.h>
+
+namespace geos {
+namespace geom {
+
+class GEOS_DLL MultiCurve : public GeometryCollection {
+    friend class GeometryFactory;
+
+public:
+    ~MultiCurve() override = default;
+
+    std::unique_ptr<MultiCurve> clone() const
+    {
+        return std::unique_ptr<MultiCurve>(cloneImpl());
+    };
+
+    /// Returns a (possibly empty) [MultiPoint](@ref geom::MultiPoint)
+    std::unique_ptr<Geometry> getBoundary() const override;
+
+    /**
+     * \brief
+     * Returns Dimension::False if all [Curves](@ref geom::Curve) in the collection
+     * are closed, 0 otherwise.
+     */
+    int getBoundaryDimension() const override;
+
+    /// Returns line dimension (1)
+    Dimension::DimensionType getDimension() const override;
+
+    const Curve* getGeometryN(std::size_t n) const override;
+
+    std::string getGeometryType() const override;
+
+    GeometryTypeId getGeometryTypeId() const override;
+
+    bool hasDimension(Dimension::DimensionType d) const override
+    {
+        return d == Dimension::L;
+    }
+
+    /// Returns true if the MultiCurve is not empty, and every included
+    /// Curve is also closed.
+    bool isClosed() const;
+
+    bool isDimensionStrict(Dimension::DimensionType d) const override
+    {
+        return d == Dimension::L;
+    }
+
+    /**
+     * Creates a MultiCurve in the reverse
+     * order to this object.
+     * Both the order of the component Curves
+     * and the order of their coordinate sequences
+     * are reversed.
+     *
+     * @return a MultiCurve in the reverse order
+     */
+    std::unique_ptr<MultiCurve> reverse() const
+    {
+        return std::unique_ptr<MultiCurve>(reverseImpl());
+    }
+
+protected:
+
+    /**
+     * \brief Constructs a MultiCurve.
+     *
+     * @param  newLines The [Curves](@ref geom::Curve) for this
+     *                  MultiCurve, or `null`
+     *                  or an empty array to create the empty geometry.
+     *                  Elements may be empty Curve,
+     *                  but not `null`s.
+     *
+     * @param newFactory The GeometryFactory used to create this geometry.
+     *                   Caller must keep the factory alive for the life-time
+     *                   of the constructed MultiCurve.
+     *
+     * @note Constructed object will take ownership of
+     *       the vector and its elements.
+     *
+     */
+    MultiCurve(std::vector<std::unique_ptr<Curve>>&& newLines,
+               const GeometryFactory& newFactory);
+
+    MultiCurve(std::vector<std::unique_ptr<Geometry>>&& newLines,
+               const GeometryFactory& newFactory);
+
+    MultiCurve(const MultiCurve& mp)
+        : GeometryCollection(mp)
+    {}
+
+    MultiCurve* cloneImpl() const override
+    {
+        return new MultiCurve(*this);
+    }
+
+    MultiCurve* reverseImpl() const override;
+
+    int
+    getSortIndex() const override
+    {
+        return SORTINDEX_MULTICURVE;
+    };
+
+};
+
+}
+}

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

@@ -138,6 +138,11 @@ protected:
         return SORTINDEX_MULTILINESTRING;
     };
 
+    bool hasCurvedComponents() const override
+    {
+        return false;
+    }
+
 };
 
 

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

@@ -134,6 +134,11 @@ protected:
         return SORTINDEX_MULTIPOINT;
     };
 
+    bool hasCurvedComponents() const override
+    {
+        return false;
+    }
+
 };
 
 #ifdef _MSC_VER

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

@@ -26,7 +26,6 @@
 #include <geos/geom/GeometryCollection.h> // for inheritance
 #include <geos/geom/Polygon.h> // for inheritance
 #include <geos/geom/Dimension.h> // for Dimension::DimensionType
-#include <geos/geom/MultiPolygon.h>
 #include <geos/geom/GeometryCollection.h>
 
 
@@ -35,6 +34,7 @@ namespace geos {
 namespace geom { // geos::geom
 class Coordinate;
 class MultiPoint;
+class Polygon;
 }
 }
 
@@ -140,6 +140,11 @@ protected:
         return SORTINDEX_MULTIPOLYGON;
     };
 
+    bool hasCurvedComponents() const override
+    {
+        return false;
+    }
+
 };
 
 #ifdef _MSC_VER