def test_copyfile_eeglab(tmp_path, fname):
"""Test the copying of EEGlab set and fdt files."""
if (fname == 'test_raw_chanloc.set'
and _compare_version(testing.get_version(), '<', '0.112')):
return
bids_root = str(tmp_path)
data_path = op.join(testing.data_path(), 'EEGLAB')
raw_fname = op.join(data_path, fname)
new_name = op.join(bids_root, 'tested_conversion.set')
# IO error testing
with pytest.raises(ValueError, match="Need to move data with same ext"):
copyfile_eeglab(raw_fname, new_name + '.wrong')
# Test copying and reading
copyfile_eeglab(raw_fname, new_name)
if fname == 'test_raw_chanloc.set': # combined set+fdt
with pytest.warns(RuntimeWarning,
match="The data contains 'boundary' events"):
raw = mne.io.read_raw_eeglab(new_name)
assert 'Fp1' in raw.ch_names
else: # combined set+fdt and single set (new EEGLAB format)
raw = mne.io.read_raw_eeglab(new_name, preload=True)
assert 'EEG 001' in raw.ch_names
assert isinstance(raw, mne.io.BaseRaw)
def run():
"""Run the cp command."""
from mne.commands.utils import get_optparser
accepted_formats_msg = ('Accepted formats are BrainVision (.vhdr), '
'EEGLAB (.set), CTF (.ds).')
parser = get_optparser(__file__,
usage="usage: %prog -i INPUT -o OUTPUT",
prog_prefix='mne_bids',
version=mne_bids.__version__)
parser.add_option(
'-i',
'--input',
dest='input',
help=('Path to the input file. {}'.format(accepted_formats_msg)),
metavar='INPUT')
parser.add_option('-o',
'--output',
dest='output',
help=('Path to the output file. MUST be same format '
'as input file.'),
metavar='OUTPUT')
parser.add_option('-v',
'--verbose',
dest="verbose",
help='Set logging level to verbose',
action="store_true")
opt, args = parser.parse_args()
opt_dict = vars(opt)
# Check the usage and raise error if invalid
if len(args) > 0:
parser.print_help()
parser.error('Do not specify arguments without flags. Found: "{}".\n'
'Did you forget to provide -i and -o?'.format(args))
if not opt_dict.get('input') or not opt_dict.get('output'):
parser.print_help()
parser.error('Incorrect number of arguments. Supply one input and one '
'output file. You supplied: "{}"'.format(opt))
# Attempt to do the copying. Errors will be raised by the copyfile
# functions if there are issues with the file formats
if opt.input.endswith('.vhdr'):
copyfile_brainvision(opt.input, opt.output, opt.verbose)
elif opt.input.endswith('.set'):
copyfile_eeglab(opt.input, opt.output)
elif opt.input.endswith('.ds'):
copyfile_ctf(opt.input, opt.output)
else:
parser.error('{} You supplied: "{}"'.format(accepted_formats_msg, opt))
def test_copyfile_eeglab(tmpdir, fname):
"""Test the copying of EEGlab set and fdt files."""
if (fname == 'test_raw_chanloc.set' and
LooseVersion(testing.get_version()) < LooseVersion('0.112')):
return
bids_root = str(tmpdir)
data_path = op.join(testing.data_path(), 'EEGLAB')
raw_fname = op.join(data_path, fname)
new_name = op.join(bids_root, 'tested_conversion.set')
# IO error testing
with pytest.raises(ValueError, match="Need to move data with same ext"):
copyfile_eeglab(raw_fname, new_name + '.wrong')
# Bad .set file testing
with pytest.raises(ValueError, match='Could not find "EEG" field'):
fake_set = op.join(bids_root, 'fake.set')
savemat(fake_set, {'arr': [1, 2, 3]}, appendmat=False)
copyfile_eeglab(fake_set, new_name)
# Test copying and reading a combined set+fdt
copyfile_eeglab(raw_fname, new_name)
if fname == 'test_raw_chanloc.set':
with pytest.warns(RuntimeWarning,
match="The data contains 'boundary' events"):
raw = mne.io.read_raw_eeglab(new_name)
assert 'Fp1' in raw.ch_names
else:
raw = mne.io.read_raw_eeglab(new_name)
assert 'EEG 001' in raw.ch_names
assert isinstance(raw, mne.io.BaseRaw)
def test_copyfile_eeglab():
"""Test the copying of EEGlab set and fdt files."""
output_path = _TempDir()
data_path = op.join(testing.data_path(), 'EEGLAB')
raw_fname = op.join(data_path, 'test_raw.set')
new_name = op.join(output_path, 'tested_conversion.set')
# IO error testing
with pytest.raises(ValueError):
copyfile_eeglab(raw_fname, new_name + '.wrong')
# Bad .set file testing
with pytest.raises(ValueError):
tmp = _TempDir()
fake_set = op.join(tmp, 'fake.set')
savemat(fake_set, {'arr': [1, 2, 3]}, appendmat=False)
copyfile_eeglab(fake_set, new_name)
# Test copying and reading a combined set+fdt
copyfile_eeglab(raw_fname, new_name)
raw = mne.io.read_raw_eeglab(new_name)
assert isinstance(raw, mne.io.BaseRaw)
def write_raw_bids(raw, bids_basename, output_path, events_data=None,
event_id=None, overwrite=False, verbose=True):
"""Walk over a folder of files and create BIDS compatible folder.
.. warning:: The original files are simply copied over if the original
file format is BIDS-supported for that modality. Otherwise,
this function will convert to a BIDS-supported file format
while warning the user. For EEG and iEEG data, conversion will
be to BrainVision format, for MEG conversion will be to FIF.
Parameters
----------
raw : instance of mne.io.Raw
The raw data. It must be an instance of mne.Raw. The data should not be
loaded on disk, i.e., raw.preload must be False.
bids_basename : str
The base filename of the BIDS compatible files. Typically, this can be
generated using make_bids_basename.
Example: `sub-01_ses-01_task-testing_acq-01_run-01`.
This will write the following files in the correct subfolder of the
output_path::
sub-01_ses-01_task-testing_acq-01_run-01_meg.fif
sub-01_ses-01_task-testing_acq-01_run-01_meg.json
sub-01_ses-01_task-testing_acq-01_run-01_channels.tsv
sub-01_ses-01_task-testing_acq-01_run-01_coordsystem.json
and the following one if events_data is not None::
sub-01_ses-01_task-testing_acq-01_run-01_events.tsv
and add a line to the following files::
participants.tsv
scans.tsv
Note that the modality 'meg' is automatically inferred from the raw
object and extension '.fif' is copied from raw.filenames.
output_path : str
The path of the root of the BIDS compatible folder. The session and
subject specific folders will be populated automatically by parsing
bids_basename.
events_data : str | array | None
The events file. If a string, a path to the events file. If an array,
the MNE events array (shape n_events, 3). If None, events will be
inferred from the stim channel using `mne.find_events`.
event_id : dict | None
The event id dict used to create a 'trial_type' column in events.tsv
overwrite : bool
Whether to overwrite existing files or data in files.
Defaults to False.
If overwrite is True, any existing files with the same BIDS parameters
will be overwritten with the exception of the `participants.tsv` and
`scans.tsv` files. For these files, parts of pre-existing data that
match the current data will be replaced.
If overwrite is False, no existing data will be overwritten or
replaced.
verbose : bool
If verbose is True, this will print a snippet of the sidecar files. If
False, no content will be printed.
Returns
-------
output_path : str
The path of the root of the BIDS compatible folder.
Notes
-----
For the participants.tsv file, the raw.info['subjects_info'] should be
updated and raw.info['meas_date'] should not be None to compute the age
of the participant correctly.
"""
if not check_version('mne', '0.17'):
raise ValueError('Your version of MNE is too old. '
'Please update to 0.17 or newer.')
if not isinstance(raw, BaseRaw):
raise ValueError('raw_file must be an instance of BaseRaw, '
'got %s' % type(raw))
if not hasattr(raw, 'filenames') or raw.filenames[0] is None:
raise ValueError('raw.filenames is missing. Please set raw.filenames'
'as a list with the full path of original raw file.')
if raw.preload is not False:
raise ValueError('The data should not be preloaded.')
raw = raw.copy()
raw_fname = raw.filenames[0]
if '.ds' in op.dirname(raw.filenames[0]):
raw_fname = op.dirname(raw.filenames[0])
# point to file containing header info for multifile systems
raw_fname = raw_fname.replace('.eeg', '.vhdr')
raw_fname = raw_fname.replace('.fdt', '.set')
_, ext = _parse_ext(raw_fname, verbose=verbose)
raw_orig = reader[ext](**raw._init_kwargs)
assert_array_equal(raw.times, raw_orig.times,
"raw.times should not have changed since reading"
" in from the file. It may have been cropped.")
params = _parse_bids_filename(bids_basename, verbose)
subject_id, session_id = params['sub'], params['ses']
acquisition, task, run = params['acq'], params['task'], params['run']
kind = _handle_kind(raw)
bids_fname = bids_basename + '_%s%s' % (kind, ext)
# check whether the info provided indicates that the data is emptyroom
# data
emptyroom = False
if subject_id == 'emptyroom' and task == 'noise':
emptyroom = True
# check the session date provided is consistent with the value in raw
meas_date = raw.info.get('meas_date', None)
if meas_date is not None:
er_date = datetime.fromtimestamp(
raw.info['meas_date'][0]).strftime('%Y%m%d')
if er_date != session_id:
raise ValueError("Date provided for session doesn't match "
"session date.")
data_path = make_bids_folders(subject=subject_id, session=session_id,
kind=kind, output_path=output_path,
overwrite=False, verbose=verbose)
if session_id is None:
ses_path = os.sep.join(data_path.split(os.sep)[:-1])
else:
ses_path = make_bids_folders(subject=subject_id, session=session_id,
output_path=output_path, make_dir=False,
overwrite=False, verbose=verbose)
# create filenames
scans_fname = make_bids_basename(
subject=subject_id, session=session_id, suffix='scans.tsv',
prefix=ses_path)
participants_tsv_fname = make_bids_basename(prefix=output_path,
suffix='participants.tsv')
participants_json_fname = make_bids_basename(prefix=output_path,
suffix='participants.json')
coordsystem_fname = make_bids_basename(
subject=subject_id, session=session_id, acquisition=acquisition,
suffix='coordsystem.json', prefix=data_path)
sidecar_fname = make_bids_basename(
subject=subject_id, session=session_id, task=task, run=run,
acquisition=acquisition, suffix='%s.json' % kind, prefix=data_path)
events_fname = make_bids_basename(
subject=subject_id, session=session_id, task=task,
acquisition=acquisition, run=run, suffix='events.tsv',
prefix=data_path)
channels_fname = make_bids_basename(
subject=subject_id, session=session_id, task=task, run=run,
acquisition=acquisition, suffix='channels.tsv', prefix=data_path)
if ext not in ['.fif', '.ds', '.vhdr', '.edf', '.bdf', '.set', '.con',
'.sqd']:
bids_raw_folder = bids_fname.split('.')[0]
bids_fname = op.join(bids_raw_folder, bids_fname)
# Read in Raw object and extract metadata from Raw object if needed
orient = ORIENTATION.get(ext, 'n/a')
unit = UNITS.get(ext, 'n/a')
manufacturer = MANUFACTURERS.get(ext, 'n/a')
# save all meta data
_participants_tsv(raw, subject_id, participants_tsv_fname, overwrite,
verbose)
_participants_json(participants_json_fname, True, verbose)
_scans_tsv(raw, op.join(kind, bids_fname), scans_fname, overwrite, verbose)
# TODO: Implement coordystem.json and electrodes.tsv for EEG and iEEG
if kind == 'meg' and not emptyroom:
_coordsystem_json(raw, unit, orient, manufacturer, coordsystem_fname,
overwrite, verbose)
events, event_id = _read_events(events_data, event_id, raw, ext)
if events is not None and len(events) > 0 and not emptyroom:
_events_tsv(events, raw, events_fname, event_id, overwrite, verbose)
make_dataset_description(output_path, name=" ", verbose=verbose)
_sidecar_json(raw, task, manufacturer, sidecar_fname, kind, overwrite,
verbose)
_channels_tsv(raw, channels_fname, overwrite, verbose)
# set the raw file name to now be the absolute path to ensure the files
# are placed in the right location
bids_fname = op.join(data_path, bids_fname)
if os.path.exists(bids_fname) and not overwrite:
raise FileExistsError('"%s" already exists. Please set ' # noqa: F821
'overwrite to True.' % bids_fname)
_mkdir_p(os.path.dirname(bids_fname))
if verbose:
print('Copying data files to %s' % op.splitext(bids_fname)[0])
convert = ext not in ALLOWED_EXTENSIONS[kind]
# Copy the imaging data files
if convert:
if kind == 'meg':
raise ValueError('Got file extension %s for MEG data, ' +
'expected one of %s' % ALLOWED_EXTENSIONS['meg'])
if verbose:
warn('Converting data files to BrainVision format')
if not check_version('pybv', '0.2'):
raise ImportError('pybv >=0.2.0 is required for converting ' +
'%s files to Brainvision format' % ext)
from pybv import write_brainvision
events, event_id = events_from_annotations(raw)
write_brainvision(raw.get_data(), raw.info['sfreq'],
raw.ch_names,
op.splitext(op.basename(bids_fname))[0],
op.dirname(bids_fname), events[:, [0, 2]],
resolution=1e-6)
elif ext == '.fif':
n_rawfiles = len(raw.filenames)
if n_rawfiles > 1:
split_naming = 'bids'
raw.save(bids_fname, split_naming=split_naming, overwrite=True)
else:
# This ensures that single FIF files do not have the part param
raw.save(bids_fname, split_naming='neuromag', overwrite=True)
# CTF data is saved and renamed in a directory
elif ext == '.ds':
copyfile_ctf(raw_fname, bids_fname)
# BrainVision is multifile, copy over all of them and fix pointers
elif ext == '.vhdr':
copyfile_brainvision(raw_fname, bids_fname)
# EEGLAB .set might be accompanied by a .fdt - find out and copy it too
elif ext == '.set':
copyfile_eeglab(raw_fname, bids_fname)
elif ext == '.pdf':
copyfile_bti(raw_orig, op.join(data_path, bids_raw_folder))
else:
sh.copyfile(raw_fname, bids_fname)
# KIT data requires the marker file to be copied over too
if 'mrk' in raw._init_kwargs:
hpi = raw._init_kwargs['mrk']
acq_map = dict()
if isinstance(hpi, list):
if _get_mrk_meas_date(hpi[0]) > _get_mrk_meas_date(hpi[1]):
raise ValueError('Markers provided in incorrect order.')
_, marker_ext = _parse_ext(hpi[0])
acq_map = dict(zip(['pre', 'post'], hpi))
else:
_, marker_ext = _parse_ext(hpi)
acq_map[None] = hpi
for key, value in acq_map.items():
marker_fname = make_bids_basename(
subject=subject_id, session=session_id, task=task, run=run,
acquisition=key, suffix='markers%s' % marker_ext,
prefix=data_path)
sh.copyfile(value, marker_fname)
return output_path
