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

package/dist/prebuilt/Android-x86_64/include/geos/index/strtree/ItemDistance.h

@@ -0,0 +1,49 @@
+/**********************************************************************
+ *
+ * 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: index/strtree/ItemDistance.java (JTS-1.14)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/index/strtree/ItemBoundable.h>
+
+namespace geos {
+namespace index {
+namespace strtree {
+
+/** \brief
+ * A function method which computes the distance between two [ItemBoundables](\ref ItemBoundable)
+ * in an STRtree. Used for Nearest Neighbour searches.
+ *
+ * \author Martin Davis
+ */
+class GEOS_DLL ItemDistance {
+public:
+    /** \brief
+     * Computes the distance between two items.
+     *
+     * @param item1
+     * @param item2
+     * @return the distance between the items
+     *
+     * @throws IllegalArgumentException if the metric is not applicable to the arguments
+     */
+    virtual double distance(const ItemBoundable* item1, const ItemBoundable* item2) = 0;
+};
+}
+}
+}
+

package/dist/prebuilt/Android-x86_64/include/geos/index/strtree/SIRtree.h

@@ -0,0 +1,124 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/index/strtree/AbstractSTRtree.h> // for inheritance
+#include <geos/index/strtree/Interval.h> // for inline
+
+#include <vector>
+#include <memory>
+
+namespace geos {
+namespace index { // geos::index
+namespace strtree { // geos::index::strtree
+
+/** \brief
+ * One-dimensional version of an STR-packed R-tree.
+ *
+ * SIR stands for "Sort-Interval-Recursive".
+ *
+ * STR-packed R-trees are described in:
+ * P. Rigaux, Michel Scholl and Agnes Voisard. Spatial Databases With
+ * Application To GIS. Morgan Kaufmann, San Francisco, 2002.
+ *
+ * @see STRtree
+ */
+class GEOS_DLL SIRtree: public AbstractSTRtree {
+    using AbstractSTRtree::insert;
+    using AbstractSTRtree::query;
+
+public:
+
+    /** \brief
+     * Constructs an SIRtree with the default node capacity.
+     */
+    SIRtree();
+
+    /** \brief
+     * Constructs an SIRtree with the given maximum number of child nodes
+     * that a node may have
+     */
+    SIRtree(std::size_t nodeCapacity);
+
+    ~SIRtree() override;
+
+    void insert(double x1, double x2, void* item);
+
+    /**
+     * Returns items whose bounds intersect the given bounds.
+     * @param x1 possibly equal to x2
+     * @param x2
+     */
+    std::vector<void*>*
+    query(double x1, double x2)
+    {
+        std::vector<void*>* results = new std::vector<void*>();
+        Interval interval(std::min(x1, x2), std::max(x1, x2));
+        AbstractSTRtree::query(&interval, *results);
+        return results;
+    }
+
+    /**
+     * Returns items whose bounds intersect the given value.
+     */
+    std::vector<void*>*
+    query(double x)
+    {
+        return query(x, x);
+    }
+
+    /**
+     * Disable copy construction and assignment. Apparently needed to make this
+     * class compile under MSVC. (See https://stackoverflow.com/q/29565299)
+     */
+    SIRtree(const SIRtree&) = delete;
+    SIRtree& operator=(const SIRtree&) = delete;
+
+protected:
+
+    class SIRIntersectsOp: public AbstractSTRtree::IntersectsOp {
+    public:
+        bool intersects(const void* aBounds, const void* bBounds) override;
+    };
+
+    /** \brief
+     * Sorts the childBoundables then divides them into groups of size M, where
+     * M is the node capacity.
+     */
+    std::unique_ptr<BoundableList> createParentBoundables(
+        BoundableList* childBoundables, int newLevel) override;
+
+    AbstractNode* createNode(int level) override;
+
+    IntersectsOp*
+    getIntersectsOp() override
+    {
+        return intersectsOp;
+    }
+
+    std::unique_ptr<BoundableList> sortBoundables(const BoundableList* input);
+
+private:
+    IntersectsOp* intersectsOp;
+    std::vector<std::unique_ptr<Interval>> intervals;
+};
+
+
+} // namespace geos::index::strtree
+} // namespace geos::index
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/index/strtree/STRtree.h

@@ -0,0 +1,177 @@
+/**********************************************************************
+ *
+ * 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: index/strtree/STRtree.java rev. 1.11
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/index/strtree/ItemDistance.h>
+#include <geos/index/strtree/BoundablePair.h>
+#include <geos/index/strtree/AbstractSTRtree.h> // for inheritance
+#include <geos/index/SpatialIndex.h> // for inheritance
+#include <geos/geom/Envelope.h> // for inlines
+
+#include <vector>
+
+#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 index {
+namespace strtree {
+class Boundable;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos::index
+namespace strtree { // geos::index::strtree
+
+/**
+ * \brief
+ * A query-only R-tree created using the Sort-Tile-Recursive (STR) algorithm.
+ * For two-dimensional spatial data.
+ *
+ * The STR packed R-tree is simple to implement and maximizes space
+ * utilization; that is, as many leaves as possible are filled to capacity.
+ * Overlap between nodes is far less than in a basic R-tree. However, once the
+ * tree has been built (explicitly or on the first call to #query), items may
+ * not be added or removed.
+ *
+ * Described in: P. Rigaux, Michel Scholl and Agnes Voisard. Spatial
+ * Databases With Application To GIS. Morgan Kaufmann, San Francisco, 2002.
+ *
+ */
+class GEOS_DLL STRtree: public AbstractSTRtree, public SpatialIndex {
+    using AbstractSTRtree::insert;
+    using AbstractSTRtree::query;
+
+private:
+    class GEOS_DLL STRIntersectsOp: public AbstractSTRtree::IntersectsOp {
+    public:
+        bool intersects(const void* aBounds, const void* bBounds) override;
+    };
+
+    /**
+     * Creates the parent level for the given child level. First, orders the items
+     * by the x-values of the midpoints, and groups them into vertical slices.
+     * For each slice, orders the items by the y-values of the midpoints, and
+     * group them into runs of size M (the node capacity). For each run, creates
+     * a new (parent) node.
+     */
+    std::unique_ptr<BoundableList> createParentBoundables(BoundableList* childBoundables, int newLevel) override;
+
+    std::unique_ptr<BoundableList> createParentBoundablesFromVerticalSlices(std::vector<BoundableList*>* verticalSlices,
+            int newLevel);
+
+    STRIntersectsOp intersectsOp;
+
+    std::unique_ptr<BoundableList> sortBoundablesY(const BoundableList* input);
+    std::unique_ptr<BoundableList> sortBoundablesX(const BoundableList* input);
+
+    std::unique_ptr<BoundableList> createParentBoundablesFromVerticalSlice(
+        BoundableList* childBoundables,
+        int newLevel);
+
+    /**
+     * @param childBoundables Must be sorted by the x-value of
+     *        the envelope midpoints
+     * @return
+     */
+    std::vector<BoundableList*>* verticalSlices(
+        BoundableList* childBoundables,
+        std::size_t sliceCount);
+
+    bool isWithinDistance(BoundablePair* initBndPair, double maxDistance);
+
+protected:
+
+    AbstractNode* createNode(int level) override;
+
+    IntersectsOp*
+    getIntersectsOp() override
+    {
+        return &intersectsOp;
+    }
+
+public:
+
+    ~STRtree() override = default;
+
+    /**
+     * Constructs an STRtree with the given maximum number of child nodes that
+     * a node may have
+     */
+    STRtree(std::size_t nodeCapacity = 10);
+
+    void insert(const geom::Envelope* itemEnv, void* item) override;
+
+    //static double centreX(const geom::Envelope *e);
+
+    static double
+    avg(double a, double b)
+    {
+        return (a + b) / 2.0;
+    }
+
+    static double
+    centreY(const geom::Envelope* e)
+    {
+        return STRtree::avg(e->getMinY(), e->getMaxY());
+    }
+
+    void
+    query(const geom::Envelope* searchEnv, std::vector<void*>& matches) override
+    {
+        AbstractSTRtree::query(searchEnv, matches);
+    }
+
+    void
+    query(const geom::Envelope* searchEnv, ItemVisitor& visitor) override
+    {
+        return AbstractSTRtree::query(searchEnv, visitor);
+    }
+
+    std::pair<const void*, const void*> nearestNeighbour(ItemDistance* itemDist);
+    const void* nearestNeighbour(const geom::Envelope* env, const void* item, ItemDistance* itemDist);
+    std::pair<const void*, const void*> nearestNeighbour(STRtree* tree, ItemDistance* itemDist);
+    std::pair<const void*, const void*> nearestNeighbour(BoundablePair* initBndPair);
+    std::pair<const void*, const void*> nearestNeighbour(BoundablePair* initBndPair, double maxDistance);
+
+    bool
+    remove(const geom::Envelope* itemEnv, void* item) override
+    {
+        return AbstractSTRtree::remove(itemEnv, item);
+    }
+
+    bool isWithinDistance(STRtree* tree, ItemDistance* itemDist, double maxDistance);
+
+};
+
+} // namespace geos::index::strtree
+} // namespace geos::index
+} // namespace geos
+
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/include/geos/index/strtree/SimpleSTRdistance.h

