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

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

@@ -0,0 +1,171 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (c) Martin Davis 2022
+ *
+ * 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/Noder.h>     // for composition
+#include <geos/noding/SegmentString.h>     // for composition
+#include <geos/geom/LineSegment.h> // for composition
+
+#include <unordered_set>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+class Coordinate;
+}
+namespace noding {
+class NodedSegmentString;
+}
+}
+
+using geos::geom::Coordinate;
+
+namespace geos {   // geos
+namespace noding { // geos::noding
+
+/**
+ * A noder which extracts chains of boundary segments
+ * as SegmentStrings from a polygonal coverage.
+ * Boundary segments are those which are not duplicated in the input polygonal coverage.
+ * Extracting chains of segments minimize the number of segment strings created,
+ * which produces a more efficient topological graph structure.
+ * <p>
+ * This enables fast overlay of polygonal coverages in CoverageUnion.
+ * Using this noder is faster than SegmentExtractingNoder
+ * and BoundarySegmentNoder.
+ * <p>
+ * No precision reduction is carried out.
+ * If that is required, another noder must be used (such as a snap-rounding noder),
+ * or the input must be precision-reduced beforehand.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL BoundaryChainNoder : public Noder {
+
+private:
+
+    class BoundarySegmentMap {
+
+        private:
+
+            // Members
+            SegmentString* segString;
+            std::vector<bool> isBoundary;
+
+            static SegmentString* createChain(
+                const SegmentString* segString,
+                std::size_t startIndex,
+                std::size_t endIndex,
+                bool constructZ,
+                bool constructM);
+
+            std::size_t findChainStart(std::size_t index) const;
+            std::size_t findChainEnd(std::size_t index) const;
+
+        public:
+
+            BoundarySegmentMap(SegmentString* ss)
+                : segString(ss) {
+                    isBoundary.resize(ss->size()-1, false);
+                };
+
+            void setBoundarySegment(std::size_t index);
+            void createChains(std::vector<SegmentString*>& chainList, bool constructZ, bool constructM);
+    };
+
+    class Segment {
+    public:
+        Segment(const geom::CoordinateSequence& seq,
+            BoundarySegmentMap& segMap,
+            std::size_t index)
+            : m_seq(seq)
+            , m_segMap(segMap)
+            , m_index(index)
+            , m_flip(seq.getAt<geom::CoordinateXY>(index).compareTo(seq.getAt<geom::CoordinateXY>(index + 1)) < 0)
+        {}
+
+        const geom::CoordinateXY& p0() const {
+            return m_seq.getAt<geom::CoordinateXY>(m_flip ? m_index : m_index + 1);
+        }
+
+        const geom::CoordinateXY& p1() const {
+            return m_seq.getAt<geom::CoordinateXY>(m_flip ? m_index + 1 : m_index);
+        }
+
+        void markInBoundary() const {
+            m_segMap.setBoundarySegment(m_index);
+        };
+
+        bool operator==(const Segment& other) const {
+            return p0().equals2D(other.p0()) && p1().equals2D(other.p1());
+        }
+
+        struct HashCode {
+            std::size_t operator()(const Segment& s) const {
+                std::size_t h = std::hash<double>{}(s.p0().x);
+                h ^= (std::hash<double>{}(s.p0().y) << 1);
+                h ^= (std::hash<double>{}(s.p1().x) << 1);
+                h ^= (std::hash<double>{}(s.p1().y) << 1);
+                return h;
+            }
+        };
+
+    private:
+        const geom::CoordinateSequence& m_seq;
+        BoundarySegmentMap& m_segMap;
+        std::size_t m_index;
+        bool m_flip;
+    };
+
+public:
+    using SegmentSet = std::unordered_set<Segment, Segment::HashCode>;
+
+    BoundaryChainNoder() : chainList(nullptr), m_constructZ(false), m_constructM(false) {};
+
+    // Noder virtual methods
+    std::vector<SegmentString*>* getNodedSubstrings() const override;
+    void computeNodes(std::vector<SegmentString*>* inputSegStrings) override;
+
+
+private:
+
+    // Members
+    std::vector<SegmentString*>* chainList;
+    bool m_constructZ;
+    bool m_constructM;
+
+    // Methods
+    void addSegments(std::vector<SegmentString*>* segStrings,
+        SegmentSet& segSet,
+        std::vector<BoundarySegmentMap>& includedSegs);
+
+    static void addSegments(SegmentString* segString,
+        BoundarySegmentMap& segInclude,
+        SegmentSet& segSet);
+
+    static void markBoundarySegments(SegmentSet& segSet);
+
+    std::vector<SegmentString*>* extractChains(std::vector<BoundarySegmentMap>& sections) const;
+
+    static bool segSetContains(SegmentSet& segSet, Segment& seg);
+
+};
+
+} // namespace geos::noding
+} // namespace geos
+
+

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