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

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/union/PointGeometryUnion.h

@@ -1,72 +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/PointGeometryUnion.java r320 (JTS-1.12)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <vector>
-#include <algorithm>
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class GeometryFactory;
-class Geometry;
-}
-}
-
-namespace geos {
-namespace operation { // geos::operation
-namespace geounion {  // geos::operation::geounion
-
-/**
- * \brief
- * Computes the union of a puntal geometry with another
- * arbitrary [Geometry](@ref geom::Geometry).
- *
- * Does not copy any component geometries.
- *
- */
-class GEOS_DLL PointGeometryUnion {
-public:
-
-    static std::unique_ptr<geom::Geometry> Union(
-        const geom::Geometry& pointGeom,
-        const geom::Geometry& otherGeom);
-
-
-    PointGeometryUnion(const geom::Geometry& pointGeom,
-                       const geom::Geometry& otherGeom);
-
-    std::unique_ptr<geom::Geometry> Union() const;
-
-private:
-    const geom::Geometry& pointGeom;
-    const geom::Geometry& otherGeom;
-    const geom::GeometryFactory* geomFact;
-
-    // Declared as non-copyable
-    PointGeometryUnion(const PointGeometryUnion& other);
-    PointGeometryUnion& operator=(const PointGeometryUnion& rhs);
-};
-
-} // namespace geos::operation::union
-} // namespace geos::operation
-} // namespace geos
-

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/union/UnaryUnionOp.h

@@ -1,243 +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>
-
-#include <geos/util.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)
-    {
-        util::ensureNoCurvedComponents(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
-

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/union/UnionStrategy.h

@@ -1,73 +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.
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <memory>
-
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Geometry;
-}
-}
-
-namespace geos {
-namespace operation { // geos::operation
-namespace geounion {  // geos::operation::geounion
-
-/**
- * A strategy class that adapts UnaryUnion to different
- * kinds of overlay algorithms.
- *
- * @author Martin Davis
- *
- */
-class GEOS_DLL UnionStrategy {
-
-public:
-
-    virtual ~UnionStrategy() {};
-
-    /**
-    * Computes the union of two geometries.
-    * This method may throw a {@link util::TopologyException}
-    * if one is encountered
-    */
-    virtual std::unique_ptr<geom::Geometry> Union(const geom::Geometry*, const geom::Geometry*) = 0;
-
-    virtual std::unique_ptr<geom::Geometry> Union(std::unique_ptr<geom::Geometry> &&,
-                                                  std::unique_ptr<geom::Geometry> &&);
-
-    /**
-    * 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 operation::union::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.
-    */
-    virtual bool isFloatingPrecision() const = 0;
-
-
-};
-
-} // namespace geos::operation::geounion
-} // namespace geos::operation
-} // namespace geos
-

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/valid/ConsistentAreaTester.h

