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

package/dist/prebuilt/Android-x86_64/include/geos/operation/predicate/SegmentIntersectionTester.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.
+ *
+ * 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/predicate/SegmentIntersectionTester.java r378 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/algorithm/LineIntersector.h> // for composition
+#include <geos/geom/Coordinate.h> // for composition
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class LineString;
+class CoordinateSequence;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace predicate { // geos::operation::predicate
+
+/** \brief
+ * Tests if any line segments in two sets of CoordinateSequences intersect.
+ *
+ * The algorithm is optimized for use when the first input has smaller extent
+ * than the set of test lines.
+ * The code is short-circuited to return as soon an intersection is found.
+ *
+ */
+class GEOS_DLL SegmentIntersectionTester {
+
+private:
+
+    /// \brief
+    /// For purposes of intersection testing,
+    /// don't need to set precision model
+    ///
+    algorithm::LineIntersector li; // Robust
+
+    bool hasIntersectionVar;
+
+public:
+
+    SegmentIntersectionTester(): hasIntersectionVar(false) {}
+
+    bool hasIntersectionWithLineStrings(const geom::LineString& line,
+                                        const std::vector<const geom::LineString*>& lines);
+
+    bool hasIntersection(const geom::LineString& line,
+                         const geom::LineString& testLine);
+
+    /**
+     * Tests the segments of a LineString against the segs in
+     * another LineString for intersection.
+     * Uses the envelope of the query LineString
+     * to filter before testing segments directly.
+     * This is optimized for the case when the query
+     * LineString is a rectangle.
+     *
+     * Testing shows this is somewhat faster than not checking the envelope.
+     *
+     * @param line
+     * @param testLine
+     * @return
+     */
+    bool hasIntersectionWithEnvelopeFilter(const geom::LineString& line,
+                                           const geom::LineString& testLine);
+
+
+};
+
+} // namespace geos::operation::predicate
+} // namespace geos::operation
+} // namespace geos

package/dist/prebuilt/Android-x86_64/include/geos/operation/relate/EdgeEndBuilder.h

@@ -0,0 +1,70 @@
+/**********************************************************************
+ *
+ * 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/relate/EdgeEndBuilder.java rev. 1.12 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <memory>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class IntersectionMatrix;
+class Coordinate;
+}
+namespace geomgraph {
+class Edge;
+class EdgeIntersection;
+class EdgeEnd;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace relate { // geos::operation::relate
+
+/** \brief
+ * Computes the geomgraph::EdgeEnd objects which arise
+ * from a noded geomgraph::Edge.
+ */
+class GEOS_DLL EdgeEndBuilder {
+public:
+    EdgeEndBuilder() {}
+
+    std::vector<std::unique_ptr<geomgraph::EdgeEnd>> computeEdgeEnds(std::vector<geomgraph::Edge*>* edges);
+    void computeEdgeEnds(geomgraph::Edge* edge, std::vector<std::unique_ptr<geomgraph::EdgeEnd>>& l);
+
+protected:
+
+    void createEdgeEndForPrev(geomgraph::Edge* edge,
+                              std::vector<std::unique_ptr<geomgraph::EdgeEnd>>& l,
+                              const geomgraph::EdgeIntersection* eiCurr,
+                              const geomgraph::EdgeIntersection* eiPrev);
+
+    void createEdgeEndForNext(geomgraph::Edge* edge,
+                              std::vector<std::unique_ptr<geomgraph::EdgeEnd>>& l,
+                              const geomgraph::EdgeIntersection* eiCurr,
+                              const geomgraph::EdgeIntersection* eiNext);
+};
+
+} // namespace geos:operation:relate
+} // namespace geos:operation
+} // namespace geos

package/dist/prebuilt/Android-x86_64/include/geos/operation/relate/EdgeEndBundle.h

