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

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/noding/BoundaryChainNoder.h

@@ -1,171 +0,0 @@
-/**********************************************************************
- *
- * 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/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/noding/FastNodingValidator.h

@@ -1,129 +0,0 @@
-/**********************************************************************
- *
- * 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/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/noding/FastSegmentSetIntersectionFinder.h

@@ -1,80 +0,0 @@
-/**********************************************************************
- *
- * 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/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/noding/GeometryNoder.h

@@ -1,69 +0,0 @@
-/**********************************************************************
- *
- * 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/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/noding/IntersectionAdder.h

@@ -1,202 +0,0 @@
-/**********************************************************************
- *
- * 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
-