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

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

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

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

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

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