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

package/dist/prebuilt/iOS-iphonesimulator/include/geos/operation/cluster/GeometryFlattener.h

@@ -1,46 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2022 ISciences LLC
- *
- * 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/geom/Geometry.h>
-#include <geos/geom/GeometryFactory.h>
-#include <geos/geom/GeometryCollection.h>
-
-namespace geos  {
-namespace operation {
-namespace cluster {
-
-
-class GEOS_DLL GeometryFlattener {
-public:
-    /** Flatten a geometry such that it contains no nested components (e.g., MultiPolygons within
-     *  GeometryCollections, etc.). The flattened geometry will use the most narrow representation
-     *  possible (Polygon preferred to MultiPolygon, MultiPolygon preferred to GeometryCollection.)
-     *
-     * @brief flatten
-     * @param g a geometry to be flattened; consumed by the function
-     * @return a geometry with no nested components
-     */
-    static std::unique_ptr<geom::Geometry> flatten(std::unique_ptr<geom::Geometry>&& g);
-
-private:
-    static void flatten(std::unique_ptr<geom::Geometry>&& g, std::vector<std::unique_ptr<geom::Geometry>>& components);
-};
-
-
-}
-}
-}

package/dist/prebuilt/iOS-iphonesimulator/include/geos/operation/cluster/GeometryIntersectsClusterFinder.h

@@ -1,53 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2020-2021 Daniel Baston
- *
- * 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.
- *
- **********************************************************************/
-
-#ifndef GEOS_OPERATION_CLUSTER_GEOMETRYINTERSECTSCLUSTERFINDER
-#define GEOS_OPERATION_CLUSTER_GEOMETRYINTERSECTSCLUSTERFINDER
-
-#include <geos/operation/cluster/AbstractClusterFinder.h>
-#include <geos/geom/Geometry.h>
-#include <geos/geom/prep/PreparedGeometry.h>
-#include <geos/geom/prep/PreparedGeometryFactory.h>
-
-namespace geos {
-namespace operation {
-namespace cluster {
-
-/** GeometryIntersectsClusterFinder clusters geometries by intersection.
- * Any two geometries that intersect will be included in the same cluster.
- */
-class GEOS_DLL GeometryIntersectsClusterFinder : public AbstractClusterFinder {
-protected:
-    const geom::Envelope& queryEnvelope(const geom::Geometry* a) override {
-        return *(a->getEnvelopeInternal());
-    }
-
-    bool shouldJoin(const geom::Geometry* a, const geom::Geometry *b) override {
-        if (m_prep == nullptr || &(m_prep->getGeometry()) != a) {
-            m_prep = geom::prep::PreparedGeometryFactory::prepare(a);
-        }
-
-        return m_prep->intersects(b);
-    }
-
-private:
-    std::unique_ptr<geom::prep::PreparedGeometry> m_prep;
-};
-
-
-}
-}
-}
-
-#endif

package/dist/prebuilt/iOS-iphonesimulator/include/geos/operation/cluster/UnionFind.h

@@ -1,137 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2020-2021 Daniel Baston
- *
- * 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.
- *
- **********************************************************************/
-
-#ifndef GEOS_OPERATION_CLUSTER_UNIONFIND
-#define GEOS_OPERATION_CLUSTER_UNIONFIND
-
-#include <algorithm>
-#include <numeric>
-#include <vector>
-
-#include <geos/export.h>
-#include <geos/operation/cluster/Clusters.h>
-
-namespace geos {
-namespace operation {
-namespace cluster {
-
-/** UnionFind provides an implementation of a disjoint set data structure that
- * is useful in clustering. Elements to be clustered are referred to according
- * to a numeric index.
- */
-class GEOS_DLL UnionFind {
-
-public:
-    /** Create a UnionFind object
-     *
-     * @param n the number of elements to be clustered (fixed size)
-     */
-    explicit UnionFind(size_t n) :
-            clusters(n),
-            sizes(n),
-            num_clusters(n) {
-        std::iota(clusters.begin(), clusters.end(), 0);
-        std::fill(sizes.begin(), sizes.end(), 1);
-    }
-
-    // Are two elements in the same cluster?
-    bool same(size_t i, size_t j) {
-        return i == j || (find(i) == find(j));
-    }
-
-    // Are two elements in a different cluster?
-    bool different(size_t i, size_t j) {
-        return !same(i, j);
-    }
-
-    /**
-     * Return the ID of the cluster associated with an item
-     * @param i index of the item to lookup
-     * @return a numeric cluster ID
-     */
-    size_t find(size_t i) {
-        size_t root = i;
-
-        while(clusters[root] != root) {
-            root = clusters[root];
-        }
-
-        while (i != root) {
-            size_t next = clusters[i];
-            clusters[i] = root;
-            i = next;
-        }
-
-        return i;
-    }
-
-    /**
-     * Merge the clusters associated with two items
-     * @param i ID of an item associated with the first cluster
-     * @param j ID of an item associated with the second cluster
-     */
-    void join(size_t i, size_t j) {
-        auto a = find(i);
-        auto b = find(j);
-
-        if (a == b) {
-            return;
-        }
-
-        if ((sizes[b] > sizes[a]) || (sizes[a] == sizes[b] && b <= a)) {
-            std::swap(a, b);
-        }
-
-        clusters[a] = clusters[b];
-        sizes[b] += sizes[a];
-        sizes[a] = 0;
-
-        num_clusters--;
-    }
-
-    size_t getNumClusters() const {
-        return num_clusters;
-    }
-
-    template<typename T>
-    void sortByCluster(T begin, T end) {
-        std::sort(begin, end, [this](size_t a, size_t b) {
-            return find(a) < find(b);
-        });
-    }
-
-    /**
-     * Return the clusters associated with all elements
-     * @return an object that allows iteration over the elements of each cluster
-     */
-    Clusters getClusters();
-
-    /**
-     * Return the clusters associated with the given elements
-     * @param elems a vector of element ids
-     * @return an object that allows iteration over the elements of each cluster
-     */
-    Clusters getClusters(std::vector<size_t> elems);
-
-private:
-    std::vector<size_t> clusters;
-    std::vector<size_t> sizes;
-    size_t num_clusters;
-};
-
-}
-}
-}
-
-#endif

