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

package/dist/prebuilt/Android-x86_64/include/geos/operation/valid/IndexedNestedPolygonTester.h

@@ -0,0 +1,111 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021 Paul Ramsey <pramsey@cleverelephant.ca>
+ * Copyright (C) 2021 Martin Davis
+ *
+ * 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 <geos/index/strtree/TemplateSTRtree.h>
+#include <geos/algorithm/locate/IndexedPointInAreaLocator.h>
+
+#include <memory>
+#include <map>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class Polygon;
+class LinearRing;
+class MultiPolygon;
+}
+}
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace valid {     // geos.operation.valid
+
+using geos::geom::Polygon;
+using geos::geom::MultiPolygon;
+using geos::geom::LinearRing;
+using geos::geom::CoordinateXY;
+using algorithm::locate::IndexedPointInAreaLocator;
+using index::strtree::TemplateSTRtree;
+
+class GEOS_DLL IndexedNestedPolygonTester {
+
+private:
+
+    const MultiPolygon* multiPoly;
+    TemplateSTRtree<const Polygon*> index;
+    // std::vector<IndexedPointInAreaLocator> locators;
+    std::map<const Polygon*, IndexedPointInAreaLocator> locators;
+    CoordinateXY nestedPt;
+
+    void loadIndex();
+
+    IndexedPointInAreaLocator& getLocator(const Polygon* poly);
+
+    bool findNestedPoint(const LinearRing* shell,
+        const Polygon* possibleOuterPoly,
+        IndexedPointInAreaLocator& locator,
+        CoordinateXY& coordNested);
+
+    /**
+    * Finds a point of a shell segment which lies inside a polygon, if any.
+    * The shell is assume to touch the polyon only at shell vertices,
+    * and does not cross the polygon.
+    *
+    * @param the shell to test
+    * @param the polygon to test against
+    * @param coordNested return parameter for found coordinate
+    * @return an interior segment point, or null if the shell is nested correctly
+    */
+    static bool findIncidentSegmentNestedPoint(
+        const LinearRing* shell,
+        const Polygon* poly,
+        CoordinateXY& coordNested);
+
+    // Declare type as noncopyable
+    IndexedNestedPolygonTester(const IndexedNestedPolygonTester& other) = delete;
+    IndexedNestedPolygonTester& operator=(const IndexedNestedPolygonTester& rhs) = delete;
+
+public:
+
+    IndexedNestedPolygonTester(const MultiPolygon* p_multiPoly);
+
+    /**
+    * Gets a point on a nested polygon, if one exists.
+    *
+    * @return a point on a nested polygon, or null if none are nested
+    */
+    const CoordinateXY& getNestedPoint() const { return nestedPt; }
+
+    /**
+    * Tests if any polygon is nested (contained) within another polygon.
+    * This is invalid.
+    * The nested point will be set to reflect this.
+    * @return true if some polygon is nested
+    */
+    bool isNested();
+
+
+};
+
+
+
+} // namespace geos.operation.valid
+} // namespace geos.operation
+} // namespace geos

package/dist/prebuilt/Android-x86_64/include/geos/operation/valid/IsSimpleOp.h

