def test_Ex5_great_circle_distance():
frame_E = FrameE(a=6371e3, f=0)
positionA = frame_E.GeoPoint(latitude=88, longitude=0, degrees=True)
positionB = frame_E.GeoPoint(latitude=89, longitude=-170, degrees=True)
s_AB, _azia, _azib = positionA.distance_and_azimuth(positionB)
p_AB_E = positionB.to_ecef_vector() - positionA.to_ecef_vector()
# The Euclidean distance is given by:
d_AB = p_AB_E.length
msg = 'Ex5, Great circle distance = {} km, Euclidean distance = {} km'
print((msg.format(s_AB / 1000, d_AB / 1000)))
assert_array_almost_equal(s_AB / 1000, 332.45644411)
assert_array_almost_equal(d_AB / 1000, 332.41872486)
def test_alternative_great_circle_distance():
frame_E = FrameE(a=6371e3, f=0)
positionA = frame_E.GeoPoint(latitude=88, longitude=0, degrees=True)
positionB = frame_E.GeoPoint(latitude=89, longitude=-170, degrees=True)
path = GeoPath(positionA, positionB)
s_AB = path.track_distance(method='greatcircle')
d_AB = path.track_distance(method='euclidean')
s1_AB = path.track_distance(method='exact')
msg = 'Ex5, Great circle distance = {} km, Euclidean distance = {} km'
print(msg.format(s_AB / 1000, d_AB / 1000))
assert_array_almost_equal(s_AB / 1000, 332.45644411)
assert_array_almost_equal(s1_AB / 1000, 332.45644411)
assert_array_almost_equal(d_AB / 1000, 332.41872486)
def test_Ex4_geodetic_latitude_to_ECEF_vector():
wgs84 = FrameE(name='WGS84')
pointB = wgs84.GeoPoint(latitude=1, longitude=2, z=-3, degrees=True)
p_EB_E = pointB.to_ecef_vector()
print('Ex4: p_EB_E = {0} m'.format(p_EB_E.pvector.ravel()))
assert_array_almost_equal(
p_EB_E.pvector.ravel(),
[6373290.27721828, 222560.20067474, 110568.82718179])
def test_compute_delta_in_moving_frame_north():
wgs84 = FrameE(name='WGS84')
point_a = wgs84.GeoPoint(latitude=1, longitude=2, z=0, degrees=True)
point_b = wgs84.GeoPoint(latitude=1.005,
longitude=2.0,
z=0,
degrees=True)
sensor_position = wgs84.GeoPoint(latitude=1.0025,
longitude=2.0,
z=0,
degrees=True)
path = GeoPath(point_a, point_b)
ti = np.linspace(0, 1.0, 8)
ship_positions0 = path.interpolate(ti[:-1])
ship_positions1 = path.interpolate(ti[1:])
headings = ship_positions0.delta_to(ship_positions1).azimuth_deg
assert_array_almost_equal(headings, 0, decimal=8)
ship_positions = path.interpolate(ti)
delta0 = delta_L(ship_positions, sensor_position, wander_azimuth=0)
delta = ship_positions.delta_to(sensor_position)
assert_array_almost_equal(delta0.pvector, delta.pvector)
x, y, z = delta.pvector
azimuth = np.round(np.abs(delta.azimuth_deg))
# positive angle about down-axis
print('Ex1, delta north, east, down = {0}'.format(delta.pvector.T))
print('Ex1, azimuth = {0} deg'.format(azimuth))
true_x = [
276.436537069603, 197.45466985931083, 118.47280221160541,
39.49093416312986, -39.490934249581684, -118.47280298990226,
-197.454672021303, -276.4365413071498
]
assert_array_almost_equal(x, true_x)
assert_array_almost_equal(y, 0, decimal=8)
assert_array_almost_equal(z, 0, decimal=2)
n2 = len(azimuth) // 2
assert_array_almost_equal(azimuth[:n2], 0)
assert_array_almost_equal(azimuth[n2:], 180)
def test_compare_N_frames(self):
wgs84 = FrameE(name='WGS84')
wgs72 = FrameE(name='WGS72')
pointA = wgs84.GeoPoint(latitude=1, longitude=2, z=3, degrees=True)
pointB = wgs72.GeoPoint(latitude=1, longitude=2, z=6, degrees=True)
frame_N = FrameN(pointA)
frame_L1 = FrameL(pointA, wander_azimuth=0)
frame_L2 = FrameL(pointA, wander_azimuth=0)
frame_L3 = FrameL(pointB, wander_azimuth=0)
self.assertEqual(frame_N, frame_N)
self.assertEqual(frame_N, frame_L1)
self.assertFalse((frame_N != frame_L1))
self.assertEqual(frame_N, frame_L2)
self.assertTrue(frame_N != frame_L3)
self.assertTrue(frame_L1 != frame_L3)
def test_compute_delta_in_moving_frame_east():
wgs84 = FrameE(name='WGS84')
point_a = wgs84.GeoPoint(latitude=1, longitude=2, z=0, degrees=True)
point_b = wgs84.GeoPoint(latitude=1,
longitude=2.005,
z=0,
degrees=True)
sensor_position = wgs84.GeoPoint(latitude=1.0,
longitude=2.0025,
z=0,
degrees=True)
path = GeoPath(point_a, point_b)
ti = np.linspace(0, 1.0, 8)
ship_positions0 = path.interpolate(ti[:-1])
ship_positions1 = path.interpolate(ti[1:])
headings = ship_positions0.delta_to(ship_positions1).azimuth_deg
assert_array_almost_equal(headings, 90, decimal=4)
ship_positions = path.interpolate(ti)
delta = ship_positions.delta_to(sensor_position)
x, y, z = delta.pvector
azimuth = np.round(delta.azimuth_deg)
# positive angle about down-axis
print('Ex1, delta north, east, down = {0}'.format(delta.pvector.T))
print('Ex1, azimuth = {0} deg'.format(azimuth))
true_y = [
278.2566243359911, 198.7547317612817, 119.25283909376164,
39.750946370747656, -39.75094637085409, -119.25283909387079,
-198.75473176137066, -278.2566243360949
]
assert_array_almost_equal(x, 0, decimal=3)
assert_array_almost_equal(y, true_y)
assert_array_almost_equal(z, 0, decimal=2)
n2 = len(azimuth) // 2
assert_array_almost_equal(azimuth[:n2], 90)
assert_array_almost_equal(azimuth[n2:], -90)
def test_Ex6_interpolated_position():
# Position B at time t0 and t2 is given as n_EB_E_t0 and n_EB_E_t1:
# Enter elements as lat/long in deg:
wgs84 = FrameE(name='WGS84')
n_EB_E_t0 = wgs84.GeoPoint(89, 0, degrees=True).to_nvector()
n_EB_E_t1 = wgs84.GeoPoint(89, 180, degrees=True).to_nvector()
# The times are given as:
t0 = 10.
t1 = 20.
ti = 16. # time of interpolation
# Find the interpolated position at time ti, n_EB_E_ti
# SOLUTION:
# Using standard interpolation:
ti_n = (ti - t0) / (t1 - t0)
n_EB_E_ti = n_EB_E_t0 + ti_n * (n_EB_E_t1 - n_EB_E_t0)
# When displaying the resulting position for humans, it is more
# convenient to see lat, long:
g_EB_E_ti = n_EB_E_ti.to_geo_point()
lat_ti, lon_ti = g_EB_E_ti.latitude_deg, g_EB_E_ti.longitude_deg
msg = 'Ex6, Interpolated position: lat, long = {} deg, {} deg'
print(msg.format(lat_ti, lon_ti))
assert_array_almost_equal(lat_ti, 89.7999805)
assert_array_almost_equal(lon_ti, 180.)
# Alternative solution
path = GeoPath(n_EB_E_t0, n_EB_E_t1)
g_EB_E_ti = path.interpolate(ti_n).to_geo_point()
lat_ti, lon_ti = g_EB_E_ti.latitude_deg, g_EB_E_ti.longitude_deg
msg = 'Ex6, Interpolated position: lat, long = {} deg, {} deg'
print(msg.format(lat_ti, lon_ti))
assert_array_almost_equal(lat_ti, 89.7999805)
assert_array_almost_equal(lon_ti, 180.)
def test_Ex8_position_A_and_azimuth_and_distance_to_B():
frame = FrameE(a=EARTH_RADIUS_M, f=0)
pointA = frame.GeoPoint(latitude=80, longitude=-90, degrees=True)
pointB, _azimuthb = pointA.displace(distance=1000,
azimuth=200,
degrees=True)
pointB2, _azimuthb = pointA.displace(distance=1000,
azimuth=np.deg2rad(200))
assert_array_almost_equal(pointB.latlon, pointB2.latlon)
lat_B, lon_B = pointB.latitude_deg, pointB.longitude_deg
print('Ex8, Destination: lat, long = {0} {1} deg'.format(lat_B, lon_B))
assert_array_almost_equal(lat_B, 79.99154867)
assert_array_almost_equal(lon_B, -90.01769837)
def test_Ex1_A_and_B_to_delta_in_frame_N():
wgs84 = FrameE(name='WGS84')
point_a = wgs84.GeoPoint(latitude=1, longitude=2, z=3, degrees=True)
point_b = wgs84.GeoPoint(latitude=4, longitude=5, z=6, degrees=True)
# Find the exact vector between the two positions, given in meters
# north, east, and down, i.e. find delta_N.
# SOLUTION:
delta = point_a.delta_to(point_b)
x, y, z = delta.pvector
azimuth = delta.azimuth_deg
elevation = delta.elevation_deg
print('Ex1, delta north, east, down = {0}, {1}, {2}'.format(x, y, z))
print('Ex1, azimuth = {0} deg'.format(azimuth))
assert_array_almost_equal(x, 331730.23478089)
assert_array_almost_equal(y, 332997.87498927)
assert_array_almost_equal(z, 17404.27136194)
assert_array_almost_equal(azimuth, 45.10926324)
assert_array_almost_equal(elevation, 2.12055861)
