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