add lab 5 and update code to be more python 2 compatible

lab3/LSLHandoff.py

@@ -3,7 +3,10 @@
 
 from pylsl import StreamInfo, StreamOutlet
 import numpy as np
-from builtins import input
+try:
+   input = raw_input
+except NameError:
+   pass
 
 info = StreamInfo('Ganglion_EEG', 'EEG', 4, 200, 'float32',
                   'Ganglion_123456789')

lab4/LSLHandoff.py

@@ -3,7 +3,10 @@
 
 from pylsl import StreamInfo, StreamOutlet
 import numpy as np
-from builtins import input
+try:
+   input = raw_input
+except NameError:
+   pass
 
 info = StreamInfo('Ganglion_EEG', 'EEG', 4, 200, 'float32',
                   'Ganglion_123456789')

lab5/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])

lab5/README.md

@@ -0,0 +1,37 @@
+# Lab 4: Neurofeedback
+
+### 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 Ganglion to participant's head.
+- Record positions of EEG according to 10-20 system.
+- 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`
+- Run neurofeedback: `python neurofeedback.py`
+
+When running `neurofeedback.py`, it will show a bar representing the ratio of beta (12-20Hz) to theta (4-8Hz) rhythms in all 4 electrodes.
+The goal is to increase beta while decreasing theta, which has been shown to improve symptoms of ADHD [1].
+
+You can play around with which frequency bands to use in the ratio for the bar by changing the following two variables in `neurofeedback.py`:
+
+``` python
+decrease_fs = [4, 8]
+increase_fs = [12, 20]
+```
+
+References
+[1] Arns, M., de Ridder, S., Strehl, U., Breteler, M., & Coenen, A. (2009). Efficacy of neurofeedback treatment in ADHD: the effects on inattention, impulsivity and hyperactivity: a meta-analysis. Clinical EEG and neuroscience, 40(3), 180-189. [(PDF)](http://www.bakerneuropsychology.com/files/Arns_2009_ClinEEGNeurosci_Efficacy_for_ADHD_meta-analysis.pdf)

lab5/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();

lab5/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=300,
+                  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 !')

lab5/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()

lab5/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"
+}

lab5/requirements.txt

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

lab5/stimulus.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python2
+
+import pygame
+import platform
+import time
+from pygame.locals import *
+
+fullscreen_on = False
+
+size = 1280,800
+width, height = size
+
+white = 255,255,255
+black = 0,0,0
+red = 255,0,0
+green = 0,255,0
+blue = 0,0,255
+chartreuse = 127,255,0
+light_green = 131,255,100
+nice_red = 207,45,64
+sky_blue = 100,244,255
+nice_blue = 0,194,255
+dark_gray = 20,20,20
+
+
+space_x = 100
+space_y = 100
+
+rect_width = (width - space_x*3)/2.0
+rect_height = (height - space_y *3)/2.0
+rect_xs = [space_x, space_x*2+rect_width, space_x, space_x*2+rect_width]
+rect_ys = [space_y, space_y, space_y*2+rect_height, space_y*2+rect_height]
+
+freqs = [10, 14, 17, 20]
+stimuli = [0, 0, 0, 0]
+wait_times = [0,0,0,0]
+
+
+
+if fullscreen_on:
+    screen = pygame.display.set_mode(size, FULLSCREEN)
+else:
+    screen = pygame.display.set_mode(size)
+
+if platform.system() == 'Windows':
+   wallclock = time.clock
+else:
+   wallclock = time.time
+
+pygame.mouse.set_visible(False)
+
+
+def check_for_escape():
+   event = pygame.event.poll()
+   if event.type == 0:
+       return
+   elif event.dict.get('key', -1) == K_ESCAPE:
+       pygame.quit()
+       exit()
+
+def draw_stimuli():
+    screen.fill(black)
+
+    for s, x, y in zip(stimuli, rect_xs, rect_ys):
+        if s == 0:
+            col = black
+        else:
+            col = white
+
+        rect = ((x, y), (rect_width, rect_height))
+        screen.fill(col, rect)
+
+    pygame.display.flip()
+
+
+to_wait = 0
+
+while True:
+    t = time.time()
+    check_for_escape()
+
+    draw_stimuli()
+
+    for i in range(len(stimuli)):
+        wait = wait_times[i]
+        if wait <= 1e-5:
+            stimuli[i] = 1 - stimuli[i]
+            wait_times[i] = 1.0/freqs[i]
+
+    to_wait = 0.005
+    time.sleep(to_wait)
+    for i in range(len(stimuli)):
+        wait_times[i] -= time.time() - t
+