def test_ctf(_bids_validate):
"""Test functionality of the write_raw_bids conversion for CTF data."""
output_path = _TempDir()
data_path = op.join(testing.data_path(download=False), 'CTF')
raw_fname = op.join(data_path, 'testdata_ctf.ds')
raw = mne.io.read_raw_ctf(raw_fname)
with pytest.warns(UserWarning, match='No line frequency'):
write_raw_bids(raw, bids_basename, output_path=output_path)
_bids_validate(output_path)
with pytest.warns(UserWarning, match='Did not find any events'):
raw = read_raw_bids(bids_basename + '_meg.ds',
output_path,
extra_params=dict(clean_names=False))
# test to check that running again with overwrite == False raises an error
with pytest.raises(FileExistsError, match="already exists"): # noqa: F821
write_raw_bids(raw, bids_basename, output_path=output_path)
assert op.exists(op.join(output_path, 'participants.tsv'))
# test anonymize
raw = mne.io.read_raw_ctf(raw_fname)
with pytest.warns(UserWarning,
match='Converting to FIF for anonymization'):
output_path = _test_anonymize(raw, bids_basename)
_bids_validate(output_path)
# XXX: change the next two lines once raw.set_meas_date() is
# available.
raw.info['meas_date'] = None
raw.anonymize()
with pytest.raises(ValueError, match='All measurement dates are None'):
get_anonymization_daysback(raw)
def test_bdf(_bids_validate):
"""Test write_raw_bids conversion for Biosemi data."""
output_path = _TempDir()
data_path = op.join(base_path, 'edf', 'tests', 'data')
raw_fname = op.join(data_path, 'test.bdf')
raw = mne.io.read_raw_bdf(raw_fname)
with pytest.warns(UserWarning, match='No line frequency found'):
write_raw_bids(raw, bids_basename, output_path, overwrite=False)
_bids_validate(output_path)
# Test also the reading of channel types from channels.tsv
# the first channel in the raw data is not MISC right now
test_ch_idx = 0
assert coil_type(raw.info, test_ch_idx) != 'misc'
# we will change the channel type to MISC and overwrite the channels file
bids_fname = bids_basename + '_eeg.bdf'
channels_fname = _find_matching_sidecar(bids_fname, output_path,
'channels.tsv')
channels_dict = _from_tsv(channels_fname)
channels_dict['type'][test_ch_idx] = 'MISC'
_to_tsv(channels_dict, channels_fname)
# Now read the raw data back from BIDS, with the tampered TSV, to show
# that the channels.tsv truly influences how read_raw_bids sets ch_types
# in the raw data object
raw = read_raw_bids(bids_fname, output_path)
assert coil_type(raw.info, test_ch_idx) == 'misc'
# Test cropped assertion error
raw = mne.io.read_raw_bdf(raw_fname)
raw.crop(0, raw.times[-2])
with pytest.raises(AssertionError, match='cropped'):
write_raw_bids(raw, bids_basename, output_path)
def return_bids_test_dir(tmpdir_factory):
"""Return path to a written test BIDS dir."""
bids_root = str(tmpdir_factory.mktemp('mnebids_utils_test_bids_ds'))
data_path = testing.data_path()
raw_fname = op.join(data_path, 'MEG', 'sample',
'sample_audvis_trunc_raw.fif')
event_id = {
'Auditory/Left': 1,
'Auditory/Right': 2,
'Visual/Left': 3,
'Visual/Right': 4,
'Smiley': 5,
'Button': 32
}
events_fname = op.join(data_path, 'MEG', 'sample',
'sample_audvis_trunc_raw-eve.fif')
raw = mne.io.read_raw_fif(raw_fname)
# Write multiple runs for test_purposes
bids_basename2 = bids_basename.replace('run-{}'.format(run), 'run-02')
for name in [
bids_basename,
bids_basename2,
]:
with pytest.warns(UserWarning, match='No line frequency'):
write_raw_bids(raw,
name,
bids_root,
events_data=events_fname,
event_id=event_id,
overwrite=True)
return bids_root
def test_find_emptyroom_ties(tmpdir):
"""Test that we receive a warning on a date tie."""
data_path = testing.data_path()
raw_fname = op.join(data_path, 'MEG', 'sample',
'sample_audvis_trunc_raw.fif')
bids_root = str(tmpdir)
bids_path.update(root=bids_root)
session = '20010101'
er_dir_path = BIDSPath(subject='emptyroom', session=session,
datatype='meg', root=bids_root)
er_dir = er_dir_path.mkdir().directory
meas_date = (datetime
.strptime(session, '%Y%m%d')
.replace(tzinfo=timezone.utc))
raw = _read_raw_fif(raw_fname)
er_raw_fname = op.join(data_path, 'MEG', 'sample', 'ernoise_raw.fif')
raw.copy().crop(0, 10).save(er_raw_fname, overwrite=True)
er_raw = _read_raw_fif(er_raw_fname)
raw.set_meas_date(meas_date)
er_raw.set_meas_date(meas_date)
write_raw_bids(raw, bids_path, overwrite=True)
er_bids_path = BIDSPath(subject='emptyroom', session=session)
er_basename_1 = er_bids_path.basename
er_basename_2 = BIDSPath(subject='emptyroom', session=session,
task='noise').basename
er_raw.save(op.join(er_dir, f'{er_basename_1}_meg.fif'))
er_raw.save(op.join(er_dir, f'{er_basename_2}_meg.fif'))
with pytest.warns(RuntimeWarning, match='Found more than one'):
bids_path.find_empty_room()
def return_bids_test_dir(tmpdir_factory):
"""Return path to a written test BIDS dir."""
bids_root = str(tmpdir_factory.mktemp('mnebids_utils_test_bids_ds'))
data_path = testing.data_path()
raw_fname = op.join(data_path, 'MEG', 'sample',
'sample_audvis_trunc_raw.fif')
event_id = {
'Auditory/Left': 1,
'Auditory/Right': 2,
'Visual/Left': 3,
'Visual/Right': 4,
'Smiley': 5,
'Button': 32
}
events_fname = op.join(data_path, 'MEG', 'sample',
'sample_audvis_trunc_raw-eve.fif')
cal_fname = op.join(data_path, 'SSS', 'sss_cal_mgh.dat')
crosstalk_fname = op.join(data_path, 'SSS', 'ct_sparse.fif')
raw = mne.io.read_raw_fif(raw_fname)
raw.info['line_freq'] = 60
bids_path.update(root=bids_root)
# Write multiple runs for test_purposes
for run_idx in [run, '02']:
name = bids_path.copy().update(run=run_idx)
write_raw_bids(raw,
name,
events_data=events_fname,
event_id=event_id,
overwrite=True)
write_meg_calibration(cal_fname, bids_path=bids_path)
write_meg_crosstalk(crosstalk_fname, bids_path=bids_path)
return bids_root
def test_ctf():
"""Test functionality of the write_raw_bids conversion for CTF data."""
output_path = _TempDir()
data_path = op.join(testing.data_path(download=False), 'CTF')
raw_fname = op.join(data_path, 'testdata_ctf.ds')
raw = mne.io.read_raw_ctf(raw_fname)
folder = write_raw_bids(raw, bids_basename, output_path=output_path)
# XXX: hack to be removed once the empty file issue is solved in validator
# https://github.com/bids-standard/bids-validator/issues/651
for root, dirs, files in os.walk(folder):
for file in files:
fpath = op.join(root, file)
if os.stat(fpath).st_size == 0:
with open(fpath, 'w') as f:
f.write('***Empty-File-Filler***')
cmd = ['bids-validator', output_path]
run_subprocess(cmd, shell=shell)
# test to check that running again with overwrite == False raises an error
with pytest.raises(FileExistsError, match="already exists"):
write_raw_bids(raw, bids_basename, output_path=output_path)
assert op.exists(op.join(output_path, 'participants.tsv'))
def test_inspect(tmp_path):
"""Test mne_bids inspect."""
# Check that help is printed
check_usage(mne_bids_inspect)
# Create test dataset.
bids_root = str(tmp_path)
data_path = testing.data_path()
subject = '01'
task = 'test'
datatype = 'meg'
raw_fname = op.join(data_path, 'MEG', 'sample',
'sample_audvis_trunc_raw.fif')
raw = mne.io.read_raw(raw_fname)
raw.info['line_freq'] = 60.
bids_path = BIDSPath(subject=subject, task=task, datatype=datatype,
root=bids_root)
write_raw_bids(raw, bids_path, overwrite=True, verbose=False)
import matplotlib
matplotlib.use('agg')
h_freqs = (30.0, 30, '30')
for h_freq in h_freqs:
args = ('--bids_root', bids_root, '--h_freq', h_freq,
'--find_flat', 0)
with ArgvSetter(args):
mne_bids_inspect.run()
def test_bti(_bids_validate):
"""Test functionality of the write_raw_bids conversion for BTi data."""
output_path = _TempDir()
data_path = op.join(base_path, 'bti', 'tests', 'data')
raw_fname = op.join(data_path, 'test_pdf_linux')
config_fname = op.join(data_path, 'test_config_linux')
headshape_fname = op.join(data_path, 'test_hs_linux')
raw = mne.io.read_raw_bti(raw_fname,
config_fname=config_fname,
head_shape_fname=headshape_fname)
write_raw_bids(raw, bids_basename, output_path, verbose=True)
assert op.exists(op.join(output_path, 'participants.tsv'))
_bids_validate(output_path)
raw = read_raw_bids(bids_basename + '_meg', output_path)
with pytest.raises(TypeError, match="unexpected keyword argument 'foo'"):
read_raw_bids(bids_basename + '_meg',
output_path,
extra_params=dict(foo='bar'))
# test anonymize
raw = mne.io.read_raw_bti(raw_fname,
config_fname=config_fname,
head_shape_fname=headshape_fname)
with pytest.warns(UserWarning,
match='Converting to FIF for anonymization'):
output_path = _test_anonymize(raw, bids_basename)
_bids_validate(output_path)
def test_count_events(tmpdir):
"""Test mne_bids count_events."""
# Check that help is printed
check_usage(mne_bids_count_events)
# Create test dataset.
output_path = str(tmpdir)
data_path = testing.data_path()
raw_fname = op.join(data_path, 'MEG', 'sample',
'sample_audvis_trunc_raw.fif')
raw = mne.io.read_raw(raw_fname)
raw.info['line_freq'] = 60.
events = mne.find_events(raw)
event_id = {'auditory/left': 1, 'auditory/right': 2, 'visual/left': 3,
'visual/right': 4, 'face': 5, 'button': 32}
bids_path = BIDSPath(subject='01', root=output_path)
write_raw_bids(raw, bids_path, events, event_id, overwrite=True,
verbose=False)
with ArgvSetter(('--bids_root', output_path)):
mne_bids_count_events.run()
with ArgvSetter(('--bids_root', output_path, '--describe')):
mne_bids_count_events.run()
def test_find_emptyroom_no_meas_date(tmpdir):
"""Test that we warn if measurement date can be read or inferred."""
data_path = testing.data_path()
raw_fname = op.join(data_path, 'MEG', 'sample',
'sample_audvis_trunc_raw.fif')
bids_root = str(tmpdir)
bids_path.update(root=bids_root)
er_session = 'mysession'
er_meas_date = None
er_dir_path = BIDSPath(subject='emptyroom', session=er_session,
datatype='meg', root=bids_root)
er_dir = er_dir_path.mkdir().directory
er_bids_path = BIDSPath(subject='emptyroom', session=er_session,
task='noise', check=False)
er_basename = er_bids_path.basename
raw = _read_raw_fif(raw_fname)
er_raw_fname = op.join(data_path, 'MEG', 'sample', 'ernoise_raw.fif')
raw.copy().crop(0, 10).save(er_raw_fname, overwrite=True)
er_raw = _read_raw_fif(er_raw_fname)
er_raw.set_meas_date(er_meas_date)
er_raw.save(op.join(er_dir, f'{er_basename}_meg.fif'), overwrite=True)
# Write raw file data using mne-bids, and remove participants.tsv
# as it's incomplete (doesn't contain the emptyroom subject we wrote
# manually using MNE's Raw.save() above)
raw = _read_raw_fif(raw_fname)
write_raw_bids(raw, bids_path, overwrite=True)
os.remove(op.join(bids_root, 'participants.tsv'))
with pytest.warns(RuntimeWarning, match='Could not retrieve .* date'):
bids_path.find_empty_room()
def _make_dataset(subjects, tasks=(None, ), runs=(None, ), sessions=(None, )):
data_path = testing.data_path()
raw_fname = \
Path(data_path) / 'MEG' / 'sample' / 'sample_audvis_trunc_raw.fif'
raw = mne.io.read_raw(raw_fname)
raw.info['line_freq'] = 60.
root = _TempDir()
events = mne.find_events(raw)
event_id = {
'auditory/left': 1,
'auditory/right': 2,
'visual/left': 3,
'visual/right': 4,
'face': 5,
'button': 32
}
for subject, session, task, run in \
itertools.product(subjects, sessions, tasks, runs):
bids_path = BIDSPath(
subject=subject,
session=session,
run=run,
task=task,
root=root,
)
write_raw_bids(raw,
bids_path,
events,
event_id,
overwrite=True,
verbose=False)
return root, events, event_id
def test_vhdr(_bids_validate):
"""Test write_raw_bids conversion for BrainVision data."""
output_path = _TempDir()
data_path = op.join(base_path, 'brainvision', 'tests', 'data')
raw_fname = op.join(data_path, 'test.vhdr')
raw = mne.io.read_raw_brainvision(raw_fname)
# inject a bad channel
assert not raw.info['bads']
injected_bad = ['FP1']
raw.info['bads'] = injected_bad
# write with injected bad channels
write_raw_bids(raw, bids_basename_minimal, output_path, overwrite=False)
_bids_validate(output_path)
# read and also get the bad channels
raw = read_raw_bids(bids_basename_minimal + '_eeg.vhdr', output_path)
with pytest.raises(TypeError, match="unexpected keyword argument 'foo'"):
read_raw_bids(bids_basename_minimal + '_eeg.vhdr', output_path,
extra_params=dict(foo='bar'))
# Check that injected bad channel shows up in raw after reading
np.testing.assert_array_equal(np.asarray(raw.info['bads']),
np.asarray(injected_bad))
# Test that correct channel units are written ... and that bad channel
# is in channels.tsv
channels_tsv_name = op.join(output_path, 'sub-{}'.format(subject_id),
'eeg', bids_basename_minimal + '_channels.tsv')
data = _from_tsv(channels_tsv_name)
assert data['units'][data['name'].index('FP1')] == 'µV'
assert data['units'][data['name'].index('CP5')] == 'n/a'
assert data['status'][data['name'].index(injected_bad[0])] == 'bad'
# check events.tsv is written
events_tsv_fname = channels_tsv_name.replace('channels', 'events')
assert op.exists(events_tsv_fname)
# create another bids folder with the overwrite command and check
# no files are in the folder
data_path = make_bids_folders(subject=subject_id, kind='eeg',
output_path=output_path, overwrite=True)
assert len([f for f in os.listdir(data_path) if op.isfile(f)]) == 0
# test anonymize and convert
raw = mne.io.read_raw_brainvision(raw_fname)
_test_anonymize(raw, bids_basename)
# Also cover iEEG
# We use the same data and pretend that eeg channels are ecog
raw = mne.io.read_raw_brainvision(raw_fname)
raw.set_channel_types({raw.ch_names[i]: 'ecog'
for i in mne.pick_types(raw.info, eeg=True)})
output_path = _TempDir()
write_raw_bids(raw, bids_basename, output_path, overwrite=False)
_bids_validate(output_path)
def save_bids_data(raw, subject, bidsdir, figdir, ctfile, fcfile, behav_dir):
"""
Saves BIDS-structured data subject-wise
:param raw: raw fif data
:param subject: str, subject identifier
:param bidsdir: str, path to where a bids-conform output dir shall exist
:param figdir: str, path to diagnostic plot directory
:param ctfile: str, path to crosstalk file
:param fcfile: str, path to fine cal file
:return:
"""
bids_path = _get_BIDSPath(subject, bidsdir)
logging.info(f"Saving BIDS-compliant raw data from subject "
f"{subject} into "
f"{bids_path}")
# a workaround of https://github.com/mne-tools/mne-bids/issues/718
if subject in ["001", "005"]:
# these subjects can't be written directly - mne-bids would perform an
# internal check that fails on the basis that the hand-concatenated
# files are longer than the single split file that would be read-in
# automatically.
from tempfile import NamedTemporaryFile
with NamedTemporaryFile(suffix="_raw.fif", delete=False) as f:
fname = f.name
raw.save(fname, overwrite=True)
raw = mne.io.read_raw_fif(fname, preload=False)
# save raw fif data and events
# get log files, but don't yet write them out as the path doesn't exist yet
df = write_to_df(
participant=subject,
behav_dir=behav_dir,
bids_dir=bids_path.directory,
write_out=False,
)
events_data, event_dict = _events(raw, subject, figdir, df)
write_raw_bids(raw,
bids_path,
events_data=events_data,
event_id=event_dict,
overwrite=True)
# save crosstalk and calibration file
_elektas_extras(crosstalk_file=ctfile,
fine_cal_file=fcfile,
bids_path=bids_path)
# write out log files
df = write_to_df(
participant=subject,
behav_dir=behav_dir,
bids_dir=bids_path.directory,
write_out=True,
)
def mne_write_bids(filename, subject, bids_folder='/bids', task='rest'):
raw = mne.io.read_raw_brainvision(str(pathlib.Path(filename)))
print(raw.annotations)
raw.annotations.duration[raw.annotations.description ==
'DC Correction/'] = 6
events, event_id = mne.events_from_annotations(
raw) # this needs to be checked
write_raw_bids(raw,
make_bids_basename(subject=subject, task=task),
bids_folder,
overwrite=True)
def test_kit():
"""Test functionality of the write_raw_bids conversion for KIT data."""
output_path = _TempDir()
data_path = op.join(base_path, 'kit', 'tests', 'data')
raw_fname = op.join(data_path, 'test.sqd')
events_fname = op.join(data_path, 'test-eve.txt')
hpi_fname = op.join(data_path, 'test_mrk.sqd')
electrode_fname = op.join(data_path, 'test_elp.txt')
headshape_fname = op.join(data_path, 'test_hsp.txt')
event_id = dict(cond=1)
raw = mne.io.read_raw_kit(raw_fname,
mrk=hpi_fname,
elp=electrode_fname,
hsp=headshape_fname)
write_raw_bids(raw,
bids_basename,
output_path,
events_data=events_fname,
event_id=event_id,
overwrite=False)
cmd = ['bids-validator', output_path]
run_subprocess(cmd, shell=shell)
assert op.exists(op.join(output_path, 'participants.tsv'))
# ensure the channels file has no STI 014 channel:
channels_tsv = make_bids_basename(subject=subject_id,
session=session_id,
task=task,
run=run,
suffix='channels.tsv',
acquisition=acq,
prefix=op.join(output_path,
'sub-01/ses-01/meg'))
df = pd.read_csv(channels_tsv, sep='\t')
assert not ('STI 014' in df['name'].values)
# ensure the marker file is produced in the right place
raw_folder = make_bids_basename(subject=subject_id,
session=session_id,
task=task,
run=run,
acquisition=acq,
suffix='%s' % 'meg')
marker_fname = make_bids_basename(subject=subject_id,
session=session_id,
task=task,
run=run,
acquisition=acq,
suffix='markers.sqd',
prefix=os.path.join(
output_path, 'sub-01/ses-01/meg',
raw_folder))
assert op.exists(marker_fname)
def fif_to_bids(path: Path):
raw = mne.io.read_raw_fif(path)
bids_path = mne_bids.BIDSPath(
subject="01",
session="01",
task="testing",
acquisition="01",
run="01",
root=data_dir / "BIDS",
)
mne_bids.write_raw_bids(raw, bids_path, overwrite=True)
def _test_anonymize(raw, bids_basename, events_fname=None, event_id=None):
bids_root = _TempDir()
write_raw_bids(raw, bids_basename, bids_root,
events_data=events_fname,
event_id=event_id, anonymize=dict(daysback=33000),
overwrite=False)
scans_tsv = make_bids_basename(
subject=subject_id, session=session_id, suffix='scans.tsv',
prefix=op.join(bids_root, 'sub-01', 'ses-01'))
data = _from_tsv(scans_tsv)
if data['acq_time'] is not None and data['acq_time'][0] != 'n/a':
assert datetime.strptime(data['acq_time'][0],
'%Y-%m-%dT%H:%M:%S').year < 1925
return bids_root
def test_bdf():
"""Test write_raw_bids conversion for Biosemi data."""
output_path = _TempDir()
data_path = op.join(base_path, 'edf', 'tests', 'data')
raw_fname = op.join(data_path, 'test.bdf')
raw = mne.io.read_raw_edf(raw_fname)
write_raw_bids(raw, bids_basename, output_path, overwrite=False)
cmd = ['bids-validator', '--bep006', output_path]
run_subprocess(cmd, shell=shell)
raw.crop(0, raw.times[-2])
with pytest.raises(AssertionError, match='cropped'):
write_raw_bids(raw, bids_basename, output_path)
def test_set(_bids_validate):
"""Test write_raw_bids conversion for EEGLAB data."""
# standalone .set file
output_path = _TempDir()
data_path = op.join(testing.data_path(), 'EEGLAB')
# .set with associated .fdt
output_path = _TempDir()
data_path = op.join(testing.data_path(), 'EEGLAB')
raw_fname = op.join(data_path, 'test_raw.set')
raw = mne.io.read_raw_eeglab(raw_fname)
# embedded - test mne-version assertion
tmp_version = mne.__version__
mne.__version__ = '0.16'
with pytest.raises(ValueError, match='Your version of MNE is too old.'):
write_raw_bids(raw, bids_basename, output_path)
mne.__version__ = tmp_version
# proceed with the actual test for EEGLAB data
write_raw_bids(raw, bids_basename, output_path, overwrite=False)
read_raw_bids(bids_basename + '_eeg.set', output_path)
with pytest.raises(TypeError, match="unexpected keyword argument 'foo'"):
read_raw_bids(bids_basename + '_eeg.set',
output_path,
extra_params=dict(foo='bar'))
with pytest.raises(FileExistsError, match="already exists"): # noqa: F821
write_raw_bids(raw,
bids_basename,
output_path=output_path,
overwrite=False)
_bids_validate(output_path)
# check events.tsv is written
# XXX: only from 0.18 onwards because events_from_annotations
# is broken for earlier versions
events_tsv_fname = op.join(output_path, 'sub-' + subject_id,
'ses-' + session_id, 'eeg',
bids_basename + '_events.tsv')
if check_version('mne', '0.18'):
assert op.exists(events_tsv_fname)
# Also cover iEEG
# We use the same data and pretend that eeg channels are ecog
raw.set_channel_types(
{raw.ch_names[i]: 'ecog'
for i in mne.pick_types(raw.info, eeg=True)})
output_path = _TempDir()
write_raw_bids(raw, bids_basename, output_path)
_bids_validate(output_path)
# test anonymize and convert
if check_version('mne', '0.20') and check_version('pybv', '0.2.0'):
output_path = _test_anonymize(raw, bids_basename)
_bids_validate(output_path)
def _create_bidsrun(self, data_fpath):
"""
Create a BIDS Run if it does not exist.
Parameters
----------
data_fpath : str
A filepath to the dataset, and it will create a BIDS-like run using MNE_Bids.
"""
if pathlib.Path(data_fpath).suffix == ".fif":
raw = mne.io.read_raw_fif(data_fpath)
elif pathlib.Path(data_fpath).suffix == ".edf":
raw = mne.io.read_raw_edf(data_fpath)
else:
raise RuntimeError(
"Can't automatically create bids run using this extension. "
)
bids_basename = self.loader.datafile_fpath
bids_dir = self.bids_root
# copy over bids run to where it should be within the bids directory
output_path = mne_bids.write_raw_bids(
raw, bids_basename, output_path=bids_dir, overwrite=True, verbose=False
)
return output_path
def test_inspect_multiple_files(return_bids_test_dir):
import matplotlib
matplotlib.use('Agg')
bids_path = _bids_path.copy().update(root=return_bids_test_dir)
# Create a second subject
raw = read_raw_bids(bids_path=bids_path, verbose='error')
write_raw_bids(raw, bids_path.copy().update(subject='02'))
del raw
# Inspection should end with the second subject.
inspect_dataset(bids_path.copy().update(subject=None))
raw_fig = mne_bids.inspect._global_vars['raw_fig']
assert raw_fig.mne.info['subject_info']['participant_id'] == 'sub-02'
raw_fig.canvas.key_press_event(raw_fig.mne.close_key)
def test_count_no_events_file(tmpdir):
"""Test count_events with no event present."""
data_path = testing.data_path()
raw_fname = \
Path(data_path) / 'MEG' / 'sample' / 'sample_audvis_trunc_raw.fif'
raw = mne.io.read_raw(raw_fname)
raw.info['line_freq'] = 60.
root = str(tmpdir)
bids_path = BIDSPath(
subject='01', task='task1', root=root,
)
write_raw_bids(raw, bids_path, overwrite=True, verbose=False)
with pytest.raises(ValueError, match='No events files found.'):
count_events(root)
def test_bti():
"""Test functionality of the write_raw_bids conversion for BTi data."""
output_path = _TempDir()
data_path = op.join(base_path, 'bti', 'tests', 'data')
raw_fname = op.join(data_path, 'test_pdf_linux')
config_fname = op.join(data_path, 'test_config_linux')
headshape_fname = op.join(data_path, 'test_hs_linux')
raw = mne.io.read_raw_bti(raw_fname,
config_fname=config_fname,
head_shape_fname=headshape_fname)
write_raw_bids(raw, bids_basename, output_path, verbose=True)
assert op.exists(op.join(output_path, 'participants.tsv'))
cmd = ['bids-validator', output_path]
run_subprocess(cmd, shell=shell)
def write_BIDS():
# write Brainvision format
l_session_path = get_used_sessions()
for patient_idx, patient_l in enumerate(l_session_path):
for sess_idx, sess_path in enumerate(patient_l):
data, channel_names = read_raw_session(
l_session_path[patient_idx][sess_idx])
pybv.write_brainvision(data,
sfreq=1000,
ch_names=channel_names,
fname_base=str(sess_idx),
folder_out='BrainVision',
events=None,
resolution=1e-7,
scale_data=True,
fmt='binary_float32',
meas_date=None)
# BIDS Filename
if patient_idx < 10:
subject_id = str('00') + str(patient_idx)
else:
subject_id = str('0') + str(patient_idx)
raw = mne.io.read_raw_brainvision('BrainVision/' + str(sess_idx) +
'.vhdr')
run_ = sess_idx
print(str(subject_id))
if 'LEFT' in channel_names[0]:
laterality = 'left'
else:
laterality = 'right'
bids_basename = make_bids_basename(subject=str(subject_id),
session=laterality,
task='force',
run=str(run_))
# BIDS schreiben
output_path = '/Users/hi/Documents/workshop_ML/thesis_plots/BIDS_new/'
write_raw_bids(raw,
bids_basename,
output_path,
event_id=0,
overwrite=True)
def BrainSenseTimeDomain_to_bids(filename,
subject,
bids_folder='/bids',
task='BrainSenseTimeDomain'):
data = read_file(filename)
opath, fname, ext = tb.fileparts(filename)
if subject.find('-') > 0:
subject = subject[subject.find('-') + 1:]
session = data['SessionDate'][:-1].replace('-', '').replace(':', '')
basename = make_bids_basename(subject=subject, task=task, session=session)
bpath = make_bids_folders(subject=subject, session=session, make_dir=False)
sourcename = make_bids_basename(subject=subject, session=session)
raw = import_BrainSenseTimeDomain(filename)
if raw is not None:
rfig = raw.plot(color='k')
rfig.savefig(
pathlib.Path(bids_folder, bpath, 'eeg', 'sourcedata', 'figures',
basename + '.png'))
if os.path.exists('tmp.edf'):
os.remove('tmp.edf')
ephys.mne_write_edf(raw, 'tmp.edf')
raw = mne.io.read_raw_edf('tmp.edf')
write_raw_bids(raw,
bids_basename=basename,
output_path=bids_folder,
overwrite=True)
if not os.path.isdir(
pathlib.Path(bids_folder, bpath, 'eeg', 'sourcedata')):
os.makedirs(pathlib.Path(bids_folder, bpath, 'eeg', 'sourcedata'))
shutil.copyfile(
filename,
pathlib.Path(bids_folder, bpath, 'eeg', 'sourcedata',
basename + ext))
plot_wavelet_spectra(pathlib.Path(bids_folder, bpath, 'eeg',
'sourcedata', basename + ext),
typefield=task)
plot_BrainSenseLfp(
pathlib.Path(bids_folder, bpath, 'eeg', 'sourcedata',
basename + ext))
os.remove('tmp.edf')
shutil.move(
pathlib.Path(bids_folder, bpath, 'eeg', 'sourcedata',
basename + ext),
pathlib.Path(bids_folder, bpath, 'eeg', 'sourcedata',
sourcename + ext))
def test_bti(_bids_validate):
"""Test functionality of the write_raw_bids conversion for BTi data."""
output_path = _TempDir()
data_path = op.join(base_path, 'bti', 'tests', 'data')
raw_fname = op.join(data_path, 'test_pdf_linux')
config_fname = op.join(data_path, 'test_config_linux')
headshape_fname = op.join(data_path, 'test_hs_linux')
raw = mne.io.read_raw_bti(raw_fname,
config_fname=config_fname,
head_shape_fname=headshape_fname)
write_raw_bids(raw, bids_basename, output_path, verbose=True)
assert op.exists(op.join(output_path, 'participants.tsv'))
_bids_validate(output_path)
raw = read_raw_bids(bids_basename + '_meg', output_path)
def test_ctf(_bids_validate):
"""Test functionality of the write_raw_bids conversion for CTF data."""
output_path = _TempDir()
data_path = op.join(testing.data_path(download=False), 'CTF')
raw_fname = op.join(data_path, 'testdata_ctf.ds')
raw = mne.io.read_raw_ctf(raw_fname)
with pytest.warns(UserWarning, match='No line frequency'):
write_raw_bids(raw, bids_basename, output_path=output_path)
_bids_validate(output_path)
with pytest.warns(UserWarning, match='Did not find any events'):
raw = read_raw_bids(bids_basename + '_meg.ds', output_path)
# test to check that running again with overwrite == False raises an error
with pytest.raises(FileExistsError, match="already exists"): # noqa: F821
write_raw_bids(raw, bids_basename, output_path=output_path)
assert op.exists(op.join(output_path, 'participants.tsv'))
def test_inspect_multiple_files(tmp_path):
"""Test inspecting a dataset consisting of more than one file."""
import matplotlib
import matplotlib.pyplot as plt
matplotlib.use('Agg')
plt.close('all')
bids_root = setup_bids_test_dir(tmp_path)
bids_path = _bids_path.copy().update(root=bids_root)
# Create a second subject
raw = read_raw_bids(bids_path=bids_path, verbose='error')
write_raw_bids(raw, bids_path.copy().update(subject='02'))
del raw
# Inspection should end with the second subject.
inspect_dataset(bids_path.copy().update(subject=None))
raw_fig = mne_bids.inspect._global_vars['raw_fig']
assert raw_fig.mne.info['subject_info']['participant_id'] == 'sub-02'
raw_fig.canvas.key_press_event(raw_fig.mne.close_key)
def fieldtrip_to_BIDS(filename, BIDS_path, subject_id, session, task, run):
"""
Write BIDS entry from a fieldtrip format
The function has to temporarily save the output file as brainvision to set the filenames attribute in the mne RawArray
Args:
filename (string): .mat fieldtrip name
BIDS_path (string): BIDS_path
subject_id (string): BIDS subject id
session (string): BIDS session
task (string): BIDS session
run (string): BIDS session
"""
raw = mne.io.read_raw_fieldtrip(filename, None)
ieegdata = raw.get_data()
info = mne.create_info(raw.ch_names, raw.info['sfreq'], ch_types='ecog')
raw = mne.io.RawArray(ieegdata, info)
bids_basename = mne_bids.make_bids_basename(subject=subject_id,
session=session,
task=task,
run=run)
pybv.write_brainvision(raw.get_data(), raw.info['sfreq'], raw.ch_names,
'dummy_write', os.getcwd())
bv_raw = mne.io.read_raw_brainvision('dummy_write.vhdr')
# set all channel types to ECOG for iEEG - BIDS does not allow more than one channel type
mapping = {}
for ch in range(len(bv_raw.info['ch_names'])):
mapping[bv_raw.info['ch_names'][ch]] = 'ecog'
bv_raw.set_channel_types(mapping)
mne_bids.write_raw_bids(bv_raw, bids_basename, BIDS_path, overwrite=True)
# remove dummy file
os.remove('dummy_write.vhdr')
os.remove('dummy_write.eeg')
os.remove('dummy_write.vmrk')
def test_set():
"""Test write_raw_bids conversion for EEGLAB data."""
# standalone .set file
output_path = _TempDir()
data_path = op.join(testing.data_path(), 'EEGLAB')
# .set with associated .fdt
output_path = _TempDir()
data_path = op.join(testing.data_path(), 'EEGLAB')
raw_fname = op.join(data_path, 'test_raw.set')
raw = mne.io.read_raw_eeglab(raw_fname)
write_raw_bids(raw, bids_basename, output_path, overwrite=False)
with pytest.raises(FileExistsError, match="already exists"):
write_raw_bids(raw,
bids_basename,
output_path=output_path,
overwrite=False)
cmd = ['bids-validator', '--bep006', output_path]
run_subprocess(cmd, shell=shell)
# Also cover iEEG
# We use the same data and pretend that eeg channels are ecog
raw.set_channel_types(
{raw.ch_names[i]: 'ecog'
for i in mne.pick_types(raw.info, eeg=True)})
output_path = _TempDir()
write_raw_bids(raw, bids_basename, output_path)
cmd = ['bids-validator', '--bep010', output_path]
run_subprocess(cmd, shell=shell)
if elp_file is None:
sys.stderr.write('No _Points.txt file found in raw directory')
sys.exit(3)
if hsp_file is None:
sys.stderr.write('No _HS.txt file found in raw directory')
sys.exit(3)
stim_dir = os.path.join(bids_path, 'stimuli')
raws = mne_read_raw_kit(sqd_files, mrk_files[0], elp_file, hsp_file, subject=sub)
for ii in range(len(raws)):
bname = os.path.split(raws[ii].filenames[0])[1];
bname = '.'.join(bname.split('.')[:-1])
bdata = {kk[0]:kk[1] for pp in bname.split('_') for kk in [pp.split('-')] if len(kk) == 2}
mne_bids.write_raw_bids(raws[ii], bname, bids_path,
events_data=None, overwrite=True, verbose=False)
# since mne_bids doesn't correctly write out our events data...
pnm = mne_bids.make_bids_folders(subject=bdata['sub'], kind='meg', session=bdata['ses'],
make_dir=False, output_path=bids_path)
edata_in = os.path.join(meta_path, bname + '.tsv')
edata_out = os.path.join(pnm, bname + '_events.tsv')
edata = pandas.read_csv(edata_in, sep='\t')
ts = triggers(raws[ii])
wh = np.where(ts > 0)[0]
edata['onset'] = wh / 1000.0
edata.to_csv(edata_out, sep='\t', index=False)
# we need to make the stimulus directory also...
if not os.path.isdir(stim_dir): os.makedirs(stim_dir)
mdata_in = os.path.join(meta_path, bname + '.mat')
