@cpp.js/package-geos 1.0.0 → 2.0.0-beta.2

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/precision/CommonBits.h

@@ -1,97 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2005-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 <cstdint>
-
-namespace geos {
-namespace precision { // geos.precision
-
-/** \brief
- * Determines the maximum number of common most-significant
- * bits in the mantissa of one or numbers.
- *
- * Can be used to compute the double-precision number which
- * is represented by the common bits.
- * If there are no common bits, the number computed is 0.0.
- *
- */
-class GEOS_DLL CommonBits {
-
-private:
-
-    bool isFirst;
-
-    int commonMantissaBitsCount;
-
-    int64_t commonBits;
-
-    int64_t commonSignExp;
-
-public:
-
-    /** \brief
-     * Computes the bit pattern for the sign and exponent of a
-     * double-precision number.
-     *
-     * @param num
-     * @return the bit pattern for the sign and exponent
-     */
-    static int64_t signExpBits(int64_t num);
-
-    /** \brief
-     * This computes the number of common most-significant
-     * bits in the mantissas of two double-precision numbers.
-     *
-     * It does not count the hidden bit, which is always 1.
-     * It does not determine whether the numbers have the same
-     * exponent - if they do not, the value computed by this
-     * function is meaningless.
-     * @param num1
-     * @param num2
-     * @return the number of common most-significant mantissa bits
-     */
-    static int numCommonMostSigMantissaBits(int64_t num1, int64_t num2);
-
-    /** \brief
-     * Zeroes the lower n bits of a bitstring.
-     *
-     * @param bits the bitstring to alter
-     * @param nBits the number of bits to zero
-     * @return the zeroed bitstring
-     */
-    static int64_t zeroLowerBits(int64_t bits, int nBits);
-
-    /** \brief
-     * Extracts the i'th bit of a bitstring.
-     *
-     * @param bits the bitstring to extract from
-     * @param i the bit to extract
-     * @return the value of the extracted bit
-     */
-    static int getBit(int64_t bits, int i);
-
-    CommonBits();
-
-    void add(double num);
-
-    double getCommon();
-
-};
-
-} // namespace geos.precision
-} // namespace geos
-

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/precision/CommonBitsOp.h

@@ -1,172 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2005-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/precision/CommonBitsRemover.h> // for unique_ptr composition
-
-#include <vector>
-#include <memory>
-
-#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
-
-namespace geos {
-namespace geom {
-class Geometry;
-}
-namespace precision {
-//class CommonBitsRemover;
-}
-}
-
-namespace geos {
-namespace precision { // geos.precision
-
-/** \brief
- * Provides versions of Geometry spatial functions which use
- * common bit removal to reduce the likelihood of robustness problems.
- *
- * In the current implementation no rounding is performed on the
- * reshifted result geometry, which means that it is possible
- * that the returned Geometry is invalid.
- * Client classes should check the validity of the returned result themselves.
- */
-class GEOS_DLL CommonBitsOp {
-
-private:
-
-    bool returnToOriginalPrecision;
-
-    std::unique_ptr<CommonBitsRemover> cbr;
-
-    /** \brief
-     * Computes a copy of the input Geometry with the calculated
-     * common bits removed from each coordinate.
-     *
-     * @param geom0 the Geometry to remove common bits from
-     * @return a copy of the input Geometry with common bits removed
-     *         (caller takes responsibility of its deletion)
-     */
-    std::unique_ptr<geom::Geometry> removeCommonBits(const geom::Geometry* geom0);
-
-    /** \brief
-     *
-     */
-    void removeCommonBits(
-        const geom::Geometry* geom0,
-        const geom::Geometry* geom1,
-        std::unique_ptr<geom::Geometry>& rgeom0,
-        std::unique_ptr<geom::Geometry>& rgeom1);
-
-
-public:
-
-    /** \brief
-     * Creates a new instance of class, which reshifts result Geometry
-     */
-    CommonBitsOp();
-
-    /** \brief
-     * Creates a new instance of class, specifying whether
-     * the result {@link geom::Geometry}s should be reshifted.
-     *
-     * @param nReturnToOriginalPrecision
-     */
-    CommonBitsOp(bool nReturnToOriginalPrecision);
-
-    /** \brief
-     * Computes the set-theoretic intersection of two Geometry,
-     * using enhanced precision.
-     * @param geom0 the first Geometry
-     * @param geom1 the second Geometry
-     * @return the Geometry representing the set-theoretic
-     *  intersection of the input Geometries.
-     */
-    std::unique_ptr<geom::Geometry> intersection(
-        const geom::Geometry* geom0,
-        const geom::Geometry* geom1);
-
-    /** \brief
-     * Computes the set-theoretic union of two Geometry,
-     * using enhanced precision.
-     * @param geom0 the first Geometry
-     * @param geom1 the second Geometry
-     * @return the Geometry representing the set-theoretic union
-     * of the input Geometries.
-     */
-    std::unique_ptr<geom::Geometry> Union(
-        const geom::Geometry* geom0,
-        const geom::Geometry* geom1);
-
-    /** \brief
-     * Computes the set-theoretic difference of two Geometry,
-     * using enhanced precision.
-     * @param geom0 the first Geometry
-     * @param geom1 the second Geometry, to be subtracted from the first
-     * @return the Geometry representing the set-theoretic difference
-     * of the input Geometries.
-     */
-    std::unique_ptr<geom::Geometry> difference(
-        const geom::Geometry* geom0,
-        const geom::Geometry* geom1);
-
-    /** \brief
-     * Computes the set-theoretic symmetric difference of two geometries,
-     * using enhanced precision.
-     * @param geom0 the first Geometry
-     * @param geom1 the second Geometry
-     * @return the Geometry representing the set-theoretic symmetric
-     * difference of the input Geometries.
-     */
-    std::unique_ptr<geom::Geometry> symDifference(
-        const geom::Geometry* geom0,
-        const geom::Geometry* geom1);
-
-    /** \brief
-     * Computes the buffer a geometry,
-     * using enhanced precision.
-     * @param geom0 the Geometry to buffer
-     * @param distance the buffer distance
-     * @return the Geometry representing the buffer of the input Geometry.
-     */
-    std::unique_ptr<geom::Geometry> buffer(
-        const geom::Geometry* geom0,
-        double distance);
-
-    /** \brief
-     * If required, returning the result to the original precision
-     * if required.
-     *
-     * In this current implementation, no rounding is performed on the
-     * reshifted result geometry, which means that it is possible
-     * that the returned Geometry is invalid.
-     *
-     * @param result the result Geometry to modify
-     * @return the result Geometry with the required precision
-     */
-    std::unique_ptr<geom::Geometry> computeResultPrecision(
-        std::unique_ptr<geom::Geometry> result);
-};
-
-} // namespace geos.precision
-} // namespace geos
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/precision/CommonBitsRemover.h

@@ -1,92 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2005-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/Coordinate.h> // for composition
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Geometry;
-}
-namespace precision {
-class CommonBitsRemover;
-class CommonCoordinateFilter;
-}
-}
-
-namespace geos {
-namespace precision { // geos.precision
-
-/** \brief
- * Allow computing and removing common mantissa bits from one or
- * more Geometries.
- *
- */
-class GEOS_DLL CommonBitsRemover {
-
-private:
-
-    geom::Coordinate commonCoord;
-
-    CommonCoordinateFilter* ccFilter;
-
-    CommonBitsRemover(const CommonBitsRemover&) = delete;
-    CommonBitsRemover& operator=(const CommonBitsRemover&) = delete;
-
-public:
-
-    CommonBitsRemover();
-
-    ~CommonBitsRemover();
-
-    /**
-     * Add a geometry to the set of geometries whose common bits are
-     * being computed.  After this method has executed the
-     * common coordinate reflects the common bits of all added
-     * geometries.
-     *
-     * @param geom a Geometry to test for common bits
-     */
-    void add(const geom::Geometry* geom);
-
-    /**
-     * The common bits of the Coordinates in the supplied Geometries.
-     */
-    geom::Coordinate& getCommonCoordinate();
-
-    /** \brief
-     * Removes the common coordinate bits from a Geometry.
-     * The coordinates of the Geometry are changed.
-     *
-     * @param geom the Geometry from which to remove the common
-     *             coordinate bits
-     */
-    void removeCommonBits(geom::Geometry* geom);
-
-    /** \brief
-     * Adds the common coordinate bits back into a Geometry.
-     * The coordinates of the Geometry are changed.
-     *
-     * @param geom the Geometry to which to add the common coordinate bits
-     * @return the shifted Geometry
-     */
-    geom::Geometry* addCommonBits(geom::Geometry* geom);
-};
-
-} // namespace geos.precision
-} // namespace geos
-

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/precision/EnhancedPrecisionOp.h

