def run_strural(subject,
bem_ico=4,
spacing='ico5',
n_jobs=4,
subjects_dir='/cluster/transcend/MRI/WMA/recons'):
mne.bem.make_watershed_bem(subject,
subjects_dir=subjects_dir,
overwrite=True)
src_fname = op.join(subjects_dir, subject,
'%s-pyimpress-src.fif' % spacing)
if not os.path.isfile(src_fname):
src = mne.setup_source_space(subject,
spacing=spacing,
subjects_dir=subjects_dir,
overwrite=True,
n_jobs=n_jobs,
add_dist=True)
mne.write_source_spaces(src_fname, src)
else:
src = mne.read_source_spaces(src_fname)
bem_fname = op.join(subjects_dir, subject,
'%s-pyimpress-bem.fif' % bem_ico)
if not os.path.isfile(bem_fname):
bem_model = mne.make_bem_model(subject,
ico=bem_ico,
subjects_dir=subjects_dir,
conductivity=(0.3, ))
bem = mne.make_bem_solution(bem_model)
mne.write_bem_solution(bem_fname, bem)
else:
bem = mne.read_bem_solution(bem_fname)
return src, bem, src_fname, bem_fname
def process_subject_source_space(subject):
# make BEMs using watershed bem
# NOTE: Use MNE version >= 20 or set overwrite=True!
# mne.bem.make_watershed_bem(subject,
# subjects_dir=subjects_dir,
# show=False,
# verbose=False,
# overwrite=True)
bem_surf_fname = op.join(subjects_dir, subject, 'bem',
f'{subject}-ico{bem_ico}-bem.fif')
bem_sol_fname = op.join(subjects_dir, subject, 'bem',
f'{subject}-ico{bem_ico}-bem-sol.fif')
src_fname = op.join(subjects_dir, subject, 'bem',
f'{subject}-ico{bem_ico}-src.fif')
# make BEM models
# ico5 is for downsamping
bem_surf = mne.make_bem_model(
subject,
ico=bem_ico,
conductivity=[0.3], # for MEG data, 1 layer model is enough
subjects_dir=subjects_dir)
mne.write_bem_surfaces(bem_surf_fname, bem_surf)
# make BEM solution
bem_sol = mne.make_bem_solution(bem_surf)
mne.write_bem_solution(bem_sol_fname, bem_sol)
# Create the surface source space
src = mne.setup_source_space(subject, spacing, subjects_dir=subjects_dir)
mne.write_source_spaces(src_fname, src, overwrite=True)
def createBem(subj):
src = mne.setup_source_space(subj, n_jobs=2)
subprocess.call(['mne', 'watershed_bem', '-s', subj])
model = mne.make_bem_model(subj, conductivity=[0.3])
bem = mne.make_bem_solution(model)
mne.write_bem_solution(subj + '-5120-5120-5120-bem-sol.fif', bem)
mne.viz.plot_bem(subj)
def run_forward(subject_id):
subject = "sub%03d" % subject_id
print("processing subject: %s" % subject)
data_path = op.join(meg_dir, subject)
fname_ave = op.join(data_path, '%s-ave.fif' % subject)
fname_fwd = op.join(data_path, '%s-meg-%s-fwd.fif' % (subject, spacing))
fname_trans = op.join(study_path, 'ds117', subject, 'MEG', '%s-trans.fif' % subject)
src = mne.setup_source_space(subject, spacing=spacing,
subjects_dir=subjects_dir, overwrite=True,
n_jobs=1, add_dist=False)
src_fname = op.join(subjects_dir, subject, '%s-src.fif' % spacing)
mne.write_source_spaces(src_fname, src)
bem_model = mne.make_bem_model(subject, ico=4, subjects_dir=subjects_dir,
conductivity=(0.3,))
bem = mne.make_bem_solution(bem_model)
info = mne.read_evokeds(fname_ave, condition=0).info
fwd = mne.make_forward_solution(info, trans=fname_trans, src=src, bem=bem,
fname=None, meg=True, eeg=False,
mindist=mindist, n_jobs=1, overwrite=True)
fwd = mne.convert_forward_solution(fwd, surf_ori=True)
mne.write_forward_solution(fname_fwd, fwd, overwrite=True)
def process_subject_bem(subject, subjects_dir='/cluster/transcend/MRI/WMA/recons', spacing='ico4'):
try:
bem_fname = op.join(subjects_dir,subject,'bem', '%s-src.fif' % subject)
src_fname = op.join(subjects_dir, subject, 'bem', '%s-src.fif' % spacing)
#headsurf_log = op.join(subjects_dir, subject, 'bem', subject + '_headsurf.log')
if not os.path.isfile(bem_fname):
mne.bem.make_watershed_bem(subject=subject, subjects_dir=subjects_dir, overwrite=True, volume='T1', atlas=True,
gcaatlas=False, preflood=None)
conductivity = (0.3,)
model = mne.make_bem_model(subject=subject, ico=4,
conductivity=conductivity,
subjects_dir=subjects_dir)
bem = mne.make_bem_solution(model)
mne.write_bem_solution(bem_fname, bem=bem)
if not os.path.isfile(src_fname):
src = mne.setup_source_space(subject, spacing=spacing,
subjects_dir=subjects_dir,
add_dist=False)
mne.write_source_spaces(src_fname, src=src, overwrite=True)
except Exception as ee:
error = str(ee)
print(subject, error)
pass
def prepare_bem(subject, fsMRI_dir):
meg_subject_dir = op.join(config.meg_dir, subject)
dcm_subdir = op.join(config.root_path, 'data', 'MRI', 'orig_dicom', subject, 'organized')
flashfold = glob.glob(op.join(dcm_subdir, '*5°_PDW'))
if len(flashfold) > 0:
# In case watershed version was computed before, remove it to avoid confusion
watersheddir = op.join(config.root_path, 'data', 'MRI', 'fs_converted', subject, 'bem', 'watershed')
if op.exists(watersheddir):
shutil.rmtree(watersheddir)
# Also delete previously created symbolic links (overwrite issue...)
bemdir = op.join(config.root_path, 'data', 'MRI', 'fs_converted', subject, 'bem')
files_in_directory = os.listdir(bemdir)
filtered_files = [file for file in files_in_directory if file.endswith(".surf")]
for file in filtered_files:
os.remove(op.join(bemdir, file))
# Create BEM surfaces from (already converted) 5°Flash MRI using freesurfer(6.0!) mri_make_bem_surfaces
print('Subject ' + subject + ': make_flash_bem ======================')
mne.bem.make_flash_bem(subject, overwrite=True, show=False, subjects_dir=fsMRI_dir)
else:
# Create BEM surfaces from T1 MRI using freesurfer watershed
print('Subject ' + subject + ': make_watershed_bem ======================')
mne.bem.make_watershed_bem(subject=subject, subjects_dir=fsMRI_dir, overwrite=True)
# BEM model meshes
model = mne.make_bem_model(subject=subject, subjects_dir=fsMRI_dir)
mne.write_bem_surfaces(op.join(meg_subject_dir, subject + '-5120-5120-5120-bem.fif'), model, overwrite=True)
# BEM solution
bem_sol = mne.make_bem_solution(model)
mne.write_bem_solution(op.join(meg_subject_dir, subject + '-5120-5120-5120-bem-sol.fif'), bem_sol, overwrite=True)
def bem_computation(subject: str,
subjects_dir: str,
conductivity: tuple,
_subject_tree: Optional[SubjectTree] = None,
_priority: Optional[int] = None) -> mne.bem.ConductorModel:
"""Computes bem_ solution, uses :func:`nodestimation.project.read_or_write` decorator
:param subject: patient`s ID
:type subject: str
:param subjects_dir: path to directory with patient`s files
:type subjects_dir: str
:param conductivity: the conductivities to use for each brain tissue shell. Single element for single-layer model or three elements for three-layer model
:type conductivity: tuple
:param _subject_tree: representation of patient`s files structure, default None
:type _subject_tree: *look for SubjectTree in* :mod:`nodestimation.project.annotations` *, optional*
:param _priority: if several files are read, which one to choose, if None, read all of them, default None
:type _priority: int, optional
:return: bem_ solution
:rtype: mne.bem.ConductorModel_
.. _imne.bem.ConductorModel:
.. _mne.bem.ConductorModel:
.. _bem: https://mne.tools/stable/generated/mne.bem.ConductorModel.html?highlight=conductormodel#mne.bem.ConductorModel
"""
model = mne.make_bem_model(subject=subject,
conductivity=conductivity,
subjects_dir=subjects_dir)
return mne.make_bem_solution(model)
def setup_bem():
if not os.path.exists('bem/fsaverage_bem.fif'):
model = mne.make_bem_model(MNE_Repo_Mat.subject)
bem_sol = mne.make_bem_solution(model)
mne.write_bem_solution('bem/fsaverage_bem.fif',bem_sol)
else:
bem_sol = mne.read_bem_solution('bem/fsaverage_bem.fif')
return bem_sol
def create_bem_sol(sbj_dir, sbj_id):
"""Create bem solution."""
import os.path as op
import mne
from mne.bem import make_watershed_bem
from mne.report import Report
report = Report()
bem_dir = op.join(sbj_dir, sbj_id, 'bem')
surf_name = 'inner_skull.surf'
sbj_inner_skull_fname = op.join(bem_dir, sbj_id + '-' + surf_name)
inner_skull_fname = op.join(bem_dir, surf_name)
# check if bem-sol was created, if not creates the bem sol using C MNE
bem_fname = op.join(bem_dir, '%s-5120-bem-sol.fif' % sbj_id)
model_fname = op.join(bem_dir, '%s-5120-bem.fif' % sbj_id)
if not op.isfile(bem_fname):
# chek if inner_skull surf exists, if not BEM computation is
# performed by MNE python functions mne.bem.make_watershed_bem
if not (op.isfile(sbj_inner_skull_fname)
or op.isfile(inner_skull_fname)):
print("%s ---> FILE NOT FOUND!!!---> BEM "
"computed" % inner_skull_fname)
make_watershed_bem(sbj_id, sbj_dir, overwrite=True)
else:
print(("\n*** inner skull %s surface "
"exists!!!\n" % inner_skull_fname))
# Create a BEM model for a subject
surfaces = mne.make_bem_model(sbj_id,
ico=4,
conductivity=[0.3],
subjects_dir=sbj_dir)
# Write BEM surfaces to a fiff file
mne.write_bem_surfaces(model_fname, surfaces)
# Create a BEM solution using the linear collocation approach
bem = mne.make_bem_solution(surfaces)
mne.write_bem_solution(bem_fname, bem)
print(('\n*** BEM solution file %s written ***\n' % bem_fname))
# add BEM figures to a Report
report.add_bem_to_section(subject=sbj_id, subjects_dir=sbj_dir)
report_filename = op.join(bem_dir, "BEM_report.html")
print(('\n*** REPORT file %s written ***\n' % report_filename))
print(report_filename)
report.save(report_filename, open_browser=False, overwrite=True)
else:
bem = bem_fname
print(('\n*** BEM solution file %s exists!!! ***\n' % bem_fname))
return bem
def make_anony_fwd(subject,
dir_base,
subjects_dir,
conductivity=(0.3, 0.006, 0.3),
ico=4):
import os.path as op
from mne.io.constants import FIFF
from mne.bem import _surfaces_to_bem, _check_bem_size
import glob
import mayavi.mlab as mlab
for m in ['anonymi', 'defaced', 'mf']:
print('Preparing fwd - method: %s' % m)
bem_dir = op.join(dir_base, 'spatial', 'bems', m)
inner_skull = op.join(bem_dir,
'%s_%s_inner_skull_surface' % (subject, m))
outer_skull = op.join(bem_dir,
'%s_%s_outer_skull_surface' % (subject, m))
outer_skin = op.join(bem_dir,
'%s_%s_outer_skin_surface' % (subject, m))
surfaces = [inner_skull, outer_skull, outer_skin]
ids = [
FIFF.FIFFV_BEM_SURF_ID_BRAIN, FIFF.FIFFV_BEM_SURF_ID_SKULL,
FIFF.FIFFV_BEM_SURF_ID_HEAD
]
surfaces = _surfaces_to_bem(surfaces, ids, conductivity, ico)
_check_bem_size(surfaces)
bem = mne.make_bem_solution(surfaces)
bem_fname = op.join(dir_base, 'spatial', 'bems', m,
'%s_%s-bem.fif' % (subject, m))
mne.write_bem_solution(bem_fname, bem)
files_epochs = glob.glob(
op.join(dir_base, 'data', 'fif', '%s*' % subject))
epo = mne.read_epochs(files_epochs[0])
trans_fname = op.join(dir_base, 'spatial', 'fwd',
'%s-trans.fif' % subject)
src_fname = op.join(dir_base, 'spatial', 'fwd', '%s-src.fif' % subject)
fwd = mne.make_forward_solution(epo.info, trans_fname, src_fname,
bem_fname)
trans = mne.read_trans(trans_fname)
mne.viz.plot_alignment(epo.info,
trans,
subject=subject,
surfaces=['head', 'brain'],
bem=bem,
subjects_dir=subjects_dir)
mlab.show()
mne.write_forward_solution(
op.join(dir_base, 'spatial', 'bems', m,
'%s_%s-fwd.fif' % (subject, m)), fwd)
def run_forward(subject, session=None):
deriv_path = config.get_subject_deriv_path(subject=subject,
session=session,
kind=config.get_kind())
bids_basename = make_bids_basename(subject=subject,
session=session,
task=config.get_task(),
acquisition=config.acq,
run=None,
processing=config.proc,
recording=config.rec,
space=config.space)
fname_evoked = op.join(deriv_path, bids_basename + '-ave.fif')
fname_trans = op.join(deriv_path, 'sub-{}'.format(subject) + '-trans.fif')
fname_fwd = op.join(deriv_path, bids_basename + '-fwd.fif')
msg = f'Input: {fname_evoked}, Output: {fname_fwd}'
logger.info(gen_log_message(message=msg, step=10, subject=subject,
session=session))
# Find the raw data file
# XXX : maybe simplify
bids_basename = make_bids_basename(subject=subject,
session=session,
task=config.get_task(),
acquisition=config.acq,
run=config.get_runs()[0],
processing=config.proc,
recording=config.rec,
space=config.space)
trans = get_head_mri_trans(bids_basename=bids_basename,
bids_root=config.bids_root)
mne.write_trans(fname_trans, trans)
src = mne.setup_source_space(subject, spacing=config.spacing,
subjects_dir=config.get_fs_subjects_dir(),
add_dist=False)
evoked = mne.read_evokeds(fname_evoked, condition=0)
# Here we only use 3-layers BEM only if EEG is available.
if 'eeg' in config.ch_types:
model = mne.make_bem_model(subject, ico=4,
conductivity=(0.3, 0.006, 0.3),
subjects_dir=config.get_fs_subjects_dir())
else:
model = mne.make_bem_model(subject, ico=4, conductivity=(0.3,),
subjects_dir=config.get_fs_subjects_dir())
bem = mne.make_bem_solution(model)
fwd = mne.make_forward_solution(evoked.info, trans, src, bem,
mindist=config.mindist)
mne.write_forward_solution(fname_fwd, fwd, overwrite=True)
def repeat_coreg(subject,
subjects_dir=None,
subjects_dir_old=None,
overwrite=False,
verbose=None):
"""Repeat a mne coreg warping of an MRI.
This is useful for example when bugs are fixed with
:func:`mne.scale_mri`.
.. warning:: This function should not be used when the parameters
in ``'MRI scaling parameters.cfg'`` have been changed.
Parameters
----------
subject : str
The subject name.
subjects_dir : str | None
The subjects directory where the redone subject should go.
The template/surrogate MRI must also be in this directory.
subjects_dir_old : str | None
The subjects directory where the old subject is.
Can be None to use ``subjects_dir``.
overwrite : bool
If True (default False), overwrite an existing subject directory
if it exists.
verbose : str | None
The verbose level to use.
Returns
-------
out_dir : str
The output subject directory.
"""
subjects_dir = mne.utils.get_subjects_dir(subjects_dir)
if subjects_dir_old is None:
subjects_dir_old = subjects_dir
config = mne.coreg.read_mri_cfg(subject, subjects_dir_old)
n_params = config.pop('n_params')
assert n_params in (3, 1), n_params
out_dir = op.join(subjects_dir, subject)
mne.coreg.scale_mri(subject_to=subject,
subjects_dir=subjects_dir,
labels=True,
annot=True,
overwrite=overwrite,
**config)
for pattern in ('-5120', '-5120-5120-5120', 'inner_skull'):
fname_bem = op.join(subjects_dir, subject, 'bem',
f'{subject}{pattern}-bem.fif')
fname_sol = fname_bem[:-4] + '-sol.fif'
if op.isfile(fname_bem) and not op.isfile(fname_sol):
bem = mne.read_bem_surfaces(fname_bem)
sol = mne.make_bem_solution(bem)
mne.write_bem_solution(fname_sol, sol)
return out_dir
def run_forward(subject, session=None):
deriv_path = config.get_subject_deriv_path(subject=subject,
session=session,
kind=config.get_kind())
bids_basename = BIDSPath(subject=subject,
session=session,
task=config.get_task(),
acquisition=config.acq,
run=None,
recording=config.rec,
space=config.space,
prefix=deriv_path,
check=False)
fname_evoked = bids_basename.copy().update(kind='ave', extension='.fif')
fname_trans = bids_basename.copy().update(kind='trans', extension='.fif')
fname_fwd = bids_basename.copy().update(kind='fwd', extension='.fif')
msg = f'Input: {fname_evoked}, Output: {fname_fwd}'
logger.info(
gen_log_message(message=msg, step=10, subject=subject,
session=session))
# Find the raw data file
trans = get_head_mri_trans(bids_basename=(bids_basename.copy().update(
run=config.get_runs()[0], prefix=None)),
bids_root=config.bids_root)
mne.write_trans(fname_trans, trans)
src = mne.setup_source_space(subject,
spacing=config.spacing,
subjects_dir=config.get_fs_subjects_dir(),
add_dist=False)
evoked = mne.read_evokeds(fname_evoked, condition=0)
# Here we only use 3-layers BEM only if EEG is available.
if 'eeg' in config.ch_types:
model = mne.make_bem_model(subject,
ico=4,
conductivity=(0.3, 0.006, 0.3),
subjects_dir=config.get_fs_subjects_dir())
else:
model = mne.make_bem_model(subject,
ico=4,
conductivity=(0.3, ),
subjects_dir=config.get_fs_subjects_dir())
bem = mne.make_bem_solution(model)
fwd = mne.make_forward_solution(evoked.info,
trans,
src,
bem,
mindist=config.mindist)
mne.write_forward_solution(fname_fwd, fwd, overwrite=True)
def finalize_model(conductivity,src,trans,subjects_dir,raw_fname,ico):
model = mne.make_bem_model(subject='sample', ico=ico,
conductivity=conductivity,
subjects_dir=subjects_dir)
bem = mne.make_bem_solution(model)
fwd = mne.convert_forward_solution(mne.make_forward_solution(raw_fname, trans=trans, src=src, bem=bem,
meg=False,eeg=True, mindist=5.0, n_jobs=2),force_fixed=True)
del model
return fwd
def run_forward(subject, session=None):
bids_path = BIDSPath(subject=subject,
session=session,
task=config.get_task(),
acquisition=config.acq,
run=None,
recording=config.rec,
space=config.space,
extension='.fif',
datatype=config.get_datatype(),
root=config.deriv_root,
check=False)
fname_evoked = bids_path.copy().update(suffix='ave')
fname_trans = bids_path.copy().update(suffix='trans')
fname_fwd = bids_path.copy().update(suffix='fwd')
msg = f'Input: {fname_evoked}, Output: {fname_fwd}'
logger.info(
gen_log_message(message=msg, step=10, subject=subject,
session=session))
# Retrieve the head -> MRI transformation matrix from the MRI sidecar file
# in the input data, and save it to an MNE "trans" file in the derivatives
# folder.
trans = get_head_mri_trans(bids_path.copy().update(
run=config.get_runs()[0], root=config.bids_root))
mne.write_trans(fname_trans, trans)
src = mne.setup_source_space(subject,
spacing=config.spacing,
subjects_dir=config.get_fs_subjects_dir(),
add_dist=False)
evoked = mne.read_evokeds(fname_evoked, condition=0)
# Here we only use 3-layers BEM only if EEG is available.
if 'eeg' in config.ch_types:
model = mne.make_bem_model(subject,
ico=4,
conductivity=(0.3, 0.006, 0.3),
subjects_dir=config.get_fs_subjects_dir())
else:
model = mne.make_bem_model(subject,
ico=4,
conductivity=(0.3, ),
subjects_dir=config.get_fs_subjects_dir())
bem = mne.make_bem_solution(model)
fwd = mne.make_forward_solution(evoked.info,
trans,
src,
bem,
mindist=config.mindist)
mne.write_forward_solution(fname_fwd, fwd, overwrite=True)
def forward_model(subject, subjects_dir, fname_meg, trans, src, fwd_fname):
#conductivity = (0.3, 0.006, 0.3) # for three layers
conductivity = (0.3,) # for single layer
model = mne.make_bem_model(subject=subject, ico=4,
conductivity=conductivity,
subjects_dir=subjects_dir)
bem = mne.make_bem_solution(model)
fwd = mne.make_forward_solution(fname_meg, trans=trans, src=src, bem=bem,
meg=True, eeg=False, mindist=5.06)
# print(fwd)
mne.write_forward_solution(fwd_fname, fwd, overwrite=True, verbose=None)
def __make_bem_individual(sub, fs_sub_dir, outdir, single_layers):
"""
:param sub:
:param fs_sub_dir:
:param single_layers:
:return:
"""
# see if file exists and skip if so
if os.path.isfile(f'{outdir}/{sub}-5120-5120-5120-bem.fif'):
print(f'{sub} has full file skipping')
model = mne.read_bem_surfaces(f'{outdir}/{sub}-5120-5120-5120-bem.fif')
solname = f'{outdir}/{sub}-5120-5120-5120-bem-sol.fif'
# if single layers is true check for this, if not we want to try full model
elif os.path.isfile(f'{outdir}/{sub}-5120-5120-5120-single-bem.fif'):
if single_layers:
print(f'{sub} has single layer file skipping')
model = mne.read_bem_surfaces(
f'{outdir}/{sub}-5120-5120-5120-single-bem.fif')
solname = f'{outdir}/{sub}-5120-5120-5120-single-bem-sol.fif'
else:
# make model
try:
model = mne.make_bem_model(sub, subjects_dir=fs_sub_dir)
bemname = f'{outdir}/{sub}-5120-5120-5120-bem.fif'
solname = f'{outdir}/{sub}-5120-5120-5120-bem-sol.fif'
except:
print('failed to make BEM model with input')
if single_layers:
try:
print(
'falling back to single layer model due to BEM suckiness'
)
model = mne.make_bem_model(sub,
subjects_dir=fs_sub_dir,
conductivity=[0.3])
bemname = f'{outdir}/{sub}-5120-5120-5120-single-bem.fif'
solname = f'{outdir}/{sub}-5120-5120-5120-single-bem-sol.fif'
except:
print(f'oops that also failed for {sub}')
return ''
else:
print('wont allow single layer model so skipping')
return ''
# save model
mne.write_bem_surfaces(bemname, model) # save to source dir
bem_sol = mne.make_bem_solution(model) # make bem solution using model
mne.write_bem_solution(solname, bem_sol) # save as well to the outdir
return solname
def create_bem_sol(sbj_dir, sbj_id):
import os.path as op
import mne
from mne.bem import make_watershed_bem
from mne.report import Report
report = Report()
bem_dir = op.join(sbj_dir, sbj_id, 'bem')
surf_name = 'inner_skull.surf'
sbj_inner_skull_fname = op.join(bem_dir, sbj_id + '-' + surf_name)
inner_skull_fname = op.join(bem_dir, surf_name)
# check if bem-sol was created, if not creates the bem sol using C MNE
bem_fname = op.join(bem_dir, '%s-5120-bem-sol.fif' % sbj_id)
model_fname = op.join(bem_dir, '%s-5120-bem.fif' % sbj_id)
if not op.isfile(bem_fname):
# chek if inner_skull surf exists, if not BEM computation is
# performed by MNE python functions mne.bem.make_watershed_bem
if not (op.isfile(sbj_inner_skull_fname) or
op.isfile(inner_skull_fname)):
print inner_skull_fname + '---> FILE NOT FOUND!!!---> BEM computed'
make_watershed_bem(sbj_id, sbj_dir, overwrite=True)
else:
print '\n*** inner skull %s surface exists!!!\n' % inner_skull_fname
# Create a BEM model for a subject
surfaces = mne.make_bem_model(sbj_id, ico=4, conductivity=[0.3],
subjects_dir=sbj_dir)
# Write BEM surfaces to a fiff file
mne.write_bem_surfaces(model_fname, surfaces)
# Create a BEM solution using the linear collocation approach
bem = mne.make_bem_solution(surfaces)
mne.write_bem_solution(bem_fname, bem)
print '\n*** BEM solution file %s written ***\n' % bem_fname
# add BEM figures to a Report
report.add_bem_to_section(subject=sbj_id, subjects_dir=sbj_dir)
report_filename = op.join(bem_dir, "BEM_report.html")
print '\n*** REPORT file %s written ***\n' % report_filename
print report_filename
report.save(report_filename, open_browser=False, overwrite=True)
else:
bem = bem_fname
print '\n*** BEM solution file %s exists!!! ***\n' % bem_fname
return bem
def get_leadfield(subject,
raw_filename,
epochs_filename,
trans_filename,
conductivity=(0.3, 0.006, 0.3),
njobs=4,
bem_sub_path='bem',
sdir=None):
"""Compute leadfield with presets for this subject
Args:
subject : str
Name of freesurfer subject
raw_filename : str
Filename that points to the raw data for this lead field.
This file will be used to extract a CTF transformation matrix
and an info struct.
epochs_filename : str
Filename from which fiducial locations will be extracted.
trans_filename : str
Points to transformation file between fiducials and MRI.
conductivity : 3-tuple of floats
Conductivities for BEM model
njobs: int
Number of cores to paralellize over
bem_sub_path: str
Sub-path of freesurfer subject path where to read bem
surfaces from
Returns:
Tuple of (forward model, BEM model, source space)
"""
if sdir is None:
sdir = subjects_dir
src = get_source_space(subject, sdir=sdir)
model = make_bem_model(subject=subject,
ico=None,
conductivity=conductivity,
subjects_dir=sdir,
bem_sub_path=bem_sub_path)
bem = mne.make_bem_solution(model)
info = get_info(raw_filename, epochs_filename)
fwd = mne.make_forward_solution(info,
trans=trans_filename,
src=src,
bem=bem,
meg=True,
eeg=False,
mindist=2.5,
n_jobs=njobs)
return fwd, bem, fwd['src']
def make_bem_solutions(subject, subjects_dir):
command = mne.make_bem_model(subject,
ico=4,
conductivity=[0.3],
subjects_dir=subjects_dir,
verbose=None)
solution = mne.make_bem_solution(command, verbose=None)
filename = subject + '-5120-bem-sol.fif'
saveSolution_path = subjects_dir + subject + '/bem/' + filename
mne.write_bem_solution(saveSolution_path, solution)
'''
def repeat_coreg(subject,
subjects_dir=None,
subjects_dir_old=None,
overwrite=False,
verbose=None):
"""Repeat a mne coreg warping of an MRI.
This is useful for example when bugs are fixed with
:func:`mne.scale_mri`.
Parameters
----------
subject : str
The subject name.
subjects_dir : str | None
The subjects directory where the redone subject should go.
The template/surrogate MRI must also be in this directory.
subjects_dir_old : str | None
The subjects directory where the old subject is.
Can be None to use ``subjects_dir``.
overwrite : bool
If True (default False), overwrite an existing subject directory
if it exists.
verbose : str | None
The verbose level to use.
Returns
-------
out_dir : str
The output subject directory.
"""
subjects_dir = mne.utils.get_subjects_dir(subjects_dir)
if subjects_dir_old is None:
subjects_dir_old = subjects_dir
config = mne.coreg.read_mri_cfg(subject, subjects_dir_old)
n_params = config.pop('n_params')
assert n_params in (3, 1), n_params
out_dir = op.join(subjects_dir, subject)
mne.coreg.scale_mri(subject_to=subject,
subjects_dir=subjects_dir,
labels=False,
annot=False,
overwrite=overwrite,
**config)
sol_file = op.join(subjects_dir, subject, 'bem',
'%s-5120-bem-sol.fif' % subject)
if not op.isfile(sol_file):
print(' Computing BEM solution')
sol = mne.make_bem_solution(sol_file[:-8] + '.fif')
mne.write_bem_solution(sol_file, sol)
return out_dir
def process_subject_bem(subject, spacing='ico5'):
mne.bem.make_watershed_bem(subject=subject, subjects_dir=subjects_dir, overwrite=True, volume='T1', atlas=True,
gcaatlas=False, preflood=None)
conductivity = (0.3,)
model = mne.make_bem_model(subject=subject, ico=4,
conductivity=conductivity,
subjects_dir=subjects_dir)
bem = mne.make_bem_solution(model)
src = mne.setup_source_space(subject, spacing=spacing,
subjects_dir=subjects_dir,
add_dist=False)
bem_fname = op.join(subjects_dir,subject,'bem', '%s-src.fif' % subject)
src_fname = op.join(subjects_dir, subject, 'bem', '%s-src.fif' % spacing)
mne.write_bem_solution(bem_fname, bem=bem)
mne.write_source_spaces(src_fname, src=src)
def test_bem_solution():
"""Test making a BEM solution from Python with I/O"""
# test degenerate conditions
surf = read_bem_surfaces(fname_bem_1)[0]
assert_raises(RuntimeError, _ico_downsample, surf, 10) # bad dec grade
s_bad = dict(tris=surf['tris'][1:], ntri=surf['ntri'] - 1, rr=surf['rr'])
assert_raises(RuntimeError, _ico_downsample, s_bad, 1) # not isomorphic
s_bad = dict(tris=surf['tris'].copy(), ntri=surf['ntri'],
rr=surf['rr']) # bad triangulation
s_bad['tris'][0] = [0, 0, 0]
assert_raises(RuntimeError, _ico_downsample, s_bad, 1)
s_bad['id'] = 1
assert_raises(RuntimeError, _assert_complete_surface, s_bad)
s_bad = dict(tris=surf['tris'], ntri=surf['ntri'], rr=surf['rr'].copy())
s_bad['rr'][0] = 0.
assert_raises(RuntimeError, _get_ico_map, surf, s_bad)
surfs = read_bem_surfaces(fname_bem_3)
assert_raises(RuntimeError, _assert_inside, surfs[0], surfs[1]) # outside
surfs[0]['id'] = 100 # bad surfs
assert_raises(RuntimeError, _order_surfaces, surfs)
surfs[1]['rr'] /= 1000.
assert_raises(RuntimeError, _check_surface_size, surfs[1])
# actually test functionality
tempdir = _TempDir()
fname_temp = op.join(tempdir, 'temp-bem-sol.fif')
# use a model and solution made in Python
conductivities = [(0.3, ), (0.3, 0.006, 0.3)]
fnames = [fname_bem_sol_1, fname_bem_sol_3]
for cond, fname in zip(conductivities, fnames):
for model_type in ('python', 'c'):
if model_type == 'python':
model = make_bem_model('sample',
conductivity=cond,
ico=2,
subjects_dir=subjects_dir)
else:
model = fname_bem_1 if len(cond) == 1 else fname_bem_3
solution = make_bem_solution(model)
solution_c = read_bem_solution(fname)
_compare_bem_solutions(solution, solution_c)
write_bem_solution(fname_temp, solution)
solution_read = read_bem_solution(fname_temp)
_compare_bem_solutions(solution, solution_c)
_compare_bem_solutions(solution_read, solution_c)
def create_bem(subject, bem_dir=None, json_fname='default'):
""" Create the BEM model from FreeSurfer files
Parameters:
----------
subject : str
Name of the subject to calculate the BEM model
Returns:
-------
surfaces : list of dict
BEM surfaces
bem : instance of ConductorModel
BEM model
-------
"""
db_fs, _, db_mne = read_db_coords(json_fname)
assert not (db_mne == None
and bem_dir == None), 'Pleas specify the bem_dir location'
if db_mne != None:
_, _, _, _, _, bem_dir, _, _ = mne_directories(json_fname)
bem_dir = bem_dir.format(subject)
print('\n---------- Resolving BEM model and BEM soultion ----------\n')
# database, project, db_mne, db_bv, db_fs = read_databases(json_fname)
#
# raw_dir, prep_dir, trans_dir, mri_dir, src_dir, bem_dir, fwd_dir, hga_dir = read_directories(json_fname)
fname_bem_model = op.join(bem_dir, '{0}-bem-model.fif'.format(subject))
fname_bem_sol = op.join(bem_dir, '{0}-bem-sol.fif'.format(subject))
# Make bem model: single-shell model. Depends on anatomy only.
bem_model = mne.make_bem_model(subject,
ico=None,
conductivity=[0.3],
subjects_dir=op.join(db_fs))
mne.write_bem_surfaces(fname_bem_model, bem_model)
# Make bem solution. Depends on anatomy only.
bem_sol = mne.make_bem_solution(bem_model)
mne.write_bem_solution(fname_bem_sol, bem_sol)
return bem_model, bem_sol
def gen_fwd(subject, conductivity, info):
src = mne.read_source_spaces(subject_dir + '/sub-' + subject + '_free' +
'/sub-' + subject + '_free-src.fif')
trans = subject_dir + '/sub-' + subject + '_free' + '/sub-' + subject + '_free-trans.fif'
model = mne.make_bem_model(subject='sub-' + subject + '_free',
ico=4,
conductivity=conductivity,
subjects_dir=subject_dir)
bem = mne.make_bem_solution(model)
return mne.make_forward_solution(info,
trans=trans,
src=src,
bem=bem,
eeg=True,
meg=False,
mindist=5.0,
n_jobs=2)
def test_bem_solution():
"""Test making a BEM solution from Python with I/O."""
# test degenerate conditions
surf = read_bem_surfaces(fname_bem_1)[0]
pytest.raises(RuntimeError, _ico_downsample, surf, 10) # bad dec grade
s_bad = dict(tris=surf['tris'][1:], ntri=surf['ntri'] - 1, rr=surf['rr'])
pytest.raises(RuntimeError, _ico_downsample, s_bad, 1) # not isomorphic
s_bad = dict(tris=surf['tris'].copy(), ntri=surf['ntri'],
rr=surf['rr']) # bad triangulation
s_bad['tris'][0] = [0, 0, 0]
pytest.raises(RuntimeError, _ico_downsample, s_bad, 1)
s_bad['id'] = 1
pytest.raises(RuntimeError, _assert_complete_surface, s_bad)
s_bad = dict(tris=surf['tris'], ntri=surf['ntri'], rr=surf['rr'].copy())
s_bad['rr'][0] = 0.
pytest.raises(RuntimeError, _get_ico_map, surf, s_bad)
surfs = read_bem_surfaces(fname_bem_3)
pytest.raises(RuntimeError, _assert_inside, surfs[0], surfs[1]) # outside
surfs[0]['id'] = 100 # bad surfs
pytest.raises(RuntimeError, _order_surfaces, surfs)
surfs[1]['rr'] /= 1000.
pytest.raises(RuntimeError, _check_surface_size, surfs[1])
# actually test functionality
tempdir = _TempDir()
fname_temp = op.join(tempdir, 'temp-bem-sol.fif')
# use a model and solution made in Python
conductivities = [(0.3,), (0.3, 0.006, 0.3)]
fnames = [fname_bem_sol_1, fname_bem_sol_3]
for cond, fname in zip(conductivities, fnames):
for model_type in ('python', 'c'):
if model_type == 'python':
model = make_bem_model('sample', conductivity=cond, ico=2,
subjects_dir=subjects_dir)
else:
model = fname_bem_1 if len(cond) == 1 else fname_bem_3
solution = make_bem_solution(model)
solution_c = read_bem_solution(fname)
_compare_bem_solutions(solution, solution_c)
write_bem_solution(fname_temp, solution)
solution_read = read_bem_solution(fname_temp)
_compare_bem_solutions(solution, solution_c)
_compare_bem_solutions(solution_read, solution_c)
def makeBem(subj):
camcan_root = os.environ['CAMCAN_ROOT']
bemmodel_fname = camcan_root + 'processed/cc700/mri/pipeline/release004/BIDSsep/megraw/' + subj + '/meg/' + subj + \
'-5120-5120-5120-singles-bem.fif'
bemsolution_fname = camcan_root + 'processed/cc700/mri/pipeline/release004/BIDSsep/megraw/' + subj + '/meg/' + \
subj + '-5120-5120-5120-singles-bem-sol.fif'
try:
model = mne.read_bem_surfaces(bemmodel_fname)
except IOError:
model = mne.make_bem_model(subj, conductivity=[0.3])
mne.write_bem_surfaces(bemmodel_fname, model)
try:
bem_sol = mne.read_bem_solution(bemsolution_fname)
except IOError:
bem_sol = mne.make_bem_solution(model)
mne.write_bem_solution(bemsolution_fname, bem_sol)
return bem_sol
def run():
"""Run command."""
from mne.commands.utils import get_optparser, _add_verbose_flag
parser = get_optparser(__file__)
parser.add_option('--bem',
dest='bem_fname',
help='The name of the file containing the '
'triangulations of the BEM surfaces and the '
'conductivities of the compartments. The standard '
'ending for this file is -bem.fif.',
metavar="FILE")
parser.add_option('--sol',
dest='bem_sol_fname',
help='The name of the resulting file containing BEM '
'solution (geometry matrix). It uses the linear '
'collocation approach. The file should end with '
'-bem-sof.fif.',
metavar='FILE',
default=None)
_add_verbose_flag(parser)
options, args = parser.parse_args()
bem_fname = options.bem_fname
bem_sol_fname = options.bem_sol_fname
verbose = True if options.verbose is not None else False
if bem_fname is None:
parser.print_help()
sys.exit(1)
if bem_sol_fname is None:
base, _ = os.path.splitext(bem_fname)
bem_sol_fname = base + '-sol.fif'
bem_model = mne.read_bem_surfaces(bem_fname,
patch_stats=False,
verbose=verbose)
bem_solution = mne.make_bem_solution(bem_model, verbose=verbose)
mne.write_bem_solution(bem_sol_fname, bem_solution)
def make_bem_and_source_space(subject, subjects_dir, dir_base):
# BEM
mne.bem.make_watershed_bem(subject, subjects_dir, volume='T1', show=True)
conductivity = (0.3, 0.006, 0.3)
model = mne.make_bem_model(subject=subject,
ico=4,
conductivity=conductivity,
subjects_dir=subjects_dir)
bem = mne.make_bem_solution(model)
mne.write_bem_solution(
op.join(dir_base, 'spatial', 'fwd', '%s-bem.fif' % subject), bem)
# Anatomical Source Space
src = mne.setup_source_space(subject,
spacing='oct6',
subjects_dir=subjects_dir)
mne.write_source_spaces(
op.join(dir_base, 'spatial', 'fwd', '%s-src.fif' % subject), src)
def src_modelling(self, spacing=['oct5'], overwrite=False):
from mne import (read_forward_solution, make_forward_solution,
write_forward_solution, setup_source_space)
subject = self.subject
task = self.experiment
mne.set_config('SUBJECTS_DIR', self.pth_FS)
FS_subj = op.join(self.pth_FS, subject)
fname_trans = op.join(FS_subj, subject + '-trans.fif')
fname_bem = op.join(FS_subj, '%s-bem_sol.fif' % subject)
if not op.exists(fname_bem) or overwrite:
# make_watershed_bem already run in the sh script
# mne.bem.make_watershed_bem(subject, overwrite=True,
# volume='T1', atlas=True, gcaatlas=False,
# preflood=None)
model = mne.make_bem_model(subject, ico=4, conductivity=[0.3])
bem = mne.make_bem_solution(model)
mne.write_bem_solution(fname_bem, bem)
else:
bem = mne.read_bem_solution(fname_bem)
for space in spacing:
fname_src = op.join(FS_subj, 'bem', '%s-src.fif' % space)
bname_fwd = '%s_%s_%s-fwd.fif' % (subject, task, space)
fname_fwd = op.join(self.out_srcData, bname_fwd)
if not op.exists(fname_src) or overwrite:
src = setup_source_space(subject, space,
subjects_dir=self.pth_FS)
src.save(fname_src, overwrite=overwrite)
if op.exists(fname_fwd) and not overwrite:
self.fwd = read_forward_solution(fname_fwd)
else:
self.fwd = make_forward_solution(self.raw.info, fname_trans,
fname_src, fname_bem)
write_forward_solution(fname_fwd, self.fwd, overwrite)
def create_bem(json_fname, subject):
""" Create the BEM model from FreeSurfer files
Parameters:
----------
subject : str
Name of the subject to calculate the BEM model
Returns:
-------
surfaces : list of dict
BEM surfaces
bem : instance of ConductorModel
BEM model
-------
"""
print('\n---------- Resolving BEM model and BEM soultion ----------\n')
database, project, db_mne, db_bv, db_fs = read_databases(json_fname)
raw_dir, prep_dir, trans_dir, mri_dir, src_dir, bem_dir, fwd_dir, hga_dir = read_directories(json_fname)
fname_bem_model = op.join(bem_dir.format(subject), '{0}-bem-model.fif'.format(subject))
fname_bem_sol = op.join(bem_dir.format(subject), '{0}-bem-sol.fif'.format(subject))
# Make bem model: single-shell model. Depends on anatomy only.
bem_model = mne.make_bem_model(subject, ico=None, conductivity=[0.3], subjects_dir=op.join(db_fs, project))
mne.write_bem_surfaces(fname_bem_model, bem_model)
# Make bem solution. Depends on anatomy only.
bem_sol = mne.make_bem_solution(bem_model)
mne.write_bem_solution(fname_bem_sol, bem_sol)
return bem_model, bem_sol
# preproc_dir = "G:/TSM_test/NEM_proc/"
# trans_dir = "G:/TSM_test/NEM_proc/" # enter your special trans file folder here
# meg_dir = "G:/TSM_test/NEM_proc/"
meg_dir = "V:/Alle/Müller-Voggel/anne/"
mri_dir = "D:/freesurfer/subjects/"
sub_dict = {"TSM_02":"BAE51","TSM_07":"DTN25_fa","TSM_17":"EAH91_fa","TSM_19":"HHH42","TSM_26":"LEN04_fa",
"TSM_22":"NAI16_fa","TSM_16":"NIC98","TSM_11":"NLK24_fa","TSM_04":"NLL75_fa","TSM_21":"NNE17",
"TSM_15":"NOI26_fa","TSM_24":"NOR76","TSM_27":"NUT15_fa","TSM_20":"RTB16","TSM_23":"SRA67_fa",
"TSM_06":"VIM71_fa","TSM_13":"BEU80"}
# sub_dict = {"NEM_26":"ENR41"}
## prep fsaverage
# build BEM model for fsaverage (as boundary for source space creation) --- only needed for volume or mixed source spaces
bem_model = mne.make_bem_model("fsaverage", subjects_dir=mri_dir, ico=5, conductivity=[0.3])
bem = mne.make_bem_solution(bem_model)
mne.write_bem_solution("{dir}fsaverage-bem.fif".format(dir=meg_dir),bem)
mne.viz.plot_bem(subject="fsaverage", subjects_dir=mri_dir, brain_surfaces='white', orientation='coronal')
# build fs_average mixed 'oct6' surface source space & save (to use as morph target later)
fs_src = mne.setup_source_space("fsaverage", spacing='oct6', surface="white", subjects_dir=mri_dir, n_jobs=6)
# print out the number of spaces and points
n = sum(fs_src[i]['nuse'] for i in range(len(fs_src)))
print('the fs_src space contains %d spaces and %d points' % (len(fs_src), n))
fs_src.plot(subjects_dir=mri_dir)
# save the surface source space
fs_src.save("{}fsaverage_oct6_mix-src.fif".format(meg_dir), overwrite=True)
del fs_src
## prep subjects
def compute_LF_matrix(sbj_id, sbj_dir, raw_info, aseg, spacing, labels):
import os.path as op
import mne
from mne.bem import make_watershed_bem
from mne.report import Report
from nipype.utils.filemanip import split_filename as split_f
from neuropype_ephy.compute_fwd_problem import create_mixed_source_space
report = Report()
bem_dir = op.join(sbj_dir, sbj_id, 'bem')
surf_name = 'inner_skull.surf'
sbj_inner_skull_fname = op.join(bem_dir, sbj_id + '-' + surf_name)
inner_skull_fname = op.join(bem_dir, surf_name)
data_path, raw_fname, ext = split_f(raw_info['filename'])
if aseg:
fwd_filename = op.join(data_path, '%s-%s-aseg-fwd.fif'
% (raw_fname, spacing))
else:
fwd_filename = op.join(data_path, '%s-%s-fwd.fif'
% (raw_fname, spacing))
# check if we have just created the fwd matrix
if not op.isfile(fwd_filename):
# check if bem-sol was created, if not creates the bem sol using C MNE
bem_fname = op.join(bem_dir, '%s-5120-bem-sol.fif' % sbj_id)
model_fname = op.join(bem_dir, '%s-5120-bem.fif' % sbj_id)
if not op.isfile(bem_fname):
# chek if inner_skull surf exists, if not BEM computation is
# performed by MNE python functions mne.bem.make_watershed_bem
if not (op.isfile(sbj_inner_skull_fname) or
op.isfile(inner_skull_fname)):
print sbj_inner_skull_fname + '---> FILE NOT FOUND!!! ---> BEM is computed'
make_watershed_bem(sbj_id, sbj_dir, overwrite=True)
else:
print '*** inner skull surface exists!!!'
# Create a BEM model for a subject
surfaces = mne.make_bem_model(sbj_id, ico=4, conductivity=[0.3],
subjects_dir=sbj_dir)
# Write BEM surfaces to a fiff file
mne.write_bem_surfaces(model_fname, surfaces)
# Create a BEM solution using the linear collocation approach
bem = mne.make_bem_solution(surfaces)
mne.write_bem_solution(bem_fname, bem)
print '*** BEM solution file %s written ***' % bem_fname
# add BEM figures to a Report
report.add_bem_to_section(subject=sbj_id, subjects_dir=sbj_dir)
report_filename = op.join(bem_dir, "BEM_report.html")
print report_filename
report.save(report_filename, open_browser=False, overwrite=True)
else:
bem = bem_fname
print '*** BEM solution file %s exists!!!' % bem_fname
# check if source space exists, if not it creates using mne-python fun
# we have to create the cortical surface source space even when aseg is
# True
src_fname = op.join(bem_dir, '%s-%s-src.fif' % (sbj_id, spacing))
if not op.isfile(src_fname):
src = mne.setup_source_space(sbj_id, subjects_dir=sbj_dir,
fname=True,
spacing=spacing.replace('-', ''),
add_dist=False, overwrite=True,
n_jobs=2)
print '*** source space file %s written ***' % src_fname
else:
print '*** source space file %s exists!!!' % src_fname
src = mne.read_source_spaces(src_fname)
if aseg:
src = create_mixed_source_space(sbj_dir, sbj_id, spacing,
labels, src)
n = sum(src[i]['nuse'] for i in range(len(src)))
print('il src space contiene %d spaces e %d vertici' % (len(src), n))
# check if the co-registration file was created
# if not raise an runtime error
trans_fname = op.join(data_path, '%s-trans.fif' % raw_fname)
if not op.isfile(trans_fname):
raise RuntimeError('coregistration file %s NOT found!!!'
% trans_fname)
# if all is ok creates the fwd matrix
mne.make_forward_solution(raw_info, trans_fname, src, bem,
fwd_filename,
mindist=5.0, # ignore sources <= 0mm from inner skull
meg=True, eeg=False,
n_jobs=2,
overwrite=True)
else:
print '*** FWD file %s exists!!!' % fwd_filename
return fwd_filename
def test_iterable():
"""Test iterable support for simulate_raw."""
raw = read_raw_fif(raw_fname_short).load_data()
raw.pick_channels(raw.ch_names[:10] + ['STI 014'])
src = setup_volume_source_space(
pos=dict(rr=[[-0.05, 0, 0], [0.1, 0, 0]],
nn=[[0, 1., 0], [0, 1., 0]]))
assert src.kind == 'discrete'
trans = None
sphere = make_sphere_model(head_radius=None, info=raw.info)
tstep = 1. / raw.info['sfreq']
rng = np.random.RandomState(0)
vertices = np.array([1])
data = rng.randn(1, 2)
stc = VolSourceEstimate(data, vertices, 0, tstep)
assert isinstance(stc.vertices, np.ndarray)
with pytest.raises(ValueError, match='at least three time points'):
simulate_raw(raw.info, stc, trans, src, sphere, None)
data = rng.randn(1, 1000)
n_events = (len(raw.times) - 1) // 1000 + 1
stc = VolSourceEstimate(data, vertices, 0, tstep)
assert isinstance(stc.vertices, np.ndarray)
with catch_logging() as log:
with pytest.deprecated_call():
raw_sim = simulate_raw(raw, stc, trans, src, sphere, None,
verbose=True)
log = log.getvalue()
assert 'Making 15 copies of STC' in log
assert_allclose(raw.times, raw_sim.times)
events = find_events(raw_sim, initial_event=True)
assert len(events) == n_events
assert_array_equal(events[:, 2], 1)
# Degenerate STCs
with pytest.raises(RuntimeError,
match=r'Iterable did not provide stc\[0\]'):
simulate_raw(raw.info, [], trans, src, sphere, None)
with pytest.raises(RuntimeError,
match=r'Iterable did not provide stc\[2\].*duration'):
with pytest.deprecated_call():
simulate_raw(raw, [stc, stc], trans, src, sphere, None)
# tuple with ndarray
event_data = np.zeros(len(stc.times), int)
event_data[0] = 3
raw_new = simulate_raw(raw.info, [(stc, event_data)] * 15,
trans, src, sphere, None, first_samp=raw.first_samp)
assert raw_new.n_times == 15000
raw_new.crop(0, raw_sim.times[-1])
_assert_iter_sim(raw_sim, raw_new, 3)
with pytest.raises(ValueError, match='event data had shape .* but need'):
simulate_raw(raw.info, [(stc, event_data[:-1])], trans, src, sphere,
None)
with pytest.raises(ValueError, match='stim_data in a stc tuple .* int'):
simulate_raw(raw.info, [(stc, event_data * 1.)], trans, src, sphere,
None)
# iterable
def stc_iter():
stim_data = np.zeros(len(stc.times), int)
stim_data[0] = 4
ii = 0
while ii < 100:
ii += 1
yield (stc, stim_data)
with pytest.deprecated_call():
raw_new = simulate_raw(raw, stc_iter(), trans, src, sphere, None)
_assert_iter_sim(raw_sim, raw_new, 4)
def stc_iter_bad():
ii = 0
while ii < 100:
ii += 1
yield (stc, 4, 3)
with pytest.raises(ValueError, match='stc, if tuple, must be length'):
simulate_raw(raw.info, stc_iter_bad(), trans, src, sphere, None)
_assert_iter_sim(raw_sim, raw_new, 4)
def stc_iter_bad():
ii = 0
while ii < 100:
ii += 1
stc_new = stc.copy()
stc_new.vertices = np.array([ii % 2])
yield stc_new
with pytest.raises(RuntimeError, match=r'Vertex mismatch for stc\[1\]'):
simulate_raw(raw.info, stc_iter_bad(), trans, src, sphere, None)
# Forward omission
vertices = np.array([0, 1])
data = rng.randn(2, 1000)
stc = VolSourceEstimate(data, vertices, 0, tstep)
assert isinstance(stc.vertices, np.ndarray)
# XXX eventually we should support filtering based on sphere radius, too,
# by refactoring the code in source_space.py that does it!
surf = _get_ico_surface(3)
surf['rr'] *= 60 # mm
model = _surfaces_to_bem([surf], [FIFF.FIFFV_BEM_SURF_ID_BRAIN], [0.3])
bem = make_bem_solution(model)
with pytest.warns(RuntimeWarning,
match='1 of 2 SourceEstimate vertices'):
simulate_raw(raw, stc, trans, src, bem, None)
subject='fsaverage', subjects_dir=subjects_dir, add_dist=False,
spacing='oct6', overwrite=True)
# now we morph it onto the subject.
src_subject = mne.morph_source_spaces(
src_fsaverage, subject, subjects_dir=subjects_dir)
##############################################################################
# For the same reason `ico` has to be set to `None` when computing the bem.
# The headshape is not computed with MNE and has a none standard configuration.
bems = mne.make_bem_model(subject, conductivity=(0.3,),
subjects_dir=subjects_dir,
ico=None) # ico = None for morphed SP.
bem_sol = mne.make_bem_solution(bems)
bem_sol['surfs'][0]['coord_frame'] = 5
##############################################################################
# Now we can read the channels that we want to map to the cortical locations.
# Then we can compute the forward solution.
info = hcp.read_info(subject=subject, hcp_path=hcp_path, data_type='rest',
run_index=0)
picks = mne.pick_types(info, meg=True, ref_meg=False)
info = mne.pick_info(info, picks)
fwd = mne.make_forward_solution(info, trans=head_mri_t, bem=bem_sol,
src=src_subject)
mag_map = mne.sensitivity_map(
def make_mne_forward(anatomy_path,
subject,
recordings_path,
info_from=(('data_type', 'rest'), ('run_index', 0)),
fwd_params=None, src_params=None,
hcp_path=op.curdir, n_jobs=1):
""""
Convenience script for conducting standard MNE analyses.
Parameters
----------
subject : str
The subject name.
hcp_path : str
The directory containing the HCP data.
recordings_path : str
The path where MEG data and transformations are stored.
anatomy_path : str
The directory containing the extracted HCP subject data.
info_from : tuple of tuples | dict
The reader info concerning the data from which sensor positions
should be read.
Must not be empty room as sensor positions are in head
coordinates for 4D systems, hence not available in that case.
Note that differences between the sensor positions across runs
are smaller than 12 digits, hence negligible.
fwd_params : None | dict
The forward parameters
src_params : None | dict
The src params. Defaults to:
dict(subject='fsaverage', fname=None, spacing='oct6', n_jobs=2,
surface='white', subjects_dir=anatomy_path, add_dist=True)
hcp_path : str
The prefix of the path of the HCP data.
n_jobs : int
The number of jobs to use in parallel.
"""
if isinstance(info_from, tuple):
info_from = dict(info_from)
head_mri_t = mne.read_trans(
op.join(recordings_path, subject, '{}-head_mri-trans.fif'.format(
subject)))
src_params = _update_dict_defaults(
src_params,
dict(subject='fsaverage', fname=None, spacing='oct6', n_jobs=n_jobs,
surface='white', subjects_dir=anatomy_path, add_dist=True))
add_source_space_distances = False
if src_params['add_dist']: # we want the distances on the morphed space
src_params['add_dist'] = False
add_source_space_distances = True
src_fsaverage = mne.setup_source_space(**src_params)
src_subject = mne.morph_source_spaces(
src_fsaverage, subject, subjects_dir=anatomy_path)
if add_source_space_distances: # and here we compute them post hoc.
src_subject = mne.add_source_space_distances(
src_subject, n_jobs=n_jobs)
bems = mne.make_bem_model(subject, conductivity=(0.3,),
subjects_dir=anatomy_path,
ico=None) # ico = None for morphed SP.
bem_sol = mne.make_bem_solution(bems)
info = read_info_hcp(subject=subject, hcp_path=hcp_path, **info_from)
picks = _pick_data_channels(info, with_ref_meg=False)
info = pick_info(info, picks)
# here we assume that as a result of our MNE-HCP processing
# all other transforms in info are identity
for trans in ['dev_head_t', 'ctf_head_t']:
# 'dev_ctf_t' is not identity
assert np.sum(info[trans]['trans'] - np.eye(4)) == 0
fwd = mne.make_forward_solution(
info, trans=head_mri_t, bem=bem_sol, src=src_subject,
n_jobs=n_jobs)
return dict(fwd=fwd, src_subject=src_subject,
src_fsaverage=src_fsaverage,
bem_sol=bem_sol, info=info)
# ``use_precomputed=False`` in the beginning of this script to build the
# forward solution from scratch. The head surfaces for constructing a BEM
# solution are read from a file. Since the data only contains MEG channels, we
# only need the inner skull surface for making the forward solution. For more
# information: :ref:`CHDBBCEJ`, :func:`mne.setup_source_space`,
# :ref:`create_bem_model`, :func:`mne.bem.make_watershed_bem`.
if use_precomputed:
fwd_fname = op.join(data_path, 'MEG', 'bst_auditory',
'bst_auditory-meg-oct-6-fwd.fif')
fwd = mne.read_forward_solution(fwd_fname)
else:
src = mne.setup_source_space(subject, spacing='ico4',
subjects_dir=subjects_dir, overwrite=True)
model = mne.make_bem_model(subject=subject, ico=4, conductivity=[0.3],
subjects_dir=subjects_dir)
bem = mne.make_bem_solution(model)
fwd = mne.make_forward_solution(evoked_std.info, trans=trans, src=src,
bem=bem)
inv = mne.minimum_norm.make_inverse_operator(evoked_std.info, fwd, cov)
snr = 3.0
lambda2 = 1.0 / snr ** 2
del fwd
###############################################################################
# The sources are computed using dSPM method and plotted on an inflated brain
# surface. For interactive controls over the image, use keyword
# ``time_viewer=True``.
# Standard condition.
stc_standard = mne.minimum_norm.apply_inverse(evoked_std, inv, lambda2, 'dSPM')
brain = stc_standard.plot(subjects_dir=subjects_dir, subject=subject,
fig.suptitle(titles[kind])
fig.subplots_adjust(0.1, 0.1, 0.95, 0.85)
##############################################################################
# Alignment and forward
# ---------------------
# Here we use a reduced size source space (oct5) just for speed
src = mne.setup_source_space(
subject, 'oct5', add_dist=False, subjects_dir=subjects_dir)
# This line removes source-to-source distances that we will not need.
# We only do it here to save a bit of memory, in general this is not required.
del src[0]['dist'], src[1]['dist']
bem = mne.read_bem_solution(bem_fname)
# For speed, let's just use a 1-layer BEM
bem = mne.make_bem_solution(bem['surfs'][-1:])
fwd = dict()
# check alignment and generate forward for VectorView
kwargs = dict(azimuth=0, elevation=90, distance=0.6, focalpoint=(0., 0., 0.))
fig = mne.viz.plot_alignment(
raws['vv'].info, trans=vv_trans_fname, subject=subject,
subjects_dir=subjects_dir, dig=True, coord_frame='mri',
surfaces=('head', 'white'))
mne.viz.set_3d_view(figure=fig, **kwargs)
fwd['vv'] = mne.make_forward_solution(
raws['vv'].info, vv_trans_fname, src, bem, eeg=False, verbose=True)
##############################################################################
# And for OPM:
def compute_forward_stack(subjects_dir,
subject,
recordings_path,
info_from=(('data_type', 'rest'), ('run_index', 0)),
fwd_params=None, src_params=None,
hcp_path=op.curdir, n_jobs=1, verbose=None):
"""
Convenience function for conducting standard MNE analyses.
.. note::
this function computes bem solutions, source spaces and forward models
optimized for connectivity computation, i.e., the fsaverage space
is morphed onto the subject's space.
Parameters
----------
subject : str
The subject name.
hcp_path : str
The directory containing the HCP data.
recordings_path : str
The path where MEG data and transformations are stored.
subjects_dir : str
The directory containing the extracted HCP subject data.
info_from : tuple of tuples | dict
The reader info concerning the data from which sensor positions
should be read.
Must not be empty room as sensor positions are in head
coordinates for 4D systems, hence not available in that case.
Note that differences between the sensor positions across runs
are smaller than 12 digits, hence negligible.
fwd_params : None | dict
The forward parameters
src_params : None | dict
The src params. Defaults to:
dict(subject='fsaverage', fname=None, spacing='oct6', n_jobs=2,
surface='white', subjects_dir=subjects_dir, add_dist=True)
hcp_path : str
The prefix of the path of the HCP data.
n_jobs : int
The number of jobs to use in parallel.
verbose : bool, str, int, or None
If not None, override default verbose level (see mne.verbose)
Returns
-------
out : dict
A dictionary with the following keys:
fwd : instance of mne.Forward
The forward solution.
src_subject : instance of mne.SourceSpace
The source model on the subject's surface
src_fsaverage : instance of mne.SourceSpace
The source model on fsaverage's surface
bem_sol : dict
The BEM.
info : instance of mne.io.meas_info.Info
The actual measurement info used.
"""
if isinstance(info_from, tuple):
info_from = dict(info_from)
head_mri_t = mne.read_trans(
op.join(recordings_path, subject, '{}-head_mri-trans.fif'.format(
subject)))
src_defaults = dict(subject='fsaverage', spacing='oct6', n_jobs=n_jobs,
surface='white', subjects_dir=subjects_dir, add_dist=True)
if 'fname' in mne.fixes._get_args(mne.setup_source_space):
# needed for mne-0.14 and below
src_defaults.update(dict(fname=None))
else:
# remove 'fname' argument (if necessary) when using mne-0.15+
if 'fname' in src_params:
del src_params['fname']
src_params = _update_dict_defaults(src_params, src_defaults)
add_source_space_distances = False
if src_params['add_dist']: # we want the distances on the morphed space
src_params['add_dist'] = False
add_source_space_distances = True
src_fsaverage = mne.setup_source_space(**src_params)
src_subject = mne.morph_source_spaces(
src_fsaverage, subject, subjects_dir=subjects_dir)
if add_source_space_distances: # and here we compute them post hoc.
src_subject = mne.add_source_space_distances(
src_subject, n_jobs=n_jobs)
bems = mne.make_bem_model(subject, conductivity=(0.3,),
subjects_dir=subjects_dir,
ico=None) # ico = None for morphed SP.
bem_sol = mne.make_bem_solution(bems)
bem_sol['surfs'][0]['coord_frame'] = 5
info = read_info(subject=subject, hcp_path=hcp_path, **info_from)
picks = _pick_data_channels(info, with_ref_meg=False)
info = pick_info(info, picks)
# here we assume that as a result of our MNE-HCP processing
# all other transforms in info are identity
for trans in ['dev_head_t', 'ctf_head_t']:
# 'dev_ctf_t' is not identity
assert np.sum(info[trans]['trans'] - np.eye(4)) == 0
fwd = mne.make_forward_solution(
info, trans=head_mri_t, bem=bem_sol, src=src_subject,
n_jobs=n_jobs)
return dict(fwd=fwd, src_subject=src_subject,
src_fsaverage=src_fsaverage,
bem_sol=bem_sol, info=info)
