FM / geographic

/usr/include/boost/geometry/strategies/geographic/

/usr/include/boost/geometry/strategies/geographic

Name	Size	Mode	Actions
area.hpp	6933	0644	edit dl rm
azimuth.hpp	4021	0644	edit dl rm
buffer_point_circle.hpp	4189	0644	edit dl rm
densify.hpp	4004	0644	edit dl rm
disjoint_segment_box.hpp	4043	0644	edit dl rm
distance.hpp	6294	0644	edit dl rm
distance_andoyer.hpp	3829	0644	edit dl rm
distance_cross_track.hpp	34524	0644	edit dl rm
distance_cross_track_box_box.hpp	7147	0644	edit dl rm
distance_cross_track_point_box.hpp	6780	0644	edit dl rm
distance_karney.hpp	2985	0644	edit dl rm
distance_segment_box.hpp	10100	0644	edit dl rm
distance_thomas.hpp	3354	0644	edit dl rm
distance_vincenty.hpp	3547	0644	edit dl rm
envelope.hpp	3348	0644	edit dl rm
envelope_segment.hpp	3795	0644	edit dl rm
expand_segment.hpp	2915	0644	edit dl rm
index.hpp	7450	0644	edit dl rm
intersection.hpp	37874	0644	edit dl rm
intersection_elliptic.hpp	6899	0644	edit dl rm
io.hpp	2285	0644	edit dl rm
line_interpolate.hpp	3710	0644	edit dl rm
mapping_ssf.hpp	5625	0644	edit dl rm
parameters.hpp	5467	0644	edit dl rm
point_in_poly_winding.hpp	2122	0644	edit dl rm
point_order.hpp	3107	0644	edit dl rm
side.hpp	4609	0644	edit dl rm
side_andoyer.hpp	1501	0644	edit dl rm
side_thomas.hpp	1493	0644	edit dl rm
side_vincenty.hpp	1509	0644	edit dl rm

Edit: /usr/include/boost/geometry/strategies/geographic/distance_cross_track_box_box.hpp (7147B)

// Boost.Geometry (aka GGL, Generic Geometry Library)

// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
// 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_STRATEGIES_GEOGRAPHIC_DISTANCE_CROSS_TRACK_BOX_BOX_HPP
#define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_DISTANCE_CROSS_TRACK_BOX_BOX_HPP

#include <boost/config.hpp>
#include <boost/concept_check.hpp>
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_void.hpp>

#include <boost/geometry/core/access.hpp>
#include <boost/geometry/core/assert.hpp>
#include <boost/geometry/core/point_type.hpp>
#include <boost/geometry/core/radian_access.hpp>
#include <boost/geometry/core/tags.hpp>

#include <boost/geometry/strategies/distance.hpp>
#include <boost/geometry/strategies/concepts/distance_concept.hpp>
#include <boost/geometry/strategies/geographic/distance.hpp>
#include <boost/geometry/strategies/geographic/distance_cross_track.hpp>
#include <boost/geometry/strategies/spherical/distance_cross_track.hpp>
#include <boost/geometry/strategies/spherical/distance_cross_track_box_box.hpp>

#include <boost/geometry/util/math.hpp>
#include <boost/geometry/algorithms/detail/assign_box_corners.hpp>

