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

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/algorithm/hull/ConcaveHull.h

@@ -1,317 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2021 Paul Ramsey <pramsey@cleverelephant.ca>
- *
- * 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/Triangle.h>
-#include <geos/triangulate/tri/Tri.h>
-#include <geos/triangulate/tri/TriList.h>
-#include <geos/triangulate/quadedge/TriangleVisitor.h>
-#include <geos/algorithm/hull/HullTri.h>
-
-#include <queue>
-#include <deque>
-
-namespace geos {
-namespace geom {
-class Coordinate;
-class Geometry;
-class GeometryFactory;
-}
-namespace triangulate {
-namespace quadedge {
-class Quadedge;
-class QuadEdgeSubdivision;
-}
-}
-}
-
-using geos::geom::Coordinate;
-using geos::geom::Geometry;
-using geos::geom::GeometryFactory;
-using geos::geom::Triangle;
-using geos::triangulate::quadedge::QuadEdge;
-using geos::triangulate::quadedge::QuadEdgeSubdivision;
-using geos::triangulate::quadedge::TriangleVisitor;
-using geos::triangulate::tri::Tri;
-using geos::triangulate::tri::TriList;
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-namespace hull {      // geos::algorithm::hull
-
-
-typedef std::priority_queue<HullTri*, std::vector<HullTri*>, HullTri::HullTriCompare> HullTriQueue;
-
-
-/**
-* Constructs a concave hull of a set of points.
-* The hull is constructed by removing border triangles
-* of the Delaunay Triangulation of the points
-* as long as their "size" is larger than the target criterion.
-* The target criteria are:
-*
-*  * Maximum Edge Length Ratio - determines the Maximum Edge Length
-*    by a fraction of the difference between
-*    the longest and shortest edge lengths
-*    in the Delaunay Triangulation. This normalizes the
-*    Maximum Edge Length to be scale-independent.
-*  * Maximum Area Ratio - the ratio of the concave hull area to the convex
-*    hull area will be no larger than this value
-*  * Alpha - produces Alpha-shapes, by removing border triangles
-*    with a circumradius greater than alpha.
-*    Large values produce the convex hull; a value of 0
-*    produces maximum concaveness.
-*
-* The preferred criterium is the Maximum Edge Length Ratio, since it is
-* scale-free and local (so that no assumption needs to be made about the
-* total amount of concavity present.
-*
-* Other length criteria can be used by setting the Maximum Edge Length.
-* For example, use a length relative  to the longest edge length
-* in the Minimum Spanning Tree of the point set.
-* Or, use a length derived from the uniformGridEdgeLength() value.
-*
-* The computed hull is always a single connected geom::Polygon
-* (unless it is degenerate, in which case it will be a geom::Point or a geom::LineString).
-* This constraint may cause the concave hull to fail to meet the target criteria.
-*
-* Optionally the concave hull can be allowed
-* to contain holes by calling setHolesAllowed(boolean).
-*
-* @author mdavis
-*/
-class GEOS_DLL ConcaveHull {
-
-public:
-
-    ConcaveHull(const Geometry* geom)
-        : inputGeometry(geom)
-        , maxEdgeLengthRatio(-1.0)
-        , alpha(-1)
-        , isHolesAllowed(false)
-        , criteriaType(PARAM_EDGE_LENGTH)
-        , maxSizeInHull(0.0)
-        , geomFactory(geom->getFactory())
-        {};
-
-    /**
-    * Computes the approximate edge length of
-    * a uniform square grid having the same number of
-    * points as a geometry and the same area as its convex hull.
-    * This value can be used to determine a suitable length threshold value
-    * for computing a concave hull.
-    * A value from 2 to 4 times the uniform grid length
-    * seems to produce reasonable results.
-    *
-    * @param geom a geometry
-    * @return the approximate uniform grid length
-    */
-    static double uniformEdgeLength(const Geometry* geom);
-
-    /**
-    * Computes the concave hull of the vertices in a geometry
-    * using the target criteria of maximum edge length.
-    *
-    * @param geom the input geometry
-    * @param maxLength the target maximum edge length
-    * @return the concave hull
-    */
-    static std::unique_ptr<Geometry> concaveHullByLength(
-        const Geometry* geom, double maxLength);
-
-    static std::unique_ptr<Geometry> concaveHullByLength(
-        const Geometry* geom, double maxLength, bool isHolesAllowed);
-
-    /**
-    * Computes the concave hull of the vertices in a geometry
-    * using the target criteria of maximum edge length ratio.
-    * The edge length ratio is a fraction of the length difference
-    * between the longest and shortest edges
-    * in the Delaunay Triangulation of the input points.
-    *
-    * @param geom the input geometry
-    * @param lengthRatio the target edge length factor
-    * @return the concave hull
-    */
-    static std::unique_ptr<Geometry> concaveHullByLengthRatio(
-        const Geometry* geom, double lengthRatio);
-
-    /**
-    * Computes the concave hull of the vertices in a geometry
-    * using the target criterion of maximum edge length factor,
-    * and optionally allowing holes.
-    * The edge length factor is a fraction of the length difference
-    * between the longest and shortest edges
-    * in the Delaunay Triangulation of the input points.
-    *
-    * @param geom the input geometry
-    * @param lengthRatio the target maximum edge length
-    * @param isHolesAllowed whether holes are allowed in the result
-    * @return the concave hull
-    */
-    static std::unique_ptr<Geometry> concaveHullByLengthRatio(
-        const Geometry* geom,
-        double lengthRatio,
-        bool isHolesAllowed);
-
-    /**
-    * Computes the alpha shape of a geometry as a polygon.
-    * The alpha parameter is the radius of the eroding disc.
-    *
-    * @param geom the input geometry
-    * @param alpha the radius of the eroding disc
-    * @param isHolesAllowed whether holes are allowed in the result
-    * @return the alpha shape polygon
-    */
-    static std::unique_ptr<Geometry> alphaShape(
-        const Geometry* geom,
-        double alpha,
-        bool isHolesAllowed);
-
-    /**
-    * Sets the target maximum edge length for the concave hull.
-    * The length value must be zero or greater.
-    *
-    *  * The value 0.0 produces the concave hull of smallest area
-    *    that is still connected.
-    *  * Larger values produce less concave results.
-    *    A value equal or greater than the longest Delaunay Triangulation edge length
-    *    produces the convex hull.
-    *
-    * The uniformGridEdgeLength value may be used as
-    * the basis for estimating an appropriate target maximum edge length.
-    *
-    * @param edgeLength a non-negative length
-    */
-    void setMaximumEdgeLength(double edgeLength);
-
-    /**
-    * Sets the target maximum edge length ratio for the concave hull.
-    * The edge length ratio is a fraction of the length delta
-    * between the longest and shortest edges
-    * in the Delaunay Triangulation of the input points.
-    * A value of 1.0 produces the convex hull.
-    * A value of 0.0 produces a concave hull of minimum area
-    * that is still connected.
-    *
-    * @param edgeLengthRatio a length ratio value between 0 and 1
-    */
-    void setMaximumEdgeLengthRatio(double edgeLengthRatio);
-
-    /**
-    * Sets whether holes are allowed in the concave hull polygon.
-    *
-    * @param holesAllowed true if holes are allowed in the result
-    */
-    void setHolesAllowed(bool holesAllowed);
-
-    /**
-    * Sets the alpha parameter to compute an alpha shape of the input.
-    * Alpha is the radius of the eroding disc.
-    * Border triangles with circumradius greater than alpha are removed.
-    *
-    * @param newAlpha the alpha radius
-    */
-    void setAlpha(double newAlpha);
-
-    /**
-    * Gets the computed concave hull.
-    *
-    * @return the concave hull
-    */
-    std::unique_ptr<Geometry> getHull();
-
-
-private:
-
-    // Constants
-    static constexpr int PARAM_EDGE_LENGTH = 1;
-    static constexpr int PARAM_ALPHA = 2;
-
-    // Members
-    const Geometry* inputGeometry;
-    double maxEdgeLengthRatio;
-    double alpha;
-    bool isHolesAllowed;
-    int criteriaType;
-    double maxSizeInHull;
-    const GeometryFactory* geomFactory;
-
-    // Methods
-    static double computeTargetEdgeLength(
-        TriList<HullTri>& triList,
-        double edgeLengthFactor);
-
-    void computeHull(TriList<HullTri>& triList);
-    void computeHullBorder(TriList<HullTri>& triList);
-    void createBorderQueue(HullTriQueue& queue, TriList<HullTri>& triList);
-
-    /**
-    * Adds a Tri to the queue.
-    * Only add tris with a single border edge.
-    * since otherwise that would risk isolating a vertex if
-    * the tri ends up being eroded from the hull.
-    * Sets the tri size according to the threshold parameter being used.
-    *
-    * @param tri the Tri to add
-    * @param queue the priority queue
-    */
-    void addBorderTri(HullTri* tri, HullTriQueue& queue);
-    void computeHullHoles(TriList<HullTri>& triList);
-    void setSize(HullTri* tri);
-
-
-    /**
-    * Finds tris which may be the start of holes.
-    * Only tris which have a long enough edge and which do not touch the current hull
-    * boundary are included.
-    * This avoids the risk of disconnecting the result polygon.
-    * The list is sorted in decreasing order of edge length.
-    * The list is sorted in decreasing order of size.
-    *
-    * @param triList
-    * @param maxSizeInHull maximum tri size which is not in a hole
-    * @return
-    */
-    static std::vector<HullTri*> findCandidateHoles(
-        TriList<HullTri>& triList, double maxSizeInHull);
-
-    void removeHole(TriList<HullTri>& triList, HullTri* triHole);
-    void setSize(TriList<HullTri>& triList);
-
-    /**
-    * Tests if a tri is included in the hull.
-    * Tris with size less than the maximum are included in the hull.
-    *
-    * @param tri the tri to test
-    * @return true if the tri is included in the hull
-    */
-    bool isInHull(const HullTri* tri) const;
-
-    bool isRemovableBorder(const HullTri* tri) const;
-    bool isRemovableHole(const HullTri* tri) const;
-
-    std::unique_ptr<Geometry> toGeometry(
-        TriList<HullTri>& triList,
-        const GeometryFactory* factory);
-
-
-};
-
-
-} // geos::algorithm::hull
-} // geos::algorithm
-} // geos
-

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/algorithm/hull/HullTriangulation.h

