Finished setting up the demo and fixed my git stupidity

portiloop/src/demo/demo.py

@@ -1,137 +1,47 @@
 import gradio as gr
-import matplotlib.pyplot as plt
-import time
-import numpy as np
-import pandas as pd
-from portiloop.src.demo.demo_stimulator import DemoSleepSpindleRealTimeStimulator
-from portiloop.src.detection import SleepSpindleRealTimeDetector
 
-from portiloop.src.stimulation import UpStateDelayer
-plt.switch_backend('agg')
-from portiloop.src.processing import FilterPipeline
+from portiloop.src.demo.offline import run_offline
 
-
-def do_treatment(csv_file, filtering, threshold, detect_channel, freq, spindle_freq, spindle_detection_mode, time_to_buffer):
-
-    # Read the csv file to a numpy array
-    data_whole = np.loadtxt(csv_file.name, delimiter=',')
-
-    # Get the data from the selected channel
-    detect_channel = int(detect_channel)
-    freq = int(freq)
-    data = data_whole[:, detect_channel - 1]
-
-    # Create the detector and the stimulator
-    detector = SleepSpindleRealTimeDetector(threshold=threshold, channel=1) # always 1 because we have only one channel
-    stimulator = DemoSleepSpindleRealTimeStimulator()
-    if spindle_detection_mode != 'Fast':
-        delayer = UpStateDelayer(freq, spindle_freq, spindle_detection_mode == 'Peak', time_to_buffer=time_to_buffer)
-        stimulator.add_delayer(delayer)
-    
-    # Create the filtering pipeline
-    if filtering:
-        filter = FilterPipeline(nb_channels=1, sampling_rate=freq)
-
-    # Plotting variables
-    points = []
-    activations = []
-    delayed_activations = []
-
-    # Go through the data
-    for index, point in enumerate(data):
-        # Step the delayer if exists
-        if spindle_detection_mode != 'Fast':
-            delayed = delayer.step(point)
-            if delayed:
-                delayed_activations.append(1)
-            else:
-                delayed_activations.append(0)
-
-        # Filter the data
-        if filtering:
-            filtered_point = filter.filter(np.array([point]))
-        else:
-            filtered_point = point
-        
-        filtered_point = filtered_point.tolist()
-
-        # Detect the spindles
-        result = detector.detect([filtered_point])
-
-        # Stimulate if necessary
-        stim = stimulator.stimulate(result)
-        if stim:
-            activations.append(1)
-        else:
-            activations.append(0)
-        
-        # Add data to plotting buffer
-        points.append(filtered_point[0])
-
-        # Function to return a list of all indexes where activations have happened
-        def get_activations(activations):
-            return [i for i, x in enumerate(activations) if x == 1]
-
-        # Plot the data
-        if index % (10 * freq) == 0 and index >= (10 * freq):
-            plt.close()
-            fig = plt.figure(figsize=(20, 10))
-            plt.clf()
-            plt.plot(np.linspace(0, 10, num=freq*10), points[-10 * freq:], label="Data")
-            # Draw vertical lines for activations
-            for index in get_activations(activations[-10 * freq:]):
-                plt.axvline(x=index / freq, color='r', label="Fast Stimulation")
-            if spindle_detection_mode != 'Fast':
-                for index in get_activations(delayed_activations[-10 * freq:]):
-                    plt.axvline(x=index / freq, color='g', label="Delayed Stimulation")
-            # Add axis titles and legend
-            plt.legend()
-            plt.xlabel("Time (s)")
-            plt.ylabel("Amplitude")
-            yield fig, None
-
-    # Put all points and activations back in numpy arrays
-    points = np.array(points)
-    activations = np.array(activations)
-    delayed_activations = np.array(delayed_activations)
-    # Concatenate with the original data
-    data_whole = np.concatenate((data_whole, points.reshape(-1, 1), activations.reshape(-1, 1), delayed_activations.reshape(-1, 1)), axis=1)
-    # Output the data to a csv file
-    np.savetxt('output.csv', data_whole, delimiter=',')
-
-    yield None, "output.csv"
         
+def on_upload_file(file):
+    # Check if file extension is .xdf
+    if file.name.split(".")[-1] != "xdf":
+        raise gr.Error("Please upload a .xdf file.")
+    else:
+        yield f"File {file.name} successfully uploaded!"
 
