@cpp.js/package-geos 1.0.0-beta.22 → 1.0.0

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

@@ -0,0 +1,236 @@
+/**********************************************************************
+ *
+ * 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/DirectedEdge.java r428 (JTS-1.12)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <string>
+
+#include <geos/geom/Location.h>
+#include <geos/geomgraph/EdgeEnd.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace geomgraph {
+class Edge;
+class EdgeRing;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/// A directed EdgeEnd
+class GEOS_DLL DirectedEdge final: public EdgeEnd {
+
+public:
+
+    /** \brief
+     * Computes the factor for the change in depth when moving from
+     * one location to another.
+     * E.g. if crossing from the INTERIOR to the EXTERIOR the depth
+     * decreases, so the factor is -1
+     */
+    static int depthFactor(geom::Location currLocation, geom::Location nextLocation);
+
+    //DirectedEdge();
+    //virtual ~DirectedEdge();
+
+    DirectedEdge(Edge* newEdge, bool newIsForward);
+
+    // this is no different from Base class, no need to override
+    //Edge* getEdge();
+
+    void setInResult(bool v)
+    {
+        isInResultVar = v;
+    };
+
+    bool isInResult() const
+    {
+        return isInResultVar;
+    };
+
+    bool isVisited() const
+    {
+        return isVisitedVar;
+    };
+
+
+    void setVisited(bool v)
+    {
+        isVisitedVar = v;
+    };
+
+    void setEdgeRing(EdgeRing* er)
+    {
+        edgeRing = er;
+    };
+
+    EdgeRing* getEdgeRing() const
+    {
+        return edgeRing;
+    };
+
+    void setMinEdgeRing(EdgeRing* mer)
+    {
+        minEdgeRing = mer;
+    };
+
+    EdgeRing* getMinEdgeRing() const
+    {
+        return minEdgeRing;
+    };
+
+    int getDepth(int position) const
+    {
+        return depth[position];
+    };
+
+    void setDepth(int position, int newDepth);
+
+    int getDepthDelta() const;
+
+    /// Marks both DirectedEdges attached to a given Edge.
+    ///
+    /// This is used for edges corresponding to lines, which will only
+    /// appear oriented in a single direction in the result.
+    ///
+    void setVisitedEdge(bool newIsVisited);
+
+    /** \brief
+     * Each Edge gives rise to a pair of symmetric DirectedEdges,
+     * in opposite directions.
+     *
+     * @return the DirectedEdge for the same Edge but in the
+     *         opposite direction
+     */
+    DirectedEdge* getSym() const
+    {
+        return sym;
+    };
+
+    bool isForward() const
+    {
+        return isForwardVar;
+    };
+
+    void setSym(DirectedEdge* de)
+    {
+        sym = de;
+    };
+
+    DirectedEdge* getNext() const
+    {
+        return next;
+    };
+
+    void setNext(DirectedEdge* newNext)
+    {
+        next = newNext;
+    };
+
+    DirectedEdge* getNextMin() const
+    {
+        return nextMin;
+    };
+
+    void setNextMin(DirectedEdge* nm)
+    {
+        nextMin = nm;
+    };
+
+    /** \brief
+     * Tells whether this edge is a Line
+     *
+     * This edge is a line edge if
+     * - at least one of the labels is a line label
+     * - any labels which are not line labels have all Locations = EXTERIOR
+     *
+     */
+    bool isLineEdge();
+
+    /** \brief
+     * Tells whether this edge is an Area
+     *
+     * This is an interior Area edge if
+     * - its label is an Area label for both Geometries
+     * - and for each Geometry both sides are in the interior.
+     *
+     * @return true if this is an interior Area edge
+     */
+    bool isInteriorAreaEdge();
+
+    /** \brief
+     * Set both edge depths.
+     *
+     * One depth for a given side is provided.
+     * The other is computed depending on the Location transition and the
+     * depthDelta of the edge.
+     */
+    void setEdgeDepths(int position, int newDepth);
+
+    std::string print() const override;
+
+    std::string printEdge();
+
+
+protected:
+
+    bool isForwardVar;
+
+
+private:
+
+    bool isInResultVar;
+
+    bool isVisitedVar;
+
+    /// the symmetric edge
+    DirectedEdge* sym;
+
+    /// the next edge in the edge ring for the polygon containing this edge
+    DirectedEdge* next;
+
+    /// the next edge in the MinimalEdgeRing that contains this edge
+    DirectedEdge* nextMin;
+
+    /// the EdgeRing that this edge is part of
+    EdgeRing* edgeRing;
+
+    /// the MinimalEdgeRing that this edge is part of
+    EdgeRing* minEdgeRing;
+
+    /** \brief
+     * The depth of each side (position) of this edge.
+     * The 0 element of the array is never used.
+     */
+    int depth[3];
+
+    /// Compute the label in the appropriate orientation for this DirEdge
+    void computeDirectedLabel();
+
+
+};
+
+} // namespace geos.geomgraph
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/geomgraph/DirectedEdgeStar.h

@@ -0,0 +1,164 @@
+/**********************************************************************
+ *
+ * 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/DirectedEdgeStar.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <memory>
+#include <geos/export.h>
+#include <set>
+#include <string>
+#include <vector>
+
+#include <geos/geomgraph/EdgeEndStar.h>  // for inheritance
+#include <geos/geomgraph/Label.h>  // for private member
+#include <geos/geom/Coordinate.h>  // for p0,p1
+
+
+// Forward declarations
+namespace geos {
+namespace geomgraph {
+class DirectedEdge;
+class EdgeRing;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/**
+ * \brief
+ * A DirectedEdgeStar is an ordered list of **outgoing** DirectedEdges around a node.
+ *
+ * It supports labelling the edges as well as linking the edges to form both
+ * MaximalEdgeRings and MinimalEdgeRings.
+ *
+ */
+class GEOS_DLL DirectedEdgeStar: public EdgeEndStar {
+
+public:
+
+    DirectedEdgeStar()
+        :
+        EdgeEndStar(),
+        label(),
+        resultAreaEdgesComputed(false)
+    {}
+
+    ~DirectedEdgeStar() override = default;
+
+    /// Insert a directed edge in the list
+    void insert(EdgeEnd* ee) override;
+
+    Label&
+    getLabel()
+    {
+        return label;
+    }
+
+    int getOutgoingDegree();
+
+    int getOutgoingDegree(EdgeRing* er);
+
+    DirectedEdge* getRightmostEdge();
+
+    /** \brief
+     * Compute the labelling for all dirEdges in this star, as well as the overall labelling
+     */
+    void computeLabelling(const std::vector<std::unique_ptr<GeometryGraph>>&geom) override; // throw(TopologyException *);
+
+    /** \brief
+     * For each dirEdge in the star, merge the label from the sym dirEdge into the label
+     */
+    void mergeSymLabels();
+
+    /// \brief Update incomplete dirEdge labels from the labelling for the node
+    void updateLabelling(const Label& nodeLabel);
+
+
+    /** \brief
+     * Traverse the star of DirectedEdges, linking the included edges together.
+     *
+     * To link two dirEdges, the `next` pointer for an incoming dirEdge
+     * is set to the next outgoing edge.
+     *
+     * DirEdges are only linked if:
+     *
+     * - they belong to an area (i.e. they have sides)
+     * - they are marked as being in the result
+     *
+     * Edges are linked in CCW order (the order they are stored). This means
+     * that rings have their face on the Right (in other words, the topological
+     * location of the face is given by the RHS label of the DirectedEdge)
+     *
+     * PRECONDITION: No pair of dirEdges are both marked as being in the result
+     */
+    void linkResultDirectedEdges(); // throw(TopologyException *);
+
+    void linkMinimalDirectedEdges(EdgeRing* er);
+
+    void linkAllDirectedEdges();
+
+    /** \brief
+     * Traverse the star of edges, maintaining the current location in the result
+     * area at this node (if any).
+     *
+     * If any L edges are found in the interior of the result, mark them as covered.
+     */
+    void findCoveredLineEdges();
+
+    /** \brief
+     * Compute the DirectedEdge depths for a subsequence of the edge array.
+     */
+    void computeDepths(DirectedEdge* de);
+
+    std::string print() const override;
+
+private:
+
+    /**
+     * A list of all outgoing edges in the result, in CCW order
+     */
+    std::vector<DirectedEdge*> resultAreaEdgeList;
+
+    Label label;
+
+    bool resultAreaEdgesComputed;
+
+    /// \brief
+    /// Returned vector is owned by DirectedEdgeStar object, but
+    /// lazily created
+    const std::vector<DirectedEdge*>& getResultAreaEdges();
+
+
+    /// States for linResultDirectedEdges
+    enum {
+        SCANNING_FOR_INCOMING = 1,
+        LINKING_TO_OUTGOING
+    };
+
+    int computeDepths(EdgeEndStar::iterator startIt,
+                      EdgeEndStar::iterator endIt, int startDepth);
+};
+
+
+} // namespace geos.geomgraph
+} // namespace geos
+

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