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

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

@@ -1,72 +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: 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-arm64-v8a/include/geos/geomgraph/index/MonotoneChainEdge.h

@@ -1,85 +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.
- *
- **********************************************************************/
-
-#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-arm64-v8a/include/geos/geomgraph/index/MonotoneChainIndexer.h

@@ -1,71 +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.
- *
- **********************************************************************/
-
-#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-arm64-v8a/include/geos/geomgraph/index/SegmentIntersector.h

@@ -1,176 +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.
- *
- **********************************************************************/
-
-#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-arm64-v8a/include/geos/geomgraph/index/SimpleEdgeSetIntersector.h

@@ -1,64 +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.
- *
- **********************************************************************/
-
-#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-arm64-v8a/include/geos/geomgraph/index/SimpleMCSweepLineIntersector.h

@@ -1,108 +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.
- *
- **********************************************************************/
-
-#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-arm64-v8a/include/geos/geomgraph/index/SimpleSweepLineIntersector.h

@@ -1,94 +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.
- *
- **********************************************************************/
-
-#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
-