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

package/dist/prebuilt/Android-x86_64/include/geos/index/chain/MonotoneChainOverlapAction.h

@@ -0,0 +1,86 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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/chain/MonotoneChainOverlapAction.java rev. 1.6 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/LineSegment.h>
+
+
+// Forward declarations
+namespace geos {
+namespace index {
+namespace chain {
+class MonotoneChain;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos::index
+namespace chain { // geos::index::chain
+
+/** \brief
+ * The action for the internal iterator for performing
+ * overlap queries on a MonotoneChain.
+ */
+class GEOS_DLL MonotoneChainOverlapAction {
+
+protected:
+
+    geom::LineSegment overlapSeg1;
+
+    geom::LineSegment overlapSeg2;
+
+public:
+
+    MonotoneChainOverlapAction() {}
+
+    virtual
+    ~MonotoneChainOverlapAction() {}
+
+    /** \brief
+     * This function can be overridden if the original chains are needed.
+     *
+     * @param mc1 a MonotoneChain
+     * @param mc2 a MonotoneChain
+     * @param start1 the index of the start of the overlapping segment
+     *               from mc1
+     * @param start2 the index of the start of the overlapping segment
+     *               from mc2
+     */
+    virtual void overlap(const MonotoneChain& mc1, std::size_t start1,
+                         const MonotoneChain& mc2, std::size_t start2);
+
+    /** \brief
+     * This is a convenience function which can be overridden to
+     * obtain the actual line segments which overlap.
+     *
+     * **param** `seg1`
+     * **param** `seg2`
+     */
+    virtual void
+    overlap(const geom::LineSegment& /*seg1*/,
+            const geom::LineSegment& /*seg2*/) {}
+
+};
+
+} // namespace geos::index::chain
+} // namespace geos::index
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/index/chain/MonotoneChainSelectAction.h

@@ -0,0 +1,74 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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/chain/MonotoneChainSelectAction.java rev. 1.6 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/LineSegment.h> // composition
+#include <geos/geom/Envelope.h> // composition
+
+
+// Forward declarations
+namespace geos {
+namespace index {
+namespace chain {
+class MonotoneChain;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos::index
+namespace chain { // geos::index::chain
+
+/**
+ *  The action for the internal iterator for performing
+ *  Envelope select queries on a MonotoneChain
+ *
+ */
+class GEOS_DLL MonotoneChainSelectAction {
+
+protected:
+
+    geom::LineSegment selectedSegment;
+
+public:
+
+    MonotoneChainSelectAction() {}
+
+    virtual
+    ~MonotoneChainSelectAction() {}
+
+    /// This function can be overridden if the original chain is needed
+    virtual void select(const MonotoneChain& mc, std::size_t start);
+
+    /**
+     * This is a convenience function which can be overridden
+     * to obtain the actual line segment which is selected
+     *
+     * @param seg
+     */
+    virtual void select(const geom::LineSegment& seg) = 0;
+
+};
+
+
+} // namespace geos::index::chain
+} // namespace geos::index
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/index/intervalrtree/IntervalRTreeBranchNode.h

@@ -0,0 +1,53 @@
+/**********************************************************************
+ *
+ * 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/index/intervalrtree/IntervalRTreeNode.h> // inherited
+
+#include <algorithm>
+
+// forward declarations
+namespace geos {
+namespace index {
+class ItemVisitor;
+}
+}
+
+
+namespace geos {
+namespace index {
+namespace intervalrtree {
+
+class IntervalRTreeBranchNode : public IntervalRTreeNode {
+private:
+    const IntervalRTreeNode* node1;
+    const IntervalRTreeNode* node2;
+
+protected:
+public:
+    IntervalRTreeBranchNode(const IntervalRTreeNode* n1, const IntervalRTreeNode* n2)
+        :	IntervalRTreeNode(std::min(n1->getMin(), n2->getMin()), std::max(n1->getMax(), n2->getMax())),
+          node1(n1),
+          node2(n2)
+    { }
+
+    void query(double queryMin, double queryMax, index::ItemVisitor* visitor) const override;
+};
+
+} // geos::intervalrtree
+} // geos::index
+} // geos
+

package/dist/prebuilt/Android-x86_64/include/geos/index/intervalrtree/IntervalRTreeLeafNode.h

@@ -0,0 +1,58 @@
+/**********************************************************************
+ *
+ * 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/index/intervalrtree/IntervalRTreeNode.h> // inherited
+
+
+// forward declarations
+namespace geos {
+namespace index {
+class ItemVisitor;
+}
+}
+
+
+namespace geos {
+namespace index {
+namespace intervalrtree {
+
+class IntervalRTreeLeafNode : public IntervalRTreeNode {
+private:
+    /// externally owned
+    void* item;
+
+protected:
+public:
+
+    /// @param p_item externally owned
+    IntervalRTreeLeafNode(double p_min, double p_max, void* p_item)
+        :	IntervalRTreeNode(p_min, p_max),
+          item(p_item)
+    { }
+
+    ~IntervalRTreeLeafNode() override
+    {
+    }
+
+    void query(double queryMin, double queryMax, index::ItemVisitor* visitor) const override;
+
+};
+
+} // geos::intervalrtree
+} // geos::index
+} // geos
+

package/dist/prebuilt/Android-x86_64/include/geos/index/intervalrtree/IntervalRTreeNode.h

@@ -0,0 +1,105 @@
+/**********************************************************************
+ *
+ * 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/constants.h>
+#include <vector>
+#include <limits>
+
+// forward declarations
+namespace geos {
+namespace index {
+class ItemVisitor;
+}
+}
+
+
+namespace geos {
+namespace index {
+namespace intervalrtree {
+
+class IntervalRTreeNode {
+private:
+protected:
+    double min;
+    double max;
+
+    bool
+    intersects(double queryMin, double queryMax) const
+    {
+        if(min > queryMax || max < queryMin) {
+            return false;
+        }
+
+        return true;
+    }
+
+public:
+    typedef std::vector<const IntervalRTreeNode*> ConstVect;
+
+    IntervalRTreeNode()
+        :	min(DoubleInfinity),
+          max(DoubleNegInfinity)
+    { }
+
+    IntervalRTreeNode(double p_min, double p_max)
+        :	min(p_min),
+          max(p_max)
+    { }
+
+    virtual
+    ~IntervalRTreeNode()
+    { }
+
+    double
+    getMin() const
+    {
+        return min;
+    }
+
+    double
+    getMax() const
+    {
+        return max;
+    }
+
+    virtual void query(double queryMin, double queryMax, ItemVisitor* visitor) const = 0;
+
+    //std::string toString()
+    //{
+    //	return WKTWriter.toLineString(new Coordinate(min, 0), new Coordinate(max, 0));
+    //}
+
+
+    //class NodeComparator
+    //{
+    //public:
+    static bool
+    compare(const IntervalRTreeNode* n1, const IntervalRTreeNode* n2)
+    {
+        double mid1 = n1->getMin() + n1->getMax();
+        double mid2 = n2->getMin() + n2->getMax();
+
+        return mid1 > mid2;
+    }
+    //};
+
+};
+
+} // geos::index::intervalrtree
+} // geos::index
+} // geos
+

package/dist/prebuilt/Android-x86_64/include/geos/index/intervalrtree/SortedPackedIntervalRTree.h

@@ -0,0 +1,110 @@
+/**********************************************************************
+ *
+ * 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/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 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/Android-x86_64/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() { return p.x; }
+    double getY() { return p.y; }
+    const geom::Coordinate& getCoordinate() { return p; }
+    void* getData() { return data; }
+    KdNode* getLeft() { return left; }
+    KdNode* getRight() { return right; }
+    void increment() { count++; }
+    std::size_t getCount() { return count; }
+    bool isRepeated() { 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/Android-x86_64/include/geos/index/kdtree/KdNodeVisitor.h

@@ -0,0 +1,45 @@
+/**********************************************************************
+ *
+ * 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;
+
+
+};
+
+
+} // namespace geos::index::kdtree
+} // namespace geos::index
+} // namespace geos
+