@cpp.js/package-geos 1.0.0-beta.20

package/dist/prebuilt/Android-arm64-v8a/include/geos/planargraph/PlanarGraph.h

@@ -0,0 +1,293 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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/PlanarGraph.java rev. 107/138 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/planargraph/NodeMap.h> // for composition
+
+#include <vector> // for typedefs
+
+#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;
+class Node;
+}
+}
+
+namespace geos {
+namespace planargraph { // geos.planargraph
+
+/**
+ * \class PlanarGraph
+ * \brief
+ * Represents a directed graph which is embeddable in a planar surface.
+ *
+ * This class and the other classes in this package serve as a framework for
+ * building planar graphs for specific algorithms. This class must be
+ * subclassed to expose appropriate methods to construct the graph. This allows
+ * controlling the types of graph components (DirectedEdge, Edge and Node)
+ * which can be added to the graph. An application which uses the graph
+ * framework will almost always provide subclasses for one or more graph
+ * components, which hold application-specific data and graph algorithms.
+ */
+class GEOS_DLL PlanarGraph {
+
+protected:
+
+    std::vector<Edge*> edges;
+    std::vector<DirectedEdge*> dirEdges;
+    NodeMap nodeMap;
+
+    /**
+     * \brief
+     * Adds a node to the std::map, replacing any that is already at that
+     * location.
+     *
+     * Only subclasses can add Nodes, to ensure Nodes are
+     * of the right type.
+     */
+    void
+    add(Node* node)
+    {
+        nodeMap.add(node);
+    }
+
+    /**
+     * \brief
+     * Adds the Edge and its DirectedEdges with this PlanarGraph.
+     *
+     * Assumes that the Edge has already been created with its associated
+     * DirectEdges.
+     * Only subclasses can add Edges, to ensure the edges added are of
+     * the right class.
+     */
+    void add(Edge* edge);
+
+    /**
+     * \brief
+     * Adds the Edge to this PlanarGraph.
+     *
+     * Only subclasses can add DirectedEdges,
+     * to ensure the edges added are of the right class.
+     */
+    void
+    add(DirectedEdge* dirEdge)
+    {
+        dirEdges.push_back(dirEdge);
+    }
+
+public:
+
+    typedef std::vector<Edge*> EdgeContainer;
+    typedef EdgeContainer::iterator EdgeIterator;
+
+
+    /**
+     * \brief
+     * Constructs a PlanarGraph without any Edges, DirectedEdges, or Nodes.
+     */
+    PlanarGraph() {}
+
+    virtual
+    ~PlanarGraph() {}
+
+    /**
+     * \brief
+     * Returns the Node at the given location,
+     * or null if no Node was there.
+     */
+    Node*
+    findNode(const geom::Coordinate& pt)
+    {
+        return nodeMap.find(pt);
+    }
+
+    /**
+     * \brief
+     * Returns an Iterator over the Nodes in this PlanarGraph.
+     */
+    NodeMap::container::iterator
+    nodeIterator()
+    {
+        return nodeMap.begin();
+    }
+
+    NodeMap::container::iterator
+    nodeBegin()
+    {
+        return nodeMap.begin();
+    }
+
+    NodeMap::container::const_iterator
+    nodeBegin() const
+    {
+        return nodeMap.begin();
+    }
+
+    NodeMap::container::iterator
+    nodeEnd()
+    {
+        return nodeMap.end();
+    }
+
+    NodeMap::container::const_iterator
+    nodeEnd() const
+    {
+        return nodeMap.end();
+    }
+
+    /**
+     * \brief
+     * Returns the Nodes in this PlanarGraph.
+     *
+     * @param nodes : the nodes are push_back'ed here
+     */
+    void
+    getNodes(std::vector<Node*>& nodes)
+    {
+        nodeMap.getNodes(nodes);
+    }
+
+    /**
+     * \brief
+     * Returns an Iterator over the DirectedEdges in this PlanarGraph,
+     * in the order in which they were added.
+     *
+     * @see add(Edge)
+     * @see add(DirectedEdge)
+     */
+    std::vector<DirectedEdge*>::iterator
+    dirEdgeIterator()
+    {
+        return dirEdges.begin();
+    }
+
+    std::vector<DirectedEdge*>::iterator
+    dirEdgeBegin()
+    {
+        return dirEdges.begin();
+    }
+
+    std::vector<DirectedEdge*>::iterator
+    dirEdgeEnd()
+    {
+        return dirEdges.end();
+    }
+
+    /// Alias for edgeBegin()
+    std::vector<Edge*>::iterator
+    edgeIterator()
+    {
+        return edges.begin();
+    }
+
+    /// Returns an iterator to first Edge in this graph.
+    //
+    /// Edges are stored in the order they were added.
+    /// @see add(Edge)
+    ///
+    std::vector<Edge*>::iterator
+    edgeBegin()
+    {
+        return edges.begin();
+    }
+
+    /// Returns an iterator to one-past last Edge in this graph.
+    //
+    /// Edges are stored in the order they were added.
+    /// @see add(Edge)
+    ///
+    std::vector<Edge*>::iterator
+    edgeEnd()
+    {
+        return edges.end();
+    }
+
+    /**
+     * Returns the Edges that have been added to this PlanarGraph
+     * @see PlanarGraph::add(Edge* edge)
+     */
+    std::vector<Edge*>*
+    getEdges()
+    {
+        return &edges;
+    }
+
+    /**
+     * \brief
+     * Removes an Edge and its associated DirectedEdges from their
+     * from-Nodes and from this PlanarGraph.
+     *
+     * Note: This method does not remove the Nodes associated
+     * with the Edge, even if the removal of the Edge reduces the
+     * degree of a Node to zero.
+     */
+    void remove(Edge* edge);
+
+    /**
+     * \brief
+     * Removes DirectedEdge from its from-Node and from this PlanarGraph.
+     *
+     * Note:
+     * This method does not remove the Nodes associated with the
+     * DirectedEdge, even if the removal of the DirectedEdge reduces
+     * the degree of a Node to zero.
+     */
+    void remove(DirectedEdge* de);
+
+    /**
+     * \brief
+     * Removes a node from the graph, along with any associated
+     * DirectedEdges and Edges.
+     */
+    void remove(Node* node);
+
+    /**
+     * \brief
+     * Returns all Nodes with the given number of Edges around it.
+     * The return value is a newly allocated vector of existing nodes
+     */
+    std::vector<Node*>* findNodesOfDegree(std::size_t degree);
+
+    /**
+     * \brief
+     * Get all Nodes with the given number of Edges around it.
+     *
+     * Found nodes are pushed to the given vector
+     */
+    void findNodesOfDegree(std::size_t degree, std::vector<Node*>& to);
+};
+
+} // namespace geos::planargraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-arm64-v8a/include/geos/planargraph/Subgraph.h

@@ -0,0 +1,181 @@
+/**********************************************************************
+ *
+ * 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/NodeMap.h> // for composition
+
+#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 planargraph {
+class PlanarGraph;
+class DirectedEdge;
+class Edge;
+}
+}
+
+namespace geos {
+namespace planargraph { // geos.planargraph
+
+/// \brief A subgraph of a PlanarGraph.
+///
+/// A subgraph may contain any subset of {@link Edge}s
+/// from the parent graph.
+/// It will also automatically contain all {@link DirectedEdge}s
+/// and {@link Node}s associated with those edges.
+/// No new objects are created when edges are added -
+/// all associated components must already exist in the parent graph.
+///
+/// @note Actually we'll be copying Coordinates in NodeMap.
+/// I guess that'll need to be changed soon.
+///
+class GEOS_DLL Subgraph {
+public:
+    /** \brief
+     * Creates a new subgraph of the given PlanarGraph
+     *
+     * @param parent the parent graph
+     */
+    Subgraph(PlanarGraph& parent)
+        :
+        parentGraph(parent)
+    {}
+
+    /** \brief
+     * Gets the PlanarGraph which this subgraph
+     * is part of.
+     *
+     * @return the parent PlanarGraph
+     */
+    PlanarGraph&
+    getParent() const
+    {
+        return parentGraph;
+    }
+
+    /** \brief
+     * Adds an Edge to the subgraph.
+     *
+     * The associated {@link DirectedEdge}s and {@link Node}s
+     * are also added.
+     *
+     * @param e the edge to add
+     *
+     * @return a pair with first element being an iterator
+     *         to the Edge in set and second element
+     *	       being a boolean value indicating wheter
+     *	       the Edge has been inserted now or was
+     *	       already in the set.
+     */
+    std::pair<std::set<Edge*>::iterator, bool> add(Edge* e);
+
+    /** \brief
+     * Returns an iterator over the DirectedEdge in this graph,
+     * in the order in which they were added.
+     *
+     * @return an iterator over the directed edges
+     *
+     * @see add(Edge)
+     */
+    std::vector<const DirectedEdge*>::iterator
+    getDirEdgeBegin()
+    {
+        return dirEdges.begin();
+    }
+
+
+    /** \brief
+     * Returns an iterator over the {@link Edge}s in this
+     * graph, in the order in which they were added.
+     *
+     * @return an iterator over the edges
+     *
+     * @see add(Edge)
+     */
+    std::set<Edge*>::iterator
+    edgeBegin()
+    {
+        return edges.begin();
+    }
+    std::set<Edge*>::iterator
+    edgeEnd()
+    {
+        return edges.end();
+    }
+
+    /** \brief
+     * Returns a iterators over the planar NodeMap::container
+     * in this graph.
+     */
+    NodeMap::container::iterator
+    nodeBegin()
+    {
+        return nodeMap.begin();
+    }
+    NodeMap::container::const_iterator
+    nodeEnd() const
+    {
+        return nodeMap.end();
+    }
+    NodeMap::container::iterator
+    nodeEnd()
+    {
+        return nodeMap.end();
+    }
+    NodeMap::container::const_iterator
+    nodeBegin() const
+    {
+        return nodeMap.begin();
+    }
+
+    /** \brief
+     * Tests whether an {@link Edge} is contained in this subgraph.
+     *
+     * @param e the edge to test
+     * @return `true` if the edge is contained in this subgraph
+     */
+    bool
+    contains(Edge* e)
+    {
+        return (edges.find(e) != edges.end());
+    }
+
+protected:
+
+    PlanarGraph& parentGraph;
+    std::set<Edge*> edges;
+    std::vector<const DirectedEdge*> dirEdges;
+    NodeMap nodeMap;
+
+    // Declare type as noncopyable
+    Subgraph(const Subgraph& other) = delete;
+    Subgraph& operator=(const Subgraph& rhs) = delete;
+};
+
+} // namespace geos::planargraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-arm64-v8a/include/geos/planargraph/algorithm/ConnectedSubgraphFinder.h

@@ -0,0 +1,92 @@
+/**********************************************************************
+ *
+ * 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/PlanarGraph.h> // for inlines
+
+#include <stack>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace planargraph {
+class PlanarGraph;
+class Subgraph;
+class Node;
+}
+}
+
+namespace geos {
+namespace planargraph { // geos::planargraph
+namespace algorithm { // geos::planargraph::algorithm
+
+/** \brief
+ * Finds all connected {@link Subgraph}s of a PlanarGraph.
+ *
+ * <b>Note:</b> uses the <code>isVisited</code> flag on the nodes.
+ */
+class GEOS_DLL ConnectedSubgraphFinder {
+public:
+
+    ConnectedSubgraphFinder(PlanarGraph& newGraph)
+        :
+        graph(newGraph)
+    {}
+
+    /// \brief
+    /// Store newly allocated connected Subgraphs into the
+    /// given std::vector
+    ///
+    /// Caller take responsibility in releasing memory associated
+    /// with the subgraphs themself.
+    ///
+    ///
+    void getConnectedSubgraphs(std::vector<Subgraph*>& dest);
+
+private:
+
+    PlanarGraph& graph;
+
+    /// Returns a newly allocated Subgraph
+    Subgraph* findSubgraph(Node* node);
+
+
+    /**
+     * Adds all nodes and edges reachable from this node to the subgraph.
+     * Uses an explicit stack to avoid a large depth of recursion.
+     *
+     * @param node a node known to be in the subgraph
+     */
+    void addReachable(Node* node, Subgraph* subgraph);
+
+    /**
+     * Adds the argument node and all its out edges to the subgraph.
+     * @param node the node to add
+     * @param nodeStack the current set of nodes being traversed
+     */
+    void addEdges(Node* node, std::stack<Node*>& nodeStack,
+                  Subgraph* subgraph);
+
+    // Declare type as noncopyable
+    ConnectedSubgraphFinder(const ConnectedSubgraphFinder& other) = delete;
+    ConnectedSubgraphFinder& operator=(const ConnectedSubgraphFinder& rhs) = delete;
+};
+
+} // namespace geos::planargraph::algorithm
+} // namespace geos::planargraph
+} // namespace geos
+

