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

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

@@ -0,0 +1,233 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020-2021 Daniel Baston
+ *
+ * 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 <geos/index/strtree/TemplateSTRNode.h>
+#include <geos/index/strtree/TemplateSTRNodePair.h>
+#include <geos/util/IllegalArgumentException.h>
+#include <geos/util.h>
+
+#include <queue>
+#include <memory>
+#include <vector>
+
+namespace geos {
+namespace index {
+namespace strtree {
+
+template<typename ItemType, typename BoundsType, typename ItemDistance>
+class TemplateSTRtreeDistance {
+    using Node = TemplateSTRNode<ItemType, BoundsType>;
+    using NodePair = TemplateSTRNodePair<ItemType, BoundsType, ItemDistance>;
+    using ItemPair = std::pair<ItemType, ItemType>;
+
+    struct PairQueueCompare {
+        bool operator()(const NodePair& a, const NodePair& b) {
+            return a.getDistance() > b.getDistance();
+        }
+    };
+
+    using PairQueue = std::priority_queue<NodePair, std::vector<NodePair>, PairQueueCompare>;
+
+public:
+    explicit TemplateSTRtreeDistance(ItemDistance& id) : m_id(id) {}
+
+    ItemPair nearestNeighbour(const Node& root1, const Node& root2) {
+        NodePair initPair(root1, root2, m_id);
+        return nearestNeighbour(initPair);
+    }
+
+    ItemPair nearestNeighbour(NodePair& initPair) {
+        return nearestNeighbour(initPair, DoubleInfinity);
+    }
+
+    bool isWithinDistance(const Node& root1, const Node& root2, double maxDistance) {
+        NodePair initPair(root1, root2, m_id);
+        return isWithinDistance(initPair, maxDistance);
+    }
+
+private:
+
+    ItemPair nearestNeighbour(NodePair& initPair, double maxDistance) {
+        double distanceLowerBound = maxDistance;
+        std::unique_ptr<NodePair> minPair;
+
+        PairQueue priQ;
+        priQ.push(initPair);
+
+        while (!priQ.empty() && distanceLowerBound > 0) {
+            NodePair pair = priQ.top();
+            priQ.pop();
+            double currentDistance = pair.getDistance();
+
+            /*
+             * If the distance for the first node in the queue
+             * is >= the current minimum distance, all other nodes
+             * in the queue must also have a greater distance.
+             * So the current minDistance must be the true minimum,
+             * and we are done.
+             */
+            if (minPair && currentDistance >= distanceLowerBound) {
+                break;
+            }
+
+            /*
+             * If the pair members are leaves
+             * then their distance is the exact lower bound.
+             * Update the distanceLowerBound to reflect this
+             * (which must be smaller, due to the test
+             * immediately prior to this).
+             */
+            if (pair.isLeaves()) {
+                distanceLowerBound = currentDistance;
+                if (minPair) {
+                    *minPair = pair;
+                } else {
+                    minPair = detail::make_unique<NodePair>(pair);
+                }
+            } else {
+                /*
+                 * Otherwise, expand one side of the pair,
+                 * (the choice of which side to expand is heuristically determined)
+                 * and insert the new expanded pairs into the queue
+                 */
+                expandToQueue(pair, priQ, distanceLowerBound);
+            }
+        }
+
+        if (!minPair) {
+            throw util::GEOSException("Error computing nearest neighbor");
+        }
+
+        return minPair->getItems();
+    }
+
+    void expandToQueue(const NodePair& pair, PairQueue& priQ, double minDistance) {
+        const Node& node1 = pair.getFirst();
+        const Node& node2 = pair.getSecond();
+
+        bool isComp1 = node1.isComposite();
+        bool isComp2 = node2.isComposite();
+
+        /**
+         * HEURISTIC: If both boundables are composite,
+         * choose the one with largest area to expand.
+         * Otherwise, simply expand whichever is composite.
+         */
+        if (isComp1 && isComp2) {
+            if (node1.getSize() > node2.getSize()) {
+                expand(node1, node2, false, priQ, minDistance);
+                return;
+            } else {
+                expand(node2, node1, true, priQ, minDistance);
+                return;
+            }
+        } else if (isComp1) {
+            expand(node1, node2, false, priQ, minDistance);
+            return;
+        } else if (isComp2) {
+            expand(node2, node1, true, priQ, minDistance);
+            return;
+        }
+
+        throw util::IllegalArgumentException("neither boundable is composite");
+
+    }
+
+    void expand(const Node &nodeComposite, const Node &nodeOther, bool isFlipped, PairQueue& priQ,
+                double minDistance) {
+        for (const auto *child = nodeComposite.beginChildren();
+             child < nodeComposite.endChildren(); ++child) {
+            NodePair sp = isFlipped ? NodePair(nodeOther, *child, m_id) : NodePair(*child, nodeOther, m_id);
+
+            // only add to queue if this pair might contain the closest points
+            if (minDistance == DoubleInfinity || sp.getDistance() < minDistance) {
+                priQ.push(sp);
+            }
+        }
+    }
+
+    bool isWithinDistance(const NodePair& initPair, double maxDistance) {
+        double distanceUpperBound = DoubleInfinity;
+
+        // initialize search queue
+        PairQueue priQ;
+        priQ.push(initPair);
+
+        while (! priQ.empty()) {
+            // pop head of queue and expand one side of pair
+            NodePair pair = priQ.top();
+            double pairDistance = pair.getDistance();
+
+            /**
+            * If the distance for the first pair in the queue
+            * is > maxDistance, all other pairs
+            * in the queue must have a greater distance as well.
+            * So can conclude no items are within the distance
+            * and terminate with result = false
+            */
+            if (pairDistance > maxDistance)
+                return false;
+
+            priQ.pop();
+
+            /**
+            * If the maximum distance between the nodes
+            * is less than the maxDistance,
+            * than all items in the nodes must be
+            * closer than the max distance.
+            * Then can terminate with result = true.
+            *
+            * NOTE: using Envelope MinMaxDistance
+            * would provide a tighter bound,
+            * but not much performance improvement has been observed
+            */
+            if (pair.maximumDistance() <= maxDistance)
+                return true;
+            /**
+            * If the pair items are leaves
+            * then their actual distance is an upper bound.
+            * Update the distanceUpperBound to reflect this
+            */
+            if (pair.isLeaves()) {
+                // assert: currentDistance < minimumDistanceFound
+                distanceUpperBound = pairDistance;
+                /**
+                * If the items are closer than maxDistance
+                * can terminate with result = true.
+                */
+                if (distanceUpperBound <= maxDistance)
+                return true;
+            }
+            else {
+                /**
+                * Otherwise, expand one side of the pair,
+                * and insert the expanded pairs into the queue.
+                * The choice of which side to expand is determined heuristically.
+                */
+                expandToQueue(pair, priQ, distanceUpperBound);
+            }
+        }
+        return false;
+
+    }
+
+
+    ItemDistance& m_id;
+};
+}
+}
+}

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