@@ -0,0 +1,104 @@
+/**********************************************************************
+ *
+ * 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/relate/EdgeEndBundle.java rev. 1.17 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geomgraph/EdgeEnd.h> // for EdgeEndBundle inheritance
+
+#include <string>
+
+// Forward declarations
+namespace geos {
+namespace algorithm {
+class BoundaryNodeRule;
+}
+namespace geom {
+class IntersectionMatrix;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace relate { // geos::operation::relate
+
+/** \brief
+ * A collection of geomgraph::EdgeEnd objects which
+ * originate at the same point and have the same direction.
+ */
+class GEOS_DLL EdgeEndBundle: public geomgraph::EdgeEnd {
+public:
+    EdgeEndBundle(geomgraph::EdgeEnd* e);
+    ~EdgeEndBundle() override;
+    const std::vector<geomgraph::EdgeEnd*>& getEdgeEnds();
+    void insert(geomgraph::EdgeEnd* e);
+
+    void computeLabel(const algorithm::BoundaryNodeRule& bnr) override;
+
+    /**
+     * \brief
+     * Update the IM with the contribution for the computed label for
+     * the EdgeStubs.
+     */
+    void updateIM(geom::IntersectionMatrix& im);
+
+    std::string print() const override;
+protected:
+    std::vector<geomgraph::EdgeEnd*> edgeEnds;
+
+    /**
+     * Compute the overall ON location for the list of EdgeStubs.
+     *
+     * (This is essentially equivalent to computing the self-overlay of
+     * a single Geometry)
+     *
+     * edgeStubs can be either on the boundary (eg Polygon edge)
+     * OR in the interior (e.g. segment of a LineString)
+     * of their parent Geometry.
+     *
+     * In addition, GeometryCollections use a algorithm::BoundaryNodeRule
+     * to determine whether a segment is on the boundary or not.
+     *
+     * Finally, in GeometryCollections it can occur that an edge
+     * is both
+     * on the boundary and in the interior (e.g. a LineString segment
+     * lying on
+     * top of a Polygon edge.) In this case the Boundary is
+     * given precedence.
+     *
+     * These observations result in the following rules for computing
+     * the ON location:
+     *  - if there are an odd number of Bdy edges, the attribute is Bdy
+     *  - if there are an even number >= 2 of Bdy edges, the attribute
+     *    is Int
+     *  - if there are any Int edges, the attribute is Int
+     *  - otherwise, the attribute is NULL.
+     *
+     */
+    void computeLabelOn(uint8_t geomIndex,
+                        const algorithm::BoundaryNodeRule& boundaryNodeRule);
+
+    void computeLabelSides(uint8_t geomIndex);
+    void computeLabelSide(uint8_t geomIndex, uint32_t side);
+};
+
+} // namespace geos:operation:relate
+} // namespace geos:operation
+} // namespace geos

package/dist/prebuilt/Android-x86_64/include/geos/operation/relate/EdgeEndBundleStar.h

@@ -0,0 +1,65 @@
+/**********************************************************************
+ *
+ * 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/relate/EdgeEndBundleStar.java rev. 1.13 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geomgraph/EdgeEndStar.h> // for EdgeEndBundleStar inheritance
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class IntersectionMatrix;
+}
+namespace geomgraph {
+class EdgeEnd;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace relate { // geos::operation::relate
+
+/** \brief
+ * An ordered list of EdgeEndBundle objects around a RelateNode.
+ *
+ * They are maintained in CCW order (starting with the positive x-axis)
+ * around the node
+ * for efficient lookup and topology building.
+ */
+class GEOS_DLL EdgeEndBundleStar: public geomgraph::EdgeEndStar {
+public:
+
+    /// Creates a new empty EdgeEndBundleStar
+    EdgeEndBundleStar() {}
+
+    ~EdgeEndBundleStar() override;
+    void insert(geomgraph::EdgeEnd* e) override;
+
+    /**
+     * Update the IM with the contribution for the EdgeStubs around the node.
+     */
+    void updateIM(geom::IntersectionMatrix& im);
+};
+
+
+} // namespace geos:operation:relate
+} // namespace geos:operation
+} // namespace geos

package/dist/prebuilt/Android-x86_64/include/geos/operation/relate/RelateComputer.h

