public void GeodSolve17()
{
// Check fix for LONG_UNROLL bug found on 2015-05-07
GeodesicData dir =
Geodesic.WGS84.Direct(40, -75, -10, 2e7,
GeodesicMask.STANDARD | GeodesicMask.LONG_UNROLL);
AssertEquals(dir.lat2, -39, 1);
AssertEquals(dir.lon2, -254, 1);
AssertEquals(dir.azi2, -170, 1);
GeodesicLine line = Geodesic.WGS84.Line(40, -75, -10);
dir = line.Position(2e7, GeodesicMask.STANDARD | GeodesicMask.LONG_UNROLL);
AssertEquals(dir.lat2, -39, 1);
AssertEquals(dir.lon2, -254, 1);
AssertEquals(dir.azi2, -170, 1);
dir = Geodesic.WGS84.Direct(40, -75, -10, 2e7);
AssertEquals(dir.lat2, -39, 1);
AssertEquals(dir.lon2, 105, 1);
AssertEquals(dir.azi2, -170, 1);
dir = line.Position(2e7);
AssertEquals(dir.lat2, -39, 1);
AssertEquals(dir.lon2, 105, 1);
AssertEquals(dir.azi2, -170, 1);
}
public void GeodSolve26()
{
// Check 0/0 problem with area calculation on sphere 2015-09-08
Geodesic geod = new Geodesic(6.4e6, 0);
GeodesicData inv = geod.Inverse(1, 2, 3, 4, GeodesicMask.AREA);
AssertEquals(inv.S12, 49911046115.0, 0.5);
}
public void GeodSolve4()
{
// Check fix for short line bug found 2010-05-21
GeodesicData inv = Geodesic.WGS84.Inverse(36.493349428792, 0,
36.49334942879201, .0000008);
AssertEquals(inv.s12, 0.072, 0.5e-3);
}
public void GeodSolve1()
{
GeodesicData dir = Geodesic.WGS84.Direct(40.63972222, -73.77888889,
53.5, 5850e3);
AssertEquals(dir.lat2, 49.01467, 0.5e-5);
AssertEquals(dir.lon2, 2.56106, 0.5e-5);
AssertEquals(dir.azi2, 111.62947, 0.5e-5);
}
public void GeodSolve0()
{
GeodesicData inv = Geodesic.WGS84.Inverse(40.6, -73.8,
49.01666667, 2.55);
AssertEquals(inv.azi1, 53.47022, 0.5e-5);
AssertEquals(inv.azi2, 111.59367, 0.5e-5);
AssertEquals(inv.s12, 5853226, 0.5);
}
public void GeodSolve15()
{
// Initial implementation of Math::eatanhe was wrong for e^2 < 0. This
// checks that this is fixed.
Geodesic geod = new Geodesic(6.4e6, -1 / 150.0);
GeodesicData dir = geod.Direct(1, 2, 3, 4, GeodesicMask.AREA);
AssertEquals(dir.S12, 23700, 0.5);
}
public void GeodSolve78()
{
// An example where the NGS calculator fails to converge */
GeodesicData inv = Geodesic.WGS84.Inverse(27.2, 0.0, -27.1, 179.5);
AssertEquals(inv.azi1, 45.82468716758, 0.5e-11);
AssertEquals(inv.azi2, 134.22776532670, 0.5e-11);
AssertEquals(inv.s12, 19974354.765767, 0.5e-6);
}
public void GeodSolve59()
{
// Check for points close with longitudes close to 180 deg apart.
GeodesicData inv = Geodesic.WGS84.Inverse(5, 0.00000000000001, 10, 180);
AssertEquals(inv.azi1, 0.000000000000035, 1.5e-14);
AssertEquals(inv.azi2, 179.99999999999996, 1.5e-14);
AssertEquals(inv.s12, 18345191.174332713, 4e-9);
}
public void GeodSolve14()
{
// Check fix for inverse ignoring lon12 = nan
GeodesicData inv = Geodesic.WGS84.Inverse(0, 0, 1, Double.NaN);
Assert.True(IsNaN(inv.azi1));
Assert.True(IsNaN(inv.azi2));
Assert.True(IsNaN(inv.s12));
}
public void GeodSolve9()
{
// Check fix for volatile x bug found 2011-06-25 (gcc 4.4.4 x86 -O3)
GeodesicData inv =
Geodesic.WGS84.Inverse(56.320923501171, 0,
-56.320923501171, 179.664747671772880215);
AssertEquals(inv.s12, 19993558.287, 0.5e-3);
}
public void GeodSolve28()
{
// Check for bad placement of assignment of r.a12 with |f| > 0.01 (bug in
// Java implementation fixed on 2015-05-19).
Geodesic geod = new Geodesic(6.4e6, 0.1);
GeodesicData dir = geod.Direct(1, 2, 10, 5e6);
AssertEquals(dir.a12, 48.55570690, 0.5e-8);
}
public void GeodSolve11()
{
// Check fix for bet2 = -bet1 bug found 2011-06-25 (Visual Studio
// 10 rel + debug)
GeodesicData inv =
Geodesic.WGS84.Inverse(48.522876735459, 0,
-48.52287673545898293, 179.599720456223079643);
AssertEquals(inv.s12, 19989144.774, 0.5e-3);
}
public void GeodSolve10()
{
// Check fix for adjust tol1_ bug found 2011-06-25 (Visual Studio
// 10 rel + debug)
GeodesicData inv =
Geodesic.WGS84.Inverse(52.784459512564, 0,
-52.784459512563990912, 179.634407464943777557);
AssertEquals(inv.s12, 19991596.095, 0.5e-3);
}
public void GeodSolve73()
{
// Check for backwards from the pole bug reported by Anon on 2016-02-13.
// This only affected the Java implementation. It was introduced in Java
// version 1.44 and fixed in 1.46-SNAPSHOT on 2016-01-17.
GeodesicData dir = Geodesic.WGS84.Direct(90, 10, 180, -1e6);
AssertEquals(dir.lat2, 81.04623, 0.5e-5);
AssertEquals(dir.lon2, -170, 0.5e-5);
AssertEquals(dir.azi2, 0, 0.5e-5);
}
public void GeodSolve76()
{
// The distance from Wellington and Salamanca (a classic failure of
// Vincenty)
GeodesicData inv = Geodesic.WGS84.Inverse(-(41 + 19 / 60.0), 174 + 49 / 60.0,
40 + 58 / 60.0, -(5 + 30 / 60.0));
AssertEquals(inv.azi1, 160.39137649664, 0.5e-11);
AssertEquals(inv.azi2, 19.50042925176, 0.5e-11);
AssertEquals(inv.s12, 19960543.857179, 0.5e-6);
}
public void GeodSolve33()
{
// Check max(-0.0,+0.0) issues 2015-08-22 (triggered by bugs in Octave --
// sind(-0.0) = +0.0 -- and in some version of Visual Studio --
// fmod(-0.0, 360.0) = +0.0.
GeodesicData inv = Geodesic.WGS84.Inverse(0, 0, 0, 179);
AssertEquals(inv.azi1, 90.00000, 0.5e-5);
AssertEquals(inv.azi2, 90.00000, 0.5e-5);
AssertEquals(inv.s12, 19926189, 0.5);
inv = Geodesic.WGS84.Inverse(0, 0, 0, 179.5);
AssertEquals(inv.azi1, 55.96650, 0.5e-5);
AssertEquals(inv.azi2, 124.03350, 0.5e-5);
AssertEquals(inv.s12, 19980862, 0.5);
inv = Geodesic.WGS84.Inverse(0, 0, 0, 180);
AssertEquals(inv.azi1, 0.00000, 0.5e-5);
AssertEquals(Math.Abs(inv.azi2), 180.00000, 0.5e-5);
AssertEquals(inv.s12, 20003931, 0.5);
inv = Geodesic.WGS84.Inverse(0, 0, 1, 180);
AssertEquals(inv.azi1, 0.00000, 0.5e-5);
AssertEquals(Math.Abs(inv.azi2), 180.00000, 0.5e-5);
AssertEquals(inv.s12, 19893357, 0.5);
Geodesic geod = new Geodesic(6.4e6, 0);
inv = geod.Inverse(0, 0, 0, 179);
AssertEquals(inv.azi1, 90.00000, 0.5e-5);
AssertEquals(inv.azi2, 90.00000, 0.5e-5);
AssertEquals(inv.s12, 19994492, 0.5);
inv = geod.Inverse(0, 0, 0, 180);
AssertEquals(inv.azi1, 0.00000, 0.5e-5);
AssertEquals(Math.Abs(inv.azi2), 180.00000, 0.5e-5);
AssertEquals(inv.s12, 20106193, 0.5);
inv = geod.Inverse(0, 0, 1, 180);
AssertEquals(inv.azi1, 0.00000, 0.5e-5);
AssertEquals(Math.Abs(inv.azi2), 180.00000, 0.5e-5);
AssertEquals(inv.s12, 19994492, 0.5);
geod = new Geodesic(6.4e6, -1 / 300.0);
inv = geod.Inverse(0, 0, 0, 179);
AssertEquals(inv.azi1, 90.00000, 0.5e-5);
AssertEquals(inv.azi2, 90.00000, 0.5e-5);
AssertEquals(inv.s12, 19994492, 0.5);
inv = geod.Inverse(0, 0, 0, 180);
AssertEquals(inv.azi1, 90.00000, 0.5e-5);
AssertEquals(inv.azi2, 90.00000, 0.5e-5);
AssertEquals(inv.s12, 20106193, 0.5);
inv = geod.Inverse(0, 0, 0.5, 180);
AssertEquals(inv.azi1, 33.02493, 0.5e-5);
AssertEquals(inv.azi2, 146.97364, 0.5e-5);
AssertEquals(inv.s12, 20082617, 0.5);
inv = geod.Inverse(0, 0, 1, 180);
AssertEquals(inv.azi1, 0.00000, 0.5e-5);
AssertEquals(Math.Abs(inv.azi2), 180.00000, 0.5e-5);
AssertEquals(inv.s12, 20027270, 0.5);
}
public void GeodSolve71()
{
// Check that DirectLine sets s13.
GeodesicLine line = Geodesic.WGS84.DirectLine(1, 2, 45, 1e7);
GeodesicData dir =
line.Position(0.5 * line.Distance(),
GeodesicMask.STANDARD | GeodesicMask.LONG_UNROLL);
AssertEquals(dir.lat2, 30.92625, 0.5e-5);
AssertEquals(dir.lon2, 37.54640, 0.5e-5);
AssertEquals(dir.azi2, 55.43104, 0.5e-5);
}
public void GeodSolve12()
{
// Check fix for inverse geodesics on extreme prolate/oblate
// ellipsoids Reported 2012-08-29 Stefan Guenther
// <*****@*****.**>; fixed 2012-10-07
Geodesic geod = new Geodesic(89.8, -1.83);
GeodesicData inv = geod.Inverse(0, 0, -10, 160);
AssertEquals(inv.azi1, 120.27, 1e-2);
AssertEquals(inv.azi2, 105.15, 1e-2);
AssertEquals(inv.s12, 266.7, 1e-1);
}
public void JFKToCANShouldPass()
{
Pair jfk = new Pair(40.639801, -73.7789002);
Pair can = new Pair(23.3924007, 113.2990036);
GeodesicData g = Geodesic.WGS84.Inverse(jfk.First, jfk.Second, can.First, can.Second, GeodesicMask.ALL);
Assert.NotNull(g);
double expectedDistance = 12877.8358;
double actualDistance = g.Distance / 1000.0;
Assert.True(Math.Abs(actualDistance - expectedDistance) <= 0.0001);
}
public void GeodSolve2()
{
// Check fix for antipodal prolate bug found 2010-09-04
Geodesic geod = new Geodesic(6.4e6, -1 / 150.0);
GeodesicData inv = geod.Inverse(0.07476, 0, -0.07476, 180);
AssertEquals(inv.azi1, 90.00078, 0.5e-5);
AssertEquals(inv.azi2, 90.00078, 0.5e-5);
AssertEquals(inv.s12, 20106193, 0.5);
inv = geod.Inverse(0.1, 0, -0.1, 180);
AssertEquals(inv.azi1, 90.00105, 0.5e-5);
AssertEquals(inv.azi2, 90.00105, 0.5e-5);
AssertEquals(inv.s12, 20106193, 0.5);
}
public void GeodSolve55()
{
// Check fix for nan + point on equator or pole not returning all nans in
// Geodesic::Inverse, found 2015-09-23.
GeodesicData inv = Geodesic.WGS84.Inverse(Double.NaN, 0, 0, 90);
Assert.True(IsNaN(inv.azi1));
Assert.True(IsNaN(inv.azi2));
Assert.True(IsNaN(inv.s12));
inv = Geodesic.WGS84.Inverse(Double.NaN, 0, 90, 3);
Assert.True(IsNaN(inv.azi1));
Assert.True(IsNaN(inv.azi2));
Assert.True(IsNaN(inv.s12));
}
public void GeodSolve29()
{
// Check longitude unrolling with inverse calculation 2015-09-16
GeodesicData dir = Geodesic.WGS84.Inverse(0, 539, 0, 181);
AssertEquals(dir.lon1, 179, 1e-10);
AssertEquals(dir.lon2, -179, 1e-10);
AssertEquals(dir.s12, 222639, 0.5);
dir = Geodesic.WGS84.Inverse(0, 539, 0, 181,
GeodesicMask.STANDARD |
GeodesicMask.LONG_UNROLL);
AssertEquals(dir.lon1, 539, 1e-10);
AssertEquals(dir.lon2, 541, 1e-10);
AssertEquals(dir.s12, 222639, 0.5);
}
public void GeodSolve6()
{
// Check fix for volatile sbet12a bug found 2011-06-25 (gcc 4.4.4
// x86 -O3). Found again on 2012-03-27 with tdm-mingw32 (g++ 4.6.1).
GeodesicData inv =
Geodesic.WGS84.Inverse(88.202499451857, 0,
-88.202499451857, 179.981022032992859592);
AssertEquals(inv.s12, 20003898.214, 0.5e-3);
inv = Geodesic.WGS84.Inverse(89.262080389218, 0,
-89.262080389218, 179.992207982775375662);
AssertEquals(inv.s12, 20003925.854, 0.5e-3);
inv = Geodesic.WGS84.Inverse(89.333123580033, 0, -89.333123580032997687,
179.99295812360148422);
AssertEquals(inv.s12, 20003926.881, 0.5e-3);
}
public void TestJFKToLHR()
{
Pair jfk = new Pair(40.639801, -73.7789002);
Pair lhr = new Pair(51.4706001, -0.461941);
GeodesicData g = Geodesic.WGS84.Inverse(jfk.First, jfk.Second, lhr.First, lhr.Second, GeodesicMask.ALL);
Assert.IsNotNull(g);
double expectedDistance = 5554.539; //in kilometers
double actualDistance = g.Distance / 1000.0;
Assert.IsTrue(Math.Abs(actualDistance - expectedDistance) <= 0.001);
double expectedInitialCourse = 51.38;
double actualInitialCourse = g.InitialAzimuth;
Assert.IsTrue(Math.Abs(actualInitialCourse - expectedInitialCourse) <= 0.01);
}
public void GeodSolve74()
{
// Check fix for inaccurate areas, bug introduced in v1.46, fixed
// 2015-10-16.
GeodesicData inv = Geodesic.WGS84.Inverse(54.1589, 15.3872,
54.1591, 15.3877,
GeodesicMask.ALL);
AssertEquals(inv.azi1, 55.723110355, 5e-9);
AssertEquals(inv.azi2, 55.723515675, 5e-9);
AssertEquals(inv.s12, 39.527686385, 5e-9);
AssertEquals(inv.a12, 0.000355495, 5e-9);
AssertEquals(inv.m12, 39.527686385, 5e-9);
AssertEquals(inv.M12, 0.999999995, 5e-9);
AssertEquals(inv.M21, 0.999999995, 5e-9);
AssertEquals(inv.S12, 286698586.30197, 5e-4);
}
public void GeodSolve5()
{
// Check fix for point2=pole bug found 2010-05-03
GeodesicData dir = Geodesic.WGS84.Direct(0.01777745589997, 30, 0, 10e6);
AssertEquals(dir.lat2, 90, 0.5e-5);
if (dir.lon2 < 0)
{
AssertEquals(dir.lon2, -150, 0.5e-5);
AssertEquals(Math.Abs(dir.azi2), 180, 0.5e-5);
}
else
{
AssertEquals(dir.lon2, 30, 0.5e-5);
AssertEquals(dir.azi2, 0, 0.5e-5);
}
}
/**
* Solve the direct geodesic problem.
*
* This program reads in lines with lat1, lon1, azi1, s12 and prints out lines
* with lat2, lon2, azi2 (for the WGS84 ellipsoid).
**********************************************************************/
public static void main(String[] args)
{
try
{
var inp = (from arg in args select double.Parse(arg)).GetEnumerator();
double lat1, lon1, azi1, s12;
while (inp.MoveNext())
{
lat1 = inp.Current; inp.MoveNext();
lon1 = inp.Current; inp.MoveNext();
azi1 = inp.Current; inp.MoveNext();
s12 = inp.Current;
GeodesicData g = Geodesic.WGS84.Direct(lat1, lon1, azi1, s12);
Console.WriteLine(g.lat2 + " " + g.lon2 + " " + g.azi2);
}
}
catch (Exception e) { }
}
public void GeodSolve69()
{
// Check for InverseLine if line is slightly west of S and that s13 is
// correctly set.
GeodesicLine line =
Geodesic.WGS84.InverseLine(-5, -0.000000000000002, -10, 180);
GeodesicData dir =
line.Position(2e7, GeodesicMask.STANDARD | GeodesicMask.LONG_UNROLL);
AssertEquals(dir.lat2, 4.96445, 0.5e-5);
AssertEquals(dir.lon2, -180.00000, 0.5e-5);
AssertEquals(dir.azi2, -0.00000, 0.5e-5);
dir = line.Position(0.5 * line.Distance(),
GeodesicMask.STANDARD | GeodesicMask.LONG_UNROLL);
AssertEquals(dir.lat2, -87.52461, 0.5e-5);
AssertEquals(dir.lon2, -0.00000, 0.5e-5);
AssertEquals(dir.azi2, -180.00000, 0.5e-5);
}
public void GeodSolve61()
{
// Make sure small negative azimuths are west-going
GeodesicData dir =
Geodesic.WGS84.Direct(45, 0, -0.000000000000000003, 1e7,
GeodesicMask.STANDARD | GeodesicMask.LONG_UNROLL);
AssertEquals(dir.lat2, 45.30632, 0.5e-5);
AssertEquals(dir.lon2, -180, 0.5e-5);
AssertEquals(Math.Abs(dir.azi2), 180, 0.5e-5);
GeodesicLine line = Geodesic.WGS84.InverseLine(45, 0, 80,
-0.000000000000000003);
dir = line.Position(1e7, GeodesicMask.STANDARD | GeodesicMask.LONG_UNROLL);
AssertEquals(dir.lat2, 45.30632, 0.5e-5);
AssertEquals(dir.lon2, -180, 0.5e-5);
AssertEquals(Math.Abs(dir.azi2), 180, 0.5e-5);
}
public void ArcDirectCheck()
{
for (int i = 0; i < testcases.Length; ++i)
{
double
lat1 = testcases[i][0], lon1 = testcases[i][1], azi1 = testcases[i][2],
lat2 = testcases[i][3], lon2 = testcases[i][4], azi2 = testcases[i][5],
s12 = testcases[i][6], a12 = testcases[i][7], m12 = testcases[i][8],
M12 = testcases[i][9], M21 = testcases[i][10], S12 = testcases[i][11];
GeodesicData dir = Geodesic.WGS84.ArcDirect(lat1, lon1, azi1, a12,
GeodesicMask.ALL |
GeodesicMask.LONG_UNROLL);
AssertEquals(lat2, dir.lat2, 1e-13);
AssertEquals(lon2, dir.lon2, 1e-13);
AssertEquals(azi2, dir.azi2, 1e-13);
AssertEquals(s12, dir.s12, 1e-8);
AssertEquals(m12, dir.m12, 1e-8);
AssertEquals(M12, dir.M12, 1e-15);
AssertEquals(M21, dir.M21, 1e-15);
AssertEquals(S12, dir.S12, 0.1);
}
}
