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

package/dist/prebuilt/Android-x86_64/include/geos/operation/buffer/SegmentMCIndex.h

@@ -0,0 +1,56 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021 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/index/chain/MonotoneChain.h>
+#include <geos/index/strtree/TemplateSTRtree.h>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+class Envelope;
+}
+}
+
+using geos::geom::CoordinateSequence;
+using geos::geom::Envelope;
+using namespace geos::index;
+
+namespace geos {
+namespace operation {
+namespace buffer {
+
+class GEOS_DLL SegmentMCIndex {
+
+private:
+
+    strtree::TemplateSTRtree<const index::chain::MonotoneChain*> index;
+    std::vector<chain::MonotoneChain> segChains;
+
+    void buildIndex(const CoordinateSequence* segs);
+
+public:
+
+    SegmentMCIndex(const CoordinateSequence* segs);
+
+    void query(const Envelope* env, chain::MonotoneChainSelectAction& action);
+};
+
+
+} // geos.operation.buffer
+} // geos.operation
+} // geos

package/dist/prebuilt/Android-x86_64/include/geos/operation/buffer/SubgraphDepthLocater.h

@@ -0,0 +1,120 @@
+/**********************************************************************
+ *
+ * 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/buffer/SubgraphDepthLocater.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <vector>
+
+#include <geos/geom/LineSegment.h> // for composition
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+namespace geomgraph {
+class DirectedEdge;
+}
+namespace operation {
+namespace buffer {
+class BufferSubgraph;
+class DepthSegment;
+}
+}
+}
+
+namespace geos {
+namespace operation { // geos.operation
+namespace buffer { // geos.operation.buffer
+
+/**
+ * \class SubgraphDepthLocater
+ *
+ * \brief
+ * Locates a subgraph inside a set of subgraphs,
+ * in order to determine the outside depth of the subgraph.
+ *
+ * The input subgraphs are assumed to have had depths
+ * already calculated for their edges.
+ *
+ */
+class GEOS_DLL SubgraphDepthLocater {
+
+public:
+
+    SubgraphDepthLocater(std::vector<BufferSubgraph*>* newSubgraphs)
+        :
+        subgraphs(newSubgraphs)
+    {}
+
+    ~SubgraphDepthLocater() {}
+
+    int getDepth(const geom::Coordinate& p);
+
+private:
+
+    std::vector<BufferSubgraph*>* subgraphs;
+
+    geom::LineSegment seg;
+
+    /**
+     * Finds all non-horizontal segments intersecting the stabbing line.
+     * The stabbing line is the ray to the right of stabbingRayLeftPt.
+     *
+     * @param stabbingRayLeftPt the left-hand origin of the stabbing line
+     * @param stabbedSegments a vector to which DepthSegments intersecting
+     *        the stabbing line will be added.
+     */
+    void findStabbedSegments(const geom::Coordinate& stabbingRayLeftPt,
+                             std::vector<DepthSegment*>& stabbedSegments);
+
+    /**
+     * Finds all non-horizontal segments intersecting the stabbing line
+     * in the list of dirEdges.
+     * The stabbing line is the ray to the right of stabbingRayLeftPt.
+     *
+     * @param stabbingRayLeftPt the left-hand origin of the stabbing line
+     * @param stabbedSegments the current vector of DepthSegments
+     *        intersecting the stabbing line will be added.
+     */
+    void findStabbedSegments(const geom::Coordinate& stabbingRayLeftPt,
+                             std::vector<geomgraph::DirectedEdge*>* dirEdges,
+                             std::vector<DepthSegment*>& stabbedSegments);
+
+    /**
+     * Finds all non-horizontal segments intersecting the stabbing line
+     * in the input dirEdge.
+     * The stabbing line is the ray to the right of stabbingRayLeftPt.
+     *
+     * @param stabbingRayLeftPt the left-hand origin of the stabbing line
+     * @param stabbedSegments the current list of DepthSegments intersecting
+     *        the stabbing line
+     */
+    void findStabbedSegments(const geom::Coordinate& stabbingRayLeftPt,
+                             geomgraph::DirectedEdge* dirEdge,
+                             std::vector<DepthSegment*>& stabbedSegments);
+
+};
+
+
+} // namespace geos::operation::buffer
+} // namespace geos::operation
+} // namespace geos
+

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

