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

package/dist/prebuilt/Android-x86_64/include/geos/operation/cluster/GeometryFlattener.h

@@ -0,0 +1,46 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2022 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/Geometry.h>
+#include <geos/geom/GeometryFactory.h>
+#include <geos/geom/GeometryCollection.h>
+
+namespace geos  {
+namespace operation {
+namespace cluster {
+
+
+class GEOS_DLL GeometryFlattener {
+public:
+    /** Flatten a geometry such that it contains no nested components (e.g., MultiPolygons within
+     *  GeometryCollections, etc.). The flattened geometry will use the most narrow representation
+     *  possible (Polygon preferred to MultiPolygon, MultiPolygon preferred to GeometryCollection.)
+     *
+     * @brief flatten
+     * @param g a geometry to be flattened; consumed by the function
+     * @return a geometry with no nested components
+     */
+    static std::unique_ptr<geom::Geometry> flatten(std::unique_ptr<geom::Geometry>&& g);
+
+private:
+    static void flatten(std::unique_ptr<geom::Geometry>&& g, std::vector<std::unique_ptr<geom::Geometry>>& components);
+};
+
+
+}
+}
+}

package/dist/prebuilt/Android-x86_64/include/geos/operation/cluster/GeometryIntersectsClusterFinder.h

@@ -0,0 +1,53 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020-2021 Daniel Baston
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#ifndef GEOS_OPERATION_CLUSTER_GEOMETRYINTERSECTSCLUSTERFINDER
+#define GEOS_OPERATION_CLUSTER_GEOMETRYINTERSECTSCLUSTERFINDER
+
+#include <geos/operation/cluster/AbstractClusterFinder.h>
+#include <geos/geom/Geometry.h>
+#include <geos/geom/prep/PreparedGeometry.h>
+#include <geos/geom/prep/PreparedGeometryFactory.h>
+
+namespace geos {
+namespace operation {
+namespace cluster {
+
+/** GeometryIntersectsClusterFinder clusters geometries by intersection.
+ * Any two geometries that intersect will be included in the same cluster.
+ */
+class GEOS_DLL GeometryIntersectsClusterFinder : public AbstractClusterFinder {
+protected:
+    const geom::Envelope& queryEnvelope(const geom::Geometry* a) override {
+        return *(a->getEnvelopeInternal());
+    }
+
+    bool shouldJoin(const geom::Geometry* a, const geom::Geometry *b) override {
+        if (m_prep == nullptr || &(m_prep->getGeometry()) != a) {
+            m_prep = geom::prep::PreparedGeometryFactory::prepare(a);
+        }
+
+        return m_prep->intersects(b);
+    }
+
+private:
+    std::unique_ptr<geom::prep::PreparedGeometry> m_prep;
+};
+
+
+}
+}
+}
+
+#endif

package/dist/prebuilt/Android-x86_64/include/geos/operation/cluster/UnionFind.h