-    
 
 with gr.Blocks() as demo:
     gr.Markdown("# Portiloop Demo")
     gr.Markdown("This Demo takes as input a csv file containing EEG data and outputs a csv file with the following added: \n * The data filtered by the Portiloop online filter \n * The stimulations made by Portiloop.")
     gr.Markdown("Upload your CSV file and click **Run Inference** to start the processing...")
 
-    # Row containing all inputs:
     with gr.Row():
-        # CSV file
-        csv_file = gr.UploadButton(label="CSV File", file_count="single")
-        # Filtering (Boolean)
-        filtering = gr.Checkbox(label="Filtering (On/Off)", value=True)
+        xdf_file = gr.UploadButton(label="Upload XDF File", type="file")
+
+        # Offline Filtering (Boolean)
+        offline_filtering = gr.Checkbox(label="Offline Filtering (On/Off)", value=True)
+        # Online Filtering (Boolean)
+        online_filtering = gr.Checkbox(label="Online Filtering (On/Off)", value=True)
+        # Lacourse's Method (Boolean)
+        lacourse = gr.Checkbox(label="Lacourse Detection (On/Off)", value=True)
+        # Wamsley's Method (Boolean)
+        wamsley = gr.Checkbox(label="Wamsley Detection (On/Off)", value=True)
+        # Online Detection (Boolean)
+        online_detection = gr.Checkbox(label="Online Detection (On/Off)", value=True)
+
         # Threshold value
         threshold = gr.Slider(0, 1, value=0.82, step=0.01, label="Threshold", interactive=True)
         # Detection Channel
-        detect_column = gr.Dropdown(choices=["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"], value="1", label="Detection Column in CSV", interactive=True) 
+        detect_channel = gr.Dropdown(choices=["1", "2", "3", "4", "5", "6", "7", "8"], value="2", label="Detection Channel in XDF recording", interactive=True) 
         # Frequency
         freq = gr.Dropdown(choices=["100", "200", "250", "256", "500", "512", "1000", "1024"], value="250", label="Sampling Frequency (Hz)", interactive=True)
-        # Spindle Frequency
-        spindle_freq = gr.Slider(10, 16, value=12, step=1, label="Spindle Frequency (Hz)", interactive=True)
-        # Spindle Detection Mode
-        spindle_detection_mode = gr.Dropdown(choices=["Fast", "Peak", "Valley"], value="Peak", label="Spindle Detection Mode", interactive=True)
-        # Time to buffer
-        time_to_buffer = gr.Slider(0, 1, value=0.3, step=0.01, label="Time to Buffer (s)", interactive=True)
 
-    # Output plot
+    # Output elements
+    update_text = gr.Textbox(value="Waiting for user input...", label="Status", interactive=False)
     output_plot = gr.Plot()
-    # Output file
     output_array = gr.File(label="Output CSV File")
+    xdf_file.upload(fn=on_upload_file, inputs=[xdf_file], outputs=[update_text])
 
     # Row containing all buttons:
     with gr.Row():
@@ -139,7 +49,19 @@ with gr.Blocks() as demo:
         run_inference = gr.Button(value="Run Inference")
         # Reset button
         reset = gr.Button(value="Reset", variant="secondary")
-    run_inference.click(fn=do_treatment, inputs=[csv_file, filtering, threshold, detect_column, freq, spindle_freq, spindle_detection_mode, time_to_buffer], outputs=[output_plot, output_array])
+    run_inference.click(
+        fn=run_offline, 
+        inputs=[
+            xdf_file, 
+            offline_filtering, 
+            online_filtering, 
+            online_detection, 
+            lacourse, 
+            wamsley, 
+            threshold, 
+            detect_channel,
+            freq], 
+        outputs=[output_plot, output_array, update_text])
 
 demo.queue()
 demo.launch(share=True)

portiloop/src/demo/demo_stimulator.py

@@ -1,30 +0,0 @@
-import time
-from portiloop.src.stimulation import Stimulator
-
-
-class DemoSleepSpindleRealTimeStimulator(Stimulator):
-    def __init__(self):
-        self.last_detected_ts = time.time()
-        self.wait_t = 0.4  # 400 ms
-    
-    def stimulate(self, detection_signal):
-        stim = False
-        for sig in detection_signal:
-            # We detect a stimulation
-            if sig:
-                # Record time of stimulation
-                ts = time.time()
-                
-                # Check if time since last stimulation is long enough
-                if ts - self.last_detected_ts > self.wait_t:
-                    if self.delayer is not None:
-                        # If we have a delayer, notify it
-                        self.delayer.detected()
-                    stim = True
-
-                self.last_detected_ts = ts
-        return stim
-
-    def add_delayer(self, delayer):
-        self.delayer = delayer
-        self.delayer.stimulate = lambda: True

portiloop/src/demo/offline.py

@@ -0,0 +1,137 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from portiloop.src.detection import SleepSpindleRealTimeDetector
+plt.switch_backend('agg')
+from portiloop.src.processing import FilterPipeline
+from portiloop.src.demo.utils import xdf2array, offline_detect, offline_filter, OfflineSleepSpindleRealTimeStimulator
+import gradio as gr
+
+
+def run_offline(xdf_file, offline_filtering, online_filtering, online_detection, lacourse, wamsley, threshold, channel_num, freq):
+
+    print("Starting offline processing...")
+    # Make sure the inputs make sense:
+    if not offline_filtering and (lacourse or wamsley):
+        raise gr.Error("You can't use the offline detection methods without offline filtering.")
+
+    if not online_filtering and online_detection:
+        raise gr.Error("You can't use the online detection without online filtering.")
+
+    freq = int(freq)
+
+    # Read the xdf file to a numpy array
+    print("Loading xdf file...")
+    yield None, None, "Loading xdf file..."
+    data_whole, columns = xdf2array(xdf_file.name, int(channel_num))
+    print(data_whole.shape)
+    # Do the offline filtering of the data
+    print("Filtering offline...")
+    yield None, None, "Filtering offline..."
+    if offline_filtering:
+        offline_filtered_data = offline_filter(data_whole[:, columns.index("raw_signal")], freq)
+        # Expand the dimension of the filtered data to match the shape of the other columns
+        offline_filtered_data = np.expand_dims(offline_filtered_data, axis=1)
+        data_whole = np.concatenate((data_whole, offline_filtered_data), axis=1)
+        columns.append("offline_filtered_signal")
+
+    #  Do Wamsley's method
+    print("Running Wamsley detection...")
+    yield None, None, "Running Wamsley detection..."
+    if wamsley:
+        wamsley_data = offline_detect("Wamsley", \
+            data_whole[:, columns.index("offline_filtered_signal")],\
+                data_whole[:, columns.index("time_stamps")],\
+                    freq)
+        wamsley_data = np.expand_dims(wamsley_data, axis=1)
+        data_whole = np.concatenate((data_whole, wamsley_data), axis=1)
+        columns.append("wamsley_spindles")
+
+    # Do Lacourse's method
+    print("Running Lacourse detection...")
+    yield None, None, "Running Lacourse detection..."
+    if lacourse:
+        lacourse_data = offline_detect("Lacourse", \
+            data_whole[:, columns.index("offline_filtered_signal")],\
+                data_whole[:, columns.index("time_stamps")],\
+                    freq)
+        lacourse_data = np.expand_dims(lacourse_data, axis=1)
+        data_whole = np.concatenate((data_whole, lacourse_data), axis=1)
+        columns.append("lacourse_spindles")
+
+    # Get the data from the raw signal column
+    data = data_whole[:, columns.index("raw_signal")]
+    
+    # Create the online filtering pipeline
+    if online_filtering:
+        filter = FilterPipeline(nb_channels=1, sampling_rate=freq)
+
+    # Create the detector
+    if online_detection:
+        detector = SleepSpindleRealTimeDetector(threshold=threshold, channel=1) # always 1 because we have only one channel
+        stimulator = OfflineSleepSpindleRealTimeStimulator()
+
+    print("Running online filtering and detection...")
+    yield None, None, "Running online filtering and detection..."
+    if online_filtering or online_detection:
+        # Plotting variables
+        points = []
+        online_activations = []
+
+        # Go through the data
+        for index, point in enumerate(data):
+            # Filter the data
+            if online_filtering:
+                filtered_point = filter.filter(np.array([point]))
+            else:
+                filtered_point = point
+            filtered_point = filtered_point.tolist()
+            points.append(filtered_point[0])
+
+            if online_detection:
+                # Detect the spindles
+                result = detector.detect([filtered_point])
+
+                # Stimulate if necessary
+                stim = stimulator.stimulate(result)
+                if stim:
+                    online_activations.append(1)
+                else:
+                    online_activations.append(0)
+            
+            # Function to return a list of all indexes where activations have happened
+            def get_activations(activations):
+                return [i for i, x in enumerate(activations) if x == 1]
+
+            # Plot the data
+            if index % (10 * freq) == 0 and index >= (10 * freq):
+                plt.close()
+                fig = plt.figure(figsize=(20, 10))
+                plt.clf()
+                plt.plot(np.linspace(0, 10, num=freq*10), points[-10 * freq:], label="Data")
+                # Draw vertical lines for activations
+                for index in get_activations(online_activations[-10 * freq:]):
+                    plt.axvline(x=index / freq, color='r', label="Portiloop Stimulation")
+                # Add axis titles and legend
+                plt.legend()
+                plt.xlabel("Time (s)")
+                plt.ylabel("Amplitude")
+                yield fig, None, "Running online filtering and detection..."
+
+    if online_filtering:
+        online_filtered = np.array(points)
+        online_filtered = np.expand_dims(online_filtered, axis=1)
+        data_whole = np.concatenate((data_whole, online_filtered), axis=1)
+        columns.append("online_filtered_signal")
+
+    if online_detection:
+        online_activations = np.array(online_activations)
+        online_activations = np.expand_dims(online_activations, axis=1)
+        data_whole = np.concatenate((data_whole, online_activations), axis=1)
+        columns.append("online_stimulations")
+
+    print("Saving output...")
+    # Output the data to a csv file
+    np.savetxt("output.csv", data_whole, delimiter=",", header=",".join(columns), comments="")
+
+    print("Done!")
+    yield None, "output.csv", "Done!"

portiloop/src/demo/test_offline.py

@@ -0,0 +1,49 @@
+import itertools
+import unittest
+from portiloop.src.demo.offline import run_offline
+from pathlib import Path
+
+
+class TestOffline(unittest.TestCase):
+
+    def setUp(self):
+        combinatorial_config = {
+            'offline_filtering': [True, False],
+            'online_filtering': [True, False],
+            'online_detection': [True, False],
+            'wamsley': [True, False],
+            'lacourse': [True, False],
+        }
+
+        self.exclusives = [("duplicate_as_window", "use_cnn_encoder")]
+
+        keys = list(combinatorial_config)
+        all_options_iterator = itertools.product(*map(combinatorial_config.get, keys))
+        all_options_dicts = [dict(zip(keys, values)) for values in all_options_iterator]
+        self.filtered_options = [value for value in all_options_dicts if (value['online_detection'] and value['online_filtering']) or not value['online_detection']]
+        self.xdf_file = Path(__file__).parents[3] / "test_xdf" / "test_file.xdf"
+
+
+    def test_all_options(self):
+        for config in self.filtered_options:
+            if config['online_detection']:
+                self.assertTrue(config['online_filtering'])
+
+    def test_single_option(self):
+        res = list(run_offline(
+                self.xdf_file,
+                offline_filtering=True,
+                online_filtering=True,
+                online_detection=True,
+                wamsley=True,
+                lacourse=True,
+                threshold=0.5,
+                channel_num=2,
+                freq=250))
+        print(res)
+
+    def tearDown(self):
+        pass
+
+if __name__ == '__main__':
+    unittest.main()

portiloop/src/demo/utils.py

