@crossbind/port-geos-linuxmusl 0.0.0-stage → 2.0.0-beta.64

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/geomgraph/Edge.h

@@ -0,0 +1,285 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * 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: geomgraph/Edge.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <string>
+#include <cassert>
+
+#include <geos/geomgraph/GraphComponent.h> // for inheritance
+#include <geos/geomgraph/Depth.h> // for member
+#include <geos/geomgraph/EdgeIntersectionList.h> // for composition
+#include <geos/geom/CoordinateSequence.h> // for inlines
+#include <geos/geom/Envelope.h>
+
+#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 IntersectionMatrix;
+class Coordinate;
+}
+namespace algorithm {
+class LineIntersector;
+}
+namespace geomgraph {
+class Node;
+class EdgeEndStar;
+class Label;
+class NodeFactory;
+namespace index {
+class MonotoneChainEdge;
+}
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/** The edge component of a geometry graph */
+class GEOS_DLL Edge final: public GraphComponent {
+    using GraphComponent::updateIM;
+
+private:
+
+    /// Lazily-created, owned by Edge.
+    std::unique_ptr<index::MonotoneChainEdge> mce;
+
+    geom::Envelope env;
+
+    Depth depth;
+
+    int depthDelta;   // the change in area depth from the R to L side of this edge
+
+    bool isIsolatedVar;
+
+public:
+
+    void
+    testInvariant() const
+    {
+        assert(pts);
+        assert(pts->size() > 1);
+    }
+
+    friend std::ostream& operator<< (std::ostream& os, const Edge& el);
+
+    static void updateIM(const Label& lbl, geom::IntersectionMatrix& im);
+
+    /// Externally-set, owned by Edge. FIXME: refuse ownership
+    std::unique_ptr<geom::CoordinateSequence> pts;
+
+    EdgeIntersectionList eiList;
+
+    /// Takes ownership of CoordinateSequence
+    Edge(geom::CoordinateSequence* newPts, const Label& newLabel);
+
+    /// Takes ownership of CoordinateSequence
+    Edge(geom::CoordinateSequence* newPts);
+
+    ~Edge() override;
+
+    size_t
+    getNumPoints() const
+    {
+        return pts->getSize();
+    }
+
+    const geom::CoordinateSequence*
+    getCoordinates() const
+    {
+        testInvariant();
+        return pts.get();
+    }
+
+    const geom::Coordinate&
+    getCoordinate(std::size_t i) const
+    {
+        testInvariant();
+        return pts->getAt(i);
+    }
+
+    const geom::Coordinate&
+    getCoordinate() const
+    {
+        testInvariant();
+        return pts->getAt(0);
+    }
+
+
+    const Depth&
+    getDepth() const
+    {
+        testInvariant();
+        return depth;
+    }
+
+    /** \brief
+     * The depthDelta is the change in depth as an edge is crossed from R to L
+     *
+     * @return the change in depth as the edge is crossed from R to L
+     */
+    int
+    getDepthDelta() const
+    {
+        testInvariant();
+        return depthDelta;
+    }
+
+    void
+    setDepthDelta(int newDepthDelta)
+    {
+        depthDelta = newDepthDelta;
+        testInvariant();
+    }
+
+    size_t
+    getMaximumSegmentIndex() const
+    {
+        testInvariant();
+        return getNumPoints() - 1;
+    }
+
+    EdgeIntersectionList&
+    getEdgeIntersectionList()
+    {
+        testInvariant();
+        return eiList;
+    }
+
+    const EdgeIntersectionList&
+    getEdgeIntersectionList() const
+    {
+        testInvariant();
+        return eiList;
+    }
+
+    /// \brief
+    /// Return this Edge's index::MonotoneChainEdge,
+    /// ownership is retained by this object.
+    ///
+    index::MonotoneChainEdge* getMonotoneChainEdge();
+
+    bool
+    isClosed() const
+    {
+        testInvariant();
+        return pts->getAt(0) == pts->getAt(getNumPoints() - 1);
+    }
+
+    /** \brief
+     * An Edge is collapsed if it is an Area edge and it consists of
+     * two segments which are equal and opposite (eg a zero-width V).
+     */
+     bool isCollapsed() const;
+
+    Edge* getCollapsedEdge();
+
+    void
+    setIsolated(bool newIsIsolated)
+    {
+        isIsolatedVar = newIsIsolated;
+        testInvariant();
+    }
+
+    bool
+    isIsolated() const override
+    {
+        testInvariant();
+        return isIsolatedVar;
+    }
+
+    /** \brief
+     * Adds EdgeIntersections for one or both
+     * intersections found for a segment of an edge to the edge intersection list.
+     */
+    void addIntersections(algorithm::LineIntersector* li, std::size_t segmentIndex,
+                                  std::size_t geomIndex);
+
+    /// Add an EdgeIntersection for intersection intIndex.
+    //
+    /// An intersection that falls exactly on a vertex of the edge is normalized
+    /// to use the higher of the two possible segmentIndexes
+    ///
+    void addIntersection(algorithm::LineIntersector* li, std::size_t segmentIndex,
+                                 std::size_t geomIndex, std::size_t intIndex);
+
+    /// Update the IM with the contribution for this component.
+    //
+    /// A component only contributes if it has a labelling for both
+    /// parent geometries
+    ///
+    void
+    computeIM(geom::IntersectionMatrix& im) override
+    {
+        updateIM(label, im);
+        testInvariant();
+    }
+
+    /// return true if the coordinate sequences of the Edges are identical
+    bool isPointwiseEqual(const Edge* e) const;
+
+    std::string print() const;
+
+    std::string printReverse() const;
+
+    /**
+     * equals is defined to be:
+     *
+     * e1 equals e2
+     * <b>iff</b>
+     * the coordinates of e1 are the same or the reverse of the coordinates in e2
+     */
+    bool equals(const Edge& e) const;
+
+    bool
+    equals(const Edge* e) const
+    {
+        assert(e);
+        return equals(*e);
+    }
+
+    const geom::Envelope* getEnvelope();
+};
+
+
+//Operators
+inline bool
+operator==(const Edge& a, const Edge& b)
+{
+    return a.equals(b);
+}
+
+std::ostream& operator<< (std::ostream& os, const Edge& el);
+
+
+} // namespace geos.geomgraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/geomgraph/EdgeEnd.h

