GeographicLib: GeodesicLineExact.cpp Source File (original) (raw)

33 using namespace std;

35 void GeodesicLineExact::LineInit(const GeodesicExact& g,

38 unsigned caps) {

39 tiny_ = g.tiny_;

41 _lon1 = lon1;

42 _azi1 = azi1;

43 _salp1 = salp1;

44 _calp1 = calp1;

45 _a = g._a;

46 _f = g._f;

47 _b = g._b;

48 _c2 = g._c2;

49 _f1 = g._f1;

50 _e2 = g._e2;

51 _nC4 = g._nC4;

55 real cbet1, sbet1;

58 Math::norm(sbet1, cbet1); cbet1 = fmax(tiny_, cbet1);

59 _dn1 = (_f >= 0 ? sqrt(1 + g._ep2 * Math::sq(sbet1)) :

60 sqrt(1 - _e2 * Math::sq(cbet1)) / _f1);

63 _salp0 = _salp1 * cbet1;

66 _calp0 = hypot(_calp1, _salp1 * sbet1);

76 _ssig1 = sbet1; _somg1 = _salp0 * sbet1;

77 _csig1 = _comg1 = sbet1 != 0 || _calp1 != 0 ? cbet1 * _calp1 : 1;

79 _cchi1 = _f1 * _dn1 * _comg1;

80 Math::norm(_ssig1, _csig1);

84 _k2 = Math::sq(_calp0) * g._ep2;

85 _eE.Reset(-_k2, -g._ep2, 1 + _k2, 1 + g._ep2);

87 if (_caps & CAP_E) {

88 _eE0 = _eE.E() / (Math::pi() / 2);

89 _eE1 = _eE.deltaE(_ssig1, _csig1, _dn1);

90 real s = sin(_eE1), c = cos(_eE1);

92 _stau1 = _ssig1 * c + _csig1 * s;

93 _ctau1 = _csig1 * c - _ssig1 * s;

96 }

98 if (_caps & CAP_D) {

99 _dD0 = _eE.D() / (Math::pi() / 2);

100 _dD1 = _eE.deltaD(_ssig1, _csig1, _dn1);

101 }

102

103 if (_caps & CAP_H) {

104 _hH0 = _eE.H() / (Math::pi() / 2);

105 _hH1 = _eE.deltaH(_ssig1, _csig1, _dn1);

106 }

107

108 if (_caps & CAP_C4) {

109

110 _aA4 = Math::sq(_a) * _calp0 * _salp0 * _e2;

111 if (_aA4 == 0)

112 _bB41 = 0;

113 else {

114 GeodesicExact::I4Integrand i4(g._ep2, _k2);

115 _cC4a.resize(_nC4);

116 g._fft.transform(i4, _cC4a.data());

117 _bB41 = DST::integral(_ssig1, _csig1, _cC4a.data(), _nC4);

118 }

119 }

120

122 }

123

125 real lat1, real lon1, real azi1,

126 unsigned caps) {

128 real salp1, calp1;

129

131 LineInit(g, lat1, lon1, azi1, salp1, calp1, caps);

132 }

133

137 unsigned caps,

138 bool arcmode, real s13_a13) {

139 LineInit(g, lat1, lon1, azi1, salp1, calp1, caps);

141 }

142

144 unsigned outmask,

145 real& lat2, real& lon2, real& azi2,

146 real& s12, real& m12,

147 real& M12, real& M21,

148 real& S12) const {

149 outmask &= _caps & OUT_MASK;

150 if (!( Init() && (arcmode || (_caps & (OUT_MASK & DISTANCE_IN))) ))

151

153

154

155 real sig12, ssig12, csig12, E2 = 0, AB1 = 0;

156 if (arcmode) {

157

160 } else {

161

162 real

163 tau12 = s12_a12 / (_b * _eE0),

164 s = sin(tau12),

165 c = cos(tau12);

166

167 E2 = - _eE.deltaEinv(_stau1 * c + _ctau1 * s, _ctau1 * c - _stau1 * s);

168 sig12 = tau12 - (E2 - _eE1);

169 ssig12 = sin(sig12);

170 csig12 = cos(sig12);

171 }

172

173 real ssig2, csig2, sbet2, cbet2, salp2, calp2;

174

175 ssig2 = _ssig1 * csig12 + _csig1 * ssig12;

176 csig2 = _csig1 * csig12 - _ssig1 * ssig12;

177 real dn2 = _eE.Delta(ssig2, csig2);

179 if (arcmode) {

180 E2 = _eE.deltaE(ssig2, csig2, dn2);

181 }

182 AB1 = _eE0 * (E2 - _eE1);

183 }

184

185 sbet2 = _calp0 * ssig2;

186

187 cbet2 = hypot(_salp0, _calp0 * csig2);

188 if (cbet2 == 0)

189

190 cbet2 = csig2 = tiny_;

191

192 salp2 = _salp0; calp2 = _calp0 * csig2;

193

195 s12 = arcmode ? _b * (_eE0 * sig12 + AB1) : s12_a12;

196

198 real somg2 = _salp0 * ssig2, comg2 = csig2,

199 E = copysign(real(1), _salp0);

200

201 real cchi2 = _f1 * dn2 * comg2;

203 ? E * (sig12

204 - (atan2( ssig2, csig2) - atan2( _ssig1, _csig1))

205 + (atan2(E * somg2, cchi2) - atan2(E * _somg1, _cchi1)))

206 : atan2(somg2 * _cchi1 - cchi2 * _somg1,

207 cchi2 * _cchi1 + somg2 * _somg1);

208 real lam12 = chi12 -

209 _e2/_f1 * _salp0 * _hH0 *

210 (sig12 + (_eE.deltaH(ssig2, csig2, dn2) - _hH1));

212 lon2 = outmask & LONG_UNROLL ? _lon1 + lon12 :

215 }

216

219

222

224 real J12 = _k2 * _dD0 * (sig12 + (_eE.deltaD(ssig2, csig2, dn2) - _dD1));

226

227

228 m12 = _b * ((dn2 * (_csig1 * ssig2) - _dn1 * (_ssig1 * csig2))

229 - _csig1 * csig2 * J12);

231 real t = _k2 * (ssig2 - _ssig1) * (ssig2 + _ssig1) / (_dn1 + dn2);

232 M12 = csig12 + (t * ssig2 - csig2 * J12) * _ssig1 / _dn1;

233 M21 = csig12 - (t * _ssig1 - _csig1 * J12) * ssig2 / dn2;

234 }

235 }

236

237 if (outmask & AREA) {

238 real B42 = _aA4 == 0 ? 0 :

240 real salp12, calp12;

241 if (_calp0 == 0 || _salp0 == 0) {

242

243 salp12 = salp2 * _calp1 - calp2 * _salp1;

244 calp12 = calp2 * _calp1 + salp2 * _salp1;

245

246

247

248

249

250

251

252 } else {

253

254

255

256

257

258

259

260

261 salp12 = _calp0 * _salp0 *

262 (csig12 <= 0 ? _csig1 * (1 - csig12) + ssig12 * _ssig1 :

263 ssig12 * (_csig1 * ssig12 / (1 + csig12) + _ssig1));

264 calp12 = Math::sq(_salp0) + Math::sq(_calp0) * _csig1 * csig2;

265 }

266 S12 = _c2 * atan2(salp12, calp12) + _aA4 * (B42 - _bB41);

267 }

268

269 return arcmode ? s12_a12 : sig12 / Math::degree();

270 }

271

273 _s13 = s13;

274 real t;

275

276

277 _a13 = GenPosition(false, _s13, 0u, t, t, t, t, t, t, t, t);

278 }

279

281 _a13 = a13;

282

284 real t;

285 GenPosition(true, _a13, DISTANCE, t, t, t, _s13, t, t, t, t);

286 }

287

291

292}

GeographicLib::Math::real real

Header for GeographicLib::GeodesicLineExact class.

static real integral(real sinx, real cosx, const real F[], int N)

Math::real deltaE(real sn, real cn, real dn) const

void Reset(real k2=0, real alpha2=0)

Math::real Delta(real sn, real cn) const

Math::real deltaD(real sn, real cn, real dn) const

Math::real deltaH(real sn, real cn, real dn) const

Math::real deltaEinv(real stau, real ctau) const

Exact geodesic calculations.

void SetArc(real a13)

Definition GeodesicLineExact.cpp:280

Math::real GenPosition(bool arcmode, real s12_a12, unsigned outmask, real &lat2, real &lon2, real &azi2, real &s12, real &m12, real &M12, real &M21, real &S12) const

Definition GeodesicLineExact.cpp:143

void SetDistance(real s13)

Definition GeodesicLineExact.cpp:272

void GenSetDistance(bool arcmode, real s13_a13)

Definition GeodesicLineExact.cpp:288

static void sincosd(T x, T &sinx, T &cosx)

static T atan2d(T y, T x)

static void norm(T &x, T &y)

static T AngNormalize(T x)

Namespace for GeographicLib.