Baoding-FenShuaJiang
/
Green_GoodERP18_FSJ_Standard
Suivre 1
Ajouter aux favoris 0
Wiki 捐赠
gooderp18绿色标准版
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
Aborescence: 0f75e31513
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de '0f75e31513'
${ noResults }
Green_GoodERP18_FSJ_Standard/PostgreSQL/include/geodesic.h

925 lignes
43KB
Brut Annotations Historique 

  1. /**

  2.  * \file geodesic.h

  3.  * \brief API for the geodesic routines in C

  4.  *

  5.  * This an implementation in C of the geodesic algorithms described in

  6.  * - C. F. F. Karney,

  7.  *   <a href="https://doi.org/10.1007/s00190-012-0578-z">

  8.  *   Algorithms for geodesics</a>,

  9.  *   J. Geodesy <b>87</b>, 43--55 (2013);

  10.  *   DOI: <a href="https://doi.org/10.1007/s00190-012-0578-z">

  11.  *   10.1007/s00190-012-0578-z</a>;

  12.  *   addenda: <a href="https://geographiclib.sourceforge.io/geod-addenda.html">

  13.  *   geod-addenda.html</a>.

  14.  * .

  15.  * The principal advantages of these algorithms over previous ones (e.g.,

  16.  * Vincenty, 1975) are

  17.  * - accurate to round off for |<i>f</i>| &lt; 1/50;

  18.  * - the solution of the inverse problem is always found;

  19.  * - differential and integral properties of geodesics are computed.

  20.  *

  21.  * The shortest path between two points on the ellipsoid at (\e lat1, \e

  22.  * lon1) and (\e lat2, \e lon2) is called the geodesic.  Its length is

  23.  * \e s12 and the geodesic from point 1 to point 2 has forward azimuths

  24.  * \e azi1 and \e azi2 at the two end points.

  25.  *

  26.  * Traditionally two geodesic problems are considered:

  27.  * - the direct problem -- given \e lat1, \e lon1, \e s12, and \e azi1,

  28.  *   determine \e lat2, \e lon2, and \e azi2.  This is solved by the function

  29.  *   geod_direct().

  30.  * - the inverse problem -- given \e lat1, \e lon1, and \e lat2, \e lon2,

  31.  *   determine \e s12, \e azi1, and \e azi2.  This is solved by the function

  32.  *   geod_inverse().

  33.  *

  34.  * The ellipsoid is specified by its equatorial radius \e a (typically in

  35.  * meters) and flattening \e f.  The routines are accurate to round off with

  36.  * double precision arithmetic provided that |<i>f</i>| &lt; 1/50; for the

  37.  * WGS84 ellipsoid, the errors are less than 15 nanometers.  (Reasonably

  38.  * accurate results are obtained for |<i>f</i>| &lt; 1/5.)  For a prolate

  39.  * ellipsoid, specify \e f &lt; 0.

  40.  *

  41.  * The routines also calculate several other quantities of interest

  42.  * - \e S12 is the area between the geodesic from point 1 to point 2 and the

  43.  *   equator; i.e., it is the area, measured counter-clockwise, of the

  44.  *   quadrilateral with corners (\e lat1,\e lon1), (0,\e lon1), (0,\e lon2),

  45.  *   and (\e lat2,\e lon2).

  46.  * - \e m12, the reduced length of the geodesic is defined such that if

  47.  *   the initial azimuth is perturbed by \e dazi1 (radians) then the

  48.  *   second point is displaced by \e m12 \e dazi1 in the direction

  49.  *   perpendicular to the geodesic.  On a curved surface the reduced

  50.  *   length obeys a symmetry relation, \e m12 + \e m21 = 0.  On a flat

  51.  *   surface, we have \e m12 = \e s12.

  52.  * - \e M12 and \e M21 are geodesic scales.  If two geodesics are

  53.  *   parallel at point 1 and separated by a small distance \e dt, then

  54.  *   they are separated by a distance \e M12 \e dt at point 2.  \e M21

  55.  *   is defined similarly (with the geodesics being parallel to one

  56.  *   another at point 2).  On a flat surface, we have \e M12 = \e M21

  57.  *   = 1.

  58.  * - \e a12 is the arc length on the auxiliary sphere.  This is a

  59.  *   construct for converting the problem to one in spherical

  60.  *   trigonometry.  \e a12 is measured in degrees.  The spherical arc

  61.  *   length from one equator crossing to the next is always 180&deg;.

  62.  *

  63.  * If points 1, 2, and 3 lie on a single geodesic, then the following

  64.  * addition rules hold:

  65.  * - \e s13 = \e s12 + \e s23

  66.  * - \e a13 = \e a12 + \e a23

  67.  * - \e S13 = \e S12 + \e S23

  68.  * - \e m13 = \e m12 \e M23 + \e m23 \e M21

  69.  * - \e M13 = \e M12 \e M23 &minus; (1 &minus; \e M12 \e M21) \e

  70.  *   m23 / \e m12

  71.  * - \e M31 = \e M32 \e M21 &minus; (1 &minus; \e M23 \e M32) \e

  72.  *   m12 / \e m23

  73.  *

  74.  * The shortest distance returned by the solution of the inverse problem is

  75.  * (obviously) uniquely defined.  However, in a few special cases there are

  76.  * multiple azimuths which yield the same shortest distance.  Here is a

  77.  * catalog of those cases:

  78.  * - \e lat1 = &minus;\e lat2 (with neither point at a pole).  If \e azi1 = \e

  79.  *   azi2, the geodesic is unique.  Otherwise there are two geodesics and the

  80.  *   second one is obtained by setting [\e azi1, \e azi2] &rarr; [\e azi2, \e

  81.  *   azi1], [\e M12, \e M21] &rarr; [\e M21, \e M12], \e S12 &rarr; &minus;\e

  82.  *   S12.  (This occurs when the longitude difference is near &plusmn;180&deg;

  83.  *   for oblate ellipsoids.)

  84.  * - \e lon2 = \e lon1 &plusmn; 180&deg; (with neither point at a pole).  If \e

  85.  *   azi1 = 0&deg; or &plusmn;180&deg;, the geodesic is unique.  Otherwise

  86.  *   there are two geodesics and the second one is obtained by setting [\e

  87.  *   azi1, \e azi2] &rarr; [&minus;\e azi1, &minus;\e azi2], \e S12 &rarr;

  88.  *   &minus;\e S12.  (This occurs when \e lat2 is near &minus;\e lat1 for

  89.  *   prolate ellipsoids.)

  90.  * - Points 1 and 2 at opposite poles.  There are infinitely many geodesics

  91.  *   which can be generated by setting [\e azi1, \e azi2] &rarr; [\e azi1, \e

  92.  *   azi2] + [\e d, &minus;\e d], for arbitrary \e d.  (For spheres, this

  93.  *   prescription applies when points 1 and 2 are antipodal.)

  94.  * - \e s12 = 0 (coincident points).  There are infinitely many geodesics which

  95.  *   can be generated by setting [\e azi1, \e azi2] &rarr; [\e azi1, \e azi2] +

  96.  *   [\e d, \e d], for arbitrary \e d.

  97.  *

  98.  * These routines are a simple transcription of the corresponding C++ classes

  99.  * in <a href="https://geographiclib.sourceforge.io"> GeographicLib</a>.  The

  100.  * "class data" is represented by the structs geod_geodesic, geod_geodesicline,

  101.  * geod_polygon and pointers to these objects are passed as initial arguments

  102.  * to the member functions.  Most of the internal comments have been retained.

  103.  * However, in the process of transcription some documentation has been lost

  104.  * and the documentation for the C++ classes, GeographicLib::Geodesic,

  105.  * GeographicLib::GeodesicLine, and GeographicLib::PolygonAreaT, should be

  106.  * consulted.  The C++ code remains the "reference implementation".  Think

  107.  * twice about restructuring the internals of the C code since this may make

  108.  * porting fixes from the C++ code more difficult.

  109.  *

  110.  * Copyright (c) Charles Karney (2012-2018) <charles@karney.com> and licensed

  111.  * under the MIT/X11 License.  For more information, see

  112.  * https://geographiclib.sourceforge.io/

  113.  *

  114.  * This library was distributed with

  115.  * <a href="../index.html">GeographicLib</a> 1.49.

  116.  **********************************************************************/

  117. 

  118. #if !defined(GEODESIC_H)

  119. #define GEODESIC_H 1

  120. 

  121. /**

  122.  * The major version of the geodesic library.  (This tracks the version of

  123.  * GeographicLib.)

  124.  **********************************************************************/

  125. #define GEODESIC_VERSION_MAJOR 1

  126. /**

  127.  * The minor version of the geodesic library.  (This tracks the version of

  128.  * GeographicLib.)

  129.  **********************************************************************/

  130. #define GEODESIC_VERSION_MINOR 49

  131. /**

  132.  * The patch level of the geodesic library.  (This tracks the version of

  133.  * GeographicLib.)

  134.  **********************************************************************/

  135. #define GEODESIC_VERSION_PATCH 3

  136. 

  137. /**

  138.  * Pack the version components into a single integer.  Users should not rely on

  139.  * this particular packing of the components of the version number; see the

  140.  * documentation for GEODESIC_VERSION, below.

  141.  **********************************************************************/

  142. #define GEODESIC_VERSION_NUM(a,b,c) ((((a) * 10000 + (b)) * 100) + (c))

  143. 

  144. /**

  145.  * The version of the geodesic library as a single integer, packed as MMmmmmpp

  146.  * where MM is the major version, mmmm is the minor version, and pp is the

  147.  * patch level.  Users should not rely on this particular packing of the

  148.  * components of the version number.  Instead they should use a test such as

  149.  * @code{.c}

  150.    #if GEODESIC_VERSION >= GEODESIC_VERSION_NUM(1,40,0)

  151.    ...

  152.    #endif

  153.  * @endcode

  154.  **********************************************************************/

  155. #define GEODESIC_VERSION \

  156.  GEODESIC_VERSION_NUM(GEODESIC_VERSION_MAJOR, \

  157.                       GEODESIC_VERSION_MINOR, \

  158.                       GEODESIC_VERSION_PATCH)

  159. 

  160. #ifndef GEOD_DLL

  161. #if defined(_MSC_VER)

  162. #define GEOD_DLL __declspec(dllexport)

  163. #elif defined(__GNUC__)

  164. #define GEOD_DLL __attribute__ ((visibility("default")))

  165. #else

  166. #define GEOD_DLL

  167. #endif

  168. #endif

  169. 

  170. #ifdef PROJ_RENAME_SYMBOLS

  171. #include "proj_symbol_rename.h"

  172. #endif

  173. 

  174. #if defined(__cplusplus)

  175. extern "C" {

  176. #endif

  177. 

  178.   /**

  179.    * The struct containing information about the ellipsoid.  This must be

  180.    * initialized by geod_init() before use.

  181.    **********************************************************************/

  182.   struct geod_geodesic {

  183.     double a;                   /**< the equatorial radius */

  184.     double f;                   /**< the flattening */

  185.     /**< @cond SKIP */

  186.     double f1, e2, ep2, n, b, c2, etol2;

  187.     double A3x[6], C3x[15], C4x[21];

  188.     /**< @endcond */

  189.   };

  190. 

  191.   /**

  192.    * The struct containing information about a single geodesic.  This must be

  193.    * initialized by geod_lineinit(), geod_directline(), geod_gendirectline(),

  194.    * or geod_inverseline() before use.

  195.    **********************************************************************/

  196.   struct geod_geodesicline {

  197.     double lat1;                /**< the starting latitude */

  198.     double lon1;                /**< the starting longitude */

  199.     double azi1;                /**< the starting azimuth */

  200.     double a;                   /**< the equatorial radius */

  201.     double f;                   /**< the flattening */

  202.     double salp1;               /**< sine of \e azi1 */

  203.     double calp1;               /**< cosine of \e azi1 */

  204.     double a13;                 /**< arc length to reference point */

  205.     double s13;                 /**< distance to reference point */

  206.     /**< @cond SKIP */

  207.     double b, c2, f1, salp0, calp0, k2,

  208.       ssig1, csig1, dn1, stau1, ctau1, somg1, comg1,

  209.       A1m1, A2m1, A3c, B11, B21, B31, A4, B41;

  210.     double C1a[6+1], C1pa[6+1], C2a[6+1], C3a[6], C4a[6];

  211.     /**< @endcond */

  212.     unsigned caps;              /**< the capabilities */

  213.   };

  214. 

  215.   /**

  216.    * The struct for accumulating information about a geodesic polygon.  This is

  217.    * used for computing the perimeter and area of a polygon.  This must be

  218.    * initialized by geod_polygon_init() before use.

  219.    **********************************************************************/

  220.   struct geod_polygon {

  221.     double lat;                 /**< the current latitude */

  222.     double lon;                 /**< the current longitude */

  223.     /**< @cond SKIP */

  224.     double lat0;

  225.     double lon0;

  226.     double A[2];

  227.     double P[2];

  228.     int polyline;

  229.     int crossings;

  230.     /**< @endcond */

  231.     unsigned num;               /**< the number of points so far */

  232.   };

  233. 

  234.   /**

  235.    * Initialize a geod_geodesic object.

  236.    *

  237.    * @param[out] g a pointer to the object to be initialized.

  238.    * @param[in] a the equatorial radius (meters).

  239.    * @param[in] f the flattening.

  240.    **********************************************************************/

  241.   void GEOD_DLL geod_init(struct geod_geodesic* g, double a, double f);

  242. 

  243.   /**

  244.    * Solve the direct geodesic problem.

  245.    *

  246.    * @param[in] g a pointer to the geod_geodesic object specifying the

  247.    *   ellipsoid.

  248.    * @param[in] lat1 latitude of point 1 (degrees).

  249.    * @param[in] lon1 longitude of point 1 (degrees).

  250.    * @param[in] azi1 azimuth at point 1 (degrees).

  251.    * @param[in] s12 distance from point 1 to point 2 (meters); it can be

  252.    *   negative.

  253.    * @param[out] plat2 pointer to the latitude of point 2 (degrees).

  254.    * @param[out] plon2 pointer to the longitude of point 2 (degrees).

  255.    * @param[out] pazi2 pointer to the (forward) azimuth at point 2 (degrees).

  256.    *

  257.    * \e g must have been initialized with a call to geod_init().  \e lat1

  258.    * should be in the range [&minus;90&deg;, 90&deg;].  The values of \e lon2

  259.    * and \e azi2 returned are in the range [&minus;180&deg;, 180&deg;].  Any of

  260.    * the "return" arguments \e plat2, etc., may be replaced by 0, if you do not

  261.    * need some quantities computed.

  262.    *

  263.    * If either point is at a pole, the azimuth is defined by keeping the

  264.    * longitude fixed, writing \e lat = &plusmn;(90&deg; &minus; &epsilon;), and

  265.    * taking the limit &epsilon; &rarr; 0+.  An arc length greater that 180&deg;

  266.    * signifies a geodesic which is not a shortest path.  (For a prolate

  267.    * ellipsoid, an additional condition is necessary for a shortest path: the

  268.    * longitudinal extent must not exceed of 180&deg;.)

  269.    *

  270.    * Example, determine the point 10000 km NE of JFK:

  271.    @code{.c}

  272.    struct geod_geodesic g;

  273.    double lat, lon;

  274.    geod_init(&g, 6378137, 1/298.257223563);

  275.    geod_direct(&g, 40.64, -73.78, 45.0, 10e6, &lat, &lon, 0);

  276.    printf("%.5f %.5f\n", lat, lon);

  277.    @endcode

  278.    **********************************************************************/

  279.   void GEOD_DLL geod_direct(const struct geod_geodesic* g,

  280.                    double lat1, double lon1, double azi1, double s12,

  281.                    double* plat2, double* plon2, double* pazi2);

  282. 

  283.   /**

  284.    * The general direct geodesic problem.

  285.    *

  286.    * @param[in] g a pointer to the geod_geodesic object specifying the

  287.    *   ellipsoid.

  288.    * @param[in] lat1 latitude of point 1 (degrees).

  289.    * @param[in] lon1 longitude of point 1 (degrees).

  290.    * @param[in] azi1 azimuth at point 1 (degrees).

  291.    * @param[in] flags bitor'ed combination of geod_flags(); \e flags &

  292.    *   GEOD_ARCMODE determines the meaning of \e s12_a12 and \e flags &

  293.    *   GEOD_LONG_UNROLL "unrolls" \e lon2.

  294.    * @param[in] s12_a12 if \e flags & GEOD_ARCMODE is 0, this is the distance

  295.    *   from point 1 to point 2 (meters); otherwise it is the arc length

  296.    *   from point 1 to point 2 (degrees); it can be negative.

  297.    * @param[out] plat2 pointer to the latitude of point 2 (degrees).

  298.    * @param[out] plon2 pointer to the longitude of point 2 (degrees).

  299.    * @param[out] pazi2 pointer to the (forward) azimuth at point 2 (degrees).

  300.    * @param[out] ps12 pointer to the distance from point 1 to point 2

  301.    *   (meters).

  302.    * @param[out] pm12 pointer to the reduced length of geodesic (meters).

  303.    * @param[out] pM12 pointer to the geodesic scale of point 2 relative to

  304.    *   point 1 (dimensionless).

  305.    * @param[out] pM21 pointer to the geodesic scale of point 1 relative to

  306.    *   point 2 (dimensionless).

  307.    * @param[out] pS12 pointer to the area under the geodesic

  308.    *   (meters<sup>2</sup>).

  309.    * @return \e a12 arc length from point 1 to point 2 (degrees).

  310.    *

  311.    * \e g must have been initialized with a call to geod_init().  \e lat1

  312.    * should be in the range [&minus;90&deg;, 90&deg;].  The function value \e

  313.    * a12 equals \e s12_a12 if \e flags & GEOD_ARCMODE.  Any of the "return"

  314.    * arguments, \e plat2, etc., may be replaced by 0, if you do not need some

  315.    * quantities computed.

  316.    *

  317.    * With \e flags & GEOD_LONG_UNROLL bit set, the longitude is "unrolled" so

  318.    * that the quantity \e lon2 &minus; \e lon1 indicates how many times and in

  319.    * what sense the geodesic encircles the ellipsoid.

  320.    **********************************************************************/

  321.   double GEOD_DLL geod_gendirect(const struct geod_geodesic* g,

  322.                         double lat1, double lon1, double azi1,

  323.                         unsigned flags, double s12_a12,

  324.                         double* plat2, double* plon2, double* pazi2,

  325.                         double* ps12, double* pm12, double* pM12, double* pM21,

  326.                         double* pS12);

  327. 

  328.   /**

  329.    * Solve the inverse geodesic problem.

  330.    *

  331.    * @param[in] g a pointer to the geod_geodesic object specifying the

  332.    *   ellipsoid.

  333.    * @param[in] lat1 latitude of point 1 (degrees).

  334.    * @param[in] lon1 longitude of point 1 (degrees).

  335.    * @param[in] lat2 latitude of point 2 (degrees).

  336.    * @param[in] lon2 longitude of point 2 (degrees).

  337.    * @param[out] ps12 pointer to the distance from point 1 to point 2

  338.    *   (meters).

  339.    * @param[out] pazi1 pointer to the azimuth at point 1 (degrees).

  340.    * @param[out] pazi2 pointer to the (forward) azimuth at point 2 (degrees).

  341.    *

  342.    * \e g must have been initialized with a call to geod_init().  \e lat1 and

  343.    * \e lat2 should be in the range [&minus;90&deg;, 90&deg;].  The values of

  344.    * \e azi1 and \e azi2 returned are in the range [&minus;180&deg;, 180&deg;].

  345.    * Any of the "return" arguments, \e ps12, etc., may be replaced by 0, if you

  346.    * do not need some quantities computed.

  347.    *

  348.    * If either point is at a pole, the azimuth is defined by keeping the

  349.    * longitude fixed, writing \e lat = &plusmn;(90&deg; &minus; &epsilon;), and

  350.    * taking the limit &epsilon; &rarr; 0+.

  351.    *

  352.    * The solution to the inverse problem is found using Newton's method.  If

  353.    * this fails to converge (this is very unlikely in geodetic applications

  354.    * but does occur for very eccentric ellipsoids), then the bisection method

  355.    * is used to refine the solution.

  356.    *

  357.    * Example, determine the distance between JFK and Singapore Changi Airport:

  358.    @code{.c}

  359.    struct geod_geodesic g;

  360.    double s12;

  361.    geod_init(&g, 6378137, 1/298.257223563);

  362.    geod_inverse(&g, 40.64, -73.78, 1.36, 103.99, &s12, 0, 0);

  363.    printf("%.3f\n", s12);

  364.    @endcode

  365.    **********************************************************************/

  366.   void GEOD_DLL geod_inverse(const struct geod_geodesic* g,

  367.                     double lat1, double lon1, double lat2, double lon2,

  368.                     double* ps12, double* pazi1, double* pazi2);

  369. 

  370.   /**

  371.    * The general inverse geodesic calculation.

  372.    *

  373.    * @param[in] g a pointer to the geod_geodesic object specifying the

  374.    *   ellipsoid.

  375.    * @param[in] lat1 latitude of point 1 (degrees).

  376.    * @param[in] lon1 longitude of point 1 (degrees).

  377.    * @param[in] lat2 latitude of point 2 (degrees).

  378.    * @param[in] lon2 longitude of point 2 (degrees).

  379.    * @param[out] ps12 pointer to the distance from point 1 to point 2

  380.    *  (meters).

  381.    * @param[out] pazi1 pointer to the azimuth at point 1 (degrees).

  382.    * @param[out] pazi2 pointer to the (forward) azimuth at point 2 (degrees).

  383.    * @param[out] pm12 pointer to the reduced length of geodesic (meters).

  384.    * @param[out] pM12 pointer to the geodesic scale of point 2 relative to

  385.    *   point 1 (dimensionless).

  386.    * @param[out] pM21 pointer to the geodesic scale of point 1 relative to

  387.    *   point 2 (dimensionless).

  388.    * @param[out] pS12 pointer to the area under the geodesic

  389.    *   (meters<sup>2</sup>).

  390.    * @return \e a12 arc length from point 1 to point 2 (degrees).

  391.    *

  392.    * \e g must have been initialized with a call to geod_init().  \e lat1 and

  393.    * \e lat2 should be in the range [&minus;90&deg;, 90&deg;].  Any of the

  394.    * "return" arguments \e ps12, etc., may be replaced by 0, if you do not need

  395.    * some quantities computed.

  396.    **********************************************************************/

  397.   double GEOD_DLL geod_geninverse(const struct geod_geodesic* g,

  398.                          double lat1, double lon1, double lat2, double lon2,

  399.                          double* ps12, double* pazi1, double* pazi2,

  400.                          double* pm12, double* pM12, double* pM21,

  401.                          double* pS12);

  402. 

  403.   /**

  404.    * Initialize a geod_geodesicline object.

  405.    *

  406.    * @param[out] l a pointer to the object to be initialized.

  407.    * @param[in] g a pointer to the geod_geodesic object specifying the

  408.    *   ellipsoid.

  409.    * @param[in] lat1 latitude of point 1 (degrees).

  410.    * @param[in] lon1 longitude of point 1 (degrees).

  411.    * @param[in] azi1 azimuth at point 1 (degrees).

  412.    * @param[in] caps bitor'ed combination of geod_mask() values specifying the

  413.    *   capabilities the geod_geodesicline object should possess, i.e., which

  414.    *   quantities can be returned in calls to geod_position() and

  415.    *   geod_genposition().

  416.    *

  417.    * \e g must have been initialized with a call to geod_init().  \e lat1

  418.    * should be in the range [&minus;90&deg;, 90&deg;].

  419.    *

  420.    * The geod_mask values are [see geod_mask()]:

  421.    * - \e caps |= GEOD_LATITUDE for the latitude \e lat2; this is

  422.    *   added automatically,

  423.    * - \e caps |= GEOD_LONGITUDE for the latitude \e lon2,

  424.    * - \e caps |= GEOD_AZIMUTH for the latitude \e azi2; this is

  425.    *   added automatically,

  426.    * - \e caps |= GEOD_DISTANCE for the distance \e s12,

  427.    * - \e caps |= GEOD_REDUCEDLENGTH for the reduced length \e m12,

  428.    * - \e caps |= GEOD_GEODESICSCALE for the geodesic scales \e M12

  429.    *   and \e M21,

  430.    * - \e caps |= GEOD_AREA for the area \e S12,

  431.    * - \e caps |= GEOD_DISTANCE_IN permits the length of the

  432.    *   geodesic to be given in terms of \e s12; without this capability the

  433.    *   length can only be specified in terms of arc length.

  434.    * .

  435.    * A value of \e caps = 0 is treated as GEOD_LATITUDE | GEOD_LONGITUDE |

  436.    * GEOD_AZIMUTH | GEOD_DISTANCE_IN (to support the solution of the "standard"

  437.    * direct problem).

  438.    *

  439.    * When initialized by this function, point 3 is undefined (l->s13 = l->a13 =

  440.    * NaN).

  441.    **********************************************************************/

  442.   void GEOD_DLL geod_lineinit(struct geod_geodesicline* l,

  443.                      const struct geod_geodesic* g,

  444.                      double lat1, double lon1, double azi1, unsigned caps);

  445. 

  446.   /**

  447.    * Initialize a geod_geodesicline object in terms of the direct geodesic

  448.    * problem.

  449.    *

  450.    * @param[out] l a pointer to the object to be initialized.

  451.    * @param[in] g a pointer to the geod_geodesic object specifying the

  452.    *   ellipsoid.

  453.    * @param[in] lat1 latitude of point 1 (degrees).

  454.    * @param[in] lon1 longitude of point 1 (degrees).

  455.    * @param[in] azi1 azimuth at point 1 (degrees).

  456.    * @param[in] s12 distance from point 1 to point 2 (meters); it can be

  457.    *   negative.

  458.    * @param[in] caps bitor'ed combination of geod_mask() values specifying the

  459.    *   capabilities the geod_geodesicline object should possess, i.e., which

  460.    *   quantities can be returned in calls to geod_position() and

  461.    *   geod_genposition().

  462.    *

  463.    * This function sets point 3 of the geod_geodesicline to correspond to point

  464.    * 2 of the direct geodesic problem.  See geod_lineinit() for more

  465.    * information.

  466.    **********************************************************************/

  467.   void GEOD_DLL geod_directline(struct geod_geodesicline* l,

  468.                        const struct geod_geodesic* g,

  469.                        double lat1, double lon1, double azi1, double s12,

  470.                        unsigned caps);

  471. 

  472.   /**

  473.    * Initialize a geod_geodesicline object in terms of the direct geodesic

  474.    * problem spacified in terms of either distance or arc length.

  475.    *

  476.    * @param[out] l a pointer to the object to be initialized.

  477.    * @param[in] g a pointer to the geod_geodesic object specifying the

  478.    *   ellipsoid.

  479.    * @param[in] lat1 latitude of point 1 (degrees).

  480.    * @param[in] lon1 longitude of point 1 (degrees).

  481.    * @param[in] azi1 azimuth at point 1 (degrees).

  482.    * @param[in] flags either GEOD_NOFLAGS or GEOD_ARCMODE to determining the

  483.    *   meaning of the \e s12_a12.

  484.    * @param[in] s12_a12 if \e flags = GEOD_NOFLAGS, this is the distance

  485.    *   from point 1 to point 2 (meters); if \e flags = GEOD_ARCMODE, it is

  486.    *   the arc length from point 1 to point 2 (degrees); it can be

  487.    *   negative.

  488.    * @param[in] caps bitor'ed combination of geod_mask() values specifying the

  489.    *   capabilities the geod_geodesicline object should possess, i.e., which

  490.    *   quantities can be returned in calls to geod_position() and

  491.    *   geod_genposition().

  492.    *

  493.    * This function sets point 3 of the geod_geodesicline to correspond to point

  494.    * 2 of the direct geodesic problem.  See geod_lineinit() for more

  495.    * information.

  496.    **********************************************************************/

  497.   void GEOD_DLL geod_gendirectline(struct geod_geodesicline* l,

  498.                           const struct geod_geodesic* g,

  499.                           double lat1, double lon1, double azi1,

  500.                           unsigned flags, double s12_a12,

  501.                           unsigned caps);

  502. 

  503.   /**

  504.    * Initialize a geod_geodesicline object in terms of the inverse geodesic

  505.    * problem.

  506.    *

  507.    * @param[out] l a pointer to the object to be initialized.

  508.    * @param[in] g a pointer to the geod_geodesic object specifying the

  509.    *   ellipsoid.

  510.    * @param[in] lat1 latitude of point 1 (degrees).

  511.    * @param[in] lon1 longitude of point 1 (degrees).

  512.    * @param[in] lat2 latitude of point 2 (degrees).

  513.    * @param[in] lon2 longitude of point 2 (degrees).

  514.    * @param[in] caps bitor'ed combination of geod_mask() values specifying the

  515.    *   capabilities the geod_geodesicline object should possess, i.e., which

  516.    *   quantities can be returned in calls to geod_position() and

  517.    *   geod_genposition().

  518.    *

  519.    * This function sets point 3 of the geod_geodesicline to correspond to point

  520.    * 2 of the inverse geodesic problem.  See geod_lineinit() for more

  521.    * information.

  522.    **********************************************************************/

  523.   void GEOD_DLL geod_inverseline(struct geod_geodesicline* l,

  524.                        const struct geod_geodesic* g,

  525.                        double lat1, double lon1, double lat2, double lon2,

  526.                        unsigned caps);

  527. 

  528.   /**

  529.    * Compute the position along a geod_geodesicline.

  530.    *

  531.    * @param[in] l a pointer to the geod_geodesicline object specifying the

  532.    *   geodesic line.

  533.    * @param[in] s12 distance from point 1 to point 2 (meters); it can be

  534.    *   negative.

  535.    * @param[out] plat2 pointer to the latitude of point 2 (degrees).

  536.    * @param[out] plon2 pointer to the longitude of point 2 (degrees); requires

  537.    *   that \e l was initialized with \e caps |= GEOD_LONGITUDE.

  538.    * @param[out] pazi2 pointer to the (forward) azimuth at point 2 (degrees).

  539.    *

  540.    * \e l must have been initialized with a call, e.g., to geod_lineinit(),

  541.    * with \e caps |= GEOD_DISTANCE_IN.  The values of \e lon2 and \e azi2

  542.    * returned are in the range [&minus;180&deg;, 180&deg;].  Any of the

  543.    * "return" arguments \e plat2, etc., may be replaced by 0, if you do not

  544.    * need some quantities computed.

  545.    *

  546.    * Example, compute way points between JFK and Singapore Changi Airport

  547.    * the "obvious" way using geod_direct():

  548.    @code{.c}

  549.    struct geod_geodesic g;

  550.    double s12, azi1, lat[101],lon[101];

  551.    int i;

  552.    geod_init(&g, 6378137, 1/298.257223563);

  553.    geod_inverse(&g, 40.64, -73.78, 1.36, 103.99, &s12, &azi1, 0);

  554.    for (i = 0; i < 101; ++i) {

  555.      geod_direct(&g, 40.64, -73.78, azi1, i * s12 * 0.01, lat + i, lon + i, 0);

  556.      printf("%.5f %.5f\n", lat[i], lon[i]);

  557.    }

  558.    @endcode

  559.    * A faster way using geod_position():

  560.    @code{.c}

  561.    struct geod_geodesic g;

  562.    struct geod_geodesicline l;

  563.    double lat[101],lon[101];

  564.    int i;

  565.    geod_init(&g, 6378137, 1/298.257223563);

  566.    geod_inverseline(&l, &g, 40.64, -73.78, 1.36, 103.99, 0);

  567.    for (i = 0; i <= 100; ++i) {

  568.      geod_position(&l, i * l.s13 * 0.01, lat + i, lon + i, 0);

  569.      printf("%.5f %.5f\n", lat[i], lon[i]);

  570.    }

  571.    @endcode

  572.    **********************************************************************/

  573.   void GEOD_DLL geod_position(const struct geod_geodesicline* l, double s12,

  574.                      double* plat2, double* plon2, double* pazi2);

  575. 

  576.   /**

  577.    * The general position function.

  578.    *

  579.    * @param[in] l a pointer to the geod_geodesicline object specifying the

  580.    *   geodesic line.

  581.    * @param[in] flags bitor'ed combination of geod_flags(); \e flags &

  582.    *   GEOD_ARCMODE determines the meaning of \e s12_a12 and \e flags &

  583.    *   GEOD_LONG_UNROLL "unrolls" \e lon2; if \e flags & GEOD_ARCMODE is 0,

  584.    *   then \e l must have been initialized with \e caps |= GEOD_DISTANCE_IN.

  585.    * @param[in] s12_a12 if \e flags & GEOD_ARCMODE is 0, this is the

  586.    *   distance from point 1 to point 2 (meters); otherwise it is the

  587.    *   arc length from point 1 to point 2 (degrees); it can be

  588.    *   negative.

  589.    * @param[out] plat2 pointer to the latitude of point 2 (degrees).

  590.    * @param[out] plon2 pointer to the longitude of point 2 (degrees); requires

  591.    *   that \e l was initialized with \e caps |= GEOD_LONGITUDE.

  592.    * @param[out] pazi2 pointer to the (forward) azimuth at point 2 (degrees).

  593.    * @param[out] ps12 pointer to the distance from point 1 to point 2

  594.    *   (meters); requires that \e l was initialized with \e caps |=

  595.    *   GEOD_DISTANCE.

  596.    * @param[out] pm12 pointer to the reduced length of geodesic (meters);

  597.    *   requires that \e l was initialized with \e caps |= GEOD_REDUCEDLENGTH.

  598.    * @param[out] pM12 pointer to the geodesic scale of point 2 relative to

  599.    *   point 1 (dimensionless); requires that \e l was initialized with \e caps

  600.    *   |= GEOD_GEODESICSCALE.

  601.    * @param[out] pM21 pointer to the geodesic scale of point 1 relative to

  602.    *   point 2 (dimensionless); requires that \e l was initialized with \e caps

  603.    *   |= GEOD_GEODESICSCALE.

  604.    * @param[out] pS12 pointer to the area under the geodesic

  605.    *   (meters<sup>2</sup>); requires that \e l was initialized with \e caps |=

  606.    *   GEOD_AREA.

  607.    * @return \e a12 arc length from point 1 to point 2 (degrees).

  608.    *

  609.    * \e l must have been initialized with a call to geod_lineinit() with \e

  610.    * caps |= GEOD_DISTANCE_IN.  The value \e azi2 returned is in the range

  611.    * [&minus;180&deg;, 180&deg;].  Any of the "return" arguments \e plat2,

  612.    * etc., may be replaced by 0, if you do not need some quantities

  613.    * computed.  Requesting a value which \e l is not capable of computing

  614.    * is not an error; the corresponding argument will not be altered.

  615.    *

  616.    * With \e flags & GEOD_LONG_UNROLL bit set, the longitude is "unrolled" so

  617.    * that the quantity \e lon2 &minus; \e lon1 indicates how many times and in

  618.    * what sense the geodesic encircles the ellipsoid.

  619.    *

  620.    * Example, compute way points between JFK and Singapore Changi Airport using

  621.    * geod_genposition().  In this example, the points are evenly space in arc

  622.    * length (and so only approximately equally spaced in distance).  This is

  623.    * faster than using geod_position() and would be appropriate if drawing the

  624.    * path on a map.

  625.    @code{.c}

  626.    struct geod_geodesic g;

  627.    struct geod_geodesicline l;

  628.    double lat[101], lon[101];

  629.    int i;

  630.    geod_init(&g, 6378137, 1/298.257223563);

  631.    geod_inverseline(&l, &g, 40.64, -73.78, 1.36, 103.99,

  632.                     GEOD_LATITUDE | GEOD_LONGITUDE);

  633.    for (i = 0; i <= 100; ++i) {

  634.      geod_genposition(&l, GEOD_ARCMODE, i * l.a13 * 0.01,

  635.                       lat + i, lon + i, 0, 0, 0, 0, 0, 0);

  636.      printf("%.5f %.5f\n", lat[i], lon[i]);

  637.    }

  638.    @endcode

  639.    **********************************************************************/

  640.   double GEOD_DLL geod_genposition(const struct geod_geodesicline* l,

  641.                           unsigned flags, double s12_a12,

  642.                           double* plat2, double* plon2, double* pazi2,

  643.                           double* ps12, double* pm12,

  644.                           double* pM12, double* pM21,

  645.                           double* pS12);

  646. 

  647.   /**

  648.    * Specify position of point 3 in terms of distance.

  649.    *

  650.    * @param[in,out] l a pointer to the geod_geodesicline object.

  651.    * @param[in] s13 the distance from point 1 to point 3 (meters); it

  652.    *   can be negative.

  653.    *

  654.    * This is only useful if the geod_geodesicline object has been constructed

  655.    * with \e caps |= GEOD_DISTANCE_IN.

  656.    **********************************************************************/

  657.   void GEOD_DLL geod_setdistance(struct geod_geodesicline* l, double s13);

  658. 

  659.   /**

  660.    * Specify position of point 3 in terms of either distance or arc length.

  661.    *

  662.    * @param[in,out] l a pointer to the geod_geodesicline object.

  663.    * @param[in] flags either GEOD_NOFLAGS or GEOD_ARCMODE to determining the

  664.    *   meaning of the \e s13_a13.

  665.    * @param[in] s13_a13 if \e flags = GEOD_NOFLAGS, this is the distance

  666.    *   from point 1 to point 3 (meters); if \e flags = GEOD_ARCMODE, it is

  667.    *   the arc length from point 1 to point 3 (degrees); it can be

  668.    *   negative.

  669.    *

  670.    * If flags = GEOD_NOFLAGS, this calls geod_setdistance().  If flags =

  671.    * GEOD_ARCMODE, the \e s13 is only set if the geod_geodesicline object has

  672.    * been constructed with \e caps |= GEOD_DISTANCE.

  673.    **********************************************************************/

  674.   void GEOD_DLL geod_gensetdistance(struct geod_geodesicline* l,

  675.                            unsigned flags, double s13_a13);

  676. 

  677.   /**

  678.    * Initialize a geod_polygon object.

  679.    *

  680.    * @param[out] p a pointer to the object to be initialized.

  681.    * @param[in] polylinep non-zero if a polyline instead of a polygon.

  682.    *

  683.    * If \e polylinep is zero, then the sequence of vertices and edges added by

  684.    * geod_polygon_addpoint() and geod_polygon_addedge() define a polygon and

  685.    * the perimeter and area are returned by geod_polygon_compute().  If \e

  686.    * polylinep is non-zero, then the vertices and edges define a polyline and

  687.    * only the perimeter is returned by geod_polygon_compute().

  688.    *

  689.    * The area and perimeter are accumulated at two times the standard floating

  690.    * point precision to guard against the loss of accuracy with many-sided

  691.    * polygons.  At any point you can ask for the perimeter and area so far.

  692.    *

  693.    * An example of the use of this function is given in the documentation for

  694.    * geod_polygon_compute().

  695.    **********************************************************************/

  696.   void GEOD_DLL geod_polygon_init(struct geod_polygon* p, int polylinep);

  697. 

  698.   /**

  699.    * Clear the polygon, allowing a new polygon to be started.

  700.    *

  701.    * @param[in,out] p a pointer to the object to be cleared.

  702.    **********************************************************************/

  703.   void GEOD_DLL geod_polygon_clear(struct geod_polygon* p);

  704. 

  705.   /**

  706.    * Add a point to the polygon or polyline.

  707.    *

  708.    * @param[in] g a pointer to the geod_geodesic object specifying the

  709.    *   ellipsoid.

  710.    * @param[in,out] p a pointer to the geod_polygon object specifying the

  711.    *   polygon.

  712.    * @param[in] lat the latitude of the point (degrees).

  713.    * @param[in] lon the longitude of the point (degrees).

  714.    *

  715.    * \e g and \e p must have been initialized with calls to geod_init() and

  716.    * geod_polygon_init(), respectively.  The same \e g must be used for all the

  717.    * points and edges in a polygon.  \e lat should be in the range

  718.    * [&minus;90&deg;, 90&deg;].

  719.    *

  720.    * An example of the use of this function is given in the documentation for

  721.    * geod_polygon_compute().

  722.    **********************************************************************/

  723.   void GEOD_DLL geod_polygon_addpoint(const struct geod_geodesic* g,

  724.                              struct geod_polygon* p,

  725.                              double lat, double lon);

  726. 

  727.   /**

  728.    * Add an edge to the polygon or polyline.

  729.    *

  730.    * @param[in] g a pointer to the geod_geodesic object specifying the

  731.    *   ellipsoid.

  732.    * @param[in,out] p a pointer to the geod_polygon object specifying the

  733.    *   polygon.

  734.    * @param[in] azi azimuth at current point (degrees).

  735.    * @param[in] s distance from current point to next point (meters).

  736.    *

  737.    * \e g and \e p must have been initialized with calls to geod_init() and

  738.    * geod_polygon_init(), respectively.  The same \e g must be used for all the

  739.    * points and edges in a polygon.  This does nothing if no points have been

  740.    * added yet.  The \e lat and \e lon fields of \e p give the location of the

  741.    * new vertex.

  742.    **********************************************************************/

  743.   void GEOD_DLL geod_polygon_addedge(const struct geod_geodesic* g,

  744.                             struct geod_polygon* p,

  745.                             double azi, double s);

  746. 

  747.   /**

  748.    * Return the results for a polygon.

  749.    *

  750.    * @param[in] g a pointer to the geod_geodesic object specifying the

  751.    *   ellipsoid.

  752.    * @param[in] p a pointer to the geod_polygon object specifying the polygon.

  753.    * @param[in] reverse if non-zero then clockwise (instead of

  754.    *   counter-clockwise) traversal counts as a positive area.

  755.    * @param[in] sign if non-zero then return a signed result for the area if

  756.    *   the polygon is traversed in the "wrong" direction instead of returning

  757.    *   the area for the rest of the earth.

  758.    * @param[out] pA pointer to the area of the polygon (meters<sup>2</sup>);

  759.    *   only set if \e polyline is non-zero in the call to geod_polygon_init().

  760.    * @param[out] pP pointer to the perimeter of the polygon or length of the

  761.    *   polyline (meters).

  762.    * @return the number of points.

  763.    *

  764.    * The area and perimeter are accumulated at two times the standard floating

  765.    * point precision to guard against the loss of accuracy with many-sided

  766.    * polygons.  Only simple polygons (which are not self-intersecting) are

  767.    * allowed.  There's no need to "close" the polygon by repeating the first

  768.    * vertex.  Set \e pA or \e pP to zero, if you do not want the corresponding

  769.    * quantity returned.

  770.    *

  771.    * More points can be added to the polygon after this call.

  772.    *

  773.    * Example, compute the perimeter and area of the geodesic triangle with

  774.    * vertices (0&deg;N,0&deg;E), (0&deg;N,90&deg;E), (90&deg;N,0&deg;E).

  775.    @code{.c}

  776.    double A, P;

  777.    int n;

  778.    struct geod_geodesic g;

  779.    struct geod_polygon p;

  780.    geod_init(&g, 6378137, 1/298.257223563);

  781.    geod_polygon_init(&p, 0);

  782. 

  783.    geod_polygon_addpoint(&g, &p,  0,  0);

  784.    geod_polygon_addpoint(&g, &p,  0, 90);

  785.    geod_polygon_addpoint(&g, &p, 90,  0);

  786.    n = geod_polygon_compute(&g, &p, 0, 1, &A, &P);

  787.    printf("%d %.8f %.3f\n", n, P, A);

  788.    @endcode

  789.    **********************************************************************/

  790.   unsigned GEOD_DLL geod_polygon_compute(const struct geod_geodesic* g,

  791.                                 const struct geod_polygon* p,

  792.                                 int reverse, int sign,

  793.                                 double* pA, double* pP);

  794. 

  795.   /**

  796.    * Return the results assuming a tentative final test point is added;

  797.    * however, the data for the test point is not saved.  This lets you report a

  798.    * running result for the perimeter and area as the user moves the mouse

  799.    * cursor.  Ordinary floating point arithmetic is used to accumulate the data

  800.    * for the test point; thus the area and perimeter returned are less accurate

  801.    * than if geod_polygon_addpoint() and geod_polygon_compute() are used.

  802.    *

  803.    * @param[in] g a pointer to the geod_geodesic object specifying the

  804.    *   ellipsoid.

  805.    * @param[in] p a pointer to the geod_polygon object specifying the polygon.

  806.    * @param[in] lat the latitude of the test point (degrees).

  807.    * @param[in] lon the longitude of the test point (degrees).

  808.    * @param[in] reverse if non-zero then clockwise (instead of

  809.    *   counter-clockwise) traversal counts as a positive area.

  810.    * @param[in] sign if non-zero then return a signed result for the area if

  811.    *   the polygon is traversed in the "wrong" direction instead of returning

  812.    *   the area for the rest of the earth.

  813.    * @param[out] pA pointer to the area of the polygon (meters<sup>2</sup>);

  814.    *   only set if \e polyline is non-zero in the call to geod_polygon_init().

  815.    * @param[out] pP pointer to the perimeter of the polygon or length of the

  816.    *   polyline (meters).

  817.    * @return the number of points.

  818.    *

  819.    * \e lat should be in the range [&minus;90&deg;, 90&deg;].

  820.    **********************************************************************/

  821.   unsigned GEOD_DLL geod_polygon_testpoint(const struct geod_geodesic* g,

  822.                                   const struct geod_polygon* p,

  823.                                   double lat, double lon,

  824.                                   int reverse, int sign,

  825.                                   double* pA, double* pP);

  826. 

  827.   /**

  828.    * Return the results assuming a tentative final test point is added via an

  829.    * azimuth and distance; however, the data for the test point is not saved.

  830.    * This lets you report a running result for the perimeter and area as the

  831.    * user moves the mouse cursor.  Ordinary floating point arithmetic is used

  832.    * to accumulate the data for the test point; thus the area and perimeter

  833.    * returned are less accurate than if geod_polygon_addedge() and

  834.    * geod_polygon_compute() are used.

  835.    *

  836.    * @param[in] g a pointer to the geod_geodesic object specifying the

  837.    *   ellipsoid.

  838.    * @param[in] p a pointer to the geod_polygon object specifying the polygon.

  839.    * @param[in] azi azimuth at current point (degrees).

  840.    * @param[in] s distance from current point to final test point (meters).

  841.    * @param[in] reverse if non-zero then clockwise (instead of

  842.    *   counter-clockwise) traversal counts as a positive area.

  843.    * @param[in] sign if non-zero then return a signed result for the area if

  844.    *   the polygon is traversed in the "wrong" direction instead of returning

  845.    *   the area for the rest of the earth.

  846.    * @param[out] pA pointer to the area of the polygon (meters<sup>2</sup>);

  847.    *   only set if \e polyline is non-zero in the call to geod_polygon_init().

  848.    * @param[out] pP pointer to the perimeter of the polygon or length of the

  849.    *   polyline (meters).

  850.    * @return the number of points.

  851.    **********************************************************************/

  852.   unsigned GEOD_DLL geod_polygon_testedge(const struct geod_geodesic* g,

  853.                                  const struct geod_polygon* p,

  854.                                  double azi, double s,

  855.                                  int reverse, int sign,

  856.                                  double* pA, double* pP);

  857. 

  858.   /**

  859.    * A simple interface for computing the area of a geodesic polygon.

  860.    *

  861.    * @param[in] g a pointer to the geod_geodesic object specifying the

  862.    *   ellipsoid.

  863.    * @param[in] lats an array of latitudes of the polygon vertices (degrees).

  864.    * @param[in] lons an array of longitudes of the polygon vertices (degrees).

  865.    * @param[in] n the number of vertices.

  866.    * @param[out] pA pointer to the area of the polygon (meters<sup>2</sup>).

  867.    * @param[out] pP pointer to the perimeter of the polygon (meters).

  868.    *

  869.    * \e lats should be in the range [&minus;90&deg;, 90&deg;].

  870.    *

  871.    * Only simple polygons (which are not self-intersecting) are allowed.

  872.    * There's no need to "close" the polygon by repeating the first vertex.  The

  873.    * area returned is signed with counter-clockwise traversal being treated as

  874.    * positive.

  875.    *

  876.    * Example, compute the area of Antarctica:

  877.    @code{.c}

  878.    double

  879.      lats[] = {-72.9, -71.9, -74.9, -74.3, -77.5, -77.4, -71.7, -65.9, -65.7,

  880.                -66.6, -66.9, -69.8, -70.0, -71.0, -77.3, -77.9, -74.7},

  881.      lons[] = {-74, -102, -102, -131, -163, 163, 172, 140, 113,

  882.                 88, 59, 25, -4, -14, -33, -46, -61};

  883.    struct geod_geodesic g;

  884.    double A, P;

  885.    geod_init(&g, 6378137, 1/298.257223563);

  886.    geod_polygonarea(&g, lats, lons, (sizeof lats) / (sizeof lats[0]), &A, &P);

  887.    printf("%.0f %.2f\n", A, P);

  888.    @endcode

  889.    **********************************************************************/

  890.   void GEOD_DLL geod_polygonarea(const struct geod_geodesic* g,

  891.                         double lats[], double lons[], int n,

  892.                         double* pA, double* pP);

  893. 

  894.   /**

  895.    * mask values for the \e caps argument to geod_lineinit().

  896.    **********************************************************************/

  897.   enum geod_mask {

  898.     GEOD_NONE         = 0U,                    /**< Calculate nothing */

  899.     GEOD_LATITUDE     = 1U<<7  | 0U,           /**< Calculate latitude */

  900.     GEOD_LONGITUDE    = 1U<<8  | 1U<<3,        /**< Calculate longitude */

  901.     GEOD_AZIMUTH      = 1U<<9  | 0U,           /**< Calculate azimuth */

  902.     GEOD_DISTANCE     = 1U<<10 | 1U<<0,        /**< Calculate distance */

  903.     GEOD_DISTANCE_IN  = 1U<<11 | 1U<<0 | 1U<<1,/**< Allow distance as input  */

  904.     GEOD_REDUCEDLENGTH= 1U<<12 | 1U<<0 | 1U<<2,/**< Calculate reduced length */

  905.     GEOD_GEODESICSCALE= 1U<<13 | 1U<<0 | 1U<<2,/**< Calculate geodesic scale */

  906.     GEOD_AREA         = 1U<<14 | 1U<<4,        /**< Calculate reduced length */

  907.     GEOD_ALL          = 0x7F80U| 0x1FU         /**< Calculate everything */

  908.   };

  909. 

  910.   /**

  911.    * flag values for the \e flags argument to geod_gendirect() and

  912.    * geod_genposition()

  913.    **********************************************************************/

  914.   enum geod_flags {

  915.     GEOD_NOFLAGS      = 0U,     /**< No flags */

  916.     GEOD_ARCMODE      = 1U<<0,  /**< Position given in terms of arc distance */

  917.     GEOD_LONG_UNROLL  = 1U<<15  /**< Unroll the longitude */

  918.   };

  919. 

  920. #if defined(__cplusplus)

  921. }

  922. #endif

  923. 

  924. #endif
上海开阖软件有限公司 沪ICP备12045867号-1