DistanceOp.h

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
 * 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 Public Licence as published
 * by the Free Software Foundation.
 * See the COPYING file for more information.
 *
 **********************************************************************
 *
 * Last port: operation/distance/DistanceOp.java r335 (JTS-1.12-)
 *
 **********************************************************************/
 
#pragma once
 
#include <geos/export.h>
 
#include <geos/algorithm/PointLocator.h> // for composition
#include <geos/operation/distance/GeometryLocation.h>
#include <geos/geom/CoordinateSequence.h>
 
#include <array>
#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
 
// Forward declarations
namespace geos {
namespace geom {
class CircularString;
class Coordinate;
class Polygon;
class LineString;
class Point;
class Geometry;
class SimpleCurve;
class Surface;
}
}
 
 
namespace geos {
namespace operation { // geos::operation
namespace distance { // geos::operation::distance
 
class GEOS_DLL DistanceOp {
public:
    static double distance(const geom::Geometry& g0,
                           const geom::Geometry& g1);
 
    static double distance(const geom::Geometry* g0,
                           const geom::Geometry* g1);
 
    static bool isWithinDistance(const geom::Geometry& g0,
                                 const geom::Geometry& g1,
                                 double distance);
 
    const std::array<GeometryLocation, 2>& nearestLocations();
 
    static std::unique_ptr<geom::CoordinateSequence> nearestPoints(
        const geom::Geometry* g0,
        const geom::Geometry* g1);
 
    DistanceOp(const geom::Geometry* g0, const geom::Geometry* g1);
 
    DistanceOp(const geom::Geometry& g0, const geom::Geometry& g1);
 
    DistanceOp(const geom::Geometry& g0, const geom::Geometry& g1,
               double terminateDistance);
 
    ~DistanceOp() = default;
 
    double distance();
 
    std::unique_ptr<geom::CoordinateSequence> nearestPoints();
 
private:
 
    // input
    std::array<geom::Geometry const*, 2> geom;
    double terminateDistance;
 
    // working
    algorithm::PointLocator ptLocator;
    std::array<GeometryLocation, 2> minDistanceLocation;
    double minDistance;
    bool computed = false;
 
    void updateMinDistance(std::array<GeometryLocation, 2> & locGeom, bool flip);
 
    void computeMinDistance();
 
    void computeContainmentDistance();
 
    void computeInside(std::vector<GeometryLocation> & locs,
                       const std::vector<const geom::Surface*>& polys,
                       std::array<GeometryLocation, 2> & locPtPoly);
 
 
    void computeFacetDistance();
 
    void computeMinDistanceLines(
        const std::vector<const geom::SimpleCurve*>& lines0,
        const std::vector<const geom::SimpleCurve*>& lines1,
        std::array<GeometryLocation, 2> & locGeom);
 
    void computeMinDistancePoints(
        const std::vector<const geom::Point*>& points0,
        const std::vector<const geom::Point*>& points1,
        std::array<GeometryLocation, 2> & locGeom);
 
    void computeMinDistanceLinesPoints(
        const std::vector<const geom::SimpleCurve*>& lines0,
        const std::vector<const geom::Point*>& points1,
        std::array<GeometryLocation, 2> & locGeom);
 
    void computeMinDistance(const geom::CircularString* cs0,
                            const geom::LineString* line1,
                            std::array<GeometryLocation, 2> & locGeom);
 
    void computeMinDistance(const geom::LineString* line0,
                            const geom::CircularString* cs1,
                            std::array<GeometryLocation, 2> & locGeom);
 
    void computeMinDistance(const geom::LineString* line0,
                            const geom::LineString* line1,
                            std::array<GeometryLocation, 2> & locGeom);
 
    void computeMinDistance(const geom::CircularString* cs0,
                            const geom::CircularString* cs1,
                            std::array<GeometryLocation, 2> & locGeom);
 
    void computeMinDistance(const geom::LineString* line,
                            const geom::Point* pt,
                            std::array<GeometryLocation, 2> & locGeom);
 
    void computeMinDistance(const geom::CircularString* cs,
                            const geom::Point* pt,
                            std::array<GeometryLocation, 2> & locGeom);
};
 
 
} // namespace geos::operation::distance
} // namespace geos::operation
} // namespace geos
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif