NETGeographicLib::Rhumb Class Reference

.NET wrapper for GeographicLib::Rhumb. More...

#include <NETGeographicLib/Rhumb.h>

List of all members.

Public Member Functions

 Rhumb (double a, double f, bool exact)
 ~Rhumb ()
 The destructor calls the finalizer.
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)
RhumbLineLine (double lat1, double lon1, double azi12)

Inspector functions.



double MajorRadius [get]
double Flattening [get]
static RhumbWGS84 ()

Detailed Description

.NET wrapper for GeographicLib::Rhumb.

This class allows .NET applications to access GeographicLib::Rhumb.

Solve of the direct and inverse rhumb problems.

The path of constant azimuth between two points on a ellipsoid at (lat1, lon1) and (lat2, lon2) is called the rhumb line (also called the loxodrome). Its length is s12 and its azimuth is azi12 and azi2. (The azimuth is the heading measured clockwise from north.)

Given lat1, lon1, azi12, and s12, we can determine lat2, and lon2. This is the direct rhumb problem and its solution is given by the function Rhumb::Direct.

Given lat1, lon1, lat2, and lon2, we can determine azi12 and s12. This is the inverse rhumb problem, whose solution is given by Rhumb::Inverse. This finds the shortest such rhumb line, i.e., the one that wraps no more than half way around the earth .

Note that rhumb lines may be appreciably longer (up to 50%) than the corresponding Geodesic. For example the distance between London Heathrow and Tokyo Narita via the rhumb line is 11400 km which is 18% longer than the geodesic distance 9600 km.

For more information on rhumb lines see Rhumb lines.

C# Example:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NETGeographicLib;

namespace example_Rhumb
{
    class Program
    {
        static void Main(string[] args)
        {
            try {
            Rhumb rhumb = new Rhumb(Constants.WGS84.MajorRadius, Constants.WGS84.Flattening, true);
            // Alternatively: const Rhumb& rhumb = Rhumb::WGS84();
            {
                // Sample direct calculation, travelling about NE from JFK
                double lat1 = 40.6, lon1 = -73.8, s12 = 5.5e6, azi12 = 51;
                double lat2, lon2;
                rhumb.Direct(lat1, lon1, azi12, s12, out lat2, out lon2);
                    Console.WriteLine( "{0} {1}", lat2, lon2 );
            }
            {
                // Sample inverse calculation, JFK to LHR
                double
                lat1 = 40.6, lon1 = -73.8, // JFK Airport
                lat2 = 51.6, lon2 = -0.5;  // LHR Airport
                double s12, azi12;
                rhumb.Inverse(lat1, lon1, lat2, lon2, out s12, out azi12);
                    Console.WriteLine( "{0} {1}", s12, azi12 );
            }
            }
            catch (GeographicErr e) {
                Console.WriteLine(String.Format("Caught exception: {0}", e.Message));
            }
        }
    }
}

Managed C++ Example:

using namespace System;
using namespace NETGeographicLib;

int main(array<System::String ^> ^/*args*/
)
{
  try {
    Rhumb^ rhumb = gcnew Rhumb(Constants::WGS84::MajorRadius, Constants::WGS84::Flattening, true);
    // Alternatively: const Rhumb& rhumb = Rhumb::WGS84();
    {
      // Sample direct calculation, travelling about NE from JFK
      double lat1 = 40.6, lon1 = -73.8, s12 = 5.5e6, azi12 = 51;
      double lat2, lon2;
      rhumb->Direct(lat1, lon1, azi12, s12, lat2, lon2);
      Console::WriteLine( "{0} {1}", lat2, lon2 );
    }
    {
      // Sample inverse calculation, JFK to LHR
      double
        lat1 = 40.6, lon1 = -73.8, // JFK Airport
        lat2 = 51.6, lon2 = -0.5;  // LHR Airport
      double s12, azi12;
      rhumb->Inverse(lat1, lon1, lat2, lon2, s12, azi12);
      Console::WriteLine( "{0} {1}", s12, azi12 );
    }
  }
  catch (GeographicErr^ e) {
      Console::WriteLine(String::Format("Caught exception: {0}", e->Message));
      return -1;
  }
  return 0;
}

Visual Basic Example:

Imports NETGeographicLib

Module example_Rhumb
    Sub Main()
        Try
            Dim rhumb As Rhumb = New Rhumb(Constants.WGS84.MajorRadius, Constants.WGS84.Flattening, True)
            ' Alternatively: const Rhumb& rhumb = Rhumb::WGS84();

            ' Sample direct calculation, travelling about NE from JFK
            Dim lat1 As Double = 40.6, lon1 = -73.8, s12 = 5500000.0, azi12 = 51
            Dim lat2 As Double, lon2
            rhumb.Direct(lat1, lon1, azi12, s12, lat2, lon2)
            Console.WriteLine("{0} {1}", lat2, lon2)

            ' Sample inverse calculation, JFK to LHR
            lat1 = 40.6 : lon1 = -73.8 ' JFK Airport
            lat2 = 51.6 : lon2 = -0.5  ' LHR Airport
            rhumb.Inverse(lat1, lon1, lat2, lon2, s12, azi12)
            Console.WriteLine("{0} {1}", s12, azi12)
        Catch ex As GeographicErr
            Console.WriteLine(String.Format("Caught exception: {0}", ex.Message))
        End Try
    End Sub
