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

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

@@ -0,0 +1,324 @@
+/**********************************************************************
+ *
+ * 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/AbstractNode.h> // for inlines
+
+#include <vector>
+#include <list>
+#include <memory> // for unique_ptr
+#include <cassert> // for inlines
+#include <algorithm>
+
+// Forward declarations
+namespace geos {
+namespace index {
+class ItemVisitor;
+namespace strtree {
+class Boundable;
+class AbstractNode;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos::index
+namespace strtree { // geos::index::strtree
+
+/// A list of boundables. TODO: use a list
+typedef std::vector<Boundable*> BoundableList;
+
+/// list contains boundables or lists of boundables. The lists are owned by
+/// this class, the plain boundables are held by reference only.
+class ItemsList;
+
+class ItemsListItem {
+public:
+    enum type {
+        item_is_geometry,
+        item_is_list
+    };
+
+    ItemsListItem(void* item_)
+        : t(item_is_geometry)
+    {
+        item.g = item_;
+    }
+    ItemsListItem(ItemsList* item_)
+        : t(item_is_list)
+    {
+        item.l = item_;
+    }
+
+    type
+    get_type() const
+    {
+        return t;
+    }
+
+    void*
+    get_geometry() const
+    {
+        assert(t == item_is_geometry);
+        return item.g;
+    }
+    ItemsList*
+    get_itemslist() const
+    {
+        assert(t == item_is_list);
+        return item.l;
+    }
+
+    type t;
+    union {
+        void* g;
+        ItemsList* l;
+    } item;
+};
+
+class ItemsList : public std::vector<ItemsListItem> {
+private:
+    typedef std::vector<ItemsListItem> base_type;
+
+    static void
+    delete_item(ItemsListItem& item)
+    {
+        if(ItemsListItem::item_is_list == item.t) {
+            delete item.item.l;
+        }
+    }
+
+public:
+    ~ItemsList()
+    {
+        std::for_each(begin(), end(), &ItemsList::delete_item);
+    }
+
+    // lists of items need to be deleted in the end
+    void
+    push_back(void* item)
+    {
+        this->base_type::push_back(ItemsListItem(item));
+    }
+
+    // lists of items need to be deleted in the end
+    void
+    push_back_owned(ItemsList* itemList)
+    {
+        this->base_type::push_back(ItemsListItem(itemList));
+    }
+};
+
+/** \brief
+ * Base class for STRtree and SIRtree.
+ *
+ * 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.
+ *
+ * This implementation is based on Boundables rather than just AbstractNodes,
+ * because the STR algorithm operates on both nodes and
+ * data, both of which are treated here as Boundables.
+ *
+ */
+class GEOS_DLL AbstractSTRtree {
+
+private:
+    bool built;
+    BoundableList* itemBoundables;
+
+    /**
+     * Creates the levels higher than the given level
+     *
+     * @param boundablesOfALevel
+     *            the level to build on
+     * @param level
+     *            the level of the Boundables, or -1 if the boundables are item
+     *            boundables (that is, below level 0)
+     * @return the root, which may be a ParentNode or a LeafNode
+     */
+    virtual AbstractNode* createHigherLevels(
+        BoundableList* boundablesOfALevel,
+        int level);
+
+    std::unique_ptr<BoundableList> sortBoundablesY(const BoundableList* input);
+
+    bool remove(const void* searchBounds, AbstractNode& node, void* item);
+    bool removeItem(AbstractNode& node, void* item);
+
+    ItemsList* itemsTree(AbstractNode* node);
+
+    AbstractSTRtree(const AbstractSTRtree&) = delete;
+    AbstractSTRtree& operator=(const AbstractSTRtree&) = delete;
+
+protected:
+
+    /** \brief
+     * A test for intersection between two bounds, necessary because
+     * subclasses of AbstractSTRtree have different implementations of
+     * bounds.
+     */
+    class GEOS_DLL IntersectsOp {
+    public:
+        /**
+         * For STRtrees, the bounds will be Envelopes; for
+         * SIRtrees, Intervals; for other subclasses of
+         * AbstractSTRtree, some other class.
+         * @param aBounds the bounds of one spatial object
+         * @param bBounds the bounds of another spatial object
+         * @return whether the two bounds intersect
+         */
+        virtual bool intersects(const void* aBounds,
+                                const void* bBounds) = 0;
+
+        virtual
+        ~IntersectsOp() {}
+    };
+
+    AbstractNode* root;
+
+    std::vector <AbstractNode*>* nodes;
+
+    // Ownership to caller (TODO: return by unique_ptr)
+    virtual AbstractNode* createNode(int level) = 0;
+
+    /** \brief
+     * Sorts the childBoundables then divides them into groups of size M, where
+     * M is the node capacity.
+     */
+    virtual std::unique_ptr<BoundableList> createParentBoundables(
+        BoundableList* childBoundables, int newLevel);
+
+    virtual AbstractNode*
+    lastNode(BoundableList* nodeList)
+    {
+        assert(!nodeList->empty());
+        // Cast from Boundable to AbstractNode
+        return static_cast<AbstractNode*>(nodeList->back());
+    }
+
+    virtual AbstractNode*
+    getRoot()
+    {
+        assert(built);
+        return root;
+    }
+
+    ///  Also builds the tree, if necessary.
+    virtual void insert(const void* bounds, void* item);
+
+    ///  Also builds the tree, if necessary.
+    void query(const void* searchBounds, std::vector<void*>& foundItems);
+
+    ///  Also builds the tree, if necessary.
+    void query(const void* searchBounds, ItemVisitor& visitor);
+
+    void query(const void* searchBounds, const AbstractNode& node, ItemVisitor& visitor);
+
+    ///  Also builds the tree, if necessary.
+    bool remove(const void* itemEnv, void* item);
+
+    std::unique_ptr<BoundableList> boundablesAtLevel(int level);
+
+    // @@ should be size_t, probably
+    std::size_t nodeCapacity;
+
+    /**
+     * @return a test for intersection between two bounds,
+     * necessary because subclasses
+     * of AbstractSTRtree have different implementations of bounds.
+     * @see IntersectsOp
+     */
+    virtual IntersectsOp* getIntersectsOp() = 0;
+
+
+public:
+
+    /** \brief
+     * Constructs an AbstractSTRtree with the specified maximum number of child
+     * nodes that a node may have.
+     */
+    AbstractSTRtree(std::size_t newNodeCapacity)
+        :
+        built(false),
+        itemBoundables(new BoundableList()),
+        nodes(new std::vector<AbstractNode *>()),
+        nodeCapacity(newNodeCapacity)
+    {
+        assert(newNodeCapacity > 1);
+    }
+
+    virtual ~AbstractSTRtree();
+
+    /** \brief
+     * Creates parent nodes, grandparent nodes, and so forth up to the root
+     * node, for the data that has been inserted into the tree.
+     *
+     * Can only be
+     * called once, and thus can be called only after all of the data has been
+     * inserted into the tree.
+     */
+    virtual void build();
+
+    /** \brief
+     * Returns the maximum number of child nodes that a node may have.
+     */
+    virtual std::size_t
+    getNodeCapacity()
+    {
+        return nodeCapacity;
+    }
+
+    virtual void query(const void* searchBounds, const AbstractNode* node, std::vector<void*>* matches);
+
+    /**
+     * Iterate over all items added thus far.  Explicitly does not build
+     * the tree.
+     */
+    void iterate(ItemVisitor& visitor);
+
+
+    /**
+     * @param level -1 to get items
+     * @param top an AbstractNode
+     * @param boundables a BoundableList
+     */
+    virtual void boundablesAtLevel(int level, AbstractNode* top,
+                                   BoundableList* boundables);
+
+    /** \brief
+     * Gets a tree structure (as a nested list) corresponding to the structure
+     * of the items and nodes in this tree.
+     *
+     * The returned Lists contain either Object items, or Lists which
+     * correspond to subtrees of the tree Subtrees which do not contain
+     * any items are not included.
+     *
+     * Builds the tree if necessary.
+     *
+     * @note The caller is responsible for releasing the list
+     *
+     * @return a List of items and/or Lists
+     */
+    ItemsList* itemsTree();
+};
+
+
+} // namespace geos::index::strtree
+} // namespace geos::index
+} // namespace geos
+

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

