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

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e/Headers/geos/operation/sharedpaths/SharedPathsOp.h

@@ -1,161 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2010      Sandro Santilli <strk@kbt.io>
- *
- * 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 Sandro Santilli (strk@kbt.io)
- * for Faunalia (http://www.faunalia.it)
- * with funding from Regione Toscana - Settore SISTEMA INFORMATIVO
- * TERRITORIALE ED AMBIENTALE - for the project: "Sviluppo strumenti
- * software per il trattamento di dati geografici basati su QuantumGIS
- * e Postgis (CIG 0494241492)"
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h> // for GEOS_DLL
-
-#include <vector>
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class LineString;
-class Geometry;
-class GeometryFactory;
-}
-}
-
-
-namespace geos {
-namespace operation { // geos.operation
-
-/// Find shared paths among two linear Geometry objects.
-namespace sharedpaths { // geos.operation.sharedpaths
-
-/** \brief
- * Find shared paths among two linear Geometry objects
- *
- * For each shared path report if it direction is the same
- * or opposite.
- *
- * Paths reported as shared are given in the direction they
- * appear in the first geometry.
- *
- * \remark Developed by Sandro Santilli (strk@kbt.io)
- * for Faunalia (http://www.faunalia.it)
- * with funding from Regione Toscana - Settore SISTEMA INFORMATIVO
- * TERRITORIALE ED AMBIENTALE - for the project: "Sviluppo strumenti
- * software per il trattamento di dati geografici basati su QuantumGIS
- * e Postgis (CIG 0494241492)"
- *
- */
-class GEOS_DLL SharedPathsOp {
-public:
-
-    /// LineString vector (list of edges)
-    typedef std::vector<geom::LineString*> PathList;
-
-    /// Find paths shared between two linear geometries
-    ///
-    /// @param g1
-    ///   First geometry. Must be linear.
-    ///
-    /// @param g2
-    ///   Second geometry. Must be linear.
-    ///
-    /// @param sameDirection
-    ///   Shared edges having the same direction are pushed
-    ///   onto this vector. They'll be of type LineString.
-    ///   Ownership of the edges is tranferred.
-    ///
-    /// @param oppositeDirection
-    ///   Shared edges having the opposite direction are pushed
-    ///   onto this vector. They'll be of type geom::LineString.
-    ///   Ownership of the edges is tranferred.
-    ///
-    static void sharedPathsOp(const geom::Geometry& g1,
-                              const geom::Geometry& g2,
-                              PathList& sameDirection,
-                              PathList& oppositeDirection);
-
-    /// Constructor
-    ///
-    /// @param g1
-    ///   First geometry. Must be linear.
-    ///
-    /// @param g2
-    ///   Second geometry. Must be linear.
-    ///
-    SharedPathsOp(const geom::Geometry& g1, const geom::Geometry& g2);
-
-    /// Get shared paths
-    ///
-    /// @param sameDirection
-    ///   Shared edges having the same direction are pushed
-    ///   onto this vector. They'll be of type geom::LineString.
-    ///   Ownership of the edges is tranferred.
-    ///
-    /// @param oppositeDirection
-    ///   Shared edges having the opposite direction are pushed
-    ///   onto this vector. They'll be of type geom::LineString.
-    ///   Ownership of the edges is tranferred.
-    ///
-    void getSharedPaths(PathList& sameDirection, PathList& oppositeDirection);
-
-    /// Delete all edges in the list
-    static void clearEdges(PathList& from);
-
-private:
-
-    /// Get all the linear intersections
-    ///
-    /// Ownership of linestring pushed to the given container
-    /// is transferred to caller. See clearEdges for a deep
-    /// release if you need one.
-    ///
-    void findLinearIntersections(PathList& to);
-
-    /// Check if the given edge goes forward or backward on the given line.
-    ///
-    /// PRECONDITION: It is assumed the edge fully lays on the geometry
-    ///
-    bool isForward(const geom::LineString& edge,
-                   const geom::Geometry& geom);
-
-    /// Check if the given edge goes in the same direction over
-    /// the two geometries.
-    bool
-    isSameDirection(const geom::LineString& edge)
-    {
-        return (isForward(edge, _g1) == isForward(edge, _g2));
-    }
-
-    /// Throw an IllegalArgumentException if the geom is not linear
-    void checkLinealInput(const geom::Geometry& g);
-
-    const geom::Geometry& _g1;
-    const geom::Geometry& _g2;
-    const geom::GeometryFactory& _gf;
-
-    // Declare type as noncopyable
-    SharedPathsOp(const SharedPathsOp& other) = delete;
-    SharedPathsOp& operator=(const SharedPathsOp& rhs) = delete;
-
-};
-
-} // namespace geos.operation.sharedpaths
-} // namespace geos.operation
-} // namespace geos

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e/Headers/geos/operation/union/CascadedPolygonUnion.h