@@ -0,0 +1,95 @@
+/**********************************************************************
+ *
+ * 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 <cstddef>
+#include <geos/export.h>
+
+// Forward declarations
+namespace geos {
+namespace index {
+namespace sweepline {
+class SweepLineInterval;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos.index
+namespace sweepline { // geos:index:sweepline
+
+class GEOS_DLL SweepLineEvent {
+
+public:
+
+    enum {
+        INSERT_EVENT = 1,
+        DELETE_EVENT
+    };
+
+    SweepLineEvent(double x, SweepLineEvent* newInsertEvent,
+                   SweepLineInterval* newSweepInt);
+
+    bool isInsert();
+
+    bool isDelete();
+
+    SweepLineEvent* getInsertEvent();
+
+    std::size_t getDeleteEventIndex();
+
+    void setDeleteEventIndex(std::size_t newDeleteEventIndex);
+
+    SweepLineInterval* getInterval();
+
+    /**
+     * ProjectionEvents are ordered first by their x-value, and then by their eventType.
+     * It is important that Insert events are sorted before Delete events, so that
+     * items whose Insert and Delete events occur at the same x-value will be
+     * correctly handled.
+     */
+    int compareTo(const SweepLineEvent* pe) const;
+
+    //int compareTo(void *o) const;
+
+private:
+
+    double xValue;
+
+    int eventType;
+
+    /// null if this is an INSERT_EVENT event
+    SweepLineEvent* insertEvent;
+
+    std::size_t deleteEventIndex;
+
+    SweepLineInterval* sweepInt;
+
+};
+
+// temp typedefs for backward compatibility
+//typedef SweepLineEvent indexSweepLineEvent;
+
+struct GEOS_DLL  SweepLineEventLessThen {
+    bool operator()(const SweepLineEvent* first, const SweepLineEvent* second) const;
+};
+
+//bool isleLessThen(SweepLineEvent *first, SweepLineEvent *second);
+
+
+} // namespace geos:index:sweepline
+} // namespace geos:index
+} // namespace geos
+

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

