@cpp.js/package-geos 1.0.0-beta.22 → 1.0.0-beta.23

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

@@ -0,0 +1,214 @@
+/**********************************************************************
+ *
+ * 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-x86_64/include/geos/operation/polygonize/Polygonizer.h

@@ -0,0 +1,260 @@
+/**********************************************************************
+ *
+ * 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-x86_64/include/geos/operation/predicate/RectangleContains.h

@@ -0,0 +1,119 @@
+/**********************************************************************
+ *
+ * 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-x86_64/include/geos/operation/predicate/RectangleIntersects.h

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