ceph/src/boost/boost/geometry/srs/projections/proj/mbtfpq.hpp

   1 #ifndef BOOST_GEOMETRY_PROJECTIONS_MBTFPQ_HPP
   2 #define BOOST_GEOMETRY_PROJECTIONS_MBTFPQ_HPP
   3
   4 // Boost.Geometry - extensions-gis-projections (based on PROJ4)
   5 // This file is automatically generated. DO NOT EDIT.
   6
   7 // Copyright (c) 2008-2015 Barend Gehrels, Amsterdam, the Netherlands.
   8
   9 // This file was modified by Oracle on 2017.
  10 // Modifications copyright (c) 2017, Oracle and/or its affiliates.
  11 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle.
  12
  13 // Use, modification and distribution is subject to the Boost Software License,
  14 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
  15 // http://www.boost.org/LICENSE_1_0.txt)
  16
  17 // This file is converted from PROJ4, http://trac.osgeo.org/proj
  18 // PROJ4 is originally written by Gerald Evenden (then of the USGS)
  19 // PROJ4 is maintained by Frank Warmerdam
  20 // PROJ4 is converted to Boost.Geometry by Barend Gehrels
  21
  22 // Last updated version of proj: 4.9.1
  23
  24 // Original copyright notice:
  25
  26 // Permission is hereby granted, free of charge, to any person obtaining a
  27 // copy of this software and associated documentation files (the "Software"),
  28 // to deal in the Software without restriction, including without limitation
  29 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
  30 // and/or sell copies of the Software, and to permit persons to whom the
  31 // Software is furnished to do so, subject to the following conditions:
  32
  33 // The above copyright notice and this permission notice shall be included
  34 // in all copies or substantial portions of the Software.
  35
  36 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  37 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  38 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  39 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  40 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  41 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  42 // DEALINGS IN THE SOFTWARE.
  43
  44 #include <boost/geometry/util/math.hpp>
  45
  46 #include <boost/geometry/srs/projections/impl/base_static.hpp>
  47 #include <boost/geometry/srs/projections/impl/base_dynamic.hpp>
  48 #include <boost/geometry/srs/projections/impl/projects.hpp>
  49 #include <boost/geometry/srs/projections/impl/factory_entry.hpp>
  50
  51 namespace boost { namespace geometry
  52 {
  53
  54 namespace srs { namespace par4
  55 {
  56     struct mbtfpq {};
  57
  58 }} //namespace srs::par4
  59
  60 namespace projections
  61 {
  62     #ifndef DOXYGEN_NO_DETAIL
  63     namespace detail { namespace mbtfpq
  64     {
  65
  66             static const int NITER = 20;
  67             static const double EPS = 1e-7;
  68             static const double ONETOL = 1.000001;
  69             static const double C = 1.70710678118654752440;
  70             static const double RC = 0.58578643762690495119;
  71             static const double FYC = 1.87475828462269495505;
  72             static const double RYC = 0.53340209679417701685;
  73             static const double FXC = 0.31245971410378249250;
  74             static const double RXC = 3.20041258076506210122;
  75
  76             // template class, using CRTP to implement forward/inverse
  77             template <typename CalculationType, typename Parameters>
  78             struct base_mbtfpq_spheroid : public base_t_fi<base_mbtfpq_spheroid<CalculationType, Parameters>,
  79                      CalculationType, Parameters>
  80             {
  81
  82                 typedef CalculationType geographic_type;
  83                 typedef CalculationType cartesian_type;
  84
  85
  86                 inline base_mbtfpq_spheroid(const Parameters& par)
  87                     : base_t_fi<base_mbtfpq_spheroid<CalculationType, Parameters>,
  88                      CalculationType, Parameters>(*this, par) {}
  89
  90                 // FORWARD(s_forward)  spheroid
  91                 // Project coordinates from geographic (lon, lat) to cartesian (x, y)
  92                 inline void fwd(geographic_type& lp_lon, geographic_type& lp_lat, cartesian_type& xy_x, cartesian_type& xy_y) const
  93                 {
  94                     CalculationType th1, c;
  95                     int i;
  96
  97                     c = C * sin(lp_lat);
  98                     for (i = NITER; i; --i) {
  99                         lp_lat -= th1 = (sin(.5*lp_lat) + sin(lp_lat) - c) /
 100                             (.5*cos(.5*lp_lat)  + cos(lp_lat));
 101                         if (fabs(th1) < EPS) break;
 102                     }
 103                     xy_x = FXC * lp_lon * (1.0 + 2. * cos(lp_lat)/cos(0.5 * lp_lat));
 104                     xy_y = FYC * sin(0.5 * lp_lat);
 105                 }
 106
 107                 // INVERSE(s_inverse)  spheroid
 108                 // Project coordinates from cartesian (x, y) to geographic (lon, lat)
 109                 inline void inv(cartesian_type& xy_x, cartesian_type& xy_y, geographic_type& lp_lon, geographic_type& lp_lat) const
 110                 {
 111                     static const CalculationType ONEPI = detail::ONEPI<CalculationType>();
 112                     static const CalculationType HALFPI = detail::HALFPI<CalculationType>();
 113
 114                     CalculationType t;
 115
 116                     lp_lat = RYC * xy_y;
 117                     if (fabs(lp_lat) > 1.) {
 118                         if (fabs(lp_lat) > ONETOL)
 119                             BOOST_THROW_EXCEPTION( projection_exception(-20) );
 120                         else if (lp_lat < 0.) {
 121                             t = -1.; lp_lat = -ONEPI;
 122                         } else {
 123                             t = 1.; lp_lat = ONEPI;
 124                         }
 125                     } else
 126                         lp_lat = 2. * asin(t = lp_lat);
 127                     lp_lon = RXC * xy_x / (1. + 2. * cos(lp_lat)/cos(0.5 * lp_lat));
 128                     lp_lat = RC * (t + sin(lp_lat));
 129                     if (fabs(lp_lat) > 1.)
 130                         if (fabs(lp_lat) > ONETOL)
 131                             BOOST_THROW_EXCEPTION( projection_exception(-20) );
 132                         else
 133                             lp_lat = lp_lat < 0. ? -HALFPI : HALFPI;
 134                     else
 135                         lp_lat = asin(lp_lat);
 136                 }
 137
 138                 static inline std::string get_name()
 139                 {
 140                     return "mbtfpq_spheroid";
 141                 }
 142
 143             };
 144
 145             // McBryde-Thomas Flat-Polar Quartic
 146             template <typename Parameters>
 147             inline void setup_mbtfpq(Parameters& par)
 148             {
 149                 par.es = 0.;
 150             }
 151
 152     }} // namespace detail::mbtfpq
 153     #endif // doxygen
 154
 155     /*!
 156         \brief McBryde-Thomas Flat-Polar Quartic projection
 157         \ingroup projections
 158         \tparam Geographic latlong point type
 159         \tparam Cartesian xy point type
 160         \tparam Parameters parameter type
 161         \par Projection characteristics
 162          - Cylindrical
 163          - Spheroid
 164         \par Example
 165         \image html ex_mbtfpq.gif
 166     */
 167     template <typename CalculationType, typename Parameters>
 168     struct mbtfpq_spheroid : public detail::mbtfpq::base_mbtfpq_spheroid<CalculationType, Parameters>
 169     {
 170         inline mbtfpq_spheroid(const Parameters& par) : detail::mbtfpq::base_mbtfpq_spheroid<CalculationType, Parameters>(par)
 171         {
 172             detail::mbtfpq::setup_mbtfpq(this->m_par);
 173         }
 174     };
 175
 176     #ifndef DOXYGEN_NO_DETAIL
 177     namespace detail
 178     {
 179
 180         // Static projection
 181         BOOST_GEOMETRY_PROJECTIONS_DETAIL_STATIC_PROJECTION(srs::par4::mbtfpq, mbtfpq_spheroid, mbtfpq_spheroid)
 182
 183         // Factory entry(s)
 184         template <typename CalculationType, typename Parameters>
 185         class mbtfpq_entry : public detail::factory_entry<CalculationType, Parameters>
 186         {
 187             public :
 188                 virtual base_v<CalculationType, Parameters>* create_new(const Parameters& par) const
 189                 {
 190                     return new base_v_fi<mbtfpq_spheroid<CalculationType, Parameters>, CalculationType, Parameters>(par);
 191                 }
 192         };
 193
 194         template <typename CalculationType, typename Parameters>
 195         inline void mbtfpq_init(detail::base_factory<CalculationType, Parameters>& factory)
 196         {
 197             factory.add_to_factory("mbtfpq", new mbtfpq_entry<CalculationType, Parameters>);
 198         }
 199
 200     } // namespace detail
 201     #endif // doxygen
 202
 203 } // namespace projections
 204
 205 }} // namespace boost::geometry
 206
 207 #endif // BOOST_GEOMETRY_PROJECTIONS_MBTFPQ_HPP
 208