Merge branch 'bugflix-imp-cutoff-freq' of github.com:Mentalab-hub/explorepy into bugflix-imp-cutoff-freq

Author: salman2135

pyproject.toml

@@ -42,7 +42,8 @@ dependencies = [
     'pyyaml',
     'bleak==0.22.3',
     'pylsl',
-    'numba']
+    'numba',
+    'eegprep']
 
 [tool.setuptools]
 package-dir = {"" = "src"}

src/explorepy/_exceptions.py

@@ -62,6 +62,16 @@ class BleDisconnectionFailedError(Exception):
     pass
 
 
+class ImpedanceModeActiveError(Exception):
+    """
+    Exception for ASR, raised when impedance is running
+    """
+
+    def __init__(self, message="ASR can not run because impedance mode is active.\n"
+                               "Please disable impedance and try again\n"):
+        super().__init__(message)
+
+
 class ExplorePyDeprecationError(Exception):
     def __init__(self, message="Explorepy support for legacy devices is deprecated.\n"
                                "Please install explorepy 3.2.1 from Github or use the following command from Anaconda "

src/explorepy/asr_processor.py

@@ -17,8 +17,7 @@
     asr_process
 )
 
-from explorepy.filters import ExGFilter
-
+from explorepy.filters import bp_filter
 
 
 logger = logging.getLogger(__name__)
@@ -138,7 +137,6 @@ def __init__(self, stream_proc, in_topic):
         self.instantiate_buffers()
         self.is_initialized = True
         self.lifecycle_state = State.STABLE
-        self.filter = None
 
     @property
     def cutoff(self):
@@ -187,12 +185,11 @@ def on_calib_data_received(self, packet):
                 "Error writing calibration packet, timer has not been set correctly or calibration length is invalid!"
             )
         if (time.time() - self.calib_started_at) > self.calibration_length:
-            self.calibration_data_available = True
             self.stop_calibration()
             return
         self.calibration_data_input = np.append(
             self.calibration_data_input,
-            self.filter.apply(packet, in_place=False).get_data()[1],
+            packet.get_data()[1],
             axis=1,
         )
 
@@ -223,8 +220,10 @@ def clean_data(self):
             return
         if self.to_clean_ts[0][0] <= 1.0:
             return
+        filt_sig = bp_filter(self.to_clean.copy(), 45, 55, btype='bandstop', fs=self.sr)
+        filtered_data = bp_filter(filt_sig, .1, 40, fs=self.sr)
         try:
-            ret = asr_pipeline(self.to_clean, self.sr, self.ch_count, self._state)
+            ret = asr_pipeline(filtered_data, self.sr, self.ch_count, self._state)
             self.cleaned_data_available = True
             idx = np.searchsorted(self.to_clean_ts[0], self.last_cleaned_timestamp)
             self.cleaned_data = ret[:, idx:]
@@ -260,12 +259,6 @@ def start_calibration(self, calib_length: float = -1.0):
                          f"[{self._min_calibration_length},{self._max_calibration_length}]")
         logger.info(f"Starting ASR calibration for {self.calibration_length}s...")
         self.calib_started_at = time.time()
-        self.filter = ExGFilter(
-            cutoff_freq=(1, 45),
-            filter_type='bandpass',
-            s_rate=self.sr,
-            n_chan=self.ch_count,
-        )
         self.stream_processor.subscribe(self.on_calib_data_received, topic=self.in_topic)
 
     def stop_calibration(self):
@@ -278,13 +271,16 @@ def stop_calibration(self):
 
     def set_state_from_calibration_data(self, calib_data):
         self.lifecycle_state = State.CLEANING
-        cleaned, state = clean_calib_data(calib_data, self.sr)
+        filt_sig = bp_filter(calib_data, 45, 55, btype='bandstop', fs=self.sr)
+        filtered_data = bp_filter(filt_sig, .1, 40, self.sr)
+        cleaned, state = clean_calib_data(filtered_data, self.sr)
         if cleaned is None:
             self.calibration_data_available = False
             self.lifecycle_state = state
             return
         try:
             self._state = asr_calibrate(cleaned, self.sr, cutoff=self._cutoff)
+            self.calibration_data_available = True
             self.lifecycle_state = state
         except np.linalg.LinAlgError as e:
             self.calibration_data_available = False

src/explorepy/explore.py

@@ -734,7 +734,7 @@ def get_channel_mask(self):
         return SettingsManager(self.device_name).get_adc_mask()
 
     def is_asr_processor_available(self):
-        return self.stream_processor.asr_processor is not None and self.stream_processor.asr_processor.is_initialized
+        return self.stream_processor.ensure_asr_processor_available()
 
     def calibrate_asr(self, length=-1.0):
         if self.is_asr_processor_available():

src/explorepy/filters.py

@@ -4,6 +4,7 @@
 import logging
 
 import numpy as np
+from scipy import signal
 from scipy.signal import (
     butter,
     iirfilter,
@@ -17,6 +18,13 @@
 logger = logging.getLogger(__name__)
 
 
+@staticmethod
+def bp_filter(exg, lf, hf, fs, btype='bandpass'):
+    N = 5
+    b, a = signal.butter(N, [lf, hf], btype=btype, fs=fs)
+    return signal.filtfilt(b, a, exg, axis=1)
+
+
 class ExGFilter:
     """Filter class for ExG signals"""
     def __init__(self, cutoff_freq, filter_type, s_rate, n_chan, order=5):

src/explorepy/stream_processor.py

@@ -15,6 +15,7 @@
 
 import numpy as np
 
+from explorepy._exceptions import ImpedanceModeActiveError
 from explorepy.asr_processor import AsrProcessor
 from explorepy.command import (
     DeviceConfiguration,
@@ -617,5 +618,9 @@ def get_power_line_freq(self):
             (item for item in self.filters if item.filter_type == 'notch'),
             None
         )
-
         return match.get_cutoff_freq() if match else None
+
+    def ensure_asr_processor_available(self):
+        if self.is_imp_running():
+            raise ImpedanceModeActiveError()
+        return self.asr_processor is not None and self.asr_processor.is_initialized