@@ -1,246 +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/union/CascadedPolygonUnion.java r487 (JTS-1.12+)
- * Includes custom code to deal with https://trac.osgeo.org/geos/ticket/837
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <geos/operation/union/UnionStrategy.h>
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class GeometryFactory;
-class Geometry;
-class Polygon;
-class MultiPolygon;
-class Envelope;
-}
-}
-
-namespace geos {
-namespace operation { // geos::operation
-namespace geounion {  // geos::operation::geounion
-
-
-/**
-* \brief
-* Implementation of UnionStrategy that provides overlay using
-* the first generation overlay routines.
-*/
-class GEOS_DLL ClassicUnionStrategy : public UnionStrategy {
-
-public:
-
-    ClassicUnionStrategy() {};
-
-    /**
-    * Computes the union of two geometries.
-    * This method may throw a {@link util::TopologyException}
-    * if one is encountered
-    */
-    std::unique_ptr<geom::Geometry> Union(const geom::Geometry*, const geom::Geometry*) override;
-
-    /**
-    * Indicates whether the union function operates using
-    * a floating (full) precision model.
-    * If this is the case, then the unary union code
-    * can make use of the {@link OverlapUnion} performance optimization,
-    * and perhaps other optimizations as well.
-    * Otherwise, the union result extent may not be the same as the extent of the inputs,
-    * which prevents using some optimizations.
-    */
-    bool isFloatingPrecision() const override;
-
-private:
-
-    /**
-    * An alternative way of unioning polygonal geometries
-    * by using <code>bufer(0)</code>.
-    * Only worth using if regular overlay union fails.
-    */
-    std::unique_ptr<geom::Geometry> unionPolygonsByBuffer(const geom::Geometry* g0, const geom::Geometry* g1);
-
-};
-
-
-
-/**
- * \brief
- * Provides an efficient method of unioning a collection of polygonal geometries.
- *
- * This algorithm is faster and likely more robust than the simple iterated
- * approach of repeatedly unioning each polygon to a result geometry.
- *
- * The `buffer(0)` trick is sometimes faster, but can be less robust and
- * can sometimes take an exceptionally long time to complete.
- * This is particularly the case where there is a high degree of overlap
- * between the polygons.  In this case, `buffer(0)` is forced to compute
- * with *all* line segments from the outset, whereas cascading can eliminate
- * many segments at each stage of processing.
- * The best case for buffer(0) is the trivial case where there is `no` overlap
- * between the input geometries. However, this case is likely rare in practice.
- */
-class GEOS_DLL CascadedPolygonUnion {
-private:
-    std::vector<geom::Polygon*>* inputPolys;
-    geom::GeometryFactory const* geomFactory;
-
-    /**
-     * The effectiveness of the index is somewhat sensitive
-     * to the node capacity.
-     * Testing indicates that a smaller capacity is better.
-     * For an STRtree, 4 is probably a good number (since
-     * this produces 2x2 "squares").
-     */
-    static int const STRTREE_NODE_CAPACITY = 4;
-
-    /** \brief
-     * Computes a [Geometry](@ref geom::Geometry) containing only polygonal components.
-     *
-     * Extracts the [Polygons](@ref geom::Polygon) from the input
-     * and returns them as an appropriate polygonal geometry.
-     *
-     * If the input is already `Polygonal`, it is returned unchanged.
-     *
-     * A particular use case is to filter out non-polygonal components
-     * returned from an overlay operation.
-     *
-     * @param g the geometry to filter
-     * @return a Polygonal geometry
-     */
-    static std::unique_ptr<geom::Geometry> restrictToPolygons(std::unique_ptr<geom::Geometry> g);
-
-public:
-    CascadedPolygonUnion();
-
-    /** \brief
-     * Computes the union of a collection of polygonal [Geometrys](@ref geom::Geometry).
-     *
-     * @param polys a collection of polygonal [Geometrys](@ref geom::Geometry).
-     *              ownership of elements *and* vector are left to caller.
-     */
-    static std::unique_ptr<geom::Geometry> Union(std::vector<geom::Polygon*>* polys);
-    static std::unique_ptr<geom::Geometry> Union(std::vector<geom::Polygon*>* polys, UnionStrategy* unionFun);
-
-    /** \brief
-     * Computes the union of a set of polygonal [Geometrys](@ref geom::Geometry).
-     *
-     * @tparam T an iterator yielding something castable to const Polygon *
-     * @param start start iterator
-     * @param end end iterator
-     * @param unionStrategy strategy to apply
-     */
-    template <class T>
-    static std::unique_ptr<geom::Geometry>
-    Union(T start, T end, UnionStrategy *unionStrategy)
-    {
-        std::vector<geom::Polygon*> polys;
-        for(T i = start; i != end; ++i) {
-            const geom::Polygon* p = dynamic_cast<const geom::Polygon*>(*i);
-            polys.push_back(const_cast<geom::Polygon*>(p));
-        }
-        return Union(&polys, unionStrategy);
-    }
-
-    /** \brief
-     * Computes the union of a collection of polygonal [Geometrys](@ref geom::Geometry).
-     *
-     * @param polys a collection of polygonal [Geometrys](@ref geom::Geometry).
-     *              Ownership of elements *and* vector are left to caller.
-     */
-    static std::unique_ptr<geom::Geometry> Union(const geom::MultiPolygon* polys);
-
-    /** \brief
-     * Creates a new instance to union the given collection of
-     * [Geometrys](@ref geom::Geometry).
-     *
-     * @param polys a collection of polygonal [Geometrys](@ref geom::Geometry).
-     *              Ownership of elements *and* vector are left to caller.
-     */
-    CascadedPolygonUnion(std::vector<geom::Polygon*>* polys)
-        : inputPolys(polys)
-        , geomFactory(nullptr)
-        , unionFunction(&defaultUnionFunction)
-    {}
-
-    CascadedPolygonUnion(std::vector<geom::Polygon*>* polys, UnionStrategy* unionFun)
-        : inputPolys(polys)
-        , geomFactory(nullptr)
-        , unionFunction(unionFun)
-    {}
-
-    /** \brief
-     * Computes the union of the input geometries.
-     *
-     * @return the union of the input geometries
-     * @return `null` if no input geometries were provided
-     */
-    std::unique_ptr<geom::Geometry> Union();
-
-private:
-
-    UnionStrategy* unionFunction;
-    ClassicUnionStrategy defaultUnionFunction;
-
-    /**
-     * Unions a section of a list using a recursive binary union on each half
-     * of the section.
-     *
-     * @param geoms the list of geometries containing the section to union
-     * @param start the start index of the section
-     * @param end the index after the end of the section
-     * @return the union of the list section
-     */
-    std::unique_ptr<geom::Geometry> binaryUnion(const std::vector<const geom::Geometry*> & geoms, std::size_t start, std::size_t end);
-
-    /**
-     * Computes the union of two geometries,
-     * either of both of which may be null.
-     *
-     * @param g0 a Geometry
-     * @param g1 a Geometry
-     * @return the union of the input(s)
-     * @return null if both inputs are null
-     */
-    std::unique_ptr<geom::Geometry> unionSafe(const geom::Geometry* g0, const geom::Geometry* g1) const;
-
-    std::unique_ptr<geom::Geometry> unionSafe(std::unique_ptr<geom::Geometry> &&, std::unique_ptr<geom::Geometry> &&);
-
-    /**
-     * Encapsulates the actual unioning of two polygonal geometries.
-     *
-     * @param g0
-     * @param g1
-     * @return
-     */
-    std::unique_ptr<geom::Geometry> unionActual(const geom::Geometry* g0, const geom::Geometry* g1) const;
-
-    std::unique_ptr<geom::Geometry> unionActual(std::unique_ptr<geom::Geometry> &&, std::unique_ptr<geom::Geometry> &&) const;
-};
-
-
-
-
-
-} // namespace geos::operation::union
-} // namespace geos::operation
-} // namespace geos
-

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e/Headers/geos/operation/union/UnaryUnionOp.h

