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

package/dist/prebuilt/Android-arm64-v8a/include/geos/io/WKTWriter.h

@@ -39,6 +39,8 @@ class Coordinate;
 class CoordinateXY;
 class CoordinateXYZM;
 class CoordinateSequence;
+class Curve;
+class CompoundCurve;
 class Geometry;
 class GeometryCollection;
 class Point;
@@ -49,6 +51,8 @@ class MultiPoint;
 class MultiLineString;
 class MultiPolygon;
 class PrecisionModel;
+class SimpleCurve;
+class Surface;
 }
 namespace io {
 class Writer;
@@ -117,7 +121,7 @@ public:
      *
      * @return the WKT
      */
-    static std::string toLineString(const geom::Coordinate& p0, const geom::Coordinate& p1);
+    static std::string toLineString(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1);
 
     /**
      * Generates the WKT for a <code>Point</code>.
@@ -195,6 +199,9 @@ public:
      */
     void setOutputDimension(uint8_t newOutputDimension);
 
+    static std::string writeNumber(double d, bool trim, uint32_t precision);
+    static int writeTrimmedNumber(double d, uint32_t precision, char* buf);
+
 protected:
 
     int decimalPlaces;
@@ -205,23 +212,28 @@ protected:
             int level,
             Writer& writer) const;
 
+    void appendTag(
+            const geom::Geometry& geometry,
+            OrdinateSet outputOrdinates,
+            Writer& writer) const;
+
     void appendPointTaggedText(
         const geom::Point& point,
         OrdinateSet outputOrdinates,
         int level, Writer& writer) const;
 
