FM / strategies

/usr/include/boost/geometry/strategies

Name	Size	Mode	Actions
agnostic/	-	0755	rm
cartesian/	-	0755	rm
concepts/	-	0755	rm
geographic/	-	0755	rm
spherical/	-	0755	rm
transform/	-	0755	rm
area.hpp	2031	0644	edit dl rm
area_result.hpp	3205	0644	edit dl rm
azimuth.hpp	1203	0644	edit dl rm
buffer.hpp	2425	0644	edit dl rm
centroid.hpp	1660	0644	edit dl rm
comparable_distance_result.hpp	5339	0644	edit dl rm
compare.hpp	5188	0644	edit dl rm
convex_hull.hpp	1564	0644	edit dl rm
covered_by.hpp	3486	0644	edit dl rm
default_area_result.hpp	1287	0644	edit dl rm
default_comparable_distance_result.hpp	1552	0644	edit dl rm
default_distance_result.hpp	1475	0644	edit dl rm
default_length_result.hpp	2493	0644	edit dl rm
default_strategy.hpp	1270	0644	edit dl rm
densify.hpp	798	0644	edit dl rm
disjoint.hpp	2644	0644	edit dl rm
distance.hpp	2921	0644	edit dl rm
distance_result.hpp	6443	0644	edit dl rm
envelope.hpp	1257	0644	edit dl rm
expand.hpp	1128	0644	edit dl rm
index.hpp	1574	0644	edit dl rm
intersection.hpp	1222	0644	edit dl rm
intersection_result.hpp	1995	0644	edit dl rm
intersection_strategies.hpp	3106	0644	edit dl rm
io.hpp	806	0644	edit dl rm
line_interpolate.hpp	850	0644	edit dl rm
normalize.hpp	8399	0644	edit dl rm
point_order.hpp	862	0644	edit dl rm
relate.hpp	4656	0644	edit dl rm
side.hpp	1585	0644	edit dl rm
side_info.hpp	4511	0644	edit dl rm
strategies.hpp	8628	0644	edit dl rm
strategy_transform.hpp	16469	0644	edit dl rm
tags.hpp	1655	0644	edit dl rm
transform.hpp	1859	0644	edit dl rm
within.hpp	3457	0644	edit dl rm

Edit: /usr/include/boost/geometry/strategies/normalize.hpp (8399B)

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

// 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_STRATEGIES_NORMALIZE_HPP
#define BOOST_GEOMETRY_STRATEGIES_NORMALIZE_HPP

#include <cstddef>

#include <boost/numeric/conversion/cast.hpp>

#include <boost/geometry/core/access.hpp>
#include <boost/geometry/core/coordinate_system.hpp>
#include <boost/geometry/core/coordinate_type.hpp>
#include <boost/geometry/core/cs.hpp>
#include <boost/geometry/core/tag.hpp>
#include <boost/geometry/core/tags.hpp>

#include <boost/geometry/util/normalize_spheroidal_coordinates.hpp>
#include <boost/geometry/util/normalize_spheroidal_box_coordinates.hpp>

#include <boost/geometry/views/detail/indexed_point_view.hpp>

