def go():
global graphic_view, status_label
data_parent, data_child = Pipe(duplex=False)
receiver = Process(target=generate_data, args=(data_child,))
receiver.daemon = True
receiver.start()
scene = QGraphicsScene()
graphic_view.setScene(scene)
scene.setSceneRect(0, 0, 1024, 1024)
x_pos = 0
y_pos = 0
t = time.time()
while True:
speed = time.time()
data = data_parent.recv()
spectrogram = Spectrogram(data)
pixmap = QPixmap.fromImage(spectrogram.create_spectrogram_image(transpose=True))
scene.setSceneRect(scene.sceneRect().adjusted(0, 0, 0, pixmap.height()))
item = scene.addPixmap(pixmap)
item.setPos(x_pos, y_pos)
y_pos += pixmap.height()
graphic_view.fitInView(scene.sceneRect())
status_label.setText("Height: {0:.0f} // Speed: {1:.2f} // Total Time: {2:.2f}".format(scene.sceneRect().height(),
1/(time.time()-speed),
time.time()-t))
QApplication.instance().processEvents()
def __init__(self, samples, parent):
super().__init__(parent)
self.samples_need_update = True
self.scene.clear()
self.spectrogram = Spectrogram(samples)
self.scene = SpectrogramScene()
def __update_spectrogram(self):
spectrogram = Spectrogram(self.device.data)
spectrogram.data_min = -80
spectrogram.data_max = 10
scene = self.ui.graphicsViewSpectrogram.scene()
pixmap = QPixmap.fromImage(spectrogram.create_spectrogram_image(transpose=True))
scene.addPixmap(pixmap).moveBy(0, self.spectrogram_y_pos)
self.spectrogram_y_pos += pixmap.height()
if self.spectrogram_y_pos >= scene.sceneRect().height():
scene.setSceneRect(0, 0, Spectrogram.DEFAULT_FFT_WINDOW_SIZE, self.spectrogram_y_pos)
self.ui.graphicsViewSpectrogram.verticalScrollBar().setValue(
self.ui.graphicsViewSpectrogram.verticalScrollBar().maximum())
def __update_spectrogram(self):
spectrogram = Spectrogram(self.device.data)
spectrogram.data_min = -80
spectrogram.data_max = 10
scene = self.ui.graphicsViewSpectrogram.scene()
pixmap = QPixmap.fromImage(spectrogram.create_spectrogram_image(transpose=True))
pixmap_item = scene.addPixmap(pixmap)
pixmap_item.moveBy(0, self.spectrogram_y_pos)
self.spectrogram_y_pos += pixmap.height()
if self.spectrogram_y_pos >= scene.sceneRect().height():
scene.setSceneRect(0, 0, Spectrogram.DEFAULT_FFT_WINDOW_SIZE, self.spectrogram_y_pos)
self.ui.graphicsViewSpectrogram.ensureVisible(pixmap_item)
def test_channels(self):
sample_rate = 10**6
channel1_freq = 40 * 10**3
channel2_freq = 240 * 10**3
channel1_data = array.array("B", [1, 0, 1, 0, 1, 0, 0, 1])
channel2_data = array.array("B", [1, 1, 0, 0, 1, 1, 0, 1])
channel3_data = array.array("B", [1, 0, 0, 1, 0, 1, 1, 1])
filter_bw = 0.1
filter_freq1_high = 1.5 * channel1_freq
filter_freq1_low = 0.5 * channel1_freq
filter_freq2_high = 1.5 * channel2_freq
filter_freq2_low = 0.5 * channel2_freq
modulator1, modulator2, modulator3 = Modulator("test"), Modulator(
"test2"), Modulator("test3")
modulator1.carrier_freq_hz = channel1_freq
modulator2.carrier_freq_hz = channel2_freq
modulator3.carrier_freq_hz = -channel2_freq
modulator1.sample_rate = modulator2.sample_rate = modulator3.sample_rate = sample_rate
data1 = modulator1.modulate(channel1_data)
data2 = modulator2.modulate(channel2_data)
data3 = modulator3.modulate(channel3_data)
mixed_signal = data1 + data2 + data3
mixed_signal.tofile("/tmp/three_channels.complex")
plt.subplot("221")
plt.title("Signal")
plt.plot(mixed_signal)
spectrogram = Spectrogram(mixed_signal)
plt.subplot("222")
plt.title("Spectrogram")
plt.imshow(np.transpose(spectrogram.data), aspect="auto", cmap="magma")
plt.ylim(0, spectrogram.freq_bins)
chann1_filtered = Filter.apply_bandpass_filter(
mixed_signal, filter_freq1_low / sample_rate,
filter_freq1_high / sample_rate, filter_bw)
plt.subplot("223")
plt.title("Channel 1 Filtered ({})".format("".join(
map(str, channel1_data))))
plt.plot(chann1_filtered)
chann2_filtered = Filter.apply_bandpass_filter(
mixed_signal, filter_freq2_low / sample_rate,
filter_freq2_high / sample_rate, filter_bw)
plt.subplot("224")
plt.title("Channel 2 Filtered ({})".format("".join(
map(str, channel2_data))))
plt.plot(chann2_filtered)
plt.show()
def show_available_colormaps(self):
height = 50
selected = colormaps.read_selected_colormap_name_from_settings()
for colormap_name in sorted(colormaps.maps.keys()):
image = Spectrogram.create_colormap_image(colormap_name, height=height)
rb = QRadioButton(colormap_name)
rb.setObjectName(colormap_name)
rb.setChecked(colormap_name == selected)
rb.setIcon(QIcon(QPixmap.fromImage(image)))
rb.setIconSize(QSize(256, height))
self.ui.scrollAreaWidgetSpectrogramColormapContents.layout().addWidget(rb)
def __update_spectrogram(self):
spectrogram = Spectrogram(self.device.data,
overlap_factor=self.my_overlap_factor)
spectrogram.data_min = -80
spectrogram.data_max = 10
scene = self.ui.graphicsViewSpectrogram.scene()
pixmap = QPixmap.fromImage(
spectrogram.create_spectrogram_image(transpose=True))
pixmap_item = scene.addPixmap(pixmap)
self.my_mass_vodopad.append(pixmap)
pixmap_item.moveBy(0, self.spectrogram_y_pos)
self.spectrogram_y_pos += pixmap.height()
if self.spectrogram_y_pos >= scene.sceneRect().height():
while sum(map(lambda x: x.height(),
self.my_mass_vodopad)) >= 20480:
scene.setSceneRect(0, 0, Spectrogram.DEFAULT_FFT_WINDOW_SIZE,
self.spectrogram_y_pos)
self.ui.graphicsViewSpectrogram.ensureVisible(pixmap_item)
scene.removeItem(scene.items().pop(-1))
self.my_mass_vodopad.pop(-1)
def setUp(self):
self.signal = Signal(
self.get_path_for_filename("two_participants.complex16s"), "test")
self.spectrogram = Spectrogram(self.signal.iq_array.data)
class TestSpectrogram(QtTestCase):
def setUp(self):
self.signal = Signal(
self.get_path_for_filename("two_participants.complex16s"), "test")
self.spectrogram = Spectrogram(self.signal.iq_array.data)
def test_create_spectrogram_image(self):
image = self.spectrogram.create_spectrogram_image()
self.assertEqual(image.width(), self.spectrogram.time_bins - 2)
self.assertEqual(image.height(), self.spectrogram.freq_bins)
def test_create_colormap_image(self):
image = self.spectrogram.create_colormap_image("magma", height=42)
self.assertEqual(image.height(), 42)
self.assertEqual(image.width(),
len(colormaps.chosen_colormap_numpy_bgra))
def test_channel_separation_with_negative_frequency(self):
super().setUp()
self.add_signal_to_form("three_channels.complex")
self.assertEqual(self.form.signal_tab_controller.num_frames, 1)
signal_frame = self.form.signal_tab_controller.signal_frames[0]
self.__prepare_channel_separation(signal_frame)
self.__test_extract_channel(signal_frame,
freq1=650,
freq2=850,
bandwidth="195,312KHz",
target_bits="11001101",
center=0.1)
self.__test_extract_channel(signal_frame,
freq1=500,
freq2=620,
bandwidth="117,188KHz",
target_bits="10101001",
center=0.1)
self.__test_extract_channel(signal_frame,
freq1=217,
freq2=324,
bandwidth="104,492KHz",
target_bits="10010111",
center=0.1)
def test_cancel_filtering(self):
super().setUp()
self.add_signal_to_form("two_participants.complex16s")
signal_frame = self.form.signal_tab_controller.signal_frames[0]
signal_frame.ui.cbSignalView.setCurrentIndex(2)
signal_frame.ui.spinBoxSelectionStart.setValue(100)
signal_frame.ui.spinBoxSelectionEnd.setValue(200)
menu = signal_frame.ui.gvSpectrogram.create_context_menu()
create_action = next(action for action in menu.actions()
if "bandpass filter" in action.text())
timer = QTimer(self.form)
timer.setSingleShot(True)
timer.timeout.connect(self.form.cancel_action.trigger)
timer.start(1)
create_action.trigger()
self.assertTrue(signal_frame.filter_abort_wanted)
self.assertEqual(self.form.signal_tab_controller.num_frames, 1)
def __prepare_channel_separation(self, signal_frame):
self.assertEqual(self.form.signal_tab_controller.num_frames, 1)
signal_frame = self.form.signal_tab_controller.signal_frames[0]
signal_frame.ui.spinBoxNoiseTreshold.setValue(0)
signal_frame.ui.spinBoxNoiseTreshold.editingFinished.emit()
self.assertEqual(signal_frame.signal.num_samples, 800)
signal_frame.ui.cbSignalView.setCurrentIndex(2)
self.assertTrue(signal_frame.spectrogram_is_active)
def __test_extract_channel(self,
signal_frame,
freq1,
freq2,
bandwidth: str,
target_bits: str,
center=None):
num_frames = self.form.signal_tab_controller.num_frames
signal_frame.ui.spinBoxSelectionStart.setValue(freq1)
signal_frame.ui.spinBoxSelectionEnd.setValue(freq2 - 1)
signal_frame.ui.spinBoxSelectionEnd.setValue(freq2)
self.assertEqual(signal_frame.ui.lNumSelectedSamples.text(),
str(freq2 - freq1))
self.assertEqual(signal_frame.ui.lDuration.text().replace(".", ","),
bandwidth)
menu = signal_frame.ui.gvSpectrogram.create_context_menu()
create_action = next(action for action in menu.actions()
if "bandpass filter" in action.text())
create_action.trigger()
self.assertEqual(self.form.signal_tab_controller.num_frames,
num_frames + 1)
filtered_frame = self.form.signal_tab_controller.signal_frames[1]
filtered_frame.ui.cbModulationType.setCurrentText("ASK")
filtered_frame.ui.spinBoxNoiseTreshold.setValue(0)
filtered_frame.ui.spinBoxNoiseTreshold.editingFinished.emit()
filtered_frame.ui.spinBoxSamplesPerSymbol.setValue(100)
filtered_frame.ui.spinBoxSamplesPerSymbol.editingFinished.emit()
if center is not None:
filtered_frame.ui.spinBoxCenterOffset.setValue(center)
filtered_frame.ui.spinBoxCenterOffset.editingFinished.emit()
self.assertEqual(len(filtered_frame.proto_analyzer.plain_bits_str), 1)
self.assertEqual(filtered_frame.proto_analyzer.plain_bits_str[0],
target_bits)
def setUp(self):
self.signal = Signal(self.get_path_for_filename("two_participants.coco"), "test")
self.spectrogram = Spectrogram(self.signal.data)
class TestSpectrogram(QtTestCase):
def setUp(self):
self.signal = Signal(self.get_path_for_filename("two_participants.coco"), "test")
self.spectrogram = Spectrogram(self.signal.data)
def test_create_spectrogram_image(self):
image = self.spectrogram.create_spectrogram_image()
self.assertEqual(image.width(), self.spectrogram.time_bins - 2)
self.assertEqual(image.height(), self.spectrogram.freq_bins)
def test_create_colormap_image(self):
image = self.spectrogram.create_colormap_image("magma", height=42)
self.assertEqual(image.height(), 42)
self.assertEqual(image.width(), len(colormaps.chosen_colormap_numpy_bgra))
def test_channel_separation_with_negative_frequency(self):
super().setUp()
self.add_signal_to_form("three_channels.complex")
self.assertEqual(self.form.signal_tab_controller.num_frames, 1)
signal_frame = self.form.signal_tab_controller.signal_frames[0]
self.__prepare_channel_separation(signal_frame)
self.__test_extract_channel(signal_frame, freq1=650, freq2=850, bandwidth="195,312kHz", target_bits="11001101", center=0.1)
self.__test_extract_channel(signal_frame, freq1=500, freq2=620, bandwidth="117,188kHz", target_bits="10101001", center=0.1)
self.__test_extract_channel(signal_frame, freq1=217, freq2=324, bandwidth="104,492kHz", target_bits="10010111", center=0.1)
def test_cancel_filtering(self):
super().setUp()
self.add_signal_to_form("two_participants.coco")
signal_frame = self.form.signal_tab_controller.signal_frames[0]
signal_frame.ui.cbSignalView.setCurrentIndex(2)
signal_frame.ui.spinBoxSelectionStart.setValue(100)
signal_frame.ui.spinBoxSelectionEnd.setValue(200)
menu = signal_frame.ui.gvSpectrogram.create_context_menu()
create_action = next(action for action in menu.actions() if "bandpass filter" in action.text())
timer = QTimer(self.form)
timer.setSingleShot(True)
timer.timeout.connect(self.form.cancel_action.trigger)
timer.start(1)
create_action.trigger()
self.assertTrue(signal_frame.filter_abort_wanted)
self.assertEqual(self.form.signal_tab_controller.num_frames, 1)
def __prepare_channel_separation(self, signal_frame):
self.assertEqual(self.form.signal_tab_controller.num_frames, 1)
signal_frame = self.form.signal_tab_controller.signal_frames[0]
signal_frame.ui.spinBoxNoiseTreshold.setValue(0)
signal_frame.ui.spinBoxNoiseTreshold.editingFinished.emit()
self.assertEqual(signal_frame.signal.num_samples, 800)
signal_frame.ui.cbSignalView.setCurrentIndex(2)
self.assertTrue(signal_frame.spectrogram_is_active)
def __test_extract_channel(self, signal_frame, freq1, freq2, bandwidth: str, target_bits: str, center=None):
num_frames = self.form.signal_tab_controller.num_frames
signal_frame.ui.spinBoxSelectionStart.setValue(freq1)
signal_frame.ui.spinBoxSelectionEnd.setValue(freq2 - 1)
signal_frame.ui.spinBoxSelectionEnd.setValue(freq2)
self.assertEqual(signal_frame.ui.lNumSelectedSamples.text(), str(freq2 - freq1))
self.assertEqual(signal_frame.ui.lDuration.text().replace(".", ","), bandwidth)
menu = signal_frame.ui.gvSpectrogram.create_context_menu()
create_action = next(action for action in menu.actions() if "bandpass filter" in action.text())
create_action.trigger()
self.assertEqual(self.form.signal_tab_controller.num_frames, num_frames + 1)
filtered_frame = self.form.signal_tab_controller.signal_frames[1]
filtered_frame.ui.cbModulationType.setCurrentText("ASK")
filtered_frame.ui.spinBoxNoiseTreshold.setValue(0)
filtered_frame.ui.spinBoxNoiseTreshold.editingFinished.emit()
filtered_frame.ui.spinBoxInfoLen.setValue(100)
filtered_frame.ui.spinBoxInfoLen.editingFinished.emit()
if center is not None:
filtered_frame.ui.spinBoxCenterOffset.setValue(center)
filtered_frame.ui.spinBoxCenterOffset.editingFinished.emit()
self.assertEqual(len(filtered_frame.proto_analyzer.plain_bits_str), 1)
self.assertEqual(filtered_frame.proto_analyzer.plain_bits_str[0], target_bits)
class SpectrogramSceneManager(SceneManager):
def __init__(self, samples, parent):
super().__init__(parent)
self.samples_need_update = True
self.scene.clear()
self.spectrogram = Spectrogram(samples)
self.scene = SpectrogramScene()
@property
def num_samples(self):
return len(self.spectrogram.samples)
def set_parameters(self, samples: np.ndarray, window_size, data_min,
data_max) -> bool:
"""
Return true if redraw is needed
"""
redraw_needed = False
if self.samples_need_update:
self.spectrogram.samples = samples
redraw_needed = True
self.samples_need_update = False
if window_size != self.spectrogram.window_size:
self.spectrogram.window_size = window_size
redraw_needed = True
if data_min != self.spectrogram.data_min:
self.spectrogram.data_min = data_min
redraw_needed = True
if data_max != self.spectrogram.data_max:
self.spectrogram.data_max = data_max
redraw_needed = True
return redraw_needed
def show_scene_section(self,
x1: float,
x2: float,
subpath_ranges=None,
colors=None):
pass
def update_scene_rect(self):
self.scene.setSceneRect(0, 0, self.spectrogram.time_bins,
self.spectrogram.freq_bins)
def show_full_scene(self):
for item in self.scene.items():
if isinstance(item, QGraphicsPixmapItem):
self.scene.removeItem(item)
x_pos = 0
for image in self.spectrogram.create_image_segments():
item = self.scene.addPixmap(QPixmap.fromImage(image))
item.setPos(x_pos, 0)
x_pos += image.width()
QApplication.instance().processEvents()
# Estimated time_bins from update_scene_rect may be too many for small signals so we update the scene rect
# after we know how wide the spectrogram actually is
self.scene.setSceneRect(0, 0, x_pos, self.spectrogram.freq_bins)
def init_scene(self, apply_padding=True):
pass
def eliminate(self):
self.spectrogram.samples = None
self.spectrogram = None
super().eliminate()
