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

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

@@ -0,0 +1,124 @@
+/**********************************************************************
+ *
+ * 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/EdgeList.java rev. 1.4 (JTS-1.10)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <vector>
+#include <unordered_map>
+#include <string>
+#include <iostream>
+
+#include <geos/noding/OrientedCoordinateArray.h> // for map comparator
+
+#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 index {
+class SpatialIndex;
+}
+namespace geomgraph {
+class Edge;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/** \brief
+ * A EdgeList is a list of Edges.
+ *
+ * It supports locating edges
+ * that are pointwise equals to a target edge.
+ */
+class GEOS_DLL EdgeList final {
+
+private:
+
+    std::vector<Edge*> edges;
+
+    struct OcaCmp {
+        bool
+        operator()(
+            const noding::OrientedCoordinateArray* oca1,
+            const noding::OrientedCoordinateArray* oca2) const
+        {
+            return *oca1 < *oca2;
+        }
+    };
+
+    /**
+     * An index of the edges, for fast lookup.
+     */
+    typedef std::unordered_map<noding::OrientedCoordinateArray,
+                               Edge*,
+                               noding::OrientedCoordinateArray::HashCode> EdgeMap;
+    EdgeMap ocaMap;
+
+public:
+    friend std::ostream& operator<< (std::ostream& os, const EdgeList& el);
+
+    EdgeList()
+        :
+        edges(),
+        ocaMap()
+    {}
+
+    ~EdgeList() = default;
+
+    /**
+     * Insert an edge unless it is already in the list
+     */
+    void add(Edge* e);
+
+    void addAll(const std::vector<Edge*>& edgeColl);
+
+    std::vector<Edge*>&
+    getEdges()
+    {
+        return edges;
+    }
+
+    Edge* findEqualEdge(const Edge* e) const;
+
+    Edge* get(std::size_t i);
+
+    int findEdgeIndex(const Edge* e) const;
+
+    std::string print();
+
+    void clearList();
+
+};
+
+std::ostream& operator<< (std::ostream& os, const EdgeList& el);
+
+
+} // namespace geos.geomgraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

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

@@ -0,0 +1,113 @@
+/**********************************************************************
+ *
+ * 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/EdgeNodingValidator.java rev. 1.6 (JTS-1.10)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <vector>
+
+#include <geos/noding/FastNodingValidator.h> // for composition
+
+#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 CoordinateSequence;
+}
+namespace noding {
+class SegmentString;
+}
+namespace geomgraph {
+class Edge;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/** \brief
+ * Validates that a collection of SegmentStrings is correctly noded.
+ *
+ * Throws an appropriate exception if an noding error is found.
+ */
+class GEOS_DLL EdgeNodingValidator final {
+
+private:
+    std::vector<noding::SegmentString*>& toSegmentStrings(std::vector<Edge*>& edges);
+
+    // Make sure this member is initialized *before*
+    // the NodingValidator, as initialization of
+    // NodingValidator will use toSegmentString(), that
+    // in turn expects this member to be initialized
+    std::vector<noding::SegmentString*> segStr;
+
+    // Make sure this member is initialized *before*
+    // the NodingValidator, as initialization of
+    // NodingValidator will use toSegmentString(), that
+    // in turn expects this member to be initialized
+    std::vector<geom::CoordinateSequence*> newCoordSeq;
+
+    noding::FastNodingValidator nv;
+
+public:
+
+    /** \brief
+     * Checks whether the supplied {@link Edge}s are correctly noded.
+     *
+     * Throws a [TopologyException](@ref util::TopologyException) if they are not.
+     *
+     * @param edges a collection of Edges.
+     * @throws TopologyException if the SegmentStrings are not
+     *         correctly noded
+     */
+    static void
+    checkValid(std::vector<Edge*>& edges)
+    {
+        EdgeNodingValidator validator(edges);
+        validator.checkValid();
+    }
+
+    EdgeNodingValidator(std::vector<Edge*>& edges)
+        :
+        segStr(),
+        newCoordSeq(),
+        nv(toSegmentStrings(edges))
+    {}
+
+    ~EdgeNodingValidator();
+
+    void
+    checkValid()
+    {
+        nv.checkValid();
+    }
+};
+
+
+} // namespace geos.geomgraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

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

