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

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/overlay/PolygonBuilder.h

@@ -0,0 +1,210 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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/overlay/PolygonBuilder.java rev. 1.20 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/algorithm/locate/IndexedPointInAreaLocator.h>
+
+#include <vector>
+
+#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 Geometry;
+class Coordinate;
+class GeometryFactory;
+}
+namespace geomgraph {
+class EdgeRing;
+class Node;
+class PlanarGraph;
+class DirectedEdge;
+}
+namespace operation {
+namespace overlay {
+class MaximalEdgeRing;
+class MinimalEdgeRing;
+}
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace overlay { // geos::operation::overlay
+
+/** \brief
+ * Forms Polygon out of a graph of geomgraph::DirectedEdge.
+ *
+ * The edges to use are marked as being in the result Area.
+ */
+class GEOS_DLL PolygonBuilder {
+public:
+
+    PolygonBuilder(const geom::GeometryFactory* newGeometryFactory);
+
+    ~PolygonBuilder();
+
+    /**
+     * Add a complete graph.
+     * The graph is assumed to contain one or more polygons,
+     * possibly with holes.
+     */
+    void add(geomgraph::PlanarGraph* graph);
+    // throw(const TopologyException &)
+
+    /**
+     * Add a set of edges and nodes, which form a graph.
+     * The graph is assumed to contain one or more polygons,
+     * possibly with holes.
+     */
+    void add(const std::vector<geomgraph::DirectedEdge*>* dirEdges,
+             const std::vector<geomgraph::Node*>* nodes);
+    // throw(const TopologyException &)
+
+    std::vector<std::unique_ptr<geom::Geometry>> getPolygons();
+
+private:
+
+    const geom::GeometryFactory* geometryFactory;
+
+    std::vector<geomgraph::EdgeRing*> shellList;
+
+    /**
+     * For all DirectedEdges in result, form them into MaximalEdgeRings
+     *
+     * @param maxEdgeRings
+     *   Formed MaximalEdgeRings will be pushed to this vector.
+     *   Ownership of the elements is transferred to caller.
+     */
+    void buildMaximalEdgeRings(
+        const std::vector<geomgraph::DirectedEdge*>* dirEdges,
+        std::vector<MaximalEdgeRing*>& maxEdgeRings);
+    // throw(const TopologyException &)
+
+    void buildMinimalEdgeRings(
+        std::vector<MaximalEdgeRing*>& maxEdgeRings,
+        std::vector<geomgraph::EdgeRing*>& newShellList,
+        std::vector<geomgraph::EdgeRing*>& freeHoleList,
+        std::vector<MaximalEdgeRing*>& edgeRings);
+
+    /**
+     * This method takes a list of MinimalEdgeRings derived from a
+     * MaximalEdgeRing, and tests whether they form a Polygon.
+     * This is the case if there is a single shell
+     * in the list.  In this case the shell is returned.
+     * The other possibility is that they are a series of connected
+     * holes, in which case no shell is returned.
+     *
+     * @return the shell geomgraph::EdgeRing, if there is one
+     * @return NULL, if all the rings are holes
+     */
+    geomgraph::EdgeRing* findShell(std::vector<MinimalEdgeRing*>* minEdgeRings);
+
+    /**
+     * This method assigns the holes for a Polygon (formed from a list of
+     * MinimalEdgeRings) to its shell.
+     * Determining the holes for a MinimalEdgeRing polygon 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
+     */
+    void placePolygonHoles(geomgraph::EdgeRing* shell,
+                           std::vector<MinimalEdgeRing*>* minEdgeRings);
+
+    /**
+     * For all rings in the input list,
+     * determine whether the ring is a shell or a hole
+     * and add it to the appropriate list.
+     * Due to the way the DirectedEdges were linked,
+     * a ring is a shell if it is oriented CW, a hole otherwise.
+     */
+    void sortShellsAndHoles(std::vector<MaximalEdgeRing*>& edgeRings,
+                            std::vector<geomgraph::EdgeRing*>& newShellList,
+                            std::vector<geomgraph::EdgeRing*>& freeHoleList);
+
+    struct FastPIPRing {
+        geomgraph::EdgeRing* edgeRing;
+        algorithm::locate::IndexedPointInAreaLocator* pipLocator;
+    };
+
+    /** \brief
+     * This method determines finds a containing shell for all holes
+     * which 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(std::vector<FastPIPRing>& newShellList,
+                        std::vector<geomgraph::EdgeRing*>& freeHoleList);
+    // throw(const TopologyException&)
+
+    /** \brief
+     * Find the innermost enclosing shell geomgraph::EdgeRing containing the
+     * argument geomgraph::EdgeRing, if any.
+     *
+     * The innermost enclosing ring is the <i>smallest</i> enclosing ring.
+     * The algorithm used depends on the fact that:
+     *
+     * ring A contains ring B iff envelope(ring A)
+     * contains envelope(ring B)
+     *
+     * This routine is only safe to use if the chosen point of the hole
+     * is known to be properly contained in a shell
+     * (which is guaranteed to be the case if the hole does not touch
+     * its shell)
+     *
+     * @return containing geomgraph::EdgeRing, if there is one
+     * @return NULL if no containing geomgraph::EdgeRing is found
+     */
+    geomgraph::EdgeRing* findEdgeRingContaining(geomgraph::EdgeRing* testEr,
+            std::vector<FastPIPRing>& newShellList);
+
+    std::vector<std::unique_ptr<geom::Geometry>> computePolygons(
+        std::vector<geomgraph::EdgeRing*>& newShellList);
+
+    /**
+     * Checks the current set of shells (with their associated holes) to
+     * see if any of them contain the point.
+     */
+
+};
+
+} // namespace geos::operation::overlay
+} // namespace geos::operation
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/overlay/snap/GeometrySnapper.h

