def test_GeodSolve0(self):
point1 = GeoPoint(40.6, -73.8, frame=wgs84, degrees=True)
point2 = GeoPoint(49.01666667, 2.55, frame=wgs84, degrees=True)
s_ab, az_a, az_b = point1.distance_and_azimuth(point2, degrees=True)
self.assertAlmostEqual(az_a, 53.47022, delta=0.5e-5)
self.assertAlmostEqual(az_b, 111.59367, delta=0.5e-5)
self.assertAlmostEqual(s_ab, 5853226, delta=0.5)
def test_GeodSolve0(self):
point1 = GeoPoint(40.6, -73.8, frame=wgs84, degrees=True)
point2 = GeoPoint(49.01666667, 2.55, frame=wgs84, degrees=True)
s_ab, az_a, az_b = point1.distance_and_azimuth(point2, degrees=True)
self.assertAlmostEqual(az_a, 53.47022, delta=0.5e-5)
self.assertAlmostEqual(az_b, 111.59367, delta=0.5e-5)
self.assertAlmostEqual(s_ab, 5853226, delta=0.5)
def test_wgs84_inverse(testcase):
"""Test inverse method on the WGS84 ellipsoid"""
options = dict(frame=WGS84, degrees=True)
(lat1, lon1, azi1, lat2, lon2, azi2, s12) = testcase[:7]
point1 = GeoPoint(lat1, lon1, **options)
point2 = GeoPoint(lat2, lon2, **options)
s_ab, az_a, az_b = point1.distance_and_azimuth(point2, degrees=True)
assert s_ab == approx(s12, rel=1e-14)
assert az_a == approx(azi1, abs=2e-13)
assert az_b == approx(azi2, abs=1e-13)
def test_direct(self):
options = dict(frame=wgs84, degrees=True)
for l in GeodesicTest.testcases:
(lat1, lon1, azi1, lat2, lon2, azi2, s12) = l[:7]
point1 = GeoPoint(lat1, lon1, **options)
point2, az_b = point1.geo_point(s12, azi1, long_unroll=True,
degrees=True)
lat_b, lon_b = point2.latitude_deg, point2.longitude_deg
self.assertAlmostEqual(lat2, lat_b, delta=1e-13)
self.assertAlmostEqual(lon2, lon_b, delta=1e-13)
self.assertAlmostEqual(azi2, az_b, delta=1e-13)
def test_inverse(self):
options = dict(frame=wgs84, degrees=True)
for l in GeodesicTest.testcases:
(lat1, lon1, azi1, lat2, lon2, azi2, s12) = l[:7]
point1 = GeoPoint(lat1, lon1, **options)
point2 = GeoPoint(lat2, lon2, **options)
s_ab, az_a, az_b = point1.distance_and_azimuth(point2,
long_unroll=True,
degrees=True)
self.assertAlmostEqual(azi1, az_a, delta=1e-13)
self.assertAlmostEqual(azi2, az_b, delta=1e-13)
self.assertAlmostEqual(s12, s_ab, delta=1e-8)
def test_inverse(self):
options = dict(frame=wgs84, degrees=True)
for l in TESTCASES:
(lat1, lon1, azi1, lat2, lon2, azi2, s12) = l[:7]
point1 = GeoPoint(lat1, lon1, **options)
point2 = GeoPoint(lat2, lon2, **options)
s_ab, az_a, az_b = point1.distance_and_azimuth(point2,
long_unroll=True,
degrees=True)
self.assertAlmostEqual(azi1, az_a, delta=1e-13)
self.assertAlmostEqual(azi2, az_b, delta=1e-13)
self.assertAlmostEqual(s12, s_ab, delta=1e-8)
def test_prolate30_direct(testcase):
"""Test direct method on the prolate 30 ellipsoid"""
options = dict(frame=PROLATE30, degrees=True)
(lat1, lon1, azi1, lat2, lon2, azi2, s12) = testcase[:7]
point1 = GeoPoint(lat1, lon1, **options)
point2, az_b = point1.displace(s12, azi1, long_unroll=True, degrees=True)
lat_b, lon_b = point2.latitude_deg, point2.longitude_deg
assert lat_b == approx(lat2, abs=1e-13)
assert lon_b == approx(lon2, abs=1e-13)
assert az_b == approx(azi2, abs=1e-13)
def test_Ex7_mean_position():
# Three positions A, B and C are given:
# Enter elements directly:
# n_EA_E=unit(np.vstack((1, 0, -2)))
# n_EB_E=unit(np.vstack((-1, -2, 0)))
# n_EC_E=unit(np.vstack((0, -2, 3)))
# or input as lat/long in deg:
points = GeoPoint(latitude=[90, 60, 50], longitude=[0, 10, -20], degrees=True)
nvectors = points.to_nvector()
nmean = nvectors.mean_horizontal_position()
n_EM_E = nmean.normal
assert_array_almost_equal(n_EM_E.ravel(), [0.384117, -0.046602, 0.922107])
def test_direct(self):
options = dict(frame=wgs84, degrees=True)
for l in TESTCASES:
(lat1, lon1, azi1, lat2, lon2, azi2, s12) = l[:7]
point1 = GeoPoint(lat1, lon1, **options)
point2, az_b = point1.geo_point(s12,
azi1,
long_unroll=True,
degrees=True)
lat_b, lon_b = point2.latitude_deg, point2.longitude_deg
self.assertAlmostEqual(lat2, lat_b, delta=1e-13)
self.assertAlmostEqual(lon2, lon_b, delta=1e-13)
self.assertAlmostEqual(azi2, az_b, delta=1e-13)
def test_intersect_on_parallell_paths(self):
# Two paths A and B are given by two pairs of positions:
pointA1 = GeoPoint(10, 20, degrees=True)
pointA2 = GeoPoint(30, 40, degrees=True)
pointB1 = GeoPoint(10, 20, degrees=True)
pointB2 = GeoPoint(30, 40, degrees=True)
pathA = GeoPath(pointA1, pointA2)
pathB = GeoPath(pointB1, pointB2)
pointC = pathA.intersect(pathB).to_geo_point()
lat, lon = pointC.latitude_deg, pointC.longitude_deg
msg = 'Ex9, Intersection: lat, long = {} {} deg'
print(msg.format(lat, lon))
self.assertTrue(np.isnan(lat))
self.assertTrue(np.isnan(lon))
def test_Ex9_intersect():
# Two paths A and B are given by two pairs of positions:
pointA1 = GeoPoint(10, 20, degrees=True)
pointA2 = GeoPoint(30, 40, degrees=True)
pointB1 = GeoPoint(50, 60, degrees=True)
pointB2 = GeoPoint(70, 80, degrees=True)
pathA = GeoPath(pointA1, pointA2)
pathB = GeoPath(pointB1, pointB2)
pointC = pathA.intersect(pathB).to_geo_point()
lat, lon = pointC.latitude_deg, pointC.longitude_deg
msg = 'Ex9, Intersection: lat, long = {} {} deg'
print(msg.format(lat, lon))
assert_array_almost_equal(lat, 40.31864307)
assert_array_almost_equal(lon, 55.90186788)
def test_Ex7_mean_position():
# Three positions A, B and C are given:
# Enter elements directly:
# n_EA_E=unit(np.vstack((1, 0, -2)))
# n_EB_E=unit(np.vstack((-1, -2, 0)))
# n_EC_E=unit(np.vstack((0, -2, 3)))
# or input as lat/long in deg:
points = GeoPoint(latitude=[90, 60, 50],
longitude=[0, 10, -20],
degrees=True)
nvectors = points.to_nvector()
nmean = nvectors.mean_horizontal_position()
n_EM_E = nmean.normal
assert_array_almost_equal(n_EM_E.ravel(),
[0.384117, -0.046602, 0.922107])
