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

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/locate/IndexedPointInAreaLocator.h

@@ -0,0 +1,139 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2006 Refractions Research Inc.
+ * Copyright (C) 2018 Daniel Baston <dbaston@gmail.com>
+ *
+ * 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/geom/LineSegment.h>
+#include <geos/algorithm/locate/PointOnGeometryLocator.h> // inherited
+#include <geos/index/ItemVisitor.h> // inherited
+#include <geos/index/strtree/TemplateSTRtree.h>
+
+#include <memory>
+#include <vector> // composition
+
+namespace geos {
+namespace algorithm {
+class RayCrossingCounter;
+}
+namespace geom {
+class Geometry;
+class Coordinate;
+class CoordinateSequence;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+namespace locate { // geos::algorithm::locate
+
+/** \brief
+ * Determines the location of [Coordinates](@ref geom::Coordinate) relative to
+ * an areal geometry, using indexing for efficiency.
+ *
+ * The Location is computed precisely, in that points located on the geometry boundary
+ * or segments will return [geom::Location::BOUNDARY](@ref geom::Location).
+ *
+ * Polygonal and [LinearRing](@ref geom::LinearRing) geometries are supported.
+ *
+ * The index is lazy-loaded, which allows creating instances even if they are not used.
+ *
+ */
+class GEOS_DLL IndexedPointInAreaLocator : public PointOnGeometryLocator {
+private:
+    struct SegmentView {
+        SegmentView(const geom::CoordinateXY* p0, const geom::CoordinateXY* p1) {
+            // There is a significant performance benefit in fitting our
+            // line segment into 8 bytes (about 15-20%). Because we know that
+            // p1 follows p0 in a CoordinateSequence, we know that the address
+            // of p1 is 16, 24, or 32 bytes greater than the address of p0.
+            // By packing this offset into the least significant bits of p0,
+            // we can retrieve both p0 and p1 while only using 8 bytes.
+            std::size_t os = static_cast<std::size_t>(reinterpret_cast<const double*>(p1) - reinterpret_cast<const double*>(p0)) - 2u;
+            m_p0 = reinterpret_cast<std::size_t>(p0) | os;
+
+            assert(&this->p0() == p0);
+            assert(&this->p1() == p1);
+        }
+
+        const geom::CoordinateXY& p0() const {
+            auto ret = reinterpret_cast<const geom::CoordinateXY*>(m_p0 >> 2 << 2);
+            return *ret;
+        }
+
+        const geom::CoordinateXY& p1() const {
+            auto offset = (m_p0 & 0x03) + 2;
+            auto ret = reinterpret_cast<const geom::CoordinateXY*>(reinterpret_cast<double*>(m_p0 >> 2 << 2) + offset);
+            return *ret;
+        }
+
+        std::size_t m_p0;
+    };
+
+    class IntervalIndexedGeometry {
+    private:
+
+        index::strtree::TemplateSTRtree<SegmentView, index::strtree::IntervalTraits> index;
+
+        void init(const geom::Geometry& g);
+        void addLine(const geom::CoordinateSequence* pts);
+
+    public:
+        IntervalIndexedGeometry(const geom::Geometry& g);
+
+        template<typename Visitor>
+        void query(double min, double max, Visitor&& f) {
+            index.query(index::strtree::Interval(min, max), f);
+        }
+    };
+
+    const geom::Geometry& areaGeom;
+    std::unique_ptr<IntervalIndexedGeometry> index;
+
+    void buildIndex(const geom::Geometry& g);
+
+    // Declare type as noncopyable
+    IndexedPointInAreaLocator(const IndexedPointInAreaLocator& other) = delete;
+    IndexedPointInAreaLocator& operator=(const IndexedPointInAreaLocator& rhs) = delete;
+
+public:
+    /** \brief
+     * Creates a new locator for a given [Geometry](@ref geom::Geometry).
+     *
+     * Polygonal and [LinearRing](@ref geom::LinearRing) geometries are supported.
+     *
+     * @param g the Geometry to locate in
+     */
+    IndexedPointInAreaLocator(const geom::Geometry& g);
+
+    const geom::Geometry&  getGeometry() const {
+        return areaGeom;
+    }
+
+    /** \brief
+     * Determines the [Location](@ref geom::Location) of a point in an areal
+     * [Geometry](@ref geom::Geometry).
+     *
+     * @param p the point to test
+     * @return the location of the point in the geometry
+     */
+    geom::Location locate(const geom::CoordinateXY* /*const*/ p) override;
+
+};
+
+} // geos::algorithm::locate
+} // geos::algorithm
+} // geos
+

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/locate/SimplePointInAreaLocator.h