@@ -0,0 +1,136 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020-2022 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_ABSTRACTCLUSTERFINDER
+#define GEOS_OPERATION_CLUSTER_ABSTRACTCLUSTERFINDER
+
+#include <functional>
+#include <memory>
+#include <vector>
+
+#include <geos/export.h>
+#include <geos/index/strtree/TemplateSTRtree.h>
+#include <geos/operation/cluster/Clusters.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+    class Envelope;
+    class Geometry;
+}
+namespace operation {
+namespace cluster {
+    class UnionFind;
+}
+}
+}
+
+namespace geos {
+namespace operation {
+namespace cluster {
+
+/** AbstractClusterFinder defines an interface for bottom-up clustering algorithms,
+ * where spatial index queries can be used to identify geometries that should be
+ * clustered together.
+ */
+class GEOS_DLL AbstractClusterFinder {
+
+public:
+    /**
+     * Cluster the provided geometries, returning an object that provides access
+     * to the components of each cluster.
+     *
+     * @param g A vector of geometries to cluster
+     */
+    Clusters cluster(const std::vector<const geom::Geometry*>& g);
+
+    /**
+     * Cluster the components of the provided geometry, returning a vector of clusters.
+     * This function will take ownership of the provided geometry. Any components that
+     * are included in a cluster will be returned. Components that are not included in
+     * any cluster will be destroyed.
+     *
+     * @param g A geometry whose components should be clustered.
+     * @return a Geometry vector, with each entry representing a single cluster.
+     */
+    std::vector<std::unique_ptr<geom::Geometry>> clusterToVector(std::unique_ptr<geom::Geometry> && g);
+
+    /**
+     * Cluster the components of the provided geometry, returning a vector of clusters.
+     * The input geometry will not be modified.
+     *
+     * @param g A geometry whose components should be clustered.
+     * @return a Geometry vector, with each entry representing a single cluster.
+     */
+    std::vector<std::unique_ptr<geom::Geometry>> clusterToVector(const geom::Geometry& g);
+
+    /**
+     * Cluster the components of the provided geometry, returning a GeometryCollection.
+     * This function will take ownership of the provided geometry. Any components that
+     * are included in a cluster will be returned. Components that are not included in
+     * any cluster will be destroyed.
+     *
+     * @param g A geometry whose components should be clustered.
+     * @return a GeometryCollection, with each sub-geometry representing a single cluster.
+     */
+    std::unique_ptr<geom::Geometry> clusterToCollection(std::unique_ptr<geom::Geometry> && g);
+
+    /**
+     * Cluster the components of the provided geometry, returning a GeometryCollection.
+     * The input geometry will not be modified.
+     *
+     * @param g A geometry whose components should be clustered.
+     * @return a GeometryCollection, with each sub-geometry representing a single cluster.
+     */
+    std::unique_ptr<geom::Geometry> clusterToCollection(const geom::Geometry & g);
+
+protected:
+    /**
+     * Determine whether two geometries should be considered in the same cluster.
+     * @param a Geometry
+     * @param b Geometry
+     * @return `true` if the clusters associated with `a` and `b` should be merged.
+     */
+    virtual bool shouldJoin(const geom::Geometry* a, const geom::Geometry* b) = 0;
+
+    /**
+     * Provide an query Envelope that can be used to find all geometries possibly
+     * in the same cluster as the input.
+     * @param a Geometry
+     * @return an Envelope suitable for querying
+     */
+    virtual const geom::Envelope& queryEnvelope(const geom::Geometry* a) = 0;
+
+    /**
+     * Given a vector and index of components,
+     * @param components a vector of Geometry components
+     * @param index a spatial index storing pointers to those components
+     * @param uf a UnionFind
+     * @return a vector of with the indices of all components that should be included in a cluster
+     */
+    virtual Clusters process(const std::vector<const geom::Geometry*> & components,
+                 index::strtree::TemplateSTRtree<std::size_t> & index,
+                 UnionFind & uf);
+
+private:
+    static std::vector<std::unique_ptr<geom::Geometry>> getComponents(std::unique_ptr<geom::Geometry>&& g);
+};
+
+
+
+}
+}
+}
+
+#endif

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