@@ -0,0 +1,49 @@
+/**********************************************************************
+ *
+ * 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>
+
+namespace geos {
+namespace index { // geos::index
+namespace strtree { // geos::index::strtree
+
+/// A spatial object in an AbstractSTRtree.
+class GEOS_DLL Boundable {
+public:
+    /**
+     * 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
+     */
+    virtual const void* getBounds() const = 0;
+
+    virtual bool isLeaf() const = 0;
+    virtual ~Boundable() {}
+};
+
+
+} // namespace geos::index::strtree
+} // namespace geos::index
+} // namespace geos
+

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

@@ -0,0 +1,122 @@
+/**********************************************************************
+ *
+ * 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/BoundablePair.java (JTS-1.14)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/index/strtree/Boundable.h>
+#include <geos/index/strtree/ItemDistance.h>
+#include <queue>
+
+namespace geos {
+namespace index {
+namespace strtree {
+
+/**
+ * @brief A pair of [Boundables](@ref Boundable), whose
+ *        leaf items support a distance metric between them.
+ *
+ * Used to compute the distance between the members,
+ * and to expand a member relative to the other
+ * in order to produce new branches of the
+ * Branch-and-Bound evaluation tree.
+ * Provides an ordering based on the distance between the members,
+ * which allows building a priority queue by minimum distance.
+ *
+ * @author Martin Davis
+ *
+ */
+class BoundablePair {
+private:
+    const Boundable* boundable1;
+    const Boundable* boundable2;
+    ItemDistance* itemDistance;
+    double mDistance;
+
+public:
+    struct BoundablePairQueueCompare {
+        bool
+        operator()(const BoundablePair* a, const BoundablePair* b)
+        {
+            return a->getDistance() > b->getDistance();
+        }
+    };
+
+    typedef std::priority_queue<BoundablePair*, std::vector<BoundablePair*>, BoundablePairQueueCompare> BoundablePairQueue;
+    BoundablePair(const Boundable* boundable1, const Boundable* boundable2, ItemDistance* itemDistance);
+
+    /**
+     * Gets one of the member {@link Boundable}s in the pair
+     * (indexed by [0, 1]).
+     *
+     * @param i the index of the member to return (0 or 1)
+     * @return the chosen member
+     */
+    const Boundable* getBoundable(int i) const;
+
+    /** \brief
+     * Computes the distance between the {@link Boundable}s in this pair.
+     * The boundables 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 ItemBoundable* item1, const ItemBoundable* item2).
+     *
+     * @return the distance between the items
+     */
+    double distance() const;
+
+    /** \brief
+     * Gets the minimum possible distance between the Boundables 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();
+
+    static bool isComposite(const Boundable* item);
+
+    static double area(const Boundable* b);
+
+    void expandToQueue(BoundablePairQueue&, double minDistance);
+    void expand(const Boundable* bndComposite, const Boundable* bndOther, bool isFlipped, BoundablePairQueue& priQ,
+                double minDistance);
+};
+
+}
+}
+}

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

@@ -0,0 +1,33 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2019 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/geom/Envelope.h>
+
+namespace geos {
+namespace index { // geos::index
+namespace strtree { // geos::index::strtree
+
+class GEOS_DLL EnvelopeUtil {
+public:
+    // EnvelopeUtil(const void* newBounds, void* newItem);
+    // ~EnvelopeUtil() override = default;
+
+    static double maximumDistance(const geom::Envelope* env1, const geom::Envelope* env2);
+
+};
+
+} // namespace geos::index::strtree
+} // namespace geos::index
+} // namespace geos

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

@@ -0,0 +1,44 @@
+/**********************************************************************
+ *
+ * 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/GeometryItemDistance.java (JTS-1.14)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Geometry.h>
+#include <geos/index/strtree/ItemDistance.h>
+
+namespace geos {
+namespace index {
+namespace strtree {
+class GEOS_DLL GeometryItemDistance : public ItemDistance {
+public:
+    /**
+     * Computes the distance between two {@link Geometry} items,
+     * using the {@link Geometry#distance(Geometry)} method.
+     *
+     * @param item1 an item which is a Geometry
+     * @param item2 an item which is a Geometry
+     * @return the distance between the geometries
+     * @throws ClassCastException if either item is not a Geometry
+     */
+    double distance(const ItemBoundable* item1, const ItemBoundable* item2) override;
+};
+
+}
+}
+}
+

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

