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

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/construct/LargestEmptyCircle.h

@@ -0,0 +1,219 @@
+/**********************************************************************
+ *
+ * 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/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;
+}
+namespace operation {
+namespace distance {
+class 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 are point and line geometries.
+*
+* The Largest Empty Circle is the largest circle which has its center
+* in the convex hull of the obstacles (the boundary), and whose
+* interior does not intersect with any obstacle. The circle center
+* is the point in the interior of the boundary which has the
+* farthest distance from the obstacles (up to tolerance).
+* The circle is determined by the center point and a point lying
+* on an obstacle indicating the circle radius.
+*
+* 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.
+    *
+    * @param p_obstacles a geometry representing the obstacles (points and lines)
+    * @param p_tolerance the distance tolerance for computing the circle center point
+    */
+    LargestEmptyCircle(const geom::Geometry* p_obstacles, double p_tolerance);
+    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.
+    *
+    * @param p_obstacles a geometry representing the obstacles (points and lines)
+    * @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.
+    *
+    * @param p_obstacles a geometry representing the obstacles (points and lines)
+    * @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;
+    operation::distance::IndexedFacetDistance obstacleDistance;
+    bool done;
+    std::unique_ptr<algorithm::locate::IndexedPointInAreaLocator> ptLocator;
+    std::unique_ptr<operation::distance::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/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/construct/MaximumInscribedCircle.h

@@ -0,0 +1,221 @@
+/**********************************************************************
+ *
+ * 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/MaximumInscribedCircle.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/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::algorithm::locate::IndexedPointInAreaLocator;
+using geos::operation::distance::IndexedFacetDistance;
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+namespace construct { // geos::algorithm::construct
+
+/**
+ * Computes the Euclidean distance (L2 metric) from a Point to a Geometry.
+ *
+ * Also computes two points which are separated by the distance.
+ */
+class GEOS_DLL MaximumInscribedCircle {
+
+public:
+
+    MaximumInscribedCircle(const geom::Geometry* polygonal, double tolerance);
+    ~MaximumInscribedCircle() = default;
+
+    /**
+    * Gets the center point of the maximum inscribed circle
+    * (up to the tolerance distance).
+    *
+    * @return the center point of the maximum inscribed circle
+    */
+    std::unique_ptr<geom::Point> getCenter();
+
+    /**
+    * Gets a point defining the radius of the Maximum Inscribed Circle.
+    * This is a point on the boundary which is
+    * nearest to the computed center of the Maximum Inscribed Circle.
+    * The line segment from the center to this point
+    * is a radius of the constructed circle, and this point
+    * lies on the boundary of the circle.
+    *
+    * @return a point defining the radius of the Maximum Inscribed Circle
+    */
+    std::unique_ptr<geom::Point> getRadiusPoint();
+
+    /**
+    * Gets a line representing a radius of the Largest Empty Circle.
+    *
+    * @return a line from the center of the circle to a point on the edge
+    */
+    std::unique_ptr<geom::LineString> getRadiusLine();
+
+    /**
+    * Computes the center point of the Maximum Inscribed Circle
+    * of a polygonal geometry, up to a given tolerance distance.
+    *
+    * @param polygonal a polygonal geometry
+    * @param tolerance the distance tolerance for computing the center point
+    * @return the center point of the maximum inscribed circle
+    */
+    static std::unique_ptr<geom::Point> getCenter(const geom::Geometry* polygonal, double tolerance);
+
+    /**
+    * Computes a radius line of the Maximum Inscribed Circle
+    * of a polygonal geometry, up to a given tolerance distance.
+    *
+    * @param polygonal a polygonal geometry
+    * @param tolerance the distance tolerance for computing the center point
+    * @return a line from the center to a point on the circle
+    */
+    static std::unique_ptr<geom::LineString> getRadiusLine(const geom::Geometry* polygonal, double tolerance);
+
+    /**
+     * Computes the maximum number of iterations allowed.
+     * Uses a heuristic based on the area of the input geometry
+     * and the tolerance distance.
+     * The number of tolerance-sized cells that cover the input geometry area
+     * is computed, times a safety factor.
+     * This prevents massive numbers of iterations and created cells
+     * for casees where the input geometry has extremely small area
+     * (e.g. is very thin).
+     *
+     * @param geom the input geometry
+     * @param toleranceDist the tolerance distance
+     * @return the maximum number of iterations allowed
+     */
+    static std::size_t computeMaximumIterations(const geom::Geometry* geom, double toleranceDist);
+
+private:
+
+    /* private members */
+    const geom::Geometry* inputGeom;
+    std::unique_ptr<geom::Geometry> inputGeomBoundary;
+    double tolerance;
+    IndexedFacetDistance indexedDistance;
+    IndexedPointInAreaLocator ptLocator;
+    const geom::GeometryFactory* factory;
+    bool done;
+    geom::CoordinateXY centerPt;
+    geom::CoordinateXY radiusPt;
+
+    /* private methods */
+    double distanceToBoundary(const geom::Coordinate& c);
+    double distanceToBoundary(double x, double y);
+    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_distanceToBoundary)
+            : x(p_x)
+            , y(p_y)
+            , hSize(p_hSize)
+            , distance(p_distanceToBoundary)
+            , maxDist(p_distanceToBoundary+(p_hSize*SQRT2))
+        {};
+
+        geom::Envelope getEnvelope() const
+        {
+            geom::Envelope env(x-hSize, x+hSize, y-hSize, y+hSize);
+            return env;
+        }
+
+        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;
+        }
+
+        /**
+         * The Cell priority queue is sorted by the natural order of maxDistance.
+         * std::priority_queue sorts with largest first,
+         * which is what is needed for this algorithm.
+         */
+        using CellQueue = std::priority_queue<Cell>;
+    };
+
+    void createInitialGrid(const geom::Envelope* env, Cell::CellQueue& cellQueue);
+    Cell createInteriorPointCell(const geom::Geometry* geom);
+
+};
+
+
+} // geos::algorithm::construct
+} // geos::algorithm
+} // geos

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/distance/DiscreteFrechetDistance.h