@@ -0,0 +1,137 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020-2021 Daniel Baston
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#ifndef GEOS_OPERATION_CLUSTER_UNIONFIND
+#define GEOS_OPERATION_CLUSTER_UNIONFIND
+
+#include <algorithm>
+#include <numeric>
+#include <vector>
+
+#include <geos/export.h>
+#include <geos/operation/cluster/Clusters.h>
+
+namespace geos {
+namespace operation {
+namespace cluster {
+
+/** UnionFind provides an implementation of a disjoint set data structure that
+ * is useful in clustering. Elements to be clustered are referred to according
+ * to a numeric index.
+ */
+class GEOS_DLL UnionFind {
+
+public:
+    /** Create a UnionFind object
+     *
+     * @param n the number of elements to be clustered (fixed size)
+     */
+    explicit UnionFind(size_t n) :
+            clusters(n),
+            sizes(n),
+            num_clusters(n) {
+        std::iota(clusters.begin(), clusters.end(), 0);
+        std::fill(sizes.begin(), sizes.end(), 1);
+    }
+
+    // Are two elements in the same cluster?
+    bool same(size_t i, size_t j) {
+        return i == j || (find(i) == find(j));
+    }
+
+    // Are two elements in a different cluster?
+    bool different(size_t i, size_t j) {
+        return !same(i, j);
+    }
+
+    /**
+     * Return the ID of the cluster associated with an item
+     * @param i index of the item to lookup
+     * @return a numeric cluster ID
+     */
+    size_t find(size_t i) {
+        size_t root = i;
+
+        while(clusters[root] != root) {
+            root = clusters[root];
+        }
+
+        while (i != root) {
+            size_t next = clusters[i];
+            clusters[i] = root;
+            i = next;
+        }
+
+        return i;
+    }
+
+    /**
+     * Merge the clusters associated with two items
+     * @param i ID of an item associated with the first cluster
+     * @param j ID of an item associated with the second cluster
+     */
+    void join(size_t i, size_t j) {
+        auto a = find(i);
+        auto b = find(j);
+
+        if (a == b) {
+            return;
+        }
+
+        if ((sizes[b] > sizes[a]) || (sizes[a] == sizes[b] && b <= a)) {
+            std::swap(a, b);
+        }
+
+        clusters[a] = clusters[b];
+        sizes[b] += sizes[a];
+        sizes[a] = 0;
+
+        num_clusters--;
+    }
+
+    size_t getNumClusters() const {
+        return num_clusters;
+    }
+
+    template<typename T>
+    void sortByCluster(T begin, T end) {
+        std::sort(begin, end, [this](size_t a, size_t b) {
+            return find(a) < find(b);
+        });
+    }
+
+    /**
+     * Return the clusters associated with all elements
+     * @return an object that allows iteration over the elements of each cluster
+     */
+    Clusters getClusters();
+
+    /**
+     * Return the clusters associated with the given elements
+     * @param elems a vector of element ids
+     * @return an object that allows iteration over the elements of each cluster
+     */
+    Clusters getClusters(std::vector<size_t> elems);
+
+private:
+    std::vector<size_t> clusters;
+    std::vector<size_t> sizes;
+    size_t num_clusters;
+};
+
+}
+}
+}
+
+#endif

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

@@ -0,0 +1,76 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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: operation/distance/ConnectedElementLocationFilter.java b98e8234
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geom/GeometryFilter.h> // for inheritance
+#include <geos/operation/distance/GeometryLocation.h>
+
+#include <memory>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace distance { // geos::operation::distance
+
+/** \brief
+ * A ConnectedElementPointFilter extracts a single point from each connected
+ * element in a Geometry (e.g. a polygon, linestring or point) and returns
+ * them in a list. Empty geometries do not provide a location item.
+ *
+ * The elements of the list are GeometryLocation.
+ *
+ * Empty geometries do not provide a location item.
+ */
+class GEOS_DLL ConnectedElementLocationFilter: public geom::GeometryFilter {
+private:
+
+    std::vector<GeometryLocation> locations;
+    ConnectedElementLocationFilter() = default;
+    ConnectedElementLocationFilter(const ConnectedElementLocationFilter&) = delete;
+    ConnectedElementLocationFilter& operator=(const ConnectedElementLocationFilter&) = delete;
+public:
+    /** \brief
+     * Returns a list containing a point from each Polygon, LineString, and
+     * Point found inside the specified geometry.
+     *
+     * Thus, if the specified geometry is not a GeometryCollection,
+     * an empty list will be returned. The elements of the list
+     * are [GeometryLocations](@ref operation::distance::GeometryLocation).
+     */
+    static std::vector<GeometryLocation> getLocations(const geom::Geometry* geom);
+
+    void filter_ro(const geom::Geometry* geom) override;
+    void filter_rw(geom::Geometry* geom) override;
+};
+
+
+} // namespace geos::operation::distance
+} // namespace geos::operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/distance/ConnectedElementPointFilter.h

@@ -0,0 +1,73 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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: operation/distance/ConnectedElementPointFilter.java rev. 1.7 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geom/GeometryFilter.h> // for inheritance
+
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class CoordinateXY;
+class Geometry;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace distance { // geos::operation::distance
+
+/** \brief
+ * Extracts a single point
+ * from each connected element in a Geometry
+ * (e.g. a polygon, linestring or point)
+ * and returns them in a list
+ */
+class GEOS_DLL ConnectedElementPointFilter: public geom::GeometryFilter {
+
+private:
+    std::vector<const geom::CoordinateXY*>* pts;
+
+public:
+    /**
+     * Returns a list containing a Coordinate from each Polygon, LineString, and Point
+     * found inside the specified geometry. Thus, if the specified geometry is
+     * not a GeometryCollection, an empty list will be returned.
+     */
+    static std::vector<const geom::CoordinateXY*>* getCoordinates(const geom::Geometry* geom);
+
+    ConnectedElementPointFilter(std::vector<const geom::CoordinateXY*>* newPts)
+        :
+        pts(newPts)
+    {}
+
+    void filter_ro(const geom::Geometry* geom) override;
+
+    //void filter_rw(geom::Geometry * /*geom*/) {};
+};
+
+
+} // namespace geos::operation::distance
+} // namespace geos::operation
+} // namespace geos
+

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

