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

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/distance/DiscreteFrechetDistance.h

@@ -1,175 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2016 Shinichi SUGIYAMA (shin.sugi@gmail.com)
- *
- * 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: original work
- *
- * Developed by Shinichi SUGIYAMA (shin.sugi@gmail.com)
- * based on http://www.kr.tuwien.ac.at/staff/eiter/et-archive/cdtr9464.pdf
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <geos/algorithm/distance/PointPairDistance.h> // for composition
-#include <geos/algorithm/distance/DistanceToPoint.h> // for composition
-#include <geos/util/IllegalArgumentException.h> // for inlines
-#include <geos/geom/Geometry.h> // for inlines
-#include <geos/util/math.h> // for inlines
-#include <geos/geom/CoordinateFilter.h> // for inheritance
-#include <geos/geom/CoordinateSequence.h> // for inheritance
-
-#include <cstddef>
-#include <vector>
-
-#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 algorithm {
-//class RayCrossingCounter;
-}
-namespace geom {
-class Geometry;
-class Coordinate;
-//class CoordinateSequence;
-}
-namespace index {
-namespace intervalrtree {
-//class SortedPackedIntervalRTree;
-}
-}
-}
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-namespace distance { // geos::algorithm::distance
-
-/** \brief
- * An algorithm for computing a distance metric
- * which is an approximation to the Frechet Distance
- * based on a discretization of the input {@link geom::Geometry}.
- *
- * The algorithm computes the Frechet distance restricted to discrete points
- * for one of the geometries.
- * The points can be either the vertices of the geometries (the default),
- * or the geometries with line segments densified by a given fraction.
- * Also determines two points of the Geometries which are separated by the
- * computed distance.
- *
- * This algorithm is an approximation to the standard Frechet distance.
- * Specifically,
- * <pre>
- *    for all geometries a, b:    DFD(a, b) >= FD(a, b)
- * </pre>
- * The approximation can be made as close as needed by densifying the
- * input geometries.
- * In the limit, this value will approach the true Frechet distance:
- * <pre>
- *    DFD(A, B, densifyFactor) -> FD(A, B) as densifyFactor -> 0.0
- * </pre>
- * The default approximation is exact or close enough for a large subset of
- * useful cases.
- *
- * The difference between DFD and FD is bounded
- * by the length of the longest edge of the polygonal curves.
- *
- * Fréchet distance sweep continuously along their respective curves
- * and the direction of curves is significant.
- * This makes a better measure of similarity than Hausdorff distance.
- *
- * An example showing how different DHD and DFD are:
- * <pre>
- *   A  = LINESTRING (0 0, 50 200, 100 0, 150 200, 200 0)
- *   B  = LINESTRING (0 200, 200 150, 0 100, 200 50, 0 0)
- *   B' = LINESTRING (0 0, 200 50, 0 100, 200 150, 0 200)
- *
- *   DHD(A, B)  = DHD(A, B') = 48.5071250072666
- *   DFD(A, B)  = 200
- *   DFD(A, B') = 282.842712474619
- * </pre>
- */
-class GEOS_DLL DiscreteFrechetDistance {
-public:
-
-    static double distance(const geom::Geometry& g0,
-                           const geom::Geometry& g1);
-
-    static double distance(const geom::Geometry& g0,
-                           const geom::Geometry& g1, double densifyFrac);
-
-    DiscreteFrechetDistance(const geom::Geometry& p_g0,
-                            const geom::Geometry& p_g1)
-        :
-        g0(p_g0),
-        g1(p_g1),
-        ptDist(),
-        densifyFrac(0.0)
-    {}
-
-    /**
-     * Sets the fraction by which to densify each segment.
-     * Each segment will be (virtually) split into a number of equal-length
-     * subsegments, whose fraction of the total length is closest
-     * to the given fraction.
-     *
-     * @param dFrac
-     */
-    void setDensifyFraction(double dFrac);
-
-    double
-    distance()
-    {
-        compute(g0, g1);
-        return ptDist.getDistance();
-    }
-
-    const std::array<geom::CoordinateXY, 2>
-    getCoordinates() const
-    {
-        return ptDist.getCoordinates();
-    }
-
-private:
-    geom::Coordinate getSegmentAt(const geom::CoordinateSequence& seq, std::size_t index);
-
-    PointPairDistance& getFrechetDistance(std::vector< std::vector<PointPairDistance> >& ca, std::size_t i, std::size_t j,
-                                         const geom::CoordinateSequence& p, const geom::CoordinateSequence& q);
-
-    void compute(const geom::Geometry& discreteGeom, const geom::Geometry& geom);
-
-    const geom::Geometry& g0;
-
-    const geom::Geometry& g1;
-
-    PointPairDistance ptDist;
-
-    /// Value of 0.0 indicates that no densification should take place
-    double densifyFrac; // = 0.0;
-
-    // Declare type as noncopyable
-    DiscreteFrechetDistance(const DiscreteFrechetDistance& other) = delete;
-    DiscreteFrechetDistance& operator=(const DiscreteFrechetDistance& rhs) = delete;
-};
-
-} // geos::algorithm::distance
-} // geos::algorithm
-} // geos
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/distance/DiscreteHausdorffDistance.h

