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

package/dist/prebuilt/Android-x86_64/include/geos/operation/intersection/RectangleIntersection.h

@@ -0,0 +1,174 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2014 Mika Heiskanen <mika.heiskanen@fmi.fi>
+ *
+ * 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 <memory>
+
+#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 Point;
+class MultiPoint;
+class Polygon;
+class MultiPolygon;
+class LineString;
+class MultiLineString;
+class Geometry;
+class GeometryCollection;
+class GeometryFactory;
+}
+namespace operation {
+namespace intersection {
+class Rectangle;
+class RectangleIntersectionBuilder;
+}
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace intersection { // geos::operation::intersection
+
+/**
+ * \brief
+ * Speed-optimized clipping of a [Geometry](@ref geom::Geometry) with a rectangle.
+ *
+ * Two different methods are provided. The first performs normal
+ * clipping, the second clips the boundaries of polygons, not
+ * the polygons themselves. In the first case a polygon will remain
+ * a polygon or is completely cut out. In the latter case polygons
+ * will be converted to polylines if any vertex is outside the clipping
+ * rectangle, or will be cut out completely.
+ *
+ * The algorithm works best when the number of intersections is very low.
+ * For example, if the geometry is completely to the left of the
+ * clipping rectangle, only the x-coordinate of the geometry is ever
+ * tested and is only compared with the x-coordinate of the left edge
+ * of the rectangle. Hence clipping may be faster than calculating
+ * the envelope of the geometry for trivial overlap tests.
+ *
+ * The input geometry must be valid. In particular all [LinearRings](@ref geom::LinearRing)
+ * must be properly closed, or the algorithm may not terminate.
+ *
+ */
+class GEOS_DLL RectangleIntersection {
+public:
+
+    /**
+     * \brief Clip geometry with a rectangle.
+     *
+     * @param geom a [Geometry](@ref geom::Geometry)
+     * @param rect a Rectangle
+     * @return the clipped geometry
+     * @return `NULL` if the geometry is outside the Rectangle
+     */
+    static std::unique_ptr<geom::Geometry> clip(const geom::Geometry& geom,
+            const Rectangle& rect);
+
+    /**
+     * \brief Clip boundary of a geometry with a rectangle.
+     *
+     * Any polygon which intersects the rectangle will be converted to
+     * a polyline or a multipolyline - including the holes.
+     *
+     * @param geom a [Geometry](@ref geom::Geometry)
+     * @param rect a Rectangle
+     * @return the clipped geometry
+     * @return `NULL` if the geometry is outside the Rectangle
+     */
+    static std::unique_ptr<geom::Geometry> clipBoundary(const geom::Geometry& geom,
+            const Rectangle& rect);
+
+private:
+
+    RectangleIntersection(const geom::Geometry& geom, const Rectangle& rect);
+
+    std::unique_ptr<geom::Geometry> clipBoundary();
+
+    std::unique_ptr<geom::Geometry> clip();
+
+    const geom::Geometry& _geom;
+    const Rectangle& _rect;
+    const geom::GeometryFactory* _gf;
+
+    void clip_geom(const geom::Geometry* g,
+                   RectangleIntersectionBuilder& parts,
+                   const Rectangle& rect,
+                   bool keep_polygons);
+
+    void clip_point(const geom::Point* g,
+                    RectangleIntersectionBuilder& parts,
+                    const Rectangle& rect);
+
+    void clip_multipoint(const geom::MultiPoint* g,
+                         RectangleIntersectionBuilder& parts,
+                         const Rectangle& rect);
+
+    void clip_linestring(const geom::LineString* g,
+                         RectangleIntersectionBuilder& parts,
+                         const Rectangle& rect);
+
+    void clip_multilinestring(const geom::MultiLineString* g,
+                              RectangleIntersectionBuilder& parts,
+                              const Rectangle& rect);
+
+    void clip_polygon(const geom::Polygon* g,
+                      RectangleIntersectionBuilder& parts,
+                      const Rectangle& rect,
+                      bool keep_polygons);
+
+    void clip_multipolygon(const geom::MultiPolygon* g,
+                           RectangleIntersectionBuilder& parts,
+                           const Rectangle& rect,
+                           bool keep_polygons);
+
+    void clip_geometrycollection(
+        const geom::GeometryCollection* g,
+        RectangleIntersectionBuilder& parts,
+        const Rectangle& rect,
+        bool keep_polygons);
+
+    void clip_polygon_to_linestrings(const geom::Polygon* g,
+                                     RectangleIntersectionBuilder& parts,
+                                     const Rectangle& rect);
+
+    void clip_polygon_to_polygons(const geom::Polygon* g,
+                                  RectangleIntersectionBuilder& parts,
+                                  const Rectangle& rect);
+
+
+    /**
+     * \brief Clip geometry.
+     *
+     * Returns true if the geometry was fully inside, and does not output
+     * anything to RectangleIntersectionBuilder.
+     */
+    bool clip_linestring_parts(const geom::LineString* gi,
+                               RectangleIntersectionBuilder& parts,
+                               const Rectangle& rect);
+
+}; // class RectangleIntersection
+
+} // namespace geos::operation::intersection
+} // namespace geos::operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/intersection/RectangleIntersectionBuilder.h

