Added thirdparty: boost library

thirdparty/include/boost/geometry/algorithms/detail/distance/box_to_box.hpp

@@ -0,0 +1,55 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2021, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_BOX_TO_BOX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_BOX_TO_BOX_HPP
+
+#include <boost/core/ignore_unused.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/tags.hpp>
+
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Box1, typename Box2, typename Strategies>
+struct distance
+    <
+        Box1, Box2, Strategies, box_tag, box_tag,
+        strategy_tag_distance_box_box, false
+    >
+{
+    static inline auto apply(Box1 const& box1, Box2 const& box2, Strategies const& strategies)
+    {
+        boost::ignore_unused(strategies);
+        return strategies.distance(box1, box2).apply(box1, box2);
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_BOX_TO_BOX_HPP

thirdparty/include/boost/geometry/algorithms/detail/distance/geometry_collection.hpp

@@ -0,0 +1,239 @@
+// Boost.Geometry
+
+// Copyright (c) 2021 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_GEOMETRY_COLLECTION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_GEOMETRY_COLLECTION_HPP
+
+
+#include <vector>
+
+#include <boost/range/size.hpp>
+
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+#include <boost/geometry/algorithms/detail/visit.hpp>
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/index/rtree.hpp>
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/distance_result.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+template <typename Geometry, typename GeometryCollection, typename Strategies>
+inline auto geometry_to_collection(Geometry const& geometry,
+                                   GeometryCollection const& collection,
+                                   Strategies const& strategies)
+{
+    using result_t = typename geometry::distance_result<Geometry, GeometryCollection, Strategies>::type;
+    result_t result = 0;
+    bool is_first = true;
+    detail::visit_breadth_first([&](auto const& g)
+    {
+        result_t r = dispatch::distance
+                        <
+                            Geometry, util::remove_cref_t<decltype(g)>, Strategies
+                        >::apply(geometry, g, strategies);
+        if (is_first)
+        {
+            result = r;
+            is_first = false;
+        }
+        else if (r < result)
+        {
+            result = r;
+        }
+        return result > result_t(0);
+    }, collection);
+
+    return result;
+}
+
+template <typename GeometryCollection1, typename GeometryCollection2, typename Strategies>
+inline auto collection_to_collection(GeometryCollection1 const& collection1,
+                                     GeometryCollection2 const& collection2,
+                                     Strategies const& strategies)
+{
+    using result_t = typename geometry::distance_result<GeometryCollection1, GeometryCollection2, Strategies>::type;
+
+    using point1_t = typename geometry::point_type<GeometryCollection1>::type;
+    using box1_t = model::box<point1_t>;
+    using point2_t = typename geometry::point_type<GeometryCollection2>::type;
+    using box2_t = model::box<point2_t>;
+
+    using rtree_value_t = std::pair<box1_t, typename boost::range_iterator<GeometryCollection1 const>::type>;
+    using rtree_params_t = index::parameters<index::rstar<4>, Strategies>;
+    using rtree_t = index::rtree<rtree_value_t, rtree_params_t>;
+
+    rtree_params_t rtree_params(index::rstar<4>(), strategies);
+    rtree_t rtree(rtree_params);
+
+    // Build rtree of boxes and iterators of elements of GC1
+    // TODO: replace this with visit_breadth_first_iterator to avoid creating an unnecessary container?
+    {
+        std::vector<rtree_value_t> values;
+        visit_breadth_first_impl<true>::apply([&](auto & g1, auto it)
+        {
+            box1_t b1 = geometry::return_envelope<box1_t>(g1, strategies);
+            geometry::detail::expand_by_epsilon(b1);
+            values.emplace_back(b1, it);
+            return true;
+        }, collection1);
+        rtree_t rt(values.begin(), values.end(), rtree_params);
+        rtree = std::move(rt);
+    }
+
+    result_t const zero = 0;
+    auto const rtree_qend = rtree.qend();
+
+    result_t result = 0;
+    bool is_first = true;
+    visit_breadth_first([&](auto const& g2)
+    {
+        box2_t b2 = geometry::return_envelope<box2_t>(g2, strategies);
+        geometry::detail::expand_by_epsilon(b2);
+
+        for (auto it = rtree.qbegin(index::nearest(b2, rtree.size())) ; it != rtree_qend ; ++it)
+        {
+            // If the distance between boxes is greater than or equal to previously found
+            // distance between geometries then stop processing the current b2 because no
+            // closer b1 will be found
+            if (! is_first)
+            {
+                result_t const bd = dispatch::distance
+                    <
+                        box1_t, box2_t, Strategies
+                    >::apply(it->first, b2, strategies);
+                if (bd >= result)
+                {
+                    break;
+                }
+            }
+
+            // Boxes are closer than the previously found distance (or it's the first time),
+            // calculate the new distance between geometries and check if it's closer (or assign it).
+            traits::iter_visit<GeometryCollection1>::apply([&](auto const& g1)
+            {
+                result_t const d = dispatch::distance
+                    <
+                        util::remove_cref_t<decltype(g1)>, util::remove_cref_t<decltype(g2)>,
+                        Strategies
+                    >::apply(g1, g2, strategies);
+                if (is_first)
+                {
+                    result = d;
+                    is_first = false;
+                }
+                else if (d < result)
+                {
+                    result = d;
+                }
+            }, it->second);
+
+            // The smallest possible distance found, end searching.
+            if (! is_first && result <= zero)
+            {
+                return false;
+            }
+        }
+
+        // Just in case
+        return is_first || result > zero;
+    }, collection2);
+
+    return result;
+}
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Geometry, typename GeometryCollection, typename Strategies, typename Tag1
+>
+struct distance
+    <
+        Geometry, GeometryCollection, Strategies,
+        Tag1, geometry_collection_tag, void, false
+    >
+{
+    static inline auto apply(Geometry const& geometry,
+                             GeometryCollection const& collection,
+                             Strategies const& strategies)
+    {
+        assert_dimension_equal<Geometry, GeometryCollection>();
+
+        return detail::distance::geometry_to_collection(geometry, collection, strategies);
+    }
+};
+
+template
+<
+    typename GeometryCollection, typename Geometry, typename Strategies, typename Tag2
+>
+struct distance
+    <
+        GeometryCollection, Geometry, Strategies,
+        geometry_collection_tag, Tag2, void, false
+    >
+{
+    static inline auto apply(GeometryCollection const& collection,
+                             Geometry const& geometry,
+                             Strategies const& strategies)
+    {
+        assert_dimension_equal<Geometry, GeometryCollection>();
+
+        return detail::distance::geometry_to_collection(geometry, collection, strategies);
+    }
+};
+
+template
+<
+    typename GeometryCollection1, typename GeometryCollection2, typename Strategies
+>
+struct distance
+    <
+        GeometryCollection1, GeometryCollection2, Strategies,
+        geometry_collection_tag, geometry_collection_tag, void, false
+    >
+{
+    static inline auto apply(GeometryCollection1 const& collection1,
+                             GeometryCollection2 const& collection2,
+                             Strategies const& strategies)
+    {
+        assert_dimension_equal<GeometryCollection1, GeometryCollection2>();
+
+        // Build the rtree for the smaller GC (ignoring recursive GCs)
+        return boost::size(collection1) <= boost::size(collection2)
+             ? detail::distance::collection_to_collection(collection1, collection2, strategies)
+             : detail::distance::collection_to_collection(collection2, collection1, strategies);
+    }
+};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_SEGMENT_TO_BOX_HPP

thirdparty/include/boost/geometry/algorithms/detail/distance/geometry_to_segment_or_box.hpp

@@ -0,0 +1,420 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2021, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_GEOMETRY_TO_SEGMENT_OR_BOX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_GEOMETRY_TO_SEGMENT_OR_BOX_HPP
+
+#include <iterator>
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/detail/closest_feature/geometry_to_range.hpp>
+#include <boost/geometry/algorithms/detail/closest_feature/point_to_range.hpp>
+#include <boost/geometry/algorithms/detail/distance/is_comparable.hpp>
+#include <boost/geometry/algorithms/detail/distance/strategy_utils.hpp>
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+#include <boost/geometry/algorithms/intersects.hpp>
+#include <boost/geometry/algorithms/num_points.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/iterators/point_iterator.hpp>
+#include <boost/geometry/iterators/segment_iterator.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/tags.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+// closure of segment or box point range
+template
+<
+    typename SegmentOrBox,
+    typename Tag = typename tag<SegmentOrBox>::type
+>
+struct segment_or_box_point_range_closure
+    : not_implemented<SegmentOrBox>
+{};
+
+template <typename Segment>
+struct segment_or_box_point_range_closure<Segment, segment_tag>
+{
+    static const closure_selector value = closed;
+};
+
+template <typename Box>
+struct segment_or_box_point_range_closure<Box, box_tag>
+{
+    static const closure_selector value = open;
+};
+
+
+
+template
+<
+    typename Geometry,
+    typename SegmentOrBox,
+    typename Strategies,
+    typename Tag = typename tag<Geometry>::type
+>
+class geometry_to_segment_or_box
+{
+private:
+    typedef typename point_type<SegmentOrBox>::type segment_or_box_point;
+
+    typedef distance::strategy_t<Geometry, SegmentOrBox, Strategies> strategy_type;
+
+    typedef detail::closest_feature::point_to_point_range
+        <
+            typename point_type<Geometry>::type,
+            std::vector<segment_or_box_point>,
+            segment_or_box_point_range_closure<SegmentOrBox>::value
+        > point_to_point_range;
+
+    typedef detail::closest_feature::geometry_to_range geometry_to_range;
+
+    typedef distance::creturn_t<Geometry, SegmentOrBox, Strategies> comparable_return_type;
+
+    // assign the new minimum value for an iterator of the point range
+    // of a segment or a box
+    template
+    <
+        typename SegOrBox,
+        typename SegOrBoxTag = typename tag<SegOrBox>::type
+    >
+    struct assign_new_min_iterator
+        : not_implemented<SegOrBox>
+    {};
+
+    template <typename Segment>
+    struct assign_new_min_iterator<Segment, segment_tag>
+    {
+        template <typename Iterator>
+        static inline void apply(Iterator&, Iterator)
+        {
+        }
+    };
+
+    template <typename Box>
+    struct assign_new_min_iterator<Box, box_tag>
+    {
+        template <typename Iterator>
+        static inline void apply(Iterator& it_min, Iterator it)
+        {
+            it_min = it;
+        }
+    };
+
+
+    // assign the points of a segment or a box to a range
+    template
+    <
+        typename SegOrBox,
+        typename PointRange,
+        typename SegOrBoxTag = typename tag<SegOrBox>::type
+    >
+    struct assign_segment_or_box_points
+    {};
+
+    template <typename Segment, typename PointRange>
+    struct assign_segment_or_box_points<Segment, PointRange, segment_tag>
+    {
+        static inline void apply(Segment const& segment, PointRange& range)
+        {
+            detail::assign_point_from_index<0>(segment, range[0]);
+            detail::assign_point_from_index<1>(segment, range[1]);
+        }
+    };
+
+    template <typename Box, typename PointRange>
+    struct assign_segment_or_box_points<Box, PointRange, box_tag>
+    {
+        static inline void apply(Box const& box, PointRange& range)
+        {
+            detail::assign_box_corners_oriented<true>(box, range);
+        }
+    };
+
+public:
+    typedef distance::return_t<Geometry, SegmentOrBox, Strategies> return_type;
+
+    static inline return_type apply(Geometry const& geometry,
+                                    SegmentOrBox const& segment_or_box,
+                                    Strategies const& strategies,
+                                    bool check_intersection = true)
+    {
+        typedef geometry::segment_iterator
+            <
+                Geometry const
+            > segment_iterator_type;
+
+        typedef assign_new_min_iterator<SegmentOrBox> assign_new_value;
+
+
+        if (check_intersection
+            && geometry::intersects(geometry, segment_or_box, strategies))
+        {
+            return return_type(0);
+        }
+
+        strategy_type const strategy = strategies.distance(geometry, segment_or_box);
+
+        auto const cstrategy = strategy::distance::services::get_comparable
+                                <
+                                    strategy_type
+                                >::apply(strategy);
+
+        // get all points of the segment or the box
+        std::vector<segment_or_box_point>
+            seg_or_box_points(geometry::num_points(segment_or_box));
+
+        assign_segment_or_box_points
+            <
+                SegmentOrBox,
+                std::vector<segment_or_box_point>
+            >::apply(segment_or_box, seg_or_box_points);
+
+        // consider all distances of the points in the geometry to the
+        // segment or box
+        comparable_return_type cd_min1(0);
+        auto pit_min = points_begin(geometry);
+        auto it_min1 = boost::const_begin(seg_or_box_points);
+        auto it_min2 = it_min1 + 1;
+        bool first = true;
+
+        for (auto pit = pit_min;
+             pit != points_end(geometry); ++pit, first = false)
+        {
+            comparable_return_type cd;
+            auto it_pair = point_to_point_range::apply(*pit,
+                boost::const_begin(seg_or_box_points),
+                boost::const_end(seg_or_box_points),
+                cstrategy,
+                cd);
+
+            if (first || cd < cd_min1)
+            {
+                cd_min1 = cd;
+                pit_min = pit;
+                assign_new_value::apply(it_min1, it_pair.first);
+                assign_new_value::apply(it_min2, it_pair.second);
+            }
+        }
+
+        // consider all distances of the points in the segment or box to the
+        // segments of the geometry
+        comparable_return_type cd_min2(0);
+        segment_iterator_type sit_min;
+        auto it_min = boost::const_begin(seg_or_box_points);
+
+        first = true;
+        for (auto it = boost::const_begin(seg_or_box_points);
+             it != boost::const_end(seg_or_box_points); ++it, first = false)
+        {
+            comparable_return_type cd;
+            segment_iterator_type sit
+                = geometry_to_range::apply(*it,
+                                           segments_begin(geometry),
+                                           segments_end(geometry),
+                                           cstrategy,
+                                           cd);
+
+            if (first || cd < cd_min2)
+            {
+                cd_min2 = cd;
+                it_min = it;
+                sit_min = sit;
+            }
+        }
+
+        if (BOOST_GEOMETRY_CONDITION(is_comparable<strategy_type>::value))
+        {
+            return (std::min)(cd_min1, cd_min2);
+        }
+
+        if (cd_min1 < cd_min2)
+        {
+            return strategy.apply(*pit_min, *it_min1, *it_min2);
+        }
+        else
+        {
+            return dispatch::distance
+                <
+                    segment_or_box_point,
+                    typename std::iterator_traits
+                        <
+                            segment_iterator_type
+                        >::value_type,
+                    Strategies
+                >::apply(*it_min, *sit_min, strategies);
+        }
+    }
+
+
+    static inline return_type apply(SegmentOrBox const& segment_or_box, Geometry const& geometry,
+                                    Strategies const& strategies, bool check_intersection = true)
+    {
+        return apply(geometry, segment_or_box, strategies, check_intersection);
+    }
+};
+
+
+
+template <typename MultiPoint, typename SegmentOrBox, typename Strategies>
+class geometry_to_segment_or_box
+    <
+        MultiPoint, SegmentOrBox, Strategies, multi_point_tag
+    >
+{
+private:
+    typedef detail::closest_feature::geometry_to_range base_type;
+    typedef detail::closest_feature::geometry_to_range geometry_to_range;
+    typedef distance::strategy_t<MultiPoint, SegmentOrBox, Strategies> strategy_type;
+
+public:
+    typedef distance::return_t<MultiPoint, SegmentOrBox, Strategies> return_type;
+
+    static inline return_type apply(MultiPoint const& multipoint,
+                                    SegmentOrBox const& segment_or_box,
+                                    Strategies const& strategies)
+    {
+        distance::creturn_t<MultiPoint, SegmentOrBox, Strategies> cd_min;
+
+        auto const it_min
+            = geometry_to_range::apply(segment_or_box,
+                                       boost::begin(multipoint),
+                                       boost::end(multipoint),
+                                       strategy::distance::services::get_comparable
+                                           <
+                                               strategy_type
+                                           >::apply(strategies.distance(multipoint, segment_or_box)),
+                                       cd_min);
+
+        return
+            is_comparable<strategy_type>::value
+            ?
+            cd_min
+            :
+            dispatch::distance
+                <
+                    typename point_type<MultiPoint>::type,
+                    SegmentOrBox,
+                    Strategies
+                >::apply(*it_min, segment_or_box, strategies);
+    }
+};
+
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Linear, typename Segment, typename Strategy>
+struct distance
+    <
+        Linear, Segment, Strategy, linear_tag, segment_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::geometry_to_segment_or_box<Linear, Segment, Strategy>
+{};
+
+
+template <typename Areal, typename Segment, typename Strategy>
+struct distance
+    <
+        Areal, Segment, Strategy, areal_tag, segment_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::geometry_to_segment_or_box<Areal, Segment, Strategy>
+{};
+
+
+template <typename Segment, typename Areal, typename Strategy>
+struct distance
+    <
+        Segment, Areal, Strategy, segment_tag, areal_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::geometry_to_segment_or_box<Areal, Segment, Strategy>
+{};
+
+
+template <typename Linear, typename Box, typename Strategy>
+struct distance
+    <
+        Linear, Box, Strategy, linear_tag, box_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::geometry_to_segment_or_box
+        <
+            Linear, Box, Strategy
+        >
+{};
+
+
+template <typename Areal, typename Box, typename Strategy>
+struct distance
+    <
+        Areal, Box, Strategy, areal_tag, box_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::geometry_to_segment_or_box<Areal, Box, Strategy>
+{};
+
+
+template <typename MultiPoint, typename Segment, typename Strategy>
+struct distance
+    <
+        MultiPoint, Segment, Strategy,
+        multi_point_tag, segment_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::geometry_to_segment_or_box
+        <
+            MultiPoint, Segment, Strategy
+        >
+{};
+
+
+template <typename MultiPoint, typename Box, typename Strategy>
+struct distance
+    <
+        MultiPoint, Box, Strategy,
+        multi_point_tag, box_tag,
+        strategy_tag_distance_point_box, false
+    > : detail::distance::geometry_to_segment_or_box
+        <
+            MultiPoint, Box, Strategy
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_GEOMETRY_TO_SEGMENT_OR_BOX_HPP

thirdparty/include/boost/geometry/algorithms/detail/distance/implementation.hpp

@@ -0,0 +1,41 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014-2021.
+// Modifications copyright (c) 2014-2021, Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_IMPLEMENTATION_HPP
+
+// the implementation details
+#include <boost/geometry/algorithms/detail/distance/point_to_geometry.hpp>
+#include <boost/geometry/algorithms/detail/distance/multipoint_to_geometry.hpp>
+#include <boost/geometry/algorithms/detail/distance/linear_to_linear.hpp>
+#include <boost/geometry/algorithms/detail/distance/linear_or_areal_to_areal.hpp>
+#include <boost/geometry/algorithms/detail/distance/linear_to_box.hpp>
+#include <boost/geometry/algorithms/detail/distance/geometry_collection.hpp>
+#include <boost/geometry/algorithms/detail/distance/geometry_to_segment_or_box.hpp>
+#include <boost/geometry/algorithms/detail/distance/segment_to_segment.hpp>
+#include <boost/geometry/algorithms/detail/distance/segment_to_box.hpp>
+#include <boost/geometry/algorithms/detail/distance/box_to_box.hpp>
+
+#include <boost/geometry/strategies/distance/backward_compatibility.hpp>
+#include <boost/geometry/strategies/distance/cartesian.hpp>
+#include <boost/geometry/strategies/distance/geographic.hpp>
+#include <boost/geometry/strategies/distance/spherical.hpp>
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_IMPLEMENTATION_HPP

thirdparty/include/boost/geometry/algorithms/detail/distance/interface.hpp

@@ -0,0 +1,353 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+// Copyright (c) 2014 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2014-2021.
+// Modifications copyright (c) 2014-2021, Oracle and/or its affiliates.
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_INTERFACE_HPP
+
+#include <boost/concept_check.hpp>
+
+#include <boost/geometry/algorithms/detail/throw_on_empty_input.hpp>
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/visit.hpp>
+
+#include <boost/geometry/geometries/adapted/boost_variant.hpp> // For backward compatibility
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+// TODO: move these to algorithms
+#include <boost/geometry/strategies/default_distance_result.hpp>
+#include <boost/geometry/strategies/distance_result.hpp>
+
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/detail.hpp>
+#include <boost/geometry/strategies/distance/services.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// If reversal is needed, perform it
+template
+<
+    typename Geometry1, typename Geometry2, typename Strategy,
+    typename Tag1, typename Tag2, typename StrategyTag
+>
+struct distance
+<
+    Geometry1, Geometry2, Strategy,
+    Tag1, Tag2, StrategyTag,
+    true
+>
+    : distance<Geometry2, Geometry1, Strategy, Tag2, Tag1, StrategyTag, false>
+{
+    static inline auto apply(Geometry1 const& g1, Geometry2 const& g2,
+                             Strategy const& strategy)
+    {
+        return distance
+            <
+                Geometry2, Geometry1, Strategy,
+                Tag2, Tag1, StrategyTag,
+                false
+            >::apply(g2, g1, strategy);
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_strategy
+{
+
+template
+<
+    typename Strategy,
+    bool IsUmbrella = strategies::detail::is_umbrella_strategy<Strategy>::value
+>
+struct distance
+{
+    template <typename Geometry1, typename Geometry2>
+    static inline auto apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        return dispatch::distance
+            <
+                Geometry1, Geometry2, Strategy
+            >::apply(geometry1, geometry2, strategy);
+    }
+};
+
+template <typename Strategy>
+struct is_strategy_converter_specialized
+{
+    typedef strategies::distance::services::strategy_converter<Strategy> converter;
+    static const bool value = ! std::is_same
+        <
+            decltype(converter::get(std::declval<Strategy>())),
+            strategies::detail::not_implemented
+        >::value;
+};
+
+template <typename Strategy>
+struct distance<Strategy, false>
+{
+    template
+    <
+        typename Geometry1, typename Geometry2, typename S,
+        std::enable_if_t<is_strategy_converter_specialized<S>::value, int> = 0
+    >
+    static inline auto apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             S const& strategy)
+    {
+        typedef strategies::distance::services::strategy_converter<Strategy> converter;
+        typedef decltype(converter::get(strategy)) strategy_type;
+
+        return dispatch::distance
+            <
+                Geometry1, Geometry2, strategy_type
+            >::apply(geometry1, geometry2, converter::get(strategy));
+    }
+
+    template
+    <
+        typename Geometry1, typename Geometry2, typename S,
+        std::enable_if_t<! is_strategy_converter_specialized<S>::value, int> = 0
+    >
+    static inline auto apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             S const& strategy)
+    {
+        typedef strategies::distance::services::custom_strategy_converter
+            <
+                Geometry1, Geometry2, Strategy
+            > converter;
+        typedef decltype(converter::get(strategy)) strategy_type;
+
+        return dispatch::distance
+            <
+                Geometry1, Geometry2, strategy_type
+            >::apply(geometry1, geometry2, converter::get(strategy));
+    }
+};
+
+template <>
+struct distance<default_strategy, false>
+{
+    template <typename Geometry1, typename Geometry2>
+    static inline auto apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             default_strategy)
+    {
+        typedef typename strategies::distance::services::default_strategy
+            <
+                Geometry1, Geometry2
+            >::type strategy_type;
+
+        return dispatch::distance
+            <
+                Geometry1, Geometry2, strategy_type
+            >::apply(geometry1, geometry2, strategy_type());
+    }
+};
+
+} // namespace resolve_strategy
+
+
+namespace resolve_dynamic
+{
+
+
+template
+<
+    typename Geometry1, typename Geometry2,
+    typename Tag1 = typename geometry::tag<Geometry1>::type,
+    typename Tag2 = typename geometry::tag<Geometry2>::type
+>
+struct distance
+{
+    template <typename Strategy>
+    static inline auto apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        return resolve_strategy::distance
+            <
+                Strategy
+            >::apply(geometry1, geometry2, strategy);
+    }
+};
+
+
+template <typename DynamicGeometry1, typename Geometry2, typename Tag2>
+struct distance<DynamicGeometry1, Geometry2, dynamic_geometry_tag, Tag2>
+{
+    template <typename Strategy>
+    static inline auto apply(DynamicGeometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        using result_t = typename geometry::distance_result<DynamicGeometry1, Geometry2, Strategy>::type;
+        result_t result = 0;
+        traits::visit<DynamicGeometry1>::apply([&](auto const& g1)
+        {
+            result = resolve_strategy::distance
+                        <
+                            Strategy
+                        >::apply(g1, geometry2, strategy);
+        }, geometry1);
+        return result;
+    }
+};
+
+
+template <typename Geometry1, typename DynamicGeometry2, typename Tag1>
+struct distance<Geometry1, DynamicGeometry2, Tag1, dynamic_geometry_tag>
+{
+    template <typename Strategy>
+    static inline auto apply(Geometry1 const& geometry1,
+                             DynamicGeometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        using result_t = typename geometry::distance_result<Geometry1, DynamicGeometry2, Strategy>::type;
+        result_t result = 0;
+        traits::visit<DynamicGeometry2>::apply([&](auto const& g2)
+        {
+            result = resolve_strategy::distance
+                        <
+                            Strategy
+                        >::apply(geometry1, g2, strategy);
+        }, geometry2);
+        return result;
+    }
+};
+
+
+template <typename DynamicGeometry1, typename DynamicGeometry2>
+struct distance<DynamicGeometry1, DynamicGeometry2, dynamic_geometry_tag, dynamic_geometry_tag>
+{
+    template <typename Strategy>
+    static inline auto apply(DynamicGeometry1 const& geometry1,
+                             DynamicGeometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        using result_t = typename geometry::distance_result<DynamicGeometry1, DynamicGeometry2, Strategy>::type;
+        result_t result = 0;
+        traits::visit<DynamicGeometry1, DynamicGeometry2>::apply([&](auto const& g1, auto const& g2)
+        {
+            result = resolve_strategy::distance
+                        <
+                            Strategy
+                        >::apply(g1, g2, strategy);
+        }, geometry1, geometry2);
+        return result;
+    }
+};
+
+} // namespace resolve_dynamic
+
+
+/*!
+\brief Calculate the distance between two geometries \brief_strategy
+\ingroup distance
+\details
+\details The free function distance calculates the distance between two geometries \brief_strategy. \details_strategy_reasons
+
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Strategy \tparam_strategy{Distance}
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param strategy \param_strategy{distance}
+\return \return_calc{distance}
+\note The strategy can be a point-point strategy. In case of distance point-line/point-polygon
+    it may also be a point-segment strategy.
+
+\qbk{distinguish,with strategy}
+
+\qbk{
+[heading Available Strategies]
+\* [link geometry.reference.strategies.strategy_distance_pythagoras Pythagoras (cartesian)]
+\* [link geometry.reference.strategies.strategy_distance_haversine Haversine (spherical)]
+\* [link geometry.reference.strategies.strategy_distance_cross_track Cross track (spherical\, point-to-segment)]
+\* [link geometry.reference.strategies.strategy_distance_projected_point Projected point (cartesian\, point-to-segment)]
+\* more (currently extensions): Vincenty\, Andoyer (geographic)
+}
+ */
+
+/*
+Note, in case of a Compilation Error:
+if you get:
+ - "Failed to specialize function template ..."
+ - "error: no matching function for call to ..."
+for distance, it is probably so that there is no specialization
+for return_type<...> for your strategy.
+*/
+template <typename Geometry1, typename Geometry2, typename Strategy>
+inline auto distance(Geometry1 const& geometry1,
+                     Geometry2 const& geometry2,
+                     Strategy const& strategy)
+{
+    concepts::check<Geometry1 const>();
+    concepts::check<Geometry2 const>();
+
+    detail::throw_on_empty_input(geometry1);
+    detail::throw_on_empty_input(geometry2);
+
+    return resolve_dynamic::distance
+               <
+                   Geometry1,
+                   Geometry2
+               >::apply(geometry1, geometry2, strategy);
+}
+
+
+/*!
+\brief Calculate the distance between two geometries.
+\ingroup distance
+\details The free function distance calculates the distance between two geometries. \details_default_strategy
+
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\return \return_calc{distance}
+
+\qbk{[include reference/algorithms/distance.qbk]}
+ */
+template <typename Geometry1, typename Geometry2>
+inline auto distance(Geometry1 const& geometry1,
+                     Geometry2 const& geometry2)
+{
+    return geometry::distance(geometry1, geometry2, default_strategy());
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_INTERFACE_HPP

thirdparty/include/boost/geometry/algorithms/detail/distance/is_comparable.hpp

@@ -0,0 +1,47 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2020, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHS_DETAIL_DISTANCE_IS_COMPARABLE_HPP
+#define BOOST_GEOMETRY_ALGORITHS_DETAIL_DISTANCE_IS_COMPARABLE_HPP
+
+
+#include <type_traits>
+
+#include <boost/geometry/strategies/distance.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+// metafunction to determine is a strategy is comparable or not
+template <typename Strategy>
+struct is_comparable
+    : std::is_same
+        <
+            Strategy,
+            typename strategy::distance::services::comparable_type
+              <
+                  Strategy
+              >::type
+        >
+{};
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHS_DETAIL_DISTANCE_IS_COMPARABLE_HPP

thirdparty/include/boost/geometry/algorithms/detail/distance/iterator_selector.hpp

@@ -0,0 +1,70 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHS_DETAIL_DISTANCE_ITERATOR_SELECTOR_HPP
+#define BOOST_GEOMETRY_ALGORITHS_DETAIL_DISTANCE_ITERATOR_SELECTOR_HPP
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/iterators/point_iterator.hpp>
+#include <boost/geometry/iterators/segment_iterator.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+// class to choose between point_iterator and segment_iterator
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct iterator_selector
+{
+    typedef geometry::segment_iterator<Geometry> iterator_type;
+
+    static inline iterator_type begin(Geometry& geometry)
+    {
+        return segments_begin(geometry);
+    }
+
+    static inline iterator_type end(Geometry& geometry)
+    {
+        return segments_end(geometry);
+    }
+};
+
+template <typename MultiPoint>
+struct iterator_selector<MultiPoint, multi_point_tag>
+{
+    typedef geometry::point_iterator<MultiPoint> iterator_type;
+
+    static inline iterator_type begin(MultiPoint& multipoint)
+    {
+        return points_begin(multipoint);
+    }
+
+    static inline iterator_type end(MultiPoint& multipoint)
+    {
+        return points_end(multipoint);
+    }
+};
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHS_DETAIL_DISTANCE_ITERATOR_SELECTOR_HPP

thirdparty/include/boost/geometry/algorithms/detail/distance/linear_or_areal_to_areal.hpp

@@ -0,0 +1,136 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2021, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_LINEAR_OR_AREAL_TO_AREAL_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_LINEAR_OR_AREAL_TO_AREAL_HPP
+
+#include <boost/geometry/algorithms/detail/distance/linear_to_linear.hpp>
+#include <boost/geometry/algorithms/detail/distance/strategy_utils.hpp>
+#include <boost/geometry/algorithms/intersects.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+template <typename Linear, typename Areal, typename Strategies>
+struct linear_to_areal
+{
+    typedef distance::return_t<Linear, Areal, Strategies> return_type;
+
+    static inline return_type apply(Linear const& linear,
+                                    Areal const& areal,
+                                    Strategies const& strategies)
+    {
+        if ( geometry::intersects(linear, areal, strategies) )
+        {
+            return return_type(0);
+        }
+
+        return linear_to_linear
+            <
+                Linear, Areal, Strategies
+            >::apply(linear, areal, strategies, false);
+    }
+
+
+    static inline return_type apply(Areal const& areal,
+                                    Linear const& linear,
+                                    Strategies const& strategies)
+    {
+        return apply(linear, areal, strategies);
+    }
+};
+
+template <typename Areal1, typename Areal2, typename Strategies>
+struct areal_to_areal
+{
+    typedef distance::return_t<Areal1, Areal2, Strategies> return_type;
+
+    static inline return_type apply(Areal1 const& areal1,
+                                    Areal2 const& areal2,
+                                    Strategies const& strategies)
+    {
+        if ( geometry::intersects(areal1, areal2, strategies) )
+        {
+            return return_type(0);
+        }
+
+        return linear_to_linear
+            <
+                Areal1, Areal2, Strategies
+            >::apply(areal1, areal2, strategies, false);
+    }
+};
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Linear, typename Areal, typename Strategy>
+struct distance
+    <
+        Linear, Areal, Strategy,
+        linear_tag, areal_tag,
+        strategy_tag_distance_point_segment, false
+    >
+    : detail::distance::linear_to_areal
+        <
+            Linear, Areal, Strategy
+        >
+{};
+
+template <typename Areal, typename Linear, typename Strategy>
+struct distance
+    <
+        Areal, Linear, Strategy,
+        areal_tag, linear_tag,
+        strategy_tag_distance_point_segment, false
+    >
+    : detail::distance::linear_to_areal
+        <
+            Linear, Areal, Strategy
+        >
+{};
+
+
+template <typename Areal1, typename Areal2, typename Strategy>
+struct distance
+    <
+        Areal1, Areal2, Strategy,
+        areal_tag, areal_tag,
+        strategy_tag_distance_point_segment, false
+    >
+    : detail::distance::areal_to_areal
+        <
+            Areal1, Areal2, Strategy
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_LINEAR_OR_AREAL_TO_AREAL_HPP

thirdparty/include/boost/geometry/algorithms/detail/distance/linear_to_box.hpp

@@ -0,0 +1,126 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2018-2021, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_LINEAR_TO_BOX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_LINEAR_TO_BOX_HPP
+
+#include <iterator>
+
+#include <boost/geometry/algorithms/intersects.hpp>
+#include <boost/geometry/algorithms/detail/distance/strategy_utils.hpp>
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+
+#include <boost/geometry/iterators/segment_iterator.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+template <typename Linear, typename Box, typename Strategies>
+struct linear_to_box
+{
+    typedef distance::return_t<Linear, Box, Strategies> return_type;
+
+    template <typename Iterator>
+    static inline return_type apply(Box const& box,
+                                    Iterator begin,
+                                    Iterator end,
+                                    Strategies const& strategies)
+    {
+        bool first = true;
+        return_type d_min(0);
+        for (Iterator it = begin; it != end; ++it, first = false)
+        {
+            typedef typename std::iterator_traits<Iterator>::value_type
+                    Segment;
+
+            return_type d = dispatch::distance<Segment, Box, Strategies>
+                                    ::apply(*it, box, strategies);
+
+            if ( first || d < d_min )
+            {
+                d_min = d;
+            }
+        }
+        return d_min;
+    }
+
+    static inline return_type apply(Linear const& linear,
+                                    Box const& box,
+                                    Strategies const& strategies)
+    {
+        if ( geometry::intersects(linear, box) )
+        {
+            return return_type(0);
+        }
+
+        return apply(box,
+                     geometry::segments_begin(linear),
+                     geometry::segments_end(linear),
+                     strategies);
+    }
+
+
+    static inline return_type apply(Box const& box,
+                                    Linear const& linear,
+                                    Strategies const& strategies)
+    {
+        return apply(linear, box, strategies);
+    }
+};
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Linear, typename Box, typename Strategy>
+struct distance
+    <
+        Linear, Box, Strategy,
+        linear_tag, box_tag,
+        strategy_tag_distance_segment_box, false
+    >
+    : detail::distance::linear_to_box
+        <
+            Linear, Box, Strategy
+        >
+{};
+
+
+template <typename Areal, typename Box, typename Strategy>
+struct distance
+    <
+        Areal, Box, Strategy,
+        areal_tag, box_tag,
+        strategy_tag_distance_segment_box, false
+    >
+    : detail::distance::linear_to_box
+        <
+            Areal, Box, Strategy
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_LINEAR_TO_BOX_HPP

thirdparty/include/boost/geometry/algorithms/detail/distance/linear_to_linear.hpp

@@ -0,0 +1,118 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2021, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_LINEAR_TO_LINEAR_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_LINEAR_TO_LINEAR_HPP
+
+#include <boost/geometry/algorithms/detail/distance/range_to_geometry_rtree.hpp>
+#include <boost/geometry/algorithms/detail/distance/strategy_utils.hpp>
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+#include <boost/geometry/algorithms/num_points.hpp>
+#include <boost/geometry/algorithms/num_segments.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/iterators/point_iterator.hpp>
+#include <boost/geometry/iterators/segment_iterator.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+template <typename Linear1, typename Linear2, typename Strategies>
+struct linear_to_linear
+{
+    typedef distance::return_t<Linear1, Linear2, Strategies> return_type;
+
+    static inline return_type apply(Linear1 const& linear1,
+                                    Linear2 const& linear2,
+                                    Strategies const& strategies,
+                                    bool = false)
+    {
+        if (geometry::num_points(linear1) == 1)
+        {
+            return dispatch::distance
+                <
+                    typename point_type<Linear1>::type,
+                    Linear2,
+                    Strategies
+                >::apply(*points_begin(linear1), linear2, strategies);
+        }
+
+        if (geometry::num_points(linear2) == 1)
+        {
+            return dispatch::distance
+                <
+                    typename point_type<Linear2>::type,
+                    Linear1,
+                    Strategies
+                >::apply(*points_begin(linear2), linear1, strategies);
+        }
+
+        if (geometry::num_segments(linear2) < geometry::num_segments(linear1))
+        {
+            return point_or_segment_range_to_geometry_rtree
+                <
+                    geometry::segment_iterator<Linear2 const>,
+                    Linear1,
+                    Strategies
+                >::apply(geometry::segments_begin(linear2),
+                         geometry::segments_end(linear2),
+                         linear1,
+                         strategies);
+
+        }
+
+        return point_or_segment_range_to_geometry_rtree
+            <
+                geometry::segment_iterator<Linear1 const>,
+                Linear2,
+                Strategies
+            >::apply(geometry::segments_begin(linear1),
+                     geometry::segments_end(linear1),
+                     linear2,
+                     strategies);
+    }
+};
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Linear1, typename Linear2, typename Strategy, typename StrategyTag>
+struct distance
+    <
+        Linear1, Linear2, Strategy,
+        linear_tag, linear_tag,
+        StrategyTag, false
+    > : detail::distance::linear_to_linear
+        <
+            Linear1, Linear2, Strategy
+        >
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_LINEAR_TO_LINEAR_HPP

thirdparty/include/boost/geometry/algorithms/detail/distance/multipoint_to_geometry.hpp

@@ -0,0 +1,221 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2021, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_MULTIPOINT_TO_GEOMETRY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_MULTIPOINT_TO_GEOMETRY_HPP
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/size.hpp>
+
+#include <boost/geometry/algorithms/covered_by.hpp>
+#include <boost/geometry/algorithms/detail/distance/range_to_geometry_rtree.hpp>
+#include <boost/geometry/algorithms/detail/distance/strategy_utils.hpp>
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+template <typename MultiPoint1, typename MultiPoint2, typename Strategies>
+struct multipoint_to_multipoint
+{
+    typedef distance::return_t<MultiPoint1, MultiPoint2, Strategies> return_type;
+
+    static inline return_type apply(MultiPoint1 const& multipoint1,
+                                    MultiPoint2 const& multipoint2,
+                                    Strategies const& strategies)
+    {
+        if (boost::size(multipoint2) < boost::size(multipoint1))
+        {
+            return point_or_segment_range_to_geometry_rtree
+                <
+                    typename boost::range_iterator<MultiPoint2 const>::type,
+                    MultiPoint1,
+                    Strategies
+                >::apply(boost::begin(multipoint2),
+                         boost::end(multipoint2),
+                         multipoint1,
+                         strategies);
+        }
+
+        return point_or_segment_range_to_geometry_rtree
+            <
+                typename boost::range_iterator<MultiPoint1 const>::type,
+                MultiPoint2,
+                Strategies
+            >::apply(boost::begin(multipoint1),
+                     boost::end(multipoint1),
+                     multipoint2,
+                     strategies);
+    }
+};
+
+
+template <typename MultiPoint, typename Linear, typename Strategies>
+struct multipoint_to_linear
+{
+    static inline auto apply(MultiPoint const& multipoint,
+                             Linear const& linear,
+                             Strategies const& strategies)
+    {
+        return detail::distance::point_or_segment_range_to_geometry_rtree
+            <
+                typename boost::range_iterator<MultiPoint const>::type,
+                Linear,
+                Strategies
+            >::apply(boost::begin(multipoint),
+                     boost::end(multipoint),
+                     linear,
+                     strategies);
+    }
+
+    static inline auto apply(Linear const& linear,
+                             MultiPoint const& multipoint,
+                             Strategies const& strategies)
+    {
+        return apply(multipoint, linear, strategies);
+    }
+};
+
+
+template <typename MultiPoint, typename Areal, typename Strategies>
+class multipoint_to_areal
+{
+private:
+    struct covered_by_areal
+    {
+        covered_by_areal(Areal const& areal, Strategies const& strategy)
+            : m_areal(areal), m_strategy(strategy)
+        {}
+
+        template <typename Point>
+        inline bool operator()(Point const& point) const
+        {
+            return geometry::covered_by(point, m_areal, m_strategy);
+        }
+
+        Areal const& m_areal;
+        Strategies const& m_strategy;
+    };
+
+public:
+    typedef distance::return_t<MultiPoint, Areal, Strategies> return_type;
+
+    static inline return_type apply(MultiPoint const& multipoint,
+                                    Areal const& areal,
+                                    Strategies const& strategies)
+    {
+        covered_by_areal predicate(areal, strategies);
+
+        if (! boost::empty(multipoint) &&
+            std::none_of(boost::begin(multipoint), boost::end(multipoint), predicate))
+        {
+            return detail::distance::point_or_segment_range_to_geometry_rtree
+                <
+                    typename boost::range_iterator<MultiPoint const>::type,
+                    Areal,
+                    Strategies
+                >::apply(boost::begin(multipoint),
+                         boost::end(multipoint),
+                         areal,
+                         strategies);
+        }
+        return return_type(0);
+    }
+
+    static inline return_type apply(Areal const& areal,
+                                    MultiPoint const& multipoint,
+                                    Strategies const& strategies)
+    {
+        return apply(multipoint, areal, strategies);
+    }
+};
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename MultiPoint1, typename MultiPoint2, typename Strategy>
+struct distance
+    <
+        MultiPoint1, MultiPoint2, Strategy,
+        multi_point_tag, multi_point_tag,
+        strategy_tag_distance_point_point, false
+    > : detail::distance::multipoint_to_multipoint
+        <
+            MultiPoint1, MultiPoint2, Strategy
+        >
+{};
+
+
+template <typename MultiPoint, typename Linear, typename Strategy>
+struct distance
+    <
+         MultiPoint, Linear, Strategy, multi_point_tag, linear_tag,
+         strategy_tag_distance_point_segment, false
+    > : detail::distance::multipoint_to_linear<MultiPoint, Linear, Strategy>
+{};
+
+
+template <typename Linear, typename MultiPoint, typename Strategy>
+struct distance
+    <
+         Linear, MultiPoint, Strategy, linear_tag, multi_point_tag,
+         strategy_tag_distance_point_segment, false
+    > : detail::distance::multipoint_to_linear<MultiPoint, Linear, Strategy>
+{};
+
+
+template <typename MultiPoint, typename Areal, typename Strategy>
+struct distance
+    <
+         MultiPoint, Areal, Strategy, multi_point_tag, areal_tag,
+         strategy_tag_distance_point_segment, false
+    > : detail::distance::multipoint_to_areal<MultiPoint, Areal, Strategy>
+{};
+
+
+template <typename Areal, typename MultiPoint, typename Strategy>
+struct distance
+    <
+         Areal, MultiPoint, Strategy, areal_tag, multi_point_tag,
+         strategy_tag_distance_point_segment, false
+    > : detail::distance::multipoint_to_areal<MultiPoint, Areal, Strategy>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_MULTIPOINT_TO_GEOMETRY_HPP

thirdparty/include/boost/geometry/algorithms/detail/distance/point_to_geometry.hpp

@@ -0,0 +1,539 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014-2021.
+// Modifications copyright (c) 2014-2021, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_POINT_TO_GEOMETRY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_POINT_TO_GEOMETRY_HPP
+
+#include <iterator>
+#include <type_traits>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/size.hpp>
+#include <boost/range/value_type.hpp>
+
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/detail/closest_feature/geometry_to_range.hpp>
+#include <boost/geometry/algorithms/detail/closest_feature/point_to_range.hpp>
+#include <boost/geometry/algorithms/detail/distance/is_comparable.hpp>
+#include <boost/geometry/algorithms/detail/distance/iterator_selector.hpp>
+#include <boost/geometry/algorithms/detail/distance/strategy_utils.hpp>
+#include <boost/geometry/algorithms/detail/within/point_in_geometry.hpp>
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/relate/services.hpp>
+#include <boost/geometry/strategies/tags.hpp>
+
+#include <boost/geometry/util/math.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+template
+<
+    typename P1, typename P2, typename Strategies,
+    bool IsUmbrella = strategies::detail::is_umbrella_strategy<Strategies>::value
+>
+struct point_to_point
+{
+    static inline
+    auto apply(P1 const& p1, P2 const& p2, Strategies const& strategies)
+    {
+        boost::ignore_unused(strategies);
+        return strategies.distance(p1, p2).apply(p1, p2);
+    }
+};
+
+// TEMP?
+// called by geometry_to_range
+template <typename P1, typename P2, typename Strategy>
+struct point_to_point<P1, P2, Strategy, false>
+{
+    static inline
+    auto apply(P1 const& p1, P2 const& p2, Strategy const& strategy)
+    {
+        boost::ignore_unused(strategy);
+        return strategy.apply(p1, p2);
+    }
+};
+
+
+template
+<
+    typename Point, typename Segment, typename Strategies,
+    bool IsUmbrella = strategies::detail::is_umbrella_strategy<Strategies>::value
+>
+struct point_to_segment
+{
+    static inline auto apply(Point const& point, Segment const& segment,
+                             Strategies const& strategies)
+    {
+        typename point_type<Segment>::type p[2];
+        geometry::detail::assign_point_from_index<0>(segment, p[0]);
+        geometry::detail::assign_point_from_index<1>(segment, p[1]);
+
+        boost::ignore_unused(strategies);
+        return strategies.distance(point, segment).apply(point, p[0], p[1]);
+    }
+};
+
+// TEMP?
+// called by geometry_to_range
+template <typename Point, typename Segment, typename Strategy>
+struct point_to_segment<Point, Segment, Strategy, false>
+{
+    static inline auto apply(Point const& point, Segment const& segment,
+                             Strategy const& strategy)
+    {
+        typename point_type<Segment>::type p[2];
+        geometry::detail::assign_point_from_index<0>(segment, p[0]);
+        geometry::detail::assign_point_from_index<1>(segment, p[1]);
+
+        boost::ignore_unused(strategy);
+        return strategy.apply(point, p[0], p[1]);
+    }
+};
+
+
+template
+<
+    typename Point, typename Box, typename Strategies,
+    bool IsUmbrella = strategies::detail::is_umbrella_strategy<Strategies>::value
+>
+struct point_to_box
+{
+    static inline auto apply(Point const& point, Box const& box,
+                             Strategies const& strategies)
+    {
+        boost::ignore_unused(strategies);
+        return strategies.distance(point, box).apply(point, box);
+    }
+};
+
+// TEMP?
+// called by geometry_to_range
+template <typename Point, typename Box, typename Strategy>
+struct point_to_box<Point, Box, Strategy, false>
+{
+    static inline auto apply(Point const& point, Box const& box,
+                             Strategy const& strategy)
+    {
+        boost::ignore_unused(strategy);
+        return strategy.apply(point, box);
+    }
+};
+
+
+template
+<
+    typename Point,
+    typename Range,
+    closure_selector Closure,
+    typename Strategies
+>
+class point_to_range
+{
+private:
+    typedef distance::strategy_t<Point, Range, Strategies> strategy_type;
+
+    typedef detail::closest_feature::point_to_point_range
+        <
+            Point, Range, Closure
+        > point_to_point_range;
+
+public:
+    typedef distance::return_t<Point, Range, Strategies> return_type;
+
+    static inline return_type apply(Point const& point, Range const& range,
+                                    Strategies const& strategies)
+    {
+        if (boost::size(range) == 0)
+        {
+            return return_type(0);
+        }
+
+        distance::creturn_t<Point, Range, Strategies> cd_min;
+
+        std::pair
+            <
+                typename boost::range_iterator<Range const>::type,
+                typename boost::range_iterator<Range const>::type
+            > it_pair
+            = point_to_point_range::apply(point,
+                                          boost::begin(range),
+                                          boost::end(range),
+                                          strategy::distance::services::get_comparable
+                                              <
+                                                  strategy_type
+                                              >::apply(strategies.distance(point, range)),
+                                          cd_min);
+
+        return
+            is_comparable<strategy_type>::value
+            ?
+            cd_min
+            :
+            strategies.distance(point, range).apply(point, *it_pair.first, *it_pair.second);
+    }
+};
+
+
+template
+<
+    typename Point,
+    typename Ring,
+    closure_selector Closure,
+    typename Strategies
+>
+struct point_to_ring
+{
+    typedef distance::return_t<Point, Ring, Strategies> return_type;
+
+    static inline return_type apply(Point const& point,
+                                    Ring const& ring,
+                                    Strategies const& strategies)
+    {
+        if (within::within_point_geometry(point, ring, strategies))
+        {
+            return return_type(0);
+        }
+
+        return point_to_range
+            <
+                Point, Ring, closure<Ring>::value, Strategies
+            >::apply(point, ring, strategies);
+    }
+};
+
+
+template
+<
+    typename Point,
+    typename Polygon,
+    closure_selector Closure,
+    typename Strategies
+>
+class point_to_polygon
+{
+public:
+    typedef distance::return_t<Point, Polygon, Strategies> return_type;
+
+private:
+    typedef point_to_range
+        <
+            Point, typename ring_type<Polygon>::type, Closure, Strategies
+        > per_ring;
+
+    struct distance_to_interior_rings
+    {
+        template <typename InteriorRingIterator>
+        static inline return_type apply(Point const& point,
+                                        InteriorRingIterator first,
+                                        InteriorRingIterator last,
+                                        Strategies const& strategies)
+        {
+            for (InteriorRingIterator it = first; it != last; ++it)
+            {
+                if (within::within_point_geometry(point, *it, strategies))
+                {
+                    // the point is inside a polygon hole, so its distance
+                    // to the polygon its distance to the polygon's
+                    // hole boundary
+                    return per_ring::apply(point, *it, strategies);
+                }
+            }
+            return return_type(0);
+        }
+
+        template <typename InteriorRings>
+        static inline return_type apply(Point const& point, InteriorRings const& interior_rings,
+                                        Strategies const& strategies)
+        {
+            return apply(point,
+                         boost::begin(interior_rings),
+                         boost::end(interior_rings),
+                         strategies);
+        }
+    };
+
+
+public:
+    static inline return_type apply(Point const& point,
+                                    Polygon const& polygon,
+                                    Strategies const& strategies)
+    {
+        if (! within::covered_by_point_geometry(point, exterior_ring(polygon),
+                                                strategies))
+        {
+            // the point is outside the exterior ring, so its distance
+            // to the polygon is its distance to the polygon's exterior ring
+            return per_ring::apply(point, exterior_ring(polygon), strategies);
+        }
+
+        // Check interior rings
+        return distance_to_interior_rings::apply(point,
+                                                 interior_rings(polygon),
+                                                 strategies);
+    }
+};
+
+
+template
+<
+    typename Point,
+    typename MultiGeometry,
+    typename Strategies,
+    bool CheckCoveredBy = std::is_same
+        <
+            typename tag<MultiGeometry>::type, multi_polygon_tag
+        >::value
+>
+class point_to_multigeometry
+{
+private:
+    typedef detail::closest_feature::geometry_to_range geometry_to_range;
+
+    typedef distance::strategy_t<Point, MultiGeometry, Strategies> strategy_type;
+
+public:
+    typedef distance::return_t<Point, MultiGeometry, Strategies> return_type;
+
+    static inline return_type apply(Point const& point,
+                                    MultiGeometry const& multigeometry,
+                                    Strategies const& strategies)
+    {
+        typedef iterator_selector<MultiGeometry const> selector_type;
+
+        distance::creturn_t<Point, MultiGeometry, Strategies> cd;
+
+        typename selector_type::iterator_type it_min
+            = geometry_to_range::apply(point,
+                                       selector_type::begin(multigeometry),
+                                       selector_type::end(multigeometry),
+                                       strategy::distance::services::get_comparable
+                                           <
+                                               strategy_type
+                                           >::apply(strategies.distance(point, multigeometry)),
+                                       cd);
+
+        // TODO - It would be possible to use a tool similar to result_from_distance
+        //        but working in the opposite way, i.e. calculating the distance
+        //        value from comparable distance value. This way the additional distance
+        //        call would not be needed.
+        return
+            is_comparable<strategy_type>::value
+            ?
+            cd
+            :
+            dispatch::distance
+                <
+                    Point,
+                    typename std::iterator_traits
+                        <
+                            typename selector_type::iterator_type
+                        >::value_type,
+                    Strategies
+                >::apply(point, *it_min, strategies);
+    }
+};
+
+
+// this is called only for multipolygons, hence the change in the
+// template parameter name MultiGeometry to MultiPolygon
+template <typename Point, typename MultiPolygon, typename Strategies>
+struct point_to_multigeometry<Point, MultiPolygon, Strategies, true>
+{
+    typedef distance::return_t<Point, MultiPolygon, Strategies> return_type;
+
+    static inline return_type apply(Point const& point,
+                                    MultiPolygon const& multipolygon,
+                                    Strategies const& strategies)
+    {
+        if (within::covered_by_point_geometry(point, multipolygon, strategies))
+        {
+            return return_type(0);
+        }
+
+        return point_to_multigeometry
+            <
+                Point, MultiPolygon, Strategies, false
+            >::apply(point, multipolygon, strategies);
+    }
+};
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename P1, typename P2, typename Strategy>
+struct distance
+    <
+        P1, P2, Strategy, point_tag, point_tag,
+        strategy_tag_distance_point_point, false
+    > : detail::distance::point_to_point<P1, P2, Strategy>
+{};
+
+
+template <typename Point, typename Linestring, typename Strategy>
+struct distance
+    <
+        Point, Linestring, Strategy, point_tag, linestring_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::point_to_range<Point, Linestring, closed, Strategy>
+{};
+
+
+template <typename Point, typename Ring, typename Strategy>
+struct distance
+    <
+        Point, Ring, Strategy, point_tag, ring_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::point_to_ring
+        <
+            Point, Ring, closure<Ring>::value, Strategy
+        >
+{};
+
+
+template <typename Point, typename Polygon, typename Strategy>
+struct distance
+    <
+        Point, Polygon, Strategy, point_tag, polygon_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::point_to_polygon
+        <
+            Point, Polygon, closure<Polygon>::value, Strategy
+        >
+{};
+
+
+template <typename Point, typename Segment, typename Strategy>
+struct distance
+    <
+        Point, Segment, Strategy, point_tag, segment_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::point_to_segment<Point, Segment, Strategy>
+{};
+
+
+template <typename Point, typename Box, typename Strategy>
+struct distance
+    <
+         Point, Box, Strategy, point_tag, box_tag,
+         strategy_tag_distance_point_box, false
+    > : detail::distance::point_to_box<Point, Box, Strategy>
+{};
+
+
+template<typename Point, typename MultiPoint, typename Strategy>
+struct distance
+    <
+        Point, MultiPoint, Strategy, point_tag, multi_point_tag,
+        strategy_tag_distance_point_point, false
+    > : detail::distance::point_to_multigeometry
+        <
+            Point, MultiPoint, Strategy
+        >
+{};
+
+
+template<typename Point, typename MultiLinestring, typename Strategy>
+struct distance
+    <
+        Point, MultiLinestring, Strategy, point_tag, multi_linestring_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::point_to_multigeometry
+        <
+            Point, MultiLinestring, Strategy
+        >
+{};
+
+
+template<typename Point, typename MultiPolygon, typename Strategy>
+struct distance
+    <
+        Point, MultiPolygon, Strategy, point_tag, multi_polygon_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::point_to_multigeometry
+        <
+            Point, MultiPolygon, Strategy
+        >
+{};
+
+
+template <typename Point, typename Linear, typename Strategy>
+struct distance
+    <
+         Point, Linear, Strategy, point_tag, linear_tag,
+         strategy_tag_distance_point_segment, false
+    > : distance
+        <
+            Point, Linear, Strategy,
+            point_tag, typename tag<Linear>::type,
+            strategy_tag_distance_point_segment, false
+        >
+{};
+
+
+template <typename Point, typename Areal, typename Strategy>
+struct distance
+    <
+         Point, Areal, Strategy, point_tag, areal_tag,
+         strategy_tag_distance_point_segment, false
+    > : distance
+        <
+            Point, Areal, Strategy,
+            point_tag, typename tag<Areal>::type,
+            strategy_tag_distance_point_segment, false
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_POINT_TO_GEOMETRY_HPP

thirdparty/include/boost/geometry/algorithms/detail/distance/range_to_geometry_rtree.hpp

@@ -0,0 +1,117 @@
+// Boost.Geometry
+
+// Copyright (c) 2014-2021, Oracle and/or its affiliates.
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_RANGE_TO_GEOMETRY_RTREE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_RANGE_TO_GEOMETRY_RTREE_HPP
+
+#include <iterator>
+#include <utility>
+
+#include <boost/geometry/algorithms/detail/closest_feature/range_to_range.hpp>
+#include <boost/geometry/algorithms/detail/distance/is_comparable.hpp>
+#include <boost/geometry/algorithms/detail/distance/iterator_selector.hpp>
+#include <boost/geometry/algorithms/detail/distance/strategy_utils.hpp>
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/iterators/detail/has_one_element.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+template
+<
+    typename PointOrSegmentIterator,
+    typename Geometry,
+    typename Strategies
+>
+class point_or_segment_range_to_geometry_rtree
+{
+private:
+    typedef typename std::iterator_traits
+        <
+            PointOrSegmentIterator
+        >::value_type point_or_segment_type;
+
+    typedef iterator_selector<Geometry const> selector_type;
+
+    typedef detail::closest_feature::range_to_range_rtree range_to_range;
+
+    typedef distance::strategy_t<point_or_segment_type, Geometry, Strategies> strategy_type;
+
+public:
+    typedef distance::return_t<point_or_segment_type, Geometry, Strategies> return_type;
+
+    static inline return_type apply(PointOrSegmentIterator first,
+                                    PointOrSegmentIterator last,
+                                    Geometry const& geometry,
+                                    Strategies const& strategies)
+    {
+        BOOST_GEOMETRY_ASSERT( first != last );
+
+        if ( detail::has_one_element(first, last) )
+        {
+            return dispatch::distance
+                <
+                    point_or_segment_type, Geometry, Strategies
+                >::apply(*first, geometry, strategies);
+        }
+
+        distance::creturn_t<point_or_segment_type, Geometry, Strategies> cd_min;
+
+        std::pair
+            <
+                point_or_segment_type,
+                typename selector_type::iterator_type
+            > closest_features
+            = range_to_range::apply(first,
+                                    last,
+                                    selector_type::begin(geometry),
+                                    selector_type::end(geometry),
+                                    strategies,
+                                    cd_min);
+
+        return
+            is_comparable<strategy_type>::value
+            ?
+            cd_min
+            :
+            dispatch::distance
+                <
+                    point_or_segment_type,
+                    typename std::iterator_traits
+                        <
+                            typename selector_type::iterator_type
+                        >::value_type,
+                    Strategies
+                >::apply(closest_features.first,
+                         *closest_features.second,
+                         strategies);
+    }
+};
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_RANGE_TO_GEOMETRY_RTREE_HPP

thirdparty/include/boost/geometry/algorithms/detail/distance/segment_to_box.hpp

@@ -0,0 +1,825 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2023 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_SEGMENT_TO_BOX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_SEGMENT_TO_BOX_HPP
+
+#include <cstddef>
+#include <functional>
+#include <type_traits>
+#include <vector>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <boost/geometry/algorithms/detail/assign_box_corners.hpp>
+#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
+#include <boost/geometry/algorithms/detail/closest_feature/point_to_range.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/segment_box.hpp>
+#include <boost/geometry/algorithms/detail/distance/is_comparable.hpp>
+#include <boost/geometry/algorithms/detail/distance/strategy_utils.hpp>
+#include <boost/geometry/algorithms/detail/dummy_geometries.hpp>
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/policies/compare.hpp>
+
+#include <boost/geometry/util/calculation_type.hpp>
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/has_nan_coordinate.hpp>
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/strategies/disjoint.hpp>
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/tags.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+template <typename Segment, typename Box, typename Strategy>
+inline bool intersects_segment_box(Segment const& segment, Box const& box,
+                                   Strategy const& strategy)
+{
+    return ! detail::disjoint::disjoint_segment_box::apply(segment, box, strategy);
+}
+
+// TODO: segment_to_box_2D_generic is not used anymore. Remove?
+
+// TODO: Furthermore this utility can potentially use different strategy than
+//       the one that was passed into bg::distance() but it seems this is by design.
+
+template
+<
+    typename Segment,
+    typename Box,
+    typename Strategies,
+    bool UsePointBoxStrategy = false // use only PointSegment strategy
+>
+class segment_to_box_2D_generic
+{
+private:
+    typedef typename point_type<Segment>::type segment_point;
+    typedef typename point_type<Box>::type box_point;
+
+    typedef distance::strategy_t<box_point, Segment, Strategies> ps_strategy_type;
+
+    typedef detail::closest_feature::point_to_point_range
+        <
+            segment_point,
+            std::vector<box_point>,
+            open
+        > point_to_point_range;
+
+public:
+    // TODO: Or should the return type be defined by sb_strategy_type?
+    typedef distance::return_t<box_point, Segment, Strategies> return_type;
+
+    static inline return_type apply(Segment const& segment,
+                                    Box const& box,
+                                    Strategies const& strategies,
+                                    bool check_intersection = true)
+    {
+        if (check_intersection && intersects_segment_box(segment, box, strategies))
+        {
+            return return_type(0);
+        }
+
+        // get segment points
+        segment_point p[2];
+        detail::assign_point_from_index<0>(segment, p[0]);
+        detail::assign_point_from_index<1>(segment, p[1]);
+
+        // get box points
+        std::vector<box_point> box_points(4);
+        detail::assign_box_corners_oriented<true>(box, box_points);
+
+        ps_strategy_type const strategy = strategies.distance(dummy_point(), dummy_segment());
+
+        auto const cstrategy = strategy::distance::services::get_comparable
+                                <
+                                    ps_strategy_type
+                                >::apply(strategy);
+
+        distance::creturn_t<box_point, Segment, Strategies> cd[6];
+        for (unsigned int i = 0; i < 4; ++i)
+        {
+            cd[i] = cstrategy.apply(box_points[i], p[0], p[1]);
+        }
+
+        std::pair
+            <
+                typename std::vector<box_point>::const_iterator,
+                typename std::vector<box_point>::const_iterator
+            > bit_min[2];
+
+        bit_min[0] = point_to_point_range::apply(p[0],
+                                                 box_points.begin(),
+                                                 box_points.end(),
+                                                 cstrategy,
+                                                 cd[4]);
+        bit_min[1] = point_to_point_range::apply(p[1],
+                                                 box_points.begin(),
+                                                 box_points.end(),
+                                                 cstrategy,
+                                                 cd[5]);
+
+        unsigned int imin = 0;
+        for (unsigned int i = 1; i < 6; ++i)
+        {
+            if (cd[i] < cd[imin])
+            {
+                imin = i;
+            }
+        }
+
+        if (BOOST_GEOMETRY_CONDITION(is_comparable<ps_strategy_type>::value))
+        {
+            return cd[imin];
+        }
+
+        if (imin < 4)
+        {
+            return strategy.apply(box_points[imin], p[0], p[1]);
+        }
+        else
+        {
+            unsigned int bimin = imin - 4;
+            return strategy.apply(p[bimin],
+                                  *bit_min[bimin].first,
+                                  *bit_min[bimin].second);
+        }
+    }
+};
+
+
+template
+<
+    typename Segment,
+    typename Box,
+    typename Strategies
+>
+class segment_to_box_2D_generic<Segment, Box, Strategies, true> // Use both PointSegment and PointBox strategies
+{
+private:
+    typedef typename point_type<Segment>::type segment_point;
+    typedef typename point_type<Box>::type box_point;
+
+    typedef distance::strategy_t<box_point, Segment, Strategies> ps_strategy_type;
+    typedef distance::strategy_t<segment_point, Box, Strategies> pb_strategy_type;
+
+public:
+    // TODO: Or should the return type be defined by sb_strategy_type?
+    typedef distance::return_t<box_point, Segment, Strategies> return_type;
+
+    static inline return_type apply(Segment const& segment,
+                                    Box const& box,
+                                    Strategies const& strategies,
+                                    bool check_intersection = true)
+    {
+        if (check_intersection && intersects_segment_box(segment, box, strategies))
+        {
+            return return_type(0);
+        }
+
+        // get segment points
+        segment_point p[2];
+        detail::assign_point_from_index<0>(segment, p[0]);
+        detail::assign_point_from_index<1>(segment, p[1]);
+
+        // get box points
+        std::vector<box_point> box_points(4);
+        detail::assign_box_corners_oriented<true>(box, box_points);
+
+        distance::creturn_t<box_point, Segment, Strategies> cd[6];
+
+        ps_strategy_type ps_strategy = strategies.distance(dummy_point(), dummy_segment());
+        auto const ps_cstrategy = strategy::distance::services::get_comparable
+                                    <
+                                        ps_strategy_type
+                                    >::apply(ps_strategy);
+        boost::ignore_unused(ps_strategy, ps_cstrategy);
+
+        for (unsigned int i = 0; i < 4; ++i)
+        {
+            cd[i] = ps_cstrategy.apply(box_points[i], p[0], p[1]);
+        }
+
+        pb_strategy_type const pb_strategy = strategies.distance(dummy_point(), dummy_box());
+        auto const pb_cstrategy = strategy::distance::services::get_comparable
+                                    <
+                                        pb_strategy_type
+                                    >::apply(pb_strategy);
+        boost::ignore_unused(pb_strategy, pb_cstrategy);
+
+        cd[4] = pb_cstrategy.apply(p[0], box);
+        cd[5] = pb_cstrategy.apply(p[1], box);
+
+        unsigned int imin = 0;
+        for (unsigned int i = 1; i < 6; ++i)
+        {
+            if (cd[i] < cd[imin])
+            {
+                imin = i;
+            }
+        }
+
+        if (imin < 4)
+        {
+            if (is_comparable<ps_strategy_type>::value)
+            {
+                return cd[imin];
+            }
+
+            return ps_strategy.apply(box_points[imin], p[0], p[1]);
+        }
+        else
+        {
+            if (is_comparable<pb_strategy_type>::value)
+            {
+                return cd[imin];
+            }
+
+            return pb_strategy.apply(p[imin - 4], box);
+        }
+    }
+};
+
+
+
+
+template
+<
+    typename ReturnType,
+    typename SegmentPoint,
+    typename BoxPoint,
+    typename Strategies
+>
+class segment_to_box_2D
+{
+private:
+    template <typename Result>
+    struct cast_to_result
+    {
+        template <typename T>
+        static inline Result apply(T const& t)
+        {
+            return boost::numeric_cast<Result>(t);
+        }
+    };
+
+
+    template <typename T, bool IsLess /* true */>
+    struct compare_less_equal
+    {
+        typedef compare_less_equal<T, !IsLess> other;
+
+        template <typename T1, typename T2>
+        inline bool operator()(T1 const& t1, T2 const& t2) const
+        {
+            return std::less_equal<T>()(cast_to_result<T>::apply(t1),
+                                        cast_to_result<T>::apply(t2));
+        }
+    };
+
+    template <typename T>
+    struct compare_less_equal<T, false>
+    {
+        typedef compare_less_equal<T, true> other;
+
+        template <typename T1, typename T2>
+        inline bool operator()(T1 const& t1, T2 const& t2) const
+        {
+            return std::greater_equal<T>()(cast_to_result<T>::apply(t1),
+                                           cast_to_result<T>::apply(t2));
+        }
+    };
+
+
+    template <typename LessEqual>
+    struct other_compare
+    {
+        typedef typename LessEqual::other type;
+    };
+
+
+    // it is assumed here that p0 lies to the right of the box (so the
+    // entire segment lies to the right of the box)
+    template <typename LessEqual>
+    struct right_of_box
+    {
+        static inline ReturnType apply(SegmentPoint const& p0,
+                                       SegmentPoint const& p1,
+                                       BoxPoint const& bottom_right,
+                                       BoxPoint const& top_right,
+                                       Strategies const& strategies)
+        {
+            // the implementation below is written for non-negative slope
+            // segments
+            //
+            // for negative slope segments swap the roles of bottom_right
+            // and top_right and use greater_equal instead of less_equal.
+
+            typedef cast_to_result<ReturnType> cast;
+
+            LessEqual less_equal;
+
+            auto const ps_strategy = strategies.distance(dummy_point(), dummy_segment());
+
+            if (less_equal(geometry::get<1>(bottom_right), geometry::get<1>(p0)))
+            {
+                //if p0 is in box's band
+                if (less_equal(geometry::get<1>(p0), geometry::get<1>(top_right)))
+                {
+                    // segment & crosses band (TODO:merge with box-box dist)
+                    if (math::equals(geometry::get<0>(p0), geometry::get<0>(p1)))
+                    {
+                        SegmentPoint high = geometry::get<1>(p1) > geometry::get<1>(p0) ? p1 : p0;
+                        if (less_equal(geometry::get<1>(high), geometry::get<1>(top_right)))
+                        {
+                            return cast::apply(ps_strategy.apply(high, bottom_right, top_right));
+                        }
+                        return cast::apply(ps_strategy.apply(top_right, p0, p1));
+                    }
+                    return cast::apply(ps_strategy.apply(p0, bottom_right, top_right));
+                }
+                // distance is realized between the top-right
+                // corner of the box and the segment
+                return cast::apply(ps_strategy.apply(top_right, p0, p1));
+            }
+            else
+            {
+                // distance is realized between the bottom-right
+                // corner of the box and the segment
+                return cast::apply(ps_strategy.apply(bottom_right, p0, p1));
+            }
+        }
+    };
+
+    // it is assumed here that p0 lies above the box (so the
+    // entire segment lies above the box)
+
+    template <typename LessEqual>
+    struct above_of_box
+    {
+
+        static inline ReturnType apply(SegmentPoint const& p0,
+                                       SegmentPoint const& p1,
+                                       BoxPoint const& top_left,
+                                       Strategies const& strategies)
+        {
+            return apply(p0, p1, p0, top_left, strategies);
+        }
+
+        static inline ReturnType apply(SegmentPoint const& p0,
+                                       SegmentPoint const& p1,
+                                       SegmentPoint const& p_max,
+                                       BoxPoint const& top_left,
+                                       Strategies const& strategies)
+        {
+            auto const ps_strategy = strategies.distance(dummy_point(), dummy_segment());
+
+            typedef cast_to_result<ReturnType> cast;
+            LessEqual less_equal;
+
+            // p0 is above the upper segment of the box (and inside its band)
+            // then compute the vertical (i.e. meridian for spherical) distance
+            if (less_equal(geometry::get<0>(top_left), geometry::get<0>(p_max)))
+            {
+                ReturnType diff = ps_strategy.vertical_or_meridian(
+                                    geometry::get_as_radian<1>(p_max),
+                                    geometry::get_as_radian<1>(top_left));
+
+                return strategy::distance::services::result_from_distance
+                    <
+                        std::remove_const_t<decltype(ps_strategy)>,
+                        SegmentPoint, BoxPoint
+                    >::apply(ps_strategy, math::abs(diff));
+            }
+
+            // p0 is to the left of the box, but p1 is above the box
+            // in this case the distance is realized between the
+            // top-left corner of the box and the segment
+            return cast::apply(ps_strategy.apply(top_left, p0, p1));
+        }
+    };
+
+    template <typename LessEqual>
+    struct check_right_left_of_box
+    {
+        static inline bool apply(SegmentPoint const& p0,
+                                 SegmentPoint const& p1,
+                                 BoxPoint const& top_left,
+                                 BoxPoint const& top_right,
+                                 BoxPoint const& bottom_left,
+                                 BoxPoint const& bottom_right,
+                                 Strategies const& strategies,
+                                 ReturnType& result)
+        {
+            // p0 lies to the right of the box
+            if (geometry::get<0>(p0) >= geometry::get<0>(top_right))
+            {
+                result = right_of_box
+                    <
+                        LessEqual
+                    >::apply(p0, p1, bottom_right, top_right,
+                             strategies);
+                return true;
+            }
+
+            // p1 lies to the left of the box
+            if (geometry::get<0>(p1) <= geometry::get<0>(bottom_left))
+            {
+                result = right_of_box
+                    <
+                        typename other_compare<LessEqual>::type
+                    >::apply(p1, p0, top_left, bottom_left,
+                             strategies);
+                return true;
+            }
+
+            return false;
+        }
+    };
+
+    template <typename LessEqual>
+    struct check_above_below_of_box
+    {
+        static inline bool apply(SegmentPoint const& p0,
+                                 SegmentPoint const& p1,
+                                 BoxPoint const& top_left,
+                                 BoxPoint const& top_right,
+                                 BoxPoint const& bottom_left,
+                                 BoxPoint const& bottom_right,
+                                 Strategies const& strategies,
+                                 ReturnType& result)
+        {
+            typedef compare_less_equal<ReturnType, false> GreaterEqual;
+
+            // the segment lies below the box
+            if (geometry::get<1>(p1) < geometry::get<1>(bottom_left))
+            {
+                auto const sb_strategy = strategies.distance(dummy_segment(), dummy_box());
+
+                // TODO: this strategy calls this algorithm's again, specifically:
+                //       geometry::detail::distance::segment_to_box_2D<>::call_above_of_box
+                //       If possible rewrite them to avoid this.
+                //       For now just pass umbrella strategy.
+                result = sb_strategy.template segment_below_of_box
+                        <
+                            LessEqual,
+                            ReturnType
+                        >(p0, p1,
+                          top_left, top_right,
+                          bottom_left, bottom_right,
+                          strategies);
+                return true;
+            }
+
+            // the segment lies above the box
+            if (geometry::get<1>(p0) > geometry::get<1>(top_right))
+            {
+                result = (std::min)(above_of_box
+                                    <
+                                        LessEqual
+                                    >::apply(p0, p1, top_left, strategies),
+                                    above_of_box
+                                    <
+                                        GreaterEqual
+                                    >::apply(p1, p0, top_right, strategies));
+                return true;
+            }
+            return false;
+        }
+    };
+
+    struct check_generic_position
+    {
+        static inline bool apply(SegmentPoint const& p0,
+                                 SegmentPoint const& p1,
+                                 BoxPoint const& corner1,
+                                 BoxPoint const& corner2,
+                                 Strategies const& strategies,
+                                 ReturnType& result)
+        {
+            auto const side_strategy = strategies.side();
+            auto const ps_strategy = strategies.distance(dummy_point(), dummy_segment());
+
+            typedef cast_to_result<ReturnType> cast;
+            ReturnType diff1 = cast::apply(geometry::get<1>(p1))
+                               - cast::apply(geometry::get<1>(p0));
+
+            int sign = diff1 < 0 ? -1 : 1;
+            if (side_strategy.apply(p0, p1, corner1) * sign < 0)
+            {
+                result = cast::apply(ps_strategy.apply(corner1, p0, p1));
+                return true;
+            }
+            if (side_strategy.apply(p0, p1, corner2) * sign > 0)
+            {
+                result = cast::apply(ps_strategy.apply(corner2, p0, p1));
+                return true;
+            }
+            return false;
+        }
+    };
+
+    static inline ReturnType
+    non_negative_slope_segment(SegmentPoint const& p0,
+                               SegmentPoint const& p1,
+                               BoxPoint const& top_left,
+                               BoxPoint const& top_right,
+                               BoxPoint const& bottom_left,
+                               BoxPoint const& bottom_right,
+                               Strategies const& strategies)
+    {
+        typedef compare_less_equal<ReturnType, true> less_equal;
+
+        // assert that the segment has non-negative slope
+        BOOST_GEOMETRY_ASSERT( ( math::equals(geometry::get<0>(p0), geometry::get<0>(p1))
+                              && geometry::get<1>(p0) < geometry::get<1>(p1))
+                            ||
+                               ( geometry::get<0>(p0) < geometry::get<0>(p1)
+                              && geometry::get<1>(p0) <= geometry::get<1>(p1) )
+                            || geometry::has_nan_coordinate(p0)
+                            || geometry::has_nan_coordinate(p1));
+
+        ReturnType result(0);
+
+        if (check_right_left_of_box
+                <
+                    less_equal
+                >::apply(p0, p1,
+                         top_left, top_right, bottom_left, bottom_right,
+                         strategies, result))
+        {
+            return result;
+        }
+
+        if (check_above_below_of_box
+                <
+                    less_equal
+                >::apply(p0, p1,
+                         top_left, top_right, bottom_left, bottom_right,
+                         strategies, result))
+        {
+            return result;
+        }
+
+        if (check_generic_position::apply(p0, p1,
+                                          top_left, bottom_right,
+                                          strategies, result))
+        {
+            return result;
+        }
+
+        // in all other cases the box and segment intersect, so return 0
+        return result;
+    }
+
+
+    static inline ReturnType
+    negative_slope_segment(SegmentPoint const& p0,
+                           SegmentPoint const& p1,
+                           BoxPoint const& top_left,
+                           BoxPoint const& top_right,
+                           BoxPoint const& bottom_left,
+                           BoxPoint const& bottom_right,
+                           Strategies const& strategies)
+    {
+        typedef compare_less_equal<ReturnType, false> greater_equal;
+
+        // assert that the segment has negative slope
+        BOOST_GEOMETRY_ASSERT( ( geometry::get<0>(p0) < geometry::get<0>(p1)
+                              && geometry::get<1>(p0) > geometry::get<1>(p1) )
+                            || geometry::has_nan_coordinate(p0)
+                            || geometry::has_nan_coordinate(p1) );
+
+        ReturnType result(0);
+
+        if (check_right_left_of_box
+                <
+                    greater_equal
+                >::apply(p0, p1,
+                         bottom_left, bottom_right, top_left, top_right,
+                         strategies, result))
+        {
+            return result;
+        }
+
+        if (check_above_below_of_box
+                <
+                    greater_equal
+                >::apply(p1, p0,
+                         top_right, top_left, bottom_right, bottom_left,
+                         strategies, result))
+        {
+            return result;
+        }
+
+        if (check_generic_position::apply(p0, p1,
+                                          bottom_left, top_right,
+                                          strategies, result))
+        {
+            return result;
+        }
+
+        // in all other cases the box and segment intersect, so return 0
+        return result;
+    }
+
+public:
+    static inline ReturnType apply(SegmentPoint const& p0,
+                                   SegmentPoint const& p1,
+                                   BoxPoint const& top_left,
+                                   BoxPoint const& top_right,
+                                   BoxPoint const& bottom_left,
+                                   BoxPoint const& bottom_right,
+                                   Strategies const& strategies)
+    {
+        BOOST_GEOMETRY_ASSERT( (geometry::less<SegmentPoint, -1, Strategies>()(p0, p1))
+                            || geometry::has_nan_coordinate(p0)
+                            || geometry::has_nan_coordinate(p1) );
+
+        if (geometry::get<0>(p0) < geometry::get<0>(p1)
+            && geometry::get<1>(p0) > geometry::get<1>(p1))
+        {
+            return negative_slope_segment(p0, p1,
+                                          top_left, top_right,
+                                          bottom_left, bottom_right,
+                                          strategies);
+        }
+
+        return non_negative_slope_segment(p0, p1,
+                                          top_left, top_right,
+                                          bottom_left, bottom_right,
+                                          strategies);
+    }
+
+    template <typename LessEqual>
+    static inline ReturnType call_above_of_box(SegmentPoint const& p0,
+                                               SegmentPoint const& p1,
+                                               SegmentPoint const& p_max,
+                                               BoxPoint const& top_left,
+                                               Strategies const& strategies)
+    {
+        return above_of_box<LessEqual>::apply(p0, p1, p_max, top_left, strategies);
+    }
+
+    template <typename LessEqual>
+    static inline ReturnType call_above_of_box(SegmentPoint const& p0,
+                                               SegmentPoint const& p1,
+                                               BoxPoint const& top_left,
+                                               Strategies const& strategies)
+    {
+        return above_of_box<LessEqual>::apply(p0, p1, top_left, strategies);
+    }
+};
+
+//=========================================================================
+
+template
+<
+    typename Segment,
+    typename Box,
+    typename std::size_t Dimension,
+    typename Strategies
+>
+class segment_to_box
+    : not_implemented<Segment, Box>
+{};
+
+
+template
+<
+    typename Segment,
+    typename Box,
+    typename Strategies
+>
+class segment_to_box<Segment, Box, 2, Strategies>
+{
+    typedef distance::strategy_t<Segment, Box, Strategies> strategy_type;
+
+public:
+    typedef distance::return_t<Segment, Box, Strategies> return_type;
+
+    static inline return_type apply(Segment const& segment,
+                                    Box const& box,
+                                    Strategies const& strategies)
+    {
+        typedef typename point_type<Segment>::type segment_point;
+        typedef typename point_type<Box>::type box_point;
+
+        segment_point p[2];
+        detail::assign_point_from_index<0>(segment, p[0]);
+        detail::assign_point_from_index<1>(segment, p[1]);
+
+        if (detail::equals::equals_point_point(p[0], p[1], strategies))
+        {
+            return dispatch::distance
+                <
+                    segment_point,
+                    Box,
+                    Strategies
+                >::apply(p[0], box, strategies);
+        }
+
+        box_point top_left, top_right, bottom_left, bottom_right;
+        detail::assign_box_corners(box, bottom_left, bottom_right,
+                                   top_left, top_right);
+
+        strategy_type::mirror(p[0], p[1],
+                              bottom_left, bottom_right,
+                              top_left, top_right);
+
+        typedef geometry::less<segment_point, -1, Strategies> less_type;
+        if (less_type()(p[0], p[1]))
+        {
+            return segment_to_box_2D
+                <
+                    return_type,
+                    segment_point,
+                    box_point,
+                    Strategies
+                >::apply(p[0], p[1],
+                         top_left, top_right, bottom_left, bottom_right,
+                         strategies);
+        }
+        else
+        {
+            return segment_to_box_2D
+                <
+                    return_type,
+                    segment_point,
+                    box_point,
+                    Strategies
+                >::apply(p[1], p[0],
+                         top_left, top_right, bottom_left, bottom_right,
+                         strategies);
+        }
+    }
+};
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Segment, typename Box, typename Strategies>
+struct distance
+    <
+        Segment, Box, Strategies, segment_tag, box_tag,
+        strategy_tag_distance_segment_box, false
+    >
+{
+    static inline auto apply(Segment const& segment, Box const& box,
+                             Strategies const& strategies)
+    {
+        assert_dimension_equal<Segment, Box>();
+
+        return detail::distance::segment_to_box
+            <
+                Segment,
+                Box,
+                dimension<Segment>::value,
+                Strategies
+            >::apply(segment, box, strategies);
+    }
+};
+
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_SEGMENT_TO_BOX_HPP

thirdparty/include/boost/geometry/algorithms/detail/distance/segment_to_segment.hpp

@@ -0,0 +1,136 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2021, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_SEGMENT_TO_SEGMENT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_SEGMENT_TO_SEGMENT_HPP
+
+#include <algorithm>
+#include <iterator>
+
+#include <boost/core/addressof.hpp>
+
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/detail/distance/is_comparable.hpp>
+#include <boost/geometry/algorithms/detail/distance/strategy_utils.hpp>
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+#include <boost/geometry/algorithms/intersects.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/tags.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+
+// compute segment-segment distance
+template<typename Segment1, typename Segment2, typename Strategies>
+class segment_to_segment
+{
+    typedef distance::strategy_t<Segment1, Segment2, Strategies> strategy_type;
+
+public:
+    typedef distance::return_t<Segment1, Segment2, Strategies> return_type;
+
+    static inline return_type apply(Segment1 const& segment1, Segment2 const& segment2,
+                                    Strategies const& strategies)
+    {
+        if (geometry::intersects(segment1, segment2, strategies))
+        {
+            return 0;
+        }
+
+        typename point_type<Segment1>::type p[2];
+        detail::assign_point_from_index<0>(segment1, p[0]);
+        detail::assign_point_from_index<1>(segment1, p[1]);
+
+        typename point_type<Segment2>::type q[2];
+        detail::assign_point_from_index<0>(segment2, q[0]);
+        detail::assign_point_from_index<1>(segment2, q[1]);
+
+        strategy_type const strategy = strategies.distance(segment1, segment2);
+
+        auto const cstrategy = strategy::distance::services::get_comparable
+                                <
+                                    strategy_type
+                                >::apply(strategy);
+
+        distance::creturn_t<Segment1, Segment2, Strategies> d[4];
+        d[0] = cstrategy.apply(q[0], p[0], p[1]);
+        d[1] = cstrategy.apply(q[1], p[0], p[1]);
+        d[2] = cstrategy.apply(p[0], q[0], q[1]);
+        d[3] = cstrategy.apply(p[1], q[0], q[1]);
+
+        std::size_t imin = std::distance(boost::addressof(d[0]),
+                                         std::min_element(d, d + 4));
+
+        if (BOOST_GEOMETRY_CONDITION(is_comparable<strategy_type>::value))
+        {
+            return d[imin];
+        }
+
+        switch (imin)
+        {
+        case 0:
+            return strategy.apply(q[0], p[0], p[1]);
+        case 1:
+            return strategy.apply(q[1], p[0], p[1]);
+        case 2:
+            return strategy.apply(p[0], q[0], q[1]);
+        default:
+            return strategy.apply(p[1], q[0], q[1]);
+        }
+    }
+};
+
+
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+
+// segment-segment
+template <typename Segment1, typename Segment2, typename Strategy>
+struct distance
+    <
+        Segment1, Segment2, Strategy, segment_tag, segment_tag,
+        strategy_tag_distance_point_segment, false
+    >
+    : detail::distance::segment_to_segment<Segment1, Segment2, Strategy>
+{};
+
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_SEGMENT_TO_SEGMENT_HPP

thirdparty/include/boost/geometry/algorithms/detail/distance/strategy_utils.hpp

@@ -0,0 +1,64 @@
+// Boost.Geometry
+
+// Copyright (c) 2021, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHS_DETAIL_DISTANCE_STRATEGY_UTILS_HPP
+#define BOOST_GEOMETRY_ALGORITHS_DETAIL_DISTANCE_STRATEGY_UTILS_HPP
+
+
+#include <utility>
+
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+template <typename Geometry1, typename Geometry2, typename Strategies>
+using strategy_t = decltype(
+    std::declval<Strategies>().distance(std::declval<Geometry1>(), std::declval<Geometry2>()));
+
+
+template <typename Geometry1, typename Geometry2, typename Strategies>
+using return_t = typename strategy::distance::services::return_type
+    <
+        strategy_t<Geometry1, Geometry2, Strategies>,
+        typename point_type<Geometry1>::type,
+        typename point_type<Geometry2>::type
+    >::type;
+
+
+template <typename Geometry1, typename Geometry2, typename Strategies>
+using cstrategy_t = typename strategy::distance::services::comparable_type
+    <
+        strategy_t<Geometry1, Geometry2, Strategies>
+    >::type;
+
+
+template <typename Geometry1, typename Geometry2, typename Strategies>
+using creturn_t = typename strategy::distance::services::return_type
+    <
+        cstrategy_t<Geometry1, Geometry2, Strategies>,
+        typename point_type<Geometry1>::type,
+        typename point_type<Geometry2>::type
+    >::type;
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHS_DETAIL_DISTANCE_STRATEGY_UTILS_HPP