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

package/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/SimplePointInRing.h

@@ -1,44 +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/export.h>
-#include <geos/algorithm/PointInRing.h> // for inheritance
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Coordinate;
-class LinearRing;
-class CoordinateSequence;
-}
-}
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-
-class GEOS_DLL SimplePointInRing: public PointInRing {
-public:
-    SimplePointInRing(geom::LinearRing* ring);
-    ~SimplePointInRing() override = default;
-    bool isInside(const geom::Coordinate& pt) override;
-private:
-    const geom::CoordinateSequence* pts;
-};
-
-} // namespace geos::algorithm
-} // namespace geos
-

package/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/construct/IndexedDistanceToPoint.h

@@ -1,88 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2023 Martin Davis <mtnclimb@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: algorithm/construct/IndexedDistanceToPoint.java
- * https://github.com/locationtech/jts/commit/d92f783163d9440fcc10c729143787bf7b9fe8f9
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/geom/CoordinateSequence.h>
-#include <geos/geom/Geometry.h>
-#include <geos/geom/Point.h>
-#include <geos/algorithm/construct/IndexedPointInPolygonsLocator.h>
-#include <geos/operation/distance/IndexedFacetDistance.h>
-
-using geos::geom::Geometry;
-using geos::geom::Point;
-using geos::operation::distance::IndexedFacetDistance;
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-namespace construct { // geos::algorithm::construct
-
-/**
- * \brief Computes the distance between a point and a geometry
- * (which may be a collection containing any type of geometry).
- * 
- * Also computes the pair of points containing the input
- * point and the nearest point on the geometry.
- * 
- * \author Martin Davis
- */
-class GEOS_DLL IndexedDistanceToPoint {
-
-public:
-    /** 
-     * \brief Creates an instance to find the distance from points to a geometry.
-     * 
-     * \param geom the geometry to compute distances to
-     */
-    IndexedDistanceToPoint(const Geometry& geom);
-
-    /**
-     * \brief Computes the distance from the base geometry to the given point.
-     *
-     * \param pt the point to compute the distance to
-     *
-     * \return the computed distance
-     */
-    double distance(const Point& pt);
-
-    /**
-     * \brief Computes the nearest point on the geometry to the point.
-     * 
-     * The first location lies on the geometry, 
-     * and the second location is the provided point.
-     *
-     * \param pt the point to compute the nearest point for
-     *
-     * \return the points that are nearest
-     */
-    std::unique_ptr<geom::CoordinateSequence> nearestPoints(const Point& pt);
-
-private:
-    void init();
-
-    bool isInArea(const Point& pt);
-
-    //-- members
-    const Geometry& targetGeometry;
-    std::unique_ptr<operation::distance::IndexedFacetDistance> facetDistance;
-    std::unique_ptr<IndexedPointInPolygonsLocator> ptLocator;
-
-};
-
-}}}

package/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/construct/IndexedPointInPolygonsLocator.h

@@ -1,79 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2023 Martin Davis <mtnclimb@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: algorithm/construct/IndexedDistanceToPoint.java
- * https://github.com/locationtech/jts/commit/d92f783163d9440fcc10c729143787bf7b9fe8f9
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/geom/Coordinate.h>
-#include <geos/geom/Geometry.h>
-#include <geos/geom/Location.h>
-#include <geos/index/strtree/TemplateSTRtree.h>
-#include <geos/algorithm/locate/IndexedPointInAreaLocator.h>
-
-using geos::geom::Geometry;
-using geos::geom::CoordinateXY;
-using geos::geom::Location;
-using geos::index::strtree::TemplateSTRtree;
-using geos::algorithm::locate::IndexedPointInAreaLocator;
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-namespace construct { // geos::algorithm::construct
-
-/**
- * \brief Determines the location of a point in the polygonal elements of a geometry.
- * 
- * Uses spatial indexing to provide efficient performance.
- * 
- * \author Martin Davis
- */
-class GEOS_DLL IndexedPointInPolygonsLocator {
-
-public:
-    /** 
-     * \brief Creates an instance to locate a point in polygonal elements.
-     * 
-     * \param geom the geometry to locate in
-     */
-    IndexedPointInPolygonsLocator(const Geometry& geom);
-
-    /** \brief
-     * Determines the [Location](@ref geom::Location) of a point in 
-     * the polygonal elements of a
-     * [Geometry](@ref geom::Geometry).
-     *
-     * @param p the point to test
-     * @return the location of the point in the geometry
-     */
-    Location locate(const CoordinateXY* /*const*/ p);
-
-private:
-    void init();
-
-    // Declare type as noncopyable
-    IndexedPointInPolygonsLocator(const IndexedPointInPolygonsLocator& other) = delete;
-    IndexedPointInPolygonsLocator& operator=(const IndexedPointInPolygonsLocator& rhs) = delete;
-
-    //-- members
-    const Geometry& geom;
-    bool isInitialized;
-    TemplateSTRtree<IndexedPointInAreaLocator*> index;
-    std::vector<std::unique_ptr<IndexedPointInAreaLocator>> locators;
-};
-
-}}}

package/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/construct/LargestEmptyCircle.h

@@ -1,240 +0,0 @@
-/**********************************************************************
- *
- * 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/dist/prebuilt/Android-arm64-v8a/include/geos/algorithm/construct/MaximumInscribedCircle.h

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