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

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

@@ -0,0 +1,72 @@
+/**********************************************************************
+ *
+ * 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: geomgraph/index/MonotoneChain.java rev. 1.3 (JTS-1.7)
+ *
+ **********************************************************************/
+
+#pragma once
+
+
+#include <geos/export.h>
+#include <geos/geomgraph/index/SweepLineEventObj.h> // for inheritance
+#include <geos/geomgraph/index/MonotoneChainEdge.h> // for inline
+#include <geos/geomgraph/index/MonotoneChain.h>
+
+// Forward declarations
+namespace geos {
+namespace geomgraph {
+namespace index {
+class SegmentIntersector;
+}
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos::geomgraph
+namespace index { // geos::geomgraph::index
+
+/**
+ * A chain in a MonotoneChainEdge
+ */
+class GEOS_DLL MonotoneChain: public SweepLineEventOBJ {
+private:
+    MonotoneChainEdge* mce;
+    std::size_t chainIndex;
+
+    MonotoneChain(const MonotoneChain& other) = delete;
+    MonotoneChain& operator=(const MonotoneChain& rhs) = delete;
+
+public:
+
+    MonotoneChain(MonotoneChainEdge* newMce, std::size_t newChainIndex):
+        mce(newMce),
+        chainIndex(newChainIndex)
+    {}
+
+    ~MonotoneChain() override {}
+
+    void
+    computeIntersections(MonotoneChain* mc, SegmentIntersector* si)
+    {
+        mce->computeIntersectsForChain(chainIndex, *(mc->mce), mc->chainIndex, *si);
+    }
+};
+
+
+} // namespace geos.geomgraph.index
+} // namespace geos.geomgraph
+} // namespace geos
+

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

