geographiclib 0.0.1

data/ext/geographiclib/GeographicLib/AzimuthalEquidistant.hpp

@@ -0,0 +1,139 @@
+/**
+ * \file AzimuthalEquidistant.hpp
+ * \brief Header for GeographicLib::AzimuthalEquidistant class
+ *
+ * Copyright (c) Charles Karney (2009-2015) <charles@karney.com> and licensed
+ * under the MIT/X11 License.  For more information, see
+ * http://geographiclib.sourceforge.net/
+ **********************************************************************/
+
+#if !defined(GEOGRAPHICLIB_AZIMUTHALEQUIDISTANT_HPP)
+#define GEOGRAPHICLIB_AZIMUTHALEQUIDISTANT_HPP 1
+
+#include <GeographicLib/Geodesic.hpp>
+#include <GeographicLib/Constants.hpp>
+
+namespace GeographicLib {
+
+  /**
+   * \brief Azimuthal equidistant projection
+   *
+   * Azimuthal equidistant projection centered at an arbitrary position on the
+   * ellipsoid.  For a point in projected space (\e x, \e y), the geodesic
+   * distance from the center position is hypot(\e x, \e y) and the azimuth of
+   * the geodesic from the center point is atan2(\e x, \e y).  The Forward and
+   * Reverse methods also return the azimuth \e azi of the geodesic at (\e x,
+   * \e y) and reciprocal scale \e rk in the azimuthal direction which,
+   * together with the basic properties of the projection, serve to specify
+   * completely the local affine transformation between geographic and
+   * projected coordinates.
+   *
+   * The conversions all take place using a Geodesic object (by default
+   * Geodesic::WGS84()).  For more information on geodesics see \ref geodesic.
+   *
+   * Example of use:
+   * \include example-AzimuthalEquidistant.cpp
+   *
+   * <a href="GeodesicProj.1.html">GeodesicProj</a> is a command-line utility
+   * providing access to the functionality of AzimuthalEquidistant, Gnomonic,
+   * and CassiniSoldner.
+   **********************************************************************/
+
+  class GEOGRAPHICLIB_EXPORT AzimuthalEquidistant {
+  private:
+    typedef Math::real real;
+    real eps_;
+    Geodesic _earth;
+  public:
+
+    /**
+     * Constructor for AzimuthalEquidistant.
+     *
+     * @param[in] earth the Geodesic object to use for geodesic calculations.
+     *   By default this uses the WGS84 ellipsoid.
+     **********************************************************************/
+    explicit AzimuthalEquidistant(const Geodesic& earth = Geodesic::WGS84());
+
+    /**
+     * Forward projection, from geographic to azimuthal equidistant.
+     *
+     * @param[in] lat0 latitude of center point of projection (degrees).
+     * @param[in] lon0 longitude of center point of projection (degrees).
+     * @param[in] lat latitude of point (degrees).
+     * @param[in] lon longitude of point (degrees).
+     * @param[out] x easting of point (meters).
+     * @param[out] y northing of point (meters).
+     * @param[out] azi azimuth of geodesic at point (degrees).
+     * @param[out] rk reciprocal of azimuthal scale at point.
+     *
+     * \e lat0 and \e lat should be in the range [&minus;90&deg;, 90&deg;].
+     * The scale of the projection is 1 in the "radial" direction, \e azi
+     * clockwise from true north, and is 1/\e rk in the direction perpendicular
+     * to this.  A call to Forward followed by a call to Reverse will return
+     * the original (\e lat, \e lon) (to within roundoff).
+     **********************************************************************/
+    void Forward(real lat0, real lon0, real lat, real lon,
+                 real& x, real& y, real& azi, real& rk) const;
+
+    /**
+     * Reverse projection, from azimuthal equidistant to geographic.
+     *
+     * @param[in] lat0 latitude of center point of projection (degrees).
+     * @param[in] lon0 longitude of center point of projection (degrees).
+     * @param[in] x easting of point (meters).
+     * @param[in] y northing of point (meters).
+     * @param[out] lat latitude of point (degrees).
+     * @param[out] lon longitude of point (degrees).
+     * @param[out] azi azimuth of geodesic at point (degrees).
+     * @param[out] rk reciprocal of azimuthal scale at point.
+     *
+     * \e lat0 should be in the range [&minus;90&deg;, 90&deg;].  \e lat will
+     * be in the range [&minus;90&deg;, 90&deg;] and \e lon will be in the
+     * range [&minus;180&deg;, 180&deg;).  The scale of the projection is 1 in
+     * the "radial" direction, \e azi clockwise from true north, and is 1/\e rk
+     * in the direction perpendicular to this.  A call to Reverse followed by a
+     * call to Forward will return the original (\e x, \e y) (to roundoff) only
+     * if the geodesic to (\e x, \e y) is a shortest path.
+     **********************************************************************/
+    void Reverse(real lat0, real lon0, real x, real y,
+                 real& lat, real& lon, real& azi, real& rk) const;
+
+    /**
+     * AzimuthalEquidistant::Forward without returning the azimuth and scale.
+     **********************************************************************/
+    void Forward(real lat0, real lon0, real lat, real lon,
+                 real& x, real& y) const {
+      real azi, rk;
+      Forward(lat0, lon0, lat, lon, x, y, azi, rk);
+    }
+
+    /**
+     * AzimuthalEquidistant::Reverse without returning the azimuth and scale.
+     **********************************************************************/
+    void Reverse(real lat0, real lon0, real x, real y,
+                 real& lat, real& lon) const {
+      real azi, rk;
+      Reverse(lat0, lon0, x, y, lat, lon, azi, rk);
+    }
+
+    /** \name Inspector functions
+     **********************************************************************/
+    ///@{
+    /**
+     * @return \e a the equatorial radius of the ellipsoid (meters).  This is
+     *   the value inherited from the Geodesic object used in the constructor.
+     **********************************************************************/
+    Math::real MajorRadius() const { return _earth.MajorRadius(); }
+
+    /**
+     * @return \e f the flattening of the ellipsoid.  This is the value
+     *   inherited from the Geodesic object used in the constructor.
+     **********************************************************************/
+    Math::real Flattening() const { return _earth.Flattening(); }
+    ///@}
+
+  };
+
+} // namespace GeographicLib
+
+#endif  // GEOGRAPHICLIB_AZIMUTHALEQUIDISTANT_HPP

