예제 #1
0
 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))
예제 #3
0
    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)
예제 #5
0
    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))
예제 #6
0
    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()
예제 #7
0
 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()
예제 #8
0
    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()
예제 #9
0
    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
예제 #10
0
    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)
예제 #11
0
    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
예제 #12
0
    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
예제 #13
0
    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
예제 #14
0
 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))
예제 #15
0
 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)
예제 #16
0
    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)
예제 #17
0
    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__()
예제 #18
0
 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
예제 #19
0
    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)
예제 #20
0
    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
예제 #21
0
 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
예제 #22
0
 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)
예제 #23
0
    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)
예제 #25
0
    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.')
예제 #26
0
 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()
예제 #28
0
    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()
예제 #29
0
    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)
예제 #30
0
 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__())