GeodesicLineExact.hpp

Go to the documentation of this file.

 
#if !defined(GEOGRAPHICLIB_GEODESICLINEEXACT_HPP)
#define GEOGRAPHICLIB_GEODESICLINEEXACT_HPP 1
 
#include <GeographicLib/Constants.hpp>
#include <GeographicLib/GeodesicExact.hpp>
#include <GeographicLib/EllipticFunction.hpp>
 
namespace GeographicLib {
 
  class GEOGRAPHICLIB_EXPORT GeodesicLineExact {
  private:
    typedef Math::real real;
    friend class GeodesicExact;
    static const int nC4_ = GeodesicExact::nC4_;
 
    real tiny_;
    real _lat1, _lon1, _azi1;
    real _a, _f, _b, _c2, _f1, _e2, _salp0, _calp0, _k2,
      _salp1, _calp1, _ssig1, _csig1, _dn1, _stau1, _ctau1,
      _somg1, _comg1, _cchi1,
      _A4, _B41, _E0, _D0, _H0, _E1, _D1, _H1;
    real _a13, _s13;
    real _C4a[nC4_];            // all the elements of _C4a are used
    EllipticFunction _E;
    unsigned _caps;
 
    void LineInit(const GeodesicExact& g,
                  real lat1, real lon1,
                  real azi1, real salp1, real calp1,
                  unsigned caps);
    GeodesicLineExact(const GeodesicExact& g,
                      real lat1, real lon1,
                      real azi1, real salp1, real calp1,
                      unsigned caps, bool arcmode, real s13_a13);
 
    enum captype {
      CAP_NONE = GeodesicExact::CAP_NONE,
      CAP_E    = GeodesicExact::CAP_E,
      CAP_D    = GeodesicExact::CAP_D,
      CAP_H    = GeodesicExact::CAP_H,
      CAP_C4   = GeodesicExact::CAP_C4,
      CAP_ALL  = GeodesicExact::CAP_ALL,
      CAP_MASK = GeodesicExact::CAP_MASK,
      OUT_ALL  = GeodesicExact::OUT_ALL,
      OUT_MASK = GeodesicExact::OUT_MASK,
    };
  public:
 
    enum mask {
      NONE          = GeodesicExact::NONE,
      LATITUDE      = GeodesicExact::LATITUDE,
      LONGITUDE     = GeodesicExact::LONGITUDE,
      AZIMUTH       = GeodesicExact::AZIMUTH,
      DISTANCE      = GeodesicExact::DISTANCE,
      DISTANCE_IN   = GeodesicExact::DISTANCE_IN,
      REDUCEDLENGTH = GeodesicExact::REDUCEDLENGTH,
      GEODESICSCALE = GeodesicExact::GEODESICSCALE,
      AREA          = GeodesicExact::AREA,
      LONG_UNROLL = GeodesicExact::LONG_UNROLL,
      ALL           = GeodesicExact::ALL,
    };
 
 
    GeodesicLineExact(const GeodesicExact& g, real lat1, real lon1, real azi1,
                      unsigned caps = ALL);
 
    GeodesicLineExact() : _caps(0U) {}
 
 
    Math::real Position(real s12,
                        real& lat2, real& lon2, real& azi2,
                        real& m12, real& M12, real& M21,
                        real& S12) const {
      real t;
      return GenPosition(false, s12,
                         LATITUDE | LONGITUDE | AZIMUTH |
                         REDUCEDLENGTH | GEODESICSCALE | AREA,
                         lat2, lon2, azi2, t, m12, M12, M21, S12);
    }
 
    Math::real Position(real s12, real& lat2, real& lon2) const {
      real t;
      return GenPosition(false, s12,
                         LATITUDE | LONGITUDE,
                         lat2, lon2, t, t, t, t, t, t);
    }
 
    Math::real Position(real s12, real& lat2, real& lon2,
                        real& azi2) const {
      real t;
      return GenPosition(false, s12,
                         LATITUDE | LONGITUDE | AZIMUTH,
                         lat2, lon2, azi2, t, t, t, t, t);
    }
 
    Math::real Position(real s12, real& lat2, real& lon2,
                        real& azi2, real& m12) const {
      real t;
      return GenPosition(false, s12,
                         LATITUDE | LONGITUDE |
                         AZIMUTH | REDUCEDLENGTH,
                         lat2, lon2, azi2, t, m12, t, t, t);
    }
 
    Math::real Position(real s12, real& lat2, real& lon2,
                        real& azi2, real& M12, real& M21)
      const {
      real t;
      return GenPosition(false, s12,
                         LATITUDE | LONGITUDE |
                         AZIMUTH | GEODESICSCALE,
                         lat2, lon2, azi2, t, t, M12, M21, t);
    }
 
    Math::real Position(real s12,
                        real& lat2, real& lon2, real& azi2,
                        real& m12, real& M12, real& M21)
      const {
      real t;
      return GenPosition(false, s12,
                         LATITUDE | LONGITUDE | AZIMUTH |
                         REDUCEDLENGTH | GEODESICSCALE,
                         lat2, lon2, azi2, t, m12, M12, M21, t);
    }
 
 
    void ArcPosition(real a12, real& lat2, real& lon2, real& azi2,
                     real& s12, real& m12, real& M12, real& M21,
                     real& S12) const {
      GenPosition(true, a12,
                  LATITUDE | LONGITUDE | AZIMUTH | DISTANCE |
                  REDUCEDLENGTH | GEODESICSCALE | AREA,
                  lat2, lon2, azi2, s12, m12, M12, M21, S12);
    }
 
    void ArcPosition(real a12, real& lat2, real& lon2)
      const {
      real t;
      GenPosition(true, a12,
                  LATITUDE | LONGITUDE,
                  lat2, lon2, t, t, t, t, t, t);
    }
 
    void ArcPosition(real a12,
                     real& lat2, real& lon2, real& azi2)
      const {
      real t;
      GenPosition(true, a12,
                  LATITUDE | LONGITUDE | AZIMUTH,
                  lat2, lon2, azi2, t, t, t, t, t);
    }
 
    void ArcPosition(real a12, real& lat2, real& lon2, real& azi2,
                     real& s12) const {
      real t;
      GenPosition(true, a12,
                  LATITUDE | LONGITUDE | AZIMUTH | DISTANCE,
                  lat2, lon2, azi2, s12, t, t, t, t);
    }
 
    void ArcPosition(real a12, real& lat2, real& lon2, real& azi2,
                     real& s12, real& m12) const {
      real t;
      GenPosition(true, a12,
                  LATITUDE | LONGITUDE | AZIMUTH |
                  DISTANCE | REDUCEDLENGTH,
                  lat2, lon2, azi2, s12, m12, t, t, t);
    }
 
    void ArcPosition(real a12, real& lat2, real& lon2, real& azi2,
                     real& s12, real& M12, real& M21)
      const {
      real t;
      GenPosition(true, a12,
                  LATITUDE | LONGITUDE | AZIMUTH |
                  DISTANCE | GEODESICSCALE,
                  lat2, lon2, azi2, s12, t, M12, M21, t);
    }
 
    void ArcPosition(real a12, real& lat2, real& lon2, real& azi2,
                     real& s12, real& m12, real& M12, real& M21)
      const {
      real t;
      GenPosition(true, a12,
                  LATITUDE | LONGITUDE | AZIMUTH |
                  DISTANCE | REDUCEDLENGTH | GEODESICSCALE,
                  lat2, lon2, azi2, s12, m12, M12, M21, t);
    }
 
 
    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;
 
 
    void SetDistance(real s13);
 
    void SetArc(real a13);
 
    void GenSetDistance(bool arcmode, real s13_a13);
 
 
    bool Init() const { return _caps != 0U; }
 
    Math::real Latitude() const
    { return Init() ? _lat1 : Math::NaN(); }
 
    Math::real Longitude() const
    { return Init() ? _lon1 : Math::NaN(); }
 
    Math::real Azimuth() const
    { return Init() ? _azi1 : Math::NaN(); }
 
    void Azimuth(real& sazi1, real& cazi1) const
    { if (Init()) { sazi1 = _salp1; cazi1 = _calp1; } }
 
    Math::real EquatorialAzimuth() const
    { return Init() ? Math::atan2d(_salp0, _calp0) : Math::NaN(); }
 
    void EquatorialAzimuth(real& sazi0, real& cazi0) const
    { if (Init()) { sazi0 = _salp0; cazi0 = _calp0; } }
 
    Math::real EquatorialArc() const {
      using std::atan2;
      return Init() ? atan2(_ssig1, _csig1) / Math::degree() : Math::NaN();
    }
 
    Math::real MajorRadius() const
    { return Init() ? _a : Math::NaN(); }
 
    Math::real Flattening() const
    { return Init() ? _f : Math::NaN(); }
 
    unsigned Capabilities() const { return _caps; }
 
    bool Capabilities(unsigned testcaps) const {
      testcaps &= OUT_ALL;
      return (_caps & testcaps) == testcaps;
    }
 
    Math::real GenDistance(bool arcmode) const
    { return Init() ? (arcmode ? _a13 : _s13) : Math::NaN(); }
 
    Math::real Distance() const { return GenDistance(false); }
 
    Math::real Arc() const { return GenDistance(true); }
 
  };
 
} // namespace GeographicLib
 
#endif  // GEOGRAPHICLIB_GEODESICLINEEXACT_HPP