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

package/dist/prebuilt/Android-arm64-v8a/include/geos/index/chain/MonotoneChain.h

@@ -0,0 +1,205 @@
+/**********************************************************************
+ *
+ * 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/MonotoneChain.java rev. 1.15 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/CoordinateSequence.h> // for inline
+#include <geos/geom/Envelope.h> // for inline
+#include <geos/geom/LineSegment.h> // for inline
+
+#include <memory> // for unique_ptr
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class LineSegment;
+class CoordinateSequence;
+}
+namespace index {
+namespace chain {
+class MonotoneChainSelectAction;
+class MonotoneChainOverlapAction;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos::index
+namespace chain { // geos::index::chain
+
+/** \brief
+ * Monotone Chains are a way of partitioning the segments of a linestring to
+ * allow for fast searching of intersections.
+ *
+ * They have the following properties:
+ *
+ * - the segments within a monotone chain never intersect each other
+ * - the envelope of any contiguous subset of the segments in a monotone
+ *   chain is equal to the envelope of the endpoints of the subset.
+ *
+ * Property 1 means that there is no need to test pairs of segments from
+ * within the same monotone chain for intersection.
+ * Property 2 allows an efficient binary search to be used to find the
+ * intersection points of two monotone chains.
+ *
+ * For many types of real-world data, these properties eliminate
+ * a large number of segment comparisons, producing substantial speed gains.
+ *
+ * One of the goals of this implementation of MonotoneChains is to be
+ * as space and time efficient as possible. One design choice that aids this
+ * is that a MonotoneChain is based on a subarray of a list of points.
+ * This means that new arrays of points (potentially very large) do not
+ * have to be allocated.
+ *
+ * MonotoneChains support the following kinds of queries:
+ *
+ * - Envelope select: determine all the segments in the chain which
+ *   intersect a given envelope
+ * - Overlap: determine all the pairs of segments in two chains whose
+ *   envelopes overlap
+ *
+ * This implementation of MonotoneChains uses the concept of internal iterators
+ * to return the resultsets for the above queries.
+ * This has time and space advantages, since it
+ * is not necessary to build lists of instantiated objects to represent the segments
+ * returned by the query.
+ * However, it does mean that the queries are not thread-safe.
+ *
+ */
+class GEOS_DLL MonotoneChain {
+public:
+
+    /// @param pts
+    ///   Ownership left to caller, this class holds a reference.
+    ///
+    /// @param start
+    ///
+    /// @param end
+    ///
+    /// @param context
+    ///   Ownership left to caller, this class holds a reference.
+    ///
+    MonotoneChain(const geom::CoordinateSequence& pts,
+                  std::size_t start, std::size_t end, void* context);
+
+    ~MonotoneChain() = default;
+
+    /// Returned envelope is owned by this class
+    const geom::Envelope& getEnvelope() const;
+    const geom::Envelope& getEnvelope(double expansionDistance) const;
+
+    size_t
+    getStartIndex() const
+    {
+        return start;
+    }
+
+    size_t
+    getEndIndex() const
+    {
+        return end;
+    }
+
+    /** \brief
+     *  Set given LineSegment with points of the segment starting
+     *  at the given index.
+     */
+    void getLineSegment(std::size_t index, geom::LineSegment& ls) const {
+        pts->getAt(index, ls.p0);
+        pts->getAt(index + 1, ls.p1);
+    }
+
+    /**
+     * Return the subsequence of coordinates forming this chain.
+     * Allocates a new CoordinateSequence to hold the Coordinates
+     *
+     */
+    std::unique_ptr<geom::CoordinateSequence> getCoordinates() const;
+
+    /**
+     * Determine all the line segments in the chain whose envelopes overlap
+     * the searchEnvelope, and process them
+     */
+    void select(const geom::Envelope& searchEnv,
+                MonotoneChainSelectAction& mcs) const;
+
+    void computeOverlaps(const MonotoneChain* mc,
+                         MonotoneChainOverlapAction* mco) const;
+
+    void computeOverlaps(const MonotoneChain* mc, double overlapTolerance,
+                         MonotoneChainOverlapAction* mco) const;
+
+    void*
+    getContext() const
+    {
+        return context;
+    }
+
+private:
+
+    void computeSelect(const geom::Envelope& searchEnv,
+                       std::size_t start0,
+                       std::size_t end0,
+                       MonotoneChainSelectAction& mcs) const;
+
+    void computeOverlaps(std::size_t start0, std::size_t end0, const MonotoneChain& mc,
+                         std::size_t start1, std::size_t end1,
+                         double overlapTolerance,
+                         MonotoneChainOverlapAction& mco) const;
+
+    bool overlaps(std::size_t start0, std::size_t end0,
+                  const MonotoneChain& mc, std::size_t start1, std::size_t end1,
+                  double overlapTolerance) const {
+        if (overlapTolerance > 0.0) {
+            return overlaps(pts->getAt<geom::CoordinateXY>(start0),
+                            pts->getAt<geom::CoordinateXY>(end0),
+                            mc.pts->getAt<geom::CoordinateXY>(start1),
+                            mc.pts->getAt<geom::CoordinateXY>(end1),
+                            overlapTolerance);
+        }
+        return geom::Envelope::intersects(pts->getAt<geom::CoordinateXY>(start0),
+                                          pts->getAt<geom::CoordinateXY>(end0),
+                                          mc.pts->getAt<geom::CoordinateXY>(start1),
+                                          mc.pts->getAt<geom::CoordinateXY>(end1));
+    }
+
+    static bool overlaps(const geom::CoordinateXY& p1, const geom::CoordinateXY& p2,
+                  const geom::CoordinateXY& q1, const geom::CoordinateXY& q2,
+                  double overlapTolerance);
+
+    /// Externally owned
+    const geom::CoordinateSequence* pts;
+
+    /// user-defined information
+    void* context;
+
+    /// Index of chain start vertex into the CoordinateSequence, 0 based.
+    std::size_t start;
+
+    /// Index of chain end vertex into the CoordinateSequence, 0 based.
+    std::size_t end;
+
+    /// Owned by this class
+    mutable geom::Envelope env;
+};
+
+} // namespace geos::index::chain
+} // namespace geos::index
+} // namespace geos
+

