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

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/geom/prep/PreparedPolygonIntersects.h

@@ -0,0 +1,90 @@
+/**********************************************************************
+ *
+ * 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/PreparedPolygonIntersects.java rev 1.6 (JTS-1.10)
+ * (2007-12-12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/prep/PreparedPolygonPredicate.h> // inherited
+
+namespace geos {
+namespace geom {
+class Geometry;
+
+namespace prep {
+class PreparedPolygon;
+}
+}
+}
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+/**
+ * \brief
+ * Computes the <tt>intersects</tt> spatial relationship predicate
+ * for {@link PreparedPolygon}s relative to all other {@link Geometry} classes.
+ *
+ * Uses short-circuit tests and indexing to improve performance.
+ *
+ * @author Martin Davis
+ *
+ */
+class PreparedPolygonIntersects : public PreparedPolygonPredicate {
+private:
+protected:
+public:
+    /** \brief
+     * Computes the intersects predicate between a {@link PreparedPolygon}
+     * and a {@link Geometry}.
+     *
+     * @param prep the prepared polygon
+     * @param geom a test geometry
+     * @return true if the polygon intersects the geometry
+     */
+    static bool
+    intersects(const PreparedPolygon* const prep, const geom::Geometry* geom)
+    {
+        PreparedPolygonIntersects polyInt(prep);
+        return polyInt.intersects(geom);
+    }
+
+    /** \brief
+     * Creates an instance of this operation.
+     *
+     * @param prep the PreparedPolygon to evaluate
+     */
+    PreparedPolygonIntersects(const PreparedPolygon* const prep)
+        :	PreparedPolygonPredicate(prep)
+    { }
+
+    /** \brief
+     * Tests whether this PreparedPolygon intersects a given geometry.
+     *
+     * @param geom the test geometry
+     * @return true if the test geometry intersects
+     */
+    bool intersects(const geom::Geometry* geom);
+
+};
+
+} // geos::geom::prep
+} // geos::geom
+} // geos
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/geom/prep/PreparedPolygonPredicate.h

@@ -0,0 +1,141 @@
+/**********************************************************************
+ *
+ * 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/PreparedPolygonPredicate.java rev. 1.4 (JTS-1.10)
+ * (2007-12-12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Location.h>
+
+// forward declarations
+namespace geos {
+namespace algorithm {
+namespace locate {
+class PointOnGeometryLocator;
+}
+}
+namespace geom {
+class Geometry;
+
+namespace prep {
+class PreparedPolygon;
+}
+}
+namespace noding {
+class FastSegmentSetIntersectionFinder;
+}
+}
+
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+/**
+ * \brief
+ * A base class for predicate operations on {@link PreparedPolygon}s.
+ *
+ * @author mbdavis
+ *
+ */
+class PreparedPolygonPredicate {
+private:
+    // Declare type as noncopyable
+    PreparedPolygonPredicate(const PreparedPolygonPredicate& other) = delete;
+    PreparedPolygonPredicate& operator=(const PreparedPolygonPredicate& rhs) = delete;
+
+protected:
+    const PreparedPolygon* const prepPoly;
+
+    /** \brief
+     * Returns the outermost Location among a test point from each
+     * components of the test geometry.
+     *
+     * @param testGeom a geometry to test
+     * @return the outermost Location
+     */
+    geom::Location getOutermostTestComponentLocation(const geom::Geometry* testGeom) const;
+
+    /** \brief
+     * Tests whether all components of the test Geometry
+     * are contained in the interior of the target geometry.
+     *
+     * Handles both linear and point components.
+     *
+     * @param testGeom a geometry to test
+     * @return true if all componenta of the argument are contained in
+     *              the target geometry interior
+     */
+    bool isAllTestComponentsInTargetInterior(const geom::Geometry* testGeom) const;
+
+    /** \brief
+     * Tests whether any component of the test Geometry intersects
+     * the area of the target geometry.
+     *
+     * Handles test geometries with both linear and point components.
+     *
+     * @param testGeom a geometry to test
+     * @return true if any component of the argument intersects the
+     *              prepared geometry
+     */
+    bool isAnyTestComponentInTarget(const geom::Geometry* testGeom) const;
+
+    /** \brief
+     * Tests whether any component of the test Geometry intersects
+     * the interior of the target geometry.
+     *
+     * Handles test geometries with both linear and point components.
+     *
+     * @param testGeom a geometry to test
+     * @return true if any component of the argument intersects the
+     *              prepared area geometry interior
+     */
+    bool isAnyTestComponentInTargetInterior(const geom::Geometry* testGeom) const;
+
+    /**
+     * Tests whether any component of the target geometry
+     * intersects the test geometry (which must be an areal geometry)
+     *
+     * @param testGeom the test geometry
+     * @param targetRepPts the representative points of the target geometry
+     * @return true if any component intersects the areal test geometry
+     */
+    bool isAnyTargetComponentInAreaTest(const geom::Geometry* testGeom,
+                                        const std::vector<const geom::CoordinateXY*>* targetRepPts) const;
+
+public:
+    /** \brief
+     * Creates an instance of this operation.
+     *
+     * @param p_prepPoly the PreparedPolygon to evaluate
+     */
+    PreparedPolygonPredicate(const PreparedPolygon* const p_prepPoly)
+        :	prepPoly(p_prepPoly)
+    { }
+
+    virtual
+    ~PreparedPolygonPredicate()
+    { }
+
+};
+
+} // namespace geos::geom::prep
+} // namespace geos::geom
+} // namespace geos
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/geom/util/ComponentCoordinateExtracter.h