@@ -1,252 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2009  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: algorithm/distance/DiscreteHausdorffDistance.java 1.5 (JTS-1.10)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <geos/algorithm/distance/PointPairDistance.h> // for composition
-#include <geos/algorithm/distance/DistanceToPoint.h> // for composition
-#include <geos/util/IllegalArgumentException.h> // for inlines
-#include <geos/geom/Geometry.h> // for inlines
-#include <geos/util/math.h> // for inlines
-#include <geos/geom/CoordinateFilter.h> // for inheritance
-#include <geos/geom/CoordinateSequenceFilter.h> // for inheritance
-
-#include <cstddef>
-#include <vector>
-
-#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;
-class Coordinate;
-//class CoordinateSequence;
-}
-}
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-namespace distance { // geos::algorithm::distance
-
-/** \brief
- * An algorithm for computing a distance metric
- * which is an approximation to the Hausdorff Distance
- * based on a discretization of the input {@link geom::Geometry}.
- *
- * The algorithm computes the Hausdorff distance restricted to discrete points
- * for one of the geometries.
- * The points can be either the vertices of the geometries (the default),
- * or the geometries with line segments densified by a given fraction.
- * Also determines two points of the Geometries which are separated by the
- * computed distance.
- *
- * This algorithm is an approximation to the standard Hausdorff distance.
- * Specifically,
- * <pre>
- *    for all geometries a, b:    DHD(a, b) <= HD(a, b)
- * </pre>
- * The approximation can be made as close as needed by densifying the
- * input geometries.
- * In the limit, this value will approach the true Hausdorff distance:
- * <pre>
- *    DHD(A, B, densifyFactor) -> HD(A, B) as densifyFactor -> 0.0
- * </pre>
- * The default approximation is exact or close enough for a large subset of
- * useful cases.
- * Examples of these are:
- *
- * - computing distance between Linestrings that are roughly parallel to
- *   each other, and roughly equal in length.  This occurs in matching
- *   linear networks.
- * - Testing similarity of geometries.
- *
- * An example where the default approximation is not close is:
- * <pre>
- *   A = LINESTRING (0 0, 100 0, 10 100, 10 100)
- *   B = LINESTRING (0 100, 0 10, 80 10)
- *
- *   DHD(A, B) = 22.360679774997898
- *   HD(A, B) ~= 47.8
- * </pre>
- */
-class GEOS_DLL DiscreteHausdorffDistance {
-public:
-
-    static double distance(const geom::Geometry& g0,
-                           const geom::Geometry& g1);
-
-    static double distance(const geom::Geometry& g0,
-                           const geom::Geometry& g1, double densifyFrac);
-
-    DiscreteHausdorffDistance(const geom::Geometry& p_g0,
-                              const geom::Geometry& p_g1)
-        :
-        g0(p_g0),
-        g1(p_g1),
-        ptDist(),
-        densifyFrac(0.0)
-    {}
-
-    /**
-     * Sets the fraction by which to densify each segment.
-     * Each segment will be (virtually) split into a number of equal-length
-     * subsegments, whose fraction of the total length is closest
-     * to the given fraction.
-     *
-     * @param dFrac
-     */
-    void setDensifyFraction(double dFrac);
-
-    double
-    distance()
-    {
-        compute(g0, g1);
-        return ptDist.getDistance();
-    }
-
-    double
-    orientedDistance()
-    {
-        computeOrientedDistance(g0, g1, ptDist);
-        return ptDist.getDistance();
-    }
-
-    const std::array<geom::CoordinateXY, 2>
-    getCoordinates() const
-    {
-        return ptDist.getCoordinates();
-    }
-
-    class MaxPointDistanceFilter : public geom::CoordinateFilter {
-    public:
-        MaxPointDistanceFilter(const geom::Geometry& p_geom)
-            :
-            geom(p_geom)
-        {}
-
-        void
-        filter_ro(const geom::CoordinateXY* pt) override
-        {
-            minPtDist.initialize();
-            DistanceToPoint::computeDistance(geom, *pt,
-                                             minPtDist);
-            maxPtDist.setMaximum(minPtDist);
-        }
-
-        const PointPairDistance&
-        getMaxPointDistance() const
-        {
-            return maxPtDist;
-        }
-
-    private:
-        PointPairDistance maxPtDist;
-        PointPairDistance minPtDist;
-        DistanceToPoint euclideanDist;
-        const geom::Geometry& geom;
-
-        // Declare type as noncopyable
-        MaxPointDistanceFilter(const MaxPointDistanceFilter& other);
-        MaxPointDistanceFilter& operator=(const MaxPointDistanceFilter& rhs);
-    };
-
-    class MaxDensifiedByFractionDistanceFilter
-        : public geom::CoordinateSequenceFilter {
-    public:
-
-        MaxDensifiedByFractionDistanceFilter(
-            const geom::Geometry& p_geom, double fraction)
-            :
-            geom(p_geom),
-            // Validity of the cast to size_t has been verified in setDensifyFraction()
-            numSubSegs(std::size_t(util::round(1.0 / fraction)))
-        {
-        }
-
-        void filter_ro(const geom::CoordinateSequence& seq,
-                       std::size_t index) override;
-
-        bool
-        isGeometryChanged() const override
-        {
-            return false;
-        }
-
-        bool
-        isDone() const override
-        {
-            return false;
-        }
-
-        const PointPairDistance&
-        getMaxPointDistance() const
-        {
-            return maxPtDist;
-        }
-
-    private:
-        PointPairDistance maxPtDist;
-        PointPairDistance minPtDist;
-        const geom::Geometry& geom;
-        std::size_t numSubSegs; // = 0;
-
-        // Declare type as noncopyable
-        MaxDensifiedByFractionDistanceFilter(const MaxDensifiedByFractionDistanceFilter& other);
-        MaxDensifiedByFractionDistanceFilter& operator=(const MaxDensifiedByFractionDistanceFilter& rhs);
-    };
-
-private:
-
-    void
-    compute(const geom::Geometry& p_g0,
-            const geom::Geometry& p_g1)
-    {
-        computeOrientedDistance(p_g0, p_g1, ptDist);
-        computeOrientedDistance(p_g1, p_g0, ptDist);
-    }
-
-    void computeOrientedDistance(const geom::Geometry& discreteGeom,
-                                 const geom::Geometry& geom,
-                                 PointPairDistance& ptDist);
-
-    const geom::Geometry& g0;
-
-    const geom::Geometry& g1;
-
-    PointPairDistance ptDist;
-
-    /// Value of 0.0 indicates that no densification should take place
-    double densifyFrac; // = 0.0;
-
-    // Declare type as noncopyable
-    DiscreteHausdorffDistance(const DiscreteHausdorffDistance& other) = delete;
-    DiscreteHausdorffDistance& operator=(const DiscreteHausdorffDistance& rhs) = delete;
-};
-
-} // geos::algorithm::distance
-} // geos::algorithm
-} // geos
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/distance/DistanceToPoint.h