@@ -1,139 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2021 Paul Ramsey <pramsey@cleverelephant.ca>
- *
- * 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/hull/HullTri.h>
-#include <geos/triangulate/tri/Tri.h>
-#include <geos/triangulate/tri/TriList.h>
-#include <geos/triangulate/quadedge/TriangleVisitor.h>
-
-
-namespace geos {
-namespace geom {
-class Geometry;
-class GeometryFactory;
-class Coordinate;
-}
-namespace triangulate {
-namespace quadedge {
-class QuadEdge;
-class QuadEdgeSubdivision;
-}
-}
-}
-
-using geos::geom::Geometry;
-using geos::geom::GeometryFactory;
-using geos::geom::Coordinate;
-using geos::triangulate::tri::Tri;
-using geos::triangulate::tri::TriList;
-using geos::triangulate::quadedge::QuadEdge;
-using geos::triangulate::quadedge::QuadEdgeSubdivision;
-using geos::triangulate::quadedge::TriangleVisitor;
-
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-namespace hull {      // geos::algorithm::hull
-
-
-class HullTriangulation
-{
-
-private:
-
-    static void toTris(
-        QuadEdgeSubdivision& subdiv,
-        TriList<HullTri>& triList);
-
-    /**
-    * Extracts the coordinates of the edges along the boundary of a triangulation,
-    * by tracing CW around the border triangles.
-    * Assumption: there are at least 2 tris, they are connected,
-    * and there are no holes.
-    * So each tri has at least one non-boundary edge, and there is only one boundary.
-    *
-    * @param triList the triangulation
-    * @return the points in the boundary of the triangulation
-    */
-    static geom::CoordinateSequence traceBoundary(
-        TriList<HullTri>& triList);
-
-    static HullTri* findBorderTri(
-        TriList<HullTri>& triList);
-
-
-
-public:
-
-    HullTriangulation() {};
-
-    static void createDelaunayTriangulation(
-        const Geometry* geom,
-        TriList<HullTri>& triList);
-
-    /**
-    * Creates a Polygon representing the area of a triangulation
-    * which is connected and contains no holes.
-    *
-    * @param triList the triangulation
-    * @param geomFactory the geometry factory to use
-    * @return the area polygon
-    */
-    static std::unique_ptr<Geometry> traceBoundaryPolygon(
-        TriList<HullTri>& triList,
-        const GeometryFactory* factory);
-
-    static HullTri* nextBorderTri(HullTri* triStart);
-
-    /**
-    * Creates a polygonal geometry representing the area of a triangulation
-    * which may be disconnected or contain holes.
-    *
-    * @param triList the triangulation
-    * @param geomFactory the geometry factory to use
-    * @return the area polygonal geometry
-    */
-    static std::unique_ptr<Geometry> geomunion(
-        TriList<HullTri>& triList,
-        const GeometryFactory* factory);
-
-
-    class HullTriVisitor : public TriangleVisitor
-    {
-
-        private:
-
-            TriList<HullTri>& triList;
-
-        public:
-
-            HullTriVisitor(TriList<HullTri>& p_triList)
-                : triList(p_triList)
-                {};
-
-            void visit(std::array<QuadEdge*, 3>& triEdges);
-
-    }; // HullTriVisitor
-
-
-}; // HullTriangulation
-
-
-
-} // geos::algorithm::hull
-} // geos::algorithm
-} // geos
-

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/algorithm/locate/IndexedPointInAreaLocator.h

@@ -1,139 +0,0 @@
-/**********************************************************************
- *
- * 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 byytes.
-            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/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/algorithm/locate/SimplePointInAreaLocator.h

@@ -1,117 +0,0 @@
-/**********************************************************************
- *
- * 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 Polygon;
-}
-}
-
-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 [Polygon](@ref geom::Polygon).
-     *
-     * 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 locatePointInPolygon(const geom::CoordinateXY& p,
-                                               const geom::Polygon* 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
-
-