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

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/geom/Quadrant.h

@@ -0,0 +1,182 @@
+/**********************************************************************
+ *
+ * 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: geom/Quadrant.java rev. 1.8 (JTS-1.10)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Quadrant.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/util/IllegalArgumentException.h>
+
+#include <string>
+#include <sstream>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+}
+
+namespace geos {
+namespace geom { // geos.geom
+
+/** \brief
+ * Utility functions for working with quadrants.
+ *
+ * The quadrants are numbered as follows:
+ * <pre>
+ * 1 | 0
+ * --+--
+ * 2 | 3
+ * </pre>
+ *
+ */
+class GEOS_DLL Quadrant {
+
+public:
+
+    static const int NE = 0;
+    static const int NW = 1;
+    static const int SW = 2;
+    static const int SE = 3;
+
+    /**
+     * Returns the quadrant of a directed line segment
+     * (specified as x and y displacements, which cannot both be 0).
+     *
+     * @throws IllegalArgumentException if the displacements are both 0
+     */
+    static int quadrant(double dx, double dy)
+    {
+        if(dx == 0.0 && dy == 0.0) {
+            std::ostringstream s;
+            s << "Cannot compute the quadrant for point ";
+            s << "(" << dx << "," << dy << ")" << std::endl;
+            throw geos::util::IllegalArgumentException(s.str());
+        }
+        if(dx >= 0) {
+            if(dy >= 0) {
+                return NE;
+            }
+            else {
+                return SE;
+            }
+        }
+        else {
+            if(dy >= 0) {
+                return NW;
+            }
+            else {
+                return SW;
+            }
+        }
+    };
+
+    /**
+     * Returns the quadrant of a directed line segment from p0 to p1.
+     *
+     * @throws IllegalArgumentException if the points are equal
+     */
+    static int quadrant(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1)
+    {
+        if(p1.x == p0.x && p1.y == p0.y) {
+            throw geos::util::IllegalArgumentException("Cannot compute the quadrant for two identical points " + p0.toString());
+        }
+
+        if(p1.x >= p0.x) {
+            if(p1.y >= p0.y) {
+                return NE;
+            }
+            else {
+                return SE;
+            }
+        }
+        else {
+            if(p1.y >= p0.y) {
+                return NW;
+            }
+            else {
+                return SW;
+            }
+        }
+    };
+
+    /** Return a measure that increases monotonically with counterclockwise
+     *  angle and avoids trigonometric calculations. Values are consistent
+     *  with the numeric quadrant codes
+     *
+     * @param p0 circle center coordinate
+     * @param p1 coordinate for which pseudoangle should be calculated
+     */
+    static double pseudoAngle(const CoordinateXY& p0, const CoordinateXY& p1)
+    {
+        const double dx = p1.x - p0.x;
+        const double dy = p1.y - p0.y;
+
+        const double k = dx / (std::abs(dx) + std::abs(dy));
+        const double w = 2 + (dy > 0 ? 3 - k : 1 + k);
+
+        return w >= 4 ? w - 4 : w;
+    }
+
+    /**
+     * Returns true if the quadrants are 1 and 3, or 2 and 4
+     */
+    static bool isOpposite(int quad1, int quad2)
+    {
+        if(quad1 == quad2) {
+            return false;
+        }
+        int diff = (quad1 - quad2 + 4) % 4;
+        // if quadrants are not adjacent, they are opposite
+        if(diff == 2) {
+            return true;
+        }
+        return false;
+    };
+
+    /*
+     * Returns the right-hand quadrant of the halfplane defined by
+     * the two quadrants,
+     * or -1 if the quadrants are opposite, or the quadrant if they
+     * are identical.
+     */
+    static int commonHalfPlane(int quad1, int quad2);
+
+    /**
+     * Returns whether the given quadrant lies within the given halfplane
+     * (specified by its right-hand quadrant).
+     */
+    static bool isInHalfPlane(int quad, int halfPlane);
+
+    /**
+     * Returns true if the given quadrant is 0 or 1.
+     */
+    static bool isNorthern(int quad)
+    {
+        return quad == NE || quad == NW;
+    };
+
+};
+
+
+} // namespace geos.geom
+} // namespace geos

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/geom/SimpleCurve.h

