def test_get_waypoint_travel_time(self): """Tests travel time calc.""" test_spds = [1, 10, 100, 500] for (lon2, lat2, lon1, lat1, dist_km) in TESTDATA_COMPETITION_DIST: dist_ft = units.kilometers_to_feet(dist_km) for speed in test_spds: speed_fps = units.knots_to_feet_per_second(speed) time = dist_ft / speed_fps gpos1 = GpsPosition() gpos1.latitude = lat1 gpos1.longitude = lon1 gpos1.save() apos1 = AerialPosition() apos1.gps_position = gpos1 apos1.altitude_msl = 0 apos1.save() wpt1 = Waypoint() wpt1.position = apos1 gpos2 = GpsPosition() gpos2.latitude = lat2 gpos2.longitude = lon2 gpos2.save() apos2 = AerialPosition() apos2.gps_position = gpos2 apos2.altitude_msl = 0 apos2.save() wpt2 = Waypoint() wpt2.position = apos2 waypoints = [wpt1, wpt2] obstacle = MovingObstacle() obstacle.speed_avg = speed self.assertTrue( self.eval_travel_time( obstacle.get_waypoint_travel_time(waypoints, 0, 1), time))
def test_duplicate_unequal(self): """Tests the duplicate function with unequal positions.""" pos1 = AerialPosition(latitude=0, longitude=0, altitude_msl=0) pos2 = AerialPosition(latitude=1, longitude=1, altitude_msl=0) pos3 = AerialPosition(latitude=0, longitude=0, altitude_msl=1) self.assertFalse(pos1.duplicate(pos2)) self.assertFalse(pos1.duplicate(pos3))
def setUp(self): """Create the obstacles for testing.""" # Obstacle with no waypoints obst_no_wpt = MovingObstacle() obst_no_wpt.speed_avg = 1 obst_no_wpt.sphere_radius = 1 obst_no_wpt.save() self.obst_no_wpt = obst_no_wpt # Obstacle with single waypoint self.single_wpt_lat = 40 self.single_wpt_lon = 76 self.single_wpt_alt = 100 obst_single_wpt = MovingObstacle() obst_single_wpt.speed_avg = 1 obst_single_wpt.sphere_radius = 1 obst_single_wpt.save() single_gpos = GpsPosition() single_gpos.latitude = self.single_wpt_lat single_gpos.longitude = self.single_wpt_lon single_gpos.save() single_apos = AerialPosition() single_apos.gps_position = single_gpos single_apos.altitude_msl = self.single_wpt_alt single_apos.save() single_wpt = Waypoint() single_wpt.position = single_apos single_wpt.order = 1 single_wpt.save() obst_single_wpt.waypoints.add(single_wpt) self.obst_single_wpt = obst_single_wpt # Obstacles with predefined path self.obstacles = [] for path in TESTDATA_MOVOBST_PATHS: cur_obst = MovingObstacle() cur_obst.speed_avg = 68 cur_obst.sphere_radius = 10 cur_obst.save() for pt_id in range(len(path)): (lat, lon, alt) = path[pt_id] cur_gpos = GpsPosition() cur_gpos.latitude = lat cur_gpos.longitude = lon cur_gpos.save() cur_apos = AerialPosition() cur_apos.gps_position = cur_gpos cur_apos.altitude_msl = alt cur_apos.save() cur_wpt = Waypoint() cur_wpt.position = cur_apos cur_wpt.order = pt_id cur_wpt.save() cur_obst.waypoints.add(cur_wpt) cur_obst.save() self.obstacles.append(cur_obst)
def evaluate_distance_inputs(self, io_list): """Evaluates the distance_to calc with the given input list.""" for (lon1, lat1, alt1, lon2, lat2, alt2, dist_actual) in io_list: pos1 = AerialPosition(latitude=lat1, longitude=lon1, altitude_msl=alt1) pos2 = AerialPosition(latitude=lat2, longitude=lon2, altitude_msl=alt2) self.assertDistanceEqual(pos1, pos2, dist_actual)
def test_duplicate_equal(self): """Tests the duplicate function with unequal positions.""" gps1 = GpsPosition(latitude=0, longitude=0) gps1.save() gps2 = GpsPosition(latitude=0, longitude=0) gps2.save() pos1 = AerialPosition(gps_position=gps1, altitude_msl=0) pos2 = AerialPosition(gps_position=gps2, altitude_msl=0) pos3 = AerialPosition(gps_position=gps1, altitude_msl=0) self.assertTrue(pos1.duplicate(pos2)) self.assertTrue(pos1.duplicate(pos3))
def setUp(self): """Sets up the tests.""" super(TestOdlc, self).setUp() self.user = User.objects.create_user('user', '*****@*****.**', 'pass') # Mission pos = GpsPosition() pos.latitude = 10 pos.longitude = 100 pos.save() apos = AerialPosition() apos.altitude_msl = 1000 apos.gps_position = pos apos.save() wpt = Waypoint() wpt.position = apos wpt.order = 10 wpt.save() self.mission = MissionConfig() self.mission.home_pos = pos self.mission.emergent_last_known_pos = pos self.mission.off_axis_odlc_pos = pos self.mission.air_drop_pos = pos self.mission.save() self.mission.mission_waypoints.add(wpt) self.mission.search_grid_points.add(wpt) self.mission.save()
def setUp(self): # Mission pos = GpsPosition() pos.latitude = 10 pos.longitude = 100 pos.save() apos = AerialPosition() apos.altitude_msl = 1000 apos.gps_position = pos apos.save() wpt = Waypoint() wpt.position = apos wpt.order = 10 wpt.save() self.mission = MissionConfig() self.mission.home_pos = pos self.mission.emergent_last_known_pos = pos self.mission.off_axis_odlc_pos = pos self.mission.air_drop_pos = pos self.mission.save() self.mission.mission_waypoints.add(wpt) self.mission.search_grid_points.add(wpt) self.mission.save() # Mission 2 self.mission2 = MissionConfig() self.mission2.home_pos = pos self.mission2.emergent_last_known_pos = pos self.mission2.off_axis_odlc_pos = pos self.mission2.air_drop_pos = pos self.mission2.save() self.mission2.mission_waypoints.add(wpt) self.mission2.search_grid_points.add(wpt) self.mission2.save()
def setUp(self): self.user = User.objects.create_user('testuser', '*****@*****.**', 'testpass') self.user.save() # Mission pos = GpsPosition() pos.latitude = 10 pos.longitude = 100 pos.save() apos = AerialPosition() apos.latitude = 10 apos.longitude = 100 apos.altitude_msl = 1000 apos.save() wpt = Waypoint() wpt.latitude = 10 wpt.longitude = 100 wpt.altitude_msl = 1000 wpt.order = 10 wpt.save() self.mission = MissionConfig() self.mission.home_pos = pos self.mission.emergent_last_known_pos = pos self.mission.off_axis_odlc_pos = pos self.mission.air_drop_pos = pos self.mission.save() self.mission.mission_waypoints.add(wpt) self.mission.search_grid_points.add(wpt) self.mission.save() self.now = timezone.now()
def create_uas_logs(self, user, entries): """Create a list of uas telemetry logs. Args: user: User to create logs for. entries: List of (lat, lon, alt) tuples for each entry. Returns: List of UasTelemetry objects """ ret = [] for i in range(len(entries)): lat, lon, alt = entries[i] pos = GpsPosition() pos.latitude = lat pos.longitude = lon pos.save() apos = AerialPosition() apos.altitude_msl = alt apos.gps_position = pos apos.save() log = UasTelemetry() log.user = user log.uas_position = apos log.uas_heading = 0 if i > 0: log.timetamp = ret[i - 1].timestamp + timedelta(seconds=1) log.save() ret.append(log) return ret
def test_contains_pos(self): """Tests the inside obstacle method.""" # (lat, lon, rad, height) TESTDATA_STATOBST_CONTAINSPOS_OBJ = (-76, 38, 100, 200) # (lat, lon, alt) TESTDATA_STATOBST_CONTAINSPOS_INSIDE = [ (-76, 38, 0), (-76, 38, -1), (-76, 38, 200), (-76.0002, 38, 100), (-76, 38.0003, 100) ] # yapf: disable TESTDATA_STATOBST_CONTAINSPOS_OUTSIDE = [ (-76, 38, 201), (-76.0003, 38, 100), (-76, 38.004, 100) ] # yapf: disable # Form the test obstacle pos = GpsPosition(latitude=TESTDATA_STATOBST_CONTAINSPOS_OBJ[0], longitude=TESTDATA_STATOBST_CONTAINSPOS_OBJ[1]) pos.save() obst = StationaryObstacle( gps_position=pos, cylinder_radius=TESTDATA_STATOBST_CONTAINSPOS_OBJ[2], cylinder_height=TESTDATA_STATOBST_CONTAINSPOS_OBJ[3]) # Run test points against obstacle test_data = [(TESTDATA_STATOBST_CONTAINSPOS_INSIDE, True), (TESTDATA_STATOBST_CONTAINSPOS_OUTSIDE, False)] for (cur_data, cur_contains) in test_data: for (lat, lon, alt) in cur_data: pos = GpsPosition(latitude=lat, longitude=lon) pos.save() apos = AerialPosition(gps_position=pos, altitude_msl=alt) self.assertEqual(obst.contains_pos(apos), cur_contains)
def create_moving_obstacle(self, waypoints): """Create a new MovingObstacle model. Args: waypoints: List of (lat, lon, alt) tuples Returns: Saved MovingObstacle """ obstacle = MovingObstacle(speed_avg=40, sphere_radius=100) obstacle.save() for num, waypoint in enumerate(waypoints): (lat, lon, alt) = waypoint gps = GpsPosition(latitude=lat, longitude=lon) gps.save() pos = AerialPosition(gps_position=gps, altitude_msl=alt) pos.save() waypoint = Waypoint(order=num, position=pos) waypoint.save() obstacle.waypoints.add(waypoint) obstacle.save() return obstacle
def create_logs(self, user, num=10, start=None, delta=None, altitude=100, heading=90): if start is None: start = timezone.now() if delta is None: delta = datetime.timedelta(seconds=1) logs = [] for i in xrange(num): gps = GpsPosition( latitude=38 + 0.001 * i, longitude=-78 + 0.001 * i) gps.save() pos = AerialPosition(gps_position=gps, altitude_msl=altitude) pos.save() log = UasTelemetry( user=user, uas_position=pos, uas_heading=heading) log.save() log.timestamp = start + i * delta log.save() logs.append(log) return logs
def create_uas_logs(self, user, entries): """Create a list of uas telemetry logs. Args: user: User to create logs for. entries: List of (lat, lon, alt) tuples for each entry. Returns: List of UasTelemetry objects """ ret = [] for (lat, lon, alt) in entries: pos = GpsPosition() pos.latitude = lat pos.longitude = lon pos.save() apos = AerialPosition() apos.altitude_msl = alt apos.gps_position = pos apos.save() log = UasTelemetry() log.user = user log.uas_position = apos log.uas_heading = 0 log.save() ret.append(log) return ret
def setUp(self): """Creates test data.""" # Form test set for contains position self.testdata_containspos = [] for test_data in TESTDATA_FLYZONE_CONTAINSPOS: # Create the FlyZone zone = FlyZone() zone.altitude_msl_min = test_data['min_alt'] zone.altitude_msl_max = test_data['max_alt'] zone.save() for waypoint_id in range(len(test_data['waypoints'])): (lat, lon) = test_data['waypoints'][waypoint_id] gpos = GpsPosition() gpos.latitude = lat gpos.longitude = lon gpos.save() apos = AerialPosition() apos.gps_position = gpos apos.altitude_msl = 0 apos.save() wpt = Waypoint() wpt.order = waypoint_id wpt.position = apos wpt.save() zone.boundary_pts.add(wpt) # Form test set test_pos = [] for pos in test_data['inside_pos']: test_pos.append((pos, True)) for pos in test_data['outside_pos']: test_pos.append((pos, False)) # Store self.testdata_containspos.append((zone, test_pos))
def test_contains_pos(self): """Tests the contains_pos method.""" for (zone, test_pos) in self.testdata_containspos: for ((lat, lon, alt), inside) in test_pos: apos = AerialPosition() apos.latitude = lat apos.longitude = lon apos.altitude_msl = alt self.assertEqual(zone.contains_pos(apos), inside)
def evaluate_inputs(self, io_list): for (lon1, lat1, alt1, lon2, lat2, alt2, dist) in io_list: gps1 = GpsPosition(latitude=lat1, longitude=lon1) gps1.save() gps2 = GpsPosition(latitude=lat2, longitude=lon2) gps2.save() pos1 = AerialPosition(gps_position=gps1, altitude_msl=alt1) pos1.save() pos2 = AerialPosition(gps_position=gps2, altitude_msl=alt2) pos2.save() wpt1 = Waypoint(position=pos1) wpt2 = Waypoint(position=pos2) self.assertDistanceEqual(wpt1, wpt2, dist)
def test_unicode(self): """Tests the unicode method executes.""" gps = GpsPosition(latitude=10, longitude=100) gps.save() pos = AerialPosition(gps_position=gps, altitude_msl=100) pos.save() pos.__unicode__()
def create_log_element(self, timestamp, user, lat, lon, alt, heading): pos = GpsPosition(latitude=lat, longitude=lon) pos.save() apos = AerialPosition(gps_position=pos, altitude_msl=alt) apos.save() log = UasTelemetry(timestamp=timezone.now(), user=user, uas_position=apos, uas_heading=heading) log.save() return log
def test_evaluate_collision_with_uas(self): """Tests the collision with UAS method.""" # Get test data user = User.objects.create_user('testuser', '*****@*****.**', 'testpass') user.save() testdata = TESTDATA_MOVOBST_EVALCOLLISION (obst_rad, obst_speed, obst_pos, log_details) = testdata # Create the obstacle obst = MovingObstacle() obst.speed_avg = obst_speed obst.sphere_radius = obst_rad obst.save() for pos_id in xrange(len(obst_pos)): (lat, lon, alt) = obst_pos[pos_id] gpos = GpsPosition() gpos.latitude = lat gpos.longitude = lon gpos.save() apos = AerialPosition() apos.gps_position = gpos apos.altitude_msl = alt apos.save() wpt = Waypoint() wpt.order = pos_id wpt.position = apos wpt.save() obst.waypoints.add(wpt) obst.save() # Create sets of logs epoch = timezone.now().replace(year=1970, month=1, day=1, hour=0, minute=0, second=0, microsecond=0) inside_logs = [] outside_logs = [] for (time_sec, inside_pos, outside_pos) in log_details: log_time = epoch + datetime.timedelta(seconds=time_sec) logs_pos = [(inside_pos, inside_logs), (outside_pos, outside_logs)] for (positions, log_list) in logs_pos: for (lat, lon, alt) in positions: log = self.create_log(lat, lon, alt, user, log_time) log_list.append(log) # Assert the obstacle correctly computes collisions log_collisions = [(True, inside_logs), (False, outside_logs)] for (inside, logs) in log_collisions: self.assertEqual(obst.evaluate_collision_with_uas(logs), inside) for log in logs: self.assertEqual(obst.evaluate_collision_with_uas([log]), inside)
def create_log_element(self, timestamp, lat, lon, alt, heading, user=None): if user is None: user = self.user pos = GpsPosition(latitude=lat, longitude=lon) pos.save() apos = AerialPosition(gps_position=pos, altitude_msl=alt) apos.save() log = UasTelemetry(user=user, uas_position=apos, uas_heading=heading) log.save() log.timestamp = self.now + datetime.timedelta(seconds=timestamp) log.save() return log
def create_log_element(self, lat, lon, alt, user, log_time): pos = GpsPosition(latitude=lat, longitude=lon) pos.save() apos = AerialPosition(gps_position=pos, altitude_msl=alt) apos.save() log = UasTelemetry( user=user, uas_position=apos, uas_heading=100, ) log.save() log.timestamp = log_time log.save() return log
def test_contains_many_pos(self): """Tests the contains_many_pos method.""" for (zone, test_pos) in self.testdata_containspos: aerial_pos_list = [] expected_results = [] for ((lat, lon, alt), inside) in test_pos: apos = AerialPosition() apos.latitude = lat apos.longitude = lon apos.altitude_msl = alt aerial_pos_list.append(apos) expected_results.append(inside) self.assertEqual(zone.contains_many_pos(aerial_pos_list), expected_results)
def interpolate(cls, uas_telemetry_logs, step=TELEMETRY_INTERPOLATION_STEP, max_gap=TELEMETRY_INTERPOLATION_MAX_GAP): """Interpolates the ordered set of telemetry. Args: uas_telemetry_logs: The telemetry to interpolate. step: The discrete interpolation step in seconds. max_gap: The max time between telemetry to interpolate. Returns: An iterable set of telemetry. """ for ix, log in enumerate(uas_telemetry_logs): yield log if ix + 1 >= len(uas_telemetry_logs): continue next_log = uas_telemetry_logs[ix + 1] dt = next_log.timestamp - log.timestamp if dt > max_gap or dt <= datetime.timedelta(seconds=0): continue t = log.timestamp + step while t < next_log.timestamp: n_w = (t - log.timestamp).total_seconds() / dt.total_seconds() w = (next_log.timestamp - t).total_seconds() / dt.total_seconds() weighted_avg = lambda v, n_v: w * v + n_w * n_v telem = UasTelemetry() telem.user = log.user telem.timestamp = t telem.uas_position = AerialPosition() telem.uas_position.gps_position = GpsPosition() telem.uas_position.gps_position.latitude = weighted_avg( log.uas_position.gps_position.latitude, next_log.uas_position.gps_position.latitude) telem.uas_position.gps_position.longitude = weighted_avg( log.uas_position.gps_position.longitude, next_log.uas_position.gps_position.longitude) telem.uas_position.altitude_msl = weighted_avg( log.uas_position.altitude_msl, next_log.uas_position.altitude_msl) telem.uas_heading = weighted_avg(log.uas_heading, next_log.uas_heading) yield telem t += step
def setUp(self): super(TestTakeoffOrLandingEventModel, self).setUp() # Mission pos = GpsPosition() pos.latitude = 10 pos.longitude = 100 pos.save() apos = AerialPosition() apos.latitude = 10 apos.longitude = 100 apos.altitude_msl = 1000 apos.save() wpt = Waypoint() wpt.latitude = 10 wpt.longitude = 100 wpt.altitude_msl = 1000 wpt.order = 10 wpt.save() self.mission = MissionConfig() self.mission.home_pos = pos self.mission.lost_comms_pos = pos self.mission.emergent_last_known_pos = pos self.mission.off_axis_odlc_pos = pos self.mission.map_center_pos = pos self.mission.map_height_ft = 1 self.mission.air_drop_pos = pos self.mission.ugv_drive_pos = pos self.mission.save() self.mission.mission_waypoints.add(wpt) self.mission.search_grid_points.add(wpt) self.mission.save() # Mission 2 self.mission2 = MissionConfig() self.mission2.home_pos = pos self.mission2.lost_comms_pos = pos self.mission2.emergent_last_known_pos = pos self.mission2.off_axis_odlc_pos = pos self.mission2.map_center_pos = pos self.mission2.map_height_ft = 1 self.mission2.air_drop_pos = pos self.mission2.ugv_drive_pos = pos self.mission2.save() self.mission2.mission_waypoints.add(wpt) self.mission2.search_grid_points.add(wpt) self.mission2.save() self.ten_minutes = datetime.timedelta(minutes=10)
def post(self, request): """Posts the UAS position with a POST request.""" telemetry_proto = interop_api_pb2.Telemetry() try: json_format.Parse(request.body, telemetry_proto) except Exception as e: return HttpResponseBadRequest( 'Failed to parse request. Error: %s' % str(e)) if (not telemetry_proto.HasField('latitude') or not telemetry_proto.HasField('longitude') or not telemetry_proto.HasField('altitude') or not telemetry_proto.HasField('heading')): return HttpResponseBadRequest('Request missing fields.') # Check the values make sense. if telemetry_proto.latitude < -90 or telemetry_proto.latitude > 90: return HttpResponseBadRequest('Latitude out of range [-90, 90]: %f' % telemetry_proto.latitude) if telemetry_proto.longitude < -180 or telemetry_proto.longitude > 180: return HttpResponseBadRequest( 'Longitude out of range [-180, 180]: %f' % telemetry_proto.longitude) if telemetry_proto.altitude < -1500 or telemetry_proto.altitude > 330000: return HttpResponseBadRequest( 'Altitude out of range [-1500, 330000]: %f' % telemetry_proto.altitude) if telemetry_proto.heading < 0 or telemetry_proto.heading > 360: return HttpResponseBadRequest( 'Heading out of range [0, 360]: %f' % telemetry_proto.heading) # Store telemetry. gpos = GpsPosition( latitude=telemetry_proto.latitude, longitude=telemetry_proto.longitude) gpos.save() apos = AerialPosition( gps_position=gpos, altitude_msl=telemetry_proto.altitude) apos.save() telemetry = UasTelemetry( user=request.user, uas_position=apos, uas_heading=telemetry_proto.heading) telemetry.save() return HttpResponse('UAS Telemetry Successfully Posted.')
def waypoints_from_data(self, waypoints_data): """Converts tuples of lat/lon/alt to a waypoint.""" waypoints = [] for i, waypoint in enumerate(waypoints_data): (lat, lon, alt) = waypoint pos = GpsPosition() pos.latitude = lat pos.longitude = lon pos.save() apos = AerialPosition() apos.altitude_msl = alt apos.gps_position = pos apos.save() wpt = Waypoint() wpt.position = apos wpt.order = i wpt.save() waypoints.append(wpt) return waypoints
def setUp(self): pos = GpsPosition() pos.latitude = 10 pos.longitude = 100 pos.save() apos = AerialPosition() apos.altitude_msl = 1000 apos.gps_position = pos apos.save() wpt = Waypoint() wpt.position = apos wpt.order = 10 wpt.save() config = MissionConfig() config.home_pos = pos config.emergent_last_known_pos = pos config.off_axis_odlc_pos = pos config.air_drop_pos = pos config.save() config.mission_waypoints.add(wpt) config.search_grid_points.add(wpt) config.save() user = User.objects.create_user('user', '*****@*****.**', 'pass') self.feedback = MissionJudgeFeedback( mission=config, user=user, flight_time=datetime.timedelta(seconds=1), post_process_time=datetime.timedelta(seconds=2), used_timeout=True, min_auto_flight_time=True, safety_pilot_takeovers=3, waypoints_captured=5, out_of_bounds=6, unsafe_out_of_bounds=7, things_fell_off_uas=False, crashed=False, air_drop_accuracy=interop_admin_api_pb2.MissionJudgeFeedback. WITHIN_05_FT, ugv_drove_to_location=False, operational_excellence_percent=9) self.feedback.save()
def create_data(self): """Create a basic sample dataset.""" self.user1 = User.objects.create_user('user1', '*****@*****.**', 'testpass') self.user1.save() self.user2 = User.objects.create_user('user2', '*****@*****.**', 'testpass') self.user2.save() # user1 is on mission event = MissionClockEvent(user=self.user1, team_on_clock=True, team_on_timeout=False) event.save() # user1 is flying event = TakeoffOrLandingEvent(user=self.user1, uas_in_air=True) event.save() # user2 has landed event = TakeoffOrLandingEvent(user=self.user2, uas_in_air=True) event.save() event = TakeoffOrLandingEvent(user=self.user2, uas_in_air=False) event.save() # user2 is active self.timestamp = timezone.now() gps = GpsPosition(latitude=38.6462, longitude=-76.2452) gps.save() pos = AerialPosition(gps_position=gps, altitude_msl=0) pos.save() self.telem = UasTelemetry(user=self.user2, uas_position=pos, uas_heading=90) self.telem.save() self.telem.timestamp = dateutil.parser.parse( u'2016-10-01T00:00:00.0+00:00') self.telem.save()
def test_evaluate_collision_with_uas(self): """Tests the collision with UAS method.""" # Create testing data user = User.objects.create_user('testuser', '*****@*****.**', 'testpass') user.save() (cyl_details, inside_pos, outside_pos) = TESTDATA_STATOBST_EVALCOLLISION (cyl_lat, cyl_lon, cyl_height, cyl_rad) = cyl_details gpos = GpsPosition(latitude=cyl_lat, longitude=cyl_lon) gpos.save() obst = StationaryObstacle(gps_position=gpos, cylinder_radius=cyl_rad, cylinder_height=cyl_height) obst.save() inside_logs = [] outside_logs = [] logs_to_create = [ (inside_pos, inside_logs), (outside_pos, outside_logs) ] for (positions, log_list) in logs_to_create: for (lat, lon, alt) in positions: gpos = GpsPosition(latitude=lat, longitude=lon) gpos.save() apos = AerialPosition(gps_position=gpos, altitude_msl=alt) apos.save() log = UasTelemetry(user=user, uas_position=apos, uas_heading=0) log.save() log_list.append(log) # Assert collisions correctly evaluated collisions = [(inside_logs, True), (outside_logs, False)] for (log_list, inside) in collisions: self.assertEqual( obst.evaluate_collision_with_uas(log_list), inside) for log in log_list: self.assertEqual( obst.evaluate_collision_with_uas([log]), inside)
def test_unicode(self): """Tests the unicode method executes.""" obst = MovingObstacle() obst.speed_avg = 10 obst.sphere_radius = 100 obst.save() for _ in range(3): pos = GpsPosition() pos.latitude = 10 pos.longitude = 100 pos.save() apos = AerialPosition() apos.altitude_msl = 1000 apos.gps_position = pos apos.save() wpt = Waypoint() wpt.position = apos wpt.order = 10 wpt.save() obst.waypoints.add(wpt) self.assertTrue(obst.__unicode__())