data/ext/geographiclib/GeographicLib/CassiniSoldner.hpp

@@ -0,0 +1,204 @@
+/**
+ * \file CassiniSoldner.hpp
+ * \brief Header for GeographicLib::CassiniSoldner class
+ *
+ * Copyright (c) Charles Karney (2009-2015) <charles@karney.com> and licensed
+ * under the MIT/X11 License.  For more information, see
+ * http://geographiclib.sourceforge.net/
+ **********************************************************************/
+
+#if !defined(GEOGRAPHICLIB_CASSINISOLDNER_HPP)
+#define GEOGRAPHICLIB_CASSINISOLDNER_HPP 1
+
+#include <GeographicLib/Geodesic.hpp>
+#include <GeographicLib/GeodesicLine.hpp>
+#include <GeographicLib/Constants.hpp>
+
+namespace GeographicLib {
+
+  /**
+   * \brief Cassini-Soldner projection
+   *
+   * Cassini-Soldner projection centered at an arbitrary position, \e lat0, \e
+   * lon0, on the ellipsoid.  This projection is a transverse cylindrical
+   * equidistant projection.  The projection from (\e lat, \e lon) to easting
+   * and northing (\e x, \e y) is defined by geodesics as follows.  Go north
+   * along a geodesic a distance \e y from the central point; then turn
+   * clockwise 90&deg; and go a distance \e x along a geodesic.
+   * (Although the initial heading is north, this changes to south if the pole
+   * is crossed.)  This procedure uniquely defines the reverse projection.  The
+   * forward projection is constructed as follows.  Find the point (\e lat1, \e
+   * lon1) on the meridian closest to (\e lat, \e lon).  Here we consider the
+   * full meridian so that \e lon1 may be either \e lon0 or \e lon0 +
+   * 180&deg;.  \e x is the geodesic distance from (\e lat1, \e lon1) to
+   * (\e lat, \e lon), appropriately signed according to which side of the
+   * central meridian (\e lat, \e lon) lies.  \e y is the shortest distance
+   * along the meridian from (\e lat0, \e lon0) to (\e lat1, \e lon1), again,
+   * appropriately signed according to the initial heading.  [Note that, in the
+   * case of prolate ellipsoids, the shortest meridional path from (\e lat0, \e
+   * lon0) to (\e lat1, \e lon1) may not be the shortest path.]  This procedure
+   * uniquely defines the forward projection except for a small class of points
+   * for which there may be two equally short routes for either leg of the
+   * path.
+   *
+   * Because of the properties of geodesics, the (\e x, \e y) grid is
+   * orthogonal.  The scale in the easting direction is unity.  The scale, \e
+   * k, in the northing direction is unity on the central meridian and
+   * increases away from the central meridian.  The projection routines return
+   * \e azi, the true bearing of the easting direction, and \e rk = 1/\e k, the
+   * reciprocal of the scale in the northing direction.
+   *
+   * The conversions all take place using a Geodesic object (by default
+   * Geodesic::WGS84()).  For more information on geodesics see \ref geodesic.
+   * The determination of (\e lat1, \e lon1) in the forward projection is by
+   * solving the inverse geodesic problem for (\e lat, \e lon) and its twin
+   * obtained by reflection in the meridional plane.  The scale is found by
+   * determining where two neighboring geodesics intersecting the central
+   * meridian at \e lat1 and \e lat1 + \e dlat1 intersect and taking the ratio
+   * of the reduced lengths for the two geodesics between that point and,
+   * respectively, (\e lat1, \e lon1) and (\e lat, \e lon).
+   *
+   * Example of use:
+   * \include example-CassiniSoldner.cpp
+   *
+   * <a href="GeodesicProj.1.html">GeodesicProj</a> is a command-line utility
+   * providing access to the functionality of AzimuthalEquidistant, Gnomonic,
+   * and CassiniSoldner.
+   **********************************************************************/
+
+  class GEOGRAPHICLIB_EXPORT CassiniSoldner {
+  private:
+    typedef Math::real real;
+    Geodesic _earth;
+    GeodesicLine _meridian;
+    real _sbet0, _cbet0;
+    static const unsigned maxit_ = 10;
+
+  public:
+
+    /**
+     * Constructor for CassiniSoldner.
+     *
+     * @param[in] earth the Geodesic object to use for geodesic calculations.
+     *   By default this uses the WGS84 ellipsoid.
+     *
+     * This constructor makes an "uninitialized" object.  Call Reset to set the
+     * central latitude and longitude, prior to calling Forward and Reverse.
+     **********************************************************************/
+    explicit CassiniSoldner(const Geodesic& earth = Geodesic::WGS84());
+
+    /**
+     * Constructor for CassiniSoldner specifying a center point.
+     *
+     * @param[in] lat0 latitude of center point of projection (degrees).
+     * @param[in] lon0 longitude of center point of projection (degrees).
+     * @param[in] earth the Geodesic object to use for geodesic calculations.
+     *   By default this uses the WGS84 ellipsoid.
+     *
+     * \e lat0 should be in the range [&minus;90&deg;, 90&deg;].
+     **********************************************************************/
+    CassiniSoldner(real lat0, real lon0,
+                   const Geodesic& earth = Geodesic::WGS84());
+
+    /**
+     * Set the central point of the projection
+     *
+     * @param[in] lat0 latitude of center point of projection (degrees).
+     * @param[in] lon0 longitude of center point of projection (degrees).
+     *
+     * \e lat0 should be in the range [&minus;90&deg;, 90&deg;].
+     **********************************************************************/
+    void Reset(real lat0, real lon0);
+
+    /**
+     * Forward projection, from geographic to Cassini-Soldner.
+     *
+     * @param[in] lat latitude of point (degrees).
+     * @param[in] lon longitude of point (degrees).
+     * @param[out] x easting of point (meters).
+     * @param[out] y northing of point (meters).
+     * @param[out] azi azimuth of easting direction at point (degrees).
+     * @param[out] rk reciprocal of azimuthal northing scale at point.
+     *
+     * \e lat should be in the range [&minus;90&deg;, 90&deg;].  A call to
+     * Forward followed by a call to Reverse will return the original (\e lat,
+     * \e lon) (to within roundoff).  The routine does nothing if the origin
+     * has not been set.
+     **********************************************************************/
+    void Forward(real lat, real lon,
+                 real& x, real& y, real& azi, real& rk) const;
+
+    /**
+     * Reverse projection, from Cassini-Soldner to geographic.
+     *
+     * @param[in] x easting of point (meters).
+     * @param[in] y northing of point (meters).
+     * @param[out] lat latitude of point (degrees).
+     * @param[out] lon longitude of point (degrees).
+     * @param[out] azi azimuth of easting direction at point (degrees).
+     * @param[out] rk reciprocal of azimuthal northing scale at point.
+     *
+     * A call to Reverse followed by a call to Forward will return the original
+     * (\e x, \e y) (to within roundoff), provided that \e x and \e y are
+     * sufficiently small not to "wrap around" the earth.  The routine does
+     * nothing if the origin has not been set.
+     **********************************************************************/
+    void Reverse(real x, real y,
+                 real& lat, real& lon, real& azi, real& rk) const;
+
+    /**
+     * CassiniSoldner::Forward without returning the azimuth and scale.
+     **********************************************************************/
+    void Forward(real lat, real lon,
+                 real& x, real& y) const {
+      real azi, rk;
+      Forward(lat, lon, x, y, azi, rk);
+    }
+
+    /**
+     * CassiniSoldner::Reverse without returning the azimuth and scale.
+     **********************************************************************/
+    void Reverse(real x, real y,
+                 real& lat, real& lon) const {
+      real azi, rk;
+      Reverse(x, y, lat, lon, azi, rk);
+    }
+
+    /** \name Inspector functions
+     **********************************************************************/
+    ///@{
+    /**
+     * @return true if the object has been initialized.
+     **********************************************************************/
+    bool Init() const { return _meridian.Init(); }
+
+    /**
+     * @return \e lat0 the latitude of origin (degrees).
+     **********************************************************************/
+    Math::real LatitudeOrigin() const
+    { return _meridian.Latitude(); }
+
+    /**
+     * @return \e lon0 the longitude of origin (degrees).
+     **********************************************************************/
+    Math::real LongitudeOrigin() const
+    { return _meridian.Longitude(); }
+
+    /**
+     * @return \e a the equatorial radius of the ellipsoid (meters).  This is
+     *   the value inherited from the Geodesic object used in the constructor.
+     **********************************************************************/
+    Math::real MajorRadius() const { return _earth.MajorRadius(); }
+
+    /**
+     * @return \e f the flattening of the ellipsoid.  This is the value
+     *   inherited from the Geodesic object used in the constructor.
+     **********************************************************************/
+    Math::real Flattening() const { return _earth.Flattening(); }
+    ///@}
+
+  };
+
+} // namespace GeographicLib
+
+#endif  // GEOGRAPHICLIB_CASSINISOLDNER_HPP

