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

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/index/intervalrtree/SortedPackedIntervalRTree.h

@@ -0,0 +1,111 @@
+/**********************************************************************
+ *
+ * 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/intervalrtree/IntervalRTreeNode.h>
+#include <geos/index/intervalrtree/IntervalRTreeBranchNode.h>
+#include <geos/index/intervalrtree/IntervalRTreeLeafNode.h>
+#include <geos/util/UnsupportedOperationException.h>
+
+// forward declarations
+namespace geos {
+namespace index {
+class ItemVisitor;
+}
+}
+
+namespace geos {
+namespace index {
+namespace intervalrtree {
+
+/** \brief
+ * A static index on a set of 1-dimensional intervals,
+ * using an R-Tree packed based on the order of the interval midpoints.
+ *
+ * It supports range searching,
+ * where the range is an interval of the real line (which may be a single point).
+ * A common use is to index 1-dimensional intervals which
+ * are the projection of 2-D objects onto an axis of the coordinate system.
+ *
+ * This index structure is <i>static</i>
+ * - items cannot be added or removed once the first query has been made.
+ * The advantage of this characteristic is that the index performance
+ * can be optimized based on a fixed set of items.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL SortedPackedIntervalRTree { 
+private:
+    std::vector<IntervalRTreeLeafNode> leaves;
+    std::vector<IntervalRTreeBranchNode> branches;
+
+    /**
+    * If root is null that indicates
+    * that the tree has not yet been built,
+    * OR nothing has been added to the tree.
+    * In both cases, the tree is still open for insertions.
+    */
+    const IntervalRTreeNode* root = nullptr;
+    int level = 0;
+
+    void init();
+    void buildLevel(IntervalRTreeNode::ConstVect& src, IntervalRTreeNode::ConstVect& dest);
+    const IntervalRTreeNode* buildTree();
+
+protected:
+public:
+    SortedPackedIntervalRTree() {}
+
+    SortedPackedIntervalRTree(std::size_t initialCapacity)
+    {
+        leaves.reserve(initialCapacity);
+    }
+
+    /**
+     * Adds an item to the index which is associated with the given interval
+     *
+     * @param min the lower bound of the item interval
+     * @param max the upper bound of the item interval
+     * @param item the item to insert, ownership left to caller
+     *
+     * @throw IllegalStateException if the index has already been queried
+     */
+    void insert(double min, double max, void* item) {
+        if(root != nullptr) {
+            throw util::UnsupportedOperationException("Index cannot be added to once it has been queried");
+        }
+
+        leaves.emplace_back(min, max, item);
+    }
+
+    /**
+     * Search for intervals in the index which intersect the given closed interval
+     * and apply the visitor to them.
+     *
+     * @param min the lower bound of the query interval
+     * @param max the upper bound of the query interval
+     * @param visitor the visitor to pass any matched items to
+     */
+    void query(double min, double max, index::ItemVisitor* visitor);
+
+};
+
+} // geos::intervalrtree
+} // geos::index
+} // geos
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/index/kdtree/KdNode.h

@@ -0,0 +1,64 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************
+ *
+ * Last port: index/kdtree/Node.java rev 1.8 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Coordinate.h> // for composition
+
+namespace geos {
+namespace index { // geos::index
+namespace kdtree { // geos::index::kdtree
+
+/**
+ * A node of a {@link KdTree}, which represents one or more points in the same location.
+ */
+class GEOS_DLL KdNode {
+
+private:
+
+    geom::Coordinate p;
+    void* data;
+    KdNode* left;
+    KdNode* right;
+    std::size_t count;
+
+public:
+
+    KdNode(double p_x, double p_y, void* p_data);
+    KdNode(const geom::Coordinate& p_p, void* p_data);
+
+    double getX() const { return p.x; }
+    double getY() const { return p.y; }
+    const geom::Coordinate& getCoordinate() const { return p; }
+    void* getData() { return data; }
+    KdNode* getLeft() { return left; }
+    KdNode* getRight() { return right; }
+    void increment() { count++; }
+    std::size_t getCount() const { return count; }
+    bool isRepeated() const { return count > 1; }
+    void setLeft(KdNode* p_left) { left = p_left; }
+    void setRight(KdNode* p_right) { right = p_right; }
+
+};
+
+} // namespace geos::index::kdtree
+} // namespace geos::index
+} // namespace geos
+
+
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/index/kdtree/KdNodeVisitor.h

@@ -0,0 +1,46 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************
+ *
+ * Last port: index/kdtree/Node.java rev 1.8 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/index/kdtree/KdNode.h>
+
+namespace geos {
+namespace index { // geos::index
+namespace kdtree { // geos::index::kdtree
+
+class GEOS_DLL KdNodeVisitor {
+
+private:
+
+protected:
+
+public:
+
+    KdNodeVisitor() {};
+    virtual void visit(KdNode *node) = 0;
+
+    virtual ~KdNodeVisitor() = default;
+
+};
+
+
+} // namespace geos::index::kdtree
+} // namespace geos::index
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-x64-mt-release/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 <vector>
+#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);
+
+    static void queryNode(KdNode* currentNode, const geom::Envelope& queryEnv, bool odd, KdNodeVisitor& visitor);
+    static 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;
+
+        // Declare type as noncopyable
+        BestMatchVisitor(const BestMatchVisitor& other) = delete;
+        BestMatchVisitor& operator=(const BestMatchVisitor& rhs) = delete;
+
+    private:
+        // Members
+        double tolerance;
+        KdNode* matchNode;
+        double matchDist;
+        const geom::Coordinate& p;
+    };
+
+    /**
+    * AccumulatingVisitor used to query the tree and get list
+    * of matching nodes.
+    */
+    class AccumulatingVisitor : public KdNodeVisitor {
+    public:
+        explicit AccumulatingVisitor(std::vector<KdNode*>& p_nodeList) :
+            nodeList(p_nodeList) {};
+        void visit(KdNode* node) override { nodeList.push_back(node); }
+
+        // Declare type as noncopyable
+        AccumulatingVisitor(const AccumulatingVisitor& other) = delete;
+        AccumulatingVisitor& operator=(const AccumulatingVisitor& rhs) = delete;
+
+    private:
+        // Members
+        std::vector<KdNode*>& nodeList;
+    };
+
+
+
+public:
+
+    /**
+    * Converts a collection of {@link KdNode}s to a vector of {@link geom::Coordinate}s.
+    *
+    * @param kdNodes a collection of nodes
+    * @return a vector of the coordinates represented by the nodes
+    */
+    static std::vector<geom::Coordinate> toCoordinates(const std::vector<KdNode*>& kdNodes);
+
+    /**
+    * Converts a collection of {@link KdNode}s
+    * to a 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 a vector of the coordinates represented by the nodes
+    */
+    static std::vector<geom::Coordinate> toCoordinates(const std::vector<KdNode*>& kdNodes, bool includeRepeated);
+
+    KdTree() :
+        root(nullptr),
+        numberOfNodes(0),
+        tolerance(0.0)
+        {};
+
+    explicit 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::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/linuxmusl-x64-mt-release/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/linuxmusl-x64-mt-release/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/linuxmusl-x64-mt-release/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
+