← Back to branch summary

~ubuntu-branches/ubuntu/saucy/merkaartor/saucy

« back to all changes in this revision

Viewing changes to include/ggl/projections/proj/lcca.hpp

  • Committer: Bazaar Package Importer
  • Author(s): Bernd Zeimetz
  • Date: 2009-09-13 00:52:12 UTC
  • mto: (1.2.7 upstream) (0.1.3 upstream) (3.1.7 sid)
  • mto: This revision was merged to the branch mainline in revision 10.
  • Revision ID: james.westby@ubuntu.com-20090913005212-pjecal8zxm07x0fj
Import upstream version 0.14+svnfixes~20090912

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/ggl/projections/proj/lcca.hpp
 
1
#ifndef GGL_PROJECTIONS_LCCA_HPP
 
2
#define GGL_PROJECTIONS_LCCA_HPP
 
3
 
 
4
// Generic Geometry Library - projections (based on PROJ4)
 
5
// This file is automatically generated. DO NOT EDIT.
 
6
 
 
7
// Copyright Barend Gehrels (1995-2009), Geodan Holding B.V. Amsterdam, the Netherlands.
 
8
// Copyright Bruno Lalande (2008-2009)
 
9
// Use, modification and distribution is subject to the Boost Software License,
 
10
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 
11
// http://www.boost.org/LICENSE_1_0.txt)
 
12
 
 
13
// This file is converted from PROJ4, http://trac.osgeo.org/proj
 
14
// PROJ4 is originally written by Gerald Evenden (then of the USGS)
 
15
// PROJ4 is maintained by Frank Warmerdam
 
16
// PROJ4 is converted to Geometry Library by Barend Gehrels (Geodan, Amsterdam)
 
17
 
 
18
// Original copyright notice:
 
19
 
 
20
// Permission is hereby granted, free of charge, to any person obtaining a
 
21
// copy of this software and associated documentation files (the "Software"),
 
22
// to deal in the Software without restriction, including without limitation
 
23
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
 
24
// and/or sell copies of the Software, and to permit persons to whom the
 
25
// Software is furnished to do so, subject to the following conditions:
 
26
 
 
27
// The above copyright notice and this permission notice shall be included
 
28
// in all copies or substantial portions of the Software.
 
29
 
 
30
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 
31
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
32
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 
33
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
34
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 
35
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 
36
// DEALINGS IN THE SOFTWARE.
 
37
 
 
38
#include <boost/math/special_functions/hypot.hpp>
 
39
 
 
40
#include <ggl/projections/impl/base_static.hpp>
 
41
#include <ggl/projections/impl/base_dynamic.hpp>
 
42
#include <ggl/projections/impl/projects.hpp>
 
43
#include <ggl/projections/impl/factory_entry.hpp>
 
44
#include <ggl/projections/impl/pj_mlfn.hpp>
 
45
 
 
46
namespace ggl { namespace projection
 
47
{
 
48
    #ifndef DOXYGEN_NO_DETAIL
 
49
    namespace detail { namespace lcca{ 
 
50
            static const int MAX_ITER = 10;
 
51
            static const double DEL_TOL = 1e-12;
 
52
 
 
53
            struct par_lcca
 
54
            {
 
55
                double en[EN_SIZE];
 
56
                double r0, l, M0;
 
57
                double C;
 
58
            };
 
59
            
 
60
            
 
61
                inline double /* func to compute dr */
 
62
            fS(double S, double C) {
 
63
                        return(S * ( 1. + S * S * C));
 
64
            }
 
65
                inline double /* deriv of fs */
 
66
            fSp(double S, double C) {
 
67
                return(1. + 3.* S * S * C);
 
68
            }
 
69
 
 
70
            // template class, using CRTP to implement forward/inverse
 
71
            template <typename Geographic, typename Cartesian, typename Parameters>
 
72
            struct base_lcca_ellipsoid : public base_t_fi<base_lcca_ellipsoid<Geographic, Cartesian, Parameters>,
 
73
                     Geographic, Cartesian, Parameters>
 
74
            {
 
75
 
 
76
                 typedef double geographic_type;
 
77
                 typedef double cartesian_type;
 
78
 
 
79
                par_lcca m_proj_parm;
 
80
 
 
81
                inline base_lcca_ellipsoid(const Parameters& par)
 
82
                    : base_t_fi<base_lcca_ellipsoid<Geographic, Cartesian, Parameters>,
 
83
                     Geographic, Cartesian, Parameters>(*this, par) {}
 
84
 
 
85
                inline void fwd(geographic_type& lp_lon, geographic_type& lp_lat, cartesian_type& xy_x, cartesian_type& xy_y) const
 
86
                {
 
87
                        double S, r, dr;
 
88
                        
 
89
                        S = pj_mlfn(lp_lat, sin(lp_lat), cos(lp_lat), this->m_proj_parm.en) - this->m_proj_parm.M0;
 
90
                        dr = fS(S, this->m_proj_parm.C);
 
91
                        r = this->m_proj_parm.r0 - dr;
 
92
                        xy_x = this->m_par.k0 * (r * sin( lp_lon *= this->m_proj_parm.l ) );
 
93
                        xy_y = this->m_par.k0 * (this->m_proj_parm.r0 - r * cos(lp_lon) );
 
94
                }
 
95
 
 
96
                inline void inv(cartesian_type& xy_x, cartesian_type& xy_y, geographic_type& lp_lon, geographic_type& lp_lat) const
 
97
                {
 
98
                        double theta, dr, S, dif;
 
99
                        int i;
 
100
                
 
101
                        xy_x /= this->m_par.k0;
 
102
                        xy_y /= this->m_par.k0;
 
103
                        theta = atan2(xy_x , this->m_proj_parm.r0 - xy_y);
 
104
                        dr = xy_y - xy_x * tan(0.5 * theta);
 
105
                        lp_lon = theta / this->m_proj_parm.l;
 
106
                        S = dr;
 
107
                        for (i = MAX_ITER; i ; --i) {
 
108
                                S -= (dif = (fS(S, this->m_proj_parm.C) - dr) / fSp(S, this->m_proj_parm.C));
 
109
                                if (fabs(dif) < DEL_TOL) break;
 
110
                        }
 
111
                        if (!i) throw proj_exception();
 
112
                        lp_lat = pj_inv_mlfn(S + this->m_proj_parm.M0, this->m_par.es, this->m_proj_parm.en);
 
113
                }
 
114
            };
 
115
 
 
116
            // Lambert Conformal Conic Alternative
 
117
            template <typename Parameters>
 
118
            void setup_lcca(Parameters& par, par_lcca& proj_parm)
 
119
            {
 
120
                double s2p0, N0, R0, tan0, tan20;
 
121
                    pj_enfn(par.es, proj_parm.en);
 
122
                if (!pj_param(par.params, "tlat_0").i) throw proj_exception(50);
 
123
                if (par.phi0 == 0.) throw proj_exception(51);
 
124
                proj_parm.l = sin(par.phi0);
 
125
                proj_parm.M0 = pj_mlfn(par.phi0, proj_parm.l, cos(par.phi0), proj_parm.en);
 
126
                s2p0 = proj_parm.l * proj_parm.l;
 
127
                R0 = 1. / (1. - par.es * s2p0);
 
128
                N0 = sqrt(R0);
 
129
                R0 *= par.one_es * N0;
 
130
                tan0 = tan(par.phi0);
 
131
                tan20 = tan0 * tan0;
 
132
                proj_parm.r0 = N0 / tan0;
 
133
                proj_parm.C = 1. / (6. * R0 * N0);
 
134
                // par.inv = e_inverse;
 
135
                // par.fwd = e_forward;
 
136
            }
 
137
 
 
138
        }} // namespace detail::lcca
 
139
    #endif // doxygen 
 
140
 
 
141
    /*!
 
142
        \brief Lambert Conformal Conic Alternative projection
 
143
        \ingroup projections
 
144
        \tparam Geographic latlong point type
 
145
        \tparam Cartesian xy point type
 
146
        \tparam Parameters parameter type
 
147
        \par Projection characteristics
 
148
         - Conic
 
149
         - Spheroid
 
150
         - Ellipsoid
 
151
         - lat_0=
 
152
        \par Example
 
153
        \image html ex_lcca.gif
 
154
    */
 
155
    template <typename Geographic, typename Cartesian, typename Parameters = parameters>
 
156
    struct lcca_ellipsoid : public detail::lcca::base_lcca_ellipsoid<Geographic, Cartesian, Parameters>
 
157
    {
 
158
        inline lcca_ellipsoid(const Parameters& par) : detail::lcca::base_lcca_ellipsoid<Geographic, Cartesian, Parameters>(par)
 
159
        {
 
160
            detail::lcca::setup_lcca(this->m_par, this->m_proj_parm);
 
161
        }
 
162
    };
 
163
 
 
164
    #ifndef DOXYGEN_NO_DETAIL
 
165
    namespace detail
 
166
    {
 
167
 
 
168
        // Factory entry(s)
 
169
        template <typename Geographic, typename Cartesian, typename Parameters>
 
170
        class lcca_entry : public detail::factory_entry<Geographic, Cartesian, Parameters>
 
171
        {
 
172
            public :
 
173
                virtual projection<Geographic, Cartesian>* create_new(const Parameters& par) const
 
174
                {
 
175
                    return new base_v_fi<lcca_ellipsoid<Geographic, Cartesian, Parameters>, Geographic, Cartesian, Parameters>(par);
 
176
                }
 
177
        };
 
178
 
 
179
        template <typename Geographic, typename Cartesian, typename Parameters>
 
180
        inline void lcca_init(detail::base_factory<Geographic, Cartesian, Parameters>& factory)
 
181
        {
 
182
            factory.add_to_factory("lcca", new lcca_entry<Geographic, Cartesian, Parameters>);
 
183
        }
 
184
 
 
185
    } // namespace detail 
 
186
    #endif // doxygen
 
187
 
 
188
}} // namespace ggl::projection
 
189
 
 
190
#endif // GGL_PROJECTIONS_LCCA_HPP
 
191