def calc_sub_cortical_activity(events_id, evoked_fn, inv_fn, sub_corticals_codes_file, baseline_min_t=None,
baseline_max_t = 0, snr = 3.0, inverse_method='dSPM'):
sub_corticals = read_sub_corticals_code_file(sub_corticals_codes_file)
if len(sub_corticals) == 0:
return
lambda2 = 1.0 / snr ** 2
lut = read_freesurfer_lookup_table(FREE_SURFER_HOME)
for cond in events_id.keys():
evo = evoked_fn.format(cond=cond)
evoked = {event:mne.read_evokeds(evo, baseline=(baseline_min_t, baseline_max_t))[0] for event in [event]}
inverse_operator = read_inverse_operator(inv_fn.format(cond=cond))
stc = apply_inverse(evoked[cond], inverse_operator, lambda2, inverse_method)
read_vertices_from = len(stc.vertices[0])+len(stc.vertices[1])
sub_corticals_activity = {}
for sub_cortical_ind, sub_cortical_code in enumerate(sub_corticals):
# +2 becasue the first two are the hemispheres
sub_corticals_activity[sub_cortical_code] = stc.data[
read_vertices_from: read_vertices_from + len(stc.vertices[sub_cortical_ind + 2])]
read_vertices_from += len(stc.vertices[sub_cortical_ind + 2])
if not os.path.isdir:
os.mkdir(os.path.join(SUBJECT_MEG_FOLDER, 'subcorticals'))
for sub_cortical_code, activity in sub_corticals_activity.iteritems():
sub_cortical, _ = get_numeric_index_to_label(sub_cortical_code, lut)
np.save(os.path.join(SUBJECT_MEG_FOLDER, 'subcorticals', '{}-{}-{}'.format(cond, sub_cortical, inverse_method)), activity.mean(0))
np.save(os.path.join(SUBJECT_MEG_FOLDER, 'subcorticals', '{}-{}-{}-all-vertices'.format(cond, sub_cortical, inverse_method)), activity)
def test_spatio_temporal_src_connectivity():
"""Test spatio-temporal connectivity from source spaces."""
tris = np.array([[0, 1, 2], [3, 4, 5]])
src = [dict(), dict()]
connectivity = spatio_temporal_tris_connectivity(tris, 2)
src[0]['use_tris'] = np.array([[0, 1, 2]])
src[1]['use_tris'] = np.array([[0, 1, 2]])
src[0]['vertno'] = np.array([0, 1, 2])
src[1]['vertno'] = np.array([0, 1, 2])
src[0]['type'] = 'surf'
src[1]['type'] = 'surf'
connectivity2 = spatio_temporal_src_connectivity(src, 2)
assert_array_equal(connectivity.todense(), connectivity2.todense())
# add test for dist connectivity
src[0]['dist'] = np.ones((3, 3)) - np.eye(3)
src[1]['dist'] = np.ones((3, 3)) - np.eye(3)
src[0]['vertno'] = [0, 1, 2]
src[1]['vertno'] = [0, 1, 2]
src[0]['type'] = 'surf'
src[1]['type'] = 'surf'
connectivity3 = spatio_temporal_src_connectivity(src, 2, dist=2)
assert_array_equal(connectivity.todense(), connectivity3.todense())
# add test for source space connectivity with omitted vertices
inverse_operator = read_inverse_operator(fname_inv)
src_ = inverse_operator['src']
with pytest.warns(RuntimeWarning, match='will have holes'):
connectivity = spatio_temporal_src_connectivity(src_, n_times=2)
a = connectivity.shape[0] / 2
b = sum([s['nuse'] for s in inverse_operator['src']])
assert (a == b)
assert_equal(grade_to_tris(5).shape, [40960, 3])
def test_epochs_vector_inverse():
"""Test vector inverse consistency between evoked and epochs."""
raw = read_raw_fif(fname_raw)
events = find_events(raw, stim_channel='STI 014')[:2]
reject = dict(grad=2000e-13, mag=4e-12, eog=150e-6)
epochs = Epochs(raw, events, None, 0, 0.01, baseline=None,
reject=reject, preload=True)
assert_equal(len(epochs), 2)
evoked = epochs.average(picks=range(len(epochs.ch_names)))
inv = read_inverse_operator(fname_inv)
method = "MNE"
snr = 3.
lambda2 = 1. / snr ** 2
stcs_epo = apply_inverse_epochs(epochs, inv, lambda2, method=method,
pick_ori='vector', return_generator=False)
stc_epo = np.mean(stcs_epo)
stc_evo = apply_inverse(evoked, inv, lambda2, method=method,
pick_ori='vector')
assert_allclose(stc_epo.data, stc_evo.data, rtol=1e-9, atol=0)
def test_spatio_temporal_src_connectivity():
"""Test spatio-temporal connectivity from source spaces"""
tris = np.array([[0, 1, 2], [3, 4, 5]])
src = [dict(), dict()]
connectivity = spatio_temporal_tris_connectivity(tris, 2)
src[0]['use_tris'] = np.array([[0, 1, 2]])
src[1]['use_tris'] = np.array([[0, 1, 2]])
src[0]['vertno'] = np.array([0, 1, 2])
src[1]['vertno'] = np.array([0, 1, 2])
connectivity2 = spatio_temporal_src_connectivity(src, 2)
assert_array_equal(connectivity.todense(), connectivity2.todense())
# add test for dist connectivity
src[0]['dist'] = np.ones((3, 3)) - np.eye(3)
src[1]['dist'] = np.ones((3, 3)) - np.eye(3)
src[0]['vertno'] = [0, 1, 2]
src[1]['vertno'] = [0, 1, 2]
connectivity3 = spatio_temporal_src_connectivity(src, 2, dist=2)
assert_array_equal(connectivity.todense(), connectivity3.todense())
# add test for source space connectivity with omitted vertices
inverse_operator = read_inverse_operator(fname_inv)
with warnings.catch_warnings(record=True) as w:
connectivity = spatio_temporal_src_connectivity(
inverse_operator['src'], n_times=2)
assert len(w) == 1
a = connectivity.shape[0] / 2
b = sum([s['nuse'] for s in inverse_operator['src']])
assert_true(a == b)
def test_spatio_temporal_src_connectivity():
"""Test spatio-temporal connectivity from source spaces."""
tris = np.array([[0, 1, 2], [3, 4, 5]])
src = [dict(), dict()]
connectivity = spatio_temporal_tris_connectivity(tris, 2)
src[0]['use_tris'] = np.array([[0, 1, 2]])
src[1]['use_tris'] = np.array([[0, 1, 2]])
src[0]['vertno'] = np.array([0, 1, 2])
src[1]['vertno'] = np.array([0, 1, 2])
src[0]['type'] = 'surf'
src[1]['type'] = 'surf'
connectivity2 = spatio_temporal_src_connectivity(src, 2)
assert_array_equal(connectivity.todense(), connectivity2.todense())
# add test for dist connectivity
src[0]['dist'] = np.ones((3, 3)) - np.eye(3)
src[1]['dist'] = np.ones((3, 3)) - np.eye(3)
src[0]['vertno'] = [0, 1, 2]
src[1]['vertno'] = [0, 1, 2]
src[0]['type'] = 'surf'
src[1]['type'] = 'surf'
connectivity3 = spatio_temporal_src_connectivity(src, 2, dist=2)
assert_array_equal(connectivity.todense(), connectivity3.todense())
# add test for source space connectivity with omitted vertices
inverse_operator = read_inverse_operator(fname_inv)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
src_ = inverse_operator['src']
connectivity = spatio_temporal_src_connectivity(src_, n_times=2)
assert_equal(len(w), 1)
a = connectivity.shape[0] / 2
b = sum([s['nuse'] for s in inverse_operator['src']])
assert_true(a == b)
assert_equal(grade_to_tris(5).shape, [40960, 3])
def _create_stcs(params):
subject, events_id, epochs, evoked, inv, inverse_method, baseline, apply_for_epochs, apply_SSP_projection_vectors, add_eeg_ref = params
snr = 3.0
lambda2 = 1.0 / snr ** 2
local_inv_file_name = op.join(LOCAL_ROOT_DIR, 'inv', '{}_ecr_nTSSS_conflict-inv.fif'.format(subject))
if inv is None and os.path.isfile(local_inv_file_name):
inv = read_inverse_operator(local_inv_file_name)
if inv is None:
return
print([s['vertno'] for s in inv['src']])
for cond_name in events_id.keys():
if not apply_for_epochs:
local_stc_file_name = op.join(LOCAL_ROOT_DIR, 'stc', '{}_{}_{}'.format(subject, cond_name, inverse_method))
if os.path.isfile('{}-lh.stc'.format(local_stc_file_name)):
print('stc was already calculated for {}'.format(subject))
else:
if evoked is None:
evoked_cond = mne.read_evokeds(op.join(LOCAL_ROOT_DIR, 'evo', '{}_ecr_{}-ave.fif'.format(subject, cond_name)))
else:
evoked_cond = evoked[cond_name]
stcs = apply_inverse(evoked_cond, inv, lambda2, inverse_method, pick_ori=None)
stcs.save(local_stc_file_name, ftype='h5')
else:
local_stc_template = op.join(LOCAL_ROOT_DIR, 'stc_epochs', '{}_{}_{}_{}'.format(subject, cond_name, '{epoch_ind}', inverse_method))
if len(glob.glob(local_stc_template.format(epoch_ind='*') == 36)):
print('stc was already calculated for {}'.format(subject))
else:
stcs = apply_inverse_epochs(epochs[cond_name], inv, lambda2, inverse_method, pick_ori=None, return_generator=True)
for epoch_ind, stc in enumerate(stcs):
if not os.path.isfile(local_stc_template.format(epoch_ind=epoch_ind)):
stc.save(local_stc_template.format(epoch_ind=epoch_ind), ftype='h5')
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_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 test_plot_snr():
"""Test plotting SNR estimate."""
import matplotlib.pyplot as plt
inv = read_inverse_operator(inv_fname)
evoked = read_evokeds(evoked_fname, baseline=(None, 0))[0]
plot_snr_estimate(evoked, inv)
plt.close('all')
def plot_inverse_operator(subject, fnout_img=None, verbose=None):
""""Reads in and plots the inverse solution."""
# get name of inverse solution-file
subjects_dir = os.environ.get('SUBJECTS_DIR')
fname_dir_inv = os.path.join(subjects_dir,
subject)
for files in os.listdir(fname_dir_inv):
if files.endswith(",cleaned_epochs_avg-7-src-meg-inv.fif"):
fname_inv = os.path.join(fname_dir_inv,
files)
break
try:
fname_inv
except NameError:
print "ERROR: No forward solution found!"
sys.exit()
# read inverse solution
inv = min_norm.read_inverse_operator(fname_inv)
# print some information if desired
if verbose is not None:
print "Method: %s" % inv['methods']
print "fMRI prior: %s" % inv['fmri_prior']
print "Number of sources: %s" % inv['nsource']
print "Number of channels: %s" % inv['nchan']
# show 3D source space
lh_points = inv['src'][0]['rr']
lh_faces = inv['src'][0]['tris']
rh_points = inv['src'][1]['rr']
rh_faces = inv['src'][1]['tris']
# create figure and plot results
fig_inverse = mlab.figure(size=(1200, 1200),
bgcolor=(0, 0, 0))
mlab.triangular_mesh(lh_points[:, 0],
lh_points[:, 1],
lh_points[:, 2],
lh_faces)
mlab.triangular_mesh(rh_points[:, 0],
rh_points[:, 1],
rh_points[:, 2],
rh_faces)
# save result
if fnout_img is not None:
mlab.savefig(fnout_img,
figure=fig_inverse,
size=(1200, 1200))
mlab.close(all=True)
def test_psf_ctf():
"""Test computation of PSFs and CTFs for linear estimators
"""
inverse_operator = read_inverse_operator(fname_inv)
forward = read_forward_solution(fname_fwd, force_fixed=False,
surf_ori=True)
forward = pick_types_forward(forward, meg=True, eeg=False)
labels = [mne.read_label(ss) for ss in fname_label]
method = 'MNE'
n_svd_comp = 2
# Test PSFs (then CTFs)
for mode in ('sum', 'svd'):
stc_psf, psf_ev = point_spread_function(inverse_operator,
forward,
method=method,
labels=labels,
lambda2=lambda2,
pick_ori='normal',
mode=mode,
n_svd_comp=n_svd_comp)
n_vert, n_samples = stc_psf.shape
should_n_vert = (inverse_operator['src'][1]['vertno'].shape[0] +
inverse_operator['src'][0]['vertno'].shape[0])
if mode == 'svd':
should_n_samples = len(labels) * n_svd_comp + 1
else:
should_n_samples = len(labels) + 1
assert_true(n_vert == should_n_vert)
assert_true(n_samples == should_n_samples)
n_chan, n_samples = psf_ev.data.shape
assert_true(n_chan == forward['nchan'])
forward = read_forward_solution(fname_fwd, force_fixed=True, surf_ori=True)
forward = pick_types_forward(forward, meg=True, eeg=False)
# Test CTFs
for mode in ('sum', 'svd'):
stc_ctf = cross_talk_function(inverse_operator, forward,
labels, method=method,
lambda2=lambda2,
signed=False, mode=mode,
n_svd_comp=n_svd_comp)
n_vert, n_samples = stc_ctf.shape
should_n_vert = (inverse_operator['src'][1]['vertno'].shape[0] +
inverse_operator['src'][0]['vertno'].shape[0])
if mode == 'svd':
should_n_samples = len(labels) * n_svd_comp + 1
else:
should_n_samples = len(labels) + 1
assert_true(n_vert == should_n_vert)
assert_true(n_samples == should_n_samples)
def calc_inv_kernel(fn_inv, method="dSPM", nave=1, snr=6.,
pick_ori="normal", verbose=None):
"""
Interface for preparing the kernel of the inverse
estimation.
Parameters
----------
fn_inv : String containing the filename
of the inverse operator (must be a fif-file)
method : string
which source localization method should be used?
MNE-based: "MNE" | "dSPM" | "sLORETA"
default: method="dSPM"
nave : number of averages used to regularize the solution
default: nave=1
snr : signal-to-noise ratio
default: snr = 3.
verbose : bool, str, int, or None
If not None, override default verbose level
(see mne.verbose).
default: verbose=None
"""
# -------------------------------------------
# import necessary modules
# -------------------------------------------
import mne.minimum_norm as min_norm
from mne.minimum_norm.inverse import _assemble_kernel
import numpy as np
# -------------------------------------------
# estimate inverse kernel
# -------------------------------------------
# load inverse solution
inv_operator = min_norm.read_inverse_operator(fn_inv, verbose=verbose)
# set up the inverse according to the parameters
lambda2 = 1. / snr ** 2. # the regularization parameter.
inv_operator = min_norm.prepare_inverse_operator(inv_operator, nave, lambda2, method)
# estimate inverse kernel and noise normalization coefficient
kernel, noise_norm, vertno = _assemble_kernel(inv_operator, None, method, pick_ori)
if method == "MNE":
noise_norm = np.ones((kernel.shape[0]/3))
noise_norm = noise_norm[:, np.newaxis]
# -------------------------------------------
# return results
# -------------------------------------------
return kernel, noise_norm, vertno
def test_surface_vector_source_morph():
"""Test surface and vector source estimate morph."""
tempdir = _TempDir()
inverse_operator_surf = read_inverse_operator(fname_inv_surf)
stc_surf = read_source_estimate(fname_smorph, subject='sample')
stc_surf.crop(0.09, 0.1) # for faster computation
stc_vec = _real_vec_stc()
source_morph_surf = compute_source_morph(
inverse_operator_surf['src'], subjects_dir=subjects_dir,
smooth=1, warn=False) # smooth 1 for speed
assert source_morph_surf.subject_from == 'sample'
assert source_morph_surf.subject_to == 'fsaverage'
assert source_morph_surf.kind == 'surface'
assert isinstance(source_morph_surf.src_data, dict)
assert isinstance(source_morph_surf.src_data['vertices_from'], list)
assert isinstance(source_morph_surf, SourceMorph)
stc_surf_morphed = source_morph_surf.apply(stc_surf)
assert isinstance(stc_surf_morphed, SourceEstimate)
stc_vec_morphed = source_morph_surf.apply(stc_vec)
with pytest.raises(ValueError, match='Only volume source estimates'):
source_morph_surf.apply(stc_surf, output='nifti1')
# check if correct class after morphing
assert isinstance(stc_surf_morphed, SourceEstimate)
assert isinstance(stc_vec_morphed, VectorSourceEstimate)
# check __repr__
assert 'surface' in repr(source_morph_surf)
# check loading and saving for surf
source_morph_surf.save(op.join(tempdir, '42.h5'))
source_morph_surf_r = read_source_morph(op.join(tempdir, '42.h5'))
assert (all([read == saved for read, saved in
zip(sorted(source_morph_surf_r.__dict__),
sorted(source_morph_surf.__dict__))]))
# check wrong subject correction
stc_surf.subject = None
assert isinstance(source_morph_surf.apply(stc_surf), SourceEstimate)
# degenerate
stc_vol = read_source_estimate(fname_vol, 'sample')
with pytest.raises(ValueError, match='stc_from was type'):
source_morph_surf.apply(stc_vol)
def test_snr():
"""Test SNR calculation"""
tempdir = _TempDir()
inv = read_inverse_operator(fname_inv)
evoked = read_evokeds(fname_evoked, baseline=(None, 0))[0]
snr = estimate_snr(evoked, inv)[0]
orig_dir = os.getcwd()
os.chdir(tempdir)
try:
cmd = ['mne_compute_mne', '--inv', fname_inv, '--meas', fname_evoked,
'--snronly', '--bmin', '-200', '--bmax', '0']
run_subprocess(cmd)
except Exception:
pass # this returns 1 for some reason
finally:
os.chdir(orig_dir)
snr_c = np.loadtxt(op.join(tempdir, 'SNR'))[:, 1]
assert_allclose(snr, snr_c, atol=1e-2, rtol=1e-2)
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 get_mne_stc(ndvar=False, vol=False, subject='sample'):
"""MNE-Python SourceEstimate
Parameters
----------
ndvar : bool
Convert to NDVar (default False; src="ico-4" is false, but it works as
long as the source space is not accessed).
vol : bool
Volume source estimate.
"""
data_path = Path(mne.datasets.testing.data_path())
meg_sdir = data_path / 'MEG/sample'
subjects_dir = data_path / 'subjects'
# scaled subject
if subject == 'fsaverage_scaled':
subject_dir = os.path.join(subjects_dir, subject)
if not os.path.exists(subject_dir):
mne.scale_mri('fsaverage', subject, .9, subjects_dir=subjects_dir, skip_fiducials=True, labels=False, annot=True)
data_subject = 'fsaverage'
else:
data_subject = subject
if vol:
inv = mn.read_inverse_operator(str(meg_sdir / 'sample_audvis_trunc-meg-vol-7-meg-inv.fif'))
evoked = mne.read_evokeds(str(meg_sdir / 'sample_audvis_trunc-ave.fif'), 'Left Auditory')
stc = mn.apply_inverse(evoked, inv, method='MNE', pick_ori='vector')
if data_subject == 'fsaverage':
m = mne.compute_source_morph(stc, 'sample', data_subject, subjects_dir)
stc = m.apply(stc)
stc.subject = subject
elif subject != 'sample':
raise ValueError(f"subject={subject!r}")
if ndvar:
return load.fiff.stc_ndvar(stc, subject, 'vol-7', subjects_dir, 'MNE', sss_filename='{subject}-volume-7mm-src.fif')
else:
return stc
stc_path = meg_sdir / f'{data_subject}_audvis_trunc-meg'
if ndvar:
return load.fiff.stc_ndvar(stc_path, subject, 'ico-5', subjects_dir)
else:
return mne.read_source_estimate(str(stc_path), subject)
def load(typ, subject='fsaverage', analysis='analysis', block=999,
download=True, preload=False):
"""Auxiliary saving function."""
# get file name
fname = paths(typ, subject=subject, analysis=analysis, block=block)
# check if file exists
if not op.exists(fname) and download:
client.download(fname)
# different data format depending file type
if typ == 'behavior':
from base import read_events
out = read_events(fname)
elif typ == 'sss':
out = Raw(fname, preload=preload)
elif typ in ['epo_block', 'epochs', 'epochs_decim', 'epochs_vhp']:
out = read_epochs(fname, preload=preload)
elif typ in ['cov']:
from mne.cov import read_cov
out = read_cov(fname)
elif typ in ['fwd']:
from mne import read_forward_solution
out = read_forward_solution(fname, surf_ori=True)
elif typ in ['inv']:
from mne.minimum_norm import read_inverse_operator
out = read_inverse_operator(fname)
elif typ in ['evoked', 'decod', 'decod_tfr', 'score', 'score_tfr',
'evoked_source']:
with open(fname, 'rb') as f:
out = pickle.load(f)
elif typ == 'morph':
from scipy.sparse import csr_matrix
loader = np.load(fname)
out = csr_matrix((loader['data'], loader['indices'], loader['indptr']),
shape=loader['shape'])
elif typ in ['score_source', 'score_pval']:
out = np.load(fname)
else:
raise NotImplementedError()
return out
def _calc_inverse(params):
subject, epochs, overwrite = params
epo = op.join(REMOTE_ROOT_DIR, 'ave', '{}_ecr_nTSSS_conflict-epo.fif'.format(subject))
fwd = op.join(REMOTE_ROOT_DIR, 'fwd', '{}_ecr-fwd.fif'.format(subject))
local_inv_file_name = op.join(LOCAL_ROOT_DIR, 'inv', '{}_ecr_nTSSS_conflict-inv.fif'.format(subject))
if os.path.isfile(local_inv_file_name) and not overwrite:
inverse_operator = read_inverse_operator(local_inv_file_name)
print('inv already calculated for {}'.format(subject))
else:
if epochs is None:
epochs = mne.read_epochs(epo)
noise_cov = mne.compute_covariance(epochs.crop(None, 0, copy=True))
inverse_operator = None
if not os.path.isfile(fwd):
print('no fwd for {}'.format(subject))
else:
forward = mne.read_forward_solution(fwd)
inverse_operator = make_inverse_operator(epochs.info, forward, noise_cov,
loose=None, depth=None)
write_inverse_operator(local_inv_file_name, inverse_operator)
return inverse_operator
def test_stc_as_volume():
"""Test previous volume source estimate morph."""
import nibabel as nib
inverse_operator_vol = read_inverse_operator(fname_inv_vol)
# Apply inverse operator
stc_vol = read_source_estimate(fname_vol, 'sample')
img = stc_vol.as_volume(inverse_operator_vol['src'], mri_resolution=True,
dest='42')
t1_img = nib.load(fname_t1)
# always assure nifti and dimensionality
assert isinstance(img, nib.Nifti1Image)
assert img.header.get_zooms()[:3] == t1_img.header.get_zooms()[:3]
img = stc_vol.as_volume(inverse_operator_vol['src'], mri_resolution=False)
assert isinstance(img, nib.Nifti1Image)
assert img.shape[:3] == inverse_operator_vol['src'][0]['shape'][:3]
with pytest.raises(ValueError, match='invalid output'):
stc_vol.as_volume(inverse_operator_vol['src'], format='42')
def test_extract_label_time_course():
"""Test extraction of label time courses from stc."""
n_stcs = 3
n_times = 50
src = read_inverse_operator(fname_inv)['src']
vertices = [src[0]['vertno'], src[1]['vertno']]
n_verts = len(vertices[0]) + len(vertices[1])
# get some labels
labels_lh = read_labels_from_annot('sample',
hemi='lh',
subjects_dir=subjects_dir)
labels_rh = read_labels_from_annot('sample',
hemi='rh',
subjects_dir=subjects_dir)
labels = list()
labels.extend(labels_lh[:5])
labels.extend(labels_rh[:4])
n_labels = len(labels)
label_means = np.arange(n_labels)[:, None] * np.ones((n_labels, n_times))
label_maxs = np.arange(n_labels)[:, None] * np.ones((n_labels, n_times))
# compute the mean with sign flip
label_means_flipped = np.zeros_like(label_means)
for i, label in enumerate(labels):
label_means_flipped[i] = i * np.mean(label_sign_flip(label, src))
# generate some stc's with known data
stcs = list()
for i in range(n_stcs):
data = np.zeros((n_verts, n_times))
# set the value of the stc within each label
for j, label in enumerate(labels):
if label.hemi == 'lh':
idx = np.intersect1d(vertices[0], label.vertices)
idx = np.searchsorted(vertices[0], idx)
elif label.hemi == 'rh':
idx = np.intersect1d(vertices[1], label.vertices)
idx = len(vertices[0]) + np.searchsorted(vertices[1], idx)
data[idx] = label_means[j]
this_stc = SourceEstimate(data, vertices, 0, 1)
stcs.append(this_stc)
# test some invalid inputs
pytest.raises(ValueError,
extract_label_time_course,
stcs,
labels,
src,
mode='notamode')
# have an empty label
empty_label = labels[0].copy()
empty_label.vertices += 1000000
pytest.raises(ValueError,
extract_label_time_course,
stcs,
empty_label,
src,
mode='mean')
# but this works:
with pytest.warns(RuntimeWarning, match='does not contain any vertices'):
tc = extract_label_time_course(stcs,
empty_label,
src,
mode='mean',
allow_empty=True)
for arr in tc:
assert (arr.shape == (1, n_times))
assert_array_equal(arr, np.zeros((1, n_times)))
# test the different modes
modes = ['mean', 'mean_flip', 'pca_flip', 'max']
for mode in modes:
label_tc = extract_label_time_course(stcs, labels, src, mode=mode)
label_tc_method = [
stc.extract_label_time_course(labels, src, mode=mode)
for stc in stcs
]
assert (len(label_tc) == n_stcs)
assert (len(label_tc_method) == n_stcs)
for tc1, tc2 in zip(label_tc, label_tc_method):
assert (tc1.shape == (n_labels, n_times))
assert (tc2.shape == (n_labels, n_times))
assert (np.allclose(tc1, tc2, rtol=1e-8, atol=1e-16))
if mode == 'mean':
assert_array_almost_equal(tc1, label_means)
if mode == 'mean_flip':
assert_array_almost_equal(tc1, label_means_flipped)
if mode == 'max':
assert_array_almost_equal(tc1, label_maxs)
# test label with very few vertices (check SVD conditionals)
label = Label(vertices=src[0]['vertno'][:2], hemi='lh')
x = label_sign_flip(label, src)
assert (len(x) == 2)
label = Label(vertices=[], hemi='lh')
x = label_sign_flip(label, src)
assert (x.size == 0)
# Reading epochs
epo_name_SD = data_path + meg + 'block_SD_words_epochs-epo.fif'
epo_name_LD = data_path + meg + 'block_LD_words_epochs-epo.fif'
epochs_sd = mne.read_epochs(epo_name_SD, preload=True)
epochs_ld = mne.read_epochs(epo_name_LD, preload=True)
epochs_SD = epochs_sd['words']
epochs_LD = epochs_ld['words']
# Reading inverse operator
inv_fname_SD = data_path + meg + 'InvOp_SD_EMEG-inv.fif'
inv_fname_LD = data_path + meg + 'InvOp_LD_EMEG-inv.fif'
inv_op_SD = read_inverse_operator(inv_fname_SD)
inv_op_LD = read_inverse_operator(inv_fname_LD)
# Evoked responses
evoked_sd = epochs_SD.average().set_eeg_reference(ref_channels = \
'average',projection=True)
evoked_ld = epochs_LD.average().set_eeg_reference(ref_channels = \
'average',projection=True)
evoked_SD = evoked_sd.copy().resample(500)
evoked_LD = evoked_ld.copy().resample(500)
# evoked_SD = evoked_sd.copy()
# evoked_LD = evoked_ld.copy()
# Applying inverse solution to get sourse signals
stc_sd = apply_inverse(evoked_SD, inv_op_SD,lambda2,method ='MNE',
def test_source_psd_epochs(method):
"""Test multi-taper source PSD computation in label from epochs."""
raw = read_raw_fif(fname_data)
inverse_operator = read_inverse_operator(fname_inv)
label = read_label(fname_label)
event_id, tmin, tmax = 1, -0.2, 0.5
lambda2 = 1. / 9.
bandwidth = 8.
fmin, fmax = 0, 100
picks = pick_types(raw.info, meg=True, eeg=False, stim=True,
ecg=True, eog=True, include=['STI 014'],
exclude='bads')
reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)
events = find_events(raw, stim_channel='STI 014')
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=(None, 0), reject=reject)
# only look at one epoch
epochs.drop_bad()
one_epochs = epochs[:1]
inv = prepare_inverse_operator(inverse_operator, nave=1,
lambda2=1. / 9., method="dSPM")
# return list
stc_psd = compute_source_psd_epochs(one_epochs, inv,
lambda2=lambda2, method=method,
pick_ori="normal", label=label,
bandwidth=bandwidth,
fmin=fmin, fmax=fmax,
prepared=True)[0]
# return generator
stcs = compute_source_psd_epochs(one_epochs, inv,
lambda2=lambda2, method=method,
pick_ori="normal", label=label,
bandwidth=bandwidth,
fmin=fmin, fmax=fmax,
return_generator=True,
prepared=True)
for stc in stcs:
stc_psd_gen = stc
assert_allclose(stc_psd.data, stc_psd_gen.data, atol=1e-7)
# compare with direct computation
stc = apply_inverse_epochs(one_epochs, inv,
lambda2=lambda2, method=method,
pick_ori="normal", label=label,
prepared=True)[0]
sfreq = epochs.info['sfreq']
psd, freqs = psd_array_multitaper(stc.data, sfreq=sfreq,
bandwidth=bandwidth, fmin=fmin,
fmax=fmax)
assert_allclose(psd, stc_psd.data, atol=1e-7)
assert_allclose(freqs, stc_psd.times)
# Check corner cases caused by tiny bandwidth
with pytest.raises(ValueError, match='use a value of at least'):
compute_source_psd_epochs(
one_epochs, inv, lambda2=lambda2, method=method,
pick_ori="normal", label=label, bandwidth=0.01, low_bias=True,
fmin=fmin, fmax=fmax, return_generator=False, prepared=True)
from mne.minimum_norm import read_inverse_operator, apply_inverse_epochs
from my_settings import (mne_folder, epochs_folder, source_folder)
subject = sys.argv[1]
method = "dSPM"
snr = 1.
lambda2 = 1. / snr**2
labels = mne.read_labels_from_annot(
subject=subject, parc="PALS_B12_Brodmann", regexp="Brodmann")
condition = "interupt"
inv = read_inverse_operator(mne_folder + "%s_%s-inv.fif" % (subject, condition
))
epochs = mne.read_epochs(epochs_folder + "%s_%s-epo.fif" % (subject, condition
))
# epochs.resample(500)
stcs = apply_inverse_epochs(
epochs["press"], inv, lambda2, method=method, pick_ori=None)
ts = [
mne.extract_label_time_course(
stc, labels, inv["src"], mode="mean_flip") for stc in stcs
]
# for h, tc in enumerate(ts):
# for j, t in enumerate(tc):
# t *= np.sign(t[np.argmax(np.abs(t))])
# tc[j, :] = t
def SN_functional_connectivity_betweenROIs(i, method):
s = time.time()
meg = subjects[i]
sub_to = MRI_sub[i][1:15]
con_SD_file_name = os.path.expanduser(
'~'
) + '/my_semnet/json_files/connectivity/con_labels_' + method + '_bands_SD_sub' + str(
i) + '.json'
con_LD_file_name = os.path.expanduser(
'~'
) + '/my_semnet/json_files/connectivity/con_labels_' + method + '_bands_LD_sub' + str(
i) + '.json'
morphed_labels = mne.morph_labels(SN_ROI,subject_to=data_path+sub_to,\
subject_from='fsaverage',subjects_dir=data_path)
# Reading epochs
epo_name_SD = data_path + meg + 'block_SD_words_epochs-epo.fif'
epo_name_LD = data_path + meg + 'block_LD_words_epochs-epo.fif'
epochs_sd = mne.read_epochs(epo_name_SD, preload=True)
epochs_ld = mne.read_epochs(epo_name_LD, preload=True)
epochs_SD = epochs_sd['words'].copy().resample(500)
epochs_LD = epochs_ld['words'].copy().resample(500)
# Equalize trial counts to eliminate bias
equalize_epoch_counts([epochs_SD, epochs_LD])
# Reading inverse operator
inv_fname_SD = data_path + meg + 'InvOp_SD_EMEG-inv.fif'
inv_fname_LD = data_path + meg + 'InvOp_LD_EMEG-inv.fif'
inv_op_SD = read_inverse_operator(inv_fname_SD)
inv_op_LD = read_inverse_operator(inv_fname_LD)
stc_sd = apply_inverse_epochs(epochs_SD,
inv_op_SD,
lambda2,
method='MNE',
pick_ori="normal",
return_generator=False)
stc_ld = apply_inverse_epochs(epochs_LD,
inv_op_LD,
lambda2,
method='MNE',
pick_ori="normal",
return_generator=False)
times = epochs_SD.times
stc_SD_t = []
stc_LD_t = []
src_SD = inv_op_SD['src']
src_LD = inv_op_LD['src']
for n in np.arange(0, len(stc_sd)):
stc_SD_t.append(stc_baseline_correction(stc_sd[n], times))
stc_LD_t.append(stc_baseline_correction(stc_ld[n], times))
for win in np.arange(0, len(C.con_time_window) - 1):
print('[i,win]: ', i, win)
t_min = C.con_time_window[win]
t_max = C.con_time_window[win + 1]
stc_SD = []
stc_LD = []
for n in np.arange(0, len(stc_sd)):
stc_SD.append(stc_SD_t[n].copy().crop(t_min * 1e-3, t_max * 1e-3))
stc_LD.append(stc_LD_t[n].copy().crop(t_min * 1e-3, t_max * 1e-3))
for k in np.arange(0, 6):
# print('[i,win,k]: ',i,win,k)
morphed_labels[k].name = C.rois_labels[k]
labels_ts_sd = mne.extract_label_time_course(stc_SD, morphed_labels, \
src_SD, mode='mean_flip',return_generator=False)
labels_ts_ld = mne.extract_label_time_course(stc_LD, morphed_labels, \
src_LD, mode='mean_flip',return_generator=False)
for f in np.arange(0, len(C.con_freq_band) - 1):
print('[i,win,k,f]: ', i, win, k, f)
f_min = C.con_freq_band[f]
f_max = C.con_freq_band[f + 1]
print(f_min, f_max)
con_SD, freqs, times, n_epochs, n_tapers = spectral_connectivity(
labels_ts_sd,
method=method,
mode='fourier',
sfreq=500,
fmin=f_min,
fmax=f_max,
faverage=True,
n_jobs=10)
con_LD, freqs, times, n_epochs, n_tapers = spectral_connectivity(
labels_ts_ld,
method=method,
mode='fourier',
sfreq=500,
fmin=f_min,
fmax=f_max,
faverage=True,
n_jobs=10)
con_labels_SD[win][f] = con_SD.reshape(6, 6)
con_labels_LD[win][f] = con_LD.reshape(6, 6)
with open(con_SD_file_name, "wb") as fp: #Pickling
pickle.dump(con_labels_SD, fp)
with open(con_LD_file_name, "wb") as fp: #Pickling
pickle.dump(con_labels_LD, fp)
e = time.time()
print(e - s)
def test_extract_label_time_course():
"""Test extraction of label time courses from stc
"""
n_stcs = 3
n_times = 50
src = read_inverse_operator(fname_inv)['src']
vertices = [src[0]['vertno'], src[1]['vertno']]
n_verts = len(vertices[0]) + len(vertices[1])
# get some labels
labels_lh, _ = labels_from_parc('sample', hemi='lh',
subjects_dir=subjects_dir)
labels_rh, _ = labels_from_parc('sample', hemi='rh',
subjects_dir=subjects_dir)
labels = list()
labels.extend(labels_lh[:5])
labels.extend(labels_rh[:4])
n_labels = len(labels)
label_means = np.arange(n_labels)[:, None] * np.ones((n_labels, n_times))
# compute the mean with sign flip
label_means_flipped = np.zeros_like(label_means)
for i, label in enumerate(labels):
label_means_flipped[i] = i * np.mean(label_sign_flip(label, src))
# generate some stc's with known data
stcs = list()
for i in range(n_stcs):
data = np.zeros((n_verts, n_times))
# set the value of the stc within each label
for j, label in enumerate(labels):
if label.hemi == 'lh':
idx = np.intersect1d(vertices[0], label.vertices)
idx = np.searchsorted(vertices[0], idx)
elif label.hemi == 'rh':
idx = np.intersect1d(vertices[1], label.vertices)
idx = len(vertices[0]) + np.searchsorted(vertices[1], idx)
data[idx] = label_means[j]
this_stc = SourceEstimate(data, vertices, 0, 1)
stcs.append(this_stc)
# test some invalid inputs
assert_raises(ValueError, extract_label_time_course, stcs, labels,
src, mode='notamode')
# have an empty label
empty_label = labels[0].copy()
empty_label.vertices += 1000000
assert_raises(ValueError, extract_label_time_course, stcs, empty_label,
src, mode='mean')
# but this works:
tc = extract_label_time_course(stcs, empty_label, src, mode='mean',
allow_empty=True)
for arr in tc:
assert_true(arr.shape == (1, n_times))
assert_array_equal(arr, np.zeros((1, n_times)))
# test the different modes
modes = ['mean', 'mean_flip', 'pca_flip']
for mode in modes:
label_tc = extract_label_time_course(stcs, labels, src, mode=mode)
label_tc_method = [stc.extract_label_time_course(labels, src,
mode=mode) for stc in stcs]
assert_true(len(label_tc) == n_stcs)
assert_true(len(label_tc_method) == n_stcs)
for tc1, tc2 in zip(label_tc, label_tc_method):
assert_true(tc1.shape == (n_labels, n_times))
assert_true(tc2.shape == (n_labels, n_times))
assert_true(np.allclose(tc1, tc2, rtol=1e-8, atol=1e-16))
if mode == 'mean':
assert_array_almost_equal(tc1, label_means)
if mode == 'mean_flip':
assert_array_almost_equal(tc1, label_means_flipped)
import mne from mne.datasets import sample from mne.minimum_norm import read_inverse_operator, apply_inverse print(__doc__) data_path = sample.data_path() subjects_dir = data_path + '/subjects' # Read evoked data fname_evoked = data_path + '/MEG/sample/sample_audvis-ave.fif' evoked = mne.read_evokeds(fname_evoked, condition=0, baseline=(None, 0)) # Read inverse solution fname_inv = data_path + '/MEG/sample/sample_audvis-meg-oct-6-meg-inv.fif' inv = read_inverse_operator(fname_inv) # Apply inverse solution, set pick_ori='vector' to obtain a # :class:`mne.VectorSourceEstimate` object snr = 3.0 lambda2 = 1.0 / snr**2 stc = apply_inverse(evoked, inv, lambda2, 'dSPM', pick_ori='vector') # Use peak getter to move visualization to the time point of the peak magnitude _, peak_time = stc.magnitude().get_peak(hemi='lh') ############################################################################### # Plot the source estimate: brain = stc.plot(initial_time=peak_time, hemi='lh', subjects_dir=subjects_dir) ###############################################################################
def SN_functional_connectivity_bands(i, method):
s = time.time()
meg = subjects[i]
sub_to = MRI_sub[i][1:15]
stc_SD_file_name = os.path.expanduser(
'~'
) + '/my_semnet/json_files/connectivity/stc_' + method + '200_equalized_bands_SD_sub' + str(
i) + '.json'
stc_LD_file_name = os.path.expanduser(
'~'
) + '/my_semnet/json_files/connectivity/stc_' + method + '200_equalized_bands_LD_sub' + str(
i) + '.json'
# stc_SD_file_name=os.path.expanduser('~') +'/my_semnet/json_files/connectivity/stc_'+method+'bl_bands_SD_sub'+str(i)+'.json'
# stc_LD_file_name=os.path.expanduser('~') +'/my_semnet/json_files/connectivity/stc_'+method+'bl_bands_LD_sub'+str(i)+'.json'
morphed_labels = mne.morph_labels(SN_ROI,subject_to=data_path+sub_to,\
subject_from='fsaverage',subjects_dir=data_path)
# Reading epochs
epo_name_SD = data_path + meg + 'block_SD_words_epochs-epo.fif'
epo_name_LD = data_path + meg + 'block_LD_words_epochs-epo.fif'
epochs_sd = mne.read_epochs(epo_name_SD, preload=True)
epochs_ld = mne.read_epochs(epo_name_LD, preload=True)
epochs_SD = epochs_sd['words'].copy().resample(500)
epochs_LD = epochs_ld['words'].copy().resample(500)
equalize_epoch_counts([epochs_SD, epochs_LD])
# Reading inverse operator
inv_fname_SD = data_path + meg + 'InvOp_SD_EMEG-inv.fif'
inv_fname_LD = data_path + meg + 'InvOp_LD_EMEG-inv.fif'
inv_op_SD = read_inverse_operator(inv_fname_SD)
inv_op_LD = read_inverse_operator(inv_fname_LD)
stc_sd = apply_inverse_epochs(epochs_SD,
inv_op_SD,
lambda2,
method='MNE',
pick_ori="normal",
return_generator=False)
stc_ld = apply_inverse_epochs(epochs_LD,
inv_op_LD,
lambda2,
method='MNE',
pick_ori="normal",
return_generator=False)
src_SD = inv_op_SD['src']
src_LD = inv_op_LD['src']
# Construct indices to estimate connectivity between the label time course
# and all source space time courses
vertices_SD = [src_SD[j]['vertno'] for j in range(2)]
n_signals_tot = 1 + len(vertices_SD[0]) + len(vertices_SD[1])
indices = seed_target_indices([0], np.arange(1, n_signals_tot))
morph_SD = mne.compute_source_morph(src=inv_op_SD['src'],\
subject_from=sub_to, subject_to=C.subject_to,\
spacing=C.spacing_morph, subjects_dir=C.data_path)
morph_LD = mne.compute_source_morph(src= inv_op_LD['src'],\
subject_from=sub_to, subject_to=C.subject_to,\
spacing=C.spacing_morph, subjects_dir=C.data_path)
for win in np.arange(0, len(C.con_time_window) - 1):
print('[i,win]: ', i, win)
t_min = C.con_time_window[win]
t_max = C.con_time_window[win + 1]
stc_SD = []
stc_LD = []
for n in np.arange(0, len(stc_sd)):
stc_SD.append(stc_sd[n].copy().crop(t_min * 1e-3, t_max * 1e-3))
for n in np.arange(0, len(stc_ld)):
stc_LD.append(stc_ld[n].copy().crop(t_min * 1e-3, t_max * 1e-3))
for k in np.arange(0, 6):
print('[i,win,k]: ', i, win, k)
morphed_labels[k].name = C.rois_labels[k]
seed_ts_sd = mne.extract_label_time_course(stc_SD, morphed_labels[k], \
src_SD, mode='mean_flip',return_generator=False)
seed_ts_ld = mne.extract_label_time_course(stc_LD, morphed_labels[k], \
src_LD, mode='mean_flip',return_generator=False)
for f in np.arange(0, len(C.con_freq_band) - 1):
print('[i,win,k,f]: ', i, win, k, f)
f_min = C.con_freq_band[f]
f_max = C.con_freq_band[f + 1]
print(f_min, f_max)
comb_ts_sd = zip(seed_ts_sd, stc_SD)
comb_ts_ld = zip(seed_ts_ld, stc_LD)
con_SD, freqs, times, n_epochs, n_tapers = spectral_connectivity(
comb_ts_sd,
method=method,
mode='fourier',
indices=indices,
sfreq=500,
fmin=f_min,
fmax=f_max,
faverage=True,
n_jobs=10)
con_LD, freqs, times, n_epochs, n_tapers = spectral_connectivity(
comb_ts_ld,
method=method,
mode='fourier',
indices=indices,
sfreq=500,
fmin=f_min,
fmax=f_max,
faverage=True,
n_jobs=10)
con_stc_SD = mne.SourceEstimate(con_SD, vertices=vertices_SD,\
tmin=t_min*1e-3, tstep=2e-3,subject=sub_to)
con_stc_LD = mne.SourceEstimate(con_LD, vertices=vertices_SD,\
tmin=t_min*1e-3, tstep=2e-3,subject=sub_to)
stc_total_SD[win][k][f] = morph_SD.apply(con_stc_SD)
stc_total_LD[win][k][f] = morph_LD.apply(con_stc_LD)
with open(stc_SD_file_name, "wb") as fp: #Pickling
pickle.dump(stc_total_SD, fp)
with open(stc_LD_file_name, "wb") as fp: #Pickling
pickle.dump(stc_total_LD, fp)
e = time.time()
print(e - s)
from metacog.utils import setup_logging
logger = setup_logging(__file__)
parser = ArgumentParser(description=__doc__)
parser.add_argument("subject", help="subject id")
args = parser.parse_args()
subj = args.subject
fwd_path = bp.fwd.fpath(subject=subj)
fwd = read_forward_solution(fwd_path)
inv_path = bp.inv.fpath(subject=subj)
epochs_path = bp.epochs.fpath(subject=subj)
epochs = read_epochs(epochs_path)["answer"]
inverse_operator = read_inverse_operator(inv_path)
# stcs_low = source_band_induced_power(
# epochs["low"],
# inverse_operator,
# bands,
# n_cycles=2,
# use_fft=False,
# n_jobs=4,
# decim=2,
# baseline=(-1, 0),
# )
epochs_active = epochs.copy().crop(tmin=cfg.config_sources["active_win"][0],
tmax=cfg.config_sources["active_win"][1])
epochs_base = epochs.copy().crop(
def test_plot_snr():
"""Test plotting SNR estimate."""
inv = read_inverse_operator(inv_fname)
evoked = read_evokeds(evoked_fname, baseline=(None, 0))[0]
plot_snr_estimate(evoked, inv)
# params
for subject in subjects:
print (subject)
subj_dir = '%s%s/'%(meg_dir,subject)
# paths
epochs_fname = subj_dir + subject+ '_shepard-epo.fif'
inv_fname = subj_dir+subject+'_shepard-inv.fif'
print ("Loading variables...")
epochs = read_epochs(epochs_fname)
epochs.metadata['freq'].replace(524,523,inplace=True)
inverse_operator = read_inverse_operator(inv_fname)
src = inverse_operator['src']
# make stcs for each frequency for each tonetype
for tonetype in tonetypes:
print("Beginning %s tones..."%(tonetype))
# frequencies = np.sort(epochs.metadata[np.logical_and(epochs.metadata['key']==key,
# epochs.metadata['condition']==tonetype)].freq.unique())
for freq in frequencies:
print(freq)
freq_epochs = epochs[(epochs.metadata['condition']==tonetype) &
(epochs.metadata['freq']==freq) &
(epochs.metadata['key']==key)]
evoked = freq_epochs.average()
# if there is no baseline, e.g., in resting state data
# there is no stimulus, use empty room noise cov
fn_cov = fn_epo.split('-epo.fif')[0] + '-cov.fif'
fn_inv = fn_epo.rsplit('-epo.fif')[0] + '-inv.fif'
# to read forward solution and noise_cov
noise_cov = mne.read_cov(fn_cov)
if not op.isfile(fn_inv):
# compute the inverse operator (mne_do_inverse_operator)
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)
else:
inv = read_inverse_operator(fn_inv)
evoked = epochs.average()
# Compute inverse solution for evoked data
fn_stc = fn_epo.rsplit('-epo.fif')[0] + ',ave'
if not op.isfile(fn_stc + '-lh.stc'):
stc = apply_inverse(evoked, inv, lambda2, method, pick_ori=None)
stc.save(fn_stc)
print('Saved...', fn_stc + '-lh.stc')
if plot_stc:
stc = mne.read_source_estimate(fn_stc + '-lh.stc')
pos, t_peak = stc.get_peak(hemi=None, tmin=0., tmax=0.5,
from mne.minimum_norm import read_inverse_operator, apply_inverse
from my_settings import (mne_folder, epochs_folder, conditions, source_folder)
subject = sys.argv[1]
method = "dSPM"
snr = 3.
lambda2 = 1. / snr**2
labels = mne.read_labels_from_annot(subject=subject,
parc="PALS_B12_Brodmann",
regexp="Brodmann")
for condition in conditions:
inv = read_inverse_operator(mne_folder + "%s_%s-inv.fif" %
(subject, condition))
evoked = mne.read_evokeds(epochs_folder + "%s_%s-ave.fif" %
(subject, condition))[0]
stc = apply_inverse(evoked, inv, lambda2, method=method, pick_ori=None)
ts = mne.extract_label_time_course(stc,
labels,
inv["src"],
mode="mean_flip")
# for j, t in enumerate(ts):
# t *= np.sign(t[np.argmax(np.abs(t))])
# ts[j, :] = t
stc.save(source_folder + "%s_%s_ave" % (subject, condition))
np.save(source_folder + "ave_ts/%s_%s_ts.npy" % (subject, condition), ts)
def SN_functional_connectivity_bands_runs(i, method, SN_ROI):
s = time.time()
meg = subjects[i]
sub_to = MRI_sub[i][1:15]
stc_F_file_name = os.path.expanduser(
'~'
) + '/old_semnet/my_semnet/json_files/connectivity/stc_' + method + '200_F_bands_SD_sub' + str(
i) + '.json'
stc_O_file_name = os.path.expanduser(
'~'
) + '/old_semnet/my_semnet/json_files/connectivity/stc_' + method + '200_O_bands_LD_sub' + str(
i) + '.json'
stc_M_file_name = os.path.expanduser(
'~'
) + '/old_semnet/my_semnet/json_files/connectivity/stc_' + method + '200_M_bands_SD_sub' + str(
i) + '.json'
stc_SD_file_name = os.path.expanduser(
'~'
) + '/old_semnet/my_semnet/json_files/connectivity/stc_' + method + '200_mean_bands_SD_sub' + str(
i) + '.json'
stc_LD_file_name = os.path.expanduser(
'~'
) + '/old_semnet/my_semnet/json_files/connectivity/stc_' + method + '200_mean_bands_LD_sub' + str(
i) + '.json'
morphed_labels = mne.morph_labels(SN_ROI,
subject_to=sub_to,
subject_from='fsaverage',
subjects_dir=data_path)
# Reading epochs
# Reading epochs
epo_name_LD = data_path + meg + 'block_LD_words_epochs-epo.fif'
epochs_ld = mne.read_epochs(epo_name_LD, preload=True)
epochs_LD = epochs_ld['words'].copy().resample(500)
epoch_fname_fruit = data_path + meg + 'block_fruit_epochs-epo.fif'
epoch_fname_odour = data_path + meg + 'block_odour_epochs-epo.fif'
epoch_fname_milk = data_path + meg + 'block_milk_epochs-epo.fif'
epochs_fruit = mne.read_epochs(epoch_fname_fruit, preload=True)
epochs_odour = mne.read_epochs(epoch_fname_odour, preload=True)
epochs_milk = mne.read_epochs(epoch_fname_milk, preload=True)
epochs_f = mne.epochs.combine_event_ids(
epochs_fruit, ['visual', 'hear', 'hand', 'neutral', 'emotional'],
{'words': 15})
epochs_o = mne.epochs.combine_event_ids(
epochs_odour, ['visual', 'hear', 'hand', 'neutral', 'emotional'],
{'words': 15})
epochs_m = mne.epochs.combine_event_ids(
epochs_milk, ['visual', 'hear', 'hand', 'neutral', 'emotional'],
{'words': 15})
epochs_f = epochs_f['words'].copy().resample(500)
epochs_o = epochs_o['words'].copy().resample(500)
epochs_m = epochs_m['words'].copy().resample(500)
# Reading inverse operator
inv_fname_SD = data_path + meg + 'InvOp_SD_EMEG-inv.fif'
inv_fname_LD = data_path + meg + 'InvOp_LD_EMEG-inv.fif'
inv_op_SD = read_inverse_operator(inv_fname_SD)
inv_op_LD = read_inverse_operator(inv_fname_LD)
stc_f = apply_inverse_epochs(epochs_f,
inv_op_SD,
lambda2,
method='MNE',
pick_ori="normal",
return_generator=False)
stc_o = apply_inverse_epochs(epochs_o,
inv_op_SD,
lambda2,
method='MNE',
pick_ori="normal",
return_generator=False)
stc_m = apply_inverse_epochs(epochs_m,
inv_op_SD,
lambda2,
method='MNE',
pick_ori="normal",
return_generator=False)
stc_ld = apply_inverse_epochs(epochs_LD,
inv_op_LD,
lambda2,
method='MNE',
pick_ori="normal",
return_generator=False)
src_SD = inv_op_SD['src']
src_LD = inv_op_LD['src']
# Construct indices to estimate connectivity between the label time course
# and all source space time courses
vertices_SD = [src_SD[j]['vertno'] for j in range(2)]
n_signals_tot = 1 + len(vertices_SD[0]) + len(vertices_SD[1])
indices = seed_target_indices([0], np.arange(1, n_signals_tot))
morph_SD = mne.compute_source_morph(src=inv_op_SD['src'],
subject_from=sub_to,
subject_to=C.subject_to,
spacing=C.spacing_morph,
subjects_dir=C.data_path)
morph_LD = mne.compute_source_morph(src=inv_op_LD['src'],
subject_from=sub_to,
subject_to=C.subject_to,
spacing=C.spacing_morph,
subjects_dir=C.data_path)
for win in np.arange(0, len(C.con_time_window) - 1):
print('[i,win]: ', i, win)
t_min = C.con_time_window[win]
t_max = C.con_time_window[win + 1]
stc_F = []
stc_O = []
stc_M = []
stc_LD = []
for n in np.arange(0, len(stc_f)):
stc_F.append(stc_f[n].copy().crop(t_min * 1e-3, t_max * 1e-3))
for n in np.arange(0, len(stc_o)):
stc_O.append(stc_o[n].copy().crop(t_min * 1e-3, t_max * 1e-3))
for n in np.arange(0, len(stc_m)):
stc_M.append(stc_m[n].copy().crop(t_min * 1e-3, t_max * 1e-3))
for n in np.arange(0, len(stc_ld)):
stc_LD.append(stc_ld[n].copy().crop(t_min * 1e-3, t_max * 1e-3))
for k in np.arange(0, 6):
print('[i,win,k]: ', i, win, k)
morphed_labels[k].name = C.rois_labels[k]
seed_ts_f = mne.extract_label_time_course(stc_F,
morphed_labels[k],
src_SD,
mode='mean_flip',
return_generator=False)
seed_ts_o = mne.extract_label_time_course(stc_O,
morphed_labels[k],
src_SD,
mode='mean_flip',
return_generator=False)
seed_ts_m = mne.extract_label_time_course(stc_M,
morphed_labels[k],
src_SD,
mode='mean_flip',
return_generator=False)
seed_ts_ld = mne.extract_label_time_course(stc_LD,
morphed_labels[k],
src_LD,
mode='mean_flip',
return_generator=False)
for f in np.arange(0, len(C.con_freq_band) - 1):
print('[i,win,k,f]: ', i, win, k, f)
f_min = C.con_freq_band[f]
f_max = C.con_freq_band[f + 1]
print(f_min, f_max)
comb_ts_f = zip(seed_ts_f, stc_F)
comb_ts_o = zip(seed_ts_o, stc_O)
comb_ts_m = zip(seed_ts_m, stc_M)
comb_ts_ld = zip(seed_ts_ld, stc_LD)
con_F, freqs, times, n_epochs, n_tapers = spectral_connectivity(
comb_ts_f,
method=method,
mode='fourier',
indices=indices,
sfreq=500,
fmin=f_min,
fmax=f_max,
faverage=True,
n_jobs=10)
con_O, freqs, times, n_epochs, n_tapers = spectral_connectivity(
comb_ts_o,
method=method,
mode='fourier',
indices=indices,
sfreq=500,
fmin=f_min,
fmax=f_max,
faverage=True,
n_jobs=10)
con_M, freqs, times, n_epochs, n_tapers = spectral_connectivity(
comb_ts_m,
method=method,
mode='fourier',
indices=indices,
sfreq=500,
fmin=f_min,
fmax=f_max,
faverage=True,
n_jobs=10)
con_LD, freqs, times, n_epochs, n_tapers = spectral_connectivity(
comb_ts_ld,
method=method,
mode='fourier',
indices=indices,
sfreq=500,
fmin=f_min,
fmax=f_max,
faverage=True,
n_jobs=10)
con_SD = (con_F + con_O + con_M) / 3
con_stc_F = mne.SourceEstimate(con_F,
vertices=vertices_SD,
tmin=t_min * 1e-3,
tstep=2e-3,
subject=sub_to)
con_stc_O = mne.SourceEstimate(con_O,
vertices=vertices_SD,
tmin=t_min * 1e-3,
tstep=2e-3,
subject=sub_to)
con_stc_M = mne.SourceEstimate(con_M,
vertices=vertices_SD,
tmin=t_min * 1e-3,
tstep=2e-3,
subject=sub_to)
con_stc_SD = mne.SourceEstimate(con_SD,
vertices=vertices_SD,
tmin=t_min * 1e-3,
tstep=2e-3,
subject=sub_to)
con_stc_LD = mne.SourceEstimate(con_LD,
vertices=vertices_SD,
tmin=t_min * 1e-3,
tstep=2e-3,
subject=sub_to)
stc_total_F[win][k][f] = morph_SD.apply(con_stc_F)
stc_total_O[win][k][f] = morph_SD.apply(con_stc_O)
stc_total_M[win][k][f] = morph_SD.apply(con_stc_M)
stc_total_SD[win][k][f] = morph_SD.apply(con_stc_SD)
stc_total_LD[win][k][f] = morph_LD.apply(con_stc_LD)
# with open(stc_F_file_name, "wb") as fp: #Pickling
# pickle.dump(stc_total_F, fp)
# with open(stc_O_file_name, "wb") as fp: #Pickling
# pickle.dump(stc_total_O, fp)
# with open(stc_M_file_name, "wb") as fp: #Pickling
# pickle.dump(stc_total_M, fp)
# with open(stc_SD_file_name, "wb") as fp: #Pickling
# pickle.dump(stc_total_SD, fp)
with open(stc_LD_file_name, "wb") as fp: # Pickling
pickle.dump(stc_total_LD, fp)
e = time.time()
print(e - s)
def test_apply_inverse_operator(evoked, inv, min_, max_):
"""Test MNE inverse application."""
# use fname_inv as it will be faster than fname_full (fewer verts and chs)
inverse_operator = read_inverse_operator(inv)
# Inverse has 306 channels - 4 proj = 302
assert (compute_rank_inverse(inverse_operator) == 302)
# Inverse has 306 channels - 4 proj = 302
assert (compute_rank_inverse(inverse_operator) == 302)
stc = apply_inverse(evoked, inverse_operator, lambda2, "MNE")
assert stc.subject == 'sample'
assert stc.data.min() > min_
assert stc.data.max() < max_
assert abs(stc).data.mean() > 1e-11
# test if using prepared and not prepared inverse operator give the same
# result
inv_op = prepare_inverse_operator(inverse_operator, nave=evoked.nave,
lambda2=lambda2, method="MNE")
stc2 = apply_inverse(evoked, inv_op, lambda2, "MNE")
assert_array_almost_equal(stc.data, stc2.data)
assert_array_almost_equal(stc.times, stc2.times)
# This is little more than a smoke test...
stc = apply_inverse(evoked, inverse_operator, lambda2, "sLORETA")
assert stc.subject == 'sample'
assert abs(stc).data.min() > 0
assert 2 < stc.data.max() < 7
assert abs(stc).data.mean() > 0.1
stc = apply_inverse(evoked, inverse_operator, lambda2, "eLORETA")
assert stc.subject == 'sample'
assert abs(stc).data.min() > min_
assert stc.data.max() < max_ * 2
assert abs(stc).data.mean() > 1e-11
stc = apply_inverse(evoked, inverse_operator, lambda2, "dSPM")
assert stc.subject == 'sample'
assert abs(stc).data.min() > 0
assert 7.5 < stc.data.max() < 15
assert abs(stc).data.mean() > 0.1
# test without using a label (so delayed computation is used)
label = read_label(fname_label % 'Aud-lh')
for method in INVERSE_METHODS:
stc = apply_inverse(evoked, inv_op, lambda2, method)
stc_label = apply_inverse(evoked, inv_op, lambda2, method,
label=label)
assert_equal(stc_label.subject, 'sample')
label_stc = stc.in_label(label)
assert label_stc.subject == 'sample'
assert_allclose(stc_label.data, label_stc.data)
# Test that no errors are raised with loose inverse ops and picking normals
noise_cov = read_cov(fname_cov)
fwd = read_forward_solution_meg(fname_fwd)
inv_op_meg = make_inverse_operator(
evoked.info, fwd, noise_cov, loose=1,
fixed='auto', depth=None)
apply_inverse(evoked, inv_op_meg, 1 / 9., method='MNE', pick_ori='normal')
# Test we get errors when using custom ref or no average proj is present
evoked.info['custom_ref_applied'] = True
pytest.raises(ValueError, apply_inverse, evoked, inv_op, lambda2, "MNE")
evoked.info['custom_ref_applied'] = False
evoked.info['projs'] = [] # remove EEG proj
pytest.raises(ValueError, apply_inverse, evoked, inv_op, lambda2, "MNE")
# But test that we do not get EEG-related errors on MEG-only inv (gh-4650)
apply_inverse(evoked, inv_op_meg, 1. / 9.)
effects=['A','A:B']
for i in np.arange(0, len(subjects)-17):
n_subjects = len(subjects)
meg = subjects[i]
sub_to = MRI_sub[i][1:15]
print('Participant : ' , i)
for n in np.array([0]):
# Reading epochs
epo_name= data_path + meg + epochs_names[n]
epochs = mne.read_epochs(epo_name, preload=True)
epochs = epochs['words'].crop(-0.300,0.550).resample(500)
# Reading inverse operator
inv_fname = data_path + meg + inv_op_name[n]
inv_op = read_inverse_operator(inv_fname)
print('Participant: ' , i,'/ condition: ',n)
power, itc = source_induced_power(epochs,inverse_operator=\
inv_op, freqs=freq, label=None, lambda2=\
C.lambda2, method='MNE', baseline=(-.300,0), baseline_mode=\
'percent', n_jobs=6, n_cycles=n_cycles)
X[i,:,:] = power.copy().mean(1)
Y[i,:,:] = itc.copy().mean(1)
inv_fname_SD = data_path + meg + 'InvOp_SD_EMEG-inv.fif'
inv_op_SD = read_inverse_operator(inv_fname_SD)
morph_SD = mne.compute_source_morph( src= inv_op_SD['src'],subject_from\
= sub_to , subject_to = 'fsaverage' , spacing = \
def test_volume_source_morph():
"""Test volume source estimate morph, special cases and exceptions."""
import nibabel as nib
tempdir = _TempDir()
inverse_operator_vol = read_inverse_operator(fname_inv_vol)
stc_vol = read_source_estimate(fname_vol, 'sample')
# check for invalid input type
with pytest.raises(TypeError, match='src must be an instance of'):
compute_source_morph(src=42)
# check for raising an error if neither
# inverse_operator_vol['src'][0]['subject_his_id'] nor subject_from is set,
# but attempting to perform a volume morph
src = inverse_operator_vol['src']
src[0]['subject_his_id'] = None
with pytest.raises(ValueError, match='subject_from could not be inferred'):
compute_source_morph(src=src, subjects_dir=subjects_dir)
# check infer subject_from from src[0]['subject_his_id']
src[0]['subject_his_id'] = 'sample'
with pytest.raises(ValueError, match='Inter-hemispheric morphing'):
compute_source_morph(src=src, subjects_dir=subjects_dir, xhemi=True)
with pytest.raises(ValueError, match='Only surface.*sparse morph'):
compute_source_morph(src=src, sparse=True, subjects_dir=subjects_dir)
# terrible quality buts fast
zooms = 20
kwargs = dict(zooms=zooms, niter_sdr=(1,), niter_affine=(1,))
source_morph_vol = compute_source_morph(
subjects_dir=subjects_dir, src=inverse_operator_vol['src'], **kwargs)
shape = (13,) * 3 # for the given zooms
assert source_morph_vol.subject_from == 'sample'
# the brain used in sample data has shape (255, 255, 255)
assert tuple(source_morph_vol.sdr_morph.domain_shape) == shape
assert tuple(source_morph_vol.pre_affine.domain_shape) == shape
# proofs the above
assert_array_equal(source_morph_vol.zooms, (zooms,) * 3)
# assure proper src shape
mri_size = (src[0]['mri_height'], src[0]['mri_depth'], src[0]['mri_width'])
assert source_morph_vol.src_data['src_shape_full'] == mri_size
fwd = read_forward_solution(fname_fwd_vol)
source_morph_vol = compute_source_morph(
fwd['src'], 'sample', 'sample', subjects_dir=subjects_dir,
**kwargs)
# check wrong subject_to
with pytest.raises(IOError, match='cannot read file'):
compute_source_morph(fwd['src'], 'sample', '42',
subjects_dir=subjects_dir)
# two different ways of saving
source_morph_vol.save(op.join(tempdir, 'vol'))
# check loading
source_morph_vol_r = read_source_morph(
op.join(tempdir, 'vol-morph.h5'))
# check for invalid file name handling ()
with pytest.raises(IOError, match='not found'):
read_source_morph(op.join(tempdir, '42'))
# check morph
stc_vol_morphed = source_morph_vol.apply(stc_vol)
# check output as NIfTI
assert isinstance(source_morph_vol.apply(stc_vol, output='nifti2'),
nib.Nifti2Image)
# check for subject_from mismatch
source_morph_vol_r.subject_from = '42'
with pytest.raises(ValueError, match='subject_from must match'):
source_morph_vol_r.apply(stc_vol_morphed)
# check if nifti is in grid morph space with voxel_size == spacing
img_morph_res = source_morph_vol.apply(stc_vol, output='nifti1')
# assure morph spacing
assert isinstance(img_morph_res, nib.Nifti1Image)
assert img_morph_res.header.get_zooms()[:3] == (zooms,) * 3
# assure src shape
img_mri_res = source_morph_vol.apply(stc_vol, output='nifti1',
mri_resolution=True)
assert isinstance(img_mri_res, nib.Nifti1Image)
assert (img_mri_res.shape == (src[0]['mri_height'], src[0]['mri_depth'],
src[0]['mri_width']) +
(img_mri_res.shape[3],))
# check if nifti is defined resolution with voxel_size == (5., 5., 5.)
img_any_res = source_morph_vol.apply(stc_vol, output='nifti1',
mri_resolution=(5., 5., 5.))
assert isinstance(img_any_res, nib.Nifti1Image)
assert img_any_res.header.get_zooms()[:3] == (5., 5., 5.)
# check if morph outputs correct data
assert isinstance(stc_vol_morphed, VolSourceEstimate)
# check if loaded and saved objects contain the same
assert (all([read == saved for read, saved in
zip(sorted(source_morph_vol_r.__dict__),
sorted(source_morph_vol.__dict__))]))
# check __repr__
assert 'volume' in repr(source_morph_vol)
# check Nifti2Image
assert isinstance(
source_morph_vol.apply(stc_vol, mri_resolution=True,
mri_space=True, output='nifti2'),
nib.Nifti2Image)
# Degenerate conditions
with pytest.raises(TypeError, match='output must be'):
source_morph_vol.apply(stc_vol, output=1)
with pytest.raises(ValueError, match='subject_from does not match'):
compute_source_morph(src=src, subject_from='42')
with pytest.raises(ValueError, match='output must be one of'):
source_morph_vol.apply(stc_vol, output='42')
with pytest.raises(TypeError, match='subject_to must'):
compute_source_morph(src, 'sample', None,
subjects_dir=subjects_dir)
# Check if not morphed, but voxel size not boolean, raise ValueError.
# Note that this check requires dipy to not raise the dipy ImportError
# before checking if the actual voxel size error will raise.
with pytest.raises(ValueError, match='Cannot infer original voxel size'):
stc_vol.as_volume(inverse_operator_vol['src'], mri_resolution=4)
fname_fwd = data_path + '/MEG/sample/sample_audvis-meg-eeg-oct-6-fwd.fif'
fname_inv_eegmeg = (data_path +
'/MEG/sample/sample_audvis-meg-eeg-oct-6-meg-eeg-inv.fif')
fname_inv_meg = data_path + '/MEG/sample/sample_audvis-meg-oct-6-meg-inv.fif'
fname_label = [
data_path + '/MEG/sample/labels/Aud-rh.label',
data_path + '/MEG/sample/labels/Aud-lh.label',
data_path + '/MEG/sample/labels/Vis-rh.label',
data_path + '/MEG/sample/labels/Vis-lh.label'
]
# read forward solution
forward = mne.read_forward_solution(fname_fwd)
# read inverse operators
inverse_operator_eegmeg = read_inverse_operator(fname_inv_eegmeg)
inverse_operator_meg = read_inverse_operator(fname_inv_meg)
# read label(s)
labels = [mne.read_label(ss) for ss in fname_label]
# regularisation parameter
snr = 3.0
lambda2 = 1.0 / snr**2
method = 'MNE' # can be 'MNE' or 'sLORETA'
mode = 'svd'
n_svd_comp = 1
stc_psf_eegmeg, _ = point_spread_function(inverse_operator_eegmeg,
forward,
method=method,
The inverse operator's source space is shown in 3D.
"""
# Author: Alexandre Gramfort <*****@*****.**>
#
# License: BSD (3-clause)
from mne.datasets import sample
from mne.minimum_norm import read_inverse_operator
print(__doc__)
data_path = sample.data_path()
fname = data_path
fname += '/MEG/sample/sample_audvis-meg-oct-6-meg-inv.fif'
inv = read_inverse_operator(fname)
print("Method: %s" % inv['methods'])
print("fMRI prior: %s" % inv['fmri_prior'])
print("Number of sources: %s" % inv['nsource'])
print("Number of channels: %s" % inv['nchan'])
###############################################################################
# Show result on 3D source space
lh_points = inv['src'][0]['rr']
lh_faces = inv['src'][0]['use_tris']
rh_points = inv['src'][1]['rr']
rh_faces = inv['src'][1]['use_tris']
try:
from enthought.mayavi import mlab
except:
conditions = ['EngGram', 'EngUngram', 'JabGram', 'JabUngram']
method = "dSPM"
snr = 3.
lambda2 = 1. / snr**2
source = mne.read_source_spaces(
op.join(anat_path, 'BBC_249', 'bem', 'BBC_249-oct-6-src.fif'))
source_verts = [source[0]['vertno'], source[1]['vertno']]
for si, s in enumerate(subj):
fwd = mne.read_forward_solution(
op.join(data_path, '%s' % s, 'forward', '%s-sss-fwd.fif' % s))
cov = mne.read_cov(
op.join(data_path, '%s' % s, 'covariance', '%s-80-sss-cov.fif' % s))
inv = read_inverse_operator(
op.join(data_path, '%s' % s, 'inverse',
'%s-80-sss-meg-free-inv.fif' % s))
evokeds = [
mne.read_evokeds(op.join(data_path, '%s' % s, 'inverse',
'Conditions_80-sss_eq_%s-ave.fif' % s),
condition=c) for c in conditions
]
stcs = [
apply_inverse(e, inv, lambda2, method=method, pick_ori=None)
for e in evokeds
]
if not op.isdir(op.join(data_path, '%s' % s, 'stc')):
os.mkdir(op.join(data_path, '%s' % s, 'stc'))
for j, stc in enumerate(stcs):
stc.save(
op.join(data_path, '%s' % s, 'stc',
continue
#initialize names
subject = "h%02d" % run
fssub = "H%02d" % run #freesurfer subject
subjects_dir=op.join('/path/path/path/path/', '%s/RAW/fs_test/' % (fssub)) #create subject directory for freesurfer data
print("processing subject: %s" % subject)
src_fname=op.join('/path/path/path/path/%s/RAW/fs_test/%s/bem/%s-oct-6-src.fif' %(fssub, fssub, fssub))
inv40_fname=op.join(data_path,'inv/', '%s_40hz-meg-oct-6-inv.fif' % (subject))
cov40_fname=op.join(data_path, 'noise_cov/', '%s_noise_40-cov.fif' % (subject))
fname40=op.join(data_path, 'epochs/', '%s_40epo.fif' % (subject))
fwd_fname40=op.join(data_path, 'fwd/', '%s_40.fwd.fif' % (subject))
epochs40=mne.read_epochs(fname40, proj=True, preload=True, verbose=None)
evoked40 = epochs40.average()
fwd40 = mne.read_forward_solution(fwd_fname40, surf_ori=True)
noise_cov40=mne.read_cov(cov40_fname)
inverse_operator40 = read_inverse_operator(inv40_fname)
# label information
# read label information
label_rh = mne.read_labels_from_annot(fssub, parc='aparc',
subjects_dir=subjects_dir,
regexp=labeln_rh1)[0]
label_lh = mne.read_labels_from_annot(fssub, parc='aparc',
subjects_dir=subjects_dir,
regexp=labeln_lh1)[0]
label_rh2 = mne.read_labels_from_annot(fssub, parc='aparc',
subjects_dir=subjects_dir,
regexp=labeln_rh2)[0]
label_lh2 = mne.read_labels_from_annot(fssub, parc='aparc',
def _real_vec_stc():
inv = read_inverse_operator(fname_inv_surf)
evoked = read_evokeds(fname_evoked, baseline=(None, 0))[0].crop(0, 0.01)
return apply_inverse(evoked, inv, pick_ori='vector')
def make_inverse_operator():
from mne.datasets import sample
from mne.minimum_norm import read_inverse_operator
data_path = sample.data_path()
filename_inv = data_path + '/MEG/sample/sample_audvis-meg-oct-6-meg-inv.fif'
return read_inverse_operator(filename_inv, verbose='ERROR')
def test_volume_source_morph(tmpdir):
"""Test volume source estimate morph, special cases and exceptions."""
import nibabel as nib
inverse_operator_vol = read_inverse_operator(fname_inv_vol)
stc_vol = read_source_estimate(fname_vol_w, 'sample')
# check for invalid input type
with pytest.raises(TypeError, match='src must be'):
compute_source_morph(src=42)
# check for raising an error if neither
# inverse_operator_vol['src'][0]['subject_his_id'] nor subject_from is set,
# but attempting to perform a volume morph
src = inverse_operator_vol['src']
assert src._subject is None # already None on disk (old!)
with pytest.raises(ValueError, match='subject_from could not be inferred'):
with pytest.warns(RuntimeWarning, match='recommend regenerating'):
compute_source_morph(src=src, subjects_dir=subjects_dir)
# check infer subject_from from src[0]['subject_his_id']
src[0]['subject_his_id'] = 'sample'
with pytest.raises(ValueError, match='Inter-hemispheric morphing'):
compute_source_morph(src=src, subjects_dir=subjects_dir, xhemi=True)
with pytest.raises(ValueError, match='Only surface.*sparse morph'):
compute_source_morph(src=src, sparse=True, subjects_dir=subjects_dir)
# terrible quality but fast
zooms = 20
kwargs = dict(zooms=zooms, niter_sdr=(1,), niter_affine=(1,))
source_morph_vol = compute_source_morph(
subjects_dir=subjects_dir, src=fname_inv_vol,
subject_from='sample', **kwargs)
shape = (13,) * 3 # for the given zooms
assert source_morph_vol.subject_from == 'sample'
# the brain used in sample data has shape (255, 255, 255)
assert tuple(source_morph_vol.sdr_morph.domain_shape) == shape
assert tuple(source_morph_vol.pre_affine.domain_shape) == shape
# proofs the above
assert_array_equal(source_morph_vol.zooms, (zooms,) * 3)
# assure proper src shape
mri_size = (src[0]['mri_height'], src[0]['mri_depth'], src[0]['mri_width'])
assert source_morph_vol.src_data['src_shape_full'] == mri_size
fwd = read_forward_solution(fname_fwd_vol)
fwd['src'][0]['subject_his_id'] = 'sample' # avoid further warnings
source_morph_vol = compute_source_morph(
fwd['src'], 'sample', 'sample', subjects_dir=subjects_dir,
**kwargs)
# check wrong subject_to
with pytest.raises(IOError, match='cannot read file'):
compute_source_morph(fwd['src'], 'sample', '42',
subjects_dir=subjects_dir)
# two different ways of saving
source_morph_vol.save(tmpdir.join('vol'))
# check loading
source_morph_vol_r = read_source_morph(tmpdir.join('vol-morph.h5'))
# check for invalid file name handling ()
with pytest.raises(IOError, match='not found'):
read_source_morph(tmpdir.join('42'))
# check morph
stc_vol_morphed = source_morph_vol.apply(stc_vol)
# old way, verts do not match
assert not np.array_equal(stc_vol_morphed.vertices[0], stc_vol.vertices[0])
# vector
stc_vol_vec = VolVectorSourceEstimate(
np.tile(stc_vol.data[:, np.newaxis], (1, 3, 1)),
stc_vol.vertices, 0, 1)
stc_vol_vec_morphed = source_morph_vol.apply(stc_vol_vec)
assert isinstance(stc_vol_vec_morphed, VolVectorSourceEstimate)
for ii in range(3):
assert_allclose(stc_vol_vec_morphed.data[:, ii], stc_vol_morphed.data)
# check output as NIfTI
assert isinstance(source_morph_vol.apply(stc_vol_vec, output='nifti2'),
nib.Nifti2Image)
# check for subject_from mismatch
source_morph_vol_r.subject_from = '42'
with pytest.raises(ValueError, match='subject_from must match'):
source_morph_vol_r.apply(stc_vol_morphed)
# check if nifti is in grid morph space with voxel_size == spacing
img_morph_res = source_morph_vol.apply(stc_vol, output='nifti1')
# assure morph spacing
assert isinstance(img_morph_res, nib.Nifti1Image)
assert img_morph_res.header.get_zooms()[:3] == (zooms,) * 3
# assure src shape
img_mri_res = source_morph_vol.apply(stc_vol, output='nifti1',
mri_resolution=True)
assert isinstance(img_mri_res, nib.Nifti1Image)
assert (img_mri_res.shape == (src[0]['mri_height'], src[0]['mri_depth'],
src[0]['mri_width']) +
(img_mri_res.shape[3],))
# check if nifti is defined resolution with voxel_size == (5., 5., 5.)
img_any_res = source_morph_vol.apply(stc_vol, output='nifti1',
mri_resolution=(5., 5., 5.))
assert isinstance(img_any_res, nib.Nifti1Image)
assert img_any_res.header.get_zooms()[:3] == (5., 5., 5.)
# check if morph outputs correct data
assert isinstance(stc_vol_morphed, VolSourceEstimate)
# check if loaded and saved objects contain the same
assert (all([read == saved for read, saved in
zip(sorted(source_morph_vol_r.__dict__),
sorted(source_morph_vol.__dict__))]))
# check __repr__
assert 'volume' in repr(source_morph_vol)
# check Nifti2Image
assert isinstance(
source_morph_vol.apply(stc_vol, mri_resolution=True,
mri_space=True, output='nifti2'),
nib.Nifti2Image)
# Degenerate conditions
with pytest.raises(TypeError, match='output must be'):
source_morph_vol.apply(stc_vol, output=1)
with pytest.raises(ValueError, match='subject_from does not match'):
compute_source_morph(src=src, subject_from='42')
with pytest.raises(ValueError, match='output'):
source_morph_vol.apply(stc_vol, output='42')
with pytest.raises(ValueError, match='subject_to cannot be None'):
compute_source_morph(src, 'sample', None,
subjects_dir=subjects_dir)
# Check if not morphed, but voxel size not boolean, raise ValueError.
# Note that this check requires dipy to not raise the dipy ImportError
# before checking if the actual voxel size error will raise.
with pytest.raises(ValueError, match='Cannot infer original voxel size'):
stc_vol.as_volume(inverse_operator_vol['src'], mri_resolution=4)
stc_surf = read_source_estimate(fname_stc, 'sample')
with pytest.raises(TypeError, match='stc_from must be an instance'):
source_morph_vol.apply(stc_surf)
# src_to
source_morph_vol = compute_source_morph(
fwd['src'], subject_from='sample', src_to=fwd['src'],
subject_to='sample', subjects_dir=subjects_dir, **kwargs)
stc_vol_2 = source_morph_vol.apply(stc_vol)
# new way, verts match
assert_array_equal(stc_vol.vertices[0], stc_vol_2.vertices[0])
stc_vol_bad = VolSourceEstimate(
stc_vol.data[:-1], [stc_vol.vertices[0][:-1]],
stc_vol.tmin, stc_vol.tstep)
match = (
'vertices do not match between morph \\(4157\\) and stc \\(4156\\).*'
'\n.*\n.*\n.*Vertices were likely excluded during forward computatio.*'
)
with pytest.raises(ValueError, match=match):
source_morph_vol.apply(stc_vol_bad)
def calc_power(subject, epochs, condition=None, label=None, save=True):
"""Calculate induced power and ITC.
Does TF...
Parameters
----------
subject : string
the subject number.
epochs : ??? # TODO give proper name for epochs file
the epochs to calculate power from.
label : string
restrict to a label.
condition : string
the condition to use if there several in the epochs file.
save : bool
whether for save the results. Defaults to True.
"""
frequencies = np.arange(8, 13, 1) # define frequencies of interest
n_cycles = frequencies / 3.
inverse_operator = read_inverse_operator(mne_folder +
"%s-inv.fif" % subject)
snr = 1.0
lambda2 = 1.0 / snr ** 2
method = "dSPM" # use dSPM method (could also be MNE or sLORETA)
if condition:
epochs_test = epochs[condition]
else:
epochs_test = epochs
power, phase_lock = source_induced_power(epochs_test,
inverse_operator,
frequencies,
label=label,
method=method,
lambda2=lambda2,
n_cycles=n_cycles,
use_fft=True,
pick_ori=None,
baseline=(None, -0.3),
baseline_mode='zscore',
pca=True,
n_jobs=2)
if save:
np.save(tf_folder + "pow_%s_%s-%s_%s_%s_%s.npy" % (subject,
frequencies[0],
frequencies[-1],
label.name,
condition,
method),
power)
np.save(tf_folder + "itc_%s_%s-%s_%s_%s_%s.npy" % (subject,
frequencies[0],
frequencies[-1],
label.name,
condition,
method),
phase_lock)
return power, phase_lock
epo_name = data_path + meg + 'block_' + cond + '_words_epochs-epo.fif'
epochs_cond = mne.read_epochs(epo_name, preload=True)
# crop epochs
epochs = epochs_cond['words'].copy().crop(-.200,
.900).resample(f_down_sampling)
# equalize trial counts to eliminate bias
# equalize_epoch_counts([epochs_SD, epochs_LD])
inv_fname_epoch = data_path + meg + 'InvOp_' + cond + '_EMEG-inv.fif'
output = [0] * 2
# read inverse operator,apply inverse operator
inv_op = read_inverse_operator(inv_fname_epoch)
stc = apply_inverse_epochs(epochs,
inv_op,
lambda2,
method='MNE',
pick_ori="normal",
return_generator=False)
for j, idx in enumerate([ROI_x, ROI_y]):
labels[idx].subject = sub_to
# define dimentions of matrix (vertices X timepoints), & initializing
v, t = stc[0].in_label(labels[idx]).data.shape
X = np.zeros([len(stc), v, t])
# create output array of size (vertices X stimuli X timepoints)
for s in np.arange(0, len(stc)):
S = stc[s].in_label(labels[idx]).data
snr = 1.0 # Standard assumption for average data but using it for single trial
lambda2 = 1.0 / snr ** 2
method = "dSPM" # use dSPM method (could also be MNE or sLORETA)
freqs = np.arange(8, 13, 1)
n_cycle = freqs / 3.
conditions = ["ent/left", "ctl/left", "ent/right", "ctl/right"]
for subject in subjects_select:
# Load data
labels = mne.read_labels_from_annot(subject, parc='PALS_B12_Brodmann',
regexp="Bro",
subjects_dir=subjects_dir)
labels_sel = [labels[6], labels[7]]
inverse_operator = read_inverse_operator(mne_folder +
"%s-inv.fif" % subject)
src = inverse_operator["src"]
epochs = mne.read_epochs(epochs_folder +
"%s_trial_start-epo.fif" % subject)
# epochs.drop_bad_epochs(reject_params)
# epochs.resample(250, n_jobs=4)
for condition in conditions:
stcs = apply_inverse_epochs(epochs[condition],
inverse_operator,
lambda2,
method,
pick_ori=None)
for label in labels_sel:
label_ts = []
import numpy as np
import scipy.io
datapath = '/net/server/data/Archive/aut_gamma/orekhova/KI/'
savepath = '/net/server/data/Archive/aut_gamma/orekhova/KI/Scripts_bkp/Shishkina/KI/Results_Alpha_and_Gamma/'
subjects_dir = datapath + 'freesurfersubjects'
subject = '0102'
fname_raw = datapath + 'SUBJECTS/' + subject + '/ICA_nonotch_crop/' + subject + '_rings_ICA_raw.fif'
fname_inv = savepath + subject + '/' + subject + '_inv'
# Load Data
raw = io.Raw(fname_raw, preload=True)
raw.filter(2, 40)
inverse_operator = read_inverse_operator(fname_inv, verbose=None)
events = mne.find_events(raw,
stim_channel='STI101',
verbose=True,
shortest_event=1)
# Make epochs from raw
delay = 8
events[:, 0] = events[:, 0] + delay / 1000. * raw.info['sfreq']
ev = np.sort(
np.concatenate((np.where(events[:, 2] == 2), np.where(events[:, 2] == 4),
np.where(events[:, 2] == 8)),
axis=1))
relevantevents = events[ev, :][0]
def test_channel_name_limit(tmpdir, monkeypatch, fname):
"""Test that our remapping works properly."""
#
# raw
#
if fname.endswith('fif'):
raw = read_raw_fif(fname)
raw.pick_channels(raw.ch_names[:3])
ref_names = []
data_names = raw.ch_names
else:
assert fname.endswith('.ds')
raw = read_raw_ctf(fname)
ref_names = [
raw.ch_names[pick]
for pick in pick_types(raw.info, meg=False, ref_meg=True)
]
data_names = raw.ch_names[32:35]
proj = dict(data=np.ones((1, len(data_names))),
col_names=data_names[:2].copy(),
row_names=None,
nrow=1)
proj = Projection(data=proj,
active=False,
desc='test',
kind=0,
explained_var=0.)
raw.add_proj(proj, remove_existing=True)
raw.info.normalize_proj()
raw.pick_channels(data_names + ref_names).crop(0, 2)
long_names = ['123456789abcdefg' + name for name in raw.ch_names]
fname = tmpdir.join('test-raw.fif')
with catch_logging() as log:
raw.save(fname)
log = log.getvalue()
assert 'truncated' not in log
rename = dict(zip(raw.ch_names, long_names))
long_data_names = [rename[name] for name in data_names]
long_proj_names = long_data_names[:2]
raw.rename_channels(rename)
for comp in raw.info['comps']:
for key in ('row_names', 'col_names'):
for name in comp['data'][key]:
assert name in raw.ch_names
if raw.info['comps']:
assert raw.compensation_grade == 0
raw.apply_gradient_compensation(3)
assert raw.compensation_grade == 3
assert len(raw.info['projs']) == 1
assert raw.info['projs'][0]['data']['col_names'] == long_proj_names
raw.info['bads'] = bads = long_data_names[2:3]
good_long_data_names = [
name for name in long_data_names if name not in bads
]
with catch_logging() as log:
raw.save(fname, overwrite=True, verbose=True)
log = log.getvalue()
assert 'truncated to 15' in log
for name in raw.ch_names:
assert len(name) > 15
# first read the full way
with catch_logging() as log:
raw_read = read_raw_fif(fname, verbose=True)
log = log.getvalue()
assert 'Reading extended channel information' in log
for ra in (raw, raw_read):
assert ra.ch_names == long_names
assert raw_read.info['projs'][0]['data']['col_names'] == long_proj_names
del raw_read
# next read as if no longer names could be read
monkeypatch.setattr(meas_info, '_read_extended_ch_info',
lambda x, y, z: None)
with catch_logging() as log:
raw_read = read_raw_fif(fname, verbose=True)
log = log.getvalue()
assert 'extended' not in log
if raw.info['comps']:
assert raw_read.compensation_grade == 3
raw_read.apply_gradient_compensation(0)
assert raw_read.compensation_grade == 0
monkeypatch.setattr( # restore
meas_info, '_read_extended_ch_info', _read_extended_ch_info)
short_proj_names = [
f'{name[:13 - bool(len(ref_names))]}-{len(ref_names) + ni}'
for ni, name in enumerate(long_data_names[:2])
]
assert raw_read.info['projs'][0]['data']['col_names'] == short_proj_names
#
# epochs
#
epochs = Epochs(raw, make_fixed_length_events(raw))
fname = tmpdir.join('test-epo.fif')
epochs.save(fname)
epochs_read = read_epochs(fname)
for ep in (epochs, epochs_read):
assert ep.info['ch_names'] == long_names
assert ep.ch_names == long_names
del raw, epochs_read
# cov
epochs.info['bads'] = []
cov = compute_covariance(epochs, verbose='error')
fname = tmpdir.join('test-cov.fif')
write_cov(fname, cov)
cov_read = read_cov(fname)
for co in (cov, cov_read):
assert co['names'] == long_data_names
assert co['bads'] == []
del cov_read
#
# evoked
#
evoked = epochs.average()
evoked.info['bads'] = bads
assert evoked.nave == 1
fname = tmpdir.join('test-ave.fif')
evoked.save(fname)
evoked_read = read_evokeds(fname)[0]
for ev in (evoked, evoked_read):
assert ev.ch_names == long_names
assert ev.info['bads'] == bads
del evoked_read, epochs
#
# forward
#
with pytest.warns(None): # not enough points for CTF
sphere = make_sphere_model('auto', 'auto', evoked.info)
src = setup_volume_source_space(
pos=dict(rr=[[0, 0, 0.04]], nn=[[0, 1., 0.]]))
fwd = make_forward_solution(evoked.info, None, src, sphere)
fname = tmpdir.join('temp-fwd.fif')
write_forward_solution(fname, fwd)
fwd_read = read_forward_solution(fname)
for fw in (fwd, fwd_read):
assert fw['sol']['row_names'] == long_data_names
assert fw['info']['ch_names'] == long_data_names
assert fw['info']['bads'] == bads
del fwd_read
#
# inv
#
inv = make_inverse_operator(evoked.info, fwd, cov)
fname = tmpdir.join('test-inv.fif')
write_inverse_operator(fname, inv)
inv_read = read_inverse_operator(fname)
for iv in (inv, inv_read):
assert iv['info']['ch_names'] == good_long_data_names
apply_inverse(evoked, inv) # smoke test
fname_fwd = data_path + '/MEG/sample/sample_audvis-meg-eeg-oct-6-fwd.fif'
fname_inv_eegmeg = (data_path +
'/MEG/sample/sample_audvis-meg-eeg-oct-6-meg-eeg-inv.fif')
fname_inv_meg = data_path + '/MEG/sample/sample_audvis-meg-oct-6-meg-inv.fif'
fname_label = [data_path + '/MEG/sample/labels/Aud-rh.label',
data_path + '/MEG/sample/labels/Aud-lh.label',
data_path + '/MEG/sample/labels/Vis-rh.label',
data_path + '/MEG/sample/labels/Vis-lh.label']
# read forward solution (sources in surface-based coordinates)
forward = mne.read_forward_solution(fname_fwd, force_fixed=False,
surf_ori=True)
# read inverse operators
inverse_operator_eegmeg = read_inverse_operator(fname_inv_eegmeg)
inverse_operator_meg = read_inverse_operator(fname_inv_meg)
# read label(s)
labels = [mne.read_label(ss) for ss in fname_label]
# regularisation parameter
snr = 3.0
lambda2 = 1.0 / snr ** 2
method = 'MNE' # can be 'MNE' or 'sLORETA'
mode = 'svd'
n_svd_comp = 1
stc_psf_eegmeg, _ = point_spread_function(inverse_operator_eegmeg,
forward, method=method,
labels=labels,
times = np.arange(-0.1, 1.5, 0.1) # Timing of the source time course (shouldn't be too big)
for nip in nips:
for bloc in bloc_names:
for stimulus in stimulus_names:
###################################################################
########################### Importation ###########################
###################################################################
# Evoked responses
fname = data_evoked_directory + bloc + '/' + nip + '/' + stimulus
evoked = mne.Evoked(fname + '-ave.fif')
# Corresponding inverse operator
inverse_operator = read_inverse_operator(fname + '-inv.fif')
###################################################################
######################### Source estimation #######################
###################################################################
stc = apply_inverse(evoked, inverse_operator, lambda2,
method=method, pick_ori=None)
###################################################################
########################### Visualization #########################
###################################################################
# We need to separate right and left hemisphere
stc_data = dict()
stc_data['lh'] = stc.data[:len(stc.lh_vertno)]
def _real_vec_stc():
inv = read_inverse_operator(fname_inv)
evoked = read_evokeds(fname_evoked, baseline=(None, 0))[0].crop(0, 0.01)
return apply_inverse(evoked, inv, pick_ori='vector')
def test_volume_source_morph():
"""Test volume source estimate morph, special cases and exceptions."""
import nibabel as nib
tempdir = _TempDir()
inverse_operator_vol = read_inverse_operator(fname_inv_vol)
stc_vol = read_source_estimate(fname_vol, 'sample')
# check for invalid input type
with pytest.raises(TypeError, match='src must be an instance of'):
compute_source_morph(src=42)
# check for raising an error if neither
# inverse_operator_vol['src'][0]['subject_his_id'] nor subject_from is set,
# but attempting to perform a volume morph
src = inverse_operator_vol['src']
src[0]['subject_his_id'] = None
with pytest.raises(ValueError, match='subject_from could not be inferred'):
compute_source_morph(src=src, subjects_dir=subjects_dir)
# check infer subject_from from src[0]['subject_his_id']
src[0]['subject_his_id'] = 'sample'
with pytest.raises(ValueError, match='Inter-hemispheric morphing'):
compute_source_morph(src=src, subjects_dir=subjects_dir, xhemi=True)
with pytest.raises(ValueError, match='Only surface.*sparse morph'):
compute_source_morph(src=src, sparse=True, subjects_dir=subjects_dir)
# terrible quality buts fast
zooms = 20
kwargs = dict(zooms=zooms, niter_sdr=(1,), niter_affine=(1,))
source_morph_vol = compute_source_morph(
subjects_dir=subjects_dir, src=inverse_operator_vol['src'], **kwargs)
shape = (13,) * 3 # for the given zooms
assert source_morph_vol.subject_from == 'sample'
# the brain used in sample data has shape (255, 255, 255)
assert tuple(source_morph_vol.sdr_morph.domain_shape) == shape
assert tuple(source_morph_vol.pre_affine.domain_shape) == shape
# proofs the above
assert_array_equal(source_morph_vol.zooms, (zooms,) * 3)
# assure proper src shape
mri_size = (src[0]['mri_height'], src[0]['mri_depth'], src[0]['mri_width'])
assert source_morph_vol.src_data['src_shape_full'] == mri_size
fwd = read_forward_solution(fname_fwd_vol)
source_morph_vol = compute_source_morph(
fwd['src'], 'sample', 'sample', subjects_dir=subjects_dir,
**kwargs)
# check wrong subject_to
with pytest.raises(IOError, match='cannot read file'):
compute_source_morph(fwd['src'], 'sample', '42',
subjects_dir=subjects_dir)
# two different ways of saving
source_morph_vol.save(op.join(tempdir, 'vol'))
# check loading
source_morph_vol_r = read_source_morph(
op.join(tempdir, 'vol-morph.h5'))
# check for invalid file name handling ()
with pytest.raises(IOError, match='not found'):
read_source_morph(op.join(tempdir, '42'))
# check morph
stc_vol_morphed = source_morph_vol.apply(stc_vol)
# check output as NIfTI
assert isinstance(source_morph_vol.apply(stc_vol, output='nifti2'),
nib.Nifti2Image)
# check for subject_from mismatch
source_morph_vol_r.subject_from = '42'
with pytest.raises(ValueError, match='subject_from must match'):
source_morph_vol_r.apply(stc_vol_morphed)
# check if nifti is in grid morph space with voxel_size == spacing
img_morph_res = source_morph_vol.apply(stc_vol, output='nifti1')
# assure morph spacing
assert isinstance(img_morph_res, nib.Nifti1Image)
assert img_morph_res.header.get_zooms()[:3] == (zooms,) * 3
# assure src shape
img_mri_res = source_morph_vol.apply(stc_vol, output='nifti1',
mri_resolution=True)
assert isinstance(img_mri_res, nib.Nifti1Image)
assert (img_mri_res.shape == (src[0]['mri_height'], src[0]['mri_depth'],
src[0]['mri_width']) +
(img_mri_res.shape[3],))
# check if nifti is defined resolution with voxel_size == (5., 5., 5.)
img_any_res = source_morph_vol.apply(stc_vol, output='nifti1',
mri_resolution=(5., 5., 5.))
assert isinstance(img_any_res, nib.Nifti1Image)
assert img_any_res.header.get_zooms()[:3] == (5., 5., 5.)
# check if morph outputs correct data
assert isinstance(stc_vol_morphed, VolSourceEstimate)
# check if loaded and saved objects contain the same
assert (all([read == saved for read, saved in
zip(sorted(source_morph_vol_r.__dict__),
sorted(source_morph_vol.__dict__))]))
# check __repr__
assert 'volume' in repr(source_morph_vol)
# check Nifti2Image
assert isinstance(
source_morph_vol.apply(stc_vol, mri_resolution=True,
mri_space=True, output='nifti2'),
nib.Nifti2Image)
# Degenerate conditions
with pytest.raises(TypeError, match='output must be'):
source_morph_vol.apply(stc_vol, output=1)
with pytest.raises(ValueError, match='subject_from does not match'):
compute_source_morph(src=src, subject_from='42')
with pytest.raises(ValueError, match='output must be one of'):
source_morph_vol.apply(stc_vol, output='42')
with pytest.raises(TypeError, match='subject_to must'):
compute_source_morph(src, 'sample', None,
subjects_dir=subjects_dir)
# Check if not morphed, but voxel size not boolean, raise ValueError.
# Note that this check requires dipy to not raise the dipy ImportError
# before checking if the actual voxel size error will raise.
with pytest.raises(ValueError, match='Cannot infer original voxel size'):
stc_vol.as_volume(inverse_operator_vol['src'], mri_resolution=4)
baseline=(None, 0),
reject=reject,
preload=True)
# Equalize trial counts to eliminate bias (which would otherwise be
# introduced by the abs() performed below)
epochs.equalize_event_counts(event_id)
###############################################################################
# Transform to source space
# -------------------------
fname_inv = data_path + '/MEG/sample/sample_audvis-meg-oct-6-meg-inv.fif'
snr = 3.0
lambda2 = 1.0 / snr**2
method = "dSPM" # use dSPM method (could also be MNE, sLORETA, or eLORETA)
inverse_operator = read_inverse_operator(fname_inv)
# we'll only use one hemisphere to speed up this example
# instead of a second vertex array we'll pass an empty array
sample_vertices = [inverse_operator['src'][0]['vertno'], np.array([], int)]
# Let's average and compute inverse, then resample to speed things up
conditions = []
for cond in ['l_aud', 'r_aud', 'l_vis', 'r_vis']: # order is important
evoked = epochs[cond].average()
evoked.resample(50, npad='auto')
condition = apply_inverse(evoked, inverse_operator, lambda2, method)
# Let's only deal with t > 0, cropping to reduce multiple comparisons
condition.crop(0, None)
conditions.append(condition)
def test_plot_snr():
"""Test plotting SNR estimate."""
inv = read_inverse_operator(inv_fname)
evoked = read_evokeds(evoked_fname, baseline=(None, 0))[0]
plot_snr_estimate(evoked, inv)
plt.close('all')
###############################################################################################################################################
########## Load fwd and inv solutions from RS example data
subject = 'S0116'
subjects_dir = 'M:\\inverse_weighting\\'
parc = 'parc2018yeo7_400'
fwdFile = 'M:\\inverse_weighting\\S0116\\S0116_set02__220416_tsss_09_trans_MEG_ICA-py-fwd.fif'
invFile = 'M:\\inverse_weighting\\S0116\\S0116_set02__220416_tsss_09_trans_MEG_ICA-py-inv.fif'
# read fwd op
fwd = mne.read_forward_solution(fwdFile)
fwd_sol = fwd['sol'][
'data'] # counterpart to forwardOperator, [sensors x sources]
# read and prepare inv op
inv = minnorm.read_inverse_operator(invFile)
invP = minnorm.prepare_inverse_operator(inv, 1, 1. / 9.)
inv_sol = minnorm.inverse._assemble_kernel(
invP, None, 'MNE',
None)[0] # counterpart to forwardOperator, [sources x sensors]
# get source space
src = inv.get('src')
vert_lh = src[0].get('vertno')
vert_rh = src[1].get('vertno')
# get labels, vertices and src-identities
labels_parc = mne.read_labels_from_annot(subject,
parc=parc,
subjects_dir=subjects_dir)
src_ident_lh = np.full(len(vert_lh), -1)
def test_apply_mne_inverse_epochs():
"""Test MNE with precomputed inverse operator on Epochs."""
inverse_operator = read_inverse_operator(fname_full)
label_lh = read_label(fname_label % 'Aud-lh')
label_rh = read_label(fname_label % 'Aud-rh')
event_id, tmin, tmax = 1, -0.2, 0.5
raw = read_raw_fif(fname_raw)
picks = pick_types(raw.info, meg=True, eeg=False, stim=True, ecg=True,
eog=True, include=['STI 014'], exclude='bads')
reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)
flat = dict(grad=1e-15, mag=1e-15)
events = read_events(fname_event)[:15]
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=(None, 0), reject=reject, flat=flat)
inverse_operator = prepare_inverse_operator(inverse_operator, nave=1,
lambda2=lambda2,
method="dSPM")
for pick_ori in [None, "normal", "vector"]:
stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_lh, pick_ori=pick_ori)
stcs2 = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_lh, pick_ori=pick_ori,
prepared=True)
# test if using prepared and not prepared inverse operator give the
# same result
assert_array_almost_equal(stcs[0].data, stcs2[0].data)
assert_array_almost_equal(stcs[0].times, stcs2[0].times)
assert (len(stcs) == 2)
assert (3 < stcs[0].data.max() < 10)
assert (stcs[0].subject == 'sample')
inverse_operator = read_inverse_operator(fname_full)
stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_lh, pick_ori='normal')
data = sum(stc.data for stc in stcs) / len(stcs)
flip = label_sign_flip(label_lh, inverse_operator['src'])
label_mean = np.mean(data, axis=0)
label_mean_flip = np.mean(flip[:, np.newaxis] * data, axis=0)
assert (label_mean.max() < label_mean_flip.max())
# test extracting a BiHemiLabel
inverse_operator = prepare_inverse_operator(inverse_operator, nave=1,
lambda2=lambda2,
method="dSPM")
stcs_rh = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_rh, pick_ori="normal",
prepared=True)
stcs_bh = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
label=label_lh + label_rh,
pick_ori="normal",
prepared=True)
n_lh = len(stcs[0].data)
assert_array_almost_equal(stcs[0].data, stcs_bh[0].data[:n_lh])
assert_array_almost_equal(stcs_rh[0].data, stcs_bh[0].data[n_lh:])
# test without using a label (so delayed computation is used)
stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
pick_ori="normal", prepared=True)
assert (stcs[0].subject == 'sample')
label_stc = stcs[0].in_label(label_rh)
assert (label_stc.subject == 'sample')
assert_array_almost_equal(stcs_rh[0].data, label_stc.data)
from my_settings import (epochs_folder, tf_folder, subjects_dir, mne_folder)
import mne
import sys
import numpy as np
import pandas as pd
from mne.minimum_norm import read_inverse_operator, source_induced_power
subject = sys.argv[1]
epochs = mne.read_epochs(epochs_folder + "%s_target-epo.fif" % subject)
inv = read_inverse_operator(mne_folder + "%s-inv.fif" % subject)
labels = mne.read_labels_from_annot(
subject,
parc='PALS_B12_Lobes',
# regexp="Bro",
subjects_dir=subjects_dir)
labels_selc = labels[9], labels[10]
frequencies = np.arange(8, 13, 1) # define frequencies of interest
n_cycles = frequencies / 3. # different number of cycle per frequency
method = "dSPM"
sides = ["left", "right"]
conditions = ["ctl", "ent"]
cor = ["correct", "incorrect"]
phase = ["in_phase", "out_phase"]
congrunet = ["cong", "incong"]
def SN_functional_connectivity_betweenROIs_runs_BL(i, method):
s = time.time()
meg = subjects[i]
sub_to = MRI_sub[i][1:15]
# stc_SD_file_name=os.path.expanduser('~') +'/my_semnet/json_files/connectivity/con_labels_'+method+'_bl_bands_SD_sub'+str(i)+'.json'
# stc_LD_file_name=os.path.expanduser('~') +'/my_semnet/json_files/connectivity/con_labels_'+method+'_bl_bands_LD_sub'+str(i)+'.json'
stc_F_file_name = os.path.expanduser(
'~'
) + '/my_semnet/json_files/connectivity/con_labels_' + method + '_bl_bands_F_sub' + str(
i) + '.json'
stc_M_file_name = os.path.expanduser(
'~'
) + '/my_semnet/json_files/connectivity/con_labels_' + method + '_bl_bands_M_sub' + str(
i) + '.json'
stc_O_file_name = os.path.expanduser(
'~'
) + '/my_semnet/json_files/connectivity/con_labels_' + method + '_bl_bands_O_sub' + str(
i) + '.json'
morphed_labels = mne.morph_labels(SN_ROI,subject_to=data_path+sub_to,\
subject_from='fsaverage',subjects_dir=data_path)
# Reading epochs
epoch_fname_fruit = data_path + meg + 'block_fruit_epochs-epo.fif'
epoch_fname_odour = data_path + meg + 'block_odour_epochs-epo.fif'
epoch_fname_milk = data_path + meg + 'block_milk_epochs-epo.fif'
epo_name_LD = data_path + meg + 'block_LD_words_epochs-epo.fif'
epochs_fruit = mne.read_epochs(epoch_fname_fruit, preload=True)
epochs_odour = mne.read_epochs(epoch_fname_odour, preload=True)
epochs_milk = mne.read_epochs(epoch_fname_milk, preload=True)
epochs_ld = mne.read_epochs(epo_name_LD, preload=True)
epochs_f = mne.epochs.combine_event_ids(
epochs_fruit, ['visual', 'hear', 'hand', 'neutral', 'emotional'],
{'words': 15})
epochs_o = mne.epochs.combine_event_ids(
epochs_odour, ['visual', 'hear', 'hand', 'neutral', 'emotional'],
{'words': 15})
epochs_m = mne.epochs.combine_event_ids(
epochs_milk, ['visual', 'hear', 'hand', 'neutral', 'emotional'],
{'words': 15})
epochs_f = epochs_f['words'].copy().crop(-.200, 0).resample(500)
epochs_o = epochs_o['words'].copy().crop(-.200, 0).resample(500)
epochs_m = epochs_m['words'].copy().crop(-.200, 0).resample(500)
epochs_LD = epochs_ld['words'].copy().crop(-.200, 0).resample(500)
# Reading inverse operator
inv_fname_SD = data_path + meg + 'InvOp_SD_EMEG-inv.fif'
inv_fname_LD = data_path + meg + 'InvOp_LD_EMEG-inv.fif'
inv_op_SD = read_inverse_operator(inv_fname_SD)
inv_op_LD = read_inverse_operator(inv_fname_LD)
stc_F = apply_inverse_epochs(epochs_f,
inv_op_SD,
lambda2,
method='MNE',
pick_ori="normal",
return_generator=False)
stc_O = apply_inverse_epochs(epochs_o,
inv_op_SD,
lambda2,
method='MNE',
pick_ori="normal",
return_generator=False)
stc_M = apply_inverse_epochs(epochs_m,
inv_op_SD,
lambda2,
method='MNE',
pick_ori="normal",
return_generator=False)
stc_LD = apply_inverse_epochs(epochs_LD,
inv_op_LD,
lambda2,
method='MNE',
pick_ori="normal",
return_generator=False)
src_SD = inv_op_SD['src']
src_LD = inv_op_LD['src']
for k in np.arange(0, 6):
# print('[i,win,k]: ',i,win,k)
morphed_labels[k].name = C.rois_labels[k]
for f in np.arange(0, len(C.con_freq_band) - 1):
print('[i,k,f]: ', i, k, f)
f_min = C.con_freq_band[f]
f_max = C.con_freq_band[f + 1]
print(f_min, f_max)
labels_ts_f = mne.extract_label_time_course(stc_F, morphed_labels, \
src_SD, mode='mean_flip',return_generator=False)
labels_ts_o = mne.extract_label_time_course(stc_O, morphed_labels, \
src_SD, mode='mean_flip',return_generator=False)
labels_ts_m = mne.extract_label_time_course(stc_M, morphed_labels, \
src_SD, mode='mean_flip',return_generator=False)
labels_ts_ld= mne.extract_label_time_course(stc_LD, morphed_labels, \
src_LD, mode='mean_flip',return_generator=False)
con_F, freqs, times, n_epochs, n_tapers = spectral_connectivity(
labels_ts_f,
method=method,
mode='fourier',
sfreq=500,
fmin=f_min,
fmax=f_max,
faverage=True,
n_jobs=10)
con_O, freqs, times, n_epochs, n_tapers = spectral_connectivity(
labels_ts_o,
method=method,
mode='fourier',
sfreq=500,
fmin=f_min,
fmax=f_max,
faverage=True,
n_jobs=10)
con_M, freqs, times, n_epochs, n_tapers = spectral_connectivity(
labels_ts_m,
method=method,
mode='fourier',
sfreq=500,
fmin=f_min,
fmax=f_max,
faverage=True,
n_jobs=10)
# con_LD, freqs, times, n_epochs, n_tapers = spectral_connectivity(
# labels_ts_ld, method=method, mode='fourier',
# sfreq=500, fmin=f_min, fmax=f_max, faverage=True, n_jobs=10)
# con_SD=(con_F+ con_O+ con_M)/3
# con_labels_SD[f]= con_SD.reshape(6,6)
# con_labels_LD[f]= con_LD.reshape(6,6)
con_labels_F[f] = con_F.reshape(6, 6)
con_labels_M[f] = con_M.reshape(6, 6)
con_labels_O[f] = con_O.reshape(6, 6)
# with open(stc_SD_file_name, "wb") as fp: #Pickling
# pickle.dump(con_labels_SD, fp)
# with open(stc_LD_file_name, "wb") as fp: #Pickling
# pickle.dump(con_labels_LD, fp)
with open(stc_F_file_name, "wb") as fp: #Pickling
pickle.dump(con_labels_F, fp)
with open(stc_M_file_name, "wb") as fp: #Pickling
pickle.dump(con_labels_M, fp)
with open(stc_O_file_name, "wb") as fp: #Pickling
pickle.dump(con_labels_O, fp)
e = time.time()
print(e - s)
reject = dict(grad=1000e-13, mag=4000e-15, eog=150e-6)
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=(None, 0), reject=reject, preload=True)
# Equalize trial counts to eliminate bias (which would otherwise be
# introduced by the abs() performed below)
epochs.equalize_event_counts(event_id, copy=False)
###############################################################################
# Transform to source space
fname_inv = data_path + '/MEG/sample/sample_audvis-meg-oct-6-meg-inv.fif'
snr = 3.0
lambda2 = 1.0 / snr ** 2
method = "dSPM" # use dSPM method (could also be MNE or sLORETA)
inverse_operator = read_inverse_operator(fname_inv)
# we'll only use one hemisphere to speed up this example
# instead of a second vertex array we'll pass an empty array
sample_vertices = [inverse_operator['src'][0]['vertno'], np.array([], int)]
# Let's average and compute inverse, then resample to speed things up
conditions = []
for cond in ['l_aud', 'r_aud', 'l_vis', 'r_vis']: # order is important
evoked = epochs[cond].average()
evoked.resample(50)
condition = apply_inverse(evoked, inverse_operator, lambda2, method)
# Let's only deal with t > 0, cropping to reduce multiple comparisons
condition.crop(0, None)
conditions.append(condition)
The inverse operator's source space is shown in 3D.
"""
# Author: Alexandre Gramfort <*****@*****.**>
#
# License: BSD (3-clause)
from mne.datasets import sample
from mne.minimum_norm import read_inverse_operator
print(__doc__)
data_path = sample.data_path()
fname = data_path
fname += "/MEG/sample/sample_audvis-meg-oct-6-meg-inv.fif"
inv = read_inverse_operator(fname)
print("Method: %s" % inv["methods"])
print("fMRI prior: %s" % inv["fmri_prior"])
print("Number of sources: %s" % inv["nsource"])
print("Number of channels: %s" % inv["nchan"])
###############################################################################
# Show result on 3D source space
lh_points = inv["src"][0]["rr"]
lh_faces = inv["src"][0]["use_tris"]
rh_points = inv["src"][1]["rr"]
rh_faces = inv["src"][1]["use_tris"]
from mayavi import mlab # noqa
mlab.figure(size=(600, 600), bgcolor=(0, 0, 0))
