@cpp.js/package-geos 1.0.0-beta.22 → 1.0.0

package/dist/prebuilt/Android-x86_64/include/geos/index/kdtree/KdTree.h

@@ -0,0 +1,191 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 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/export.h>
+#include <geos/geom/Envelope.h>
+#include <geos/index/kdtree/KdNodeVisitor.h>
+#include <geos/index/kdtree/KdNode.h>
+
+#include <memory>
+#include <vector>
+#include <string>
+#include <deque>
+
+#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 kdtree { // geos::index::kdtree
+
+/**
+ * An implementation of a 2-D KD-Tree. KD-trees provide fast range searching on
+ * point data.
+ * <p>
+ * This implementation supports detecting and snapping points which are closer
+ * than a given distance tolerance.
+ * If the same point (up to tolerance) is inserted
+ * more than once, it is snapped to the existing node.
+ * In other words, if a point is inserted which lies within the tolerance of a node already in the index,
+ * it is snapped to that node.
+ * When a point is snapped to a node then a new node is not created but the count of the existing node
+ * is incremented.
+ * If more than one node in the tree is within tolerance of an inserted point,
+ * the closest and then lowest node is snapped to.
+ *
+ * @author David Skea
+ * @author Martin Davis
+ */
+class GEOS_DLL KdTree {
+
+private:
+
+    std::deque<KdNode> nodeQue;
+    KdNode *root;
+    std::size_t numberOfNodes;
+    double tolerance;
+
+    KdNode* findBestMatchNode(const geom::Coordinate& p);
+    KdNode* insertExact(const geom::Coordinate& p, void* data);
+
+    void queryNode(KdNode* currentNode, const geom::Envelope& queryEnv, bool odd, KdNodeVisitor& visitor);
+    KdNode* queryNodePoint(KdNode* currentNode, const geom::Coordinate& queryPt, bool odd);
+
+    /**
+    * Create a node on a locally managed deque to allow easy
+    * disposal and hopefully faster allocation as well.
+    */
+    KdNode* createNode(const geom::Coordinate& p, void* data);
+
+
+    /**
+    * BestMatchVisitor used to query the tree for a match
+    * within tolerance.
+    */
+    class BestMatchVisitor : public KdNodeVisitor {
+    public:
+        BestMatchVisitor(const geom::Coordinate& p_p, double p_tolerance);
+        geom::Envelope queryEnvelope();
+        KdNode* getNode();
+        void visit(KdNode* node) override;
+
+    private:
+        // Members
+        double tolerance;
+        KdNode* matchNode;
+        double matchDist;
+        const geom::Coordinate& p;
+        // Declare type as noncopyable
+        BestMatchVisitor(const BestMatchVisitor& other);
+        BestMatchVisitor& operator=(const BestMatchVisitor& rhs);
+    };
+
+    /**
+    * AccumulatingVisitor used to query the tree and get list
+    * of matching nodes.
+    */
+    class AccumulatingVisitor : public KdNodeVisitor {
+    public:
+        AccumulatingVisitor(std::vector<KdNode*>& p_nodeList) :
+            nodeList(p_nodeList) {};
+        void visit(KdNode* node) override { nodeList.push_back(node); }
+
+    private:
+        // Members
+        std::vector<KdNode*>& nodeList;
+        // Declare type as noncopyable
+        AccumulatingVisitor(const AccumulatingVisitor& other);
+        AccumulatingVisitor& operator=(const AccumulatingVisitor& rhs);
+    };
+
+
+
+public:
+
+    /**
+    * Converts a collection of {@link KdNode}s to an vector of {@link geom::Coordinate}s.
+    *
+    * @param kdnodes a collection of nodes
+    * @return an vector of the coordinates represented by the nodes
+    */
+    static std::unique_ptr<std::vector<geom::Coordinate>> toCoordinates(std::vector<KdNode*>& kdnodes);
+
+    /**
+    * Converts a collection of {@link KdNode}s
+    * to an vector of {@link geom::Coordinate}s,
+    * specifying whether repeated nodes should be represented
+    * by multiple coordinates.
+    *
+    * @param kdnodes a collection of nodes
+    * @param includeRepeated true if repeated nodes should
+    *   be included multiple times
+    * @return an vector of the coordinates represented by the nodes
+    */
+    static std::unique_ptr<std::vector<geom::Coordinate>> toCoordinates(std::vector<KdNode*>& kdnodes, bool includeRepeated);
+
+    KdTree() :
+        root(nullptr),
+        numberOfNodes(0),
+        tolerance(0.0)
+        {};
+
+    KdTree(double p_tolerance) :
+        root(nullptr),
+        numberOfNodes(0),
+        tolerance(p_tolerance)
+        {};
+
+    bool isEmpty() { return root == nullptr; }
+
+    /**
+    * Inserts a new point in the kd-tree.
+    */
+    KdNode* insert(const geom::Coordinate& p);
+    KdNode* insert(const geom::Coordinate& p, void* data);
+
+    /**
+    * Performs a range search of the points in the index and visits all nodes found.
+    */
+    void query(const geom::Envelope& queryEnv, KdNodeVisitor& visitor);
+
+    /**
+    * Performs a range search of the points in the index.
+    */
+    std::unique_ptr<std::vector<KdNode*>> query(const geom::Envelope& queryEnv);
+
+    /**
+    * Performs a range search of the points in the index.
+    */
+    void query(const geom::Envelope& queryEnv, std::vector<KdNode*>& result);
+
+    /**
+    * Searches for a given point in the index and returns its node if found.
+    */
+    KdNode* query(const geom::Coordinate& queryPt);
+
+};
+
+} // namespace geos::index::kdtree
+} // namespace geos::index
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/include/geos/index/quadtree/IntervalSize.h