@@ -1,105 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2005-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: precision/EnhancedPrecisionOp.java rev. 1.9 (JTS-1.7)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <geos/constants.h> // for int64
-#include <geos/geom/Geometry.h>
-
-#include <memory>
-
-namespace geos {
-namespace precision { // geos.precision
-
-/** \brief
- * Provides versions of Geometry spatial functions which use
- * enhanced precision techniques to reduce the likelihood of robustness
- * problems.
- */
-class GEOS_DLL EnhancedPrecisionOp {
-
-public:
-
-    /** \brief
-     * Computes the set-theoretic intersection of two
-     * Geometrys, using enhanced precision.
-     *
-     * @param geom0 the first Geometry
-     * @param geom1 the second Geometry
-     * @return the Geometry representing the set-theoretic
-     * intersection of the input Geometries.
-     */
-    static std::unique_ptr<geom::Geometry> intersection(
-        const geom::Geometry* geom0,
-        const geom::Geometry* geom1);
-
-    /**
-     * Computes the set-theoretic union of two Geometrys,
-     * using enhanced precision.
-     * @param geom0 the first Geometry
-     * @param geom1 the second Geometry
-     * @return the Geometry representing the set-theoretic
-     * union of the input Geometries.
-     */
-    static std::unique_ptr<geom::Geometry> Union(
-        const geom::Geometry* geom0,
-        const geom::Geometry* geom1);
-
-    /**
-     * Computes the set-theoretic difference of two Geometrys,
-     * using enhanced precision.
-     * @param geom0 the first Geometry
-     * @param geom1 the second Geometry
-     * @return the Geometry representing the set-theoretic
-     * difference of the input Geometries.
-     */
-    static std::unique_ptr<geom::Geometry> difference(
-        const geom::Geometry* geom0,
-        const geom::Geometry* geom1);
-
-    /**
-     * Computes the set-theoretic symmetric difference of two
-     * Geometrys, using enhanced precision.
-     * @param geom0 the first Geometry
-     * @param geom1 the second Geometry
-     * @return the Geometry representing the set-theoretic symmetric
-     * difference of the input Geometries.
-     */
-    static std::unique_ptr<geom::Geometry> symDifference(
-        const geom::Geometry* geom0,
-        const geom::Geometry* geom1);
-
-    /**
-     * Computes the buffer of a Geometry, using enhanced precision.
-     * This method should no longer be necessary, since the buffer
-     * algorithm now is highly robust.
-     *
-     * @param geom the first Geometry
-     * @param distance the buffer distance
-     * @return the Geometry representing the buffer of the input Geometry.
-     */
-    static std::unique_ptr<geom::Geometry> buffer(
-        const geom::Geometry* geom,
-        double distance);
-};
-
-
-} // namespace geos.precision
-} // namespace geos
-

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/precision/GeometryPrecisionReducer.h

