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

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/overlayng/OverlayNGRobust.h

@@ -0,0 +1,174 @@
+/**********************************************************************
+ *
+ * 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: operation/overlayng/OverlayNGRobust.java 6ef89b09
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/PrecisionModel.h>
+#include <geos/operation/union/UnionStrategy.h>
+#include <geos/operation/overlayng/OverlayNG.h>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+
+/**
+ * Performs an overlay operation, increasing robustness by using a series of
+ * increasingly aggressive (and slower) noding strategies.
+ *
+ * The noding strategies used are:
+ *
+ *  - A simple, fast noder using FLOATING precision.
+ *  - A {@link noding::snap::SnappingNoder} using an automatically-determined snap tolerance
+ *  - First snapping each geometry to itself,
+ *    and then overlaying them using a SnappingNoder.
+ *  - The above two strategies are repeated with increasing snap tolerance, up to a limit.
+ *
+ * If the above heuristics still fail to compute a valid overlay,
+ * the original {@link util::TopologyException} is thrown.
+ *
+ * This algorithm relies on each overlay operation execution
+ * throwing a {@link util::TopologyException} if it is unable
+ * to compute the overlay correctly.
+ * Generally this occurs because the noding phase does
+ * not produce a valid noding.
+ * This requires the use of a {@link noding::ValidatingNoder}
+ * in order to check the results of using a floating noder.
+ *
+ * @author Martin Davis
+ */
+class GEOS_DLL OverlayNGRobust {
+
+private:
+
+
+    // Constants
+    static constexpr int NUM_SNAP_TRIES = 5;
+    /**
+    * A factor for a snapping tolerance distance which
+    * should allow noding to be computed robustly.
+    */
+    static constexpr double SNAP_TOL_FACTOR = 1e12;
+
+    static std::unique_ptr<Geometry> overlaySnapping(
+        const Geometry* geom0, const Geometry* geom1, int opCode, double snapTol);
+
+    static std::unique_ptr<Geometry> overlaySnapBoth(
+        const Geometry* geom0, const Geometry* geom1, int opCode, double snapTol);
+
+    static std::unique_ptr<Geometry> overlaySnapTol(
+        const Geometry* geom0, const Geometry* geom1, int opCode, double snapTol);
+
+    static double snapTolerance(const Geometry* geom);
+
+    /**
+    * Computes the largest magnitude of the ordinates of a geometry,
+    * based on the geometry envelope.
+    *
+    * @param geom a geometry
+    * @return the magnitude of the largest ordinate
+    */
+    static double ordinateMagnitude(const Geometry* geom);
+
+    /**
+    * Overlay using Snap-Rounding with an automatically-determined
+    * scale factor.
+    *
+    * NOTE: currently this strategy is not used, since all known
+    * test cases work using one of the Snapping strategies.
+    */
+    static std::unique_ptr<Geometry>
+    overlaySR(const Geometry* geom0, const Geometry* geom1, int opCode);
+
+	/**
+   	 * Self-snaps a geometry by running a union operation with it as the only input.
+   	 * This helps to remove narrow spike/gore artifacts to simplify the geometry,
+   	 * which improves robustness.
+   	 * Collapsed artifacts are removed from the result to allow using
+   	 * it in further overlay operations.
+   	 *
+   	 * @param geom geometry to self-snap
+   	 * @param snapTol snap tolerance
+   	 * @return the snapped geometry (homogeneous)
+   	 */
+	static std::unique_ptr<Geometry>
+	snapSelf(const Geometry* geom, double snapTol);
+
+
+public:
+
+    class SRUnionStrategy : public operation::geounion::UnionStrategy {
+
+        std::unique_ptr<geom::Geometry> Union(const geom::Geometry* g0, const geom::Geometry* g1) override
+        {
+            return OverlayNGRobust::Overlay(g0, g1, OverlayNG::UNION);
+        };
+
+        bool isFloatingPrecision() const override
+        {
+            return true;
+        };
+
+    };
+
+    static std::unique_ptr<Geometry> Intersection(
+        const Geometry* g0, const Geometry* g1);
+
+    static std::unique_ptr<Geometry> Union(
+        const Geometry* g0, const Geometry* g1);
+
+    static std::unique_ptr<Geometry> Difference(
+        const Geometry* g0, const Geometry* g1);
+
+    static std::unique_ptr<Geometry> SymDifference(
+        const Geometry* g0, const Geometry* g1);
+
+    static std::unique_ptr<Geometry> Union(
+        const Geometry* a);
+
+    static std::unique_ptr<Geometry> Overlay(
+        const Geometry* geom0, const Geometry* geom1, int opCode);
+
+    static std::unique_ptr<Geometry> overlaySnapTries(
+        const Geometry* geom0, const Geometry* geom1, int opCode);
+
+    /**
+    * Computes a heuristic snap tolerance distance
+    * for overlaying a pair of geometries using a {@link noding::snap::SnappingNoder}.
+    */
+    static double snapTolerance(const Geometry* geom0, const Geometry* geom1);
+
+
+
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/overlayng/OverlayPoints.h

@@ -0,0 +1,120 @@
+/**********************************************************************
+ *
+ * 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 <geos/geom/Geometry.h>
+#include <geos/geom/Point.h>
+
+#include <map>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class CoordinateSequence;
+class GeometryFactory;
+class Geometry;
+class PrecisionModel;
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+using namespace geos::geom;
+
+/**
+ * Performs an overlay operation on inputs which are both point geometries.
+ *
+ * Semantics are:
+ *
+ *  - Points are rounded to the precision model if provided
+ *  - Points with identical XY values are merged to a single point
+ *  - Extended ordinate values are preserved in the output,
+ *    apart from merging
+ *  - An empty result is returned as <code>POINT EMPTY</code>
+ *
+ * @author Martin Davis
+ */
+class GEOS_DLL OverlayPoints {
+
+private:
+
+    // Members
+    int opCode;
+    const Geometry* geom0;
+    const Geometry* geom1;
+    const PrecisionModel* pm;
+    const GeometryFactory* geometryFactory;
+    std::vector<std::unique_ptr<Point>> resultList;
+
+    using PointMap = std::map<CoordinateXY, std::unique_ptr<Point>>;
+
+    // Methods
+    void
+    computeIntersection(PointMap& map0,
+                        PointMap& map1,
+                        std::vector<std::unique_ptr<Point>>& resultList);
+
+    void
+    computeDifference(PointMap& map0,
+                      PointMap& map1,
+                      std::vector<std::unique_ptr<Point>>& resultList);
+
+    void
+    computeUnion(PointMap& map0,
+                 PointMap& map1,
+                 std::vector<std::unique_ptr<Point>>& resultList);
+
+    PointMap buildPointMap(const Geometry* geom);
+
+public:
+
+    /**
+    * Creates an instance of an overlay operation on inputs which are both point geometries.
+    */
+    OverlayPoints(int p_opCode, const Geometry* p_geom0, const Geometry* p_geom1, const PrecisionModel* p_pm)
+        : opCode(p_opCode)
+        , geom0(p_geom0)
+        , geom1(p_geom1)
+        , pm(p_pm)
+        , geometryFactory(p_geom0->getFactory()) {}
+
+    OverlayPoints(const OverlayPoints&) = delete;
+    OverlayPoints& operator=(const OverlayPoints&) = delete;
+
+    /**
+    * Performs an overlay operation on inputs which are both point geometries.
+    */
+    static std::unique_ptr<Geometry> overlay(int opCode, const Geometry* geom0, const Geometry* geom1, const PrecisionModel* pm);
+
+    /**
+    * Gets the result of the overlay.
+    *
+    * @return the overlay result
+    */
+    std::unique_ptr<Geometry> getResult();
+
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/overlayng/OverlayUtil.h

@@ -0,0 +1,213 @@
+/**********************************************************************
+ *
+ * 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/geom/Point.h>
+#include <geos/geom/Polygon.h>
+#include <geos/geom/LineString.h>
+#include <geos/geom/Geometry.h>
+
+#include <geos/export.h>
+
+#include <vector>
+#include <memory>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class CoordinateSequence;
+class Envelope;
+class GeometryFactory;
+class PrecisionModel;
+}
+namespace operation {
+namespace overlayng {
+class InputGeometry;
+class OverlayGraph;
+}
+}
+}
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+using namespace geos::geom;
+
+/**
+ * Utility methods for overlay processing.
+ *
+ * @author mdavis
+ *
+ */
+class GEOS_DLL OverlayUtil {
+
+private:
+
+    static constexpr double SAFE_ENV_BUFFER_FACTOR = 0.1;
+    static constexpr int SAFE_ENV_GRID_FACTOR = 3;
+    static constexpr double AREA_HEURISTIC_TOLERANCE = 0.1;
+
+    /**
+    * Computes an envelope which covers the extent of the result of
+    * a given overlay operation for given inputs.
+    * The operations which have a result envelope smaller than the extent of the inputs
+    * are:
+    *
+    * - INTERSECTION: result envelope is the intersection of the input envelopes
+    * - DIFERENCE: result envelope is the envelope of the A input geometry
+    *
+    * Otherwise, <code>null</code> is returned to indicate full extent.
+    */
+    static bool resultEnvelope(int opCode, const InputGeometry* inputGeom, const PrecisionModel* pm, Envelope& rsltEnvelope);
+    static double safeExpandDistance(const Envelope* env, const PrecisionModel* pm);
+    static bool safeEnv(const Envelope* env, const PrecisionModel* pm, Envelope& rsltEnvelope);
+
+    static bool isEmpty(const Geometry* geom);
+
+    /**
+    * Tests for disjoint envelopes adjusting for rounding
+    * caused by a fixed precision model.
+    * Assumes envelopes are non-empty.
+    */
+    static bool isDisjoint(const Envelope* envA, const Envelope* envB, const PrecisionModel* pm);
+
+    static bool isLess(double v1, double v2, double tol) {
+        return v1 <= v2 * (1 + tol);
+    };
+
+    static bool isGreater(double v1, double v2, double tol) {
+        return v1 >= v2 * (1 - tol);
+    }
+
+
+public:
+
+    static bool isFloating(const PrecisionModel* pm);
+
+    /**
+    * Computes a clipping envelope for overlay input geometries.
+    * The clipping envelope encloses all geometry line segments which
+    * might participate in the overlay, with a buffer to
+    * account for numerical precision
+    * (in particular, rounding due to a precision model.
+    * The clipping envelope is used in both the {@link RingClipper}
+    * and in the {@link LineLimiter}.
+    *
+    * Some overlay operations (i.e. UNION and SYMDIFFERENCE
+    * cannot use clipping as an optimization,
+    * since the result envelope is the full extent of the two input geometries.
+    * In this case the returned
+    * envelope is null to indicate this.
+    */
+    static bool clippingEnvelope(int opCode, const InputGeometry* inputGeom, const PrecisionModel* pm, Envelope& rsltEnvelope);
+
+    /**
+    * Tests if the result can be determined to be empty
+    * based on simple properties of the input geometries
+    * (such as whether one or both are empty,
+    * or their envelopes are disjoint).
+    */
+    static bool isEmptyResult(int opCode, const Geometry* a, const Geometry* b, const PrecisionModel* pm);
+
+    /**
+    * Tests if the geometry envelopes are disjoint, or empty.
+    * The disjoint test must take into account the precision model
+    * being used, since geometry coordinates may shift under rounding.
+    */
+    static bool isEnvDisjoint(const Geometry* a, const Geometry* b, const PrecisionModel* pm);
+
+    /**
+    * Creates an empty result geometry of the appropriate dimension,
+    * based on the given overlay operation and the dimensions of the inputs.
+    * The created geometry is an atomic geometry,
+    * not a collection (unless the dimension is -1,
+    * in which case a GEOMETRYCOLLECTION EMPTY is created.)
+    */
+    static std::unique_ptr<Geometry> createEmptyResult(int dim, const GeometryFactory* geomFact);
+
+    /**
+    * Computes the dimension of the result of
+    * applying the given operation to inputs
+    * with the given dimensions.
+    * This assumes that complete collapse does not occur.
+    *
+    * The result dimension is computed according to the following rules:
+    * - OverlayNG::INTERSECTION - result has the dimension of the lowest input dimension
+    * - OverlayNG::UNION - result has the dimension of the highest input dimension
+    * - OverlayNG::DIFFERENCE - result has the dimension of the left-hand input
+    * - OverlayNG::SYMDIFFERENCE - result has the dimension of the highest input dimension
+    * (since the Symmetric Difference is the Union of the Differences).
+    */
+    static int resultDimension(int opCode, int dim0, int dim1);
+
+    /**
+    * Creates an overlay result geometry for homogeneous or mixed components.
+    */
+    static std::unique_ptr<Geometry> createResultGeometry(
+        std::vector<std::unique_ptr<Polygon>>& resultPolyList,
+        std::vector<std::unique_ptr<LineString>>& resultLineList,
+        std::vector<std::unique_ptr<Point>>& resultPointList,
+        const GeometryFactory* geometryFactory);
+
+    static std::unique_ptr<Geometry> toLines(OverlayGraph* graph, bool isOutputEdges, const GeometryFactory* geomFact);
+
+    /**
+    * A heuristic check for overlay result correctness
+    * comparing the areas of the input and result.
+    * The heuristic is necessarily coarse, but it detects some obvious issues.
+    * (e.g. https://github.com/locationtech/jts/issues/798)
+    * <p>
+    * <b>Note:</b> - this check is only safe if the precision model is floating.
+    * It should also be safe for snapping noding if the distance tolerance is reasonably small.
+    * (Fixed precision models can lead to collapse causing result area to expand.)
+    *
+    * @param geom0 input geometry 0
+    * @param geom1 input geometry 1
+    * @param opCode the overlay opcode
+    * @param result the overlay result
+    * @return true if the result area is consistent
+    */
+    static bool isResultAreaConsistent(
+        const Geometry* geom0, const Geometry* geom1,
+        int opCode, const Geometry* result);
+
+    /**
+    * Round the key point if precision model is fixed.
+    * Note: return value is only copied if rounding is performed.
+    */
+    static bool round(const Point* pt, const PrecisionModel* pm, Coordinate& rsltCoord);
+
+    template<typename T>
+    static void moveGeometry(std::vector<std::unique_ptr<T>>& inGeoms, std::vector<std::unique_ptr<Geometry>>& outGeoms)
+    {
+        static_assert(std::is_base_of<Geometry, T>::value, "");
+        for (auto& geom: inGeoms) {
+            Geometry* outGeom = static_cast<Geometry*>(geom.release());
+            outGeoms.emplace_back(outGeom);
+        }
+        return;
+    }
+
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/overlayng/PolygonBuilder.h

@@ -0,0 +1,151 @@
+/**********************************************************************
+ *
+ * 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 <geos/geom/Polygon.h>
+#include <geos/operation/overlayng/OverlayEdge.h>
+#include <geos/operation/overlayng/OverlayEdgeRing.h>
+#include <geos/operation/overlayng/MaximalEdgeRing.h>
+
+#include <vector>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class GeometryFactory;
+class Geometry;
+class Polygon;
+}
+namespace operation {
+namespace overlayng {
+class Edge;
+}
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+class GEOS_DLL PolygonBuilder {
+
+private:
+
+    // Members
+    const geom::GeometryFactory* geometryFactory;
+    std::vector<OverlayEdgeRing*> shellList;
+    std::vector<OverlayEdgeRing*> freeHoleList;
+    bool isEnforcePolygonal;
+
+    // Storage
+    std::vector<std::unique_ptr<OverlayEdgeRing>> vecOER;
+
+    std::vector<std::unique_ptr<geom::Polygon>> computePolygons(const std::vector<OverlayEdgeRing*>& shellList) const;
+
+    void buildRings(const std::vector<OverlayEdge*>& resultAreaEdges);
+
+    static void linkResultAreaEdgesMax(const std::vector<OverlayEdge*>& resultEdges);
+
+    /**
+    * For all OverlayEdge*s in result, form them into MaximalEdgeRings
+    */
+    static std::vector<std::unique_ptr<MaximalEdgeRing>>
+        buildMaximalRings(const std::vector<OverlayEdge *> &edges);
+
+    /**
+    * The lifespan of the OverlayEdgeRings is tieds to the lifespan
+    * of the PolygonBuilder, so we hold them on the PolygonBuilder
+    * and use bare pointers for managing the relationships
+    */
+    std::vector<OverlayEdgeRing*> storeMinimalRings(std::vector<std::unique_ptr<OverlayEdgeRing>>& minRings);
+
+    void buildMinimalRings(const std::vector<std::unique_ptr<MaximalEdgeRing>>& maxRings);
+
+    void assignShellsAndHoles(const std::vector<OverlayEdgeRing *> &minRings);
+
+    /**
+    * Finds the single shell, if any, out of
+    * a list of minimal rings derived from a maximal ring.
+    * The other possibility is that they are a set of (connected) holes,
+    * in which case no shell will be found.
+    *
+    * @return the shell ring, if there is one
+    * or null, if all rings are holes
+    */
+    static OverlayEdgeRing* findSingleShell(const std::vector<OverlayEdgeRing *> &edgeRings) ;
+
+    /**
+    * For the set of minimal rings comprising a maximal ring,
+    * assigns the holes to the shell known to contain them.
+    * Assigning the holes directly to the shell serves two purposes:
+    *
+    *  - it is faster than using a point-in-polygon check later on.
+    *  - it ensures correctness, since if the PIP test was used the point
+    * chosen might lie on the shell, which might return an incorrect result from the
+    * PIP test
+    */
+    static void assignHoles(OverlayEdgeRing* shell, const std::vector<OverlayEdgeRing *> &edgeRings);
+
+
+    /**
+    * Place holes have not yet been assigned to a shell.
+    * These "free" holes should
+    * all be <b>properly</b> contained in their parent shells, so it is safe to use the
+    * <code>findEdgeRingContaining</code> method.
+    * (This is the case because any holes which are NOT
+    * properly contained (i.e. are connected to their
+    * parent shell) would have formed part of a MaximalEdgeRing
+    * and been handled in a previous step).
+    *
+    * @throws TopologyException if a hole cannot be assigned to a shell
+    */
+    void placeFreeHoles(const std::vector<OverlayEdgeRing*> & shellList, const std::vector<OverlayEdgeRing*>& freeHoleList) const;
+
+
+
+public:
+
+    PolygonBuilder(std::vector<OverlayEdge*>& resultAreaEdges, const geom::GeometryFactory* geomFact)
+        : geometryFactory(geomFact)
+        , isEnforcePolygonal(true)
+    {
+        buildRings(resultAreaEdges);
+    }
+
+    PolygonBuilder(std::vector<OverlayEdge*>& resultAreaEdges, const geom::GeometryFactory* geomFact, bool p_isEnforcePolygonal)
+        : geometryFactory(geomFact)
+        , isEnforcePolygonal(p_isEnforcePolygonal)
+    {
+        buildRings(resultAreaEdges);
+    }
+
+    PolygonBuilder(const PolygonBuilder&) = delete;
+    PolygonBuilder& operator=(const PolygonBuilder&) = delete;
+
+    // Methods
+    std::vector<std::unique_ptr<geom::Polygon>> getPolygons() const;
+    std::vector<OverlayEdgeRing*> getShellRings() const;
+
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+