def test_read_edf_extension_casing(tmp_path):
"""Test that EDF reading can occur with upper/lower-case extensions."""
bids_path = BIDSPath(subject=subject_id,
session=session_id,
run=run,
acquisition=acq,
task=task,
root=tmp_path,
extension='.EDF')
data_path = op.join(testing.data_path(), 'EDF')
raw_fname = op.join(data_path, 'test_reduced.edf')
raw = _read_raw_edf(raw_fname)
write_raw_bids(raw, bids_path, overwrite=True)
# obtain the sensor positions and assert ch_coords are same
read_raw_bids(bids_path, verbose=True)
def test_read_raw_datatype():
"""Test that read_raw_bids() can infer the str_suffix if need be."""
bids_root = _TempDir()
bids_path = _bids_path.copy().update(root=bids_root, datatype='meg')
raw = _read_raw_fif(raw_fname, verbose=False)
write_raw_bids(raw, bids_path, overwrite=True, verbose=False)
raw_1 = read_raw_bids(bids_path=bids_path)
bids_path.update(datatype=None)
raw_2 = read_raw_bids(bids_path=bids_path)
raw_3 = read_raw_bids(bids_path=bids_path)
raw_1.crop(0, 2).load_data()
raw_2.crop(0, 2).load_data()
raw_3.crop(0, 2).load_data()
assert raw_1 == raw_2
assert raw_1 == raw_3
def test_ignore_exclude_param(tmpdir):
"""Test that extra_params=dict(exclude=...) is being ignored."""
bids_path = _bids_path.copy().update(root=tmpdir)
ch_name = 'EEG 001'
raw = _read_raw_fif(raw_fname, verbose=False)
write_raw_bids(raw, bids_path=bids_path, overwrite=True, verbose=False)
raw = read_raw_bids(bids_path=bids_path, verbose=False,
extra_params=dict(exclude=[ch_name]))
assert ch_name in raw.ch_names
def test_handle_coords_reading():
"""Test reading coordinates from BIDS files."""
bids_root = _TempDir()
data_path = op.join(testing.data_path(), 'EDF')
raw_fname = op.join(data_path, 'test_reduced.edf')
raw = mne.io.read_raw_edf(raw_fname)
# ensure we are writing 'ecog'/'ieeg' data
raw.set_channel_types({ch: 'ecog' for ch in raw.ch_names})
# set a `random` montage
ch_names = raw.ch_names
elec_locs = np.random.random((len(ch_names), 3)).astype(float)
ch_pos = dict(zip(ch_names, elec_locs))
montage = mne.channels.make_dig_montage(ch_pos=ch_pos, coord_frame="mri")
raw.set_montage(montage)
write_raw_bids(raw, bids_basename, bids_root, overwrite=True)
# read in the data and assert montage is the same
bids_fname = bids_basename + "_ieeg.edf"
raw_test = read_raw_bids(bids_fname, bids_root)
# obtain the sensor positions
orig_locs = raw.info['dig'][1]
test_locs = raw_test.info['dig'][1]
assert orig_locs == test_locs
assert not object_diff(raw.info['chs'], raw_test.info['chs'])
# test error message if electrodes don't match
electrodes_fname = _find_matching_sidecar(bids_fname,
bids_root,
"electrodes.tsv",
allow_fail=True)
electrodes_dict = _from_tsv(electrodes_fname)
# pop off 5 channels
for key in electrodes_dict.keys():
for i in range(5):
electrodes_dict[key].pop()
_to_tsv(electrodes_dict, electrodes_fname)
with pytest.raises(RuntimeError, match='Channels do not correspond'):
raw_test = read_raw_bids(bids_fname, bids_root)
def test_handle_channel_type_casing(tmpdir):
"""Test that non-uppercase entries in the `type` column are accepted."""
bids_path = _bids_path.copy().update(root=tmpdir)
raw = _read_raw_fif(raw_fname, verbose=False)
write_raw_bids(raw, bids_path, overwrite=True, verbose=False)
ch_path = bids_path.copy().update(root=tmpdir,
datatype='meg',
suffix='channels',
extension='.tsv')
bids_channels_fname = ch_path.fpath
# Convert all channel type entries to lowercase.
channels_data = _from_tsv(bids_channels_fname)
channels_data['type'] = [t.lower() for t in channels_data['type']]
_to_tsv(channels_data, bids_channels_fname)
with pytest.warns(RuntimeWarning, match='lowercase spelling'):
read_raw_bids(bids_path)
def test_handle_scans_reading():
"""Test reading data from a BIDS scans.tsv file."""
bids_root = _TempDir()
raw = _read_raw_fif(raw_fname)
suffix = "meg"
# write copy of raw with line freq of 60
# bids basename and fname
bids_path = BIDSPath(subject='01',
session='01',
task='audiovisual',
run='01',
datatype=suffix,
root=bids_root)
bids_path = write_raw_bids(raw, bids_path, overwrite=True)
raw_01 = read_raw_bids(bids_path)
# find sidecar scans.tsv file and alter the
# acquisition time to not have the optional microseconds
scans_path = BIDSPath(subject=bids_path.subject,
session=bids_path.session,
root=bids_root,
suffix='scans',
extension='.tsv')
scans_tsv = _from_tsv(scans_path)
acq_time_str = scans_tsv['acq_time'][0]
acq_time = datetime.strptime(acq_time_str, '%Y-%m-%dT%H:%M:%S.%fZ')
acq_time = acq_time.replace(tzinfo=timezone.utc)
new_acq_time = acq_time_str.split('.')[0]
assert acq_time == raw_01.info['meas_date']
scans_tsv['acq_time'][0] = new_acq_time
_to_tsv(scans_tsv, scans_path)
# now re-load the data and it should be different
# from the original date and the same as the newly altered date
raw_02 = read_raw_bids(bids_path)
new_acq_time += '.0Z'
new_acq_time = datetime.strptime(new_acq_time, '%Y-%m-%dT%H:%M:%S.%fZ')
new_acq_time = new_acq_time.replace(tzinfo=timezone.utc)
assert raw_02.info['meas_date'] == new_acq_time
assert new_acq_time != raw_01.info['meas_date']
def test_read_raw_bids_pathlike():
"""Test that read_raw_bids() can handle a Path-like bids_root."""
bids_root = _TempDir()
raw = mne.io.read_raw_fif(raw_fname, verbose=False)
write_raw_bids(raw,
bids_basename,
bids_root,
overwrite=True,
verbose=False)
raw = read_raw_bids(bids_basename=bids_basename,
bids_root=Path(bids_root),
kind='meg')
def test_handle_chpi_reading(tmpdir):
"""Test reading of cHPI information."""
raw = _read_raw_fif(raw_fname_chpi, allow_maxshield=True)
root = tmpdir.mkdir('chpi')
bids_path = BIDSPath(subject='01',
session='01',
task='audiovisual',
run='01',
root=root,
datatype='meg')
bids_path = write_raw_bids(raw, bids_path)
raw_read = read_raw_bids(bids_path)
assert raw_read.info['hpi_subsystem'] is not None
# cause conflicts between cHPI info in sidecar and raw data
meg_json_path = bids_path.copy().update(suffix='meg', extension='.json')
with open(meg_json_path, 'r', encoding='utf-8') as f:
meg_json_data = json.load(f)
# cHPI frequency mismatch
meg_json_data_freq_mismatch = meg_json_data.copy()
meg_json_data_freq_mismatch['HeadCoilFrequency'][0] = 123
with open(meg_json_path, 'w', encoding='utf-8') as f:
json.dump(meg_json_data_freq_mismatch, f)
with pytest.raises(ValueError, match='cHPI coil frequencies'):
raw_read = read_raw_bids(bids_path)
# cHPI "off" according to sidecar, but present in the data
meg_json_data_chpi_mismatch = meg_json_data.copy()
meg_json_data_chpi_mismatch['ContinuousHeadLocalization'] = False
with open(meg_json_path, 'w', encoding='utf-8') as f:
json.dump(meg_json_data_chpi_mismatch, f)
raw_read = read_raw_bids(bids_path)
assert raw_read.info['hpi_subsystem'] is None
assert raw_read.info['hpi_meas'] == []
def test_read_raw_kind():
"""Test that read_raw_bids() can infer the kind if need be."""
bids_root = _TempDir()
raw = mne.io.read_raw_fif(raw_fname, verbose=False)
write_raw_bids(raw,
bids_basename,
bids_root,
overwrite=True,
verbose=False)
raw_1 = read_raw_bids(bids_basename=bids_basename,
bids_root=bids_root,
kind='meg')
raw_2 = read_raw_bids(bids_basename=bids_basename,
bids_root=bids_root,
kind=None)
raw_3 = read_raw_bids(bids_basename=bids_basename, bids_root=bids_root)
raw_1.crop(0, 2).load_data()
raw_2.crop(0, 2).load_data()
raw_3.crop(0, 2).load_data()
assert raw_1 == raw_2
assert raw_1 == raw_3
def test_channels_tsv_raw_mismatch(tmp_path):
"""Test behavior when channels.tsv contains channels not found in raw."""
bids_path = _bids_path.copy().update(root=tmp_path, datatype='meg',
task='rest')
# Remove one channel from the raw data without updating channels.tsv
raw = _read_raw_fif(raw_fname, verbose=False)
write_raw_bids(raw, bids_path=bids_path, overwrite=True, verbose=False)
raw_path = bids_path.copy().update(extension='.fif').fpath
raw = _read_raw(raw_path, preload=True)
raw.drop_channels(ch_names=raw.ch_names[-1])
raw.load_data()
raw.save(raw_path, overwrite=True)
with pytest.warns(
RuntimeWarning,
match='number of channels in the channels.tsv sidecar .* '
'does not match the number of channels in the raw data'
):
read_raw_bids(bids_path)
# Remame a channel in the raw data without updating channels.tsv
# (number of channels in channels.tsv and raw remains different)
ch_name_orig = raw.ch_names[-1]
ch_name_new = 'MEGtest'
raw.rename_channels({ch_name_orig: ch_name_new})
raw.save(raw_path, overwrite=True)
with pytest.warns(
RuntimeWarning,
match=f'Cannot set channel type for the following channels, as they '
f'are missing in the raw data: {ch_name_orig}'
):
read_raw_bids(bids_path)
# Mark channel as bad in channels.tsv and remove it from the raw data
raw = _read_raw_fif(raw_fname, verbose=False)
ch_name_orig = raw.ch_names[-1]
ch_name_new = 'MEGtest'
raw.info['bads'] = [ch_name_orig]
write_raw_bids(raw, bids_path=bids_path, overwrite=True, verbose=False)
raw.drop_channels(raw.ch_names[-2])
raw.rename_channels({ch_name_orig: ch_name_new})
raw.save(raw_path, overwrite=True)
with pytest.warns(
RuntimeWarning,
match=f'Cannot set "bad" status for the following channels, as '
f'they are missing in the raw data: {ch_name_orig}'
):
read_raw_bids(bids_path)
def test_bads_reading(tmpdir):
bids_path = _bids_path.copy().update(root=tmpdir, datatype='meg')
bads_raw = ['MEG 0112', 'MEG 0113']
bads_sidecar = ['EEG 053', 'MEG 2443']
# Produce conflicting information between raw and sidecar file.
raw = _read_raw_fif(raw_fname, verbose=False)
raw.info['bads'] = bads_sidecar
write_raw_bids(raw, bids_path, verbose=False)
raw = _read_raw(bids_path.copy().update(extension='.fif').fpath,
preload=True)
raw.info['bads'] = bads_raw
raw.save(raw.filenames[0], overwrite=True)
# Upon reading the data, only the sidecar info should be present.
raw = read_raw_bids(bids_path=bids_path, verbose=False)
assert len(raw.info['bads']) == len(bads_sidecar)
assert set(raw.info['bads']) == set(bads_sidecar)
def test_keep_essential_annotations(tmpdir):
"""Test that essential Annotations are not omitted during I/O roundtrip."""
raw = _read_raw_fif(raw_fname)
annotations = mne.Annotations(onset=[raw.times[0]], duration=[1],
description=['BAD_ACQ_SKIP'])
raw.set_annotations(annotations)
# Write data, remove events.tsv, then try to read again
bids_path = BIDSPath(subject='01', task='task', datatype='meg',
root=tmpdir)
with pytest.warns(RuntimeWarning, match='Acquisition skips detected'):
write_raw_bids(raw, bids_path, overwrite=True)
bids_path.copy().update(suffix='events', extension='.tsv').fpath.unlink()
raw_read = read_raw_bids(bids_path)
assert len(raw_read.annotations) == len(raw.annotations) == 1
assert (raw_read.annotations[0]['description'] ==
raw.annotations[0]['description'])
def test_read_participants_handedness_and_sex_mapping(hand_bids, hand_mne,
sex_bids, sex_mne):
"""Test we're correctly mapping handedness and sex between BIDS and MNE."""
bids_root = _TempDir()
bids_path = _bids_path.copy().update(root=bids_root, datatype='meg')
participants_tsv_fpath = op.join(bids_root, 'participants.tsv')
raw = _read_raw_fif(raw_fname, verbose=False)
# Avoid that we end up with subject information stored in the raw data.
raw.info['subject_info'] = {}
write_raw_bids(raw, bids_path, overwrite=True, verbose=False)
participants_tsv = _from_tsv(participants_tsv_fpath)
participants_tsv['hand'][0] = hand_bids
participants_tsv['sex'][0] = sex_bids
_to_tsv(participants_tsv, participants_tsv_fpath)
raw = read_raw_bids(bids_path=bids_path)
assert raw.info['subject_info']['hand'] is hand_mne
assert raw.info['subject_info']['sex'] is sex_mne
def load_data(self):
"""
Load raw data from BIDS folder
Allowing for a number of extensions, loads file
Parameters
----------
none
Returns
-------
raw MNE object
"""
# params = _parse_bids_filename(self.unique_name, verbose=False)
# if params['ses'] is None :
# bids_root = os.path.join(self.root_path,f"sub-{params['sub']}")
# else:
# bids_root = os.path.join(self.root_path,f"sub-{params['sub']}",f"ses-{params['ses']}")
# data_path = os.path.join(bids_root,self.unique_name)
bids_fname = self.unique_name + self.file_ext
data = read_raw_bids(bids_fname, self.root_path)
return data
def test_handle_ieeg_coords_reading(bids_basename):
"""Test reading iEEG coordinates from BIDS files."""
bids_root = _TempDir()
data_path = op.join(testing.data_path(), 'EDF')
raw_fname = op.join(data_path, 'test_reduced.edf')
bids_fname = bids_basename.copy().update(suffix='ieeg.edf')
raw = mne.io.read_raw_edf(raw_fname)
# ensure we are writing 'ecog'/'ieeg' data
raw.set_channel_types({ch: 'ecog' for ch in raw.ch_names})
# coordinate frames in mne-python should all map correctly
# set a `random` montage
ch_names = raw.ch_names
elec_locs = np.random.random((len(ch_names), 3)).astype(float)
ch_pos = dict(zip(ch_names, elec_locs))
coordinate_frames = ['mri', 'ras']
for coord_frame in coordinate_frames:
# XXX: mne-bids doesn't support multiple electrodes.tsv files
sh.rmtree(bids_root)
montage = mne.channels.make_dig_montage(ch_pos=ch_pos,
coord_frame=coord_frame)
raw.set_montage(montage)
write_raw_bids(raw,
bids_basename,
bids_root,
overwrite=True,
verbose=False)
# read in raw file w/ updated coordinate frame
# and make sure all digpoints are correct coordinate frames
raw_test = read_raw_bids(bids_basename=bids_basename,
bids_root=bids_root,
verbose=False)
coord_frame_int = MNE_STR_TO_FRAME[coord_frame]
for digpoint in raw_test.info['dig']:
assert digpoint['coord_frame'] == coord_frame_int
# start w/ new bids root
sh.rmtree(bids_root)
write_raw_bids(raw,
bids_basename,
bids_root,
overwrite=True,
verbose=False)
# obtain the sensor positions and assert ch_coords are same
raw_test = read_raw_bids(bids_basename=bids_basename,
bids_root=bids_root,
verbose=False)
orig_locs = raw.info['dig'][1]
test_locs = raw_test.info['dig'][1]
assert orig_locs == test_locs
assert not object_diff(raw.info['chs'], raw_test.info['chs'])
# read in the data and assert montage is the same
# regardless of 'm', 'cm', 'mm', or 'pixel'
scalings = {'m': 1, 'cm': 100, 'mm': 1000}
coordsystem_fname = _find_matching_sidecar(bids_fname,
bids_root,
suffix='coordsystem.json',
allow_fail=True)
electrodes_fname = _find_matching_sidecar(bids_fname,
bids_root,
"electrodes.tsv",
allow_fail=True)
orig_electrodes_dict = _from_tsv(electrodes_fname,
[str, float, float, float, str])
# not BIDS specified should not be read
coord_unit = 'km'
scaling = 0.001
_update_sidecar(coordsystem_fname, 'iEEGCoordinateUnits', coord_unit)
electrodes_dict = _from_tsv(electrodes_fname,
[str, float, float, float, str])
for axis in ['x', 'y', 'z']:
electrodes_dict[axis] = \
np.multiply(orig_electrodes_dict[axis], scaling)
_to_tsv(electrodes_dict, electrodes_fname)
with pytest.warns(RuntimeWarning,
match='Coordinate unit is not '
'an accepted BIDS unit'):
raw_test = read_raw_bids(bids_basename=bids_basename,
bids_root=bids_root,
verbose=False)
# correct BIDS units should scale to meters properly
for coord_unit, scaling in scalings.items():
# update coordinate SI units
_update_sidecar(coordsystem_fname, 'iEEGCoordinateUnits', coord_unit)
electrodes_dict = _from_tsv(electrodes_fname,
[str, float, float, float, str])
for axis in ['x', 'y', 'z']:
electrodes_dict[axis] = \
np.multiply(orig_electrodes_dict[axis], scaling)
_to_tsv(electrodes_dict, electrodes_fname)
# read in raw file w/ updated montage
raw_test = read_raw_bids(bids_basename=bids_basename,
bids_root=bids_root,
verbose=False)
# obtain the sensor positions and make sure they're the same
assert_dig_allclose(raw.info, raw_test.info)
# XXX: Improve by changing names to 'unknown' coordframe (needs mne PR)
# check that coordinate systems other coordinate systems should be named
# in the file and not the CoordinateSystem, which is reserved for keywords
coordinate_frames = ['lia', 'ria', 'lip', 'rip', 'las']
for coord_frame in coordinate_frames:
# update coordinate units
_update_sidecar(coordsystem_fname, 'iEEGCoordinateSystem', coord_frame)
# read in raw file w/ updated coordinate frame
# and make sure all digpoints are MRI coordinate frame
with pytest.warns(RuntimeWarning,
match="iEEG Coordinate frame is "
"not accepted BIDS keyword"):
raw_test = read_raw_bids(bids_basename=bids_basename,
bids_root=bids_root,
verbose=False)
assert raw_test.info['dig'] is None
# ACPC should be read in as RAS for iEEG
_update_sidecar(coordsystem_fname, 'iEEGCoordinateSystem', 'acpc')
raw_test = read_raw_bids(bids_basename=bids_basename,
bids_root=bids_root,
verbose=False)
coord_frame_int = MNE_STR_TO_FRAME['ras']
for digpoint in raw_test.info['dig']:
assert digpoint['coord_frame'] == coord_frame_int
# test error message if electrodes don't match
write_raw_bids(raw, bids_basename, bids_root, overwrite=True)
electrodes_dict = _from_tsv(electrodes_fname)
# pop off 5 channels
for key in electrodes_dict.keys():
for i in range(5):
electrodes_dict[key].pop()
_to_tsv(electrodes_dict, electrodes_fname)
with pytest.raises(RuntimeError, match='Channels do not correspond'):
raw_test = read_raw_bids(bids_basename=bids_basename,
bids_root=bids_root,
verbose=False)
# make sure montage is set if there are coordinates w/ 'n/a'
raw.info['bads'] = []
write_raw_bids(raw,
bids_basename,
bids_root,
overwrite=True,
verbose=False)
electrodes_dict = _from_tsv(electrodes_fname)
for axis in ['x', 'y', 'z']:
electrodes_dict[axis][0] = 'n/a'
electrodes_dict[axis][3] = 'n/a'
_to_tsv(electrodes_dict, electrodes_fname)
# test if montage is correctly set via mne-bids
# electrode coordinates should be nan
# when coordinate is 'n/a'
nan_chs = [electrodes_dict['name'][i] for i in [0, 3]]
with pytest.warns(RuntimeWarning,
match='There are channels '
'without locations'):
raw = read_raw_bids(bids_basename=bids_basename,
bids_root=bids_root,
verbose=False)
for idx, ch in enumerate(raw.info['chs']):
if ch['ch_name'] in nan_chs:
assert all(np.isnan(ch['loc'][:3]))
else:
assert not any(np.isnan(ch['loc'][:3]))
assert ch['ch_name'] not in raw.info['bads']
def test_handle_eeg_coords_reading():
"""Test reading iEEG coordinates from BIDS files."""
bids_root = _TempDir()
data_path = op.join(testing.data_path(), 'EDF')
raw_fname = op.join(data_path, 'test_reduced.edf')
raw = mne.io.read_raw_edf(raw_fname)
# ensure we are writing 'eeg' data
raw.set_channel_types({ch: 'eeg' for ch in raw.ch_names})
# set a `random` montage
ch_names = raw.ch_names
elec_locs = np.random.random((len(ch_names), 3)).astype(float)
ch_pos = dict(zip(ch_names, elec_locs))
# # create montage in 'unknown' coordinate frame
# # and assert coordsystem/electrodes sidecar tsv don't exist
montage = mne.channels.make_dig_montage(ch_pos=ch_pos,
coord_frame="unknown")
raw.set_montage(montage)
with pytest.warns(RuntimeWarning, match="Skipping EEG electrodes.tsv"):
write_raw_bids(raw, bids_basename, bids_root, overwrite=True)
coordsystem_fname = _find_matching_sidecar(bids_basename,
bids_root,
suffix='coordsystem.json',
allow_fail=True)
electrodes_fname = _find_matching_sidecar(bids_basename,
bids_root,
suffix="electrodes.tsv",
allow_fail=True)
assert coordsystem_fname is None
assert electrodes_fname is None
# create montage in head frame and set should result in
# warning if landmarks not set
montage = mne.channels.make_dig_montage(ch_pos=ch_pos, coord_frame="head")
raw.set_montage(montage)
with pytest.warns(RuntimeWarning,
match='Setting montage not possible '
'if anatomical landmarks'):
write_raw_bids(raw, bids_basename, bids_root, overwrite=True)
montage = mne.channels.make_dig_montage(ch_pos=ch_pos,
coord_frame="head",
nasion=[1, 0, 0],
lpa=[0, 1, 0],
rpa=[0, 0, 1])
raw.set_montage(montage)
write_raw_bids(raw, bids_basename, bids_root, overwrite=True)
# obtain the sensor positions and assert ch_coords are same
raw_test = read_raw_bids(bids_basename, bids_root, verbose=True)
assert not object_diff(raw.info['chs'], raw_test.info['chs'])
# modify coordinate frame to not-captrak
coordsystem_fname = _find_matching_sidecar(bids_basename,
bids_root,
suffix='coordsystem.json',
allow_fail=True)
_update_sidecar(coordsystem_fname, 'EEGCoordinateSystem', 'besa')
with pytest.warns(RuntimeWarning,
match='EEG Coordinate frame is not '
'accepted BIDS keyword'):
raw_test = read_raw_bids(bids_basename, bids_root)
assert raw_test.info['dig'] is None
def test_handle_info_reading():
"""Test reading information from a BIDS sidecar.json file."""
bids_root = _TempDir()
# read in USA dataset, so it should find 50 Hz
raw = mne.io.read_raw_fif(raw_fname)
raw.info['line_freq'] = 60
# write copy of raw with line freq of 60
# bids basename and fname
bids_basename = make_bids_basename(subject='01',
session='01',
task='audiovisual',
run='01')
kind = "meg"
bids_fname = bids_basename.copy().update(suffix=f'{kind}.fif')
write_raw_bids(raw, bids_basename, bids_root, overwrite=True)
# find sidecar JSON fname
sidecar_fname = _find_matching_sidecar(bids_fname,
bids_root,
'{}.json'.format(kind),
allow_fail=True)
# assert that we get the same line frequency set
raw = read_raw_bids(bids_basename=bids_basename,
bids_root=bids_root,
kind=kind)
assert raw.info['line_freq'] == 60
# 2. if line frequency is not set in raw file, then default to sidecar
raw.info['line_freq'] = None
write_raw_bids(raw, bids_basename, bids_root, overwrite=True)
_update_sidecar(sidecar_fname, "PowerLineFrequency", 55)
raw = read_raw_bids(bids_basename=bids_basename,
bids_root=bids_root,
kind=kind)
assert raw.info['line_freq'] == 55
# make a copy of the sidecar in "derivatives/"
# to check that we make sure we always get the right sidecar
# in addition, it should not break the sidecar reading
# in `read_raw_bids`
deriv_dir = op.join(bids_root, "derivatives")
sidecar_copy = op.join(deriv_dir, op.basename(sidecar_fname))
os.mkdir(deriv_dir)
with open(sidecar_fname, "r") as fin:
sidecar_json = json.load(fin)
sidecar_json["PowerLineFrequency"] = 45
_write_json(sidecar_copy, sidecar_json)
raw = read_raw_bids(bids_basename=bids_basename,
bids_root=bids_root,
kind=kind)
assert raw.info['line_freq'] == 55
# 3. if line frequency is set in raw file, but not sidecar
raw.info['line_freq'] = 60
write_raw_bids(raw, bids_basename, bids_root, overwrite=True)
_update_sidecar(sidecar_fname, "PowerLineFrequency", "n/a")
raw = read_raw_bids(bids_basename=bids_basename,
bids_root=bids_root,
kind=kind)
assert raw.info['line_freq'] == 60
# 4. assert that we get an error when sidecar json doesn't match
_update_sidecar(sidecar_fname, "PowerLineFrequency", 55)
with pytest.raises(ValueError, match="Line frequency in sidecar json"):
raw = read_raw_bids(bids_basename=bids_basename,
bids_root=bids_root,
kind=kind)
def test_handle_info_reading(tmpdir):
"""Test reading information from a BIDS sidecar.json file."""
# read in USA dataset, so it should find 50 Hz
raw = _read_raw_fif(raw_fname)
# write copy of raw with line freq of 60
# bids basename and fname
bids_path = BIDSPath(subject='01',
session='01',
task='audiovisual',
run='01',
root=tmpdir)
suffix = "meg"
bids_fname = bids_path.copy().update(suffix=suffix, extension='.fif')
write_raw_bids(raw, bids_path, overwrite=True)
# find sidecar JSON fname
bids_fname.update(datatype=suffix)
sidecar_fname = _find_matching_sidecar(bids_fname,
suffix=suffix,
extension='.json')
# assert that we get the same line frequency set
raw = read_raw_bids(bids_path=bids_path)
assert raw.info['line_freq'] == 60
# setting line_freq to None should produce 'n/a' in the JSON sidecar
raw.info['line_freq'] = None
write_raw_bids(raw, bids_path, overwrite=True)
raw = read_raw_bids(bids_path=bids_path)
assert raw.info['line_freq'] is None
with open(sidecar_fname, 'r', encoding='utf-8') as fin:
sidecar_json = json.load(fin)
assert sidecar_json["PowerLineFrequency"] == 'n/a'
# 2. if line frequency is not set in raw file, then ValueError
del raw.info['line_freq']
with pytest.raises(ValueError, match="PowerLineFrequency .* required"):
write_raw_bids(raw, bids_path, overwrite=True)
# make a copy of the sidecar in "derivatives/"
# to check that we make sure we always get the right sidecar
# in addition, it should not break the sidecar reading
# in `read_raw_bids`
raw.info['line_freq'] = 60
write_raw_bids(raw, bids_path, overwrite=True)
deriv_dir = tmpdir.mkdir("derivatives")
sidecar_copy = deriv_dir / op.basename(sidecar_fname)
with open(sidecar_fname, "r", encoding='utf-8') as fin:
sidecar_json = json.load(fin)
sidecar_json["PowerLineFrequency"] = 45
_write_json(sidecar_copy, sidecar_json)
raw = read_raw_bids(bids_path=bids_path)
assert raw.info['line_freq'] == 60
# 3. assert that we get an error when sidecar json doesn't match
_update_sidecar(sidecar_fname, "PowerLineFrequency", 55)
with pytest.raises(ValueError, match="Line frequency in sidecar json"):
raw = read_raw_bids(bids_path=bids_path)
assert raw.info['line_freq'] == 55
def test_read_raw_bids_pathlike(tmpdir):
"""Test that read_raw_bids() can handle a Path-like bids_root."""
bids_path = _bids_path.copy().update(root=tmpdir, datatype='meg')
raw = _read_raw_fif(raw_fname, verbose=False)
write_raw_bids(raw, bids_path, overwrite=True, verbose=False)
raw = read_raw_bids(bids_path=bids_path)
def test_write_read_fif_split_file(tmp_path, monkeypatch):
"""Test split files are read correctly."""
# load raw test file, extend it to be larger than 2gb, and save it
bids_root = tmp_path / 'bids'
tmp_dir = tmp_path / 'tmp'
tmp_dir.mkdir()
bids_path = _bids_path.copy().update(root=bids_root, datatype='meg')
raw = _read_raw_fif(raw_fname, verbose=False)
bids_path.update(acquisition=None)
write_raw_bids(raw, bids_path, verbose=False)
bids_path.update(acquisition='01')
n_channels = len(raw.ch_names)
n_times = int(2.5e6 / n_channels) # enough to produce a 10MB split
data = np.empty((n_channels, n_times), dtype=np.float32)
raw = mne.io.RawArray(data, raw.info)
big_fif_fname = pathlib.Path(tmp_dir) / 'test_raw.fif'
split_size = '10MB'
raw.save(big_fif_fname, split_size=split_size)
raw = _read_raw_fif(big_fif_fname, verbose=False)
with monkeypatch.context() as m: # Force MNE-BIDS to split at 10MB
m.setattr(mne_bids.write, '_FIFF_SPLIT_SIZE', split_size)
write_raw_bids(raw, bids_path, verbose=False)
# test whether split raw files were read correctly
raw1 = read_raw_bids(bids_path=bids_path)
assert 'split-01' in str(bids_path.fpath)
bids_path.update(split='01')
raw2 = read_raw_bids(bids_path=bids_path)
bids_path.update(split='02')
raw3 = read_raw_bids(bids_path=bids_path)
assert len(raw) == len(raw1)
assert len(raw) == len(raw2)
assert len(raw) > len(raw3)
# check that split files both appear in scans.tsv
scans_tsv = BIDSPath(
subject=subject_id, session=session_id,
suffix='scans', extension='.tsv',
root=bids_root)
scan_data = _from_tsv(scans_tsv)
scan_fnames = scan_data['filename']
scan_acqtime = scan_data['acq_time']
assert len(scan_fnames) == 3
assert 'split-01' in scan_fnames[0] and 'split-02' in scan_fnames[1]
# check that the acq_times in scans.tsv are the same
assert scan_acqtime[0] == scan_acqtime[1]
# check the recordings are in the correct order
assert raw2.first_time < raw3.first_time
# check whether non-matching acq_times are caught
scan_data['acq_time'][0] = scan_acqtime[0].split('.')[0]
_to_tsv(scan_data, scans_tsv)
with pytest.raises(ValueError,
match='Split files must have the same acq_time.'):
read_raw_bids(bids_path)
# reset scans.tsv file for downstream tests
scan_data['acq_time'][0] = scan_data['acq_time'][1]
_to_tsv(scan_data, scans_tsv)
def test_get_matched_empty_room():
"""Test reading of empty room data."""
bids_root = _TempDir()
raw = mne.io.read_raw_fif(raw_fname)
bids_basename = make_bids_basename(subject='01',
session='01',
task='audiovisual',
run='01')
write_raw_bids(raw, bids_basename, bids_root, overwrite=True)
er_basename = get_matched_empty_room(bids_basename=bids_basename,
bids_root=bids_root)
assert er_basename is None
# testing data has no noise recording, so save the actual data
# as if it were noise
er_raw_fname = op.join(data_path, 'MEG', 'sample', 'ernoise_raw.fif')
raw.crop(0, 10).save(er_raw_fname, overwrite=True)
er_raw = mne.io.read_raw_fif(er_raw_fname)
er_date = er_raw.info['meas_date']
if not isinstance(er_date, datetime):
# mne < v0.20
er_date = datetime.fromtimestamp(er_raw.info['meas_date'][0])
er_date = er_date.strftime('%Y%m%d')
er_bids_basename = make_bids_basename(subject='emptyroom',
task='noise',
session=er_date)
write_raw_bids(er_raw, er_bids_basename, bids_root, overwrite=True)
recovered_er_basename = get_matched_empty_room(bids_basename=bids_basename,
bids_root=bids_root)
assert er_bids_basename == recovered_er_basename
# assert that we get best emptyroom if there are multiple available
sh.rmtree(op.join(bids_root, 'sub-emptyroom'))
dates = ['20021204', '20021201', '20021001']
for date in dates:
er_bids_basename.update(session=date)
er_meas_date = datetime.strptime(date, '%Y%m%d')
er_meas_date = er_meas_date.replace(tzinfo=timezone.utc)
if check_version('mne', '0.20'):
er_raw.set_meas_date(er_meas_date)
else:
er_raw.info['meas_date'] = (er_meas_date.timestamp(), 0)
write_raw_bids(er_raw, er_bids_basename, bids_root)
best_er_basename = get_matched_empty_room(bids_basename=bids_basename,
bids_root=bids_root)
assert '20021204' in best_er_basename
# assert that we get error if meas_date is not available.
raw = read_raw_bids(bids_basename=bids_basename,
bids_root=bids_root,
kind='meg')
if check_version('mne', '0.20'):
raw.set_meas_date(None)
else:
raw.info['meas_date'] = None
raw.annotations.orig_time = None
anonymize_info(raw.info)
write_raw_bids(raw, bids_basename, bids_root, overwrite=True)
with pytest.raises(ValueError,
match='The provided recording does not '
'have a measurement date set'):
get_matched_empty_room(bids_basename=bids_basename,
bids_root=bids_root)
def test_bads_reading():
bids_root = _TempDir()
bids_path = _bids_path.copy().update(root=bids_root)
data_path = BIDSPath(subject=subject_id,
session=session_id,
datatype='meg',
root=bids_root).mkdir().directory
ch_path = (bids_path.copy().update(suffix='channels', extension='.tsv'))
channels_fname = op.join(data_path, ch_path.basename)
raw_bids_fname = (bids_path.copy().update(root=bids_root,
datatype='meg',
suffix='meg',
extension='.fif'))
raw = _read_raw_fif(raw_fname, verbose=False)
###########################################################################
# bads in FIF only, no `status` column in channels.tsv
bads = ['EEG 053', 'MEG 2443']
raw.info['bads'] = bads
write_raw_bids(raw, bids_path, overwrite=True, verbose=False)
# Delete `status` column
tsv_data = _from_tsv(channels_fname)
del tsv_data['status'], tsv_data['status_description']
_to_tsv(tsv_data, fname=channels_fname)
raw = read_raw_bids(bids_path=bids_path, verbose=False)
assert raw.info['bads'] == bads
###########################################################################
# bads in `status` column in channels.tsv, no bads in raw.info['bads']
bads = ['EEG 053', 'MEG 2443']
raw.info['bads'] = bads
write_raw_bids(raw, bids_path, overwrite=True, verbose=False)
# Remove info['bads'] from the raw file.
raw = _read_raw_fif(raw_bids_fname, preload=True, verbose=False)
raw.info['bads'] = []
raw.save(raw_bids_fname, overwrite=True, verbose=False)
raw = read_raw_bids(bids_path=bids_path, verbose=False)
assert type(raw.info['bads']) is list
assert set(raw.info['bads']) == set(bads)
###########################################################################
# Different bads in `status` column and raw.info['bads']
bads_bids = ['EEG 053', 'MEG 2443']
bads_raw = ['MEG 0112', 'MEG 0131']
raw.info['bads'] = bads_bids
write_raw_bids(raw, bids_path, overwrite=True, verbose=False)
# Replace info['bads'] in the raw file.
raw = _read_raw_fif(raw_bids_fname, preload=True, verbose=False)
raw.info['bads'] = bads_raw
raw.save(raw_bids_fname, overwrite=True, verbose=False)
with pytest.warns(RuntimeWarning, match='conflicting information'):
raw = read_raw_bids(bids_path=bids_path, verbose=False)
assert type(raw.info['bads']) is list
assert set(raw.info['bads']) == set(bads_bids)
def test_handle_info_reading(tmpdir):
"""Test reading information from a BIDS sidecar JSON file."""
# read in USA dataset, so it should find 50 Hz
raw = _read_raw_fif(raw_fname)
# write copy of raw with line freq of 60
# bids basename and fname
bids_path = BIDSPath(subject='01',
session='01',
task='audiovisual',
run='01',
root=tmpdir)
suffix = "meg"
bids_fname = bids_path.copy().update(suffix=suffix, extension='.fif')
write_raw_bids(raw, bids_path, overwrite=True)
# find sidecar JSON fname
bids_fname.update(datatype=suffix)
sidecar_fname = _find_matching_sidecar(bids_fname,
suffix=suffix,
extension='.json')
# assert that we get the same line frequency set
raw = read_raw_bids(bids_path=bids_path)
assert raw.info['line_freq'] == 60
# setting line_freq to None should produce 'n/a' in the JSON sidecar
raw.info['line_freq'] = None
write_raw_bids(raw, bids_path, overwrite=True)
raw = read_raw_bids(bids_path=bids_path)
assert raw.info['line_freq'] is None
with open(sidecar_fname, 'r', encoding='utf-8') as fin:
sidecar_json = json.load(fin)
assert sidecar_json["PowerLineFrequency"] == 'n/a'
# 2. if line frequency is not set in raw file, then ValueError
del raw.info['line_freq']
with pytest.raises(ValueError, match="PowerLineFrequency .* required"):
write_raw_bids(raw, bids_path, overwrite=True)
# check whether there are "Extra points" in raw.info['dig'] if
# DigitizedHeadPoints is set to True and not otherwise
n_dig_points = 0
for dig_point in raw.info['dig']:
if dig_point['kind'] == FIFF.FIFFV_POINT_EXTRA:
n_dig_points += 1
if sidecar_json['DigitizedHeadPoints']:
assert n_dig_points > 0
else:
assert n_dig_points == 0
# check whether any of NAS/LPA/RPA are present in raw.info['dig']
# DigitizedLandmark is set to True, and False otherwise
landmark_present = False
for dig_point in raw.info['dig']:
if dig_point['kind'] in [
FIFF.FIFFV_POINT_LPA, FIFF.FIFFV_POINT_RPA,
FIFF.FIFFV_POINT_NASION
]:
landmark_present = True
break
if landmark_present:
assert sidecar_json['DigitizedLandmarks'] is True
else:
assert sidecar_json['DigitizedLandmarks'] is False
# make a copy of the sidecar in "derivatives/"
# to check that we make sure we always get the right sidecar
# in addition, it should not break the sidecar reading
# in `read_raw_bids`
raw.info['line_freq'] = 60
write_raw_bids(raw, bids_path, overwrite=True)
deriv_dir = tmpdir.mkdir("derivatives")
sidecar_copy = deriv_dir / op.basename(sidecar_fname)
with open(sidecar_fname, "r", encoding='utf-8') as fin:
sidecar_json = json.load(fin)
sidecar_json["PowerLineFrequency"] = 45
_write_json(sidecar_copy, sidecar_json)
raw = read_raw_bids(bids_path=bids_path)
assert raw.info['line_freq'] == 60
# 3. assert that we get an error when sidecar json doesn't match
_update_sidecar(sidecar_fname, "PowerLineFrequency", 55)
with pytest.warns(RuntimeWarning, match="Defaulting to .* sidecar JSON"):
raw = read_raw_bids(bids_path=bids_path)
assert raw.info['line_freq'] == 55
def test_handle_eeg_coords_reading(tmp_path):
"""Test reading iEEG coordinates from BIDS files."""
bids_path = BIDSPath(
subject=subject_id, session=session_id, run=run, acquisition=acq,
task=task, root=tmp_path)
data_path = op.join(testing.data_path(), 'EDF')
raw_fname = op.join(data_path, 'test_reduced.edf')
raw = _read_raw_edf(raw_fname)
# ensure we are writing 'eeg' data
raw.set_channel_types({ch: 'eeg'
for ch in raw.ch_names})
# set a `random` montage
ch_names = raw.ch_names
elec_locs = np.random.random((len(ch_names), 3)).astype(float)
ch_pos = dict(zip(ch_names, elec_locs))
# # create montage in 'unknown' coordinate frame
# # and assert coordsystem/electrodes sidecar tsv don't exist
montage = mne.channels.make_dig_montage(ch_pos=ch_pos,
coord_frame="unknown")
raw.set_montage(montage)
with pytest.raises(RuntimeError, match="'head' coordinate frame "
"must contain"):
write_raw_bids(raw, bids_path, overwrite=True)
bids_path.update(root=tmp_path)
coordsystem_fname = _find_matching_sidecar(bids_path,
suffix='coordsystem',
extension='.json',
on_error='warn')
electrodes_fname = _find_matching_sidecar(bids_path,
suffix='electrodes',
extension='.tsv',
on_error='warn')
assert coordsystem_fname is None
assert electrodes_fname is None
# create montage in head frame and set should result in
# an error if landmarks are not set
montage = mne.channels.make_dig_montage(ch_pos=ch_pos,
coord_frame="head")
raw.set_montage(montage)
with pytest.raises(RuntimeError, match="'head' coordinate frame "
"must contain"):
write_raw_bids(raw, bids_path, overwrite=True)
montage = mne.channels.make_dig_montage(ch_pos=ch_pos,
coord_frame="head",
nasion=[1, 0, 0],
lpa=[0, 1, 0],
rpa=[0, 0, 1])
raw.set_montage(montage)
write_raw_bids(raw, bids_path, overwrite=True)
# obtain the sensor positions and assert ch_coords are same
raw_test = read_raw_bids(bids_path, verbose=True)
assert not object_diff(raw.info['chs'], raw_test.info['chs'])
# modify coordinate frame to not-captrak
coordsystem_fname = _find_matching_sidecar(bids_path,
suffix='coordsystem',
extension='.json')
_update_sidecar(coordsystem_fname, 'EEGCoordinateSystem', 'besa')
with pytest.warns(RuntimeWarning, match='is not a BIDS-acceptable '
'coordinate frame for EEG'):
raw_test = read_raw_bids(bids_path)
assert raw_test.info['dig'] is None
def test_read_participants_data():
"""Test reading information from a BIDS sidecar.json file."""
bids_root = _TempDir()
raw = mne.io.read_raw_fif(raw_fname, verbose=False)
# if subject info was set, we don't roundtrip birthday
# due to possible anonymization in mne-bids
subject_info = {
'hand': 1,
'sex': 2,
}
raw.info['subject_info'] = subject_info
write_raw_bids(raw,
bids_basename,
bids_root,
overwrite=True,
verbose=False)
raw = read_raw_bids(bids_basename=bids_basename,
bids_root=bids_root,
kind='meg')
print(raw.info['subject_info'])
assert raw.info['subject_info']['hand'] == 1
assert raw.info['subject_info']['sex'] == 2
assert raw.info['subject_info'].get('birthday', None) is None
# if modifying participants tsv, then read_raw_bids reflects that
participants_tsv_fpath = op.join(bids_root, 'participants.tsv')
participants_tsv = _from_tsv(participants_tsv_fpath)
participants_tsv['hand'][0] = 'n/a'
_to_tsv(participants_tsv, participants_tsv_fpath)
raw = read_raw_bids(bids_basename=bids_basename,
bids_root=Path(bids_root),
kind='meg')
assert raw.info['subject_info']['hand'] == 0
assert raw.info['subject_info']['sex'] == 2
assert raw.info['subject_info'].get('birthday', None) is None
# make sure things are read even if the entries don't make sense
participants_tsv = _from_tsv(participants_tsv_fpath)
participants_tsv['hand'][0] = 'righty'
participants_tsv['sex'][0] = 'malesy'
_to_tsv(participants_tsv, participants_tsv_fpath)
with pytest.warns(RuntimeWarning, match='Unable to map'):
raw = read_raw_bids(bids_basename=bids_basename,
bids_root=Path(bids_root),
kind='meg')
assert raw.info['subject_info']['hand'] is None
assert raw.info['subject_info']['sex'] is None
# make sure to read in if no participants file
raw = mne.io.read_raw_fif(raw_fname, verbose=False)
write_raw_bids(raw,
bids_basename,
bids_root,
overwrite=True,
verbose=False)
os.remove(participants_tsv_fpath)
with pytest.warns(RuntimeWarning, match='Participants file not found'):
raw = read_raw_bids(bids_basename=bids_basename,
bids_root=Path(bids_root),
kind='meg')
assert raw.info['subject_info'] is None
def test_handle_ieeg_coords_reading(bids_path, tmpdir):
"""Test reading iEEG coordinates from BIDS files."""
data_path = op.join(testing.data_path(), 'EDF')
raw_fname = op.join(data_path, 'test_reduced.edf')
bids_fname = bids_path.copy().update(datatype='ieeg',
suffix='ieeg',
extension='.edf',
root=tmpdir)
raw = _read_raw_edf(raw_fname)
# ensure we are writing 'ecog'/'ieeg' data
raw.set_channel_types({ch: 'ecog' for ch in raw.ch_names})
# coordinate frames in mne-python should all map correctly
# set a `random` montage
ch_names = raw.ch_names
elec_locs = np.random.random((len(ch_names), 3)).astype(float)
ch_pos = dict(zip(ch_names, elec_locs))
coordinate_frames = ['mni_tal']
for coord_frame in coordinate_frames:
# XXX: mne-bids doesn't support multiple electrodes.tsv files
sh.rmtree(tmpdir)
montage = mne.channels.make_dig_montage(ch_pos=ch_pos,
coord_frame=coord_frame)
raw.set_montage(montage)
write_raw_bids(raw, bids_fname, overwrite=True, verbose=False)
# read in raw file w/ updated coordinate frame
# and make sure all digpoints are correct coordinate frames
raw_test = read_raw_bids(bids_path=bids_fname, verbose=False)
coord_frame_int = MNE_STR_TO_FRAME[coord_frame]
for digpoint in raw_test.info['dig']:
assert digpoint['coord_frame'] == coord_frame_int
# start w/ new bids root
sh.rmtree(tmpdir)
write_raw_bids(raw, bids_fname, overwrite=True, verbose=False)
# obtain the sensor positions and assert ch_coords are same
raw_test = read_raw_bids(bids_path=bids_fname, verbose=False)
orig_locs = raw.info['dig'][1]
test_locs = raw_test.info['dig'][1]
assert orig_locs == test_locs
assert not object_diff(raw.info['chs'], raw_test.info['chs'])
# read in the data and assert montage is the same
# regardless of 'm', 'cm', 'mm', or 'pixel'
scalings = {'m': 1, 'cm': 100, 'mm': 1000}
bids_fname.update(root=tmpdir)
coordsystem_fname = _find_matching_sidecar(bids_fname,
suffix='coordsystem',
extension='.json')
electrodes_fname = _find_matching_sidecar(bids_fname,
suffix='electrodes',
extension='.tsv')
orig_electrodes_dict = _from_tsv(electrodes_fname,
[str, float, float, float, str])
# not BIDS specified should not be read
coord_unit = 'km'
scaling = 0.001
_update_sidecar(coordsystem_fname, 'iEEGCoordinateUnits', coord_unit)
electrodes_dict = _from_tsv(electrodes_fname,
[str, float, float, float, str])
for axis in ['x', 'y', 'z']:
electrodes_dict[axis] = \
np.multiply(orig_electrodes_dict[axis], scaling)
_to_tsv(electrodes_dict, electrodes_fname)
with pytest.warns(RuntimeWarning,
match='Coordinate unit is not '
'an accepted BIDS unit'):
raw_test = read_raw_bids(bids_path=bids_fname, verbose=False)
# correct BIDS units should scale to meters properly
for coord_unit, scaling in scalings.items():
# update coordinate SI units
_update_sidecar(coordsystem_fname, 'iEEGCoordinateUnits', coord_unit)
electrodes_dict = _from_tsv(electrodes_fname,
[str, float, float, float, str])
for axis in ['x', 'y', 'z']:
electrodes_dict[axis] = \
np.multiply(orig_electrodes_dict[axis], scaling)
_to_tsv(electrodes_dict, electrodes_fname)
# read in raw file w/ updated montage
raw_test = read_raw_bids(bids_path=bids_fname, verbose=False)
# obtain the sensor positions and make sure they're the same
assert_dig_allclose(raw.info, raw_test.info)
# XXX: Improve by changing names to 'unknown' coordframe (needs mne PR)
# check that coordinate systems other coordinate systems should be named
# in the file and not the CoordinateSystem, which is reserved for keywords
coordinate_frames = ['Other']
for coord_frame in coordinate_frames:
# update coordinate units
_update_sidecar(coordsystem_fname, 'iEEGCoordinateSystem', coord_frame)
# read in raw file w/ updated coordinate frame
# and make sure all digpoints are MRI coordinate frame
with pytest.warns(RuntimeWarning,
match="Defaulting coordinate "
"frame to unknown"):
raw_test = read_raw_bids(bids_path=bids_fname, verbose=False)
assert raw_test.info['dig'] is not None
# check that standard template identifiers that are unsupported in
# mne-python coordinate frames, still get read in, but produce a warning
coordinate_frames = [
'individual', 'fsnative', 'scanner', 'ICBM452AirSpace', 'NIHPD'
]
for coord_frame in coordinate_frames:
# update coordinate units
_update_sidecar(coordsystem_fname, 'iEEGCoordinateSystem', coord_frame)
# read in raw file w/ updated coordinate frame
# and make sure all digpoints are MRI coordinate frame
with pytest.warns(RuntimeWarning,
match=f"iEEG Coordinate frame {coord_frame} "
f"is not a readable BIDS keyword "):
raw_test = read_raw_bids(bids_path=bids_fname, verbose=False)
assert raw_test.info['dig'] is not None
# ACPC should be read in as RAS for iEEG
_update_sidecar(coordsystem_fname, 'iEEGCoordinateSystem', 'ACPC')
raw_test = read_raw_bids(bids_path=bids_fname, verbose=False)
coord_frame_int = MNE_STR_TO_FRAME['mri']
for digpoint in raw_test.info['dig']:
assert digpoint['coord_frame'] == coord_frame_int
# if we delete the coordsystem.json file, an error will be raised
os.remove(coordsystem_fname)
with pytest.raises(RuntimeError,
match='BIDS mandates that '
'the coordsystem.json'):
raw = read_raw_bids(bids_path=bids_fname, verbose=False)
# test error message if electrodes is not a subset of Raw
bids_path.update(root=tmpdir)
write_raw_bids(raw, bids_path, overwrite=True)
electrodes_dict = _from_tsv(electrodes_fname)
# pop off 5 channels
for key in electrodes_dict.keys():
for i in range(5):
electrodes_dict[key].pop()
_to_tsv(electrodes_dict, electrodes_fname)
# popping off channels should not result in an error
# however, a warning will be raised through mne-python
with pytest.warns(RuntimeWarning,
match='DigMontage is '
'only a subset of info'):
read_raw_bids(bids_path=bids_fname, verbose=False)
# make sure montage is set if there are coordinates w/ 'n/a'
raw.info['bads'] = []
write_raw_bids(raw, bids_path, overwrite=True, verbose=False)
electrodes_dict = _from_tsv(electrodes_fname)
for axis in ['x', 'y', 'z']:
electrodes_dict[axis][0] = 'n/a'
electrodes_dict[axis][3] = 'n/a'
_to_tsv(electrodes_dict, electrodes_fname)
# test if montage is correctly set via mne-bids
# electrode coordinates should be nan
# when coordinate is 'n/a'
nan_chs = [electrodes_dict['name'][i] for i in [0, 3]]
with pytest.warns(RuntimeWarning,
match='There are channels '
'without locations'):
raw = read_raw_bids(bids_path=bids_fname, verbose=False)
for idx, ch in enumerate(raw.info['chs']):
if ch['ch_name'] in nan_chs:
assert all(np.isnan(ch['loc'][:3]))
else:
assert not any(np.isnan(ch['loc'][:3]))
assert ch['ch_name'] not in raw.info['bads']