@@ -0,0 +1,133 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ * Copyright (C) 2005 2006 Refractions Research Inc.
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2024 ISciences, LLC
+ *
+ * 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/Curve.h>
+#include <geos/geom/Geometry.h>
+
+namespace geos {
+namespace geom {
+
+class GEOS_DLL SimpleCurve : public Curve {
+public:
+
+    using Curve::apply_ro;
+    using Curve::apply_rw;
+
+    void apply_ro(CoordinateFilter* filter) const override;
+
+    void apply_ro(CoordinateSequenceFilter& filter) const override;
+
+    void apply_rw(CoordinateSequenceFilter& filter) override;
+
+    void apply_rw(const CoordinateFilter* filter) override;
+
+    bool equalsExact(const Geometry* other, double tolerance = 0)
+    const override;
+
+    bool equalsIdentical(const Geometry* other) const override;
+
+    /**
+     * \brief
+     * Returns a MultiPoint.
+     * Empty for closed Curve, a Point for each vertex otherwise.
+     */
+    std::unique_ptr<Geometry> getBoundary() const override;
+
+    const CoordinateXY* getCoordinate() const override;
+
+    /// Returns coordinate dimension.
+    uint8_t getCoordinateDimension() const override;
+
+    virtual const Coordinate& getCoordinateN(std::size_t n) const;
+
+    std::unique_ptr<CoordinateSequence> getCoordinates() const override;
+
+    /// Returns a read-only pointer to internal CoordinateSequence
+    const CoordinateSequence* getCoordinatesRO() const;
+
+    /// Returns a read-only pointer to internal CoordinateSequence
+    const std::shared_ptr<const CoordinateSequence>& getSharedCoordinates() const;
+
+    const SimpleCurve* getCurveN(std::size_t) const override;
+
+    const CoordinateXY& getEndCoordinate() const override;
+
+    /// \brief
+    /// Return the end point of the LineString
+    /// or NULL if this is an EMPTY LineString.
+    ///
+    std::unique_ptr<Point> getEndPoint() const override;
+
+    const Envelope* getEnvelopeInternal() const override
+    {
+        return &envelope;
+    }
+
+    std::size_t getNumCurves() const override;
+
+    std::size_t getNumPoints() const override;
+
+    std::unique_ptr<Point> getPointN(std::size_t n) const override;
+
+    const CoordinateXY& getStartCoordinate() const override;
+
+    /// \brief
+    /// Return the start point of the LineString
+    /// or NULL if this is an EMPTY LineString.
+    ///
+    std::unique_ptr<Point> getStartPoint() const override;
+
+    bool hasM() const override;
+
+    bool hasZ() const override;
+
+    bool isClosed() const override;
+
+    virtual bool isCoordinate(CoordinateXY& pt) const;
+
+    virtual bool isCurved() const = 0;
+
+    bool isEmpty() const override;
+
+    std::unique_ptr<SimpleCurve> clone() const;
+
+    std::unique_ptr<SimpleCurve> reverse() const;
+
+protected:
+
+    SimpleCurve(const SimpleCurve& other);
+
+    SimpleCurve(const std::shared_ptr<const CoordinateSequence>& newCoords,
+                bool isLinear,
+                const GeometryFactory& factory);
+
+    SimpleCurve(std::unique_ptr<CoordinateSequence>&& newCoords,
+                bool isLinear,
+                const GeometryFactory& factory);
+
+    int compareToSameClass(const Geometry* ls) const override;
+
+    Envelope computeEnvelopeInternal(bool isLinear) const;
+
+    std::shared_ptr<const CoordinateSequence> points;
+    mutable Envelope envelope;
+};
+
+}
+}

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/geom/Surface.h

@@ -0,0 +1,119 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2024 ISciences, LLC
+ *
+ * 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/Geometry.h>
+
+namespace geos {
+namespace geom {
+
+class Curve;
+
+/// A Surface is an abstract class representing a Geometry of dimension 2.
+/// It is extended by Polygon, which represents a Surface with linear edges,
+/// and by CurvePolygon, whose edges may include circular arcs.
+class GEOS_DLL Surface : public Geometry {
+
+private:
+
+protected:
+    using Geometry::Geometry;
+
+public:
+
+    void apply_ro(CoordinateFilter* filter) const override;
+
+    void apply_ro(CoordinateSequenceFilter& filter) const override;
+
+    void apply_ro(GeometryComponentFilter* filter) const override;
+
+    void apply_ro(GeometryFilter* filter) const override;
+
+    void apply_rw(CoordinateSequenceFilter& filter) override;
+
+    void apply_rw(GeometryComponentFilter* filter) override;
+
+    void apply_rw(GeometryFilter* filter) override;
+
+    void apply_rw(const CoordinateFilter* filter) override;
+
+    std::unique_ptr<Surface> clone() const;
+
+    std::unique_ptr<Geometry> convexHull() const override;
+
+    bool
+    equalsExact(const Geometry* other, double tolerance = 0.0) const override;
+
+    bool
+    equalsIdentical(const Geometry* other) const override;
+
+    int
+    getBoundaryDimension() const override
+    {
+        return 1;
+    }
+
+    const CoordinateXY* getCoordinate() const override;
+
+    uint8_t getCoordinateDimension() const override;
+
+    Dimension::DimensionType
+    getDimension() const override
+    {
+        return Dimension::A; // area
+    }
+
+    const Envelope* getEnvelopeInternal() const override;
+
+    /// Returns the exterior ring (shell)
+    virtual const Curve* getExteriorRing() const = 0;
+
+    /// Get nth interior ring (hole)
+    virtual const Curve* getInteriorRingN(std::size_t n) const = 0;
+
+    /// Returns the perimeter of this Surface
+    double getLength() const override;
+
+    /// Returns number of interior rings (holes)
+    virtual size_t getNumInteriorRing() const = 0;
+
+    size_t getNumPoints() const override;
+
+    bool hasM() const override;
+
+    bool hasZ() const override;
+
+    bool isEmpty() const override;
+
+protected:
+
+    int
+    compareToSameClass(const Geometry* g) const override;
+
+    // Helper method allowing PolygonImpl to use GeometryFactory without circular imports
+    static std::unique_ptr<Geometry> createEmptyRing(const GeometryFactory&);
+
+    virtual Curve* getExteriorRing() = 0;
+
+    virtual Curve* getInteriorRingN(std::size_t i) = 0;
+
+    void geometryChangedAction() override {}
+
+    void validateConstruction() const;
+
+};
+
+}
+}

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/geom/SurfaceImpl.h

