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

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/polygonize/PolygonizeGraph.h

@@ -1,214 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 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/polygonize/PolygonizeGraph.java rev. 974
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <geos/planargraph/PlanarGraph.h> // for inheritance
-
-#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 LineString;
-class GeometryFactory;
-class Coordinate;
-class CoordinateSequence;
-}
-namespace planargraph {
-class Node;
-class Edge;
-class DirectedEdge;
-}
-namespace operation {
-namespace polygonize {
-class EdgeRing;
-class PolygonizeDirectedEdge;
-}
-}
-}
-
-namespace geos {
-namespace operation { // geos::operation
-namespace polygonize { // geos::operation::polygonize
-
-
-/** \brief
- * Represents a planar graph of edges that can be used to compute a
- * polygonization, and implements the algorithms to compute the
- * EdgeRings formed by the graph.
- *
- * The marked flag on DirectedEdge is used to indicate that a directed edge
- * has be logically deleted from the graph.
- *
- */
-class GEOS_DLL PolygonizeGraph: public planargraph::PlanarGraph {
-
-public:
-
-    /**
-     * \brief
-     * Deletes all edges at a node
-     */
-    static void deleteAllEdges(planargraph::Node* node);
-
-    /**
-     * \brief
-     * Create a new polygonization graph.
-     */
-    explicit PolygonizeGraph(const geom::GeometryFactory* newFactory);
-
-    /**
-     * \brief
-     * Destroy a polygonization graph.
-     */
-    ~PolygonizeGraph() override;
-
-    /**
-     * \brief
-     * Add a LineString forming an edge of the polygon graph.
-     * @param line the line to add
-     */
-    void addEdge(const geom::LineString* line);
-
-    /**
-     * \brief
-     * Computes the EdgeRings formed by the edges in this graph.
-     *
-     * @param edgeRingList : the EdgeRing found by the
-     * 	polygonization process will be pushed here.
-     *
-     */
-    void getEdgeRings(std::vector<EdgeRing*>& edgeRingList);
-
-    /**
-     * \brief
-     * Finds and removes all cut edges from the graph.
-     *
-     * @param cutLines : the list of the LineString forming the removed
-     *                   cut edges will be pushed here.
-     *
-     * TODO: document ownership of the returned LineStrings
-     */
-    void deleteCutEdges(std::vector<const geom::LineString*>& cutLines);
-
-    /** \brief
-     * Marks all edges from the graph which are "dangles".
-     *
-     * Dangles are which are incident on a node with degree 1.
-     * This process is recursive, since removing a dangling edge
-     * may result in another edge becoming a dangle.
-     * In order to handle large recursion depths efficiently,
-     * an explicit recursion stack is used
-     *
-     * @param dangleLines : the LineStrings that formed dangles will
-     *                      be push_back'ed here
-     */
-    void deleteDangles(std::vector<const geom::LineString*>& dangleLines);
-
-private:
-
-    static int getDegreeNonDeleted(planargraph::Node* node);
-
-    static int getDegree(planargraph::Node* node, long label);
-
-    const geom::GeometryFactory* factory;
-
-    planargraph::Node* getNode(const geom::Coordinate& pt);
-
-    void computeNextCWEdges();
-
-    /**
-     * \brief
-     * Convert the maximal edge rings found by the initial graph traversal
-     * into the minimal edge rings required by JTS polygon topology rules.
-     *
-     * @param ringEdges
-     * 	the list of start edges for the edgeRings to convert.
-     *
-     */
-    void convertMaximalToMinimalEdgeRings(
-        std::vector<PolygonizeDirectedEdge*>& ringEdges);
-
-    /**
-     * \brief
-     * Finds all nodes in a maximal edgering
-     * which are self-intersection nodes
-     *
-     * @param startDE
-     * @param label
-     * @param intNodes : intersection nodes found will be pushed here
-     *                   the vector won't be cleared before pushing.
-     */
-    static void findIntersectionNodes(PolygonizeDirectedEdge* startDE,
-                                      long label, std::vector<planargraph::Node*>& intNodes
-                                     );
-
-    /**
-     * Finds and labels all edgerings in the graph.
-     *
-     * The edge rings are labeling with unique integers.
-     * The labeling allows detecting cut edges.
-     *
-     * @param dirEdgesIn  a list of the DirectedEdges in the graph
-     * @param dirEdgesOut each ring found will be pushed here
-     */
-    static void findLabeledEdgeRings(
-        std::vector<planargraph::DirectedEdge*>& dirEdgesIn,
-        std::vector<PolygonizeDirectedEdge*>& dirEdgesOut);
-
-    static void label(std::vector<PolygonizeDirectedEdge*>& dirEdges, long label);
-    static void label(std::vector<planargraph::DirectedEdge*>& dirEdges, long label);
-
-    static void computeNextCWEdges(planargraph::Node* node);
-
-    /**
-     * \brief
-     * Computes the next edge pointers going CCW around the given node,
-     * for the given edgering label.
-     * This algorithm has the effect of converting maximal edgerings
-     * into minimal edgerings
-     */
-    static void computeNextCCWEdges(planargraph::Node* node, long label);
-
-    EdgeRing* findEdgeRing(PolygonizeDirectedEdge* startDE);
-
-    /* These are for memory management */
-    std::vector<planargraph::Edge*> newEdges;
-    std::vector<planargraph::DirectedEdge*> newDirEdges;
-    std::vector<planargraph::Node*> newNodes;
-    std::vector<EdgeRing*> newEdgeRings;
-    std::vector<geom::CoordinateSequence*> newCoords;
-};
-
-} // namespace geos::operation::polygonize
-} // namespace geos::operation
-} // namespace geos
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/polygonize/Polygonizer.h

