source: flair-src/trunk/lib/FlairSensorActuator/src/unexported/geodesie.h @ 15

Last change on this file since 15 was 15, checked in by Bayard Gildas, 5 years ago

sources reformatted with flair-format-dir script

File size: 5.7 KB
RevLine 
[3]1// %flair:license{
[15]2// This file is part of the Flair framework distributed under the
3// CECILL-C License, Version 1.0.
[3]4// %flair:license}
5#ifndef GEODESIE_H
6#define GEODESIE_H
7
8#include <cmath>
9#include <iostream>
10#include <vector>
11
12namespace Geodesie {
13
14#ifndef M_PI
[15]15#define M_PI 3.14159265358979323846
[3]16#endif
17#ifndef M_PI_2
[15]18#define M_PI_2 1.57079632679489661923
[3]19#endif
20#ifndef M_PI_4
[15]21#define M_PI_4 0.78539816339744830962
[3]22#endif
23
24////////////////////////////////////////////////////////////////////////
25struct Matrice {
[15]26  Matrice(const Matrice &A);
27  Matrice();
28  void Apply(double v0, double v1, double v2, double &Mv0, double &Mv1,
29             double &Mv2);
30  double c0_l0;
31  double c1_l0;
32  double c2_l0;
33  double c0_l1;
34  double c1_l1;
35  double c2_l1;
36  double c0_l2;
37  double c1_l2;
38  double c2_l2;
[3]39}; // class
40
41Matrice TransMat(const Matrice A);
42
[15]43Matrice ProdMat(const Matrice A, const Matrice B);
44void Write(const Matrice A, std::ostream &out);
[3]45
46////////////////////////////////////////////////////////////////////////
47class Raf98 {
[15]48private:
49  std::vector<double> m_dvalues;
50  double LitGrille(unsigned int c, unsigned int l) const;
51
52public:
53  ~Raf98();
54  Raf98() {}
55  bool Load(const std::string &s);
56  bool Interpol(double longitude /*deg*/, double latitude /*deg*/,
57                double *Hwgs84) const;
[3]58}; // class
59////////////////////////////////////////////////////////////////////////
60
61////////////////////////////////////////////////////////////////////////
[15]62inline double Deg2Rad(double deg) { return deg * M_PI / 180.0; }
63inline double Rad2Deg(double rad) { return rad * 180.0 / M_PI; }
[3]64////////////////////////////////////////////////////////////////////////
65
[15]66const double a_Lambert93 = 6378137;
67const double f_Lambert93 = 1 / 298.257222101;
68const double e_Lambert93 = sqrt(f_Lambert93 * (2 - f_Lambert93));
69const double lambda0_Lambert93 = Deg2Rad(3.0); // degres
70const double phi0_Lambert93 = Deg2Rad(46.5);
71const double phi1_Lambert93 = Deg2Rad(44.0);
72const double phi2_Lambert93 = Deg2Rad(49.0); // degres
73const double X0_Lambert93 = 700000;  //
74const double Y0_Lambert93 = 6600000; //
[3]75const double n_Lambert93 = 0.7256077650;
76const double c_Lambert93 = 11754255.426;
77const double xs_Lambert93 = 700000;
78const double ys_Lambert93 = 12655612.050;
79
80const double GRS_a = 6378137;
[15]81const double GRS_f = 1 / 298.257222101;
82const double GRS_b = GRS_a * (1 - GRS_f);
83const double GRS_e = sqrt((pow(GRS_a, 2) - pow(GRS_b, 2)) / pow(GRS_a, 2));
[3]84
85////////////////////////////////////////////////////////////////////////
[15]86void Geographique_2_Lambert93(const Raf98 &raf98, double lambda, double phi,
87                              double he, Matrice in, double &E, double &N,
88                              double &h, Matrice &out);
89void Geographique_2_Lambert93(const Raf98 &raf98, double lambda, double phi,
90                              double he, double &E, double &N, double &h);
91void Lambert93_2_Geographique(const Raf98 &raf98, double E, double N, double h,
92                              double &lambda, double &phi, double &he);
93void Lambert93_2_Geographique(const Raf98 &raf98, double E, double N, double h,
94                              Matrice in, double &lambda, double &phi,
95                              double &he, Matrice &out);
[3]96/** Convert from geographique to ECEF.
97 * @param[in] longitude Longitude in radian.
98 * @param[in] latitude Latitude in radian.
99 * @param[in] he Height in meter.
100 */
[15]101void Geographique_2_ECEF(double longitude, double latitude, double he,
102                         double &x, double &y, double &z);
[3]103/** Convert from ECEF two ENU.
104 * @param[in] lon0 Longitude of the origin in radian.
105 * @param[in] lat0 Latitude of the origin in radian.
106 * @param[in] he0 Height of the origin in radian.
107 */
[15]108void ECEF_2_ENU(double x, double y, double z, double &e, double &n, double &u,
109                double lon0, double lat0, double he0);
[3]110////////////////////////////////////////////////////////////////////////
111
[15]112// ALGO0001
113double LatitueIsometrique(double latitude, double e);
114// ALGO0002
115double LatitueIsometrique2Lat(double latitude_iso, double e, double epsilon);
[3]116
[15]117// ALGO0003
118void Geo2ProjLambert(double lambda, double phi, double n, double c, double e,
119                     double lambdac, double xs, double ys, double &X,
120                     double &Y);
121// ALGO0004
122void Proj2GeoLambert(double X, double Y, double n, double c, double e,
123                     double lambdac, double xs, double ys, double epsilon,
124                     double &lambda, double &phi);
[3]125
126double ConvMerApp(double longitude);
127
128/**
129Converts Cartesian (x, y) coordinates to polar coordinates (r, theta)
130*/
131template <typename _T1, typename _T2>
[15]132void cartesianToPolar(const _T1 x, const _T1 y, _T2 &r, _T2 &theta) {
133  r = std::sqrt(x * x + y * y);
134  theta = std::atan2(x, y);
[3]135}
136
137/**
138Converts polar coordinates (r, theta) to Cartesian (x, y) coordinates
139*/
140template <typename _T1, typename _T2>
[15]141void polarToCartesian(const _T1 r, const _T1 theta, _T2 &x, _T2 &y) {
142  x = r * std::cos(theta);
143  y = r * std::sin(theta);
[3]144}
145
146/**
[15]147Converts Cartesian (x, y, z) coordinates to spherical coordinates (r, theta,
148phi)
[3]149Angles expressed in radians.
150*/
151template <typename _T1, typename _T2>
[15]152void cartesianToSpherical(const _T1 x, const _T1 y, const _T1 z, _T2 &r,
153                          _T2 &theta, _T2 &phi) {
154  r = std::sqrt(x * x + y * y + z * z);
155  theta = std::acos(z / r);
156  phi = std::atan2(y, x);
[3]157}
158
159/**
[15]160Converts spherical coordinates (r, theta, phi) to Cartesian (x, y, z)
161coordinates.
[3]162Angles expressed in radians.
163*/
164template <typename _T1, typename _T2>
[15]165void sphericalToCartesian(const _T1 r, const _T1 theta, const _T1 phi, _T2 &x,
166                          _T2 &y, _T2 &z) {
167  x = r * std::sin(theta) * std::cos(phi);
168  y = r * std::sin(theta) * std::sin(phi);
169  z = r * std::cos(theta);
[3]170}
171
172} // namespace Geodesie
173
174#endif // GEODESIE_H
Note: See TracBrowser for help on using the repository browser.