@@ -0,0 +1,117 @@
+/**********************************************************************
+ *
+ * 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/algorithm/locate/PointOnGeometryLocator.h> // inherited
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class Coordinate;
+class Surface;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+namespace locate { // geos::algorithm::locate
+
+/** \brief
+ * Computes the location of points relative to a polygonal
+ * [Geometry](@ref geom::Geometry), using a simple `O(n)` algorithm.
+ *
+ * The algorithm used reports if a point lies in the interior, exterior,
+ * or exactly on the boundary of the Geometry.
+ *
+ * Instance methods are provided to implement the interface `PointInAreaLocator`.
+ * However, they provide no performance advantage over the class methods.
+ *
+ * This algorithm is suitable for use in cases where only a few points will be tested.
+ * If many points will be tested, IndexedPointInAreaLocator may provide better performance.
+ */
+class GEOS_DLL SimplePointInAreaLocator : public PointOnGeometryLocator {
+
+public:
+
+    static geom::Location locate(const geom::CoordinateXY& p,
+                                 const geom::Geometry* geom);
+
+    /** \brief
+     * Determines the Location of a point in a [Surface](@ref geom::Surface).
+     *
+     * The return value is one of:
+     *
+     * - geom::Location::INTERIOR
+     *   if the point is in the geometry interior
+     * - geom::Location::BOUNDARY
+     *   if the point lies exactly on the boundary
+     * - geom::Location::EXTERIOR
+     *   if the point is outside the geometry
+     *
+     * Computes `geom::Location::BOUNDARY` if the point lies exactly
+     * on the polygon boundary.
+     *
+     * @param p the point to test
+     * @param poly the geometry to test
+     * @return the Location of the point in the polygon
+     */
+    static geom::Location locatePointInSurface(const geom::CoordinateXY& p,
+                                               const geom::Surface& poly);
+
+    /** \brief
+     * Determines whether a point is contained in a [Geometry](@ref geom::Geometry),
+     * or lies on its boundary.
+     *
+     * This is a convenience method for
+     *
+     *      Location::EXTERIOR != locate(p, geom)
+     *
+     * @param p the point to test
+     * @param geom the geometry to test
+     * @return true if the point lies in or on the geometry
+     */
+    static bool isContained(const geom::CoordinateXY& p,
+                            const geom::Geometry* geom);
+
+    SimplePointInAreaLocator(const geom::Geometry* p_g)
+        : g(p_g)
+    { }
+
+    SimplePointInAreaLocator(const geom::Geometry& p_g)
+        : g(&p_g)
+    { }
+
+    geom::Location
+    locate(const geom::CoordinateXY* p) override
+    {
+        return locate(*p, g);
+    }
+
+private:
+
+    static geom::Location locateInGeometry(const geom::CoordinateXY& p,
+                                           const geom::Geometry* geom);
+
+    const geom::Geometry* g;
+
+};
+
+} // geos::algorithm::locate
+} // geos::algorithm
+} // geos
+
+

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/constants.h

