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

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

@@ -0,0 +1,189 @@
+/**********************************************************************
+ *
+ * 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 <geos/export.h>
+#include <geos/index/SpatialIndex.h> // for inheritance
+#include <geos/geom/Envelope.h>
+#include <geos/index/strtree/SimpleSTRnode.h>
+
+#include <vector>
+#include <utility>
+
+
+#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 Geometry;
+class Envelope;
+}
+namespace index {
+namespace strtree {
+class ItemDistance;
+}
+}
+}
+
+
+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 SimpleSTRtree: public SpatialIndex {
+
+
+private:
+
+    /* Members */
+    std::deque<SimpleSTRnode> nodesQue;
+    std::vector<SimpleSTRnode*> nodes;
+    std::size_t nodeCapacity;
+    bool built;
+
+    /*
+    * Allocate node in nodesQue std::deque for memory locality,
+    * return reference to node.
+    */
+    SimpleSTRnode* createNode(int newLevel, const geom::Envelope* itemEnv, void* item);
+    SimpleSTRnode* createNode(int newLevel);
+
+
+    void build();
+
+    static void sortNodesY(std::vector<SimpleSTRnode*>& nodeList);
+    static void sortNodesX(std::vector<SimpleSTRnode*>& nodeList);
+
+    void query(const geom::Envelope* searchEnv, const SimpleSTRnode* node, ItemVisitor& visitor);
+    void query(const geom::Envelope* searchEnv, const SimpleSTRnode* node, std::vector<void*>& matches);
+
+    /* Turn off copy constructors for MSVC */
+    SimpleSTRtree(const SimpleSTRtree&) = delete;
+    SimpleSTRtree& operator=(const SimpleSTRtree&) = delete;
+
+    std::vector<SimpleSTRnode*> createHigherLevels(
+        std::vector<SimpleSTRnode*>& nodesOfALevel, int level);
+
+    void addParentNodesFromVerticalSlice(
+        std::vector<SimpleSTRnode*>& verticalSlice,
+        int newLevel,
+        std::vector<SimpleSTRnode*>& parentNodes);
+
+    std::vector<SimpleSTRnode*> createParentNodes(
+        std::vector<SimpleSTRnode*>& childNodes,
+        int newLevel);
+
+    bool remove(const geom::Envelope* searchBounds, SimpleSTRnode* node, void* item);
+
+
+public:
+
+    /* Member */
+    SimpleSTRnode* root;
+
+    /**
+     * Constructs an STRtree with the given maximum number of child nodes that
+     * a node may have
+     */
+    SimpleSTRtree(std::size_t capacity = 10)
+        : nodeCapacity(capacity)
+        , built(false)
+        , root(nullptr)
+        {};
+
+    std::size_t getNodeCapacity() const {
+        return nodeCapacity;
+    }
+
+    std::size_t getNumLeafNodes() const {
+        if (!root)
+            return 0;
+        else
+            return root->getNumLeafNodes();
+    }
+
+
+
+    bool getBuilt() const {
+        return built;
+    }
+
+    SimpleSTRnode* getRoot() {
+        build();
+        return root;
+    }
+
+    void insert(geom::Geometry* geom);
+
+    void insert(const geom::Envelope* itemEnv, void* item) override;
+
+    void iterate(ItemVisitor& visitor);
+
+    void query(const geom::Envelope* searchEnv, std::vector<void*>& matches) override;
+
+    void query(const geom::Envelope* searchEnv, ItemVisitor& visitor) override;
+
+    bool remove(const geom::Envelope* searchBounds, void* item) override;
+
+    friend std::ostream& operator<<(std::ostream& os, const SimpleSTRtree& tree);
+
+
+    /*********************************************************************************/
+    /* Nearest neighbor searches, public API */
+
+    /* Internal nearest node to node */
+    std::pair<const void*, const void*> nearestNeighbour(ItemDistance* itemDist);
+
+    /* Nearest to another geometry/item */
+    const void* nearestNeighbour(const geom::Envelope* env, const void* item, ItemDistance* itemDist);
+
+    /* Nearest to another tree */
+    std::pair<const void*, const void*> nearestNeighbour(SimpleSTRtree& tree, ItemDistance* itemDist);
+
+    /* Radius test */
+    bool isWithinDistance(SimpleSTRtree& 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/TemplateSTRNode.h

@@ -0,0 +1,156 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <utility>
+
+namespace geos {
+namespace index {
+namespace strtree {
+
+template<typename ItemType, typename BoundsTraits>
+class TemplateSTRNode {
+private:
+    using BoundsType = typename BoundsTraits::BoundsType;
+
+    BoundsType bounds;
+
+    union Body {
+        ItemType item;
+        const TemplateSTRNode* childrenEnd;
+
+        explicit Body (ItemType&& p_item) : item(std::forward<ItemType>(p_item)) {}
+
+        explicit Body (const ItemType& p_item) : item(p_item) {}
+
+        explicit Body (const TemplateSTRNode<ItemType, BoundsTraits>* p_childrenEnd) : childrenEnd(p_childrenEnd) {}
+
+        ~Body() = default;
+    } data;
+    const TemplateSTRNode* children;
+
+public:
+    ~TemplateSTRNode() {
+        if (isLeaf()) {
+            data.item.~ItemType();
+        }
+    }
+
+    TemplateSTRNode(ItemType&& p_item, const BoundsType& env) :
+        bounds(env),
+        data(std::forward<ItemType>(p_item)),
+        children(nullptr)
+        {}
+
+    TemplateSTRNode(const ItemType& p_item, const BoundsType& env) :
+            bounds(env),
+            data(p_item),
+            children(nullptr)
+            {}
+
+    TemplateSTRNode(const TemplateSTRNode* begin, const TemplateSTRNode* end) :
+        bounds(boundsFromChildren(begin, end)),
+        data(end),
+        children(begin)
+    {}
+
+    const TemplateSTRNode* beginChildren() const {
+        return children;
+    }
+
+    const TemplateSTRNode* endChildren() const {
+        return data.childrenEnd;
+    }
+
+    bool isDeleted() const {
+        return children == this;
+    }
+
+    bool isLeaf() const {
+        return children == nullptr || children == this;
+    }
+
+    bool isComposite() const {
+        return !isLeaf();
+    }
+
+    bool boundsIntersect(const BoundsType& queryBounds) const {
+        return BoundsTraits::intersects(getBounds(), queryBounds);
+    }
+
+    double getSize() const {
+        return BoundsTraits::size(getBounds());
+    }
+
+    static BoundsType boundsFromChildren(const TemplateSTRNode* from, const TemplateSTRNode* to) {
+        BoundsType bnds = from->getBounds();
+
+        for (auto *child = from + 1; child < to; ++child) {
+            BoundsTraits::expandToInclude(bnds, child->getBounds());
+        }
+
+        return bnds;
+    }
+
+    BoundsType boundsFromChildren() const {
+        return boundsFromChildren(children, data.childrenEnd);
+    }
+
+    const BoundsType& getBounds() const {
+        return bounds;
+    }
+
+    std::size_t getNumNodes() const
+    {
+        if (isLeaf()) {
+            return isDeleted() ? 0 : 1;
+        }
+
+        std::size_t count = 1;
+        for (const auto* child = beginChildren(); child != endChildren(); ++child) {
+            count += child->getNumNodes();
+        }
+
+        return count;
+    }
+
+    std::size_t getNumLeafNodes() const
+    {
+        if (isLeaf()) {
+            return isDeleted() ? 0 : 1;
+        }
+
+        std::size_t count = 0;
+        for (const auto* child = beginChildren(); child != endChildren(); ++child) {
+            count += child->getNumNodes();
+        }
+        return count;
+    }
+
+    const ItemType& getItem() const {
+        assert(!isDeleted());
+        return data.item;
+    }
+
+    void removeItem() {
+        children = this;
+    }
+
+};
+
+}
+}
+}
+

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

@@ -0,0 +1,74 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/index/strtree/TemplateSTRNode.h>
+#include <utility>
+
+namespace geos {
+namespace index {
+namespace strtree {
+
+template<typename ItemType, typename BoundsTraits, typename ItemDistance>
+class TemplateSTRNodePair {
+public:
+    using Node = TemplateSTRNode<ItemType, BoundsTraits>;
+
+    TemplateSTRNodePair(const Node &node1, const Node &node2, ItemDistance& id)
+            : m_node1(&node1), m_node2(&node2), m_distance(distance(id)) {}
+
+    bool isLeaves() const {
+        return getFirst().isLeaf() && getSecond().isLeaf();
+    }
+
+    double getDistance() const {
+        return m_distance;
+    }
+
+    std::pair<ItemType, ItemType> getItems() const {
+        assert(isLeaves());
+        return std::make_pair(getFirst().getItem(), getSecond().getItem());
+    }
+
+    const Node &getFirst() const {
+        return *m_node1;
+    }
+
+    const Node &getSecond() const {
+        return *m_node2;
+    }
+
+    double distance(ItemDistance& id) {
+        if (isLeaves()) {
+            return id(getFirst().getItem(), getSecond().getItem());
+        } else {
+            return BoundsTraits::distance(getFirst().getBounds(), getSecond().getBounds());
+        }
+    }
+
+    double maximumDistance() {
+        return BoundsTraits::maxDistance(getFirst().getBounds(), getSecond().getBounds());
+    }
+
+private:
+    const Node* m_node1;
+    const Node* m_node2;
+    double m_distance;
+};
+
+}
+}
+}
+