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

package/dist/prebuilt/iOS-iphoneos/include/geos/geom.h

@@ -0,0 +1,146 @@
+/**********************************************************************
+ *
+ * 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
+
+/** \mainpage GEOS - Geometry Engine Open Source
+ *
+ * \section intro_sec Introduction
+ *
+ * Geometry Engine Open Source is a C++ port of the Java Topology Suite
+ * released under the LGPL license.
+ * It has interfaces for C++ and C.
+ *
+ * \section getstart_sec Getting Started
+ *
+ * The recommended low-level interface to the GEOS library
+ * is the simplified \ref c_iface. This will ensure stability of the
+ * API and the ABI of the library during performance improvements
+ * that will likely change classes definitions.
+ *
+ * If you don't care about adapting/rebuilding your client code
+ * you can still use the \ref cpp_iface.
+ */
+
+/** \page c_iface C wrapper interface
+ *
+ * \section overview_c Overview
+ *
+ * This is the preferred access method for GEOS.
+ *
+ * It is designed to keep binary compatibility across releases.
+ *
+ * \section Usage
+ *
+ * In order to use the C-API of geos you must link your code against
+ * libgeos_c.so and include the geos_c.h header file, which also contain
+ * function-level documentation.
+ *
+ */
+
+/** \page cpp_iface C++ interface
+ *
+ * \section overview_cpp Overview
+ *
+ * Main class is geos::geom::Geometry, from which all geometry types
+ * derive.
+ *
+ * Construction and destruction of Geometries is done
+ * using geos::geom::GeometryFactory.
+ *
+ * You'll feed it geos::geom::CoordinateSequence
+ * for base geometries or vectors of geometries for collections.
+ *
+ * If you need to construct geometric shaped geometries, you
+ * can use geos::geom::GeometricShapeFactory.
+ *
+ * GEOS version info (as a string) can be obtained using
+ * geos::geom::geosversion(). The JTS version this release has been
+ * ported from is available throu geos::geom::jtsport().
+ *
+ * \section io_sect Input / Output
+ *
+ * For WKT input/output you can use geos::io::WKTReader and geos::io::WKTWriter
+ *
+ * For WKB input/output you can use geos::io::WKBReader and geos::io::WKBWriter
+ *
+ * \section exc_sect Exceptions
+ *
+ * Internal exceptions are thrown as instances geos::util::GEOSException or
+ * derived classes. GEOSException derives from std::exception.
+ *
+ * Note that prior to version 3.0.0, GEOSException were thrown by
+ * pointer, and did not derive from std::exception.
+ *
+ */
+
+
+namespace geos {
+
+/// Contains the <CODE>Geometry</CODE> interface hierarchy and supporting classes.
+///
+/// The Java Topology Suite (JTS) is a Java API that implements a core
+/// set of spatial data operations using an explicit precision model
+/// and robust geometric algorithms. JTS is int ended to be used in the
+/// development of applications that support the validation, cleaning,
+/// integration and querying of spatial datasets.
+///
+/// JTS attempts to implement the OpenGIS Simple Features Specification
+/// (SFS) as accurately as possible.  In some cases the SFS is unclear
+/// or omits a specification; in this case J TS attempts to choose
+/// a reasonable and consistent alternative.  Differences from and
+/// elaborations of the SFS are documented in this specification.
+///
+/// <h2>Package Specification</h2>
+///
+/// - Java Topology Suite Technical Specifications
+/// - <A HREF="http://www.opengis.org/techno/specs.htm">
+///   OpenGIS Simple Features Specification for SQL</A>
+///
+namespace geom { // geos::geom
+
+} // namespace geos::geom
+} // namespace geos
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateFilter.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/Dimension.h>
+#include <geos/geom/Envelope.h>
+#include <geos/geom/Geometry.h>
+#include <geos/geom/GeometryCollection.h>
+#include <geos/geom/GeometryComponentFilter.h>
+#include <geos/geom/GeometryFactory.h>
+#include <geos/geom/GeometryFilter.h>
+#include <geos/geom/LineString.h>
+#include <geos/geom/LinearRing.h>
+#include <geos/geom/MultiLineString.h>
+#include <geos/geom/MultiPoint.h>
+#include <geos/geom/MultiPolygon.h>
+#include <geos/geom/Point.h>
+#include <geos/geom/Polygon.h>
+#include <geos/geom/PrecisionModel.h>
+#include <geos/geom/LineSegment.h>
+#include <geos/geom/IntersectionMatrix.h>
+#include <geos/geom/Location.h>
+//#include <geos/geom/Triangle.h>
+
+#ifdef __GNUC__
+#warning *** DEPRECATED: You are using deprecated header geom.h. Please, update your sources according to new layout of GEOS headers and namespaces
+#endif
+
+using namespace geos::geom;
+
+

