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

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/valid/PolygonRing.h

@@ -0,0 +1,231 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021 Paul Ramsey <pramsey@cleverelephant.ca>
+ * Copyright (C) 2021 Martin Davis
+ *
+ * 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/operation/valid/PolygonRingTouch.h>
+#include <geos/operation/valid/PolygonRingSelfNode.h>
+
+#include <geos/export.h>
+
+
+#include <memory>
+#include <map>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class LinearRing;
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace valid {     // geos.operation.valid
+
+using geos::geom::CoordinateXY;
+using geos::geom::LinearRing;
+
+
+class GEOS_DLL PolygonRing {
+
+private:
+
+    int id = -1;
+    PolygonRing* shell = nullptr;
+    const LinearRing* ring = nullptr;
+
+    /**
+    * The root of the touch graph tree containing this ring.
+    * Serves as the id for the graph partition induced by the touch relation.
+    */
+    PolygonRing* touchSetRoot = nullptr;
+
+    /**
+    * The set of PolygonRingTouch links
+    * for this ring.
+    * The set of all touches in the rings of a polygon
+    * forms the polygon touch graph.
+    * This supports detecting touch cycles, which
+    * reveal the condition of a disconnected interior.
+    *
+    * Only a single touch is recorded between any two rings,
+    * since more than one touch between two rings
+    * indicates interior disconnection as well.
+    */
+    std::map<int, PolygonRingTouch> touches;
+
+    /**
+    * The set of self-nodes in this ring.
+    * This supports checking valid ring self-touch topology.
+    */
+    std::vector<PolygonRingSelfNode> selfNodes;
+
+    /* METHODS */
+
+    /**
+    * Tests if this ring touches a given ring at
+    * the single point specified.
+    *
+    * @param ring the other PolygonRing
+    * @param pt the touch point
+    * @return true if the rings touch only at the given point
+    */
+    bool isOnlyTouch(const PolygonRing* polyRing, const CoordinateXY& pt) const;
+
+    /**
+    * Detects whether the subgraph of holes linked by touch to this ring
+    * contains a hole cycle.
+    * If no cycles are detected, the set of touching rings is a tree.
+    * The set is marked using this ring as the root.
+    *
+    * @return a vertex in a hole cycle, or null if no cycle found
+    */
+    const CoordinateXY* findHoleCycleLocation();
+
+    void init(PolygonRing* root, std::stack<PolygonRingTouch*>& touchStack);
+
+    /**
+    * Scans for a hole cycle starting at a given touch.
+    *
+    * @param currentTouch the touch to investigate
+    * @param root the root of the touch subgraph
+    * @param touchStack the stack of touches to scan
+    * @return a vertex in a hole cycle if found, or null
+    */
+    const CoordinateXY* scanForHoleCycle(PolygonRingTouch* currentTouch,
+        PolygonRing* root,
+        std::stack<PolygonRingTouch*>& touchStack);
+
+
+    bool isInTouchSet() const
+    {
+        return touchSetRoot != nullptr;
+    };
+
+    void setTouchSetRoot(PolygonRing* polyRing)
+    {
+        touchSetRoot = polyRing;
+    };
+
+    PolygonRing* getTouchSetRoot() const
+    {
+        return touchSetRoot;
+    };
+
+    bool hasTouches() const
+    {
+        return ! touches.empty();
+    };
+
+    std::vector<PolygonRingTouch*> getTouches() const;
+
+    void addTouch(PolygonRing* polyRing, const CoordinateXY& pt);
+
+
+public:
+
+    /**
+    * Creates a ring for a polygon hole.
+    * @param p_ring the ring geometry
+    * @param p_index the index of the hole
+    * @param p_shell the parent polygon shell
+    */
+    PolygonRing(const LinearRing* p_ring, int p_index, PolygonRing* p_shell)
+        : id(p_index)
+        , shell(p_shell)
+        , ring(p_ring)
+        {};
+
+    /**
+    * Creates a ring for a polygon shell.
+    * @param p_ring
+    */
+    PolygonRing(const LinearRing* p_ring)
+        : PolygonRing(p_ring, -1, this)
+        {};
+
+    /**
+    * Tests if a polygon ring represents a shell.
+    *
+    * @param polyRing the ring to test (may be null)
+    * @return true if the ring represents a shell
+    */
+    static bool isShell(const PolygonRing* polyRing);
+
+    /**
+    * Records a touch location between two rings,
+    * and checks if the rings already touch in a different location.
+    *
+    * @param ring0 a polygon ring
+    * @param ring1 a polygon ring
+    * @param pt the location where they touch
+    * @return true if the polygons already touch
+    */
+    static bool addTouch(PolygonRing* ring0, PolygonRing* ring1, const CoordinateXY& pt);
+
+    /**
+    * Finds a location (if any) where a chain of holes forms a cycle
+    * in the ring touch graph.
+    * The shell may form part of the chain as well.
+    * This indicates that a set of holes disconnects the interior of a polygon.
+    *
+    * @param polyRings the list of rings to check
+    * @return a vertex contained in a ring cycle, or null if none is found
+    */
+    static const CoordinateXY* findHoleCycleLocation(std::vector<PolygonRing*> polyRings);
+
+    /**
+    * Finds a location of an interior self-touch in a list of rings,
+    * if one exists.
+    * This indicates that a self-touch disconnects the interior of a polygon,
+    * which is invalid.
+    *
+    * @param polyRings the list of rings to check
+    * @return the location of an interior self-touch node, or null if there are none
+    */
+    static const CoordinateXY* findInteriorSelfNode(std::vector<PolygonRing*> polyRings);
+
+    bool isSamePolygon(const PolygonRing* polyRing) const
+    {
+        return shell == polyRing->shell;
+    };
+
+    bool isShell() const
+    {
+        return shell == this;
+    };
+
+    void addSelfTouch(const CoordinateXY& origin,
+        const CoordinateXY* e00, const CoordinateXY* e01,
+        const CoordinateXY* e10, const CoordinateXY* e11);
+
+    /**
+    * Finds the location of an invalid interior self-touch in this ring,
+    * if one exists.
+    *
+    * @return the location of an interior self-touch node, or null if there are none
+    */
+    const CoordinateXY* findInteriorSelfNode();
+
+
+};
+
+
+
+} // namespace geos.operation.valid
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/valid/PolygonRingSelfNode.h

