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

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

@@ -0,0 +1,149 @@
+/**********************************************************************
+ *
+ * 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 <vector>
+
+#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 Coordinate;
+}
+namespace planargraph {
+class DirectedEdge;
+class Edge;
+}
+}
+
+namespace geos {
+namespace planargraph { // geos.planargraph
+
+/// A sorted collection of DirectedEdge which leave a Node in a PlanarGraph.
+class GEOS_DLL DirectedEdgeStar {
+protected:
+
+private:
+    /**
+     * \brief The underlying list of outgoing DirectedEdges
+     */
+    mutable std::vector<DirectedEdge*> outEdges;
+    mutable bool sorted;
+    void sortEdges() const;
+
+public:
+    /**
+     * \brief Constructs a DirectedEdgeStar with no edges.
+     */
+    DirectedEdgeStar(): sorted(false) {}
+
+    virtual
+    ~DirectedEdgeStar() {}
+
+    /**
+     * \brief Adds a new member to this DirectedEdgeStar.
+     */
+    void add(DirectedEdge* de);
+
+    /**
+     * \brief Drops a member of this DirectedEdgeStar.
+     */
+    void remove(DirectedEdge* de);
+
+    /**
+     * \brief Returns an Iterator over the DirectedEdges,
+     * in ascending order by angle with the positive x-axis.
+     */
+    std::vector<DirectedEdge*>::iterator
+    iterator()
+    {
+        return begin();
+    }
+    /// Returns an iterator to first DirectedEdge
+    std::vector<DirectedEdge*>::iterator begin();
+
+    /// Returns an iterator to one-past last DirectedEdge
+    std::vector<DirectedEdge*>::iterator end();
+
+    /// Returns an const_iterator to first DirectedEdge
+    std::vector<DirectedEdge*>::const_iterator begin() const;
+
+    /// Returns an const_iterator to one-past last DirectedEdge
+    std::vector<DirectedEdge*>::const_iterator end() const;
+
+    /**
+     * \brief Returns the number of edges around the Node associated
+     * with this DirectedEdgeStar.
+     */
+    std::size_t
+    getDegree() const
+    {
+        return outEdges.size();
+    }
+
+    /**
+     * \brief Returns the coordinate for the node at which this
+     * star is based
+     */
+    geom::Coordinate& getCoordinate() const;
+
+    /**
+     * \brief Returns the DirectedEdges, in ascending order
+     * by angle with the positive x-axis.
+     */
+    std::vector<DirectedEdge*>& getEdges();
+
+    /**
+     * \brief Returns the zero-based index of the given Edge,
+     * after sorting in ascending order by angle with the
+     * positive x-axis.
+     */
+    int getIndex(const Edge* edge);
+
+    /**
+     * \brief Returns the zero-based index of the given DirectedEdge,
+     * after sorting in ascending order
+     * by angle with the positive x-axis.
+     */
+    int getIndex(const DirectedEdge* dirEdge);
+
+    /**
+     * \brief Returns the remainder when i is divided by the number of
+     * edges in this DirectedEdgeStar.
+     */
+    unsigned int getIndex(int i) const;
+
+    /**
+     * \brief Returns the DirectedEdge on the left-hand side
+     * of the given DirectedEdge (which must be a member of this
+     * DirectedEdgeStar).
+     */
+    DirectedEdge* getNextEdge(DirectedEdge* dirEdge);
+};
+
+} // namespace geos::planargraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

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