@@ -0,0 +1,49 @@
+/**********************************************************************
+ *
+ * constants.h
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2018 Vicky Vergara
+ * Copyright (C) 2009 Mateusz Loskot
+ * Copyright (C) 2005-2009 Refractions Research Inc.
+ * Copyright (C) 2001-2009 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
+
+#ifdef _MSC_VER
+#ifndef NOMINMAX
+#define NOMINMAX 1
+typedef __int64 int64;
+#endif
+#endif
+
+#include <cmath>
+#include <limits>
+#include <cinttypes>
+#include <cstddef> // for std::size_t
+
+namespace geos {
+
+constexpr double MATH_PI = 3.14159265358979323846;
+
+// Some handy constants
+constexpr double DoubleNotANumber = std::numeric_limits<double>::quiet_NaN();
+constexpr double DoubleMax = (std::numeric_limits<double>::max)();
+constexpr double DoubleInfinity = (std::numeric_limits<double>::infinity)();
+constexpr double DoubleNegInfinity = (-(std::numeric_limits<double>::infinity)());
+constexpr double DoubleEpsilon = std::numeric_limits<double>::epsilon();
+
+constexpr std::size_t NO_COORD_INDEX = std::numeric_limits<std::size_t>::max();
+constexpr std::size_t INDEX_UNKNOWN = std::numeric_limits<std::size_t>::max();
+
+} // namespace geos
+

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/coverage/CoverageRingEdges.h

@@ -0,0 +1,170 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2023 Paul Ramsey <pramsey@cleverelephant.ca>
+ * Copyright (c) 2023 Martin Davis.
+ *
+ * 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/geom/Coordinate.h>
+#include <geos/geom/LineSegment.h>
+#include <geos/coverage/CoverageEdge.h> // to materialize CoverageEdge
+
+#include <set>
+#include <map>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+class Geometry;
+class LinearRing;
+class MultiPolygon;
+class Polygon;
+}
+namespace coverage {
+class CoverageEdge;
+}
+}
+
+using geos::geom::Coordinate;
+using geos::geom::CoordinateSequence;
+using geos::geom::Geometry;
+using geos::geom::LinearRing;
+using geos::geom::LineSegment;
+using geos::geom::MultiPolygon;
+using geos::geom::Polygon;
+
+namespace geos {     // geos
+namespace coverage { // geos.coverage
+
+/**
+ * Models a polygonal coverage as a set of unique {@link CoverageEdge}s,
+ * linked to the parent rings in the coverage polygons.
+ * Each edge has either one or two parent rings, depending on whether
+ * it is an inner or outer edge of the coverage.
+ * The source coverage is represented as a array of polygonal geometries
+ * (either {@link geos::geom::Polygon}s or {@link geos::geom::MultiPolygon}s).
+ *
+ * @author Martin Davis
+ */
+class GEOS_DLL CoverageRingEdges {
+
+private:
+
+    // Members
+    const std::vector<const Geometry*>& m_coverage;
+    std::map<const LinearRing*, std::vector<CoverageEdge*>> m_ringEdgesMap;
+    std::vector<CoverageEdge*> m_edges;
+    std::vector<std::unique_ptr<CoverageEdge>> m_edgeStore;
+
+    /* Turn off copy constructors for MSVC */
+    CoverageRingEdges(const CoverageRingEdges&) = delete;
+    CoverageRingEdges& operator=(const CoverageRingEdges&) = delete;
+
+public:
+
+    CoverageRingEdges(const std::vector<const Geometry*>& coverage)
+        : m_coverage(coverage)
+    {
+        build();
+    };
+
+
+    std::vector<CoverageEdge*>& getEdges()
+    {
+        return m_edges;
+    };
+
+    /**
+    * Selects the edges with a given ring count (which can be 1 or 2).
+    *
+    * @param ringCount the edge ring count to select (1 or 2)
+    * @return the selected edges
+    */
+    std::vector<CoverageEdge*> selectEdges(
+        std::size_t ringCount) const;
+
+    /**
+    * Recreates the polygon coverage from the current edge values.
+    *
+    * @return an array of polygonal geometries representing the coverage
+    */
+    std::vector<std::unique_ptr<Geometry>> buildCoverage() const;
+
+
+private:
+
+    void build();
+
+    void addRingEdges(
+        const LinearRing* ring,
+        Coordinate::UnorderedSet& nodes,
+        LineSegment::UnorderedSet& boundarySegs,
+        std::map<LineSegment, CoverageEdge*>& uniqueEdgeMap);
+
+    void addBoundaryInnerNodes(
+        const LinearRing* ring,
+        LineSegment::UnorderedSet& boundarySegs,
+        Coordinate::UnorderedSet& nodes);
+
+    std::vector<CoverageEdge*> extractRingEdges(
+        const LinearRing* ring,
+        std::map<LineSegment, CoverageEdge*>& uniqueEdgeMap,
+        Coordinate::UnorderedSet& nodes);
+
+    CoverageEdge* createEdge(
+        const CoordinateSequence& ring,
+        std::map<LineSegment, CoverageEdge*>& uniqueEdgeMap);
+
+    CoverageEdge* createEdge(
+        const CoordinateSequence& ring,
+        std::size_t start, std::size_t end,
+        std::map<LineSegment, CoverageEdge*>& uniqueEdgeMap);
+
+    std::size_t findNextNodeIndex(
+        const CoordinateSequence& ring,
+        std::size_t start,
+        Coordinate::UnorderedSet& nodes) const;
+
+    static std::size_t next(
+        std::size_t index,
+        const CoordinateSequence& ring);
+
+    Coordinate::UnorderedSet findMultiRingNodes(
+        const std::vector<const Geometry*>& coverage);
+
+    Coordinate::UnorderedSet findBoundaryNodes(
+        LineSegment::UnorderedSet& lineSegments);
+
+    std::unique_ptr<Geometry> buildPolygonal(
+        const Geometry* geom) const;
+
+    std::unique_ptr<Geometry> buildMultiPolygon(
+        const MultiPolygon* geom) const;
+
+    std::unique_ptr<Polygon> buildPolygon(
+        const Polygon* polygon) const;
+
+    std::unique_ptr<LinearRing> buildRing(
+        const LinearRing* ring) const;
+
+    bool isEdgeDirForward(
+        const std::vector<CoverageEdge*>& ringEdges,
+        std::size_t index,
+        const Coordinate& prevPt) const;
+
+
+};
+
+} // namespace geos.coverage
+} // namespace geos

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/coverage/CoverageSimplifier.h

