NETGeographicLib  1.50.1
Rhumb.h
Go to the documentation of this file.
1 #pragma once
2 /**
3  * \file NETGeographicLib/Rhumb.h
4  * \brief Header for NETGeographicLib::Rhumb and NETGeographicLib::RhumbLine classes
5  *
6  * NETGeographicLib is copyright (c) Scott Heiman (2013)
7  * GeographicLib is Copyright (c) Charles Karney (2010-2012)
8  * <charles@karney.com> and licensed under the MIT/X11 License.
9  * For more information, see
10  * https://geographiclib.sourceforge.io/
11  **********************************************************************/
12 
13 namespace NETGeographicLib {
14 
15  ref class RhumbLine;
16 
17  /**
18  * \brief .NET wrapper for GeographicLib::Rhumb.
19  *
20  * This class allows .NET applications to access GeographicLib::Rhumb.
21  *
22  * Solve of the direct and inverse rhumb problems.
23  *
24  * The path of constant azimuth between two points on a ellipsoid at (\e
25  * lat1, \e lon1) and (\e lat2, \e lon2) is called the rhumb line (also
26  * called the loxodrome). Its length is \e s12 and its azimuth is \e azi12.
27  * (The azimuth is the heading measured clockwise from north.)
28  *
29  * Given \e lat1, \e lon1, \e azi12, and \e s12, we can determine \e lat2,
30  * and \e lon2. This is the \e direct rhumb problem and its solution is
31  * given by the function Rhumb::Direct.
32  *
33  * Given \e lat1, \e lon1, \e lat2, and \e lon2, we can determine \e azi12
34  * and \e s12. This is the \e inverse rhumb problem, whose solution is given
35  * by Rhumb::Inverse. This finds the shortest such rhumb line, i.e., the one
36  * that wraps no more than half way around the earth. If the end points are
37  * on opposite meridians, there are two shortest rhumb lines and the
38  * east-going one is chosen.
39  *
40  * These routines also optionally calculate the area under the rhumb line, \e
41  * S12. This is the area, measured counter-clockwise, of the rhumb line
42  * quadrilateral with corners (<i>lat1</i>,<i>lon1</i>), (0,<i>lon1</i>),
43  * (0,<i>lon2</i>), and (<i>lat2</i>,<i>lon2</i>).
44  *
45  * Note that rhumb lines may be appreciably longer (up to 50%) than the
46  * corresponding Geodesic. For example the distance between London Heathrow
47  * and Tokyo Narita via the rhumb line is 11400 km which is 18% longer than
48  * the geodesic distance 9600 km.
49  *
50  * For more information on rhumb lines see \ref rhumb.
51  *
52  * For more information on rhumb lines see \ref rhumb.
53  *
54  * C# Example:
55  * \include example-Rhumb.cs
56  * Managed C++ Example:
57  * \include example-Rhumb.cpp
58  * Visual Basic Example:
59  * \include example-Rhumb.vb
60  *
61  * <B>INTERFACE DIFFERENCES:</B><BR>
62  * The EquatorialRadius and Flattening functions are implemented as properties.
63  **********************************************************************/
64 
65  public ref class Rhumb {
66  private:
67  // pointer to the unmanaged Rhumb object
68  GeographicLib::Rhumb* m_pRhumb;
69 
70  // The finalizer destroys m_pRhumb when this object is destroyed.
71  !Rhumb(void);
72  public:
73  /**
74  * Bit masks for what calculations to do. They specify which results to
75  * return in the general routines Rhumb::GenDirect and Rhumb::GenInverse
76  * routines. RhumbLine::mask is a duplication of this enum.
77  **********************************************************************/
78  enum class mask {
79  /**
80  * No output.
81  * @hideinitializer
82  **********************************************************************/
83  NONE = 0U,
84  /**
85  * Calculate latitude \e lat2.
86  * @hideinitializer
87  **********************************************************************/
88  LATITUDE = 1U<<7,
89  /**
90  * Calculate longitude \e lon2.
91  * @hideinitializer
92  **********************************************************************/
93  LONGITUDE = 1U<<8,
94  /**
95  * Calculate azimuth \e azi12.
96  * @hideinitializer
97  **********************************************************************/
98  AZIMUTH = 1U<<9,
99  /**
100  * Calculate distance \e s12.
101  * @hideinitializer
102  **********************************************************************/
103  DISTANCE = 1U<<10,
104  /**
105  * Calculate area \e S12.
106  * @hideinitializer
107  **********************************************************************/
108  AREA = 1U<<14,
109  /**
110  * Unroll \e lon2 in the direct calculation.
111  * @hideinitializer
112  **********************************************************************/
113  LONG_UNROLL = 1U<<15,
114  /**
115  * Calculate everything. (LONG_UNROLL is not included in this mask.)
116  * @hideinitializer
117  **********************************************************************/
118  ALL = 0x7F80U,
119  };
120 
121  /**
122  * Constructor for a ellipsoid with
123  *
124  * @param[in] a equatorial radius (meters).
125  * @param[in] f flattening of ellipsoid. Setting \e f = 0 gives a sphere.
126  * Negative \e f gives a prolate ellipsoid.
127  * @param[in] exact if true (the default) use an addition theorem for
128  * elliptic integrals to compute divided differences; otherwise use
129  * series expansion (accurate for |<i>f</i>| < 0.01).
130  * @exception GeographicErr if \e a or (1 &minus; \e f) \e a is not
131  * positive.
132  *
133  * See \ref rhumb, for a detailed description of the \e exact parameter.
134  **********************************************************************/
135  Rhumb(double a, double f, bool exact);
136 
137  /**
138  * \brief The destructor calls the finalizer.
139  **********************************************************************/
140  ~Rhumb() { this->!Rhumb(); }
141 
142  /**
143  * Solve the direct rhumb problem returning also the area.
144  *
145  * @param[in] lat1 latitude of point 1 (degrees).
146  * @param[in] lon1 longitude of point 1 (degrees).
147  * @param[in] azi12 azimuth of the rhumb line (degrees).
148  * @param[in] s12 distance between point 1 and point 2 (meters); it can be
149  * negative.
150  * @param[out] lat2 latitude of point 2 (degrees).
151  * @param[out] lon2 longitude of point 2 (degrees).
152  * @param[out] S12 area under the rhumb line (meters<sup>2</sup>).
153  *
154  * \e lat1 should be in the range [&minus;90&deg;, 90&deg;]. The value of
155  * \e lon2 returned is in the range [&minus;180&deg;, 180&deg;).
156  *
157  * If point 1 is a pole, the cosine of its latitude is taken to be
158  * 1/&epsilon;<sup>2</sup> (where &epsilon; is 2<sup>-52</sup>). This
159  * position, which is extremely close to the actual pole, allows the
160  * calculation to be carried out in finite terms. If \e s12 is large
161  * enough that the rhumb line crosses a pole, the longitude of point 2
162  * is indeterminate (a NaN is returned for \e lon2 and \e S12).
163  **********************************************************************/
164  void Direct(double lat1, double lon1, double azi12, double s12,
165  [System::Runtime::InteropServices::Out] double% lat2,
166  [System::Runtime::InteropServices::Out] double% lon2,
167  [System::Runtime::InteropServices::Out] double% S12);
168 
169  /**
170  * Solve the direct rhumb problem without the area.
171  *
172  * @param[in] lat1 latitude of point 1 (degrees).
173  * @param[in] lon1 longitude of point 1 (degrees).
174  * @param[in] azi12 azimuth of the rhumb line (degrees).
175  * @param[in] s12 distance between point 1 and point 2 (meters); it can be
176  * negative.
177  * @param[out] lat2 latitude of point 2 (degrees).
178  * @param[out] lon2 longitude of point 2 (degrees).
179  *
180  * \e lat1 should be in the range [&minus;90&deg;, 90&deg;]. The values of
181  * \e lon2 and \e azi2 returned are in the range [&minus;180&deg;,
182  * 180&deg;).
183  *
184  * If point 1 is a pole, the cosine of its latitude is taken to be
185  * 1/&epsilon;<sup>2</sup> (where &epsilon; is 2<sup>-52</sup>). This
186  * position, which is extremely close to the actual pole, allows the
187  * calculation to be carried out in finite terms. If \e s12 is large
188  * enough that the rhumb line crosses a pole, the longitude of point 2
189  * is indeterminate (a NaN is returned for \e lon2).
190  **********************************************************************/
191  void Direct(double lat1, double lon1, double azi12, double s12,
192  [System::Runtime::InteropServices::Out] double% lat2,
193  [System::Runtime::InteropServices::Out] double% lon2);
194 
195  /**
196  * The general direct rhumb problem. Rhumb::Direct is defined in terms
197  * of this function.
198  *
199  * @param[in] lat1 latitude of point 1 (degrees).
200  * @param[in] lon1 longitude of point 1 (degrees).
201  * @param[in] azi12 azimuth of the rhumb line (degrees).
202  * @param[in] s12 distance between point 1 and point 2 (meters); it can be
203  * negative.
204  * @param[in] outmask a bitor'ed combination of Rhumb::mask values
205  * specifying which of the following parameters should be set.
206  * @param[out] lat2 latitude of point 2 (degrees).
207  * @param[out] lon2 longitude of point 2 (degrees).
208  * @param[out] S12 area under the rhumb line (meters<sup>2</sup>).
209  *
210  * The Rhumb::mask values possible for \e outmask are
211  * - \e outmask |= Rhumb.LATITUDE for the latitude \e lat2;
212  * - \e outmask |= Rhumb.LONGITUDE for the latitude \e lon2;
213  * - \e outmask |= Rhumb.AREA for the area \e S12;
214  * - \e outmask |= Rhumb:.ALL for all of the above;
215  * - \e outmask |= Rhumb.LONG_UNROLL to unroll \e lon2 instead of
216  * wrapping it into the range [&minus;180&deg;, 180&deg;).
217  * .
218  * With the LONG_UNROLL bit set, the quantity \e lon2 &minus; \e lon1
219  * indicates how many times the rhumb line wrapped around the ellipsoid.
220  **********************************************************************/
221  void GenDirect(double lat1, double lon1, double azi12, double s12,
222  Rhumb::mask outmask,
223  [System::Runtime::InteropServices::Out] double% lat2,
224  [System::Runtime::InteropServices::Out] double% lon2,
225  [System::Runtime::InteropServices::Out] double% S12);
226 
227  /**
228  * Solve the inverse rhumb problem returning also the area.
229  *
230  * @param[in] lat1 latitude of point 1 (degrees).
231  * @param[in] lon1 longitude of point 1 (degrees).
232  * @param[in] lat2 latitude of point 2 (degrees).
233  * @param[in] lon2 longitude of point 2 (degrees).
234  * @param[out] s12 rhumb distance between point 1 and point 2 (meters).
235  * @param[out] azi12 azimuth of the rhumb line (degrees).
236  * @param[out] S12 area under the rhumb line (meters<sup>2</sup>).
237  *
238  * The shortest rhumb line is found. If the end points are on opposite
239  * meridians, there are two shortest rhumb lines and the east-going one is
240  * chosen. \e lat1 and \e lat2 should be in the range [&minus;90&deg;,
241  * 90&deg;]. The value of \e azi12 returned is in the range
242  * [&minus;180&deg;, 180&deg;).
243  *
244  * If either point is a pole, the cosine of its latitude is taken to be
245  * 1/&epsilon;<sup>2</sup> (where &epsilon; is 2<sup>-52</sup>). This
246  * position, which is extremely close to the actual pole, allows the
247  * calculation to be carried out in finite terms.
248  **********************************************************************/
249  void Inverse(double lat1, double lon1, double lat2, double lon2,
250  [System::Runtime::InteropServices::Out] double% s12,
251  [System::Runtime::InteropServices::Out] double% azi12,
252  [System::Runtime::InteropServices::Out] double% S12);
253 
254  /**
255  * Solve the inverse rhumb problem without the area.
256  *
257  * @param[in] lat1 latitude of point 1 (degrees).
258  * @param[in] lon1 longitude of point 1 (degrees).
259  * @param[in] lat2 latitude of point 2 (degrees).
260  * @param[in] lon2 longitude of point 2 (degrees).
261  * @param[out] s12 rhumb distance between point 1 and point 2 (meters).
262  * @param[out] azi12 azimuth of the rhumb line (degrees).
263  *
264  * The shortest rhumb line is found. \e lat1 and \e lat2 should be in the
265  * range [&minus;90&deg;, 90&deg;]. The value of \e azi12 returned is in
266  * the range [&minus;180&deg;, 180&deg;).
267  *
268  * If either point is a pole, the cosine of its latitude is taken to be
269  * 1/&epsilon;<sup>2</sup> (where &epsilon; is 2<sup>-52</sup>). This
270  * position, which is extremely close to the actual pole, allows the
271  * calculation to be carried out in finite terms.
272  **********************************************************************/
273  void Inverse(double lat1, double lon1, double lat2, double lon2,
274  [System::Runtime::InteropServices::Out] double% s12,
275  [System::Runtime::InteropServices::Out] double% azi12);
276 
277  /**
278  * The general inverse rhumb problem. Rhumb::Inverse is defined in terms
279  * of this function.
280  *
281  * @param[in] lat1 latitude of point 1 (degrees).
282  * @param[in] lon1 longitude of point 1 (degrees).
283  * @param[in] lat2 latitude of point 2 (degrees).
284  * @param[in] lon2 longitude of point 2 (degrees).
285  * @param[in] outmask a bitor'ed combination of Rhumb::mask values
286  * specifying which of the following parameters should be set.
287  * @param[out] s12 rhumb distance between point 1 and point 2 (meters).
288  * @param[out] azi12 azimuth of the rhumb line (degrees).
289  * @param[out] S12 area under the rhumb line (meters<sup>2</sup>).
290  *
291  * The Rhumb::mask values possible for \e outmask are
292  * - \e outmask |= Rhumb::DISTANCE for the latitude \e s12;
293  * - \e outmask |= Rhumb::AZIMUTH for the latitude \e azi12;
294  * - \e outmask |= Rhumb::AREA for the area \e S12;
295  * - \e outmask |= Rhumb::ALL for all of the above;
296  **********************************************************************/
297  void GenInverse(double lat1, double lon1, double lat2, double lon2,
298  Rhumb::mask outmask,
299  [System::Runtime::InteropServices::Out] double% s12,
300  [System::Runtime::InteropServices::Out] double% azi12,
301  [System::Runtime::InteropServices::Out] double% S12);
302 
303  /**
304  * Set up to compute several points on a single rhumb line.
305  *
306  * @param[in] lat1 latitude of point 1 (degrees).
307  * @param[in] lon1 longitude of point 1 (degrees).
308  * @param[in] azi12 azimuth of the rhumb line (degrees).
309  * @return a RhumbLine object.
310  *
311  * \e lat1 should be in the range [&minus;90&deg;, 90&deg;].
312  *
313  * If point 1 is a pole, the cosine of its latitude is taken to be
314  * 1/&epsilon;<sup>2</sup> (where &epsilon; is 2<sup>-52</sup>). This
315  * position, which is extremely close to the actual pole, allows the
316  * calculation to be carried out in finite terms.
317  **********************************************************************/
318  RhumbLine^ Line(double lat1, double lon1, double azi12);
319 
320  /** \name Inspector functions.
321  **********************************************************************/
322  ///@{
323 
324  /**
325  * @return the equatorial radius of the ellipsoid (meters). This is
326  * the value used in the constructor.
327  **********************************************************************/
328  property double EquatorialRadius { double get(); }
329 
330  /**
331  * @return f the flattening of the ellipsoid. This is the
332  * value used in the constructor.
333  **********************************************************************/
334  property double Flattening { double get(); }
335 
336  /**
337  * @return the area of the ellipsoid.
338  **********************************************************************/
339  property double EllipsoidArea { double get(); }
340 
341  /**
342  * %return The unmanaged pointer to the GeographicLib::Geodesic.
343  *
344  * This function is for internal use only.
345  **********************************************************************/
346  System::IntPtr^ GetUnmanaged();
347 
348  /**
349  * A global instantiation of Rhumb with the parameters for the WGS84
350  * ellipsoid.
351  **********************************************************************/
352  static Rhumb^ WGS84();
353  };
354 
355  /**
356  * \brief .NET wrapper for GeographicLib::RhumbLine.
357  *
358  * This class allows .NET applications to access GeographicLib::RhumbLine.
359  *
360  * Find a sequence of points on a single rhumb line.
361  *
362  * RhumbLine facilitates the determination of a series of points on a single
363  * rhumb line. The starting point (\e lat1, \e lon1) and the azimuth \e
364  * azi12 are specified in the call to Rhumb::Line which returns a RhumbLine
365  * object. RhumbLine.Position returns the location of point 2 a distance \e
366  * s12 along the rhumb line.
367 
368  * There is no public constructor for this class. (Use Rhumb::Line to create
369  * an instance.) The Rhumb object used to create a RhumbLine must stay in
370  * scope as long as the RhumbLine.
371  *
372  **********************************************************************/
373 
374  public ref class RhumbLine {
375  private:
376  // pointer to the unmanaged RhumbLine object.
377  GeographicLib::RhumbLine* m_pRhumbLine;
378 
379  // The finalizer destroys m_pRhumbLine when this object is destroyed.
380  !RhumbLine(void);
381  public:
382  enum class mask {
383  /**
384  * No output.
385  * @hideinitializer
386  **********************************************************************/
387  NONE = 0, //NETGeographicLib::Rhumb::NONE,
388  /**
389  * Calculate latitude \e lat2.
390  * @hideinitializer
391  **********************************************************************/
392  LATITUDE = 1U<<7, //Rhumb::LATITUDE,
393  /**
394  * Calculate longitude \e lon2.
395  * @hideinitializer
396  **********************************************************************/
397  LONGITUDE = 1U<<8, //Rhumb::LONGITUDE,
398  /**
399  * Calculate azimuth \e azi12.
400  * @hideinitializer
401  **********************************************************************/
402  AZIMUTH = 1U<<9, //Rhumb::AZIMUTH,
403  /**
404  * Calculate distance \e s12.
405  * @hideinitializer
406  **********************************************************************/
407  DISTANCE = 1U<<10, //Rhumb::DISTANCE,
408  /**
409  * Calculate area \e S12.
410  * @hideinitializer
411  **********************************************************************/
412  AREA = 1U<<14, //Rhumb::AREA,
413  /**
414  * Unroll \e lon2 in the direct calculation.
415  * @hideinitializer
416  **********************************************************************/
417  LONG_UNROLL = 1U<<15, //Rhumb::LONG_UNROLL,
418  /**
419  * Calculate everything. (LONG_UNROLL is not included in this mask.)
420  * @hideinitializer
421  **********************************************************************/
422  ALL = 0x7F80U, //Rhumb::ALL,
423  };
424  /**
425  * \brief Constructor.
426  *
427  * For internal use only. Developers should not call this constructor
428  * directly. Use the Rhumb::Line function to create RhumbLine objects.
429  **********************************************************************/
431 
432  /**
433  * \brief The destructor calls the finalizer.
434  **********************************************************************/
435  ~RhumbLine() { this->!RhumbLine(); }
436 
437  /**
438  * Compute the position of point 2 which is a distance \e s12 (meters) from
439  * point 1. The area is also computed.
440  *
441  * @param[in] s12 distance between point 1 and point 2 (meters); it can be
442  * negative.
443  * @param[out] lat2 latitude of point 2 (degrees).
444  * @param[out] lon2 longitude of point 2 (degrees).
445  * @param[out] S12 area under the rhumb line (meters<sup>2</sup>).
446  *
447  * The value of \e lon2 returned is in the range [&minus;180&deg;,
448  * 180&deg;).
449  *
450  * If \e s12 is large enough that the rhumb line crosses a pole, the
451  * longitude of point 2 is indeterminate (a NaN is returned for \e lon2 and
452  * \e S12).
453  **********************************************************************/
454  void Position(double s12,
455  [System::Runtime::InteropServices::Out] double% lat2,
456  [System::Runtime::InteropServices::Out] double% lon2,
457  [System::Runtime::InteropServices::Out] double% S12);
458 
459  /**
460  * Compute the position of point 2 which is a distance \e s12 (meters) from
461  * point 1.
462  *
463  * @param[in] s12 distance between point 1 and point 2 (meters); it can be
464  * negative.
465  * @param[out] lat2 latitude of point 2 (degrees).
466  * @param[out] lon2 longitude of point 2 (degrees).
467  *
468  * The values of \e lon2 and \e azi2 returned are in the range
469  * [&minus;180&deg;, 180&deg;).
470  *
471  * If \e s12 is large enough that the rhumb line crosses a pole, the
472  * longitude of point 2 is indeterminate (a NaN is returned for \e lon2).
473  **********************************************************************/
474  void Position(double s12,
475  [System::Runtime::InteropServices::Out] double% lat2,
476  [System::Runtime::InteropServices::Out] double% lon2);
477 
478  /**
479  * The general position routine. RhumbLine::Position is defined in term so
480  * this function.
481  *
482  * @param[in] s12 distance between point 1 and point 2 (meters); it can be
483  * negative.
484  * @param[in] outmask a bitor'ed combination of RhumbLine::mask values
485  * specifying which of the following parameters should be set.
486  * @param[out] lat2 latitude of point 2 (degrees).
487  * @param[out] lon2 longitude of point 2 (degrees).
488  * @param[out] S12 area under the rhumb line (meters<sup>2</sup>).
489  *
490  * The RhumbLine::mask values possible for \e outmask are
491  * - \e outmask |= RhumbLine::LATITUDE for the latitude \e lat2;
492  * - \e outmask |= RhumbLine::LONGITUDE for the latitude \e lon2;
493  * - \e outmask |= RhumbLine::AREA for the area \e S12;
494  * - \e outmask |= RhumbLine::ALL for all of the above;
495  * - \e outmask |= RhumbLine::LONG_UNROLL to unroll \e lon2 instead of
496  * wrapping it into the range [&minus;180&deg;, 180&deg;).
497  * .
498  * With the LONG_UNROLL bit set, the quantity \e lon2 &minus; \e lon1
499  * indicates how many times and in what sense the rhumb line encircles the
500  * ellipsoid.
501  *
502  * If \e s12 is large enough that the rhumb line crosses a pole, the
503  * longitude of point 2 is indeterminate (a NaN is returned for \e lon2 and
504  * \e S12).
505  **********************************************************************/
506  void GenPosition(double s12, RhumbLine::mask outmask,
507  [System::Runtime::InteropServices::Out] double% lat2,
508  [System::Runtime::InteropServices::Out] double% lon2,
509  [System::Runtime::InteropServices::Out] double% S12);
510 
511  /** \name Inspector functions
512  **********************************************************************/
513  ///@{
514 
515  /**
516  * @return the latitude of point 1 (degrees).
517  **********************************************************************/
518  property double Latitude { double get(); }
519 
520  /**
521  * @return the longitude of point 1 (degrees).
522  **********************************************************************/
523  property double Longitude { double get(); }
524 
525  /**
526  * @return the azimuth of the rhumb line (degrees).
527  **********************************************************************/
528  property double Azimuth { double get(); }
529 
530  /**
531  * @return the equatorial radius of the ellipsoid (meters). This is
532  * the value inherited from the Rhumb object used in the constructor.
533  **********************************************************************/
534  property double EquatorialRadius { double get(); }
535 
536  /**
537  * @return the flattening of the ellipsoid. This is the value
538  * inherited from the Rhumb object used in the constructor.
539  **********************************************************************/
540  property double Flattening { double get(); }
541  };
542 
543 } // namespace NETGeographicLib
NETGeographicLib::RhumbLine::mask::AREA
@ AREA
NETGeographicLib::RhumbLine::RhumbLine
RhumbLine(GeographicLib::RhumbLine *pRhumbLine)
Constructor.
NETGeographicLib::Rhumb::mask::NONE
@ NONE
NETGeographicLib::Rhumb::Inverse
void Inverse(double lat1, double lon1, double lat2, double lon2, [System::Runtime::InteropServices::Out] double% s12, [System::Runtime::InteropServices::Out] double% azi12, [System::Runtime::InteropServices::Out] double% S12)
NETGeographicLib::RhumbLine::mask::LATITUDE
@ LATITUDE
NETGeographicLib::RhumbLine::~RhumbLine
~RhumbLine()
The destructor calls the finalizer.
Definition: Rhumb.h:435
GeographicLib::Rhumb
NETGeographicLib::Rhumb::WGS84
static Rhumb ^ WGS84()
NETGeographicLib::RhumbLine::GenPosition
void GenPosition(double s12, RhumbLine::mask outmask, [System::Runtime::InteropServices::Out] double% lat2, [System::Runtime::InteropServices::Out] double% lon2, [System::Runtime::InteropServices::Out] double% S12)
NETGeographicLib::RhumbLine::mask::LONG_UNROLL
@ LONG_UNROLL
NETGeographicLib::Rhumb::mask::AREA
@ AREA
NETGeographicLib::Rhumb::GenDirect
void GenDirect(double lat1, double lon1, double azi12, double s12, Rhumb::mask outmask, [System::Runtime::InteropServices::Out] double% lat2, [System::Runtime::InteropServices::Out] double% lon2, [System::Runtime::InteropServices::Out] double% S12)
NETGeographicLib::RhumbLine::mask::LONGITUDE
@ LONGITUDE
NETGeographicLib::Rhumb::Direct
void Direct(double lat1, double lon1, double azi12, double s12, [System::Runtime::InteropServices::Out] double% lat2, [System::Runtime::InteropServices::Out] double% lon2, [System::Runtime::InteropServices::Out] double% S12)
NETGeographicLib::RhumbLine::Flattening
double Flattening
Definition: Rhumb.h:540
NETGeographicLib::Rhumb::EquatorialRadius
double EquatorialRadius
Definition: Rhumb.h:328
NETGeographicLib::RhumbLine::Longitude
double Longitude
Definition: Rhumb.h:523
NETGeographicLib::Rhumb::Line
RhumbLine ^ Line(double lat1, double lon1, double azi12)
NETGeographicLib::RhumbLine::mask::NONE
@ NONE
NETGeographicLib::RhumbLine::Position
void Position(double s12, [System::Runtime::InteropServices::Out] double% lat2, [System::Runtime::InteropServices::Out] double% lon2, [System::Runtime::InteropServices::Out] double% S12)
NETGeographicLib::Rhumb::Inverse
void Inverse(double lat1, double lon1, double lat2, double lon2, [System::Runtime::InteropServices::Out] double% s12, [System::Runtime::InteropServices::Out] double% azi12)
NETGeographicLib::Rhumb::Direct
void Direct(double lat1, double lon1, double azi12, double s12, [System::Runtime::InteropServices::Out] double% lat2, [System::Runtime::InteropServices::Out] double% lon2)
NETGeographicLib::Rhumb::GetUnmanaged
System::IntPtr ^ GetUnmanaged()
NETGeographicLib::Rhumb::EllipsoidArea
double EllipsoidArea
Definition: Rhumb.h:339
NETGeographicLib::Rhumb::GenInverse
void GenInverse(double lat1, double lon1, double lat2, double lon2, Rhumb::mask outmask, [System::Runtime::InteropServices::Out] double% s12, [System::Runtime::InteropServices::Out] double% azi12, [System::Runtime::InteropServices::Out] double% S12)
NETGeographicLib::RhumbLine::Position
void Position(double s12, [System::Runtime::InteropServices::Out] double% lat2, [System::Runtime::InteropServices::Out] double% lon2)
NETGeographicLib::Rhumb::mask::LATITUDE
@ LATITUDE
NETGeographicLib::RhumbLine::Latitude
double Latitude
Definition: Rhumb.h:518
GeographicLib::RhumbLine
NETGeographicLib::Rhumb::mask::DISTANCE
@ DISTANCE
NETGeographicLib::RhumbLine::mask::ALL
@ ALL
NETGeographicLib::Rhumb::~Rhumb
~Rhumb()
The destructor calls the finalizer.
Definition: Rhumb.h:140
NETGeographicLib::Rhumb
.NET wrapper for GeographicLib::Rhumb.
Definition: Rhumb.h:65
NETGeographicLib::Rhumb::mask::LONG_UNROLL
@ LONG_UNROLL
NETGeographicLib::Rhumb::Rhumb
Rhumb(double a, double f, bool exact)
NETGeographicLib::Rhumb::mask::ALL
@ ALL
NETGeographicLib::Rhumb::Flattening
double Flattening
Definition: Rhumb.h:334
NETGeographicLib::RhumbLine::Azimuth
double Azimuth
Definition: Rhumb.h:528
NETGeographicLib::RhumbLine::EquatorialRadius
double EquatorialRadius
Definition: Rhumb.h:534
NETGeographicLib::Rhumb::mask
mask
Definition: Rhumb.h:78
NETGeographicLib::RhumbLine::mask
mask
Definition: Rhumb.h:382
NETGeographicLib::Rhumb::mask::LONGITUDE
@ LONGITUDE
NETGeographicLib::RhumbLine::mask::AZIMUTH
@ AZIMUTH
NETGeographicLib::Rhumb::mask::AZIMUTH
@ AZIMUTH
NETGeographicLib::RhumbLine::mask::DISTANCE
@ DISTANCE
NETGeographicLib
Definition: Accumulator.h:14
NETGeographicLib::RhumbLine
.NET wrapper for GeographicLib::RhumbLine.
Definition: Rhumb.h:374