def processing(fpath, bdf, eid, fs): # eid = [id_475_pos, id_475_neg, id_500_pos, id_500_neg, id_525_pos, id_525_neg,]
rawtemp, evestemp = bs.importbdf(fpath + bdf)
raw = rawtemp
eves2 = evestemp.copy()
eves2[:, 1] = np.mod(eves2[:, 1], 256)
eves2[:, 2] = np.mod(eves2[:, 2], 256)
raw.filter(l_freq = 400, h_freq=1300) # adjust this range
evoked_pos = []
evoked_neg = []
numpos = []
numneg = []
flags = [False, False]
if eid[0] in eves2[:,2]:
evoked_pos, numpos = evoked(raw, eves2, eid[0])
subtraction = offsetSub(evoked_pos, fs)
evoked_pos = evoked_pos - subtraction
evoked_pos = evoked_pos[int(0.0266*fs):int((0.0266+0.395)*fs)] # starting from time 0 to the end of masked stimulus
flags[0] = True;
length = len(evoked_pos)
if eid[1] in eves2[:,2]:
evoked_neg, numneg = evoked(raw, eves2, eid[1])
subtraction = offsetSub(evoked_neg, fs)
evoked_neg = evoked_neg - subtraction
evoked_neg = evoked_neg[int(0.0266*fs):int((0.0266+0.395)*fs)]
flags[1] = True;
length = len(evoked_neg)
return evoked_pos, evoked_neg, numpos, numneg, length, flags
def processing(
fpath, bdf, eid, fs
): # eid = [id_475_pos, id_475_neg, id_500_pos, id_500_neg, id_525_pos, id_525_neg,]
raw, eves = bs.importbdf(fpath + bdf)
raw.info['bads'] += ['A28', 'A3', 'A6', 'A24', 'A7', 'A25', 'A27']
eves[:, 1] = np.mod(eves[:, 1], 256)
eves[:, 2] = np.mod(eves[:, 2], 256)
raw.filter(l_freq=400, h_freq=1300) # adjust this range
evoked_pos = []
evoked_neg = []
numpos = []
numneg = []
flags = [False, False]
if eid[0] in eves[:, 2]:
evoked_pos, numpos, epochs_prob_pos, epochs_masked_pos, epochs_masker_pos = evoked(
raw, eves, eid[0])
flags[0] = True
length = len(evoked_pos)
if eid[1] in eves[:, 2]:
evoked_neg, numneg, epochs_prob_neg, epochs_masked_neg, epochs_masker_neg = evoked(
raw, eves, eid[1])
flags[1] = True
length = len(evoked_neg)
return evoked_pos, evoked_neg, numpos, numneg, length, flags, epochs_prob_pos, epochs_masked_pos, epochs_masker_pos, epochs_prob_neg, epochs_masked_neg, epochs_masker_neg
def EEGconcatenateFolder(folder, nchans, refchans, fs_new=[], exclude=[]):
#concatenates all the EEG files in one folder
#Assumes files are in format output from biosemi ... subj.bdf, subj+001.bdf, etc.
#Also folder should end with a '/'
EEGfiles = listdir(folder)
EEGfiles.sort() # This line and next to fix order of files
EEGfiles.insert(0, EEGfiles.pop(len(EEGfiles) - 1))
print(EEGfiles)
raw = []
events = []
for eeg_f in EEGfiles:
raw_temp, events_temp = bs.importbdf(
folder + eeg_f, nchans, refchans,
exclude=exclude) #uses EXG1 and EXG2 as reference usually
if numel(fs_new):
print('Resample raw data and update eves indices')
events_temp[:, 0] = np.round(events_temp[:, 0] /
raw_temp.info['sfreq'] *
fs_new).astype('int')
raw_temp.resample(fs_new)
raw.append(raw_temp)
events.append(events_temp)
EEG_full, events_full = concatenate_raws(raw, events_list=events)
return EEG_full, events_full
def preprocessing_raw(fpath, subj):
# load data and read event channels
rawlist = []
evelist = []
# extracting bdf filenames into bdfs
bdfs = fnmatch.filter(os.listdir(fpath), subj + '_ITD*.bdf')
if len(bdfs) >= 1:
for k, bdf in enumerate(bdfs):
rawtemp, evestemp = bs.importbdf(fpath + bdf)
rawlist += [rawtemp,]
evelist += [evestemp,]
else:
RuntimeError("No bdf files found!")
raw, eves = mne.concatenate_raws(rawlist, events_list = evelist)
# Things to try if data are too noisy
# raw.info['bads'] += ['A20'] # if A7, A6, A24 have been rejected a lot, they can be added manually
# raw.set_eeg_reference(ref_channels = ['Average']) # referencing to the average of all channels, do this if channels are too noisy
# the returned eves has three columns: sample number, value of onset, value of offset.
eves2 = eves.copy()
eves2[:, 1] = np.mod(eves2[:, 1], 256)
eves2[:, 2] = np.mod(eves2[:, 2], 256)
# raw.plot(events=eves2)
raw.filter(l_freq = 1, h_freq=50) # if channels are noisy, adjust the filter parameters, high-pass frequency is better set at 1 compared to 0.5 Hz, to get rid of low-frequency drift
# SSP for blinks
blinks = find_blinks(raw, ch_name = ['A1',], l_trans_bandwidth=0.5,
l_freq=1.0) # A1 is the closest electrode to eyebrow, raw.plot(events=blinks) shows the lines at eye blinks, 998 is default event_id
epochs_blinks = mne.Epochs(raw, blinks, 998, tmin = -0.25, tmax = 0.25,
proj = False, baseline = (-0.25, 0),
reject=dict(eeg=500e-6))
n_eeg = 4
blink_projs = compute_proj_epochs(epochs_blinks, n_grad=0,
n_mag=0, n_eeg=n_eeg,
verbose='DEBUG')
if subj in ['S025', 'S031', 'S046', 'S117', 'S123', 'S127', 'S128', 'S132', 'S133', 'S143', 'S149', 'S051', 'S183', 'S185', 'S187', 'S189', 'S193', 'S195', 'S196', 'S043', 'S072', 'S078', 'S191', 'S129', 'S141', 'S190', 'S194']:
#raw.add_proj(blink_projs) # adding all projections
#raw.del_proj()
#raw.plot_projs_topomap()
raw.add_proj([blink_projs[0], blink_projs[2]])
elif subj in ['S135', 'S192', 'S197', 'S199', 'S216', 'S218']:
raw.add_proj([blink_projs[0], blink_projs[1]])
elif subj in ['S084', 'S075']:
raw.add_proj([blink_projs[0]])
return raw, eves2
def processing(fpath, bdf, eid): # eid = [id_475_pos, id_475_neg, id_500_pos, id_500_neg, id_525_pos, id_525_neg,]
rawtemp, evestemp = bs.importbdf(fpath + bdf)
raw = rawtemp
eves2 = evestemp.copy()
eves2[:, 1] = np.mod(eves2[:, 1], 256)
eves2[:, 2] = np.mod(eves2[:, 2], 256)
raw.filter(l_freq = 400, h_freq=1300) # adjust this range
evoked_475_pos = []
evoked_475_neg = []
evoked_500_pos = []
evoked_500_neg = []
evoked_525_pos = []
evoked_525_neg = []
num475pos = []
num475neg = []
num500pos = []
num500neg = []
num525pos = []
num525neg = []
flags = [False, False, False, False, False, False]
if eid[0] in eves2[:,2]:
evoked_475_pos, num475pos = epochsExtraction(raw, eves2, eid[0])
flags[0] = True;
length = len(evoked_475_pos)
if eid[1] in eves2[:,2]:
evoked_475_neg, num475neg = epochsExtraction(raw, eves2, eid[1])
flags[1] = True;
length = len(evoked_475_neg)
if eid[2] in eves2[:,2]:
evoked_500_pos, num500pos = epochsExtraction(raw, eves2, eid[2])
flags[2] = True;
length = len(evoked_500_pos)
if eid[3] in eves2[:,2]:
evoked_500_neg, num500neg = epochsExtraction(raw, eves2, eid[3])
flags[3] = True;
length = len(evoked_500_neg)
if eid[4] in eves2[:,2]:
evoked_525_pos, num525pos = epochsExtraction(raw, eves2, eid[4])
flags[4] = True;
length = len(evoked_525_pos)
if eid[5] in eves2[:,2]:
evoked_525_neg, num525neg = epochsExtraction(raw, eves2, eid[5])
flags[5] = True;
length = len(evoked_525_neg)
return evoked_475_pos, evoked_475_neg, evoked_500_pos, evoked_500_neg, evoked_525_pos, evoked_525_neg, num475pos, num475neg, num500pos, num500neg, num525pos, num525neg, length, flags
def EEGconcatenateFolder(folder, nchans, refchans, exclude=[]):
#concatenates all the EEG files in one folder
#Assumes files are in format output from biosemi ... subj.bdf, subj+001.bdf, etc.
#Also folder should end with a '/'
EEGfiles = listdir(folder)
EEGfiles.sort() # This line and next to fix order of files
EEGfiles.insert(0, EEGfiles.pop(len(EEGfiles) - 1))
print(EEGfiles)
raw = []
events = []
for eeg_f in EEGfiles:
raw_f, events_f = bs.importbdf(
folder + eeg_f, nchans, refchans,
exclude=exclude) #uses EXG1 and EXG2 as reference usually
raw.append(raw_f)
events.append(events_f)
EEG_full, events_full = concatenate_raws(raw, events_list=events)
return EEG_full, events_full
def processing(fpath, bdf, eid, fs): # eid = [id_475_pos, id_475_neg, id_500_pos, id_500_neg, id_525_pos, id_525_neg,]
rawtemp, evestemp = bs.importbdf(fpath + bdf)
raw = rawtemp
evestemp[:, 1] = np.mod(evestemp[:, 1], 256)
evestemp[:, 2] = np.mod(evestemp[:, 2], 256)
raw.filter(l_freq = 100, h_freq=2000) # ABR is broadband
evoked_pos = []
evoked_neg = []
numpos = []
numneg = []
flags = [False, False]
if eid[0] in evestemp[:,2]:
evoked_pos, numpos, data_masker_pos = evoked(raw, evestemp, eid[0])
flags[0] = True;
length = len(evoked_pos)
if eid[1] in evestemp[:,2]:
evoked_neg, numneg, data_masker_neg = evoked(raw, evestemp, eid[1])
flags[1] = True;
length = len(evoked_neg)
return evoked_pos, evoked_neg, numpos, numneg, length, flags, data_masker_pos, data_masker_neg
EEGfiles.sort() #This line and next to fix order of files
EEGfiles.insert(0, EEGfiles.pop(len(EEGfiles) - 1))
epdat = []
#%% Go through all files
file_num = 0
files_at_time = 3
while file_num < len(EEGfiles):
data_eeg = []
data_evnt = []
for fn in range(files_at_time):
if file_num < len(EEGfiles):
raw_f, events_f = bs.importbdf(datapath + '/' +
EEGfiles[file_num],
nchans,
refchans,
exclude=exclude)
data_eeg.append(raw_f)
data_evnt.append(events_f)
file_num += 1
data_eeg, data_evnt = concatenate_raws(data_eeg, events_list=data_evnt)
data_eeg.filter(l_freq=1, h_freq=1000)
del raw_f, events_f
# Blink Removal
blinks = find_blinks(data_eeg,
ch_name=['A1'],
thresh=100e-6,
l_trans_bandwidth=0.5,
l_freq=1.0)
from anlffr.helper import biosemi2mne as bs import mne import numpy as np from anlffr import spectral import pylab as pl # Adding Files and locations # This below is just an example # You have to edit this to supply your own data fpath = '/home/hari/Documents/MNEforBiosemi/' edfname = 'I13_depth_01.bdf' # Load data and read event channel (raw,eves) = bs.importbdf(fpath+edfname) # Filter the data raw.filter(l_freq = 70, h_freq = 1500, picks = np.arange(0,32,1)) # Here events 1 and 7 represent a particular stimulus in each polarity selectedEve = dict(up0 = 1, down0 = 7) # Epoching events of type 1 and 7 epochs = mne.Epochs(raw,eves,selectedEve,tmin = -0.05, tmax = 0.45, baseline = (-0.05, 0), reject = dict(eeg=100e-6)) # Combining both polarities so I can get envelope related FFR responses epochs = mne.epochs.combine_event_ids(epochs,['up0','down0'],dict(all0= 101)) # Getting the epoched data out, this step will also perform rejection x = epochs.get_data()
print 'Running Subject', subj
rawlist = []
evelist = []
bdfs = fnmatch.filter(os.listdir(fpath), subj + '_ABR*.bdf')
if len(bdfs) >= 1:
for k, bdf in enumerate(bdfs):
edfname = fpath + bdf
# Load data and read event channel
extrachans = [
u'GSR1', u'GSR2', u'Erg1', u'Erg2', u'Resp', u'Plet', u'Temp'
]
(rawtemp, evestemp) = bs.importbdf(edfname,
nchans=36,
extrachans=extrachans)
rawtemp.set_channel_types({'EXG3': 'eeg', 'EXG4': 'eeg'})
rawlist += [
rawtemp,
]
evelist += [
evestemp,
]
else:
RuntimeError('No BDF files found!!')
raw, eves = mne.concatenate_raws(rawlist, events_list=evelist)
# Filter the data
raw.filter(l_freq=30., h_freq=3000, picks=np.arange(36))
# These are so that the generated files are organized better
respath = fpath + 'RES/'
print 'Running Subject', subj
bdfs = fnmatch.filter(os.listdir(fpath), subj + '*.bdf')
if len(bdfs) > 1:
print '***WARNING!! Multiple files found!***'
print 'Viola! Data files found!'
edfname = bdfs[0]
# Load data and read event channel
(raw, eves) = bs.importbdf(fpath + edfname, refchans=None)
raw.info['bads'] += ['A7', 'A24', 'A28', 'EXG1', 'EXG2']
# Filter the data for ERPs
raw.filter(l_freq=0.5,
h_freq=200,
l_trans_bandwidth=0.15,
picks=np.arange(0, 32, 1))
# SSP for blinks
blinks = find_blinks(raw)
epochs_blinks = mne.Epochs(raw,
blinks,
998,
tmin=-0.25,
tmax=0.25,
proj=True,
print 'Running Subject', subj
rawlist = []
evelist = []
nruns = 6
for run in range(nruns):
bdfs = fnmatch.filter(os.listdir(fpath), subj + '_MEMR_' + ear +
'_' + str(run + 1) + '_ABR.bdf')
if len(bdfs) == 1:
edfname = fpath + bdfs[0]
# Load data and read event channel
if ear == 'right':
refchans = ['EXG2']
else:
refchans = ['EXG1', ]
(rawtemp, evestemp) = bs.importbdf(edfname, nchans=35,
refchans=refchans)
rawtemp.set_channel_types({'EXG3': 'eeg'})
rawlist += [rawtemp, ]
evelist += [evestemp, ]
else:
if len(bdfs) == 0:
pass
else:
RuntimeError('More than one bdf file for same run!!')
raw, eves = mne.concatenate_raws(rawlist, events_list=evelist)
# Filter the data
if MLR:
raw.filter(l_freq=30., h_freq=1500, picks=np.arange(35))
tmin, tmax = -0.005, 0.08
else:
respath = fpath + 'RES/'
condlist = [3, 8]
condstemlist = ['_clickpos', '_clickneg']
print 'Running Subject', subj
bdfs = fnmatch.filter(os.listdir(fpath), subj + '*ABR*.bdf')
if len(bdfs) > 1:
print 'Warning! More than 1 file found!'
else:
edfname = bdfs[0]
# Load data and read event channel
(raw, eves) = bs.importbdf(fpath + edfname, nchans=2)
# Filter the data
raw.filter(l_freq=100, h_freq=3000, picks=np.arange(0, 2, 1))
selectedEve = dict(pos=condlist[0], neg=condlist[1])
# Epoching events of type 3 and 8
epochs = mne.Epochs(raw,
eves,
selectedEve,
tmin=0.,
proj=False,
tmax=0.014,
baseline=(0., 0.002),
reject=dict(eeg=20e-6))
This is a temporary script file.
"""
import numpy as np
import scipy as sp
import mne
from anlffr.helper import biosemi2mne as bs
import pylab as pl
#raw1, events1 = bs.importbdf('C:/Users/rav28/Google Drive/Purdue Summer rotation 2017/Data/Human data/BindingEEG/SubjMS/SubjMS_Binding.bdf')
#raw2, events2 = bs.importbdf('C:/Users/rav28/Google Drive/Purdue Summer rotation 2017/Data/Human data/BindingEEG/SubjMS/SubjMS_Binding+001.bdf')
#raw1, events1 = bs.importbdf('C:/Users/rav28/Google Drive/Purdue Summer rotation 2017/Data/Human data/BindingEEG/SubjHB/SubjHB_Binding.bdf')
#raw2, events2 = bs.importbdf('C:/Users/rav28/Google Drive/Purdue Summer rotation 2017/Data/Human data/BindingEEG/SubjHB/SubjHB_Binding+001.bdf')
#raw1, events1 = bs.importbdf('C:/Users/rav28/Google Drive/Purdue Summer rotation 2017/Data/Human data/BindingEEG/SubjRS/SubjRS_Binding.bdf')
#raw2, events2 = bs.importbdf('C:/Users/rav28/Google Drive/Purdue Summer rotation 2017/Data/Human data/BindingEEG/SubjRS/SubjRS_Binding+001.bdf')
raw1, events1 = bs.importbdf(
'/media/ravinderjit/Data_Drive/EEGdata/Summer17/SubjRS_Binding.bdf')
raw2, events2 = bs.importbdf(
'/media/ravinderjit/Data_Drive/EEGdata/Summer17/SubjRS_Binding+001.bdf')
rawlist = [raw1, raw2]
eventlist = [events1, events2]
raw, eves = mne.concatenate_raws(rawlist, events_list=eventlist)
raw.filter(1.0, 150) #filter the eeg
raw._data[36, :] = raw._data[34, :] - raw._data[
35, :] #replacing an empty channel with the difference of the two eog channels to use for blink detection. This is gonna be channel EXG5
from anlffr.preproc import find_blinks
#The below line was blinks = find_blinks(raw, ch_name = ['EXG5'], thresh = 100e-6) ... changed to below on 06/12/18
blinks = find_blinks(raw,
if os.path.isfile(respath + save_raw_name) and not overwriteOld:
print 'Epoched data is already available on disk!'
print 'Loading data from:', respath + save_raw_name
x = io.loadmat(respath + save_raw_name)['x']
fs = 4096.0
else:
bdfs = fnmatch.filter(os.listdir(fpath),
subj + '_' + '*Chirp*.bdf')
print 'No pre-epoched data found, looking for BDF files'
print 'Viola!', len(bdfs), 'files found!'
for k, edfname in enumerate(bdfs):
# Load data and read event channel
(raw, eves) = bs.importbdf(fpath + edfname,
nchans=35,
refchans=['EXG1', 'EXG2'])
raw.info['bads'] += [
'EXG3', 'A1', 'A2', 'A30', 'A7', 'A6', 'A24', 'A28', 'A29',
'A3', 'A11', 'A15', 'A16', 'A17', 'A10', 'A21', 'A20',
'A25'
]
raw.drop_channels(raw.info['bads'])
# Filter the data
raw.filter(l_freq=15, h_freq=1000, picks=np.arange(0, 17, 1))
# raw.apply_proj()
fs = raw.info['sfreq']
for subj in subjlist:
fpath = froot + subj + '/'
# These are so that the generated files are organized better
respath = fpath + 'RES/'
bdfs = fnmatch.filter(os.listdir(fpath), subj + '_' + para + '.bdf')
print 'Viola!', len(bdfs), 'files found!'
if len(bdfs) > 1:
print 'Warning! Multitple raw files found! Using only the first one'
# Load data and read event channel
(raw, eves) = bs.importbdf(fpath + bdfs[0],
nchans=34,
refchans=None,
extrachans=['EXG1', 'EXG2'],
verbose='DEBUG')
# raw.info['bads'] += []
# Filter the data for ERPs
raw.filter(l_freq=0.5,
h_freq=100,
l_trans_bandwidth=0.15,
picks=np.arange(0, 32, 1))
# raw.apply_proj()
fs = raw.info['sfreq']
removeblinks = True
if removeblinks:
save_raw_name = subj + '_fmsweep_alltrial.mat'
if os.path.isfile(respath + save_raw_name) and not overwriteOld:
print 'Epoched data is already available on disk!'
print 'Loading data from:', respath + save_raw_name
x = io.loadmat(respath + save_raw_name)['x']
fs = 4096.0
else:
bdfs = fnmatch.filter(os.listdir(fpath), subj + '*EFR_fmsweep*.bdf')
print 'No pre-epoched data found, looking for BDF files'
print 'Viola!', len(bdfs), 'files found!'
for k, edfname in enumerate(bdfs):
# Load data and read event channel
(raw, eves) = bs.importbdf(fpath + edfname,
nchans=36,
refchans=['EXG1', 'EXG2'],
mask=None)
eves[:, 1] = np.mod(eves[:, 1], 256)
eves[:, 2] = np.mod(eves[:, 2], 256)
raw.set_channel_types({'EXG3': 'eeg', 'EXG4': 'eeg'})
raw.info['bads'] += [
'EXG3', 'A1', 'A2', 'A30', 'A7', 'A6', 'A24', 'A28', 'A29',
'A3', 'A11', 'A15', 'A16', 'A17', 'A10', 'A21', 'A20', 'A25',
'EXG4'
]
raw.drop_channels(raw.info['bads'])
# Filter the data
raw.filter(l_freq=130, h_freq=500)
# raw.apply_proj()
fs = raw.info['sfreq']
# -*- coding: utf-8 -*-
"""
Created on Wed Jun 14 14:43:33 2017
@author: rav28
"""
import mne
from anlffr.helper import biosemi2mne as bs
raw, eves = bs.importbdf('D:/DATA/BindingEEG/SubjMS/SubjMS_Binding.bdf')
from anlffr.preproc import find_blinks
blinks = find_blinks(raw)
scalings = dict(mag=1e-12,
grad=4e-11,
eeg=20e-6,
eog=150e-6,
ecg=5e-4,
emg=1e-3,
ref_meg=1e-12,
misc=1e-3,
stim=1,
resp=1,
chpi=1e-4)
scalings['eeg'] = 40e-6
scalings['misc'] = 150e-6
raw.plot(events=blinks, scalings=scalings)
from mne.preprocessing.ssp import compute_proj_epochs
# -*- coding: utf-8 -*-
"""
Created on Wed Jul 26 13:47:23 2017
@author: rav28
"""
import numpy as np
import scipy as sp
import mne
from anlffr.helper import biosemi2mne as bs
import pylab as pl
rawHB_1, eventsHB_1 = bs.importbdf(
'C:/Users/rav28/Google Drive/Purdue Summer rotation 2017/Data/Human data/BindingEEG/SubjHB/SubjHB_BindingBehavioral.bdf',
mask=None) #making mask none changes event numbers
rawHB_2, eventsHB_2 = bs.importbdf(
'C:/Users/rav28/Google Drive/Purdue Summer rotation 2017/Data/Human data/BindingEEG/SubjHB/SubjHB_BindingBehavioral+001.bdf',
mask=None)
#raw1, events1 = bs.importbdf('C:/Users/rav28/Google Drive/Purdue Summer rotation 2017/Data/Human data/BindingEEG/SubjJP/SubjJP_BindingBehavioral.bdf', mask=None) #making mask none changes event numbers
#raw2, events2 = bs.importbdf('C:/Users/rav28/Google Drive/Purdue Summer rotation 2017/Data/Human data/BindingEEG/SubjJP/SubjJP_BindingBehavioral+001.bdf', mask=None)
rawRS_1, eventsRS_1 = bs.importbdf(
'C:/Users/rav28/Google Drive/Purdue Summer rotation 2017/Data/Human data/BindingEEG/SubjRS/SubjRS_BindingBehavioral.bdf',
mask=None) #making mask none changes event numbers
rawRS_2, eventsRS_2 = bs.importbdf(
'C:/Users/rav28/Google Drive/Purdue Summer rotation 2017/Data/Human data/BindingEEG/SubjRS/SubjRS_BindingBehavioral+001.bdf',
mask=None)
rawRS_3, eventsRS_3 = bs.importbdf(
'C:/Users/rav28/Google Drive/Purdue Summer rotation 2017/Data/Human data/BindingEEG/SubjRS/SubjRS_BindingBehavioral+002.bdf',
mask=None)
#if Mask is none: events 1:4 = 65281-84, button presses are 65280
u'B23', u'B24', u'B25', u'B26', u'B27', u'B28', u'B29',
u'B30', u'B31', u'B32', u'C1', u'C2', u'C3', u'C4', u'C5',
u'C6', u'C7', u'C8', u'C9', u'C10', u'C11', u'C12', u'C13',
u'C14', u'C15', u'C16', u'C17', u'C18', u'C19', u'C20',
u'C21', u'C22', u'C23', u'C24', u'C25', u'C26', u'C27',
u'C28', u'C29', u'C30', u'C31', u'C32', u'D1', u'D2',
u'D3', u'D4', u'D5', u'D6', u'D7', u'D8', u'D9', u'D10',
u'D11', u'D12', u'D13', u'D14', u'D15', u'D16', u'D17',
u'D18', u'D19', u'D20', u'D21', u'D22', u'D23', u'D24',
u'D25', u'D26', u'D27', u'D28', u'D29', u'D30', u'D31',
u'D32']
else:
exclude = []
for k, rawname in enumerate(bdfs):
rawtemp, evestemp = bs.importbdf(fpath + rawname, verbose='DEBUG',
refchans=None, exclude=exclude)
rawlist += [rawtemp, ]
evelist += [evestemp, ]
raw, eves = mne.concatenate_raws(rawlist, events_list=evelist)
# raw.set_channel_types({'EXG3': 'eeg', 'EXG4': 'eeg'})
raw.info['bads'] += []
# Filter the data
raw.filter(l_freq=1.5, h_freq=40.)
removeblinks = True
if removeblinks:
# SSP for blinks
blinks = find_blinks(raw, ch_name=['A1', ], l_trans_bandwidth=0.4)
# Adding Files and locations
fpath = '/home/hari/Documents/MNEforBiosemi/'
# List of files stems, each will be appended by run number
# Use list [] and enumerate over if filenames are weird
namestem = 'I13_depth'
nruns = 5 # Number of files
for k in np.arange(0,nruns):
# Load data and read event channel
# You'll need to modify it based on your file naming convention:
edfname = fpath + namestem + '_0' + str(k+1) + '.bdf'
(raw,eves) = bs.importbdf(edfname)
# Filter the data
raw.filter(l_freq = 70, h_freq = 1500, picks = np.arange(0,32,1))
# Here events 1 and 7 represent a particular stimulus in each polarity
selectedEve = dict(up0 = 1, down0 = 7)
# Epoching events of type 1 and 7
epochs = mne.Epochs(raw,eves,selectedEve,tmin = -0.05,
tmax = 0.45, baseline = (-0.05, 0), reject = dict(eeg=100e-6))
# Combining both polarities so I can get envelope related FFR responses
epochs = mne.epochs.combine_event_ids(epochs,['up0','down0'],dict(all0= 101))
# Getting the epoched data out, this step will also perform rejection
saveAve = False
for subj in subjlist:
fpath = froot + subj + '/'
# These are so that the generated files are organized better
respath = fpath + 'RES/'
bdfs = fnmatch.filter(os.listdir(fpath), subj + '_' + para + '*.bdf')
print 'Viola!', len(bdfs), 'files found!'
# Load data and read event channel
rawlist = []
evelist = []
for k, rawname in enumerate(bdfs):
rawtemp, evestemp = bs.importbdf(fpath + rawname, verbose='DEBUG')
rawlist += [
rawtemp,
]
evelist += [
evestemp,
]
raw, eves = mne.concatenate_raws(rawlist, events_list=evelist)
# raw.info['bads'] += []
# Filter the data for ERPs
raw.filter(l_freq=2.0, h_freq=40, l_trans_bandwidth=0.15)
# raw.apply_proj()
fs = raw.info['sfreq']
removeblinks = True
'figOut':'\Users\racqu\Documents\Research\Purdue\Human Data\Figs\\'} # define directories
read_data_params = {
'refchans': ['EXG1', 'EXG2'],
'exclude': ['EXG3', 'EXG4', 'EXG5', 'EXG6', 'EXG7', 'EXG8']
}
if not op.isdir(dir_dict['figOut']):
mkdir(dir_dict['figOut'])
allFiles = glob(dir_dict['dataIn'] + '*.bdf')
plotYes = True
# Loop through directories
for fileVar in allFiles:
print('Working on ->' + fileVar)
raw, eves = bs.importbdf(fileVar,
refchans=read_data_params['refchans'],
exclude=read_data_params['exclude'])
# raw= mne.io.read_raw_edf(fileVar)
# raw.load_data()
# eves= mne.find_events(raw, shortest_event=1, mask=255)
raw.filter(70, 1e3, phase='zero')
epochs = mne.Epochs(raw,
eves,
1,
tmin=-0.1,
proj=False,
tmax=1.2,
baseline=(-0.1, 0.0),
reject=dict(eeg=200e-6))
evoked = epochs.average()
params = dict(Fs=raw.info['sfreq'], tapers=[1, 1], fpass=[70, 1000], itc=0)
for ind, cond in enumerate(conds):
name = names[ind]
print 'Doing condition ', cond
fpath = froot + '/' + subj + '/'
bdfs = fnmatch.filter(os.listdir(fpath), subj + '_ABR*.bdf')
if len(bdfs) >= 1:
for k, bdf in enumerate(bdfs):
edfname = fpath + bdf
# Load data and read event channel
extrachans = [
u'GSR1', u'GSR2', u'Erg1', u'Erg2', u'Resp', u'Plet',
u'Temp'
]
raw, eves = bs.importbdf(edfname,
nchans=36,
extrachans=extrachans)
raw.set_channel_types({'EXG3': 'eeg', 'EXG4': 'eeg'})
# Pick channels to not include in epoch rejection
raw.info['bads'] += [
'EXG3', 'EXG4', 'A1', 'A2', 'A30', 'A7', 'A6', 'A24',
'A28', 'A29', 'A3', 'A11', 'A15', 'A16', 'A17', 'A10',
'A21', 'A20', 'A25'
]
# Filter the data
raw.filter(l_freq=130., h_freq=3000, picks=np.arange(36))
# Epoch the data
tmin, tmax = -0.002, 0.015
bmin, bmax = -0.001, 0.001
print 'Epoched data is already available on disk!'
print 'Loading data from:', respath + save_raw_name
dat = io.loadmat(respath + save_raw_name)
Fs = dat['Fs'][0, 0]
x = dat['x']
times = dat['times'].squeeze()
else:
preEpoched = False
bdfs = fnmatch.filter(os.listdir(fpath), subj + '*.bdf')
print 'No pre-epoched data found, looking for BDF files'
print 'Viola!', len(bdfs), 'files found!'
for k, edfname in enumerate(bdfs):
# Load data and read event channel
(raw, eves) = bs.importbdf(fpath + edfname,
nchans=nchans,
refchans=['EXG1', 'EXG2'],
verbose='DEBUG')
raw.info['bads'] += [
'EXG3',
]
# Filter the data for ERPs
raw.filter(l_freq=0.5,
h_freq=500,
l_trans_bandwidth=0.15,
picks=np.arange(0, 32, 1))
# raw.apply_proj()
fs = raw.info['sfreq']
# SSP for blinks
blinks = find_blinks(raw)
def processing(stimulus, subj, fpath):
# load data and read event channels
rawlist = []
evelist = []
# extracting bdf filenames into bdfs
if stimulus == 'ITD':
bdfs = fnmatch.filter(os.listdir(fpath), subj + '_ITD*.bdf')
elif stimulus == 'Atten':
bdfs = fnmatch.filter(os.listdir(fpath), subj + '_Atten*.bdf')
if len(bdfs) >= 1:
for k, bdf in enumerate(bdfs):
rawtemp, evestemp = bs.importbdf(fpath + bdf)
rawlist += [rawtemp,]
evelist += [evestemp,]
else:
RuntimeError("No bdf files found!")
# the returned eves has three columns: sample number, value of onset, value of offset.
raw, eves = mne.concatenate_raws(rawlist, events_list = evelist)
# Things to try if data are too noisy
# raw.info['bads'] += ['A7', 'A6', 'A24'] # if A7, A6, A24 have been rejected a lot, they can be added manually
# raw.set_eeg_reference(ref_channels=['Average']) # referencing to the average of all channels, do this if channels are too noisy
eves2 = eves.copy()
# the eves are in 16 bits originally, so this operation only looks at the lower 8 bits. higher 8 bits are always
# high, representing button box condition. If interested in what's happening at button press, do np.floor(eves2[:,1]/256)
eves2[:, 1] = np.mod(eves2[:, 1], 256)
eves2[:, 2] = np.mod(eves2[:, 2], 256)
if stimulus == 'ITD' or stimulus == 'Atten':
raw.filter(l_freq = 1, h_freq=50) # if channels are noisy, adjust the filter parameters
# raw.plot(events=eves2)
# SSP for blinks
blinks = find_blinks(raw, ch_name = ['A1',], l_trans_bandwidth=0.5,
l_freq=1.0) # A1 is the closest electrode to eyebrow
# blink and eves2 triggers can be combined using np.concatenate((eves2, blinks), axis = 0)
# raw.plot(events=blinks) shows the lines at eye blinks
# the trigger for blinks can be chosen to be starting from 1000, just to make sure it doesn't collide with the triggers for conditions
epochs_blinks = mne.Epochs(raw, blinks, 998, tmin = -0.25, tmax = 0.25,
proj = False, baseline = (-0.25, 0),
reject=dict(eeg=500e-6))
# evoked_blinks = epochs_blinks.average()
# evoked_blinks_data = evoked_blinks.data[np.arange(32),:]
# PCA is only applied to the epochs around eye blinks. Since the eye blinks are
# contributing the most to the variance within this chunk of window,
# the first PCA (first eigenvector) is going to be due to the eye blink
# for sure and removed. If the PCA was performed on the whole samples, we wouldn't
# know which vector is going to be linked to the eye blink
# for "n_eeg", it's recommended to remove only the biggest projection, which is eye blinks in this case
# greater n_eeg removes more nueral data, which is not favorable
n_eeg = 4
blink_projs = compute_proj_epochs(epochs_blinks, n_grad=0,
n_mag=0, n_eeg=n_eeg,
verbose='DEBUG')
projN = np.zeros(2)
if subj in ['S025', 'S031', 'S046', 'S117', 'S123', 'S127', 'S128', 'S132', 'S133', 'S143', 'S149', 'S051', 'S183', 'S185', 'S187', 'S189', 'S193', 'S195', 'S196', 'S043', 'S072', 'S075', 'S078', 'S191', 'S129', 'S141', 'S190', 'S021', 'S024', 'S028', 'S083', 'S119', 'S121', 'S122', 'S139', 'S140', 'S142', 'S144', 'S145']:
#raw.add_proj(blink_projs) # adding all projections
raw.add_proj([blink_projs[0], blink_projs[2]]) # raw.del_proj()
projN = [1, 3]
elif subj in ['S135', 'S192', 'S194', 'S197', 'S199', 'S216', 'S218']:
raw.add_proj([blink_projs[0], blink_projs[1]]) # raw.del_proj()
projN = [1, 2]
elif subj in ['S084']:
raw.add_proj([blink_projs[0]]) # raw.del_proj()
projN = [1, 0]
# raw.plot_projs_topomap() shows the 4 max PCAs (eigenvectors)
# raw.plot(events = blinks, show_options = True) could show the options for applying different projections
# if channels are too noisy, play with n_eeg, if the second variance is acting more than
# the first, that means the channels are contaminated not just by the eye blinks, but also
# from other sources
# MANUALLY SELECT PROJECTIONS BY PLOTTING raw.plot_projs_topomap
# REMOVE EXTRA PROJS USING raw.del_proj -- Remember index starts at 0
return raw, eves2, projN
# These are so that the generated files are organized better
respath = fpath + 'RES/'
print 'Running Subject', subj
bdfs = fnmatch.filter(os.listdir(fpath), subj + '*.bdf')
if len(bdfs) > 1:
print '***WARNING!! Multiple files found! Cannot continue!***'
else:
print 'Viola! Data files found!'
edfname = bdfs[0]
# Load data and read event channel
(raw, eves) = bs.importbdf(fpath + edfname)
# Filter the data for ERPs
raw.filter(l_freq=0.5,
h_freq=200,
l_trans_bandwidth=0.15,
picks=np.arange(0, 32, 1))
#raw.apply_function(detrend, picks=np.arange(0, 32, 1), dtype=None,
# n_jobs=1, verbose=True)
# SSP for blinks
blinks = find_blinks(raw)
epochs_blinks = mne.Epochs(raw,
blinks,
998,
tmin=-0.25,
froot = 'D:/DATA/Saccade/'
subj = 'BM'
fpath = froot + subj + '/'
print 'Running Subject', subj
bdfs = fnmatch.filter(os.listdir(fpath), subj +
'*saccade*.bdf')
print 'Viola!', len(bdfs), 'files found!'
bdf = bdfs[-1] # Use only the last one
# Load data and read event channel
raw, eves = bs.importbdf(fpath + bdf, nchans=34, exclude=[],
refchans=['EXG2'])
# Filter the data
raw.filter(l_freq=0., h_freq=40., method='fir')
scalings = dict(eeg=150e-6)
# raw.plot(events=eves, scalings=scalings)
# Make new event number for PL, PR, AL, AR respectively
eves2 = eves.copy()
for k, trig in enumerate(eves[:, 2]):
if trig == 1:
eves2[k + 1, 2] += 10
if trig == 2:
eves2[k + 1, 2] += 20
# -*- coding: utf-8 -*-
"""
Spyder Editor
This is a temporary script file.
"""
import numpy as np
import scipy as sp
import mne
from anlffr.helper import biosemi2mne as bs
import pylab as pl
raw1, events1 = bs.importbdf(
'C:/Users/rav28/Google Drive/Purdue Summer rotation 2017/Data/Human data/BindingEEG/SubjMS/SubjMS_Binding.bdf'
)
raw2, events2 = bs.importbdf(
'C:/Users/rav28/Google Drive/Purdue Summer rotation 2017/Data/Human data/BindingEEG/SubjMS/SubjMS_Binding+001.bdf'
)
#raw1, events1 = bs.importbdf('C:/Users/rav28/Google Drive/Purdue Summer rotation 2017/Data/Human data/BindingEEG/SubjHB/SubjHB_Binding.bdf')
#raw2, events2 = bs.importbdf('C:/Users/rav28/Google Drive/Purdue Summer rotation 2017/Data/Human data/BindingEEG/SubjHB/SubjHB_Binding+001.bdf')
rawlist = [raw1, raw2]
eventlist = [events1, events2]
raw, eves = mne.concatenate_raws(rawlist, events_list=eventlist)
raw.filter(1.0, 40) #filter the eeg
raw._data[36, :] = raw._data[34, :] - raw._data[
35, :] #replacing an empty channel with the difference of the two eog channels to use for blink detection. This is gonna be channel EXG5
from anlffr.preproc import find_blinks
for subj in subjlist:
fpath = froot + '/' + subj + '/'
print 'Running Subject', subj
rawlist = []
evelist = []
bdfs = fnmatch.filter(os.listdir(fpath), subj + '_ABR*.bdf')
if len(bdfs) >= 1:
for k, bdf in enumerate(bdfs):
edfname = fpath + bdf
(rawtemp, evestemp) = bs.importbdf(edfname,
nchans=36,
refchans=['EXG1', 'EXG2'])
rawtemp.set_channel_types({'EXG3': 'eeg', 'EXG4': 'eeg'})
rawlist += [
rawtemp,
]
evelist += [
evestemp,
]
else:
RuntimeError('No BDF files found!!')
raw, eves = mne.concatenate_raws(rawlist, events_list=evelist)
# Filter the data
raw.filter(l_freq=0.5, h_freq=3000, picks=np.arange(36), method='iir')
