@cpp.js/package-geos 1.0.0 → 2.0.0-beta.1

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

@@ -1,324 +0,0 @@
-/**********************************************************************
- *
- * 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-arm64-v8a/include/geos/index/strtree/Boundable.h

@@ -1,49 +0,0 @@
-/**********************************************************************
- *
- * 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-arm64-v8a/include/geos/index/strtree/BoundablePair.h

@@ -1,122 +0,0 @@
-/**********************************************************************
- *
- * 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-arm64-v8a/include/geos/index/strtree/EnvelopeUtil.h

@@ -1,33 +0,0 @@
-/**********************************************************************
- *
- * 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-arm64-v8a/include/geos/index/strtree/GeometryItemDistance.h

@@ -1,44 +0,0 @@
-/**********************************************************************
- *
- * 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-arm64-v8a/include/geos/index/strtree/Interval.h

@@ -1,60 +0,0 @@
-/**********************************************************************
- *
- * 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-arm64-v8a/include/geos/index/strtree/ItemBoundable.h

@@ -1,59 +0,0 @@
-/**********************************************************************
- *
- * 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
-