@@ -1,137 +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.
- *
- **********************************************************************
- *
- * Last port: operation/valid/ConsistentAreaTester.java rev. 1.14 (JTS-1.10)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <geos/geom/Coordinate.h> // for composition
-#include <geos/algorithm/LineIntersector.h> // for composition
-#include <geos/operation/relate/RelateNodeGraph.h> // for composition
-
-// Forward declarations
-namespace geos {
-namespace algorithm {
-class LineIntersector;
-}
-namespace geomgraph {
-class GeometryGraph;
-}
-namespace operation {
-namespace relate {
-class RelateNodeGraph;
-}
-}
-}
-
-namespace geos {
-namespace operation { // geos::operation
-namespace valid { // geos::operation::valid
-
-/** \brief
- * Checks that a geomgraph::GeometryGraph representing an area
- * (a geom::Polygon or geom::MultiPolygon)
- * has consistent semantics for area geometries.
- * This check is required for any reasonable polygonal model
- * (including the OGC-SFS model, as well as models which allow ring
- * self-intersection at single points)
- *
- * Checks include:
- *
- *  - test for rings which properly intersect
- *    (but not for ring self-intersection, or intersections at vertices)
- *  - test for consistent labelling at all node points
- *    (this detects vertex intersections with invalid topology,
- *    i.e. where the exterior side of an edge lies in the interior of the area)
- *  - test for duplicate rings
- *
- * If an inconsistency is found the location of the problem
- * is recorded and is available to the caller.
- *
- */
-class GEOS_DLL ConsistentAreaTester {
-private:
-
-    algorithm::LineIntersector li;
-
-    /// Not owned
-    geomgraph::GeometryGraph* geomGraph;
-
-    relate::RelateNodeGraph nodeGraph;
-
-    /// the intersection point found (if any)
-    geom::Coordinate invalidPoint;
-
-    /**
-     * Check all nodes to see if their labels are consistent.
-     * If any are not, return false
-     */
-    bool isNodeEdgeAreaLabelsConsistent();
-
-public:
-
-    /**
-     * Creates a new tester for consistent areas.
-     *
-     * @param newGeomGraph the topology graph of the area geometry.
-     *                     Caller keeps responsibility for its deletion
-     */
-    ConsistentAreaTester(geomgraph::GeometryGraph* newGeomGraph);
-
-    ~ConsistentAreaTester() = default;
-
-    /**
-     * @return the intersection point, or <code>null</code>
-     *         if none was found
-     */
-    geom::Coordinate& getInvalidPoint();
-
-    /** \brief
-     * Check all nodes to see if their labels are consistent with
-     * area topology.
-     *
-     * @return <code>true</code> if this area has a consistent node
-     *         labelling
-     */
-    bool isNodeConsistentArea();
-
-    /**
-     * Checks for two duplicate rings in an area.
-     * Duplicate rings are rings that are topologically equal
-     * (that is, which have the same sequence of points up to point order).
-     * If the area is topologically consistent (determined by calling the
-     * <code>isNodeConsistentArea</code>,
-     * duplicate rings can be found by checking for EdgeBundles which contain
-     * more than one geomgraph::EdgeEnd.
-     * (This is because topologically consistent areas cannot have two rings sharing
-     * the same line segment, unless the rings are equal).
-     * The start point of one of the equal rings will be placed in
-     * invalidPoint.
-     *
-     * @return true if this area Geometry is topologically consistent but has two duplicate rings
-     */
-    bool hasDuplicateRings();
-};
-
-
-
-} // namespace geos::operation::valid
-} // namespace geos::operation
-} // namespace geos
-

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/valid/IndexedNestedHoleTester.h

@@ -1,83 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2021 Paul Ramsey <pramsey@cleverelephant.ca>
- * Copyright (C) 2021 Martin Davis
- *
- * 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/index/strtree/TemplateSTRtree.h>
-
-#include <memory>
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Coordinate;
-class Polygon;
-class LinearRing;
-}
-}
-
-
-namespace geos {      // geos.
-namespace operation { // geos.operation
-namespace valid {     // geos.operation.valid
-
-using geos::geom::Polygon;
-using geos::geom::LinearRing;
-using geos::geom::CoordinateXY;
-
-
-class GEOS_DLL IndexedNestedHoleTester {
-
-private:
-
-    const Polygon* polygon;
-    index::strtree::TemplateSTRtree<const LinearRing*> index;
-    CoordinateXY nestedPt;
-
-    void loadIndex();
-
-
-public:
-
-    IndexedNestedHoleTester(const Polygon* p_polygon)
-        : polygon(p_polygon)
-    {
-        loadIndex();
-    }
-
-    /**
-    * Gets a point on a nested hole, if one exists.
-    *
-    * @return a point on a nested hole, or null if none are nested
-    */
-    const CoordinateXY& getNestedPoint() { return nestedPt; }
-
-    /**
-    * Tests if any hole is nested (contained) within another hole.
-    * This is invalid.
-    * The nested point will be set to reflect this.
-    * @return true if some hole is nested
-    */
-    bool isNested();
-
-};
-
-
-
-} // namespace geos.operation.valid
-} // namespace geos.operation
-} // namespace geos
-