@@ -0,0 +1,159 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2014 Mika Heiskanen <mika.heiskanen@fmi.fi>
+ *
+ * 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>
+
+#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
+
+#include <memory>
+#include <list>
+#include <vector>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class CoordinateSequence;
+class Geometry;
+class GeometryFactory;
+class Polygon;
+class LineString;
+class Point;
+}
+namespace operation {
+namespace intersection {
+class Rectangle;
+}
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace intersection { // geos::operation::intersection
+
+/**
+ * \brief Rebuild geometries from subpaths left by clipping with a rectangle
+ *
+ * The RectangleIntersectionBuilder is used to maintain lists of polygons,
+ * linestrings and points left from clipping a geom::Geometry with a Rectangle.
+ * Once all clipping has been done, the class builds a valid geom::Geometry from
+ * the components.
+ *
+ * @note This is a utility class needed by RectangleIntersection, and is not
+ * intended for public use.
+ */
+
+class GEOS_DLL RectangleIntersectionBuilder {
+    // Regular users are not supposed to use this utility class.
+    friend class RectangleIntersection;
+
+public:
+
+    ~RectangleIntersectionBuilder();
+
+private:
+
+    /**
+     * \brief Build the result geometry from partial results and clean up
+     */
+    std::unique_ptr<geom::Geometry> build();
+
+    /**
+     * \brief Build polygons from parts left by clipping one
+     *
+     * 1. Build exterior ring(s) from lines
+     * 2. Attach polygons as holes to the exterior ring(s)
+     */
+    void reconnectPolygons(const Rectangle& rect);
+
+    /**
+     * Reconnect disjointed parts
+     *
+     * When we clip a LinearRing we may get multiple linestrings.
+     * Often the first and last ones can be reconnected to simplify
+     * output.
+     *
+     * Sample clip with a rectangle 0,0 --> 10,10 without reconnecting:
+     *
+     *   Input:   POLYGON ((5 10,0 0,10 0,5 10))
+     *   Output:  MULTILINESTRING ((5 10,0 0),(10 0,5 10))
+     *   Desired: LINESTRING (10 0,5 10,0 0)
+     *
+     * TODO: If there is a very sharp spike from inside the rectangle
+     *       outside, and then back in, it is possible that the
+     *       intersection points at the edge are equal. In this
+     *       case we could reconnect the linestrings. The task is
+     *       the same we're already doing for the 1st/last linestrings,
+     *       we'd just do it for any adjacent pair as well.
+     */
+    void reconnect();
+
+    void reverseLines();
+
+    /**
+     * Export parts to another container
+     */
+    void release(RectangleIntersectionBuilder& parts);
+
+    // Adding Geometry components
+    void add(geom::Polygon* g);
+    void add(geom::LineString* g);
+    void add(geom::Point* g);
+
+    // Trivial methods
+    bool empty() const;
+    void clear();
+
+    // Added components
+    std::list<geom::Polygon*> polygons;
+    std::list<geom::LineString*> lines;
+    std::list<geom::Point*> points;
+
+    /**
+     * \brief Close a ring clockwise along rectangle edges
+     *
+     * Only the 4 corners and x1,y1 need to be considered. The possible
+     * cases are:
+     *
+     *    x1,y1
+     *    corner1 x1,y1
+     *    corner1 corner2 x1,y1
+     *    corner1 corner2 corner3 x1,y1
+     *    corner1 corner2 corner3 corner4 x1,y1
+     */
+    void close_boundary(
+        const Rectangle& rect,
+        geom::CoordinateSequence* ring,
+        double x1, double y1,
+        double x2, double y2);
+
+    void close_ring(const Rectangle& rect, geom::CoordinateSequence* ring);
+
+    RectangleIntersectionBuilder(const geom::GeometryFactory& f)
+        : _gf(f) {}
+
+    const geom::GeometryFactory& _gf;
+
+}; // class RectangleIntersectionBuilder
+
+} // namespace geos::operation::intersection
+} // namespace geos::operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/linemerge/EdgeString.h

