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

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlay/validate/FuzzyPointLocator.h

@@ -0,0 +1,97 @@
+/**********************************************************************
+ *
+ * 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/overlay/validate/FuzzyPointLocator.java rev. 1.1 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/algorithm/PointLocator.h> // for composition
+#include <geos/geom/Geometry.h> // for unique_ptr visibility of dtor
+#include <geos/geom/Location.h> // for Location::Value enum
+
+#include <vector>
+#include <memory> // for unique_ptr
+
+#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 Geometry;
+class Coordinate;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace overlay { // geos::operation::overlay
+namespace validate { // geos::operation::overlay::validate
+
+/** \brief
+ * Finds the most likely Location of a point relative to
+ * the polygonal components of a geometry, using a tolerance value.
+ *
+ * If a point is not clearly in the Interior or Exterior,
+ * it is considered to be on the Boundary.
+ * In other words, if the point is within the tolerance of the Boundary,
+ * it is considered to be on the Boundary; otherwise,
+ * whether it is Interior or Exterior is determined directly.
+ */
+class GEOS_DLL FuzzyPointLocator {
+
+public:
+
+    FuzzyPointLocator(const geom::Geometry& geom, double nTolerance);
+
+    geom::Location getLocation(const geom::Coordinate& pt);
+
+private:
+
+    const geom::Geometry& g;
+
+    double tolerance;
+
+    algorithm::PointLocator ptLocator;
+
+    std::unique_ptr<geom::Geometry> linework;
+
+    // this function has been obsoleted
+    std::unique_ptr<geom::Geometry> getLineWork(const geom::Geometry& geom);
+
+    /// Extracts linework for polygonal components.
+    ///
+    /// @param geom the geometry from which to extract
+    /// @return a lineal geometry containing the extracted linework
+    std::unique_ptr<geom::Geometry> extractLineWork(const geom::Geometry& geom);
+
+    // Declare type as noncopyable
+    FuzzyPointLocator(const FuzzyPointLocator& other) = delete;
+    FuzzyPointLocator& operator=(const FuzzyPointLocator& rhs) = delete;
+};
+
+} // namespace geos::operation::overlay::validate
+} // namespace geos::operation::overlay
+} // namespace geos::operation
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlay/validate/OffsetPointGenerator.h