@@ -0,0 +1,166 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 Paul Ramsey
+ *
+ * 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 <cassert>
+#include <cstddef>
+#include <geos/export.h>
+#include <geos/geom/Envelope.h>
+#include <geos/index/strtree/SimpleSTRtree.h>
+#include <geos/index/strtree/SimpleSTRnode.h>
+
+#include <vector>
+#include <queue>
+
+#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
+
+namespace geos {
+namespace index { // geos::index
+namespace strtree { // geos::index::strtree
+
+
+
+
+
+class GEOS_DLL SimpleSTRpair {
+
+private:
+
+    SimpleSTRnode* node1;
+    SimpleSTRnode* node2;
+    ItemDistance* itemDistance;
+    double m_distance;
+
+    /** \brief
+     * Computes the distance between the {@link SimpleSTRnode}s in this pair.
+     * The nodes are either composites or leaves.
+     *
+     * If either is composite, the distance is computed as the minimum distance
+     * between the bounds.
+     * If both are leaves, the distance is computed by
+     * ItemDistance::distance(const void* item1, const void* item2).
+     *
+     * @return the distance between the items
+     */
+    double distance();
+
+public:
+
+    SimpleSTRpair(SimpleSTRnode* p_node1, SimpleSTRnode* p_node2, ItemDistance* p_itemDistance)
+        : node1(p_node1)
+        , node2(p_node2)
+        , itemDistance(p_itemDistance)
+        {
+            m_distance = distance();
+        }
+
+    SimpleSTRnode* getNode(int i) const;
+
+    /** \brief
+     * Gets the minimum possible distance between the SimpleSTRnode in this pair.
+     *
+     * If the members are both items, this will be the
+     * exact distance between them.
+     * Otherwise, this distance will be a lower bound on
+     * the distances between the items in the members.
+     *
+     * @return the exact or lower bound distance for this pair
+     */
+    double getDistance() const;
+
+    /**
+     * Tests if both elements of the pair are leaf nodes
+     *
+     * @return true if both pair elements are leaf nodes
+     */
+    bool isLeaves() const;
+
+    /** \brief
+     * Computes the maximum distance between any
+     * two items in the pair of nodes.
+     *
+     * @return the maximum distance between items in the pair
+     */
+    double maximumDistance();
+
+    friend std::ostream& operator<<(std::ostream& os, SimpleSTRpair& pair);
+
+
+};
+
+
+
+class GEOS_DLL SimpleSTRdistance {
+
+
+public:
+
+    struct STRpairQueueCompare {
+        bool
+        operator()(const SimpleSTRpair* a, const SimpleSTRpair* b)
+        {
+            return a->getDistance() > b->getDistance();
+        }
+    };
+
+    typedef std::priority_queue<SimpleSTRpair*,
+        std::vector<SimpleSTRpair*>,
+        STRpairQueueCompare> STRpairQueue;
+
+
+    /* Initialize class */
+    SimpleSTRdistance(SimpleSTRnode* root1, SimpleSTRnode* root2, ItemDistance* p_itemDistance);
+
+    /* Turn over the calculation */
+    std::pair<const void*, const void*> nearestNeighbour();
+    bool isWithinDistance(double maxDistance);
+
+
+private:
+
+    std::deque<SimpleSTRpair> pairStore;
+    SimpleSTRpair* initPair;
+    ItemDistance* itemDistance;
+
+    /* Utility method to store allocated pairs */
+    SimpleSTRpair* createPair(SimpleSTRnode* p_node1, SimpleSTRnode* p_node2, ItemDistance* p_itemDistance);
+
+    std::pair<const void*, const void*> nearestNeighbour(SimpleSTRpair* p_initPair);
+    std::pair<const void*, const void*> nearestNeighbour(SimpleSTRpair* p_initPair, double maxDistance);
+
+    bool isWithinDistance(SimpleSTRpair* p_initPair, double maxDistance);
+
+    void expandToQueue(SimpleSTRpair* pair, STRpairQueue&, double minDistance);
+    void expand(SimpleSTRnode* nodeComposite, SimpleSTRnode* nodeOther,
+        bool isFlipped, STRpairQueue& priQ, double minDistance);
+
+
+};
+
+
+
+
+
+} // namespace geos::index::strtree
+} // namespace geos::index
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/include/geos/index/strtree/SimpleSTRnode.h

@@ -0,0 +1,141 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 Paul Ramsey
+ *
+ * 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 <cassert>
+#include <geos/export.h>
+#include <geos/geom/Envelope.h>
+#include <geos/index/strtree/ItemBoundable.h>
+
+#include <vector>
+
+#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
+
+namespace geos {
+namespace index { // geos::index
+namespace strtree { // geos::index::strtree
+
+/** \brief
+ * A node of the STR tree.
+ *
+ */
+class GEOS_DLL SimpleSTRnode : public ItemBoundable {
+
+private:
+
+    std::vector<SimpleSTRnode*> childNodes;
+    void *item;
+    geom::Envelope bounds;
+    std::size_t level;
+
+public:
+
+    /*
+     * Constructs an AbstractNode at the given level in the tree
+     */
+    SimpleSTRnode(std::size_t newLevel, const geom::Envelope *p_env, void* p_item, std::size_t capacity = 10)
+        : ItemBoundable(p_env, p_item)
+        , item(p_item)
+        , bounds()
+        , level(newLevel)
+    {
+        childNodes.reserve(capacity);
+        if (p_env) {
+            bounds = *p_env;
+        }
+
+    }
+
+    SimpleSTRnode(std::size_t newLevel)
+        : SimpleSTRnode(newLevel, nullptr, nullptr)
+    {}
+
+    void toString(std::ostream& os, int indentLevel) const;
+
+    std::size_t getNumNodes() const;
+    std::size_t getNumLeafNodes() const;
+
+    const std::vector<SimpleSTRnode*>&
+    getChildNodes() const
+    {
+        return childNodes;
+    }
+
+    void* getItem() const {
+        return item;
+    }
+
+    bool removeItem(void *item);
+    bool removeChild(SimpleSTRnode *child);
+
+    /**
+     * Returns a representation of space that encloses this Node
+     */
+    const inline geom::Envelope& getEnvelope() const {
+        return bounds;
+    }
+
+    const void* getBounds() const override {
+        return &bounds;
+    }
+
+    /**
+    * Returns 0 if this node is a leaf, 1 if a parent of a leaf, and so on; the
+    * root node will have the highest level
+    */
+    std::size_t getLevel() const {
+        return level;
+    }
+
+    std::size_t size() const {
+        return childNodes.size();
+    }
+
+    /**
+     * Adds either an AbstractNode, or if this is a leaf node, a data object
+     * (wrapped in an ItemBoundable)
+     */
+    void addChildNode(SimpleSTRnode* childNode);
+
+    bool isLeaf() const override
+    {
+        return level == 0;
+    }
+
+    bool isComposite() const
+    {
+        return ! isLeaf();
+    }
+
+    double area() const
+    {
+        return bounds.getArea();
+    }
+
+
+};
+
+
+} // namespace geos::index::strtree
+} // namespace geos::index
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+