@@ -0,0 +1,85 @@
+/**********************************************************************
+ *
+ * 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 <geos/geom/Envelope.h> // for composition
+
+#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 geom {
+class CoordinateSequence;
+}
+namespace geomgraph {
+class Edge;
+namespace index {
+class SegmentIntersector;
+}
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos::geomgraph
+namespace index { // geos::geomgraph::index
+
+/// \brief MonotoneChains are a way of partitioning the segments of an edge to
+/// allow for fast searching of intersections.
+class GEOS_DLL MonotoneChainEdge {
+public:
+    //MonotoneChainEdge();
+    ~MonotoneChainEdge() = default;
+    MonotoneChainEdge(Edge* newE);
+    const geom::CoordinateSequence* getCoordinates();
+    std::vector<size_t>& getStartIndexes();
+    double getMinX(std::size_t chainIndex);
+    double getMaxX(std::size_t chainIndex);
+
+    void computeIntersects(const MonotoneChainEdge& mce,
+                           SegmentIntersector& si);
+
+    void computeIntersectsForChain(std::size_t chainIndex0,
+                                   const MonotoneChainEdge& mce, std::size_t chainIndex1,
+                                   SegmentIntersector& si);
+
+protected:
+    Edge* e;
+    const geom::CoordinateSequence* pts; // cache a reference to the coord array, for efficiency
+    // the lists of start/end indexes of the monotone chains.
+    // Includes the end point of the edge as a sentinel
+    std::vector<size_t> startIndex;
+    // these envelopes are created once and reused
+private:
+    void computeIntersectsForChain(std::size_t start0, std::size_t end0,
+                                   const MonotoneChainEdge& mce,
+                                   std::size_t start1, std::size_t end1,
+                                   SegmentIntersector& ei);
+
+    bool overlaps(std::size_t start0, std::size_t end0, const MonotoneChainEdge& mce, std::size_t start1, std::size_t end1);
+
+};
+
+} // namespace geos.geomgraph.index
+} // namespace geos.geomgraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

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

@@ -0,0 +1,71 @@
+/**********************************************************************
+ *
+ * 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 <vector>
+#include <geos/export.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos::geomgraph
+namespace index { // geos::geomgraph::index
+
+/// \brief MonotoneChains are a way of partitioning the segments of an edge to
+/// allow for fast searching of intersections.
+///
+/// Specifically, a sequence of contiguous line segments is a monotone chain
+/// iff all the vectors defined by the oriented segments lies in the same
+/// quadrant.
+///
+/// Monotone Chains have the following useful properties:
+///
+/// - the segments within a monotone chain will never intersect each other
+///
+/// - the envelope of any contiguous subset of the segments in a monotone chain
+///   is simply 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 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.
+///
+/// \note Due to the efficient intersection test, there is no need to limit the
+/// size of chains to obtain fast performance.
+class GEOS_DLL MonotoneChainIndexer {
+
+public:
+
+    MonotoneChainIndexer() {}
+
+    void getChainStartIndices(const geom::CoordinateSequence*, std::vector<std::size_t>&);
+
+private:
+
+    std::size_t findChainEnd(const geom::CoordinateSequence* pts, std::size_t start);
+
+};
+
+} // namespace geos.geomgraph.index
+} // namespace geos.geomgraph
+} // namespace geos
+

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

@@ -0,0 +1,176 @@
+/**********************************************************************
+ *
+ * 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 <array>
+#include <vector>
+
+#include <geos/geom/Coordinate.h> // for composition
+
+#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 algorithm {
+class LineIntersector;
+}
+namespace geomgraph {
+class Node;
+class Edge;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos::geomgraph
+namespace index { // geos::geomgraph::index
+
+/// \brief Computes the intersection of line segments, and adds the
+/// intersection to the edges containing the segments.
+class GEOS_DLL SegmentIntersector {
+
+private:
+
+    /**
+     * These variables keep track of what types of intersections were
+     * found during ALL edges that have been intersected.
+     */
+    bool hasIntersectionVar;
+
+    bool hasProper;
+
+    bool hasProperInterior;
+
+    /// the proper intersection point found
+    geom::Coordinate properIntersectionPoint;
+
+    algorithm::LineIntersector* li;
+
+    bool includeProper;
+
+    bool recordIsolated;
+
+    int numIntersections;
+
+    /// Elements are externally owned
+    std::array<std::vector<Node*>*, 2> bdyNodes;
+
+    bool isTrivialIntersection(Edge* e0, std::size_t segIndex0, Edge* e1, std::size_t segIndex1);
+
+    bool isBoundaryPoint(algorithm::LineIntersector* p_li,
+                         std::array<std::vector<Node*>*, 2>& tstBdyNodes)
+    {
+        return isBoundaryPoint(p_li, tstBdyNodes[0]) || isBoundaryPoint(p_li, tstBdyNodes[1]);
+    };
+
+    bool isBoundaryPoint(algorithm::LineIntersector* li,
+                         std::vector<Node*>* tstBdyNodes);
+
+public:
+
+    static bool isAdjacentSegments(std::size_t i1, size_t i2)
+    {
+        return (i1 > i2 ? i1 - i2 : i2 - i1) == 1;
+    };
+
+    // testing only
+    int numTests;
+
+    //SegmentIntersector();
+
+    virtual
+    ~SegmentIntersector() {}
+
+    SegmentIntersector(algorithm::LineIntersector* newLi,
+                       bool newIncludeProper, bool newRecordIsolated)
+        :
+        hasIntersectionVar(false),
+        hasProper(false),
+        hasProperInterior(false),
+        li(newLi),
+        includeProper(newIncludeProper),
+        recordIsolated(newRecordIsolated),
+        numIntersections(0),
+        bdyNodes{{nullptr, nullptr}},
+        numTests(0)
+    {}
+
+    /// \brief
+    /// Parameters are externally owned.
+    /// Make sure they live for the whole lifetime of this object
+    void setBoundaryNodes(std::vector<Node*>* bdyNodes0,
+                          std::vector<Node*>* bdyNodes1)
+    {
+        bdyNodes[0] = bdyNodes0;
+        bdyNodes[1] = bdyNodes1;
+    };
+
+    /*
+    * @return the proper intersection point, or <code>null</code>
+    * if none was found
+    */
+    geom::Coordinate& getProperIntersectionPoint()
+    {
+        return properIntersectionPoint;
+    };
+
+    bool hasIntersection() const
+    {
+        return hasIntersectionVar;
+    };
+
+    /**
+     * A proper intersection is an intersection which is interior to at least two
+     * line segments.  Note that a proper intersection is not necessarily
+     * in the interior of the entire Geometry, since another edge may have
+     * an endpoint equal to the intersection, which according to SFS semantics
+     * can result in the point being on the Boundary of the Geometry.
+     */
+    bool hasProperIntersection() const
+    {
+        return hasProper;
+    };
+
+    /**
+     * A proper interior intersection is a proper intersection which is <b>not</b>
+     * contained in the set of boundary nodes set for this SegmentIntersector.
+     */
+    bool hasProperInteriorIntersection() const
+    {
+        return hasProperInterior;
+    };
+
+    void addIntersections(Edge* e0, std::size_t segIndex0, Edge* e1, std::size_t segIndex1);
+
+    bool getIsDone() const
+    {
+        return false;
+    };
+
+
+};
+
+} // namespace geos.geomgraph.index
+} // namespace geos.geomgraph
+} // namespace geos
+
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

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