@@ -1,72 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2009  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: algorithm/distance/DistanceToPoint.java 1.1 (JTS-1.9)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/geom/LineSegment.h> // for composition
-
-namespace geos {
-namespace algorithm {
-namespace distance {
-class PointPairDistance;
-}
-}
-namespace geom {
-class Geometry;
-class Coordinate;
-class LineString;
-class Polygon;
-}
-}
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-namespace distance { // geos::algorithm::distance
-
-/**
- * Computes the Euclidean distance (L2 metric) from a Point to a Geometry.
- *
- * Also computes two points which are separated by the distance.
- */
-class DistanceToPoint {
-public:
-
-    DistanceToPoint() {}
-
-    static void computeDistance(const geom::Geometry& geom,
-                                const geom::CoordinateXY& pt,
-                                PointPairDistance& ptDist);
-
-    static void computeDistance(const geom::LineString& geom,
-                                const geom::CoordinateXY& pt,
-                                PointPairDistance& ptDist);
-
-    static void computeDistance(const geom::LineSegment& geom,
-                                const geom::CoordinateXY& pt,
-                                PointPairDistance& ptDist);
-
-    static void computeDistance(const geom::Polygon& geom,
-                                const geom::CoordinateXY& pt,
-                                PointPairDistance& ptDist);
-
-};
-
-} // geos::algorithm::distance
-} // geos::algorithm
-} // geos
-

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/distance/PointPairDistance.h

