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

package/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/shape/fractal/HilbertEncoder.h

@@ -1,96 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2020 Paul Ramsey <pramsey@cleverelephant.ca>
- *
- * 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/Geometry.h>
-#include <string>
-#include <vector>
-#include <cstdint>
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Coordinate;
-}
-}
-
-namespace geos {
-namespace shape {   // geos.shape
-namespace fractal { // geos.shape.fractal
-
-
-class GEOS_DLL HilbertEncoder {
-
-public:
-
-    HilbertEncoder(uint32_t p_level, geom::Envelope& extent);
-    uint32_t encode(const geom::Envelope* env);
-    static void sort(std::vector<geom::Geometry*>& geoms);
-
-    template<typename T>
-    static geom::Envelope getEnvelope(T begin, T end) {
-        geom::Envelope extent;
-        for (auto it = begin; it != end; ++it) {
-            const auto* g = *it;
-            if (extent.isNull())
-                extent = *(g->getEnvelopeInternal());
-            else
-                extent.expandToInclude(*(g->getEnvelopeInternal()));
-        }
-
-        return extent;
-    }
-
-    template<typename T>
-    static void sort(T begin, T end) {
-        auto extent = getEnvelope(begin, end);
-        HilbertEncoder encoder(12, extent);
-        HilbertComparator hilbertCompare(encoder);
-        std::sort(begin, end, hilbertCompare);
-    }
-
-private:
-
-    uint32_t level;
-    double minx;
-    double miny;
-    double strideX;
-    double strideY;
-
-    struct HilbertComparator {
-
-        HilbertEncoder& enc;
-
-        HilbertComparator(HilbertEncoder& e)
-            : enc(e) {};
-
-        bool
-        operator()(const geom::Geometry* a, const geom::Geometry* b)
-        {
-            return enc.encode(a->getEnvelopeInternal()) > enc.encode(b->getEnvelopeInternal());
-        }
-    };
-
-};
-
-
-} // namespace geos.shape.fractal
-} // namespace geos.shape
-} // namespace geos
-
-
-

package/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/shape/fractal/MortonCode.h

@@ -1,140 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2020 Paul Ramsey <pramsey@cleverelephant.ca>
- *
- * 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 <string>
-#include <cstdint>
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Coordinate;
-}
-}
-
-namespace geos {
-namespace shape {   // geos.shape
-namespace fractal { // geos.shape.fractal
-
-
-/**
- * Encodes points as the index along the planar Morton (Z-order) curve.
- *
- * The planar Morton (Z-order) curve is a continuous space-filling curve.
- * The Morton curve defines an ordering of the
- * points in the positive quadrant of the plane.
- * The index of a point along the Morton curve is called the Morton code.
- *
- * A sequence of subsets of the Morton curve can be defined by a level number.
- * Each level subset occupies a square range.
- * The curve at level n M(n) contains 2^(n + 1) points.
- * It fills the range square of side 2^level.
- * Curve points have ordinates in the range [0, 2^level - 1].
- * The code for a given point is identical at all levels.
- * The level simply determines the number of points in the curve subset
- * and the size of the range square.
- *
- * This implementation represents codes using 32-bit integers.
- * This allows levels 0 to 16 to be handled.
- * The class supports encoding points
- * and decoding the point for a given code value.
- *
- * The Morton order has the property that it tends to preserve locality.
- * This means that codes which are near in value will have spatially proximate
- * points.  The converse is not always true - the delta between
- * codes for nearby points is not always small.  But the average delta
- * is small enough that the Morton order is an effective way of linearizing space
- * to support range queries.
- *
- * @author Martin Davis
- *
- * @see HilbertCode
- */
-class GEOS_DLL MortonCode {
-
-public:
-
-    /**
-    * The maximum curve level that can be represented.
-    */
-    static constexpr int MAX_LEVEL = 16;
-
-    /**
-    * Computes the index of the point (x,y)
-    * in the Morton curve ordering.
-    *
-    * @param x the x ordinate of the point
-    * @param y the y ordinate of the point
-    * @return the index of the point along the Morton curve
-    */
-    static uint32_t encode(int x, int y);
-
-    /**
-    * Computes the point on the Morton curve
-    * for a given index.
-    *
-    * @param index the index of the point on the curve
-    * @return the point on the curve
-    */
-    static geom::Coordinate decode(uint32_t index);
-
-    /**
-    * The number of points in the curve for the given level.
-    * The number of points is 2<sup>2 * level</sup>.
-    *
-    * @param level the level of the curve
-    * @return the number of points
-    */
-    static uint32_t levelSize(uint32_t level);
-
-    /**
-    * The maximum ordinate value for points
-    * in the curve for the given level.
-    * The maximum ordinate is 2<sup>level</sup> - 1.
-    *
-    * @param level the level of the curve
-    * @return the maximum ordinate value
-    */
-    static uint32_t maxOrdinate(uint32_t level);
-
-    /**
-    * The level of the finite Morton curve which contains at least
-    * the given number of points.
-    *
-    * @param numPoints the number of points required
-    * @return the level of the curve
-    */
-    static uint32_t level(uint32_t numPoints);
-
-
-private:
-
-    static void checkLevel(uint32_t level) ;
-
-    static  uint32_t interleave(uint32_t x);
-
-    static  uint32_t deinterleave(uint32_t x);
-
-};
-
-
-} // namespace geos.shape.fractal
-} // namespace geos.shape
-} // namespace geos
-
-
-