@@ -0,0 +1,154 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2009-2010  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/overlay/snap/GeometrySnapper.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Coordinate.h>
+
+#include <memory>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+//class PrecisionModel;
+class Geometry;
+class CoordinateSequence;
+struct GeomPtrPair;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace overlay { // geos::operation::overlay
+namespace snap { // geos::operation::overlay::snap
+
+/** \brief
+ * Snaps the vertices and segments of a {@link geom::Geometry}
+ * to another Geometry's vertices.
+ *
+ * Where possible, this operation tries to avoid creating invalid geometries;
+ * however, it does not guarantee that output geometries will be valid.  It is
+ * the responsibility of the caller to check for and handle invalid geometries.
+ *
+ * Because too much snapping can result in invalid
+ * topology being created, heuristics are used to determine the number and
+ * location of snapped vertices that are likely safe to snap. These heuristics
+ * may omit some potential snaps that are otherwise within the tolerance.
+ *
+ */
+class GEOS_DLL GeometrySnapper {
+
+public:
+
+    typedef std::unique_ptr<geom::Geometry> GeomPtr;
+
+    /**
+     * Snaps two geometries together with a given tolerance.
+     *
+     * @param g0 a geometry to snap
+     * @param g1 a geometry to snap
+     * @param snapTolerance the tolerance to use
+     * @param ret the snapped geometries as a pair of smart pointers
+     *            (output parameter)
+     */
+    static void snap(const geom::Geometry& g0,
+                     const geom::Geometry& g1,
+                     double snapTolerance, geom::GeomPtrPair& ret);
+
+    static GeomPtr snapToSelf(const geom::Geometry& g0,
+                              double snapTolerance, bool cleanResult);
+
+    /**
+     * Creates a new snapper acting on the given geometry
+     *
+     * @param g the geometry to snap
+     */
+    GeometrySnapper(const geom::Geometry& g)
+        :
+        srcGeom(g)
+    {
+    }
+
+    /** \brief
+     * Snaps the vertices in the component {@link geom::LineString}s
+     * of the source geometry to the vertices of the given snap geometry
+     * with a given snap tolerance
+     *
+     * @param g a geometry to snap the source to
+     * @param snapTolerance
+     * @return a new snapped Geometry
+     */
+    std::unique_ptr<geom::Geometry> snapTo(const geom::Geometry& g,
+                                           double snapTolerance);
+
+    /** \brief
+     * Snaps the vertices in the component {@link geom::LineString}s
+     * of the source geometry to the vertices of itself
+     * with a given snap tolerance and optionally cleaning the result.
+     *
+     * @param snapTolerance
+     * @param cleanResult clean the result
+     * @return a new snapped Geometry
+     */
+    std::unique_ptr<geom::Geometry> snapToSelf(double snapTolerance,
+            bool cleanResult);
+
+    /** \brief
+     * Estimates the snap tolerance for a Geometry, taking into account
+     * its precision model.
+     *
+     * @param g a Geometry
+     * @return the estimated snap tolerance
+     */
+    static double computeOverlaySnapTolerance(const geom::Geometry& g);
+
+    static double computeSizeBasedSnapTolerance(const geom::Geometry& g);
+
+    /** \brief
+     * Computes the snap tolerance based on input geometries;
+     */
+    static double computeOverlaySnapTolerance(const geom::Geometry& g1,
+            const geom::Geometry& g2);
+
+
+private:
+
+    // eventually this will be determined from the geometry topology
+    //static const double snapTol; //  = 0.000001;
+
+    static const double snapPrecisionFactor; //  = 10e-10
+
+    const geom::Geometry& srcGeom;
+
+    /// Extract target (unique) coordinates
+    std::unique_ptr<geom::Coordinate::ConstVect> extractTargetCoordinates(
+        const geom::Geometry& g);
+
+    // Declare type as noncopyable
+    GeometrySnapper(const GeometrySnapper& other) = delete;
+    GeometrySnapper& operator=(const GeometrySnapper& rhs) = delete;
+};
+
+
+} // namespace geos::operation::overlay::snap
+} // namespace geos::operation::overlay
+} // namespace geos::operation
+} // namespace geos
+

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/overlay/snap/LineStringSnapper.h

@@ -0,0 +1,165 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2009-2010  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/overlay/snap/LineStringSnapper.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/CoordinateList.h>
+
+#include <memory>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+//class PrecisionModel;
+//class CoordinateSequence;
+class CoordinateList;
+class Geometry;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace overlay { // geos::operation::overlay
+namespace snap { // geos::operation::overlay::snap
+
+/** \brief
+ * Snaps the vertices and segments of a LineString to a set
+ * of target snap vertices.
+ *
+ * A snapping distance tolerance is used to control where snapping is performed.
+ *
+ */
+class GEOS_DLL LineStringSnapper {
+
+public:
+
+    /**
+     * Creates a new snapper using the given points
+     * as source points to be snapped.
+     *
+     * @param nSrcPts the points to snap
+     * @param nSnapTol the snap tolerance to use
+     */
+    LineStringSnapper(const geom::CoordinateSequence& nSrcPts,
+                      double nSnapTol)
+        :
+        srcPts(nSrcPts),
+        snapTolerance(nSnapTol),
+        allowSnappingToSourceVertices(false)
+    {
+        std::size_t s = srcPts.size();
+        isClosed = s < 2 ? false : srcPts[0].equals2D(srcPts[s - 1]);
+    }
+
+    // Snap points are assumed to be all distinct points (a set would be better, uh ?)
+    std::unique_ptr<geom::CoordinateSequence> snapTo(const geom::Coordinate::ConstVect& snapPts);
+
+    void
+    setAllowSnappingToSourceVertices(bool allow)
+    {
+        allowSnappingToSourceVertices = allow;
+    }
+
+private:
+
+    const geom::CoordinateSequence& srcPts;
+
+    double snapTolerance;
+
+    bool allowSnappingToSourceVertices;
+    bool isClosed;
+
+
+    // Modifies first arg
+    void snapVertices(geom::CoordinateList& srcCoords,
+                      const geom::Coordinate::ConstVect& snapPts);
+
+
+    // Returns snapPts.end() if no snap point is close enough (within snapTol distance)
+    geom::Coordinate::ConstVect::const_iterator findSnapForVertex(const geom::Coordinate& pt,
+            const geom::Coordinate::ConstVect& snapPts);
+
+    /** \brief
+     * Snap segments of the source to nearby snap vertices.
+     *
+     * Source segments are "cracked" at a snap vertex.
+     * A single input segment may be snapped several times
+     * to different snap vertices.
+     *
+     * For each distinct snap vertex, at most one source segment
+     * is snapped to.  This prevents "cracking" multiple segments
+     * at the same point, which would likely cause
+     * topology collapse when being used on polygonal linework.
+     *
+     * @param srcCoords the coordinates of the source linestring to be snapped
+     *                  the object will be modified (coords snapped)
+     * @param snapPts the target snap vertices                                       */
+    void snapSegments(geom::CoordinateList& srcCoords,
+                      const geom::Coordinate::ConstVect& snapPts);
+
+    /// \brief
+    /// Finds a src segment which snaps to (is close to) the given snap
+    /// point.
+    ///
+    /// Only a single segment is selected for snapping.
+    /// This prevents multiple segments snapping to the same snap vertex,
+    /// which would almost certainly cause invalid geometry
+    /// to be created.
+    /// (The heuristic approach to snapping used here
+    /// is really only appropriate when
+    /// snap pts snap to a unique spot on the src geometry.)
+    ///
+    /// Also, if the snap vertex occurs as a vertex in the src
+    /// coordinate list, no snapping is performed (may be changed
+    /// using setAllowSnappingToSourceVertices).
+    ///
+    /// @param from
+    ///        an iterator to first point of first segment to be checked
+    ///
+    /// @param too_far
+    ///        an iterator to last point of last segment to be checked
+    ///
+    /// @returns an iterator to the snapped segment or
+    ///          too_far if no segment needs snapping
+    ///          (either none within snapTol distance,
+    ///           or one found on the snapPt)
+    ///
+    geom::CoordinateList::iterator findSegmentToSnap(
+        const geom::Coordinate& snapPt,
+        geom::CoordinateList::iterator from,
+        geom::CoordinateList::iterator too_far);
+
+    geom::CoordinateList::iterator findVertexToSnap(
+        const geom::Coordinate& snapPt,
+        geom::CoordinateList::iterator from,
+        geom::CoordinateList::iterator too_far);
+
+    // Declare type as noncopyable
+    LineStringSnapper(const LineStringSnapper& other) = delete;
+    LineStringSnapper& operator=(const LineStringSnapper& rhs) = delete;
+};
+
+
+} // namespace geos::operation::overlay::snap
+} // namespace geos::operation::overlay
+} // namespace geos::operation
+} // namespace geos
+

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/overlay/snap/SnapOverlayOp.h