@@ -0,0 +1,187 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * 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: geomgraph/EdgeEnd.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>  // for p0,p1
+#include <geos/geomgraph/Label.h>  // for composition
+
+#include <string>
+
+// Forward declarations
+namespace geos {
+namespace algorithm {
+class BoundaryNodeRule;
+}
+namespace geomgraph {
+class Edge;
+class Node;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/** \brief
+ * Models the end of an edge incident on a node.
+ *
+ * EdgeEnds have a direction
+ * determined by the direction of the ray from the initial
+ * point to the next point.
+ * EdgeEnds are comparable under the ordering
+ * "a has a greater angle with the x-axis than b".
+ * This ordering is used to sort EdgeEnds around a node.
+ */
+class GEOS_DLL EdgeEnd /* non-final */ {
+
+public:
+
+    friend std::ostream& operator<< (std::ostream&, const EdgeEnd&);
+
+    EdgeEnd();
+
+    virtual
+    ~EdgeEnd() {}
+
+    /**
+     * NOTES:
+     *  - Copies the given Label
+     *  - keeps a pointer to given Edge, make sure it's
+     *    not deleted before the EdgeEnd.
+     *  - copies given Coordinates (maybe we should avoid that)
+     */
+    EdgeEnd(Edge* newEdge, const geom::Coordinate& newP0,
+            const geom::Coordinate& newP1,
+            const Label& newLabel);
+
+    /**
+     * NOTES:
+     *  - keeps a pointer to given Edge, make sure it's
+     *    not deleted before the EdgeEnd.
+     *  - copies given Coordinates (maybe we should avoid that)
+     */
+    EdgeEnd(Edge* newEdge, const geom::Coordinate& newP0,
+            const geom::Coordinate& newP1);
+
+    Edge*
+    getEdge()
+    {
+        return edge;
+    }
+    //virtual Edge* getEdge() { return edge; }
+
+    Label&
+    getLabel()
+    {
+        return label;
+    }
+
+    const Label&
+    getLabel() const
+    {
+        return label;
+    }
+
+    geom::Coordinate& getCoordinate() {
+        return p0;
+    }
+
+    const geom::Coordinate&
+    getCoordinate() const
+    {
+        return p0;
+    }
+
+    geom::Coordinate& getDirectedCoordinate();
+
+    int getQuadrant();
+
+    double getDx();
+
+    double getDy();
+
+    void setNode(Node* newNode);
+
+    Node* getNode();
+
+    int compareTo(const EdgeEnd* e) const;
+
+    /**
+     * Implements the total order relation:
+     *
+     *    a has a greater angle with the positive x-axis than b
+     *
+     * Using the obvious algorithm of simply computing the angle
+     * is not robust, since the angle calculation is obviously
+     * susceptible to roundoff.
+     * A robust algorithm is:
+     * - first compare the quadrant.  If the quadrants
+     *   are different, it it trivial to determine which vector
+     *   is "greater".
+     * - if the vectors lie in the same quadrant, the
+     *   computeOrientation function can be used to decide
+     *   the relative orientation of the vectors.
+     */
+    int compareDirection(const EdgeEnd* e) const;
+
+    virtual void computeLabel(const algorithm::BoundaryNodeRule& bnr);
+
+    virtual std::string print() const;
+
+protected:
+
+    Edge* edge;// the parent edge of this edge end
+
+    Label label;
+
+    EdgeEnd(Edge* newEdge);
+
+    void init(const geom::Coordinate& newP0,
+                      const geom::Coordinate& newP1);
+
+private:
+
+    /// the node this edge end originates at
+    Node* node;
+
+    /// points of initial line segment. FIXME: do we need a copy here ?
+    geom::Coordinate p0, p1;
+
+    /// the direction vector for this edge from its starting point
+    double dx, dy;
+
+    int quadrant;
+};
+
+std::ostream& operator<< (std::ostream&, const EdgeEnd&);
+
+struct GEOS_DLL  EdgeEndLT {
+    bool
+    operator()(const EdgeEnd* s1, const EdgeEnd* s2) const
+    {
+        return s1->compareTo(s2) < 0;
+    }
+};
+
+} // namespace geos.geomgraph
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/geomgraph/EdgeEndStar.h

@@ -0,0 +1,217 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * 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: geomgraph/EdgeEndStar.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geomgraph/EdgeEnd.h>  // for EdgeEndLT
+#include <geos/geom/Location.h>
+#include <geos/geom/Coordinate.h>  // for p0,p1
+
+#include <array>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+#include <algorithm> // for inlines (find)
+
+#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 algorithm {
+class BoundaryNodeRule;
+}
+namespace geomgraph {
+class GeometryGraph;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+
+/** \brief
+ * A EdgeEndStar is an ordered list of EdgeEnds around a node.
+ *
+ * They are maintained in CCW order (starting with the positive x-axis)
+ * around the node for efficient lookup and topology building.
+ *
+ * @version 1.4
+ */
+class GEOS_DLL EdgeEndStar /* non-final */ {
+public:
+
+    typedef std::set<EdgeEnd*, EdgeEndLT> container;
+
+    typedef container::iterator iterator;
+    typedef container::const_iterator const_iterator;
+    typedef container::reverse_iterator reverse_iterator;
+
+    EdgeEndStar();
+
+    virtual
+    ~EdgeEndStar() {}
+
+    /** \brief
+     * Insert a EdgeEnd into this EdgeEndStar
+     */
+    virtual void insert(EdgeEnd* e) = 0;
+
+    /**
+     * @return the coordinate for the node this star is based at
+     *         or NULL if this is still an unbound star.
+     * Be aware that the returned pointer will point to
+     * a Coordinate owned by the specific EdgeEnd happening
+     * to be the first in the star (ordered CCW)
+     */
+    geom::Coordinate& getCoordinate();
+
+    const geom::Coordinate& getCoordinate() const;
+
+    std::size_t getDegree();
+
+    iterator begin();
+
+    iterator end();
+
+    reverse_iterator rbegin();
+
+    reverse_iterator rend();
+
+    const_iterator
+    begin() const
+    {
+        return edgeMap.begin();
+    }
+
+    const_iterator
+    end() const
+    {
+        return edgeMap.end();
+    }
+
+    container& getEdges();
+
+    EdgeEnd* getNextCW(EdgeEnd* ee);
+
+    virtual void computeLabelling(const std::vector<std::unique_ptr<GeometryGraph>>&geomGraph);
+    // throw(TopologyException *);
+
+    bool isAreaLabelsConsistent(const GeometryGraph& geomGraph);
+
+    void propagateSideLabels(uint32_t geomIndex);
+    // throw(TopologyException *);
+
+    //virtual int findIndex(EdgeEnd *eSearch);
+    iterator find(EdgeEnd* eSearch);
+
+    virtual std::string print() const;
+
+protected:
+
+    /** \brief
+     * A map which maintains the edges in sorted order
+     * around the node
+     */
+    EdgeEndStar::container edgeMap;
+
+    /** \brief
+     * Insert an EdgeEnd into the map.
+     */
+    void
+    insertEdgeEnd(EdgeEnd* e)
+    {
+        edgeMap.insert(e);
+    }
+
+private:
+
+    geom::Location getLocation(uint32_t geomIndex,
+                                       const geom::Coordinate&p,
+                                       const std::vector<std::unique_ptr<GeometryGraph>>&geom);
+
+    /** \brief
+     * The location of the point for this star in
+     * Geometry i Areas
+     */
+    std::array<geom::Location, 2> ptInAreaLocation;
+
+    void computeEdgeEndLabels(const algorithm::BoundaryNodeRule&);
+
+    bool checkAreaLabelsConsistent(uint32_t geomIndex);
+
+};
+
+inline std::size_t
+EdgeEndStar::getDegree()
+{
+    return edgeMap.size();
+}
+
+inline EdgeEndStar::iterator
+EdgeEndStar::begin()
+{
+    return edgeMap.begin();
+}
+
+inline EdgeEndStar::container&
+EdgeEndStar::getEdges()
+{
+    return edgeMap;
+}
+
+inline EdgeEndStar::reverse_iterator
+EdgeEndStar::rend()
+{
+    return edgeMap.rend();
+}
+
+inline EdgeEndStar::iterator
+EdgeEndStar::end()
+{
+    return edgeMap.end();
+}
+
+inline EdgeEndStar::reverse_iterator
+EdgeEndStar::rbegin()
+{
+    return edgeMap.rbegin();
+}
+
+inline EdgeEndStar::iterator
+EdgeEndStar::find(EdgeEnd* eSearch)
+{
+    return edgeMap.find(eSearch);
+}
+
+std::ostream& operator<< (std::ostream&, const EdgeEndStar&);
+
+} // namespace geos.geomgraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+