def test_fit_arc_to_points(self): LATS_0 = np.zeros(4, dtype=np.float) LONS_0 = np.array([0.0, 1.0, 2.0, 3.0]) # Test points along arc ecef_points_0 = calculate_EcefPoints(LATS_0, LONS_0) ecef_arc_0 = EcefArc(ecef_points_0[0], ecef_points_0[-1]) new_arc_0 = fit_arc_to_points(ecef_points_0, ecef_arc_0) assert_array_almost_equal(new_arc_0.a, ecef_arc_0.a) assert_array_almost_equal(new_arc_0.b, ecef_arc_0.b) # Test slope away from start of arc ecef_points_1 = calculate_EcefPoints(LONS_0, LONS_0) ecef_arc_1 = EcefArc(ecef_points_1[0], ecef_points_1[-1]) new_arc_1 = fit_arc_to_points(ecef_points_1, ecef_arc_0) assert_array_almost_equal(new_arc_1.a, ecef_arc_0.a) assert_array_almost_equal(new_arc_1.pole, ecef_arc_1.pole) # Test slope towards end of arc LATS_2 = np.array([3.0, 2.0, 1.0, 0.0]) ecef_points_2 = calculate_EcefPoints(LATS_2, LONS_0) ecef_arc_2 = EcefArc(ecef_points_2[0], ecef_points_2[-1]) new_arc_2 = fit_arc_to_points(ecef_points_2, ecef_arc_0) assert_array_almost_equal(new_arc_2.pole, ecef_arc_2.pole) assert_array_almost_equal(new_arc_2.b, ecef_arc_0.b)
def test_find_extreme_point_index_3(self): # A line of Lat Longs around the Equator LATITUDES = np.zeros(10, dtype=float) LONGITUDES = np.array(range(-5, 5), dtype=float) ecef_points_0 = calculate_EcefPoints(LATITUDES, LONGITUDES) # same point max_index = len(ecef_points_0) - 1 result_0 = find_extreme_point_index(ecef_points_0, 0, max_index, threshold=ACROSS_TRACK_TOLERANCE, xtd_ratio=0.1, calc_along_track=True) self.assertEqual(result_0, max_index) # route "doubles back" on itself LONGITUDES[-1] = LONGITUDES[-3] ecef_points_1 = calculate_EcefPoints(LATITUDES, LONGITUDES) result_1 = find_extreme_point_index(ecef_points_1, 0, max_index, threshold=ACROSS_TRACK_TOLERANCE, xtd_ratio=0.1, calc_along_track=True) self.assertEqual(result_1, max_index - 1)
def test_find_extreme_point_indicies(self): # A line of Lat Longs around the Equator LATITUDES = np.zeros(10, dtype=float) LONGITUDES = np.array([-5 + i for i in range(10)], dtype=float) ecef_points_0 = calculate_EcefPoints(LATITUDES, LONGITUDES) indicies_0 = find_extreme_point_indicies( ecef_points_0, threshold=ACROSS_TRACK_TOLERANCE, xtd_ratio=0.1) self.assertEqual(len(indicies_0), 2) assert_array_almost_equal(indicies_0, [0, 9]) LATITUDES[4] = 1 LATITUDES[8] = -1 ecef_points_1 = calculate_EcefPoints(LATITUDES, LONGITUDES) indicies_1 = find_extreme_point_indicies( ecef_points_1, threshold=ACROSS_TRACK_TOLERANCE, xtd_ratio=0.1) self.assertEqual(len(indicies_1), 7) assert_array_almost_equal(indicies_1, [0, 3, 4, 5, 7, 8, 9]) indicies_3 = find_extreme_point_indicies(ecef_points_1, threshold=np.deg2rad(1.0), xtd_ratio=0.1) self.assertEqual(len(indicies_3), 7)
def test_find_extreme_point_along_track_index(self): # A line of Lat Longs around the Equator LATITUDES = np.zeros(10, dtype=float) LONGITUDES = np.array(range(-5, 5), dtype=float) ecef_points_0 = calculate_EcefPoints(LATITUDES, LONGITUDES) # All points within arc arc = EcefArc(ecef_points_0[0], ecef_points_0[-1]) index_0 = find_extreme_point_along_track_index(arc, ecef_points_0, 1.0 * NM) self.assertEqual(index_0, 0) # Point 2 before start of arc LONGITUDES[2] = -6 ecef_points_1 = calculate_EcefPoints(LATITUDES, LONGITUDES) index_1 = find_extreme_point_along_track_index(arc, ecef_points_1, 1.0 * NM) self.assertEqual(index_1, 2) # Point 8 past end of arc LONGITUDES[8] = 8 ecef_points_2 = calculate_EcefPoints(LATITUDES, LONGITUDES) index_2 = find_extreme_point_along_track_index(arc, ecef_points_2, 1.0 * NM) self.assertEqual(index_2, 8)
def test_EcefPath_turn_points(self): ecef_points = calculate_EcefPoints(ROUTE_LATS, ROUTE_LONS) ecef_path = EcefPath(ecef_points, TURN_DISTANCES) turn_points_0 = ecef_path.turn_points(number_of_points=0) self.assertEqual(len(turn_points_0), len(ecef_path) + 8) # Ensure that start and end points are along inbound and outboud arcs arc_1 = EcefArc(ecef_points[1], ecef_points[2]) assert_almost_equal(arc_1.cross_track_distance(turn_points_0[2]), 0.0) arc_2 = EcefArc(ecef_points[2], ecef_points[3]) assert_almost_equal(arc_2.cross_track_distance(turn_points_0[3]), 0.0) assert_almost_equal(arc_2.cross_track_distance(turn_points_0[4]), 0.0) arc_last = EcefArc(ecef_points[-2], ecef_points[-1]) assert_almost_equal(arc_last.cross_track_distance(turn_points_0[-2]), 0.0) turn_points_1 = ecef_path.turn_points(number_of_points=1) self.assertEqual(len(turn_points_1), len(ecef_path) + 16) turn_points_3 = ecef_path.turn_points() self.assertEqual(len(turn_points_3), len(ecef_path) + 32) turn_points_5 = ecef_path.turn_points(number_of_points=5) self.assertEqual(len(turn_points_5), len(ecef_path) + 48)
def test_find_extreme_point_index_2(self): # A line of Lat Longs by the Equator LATITUDES = np.array([0.0, -0.001, 0.01, -0.001, 0.0]) LONGITUDES = np.array([0.0, 0.0005, 0.001, 0.0014, 0.0015]) ecef_points_0 = calculate_EcefPoints(LATITUDES, LONGITUDES) # mid point max_index = len(ecef_points_0) - 1 result_0 = find_extreme_point_index(ecef_points_0, 0, max_index, threshold=ACROSS_TRACK_TOLERANCE, xtd_ratio=0.1, calc_along_track=False) self.assertEqual(result_0, 2) # first half max_index = 2 result_1 = find_extreme_point_index(ecef_points_0, 0, max_index, threshold=ACROSS_TRACK_TOLERANCE, xtd_ratio=0.1, calc_along_track=False) self.assertEqual(result_1, 2) # second half max_index = len(ecef_points_0) - 1 result_2 = find_extreme_point_index(ecef_points_0, 2, max_index, threshold=ACROSS_TRACK_TOLERANCE, xtd_ratio=0.1, calc_along_track=False) self.assertEqual(result_2, max_index)
def test_EcefPath_section_distances_and_types(self): ecef_points = calculate_EcefPoints(ROUTE_LATS, ROUTE_LONS) ecef_path = EcefPath(ecef_points, TURN_DISTANCES) path_distances = rad2nm(ecef_path.path_distances()) distances, types = ecef_path.section_distances_and_types() self.assertEqual(len(distances), len(ecef_path) + 8) self.assertEqual(len(types), len(ecef_path) + 8) self.assertEqual(distances[0], 0.0) self.assertEqual(types[0], PointType.Waypoint) self.assertEqual(distances[1], path_distances[1]) self.assertEqual(types[1], PointType.Waypoint) self.assertTrue(distances[2] < path_distances[2]) self.assertEqual(types[2], PointType.TurnStart) self.assertTrue(distances[3] > path_distances[2]) self.assertEqual(types[3], PointType.TurnFinish) self.assertEqual(distances[-2], path_distances[-2]) self.assertEqual(types[-2], PointType.Waypoint) self.assertEqual(distances[-1], path_distances[-1]) self.assertEqual(types[-1], PointType.Waypoint)
def test_calculate_path_cross_track_distance(self): ecef_points = calculate_EcefPoints(ROUTE_LATS, ROUTE_LONS) ecef_path = EcefPath(ecef_points, TURN_DISTANCES) assert_almost_equal( ecef_path.calculate_path_cross_track_distance(ecef_points[0], 0), 0.0) assert_almost_equal( ecef_path.calculate_path_cross_track_distance(ecef_points[1], 1), 0.0) xtd_2_1 = ecef_path.calculate_path_cross_track_distance( ecef_points[2], 1) assert_almost_equal(rad2nm(xtd_2_1), 4.1416795658323213) xtd_2_2 = ecef_path.calculate_path_cross_track_distance( ecef_points[2], 2) assert_almost_equal(rad2nm(xtd_2_2), 4.1416795658323213) xtd_3_2 = ecef_path.calculate_path_cross_track_distance( ecef_points[3], 2) assert_almost_equal(rad2nm(xtd_3_2), 8.2824069920496726) xtd_3_3 = ecef_path.calculate_path_cross_track_distance( ecef_points[3], 3) assert_almost_equal(rad2nm(xtd_3_3), 8.2824069920496726)
def test_calculate_turn_initiation_distance_20(self): # A shallow turn at the Equator LATS = np.array([0.0, 0.0, 0.2]) LONS = np.array([-1.0, 0.0, 1.0]) ecef_points = calculate_EcefPoints(LATS, LONS) prev_arc = EcefArc(ecef_points[0], ecef_points[1]) arc = EcefArc(ecef_points[1], ecef_points[2]) TEN_NM = TWENTY_NM / 2 turn_0 = TurnArc(prev_arc, arc, TEN_NM) turn_angle_0 = turn_0.angle distance_start = calculate_turn_initiation_distance( prev_arc, arc, turn_0.start, TWENTY_NM, ACROSS_TRACK_TOLERANCE) assert_almost_equal(distance_start, TEN_NM) distance_finish = calculate_turn_initiation_distance( prev_arc, arc, turn_0.finish, TWENTY_NM, ACROSS_TRACK_TOLERANCE) assert_almost_equal(distance_finish, TEN_NM) point_1 = turn_0.position(turn_angle_0 / 2) distance_1 = calculate_turn_initiation_distance( prev_arc, arc, point_1, TWENTY_NM, ACROSS_TRACK_TOLERANCE) assert_almost_equal(distance_1, TEN_NM, decimal=6) point_2 = turn_0.position(turn_angle_0 / 4) distance_2 = calculate_turn_initiation_distance( prev_arc, arc, point_2, TWENTY_NM, ACROSS_TRACK_TOLERANCE / 4) assert_almost_equal(distance_2, TEN_NM, decimal=6) point_3 = turn_0.position(3 * turn_angle_0 / 4) distance_3 = calculate_turn_initiation_distance( prev_arc, arc, point_3, TWENTY_NM, ACROSS_TRACK_TOLERANCE / 4) assert_almost_equal(distance_3, TEN_NM, decimal=5)
def test_EcefPath_init(self): ecef_points = calculate_EcefPoints(ROUTE_LATS, ROUTE_LONS) ecef_path = EcefPath(ecef_points, TURN_DISTANCES) self.assertEqual(len(ecef_path.points), 12) assert_array_almost_equal(ecef_path.points, ecef_points) self.assertEqual(len(ecef_path.turn_initiation_distances), 12) assert_array_almost_equal(ecef_path.turn_initiation_distances, TURN_DISTANCES) self.assertEqual(len(ecef_path.leg_lengths), 12) assert_array_almost_equal(rad2nm(ecef_path.leg_lengths), EXPECTED_LEG_LENGTHS) self.assertEqual(len(ecef_path.turn_angles), 12) assert_array_almost_equal(np.rad2deg(ecef_path.turn_angles), EXPECTED_TURN_ANGLES) self.assertEqual(len(ecef_path.path_lengths), 12) assert_array_almost_equal(rad2nm(ecef_path.path_lengths), EXPECTED_PATH_LENGTHS) lats, lons = ecef_path.point_lat_longs() assert_array_almost_equal(lats, ROUTE_LATS) assert_array_almost_equal(lons, ROUTE_LONS) assert_array_almost_equal(ecef_path.turn_initiation_distances_nm(), rad2nm(TURN_DISTANCES))
def test_EcefPath_calculate_position(self): ecef_points = calculate_EcefPoints(ROUTE_LATS, ROUTE_LONS) ecef_path = EcefPath(ecef_points, TURN_DISTANCES) pos_0 = ecef_path.calculate_position(0, 0.0) assert_array_almost_equal(pos_0, ecef_points[0]) pos_1 = ecef_path.calculate_position(1, 0.0) assert_array_almost_equal(pos_1, ecef_points[1]) arc2 = EcefArc(ecef_points[1], ecef_points[2]) arc3 = EcefArc(ecef_points[2], ecef_points[3]) turn_arc2 = TurnArc(arc2, arc3, TURN_DISTANCES[2]) turn2_midpoint = EcefPoint( turn_arc2.position(0.5 * abs(turn_arc2.angle))) pos_2 = ecef_path.calculate_position(2, 0.000001) assert_array_almost_equal(pos_2, turn2_midpoint) pos_1_99999 = ecef_path.calculate_position(1, 0.99999) assert_array_almost_equal(pos_1_99999, pos_2) pos_13 = ecef_path.calculate_position(13, 0.0) assert_array_almost_equal(pos_13, ecef_points[-1])
def test_EcefPath_invalid_init(self): 'The route has a duplicate point in the middle, so closer than MIN_LENGTH' INVALID_ROUTE_LATS = np.array([1.0, 1.0, 1.0, 1.0, -1.0, 1.0]) INVALID_ROUTE_LONS = np.array([-3.0, -2.0, -1.0, -1.0, 1.0, 0.0]) invalid_points = calculate_EcefPoints(INVALID_ROUTE_LATS, INVALID_ROUTE_LONS) zero_distances = np.zeros(len(invalid_points), dtype=float) self.assertRaises(ValueError, EcefPath, invalid_points, zero_distances)
def test_derive_horizontal_path(self): test_data_home = env.get('TEST_DATA_HOME') self.assertTrue(test_data_home) ecef_points = calculate_EcefPoints(ROUTE_LATS, ROUTE_LONS) ecef_path = derive_horizontal_path(ecef_points, ACROSS_TRACK_TOLERANCE) self.assertEqual(len(ecef_path), 12) assert_array_almost_equal(ecef_path.points[0], ecef_points[0]) assert_array_almost_equal(ecef_path.points[-1], ecef_points[-1])
def test_EcefPath_path_distances(self): ecef_points = calculate_EcefPoints(ROUTE_LATS, ROUTE_LONS) ecef_path = EcefPath(ecef_points, TURN_DISTANCES) path_distances = ecef_path.path_distances() self.assertEqual(len(path_distances), 12) assert_array_almost_equal(rad2nm(path_distances), EXPECTED_PATH_DISTANCES)
def test_EcefPath_calculate_ground_tracks(self): ecef_points = calculate_EcefPoints(ROUTE_LATS, ROUTE_LONS) ecef_path = EcefPath(ecef_points, TURN_DISTANCES) distances, types = ecef_path.section_distances_and_types() ground_tracks = ecef_path.calculate_ground_tracks(distances) self.assertEqual(len(ground_tracks), len(ecef_path) + 8) assert_almost_equal(ground_tracks[0], np.pi / 2, decimal=3)
def test_EcefPath_calculate_path_leg_distance(self): ecef_points = calculate_EcefPoints(ROUTE_LATS, ROUTE_LONS) ecef_path = EcefPath(ecef_points, TURN_DISTANCES) # Start point distance_0 = ecef_path.calculate_path_leg_distance(ecef_points[0], 0) self.assertEqual(distance_0, 0.0) # Point at end of a straight leg distance_1_0 = ecef_path.calculate_path_leg_distance(ecef_points[1], 0) assert_almost_equal(rad2nm(distance_1_0), EXPECTED_PATH_LENGTHS[1]) # Point at start of a straight leg distance_1_1 = ecef_path.calculate_path_leg_distance(ecef_points[1], 1) self.assertEqual(distance_0, 0.0) # Point in middle of a straight leg pos_1_5 = ecef_path.calculate_position(1, 0.5) distance_1_5 = ecef_path.calculate_path_leg_distance(pos_1_5, 1) assert_almost_equal(rad2nm(distance_1_5), 0.5 * EXPECTED_PATH_LENGTHS[2]) # Point toward end of a turning leg pos_1_9 = ecef_path.calculate_position(1, 0.99) distance_1_9 = ecef_path.calculate_path_leg_distance(pos_1_9, 1) assert_almost_equal(rad2nm(distance_1_9), 0.99 * EXPECTED_PATH_LENGTHS[2]) # Before start of a turning leg distance_2_9 = ecef_path.calculate_path_leg_distance(pos_1_9, 2) assert_almost_equal(rad2nm(distance_2_9), -0.57845277761762326) # Point toward start of a turning leg pos_2_1 = ecef_path.calculate_position(2, 0.01) distance_2_1 = ecef_path.calculate_path_leg_distance(pos_2_1, 2) assert_almost_equal(rad2nm(distance_2_1), 0.01 * EXPECTED_PATH_LENGTHS[3]) # Past the ned of a turning leg distance_1_2 = ecef_path.calculate_path_leg_distance(pos_2_1, 1) self.assertTrue(rad2nm(distance_1_2) > EXPECTED_PATH_LENGTHS[2]) assert_almost_equal(rad2nm(distance_1_2), 58.980918943627351) # Point along a turning leg pos_2_75 = ecef_path.calculate_position(2, 0.75) distance_2_75 = ecef_path.calculate_path_leg_distance(pos_2_75, 2) assert_almost_equal(rad2nm(distance_2_75), 0.75 * EXPECTED_PATH_LENGTHS[3]) # Last point distance_last = ecef_path.calculate_path_leg_distance( ecef_points[-1], 10) assert_almost_equal(rad2nm(distance_last), EXPECTED_PATH_LENGTHS[11])
def test_EcefPath_calculate_path_distances(self): ecef_points = calculate_EcefPoints(ROUTE_LATS, ROUTE_LONS) ecef_path = EcefPath(ecef_points, TURN_DISTANCES) distances = rad2nm( ecef_path.calculate_path_distances(ecef_points, ACROSS_TRACK_TOLERANCE)) self.assertEqual(len(distances), len(ecef_points)) self.assertEqual(distances[0], 0.0) assert_almost_equal(distances[11], EXPECTED_PATH_DISTANCES[11], decimal=6) assert_array_almost_equal(distances, EXPECTED_PATH_DISTANCES)
def test_EcefPath_calculate_positions(self): ecef_points = calculate_EcefPoints(ROUTE_LATS, ROUTE_LONS) ecef_path = EcefPath(ecef_points, TURN_DISTANCES) distances, types = ecef_path.section_distances_and_types() positions = ecef_path.calculate_positions(distances) self.assertEqual(len(positions), len(ecef_path) + 8) assert_array_almost_equal(positions[0], ecef_points[0]) assert_array_almost_equal(positions[1], ecef_points[1]) assert_array_almost_equal(positions[-2], ecef_points[-2]) assert_array_almost_equal(positions[-1], ecef_points[-1])
def test_EcefPath_calculate_ground_track(self): ecef_points = calculate_EcefPoints(ROUTE_LATS, ROUTE_LONS) ecef_path = EcefPath(ecef_points, TURN_DISTANCES) track_0 = ecef_path.calculate_ground_track(0, 0.0) assert_almost_equal(track_0, np.pi / 2, decimal=3) # close to due East track_2_5 = ecef_path.calculate_ground_track(2, 0.5) assert_almost_equal(track_2_5, np.pi) # due south track_2_0 = ecef_path.calculate_ground_track(2, 0.0) assert_almost_equal(track_2_0, 0.75 * np.pi, decimal=3) # South East track_12_0 = ecef_path.calculate_ground_track(12, 0.0) assert_almost_equal(track_12_0, 0.0) # North
def test_calculate_turn_initiation_distance_90(self): # A 90 degree turn at the Equator LATS = np.array([0.0, 0.0, 1.0]) LONS = np.array([1.0, 0.0, 0.0]) ecef_points = calculate_EcefPoints(LATS, LONS) prev_arc = EcefArc(ecef_points[0], ecef_points[1]) arc = EcefArc(ecef_points[1], ecef_points[2]) TEN_NM = TWENTY_NM / 2 turn_0 = TurnArc(prev_arc, arc, TEN_NM) turn_angle_0 = turn_0.angle distance_start = calculate_turn_initiation_distance( prev_arc, arc, turn_0.start, TWENTY_NM, ACROSS_TRACK_TOLERANCE) assert_almost_equal(distance_start, TEN_NM) distance_finish = calculate_turn_initiation_distance( prev_arc, arc, turn_0.finish, TWENTY_NM, ACROSS_TRACK_TOLERANCE) assert_almost_equal(distance_finish, TEN_NM) point_1 = turn_0.position(turn_angle_0 / 2) distance_1 = calculate_turn_initiation_distance( prev_arc, arc, point_1, TWENTY_NM, ACROSS_TRACK_TOLERANCE) assert_almost_equal(distance_1, TEN_NM) point_2 = turn_0.position(turn_angle_0 / 4) distance_2 = calculate_turn_initiation_distance( prev_arc, arc, point_2, TWENTY_NM, ACROSS_TRACK_TOLERANCE) assert_almost_equal(distance_2, TEN_NM) point_3 = turn_0.position(3 * turn_angle_0 / 4) distance_3 = calculate_turn_initiation_distance( prev_arc, arc, point_3, TWENTY_NM, ACROSS_TRACK_TOLERANCE) assert_almost_equal(distance_3, TEN_NM) # Test with a point further than TWENTY_NM from the intersection turn_30 = TurnArc(prev_arc, arc, TWENTY_NM + TEN_NM) distance_4 = calculate_turn_initiation_distance( prev_arc, arc, turn_30.start, TWENTY_NM, ACROSS_TRACK_TOLERANCE) self.assertEqual(distance_4, TWENTY_NM) point_30 = turn_30.position(3 * turn_angle_0 / 4) distance_30 = calculate_turn_initiation_distance( prev_arc, arc, point_30, TWENTY_NM, ACROSS_TRACK_TOLERANCE) self.assertEqual(distance_30, TWENTY_NM)
def test_EcefPath_calculate_cross_track_distances(self): ecef_points = calculate_EcefPoints(ROUTE_LATS, ROUTE_LONS) ecef_path = EcefPath(ecef_points, TURN_DISTANCES) distances = rad2nm( ecef_path.calculate_path_distances(ecef_points, ACROSS_TRACK_TOLERANCE)) self.assertEqual(len(distances), len(ecef_points)) xtds = ecef_path.calculate_cross_track_distances( ecef_points, distances) self.assertEqual(len(xtds), len(ecef_points)) assert_almost_equal(xtds[0], 0.0) assert_almost_equal(xtds[1], 0.0) assert_almost_equal(xtds[2], 4.1416795658323213) # 10NM TID assert_almost_equal(xtds[3], 8.2824069920496726) # 20NM TID assert_almost_equal(xtds[-1], 0.0)
def test_EcefPath_subsection_positions(self): ecef_points = calculate_EcefPoints(ROUTE_LATS, ROUTE_LONS) ecef_path = EcefPath(ecef_points, TURN_DISTANCES) positions0 = ecef_path.subsection_positions(0, 1040.0) self.assertEqual(len(positions0), len(ecef_path)) assert_array_almost_equal(positions0[0], ecef_points[0]) assert_array_almost_equal(positions0[-1], ecef_points[-1]) positions1 = ecef_path.subsection_positions(0, 1000.0) self.assertEqual(len(positions1), len(ecef_path)) assert_array_almost_equal(positions1[0], ecef_points[0]) assert_array_almost_equal(positions1[-2], ecef_points[-2]) positions2 = ecef_path.subsection_positions(100.0, 1040.0) self.assertEqual(len(positions2), len(ecef_path) - 1) assert_array_almost_equal(positions2[1], ecef_points[2]) assert_array_almost_equal(positions2[-1], ecef_points[-1])
def test_calculate_intersection(self): ecef_points = calculate_EcefPoints(ROUTE_LATS, ROUTE_LONS) # intersection point between arcs on different Great Circles prev_arc = EcefArc(ecef_points[0], ecef_points[1]) arc = EcefArc(ecef_points[1], ecef_points[2]) point_1 = calculate_intersection(prev_arc, arc) assert_array_almost_equal(point_1, ecef_points[1]) # intersection point between arcs on same Great Circles next_point = arc.position(2 * arc.length) next_arc = EcefArc(ecef_points[2], next_point) point_2 = calculate_intersection(arc, next_arc) assert_array_almost_equal(point_2, ecef_points[2]) # intersection point between arcs on different Great Circles, # opposite direction turn prev_arc = EcefArc(ecef_points[5], ecef_points[6]) arc = EcefArc(ecef_points[6], ecef_points[7]) point_3 = calculate_intersection(prev_arc, arc) assert_array_almost_equal(point_3, ecef_points[6])
def test_find_extreme_point_index_1(self): # A line of Lat Longs around the Equator LATITUDES = np.zeros(10, dtype=float) LONGITUDES = np.array(range(-5, 5), dtype=float) ecef_points_0 = calculate_EcefPoints(LATITUDES, LONGITUDES) # same point max_index = 0 result_0 = find_extreme_point_index(ecef_points_0, 0, max_index, threshold=ACROSS_TRACK_TOLERANCE, xtd_ratio=0.1, calc_along_track=False) self.assertEqual(result_0, max_index) # adjacent points max_index = 1 result_1 = find_extreme_point_index(ecef_points_0, 0, max_index, threshold=ACROSS_TRACK_TOLERANCE, xtd_ratio=0.1, calc_along_track=False) self.assertEqual(result_1, max_index) # a point inbetween points max_index = 2 result_2 = find_extreme_point_index(ecef_points_0, 0, max_index, threshold=ACROSS_TRACK_TOLERANCE, xtd_ratio=0.1, calc_along_track=False) self.assertEqual(result_2, max_index) # test toward the end max_index = 8 max_index_0 = find_extreme_point_index( ecef_points_0, 2, max_index, threshold=ACROSS_TRACK_TOLERANCE, xtd_ratio=0.1, calc_along_track=False) self.assertEqual(max_index_0, max_index) # move some points alongside the arc LATITUDES[1] = 0.5 LATITUDES[4] = 1 ecef_points_1 = calculate_EcefPoints(LATITUDES, LONGITUDES) max_index = 2 result_2 = find_extreme_point_index(ecef_points_1, 0, max_index, threshold=ACROSS_TRACK_TOLERANCE, xtd_ratio=0.1, calc_along_track=False) self.assertEqual(result_2, 1) max_index = 8 max_index_1 = find_extreme_point_index( ecef_points_1, 0, max_index, threshold=ACROSS_TRACK_TOLERANCE, xtd_ratio=0.1, calc_along_track=False) self.assertEqual(max_index_1, 4) LATITUDES[4] = -1 ecef_points_2 = calculate_EcefPoints(LATITUDES, LONGITUDES) max_index_2 = find_extreme_point_index( ecef_points_2, 2, max_index, threshold=ACROSS_TRACK_TOLERANCE, xtd_ratio=0.1, calc_along_track=False) self.assertEqual(max_index_2, 4) max_index_3 = find_extreme_point_index(ecef_points_2, 2, max_index, threshold=np.deg2rad(1.0), xtd_ratio=0.1, calc_along_track=False) self.assertEqual(max_index_3, 4) SHORT_LONGITUDES = np.array([-5 + i / 600.0 for i in range(10)], dtype=float) ecef_points_4 = calculate_EcefPoints(LATITUDES, SHORT_LONGITUDES) max_index_4 = find_extreme_point_index( ecef_points_4, 2, max_index, threshold=ACROSS_TRACK_TOLERANCE, xtd_ratio=0.1, calc_along_track=False) self.assertEqual(max_index_2, 4)
def test_EcefPath_calculate_path_distance(self): ecef_points = calculate_EcefPoints(ROUTE_LATS, ROUTE_LONS) ecef_path = EcefPath(ecef_points, TURN_DISTANCES) # Start point distance_0 = ecef_path.calculate_path_distance(ecef_points[0], 0, ACROSS_TRACK_TOLERANCE) self.assertEqual(distance_0, 0.0) # from next leg distance_0 = ecef_path.calculate_path_distance(ecef_points[0], 1, ACROSS_TRACK_TOLERANCE) self.assertEqual(distance_0, 0.0) # Point at end of first, straight leg distance_1_0 = ecef_path.calculate_path_distance( ecef_points[1], 0, ACROSS_TRACK_TOLERANCE) assert_almost_equal(rad2nm(distance_1_0), EXPECTED_PATH_DISTANCES[1]) # from next leg distance_1_0 = ecef_path.calculate_path_distance( ecef_points[1], 1, ACROSS_TRACK_TOLERANCE) assert_almost_equal(rad2nm(distance_1_0), EXPECTED_PATH_DISTANCES[1]) # from leg after next distance_1_0 = ecef_path.calculate_path_distance( ecef_points[1], 2, ACROSS_TRACK_TOLERANCE) assert_almost_equal(rad2nm(distance_1_0), EXPECTED_PATH_DISTANCES[1]) # Point in middle of first, straight leg pos_1_5 = ecef_path.calculate_position(1, 0.5) distance_1_5 = ecef_path.calculate_path_distance( pos_1_5, 1, ACROSS_TRACK_TOLERANCE) assert_almost_equal( rad2nm(distance_1_5), EXPECTED_PATH_DISTANCES[1] + 0.5 * EXPECTED_PATH_LENGTHS[2]) # from previous leg distance_1_5 = ecef_path.calculate_path_distance( pos_1_5, 0, ACROSS_TRACK_TOLERANCE) assert_almost_equal( rad2nm(distance_1_5), EXPECTED_PATH_DISTANCES[1] + 0.5 * EXPECTED_PATH_LENGTHS[2]) # from next leg distance_1_5 = ecef_path.calculate_path_distance( pos_1_5, 2, ACROSS_TRACK_TOLERANCE) assert_almost_equal( rad2nm(distance_1_5), EXPECTED_PATH_DISTANCES[1] + 0.5 * EXPECTED_PATH_LENGTHS[2]) # Point along a turning leg pos_2_75 = ecef_path.calculate_position(2, 0.75) distance_2_75 = ecef_path.calculate_path_distance( pos_2_75, 2, ACROSS_TRACK_TOLERANCE) assert_almost_equal( rad2nm(distance_2_75), EXPECTED_PATH_DISTANCES[2] + 0.75 * EXPECTED_PATH_LENGTHS[3]) # Last point distance_last = ecef_path.calculate_path_distance( ecef_points[-1], 10, ACROSS_TRACK_TOLERANCE) assert_almost_equal(rad2nm(distance_last), EXPECTED_PATH_DISTANCES[11], decimal=6) # from previous leg distance_last = ecef_path.calculate_path_distance( ecef_points[-1], 9, ACROSS_TRACK_TOLERANCE) assert_almost_equal(rad2nm(distance_last), EXPECTED_PATH_DISTANCES[11], decimal=6)
def test_find_furthest_distance(self): ecef_points = calculate_EcefPoints(ROUTE_LATS, ROUTE_LONS) # Test North pole to South pole distance1, index1 = find_furthest_distance(ecef_points) self.assertEqual(index1, 11)
def test_EcefPath_find_index_and_ratio(self): ecef_points = calculate_EcefPoints(ROUTE_LATS, ROUTE_LONS) ecef_path = EcefPath(ecef_points, TURN_DISTANCES) # Start point index_0, ratio_0 = ecef_path.find_index_and_ratio(ecef_points[0]) self.assertEqual(index_0, 0) self.assertEqual(ratio_0, 0.0) # Point at end of a straight leg pos_1 = ecef_points[1] index_1, ratio_1 = ecef_path.find_index_and_ratio(pos_1) self.assertEqual(index_1, 1) self.assertEqual(ratio_1, 0.0) # Point in middle of a straight leg pos_1_5 = ecef_path.calculate_position(1, 0.5) index_1_5, ratio_1_5 = ecef_path.find_index_and_ratio(pos_1_5) self.assertEqual(index_1_5, 1) assert_almost_equal(ratio_1_5, 0.5) # Point toward end of a turning leg pos_1_9 = ecef_path.calculate_position(1, 0.99) index_1_9, ratio_1_9 = ecef_path.find_index_and_ratio(pos_1_9) self.assertEqual(index_1_9, 1) assert_almost_equal(ratio_1_9, 0.99) # Point in middle of a turn pos_2 = ecef_path.calculate_position(2, 0.0) index_2, ratio_2 = ecef_path.find_index_and_ratio(pos_2) self.assertEqual(index_2, 2) assert_almost_equal(ratio_2, 0.0) # Point toward start of a turning leg pos_2_1 = ecef_path.calculate_position(2, 0.01) index_2_1, ratio_2_1 = ecef_path.find_index_and_ratio(pos_2_1) self.assertEqual(index_2_1, 2) assert_almost_equal(ratio_2_1, 0.01) # Point along a turning leg pos_2_25 = ecef_path.calculate_position(2, 0.25) index_2_25, ratio_2_25 = ecef_path.find_index_and_ratio(pos_2_25) self.assertEqual(index_2_25, 2) assert_almost_equal(ratio_2_25, 0.25) # Point in middle of a turning leg pos_2_5 = ecef_path.calculate_position(2, 0.5) index_2_5, ratio_2_5 = ecef_path.find_index_and_ratio(pos_2_5) self.assertEqual(index_2_5, 2) assert_almost_equal(ratio_2_5, 0.5) # Point along a turning leg pos_2_75 = ecef_path.calculate_position(2, 0.75) index_2_75, ratio_2_75 = ecef_path.find_index_and_ratio(pos_2_75) self.assertEqual(index_2_75, 2) assert_almost_equal(ratio_2_75, 0.75) # Finish point index_last, ratio_last = ecef_path.find_index_and_ratio( ecef_points[-1]) self.assertEqual(index_last, 11) self.assertEqual(ratio_last, 0.0) # A waypoint not on path index_waypoint, ratio_waypoint = ecef_path.find_index_and_ratio( ecef_points[2]) self.assertEqual(index_waypoint, 2) assert_almost_equal(ratio_waypoint, 0.0, decimal=6)