@crossbind/port-geos-linuxmusl 0.0.0-stage → 2.0.0-beta.64

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/index/quadtree/NodeBase.h

@@ -0,0 +1,161 @@
+/**********************************************************************
+ *
+ * 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/quadtree/NodeBase.java rev 1.9 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <array>
+#include <vector>
+#include <string>
+
+#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 Envelope;
+}
+namespace index {
+class ItemVisitor;
+namespace quadtree {
+class Node;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos::index
+namespace quadtree { // geos::index::quadtree
+
+/**
+ * \brief
+ * The base class for nodes in a Quadtree.
+ *
+ */
+class GEOS_DLL NodeBase {
+
+private:
+
+    void visitItems(const geom::Envelope* searchEnv,
+                    ItemVisitor& visitor);
+
+public:
+
+    static int getSubnodeIndex(const geom::Envelope* env,
+                               const geom::Coordinate& centre);
+
+    NodeBase();
+
+    virtual ~NodeBase();
+
+    std::vector<void*>& getItems();
+
+    /// Add an item to this node.
+    /// Ownership of the item is left to caller.
+    void add(void* item);
+
+    /// Push all node items to the given vector, return the argument
+    std::vector<void*>& addAllItems(std::vector<void*>& resultItems) const;
+
+    virtual void addAllItemsFromOverlapping(const geom::Envelope& searchEnv,
+                                            std::vector<void*>& resultItems) const;
+
+    unsigned int depth() const;
+
+    std::size_t size() const;
+
+    std::size_t getNodeCount() const;
+
+    virtual std::string toString() const;
+
+    virtual void visit(const geom::Envelope* searchEnv, ItemVisitor& visitor);
+
+    /**
+     * Removes a single item from this subtree.
+     *
+     * @param itemEnv the envelope containing the item
+     * @param item the item to remove
+     * @return <code>true</code> if the item was found and removed
+     */
+    bool remove(const geom::Envelope* itemEnv, void* item);
+
+    bool hasItems() const;
+
+    bool hasChildren() const;
+
+    bool isPrunable() const;
+
+protected:
+
+    /// Actual items are NOT owned by this class
+    std::vector<void*> items;
+
+    /**
+     * subquads are numbered as follows:
+     * <pre>
+     *  2 | 3
+     *  --+--
+     *  0 | 1
+     * </pre>
+     *
+     * Nodes are owned by this class
+     */
+    std::array<Node*, 4> subnodes;
+
+    virtual bool isSearchMatch(const geom::Envelope& searchEnv) const = 0;
+};
+
+
+// INLINES, To be moved in NodeBase.inl
+
+inline bool
+NodeBase::hasChildren() const
+{
+    for(const auto& subnode : subnodes) {
+        if(subnode != nullptr) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+inline bool
+NodeBase::isPrunable() const
+{
+    return !(hasChildren() || hasItems());
+}
+
+inline bool
+NodeBase::hasItems() const
+{
+    return ! items.empty();
+}
+
+} // namespace geos::index::quadtree
+} // namespace geos::index
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/index/quadtree/Quadtree.h

