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

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/overlayng/OverlayNGRobust.h

@@ -1,174 +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.
- *
- **********************************************************************
- *
- * 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/Android-arm64-v8a/include/geos/operation/overlayng/OverlayPoints.h

@@ -1,120 +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 <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/Android-arm64-v8a/include/geos/operation/overlayng/OverlayUtil.h

@@ -1,213 +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/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/Android-arm64-v8a/include/geos/operation/overlayng/PolygonBuilder.h

@@ -1,151 +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 <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
-