@crossbind/port-geos-ios 2.0.0-beta.50

package/dist/prebuilt/ios-iphoneos-mt-release/include/geos/noding/FastNodingValidator.h

@@ -0,0 +1,129 @@
+/**********************************************************************
+ *
+ * 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/FastNodingValidator.java rev. ??? (JTS-1.8)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/noding/NodingIntersectionFinder.h> // for composition
+#include <geos/algorithm/LineIntersector.h> // for composition
+
+#include <memory>
+#include <string>
+#include <cassert>
+
+// Forward declarations
+namespace geos {
+namespace noding {
+class SegmentString;
+}
+}
+
+namespace geos {
+namespace noding { // geos.noding
+
+/** \brief
+ * Validates that a collection of {@link SegmentString}s is correctly noded.
+ *
+ * Indexing is used to improve performance.
+ * By default validation stops after a single
+ * non-noded intersection is detected.
+ * Alternatively, it can be requested to detect all intersections by
+ * using `setFindAllIntersections(boolean)`.
+ *
+ * The validator does not check for topology collapse situations
+ * (e.g. where two segment strings are fully co-incident).
+ *
+ * The validator checks for the following situations which indicated incorrect noding:
+ *
+ * - Proper intersections between segments (i.e. the intersection is interior to both segments)
+ * - Intersections at an interior vertex (i.e. with an endpoint or another interior vertex)
+ *
+ * The client may either test the {@link #isValid()} condition,
+ * or request that a suitable [TopologyException](@ref util::TopologyException) be thrown.
+ *
+ */
+class FastNodingValidator {
+
+public:
+
+    FastNodingValidator(std::vector<noding::SegmentString*>& newSegStrings)
+        :
+        li(), // robust...
+        segStrings(newSegStrings),
+        segInt(),
+        isValidVar(true)
+    {
+    }
+
+    /** \brief
+     * Checks for an intersection and
+     * reports if one is found.
+     *
+     * @return true if the arrangement contains an interior intersection
+     */
+    bool
+    isValid()
+    {
+        execute();
+        return isValidVar;
+    }
+
+    /** \brief
+     * Returns an error message indicating the segments containing
+     * the intersection.
+     *
+     * @return an error message documenting the intersection location
+     */
+    std::string getErrorMessage() const;
+
+    /** \brief
+     * Checks for an intersection and throws
+     * a TopologyException if one is found.
+     *
+     * @throws TopologyException if an intersection is found
+     */
+    void checkValid();
+
+private:
+
+    geos::algorithm::LineIntersector li;
+
+    std::vector<noding::SegmentString*>& segStrings;
+
+    std::unique_ptr<NodingIntersectionFinder> segInt;
+
+    bool isValidVar;
+
+    void
+    execute()
+    {
+        if(segInt.get() != nullptr) {
+            return;
+        }
+        checkInteriorIntersections();
+    }
+
+    void checkInteriorIntersections();
+
+    // Declare type as noncopyable
+    FastNodingValidator(const FastNodingValidator& other) = delete;
+    FastNodingValidator& operator=(const FastNodingValidator& rhs) = delete;
+};
+
+} // namespace geos.noding
+} // namespace geos
+

package/dist/prebuilt/ios-iphoneos-mt-release/include/geos/noding/FastSegmentSetIntersectionFinder.h

@@ -0,0 +1,80 @@
+/**********************************************************************
+ *
+ * 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/FastSegmentSetIntersectionFinder.java r388 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/algorithm/LineIntersector.h>
+#include <geos/noding/SegmentString.h>
+#include <geos/noding/MCIndexSegmentSetMutualIntersector.h>
+
+#include <memory>
+
+//forward declarations
+namespace geos {
+namespace noding {
+class SegmentIntersectionDetector;
+class SegmentSetMutualIntersector;
+//class MCIndexSegmentSetMutualIntersector : public SegmentSetMutualIntersector;
+}
+}
+
+
+namespace geos {
+namespace noding { // geos::noding
+
+/** \brief
+ * Finds if two sets of [SegmentStrings](@ref noding::SegmentString) intersect.
+ *
+ * Uses indexing for fast performance and to optimize repeated tests
+ * against a target set of lines.
+ * Short-circuited to return as soon an intersection is found.
+ *
+ * @version 1.7
+ */
+class FastSegmentSetIntersectionFinder {
+private:
+    std::unique_ptr<MCIndexSegmentSetMutualIntersector> segSetMutInt;
+    std::unique_ptr<geos::algorithm::LineIntersector> lineIntersector;
+
+protected:
+public:
+    FastSegmentSetIntersectionFinder(SegmentString::ConstVect* baseSegStrings);
+
+    ~FastSegmentSetIntersectionFinder() = default;
+
+    /**
+     * Gets the segment set intersector used by this class.
+     * This allows other uses of the same underlying indexed structure.
+     *
+     * @return the segment set intersector used
+     */
+    const SegmentSetMutualIntersector*
+    getSegmentSetIntersector() const
+    {
+        return segSetMutInt.get();
+    }
+
+    bool intersects(SegmentString::ConstVect* segStrings);
+    bool intersects(SegmentString::ConstVect* segStrings, SegmentIntersectionDetector* intDetector);
+
+};
+
+} // geos::noding
+} // geos
+

package/dist/prebuilt/ios-iphoneos-mt-release/include/geos/noding/GeometryNoder.h

