add spindle and bug fix

Author: Uoops

main.py

@@ -2,12 +2,17 @@
 import re
 import sys
 from src.ui.main_window import MainWindow
+from PyQt5.QtCore import Qt
 from PyQt5.QtWidgets import *
 import multiprocessing as mp
 import torch
 import warnings
 warnings.filterwarnings("ignore")
 
+# Enable DPI scaling
+QApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True)
+QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps, True)
+
 
 def closeAllWindows():
     QApplication.instance().closeAllWindows()

src/classifer.py

@@ -74,41 +74,41 @@ def update_model_toy(self, param:ParamClassifier):
         self.model_toy = model.to(self.device)
         self.preprocessing_artifact = PreProcessing.from_param(self.param_artifact_preprocessing)
 
-    def artifact_detection(self, HFO_features, ignore_region, threshold=0.5):
+    def artifact_detection(self, biomarker_features, ignore_region, threshold=0.5):
         if not self.model_toy:
             raise ValueError("Please load artifact model first!")
-        return self._classify_artifacts(self.model_toy, HFO_features, ignore_region, threshold=threshold)
+        return self._classify_artifacts(self.model_toy, biomarker_features, ignore_region, threshold=threshold)
 
-    def spike_detection(self, HFO_features):
+    def spike_detection(self, biomarker_features):
         if not self.model_s:
             raise ValueError("Please load spike model first!")
-        return self._classify_spikes(self.model_s, HFO_features)
+        return self._classify_spikes(self.model_s, biomarker_features)
 
-    def _classify_artifacts(self, model, HFO_feature, ignore_region, threshold=0.5):
+    def _classify_artifacts(self, model, biomarker_feature, ignore_region, threshold=0.5):
         model = model.to(self.device)
-        features = self.preprocessing_artifact.process_hfo_feature(HFO_feature)
+        features = self.preprocessing_artifact.process_biomarker_feature(biomarker_feature)
         artifact_predictions = np.zeros(features.shape[0]) -1
-        starts = HFO_feature.starts
-        ends = HFO_feature.ends
+        starts = biomarker_feature.starts
+        ends = biomarker_feature.ends
         keep_index = np.where(np.logical_and(starts > ignore_region[0], ends < ignore_region[1]) == True)[0]   
         features = features[keep_index]
         if len(features) != 0:
-            predictions = inference(model, features, self.device ,self.batch_size, threshold=threshold)
+            predictions = inference(model, features, self.device, self.batch_size, threshold=threshold)
             artifact_predictions[keep_index] = predictions
-        HFO_feature.update_artifact_pred(artifact_predictions)
-        return HFO_feature
+        biomarker_feature.update_artifact_pred(artifact_predictions)
+        return biomarker_feature
 
-    def _classify_spikes(self, model, HFO_feature):
-        if len(HFO_feature.artifact_predictions) == 0:
+    def _classify_spikes(self, model, biomarker_feature):
+        if len(biomarker_feature.artifact_predictions) == 0:
             raise ValueError("Please run artifact classifier first!")
         model = model.to(self.device)
-        features = self.preprocessing_spike.process_hfo_feature(HFO_feature)
+        features = self.preprocessing_spike.process_biomarker_feature(biomarker_feature)
         spike_predictions = np.zeros(features.shape[0]) -1
-        keep_index = np.where(HFO_feature.artifact_predictions > 0)[0]
+        keep_index = np.where(biomarker_feature.artifact_predictions > 0)[0]
         features = features[keep_index]
         if len(features) != 0:
             predictions = inference(model, features, self.device, self.batch_size)
             spike_predictions[keep_index] = predictions
-        HFO_feature.update_spike_pred(spike_predictions)
-        return HFO_feature
+        biomarker_feature.update_spike_pred(spike_predictions)
+        return biomarker_feature
 

src/controllers/annotation_controller.py

@@ -8,17 +8,23 @@ def __init__(self, annotation_widget, backend=None):
         self.model = AnnotationModel(backend)
         self.view = AnnotationView(annotation_widget)
 
+        # define window length
+        if self.model.backend.biomarker_type == "HFO":
+            self.interval = 1.0
+        elif self.model.backend.biomarker_type == "Spindle":
+            self.interval = 4.0
+
     def create_waveform_plot(self):
         self.model.create_waveform_plot()
         self.view.add_widget('VisulaizationVerticalLayout', self.model.waveform_plot)
         channel, start, end = self.get_current_event()
