GeodesicLine.hpp

Go to the documentation of this file.

 
#if !defined(GEOGRAPHICLIB_GEODESICLINE_HPP)
#define GEOGRAPHICLIB_GEODESICLINE_HPP 1
 
#include <GeographicLib/Constants.hpp>
#include <GeographicLib/Geodesic.hpp>
 
namespace GeographicLib {
 
  class GEOGRAPHICLIB_EXPORT GeodesicLine {
  private:
    typedef Math::real real;
    friend class Geodesic;
    static const int nC1_ = Geodesic::nC1_;
    static const int nC1p_ = Geodesic::nC1p_;
    static const int nC2_ = Geodesic::nC2_;
    static const int nC3_ = Geodesic::nC3_;
    static const int nC4_ = Geodesic::nC4_;
 
    real tiny_;
    real _lat1, _lon1, _azi1;
    real _a, _f, _b, _c2, _f1, _salp0, _calp0, _k2,
      _salp1, _calp1, _ssig1, _csig1, _dn1, _stau1, _ctau1, _somg1, _comg1,
      _A1m1, _A2m1, _A3c, _B11, _B21, _B31, _A4, _B41;
    real _a13, _s13;
    // index zero elements of _C1a, _C1pa, _C2a, _C3a are unused
    real _C1a[nC1_ + 1], _C1pa[nC1p_ + 1], _C2a[nC2_ + 1], _C3a[nC3_],
      _C4a[nC4_];    // all the elements of _C4a are used
    unsigned _caps;
 
    void LineInit(const Geodesic& g,
                  real lat1, real lon1,
                  real azi1, real salp1, real calp1,
                  unsigned caps);
    GeodesicLine(const Geodesic& g,
                 real lat1, real lon1,
                 real azi1, real salp1, real calp1,
                 unsigned caps, bool arcmode, real s13_a13);
 
    enum captype {
      CAP_NONE = Geodesic::CAP_NONE,
      CAP_C1   = Geodesic::CAP_C1,
      CAP_C1p  = Geodesic::CAP_C1p,
      CAP_C2   = Geodesic::CAP_C2,
      CAP_C3   = Geodesic::CAP_C3,
      CAP_C4   = Geodesic::CAP_C4,
      CAP_ALL  = Geodesic::CAP_ALL,
      CAP_MASK = Geodesic::CAP_MASK,
      OUT_ALL  = Geodesic::OUT_ALL,
      OUT_MASK = Geodesic::OUT_MASK,
    };
  public:
 
    enum mask {
      NONE          = Geodesic::NONE,
      LATITUDE      = Geodesic::LATITUDE,
      LONGITUDE     = Geodesic::LONGITUDE,
      AZIMUTH       = Geodesic::AZIMUTH,
      DISTANCE      = Geodesic::DISTANCE,
      DISTANCE_IN   = Geodesic::DISTANCE_IN,
      REDUCEDLENGTH = Geodesic::REDUCEDLENGTH,
      GEODESICSCALE = Geodesic::GEODESICSCALE,
      AREA          = Geodesic::AREA,
      LONG_UNROLL   = Geodesic::LONG_UNROLL,
      ALL           = Geodesic::ALL,
    };
 
 
    GeodesicLine(const Geodesic& g, real lat1, real lon1, real azi1,
                 unsigned caps = ALL);
 
    GeodesicLine() : _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 {
      return Init() ? Math::atan2d(_ssig1, _csig1) : 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_GEODESICLINE_HPP