def make_sample_trajectory(): coordinates = [(0, 80), (90, 80), (180, 80), (-90, 80), (0, 80)] time_strings = [ "2000-01-01 00:00:00", "2000-01-01 02:00:00", "2000-01-01 03:00:00", "2000-01-01 04:00:00", "2000-01-01 06:00:00" ] trajectory = TerrestrialTrajectory() for (coords, time_string) in zip(coordinates, time_strings): point = TerrestrialTrajectoryPoint(coords) point.object_id = 'terrestrial_dg_test' point.timestamp = datetime.datetime.strptime(time_string, '%Y-%m-%d %H:%M:%S') trajectory.append(point) return trajectory
def trajectory_point_generator(start_airport, end_airport, start_time, object_id='ANON', desired_speed=800, seconds_between_points=60, minimum_num_points=10): """trajectory_point_generator(start_airport: Airport, end_airport: Airport, start_time=Timestamp (datetime.datetime), object_id='ANON' (string), desired_speed=60 (float, km/h), seconds_between_points=60 (int), minimum_num_points=10 (int)) -> iterable of points Generate a sequence of points that go from the starting airport to the ending airport with the desired speed and time between points. """ start_position = TerrestrialTrajectoryPoint() start_position[0] = start_airport.position[0] start_position[1] = start_airport.position[1] end_position = TerrestrialTrajectoryPoint() end_position[0] = end_airport.position[0] end_position[1] = end_airport.position[1] travel_time = time_between_positions(start_position, end_position, desired_speed=desired_speed) num_points = num_points_between_positions( start_position, end_position, desired_speed=desired_speed, seconds_between_points=seconds_between_points) if num_points < minimum_num_points: num_points = minimum_num_points start_position.object_id = object_id start_position.timestamp = start_time end_position.object_id = object_id end_position.timestamp = start_time + travel_time point_list = [start_position] if num_points == 2: point_list.append(end_position) else: interpolant_increment = 1.0 / (num_points - 1) for i in range(1, num_points - 1): interpolant = i * interpolant_increment point_list.append( geomath.interpolate(start_position, end_position, interpolant)) point_list.append(end_position) return point_list
def create_trajectory(): los_angeles = AirTrajectoryPoint( -118.25, 34.05 ) los_angeles.object_id = 'TEST' los_angeles.timestamp = Timestamp.from_any('2014-01-01 00:00:00') los_angeles.properties['altitude'] = 0 new_york = AirTrajectoryPoint( -74.0, 40.71 ) source = path_point_source.TrajectoryPointSource(AirTrajectoryPoint) source.start_time = source.end_time = Timestamp.from_any('2014-01-01 04:00:00') source.start_point = los_angeles source.end_point = new_york source.num_points = 240 source.object_id = 'TEST' all_points = list(source.points()) # Now we need to add altitude. Let's say that we get to maximum # altitude (50,000 feet) at point 90. We start descending at # point 150 and get back to zero altitude at point 240. max_altitude = 50000 for i in range(240): all_points[i].altitude = max_altitude for i in range(90): x = float(i) / 90 level = 1 - (x-1)*(x-1) altitude = level * max_altitude all_points[i].altitude = altitude all_points[-(i+1)].altitude = altitude trajectory = AirTrajectory.from_position_list(all_points) return trajectory
def test_compute_bounding_box_after_pickle(): error_count = 0 albuquerque = TerrestrialTrajectoryPoint(-106.6504, 35.0844) albuquerque.timestamp = datetime.datetime(year=2020, month=1, day=1, hour=12) san_francisco = TerrestrialTrajectoryPoint(-122.4194, 37.7749) san_francisco.timestamp = albuquerque.timestamp + datetime.timedelta( hours=3) tokyo = TerrestrialTrajectoryPoint(-221.6917, 35.6895) tokyo.timestamp = albuquerque.timestamp + datetime.timedelta(hours=12) trajectory_generator = TrajectoryPointSource() trajectory_generator.start_point = albuquerque trajectory_generator.end_point = tokyo trajectory_generator.num_points = 20 print("DEBUG: TerrestrialTrajectory: {}".format(TerrestrialTrajectory)) albuquerque_to_tokyo = TerrestrialTrajectory.from_position_list( list(trajectory_generator.points())) expected_min_corner = tracktable.domain.domain_class_for_object( albuquerque, 'BasePoint')() expected_max_corner = tracktable.domain.domain_class_for_object( albuquerque, 'BasePoint')() expected_min_corner[0] = min(albuquerque[0], tokyo[0]) expected_min_corner[1] = min(albuquerque[1], tokyo[1]) expected_max_corner[0] = max(albuquerque[0], tokyo[0]) expected_max_corner[1] = max(albuquerque[1], tokyo[1]) bbox_before_pickling = geomath.compute_bounding_box(albuquerque_to_tokyo) store = io.BytesIO() pickle.dump(albuquerque_to_tokyo, store) store.seek(0) restored_trajectory = pickle.load(store) bbox_after_pickling = geomath.compute_bounding_box(restored_trajectory) print("Bounding box before pickling: ({} {}) - ({} {})".format( bbox_before_pickling.min_corner[0], bbox_before_pickling.min_corner[1], bbox_before_pickling.max_corner[0], bbox_before_pickling.max_corner[1])) print("Bounding box after pickling: ({} {}) - ({} {})".format( bbox_after_pickling.min_corner[0], bbox_after_pickling.min_corner[1], bbox_after_pickling.max_corner[0], bbox_after_pickling.max_corner[1])) bbox_min_delta = (bbox_after_pickling.min_corner[0] - bbox_before_pickling.min_corner[0], bbox_after_pickling.min_corner[1] - bbox_before_pickling.min_corner[1]) bbox_max_delta = (bbox_after_pickling.max_corner[0] - bbox_before_pickling.max_corner[0], bbox_after_pickling.max_corner[1] - bbox_before_pickling.max_corner[1]) if (math.fabs(bbox_min_delta[0]) > 0.01 or math.fabs(bbox_min_delta[1]) > 0.01 or math.fabs(bbox_max_delta[0]) > 0.01 or math.fabs(bbox_max_delta[1]) > 0.01): print( ("ERROR: Expected delta between bounding box before and after " "pickling to be zero. Delta for minimum corner is {}. " "Delta for maximum corner is {}.").format(bbox_min_delta, bbox_max_delta)) error_count += 1 return error_count
def test_trajectory(): print("Testing Trajectory class.") error_count = 0 right_now = datetime.datetime.now(pytz.utc) boston = TerrestrialTrajectoryPoint(-71.0636, 42.3581) boston.timestamp = right_now boston.object_id = 'ContinentalExpress' boston.set_property('favorite_food', 'baked_beans') boston.set_property('name', 'Boston') miami = TerrestrialTrajectoryPoint(-80.2241, 25.7877) miami.timestamp = right_now + datetime.timedelta(hours=4) miami.object_id = 'ContinentalExpress' miami.set_property('favorite_food', 'cuban_sandwich') miami.set_property('name', 'Miami') san_francisco = TerrestrialTrajectoryPoint(-122.4167, 37.7833) san_francisco.timestamp = right_now + datetime.timedelta(hours=8) san_francisco.object_id = 'ContinentalExpress' san_francisco.set_property('favorite_food', 'Ghirardelli chocolate') san_francisco.set_property('name', 'San Francisco') seattle = TerrestrialTrajectoryPoint(-122.3331, 47.6097) seattle.timestamp = right_now + datetime.timedelta(hours=12) seattle.object_id = 'ContinentalExpress' seattle.set_property('favorite_food', 'seafood') seattle.set_property('name', 'Seattle') boston_return = TerrestrialTrajectoryPoint(-71.0636, 42.3581) boston_return.timestamp = right_now + datetime.timedelta(hours=16) boston_return.object_id = 'ContinentalExpress' boston_return.set_property('favorite_food', 'baked_beans') boston_return.set_property('name', 'Boston') round_trip = [boston, miami, san_francisco, seattle, boston_return] my_trajectory = TerrestrialTrajectory.from_position_list(round_trip) print("Testing from_position_list") if len(my_trajectory) != 5: sys.stderr.write( 'ERROR: Expected length of trajectory to be 5 points but it was {}\n' .format(len(my_trajectory))) error_count += 1 print("Sanity-checking first and last points") restored_point = my_trajectory[0] if restored_point != boston: sys.stderr.write( 'ERROR: Expected first point in trajectory to be Boston. Instead it claims to be {}. Dumps of original and restored points follow.\n' .format(restored_point.property('name'))) sys.stderr.write(str(boston)) sys.stderr.write('\n') sys.stderr.write(str(my_trajectory[0])) sys.stderr.write('\n') error_count += 1 if my_trajectory[-1] != boston_return: sys.stderr.write( 'ERROR: Expected last point in trajectory to be Boston. Instead it claims to be {}.\n' .format(my_trajectory[-1].property('name'))) error_count += 1 print("Testing duration") duration = my_trajectory.duration if (duration != datetime.timedelta(hours=16)): sys.stderr.write( 'ERROR: Expected duration to be 16 hours. Instead it claims to be {}.\n' .format(duration)) error_count += 1 print("Testing time_at_fraction, 0.25") first_quarter_time = geomath.time_at_fraction(my_trajectory, 0.25) delta = my_trajectory[-1].timestamp - right_now expected_first_quarter_time = right_now + (delta // 4) error_count += verify_time(expected_first_quarter_time, first_quarter_time, "Time at fraction 0.25") print("Testing time_at_fraction, 0.75") last_quarter_time = geomath.time_at_fraction(my_trajectory, 0.75) delta = my_trajectory[-1].timestamp - right_now expected_last_quarter_time = right_now + ((3 * delta) // 4) error_count += verify_time(expected_last_quarter_time, last_quarter_time, "Time at fraction 0.75") print("Testing time_at_fraction, 0.5") midpoint_time = geomath.time_at_fraction(my_trajectory, 0.5) expected_midpoint_time = (right_now + (my_trajectory[-1].timestamp - right_now) // 2) error_count += verify_time(expected_midpoint_time, midpoint_time, "Time at fraction 0.5") print("Testing time_at_fraction, 0.0") start_time = geomath.time_at_fraction(my_trajectory, 0.0) expected_start_time = right_now error_count += verify_time(expected_start_time, start_time, "Time at fraction 0.0") print("Testing time_at_fraction, 1.0") end_time = geomath.time_at_fraction(my_trajectory, 1.0) expected_end_time = my_trajectory[-1].timestamp error_count += verify_time(expected_end_time, end_time, "Time at fraction 1.0") print("Testing time_at_fraction, -0.5") before_time = geomath.time_at_fraction(my_trajectory, -0.5) expected_before_time = right_now error_count += verify_time(expected_before_time, before_time, "Time at fraction -0.5") print("Testing time_at_fraction, 1.5") after_time = geomath.time_at_fraction(my_trajectory, 1.5) expected_after_time = my_trajectory[-1].timestamp error_count += verify_time(expected_after_time, after_time, "Time at fraction 1.5") print("Testing time_at_fraction, 0.33") first_third_time = geomath.time_at_fraction(my_trajectory, 1.0 / 3.0) expected_third_quarter_time = ( right_now + (my_trajectory[-1].timestamp - right_now) // 3) error_count += verify_time(expected_third_quarter_time, first_third_time, "Time at fraction 0.33") print("Testing time_at_fraction, No Points") empty_trajectory = TerrestrialTrajectory() empty_time = geomath.time_at_fraction(empty_trajectory, 0.5) error_count += verify_time( datetime.datetime(1900, 1, 1, 0, 0, 0, 0, pytz.utc), empty_time, "Time at fraction (no points)") print("Testing point_at_fraction, 0.25") first_quarter_point = geomath.point_at_fraction(my_trajectory, 0.25) expected_first_quarter_point = TerrestrialTrajectoryPoint( -80.2241, 25.7877) expected_first_quarter_point.timestamp = right_now + datetime.timedelta( hours=4) error_count += verify_point(expected_first_quarter_point, first_quarter_point, "Point at fraction 0.25") print("Testing point_at_fraction, 0.75") third_quarter_point = geomath.point_at_fraction(my_trajectory, 0.75) expected_third_quarter_point = TerrestrialTrajectoryPoint( -122.3331, 47.6097) expected_third_quarter_point.timestamp = right_now + datetime.timedelta( hours=12) error_count += verify_point(expected_third_quarter_point, third_quarter_point, "Point at fraction 0.75") print("Testing point_at_fraction, 0.5") mid_point = geomath.point_at_fraction(my_trajectory, 0.5) expected_mid_point = TerrestrialTrajectoryPoint(-122.4167, 37.7833) expected_mid_point.timestamp = right_now + datetime.timedelta(hours=8) error_count += verify_point(expected_mid_point, mid_point, "Point at fraction 0.5") print("Testing point_at_fraction, 0.0") start_point = geomath.point_at_fraction(my_trajectory, 0.0) expected_start_point = TerrestrialTrajectoryPoint(-71.0636, 42.3581) expected_start_point.timestamp = right_now error_count += verify_point(expected_start_point, start_point, "Point at fraction 0.0") print("Testing point_at_fraction, 1.0") end_point = geomath.point_at_fraction(my_trajectory, 1.0) expected_end_point = TerrestrialTrajectoryPoint(-71.0636, 42.3581) expected_end_point.timestamp = right_now + datetime.timedelta(hours=16) error_count += verify_point(expected_end_point, end_point, "Point at fraction 1.0") print("Testing point_at_fraction, -0.5") before_point = geomath.point_at_fraction(my_trajectory, -0.5) expected_before_point = TerrestrialTrajectoryPoint(-71.0636, 42.3581) expected_before_point.timestamp = right_now error_count += verify_point(expected_before_point, before_point, "Point at fraction -0.5") print("Testing point_at_fraction, 1.5") after_point = geomath.point_at_fraction(my_trajectory, 1.5) expected_after_point = TerrestrialTrajectoryPoint(-71.0636, 42.3581) expected_after_point.timestamp = right_now + datetime.timedelta(hours=16) error_count += verify_point(expected_after_point, after_point, "Point at fraction 1.5") print("Testing point_at_fraction, 0.33") first_third_point = geomath.point_at_fraction(my_trajectory, 1.0 / 3.0) expected_first_third_point = TerrestrialTrajectoryPoint(-92.9849, 31.3181) expected_first_third_point.timestamp = ( right_now + (my_trajectory[-1].timestamp - right_now) // 3) error_count += verify_point(expected_first_third_point, first_third_point, "Point at fraction 0.33") print("Testing point_at_fraction, No Points") no_point = geomath.point_at_fraction(empty_trajectory, 0.5) empty_point = TerrestrialTrajectoryPoint.zero() error_count += verify_point(no_point, empty_point, "Point at fraction (no points)") print("Testing point_at_length_fraction, 0.25") first_quarter_point = geomath.point_at_length_fraction(my_trajectory, 0.25) expected_first_quarter_point = TerrestrialTrajectoryPoint( -87.3824, 29.1092) expected_first_quarter_point.timestamp = first_quarter_point.timestamp error_count += verify_point(expected_first_quarter_point, first_quarter_point, "Point at length fraction 0.25") print("Testing point_at_length_fraction, 0.75") third_quarter_point = geomath.point_at_length_fraction(my_trajectory, 0.75) expected_third_quarter_point = TerrestrialTrajectoryPoint( -106.489, 48.5709) expected_third_quarter_point.timestamp = third_quarter_point.timestamp error_count += verify_point(expected_third_quarter_point, third_quarter_point, "Point at length fraction 0.75") print("Testing point_at_length_fraction, 0.5") mid_point = geomath.point_at_length_fraction(my_trajectory, 0.5) expected_mid_point = TerrestrialTrajectoryPoint(-116.267, 37.0967) expected_mid_point.timestamp = mid_point.timestamp error_count += verify_point(expected_mid_point, mid_point, "Point at length fraction 0.5") print("Testing point_at_length_fraction, 0.0") start_point = geomath.point_at_length_fraction(my_trajectory, 0.0) expected_start_point = TerrestrialTrajectoryPoint(-71.0636, 42.3581) expected_start_point.timestamp = right_now error_count += verify_point(expected_start_point, start_point, "Point at length fraction 0.0") print("Testing point_at_length_fraction, 1.0") end_point = geomath.point_at_length_fraction(my_trajectory, 1.0) expected_end_point = TerrestrialTrajectoryPoint(-71.0636, 42.3581) expected_end_point.timestamp = right_now + datetime.timedelta(hours=16) error_count += verify_point(expected_end_point, end_point, "Point at length fraction 1.0") print("Testing point_at_length_fraction, -0.5") before_point = geomath.point_at_length_fraction(my_trajectory, -0.5) expected_before_point = TerrestrialTrajectoryPoint(-71.0636, 42.3581) expected_before_point.timestamp = right_now error_count += verify_point(expected_before_point, before_point, "Point at length fraction -0.5") print("Testing point_at_length_fraction, 1.5") after_point = geomath.point_at_length_fraction(my_trajectory, 1.5) expected_after_point = TerrestrialTrajectoryPoint(-71.0636, 42.3581) expected_after_point.timestamp = right_now + datetime.timedelta(hours=16) error_count += verify_point(expected_after_point, after_point, "Point at length fraction 1.5") print("Testing point_at_length_fraction, 0.33") first_third_point = geomath.point_at_length_fraction( my_trajectory, 1.0 / 3.0) expected_first_third_point = TerrestrialTrajectoryPoint(-96.4035, 32.5023) expected_first_third_point.timestamp = first_third_point.timestamp error_count += verify_point(expected_first_third_point, first_third_point, "Point at length fraction 0.33") print("Testing point_at_length_fraction, No Points") no_point = geomath.point_at_length_fraction(empty_trajectory, 0.5) empty_point = TerrestrialTrajectoryPoint.zero() error_count += verify_point(no_point, empty_point, "Point at length fraction (no points)") print("Testing interpolation at timestamp before trajectory") before_time = right_now - datetime.timedelta(hours=4) before_point = geomath.point_at_time(my_trajectory, before_time) error_count += verify_point(boston, before_point, "Point at time (-4 hours)") print("Testing interpolation at start timestamp of trajectory") start_time = right_now start_point = geomath.point_at_time(my_trajectory, start_time) error_count += verify_point(boston, start_point, "Point at time (0 hours)") print("Testing interpolation at first third timestamp of trajectory") first_third_time = right_now + datetime.timedelta(hours=16.0 / 3.0) first_third_point = geomath.point_at_time(my_trajectory, first_third_time) expected_first_third_point = TerrestrialTrajectoryPoint(-92.9849, 31.3181) expected_first_third_point.timestamp = right_now + datetime.timedelta( hours=16.0 / 3.0) error_count += verify_point(expected_first_third_point, first_third_point, "Point at time (+5.33 hours)") print("Testing interpolation at mid timestamp of trajectory") mid_time = right_now + datetime.timedelta(hours=8) mid_point = geomath.point_at_time(my_trajectory, mid_time) error_count += verify_point(san_francisco, mid_point, "Point at time (+8 hours)") print("Testing interpolation at end timestamp of trajectory") end_time = right_now + datetime.timedelta(hours=16) end_point = geomath.point_at_time(my_trajectory, end_time) error_count += verify_point(boston_return, end_point, "Point at time (+16 hours)") print("Testing interpolation at timestamp after trajectory") after_time = right_now + datetime.timedelta(hours=20) after_point = geomath.point_at_time(my_trajectory, after_time) error_count += verify_point(boston_return, after_point, "Point at time (+20 hours)") print("Testing interpolation at timestamp with no points trajectory") no_point = geomath.point_at_time(empty_trajectory, right_now + datetime.timedelta(hours=8)) empty_point = TerrestrialTrajectoryPoint() error_count += verify_point(empty_point, no_point, "Point at time (no points)") # print("Testing pickle support") # picklebuf = StringIO() # pickle.dump(my_trajectory, picklebuf) # restorebuf = StringIO(picklebuf.getvalue()) # restored_trajectory = pickle.load(restorebuf) # if my_trajectory != restored_trajectory: # sys.stderr.write('ERROR: Original trajectory is not the same as the one being restored from pickle jar.\n') # sys.stderr.write('Original trajectory: {}'.format(my_trajectory)) # sys.stderr.write('Restored trajectory: {}'.format(restored_trajectory)) # error_count += 1 if error_count == 0: print("Surface trajectory passed all tests.") return error_count
def create_point(lat, lon, id): point = TerrestrialTrajectoryPoint(lon, lat) point.object_id = id return point
def test_point_type(): print("Testing point type") error_count = 0 point1 = TerrestrialBasePoint(45, 45) point2 = TerrestrialBasePoint(135, 45) print("Testing terrestrial base point interpolate, 0.5") result = geomath.interpolate(point1, point2, 0.5) expected = TerrestrialBasePoint(90, 54.7356) error_count += verify_base_point(expected, result, "Terrestrial Base Point Interpolate 0.5") print("Testing terrestrial base point interpolate, 0.3") result = geomath.interpolate(point1, point2, 0.3) expected = TerrestrialBasePoint(69.7884, 53.0018) error_count += verify_base_point(expected, result, "Terrestrial Base Point Interpolate 0.3") print("Testing terrestrial base point interpolate, 1") result = geomath.interpolate(point1, point2, 1) error_count += verify_base_point(point2, result, "Terrestrial Base Point Interpolate 1") print("Testing terrestrial base point extrapolate, 2") result = geomath.extrapolate(point1, point2, 2) expected = TerrestrialBasePoint(180, 0) error_count += verify_base_point(expected, result, "Terrestrial Base Point Extrapolate 2") point3 = Cartesian2DBasePoint(0, 0) point4 = Cartesian2DBasePoint(10, 10) print("Testing cartesian2d base point interpolate, 0.5") result = geomath.interpolate(point3, point4, 0.5) expected = Cartesian2DBasePoint(5, 5) error_count += verify_base_point(expected, result, "Cartesian2D Base Point Interpolate 0.5") print("Testing cartesian2d base point interpolate, 0.3") result = geomath.interpolate(point3, point4, 0.3) expected = Cartesian2DBasePoint(3, 3) error_count += verify_base_point(expected, result, "Cartesian2D Base Point Interpolate 0.3") print("Testing cartesian2d base point interpolate, 1") result = geomath.interpolate(point3, point4, 1) error_count += verify_base_point(point4, result, "Cartesian2D Base Point Interpolate 1") print("Testing cartesian2d base point extrapolate, 1.5") result = geomath.extrapolate(point3, point4, 1.5) expected = Cartesian2DBasePoint(15, 15) error_count += verify_base_point(expected, result, "Cartesian2D Base Point Extrapolate 1.5") point5 = Cartesian3DBasePoint(0, 0, 0) point6 = Cartesian3DBasePoint(10, 10, 10) print("Testing cartesian3d base point interpolate, 0.5") result = geomath.interpolate(point5, point6, 0.5) expected = Cartesian3DBasePoint(5, 5, 5) error_count += verify_base_point(expected, result, "Cartesian3D Base Point Interpolate 0.5") print("Testing cartesian3d base point interpolate, 0.3") result = geomath.interpolate(point5, point6, 0.3) expected = Cartesian3DBasePoint(3, 3, 3) error_count += verify_base_point(expected, result, "Cartesian3D Base Point Interpolate 0.3") print("Testing cartesian3d base point interpolate, 1") result = geomath.interpolate(point5, point6, 1) error_count += verify_base_point(point6, result, "Cartesian3D Base Point Interpolate 1") print("Testing cartesian3d base point extrapolate, 1.5") result = geomath.extrapolate(point5, point6, 1.5) expected = Cartesian3DBasePoint(15, 15, 15) error_count += verify_base_point(expected, result, "Cartesian3D Base Point Extrapolate 1.5") point7 = TerrestrialTrajectoryPoint(10, 30) point7.timestamp = datetime.strptime("2020-12-01 00:00:00", "%Y-%m-%d %H:%M:%S") point7.object_id = 'FOO' point7.set_property('speed', 100.0) point7.set_property('heading', 0.0) point8 = TerrestrialTrajectoryPoint(14.6929, 35.1023) point8.timestamp = datetime.strptime("2020-12-01 00:30:00", "%Y-%m-%d %H:%M:%S") point8.object_id = 'FOO' point8.set_property('speed', 150.0) point8.set_property('heading', 90.0) point9 = TerrestrialTrajectoryPoint(20, 40) point9.timestamp = datetime.strptime("2020-12-01 01:00:00", "%Y-%m-%d %H:%M:%S") point9.object_id = 'FOO' point9.set_property('speed', 200.0) point9.set_property('heading', 180.0) print("Testing terrestrial trajectory point interpolate, 0.5") result = geomath.interpolate(point7, point9, 0.5) error_count += verify_trajectory_point( point8, result, "Terrestrial Trajectory Point Interpolate 0.5") print("Testing terrestrial trajectory point extrapolate, 2") result = geomath.extrapolate(point7, point8, 2) error_count += verify_trajectory_point( point9, result, "Terrestrial Trajectory Point Extrapolate 2") point10 = Cartesian2DTrajectoryPoint(5, 5) point10.timestamp = datetime.strptime("2020-12-01 00:00:00", "%Y-%m-%d %H:%M:%S") point10.object_id = 'FOO' point10.set_property('speed', 10.0) point10.set_property('heading', 0.0) point11 = Cartesian2DTrajectoryPoint(10, 10) point11.timestamp = datetime.strptime("2020-12-01 00:30:00", "%Y-%m-%d %H:%M:%S") point11.object_id = 'FOO' point11.set_property('speed', 15.0) point11.set_property('heading', 90.0) point12 = Cartesian2DTrajectoryPoint(15, 15) point12.timestamp = datetime.strptime("2020-12-01 01:00:00", "%Y-%m-%d %H:%M:%S") point12.object_id = 'FOO' point12.set_property('speed', 20.0) point12.set_property('heading', 180.0) print("Testing cartesian2d trajectory point interpolate, 0.5") result = geomath.interpolate(point10, point12, 0.5) error_count += verify_trajectory_point( point11, result, "Cartesian2D Trajectory Point Interpolate 0.5") print("Testing cartesian2d trajectory point extrapolate, 2") result = geomath.extrapolate(point10, point11, 2) error_count += verify_trajectory_point( point12, result, "Cartesian2D Trajectory Point Extrapolate 2") point13 = Cartesian3DTrajectoryPoint(5, 5, 5) point13.timestamp = datetime.strptime("2020-12-01 00:00:00", "%Y-%m-%d %H:%M:%S") point13.object_id = 'FOO' point13.set_property('speed', 10.0) point13.set_property('heading', 0.0) point14 = Cartesian3DTrajectoryPoint(10, 10, 10) point14.timestamp = datetime.strptime("2020-12-01 00:30:00", "%Y-%m-%d %H:%M:%S") point14.object_id = 'FOO' point14.set_property('speed', 15.0) point14.set_property('heading', 90.0) point15 = Cartesian3DTrajectoryPoint(15, 15, 15) point15.timestamp = datetime.strptime("2020-12-01 01:00:00", "%Y-%m-%d %H:%M:%S") point15.object_id = 'FOO' point15.set_property('speed', 20.0) point15.set_property('heading', 180.0) print("Testing cartesian3d trajectory point interpolate, 0.5") result = geomath.interpolate(point13, point15, 0.5) error_count += verify_trajectory_point( point14, result, "Cartesian3D Trajectory Point Interpolate 0.5") print("Testing cartesian3d trajectory point extrapolate, 2") result = geomath.extrapolate(point13, point14, 2) error_count += verify_trajectory_point( point15, result, "Cartesian3D Trajectory Point Extrapolate 2") return error_count
def run_test(): num_errors = 0 source = TrajectoryPointSource() start_time = Timestamp.from_any(datetime.datetime(2010, 10, 13, 12, 00, 00)) end_time = Timestamp.from_any(datetime.datetime(2010, 10, 13, 18, 00, 00)) start_point = TrajectoryPoint(-100, 35.0) start_point.object_id = 'foo' start_point.timestamp = start_time end_point = TrajectoryPoint(-80, 45.0) end_point.object_id = 'foo' end_point.timestamp = end_time num_points = 100 source.start_point = start_point source.end_point = end_point source.num_points = num_points all_points = list(source.points()) if len(all_points) != num_points: sys.stderr.write( 'ERROR: GreatCircleTrajectoryPointSource: Expected {} points but got {}\n' .format(num_points, len(all_points))) num_errors += 1 traj_start_point = (all_points[0][0], all_points[0][1]) d_lon = all_points[0][0] - start_point[0] d_lat = all_points[0][1] - start_point[1] if math.fabs(d_lon) > 1e-5 or math.fabs(d_lat) > 1e-5: sys.stderr.write( 'ERROR: GreatCircleTrajectoryPointSource: Expected first point to be {} but got {} instead\n' .format(start_point, traj_start_point)) num_errors += 1 traj_end_point = (all_points[-1][0], all_points[-1][1]) d_lon = all_points[-1][0] - end_point[0] d_lat = all_points[-1][1] - end_point[1] if math.fabs(d_lon) > 1e-5 or math.fabs(d_lat) > 1e-5: sys.stderr.write( 'ERROR: GreatCircleTrajectoryPointSource: Expected last point to be {} but got {} instead\n' .format(end_point, traj_end_point)) num_errors += 1 traj_start_time = all_points[0].timestamp d_time = math.fabs((traj_start_time - start_time).total_seconds()) if d_time > 0.001: sys.stderr.write( 'ERROR: GreatCircleTrajectoryPointSource: Expected timestamp on first point to be {} but got {} instead\n' .format(start_time, traj_start_time)) num_errors += 1 traj_end_time = all_points[-1].timestamp d_time = math.fabs((traj_end_time - end_time).total_seconds()) if d_time > 0.001: sys.stderr.write( 'ERROR: GreatCircleTrajectoryPointSource: Expected timestamp on last point to be {} but got {} instead\n' .format(end_time, traj_end_time)) num_errors += 1 return num_errors
def run_test(): # Define three sets of points: ABQ to San Diego, San Diego to # Seattle, Denver to NYC. ABQ->SAN->SEA should break into two # trajectories because of a timestamp break in San Diego. The # flight to Denver will begin right when the flight to Seattle # ends so we expect to break that one based on the distance # threshold. print("Beginning run_test()") from tracktable.domain.terrestrial import TrajectoryPoint albuquerque = TrajectoryPoint( -106.5, 35.25 ) albuquerque.timestamp = Timestamp.from_string('2010-01-01 12:00:00') albuquerque.object_id = 'flight1' san_diego1 = TrajectoryPoint( -117.16, 32.67 ) san_diego1.timestamp = Timestamp.from_string('2010-01-01 15:00:00') san_diego1.object_id = 'flight1' san_diego2 = TrajectoryPoint( -117.16, 32.67 ) san_diego2.timestamp = Timestamp.from_string('2010-01-01 16:00:00') san_diego2.object_id = 'flight1' seattle = TrajectoryPoint( -122.31, 47.60 ) seattle.timestamp = Timestamp.from_string('2010-01-01 19:00:00') seattle.object_id = 'flight1' denver = TrajectoryPoint( -104.98, 39.79 ) denver.timestamp = Timestamp.from_string('2010-01-01 19:01:00') denver.object_id = 'flight1' new_york = TrajectoryPoint( -74.02, 40.71 ) new_york.timestamp = Timestamp.from_string('2010-01-02 00:00:00') new_york.object_id = 'flight1' # Now we want sequences of points for each flight. abq_to_sd = TrajectoryPointSource() abq_to_sd.start_point = albuquerque abq_to_sd.end_point = san_diego1 abq_to_sd.num_points = 180 sd_to_sea = TrajectoryPointSource() sd_to_sea.start_point = san_diego2 sd_to_sea.end_point = seattle sd_to_sea.num_points = 360 # flying very slowly denver_to_nyc = TrajectoryPointSource() denver_to_nyc.start_point = denver denver_to_nyc.end_point = new_york denver_to_nyc.num_points = 600 # wow, very densely sampled print("Done creating point sources") all_points = list(itertools.chain( abq_to_sd.points(), sd_to_sea.points(), denver_to_nyc.points() )) trajectory_assembler = AssembleTrajectoryFromPoints() trajectory_assembler.input = all_points trajectory_assembler.separation_time = timedelta(minutes=30) trajectory_assembler.separation_distance = 100 trajectory_assembler_minimum_length = 10 print("Done instantiating assembler") all_trajectories = list(trajectory_assembler.trajectories()) print("Assembler statistics: {} points, {} valid trajectories, {} invalid trajectories".format( trajectory_assembler.valid_trajectory_count, trajectory_assembler.invalid_trajectory_count, trajectory_assembler.points_processed_count )) print("Done creating trajectories. Found {}.".format(len(all_trajectories))) test_point_proximity = geomath.sanity_check_distance_less_than(1) def test_timestamp_proximity(time1, time2): return ( (time2 - time1).total_seconds() < 1 ) error_count = 0 if len(all_trajectories) != 3: sys.stdout.write('ERROR: test_trajectory_assembly: Expected 3 trajectories but got {}\n'.format(len(all_trajectories))) error_count += 1 if not test_point_proximity(all_trajectories[0][0], albuquerque): sys.stdout.write('ERROR: test_trajectory_assembly: Expected point 0 of first trajectory to be Albuquerque ({}) but it is instead {}\n'.format(albuquerque, str(all_trajectories[0][0]))) error_count += 1 if not test_point_proximity(all_trajectories[0][-1], san_diego1): sys.stdout.write('ERROR: test_trajectory_assembly: Expected last point of first trajectory to be San Diego ({}) but it is instead {}\n'.format(san_diego, str(all_trajectories[0][-1]))) error_count += 1 if not test_point_proximity(all_trajectories[1][0], san_diego2): sys.stdout.write('ERROR: test_trajectory_assembly: Expected point 0 of second trajectory to be San Diego ({}) but it is instead {}\n'.format(san_diego, str(all_trajectories[1][0]))) error_count += 1 if not test_point_proximity(all_trajectories[1][-1], seattle): sys.stdout.write('ERROR: test_trajectory_assembly: Expected last point of second trajectory to be Seattle ({}) but it is instead {}\n'.format(seattle, str(all_trajectories[1][-1]))) error_count += 1 if not test_point_proximity(all_trajectories[2][0], denver): sys.stdout.write('ERROR: test_trajectory_assembly: Expected first point of third trajectory to be Denver ({}) but it is instead {}\n'.format(denver, str(all_trajectories[2][0]))) error_count += 1 if not test_point_proximity(all_trajectories[2][-1], new_york): sys.stdout.write('ERROR: test_trajectory_assembly: Expected last point of third trajectory to be New York ({}) but it is instead {}\n'.format(new_york, str(all_trajectories[2][-1]))) error_count += 1 if not test_timestamp_proximity(all_trajectories[0][0].timestamp, albuquerque.timestamp): sys.stdout.write('ERROR: test_trajectory_assembly: Expected timestamp at beginning of trajectory 0 to be {} but it is instead {}\n'.format(albuquerque.timestamp, all_trajectories[0][0].timestamp)) error_count += 1 if not test_timestamp_proximity(all_trajectories[0][-1].timestamp, san_diego1.timestamp): sys.stdout.write('ERROR: test_trajectory_assembly: Expected timestamp at end of trajectory 0 to be {} but it is instead {}\n'.format(san_diego1.timestamp, all_trajectories[0][-1].timestamp)) error_count += 1 if not test_timestamp_proximity(all_trajectories[1][0].timestamp, san_diego2.timestamp): sys.stdout.write('ERROR: test_trajectory_assembly: Expected timestamp at beginning of trajectory 1 to be {} but it is instead {}\n'.format(san_diego2.timestamp, all_trajectories[1][0].timestamp)) error_count += 1 if not test_timestamp_proximity(all_trajectories[1][-1].timestamp, seattle.timestamp): sys.stdout.write('ERROR: test_trajectory_assembly: Expected end at beginning of trajectory 1 to be {} but it is instead {}\n'.format(seattle.timestamp, all_trajectories[1][-1].timestamp)) error_count += 1 if not test_timestamp_proximity(all_trajectories[2][0].timestamp, denver.timestamp): sys.stdout.write('ERROR: test_trajectory_assembly: Expected timestamp at beginning of trajectory 2 to be {} but it is instead {}\n'.format(denver.timestamp, all_trajectories[2][0].timestamp)) error_count += 1 if not test_timestamp_proximity(all_trajectories[2][-1].timestamp, new_york.timestamp): sys.stdout.write('ERROR: test_trajectory_assembly: Expected timestamp at end of trajectory 2 to be {} but it is instead {}\n'.format(new_york.timestamp, all_trajectories[2][-1].timestamp)) error_count += 1 print("Done checking proximities") return error_count