@@ -0,0 +1,87 @@
+/**********************************************************************
+ *
+ * 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 <vector>
+#include <geos/export.h>
+
+
+#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 sweepline {
+class SweepLineInterval;
+class SweepLineEvent;
+class SweepLineOverlapAction;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos.index
+namespace sweepline { // geos:index:sweepline
+
+/** \brief
+ * A sweepline implements a sorted index on a set of intervals.
+ *
+ * It is used to compute all overlaps between the interval in the index.
+ */
+class GEOS_DLL SweepLineIndex {
+
+public:
+
+    SweepLineIndex();
+
+    ~SweepLineIndex();
+
+    void add(SweepLineInterval* sweepInt);
+
+    void computeOverlaps(SweepLineOverlapAction* action);
+
+private:
+
+    // FIXME: make it a real vector rather then a pointer
+    std::vector<SweepLineEvent*> events;
+
+    bool indexBuilt;
+
+    // statistics information
+    int nOverlaps;
+
+    /**
+     * Because Delete Events have a link to their corresponding Insert event,
+     * it is possible to compute exactly the range of events which must be
+     * compared to a given Insert event object.
+     */
+    void buildIndex();
+
+    void processOverlaps(std::size_t start, std::size_t end,
+                         SweepLineInterval* s0,
+                         SweepLineOverlapAction* action);
+};
+
+} // namespace geos:index:sweepline
+} // namespace geos:index
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

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

