FM / algorithms

/usr/include/boost/geometry/algorithms

Name	Size	Mode	Actions
detail/	-	0755	rm
dispatch/	-	0755	rm
append.hpp	11493	0644	edit dl rm
area.hpp	10657	0644	edit dl rm
assign.hpp	10709	0644	edit dl rm
buffer.hpp	8656	0644	edit dl rm
centroid.hpp	19620	0644	edit dl rm
clear.hpp	5156	0644	edit dl rm
comparable_distance.hpp	1107	0644	edit dl rm
convert.hpp	17327	0644	edit dl rm
convex_hull.hpp	11589	0644	edit dl rm
correct.hpp	9956	0644	edit dl rm
correct_closure.hpp	5862	0644	edit dl rm
covered_by.hpp	1077	0644	edit dl rm
crosses.hpp	8478	0644	edit dl rm
densify.hpp	12472	0644	edit dl rm
difference.hpp	16591	0644	edit dl rm
discrete_frechet_distance.hpp	7844	0644	edit dl rm
discrete_hausdorff_distance.hpp	11281	0644	edit dl rm
disjoint.hpp	1191	0644	edit dl rm
distance.hpp	1110	0644	edit dl rm
envelope.hpp	1021	0644	edit dl rm
equals.hpp	1196	0644	edit dl rm
expand.hpp	1073	0644	edit dl rm
for_each.hpp	9831	0644	edit dl rm
intersection.hpp	806	0644	edit dl rm
intersects.hpp	1145	0644	edit dl rm
is_convex.hpp	6508	0644	edit dl rm
is_empty.hpp	4853	0644	edit dl rm
is_simple.hpp	575	0644	edit dl rm
is_valid.hpp	570	0644	edit dl rm
length.hpp	9341	0644	edit dl rm
line_interpolate.hpp	13054	0644	edit dl rm
make.hpp	5170	0644	edit dl rm
not_implemented.hpp	3839	0644	edit dl rm
num_geometries.hpp	3586	0644	edit dl rm
num_interior_rings.hpp	3756	0644	edit dl rm
num_points.hpp	5565	0644	edit dl rm
num_segments.hpp	4775	0644	edit dl rm
overlaps.hpp	1067	0644	edit dl rm
perimeter.hpp	7212	0644	edit dl rm
point_on_surface.hpp	13281	0644	edit dl rm
relate.hpp	642	0644	edit dl rm
relation.hpp	652	0644	edit dl rm
remove_spikes.hpp	9753	0644	edit dl rm
reverse.hpp	4386	0644	edit dl rm
simplify.hpp	22696	0644	edit dl rm
sym_difference.hpp	23169	0644	edit dl rm
touches.hpp	1127	0644	edit dl rm
transform.hpp	14105	0644	edit dl rm
union.hpp	21383	0644	edit dl rm
unique.hpp	4682	0644	edit dl rm
validity_failure_type.hpp	3684	0644	edit dl rm
within.hpp	1057	0644	edit dl rm

Edit: /usr/include/boost/geometry/algorithms/discrete_hausdorff_distance.hpp (11281B)

// Boost.Geometry

// Copyright (c) 2018 Yaghyavardhan Singh Khangarot, Hyderabad, India.
// Contributed and/or modified by Yaghyavardhan Singh Khangarot,
//   as part of Google Summer of Code 2018 program.

// This file was modified by Oracle on 2018.
// Modifications copyright (c) 2018, Oracle and/or its affiliates.
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle

// 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_DISCRETE_HAUSDORFF_DISTANCE_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DISCRETE_HAUSDORFF_DISTANCE_HPP

#include <algorithm>

#ifdef BOOST_GEOMETRY_DEBUG_HAUSDORFF_DISTANCE
#include <iostream>
#endif

#include <iterator>
#include <utility>
#include <vector>
#include <limits>

#include <boost/geometry/algorithms/detail/throw_on_empty_input.hpp>
#include <boost/geometry/algorithms/not_implemented.hpp>
#include <boost/geometry/core/point_type.hpp>
#include <boost/geometry/core/tag.hpp>
#include <boost/geometry/core/tags.hpp>
#include <boost/geometry/strategies/distance.hpp>
#include <boost/geometry/strategies/distance_result.hpp>
#include <boost/geometry/util/range.hpp>

