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

package/dist/prebuilt/Android-x86_64/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-x86_64/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);
+    };
+
+}
+}
+}
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/valid/RepeatedPointTester.h

@@ -0,0 +1,66 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2005-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/valid/RepeatedPointTester.java rev. 1.8 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geom/Coordinate.h> // for composition
+
+// Forward declarations
+namespace geos {
+namespace geom {
+//class Coordinate;
+class CoordinateSequence;
+class Geometry;
+class Polygon;
+class MultiPolygon;
+class MultiLineString;
+class GeometryCollection;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace valid { // geos::operation::valid
+
+/** \brief
+ * Implements the appropriate checks for repeated points
+ * (consecutive identical coordinates) as defined in the
+ * JTS spec.
+ */
+class GEOS_DLL RepeatedPointTester {
+public:
+    RepeatedPointTester() {}
+    geom::CoordinateXY& getCoordinate();
+    bool hasRepeatedPoint(const geom::Geometry* g);
+    bool hasRepeatedPoint(const geom::CoordinateSequence* coord);
+private:
+    geom::CoordinateXY repeatedCoord;
+    bool hasRepeatedPoint(const geom::Polygon* p);
+    bool hasRepeatedPoint(const geom::GeometryCollection* gc);
+    bool hasRepeatedPoint(const geom::MultiPolygon* gc);
+    bool hasRepeatedPoint(const geom::MultiLineString* gc);
+};
+
+
+} // namespace geos.operation.valid
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/valid/TopologyValidationError.h

@@ -0,0 +1,76 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2005-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/valid/TopologyValidationError.java rev. 1.16 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <string>
+
+#include <geos/geom/Coordinate.h> // for composition
+
+// Forward declarations
+// none required
+
+namespace geos {
+namespace operation { // geos::operation
+namespace valid { // geos::operation::valid
+
+/** \brief
+ * Contains information about the nature and location of a geom::Geometry
+ * validation error
+ *
+ */
+class GEOS_DLL TopologyValidationError {
+public:
+
+    enum errorEnum {
+        eError,
+        eRepeatedPoint,
+        eHoleOutsideShell,
+        eNestedHoles,
+        eDisconnectedInterior,
+        eSelfIntersection,
+        eRingSelfIntersection,
+        eNestedShells,
+        eDuplicatedRings,
+        eTooFewPoints,
+        eInvalidCoordinate,
+        eRingNotClosed,
+        oNoInvalidIntersection = -1
+    };
+
+    TopologyValidationError(int newErrorType, const geom::CoordinateXY& newPt);
+    TopologyValidationError(int newErrorType);
+    const geom::CoordinateXY& getCoordinate() const;
+    std::string getMessage() const;
+    int getErrorType() const;
+    std::string toString() const;
+
+private:
+    // Used const char* to reduce dynamic allocations
+    static const char* errMsg[];
+    int errorType;
+    const geom::CoordinateXY pt;
+};
+
+
+} // namespace geos.operation.valid
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/planargraph/DirectedEdge.h

@@ -0,0 +1,237 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ * Copyright (C) 2005-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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/planargraph/GraphComponent.h> // for inheritance
+#include <geos/geom/Coordinate.h> // for composition
+
+#include <vector> // for typedefs
+#include <list> // for typedefs
+
+// Forward declarations
+namespace geos {
+namespace planargraph {
+class Edge;
+class Node;
+}
+}
+
+namespace geos {
+namespace planargraph { // geos.planargraph
+
+/**
+ * \brief Represents a directed edge in a PlanarGraph.
+ *
+ * A DirectedEdge may or may not have a reference to a parent Edge
+ * (some applications of planar graphs may not require explicit Edge
+ * objects to be created). Usually a client using a PlanarGraph
+ * will subclass DirectedEdge to add its own application-specific
+ * data and methods.
+ */
+class GEOS_DLL DirectedEdge: public GraphComponent {
+
+public:
+
+    friend std::ostream& operator << (std::ostream&, const DirectedEdge&);
+
+    typedef std::list<DirectedEdge*> NonConstList;
+    typedef std::list<const DirectedEdge*> ConstList;
+    typedef std::vector<DirectedEdge*> NonConstVect;
+
+protected:
+    Edge* parentEdge;
+    Node* from;
+    Node* to;
+    geom::Coordinate p0, p1;
+    DirectedEdge* sym;  // optional
+    bool edgeDirection;
+    int quadrant;
+    double angle;
+public:
+
+    typedef std::vector<const DirectedEdge*> ConstVect;
+    typedef std::vector<DirectedEdge*> Vect;
+
+    /**
+     * \brief
+     * Returns a List containing the parent Edge (possibly null)
+     * for each of the given DirectedEdges.
+     *
+     * @note Ownership of the returned vector is left to
+     * the caller, see the equivalent function taking a vector
+     * reference to avoid this.
+     */
+    static std::vector<Edge*>* toEdges(
+        std::vector<DirectedEdge*>& dirEdges);
+
+    /**
+     * \brief
+     * Add parent Edge (possibly null) of each of the given DirectedEdges
+     * to the given parentEdges vector.
+     *
+     * @note Parents are pushed to the parentEdges vector, make sure
+     * it is empty if index-based corrispondence is important.
+     */
+    static void toEdges(std::vector<DirectedEdge*>& dirEdges,
+                        std::vector<Edge*>& parentEdges);
+
+    /**
+     * \brief Constructs a DirectedEdge connecting the `from`
+     * node to the `to` node.
+     *
+     * @param newFrom `from` node
+     * @param newTo `to` node
+     * @param directionPt specifies this DirectedEdge's direction
+     *                    (given by an imaginary line from the
+     *                    `from` node to
+     *                    `directionPt`)
+     * @param newEdgeDirection whether this DirectedEdge's direction
+     *                         is the same as or opposite to that of the
+     *                         parent Edge (if any)
+     */
+    DirectedEdge(Node* newFrom, Node* newTo,
+                 const geom::Coordinate& directionPt,
+                 bool newEdgeDirection);
+
+    /**
+     * \brief Returns this DirectedEdge's parent Edge,
+     * or null if it has none.
+     */
+    Edge* getEdge() const;
+
+    /**
+     * \brief Associates this DirectedEdge with an Edge
+     * (possibly null, indicating no associated Edge).
+     */
+    void setEdge(Edge* newParentEdge);
+
+    /**
+     * \brief Returns 0, 1, 2, or 3, indicating the quadrant in which
+     * this DirectedEdge's orientation lies.
+     */
+    int getQuadrant() const;
+
+    /**
+     * \brief Returns a point to which an imaginary line is drawn
+     * from the from-node to specify this DirectedEdge's orientation.
+     */
+    const geom::Coordinate& getDirectionPt() const;
+
+    /**
+     * \brief Returns whether the direction of the parent Edge (if any)
+     * is the same as that of this Directed Edge.
+     */
+    bool getEdgeDirection() const;
+
+    /**
+     * \brief Returns the node from which this DirectedEdge leaves.
+     */
+    Node* getFromNode() const;
+
+    /**
+     * \brief Returns the node to which this DirectedEdge goes.
+     */
+    Node* getToNode() const;
+
+    /**
+     * \brief
+     * Returns the coordinate of the from-node.
+     */
+    geom::Coordinate& getCoordinate() const;
+
+    /**
+     * \brief
+     * Returns the angle that the start of this DirectedEdge makes
+     * with the positive x-axis, in radians.
+     */
+    double getAngle() const;
+
+    /**
+     * \brief
+     * Returns the symmetric DirectedEdge -- the other DirectedEdge
+     * associated with this DirectedEdge's parent Edge.
+     */
+    DirectedEdge* getSym() const;
+
+    /**
+     * \brief
+     * Sets this DirectedEdge's symmetric DirectedEdge, which runs
+     * in the opposite direction.
+     */
+    void setSym(DirectedEdge* newSym);
+
+    /**
+     * \brief
+     * Returns 1 if this DirectedEdge has a greater angle with the
+     * positive x-axis than b", 0 if the DirectedEdges are collinear,
+     * and -1 otherwise.
+     *
+     * Using the obvious algorithm of simply computing the angle is
+     * not robust, since the angle calculation is susceptible to roundoff.
+     * A robust algorithm is:
+     *
+     * - first compare the quadrants.
+     *   If the quadrants are different, it it
+     *   trivial to determine which std::vector is "greater".
+     * - if the vectors lie in the same quadrant, the robust
+     *   Orientation::index(Coordinate, Coordinate, Coordinate)
+     *   function can be used to decide the relative orientation of
+     *   the vectors.
+     *
+     */
+    int compareTo(const DirectedEdge* obj) const;
+
+    /**
+     * \brief
+     * Returns 1 if this DirectedEdge has a greater angle with the
+     * positive x-axis than b", 0 if the DirectedEdges are collinear,
+     * and -1 otherwise.
+     *
+     * Using the obvious algorithm of simply computing the angle is
+     * not robust, since the angle calculation is susceptible to roundoff.
+     * A robust algorithm is:
+     *
+     * - first compare the quadrants.
+     *   If the quadrants are different, it it trivial to determine
+     *   which std::vector is "greater".
+     * - if the vectors lie in the same quadrant, the robust
+     *   Orientation::index(Coordinate, Coordinate, Coordinate)
+     *   function can be used to decide the relative orientation of
+     *   the vectors.
+     *
+     */
+    int compareDirection(const DirectedEdge* e) const;
+
+    /**
+     * \brief
+     * Prints a detailed string representation of this DirectedEdge
+     * to the given PrintStream.
+     */
+    std::string print() const;
+
+};
+
+/// Strict Weak comparator function for containers
+bool pdeLessThan(DirectedEdge* first, DirectedEdge* second);
+
+/// Output operator
+std::ostream& operator << (std::ostream&, const DirectedEdge&);
+
+
+} // namespace geos::planargraph
+} // namespace geos
+