package/dist/prebuilt/iOS-iphonesimulator/include/geos/operation/distance/ConnectedElementLocationFilter.h

@@ -1,76 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2006 Refractions Research 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.
- *
- **********************************************************************
- *
- * Last port: operation/distance/ConnectedElementLocationFilter.java b98e8234
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <geos/geom/GeometryFilter.h> // for inheritance
-#include <geos/operation/distance/GeometryLocation.h>
-
-#include <memory>
-#include <vector>
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Geometry;
-}
-}
-
-
-namespace geos {
-namespace operation { // geos::operation
-namespace distance { // geos::operation::distance
-
-/** \brief
- * A ConnectedElementPointFilter extracts a single point from each connected
- * element in a Geometry (e.g. a polygon, linestring or point) and returns
- * them in a list. Empty geometries do not provide a location item.
- *
- * The elements of the list are GeometryLocation.
- *
- * Empty geometries do not provide a location item.
- */
-class GEOS_DLL ConnectedElementLocationFilter: public geom::GeometryFilter {
-private:
-
-    std::vector<GeometryLocation> locations;
-    ConnectedElementLocationFilter() = default;
-    ConnectedElementLocationFilter(const ConnectedElementLocationFilter&) = delete;
-    ConnectedElementLocationFilter& operator=(const ConnectedElementLocationFilter&) = delete;
-public:
-    /** \brief
-     * Returns a list containing a point from each Polygon, LineString, and
-     * Point found inside the specified geometry.
-     *
-     * Thus, if the specified geometry is not a GeometryCollection,
-     * an empty list will be returned. The elements of the list
-     * are [GeometryLocations](@ref operation::distance::GeometryLocation).
-     */
-    static std::vector<GeometryLocation> getLocations(const geom::Geometry* geom);
-
-    void filter_ro(const geom::Geometry* geom) override;
-    void filter_rw(geom::Geometry* geom) override;
-};
-
-
-} // namespace geos::operation::distance
-} // namespace geos::operation
-} // namespace geos
-

package/dist/prebuilt/iOS-iphonesimulator/include/geos/operation/distance/ConnectedElementPointFilter.h

@@ -1,73 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2006 Refractions Research 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.
- *
- **********************************************************************
- *
- * Last port: operation/distance/ConnectedElementPointFilter.java rev. 1.7 (JTS-1.10)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <geos/geom/GeometryFilter.h> // for inheritance
-
-#include <vector>
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class CoordinateXY;
-class Geometry;
-}
-}
-
-
-namespace geos {
-namespace operation { // geos::operation
-namespace distance { // geos::operation::distance
-
-/** \brief
- * Extracts a single point
- * from each connected element in a Geometry
- * (e.g. a polygon, linestring or point)
- * and returns them in a list
- */
-class GEOS_DLL ConnectedElementPointFilter: public geom::GeometryFilter {
-
-private:
-    std::vector<const geom::CoordinateXY*>* pts;
-
-public:
-    /**
-     * Returns a list containing a Coordinate from each Polygon, LineString, and Point
-     * found inside the specified geometry. Thus, if the specified geometry is
-     * not a GeometryCollection, an empty list will be returned.
-     */
-    static std::vector<const geom::CoordinateXY*>* getCoordinates(const geom::Geometry* geom);
-
-    ConnectedElementPointFilter(std::vector<const geom::CoordinateXY*>* newPts)
-        :
-        pts(newPts)
-    {}
-
-    void filter_ro(const geom::Geometry* geom) override;
-
-    //void filter_rw(geom::Geometry * /*geom*/) {};
-};
-
-
-} // namespace geos::operation::distance
-} // namespace geos::operation
-} // namespace geos
-