@@ -0,0 +1,141 @@
+/**********************************************************************
+ *
+ * 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 <vector> // for typedefs
+#include <set> // for typedefs
+#include <iosfwd> // ostream
+#include <cstdint>
+
+#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 planargraph {
+class DirectedEdgeStar;
+class DirectedEdge;
+class Edge;
+class Node;
+}
+}
+
+namespace geos {
+namespace planargraph { // geos.planargraph
+
+/**
+ * \brief Represents an undirected edge of a PlanarGraph.
+ *
+ * An undirected edge in fact simply acts as a central point of reference
+ * for two opposite DirectedEdge.
+ *
+ * Usually a client using a PlanarGraph will subclass Edge
+ * to add its own application-specific data and methods.
+ */
+class GEOS_DLL Edge: public GraphComponent {
+
+public:
+
+    friend std::ostream& operator<< (std::ostream& os, const Node&);
+
+    /// Set of const Edges pointers
+    typedef std::set<const Edge*> ConstSet;
+
+    /// Set of non-const Edges pointers
+    typedef std::set<Edge*> NonConstSet;
+
+    /// Vector of non-const Edges pointers
+    typedef std::vector<Edge*> NonConstVect;
+
+    /// Vector of const Edges pointers
+    typedef std::vector<const Edge*> ConstVect;
+
+protected:
+
+    /** \brief The two DirectedEdges associated with this Edge */
+    std::vector<DirectedEdge*> dirEdge;
+
+public:
+
+    /** \brief
+     * Constructs a Edge whose DirectedEdges are not yet set.
+     *
+     * Be sure to call
+     * {@link #setDirectedEdges(DirectedEdge* de0, DirectedEdge* de1)}
+     */
+    Edge(): dirEdge() {}
+
+    /**
+     * \brief Constructs an Edge initialized with the given DirectedEdges.
+     *
+     * For each DirectedEdge: sets the Edge, sets the symmetric
+     * DirectedEdge, and adds this Edge to its from-Node.
+     */
+    Edge(DirectedEdge* de0, DirectedEdge* de1)
+        :
+        dirEdge()
+    {
+        setDirectedEdges(de0, de1);
+    }
+
+    /**
+     * \brief Initializes this Edge's two DirectedEdges.
+     *
+     * For each DirectedEdge:
+     * - sets the Edge, sets the symmetric DirectedEdge, and
+     * - adds this Edge to its from-Node.
+     */
+    void setDirectedEdges(DirectedEdge* de0, DirectedEdge* de1);
+
+    /**
+     * \brief Returns one of the DirectedEdges associated with this Edge.
+     * @param i 0 or 1
+     */
+    DirectedEdge* getDirEdge(int i);
+
+    /**
+     * \brief Returns the DirectedEdge that starts from the given node,
+     * or null if the node is not one of the two nodes associated
+     * with this Edge.
+     */
+    DirectedEdge* getDirEdge(Node* fromNode);
+
+    /**
+     * \brief If <code>node</code> is one of the two nodes associated
+     * with this Edge, returns the other node; otherwise returns null.
+     */
+    Node* getOppositeNode(Node* node);
+};
+
+/// Print a Edge
+std::ostream& operator<<(std::ostream& os, const Edge& n);
+
+/// For backward compatibility
+//typedef Edge planarEdge;
+
+} // namespace geos::planargraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

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

@@ -0,0 +1,182 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************
+ *
+ * Last port: planargraph/GraphComponent.java rev. 1.7 (JTS-1.7)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+namespace geos {
+namespace planargraph { // geos.planargraph
+
+/**
+ * \brief The base class for all graph component classes.
+ *
+ * Maintains flags of use in generic graph algorithms.
+ * Provides two flags:
+ *
+ *  - <b>marked</b> - typically this is used to indicate a state that
+ *    persists for the course of the graph's lifetime.  For instance,
+ *    it can be used to indicate that a component has been logically
+ *    deleted from the graph.
+ *  - <b>visited</b> - this is used to indicate that a component has been
+ *    processed or visited by an single graph algorithm.  For instance,
+ *    a breadth-first traversal of the graph might use this to indicate
+ *    that a node has already been traversed.
+ *    The visited flag may be set and cleared many times during the
+ *    lifetime of a graph.
+ *
+ */
+class GEOS_DLL GraphComponent {
+
+protected:
+
+    /// Variable holding ''marked'' status
+    bool isMarkedVar;
+
+    /// Variable holding ''visited'' status
+    bool isVisitedVar;
+
+public:
+
+    GraphComponent()
+        :
+        isMarkedVar(false),
+        isVisitedVar(false)
+    {}
+
+    virtual
+    ~GraphComponent() {}
+
+    /** \brief
+     * Tests if a component has been visited during the course
+     * of a graph algorithm.
+     *
+     * @return <code>true</code> if the component has been visited
+     */
+    virtual bool
+    isVisited() const
+    {
+        return isVisitedVar;
+    }
+
+    /** \brief
+     * Sets the visited flag for this component.
+     * @param p_isVisited the desired value of the visited flag
+     */
+    virtual void
+    setVisited(bool p_isVisited)
+    {
+        isVisitedVar = p_isVisited;
+    }
+
+    /** \brief
+     * Sets the Visited state for the elements of a container,
+     * from start to end iterator.
+     *
+     * @param start the start element
+     * @param end one past the last element
+     * @param visited the state to set the visited flag to
+     */
+    template <typename T>
+    static void
+    setVisited(T start, T end, bool visited)
+    {
+        for(T i = start; i != end; ++i) {
+            (*i)->setVisited(visited);
+        }
+    }
+
+    /** \brief
+     * Sets the Visited state for the values of each map
+     * container element, from start to end iterator.
+     *
+     * @param start the start element
+     * @param end one past the last element
+     * @param visited the state to set the visited flag to
+     */
+    template <typename T>
+    static void
+    setVisitedMap(T start, T end, bool visited)
+    {
+        for(T i = start; i != end; ++i) {
+            i->second->setVisited(visited);
+        }
+    }
+
+    /** \brief
+     * Sets the Marked state for the elements of a container,
+     * from start to end iterator.
+     *
+     * @param start the start element
+     * @param end one past the last element
+     * @param marked the state to set the marked flag to
+     */
+    template <typename T>
+    static void
+    setMarked(T start, T end, bool marked)
+    {
+        for(T i = start; i != end; ++i) {
+            (*i)->setMarked(marked);
+        }
+    }
+
+
+    /** \brief
+     * Sets the Marked state for the values of each map
+     * container element, from start to end iterator.
+     *
+     * @param start the start element
+     * @param end one past the last element
+     * @param marked the state to set the visited flag to
+     */
+    template <typename T>
+    static void
+    setMarkedMap(T start, T end, bool marked)
+    {
+        for(T i = start; i != end; ++i) {
+            i->second->setMarked(marked);
+        }
+    }
+
+    /** \brief
+     * Tests if a component has been marked at some point
+     * during the processing involving this graph.
+     * @return <code>true</code> if the component has been marked
+     */
+    virtual bool
+    isMarked() const
+    {
+        return isMarkedVar;
+    }
+
+    /** \brief
+     * Sets the marked flag for this component.
+     * @param p_isMarked the desired value of the marked flag
+     */
+    virtual void
+    setMarked(bool p_isMarked)
+    {
+        isMarkedVar = p_isMarked;
+    }
+
+};
+
+} // namespace geos::planargraph
+} // namespace geos
+

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