namespace boost { namespace geometry
{

namespace strategy { namespace normalize
{

#ifndef DOXYGEN_NO_DETAIL
namespace detail
{

struct do_nothing
{
    template <typename GeometryIn, typename GeometryOut>
    static inline void apply(GeometryIn const&, GeometryOut&)
    {
    }
};

template <std::size_t Dimension, std::size_t DimensionCount>
struct assign_loop
{
    template <typename CoordinateType, typename PointIn, typename PointOut>
    static inline void apply(CoordinateType const& longitude,
                             CoordinateType const& latitude,
                             PointIn const& point_in,
                             PointOut& point_out)
    {
        geometry::set<Dimension>(point_out, boost::numeric_cast
            <
                typename coordinate_type<PointOut>::type
            >(geometry::get<Dimension>(point_in)));

assign_loop
            <
                Dimension + 1, DimensionCount
            >::apply(longitude, latitude, point_in, point_out);
    }
};

template <std::size_t DimensionCount>
struct assign_loop<DimensionCount, DimensionCount>
{
    template <typename CoordinateType, typename PointIn, typename PointOut>
    static inline void apply(CoordinateType const&,
                             CoordinateType const&,
                             PointIn const&,
                             PointOut&)
    {
    }
};

template <std::size_t DimensionCount>
struct assign_loop<0, DimensionCount>
{
    template <typename CoordinateType, typename PointIn, typename PointOut>
    static inline void apply(CoordinateType const& longitude,
                             CoordinateType const& latitude,
                             PointIn const& point_in,
                             PointOut& point_out)
    {
        geometry::set<0>(point_out, boost::numeric_cast
            <
                typename coordinate_type<PointOut>::type
            >(longitude));

assign_loop
            <
                1, DimensionCount
            >::apply(longitude, latitude, point_in, point_out);
    }
};

template <std::size_t DimensionCount>
struct assign_loop<1, DimensionCount>
{
    template <typename CoordinateType, typename PointIn, typename PointOut>
    static inline void apply(CoordinateType const& longitude,
                             CoordinateType const& latitude,
                             PointIn const& point_in,
                             PointOut& point_out)
    {
        geometry::set<1>(point_out, boost::numeric_cast
            <
                typename coordinate_type<PointOut>::type
            >(latitude));

assign_loop
            <
                2, DimensionCount
            >::apply(longitude, latitude, point_in, point_out);
    }
};

template <typename PointIn, typename PointOut, bool IsEquatorial = true>
struct normalize_point
{
    static inline void apply(PointIn const& point_in, PointOut& point_out)
    {
        typedef typename coordinate_type<PointIn>::type in_coordinate_type;

in_coordinate_type longitude = geometry::get<0>(point_in);
        in_coordinate_type latitude = geometry::get<1>(point_in);

math::normalize_spheroidal_coordinates
            <
                typename geometry::detail::cs_angular_units<PointIn>::type,
                IsEquatorial,
                in_coordinate_type
            >(longitude, latitude);

assign_loop
            <
                0, dimension<PointIn>::value
            >::apply(longitude, latitude, point_in, point_out);
    }
};

template <typename BoxIn, typename BoxOut, bool IsEquatorial = true>
class normalize_box
{
    template <typename UnitsIn, typename UnitsOut, typename CoordinateInType>
    static inline void apply_to_coordinates(CoordinateInType& lon_min,
                                            CoordinateInType& lat_min,
                                            CoordinateInType& lon_max,
                                            CoordinateInType& lat_max,
                                            BoxIn const& box_in,
                                            BoxOut& box_out)
    {
        geometry::detail::indexed_point_view<BoxOut, min_corner> p_min_out(box_out);
        assign_loop
            <
                0, dimension<BoxIn>::value
            >::apply(lon_min,
                     lat_min,
                     geometry::detail::indexed_point_view
                         <
                             BoxIn const, min_corner
                         >(box_in),
                     p_min_out);

geometry::detail::indexed_point_view<BoxOut, max_corner> p_max_out(box_out);
        assign_loop
            <
                0, dimension<BoxIn>::value
            >::apply(lon_max,
                     lat_max,
                     geometry::detail::indexed_point_view
                         <
                             BoxIn const, max_corner
                         >(box_in),
                     p_max_out);
    }

public:
    static inline void apply(BoxIn const& box_in, BoxOut& box_out)
    {
        typedef typename coordinate_type<BoxIn>::type in_coordinate_type;

in_coordinate_type lon_min = geometry::get<min_corner, 0>(box_in);
        in_coordinate_type lat_min = geometry::get<min_corner, 1>(box_in);
        in_coordinate_type lon_max = geometry::get<max_corner, 0>(box_in);
        in_coordinate_type lat_max = geometry::get<max_corner, 1>(box_in);

math::normalize_spheroidal_box_coordinates
            <
                typename geometry::detail::cs_angular_units<BoxIn>::type,
                IsEquatorial,
                in_coordinate_type
            >(lon_min, lat_min, lon_max, lat_max);

apply_to_coordinates
            <
                typename geometry::detail::cs_angular_units<BoxIn>::type,
                typename geometry::detail::cs_angular_units<BoxOut>::type
            >(lon_min, lat_min, lon_max, lat_max, box_in, box_out);
    }
};

} // namespace detail
#endif // DOXYGEN_NO_DETAIL

struct cartesian_point
    : detail::do_nothing
{};

struct cartesian_box
    : detail::do_nothing
{};

struct spherical_point
{
    template <typename PointIn, typename PointOut>
    static inline void apply(PointIn const& point_in, PointOut& point_out)
    {
        detail::normalize_point
            <
                PointIn, PointOut,
                boost::mpl::not_
                    <
                        boost::is_same
                            <
                                typename cs_tag<PointIn>::type,
                                spherical_polar_tag
                            >
                    >::value
            >::apply(point_in, point_out);
    }
};

struct spherical_box
{
    template <typename BoxIn, typename BoxOut>
    static inline void apply(BoxIn const& box_in, BoxOut& box_out)
    {
        detail::normalize_box
            <
                BoxIn, BoxOut,
                boost::mpl::not_
                    <
                        boost::is_same
                            <
                                typename cs_tag<BoxIn>::type,
                                spherical_polar_tag
                            >
                    >::value
            >::apply(box_in, box_out);
    }
};

}} // namespace strategy::normalize

}} // namespace boost::geometry

