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

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e/Headers/geos/geom/Polygon.h

@@ -0,0 +1,237 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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.
+ *
+ **********************************************************************
+ *
+ * Last port: geom/Polygon.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <string>
+#include <vector>
+#include <geos/geom/Geometry.h> // for inheritance
+#include <geos/geom/Envelope.h> // for proper use of unique_ptr<>
+#include <geos/geom/LinearRing.h>
+#include <geos/geom/Dimension.h> // for Dimension::DimensionType
+
+#include <memory> // for unique_ptr
+
+// Forward declarations
+namespace geos {
+namespace geom { // geos::geom
+class Coordinate;
+class CoordinateSequenceFilter;
+class LineString;
+}
+}
+
+namespace geos {
+namespace geom { // geos::geom
+
+/**
+ * \class Polygon geom.h geos.h
+ *
+ * \brief Represents a linear polygon, which may include holes.
+ *
+ * The shell and holes of the polygon are represented by {@link LinearRing}s.
+ * In a valid polygon, holes may touch the shell or other holes at a single point.
+ * However, no sequence of touching holes may split the polygon into two pieces.
+ * The orientation of the rings in the polygon does not matter.
+ * <p>
+ *  The shell and holes must conform to the assertions specified in the <A
+ *  HREF="http://www.opengis.org/techno/specs.htm">OpenGIS Simple Features
+ *  Specification for SQL</A> .
+ *
+ */
+class GEOS_DLL Polygon: public Geometry {
+
+public:
+
+    friend class GeometryFactory;
+
+    /// A vector of const Polygon pointers
+    typedef std::vector<const Polygon*> ConstVect;
+
+    ~Polygon() override = default;
+
+    /**
+     * Creates and returns a full copy of this {@link Polygon} object.
+     * (including all coordinates contained by it).
+     *
+     * @return a clone of this instance
+     */
+    std::unique_ptr<Polygon> clone() const
+    {
+        return std::unique_ptr<Polygon>(cloneImpl());
+    }
+
+    std::unique_ptr<CoordinateSequence> getCoordinates() const override;
+
+    std::size_t getNumPoints() const override;
+
+    /// Returns surface dimension (2)
+    Dimension::DimensionType getDimension() const override;
+
+    /// Returns coordinate dimension.
+    uint8_t getCoordinateDimension() const override;
+
+    bool hasM() const override;
+
+    bool hasZ() const override;
+
+    /// Returns 1 (Polygon boundary is a MultiLineString)
+    int getBoundaryDimension() const override;
+
+    /** \brief
+     * Computes the boundary of this geometry
+     *
+     * @return a lineal geometry (which may be empty)
+     * @see Geometry#getBoundary
+     */
+    std::unique_ptr<Geometry> getBoundary() const override;
+
+    bool isEmpty() const override;
+
+    /// Returns the exterior ring (shell)
+    const LinearRing* getExteriorRing() const;
+
+    /**
+     * \brief
+     * Take ownership of this Polygon's exterior ring.
+     * After releasing the exterior ring, the Polygon 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<LinearRing> releaseExteriorRing();
+
+    /// Returns number of interior rings (hole)
+    std::size_t getNumInteriorRing() const;
+
+    /// Get nth interior ring (hole)
+    const LinearRing* getInteriorRingN(std::size_t n) const;
+
+    /**
+     * \brief
+     * Take ownership of this Polygon's interior rings.
+     * After releasing the rings, the Polygon 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<LinearRing>> releaseInteriorRings();
+
+    std::string getGeometryType() const override;
+    GeometryTypeId getGeometryTypeId() const override;
+    bool equalsExact(const Geometry* other, double tolerance = 0) const override;
+    bool equalsIdentical(const Geometry* other) const override;
+    void apply_rw(const CoordinateFilter* filter) override;
+    void apply_ro(CoordinateFilter* filter) const override;
+    void apply_rw(GeometryFilter* filter) override;
+    void apply_ro(GeometryFilter* filter) const override;
+    void apply_rw(CoordinateSequenceFilter& filter) override;
+    void apply_ro(CoordinateSequenceFilter& filter) const override;
+    void apply_rw(GeometryComponentFilter* filter) override;
+    void apply_ro(GeometryComponentFilter* filter) const override;
+
+    std::unique_ptr<Geometry> convexHull() const override;
+
+    void normalize() override;
+
+    /**
+     * \brief
+     * Apply a ring ordering convention to this polygon, with
+     * interior rings having an opposite orientation to the
+     * specified exterior orientation.
+     *
+     * \param exteriorCW should exterior ring be clockwise?
+     */
+    void orientRings(bool exteriorCW);
+
+    std::unique_ptr<Polygon> reverse() const { return std::unique_ptr<Polygon>(reverseImpl()); }
+
+    const CoordinateXY* getCoordinate() const override;
+
+    double getArea() const override;
+
+    /// Returns the perimeter of this <code>Polygon</code>
+    double getLength() const override;
+
+    bool isRectangle() const override;
+
+    const Envelope* getEnvelopeInternal() const override {
+        return shell->getEnvelopeInternal();
+    }
+
+protected:
+
+
+    Polygon(const Polygon& p);
+
+    int compareToSameClass(const Geometry* p) const override;
+
+    /**
+     * Constructs a <code>Polygon</code> with the given exterior
+     * and interior boundaries.
+     *
+     * @param  newShell  the outer boundary of the new Polygon,
+     *                   or <code>null</code> or an empty
+     *		     LinearRing if the empty geometry
+     *                   is to be created.
+     *
+     * @param  newHoles  the LinearRings defining the inner
+     *                   boundaries of the new Polygon, or
+     *                   null or empty LinearRing
+     *                   if the empty  geometry is to be created.
+     *
+     * @param newFactory the GeometryFactory used to create this geometry
+     *
+     * Polygon will take ownership of Shell and Holes LinearRings
+     */
+    Polygon(std::unique_ptr<LinearRing> && newShell,
+            std::vector<std::unique_ptr<LinearRing>> && newHoles,
+            const GeometryFactory& newFactory);
+
+    Polygon(std::unique_ptr<LinearRing> && newShell,
+            const GeometryFactory& newFactory);
+
+    Polygon* cloneImpl() const override { return new Polygon(*this); }
+
+    Polygon* reverseImpl() const override;
+
+    std::unique_ptr<LinearRing> shell;
+
+    std::vector<std::unique_ptr<LinearRing>> holes;
+
+    void geometryChangedAction() override {}
+
+    int
+    getSortIndex() const override
+    {
+        return SORTINDEX_POLYGON;
+    };
+
+
+private:
+
+    void normalize(LinearRing* ring, bool clockwise);
+
+};
+
+} // namespace geos::geom
+} // namespace geos
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e/Headers/geos/geom/Position.h