data/ext/geographiclib/GeographicLib/CircularEngine.hpp

@@ -0,0 +1,195 @@
+/**
+ * \file CircularEngine.hpp
+ * \brief Header for GeographicLib::CircularEngine class
+ *
+ * Copyright (c) Charles Karney (2011-2015) <charles@karney.com> and licensed
+ * under the MIT/X11 License.  For more information, see
+ * http://geographiclib.sourceforge.net/
+ **********************************************************************/
+
+#if !defined(GEOGRAPHICLIB_CIRCULARENGINE_HPP)
+#define GEOGRAPHICLIB_CIRCULARENGINE_HPP 1
+
+#include <vector>
+#include <GeographicLib/Constants.hpp>
+#include <GeographicLib/SphericalEngine.hpp>
+
+#if defined(_MSC_VER)
+// Squelch warnings about dll vs vector
+#  pragma warning (push)
+#  pragma warning (disable: 4251)
+#endif
+
+namespace GeographicLib {
+
+  /**
+   * \brief Spherical harmonic sums for a circle
+   *
+   * The class is a companion to SphericalEngine.  If the results of a
+   * spherical harmonic sum are needed for several points on a circle of
+   * constant latitude \e lat and height \e h, then SphericalEngine::Circle can
+   * compute the inner sum, which is independent of longitude \e lon, and
+   * produce a CircularEngine object.  CircularEngine::operator()() can
+   * then be used to perform the outer sum for particular vales of \e lon.
+   * This can lead to substantial improvements in computational speed for high
+   * degree sum (approximately by a factor of \e N / 2 where \e N is the
+   * maximum degree).
+   *
+   * CircularEngine is tightly linked to the internals of SphericalEngine.  For
+   * that reason, the constructor for this class is private.  Use
+   * SphericalHarmonic::Circle, SphericalHarmonic1::Circle, and
+   * SphericalHarmonic2::Circle to create instances of this class.
+   *
+   * CircularEngine stores the coefficients needed to allow the summation over
+   * order to be performed in 2 or 6 vectors of length \e M + 1 (depending on
+   * whether gradients are to be calculated).  For this reason the constructor
+   * may throw a std::bad_alloc exception.
+   *
+   * Example of use:
+   * \include example-CircularEngine.cpp
+   **********************************************************************/
+
+  class GEOGRAPHICLIB_EXPORT CircularEngine {
+  private:
+    typedef Math::real real;
+    enum normalization {
+      FULL = SphericalEngine::FULL,
+      SCHMIDT = SphericalEngine::SCHMIDT,
+    };
+    int _M;
+    bool _gradp;
+    unsigned _norm;
+    real _a, _r, _u, _t;
+    std::vector<real> _wc, _ws, _wrc, _wrs, _wtc, _wts;
+    real _q, _uq, _uq2;
+
+    Math::real Value(bool gradp, real sl, real cl,
+                     real& gradx, real& grady, real& gradz) const;
+
+    friend class SphericalEngine;
+    CircularEngine(int M, bool gradp, unsigned norm,
+                   real a, real r, real u, real t)
+      : _M(M)
+      , _gradp(gradp)
+      , _norm(norm)
+      , _a(a)
+      , _r(r)
+      , _u(u)
+      , _t(t)
+      , _wc(std::vector<real>(_M + 1, 0))
+      , _ws(std::vector<real>(_M + 1, 0))
+      , _wrc(std::vector<real>(_gradp ? _M + 1 : 0, 0))
+      , _wrs(std::vector<real>(_gradp ? _M + 1 : 0, 0))
+      , _wtc(std::vector<real>(_gradp ? _M + 1 : 0, 0))
+      , _wts(std::vector<real>(_gradp ? _M + 1 : 0, 0))
+      {
+        _q = _a / _r;
+        _uq = _u * _q;
+        _uq2 = Math::sq(_uq);
+      }
+
+    void SetCoeff(int m, real wc, real ws)
+    { _wc[m] = wc; _ws[m] = ws; }
+
+    void SetCoeff(int m, real wc, real ws,
+                  real wrc, real wrs, real wtc, real wts) {
+      _wc[m] = wc; _ws[m] = ws;
+      if (_gradp) {
+        _wrc[m] = wrc; _wrs[m] = wrs;
+        _wtc[m] = wtc; _wts[m] = wts;
+      }
+    }
+
+  public:
+
+    /**
+     * A default constructor.  CircularEngine::operator()() on the resulting
+     * object returns zero.  The resulting object can be assigned to the result
+     * of SphericalHarmonic::Circle.
+     **********************************************************************/
+    CircularEngine()
+      : _M(-1)
+      , _gradp(true)
+      , _u(0)
+      , _t(1)
+      {}
+
+    /**
+     * Evaluate the sum for a particular longitude given in terms of its
+     * sine and cosine.
+     *
+     * @param[in] sinlon the sine of the longitude.
+     * @param[in] coslon the cosine of the longitude.
+     * @return \e V the value of the sum.
+     *
+     * The arguments must satisfy <i>sinlon</i><sup>2</sup> +
+     * <i>coslon</i><sup>2</sup> = 1.
+     **********************************************************************/
+    Math::real operator()(real sinlon, real coslon) const {
+      real dummy;
+      return Value(false, sinlon, coslon, dummy, dummy, dummy);
+    }
+
+    /**
+     * Evaluate the sum for a particular longitude.
+     *
+     * @param[in] lon the longitude (degrees).
+     * @return \e V the value of the sum.
+     **********************************************************************/
+    Math::real operator()(real lon) const {
+      real sinlon, coslon;
+      Math::sincosd(lon, sinlon, coslon);
+      return (*this)(sinlon, coslon);
+    }
+
+    /**
+     * Evaluate the sum and its gradient for a particular longitude given in
+     * terms of its sine and cosine.
+     *
+     * @param[in] sinlon the sine of the longitude.
+     * @param[in] coslon the cosine of the longitude.
+     * @param[out] gradx \e x component of the gradient.
+     * @param[out] grady \e y component of the gradient.
+     * @param[out] gradz \e z component of the gradient.
+     * @return \e V the value of the sum.
+     *
+     * The gradients will only be computed if the CircularEngine object was
+     * created with this capability (e.g., via \e gradp = true in
+     * SphericalHarmonic::Circle).  If not, \e gradx, etc., will not be
+     * touched.  The arguments must satisfy <i>sinlon</i><sup>2</sup> +
+     * <i>coslon</i><sup>2</sup> = 1.
+     **********************************************************************/
+    Math::real operator()(real sinlon, real coslon,
+                          real& gradx, real& grady, real& gradz) const {
+      return Value(true, sinlon, coslon, gradx, grady, gradz);
+    }
+
+    /**
+     * Evaluate the sum and its gradient for a particular longitude.
+     *
+     * @param[in] lon the longitude (degrees).
+     * @param[out] gradx \e x component of the gradient.
+     * @param[out] grady \e y component of the gradient.
+     * @param[out] gradz \e z component of the gradient.
+     * @return \e V the value of the sum.
+     *
+     * The gradients will only be computed if the CircularEngine object was
+     * created with this capability (e.g., via \e gradp = true in
+     * SphericalHarmonic::Circle).  If not, \e gradx, etc., will not be
+     * touched.
+     **********************************************************************/
+    Math::real operator()(real lon,
+                          real& gradx, real& grady, real& gradz) const {
+      real sinlon, coslon;
+      Math::sincosd(lon, sinlon, coslon);
+      return (*this)(sinlon, coslon, gradx, grady, gradz);
+    }
+  };
+
+} // namespace GeographicLib
+
+#if defined(_MSC_VER)
+#  pragma warning (pop)
+#endif
+
+#endif  // GEOGRAPHICLIB_CIRCULARENGINE_HPP