@@ -0,0 +1,132 @@
+import numpy as np
+import pyxdf
+from wonambi.detect.spindle import DetectSpindle, detect_Lacourse2018, detect_Wamsley2012
+from scipy.signal import butter, filtfilt, iirnotch, detrend
+import time
+from portiloop.src.stimulation import Stimulator
+
+
+STREAM_NAMES = {
+    'filtered_data': 'Portiloop Filtered',
+    'raw_data': 'Portiloop Raw Data',
+    'stimuli': 'Portiloop_stimuli'
+}
+
+
+class OfflineSleepSpindleRealTimeStimulator(Stimulator):
+    def __init__(self):
+        self.last_detected_ts = time.time()
+        self.wait_t = 0.4  # 400 ms
+        self.delayer = None
+    
+    def stimulate(self, detection_signal):
+        stim = False
+        for sig in detection_signal:
+            # We detect a stimulation
+            if sig:
+                # Record time of stimulation
+                ts = time.time()
+                
+                # Check if time since last stimulation is long enough
+                if ts - self.last_detected_ts > self.wait_t:
+                    if self.delayer is not None:
+                        # If we have a delayer, notify it
+                        self.delayer.detected()
+                    stim = True
+
+                self.last_detected_ts = ts
+        return stim
+
+    def add_delayer(self, delayer):
+        self.delayer = delayer
+        self.delayer.stimulate = lambda: True
+
+def xdf2array(xdf_path, channel):
+    xdf_data, _ = pyxdf.load_xdf(xdf_path)
+
+    # Load all streams given their names
+    filtered_stream, raw_stream, markers = None, None, None
+    for stream in xdf_data:
+        # print(stream['info']['name'])
+        if stream['info']['name'][0] == STREAM_NAMES['filtered_data']:
+            filtered_stream = stream
+        elif stream['info']['name'][0] == STREAM_NAMES['raw_data']:
+            raw_stream = stream
+        elif stream['info']['name'][0] == STREAM_NAMES['stimuli']:
+            markers = stream
+    
+    if filtered_stream is None or raw_stream is None:
+        raise ValueError("One of the necessary streams could not be found. Make sure that at least one signal stream is present in XDF recording")
+
+    # Add all samples from raw and filtered signals
+    csv_list = []
+    diffs = []
+    shortest_stream = min(int(filtered_stream['footer']['info']['sample_count'][0]),
+                          int(raw_stream['footer']['info']['sample_count'][0]))
+    for i in range(shortest_stream):
+        if markers is not None:
+            datapoint = [filtered_stream['time_stamps'][i], 
+                        float(filtered_stream['time_series'][i, channel-1]), 
+                        raw_stream['time_series'][i, channel-1], 
+                        0]
+        else:
+            datapoint = [filtered_stream['time_stamps'][i], 
+                        float(filtered_stream['time_series'][i, channel-1]), 
+                        raw_stream['time_series'][i, channel-1]]
+        diffs.append(abs(filtered_stream['time_stamps'][i] - raw_stream['time_stamps'][i]))
+        csv_list.append(datapoint)
+
+    # Add markers
+    columns = ["time_stamps", "online_filtered_signal_portiloop", "raw_signal"]
+    if markers is not None:
+        columns.append("online_stimulations_portiloop")
+        for time_stamp in markers['time_stamps']:
+            new_index = np.abs(filtered_stream['time_stamps'] - time_stamp).argmin()
+            csv_list[new_index][3] = 1
+    
+    return np.array(csv_list), columns
+    
+
+def offline_detect(method, data, timesteps, freq):
+    # Get the spindle data from the offline methods
+    time = np.arange(0, len(data)) / freq
+    if method == "Lacourse":
+        detector = DetectSpindle(method='Lacourse2018')
+        spindles, _, _ = detect_Lacourse2018(data, freq, time, detector)
+    elif method == "Wamsley":
+        detector = DetectSpindle(method='Wamsley2012')
+        spindles, _, _ = detect_Wamsley2012(data, freq, time, detector)
+    else:
+        raise ValueError("Invalid method")
+
+    # Convert the spindle data to a numpy array
+    spindle_result = np.zeros(data.shape)
+    for spindle in spindles:
+        start = spindle["start"]
+        end = spindle["end"]
+        # Find index of timestep closest to start and end
+        start_index = np.argmin(np.abs(timesteps - start))
+        end_index = np.argmin(np.abs(timesteps - end))
+        spindle_result[start_index:end_index] = 1
+    return spindle_result
+
+
+def offline_filter(signal, freq):
+
+    # Notch filter
+    f0 = 60.0  # Frequency to be removed from signal (Hz)
+    Q = 100.0  # Quality factor
+    b, a = iirnotch(f0, Q, freq)
+    signal = filtfilt(b, a, signal)
+
+    # Bandpass filter
+    lowcut = 0.5
+    highcut = 40.0
+    order = 4
+    b, a = butter(order, [lowcut / (freq / 2.0), highcut / (freq / 2.0)], btype='bandpass')
+    signal = filtfilt(b, a, signal)
+
+    # Detrend the signal
+    signal = detrend(signal)
+
+    return signal

portiloop/src/detection.py

@@ -154,7 +154,3 @@ class SleepSpindleRealTimeDetector(Detector):
             print(f"Computed output {output_data_y} in {end_time - start_time} seconds")
 
         return output_data_y, output_data_h
-        
-        
-    
-    

setup.py

@@ -20,6 +20,7 @@ setup(
                 'pylsl-coral', 
                 'pyalsaaudio'],
         'PC': ['gradio',
-               'tensorflow',]
+               'tensorflow',
+               'pyxdf']
     },
 )