initial try at lab 7

lab7/README.md

@@ -0,0 +1,26 @@
+# Lab 6: Stress
+
+### Introduction
+In this lab, we will record EEG while trying to remember words, as well as later recognizing these same words among others. Hopefully, we'll be able to see the event related potentials corresponding to remembered vs not-remembered words, and possibly recognized vs not recognized words.
+
+### Setup
+
+First, install the libraries:
+``` bash
+npm install
+pip install -r requirements.txt
+```
+
+(If you don't have `npm`, you can install by running `brew install node`. You can get `brew` from https://brew.sh/)
+
+### Stimulus Presentation + Recording
+
+
+- Attach electrodes to participant's head, preferably in visual cortex on the back of the head. 
+- Have participant sit in chair in front of monitor
+- Connect to the ganglion and stream data: `node ganglion-lsl.js`
+- Run lsl-viewer to check connections and stream: `python lsl-viewer.py`
+- Record data: `python lsl-record.py`
+- Run stress test: `python stroop_test.py medium` (can change easy to "hard" or "easy" for more or less stress)
+
+

lab7/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "lab3",
+  "version": "1.0.0",
+  "description": "",
+  "main": "ganglion-lsl.js",
+  "dependencies": {
+    "openbci-ganglion": "^0.4.3",
+    "python-shell": "^0.4.0"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "GPL-3.0"
+}

lab7/paradigm/play_tag_movie.py

@@ -0,0 +1,34 @@
+from kivy.app import App
+from kivy.uix.video import Video
+import sys
+import time
+from pylsl import StreamInfo, StreamOutlet
+try:
+   input = raw_input
+except NameError:
+   pass
+
+info = StreamInfo('Ganglion_EEG', 'Markers', 1, 0.0, 'int32',
+                  'marker')
+outlet = StreamOutlet(info)
+
+outlet.push_sample([-1], time.time())
+_ = input('\nStart recording and press Enter to start')
+
+if len(sys.argv) != 2:
+    print("usage: %s file" % sys.argv[0])
+    sys.exit(1)
+
+class VideoApp(App):
+    def build(self):
+        self.v = Video(source=sys.argv[1], state='play')
+        self.v.bind(state=self.update_state)
+        return self.v
+
+    def update_state(self, *args):
+        if self.v.state == 'stop':
+            outlet.push_sample([2], time.time())
+            exit()
+
+outlet.push_sample([1], time.time())            
+VideoApp().run()

lab7/paradigm/test_markers.py

@@ -0,0 +1,15 @@
+from pylsl import StreamInfo, StreamOutlet
+import numpy as np
+import time
+info = StreamInfo('Ganglion_EEG', 'Markers', 1, 0.0, 'int32',
+                  'marker')
+outlet = StreamOutlet(info)
+count = 0
+while True:
+    print(count)
+    stamp = time.time()
+    outlet.push_sample([count], stamp)
+    outlet.push_sample([count], stamp)
+    count += 1
+    time.sleep(0.1)
+    # print('Pushed Sample At: ' + strSample[0])

lab7/paradigm/test_movie.py

@@ -0,0 +1,22 @@
+from kivy.app import App
+from kivy.uix.video import Video
+import sys
+import time
+
+if len(sys.argv) != 2:
+    print("usage: %s file" % sys.argv[0])
+    sys.exit(1)
+
+class VideoApp(App):
+    def build(self):
+        self.v = Video(source=sys.argv[1], state='play')
+        self.v.bind(state=self.replay)
+        return self.v
+
+    def replay(self, *args):
+        if self.v.state == 'stop':
+            self.v.state = 'stop'
+            time.sleep(1)
+            exit()
+
+VideoApp().run()

lab7/recording/LSLHandoff.py

@@ -0,0 +1,19 @@
+## code by Alexandre Barachant
+## adapted by Pierre Karashchuk for compatibility with Python3
+
+from pylsl import StreamInfo, StreamOutlet
+import numpy as np
+try:
+   input = raw_input
+except NameError:
+   pass
+
+info = StreamInfo('Ganglion_EEG', 'EEG', 4, 200, 'float32',
+                  'Ganglion_123456789')
+outlet = StreamOutlet(info)
+while True:
+    strSample = input().split(': ', 1)
+    sample = 1e6*np.array(list(map(float, strSample[1].split(' '))))
+    stamp = float(strSample[0])*1e-3
+    outlet.push_sample(sample, stamp)
+    # print('Pushed Sample At: ' + strSample[0])

lab7/recording/ganglion-lsl.js

@@ -0,0 +1,29 @@
+// code by Alexandre Barachant
+
+const Ganglion = require('openbci-ganglion').Ganglion;
+const ganglion = new Ganglion();
+// Construct LSL Handoff Python Shell
+var PythonShell = require('python-shell');
+var lsloutlet = new PythonShell('LSLHandoff.py');
+
+lsloutlet.on('message', function(message){
+    console.log('LslOutlet: ' + message);
+});
+console.log('Python Shell Created for LSLHandoff');
+
+ganglion.once('ganglionFound', (peripheral) => {
+  // Stop searching for BLE devices once a ganglion is found.
+  ganglion.searchStop();
+  ganglion.on('sample', (sample) => {
+    /** Work with sample */
+    st = sample.channelData.join(' ');
+    var s = ''+ sample.timeStamp + ': '+ st
+    lsloutlet.send(s)
+  });
+  ganglion.once('ready', () => {
+    ganglion.streamStart();
+  });
+  ganglion.connect(peripheral);
+});
+// Start scanning for BLE devices
+ganglion.searchStart();

lab7/recording/lsl-record.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python
+## code by Alexandre Barachant
+import numpy as np
+import pandas as pd
+from time import time, strftime, gmtime
+from optparse import OptionParser
+from pylsl import StreamInlet, resolve_byprop
+from sklearn.linear_model import LinearRegression
+
+default_fname = ("../data/data_%s.csv" % strftime("%Y-%m-%d-%H.%M.%S", gmtime()))
+parser = OptionParser()
+parser.add_option("-d", "--duration",
+                  dest="duration", type='int', default=100,
+                  help="duration of the recording in seconds.")
+parser.add_option("-f", "--filename",
+                  dest="filename", type='str', default=default_fname,
+                  help="Name of the recording file.")
+
+# dejitter timestamps
+dejitter = False
+
+(options, args) = parser.parse_args()
+
+
+
+print("looking for an EEG stream...")
+streams = resolve_byprop('type', 'EEG', timeout=2)
+
+if len(streams) == 0:
+    raise(RuntimeError, "Cant find EEG stream")
+
+print("Start aquiring data")
+inlet = StreamInlet(streams[0], max_chunklen=12)
+eeg_time_correction = inlet.time_correction()
+
+print("looking for a Markers stream...")
+marker_streams = resolve_byprop('type', 'Markers', timeout=2)
+
+if marker_streams:
+    inlet_marker = StreamInlet(marker_streams[0])
+    marker_time_correction = inlet_marker.time_correction()
+else:
+    inlet_marker = False
+    print("Cant find Markers stream")
+
+info = inlet.info()
+description = info.desc()
+
+freq = info.nominal_srate()
+Nchan = info.channel_count()
+
+ch = description.child('channels').first_child()
+ch_names = [ch.child_value('label')]
+for i in range(1, Nchan):
+    ch = ch.next_sibling()
+    ch_names.append(ch.child_value('label'))
+
+res = []
+timestamps = []
+markers = []
+t_init = time()
+print('Start recording at time t=%.3f' % t_init)
+while (time() - t_init) < options.duration:
+    try:
+        data, timestamp = inlet.pull_chunk(timeout=1.0,
+                                           max_samples=12)
+        if timestamp:
+            res.append(data)
+            timestamps.extend(timestamp)
+        if inlet_marker:
+            marker, timestamp = inlet_marker.pull_sample(timeout=0.0)
+            if timestamp:
+                markers.append([marker, timestamp])
+    except KeyboardInterrupt:
+        break
+
+res = np.concatenate(res, axis=0)
+timestamps = np.array(timestamps)
+
+if dejitter:
+    y = timestamps
+    X = np.atleast_2d(np.arange(0, len(y))).T
+    lr = LinearRegression()
+    lr.fit(X, y)
+    timestamps = lr.predict(X)
+
+res = np.c_[timestamps, res]
+data = pd.DataFrame(data=res, columns=['timestamps'] + ch_names)
+
+data['Marker'] = 0
+# process markers:
+for marker in markers:
+    # find index of margers
+    ix = np.argmin(np.abs(marker[1] - timestamps))
+    val = timestamps[ix]
+    data.loc[ix, 'Marker'] = marker[0][0]
+
+
+data.to_csv(options.filename, float_format='%.3f', index=False)
+
+print('Done !')

lab7/recording/lsl-viewer.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python
+## code by Alexandre Barachant
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.signal import butter, filtfilt
+from time import time, sleep
+from pylsl import StreamInlet, resolve_byprop
+import seaborn as sns
+from threading import Thread
+
+sns.set(style="whitegrid")
+
+from optparse import OptionParser
+
+parser = OptionParser()
+
+parser.add_option("-w", "--window",
+                  dest="window", type='float', default=5.,
+                  help="window lenght to display in seconds.")
+parser.add_option("-s", "--scale",
+                  dest="scale", type='float', default=100,
+                  help="scale in uV")
+parser.add_option("-r", "--refresh",
+                  dest="refresh", type='float', default=0.2,
+                  help="refresh rate in seconds.")
+parser.add_option("-f", "--figure",
+                  dest="figure", type='string', default="15x6",
+                  help="window size.")
+
+filt = True
+subsample = 2
+buf = 12
+
+(options, args) = parser.parse_args()
+
+window = options.window
+scale = options.scale
+figsize = np.int16(options.figure.split('x'))
+
+print("looking for an EEG stream...")
+streams = resolve_byprop('type', 'EEG', timeout=2)
+
+if len(streams) == 0:
+    raise(RuntimeError("Cant find EEG stream"))
+print("Start aquiring data")
+
+
+class LSLViewer():
+
+    def __init__(self, stream, fig, axes,  window, scale, dejitter=True):
+        """Init"""
+        self.stream = stream
+        self.window = window
+        self.scale = scale
+        self.dejitter = dejitter
+        self.inlet = StreamInlet(stream, max_chunklen=buf)
+        self.filt = True
+        info = self.inlet.info()
+        description = info.desc()
+
+        self.sfreq = info.nominal_srate()
+        self.n_samples = int(self.sfreq * self.window)
+        self.n_chan = info.channel_count()
+
+        ch = description.child('channels').first_child()
+        ch_names = [ch.child_value('label')]
+
+        for i in range(self.n_chan):
+            ch = ch.next_sibling()
+            ch_names.append(ch.child_value('label'))
+
+        self.ch_names = ch_names
+
+        fig.canvas.mpl_connect('key_press_event', self.OnKeypress)
+        fig.canvas.mpl_connect('button_press_event', self.onclick)
+
+        self.fig = fig
+        self.axes = axes
+
+        sns.despine(left=True)
+
+        self.data = np.zeros((self.n_samples, self.n_chan))
+        self.times = np.arange(-self.window, 0, 1./self.sfreq)
+        impedances = np.std(self.data, axis=0)
+        lines = []
+
+        for ii in range(self.n_chan):
+            line, = axes.plot(self.times[::subsample],
+                              self.data[::subsample, ii] - ii, lw=1)
+            lines.append(line)
+        self.lines = lines
+
+        axes.set_ylim(-self.n_chan + 0.5, 0.5)
+        ticks = np.arange(0, -self.n_chan, -1)
+
+        axes.set_xlabel('Time (s)')
+        axes.xaxis.grid(False)
+        axes.set_yticks(ticks)
+
+        ticks_labels = ['%s - %.1f' % (ch_names[ii], impedances[ii])
+                        for ii in range(self.n_chan)]
+        axes.set_yticklabels(ticks_labels)
+
+        self.display_every = int(0.2 / (12/self.sfreq))
+
+        self.bf, self.af = butter(4, np.array([1, 40])/(self.sfreq/2.),
+                                  'bandpass')
+
+    def update_plot(self):
+        k = 0
+        while self.started:
+            samples, timestamps = self.inlet.pull_chunk(timeout=1.0,
+                                                        max_samples=12)
+            if timestamps:
+                self.data = np.vstack([self.data, samples])
+                if self.dejitter:
+                    timestamps = np.float64(np.arange(len(timestamps)))
+                    timestamps /= self.sfreq
+                    timestamps += self.times[-1] + 1./self.sfreq
+                self.times = np.concatenate([self.times, timestamps])
+
+                self.n_samples = int(self.sfreq * self.window)
+                self.data = self.data[-self.n_samples:]
+                self.times = self.times[-self.n_samples:]
+                k += 1
+                if k == self.display_every:
+                    if self.filt:
+                        data_f = filtfilt(self.bf, self.af, self.data, axis=0)
+                    else:
+                        data_f = self.data
+                        data_f -= data_f.mean(axis=0)
+
+                    for ii in range(self.n_chan):
+                        self.lines[ii].set_xdata(self.times[::subsample] -
+                                                 self.times[-1])
+                        self.lines[ii].set_ydata(data_f[::subsample, ii] /
+                                                 self.scale - ii)
+
+                    impedances = np.std(data_f, axis=0)
+                    ticks_labels = ['%s - %.2f' %
+                                    (self.ch_names[ii], impedances[ii])
+                                    for ii in range(self.n_chan)]
+                    self.axes.set_yticklabels(ticks_labels)
+                    self.axes.set_xlim(-self.window, 0)
+                    self.fig.canvas.draw()
+                    k = 0
+            else:
+                sleep(0.2)
+
+    def onclick(self, event):
+        print((event.button, event.x, event.y, event.xdata, event.ydata))
+
+    def OnKeypress(self, event):
+        if event.key == '/':
+            self.scale *= 1.2
+        elif event.key == '*':
+            self.scale /= 1.2
+        elif event.key == '+':
+            self.window += 1
+        elif event.key == '-':
+            if self.window > 1:
+                self.window -= 1
+        elif event.key == 'd':
+            self.filt = not(self.filt)
+
+    def start(self):
+        self.started = True
+        self.thread = Thread(target=self.update_plot)
+        self.thread.daemon = True
+        self.thread.start()
+
+    def stop(self):
+        self.started = False
+
+
+fig, axes = plt.subplots(1, 1, figsize=figsize, sharex=True)
+lslv = LSLViewer(streams[0], fig, axes, window, scale)
+
+help_str = """
+            toggle filter : d
+            toogle full screen : f
+            zoom out : /
+            zoom in : *
+            increase time scale : -
+            decrease time scale : +
+           """
+print(help_str)
+lslv.start()
+
+plt.show()
+lslv.stop()

lab7/requirements.txt

@@ -0,0 +1,6 @@
+pygame
+numpy
+scipy
+matplotlib
+pandas
+seaborn