def copy_surfaces(sbj_id, mesh_files):
import os
import os.path as op
from smri_params import sbj_dir
from mne.report import Report
report = Report()
surf_names = ["brain_surface", "inner_skull_surface", "outer_skull_surface", "outer_skin_surface"]
new_surf_names = ["brain.surf", "inner_skull.surf", "outer_skull.surf", "outer_skin.surf"]
bem_dir = op.join(sbj_dir, sbj_id, "bem")
surface_dir = op.join(sbj_dir, sbj_id, "bem/watershed")
for i in range(len(surf_names)):
os.system(
"cp %s %s" % (op.join(surface_dir, sbj_id + "_" + surf_names[i]), op.join(bem_dir, new_surf_names[i]))
)
# op.join(bem_dir,sbj_id + '-' + new_surf_names[i])))
report.add_bem_to_section(subject=sbj_id, subjects_dir=sbj_dir)
report_filename = op.join(bem_dir, "BEM_report.html")
print "*** REPORT file %s written ***" % report_filename
print report_filename
report.save(report_filename, open_browser=False, overwrite=True)
return sbj_id
def test_render_mri():
"""Test rendering MRI for mne report.
"""
report = Report(info_fname=raw_fname,
subject='sample', subjects_dir=subjects_dir)
with warnings.catch_warnings(record=True):
warnings.simplefilter('always')
report.parse_folder(data_path=data_dir,
pattern='*sample_audvis_raw-trans.fif')
def test_render_report():
"""Test rendering -*.fif files for mne report.
"""
tempdir = _TempDir()
raw_fname_new = op.join(tempdir, 'temp_raw.fif')
event_fname_new = op.join(tempdir, 'temp_raw-eve.fif')
cov_fname_new = op.join(tempdir, 'temp_raw-cov.fif')
fwd_fname_new = op.join(tempdir, 'temp_raw-fwd.fif')
inv_fname_new = op.join(tempdir, 'temp_raw-inv.fif')
for a, b in [[raw_fname, raw_fname_new],
[event_fname, event_fname_new],
[cov_fname, cov_fname_new],
[fwd_fname, fwd_fname_new],
[inv_fname, inv_fname_new]]:
shutil.copyfile(a, b)
# create and add -epo.fif and -ave.fif files
epochs_fname = op.join(tempdir, 'temp-epo.fif')
evoked_fname = op.join(tempdir, 'temp-ave.fif')
raw = Raw(raw_fname_new)
picks = pick_types(raw.info, meg='mag', eeg=False) # faster with one type
epochs = Epochs(raw, read_events(event_fname), 1, -0.2, 0.2, picks=picks)
epochs.save(epochs_fname)
epochs.average().save(evoked_fname)
report = Report(info_fname=raw_fname_new, subjects_dir=subjects_dir)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
report.parse_folder(data_path=tempdir)
assert_true(len(w) >= 1)
# Check correct paths and filenames
fnames = glob.glob(op.join(tempdir, '*.fif'))
for fname in fnames:
assert_true(op.basename(fname) in
[op.basename(x) for x in report.fnames])
assert_true(''.join(report.html).find(op.basename(fname)) != -1)
assert_equal(len(report.fnames), len(fnames))
assert_equal(len(report.html), len(report.fnames))
# Check saving functionality
report.data_path = tempdir
report.save(fname=op.join(tempdir, 'report.html'), open_browser=False)
assert_true(op.isfile(op.join(tempdir, 'report.html')))
assert_equal(len(report.html), len(fnames))
assert_equal(len(report.html), len(report.fnames))
# Check saving same report to new filename
report.save(fname=op.join(tempdir, 'report2.html'), open_browser=False)
assert_true(op.isfile(op.join(tempdir, 'report2.html')))
# Check overwriting file
report.save(fname=op.join(tempdir, 'report.html'), open_browser=False,
overwrite=True)
assert_true(op.isfile(op.join(tempdir, 'report.html')))
def test_add_htmls_to_section():
"""Test adding html str to mne report.
"""
report = Report(info_fname=raw_fname, subject="sample", subjects_dir=subjects_dir)
html = "<b>MNE-Python is AWESOME</b>"
caption, section = "html", "html_section"
report.add_htmls_to_section(html, caption, section)
idx = report._sectionlabels.index("report_" + section)
html_compare = report.html[idx]
assert_true(html in html_compare)
def test_render_mri_without_bem():
"""Test rendering MRI without BEM for mne report."""
tempdir = _TempDir()
os.mkdir(op.join(tempdir, 'sample'))
os.mkdir(op.join(tempdir, 'sample', 'mri'))
shutil.copyfile(mri_fname, op.join(tempdir, 'sample', 'mri', 'T1.mgz'))
report = Report(info_fname=raw_fname,
subject='sample', subjects_dir=tempdir)
report.parse_folder(tempdir, render_bem=False)
report.save(op.join(tempdir, 'report.html'), open_browser=False)
def test_validate_input():
report = Report()
items = ["a", "b", "c"]
captions = ["Letter A", "Letter B", "Letter C"]
section = "ABCs"
comments = ["First letter of the alphabet.", "Second letter of the alphabet", "Third letter of the alphabet"]
assert_raises(ValueError, report._validate_input, items, captions[:-1], section, comments=None)
assert_raises(ValueError, report._validate_input, items, captions, section, comments=comments[:-1])
values = report._validate_input(items, captions, section, comments=None)
items_new, captions_new, comments_new = values
assert_equal(len(comments_new), len(items))
def test_add_htmls_to_section():
"""Test adding html str to mne report."""
report = Report(info_fname=raw_fname,
subject='sample', subjects_dir=subjects_dir)
html = '<b>MNE-Python is AWESOME</b>'
caption, section = 'html', 'html_section'
report.add_htmls_to_section(html, caption, section)
idx = report._sectionlabels.index('report_' + section)
html_compare = report.html[idx]
assert_true(html in html_compare)
assert_true(repr(report))
def test_render_mri():
"""Test rendering MRI for mne report."""
tempdir = _TempDir()
trans_fname_new = op.join(tempdir, 'temp-trans.fif')
for a, b in [[trans_fname, trans_fname_new]]:
shutil.copyfile(a, b)
report = Report(info_fname=raw_fname,
subject='sample', subjects_dir=subjects_dir)
report.parse_folder(data_path=tempdir, mri_decim=30, pattern='*')
report.save(op.join(tempdir, 'report.html'), open_browser=False)
assert repr(report)
def test_render_mri():
"""Test rendering MRI for mne report.
"""
tempdir = _TempDir()
trans_fname_new = op.join(tempdir, "temp-trans.fif")
for a, b in [[trans_fname, trans_fname_new]]:
shutil.copyfile(a, b)
report = Report(info_fname=raw_fname, subject="sample", subjects_dir=subjects_dir)
with warnings.catch_warnings(record=True):
warnings.simplefilter("always")
report.parse_folder(data_path=tempdir, mri_decim=30, pattern="*", n_jobs=2)
report.save(op.join(tempdir, "report.html"), open_browser=False)
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 test_render_mri_without_bem():
"""Test rendering MRI without BEM for mne report."""
tempdir = _TempDir()
os.mkdir(op.join(tempdir, 'sample'))
os.mkdir(op.join(tempdir, 'sample', 'mri'))
shutil.copyfile(mri_fname, op.join(tempdir, 'sample', 'mri', 'T1.mgz'))
report = Report(info_fname=raw_fname,
subject='sample', subjects_dir=tempdir)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
report.parse_folder(tempdir)
assert_true(len(w) >= 1)
report.save(op.join(tempdir, 'report.html'), open_browser=False)
def test_add_slider_to_section():
"""Test adding a slider with a series of images to mne report."""
tempdir = _TempDir()
from matplotlib import pyplot as plt
report = Report(info_fname=raw_fname,
subject='sample', subjects_dir=subjects_dir)
section = 'slider_section'
figs = list()
figs.append(plt.figure())
plt.plot([1, 2, 3])
plt.close('all')
figs.append(plt.figure())
plt.plot([3, 2, 1])
plt.close('all')
report.add_slider_to_section(figs, section=section)
report.save(op.join(tempdir, 'report.html'), open_browser=False)
assert_raises(NotImplementedError, report.add_slider_to_section,
[figs, figs])
assert_raises(ValueError, report.add_slider_to_section, figs, ['wug'])
assert_raises(TypeError, report.add_slider_to_section, figs, 'wug')
# need at least 2
assert_raises(ValueError, report.add_slider_to_section, figs[:1], 'wug')
# Smoke test that SVG w/unicode can be added
report = Report()
fig, ax = plt.subplots()
ax.set_xlabel(u'μ')
report.add_slider_to_section([fig] * 2, image_format='svg')
def test_validate_input():
report = Report()
items = ['a', 'b', 'c']
captions = ['Letter A', 'Letter B', 'Letter C']
section = 'ABCs'
comments = ['First letter of the alphabet.',
'Second letter of the alphabet',
'Third letter of the alphabet']
assert_raises(ValueError, report._validate_input, items, captions[:-1],
section, comments=None)
assert_raises(ValueError, report._validate_input, items, captions, section,
comments=comments[:-1])
values = report._validate_input(items, captions, section, comments=None)
items_new, captions_new, comments_new = values
assert_equal(len(comments_new), len(items))
def run():
from mne.commands.utils import get_optparser
parser = get_optparser(__file__)
parser.add_option("-p", "--path", dest="path",
help="Path to folder who MNE-Report must be created")
parser.add_option("-i", "--info", dest="info_fname",
help="File from which info dictionary is to be read",
metavar="FILE")
parser.add_option("-d", "--subjects-dir", dest="subjects_dir",
help="The subjects directory")
parser.add_option("-s", "--subject", dest="subject",
help="The subject name")
parser.add_option("-v", "--verbose", dest="verbose",
action='store_true', help="run in verbose mode")
parser.add_option("--no-browser", dest="no_browser", action='store_false',
help="Do not open MNE-Report in browser")
parser.add_option("--overwrite", dest="overwrite", action='store_false',
help="Overwrite html report if it already exists")
parser.add_option("-j", "--jobs", dest="n_jobs", help="Number of jobs to"
" run in parallel")
parser.add_option("-m", "--mri-decim", type="int", dest="mri_decim",
default=2, help="Integer factor used to decimate "
"BEM plots")
options, args = parser.parse_args()
path = options.path
if path is None:
parser.print_help()
sys.exit(1)
info_fname = options.info_fname
subjects_dir = options.subjects_dir
subject = options.subject
mri_decim = int(options.mri_decim)
verbose = True if options.verbose is not None else False
open_browser = False if options.no_browser is not None else True
overwrite = True if options.overwrite is not None else False
n_jobs = int(options.n_jobs) if options.n_jobs is not None else 1
t0 = time.time()
report = Report(info_fname, subjects_dir=subjects_dir, subject=subject,
verbose=verbose)
report.parse_folder(path, verbose=verbose, n_jobs=n_jobs,
mri_decim=mri_decim)
log_elapsed(time.time() - t0, verbose=verbose)
report.save(open_browser=open_browser, overwrite=overwrite)
def test_render_add_sections():
"""Test adding figures/images to section.
"""
tempdir = _TempDir()
import matplotlib.pyplot as plt
report = Report(subjects_dir=subjects_dir)
# Check add_figs_to_section functionality
fig = plt.plot([1, 2], [1, 2])[0].figure
report.add_figs_to_section(figs=fig, # test non-list input
captions=['evoked response'], scale=1.2,
image_format='svg')
assert_raises(ValueError, report.add_figs_to_section, figs=[fig, fig],
captions='H')
# Check add_images_to_section
img_fname = op.join(tempdir, 'testimage.png')
fig.savefig(img_fname)
report.add_images_to_section(fnames=[img_fname],
captions=['evoked response'])
assert_raises(ValueError, report.add_images_to_section,
fnames=[img_fname, img_fname], captions='H')
# Check deprecation of add_section
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
report.add_section(figs=fig,
captions=['evoked response'])
assert_true(w[0].category == DeprecationWarning)
def test_render_add_sections():
"""Test adding figures/images to section.
"""
tempdir = _TempDir()
import matplotlib.pyplot as plt
report = Report(subjects_dir=subjects_dir)
# Check add_figs_to_section functionality
fig = plt.plot([1, 2], [1, 2])[0].figure
report.add_figs_to_section(figs=fig, # test non-list input
captions=['evoked response'], scale=1.2,
image_format='svg')
assert_raises(ValueError, report.add_figs_to_section, figs=[fig, fig],
captions='H')
assert_raises(ValueError, report.add_figs_to_section, figs=fig,
captions=['foo'], scale=0, image_format='svg')
assert_raises(ValueError, report.add_figs_to_section, figs=fig,
captions=['foo'], scale=1e-10, image_format='svg')
# need to recreate because calls above change size
fig = plt.plot([1, 2], [1, 2])[0].figure
# Check add_images_to_section
img_fname = op.join(tempdir, 'testimage.png')
fig.savefig(img_fname)
report.add_images_to_section(fnames=[img_fname],
captions=['evoked response'])
assert_raises(ValueError, report.add_images_to_section,
fnames=[img_fname, img_fname], captions='H')
evoked = read_evokeds(evoked_fname, condition='Left Auditory',
baseline=(-0.2, 0.0))
fig = plot_trans(evoked.info, trans_fname, subject='sample',
subjects_dir=subjects_dir)
report.add_figs_to_section(figs=fig, # test non-list input
captions='random image', scale=1.2)
def test_remove():
"""Test removing figures from a report."""
r = Report()
fig1, fig2 = _get_example_figures()
r.add_figs_to_section(fig1, 'figure1', 'mysection')
r.add_figs_to_section(fig1, 'figure1', 'othersection')
r.add_figs_to_section(fig2, 'figure1', 'mysection')
r.add_figs_to_section(fig2, 'figure2', 'mysection')
# Test removal by caption
r2 = copy.deepcopy(r)
removed_index = r2.remove(caption='figure1')
assert removed_index == 2
assert len(r2.html) == 3
assert r2.html[0] == r.html[0]
assert r2.html[1] == r.html[1]
assert r2.html[2] == r.html[3]
# Test restricting to section
r2 = copy.deepcopy(r)
removed_index = r2.remove(caption='figure1', section='othersection')
assert removed_index == 1
assert len(r2.html) == 3
assert r2.html[0] == r.html[0]
assert r2.html[1] == r.html[2]
assert r2.html[2] == r.html[3]
# Test removal of empty sections
r2 = copy.deepcopy(r)
r2.remove(caption='figure1', section='othersection')
assert r2.sections == ['mysection']
assert r2._sectionvars == {'mysection': 'report_mysection'}
def test_add_slider_to_section():
"""Test adding a slider with a series of images to mne report."""
tempdir = _TempDir()
from matplotlib import pyplot as plt
report = Report(info_fname=raw_fname,
subject='sample', subjects_dir=subjects_dir)
section = 'slider_section'
figs = list()
figs.append(plt.figure())
plt.plot([1, 2, 3])
plt.close('all')
figs.append(plt.figure())
plt.plot([3, 2, 1])
plt.close('all')
report.add_slider_to_section(figs, section=section)
report.save(op.join(tempdir, 'report.html'), open_browser=False)
assert_raises(NotImplementedError, report.add_slider_to_section,
[figs, figs])
assert_raises(ValueError, report.add_slider_to_section, figs, ['wug'])
assert_raises(TypeError, report.add_slider_to_section, figs, 'wug')
def test_render_add_sections():
"""Test adding figures/images to section.
"""
from PIL import Image
tempdir = _TempDir()
import matplotlib.pyplot as plt
report = Report(subjects_dir=subjects_dir)
# Check add_figs_to_section functionality
fig = plt.plot([1, 2], [1, 2])[0].figure
report.add_figs_to_section(
figs=fig, captions=["evoked response"], scale=1.2, image_format="svg" # test non-list input
)
assert_raises(ValueError, report.add_figs_to_section, figs=[fig, fig], captions="H")
assert_raises(ValueError, report.add_figs_to_section, figs=fig, captions=["foo"], scale=0, image_format="svg")
assert_raises(ValueError, report.add_figs_to_section, figs=fig, captions=["foo"], scale=1e-10, image_format="svg")
# need to recreate because calls above change size
fig = plt.plot([1, 2], [1, 2])[0].figure
# Check add_images_to_section with png and then gif
img_fname = op.join(tempdir, "testimage.png")
fig.savefig(img_fname)
report.add_images_to_section(fnames=[img_fname], captions=["evoked response"])
im = Image.open(img_fname)
op.join(tempdir, "testimage.gif")
im.save(img_fname) # matplotlib does not support gif
report.add_images_to_section(fnames=[img_fname], captions=["evoked response"])
assert_raises(ValueError, report.add_images_to_section, fnames=[img_fname, img_fname], captions="H")
assert_raises(ValueError, report.add_images_to_section, fnames=["foobar.xxx"], captions="H")
evoked = read_evokeds(evoked_fname, condition="Left Auditory", baseline=(-0.2, 0.0))
fig = plot_trans(evoked.info, trans_fname, subject="sample", subjects_dir=subjects_dir)
report.add_figs_to_section(figs=fig, captions="random image", scale=1.2) # test non-list input
def test_add_slider_to_section():
"""Test adding a slider with a series of images to mne report."""
tempdir = _TempDir()
report = Report(info_fname=raw_fname,
subject='sample', subjects_dir=subjects_dir)
section = 'slider_section'
figs = _get_example_figures()
report.add_slider_to_section(figs, section=section)
report.save(op.join(tempdir, 'report.html'), open_browser=False)
pytest.raises(NotImplementedError, report.add_slider_to_section,
[figs, figs])
pytest.raises(ValueError, report.add_slider_to_section, figs, ['wug'])
pytest.raises(TypeError, report.add_slider_to_section, figs, 'wug')
# need at least 2
pytest.raises(ValueError, report.add_slider_to_section, figs[:1], 'wug')
# Smoke test that SVG w/unicode can be added
report = Report()
fig, ax = plt.subplots()
ax.set_xlabel(u'μ')
report.add_slider_to_section([fig] * 2, image_format='svg')
def test_add_or_replace():
"""Test replacing existing figures in a report."""
r = Report()
fig1, fig2 = _get_example_figures()
r.add_figs_to_section(fig1, 'duplicate', 'mysection')
r.add_figs_to_section(fig1, 'duplicate', 'mysection')
r.add_figs_to_section(fig1, 'duplicate', 'othersection')
r.add_figs_to_section(fig2, 'nonduplicate', 'mysection')
# By default, replace=False, so all figures should be there
assert len(r.html) == 4
old_r = copy.deepcopy(r)
# Re-add fig1 with replace=True, it should overwrite the last occurrence of
# fig1 in section 'mysection'.
r.add_figs_to_section(fig2, 'duplicate', 'mysection', replace=True)
assert len(r.html) == 4
assert r.html[1] != old_r.html[1] # This figure should have changed
# All other figures should be the same
assert r.html[0] == old_r.html[0]
assert r.html[2] == old_r.html[2]
assert r.html[3] == old_r.html[3]
def test_report_raw_psd_and_date():
"""Test report raw PSD and DATE_NONE functionality."""
with pytest.raises(TypeError, match='dict'):
Report(raw_psd='foo')
tempdir = _TempDir()
raw = read_raw_fif(raw_fname).crop(0, 1.).load_data()
raw_fname_new = op.join(tempdir, 'temp_raw.fif')
raw.save(raw_fname_new)
report = Report(raw_psd=True)
report.parse_folder(data_path=tempdir, render_bem=False,
on_error='raise')
assert isinstance(report.html, list)
assert 'PSD' in ''.join(report.html)
assert 'GMT' in ''.join(report.html)
# DATE_NONE functionality
report = Report()
raw.anonymize()
raw.save(raw_fname_new, overwrite=True)
report.parse_folder(data_path=tempdir, render_bem=False,
on_error='raise')
assert isinstance(report.html, list)
assert 'GMT' not in ''.join(report.html)
def check_ICA_Cleaning(subject, runlist, badEEG, badICA):
import mne
import os.path as op
import os
from mne.report import Report
from mne.io.pick import _picks_by_type as picks_by_type
from mne.preprocessing import read_ica
from mne.io import Raw
from mne.preprocessing import create_ecg_epochs, create_eog_epochs
data_path = '/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/'
report = Report(subject)
raw_fnames = []
for run in runlist:
raw_fnames.append(data_path + subject + '/' + run + '_trans_sss.fif')
# read raw data
raw = Raw(raw_fnames, preload=True)
raw.info['bads'] = badEEG
# Highpass filter 1Hz on EOG/ECG channels
picks = mne.pick_types(raw.info, meg=False, eeg=False, eog=True, ecg=False)
raw.filter(l_freq=1, h_freq=2, picks=picks)
picks = mne.pick_types(raw.info, meg=True, eeg=True, eog=True, ecg=True)
raw.filter(l_freq=None, h_freq=30, picks=picks, n_jobs=4)
results_dir = op.join(data_path, subject, 'artefactICA')
if not op.exists(results_dir):
os.makedirs(results_dir)
# Create ICA file for each data type (MEG and EEG)
for ch_type, picks in picks_by_type(
raw.info, meg_combined=True): # bad EEG channels are excluded
# Read ICA file
ica = []
ica = read_ica(data_path + subject + '/mne_python/ICA/ICA_' + ch_type +
'_allRuns')
for badICAsel in badICA[ch_type]:
# Select bad component and assess artefact rejection quality
ica_exclude = badICAsel
ecg_evoked = create_ecg_epochs(raw, tmin=-.5, tmax=.5,
picks=picks).average()
fig = ica.plot_overlay(ecg_evoked,
exclude=ica_exclude) # plot ECG cleaning
report.add_figs_to_section(
fig,
str(badICAsel) + ' Rejection overlay (%s)' % ch_type, 'ECG')
eog_evoked = create_eog_epochs(raw, tmin=-.5, tmax=.5,
picks=picks).average()
fig = ica.plot_overlay(eog_evoked,
exclude=ica_exclude) # plot EOG cleaning
report.add_figs_to_section(
fig,
str(badICAsel) + ' Rejection overlay (%s)' % ch_type, 'EOG')
fig = ica.plot_overlay(raw)
report.add_figs_to_section(
fig,
str(badICAsel) + ' Rejection overlay (%s)' % ch_type,
'Workroad artefact')
report.save((results_dir + '/AllRunsChecked.html'),
open_browser=False,
overwrite=True)
def setup_provenance(script, results_dir, config=None, use_agg=True,
run_id=None):
"""Setup provenance tracking
Parameters
----------
script : str
The script that was executed.
results_dir : str
The results directory.
config : None | str
The name of the config file. By default, the function expects the
config to be under `__script__/' named `config.py`. It can also
be another kind of textfile, e.g. .json.
use_agg : bool
Whether to use the 'Agg' backend for matplotlib or not.
Returns
-------
report : mne.report.Report
The mne report.
Side-effects
------------
- make results dir if it does not exists
- sets log file for sterr output
- writes log file with runtime information
"""
if use_agg is True:
import matplotlib
matplotlib.use('Agg')
if not callable(script):
if not op.isfile(script):
raise ValueError('sorry, this is not a script!')
if not op.isdir(results_dir) and not callable(script):
results_dir = op.join(op.dirname(op.dirname(script)), results_dir)
else:
results_dir = op.join(op.curdir, results_dir)
if not callable(script):
step = op.splitext(op.split(script)[1])[0]
else:
step = script.__name__
if not op.isabs(results_dir):
results_dir = op.abspath(results_dir)
start_path = op.dirname(results_dir)
results_dir = op.join(results_dir, step)
if not op.exists(results_dir):
logger.info('generating results dir')
_forec_create_dir(results_dir, start=start_path)
if run_id is None:
run_id = create_run_id()
logger.info('generated run id: %s' % run_id)
else:
logger.info('using existing run id: %s' % run_id)
logger.info('preparing logging:')
logging_dir = op.join(results_dir, run_id)
if not op.exists(logging_dir):
logger.info('... making logging directory: %s' % logging_dir)
os.mkdir(logging_dir)
else:
logger.info('... using logging directory: %s' % logging_dir)
modules = get_versions(sys)
runtime_log = op.join(logging_dir, 'run_time.json')
with open(runtime_log, 'w') as fid:
json.dump(modules, fid)
logger.info('... writing runtime info to: %s' % runtime_log)
script_code_out = op.join(logging_dir, 'script.py')
if callable(script):
script_code_in = inspect.getsourcefile(script)
else:
script_code_in = script
if not op.isfile(script_code_out):
with open(script_code_out, 'w') as fid:
with open(script_code_in) as script_fid:
source_code = script_fid.read()
fid.write(source_code)
logger.info('... logging source code of calling script')
if config is None:
config = 'config.py'
if op.isabs(config):
config_fname = config
else:
config_fname = ''
config_code = op.join( # weird behavior of join if last arg is path
results_dir, run_id, op.split(config_fname)[-1])
if not op.isfile(config_fname):
logger.info('... No config found. Logging nothing.')
elif op.isfile(config_code):
logger.info('... Config already written. I assume that you are using'
' the same run_id for different runs of your script.')
else:
with open(config_code, 'w') as fid:
with open(config_fname) as config_fid:
source_code = config_fid.read()
fid.write(source_code)
logger.info('... logging source code of "%s".' % config_fname)
logger.info('... preparing Report')
report = Report(title=step)
report.data_path = logging_dir
std_logfile = op.join(logging_dir, 'run_output.log')
logger.info('... setting logfile: %s' % std_logfile)
set_log_file(std_logfile)
return report, run_id, results_dir, logger
def test_render_report():
"""Test rendering -*.fif files for mne report.
"""
report = Report(info_fname=raw_fname)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
report.parse_folder(data_path=base_dir)
assert_true(len(w) == 1)
# Check correct paths and filenames
assert_true(raw_fname in report.fnames)
assert_true(event_name in report.fnames)
assert_true(report.data_path == base_dir)
# Check if all files were rendered in the report
fnames = glob.glob(op.join(base_dir, '*.fif'))
bad_name = 'test_ctf_comp_raw-eve.fif'
decrement = any(fname.endswith(bad_name) for fname in fnames)
fnames = [fname for fname in fnames if
fname.endswith(('-eve.fif', '-ave.fif', '-cov.fif',
'-sol.fif', '-fwd.fif', '-inv.fif',
'-src.fif', '-trans.fif', 'raw.fif',
'sss.fif', '-epo.fif')) and
not fname.endswith(bad_name)]
# last file above gets created by another test, and it shouldn't be there
for fname in fnames:
assert_true(''.join(report.html).find(op.basename(fname)) != -1)
assert_equal(len(report.fnames), len(fnames))
assert_equal(len(report.html), len(report.fnames))
evoked1 = read_evokeds(evoked1_fname)
evoked2 = read_evokeds(evoked2_fname)
assert_equal(len(report.fnames) + len(evoked1) + len(evoked2) - 2,
report.initial_id - decrement)
# Check saving functionality
report.data_path = tempdir
report.save(fname=op.join(tempdir, 'report.html'), open_browser=False)
assert_true(op.isfile(op.join(tempdir, 'report.html')))
# Check add_section functionality
fig = evoked1[0].plot(show=False)
report.add_section(figs=fig, # test non-list input
captions=['evoked response'])
assert_equal(len(report.html), len(fnames) + 1)
assert_equal(len(report.html), len(report.fnames))
assert_raises(ValueError, report.add_section, figs=[fig, fig],
captions='H')
# Check saving same report to new filename
report.save(fname=op.join(tempdir, 'report2.html'), open_browser=False)
assert_true(op.isfile(op.join(tempdir, 'report2.html')))
# Check overwriting file
report.save(fname=op.join(tempdir, 'report.html'), open_browser=False,
overwrite=True)
assert_true(op.isfile(op.join(tempdir, 'report.html')))
def run_ica(*, cfg, subject, session=None):
"""Run ICA."""
bids_basename = BIDSPath(subject=subject,
session=session,
task=cfg.task,
acquisition=cfg.acq,
recording=cfg.rec,
space=cfg.space,
datatype=cfg.datatype,
root=cfg.deriv_root,
check=False)
raw_fname = bids_basename.copy().update(processing='filt', suffix='raw')
ica_fname = bids_basename.copy().update(suffix='ica', extension='.fif')
ica_components_fname = bids_basename.copy().update(processing='ica',
suffix='components',
extension='.tsv')
report_fname = bids_basename.copy().update(processing='ica+components',
suffix='report',
extension='.html')
# Generate a list of raw data paths (i.e., paths of individual runs)
# we want to create epochs from.
raw_fnames = []
for run in cfg.runs:
raw_fname.update(run=run)
if raw_fname.copy().update(split='01').fpath.exists():
raw_fname.update(split='01')
raw_fnames.append(raw_fname.copy())
# Generate a unique event name -> event code mapping that can be used
# across all runs.
event_name_to_code_map = annotations_to_events(raw_paths=raw_fnames)
# Now, generate epochs from each individual run
epochs_all_runs = []
eog_epochs_all_runs = []
ecg_epochs_all_runs = []
for run, raw_fname in zip(cfg.runs, raw_fnames):
msg = f'Loading filtered raw data from {raw_fname} and creating epochs'
logger.info(**gen_log_kwargs(
message=msg, subject=subject, session=session, run=run))
raw = mne.io.read_raw_fif(raw_fname, preload=True)
# EOG epochs
eog_epochs = make_eog_epochs(raw=raw,
eog_channels=cfg.eog_channels,
subject=subject,
session=session,
run=run)
if eog_epochs is not None:
eog_epochs_all_runs.append(eog_epochs)
# ECG epochs
ecg_epochs = make_ecg_epochs(cfg=cfg,
raw=raw,
subject=subject,
session=session,
run=run)
if ecg_epochs is not None:
ecg_epochs_all_runs.append(ecg_epochs)
# Produce high-pass filtered version of the data for ICA.
# Sanity check – make sure we're using the correct data!
if cfg.resample_sfreq is not None:
assert np.allclose(raw.info['sfreq'], cfg.resample_sfreq)
if cfg.l_freq is not None:
assert np.allclose(raw.info['highpass'], cfg.l_freq)
filter_for_ica(cfg=cfg,
raw=raw,
subject=subject,
session=session,
run=run)
# Only keep the subset of the mapping that applies to the current run
event_id = event_name_to_code_map.copy()
for event_name in event_id.copy().keys():
if event_name not in raw.annotations.description:
del event_id[event_name]
msg = 'Creating task-related epochs …'
logger.info(**gen_log_kwargs(
message=msg, subject=subject, session=session, run=run))
epochs = make_epochs(raw=raw,
event_id=event_id,
tmin=cfg.epochs_tmin,
tmax=cfg.epochs_tmax,
event_repeated=cfg.event_repeated,
decim=cfg.decim)
epochs_all_runs.append(epochs)
del raw, epochs, eog_epochs, ecg_epochs # free memory
# Lastly, we can concatenate the epochs and set an EEG reference
epochs = mne.concatenate_epochs(epochs_all_runs, on_mismatch='warn')
if eog_epochs_all_runs:
epochs_eog = mne.concatenate_epochs(eog_epochs_all_runs,
on_mismatch='warn')
else:
epochs_eog = None
if ecg_epochs_all_runs:
epochs_ecg = mne.concatenate_epochs(ecg_epochs_all_runs,
on_mismatch='warn')
else:
epochs_ecg = None
del epochs_all_runs, eog_epochs_all_runs, ecg_epochs_all_runs
epochs.load_data()
if 'eeg' in cfg.ch_types:
projection = True if cfg.eeg_reference == 'average' else False
epochs.set_eeg_reference(cfg.eeg_reference, projection=projection)
# Reject epochs based on peak-to-peak rejection thresholds
msg = f'Using PTP rejection thresholds: {cfg.ica_reject}'
logger.info(
**gen_log_kwargs(message=msg, subject=subject, session=session))
# Reject epochs based on peak-to-peak amplitude
epochs.drop_bad(reject=cfg.ica_reject)
if epochs_eog is not None:
epochs_eog.drop_bad(reject=cfg.ica_reject)
if epochs_ecg is not None:
epochs_ecg.drop_bad(reject=cfg.ica_reject)
# Now actually perform ICA.
msg = 'Calculating ICA solution.'
logger.info(
**gen_log_kwargs(message=msg, subject=subject, session=session))
ica = fit_ica(cfg=cfg, epochs=epochs, subject=subject, session=session)
# Start a report
title = f'ICA – sub-{subject}'
if session is not None:
title += f', ses-{session}'
if cfg.task is not None:
title += f', task-{cfg.task}'
report = Report(info_fname=epochs, title=title, verbose=False)
# ECG and EOG component detection
if epochs_ecg:
ecg_ics = detect_bad_components(cfg=cfg,
which='ecg',
epochs=epochs_ecg,
ica=ica,
subject=subject,
session=session,
report=report)
else:
ecg_ics = []
if epochs_eog:
eog_ics = detect_bad_components(cfg=cfg,
which='eog',
epochs=epochs_eog,
ica=ica,
subject=subject,
session=session,
report=report)
else:
eog_ics = []
# Save ICA to disk.
# We also store the automatically identified ECG- and EOG-related ICs.
msg = 'Saving ICA solution and detected artifacts to disk.'
logger.info(
**gen_log_kwargs(message=msg, subject=subject, session=session))
ica.exclude = sorted(set(ecg_ics + eog_ics))
ica.save(ica_fname)
# Create TSV.
tsv_data = pd.DataFrame(
dict(component=list(range(ica.n_components_)),
type=['ica'] * ica.n_components_,
description=['Independent Component'] * ica.n_components_,
status=['good'] * ica.n_components_,
status_description=['n/a'] * ica.n_components_))
for component in ecg_ics:
row_idx = tsv_data['component'] == component
tsv_data.loc[row_idx, 'status'] = 'bad'
tsv_data.loc[row_idx,
'status_description'] = 'Auto-detected ECG artifact'
for component in eog_ics:
row_idx = tsv_data['component'] == component
tsv_data.loc[row_idx, 'status'] = 'bad'
tsv_data.loc[row_idx,
'status_description'] = 'Auto-detected EOG artifact'
tsv_data.to_csv(ica_components_fname, sep='\t', index=False)
# Lastly, add info about the epochs used for the ICA fit, and plot all ICs
# for manual inspection.
fig = epochs.plot_drop_log(subject=f'sub-{subject}', show=cfg.interactive)
caption = 'Dropped epochs before fit'
report.add_figs_to_section(fig, section=f'sub-{subject}', captions=caption)
msg = 'Adding diagnostic plots for all ICs to the HTML report …'
logger.info(
**gen_log_kwargs(message=msg, subject=subject, session=session))
for component_num in tqdm(range(ica.n_components_)):
fig = ica.plot_properties(epochs,
picks=component_num,
psd_args={'fmax': 60},
show=False)
caption = f'IC {component_num}'
if component_num in eog_ics and component_num in ecg_ics:
caption += ' (EOG & ECG)'
elif component_num in eog_ics:
caption += ' (EOG)'
elif component_num in ecg_ics:
caption += ' (ECG)'
report.add_figs_to_section(fig,
section=f'sub-{subject}',
captions=caption)
open_browser = True if cfg.interactive else False
report.save(report_fname, overwrite=True, open_browser=open_browser)
msg = (f"ICA completed. Please carefully review the extracted ICs in the "
f"report {report_fname.basename}, and mark all components you wish "
f"to reject as 'bad' in {ica_components_fname.basename}")
logger.info(
**gen_log_kwargs(message=msg, subject=subject, session=session))
def apply_ica(subject, session):
bids_basename = BIDSPath(subject=subject,
session=session,
task=config.get_task(),
acquisition=config.acq,
run=None,
recording=config.rec,
space=config.space,
datatype=config.get_datatype(),
root=config.deriv_root,
check=False)
fname_epo_in = bids_basename.copy().update(suffix='epo', extension='.fif')
fname_epo_out = bids_basename.copy().update(suffix='epo',
processing='clean',
extension='.fif')
fname_ica = bids_basename.copy().update(suffix='ica', extension='.fif')
fname_ica_components = bids_basename.copy().update(processing='ica',
suffix='components',
extension='.tsv')
# Load epochs to reject ICA components.
epochs = mne.read_epochs(fname_epo_in, preload=True)
msg = f'Input: {fname_epo_in}, Output: {fname_epo_out}'
logger.info(
gen_log_message(message=msg, step=5, subject=subject, session=session))
report_fname = (bids_basename.copy().update(processing='clean',
suffix='report',
extension='.html'))
report = Report(report_fname, verbose=False)
# Load ICA.
msg = f'Reading ICA: {fname_ica}'
logger.debug(
gen_log_message(message=msg, step=5, subject=subject, session=session))
ica = read_ica(fname=fname_ica)
# Select ICs to remove.
tsv_data = pd.read_csv(fname_ica_components, sep='\t')
ica.exclude = (tsv_data.loc[tsv_data['status'] == 'bad',
'component'].to_list())
# Compare ERP/ERF before and after ICA artifact rejection. The evoked
# response is calculated across ALL epochs, just like ICA was run on
# all epochs, regardless of their respective experimental condition.
#
# Note that up until now, we haven't actually rejected any ICs from the
# epochs.
evoked = epochs.average()
# Plot source time course
fig = ica.plot_sources(evoked, show=config.interactive)
report.add_figs_to_section(figs=fig,
captions='All ICs - Source time course')
# Plot original & corrected data
fig = ica.plot_overlay(evoked, show=config.interactive)
report.add_figs_to_section(figs=fig,
captions=f'Evoked response (across all epochs) '
f'before and after cleaning via ICA '
f'({len(ica.exclude)} ICs removed)')
report.save(report_fname, overwrite=True, open_browser=False)
# Now actually reject the components.
msg = f'Rejecting ICs: {ica.exclude}'
logger.info(
gen_log_message(message=msg, step=5, subject=subject, session=session))
epochs_cleaned = ica.apply(epochs.copy()) # Copy b/c works in-place!
epochs_cleaned.apply_baseline(config.baseline)
msg = 'Saving cleaned epochs.'
logger.info(
gen_log_message(message=msg, step=5, subject=subject, session=session))
epochs_cleaned.save(fname_epo_out, overwrite=True)
if config.interactive:
epochs_cleaned.plot_image(combine='gfp', sigma=2., cmap="YlGnBu_r")
def test_compute_LF_matrix():
import os
import os.path as op
import nipype.pipeline.engine as pe
from nipype.interfaces.mne import WatershedBEM
import mne
import mne.io as io
from mne.minimum_norm import make_inverse_operator, apply_inverse_raw
from mne.report import Report
from nipype.utils.filemanip import split_filename as split_f
main_path = '/home/karim/Documents/pasca/data/resting_state/'
sbj_id = 'K0002'
sbj_dir = op.join(main_path, 'FSF')
bem_dir = op.join(sbj_dir, sbj_id, 'bem')
surface_dir = op.join(sbj_dir, sbj_id, 'bem/watershed')
data_dir = op.join(main_path, 'MEG')
raw_fname = op.join(data_dir, '%s/%s_rest_tsss_mc.fif' % (sbj_id, sbj_id))
raw = io.Raw(raw_fname, preload=True)
picks = mne.pick_types(raw.info, meg=True, ref_meg=False, exclude='bads')
raw.filter(l_freq=0.1, h_freq=300, picks=picks, method='iir', n_jobs=2)
raw.resample(sfreq=300, npad=0)
report = Report()
surfaces = [sbj_id + '_brain_surface',
sbj_id + '_inner_skull_surface',
sbj_id + '_outer_skull_surface',
sbj_id + '_outer_skin_surface']
new_surfaces = ['brain.surf',
'inner_skull.surf',
'outer_skull.surf',
'outer_skin.surf']
sbj_inner_skull_fname = op.join(bem_dir, sbj_id + '-' + new_surfaces[1])
inner_skull_fname = op.join(bem_dir, new_surfaces[1])
if not (op.isfile(sbj_inner_skull_fname) or op.isfile(inner_skull_fname)):
bem_IF = WatershedBEM()
bem_IF.inputs.subject_id = sbj_id
bem_IF.inputs.subjects_dir = sbj_dir
bem_IF.inputs.atlas_mode = True
bem_IF.run()
for i in range(len(surfaces)):
os.system('cp %s %s' % (op.join(surface_dir, surfaces[i]), op.join(bem_dir, sbj_id + '-' + new_surfaces[i])))
else:
print '*** inner skull surface exists!!!'
bem = op.join(bem_dir, '%s-5120-bem-sol.fif' % sbj_id)
if not op.isfile(bem):
os.system('$MNE_ROOT/bin/mne_setup_forward_model --subject ' + sbj_id + ' --homog --surf --ico 4')
else:
print '*** BEM solution file exists!!!'
src_fname = op.join(bem_dir, '%s-ico-5-src.fif' % sbj_id)
if not op.isfile(src_fname):
src = mne.setup_source_space(sbj_id, fname=True, spacing='ico5', subjects_dir=sbj_dir, overwrite=True, n_jobs=2)
else:
print '*** source space file exists!!!'
src = mne.read_source_spaces(src_fname)
trans_fname = op.join(data_dir, '%s/%s-trans.fif' % (sbj_id, sbj_id))
data_path, basename, ext = split_f(raw_fname)
fwd_filename = op.join(data_path, '%s-fwd.fif' % basename)
forward = mne.make_forward_solution(raw_fname, trans_fname, src, bem, fwd_filename, n_jobs=2, overwrite=True)
forward = mne.convert_forward_solution(forward, surf_ori=True)
snr = 1.0
lambda2 = 1.0 / snr ** 2
method = 'MNE'
reject = dict(mag=4e-12, grad=4e-10, eog=0.00025)
noise_cov = mne.compute_raw_data_covariance(raw, picks=picks, reject=reject)
inverse_operator = make_inverse_operator(raw.info, forward, noise_cov, loose=0.2, depth=0.8)
start, stop = raw.time_as_index([0, 30])
stc = apply_inverse_raw(raw, inverse_operator, lambda2, method, label=None, start=start, stop=stop, pick_ori=None)
print '***'
stc.shape
print '***'
subj_path, basename, ext = split_f(raw_fname)
stc_filename = op.join(subj_path, basename)
stc.save(stc_filename)
report_filename = op.join(subj_path, basename + '-BEM-report.html')
print report_filename
report.save(report_filename, open_browser=False, overwrite=True)
return
def run_ica(subject, tsss=config.mf_st_duration):
print("Processing subject: %s" % subject)
meg_subject_dir = op.join(config.meg_dir, subject)
raw_list = list()
events_list = list()
print(" Loading raw data")
for run in config.runs:
extension = run + '_sss_raw'
raw_fname_in = op.join(meg_subject_dir,
config.base_fname.format(**locals()))
eve_fname = op.splitext(raw_fname_in)[0] + '-eve.fif'
print("Input: ", raw_fname_in, eve_fname)
raw = mne.io.read_raw_fif(raw_fname_in, preload=True)
events = mne.read_events(eve_fname)
events_list.append(events)
# XXX mark bads from any run – is it a problem for ICA
# if we just exclude the bads shared by all runs ?
if run:
bads = set(chain(*config.bads[subject].values()))
else:
bads = config.bads[subject]
raw.info['bads'] = bads
print("added bads: ", raw.info['bads'])
raw_list.append(raw)
print(' Concatenating runs')
raw, events = mne.concatenate_raws(raw_list, events_list=events_list)
if config.eeg:
raw.set_eeg_reference(projection=True)
del raw_list
# produce high-pass filtered version of the data for ICA
epochs_for_ica = mne.Epochs(raw.copy().filter(l_freq=1., h_freq=None),
events,
config.event_id,
config.tmin,
config.tmax,
proj=True,
baseline=config.baseline,
preload=True,
decim=config.decim,
reject=config.reject)
# run ICA on MEG and EEG
picks_meg = mne.pick_types(epochs_for_ica.info,
meg=True,
eeg=False,
eog=False,
stim=False,
exclude='bads')
picks_eeg = mne.pick_types(epochs_for_ica.info,
meg=False,
eeg=True,
eog=False,
stim=False,
exclude='bads')
all_picks = {'meg': picks_meg, 'eeg': picks_eeg}
# get number of components for ICA
# compute_rank requires 0.18
# n_components_meg = (mne.compute_rank(epochs_for_ica.copy()
# .pick_types(meg=True)))['meg']
n_components_meg = 0.999
n_components = {'meg': n_components_meg, 'eeg': 0.999}
if config.eeg:
ch_types = ['meg', 'eeg']
else:
ch_types = ['meg']
for ch_type in ch_types:
print('Running ICA for ' + ch_type)
ica = ICA(method='fastica',
random_state=config.random_state,
n_components=n_components[ch_type])
picks = all_picks[ch_type]
ica.fit(epochs_for_ica, picks=picks, decim=decim)
print(
' Fit %d components (explaining at least %0.1f%% of the variance)'
% (ica.n_components_, 100 * n_components[ch_type]))
ica_name = op.join(
meg_subject_dir,
'{0}_{1}_{2}-ica.fif'.format(subject, config.study_name, ch_type))
ica.save(ica_name)
if config.plot:
# plot ICA components to html report
from mne.report import Report
report_name = op.join(
meg_subject_dir,
'{0}_{1}_{2}-ica.html'.format(subject, config.study_name,
ch_type))
report = Report(report_name, verbose=False)
for figure in ica.plot_properties(epochs_for_ica,
picks=list(
range(0, ica.n_components_)),
psd_args={'fmax': 60},
show=False):
report.add_figs_to_section(figure,
section=subject,
captions=(ch_type.upper() +
' - ICA Components'))
# XXX how to close each figure within the loop to avoid
# runtime error: > 20 figures opened
report.save(report_name, overwrite=True, open_browser=False)
def run_ica(subject, session=None):
"""Run ICA."""
print("Processing subject: %s" % subject)
# Construct the search path for the data file. `sub` is mandatory
subject_path = op.join('sub-{}'.format(subject))
# `session` is optional
if session is not None:
subject_path = op.join(subject_path, 'ses-{}'.format(session))
subject_path = op.join(subject_path, config.kind)
fpath_deriv = op.join(config.bids_root, 'derivatives',
config.PIPELINE_NAME, subject_path)
raw_list = list()
print(" Loading raw data")
for run in config.runs:
# load first run of raw data for ecg /eog epochs
print(" Loading one run from raw data")
bids_basename = make_bids_basename(subject=subject,
session=session,
task=config.task,
acquisition=config.acq,
run=run,
processing=config.proc,
recording=config.rec,
space=config.space)
raw_fname_in = \
op.join(fpath_deriv, bids_basename + '_filt_raw.fif')
eve_fname = \
op.join(fpath_deriv, bids_basename + '-eve.fif')
print("Input: ", raw_fname_in, eve_fname)
raw = mne.io.read_raw_fif(raw_fname_in, preload=True)
raw_list.append(raw)
print(' Concatenating runs')
raw = mne.concatenate_raws(raw_list)
events, event_id = mne.events_from_annotations(raw)
if "eeg" in config.ch_types or config.kind == 'eeg':
raw.set_eeg_reference(projection=True)
del raw_list
# don't reject based on EOG to keep blink artifacts
# in the ICA computation.
reject_ica = config.reject
if reject_ica and 'eog' in reject_ica:
reject_ica = dict(reject_ica)
del reject_ica['eog']
# produce high-pass filtered version of the data for ICA
raw_ica = raw.copy().filter(l_freq=1., h_freq=None)
print(" Running ICA...")
epochs_for_ica = mne.Epochs(raw_ica,
events,
event_id,
config.tmin,
config.tmax,
proj=True,
baseline=config.baseline,
preload=True,
decim=config.decim,
reject=reject_ica)
# run ICA on MEG and EEG
picks_meg = mne.pick_types(epochs_for_ica.info,
meg=True,
eeg=False,
eog=False,
stim=False,
exclude='bads')
picks_eeg = mne.pick_types(epochs_for_ica.info,
meg=False,
eeg=True,
eog=False,
stim=False,
exclude='bads')
all_picks = {'meg': picks_meg, 'eeg': picks_eeg}
# get number of components for ICA
# compute_rank requires 0.18
# n_components_meg = (mne.compute_rank(epochs_for_ica.copy()
# .pick_types(meg=True)))['meg']
n_components_meg = 0.999
n_components = {'meg': n_components_meg, 'eeg': 0.999}
ch_types = []
if 'eeg' in config.ch_types or config.kind == 'eeg':
ch_types.append('eeg')
if set(config.ch_types).intersection(('meg', 'grad', 'mag')):
ch_types.append('meg')
for ch_type in ch_types:
print('Running ICA for ' + ch_type)
ica = ICA(method='fastica',
random_state=config.random_state,
n_components=n_components[ch_type])
picks = all_picks[ch_type]
if picks.size == 0:
ica.fit(epochs_for_ica, decim=config.ica_decim)
else:
ica.fit(epochs_for_ica, picks=picks, decim=config.ica_decim)
print(' Fit %d components (explaining at least %0.1f%% of the'
' variance)' % (ica.n_components_, 100 * n_components[ch_type]))
# Load ICA
ica_fname = \
op.join(fpath_deriv, bids_basename + '_%s-ica.fif' % ch_type)
ica.save(ica_fname)
if config.plot:
# plot ICA components to html report
report_fname = \
op.join(fpath_deriv,
bids_basename + '_%s-ica.html' % ch_type)
report = Report(report_fname, verbose=False)
for idx in range(0, ica.n_components_):
figure = ica.plot_properties(epochs_for_ica,
picks=idx,
psd_args={'fmax': 60},
show=False)
report.add_figs_to_section(figure,
section=subject,
captions=(ch_type.upper() +
' - ICA Components'))
report.save(report_fname, overwrite=True, open_browser=False)
def preprocess_ICA_fif_to_ts(fif_file, ECG_ch_name, EoG_ch_name, l_freq, h_freq, down_sfreq, variance, is_sensor_space, data_type):
import os
import numpy as np
import mne
from mne.io import Raw
from mne.preprocessing import ICA, read_ica
from mne.preprocessing import create_ecg_epochs, create_eog_epochs
from mne.report import Report
from nipype.utils.filemanip import split_filename as split_f
report = Report()
subj_path, basename, ext = split_f(fif_file)
(data_path, sbj_name) = os.path.split(subj_path)
print data_path
# Read raw
# If None the compensation in the data is not modified.
# If set to n, e.g. 3, apply gradient compensation of grade n as for
# CTF systems (compensation=3)
raw = Raw(fif_file, preload=True)
# select sensors
select_sensors = mne.pick_types(raw.info, meg=True, ref_meg=False,
exclude='bads')
picks_meeg = mne.pick_types(raw.info, meg=True, eeg=True, exclude='bads')
# save electrode locations
sens_loc = [raw.info['chs'][i]['loc'][:3] for i in select_sensors]
sens_loc = np.array(sens_loc)
channel_coords_file = os.path.abspath("correct_channel_coords.txt")
print '*** ' + channel_coords_file + '***'
np.savetxt(channel_coords_file, sens_loc, fmt='%s')
# save electrode names
sens_names = np.array([raw.ch_names[pos] for pos in select_sensors],dtype = "str")
# AP 21032016
# channel_names_file = os.path.join(data_path, "correct_channel_names.txt")
channel_names_file = os.path.abspath("correct_channel_names.txt")
np.savetxt(channel_names_file,sens_names , fmt = '%s')
### filtering + downsampling
raw.filter(l_freq=l_freq, h_freq=h_freq, picks=picks_meeg,
method='iir', n_jobs=8)
# raw.filter(l_freq = l_freq, h_freq = h_freq, picks = picks_meeg,
# method='iir')
# raw.resample(sfreq=down_sfreq, npad=0)
### 1) Fit ICA model using the FastICA algorithm
# Other available choices are `infomax` or `extended-infomax`
# We pass a float value between 0 and 1 to select n_components based on the
# percentage of variance explained by the PCA components.
ICA_title = 'Sources related to %s artifacts (red)'
is_show = False # visualization
reject = dict(mag=4e-12, grad=4000e-13)
# check if we have an ICA, if yes, we load it
ica_filename = os.path.join(subj_path,basename + "-ica.fif")
if os.path.exists(ica_filename) is False:
ica = ICA(n_components=variance, method='fastica', max_iter=500) # , max_iter=500
ica.fit(raw, picks=select_sensors, reject=reject) # decim = 3,
has_ICA = False
else:
has_ICA = True
print ica_filename + ' exists!!!'
ica = read_ica(ica_filename)
ica.exclude = []
# 2) identify bad components by analyzing latent sources.
# generate ECG epochs use detection via phase statistics
# if we just have exclude channels we jump these steps
# if len(ica.exclude)==0:
n_max_ecg = 3
n_max_eog = 2
# check if ECG_ch_name is in the raw channels
if ECG_ch_name in raw.info['ch_names']:
ecg_epochs = create_ecg_epochs(raw, tmin=-.5, tmax=.5,
picks=select_sensors,
ch_name=ECG_ch_name)
# if not a synthetic ECG channel is created from cross channel average
else:
ecg_epochs = create_ecg_epochs(raw, tmin=-.5, tmax=.5,
picks=select_sensors)
# ICA for ECG artifact
# threshold=0.25 come default
ecg_inds, scores = ica.find_bads_ecg(ecg_epochs, method='ctps')
print scores
print '\n len ecg_inds *** ' + str(len(ecg_inds)) + '***\n'
if len(ecg_inds) > 0:
ecg_evoked = ecg_epochs.average()
fig1 = ica.plot_scores(scores, exclude=ecg_inds,
title=ICA_title % 'ecg', show=is_show)
show_picks = np.abs(scores).argsort()[::-1][:5] # Pick the five largest scores and plot them
# Plot estimated latent sources given the unmixing matrix.
#ica.plot_sources(raw, show_picks, exclude=ecg_inds, title=ICA_title % 'ecg', show=is_show)
t_start = 0
t_stop = 30 # take the fist 30s
fig2 = ica.plot_sources(raw, show_picks, exclude=ecg_inds, title=ICA_title % 'ecg' + ' in 30s'
,start = t_start, stop = t_stop, show=is_show)
# topoplot of unmixing matrix columns
fig3 = ica.plot_components(show_picks, title=ICA_title % 'ecg', colorbar=True, show=is_show)
ecg_inds = ecg_inds[:n_max_ecg]
ica.exclude += ecg_inds
fig4 = ica.plot_sources(ecg_evoked, exclude=ecg_inds, show=is_show) # plot ECG sources + selection
fig5 = ica.plot_overlay(ecg_evoked, exclude=ecg_inds, show=is_show) # plot ECG cleaning
fig = [fig1, fig2, fig3, fig4, fig5]
report.add_figs_to_section(fig, captions=['Scores of ICs related to ECG',
'Time Series plots of ICs (ECG)',
'TopoMap of ICs (ECG)',
'Time-locked ECG sources',
'ECG overlay'], section = 'ICA - ECG')
# check if EoG_ch_name is in the raw channels
# if EoG_ch_name is empty if data_type is fif, ICA routine automatically looks for EEG61, EEG62
# otherwise if data_type is ds we jump this step
if not EoG_ch_name and data_type=='ds':
eog_inds = []
else:
if EoG_ch_name in raw.info['ch_names']:
### ICA for eye blink artifact - detect EOG by correlation
eog_inds, scores = ica.find_bads_eog(raw, ch_name = EoG_ch_name)
else:
eog_inds, scores = ica.find_bads_eog(raw)
if len(eog_inds) > 0:
fig6 = ica.plot_scores(scores, exclude=eog_inds, title=ICA_title % 'eog', show=is_show)
report.add_figs_to_section(fig6, captions=['Scores of ICs related to EOG'],
section = 'ICA - EOG')
# check how many EoG ch we have
rs = np.shape(scores)
if len(rs)>1:
rr = rs[0]
show_picks = [np.abs(scores[i][:]).argsort()[::-1][:5] for i in range(rr)]
for i in range(rr):
fig7 = ica.plot_sources(raw, show_picks[i][:], exclude=eog_inds,
start = raw.times[0], stop = raw.times[-1],
title=ICA_title % 'eog',show=is_show)
fig8 = ica.plot_components(show_picks[i][:], title=ICA_title % 'eog', colorbar=True, show=is_show) # ICA nel tempo
fig = [fig7, fig8]
report.add_figs_to_section(fig, captions=['Scores of ICs related to EOG',
'Time Series plots of ICs (EOG)'],
section = 'ICA - EOG')
else:
show_picks = np.abs(scores).argsort()[::-1][:5]
fig7 = ica.plot_sources(raw, show_picks, exclude=eog_inds, title=ICA_title % 'eog', show=is_show)
fig8 = ica.plot_components(show_picks, title=ICA_title % 'eog', colorbar=True, show=is_show)
fig = [fig7, fig8]
report.add_figs_to_section(fig, captions=['Time Series plots of ICs (EOG)',
'TopoMap of ICs (EOG)',],
section = 'ICA - EOG')
eog_inds = eog_inds[:n_max_eog]
ica.exclude += eog_inds
if EoG_ch_name in raw.info['ch_names']:
eog_evoked = create_eog_epochs(raw, tmin=-.5, tmax=.5, picks=select_sensors,
ch_name=EoG_ch_name).average()
else:
eog_evoked = create_eog_epochs(raw, tmin=-.5, tmax=.5, picks=select_sensors).average()
fig9 = ica.plot_sources(eog_evoked, exclude=eog_inds, show=is_show) # plot EOG sources + selection
fig10 = ica.plot_overlay(eog_evoked, exclude=eog_inds, show=is_show) # plot EOG cleaning
fig = [fig9, fig10]
report.add_figs_to_section(fig, captions=['Time-locked EOG sources',
'EOG overlay'], section = 'ICA - EOG')
fig11 = ica.plot_overlay(raw, show=is_show)
report.add_figs_to_section(fig11, captions=['Signal'], section = 'Signal quality')
### plot all topographies and time seris of the ICA components
n_ica_components = ica.mixing_matrix_.shape[1]
n_topo = 10;
n_fig = n_ica_components/n_topo;
n_plot = n_ica_components%n_topo;
print '*************** n_fig = ' + str(n_fig) + ' n_plot = ' + str(n_plot) + '********************'
fig = []
t_start = 0
t_stop = None # 60 if we want to take the fist 60s
for n in range(0,n_fig):
fig_tmp = ica.plot_components(range(n_topo*n,n_topo*(n+1)),title='ICA components', show=is_show)
fig.append(fig_tmp)
fig_tmp = ica.plot_sources(raw, range(n_topo*n,n_topo*(n+1)),
start = t_start, stop = t_stop,
title='ICA components')
fig.append(fig_tmp)
# if n_plot > 0:
# fig_tmp = ica.plot_components(range(n_fig*n_topo,n_ica_components), title='ICA components', show=is_show)
# fig.append(fig_tmp)
# fig_tmp = ica.plot_sources(raw, range(n_fig*n_topo,n_ica_components),
# start = t_start, stop = t_stop,
# title='ICA components')
# fig.append(fig_tmp)
#
# for n in range(0, len(fig)):
# report.add_figs_to_section(fig[n], captions=['TOPO'], section = 'ICA Topo Maps')
if n_plot > 5:
n_fig_l = n_plot//5
print '*************************** ' + str(n_fig_l) + ' *********************************'
for n in range(0,n_fig_l):
print range(n_fig*n_topo+5*n, n_fig*n_topo+5*(n+1))
fig_tmp = ica.plot_components(range(n_fig*n_topo+5*n, n_fig*n_topo+5*(n+1)),title='ICA components')
fig.append(fig_tmp)
fig_tmp = ica.plot_sources(raw, range(n_fig*n_topo+5*n, n_fig*n_topo+5*(n+1)),
start = t_start, stop = t_stop,
title='ICA components')
fig.append(fig_tmp)
print range(n_fig*n_topo+5*(n+1),n_ica_components)
fig_tmp = ica.plot_components(range(n_fig*n_topo+5*(n+1),n_ica_components), title='ICA components')
fig.append(fig_tmp)
fig_tmp = ica.plot_sources(raw, range(n_fig*n_topo+5*(n+1),n_ica_components),
start = t_start, stop = t_stop,
title='ICA components')
fig.append(fig_tmp)
for n in range(0, len(fig)):
report.add_figs_to_section(fig[n], captions=['TOPO'], section = 'ICA Topo Maps')
report_filename = os.path.join(subj_path,basename + "-report.html")
print '******* ' + report_filename
report.save(report_filename, open_browser=False, overwrite=True)
# 3) apply ICA to raw data and save solution and report
# check the amplitudes do not change
# raw_ica_file = os.path.abspath(basename[:i_raw] + 'ica-raw.fif')
raw_ica_file = os.path.join(subj_path, basename + '-preproc-raw.fif')
raw_ica = ica.apply(raw)
raw_ica.resample(sfreq=down_sfreq, npad=0)
raw_ica.save(raw_ica_file, overwrite=True)
# save ICA solution
print ica_filename
if has_ICA is False:
ica.save(ica_filename)
# 4) save data
data_noIca, times = raw[select_sensors, :]
data, times = raw_ica[select_sensors, :]
print data.shape
print raw.info['sfreq']
ts_file = os.path.abspath(basename + "_ica.npy")
np.save(ts_file, data)
print '***** TS FILE ' + ts_file + '*****'
if is_sensor_space:
return ts_file, channel_coords_file, channel_names_file, raw.info['sfreq']
else:
# return raw_ica, channel_coords_file, channel_names_file, raw.info['sfreq']
return raw_ica_file, channel_coords_file, channel_names_file, raw.info['sfreq']
def test_render_report():
"""Test rendering -*.fif files for mne report.
"""
tempdir = _TempDir()
raw_fname_new = op.join(tempdir, 'temp_raw.fif')
event_fname_new = op.join(tempdir, 'temp_raw-eve.fif')
cov_fname_new = op.join(tempdir, 'temp_raw-cov.fif')
fwd_fname_new = op.join(tempdir, 'temp_raw-fwd.fif')
inv_fname_new = op.join(tempdir, 'temp_raw-inv.fif')
for a, b in [[raw_fname, raw_fname_new], [event_fname, event_fname_new],
[cov_fname, cov_fname_new], [fwd_fname, fwd_fname_new],
[inv_fname, inv_fname_new]]:
shutil.copyfile(a, b)
# create and add -epo.fif and -ave.fif files
epochs_fname = op.join(tempdir, 'temp-epo.fif')
evoked_fname = op.join(tempdir, 'temp-ave.fif')
raw = Raw(raw_fname_new)
picks = pick_types(raw.info, meg='mag', eeg=False) # faster with one type
epochs = Epochs(raw, read_events(event_fname), 1, -0.2, 0.2, picks=picks)
epochs.save(epochs_fname)
epochs.average().save(evoked_fname)
report = Report(info_fname=raw_fname_new, subjects_dir=subjects_dir)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
report.parse_folder(data_path=tempdir, on_error='raise')
assert_true(len(w) >= 1)
# Check correct paths and filenames
fnames = glob.glob(op.join(tempdir, '*.fif'))
for fname in fnames:
assert_true(
op.basename(fname) in [op.basename(x) for x in report.fnames])
assert_true(''.join(report.html).find(op.basename(fname)) != -1)
assert_equal(len(report.fnames), len(fnames))
assert_equal(len(report.html), len(report.fnames))
# Check saving functionality
report.data_path = tempdir
report.save(fname=op.join(tempdir, 'report.html'), open_browser=False)
assert_true(op.isfile(op.join(tempdir, 'report.html')))
assert_equal(len(report.html), len(fnames))
assert_equal(len(report.html), len(report.fnames))
# Check saving same report to new filename
report.save(fname=op.join(tempdir, 'report2.html'), open_browser=False)
assert_true(op.isfile(op.join(tempdir, 'report2.html')))
# Check overwriting file
report.save(fname=op.join(tempdir, 'report.html'),
open_browser=False,
overwrite=True)
assert_true(op.isfile(op.join(tempdir, 'report.html')))
# Check pattern matching with multiple patterns
pattern = ['*raw.fif', '*eve.fif']
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
report.parse_folder(data_path=tempdir, pattern=pattern)
assert_true(len(w) >= 1)
fnames = glob.glob(op.join(tempdir, '*.raw')) + \
glob.glob(op.join(tempdir, '*.raw'))
for fname in fnames:
assert_true(
op.basename(fname) in [op.basename(x) for x in report.fnames])
assert_true(''.join(report.html).find(op.basename(fname)) != -1)
def test_render_add_sections(renderer, tmpdir):
"""Test adding figures/images to section."""
tempdir = str(tmpdir)
report = Report(subjects_dir=subjects_dir)
# Check add_figs_to_section functionality
fig = plt.plot([1, 2], [1, 2])[0].figure
report.add_figs_to_section(
figs=fig, # test non-list input
captions=['evoked response'],
scale=1.2,
image_format='svg')
pytest.raises(ValueError,
report.add_figs_to_section,
figs=[fig, fig],
captions='H')
pytest.raises(ValueError,
report.add_figs_to_section,
figs=fig,
captions=['foo'],
scale=0,
image_format='svg')
pytest.raises(ValueError,
report.add_figs_to_section,
figs=fig,
captions=['foo'],
scale=1e-10,
image_format='svg')
# need to recreate because calls above change size
fig = plt.plot([1, 2], [1, 2])[0].figure
# Check add_images_to_section with png
img_fname = op.join(tempdir, 'testimage.png')
fig.savefig(img_fname)
report.add_images_to_section(fnames=[img_fname],
captions=['evoked response'])
report.add_images_to_section(fnames=[img_fname],
captions=['evoked response'])
pytest.raises(ValueError,
report.add_images_to_section,
fnames=[img_fname, img_fname],
captions='H')
pytest.raises(ValueError,
report.add_images_to_section,
fnames=['foobar.xxx'],
captions='H')
evoked = read_evokeds(evoked_fname,
condition='Left Auditory',
baseline=(-0.2, 0.0))
fig = plot_alignment(evoked.info,
trans_fname,
subject='sample',
subjects_dir=subjects_dir)
report.add_figs_to_section(
figs=fig, # test non-list input
captions='random image',
scale=1.2)
assert (repr(report))
def comparativePlot(evoked_dict, section=None, captions=None, colors=colors):
fig, ax = plt.subplots(1, 2, figsize=(12, 5))
ax = mne.viz.plot_compare_evokeds(evoked_dict, truncate_yaxis=False,
show=False, axes=ax, colors=colors)
report.add_figs_to_section(fig, section=nip, captions=captions)
###############################################################################
############################# SUBJECTS ANALYSIS ###############################
###############################################################################
# Open html report
report = Report('Mutlisensory vs Unisensory evoked response', verbose=False)
group_evoked_dict_aud = {'Causality':[], 'Temporal':[], 'Auditory':[]}
group_evoked_dict_vis = {'Causality':[], 'Temporal':[], 'Visual':[]}
for nip in nips:
###########################################################################
####################### Import preprocessed data ##########################
###########################################################################
raw = importRaw(nip)
events = importEvents(raw, nip)
###########################################################################
########################## Cycle across blocs #############################
# Directories to use
data_sss_directory = returnSSSDirectory()
data_ica_directory = returnICADirectory()
data_preprocesed_directory = returnPreProcessedDirectory()
# NIPs of subjects
nips = returnNips()
# Bad EEG channels
bad_EEG = returnBadEEG()
# Parameters for automatic rejection
rejectDict = returnRejectLimits()
# Open html report
report = Report('EOG/ECG/MISC artifacts automatic rejection', verbose=False)
###############################################################################
####################### ARTIFACTS REJECTION PER SUBJECT ######################
###############################################################################
for nip in nips:
nip_path = data_sss_directory + '/' + nip + '/'
# Load raw data (problem with MISC005 not present)
for filePath in glob.glob(nip_path + '*sss_raw.fif'):
temp = mne.io.Raw(filePath, preload=True, add_eeg_ref=False)
if 'MISC005' in temp.ch_names and nip in ['vV100048', 'Pb160320']:
temp.drop_channels(['MISC005'])
if not 'raw' in locals():
def setup_provenance(script, results_dir, use_agg=True):
"""Setup provenance tracking
Parameters
----------
script : str
The script that was executed.
results_dir : str
The results directory.
use_agg : bool
Whether to use the 'Agg' backend for matplotlib or not.
Returns
-------
report : mne.report.Report
The mne report.
Side-effects
------------
- make results dir if it does not exists
- sets log file for sterr output
- writes log file with runtime information
"""
if use_agg is True:
import matplotlib
matplotlib.use('Agg')
if not op.isfile(script):
raise ValueError('sorry, this is not a script!')
step = op.splitext(op.split(script)[1])[0]
results_dir = op.join(results_dir, step)
if not op.exists(results_dir):
logger.info('generating results dir')
os.mkdir(results_dir)
run_id = create_run_id()
logger.info('generated run id: %s' % run_id)
logger.info('preparing logging:')
logging_dir = op.join(results_dir, run_id)
logger.info('... making logging directory: %s' % logging_dir)
os.mkdir(logging_dir)
modules = get_versions(sys)
runtime_log = op.join(logging_dir, 'run_time.json')
with open(runtime_log, 'w') as fid:
json.dump(modules, fid)
logger.info('... writing runtime info to: %s' % runtime_log)
std_logfile = op.join(logging_dir, 'run_output.log')
script_code = op.join(logging_dir, 'script.py')
with open(script_code, 'w') as fid:
with open(script) as script_fid:
source_code = script_fid.read()
fid.write(source_code)
logger.info('... logging source code')
logger.info('... preparing Report')
report = Report(title=step)
report.data_path = logging_dir
logger.info('... setting logfile: %s' % std_logfile)
set_log_file(std_logfile)
return report, run_id, results_dir, logger
# Bad EEG channels
bad_EEG = returnBadEEG()
# Parameters for automatic rejection
rejectDict = returnRejectLimits()
# ICA components manually rejected
ica_rejects = returnBadICA()
###############################################################################
############################ ARTIFACTS REJECTION #############################
###############################################################################
# Open html report
report = Report('EOG/ECG artifacts manual rejection', verbose=False)
for nip in nips:
nip_path = data_ica_directory + '/' + nip + '/'
# Load raw data (already gone trough 3_rejectArtifactsAutomatically.py)
filePath = glob.glob(nip_path + nip + '_auto_ica_sss_raw*.fif') # Multiple files
raw = mne.io.Raw(filePath, preload=True)
# Exclude bad EEG channels
raw.info['bads'] = bad_EEG[nip]
###########################################################################
####################### Cycle across channel type #########################
###########################################################################
def autodenoise_MEG(subject, run):
###############################################################################
import numpy as np
import mne
import os.path as op
import os
import matplotlib
matplotlib.use('Agg')
from mne.report import Report
from mne.io import Raw
from mne.preprocessing import ICA
from mne.preprocessing import create_ecg_epochs, create_eog_epochs
data_path = '/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/'
raw_fname = data_path + subject + '/' + run + '_trans_sss.fif'
# ICA
report = Report(subject)
raw = Raw(raw_fname, preload=True)
raw.filter(None, 30, n_jobs=4)
picks = mne.pick_types(raw.info,
meg=True,
eeg=False,
eog=False,
stim=False,
exclude='bads')
ica = ICA(n_components=0.95, method='fastica')
ica.fit(raw, picks=picks, decim=4)
# maximum number of components to reject
n_max_ecg, n_max_eogv, n_max_eogh = 3, 3, 3
title = 'Sources related to %s artifacts (red)'
# Create the results directory if it doesn't exist
results_dir = op.join(data_path, subject, 'artefactICA')
if not op.exists(results_dir):
os.makedirs(results_dir)
#ica_fname = '%s_ica' % (subject)
###############################################################################
# generate ECG epochs use detection via phase statistics
ecg_epochs = create_ecg_epochs(raw, tmin=-.5, tmax=.5, picks=picks)
ecg_inds, scores = ica.find_bads_ecg(ecg_epochs, method='ctps')
fig1 = ica.plot_scores(scores,
exclude=ecg_inds,
title=title % 'ecg',
labels='ecg')
report.add_figs_to_section(fig1, captions='ECGcomp', section='ICA')
show_picks = np.abs(scores).argsort()[::-1][:5]
fig2 = ica.plot_sources(raw,
show_picks,
exclude=ecg_inds,
title=title % 'ecg')
report.add_figs_to_section(fig2, captions='ECGcomptime', section='ICA')
fig3 = ica.plot_components(ecg_inds, title=title % 'ecg', colorbar=True)
report.add_figs_to_section(fig3, captions='ECGcomptopo', section='ICA')
ecg_inds = ecg_inds[:n_max_ecg]
report.save((results_dir + '/' + run + '.html'),
open_browser=False,
overwrite=True)
###############################################################################
# detect vertical EOG by correlation
eogv_inds = []
eogv_inds, scores = ica.find_bads_eog(raw, ch_name='EOG061')
fig4 = ica.plot_scores(scores,
exclude=eogv_inds,
title=title % 'eogv',
labels='ecg')
report.add_figs_to_section(fig4, captions='EOGvcomp', section='ICA')
show_picks = np.abs(scores).argsort()[::-1][:5]
fig5 = ica.plot_sources(raw,
show_picks,
exclude=eogv_inds,
title=title % 'eogv')
report.add_figs_to_section(fig5, captions='EOGvcomptime', section='ICA')
fig6 = ica.plot_components(eogv_inds, title=title % 'eogv', colorbar=True)
report.add_figs_to_section(fig6, captions='EOGvcomptopo', section='ICA')
eogv_inds = eogv_inds[:n_max_eogv]
report.save((results_dir + '/' + run + '.html'),
open_browser=False,
overwrite=True)
###############################################################################
# detect horizontal EOG by correlation
eogh_inds = []
eogh_inds, scores = ica.find_bads_eog(raw, ch_name='EOG062')
fig7 = ica.plot_scores(scores,
exclude=eogh_inds,
title=title % 'eogh',
labels='ecg')
report.add_figs_to_section(fig7, captions='EOGhcomp', section='ICA')
show_picks = np.abs(scores).argsort()[::-1][:5]
fig8 = ica.plot_sources(raw,
show_picks,
exclude=eogh_inds,
title=title % 'eogh')
report.add_figs_to_section(fig8, captions='EOGhcomptime', section='ICA')
fig9 = ica.plot_components(eogh_inds, title=title % 'eogh', colorbar=True)
report.add_figs_to_section(fig9, captions='EOGhcomptopo', section='ICA')
eogh_inds = eogh_inds[:n_max_eogh]
report.save((results_dir + '/' + run + '.html'),
open_browser=False,
overwrite=True)
###############################################################################
# estimate average artifact
ecg_evoked = ecg_epochs.average()
fig10 = ica.plot_sources(ecg_evoked,
exclude=ecg_inds) # plot ECG sources + selection
fig11 = ica.plot_overlay(ecg_evoked, exclude=ecg_inds) # plot ECG cleaning
report.add_figs_to_section(fig10, captions='ECG sources', section='ICA')
report.add_figs_to_section(fig11, captions='ECG clean', section='ICA')
eogv_evoked = create_eog_epochs(raw,
tmin=-.5,
ch_name='EOG061',
tmax=.5,
picks=picks).average()
fig12 = ica.plot_sources(eogv_evoked,
exclude=eogv_inds) # plot EOG sources + selection
fig13 = ica.plot_overlay(eogv_evoked,
exclude=eogv_inds) # plot EOG cleaning
report.add_figs_to_section(fig12, captions='EOGv sources', section='ICA')
report.add_figs_to_section(fig13, captions='EOGv clean', section='ICA')
eogh_evoked = create_eog_epochs(raw,
tmin=-.5,
ch_name='EOG062',
tmax=.5,
picks=picks).average()
fig14 = ica.plot_sources(eogh_evoked,
exclude=eogh_inds) # plot EOG sources + selection
fig15 = ica.plot_overlay(eogh_evoked,
exclude=eogh_inds) # plot EOG cleaning
report.add_figs_to_section(fig14, captions='EOGh sources', section='ICA')
report.add_figs_to_section(fig15, captions='EOGh clean', section='ICA')
# check the amplitudes do not change
fig16 = ica.plot_overlay(raw) # EOG artifacts remain
report.add_figs_to_section(fig16, captions='avg', section='ICA')
###############################################################################
# Create the results directory if it doesn't exist
ica_dir = op.join(data_path, subject, 'mne_python/ICA')
if not op.exists(ica_dir):
os.makedirs(ica_dir)
# mark bad components and save ica
artifact_inds = list(np.unique(eogv_inds + eogh_inds + ecg_inds))
ica.exclude = []
ica.exclude = artifact_inds
ica.save((ica_dir + '/ICA_MEG' + run))
def test_render_report(renderer, tmpdir):
"""Test rendering -*.fif files for mne report."""
tempdir = str(tmpdir)
raw_fname_new = op.join(tempdir, 'temp_raw.fif')
raw_fname_new_bids = op.join(tempdir, 'temp_meg.fif')
ms_fname_new = op.join(tempdir, 'temp_ms_raw.fif')
event_fname_new = op.join(tempdir, 'temp_raw-eve.fif')
cov_fname_new = op.join(tempdir, 'temp_raw-cov.fif')
fwd_fname_new = op.join(tempdir, 'temp_raw-fwd.fif')
inv_fname_new = op.join(tempdir, 'temp_raw-inv.fif')
for a, b in [[raw_fname, raw_fname_new], [raw_fname, raw_fname_new_bids],
[ms_fname, ms_fname_new], [event_fname, event_fname_new],
[cov_fname, cov_fname_new], [fwd_fname, fwd_fname_new],
[inv_fname, inv_fname_new]]:
shutil.copyfile(a, b)
# create and add -epo.fif and -ave.fif files
epochs_fname = op.join(tempdir, 'temp-epo.fif')
evoked_fname = op.join(tempdir, 'temp-ave.fif')
# Speed it up by picking channels
raw = read_raw_fif(raw_fname_new, preload=True)
raw.pick_channels(['MEG 0111', 'MEG 0121'])
raw.del_proj()
epochs = Epochs(raw, read_events(event_fname), 1, -0.2, 0.2)
epochs.save(epochs_fname, overwrite=True)
# This can take forever (stall Travis), so let's make it fast
# Also, make sure crop range is wide enough to avoid rendering bug
epochs.average().crop(0.1, 0.2).save(evoked_fname)
report = Report(info_fname=raw_fname_new, subjects_dir=subjects_dir)
with pytest.warns(RuntimeWarning, match='Cannot render MRI'):
report.parse_folder(data_path=tempdir, on_error='raise')
assert repr(report)
# Check correct paths and filenames
fnames = glob.glob(op.join(tempdir, '*.fif'))
for fname in fnames:
assert (op.basename(fname) in [op.basename(x) for x in report.fnames])
assert (''.join(report.html).find(op.basename(fname)) != -1)
assert_equal(len(report.fnames), len(fnames))
assert_equal(len(report.html), len(report.fnames))
assert_equal(len(report.fnames), len(report))
# Check saving functionality
report.data_path = tempdir
fname = op.join(tempdir, 'report.html')
report.save(fname=fname, open_browser=False)
assert (op.isfile(fname))
with open(fname, 'rb') as fid:
html = fid.read().decode('utf-8')
assert '(MaxShield on)' in html
assert_equal(len(report.html), len(fnames))
assert_equal(len(report.html), len(report.fnames))
# Check saving same report to new filename
report.save(fname=op.join(tempdir, 'report2.html'), open_browser=False)
assert (op.isfile(op.join(tempdir, 'report2.html')))
# Check overwriting file
report.save(fname=op.join(tempdir, 'report.html'),
open_browser=False,
overwrite=True)
assert (op.isfile(op.join(tempdir, 'report.html')))
# Check pattern matching with multiple patterns
pattern = ['*raw.fif', '*eve.fif']
with pytest.warns(RuntimeWarning, match='Cannot render MRI'):
report.parse_folder(data_path=tempdir, pattern=pattern)
assert (repr(report))
fnames = glob.glob(op.join(tempdir, '*.raw')) + \
glob.glob(op.join(tempdir, '*.raw'))
for fname in fnames:
assert (op.basename(fname) in [op.basename(x) for x in report.fnames])
assert (''.join(report.html).find(op.basename(fname)) != -1)
pytest.raises(ValueError, Report, image_format='foo')
pytest.raises(ValueError, Report, image_format=None)
# SVG rendering
report = Report(info_fname=raw_fname_new,
subjects_dir=subjects_dir,
image_format='svg')
with pytest.warns(RuntimeWarning, match='Cannot render MRI'):
report.parse_folder(data_path=tempdir, on_error='raise')
# ndarray support smoke test
report.add_figs_to_section(np.zeros((2, 3, 3)), 'caption', 'section')
with pytest.raises(TypeError, match='figure must be a'):
report.add_figs_to_section('foo', 'caption', 'section')
with pytest.raises(TypeError, match='figure must be a'):
report.add_figs_to_section(['foo'], 'caption', 'section')
def test_render_report(renderer, tmpdir):
"""Test rendering *.fif files for mne report."""
tempdir = str(tmpdir)
raw_fname_new = op.join(tempdir, 'temp_raw.fif')
raw_fname_new_bids = op.join(tempdir, 'temp_meg.fif')
ms_fname_new = op.join(tempdir, 'temp_ms_raw.fif')
event_fname_new = op.join(tempdir, 'temp_raw-eve.fif')
cov_fname_new = op.join(tempdir, 'temp_raw-cov.fif')
proj_fname_new = op.join(tempdir, 'temp_ecg-proj.fif')
fwd_fname_new = op.join(tempdir, 'temp_raw-fwd.fif')
inv_fname_new = op.join(tempdir, 'temp_raw-inv.fif')
nirs_fname_new = op.join(tempdir, 'temp_raw-nirs.snirf')
for a, b in [[raw_fname, raw_fname_new],
[raw_fname, raw_fname_new_bids],
[ms_fname, ms_fname_new],
[event_fname, event_fname_new],
[cov_fname, cov_fname_new],
[proj_fname, proj_fname_new],
[fwd_fname, fwd_fname_new],
[inv_fname, inv_fname_new],
[nirs_fname, nirs_fname_new]]:
shutil.copyfile(a, b)
# create and add -epo.fif and -ave.fif files
epochs_fname = op.join(tempdir, 'temp-epo.fif')
evoked_fname = op.join(tempdir, 'temp-ave.fif')
# Speed it up by picking channels
raw = read_raw_fif(raw_fname_new, preload=True)
raw.pick_channels(['MEG 0111', 'MEG 0121', 'EEG 001', 'EEG 002'])
raw.del_proj()
raw.set_eeg_reference(projection=True)
epochs = Epochs(raw, read_events(event_fname), 1, -0.2, 0.2)
epochs.save(epochs_fname, overwrite=True)
# This can take forever, so let's make it fast
# Also, make sure crop range is wide enough to avoid rendering bug
evoked = epochs.average()
with pytest.warns(RuntimeWarning, match='tmax is not in Evoked'):
evoked.crop(0.1, 0.2)
evoked.save(evoked_fname)
report = Report(info_fname=raw_fname_new, subjects_dir=subjects_dir,
projs=True)
with pytest.warns(RuntimeWarning, match='Cannot render MRI'):
report.parse_folder(data_path=tempdir, on_error='raise')
assert repr(report)
# Check correct paths and filenames
fnames = glob.glob(op.join(tempdir, '*.fif'))
fnames.extend(glob.glob(op.join(tempdir, '*.snirf')))
for fname in fnames:
assert (op.basename(fname) in
[op.basename(x) for x in report.fnames])
assert (''.join(report.html).find(op.basename(fname)) != -1)
assert len(report.fnames) == len(fnames)
assert len(report.html) == len(report.fnames)
assert len(report.fnames) == len(report)
# Check saving functionality
report.data_path = tempdir
fname = op.join(tempdir, 'report.html')
report.save(fname=fname, open_browser=False)
assert (op.isfile(fname))
with open(fname, 'rb') as fid:
html = fid.read().decode('utf-8')
assert '(MaxShield on)' in html
# Projectors in Raw.info
assert '<h4>SSP Projectors</h4>' in html
# Projectors in `proj_fname_new`
assert f'SSP Projectors: {op.basename(proj_fname_new)}' in html
# Evoked in `evoked_fname`
assert f'Evoked: {op.basename(evoked_fname)} ({evoked.comment})' in html
assert 'Topomap (ch_type =' in html
assert f'Evoked: {op.basename(evoked_fname)} (GFPs)' in html
assert len(report.html) == len(fnames)
assert len(report.html) == len(report.fnames)
# Check saving same report to new filename
report.save(fname=op.join(tempdir, 'report2.html'), open_browser=False)
assert (op.isfile(op.join(tempdir, 'report2.html')))
# Check overwriting file
report.save(fname=op.join(tempdir, 'report.html'), open_browser=False,
overwrite=True)
assert (op.isfile(op.join(tempdir, 'report.html')))
# Check pattern matching with multiple patterns
pattern = ['*raw.fif', '*eve.fif']
with pytest.warns(RuntimeWarning, match='Cannot render MRI'):
report.parse_folder(data_path=tempdir, pattern=pattern)
assert (repr(report))
fnames = glob.glob(op.join(tempdir, '*.raw')) + \
glob.glob(op.join(tempdir, '*.raw'))
for fname in fnames:
assert (op.basename(fname) in
[op.basename(x) for x in report.fnames])
assert (''.join(report.html).find(op.basename(fname)) != -1)
pytest.raises(ValueError, Report, image_format='foo')
pytest.raises(ValueError, Report, image_format=None)
# SVG rendering
report = Report(info_fname=raw_fname_new, subjects_dir=subjects_dir,
image_format='svg')
tempdir = pathlib.Path(tempdir) # test using pathlib.Path
with pytest.warns(RuntimeWarning, match='Cannot render MRI'):
report.parse_folder(data_path=tempdir, on_error='raise')
# ndarray support smoke test
report.add_figs_to_section(np.zeros((2, 3, 3)), 'caption', 'section')
with pytest.raises(TypeError, match='figure must be a'):
report.add_figs_to_section('foo', 'caption', 'section')
with pytest.raises(TypeError, match='figure must be a'):
report.add_figs_to_section(['foo'], 'caption', 'section')
from mne.report import Report
from mne.datasets import sample
from mne import read_evokeds
from matplotlib import pyplot as plt
data_path = sample.data_path()
meg_path = data_path + '/MEG/sample'
subjects_dir = data_path + '/subjects'
evoked_fname = meg_path + '/sample_audvis-ave.fif'
###############################################################################
# Do standard folder parsing (this can take a couple of minutes):
report = Report(image_format='png',
subjects_dir=subjects_dir,
info_fname=evoked_fname,
subject='sample')
report.parse_folder(meg_path)
###############################################################################
# Add a custom section with an evoked slider:
# Load the evoked data
evoked = read_evokeds(evoked_fname,
condition='Left Auditory',
baseline=(None, 0),
verbose=False)
evoked.crop(0, .2)
times = evoked.times[::4]
# Create a list of figs for the slider
figs = list()
def test_sorting(tmp_path):
"""Test that automated ordering based on tags works."""
r = Report()
r.add_code(code='E = m * c**2', title='intelligence >9000', tags=('bem', ))
r.add_code(code='a**2 + b**2 = c**2',
title='Pythagoras',
tags=('evoked', ))
r.add_code(code='🧠',
title='source of truth',
tags=('source-estimate', ))
r.add_code(code='🥦', title='veggies', tags=('raw', ))
# Check that repeated calls of add_* actually continuously appended to
# the report
orig_order = ['bem', 'evoked', 'source-estimate', 'raw']
assert [c.tags[0] for c in r._content] == orig_order
# Now check the actual sorting
content_sorted = r._sort(content=r._content, order=CONTENT_ORDER)
expected_order = ['raw', 'evoked', 'bem', 'source-estimate']
assert content_sorted != r._content
assert [c.tags[0] for c in content_sorted] == expected_order
r.save(fname=op.join(tmp_path, 'report.html'),
sort_content=True,
open_browser=False)
def run():
"""Run command."""
from mne.commands.utils import get_optparser
parser = get_optparser(__file__)
parser.add_option("-p", "--path", dest="path",
help="Path to folder who MNE-Report must be created")
parser.add_option("-i", "--info", dest="info_fname",
help="File from which info dictionary is to be read",
metavar="FILE")
parser.add_option("-c", "--cov", dest="cov_fname",
help="File from which noise covariance is to be read",
metavar="FILE")
parser.add_option("--bmin", dest="bmin",
help="Time at which baseline correction starts for "
"evokeds", default=None)
parser.add_option("--bmax", dest="bmax",
help="Time at which baseline correction stops for "
"evokeds", default=None)
parser.add_option("-d", "--subjects-dir", dest="subjects_dir",
help="The subjects directory")
parser.add_option("-s", "--subject", dest="subject",
help="The subject name")
parser.add_option("-v", "--verbose", dest="verbose",
action='store_true', help="run in verbose mode")
parser.add_option("--no-browser", dest="no_browser", action='store_false',
help="Do not open MNE-Report in browser")
parser.add_option("--overwrite", dest="overwrite", action='store_false',
help="Overwrite html report if it already exists")
parser.add_option("-j", "--jobs", dest="n_jobs", help="Number of jobs to"
" run in parallel")
parser.add_option("-m", "--mri-decim", type="int", dest="mri_decim",
default=2, help="Integer factor used to decimate "
"BEM plots")
options, args = parser.parse_args()
path = options.path
if path is None:
parser.print_help()
sys.exit(1)
info_fname = options.info_fname
cov_fname = options.cov_fname
subjects_dir = options.subjects_dir
subject = options.subject
mri_decim = int(options.mri_decim)
verbose = True if options.verbose is not None else False
open_browser = False if options.no_browser is not None else True
overwrite = True if options.overwrite is not None else False
n_jobs = int(options.n_jobs) if options.n_jobs is not None else 1
bmin = float(options.bmin) if options.bmin is not None else None
bmax = float(options.bmax) if options.bmax is not None else None
# XXX: this means (None, None) cannot be specified through command line
if bmin is None and bmax is None:
baseline = None
else:
baseline = (bmin, bmax)
t0 = time.time()
report = Report(info_fname, subjects_dir=subjects_dir,
subject=subject, baseline=baseline,
cov_fname=cov_fname, verbose=verbose)
report.parse_folder(path, verbose=verbose, n_jobs=n_jobs,
mri_decim=mri_decim)
log_elapsed(time.time() - t0, verbose=verbose)
report.save(open_browser=open_browser, overwrite=overwrite)
def apply_ica(subject, run, session):
print("Processing subject: %s" % subject)
# Construct the search path for the data file. `sub` is mandatory
subject_path = op.join('sub-{}'.format(subject))
# `session` is optional
if session is not None:
subject_path = op.join(subject_path, 'ses-{}'.format(session))
subject_path = op.join(subject_path, config.kind)
bids_basename = make_bids_basename(subject=subject,
session=session,
task=config.task,
acquisition=config.acq,
run=None,
processing=config.proc,
recording=config.rec,
space=config.space
)
fpath_deriv = op.join(config.bids_root, 'derivatives',
config.PIPELINE_NAME, subject_path)
fname_in = \
op.join(fpath_deriv, bids_basename + '-epo.fif')
fname_out = \
op.join(fpath_deriv, bids_basename + '_cleaned-epo.fif')
# load epochs to reject ICA components
epochs = mne.read_epochs(fname_in, preload=True)
print("Input: ", fname_in)
print("Output: ", fname_out)
# load first run of raw data for ecg /eog epochs
print(" Loading one run from raw data")
bids_basename = make_bids_basename(subject=subject,
session=session,
task=config.task,
acquisition=config.acq,
run=config.runs[0],
processing=config.proc,
recording=config.rec,
space=config.space
)
if config.use_maxwell_filter:
raw_fname_in = \
op.join(fpath_deriv, bids_basename + '_sss_raw.fif')
else:
raw_fname_in = \
op.join(fpath_deriv, bids_basename + '_filt_raw.fif')
raw = mne.io.read_raw_fif(raw_fname_in, preload=True)
# run ICA on MEG and EEG
picks_meg = mne.pick_types(raw.info, meg=True, eeg=False,
eog=False, stim=False, exclude='bads')
picks_eeg = mne.pick_types(raw.info, meg=False, eeg=True,
eog=False, stim=False, exclude='bads')
all_picks = {'meg': picks_meg, 'eeg': picks_eeg}
for ch_type in config.ch_types:
report = None
print(ch_type)
picks = all_picks[ch_type]
# Load ICA
fname_ica = \
op.join(fpath_deriv, bids_basename + '_%s-ica.fif' % ch_type)
print('Reading ICA: ' + fname_ica)
ica = read_ica(fname=fname_ica)
pick_ecg = mne.pick_types(raw.info, meg=False, eeg=False,
ecg=True, eog=False)
# ECG
# either needs an ecg channel, or avg of the mags (i.e. MEG data)
ecg_inds = list()
if pick_ecg or ch_type == 'meg':
picks_ecg = np.concatenate([picks, pick_ecg])
# Create ecg epochs
if ch_type == 'meg':
reject = {'mag': config.reject['mag'],
'grad': config.reject['grad']}
elif ch_type == 'eeg':
reject = {'eeg': config.reject['eeg']}
ecg_epochs = create_ecg_epochs(raw, picks=picks_ecg, reject=reject,
baseline=(None, 0), tmin=-0.5,
tmax=0.5)
ecg_average = ecg_epochs.average()
ecg_inds, scores = \
ica.find_bads_ecg(ecg_epochs, method='ctps',
threshold=config.ica_ctps_ecg_threshold)
del ecg_epochs
report_fname = \
op.join(fpath_deriv,
bids_basename + '_%s-reject_ica.html' % ch_type)
report = Report(report_fname, verbose=False)
# Plot r score
report.add_figs_to_section(ica.plot_scores(scores,
exclude=ecg_inds,
show=config.plot),
captions=ch_type.upper() + ' - ECG - ' +
'R scores')
# Plot source time course
report.add_figs_to_section(ica.plot_sources(ecg_average,
exclude=ecg_inds,
show=config.plot),
captions=ch_type.upper() + ' - ECG - ' +
'Sources time course')
# Plot source time course
report.add_figs_to_section(ica.plot_overlay(ecg_average,
exclude=ecg_inds,
show=config.plot),
captions=ch_type.upper() + ' - ECG - ' +
'Corrections')
else:
# XXX : to check when EEG only is processed
print('no ECG channel is present. Cannot automate ICAs component '
'detection for ECG!')
# EOG
pick_eog = mne.pick_types(raw.info, meg=False, eeg=False,
ecg=False, eog=True)
eog_inds = list()
if pick_eog.any():
print('using EOG channel')
picks_eog = np.concatenate([picks, pick_eog])
# Create eog epochs
eog_epochs = create_eog_epochs(raw, picks=picks_eog, reject=None,
baseline=(None, 0), tmin=-0.5,
tmax=0.5)
eog_average = eog_epochs.average()
eog_inds, scores = ica.find_bads_eog(eog_epochs, threshold=config.ica_ctps_eog_threshold)
del eog_epochs
params = dict(exclude=eog_inds, show=config.plot)
# Plot r score
report.add_figs_to_section(ica.plot_scores(scores, **params),
captions=ch_type.upper() + ' - EOG - ' +
'R scores')
# Plot source time course
report.add_figs_to_section(ica.plot_sources(eog_average, **params),
captions=ch_type.upper() + ' - EOG - ' +
'Sources time course')
# Plot source time course
report.add_figs_to_section(ica.plot_overlay(eog_average, **params),
captions=ch_type.upper() + ' - EOG - ' +
'Corrections')
report.save(report_fname, overwrite=True, open_browser=False)
else:
print('no EOG channel is present. Cannot automate ICAs component '
'detection for EOG!')
ica_reject = (list(ecg_inds) + list(eog_inds) +
list(config.rejcomps_man[subject][ch_type]))
# now reject the components
print('Rejecting from %s: %s' % (ch_type, ica_reject))
epochs = ica.apply(epochs, exclude=ica_reject)
print('Saving cleaned epochs')
epochs.save(fname_out)
if report is not None:
fig = ica.plot_overlay(raw, exclude=ica_reject, show=config.plot)
report.add_figs_to_section(fig, captions=ch_type.upper() +
' - ALL(epochs) - Corrections')
if config.plot:
epochs.plot_image(combine='gfp', group_by='type', sigma=2.,
cmap="YlGnBu_r", show=config.plot)
def test_manual_report_2d(tmp_path, invisible_fig):
"""Simulate user manually creating report by adding one file at a time."""
from sklearn.exceptions import ConvergenceWarning
r = Report(title='My Report')
raw = read_raw_fif(raw_fname)
raw.pick_channels(raw.ch_names[:6]).crop(10, None)
raw.info.normalize_proj()
cov = read_cov(cov_fname)
cov = pick_channels_cov(cov, raw.ch_names)
events = read_events(events_fname)
event_id = {
'auditory/left': 1,
'auditory/right': 2,
'visual/left': 3,
'visual/right': 4,
'face': 5,
'buttonpress': 32
}
metadata, metadata_events, metadata_event_id = make_metadata(
events=events,
event_id=event_id,
tmin=-0.2,
tmax=0.5,
sfreq=raw.info['sfreq'])
epochs_without_metadata = Epochs(raw=raw,
events=events,
event_id=event_id,
baseline=None)
epochs_with_metadata = Epochs(raw=raw,
events=metadata_events,
event_id=metadata_event_id,
baseline=None,
metadata=metadata)
evokeds = read_evokeds(evoked_fname)
evoked = evokeds[0].pick('eeg')
with pytest.warns(ConvergenceWarning, match='did not converge'):
ica = (ICA(n_components=2, max_iter=1,
random_state=42).fit(inst=raw.copy().crop(tmax=1)))
ica_ecg_scores = ica_eog_scores = np.array([3, 0])
ica_ecg_evoked = ica_eog_evoked = epochs_without_metadata.average()
r.add_raw(raw=raw,
title='my raw data',
tags=('raw', ),
psd=True,
projs=False)
r.add_raw(raw=raw,
title='my raw data 2',
psd=False,
projs=False,
butterfly=1)
r.add_events(events=events_fname,
title='my events',
sfreq=raw.info['sfreq'])
r.add_epochs(epochs=epochs_without_metadata,
title='my epochs',
tags=('epochs', ),
psd=False,
projs=False)
r.add_epochs(epochs=epochs_without_metadata,
title='my epochs 2',
psd=1,
projs=False)
r.add_epochs(epochs=epochs_without_metadata,
title='my epochs 2',
psd=True,
projs=False)
assert 'Metadata' not in r.html[-1]
# Try with metadata
r.add_epochs(epochs=epochs_with_metadata,
title='my epochs with metadata',
psd=False,
projs=False)
assert 'Metadata' in r.html[-1]
with pytest.raises(ValueError,
match='requested to calculate PSD on a duration'):
r.add_epochs(epochs=epochs_with_metadata,
title='my epochs 2',
psd=100000000,
projs=False)
r.add_evokeds(evokeds=evoked,
noise_cov=cov_fname,
titles=['my evoked 1'],
tags=('evoked', ),
projs=False,
n_time_points=2)
r.add_projs(info=raw_fname,
projs=ecg_proj_fname,
title='my proj',
tags=('ssp', 'ecg'))
r.add_ica(ica=ica, title='my ica', inst=None)
with pytest.raises(RuntimeError, match='not preloaded'):
r.add_ica(ica=ica, title='ica', inst=raw)
r.add_ica(ica=ica,
title='my ica with inst',
inst=raw.copy().load_data(),
picks=[0],
ecg_evoked=ica_ecg_evoked,
eog_evoked=ica_eog_evoked,
ecg_scores=ica_ecg_scores,
eog_scores=ica_eog_scores)
r.add_covariance(cov=cov, info=raw_fname, title='my cov')
r.add_forward(forward=fwd_fname,
title='my forward',
subject='sample',
subjects_dir=subjects_dir)
r.add_html(html='<strong>Hello</strong>', title='Bold')
r.add_code(code=__file__, title='my code')
r.add_sys_info(title='my sysinfo')
# drop locations (only EEG channels in `evoked`)
evoked_no_ch_locs = evoked.copy()
for ch in evoked_no_ch_locs.info['chs']:
ch['loc'][:3] = np.nan
with pytest.warns(
RuntimeWarning,
match='No EEG channel locations found, cannot create joint plot'):
r.add_evokeds(evokeds=evoked_no_ch_locs,
titles=['evoked no chan locs'],
tags=('evoked', ),
projs=False,
n_time_points=1)
assert 'Time course' not in r._content[-1].html
assert 'Topographies' not in r._content[-1].html
assert evoked.info['projs'] # only then the following test makes sense
assert 'Projectors' not in r._content[-1].html
assert 'Global field power' in r._content[-1].html
# Drop locations from Info used for projs
info_no_ch_locs = raw.info.copy()
for ch in info_no_ch_locs['chs']:
ch['loc'][:3] = np.nan
with pytest.raises(ValueError,
match='does not contain.*channel locations'):
r.add_projs(info=info_no_ch_locs, title='Projs no chan locs')
# Drop locations from ICA
ica_no_ch_locs = ica.copy()
for ch in ica_no_ch_locs.info['chs']:
ch['loc'][:3] = np.nan
with pytest.warns(RuntimeWarning,
match='No Magnetometers channel locations'):
r.add_ica(ica=ica_no_ch_locs,
picks=[0],
inst=raw.copy().load_data(),
title='ICA')
assert 'ICA component properties' not in r._content[-1].html
assert 'ICA component topographies' not in r._content[-1].html
assert 'Original and cleaned signal' in r._content[-1].html
fname = op.join(tmp_path, 'report.html')
r.save(fname=fname, open_browser=False)
def test_manual_report_3d(tmp_path, renderer):
"""Simulate adding 3D sections."""
r = Report(title='My Report')
info = read_info(raw_fname)
with info._unlock():
dig, info['dig'] = info['dig'], []
add_kwargs = dict(trans=trans_fname,
info=info,
subject='sample',
subjects_dir=subjects_dir)
with pytest.warns(RuntimeWarning, match='could not be calculated'):
r.add_trans(title='coreg no dig', **add_kwargs)
with info._unlock():
info['dig'] = dig
# TODO: We should probably speed this up. We could expose an arg to allow
# use of sparse rather than dense head, and also possibly an arg to specify
# which views to actually show. Both of these could probably be useful to
# end-users, too.
r.add_trans(title='my coreg', **add_kwargs)
r.add_bem(subject='sample',
subjects_dir=subjects_dir,
title='my bem',
decim=100)
r.add_inverse_operator(inverse_operator=inv_fname,
title='my inverse',
subject='sample',
subjects_dir=subjects_dir,
trans=trans_fname)
r.add_stc(
stc=stc_fname,
title='my stc',
subject='sample',
subjects_dir=subjects_dir,
n_time_points=2,
stc_plot_kwargs=stc_plot_kwargs,
)
fname = op.join(tmp_path, 'report.html')
r.save(fname=fname, open_browser=False)
print "Can't find any file !"
finally:
os.chdir(os.getcwd())
###############################################################################
############################# APPLY MAXFILTER ################################
###############################################################################
# Define reference run for Maxfilter : all subjects the same.
refrun_path = findRefrun(data_raw_directory)
for nip in nips:
# Open html report
report = Report()
nip_path = data_raw_directory + nip + '/'
# Cycle across file
for raw_file_path in glob.glob(nip_path + '*'):
# Verbose
print '---------------------------------------------------------------'
print 'Subject ' + nip
print('File n° ' +
str(glob.glob(nip_path + '*').index(raw_file_path) + 1) + '/' +
str(len(glob.glob(nip_path + '*'))))
#######################################################################
############################### Load raw ##############################
#######################################################################
def test_render_report(renderer_pyvistaqt, tmp_path, invisible_fig):
"""Test rendering *.fif files for mne report."""
tempdir = str(tmp_path)
raw_fname_new = op.join(tempdir, 'temp_raw.fif')
raw_fname_new_bids = op.join(tempdir, 'temp_meg.fif')
ms_fname_new = op.join(tempdir, 'temp_ms_raw.fif')
event_fname_new = op.join(tempdir, 'temp_raw-eve.fif')
cov_fname_new = op.join(tempdir, 'temp_raw-cov.fif')
proj_fname_new = op.join(tempdir, 'temp_ecg-proj.fif')
fwd_fname_new = op.join(tempdir, 'temp_raw-fwd.fif')
inv_fname_new = op.join(tempdir, 'temp_raw-inv.fif')
nirs_fname_new = op.join(tempdir, 'temp_raw-nirs.snirf')
for a, b in [[raw_fname, raw_fname_new], [raw_fname, raw_fname_new_bids],
[ms_fname, ms_fname_new], [events_fname, event_fname_new],
[cov_fname, cov_fname_new], [ecg_proj_fname, proj_fname_new],
[fwd_fname, fwd_fname_new], [inv_fname, inv_fname_new],
[nirs_fname, nirs_fname_new]]:
shutil.copyfile(a, b)
# create and add -epo.fif and -ave.fif files
epochs_fname = op.join(tempdir, 'temp-epo.fif')
evoked_fname = op.join(tempdir, 'temp-ave.fif')
# Speed it up by picking channels
raw = read_raw_fif(raw_fname_new)
raw.pick_channels(['MEG 0111', 'MEG 0121', 'EEG 001', 'EEG 002'])
raw.del_proj()
raw.set_eeg_reference(projection=True).load_data()
epochs = Epochs(raw, read_events(events_fname), 1, -0.2, 0.2)
epochs.save(epochs_fname, overwrite=True)
# This can take forever, so let's make it fast
# Also, make sure crop range is wide enough to avoid rendering bug
evoked = epochs.average()
with pytest.warns(RuntimeWarning, match='tmax is not in Evoked'):
evoked.crop(0.1, 0.2)
evoked.save(evoked_fname)
report = Report(info_fname=raw_fname_new,
subjects_dir=subjects_dir,
projs=False,
image_format='png')
with pytest.warns(RuntimeWarning, match='Cannot render MRI'):
report.parse_folder(data_path=tempdir,
on_error='raise',
n_time_points_evokeds=2,
raw_butterfly=False,
stc_plot_kwargs=stc_plot_kwargs,
topomap_kwargs=topomap_kwargs)
assert repr(report)
# Check correct paths and filenames
fnames = glob.glob(op.join(tempdir, '*.fif'))
fnames.extend(glob.glob(op.join(tempdir, '*.snirf')))
titles = [op.basename(x) for x in fnames if not x.endswith('-ave.fif')]
titles.append(f'{op.basename(evoked_fname)}: {evoked.comment}')
_, _, content_titles, _ = report._content_as_html()
for title in titles:
assert title in content_titles
assert (''.join(report.html).find(title) != -1)
assert len(content_titles) == len(fnames)
# Check saving functionality
report.data_path = tempdir
fname = op.join(tempdir, 'report.html')
report.save(fname=fname, open_browser=False)
assert (op.isfile(fname))
html = Path(fname).read_text(encoding='utf-8')
# Evoked in `evoked_fname`
assert f'{op.basename(evoked_fname)}: {evoked.comment}' in html
assert 'Topographies' in html
assert 'Global field power' in html
# Check saving same report to new filename
report.save(fname=op.join(tempdir, 'report2.html'), open_browser=False)
assert (op.isfile(op.join(tempdir, 'report2.html')))
# Check overwriting file
report.save(fname=op.join(tempdir, 'report.html'),
open_browser=False,
overwrite=True)
assert (op.isfile(op.join(tempdir, 'report.html')))
# Check pattern matching with multiple patterns
pattern = ['*proj.fif', '*eve.fif']
with pytest.warns(RuntimeWarning, match='Cannot render MRI'):
report.parse_folder(data_path=tempdir,
pattern=pattern,
raw_butterfly=False)
assert (repr(report))
fnames = glob.glob(op.join(tempdir, '*.raw')) + \
glob.glob(op.join(tempdir, '*.raw'))
content_names = [element.name for element in report._content]
for fname in fnames:
assert (op.basename(fname) in [op.basename(x) for x in content_names])
assert (''.join(report.html).find(op.basename(fname)) != -1)
with pytest.raises(ValueError, match='Invalid value'):
Report(image_format='foo')
with pytest.raises(ValueError, match='Invalid value'):
Report(image_format=None)
# ndarray support smoke test
report.add_figure(fig=np.zeros((2, 3, 3)), title='title')
with pytest.raises(TypeError, match='It seems you passed a path'):
report.add_figure(fig='foo', title='title')
with pytest.raises(TypeError, match='.*MNEQtBrowser.*Figure3D.*got.*'):
report.add_figure(fig=1., title='title')
def run_evoked(subject):
print("Processing subject: %s" % subject)
meg_subject_dir = op.join(config.meg_dir, subject)
# load epochs to reject ICA components
extension = '-epo'
fname_in = op.join(meg_subject_dir, config.base_fname.format(**locals()))
epochs = mne.read_epochs(fname_in, preload=True)
extension = 'cleaned-epo'
fname_out = op.join(meg_subject_dir, config.base_fname.format(**locals()))
print("Input: ", fname_in)
print("Output: ", fname_out)
# load first run of raw data for ecg /eog epochs
raw_list = list()
print(" Loading one run from raw data")
extension = config.runs[0] + '_sss_raw'
raw_fname_in = op.join(meg_subject_dir,
config.base_fname.format(**locals()))
raw = mne.io.read_raw_fif(raw_fname_in, preload=True)
# run ICA on MEG and EEG
picks_meg = mne.pick_types(raw.info,
meg=True,
eeg=False,
eog=False,
stim=False,
exclude='bads')
picks_eeg = mne.pick_types(raw.info,
meg=False,
eeg=True,
eog=False,
stim=False,
exclude='bads')
all_picks = {'meg': picks_meg, 'eeg': picks_eeg}
if config.eeg:
ch_types = ['meg', 'eeg']
else:
ch_types = ['meg']
for ch_type in ch_types:
print(ch_type)
picks = all_picks[ch_type]
# Load ICA
fname_ica = op.join(
meg_subject_dir,
'{0}_{1}_{2}-ica.fif'.format(subject, config.study_name, ch_type))
print('Reading ICA: ' + fname_ica)
ica = read_ica(fname=fname_ica)
pick_ecg = mne.pick_types(raw.info,
meg=False,
eeg=False,
ecg=True,
eog=False)
# ECG
# either needs an ecg channel, or avg of the mags (i.e. MEG data)
if pick_ecg or ch_type == 'meg':
picks_ecg = np.concatenate([picks, pick_ecg])
# Create ecg epochs
if ch_type == 'meg':
reject = {
'mag': config.reject['mag'],
'grad': config.reject['grad']
}
elif ch_type == 'eeg':
reject = {'eeg': config.reject['eeg']}
ecg_epochs = create_ecg_epochs(raw,
picks=picks_ecg,
reject=reject,
baseline=(None, 0),
tmin=-0.5,
tmax=0.5)
ecg_average = ecg_epochs.average()
# XXX I had to lower the threshold for ctps (default 0.25), otherwise it does not
# find any components
# check how this behaves on other data
ecg_inds, scores = ica.find_bads_ecg(ecg_epochs,
method='ctps',
threshold=0.1)
del ecg_epochs
report_name = op.join(
meg_subject_dir,
'{0}_{1}_{2}-reject_ica.html'.format(subject,
config.study_name,
ch_type))
report = Report(report_name, verbose=False)
# Plot r score
report.add_figs_to_section(ica.plot_scores(scores,
exclude=ecg_inds),
captions=ch_type.upper() + ' - ECG - ' +
'R scores')
# Plot source time course
report.add_figs_to_section(ica.plot_sources(ecg_average,
exclude=ecg_inds),
captions=ch_type.upper() + ' - ECG - ' +
'Sources time course')
# Plot source time course
report.add_figs_to_section(ica.plot_overlay(ecg_average,
exclude=ecg_inds),
captions=ch_type.upper() + ' - ECG - ' +
'Corrections')
else:
print('no ECG channel!')
# EOG
pick_eog = mne.pick_types(raw.info,
meg=False,
eeg=False,
ecg=False,
eog=True)
if pick_eog.any():
print('using EOG channel')
picks_eog = np.concatenate([picks, pick_eog])
# Create eog epochs
eog_epochs = create_eog_epochs(raw,
picks=picks_eog,
reject=None,
baseline=(None, 0),
tmin=-0.5,
tmax=0.5)
eog_average = eog_epochs.average()
eog_inds, scores = ica.find_bads_eog(eog_epochs, threshold=3.0)
del eog_epochs
# Plot r score
report.add_figs_to_section(ica.plot_scores(scores,
exclude=eog_inds),
captions=ch_type.upper() + ' - EOG - ' +
'R scores')
# Plot source time course
report.add_figs_to_section(ica.plot_sources(eog_average,
exclude=eog_inds),
captions=ch_type.upper() + ' - EOG - ' +
'Sources time course')
# Plot source time course
report.add_figs_to_section(ica.plot_overlay(eog_average,
exclude=eog_inds),
captions=ch_type.upper() + ' - EOG - ' +
'Corrections')
report.save(report_name, overwrite=True, open_browser=False)
else:
print('no EOG channel!')
ica_reject = (list(ecg_inds) + list(eog_inds) +
list(config.rejcomps_man[subject][ch_type]))
# now reject the components
print('Rejecting from ' + ch_type + ': ' + str(ica_reject))
epochs = ica.apply(epochs, exclude=ica_reject)
print('Saving epochs')
epochs.save(fname_out)
report.add_figs_to_section(ica.plot_overlay(raw.copy(),
exclude=ica_reject),
captions=ch_type.upper() +
' - ALL(epochs) - ' + 'Corrections')
if config.plot:
epochs.plot_image(combine='gfp',
group_by='type',
sigma=2.,
cmap="YlGnBu_r")
def _generate_report(raw, ica, subj_name, basename, ecg_evoked, ecg_scores,
ecg_inds, ecg_ch_name, eog_evoked, eog_scores, eog_inds,
eog_ch_name):
"""Generate report for ica solution."""
import matplotlib.pyplot as plt
report = Report()
ica_title = 'Sources related to %s artifacts (red)'
is_show = False
# ------------------- Generate report for ECG ------------------------ #
fig_ecg_scores = ica.plot_scores(ecg_scores,
exclude=ecg_inds,
title=ica_title % 'ecg',
show=is_show)
# Pick the five largest ecg_scores and plot them
show_picks = np.abs(ecg_scores).argsort()[::-1][:5]
# Plot estimated latent sources given the unmixing matrix.
fig_ecg_ts = ica.plot_sources(raw,
show_picks,
exclude=ecg_inds,
title=ica_title % 'ecg' + ' in 30s',
start=0,
stop=30,
show=is_show)
# topoplot of unmixing matrix columns
fig_ecg_comp = ica.plot_components(show_picks,
title=ica_title % 'ecg',
colorbar=True,
show=is_show)
# plot ECG sources + selection
fig_ecg_src = ica.plot_sources(ecg_evoked, exclude=ecg_inds, show=is_show)
fig = [fig_ecg_scores, fig_ecg_ts, fig_ecg_comp, fig_ecg_src]
report.add_figs_to_section(fig,
captions=[
'Scores of ICs related to ECG',
'Time Series plots of ICs (ECG)',
'TopoMap of ICs (ECG)',
'Time-locked ECG sources'
],
section='ICA - ECG')
# -------------------- end generate report for ECG ---------------------- #
# -------------------------- Generate report for EoG -------------------- #
# check how many EoG ch we have
if set(eog_ch_name.split(',')).issubset(set(raw.info['ch_names'])):
fig_eog_scores = ica.plot_scores(eog_scores,
exclude=eog_inds,
title=ica_title % 'eog',
show=is_show)
report.add_figs_to_section(fig_eog_scores,
captions=['Scores of ICs related to EOG'],
section='ICA - EOG')
n_eogs = np.shape(eog_scores)
if len(n_eogs) > 1:
n_eog0 = n_eogs[0]
show_picks = [
np.abs(eog_scores[i][:]).argsort()[::-1][:5]
for i in range(n_eog0)
]
for i in range(n_eog0):
fig_eog_comp = ica.plot_components(show_picks[i][:],
title=ica_title % 'eog',
colorbar=True,
show=is_show)
fig = [fig_eog_comp]
report.add_figs_to_section(fig,
captions=['Scores of EoG ICs'],
section='ICA - EOG')
else:
show_picks = np.abs(eog_scores).argsort()[::-1][:5]
fig_eog_comp = ica.plot_components(show_picks,
title=ica_title % 'eog',
colorbar=True,
show=is_show)
fig = [fig_eog_comp]
report.add_figs_to_section(fig,
captions=['TopoMap of ICs (EOG)'],
section='ICA - EOG')
fig_eog_src = ica.plot_sources(eog_evoked,
exclude=eog_inds,
show=is_show)
fig = [fig_eog_src]
report.add_figs_to_section(fig,
captions=['Time-locked EOG sources'],
section='ICA - EOG')
# ----------------- end generate report for EoG ---------- #
ic_nums = list(range(ica.n_components_))
fig = ica.plot_components(picks=ic_nums, show=False)
report.add_figs_to_section(fig,
captions=['All IC topographies'],
section='ICA - muscles')
fig = ica.plot_sources(raw,
start=0,
stop=None,
show=False,
title='All IC time series')
report.add_figs_to_section(fig,
captions=['All IC time series'],
section='ICA - muscles')
psds_fig = []
captions_psd = []
ica_src = ica.get_sources(raw)
for i_ic in ic_nums:
psds, freqs = psd_multitaper(ica_src, picks=i_ic, fmax=140, tmax=60)
psds = np.squeeze(psds)
f, ax = plt.subplots()
psds = 10 * np.log10(psds)
ax.plot(freqs, psds, color='k')
ax.set(title='PSD',
xlabel='Frequency',
ylabel='Power Spectral Density (dB)')
psds_fig.append(f)
captions_psd.append('IC #' + str(i_ic))
report.add_figs_to_section(figs=psds_fig,
captions=captions_psd,
section='ICA - muscles')
report_filename = os.path.join(basename + "-report.html")
print(('******* ' + report_filename))
report.save(report_filename, open_browser=False, overwrite=True)
return report_filename
new_dist = np.mean(model.point_distance)
assert new_dist < avg_point_distance
if model.status_text.endswith('converged)'):
break
model.save_trans(trans_dst)
trans = mne.read_trans(trans_dst)
np.testing.assert_allclose(trans['trans'], model.head_mri_t)
if __name__ == '__main__':
mne.set_log_level(verbose=False)
subjects_dir = 'G:\OpenSource_data\CAM-CAN\\freesurfer_anat'
rest_dir = 'G:\OpenSource_data\CAM-CAN\cc700\mri\pipeline\\release004\BIDSsep\megmax_rest'
os.chdir(subjects_dir)
files = glob.glob('sub-CC*')
report = Report()
logFile = open('G:\OpenSource_data\CAM-CAN\cc700\mri\pipeline\\release004\BIDSsep\megmax_rest_reports\coregistration_logFile.txt','a')
for subject in tqdm(files):
native_fid = op.join('G:\OpenSource_data\CAM-CAN\cc700\mri\pipeline\\release004\\fiducials','fid-native-' + subject.replace("sub-","") +'.mat')
raw_path = op.join(rest_dir, subject, 'meg\\transdef_mf2pt2_rest_raw.fif')
clean_dir = op.join(rest_dir, subject, 'meg_clean')
if not os.path.exists(clean_dir):
os.makedirs(clean_dir)
raw_NosePtsOut = op.join(clean_dir,'nose-pts-out_raw.fif')
trans_dst = op.join(clean_dir,'_trans.fif')
if not os.path.exists(raw_path):
logFile.write("Subject " + subject + " doesn't have MEG data\n")
continue
def ICA_denoising_full(subject, runlist, badEEG):
import mne
import os.path as op
import os
import matplotlib
matplotlib.use('Agg')
from mne.report import Report
from mne.io import Raw
from meeg_preprocessing import compute_ica
from mne.io.pick import _picks_by_type as picks_by_type
###########################################################################
# jobs and runtime performance
n_components = 0.99
decim = 5 # decimation
n_max_ecg, n_max_eog = 5, 5 # limit components detected due to ECG / EOG
ica_reject = {'mag': 5e-12, 'grad': 5000e-13, 'eeg': 500e-6}
###########################################################################
data_path = '/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/'
raw_fnames = []
for run in runlist:
raw_fnames.append(data_path + subject + '/' + run + '_trans_sss.fif')
report = Report(subject)
# read raw data
raw = Raw(raw_fnames, preload=True)
raw.info['bads'] = badEEG
# Highpass filter 1Hz on EOG/ECG channels
picks = mne.pick_types(raw.info, meg=False, eeg=False, eog=False, ecg=True)
raw.filter(l_freq=1, h_freq=30, picks=picks)
picks = mne.pick_types(raw.info, meg=False, eeg=False, eog=True, ecg=False)
raw.filter(l_freq=1, h_freq=2, picks=picks)
picks = mne.pick_types(raw.info, meg=True, eeg=True, eog=True, ecg=True)
raw.filter(l_freq=None, h_freq=30, picks=picks, n_jobs=4)
###########################################################################
# Create the report directory if it doesn't exist
results_dir = op.join(data_path, subject, 'artefactICA')
if not op.exists(results_dir):
os.makedirs(results_dir)
# Create the results directory if it doesn't exist
ica_dir = op.join(data_path, subject, 'mne_python/ICA')
if not op.exists(ica_dir):
os.makedirs(ica_dir)
report = mne.report.Report(subject)
###########################################################################
for ch_type, picks in picks_by_type(
raw.info, meg_combined=True): # bad EEG channels are excluded
print 'loul'
ica, _ = compute_ica(raw,
picks=picks,
subject=subject,
n_components=n_components,
n_max_ecg=n_max_ecg,
n_max_eog=n_max_eog,
reject=ica_reject,
random_state=666,
decim=decim,
report=report)
# when pb with eeg
#ica = ICA(n_components=0.99, method='fastica')
#ica.fit(raw, picks=picks, decim=5, reject=dict(eeg=300e-6))
ica.save((ica_dir + '/ICA_' + ch_type + '_allRuns'))
report.save((results_dir + '/AllRuns.html'),
open_browser=False,
overwrite=True)
del raw
def test_render_report():
"""Test rendering -*.fif files for mne report."""
tempdir = _TempDir()
raw_fname_new = op.join(tempdir, 'temp_raw.fif')
event_fname_new = op.join(tempdir, 'temp_raw-eve.fif')
cov_fname_new = op.join(tempdir, 'temp_raw-cov.fif')
fwd_fname_new = op.join(tempdir, 'temp_raw-fwd.fif')
inv_fname_new = op.join(tempdir, 'temp_raw-inv.fif')
for a, b in [[raw_fname, raw_fname_new],
[event_fname, event_fname_new],
[cov_fname, cov_fname_new],
[fwd_fname, fwd_fname_new],
[inv_fname, inv_fname_new]]:
shutil.copyfile(a, b)
# create and add -epo.fif and -ave.fif files
epochs_fname = op.join(tempdir, 'temp-epo.fif')
evoked_fname = op.join(tempdir, 'temp-ave.fif')
# Speed it up by picking channels
raw = read_raw_fif(raw_fname_new, preload=True)
raw.pick_channels(['MEG 0111', 'MEG 0121'])
epochs = Epochs(raw, read_events(event_fname), 1, -0.2, 0.2)
epochs.save(epochs_fname)
# This can take forever (stall Travis), so let's make it fast
# Also, make sure crop range is wide enough to avoid rendering bug
epochs.average().crop(0.1, 0.2).save(evoked_fname)
report = Report(info_fname=raw_fname_new, subjects_dir=subjects_dir)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
report.parse_folder(data_path=tempdir, on_error='raise')
assert_true(len(w) >= 1)
assert_true(repr(report))
# Check correct paths and filenames
fnames = glob.glob(op.join(tempdir, '*.fif'))
for fname in fnames:
assert_true(op.basename(fname) in
[op.basename(x) for x in report.fnames])
assert_true(''.join(report.html).find(op.basename(fname)) != -1)
assert_equal(len(report.fnames), len(fnames))
assert_equal(len(report.html), len(report.fnames))
assert_equal(len(report.fnames), len(report))
# Check saving functionality
report.data_path = tempdir
report.save(fname=op.join(tempdir, 'report.html'), open_browser=False)
assert_true(op.isfile(op.join(tempdir, 'report.html')))
assert_equal(len(report.html), len(fnames))
assert_equal(len(report.html), len(report.fnames))
# Check saving same report to new filename
report.save(fname=op.join(tempdir, 'report2.html'), open_browser=False)
assert_true(op.isfile(op.join(tempdir, 'report2.html')))
# Check overwriting file
report.save(fname=op.join(tempdir, 'report.html'), open_browser=False,
overwrite=True)
assert_true(op.isfile(op.join(tempdir, 'report.html')))
# Check pattern matching with multiple patterns
pattern = ['*raw.fif', '*eve.fif']
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
report.parse_folder(data_path=tempdir, pattern=pattern)
assert_true(len(w) >= 1)
assert_true(repr(report))
fnames = glob.glob(op.join(tempdir, '*.raw')) + \
glob.glob(op.join(tempdir, '*.raw'))
for fname in fnames:
assert_true(op.basename(fname) in
[op.basename(x) for x in report.fnames])
assert_true(''.join(report.html).find(op.basename(fname)) != -1)
assert_raises(ValueError, Report, image_format='foo')
assert_raises(ValueError, Report, image_format=None)
# SVG rendering
report = Report(info_fname=raw_fname_new, subjects_dir=subjects_dir,
image_format='svg')
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
report.parse_folder(data_path=tempdir, on_error='raise')
def run():
"""Run command."""
from mne.commands.utils import get_optparser
parser = get_optparser(__file__)
parser.add_option("-p",
"--path",
dest="path",
help="Path to folder who MNE-Report must be created")
parser.add_option("-i",
"--info",
dest="info_fname",
help="File from which info dictionary is to be read",
metavar="FILE")
parser.add_option("-c",
"--cov",
dest="cov_fname",
help="File from which noise covariance is to be read",
metavar="FILE")
parser.add_option("--bmin",
dest="bmin",
help="Time at which baseline correction starts for "
"evokeds",
default=None)
parser.add_option("--bmax",
dest="bmax",
help="Time at which baseline correction stops for "
"evokeds",
default=None)
parser.add_option("-d",
"--subjects-dir",
dest="subjects_dir",
help="The subjects directory")
parser.add_option("-s",
"--subject",
dest="subject",
help="The subject name")
parser.add_option("--no-browser",
dest="no_browser",
action='store_false',
help="Do not open MNE-Report in browser")
parser.add_option("--overwrite",
dest="overwrite",
action='store_false',
help="Overwrite html report if it already exists")
parser.add_option("-j",
"--jobs",
dest="n_jobs",
help="Number of jobs to"
" run in parallel")
parser.add_option("-m",
"--mri-decim",
type="int",
dest="mri_decim",
default=2,
help="Integer factor used to decimate "
"BEM plots")
parser.add_option("--image-format",
type="str",
dest="image_format",
default='png',
help="Image format to use "
"(can be 'png' or 'svg')")
parser.add_option("-v",
"--verbose",
dest="verbose",
action='store_true',
help="run in verbose mode")
options, args = parser.parse_args()
path = options.path
if path is None:
parser.print_help()
sys.exit(1)
info_fname = options.info_fname
cov_fname = options.cov_fname
subjects_dir = options.subjects_dir
subject = options.subject
image_format = options.image_format
mri_decim = int(options.mri_decim)
verbose = True if options.verbose is not None else False
open_browser = False if options.no_browser is not None else True
overwrite = True if options.overwrite is not None else False
n_jobs = int(options.n_jobs) if options.n_jobs is not None else 1
bmin = float(options.bmin) if options.bmin is not None else None
bmax = float(options.bmax) if options.bmax is not None else None
# XXX: this means (None, None) cannot be specified through command line
if bmin is None and bmax is None:
baseline = None
else:
baseline = (bmin, bmax)
t0 = time.time()
report = Report(info_fname,
subjects_dir=subjects_dir,
subject=subject,
baseline=baseline,
cov_fname=cov_fname,
verbose=verbose,
image_format=image_format)
report.parse_folder(path,
verbose=verbose,
n_jobs=n_jobs,
mri_decim=mri_decim)
log_elapsed(time.time() - t0, verbose=verbose)
report.save(open_browser=open_browser, overwrite=overwrite)
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_render_add_sections():
"""Test adding figures/images to section."""
from PIL import Image
tempdir = _TempDir()
import matplotlib.pyplot as plt
report = Report(subjects_dir=subjects_dir)
# Check add_figs_to_section functionality
fig = plt.plot([1, 2], [1, 2])[0].figure
report.add_figs_to_section(
figs=fig, # test non-list input
captions=['evoked response'],
scale=1.2,
image_format='svg')
assert_raises(ValueError,
report.add_figs_to_section,
figs=[fig, fig],
captions='H')
assert_raises(ValueError,
report.add_figs_to_section,
figs=fig,
captions=['foo'],
scale=0,
image_format='svg')
assert_raises(ValueError,
report.add_figs_to_section,
figs=fig,
captions=['foo'],
scale=1e-10,
image_format='svg')
# need to recreate because calls above change size
fig = plt.plot([1, 2], [1, 2])[0].figure
# Check add_images_to_section with png and then gif
img_fname = op.join(tempdir, 'testimage.png')
fig.savefig(img_fname)
report.add_images_to_section(fnames=[img_fname],
captions=['evoked response'])
im = Image.open(img_fname)
op.join(tempdir, 'testimage.gif')
im.save(img_fname) # matplotlib does not support gif
report.add_images_to_section(fnames=[img_fname],
captions=['evoked response'])
assert_raises(ValueError,
report.add_images_to_section,
fnames=[img_fname, img_fname],
captions='H')
assert_raises(ValueError,
report.add_images_to_section,
fnames=['foobar.xxx'],
captions='H')
evoked = read_evokeds(evoked_fname,
condition='Left Auditory',
baseline=(-0.2, 0.0))
fig = plot_alignment(evoked.info,
trans_fname,
subject='sample',
subjects_dir=subjects_dir)
report.add_figs_to_section(
figs=fig, # test non-list input
captions='random image',
scale=1.2)
assert_true(repr(report))
data_ica_directory = returnICADirectory()
# NIPs of subjects
nips = returnNips()
nips = ['Mb160304']
# ICA parameters
n_components, method, decim, random_state = returnICAParameters()
# Bad EEG channels
bad_EEG = returnBadEEG()
# Rejection limits
reject = returnRejectLimits()
# Open html report
report = Report('ICA Processing', verbose=False)
###############################################################################
############################### ICA PER SUBJECT ###############################
###############################################################################
for nip in nips:
nip_path = data_sss_directory + nip + '/'
# Load raw (problem with MISC005 not present)
for filePath in glob.glob(nip_path + '*sss_raw.fif'):
temp = mne.io.Raw(filePath, preload=True, add_eeg_ref=False)
if 'MISC005' in temp.ch_names and nip in ['vV100048', 'Pb160320']:
temp.drop_channels(['MISC005'])
if not 'raw' in locals():
def test_report_raw_psd_and_date(tmpdir):
"""Test report raw PSD and DATE_NONE functionality."""
with pytest.raises(TypeError, match='dict'):
Report(raw_psd='foo')
tempdir = str(tmpdir)
raw = read_raw_fif(raw_fname).crop(0, 1.).load_data()
raw_fname_new = op.join(tempdir, 'temp_raw.fif')
raw.save(raw_fname_new)
report = Report(raw_psd=True)
report.parse_folder(data_path=tempdir, render_bem=False, on_error='raise')
assert isinstance(report.html, list)
assert 'PSD' in ''.join(report.html)
assert 'GMT' in ''.join(report.html)
# test new anonymize functionality
report = Report()
raw.anonymize()
raw.save(raw_fname_new, overwrite=True)
report.parse_folder(data_path=tempdir, render_bem=False, on_error='raise')
assert isinstance(report.html, list)
assert 'GMT' in ''.join(report.html)
# DATE_NONE functionality
report = Report()
# old style (pre 0.20) date anonymization
raw.info['meas_date'] = None
for key in ('file_id', 'meas_id'):
value = raw.info.get(key)
if value is not None:
assert 'msecs' not in value
value['secs'] = DATE_NONE[0]
value['usecs'] = DATE_NONE[1]
raw.save(raw_fname_new, overwrite=True)
report.parse_folder(data_path=tempdir, render_bem=False, on_error='raise')
assert isinstance(report.html, list)
assert 'GMT' not in ''.join(report.html)
from mne.report import Report
from mne.datasets import sample
from mne import read_evokeds
from matplotlib import pyplot as plt
data_path = sample.data_path()
meg_path = data_path + '/MEG/sample'
subjects_dir = data_path + '/subjects'
evoked_fname = meg_path + '/sample_audvis-ave.fif'
###############################################################################
# Do standard folder parsing (this can take a couple of minutes):
report = Report(image_format='png', subjects_dir=subjects_dir,
info_fname=evoked_fname, subject='sample', raw_psd=True)
report.parse_folder(meg_path)
###############################################################################
# Add a custom section with an evoked slider:
# Load the evoked data
evoked = read_evokeds(evoked_fname, condition='Left Auditory',
baseline=(None, 0), verbose=False)
evoked.crop(0, .2)
times = evoked.times[::4]
# Create a list of figs for the slider
figs = list()
for t in times:
figs.append(evoked.plot_topomap(t, vmin=-300, vmax=300, res=100,
show=False))
def run_ica(subject, tsss=config.mf_st_duration):
print("Processing subject: %s" % subject)
meg_subject_dir = op.join(config.meg_dir, subject)
raw_list = list()
events_list = list()
print(" Loading raw data")
for run in config.runs:
if config.use_maxwell_filter:
extension = run + '_sss_raw'
else:
extension = run + '_filt_raw'
raw_fname_in = op.join(meg_subject_dir,
config.base_fname.format(**locals()))
eve_fname = op.splitext(raw_fname_in)[0] + '-eve.fif'
print("Input: ", raw_fname_in, eve_fname)
raw = mne.io.read_raw_fif(raw_fname_in, preload=True)
events = mne.read_events(eve_fname)
events_list.append(events)
raw_list.append(raw)
print(' Concatenating runs')
raw, events = mne.concatenate_raws(raw_list, events_list=events_list)
if "eeg" in config.ch_types:
raw.set_eeg_reference(projection=True)
del raw_list
# don't reject based on EOG to keep blink artifacts
# in the ICA computation.
reject_ica = config.reject
if reject_ica and 'eog' in reject_ica:
reject_ica = dict(reject_ica)
del reject_ica['eog']
# produce high-pass filtered version of the data for ICA
raw_ica = raw.copy().filter(l_freq=1., h_freq=None)
print(" Running ICA...")
epochs_for_ica = mne.Epochs(raw_ica,
events,
config.event_id,
config.tmin,
config.tmax,
proj=True,
baseline=config.baseline,
preload=True,
decim=config.decim,
reject=reject_ica)
# run ICA on MEG and EEG
picks_meg = mne.pick_types(epochs_for_ica.info,
meg=True,
eeg=False,
eog=False,
stim=False,
exclude='bads')
picks_eeg = mne.pick_types(epochs_for_ica.info,
meg=False,
eeg=True,
eog=False,
stim=False,
exclude='bads')
all_picks = {'meg': picks_meg, 'eeg': picks_eeg}
# get number of components for ICA
# compute_rank requires 0.18
# n_components_meg = (mne.compute_rank(epochs_for_ica.copy()
# .pick_types(meg=True)))['meg']
n_components_meg = 0.999
n_components = {'meg': n_components_meg, 'eeg': 0.999}
ch_types = []
if 'eeg' in config.ch_types:
ch_types.append('eeg')
if set(config.ch_types).intersection(('meg', 'grad', 'mag')):
ch_types.append('meg')
for ch_type in ch_types:
print('Running ICA for ' + ch_type)
ica = ICA(method='fastica',
random_state=config.random_state,
n_components=n_components[ch_type])
picks = all_picks[ch_type]
ica.fit(epochs_for_ica, picks=picks, decim=config.ica_decim)
print(' Fit %d components (explaining at least %0.1f%% of the'
' variance)' % (ica.n_components_, 100 * n_components[ch_type]))
ica_fname = \
'{0}_{1}_{2}-ica.fif'.format(subject, config.study_name, ch_type)
ica_fname = op.join(meg_subject_dir, ica_fname)
ica.save(ica_fname)
if config.plot:
# plot ICA components to html report
report_fname = \
'{0}_{1}_{2}-ica.html'.format(subject, config.study_name,
ch_type)
report_fname = op.join(meg_subject_dir, report_fname)
report = Report(report_fname, verbose=False)
for idx in range(0, ica.n_components_):
figure = ica.plot_properties(epochs_for_ica,
picks=idx,
psd_args={'fmax': 60},
show=False)
report.add_figs_to_section(figure,
section=subject,
captions=(ch_type.upper() +
' - ICA Components'))
report.save(report_fname, overwrite=True, open_browser=False)