@@ -0,0 +1,185 @@
+/**********************************************************************
+ *
+ * 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/relate/RelateComputer.java rev. 1.24 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/algorithm/PointLocator.h> // for RelateComputer composition
+#include <geos/algorithm/LineIntersector.h> // for RelateComputer composition
+#include <geos/geomgraph/NodeMap.h> // for RelateComputer composition
+#include <geos/geom/Coordinate.h> // for RelateComputer composition
+#include <geos/geom/IntersectionMatrix.h>
+
+#include <vector>
+#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 algorithm {
+class BoundaryNodeRule;
+}
+namespace geom {
+class Geometry;
+}
+namespace geomgraph {
+class GeometryGraph;
+class Edge;
+class EdgeEnd;
+class Node;
+namespace index {
+class SegmentIntersector;
+}
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace relate { // geos::operation::relate
+
+/** \brief
+ * Computes the topological relationship between two Geometries.
+ *
+ * RelateComputer does not need to build a complete graph structure to compute
+ * the IntersectionMatrix.  The relationship between the geometries can
+ * be computed by simply examining the labelling of edges incident on each node.
+ *
+ * RelateComputer does not currently support arbitrary GeometryCollections.
+ * This is because GeometryCollections can contain overlapping Polygons.
+ * In order to correct compute relate on overlapping Polygons, they
+ * would first need to be noded and merged (if not explicitly, at least
+ * implicitly).
+ *
+ */
+class GEOS_DLL RelateComputer {
+public:
+    RelateComputer(std::vector<std::unique_ptr<geomgraph::GeometryGraph>>& newArg);
+    ~RelateComputer() = default;
+
+    std::unique_ptr<geom::IntersectionMatrix> computeIM();
+private:
+
+    algorithm::LineIntersector li;
+
+    algorithm::PointLocator ptLocator;
+
+    /// the arg(s) of the operation
+    const std::vector<std::unique_ptr<geomgraph::GeometryGraph>>& arg;
+
+    geomgraph::NodeMap nodes;
+
+    /// this intersection matrix will hold the results compute for the relate
+    std::unique_ptr<geom::IntersectionMatrix> im;
+
+    std::vector<geomgraph::Edge*> isolatedEdges;
+
+    /// the intersection point found (if any)
+    geom::Coordinate invalidPoint;
+
+    void insertEdgeEnds(std::vector<std::unique_ptr<geomgraph::EdgeEnd>>& ee);
+
+    void computeProperIntersectionIM(
+        geomgraph::index::SegmentIntersector* intersector,
+        geom::IntersectionMatrix* imX);
+
+    void copyNodesAndLabels(uint8_t argIndex);
+    void computeIntersectionNodes(uint8_t argIndex);
+    void labelIntersectionNodes(uint8_t argIndex);
+
+    /**
+     * If the Geometries are disjoint, we need to enter their dimension and
+     * boundary dimension in the Ext rows in the IM
+     */
+    void computeDisjointIM(geom::IntersectionMatrix* imX,
+                           const algorithm::BoundaryNodeRule& boundaryNodeRule);
+
+    void labelNodeEdges();
+
+    /**
+     * update the IM with the sum of the IMs for each component
+     */
+    void updateIM(geom::IntersectionMatrix& imX);
+
+    /**
+     * Compute the IM entry for the intersection of the boundary
+     * of a geometry with the Exterior.
+     * This is the nominal dimension of the boundary
+     * unless the boundary is empty, in which case it is {@link Dimension#FALSE}.
+     * For linear geometries the Boundary Node Rule determines
+     * whether the boundary is empty.
+     *
+     * @param geom the geometry providing the boundary
+     * @param boundaryNodeRule  the Boundary Node Rule to use
+     * @return the IM dimension entry
+     */
+    static int getBoundaryDim(const geom::Geometry& geom,
+                              const algorithm::BoundaryNodeRule& boundaryNodeRule);
+
+    /**
+     * Processes isolated edges by computing their labelling and adding them
+     * to the isolated edges list.
+     * Isolated edges are guaranteed not to touch the boundary of the target
+     * (since if they
+     * did, they would have caused an intersection to be computed and hence would
+     * not be isolated)
+     */
+    void labelIsolatedEdges(uint8_t thisIndex, uint8_t targetIndex);
+
+    /**
+     * Label an isolated edge of a graph with its relationship to the target
+     * geometry.
+     * If the target has dim 2 or 1, the edge can either be in the interior
+     * or the exterior.
+     * If the target has dim 0, the edge must be in the exterior
+     */
+    void labelIsolatedEdge(geomgraph::Edge* e, uint8_t targetIndex,
+                           const geom::Geometry* target);
+
+    /**
+     * Isolated nodes are nodes whose labels are incomplete
+     * (e.g. the location for one Geometry is null).
+     * This is the case because nodes in one graph which don't intersect
+     * nodes in the other are not completely labelled by the initial process
+     * of adding nodes to the nodeList.
+     * To complete the labelling we need to check for nodes that lie in the
+     * interior of edges, and in the interior of areas.
+     */
+    void labelIsolatedNodes();
+
+    /**
+     * Label an isolated node with its relationship to the target geometry.
+     */
+    void labelIsolatedNode(geomgraph::Node* n, uint8_t targetIndex);
+};
+
+
+} // namespace geos:operation:relate
+} // namespace geos:operation
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

package/dist/prebuilt/Android-x86_64/include/geos/operation/relate/RelateNode.h

@@ -0,0 +1,67 @@
+/**********************************************************************
+ *
+ * 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/relate/RelateNode.java rev. 1.11 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geomgraph/Node.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class IntersectionMatrix;
+class Coordinate;
+}
+namespace geomgraph {
+class EdgeEndStar;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace relate { // geos::operation::relate
+
+/** \brief
+ * Represents a node in the topological graph used to compute spatial
+ * relationships.
+ */
+class GEOS_DLL RelateNode final: public geomgraph::Node {
+
+public:
+
+    RelateNode(const geom::Coordinate& coord, geomgraph::EdgeEndStar* edges);
+
+    ~RelateNode() override = default;
+
+    /**
+     * Update the IM with the contribution for the EdgeEnds incident on this node.
+     */
+    void updateIMFromEdges(geom::IntersectionMatrix& im);
+
+protected:
+
+    void computeIM(geom::IntersectionMatrix& im) override;
+};
+
+
+} // namespace geos:operation:relate
+} // namespace geos:operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/relate/RelateNodeFactory.h

@@ -0,0 +1,55 @@
+/**********************************************************************
+ *
+ * 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/relate/RelateNodeFactory.java rev. 1.11 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geomgraph/NodeFactory.h> // for RelateNodeFactory inheritance
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+namespace geomgraph {
+class Node;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace relate { // geos::operation::relate
+
+/** \brief
+ * Used by the geomgraph::NodeMap in a RelateNodeGraph to create RelateNode objects.
+ */
+class GEOS_DLL RelateNodeFactory: public geomgraph::NodeFactory {
+public:
+    geomgraph::Node* createNode(const geom::Coordinate& coord) const override;
+    static const geomgraph::NodeFactory& instance();
+private:
+    RelateNodeFactory() {}
+};
+
+
+} // namespace geos:operation:relate
+} // namespace geos:operation
+} // namespace geos
+