package/dist/prebuilt/iOS-iphoneos/include/geos/geomgraph/Depth.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/Depth.java rev. 1.4 (JTS-1.10)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Location.h>
+#include <geos/geom/Position.h>
+#include <string>
+#include <cstdint>
+
+// Forward declarations
+namespace geos {
+namespace geomgraph {
+class Label;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/// \brief A Depth object records the topological depth of the sides of an Edge
+/// for up to two Geometries.
+class GEOS_DLL Depth {
+
+private:
+
+    static constexpr int NULL_VALUE = -1; // Replaces NULL
+
+    int depth[2][3];
+
+
+public:
+
+    static int depthAtLocation(geom::Location location)
+    {
+        if(location == geom::Location::EXTERIOR) {
+            return 0;
+        }
+        if(location == geom::Location::INTERIOR) {
+            return 1;
+        }
+        return NULL_VALUE;
+    };
+
+
+    Depth()
+    {
+        // initialize depth array to a sentinel value
+        for(std::size_t i = 0; i < 2; i++) {
+            for(std::size_t j = 0; j < 3; j++) {
+                depth[i][j] = NULL_VALUE;
+            }
+        }
+    };
+
+    virtual ~Depth() = default; // FIXME: shouldn't be virtual!
+
+    int getDepth(int geomIndex, int posIndex) const
+    {
+        return depth[geomIndex][posIndex];
+    };
+
+    void setDepth(int geomIndex, int posIndex, int depthValue)
+    {
+        depth[geomIndex][posIndex] = depthValue;
+    };
+
+    geom::Location getLocation(int geomIndex, int posIndex) const
+    {
+        if(depth[geomIndex][posIndex] <= 0) {
+            return geom::Location::EXTERIOR;
+        }
+        return geom::Location::INTERIOR;
+    };
+
+    void add(int geomIndex, int posIndex, geom::Location location)
+    {
+        if(location == geom::Location::INTERIOR) {
+            depth[geomIndex][posIndex]++;
+        }
+    };
+
+    /**
+     * A Depth object is null (has never been initialized) if all depths are null.
+     */
+    bool isNull() const
+    {
+        for(std::size_t i = 0; i < 2; i++) {
+            for(std::size_t j = 0; j < 3; j++) {
+                if(depth[i][j] != NULL_VALUE) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    };
+
+    bool isNull(uint8_t geomIndex) const
+    {
+        return depth[geomIndex][1] == NULL_VALUE;
+    };
+
+    bool isNull(uint8_t geomIndex, uint8_t posIndex) const
+    {
+        return depth[geomIndex][posIndex] == NULL_VALUE;
+    };
+
+    int getDelta(int geomIndex) const
+    {
+        return depth[geomIndex][geom::Position::RIGHT] - depth[geomIndex][geom::Position::LEFT];
+    };
+
+    void normalize();
+
+    void add(const Label& lbl);
+
+    std::string toString() const;
+
+
+};
+
+
+} // namespace geos.geomgraph
+} // namespace geos
+

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

@@ -0,0 +1,236 @@
+/**********************************************************************
+ *
+ * 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/DirectedEdge.java r428 (JTS-1.12)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <string>
+
+#include <geos/geom/Location.h>
+#include <geos/geomgraph/EdgeEnd.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace geomgraph {
+class Edge;
+class EdgeRing;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/// A directed EdgeEnd
+class GEOS_DLL DirectedEdge: public EdgeEnd {
+
+public:
+
+    /** \brief
+     * Computes the factor for the change in depth when moving from
+     * one location to another.
+     * E.g. if crossing from the INTERIOR to the EXTERIOR the depth
+     * decreases, so the factor is -1
+     */
+    static int depthFactor(geom::Location currLocation, geom::Location nextLocation);
+
+    //DirectedEdge();
+    //virtual ~DirectedEdge();
+
+    DirectedEdge(Edge* newEdge, bool newIsForward);
+
+    // this is no different from Base class, no need to override
+    //Edge* getEdge();
+
+    void setInResult(bool v)
+    {
+        isInResultVar = v;
+    };
+
+    bool isInResult() const
+    {
+        return isInResultVar;
+    };
+
+    bool isVisited() const
+    {
+        return isVisitedVar;
+    };
+
+
+    void setVisited(bool v)
+    {
+        isVisitedVar = v;
+    };
+
+    void setEdgeRing(EdgeRing* er)
+    {
+        edgeRing = er;
+    };
+
+    EdgeRing* getEdgeRing() const
+    {
+        return edgeRing;
+    };
+
+    void setMinEdgeRing(EdgeRing* mer)
+    {
+        minEdgeRing = mer;
+    };
+
+    EdgeRing* getMinEdgeRing() const
+    {
+        return minEdgeRing;
+    };
+
+    int getDepth(int position) const
+    {
+        return depth[position];
+    };
+
+    void setDepth(int position, int newDepth);
+
+    int getDepthDelta() const;
+
+    /// Marks both DirectedEdges attached to a given Edge.
+    ///
+    /// This is used for edges corresponding to lines, which will only
+    /// appear oriented in a single direction in the result.
+    ///
+    void setVisitedEdge(bool newIsVisited);
+
+    /** \brief
+     * Each Edge gives rise to a pair of symmetric DirectedEdges,
+     * in opposite directions.
+     *
+     * @return the DirectedEdge for the same Edge but in the
+     *         opposite direction
+     */
+    DirectedEdge* getSym() const
+    {
+        return sym;
+    };
+
+    bool isForward() const
+    {
+        return isForwardVar;
+    };
+
+    void setSym(DirectedEdge* de)
+    {
+        sym = de;
+    };
+
+    DirectedEdge* getNext() const
+    {
+        return next;
+    };
+
+    void setNext(DirectedEdge* newNext)
+    {
+        next = newNext;
+    };
+
+    DirectedEdge* getNextMin() const
+    {
+        return nextMin;
+    };
+
+    void setNextMin(DirectedEdge* nm)
+    {
+        nextMin = nm;
+    };
+
+    /** \brief
+     * Tells wheter this edge is a Line
+     *
+     * This edge is a line edge if
+     * - at least one of the labels is a line label
+     * - any labels which are not line labels have all Locations = EXTERIOR
+     *
+     */
+    bool isLineEdge();
+
+    /** \brief
+     * Tells wheter this edge is an Area
+     *
+     * This is an interior Area edge if
+     * - its label is an Area label for both Geometries
+     * - and for each Geometry both sides are in the interior.
+     *
+     * @return true if this is an interior Area edge
+     */
+    bool isInteriorAreaEdge();
+
+    /** \brief
+     * Set both edge depths.
+     *
+     * One depth for a given side is provided.
+     * The other is computed depending on the Location transition and the
+     * depthDelta of the edge.
+     */
+    void setEdgeDepths(int position, int newDepth);
+
+    std::string print() const override;
+
+    std::string printEdge();
+
+
+protected:
+
+    bool isForwardVar;
+
+
+private:
+
+    bool isInResultVar;
+
+    bool isVisitedVar;
+
+    /// the symmetric edge
+    DirectedEdge* sym;
+
+    /// the next edge in the edge ring for the polygon containing this edge
+    DirectedEdge* next;
+
+    /// the next edge in the MinimalEdgeRing that contains this edge
+    DirectedEdge* nextMin;
+
+    /// the EdgeRing that this edge is part of
+    EdgeRing* edgeRing;
+
+    /// the MinimalEdgeRing that this edge is part of
+    EdgeRing* minEdgeRing;
+
+    /** \brief
+     * The depth of each side (position) of this edge.
+     * The 0 element of the array is never used.
+     */
+    int depth[3];
+
+    /// Compute the label in the appropriate orientation for this DirEdge
+    void computeDirectedLabel();
+
+
+};
+
+} // namespace geos.geomgraph
+} // namespace geos
+

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