#endif // BOOST_GEOMETRY_STRATEGIES_NORMALIZE_HPP

// Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2015-2018, 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_STRATEGIES_NORMALIZE_HPP #define BOOST_GEOMETRY_STRATEGIES_NORMALIZE_HPP #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace geometry { namespace strategy { namespace normalize { #ifndef DOXYGEN_NO_DETAIL namespace detail { struct do_nothing { template static inline void apply(GeometryIn const&, GeometryOut&) { } }; template struct assign_loop { template static inline void apply(CoordinateType const& longitude, CoordinateType const& latitude, PointIn const& point_in, PointOut& point_out) { geometry::set(point_out, boost::numeric_cast < typename coordinate_type::type >(geometry::get(point_in))); assign_loop < Dimension + 1, DimensionCount >::apply(longitude, latitude, point_in, point_out); } }; template struct assign_loop { template static inline void apply(CoordinateType const&, CoordinateType const&, PointIn const&, PointOut&) { } }; template struct assign_loop<0, DimensionCount> { template static inline void apply(CoordinateType const& longitude, CoordinateType const& latitude, PointIn const& point_in, PointOut& point_out) { geometry::set<0>(point_out, boost::numeric_cast < typename coordinate_type::type >(longitude)); assign_loop < 1, DimensionCount >::apply(longitude, latitude, point_in, point_out); } }; template struct assign_loop<1, DimensionCount> { template static inline void apply(CoordinateType const& longitude, CoordinateType const& latitude, PointIn const& point_in, PointOut& point_out) { geometry::set<1>(point_out, boost::numeric_cast < typename coordinate_type::type >(latitude)); assign_loop < 2, DimensionCount >::apply(longitude, latitude, point_in, point_out); } }; template struct normalize_point { static inline void apply(PointIn const& point_in, PointOut& point_out) { typedef typename coordinate_type::type in_coordinate_type; in_coordinate_type longitude = geometry::get<0>(point_in); in_coordinate_type latitude = geometry::get<1>(point_in); math::normalize_spheroidal_coordinates < typename geometry::detail::cs_angular_units::type, IsEquatorial, in_coordinate_type >(longitude, latitude); assign_loop < 0, dimension::value >::apply(longitude, latitude, point_in, point_out); } }; template class normalize_box { template static inline void apply_to_coordinates(CoordinateInType& lon_min, CoordinateInType& lat_min, CoordinateInType& lon_max, CoordinateInType& lat_max, BoxIn const& box_in, BoxOut& box_out) { geometry::detail::indexed_point_view p_min_out(box_out); assign_loop < 0, dimension::value >::apply(lon_min, lat_min, geometry::detail::indexed_point_view < BoxIn const, min_corner >(box_in), p_min_out); geometry::detail::indexed_point_view p_max_out(box_out); assign_loop < 0, dimension::value >::apply(lon_max, lat_max, geometry::detail::indexed_point_view < BoxIn const, max_corner >(box_in), p_max_out); } public: static inline void apply(BoxIn const& box_in, BoxOut& box_out) { typedef typename coordinate_type::type in_coordinate_type; in_coordinate_type lon_min = geometry::get(box_in); in_coordinate_type lat_min = geometry::get(box_in); in_coordinate_type lon_max = geometry::get(box_in); in_coordinate_type lat_max = geometry::get(box_in); math::normalize_spheroidal_box_coordinates < typename geometry::detail::cs_angular_units::type, IsEquatorial, in_coordinate_type >(lon_min, lat_min, lon_max, lat_max); apply_to_coordinates < typename geometry::detail::cs_angular_units::type, typename geometry::detail::cs_angular_units::type >(lon_min, lat_min, lon_max, lat_max, box_in, box_out); } }; } // namespace detail #endif // DOXYGEN_NO_DETAIL struct cartesian_point : detail::do_nothing {}; struct cartesian_box : detail::do_nothing {}; struct spherical_point { template static inline void apply(PointIn const& point_in, PointOut& point_out) { detail::normalize_point < PointIn, PointOut, boost::mpl::not_ < boost::is_same < typename cs_tag::type, spherical_polar_tag > >::value >::apply(point_in, point_out); } }; struct spherical_box { template static inline void apply(BoxIn const& box_in, BoxOut& box_out) { detail::normalize_box < BoxIn, BoxOut, boost::mpl::not_ < boost::is_same < typename cs_tag::type, spherical_polar_tag > >::value >::apply(box_in, box_out); } }; }} // namespace strategy::normalize }} // namespace boost::geometry #endif // BOOST_GEOMETRY_STRATEGIES_NORMALIZE_HPP