@@ -0,0 +1,228 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * 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: operation/distance/DistanceOp.java r335 (JTS-1.12-)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/algorithm/PointLocator.h> // for composition
+#include <geos/operation/distance/GeometryLocation.h>
+#include <geos/geom/CoordinateSequence.h>
+
+#include <array>
+#include <vector>
+#include <memory>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
+#endif
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class Polygon;
+class LineString;
+class Point;
+class Geometry;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace distance { // geos::operation::distance
+
+/**
+ * \brief
+ * Find two points on two {@link geom::Geometry}s which lie
+ * within a given distance, or else are the nearest points
+ * on the geometries (in which case this also
+ * provides the distance between the geometries).
+ *
+ * The distance computation also finds a pair of points in the
+ * input geometries which have the minimum distance between them.
+ * If a point lies in the interior of a line segment,
+ * the coordinate computed is a close
+ * approximation to the exact point.
+ *
+ * Empty geometry collection components are ignored.
+ *
+ * The algorithms used are straightforward O(n^2)
+ * comparisons.  This worst-case performance could be improved on
+ * by using Voronoi techniques or spatial indexes.
+ *
+ */
+class GEOS_DLL DistanceOp {
+public:
+    /**
+     * \brief
+     * Compute the distance between the nearest points of two geometries.
+     *
+     * @param g0 a {@link geom::Geometry}
+     * @param g1 another {@link geom::Geometry}
+     * @return the distance between the geometries
+     * @return 0 if either input geometry is empty
+     * @throws IllegalArgumentException if either input geometry is null
+     */
+    static double distance(const geom::Geometry& g0,
+                           const geom::Geometry& g1);
+
+    /// @deprecated, use the version taking references
+    static double distance(const geom::Geometry* g0,
+                           const geom::Geometry* g1);
+
+    /**
+     * \brief
+     * Test whether two geometries lie within a given distance of
+     * each other.
+     *
+     * @param g0 a {@link geom::Geometry}
+     * @param g1 another {@link geom::Geometry}
+     * @param distance the distance to test
+     * @return true if g0.distance(g1) <= distance
+     */
+    static bool isWithinDistance(const geom::Geometry& g0,
+                                 const geom::Geometry& g1,
+                                 double distance);
+
+    /**
+     * Compute the the nearest points of two geometries.
+     *
+     * The points are presented in the same order as the input Geometries.
+     *
+     * @param g0 a {@link geom::Geometry}
+     * @param g1 another {@link geom::Geometry}
+     *
+     * @return the nearest points in the geometries, ownership to caller.
+     *         A NULL return means one of the geometries is empty.
+     *
+     */
+    static std::unique_ptr<geom::CoordinateSequence> nearestPoints(
+        const geom::Geometry* g0,
+        const geom::Geometry* g1);
+
+    /// @deprecated use the one taking references
+    DistanceOp(const geom::Geometry* g0, const geom::Geometry* g1);
+
+    /**
+     * \brief
+     * Constructs a DistanceOp that computes the distance and
+     * nearest points between the two specified geometries.
+     *
+     * @param g0 a Geometry
+     * @param g1 a Geometry
+     */
+    DistanceOp(const geom::Geometry& g0, const geom::Geometry& g1);
+
+    /**
+     * \brief
+     * Constructs a DistanceOp that computes the distance and nearest
+     * points between the two specified geometries.
+     *
+     * @param g0 a Geometry
+     * @param g1 a Geometry
+     * @param terminateDistance the distance on which to terminate
+     *                          the search
+     */
+    DistanceOp(const geom::Geometry& g0, const geom::Geometry& g1,
+               double terminateDistance);
+
+    ~DistanceOp() = default;
+
+    /**
+     * Report the distance between the closest points on the input geometries.
+     *
+     * @return the distance between the geometries
+     */
+    double distance();
+
+    /**
+     * Report the coordinates of the nearest points in the input geometries.
+     * The points are presented in the same order as the input Geometries.
+     *
+     * @return a pair of {@link geom::Coordinate}s of the nearest points
+     *         as a newly allocated object (ownership to caller)
+     *
+     */
+    std::unique_ptr<geom::CoordinateSequence> nearestPoints();
+
+private:
+
+    // input
+    std::array<geom::Geometry const*, 2> geom;
+    double terminateDistance;
+
+    // working
+    algorithm::PointLocator ptLocator;
+    std::array<GeometryLocation, 2> minDistanceLocation;
+    double minDistance;
+    bool computed = false;
+
+    void updateMinDistance(std::array<GeometryLocation, 2> & locGeom, bool flip);
+
+    void computeMinDistance();
+
+    void computeContainmentDistance();
+
+    void computeInside(std::vector<GeometryLocation> & locs,
+                       const std::vector<const geom::Polygon*>& polys,
+                       std::array<GeometryLocation, 2> & locPtPoly);
+
+
+    /**
+     * Computes distance between facets (lines and points)
+     * of input geometries.
+     */
+    void computeFacetDistance();
+
+    void computeMinDistanceLines(
+        const std::vector<const geom::LineString*>& lines0,
+        const std::vector<const geom::LineString*>& lines1,
+        std::array<GeometryLocation, 2> & locGeom);
+
+    void computeMinDistancePoints(
+        const std::vector<const geom::Point*>& points0,
+        const std::vector<const geom::Point*>& points1,
+        std::array<GeometryLocation, 2> & locGeom);
+
+    void computeMinDistanceLinesPoints(
+        const std::vector<const geom::LineString*>& lines0,
+        const std::vector<const geom::Point*>& points1,
+        std::array<GeometryLocation, 2> & locGeom);
+
+    void computeMinDistance(const geom::LineString* line0,
+                            const geom::LineString* line1,
+                            std::array<GeometryLocation, 2> & locGeom);
+
+    void computeMinDistance(const geom::LineString* line,
+                            const geom::Point* pt,
+                            std::array<GeometryLocation, 2> & locGeom);
+};
+
+
+} // namespace geos::operation::distance
+} // namespace geos::operation
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/distance/FacetSequence.h

