@cpp.js/package-geos 1.0.0-beta.21 → 1.0.0-beta.23

package/dist/prebuilt/Android-x86_64/include/geos/operation/union/PointGeometryUnion.h

@@ -0,0 +1,72 @@
+/**********************************************************************
+ *
+ * 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/dist/prebuilt/Android-x86_64/include/geos/operation/union/UnaryUnionOp.h

@@ -0,0 +1,243 @@
+/**********************************************************************
+ *
+ * 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/dist/prebuilt/Android-x86_64/include/geos/operation/union/UnionStrategy.h

@@ -0,0 +1,73 @@
+/**********************************************************************
+ *
+ * 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/dist/prebuilt/Android-x86_64/include/geos/operation/valid/ConsistentAreaTester.h

@@ -0,0 +1,137 @@
+/**********************************************************************
+ *
+ * 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/dist/prebuilt/Android-x86_64/include/geos/operation/valid/IndexedNestedHoleTester.h

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