package/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/simplify/ComponentJumpChecker.h

@@ -1,120 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://libgeos.org
- *
- * Copyright (C) 2006 Refractions Research Inc.
- * Copyright (C) 2023 Martin Davis <mtnclimb@gmail.com>
- * Copyright (C) 2023 Paul Ramsey <pramsey@cleverelephant.ca>
- *
- * This is free software; you can redistribute and/or modify it under
- * the terms of the GNU Lesser General Licence as published
- * by the Free Software Foundation.
- * See the COPYING file for more information.
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <vector>
-#include <memory>
-
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Coordinate;
-class CoordinateSequence;
-class Envelope;
-class LineSegment;
-}
-namespace simplify {
-class TaggedLineString;
-}
-}
-
-using geos::geom::Coordinate;
-using geos::geom::Envelope;
-using geos::geom::LineSegment;
-
-namespace geos {
-namespace simplify { // geos::simplify
-
-
-class GEOS_DLL ComponentJumpChecker {
-
-private:
-
-    const std::vector<TaggedLineString*>& components;
-
-    static bool hasJumpAtComponent(
-        const Coordinate& compPt,
-        const TaggedLineString* line,
-        std::size_t start, std::size_t end,
-        const LineSegment& seg);
-
-    static bool hasJumpAtComponent(
-        const Coordinate& compPt,
-        const LineSegment* seg1, const LineSegment* seg2,
-        const LineSegment& seg);
-
-    static std::size_t crossingCount(
-        const Coordinate& compPt,
-        const LineSegment& seg);
-
-    static std::size_t crossingCount(
-        const Coordinate& compPt,
-        const LineSegment* seg1, const LineSegment* seg2);
-
-    std::size_t static  crossingCount(
-        const Coordinate& compPt,
-        const TaggedLineString* line,
-        std::size_t start, std::size_t end);
-
-    static Envelope computeEnvelope(
-        const LineSegment* seg1, const LineSegment* seg2);
-
-    static Envelope computeEnvelope(
-        const TaggedLineString* line,
-        std::size_t start, std::size_t end);
-
-
-public:
-
-    ComponentJumpChecker(const std::vector<TaggedLineString*>& taggedLines)
-        : components(taggedLines)
-    {}
-
-    bool hasJump(
-        const TaggedLineString* line,
-        std::size_t start, std::size_t end,
-        const LineSegment& seg) const;
-
-    /**
-    * Checks if two consecutive segments jumps a component if flattened.
-    * The segments are assumed to be consecutive.
-    * (so the seg1.p1 = seg2.p0).
-    * The flattening segment must be the segment between seg1.p0 and seg2.p1.
-    *
-    * @param line the line containing the section being flattened
-    * @param seg1 the first replaced segment
-    * @param seg2 the next replaced segment
-    * @param seg the flattening segment
-    * @return true if the flattened segment jumps a component
-    */
-    bool hasJump(
-        const TaggedLineString* line,
-        const LineSegment* seg1,
-        const LineSegment* seg2,
-        const LineSegment& seg) const;
-
-};
-
-} // namespace geos::simplify
-} // namespace geos
-
-
-
-
-