@@ -0,0 +1,225 @@
+/**********************************************************************
+ *
+ * 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/quadtree/Quadtree.java rev. 1.16 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Envelope.h>
+#include <geos/index/SpatialIndex.h> // for inheritance
+#include <geos/index/quadtree/Root.h> // for composition
+
+#include <memory>
+#include <vector>
+#include <string>
+
+#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 quadtree {
+// class Root;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos::index
+namespace quadtree { // geos::index::quadtree
+
+/**
+ * \brief
+ * A Quadtree is a spatial index structure for efficient querying
+ * of 2D rectangles.  If other kinds of spatial objects
+ * need to be indexed they can be represented by their
+ * envelopes
+ *
+ * The quadtree structure is used to provide a primary filter
+ * for range rectangle queries.  The query() method returns a list of
+ * all objects which <i>may</i> intersect the query rectangle.  Note that
+ * it may return objects which do not in fact intersect.
+ * A secondary filter is required to test for exact intersection.
+ * Of course, this secondary filter may consist of other tests besides
+ * intersection, such as testing other kinds of spatial relationships.
+ *
+ * This implementation does not require specifying the extent of the inserted
+ * items beforehand.  It will automatically expand to accommodate any extent
+ * of dataset.
+ *
+ * This data structure is also known as an <i>MX-CIF quadtree</i>
+ * following the usage of Samet and others.
+ */
+class GEOS_DLL Quadtree: public SpatialIndex {
+
+private:
+
+    std::vector<std::unique_ptr<geom::Envelope>> newEnvelopes;
+
+    void collectStats(const geom::Envelope& itemEnv);
+
+    Root root;
+
+    /**
+     *  Statistics
+     *
+     * minExtent is the minimum envelope extent of all items
+     * inserted into the tree so far. It is used as a heuristic value
+     * to construct non-zero envelopes for features with zero X and/or
+     * Y extent.
+     * Start with a non-zero extent, in case the first feature inserted has
+     * a zero extent in both directions.  This value may be non-optimal, but
+     * only one feature will be inserted with this value.
+     */
+    double minExtent;
+
+public:
+    /**
+     * \brief
+     * Ensure that the envelope for the inserted item has non-zero extents.
+     *
+     * Use the current minExtent to pad the envelope, if necessary.
+     * Can return a new Envelope or the given one (casted to non-const).
+     */
+    static geom::Envelope* ensureExtent(const geom::Envelope* itemEnv,
+                                        double minExtent);
+
+    /**
+     * \brief
+     * Constructs a Quadtree with zero items.
+     */
+    Quadtree()
+        :
+        root(),
+        minExtent(1.0)
+    {}
+
+    ~Quadtree() override = default;
+
+    /// Returns the number of levels in the tree.
+    std::size_t depth();
+
+    /// Returns the number of items in the tree.
+    std::size_t size();
+
+    void insert(const geom::Envelope* itemEnv, void* item) override;
+
+    /** \brief
+     * Queries the tree and returns items which may lie
+     * in the given search envelope.
+     *
+     * Precisely, the items that are returned are all items in the tree
+     * whose envelope <b>may</b> intersect the search Envelope.
+     * Note that some items with non-intersecting envelopes may be
+     * returned as well;
+     * the client is responsible for filtering these out.
+     * In most situations there will be many items in the tree which do not
+     * intersect the search envelope and which are not returned - thus
+     * providing improved performance over a simple linear scan.
+     *
+     * @param searchEnv the envelope of the desired query area.
+     * @param ret a vector where items which may intersect the
+     * 	      search envelope are pushed
+     */
+    void query(const geom::Envelope* searchEnv, std::vector<void*>& ret) override;
+
+
+    /** \brief
+     * Queries the tree and visits items which may lie in
+     * the given search envelope.
+     *
+     * Precisely, the items that are visited are all items in the tree
+     * whose envelope <b>may</b> intersect the search Envelope.
+     * Note that some items with non-intersecting envelopes may be
+     * visited as well;
+     * the client is responsible for filtering these out.
+     * In most situations there will be many items in the tree which do not
+     * intersect the search envelope and which are not visited - thus
+     * providing improved performance over a simple linear scan.
+     *
+     * @param searchEnv the envelope of the desired query area.
+     * @param visitor a visitor object which is passed the visited items
+     */
+    void
+    query(const geom::Envelope* searchEnv, ItemVisitor& visitor) override
+    {
+        /*
+         * the items that are matched are the items in quads which
+         * overlap the search envelope
+         */
+        root.visit(searchEnv, visitor);
+    }
+
+    /**
+     * Removes a single item from the tree.
+     *
+     * @param itemEnv the Envelope of the item to be removed
+     * @param item the item to remove
+     * @return <code>true</code> if the item was found (and thus removed)
+     */
+    bool remove(const geom::Envelope* itemEnv, void* item) override;
+
+    /// Return a list of all items in the Quadtree
+    std::vector<void*>* queryAll();
+
+    std::string toString() const;
+
+    /**
+     * Disable copy construction and assignment. Apparently needed to make this
+     * class compile under MSVC. (See https://stackoverflow.com/q/29565299)
+     */
+    Quadtree(const Quadtree&) = delete;
+    Quadtree& operator=(const Quadtree&) = delete;
+
+
+    // Move constructor
+    Quadtree(Quadtree&& other) noexcept :
+        newEnvelopes(std::move(other.newEnvelopes)),
+        root(other.root),
+        minExtent(other.minExtent)
+    {
+        // The contents of 'other' are moved to 'this'
+        // 'other' will be empty after the move
+    };
+
+    // Move assignment operator
+    Quadtree& operator=(Quadtree&& other) noexcept
+    {
+        if (this != &other) {
+            // Move the vector from 'other' to 'this'
+            // 'newEnvelopes.data' will be empty after this operation
+            newEnvelopes.clear();
+            newEnvelopes = std::move(other.newEnvelopes);
+            minExtent = other.minExtent;
+            root = other.root;
+        }
+        return *this;
+    };
+
+};
+
+} // namespace geos::index::quadtree
+} // namespace geos::index
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/index/quadtree/Root.h

