@crossbind/port-geos-linuxmusl 0.0.0-stage → 2.0.0-beta.63

package/dist/prebuilt/linuxmusl-x64-mt-release/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/linuxmusl-x64-mt-release/include/geos/operation/overlayng/CoverageUnion.h

@@ -0,0 +1,99 @@
+/**********************************************************************
+ *
+ * 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;
+}
+}
+
+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 {
+    using Geometry = geos::geom::Geometry;
+
+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

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/overlayng/Edge.h

@@ -0,0 +1,336 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 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/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/Dimension.h>
+#include <geos/operation/overlayng/OverlayLabel.h>
+#include <geos/operation/overlayng/EdgeSourceInfo.h>
+#include <geos/util/GEOSException.h>
+#include <geos/export.h>
+
+
+#include <memory>
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+/**
+ * Represents the underlying linework for edges in a topology graph,
+ * and carries the topology information
+ * derived from the two parent geometries.
+ * The edge may be the result of the merging of
+ * two or more edges which have the same underlying linework
+ * (although possibly different orientations).
+ * In this case the topology information is
+ * derived from the merging of the information in the
+ * source edges.
+ * Merged edges can occur in the following situations
+ *
+ *  - Due to topology collapse caused by snapping or rounding
+ *    of polygonal geometries.
+ *  - Due to coincident linework in a linear input
+ *
+ * The source edges may have the same parent geometry,
+ * or different ones, or a mix of the two.
+ *
+ * @author mdavis
+ */
+class GEOS_DLL Edge {
+    using Location = geos::geom::Location;
+
+private:
+
+    // Members
+    int aDim = OverlayLabel::DIM_UNKNOWN;
+    int aDepthDelta = 0;
+    bool aIsHole = false;
+    int bDim = OverlayLabel::DIM_UNKNOWN;
+    int bDepthDelta = 0;
+    bool bIsHole = false;
+    std::shared_ptr<const geom::CoordinateSequence> pts;
+    const bool ptsCurved;
+
+    // Methods
+
+    /**
+    * Populates the label for an edge resulting from an input geometry.
+    *  - If the edge is not part of the input, the label is left as NOT_PART
+    *  - If input is an Area and the edge is on the boundary
+    * (which may include some collapses),
+    * edge is marked as an AREA edge and side locations are assigned
+    *  - If input is an Area and the edge is collapsed
+    * (depth delta = 0),
+    * the label is set to COLLAPSE.
+    * The location will be determined later
+    * by evaluating the final graph topology.
+    *  - If input is a Line edge is set to a LINE edge.
+    * For line edges the line location is not significant
+    * (since there is no parent area for which to determine location).
+    */
+    static void initLabel(OverlayLabel& lbl, uint8_t geomIndex, int dim, int depthDelta, bool p_isHole);
+
+    static int labelDim(int dim, int depthDelta)
+    {
+        if (dim == geom::Dimension::False)
+            return OverlayLabel::DIM_NOT_PART;
+
+        if (dim == geom::Dimension::L)
+            return OverlayLabel::DIM_LINE;
+
+        // assert: dim is A
+        bool isCollapse = (depthDelta == 0);
+        if (isCollapse)
+            return OverlayLabel::DIM_COLLAPSE;
+
+        return OverlayLabel::DIM_BOUNDARY;
+    };
+
+    bool isHole(int index) const
+    {
+        if (index == 0)
+            return aIsHole;
+        return bIsHole;
+    };
+
+    bool isBoundary(int geomIndex) const
+    {
+        if (geomIndex == 0)
+            return aDim == OverlayLabel::DIM_BOUNDARY;
+        return bDim == OverlayLabel::DIM_BOUNDARY;
+    };
+
+    /**
+    * Tests whether the edge is part of a shell in the given geometry.
+    * This is only the case if the edge is a boundary.
+    */
+    bool isShell(int geomIndex) const
+    {
+        if (geomIndex == 0) {
+            return (aDim == OverlayLabel::DIM_BOUNDARY && ! aIsHole);
+        }
+        return (bDim == OverlayLabel::DIM_BOUNDARY && ! bIsHole);
+    };
+
+    static Location locationRight(int depthDelta)
+    {
+        int sgn = delSign(depthDelta);
+        switch (sgn) {
+            case 0: return Location::NONE;
+            case 1: return Location::INTERIOR;
+            case -1: return Location::EXTERIOR;
+        }
+        return Location::NONE;
+    };
+
+    static Location locationLeft(int depthDelta)
+    {
+        // TODO: is it always safe to ignore larger depth deltas?
+        int sgn = delSign(depthDelta);
+        switch (sgn) {
+            case 0: return Location::NONE;
+            case 1: return Location::EXTERIOR;
+            case -1: return Location::INTERIOR;
+        }
+        return Location::NONE;
+    };
+
+    static int delSign(int depthDel)
+    {
+        if (depthDel > 0) return 1;
+        if (depthDel < 0) return -1;
+        return 0;
+    };
+
+    void copyInfo(const EdgeSourceInfo* info)
+    {
+        if (info->getIndex() == 0) {
+            aDim = info->getDimension();
+            aIsHole = info->isHole();
+            aDepthDelta = info->getDepthDelta();
+        }
+        else {
+            bDim = info->getDimension();
+            bIsHole = info->isHole();
+            bDepthDelta = info->getDepthDelta();
+        }
+    };
+
+    static bool isHoleMerged(int geomIndex, const Edge* edge1, const Edge* edge2)
+    {
+        // TOD: this might be clearer with tri-state logic for isHole?
+        bool isShell1 = edge1->isShell(geomIndex);
+        bool isShell2 = edge2->isShell(geomIndex);
+        bool isShellMerged = isShell1 || isShell2;
+        // flip since isHole is stored
+        return !isShellMerged;
+    };
+
+
+public:
+
+    Edge(const std::shared_ptr<const geom::CoordinateSequence>& p_pts, const EdgeSourceInfo* info, bool isCurved);
+
+    friend std::ostream& operator<<(std::ostream& os, const Edge& e);
+
+    static bool isCollapsed(const geom::CoordinateSequence* pts);
+
+    bool isCurved() const {
+        return ptsCurved;
+    }
+
+    // return a clone of the underlying points
+    std::unique_ptr<geom::CoordinateSequence> getCoordinates() const
+    {
+        return pts->clone();
+    };
+
+    // return a read-only pointer to the underlying points
+    const geom::CoordinateSequence* getCoordinatesRO() const
+    {
+        return pts.get();
+    };
+
+    // release the underlying points to the caller
+    std::shared_ptr<const geom::CoordinateSequence> releaseCoordinates()
+    {
+        auto cs = pts;
+        pts.reset();
+        return cs;
+    };
+
+    const geom::CoordinateXY& getCoordinate(std::size_t index)  const
+    {
+        return pts->getAt(index);
+    };
+
+    std::size_t size() const
+    {
+        return pts->size();
+    };
+
+    bool direction() const
+    {
+        if (pts->size() < 2) {
+            throw util::GEOSException("Edge must have >= 2 points");
+        }
+
+        const geom::CoordinateXY& p0 = getCoordinate(0);
+        const geom::CoordinateXY& pn0 = getCoordinate(pts->size() - 1);
+
+        const int cmp0 = p0.compareTo(pn0);
+        if (cmp0 != 0) {
+            return cmp0 == -1;
+        }
+
+        const geom::CoordinateXY& p1 = getCoordinate(1);
+        const geom::CoordinateXY& pn1 = getCoordinate(pts->size() - 2);
+        const int cmp1 = p1.compareTo(pn1);
+        if (cmp1 != 0) {
+            return cmp1 == -1;
+        }
+
+        throw util::GEOSException("Edge direction cannot be determined because endpoints are equal");
+    };
+
+    /**
+    * Compares two coincident edges to determine
+    * whether they have the same or opposite direction.
+    */
+    bool relativeDirection(const Edge* edge2) const
+    {
+        // assert: the edges match (have the same coordinates up to direction)
+        if (!getCoordinate(0).equals2D(edge2->getCoordinate(0))) {
+            return false;
+        }
+        if (!getCoordinate(1).equals2D(edge2->getCoordinate(1))) {
+            return false;
+        }
+        return true;
+    };
+
+    int dimension(int geomIndex) const
+    {
+        if (geomIndex == 0) return aDim;
+        return bDim;
+    };
+
+    /**
+    * Merges an edge into this edge,
+    * updating the topology info accordingly.
+    */
+    void merge(const Edge* edge)
+    {
+        /**
+         * Marks this
+         * as a shell edge if any contributing edge is a shell.
+         * Update hole status first, since it depends on edge dim
+         */
+        aIsHole = isHoleMerged(0, this, edge);
+        bIsHole = isHoleMerged(1, this, edge);
+
+        if (edge->aDim > aDim) aDim = edge->aDim;
+        if (edge->bDim > bDim) bDim = edge->bDim;
+
+        bool relDir = relativeDirection(edge);
+        int flipFactor = relDir ? 1 : -1;
+        aDepthDelta += flipFactor * edge->aDepthDelta;
+        bDepthDelta += flipFactor * edge->bDepthDelta;
+    };
+
+    void populateLabel(OverlayLabel &lbl) const
+    {
+        initLabel(lbl, 0, aDim, aDepthDelta, aIsHole);
+        initLabel(lbl, 1, bDim, bDepthDelta, bIsHole);
+    };
+
+    bool compareTo(const Edge& e) const
+    {
+        const geom::CoordinateXY& ca = getCoordinate(0);
+        const geom::CoordinateXY& cb = e.getCoordinate(0);
+        if(ca.compareTo(cb) < 0) {
+            return true;
+        }
+        else if (ca.compareTo(cb) > 0) {
+            return false;
+        }
+        else {
+            const geom::CoordinateXY& cca = getCoordinate(1);
+            const geom::CoordinateXY& ccb = e.getCoordinate(1);
+            if(cca.compareTo(ccb) < 0) {
+                return true;
+            }
+            else if (cca.compareTo(ccb) > 0) {
+                return false;
+            }
+            else {
+                return false;
+            }
+        }
+    }
+
+};
+
+bool EdgeComparator(const Edge* a, const Edge* b);
+
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/overlayng/EdgeKey.h