@@ -0,0 +1,299 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ * Copyright (C) 2009 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2021 Paul Ramsey <pramsey@cleverelephant.ca>
+ *
+ * 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 <memory>
+
+#include <geos/algorithm/LineIntersector.h>
+#include <geos/algorithm/BoundaryNodeRule.h>
+#include <geos/noding/SegmentIntersector.h>
+
+// Forward declarations
+namespace geos {
+namespace noding {
+class SegmentString;
+class BasicSegmentString;
+}
+// namespace algorithm {
+// class BoundaryNodeRule;
+// }
+namespace geom {
+class LineString;
+class LinearRing;
+class MultiLineString;
+class MultiPoint;
+class Geometry;
+class Polygon;
+class GeometryCollection;
+}
+}
+
+
+namespace geos {      // geos
+namespace operation { // geos.operation
+namespace valid {     // geos.operation.valid
+
+/**
+ * Tests whether a Geometry is simple as defined by the OGC SFS specification.
+ *
+ * Simplicity is defined for each geom::Geometry type as follows:
+ *
+ *   * geom::Point geometries are simple.
+ *   * geom::MultiPoint geometries are simple if every point is unique
+ *   * geom::LineString geometries are simple if they do not self-intersect at interior points
+ *     (i.e. points other than the endpoints).
+ *   * geom::MultiLineString geometries are simple if
+ *     their elements are simple and they intersect only at points
+ *     which are boundary points of both elements.
+ *     (The notion of boundary points can be user-specified - see below).
+ *   * Polygonal geometries have no definition of simplicity.
+ *     The isSimple code checks if all polygon rings are simple.
+ *     (Note: this means that isSimple cannot be used to test
+ *     for ALL self-intersections in Polygons.
+ *     In order to check if a Polygonal geometry has self-intersections,
+ *     use geom::Geometry::isValid()).
+ *   * geom::GeometryCollection geometries are simple if all their elements are simple.
+ *   * Empty geometries are simple
+ *
+ * For linear geometries the evaluation of simplicity
+ * can be customized by supplying a BoundaryNodeRule
+ * to define how boundary points are determined.
+ * The default is the SFS-standard.
+ *
+ * Note that under the Mod-2 rule, closed LineStrings (rings)
+ * have no boundary.
+ * This means that an intersection at their endpoints makes the geometry non-simple.
+ * If it is required to test whether a set of LineStrings touch
+ * only at their endpoints, use BoundaryNodeRule::getBoundaryEndPoint().
+ * For example, this can be used to validate that a collection of lines
+ * form a topologically valid linear network.
+ *
+ * By default this class finds a single non-simple location.
+ * To find all non-simple locations, set setFindAllLocations(bool)
+ * before calling isSimple(), and retrieve the locations
+ * via getNonSimpleLocations().
+ * This can be used to find all intersection points in a linear network.
+ *
+ * @see BoundaryNodeRule
+ */
+class GEOS_DLL IsSimpleOp {
+
+private:
+
+    const geom::Geometry& inputGeom;
+    bool isClosedEndpointsInInterior = true;
+    bool isFindAllLocations = false;
+    bool isSimpleResult = false;
+    std::vector<geom::CoordinateXY> nonSimplePts;
+    bool computed = false;
+
+    void compute();
+
+    bool computeSimple(const geom::Geometry& geom);
+
+    bool isSimpleMultiPoint(const geom::MultiPoint& mp);
+
+    /**
+    * Computes simplicity for polygonal geometries.
+    * Polygonal geometries are simple if and only if
+    * all of their component rings are simple.
+    *
+    * @param geom a Polygonal geometry
+    * @return true if the geometry is simple
+    */
+    bool isSimplePolygonal(const geom::Geometry& geom);
+
+    /**
+    * Semantics for GeometryCollection is
+    * simple iff all components are simple.
+    *
+    * @param geom
+    * @return true if the geometry is simple
+    */
+    bool isSimpleGeometryCollection(const geom::Geometry& geom);
+
+    bool isSimpleLinearGeometry(const geom::Geometry& geom);
+
+    static std::vector<std::unique_ptr<geos::geom::CoordinateSequence>>
+        removeRepeatedPts(const geom::Geometry& geom);
+
+    static std::vector<std::unique_ptr<noding::SegmentString>>
+        createSegmentStrings(std::vector<std::unique_ptr<geos::geom::CoordinateSequence>>& seqs);
+
+    class NonSimpleIntersectionFinder : public noding::SegmentIntersector
+    {
+
+    private:
+
+        bool isClosedEndpointsInInterior;
+        bool isFindAll = false;
+
+        std::vector<geom::CoordinateXY>& intersectionPts;
+        algorithm::LineIntersector li;
+
+        // bool hasInteriorInt;
+        // bool hasInteriorVertexInt;
+        // bool hasEqualSegments;
+        // bool hasInteriorEndpointInt;
+
+        bool findIntersection(
+            noding::SegmentString* ss0, std::size_t segIndex0,
+            noding::SegmentString* ss1, std::size_t segIndex1,
+            const geom::CoordinateXY& p00, const geom::CoordinateXY& p01,
+            const geom::CoordinateXY& p10, const geom::CoordinateXY& p11);
+
+        /**
+        * Tests whether an intersection vertex is an endpoint of a segment string.
+        *
+        * @param ss the segmentString
+        * @param ssIndex index of segment in segmentString
+        * @param li the line intersector
+        * @param liSegmentIndex index of segment in intersector
+        * @return true if the intersection vertex is an endpoint
+        */
+        bool isIntersectionEndpoint(
+            const noding::SegmentString* ss, std::size_t ssIndex,
+            const algorithm::LineIntersector& li, std::size_t liSegmentIndex) const;
+
+        /**
+        * Finds the vertex index in a segment of an intersection
+        * which is known to be a vertex.
+        *
+        * @param li the line intersector
+        * @param segmentIndex the intersection segment index
+        * @return the vertex index (0 or 1) in the segment vertex of the intersection point
+        */
+        std::size_t intersectionVertexIndex(
+            const algorithm::LineIntersector& li, std::size_t segmentIndex) const;
+
+    public:
+
+        NonSimpleIntersectionFinder(
+            bool p_isClosedEndpointsInInterior,
+            bool p_isFindAll,
+            std::vector<geom::CoordinateXY>& p_intersectionPts)
+        : isClosedEndpointsInInterior(p_isClosedEndpointsInInterior)
+        , isFindAll(p_isFindAll)
+        , intersectionPts(p_intersectionPts)
+        {};
+
+        /**
+        * Tests whether an intersection was found.
+        *
+        * @return true if an intersection was found
+        */
+        bool hasIntersection() const;
+
+        void processIntersections(
+            noding::SegmentString* ss0, std::size_t segIndex0,
+            noding::SegmentString* ss1, std::size_t segIndex1) override;
+
+        bool isDone() const override;
+
+    }; // NonSimpleIntersectionFinder
+
+
+public:
+
+    IsSimpleOp(const geom::Geometry* geom)
+        : IsSimpleOp(*geom)
+        {};
+
+    /**
+    * Creates a simplicity checker using the default SFS Mod-2 Boundary Node Rule
+    *
+    * @param geom the geometry to test
+    */
+    IsSimpleOp(const geom::Geometry& geom)
+        : IsSimpleOp(geom, algorithm::BoundaryNodeRule::getBoundaryRuleMod2())
+        {};
+
+    /**
+    * Creates a simplicity checker using a given {@link algorithm::BoundaryNodeRule}
+    *
+    * @param geom the geometry to test
+    * @param p_boundaryNodeRule the boundary node rule to use.
+    */
+    IsSimpleOp(const geom::Geometry& geom, const algorithm::BoundaryNodeRule& p_boundaryNodeRule)
+        : inputGeom(geom)
+        , isClosedEndpointsInInterior(! p_boundaryNodeRule.isInBoundary(2))
+        , isFindAllLocations(false)
+        , computed(false)
+        {};
+
+    /**
+    * Tests whether a geometry is simple.
+    *
+    * @param geom the geometry to test
+    * @return true if the geometry is simple
+    */
+    static bool isSimple(const geom::Geometry& geom);
+
+    static bool isSimple(const geom::Geometry* geom) {
+        if (!geom) return false;
+        return isSimple(*geom);
+    }
+
+    /**
+    * Gets a non-simple location in a geometry, if any.
+    *
+    * @param geom the input geometry
+    * @return a non-simple location, or null if the geometry is simple
+    */
+    geom::CoordinateXY getNonSimpleLocation(const geom::Geometry& geom);
+
+    /**
+    * Sets whether all non-simple intersection points
+    * will be found.
+    *
+    * @param isFindAll whether to find all non-simple points
+    */
+    void setFindAllLocations(bool isFindAll);
+
+    /**
+    * Tests whether the geometry is simple.
+    *
+    * @return true if the geometry is simple
+    */
+    bool isSimple();
+
+    /**
+    * Gets the coordinate for an location where the geometry
+    * fails to be simple.
+    * (i.e. where it has a non-boundary self-intersection).
+    *
+    * @return a coordinate for the location of the non-boundary self-intersection
+    * or null if the geometry is simple
+    */
+    geom::CoordinateXY getNonSimpleLocation();
+
+    /**
+    * Gets all non-simple intersection locations.
+    *
+    * @return a list of the coordinates of non-simple locations
+    */
+    const std::vector<geom::CoordinateXY>& getNonSimpleLocations();
+
+
+
+}; // IsSimpleOp
+
+
+} // namespace geos.operation.valid
+} // namespace geos.operation
+} // namespace geos