@@ -1,239 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
- *
- * 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/union/UnaryUnionOp.java r320 (JTS-1.12)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <memory>
-#include <vector>
-
-#include <geos/export.h>
-#include <geos/geom/GeometryFactory.h>
-#include <geos/geom/Point.h>
-#include <geos/geom/LineString.h>
-#include <geos/geom/Polygon.h>
-#include <geos/geom/util/GeometryExtracter.h>
-#include <geos/operation/union/CascadedPolygonUnion.h>
-
-#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 GeometryFactory;
-class Geometry;
-}
-}
-
-namespace geos {
-namespace operation { // geos::operation
-namespace geounion {  // geos::operation::geounion
-
-/** \brief
- * Unions a collection of Geometry or a single Geometry
- * (which may be a collection) together.
- *
- * By using this special-purpose operation over a collection of
- * geometries it is possible to take advantage of various optimizations
- * to improve performance.
- * Heterogeneous [GeometryCollections](@ref geom::GeometryCollection)
- * are fully supported.
- *
- * The result obeys the following contract:
- *
- * - Unioning a set of overlapping [Polygons](@ref geom::Polygon) has the effect
- *   of merging the areas (i.e. the same effect as
- *   iteratively unioning all individual polygons together).
- * - Unioning a set of [LineStrings](@ref geom::LineString) has the effect of
- *   **fully noding** and **dissolving** the input linework.
- *   In this context "fully noded" means that there will be a node or
- *   endpoint in the output for every endpoint or line segment crossing
- *   in the input.
- *   "Dissolved" means that any duplicate (e.g. coincident) line segments
- *   or portions of line segments will be reduced to a single line segment
- *   in the output.
- *   This is consistent with the semantics of the
- *   [Geometry::Union(Geometry* )](@ref geom::Geometry::Union())
- *   operation. If **merged** linework is required, the
- *   [LineMerger](@ref operation::linemerge::LineMerger) class
- *   can be used.
- * - Unioning a set of [Points](@ref geom::Point) has the effect of merging
- *   all identical points (producing a set with no duplicates).
- *
- * `UnaryUnion` always operates on the individual components of
- * MultiGeometries.
- * So it is possible to use it to "clean" invalid self-intersecting
- * MultiPolygons (although the polygon components must all still be
- * individually valid.)
- */
-class GEOS_DLL UnaryUnionOp {
-public:
-
-    template <typename T>
-    static std::unique_ptr<geom::Geometry>
-    Union(const T& geoms)
-    {
-        UnaryUnionOp op(geoms);
-        return op.Union();
-    }
-
-    template <class T>
-    static std::unique_ptr<geom::Geometry>
-    Union(const T& geoms,
-          geom::GeometryFactory& geomFact)
-    {
-        UnaryUnionOp op(geoms, geomFact);
-        return op.Union();
-    }
-
-    static std::unique_ptr<geom::Geometry>
-    Union(const geom::Geometry& geom)
-    {
-        UnaryUnionOp op(geom);
-        return op.Union();
-    }
-
-    template <class T>
-    UnaryUnionOp(const T& geoms, geom::GeometryFactory& geomFactIn)
-        : geomFact(&geomFactIn)
-        , unionFunction(&defaultUnionFunction)
-    {
-        extractGeoms(geoms);
-    }
-
-    template <class T>
-    UnaryUnionOp(const T& geoms)
-        : geomFact(nullptr)
-        , unionFunction(&defaultUnionFunction)
-    {
-        extractGeoms(geoms);
-    }
-
-    UnaryUnionOp(const geom::Geometry& geom)
-        : geomFact(geom.getFactory())
-        , unionFunction(&defaultUnionFunction)
-    {
-        extract(geom);
-    }
-
-    void setUnionFunction(UnionStrategy* unionFun)
-    {
-        unionFunction = unionFun;
-    }
-
-    /**
-     * \brief
-     * Gets the union of the input geometries.
-     *
-     * If no input geometries were provided, an empty GEOMETRYCOLLECTION is returned.
-     *
-     * @return a Geometry containing the union
-     * @return an empty GEOMETRYCOLLECTION if no geometries were provided
-     *         in the input
-     */
-    std::unique_ptr<geom::Geometry> Union();
-
-private:
-
-    template <typename T>
-    void
-    extractGeoms(const T& geoms)
-    {
-        for(typename T::const_iterator
-                i = geoms.begin(),
-                e = geoms.end();
-                i != e;
-                ++i) {
-            const geom::Geometry* geom = *i;
-            extract(*geom);
-        }
-    }
-
-    void
-    extract(const geom::Geometry& geom)
-    {
-        using namespace geom::util;
-
-        if(! geomFact) {
-            geomFact = geom.getFactory();
-        }
-
-        GeometryExtracter::extract<geom::Polygon>(geom, polygons);
-        GeometryExtracter::extract<geom::LineString>(geom, lines);
-        GeometryExtracter::extract<geom::Point>(geom, points);
-    }
-
-    /**
-     * Computes a unary union with no extra optimization,
-     * and no short-circuiting.
-     * Due to the way the overlay operations
-     * are implemented, this is still efficient in the case of linear
-     * and puntal geometries.
-     * Uses robust version of overlay operation
-     * to ensure identical behaviour to the <tt>union(Geometry)</tt> operation.
-     *
-     * @param g0 a geometry
-     * @return the union of the input geometry
-     */
-    std::unique_ptr<geom::Geometry>
-    unionNoOpt(const geom::Geometry& g0)
-    {
-        if(! empty.get()) {
-            empty = geomFact->createEmptyGeometry();
-        }
-        return unionFunction->Union(&g0, empty.get());
-    }
-
-    /**
-     * Computes the union of two geometries,
-     * either of both of which may be null.
-     *
-     * @param g0 a Geometry (ownership transferred)
-     * @param g1 a Geometry (ownership transferred)
-     * @return the union of the input(s)
-     * @return null if both inputs are null
-     */
-    std::unique_ptr<geom::Geometry> unionWithNull(
-        std::unique_ptr<geom::Geometry> g0,
-        std::unique_ptr<geom::Geometry> g1
-        );
-
-    // Members
-    std::vector<const geom::Polygon*> polygons;
-    std::vector<const geom::LineString*> lines;
-    std::vector<const geom::Point*> points;
-
-    const geom::GeometryFactory* geomFact;
-    std::unique_ptr<geom::Geometry> empty;
-
-    UnionStrategy* unionFunction;
-    ClassicUnionStrategy defaultUnionFunction;
-
-};
-
-
-} // namespace geos::operation::union
-} // namespace geos::operation
-} // namespace geos
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-