NETGeographicLib 1.52
Loading...
Searching...
No Matches
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
13namespace 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
.NET wrapper for GeographicLib::RhumbLine.
Definition: Rhumb.h:374
void Position(double s12, [System::Runtime::InteropServices::Out] double% lat2, [System::Runtime::InteropServices::Out] double% lon2)
RhumbLine(GeographicLib::RhumbLine *pRhumbLine)
Constructor.
void Position(double s12, [System::Runtime::InteropServices::Out] double% lat2, [System::Runtime::InteropServices::Out] double% lon2, [System::Runtime::InteropServices::Out] double% S12)
~RhumbLine()
The destructor calls the finalizer.
Definition: Rhumb.h:435
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)
.NET wrapper for GeographicLib::Rhumb.
Definition: Rhumb.h:65
void Direct(double lat1, double lon1, double azi12, double s12, [System::Runtime::InteropServices::Out] double% lat2, [System::Runtime::InteropServices::Out] double% lon2)
void Inverse(double lat1, double lon1, double lat2, double lon2, [System::Runtime::InteropServices::Out] double% s12, [System::Runtime::InteropServices::Out] double% azi12)
RhumbLine ^ Line(double lat1, double lon1, double azi12)
System::IntPtr ^ GetUnmanaged()
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)
double EquatorialRadius
Definition: Rhumb.h:328
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)
static Rhumb ^ WGS84()
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)
Rhumb(double a, double f, bool exact)
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)
~Rhumb()
The destructor calls the finalizer.
Definition: Rhumb.h:140