package/dist/prebuilt/iOS-iphonesimulator/include/geos/operation/distance/DistanceOp.h

@@ -1,228 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
- * Copyright (C) 2006 Refractions Research 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.
- *
- **********************************************************************
- *
- * Last port: operation/distance/DistanceOp.java r335 (JTS-1.12-)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <geos/algorithm/PointLocator.h> // for composition
-#include <geos/operation/distance/GeometryLocation.h>
-#include <geos/geom/CoordinateSequence.h>
-
-#include <array>
-#include <vector>
-#include <memory>
-
-#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
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Coordinate;
-class Polygon;
-class LineString;
-class Point;
-class Geometry;
-}
-}
-
-
-namespace geos {
-namespace operation { // geos::operation
-namespace distance { // geos::operation::distance
-
-/**
- * \brief
- * Find two points on two {@link geom::Geometry}s which lie
- * within a given distance, or else are the nearest points
- * on the geometries (in which case this also
- * provides the distance between the geometries).
- *
- * The distance computation also finds a pair of points in the
- * input geometries which have the minimum distance between them.
- * If a point lies in the interior of a line segment,
- * the coordinate computed is a close
- * approximation to the exact point.
- *
- * Empty geometry collection components are ignored.
- *
- * The algorithms used are straightforward O(n^2)
- * comparisons.  This worst-case performance could be improved on
- * by using Voronoi techniques or spatial indexes.
- *
- */
-class GEOS_DLL DistanceOp {
-public:
-    /**
-     * \brief
-     * Compute the distance between the nearest points of two geometries.
-     *
-     * @param g0 a {@link geom::Geometry}
-     * @param g1 another {@link geom::Geometry}
-     * @return the distance between the geometries
-     * @return 0 if either input geometry is empty
-     * @throws IllegalArgumentException if either input geometry is null
-     */
-    static double distance(const geom::Geometry& g0,
-                           const geom::Geometry& g1);
-
-    /// @deprecated, use the version taking references
-    static double distance(const geom::Geometry* g0,
-                           const geom::Geometry* g1);
-
-    /**
-     * \brief
-     * Test whether two geometries lie within a given distance of
-     * each other.
-     *
-     * @param g0 a {@link geom::Geometry}
-     * @param g1 another {@link geom::Geometry}
-     * @param distance the distance to test
-     * @return true if g0.distance(g1) <= distance
-     */
-    static bool isWithinDistance(const geom::Geometry& g0,
-                                 const geom::Geometry& g1,
-                                 double distance);
-
-    /**
-     * Compute the the nearest points of two geometries.
-     *
-     * The points are presented in the same order as the input Geometries.
-     *
-     * @param g0 a {@link geom::Geometry}
-     * @param g1 another {@link geom::Geometry}
-     *
-     * @return the nearest points in the geometries, ownership to caller.
-     *         A NULL return means one of the geometries is empty.
-     *
-     */
-    static std::unique_ptr<geom::CoordinateSequence> nearestPoints(
-        const geom::Geometry* g0,
-        const geom::Geometry* g1);
-
-    /// @deprecated use the one taking references
-    DistanceOp(const geom::Geometry* g0, const geom::Geometry* g1);
-
-    /**
-     * \brief
-     * Constructs a DistanceOp that computes the distance and
-     * nearest points between the two specified geometries.
-     *
-     * @param g0 a Geometry
-     * @param g1 a Geometry
-     */
-    DistanceOp(const geom::Geometry& g0, const geom::Geometry& g1);
-
-    /**
-     * \brief
-     * Constructs a DistanceOp that computes the distance and nearest
-     * points between the two specified geometries.
-     *
-     * @param g0 a Geometry
-     * @param g1 a Geometry
-     * @param terminateDistance the distance on which to terminate
-     *                          the search
-     */
-    DistanceOp(const geom::Geometry& g0, const geom::Geometry& g1,
-               double terminateDistance);
-
-    ~DistanceOp() = default;
-
-    /**
-     * Report the distance between the closest points on the input geometries.
-     *
-     * @return the distance between the geometries
-     */
-    double distance();
-
-    /**
-     * Report the coordinates of the nearest points in the input geometries.
-     * The points are presented in the same order as the input Geometries.
-     *
-     * @return a pair of {@link geom::Coordinate}s of the nearest points
-     *         as a newly allocated object (ownership to caller)
-     *
-     */
-    std::unique_ptr<geom::CoordinateSequence> nearestPoints();
-
-private:
-
-    // input
-    std::array<geom::Geometry const*, 2> geom;
-    double terminateDistance;
-
-    // working
-    algorithm::PointLocator ptLocator;
-    std::array<GeometryLocation, 2> minDistanceLocation;
-    double minDistance;
-    bool computed = false;
-
-    void updateMinDistance(std::array<GeometryLocation, 2> & locGeom, bool flip);
-
-    void computeMinDistance();
-
-    void computeContainmentDistance();
-
-    void computeInside(std::vector<GeometryLocation> & locs,
-                       const std::vector<const geom::Polygon*>& polys,
-                       std::array<GeometryLocation, 2> & locPtPoly);
-
-
-    /**
-     * Computes distance between facets (lines and points)
-     * of input geometries.
-     */
-    void computeFacetDistance();
-
-    void computeMinDistanceLines(
-        const std::vector<const geom::LineString*>& lines0,
-        const std::vector<const geom::LineString*>& lines1,
-        std::array<GeometryLocation, 2> & locGeom);
-
-    void computeMinDistancePoints(
-        const std::vector<const geom::Point*>& points0,
-        const std::vector<const geom::Point*>& points1,
-        std::array<GeometryLocation, 2> & locGeom);
-
-    void computeMinDistanceLinesPoints(
-        const std::vector<const geom::LineString*>& lines0,
-        const std::vector<const geom::Point*>& points1,
-        std::array<GeometryLocation, 2> & locGeom);
-
-    void computeMinDistance(const geom::LineString* line0,
-                            const geom::LineString* line1,
-                            std::array<GeometryLocation, 2> & locGeom);
-
-    void computeMinDistance(const geom::LineString* line,
-                            const geom::Point* pt,
-                            std::array<GeometryLocation, 2> & locGeom);
-};
-
-
-} // namespace geos::operation::distance
-} // namespace geos::operation
-} // namespace geos
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-

