Merge pull request #422 from Mentalab-hub/APIS-1349-live-impedance-measurement

Apis 1349 live impedance measurement

Author: salman2135

src/explorepy/explore.py

@@ -182,13 +182,15 @@ def record_data(
         if file_type not in ['edf', 'csv']:
             raise ValueError(
                 '{} is not a supported file extension!'.format(file_type))
+
         if imp_mode:
+            if not self.stream_processor.is_imp_running():
+                raise ValueError('Impedance measurement not running!')
             if file_type == 'edf':
                 raise ValueError(
                     '{} is not a supported file extension for recording impedance!'.format(file_type))
-            if notch_freq is None:
-                raise ValueError(
-                    'Missing notch frequency argument, please provide the notch frequency to get live impedance values')
+
+            notch_freq = self.stream_processor.get_power_line_freq() or 50
 
         duration = self._check_duration(duration)
 
@@ -260,7 +262,6 @@ def handle_impedance_packet(packet):
                 impedance_values = packet.get_impedances()
 
                 real_values = np.array(impedance_values) / 2
-                print("Impedance:", real_values.tolist())
 
                 if file_type == 'csv':
                     row_data = [float(packet.timestamp), *real_values]
@@ -271,7 +272,6 @@ def handle_impedance_packet(packet):
 
             self.stream_processor.subscribe(callback=handle_exg_impedance_packet, topic=TOPICS.raw_ExG)
             self.stream_processor.subscribe(callback=handle_impedance_packet, topic=TOPICS.imp)
-            self.stream_processor.imp_initialize(notch_freq=notch_freq)
             logger.info("Recording with impedance mode...")
         else:
             self.stream_processor.subscribe(callback=self.recorders['exg'].write_data, topic=TOPICS.raw_ExG)
@@ -301,8 +301,6 @@ def stop_recording(self):
 
             if is_impedance_mode:
                 try:
-                    self.stream_processor.disable_imp()
-
                     if 'handle_exg_impedance_callback' in self.recorders:
                         self.stream_processor.unsubscribe(
                             callback=self.recorders['handle_exg_impedance_callback'], topic=TOPICS.raw_ExG)

src/explorepy/filters.py

@@ -31,6 +31,7 @@ def __init__(self, cutoff_freq, filter_type, s_rate, n_chan, order=5):
         self.s_rate = float(s_rate)
         self.filter_type = filter_type
         self.filter_param = None
+        self.cutoff_freq = cutoff_freq
         order = 2 if self.s_rate > 1000 else order
         a, b, zi = self.get_filter_coeffs(cutoff_freq, filter_type, s_rate, n_chan, order)
         self.filter_param = {'a': a, 'b': b, 'zi': zi}
@@ -110,6 +111,9 @@ def get_notch_coeffs(cutoff, nyquist, n_channels, order, quality=30, imp_mode=Fa
             zi = np.zeros(shape=(n_channels, 2))
         return a, b, zi
 
+    def get_cutoff_freq(self):
+        return self.cutoff_freq
+
     def apply(self, input_data, in_place=True):
         """Apply filter
 

src/explorepy/stream_processor.py

@@ -78,6 +78,7 @@ def __init__(self, debug=False):
         self.reset_timer()
         self.packet_count = 0
         self.progress = 0
+        self._notch_filter = None
 
     def subscribe(self, callback, topic):
         """Subscribe a function to a topic
@@ -312,13 +313,17 @@ def process(self, packet):
             self.last_exg_packet_timestamp = get_local_time()
             missing_timestamps = self.fill_missing_packet(packet)
             self._update_last_time_point(packet, received_time)
-            self.dispatch(topic=TOPICS.raw_ExG, packet=packet)
             self.packet_count += 1
-            if self._is_imp_mode and self.imp_calculator:
+            if self.is_imp_running():
                 packet_imp = self.imp_calculator.measure_imp(
                     packet=copy.deepcopy(packet))
                 if packet_imp is not None:
                     self.dispatch(topic=TOPICS.imp, packet=packet_imp)
+                if self._notch_filter:
+                    self._notch_filter.apply(packet)
+                    self.dispatch(topic=TOPICS.raw_ExG, packet=packet)
+            else:
+                self.dispatch(topic=TOPICS.raw_ExG, packet=packet)
             try:
                 self.apply_filters(packet=packet)
             except ValueError as error:
@@ -454,9 +459,10 @@ def imp_initialize(self, notch_freq, calibration=False):
         cmd = ZMeasurementEnable()
         if self.configure_device(cmd):
             self.imp_calib_info['calibration'] = calibration
+            self._add_notch_filter()
             self.imp_calculator = ImpedanceMeasurement(device_info=self.device_info,
                                                        calib_param=self.imp_calib_info,
-                                                       notch_freq=notch_freq)
+                                                       notch_freq=self.get_power_line_freq() or notch_freq)
             self._is_imp_mode = True
         else:
             raise ConnectionError('Device configuration process failed!')
@@ -470,6 +476,7 @@ def disable_imp(self):
             return True
         print("WARNING: Couldn't disable impedance measurement mode. "
               "Please restart your device manually.")
+        self._notch_filter = None
         return False
 
     def set_marker(self, marker_string, time_lsl=None, name='mkr', soft_marker=True):
@@ -583,3 +590,22 @@ def fill_missing_packet(self, packet):
                     timestamps = np.linspace(self._last_packet_timestamp + sps,
                                              packet.timestamp, num=missing_samples, endpoint=True)
         return timestamps[:-1]
+
+    def _add_notch_filter(self):
+        self._notch_filter = ExGFilter(
+            cutoff_freq=62.5,
+            filter_type='notch_imp',
+            s_rate=250,
+            n_chan=SettingsManager(self.device_info['device_name']).get_channel_count()
+        )
+
+    def is_imp_running(self):
+        return self._is_imp_mode and self.imp_calculator
+
+    def get_power_line_freq(self):
+        match = next(
+            (item for item in self.filters if item.filter_type == 'notch'),
+            None
+        )
+
+        return match.cutoff_freq if match else None