@@ -0,0 +1,156 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2024 ISciences, LLC
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/CoordinateSequenceFilter.h>
+#include <geos/geom/Curve.h>
+#include <geos/geom/GeometryComponentFilter.h>
+#include <geos/geom/GeometryFilter.h>
+#include <geos/geom/LinearRing.h>
+#include <geos/geom/Surface.h>
+#include <geos/util/IllegalArgumentException.h>
+
+namespace geos {
+namespace geom {
+
+template<typename RingType>
+class SurfaceImpl : public Surface {
+
+protected:
+
+    SurfaceImpl(const SurfaceImpl& p)
+        :
+        Surface(p),
+        shell(static_cast<RingType*>(p.shell->clone().release())),
+        holes(p.holes.size())
+    {
+        for (std::size_t i = 0; i < holes.size(); ++i) {
+            holes[i].reset(static_cast<RingType*>(p.holes[i]->clone().release()));
+        }
+    }
+
+    /**
+     * Constructs a <code>Surface</code> with the given exterior
+     * and interior boundaries.
+     *
+     * @param  newShell  the outer boundary of the new Polygon,
+     *                   or <code>null</code> or an empty
+             *		     Curve if the empty geometry
+     *                   is to be created.
+     *
+     * @param  newHoles  the rings defining the inner
+     *                   boundaries of the new Surface, or
+     *                   null or empty Curve
+     *                   if the empty geometry is to be created.
+     *
+     * @param newFactory the GeometryFactory used to create this geometry
+     *
+     * Polygon will take ownership of shell and hole curves
+     */
+    SurfaceImpl(std::unique_ptr<RingType>&& newShell,
+                const GeometryFactory& newFactory) :
+        Surface(&newFactory),
+        shell(std::move(newShell))
+    {
+        if (shell == nullptr) {
+            shell.reset(static_cast<RingType*>(createEmptyRing(newFactory).release()));
+        }
+
+        validateConstruction();
+    }
+
+    SurfaceImpl(std::unique_ptr<RingType>&& newShell,
+                std::vector<std::unique_ptr<RingType>>&& newHoles,
+                const GeometryFactory& newFactory) :
+        Surface(&newFactory),
+        shell(std::move(newShell)),
+        holes(std::move(newHoles))
+    {
+        if (shell == nullptr) {
+            shell.reset(static_cast<RingType*>(createEmptyRing(newFactory).release()));
+        }
+
+        validateConstruction();
+    }
+
+public:
+
+    const RingType*
+    getExteriorRing() const override
+    {
+        return shell.get();
+    }
+
+    RingType*
+    getExteriorRing() override
+    {
+        return shell.get();
+    }
+
+    const RingType*
+    getInteriorRingN(std::size_t n) const override
+    {
+        return holes[n].get();
+    }
+
+    RingType*
+    getInteriorRingN(std::size_t n) override
+    {
+        return holes[n].get();
+    }
+
+    size_t getNumInteriorRing() const override
+    {
+        return holes.size();
+    }
+
+    /**
+    * \brief
+    * Take ownership of this Surface's exterior ring.
+    * After releasing the exterior ring, the Surface should be
+    * considered in a moved-from state and should not be accessed,
+    * except to release the interior rings (if desired.)
+    * @return exterior ring
+    */
+    std::unique_ptr<RingType>
+    releaseExteriorRing()
+    {
+        return std::move(shell);
+    }
+
+    /**
+    * \brief
+    * Take ownership of this Surfaces's interior rings.
+    * After releasing the rings, the Surface should be
+    * considered in a moved-from state and should not be accessed,
+    * except to release the exterior ring (if desired.)
+    * @return vector of rings (may be empty)
+    */
+    std::vector<std::unique_ptr<RingType>> releaseInteriorRings()
+    {
+        return std::move(holes);
+    }
+
+protected:
+    std::unique_ptr<RingType> shell;
+    std::vector<std::unique_ptr<RingType>> holes;
+
+};
+
+}
+}