@@ -1,260 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2010 Sandro Santilli <strk@kbt.io>
- * Copyright (C) 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/polygonize/Polygonizer.java 0b3c7e3eb0d3e
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <geos/geom/Polygon.h>
-#include <geos/geom/GeometryComponentFilter.h> // for LineStringAdder inheritance
-#include <geos/operation/polygonize/PolygonizeGraph.h>
-
-#include <memory>
-#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 LineString;
-
-class Polygon;
-}
-namespace operation {
-namespace polygonize {
-class EdgeRing;
-}
-}
-}
-
-namespace geos {
-namespace operation { // geos::operation
-namespace polygonize { // geos::operation::polygonize
-
-/** \brief
- * Polygonizes a set of Geometrys which contain linework that
- * represents the edges of a planar graph.
- *
- * All types of Geometry are accepted as input; the constituent linework is extracted
- * as the edges to be polygonized.
- * The edges must be correctly noded; that is, they must only meet
- * at their endpoints. Polygonization will accept incorrectly noded input but will
- * not form polygons from non-noded edges, and reports them as errors.
- *
- * The Polygonizer reports the follow kinds of errors:
- *
- * - <b>Dangles</b> - edges which have one or both ends which are
- *   not incident on another edge endpoint
- * - <b>Cut Edges</b> - edges which are connected at both ends but
- *   which do not form part of a polygon
- * - <b>Invalid Ring Lines</b> - edges which form rings which are invalid
- *   (e.g. the component lines contain a self-intersection)
- *
- *   The Polygonizer constructor allows extracting only polygons which form a
- *   valid polygonal result.
- *   The set of extracted polygons is guaranteed to be edge-disjoint.
- *   This is useful when it is known that the input lines form a valid
- *   polygonal geometry (which may include holes or nested polygons).
- *
- */
-class GEOS_DLL Polygonizer {
-private:
-    /**
-     * Add every linear element in a geometry into the polygonizer graph.
-     */
-    class GEOS_DLL LineStringAdder: public geom::GeometryComponentFilter {
-    public:
-        Polygonizer* pol;
-        explicit LineStringAdder(Polygonizer* p);
-        //void filter_rw(geom::Geometry *g);
-        void filter_ro(const geom::Geometry* g) override;
-    };
-
-    // default factory
-    LineStringAdder lineStringAdder;
-
-    /**
-     * Add a linestring to the graph of polygon edges.
-     *
-     * @param line the {@link LineString} to add
-     */
-    void add(const geom::LineString* line);
-
-    /**
-     * Perform the polygonization, if it has not already been carried out.
-     */
-    void polygonize();
-
-    static void findValidRings(const std::vector<EdgeRing*>& edgeRingList,
-                               std::vector<EdgeRing*>& validEdgeRingList,
-                               std::vector<EdgeRing*>& invalidRingList);
-
-    /**
-     * Extracts unique lines for invalid rings,
-     * discarding rings which correspond to outer rings and hence contain
-     * duplicate linework.
-     */
-    std::vector<std::unique_ptr<geom::LineString>> extractInvalidLines(
-            std::vector<EdgeRing*>& invalidRings);
-
-    /**
-     * Tests if a invalid ring should be included in
-     * the list of reported invalid rings.
-     *
-     * Rings are included only if they contain
-     * linework which is not already in a valid ring,
-     * or in an already-included ring.
-     *
-     * Because the invalid rings list is sorted by extent area,
-     * this results in outer rings being discarded,
-     * since all their linework is reported in the rings they contain.
-     *
-     * @param invalidRing the ring to test
-     * @return true if the ring should be included
-     */
-    bool isIncludedInvalid(EdgeRing* invalidRing);
-
-    void findShellsAndHoles(const std::vector<EdgeRing*>& edgeRingList);
-
-    void findDisjointShells();
-
-    static void findOuterShells(std::vector<EdgeRing*>& shellList);
-
-    static std::vector<std::unique_ptr<geom::Polygon>> extractPolygons(std::vector<EdgeRing*> & shellList, bool includeAll);
-
-    bool extractOnlyPolygonal;
-    bool computed;
-
-protected:
-
-    std::unique_ptr<PolygonizeGraph> graph;
-
-    // initialize with empty collections, in case nothing is computed
-    std::vector<const geom::LineString*> dangles;
-    std::vector<const geom::LineString*> cutEdges;
-    std::vector<std::unique_ptr<geom::LineString>> invalidRingLines;
-
-    std::vector<EdgeRing*> holeList;
-    std::vector<EdgeRing*> shellList;
-    std::vector<std::unique_ptr<geom::Polygon>> polyList;
-
-public:
-
-    /** \brief
-     * Create a Polygonizer with the same GeometryFactory
-     * as the input Geometrys.
-     *
-     * @param onlyPolygonal true if only polygons which form a valid polygonal geometry should be extracted
-     */
-    explicit Polygonizer(bool onlyPolygonal = false);
-
-    ~Polygonizer() = default;
-
-    /** \brief
-     * Add a collection of geometries to be polygonized.
-     * May be called multiple times.
-     * Any dimension of Geometry may be added;
-     * the constituent linework will be extracted and used
-     *
-     * @param geomList a list of Geometry with linework to be polygonized
-     */
-    void add(std::vector<geom::Geometry*>* geomList);
-
-    /** \brief
-     * Add a collection of geometries to be polygonized.
-     * May be called multiple times.
-     * Any dimension of Geometry may be added;
-     * the constituent linework will be extracted and used
-     *
-     * @param geomList a list of Geometry with linework to be polygonized
-     */
-    void add(std::vector<const geom::Geometry*>* geomList);
-
-    /**
-     * Add a geometry to the linework to be polygonized.
-     * May be called multiple times.
-     * Any dimension of Geometry may be added;
-     * the constituent linework will be extracted and used
-     *
-     * @param g a Geometry with linework to be polygonized
-     */
-    void add(const geom::Geometry* g);
-
-    /** \brief
-     * Gets the list of polygons formed by the polygonization.
-     *
-     * Ownership of vector is transferred to caller, subsequent
-     * calls will return NULL.
-     * @return a collection of Polygons
-     */
-    std::vector<std::unique_ptr<geom::Polygon>> getPolygons();
-
-    /** \brief
-     * Get the list of dangling lines found during polygonization.
-     *
-     * @return a (possibly empty) collection of pointers to
-     *         the input LineStrings which are dangles.
-     *
-     */
-    const std::vector<const geom::LineString*>& getDangles();
-
-    bool hasDangles();
-
-    /** \brief
-     * Get the list of cut edges found during polygonization.
-     *
-     * @return a (possibly empty) collection of pointers to
-     *         the input LineStrings which are cut edges.
-     *
-     */
-    const std::vector<const geom::LineString*>& getCutEdges();
-
-    bool hasCutEdges();
-
-    /** \brief
-     * Get the list of lines forming invalid rings found during
-     * polygonization.
-     *
-     * @return a (possibly empty) collection of pointers to
-     *         the input LineStrings which form invalid rings
-     *
-     */
-    const std::vector<std::unique_ptr<geom::LineString>>& getInvalidRingLines();
-
-    bool hasInvalidRingLines();
-
-    bool allInputsFormPolygons();
-
-// This seems to be needed by    GCC 2.95.4
-    friend class Polygonizer::LineStringAdder;
-};
-
-} // namespace geos::operation::polygonize
-} // namespace geos::operation
-} // namespace geos
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/predicate/RectangleContains.h

@@ -1,119 +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/predicate/RectangleContains.java rev 1.5 (JTS-1.10)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <geos/geom/Polygon.h> // for inlines
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Envelope;
-class Geometry;
-class Point;
-class Coordinate;
-class LineString;
-//class Polygon;
-}
-}
-
-namespace geos {
-namespace operation { // geos::operation
-namespace predicate { // geos::operation::predicate
-
-/** \brief
- * Optimized implementation of spatial predicate "contains"
- * for cases where the first Geometry is a rectangle.
- *
- * As a further optimization,
- * this class can be used directly to test many geometries against a single
- * rectangle.
- *
- */
-class GEOS_DLL RectangleContains {
-
-private:
-
-    const geom::Envelope& rectEnv;
-
-    bool isContainedInBoundary(const geom::Geometry& geom);
-
-    bool isPointContainedInBoundary(const geom::Point& geom);
-
-    /** \brief
-     * Tests if a point is contained in the boundary of the target
-     * rectangle.
-     *
-     * @param pt the point to test
-     * @return true if the point is contained in the boundary
-     */
-    bool isPointContainedInBoundary(const geom::CoordinateXY& pt);
-
-    /** \brief
-     * Tests if a linestring is completely contained in the boundary
-     * of the target rectangle.
-     *
-     * @param line the linestring to test
-     * @return true if the linestring is contained in the boundary
-     */
-    bool isLineStringContainedInBoundary(const geom::LineString& line);
-
-    /** \brief
-     * Tests if a line segment is contained in the boundary of the
-     * target rectangle.
-     *
-     * @param p0 an endpoint of the segment
-     * @param p1 an endpoint of the segment
-     * @return true if the line segment is contained in the boundary
-     */
-    bool isLineSegmentContainedInBoundary(const geom::Coordinate& p0,
-                                          const geom::Coordinate& p1);
-
-public:
-
-    static bool
-    contains(const geom::Polygon& rect, const geom::Geometry& b)
-    {
-        RectangleContains rc(rect);
-        return rc.contains(b);
-    }
-
-    /**
-     * Create a new contains computer for two geometries.
-     *
-     * @param rect a rectangular geometry
-     */
-    RectangleContains(const geom::Polygon& rect)
-        :
-        rectEnv(*(rect.getEnvelopeInternal()))
-    {}
-
-    bool contains(const geom::Geometry& geom);
-
-    // Declare type as noncopyable
-    RectangleContains(const RectangleContains& other) = delete;
-    RectangleContains& operator=(const RectangleContains& rhs) = delete;
-};
-
-
-
-} // namespace geos::operation::predicate
-} // namespace geos::operation
-} // namespace geos

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/predicate/RectangleIntersects.h