@@ -1,202 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2012 Sandro Santilli <strk@kbt.io>
- *
- * 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: precision/GeometryPrecisionReducer.cpp rev. 1.10 (JTS-1.7)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <geos/geom/GeometryFactory.h> // for GeometryFactory::Ptr
-#include <memory> // for unique_ptr
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class PrecisionModel;
-class GeometryFactory;
-class Geometry;
-}
-}
-
-namespace geos {
-namespace precision { // geos.precision
-
-/** \brief
- * Reduces the precision of a {@link geom::Geometry}
- * according to the supplied {@link geom::PrecisionModel},
- * ensuring that the result is valid (unless specified otherwise).
- *
- * By default the reduced result is topologically valid
- * To ensure this a polygonal geometry is reduced in a topologically valid fashion
- * (technically, by using snap-rounding).
- * It can be forced to be reduced pointwise by using setPointwise(boolean).
- * Note that in this case the result geometry may be invalid.
- * Linear and point geometry is always reduced pointwise (i.e. without further change to
- * its topology or structure), since this does not change validity.
- *
- * By default the geometry precision model is not changed.
- * This can be overridden by usingsetChangePrecisionModel(boolean).
- *
- * Normally collapsed components (e.g. lines collapsing to a point)
- * are not included in the result.
- * This behavior can be changed by using setRemoveCollapsedComponents(boolean).
- */
-class GEOS_DLL GeometryPrecisionReducer {
-
-private:
-
-    // Externally owned
-    const geom::GeometryFactory* newFactory;
-
-    const geom::PrecisionModel& targetPM;
-
-    bool removeCollapsed;
-    bool changePrecisionModel;
-    bool useAreaReducer;
-    bool isPointwise;
-
-    std::unique_ptr<geom::Geometry> fixPolygonalTopology(const geom::Geometry& geom);
-
-    geom::GeometryFactory::Ptr createFactory(
-        const geom::GeometryFactory& oldGF,
-        const geom::PrecisionModel& newPM);
-
-    /**
-    * Duplicates a geometry to one that uses a different PrecisionModel,
-    * without changing any coordinate values.
-    *
-    * @param geom the geometry to duplicate
-    * @param newPM the precision model to use
-    * @return the geometry value with a new precision model
-    */
-    std::unique_ptr<geom::Geometry> changePM(
-        const geom::Geometry* geom,
-        const geom::PrecisionModel& newPM);
-
-    GeometryPrecisionReducer(GeometryPrecisionReducer const&); /*= delete*/
-    GeometryPrecisionReducer& operator=(GeometryPrecisionReducer const&); /*= delete*/
-
-public:
-
-    /**
-     * Convenience method for doing precision reduction
-     * on a single geometry,
-     * with collapses removed
-     * and keeping the geometry precision model the same,
-     * and preserving polygonal topology.
-     *
-     * @param g the geometry to reduce
-     * @param precModel the precision model to use
-     * @return the reduced geometry
-     */
-    static std::unique_ptr<geom::Geometry>
-    reduce(const geom::Geometry& g, const geom::PrecisionModel& precModel);
-
-    static std::unique_ptr<geom::Geometry>
-    reducePointwise(const geom::Geometry& g, const geom::PrecisionModel& precModel);
-
-    static std::unique_ptr<geom::Geometry>
-    reduceKeepCollapsed(const geom::Geometry& g, const geom::PrecisionModel& precModel);
-
-    GeometryPrecisionReducer(const geom::PrecisionModel& pm)
-        : newFactory(nullptr)
-        , targetPM(pm)
-        , removeCollapsed(true)
-        , changePrecisionModel(false)
-        , useAreaReducer(false)
-        , isPointwise(false)
-    {}
-
-    /**
-     * \brief
-     * Create a reducer that will change the precision model of the
-     * new reduced Geometry
-     *
-     * @param changeFactory the factory for the created Geometry.
-     *           Its PrecisionModel will be used for the reduction.
-     *           NOTE: ownership left to caller must be kept alive for
-     *           the whole lifetime of the returned Geometry.
-     */
-    GeometryPrecisionReducer(const geom::GeometryFactory& changeFactory)
-        : newFactory(&changeFactory)
-        , targetPM(*(changeFactory.getPrecisionModel()))
-        , removeCollapsed(true)
-        , changePrecisionModel(false)
-        , useAreaReducer(false)
-        , isPointwise(false)
-    {}
-
-    /**
-     * Sets whether the reduction will result in collapsed components
-     * being removed completely, or simply being collapsed to an (invalid)
-     * Geometry of the same type.
-     *
-     * @param remove if true collapsed components will be removed
-     */
-    void
-    setRemoveCollapsedComponents(bool remove)
-    {
-        removeCollapsed = remove;
-    }
-
-    /** \brief
-    * Sets whether the {@link geom::PrecisionModel} of the new reduced Geometry
-    * will be changed to be the {@link geom::PrecisionModel} supplied to
-    * specify the precision reduction.
-    * The default is to not change the precision model
-    *
-    * @param change if true the precision
-    * model of the created Geometry will be the
-    * the precisionModel supplied in the constructor.
-    */
-    void
-    setChangePrecisionModel(bool change)
-    {
-        changePrecisionModel = change;
-    }
-
-    void
-    setUseAreaReducer(bool useAR)
-    {
-        useAreaReducer = useAR;
-    }
-
-    /** \brief
-     * Sets whether the precision reduction will be done
-     * in pointwise fashion only.
-     *
-     * Pointwise precision reduction reduces the precision
-     * of the individual coordinates only, but does
-     * not attempt to recreate valid topology.
-     * This is only relevant for geometries containing polygonal components.
-     *
-     * @param pointwise if reduction should be done pointwise only
-     */
-    void
-    setPointwise(bool pointwise)
-    {
-        isPointwise = pointwise;
-    }
-
-    std::unique_ptr<geom::Geometry> reduce(const geom::Geometry& geom);
-
-
-
-};
-
-} // namespace geos.precision
-} // namespace geos
-