@@ -0,0 +1,87 @@
+/**********************************************************************
+ *
+ * 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/overlay/validate/OffsetPointGenerator.java rev. 1.1 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/algorithm/PointLocator.h> // for composition
+#include <geos/geom/Geometry.h> // for unique_ptr visibility of dtor
+#include <geos/geom/MultiPoint.h> // for unique_ptr visibility of dtor
+#include <geos/geom/Coordinate.h> // for use in vector
+
+#include <vector>
+#include <memory> // for unique_ptr
+
+#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 Geometry;
+//class MultiPoint;
+class LineString;
+//class Coordinate;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace overlay { // geos::operation::overlay
+namespace validate { // geos::operation::overlay::validate
+
+/// Generates points offset from both sides of all segments in a geometry
+//
+class GEOS_DLL OffsetPointGenerator {
+
+public:
+
+    OffsetPointGenerator(const geom::Geometry& geom, double offset);
+
+    /// Gets the computed offset points.
+    std::unique_ptr< std::vector<geom::Coordinate> > getPoints();
+
+private:
+
+    const geom::Geometry& g;
+
+    double offsetDistance;
+
+    std::unique_ptr< std::vector<geom::Coordinate> > offsetPts;
+
+    void extractPoints(const geom::LineString* line);
+
+    void computeOffsets(const geom::Coordinate& p0,
+                        const geom::Coordinate& p1);
+
+    // Declare type as noncopyable
+    OffsetPointGenerator(const OffsetPointGenerator& other) = delete;
+    OffsetPointGenerator& operator=(const OffsetPointGenerator& rhs) = delete;
+};
+
+} // namespace geos::operation::overlay::validate
+} // namespace geos::operation::overlay
+} // namespace geos::operation
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlay/validate/OverlayResultValidator.h

@@ -0,0 +1,131 @@
+/**********************************************************************
+ *
+ * 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/overlay/validate/OverlayResultValidator.java rev. 1.4 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/operation/overlay/validate/FuzzyPointLocator.h> // composition
+#include <geos/geom/Location.h> // for Location::Value type
+
+#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 Geometry;
+class Coordinate;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace overlay { // geos::operation::overlay
+namespace validate { // geos::operation::overlay::validate
+
+/** \brief
+ * Validates that the result of an overlay operation is
+ * geometrically correct within a determined tolerance.
+ *
+ * Uses fuzzy point location to find points which are
+ * definitely in either the interior or exterior of the result
+ * geometry, and compares these results with the expected ones.
+ *
+ * This algorithm is only useful where the inputs are polygonal.
+ *
+ * This is a heuristic test, and may return false positive results
+ * (I.e. it may fail to detect an invalid result.)
+ * It should never return a false negative result, however
+ * (I.e. it should never report a valid result as invalid.)
+ *
+ * @see OverlayOp
+ */
+class GEOS_DLL OverlayResultValidator {
+
+public:
+
+    static bool isValid(
+        const geom::Geometry& geom0,
+        const geom::Geometry& geom1,
+        int opCode,
+        const geom::Geometry& result);
+
+    OverlayResultValidator(
+        const geom::Geometry& geom0,
+        const geom::Geometry& geom1,
+        const geom::Geometry& result);
+
+    bool isValid(int opCode);
+
+    geom::Coordinate&
+    getInvalidLocation()
+    {
+        return invalidLocation;
+    }
+
+private:
+
+    double boundaryDistanceTolerance;
+
+    const geom::Geometry& g0;
+
+    const geom::Geometry& g1;
+
+    const geom::Geometry& gres;
+
+    FuzzyPointLocator fpl0;
+
+    FuzzyPointLocator fpl1;
+
+    FuzzyPointLocator fplres;
+
+    geom::Coordinate invalidLocation;
+
+    std::vector<geom::Coordinate> testCoords;
+
+    void addTestPts(const geom::Geometry& g);
+
+    void addVertices(const geom::Geometry& g);
+
+    bool testValid(int overlayOp);
+
+    bool testValid(int overlayOp, const geom::Coordinate& pt);
+
+    bool isValidResult(int overlayOp, std::vector<geom::Location>& location);
+
+    static double computeBoundaryDistanceTolerance(
+        const geom::Geometry& g0, const geom::Geometry& g1);
+
+    // Declare type as noncopyable
+    OverlayResultValidator(const OverlayResultValidator& other) = delete;
+    OverlayResultValidator& operator=(const OverlayResultValidator& rhs) = delete;
+};
+
+} // namespace geos::operation::overlay::validate
+} // namespace geos::operation::overlay
+} // namespace geos::operation
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlayng/CoverageUnion.h

@@ -0,0 +1,100 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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 <geos/export.h>
+#include <memory>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+}
+}
+
+using geos::geom::Geometry;
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+/**
+ * Unions a valid coverage of polygons or lines
+ * in an efficient way.
+ *
+ * A valid polygonal coverage is a collection of geom::Polygon
+ * which satisfy the following conditions:
+ *
+ *  * Vector-clean - Line segments within the collection
+ *    must either be identical or intersect only at endpoints.
+ *  * Non-overlapping - No two polygons
+ *    may overlap. Equivalently, polygons must be interior-disjoint.
+ *
+ * A valid linear coverage is a collection of geom::LineString
+ * which satisfies the Vector-clean condition.
+ * Note that this does not require the LineStrings to be fully noded
+ * - i.e. they may contain coincident linework.
+ * Coincident line segments are dissolved by the union.
+ * Currently linear output is not merged (this may be added in a future release.)
+ *
+ * Currently no checking is done to determine whether the input is a valid coverage.
+ * This is because coverage validation involves segment intersection detection,
+ * which is much more expensive than the union phase.
+ * If the input is not a valid coverage
+ * then in some cases this will be detected during processing
+ * and a util::TopologyException is thrown.
+ * Otherwise, the computation will produce output, but it will be invalid.
+ *
+ * Unioning a valid coverage implies that no new vertices are created.
+ * This means that a precision model does not need to be specified.
+ * The precision of the vertices in the output geometry is not changed.
+ *
+ * @author Martin Davis
+ *
+ * @see noding::SegmentExtractingNoder
+ *
+ */
+class GEOS_DLL CoverageUnion {
+
+private:
+
+    CoverageUnion()
+    {
+        // No instantiation for now
+    };
+
+
+
+public:
+
+    static constexpr double AREA_PCT_DIFF_TOL = 1e-6;
+
+    /**
+    * Unions a valid polygonal coverage or linear network.
+    *
+    * @param coverage a coverage of polygons or lines
+    * @return the union of the coverage
+    *
+    * @throws util::TopologyException in some cases if the coverage is invalid
+    */
+    static std::unique_ptr<Geometry> geomunion(const Geometry* coverage);
+
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos