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

package/dist/prebuilt/Android-x86_64/include/geos/geomgraph/index/SweepLineEvent.h

@@ -0,0 +1,136 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2005-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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <string>
+
+// Forward declarations
+namespace geos {
+namespace geomgraph {
+namespace index {
+class SweepLineEventOBJ;
+}
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos::geomgraph
+namespace index { // geos::geomgraph::index
+
+//class SweepLineEventLessThen; // needed ??
+
+class GEOS_DLL SweepLineEvent final {
+    friend class SweepLineEventLessThen;
+
+public:
+
+    enum {
+        INSERT_EVENT = 1,
+        DELETE_EVENT
+    };
+
+    SweepLineEvent(void* newEdgeSet, double x,
+                   SweepLineEvent* newInsertEvent,
+                   SweepLineEventOBJ* newObj);
+
+    ~SweepLineEvent() = default;
+
+    bool
+    isInsert()
+    {
+        return insertEvent == nullptr;
+    }
+
+    bool
+    isDelete()
+    {
+        return insertEvent != nullptr;
+    }
+
+    int
+    eventType()
+    {
+        return insertEvent == nullptr ? INSERT_EVENT : DELETE_EVENT;
+    }
+
+    SweepLineEvent*
+    getInsertEvent()
+    {
+        return insertEvent;
+    }
+
+    size_t
+    getDeleteEventIndex()
+    {
+        return deleteEventIndex;
+    }
+
+    void
+    setDeleteEventIndex(std::size_t newDeleteEventIndex)
+    {
+        deleteEventIndex = newDeleteEventIndex;
+    }
+
+    SweepLineEventOBJ*
+    getObject() const
+    {
+        return obj;
+    }
+
+    int compareTo(SweepLineEvent* sle);
+
+    std::string print();
+
+    void* edgeSet;    // used for red-blue intersection detection
+
+protected:
+
+    SweepLineEventOBJ* obj;
+
+private:
+
+    double xValue;
+
+    SweepLineEvent* insertEvent; // null if this is an INSERT_EVENT event
+
+    std::size_t deleteEventIndex;
+};
+
+class GEOS_DLL SweepLineEventLessThen {
+public:
+    template<typename T>
+    bool
+    operator()(const T& f, const T& s) const
+    {
+        if(f->xValue < s->xValue) {
+            return true;
+        }
+        if(f->xValue > s->xValue) {
+            return false;
+        }
+        if(f->eventType() < s->eventType()) {
+            return true;
+        }
+        return false;
+    }
+};
+
+
+} // namespace geos.geomgraph.index
+} // namespace geos.geomgraph
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/geomgraph/index/SweepLineEventObj.h

@@ -0,0 +1,38 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2005-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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+namespace geos {
+namespace geomgraph { // geos::geomgraph
+namespace index { // geos::geomgraph::index
+
+// This is here so that SweepLineEvent constructor
+// can use it as argument type.
+// Both  SweepLineSegment and MonotoneChain will
+// inherit from it.
+class GEOS_DLL SweepLineEventOBJ {
+public:
+    virtual
+    ~SweepLineEventOBJ() {}
+};
+
+
+} // namespace geos.geomgraph.index
+} // namespace geos.geomgraph
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/geomgraph/index/SweepLineSegment.h

@@ -0,0 +1,57 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2005-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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <cstddef>
+#include <geos/export.h>
+#include <geos/geomgraph/index/SweepLineEventObj.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+}
+namespace geomgraph {
+class Edge;
+namespace index {
+class SegmentIntersector;
+}
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos::geomgraph
+namespace index { // geos::geomgraph::index
+
+class GEOS_DLL SweepLineSegment: public SweepLineEventOBJ {
+public:
+    SweepLineSegment(Edge* newEdge, std::size_t newPtIndex);
+    ~SweepLineSegment() override = default;
+    double getMinX();
+    double getMaxX();
+    void computeIntersections(SweepLineSegment* ss, SegmentIntersector* si);
+protected:
+    Edge* edge;
+    const geom::CoordinateSequence* pts;
+    std::size_t ptIndex;
+};
+
+
+
+} // namespace geos.geomgraph.index
+} // namespace geos.geomgraph
+} // namespace geos
+

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

@@ -0,0 +1,38 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+namespace geos {
+namespace index {
+
+/** \brief
+ * A visitor for items in an index.
+ *
+ * Last port: index/ItemVisitor.java rev. 1.2 (JTS-1.7)
+ */
+class GEOS_DLL ItemVisitor {
+public:
+    virtual void visitItem(void*) = 0;
+
+    virtual
+    ~ItemVisitor() {}
+};
+
+} // namespace geos.index
+} // namespace geos
+

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

@@ -0,0 +1,103 @@
+/**********************************************************************
+ *
+ * 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 geom {
+class Envelope;
+}
+namespace index {
+class ItemVisitor;
+}
+}
+
+namespace geos {
+namespace index {
+
+/** \brief
+ * Abstract class defines basic insertion and query operations supported by
+ * classes implementing spatial index algorithms.
+ *
+ * A spatial index typically provides a primary filter for range rectangle queries. A
+ * secondary filter is required to test for exact intersection. Of course, this
+ * secondary filter may consist of other tests besides intersection, such as
+ * testing other kinds of spatial relationships.
+ *
+ * Last port: index/SpatialIndex.java rev. 1.11 (JTS-1.7)
+ *
+ */
+class GEOS_DLL SpatialIndex {
+public:
+
+    virtual
+    ~SpatialIndex() {}
+
+    /** \brief
+     * Adds a spatial item with an extent specified by the given Envelope
+     * to the index
+     *
+     * @param itemEnv
+     *    Envelope of the item, ownership left to caller.
+     *    TODO: Reference hold by this class ?
+     *
+     * @param item
+     *    Opaque item, ownership left to caller.
+     *    Reference hold by this class.
+     */
+    virtual void insert(const geom::Envelope* itemEnv, void* item) = 0;
+
+    /** \brief
+     * Queries the index for all items whose extents intersect the given search Envelope
+     *
+     * Note that some kinds of indexes may also return objects which do not in fact
+     * intersect the query envelope.
+     *
+     * @param searchEnv the envelope to query for
+     */
+    //virtual std::vector<void*>* query(const geom::Envelope *searchEnv)=0;
+    virtual void query(const geom::Envelope* searchEnv, std::vector<void*>&) = 0;
+
+    /** \brief
+     * Queries the index for all items whose extents intersect the given search Envelope
+     * and applies an ItemVisitor to them.
+     *
+     * Note that some kinds of indexes may also return objects which do not in fact
+     * intersect the query envelope.
+     *
+     * @param searchEnv the envelope to query for
+     * @param visitor a visitor object to apply to the items found
+     */
+    virtual void query(const geom::Envelope* searchEnv, ItemVisitor& visitor) = 0;
+
+    /** \brief
+     * Removes a single item from the tree.
+     *
+     * @param itemEnv the Envelope of the item to remove
+     * @param item the item to remove
+     * @return <code>true</code> if the item was found
+     */
+    virtual bool remove(const geom::Envelope* itemEnv, void* item) = 0;
+
+};
+
+
+} // namespace geos.index
+} // namespace geos
+

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