@crossbind/port-geos-linuxmusl 0.0.0-bootstrap.0 → 2.0.0-beta.63

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/geomgraph/index/SimpleEdgeSetIntersector.h

@@ -0,0 +1,64 @@
+/**********************************************************************
+ *
+ * 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 <vector>
+
+#include <geos/geomgraph/index/EdgeSetIntersector.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace geomgraph {
+class Edge;
+namespace index {
+class SegmentIntersector;
+}
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos::geomgraph
+namespace index { // geos::geomgraph::index
+
+/// \brief Finds all intersections in one or two sets of edges, using the
+/// straightforward method of comparing all segments.
+///
+/// \note This algorithm is too slow for production use, but is useful for
+/// testing purposes.
+class GEOS_DLL SimpleEdgeSetIntersector: public EdgeSetIntersector {
+
+public:
+
+    SimpleEdgeSetIntersector();
+
+    void computeIntersections(std::vector<Edge*>* edges,
+                              SegmentIntersector* si, bool testAllSegments) override;
+
+    void computeIntersections(std::vector<Edge*>* edges0,
+                              std::vector<Edge*>* edges1, SegmentIntersector* si) override;
+
+private:
+
+    int nOverlaps;
+
+    void computeIntersects(Edge* e0, Edge* e1, SegmentIntersector* si);
+};
+
+} // namespace geos.geomgraph.index
+} // namespace geos.geomgraph
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/geomgraph/index/SimpleMCSweepLineIntersector.h

@@ -0,0 +1,108 @@
+/**********************************************************************
+ *
+ * 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 <memory>
+#include <vector>
+
+#include <geos/geomgraph/index/EdgeSetIntersector.h> // for inheritance
+#include <geos/geomgraph/index/SegmentIntersector.h>
+#include <geos/geomgraph/index/SweepLineEvent.h>
+#include <geos/geomgraph/index/MonotoneChain.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 geomgraph {
+class Edge;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos::geomgraph
+namespace index { // geos::geomgraph::index
+
+/** \brief
+ * Finds all intersections in one or two sets of edges,
+ * using an x-axis sweepline algorithm in conjunction with Monotone Chains.
+ *
+ * While still O(n^2) in the worst case, this algorithm
+ * drastically improves the average-case time.
+ * The use of MonotoneChains as the items in the index
+ * seems to offer an improvement in performance over a sweep-line alone.
+ */
+class GEOS_DLL SimpleMCSweepLineIntersector: public EdgeSetIntersector {
+
+public:
+
+    SimpleMCSweepLineIntersector() = default;
+
+    ~SimpleMCSweepLineIntersector() override = default;
+
+    void computeIntersections(std::vector<Edge*>* edges,
+                              SegmentIntersector* si, bool testAllSegments) override;
+
+    void computeIntersections(std::vector<Edge*>* edges0,
+                              std::vector<Edge*>* edges1,
+                              SegmentIntersector* si) override;
+
+protected:
+
+    // SweepLineEvents need to refer to each other, and to MonotoneChains.
+    // To avoid individually heap-allocating all of these, we store them
+    // in deques so that subsequent inserts preserve addresses. However,
+    // we also need to sort the SweepLineEvents after they have all been
+    // inserted, so we keep a pointer to each event in a separate vector,
+    // which can be freely reordered without breaking linkages.
+    std::vector<SweepLineEvent*> events;
+    std::deque<SweepLineEvent> eventStore;
+    std::deque<MonotoneChain> chains;
+
+    // statistics information
+    int nOverlaps;
+
+private:
+    void add(std::vector<Edge*>* edges);
+
+    void add(std::vector<Edge*>* edges, void* edgeSet);
+
+    void add(Edge* edge, void* edgeSet);
+
+    void prepareEvents();
+
+    void computeIntersections(SegmentIntersector* si);
+
+    void processOverlaps(std::size_t start, std::size_t end,
+                         SweepLineEvent* ev0,
+                         SegmentIntersector* si);
+    // Declare type as noncopyable
+    SimpleMCSweepLineIntersector(const SimpleMCSweepLineIntersector& other) = delete;
+    SimpleMCSweepLineIntersector& operator=(const SimpleMCSweepLineIntersector& rhs) = delete;
+};
+
+} // namespace geos.geomgraph.index
+} // namespace geos.geomgraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/geomgraph/index/SimpleSweepLineIntersector.h

@@ -0,0 +1,94 @@
+/**********************************************************************
+ *
+ * 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 <vector>
+
+#include <geos/geomgraph/index/EdgeSetIntersector.h> // for inheritance
+
+#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 geomgraph {
+class Edge;
+namespace index {
+class SegmentIntersector;
+class SweepLineEvent;
+}
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos::geomgraph
+namespace index { // geos::geomgraph::index
+
+/** \brief
+ * Finds all intersections in one or two sets of edges,
+ * using a simple x-axis sweepline algorithm.
+ *
+ * While still O(n^2) in the worst case, this algorithm
+ * drastically improves the average-case time.
+ */
+class GEOS_DLL SimpleSweepLineIntersector: public EdgeSetIntersector {
+
+public:
+
+    SimpleSweepLineIntersector();
+
+    ~SimpleSweepLineIntersector() override;
+
+    void computeIntersections(std::vector<Edge*>* edges,
+                              SegmentIntersector* si,
+                              bool testAllSegments) override;
+
+    void computeIntersections(std::vector<Edge*>* edges0,
+                              std::vector<Edge*>* edges1,
+                              SegmentIntersector* si) override;
+
+private:
+
+    void add(std::vector<Edge*>* edges);
+
+    std::vector<SweepLineEvent*> events;
+
+    // statistics information
+    int nOverlaps;
+
+    void add(std::vector<Edge*>* edges, void* edgeSet);
+
+    void add(Edge* edge, void* edgeSet);
+
+    void prepareEvents();
+
+    void computeIntersections(SegmentIntersector* si);
+
+    void processOverlaps(std::size_t start, std::size_t end, SweepLineEvent* ev0,
+                         SegmentIntersector* si);
+};
+
+} // namespace geos.geomgraph.index
+} // namespace geos.geomgraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/linuxmusl-x64-mt-release/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/linuxmusl-x64-mt-release/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/linuxmusl-x64-mt-release/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/linuxmusl-x64-mt-release/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/linuxmusl-x64-mt-release/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
+