@@ -0,0 +1,175 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2016 Shinichi SUGIYAMA (shin.sugi@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.
+ *
+ **********************************************************************
+ *
+ * Last port: original work
+ *
+ * Developed by Shinichi SUGIYAMA (shin.sugi@gmail.com)
+ * based on http://www.kr.tuwien.ac.at/staff/eiter/et-archive/cdtr9464.pdf
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/algorithm/distance/PointPairDistance.h> // for composition
+#include <geos/algorithm/distance/DistanceToPoint.h> // for composition
+#include <geos/util/IllegalArgumentException.h> // for inlines
+#include <geos/geom/Geometry.h> // for inlines
+#include <geos/util/math.h> // for inlines
+#include <geos/geom/CoordinateFilter.h> // for inheritance
+#include <geos/geom/CoordinateSequence.h> // for inheritance
+
+#include <cstddef>
+#include <vector>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
+#endif
+
+namespace geos {
+namespace algorithm {
+//class RayCrossingCounter;
+}
+namespace geom {
+class Geometry;
+class Coordinate;
+//class CoordinateSequence;
+}
+namespace index {
+namespace intervalrtree {
+//class SortedPackedIntervalRTree;
+}
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+namespace distance { // geos::algorithm::distance
+
+/** \brief
+ * An algorithm for computing a distance metric
+ * which is an approximation to the Frechet Distance
+ * based on a discretization of the input {@link geom::Geometry}.
+ *
+ * The algorithm computes the Frechet distance restricted to discrete points
+ * for one of the geometries.
+ * The points can be either the vertices of the geometries (the default),
+ * or the geometries with line segments densified by a given fraction.
+ * Also determines two points of the Geometries which are separated by the
+ * computed distance.
+ *
+ * This algorithm is an approximation to the standard Frechet distance.
+ * Specifically,
+ * <pre>
+ *    for all geometries a, b:    DFD(a, b) >= FD(a, b)
+ * </pre>
+ * The approximation can be made as close as needed by densifying the
+ * input geometries.
+ * In the limit, this value will approach the true Frechet distance:
+ * <pre>
+ *    DFD(A, B, densifyFactor) -> FD(A, B) as densifyFactor -> 0.0
+ * </pre>
+ * The default approximation is exact or close enough for a large subset of
+ * useful cases.
+ *
+ * The difference between DFD and FD is bounded
+ * by the length of the longest edge of the polygonal curves.
+ *
+ * Fréchet distance sweep continuously along their respective curves
+ * and the direction of curves is significant.
+ * This makes a better measure of similarity than Hausdorff distance.
+ *
+ * An example showing how different DHD and DFD are:
+ * <pre>
+ *   A  = LINESTRING (0 0, 50 200, 100 0, 150 200, 200 0)
+ *   B  = LINESTRING (0 200, 200 150, 0 100, 200 50, 0 0)
+ *   B' = LINESTRING (0 0, 200 50, 0 100, 200 150, 0 200)
+ *
+ *   DHD(A, B)  = DHD(A, B') = 48.5071250072666
+ *   DFD(A, B)  = 200
+ *   DFD(A, B') = 282.842712474619
+ * </pre>
+ */
+class GEOS_DLL DiscreteFrechetDistance {
+public:
+
+    static double distance(const geom::Geometry& g0,
+                           const geom::Geometry& g1);
+
+    static double distance(const geom::Geometry& g0,
+                           const geom::Geometry& g1, double densifyFrac);
+
+    DiscreteFrechetDistance(const geom::Geometry& p_g0,
+                            const geom::Geometry& p_g1)
+        :
+        g0(p_g0),
+        g1(p_g1),
+        ptDist(),
+        densifyFrac(0.0)
+    {}
+
+    /**
+     * Sets the fraction by which to densify each segment.
+     * Each segment will be (virtually) split into a number of equal-length
+     * subsegments, whose fraction of the total length is closest
+     * to the given fraction.
+     *
+     * @param dFrac
+     */
+    void setDensifyFraction(double dFrac);
+
+    double
+    distance()
+    {
+        compute(g0, g1);
+        return ptDist.getDistance();
+    }
+
+    const std::array<geom::CoordinateXY, 2>
+    getCoordinates() const
+    {
+        return ptDist.getCoordinates();
+    }
+
+private:
+    geom::Coordinate getSegmentAt(const geom::CoordinateSequence& seq, std::size_t index);
+
+    PointPairDistance& getFrechetDistance(std::vector< std::vector<PointPairDistance> >& ca, std::size_t i, std::size_t j,
+                                         const geom::CoordinateSequence& p, const geom::CoordinateSequence& q);
+
+    void compute(const geom::Geometry& discreteGeom, const geom::Geometry& geom);
+
+    const geom::Geometry& g0;
+
+    const geom::Geometry& g1;
+
+    PointPairDistance ptDist;
+
+    /// Value of 0.0 indicates that no densification should take place
+    double densifyFrac; // = 0.0;
+
+    // Declare type as noncopyable
+    DiscreteFrechetDistance(const DiscreteFrechetDistance& other) = delete;
+    DiscreteFrechetDistance& operator=(const DiscreteFrechetDistance& rhs) = delete;
+};
+
+} // geos::algorithm::distance
+} // geos::algorithm
+} // geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+