@@ -0,0 +1,84 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021 Paul Ramsey <pramsey@cleverelephant.ca>
+ * Copyright (C) 2021 Martin Davis
+ *
+ * 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/Coordinate.h>
+
+#include <memory>
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace valid {     // geos.operation.valid
+
+using geos::geom::CoordinateXY;
+
+class GEOS_DLL PolygonRingSelfNode {
+
+private:
+
+    CoordinateXY nodePt;
+    const CoordinateXY* e00;
+    const CoordinateXY* e01;
+    const CoordinateXY* e10;
+    const CoordinateXY* e11;
+
+
+public:
+
+    PolygonRingSelfNode(
+        const CoordinateXY& p_nodePt,
+        const CoordinateXY* p_e00,
+        const CoordinateXY* p_e01,
+        const CoordinateXY* p_e10,
+        const CoordinateXY* p_e11)
+        : nodePt(p_nodePt)
+        , e00(p_e00)
+        , e01(p_e01)
+        , e10(p_e10)
+        , e11(p_e11)
+        {}
+
+    /**
+    * The node point.
+    *
+    * @return
+    */
+    const CoordinateXY* getCoordinate() const {
+        return &nodePt;
+    }
+
+    /**
+    * Tests if a self-touch has the segments of each half of the touch
+    * lying in the exterior of a polygon.
+    * This is a valid self-touch.
+    * It applies to both shells and holes.
+    * Only one of the four possible cases needs to be tested,
+    * since the situation has full symmetry.
+    *
+    * @param isInteriorOnRight whether the interior is to the right of the parent ring
+    * @return true if the self-touch is in the exterior
+    */
+    bool isExterior(bool isInteriorOnRight) const;
+
+};
+
+} // namespace geos.operation.valid
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/valid/PolygonRingTouch.h