@@ -1,98 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2011 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/predicate/RectangleIntersects.java r378 (JTS-1.12)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <geos/geom/Polygon.h> // for inlines
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Envelope;
-//class Polygon;
-}
-}
-
-namespace geos {
-namespace operation { // geos::operation
-namespace predicate { // geos::operation::predicate
-
-/** \brief
- * Optimized implementation of the "intersects" spatial predicate
- * for cases where one Geometry is a rectangle.
- *
- * This class works for all input geometries, including
- * [GeometryCollections](@ref geom::GeometryCollection).
- *
- * As a further optimization,
- * this class can be used to test
- * many geometries against a single
- * rectangle in a slightly more efficient way.
- *
- */
-class GEOS_DLL RectangleIntersects {
-
-private:
-
-    const geom::Polygon& rectangle;
-
-    const geom::Envelope& rectEnv;
-
-    // Declare type as noncopyable
-    RectangleIntersects(const RectangleIntersects& other) = delete;
-    RectangleIntersects& operator=(const RectangleIntersects& rhs) = delete;
-
-public:
-
-    /** \brief
-     * Create a new intersects computer for a rectangle.
-     *
-     * @param newRect a rectangular geometry
-     */
-    RectangleIntersects(const geom::Polygon& newRect)
-        :
-        rectangle(newRect),
-        rectEnv(*(newRect.getEnvelopeInternal()))
-    {}
-
-    bool intersects(const geom::Geometry& geom);
-
-    /** \brief
-     * Tests whether a rectangle intersects a given geometry.
-     *
-     * @param rectangle a rectangular Polygon
-     * @param b a Geometry of any type
-     * @return true if the geometries intersect
-     */
-    static bool
-    intersects(const geom::Polygon& rectangle,
-               const geom::Geometry& b)
-    {
-        RectangleIntersects rp(rectangle);
-        return rp.intersects(b);
-    }
-
-};
-
-
-} // namespace geos::operation::predicate
-} // namespace geos::operation
-} // namespace geos