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