@@ -0,0 +1,166 @@
+
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2023 Paul Ramsey <pramsey@cleverelephant.ca>
+ * Copyright (c) 2023 Martin Davis.
+ *
+ * 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 <memory>
+#include <geos/export.h>
+
+
+namespace geos {
+namespace geom {
+class Geometry;
+class GeometryFactory;
+class MultiLineString;
+}
+namespace coverage {
+class CoverageEdge;
+}
+}
+
+
+using geos::coverage::CoverageEdge;
+using geos::geom::Geometry;
+using geos::geom::GeometryFactory;
+using geos::geom::MultiLineString;
+
+
+namespace geos {
+namespace coverage { // geos::coverage
+
+/**
+ * Simplifies the boundaries of the polygons in a polygonal coverage
+ * while preserving the original coverage topology.
+ * An area-based simplification algorithm
+ * (similar to Visvalingam-Whyatt simplification)
+ * is used to provide high-quality results.
+ * Also supports simplifying just the inner edges in a coverage,
+ * which allows simplifying "patches" without affecting their boundary.
+ *
+ * The amount of simplification is determined by a tolerance value,
+ * which is a non-negative quantity. It equates roughly to the maximum
+ * distance by which a simplified line can change from the original.
+ * (In fact, it is the square root of the area tolerance used
+ * in the Visvalingam-Whyatt algorithm.)
+ *
+ * The simplified result coverage has the following characteristics:
+ *
+ *   * It has the same number and types of polygonal geometries as the input
+ *   * Node points (inner vertices shared by three or more polygons,
+ *     or boundary vertices shared by two or more) are not changed
+ *   * If the input is a valid coverage, then so is the result
+ *
+ * This class also supports inner simplification, which simplifies
+ * only edges of the coverage which are adjacent to two polygons.
+ * This allows partial simplification of a coverage, since a simplified
+ * subset of a coverage still matches the remainder of the coverage.
+ *
+ * The input coverage should be valid according to {@link CoverageValidator}.
+ *
+ * @author Martin Davis
+ */
+class GEOS_DLL CoverageSimplifier {
+
+
+public:
+
+    /**
+    * Create a new coverage simplifier instance.
+    *
+    * @param coverage a set of polygonal geometries forming a coverage
+    */
+    CoverageSimplifier(const std::vector<const Geometry*>& coverage);
+
+    /**
+    * Simplifies the boundaries of a set of polygonal geometries forming a coverage,
+    * preserving the coverage topology.
+    *
+    * @param coverage a set of polygonal geometries forming a coverage
+    * @param tolerance the simplification tolerance
+    * @return the simplified polygons
+    */
+    static std::vector<std::unique_ptr<Geometry>> simplify(
+        std::vector<const Geometry*>& coverage,
+        double tolerance);
+
+    static std::vector<std::unique_ptr<Geometry>> simplify(
+        const std::vector<std::unique_ptr<Geometry>>& coverage,
+        double tolerance);
+
+    /**
+    * Simplifies the inner boundaries of a set of polygonal geometries forming a coverage,
+    * preserving the coverage topology.
+    * Edges which form the exterior boundary of the coverage are left unchanged.
+    *
+    * @param coverage a set of polygonal geometries forming a coverage
+    * @param tolerance the simplification tolerance
+    * @return the simplified polygons
+    */
+    static std::vector<std::unique_ptr<Geometry>> simplifyInner(
+        std::vector<const Geometry*>& coverage,
+        double tolerance);
+
+    static std::vector<std::unique_ptr<Geometry>> simplifyInner(
+        const std::vector<std::unique_ptr<Geometry>>& coverage,
+        double tolerance);
+
+    /**
+    * Computes the simplified coverage, preserving the coverage topology.
+    *
+    * @param tolerance the simplification tolerance
+    * @return the simplified polygons
+    */
+    std::vector<std::unique_ptr<Geometry>> simplify(
+        double tolerance);
+
+    /**
+    * Computes the inner-boundary simplified coverage,
+    * preserving the coverage topology,
+    * and leaving outer boundary edges unchanged.
+    *
+    * @param tolerance the simplification tolerance
+    * @return the simplified polygons
+    */
+    std::vector<std::unique_ptr<Geometry>> simplifyInner(
+        double tolerance);
+
+
+private:
+
+    // Members
+    const std::vector<const Geometry*>& m_input;
+    const GeometryFactory* m_geomFactory;
+
+    // Methods
+    void simplifyEdges(
+        std::vector<CoverageEdge*> edges,
+        const MultiLineString* constraints,
+        double tolerance);
+
+    void setCoordinates(
+        std::vector<CoverageEdge*>& edges,
+        const MultiLineString* lines);
+
+    std::vector<bool> getFreeRings(
+        const std::vector<CoverageEdge*>& edges) const;
+
+
+}; // CoverageSimplifier
+
+
+} // geos::coverage
+} // geos