#ifdef BOOST_GEOMETRY_ENABLE_SIMILARITY_RTREE
#include <boost/geometry/index/rtree.hpp>
#endif // BOOST_GEOMETRY_ENABLE_SIMILARITY_RTREE

namespace boost { namespace geometry
{

#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace discrete_hausdorff_distance
{

struct point_range
{
    template <typename Point, typename Range, typename Strategy>
    static inline
    typename distance_result
        <
            typename point_type<Point>::type,
            typename point_type<Range>::type,
            Strategy
        >::type
    apply(Point const& pnt, Range const& rng, Strategy const& strategy)
    {
        typedef typename distance_result
            <
                typename point_type<Point>::type,
                typename point_type<Range>::type,
                Strategy
            >::type result_type;
        typedef typename boost::range_size<Range>::type size_type;

size_type const n = boost::size(rng);
        result_type dis_min = 0;
        bool is_dis_min_set = false;

for (size_type i = 0 ; i < n ; i++)
        {
            result_type dis_temp = strategy.apply(pnt, range::at(rng, i));
            if (! is_dis_min_set || dis_temp < dis_min)
            {
                dis_min = dis_temp;
                is_dis_min_set = true;
            }
        }
        return dis_min;
    }
};

struct range_range
{
    template <typename Range1, typename Range2, typename Strategy>
    static inline
    typename distance_result
        <
            typename point_type<Range1>::type,
            typename point_type<Range2>::type,
            Strategy
        >::type
    apply(Range1 const& r1, Range2 const& r2, Strategy const& strategy)
    {

typedef typename distance_result
            <
                typename point_type<Range1>::type,
                typename point_type<Range2>::type,
                Strategy
            >::type result_type;

typedef typename boost::range_size<Range1>::type size_type;

boost::geometry::detail::throw_on_empty_input(r1);
        boost::geometry::detail::throw_on_empty_input(r2);

size_type const n = boost::size(r1);
        result_type dis_max = 0;

#ifdef BOOST_GEOMETRY_ENABLE_SIMILARITY_RTREE
        namespace bgi = boost::geometry::index;
        typedef typename point_type<Range1>::type point_t;
        typedef bgi::rtree<point_t, bgi::linear<4> > rtree_type;
        rtree_type rtree(boost::begin(r2), boost::end(r2));
        point_t res;
#endif

for (size_type i = 0 ; i < n ; i++)
        {
#ifdef BOOST_GEOMETRY_ENABLE_SIMILARITY_RTREE
            size_type found = rtree.query(bgi::nearest(range::at(r1, i), 1), &res);
            result_type dis_min = strategy.apply(range::at(r1,i), res);
#else
            result_type dis_min = point_range::apply(range::at(r1, i), r2, strategy);
#endif
            if (dis_min > dis_max )
            {
                dis_max = dis_min;
            }
        }
        return dis_max;
    }
};

struct range_multi_range
{
    template <typename Range, typename Multi_range, typename Strategy>
    static inline
    typename distance_result
        <
            typename point_type<Range>::type,
            typename point_type<Multi_range>::type,
            Strategy
        >::type
    apply(Range const& rng, Multi_range const& mrng, Strategy const& strategy)
    {
        typedef typename distance_result
            <
                typename point_type<Range>::type,
                typename point_type<Multi_range>::type,
                Strategy
            >::type result_type;
        typedef typename boost::range_size<Multi_range>::type size_type;

boost::geometry::detail::throw_on_empty_input(rng);
        boost::geometry::detail::throw_on_empty_input(mrng);

size_type b = boost::size(mrng);
        result_type haus_dis = 0;

for (size_type j = 0 ; j < b ; j++)
        {
            result_type dis_max = range_range::apply(rng, range::at(mrng, j), strategy);
            if (dis_max > haus_dis)
            {
                haus_dis = dis_max;
            }
        }

return haus_dis;
    }
};

struct multi_range_multi_range
{
    template <typename Multi_Range1, typename Multi_range2, typename Strategy>
    static inline
    typename distance_result
        <
            typename point_type<Multi_Range1>::type,
            typename point_type<Multi_range2>::type,
            Strategy
        >::type
    apply(Multi_Range1 const& mrng1, Multi_range2 const& mrng2, Strategy const& strategy)
    {
        typedef typename distance_result
            <
                typename point_type<Multi_Range1>::type,
                typename point_type<Multi_range2>::type,
                Strategy
            >::type result_type;
        typedef typename boost::range_size<Multi_Range1>::type size_type;

boost::geometry::detail::throw_on_empty_input(mrng1);
        boost::geometry::detail::throw_on_empty_input(mrng2);
        
        size_type n = boost::size(mrng1);
        result_type haus_dis = 0;

for (size_type i = 0 ; i < n ; i++)
        {
            result_type dis_max = range_multi_range::apply(range::at(mrng1, i), mrng2, strategy);
            if (dis_max > haus_dis)
            {
                haus_dis = dis_max;
            }
        }
        return haus_dis;
    }
};

}} // namespace detail::hausdorff_distance
#endif // DOXYGEN_NO_DETAIL

#ifndef DOXYGEN_NO_DISPATCH
namespace dispatch
{
template
<
    typename Geometry1,
    typename Geometry2,
    typename Tag1 = typename tag<Geometry1>::type,
    typename Tag2 = typename tag<Geometry2>::type
>
struct discrete_hausdorff_distance : not_implemented<Tag1, Tag2>
{};

// Specialization for point and multi_point
template <typename Point, typename MultiPoint>
struct discrete_hausdorff_distance<Point, MultiPoint, point_tag, multi_point_tag>
    : detail::discrete_hausdorff_distance::point_range
{};

// Specialization for linestrings
template <typename Linestring1, typename Linestring2>
struct discrete_hausdorff_distance<Linestring1, Linestring2, linestring_tag, linestring_tag>
    : detail::discrete_hausdorff_distance::range_range
{};

// Specialization for multi_point-multi_point
template <typename MultiPoint1, typename MultiPoint2>
struct discrete_hausdorff_distance<MultiPoint1, MultiPoint2, multi_point_tag, multi_point_tag>
    : detail::discrete_hausdorff_distance::range_range
{};

// Specialization for Linestring and MultiLinestring
template <typename Linestring, typename MultiLinestring>
struct discrete_hausdorff_distance<Linestring, MultiLinestring, linestring_tag, multi_linestring_tag>
    : detail::discrete_hausdorff_distance::range_multi_range
{};

// Specialization for MultiLinestring and MultiLinestring
template <typename MultiLinestring1, typename MultiLinestring2>
struct discrete_hausdorff_distance<MultiLinestring1, MultiLinestring2, multi_linestring_tag, multi_linestring_tag>
    : detail::discrete_hausdorff_distance::multi_range_multi_range
{};

} // namespace dispatch
#endif // DOXYGEN_NO_DISPATCH

// Algorithm overload using explicitly passed Pt-Pt distance strategy

/*!
\brief Calculate discrete Hausdorff distance between two geometries (currently
    works for LineString-LineString, MultiPoint-MultiPoint, Point-MultiPoint,
    MultiLineString-MultiLineString) using specified strategy.
\ingroup discrete_hausdorff_distance
\tparam Geometry1 \tparam_geometry
\tparam Geometry2 \tparam_geometry
\tparam Strategy A type fulfilling a DistanceStrategy concept
\param geometry1 Input geometry
\param geometry2 Input geometry
\param strategy Distance strategy to be used to calculate Pt-Pt distance

\qbk{distinguish,with strategy}
\qbk{[include reference/algorithms/discrete_hausdorff_distance.qbk]}

\qbk{
[heading Available Strategies]
\* [link geometry.reference.strategies.strategy_distance_pythagoras Pythagoras (cartesian)]
\* [link geometry.reference.strategies.strategy_distance_haversine Haversine (spherical)]
[/ \* more (currently extensions): Vincenty\, Andoyer (geographic) ]

[heading Example]
[discrete_hausdorff_distance_strategy]
[discrete_hausdorff_distance_strategy_output]
}
*/
template <typename Geometry1, typename Geometry2, typename Strategy>
inline
typename distance_result
    <
        typename point_type<Geometry1>::type,
        typename point_type<Geometry2>::type,
        Strategy
    >::type
discrete_hausdorff_distance(Geometry1 const& geometry1,
                            Geometry2 const& geometry2,
                            Strategy const& strategy)
{
    return dispatch::discrete_hausdorff_distance
        <
            Geometry1, Geometry2
        >::apply(geometry1, geometry2, strategy);
}

\qbk{[include reference/algorithms/discrete_hausdorff_distance.qbk]}

\qbk{
[heading Example]
[discrete_hausdorff_distance]
[discrete_hausdorff_distance_output]
}
*/
template <typename Geometry1, typename Geometry2>
inline
typename distance_result
    <
        typename point_type<Geometry1>::type,
        typename point_type<Geometry2>::type
    >::type
discrete_hausdorff_distance(Geometry1 const& geometry1,
                            Geometry2 const& geometry2)
{
    typedef typename strategy::distance::services::default_strategy
        <
            point_tag, point_tag,
            typename point_type<Geometry1>::type,
            typename point_type<Geometry2>::type
        >::type strategy_type;

return discrete_hausdorff_distance(geometry1, geometry2, strategy_type());
}

}} // namespace boost::geometry

