Fixed issue with EDF recording

portiloop/src/capture.py

@@ -143,7 +143,7 @@ class Capture:
         self.record = False
         self.detect = False
         self.stimulate = False
-        self.threshold = 0.5
+        self.threshold = 0.82
         self.lsl = False
         self.display = False
         self.signal_input = "ADS"

portiloop/src/utils.py

@@ -1,9 +1,12 @@
 from EDFlib.edfwriter import EDFwriter
+from pyedflib import highlevel
 from portilooplot.jupyter_plot import ProgressPlot
 from pathlib import Path
 import numpy as np
 import csv
 import time
+import os
+import warnings
 
 
 EDF_PATH = Path.home() / 'workspace' / 'edf_recording'
@@ -22,52 +25,105 @@ class DummyAlsaMixer:
         self.volume = volume   
 
 
+# class EDFRecorder:
+#     def __init__(self, signal_labels, filename, frequency):
+#         self.filename = filename
+#         self.nb_signals = len(signal_labels)
+#         self.samples_per_datarecord_array = frequency
+#         self.physical_max = 5000000
+#         self.physical_min = -5000000
+#         self.signal_labels = signal_labels
+#         self.edf_buffer = []
+
+#     def open_recording_file(self):
+#         nb_signals = self.nb_signals
+#         samples_per_datarecord_array = self.samples_per_datarecord_array
+#         physical_max = self.physical_max
+#         physical_min = self.physical_min
+#         signal_labels = self.signal_labels
+
+#         print(f"Will store edf recording in {self.filename}")
+
+#         self.edf_writer = EDFwriter(p_path=str(self.filename),
+#                                     f_file_type=EDFwriter.EDFLIB_FILETYPE_EDFPLUS,
+#                                     number_of_signals=nb_signals)
+        
+#         for signal in range(nb_signals):
+#             assert self.edf_writer.setSampleFrequency(signal, samples_per_datarecord_array) == 0
+#             assert self.edf_writer.setPhysicalMaximum(signal, physical_max) == 0
+#             assert self.edf_writer.setPhysicalMinimum(signal, physical_min) == 0
+#             assert self.edf_writer.setDigitalMaximum(signal, 32767) == 0
+#             assert self.edf_writer.setDigitalMinimum(signal, -32768) == 0
+#             assert self.edf_writer.setSignalLabel(signal, signal_labels[signal]) == 0
+#             assert self.edf_writer.setPhysicalDimension(signal, 'uV') == 0
+
+#     def close_recording_file(self):
+#         assert self.edf_writer.close() == 0
+    
+#     def add_recording_data(self, data):
+#         self.edf_buffer += data
+#         if len(self.edf_buffer) >= self.samples_per_datarecord_array:
+#             datarecord_array = self.edf_buffer[:self.samples_per_datarecord_array]
+#             self.edf_buffer = self.edf_buffer[self.samples_per_datarecord_array:]
+#             datarecord_array = np.array(datarecord_array).transpose()
+#             assert len(datarecord_array) == self.nb_signals, f"len(data)={len(data)}!={self.nb_signals}"
+#             for d in datarecord_array:
+#                 assert len(d) == self.samples_per_datarecord_array, f"{len(d)}!={self.samples_per_datarecord_array}"
+#                 assert self.edf_writer.writeSamples(d) == 0
+
 class EDFRecorder:
     def __init__(self, signal_labels, filename, frequency):
+        self.writing_buffer = []
+        self.max_write = 1000
         self.filename = filename
-        self.nb_signals = len(signal_labels)
-        self.samples_per_datarecord_array = frequency
-        self.physical_max = 5
-        self.physical_min = -5
+        self.csv_filename = str(filename).split('.')[0] + '.csv'
         self.signal_labels = signal_labels
-        self.edf_buffer = []
+        self.frequency = frequency
 
     def open_recording_file(self):
-        nb_signals = self.nb_signals
-        samples_per_datarecord_array = self.samples_per_datarecord_array
-        physical_max = self.physical_max
-        physical_min = self.physical_min
-        signal_labels = self.signal_labels
-
-        print(f"Will store edf recording in {self.filename}")
-
-        self.edf_writer = EDFwriter(p_path=str(self.filename),
-                                    f_file_type=EDFwriter.EDFLIB_FILETYPE_EDFPLUS,
-                                    number_of_signals=nb_signals)
-        
-        for signal in range(nb_signals):
-            assert self.edf_writer.setSampleFrequency(signal, samples_per_datarecord_array) == 0
-            assert self.edf_writer.setPhysicalMaximum(signal, physical_max) == 0
-            assert self.edf_writer.setPhysicalMinimum(signal, physical_min) == 0
-            assert self.edf_writer.setDigitalMaximum(signal, 32767) == 0
-            assert self.edf_writer.setDigitalMinimum(signal, -32768) == 0
-            assert self.edf_writer.setSignalLabel(signal, signal_labels[signal]) == 0
-            assert self.edf_writer.setPhysicalDimension(signal, 'V') == 0
+        self.file = open(self.csv_filename, 'w')
 
     def close_recording_file(self):
-        assert self.edf_writer.close() == 0
-    
+        self.file.close()
+        data = np.genfromtxt(self.csv_filename, delimiter=',')
+        # Convert to float values
+        data = data.astype(np.float32)
+        data = data.transpose()
+        assert data.shape[0] == len(self.signal_labels), f"{data.shape[0]}!={len(self.signal_labels)}"
+        signal_headers = []
+        for row_i in range(data.shape[0]):
+            # If we only have zeros in that row, the channel was not activated so we must set the physical max and min manually
+            if np.all(data[row_i] == 0):
+                phys_max = 200
+                phys_min = -200
+            else:
+                phys_max = np.amax(data[row_i])
+                phys_min = np.amin(data[row_i])
+
+            # Create the signal header
+            signal_headers.append(highlevel.make_signal_header(
+                self.signal_labels[row_i], 
+                sample_frequency=self.frequency,
+                physical_max=phys_max,
+                physical_min=phys_min,))
+        self.filename = str(self.filename)
+        print(f"Saving to {self.filename}")
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            highlevel.write_edf(str(self.filename), data, signal_headers)
+
+        os.remove(self.csv_filename)
+
     def add_recording_data(self, data):
-        self.edf_buffer += data
-        if len(self.edf_buffer) >= self.samples_per_datarecord_array:
-            datarecord_array = self.edf_buffer[:self.samples_per_datarecord_array]
-            self.edf_buffer = self.edf_buffer[self.samples_per_datarecord_array:]
-            datarecord_array = np.array(datarecord_array).transpose()
-            assert len(datarecord_array) == self.nb_signals, f"len(data)={len(data)}!={self.nb_signals}"
-            for d in datarecord_array:
-                assert len(d) == self.samples_per_datarecord_array, f"{len(d)}!={self.samples_per_datarecord_array}"
-                assert self.edf_writer.writeSamples(d) == 0
+        self.writing_buffer += data
+        # write to file
+        if len(self.writing_buffer) >= self.max_write:
+            for point in self.writing_buffer:
+                self.file.write(','.join([str(elt) for elt in point]) + '\n')
+            self.writing_buffer = []
 
+        
 
 class LiveDisplay():
     def __init__(self, channel_names, window_len=100):

setup.py

@@ -11,6 +11,7 @@ def is_coral():
 
 requirements_list = ['wheel',
                      'EDFlib-Python',
+                     'pyEDFLib',
                      'numpy',
                      'portilooplot',
                      'ipywidgets',