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

package/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/algorithm/construct/LargestEmptyCircle.h

@@ -0,0 +1,240 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 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.
+ *
+ **********************************************************************
+ *
+ * Last port: algorithm/construct/LargestEmptyCircle.java
+ * https://github.com/locationtech/jts/commit/98274a7ea9b40651e9de6323dc10fb2cac17a245
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Point.h>
+#include <geos/geom/Envelope.h>
+#include <geos/algorithm/construct/IndexedDistanceToPoint.h>
+#include <geos/algorithm/locate/IndexedPointInAreaLocator.h>
+#include <geos/operation/distance/IndexedFacetDistance.h>
+
+#include <memory>
+#include <queue>
+
+namespace geos {
+namespace geom {
+class Coordinate;
+class Envelope;
+class Geometry;
+class GeometryFactory;
+class LineString;
+class Point;
+}
+}
+
+using geos::operation::distance::IndexedFacetDistance;
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+namespace construct { // geos::algorithm::construct
+
+/**
+* Constructs the Largest Empty Circle for a set of obstacle geometries,
+* up to a specified tolerance. 
+* The obstacles may be any combination of point, linear and polygonal geometries.
+*
+* The Largest Empty Circle (LEC) is the largest circle 
+* whose interior does not intersect with any obstacle
+* and whose center lies within a polygonal boundary.
+* The circle center is the point in the interior of the boundary 
+* which has the farthest distance from the obstacles 
+* (up to the accuracy of the distance tolerance).
+* The circle itself is determined by the center point
+* and a point lying on an obstacle determining the circle radius.
+* 
+* The polygonal boundary may be supplied explicitly.
+* If it is not specified the convex hull of the obstacles is used as the boundary.
+* 
+* To compute an LEC which lies wholly within
+* a polygonal boundary, include the boundary of the polygon(s) as an obstacle.
+*
+* The implementation uses a successive-approximation technique
+* over a grid of square cells covering the obstacles and boundary.
+* The grid is refined using a branch-and-bound algorithm. Point
+* containment and distance are computed in a performant way
+* by using spatial indexes.
+*
+* \author Martin Davis
+*/
+class GEOS_DLL LargestEmptyCircle {
+
+public:
+
+    /**
+    * Creates a new instance of a Largest Empty Circle construction.
+    * The obstacles may be any collection of points, lines and polygons.
+    * The constructed circle center lies within the convex hull of the obstacles.
+    *
+    * @param p_obstacles a geometry representing the obstacles
+    * @param p_tolerance the distance tolerance for computing the circle center point
+    */
+    LargestEmptyCircle(const geom::Geometry* p_obstacles, double p_tolerance);
+
+    /**
+    * Creates a new instance of a Largest Empty Circle construction,
+    * interior-disjoint to a set of obstacle geometries 
+    * and having its center within a polygonal boundary.
+    * The obstacles may be any collection of points, lines and polygons.
+    * If the boundary is null or empty the convex hull
+    * of the obstacles is used as the boundary.
+    *
+    * @param p_obstacles a geometry representing the obstacles
+    * @param p_boundary a polygonal geometry to contain the LEC center
+    * @param p_tolerance the distance tolerance for computing the circle center point
+    */
+    LargestEmptyCircle(const geom::Geometry* p_obstacles, const geom::Geometry* p_boundary, double p_tolerance);
+
+    ~LargestEmptyCircle() = default;
+
+    /**
+    * Computes the center point of the Largest Empty Circle
+    * within a set of obstacles, up to a given tolerance distance.
+    * The obstacles may be any collection of points, lines and polygons.
+    *
+    * @param p_obstacles a geometry representing the obstacles
+    * @param p_tolerance the distance tolerance for computing the center point
+    * @return the center point of the Largest Empty Circle
+    */
+    static std::unique_ptr<geom::Point> getCenter(const geom::Geometry* p_obstacles, double p_tolerance);
+
+    /**
+    * Computes a radius line of the Largest Empty Circle
+    * within a set of obstacles, up to a given distance tolerance.
+    * The obstacles may be any collection of points, lines and polygons.
+    *
+    * @param p_obstacles a geometry representing the obstacles
+    * @param p_tolerance the distance tolerance for computing the center point
+    * @return a line from the center of the circle to a point on the edge
+    */
+    static std::unique_ptr<geom::LineString> getRadiusLine(const geom::Geometry* p_obstacles, double p_tolerance);
+
+    std::unique_ptr<geom::Point> getCenter();
+    std::unique_ptr<geom::Point> getRadiusPoint();
+    std::unique_ptr<geom::LineString> getRadiusLine();
+
+
+private:
+
+    /* private members */
+    double tolerance;
+    const geom::Geometry* obstacles;
+    std::unique_ptr<geom::Geometry> boundary;
+    const geom::GeometryFactory* factory;
+    geom::Envelope gridEnv;
+    bool done;
+    std::unique_ptr<algorithm::locate::IndexedPointInAreaLocator> boundaryPtLocater;
+    IndexedDistanceToPoint obstacleDistance;
+    std::unique_ptr<IndexedFacetDistance> boundaryDistance;
+    geom::CoordinateXY centerPt;
+    geom::CoordinateXY radiusPt;
+
+    /**
+    * Computes the signed distance from a point to the constraints
+    * (obstacles and boundary).
+    * Points outside the boundary polygon are assigned a negative distance.
+    * Their containing cells will be last in the priority queue
+    * (but will still end up being tested since they may be refined).
+    *
+    * @param c the point to compute the distance for
+    * @return the signed distance to the constraints (negative indicates outside the boundary)
+    */
+    double distanceToConstraints(const geom::Coordinate& c);
+    double distanceToConstraints(double x, double y);
+    void initBoundary();
+    void compute();
+
+    /* private class */
+    class Cell {
+    private:
+        static constexpr double SQRT2 = 1.4142135623730951;
+        double x;
+        double y;
+        double hSize;
+        double distance;
+        double maxDist;
+
+    public:
+        Cell(double p_x, double p_y, double p_hSize, double p_distanceToConstraints)
+            : x(p_x)
+            , y(p_y)
+            , hSize(p_hSize)
+            , distance(p_distanceToConstraints)
+            , maxDist(p_distanceToConstraints + (p_hSize*SQRT2))
+        {};
+
+        geom::Envelope getEnvelope() const
+        {
+            geom::Envelope env(x-hSize, x+hSize, y-hSize, y+hSize);
+            return env;
+        }
+
+        bool isFullyOutside() const
+        {
+            return maxDist < 0.0;
+        }
+        bool isOutside() const
+        {
+            return distance < 0.0;
+        }
+        double getMaxDistance() const
+        {
+            return maxDist;
+        }
+        double getDistance() const
+        {
+            return distance;
+        }
+        double getHSize() const
+        {
+            return hSize;
+        }
+        double getX() const
+        {
+            return x;
+        }
+        double getY() const
+        {
+            return y;
+        }
+        bool operator< (const Cell& rhs) const
+        {
+            return maxDist < rhs.maxDist;
+        }
+        bool operator> (const Cell& rhs) const
+        {
+            return maxDist > rhs.maxDist;
+        }
+        bool operator==(const Cell& rhs) const
+        {
+            return maxDist == rhs.maxDist;
+        }
+    };
+
+    bool mayContainCircleCenter(const Cell& cell, const Cell& farthestCell);
+    void createInitialGrid(const geom::Envelope* env, std::priority_queue<Cell>& cellQueue);
+    Cell createCentroidCell(const geom::Geometry* geom);
+
+};
+
+
+} // geos::algorithm::construct
+} // geos::algorithm
+} // geos

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

@@ -0,0 +1,309 @@
+/**********************************************************************
+ *
+ * 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);
+
+    /**
+    * 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/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/algorithm/hull/HullTriangulation.h

@@ -0,0 +1,139 @@
+/**********************************************************************
+ *
+ * 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) override;
+
+    }; // HullTriVisitor
+
+
+}; // HullTriangulation
+
+
+
+} // geos::algorithm::hull
+} // geos::algorithm
+} // geos
+