@cpp.js/package-geos 1.0.0-beta.21 → 1.0.0-beta.23

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

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

@@ -0,0 +1,206 @@
+/**********************************************************************
+ *
+ * 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-x86_64/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
+