package/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/simplify/DouglasPeuckerLineSimplifier.h

@@ -1,103 +0,0 @@
-/**********************************************************************
- *
- * 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 Licence as published
- * by the Free Software Foundation.
- * See the COPYING file for more information.
- *
- **********************************************************************
- *
- * Last port: simplify/DouglasPeuckerLineSimplifier.java rev. 1.4
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <geos/geom/CoordinateSequence.h>
-#include <vector>
-#include <memory> // for unique_ptr
-
-#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
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Coordinate;
-}
-}
-
-namespace geos {
-namespace simplify { // geos::simplify
-
-/** \brief
- * Simplifies a linestring (sequence of points) using
- * the standard Douglas-Peucker algorithm.
- */
-class GEOS_DLL DouglasPeuckerLineSimplifier {
-
-public:
-
-    /** \brief
-     * Returns a newly allocated Coordinate vector, wrapped
-     * into an unique_ptr
-     */
-    static std::unique_ptr<geom::CoordinateSequence> simplify(
-        const geom::CoordinateSequence& nPts,
-        double distanceTolerance,
-        bool preserveClosedEndpoint);
-
-    DouglasPeuckerLineSimplifier(const geom::CoordinateSequence& nPts);
-
-    /** \brief
-     * Sets the distance tolerance for the simplification.
-     *
-     * All vertices in the simplified linestring will be within this
-     * distance of the original linestring.
-     *
-     * @param nDistanceTolerance the approximation tolerance to use
-     */
-    void setDistanceTolerance(double nDistanceTolerance);
-
-    /** \brief
-     * Sets whether the endpoint of a closed LineString should be preserved
-     *
-     * @param preserve `true` if the endpoint should be preserved
-     */
-    void setPreserveClosedEndpoint(bool preserve);
-
-    /** \brief
-     * Returns a newly allocated Coordinate vector, wrapped
-     * into an unique_ptr
-     */
-    std::unique_ptr<geom::CoordinateSequence> simplify();
-
-private:
-
-    const geom::CoordinateSequence& pts;
-    std::vector<bool> usePt;
-    double distanceTolerance;
-    bool preserveEndpoint;
-
-    void simplifySection(std::size_t i, std::size_t j);
-
-    // Declare type as noncopyable
-    DouglasPeuckerLineSimplifier(const DouglasPeuckerLineSimplifier& other) = delete;
-    DouglasPeuckerLineSimplifier& operator=(const DouglasPeuckerLineSimplifier& rhs) = delete;
-};
-
-} // namespace geos::simplify
-} // namespace geos
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-

package/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/simplify/DouglasPeuckerSimplifier.h

@@ -1,84 +0,0 @@
-/**********************************************************************
- *
- * 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 Licence as published
- * by the Free Software Foundation.
- * See the COPYING file for more information.
- *
- **********************************************************************
- *
- * Last port: simplify/DouglasPeuckerSimplifier.java rev. 1.5 (JTS-1.7)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <memory> // for unique_ptr
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Geometry;
-}
-}
-
-namespace geos {
-namespace simplify { // geos::simplify
-
-
-/** \brief
- * Simplifies a Geometry using the standard Douglas-Peucker algorithm.
- *
- * Ensures that any polygonal geometries returned are valid.
- * Simple lines are not guaranteed to remain simple after simplification.
- *
- * Note that in general D-P does not preserve topology -
- * e.g. polygons can be split, collapse to lines or disappear
- * holes can be created or disappear,
- * and lines can cross.
- * To simplify geometry while preserving topology use TopologyPreservingSimplifier.
- * (However, using D-P is significantly faster).
- *
- */
-class GEOS_DLL DouglasPeuckerSimplifier {
-
-public:
-
-    static std::unique_ptr<geom::Geometry> simplify(
-        const geom::Geometry* geom,
-        double tolerance);
-
-    DouglasPeuckerSimplifier(const geom::Geometry* geom);
-
-    /** \brief
-     * Sets the distance tolerance for the simplification.
-     *
-     * All vertices in the simplified geometry will be within this
-     * distance of the original geometry.
-     * The tolerance value must be non-negative.  A tolerance value
-     * of zero is effectively a no-op.
-     *
-     * @param tolerance the approximation tolerance to use
-     */
-    void setDistanceTolerance(double tolerance);
-
-    std::unique_ptr<geom::Geometry> getResultGeometry();
-
-
-private:
-
-    const geom::Geometry* inputGeom;
-
-    double distanceTolerance;
-};
-
-
-} // namespace geos::simplify
-} // namespace geos
-

package/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/simplify/LineSegmentIndex.h

@@ -1,87 +0,0 @@
-/**********************************************************************
- *
- * 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 Licence as published
- * by the Free Software Foundation.
- * See the COPYING file for more information.
- *
- **********************************************************************
- *
- * Last port: simplify/LineSegmentIndex.java rev. 1.1 (JTS-1.7.1)
- *
- **********************************************************************
- *
- * NOTES
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <geos/geom/Envelope.h>
-#include <geos/index/quadtree/Quadtree.h>
-#include <vector>
-#include <memory> // for unique_ptr
-
-#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
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class LineSegment;
-}
-namespace simplify {
-class TaggedLineString;
-}
-}
-
-namespace geos {
-namespace simplify { // geos::simplify
-
-class GEOS_DLL LineSegmentIndex {
-
-public:
-
-    LineSegmentIndex() = default;
-
-    ~LineSegmentIndex() = default;
-
-    void add(const TaggedLineString& line);
-
-    void add(const geom::LineSegment* seg);
-
-    void remove(const geom::LineSegment* seg);
-
-    std::vector<const geom::LineSegment*>
-    query(const geom::LineSegment* seg);
-
-
-private:
-
-    index::quadtree::Quadtree index;
-
-    std::vector<std::unique_ptr<geom::Envelope>> newEnvelopes;
-
-    /**
-     * Disable copy construction and assignment. Apparently needed to make this
-     * class compile under MSVC. (See https://stackoverflow.com/q/29565299)
-     */
-    LineSegmentIndex(const LineSegmentIndex&) = delete;
-    LineSegmentIndex& operator=(const LineSegmentIndex&) = delete;
-};
-
-} // namespace geos::simplify
-} // namespace geos
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-

package/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/simplify/LinkedLine.h

@@ -1,84 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2021 Paul Ramsey <pramsey@cleverelephant.ca>
- *
- * 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/Coordinate.h>
-
-#include <geos/export.h>
-
-#include <vector>
-#include <memory>
-
-
-namespace geos {
-namespace geom {
-class Coordinate;
-class CoordinateSequence;
-}
-}
-
-using geos::geom::Coordinate;
-using geos::geom::CoordinateSequence;
-
-
-namespace geos {
-namespace simplify { // geos::simplify
-
-class LinkedLine
-{
-
-public:
-
-    LinkedLine(const CoordinateSequence& pts);
-
-    bool isRing() const;
-    bool isCorner(std::size_t i) const;
-
-    std::size_t size() const;
-    std::size_t next(std::size_t i) const;
-    std::size_t prev(std::size_t i) const;
-
-    const Coordinate& getCoordinate(std::size_t index) const;
-    const Coordinate& prevCoordinate(std::size_t index) const;
-    const Coordinate& nextCoordinate(std::size_t index) const;
-
-    bool hasCoordinate(std::size_t index) const;
-
-    void remove(std::size_t index);
-
-    std::unique_ptr<CoordinateSequence> getCoordinates() const;
-
-
-private:
-
-    // Members
-    const CoordinateSequence&  m_coord;
-    bool m_isRing;
-    std::size_t m_size;
-    std::vector<std::size_t> m_next;
-    std::vector<std::size_t> m_prev;
-
-    void createNextLinks(std::size_t size);
-
-    void createPrevLinks(std::size_t size);
-
-
-}; // LinkedLine
-
-GEOS_DLL std::ostream& operator<< (std::ostream& os, const LinkedLine& ll);
-
-
-} // geos::simplify
-} // geos