package/dist/prebuilt/Android-x86_64/include/geos/operation/valid/IsValidOp.h

@@ -0,0 +1,307 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021 Paul Ramsey <pramsey@cleverelephant.ca>
+ * Copyright (C) 2021 Martin Davis
+ *
+ * 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 <geos/operation/valid/PolygonTopologyAnalyzer.h>
+#include <geos/operation/valid/TopologyValidationError.h>
+#include <geos/util.h>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class CoordinateXY;
+class Geometry;
+class Point;
+class MultiPoint;
+class LineString;
+class LinearRing;
+class Polygon;
+class MultiPolygon;
+class GeometryCollection;
+}
+namespace algorithm {
+namespace locate {
+class IndexedPointInAreaLocator;
+}
+}
+}
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace valid {     // geos.operation.valid
+
+/**
+ * Implements the algorithms required to compute the <code>isValid()</code> method
+ * for Geometry.
+ * See the documentation for the various geometry types for a specification of validity.
+ *
+ * @version 1.7
+ */
+class GEOS_DLL IsValidOp {
+
+private:
+
+    static constexpr int MIN_SIZE_LINESTRING = 2;
+    static constexpr int MIN_SIZE_RING = 4;
+
+    /**
+    * The geometry being validated
+    */
+    const geom::Geometry* inputGeometry;
+    /**
+    * If the following condition is true GEOS will validate
+    * inverted shells and exverted holes (the ESRI SDE model)
+    */
+    bool isInvertedRingValid = false;
+    std::unique_ptr<TopologyValidationError> validErr;
+
+    bool hasInvalidError()
+    {
+        return validErr != nullptr;
+    }
+
+    void logInvalid(int code, const geom::CoordinateXY& pt);
+
+    bool isValidGeometry(const geom::Geometry* g);
+
+    /**
+     * Tests validity of a Point.
+     */
+    bool isValid(const geom::Point* g);
+
+    /**
+     * Tests validity of a MultiPoint.
+     */
+    bool isValid(const geom::MultiPoint* g);
+
+    /**
+     * Tests validity of a LineString.
+     * Almost anything goes for linestrings!
+     */
+    bool isValid(const geom::LineString* g);
+
+    /**
+     * Tests validity of a LinearRing.
+     */
+    bool isValid(const geom::LinearRing* g);
+
+    /**
+     * Tests the validity of a polygon.
+     * Sets the validErr flag.
+     */
+    bool isValid(const geom::Polygon* g);
+
+    /**
+     * Tests validity of a MultiPolygon.
+     *
+     * @param g
+     * @return
+     */
+    bool isValid(const geom::MultiPolygon* g);
+
+    /**
+     * Tests validity of a GeometryCollection.
+     *
+     * @param gc
+     * @return
+     */
+    bool isValid(const geom::GeometryCollection* gc);
+
+    void checkCoordinatesValid(const geom::CoordinateSequence* coords);
+    void checkCoordinatesValid(const geom::Polygon* poly);
+    void checkRingClosed(const geom::LinearRing* ring);
+    void checkRingsClosed(const geom::Polygon* poly);
+    void checkRingsPointSize(const geom::Polygon* poly);
+    void checkRingPointSize(const geom::LinearRing* ring);
+
+    /**
+     * Check the number of non-repeated points is at least a given size.
+     *
+     * @param line
+     * @param minSize
+     */
+    void checkTooFewPoints(const geom::LineString* line, std::size_t minSize);
+
+    /**
+     * Test if the number of non-repeated points in a line
+     * is at least a given minimum size.
+     *
+     * @param line the line to test
+     * @param minSize the minimum line size
+     * @return true if the line has the required number of non-repeated points
+     */
+    bool isNonRepeatedSizeAtLeast(const geom::LineString* line, std::size_t minSize);
+
+    void checkAreaIntersections(PolygonTopologyAnalyzer& areaAnalyzer);
+
+    /**
+     * Check whether a ring self-intersects (except at its endpoints).
+     *
+     * @param ring the linear ring to check
+     */
+    void checkRingSimple(const geom::LinearRing* ring);
+
+
+    /**
+     * Tests that each hole is inside the polygon shell.
+     * This routine assumes that the holes have previously been tested
+     * to ensure that all vertices lie on the shell or on the same side of it
+     * (i.e. that the hole rings do not cross the shell ring).
+     * Given this, a simple point-in-polygon test of a single point in the hole can be used,
+     * provided the point is chosen such that it does not lie on the shell.
+     *
+     * @param poly the polygon to be tested for hole inclusion
+     */
+    void checkHolesInShell(const geom::Polygon* poly);
+
+    /**
+     * Checks if a polygon hole lies inside its shell
+     * and if not returns a point indicating this.
+     * The hole is known to be wholly inside or outside the shell,
+     * so it suffices to find a single point which is interior or exterior,
+     * or check the edge topology at a point on the boundary of the shell.
+     *
+     * @param hole the hole to test
+     * @param shell the polygon shell to test against
+     * @return a hole point outside the shell, or null if it is inside
+     */
+    const CoordinateXY* findHoleOutsideShellPoint(
+        const geom::LinearRing* hole,
+        const geom::LinearRing* shell);
+
+    /**
+     * Checks if any polygon hole is nested inside another.
+     * Assumes that holes do not cross (overlap),
+     * This is checked earlier.
+     *
+     * @param poly the polygon with holes to test
+     */
+    void checkHolesNotNested(const geom::Polygon* poly);
+
+    /**
+     * Checks that no element polygon is in the interior of another element polygon.
+     *
+     * Preconditions:
+     *
+     *  * shells do not partially overlap
+     *  * shells do not touch along an edge
+     *  * no duplicate rings exist
+     *
+     * These have been confirmed by the PolygonTopologyAnalyzer.
+     */
+    void checkShellsNotNested(const geom::MultiPolygon* mp);
+
+    void checkInteriorConnected(PolygonTopologyAnalyzer& areaAnalyzer);
+
+
+public:
+
+    /**
+     * Creates a new validator for a geometry.
+     *
+     * @param p_inputGeometry the geometry to validate
+     */
+    IsValidOp(const geom::Geometry* p_inputGeometry)
+        : inputGeometry(p_inputGeometry)
+        , validErr(nullptr)
+        {};
+
+    /**
+     * Sets whether polygons using <b>Self-Touching Rings</b> to form
+     * holes are reported as valid.
+     * If this flag is set, the following Self-Touching conditions
+     * are treated as being valid:
+     *
+     *  * the shell ring self-touches to create a hole touching the shell
+     *  * a hole ring self-touches to create two holes touching at a point
+     *
+     * The default (following the OGC SFS standard)
+     * is that this condition is not valid (false).
+     *
+     * Self-Touching Rings which disconnect the
+     * the polygon interior are still considered to be invalid
+     * (these are <b>invalid</b> under the SFS, and many other
+     * spatial models as well).
+     * This includes:
+     *
+     *  * exverted ("bow-tie") shells which self-touch at a single point
+     *  * inverted shells with the inversion touching the shell at another point
+     *  * exverted holes with exversion touching the hole at another point
+     *  * inverted ("C-shaped") holes which self-touch at a single point causing an island to be formed
+     *  * inverted shells or exverted holes which form part of a chain of touching rings
+     *    (which disconnect the interior)
+     *
+     * @param p_isValid states whether geometry with this condition is valid
+     */
+    void setSelfTouchingRingFormingHoleValid(bool p_isValid)
+    {
+        isInvertedRingValid = p_isValid;
+    };
+
+    /**
+     * Tests whether a Geometry is valid.
+     * @param geom the Geometry to test
+     * @return true if the geometry is valid
+     */
+    static bool isValid(const geom::Geometry* geom)
+    {
+        IsValidOp ivo(geom);
+        return ivo.isValid();
+    };
+
+    static bool isValid(const geom::CoordinateXY& coord)
+    {
+        return isValid(&coord);
+    }
+
+    /**
+     * Tests the validity of the input geometry.
+     *
+     * @return true if the geometry is valid
+     */
+    bool isValid();
+
+    /**
+     * Checks whether a coordinate is valid for processing.
+     * Coordinates are valid if their x and y ordinates are in the
+     * range of the floating point representation.
+     *
+     * @param coord the coordinate to validate
+     * @return <code>true</code> if the coordinate is valid
+     */
+    static bool isValid(const geom::CoordinateXY* coord);
+
+    /**
+     * Computes the validity of the geometry,
+     * and if not valid returns the validation error for the geometry,
+     * or null if the geometry is valid.
+     *
+     * @return the validation error, if the geometry is invalid
+     * or null if the geometry is valid
+     */
+    const TopologyValidationError* getValidationError();
+
+
+};
+
+
+} // namespace geos.operation.valid
+} // namespace geos.operation
+} // namespace geos