@@ -0,0 +1,163 @@
+/**********************************************************************
+ *
+ * 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/DirectedEdgeStar.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <set>
+#include <string>
+#include <vector>
+
+#include <geos/geomgraph/EdgeEndStar.h>  // for inheritance
+#include <geos/geomgraph/Label.h>  // for private member
+#include <geos/geom/Coordinate.h>  // for p0,p1
+
+
+// Forward declarations
+namespace geos {
+namespace geomgraph {
+class DirectedEdge;
+class EdgeRing;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/**
+ * \brief
+ * A DirectedEdgeStar is an ordered list of **outgoing** DirectedEdges around a node.
+ *
+ * It supports labelling the edges as well as linking the edges to form both
+ * MaximalEdgeRings and MinimalEdgeRings.
+ *
+ */
+class GEOS_DLL DirectedEdgeStar: public EdgeEndStar {
+
+public:
+
+    DirectedEdgeStar()
+        :
+        EdgeEndStar(),
+        label(),
+        resultAreaEdgesComputed(false)
+    {}
+
+    ~DirectedEdgeStar() override = default;
+
+    /// Insert a directed edge in the list
+    void insert(EdgeEnd* ee) override;
+
+    Label&
+    getLabel()
+    {
+        return label;
+    }
+
+    int getOutgoingDegree();
+
+    int getOutgoingDegree(EdgeRing* er);
+
+    DirectedEdge* getRightmostEdge();
+
+    /** \brief
+     * Compute the labelling for all dirEdges in this star, as well as the overall labelling
+     */
+    void computeLabelling(std::vector<GeometryGraph*>* geom) override; // throw(TopologyException *);
+
+    /** \brief
+     * For each dirEdge in the star, merge the label from the sym dirEdge into the label
+     */
+    void mergeSymLabels();
+
+    /// \brief Update incomplete dirEdge labels from the labelling for the node
+    void updateLabelling(const Label& nodeLabel);
+
+
+    /** \brief
+     * Traverse the star of DirectedEdges, linking the included edges together.
+     *
+     * To link two dirEdges, the `next` pointer for an incoming dirEdge
+     * is set to the next outgoing edge.
+     *
+     * DirEdges are only linked if:
+     *
+     * - they belong to an area (i.e. they have sides)
+     * - they are marked as being in the result
+     *
+     * Edges are linked in CCW order (the order they are stored). This means
+     * that rings have their face on the Right (in other words, the topological
+     * location of the face is given by the RHS label of the DirectedEdge)
+     *
+     * PRECONDITION: No pair of dirEdges are both marked as being in the result
+     */
+    void linkResultDirectedEdges(); // throw(TopologyException *);
+
+    void linkMinimalDirectedEdges(EdgeRing* er);
+
+    void linkAllDirectedEdges();
+
+    /** \brief
+     * Traverse the star of edges, maintaing the current location in the result
+     * area at this node (if any).
+     *
+     * If any L edges are found in the interior of the result, mark them as covered.
+     */
+    void findCoveredLineEdges();
+
+    /** \brief
+     * Compute the DirectedEdge depths for a subsequence of the edge array.
+     */
+    void computeDepths(DirectedEdge* de);
+
+    std::string print() const override;
+
+private:
+
+    /**
+     * A list of all outgoing edges in the result, in CCW order
+     */
+    std::vector<DirectedEdge*> resultAreaEdgeList;
+
+    Label label;
+
+    bool resultAreaEdgesComputed;
+
+    /// \brief
+    /// Returned vector is owned by DirectedEdgeStar object, but
+    /// lazily created
+    const std::vector<DirectedEdge*>& getResultAreaEdges();
+
+
+    /// States for linResultDirectedEdges
+    enum {
+        SCANNING_FOR_INCOMING = 1,
+        LINKING_TO_OUTGOING
+    };
+
+    int computeDepths(EdgeEndStar::iterator startIt,
+                      EdgeEndStar::iterator endIt, int startDepth);
+};
+
+
+} // namespace geos.geomgraph
+} // namespace geos
+