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

package/dist/prebuilt/iOS-iphoneos/include/geos/geomgraph/EdgeIntersection.h

@@ -0,0 +1,149 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2009-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/EdgeIntersection.java rev. 1.5 (JTS-1.10)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geom/Coordinate.h> // for composition and inlines
+
+#include <ostream>
+
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/** \brief
+ * Represents a point on an edge which intersects with another edge.
+ *
+ * The intersection may either be a single point, or a line segment
+ * (in which case this point is the start of the line segment)
+ * The intersection point must be precise.
+ *
+ */
+class GEOS_DLL EdgeIntersection {
+public:
+
+    // the point of intersection
+    geom::Coordinate coord;
+
+    // the edge distance of this point along the containing line segment
+    double dist;
+
+    // the index of the containing line segment in the parent edge
+    std::size_t segmentIndex;
+
+    EdgeIntersection(const geom::Coordinate& newCoord,
+                     std::size_t newSegmentIndex, double newDist)
+        :
+        coord(newCoord),
+        dist(newDist),
+        segmentIndex(newSegmentIndex)
+    {}
+
+    bool
+    isEndPoint(std::size_t maxSegmentIndex) const
+    {
+        if(segmentIndex == 0 && dist == 0.0) {
+            return true;
+        }
+        if(segmentIndex == maxSegmentIndex) {
+            return true;
+        }
+        return false;
+    }
+
+    const geom::Coordinate&
+    getCoordinate() const
+    {
+        return coord;
+    }
+
+    size_t
+    getSegmentIndex() const
+    {
+        return segmentIndex;
+    }
+
+    double
+    getDistance() const
+    {
+        return dist;
+    }
+
+    bool operator==(const EdgeIntersection& other) const {
+        return segmentIndex == other.segmentIndex &&
+            dist == other.dist;
+
+        // We don't check the coordinate, consistent with operator<
+    }
+
+};
+
+/// Strict weak ordering operator for EdgeIntersection
+///
+/// This is the C++ equivalent of JTS's compareTo
+inline bool
+operator< (const EdgeIntersection& ei1, const EdgeIntersection& ei2)
+{
+    if(ei1.segmentIndex < ei2.segmentIndex) {
+        return true;
+    }
+    if(ei1.segmentIndex == ei2.segmentIndex) {
+        if(ei1.dist < ei2.dist) {
+            return true;
+        }
+
+        // TODO: check if the Coordinate matches, or this will
+        //       be a robustness issue in computing distance
+        //       See http://trac.osgeo.org/geos/ticket/350
+    }
+    return false;
+}
+
+// @deprecated, use strict weak ordering operator
+struct GEOS_DLL  EdgeIntersectionLessThen {
+    bool
+    operator()(const EdgeIntersection* ei1,
+               const EdgeIntersection* ei2) const
+    {
+        return *ei1 < *ei2;
+    }
+
+    bool
+    operator()(const EdgeIntersection& ei1,
+               const EdgeIntersection& ei2) const
+    {
+        return ei1 < ei2;
+    }
+};
+
+/// Output operator
+inline std::ostream&
+operator<< (std::ostream& os, const EdgeIntersection& e)
+{
+    os << e.coord << " seg # = " << e.segmentIndex << " dist = " << e.dist;
+    return os;
+}
+
+} // namespace geos.geomgraph
+} // namespace geos
+

package/dist/prebuilt/iOS-iphoneos/include/geos/geomgraph/EdgeIntersectionList.h

@@ -0,0 +1,129 @@
+/**********************************************************************
+ *
+ * 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/EdgeIntersectionList.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <algorithm>
+#include <vector>
+#include <string>
+
+#include <geos/geomgraph/EdgeIntersection.h> // for EdgeIntersectionLessThen
+#include <geos/geom/Coordinate.h> // for CoordinateLessThan
+
+#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 geomgraph {
+class Edge;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+
+/** \brief
+ * A list of edge intersections along an Edge.
+ *
+ * Implements splitting an edge with intersections
+ * into multiple resultant edges.
+ */
+class GEOS_DLL EdgeIntersectionList {
+public:
+    // Instead of storing edge intersections in a set, as JTS does, we store them
+    // in a vector and then sort the vector if needed before iterating among the
+    // edges. This is much faster.
+    using container = std::vector<EdgeIntersection>;
+    using const_iterator = container::const_iterator;
+
+private:
+    mutable container nodeMap;
+    mutable bool sorted;
+
+public:
+
+    const Edge* edge;
+    EdgeIntersectionList(const Edge* edge);
+    ~EdgeIntersectionList() = default;
+
+    /*
+     * Adds an intersection into the list, if it isn't already there.
+     * The input segmentIndex and dist are expected to be normalized.
+     * @return the EdgeIntersection found or added
+     */
+    void add(const geom::Coordinate& coord, std::size_t segmentIndex, double dist);
+
+    const_iterator
+    begin() const
+    {
+        if (!sorted) {
+            std::sort(nodeMap.begin(), nodeMap.end());
+            nodeMap.erase(std::unique(nodeMap.begin(), nodeMap.end()), nodeMap.end());
+            sorted = true;
+        }
+
+        return nodeMap.begin();
+    }
+    const_iterator
+    end() const
+    {
+        return nodeMap.end();
+    }
+
+    bool isEmpty() const;
+    bool isIntersection(const geom::Coordinate& pt) const;
+
+    /*
+     * Adds entries for the first and last points of the edge to the list
+     */
+    void addEndpoints();
+
+    /**
+     * Creates new edges for all the edges that the intersections in this
+     * list split the parent edge into.
+     * Adds the edges to the input list (this is so a single list
+     * can be used to accumulate all split edges for a Geometry).
+     *
+     * @param edgeList a list of EdgeIntersections
+     */
+    void addSplitEdges(std::vector<Edge*>* edgeList);
+
+    Edge* createSplitEdge(const EdgeIntersection* ei0, const EdgeIntersection* ei1);
+    std::string print() const;
+};
+
+std::ostream& operator<< (std::ostream&, const EdgeIntersectionList&);
+
+} // namespace geos.geomgraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/iOS-iphoneos/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 {
+
+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()
+    {}
+
+    virtual ~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/iOS-iphoneos/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 {
+
+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/iOS-iphoneos/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 {
+
+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
+