@@ -0,0 +1,158 @@
+/**********************************************************************
+ *
+ * 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/planargraph/DirectedEdgeStar.h> // for inlines
+#include <geos/geom/Coordinate.h> // for composition
+
+// Forward declarations
+namespace geos {
+namespace planargraph {
+//class DirectedEdgeStar;
+class DirectedEdge;
+}
+}
+
+namespace geos {
+namespace planargraph { // geos.planargraph
+
+/**
+ * \brief A node in a PlanarGraph is a location where 0 or more Edge meet.
+ *
+ * A node is connected to each of its incident Edges via an outgoing
+ * DirectedEdge. Some clients using a <code>PlanarGraph</code> may want to
+ * subclass <code>Node</code> to add their own application-specific
+ * data and methods.
+ *
+ */
+class GEOS_DLL Node: public GraphComponent {
+protected:
+
+    /// The location of this Node
+    geom::Coordinate pt;
+
+    /// The collection of DirectedEdges that leave this Node
+    DirectedEdgeStar* deStar;
+
+public:
+
+    friend std::ostream& operator << (std::ostream& os, const Node&);
+
+    /** \brief
+     * Returns all Edges that connect the two nodes (which are
+     * assumed to be different).
+     *
+     * Note: returned vector is newly allocated, ownership to
+     * the caller.
+     */
+    static std::vector<Edge*>* getEdgesBetween(Node* node0,
+            Node* node1);
+
+    /// Constructs a Node with the given location.
+    Node(const geom::Coordinate& newPt)
+        :
+        pt(newPt)
+    {
+        deStar = new DirectedEdgeStar();
+    }
+
+    ~Node() override
+    {
+        delete deStar;
+    }
+
+    /**
+     * \brief
+     * Constructs a Node with the given location and
+     * collection of outgoing DirectedEdges.
+     * Takes ownership of the given DirectedEdgeStar!!
+     */
+    Node(geom::Coordinate& newPt, DirectedEdgeStar* newDeStar)
+        :
+        pt(newPt),
+        deStar(newDeStar)
+    {}
+
+    /**
+     * \brief Returns the location of this Node.
+     */
+    geom::Coordinate&
+    getCoordinate()
+    {
+        return pt;
+    }
+
+    /**
+     * \brief Adds an outgoing DirectedEdge to this Node.
+     */
+    void
+    addOutEdge(DirectedEdge* de)
+    {
+        deStar->add(de);
+    }
+
+    /**
+     * \brief Returns the collection of DirectedEdges that
+     * leave this Node.
+     */
+    DirectedEdgeStar*
+    getOutEdges()
+    {
+        return deStar;
+    }
+    const DirectedEdgeStar*
+    getOutEdges() const
+    {
+        return deStar;
+    }
+
+    /**
+     * \brief Returns the number of edges around this Node.
+     */
+    size_t
+    getDegree() const
+    {
+        return deStar->getDegree();
+    }
+
+    /**
+     * \brief Returns the zero-based index of the given Edge,
+     * after sorting in ascending order by angle with
+     * the positive x-axis.
+     */
+    int
+    getIndex(Edge* edge)
+    {
+        return deStar->getIndex(edge);
+    }
+
+private:
+
+    Node(const Node&) = delete;
+    Node& operator=(const Node&) = delete;
+
+};
+
+/// Print a Node
+std::ostream& operator<<(std::ostream& os, const Node& n);
+
+
+} // namespace geos::planargraph
+} // namespace geos
+