@@ -0,0 +1,62 @@
+/**********************************************************************
+ *
+ * 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/IntervalSize.java rev 1.7 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+namespace geos {
+namespace index { // geos::index
+namespace quadtree { // geos::index::quadtree
+
+/**
+ * \class IntervalSize
+ *
+ * \brief
+ * Provides a test for whether an interval is
+ * so small it should be considered as zero for the purposes of
+ * inserting it into a binary tree.
+ *
+ * The reason this check is necessary is that round-off error can
+ * cause the algorithm used to subdivide an interval to fail, by
+ * computing a midpoint value which does not lie strictly between the
+ * endpoints.
+ */
+class GEOS_DLL IntervalSize {
+public:
+    /**
+     * This value is chosen to be a few powers of 2 less than the
+     * number of bits available in the double representation (i.e. 53).
+     * This should allow enough extra precision for simple computations
+     * to be correct, at least for comparison purposes.
+     */
+    static const int MIN_BINARY_EXPONENT = -50;
+
+    /**
+     * Computes whether the interval [min, max] is effectively zero width.
+     * I.e. the width of the interval is so much less than the
+     * location of the interval that the midpoint of the interval
+     * cannot be represented precisely.
+     */
+    static bool isZeroWidth(double min, double max);
+};
+
+} // namespace geos::index::quadtree
+} // namespace geos::index
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/index/quadtree/Key.h

@@ -0,0 +1,87 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2009  Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions 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/Key.java rev 1.8 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h> // for composition
+#include <geos/geom/Envelope.h> // for composition
+
+// Forward declarations
+// ...
+
+namespace geos {
+namespace index { // geos::index
+namespace quadtree { // geos::index::quadtree
+
+/**
+ * \brief
+ * A Key is a unique identifier for a node in a quadtree.
+ *
+ * It contains a lower-left point and a level number. The level number
+ * is the power of two for the size of the node envelope
+ */
+class GEOS_DLL Key {
+public:
+
+    // Doesn't touch the Envelope, might as well be const
+    static int computeQuadLevel(const geom::Envelope& env);
+
+    // Reference to argument won't be used after construction
+    Key(const geom::Envelope& itemEnv);
+
+    // used to be virtual, but I don't see subclasses...
+    ~Key() = default;
+
+    /// Returned object ownership retained by this class
+    const geom::Coordinate& getPoint() const;
+
+    int getLevel() const;
+
+    /// Returned object ownership retained by this class
+    const geom::Envelope& getEnvelope() const;
+
+    /// Returns newly allocated object (ownership transferred)
+    geom::Coordinate* getCentre() const;
+
+    /**
+     * return a square envelope containing the argument envelope,
+     * whose extent is a power of two and which is based at a power of 2
+     */
+    void computeKey(const geom::Envelope& itemEnv);
+
+private:
+    // the fields which make up the key
+
+    // Owned by this class
+    geom::Coordinate pt;
+
+    int level;
+
+    // auxiliary data which is derived from the key for use in computation
+    geom::Envelope env;
+
+    void computeKey(int level, const geom::Envelope& itemEnv);
+};
+
+} // namespace geos::index::quadtree
+} // namespace geos::index
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/index/quadtree/Node.h

@@ -0,0 +1,141 @@
+/**********************************************************************
+ *
+ * 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/Node.java rev 1.8 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/index/quadtree/NodeBase.h> // for inheritance
+#include <geos/geom/Coordinate.h> // for composition
+#include <geos/geom/Envelope.h> // for inline
+
+#include <string>
+#include <memory>
+
+#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 geos {
+namespace index { // geos::index
+namespace quadtree { // geos::index::quadtree
+
+/**
+ * \brief
+ * Represents a node of a Quadtree.
+ *
+ * Nodes contain items which have a spatial extent corresponding to
+ * the node's position in the quadtree.
+ *
+ */
+class GEOS_DLL Node: public NodeBase {
+
+private:
+
+    /// Owned by this class
+    std::unique_ptr<geom::Envelope> env;
+
+    geom::Coordinate centre;
+
+    int level;
+
+    /**
+     * Get the subquad for the index.
+     * If it doesn't exist, create it.
+     *
+     * Ownership of the returned object belongs to this class.
+     */
+    Node* getSubnode(int index);
+
+    std::unique_ptr<Node> createSubnode(int index);
+
+protected:
+
+    bool
+    isSearchMatch(const geom::Envelope& searchEnv) const override
+    {
+        return env->intersects(searchEnv);
+    }
+
+public:
+
+    // Create a node computing level from given envelope
+    static std::unique_ptr<Node> createNode(const geom::Envelope& env);
+
+    /// Create a node containing the given node and envelope
+    //
+    /// @param node if not null, will be inserted to the returned node
+    /// @param addEnv minimum envelope to use for the node
+    ///
+    static std::unique_ptr<Node> createExpanded(std::unique_ptr<Node> node,
+            const geom::Envelope& addEnv);
+
+    Node(std::unique_ptr<geom::Envelope> nenv, int nlevel)
+        :
+        env(std::move(nenv)),
+        centre((env->getMinX() + env->getMaxX()) / 2,
+               (env->getMinY() + env->getMaxY()) / 2),
+        level(nlevel)
+    {
+    }
+
+    ~Node() override {}
+
+    /// Return Envelope associated with this node
+    /// ownership retained by this object
+    geom::Envelope*
+    getEnvelope()
+    {
+        return env.get();
+    }
+
+    /** \brief
+     * Returns the subquad containing the envelope.
+     * Creates the subquad if
+     * it does not already exist.
+     */
+    Node* getNode(const geom::Envelope* searchEnv);
+
+    /** \brief
+     * Returns the smallest <i>existing</i>
+     * node containing the envelope.
+     */
+    NodeBase* find(const geom::Envelope* searchEnv);
+
+    void insertNode(std::unique_ptr<Node> node);
+
+    std::string toString() const override;
+
+};
+
+} // namespace geos::index::quadtree
+} // namespace geos::index
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/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
+