@@ -0,0 +1,85 @@
+/**********************************************************************
+ *
+ * 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/quadtree/Root.java rev 1.7 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/index/quadtree/NodeBase.h> // for inheritance
+#include <geos/geom/Coordinate.h> // for composition
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Envelope;
+}
+namespace index {
+namespace quadtree {
+class Node;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos::index
+namespace quadtree { // geos::index::quadtree
+
+/**
+ * \class Root
+ *
+ * \brief
+ * QuadRoot is the root of a single Quadtree.  It is centred at the origin,
+ * and does not have a defined extent.
+ */
+class GEOS_DLL Root: public NodeBase {
+
+private:
+
+    static const geom::Coordinate origin;
+
+    /**
+     * insert an item which is known to be contained in the tree rooted at
+     * the given QuadNode root.  Lower levels of the tree will be created
+     * if necessary to hold the item.
+     */
+    void insertContained(Node* tree, const geom::Envelope* itemEnv,
+                         void* item);
+
+public:
+
+    Root() {}
+
+    ~Root() override {}
+
+    /**
+     * Insert an item into the quadtree this is the root of.
+     */
+    void insert(const geom::Envelope* itemEnv, void* item);
+
+protected:
+
+    bool
+    isSearchMatch(const geom::Envelope& /* searchEnv */) const override
+    {
+        return true;
+    }
+
+};
+
+} // namespace geos::index::quadtree
+} // namespace geos::index
+} // namespace geos

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/index/strtree/AbstractNode.h

@@ -0,0 +1,131 @@
+/**********************************************************************
+ *
+ * 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 <cassert>
+#include <cstddef>
+#include <geos/export.h>
+#include <geos/index/strtree/Boundable.h> // for inheritance
+
+#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.
+ *
+ * The children of this node are either more nodes
+ * (AbstractNodes) or real data (ItemBoundables).
+ *
+ * If this node contains real data (rather than nodes),
+ * then we say that this node is a "leaf node".
+ *
+ */
+class GEOS_DLL AbstractNode: public Boundable {
+private:
+    std::vector<Boundable*> childBoundables;
+    int level;
+public:
+
+    /*
+     * Constructs an AbstractNode at the given level in the tree
+     * @param level 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
+     */
+    AbstractNode(int newLevel, std::size_t capacity = 10) : level(newLevel), bounds(nullptr) {
+        childBoundables.reserve(capacity);
+    }
+
+    ~AbstractNode() override = default;
+
+    // TODO: change signature to return by ref,
+    // document ownership of the return
+    inline std::vector<Boundable*>*
+    getChildBoundables()
+    {
+        return &childBoundables;
+    }
+
+    // TODO: change signature to return by ref,
+    // document ownership of the return
+    inline const std::vector<Boundable*>*
+    getChildBoundables() const
+    {
+        return &childBoundables;
+    }
+
+    /**
+     * Returns a representation of space that encloses this Boundable,
+     * preferably not much bigger than this Boundable's boundary yet fast to
+     * test for intersection with the bounds of other Boundables.
+     * The class of object returned depends on the subclass of
+     * AbstractSTRtree.
+     *
+     * @return an Envelope (for STRtrees), an Interval (for SIRtrees),
+     *	or other object (for other subclasses of AbstractSTRtree)
+     *
+     * @see AbstractSTRtree::IntersectsOp
+     */
+    const void* getBounds() const override {
+        if(bounds == nullptr) {
+            bounds = computeBounds();
+        }
+        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
+    */
+    int getLevel() {
+        return level;
+    }
+
+    /**
+     * Adds either an AbstractNode, or if this is a leaf node, a data object
+     * (wrapped in an ItemBoundable)
+     */
+    void addChildBoundable(Boundable* childBoundable) {
+        assert(bounds == nullptr);
+        childBoundables.push_back(childBoundable);
+    }
+
+    bool isLeaf() const override {
+        return false;
+    }
+
+protected:
+
+    virtual void* computeBounds() const = 0;
+
+    mutable void* bounds;
+};
+
+
+} // namespace geos::index::strtree
+} // namespace geos::index
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+