-        self.model.waveform_plot.plot(start, end, channel, interval=1.0)  # Default interval
+        self.model.waveform_plot.plot(start, end, channel, interval=self.interval)  # Default interval
 
     def create_fft_plot(self):
         self.model.create_fft_plot()
         self.view.add_widget('FFT_layout', self.model.fft_plot)
         channel, start, end = self.get_current_event()
-        self.model.fft_plot.plot(start, end, channel, interval=1.0)  # Default interval
+        self.model.fft_plot.plot(start, end, channel, interval=self.interval)  # Default interval
 
     def update_plots(self, start, end, channel, interval):
         self.model.waveform_plot.plot(start, end, channel, interval=interval)

src/controllers/main_waveform_plot_controller.py

@@ -63,8 +63,8 @@ def get_current_start_end(self):
     def get_current_time_window(self):
         return self.model.get_current_time_window()
 
-    def set_plot_HFOs(self, plot_HFOs:bool):
-        self.model.set_plot_HFOs(plot_HFOs)
+    def set_plot_biomarkers(self, plot_biomarkers:bool):
+        self.model.set_plot_biomarkers(plot_biomarkers)
 
     def plot_all_current_channels_for_window(self):
         eeg_data_to_display, y_100_length, y_scale_length, offset_value = self.get_current_eeg_data_to_display()
@@ -78,22 +78,24 @@ def plot_all_current_channels_for_window(self):
 
         return eeg_data_to_display, y_100_length, y_scale_length, offset_value
 
-    def plot_all_current_hfos_for_window(self, eeg_data_to_display, offset_value, top_value):
+    def plot_all_current_biomarkers_for_window(self, eeg_data_to_display, offset_value, top_value):
         first_channel_to_plot = self.get_first_channel_to_plot()
         n_channels_to_plot = self.model.n_channels_to_plot
         channels_to_plot = self.model.channels_to_plot
         start_in_time, end_in_time = self.get_current_start_end()
 
         for disp_i, ch_i in enumerate(range(first_channel_to_plot, first_channel_to_plot+n_channels_to_plot)):
             channel = channels_to_plot[ch_i]
-            hfo_starts, hfo_ends, hfo_starts_in_time, hfo_ends_in_time, windows_in_time, colors = self.model.get_all_hfos_for_all_current_channels_and_color(channel)
-
-            if self.model.plot_HFOs:
-                for i in range(len(hfo_starts)):
-                    event_start = int(hfo_starts[i]-start_in_time*self.model.sample_freq)
-                    event_end = int(hfo_ends[i]-start_in_time*self.model.sample_freq)
+            (biomarker_starts, biomarker_ends,
+             biomarker_starts_in_time, biomarker_ends_in_time,
+             windows_in_time, colors) = self.model.get_all_biomarkers_for_all_current_channels_and_color(channel)
+
+            if self.model.plot_biomarkers:
+                for i in range(len(biomarker_starts)):
+                    event_start = int(biomarker_starts[i]-start_in_time*self.model.sample_freq)
+                    event_end = int(biomarker_ends[i]-start_in_time*self.model.sample_freq)
                     self.view.plot_waveform(windows_in_time[i], eeg_data_to_display[ch_i, event_start:event_end]-disp_i*offset_value, colors[i], 2)
-                    self.view.plot_waveform([hfo_starts_in_time[i], hfo_ends_in_time[i]], [top_value+0.2,top_value+0.2], colors[i], 10)
+                    self.view.plot_waveform([biomarker_starts_in_time[i], biomarker_ends_in_time[i]], [top_value+0.2,top_value+0.2], colors[i], 10)
 
 
     def draw_scale_bar(self, eeg_data_to_display, offset_value, y_100_length, y_scale_length):

src/controllers/main_window_controller.py

@@ -1,5 +1,4 @@
 from src.utils.utils_gui import *
-from src.hfo_app import HFO_App
 
 
 class MainWindowController:
@@ -10,7 +9,7 @@ def __init__(self, view, model):
         self.supported_biomarker = {
             'HFO': self.create_hfo_window,
             'Spindle': self.create_spindle_window,
-            'Hypsarrhythmia': self.create_hypsarrhythmia_window,
+            'Spike': self.create_spike_window,
         }
 
     def init_biomarker_window(self, biomarker_type):
