npm - @cpp.js/package-geos - Versions diffs - 1.0.0 → 2.0.0-beta.1 - Mend

@cpp.js/package-geos 1.0.0 → 2.0.0-beta.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4678) hide show

package/dist/prebuilt/iOS-iphoneos/include/geos/index/strtree/TemplateSTRtreeDistance.h DELETED Viewed

@@ -1,233 +0,0 @@
-/**********************************************************************
- *
- * 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/iOS-iphoneos/include/geos/index/sweepline/SweepLineEvent.h DELETED Viewed

@@ -1,95 +0,0 @@
-/**********************************************************************
- *
- * 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/iOS-iphoneos/include/geos/index/sweepline/SweepLineIndex.h DELETED Viewed

@@ -1,87 +0,0 @@
-/**********************************************************************
- *
- * 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/iOS-iphoneos/include/geos/index/sweepline/SweepLineInterval.h DELETED Viewed

@@ -1,37 +0,0 @@
-/**********************************************************************
- *
- * 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/iOS-iphoneos/include/geos/index/sweepline/SweepLineOverlapAction.h DELETED Viewed

@@ -1,44 +0,0 @@
-/**********************************************************************
- *
- * 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/iOS-iphoneos/include/geos/io/ByteOrderDataInStream.h DELETED Viewed

@@ -1,125 +0,0 @@
-/**********************************************************************
- *
- * 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/iOS-iphoneos/include/geos/io/ByteOrderValues.h DELETED Viewed

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