@@ -0,0 +1,69 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <vector>
+
+#include <geos/geom/GeometryComponentFilter.h>
+#include <geos/geom/Geometry.h> // to be removed when we have the .inl
+#include <geos/geom/Coordinate.h> // to be removed when we have the .inl
+#include <geos/geom/LineString.h> // to be removed when we have the .inl
+#include <geos/geom/Point.h> // to be removed when we have the .inl
+
+namespace geos {
+namespace geom { // geos::geom
+namespace util { // geos::geom::util
+
+/** \brief
+ * Extracts a single representative {@link Coordinate}
+ * from each connected component of a {@link Geometry}.
+ *
+ * @version 1.9
+ */
+class ComponentCoordinateExtracter : public GeometryComponentFilter {
+public:
+    /**
+     * Push the linear components from a single geometry into
+     * the provided vector.
+     * If more than one geometry is to be processed, it is more
+     * efficient to create a single ComponentCoordinateFilter instance
+     * and pass it to multiple geometries.
+     */
+    static void getCoordinates(const Geometry& geom, std::vector<const CoordinateXY*>& ret);
+
+    /**
+     * Constructs a ComponentCoordinateFilter with a list in which
+     * to store Coordinates found.
+     */
+    ComponentCoordinateExtracter(std::vector<const CoordinateXY*>& newComps);
+
+    void filter_rw(Geometry* geom) override;
+
+    void filter_ro(const Geometry* geom) override;
+
+private:
+
+    std::vector<const CoordinateXY*>& comps;
+
+    // Declare type as noncopyable
+    ComponentCoordinateExtracter(const ComponentCoordinateExtracter& other) = delete;
+    ComponentCoordinateExtracter& operator=(const ComponentCoordinateExtracter& rhs) = delete;
+};
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/geom/util/CoordinateOperation.h

@@ -0,0 +1,70 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/util/GeometryEditorOperation.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class CoordinateSequence;
+class GeometryFactory;
+}
+}
+
+
+namespace geos {
+namespace geom { // geos.geom
+namespace util { // geos.geom.util
+
+/**
+ * A GeometryEditorOperation which modifies the coordinate list of a
+ * Geometry.
+ * Operates on Geometry subclasses which contains a single coordinate list.
+ */
+class GEOS_DLL CoordinateOperation: public GeometryEditorOperation {
+
+public:
+
+    /**
+     * Return a newly created geometry, ownership to caller
+     */
+    std::unique_ptr<Geometry> edit(const Geometry* geometry,
+                                   const GeometryFactory* factory) override;
+
+    /**
+     * Edits the array of Coordinate from a Geometry.
+     *
+     * @param coordinates the coordinate array to operate on
+     * @param geometry the geometry containing the coordinate list
+     * @return an edited coordinate array (which may be the same as
+     *         the input)
+     */
+    virtual std::unique_ptr<CoordinateSequence> edit(const CoordinateSequence* coordinates,
+                                                     const Geometry* geometry) = 0;
+
+
+    ~CoordinateOperation() override = default;
+};
+
+
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/geom/util/Densifier.h

@@ -0,0 +1,90 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2010 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 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: operation/polygonize/Polygonizer.java rev. 1.6 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Geometry.h>
+#include <geos/geom/util/GeometryTransformer.h>
+#include <geos/geom/util/Densifier.h>
+#include <geos/util/Interrupt.h>
+
+#include <vector>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+/* warning C4251: needs to have dll-interface to be used by */
+/* clients of class */
+#pragma warning(disable: 4251)
+#endif
+
+
+namespace geos {
+namespace geom {
+namespace util {
+
+/**
+ * Densifies a {@link Geometry} by inserting extra vertices along the line segments
+ * contained in the geometry.
+ * All segments in the created densified geometry will be no longer than
+ * than the given distance tolerance.
+ * Densified polygonal geometries are guaranteed to be topologically correct.
+ * The coordinates created during densification respect the input geometry's
+ * {@link PrecisionModel}.
+ * <p>
+ * <b>Note:</b> At some future point this class will
+ * offer a variety of densification strategies.
+ *
+ * @author Martin Davis
+ */
+class GEOS_DLL Densifier {
+public:
+    Densifier(const Geometry* inputGeom);
+
+    static Geometry::Ptr densify(const Geometry* geom, double distanceTolerance);
+    void setDistanceTolerance(double distanceTolerance);
+    Geometry::Ptr getResultGeometry() const;
+
+private:
+    double distanceTolerance;
+    const Geometry* inputGeom;
+    static std::unique_ptr<CoordinateSequence> densifyPoints(const CoordinateSequence& pts, double distanceTolerance,
+            const PrecisionModel* precModel);
+
+    class GEOS_DLL DensifyTransformer: public GeometryTransformer {
+    public:
+        DensifyTransformer(double distanceTolerance);
+        double distanceTolerance;
+        CoordinateSequence::Ptr transformCoordinates(const CoordinateSequence* coords, const Geometry* parent) override;
+        Geometry::Ptr transformPolygon(const Polygon* geom, const Geometry* parent) override;
+        Geometry::Ptr transformMultiPolygon(const MultiPolygon* geom, const Geometry* parent) override;
+        Geometry::Ptr createValidArea(const Geometry* roughAreaGeom);
+    };
+
+}; // Densifier
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/geom/util/GeometryCombiner.h

@@ -0,0 +1,151 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2006-2011 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/util/GeometryCombiner.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include <geos/export.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class GeometryFactory;
+}
+}
+
+namespace geos {
+namespace geom { // geos.geom
+namespace util { // geos.geom.util
+
+/** \brief
+ * Combines [Geometrys](@ref Geometry) to produce a GeometryCollection
+ * of the most appropriate type.
+ *
+ * Input geometries which are already collections will have their elements
+ * extracted first.
+ * No validation of the result geometry is performed.
+ * (The only case where invalidity is possible is where polygonal geometries
+ * are combined and result in a self-intersection).
+ *
+ * @see GeometryFactory#buildGeometry
+ */
+class GEOS_DLL GeometryCombiner {
+public:
+    /** \brief
+     * Copies a collection of geometries and combines the result.
+     *
+     * @param geoms the geometries to combine (ownership left to caller)
+     * @return the combined geometry
+     */
+    static std::unique_ptr<Geometry> combine(std::vector<const Geometry*> const& geoms);
+
+    /** \brief
+     * Combines a collection of geometries.
+     *
+     * @param geoms the geometries to combine (ownership transferred to combined geometry)
+     * @return the combined geometry
+     */
+    static std::unique_ptr<Geometry> combine(std::vector<std::unique_ptr<Geometry>> && geoms);
+
+    /** \brief
+     * Copies two geometries and combines the result.
+     *
+     * @param g0 a geometry to combine (ownership left to caller)
+     * @param g1 a geometry to combine (ownership left to caller)
+     * @return the combined geometry
+     */
+    static std::unique_ptr<Geometry> combine(const Geometry* g0, const Geometry* g1);
+
+    /** \brief
+     * Combines two geometries.
+     *
+     * @param g0 a geometry to combine (ownership transferred to combined geometry)
+     * @param g1 a geometry to combine (ownership transferred to combined geometry)
+     * @return the combined geometry
+     */
+    static std::unique_ptr<Geometry> combine(std::unique_ptr<Geometry> && g0,
+                                             std::unique_ptr<Geometry> && g1);
+
+    /** \brief
+     * Copies three geometries and combines the result.
+     *
+     * @param g0 a geometry to combine (ownership left to caller)
+     * @param g1 a geometry to combine (ownership left to caller)
+     * @param g2 a geometry to combine (ownership left to caller)
+     * @return the combined geometry
+     */
+    static std::unique_ptr<Geometry> combine(const Geometry* g0, const Geometry* g1, const Geometry* g2);
+
+    /** \brief
+     * Combines three geometries.
+     *
+     * @param g0 a geometry to combine (ownership transferred to combined geometry)
+     * @param g1 a geometry to combine (ownership transferred to combined geometry)
+     * @param g2 a geometry to combine (ownership transferred to combined geometry)
+     * @return the combined geometry
+     */
+    static std::unique_ptr<Geometry> combine(std::unique_ptr<Geometry> && g0,
+                                             std::unique_ptr<Geometry> && g1,
+                                             std::unique_ptr<Geometry> && g2);
+
+private:
+    std::vector<std::unique_ptr<Geometry>> inputGeoms;
+    bool skipEmpty;
+
+public:
+    /** \brief
+     * Creates a new combiner for a collection of geometries.
+     *
+     * @param geoms the geometries to combine
+     */
+    explicit GeometryCombiner(std::vector<const Geometry*> const& geoms);
+
+    explicit GeometryCombiner(std::vector<std::unique_ptr<Geometry>> && geoms);
+
+    /** \brief
+     * Extracts the GeometryFactory used by the geometries in a collection.
+     *
+     * @return a GeometryFactory
+     */
+    GeometryFactory const* extractFactory() const;
+
+    /** \brief
+     * Computes the combination of the input geometries
+     * to produce the most appropriate Geometry or GeometryCollection.
+     *
+     * @return a Geometry which is the combination of the inputs
+     */
+    std::unique_ptr<Geometry> combine();
+
+    /** \brief
+     * Set a flag indicating that empty geometries should be omitted from the result.
+     */
+    void setSkipEmpty(bool);
+
+    // Declare type as noncopyable
+    GeometryCombiner(const GeometryCombiner& other) = delete;
+    GeometryCombiner& operator=(const GeometryCombiner& rhs) = delete;
+};
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+