#endif // BOOST_GEOMETRY_ALGORITHMS_DISCRETE_HAUSDORFF_DISTANCE_HPP

// Boost.Geometry // Copyright (c) 2018 Yaghyavardhan Singh Khangarot, Hyderabad, India. // Contributed and/or modified by Yaghyavardhan Singh Khangarot, // as part of Google Summer of Code 2018 program. // This file was modified by Oracle on 2018. // Modifications copyright (c) 2018, Oracle and/or its affiliates. // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle // 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_DISCRETE_HAUSDORFF_DISTANCE_HPP #define BOOST_GEOMETRY_ALGORITHMS_DISCRETE_HAUSDORFF_DISTANCE_HPP #include #ifdef BOOST_GEOMETRY_DEBUG_HAUSDORFF_DISTANCE #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BOOST_GEOMETRY_ENABLE_SIMILARITY_RTREE #include #endif // BOOST_GEOMETRY_ENABLE_SIMILARITY_RTREE namespace boost { namespace geometry { #ifndef DOXYGEN_NO_DETAIL namespace detail { namespace discrete_hausdorff_distance { struct point_range { template static inline typename distance_result < typename point_type::type, typename point_type::type, Strategy >::type apply(Point const& pnt, Range const& rng, Strategy const& strategy) { typedef typename distance_result < typename point_type::type, typename point_type::type, Strategy >::type result_type; typedef typename boost::range_size::type size_type; size_type const n = boost::size(rng); result_type dis_min = 0; bool is_dis_min_set = false; for (size_type i = 0 ; i < n ; i++) { result_type dis_temp = strategy.apply(pnt, range::at(rng, i)); if (! is_dis_min_set || dis_temp < dis_min) { dis_min = dis_temp; is_dis_min_set = true; } } return dis_min; } }; struct range_range { template static inline typename distance_result < typename point_type::type, typename point_type::type, Strategy >::type apply(Range1 const& r1, Range2 const& r2, Strategy const& strategy) { typedef typename distance_result < typename point_type::type, typename point_type::type, Strategy >::type result_type; typedef typename boost::range_size::type size_type; boost::geometry::detail::throw_on_empty_input(r1); boost::geometry::detail::throw_on_empty_input(r2); size_type const n = boost::size(r1); result_type dis_max = 0; #ifdef BOOST_GEOMETRY_ENABLE_SIMILARITY_RTREE namespace bgi = boost::geometry::index; typedef typename point_type::type point_t; typedef bgi::rtree > rtree_type; rtree_type rtree(boost::begin(r2), boost::end(r2)); point_t res; #endif for (size_type i = 0 ; i < n ; i++) { #ifdef BOOST_GEOMETRY_ENABLE_SIMILARITY_RTREE size_type found = rtree.query(bgi::nearest(range::at(r1, i), 1), &res); result_type dis_min = strategy.apply(range::at(r1,i), res); #else result_type dis_min = point_range::apply(range::at(r1, i), r2, strategy); #endif if (dis_min > dis_max ) { dis_max = dis_min; } } return dis_max; } }; struct range_multi_range { template static inline typename distance_result < typename point_type::type, typename point_type::type, Strategy >::type apply(Range const& rng, Multi_range const& mrng, Strategy const& strategy) { typedef typename distance_result < typename point_type::type, typename point_type::type, Strategy >::type result_type; typedef typename boost::range_size::type size_type; boost::geometry::detail::throw_on_empty_input(rng); boost::geometry::detail::throw_on_empty_input(mrng); size_type b = boost::size(mrng); result_type haus_dis = 0; for (size_type j = 0 ; j < b ; j++) { result_type dis_max = range_range::apply(rng, range::at(mrng, j), strategy); if (dis_max > haus_dis) { haus_dis = dis_max; } } return haus_dis; } }; struct multi_range_multi_range { template static inline typename distance_result < typename point_type::type, typename point_type::type, Strategy >::type apply(Multi_Range1 const& mrng1, Multi_range2 const& mrng2, Strategy const& strategy) { typedef typename distance_result < typename point_type::type, typename point_type::type, Strategy >::type result_type; typedef typename boost::range_size::type size_type; boost::geometry::detail::throw_on_empty_input(mrng1); boost::geometry::detail::throw_on_empty_input(mrng2); size_type n = boost::size(mrng1); result_type haus_dis = 0; for (size_type i = 0 ; i < n ; i++) { result_type dis_max = range_multi_range::apply(range::at(mrng1, i), mrng2, strategy); if (dis_max > haus_dis) { haus_dis = dis_max; } } return haus_dis; } }; }} // namespace detail::hausdorff_distance #endif // DOXYGEN_NO_DETAIL #ifndef DOXYGEN_NO_DISPATCH namespace dispatch { template < typename Geometry1, typename Geometry2, typename Tag1 = typename tag::type, typename Tag2 = typename tag::type > struct discrete_hausdorff_distance : not_implemented {}; // Specialization for point and multi_point template struct discrete_hausdorff_distance : detail::discrete_hausdorff_distance::point_range {}; // Specialization for linestrings template struct discrete_hausdorff_distance : detail::discrete_hausdorff_distance::range_range {}; // Specialization for multi_point-multi_point template struct discrete_hausdorff_distance : detail::discrete_hausdorff_distance::range_range {}; // Specialization for Linestring and MultiLinestring template struct discrete_hausdorff_distance : detail::discrete_hausdorff_distance::range_multi_range {}; // Specialization for MultiLinestring and MultiLinestring template struct discrete_hausdorff_distance : detail::discrete_hausdorff_distance::multi_range_multi_range {}; } // namespace dispatch #endif // DOXYGEN_NO_DISPATCH // Algorithm overload using explicitly passed Pt-Pt distance strategy /*! \brief Calculate discrete Hausdorff distance between two geometries (currently works for LineString-LineString, MultiPoint-MultiPoint, Point-MultiPoint, MultiLineString-MultiLineString) using specified strategy. \ingroup discrete_hausdorff_distance \tparam Geometry1 \tparam_geometry \tparam Geometry2 \tparam_geometry \tparam Strategy A type fulfilling a DistanceStrategy concept \param geometry1 Input geometry \param geometry2 Input geometry \param strategy Distance strategy to be used to calculate Pt-Pt distance \qbk{distinguish,with strategy} \qbk{[include reference/algorithms/discrete_hausdorff_distance.qbk]} \qbk{ [heading Available Strategies] \* [link geometry.reference.strategies.strategy_distance_pythagoras Pythagoras (cartesian)] \* [link geometry.reference.strategies.strategy_distance_haversine Haversine (spherical)] [/ \* more (currently extensions): Vincenty\, Andoyer (geographic) ] [heading Example] [discrete_hausdorff_distance_strategy] [discrete_hausdorff_distance_strategy_output] } */ template inline typename distance_result < typename point_type::type, typename point_type::type, Strategy >::type discrete_hausdorff_distance(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy) { return dispatch::discrete_hausdorff_distance < Geometry1, Geometry2 >::apply(geometry1, geometry2, strategy); } /*! \brief Calculate discrete Hausdorff distance between two geometries (currently works for LineString-LineString, MultiPoint-MultiPoint, Point-MultiPoint, MultiLineString-MultiLineString). \ingroup discrete_hausdorff_distance \tparam Geometry1 \tparam_geometry \tparam Geometry2 \tparam_geometry \param geometry1 Input geometry \param geometry2 Input geometry \qbk{[include reference/algorithms/discrete_hausdorff_distance.qbk]} \qbk{ [heading Example] [discrete_hausdorff_distance] [discrete_hausdorff_distance_output] } */ template inline typename distance_result < typename point_type::type, typename point_type::type >::type discrete_hausdorff_distance(Geometry1 const& geometry1, Geometry2 const& geometry2) { typedef typename strategy::distance::services::default_strategy < point_tag, point_tag, typename point_type::type, typename point_type::type >::type strategy_type; return discrete_hausdorff_distance(geometry1, geometry2, strategy_type()); } }} // namespace boost::geometry #endif // BOOST_GEOMETRY_ALGORITHMS_DISCRETE_HAUSDORFF_DISTANCE_HPP