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

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

@@ -20,10 +20,8 @@
 #pragma once
 
 #include <geos/geom/prep/PreparedGeometry.h> // for inheritance
-//#include <geos/algorithm/PointLocator.h>
-//#include <geos/geom/util/ComponentCoordinateExtracter.h>
 #include <geos/geom/Coordinate.h>
-//#include <geos/geom/Location.h>
+#include <geos/operation/relateng/RelateNG.h>
 
 #include <vector>
 #include <string>
@@ -40,6 +38,8 @@ namespace geos {
 namespace geom { // geos::geom
 namespace prep { // geos::geom::prep
 
+using geos::operation::relateng::RelateNG;
+
 // * \class BasicPreparedGeometry
 
 /**
@@ -59,6 +59,15 @@ class BasicPreparedGeometry: public PreparedGeometry {
 private:
     const geom::Geometry* baseGeom;
     std::vector<const CoordinateXY*> representativePts;
+    mutable std::unique_ptr<RelateNG> relate_ng;
+
+    RelateNG& getRelateNG() const
+    {
+        if (relate_ng == nullptr)
+            relate_ng = RelateNG::prepare(baseGeom);
+
+        return *relate_ng;
+    }
 
 protected:
     /**
@@ -119,6 +128,11 @@ public:
      */
     bool isAnyTargetComponentInTest(const geom::Geometry* testGeom) const;
 
+    /**
+     * Default implementation.
+     */
+    bool within(const geom::Geometry* g) const override;
+
     /**
      * Default implementation.
      */
@@ -168,7 +182,12 @@ public:
     /**
      * Default implementation.
      */
-    bool within(const geom::Geometry* g) const override;
+    std::unique_ptr<IntersectionMatrix> relate(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool relate(const geom::Geometry* g, const std::string& pat) const override;
 
     /**
      * Default implementation.

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

@@ -20,6 +20,7 @@
 
 #include <vector>
 #include <memory>
+#include <string>
 #include <geos/export.h>
 
 // Forward declarations
@@ -28,6 +29,7 @@ namespace geos {
         class Geometry;
         class Coordinate;
         class CoordinateSequence;
+        class IntersectionMatrix;
     }
 }
 
@@ -227,6 +229,28 @@ public:
      *
      */
     virtual bool isWithinDistance(const geom::Geometry* geom, double dist) const = 0;
+
+    /** \brief
+     * Compares the prepared geometry to the given geometry
+     * and returns the DE9IM intersection matrix as a string.
+     *
+     * @param geom the Geometry to test the
+     * @return the DE9IM matrix
+     */
+    virtual std::unique_ptr<IntersectionMatrix> relate(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Compares the prepared geometry to the given geometry
+     * and the provided DE9IM pattern, and returns true if the
+     * pattern is consistent with the relationship between the
+     * prepared and provided geometries.
+     *
+     * @param geom the Geometry to test the distance to
+     * @param pat the DE9IM pattern
+     * @return true if the patterns are consistent
+     */
+    virtual bool relate(const geom::Geometry* geom, const std::string& pat) const = 0;
+
 };
 
 

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

@@ -55,7 +55,7 @@ namespace util { // geos.geom.util
  *   this is not checked by the GeometryEditor
  * - the coordinate lists may be changed
  *   (e.g. by adding or deleting coordinates).
- *   The modifed coordinate lists must be consistent with their original
+ *   The modified coordinate lists must be consistent with their original
  *   parent component
  *   (e.g. a LinearRing must always have at least 4 coordinates, and the
  *   first and last coordinate must be equal)

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

@@ -0,0 +1,92 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ * 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: geom/util/GeometryExtracter.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/GeometryFilter.h>
+#include <geos/geom/GeometryCollection.h>
+#include <vector>
+
+namespace geos {
+namespace geom { // geos.geom
+namespace util { // geos.geom.util
+
+/**
+ * Extracts all the components of a collection, or just echoes back a
+ * pointers to singletons.
+ */
+class GEOS_DLL GeometryLister {
+
+public:
+
+    /**
+     * Extracts the components from a {@link Geometry}
+     * and adds them to the provided container.
+     *
+     * Useful for iterating over components of a collection.
+     *
+     * @param geom the geometry from which to extract
+     * @param lst the list to add the extracted elements to
+     */
+    static void
+    list(const Geometry* geom, std::vector<const Geometry*>& lst)
+    {
+        if(geom->isCollection()) {
+            GeometryLister::Lister lister(lst);
+            geom->apply_ro(&lister);
+        }
+        else {
+            lst.push_back(geom);
+        }
+    }
+
+private:
+
+    struct Lister : public GeometryFilter {
+
+        /**
+         * Constructs a filter with a list in which to store the elements found.
+         *
+         * @param comps the container to extract into (will push_back to it)
+         */
+        Lister(std::vector<const Geometry*>& p_geoms) : geoms(p_geoms) {}
+
+        std::vector<const Geometry*>& geoms;
+
+        void
+        filter_ro(const Geometry* geom) override
+        {
+            if(!geom->isCollection()) {
+                geoms.push_back(geom);
+            }
+        }
+
+        // // Declare type as noncopyable
+        // Lister(const Lister& other);
+        // Lister& operator=(const Lister& rhs);
+    };
+};
+
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+

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

@@ -148,7 +148,7 @@ private:
     bool pruneEmptyGeometry;
 
     /**
-     * `true` if a homogenous collection result
+     * `true` if a homogeneous collection result
      * from a {@link GeometryCollection} should still
      * be a general GeometryCollection
      */

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

@@ -0,0 +1,54 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Geometry.h>
+#include <vector>
+
+namespace geos {
+namespace geom { // geos.geom
+namespace util { // geos.geom.util
+
+/**
+ * \brief Extracts the polygonal (Polygon and MultiPolygon) elements from a Geometry.
+ */
+class GEOS_DLL PolygonalExtracter {
+
+public:
+
+    /**
+     * Pushes the polygonal (Polygon and MultiPolygon) elements from a geometry into
+     * the provided vector.
+     * 
+     * @param geom the geometry to extract from
+     * @param polys the vector to add the polygonal elements to
+     */
+    static void getPolygonals(const Geometry& geom, std::vector<const Geometry*>& polys);
+
+private:
+
+    static void getPolygonals(const Geometry* geom, std::vector<const Geometry*>& polys);
+
+    // Declare type as noncopyable
+    PolygonalExtracter(const PolygonalExtracter& other) = delete;
+    PolygonalExtracter& operator=(const PolygonalExtracter& rhs) = delete;
+};
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+

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

@@ -39,7 +39,7 @@ namespace geos {
 namespace geomgraph { // geos.geomgraph
 
 /// A directed EdgeEnd
-class GEOS_DLL DirectedEdge: public EdgeEnd {
+class GEOS_DLL DirectedEdge final: public EdgeEnd {
 
 public:
 
@@ -159,7 +159,7 @@ public:
     };
 
     /** \brief
-     * Tells wheter this edge is a Line
+     * Tells whether this edge is a Line
      *
      * This edge is a line edge if
      * - at least one of the labels is a line label
@@ -169,7 +169,7 @@ public:
     bool isLineEdge();
 
     /** \brief
-     * Tells wheter this edge is an Area
+     * Tells whether this edge is an Area
      *
      * This is an interior Area edge if
      * - its label is an Area label for both Geometries

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

@@ -21,6 +21,7 @@
 
 #pragma once
 
+#include <memory>
 #include <geos/export.h>
 #include <set>
 #include <string>
@@ -81,7 +82,7 @@ public:
     /** \brief
      * Compute the labelling for all dirEdges in this star, as well as the overall labelling
      */
-    void computeLabelling(std::vector<GeometryGraph*>* geom) override; // throw(TopologyException *);
+    void computeLabelling(const std::vector<std::unique_ptr<GeometryGraph>>&geom) override; // throw(TopologyException *);
 
     /** \brief
      * For each dirEdge in the star, merge the label from the sym dirEdge into the label
@@ -116,7 +117,7 @@ public:
     void linkAllDirectedEdges();
 
     /** \brief
-     * Traverse the star of edges, maintaing the current location in the result
+     * Traverse the star of edges, maintaining the current location in the result
      * area at this node (if any).
      *
      * If any L edges are found in the interior of the result, mark them as covered.

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

@@ -60,7 +60,7 @@ namespace geos {
 namespace geomgraph { // geos.geomgraph
 
 /** The edge component of a geometry graph */
-class GEOS_DLL Edge: public GraphComponent {
+class GEOS_DLL Edge final: public GraphComponent {
     using GraphComponent::updateIM;
 
 private:
@@ -102,27 +102,27 @@ public:
 
     ~Edge() override;
 
-    virtual size_t
+    size_t
     getNumPoints() const
     {
         return pts->getSize();
     }
 
-    virtual const geom::CoordinateSequence*
+    const geom::CoordinateSequence*
     getCoordinates() const
     {
         testInvariant();
         return pts.get();
     }
 
-    virtual const geom::Coordinate&
+    const geom::Coordinate&
     getCoordinate(std::size_t i) const
     {
         testInvariant();
         return pts->getAt(i);
     }
 
-    virtual const geom::Coordinate&
+    const geom::Coordinate&
     getCoordinate() const
     {
         testInvariant();
@@ -130,8 +130,8 @@ public:
     }
 
 
-    virtual Depth&
-    getDepth()
+    const Depth&
+    getDepth() const
     {
         testInvariant();
         return depth;
@@ -142,41 +142,48 @@ public:
      *
      * @return the change in depth as the edge is crossed from R to L
      */
-    virtual int
+    int
     getDepthDelta() const
     {
         testInvariant();
         return depthDelta;
     }
 
-    virtual void
+    void
     setDepthDelta(int newDepthDelta)
     {
         depthDelta = newDepthDelta;
         testInvariant();
     }
 
-    virtual size_t
+    size_t
     getMaximumSegmentIndex() const
     {
         testInvariant();
         return getNumPoints() - 1;
     }
 
-    virtual EdgeIntersectionList&
+    EdgeIntersectionList&
     getEdgeIntersectionList()
     {
         testInvariant();
         return eiList;
     }
 
+    const EdgeIntersectionList&
+    getEdgeIntersectionList() const
+    {
+        testInvariant();
+        return eiList;
+    }
+
     /// \brief
     /// Return this Edge's index::MonotoneChainEdge,
     /// ownership is retained by this object.
     ///
-    virtual index::MonotoneChainEdge* getMonotoneChainEdge();
+    index::MonotoneChainEdge* getMonotoneChainEdge();
 
-    virtual bool
+    bool
     isClosed() const
     {
         testInvariant();
@@ -187,11 +194,11 @@ public:
      * An Edge is collapsed if it is an Area edge and it consists of
      * two segments which are equal and opposite (eg a zero-width V).
      */
-    virtual bool isCollapsed() const;
+     bool isCollapsed() const;
 
-    virtual Edge* getCollapsedEdge();
+    Edge* getCollapsedEdge();
 
-    virtual void
+    void
     setIsolated(bool newIsIsolated)
     {
         isIsolatedVar = newIsIsolated;
@@ -209,7 +216,7 @@ public:
      * Adds EdgeIntersections for one or both
      * intersections found for a segment of an edge to the edge intersection list.
      */
-    virtual void addIntersections(algorithm::LineIntersector* li, std::size_t segmentIndex,
+    void addIntersections(algorithm::LineIntersector* li, std::size_t segmentIndex,
                                   std::size_t geomIndex);
 
     /// Add an EdgeIntersection for intersection intIndex.
@@ -217,7 +224,7 @@ public:
     /// An intersection that falls exactly on a vertex of the edge is normalized
     /// to use the higher of the two possible segmentIndexes
     ///
-    virtual void addIntersection(algorithm::LineIntersector* li, std::size_t segmentIndex,
+    void addIntersection(algorithm::LineIntersector* li, std::size_t segmentIndex,
                                  std::size_t geomIndex, std::size_t intIndex);
 
     /// Update the IM with the contribution for this component.
@@ -233,11 +240,11 @@ public:
     }
 
     /// return true if the coordinate sequences of the Edges are identical
-    virtual bool isPointwiseEqual(const Edge* e) const;
+    bool isPointwiseEqual(const Edge* e) const;
 
-    virtual std::string print() const;
+    std::string print() const;
 
-    virtual std::string printReverse() const;
+    std::string printReverse() const;
 
     /**
      * equals is defined to be:
@@ -246,16 +253,16 @@ public:
      * <b>iff</b>
      * the coordinates of e1 are the same or the reverse of the coordinates in e2
      */
-    virtual bool equals(const Edge& e) const;
+    bool equals(const Edge& e) const;
 
-    virtual bool
+    bool
     equals(const Edge* e) const
     {
         assert(e);
         return equals(*e);
     }
 
-    virtual const geom::Envelope* getEnvelope();
+    const geom::Envelope* getEnvelope();
 };
 
 

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

@@ -51,7 +51,7 @@ namespace geomgraph { // geos.geomgraph
  * "a has a greater angle with the x-axis than b".
  * This ordering is used to sort EdgeEnds around a node.
  */
-class GEOS_DLL EdgeEnd {
+class GEOS_DLL EdgeEnd /* non-final */ {
 
 public:
 
@@ -101,7 +101,7 @@ public:
         return label;
     }
 
-    virtual geom::Coordinate& getCoordinate() {
+    geom::Coordinate& getCoordinate() {
         return p0;
     }
 
@@ -111,19 +111,19 @@ public:
         return p0;
     }
 
-    virtual geom::Coordinate& getDirectedCoordinate();
+    geom::Coordinate& getDirectedCoordinate();
 
-    virtual int getQuadrant();
+    int getQuadrant();
 
-    virtual double getDx();
+    double getDx();
 
-    virtual double getDy();
+    double getDy();
 
-    virtual void setNode(Node* newNode);
+    void setNode(Node* newNode);
 
-    virtual Node* getNode();
+    Node* getNode();
 
-    virtual int compareTo(const EdgeEnd* e) const;
+    int compareTo(const EdgeEnd* e) const;
 
     /**
      * Implements the total order relation:
@@ -141,7 +141,7 @@ public:
      *   computeOrientation function can be used to decide
      *   the relative orientation of the vectors.
      */
-    virtual int compareDirection(const EdgeEnd* e) const;
+    int compareDirection(const EdgeEnd* e) const;
 
     virtual void computeLabel(const algorithm::BoundaryNodeRule& bnr);
 
@@ -155,7 +155,7 @@ protected:
 
     EdgeEnd(Edge* newEdge);
 
-    virtual void init(const geom::Coordinate& newP0,
+    void init(const geom::Coordinate& newP0,
                       const geom::Coordinate& newP1);
 
 private:

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

@@ -27,6 +27,7 @@
 #include <geos/geom/Coordinate.h>  // for p0,p1
 
 #include <array>
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
@@ -59,7 +60,7 @@ namespace geomgraph { // geos.geomgraph
  *
  * @version 1.4
  */
-class GEOS_DLL EdgeEndStar {
+class GEOS_DLL EdgeEndStar /* non-final */ {
 public:
 
     typedef std::set<EdgeEnd*, EdgeEndLT> container;
@@ -85,46 +86,46 @@ public:
      * a Coordinate owned by the specific EdgeEnd happening
      * to be the first in the star (ordered CCW)
      */
-    virtual geom::Coordinate& getCoordinate();
+    geom::Coordinate& getCoordinate();
 
     const geom::Coordinate& getCoordinate() const;
 
-    virtual std::size_t getDegree();
+    std::size_t getDegree();
 
-    virtual iterator begin();
+    iterator begin();
 
-    virtual iterator end();
+    iterator end();
 
-    virtual reverse_iterator rbegin();
+    reverse_iterator rbegin();
 
-    virtual reverse_iterator rend();
+    reverse_iterator rend();
 
-    virtual const_iterator
+    const_iterator
     begin() const
     {
         return edgeMap.begin();
     }
 
-    virtual const_iterator
+    const_iterator
     end() const
     {
         return edgeMap.end();
     }
 
-    virtual container& getEdges();
+    container& getEdges();
 
-    virtual EdgeEnd* getNextCW(EdgeEnd* ee);
+    EdgeEnd* getNextCW(EdgeEnd* ee);
 
-    virtual void computeLabelling(std::vector<GeometryGraph*>* geomGraph);
+    virtual void computeLabelling(const std::vector<std::unique_ptr<GeometryGraph>>&geomGraph);
     // throw(TopologyException *);
 
-    virtual bool isAreaLabelsConsistent(const GeometryGraph& geomGraph);
+    bool isAreaLabelsConsistent(const GeometryGraph& geomGraph);
 
-    virtual void propagateSideLabels(uint32_t geomIndex);
+    void propagateSideLabels(uint32_t geomIndex);
     // throw(TopologyException *);
 
     //virtual int findIndex(EdgeEnd *eSearch);
-    virtual iterator find(EdgeEnd* eSearch);
+    iterator find(EdgeEnd* eSearch);
 
     virtual std::string print() const;
 
@@ -139,7 +140,7 @@ protected:
     /** \brief
      * Insert an EdgeEnd into the map.
      */
-    virtual void
+    void
     insertEdgeEnd(EdgeEnd* e)
     {
         edgeMap.insert(e);
@@ -147,9 +148,9 @@ protected:
 
 private:
 
-    virtual geom::Location getLocation(uint32_t geomIndex,
-                                       const geom::Coordinate& p,
-                                       std::vector<GeometryGraph*>* geom);
+    geom::Location getLocation(uint32_t geomIndex,
+                                       const geom::Coordinate&p,
+                                       const std::vector<std::unique_ptr<GeometryGraph>>&geom);
 
     /** \brief
      * The location of the point for this star in
@@ -157,9 +158,9 @@ private:
      */
     std::array<geom::Location, 2> ptInAreaLocation;
 
-    virtual void computeEdgeEndLabels(const algorithm::BoundaryNodeRule&);
+    void computeEdgeEndLabels(const algorithm::BoundaryNodeRule&);
 
-    virtual bool checkAreaLabelsConsistent(uint32_t geomIndex);
+    bool checkAreaLabelsConsistent(uint32_t geomIndex);
 
 };
 

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

@@ -39,7 +39,7 @@ namespace geomgraph { // geos.geomgraph
  * The intersection point must be precise.
  *
  */
-class GEOS_DLL EdgeIntersection {
+class GEOS_DLL EdgeIntersection final {
 public:
 
     // the point of intersection

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

@@ -54,7 +54,7 @@ namespace geomgraph { // geos.geomgraph
  * Implements splitting an edge with intersections
  * into multiple resultant edges.
  */
-class GEOS_DLL EdgeIntersectionList {
+class GEOS_DLL EdgeIntersectionList final {
 public:
     // Instead of storing edge intersections in a set, as JTS does, we store them
     // in a vector and then sort the vector if needed before iterating among the