@cpp.js/package-geos 1.0.0-beta.20 → 1.0.0-beta.21

package/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/geom/SurfaceImpl.h

@@ -0,0 +1,159 @@
+/**********************************************************************
+ *
+ * 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()));
+        }
+    }
+
+    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()));
+        }
+
+        if(shell->isEmpty() && hasNonEmptyElements(&holes)) {
+            throw geos::util::IllegalArgumentException("shell is empty but holes are not");
+        }
+        if (hasNullElements(&holes)) {
+            throw geos::util::IllegalArgumentException("holes must not contain null elements");
+        }
+    }
+
+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;
+
+};
+
+}
+}

package/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/geom/prep/BasicPreparedGeometry.h

@@ -0,0 +1,214 @@
+/**********************************************************************
+ *
+ * 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: geom/prep/BasicPreparedGeometry.java rev. 1.5 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/prep/PreparedGeometry.h> // for inheritance
+#include <geos/geom/Coordinate.h>
+#include <geos/operation/relateng/RelateNG.h>
+
+#include <vector>
+#include <string>
+
+namespace geos {
+namespace geom {
+class Geometry;
+class Coordinate;
+}
+}
+
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+using geos::operation::relateng::RelateNG;
+
+// * \class BasicPreparedGeometry
+
+/**
+ *
+ * \brief
+ * A base class for {@link PreparedGeometry} subclasses.
+ *
+ * Contains default implementations for methods, which simply delegate
+ * to the equivalent {@link Geometry} methods.
+ * This class may be used as a "no-op" class for Geometry types
+ * which do not have a corresponding {@link PreparedGeometry} implementation.
+ *
+ * @author Martin Davis
+ *
+ */
+class BasicPreparedGeometry: public PreparedGeometry {
+private:
+    const geom::Geometry* baseGeom;
+    std::vector<const CoordinateXY*> representativePts;
+    mutable std::unique_ptr<RelateNG> relate_ng;
+
+    RelateNG& getRelateNG() const
+    {
+        if (relate_ng == nullptr)
+            relate_ng = RelateNG::prepare(baseGeom);
+
+        return *relate_ng;
+    }
+
+protected:
+    /**
+     * Sets the original {@link Geometry} which will be prepared.
+     */
+    void setGeometry(const geom::Geometry* geom);
+
+    /**
+     * Determines whether a Geometry g interacts with
+     * this geometry by testing the geometry envelopes.
+     *
+     * @param g a Geometry
+     * @return true if the envelopes intersect
+     */
+    bool envelopesIntersect(const geom::Geometry* g) const;
+
+    /**
+     * Determines whether the envelope of
+     * this geometry covers the Geometry g.
+     *
+     *
+     * @param g a Geometry
+     * @return true if g is contained in this envelope
+     */
+    bool envelopeCovers(const geom::Geometry* g) const;
+
+public:
+    BasicPreparedGeometry(const Geometry* geom);
+
+    ~BasicPreparedGeometry() override = default;
+
+    const geom::Geometry&
+    getGeometry() const override
+    {
+        return *baseGeom;
+    }
+
+    /**
+     * Gets the list of representative points for this geometry.
+     * One vertex is included for every component of the geometry
+     * (i.e. including one for every ring of polygonal geometries)
+     *
+     * @return a List of Coordinate
+     */
+    const std::vector<const CoordinateXY*>*
+    getRepresentativePoints()  const
+    {
+        return &representativePts;
+    }
+
+    /**
+     * Tests whether any representative of the target geometry
+     * intersects the test geometry.
+     * This is useful in A/A, A/L, A/P, L/P, and P/P cases.
+     *
+     * @param testGeom the test geometry
+     * @return true if any component intersects the areal test geometry
+     */
+    bool isAnyTargetComponentInTest(const geom::Geometry* testGeom) const;
+
+    /**
+     * Default implementation.
+     */
+    bool within(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool contains(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool containsProperly(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool coveredBy(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool covers(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool crosses(const geom::Geometry* g) const override;
+
+    /**
+     * Standard implementation for all geometries.
+     * Supports {@link GeometryCollection}s as input.
+     */
+    bool disjoint(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool intersects(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool overlaps(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool touches(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    std::unique_ptr<IntersectionMatrix> relate(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool relate(const geom::Geometry* g, const std::string& pat) const override;
+
+    /**
+     * Default implementation.
+     */
+    std::unique_ptr<geom::CoordinateSequence> nearestPoints(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    double distance(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool isWithinDistance(const geom::Geometry* geom, double dist) const override;
+
+    std::string toString();
+
+};
+
+} // namespace geos::geom::prep
+} // namespace geos::geom
+} // namespace geos
+

package/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/geom/prep/PreparedGeometry.h

@@ -0,0 +1,260 @@
+/**********************************************************************
+ *
+ * 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: geom/prep/PreparedGeometry.java rev. 1.11 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <vector>
+#include <memory>
+#include <string>
+#include <geos/export.h>
+
+// Forward declarations
+namespace geos {
+    namespace geom {
+        class Geometry;
+        class Coordinate;
+        class CoordinateSequence;
+        class IntersectionMatrix;
+    }
+}
+
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+/**
+ * \class PreparedGeometry
+ *
+ * \brief
+ * An interface for classes which prepare {@link Geometry}s
+ * in order to optimize the performance
+ * of repeated calls to specific geometric operations.
+ *
+ * A given implementation may provide optimized implementations
+ * for only some of the specified methods,
+ * and delegate the remaining methods to the original {@link Geometry} operations.
+ * An implementation may also only optimize certain situations,
+ * and delegate others.
+ * See the implementing classes for documentation about which methods and situations
+ * they optimize.
+ *
+ */
+class GEOS_DLL PreparedGeometry {
+public:
+    virtual
+    ~PreparedGeometry() {}
+
+    /** \brief
+     * Gets the original {@link Geometry} which has been prepared.
+     *
+     * @return the base geometry
+     */
+    virtual const geom::Geometry& getGeometry() const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} contains a given geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry contains the given Geometry
+     *
+     * @see Geometry#contains(Geometry)
+     */
+    virtual bool contains(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} properly contains
+     * a given geometry.
+     *
+     * The <code>containsProperly</code> predicate has the following
+     * equivalent definitions:
+     *
+     * - Every point of the other geometry is a point of this
+     *   geometry's interior.
+     * - The DE-9IM Intersection Matrix for the two geometries matches
+     *   <code>[T**FF*FF*]</code>
+     *
+     * In other words, if the test geometry has any interaction with
+     * the boundary of the target
+     * geometry the result of <tt>containsProperly</tt> is <tt>false</tt>.
+     * This is different semantics to the {@link Geometry::contains}
+     * predicate, in which test geometries can intersect the target's
+     * boundary and still be contained.
+     *
+     * The advantage of using this predicate is that it can be computed
+     * efficiently, since it avoids the need to compute the full
+     * topological relationship of the input boundaries in cases where
+     * they intersect.
+     *
+     * An example use case is computing the intersections
+     * of a set of geometries with a large polygonal geometry.
+     * Since <tt>intersection</tt> is a fairly slow operation, it can
+     * be more efficient
+     * to use <tt>containsProperly</tt> to filter out test geometries
+     * which lie
+     * wholly inside the area.  In these cases the intersection is
+     * known <i>a priori</i> to be exactly the original test geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry properly contains the given Geometry
+     *
+     * @see Geometry::contains
+     *
+     */
+    virtual bool containsProperly(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} is covered by a given geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry is covered by the given Geometry
+     *
+     * @see Geometry#coveredBy(Geometry)
+     */
+    virtual bool coveredBy(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} covers a given geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry covers the given Geometry
+     *
+     * @see Geometry#covers(Geometry)
+     */
+    virtual bool covers(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} crosses a given geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry crosses the given Geometry
+     *
+     * @see Geometry#crosses(Geometry)
+     */
+    virtual bool crosses(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} is disjoint from a given geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry is disjoint from the given Geometry
+     *
+     * @see Geometry#disjoint(Geometry)
+     */
+    virtual bool disjoint(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} intersects a given geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry intersects the given Geometry
+     *
+     * @see Geometry#intersects(Geometry)
+     */
+    virtual bool intersects(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} overlaps a given geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry overlaps the given Geometry
+     *
+     * @see Geometry#overlaps(Geometry)
+     */
+    virtual bool overlaps(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} touches a given geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry touches the given Geometry
+     *
+     * @see Geometry#touches(Geometry)
+     */
+    virtual bool touches(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} is within a given geometry.
+     *
+     * @param geom the Geometry to test
+     * @return true if this Geometry is within the given Geometry
+     *
+     * @see Geometry#within(Geometry)
+     */
+    virtual bool within(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Compute the nearest locations on the base {@link Geometry} and
+     * the given geometry.
+     *
+     * @param geom the Geometry to compute the nearest point to
+     * @return true the nearest points
+     *
+     */
+    virtual std::unique_ptr<geom::CoordinateSequence> nearestPoints(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Compute the minimum distance between the base {@link Geometry} and
+     * the given geometry.
+     *
+     * @param geom the Geometry to compute the distance to
+     * @return the minimum distance between the two geometries
+     *
+     */
+    virtual double distance(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Tests whether the base {@link Geometry} is within a given
+     * distance from the given geometry.
+     *
+     * @param geom the Geometry to test the distance to
+     * @param dist the distance value to compare
+     * @return true if this Geometry is within the given distance from
+     * the given Geometry.
+     *
+     */
+    virtual bool isWithinDistance(const geom::Geometry* geom, double dist) const = 0;
+
+    /** \brief
+     * Compares the prepared geometry to the given geometry
+     * and returns the DE9IM intersection matrix as a string.
+     *
+     * @param geom the Geometry to test the
+     * @return the DE9IM matrix
+     */
+    virtual std::unique_ptr<IntersectionMatrix> relate(const geom::Geometry* geom) const = 0;
+
+    /** \brief
+     * Compares the prepared geometry to the given geometry
+     * and the provided DE9IM pattern, and returns true if the
+     * pattern is consistent with the relationship between the
+     * prepared and provided geometries.
+     *
+     * @param geom the Geometry to test the distance to
+     * @param pat the DE9IM pattern
+     * @return true if the patterns are consistent
+     */
+    virtual bool relate(const geom::Geometry* geom, const std::string& pat) const = 0;
+
+};
+
+
+} // namespace geos::geom::prep
+} // namespace geos::geom
+} // namespace geos
+