@@ -0,0 +1,88 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 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: operation/linemerge/EdgeString.java r378 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#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 CoordinateSequence;
+class LineString;
+}
+namespace operation {
+namespace linemerge {
+class LineMergeDirectedEdge;
+}
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace linemerge { // geos::operation::linemerge
+
+/**
+ * \brief
+ * A sequence of LineMergeDirectedEdge forming one of the lines that will
+ * be output by the line-merging process.
+ */
+class GEOS_DLL EdgeString {
+private:
+    const geom::GeometryFactory* factory;
+    std::vector<LineMergeDirectedEdge*> directedEdges;
+    std::unique_ptr<geom::CoordinateSequence> getCoordinates() const;
+public:
+    /**
+     * \brief
+     * Constructs an EdgeString with the given factory used to
+     * convert this EdgeString to a LineString
+     */
+    EdgeString(const geom::GeometryFactory* newFactory);
+
+    ~EdgeString() = default;
+
+    /**
+    * Adds a directed edge which is known to form part of this line.
+    */
+    void add(LineMergeDirectedEdge* directedEdge);
+
+    /**
+     * Converts this EdgeString into a LineString.
+     */
+    std::unique_ptr<geom::LineString> toLineString() const;
+};
+
+} // namespace geos::operation::linemerge
+} // namespace geos::operation
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/linemerge/LineMergeDirectedEdge.h

@@ -0,0 +1,78 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 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: operation/linemerge/LineMergeDirectedEdge.java r378 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/planargraph/DirectedEdge.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+//class LineString;
+}
+namespace planargraph {
+class Node;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace linemerge { // geos::operation::linemerge
+
+/**
+ * \brief
+ * A [DirectedEdge](@ref planargraph::DirectedEdge) of a LineMergeGraph.
+ *
+ */
+class GEOS_DLL LineMergeDirectedEdge: public planargraph::DirectedEdge {
+public:
+    /** \brief
+     * Constructs a LineMergeDirectedEdge connecting the `from`
+     * node to the `to` node.
+     *
+     * @param from `from` node
+     * @param to `to` node
+     * @param directionPt specifies this DirectedEdge's direction (given by an
+     *                    imaginary line from the `from` node to
+     *                    `directionPt`)
+     * @param edgeDirection whether this DirectedEdge's direction is the same as or
+     *                      opposite to that of the parent Edge (if any)
+     */
+    LineMergeDirectedEdge(planargraph::Node* from,
+                          planargraph::Node* to,
+                          const geom::Coordinate& directionPt,
+                          bool edgeDirection);
+
+    /**  \brief
+     * Returns the directed edge that starts at this directed edge's end point, or null
+     * if there are zero or multiple directed edges starting there.
+     * @param checkDirection only consider directed edges with same direction as parent edge
+     * @return the directed edge
+     * @return `null` if there are zero or multiple directed edges starting there
+     */
+    LineMergeDirectedEdge* getNext(bool checkDirection = false);
+};
+
+} // namespace geos::operation::linemerge
+} // namespace geos::operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/linemerge/LineMergeEdge.h

@@ -0,0 +1,62 @@
+/**********************************************************************
+ *
+ * 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: operation/linemerge/LineMergeEdge.java r378 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/planargraph/Edge.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class LineString;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace linemerge { // geos::operation::linemerge
+
+/** \brief
+ * An edge of a LineMergeGraph. The <code>marked</code> field indicates
+ * whether this Edge has been logically deleted from the graph.
+ */
+class GEOS_DLL LineMergeEdge: public planargraph::Edge {
+private:
+    const geom::LineString* line;
+public:
+    /**
+     * Constructs a LineMergeEdge with vertices given by the specified
+     * LineString.
+     */
+    LineMergeEdge(const geom::LineString* newLine);
+
+    /**
+     * Returns the LineString specifying the vertices of this edge.
+     */
+    const geom::LineString* getLine() const;
+};
+
+
+} // namespace geos::operation::linemerge
+} // namespace geos::operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/linemerge/LineMergeGraph.h

@@ -0,0 +1,91 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 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: operation/linemerge/LineMergeGraph.java r378 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/planargraph/PlanarGraph.h> // for inheritance
+
+#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 LineString;
+class Coordinate;
+}
+namespace planargraph {
+class Node;
+class Edge;
+class DirectedEdge;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace linemerge { // geos::operation::linemerge
+
+/** \brief
+ * A planar graph of edges that is analyzed to sew the edges together.
+ *
+ * The <code>marked</code> flag on planargraph::Edge
+ * and planargraph::Node indicates whether they have been
+ * logically deleted from the graph.
+ */
+class GEOS_DLL LineMergeGraph: public planargraph::PlanarGraph {
+
+private:
+
+    planargraph::Node* getNode(const geom::Coordinate& coordinate);
+
+    std::vector<planargraph::Node*> newNodes;
+
+    std::vector<planargraph::Edge*> newEdges;
+
+    std::vector<planargraph::DirectedEdge*> newDirEdges;
+
+public:
+
+    /** \brief
+     * Adds an Edge, DirectedEdges, and Nodes for the given
+     * LineString representation of an edge.
+     *
+     * Empty lines or lines with all coordinates equal are not added.
+     *
+     * @param lineString the linestring to add to the graph
+     */
+    void addEdge(const geom::LineString* lineString);
+
+    ~LineMergeGraph() override;
+};
+} // namespace geos::operation::linemerge
+} // namespace geos::operation
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+