@cpp.js/package-geos 1.0.0-beta.20

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/index/VertexSequencePackedRtree.h

@@ -0,0 +1,153 @@
+/**********************************************************************
+ *
+ * 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 <vector>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class CoordinateSequence;
+class Envelope;
+}
+}
+
+using geos::geom::Coordinate;
+using geos::geom::CoordinateSequence;
+using geos::geom::Envelope;
+
+
+namespace geos {
+namespace index {
+
+
+/**
+ * A semi-static spatial index for points which occur
+ * in a spatially-coherent sequence.
+ * In particular, this is suitable for indexing the vertices
+ * of a geos::geom::LineString or geos::geom::Polygon ring.
+ *
+ * The index is constructed in a batch fashion on a given sequence of coordinates.
+ * Coordinates can be removed via the remove() method.
+ *
+ * Note that this index queries only the individual points
+ * of the input coordinate sequence,
+ * **not** any line segments which might be lie between them.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL VertexSequencePackedRtree {
+
+private:
+
+
+    /**
+    * Number of items/nodes in a parent node.
+    * Determined empirically.  Performance is not too sensitive to this.
+    */
+    static constexpr std::size_t NODE_CAPACITY = 16;
+
+    // Members
+    const CoordinateSequence& items;
+    std::vector<bool> removedItems;
+    std::vector<std::size_t> levelOffset;
+    std::size_t nodeCapacity = NODE_CAPACITY;
+    std::vector<Envelope> bounds;
+
+
+    // Methods
+
+    void build();
+
+    /**
+    * Computes the level offsets.
+    * This is the position in the <tt>bounds</tt> array of each level.
+    *
+    * The levelOffsets array includes a sentinel value of offset[0] = 0.
+    * The top level is always of size 1,
+    * and so also indicates the total number of bounds.
+    *
+    * @return the level offsets
+    */
+    std::vector<std::size_t> computeLevelOffsets();
+
+    static std::size_t ceilDivisor(std::size_t num, std::size_t denom);
+    static std::size_t clampMax(std::size_t x, std::size_t max);
+
+    std::size_t levelNodeCount(std::size_t numNodes);
+
+    std::vector<Envelope> createBounds();
+
+    void fillItemBounds(std::vector<Envelope>& bounds);
+    void fillLevelBounds(std::size_t lvl, std::vector<Envelope>& bounds);
+
+    static Envelope computeNodeEnvelope(const std::vector<Envelope>& bounds,
+        std::size_t start, std::size_t end);
+    static Envelope computeItemEnvelope(const CoordinateSequence& items,
+        std::size_t start, std::size_t end);
+
+    void queryNode(const Envelope& queryEnv,
+        std::size_t level, std::size_t nodeIndex,
+        std::vector<std::size_t>& result) const;
+    void queryNodeRange(const Envelope& queryEnv,
+        std::size_t level, std::size_t nodeStartIndex,
+        std::vector<std::size_t>& result) const;
+    void queryItemRange(const Envelope& queryEnv, std::size_t itemIndex,
+        std::vector<std::size_t>& result) const;
+
+    std::size_t levelSize(std::size_t level) const;
+    bool isNodeEmpty(std::size_t level, std::size_t index);
+    bool isItemsNodeEmpty(std::size_t nodeIndex);
+
+
+public:
+
+    /**
+    * Creates a new tree over the given sequence of coordinates.
+    * The sequence should be spatially coherent to provide query performance.
+    *
+    * @param pts a sequence of points
+    */
+    VertexSequencePackedRtree(const CoordinateSequence& pts);
+
+    std::vector<Envelope> getBounds();
+
+    /**
+    * Removes the input item at the given index from the spatial index.
+    *
+    * @param index the index of the item in the input
+    */
+    void remove(std::size_t index);
+
+    /**
+    * Queries the index to find all items which intersect an extent.
+    * The query result is a list of the indices of input coordinates
+    * which intersect the extent.
+    *
+    * @param queryEnv the query extent
+    * @param result vector to fill with results
+    */
+    void query(const Envelope& queryEnv, std::vector<std::size_t>& result) const;
+
+};
+
+
+
+} // namespace geos.index
+} // namespace geos
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/index/bintree/Bintree.h