@@ -0,0 +1,60 @@
+/**********************************************************************
+ *
+ * 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 <algorithm>
+#include <cassert>
+#include <cmath>
+
+namespace geos {
+namespace index { // geos::index
+namespace strtree { // geos::index::strtree
+
+/// A contiguous portion of 1D-space. Used internally by SIRtree.
+//
+/// @see SIRtree
+///
+class GEOS_DLL Interval {
+public:
+    Interval(double newMin, double newMax) : imin(newMin), imax(newMax) {
+        assert(std::isnan(newMin) || std::isnan(newMax) || imin <= imax);
+    }
+
+    double getMin() const { return imin; }
+    double getMax() const { return imax; }
+    double getWidth() const { return imax - imin; }
+    double getCentre() const { return (imin + imax) / 2; }
+    Interval* expandToInclude(const Interval* other) {
+        imax = std::max(imax, other->imax);
+        imin = std::min(imin, other->imin);
+        return this;
+    }
+    bool intersects(const Interval* other) const {
+        return !(other->imin > imax || other->imax < imin);
+    }
+    bool equals(const Interval* other) const {
+        return imin == other->imin && imax == other->imax;
+    }
+private:
+    double imin;
+    double imax;
+};
+
+
+} // namespace geos::index::strtree
+} // namespace geos::index
+} // namespace geos
+

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

@@ -0,0 +1,59 @@
+/**********************************************************************
+ *
+ * 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/Boundable.h> // for inheritance
+
+namespace geos {
+namespace index { // geos::index
+namespace strtree { // geos::index::strtree
+
+/**
+ * \brief
+ * Boundable wrapper for a non-Boundable spatial object.
+ * Used internally by AbstractSTRtree.
+ *
+ * \todo TODO: It's unclear who takes ownership of passed newBounds and newItem objects.
+ */
+class GEOS_DLL ItemBoundable: public Boundable {
+public:
+
+    ItemBoundable(const void* newBounds, void* newItem) : bounds(newBounds), item(newItem) {}
+    ~ItemBoundable() override = default;
+
+    bool isLeaf() const override {
+        return true;
+    }
+
+    const void* getBounds() const override {
+        return bounds;
+    }
+
+    void* getItem() const {
+        return item;
+    }
+
+private:
+
+    const void* bounds;
+    void* item;
+};
+
+} // namespace geos::index::strtree
+} // namespace geos::index
+} // namespace geos
+