@@ -1,151 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2009  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: algorithm/distance/PointPairDistance.java 1.1 (JTS-1.9)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/constants.h> // for DoubleNotANumber
-#include <geos/geom/Coordinate.h> // for inlines
-
-#include <array>
-#include <cassert>
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-namespace distance { // geos::algorithm::distance
-
-/**
- * Contains a pair of points and the distance between them.
- * Provides methods to update with a new point pair with
- * either maximum or minimum distance.
- */
-class PointPairDistance {
-public:
-
-    PointPairDistance()
-        :
-        distanceSquared(DoubleNotANumber),
-        isNull(true)
-    {}
-
-    void
-    initialize()
-    {
-        isNull = true;
-    }
-
-    void
-    initialize(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1)
-    {
-        pt[0] = p0;
-        pt[1] = p1;
-        distanceSquared = p0.distanceSquared(p1);
-        isNull = false;
-    }
-
-    double
-    getDistance() const
-    {
-        return std::sqrt(distanceSquared);
-    }
-
-    const std::array<geom::CoordinateXY, 2>&
-    getCoordinates() const
-    {
-        return pt;
-    }
-
-    const geom::CoordinateXY&
-    getCoordinate(std::size_t i) const
-    {
-        assert(i < pt.size());
-        return pt[i];
-    }
-
-    void
-    setMaximum(const PointPairDistance& ptDist)
-    {
-        setMaximum(ptDist.pt[0], ptDist.pt[1]);
-    }
-
-    void
-    setMaximum(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1)
-    {
-        if(isNull) {
-            initialize(p0, p1);
-            return;
-        }
-        double distSq = p0.distanceSquared(p1);
-        if(distSq > distanceSquared) {
-            initialize(p0, p1, distSq);
-        }
-    }
-
-    void
-    setMinimum(const PointPairDistance& ptDist)
-    {
-        setMinimum(ptDist.pt[0], ptDist.pt[1]);
-    }
-
-    void
-    setMinimum(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1)
-    {
-        if(isNull) {
-            initialize(p0, p1);
-            return;
-        }
-        double distSq = p0.distanceSquared(p1);
-        if(distSq < distanceSquared) {
-            initialize(p0, p1, distSq);
-        }
-    }
-
-    bool
-    getIsNull()
-    {
-        return isNull;
-    }
-
-private:
-
-    /**
-     * Initializes the points, avoiding recomputing the distance.
-     * @param p0
-     * @param p1
-     * @param dist the distance between p0 and p1
-     */
-    void
-    initialize(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1,
-               double distSquared)
-    {
-        pt[0] = p0;
-        pt[1] = p1;
-        distanceSquared = distSquared;
-        isNull = false;
-    }
-
-    std::array<geom::CoordinateXY, 2> pt;
-
-    double distanceSquared;
-
-    bool isNull;
-};
-
-} // geos::algorithm::distance
-} // geos::algorithm
-} // geos
-