@@ -0,0 +1,68 @@
+/**********************************************************************
+ *
+ * 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/Position.java rev. 1.4 (JTS-1.10)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <map>
+#include <vector>
+#include <string>
+
+
+
+namespace geos {
+namespace geom { // geos.geom
+
+/** \brief
+ * A Position indicates the position of a Location relative to a graph
+ * component (Node, Edge, or Area).
+ */
+class GEOS_DLL Position {
+public:
+    enum {
+        /** \brief
+         * An indicator that a Location is *on*
+         * a GraphComponent
+         */
+        ON = 0,
+
+        /** \brief
+         * An indicator that a Location is to the
+         * *left* of a GraphComponent
+         */
+        LEFT,
+
+        /** \brief
+         * An indicator that a Location is to the
+         * *right* of a GraphComponent
+         */
+        RIGHT
+    };
+
+    /** \brief
+     * Returns LEFT if the position is RIGHT, RIGHT if
+     * the position is LEFT, or the position otherwise.
+     */
+    static int opposite(int position);
+};
+
+} // namespace geos.geom
+} // namespace geos
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e/Headers/geos/geom/PrecisionModel.h

@@ -0,0 +1,374 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * 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/PrecisionModel.java r378 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Coordinate.h>
+#include <geos/export.h>
+
+#include <cassert>
+#include <string>
+
+// Forward declarations
+namespace geos {
+namespace io {
+class Unload;
+}
+namespace geom {
+class Coordinate;
+}
+}
+
+namespace geos {
+namespace geom { // geos::geom
+
+/**
+ * \class PrecisionModel geom.h geos.h
+ *
+ * \brief Specifies the precision model of the Coordinate in a Geometry.
+ *
+ * In other words, specifies the grid of allowable points for a <code>Geometry</code>.
+ * A precision model may be <b>floating</b> (PrecisionModel::Type::FLOATING or
+ * PrecisionModel::Type::FLOATING_SINGLE), in which case normal floating-point value semantics apply.
+ *
+ * For a PrecisionModel::Type::FIXED precision model the
+ * makePrecise(geom::Coordinate) method allows rounding a coordinate to
+ * a "precise" value; that is, one whose precision is known exactly.
+ *
+ * Coordinates are assumed to be precise in geometries.
+ * That is, the coordinates are assumed to be rounded to the
+ * precision model given for the geometry.
+ * All internal operations
+ * assume that coordinates are rounded to the precision model.
+ * Constructive methods (such as boolean operations) always round computed
+ * coordinates to the appropriate precision model.
+ *
+ * Three types of precision model are supported:
+ * - FLOATING - represents full double precision floating point.
+ *   This is the default precision model used in JTS
+ * - FLOATING_SINGLE - represents single precision floating point.
+ * - FIXED - represents a model with a fixed number of decimal places.
+ *   A Fixed Precision Model is specified by a scale factor.
+ *   The scale factor specifies the grid which numbers are rounded to.
+ *   Input coordinates are mapped to fixed coordinates according to the
+ *   following equations:
+ *   - jtsPt.x = round( inputPt.x * scale ) / scale
+ *   - jtsPt.y = round( inputPt.y * scale ) / scale
+ *
+ * For example, to specify 3 decimal places of precision, use a scale factor
+ * of 1000. To specify -3 decimal places of precision (i.e. rounding to
+ * the nearest 1000), use a scale factor of 0.001.
+ *
+ * It is also supported to specify a precise grid size
+ * by providing it as a negative scale factor.
+ * For example, to specify rounding to the nearest 1000 use a scale factor of -1000.
+ *
+ * Coordinates are represented internally as Java double-precision values.
+ * Java uses the IEEE-394 floating point standard, which
+ * provides 53 bits of precision. (Thus the maximum precisely representable
+ * integer is 9,007,199,254,740,992).
+ *
+ */
+class GEOS_DLL PrecisionModel {
+    friend class io::Unload;
+
+public:
+
+    /// The types of Precision Model which GEOS supports.
+    typedef enum {
+
+        /**
+         * Fixed Precision indicates that coordinates have a fixed
+         * number of decimal places.
+         * The number of decimal places is determined by the log10
+         * of the scale factor.
+         */
+        FIXED,
+
+        /**
+         * Floating precision corresponds to the standard Java
+         * double-precision floating-point representation, which is
+         * based on the IEEE-754 standard
+         */
+        FLOATING,
+
+        /**
+         * Floating single precision corresponds to the standard Java
+         * single-precision floating-point representation, which is
+         * based on the IEEE-754 standard
+         */
+        FLOATING_SINGLE
+
+    } Type;
+
+    /// Creates a PrecisionModel with a default precision of FLOATING.
+    PrecisionModel(void);
+
+    /// Creates a PrecisionModel specifying an explicit precision model type.
+    ///
+    /// If the model type is FIXED the scale factor will default to 1.
+    ///
+    /// @param nModelType the type of the precision model
+    ///
+    PrecisionModel(Type nModelType);
+
+    /** \brief
+     * Creates a <code>PrecisionModel</code> with Fixed precision.
+     *
+     * Fixed-precision coordinates are represented as precise internal
+     * coordinates, which are rounded to the grid defined by the
+     * scale factor.
+     *
+     * @param  newScale  amount by which to multiply a coordinate after
+     *                   subtracting the offset, to obtain a precise coordinate
+     * @param  newOffsetX  not used.
+     * @param  newOffsetY  not used.
+     *
+     * @deprecated offsets are no longer supported, since internal
+     * representation is rounded floating point
+     */
+    PrecisionModel(double newScale, double newOffsetX, double newOffsetY);
+
+    /**
+     * \brief
+     * Creates a PrecisionModel with Fixed precision.
+     *
+     * Fixed-precision coordinates are represented as precise
+     * internal coordinates which are rounded to the grid defined
+     * by the scale factor.
+     * The provided scale may be negative, to specify an exact grid size.
+     * The scale is then computed as the reciprocal.
+     *
+     * @param newScale amount by which to multiply a coordinate
+     * after subtracting the offset, to obtain a precise coordinate. Must be non-zero.
+     */
+    PrecisionModel(double newScale);
+
+    /// The maximum precise value representable in a double.
+    ///
+    /// Since IEE754 double-precision numbers allow 53 bits of mantissa,
+    /// the value is equal to 2^53 - 1.
+    /// This provides <i>almost</i> 16 decimal digits of precision.
+    ////
+    static const double maximumPreciseValue;
+
+    /** \brief
+     * Rounds a numeric value to the PrecisionModel grid.
+     *
+     * Asymmetric Arithmetic Rounding is used, to provide
+     * uniform rounding behaviour no matter where the number is
+     * on the number line.
+     *
+     * <b>Note:</b> Java's <code>Math#rint</code> uses the "Banker's Rounding" algorithm,
+     * which is not suitable for precision operations elsewhere in JTS.
+     */
+    double makePrecise(double val) const;
+
+    /// Rounds the given Coordinate to the PrecisionModel grid.
+    void makePrecise(CoordinateXY& coord) const
+    {
+        // optimization for full precision
+        if(modelType == FLOATING) {
+            return;
+        }
+
+        coord.x = makePrecise(coord.x);
+        coord.y = makePrecise(coord.y);
+    };
+
+    void makePrecise(CoordinateXY* coord) const
+    {
+        assert(coord);
+        return makePrecise(*coord);
+    };
+
+    /// Tests whether the precision model supports floating point
+    ///
+    /// @return <code>true</code> if the precision model supports
+    /// floating point
+    ///
+    bool isFloating() const;
+
+    /// \brief
+    /// Returns the maximum number of significant digits provided by
+    /// this precision model.
+    ///
+    /// Intended for use by routines which need to print out precise
+    /// values.
+    ///
+    /// @return the maximum number of decimal places provided by this
+    /// precision model
+    ///
+    int getMaximumSignificantDigits() const;
+
+    /// Gets the type of this PrecisionModel
+    ///
+    /// @return the type of this PrecisionModel
+    ///
+    Type getType() const
+    {
+        return modelType;
+    };
+
+    /// Returns the multiplying factor used to obtain a precise coordinate.
+    double getScale() const
+    {
+        assert(!(scale < 0));
+        return scale;
+    };
+
+    /**
+    * Computes the grid size for a fixed precision model.
+    * This is equal to the reciprocal of the scale factor.
+    * If the grid size has been set explicity (via a negative scale factor)
+    * it will be returned.
+    *
+    * @return the grid size at a fixed precision scale.
+    */
+    double getGridSize() const
+    {
+        if (isFloating())
+           return DoubleNotANumber;
+
+        if (gridSize != 0)
+            return gridSize;
+
+        return 1.0 / scale;
+    };
+
+    /// Returns the x-offset used to obtain a precise coordinate.
+    ///
+    /// @return the amount by which to subtract the x-coordinate before
+    ///         multiplying by the scale
+    /// @deprecated Offsets are no longer used
+    ///
+    double getOffsetX() const;
+
+    /// Returns the y-offset used to obtain a precise coordinate.
+    ///
+    /// @return the amount by which to subtract the y-coordinate before
+    ///         multiplying by the scale
+    /// @deprecated Offsets are no longer used
+    ///
+    double getOffsetY() const;
+
+    /*
+     *  Sets ´internal` to the precise representation of `external`.
+     *
+     * @param external the original coordinate
+     * @param internal the coordinate whose values will be changed to the
+     *                 precise representation of <code>external</code>
+     * @deprecated use makePrecise instead
+     */
+    //void toInternal(const Coordinate& external, Coordinate* internal) const;
+
+    /*
+     *  Returns the precise representation of <code>external</code>.
+     *
+     *@param  external  the original coordinate
+     *@return
+     *	the coordinate whose values will be changed to the precise
+     *	representation of <code>external</code>
+     * @deprecated use makePrecise instead
+     */
+    //Coordinate* toInternal(const Coordinate& external) const;
+
+    /*
+     *  Returns the external representation of <code>internal</code>.
+     *
+     *@param  internal  the original coordinate
+     *@return           the coordinate whose values will be changed to the
+     *      external representation of <code>internal</code>
+     * @deprecated no longer needed, since internal representation is same as external representation
+     */
+    //Coordinate* toExternal(const Coordinate& internal) const;
+
+    /*
+     *  Sets <code>external</code> to the external representation of
+     *  <code>internal</code>.
+     *
+     * @param  internal  the original coordinate
+     * @param  external
+     *	the coordinate whose values will be changed to the
+     *	external representation of <code>internal</code>
+     * @deprecated no longer needed, since internal representation is same as external representation
+     */
+    //void toExternal(const Coordinate& internal, Coordinate* external) const;
+
+    std::string toString() const;
+
+    /// \brief
+    /// Compares this PrecisionModel object with the specified object
+    /// for order.
+    ///
+    /// A PrecisionModel is greater than another if it provides greater
+    /// precision.
+    /// The comparison is based on the value returned by the
+    /// getMaximumSignificantDigits method.
+    /// This comparison is not strictly accurate when comparing floating
+    /// precision models to fixed models;
+    /// however, it is correct when both models are either floating or
+    /// fixed.
+    ///
+    /// @param other the PrecisionModel with which this PrecisionModel
+    ///      is being compared
+    /// @return a negative integer, zero, or a positive integer as this
+    ///      PrecisionModel is less than, equal to, or greater than the
+    ///      specified PrecisionModel.
+    ///
+    int compareTo(const PrecisionModel* other) const;
+
+private:
+
+    /** \brief
+     * Sets the multiplying factor used to obtain a precise coordinate.
+     *
+     * This method is private because PrecisionModel is intended to
+     * be an immutable (value) type.
+     *
+     */
+    void setScale(double newScale);
+    // throw IllegalArgumentException
+
+    /** \brief
+     * Snaps a value to nearest integer, if within tolerance.
+     */
+    static double snapToInt(double val, double tolerance);
+
+    Type modelType;
+
+    /**
+    * The scale factor which determines the number of decimal places in fixed precision.
+    */
+    double scale;
+
+    /**
+    * If non-zero, the precise grid size specified.
+    * In this case, the scale is also valid and is computed from the grid size.
+    * If zero, the scale is used to compute the grid size where needed.
+    */
+    double gridSize = 0.0;
+
+};
+
+// Equality operator for PrecisionModel, deprecate it ?
+//inline bool operator==(const PrecisionModel& a, const PrecisionModel& b);
+
+} // namespace geos::geom
+} // namespace geos