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

package/dist/prebuilt/Android-x86_64/include/geos/noding/IntersectionFinderAdder.h

@@ -0,0 +1,110 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************
+ *
+ * Last port: noding/IntersectionFinderAdder.java rev. 1.5 (JTS-1.9)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <vector>
+#include <iostream>
+
+#include <geos/geom/Coordinate.h> // for use in vector
+#include <geos/noding/SegmentIntersector.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+namespace noding {
+class SegmentString;
+}
+namespace algorithm {
+class LineIntersector;
+}
+}
+
+namespace geos {
+namespace noding { // geos.noding
+
+/** \brief
+ * Finds proper and interior intersections in a set of SegmentStrings,
+ * and adds them as nodes.
+ *
+ */
+class GEOS_DLL IntersectionFinderAdder: public SegmentIntersector {
+
+public:
+
+    /** \brief
+     * Creates an intersection finder which finds all proper intersections
+     * and stores them in the provided Coordinate array
+     *
+     * @param newLi the LineIntersector to use
+     * @param v  the Vector to push interior intersections to
+     */
+    IntersectionFinderAdder(algorithm::LineIntersector& newLi,
+                            std::vector<geom::Coordinate>& v)
+        :
+        li(newLi),
+        interiorIntersections(v)
+    {}
+
+    /** \brief
+     * This method is called by clients of the SegmentIntersector
+     * class to process intersections for two segments of the
+     * {@link SegmentString}s being intersected.
+     *
+     * Note that some clients (such as `MonotoneChains`) may
+     * optimize away this call for segment pairs which they have
+     * determined do not intersect
+     * (e.g. by an disjoint envelope test).
+     */
+    void processIntersections(
+        SegmentString* e0,  std::size_t segIndex0,
+        SegmentString* e1,  std::size_t segIndex1) override;
+
+    std::vector<geom::Coordinate>&
+    getInteriorIntersections()
+    {
+        return interiorIntersections;
+    }
+
+    /**
+     * Always process all intersections
+     *
+     * @return false always
+     */
+    bool
+    isDone() const override
+    {
+        return false;
+    }
+
+private:
+    algorithm::LineIntersector& li;
+    std::vector<geom::Coordinate>& interiorIntersections;
+
+    // Declare type as noncopyable
+    IntersectionFinderAdder(const IntersectionFinderAdder& other) = delete;
+    IntersectionFinderAdder& operator=(const IntersectionFinderAdder& rhs) = delete;
+};
+
+} // namespace geos.noding
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/noding/IteratedNoder.h

@@ -0,0 +1,120 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************
+ *
+ * Last port: noding/IteratedNoder.java r591 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <vector>
+#include <iostream>
+
+#include <geos/algorithm/LineIntersector.h>
+#include <geos/noding/SegmentString.h> // due to inlines
+#include <geos/noding/Noder.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class PrecisionModel;
+}
+}
+
+namespace geos {
+namespace noding { // geos::noding
+
+/** \brief
+ * Nodes a set of SegmentStrings completely.
+ *
+ * The set of segmentStrings is fully noded;
+ * i.e. noding is repeated until no further
+ * intersections are detected.
+ *
+ * Iterated noding using a FLOATING precision model is not guaranteed to converge,
+ * due to roundoff error. This problem is detected and an exception is thrown.
+ * Clients can choose to rerun the noding using a lower precision model.
+ *
+ */
+class GEOS_DLL IteratedNoder : public Noder { // implements Noder
+
+private:
+    static const int MAX_ITER = 5;
+
+
+    const geom::PrecisionModel* pm;
+    algorithm::LineIntersector li;
+    std::vector<SegmentString*>* nodedSegStrings;
+    int maxIter;
+
+    /**
+     * Node the input segment strings once
+     * and create the split edges between the nodes
+     */
+    void node(std::vector<SegmentString*>* segStrings,
+              int& numInteriorIntersections,
+              geom::CoordinateXY& intersectionPoint);
+
+public:
+
+    IteratedNoder(const geom::PrecisionModel* newPm)
+        :
+        pm(newPm),
+        li(pm),
+        maxIter(MAX_ITER)
+    {
+    }
+
+    ~IteratedNoder() override {}
+
+    /** \brief
+     * Sets the maximum number of noding iterations performed before
+     * the noding is aborted.
+     *
+     * Experience suggests that this should rarely need to be changed
+     * from the default.
+     * The default is MAX_ITER.
+     *
+     * @param n the maximum number of iterations to perform
+     */
+    void
+    setMaximumIterations(int n)
+    {
+        maxIter = n;
+    }
+
+    std::vector<SegmentString*>*
+    getNodedSubstrings() const override
+    {
+        return nodedSegStrings;
+    }
+
+
+    /** \brief
+     * Fully nodes a list of {@link SegmentString}s, i.e. peforms noding iteratively
+     * until no intersections are found between segments.
+     *
+     * Maintains labelling of edges correctly through the noding.
+     *
+     * @param inputSegmentStrings a collection of SegmentStrings to be noded
+     * @throws TopologyException if the iterated noding fails to converge.
+     */
+    void computeNodes(std::vector<SegmentString*>* inputSegmentStrings) override; // throw(GEOSException);
+};
+
+} // namespace geos::noding
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/noding/MCIndexNoder.h

@@ -0,0 +1,141 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************
+ *
+ * Last port: noding/MCIndexNoder.java rev. 1.6 (JTS-1.9)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/index/chain/MonotoneChainOverlapAction.h> // for inheritance
+#include <geos/index/chain/MonotoneChain.h>
+#include <geos/index/strtree/TemplateSTRtree.h> // for composition
+#include <geos/noding/NodedSegmentString.h>
+#include <geos/noding/SegmentString.h>
+#include <geos/noding/SinglePassNoder.h> // for inheritance
+#include <geos/util.h>
+
+#include <vector>
+#include <iostream>
+
+#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 LineSegment;
+class Envelope;
+}
+namespace noding {
+class SegmentString;
+class SegmentIntersector;
+}
+}
+
+namespace geos {
+namespace noding { // geos.noding
+
+/** \brief
+ * Nodes a set of SegmentString using a index based
+ * on [MonotoneChain](@ref index::chain::MonotoneChain)
+ * and a [SpatialIndex](@ref index::SpatialIndex).
+ *
+ * The [SpatialIndex](@ref index::SpatialIndex) used should be something that supports
+ * envelope (range) queries efficiently (such as a [Quadtree](@ref index::quadtree::Quadtree)
+ * or [STRtree](@ref index::strtree::STRtree)).
+ *
+ * Last port: noding/MCIndexNoder.java rev. 1.4 (JTS-1.7)
+ */
+class GEOS_DLL MCIndexNoder : public SinglePassNoder {
+
+private:
+    std::vector<index::chain::MonotoneChain> monoChains;
+    index::strtree::TemplateSTRtree<const index::chain::MonotoneChain*> index;
+    std::vector<SegmentString*>* nodedSegStrings;
+    // statistics
+    int nOverlaps;
+    double overlapTolerance;
+    bool indexBuilt;
+
+    void intersectChains();
+
+    void add(SegmentString* segStr);
+
+public:
+
+    MCIndexNoder(SegmentIntersector* nSegInt = nullptr, double p_overlapTolerance = 0.0)
+        : SinglePassNoder(nSegInt)
+        , nodedSegStrings(nullptr)
+        , nOverlaps(0)
+        , overlapTolerance(p_overlapTolerance)
+        , indexBuilt(false)
+    {}
+
+    ~MCIndexNoder() override {};
+
+
+    /// \brief Return a reference to this instance's std::vector of MonotoneChains
+    std::vector<index::chain::MonotoneChain>&
+    getMonotoneChains()
+    {
+        return monoChains;
+    }
+
+    index::SpatialIndex& getIndex()
+    {
+        return index;
+    }
+
+    std::vector<SegmentString*>* getNodedSubstrings() const override
+    {
+        assert(nodedSegStrings); // must have called computeNodes before!
+        return NodedSegmentString::getNodedSubstrings(*nodedSegStrings);
+    }
+
+    void computeNodes(std::vector<SegmentString*>* inputSegmentStrings) override;
+
+    class SegmentOverlapAction : public index::chain::MonotoneChainOverlapAction {
+    public:
+        SegmentOverlapAction(SegmentIntersector& newSi)
+            :
+            index::chain::MonotoneChainOverlapAction(),
+            si(newSi)
+        {}
+
+        void overlap(const index::chain::MonotoneChain& mc1, std::size_t start1,
+                     const index::chain::MonotoneChain& mc2, std::size_t start2) override;
+    private:
+        SegmentIntersector& si;
+
+        // Declare type as noncopyable
+        SegmentOverlapAction(const SegmentOverlapAction& other) = delete;
+        SegmentOverlapAction& operator=(const SegmentOverlapAction& rhs) = delete;
+    };
+
+};
+
+} // namespace geos.noding
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+
+

package/dist/prebuilt/Android-x86_64/include/geos/noding/MCIndexSegmentSetMutualIntersector.h

@@ -0,0 +1,146 @@
+/**********************************************************************
+ *
+ * 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/noding/SegmentSetMutualIntersector.h> // inherited
+#include <geos/index/chain/MonotoneChainOverlapAction.h> // inherited
+#include <geos/index/chain/MonotoneChain.h> // inherited
+#include <geos/index/strtree/TemplateSTRtree.h> // inherited
+
+namespace geos {
+namespace geom {
+    class Envelope;
+}
+namespace index {
+    class SpatialIndex;
+}
+namespace noding {
+    class SegmentString;
+    class SegmentIntersector;
+}
+}
+
+//using namespace geos::index::strtree;
+
+namespace geos {
+namespace noding { // geos::noding
+
+/** \brief
+ * Intersects two sets of [SegmentStrings](@ref SegmentString) using a index based
+ * on [MonotoneChains](@ref index::chain::MonotoneChain) and a
+ * [SpatialIndex](@ref index::SpatialIndex).
+ *
+ * @version 1.7
+ */
+class GEOS_DLL MCIndexSegmentSetMutualIntersector : public SegmentSetMutualIntersector {
+public:
+
+    MCIndexSegmentSetMutualIntersector(double p_tolerance)
+        : monoChains()
+        , indexCounter(0)
+        , processCounter(0)
+        , nOverlaps(0)
+        , overlapTolerance(p_tolerance)
+        , indexBuilt(false)
+        , envelope(nullptr)
+    {}
+
+    MCIndexSegmentSetMutualIntersector(const geom::Envelope* p_envelope)
+        : monoChains()
+        , indexCounter(0)
+        , processCounter(0)
+        , nOverlaps(0)
+        , overlapTolerance(0.0)
+        , indexBuilt(false)
+        , envelope(p_envelope)
+    {}
+
+    MCIndexSegmentSetMutualIntersector()
+        : MCIndexSegmentSetMutualIntersector(0.0)
+    {}
+
+    ~MCIndexSegmentSetMutualIntersector() override
+    {};
+
+    index::SpatialIndex*
+    getIndex()
+    {
+        return &index;
+    }
+
+    void setBaseSegments(SegmentString::ConstVect* segStrings) override;
+
+    // NOTE: re-populates the MonotoneChain vector with newly created chains
+    void process(SegmentString::ConstVect* segStrings) override;
+
+    class SegmentOverlapAction : public index::chain::MonotoneChainOverlapAction {
+    private:
+        SegmentIntersector& si;
+
+        // Declare type as noncopyable
+        SegmentOverlapAction(const SegmentOverlapAction& other) = delete;
+        SegmentOverlapAction& operator=(const SegmentOverlapAction& rhs) = delete;
+
+    public:
+        SegmentOverlapAction(SegmentIntersector& p_si) :
+            index::chain::MonotoneChainOverlapAction(), si(p_si)
+        {}
+
+        void overlap(const index::chain::MonotoneChain& mc1, std::size_t start1,
+                     const index::chain::MonotoneChain& mc2, std::size_t start2) override;
+    };
+
+    /**
+     * Disable copy construction and assignment. Apparently needed to make this
+     * class compile under MSVC. (See https://stackoverflow.com/q/29565299)
+     */
+    MCIndexSegmentSetMutualIntersector(const MCIndexSegmentSetMutualIntersector&) = delete;
+    MCIndexSegmentSetMutualIntersector& operator=(const MCIndexSegmentSetMutualIntersector&) = delete;
+
+private:
+
+    typedef std::vector<index::chain::MonotoneChain> MonoChains;
+    MonoChains monoChains;
+
+    /*
+     * The index::SpatialIndex used should be something that supports
+     * envelope (range) queries efficiently (such as a index::quadtree::Quadtree
+     * or index::strtree::STRtree).
+     */
+    index::strtree::TemplateSTRtree<const index::chain::MonotoneChain*> index;
+    int indexCounter;
+    int processCounter;
+    // statistics
+    int nOverlaps;
+    double overlapTolerance;
+
+    /* memory management helper, holds MonotoneChain objects used
+     * in the SpatialIndex. It's cleared when the SpatialIndex is
+     */
+    bool indexBuilt;
+    MonoChains indexChains;
+    const geom::Envelope* envelope;
+
+    void addToIndex(SegmentString* segStr);
+
+    void intersectChains();
+
+    void addToMonoChains(SegmentString* segStr);
+
+};
+
+} // namespace geos::noding
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/noding/NodableSegmentString.h

@@ -0,0 +1,56 @@
+/**********************************************************************
+ *
+ * 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 <geos/noding/SegmentString.h> // for inheritance
+
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+}
+
+namespace geos {
+namespace noding { // geos::noding
+
+/** \brief
+ * An interface for classes which support adding nodes to
+ * a segment string.
+ *
+ * @author Martin Davis
+ */
+class GEOS_DLL NodableSegmentString : public SegmentString {
+private:
+protected:
+public:
+    NodableSegmentString(const void* newContext, geom::CoordinateSequence* newSeq)
+        :
+        SegmentString(newContext, newSeq)
+    { }
+
+    /**
+     * Adds an intersection node for a given point and segment to this segment string.
+     *
+     * @param intPt the location of the intersection
+     * @param segmentIndex the index of the segment containing the intersection
+     */
+    //virtual void addIntersection( const geom::Coordinate * intPt, int segmentIndex) =0;
+};
+
+} // namespace geos::noding
+} // namespace geos
+