-    void appendLineStringTaggedText(
-        const geom::LineString& lineString,
+    void appendSimpleCurveTaggedText(
+        const geom::SimpleCurve& lineString,
         OrdinateSet outputOrdinates,
         int level, Writer& writer) const;
 
-    void appendLinearRingTaggedText(
-        const geom::LinearRing& lineString,
+    void appendCompoundCurveTaggedText(
+        const geom::CompoundCurve& lineString,
         OrdinateSet outputOrdinates,
         int level, Writer& writer) const;
 
-    void appendPolygonTaggedText(
-        const geom::Polygon& polygon,
+    void appendSurfaceTaggedText(
+        const geom::Surface& polygon,
         OrdinateSet outputOrdinates,
         int level, Writer& writer) const;
 
@@ -230,13 +242,13 @@ protected:
         OrdinateSet outputOrdinates,
         int level, Writer& writer) const;
 
-    void appendMultiLineStringTaggedText(
-        const geom::MultiLineString& multiLineString,
+    void appendMultiCurveTaggedText(
+        const geom::GeometryCollection& multiCurve,
         OrdinateSet outputOrdinates,
         int level, Writer& writer) const;
 
-    void appendMultiPolygonTaggedText(
-        const geom::MultiPolygon& multiPolygon,
+    void appendMultiSurfaceTaggedText(
+        const geom::GeometryCollection& multiSurface,
         OrdinateSet outputOrdinates,
         int level, Writer& writer) const;
 
@@ -260,13 +272,18 @@ protected:
 
     std::string writeNumber(double d) const;
 
-    void appendLineStringText(
-        const geom::LineString& lineString,
+    void appendCurveText(
+        const geom::Curve& lineString,
         OrdinateSet outputOrdinates,
         int level, bool doIndent, Writer& writer) const;
 
-    void appendPolygonText(
-        const geom::Polygon& polygon,
+    void appendSimpleCurveText(
+        const geom::SimpleCurve& lineString,
+        OrdinateSet outputOrdinates,
+        int level, bool doIndent, Writer& writer) const;
+
+    void appendSurfaceText(
+        const geom::Surface& polygon,
         OrdinateSet outputOrdinates,
         int level, bool indentFirst, Writer& writer) const;
 
@@ -275,13 +292,13 @@ protected:
         OrdinateSet outputOrdinates,
         int level, Writer& writer) const;
 
-    void appendMultiLineStringText(
-        const geom::MultiLineString& multiLineString,
+    void appendMultiCurveText(
+        const geom::GeometryCollection& multiCurve,
         OrdinateSet outputOrdinates,
         int level, bool indentFirst, Writer& writer) const;
 
-    void appendMultiPolygonText(
-        const geom::MultiPolygon& multiPolygon,
+    void appendMultiSurfaceText(
+        const geom::GeometryCollection& multiSurface,
         OrdinateSet outputOrdinates,
         int level, Writer& writer) const;
 
@@ -296,8 +313,6 @@ private:
         INDENT = 2
     };
 
-//	static const int INDENT = 2;
-
     bool isFormatted;
 
     int roundingPrecision;
@@ -306,8 +321,6 @@ private:
 
     bool removeEmptyDimensions = false;
 
-    int level;
-
     static constexpr int coordsPerLine = 10;
 
     uint8_t defaultOutputDimension;

package/dist/prebuilt/Android-arm64-v8a/include/geos/linearref/LengthIndexedLine.h

@@ -157,7 +157,7 @@ public:
      *
      * (The subline must **conform** to the line; that is,
      * all vertices in the subline (except possibly the first and last)
-     * must be vertices of the line and occcur in the same order).
+     * must be vertices of the line and occur in the same order).
      *
      * @param subLine a subLine of the line
      * @return a pair of indices for the start and end of the subline.

package/dist/prebuilt/Android-arm64-v8a/include/geos/math/DD.h

@@ -93,6 +93,7 @@
 #pragma once
 
 #include <cmath>
+#include <geos/export.h>
 
 namespace geos {
 namespace math { // geos.math

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

@@ -143,7 +143,7 @@ namespace index { // geos.index
 /// formats.
 ///
 /// The Java Topology Suite (JTS) is a Java API that implements a core set of
-/// spatial data operations usin g an explicit precision model and robust
+/// spatial data operations using an explicit precision model and robust
 /// geometric algorithms. JTS is intended to be used in the devel opment of
 /// applications that support the validation, cleaning, integration and
 /// querying of spatial data sets.

package/dist/prebuilt/Android-arm64-v8a/include/geos/noding/MCIndexSegmentSetMutualIntersector.h

@@ -20,12 +20,15 @@
 #include <geos/index/strtree/TemplateSTRtree.h> // inherited
 
 namespace geos {
+namespace geom {
+    class Envelope;
+}
 namespace index {
-class SpatialIndex;
+    class SpatialIndex;
 }
 namespace noding {
-class SegmentString;
-class SegmentIntersector;
+    class SegmentString;
+    class SegmentIntersector;
 }
 }
 
@@ -41,7 +44,7 @@ namespace noding { // geos::noding
  *
  * @version 1.7
  */
-class MCIndexSegmentSetMutualIntersector : public SegmentSetMutualIntersector {
+class GEOS_DLL MCIndexSegmentSetMutualIntersector : public SegmentSetMutualIntersector {
 public:
 
     MCIndexSegmentSetMutualIntersector(double p_tolerance)
@@ -51,6 +54,17 @@ public:
         , nOverlaps(0)
         , overlapTolerance(p_tolerance)
         , indexBuilt(false)
+        , envelope(nullptr)
+    {}
+
+    MCIndexSegmentSetMutualIntersector(const geom::Envelope* p_envelope)
+        : monoChains()
+        , indexCounter(0)
+        , processCounter(0)
+        , nOverlaps(0)
+        , overlapTolerance(0.0)
+        , indexBuilt(false)
+        , envelope(p_envelope)
     {}
 
     MCIndexSegmentSetMutualIntersector()
@@ -117,6 +131,7 @@ private:
      */
     bool indexBuilt;
     MonoChains indexChains;
+    const geom::Envelope* envelope;
 
     void addToIndex(SegmentString* segStr);
 

package/dist/prebuilt/Android-arm64-v8a/include/geos/noding/Octant.h

@@ -46,7 +46,7 @@ namespace noding { // geos.noding
  */
 class GEOS_DLL Octant {
 private:
-    Octant() {} // Can't instanciate it
+    Octant() {} // Can't instantiate it
 public:
 
     /**

package/dist/prebuilt/Android-arm64-v8a/include/geos/noding/SegmentSetMutualIntersector.h

@@ -33,7 +33,7 @@ namespace noding { // geos::noding
  * @author Martin Davis
  * @version 1.10
  */
-class SegmentSetMutualIntersector {
+class GEOS_DLL SegmentSetMutualIntersector {
 public:
 
     SegmentSetMutualIntersector()

package/dist/prebuilt/Android-arm64-v8a/include/geos/noding/SegmentString.h

@@ -131,6 +131,42 @@ public:
         return ss.getSegmentOctant(index);
     }
 
+    /**
+     * Gets the next vertex in a ring from a vertex index.
+     *
+     * @param index the vertex index
+     * @return the next vertex in the ring
+     *
+     * @see isClosed
+     */
+    const geom::CoordinateXY& nextInRing(std::size_t index) const
+    {
+        std::size_t nextIndex = index + 1;
+        if (nextIndex > size() - 1) {
+            nextIndex = 1;
+        }
+        return getCoordinate(nextIndex);
+    }
+
+    /**
+     * Gets the previous vertex in a ring from a vertex index.
+     *
+     * @param index the vertex index
+     * @return the previous vertex in the ring
+     *
+     * @see isClosed
+     */
+    const geom::CoordinateXY& prevInRing(std::size_t index) const
+    {
+        std::size_t prevIndex;
+        if (index == 0)
+            prevIndex = size() - 2;
+        else
+            prevIndex = index - 1;
+        return getCoordinate( prevIndex );
+    }
+
+
     bool isClosed() const {
         return seq->front<geom::CoordinateXY>().equals(seq->back<geom::CoordinateXY>());
     }

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/GeometryGraphOperation.h

@@ -74,9 +74,13 @@ protected:
     /** \brief
      * The operation args into an array so they can be accessed by index
      */
-    std::vector<geomgraph::GeometryGraph*> arg;
+    std::vector<std::unique_ptr<geomgraph::GeometryGraph>> arg;
 
     void setComputationPrecision(const geom::PrecisionModel* pm);
+
+    // Declare type as noncopyable
+    GeometryGraphOperation(const GeometryGraphOperation& other) = delete;
+    GeometryGraphOperation& operator=(const GeometryGraphOperation& rhs) = delete;
 };
 
 } // namespace geos.operation

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/buffer/BufferOp.h

@@ -25,6 +25,7 @@
 
 #include <geos/export.h>
 #include <geos/operation/buffer/BufferParameters.h> // for enum values
+#include <geos/geom/Geometry.h> // to materialize Geometry
 
 #include <geos/util/TopologyException.h> // for composition
 

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/buffer/OffsetCurveSection.h

@@ -16,6 +16,7 @@
 #pragma once
 
 #include <geos/export.h>
+#include <geos/geom/CoordinateSequence.h> // to materialize CoordinateSequence
 #include <memory>
 #include <vector>
 

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/distance/ConnectedElementLocationFilter.h

@@ -50,7 +50,7 @@ namespace distance { // geos::operation::distance
 class GEOS_DLL ConnectedElementLocationFilter: public geom::GeometryFilter {
 private:
 
-    std::vector<std::unique_ptr<GeometryLocation>> locations;
+    std::vector<GeometryLocation> locations;
     ConnectedElementLocationFilter() = default;
     ConnectedElementLocationFilter(const ConnectedElementLocationFilter&) = delete;
     ConnectedElementLocationFilter& operator=(const ConnectedElementLocationFilter&) = delete;
@@ -63,7 +63,7 @@ public:
      * an empty list will be returned. The elements of the list
      * are [GeometryLocations](@ref operation::distance::GeometryLocation).
      */
-    static std::vector<std::unique_ptr<GeometryLocation>> getLocations(const geom::Geometry* geom);
+    static std::vector<GeometryLocation> getLocations(const geom::Geometry* geom);
 
     void filter_ro(const geom::Geometry* geom) override;
     void filter_rw(geom::Geometry* geom) override;

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/distance/DistanceOp.h

@@ -172,19 +172,19 @@ private:
 
     // working
     algorithm::PointLocator ptLocator;
-    std::array<std::unique_ptr<GeometryLocation>, 2> minDistanceLocation;
+    std::array<GeometryLocation, 2> minDistanceLocation;
     double minDistance;
     bool computed = false;
 
-    void updateMinDistance(std::array<std::unique_ptr<GeometryLocation>, 2> & locGeom, bool flip);
+    void updateMinDistance(std::array<GeometryLocation, 2> & locGeom, bool flip);
 
     void computeMinDistance();
 
     void computeContainmentDistance();
 
-    void computeInside(std::vector<std::unique_ptr<GeometryLocation>> & locs,
+    void computeInside(std::vector<GeometryLocation> & locs,
                        const std::vector<const geom::Polygon*>& polys,
-                       std::array<std::unique_ptr<GeometryLocation>, 2> & locPtPoly);
+                       std::array<GeometryLocation, 2> & locPtPoly);
 
 
     /**
@@ -196,25 +196,25 @@ private:
     void computeMinDistanceLines(
         const std::vector<const geom::LineString*>& lines0,
         const std::vector<const geom::LineString*>& lines1,
-        std::array<std::unique_ptr<GeometryLocation>, 2> & locGeom);
+        std::array<GeometryLocation, 2> & locGeom);
 
     void computeMinDistancePoints(
         const std::vector<const geom::Point*>& points0,
         const std::vector<const geom::Point*>& points1,
-        std::array<std::unique_ptr<GeometryLocation>, 2> & locGeom);
+        std::array<GeometryLocation, 2> & locGeom);
 
     void computeMinDistanceLinesPoints(
         const std::vector<const geom::LineString*>& lines0,
         const std::vector<const geom::Point*>& points1,
-        std::array<std::unique_ptr<GeometryLocation>, 2> & locGeom);
+        std::array<GeometryLocation, 2> & locGeom);
 
     void computeMinDistance(const geom::LineString* line0,
                             const geom::LineString* line1,
-                            std::array<std::unique_ptr<GeometryLocation>, 2> & locGeom);
+                            std::array<GeometryLocation, 2> & locGeom);
 
     void computeMinDistance(const geom::LineString* line,
                             const geom::Point* pt,
-                            std::array<std::unique_ptr<GeometryLocation>, 2> & locGeom);
+                            std::array<GeometryLocation, 2> & locGeom);
 };
 
 

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/distance/GeometryLocation.h

@@ -62,6 +62,13 @@ public:
      */
     static const int INSIDE_AREA = -1;
 
+    GeometryLocation() :
+        component(nullptr),
+        segIndex(0),
+        inside_area(false),
+        pt()
+    {}
+
     /** \brief
      * Constructs a GeometryLocation specifying a point on a geometry,
      * as well as the segment that the point is on (or INSIDE_AREA if

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/overlayng/EdgeNodingBuilder.h

@@ -110,7 +110,7 @@ private:
     * This is one of:
     *
     * - Fixed precision: a snap-rounding noder (which should be fully robust)
-    * - Floating precision: a conventional nodel (which may be non-robust).
+    * - Floating precision: a conventional model (which may be non-robust).
     *   In this case, a validation step is applied to the output from the noder.
     */
     Noder* getNoder();

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/polygonize/BuildArea.h

@@ -62,7 +62,7 @@ public:
 
     ~BuildArea() = default;
 
-    /** \brief Return the area built fromthe constituent linework of the input geometry. */
+    /** \brief Return the area built from the constituent linework of the input geometry. */
     std::unique_ptr<geom::Geometry> build(const geom::Geometry* geom);
 };
 

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/polygonize/PolygonizeGraph.h

@@ -196,7 +196,7 @@ private:
 
     EdgeRing* findEdgeRing(PolygonizeDirectedEdge* startDE);
 
-    /* Tese are for memory management */
+    /* These are for memory management */
     std::vector<planargraph::Edge*> newEdges;
     std::vector<planargraph::DirectedEdge*> newDirEdges;
     std::vector<planargraph::Node*> newNodes;

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/polygonize/Polygonizer.h

@@ -192,16 +192,6 @@ public:
      */
     void add(std::vector<const geom::Geometry*>* geomList);
 
-    /**
-     * Add a geometry to the linework to be polygonized.
-     * May be called multiple times.
-     * Any dimension of Geometry may be added;
-     * the constituent linework will be extracted and used
-     *
-     * @param g a Geometry with linework to be polygonized
-     */
-    void add(geom::Geometry* g);
-
     /**
      * Add a geometry to the linework to be polygonized.
      * May be called multiple times.

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/relate/EdgeEndBundle.h

@@ -81,7 +81,7 @@ protected:
      * on the boundary and in the interior (e.g. a LineString segment
      * lying on
      * top of a Polygon edge.) In this case the Boundary is
-     * given precendence.
+     * given precedence.
      *
      * These observations result in the following rules for computing
      * the ON location:

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/relate/RelateComputer.h

@@ -76,7 +76,7 @@ namespace relate { // geos::operation::relate
  */
 class GEOS_DLL RelateComputer {
 public:
-    RelateComputer(std::vector<geomgraph::GeometryGraph*>* newArg);
+    RelateComputer(std::vector<std::unique_ptr<geomgraph::GeometryGraph>>& newArg);
     ~RelateComputer() = default;
 
     std::unique_ptr<geom::IntersectionMatrix> computeIM();
@@ -87,7 +87,7 @@ private:
     algorithm::PointLocator ptLocator;
 
     /// the arg(s) of the operation
-    std::vector<geomgraph::GeometryGraph*>* arg;
+    const std::vector<std::unique_ptr<geomgraph::GeometryGraph>>& arg;
 
     geomgraph::NodeMap nodes;
 

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/relate/RelateNode.h

@@ -42,7 +42,7 @@ namespace relate { // geos::operation::relate
  * Represents a node in the topological graph used to compute spatial
  * relationships.
  */
-class GEOS_DLL RelateNode: public geomgraph::Node {
+class GEOS_DLL RelateNode final: public geomgraph::Node {
 
 public:
 

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/relateng/AdjacentEdgeLocator.h

@@ -0,0 +1,124 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (c) 2024 Martin Davis
+ * Copyright (C) 2024 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/geom/CoordinateSequence.h>
+#include <geos/geom/Location.h>
+#include <geos/export.h>
+
+
+// Forward declarations
+namespace geos {
+namespace operation {
+namespace relateng {
+    class NodeSections;
+    class NodeSection;
+}
+}
+namespace geom {
+    class CoordinateXY;
+    class Geometry;
+    class LinearRing;
+    class Polygon;
+}
+}
+
+
+using geos::geom::CoordinateXY;
+using geos::geom::CoordinateSequence;
+using geos::geom::Geometry;
+using geos::geom::LinearRing;
+using geos::geom::Polygon;
+using geos::geom::Location;
+
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace relateng {  // geos.operation.relateng
+
+/**
+ * Determines the location for a point which is known to lie
+ * on at least one edge of a set of polygons.
+ * This provides the union-semantics for determining
+ * point location in a GeometryCollection, which may
+ * have polygons with adjacent edges which are effectively
+ * in the interior of the geometry.
+ * Note that it is also possible to have adjacent edges which
+ * lie on the boundary of the geometry
+ * (e.g. a polygon contained within another polygon with adjacent edges).
+ *
+ * @author mdavis
+ *
+ */
+class GEOS_DLL AdjacentEdgeLocator {
+
+public:
+
+    AdjacentEdgeLocator(const Geometry* geom)
+    {
+        init(geom);
+    }
+
+    Location locate(const CoordinateXY* p);
+
+    /**
+     * Disable copy construction and assignment. Apparently needed to make this
+     * class compile under MSVC. (See https://stackoverflow.com/q/29565299)
+     */
+    AdjacentEdgeLocator(const AdjacentEdgeLocator&) = delete;
+    AdjacentEdgeLocator& operator=(const AdjacentEdgeLocator&) = delete;
+
+
+private:
+
+    // Members
+
+    std::vector<const CoordinateSequence*> ringList;
+
+    /*
+     * When we have to reorient rings, we end up allocating new
+     * rings, since we cannot reorient the rings of the input
+     * geometry, so this is where we store those "local" rings.
+     */
+    std::vector<std::unique_ptr<CoordinateSequence>> localRingList;
+
+
+    // Methods
+
+    void addSections(
+        const CoordinateXY* p,
+        const CoordinateSequence* ring,
+        NodeSections& sections);
+
+    NodeSection* createSection(
+        const CoordinateXY* p,
+        const CoordinateXY* prev,
+        const CoordinateXY* next);
+
+    void init(const Geometry* geom);
+
+    void addRings(const Geometry* geom);
+
+    void addRing(const LinearRing* ring, bool requireCW);
+
+
+};
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+