@@ -0,0 +1,129 @@
+/**********************************************************************
+ *
+ * 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 <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
+
+// Forward declarations
+namespace geos {
+namespace index {
+namespace bintree {
+class Interval;
+class Root;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos::index
+namespace bintree { // geos::index::bintree
+
+/** \brief
+ * A BinTree (or "Binary Interval Tree") is a 1-dimensional version of a quadtree.
+ *
+ * It indexes 1-dimensional intervals (which of course may be the projection
+ * of 2-D objects on an axis). It supports range searching (where the range
+ * may be a single point).
+ *
+ * This implementation does not require specifying the extent of the inserted
+ * items beforehand. It will automatically expand to accomodate any extent
+ * of dataset.
+ *
+ * This index is different to the "Interval Tree of Edelsbrunner"
+ * or the "Segment Tree of Bentley".
+ */
+class GEOS_DLL Bintree {
+
+public:
+
+    /** \brief
+     * Ensure that the Interval for the inserted item has non-zero extents.
+     *
+     * Use the current minExtent to pad it, if necessary.
+     *
+     * @note In GEOS this function always return a newly allocated object
+     *       with ownership transferred to caller. TODO: change this ?
+     *
+     * @param itemInterval source interval, ownership left to caller, no references hold
+     * @param minExtent minimal extent
+     */
+    static Interval* ensureExtent(const Interval* itemInterval,
+                                  double minExtent);
+
+    Bintree();
+
+    ~Bintree();
+
+    int depth();
+
+    int size();
+
+    int nodeSize();
+
+    /// @param itemInterval
+    ///     Ownership left to caller, NO reference hold by this class.
+    ///
+    /// @param item
+    ///     Ownership left to caller, reference kept by this class.
+    ///
+    void insert(Interval* itemInterval, void* item);
+
+    std::vector<void*>* iterator();
+
+    std::vector<void*>* query(double x);
+
+    std::vector<void*>* query(Interval* interval);
+
+    void query(Interval* interval,
+               std::vector<void*>* foundItems);
+
+private:
+
+    std::vector<Interval*>newIntervals;
+
+    Root* root;
+
+    /**
+     *  Statistics
+     *
+     * minExtent is the minimum extent of all items
+     * inserted into the tree so far. It is used as a heuristic value
+     * to construct non-zero extents for features with zero 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;
+
+    void collectStats(Interval* interval);
+
+    Bintree(const Bintree&) = delete;
+    Bintree& operator=(const Bintree&) = delete;
+};
+
+} // namespace geos::index::bintree
+} // namespace geos::index
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/index/bintree/Interval.h

@@ -0,0 +1,61 @@
+/**********************************************************************
+ *
+ * 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 bintree { // geos::index::bintree
+
+/// Represents an (1-dimensional) closed interval on the Real number line.
+class GEOS_DLL Interval {
+
+public:
+
+    double min, max;
+
+    Interval();
+
+    Interval(double nmin, double nmax);
+
+    /// TODO: drop this, rely on copy ctor
+    Interval(const Interval* interval);
+
+    void init(double nmin, double nmax);
+
+    double getMin() const;
+
+    double getMax() const;
+
+    double getWidth() const;
+
+    void expandToInclude(Interval* interval);
+
+    bool overlaps(const Interval* interval) const;
+
+    bool overlaps(double nmin, double nmax) const;
+
+    bool contains(const Interval* interval) const;
+
+    bool contains(double nmin, double nmax) const;
+
+    bool contains(double p) const;
+};
+
+} // namespace geos::index::bintree
+} // namespace geos::index
+} // namespace geos
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/index/bintree/Key.h

@@ -0,0 +1,71 @@
+/**********************************************************************
+ *
+ * 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>
+
+// Forward declarations
+namespace geos {
+namespace index {
+namespace bintree {
+class Interval;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos::index
+namespace bintree { // geos::index::bintree
+
+/** \brief
+ * A Key is a unique identifier for a node in a tree.
+ *
+ * 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:
+
+    static int computeLevel(Interval* newInterval);
+
+    Key(Interval* newInterval);
+
+    ~Key();
+
+    double getPoint();
+
+    int getLevel();
+
+    Interval* getInterval();
+
+    void computeKey(Interval* itemInterval);
+
+private:
+
+    // the fields which make up the key
+    double pt;
+    int level;
+
+    // auxiliary data which is derived from the key for use in computation
+    Interval* interval;
+
+    void computeInterval(int level, Interval* itemInterval);
+};
+
+} // namespace geos::index::bintree
+} // namespace geos::index
+} // namespace geos
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/index/bintree/Node.h

@@ -0,0 +1,74 @@
+/**********************************************************************
+ *
+ * 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/bintree/NodeBase.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace index {
+namespace bintree {
+class Interval;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos::index
+namespace bintree { // geos::index::bintree
+
+/// A node of a Bintree.
+class GEOS_DLL Node: public NodeBase {
+
+public:
+
+    static Node* createNode(Interval* itemInterval);
+
+    static Node* createExpanded(Node* node, Interval* addInterval);
+
+    Node(Interval* newInterval, int newLevel);
+
+    ~Node() override;
+
+    Interval* getInterval();
+
+    Node* getNode(Interval* searchInterval);
+
+    NodeBase* find(Interval* searchInterval);
+
+    void insert(Node* node);
+
+private:
+
+    Interval* interval;
+
+    double centre;
+
+    int level;
+
+    Node* getSubnode(int index);
+
+    Node* createSubnode(int index);
+
+protected:
+
+    bool isSearchMatch(Interval* itemInterval) override;
+};
+
+} // namespace geos::index::bintree
+} // namespace geos::index
+} // namespace geos
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/index/bintree/NodeBase.h

@@ -0,0 +1,83 @@
+/**********************************************************************
+ *
+ * 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 <vector>
+
+// Forward declarations
+namespace geos {
+namespace index {
+namespace bintree {
+class Node;
+class Interval;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos::index
+namespace bintree { // geos::index::bintree
+
+/// The base class for nodes in a Bintree.
+class GEOS_DLL NodeBase {
+
+public:
+
+    static int getSubnodeIndex(Interval* interval, double centre);
+
+    NodeBase();
+
+    virtual ~NodeBase();
+
+    virtual std::vector<void*>* getItems();
+
+    virtual void add(void* item);
+
+    virtual std::vector<void*>* addAllItems(std::vector<void*>* newItems);
+
+    virtual std::vector<void*>* addAllItemsFromOverlapping(Interval* interval,
+            std::vector<void*>* resultItems);
+
+    virtual int depth();
+
+    virtual int size();
+
+    virtual int nodeSize();
+
+protected:
+
+    std::vector<void*>* items;
+
+    /**
+     * subnodes are numbered as follows:
+     *
+     *  0 | 1
+     */
+    Node* subnode[2];
+
+    virtual bool isSearchMatch(Interval* interval) = 0;
+
+private:
+
+    NodeBase(const NodeBase&) = delete;
+    NodeBase& operator=(const NodeBase&) = delete;
+
+};
+
+} // namespace geos::index::bintree
+} // namespace geos::index
+} // namespace geos
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/index/bintree/Root.h

@@ -0,0 +1,77 @@
+/**********************************************************************
+ *
+ * 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/bintree/NodeBase.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace index {
+namespace bintree {
+class Interval;
+class Node;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos::index
+namespace bintree { // geos::index::bintree
+
+/** \brief
+ * The root node of a single Bintree.
+ *
+ * It is centred at the origin,
+ * and does not have a defined extent.
+ */
+class GEOS_DLL Root: public NodeBase {
+
+private:
+
+    // the singleton root node is centred at the origin.
+    static double origin;
+
+    void insertContained(Node* tree,
+                         Interval* itemInterval,
+                         void* item);
+
+public:
+
+    Root() {}
+
+    ~Root() override {}
+
+    /// @param itemInterval
+    ///     Ownership left to caller, references kept in this class.
+    ///
+    /// @param item
+    ///     Ownership left to caller, references kept in this class.
+    ///
+    void insert(Interval* itemInterval, void* item);
+
+protected:
+
+    bool
+    isSearchMatch(Interval* /*interval*/) override
+    {
+        return true;
+    }
+};
+
+} // namespace geos::index::bintree
+} // namespace geos::index
+} // namespace geos
+