@@ -26,16 +25,12 @@ def init_general_window(self):
     def get_biomarker_type(self):
         return self.view.get_biomarker_type()
 
+    def set_biomarker_type(self, bio_type):
+        self.model.set_biomarker_type_and_init_backend(bio_type)
+
     def init_biomarker_type(self):
         default_biomarker = self.get_biomarker_type()
-        backend = None
-        if default_biomarker == 'HFO':
-            backend = HFO_App()
-        elif default_biomarker == 'Spindle':
-            backend = HFO_App()
-        elif default_biomarker == 'Spike':
-            backend = HFO_App()
-        self.model.set_backend(backend)
+        self.set_biomarker_type(default_biomarker)
 
         self.view.window.combo_box_biomarker.currentIndexChanged.connect(self.switch_biomarker)
 
@@ -44,6 +39,9 @@ def switch_biomarker(self):
         self.supported_biomarker[selected_biomarker]()
 
     def create_hfo_window(self):
+        # set biomarker type
+        self.set_biomarker_type('HFO')
+
         # dynamically create frame for different biomarkers
         self.view.window.frame_biomarker_layout = QHBoxLayout(self.view.window.frame_biomarker_type)
 
@@ -67,6 +65,9 @@ def create_hfo_window(self):
         self.model.init_param('HFO')
 
     def create_spindle_window(self):
+        # set biomarker type
+        self.set_biomarker_type('Spindle')
+
         # create detection parameters stacked widget
         self.view.create_stacked_widget_detection_param('Spindle')
 
@@ -85,5 +86,5 @@ def create_spindle_window(self):
         # init params
         self.model.init_param('Spindle')
 
-    def create_hypsarrhythmia_window(self):
+    def create_spike_window(self):
         print('not implemented yet')

src/controllers/mini_plot_controller.py

@@ -11,7 +11,7 @@ def __init__(self, mini_plot_widget, backend):
     def clear(self):
         self.view.clear()
 
-    def init_hfo_display(self):
+    def init_biomarker_display(self):
         self.view.enable_axis_information()
         self.view.add_linear_region()
 
@@ -30,25 +30,28 @@ def set_channels_to_plot(self, channels_to_plot):
     def set_n_channels_to_plot(self, n_channels_to_plot):
         self.model.set_n_channels_to_plot(n_channels_to_plot)
 
+    def set_first_channel_to_plot(self, first_channel_to_plot):
+        self.model.set_first_channel_to_plot(first_channel_to_plot)
+
     def update_channel_names(self, new_channel_names):
         self.model.update_channel_names(new_channel_names)
 
-    def plot_one_hfo(self, start_time, end_time, height, color, width=5):
-        self.view.plot_hfo(start_time, end_time, height, color, width)
+    def plot_one_biomarker(self, start_time, end_time, height, color, width=5):
+        self.view.plot_biomarker(start_time, end_time, height, color, width)
 
-    def plot_all_current_hfos_for_one_channel(self, channel, plot_height):
-        starts_in_time, ends_in_time, colors = self.model.get_all_hfos_for_channel_and_color(channel)
+    def plot_all_current_biomarkers_for_one_channel(self, channel, plot_height):
+        starts_in_time, ends_in_time, colors = self.model.get_all_biomarkers_for_channel_and_color(channel)
 
         for i in range(len(starts_in_time)):
-            self.plot_one_hfo(starts_in_time[i], ends_in_time[i], plot_height, colors[i], 5)
+            self.plot_one_biomarker(starts_in_time[i], ends_in_time[i], plot_height, colors[i], 5)
 
-    def plot_all_current_hfos_for_all_channels(self, plot_height):
+    def plot_all_current_biomarkers_for_all_channels(self, plot_height):
         first_channel_to_plot = self.get_first_channel_to_plot()
         n_channels_to_plot = self.model.n_channels_to_plot
         channels_to_plot = self.model.channels_to_plot
         for disp_i, ch_i in enumerate(range(first_channel_to_plot, first_channel_to_plot+n_channels_to_plot)):
             channel = channels_to_plot[ch_i]
-            self.plot_all_current_hfos_for_one_channel(channel, plot_height)
+            self.plot_all_current_biomarkers_for_one_channel(channel, plot_height)
 
     def set_miniplot_title(self, title, height):
         self.view.set_miniplot_title(title, height)