NETGeographicLib  1.43
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Pages
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  * http://geographiclib.sourceforge.net/
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 MajorRadius 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. (This flag used to be
111  * called LONG_NOWRAP.)
112  * @hideinitializer
113  **********************************************************************/
114  LONG_UNROLL = 1U<<15,
116  /**
117  * Calculate everything. (LONG_UNROLL is not included in this mask.)
118  * @hideinitializer
119  **********************************************************************/
120  ALL = 0x7F80U,
121  };
122 
123  /**
124  * Constructor for a ellipsoid with
125  *
126  * @param[in] a equatorial radius (meters).
127  * @param[in] f flattening of ellipsoid. Setting \e f = 0 gives a sphere.
128  * Negative \e f gives a prolate ellipsoid. If \e f &gt; 1, set
129  * flattening to 1/\e f.
130  * @param[in] exact if true (the default) use an addition theorem for
131  * elliptic integrals to compute divided differences; otherwise use
132  * series expansion (accurate for |<i>f</i>| < 0.01).
133  * @exception GeographicErr if \e a or (1 &minus; \e f) \e a is not
134  * positive.
135  *
136  * See \ref rhumb, for a detailed description of the \e exact parameter.
137  **********************************************************************/
138  Rhumb(double a, double f, bool exact);
139 
140  /**
141  * \brief The destructor calls the finalizer.
142  **********************************************************************/
143  ~Rhumb() { this->!Rhumb(); }
144 
145  /**
146  * Solve the direct rhumb problem returning also the area.
147  *
148  * @param[in] lat1 latitude of point 1 (degrees).
149  * @param[in] lon1 longitude of point 1 (degrees).
150  * @param[in] azi12 azimuth of the rhumb line (degrees).
151  * @param[in] s12 distance between point 1 and point 2 (meters); it can be
152  * negative.
153  * @param[out] lat2 latitude of point 2 (degrees).
154  * @param[out] lon2 longitude of point 2 (degrees).
155  * @param[out] S12 area under the rhumb line (meters<sup>2</sup>).
156  *
157  * \e lat1 should be in the range [&minus;90&deg;, 90&deg;]; \e lon1 and \e
158  * azi12 should be in the range [&minus;540&deg;, 540&deg;). The value of
159  * \e lon2 returned is in the range [&minus;180&deg;, 180&deg;).
160  *
161  * If point 1 is a pole, the cosine of its latitude is taken to be
162  * 1/&epsilon;<sup>2</sup> (where &epsilon; is 2<sup>-52</sup>). This
163  * position, which is extremely close to the actual pole, allows the
164  * calculation to be carried out in finite terms. If \e s12 is large
165  * enough that the rhumb line crosses a pole, the longitude of point 2
166  * is indeterminate (a NaN is returned for \e lon2 and \e S12).
167  **********************************************************************/
168  void Direct(double lat1, double lon1, double azi12, double s12,
169  [System::Runtime::InteropServices::Out] double% lat2,
170  [System::Runtime::InteropServices::Out] double% lon2,
171  [System::Runtime::InteropServices::Out] double% S12);
172 
173  /**
174  * Solve the direct rhumb problem without the area.
175  *
176  * @param[in] lat1 latitude of point 1 (degrees).
177  * @param[in] lon1 longitude of point 1 (degrees).
178  * @param[in] azi12 azimuth of the rhumb line (degrees).
179  * @param[in] s12 distance between point 1 and point 2 (meters); it can be
180  * negative.
181  * @param[out] lat2 latitude of point 2 (degrees).
182  * @param[out] lon2 longitude of point 2 (degrees).
183  *
184  * \e lat1 should be in the range [&minus;90&deg;, 90&deg;]; \e lon1 and \e
185  * azi1 should be in the range [&minus;540&deg;, 540&deg;). The values of
186  * \e lon2 and \e azi2 returned are in the range [&minus;180&deg;,
187  * 180&deg;).
188  *
189  * If point 1 is a pole, the cosine of its latitude is taken to be
190  * 1/&epsilon;<sup>2</sup> (where &epsilon; is 2<sup>-52</sup>). This
191  * position, which is extremely close to the actual pole, allows the
192  * calculation to be carried out in finite terms. If \e s12 is large
193  * enough that the rhumb line crosses a pole, the longitude of point 2
194  * is indeterminate (a NaN is returned for \e lon2).
195  **********************************************************************/
196  void Direct(double lat1, double lon1, double azi12, double s12,
197  [System::Runtime::InteropServices::Out] double% lat2,
198  [System::Runtime::InteropServices::Out] double% lon2);
199 
200  /**
201  * The general direct rhumb problem. Rhumb::Direct is defined in terms
202  * of this function.
203  *
204  * @param[in] lat1 latitude of point 1 (degrees).
205  * @param[in] lon1 longitude of point 1 (degrees).
206  * @param[in] azi12 azimuth of the rhumb line (degrees).
207  * @param[in] s12 distance between point 1 and point 2 (meters); it can be
208  * negative.
209  * @param[in] outmask a bitor'ed combination of Rhumb::mask values
210  * specifying which of the following parameters should be set.
211  * @param[out] lat2 latitude of point 2 (degrees).
212  * @param[out] lon2 longitude of point 2 (degrees).
213  * @param[out] S12 area under the rhumb line (meters<sup>2</sup>).
214  *
215  * The Rhumb::mask values possible for \e outmask are
216  * - \e outmask |= Rhumb.LATITUDE for the latitude \e lat2;
217  * - \e outmask |= Rhumb.LONGITUDE for the latitude \e lon2;
218  * - \e outmask |= Rhumb.AREA for the area \e S12;
219  * - \e outmask |= Rhumb:.ALL for all of the above;
220  * - \e outmask |= Rhumb.LONG_UNROLL to unroll \e lon2 instead of
221  * wrapping it into the range [&minus;180&deg;, 180&deg;).
222  * .
223  * With the LONG_UNROLL bit set, the quantity \e lon2 &minus; \e lon1
224  * indicates how many times the rhumb line wrapped around the ellipsoid.
225  * Because \e lon2 might be outside the normal allowed range for
226  * longitudes, [&minus;540&deg;, 540&deg;), be sure to normalize it with
227  * Math::AngNormalize2 before using it in other GeographicLib calls.
228  **********************************************************************/
229  void GenDirect(double lat1, double lon1, double azi12, double s12,
230  Rhumb::mask outmask,
231  [System::Runtime::InteropServices::Out] double% lat2,
232  [System::Runtime::InteropServices::Out] double% lon2,
233  [System::Runtime::InteropServices::Out] double% S12);
234 
235  /**
236  * Solve the inverse rhumb problem returning also the area.
237  *
238  * @param[in] lat1 latitude of point 1 (degrees).
239  * @param[in] lon1 longitude of point 1 (degrees).
240  * @param[in] lat2 latitude of point 2 (degrees).
241  * @param[in] lon2 longitude of point 2 (degrees).
242  * @param[out] s12 rhumb distance between point 1 and point 2 (meters).
243  * @param[out] azi12 azimuth of the rhumb line (degrees).
244  * @param[out] S12 area under the rhumb line (meters<sup>2</sup>).
245  *
246  * The shortest rhumb line is found. If the end points are on opposite
247  * meridians, there are two shortest rhumb lines and the east-going one is
248  * chosen. \e lat1 and \e lat2 should be in the range [&minus;90&deg;,
249  * 90&deg;]; \e lon1 and \e lon2 should be in the range [&minus;540&deg;,
250  * 540&deg;). The value of \e azi12 returned is in the range
251  * [&minus;180&deg;, 180&deg;).
252  *
253  * If either point is a pole, the cosine of its latitude is taken to be
254  * 1/&epsilon;<sup>2</sup> (where &epsilon; is 2<sup>-52</sup>). This
255  * position, which is extremely close to the actual pole, allows the
256  * calculation to be carried out in finite terms.
257  **********************************************************************/
258  void Inverse(double lat1, double lon1, double lat2, double lon2,
259  [System::Runtime::InteropServices::Out] double% s12,
260  [System::Runtime::InteropServices::Out] double% azi12,
261  [System::Runtime::InteropServices::Out] double% S12);
262 
263  /**
264  * Solve the inverse rhumb problem without the area.
265  *
266  * @param[in] lat1 latitude of point 1 (degrees).
267  * @param[in] lon1 longitude of point 1 (degrees).
268  * @param[in] lat2 latitude of point 2 (degrees).
269  * @param[in] lon2 longitude of point 2 (degrees).
270  * @param[out] s12 rhumb distance between point 1 and point 2 (meters).
271  * @param[out] azi12 azimuth of the rhumb line (degrees).
272  *
273  * The shortest rhumb line is found. \e lat1 and \e lat2 should be in the
274  * range [&minus;90&deg;, 90&deg;]; \e lon1 and \e lon2 should be in the
275  * range [&minus;540&deg;, 540&deg;). The value of \e azi12 returned is in
276  * the range [&minus;180&deg;, 180&deg;).
277  *
278  * If either point is a pole, the cosine of its latitude is taken to be
279  * 1/&epsilon;<sup>2</sup> (where &epsilon; is 2<sup>-52</sup>). This
280  * position, which is extremely close to the actual pole, allows the
281  * calculation to be carried out in finite terms.
282  **********************************************************************/
283  void Inverse(double lat1, double lon1, double lat2, double lon2,
284  [System::Runtime::InteropServices::Out] double% s12,
285  [System::Runtime::InteropServices::Out] double% azi12);
286 
287  /**
288  * The general inverse rhumb problem. Rhumb::Inverse is defined in terms
289  * of this function.
290  *
291  * @param[in] lat1 latitude of point 1 (degrees).
292  * @param[in] lon1 longitude of point 1 (degrees).
293  * @param[in] lat2 latitude of point 2 (degrees).
294  * @param[in] lon2 longitude of point 2 (degrees).
295  * @param[in] outmask a bitor'ed combination of Rhumb::mask values
296  * specifying which of the following parameters should be set.
297  * @param[out] s12 rhumb distance between point 1 and point 2 (meters).
298  * @param[out] azi12 azimuth of the rhumb line (degrees).
299  * @param[out] S12 area under the rhumb line (meters<sup>2</sup>).
300  *
301  * The Rhumb::mask values possible for \e outmask are
302  * - \e outmask |= Rhumb::DISTANCE for the latitude \e s12;
303  * - \e outmask |= Rhumb::AZIMUTH for the latitude \e azi12;
304  * - \e outmask |= Rhumb::AREA for the area \e S12;
305  * - \e outmask |= Rhumb::ALL for all of the above;
306  **********************************************************************/
307  void GenInverse(double lat1, double lon1, double lat2, double lon2,
308  Rhumb::mask outmask,
309  [System::Runtime::InteropServices::Out] double% s12,
310  [System::Runtime::InteropServices::Out] double% azi12,
311  [System::Runtime::InteropServices::Out] double% S12);
312 
313  /**
314  * Set up to compute several points on a single rhumb line.
315  *
316  * @param[in] lat1 latitude of point 1 (degrees).
317  * @param[in] lon1 longitude of point 1 (degrees).
318  * @param[in] azi12 azimuth of the rhumb line (degrees).
319  * @return a RhumbLine object.
320  *
321  * \e lat1 should be in the range [&minus;90&deg;, 90&deg;]; \e lon1 and \e
322  * azi12 should be in the range [&minus;540&deg;, 540&deg;).
323  *
324  * If point 1 is a pole, the cosine of its latitude is taken to be
325  * 1/&epsilon;<sup>2</sup> (where &epsilon; is 2<sup>-52</sup>). This
326  * position, which is extremely close to the actual pole, allows the
327  * calculation to be carried out in finite terms.
328  **********************************************************************/
329  RhumbLine^ Line(double lat1, double lon1, double azi12);
330 
331  /** \name Inspector functions.
332  **********************************************************************/
333  ///@{
334 
335  /**
336  * @return the equatorial radius of the ellipsoid (meters). This is
337  * the value used in the constructor.
338  **********************************************************************/
339  property double MajorRadius { double get(); }
340 
341  /**
342  * @return f the flattening of the ellipsoid. This is the
343  * value used in the constructor.
344  **********************************************************************/
345  property double Flattening { double get(); }
346 
347  /**
348  * @return the area of the ellipsoid.
349  **********************************************************************/
350  property double EllipsoidArea { double get(); }
351 
352  /**
353  * %return The unmanaged pointer to the GeographicLib::Geodesic.
354  *
355  * This function is for internal use only.
356  **********************************************************************/
357  System::IntPtr^ GetUnmanaged();
358 
359  /**
360  * A global instantiation of Rhumb with the parameters for the WGS84
361  * ellipsoid.
362  **********************************************************************/
363  static Rhumb^ WGS84();
364  };
365 
366  /**
367  * \brief .NET wrapper for GeographicLib::RhumbLine.
368  *
369  * This class allows .NET applications to access GeographicLib::RhumbLine.
370  *
371  * Find a sequence of points on a single rhumb line.
372  *
373  * RhumbLine facilitates the determination of a series of points on a single
374  * rhumb line. The starting point (\e lat1, \e lon1) and the azimuth \e
375  * azi12 are specified in the call to Rhumb::Line which returns a RhumbLine
376  * object. RhumbLine.Position returns the location of point 2 a distance \e
377  * s12 along the rhumb line.
378 
379  * There is no public constructor for this class. (Use Rhumb::Line to create
380  * an instance.) The Rhumb object used to create a RhumbLine must stay in
381  * scope as long as the RhumbLine.
382  *
383  **********************************************************************/
384 
385  public ref class RhumbLine {
386  private:
387  // pointer to the unmanaged RhumbLine object.
388  GeographicLib::RhumbLine* m_pRhumbLine;
389 
390  // The finalizer destroys m_pRhumbLine when this object is destroyed.
391  !RhumbLine(void);
392  public:
393  enum class mask {
394  /**
395  * No output.
396  * @hideinitializer
397  **********************************************************************/
398  NONE = 0, //NETGeographicLib::Rhumb::NONE,
399  /**
400  * Calculate latitude \e lat2.
401  * @hideinitializer
402  **********************************************************************/
403  LATITUDE = 1U<<7, //Rhumb::LATITUDE,
404  /**
405  * Calculate longitude \e lon2.
406  * @hideinitializer
407  **********************************************************************/
408  LONGITUDE = 1U<<8, //Rhumb::LONGITUDE,
409  /**
410  * Calculate azimuth \e azi12.
411  * @hideinitializer
412  **********************************************************************/
413  AZIMUTH = 1U<<9, //Rhumb::AZIMUTH,
414  /**
415  * Calculate distance \e s12.
416  * @hideinitializer
417  **********************************************************************/
418  DISTANCE = 1U<<10, //Rhumb::DISTANCE,
419  /**
420  * Calculate area \e S12.
421  * @hideinitializer
422  **********************************************************************/
423  AREA = 1U<<14, //Rhumb::AREA,
424  /**
425  * Unroll \e lon2 in the direct calculation. (This flag used to be
426  * called LONG_NOWRAP.)
427  * @hideinitializer
428  **********************************************************************/
429  LONG_UNROLL = 1U<<15, //Rhumb::LONG_UNROLL,
431  /**
432  * Calculate everything. (LONG_UNROLL is not included in this mask.)
433  * @hideinitializer
434  **********************************************************************/
435  ALL = 0x7F80U, //Rhumb::ALL,
436  };
437  /**
438  * \brief Constructor.
439  *
440  * For internal use only. Developers should not call this constructor
441  * directly. Use the Rhumb::Line function to create RhumbLine objects.
442  **********************************************************************/
443  RhumbLine( GeographicLib::RhumbLine* pRhumbLine );
444 
445  /**
446  * \brief The destructor calls the finalizer.
447  **********************************************************************/
448  ~RhumbLine() { this->!RhumbLine(); }
449 
450  /**
451  * Compute the position of point 2 which is a distance \e s12 (meters) from
452  * point 1. The area is also computed.
453  *
454  * @param[in] s12 distance between point 1 and point 2 (meters); it can be
455  * negative.
456  * @param[out] lat2 latitude of point 2 (degrees).
457  * @param[out] lon2 longitude of point 2 (degrees).
458  * @param[out] S12 area under the rhumb line (meters<sup>2</sup>).
459  *
460  * The value of \e lon2 returned is in the range [&minus;180&deg;,
461  * 180&deg;).
462  *
463  * If \e s12 is large enough that the rhumb line crosses a pole, the
464  * longitude of point 2 is indeterminate (a NaN is returned for \e lon2 and
465  * \e S12).
466  **********************************************************************/
467  void Position(double s12,
468  [System::Runtime::InteropServices::Out] double% lat2,
469  [System::Runtime::InteropServices::Out] double% lon2,
470  [System::Runtime::InteropServices::Out] double% S12);
471 
472  /**
473  * Compute the position of point 2 which is a distance \e s12 (meters) from
474  * point 1.
475  *
476  * @param[in] s12 distance between point 1 and point 2 (meters); it can be
477  * negative.
478  * @param[out] lat2 latitude of point 2 (degrees).
479  * @param[out] lon2 longitude of point 2 (degrees).
480  *
481  * The values of \e lon2 and \e azi2 returned are in the range
482  * [&minus;180&deg;, 180&deg;).
483  *
484  * If \e s12 is large enough that the rhumb line crosses a pole, the
485  * longitude of point 2 is indeterminate (a NaN is returned for \e lon2).
486  **********************************************************************/
487  void Position(double s12,
488  [System::Runtime::InteropServices::Out] double% lat2,
489  [System::Runtime::InteropServices::Out] double% lon2);
490 
491  /**
492  * The general position routine. RhumbLine::Position is defined in term so
493  * this function.
494  *
495  * @param[in] s12 distance between point 1 and point 2 (meters); it can be
496  * negative.
497  * @param[in] outmask a bitor'ed combination of RhumbLine::mask values
498  * specifying which of the following parameters should be set.
499  * @param[out] lat2 latitude of point 2 (degrees).
500  * @param[out] lon2 longitude of point 2 (degrees).
501  * @param[out] S12 area under the rhumb line (meters<sup>2</sup>).
502  *
503  * The RhumbLine::mask values possible for \e outmask are
504  * - \e outmask |= RhumbLine::LATITUDE for the latitude \e lat2;
505  * - \e outmask |= RhumbLine::LONGITUDE for the latitude \e lon2;
506  * - \e outmask |= RhumbLine::AREA for the area \e S12;
507  * - \e outmask |= RhumbLine::ALL for all of the above;
508  * - \e outmask |= RhumbLine::LONG_UNROLL to unroll \e lon2 instead of
509  * wrapping it into the range [&minus;180&deg;, 180&deg;).
510  * .
511  * With the LONG_UNROLL bit set, the quantity \e lon2 &minus; \e lon1
512  * indicates how many times and in what sense the rhumb line encircles the
513  * ellipsoid. Because \e lon2 might be outside the normal allowed range
514  * for longitudes, [&minus;540&deg;, 540&deg;), be sure to normalize it
515  * with Math::AngNormalize2 before using it in other GeographicLib calls.
516  *
517  * If \e s12 is large enough that the rhumb line crosses a pole, the
518  * longitude of point 2 is indeterminate (a NaN is returned for \e lon2 and
519  * \e S12).
520  **********************************************************************/
521  void GenPosition(double s12, RhumbLine::mask outmask,
522  [System::Runtime::InteropServices::Out] double% lat2,
523  [System::Runtime::InteropServices::Out] double% lon2,
524  [System::Runtime::InteropServices::Out] double% S12);
525 
526  /** \name Inspector functions
527  **********************************************************************/
528  ///@{
529 
530  /**
531  * @return the latitude of point 1 (degrees).
532  **********************************************************************/
533  property double Latitude { double get(); }
534 
535  /**
536  * @return the longitude of point 1 (degrees).
537  **********************************************************************/
538  property double Longitude { double get(); }
539 
540  /**
541  * @return the azimuth of the rhumb line (degrees).
542  **********************************************************************/
543  property double Azimuth { double get(); }
544 
545  /**
546  * @return the equatorial radius of the ellipsoid (meters). This is
547  * the value inherited from the Rhumb object used in the constructor.
548  **********************************************************************/
549  property double MajorRadius { double get(); }
550 
551  /**
552  * @return the flattening of the ellipsoid. This is the value
553  * inherited from the Rhumb object used in the constructor.
554  **********************************************************************/
555  property double Flattening { double get(); }
556  };
557 
558 } // namespace NETGeographicLib
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)
void Position(double s12, [System::Runtime::InteropServices::Out] double% lat2, [System::Runtime::InteropServices::Out] double% lon2, [System::Runtime::InteropServices::Out] double% S12)
RhumbLine(GeographicLib::RhumbLine *pRhumbLine)
Constructor.
.NET wrapper for GeographicLib::RhumbLine.
Definition: Rhumb.h:385
static Rhumb^ WGS84()
~Rhumb()
The destructor calls the finalizer.
Definition: Rhumb.h:143
RhumbLine^ Line(double lat1, double lon1, double azi12)
Rhumb(double a, double f, bool exact)
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)
System::IntPtr^ GetUnmanaged()
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)
.NET wrapper for GeographicLib::Rhumb.
Definition: Rhumb.h:65
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)
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)
~RhumbLine()
The destructor calls the finalizer.
Definition: Rhumb.h:448