def test_execute_less_equal_condition(self): data_filter = Filter() data_filter.less_equal(1, 40) np.testing.assert_equal(data_filter.execute(TestFilter.data), [[1, 20, 300, 4000], [2, 30, 400, 5000], [3, 40, 500, 6000], [9, 0, 100, 2000]])
def test_execute_not_equal_condition(self): data_filter = Filter() data_filter.not_equal(2, 500) np.testing.assert_equal(data_filter.execute(TestFilter.data), [[1, 20, 300, 4000], [2, 30, 400, 5000], [4, 50, 600, 7000], [5, 60, 700, 8000], [6, 70, 800, 9000], [7, 80, 900, 0], [8, 90, 0, 1000], [9, 0, 100, 2000]])
def test_execute_complex_cases(self): data_filter = Filter() data_filter.greater_equal(0, 3) data_filter.less(1, 90) data_filter.is_in(2, (0, 700, 900)) np.testing.assert_equal(data_filter.execute(TestFilter.data), [[5, 60, 700, 8000], [7, 80, 900, 0]]) data_filter = Filter() data_filter.greater_equal(0, 7) data_filter.less(1, 50) data_filter.is_in(2, (0, 700, 900)) self.assertEqual(data_filter.execute(TestFilter.data).shape, (0, 4))
def test_execute_not_in_condition(self): data_filter = Filter() data_filter.is_not_in(2, (100, 300, 500, 600, 700, 800, 900, 0)) np.testing.assert_equal(data_filter.execute(TestFilter.data), [[2, 30, 400, 5000]])
def test_execute_in_condition(self): data_filter = Filter() data_filter.is_in(2, (300, 100, 600)) np.testing.assert_equal(data_filter.execute(TestFilter.data), [[1, 20, 300, 4000], [4, 50, 600, 7000], [9, 0, 100, 2000]])
def test_execute_greater_equal_condition(self): data_filter = Filter() data_filter.greater_equal(2, 700) np.testing.assert_equal(data_filter.execute(TestFilter.data), [[5, 60, 700, 8000], [6, 70, 800, 9000], [7, 80, 900, 0]])
def test_execute_less_condition(self): data_filter = Filter() data_filter.less(2, 200) np.testing.assert_equal(data_filter.execute(TestFilter.data), [[8, 90, 0, 1000], [9, 0, 100, 2000]])
def test_execute_equal_condition(self): data_filter = Filter() data_filter.equal(0, 3) np.testing.assert_equal(data_filter.execute(TestFilter.data), [[3, 40, 500, 6000]])
def localize_mobile(mobile_node, anchors, frames): # Assume that all anchors has the same reply delay reply_delay = np.unique(anchors["beacon_reply_delay"]) assert (reply_delay.shape == (1, )) reply_delay = reply_delay[0] assert (scc.unit('speed of light in vacuum') == 'm s^-1') c = scc.value('speed of light in vacuum') c = c * 1e-12 # m/s -> m/ps frame_filer = Filter() frame_filer.equal("node_mac_address", mobile_node["mac_address"]) mobile_frames = frame_filer.execute(frames) # Filter out all sequence numbers for which mobile node received less than three beacons sequence_numbers, sequence_number_counts = np.unique( mobile_frames["sequence_number"], return_counts=True) sequence_numbers = sequence_numbers[sequence_number_counts > 3] result = Results.create_array(sequence_numbers.size, position_dimensions=2) result["mac_address"] = mobile_node["mac_address"] anchor_triples = ((0, 1, 2), (1, 2, 3)) for i in range(sequence_numbers.size): sequence_number = sequence_numbers[i] # Extract beacons with specific sequence number current_beacons = mobile_frames[np.where( mobile_frames["sequence_number"] == sequence_number)] positions = [] # Evaluate different anchors sets for anchor_triple in anchor_triples: # Compute distances between anchor pairs (first, second) and (second, third) anchor_distances = np.zeros(2) anchor_distances[0] = np.abs( np.linalg.norm(anchors[anchor_triple[1], "position_2d"] - anchors[anchor_triple[0], "position_2d"])) anchor_distances[1] = np.abs( np.linalg.norm(anchors[anchor_triple[2], "position_2d"] - anchors[anchor_triple[1], "position_2d"])) # Compute ToF between anchor pairs anchor_tx_delays = anchor_distances / c + reply_delay # Follow algorithm steps anchor_coordinates = np.zeros((3, 2)) anchor_coordinates[0] = anchors[anchor_triple[1], "position_2d"] anchor_coordinates[1] = anchors[anchor_triple[0], "position_2d"] anchor_coordinates[2] = anchors[anchor_triple[2], "position_2d"] timestamp_differences = np.full(3, float('nan')) timestamp_differences[1] = current_beacons[anchor_triple[1], "begin_clock_timestamp"] - \ current_beacons[anchor_triple[0], "begin_clock_timestamp"] - anchor_tx_delays[0] timestamp_differences[2] = current_beacons[anchor_triple[2], "begin_clock_timestamp"] - \ current_beacons[anchor_triple[1], "begin_clock_timestamp"] - anchor_tx_delays[1] # Compute position position = tdoa.doan_vesely(anchor_coordinates, timestamp_differences) positions.append(position) result[i, "begin_true_position_3d"] = current_beacons[ 0, "begin_true_position_3d"] result[i, "end_true_position_3d"] = current_beacons[ 2, "end_true_position_3d"] # Choose better position # TODO Propose better solution, for now just choose position being closer to (0, 0) if np.abs(np.linalg.norm((0, 0) - positions[0])) < np.abs( np.linalg.norm((0, 0) - positions[1])): result[i, "position_2d"] = positions[0] else: result[i, "position_2d"] = positions[1] return result