@@ -0,0 +1,201 @@
+/**********************************************************************
+ *
+ * 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/EdgeRing.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geomgraph/Label.h> // for composition
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/LinearRing.h>
+
+#include <cassert> // for testInvariant
+#include <iosfwd> // for operator<<
+#include <memory>
+#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 GeometryFactory;
+class Polygon;
+class Coordinate;
+}
+namespace geomgraph {
+class DirectedEdge;
+//class Label;
+class Edge;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/** EdgeRing */
+class GEOS_DLL EdgeRing /* non-final */ {
+
+public:
+    friend std::ostream& operator<< (std::ostream& os, const EdgeRing& er);
+
+    EdgeRing(DirectedEdge* newStart,
+             const geom::GeometryFactory* newGeometryFactory);
+
+    virtual ~EdgeRing() = default;
+
+    bool isIsolated();
+
+    bool isHole();
+
+    /**
+     * Return a pointer to the LinearRing owned by
+     * this object. Make a copy if you need it beyond
+     * this objects's lifetime.
+     */
+    geom::LinearRing* getLinearRing();
+
+    Label& getLabel();
+
+    bool isShell();
+
+    EdgeRing* getShell();
+
+    void setShell(EdgeRing* newShell);
+
+    void addHole(EdgeRing* edgeRing);
+
+    /**
+     * Return a Polygon copying coordinates from this
+     * EdgeRing and its holes.
+     */
+    std::unique_ptr<geom::Polygon> toPolygon(const geom::GeometryFactory* geometryFactory);
+
+    /**
+     * Compute a LinearRing from the point list previously collected.
+     * Test if the ring is a hole (i.e. if it is CCW) and set the hole
+     * flag accordingly.
+     */
+    void computeRing();
+
+    virtual DirectedEdge* getNext(DirectedEdge* de) = 0;
+
+    virtual void setEdgeRing(DirectedEdge* de, EdgeRing* er) = 0;
+
+    /**
+     * Returns the list of DirectedEdges that make up this EdgeRing
+     */
+    std::vector<DirectedEdge*>& getEdges();
+
+    int getMaxNodeDegree();
+
+    void setInResult();
+
+    /**
+     * This method will use the computed ring.
+     * It will also check any holes, if they have been assigned.
+     */
+    bool containsPoint(const geom::Coordinate& p);
+
+    void
+    testInvariant() const
+    {
+        // pts are never NULL
+        // assert(pts);
+
+#ifndef NDEBUG
+        // If this is not an hole, check that
+        // each hole is not null and
+        // has 'this' as it's shell
+        if(! shell) {
+            for(const auto& hole : holes) {
+                assert(hole);
+                assert(hole->getShell() == this);
+            }
+        }
+#endif // ndef NDEBUG
+    }
+
+protected:
+
+    DirectedEdge* startDe; // the directed edge which starts the list of edges for this EdgeRing
+
+    const geom::GeometryFactory* geometryFactory;
+
+    /// @throws util::TopologyException
+    void computePoints(DirectedEdge* newStart);
+
+    void mergeLabel(const Label& deLabel);
+
+    /** \brief
+     * Merge the RHS label from a DirectedEdge into the label for
+     * this EdgeRing.
+     *
+     * The DirectedEdge label may be null.
+     * This is acceptable - it results from a node which is NOT
+     * an intersection node between the Geometries
+     * (e.g. the end node of a LinearRing).
+     * In this case the DirectedEdge label does not contribute any
+     * information to the overall labelling, and is
+     * simply skipped.
+     */
+    void mergeLabel(const Label& deLabel, uint8_t geomIndex);
+
+    void addPoints(Edge* edge, bool isForward, bool isFirstEdge);
+
+    /// a list of EdgeRings which are holes in this EdgeRing
+    std::vector<std::unique_ptr<EdgeRing>> holes;
+
+private:
+
+    int maxNodeDegree;
+
+    /// the DirectedEdges making up this EdgeRing
+    std::vector<DirectedEdge*> edges;
+
+    geom::CoordinateSequence pts;
+
+    // label stores the locations of each geometry on the
+    // face surrounded by this ring
+    Label label;
+
+    std::unique_ptr<geom::LinearRing> ring;  // the ring created for this EdgeRing
+
+    bool isHoleVar;
+
+    /// if non-null, the ring is a hole and this EdgeRing is its containing shell
+    EdgeRing* shell;
+
+    void computeMaxNodeDegree();
+
+};
+
+std::ostream& operator<< (std::ostream& os, const EdgeRing& er);
+
+} // namespace geos.geomgraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

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