package/dist/prebuilt/Android-arm64-v8a/include/geos/precision/CommonBits.h

@@ -0,0 +1,97 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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 <cstdint>
+
+namespace geos {
+namespace precision { // geos.precision
+
+/** \brief
+ * Determines the maximum number of common most-significant
+ * bits in the mantissa of one or numbers.
+ *
+ * Can be used to compute the double-precision number which
+ * is represented by the common bits.
+ * If there are no common bits, the number computed is 0.0.
+ *
+ */
+class GEOS_DLL CommonBits {
+
+private:
+
+    bool isFirst;
+
+    int commonMantissaBitsCount;
+
+    int64_t commonBits;
+
+    int64_t commonSignExp;
+
+public:
+
+    /** \brief
+     * Computes the bit pattern for the sign and exponent of a
+     * double-precision number.
+     *
+     * @param num
+     * @return the bit pattern for the sign and exponent
+     */
+    static int64_t signExpBits(int64_t num);
+
+    /** \brief
+     * This computes the number of common most-significant
+     * bits in the mantissas of two double-precision numbers.
+     *
+     * It does not count the hidden bit, which is always 1.
+     * It does not determine whether the numbers have the same
+     * exponent - if they do not, the value computed by this
+     * function is meaningless.
+     * @param num1
+     * @param num2
+     * @return the number of common most-significant mantissa bits
+     */
+    static int numCommonMostSigMantissaBits(int64_t num1, int64_t num2);
+
+    /** \brief
+     * Zeroes the lower n bits of a bitstring.
+     *
+     * @param bits the bitstring to alter
+     * @param nBits the number of bits to zero
+     * @return the zeroed bitstring
+     */
+    static int64_t zeroLowerBits(int64_t bits, int nBits);
+
+    /** \brief
+     * Extracts the i'th bit of a bitstring.
+     *
+     * @param bits the bitstring to extract from
+     * @param i the bit to extract
+     * @return the value of the extracted bit
+     */
+    static int getBit(int64_t bits, int i);
+
+    CommonBits();
+
+    void add(double num);
+
+    double getCommon();
+
+};
+
+} // namespace geos.precision
+} // namespace geos
+