namespace boost { namespace geometry
{

namespace strategy { namespace distance
{

/*!
\brief Strategy functor for distance point to box calculation
\ingroup strategies
\details Class which calculates the distance of a point to a box, for
points and boxes on a sphere or globe
\tparam CalculationType \tparam_calculation
\tparam Strategy underlying point-segment distance strategy, defaults
to cross track
\qbk{
[heading See also]
[link geometry.reference.algorithms.distance.distance_3_with_strategy distance (with strategy)]
}
*/
template
<
    typename FormulaPolicy = strategy::andoyer,
    typename Spheroid = srs::spheroid<double>,
    typename CalculationType = void
>
class geographic_cross_track_box_box
{
public:

// point-point strategy getters
    struct distance_pp_strategy
    {
        typedef geographic<FormulaPolicy, Spheroid, CalculationType> type;
    };

// point-segment strategy getters
    struct distance_ps_strategy
    {
        typedef geographic_cross_track
                <
                    FormulaPolicy,
                    Spheroid,
                    CalculationType
                > type;
    };

template <typename Box1, typename Box2>
    struct return_type : services::return_type
            <
                typename distance_ps_strategy::type,
                typename point_type<Box1>::type,
                typename point_type<Box2>::type
            >
    {};

//constructor

explicit geographic_cross_track_box_box(Spheroid const& spheroid = Spheroid())
             : m_spheroid(spheroid)
    {}

template <typename Box1, typename Box2>
    inline typename return_type<Box1, Box2>::type
    apply(Box1 const& box1, Box2 const& box2) const
    {
/*
#if !defined(BOOST_MSVC)
        BOOST_CONCEPT_ASSERT
            (
                (concepts::PointSegmentDistanceStrategy
                    <
                        Strategy,
                        typename point_type<Box1>::type,
                        typename point_type<Box2>::type
                    >)
            );
#endif
*/
        typedef typename return_type<Box1, Box2>::type return_type;
        return details::cross_track_box_box_generic
                                       <return_type>::apply(box1, box2,
                                                            typename distance_pp_strategy::type(m_spheroid),
                                                            typename distance_ps_strategy::type(m_spheroid));
    }
private :
    Spheroid m_spheroid;
};

#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
namespace services
{

template <typename Strategy, typename Spheroid, typename CalculationType>
struct tag<geographic_cross_track_box_box<Strategy, Spheroid, CalculationType> >
{
    typedef strategy_tag_distance_box_box type;
};

template <typename Strategy, typename Spheroid, typename CalculationType, typename Box1, typename Box2>
struct return_type<geographic_cross_track_box_box<Strategy, Spheroid, CalculationType>, Box1, Box2>
    : geographic_cross_track_box_box
        <
            Strategy, Spheroid, CalculationType
        >::template return_type<Box1, Box2>
{};

template <typename Strategy, typename Spheroid, typename Box1, typename Box2>
struct return_type<geographic_cross_track_box_box<Strategy, Spheroid>, Box1, Box2>
    : geographic_cross_track_box_box
        <
            Strategy, Spheroid
        >::template return_type<Box1, Box2>
{};

template <typename Strategy, typename Box1, typename Box2>
struct return_type<geographic_cross_track_box_box<Strategy>, Box1, Box2>
    : geographic_cross_track_box_box
        <
            Strategy
        >::template return_type<Box1, Box2>
{};

template <typename Strategy, typename Spheroid, typename CalculationType>
struct comparable_type<geographic_cross_track_box_box<Strategy, Spheroid, CalculationType> >
{
    typedef geographic_cross_track_box_box
        <
            typename comparable_type<Strategy>::type, Spheroid, CalculationType
        > type;
};

template <typename Strategy, typename Spheroid, typename CalculationType>
struct get_comparable<geographic_cross_track_box_box<Strategy, Spheroid, CalculationType> >
{
public:
    static inline geographic_cross_track_box_box<Strategy, Spheroid, CalculationType>
    apply(geographic_cross_track_box_box<Strategy, Spheroid, CalculationType> const& str)
    {
        return str;
    }
};

template <typename Strategy, typename Spheroid, typename CalculationType, typename Box1, typename Box2>
struct result_from_distance
    <
        geographic_cross_track_box_box<Strategy, Spheroid, CalculationType>, Box1, Box2
    >
{
private:
    typedef geographic_cross_track_box_box<Strategy, Spheroid, CalculationType> this_strategy;

typedef typename this_strategy::template return_type
        <
            Box1, Box2
        >::type return_type;

public:
    template <typename T>
    static inline return_type apply(this_strategy const& strategy,
                                    T const& distance)
    {
        result_from_distance
            <
                Strategy,
                typename point_type<Box1>::type,
                typename point_type<Box2>::type
            >::apply(strategy, distance);
    }
};

template <typename Box1, typename Box2>
struct default_strategy
    <
        box_tag, box_tag, Box1, Box2,
        geographic_tag, geographic_tag
    >
{
    typedef geographic_cross_track_box_box<> type;
};

} // namespace services
#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS

}} // namespace strategy::distance

}} // namespace boost::geometry

#endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_DISTANCE_CROSS_TRACK_BOX_BOX_HPP

// Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2017-2018, 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 // 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_STRATEGIES_GEOGRAPHIC_DISTANCE_CROSS_TRACK_BOX_BOX_HPP #define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_DISTANCE_CROSS_TRACK_BOX_BOX_HPP #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace geometry { namespace strategy { namespace distance { /*! \brief Strategy functor for distance point to box calculation \ingroup strategies \details Class which calculates the distance of a point to a box, for points and boxes on a sphere or globe \tparam CalculationType \tparam_calculation \tparam Strategy underlying point-segment distance strategy, defaults to cross track \qbk{ [heading See also] [link geometry.reference.algorithms.distance.distance_3_with_strategy distance (with strategy)] } */ template < typename FormulaPolicy = strategy::andoyer, typename Spheroid = srs::spheroid, typename CalculationType = void > class geographic_cross_track_box_box { public: // point-point strategy getters struct distance_pp_strategy { typedef geographic type; }; // point-segment strategy getters struct distance_ps_strategy { typedef geographic_cross_track < FormulaPolicy, Spheroid, CalculationType > type; }; template struct return_type : services::return_type < typename distance_ps_strategy::type, typename point_type::type, typename point_type::type > {}; //constructor explicit geographic_cross_track_box_box(Spheroid const& spheroid = Spheroid()) : m_spheroid(spheroid) {} template inline typename return_type::type apply(Box1 const& box1, Box2 const& box2) const { /* #if !defined(BOOST_MSVC) BOOST_CONCEPT_ASSERT ( (concepts::PointSegmentDistanceStrategy < Strategy, typename point_type::type, typename point_type::type >) ); #endif */ typedef typename return_type::type return_type; return details::cross_track_box_box_generic ::apply(box1, box2, typename distance_pp_strategy::type(m_spheroid), typename distance_ps_strategy::type(m_spheroid)); } private : Spheroid m_spheroid; }; #ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS namespace services { template struct tag > { typedef strategy_tag_distance_box_box type; }; template struct return_type, Box1, Box2> : geographic_cross_track_box_box < Strategy, Spheroid, CalculationType >::template return_type {}; template struct return_type, Box1, Box2> : geographic_cross_track_box_box < Strategy, Spheroid >::template return_type {}; template struct return_type, Box1, Box2> : geographic_cross_track_box_box < Strategy >::template return_type {}; template struct comparable_type > { typedef geographic_cross_track_box_box < typename comparable_type::type, Spheroid, CalculationType > type; }; template struct get_comparable > { public: static inline geographic_cross_track_box_box apply(geographic_cross_track_box_box const& str) { return str; } }; template struct result_from_distance < geographic_cross_track_box_box, Box1, Box2 > { private: typedef geographic_cross_track_box_box this_strategy; typedef typename this_strategy::template return_type < Box1, Box2 >::type return_type; public: template static inline return_type apply(this_strategy const& strategy, T const& distance) { result_from_distance < Strategy, typename point_type::type, typename point_type::type >::apply(strategy, distance); } }; template struct default_strategy < box_tag, box_tag, Box1, Box2, geographic_tag, geographic_tag > { typedef geographic_cross_track_box_box<> type; }; } // namespace services #endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS }} // namespace strategy::distance }} // namespace boost::geometry #endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_DISTANCE_CROSS_TRACK_BOX_BOX_HPP