@@ -0,0 +1,72 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021-2022 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_CLUSTERS
+#define GEOS_OPERATION_CLUSTER_CLUSTERS
+
+#include <geos/export.h>
+#include <limits>
+#include <vector>
+
+namespace geos {
+namespace operation {
+namespace cluster {
+
+class UnionFind;
+
+class GEOS_DLL Clusters {
+private:
+    std::vector<std::size_t> m_elemsInCluster; // The IDs of elements that are included in a cluster
+    std::vector<std::size_t> m_starts; // Start position of each cluster in m_elemsInCluster
+    std::size_t m_numElems; // The number of elements from which clusters were generated
+
+public:
+    using const_iterator = decltype(m_elemsInCluster)::const_iterator;
+
+    explicit Clusters(UnionFind & uf, std::vector<std::size_t> elemsInCluster, std::size_t numElems);
+
+    // Get the number of clusters available
+    std::size_t getNumClusters() const {
+        return m_starts.size();
+    }
+
+    // Get the size of a given cluster
+    std::size_t getSize(std::size_t cluster) const {
+        return static_cast<std::size_t>(std::distance(begin(cluster), end(cluster)));
+    }
+
+    // Get a vector containing the cluster ID for each item in `elems`
+    std::vector<std::size_t> getClusterIds(std::size_t noClusterValue = std::numeric_limits<std::size_t>::max()) const;
+
+    // Get an iterator to the first element in a given cluster
+    const_iterator begin(std::size_t cluster) const {
+        return std::next(m_elemsInCluster.begin(), static_cast<std::ptrdiff_t>(m_starts[cluster]));
+    }
+
+    // Get an iterator beyond the last element in a given cluster
+    const_iterator end(std::size_t cluster) const {
+        if (cluster == static_cast<std::size_t>(m_starts.size() - 1)) {
+            return m_elemsInCluster.end();
+        }
+
+        return begin(cluster + 1);
+    }
+
+};
+
+}
+}
+}
+
+#endif

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

@@ -0,0 +1,59 @@
+/**********************************************************************
+ *
+ * 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_DBSCANCLUSTERFINDER
+#define GEOS_OPERATION_CLUSTER_DBSCANCLUSTERFINDER
+
+#include <geos/operation/cluster/AbstractClusterFinder.h>
+#include <geos/geom/Geometry.h>
+#include <stdexcept>
+
+namespace geos {
+namespace operation {
+namespace cluster {
+
+/** DBSCANClusterFinder clusters geometries according to the DBSCAN algorithm.
+ *
+ */
+class GEOS_DLL DBSCANClusterFinder : public AbstractClusterFinder {
+public:
+    DBSCANClusterFinder(double eps, size_t minPoints) : m_eps(eps), m_minPoints(minPoints) {}
+
+protected:
+
+    const geom::Envelope& queryEnvelope(const geom::Geometry* a) override {
+        m_envelope = *a->getEnvelopeInternal();
+        m_envelope.expandBy(m_eps);
+        return m_envelope;
+    }
+
+    Clusters process(const std::vector<const geom::Geometry*> & components,
+             index::strtree::TemplateSTRtree<std::size_t> & index,
+             UnionFind & uf) override;
+
+    bool shouldJoin(const geom::Geometry*, const geom::Geometry*) override {
+        throw std::runtime_error("Never get here.");
+    }
+
+private:
+    double m_eps;
+    size_t m_minPoints;
+    geom::Envelope m_envelope;
+};
+
+}
+}
+}
+
+#endif

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

@@ -0,0 +1,73 @@
+/**********************************************************************
+ *
+ * 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/operation/cluster/AbstractClusterFinder.h>
+#include <geos/operation/cluster/GeometryFlattener.h>
+#include <geos/geom/Geometry.h>
+#include <geos/geom/GeometryFactory.h>
+
+namespace geos {
+namespace operation {
+namespace cluster {
+
+class GEOS_DLL DisjointOperation {
+public:
+    DisjointOperation(AbstractClusterFinder& finder) : m_finder(finder), m_split_inputs(false) {}
+
+    /** Splits multipart geometries into their underlying components before identifying
+     *  disjoint subsets.
+     */
+    void setSplitInputs(bool b) {
+        m_split_inputs = b;
+    }
+
+    /** Decompose a geometry into disjoint subsets using the provided `ClusterFinder`,
+     *  process each subset using `f`, and combine/flatten the results. It is assumed that
+     *  the processed results of each subset will also be disjoint; therefore, this
+     *  algorithm may not be suitable for operations such as buffering.
+     *
+     * @brief process
+     * @param g a geometry to be processed
+     * @param f function taking a single argument of `const Geometry&`
+     */
+    template<typename Function>
+    std::unique_ptr<geom::Geometry> processDisjointSubsets(const geom::Geometry& g, Function&& f) {
+        if (g.getNumGeometries() == 1) {
+            return f(g);
+        }
+
+        auto flattened = m_split_inputs ? operation::cluster::GeometryFlattener::flatten(g.clone()) : g.clone();
+        auto clustered = m_finder.clusterToVector(std::move(flattened));
+
+        for (auto& subset : clustered) {
+            subset = f(*subset);
+        }
+
+        auto coll = g.getFactory()->createGeometryCollection(std::move(clustered));
+
+        return operation::cluster::GeometryFlattener::flatten(std::move(coll));
+    }
+
+private:
+    AbstractClusterFinder& m_finder;
+    bool m_split_inputs;
+};
+
+
+}
+}
+}

package/dist/prebuilt/Android-x86_64/include/geos/operation/cluster/EnvelopeDistanceClusterFinder.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_ENVELOPEDISTANCECLUSTERFINDER
+#define GEOS_OPERATION_CLUSTER_ENVELOPEDISTANCECLUSTERFINDER
+
+#include <geos/operation/cluster/AbstractClusterFinder.h>
+#include <geos/geom/Envelope.h>
+
+namespace geos {
+namespace operation {
+namespace cluster {
+
+/** EnvelopeDistanceClusterFinder clusters geometries by the distance between their envelopes.
+ * Any two geometries whose envelopes are within the specified distance will be included in the same cluster.
+ */
+class GEOS_DLL EnvelopeDistanceClusterFinder : public AbstractClusterFinder {
+public:
+    explicit EnvelopeDistanceClusterFinder(double d) : m_distance(d), m_distance_squared(d*d) {}
+
+protected:
+    const geom::Envelope& queryEnvelope(const geom::Geometry* a) override {
+        m_envelope = *a->getEnvelopeInternal();
+        m_envelope.expandBy(m_distance);
+        return m_envelope;
+    }
+
+    bool shouldJoin(const geom::Geometry* a, const geom::Geometry *b) override {
+        return a->getEnvelopeInternal()->distanceSquared(*b->getEnvelopeInternal()) <= m_distance_squared;
+    }
+
+private:
+    geom::Envelope m_envelope;
+    double m_distance;
+    double m_distance_squared;
+};
+
+}
+}
+}
+
+#endif

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

@@ -0,0 +1,44 @@
+/**********************************************************************
+ *
+ * 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_ENVELOPEINTERSECTSCLUSTERFINDER
+#define GEOS_OPERATION_CLUSTER_ENVELOPEINTERSECTSCLUSTERFINDER
+
+#include <geos/operation/cluster/AbstractClusterFinder.h>
+
+namespace geos {
+namespace operation {
+namespace cluster {
+
+/** EnvelopeIntersectsClusterFinder clusters geometries by envelope intersection.
+ * Any two geometries whose envelopes intersect will be included in the same cluster.
+ */
+class GEOS_DLL EnvelopeIntersectsClusterFinder : 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 {
+        return a->getEnvelopeInternal()->intersects(b->getEnvelopeInternal());
+    }
+
+};
+
+}
+}
+}
+
+#endif

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

@@ -0,0 +1,59 @@
+/**********************************************************************
+ *
+ * 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_GEOMETRYDISTANCECLUSTERFINDER
+#define GEOS_OPERATION_CLUSTER_GEOMETRYDISTANCECLUSTERFINDER
+
+#include <geos/operation/cluster/AbstractClusterFinder.h>
+#include <geos/geom/prep/PreparedGeometry.h>
+#include <geos/geom/prep/PreparedGeometryFactory.h>
+
+namespace geos {
+namespace operation {
+namespace cluster {
+
+/** GeometryDistanceClusterFinder clusters geometries according to the distance between
+ *  them. Any two geometries that are within the specified threshold distance will be
+ *  included in the same cluster.
+ */
+class GEOS_DLL GeometryDistanceClusterFinder : public AbstractClusterFinder {
+public:
+    explicit GeometryDistanceClusterFinder(double distance) : m_distance(distance) {}
+
+protected:
+    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->isWithinDistance(b, m_distance);
+    }
+
+    const geom::Envelope& queryEnvelope(const geom::Geometry* a) override {
+        m_envelope = *a->getEnvelopeInternal();
+        m_envelope.expandBy(m_distance);
+        return m_envelope;
+    }
+
+private:
+    std::unique_ptr<geom::prep::PreparedGeometry> m_prep;
+    double m_distance;
+    geom::Envelope m_envelope;
+};
+
+}
+}
+}
+
+#endif