diff options
Diffstat (limited to 'boost/geometry/srs/projections/impl/pj_param.hpp')
| -rw-r--r-- | boost/geometry/srs/projections/impl/pj_param.hpp | 573 |
1 files changed, 498 insertions, 75 deletions
diff --git a/boost/geometry/srs/projections/impl/pj_param.hpp b/boost/geometry/srs/projections/impl/pj_param.hpp index 7648055414..8ebef9566f 100644 --- a/boost/geometry/srs/projections/impl/pj_param.hpp +++ b/boost/geometry/srs/projections/impl/pj_param.hpp @@ -47,135 +47,201 @@ #include <boost/geometry/srs/projections/impl/dms_parser.hpp> #include <boost/geometry/srs/projections/impl/projects.hpp> +#include <boost/geometry/srs/projections/proj4.hpp> +#include <boost/geometry/srs/projections/dpar.hpp> +#include <boost/geometry/srs/projections/spar.hpp> #include <boost/mpl/assert.hpp> #include <boost/type_traits/is_integral.hpp> +#include <boost/type_traits/is_same.hpp> +#include <iterator> namespace boost { namespace geometry { namespace projections { -namespace detail { +namespace detail { -/* create pvalue list entry */ -template <typename T> -inline pvalue<T> pj_mkparam(std::string const& name, std::string const& value) +inline bool pj_param_pred(srs::detail::proj4_parameter const& p, std::string const& name) { - pvalue<T> newitem; - newitem.param = name; - newitem.s = value; - //newitem.used = false; - return newitem; + return p.name == name; } -/* create pvalue list entry */ -template <typename T> -inline pvalue<T> pj_mkparam(std::string const& str) +template <typename T, typename Id> +inline bool pj_param_pred(srs::dpar::parameter<T> const& p, Id const& id, + typename boost::disable_if_c<boost::is_convertible<Id, std::string>::value>::type * = 0) { - std::string name = str; - std::string value; - boost::trim_left_if(name, boost::is_any_of("+")); - std::string::size_type loc = name.find("="); - if (loc != std::string::npos) - { - value = name.substr(loc + 1); - name.erase(loc); - } - - return pj_mkparam<T>(name, value); + return p.is_id_equal(id); } /* input exists */ -template <typename T> -inline typename std::vector<pvalue<T> >::const_iterator - pj_param_find(std::vector<pvalue<T> > const& pl, std::string const& name) +template <typename Params, typename Name> +inline typename Params::const_iterator + pj_param_find(Params const& params, Name const& name) { - typedef typename std::vector<pvalue<T> >::const_iterator iterator; - for (iterator it = pl.begin(); it != pl.end(); it++) + typedef typename Params::const_iterator iterator; + for (iterator it = params.begin(); it != params.end(); it++) { - if (it->param == name) + if (pj_param_pred(*it, name)) { //it->used = true; return it; } // TODO: needed for pipeline - /*else if (it->param == "step") + /*else if (it->name == "step") { return pl.end(); }*/ } - return pl.end(); + return params.end(); } +/* +template +< + typename StaticParams, + typename IsParamPred, + int I = tuples_find_index_if<StaticParams, typename IsParamPred::pred>::value, + int N = boost::tuples::length<StaticParams>::value +> +struct pj_param_find_static +{ + typedef boost::tuples::element<I, StaticParams> type; + typedef const type* result_type; + static result_type get(StaticParams const& params) + { + return boost::addressof(boost::get<I>(params)); + } +}; + +template <typename StaticParams, typename IsParamPred, int N> +struct pj_param_find_static<StaticParams, IsParamPred, N> +{ + typedef void type; + typedef const type* result_type; + static result_type get(StaticParams const& ) { return NULL; } +};*/ + + /* input exists */ +template <typename Params, typename Name> +inline bool pj_param_exists(Params const& params, Name const& name) +{ + return pj_param_find(params, name) != params.end(); +} + +template <typename Param, BOOST_GEOMETRY_PROJECTIONS_DETAIL_TYPENAME_PX> +inline bool pj_param_exists(srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX> const& ) +{ + return srs::spar::detail::tuples_is_found + < + typename srs::spar::detail::tuples_find_if + < + srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX>, + srs::spar::detail::is_param<Param>::template pred + >::type + >::value; +} + +template <template <typename> class Param, BOOST_GEOMETRY_PROJECTIONS_DETAIL_TYPENAME_PX> +inline bool pj_param_exists(srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX> const& ) +{ + return srs::spar::detail::tuples_is_found + < + typename srs::spar::detail::tuples_find_if + < + srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX>, + srs::spar::detail::is_param_t<Param>::template pred + >::type + >::value; +} + + template <typename T> -inline bool pj_param_exists(std::vector<pvalue<T> > const& pl, std::string const& name) +inline void set_value(T & val, srs::detail::proj4_parameter const& p) { - return pj_param_find(pl, name) != pl.end(); + val = geometry::str_cast<T>(p.value); +} + +template <typename T, typename T2> +inline void set_value(T & val, srs::dpar::parameter<T2> const& p) +{ + val = p.template get_value<T>(); } -/* integer input */ template <typename T> -inline bool pj_param_i(std::vector<pvalue<T> > const& pl, std::string const& name, int & par) +inline void set_value_r(T & val, srs::detail::proj4_parameter const& p) { - typename std::vector<pvalue<T> >::const_iterator it = pj_param_find(pl, name); - if (it != pl.end()) - { - par = geometry::str_cast<int>(it->s); - return true; - } - return false; + val = dms_parser<T, true>::apply(p.value.c_str()).angle(); } -/* floating point input */ template <typename T> -inline bool pj_param_f(std::vector<pvalue<T> > const& pl, std::string const& name, T & par) +inline void set_value_r(T & val, srs::dpar::parameter<T> const& p) { - typename std::vector<pvalue<T> >::const_iterator it = pj_param_find(pl, name); - if (it != pl.end()) + val = p.template get_value<T>() * math::d2r<T>(); +} + +template <typename Name> +inline void check_name(Name const&) +{ + static const bool is_ok = boost::is_convertible<Name, std::string>::value + || boost::is_same<Name, srs::dpar::name_i>::value + || boost::is_same<Name, srs::dpar::name_f>::value + || boost::is_same<Name, srs::dpar::name_r>::value; + BOOST_MPL_ASSERT_MSG((is_ok), INVALID_ARGUMENT, (Name)); +} + + +/* integer input */ +template <typename Params, typename Name> +inline bool _pj_param_i(Params const& params, Name const& name, int & par) +{ + check_name(name); + typename Params::const_iterator it = pj_param_find(params, name); + if (it != params.end()) { - par = geometry::str_cast<T>(it->s); + set_value(par, *it); return true; } return false; } -/* radians input */ -template <typename T> -inline bool pj_param_r(std::vector<pvalue<T> > const& pl, std::string const& name, T & par) +/* floating point input */ +template <typename T, typename Params, typename Name> +inline bool _pj_param_f(Params const& params, Name const& name, T & par) { - typename std::vector<pvalue<T> >::const_iterator it = pj_param_find(pl, name); - if (it != pl.end()) + check_name(name); + typename Params::const_iterator it = pj_param_find(params, name); + if (it != params.end()) { - dms_parser<T, true> parser; - par = parser.apply(it->s.c_str()).angle(); + set_value(par, *it); return true; } return false; } -/* string input */ -template <typename T> -inline bool pj_param_s(std::vector<pvalue<T> > const& pl, std::string const& name, std::string & par) +/* radians input */ +template <typename T, typename Params, typename Name> +inline bool _pj_param_r(Params const& params, Name const& name, T & par) { - typename std::vector<pvalue<T> >::const_iterator it = pj_param_find(pl, name); - if (it != pl.end()) + check_name(name); + typename Params::const_iterator it = pj_param_find(params, name); + if (it != params.end()) { - par = it->s; + set_value_r(par, *it); return true; } return false; } /* bool input */ -template <typename T> -inline bool pj_get_param_b(std::vector<pvalue<T> > const& pl, std::string const& name) +inline bool _pj_get_param_b(srs::detail::proj4_parameters const& pl, std::string const& name) { - typename std::vector<pvalue<T> >::const_iterator it = pj_param_find(pl, name); + srs::detail::proj4_parameters::const_iterator it = pj_param_find(pl, name); if (it != pl.end()) { - switch (it->s[0]) + switch (it->value[0]) { case '\0': case 'T': case 't': return true; @@ -189,41 +255,398 @@ inline bool pj_get_param_b(std::vector<pvalue<T> > const& pl, std::string const& return false; } +template <typename T> +inline bool _pj_get_param_b(srs::dpar::parameters<T> const& pl, srs::dpar::name_be const& name) +{ + bool result = false; + typename srs::dpar::parameters<T>::const_iterator it = pj_param_find(pl, name); + if (it != pl.end()) + set_value(result, *it); + return result; +} + +/* string input */ +inline bool pj_param_s(srs::detail::proj4_parameters const& pl, std::string const& name, std::string & par) +{ + srs::detail::proj4_parameters::const_iterator it = pj_param_find(pl, name); + if (it != pl.end()) + { + par = it->value; + return true; + } + return false; +} + +template +< + typename Params, + template <typename> class IsSamePred, + int I = srs::spar::detail::tuples_find_index_if<Params, IsSamePred>::value, + int N = boost::tuples::length<Params>::value +> +struct _pj_param_x_static +{ + static const bool result = true; + template <typename T> + static void apply(Params const& params, T & out) + { + // TODO: int values could be extracted directly from the type + out = boost::tuples::get<I>(params).value; + } +}; + +template +< + typename Params, + template <typename> class IsSamePred, + int N +> +struct _pj_param_x_static<Params, IsSamePred, N, N> +{ + static const bool result = false; + template <typename T> + static void apply(Params const& , T & ) + {} +}; + +template <template <int> class Param, BOOST_GEOMETRY_PROJECTIONS_DETAIL_TYPENAME_PX> +inline bool _pj_param_i(srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX> const& params, int & par) +{ + typedef _pj_param_x_static + < + srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX>, + srs::spar::detail::is_param_i<Param>::template pred + > impl; + impl::apply(params, par); + return impl::result; +} + +template <template <typename> class Param, BOOST_GEOMETRY_PROJECTIONS_DETAIL_TYPENAME_PX, typename T> +inline bool _pj_param_f(srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX> const& params, T & par) +{ + typedef _pj_param_x_static + < + srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX>, + srs::spar::detail::is_param_t<Param>::template pred + > impl; + impl::apply(params, par); + return impl::result; +} + +template <template <typename> class Param, BOOST_GEOMETRY_PROJECTIONS_DETAIL_TYPENAME_PX, typename T> +inline bool _pj_param_r(srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX> const& params, T & par) +{ + typedef _pj_param_x_static + < + srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX>, + srs::spar::detail::is_param_t<Param>::template pred + > impl; + impl::apply(params, par); + if (impl::result) + par *= math::d2r<T>(); + return impl::result; +} + +template <typename Param, BOOST_GEOMETRY_PROJECTIONS_DETAIL_TYPENAME_PX> +inline bool _pj_get_param_b(srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX> const& params) +{ + return pj_param_exists<Param>(params); +} + +//template <typename T, typename Name, typename Value> +//inline bool pj_param_id(srs::dpar::parameters<T> const& pl, Name const& name, Value & par) +//{ +// typename srs::dpar::parameters<T>::const_iterator it = pj_param_find(pl, name); +// if (it != pl.end()) +// { +// par = static_cast<Value>(it->template get_value<int>()); +// return true; +// } +// return false; +//} + // NOTE: In the original code, in pl_ell_set.c there is a function pj_get_param // which behavior is similar to pj_param but it doesn't set `user` member to TRUE // while pj_param does in the original code. In Boost.Geometry this member is not used. -template <typename T> -inline int pj_get_param_i(std::vector<pvalue<T> > const& pl, std::string const& name) +template <typename Params, typename Name> +inline int _pj_get_param_i(Params const& pl, Name const& name) { int res = 0; - pj_param_i(pl, name, res); + _pj_param_i(pl, name, res); return res; } -template <typename T> -inline T pj_get_param_f(std::vector<pvalue<T> > const& pl, std::string const& name) +template <template <int> class Param, typename Params> +inline int _pj_get_param_i(Params const& pl) +{ + int res = 0; + _pj_param_i<Param>(pl, res); + return res; +} + +template <typename T, typename Params, typename Name> +inline T _pj_get_param_f(Params const& pl, Name const& name) { T res = 0; - pj_param_f(pl, name, res); + _pj_param_f(pl, name, res); return res; } -template <typename T> -inline T pj_get_param_r(std::vector<pvalue<T> > const& pl, std::string const& name) +template <typename T, template <typename> class Param, typename Params> +inline T _pj_get_param_f(Params const& pl) { T res = 0; - pj_param_r(pl, name, res); + _pj_param_f<Param>(pl, res); return res; } -template <typename T> -inline std::string pj_get_param_s(std::vector<pvalue<T> > const& pl, std::string const& name) +template <typename T, typename Params, typename Name> +inline T _pj_get_param_r(Params const& pl, Name const& name) +{ + T res = 0; + _pj_param_r(pl, name, res); + return res; +} + +template <typename T, template <typename> class Param, typename Params> +inline T _pj_get_param_r(Params const& pl) +{ + T res = 0; + _pj_param_r<Param>(pl, res); + return res; +} + +inline std::string pj_get_param_s(srs::detail::proj4_parameters const& pl, std::string const& name) { std::string res; pj_param_s(pl, name, res); return res; } + +// ------------------------------------------------------------------------- // + +template <typename Param, typename Name> +inline bool pj_param_exists(srs::detail::proj4_parameters const& pl, + std::string const& sn, + Name const& ) +{ + return pj_param_exists(pl, sn); +} +template <template <typename> class Param, typename Name> +inline bool pj_param_exists(srs::detail::proj4_parameters const& pl, + std::string const& sn, + Name const& ) +{ + return pj_param_exists(pl, sn); +} +template <typename Param, typename T, typename Name> +inline bool pj_param_exists(srs::dpar::parameters<T> const& pl, + std::string const& , + Name const& n) +{ + return pj_param_exists(pl, n); +} +template <template <typename> class Param, typename T, typename Name> +inline bool pj_param_exists(srs::dpar::parameters<T> const& pl, + std::string const& , + Name const& n) +{ + return pj_param_exists(pl, n); +} +template <typename Param, BOOST_GEOMETRY_PROJECTIONS_DETAIL_TYPENAME_PX, typename Name> +inline bool pj_param_exists(srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX> const& pl, + std::string const& , + Name const& ) +{ + return pj_param_exists<Param>(pl); +} +template <template <typename> class Param, BOOST_GEOMETRY_PROJECTIONS_DETAIL_TYPENAME_PX, typename Name> +inline bool pj_param_exists(srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX> const& pl, + std::string const& , + Name const& ) +{ + return pj_param_exists<Param>(pl); +} + +template <typename Param> +inline bool pj_get_param_b(srs::detail::proj4_parameters const& pl, + std::string const& sn, + srs::dpar::name_be const& ) +{ + return _pj_get_param_b(pl, sn); +} +template <typename Param, typename T> +inline bool pj_get_param_b(srs::dpar::parameters<T> const& pl, + std::string const& , + srs::dpar::name_be const& n) +{ + return _pj_get_param_b(pl, n); +} +template <typename Param, BOOST_GEOMETRY_PROJECTIONS_DETAIL_TYPENAME_PX> +inline bool pj_get_param_b(srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX> const& pl, + std::string const& , + srs::dpar::name_be const& ) +{ + return _pj_get_param_b<Param>(pl); +} + +//#define BOOST_GEOMETRY_GET_PARAM_B(PARAMS, NAME) pj_get_param_b(PARAMS, #NAME, srs::dpar::NAME) + +template <template <int> class Param> +inline bool pj_param_i(srs::detail::proj4_parameters const& pl, + std::string const& sn, + srs::dpar::name_i const& , + int & par) +{ + return _pj_param_i(pl, sn, par); +} +template <template <int> class Param, typename T> +inline bool pj_param_i(srs::dpar::parameters<T> const& pl, + std::string const& , + srs::dpar::name_i const& n, + int & par) +{ + return _pj_param_i(pl, n, par); +} +template <template <int> class Param, BOOST_GEOMETRY_PROJECTIONS_DETAIL_TYPENAME_PX> +inline bool pj_param_i(srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX> const& pl, + std::string const& , + srs::dpar::name_i const& , + int & par) +{ + return _pj_param_i<Param>(pl, par); +} + +//#define BOOST_GEOMETRY_PARAM_I(PARAMS, NAME, PAR) pj_param_i(PARAMS, #NAME, srs::dpar::NAME, PAR) + +template <template <int> class Param> +inline int pj_get_param_i(srs::detail::proj4_parameters const& pl, + std::string const& sn, + srs::dpar::name_i const& ) +{ + return _pj_get_param_i(pl, sn); +} +template <template <int> class Param, typename T> +inline int pj_get_param_i(srs::dpar::parameters<T> const& pl, + std::string const& , + srs::dpar::name_i const& n) +{ + return _pj_get_param_i(pl, n); +} +template <template <int> class Param, BOOST_GEOMETRY_PROJECTIONS_DETAIL_TYPENAME_PX> +inline bool pj_get_param_i(srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX> const& pl, + std::string const& , + srs::dpar::name_i const& ) +{ + return _pj_get_param_i<Param>(pl); +} + +//#define BOOST_GEOMETRY_GET_PARAM_I(PARAMS, NAME) pj_get_param_i(PARAMS, #NAME, srs::dpar::NAME) + +template <template <typename> class Param, typename T> +inline bool pj_param_f(srs::detail::proj4_parameters const& pl, + std::string const& sn, + srs::dpar::name_f const& , + T & par) +{ + return _pj_param_f(pl, sn, par); +} +template <template <typename> class Param, typename T> +inline bool pj_param_f(srs::dpar::parameters<T> const& pl, + std::string const& , + srs::dpar::name_f const& n, + T & par) +{ + return _pj_param_f(pl, n, par); +} +template <template <typename> class Param, BOOST_GEOMETRY_PROJECTIONS_DETAIL_TYPENAME_PX, typename T> +inline bool pj_param_f(srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX> const& pl, + std::string const& , + srs::dpar::name_f const& , + T & par) +{ + return _pj_param_f<Param>(pl, par); +} + +//#define BOOST_GEOMETRY_PARAM_F(PARAMS, NAME, PAR) pj_param_f(PARAMS, #NAME, srs::dpar::NAME, PAR) + +template <typename T, template <typename> class Param> +inline T pj_get_param_f(srs::detail::proj4_parameters const& pl, + std::string const& sn, + srs::dpar::name_f const& ) +{ + return _pj_get_param_f<T>(pl, sn); +} +template <typename T, template <typename> class Param> +inline T pj_get_param_f(srs::dpar::parameters<T> const& pl, + std::string const& , + srs::dpar::name_f const& n) +{ + return _pj_get_param_f<T>(pl, n); +} +template <typename T, template <typename> class Param, BOOST_GEOMETRY_PROJECTIONS_DETAIL_TYPENAME_PX> +inline T pj_get_param_f(srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX> const& pl, + std::string const& , + srs::dpar::name_f const& ) +{ + return _pj_get_param_f<T, Param>(pl); +} + + +//#define BOOST_GEOMETRY_GET_PARAM_F(PARAMS, NAME) pj_get_param_f<T>(PARAMS, #NAME, srs::dpar::NAME) + +template <template <typename> class Param, typename T> +inline bool pj_param_r(srs::detail::proj4_parameters const& pl, + std::string const& sn, + srs::dpar::name_r const& , + T & par) +{ + return _pj_param_r(pl, sn, par); +} +template <template <typename> class Param, typename T> +inline bool pj_param_r(srs::dpar::parameters<T> const& pl, + std::string const& , + srs::dpar::name_r const& n, + T & par) +{ + return _pj_param_r(pl, n, par); +} +template <template <typename> class Param, BOOST_GEOMETRY_PROJECTIONS_DETAIL_TYPENAME_PX, typename T> +inline bool pj_param_r(srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX> const& pl, + std::string const& , + srs::dpar::name_r const& , + T & par) +{ + return _pj_param_r<Param>(pl, par); +} + +//#define BOOST_GEOMETRY_PARAM_R(PARAMS, NAME, PAR) pj_param_r(PARAMS, #NAME, srs::dpar::NAME, PAR) + +template <typename T, template <typename> class Param> +inline T pj_get_param_r(srs::detail::proj4_parameters const& pl, + std::string const& sn, + srs::dpar::name_r const& ) +{ + return _pj_get_param_r<T>(pl, sn); +} +template <typename T, template <typename> class Param> +inline T pj_get_param_r(srs::dpar::parameters<T> const& pl, + std::string const& , + srs::dpar::name_r const& n) +{ + return _pj_get_param_r<T>(pl, n); +} +template <typename T, template <typename> class Param, BOOST_GEOMETRY_PROJECTIONS_DETAIL_TYPENAME_PX> +inline T pj_get_param_r(srs::spar::parameters<BOOST_GEOMETRY_PROJECTIONS_DETAIL_PX> const& pl, + std::string const& , + srs::dpar::name_r const& ) +{ + return _pj_get_param_r<T, Param>(pl); +} + +//#define BOOST_GEOMETRY_GET_PARAM_R(PARAMS, NAME) pj_get_param_r<T>(PARAMS, #NAME, srs::dpar::NAME) + } // namespace detail }}} // namespace boost::geometry::projections |