def test_continuous_send_dialog(self):
self.add_signal_to_form("esaver.complex16s")
self.__add_first_signal_to_generator()
port = util.get_free_port()
gframe = self.form.generator_tab_controller # type: GeneratorTabController
for msg in gframe.table_model.protocol.messages:
msg.pause = 5000
expected = IQArray(None, np.float32, gframe.total_modulated_samples)
expected = gframe.modulate_data(expected)
current_index = Value("L", 0)
buffer = Array("f", 4 * len(expected))
ready = Value("i", 0)
process = Process(target=receive,
args=(port, current_index, len(expected), buffer,
ready))
process.daemon = True
process.start()
n = 0
while ready.value == 0 and n < 50: # ensure server is up
time.sleep(0.1)
n += 1
self.assertTrue(ready.value)
ContinuousModulator.BUFFER_SIZE_MB = 10
continuous_send_dialog = self.__get_continuous_send_dialog()
continuous_send_dialog.device.set_client_port(port)
continuous_send_dialog.device_settings_widget.ui.spinBoxNRepeat.setValue(
2)
continuous_send_dialog.ui.btnStart.click()
process.join(10)
# CI sometimes swallows a sample
self.assertGreaterEqual(current_index.value, len(expected) - 1)
buffer = np.frombuffer(buffer.get_obj(), dtype=np.float32)
buffer = buffer.reshape((len(buffer) // 2, 2))
for i in range(len(expected)):
self.assertEqual(buffer[i, 0], expected[i, 0], msg=str(i))
self.assertEqual(buffer[i, 1], expected[i, 1], msg=str(i))
continuous_send_dialog.ui.btnStop.click()
continuous_send_dialog.ui.btnClear.click()
QTest.qWait(1)
continuous_send_dialog.close()
def calculateDistance(self, dataset, function):
traj_lst, traj_keys = self.prepareDataset(dataset)
traj_count = len(traj_lst)
#D = np.zeros((traj_count, traj_count))
arr = Array(c.c_double, traj_count * traj_count)
arr = np.frombuffer(arr.get_obj())
global D
D = arr.reshape((traj_count, traj_count))
with open(dataset, 'r') as inf:
traj_data_dict = eval(inf.read())
counter = 0
sub_counter = 0
nprocs = cpu_count() - 1
for i, u in enumerate(traj_keys):
counter += 1
print(str(counter) + " " + str(len(traj_keys)) + "\n")
Utils.progressBar(counter, len(traj_keys), bar_length=20)
sub_counter = 0
pool = Pool(processes=nprocs)
#pool.apply_async(self.update_dist, args=(function, traj_data_dict, u, [], i, traj_keys))
for j, v in enumerate(traj_keys[i+1:], start=i+1):
if j >= len(traj_keys):
break
# sub_counter += 1
#distance = 0
#print(sub_counter, len(traj_keys[i+1:]))
#value = []
#print(i,j)
#prod_x = partial(self.update_dist, traj_data_dict=traj_data_dict, function=function, u=u, v=v, x=[], i=i, j=j)
pool.apply_async(self.update_dist, args=(function, traj_data_dict, u, v, [], i, j))
#pool.map_async(prod_x, [1])
#p = Process(target=prod_x)
#proc.append(p)
#self.update_dist(function, traj_data_dict, u, v, D, i, j)
'''
for u_key, values1 in traj_data_dict[u][0].items():
prod_x = partial(self.similarity_function, function=function, u=np.vstack(values1).T)
r = p.map_async(prod_x, traj_data_dict[v][0].values(), callback=value.append)
r.wait()
#distance += sum(result)
#print('a')
#print(value)
distance += sum(sum(value, []))
#print(distance)
#for v_key, values2 in traj_data_dict[v][0].items():
# distance += 1 - self.similarity_function(function, np.vstack(values1).T, np.vstack(values2).T)
#distance += 1 - TrajectorySimilarity.hausdorff(np.vstack(values1).T, np.vstack(values2).T)
#distance = TrajectorySimilarity.hausdorff(traj_lst[i], traj_lst[j])
#print(i, j, distance)
D[i, j] = distance
D[j, i] = distance
'''
pool.close()
pool.join()
return traj_keys, D
