def apply_norm(fn_stc, event, thr=95):
fn_list = get_files_from_list(fn_stc)
for fname in fn_list:
fn_path = os.path.split(fname)[0]
stc = mne.read_source_estimate(fname)
name = os.path.basename(fname)
subject = name.split('_')[0]
fn_base = fn_path + '/%s_%s_baseline-lh.stc' %(subject,event)
stc = mne.read_source_estimate(fname)
stc_base = mne.read_source_estimate(fn_base)
thre = np.percentile(stc_base.data, thr, axis=-1)
data = stc.data
cal_mean = data.mean(axis=-1)
norm_data = (data.T / thre) - 1
norm_data[norm_data < 0] = 0
norm_data = norm_data.T
norm_data[cal_mean == 0, :] = 0
norm_mean = norm_data.mean(axis=-1)
zc_data = norm_data.T/norm_data.max(axis=-1)
zc_data = zc_data.T
zc_data[norm_mean == 0, :] = 0
#import pdb
#pdb.set_trace()
#print zc_data.min()
stc.data.setfield(zc_data, np.float32)
fn_nr = fname[:fname.rfind('-lh')] + '_norm_1'
stc.save(fn_nr, ftype='stc')
def apply_STC_epo(fnepo, event, method='MNE', snr=1.0, min_subject='fsaverage',
subjects_dir=None):
from mne import morph_data
from mne.minimum_norm import read_inverse_operator, apply_inverse_epochs
fnlist = get_files_from_list(fnepo)
# loop across all filenames
for fname in fnlist:
fn_path = os.path.split(fname)[0]
name = os.path.basename(fname)
subject = name.split('_')[0]
min_dir = subjects_dir + '/%s' %min_subject
snr = snr
lambda2 = 1.0 / snr ** 2
stcs_path = min_dir + '/stcs/%s/%s/' % (subject,event)
reset_directory(stcs_path)
# fn_inv = fname[:fname.rfind('-ave.fif')] + ',ave-inv.fif'
fn_inv = fn_path + '/%s_epo-inv.fif' %subject
# noise_cov = mne.read_cov(fn_cov)
epo = mne.read_epochs(fname)
epo.pick_types(meg=True, ref_meg=False)
inv = read_inverse_operator(fn_inv)
stcs = apply_inverse_epochs(epo, inv, lambda2, method,
pick_ori='normal')
s = 0
while s < len(stcs):
stc_morph = morph_data(subject, min_subject, stcs[s])
stc_morph.save(stcs_path + '/trial%s_fsaverage'
% (str(s)), ftype='stc')
s = s + 1
def apply_STC_ave(fnevo, method='dSPM', snr=3.0):
''' Inverse evoked data into the source space.
Parameter
---------
fnevo: string or list
The evoked file with ECG, EOG and environmental noise free.
method:string
Inverse method, 'MNE' or 'dSPM'
snr: float
Signal to noise ratio for inverse solution.
'''
#Get the default subjects_dir
from mne.minimum_norm import apply_inverse, read_inverse_operator
fnlist = get_files_from_list(fnevo)
# loop across all filenames
for fname in fnlist:
name = os.path.basename(fname)
fn_path = os.path.split(fname)[0]
fn_stc = fname[:fname.rfind('-ave.fif')]
# fn_inv = fname[:fname.rfind('-ave.fif')] + ',ave-inv.fif'
subject = name.split('_')[0]
fn_inv = fn_path + '/%s_fibp1-45,ave-inv.fif' % subject
snr = snr
lambda2 = 1.0 / snr ** 2
# noise_cov = mne.read_cov(fn_cov)
[evoked] = mne.read_evokeds(fname)
evoked.pick_types(meg=True, ref_meg=False)
inv = read_inverse_operator(fn_inv)
stc = apply_inverse(evoked, inv, lambda2, method,
pick_ori='normal')
stc.save(fn_stc)
def apply_inverse_ave(fnevo, min_subject='fsaverage'):
from mne import make_forward_solution
from mne.minimum_norm import write_inverse_operator
fnlist = get_files_from_list(fnevo)
# loop across all filenames
for fname in fnlist:
fn_path = os.path.split(fname)[0]
name = os.path.basename(fname)
#fn_inv = fname[:fname.rfind('-ave.fif')] + ',ave-inv.fif'
subject = name.split('_')[0]
fn_inv = fn_path + '/%s_fibp1-45,ave-inv.fif' %subject
subject_path = subjects_dir + '/%s' %subject
#min_dir = subjects_dir + '/%s' %min_subject
fn_trans = fn_path + '/%s-trans.fif' % subject
#fn_cov = fn_path + '/%s_empty,nr,fibp1-45-cov.fif' % subject
fn_cov = fn_path + '/%s_empty,fibp1-45-cov.fif' %subject
fn_src = subject_path + '/bem/%s-oct-6-src.fif' % subject
fn_bem = subject_path + '/bem/%s-5120-5120-5120-bem-sol.fif' % subject
[evoked] = mne.read_evokeds(fname)
evoked.pick_types(meg=True, ref_meg=False)
noise_cov = mne.read_cov(fn_cov)
#noise_cov = mne.cov.regularize(noise_cov, evoked.info,
# mag=0.05, grad=0.05, proj=True)
fwd = make_forward_solution(evoked.info, fn_trans, fn_src, fn_bem)
fwd['surf_ori'] = True
inv = mne.minimum_norm.make_inverse_operator(evoked.info, fwd, noise_cov, loose=0.2,
depth=0.8, limit_depth_chs=False)
write_inverse_operator(fn_inv, inv)
def apply_STC_ave(fnevo, method='dSPM', snr=3.0):
''' Inverse evoked data into the source space.
Parameter
---------
fnevo: string or list
The evoked file with ECG, EOG and environmental noise free.
method:string
Inverse method, 'dSPM' or 'mne'
snr: float
Signal to noise ratio for inverse solution.
'''
#Get the default subjects_dir
from mne.minimum_norm import apply_inverse, read_inverse_operator
fnlist = get_files_from_list(fnevo)
# loop across all filenames
for fname in fnlist:
name = os.path.basename(fname)
fn_path = os.path.split(fname)[0]
fn_stc = fname[:fname.rfind('-ave.fif')]
# fn_inv = fname[:fname.rfind('-ave.fif')] + ',ave-inv.fif'
subject = name.split('_')[0]
fn_inv = fn_path + '/%s_fibp1-45,ave-inv.fif' % subject
snr = snr
lambda2 = 1.0 / snr**2
# noise_cov = mne.read_cov(fn_cov)
[evoked] = mne.read_evokeds(fname)
evoked.pick_types(meg=True, ref_meg=False)
inv = read_inverse_operator(fn_inv)
stc = apply_inverse(evoked, inv, lambda2, method, pick_ori='normal')
stc.save(fn_stc)
def sig_thresh(cau_list, freqs, per=99.99, sfreq=678):
'''
Evaluate the significance for each pair's causal interactions.
Parameter
---------
cau_list: string
The file path of causality matrices.
freqs: list
The list of interest frequency bands.
sfreq: float
The sampling rate.
per: float or int
Percentile of the surrogates.
'''
path_list = get_files_from_list(cau_list)
# loop across all filenames
for fncau in path_list:
fnsurr = fncau[:fncau.rfind(',cau.npy')] + ',surrcau.npy'
cau_path = os.path.split(fncau)[0]
name = os.path.basename(fncau)
condition = name.split('_')[0]
sig_path = cau_path + '/sig_cau/'
set_directory(sig_path)
cau = np.load(fncau)
surr = np.load(fnsurr)
nfft = cau.shape[-1]
delta_F = sfreq / float(2 * nfft)
# freqs = [(4, 8), (8, 12), (12, 18), (18, 30), (30, 70), (60, 90)]
sig_freqs = []
nfreq = len(freqs)
for ifreq in range(nfreq):
fmin, fmax = int(freqs[ifreq][0] / delta_F), int(freqs[ifreq][1] /
delta_F)
con_band = np.mean(cau[:, :, fmin:fmax + 1], axis=-1)
np.fill_diagonal(con_band, 0)
surr_band = np.mean(surr[:, :, :, fmin:fmax + 1], axis=-1)
r, s, _ = surr_band.shape
for i in xrange(r):
ts = surr_band[i]
np.fill_diagonal(ts, 0)
con_b = con_band.flatten()
con_b = con_b[con_b > 0]
surr_b = surr_band.reshape(r, s * s)
surr_b = surr_b[surr_b > 0]
thr = np.percentile(surr_band, per)
print 'max surrogates %.4f' % thr
con_band[con_band < thr] = 0
con_band[con_band >= thr] = 1
histout = sig_path + '%s,%d-%d,distribution.png'\
% (condition, freqs[ifreq][0], freqs[ifreq][1])
throut = sig_path + '%s,%d-%d,threshold.png'\
% (condition, freqs[ifreq][0], freqs[ifreq][1])
_plot_hist(con_b, surr_b, histout)
#_plot_thr(con_b, thr, surr_band.max(), alpha, throut)
_plot_thr(con_b, thr, surr_band.max(), per, throut)
con_band[con_band < thr] = 0
con_band[con_band >= thr] = 1
sig_freqs.append(con_band)
sig_freqs = np.array(sig_freqs)
np.save(sig_path + '%s_sig_con_band.npy' %condition, sig_freqs)
def apply_inverse(fnevo, method='dSPM', snr=3.0, event='LLst',
baseline=False, btmin=-0.3, btmax=-0.1, min_subject='fsaverage'):
'''
Parameter
---------
fnevo: string or list
The evoked file with ECG, EOG and environmental noise free.
method: inverse method, 'MNE' or 'dSPM'
event: string
The event name related with epochs.
min_subject: string
The subject name as the common brain.
snr: signal to noise ratio for inverse solution.
'''
#Get the default subjects_dir
from mne.minimum_norm import apply_inverse
fnlist = get_files_from_list(fnevo)
# loop across all filenames
for fname in fnlist:
fn_path = os.path.split(fname)[0]
name = os.path.basename(fname)
stc_name = name[:name.rfind('-ave.fif')]
subject = name.split('_')[0]
subject_path = subjects_dir + '/%s' %subject
min_dir = subjects_dir + '/%s' %min_subject
fn_trans = fn_path + '/%s-trans.fif' % subject
fn_cov = fn_path + '/%s_empty,nr-cov.fif' % subject
fn_src = subject_path + '/bem/%s-ico-5-src.fif' % subject
fn_bem = subject_path + '/bem/%s-5120-5120-5120-bem-sol.fif' % subject
snr = snr
lambda2 = 1.0 / snr ** 2
#noise_cov = mne.read_cov(fn_cov)
[evoked] = mne.read_evokeds(fname)
noise_cov = mne.read_cov(fn_cov)
# this path used for ROI definition
stc_path = min_dir + '/%s_ROIs/%s' %(method,subject)
#fn_cov = meg_path + '/%s_empty,fibp1-45,nr-cov.fif' % subject
set_directory(stc_path)
noise_cov = mne.cov.regularize(noise_cov, evoked.info,
mag=0.05, grad=0.05, proj=True)
fwd_ev = mne.make_forward_solution(evoked.info, trans=fn_trans,
src=fn_src, bem=fn_bem,
fname=None, meg=True, eeg=False,
mindist=5.0, n_jobs=2,
overwrite=True)
fwd_ev = mne.convert_forward_solution(fwd_ev, surf_ori=True)
forward_meg_ev = mne.pick_types_forward(fwd_ev, meg=True, eeg=False)
inverse_operator_ev = mne.minimum_norm.make_inverse_operator(
evoked.info, forward_meg_ev, noise_cov,
loose=0.2, depth=0.8)
# Compute inverse solution
stc = apply_inverse(evoked, inverse_operator_ev, lambda2, method,
pick_ori=None)
# Morph STC
stc_morph = mne.morph_data(subject, min_subject, stc, grade=5, smooth=5)
stc_morph.save(stc_path + '/%s' % (stc_name), ftype='stc')
if baseline == True:
stc_base = stc_morph.crop(btmin, btmax)
stc_base.save(stc_path + '/%s_%s_baseline' % (subject, event), ftype='stc')
def apply_STCs(fnstcs, method='dSPM', event='LLst', min_subject='fsaverage', STC_US='ROI',
snr=5.0):
subjects_dir = os.environ['SUBJECTS_DIR']
fnlist = get_files_from_list(fnstcs)
# loop across all filenames
stcs = []
for fname in fnlist:
def apply_rois(fn_stc_list, event, min_subject='fsaverage', thr=0.85):
"""
Compute regions of interest (ROI) based on events
----------
fn_stc : string
evoked and morphed STC.
event: string
event of the related STC.
tmin, tmax: float
segment for ROIs definition.
min_subject: string
the subject as the common brain space.
thr: float or int
threshold of STC used for ROI identification.
"""
#from scipy.signal import detrend
#from scipy.stats.mstats import zscore
fnlist = get_files_from_list(fn_stc_list)
# loop across all filenames
for fn_stc in fnlist:
# extract the subject infromation from the file name
stc_path = os.path.split(fn_stc)[0]
min_path = subjects_dir + '/%s' % min_subject
fn_src = min_path + '/bem/fsaverage-ico-5-src.fif'
# Make sure the target path is exist
labels_path = stc_path + '/%s/ini' %event
reset_directory(labels_path)
# Read the MNI source space
stc = mne.read_source_estimate(fn_stc)
src_inv = mne.read_source_spaces(fn_src)
stc.lh_data[stc.lh_data < 0.85 * np.max(stc.lh_data)] = 0
stc.rh_data[stc.rh_data < 0.8 * np.max(stc.rh_data)] = 0
#data_lh=np.squeeze(stc.lh_data)
#index_lh = np.argwhere(data_lh)
#stc.lh_data[data_lh<np.percentile(data_lh[index_lh], thr)] = 0
#data_rh=np.squeeze(stc.rh_data)
#index_rh = np.argwhere(data_rh)
#stc.rh_data[data_rh<np.percentile(data_rh[index_rh], thr)] = 0
#non_index = np.argwhere(data)
#stc.data[data<np.percentile(data[non_index], thr)] = 0
func_labels_lh, func_labels_rh = mne.stc_to_label(
stc, src=src_inv, smooth=True,
subjects_dir=subjects_dir,
connected=True)
# Left hemisphere definition
i = 0
while i < len(func_labels_lh):
func_label = func_labels_lh[i]
func_label.save(labels_path + '/%s_%d' %(event, i))
i = i + 1
# right hemisphere definition
j = 0
while j < len(func_labels_rh):
func_label = func_labels_rh[j]
func_label.save(labels_path + '/%s_%d' %(event, j))
j = j + 1
def apply_rois(fn_stc, event, tmin=0.0, tmax=0.3, min_subject='fsaverage', thr=99):
"""
Compute regions of interest (ROI) based on events
----------
fn_stc : string
evoked and morphed STC.
event: string
event of the related STC.
tmin, tmax: float
segment for ROIs definition.
min_subject: string
the subject as the common brain space.
thr: float or int
threshold of STC used for ROI identification.
"""
fnlist = get_files_from_list(fn_stc)
# loop across all filenames
for ifn_stc in fnlist:
subjects_dir = os.environ['SUBJECTS_DIR']
# extract the subject infromation from the file name
stc_path = os.path.split(ifn_stc)[0]
#name = os.path.basename(fn_stc)
#tri = name.split('_')[1].split('-')[0]
min_path = subjects_dir + '/%s' % min_subject
fn_src = min_path + '/bem/fsaverage-ico-4-src.fif'
# Make sure the target path is exist
labels_path = stc_path + '/%s/' %event
reset_directory(labels_path)
# Read the MNI source space
src_inv = mne.read_source_spaces(fn_src)
stc = mne.read_source_estimate(ifn_stc, subject=min_subject)
bc_stc = stc.copy().crop(tmin, tmax)
src_pow = np.sum(bc_stc.data ** 2, axis=1)
bc_stc.data[src_pow < np.percentile(src_pow, thr)] = 0.
#stc_data = stc_morph.data
#import pdb
#pdb.set_trace()
#zscore stc for ROIs estimation
#d_mu = stc_data.mean(axis=1, keepdims=True)
#d_std = stc_data.std(axis=1, ddof=1, keepdims=True)
#z_data = (stc_data - d_mu)/d_std
func_labels_lh, func_labels_rh = mne.stc_to_label(
bc_stc, src=src_inv, smooth=True,
subjects_dir=subjects_dir,
connected=True)
# Left hemisphere definition
i = 0
while i < len(func_labels_lh):
func_label = func_labels_lh[i]
func_label.save(labels_path + '%s_%s' % (event, str(i)))
i = i + 1
# right hemisphere definition
j = 0
while j < len(func_labels_rh):
func_label = func_labels_rh[j]
func_label.save(labels_path + '%s_%s' % (event, str(j)))
j = j + 1
def model_estimation(fn_norm, thr_cons=0.8, whit_min=1., whit_max=3.,
morder=None):
'''
Check the statistical evalutions of the MVAR model corresponding the
optimized morder.
Reference
---------
Granger Causal Connectivity Analysis: A MATLAB Toolbox, Anil K. Seth
(2009)
Parameters
----------
fn_norm: string
The file name of model order estimation.
thr_cons:float
The threshold of consistency evaluation.
whit_min:float
The lower limit for whiteness evaluation.
whit_max:float
The upper limit for whiteness evaluation.
p: int
Optimized model order.
'''
import scot
path_list = get_files_from_list(fn_norm)
# loop across all filenames
print '>>> Model order is %d....' % morder
for fnnorm in path_list:
fneval = fnnorm[:fnnorm.rfind('.npy')] + '_evaluation.txt'
# npz = np.load(fnnorm)
# if morder == None:
# morder = npz['morder'].flatten()[0]
X = np.load(fnnorm)
# X = npz['X']
A, SIG, E = _tsdata_to_var(X, morder)
whi = False
dw, pval = _whiteness(X, E)
if np.all(dw < whit_max) and np.all(dw > whit_min):
whi = True
#if np.all(pval < 0.05):
# whi = True
cons = _consistency(X, E)
X = X.transpose(2, 0, 1)
#morder = model_order(fnnorm, p_max=50)
mvar = scot.var.VAR(morder)
mvar.fit(X)
is_st = mvar.is_stable()
#is_st = is_stable(mvar)
#import pdb
#pdb.set_trace()
if cons < thr_cons or is_st == False or whi == False:
print fnnorm
# assert cons > thr_cons and is_st and whi, ('Consistency, whiteness, stability:\
# %f, %s, %s' %(cons, str(whi), str(is_st)))
with open(fneval, "a") as f:
f.write('model_order, whiteness, consistency, stability: %d, %s, %f, %s\n'
% (morder, str(whi), cons, str(is_st)))
def apply_create_noise_covariance(fname_empty_room, verbose=None):
'''
Creates the noise covariance matrix from an empty room file.
Parameters
----------
fname_empty_room : String containing the filename
of the de-noise, empty room file (must be a fif-file)
require_filter: bool
If true, the empy room file is filtered before calculating
the covariance matrix. (Beware, filter settings are fixed.)
verbose : bool, str, int, or None
If not None, override default verbose level
(see mne.verbose).
default: verbose=None
'''
# -------------------------------------------
# import necessary modules
# -------------------------------------------
from mne import compute_raw_data_covariance as cp_covariance
from mne import write_cov, pick_types
from mne.io import Raw
from jumeg.jumeg_noise_reducer import noise_reducer
fner = get_files_from_list(fname_empty_room)
nfiles = len(fner)
ext_empty_raw = '-raw.fif'
ext_empty_cov = '-cov.fif'
# loop across all filenames
for ifile in range(nfiles):
fn_in = fner[ifile]
print ">>> create noise covariance using file: "
path_in, name = os.path.split(fn_in)
print name
fn_empty_nr = fn_in[:fn_in.rfind('-raw.fif')] + ',nr-raw.fif'
noise_reducer(fn_in, refnotch=50, detrending=False, fnout=fn_empty_nr)
noise_reducer(fn_empty_nr, refnotch=60, detrending=False, fnout=fn_empty_nr)
noise_reducer(fn_empty_nr, reflp=5, fnout=fn_empty_nr)
# file name for saving noise_cov
fn_out = fn_empty_nr[:fn_empty_nr.rfind(ext_empty_raw)] + ext_empty_cov
# read in data
raw_empty = Raw(fn_empty_nr, preload=True, verbose=verbose)
raw_empty.interpolate_bads()
# pick MEG channels only
picks = pick_types(raw_empty.info, meg=True, ref_meg=False, eeg=False,
stim=False, eog=False, exclude='bads')
# calculate noise-covariance matrix
noise_cov_mat = cp_covariance(raw_empty, picks=picks, verbose=verbose)
# write noise-covariance matrix to disk
write_cov(fn_out, noise_cov_mat)
def cal_labelts(stcs_path, fn_func_list, condition='LLst',
min_subject='fsaverage', subjects_dir=None):
'''
Extract stcs from special ROIs, and store them for funther causality
analysis.
Parameter
---------
stcs_path: string
The path of stc's epochs.
fn_ana_list: string
The path of the file including pathes of functional labels.
condition: string
The condition for experiments.
min_subject: the subject for common brain
'''
path_list = get_files_from_list(stcs_path)
minpath = subjects_dir + '/%s' % (min_subject)
srcpath = minpath + '/bem/fsaverage-ico-5-src.fif'
src_inv = mne.read_source_spaces(srcpath)
# loop across all filenames
for stcs_path in path_list:
caupath = stcs_path[:stcs_path.rfind('/%s' % condition)]
fn_stcs_labels = caupath + '/%s_labels_ts.npy' % (condition)
_, _, files = os.walk(stcs_path).next()
trials = len(files) / 2
# Get unfiltered and morphed stcs
stcs = []
i = 0
while i < trials:
fn_stc = stcs_path + 'trial%s_fsaverage' % (str(i))
stc = mne.read_source_estimate(fn_stc + '-lh.stc',
subject=min_subject)
stcs.append(stc)
i = i + 1
# Get common labels
list_file = fn_func_list
with open(list_file, 'r') as fl:
file_list = [line.rstrip('\n') for line in fl]
fl.close()
rois = []
labels = []
for f in file_list:
label = mne.read_label(f)
labels.append(label)
rois.append(label.name)
# Extract stcs in common labels
label_ts = mne.extract_label_time_course(stcs, labels, src_inv,
mode='pca_flip')
# make label_ts's shape as (sources, samples, trials)
label_ts = np.asarray(label_ts).transpose(1, 2, 0)
np.save(fn_stcs_labels, label_ts)
def apply_rois(fn_stcs, event='LLst', tmin=0.0, tmax=0.6, tstep=0.05, window=0.2,
fmin=4, fmax=8, thr=99, min_subject='fsaverage'):
"""
Compute regions of interest (ROI) based on events
----------
fn_stcs : the file name of morphed stc.
evt: event related with stc
thr: the percentile of stc's strength
min_subject: the subject for the common brain space.
"""
from mne import read_source_spaces
fnlist = get_files_from_list(fn_stcs)
# loop across all filenames
for fn_stc in fnlist:
name = os.path.basename(fn_stc)
subject = name.split('_')[0]
subjects_dir = os.environ['SUBJECTS_DIR']
min_dir = subjects_dir + '/%s' %min_subject
labels_path = min_dir + '/DICS_ROIs/%s/%s/' %(subject, event)
reset_directory(labels_path)
src = min_dir + '/bem/%s-ico-4-src.fif' %min_subject
src_inv = read_source_spaces(src)
stc = mne.read_source_estimate(fn_stc, subject=min_subject)
stc = stc.crop(tmin, tmax)
src_pow = np.sum(stc.data ** 2, axis=1)
stc.data[src_pow < np.percentile(src_pow, thr)] = 0.
tbeg = tmin
while tbeg < tmax:
tend = tbeg + window
win_stc = stc.copy().crop(tbeg, tend)
stc_data = win_stc.data
src_pow = np.sum(stc_data ** 2, axis=1)
win_stc.data[src_pow < np.percentile(src_pow, thr)] = 0.
func_labels_lh, func_labels_rh = mne.stc_to_label(
win_stc, src=src_inv, smooth=True,
subjects_dir=subjects_dir,
connected=True)
# Left hemisphere definition
i = 0
while i < len(func_labels_lh):
func_label = func_labels_lh[i]
func_label.save(labels_path + '%s_%s_win%.2f_%2f' % (event, str(i), tbeg, tend))
i = i + 1
# right hemisphere definition
j = 0
while j < len(func_labels_rh):
func_label = func_labels_rh[j]
func_label.save(labels_path + '%s_%s_win%2f_%2f' % (event, str(j), tbeg, tend))
j = j + 1
tbeg = tbeg + tstep
def apply_rois(fn_stcs, evt='LLst', tmin=0.05, tmax=0.25, thr=99, min_subject='fsaverage'):
"""
Compute regions of interest (ROI) based on events
----------
fn_stcs : the file name of morphed stc.
evt: event related with stc
thr: the percentile of stc's strength
min_subject: the subject for the common brain space.
"""
from mne import read_source_spaces
fnlist = get_files_from_list(fn_stcs)
# loop across all filenames
for fn_stc in fnlist:
name = os.path.basename(fn_stc)
subject = name.split('_')[0]
subjects_dir = os.environ['SUBJECTS_DIR']
min_dir = subjects_dir + '/%s' %min_subject
labels_path = min_dir + '/DICS_ROIs/%s/%s/' %(subject, evt)
reset_directory(labels_path)
src = min_dir + '/bem/%s-ico-4-src.fif' %min_subject
src_inv = read_source_spaces(src)
stc = mne.read_source_estimate(fn_stc, subject=min_subject)
stc = stc.crop(tmin, tmax)
src_pow = np.sum(stc.data ** 2, axis=1)
stc.data[src_pow < np.percentile(src_pow, thr)] = 0.
#stc_data = stc_morph.data
#import pdb
#pdb.set_trace()
#zscore stc for ROIs estimation
#d_mu = stc_data.mean(axis=1, keepdims=True)
#d_std = stc_data.std(axis=1, ddof=1, keepdims=True)
#z_data = (stc_data - d_mu)/d_std
func_labels_lh, func_labels_rh = mne.stc_to_label(
stc, src=src_inv, smooth=True,
subjects_dir=subjects_dir,
connected=True)
# Left hemisphere definition
i = 0
while i < len(func_labels_lh):
func_label = func_labels_lh[i]
func_label.save(labels_path + '%s_%s' % (evt, str(i)))
i = i + 1
# right hemisphere definition
j = 0
while j < len(func_labels_rh):
func_label = func_labels_rh[j]
func_label.save(labels_path + '%s_%s' % (evt, str(j)))
j = j + 1
def merge_rois(labels_path_list, event='LLst'):
"""
merge ROIs, so that the overlapped lables merged into one.
If 'group' is False, ROIs from all the events are merged and
saved in the folder 'ROIs' under the 'labels_path'.
If 'group' is True, ROIs from all the subjects are merged and
saved in the folder 'merged' under the 'labels_path'.
----------
labels_path: the total path of all the ROIs' folders.
group: if 'group' is False, merge ROIs from different events within one
subject, if 'group' is True, merge ROIs across subjects.
evelist: events name of all subfolders
"""
path_list = get_files_from_list(labels_path_list)
# loop across all filenames
for labels_path in path_list:
import glob, shutil
mer_path = labels_path + '/ROIs/'
reset_directory(mer_path)
source_path = labels_path + '/%s' %event
for filename in glob.glob(os.path.join(source_path, '*.*')):
shutil.copy(filename, mer_path)
# Merge the individual subject's ROIs
reducer = True
count = 1
while reducer:
list_dirs = os.walk(mer_path)
label_list = ['']
for root, dirs, files in list_dirs:
for f in files:
label_fname = os.path.join(root, f)
label_list.append(label_fname)
label_list = label_list[1:]
len_class = _cluster_rois(mer_path, label_list, count)
if len_class == len(label_list):
reducer = False
count = count + 1
#subject_id = 'fsaverage'
#list_dirs = os.walk(labels_path)
#lh_mvs = []
#rh_mvs = []
#for root, dirs, files in list_dirs:
# for f in files:
# label_fname = os.path.join(root, f)
# label = mne.read_label(label_fname)
# pca = stc_avg.extract_label_time_course(label, src_inv, mode='pca_flip')
def stan_rois(fname=None, stan_path=None, size=8.0, min_subject='fsaverage'):
"""
Before merging all ROIs together, the size of ROIs will be standardized.
Keep every ROIs in a same size
----------
fname: averaged STC of the trials.
stan_path: path to store all subjects standarlized labels
size: the radius of every ROI.
min_subject: the subject for the common brain space.
"""
fnlist = get_files_from_list(fname)
subjects_dir = os.environ['SUBJECTS_DIR']
# loop across all filenames
for fn_stc in fnlist:
stc_path = os.path.split(fn_stc)[0]
stc_morph = mne.read_source_estimate(fn_stc, subject=min_subject)
#min_path = subjects_dir + '/%s' %min_subject
# extract the subject infromation from the file name
name = os.path.basename(fn_stc)
subject = name.split('_')[0]
mer_path = stc_path + '/ROIs/'
#stan_path = min_path + '/Group_ROIs/standard/'
#set_directory(stan_path)
list_dirs = os.walk(mer_path)
for root, dirs, files in list_dirs:
for f in files:
label_fname = os.path.join(root, f)
label = mne.read_label(label_fname)
stc_label = stc_morph.in_label(label)
src_pow = np.sum(stc_label.data ** 2, axis=1)
if label.hemi == 'lh':
# Get the max MNE value within each ROI
seed_vertno = stc_label.vertices[0][np.argmax(src_pow)]
func_label = mne.grow_labels(min_subject, seed_vertno,
extents=size, hemis=0,
subjects_dir=subjects_dir,
n_jobs=1)
func_label = func_label[0]
func_label.save(stan_path + '%s_%s' % (subject, f))
elif label.hemi == 'rh':
seed_vertno = stc_label.vertices[1][np.argmax(src_pow)]
func_label = mne.grow_labels(min_subject, seed_vertno,
extents=size, hemis=1,
subjects_dir=subjects_dir,
n_jobs=1)
func_label = func_label[0]
func_label.save(stan_path + '%s_%s' % (subject, f))
def apply_stand(fn_stc, radius=5.0, min_subject='fsaverage', tmin=0.1, tmax=0.5):
"""
Standardize the size of the selected ROIs.
Parameters
----------
fn_stc: string or list
The path of the common STCs.
radius: the radius of every ROI.
tmin, tmax: float (s).
The interest time range.
"""
fnlist = get_files_from_list(fn_stc)
# loop across all filenames
for fn_stc in fnlist:
stc_path = fn_stc[:fn_stc.rfind('-')]
stc = mne.read_source_estimate(fn_stc, subject=min_subject)
stc = stc.crop(tmin, tmax)
#min_path = subjects_dir + '/%s' %min_subject
# extract the subject infromation from the file name
source_path = stc_path + '/ROIs/'
stan_path = stc_path + '/standard/'
reset_directory(stan_path)
list_dirs = os.walk(source_path)
for root, dirs, files in list_dirs:
for f in files:
label_fname = os.path.join(root, f)
label = mne.read_label(label_fname)
stc_label = stc.in_label(label)
src_pow = np.sum(stc_label.data ** 2, axis=1)
if label.hemi == 'lh':
# Get the max MNE value within each ROI
seed_vertno = stc_label.vertices[0][np.argmax(src_pow)]
func_label = mne.grow_labels(min_subject, seed_vertno,
extents=radius, hemis=0,
subjects_dir=subjects_dir,
n_jobs=1)
func_label = func_label[0]
func_label.save(stan_path + '%s' %f)
elif label.hemi == 'rh':
seed_vertno = stc_label.vertices[1][np.argmax(src_pow)]
func_label = mne.grow_labels(min_subject, seed_vertno,
extents=radius, hemis=1,
subjects_dir=subjects_dir,
n_jobs=1)
func_label = func_label[0]
func_label.save(stan_path + '%s' %f)
def merge_rois(labels_path_list, group=False, evelist=['LLst','LLrt']):
"""
merge ROIs, so that the overlapped lables merged into one.
If 'group' is False, ROIs from all the events are merged and
saved in the folder 'ROIs' under the 'labels_path'.
If 'group' is True, ROIs from all the subjects are merged and
saved in the folder 'merged' under the 'labels_path'.
----------
labels_path: the total path of all the ROIs' folders.
group: if 'group' is False, merge ROIs from different events within one
subject, if 'group' is True, merge ROIs across subjects.
evelist: events name of all subfolders
"""
path_list = get_files_from_list(labels_path_list)
# loop across all filenames
for labels_path in path_list:
import glob, shutil
if group is False:
mer_path = labels_path + '/ROIs/'
reset_directory(mer_path)
for eve in evelist:
source_path = labels_path + '/%s' %eve
for filename in glob.glob(os.path.join(source_path, '*.*')):
shutil.copy(filename, mer_path)
elif group is True:
mer_path = labels_path + 'merged/'
reset_directory(mer_path)
source_path = labels_path + 'standard/'
for filename in glob.glob(os.path.join(source_path, '*.*')):
shutil.copy(filename, mer_path)
# Merge the individual subject's ROIs
reducer = True
count = 1
while reducer:
list_dirs = os.walk(mer_path)
label_list = ['']
for root, dirs, files in list_dirs:
for f in files:
label_fname = os.path.join(root, f)
label_list.append(label_fname)
label_list = label_list[1:]
len_class = _cluster_rois(mer_path, label_list, count)
if len_class == len(label_list):
reducer = False
count = count + 1
def sele_rois(fn_stc_list, fn_src, min_dist, weight, tmin=0.1, tmax=0.5):
"""
Select ROIs based on the least distance and the difference of Euclidean_norms
between ROIs candidates.
Parameters
----------
fn_stc_list: string or list
The path of the common STCs.
fn_src: string
The path of the common source space, such as: '*/fsaverage/bem/*-src.fif'
min_dist: int (mm)
Least distance between ROIs candidates.
weight: float
Euclidean_norms weight related to the larger candidate's standard deviation.
tmin, tmax: float (s).
The interest time range.
"""
fn_stc_list = get_files_from_list(fn_stc_list)
# loop across all filenames
for fn_stc in fn_stc_list:
import glob, shutil
labels_path = fn_stc[:fn_stc.rfind('-')]
source_path = labels_path + '/ini/'
sel_path = labels_path + '/ROIs/'
reset_directory(sel_path)
for filename in glob.glob(os.path.join(source_path, '*.*')):
shutil.copy(filename, sel_path)
reducer = True
stc = mne.read_source_estimate(fn_stc)
stc = stc.crop(tmin, tmax)
src = mne.read_source_spaces(fn_src)
while reducer:
list_dirs = os.walk(sel_path)
label_list = ['']
for root, dirs, files in list_dirs:
for f in files:
label_fname = os.path.join(root, f)
label_list.append(label_fname)
label_list = label_list[1:]
len_class = _cluster_sel(sel_path, label_list, stc, src, min_dist, weight)
if len_class == len(label_list):
reducer = False
def apply_stand(fn_stc, event, radius=5.0, min_subject='fsaverage'):
"""
----------
fname: averaged STC of the trials.
radius: the radius of every ROI.
"""
fnlist = get_files_from_list(fn_stc)
# loop across all filenames
for fn_stc in fnlist:
import glob, shutil
labels_path = os.path.split(fn_stc)[0]
stan_path = labels_path + '/%s/standard/' %event
reset_directory(stan_path)
source_path = labels_path + '/%s/ini/' %event
source = glob.glob(os.path.join(source_path, '*.*'))
for filename in source:
shutil.copy(filename, stan_path)
stc = mne.read_source_estimate(fn_stc, subject=min_subject)
list_dirs = os.walk(stan_path)
for root, dirs, files in list_dirs:
for f in files:
label_fname = os.path.join(root, f)
label = mne.read_label(label_fname)
stc_label = stc.in_label(label)
src_pow = np.sum(stc_label.data ** 2, axis=1)
if label.hemi == 'lh':
# Get the max MNE value within each ROI
seed_vertno = stc_label.vertices[0][np.argmax(src_pow)]
func_label = mne.grow_labels(min_subject, seed_vertno,
extents=radius, hemis=0,
subjects_dir=subjects_dir,
n_jobs=1)
func_label = func_label[0]
func_label.save(stan_path + '%s' %f)
elif label.hemi == 'rh':
seed_vertno = stc_label.vertices[1][np.argmax(src_pow)]
func_label = mne.grow_labels(min_subject, seed_vertno,
extents=radius, hemis=1,
subjects_dir=subjects_dir,
n_jobs=1)
func_label = func_label[0]
func_label.save(stan_path + '%s' %f)
def apply_STC_ave(fnevo, method='dSPM', snr=3.0, min_subject='fsaverage'):
''' Inverse evoked data into the source space.
Parameter
---------
fnevo: string or list
The evoked file with ECG, EOG and environmental noise free.
method:string
Inverse method, 'MNE' or 'dSPM'
snr: float
Signal to noise ratio for inverse solution.
event: string
The event name related with evoked data.
baseline: bool
If true, prestimulus segment from 'btmin' to 'btmax' will be saved,
If false, no baseline segment is saved.
btmin: float
The start time point (second) of baseline.
btmax: float
The end time point(second) of baseline.
min_subject: string
The subject name as the common brain.
'''
#Get the default subjects_dir
from mne.minimum_norm import apply_inverse, read_inverse_operator
fnlist = get_files_from_list(fnevo)
# loop across all filenames
for fname in fnlist:
name = os.path.basename(fname)
fn_path = os.path.split(fname)[0]
fn_stc = fname[:fname.rfind('-ave.fif')]
#fn_inv = fname[:fname.rfind('-ave.fif')] + ',ave-inv.fif'
subject = name.split('_')[0]
fn_inv = fn_path + '/%s_fibp1-45,ave-inv.fif' %subject
snr = snr
lambda2 = 1.0 / snr ** 2
#noise_cov = mne.read_cov(fn_cov)
[evoked] = mne.read_evokeds(fname)
evoked.pick_types(meg=True, ref_meg=False)
inv = read_inverse_operator(fn_inv)
stc = apply_inverse(evoked, inv, lambda2, method,
pick_ori='normal')
stc.save(fn_stc)
def morph_STC(fn_stc, grade, template='fsaverage', event='LLst',
baseline=True, btmin=-0.3, btmax=0.):
from mne import read_source_estimate, morph_data
fnlist = get_files_from_list(fn_stc)
for fname in fnlist:
name = os.path.basename(fname)
subject = name.split('_')[0]
stc_name = name[:name.rfind('-ave.fif')]
min_dir = subjects_dir + '/%s' %template
# this path used for ROI definition
stc_path = min_dir + '/dSPM_ROIs/%s' %(subject)
#fn_cov = meg_path + '/%s_empty,fibp1-45,nr-cov.fif' % subject
set_directory(stc_path)
# Morph STC
stc = read_source_estimate(fname)
stc_morph = morph_data(subject, template, stc, grade=grade)
stc_morph.save(stc_path + '/%s' % (stc_name), ftype='stc')
if baseline == True:
stc_base = stc_morph.crop(btmin, btmax)
stc_base.save(stc_path + '/%s_%s_baseline' % (subject, event[:2]), ftype='stc')
def apply_stand(fn_stc, radius=5.0, min_subject="fsaverage", tmin=0.1, tmax=0.5):
"""
----------
fname: averaged STC of the trials.
radius: the radius of every ROI.
"""
fnlist = get_files_from_list(fn_stc)
# loop across all filenames
for fn_stc in fnlist:
stc_path = fn_stc[: fn_stc.rfind("-")]
stc = mne.read_source_estimate(fn_stc, subject=min_subject)
stc = stc.crop(tmin, tmax)
# min_path = subjects_dir + '/%s' %min_subject
# extract the subject infromation from the file name
source_path = stc_path + "/ROIs/"
stan_path = stc_path + "/standard/"
reset_directory(stan_path)
list_dirs = os.walk(source_path)
for root, dirs, files in list_dirs:
for f in files:
label_fname = os.path.join(root, f)
label = mne.read_label(label_fname)
stc_label = stc.in_label(label)
src_pow = np.sum(stc_label.data ** 2, axis=1)
if label.hemi == "lh":
# Get the max MNE value within each ROI
seed_vertno = stc_label.vertices[0][np.argmax(src_pow)]
func_label = mne.grow_labels(
min_subject, seed_vertno, extents=radius, hemis=0, subjects_dir=subjects_dir, n_jobs=1
)
func_label = func_label[0]
func_label.save(stan_path + "%s" % f)
elif label.hemi == "rh":
seed_vertno = stc_label.vertices[1][np.argmax(src_pow)]
func_label = mne.grow_labels(
min_subject, seed_vertno, extents=radius, hemis=1, subjects_dir=subjects_dir, n_jobs=1
)
func_label = func_label[0]
func_label.save(stan_path + "%s" % f)
def morph_STC(fn_stc, grade, subjects_dir, template='fsaverage', event='LLst',
baseline=True, btmin=-0.3, btmax=0.):
'''
Morph individual STC into the common brain space.
Parameter
------------------------------------
fn_stc: string or list
The path of the individual STC.
subjects_dir: The total bath of all the subjects.
template: string
The subject name as the common brain.
event: string
The name of event
baseline: bool
If true, prestimulus segment from 'btmin' to 'btmax' will be saved,
If false, no baseline segment is saved.
btmin, btmax: float
If 'baseline' is True, baseline is croped using this period.
'''
from mne import read_source_estimate, morph_data
fnlist = get_files_from_list(fn_stc)
for fname in fnlist:
name = os.path.basename(fname)
subject = name.split('_')[0]
stc_name = name[:name.rfind('-lh.stc')]
min_dir = subjects_dir + '/%s' % template
# this path used for ROI definition
stc_path = min_dir + '/dSPM_ROIs/%s' % (subject)
# fn_cov = meg_path + '/%s_empty,fibp1-45,nr-cov.fif' % subject
set_directory(stc_path)
# Morph STC
stc = read_source_estimate(fname)
stc_morph = morph_data(subject, template, stc, grade=grade)
stc_morph.save(stc_path + '/%s' % (stc_name), ftype='stc')
if baseline is True:
stc_base = stc_morph.crop(btmin, btmax)
stc_base.save(stc_path + '/%s_%s_baseline' % (subject, event[:2]),
ftype='stc')
def apply_sele(fn_stc_list, fn_src, min_dist):
"""
select ROIs, so that the overlapped lables merged into one.
If 'group' is False, ROIs from all the events are merged and
saved in the folder 'ROIs' under the 'labels_path'.
If 'group' is True, ROIs from all the subjects are merged and
saved in the folder 'merged' under the 'labels_path'.
----------
labels_path: the total path of all the ROIs' folders.
group: if 'group' is False, merge ROIs from different events within one
subject, if 'group' is True, merge ROIs across subjects.
evelist: events name of all subfolders
"""
fn_stc_list = get_files_from_list(fn_stc_list)
# loop across all filenames
for fn_stc in fn_stc_list:
import glob, shutil
labels_path = os.path.split(fn_stc)[0]
sel_path = labels_path + '/ROIs/sele/'
reset_directory(sel_path)
source_path = labels_path + '/ROIs/merge/'
source = glob.glob(os.path.join(source_path, '*.*'))
for filename in source:
shutil.copy(filename, sel_path)
reducer = True
stc = mne.read_source_estimate(fn_stc)
stc.data[stc.data < 0] = 0
#stc = stc.crop(tmin, tmax)
src = mne.read_source_spaces(fn_src)
while reducer:
list_dirs = os.walk(sel_path)
label_list = ['']
for root, dirs, files in list_dirs:
for f in files:
label_fname = os.path.join(root, f)
label_list.append(label_fname)
label_list = label_list[1:]
len_class = _cluster_rois(sel_path, label_list, stc, src, min_dist)
if len_class == len(label_list):
reducer = False
def apply_inverse_ave(fnevo, subjects_dir):
''' Make individual inverse operator.
Parameter
---------
fnevo: string or list
The evoked file with ECG, EOG and environmental noise free.
subjects_dir: The total bath of all the subjects.
'''
from mne import make_forward_solution
from mne.minimum_norm import make_inverse_operator, write_inverse_operator
fnlist = get_files_from_list(fnevo)
# loop across all filenames
for fname in fnlist:
fn_path = os.path.split(fname)[0]
name = os.path.basename(fname)
subject = name.split('_')[0]
fn_inv = fn_path + '/%s_fibp1-45,ave-inv.fif' % subject
subject_path = subjects_dir + '/%s' % subject
fn_trans = fn_path + '/%s-trans.fif' % subject
fn_cov = fn_path + '/%s_empty,fibp1-45-cov.fif' % subject
fn_src = subject_path + '/bem/%s-ico-5-src.fif' % subject
fn_bem = subject_path + '/bem/%s-5120-5120-5120-bem-sol.fif' % subject
[evoked] = mne.read_evokeds(fname)
evoked.pick_types(meg=True, ref_meg=False)
noise_cov = mne.read_cov(fn_cov)
# noise_cov = dSPM.cov.regularize(noise_cov, evoked.info,
# mag=0.05, grad=0.05, proj=True)
fwd = make_forward_solution(evoked.info, fn_trans, fn_src, fn_bem)
fwd['surf_ori'] = True
inv = make_inverse_operator(evoked.info,
fwd,
noise_cov,
loose=0.2,
depth=0.8,
limit_depth_chs=False)
write_inverse_operator(fn_inv, inv)
def apply_inverse_ave(fnevo, subjects_dir):
''' Make individual inverse operator.
Parameter
---------
fnevo: string or list
The evoked file with ECG, EOG and environmental noise free.
subjects_dir: The total bath of all the subjects.
'''
from mne import make_forward_solution
from mne.minimum_norm import make_inverse_operator, write_inverse_operator
fnlist = get_files_from_list(fnevo)
# loop across all filenames
for fname in fnlist:
fn_path = os.path.split(fname)[0]
name = os.path.basename(fname)
subject = name.split('_')[0]
fn_inv = fn_path + '/%s_fibp1-45,ave-inv.fif' % subject
subject_path = subjects_dir + '/%s' % subject
fn_trans = fn_path + '/%s-trans.fif' % subject
fn_cov = fn_path + '/%s_empty,fibp1-45-cov.fif' % subject
fn_src = subject_path + '/bem/%s-oct-6-src.fif' % subject
fn_bem = subject_path + '/bem/%s-5120-5120-5120-bem-sol.fif' % subject
[evoked] = mne.read_evokeds(fname)
evoked.pick_types(meg=True, ref_meg=False)
noise_cov = mne.read_cov(fn_cov)
# noise_cov = mne.cov.regularize(noise_cov, evoked.info,
# mag=0.05, grad=0.05, proj=True)
fwd = make_forward_solution(evoked.info, fn_trans, fn_src, fn_bem)
fwd['surf_ori'] = True
inv = make_inverse_operator(evoked.info, fwd, noise_cov, loose=0.2,
depth=0.8, limit_depth_chs=False)
write_inverse_operator(fn_inv, inv)
def apply_inverse_oper(fnepo, tmin=-0.2, tmax=0.8, subjects_dir=None):
'''
Apply inverse operator
Parameter
---------
fnepo: string or list
The epochs file with ECG, EOG and environmental noise free.
tmax, tmax:float
The time period (second) of each epoch.
'''
# Get the default subjects_dir
from mne import make_forward_solution
from mne.minimum_norm import make_inverse_operator, write_inverse_operator
fnlist = get_files_from_list(fnepo)
# loop across all filenames
for fname in fnlist:
fn_path = os.path.split(fname)[0]
name = os.path.basename(fname)
subject = name.split('_')[0]
subject_path = subjects_dir + '/%s' % subject
fn_trans = fn_path + '/%s-trans.fif' % subject
fn_cov = fn_path + '/%s_empty-cov.fif' % subject
fn_src = subject_path + '/bem/%s-oct-6-src.fif' % subject
fn_bem = subject_path + '/bem/%s-5120-5120-5120-bem-sol.fif' % subject
fn_inv = fn_path + '/%s_epo-inv.fif' % subject
epochs = mne.read_epochs(fname)
epochs.crop(tmin, tmax)
epochs.pick_types(meg=True, ref_meg=False)
noise_cov = mne.read_cov(fn_cov)
fwd = make_forward_solution(epochs.info, fn_trans, fn_src, fn_bem)
fwd['surf_ori'] = True
inv = make_inverse_operator(epochs.info, fwd, noise_cov, loose=0.2,
depth=0.8, limit_depth_chs=False)
write_inverse_operator(fn_inv, inv)
def normalize_data(fn_ts, pre_t=0.2, fs=678.17):
'''
Before causal model construction, labelts need to be normalized further:
1) Downsampling for reducing the time consuming.
2) Apply Z-scoring to each STC.
Parameter
---------
fnts: string
The file name of representative STCs for each ROI.
factor: int
The factor for downsampling.
'''
path_list = get_files_from_list(fn_ts)
# loop across all filenames
for fnts in path_list:
fnnorm = fnts[:fnts.rfind('.npy')] + ',norm.npy'
ts = np.load(fnts)
d_pre = ts[:, :int(pre_t*fs), :]
d_pos = ts[:, int(pre_t*fs):, :]
d_mu = d_pre.mean(axis=1, keepdims=True)
d_std = d_pre.std(axis=1, ddof=1, keepdims=True)
z_data = (d_pos - d_mu) / d_std
np.save(fnnorm, z_data)
def apply_inverse(fnepo, method='dSPM', event='LLst', min_subject='fsaverage', STC_US='ROI',
snr=5.0):
'''
Parameter
---------
fnepo: string or list
The epochs file with ECG, EOG and environmental noise free.
method: inverse method, 'MNE' or 'dSPM'
event: string
The event name related with epochs.
min_subject: string
The subject name as the common brain.
STC_US: string
The using of the inversion for further analysis.
'ROI' stands for ROIs definition, 'CAU' stands for causality analysis.
snr: signal to noise ratio for inverse solution.
'''
#Get the default subjects_dir
from mne.minimum_norm import (apply_inverse, apply_inverse_epochs)
subjects_dir = os.environ['SUBJECTS_DIR']
fnlist = get_files_from_list(fnepo)
# loop across all filenames
for fname in fnlist:
fn_path = os.path.split(fname)[0]
name = os.path.basename(fname)
stc_name = name[:name.rfind('-epo.fif')]
subject = name.split('_')[0]
subject_path = subjects_dir + '/%s' %subject
min_dir = subjects_dir + '/%s' %min_subject
fn_trans = fn_path + '/%s-trans.fif' % subject
fn_cov = fn_path + '/%s_empty,nr-cov.fif' % subject
fn_src = subject_path + '/bem/%s-ico-4-src.fif' % subject
fn_bem = subject_path + '/bem/%s-5120-5120-5120-bem-sol.fif' % subject
snr = snr
lambda2 = 1.0 / snr ** 2
#noise_cov = mne.read_cov(fn_cov)
epochs = mne.read_epochs(fname)
noise_cov = mne.read_cov(fn_cov)
if STC_US == 'ROI':
# this path used for ROI definition
stc_path = min_dir + '/%s_ROIs/%s' %(method,subject)
#fn_cov = meg_path + '/%s_empty,fibp1-45,nr-cov.fif' % subject
evoked = epochs.average()
set_directory(stc_path)
noise_cov = mne.cov.regularize(noise_cov, evoked.info,
mag=0.05, grad=0.05, proj=True)
fwd_ev = mne.make_forward_solution(evoked.info, trans=fn_trans,
src=fn_src, bem=fn_bem,
fname=None, meg=True, eeg=False,
mindist=5.0, n_jobs=2,
overwrite=True)
fwd_ev = mne.convert_forward_solution(fwd_ev, surf_ori=True)
forward_meg_ev = mne.pick_types_forward(fwd_ev, meg=True, eeg=False)
inverse_operator_ev = mne.minimum_norm.make_inverse_operator(
evoked.info, forward_meg_ev, noise_cov,
loose=0.2, depth=0.8)
# Compute inverse solution
stc = apply_inverse(evoked, inverse_operator_ev, lambda2, method,
pick_ori=None)
# Morph STC
subject_id = min_subject
stc_morph = mne.morph_data(subject, subject_id, stc, grade=5, smooth=5)
stc_morph.save(stc_path + '/%s' % (stc_name), ftype='stc')
elif STC_US == 'CAU':
stcs_path = min_dir + '/stcs/%s/%s/' % (subject,event)
reset_directory(stcs_path)
noise_cov = mne.cov.regularize(noise_cov, epochs.info,
mag=0.05, grad=0.05, proj=True)
fwd = mne.make_forward_solution(epochs.info, trans=fn_trans,
src=fn_src, bem=fn_bem,
meg=True, eeg=False, mindist=5.0,
n_jobs=2, overwrite=True)
fwd = mne.convert_forward_solution(fwd, surf_ori=True)
forward_meg = mne.pick_types_forward(fwd, meg=True, eeg=False)
inverse_operator = mne.minimum_norm.make_inverse_operator(
epochs.info, forward_meg, noise_cov, loose=0.2,
depth=0.8)
# Compute inverse solution
stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2,
method=method, pick_ori='normal')
s = 0
while s < len(stcs):
stc_morph = mne.morph_data(
subject, min_subject, stcs[s], grade=5, smooth=5)
stc_morph.save(stcs_path + '/trial%s_fsaverage'
% (subject, str(s)), ftype='stc')
s = s + 1
def apply_rois(fn_stc, event, tmin=0.0, tmax=0.3, tstep=0.05, window=0.2,
min_subject='fsaverage', thr=99):
"""
Compute regions of interest (ROI) based on events
----------
fn_stc : string
evoked and morphed STC.
event: string
event of the related STC.
tmin, tmax: float
segment for ROIs definition.
min_subject: string
the subject as the common brain space.
thr: float or int
threshold of STC used for ROI identification.
"""
from scipy.signal import detrend
from scipy.stats.mstats import zscore
fnlist = get_files_from_list(fn_stc)
# loop across all filenames
for ifn_stc in fnlist:
subjects_dir = os.environ['SUBJECTS_DIR']
# extract the subject infromation from the file name
stc_path = os.path.split(ifn_stc)[0]
#name = os.path.basename(fn_stc)
#tri = name.split('_')[1].split('-')[0]
min_path = subjects_dir + '/%s' % min_subject
fn_src = min_path + '/bem/fsaverage-ico-4-src.fif'
# Make sure the target path is exist
labels_path = stc_path + '/%s/' %event
reset_directory(labels_path)
# Read the MNI source space
src_inv = mne.read_source_spaces(fn_src)
stc = mne.read_source_estimate(ifn_stc, subject=min_subject)
#stc = stc.crop(tmin, tmax)
#src_pow = np.sum(stc.data ** 2, axis=1)
#stc.data[src_pow < np.percentile(src_pow, thr)] = 0.
stc = stc.crop(tmin, tmax)
cal_data = stc.data
dt_data = detrend(cal_data, axis=-1)
zc_data = zscore(dt_data, axis=-1)
src_pow = np.sum(zc_data ** 2, axis=1)
stc.data[src_pow < np.percentile(src_pow, thr)] = 0.
tbeg = tmin
count = 1
while tbeg < tmax:
tend = tbeg + window
if tend > tmax:
break
win_stc = stc.copy().crop(tbeg, tend)
stc_data = win_stc.data
src_pow = np.sum(stc_data ** 2, axis=1)
win_stc.data[src_pow < np.percentile(src_pow, thr)] = 0.
func_labels_lh, func_labels_rh = mne.stc_to_label(
win_stc, src=src_inv, smooth=True,
subjects_dir=subjects_dir,
connected=True)
# Left hemisphere definition
i = 0
while i < len(func_labels_lh):
func_label = func_labels_lh[i]
func_label.save(labels_path + '%s_%s_win%d' % (event, str(i), count))
i = i + 1
# right hemisphere definition
j = 0
while j < len(func_labels_rh):
func_label = func_labels_rh[j]
func_label.save(labels_path + '%s_%s_win%d' % (event, str(j), count))
j = j + 1
tbeg = tbeg + tstep
count = count + 1