package/dist/prebuilt/iOS-iphonesimulator/include/geos/operation/distance/FacetSequence.h

@@ -1,84 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2016 Daniel Baston
- *
- * 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: operation/distance/FacetSequence.java (f6187ee2 JTS-1.14)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/geom/CoordinateSequence.h>
-#include <geos/geom/Envelope.h>
-#include <geos/geom/Coordinate.h>
-#include <geos/geom/LineSegment.h>
-#include <geos/operation/distance/GeometryLocation.h>
-
-namespace geos {
-namespace operation {
-namespace distance {
-class FacetSequence {
-private:
-    const geom::CoordinateSequence* pts;
-    const std::size_t start;
-    const std::size_t end;
-    const geom::Geometry* geom;
-    /*
-    * Unlike JTS, we store the envelope in the FacetSequence so
-    * that it has a clear owner.  This is helpful when making a
-    * tree of FacetSequence objects (FacetSequenceTreeBuilder)
-    */
-    geom::Envelope env;
-
-    double computeDistanceLineLine(const FacetSequence& facetSeq,
-                                   std::vector<GeometryLocation> *locs) const;
-
-    double computeDistancePointLine(const geom::Coordinate& pt,
-                                    const FacetSequence& facetSeq,
-                                    std::vector<GeometryLocation> *locs) const;
-
-    void updateNearestLocationsPointLine(const geom::Coordinate& pt,
-                                         const FacetSequence& facetSeq, std::size_t i,
-                                         const geom::Coordinate& q0, const geom::Coordinate &q1,
-                                         std::vector<GeometryLocation> *locs) const;
-
-    void updateNearestLocationsLineLine(std::size_t i, const geom::Coordinate& p0, const geom::Coordinate& p1,
-                                        const FacetSequence& facetSeq,
-                                        std::size_t j, const geom::Coordinate& q0, const geom::Coordinate &q1,
-                                        std::vector<GeometryLocation> *locs) const;
-
-    void computeEnvelope();
-
-public:
-    const geom::Envelope* getEnvelope() const;
-
-    const geom::Coordinate* getCoordinate(std::size_t index) const;
-
-    std::size_t size() const;
-
-    bool isPoint() const;
-
-    double distance(const FacetSequence& facetSeq) const;
-
-    FacetSequence(const geom::CoordinateSequence* pts, std::size_t start, std::size_t end);
-
-    FacetSequence(const geom::Geometry* geom, const geom::CoordinateSequence* pts, std::size_t start, std::size_t end);
-
-    std::vector<GeometryLocation> nearestLocations(const FacetSequence& facetSeq) const;
-
-};
-
-}
-}
-}
-