@@ -0,0 +1,118 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 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/operation/overlayng/OverlayLabel.h>
+#include <geos/operation/overlayng/EdgeKey.h>
+#include <geos/operation/overlayng/Edge.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/export.h>
+
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+/**
+ * A key for sorting and comparing edges in a noded arrangement.
+ * Relies on the fact that in a correctly noded arrangement
+ * edges are identical (up to direction)
+ * iff they have their first segment in common.
+ *
+ * @author mdavis
+ *
+ */
+class GEOS_DLL EdgeKey {
+    using Coordinate = geos::geom::Coordinate;
+
+private:
+
+    // Members
+    double p0x;
+    double p0y;
+    double p1x;
+    double p1y;
+
+    // Methods
+    void initPoints(const Edge* edge)
+    {
+        bool direction = edge->direction();
+        if (direction) {
+            init(edge->getCoordinate(0),
+                 edge->getCoordinate(1));
+        }
+        else {
+            std::size_t len = edge->size();
+            init(edge->getCoordinate(len - 1),
+                 edge->getCoordinate(len - 2));
+        }
+    }
+
+    void init(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1)
+    {
+        p0x = p0.x;
+        p0y = p0.y;
+        p1x = p1.x;
+        p1y = p1.y;
+    }
+
+
+public:
+
+    EdgeKey(const Edge* edge)
+    {
+        initPoints(edge);
+    }
+
+    int compareTo(const EdgeKey* ek) const
+    {
+        if (p0x < ek->p0x) return -1;
+        if (p0x > ek->p0x) return 1;
+        if (p0y < ek->p0y) return -1;
+        if (p0y > ek->p0y) return 1;
+        // first points are equal, compare second
+        if (p1x < ek->p1x) return -1;
+        if (p1x > ek->p1x) return 1;
+        if (p1y < ek->p1y) return -1;
+        if (p1y > ek->p1y) return 1;
+        return 0;
+    }
+
+    bool equals(const EdgeKey* ek) const
+    {
+        return p0x == ek->p0x
+               && p0y == ek->p0y
+               && p1x == ek->p1x
+               && p1y == ek->p1y;
+    }
+
+    friend bool operator<(const EdgeKey& ek1, const EdgeKey& ek2)
+    {
+        return ek1.compareTo(&ek2) < 0;
+    };
+
+    friend bool operator==(const EdgeKey& ek1, const EdgeKey& ek2)
+    {
+        return ek1.equals(&ek2);
+    };
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+