@@ -0,0 +1,251 @@
+/**********************************************************************
+ *
+ * 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/GeometryGraph.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <map>
+#include <unordered_map>
+#include <vector>
+#include <memory>
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h> // for unique_ptr<CoordinateSequence>
+#include <geos/geomgraph/PlanarGraph.h>
+#include <geos/geomgraph/index/SegmentIntersector.h>
+#include <geos/geom/LineString.h> // for LineStringLT
+
+#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 LineString;
+class LinearRing;
+class Polygon;
+class Geometry;
+class GeometryCollection;
+class Point;
+class Envelope;
+}
+namespace algorithm {
+class LineIntersector;
+class BoundaryNodeRule;
+}
+namespace geomgraph {
+class Edge;
+class Node;
+namespace index {
+class EdgeSetIntersector;
+}
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/** \brief
+ * A GeometryGraph is a graph that models a given Geometry.
+ */
+class GEOS_DLL GeometryGraph final: public PlanarGraph {
+    using PlanarGraph::add;
+    using PlanarGraph::findEdge;
+
+private:
+
+    const geom::Geometry* parentGeom;
+
+    /**
+     * The lineEdgeMap is a map of the linestring components of the
+     * parentGeometry to the edges which are derived from them.
+     * This is used to efficiently perform findEdge queries
+     *
+     * Following the above description there's no need to
+     * compare LineStrings other then by pointer value.
+     */
+    std::unordered_map<const geom::LineString*, Edge*> lineEdgeMap;
+
+    /**
+     * If this flag is true, the Boundary Determination Rule will
+     * used when deciding whether nodes are in the boundary or not
+     */
+    bool useBoundaryDeterminationRule;
+
+    const algorithm::BoundaryNodeRule& boundaryNodeRule;
+
+    /**
+     * the index of this geometry as an argument to a spatial function
+     * (used for labelling)
+     */
+    uint8_t argIndex;
+
+    /// Cache for fast responses to getBoundaryPoints
+    std::unique_ptr< geom::CoordinateSequence > boundaryPoints;
+
+    std::unique_ptr< std::vector<Node*> > boundaryNodes;
+
+    bool hasTooFewPointsVar;
+
+    geom::Coordinate invalidPoint;
+
+    /// Allocates a new EdgeSetIntersector. Remember to delete it!
+    index::EdgeSetIntersector* createEdgeSetIntersector();
+
+    void add(const geom::Geometry* g);
+    // throw(UnsupportedOperationException);
+
+    void addCollection(const geom::GeometryCollection* gc);
+
+    void addPoint(const geom::Point* p);
+
+    void addPolygonRing(const geom::LinearRing* lr,
+                        geom::Location cwLeft, geom::Location cwRight);
+
+    void addPolygon(const geom::Polygon* p);
+
+    void addLineString(const geom::LineString* line);
+
+    void insertPoint(uint8_t p_argIndex, const geom::Coordinate& coord,
+                     geom::Location onLocation);
+
+    /** \brief
+     * Adds candidate boundary points using the current
+     * algorithm::BoundaryNodeRule.
+     *
+     * This is used to add the boundary
+     * points of dim-1 geometries (Curves/MultiCurves).
+     */
+    void insertBoundaryPoint(uint8_t p_argIndex, const geom::Coordinate& coord);
+
+    void addSelfIntersectionNodes(uint8_t p_argIndex);
+
+    /** \brief
+     * Add a node for a self-intersection.
+     *
+     * If the node is a potential boundary node (e.g. came from an edge
+     * which is a boundary) then insert it as a potential boundary node.
+     * Otherwise, just add it as a regular node.
+     */
+    void addSelfIntersectionNode(uint8_t p_argIndex,
+                                 const geom::Coordinate& coord, geom::Location loc);
+
+    // Declare type as noncopyable
+    GeometryGraph(const GeometryGraph& other) = delete;
+    GeometryGraph& operator=(const GeometryGraph& rhs) = delete;
+
+public:
+
+    static bool isInBoundary(int boundaryCount);
+
+    static geom::Location determineBoundary(int boundaryCount);
+
+    static geom::Location determineBoundary(
+        const algorithm::BoundaryNodeRule& boundaryNodeRule,
+        int boundaryCount);
+
+    GeometryGraph(uint8_t newArgIndex, const geom::Geometry* newParentGeom);
+
+    GeometryGraph(uint8_t newArgIndex, const geom::Geometry* newParentGeom,
+                  const algorithm::BoundaryNodeRule& boundaryNodeRule);
+
+    ~GeometryGraph() override {};
+
+    const geom::Geometry* getGeometry()
+    {
+        return parentGeom;
+    };
+
+    /// Returned object is owned by this GeometryGraph
+    void getBoundaryNodes(std::vector<Node*>& bdyNodes)
+    {
+        nodes->getBoundaryNodes(static_cast<uint8_t>(argIndex), bdyNodes);
+    };
+
+    std::vector<Node*>* getBoundaryNodes();
+
+    /// Returned object is owned by this GeometryGraph
+    geom::CoordinateSequence* getBoundaryPoints();
+
+    Edge* findEdge(const geom::LineString* line) const;
+
+    void computeSplitEdges(std::vector<Edge*>* edgelist);
+
+    void addEdge(Edge* e);
+
+    void addPoint(geom::Coordinate& pt);
+
+    /**
+     * \brief
+     * Compute self-nodes, taking advantage of the Geometry type to minimize
+     * the number of intersection tests. (E.g. rings are not tested for
+     * self-intersection, since they are assumed to be valid).
+     *
+     * @param li the LineIntersector to use
+     * @param computeRingSelfNodes if `false`, intersection checks are optimized
+     *                             to not test rings for self-intersection
+     * @param env an Envelope
+     *
+     * @return the SegmentIntersector used, containing information about
+     *         the intersections found
+     */
+    std::unique_ptr<index::SegmentIntersector>
+    computeSelfNodes(
+        algorithm::LineIntersector* li,
+        bool computeRingSelfNodes,
+        const geom::Envelope* env = nullptr)
+    {
+        return computeSelfNodes(*li, computeRingSelfNodes, env);
+    }
+
+    // Quick inline calling the function above, the above should probably
+    // be deprecated.
+    std::unique_ptr<index::SegmentIntersector> computeSelfNodes(
+        algorithm::LineIntersector& li,
+        bool computeRingSelfNodes, const geom::Envelope* env = nullptr);
+
+    std::unique_ptr<index::SegmentIntersector> computeEdgeIntersections(GeometryGraph* g,
+            algorithm::LineIntersector* li, bool includeProper,
+            const geom::Envelope* env = nullptr);
+
+    std::vector<Edge*>* getEdges();
+
+    bool hasTooFewPoints();
+
+    const geom::Coordinate& getInvalidPoint();
+
+    const algorithm::BoundaryNodeRule&
+    getBoundaryNodeRule() const
+    {
+        return boundaryNodeRule;
+    }
+
+};
+
+
+} // namespace geos.geomgraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif