Loading...
Searching...
No Matches
AuxLatitude.hpp
Go to the documentation of this file.
/**
* \file AuxLatitude.hpp
* \brief Header for the GeographicLib::AuxLatitude class
*
* This file is an implementation of the methods described in
* - C. F. F. Karney,
* <a href="https://doi.org/10.1080/00396265.2023.2217604">
* On auxiliary latitudes,</a>
* Survey Review 56(395), 165--180 (2024);
* preprint
* <a href="https://arxiv.org/abs/2212.05818">arXiv:2212.05818</a>.
* .
* Copyright (c) Charles Karney (2022-2023) <karney@alum.mit.edu> and licensed
* under the MIT/X11 License. For more information, see
* https://geographiclib.sourceforge.io/
**********************************************************************/
#if !defined(GEOGRAPHICLIB_AUXLATITUDE_HPP)
#define GEOGRAPHICLIB_AUXLATITUDE_HPP 1
#include <utility>
#include <GeographicLib/Math.hpp>
#include <GeographicLib/AuxAngle.hpp>
#if !defined(GEOGRAPHICLIB_AUXLATITUDE_ORDER)
/**
* The order of the series approximation used in AuxLatitude.
* GEOGRAPHICLIB_AUXLATITUDE_ORDER can be set to one of [4, 6, 8]. Use order
* appropriate for double precision, 6, also for GEOGRAPHICLIB_PRECISION == 5
* to enable truncation errors to be measured easily.
**********************************************************************/
# define GEOGRAPHICLIB_AUXLATITUDE_ORDER \
(GEOGRAPHICLIB_PRECISION == 2 || GEOGRAPHICLIB_PRECISION >= 5 ? 6 : \
(GEOGRAPHICLIB_PRECISION == 1 ? 4 : 8))
#endif
namespace GeographicLib {
/**
* \brief Conversions between auxiliary latitudes.
*
* This class is an implementation of the methods described in
* - C. F. F. Karney,
* <a href="https://doi.org/10.1080/00396265.2023.2217604">
* On auxiliary latitudes,</a>
* Survey Review 56(395), 165--180 (2024);
* preprint
* <a href="https://arxiv.org/abs/2212.05818">arXiv:2212.05818</a>.
*
* The provides accurate conversions between geographic (\e phi, &phi;),
* parametric (\e beta, &beta;), geocentric (\e theta, &theta;), rectifying
* (\e mu, &mu;), conformal (\e chi, &chi;), and authalic (\e xi, &xi;)
* latitudes for an ellipsoid of revolution. A latitude is represented by
* the class AuxAngle in order to maintain precision close to the poles.
*
* The class implements two methods for the conversion:
* - Direct evaluation of the defining equations, the \e exact method. These
* equations are formulated so as to preserve relative accuracy of the
* tangent of the latitude, ensuring high accuracy near the equator and the
* poles. Newton's method is used for those conversions that can't be
* expressed in closed form.
* - Expansions in powers of \e n, the third flattening, the \e series
* method. This delivers full accuracy for abs(\e f) &le; 1/150. Here, \e
* f is the flattening of the ellipsoid.
*
* The series method is the preferred method of conversion for any conversion
* involving &mu;, &chi;, or &xi;, with abs(\e f) &le; 1/150. The equations
* for the conversions between &phi;, &beta;, and &theta; are sufficiently
* simple that the exact method should be used for such conversions and also
* for conversions with with abs(\e f) &gt; 1/150.
*
* Example of use:
* \include example-AuxLatitude.cpp
**********************************************************************/
class GEOGRAPHICLIB_EXPORT AuxLatitude {
typedef Math::real real;
AuxLatitude(const std::pair<real, real>& axes);
public:
/**
* The floating-point type for real numbers. This just connects to the
* template parameters for the class.
**********************************************************************/
/**
* The different auxiliary latitudes.
**********************************************************************/
enum aux {
/**
* Geographic latitude, \e phi, &phi;
* @hideinitializer
**********************************************************************/
GEOGRAPHIC = 0,
/**
* Parametric latitude, \e beta, &beta;
* @hideinitializer
**********************************************************************/
PARAMETRIC = 1,
/**
* %Geocentric latitude, \e theta, &theta;
* @hideinitializer
**********************************************************************/
GEOCENTRIC = 2,
/**
* Rectifying latitude, \e mu, &mu;
* @hideinitializer
**********************************************************************/
RECTIFYING = 3,
/**
* Conformal latitude, \e chi, &chi;
* @hideinitializer
**********************************************************************/
CONFORMAL = 4,
/**
* Authalic latitude, \e xi, &xi;
* @hideinitializer
**********************************************************************/
AUTHALIC = 5,
/**
* The total number of auxiliary latitudes
* @hideinitializer
**********************************************************************/
AUXNUMBER = 6,
/**
* An alias for GEOGRAPHIC
* @hideinitializer
**********************************************************************/
PHI = GEOGRAPHIC,
/**
* An alias for PARAMETRIC
* @hideinitializer
**********************************************************************/
BETA = PARAMETRIC,
/**
* An alias for GEOCENTRIC
* @hideinitializer
**********************************************************************/
THETA = GEOCENTRIC,
/**
* An alias for RECTIFYING
* @hideinitializer
**********************************************************************/
MU = RECTIFYING,
/**
* An alias for CONFORMAL
* @hideinitializer
**********************************************************************/
CHI = CONFORMAL,
/**
* An alias for AUTHALIC
* @hideinitializer
**********************************************************************/
XI = AUTHALIC,
/**
* An alias for GEOGRAPHIC
* @hideinitializer
**********************************************************************/
COMMON = GEOGRAPHIC,
/**
* An alias for GEOGRAPHIC
* @hideinitializer
**********************************************************************/
GEODETIC = GEOGRAPHIC,
/**
* An alias for PARAMETRIC
* @hideinitializer
**********************************************************************/
REDUCED = PARAMETRIC,
};
/**
* Constructor
*
* @param[in] a equatorial radius.
* @param[in] f flattening of ellipsoid. Setting \e f = 0 gives a sphere.
* Negative \e f gives a prolate ellipsoid.
* @exception GeographicErr if \e a or (1 &minus; \e f) \e a is not
* positive.
*
* \note the constructor does not precompute the coefficients for the
* Fourier series for the series conversions. These are computed and saved
* when first needed.
**********************************************************************/
AuxLatitude(real a, real f);
/**
* Construct and return an AuxLatitude object specified in terms of the
* semiaxes
*
* @param[in] a equatorial radius.
* @param[in] b polar semiaxis.
* @exception GeographicErr if \e a or \e b is not positive.
*
* This allows a new AuxAngle to be initialized as an angle in radians with
* @code
* AuxLatitude aux(AuxLatitude::axes(a, b));
* @endcode
**********************************************************************/
static AuxLatitude axes(real a, real b) {
return AuxLatitude(std::pair<real, real>(a, b));
}
/**
* Convert between any two auxiliary latitudes specified as AuxAngle.
*
* @param[in] auxin an AuxLatitude::aux indicating the type of
* auxiliary latitude \e zeta.
* @param[in] auxout an AuxLatitude::aux indicating the type of
* auxiliary latitude \e eta.
* @param[in] zeta the input auxiliary latitude as an AuxAngle
* @param[in] exact if true use the exact equations instead of the Taylor
* series [default false].
* @return the output auxiliary latitude \e eta as an AuxAngle.
*
* With \e exact = false, the Fourier coefficients for a specific \e auxin
* and \e auxout are computed and saved on the first call; the saved
* coefficients are used on subsequent calls. The series method is
* accurate for abs(\e f) &le; 1/150; for other \e f, the exact method
* should be used.
**********************************************************************/
AuxAngle Convert(int auxin, int auxout, const AuxAngle& zeta,
bool exact = false) const;
/**
* Convert between any two auxiliary latitudes specified in degrees.
*
* @param[in] auxin an AuxLatitude::aux indicating the type of
* auxiliary latitude \e zeta.
* @param[in] auxout an AuxLatitude::aux indicating the type of
* auxiliary latitude \e eta.
* @param[in] zeta the input auxiliary latitude in degrees.
* @param[in] exact if true use the exact equations instead of the Taylor
* series [default false].
* @return the output auxiliary latitude \e eta in degrees.
*
* With \e exact = false, the Fourier coefficients for a specific \e auxin
* and \e auxout are computed and saved on the first call; the saved
* coefficients are used on subsequent calls. The series method is
* accurate for abs(\e f) &le; 1/150; for other \e f, the exact method
* should be used.
**********************************************************************/
Math::real Convert(int auxin, int auxout, real zeta, bool exact = false)
const;
/**
* Convert geographic latitude to an auxiliary latitude \e eta.
*
* @param[in] auxout an AuxLatitude::aux indicating the auxiliary
* latitude returned.
* @param[in] phi the geographic latitude.
* @param[out] diff optional pointer to the derivative d tan(\e eta) / d
* tan(\e phi).
* @return the auxiliary latitude \e eta.
*
* This uses the exact equations.
**********************************************************************/
AuxAngle ToAuxiliary(int auxout, const AuxAngle& phi, real* diff = nullptr)
const;
/**
* Convert an auxiliary latitude \e zeta to geographic latitude.
*
* @param[in] auxin an AuxLatitude::aux indicating the type of
* auxiliary latitude \e zeta.
* @param[in] zeta the input auxiliary latitude.
* @param[out] niter optional pointer to the number of iterations.
* @return the geographic latitude \e phi.
*
* This uses the exact equations.
**********************************************************************/
AuxAngle FromAuxiliary(int auxin, const AuxAngle& zeta,
int* niter = nullptr) const;
/**
* Return the rectifying radius.
*
* @param[in] exact if true use the exact expression instead of the Taylor
* series [default false].
* @return the rectifying radius in the same units as \e a.
**********************************************************************/
Math::real RectifyingRadius(bool exact = false) const;
/**
* Return the authalic radius squared.
*
* @param[in] exact if true use the exact expression instead of the Taylor
* series [default false].
* @return the authalic radius squared in the same units as \e a.
**********************************************************************/
Math::real AuthalicRadiusSquared(bool exact = false) const;
/**
* @return \e a the equatorial radius of the ellipsoid (meters).
**********************************************************************/
Math::real EquatorialRadius() const { return _a; }
/**
* @return \e b the polar semiaxis of the ellipsoid (meters).
**********************************************************************/
Math::real PolarSemiAxis() const { return _b; }
/**
* @return \e f, the flattening of the ellipsoid.
**********************************************************************/
Math::real Flattening() const { return _f; }
/**
* Use Clenshaw to sum a Fouier series.
*
* @param[in] sinp if true sum the sine series, else sum the cosine series.
* @param[in] szeta sin(\e zeta).
* @param[in] czeta cos(\e zeta).
* @param[in] c the array of coefficients.
* @param[in] K the number of coefficients.
* @return the Clenshaw sum.
*
* The result returned is \f$ \sum_0^{K-1} c_k \sin (2k+2)\zeta \f$, if \e
* sinp is true; with \e sinp false, replace sin by cos.
**********************************************************************/
// Clenshaw applied to sum(c[k] * sin( (2*k+2) * zeta), i, 0, K-1);
// if !sinp then subst sine->cosine.
static Math::real Clenshaw(bool sinp, real szeta, real czeta,
const real c[], int K);
/**
* The order of the series expansions. This is set at compile time to
* either 4, 6, or 8, by the preprocessor macro
* GEOGRAPHICLIB_AUXLATITUDE_ORDER.
* @hideinitializer
**********************************************************************/
static const int Lmax = GEOGRAPHICLIB_AUXLATITUDE_ORDER;
/**
* A global instantiation of Ellipsoid with the parameters for the WGS84
* ellipsoid.
**********************************************************************/
static const AuxLatitude& WGS84();
private:
// Maximum number of iterations for Newton's method
static const int numit_ = 1000;
real tol_, bmin_, bmax_; // Static consts for Newton's method
// the function atanh(e * sphi)/e + sphi / (1 - (e * sphi)^2);
protected:
/**
* Convert geographic latitude to parametric latitude
*
* @param[in] phi geographic latitude.
* @param[out] diff optional pointer to the derivative d tan(\e beta) / d
* tan(\e phi).
* @return \e beta, the parametric latitude
**********************************************************************/
AuxAngle Parametric(const AuxAngle& phi, real* diff = nullptr) const;
/**
* Convert geographic latitude to geocentric latitude
*
* @param[in] phi geographic latitude.
* @param[out] diff optional pointer to the derivative d tan(\e theta) / d
* tan(\e phi).
* @return \e theta, the geocentric latitude.
**********************************************************************/
AuxAngle Geocentric(const AuxAngle& phi, real* diff = nullptr) const;
/**
* Convert geographic latitude to rectifying latitude
*
* @param[in] phi geographic latitude.
* @param[out] diff optional pointer to the derivative d tan(\e mu) / d
* tan(\e phi).
* @return \e mu, the rectifying latitude.
**********************************************************************/
AuxAngle Rectifying(const AuxAngle& phi, real* diff = nullptr) const;
/**
* Convert geographic latitude to conformal latitude
*
* @param[in] phi geographic latitude.
* @param[out] diff optional pointer to the derivative d tan(\e chi) / d
* tan(\e phi).
* @return \e chi, the conformal latitude.
**********************************************************************/
AuxAngle Conformal(const AuxAngle& phi, real* diff = nullptr) const;
/**
* Convert geographic latitude to authalic latitude
*
* @param[in] phi geographic latitude.
* @param[out] diff optional pointer to the derivative d tan(\e xi) / d
* tan(\e phi).
* @return \e xi, the authalic latitude.
**********************************************************************/
AuxAngle Authalic(const AuxAngle& phi, real* diff = nullptr) const;
/// \cond SKIP
// Ellipsoid parameters
real _a, _b, _f, _fm1, _e2, _e2m1, _e12, _e12p1, _n, _e, _e1, _n2, _q;
// To hold computed Fourier coefficients
mutable real _c[Lmax * AUXNUMBER * AUXNUMBER];
// 1d index into AUXNUMBER x AUXNUMBER data
static int ind(int auxout, int auxin) {
return (auxout >= 0 && auxout < AUXNUMBER &&
auxin >= 0 && auxin < AUXNUMBER) ?
AUXNUMBER * auxout + auxin : -1;
}
// the function sqrt(1 + tphi^2), convert tan to sec
static real sc(real tphi)
{ using std::hypot; return hypot(real(1), tphi); }
// the function tphi / sqrt(1 + tphi^2), convert tan to sin
static real sn(real tphi) {
using std::isinf, std::copysign;
return isinf(tphi) ? copysign(real(1), tphi) : tphi / sc(tphi);
}
// Populate [_c[Lmax * k], _c[Lmax * (k + 1)])
void fillcoeff(int auxin, int auxout, int k) const;
// the function atanh(e * sphi)/e; works for e^2 = 0 and e^2 < 0
real atanhee(real tphi) const;
/// \endcond
private:
// the function atanh(e * sphi)/e + sphi / (1 - (e * sphi)^2);
real q(real tphi) const;
// The divided difference of (q(1) - q(sphi)) / (1 - sphi)
real Dq(real tphi) const;
};
} // namespace GeographicLib
#endif // GEOGRAPHICLIB_AUXLATITUDE_HPP
AuxAngle.hpp
Header for the GeographicLib::AuxAngle class.
GEOGRAPHICLIB_AUXLATITUDE_ORDER
#define GEOGRAPHICLIB_AUXLATITUDE_ORDER
Definition AuxLatitude.hpp:32
GEOGRAPHICLIB_EXPORT
#define GEOGRAPHICLIB_EXPORT
Definition Constants.hpp:59
real
GeographicLib::Math::real real
Definition Geod3Solve.cpp:25
Math.hpp
Header for GeographicLib::Math class.
GeographicLib::AuxAngle
An accurate representation of angles.
Definition AuxAngle.hpp:51
GeographicLib::AuxLatitude
Conversions between auxiliary latitudes.
Definition AuxLatitude.hpp:75
GeographicLib::AuxLatitude::EquatorialRadius
Math::real EquatorialRadius() const
Definition AuxLatitude.hpp:284
GeographicLib::AuxLatitude::Conformal
AuxAngle Conformal(const AuxAngle &phi, real *diff=nullptr) const
Definition AuxLatitude.cpp:139
GeographicLib::AuxLatitude::Flattening
Math::real Flattening() const
Definition AuxLatitude.hpp:292
GeographicLib::AuxLatitude::aux
aux
Definition AuxLatitude.hpp:86
GeographicLib::AuxLatitude::XI
@ XI
Definition AuxLatitude.hpp:151
GeographicLib::AuxLatitude::AUTHALIC
@ AUTHALIC
Definition AuxLatitude.hpp:116
GeographicLib::AuxLatitude::COMMON
@ COMMON
Definition AuxLatitude.hpp:156
GeographicLib::AuxLatitude::CONFORMAL
@ CONFORMAL
Definition AuxLatitude.hpp:111
GeographicLib::AuxLatitude::BETA
@ BETA
Definition AuxLatitude.hpp:131
GeographicLib::AuxLatitude::MU
@ MU
Definition AuxLatitude.hpp:141
GeographicLib::AuxLatitude::GEODETIC
@ GEODETIC
Definition AuxLatitude.hpp:161
GeographicLib::AuxLatitude::GEOCENTRIC
@ GEOCENTRIC
Definition AuxLatitude.hpp:101
GeographicLib::AuxLatitude::THETA
@ THETA
Definition AuxLatitude.hpp:136
GeographicLib::AuxLatitude::RECTIFYING
@ RECTIFYING
Definition AuxLatitude.hpp:106
GeographicLib::AuxLatitude::GEOGRAPHIC
@ GEOGRAPHIC
Definition AuxLatitude.hpp:91
GeographicLib::AuxLatitude::REDUCED
@ REDUCED
Definition AuxLatitude.hpp:166
GeographicLib::AuxLatitude::PARAMETRIC
@ PARAMETRIC
Definition AuxLatitude.hpp:96
GeographicLib::AuxLatitude::CHI
@ CHI
Definition AuxLatitude.hpp:146
GeographicLib::AuxLatitude::AUXNUMBER
@ AUXNUMBER
Definition AuxLatitude.hpp:121
GeographicLib::AuxLatitude::PHI
@ PHI
Definition AuxLatitude.hpp:126
GeographicLib::AuxLatitude::PolarSemiAxis
Math::real PolarSemiAxis() const
Definition AuxLatitude.hpp:288
GeographicLib::AuxLatitude::Lmax
static const int Lmax
Definition AuxLatitude.hpp:316
GeographicLib::AuxLatitude::Authalic
AuxAngle Authalic(const AuxAngle &phi, real *diff=nullptr) const
Definition AuxLatitude.cpp:196
GeographicLib::AuxLatitude::Geocentric
AuxAngle Geocentric(const AuxAngle &phi, real *diff=nullptr) const
Definition AuxLatitude.cpp:89
GeographicLib::AuxLatitude::Parametric
AuxAngle Parametric(const AuxAngle &phi, real *diff=nullptr) const
Definition AuxLatitude.cpp:84
GeographicLib::AuxLatitude::axes
static AuxLatitude axes(real a, real b)
Definition AuxLatitude.hpp:195
GeographicLib::AuxLatitude::Clenshaw
static Math::real Clenshaw(bool sinp, real szeta, real czeta, const real c[], int K)
GeographicLib::AuxLatitude::WGS84
static const AuxLatitude & WGS84()
Definition AuxLatitude.cpp:79
GeographicLib::AuxLatitude::Rectifying
AuxAngle Rectifying(const AuxAngle &phi, real *diff=nullptr) const
Definition AuxLatitude.cpp:94
GeographicLib::Math::real
double real
Definition Math.hpp:115
GeographicLib
Namespace for GeographicLib.
Definition Accumulator.cpp:12