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

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/overlayng/OverlayEdge.h

@@ -1,279 +0,0 @@
-/**********************************************************************
- *
- * 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/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/overlayng/OverlayEdgeRing.h

@@ -1,153 +0,0 @@
-/**********************************************************************
- *
- * 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/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/overlayng/OverlayGraph.h

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