DirectedHausdorffDistance.h

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2026 Martin Davis
 * Copyright (C) 2026 Jeroen Bloemscheer
 *
 * 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/DirectedHausdorffDistance.java (aff11591)
 *
 **********************************************************************/
 
#pragma once
 
#include <geos/export.h>
#include <geos/geom/Coordinate.h>
 
#include <array>
#include <memory>
#include <optional>
 
#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 Envelope;
class Geometry;
}
}
 
namespace geos {
namespace algorithm {
namespace distance {
 
class GEOS_DLL DirectedHausdorffDistance {
public:
    using PointPair = std::array<geom::CoordinateXY, 2>;
 
    static double distance(const geom::Geometry& a, const geom::Geometry& b);
 
    static double distance(const geom::Geometry& a, const geom::Geometry& b,
                           double tolerance);
 
    static std::optional<PointPair> distancePoints(
        const geom::Geometry& a, const geom::Geometry& b);
 
    static std::optional<PointPair> distancePoints(
        const geom::Geometry& a, const geom::Geometry& b, double tolerance);
 
    static double hausdorffDistance(const geom::Geometry& a, const geom::Geometry& b);
 
    static std::optional<PointPair> hausdorffDistancePoints(
        const geom::Geometry& a, const geom::Geometry& b);
 
    static bool isFullyWithinDistance(
        const geom::Geometry& a, const geom::Geometry& b, double maxDistance);
 
    static bool isFullyWithinDistance(
        const geom::Geometry& a, const geom::Geometry& b,
        double maxDistance, double tolerance);
 
    explicit DirectedHausdorffDistance(const geom::Geometry& geom);
 
    DirectedHausdorffDistance(const DirectedHausdorffDistance&) = delete;
    DirectedHausdorffDistance& operator=(const DirectedHausdorffDistance&) = delete;
 
    ~DirectedHausdorffDistance();
 
    std::optional<PointPair> farthestPoints(const geom::Geometry& geom) const;
 
    std::optional<PointPair> farthestPoints(const geom::Geometry& geom, double tolerance) const;
 
    bool isFullyWithinDistance(const geom::Geometry& geom, double maxDistance) const;
 
    bool isFullyWithinDistance(
        const geom::Geometry& geom, double maxDistance, double tolerance) const;
 
private:
    class TargetDistance;
    friend class DHDSegment;
 
    static double pairDistance(const std::optional<PointPair>& pts);
    static PointPair pair(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1);
    static double computeTolerance(const geom::Geometry& geom);
    static bool isBeyond(
        const geom::Envelope& envA, const geom::Envelope& envB, double maxDistance);
    static bool isValidLimit(double limit);
    static bool isBeyondLimit(double maxDist, double maxDistanceLimit);
    static bool isWithinLimit(double maxDist, double maxDistanceLimit);
 
    std::optional<PointPair> computeDistancePoints(
        const geom::Geometry& geom, double tolerance, double maxDistanceLimit) const;
    std::optional<PointPair> computeForPoints(
        const geom::Geometry& geom, double maxDistanceLimit) const;
    std::optional<PointPair> computeForEdges(
        const geom::Geometry& geom, double tolerance, double maxDistanceLimit) const;
    std::optional<PointPair> computeForAreaInterior(
        const geom::Geometry& geom, double tolerance) const;
 
    const geom::Geometry& target;
    std::unique_ptr<TargetDistance> targetDistance;
};
 
} // namespace distance
} // namespace algorithm
} // namespace geos
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif