FM / spherical

/usr/include/boost/geometry/strategies/spherical/

/usr/include/boost/geometry/strategies/spherical

Name	Size	Mode	Actions
area.hpp	4959	0644	edit dl rm
azimuth.hpp	3489	0644	edit dl rm
compare.hpp	9997	0644	edit dl rm
densify.hpp	4079	0644	edit dl rm
disjoint_box_box.hpp	4633	0644	edit dl rm
disjoint_segment_box.hpp	3588	0644	edit dl rm
distance_cross_track.hpp	27455	0644	edit dl rm
distance_cross_track_box_box.hpp	15443	0644	edit dl rm
distance_cross_track_point_box.hpp	13202	0644	edit dl rm
distance_haversine.hpp	9669	0644	edit dl rm
distance_segment_box.hpp	14187	0644	edit dl rm
envelope.hpp	4370	0644	edit dl rm
envelope_box.hpp	2130	0644	edit dl rm
envelope_multipoint.hpp	13234	0644	edit dl rm
envelope_point.hpp	3397	0644	edit dl rm
envelope_segment.hpp	14133	0644	edit dl rm
expand_box.hpp	5203	0644	edit dl rm
expand_point.hpp	8242	0644	edit dl rm
expand_segment.hpp	3435	0644	edit dl rm
get_radius.hpp	2109	0644	edit dl rm
index.hpp	6805	0644	edit dl rm
intersection.hpp	39856	0644	edit dl rm
io.hpp	1977	0644	edit dl rm
line_interpolate.hpp	3131	0644	edit dl rm
point_in_point.hpp	5771	0644	edit dl rm
point_in_poly_winding.hpp	21516	0644	edit dl rm
point_order.hpp	3787	0644	edit dl rm
side_by_cross_track.hpp	2864	0644	edit dl rm
ssf.hpp	5038	0644	edit dl rm

Edit: /usr/include/boost/geometry/strategies/spherical/densify.hpp (4079B)

// Boost.Geometry

// 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_STRATEGIES_SPHERICAL_DENSIFY_HPP
#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DENSIFY_HPP

#include <boost/geometry/algorithms/detail/convert_point_to_point.hpp>
#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
#include <boost/geometry/arithmetic/arithmetic.hpp>
#include <boost/geometry/arithmetic/cross_product.hpp>
#include <boost/geometry/arithmetic/dot_product.hpp>
#include <boost/geometry/arithmetic/normalize.hpp>
#include <boost/geometry/core/assert.hpp>
#include <boost/geometry/core/coordinate_dimension.hpp>
#include <boost/geometry/core/coordinate_type.hpp>
#include <boost/geometry/core/radian_access.hpp>
#include <boost/geometry/formulas/spherical.hpp>
#include <boost/geometry/formulas/interpolate_point_spherical.hpp>
#include <boost/geometry/geometries/point.hpp>
#include <boost/geometry/srs/sphere.hpp>
#include <boost/geometry/strategies/densify.hpp>
#include <boost/geometry/strategies/spherical/get_radius.hpp>
#include <boost/geometry/util/math.hpp>
#include <boost/geometry/util/select_most_precise.hpp>

namespace boost { namespace geometry
{

namespace strategy { namespace densify
{

/*!
\brief Densification of spherical segment.
\ingroup strategies
\tparam RadiusTypeOrSphere \tparam_radius_or_sphere
\tparam CalculationType \tparam_calculation

\qbk{
[heading See also]
[link geometry.reference.algorithms.densify.densify_4_with_strategy densify (with strategy)]
}
 */
template
<
    typename RadiusTypeOrSphere = double,
    typename CalculationType = void
>
class spherical
{
public:
    // For consistency with area strategy the radius is set to 1
    inline spherical()
        : m_radius(1.0)
    {}

template <typename RadiusOrSphere>
    explicit inline spherical(RadiusOrSphere const& radius_or_sphere)
        : m_radius(strategy_detail::get_radius
                    <
                        RadiusOrSphere
                    >::apply(radius_or_sphere))
    {}

template <typename Point, typename AssignPolicy, typename T>
    inline void apply(Point const& p0, Point const& p1, AssignPolicy & policy, T const& length_threshold) const
    {
        typedef typename AssignPolicy::point_type out_point_t;
        typedef typename select_most_precise
            <
                typename coordinate_type<Point>::type,
                typename coordinate_type<out_point_t>::type,
                CalculationType
            >::type calc_t;

calc_t angle01;

formula::interpolate_point_spherical<calc_t> formula;
        formula.compute_angle(p0, p1, angle01);

BOOST_GEOMETRY_ASSERT(length_threshold > T(0));

signed_size_type n = signed_size_type(angle01 * m_radius / length_threshold);
        if (n <= 0)
            return;

formula.compute_axis(p0, angle01);

calc_t step = angle01 / (n + 1);

calc_t a = step;
        for (signed_size_type i = 0 ; i < n ; ++i, a += step)
        {
            out_point_t p;
            formula.compute_point(a, p);

geometry::detail::conversion::point_to_point
                <
                    Point, out_point_t,
                    2, dimension<out_point_t>::value
                >::apply(p0, p);

policy.apply(p);
        }
    }

private:
    typename strategy_detail::get_radius
        <
            RadiusTypeOrSphere
        >::type m_radius;
};

#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
namespace services
{

template <>
struct default_strategy<spherical_equatorial_tag>
{
    typedef strategy::densify::spherical<> type;
};

} // namespace services
#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS

}} // namespace strategy::densify

}} // namespace boost::geometry

#endif // BOOST_GEOMETRY_ALGORITHMS_DENSIFY_HPP

// Boost.Geometry // Copyright (c) 2017-2019, 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_STRATEGIES_SPHERICAL_DENSIFY_HPP #define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DENSIFY_HPP #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace geometry { namespace strategy { namespace densify { /*! \brief Densification of spherical segment. \ingroup strategies \tparam RadiusTypeOrSphere \tparam_radius_or_sphere \tparam CalculationType \tparam_calculation \qbk{ [heading See also] [link geometry.reference.algorithms.densify.densify_4_with_strategy densify (with strategy)] } */ template < typename RadiusTypeOrSphere = double, typename CalculationType = void > class spherical { public: // For consistency with area strategy the radius is set to 1 inline spherical() : m_radius(1.0) {} template explicit inline spherical(RadiusOrSphere const& radius_or_sphere) : m_radius(strategy_detail::get_radius < RadiusOrSphere >::apply(radius_or_sphere)) {} template inline void apply(Point const& p0, Point const& p1, AssignPolicy & policy, T const& length_threshold) const { typedef typename AssignPolicy::point_type out_point_t; typedef typename select_most_precise < typename coordinate_type::type, typename coordinate_type::type, CalculationType >::type calc_t; calc_t angle01; formula::interpolate_point_spherical formula; formula.compute_angle(p0, p1, angle01); BOOST_GEOMETRY_ASSERT(length_threshold > T(0)); signed_size_type n = signed_size_type(angle01 * m_radius / length_threshold); if (n <= 0) return; formula.compute_axis(p0, angle01); calc_t step = angle01 / (n + 1); calc_t a = step; for (signed_size_type i = 0 ; i < n ; ++i, a += step) { out_point_t p; formula.compute_point(a, p); geometry::detail::conversion::point_to_point < Point, out_point_t, 2, dimension::value >::apply(p0, p); policy.apply(p); } } private: typename strategy_detail::get_radius < RadiusTypeOrSphere >::type m_radius; }; #ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS namespace services { template <> struct default_strategy { typedef strategy::densify::spherical<> type; }; } // namespace services #endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS }} // namespace strategy::densify }} // namespace boost::geometry #endif // BOOST_GEOMETRY_ALGORITHMS_DENSIFY_HPP