End Module

INTERFACE DIFFERENCES:
The MajorRadius and Flattening functions are implemented as properties.

Definition at line 56 of file Rhumb.h.


Constructor & Destructor Documentation

NETGeographicLib::Rhumb::Rhumb ( double  a,
double  f,
bool  exact 
)

Constructor for a ellipsoid with

Parameters:
[in] a equatorial radius (meters).
[in] f flattening of ellipsoid. Setting f = 0 gives a sphere. Negative f gives a prolate ellipsoid. If f > 1, set flattening to 1/f.
[in] exact if true (the default) use an addition theorem for elliptic integrals to compute divided differences; otherwise use series expansion (accurate for |f| < 0.01).
Exceptions:
GeographicErr if a or (1 f) a is not positive.

See Rhumb lines, for a detailed description of the exact parameter.

Referenced by ~Rhumb().

NETGeographicLib::Rhumb::~Rhumb (  )  [inline]

The destructor calls the finalizer.

Definition at line 85 of file Rhumb.h.

References Rhumb().


Member Function Documentation

void NETGeographicLib::Rhumb::Direct ( double  lat1,
double  lon1,
double  azi12,
double  s12,
[System::Runtime::InteropServices::Out] double%   lat2,
[System::Runtime::InteropServices::Out] double%   lon2 
)

Solve the direct rhumb problem.

Parameters:
[in] lat1 latitude of point 1 (degrees).
[in] lon1 longitude of point 1 (degrees).
[in] azi12 azimuth of the rhumb line (degrees).
[in] s12 distance between point 1 and point 2 (meters); it can be negative.
[out] lat2 latitude of point 2 (degrees).
[out] lon2 longitude of point 2 (degrees).

lat1 should be in the range [90, 90]; lon1 and azi1 should be in the range [540, 540). The values of lon2 and azi2 returned are in the range [180, 180).

If point 1 is a pole, the cosine of its latitude is taken to be 1/2 (where is 2-52). This position, which is extremely close to the actual pole, allows the calculation to be carried out in finite terms. If s12 is large enough that the rhumb line crosses a pole, the longitude of point 2 is indeterminate (a NaN is returned for lon2).

void NETGeographicLib::Rhumb::Inverse ( double  lat1,
double  lon1,
double  lat2,
double  lon2,
[System::Runtime::InteropServices::Out] double%   s12,
[System::Runtime::InteropServices::Out] double%   azi12 
)

Solve the inverse rhumb problem.

Parameters:
[in] lat1 latitude of point 1 (degrees).
[in] lon1 longitude of point 1 (degrees).
[in] lat2 latitude of point 2 (degrees).
[in] lon2 longitude of point 2 (degrees).
[out] s12 rhumb distance between point 1 and point 2 (meters).
[out] azi12 azimuth of the rhumb line (degrees).

The shortest rhumb line is found. lat1 and lat2 should be in the range [90, 90]; lon1 and lon2 should be in the range [540, 540). The value of azi12 returned is in the range [180, 180).

If either point is a pole, the cosine of its latitude is taken to be 1/2 (where is 2-52). This position, which is extremely close to the actual pole, allows the calculation to be carried out in finite terms.

RhumbLine ^ NETGeographicLib::Rhumb::Line ( double  lat1,
double  lon1,
double  azi12 
)

Set up to compute several points on a single rhumb line.

Parameters:
[in] lat1 latitude of point 1 (degrees).
[in] lon1 longitude of point 1 (degrees).
[in] azi12 azimuth of the rhumb line (degrees).
Returns:
a RhumbLine object.

lat1 should be in the range [90, 90]; lon1 and azi12 should be in the range [540, 540).

If point 1 is a pole, the cosine of its latitude is taken to be 1/2 (where is 2-52). This position, which is extremely close to the actual pole, allows the calculation to be carried out in finite terms.

static Rhumb ^ NETGeographicLib::Rhumb::WGS84 (  )  [static]

A global instantiation of Rhumb with the parameters for the WGS84 ellipsoid.


Property Documentation

double NETGeographicLib::Rhumb::MajorRadius [get]
Returns:
the equatorial radius of the ellipsoid (meters). This is the value used in the constructor.

Definition at line 164 of file Rhumb.h.

double NETGeographicLib::Rhumb::Flattening [get]
Returns:
f the flattening of the ellipsoid. This is the value used in the constructor.

Definition at line 170 of file Rhumb.h.


The documentation for this class was generated from the following file:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends

Generated on 6 Oct 2014 for NETGeographicLib by  doxygen 1.6.1