package/dist/prebuilt/Android-arm64-v8a/include/geos/index/chain/MonotoneChainBuilder.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/MonotoneChainBuilder.java r388 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <memory>
+#include <vector>
+#include <cstddef>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+}
+namespace index {
+namespace chain {
+class MonotoneChain;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos::index
+namespace chain { // geos::index::chain
+
+/** \brief
+ * Constructs [MonotoneChains](@ref index::chain::MonotoneChain)
+ * for sequences of [Coordinates](@ref geom::Coordinate).
+ *
+ * TODO: use vector<const Coordinate*> instead ?
+ */
+class GEOS_DLL MonotoneChainBuilder {
+
+public:
+    /** \brief
+     * Computes a list of the {@link MonotoneChain}s for a list of coordinates,
+     * attaching a context data object to each.
+     *
+     * @param pts the list of points to compute chains for
+     * @param context a data object to attach to each chain
+     * @param[out] mcList a list of the monotone chains for the points
+     */
+    static void getChains(const geom::CoordinateSequence* pts,
+                          void* context,
+                          std::vector<MonotoneChain>& mcList);
+
+    /**
+     * Disable copy construction and assignment. Apparently needed to make this
+     * class compile under MSVC. (See https://stackoverflow.com/q/29565299)
+     */
+    MonotoneChainBuilder(const MonotoneChainBuilder&) = delete;
+    MonotoneChainBuilder& operator=(const MonotoneChainBuilder&) = delete;
+};
+
+} // namespace geos::index::chain
+} // namespace geos::index
+} // namespace geos
+

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