@@ -0,0 +1,37 @@
+/**********************************************************************
+ *
+ * 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 sweepline { // geos:index:sweepline
+
+class GEOS_DLL SweepLineInterval {
+public:
+    SweepLineInterval(double newMin, double newMax, void* newItem = nullptr);
+    double getMin();
+    double getMax();
+    void* getItem();
+private:
+    double min, max;
+    void* item;
+};
+
+} // namespace geos:index:sweepline
+} // namespace geos:index
+} // namespace geos
+

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

@@ -0,0 +1,44 @@
+/**********************************************************************
+ *
+ * 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 sweepline {
+class SweepLineInterval;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos.index
+namespace sweepline { // geos:index:sweepline
+
+class GEOS_DLL SweepLineOverlapAction {
+public:
+    virtual void overlap(SweepLineInterval* s0, SweepLineInterval* s1) = 0;
+
+    virtual
+    ~SweepLineOverlapAction() {}
+};
+
+
+} // namespace geos:index:sweepline
+} // namespace geos:index
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/io/ByteOrderDataInStream.h

@@ -0,0 +1,125 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************
+ *
+ * Last port: io/ByteOrderDataInStream.java rev. 1.1 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/io/ParseException.h>
+#include <geos/io/ByteOrderValues.h>
+#include <geos/util/Machine.h> // for getMachineByteOrder
+
+#include <cstdint>
+#include <iosfwd> // ostream, istream (if we remove inlines)
+
+namespace geos {
+namespace io {
+
+/**
+ * \class ByteOrderDataInStream
+ *
+ * \brief Allows reading an stream of primitive datatypes from an underlying
+ * istream, with the representation being in either common byte ordering.
+ *
+ */
+class GEOS_DLL ByteOrderDataInStream {
+
+public:
+
+    ByteOrderDataInStream()
+        : ByteOrderDataInStream(nullptr, 0) {};
+
+    ByteOrderDataInStream(const unsigned char* buff, size_t buffsz)
+        : byteOrder(getMachineByteOrder())
+        , buf(buff)
+        , end(buff + buffsz)
+        {};
+
+    ~ByteOrderDataInStream() {};
+
+    void setOrder(int order)
+    {
+        byteOrder = order;
+    };
+
+    unsigned char readByte() // throws ParseException
+    {
+        if(size() < 1) {
+            throw  ParseException("Unexpected EOF parsing WKB");
+        }
+        auto ret = buf[0];
+        buf++;
+        return ret;
+    };
+
+    int32_t readInt()
+    {
+        if(size() < 4) {
+            throw ParseException("Unexpected EOF parsing WKB");
+        }
+        auto ret =  ByteOrderValues::getInt(buf , byteOrder);
+        buf += 4;
+        return ret;
+    };
+
+    uint32_t readUnsigned()
+    {
+        if(size() < 4) {
+            throw ParseException("Unexpected EOF parsing WKB");
+        }
+        auto ret =  ByteOrderValues::getUnsigned(buf , byteOrder);
+        buf += 4;
+        return ret;
+    };
+
+    int64_t readLong()
+    {
+        if(size() < 8) {
+            throw ParseException("Unexpected EOF parsing WKB");
+        }
+
+        auto ret = ByteOrderValues::getLong(buf, byteOrder);
+        buf += 8;
+        return ret;
+    };
+
+    double readDouble()
+    {
+        if(size() < 8) {
+            throw  ParseException("Unexpected EOF parsing WKB");
+        }
+        auto ret = ByteOrderValues::getDouble(buf, byteOrder);
+        buf += 8;
+        return ret;
+    };
+
+    size_t size() const
+    {
+        return static_cast<size_t>(end - buf);
+    };
+
+
+private:
+    int byteOrder;
+    const unsigned char* buf;
+    const unsigned char* end;
+
+};
+
+} // namespace io
+} // namespace geos

package/dist/prebuilt/Android-x86_64/include/geos/io/ByteOrderValues.h

@@ -0,0 +1,61 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************
+ *
+ * Last port: io/ByteOrderValues.java rev. 1.3 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <cstdint>
+
+namespace geos {
+namespace io {
+
+/**
+ * \class ByteOrderValues
+ *
+ * \brief Methods to read and write primitive datatypes from/to byte
+ * sequences, allowing the byte order to be specified.
+ *
+ * Similar to the standard Java <code>ByteBuffer</code> class.
+ */
+class GEOS_DLL ByteOrderValues {
+
+public:
+
+    enum EndianType {
+        ENDIAN_BIG = 0,
+        ENDIAN_LITTLE = 1
+    };
+
+    static int32_t getInt(const unsigned char* buf, int byteOrder);
+    static void putInt(int32_t intValue, unsigned char* buf, int byteOrder);
+
+    static uint32_t getUnsigned(const unsigned char* buf, int byteOrder);
+    static void putUnsigned(uint32_t intValue, unsigned char* buf, int byteOrder);
+
+    static int64_t getLong(const unsigned char* buf, int byteOrder);
+    static void putLong(int64_t longValue, unsigned char* buf, int byteOrder);
+
+    static double getDouble(const unsigned char* buf, int byteOrder);
+    static void putDouble(double doubleValue, unsigned char* buf, int byteOrder);
+
+};
+
+} // namespace io
+} // namespace geos
+