@@ -0,0 +1,69 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2012  Sandro Santilli <strk@kbt.io>
+ *
+ * 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.
+ *
+ **********************************************************************
+ *
+ * NOTE: this is not in JTS. JTS has a snapround/GeometryNoder though
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/noding/SegmentString.h> // for NonConstVect
+
+#include <memory> // for unique_ptr
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+}
+namespace noding {
+class Noder;
+}
+}
+
+namespace geos {
+namespace noding { // geos.noding
+
+class GEOS_DLL GeometryNoder {
+public:
+
+    static std::unique_ptr<geom::Geometry> node(const geom::Geometry& geom);
+
+    GeometryNoder(const geom::Geometry& g);
+
+    std::unique_ptr<geom::Geometry> getNoded();
+
+private:
+
+    const geom::Geometry& argGeom;
+
+    SegmentString::NonConstVect lineList;
+
+    static void extractSegmentStrings(const geom::Geometry& g,
+                                      SegmentString::NonConstVect& to);
+
+    Noder& getNoder();
+
+    std::unique_ptr<Noder> noder;
+
+    std::unique_ptr<geom::Geometry> toGeometry(SegmentString::NonConstVect& noded);
+
+    GeometryNoder(GeometryNoder const&); /*= delete*/
+    GeometryNoder& operator=(GeometryNoder const&); /*= delete*/
+};
+
+} // namespace geos.noding
+} // namespace geos
+

package/dist/prebuilt/ios-iphoneos-mt-release/include/geos/noding/IntersectionAdder.h

@@ -0,0 +1,202 @@
+/**********************************************************************
+ *
+ * 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/IntersectionAdder.java rev. 1.6 (JTS-1.9)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <vector>
+#include <iostream>
+#include <cstdlib> // for abs()
+
+#include <geos/geom/Coordinate.h>
+#include <geos/noding/SegmentIntersector.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace noding {
+class SegmentString;
+}
+namespace algorithm {
+class LineIntersector;
+}
+}
+
+namespace geos {
+namespace noding { // geos.noding
+
+/** \brief
+ * Computes the intersections between two line segments in SegmentString
+ * and adds them to each string.
+ *
+ * The SegmentIntersector is passed to a Noder.
+ * The NodedSegmentString::addIntersections(algorithm::LineIntersector* li, std::size_t segmentIndex, std::size_t geomIndex)
+ * method is called whenever the Noder
+ * detects that two SegmentStrings *might* intersect.
+ * This class is an example of the *Strategy* pattern.
+ *
+ */
+class GEOS_DLL IntersectionAdder: public 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;
+    bool hasInterior;
+
+    // the proper intersection point found
+    geom::CoordinateXYZM properIntersectionPoint;
+
+    algorithm::LineIntersector& li;
+    // bool isSelfIntersection;
+    // bool intersectionFound;
+
+    /**
+     * A trivial intersection is an apparent self-intersection which
+     * in fact is simply the point shared by adjacent line segments.
+     * Note that closed edges require a special check for the point
+     * shared by the beginning and end segments.
+     */
+    bool isTrivialIntersection(const SegmentString* e0, std::size_t segIndex0,
+                               const SegmentString* e1, std::size_t segIndex1);
+
+    // Declare type as noncopyable
+    IntersectionAdder(const IntersectionAdder& other) = delete;
+    IntersectionAdder& operator=(const IntersectionAdder& rhs) = delete;
+
+public:
+
+    int numIntersections;
+    int numInteriorIntersections;
+    int numProperIntersections;
+
+    // testing only
+    int numTests;
+
+    IntersectionAdder(algorithm::LineIntersector& newLi)
+        :
+        hasIntersectionVar(false),
+        hasProper(false),
+        hasProperInterior(false),
+        hasInterior(false),
+        properIntersectionPoint(),
+        li(newLi),
+        numIntersections(0),
+        numInteriorIntersections(0),
+        numProperIntersections(0),
+        numTests(0)
+    {}
+
+    algorithm::LineIntersector&
+    getLineIntersector()
+    {
+        return li;
+    }
+
+    /**
+     * @return the proper intersection point, or `Coordinate::getNull()`
+     *         if none was found
+     */
+    const geom::CoordinateXYZM&
+    getProperIntersectionPoint()
+    {
+        return properIntersectionPoint;
+    }
+
+    bool
+    hasIntersection()
+    {
+        return hasIntersectionVar;
+    }
+
+    /** \brief
+     * 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()
+    {
+        return hasProper;
+    }
+
+    /** \brief
+     * A proper interior intersection is a proper intersection which is
+     * *not* contained in the set of boundary nodes set for this SegmentIntersector.
+     */
+    bool
+    hasProperInteriorIntersection()
+    {
+        return hasProperInterior;
+    }
+
+    /** \brief
+     * An interior intersection is an intersection which is
+     * in the interior of some segment.
+     */
+    bool
+    hasInteriorIntersection()
+    {
+        return hasInterior;
+    }
+
+
+    /** \brief
+     * This method is called by clients of the SegmentIntersector class to
+     * process intersections for two segments of the SegmentStrings 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;
+
+
+    static bool
+    isAdjacentSegments(std::size_t i1, std::size_t i2)
+    {
+        return (i1 > i2 ? i1 - i2 : i2 - i1) == 1;
+    }
+
+    /** \brief
+     * Always process all intersections.
+     *
+     * @return false always
+     */
+    bool
+    isDone() const override
+    {
+        return false;
+    }
+};
+
+
+} // namespace geos.noding
+} // namespace geos
+

package/dist/prebuilt/ios-iphoneos-mt-release/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/ios-iphoneos-mt-release/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. performs 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
+