@@ -0,0 +1,134 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2009  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/overlay/snap/SnapOverlayOp.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/precision/CommonBitsRemover.h> // for dtor visibility by unique_ptr
+#include <geos/operation/overlayng/OverlayNG.h>
+
+#include <memory> // for unique_ptr
+
+#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 Geometry;
+struct GeomPtrPair;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace overlay { // geos::operation::overlay
+namespace snap { // geos::operation::overlay::snap
+
+/** \brief
+ * Performs an overlay operation using snapping and enhanced precision
+ * to improve the robustness of the result.
+ *
+ * This class <i>always</i> uses snapping.
+ * This is less performant than the standard JTS overlay code,
+ * and may even introduce errors which were not present in the original data.
+ * For this reason, this class should only be used
+ * if the standard overlay code fails to produce a correct result.
+ *
+ */
+class GEOS_DLL SnapOverlayOp {
+
+public:
+
+    static std::unique_ptr<geom::Geometry>
+    overlayOp(const geom::Geometry& g0, const geom::Geometry& g1, int opCode)
+    {
+        SnapOverlayOp op(g0, g1);
+        return op.getResultGeometry(opCode);
+    }
+
+    static std::unique_ptr<geom::Geometry>
+    intersection(const geom::Geometry& g0, const geom::Geometry& g1)
+    {
+        return overlayOp(g0, g1, overlayng::OverlayNG::INTERSECTION);
+    }
+
+    static std::unique_ptr<geom::Geometry>
+    Union(const geom::Geometry& g0, const geom::Geometry& g1)
+    {
+        return overlayOp(g0, g1, overlayng::OverlayNG::UNION);
+    }
+
+    static std::unique_ptr<geom::Geometry>
+    difference(const geom::Geometry& g0, const geom::Geometry& g1)
+    {
+        return overlayOp(g0, g1, overlayng::OverlayNG::DIFFERENCE);
+    }
+
+    static std::unique_ptr<geom::Geometry>
+    symDifference(const geom::Geometry& g0, const geom::Geometry& g1)
+    {
+        return overlayOp(g0, g1, overlayng::OverlayNG::SYMDIFFERENCE);
+    }
+
+    SnapOverlayOp(const geom::Geometry& g1, const geom::Geometry& g2)
+        :
+        geom0(g1),
+        geom1(g2)
+    {
+        computeSnapTolerance();
+    }
+
+    std::unique_ptr<geom::Geometry> getResultGeometry(int opCode);
+
+private:
+
+    void computeSnapTolerance();
+
+    void snap(geom::GeomPtrPair& ret);
+
+    void removeCommonBits(const geom::Geometry& geom0,
+                          const geom::Geometry& geom1,
+                          geom::GeomPtrPair& ret);
+
+    // re-adds common bits to the given geom
+    void prepareResult(geom::Geometry& geom);
+
+
+    const geom::Geometry& geom0;
+    const geom::Geometry& geom1;
+
+    double snapTolerance;
+
+    std::unique_ptr<precision::CommonBitsRemover> cbr;
+
+    // Declare type as noncopyable
+    SnapOverlayOp(const SnapOverlayOp& other) = delete;
+    SnapOverlayOp& operator=(const SnapOverlayOp& rhs) = delete;
+};
+
+} // namespace geos::operation::overlay::snap
+} // namespace geos::operation::overlay
+} // namespace geos::operation
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+