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

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

@@ -0,0 +1,143 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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/NodeMap.java rev. 1.3 (JTS-1.10)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <map>
+#include <memory>
+#include <vector>
+#include <string>
+
+#include <geos/geom/Coordinate.h> // for CoordinateLessThan
+#include <geos/geomgraph/Node.h> // for testInvariant
+
+
+#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 geomgraph {
+class Node;
+class EdgeEnd;
+class NodeFactory;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+class GEOS_DLL NodeMap final {
+public:
+
+    typedef std::map<geom::Coordinate*, std::unique_ptr<Node>, geom::CoordinateLessThan> container;
+
+    typedef container::iterator iterator;
+
+    typedef container::const_iterator const_iterator;
+
+    container nodeMap;
+
+    const NodeFactory& nodeFact;
+
+    /// \brief
+    /// NodeMap will keep a reference to the NodeFactory,
+    /// keep it alive for the whole NodeMap lifetime
+    NodeMap(const NodeFactory& newNodeFact);
+
+    Node* addNode(const geom::Coordinate& coord);
+
+    Node* addNode(Node* n);
+
+    /// \brief
+    /// Adds a node for the start point of this EdgeEnd
+    /// (if one does not already exist in this map).
+    /// Adds the EdgeEnd to the (possibly new) node.
+    ///
+    /// If ownership of the EdgeEnd should be transferred
+    /// to the Node, use the unique_ptr overload instead.
+    void add(EdgeEnd* e);
+
+    void add(std::unique_ptr<EdgeEnd>&& e);
+
+    Node* find(const geom::Coordinate& coord) const;
+
+    const_iterator
+    begin() const
+    {
+        return nodeMap.begin();
+    }
+
+    const_iterator
+    end() const
+    {
+        return nodeMap.end();
+    }
+
+    iterator
+    begin()
+    {
+        return nodeMap.begin();
+    }
+
+    iterator
+    end()
+    {
+        return nodeMap.end();
+    }
+
+    void getBoundaryNodes(uint8_t geomIndex,
+                          std::vector<Node*>& bdyNodes) const;
+
+    std::string print() const;
+
+    void
+    testInvariant()
+    {
+#ifndef NDEBUG
+        // Each Coordinate key is a pointer inside the Node value
+        for(const auto& nodeIt: nodeMap) {
+            const auto* n = nodeIt.second.get();
+            geom::Coordinate* c = const_cast<geom::Coordinate*>(
+                                      &(n->getCoordinate())
+                                  );
+            assert(nodeIt.first == c);
+            (void)c;
+        }
+#endif
+    }
+
+private:
+
+    // Declare type as noncopyable
+    NodeMap(const NodeMap& other) = delete;
+    NodeMap& operator=(const NodeMap& rhs) = delete;
+};
+
+} // namespace geos.geomgraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

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

@@ -0,0 +1,203 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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/PlanarGraph.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <map>
+#include <vector>
+#include <memory>
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geomgraph/PlanarGraph.h>
+#include <geos/geomgraph/NodeMap.h> // for typedefs
+#include <geos/geomgraph/DirectedEdgeStar.h> // for inlines
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+namespace geomgraph {
+class Edge;
+class Node;
+class EdgeEnd;
+class NodeFactory;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/**
+ * \brief
+ * Represents a directed graph which is embeddable in a planar surface.
+ *
+ * The computation of the IntersectionMatrix relies on the use of a structure
+ * called a "topology graph".  The topology graph contains nodes and edges
+ * corresponding to the nodes and line segments of a Geometry. Each
+ * node and edge in the graph is labeled with its topological location
+ * relative to the source geometry.
+ *
+ * Note that there is no requirement that points of self-intersection
+ * be a vertex.
+ * Thus to obtain a correct topology graph, Geometry objects must be
+ * self-noded before constructing their graphs.
+ *
+ * Two fundamental operations are supported by topology graphs:
+ *
+ *  - Computing the intersections between all the edges and nodes of
+ *    a single graph
+ *  - Computing the intersections between the edges and nodes of two
+ *    different graphs
+ *
+ */
+class GEOS_DLL PlanarGraph /* non-final */ {
+public:
+
+    /** \brief
+     * For nodes in the collection (first..last),
+     * link the DirectedEdges at the node that are in the result.
+     *
+     * This allows clients to link only a subset of nodes in the graph,
+     * for efficiency (because they know that only a subset is of
+     * interest).
+     */
+    template <typename It>
+    static void
+    linkResultDirectedEdges(It first, It last)
+    // throw(TopologyException);
+    {
+        for(; first != last; ++first) {
+            Node* node = *first;
+            assert(node);
+
+            EdgeEndStar* ees = node->getEdges();
+            assert(ees);
+            DirectedEdgeStar* des = dynamic_cast<DirectedEdgeStar*>(ees);
+            assert(des);
+
+            // this might throw an exception
+            des->linkResultDirectedEdges();
+        }
+    }
+
+    PlanarGraph(const NodeFactory& nodeFact);
+
+    PlanarGraph();
+
+    virtual ~PlanarGraph();
+
+    std::vector<Edge*>::iterator getEdgeIterator();
+
+    std::vector<EdgeEnd*>* getEdgeEnds();
+
+    bool isBoundaryNode(uint8_t geomIndex, const geom::Coordinate& coord);
+
+    void add(EdgeEnd* e);
+
+    NodeMap::iterator getNodeIterator();
+
+    void getNodes(std::vector<Node*>&);
+
+    Node* addNode(Node* node);
+
+    Node* addNode(const geom::Coordinate& coord);
+
+    /**
+     * @return the node if found; null otherwise
+     */
+    Node* find(geom::Coordinate& coord);
+
+    /** \brief
+     * Add a set of edges to the graph.  For each edge two DirectedEdges
+     * will be created.  DirectedEdges are NOT linked by this method.
+     */
+    void addEdges(const std::vector<Edge*>& edgesToAdd);
+
+    void linkResultDirectedEdges();
+
+    void linkAllDirectedEdges();
+
+    /** \brief
+     * Returns the EdgeEnd which has edge e as its base edge
+     * (MD 18 Feb 2002 - this should return a pair of edges)
+     *
+     * @return the edge, if found
+     *    <code>null</code> if the edge was not found
+     */
+    EdgeEnd* findEdgeEnd(Edge* e);
+
+    /** \brief
+     * Returns the edge whose first two coordinates are p0 and p1
+     *
+     * @return the edge, if found
+     *    <code>null</code> if the edge was not found
+     */
+    Edge* findEdge(const geom::Coordinate& p0,
+                           const geom::Coordinate& p1);
+
+    /** \brief
+     * Returns the edge which starts at p0 and whose first segment is
+     * parallel to p1
+     *
+     * @return the edge, if found
+     *    <code>null</code> if the edge was not found
+     */
+    Edge* findEdgeInSameDirection(const geom::Coordinate& p0,
+                                          const geom::Coordinate& p1);
+
+    std::string printEdges();
+
+    NodeMap* getNodeMap();
+
+protected:
+
+    std::vector<Edge*>* edges;
+
+    NodeMap* nodes;
+
+    std::vector<EdgeEnd*>* edgeEndList;
+
+    void insertEdge(Edge* e);
+
+private:
+
+    /** \brief
+     * The coordinate pairs match if they define line segments
+     * lying in the same direction.
+     *
+     * E.g. the segments are parallel and in the same quadrant
+     * (as opposed to parallel and opposite!).
+     */
+    bool matchInSameDirection(const geom::Coordinate& p0,
+                              const geom::Coordinate& p1,
+                              const geom::Coordinate& ep0,
+                              const geom::Coordinate& ep1);
+
+    PlanarGraph(const PlanarGraph&) = delete;
+    PlanarGraph& operator=(const PlanarGraph&) = delete;
+};
+
+
+
+} // namespace geos.geomgraph
+} // namespace geos
+

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

@@ -0,0 +1,238 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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/TopologyLocation.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Location.h>
+#include <geos/geom/Position.h>
+
+#include <vector>
+#include <array>
+#include <string>
+#include <cassert>
+#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
+
+using geos::geom::Position;
+using geos::geom::Location;
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/** \brief
+ * A TopologyLocation is the labelling of a
+ * GraphComponent's topological relationship to a single Geometry.
+ *
+ * If the parent component is an area edge, each side and the edge itself
+ * have a topological location.  These locations are named
+ *
+ *  - ON: on the edge
+ *  - LEFT: left-hand side of the edge
+ *  - RIGHT: right-hand side
+ *
+ * If the parent component is a line edge or node, there is a single
+ * topological relationship attribute, ON.
+ *
+ * The possible values of a topological location are
+ * {Location::NONE, Location::EXTERIOR, Location::BOUNDARY, Location::INTERIOR}
+ *
+ * The labelling is stored in an array location[j] where
+ * where j has the values ON, LEFT, RIGHT
+ */
+class GEOS_DLL TopologyLocation {
+
+public:
+
+    friend std::ostream& operator<< (std::ostream&, const TopologyLocation&);
+
+    TopologyLocation() = default;
+
+    /** \brief
+     * Constructs a TopologyLocation specifying how points on, to the
+     * left of, and to the right of some GraphComponent relate to some
+     * Geometry.
+     *
+     * Possible values for the
+     * parameters are Location::NONE, Location::EXTERIOR, Location::BOUNDARY,
+     * and Location::INTERIOR.
+     *
+     * @see Location
+     */
+    TopologyLocation(Location on, Location left, Location right)
+        : locationSize(3)
+    {
+        location[Position::ON] = on;
+        location[Position::LEFT] = left;
+        location[Position::RIGHT] = right;
+    }
+
+    TopologyLocation(Location on)
+        : locationSize(1)
+    {
+        location.fill(Location::NONE);
+        location[Position::ON] = on;
+    };
+
+    TopologyLocation(const TopologyLocation& gl)
+        : location(gl.location)
+        , locationSize(gl.locationSize)
+        {};
+
+    TopologyLocation& operator= (const TopologyLocation& gl)
+    {
+        location = gl.location;
+        locationSize = gl.locationSize;
+        return *this;
+    };
+
+    Location get(std::size_t posIndex) const
+    {
+        // should be an assert() instead ?
+        if(posIndex < locationSize) {
+            return location[posIndex];
+        }
+        return Location::NONE;
+    };
+
+    /**
+     * @return true if all locations are Location::NONE
+     */
+    bool isNull() const
+    {
+        for(std::size_t i = 0; i < locationSize; ++i) {
+            if(location[i] != Location::NONE) {
+                return false;
+            }
+        }
+        return true;
+    };
+
+    /**
+     * @return true if any locations is Location::NONE
+     */
+    bool isAnyNull() const
+    {
+        for(std::size_t i = 0; i < locationSize; ++i) {
+            if(location[i] == Location::NONE) {
+                return true;
+            }
+        }
+        return false;
+    };
+
+    bool isEqualOnSide(const TopologyLocation& le, uint32_t locIndex) const
+    {
+        return location[locIndex] == le.location[locIndex];
+    };
+
+    bool isArea() const
+    {
+        return locationSize > 1;
+    };
+
+    bool isLine() const
+    {
+        return locationSize == 1;
+    };
+
+    void flip()
+    {
+        if(locationSize <= 1) {
+            return;
+        }
+        std::swap(location[Position::LEFT], location[Position::RIGHT]);
+    };
+
+    void setAllLocations(Location locValue)
+    {
+        location.fill(locValue);
+    };
+
+
+    void setAllLocationsIfNull(Location locValue)
+    {
+        for(std::size_t i = 0; i < locationSize; ++i) {
+            if(location[i] == Location::NONE) {
+                location[i] = locValue;
+            }
+        }
+    };
+
+    void setLocation(std::size_t locIndex, Location locValue)
+    {
+        location[locIndex] = locValue;
+    };
+
+    void setLocation(Location locValue)
+    {
+        setLocation(Position::ON, locValue);
+    };
+
+    const std::array<Location, 3>& getLocations() const
+    {
+        return location;
+    };
+
+    void setLocations(Location on, Location left, Location right)
+    {
+        assert(locationSize >= 3);
+        location[Position::ON] = on;
+        location[Position::LEFT] = left;
+        location[Position::RIGHT] = right;
+    };
+
+    bool allPositionsEqual(Location loc) const
+    {
+        for(std::size_t i = 0; i < locationSize; ++i) {
+            if(location[i] != loc) {
+                return false;
+            }
+        }
+        return true;
+    };
+
+    /** \brief
+     * merge updates only the UNDEF attributes of this object
+     * with the attributes of another.
+     */
+    void merge(const TopologyLocation& gl);
+
+    std::string toString() const;
+
+
+private:
+
+    std::array<geom::Location, 3> location;
+    std::uint8_t locationSize;
+
+};
+
+std::ostream& operator<< (std::ostream&, const TopologyLocation&);
+
+} // namespace geos.geomgraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

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

@@ -0,0 +1,68 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geomgraph {
+class Edge;
+namespace index {
+class SegmentIntersector;
+}
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos::geomgraph
+namespace index { // geos::geomgraph::index
+
+/** \brief
+ * An EdgeSetIntersector computes all the intersections between the edges in the set.
+ *
+ * \note This is derived from a Java interface.
+ */
+class GEOS_DLL EdgeSetIntersector {
+public:
+    /** \brief
+     * Computes all self-intersections between edges in a set of edges,
+     * allowing client to choose whether self-intersections are computed.
+     *
+     * @param edges a list of edges to test for intersections
+     * @param si the SegmentIntersector to use
+     * @param testAllSegments true if self-intersections are to be tested as well
+     */
+    virtual void computeIntersections(std::vector<Edge*>* edges,
+                                      SegmentIntersector* si, bool testAllSegments) = 0;
+
+    /** \brief
+     * Computes all mutual intersections between two sets of edges
+     */
+    virtual void computeIntersections(std::vector<Edge*>* edges0,
+                                      std::vector<Edge*>* edges1,
+                                      SegmentIntersector* si) = 0;
+
+    virtual
+    ~EdgeSetIntersector() {}
+};
+
+
+} // namespace geos.geomgraph.index
+} // namespace geos.geomgraph
+} // namespace geos
+