@@ -0,0 +1,84 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2016 Daniel Baston
+ *
+ * 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: operation/distance/FacetSequence.java (f6187ee2 JTS-1.14)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/Envelope.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/LineSegment.h>
+#include <geos/operation/distance/GeometryLocation.h>
+
+namespace geos {
+namespace operation {
+namespace distance {
+class FacetSequence {
+private:
+    const geom::CoordinateSequence* pts;
+    const std::size_t start;
+    const std::size_t end;
+    const geom::Geometry* geom;
+    /*
+    * Unlike JTS, we store the envelope in the FacetSequence so
+    * that it has a clear owner.  This is helpful when making a
+    * tree of FacetSequence objects (FacetSequenceTreeBuilder)
+    */
+    geom::Envelope env;
+
+    double computeDistanceLineLine(const FacetSequence& facetSeq,
+                                   std::vector<GeometryLocation> *locs) const;
+
+    double computeDistancePointLine(const geom::Coordinate& pt,
+                                    const FacetSequence& facetSeq,
+                                    std::vector<GeometryLocation> *locs) const;
+
+    void updateNearestLocationsPointLine(const geom::Coordinate& pt,
+                                         const FacetSequence& facetSeq, std::size_t i,
+                                         const geom::Coordinate& q0, const geom::Coordinate &q1,
+                                         std::vector<GeometryLocation> *locs) const;
+
+    void updateNearestLocationsLineLine(std::size_t i, const geom::Coordinate& p0, const geom::Coordinate& p1,
+                                        const FacetSequence& facetSeq,
+                                        std::size_t j, const geom::Coordinate& q0, const geom::Coordinate &q1,
+                                        std::vector<GeometryLocation> *locs) const;
+
+    void computeEnvelope();
+
+public:
+    const geom::Envelope* getEnvelope() const;
+
+    const geom::Coordinate* getCoordinate(std::size_t index) const;
+
+    std::size_t size() const;
+
+    bool isPoint() const;
+
+    double distance(const FacetSequence& facetSeq) const;
+
+    FacetSequence(const geom::CoordinateSequence* pts, std::size_t start, std::size_t end);
+
+    FacetSequence(const geom::Geometry* geom, const geom::CoordinateSequence* pts, std::size_t start, std::size_t end);
+
+    std::vector<GeometryLocation> nearestLocations(const FacetSequence& facetSeq) const;
+
+};
+
+}
+}
+}
+