@@ -0,0 +1,65 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021 Paul Ramsey <pramsey@cleverelephant.ca>
+ * Copyright (C) 2021 Martin Davis
+ *
+ * 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/Coordinate.h>
+
+
+#include <memory>
+
+// Forward declarations
+namespace geos {
+namespace operation {
+namespace valid {
+class PolygonRing;
+}
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace valid {     // geos.operation.valid
+
+using geos::geom::CoordinateXY;
+
+class GEOS_DLL PolygonRingTouch {
+
+private:
+
+    PolygonRing* ring;
+    CoordinateXY touchPt;
+
+
+public:
+
+    PolygonRingTouch(PolygonRing* p_ring, const CoordinateXY& p_pt)
+        : ring(p_ring)
+        , touchPt(p_pt)
+        {};
+
+    const CoordinateXY* getCoordinate() const;
+
+    PolygonRing* getRing() const;
+
+    bool isAtLocation(const CoordinateXY& pt) const;
+
+};
+
+} // namespace geos.operation.valid
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/valid/PolygonTopologyAnalyzer.h

@@ -0,0 +1,211 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021 Paul Ramsey <pramsey@cleverelephant.ca>
+ * Copyright (C) 2021 Martin Davis
+ *
+ * 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/Coordinate.h>
+#include <geos/operation/valid/PolygonIntersectionAnalyzer.h>
+#include <geos/operation/valid/PolygonRing.h>
+#include <geos/noding/BasicSegmentString.h>
+
+#include <memory>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace valid {     // geos.operation.valid
+
+using geos::geom::CoordinateXY;
+using geos::geom::CoordinateSequence;
+using geos::geom::Geometry;
+using geos::geom::LinearRing;
+
+class GEOS_DLL PolygonTopologyAnalyzer {
+
+private:
+
+    // const Geometry* inputGeom;
+    bool isInvertedRingValid = false;
+    PolygonIntersectionAnalyzer segInt;
+    std::vector<PolygonRing*> polyRings;
+    geom::CoordinateXY disconnectionPt;
+
+
+    // holding area for PolygonRings and SegmentStrings so we
+    // can pass around pointers with abandon
+    std::deque<PolygonRing> polyRingStore;
+    std::deque<noding::BasicSegmentString> segStringStore;
+    // when building SegmentStrings we sometimes want
+    // to use deduped CoordinateSequences so we will
+    // keep the deduped ones here so they get cleaned
+    // up when processing is complete
+    std::vector<std::unique_ptr<CoordinateSequence>> coordSeqStore;
+
+    PolygonRing* createPolygonRing(const LinearRing* p_ring);
+    PolygonRing* createPolygonRing(const LinearRing* p_ring, int p_index, PolygonRing* p_shell);
+
+    static const CoordinateXY&
+    findNonEqualVertex(const LinearRing* ring, const CoordinateXY& p);
+
+    /**
+     * Tests whether a touching segment is interior to a ring.
+     *
+     * Preconditions:
+     *
+     *  * The segment does not cross the ring
+     *  * The segment vertex p0 lies on the ring
+     *  * The ring is valid
+     *
+     * This works for both shells and holes, but the caller must know
+     * the ring role.
+     *
+     * @param p0 the first vertex of the segment
+     * @param p1 the second vertex of the segment
+     * @param ringPts the points of the ring
+     * @return true if the segment is inside the ring.
+     */
+    static bool isIncidentSegmentInRing(const CoordinateXY* p0, const CoordinateXY* p1,
+        const CoordinateSequence* ringPts);
+
+    static const CoordinateXY& findRingVertexPrev(const CoordinateSequence* ringPts,
+        std::size_t index, const CoordinateXY& node);
+
+    static const CoordinateXY& findRingVertexNext(const CoordinateSequence* ringPts,
+        std::size_t index, const CoordinateXY& node);
+
+    static std::size_t ringIndexPrev(const CoordinateSequence* ringPts, std::size_t index);
+
+    static std::size_t ringIndexNext(const CoordinateSequence* ringPts, std::size_t index);
+
+    /**
+     * Computes the index of the segment which intersects a given point.
+     * @param ringPts the ring points
+     * @param pt the intersection point
+     * @return the intersection segment index, or -1 if no intersection is found
+     */
+    static std::size_t intersectingSegIndex(const CoordinateSequence* ringPts, const CoordinateXY* pt);
+
+    std::vector<SegmentString*> createSegmentStrings(const Geometry* geom, bool isInvertedRingValid);
+
+    std::vector<PolygonRing*> getPolygonRings(const std::vector<SegmentString*>& segStrings);
+
+    SegmentString* createSegString(const LinearRing* ring, const PolygonRing* polyRing);
+
+    // Declare type as noncopyable
+    PolygonTopologyAnalyzer(const PolygonTopologyAnalyzer& other) = delete;
+    PolygonTopologyAnalyzer& operator=(const PolygonTopologyAnalyzer& rhs) = delete;
+
+public:
+
+    /* public */
+    PolygonTopologyAnalyzer(const Geometry* geom, bool p_isInvertedRingValid);
+
+    /**
+     * Finds a self-intersection (if any) in a LinearRing.
+     *
+     * @param ring the ring to analyze
+     * @return a self-intersection point if one exists, or null
+     */
+    static CoordinateXY findSelfIntersection(const LinearRing* ring);
+
+    /**
+     * Tests whether a ring is nested inside another ring.
+     *
+     * Preconditions:
+     *
+     * * The rings do not cross (i.e. the test is wholly inside or outside the target)
+     * * The rings may touch at discrete points only
+     * * The target ring does not self-cross, but it may self-touch
+     *
+     * If the test ring start point is properly inside or outside, that provides the result.
+     * Otherwise the start point is on the target ring,
+     * and the incident start segment (accounting for repeated points) is
+     * tested for its topology relative to the target ring.
+     *
+     * @param test the ring to test
+     * @param target the ring to test against
+     * @return true if the test ring lies inside the target ring
+     */
+    static bool
+    isRingNested(const LinearRing* test,
+        const LinearRing* target);
+
+    bool hasInvalidIntersection() {
+        return segInt.isInvalid();
+    }
+
+    int getInvalidCode() {
+        return segInt.getInvalidCode();
+    }
+
+    const CoordinateXY& getInvalidLocation() {
+        return segInt.getInvalidLocation();
+    }
+
+    /**
+    * Tests whether the interior of the polygonal geometry is
+    * disconnected.
+    * If true, the disconnection location is available from
+    * getDisconnectionLocation().
+    *
+    * @return true if the interior is disconnected
+    */
+    bool isInteriorDisconnected();
+
+    const CoordinateXY& getDisconnectionLocation() const
+    {
+        return disconnectionPt;
+    };
+
+
+    /**
+    * Tests whether any polygon with holes has a disconnected interior
+    * by virtue of the holes (and possibly shell) forming a hole cycle.
+    *
+    * This is a global check, which relies on determining
+    * the touching graph of all holes in a polygon.
+    *
+    * If inverted rings disconnect the interior
+    * via a self-touch, this is checked by the PolygonIntersectionAnalyzer.
+    * If inverted rings are part of a hole cycle
+    * this is detected here as well.
+    */
+    void checkInteriorDisconnectedByHoleCycle();
+
+    /**
+    * Tests if an area interior is disconnected by a self-touching ring.
+    * This must be evaluated after other self-intersections have been analyzed
+    * and determined to not exist, since the logic relies on
+    * the rings not self-crossing (winding).
+    * <p>
+    * If self-touching rings are not allowed,
+    * then the self-touch will previously trigger a self-intersection error.
+    */
+    void checkInteriorDisconnectedBySelfTouch();
+
+};
+
+
+} // namespace geos.operation.valid
+} // namespace geos.operation
+} // namespace geos

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/valid/RepeatedPointRemover.h

