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

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlayng/OverlayEdge.h

@@ -0,0 +1,279 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 Paul Ramsey <pramsey@cleverelephant.ca>
+ *
+ * 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/edgegraph/HalfEdge.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/Location.h>
+#include <geos/operation/overlayng/OverlayEdge.h>
+#include <geos/operation/overlayng/OverlayLabel.h>
+#include <geos/export.h>
+
+#include <memory>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class CoordinateSequence;
+}
+namespace operation {
+namespace overlayng {
+class OverlayEdgeRing;
+class MaximalEdgeRing;
+}
+}
+}
+
+using geos::geom::Coordinate;
+using geos::geom::CoordinateXYZM;
+using geos::geom::CoordinateSequence;
+using geos::geom::Location;
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+/**
+* Creates a single OverlayEdge.
+*/
+class GEOS_DLL OverlayEdge : public edgegraph::HalfEdge {
+
+private:
+
+    // Members
+    const CoordinateSequence* pts;
+    /**
+    * 'true' indicates direction is forward along segString
+    * 'false' is reverse direction
+    * The label must be interpreted accordingly.
+    */
+    bool direction;
+    CoordinateXYZM dirPt;
+    OverlayLabel* label;
+    bool m_isInResultArea;
+    bool m_isInResultLine;
+    bool m_isVisited;
+    OverlayEdge* nextResultEdge;
+    const OverlayEdgeRing* edgeRing;
+    const MaximalEdgeRing* maxEdgeRing;
+    OverlayEdge* nextResultMaxEdge;
+
+    void markVisited()
+    {
+        m_isVisited = true;
+    };
+
+
+public:
+
+    OverlayEdge(const CoordinateXYZM& p_orig, const CoordinateXYZM& p_dirPt,
+                bool p_direction, OverlayLabel* p_label,
+                const CoordinateSequence* p_pts)
+        : HalfEdge(p_orig)
+        , pts(p_pts)
+        , direction(p_direction)
+        , dirPt(p_dirPt)
+        , label(p_label)
+        , m_isInResultArea(false)
+        , m_isInResultLine(false)
+        , m_isVisited(false)
+        , nextResultEdge(nullptr)
+        , edgeRing(nullptr)
+        , maxEdgeRing(nullptr)
+        , nextResultMaxEdge(nullptr)
+     {}
+
+    ~OverlayEdge() override {};
+
+    bool isForward() const
+    {
+        return direction;
+    };
+
+    const CoordinateXYZM& directionPt() const override
+    {
+        return dirPt;
+    };
+
+    OverlayLabel* getLabel() const
+    {
+        return label;
+    };
+
+    Location getLocation(uint8_t index, int position) const
+    {
+        return label->getLocation(index, position, direction);
+    };
+
+    const CoordinateXYZM& getCoordinate() const
+    {
+        return orig();
+    };
+
+    const CoordinateSequence* getCoordinatesRO() const
+    {
+        return pts;
+    };
+
+    std::unique_ptr<CoordinateSequence> getCoordinates()
+    {
+        // return a copy of pts
+        return pts->clone();
+    };
+
+    std::unique_ptr<CoordinateSequence> getCoordinatesOriented();
+
+    /**
+    * Adds the coordinates of this edge to the given list,
+    * in the direction of the edge.
+    * Duplicate coordinates are removed
+    * (which means that this is safe to use for a path
+    * of connected edges in the topology graph).
+    *
+    * @param coords the coordinate list to add to
+    */
+    void addCoordinates(CoordinateSequence* coords) const;
+
+    OverlayEdge* symOE() const
+    {
+        return static_cast<OverlayEdge*>(sym());
+    };
+
+    OverlayEdge* oNextOE() const
+    {
+        return static_cast<OverlayEdge*>(oNext());
+    };
+
+    bool isInResultArea() const
+    {
+        return m_isInResultArea;
+    };
+
+    bool isInResultAreaBoth() const
+    {
+        return m_isInResultArea && symOE()->m_isInResultArea;
+    };
+
+    bool isInResultEither() const
+    {
+        return isInResult() || symOE()->isInResult();
+    };
+
+    void unmarkFromResultAreaBoth()
+    {
+        m_isInResultArea = false;
+        symOE()->m_isInResultArea = false;
+    };
+
+    void markInResultArea()
+    {
+        m_isInResultArea  = true;
+    };
+
+    void markInResultAreaBoth()
+    {
+        m_isInResultArea  = true;
+        symOE()->m_isInResultArea = true;
+    };
+
+    bool isInResultLine() const
+    {
+        return m_isInResultLine;
+    };
+
+    void markInResultLine()
+    {
+        m_isInResultLine  = true;
+        symOE()->m_isInResultLine = true;
+    };
+
+    bool isInResult() const
+    {
+        return m_isInResultArea || m_isInResultLine;
+    };
+
+    void setNextResult(OverlayEdge* e)
+    {
+        // Assert: e.orig() == this.dest();
+        nextResultEdge = e;
+    };
+
+    OverlayEdge* nextResult() const
+    {
+        return nextResultEdge;
+    };
+
+    bool isResultLinked() const
+    {
+        return nextResultEdge != nullptr;
+    };
+
+    void setNextResultMax(OverlayEdge* e)
+    {
+        // Assert: e.orig() == this.dest();
+        nextResultMaxEdge = e;
+    };
+
+    OverlayEdge* nextResultMax() const
+    {
+        return nextResultMaxEdge;
+    };
+
+    bool isResultMaxLinked() const
+    {
+        return nextResultMaxEdge != nullptr;
+    };
+
+    bool isVisited() const
+    {
+        return m_isVisited;
+    };
+
+    void markVisitedBoth()
+    {
+        markVisited();
+        symOE()->markVisited();
+    };
+
+    void setEdgeRing(const OverlayEdgeRing* p_edgeRing)
+    {
+        edgeRing = p_edgeRing;
+    };
+
+    const OverlayEdgeRing* getEdgeRing() const
+    {
+        return edgeRing;
+    };
+
+    const MaximalEdgeRing* getEdgeRingMax() const
+    {
+        return maxEdgeRing;
+    };
+
+    void setEdgeRingMax(const MaximalEdgeRing* p_maximalEdgeRing)
+    {
+        maxEdgeRing = p_maximalEdgeRing;
+    };
+
+    friend std::ostream& operator<<(std::ostream& os, const OverlayEdge& oe);
+    std::string resultSymbol() const;
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlayng/OverlayEdgeRing.h

@@ -0,0 +1,153 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 Paul Ramsey <pramsey@cleverelephant.ca>
+ *
+ * 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/algorithm/locate/IndexedPointInAreaLocator.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/LinearRing.h>
+#include <geos/export.h>
+
+// Forward declarations
+namespace geos {
+namespace algorithm {
+namespace locate {
+class PointOnGeometryLocator;
+}
+}
+namespace geom {
+class Coordinate;
+class CoordinateSequence;
+class GeometryFactory;
+class LinearRing;
+class Polygon;
+}
+namespace operation {
+namespace overlayng {
+class OverlayEdge;
+}
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+using namespace geos::geom;
+using algorithm::locate::PointOnGeometryLocator;
+using algorithm::locate::IndexedPointInAreaLocator;
+
+class GEOS_DLL OverlayEdgeRing {
+
+private:
+
+    // Members
+    OverlayEdge* startEdge;
+    std::unique_ptr<LinearRing> ring;
+    bool m_isHole;
+    std::unique_ptr<IndexedPointInAreaLocator> locator;
+    OverlayEdgeRing* shell;
+    // a list of EdgeRings which are holes in this EdgeRing
+    std::vector<OverlayEdgeRing*> holes;
+
+    // Methods
+    void computeRingPts(OverlayEdge* start, CoordinateSequence& pts);
+    void computeRing(std::unique_ptr<CoordinateSequence> && ringPts, const GeometryFactory* geometryFactory);
+
+    /**
+    * Computes the list of coordinates which are contained in this ring.
+    * The coordinates are computed once only and cached.
+    * @return an array of the {@link Coordinate}s in this ring
+    */
+    const CoordinateSequence& getCoordinates();
+    PointOnGeometryLocator* getLocator();
+    static void closeRing(CoordinateSequence& pts);
+
+
+public:
+
+    OverlayEdgeRing(OverlayEdge* start, const GeometryFactory* geometryFactory);
+
+    std::unique_ptr<LinearRing> getRing();
+    const LinearRing* getRingPtr() const;
+
+    /**
+    * Tests whether this ring is a hole.
+    * @return <code>true</code> if this ring is a hole
+    */
+    bool isHole() const;
+
+    /**
+    * Sets the containing shell ring of a ring that has been determined to be a hole.
+    *
+    * @param shell the shell ring
+    */
+    void setShell(OverlayEdgeRing* p_shell);
+
+    /**
+    * Tests whether this ring has a shell assigned to it.
+    *
+    * @return true if the ring has a shell
+    */
+    bool hasShell() const;
+
+    /**
+    * Gets the shell for this ring.  The shell is the ring itself if it is not a hole, otherwise its parent shell.
+    *
+    * @return the shell for this ring
+    */
+    const OverlayEdgeRing* getShell() const;
+
+    void addHole(OverlayEdgeRing* ring);
+
+    bool isInRing(const Coordinate& pt);
+
+    const Coordinate& getCoordinate();
+
+    /**
+    * Computes the {@link Polygon} formed by this ring and any contained holes.
+    * @return the {@link Polygon} formed by this ring and its holes.
+    */
+    std::unique_ptr<Polygon> toPolygon(const GeometryFactory* factory);
+
+    OverlayEdge* getEdge();
+
+    /**
+    * Finds the innermost enclosing shell OverlayEdgeRing
+    * containing this OverlayEdgeRing, if any.
+    * The innermost enclosing ring is the smallest 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)
+    *
+    * To improve performance of this function the caller should
+    * make the passed shellList as small as possible (e.g.
+    * by using a spatial index filter beforehand).
+    *
+    * @return containing EdgeRing, if there is one
+    * or null if no containing EdgeRing is found
+    */
+    OverlayEdgeRing* findEdgeRingContaining(const std::vector<OverlayEdgeRing*>& erList);
+
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlayng/OverlayGraph.h

@@ -0,0 +1,143 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 Paul Ramsey <pramsey@cleverelephant.ca>
+ *
+ * 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/overlayng/OverlayEdge.h>
+#include <geos/operation/overlayng/OverlayLabel.h>
+#include <geos/geom/CoordinateSequence.h>
+
+#include <unordered_map>
+#include <vector>
+#include <deque>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+}
+namespace operation {
+namespace overlayng {
+class Edge;
+}
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+using namespace geos::geom;
+
+/**
+ * A planar graph of {@link OverlayEdge}, representing
+ * the topology resulting from an overlay operation.
+ * Each source {@link Edge} is represented
+ * by two OverlayEdges, with opposite orientation.
+ * A single {@link OverlayLabel} is created for each symmetric pair of OverlayEdges.
+ *
+ * @author mdavis
+ *
+ */
+class GEOS_DLL OverlayGraph {
+
+private:
+
+    // Members
+    std::unordered_map<Coordinate, OverlayEdge*, geom::Coordinate::HashCode> nodeMap;
+    std::vector<OverlayEdge*> edges;
+
+    // Locally store the OverlayEdge and OverlayLabel
+    std::deque<OverlayEdge> ovEdgeQue;
+    std::deque<OverlayLabel> ovLabelQue;
+
+    std::vector<std::unique_ptr<const geom::CoordinateSequence>> csQue;
+
+    // Methods
+
+    /**
+    * Create and add HalfEdge pairs to map and vector containers,
+    * using local std::deque storage for objects.
+    */
+    OverlayEdge* createEdgePair(const CoordinateSequence* pts, OverlayLabel* lbl);
+
+    /**
+    * Create a single OverlayEdge in local std::deque storage, and return the
+    * pointer.
+    */
+    OverlayEdge* createOverlayEdge(const CoordinateSequence* pts, OverlayLabel* lbl, bool direction);
+
+    void insert(OverlayEdge* e);
+
+
+
+public:
+
+    /**
+    * Creates a new graph for a set of noded, labelled {@link Edge}s.
+    */
+    OverlayGraph();
+
+    OverlayGraph(const OverlayGraph& g) = delete;
+    OverlayGraph& operator=(const OverlayGraph& g) = delete;
+
+    /**
+    * Adds an edge between the coordinates orig and dest
+    * to this graph.
+    * Only valid edges can be added (in particular, zero-length segments cannot be added)
+    *
+    */
+    OverlayEdge* addEdge(Edge* edge);
+
+    /**
+    * Gets the set of edges in this graph.
+    * Only one of each symmetric pair of OverlayEdges is included.
+    * The opposing edge can be found by using {@link OverlayEdge#sym()}.
+    */
+    std::vector<OverlayEdge*>& getEdges();
+
+    /**
+    * Gets the collection of edges representing the nodes in this graph.
+    * For each star of edges originating at a node
+    * a single representative edge is included.
+    * The other edges around the node can be found by following the next and prev links.
+    */
+    std::vector<OverlayEdge*> getNodeEdges();
+
+    /**
+    * Gets an edge originating at the given node point.
+    */
+    OverlayEdge* getNodeEdge(const Coordinate& nodePt) const;
+
+    /**
+    * Gets the representative edges marked as being in the result area.
+    */
+    std::vector<OverlayEdge*> getResultAreaEdges();
+
+    /**
+    * Create a single OverlayLabel in local std::deque storage
+    * and return a pointer to the stored object.
+    */
+    OverlayLabel* createOverlayLabel(const Edge* edge);
+
+    friend std::ostream& operator<<(std::ostream& os, const OverlayGraph& og);
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+