@cpp.js/package-geos 1.0.0-beta.22 → 1.0.0

package/dist/prebuilt/Android-x86_64/include/geos/precision/CommonBits.h

@@ -0,0 +1,97 @@
+/**********************************************************************
+ *
+ * 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/dist/prebuilt/Android-x86_64/include/geos/precision/CommonBitsOp.h

@@ -0,0 +1,172 @@
+/**********************************************************************
+ *
+ * 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/dist/prebuilt/Android-x86_64/include/geos/precision/CommonBitsRemover.h

@@ -0,0 +1,92 @@
+/**********************************************************************
+ *
+ * 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/dist/prebuilt/Android-x86_64/include/geos/precision/EnhancedPrecisionOp.h

@@ -0,0 +1,105 @@
+/**********************************************************************
+ *
+ * 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/dist/prebuilt/Android-x86_64/include/geos/precision/GeometryPrecisionReducer.h

@@ -0,0 +1,202 @@
+/**********************************************************************
+ *
+ * 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
+