@@ -0,0 +1,60 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2019 Daniel Baston <dbaston@gmail.com>
+ *
+ * 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/CoordinateSequence.h>
+#include <geos/geom/Geometry.h>
+
+
+namespace geos {
+namespace operation {
+namespace valid {
+
+    /**
+     *  Removes repeated, consecutive equal, coordinates from a CoordinateSequence.
+     */
+    class GEOS_DLL RepeatedPointRemover {
+
+    public:
+
+        /**
+         *  Returns a new CoordinateSequence being a copy of the input
+         *  with any consecutive equal Coordinate removed.
+         *  Equality test is 2D based.
+         *
+         *  \param seq to filter
+         *  \param tolerance to apply
+         *  \return Geometr, ownership of returned object goes to the caller.
+         */
+        static std::unique_ptr<geom::CoordinateSequence>
+            removeRepeatedPoints(
+                const geom::CoordinateSequence* seq,
+                double tolerance = 0.0);
+
+        static std::unique_ptr<geom::CoordinateSequence>
+            removeRepeatedAndInvalidPoints(
+                const geom::CoordinateSequence* seq,
+                double tolerance = 0.0);
+
+        static std::unique_ptr<geom::Geometry>
+            removeRepeatedPoints(
+                const geom::Geometry* geom,
+                double tolerance = 0.0);
+    };
+
+}
+}
+}
+