def test_ch_loc():
"""Test raw kit loc."""
raw_py = read_raw_kit(sqd_path, mrk_path, elp_txt_path, hsp_txt_path,
stim='<')
raw_bin = read_raw_fif(op.join(data_dir, 'test_bin_raw.fif'))
ch_py = np.array([ch['loc'] for ch in
raw_py._raw_extras[0]['channels'][:160]])
# ch locs stored as m, not mm
ch_py[:, :3] *= 1e3
ch_sns = read_sns(op.join(data_dir, 'sns.txt'))
assert_array_almost_equal(ch_py, ch_sns, 2)
assert_array_almost_equal(raw_py.info['dev_head_t']['trans'],
raw_bin.info['dev_head_t']['trans'], 4)
for py_ch, bin_ch in zip(raw_py.info['chs'], raw_bin.info['chs']):
if bin_ch['ch_name'].startswith('MEG'):
# the stored ch locs have more precision than the sns.txt
assert_array_almost_equal(py_ch['loc'], bin_ch['loc'], decimal=2)
# test when more than one marker file provided
mrks = [mrk_path, mrk2_path, mrk3_path]
read_raw_kit(sqd_path, mrks, elp_txt_path, hsp_txt_path, preload=False)
# this dataset does not have the equivalent set of points :(
raw_bin.info['dig'] = raw_bin.info['dig'][:8]
raw_py.info['dig'] = raw_py.info['dig'][:8]
assert_dig_allclose(raw_py.info, raw_bin.info)
def kit2fiff(subject, exp, path, dig=True, preload=False):
from glob import glob
from mne.io import read_raw_kit
kit = op.join(path, subject, 'kit', subject + '*' + exp + '*' + 'calm.con')
mrk_pre = op.join(path, subject, 'kit',
subject + '*mrk*' + 'pre_' + exp + '*.mrk')
mrk_post = op.join(path, subject, 'kit',
subject + '*mrk*' + 'post_' + exp + '*.mrk')
elp = op.join(path, subject, 'kit', subject + '*p.txt')
hsp = op.join(path, subject, 'kit', subject + '*h.txt')
mrk_pre = glob(mrk_pre)[0]
mrk_post = glob(mrk_post)[0]
elp = glob(elp)[0]
hsp = glob(hsp)[0]
kit = glob(kit)[0]
if dig:
raw = read_raw_kit(input_fname=kit,
mrk=[mrk_pre, mrk_post],
elp=elp,
hsp=hsp,
stim='>',
slope='+',
preload=preload,
verbose=False)
else:
raw = read_raw_kit(input_fname=kit,
stim='>',
slope='+',
preload=preload,
verbose=False)
return raw
def test_ch_loc():
"""Test raw kit loc
"""
raw_py = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path, stim='<')
raw_bin = Raw(op.join(data_dir, 'test_bin_raw.fif'))
ch_py = raw_py._sqd_params['sensor_locs'][:, :5]
# ch locs stored as m, not mm
ch_py[:, :3] *= 1e3
ch_sns = read_sns(op.join(data_dir, 'sns.txt'))
assert_array_almost_equal(ch_py, ch_sns, 2)
assert_array_almost_equal(raw_py.info['dev_head_t']['trans'],
raw_bin.info['dev_head_t']['trans'], 4)
for py_ch, bin_ch in zip(raw_py.info['chs'], raw_bin.info['chs']):
if bin_ch['ch_name'].startswith('MEG'):
# the stored ch locs have more precision than the sns.txt
assert_array_almost_equal(py_ch['loc'], bin_ch['loc'], decimal=2)
assert_array_almost_equal(py_ch['coil_trans'],
bin_ch['coil_trans'],
decimal=2)
# test when more than one marker file provided
mrks = [mrk_path, mrk2_path, mrk3_path]
read_raw_kit(sqd_path, mrks, elp_path, hsp_path, preload=False)
def test_ch_loc():
"""Test raw kit loc."""
raw_py = read_raw_kit(sqd_path, mrk_path, elp_txt_path, hsp_txt_path,
stim='<')
raw_bin = read_raw_fif(op.join(data_dir, 'test_bin_raw.fif'))
ch_py = np.array([ch['loc'] for ch in
raw_py._raw_extras[0]['channels'][:160]])
# ch locs stored as m, not mm
ch_py[:, :3] *= 1e3
ch_sns = read_sns(op.join(data_dir, 'sns.txt'))
assert_array_almost_equal(ch_py, ch_sns, 2)
assert_array_almost_equal(raw_py.info['dev_head_t']['trans'],
raw_bin.info['dev_head_t']['trans'], 4)
for py_ch, bin_ch in zip(raw_py.info['chs'], raw_bin.info['chs']):
if bin_ch['ch_name'].startswith('MEG'):
# the stored ch locs have more precision than the sns.txt
assert_array_almost_equal(py_ch['loc'], bin_ch['loc'], decimal=2)
# test when more than one marker file provided
mrks = [mrk_path, mrk2_path, mrk3_path]
read_raw_kit(sqd_path, mrks, elp_txt_path, hsp_txt_path, preload=False)
# this dataset does not have the equivalent set of points :(
raw_bin.info['dig'] = raw_bin.info['dig'][:8]
raw_py.info['dig'] = raw_py.info['dig'][:8]
assert_dig_allclose(raw_py.info, raw_bin.info)
def test_raw_events():
"""Test creating stim channel from raw SQD file."""
def evts(a, b, c, d, e, f=None):
out = [[269, a, b], [281, b, c], [1552, c, d], [1564, d, e]]
if f is not None:
out.append([2000, e, f])
return out
raw = read_raw_kit(sqd_path)
assert_array_equal(find_events(raw, output='step', consecutive=True),
evts(255, 254, 255, 254, 255, 0))
raw = read_raw_kit(sqd_path, slope='+')
assert_array_equal(find_events(raw, output='step', consecutive=True),
evts(0, 1, 0, 1, 0))
raw = read_raw_kit(sqd_path, stim='<', slope='+')
assert_array_equal(find_events(raw, output='step', consecutive=True),
evts(0, 128, 0, 128, 0))
raw = read_raw_kit(sqd_path, stim='<', slope='+', stim_code='channel')
assert_array_equal(find_events(raw, output='step', consecutive=True),
evts(0, 160, 0, 160, 0))
raw = read_raw_kit(sqd_path, stim=range(160, 162), slope='+',
stim_code='channel')
assert_array_equal(find_events(raw, output='step', consecutive=True),
evts(0, 160, 0, 160, 0))
def test_raw_events():
"""Test creating stim channel from raw SQD file."""
def evts(a, b, c, d, e, f=None):
out = [[269, a, b], [281, b, c], [1552, c, d], [1564, d, e]]
if f is not None:
out.append([2000, e, f])
return out
raw = read_raw_kit(sqd_path)
assert_array_equal(find_events(raw, output='step', consecutive=True),
evts(255, 254, 255, 254, 255, 0))
raw = read_raw_kit(sqd_path, slope='+')
assert_array_equal(find_events(raw, output='step', consecutive=True),
evts(0, 1, 0, 1, 0))
raw = read_raw_kit(sqd_path, stim='<', slope='+')
assert_array_equal(find_events(raw, output='step', consecutive=True),
evts(0, 128, 0, 128, 0))
raw = read_raw_kit(sqd_path, stim='<', slope='+', stim_code='channel')
assert_array_equal(find_events(raw, output='step', consecutive=True),
evts(0, 160, 0, 160, 0))
raw = read_raw_kit(sqd_path, stim=range(160, 162), slope='+',
stim_code='channel')
assert_array_equal(find_events(raw, output='step', consecutive=True),
evts(0, 160, 0, 160, 0))
def test_read_segment():
"""Test writing raw kit files when preload is False
"""
raw1 = read_raw_kit(sqd_path,
mrk_path,
elp_path,
hsp_path,
stim='<',
preload=False)
raw1_file = op.join(tempdir, 'test1-raw.fif')
raw1.save(raw1_file, buffer_size_sec=.1, overwrite=True)
raw2 = read_raw_kit(sqd_path,
mrk_path,
elp_path,
hsp_path,
stim='<',
preload=True)
raw2_file = op.join(tempdir, 'test2-raw.fif')
raw2.save(raw2_file, buffer_size_sec=.1, overwrite=True)
raw1 = Raw(raw1_file, preload=True)
raw2 = Raw(raw2_file, preload=True)
assert_array_equal(raw1._data, raw2._data)
raw3 = read_raw_kit(sqd_path,
mrk_path,
elp_path,
hsp_path,
stim='<',
preload=True)
assert_array_almost_equal(raw1._data, raw3._data)
def test_ch_loc():
"""Test raw kit loc
"""
raw_py = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path, stim='<')
raw_bin = Raw(op.join(data_dir, 'test_bin_raw.fif'))
ch_py = raw_py._sqd_params['sensor_locs'][:, :5]
# ch locs stored as m, not mm
ch_py[:, :3] *= 1e3
ch_sns = read_sns(op.join(data_dir, 'sns.txt'))
assert_array_almost_equal(ch_py, ch_sns, 2)
assert_array_almost_equal(raw_py.info['dev_head_t']['trans'],
raw_bin.info['dev_head_t']['trans'], 4)
for py_ch, bin_ch in zip(raw_py.info['chs'], raw_bin.info['chs']):
if bin_ch['ch_name'].startswith('MEG'):
# the stored ch locs have more precision than the sns.txt
assert_array_almost_equal(py_ch['loc'], bin_ch['loc'], decimal=2)
assert_array_almost_equal(py_ch['coil_trans'],
bin_ch['coil_trans'],
decimal=2)
# test when more than one marker file provided
mrks = [mrk_path, mrk2_path, mrk3_path]
_ = read_raw_kit(sqd_path, mrks, elp_path, hsp_path, preload=False)
def test_read_segment():
"""Test writing raw kit files when preload is False
"""
tempdir = _TempDir()
raw1 = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path, stim='<',
preload=False)
raw1_file = op.join(tempdir, 'test1-raw.fif')
raw1.save(raw1_file, buffer_size_sec=.1, overwrite=True)
raw2 = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path, stim='<',
preload=True)
raw2_file = op.join(tempdir, 'test2-raw.fif')
raw2.save(raw2_file, buffer_size_sec=.1, overwrite=True)
data1, times1 = raw1[0, 0:1]
raw1 = Raw(raw1_file, preload=True)
raw2 = Raw(raw2_file, preload=True)
assert_array_equal(raw1._data, raw2._data)
data2, times2 = raw2[0, 0:1]
assert_array_almost_equal(data1, data2)
assert_array_almost_equal(times1, times2)
raw3 = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path, stim='<',
preload=True)
assert_array_almost_equal(raw1._data, raw3._data)
raw4 = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path, stim='<',
preload=False)
raw4.load_data()
buffer_fname = op.join(tempdir, 'buffer')
assert_array_almost_equal(raw1._data, raw4._data)
raw5 = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path, stim='<',
preload=buffer_fname)
assert_array_almost_equal(raw1._data, raw5._data)
def test_data():
"""Test reading raw kit files
"""
assert_raises(TypeError, read_raw_kit, epochs_path)
assert_raises(TypeError, read_epochs_kit, sqd_path)
assert_raises(ValueError, read_raw_kit, sqd_path, mrk_path, elp_path)
assert_raises(ValueError, read_raw_kit, sqd_path, None, None, None,
list(range(200, 190, -1)))
assert_raises(ValueError, read_raw_kit, sqd_path, None, None, None,
list(range(167, 159, -1)), '*', 1, True)
# check functionality
raw_mrk = read_raw_kit(sqd_path, [mrk2_path, mrk3_path], elp_path,
hsp_path)
raw_py = _test_raw_reader(read_raw_kit,
input_fname=sqd_path, mrk=mrk_path, elp=elp_path,
hsp=hsp_path, stim=list(range(167, 159, -1)),
slope='+', stimthresh=1)
assert_true('RawKIT' in repr(raw_py))
assert_equal(raw_mrk.info['kit_system_id'], KIT.SYSTEM_NYU_2010)
assert_true(KIT_CONSTANTS[raw_mrk.info['kit_system_id']] is KIT_NY)
# Test stim channel
raw_stim = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path, stim='<',
preload=False)
for raw in [raw_py, raw_stim, raw_mrk]:
stim_pick = pick_types(raw.info, meg=False, ref_meg=False,
stim=True, exclude='bads')
stim1, _ = raw[stim_pick]
stim2 = np.array(raw.read_stim_ch(), ndmin=2)
assert_array_equal(stim1, stim2)
# Binary file only stores the sensor channels
py_picks = pick_types(raw_py.info, exclude='bads')
raw_bin = op.join(data_dir, 'test_bin_raw.fif')
raw_bin = Raw(raw_bin, preload=True)
bin_picks = pick_types(raw_bin.info, stim=True, exclude='bads')
data_bin, _ = raw_bin[bin_picks]
data_py, _ = raw_py[py_picks]
# this .mat was generated using the Yokogawa MEG Reader
data_Ykgw = op.join(data_dir, 'test_Ykgw.mat')
data_Ykgw = scipy.io.loadmat(data_Ykgw)['data']
data_Ykgw = data_Ykgw[py_picks]
assert_array_almost_equal(data_py, data_Ykgw)
py_picks = pick_types(raw_py.info, stim=True, ref_meg=False,
exclude='bads')
data_py, _ = raw_py[py_picks]
assert_array_almost_equal(data_py, data_bin)
# KIT-UMD data
_test_raw_reader(read_raw_kit, input_fname=sqd_umd_path)
raw = read_raw_kit(sqd_umd_path)
assert_equal(raw.info['kit_system_id'], KIT.SYSTEM_UMD_2014_12)
assert_true(KIT_CONSTANTS[raw.info['kit_system_id']] is KIT_UMD_2014)
def _read_raw(raw_fname, electrode=None, hsp=None, hpi=None, config=None,
verbose=None):
"""Read a raw file into MNE, making inferences based on extension."""
fname, ext = _parse_ext(raw_fname)
# KIT systems
if ext in ['.con', '.sqd']:
raw = io.read_raw_kit(raw_fname, elp=electrode, hsp=hsp,
mrk=hpi, preload=False)
# Neuromag or converted-to-fif systems
elif ext in ['.fif', '.gz']:
raw = io.read_raw_fif(raw_fname, preload=False)
# BTi systems
elif ext == '.pdf':
if os.path.isfile(raw_fname):
raw = io.read_raw_bti(raw_fname, config_fname=config,
head_shape_fname=hsp,
preload=False, verbose=verbose)
# CTF systems
elif ext == '.ds':
raw = io.read_raw_ctf(raw_fname)
else:
raise ValueError("Raw file name extension must be one of %\n"
"Got %" % (ALLOWED_EXTENSIONS, ext))
return raw
def test_decimate():
"""Test decimation of digitizer headshapes with too many points."""
# load headshape and convert to meters
hsp_mm = _get_ico_surface(5)['rr'] * 100
hsp_m = hsp_mm / 1000.
# save headshape to a file in mm in temporary directory
tempdir = _TempDir()
sphere_hsp_path = op.join(tempdir, 'test_sphere.txt')
np.savetxt(sphere_hsp_path, hsp_mm)
# read in raw data using spherical hsp, and extract new hsp
with warnings.catch_warnings(record=True) as w:
raw = read_raw_kit(sqd_path, mrk_path, elp_txt_path, sphere_hsp_path)
assert_true(any('more than' in str(ww.message) for ww in w))
# collect headshape from raw (should now be in m)
hsp_dec = np.array([dig['r'] for dig in raw.info['dig']])[8:]
# with 10242 points and _decimate_points set to resolution of 5 mm, hsp_dec
# should be a bit over 5000 points. If not, something is wrong or
# decimation resolution has been purposefully changed
assert_true(len(hsp_dec) > 5000)
# should have similar size, distance from center
dist = np.sqrt(np.sum((hsp_m - np.mean(hsp_m, axis=0))**2, axis=1))
dist_dec = np.sqrt(np.sum((hsp_dec - np.mean(hsp_dec, axis=0))**2, axis=1))
hsp_rad = np.mean(dist)
hsp_dec_rad = np.mean(dist_dec)
assert_almost_equal(hsp_rad, hsp_dec_rad, places=3)
def test_plot_trans():
"""Test plotting of -trans.fif files and MEG sensor layouts
"""
evoked = read_evokeds(evoked_fname)[0]
with warnings.catch_warnings(record=True): # 4D weight tables
bti = read_raw_bti(pdf_fname, config_fname, hs_fname, convert=True,
preload=False).info
infos = dict(
Neuromag=evoked.info,
CTF=read_raw_ctf(ctf_fname).info,
BTi=bti,
KIT=read_raw_kit(sqd_fname).info,
)
for system, info in infos.items():
ref_meg = False if system == 'KIT' else True
plot_trans(info, trans_fname, subject='sample', meg_sensors=True,
subjects_dir=subjects_dir, ref_meg=ref_meg)
# KIT ref sensor coil def not defined
assert_raises(RuntimeError, plot_trans, infos['KIT'], None,
meg_sensors=True, ref_meg=True)
info = infos['Neuromag']
assert_raises(ValueError, plot_trans, info, trans_fname,
subject='sample', subjects_dir=subjects_dir,
ch_type='bad-chtype')
assert_raises(TypeError, plot_trans, 'foo', trans_fname,
subject='sample', subjects_dir=subjects_dir)
# no-head version
plot_trans(info, None, meg_sensors=True, dig=True, coord_frame='head')
# EEG only with strange options
with warnings.catch_warnings(record=True) as w:
plot_trans(evoked.copy().pick_types(meg=False, eeg=True).info,
trans=trans_fname, meg_sensors=True)
assert_true(['Cannot plot MEG' in str(ww.message) for ww in w])
def test_pick_refs():
"""Test picking of reference sensors
"""
infos = list()
# KIT
kit_dir = op.join(io_dir, 'kit', 'tests', 'data')
sqd_path = op.join(kit_dir, 'test.sqd')
mrk_path = op.join(kit_dir, 'test_mrk.sqd')
elp_path = op.join(kit_dir, 'test_elp.txt')
hsp_path = op.join(kit_dir, 'test_hsp.txt')
raw_kit = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path)
infos.append(raw_kit.info)
# BTi
bti_dir = op.join(io_dir, 'bti', 'tests', 'data')
bti_pdf = op.join(bti_dir, 'test_pdf_linux')
bti_config = op.join(bti_dir, 'test_config_linux')
bti_hs = op.join(bti_dir, 'test_hs_linux')
with warnings.catch_warnings(record=True): # weight tables
raw_bti = read_raw_bti(bti_pdf, bti_config, bti_hs, preload=False)
infos.append(raw_bti.info)
# CTF
fname_ctf_raw = op.join(io_dir, 'tests', 'data', 'test_ctf_comp_raw.fif')
raw_ctf = read_raw_fif(fname_ctf_raw, add_eeg_ref=False)
raw_ctf.apply_gradient_compensation(2)
infos.append(raw_ctf.info)
for info in infos:
info['bads'] = []
assert_raises(ValueError, pick_types, info, meg='foo')
assert_raises(ValueError, pick_types, info, ref_meg='foo')
picks_meg_ref = pick_types(info, meg=True, ref_meg=True)
picks_meg = pick_types(info, meg=True, ref_meg=False)
picks_ref = pick_types(info, meg=False, ref_meg=True)
assert_array_equal(picks_meg_ref,
np.sort(np.concatenate([picks_meg, picks_ref])))
picks_grad = pick_types(info, meg='grad', ref_meg=False)
picks_ref_grad = pick_types(info, meg=False, ref_meg='grad')
picks_meg_ref_grad = pick_types(info, meg='grad', ref_meg='grad')
assert_array_equal(
picks_meg_ref_grad,
np.sort(np.concatenate([picks_grad, picks_ref_grad])))
picks_mag = pick_types(info, meg='mag', ref_meg=False)
picks_ref_mag = pick_types(info, meg=False, ref_meg='mag')
picks_meg_ref_mag = pick_types(info, meg='mag', ref_meg='mag')
assert_array_equal(picks_meg_ref_mag,
np.sort(np.concatenate([picks_mag, picks_ref_mag])))
assert_array_equal(picks_meg,
np.sort(np.concatenate([picks_mag, picks_grad])))
assert_array_equal(
picks_ref, np.sort(np.concatenate([picks_ref_mag,
picks_ref_grad])))
assert_array_equal(
picks_meg_ref,
np.sort(
np.concatenate(
[picks_grad, picks_mag, picks_ref_grad, picks_ref_mag])))
for pick in (picks_meg_ref, picks_meg, picks_ref, picks_grad,
picks_ref_grad, picks_meg_ref_grad, picks_mag,
picks_ref_mag, picks_meg_ref_mag):
if len(pick) > 0:
pick_info(info, pick)
def test_decimate(tmpdir):
"""Test decimation of digitizer headshapes with too many points."""
# load headshape and convert to meters
hsp_mm = _get_ico_surface(5)['rr'] * 100
hsp_m = hsp_mm / 1000.
# save headshape to a file in mm in temporary directory
tempdir = str(tmpdir)
sphere_hsp_path = op.join(tempdir, 'test_sphere.txt')
np.savetxt(sphere_hsp_path, hsp_mm)
# read in raw data using spherical hsp, and extract new hsp
with pytest.warns(RuntimeWarning,
match='was automatically downsampled .* FastScan'):
raw = read_raw_kit(sqd_path, mrk_path, elp_txt_path, sphere_hsp_path)
# collect headshape from raw (should now be in m)
hsp_dec = np.array([dig['r'] for dig in raw.info['dig']])[8:]
# with 10242 points and _decimate_points set to resolution of 5 mm, hsp_dec
# should be a bit over 5000 points. If not, something is wrong or
# decimation resolution has been purposefully changed
assert len(hsp_dec) > 5000
# should have similar size, distance from center
dist = np.sqrt(np.sum((hsp_m - np.mean(hsp_m, axis=0))**2, axis=1))
dist_dec = np.sqrt(np.sum((hsp_dec - np.mean(hsp_dec, axis=0))**2, axis=1))
hsp_rad = np.mean(dist)
hsp_dec_rad = np.mean(dist_dec)
assert_array_almost_equal(hsp_rad, hsp_dec_rad, decimal=3)
def test_decimate(tmpdir):
"""Test decimation of digitizer headshapes with too many points."""
# load headshape and convert to meters
hsp_mm = _get_ico_surface(5)['rr'] * 100
hsp_m = hsp_mm / 1000.
# save headshape to a file in mm in temporary directory
tempdir = str(tmpdir)
sphere_hsp_path = op.join(tempdir, 'test_sphere.txt')
np.savetxt(sphere_hsp_path, hsp_mm)
# read in raw data using spherical hsp, and extract new hsp
with pytest.warns(RuntimeWarning,
match='was automatically downsampled .* FastScan'):
raw = read_raw_kit(sqd_path, mrk_path, elp_txt_path, sphere_hsp_path)
# collect headshape from raw (should now be in m)
hsp_dec = np.array([dig['r'] for dig in raw.info['dig']])[8:]
# with 10242 points and _decimate_points set to resolution of 5 mm, hsp_dec
# should be a bit over 5000 points. If not, something is wrong or
# decimation resolution has been purposefully changed
assert len(hsp_dec) > 5000
# should have similar size, distance from center
dist = np.sqrt(np.sum((hsp_m - np.mean(hsp_m, axis=0))**2, axis=1))
dist_dec = np.sqrt(np.sum((hsp_dec - np.mean(hsp_dec, axis=0))**2, axis=1))
hsp_rad = np.mean(dist)
hsp_dec_rad = np.mean(dist_dec)
assert_array_almost_equal(hsp_rad, hsp_dec_rad, decimal=3)
def test_data():
"""Test reading raw kit files
"""
raw_py = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path,
stim=list(range(167, 159, -1)), slope='+',
stimthresh=1, preload=True)
print(repr(raw_py))
# Binary file only stores the sensor channels
py_picks = pick_types(raw_py.info, exclude='bads')
raw_bin = op.join(data_dir, 'test_bin_raw.fif')
raw_bin = Raw(raw_bin, preload=True)
bin_picks = pick_types(raw_bin.info, stim=True, exclude='bads')
data_bin, _ = raw_bin[bin_picks]
data_py, _ = raw_py[py_picks]
# this .mat was generated using the Yokogawa MEG Reader
data_Ykgw = op.join(data_dir, 'test_Ykgw.mat')
data_Ykgw = scipy.io.loadmat(data_Ykgw)['data']
data_Ykgw = data_Ykgw[py_picks]
assert_array_almost_equal(data_py, data_Ykgw)
py_picks = pick_types(raw_py.info, stim=True, ref_meg=False,
exclude='bads')
data_py, _ = raw_py[py_picks]
assert_array_almost_equal(data_py, data_bin)
# Make sure concatenation works
raw_concat = concatenate_raws([raw_py.copy(), raw_py])
assert_equal(raw_concat.n_times, 2 * raw_py.n_times)
def test_decimate():
"""Test decimation of digitizer headshapes with too many points."""
# load headshape and convert to meters
hsp_mm = _get_ico_surface(5)['rr'] * 100
hsp_m = hsp_mm / 1000.
# save headshape to a file in mm in temporary directory
tempdir = _TempDir()
sphere_hsp_path = op.join(tempdir, 'test_sphere.txt')
np.savetxt(sphere_hsp_path, hsp_mm)
# read in raw data using spherical hsp, and extract new hsp
with warnings.catch_warnings(record=True) as w:
raw = read_raw_kit(sqd_path, mrk_path, elp_txt_path, sphere_hsp_path)
assert_true(any('more than' in str(ww.message) for ww in w))
# collect headshape from raw (should now be in m)
hsp_dec = np.array([dig['r'] for dig in raw.info['dig']])[8:]
# with 10242 points and _decimate_points set to resolution of 5 mm, hsp_dec
# should be a bit over 5000 points. If not, something is wrong or
# decimation resolution has been purposefully changed
assert_true(len(hsp_dec) > 5000)
# should have similar size, distance from center
dist = np.sqrt(np.sum((hsp_m - np.mean(hsp_m, axis=0))**2, axis=1))
dist_dec = np.sqrt(np.sum((hsp_dec - np.mean(hsp_dec, axis=0))**2, axis=1))
hsp_rad = np.mean(dist)
hsp_dec_rad = np.mean(dist_dec)
assert_almost_equal(hsp_rad, hsp_dec_rad, places=3)
def test_plot_alignment_meg(renderer, system):
"""Test plotting of MEG sensors + helmet."""
if system == 'Neuromag':
this_info = read_info(evoked_fname)
elif system == 'CTF':
this_info = read_raw_ctf(ctf_fname).info
elif system == 'BTi':
this_info = read_raw_bti(pdf_fname,
config_fname,
hs_fname,
convert=True,
preload=False).info
else:
assert system == 'KIT'
this_info = read_raw_kit(sqd_fname).info
meg = ['helmet', 'sensors']
if system == 'KIT':
meg.append('ref')
fig = plot_alignment(this_info,
read_trans(trans_fname),
subject='sample',
subjects_dir=subjects_dir,
meg=meg,
eeg=False)
# count the number of objects: should be n_meg_ch + 1 (helmet) + 1 (head)
use_info = pick_info(
this_info,
pick_types(this_info,
meg=True,
eeg=False,
ref_meg='ref' in meg,
exclude=()))
n_actors = use_info['nchan'] + 2
_assert_n_actors(fig, renderer, n_actors)
def test_data():
"""Test reading raw kit files
"""
raw_py = read_raw_kit(sqd_path,
mrk_path,
elp_path,
hsp_path,
stim=list(range(167, 159, -1)),
slope='+',
stimthresh=1,
preload=True)
print(repr(raw_py))
# Binary file only stores the sensor channels
py_picks = pick_types(raw_py.info, exclude='bads')
raw_bin = op.join(data_dir, 'test_bin_raw.fif')
raw_bin = Raw(raw_bin, preload=True)
bin_picks = pick_types(raw_bin.info, stim=True, exclude='bads')
data_bin, _ = raw_bin[bin_picks]
data_py, _ = raw_py[py_picks]
# this .mat was generated using the Yokogawa MEG Reader
data_Ykgw = op.join(data_dir, 'test_Ykgw.mat')
data_Ykgw = scipy.io.loadmat(data_Ykgw)['data']
data_Ykgw = data_Ykgw[py_picks]
assert_array_almost_equal(data_py, data_Ykgw)
py_picks = pick_types(raw_py.info,
stim=True,
ref_meg=False,
exclude='bads')
data_py, _ = raw_py[py_picks]
assert_array_almost_equal(data_py, data_bin)
def test_data():
"""Test reading raw kit files
"""
assert_raises(TypeError, read_raw_kit, epochs_path)
assert_raises(TypeError, read_epochs_kit, sqd_path)
assert_raises(ValueError, read_raw_kit, sqd_path, mrk_path, elp_path)
assert_raises(ValueError, read_raw_kit, sqd_path, None, None, None,
list(range(200, 190, -1)))
assert_raises(ValueError, read_raw_kit, sqd_path, None, None, None,
list(range(167, 159, -1)), '*', 1, True)
# check functionality
_ = read_raw_kit(sqd_path, [mrk2_path, mrk3_path], elp_path, hsp_path)
raw_py = read_raw_kit(sqd_path,
mrk_path,
elp_path,
hsp_path,
stim=list(range(167, 159, -1)),
slope='+',
stimthresh=1,
preload=True)
assert_true('RawKIT' in repr(raw_py))
# Binary file only stores the sensor channels
py_picks = pick_types(raw_py.info, exclude='bads')
raw_bin = op.join(data_dir, 'test_bin_raw.fif')
raw_bin = Raw(raw_bin, preload=True)
bin_picks = pick_types(raw_bin.info, stim=True, exclude='bads')
data_bin, _ = raw_bin[bin_picks]
data_py, _ = raw_py[py_picks]
# this .mat was generated using the Yokogawa MEG Reader
data_Ykgw = op.join(data_dir, 'test_Ykgw.mat')
data_Ykgw = scipy.io.loadmat(data_Ykgw)['data']
data_Ykgw = data_Ykgw[py_picks]
assert_array_almost_equal(data_py, data_Ykgw)
py_picks = pick_types(raw_py.info,
stim=True,
ref_meg=False,
exclude='bads')
data_py, _ = raw_py[py_picks]
assert_array_almost_equal(data_py, data_bin)
# Make sure concatenation works
raw_concat = concatenate_raws([raw_py.copy(), raw_py])
assert_equal(raw_concat.n_times, 2 * raw_py.n_times)
def test_epochs():
raw = read_raw_kit(sqd_path, stim=None)
events = read_events(events_path)
raw_epochs = Epochs(raw, events, None, tmin=0, tmax=.099, baseline=None)
data1 = raw_epochs.get_data()
epochs = read_epochs_kit(epochs_path, events_path)
data11 = epochs.get_data()
assert_array_equal(data1, data11)
def test_epochs():
raw = read_raw_kit(sqd_path, stim=None)
events = read_events(events_path)
raw_epochs = Epochs(raw, events, None, tmin=0, tmax=.099, baseline=None)
data1 = raw_epochs.get_data()
epochs = read_epochs_kit(epochs_path, events_path)
data11 = epochs.get_data()
assert_array_equal(data1, data11)
def test_read_segment():
"""Test writing raw kit files when preload is False
"""
raw1 = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path, stim='<',
preload=False)
raw1_file = op.join(tempdir, 'test1-raw.fif')
raw1.save(raw1_file, buffer_size_sec=.1, overwrite=True)
raw2 = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path, stim='<',
preload=True)
raw2_file = op.join(tempdir, 'test2-raw.fif')
raw2.save(raw2_file, buffer_size_sec=.1, overwrite=True)
raw1 = Raw(raw1_file, preload=True)
raw2 = Raw(raw2_file, preload=True)
assert_array_equal(raw1._data, raw2._data)
raw3 = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path, stim='<',
preload=True)
assert_array_almost_equal(raw1._data, raw3._data)
def test_pick_refs():
"""Test picking of reference sensors
"""
infos = list()
# KIT
kit_dir = op.join(io_dir, 'kit', 'tests', 'data')
sqd_path = op.join(kit_dir, 'test.sqd')
mrk_path = op.join(kit_dir, 'test_mrk.sqd')
elp_path = op.join(kit_dir, 'test_elp.txt')
hsp_path = op.join(kit_dir, 'test_hsp.txt')
raw_kit = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path)
infos.append(raw_kit.info)
# BTi
bti_dir = op.join(io_dir, 'bti', 'tests', 'data')
bti_pdf = op.join(bti_dir, 'test_pdf_linux')
bti_config = op.join(bti_dir, 'test_config_linux')
bti_hs = op.join(bti_dir, 'test_hs_linux')
with warnings.catch_warnings(record=True): # weight tables
raw_bti = read_raw_bti(bti_pdf, bti_config, bti_hs, preload=False)
infos.append(raw_bti.info)
# CTF
fname_ctf_raw = op.join(io_dir, 'tests', 'data', 'test_ctf_comp_raw.fif')
raw_ctf = read_raw_fif(fname_ctf_raw, add_eeg_ref=False)
raw_ctf.apply_gradient_compensation(2)
infos.append(raw_ctf.info)
for info in infos:
info['bads'] = []
assert_raises(ValueError, pick_types, info, meg='foo')
assert_raises(ValueError, pick_types, info, ref_meg='foo')
picks_meg_ref = pick_types(info, meg=True, ref_meg=True)
picks_meg = pick_types(info, meg=True, ref_meg=False)
picks_ref = pick_types(info, meg=False, ref_meg=True)
assert_array_equal(picks_meg_ref,
np.sort(np.concatenate([picks_meg, picks_ref])))
picks_grad = pick_types(info, meg='grad', ref_meg=False)
picks_ref_grad = pick_types(info, meg=False, ref_meg='grad')
picks_meg_ref_grad = pick_types(info, meg='grad', ref_meg='grad')
assert_array_equal(picks_meg_ref_grad,
np.sort(np.concatenate([picks_grad,
picks_ref_grad])))
picks_mag = pick_types(info, meg='mag', ref_meg=False)
picks_ref_mag = pick_types(info, meg=False, ref_meg='mag')
picks_meg_ref_mag = pick_types(info, meg='mag', ref_meg='mag')
assert_array_equal(picks_meg_ref_mag,
np.sort(np.concatenate([picks_mag,
picks_ref_mag])))
assert_array_equal(picks_meg,
np.sort(np.concatenate([picks_mag, picks_grad])))
assert_array_equal(picks_ref,
np.sort(np.concatenate([picks_ref_mag,
picks_ref_grad])))
assert_array_equal(picks_meg_ref, np.sort(np.concatenate(
[picks_grad, picks_mag, picks_ref_grad, picks_ref_mag])))
for pick in (picks_meg_ref, picks_meg, picks_ref,
picks_grad, picks_ref_grad, picks_meg_ref_grad,
picks_mag, picks_ref_mag, picks_meg_ref_mag):
if len(pick) > 0:
pick_info(info, pick)
def run():
"""Run command."""
from mne.commands.utils import get_optparser
parser = get_optparser(__file__)
parser.add_option('--input', dest='input_fname',
help='Input data file name', metavar='filename')
parser.add_option('--mrk', dest='mrk_fname',
help='MEG Marker file name', metavar='filename')
parser.add_option('--elp', dest='elp_fname',
help='Headshape points file name', metavar='filename')
parser.add_option('--hsp', dest='hsp_fname',
help='Headshape file name', metavar='filename')
parser.add_option('--stim', dest='stim',
help='Colon Separated Stimulus Trigger Channels',
metavar='chs')
parser.add_option('--slope', dest='slope', help='Slope direction',
metavar='slope')
parser.add_option('--stimthresh', dest='stimthresh', default=1,
help='Threshold value for trigger channels',
metavar='value')
parser.add_option('--output', dest='out_fname',
help='Name of the resulting fiff file',
metavar='filename')
parser.add_option('--debug', dest='debug', action='store_true',
default=False,
help='Set logging level for terminal output to debug')
options, args = parser.parse_args()
if options.debug:
mne.set_log_level('debug')
input_fname = options.input_fname
if input_fname is None:
with ETSContext():
mne.gui.kit2fiff()
sys.exit(0)
hsp_fname = options.hsp_fname
elp_fname = options.elp_fname
mrk_fname = options.mrk_fname
stim = options.stim
slope = options.slope
stimthresh = options.stimthresh
out_fname = options.out_fname
if isinstance(stim, str):
stim = map(int, stim.split(':'))
raw = read_raw_kit(input_fname=input_fname, mrk=mrk_fname, elp=elp_fname,
hsp=hsp_fname, stim=stim, slope=slope,
stimthresh=stimthresh)
raw.save(out_fname)
raw.close()
sys.exit(0)
def run():
"""Run command."""
from mne.commands.utils import get_optparser
parser = get_optparser(__file__)
parser.add_option('--input', dest='input_fname',
help='Input data file name', metavar='filename')
parser.add_option('--mrk', dest='mrk_fname',
help='MEG Marker file name', metavar='filename')
parser.add_option('--elp', dest='elp_fname',
help='Headshape points file name', metavar='filename')
parser.add_option('--hsp', dest='hsp_fname',
help='Headshape file name', metavar='filename')
parser.add_option('--stim', dest='stim',
help='Colon Separated Stimulus Trigger Channels',
metavar='chs')
parser.add_option('--slope', dest='slope', help='Slope direction',
metavar='slope')
parser.add_option('--stimthresh', dest='stimthresh', default=1,
help='Threshold value for trigger channels',
metavar='value')
parser.add_option('--output', dest='out_fname',
help='Name of the resulting fiff file',
metavar='filename')
parser.add_option('--debug', dest='debug', action='store_true',
default=False,
help='Set logging level for terminal output to debug')
options, args = parser.parse_args()
if options.debug:
mne.set_log_level('debug')
input_fname = options.input_fname
if input_fname is None:
with ETSContext():
mne.gui.kit2fiff()
sys.exit(0)
hsp_fname = options.hsp_fname
elp_fname = options.elp_fname
mrk_fname = options.mrk_fname
stim = options.stim
slope = options.slope
stimthresh = options.stimthresh
out_fname = options.out_fname
if isinstance(stim, str):
stim = map(int, stim.split(':'))
raw = read_raw_kit(input_fname=input_fname, mrk=mrk_fname, elp=elp_fname,
hsp=hsp_fname, stim=stim, slope=slope,
stimthresh=stimthresh)
raw.save(out_fname)
raw.close()
def test_hsp_elp():
"""Test KIT usage of *.elp and *.hsp files against *.txt files."""
raw_txt = read_raw_kit(sqd_path, mrk_path, elp_txt_path, hsp_txt_path)
raw_elp = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path)
# head points
pts_txt = np.array([dig_point['r'] for dig_point in raw_txt.info['dig']])
pts_elp = np.array([dig_point['r'] for dig_point in raw_elp.info['dig']])
assert_array_almost_equal(pts_elp, pts_txt, decimal=5)
# transforms
trans_txt = raw_txt.info['dev_head_t']['trans']
trans_elp = raw_elp.info['dev_head_t']['trans']
assert_array_almost_equal(trans_elp, trans_txt, decimal=5)
# head points in device space
pts_txt_in_dev = apply_trans(linalg.inv(trans_txt), pts_txt)
pts_elp_in_dev = apply_trans(linalg.inv(trans_elp), pts_elp)
assert_array_almost_equal(pts_elp_in_dev, pts_txt_in_dev, decimal=5)
def test_epochs():
"""Test reading epoched SQD file."""
raw = read_raw_kit(sqd_path, stim=None)
events = read_events(events_path)
raw_epochs = Epochs(raw, events, None, tmin=0, tmax=.099, baseline=None,
add_eeg_ref=False)
data1 = raw_epochs.get_data()
epochs = read_epochs_kit(epochs_path, events_path)
data11 = epochs.get_data()
assert_array_equal(data1, data11)
def test_hsp_elp():
"""Test KIT usage of *.elp and *.hsp files against *.txt files."""
raw_txt = read_raw_kit(sqd_path, mrk_path, elp_txt_path, hsp_txt_path)
raw_elp = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path)
# head points
pts_txt = np.array([dig_point['r'] for dig_point in raw_txt.info['dig']])
pts_elp = np.array([dig_point['r'] for dig_point in raw_elp.info['dig']])
assert_array_almost_equal(pts_elp, pts_txt, decimal=5)
# transforms
trans_txt = raw_txt.info['dev_head_t']['trans']
trans_elp = raw_elp.info['dev_head_t']['trans']
assert_array_almost_equal(trans_elp, trans_txt, decimal=5)
# head points in device space
pts_txt_in_dev = apply_trans(linalg.inv(trans_txt), pts_txt)
pts_elp_in_dev = apply_trans(linalg.inv(trans_elp), pts_elp)
assert_array_almost_equal(pts_elp_in_dev, pts_txt_in_dev, decimal=5)
def test_stim_ch():
"""Test raw kit stim ch
"""
raw = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path, stim='<',
slope='+', preload=True)
stim_pick = pick_types(raw.info, meg=False, ref_meg=False,
stim=True, exclude='bads')
stim1, _ = raw[stim_pick]
stim2 = np.array(raw.read_stim_ch(), ndmin=2)
assert_array_equal(stim1, stim2)
def test_unknown_format(tmp_path):
"""Test our warning about an unknown format."""
fname = tmp_path / op.basename(ricoh_path)
_, kit_info = get_kit_info(ricoh_path, allow_unknown_format=False)
n_before = kit_info['dirs'][KIT.DIR_INDEX_SYSTEM]['offset']
with open(fname, 'wb') as fout:
with open(ricoh_path, 'rb') as fin:
fout.write(fin.read(n_before))
version, revision = np.fromfile(fin, '<i4', 2)
assert version > 2 # good
version = 1 # bad
np.array([version, revision], '<i4').tofile(fout)
fout.write(fin.read())
with pytest.raises(ValueError, match='SQD file format V1R000 is not offi'):
read_raw_kit(fname)
# it's not actually an old file, so it actually raises an exception later
# about an unknown datatype
with pytest.raises(Exception):
with pytest.warns(RuntimeWarning, match='Force loading'):
read_raw_kit(fname, allow_unknown_format=True)
def test_ricoh_data(tmpdir, fname, desc):
"""Test reading channel names and dig information from Ricoh systems."""
with pytest.deprecated_call(match='standardize_names'):
raw = read_raw_kit(fname)
assert raw.ch_names[0] == 'MEG 001'
raw = read_raw_kit(fname, standardize_names=False, verbose='debug')
assert raw.info['description'] == desc
assert_allclose(raw.times[-1], 5. - 1. / raw.info['sfreq'])
assert raw.ch_names[0] == 'LF31'
eeg_picks = pick_types(raw.info, meg=False, eeg=True)
assert len(eeg_picks) == 45
assert len(raw.info['dig']) == 8 + len(eeg_picks) - 2 # EKG+ and E no pos
bad_dig = [
ch['ch_name'] for ci, ch in enumerate(raw.info['chs'])
if ci in eeg_picks and (ch['loc'][:3] == 0).all()
]
assert bad_dig == ['EKG+', 'E']
assert not any(np.allclose(d['r'], 0.) for d in raw.info['dig'])
assert_allclose(
raw.info['dev_head_t']['trans'],
[[0.998311, -0.056923, 0.01164, 0.001403],
[0.054469, 0.986653, 0.153458, 0.0044],
[-0.02022, -0.152564, 0.988087, 0.018634], [0., 0., 0., 1.]],
atol=1e-5)
data = raw.get_data()
# 1 pT 10 Hz on the first channel
assert raw.info['chs'][0]['coil_type'] == FIFF.FIFFV_COIL_KIT_GRAD
_assert_sinusoid(data[0], raw.times, 10, 1e-12, '1 pT 10 Hz MEG')
assert_allclose(data[1:160], 0., atol=1e-13)
# 1 V 5 Hz analog
assert raw.info['chs'][186]['coil_type'] == FIFF.FIFFV_COIL_EEG
_assert_sinusoid(data[160], raw.times, 5, 1, '1 V 5 Hz analog')
assert_allclose(data[161:185], 0., atol=1e-20)
# 50 uV 8 Hz plus 1.6 mV offset
assert raw.info['chs'][186]['coil_type'] == FIFF.FIFFV_COIL_EEG
eeg_data = data[186]
assert_allclose(eeg_data.mean(), 1.6e-3, atol=1e-5) # offset
eeg_data = eeg_data - eeg_data.mean()
_assert_sinusoid(eeg_data, raw.times, 8, 50e-6, '50 uV 8 Hz EEG')
assert_allclose(data[187:-1], 0., atol=1e-20)
assert_allclose(data[-1], 254.5, atol=0.51)
def test_data():
"""Test reading raw kit files
"""
assert_raises(TypeError, read_raw_kit, epochs_path)
assert_raises(TypeError, read_epochs_kit, sqd_path)
assert_raises(ValueError, read_raw_kit, sqd_path, mrk_path, elp_path)
assert_raises(ValueError, read_raw_kit, sqd_path, None, None, None,
list(range(200, 190, -1)))
assert_raises(ValueError, read_raw_kit, sqd_path, None, None, None,
list(range(167, 159, -1)), '*', 1, True)
# check functionality
_ = read_raw_kit(sqd_path, [mrk2_path, mrk3_path], elp_path,
hsp_path)
raw_py = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path,
stim=list(range(167, 159, -1)), slope='+',
stimthresh=1, preload=True)
assert_true('RawKIT' in repr(raw_py))
# Binary file only stores the sensor channels
py_picks = pick_types(raw_py.info, exclude='bads')
raw_bin = op.join(data_dir, 'test_bin_raw.fif')
raw_bin = Raw(raw_bin, preload=True)
bin_picks = pick_types(raw_bin.info, stim=True, exclude='bads')
data_bin, _ = raw_bin[bin_picks]
data_py, _ = raw_py[py_picks]
# this .mat was generated using the Yokogawa MEG Reader
data_Ykgw = op.join(data_dir, 'test_Ykgw.mat')
data_Ykgw = scipy.io.loadmat(data_Ykgw)['data']
data_Ykgw = data_Ykgw[py_picks]
assert_array_almost_equal(data_py, data_Ykgw)
py_picks = pick_types(raw_py.info, stim=True, ref_meg=False,
exclude='bads')
data_py, _ = raw_py[py_picks]
assert_array_almost_equal(data_py, data_bin)
# Make sure concatenation works
raw_concat = concatenate_raws([raw_py.copy(), raw_py])
assert_equal(raw_concat.n_times, 2 * raw_py.n_times)
def test_calculate_head_pos_kit():
"""Test calculation of head position using KIT data."""
raw = read_raw_kit(con_fname, mrk_fname, elp_fname, hsp_fname)
assert len(raw.info['hpi_results']) == 1
chpi_locs = extract_chpi_locs_kit(raw)
assert chpi_locs['rrs'].shape == (2, 5, 3)
assert_array_less(chpi_locs['gofs'], 1.)
assert_array_less(0.98, chpi_locs['gofs'])
quats = compute_head_pos(raw.info, chpi_locs)
assert quats.shape == (2, 10)
# plotting works
plot_head_positions(quats, info=raw.info)
raw_berlin = read_raw_kit(berlin_fname)
assert_allclose(raw_berlin.info['dev_head_t']['trans'], np.eye(4))
assert len(raw_berlin.info['hpi_results']) == 0
with pytest.raises(ValueError, match='Invalid value'):
extract_chpi_locs_kit(raw_berlin)
with pytest.raises(RuntimeError, match='not find appropriate'):
extract_chpi_locs_kit(raw_berlin, 'STI 014')
with pytest.raises(RuntimeError, match='no initial cHPI'):
compute_head_pos(raw_berlin.info, chpi_locs)
def _read_raw(raw_fpath,
electrode=None,
hsp=None,
hpi=None,
allow_maxshield=False,
config=None,
**kwargs):
"""Read a raw file into MNE, making inferences based on extension."""
_, ext = _parse_ext(raw_fpath)
# KIT systems
if ext in ['.con', '.sqd']:
raw = io.read_raw_kit(raw_fpath,
elp=electrode,
hsp=hsp,
mrk=hpi,
preload=False,
**kwargs)
# BTi systems
elif ext == '.pdf':
raw = io.read_raw_bti(raw_fpath,
config_fname=config,
head_shape_fname=hsp,
preload=False,
**kwargs)
elif ext == '.fif':
raw = reader[ext](raw_fpath, allow_maxshield, **kwargs)
elif ext in ['.ds', '.vhdr', '.set', '.edf', '.bdf', '.EDF']:
raw_fpath = Path(raw_fpath)
# handle EDF extension upper/lower casing
if ext == '.edf' and not raw_fpath.exists():
raw_fpath = raw_fpath.with_suffix('.EDF')
elif ext == '.EDF' and not raw_fpath.exists():
raw_fpath = raw_fpath.with_suffix('.edf')
raw = reader[ext](raw_fpath, **kwargs)
# MEF and NWB are allowed, but not yet implemented
elif ext in ['.mef', '.nwb']:
raise ValueError(f'Got "{ext}" as extension. This is an allowed '
f'extension but there is no IO support for this '
f'file format yet.')
# No supported data found ...
# ---------------------------
else:
raise ValueError(f'Raw file name extension must be one '
f'of {ALLOWED_DATATYPE_EXTENSIONS}\n'
f'Got {ext}')
return raw
def _read_raw(raw_path,
electrode=None,
hsp=None,
hpi=None,
allow_maxshield=False,
config_path=None,
**kwargs):
"""Read a raw file into MNE, making inferences based on extension."""
_, ext = _parse_ext(raw_path)
# KIT systems
if ext in ['.con', '.sqd']:
raw = io.read_raw_kit(raw_path,
elp=electrode,
hsp=hsp,
mrk=hpi,
preload=False,
**kwargs)
# BTi systems
elif ext == '.pdf':
raw = io.read_raw_bti(
pdf_fname=str(raw_path), # FIXME MNE should accept Path!
config_fname=str(config_path), # FIXME MNE should accept Path!
head_shape_fname=hsp,
preload=False,
**kwargs)
elif ext == '.fif':
raw = reader[ext](raw_path, allow_maxshield, **kwargs)
elif ext in ['.ds', '.vhdr', '.set', '.edf', '.bdf', '.EDF', '.snirf']:
if (ext == '.snirf'
and not check_version('mne', '1.0')): # pragma: no cover
raise RuntimeError(
'fNIRS support in MNE-BIDS requires MNE-Python version 1.0')
raw_path = Path(raw_path)
raw = reader[ext](raw_path, **kwargs)
# MEF and NWB are allowed, but not yet implemented
elif ext in ['.mef', '.nwb']:
raise ValueError(f'Got "{ext}" as extension. This is an allowed '
f'extension but there is no IO support for this '
f'file format yet.')
# No supported data found ...
# ---------------------------
else:
raise ValueError(f'Raw file name extension must be one '
f'of {ALLOWED_DATATYPE_EXTENSIONS}\n'
f'Got {ext}')
return raw
def _read_raw(raw_fpath,
electrode=None,
hsp=None,
hpi=None,
config=None,
verbose=None,
**kwargs):
"""Read a raw file into MNE, making inferences based on extension."""
_, ext = _parse_ext(raw_fpath)
# KIT systems
if ext in ['.con', '.sqd']:
raw = io.read_raw_kit(raw_fpath,
elp=electrode,
hsp=hsp,
mrk=hpi,
preload=False,
**kwargs)
# BTi systems
elif ext == '.pdf':
raw = io.read_raw_bti(raw_fpath,
config_fname=config,
head_shape_fname=hsp,
preload=False,
verbose=verbose,
**kwargs)
elif ext == '.fif':
raw = reader[ext](raw_fpath, **kwargs)
elif ext in ['.ds', '.vhdr', '.set']:
raw = reader[ext](raw_fpath, **kwargs)
# EDF (european data format) or BDF (biosemi) format
# TODO: integrate with lines above once MNE can read
# annotations with preload=False
elif ext in ['.edf', '.bdf']:
raw = reader[ext](raw_fpath, preload=True, **kwargs)
# MEF and NWB are allowed, but not yet implemented
elif ext in ['.mef', '.nwb']:
raise ValueError(
'Got "{}" as extension. This is an allowed extension '
'but there is no IO support for this file format yet.'.format(ext))
# No supported data found ...
# ---------------------------
else:
raise ValueError('Raw file name extension must be one of {}\n'
'Got {}'.format(ALLOWED_EXTENSIONS, ext))
return raw
def run():
from mne.commands.utils import get_optparser
parser = get_optparser(__file__)
parser.add_option('--input', dest='input_fname',
help='Input data file name', metavar='filename')
parser.add_option('--mrk', dest='mrk_fname',
help='MEG Marker file name', metavar='filename')
parser.add_option('--elp', dest='elp_fname',
help='Headshape points file name', metavar='filename')
parser.add_option('--hsp', dest='hsp_fname',
help='Headshape file name', metavar='filename')
parser.add_option('--stim', dest='stim',
help='Colon Separated Stimulus Trigger Channels',
metavar='chs')
parser.add_option('--slope', dest='slope', help='Slope direction',
metavar='slope')
parser.add_option('--stimthresh', dest='stimthresh', default=1,
help='Threshold value for trigger channels',
metavar='value')
parser.add_option('--output', dest='out_fname',
help='Name of the resulting fiff file',
metavar='filename')
options, args = parser.parse_args()
input_fname = options.input_fname
if input_fname is None:
os.environ['ETS_TOOLKIT'] = 'qt4'
mne.gui.kit2fiff()
sys.exit(0)
hsp_fname = options.hsp_fname
elp_fname = options.elp_fname
mrk_fname = options.mrk_fname
stim = options.stim
slope = options.slope
stimthresh = options.stimthresh
out_fname = options.out_fname
if isinstance(stim, str):
stim = stim.split(':')
raw = read_raw_kit(input_fname=input_fname, mrk=mrk_fname, elp=elp_fname,
hsp=hsp_fname, stim=stim, slope=slope,
stimthresh=stimthresh)
raw.save(out_fname)
raw.close()
sys.exit(0)
def test_berlin():
"""Test data from Berlin."""
# gh-8535
raw = read_raw_kit(berlin_path)
assert raw.info['description'] == 'Physikalisch Technische Bundesanstalt, Berlin/128-channel MEG System (124) V2R004 PQ1128R-N2' # noqa: E501
assert raw.info['kit_system_id'] == 124
assert raw.info['highpass'] == 0.
assert raw.info['lowpass'] == 200.
assert raw.info['sfreq'] == 500.
n = int(round(28.77 * raw.info['sfreq']))
meg = raw.get_data('MEG 003', n, n + 1)[0, 0]
assert_allclose(meg, -8.89e-12, rtol=1e-3)
eeg = raw.get_data('E14', n, n + 1)[0, 0]
assert_allclose(eeg, -2.55, rtol=1e-3)
def test_epochs():
"""Test reading epoched SQD file."""
raw = read_raw_kit(sqd_path, stim=None)
events = read_events(events_path)
raw_epochs = Epochs(raw,
events,
None,
tmin=0,
tmax=.099,
baseline=None,
add_eeg_ref=False)
data1 = raw_epochs.get_data()
epochs = read_epochs_kit(epochs_path, events_path)
data11 = epochs.get_data()
assert_array_equal(data1, data11)
def run():
from mne.commands.utils import get_optparser
parser = get_optparser(__file__)
parser.add_option("--input", dest="input_fname", help="Input data file name", metavar="filename")
parser.add_option("--mrk", dest="mrk_fname", help="MEG Marker file name", metavar="filename")
parser.add_option("--elp", dest="elp_fname", help="Headshape points file name", metavar="filename")
parser.add_option("--hsp", dest="hsp_fname", help="Headshape file name", metavar="filename")
parser.add_option("--stim", dest="stim", help="Colon Separated Stimulus Trigger Channels", metavar="chs")
parser.add_option("--slope", dest="slope", help="Slope direction", metavar="slope")
parser.add_option(
"--stimthresh", dest="stimthresh", default=1, help="Threshold value for trigger channels", metavar="value"
)
parser.add_option("--output", dest="out_fname", help="Name of the resulting fiff file", metavar="filename")
options, args = parser.parse_args()
input_fname = options.input_fname
if input_fname is None:
os.environ["ETS_TOOLKIT"] = "qt4"
mne.gui.kit2fiff()
sys.exit(0)
hsp_fname = options.hsp_fname
elp_fname = options.elp_fname
mrk_fname = options.mrk_fname
stim = options.stim
slope = options.slope
stimthresh = options.stimthresh
out_fname = options.out_fname
if isinstance(stim, str):
stim = map(int, stim.split(":"))
raw = read_raw_kit(
input_fname=input_fname,
mrk=mrk_fname,
elp=elp_fname,
hsp=hsp_fname,
stim=stim,
slope=slope,
stimthresh=stimthresh,
)
raw.save(out_fname)
raw.close()
sys.exit(0)
def test_plot_trans():
"""Test plotting of -trans.fif files and MEG sensor layouts."""
from mayavi import mlab
evoked = read_evokeds(evoked_fname)[0]
with warnings.catch_warnings(record=True): # 4D weight tables
bti = read_raw_bti(pdf_fname, config_fname, hs_fname, convert=True,
preload=False).info
infos = dict(
Neuromag=evoked.info,
CTF=read_raw_ctf(ctf_fname).info,
BTi=bti,
KIT=read_raw_kit(sqd_fname).info,
)
for system, info in infos.items():
ref_meg = False if system == 'KIT' else True
plot_trans(info, trans_fname, subject='sample', meg_sensors=True,
subjects_dir=subjects_dir, ref_meg=ref_meg)
mlab.close(all=True)
# KIT ref sensor coil def is defined
plot_trans(infos['KIT'], None, meg_sensors=True, ref_meg=True)
mlab.close(all=True)
info = infos['Neuromag']
assert_raises(ValueError, plot_trans, info, trans_fname,
subject='sample', subjects_dir=subjects_dir,
ch_type='bad-chtype')
assert_raises(TypeError, plot_trans, 'foo', trans_fname,
subject='sample', subjects_dir=subjects_dir)
# no-head version
plot_trans(info, None, meg_sensors=True, dig=True, coord_frame='head')
mlab.close(all=True)
# all coord frames
for coord_frame in ('meg', 'head', 'mri'):
plot_trans(info, meg_sensors=True, dig=True, coord_frame=coord_frame,
trans=trans_fname, subject='sample',
subjects_dir=subjects_dir)
mlab.close(all=True)
# EEG only with strange options
evoked_eeg_ecog = evoked.copy().pick_types(meg=False, eeg=True)
evoked_eeg_ecog.info['projs'] = [] # "remove" avg proj
evoked_eeg_ecog.set_channel_types({'EEG 001': 'ecog'})
with warnings.catch_warnings(record=True) as w:
plot_trans(evoked_eeg_ecog.info, subject='sample', trans=trans_fname,
source='outer_skin', meg_sensors=True, skull=True,
eeg_sensors=['original', 'projected'], ecog_sensors=True,
brain='white', head=True, subjects_dir=subjects_dir)
mlab.close(all=True)
assert_true(['Cannot plot MEG' in str(ww.message) for ww in w])
def test_find_ch_adjacency():
"""Test computing the adjacency matrix."""
data_path = testing.data_path()
raw = read_raw_fif(raw_fname, preload=True)
sizes = {'mag': 828, 'grad': 1700, 'eeg': 386}
nchans = {'mag': 102, 'grad': 204, 'eeg': 60}
for ch_type in ['mag', 'grad', 'eeg']:
conn, ch_names = find_ch_adjacency(raw.info, ch_type)
# Silly test for checking the number of neighbors.
assert_equal(conn.getnnz(), sizes[ch_type])
assert_equal(len(ch_names), nchans[ch_type])
pytest.raises(ValueError, find_ch_adjacency, raw.info, None)
# Test computing the conn matrix with gradiometers.
conn, ch_names = _compute_ch_adjacency(raw.info, 'grad')
assert_equal(conn.getnnz(), 2680)
# Test ch_type=None.
raw.pick_types(meg='mag')
find_ch_adjacency(raw.info, None)
bti_fname = op.join(data_path, 'BTi', 'erm_HFH', 'c,rfDC')
bti_config_name = op.join(data_path, 'BTi', 'erm_HFH', 'config')
raw = read_raw_bti(bti_fname, bti_config_name, None)
_, ch_names = find_ch_adjacency(raw.info, 'mag')
assert 'A1' in ch_names
ctf_fname = op.join(data_path, 'CTF', 'testdata_ctf_short.ds')
raw = read_raw_ctf(ctf_fname)
_, ch_names = find_ch_adjacency(raw.info, 'mag')
assert 'MLC11' in ch_names
pytest.raises(ValueError, find_ch_adjacency, raw.info, 'eog')
raw_kit = read_raw_kit(fname_kit_157)
neighb, ch_names = find_ch_adjacency(raw_kit.info, 'mag')
assert neighb.data.size == 1329
assert ch_names[0] == 'MEG 001'
def test_find_layout():
"""Test finding layout."""
pytest.raises(ValueError, find_layout, _get_test_info(), ch_type='meep')
sample_info = read_info(fif_fname)
grads = pick_types(sample_info, meg='grad')
sample_info2 = pick_info(sample_info, grads)
mags = pick_types(sample_info, meg='mag')
sample_info3 = pick_info(sample_info, mags)
# mock new convention
sample_info4 = copy.deepcopy(sample_info)
for ii, name in enumerate(sample_info4['ch_names']):
new = name.replace(' ', '')
sample_info4['chs'][ii]['ch_name'] = new
eegs = pick_types(sample_info, meg=False, eeg=True)
sample_info5 = pick_info(sample_info, eegs)
lout = find_layout(sample_info, ch_type=None)
assert lout.kind == 'Vectorview-all'
assert all(' ' in k for k in lout.names)
lout = find_layout(sample_info2, ch_type='meg')
assert_equal(lout.kind, 'Vectorview-all')
# test new vector-view
lout = find_layout(sample_info4, ch_type=None)
assert_equal(lout.kind, 'Vectorview-all')
assert all(' ' not in k for k in lout.names)
lout = find_layout(sample_info, ch_type='grad')
assert_equal(lout.kind, 'Vectorview-grad')
lout = find_layout(sample_info2)
assert_equal(lout.kind, 'Vectorview-grad')
lout = find_layout(sample_info2, ch_type='grad')
assert_equal(lout.kind, 'Vectorview-grad')
lout = find_layout(sample_info2, ch_type='meg')
assert_equal(lout.kind, 'Vectorview-all')
lout = find_layout(sample_info, ch_type='mag')
assert_equal(lout.kind, 'Vectorview-mag')
lout = find_layout(sample_info3)
assert_equal(lout.kind, 'Vectorview-mag')
lout = find_layout(sample_info3, ch_type='mag')
assert_equal(lout.kind, 'Vectorview-mag')
lout = find_layout(sample_info3, ch_type='meg')
assert_equal(lout.kind, 'Vectorview-all')
lout = find_layout(sample_info, ch_type='eeg')
assert_equal(lout.kind, 'EEG')
lout = find_layout(sample_info5)
assert_equal(lout.kind, 'EEG')
lout = find_layout(sample_info5, ch_type='eeg')
assert_equal(lout.kind, 'EEG')
# no common layout, 'meg' option not supported
lout = find_layout(read_info(fname_ctf_raw))
assert_equal(lout.kind, 'CTF-275')
fname_bti_raw = op.join(bti_dir, 'exported4D_linux_raw.fif')
lout = find_layout(read_info(fname_bti_raw))
assert_equal(lout.kind, 'magnesWH3600')
raw_kit = read_raw_kit(fname_kit_157)
lout = find_layout(raw_kit.info)
assert_equal(lout.kind, 'KIT-157')
raw_kit.info['bads'] = ['MEG 013', 'MEG 014', 'MEG 015', 'MEG 016']
raw_kit.info._check_consistency()
lout = find_layout(raw_kit.info)
assert_equal(lout.kind, 'KIT-157')
# fallback for missing IDs
for val in (35, 52, 54, 1001):
raw_kit.info['kit_system_id'] = val
lout = find_layout(raw_kit.info)
assert lout.kind == 'custom'
raw_umd = read_raw_kit(fname_kit_umd)
lout = find_layout(raw_umd.info)
assert_equal(lout.kind, 'KIT-UMD-3')
# Test plotting
lout.plot()
lout.plot(picks=np.arange(10))
plt.close('all')
def test_data():
"""Test reading raw kit files."""
assert_raises(TypeError, read_raw_kit, epochs_path)
assert_raises(TypeError, read_epochs_kit, sqd_path)
assert_raises(ValueError, read_raw_kit, sqd_path, mrk_path, elp_txt_path)
assert_raises(ValueError, read_raw_kit, sqd_path, None, None, None,
list(range(200, 190, -1)))
assert_raises(ValueError, read_raw_kit, sqd_path, None, None, None,
list(range(167, 159, -1)), '*', 1, True)
# check functionality
raw_mrk = read_raw_kit(sqd_path, [mrk2_path, mrk3_path], elp_txt_path,
hsp_txt_path)
raw_py = _test_raw_reader(read_raw_kit, input_fname=sqd_path, mrk=mrk_path,
elp=elp_txt_path, hsp=hsp_txt_path,
stim=list(range(167, 159, -1)), slope='+',
stimthresh=1)
assert_true('RawKIT' in repr(raw_py))
assert_equal(raw_mrk.info['kit_system_id'], KIT.SYSTEM_NYU_2010)
# check number/kind of channels
assert_equal(len(raw_py.info['chs']), 193)
kit_channels = (('kind', {FIFF.FIFFV_MEG_CH: 157, FIFF.FIFFV_REF_MEG_CH: 3,
FIFF.FIFFV_MISC_CH: 32, FIFF.FIFFV_STIM_CH: 1}),
('coil_type', {FIFF.FIFFV_COIL_KIT_GRAD: 157,
FIFF.FIFFV_COIL_KIT_REF_MAG: 3,
FIFF.FIFFV_COIL_NONE: 33}))
for label, target in kit_channels:
actual = {id_: sum(ch[label] == id_ for ch in raw_py.info['chs']) for
id_ in target.keys()}
assert_equal(actual, target)
# Test stim channel
raw_stim = read_raw_kit(sqd_path, mrk_path, elp_txt_path, hsp_txt_path,
stim='<', preload=False)
for raw in [raw_py, raw_stim, raw_mrk]:
stim_pick = pick_types(raw.info, meg=False, ref_meg=False,
stim=True, exclude='bads')
stim1, _ = raw[stim_pick]
stim2 = np.array(raw.read_stim_ch(), ndmin=2)
assert_array_equal(stim1, stim2)
# Binary file only stores the sensor channels
py_picks = pick_types(raw_py.info, exclude='bads')
raw_bin = op.join(data_dir, 'test_bin_raw.fif')
raw_bin = read_raw_fif(raw_bin, preload=True)
bin_picks = pick_types(raw_bin.info, stim=True, exclude='bads')
data_bin, _ = raw_bin[bin_picks]
data_py, _ = raw_py[py_picks]
# this .mat was generated using the Yokogawa MEG Reader
data_Ykgw = op.join(data_dir, 'test_Ykgw.mat')
data_Ykgw = scipy.io.loadmat(data_Ykgw)['data']
data_Ykgw = data_Ykgw[py_picks]
assert_array_almost_equal(data_py, data_Ykgw)
py_picks = pick_types(raw_py.info, stim=True, ref_meg=False,
exclude='bads')
data_py, _ = raw_py[py_picks]
assert_array_almost_equal(data_py, data_bin)
# KIT-UMD data
_test_raw_reader(read_raw_kit, input_fname=sqd_umd_path)
raw = read_raw_kit(sqd_umd_path)
assert_equal(raw.info['kit_system_id'], KIT.SYSTEM_UMD_2014_12)
# check number/kind of channels
assert_equal(len(raw.info['chs']), 193)
for label, target in kit_channels:
actual = {id_: sum(ch[label] == id_ for ch in raw.info['chs']) for
id_ in target.keys()}
assert_equal(actual, target)
# KIT Academia Sinica
raw = read_raw_kit(sqd_as_path, slope='+')
assert_equal(raw.info['kit_system_id'], KIT.SYSTEM_AS_2008)
assert_equal(raw.info['chs'][100]['ch_name'], 'MEG 101')
assert_equal(raw.info['chs'][100]['kind'], FIFF.FIFFV_MEG_CH)
assert_equal(raw.info['chs'][100]['coil_type'], FIFF.FIFFV_COIL_KIT_GRAD)
assert_equal(raw.info['chs'][157]['ch_name'], 'MEG 158')
assert_equal(raw.info['chs'][157]['kind'], FIFF.FIFFV_REF_MEG_CH)
assert_equal(raw.info['chs'][157]['coil_type'],
FIFF.FIFFV_COIL_KIT_REF_MAG)
assert_equal(raw.info['chs'][160]['ch_name'], 'EEG 001')
assert_equal(raw.info['chs'][160]['kind'], FIFF.FIFFV_EEG_CH)
assert_equal(raw.info['chs'][160]['coil_type'], FIFF.FIFFV_COIL_EEG)
assert_array_equal(find_events(raw), [[91, 0, 2]])
def test_plot_alignment(tmpdir):
"""Test plotting of -trans.fif files and MEG sensor layouts."""
# generate fiducials file for testing
tempdir = str(tmpdir)
fiducials_path = op.join(tempdir, 'fiducials.fif')
fid = [{'coord_frame': 5, 'ident': 1, 'kind': 1,
'r': [-0.08061612, -0.02908875, -0.04131077]},
{'coord_frame': 5, 'ident': 2, 'kind': 1,
'r': [0.00146763, 0.08506715, -0.03483611]},
{'coord_frame': 5, 'ident': 3, 'kind': 1,
'r': [0.08436285, -0.02850276, -0.04127743]}]
write_dig(fiducials_path, fid, 5)
mlab = _import_mlab()
evoked = read_evokeds(evoked_fname)[0]
sample_src = read_source_spaces(src_fname)
bti = read_raw_bti(pdf_fname, config_fname, hs_fname, convert=True,
preload=False).info
infos = dict(
Neuromag=evoked.info,
CTF=read_raw_ctf(ctf_fname).info,
BTi=bti,
KIT=read_raw_kit(sqd_fname).info,
)
for system, info in infos.items():
meg = ['helmet', 'sensors']
if system == 'KIT':
meg.append('ref')
plot_alignment(info, trans_fname, subject='sample',
subjects_dir=subjects_dir, meg=meg)
mlab.close(all=True)
# KIT ref sensor coil def is defined
mlab.close(all=True)
info = infos['Neuromag']
pytest.raises(TypeError, plot_alignment, 'foo', trans_fname,
subject='sample', subjects_dir=subjects_dir)
pytest.raises(TypeError, plot_alignment, info, trans_fname,
subject='sample', subjects_dir=subjects_dir, src='foo')
pytest.raises(ValueError, plot_alignment, info, trans_fname,
subject='fsaverage', subjects_dir=subjects_dir,
src=sample_src)
sample_src.plot(subjects_dir=subjects_dir, head=True, skull=True,
brain='white')
mlab.close(all=True)
# no-head version
mlab.close(all=True)
# all coord frames
pytest.raises(ValueError, plot_alignment, info)
plot_alignment(info, surfaces=[])
for coord_frame in ('meg', 'head', 'mri'):
plot_alignment(info, meg=['helmet', 'sensors'], dig=True,
coord_frame=coord_frame, trans=trans_fname,
subject='sample', mri_fiducials=fiducials_path,
subjects_dir=subjects_dir, src=sample_src)
mlab.close(all=True)
# EEG only with strange options
evoked_eeg_ecog_seeg = evoked.copy().pick_types(meg=False, eeg=True)
evoked_eeg_ecog_seeg.info['projs'] = [] # "remove" avg proj
evoked_eeg_ecog_seeg.set_channel_types({'EEG 001': 'ecog',
'EEG 002': 'seeg'})
with pytest.warns(RuntimeWarning, match='Cannot plot MEG'):
plot_alignment(evoked_eeg_ecog_seeg.info, subject='sample',
trans=trans_fname, subjects_dir=subjects_dir,
surfaces=['white', 'outer_skin', 'outer_skull'],
meg=['helmet', 'sensors'],
eeg=['original', 'projected'], ecog=True, seeg=True)
mlab.close(all=True)
sphere = make_sphere_model(info=evoked.info, r0='auto', head_radius='auto')
bem_sol = read_bem_solution(op.join(subjects_dir, 'sample', 'bem',
'sample-1280-1280-1280-bem-sol.fif'))
bem_surfs = read_bem_surfaces(op.join(subjects_dir, 'sample', 'bem',
'sample-1280-1280-1280-bem.fif'))
sample_src[0]['coord_frame'] = 4 # hack for coverage
plot_alignment(info, subject='sample', eeg='projected',
meg='helmet', bem=sphere, dig=True,
surfaces=['brain', 'inner_skull', 'outer_skull',
'outer_skin'])
plot_alignment(info, trans_fname, subject='sample', meg='helmet',
subjects_dir=subjects_dir, eeg='projected', bem=sphere,
surfaces=['head', 'brain'], src=sample_src)
assert all(surf['coord_frame'] == FIFF.FIFFV_COORD_MRI
for surf in bem_sol['surfs'])
plot_alignment(info, trans_fname, subject='sample', meg=[],
subjects_dir=subjects_dir, bem=bem_sol, eeg=True,
surfaces=['head', 'inflated', 'outer_skull', 'inner_skull'])
assert all(surf['coord_frame'] == FIFF.FIFFV_COORD_MRI
for surf in bem_sol['surfs'])
plot_alignment(info, trans_fname, subject='sample',
meg=True, subjects_dir=subjects_dir,
surfaces=['head', 'inner_skull'], bem=bem_surfs)
sphere = make_sphere_model('auto', 'auto', evoked.info)
src = setup_volume_source_space(sphere=sphere)
plot_alignment(info, eeg='projected', meg='helmet', bem=sphere,
src=src, dig=True, surfaces=['brain', 'inner_skull',
'outer_skull', 'outer_skin'])
sphere = make_sphere_model('auto', None, evoked.info) # one layer
plot_alignment(info, trans_fname, subject='sample', meg=False,
coord_frame='mri', subjects_dir=subjects_dir,
surfaces=['brain'], bem=sphere, show_axes=True)
# 3D coil with no defined draw (ConvexHull)
info_cube = pick_info(info, [0])
info['dig'] = None
info_cube['chs'][0]['coil_type'] = 9999
with pytest.raises(RuntimeError, match='coil definition not found'):
plot_alignment(info_cube, meg='sensors', surfaces=())
coil_def_fname = op.join(tempdir, 'temp')
with open(coil_def_fname, 'w') as fid:
fid.write(coil_3d)
with use_coil_def(coil_def_fname):
plot_alignment(info_cube, meg='sensors', surfaces=(), dig=True)
# one layer bem with skull surfaces:
pytest.raises(ValueError, plot_alignment, info=info, trans=trans_fname,
subject='sample', subjects_dir=subjects_dir,
surfaces=['brain', 'head', 'inner_skull'], bem=sphere)
# wrong eeg value:
pytest.raises(ValueError, plot_alignment, info=info, trans=trans_fname,
subject='sample', subjects_dir=subjects_dir, eeg='foo')
# wrong meg value:
pytest.raises(ValueError, plot_alignment, info=info, trans=trans_fname,
subject='sample', subjects_dir=subjects_dir, meg='bar')
# multiple brain surfaces:
pytest.raises(ValueError, plot_alignment, info=info, trans=trans_fname,
subject='sample', subjects_dir=subjects_dir,
surfaces=['white', 'pial'])
pytest.raises(TypeError, plot_alignment, info=info, trans=trans_fname,
subject='sample', subjects_dir=subjects_dir,
surfaces=[1])
pytest.raises(ValueError, plot_alignment, info=info, trans=trans_fname,
subject='sample', subjects_dir=subjects_dir,
surfaces=['foo'])
mlab.close(all=True)
def test_find_layout():
"""Test finding layout"""
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
find_layout(chs=test_info['chs'])
assert_true(w[0].category == DeprecationWarning)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
find_layout(test_info['chs'])
assert_true(w[0].category == DeprecationWarning)
assert_raises(ValueError, find_layout, dict())
assert_raises(ValueError, find_layout, test_info, ch_type='meep')
sample_info = Raw(fif_fname).info
grads = pick_types(sample_info, meg='grad')
sample_info2 = pick_info(sample_info, grads)
mags = pick_types(sample_info, meg='mag')
sample_info3 = pick_info(sample_info, mags)
# mock new convention
sample_info4 = copy.deepcopy(sample_info)
for ii, name in enumerate(sample_info4['ch_names']):
new = name.replace(' ', '')
sample_info4['ch_names'][ii] = new
sample_info4['chs'][ii]['ch_name'] = new
mags = pick_types(sample_info, meg=False, eeg=True)
sample_info5 = pick_info(sample_info, mags)
lout = find_layout(sample_info, ch_type=None)
assert_true(lout.kind == 'Vectorview-all')
assert_true(all(' ' in k for k in lout.names))
lout = find_layout(sample_info2, ch_type='meg')
assert_true(lout.kind == 'Vectorview-all')
# test new vector-view
lout = find_layout(sample_info4, ch_type=None)
assert_true(lout.kind == 'Vectorview-all')
assert_true(all(not ' ' in k for k in lout.names))
lout = find_layout(sample_info, ch_type='grad')
assert_true(lout.kind == 'Vectorview-grad')
lout = find_layout(sample_info2)
assert_true(lout.kind == 'Vectorview-grad')
lout = find_layout(sample_info2, ch_type='grad')
assert_true(lout.kind == 'Vectorview-grad')
lout = find_layout(sample_info2, ch_type='meg')
assert_true(lout.kind == 'Vectorview-all')
lout = find_layout(sample_info, ch_type='mag')
assert_true(lout.kind == 'Vectorview-mag')
lout = find_layout(sample_info3)
assert_true(lout.kind == 'Vectorview-mag')
lout = find_layout(sample_info3, ch_type='mag')
assert_true(lout.kind == 'Vectorview-mag')
lout = find_layout(sample_info3, ch_type='meg')
assert_true(lout.kind == 'Vectorview-all')
#
lout = find_layout(sample_info, ch_type='eeg')
assert_true(lout.kind == 'EEG')
lout = find_layout(sample_info5)
assert_true(lout.kind == 'EEG')
lout = find_layout(sample_info5, ch_type='eeg')
assert_true(lout.kind == 'EEG')
# no common layout, 'meg' option not supported
fname_bti_raw = op.join(bti_dir, 'exported4D_linux_raw.fif')
lout = find_layout(Raw(fname_bti_raw).info)
assert_true(lout.kind == 'magnesWH3600')
lout = find_layout(Raw(fname_ctf_raw).info)
assert_true(lout.kind == 'CTF-275')
lout = find_layout(read_raw_kit(fname_kit_157).info)
assert_true(lout.kind == 'KIT-157')
sample_info5['dig'] = []
assert_raises(RuntimeError, find_layout, sample_info5)
def test_make_forward_solution_kit():
"""Test making fwd using KIT, BTI, and CTF (compensated) files."""
kit_dir = op.join(op.dirname(__file__), '..', '..', 'io', 'kit', 'tests',
'data')
sqd_path = op.join(kit_dir, 'test.sqd')
mrk_path = op.join(kit_dir, 'test_mrk.sqd')
elp_path = op.join(kit_dir, 'test_elp.txt')
hsp_path = op.join(kit_dir, 'test_hsp.txt')
trans_path = op.join(kit_dir, 'trans-sample.fif')
fname_kit_raw = op.join(kit_dir, 'test_bin_raw.fif')
bti_dir = op.join(op.dirname(__file__), '..', '..', 'io', 'bti', 'tests',
'data')
bti_pdf = op.join(bti_dir, 'test_pdf_linux')
bti_config = op.join(bti_dir, 'test_config_linux')
bti_hs = op.join(bti_dir, 'test_hs_linux')
fname_bti_raw = op.join(bti_dir, 'exported4D_linux_raw.fif')
fname_ctf_raw = op.join(op.dirname(__file__), '..', '..', 'io', 'tests',
'data', 'test_ctf_comp_raw.fif')
# first set up a small testing source space
temp_dir = _TempDir()
fname_src_small = op.join(temp_dir, 'sample-oct-2-src.fif')
src = setup_source_space('sample',
'oct2',
subjects_dir=subjects_dir,
add_dist=False)
write_source_spaces(fname_src_small, src) # to enable working with MNE-C
n_src = 108 # this is the resulting # of verts in fwd
# first use mne-C: convert file, make forward solution
fwd = _do_forward_solution('sample',
fname_kit_raw,
src=fname_src_small,
bem=fname_bem_meg,
mri=trans_path,
eeg=False,
meg=True,
subjects_dir=subjects_dir)
assert_true(isinstance(fwd, Forward))
# now let's use python with the same raw file
fwd_py = make_forward_solution(fname_kit_raw,
trans_path,
src,
fname_bem_meg,
eeg=False,
meg=True)
_compare_forwards(fwd, fwd_py, 157, n_src)
assert_true(isinstance(fwd_py, Forward))
# now let's use mne-python all the way
raw_py = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path)
# without ignore_ref=True, this should throw an error:
assert_raises(NotImplementedError,
make_forward_solution,
raw_py.info,
src=src,
eeg=False,
meg=True,
bem=fname_bem_meg,
trans=trans_path)
# check that asking for eeg channels (even if they don't exist) is handled
meg_only_info = pick_info(raw_py.info,
pick_types(raw_py.info, meg=True, eeg=False))
fwd_py = make_forward_solution(meg_only_info,
src=src,
meg=True,
eeg=True,
bem=fname_bem_meg,
trans=trans_path,
ignore_ref=True)
_compare_forwards(fwd, fwd_py, 157, n_src, meg_rtol=1e-3, meg_atol=1e-7)
# BTI python end-to-end versus C
fwd = _do_forward_solution('sample',
fname_bti_raw,
src=fname_src_small,
bem=fname_bem_meg,
mri=trans_path,
eeg=False,
meg=True,
subjects_dir=subjects_dir)
with warnings.catch_warnings(record=True): # weight tables
raw_py = read_raw_bti(bti_pdf, bti_config, bti_hs, preload=False)
fwd_py = make_forward_solution(raw_py.info,
src=src,
eeg=False,
meg=True,
bem=fname_bem_meg,
trans=trans_path)
_compare_forwards(fwd, fwd_py, 248, n_src)
# now let's test CTF w/compensation
fwd_py = make_forward_solution(fname_ctf_raw,
fname_trans,
src,
fname_bem_meg,
eeg=False,
meg=True)
fwd = _do_forward_solution('sample',
fname_ctf_raw,
mri=fname_trans,
src=fname_src_small,
bem=fname_bem_meg,
eeg=False,
meg=True,
subjects_dir=subjects_dir)
_compare_forwards(fwd, fwd_py, 274, n_src)
# CTF with compensation changed in python
ctf_raw = read_raw_fif(fname_ctf_raw)
ctf_raw.apply_gradient_compensation(2)
fwd_py = make_forward_solution(ctf_raw.info,
fname_trans,
src,
fname_bem_meg,
eeg=False,
meg=True)
with warnings.catch_warnings(record=True):
fwd = _do_forward_solution('sample',
ctf_raw,
mri=fname_trans,
src=fname_src_small,
bem=fname_bem_meg,
eeg=False,
meg=True,
subjects_dir=subjects_dir)
_compare_forwards(fwd, fwd_py, 274, n_src)
def test_other_systems():
"""Test Maxwell filtering on KIT, BTI, and CTF files."""
# KIT
kit_dir = op.join(io_dir, 'kit', 'tests', 'data')
sqd_path = op.join(kit_dir, 'test.sqd')
mrk_path = op.join(kit_dir, 'test_mrk.sqd')
elp_path = op.join(kit_dir, 'test_elp.txt')
hsp_path = op.join(kit_dir, 'test_hsp.txt')
raw_kit = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path)
with pytest.warns(RuntimeWarning, match='fit'):
pytest.raises(RuntimeError, maxwell_filter, raw_kit)
with catch_logging() as log:
raw_sss = maxwell_filter(raw_kit, origin=(0., 0., 0.04),
ignore_ref=True, verbose=True)
assert '12/15 out' in log.getvalue() # homogeneous fields removed
_assert_n_free(raw_sss, 65, 65)
raw_sss_auto = maxwell_filter(raw_kit, origin=(0., 0., 0.04),
ignore_ref=True, mag_scale='auto')
assert_allclose(raw_sss._data, raw_sss_auto._data)
# XXX this KIT origin fit is terrible! Eventually we should get a
# corrected HSP file with proper coverage
with pytest.warns(RuntimeWarning, match='more than 20 mm'):
with catch_logging() as log:
pytest.raises(RuntimeError, maxwell_filter, raw_kit,
ignore_ref=True, regularize=None) # bad condition
raw_sss = maxwell_filter(raw_kit, origin='auto',
ignore_ref=True, bad_condition='info',
verbose=True)
log = log.getvalue()
assert 'badly conditioned' in log
assert 'more than 20 mm from' in log
# fits can differ slightly based on scipy version, so be lenient here
_assert_n_free(raw_sss, 28, 34) # bad origin == brutal reg
# Let's set the origin
with catch_logging() as log:
raw_sss = maxwell_filter(raw_kit, origin=(0., 0., 0.04),
ignore_ref=True, bad_condition='info',
regularize=None, verbose=True)
log = log.getvalue()
assert 'badly conditioned' in log
assert '80/80 in, 12/15 out' in log
_assert_n_free(raw_sss, 80)
# Now with reg
with catch_logging() as log:
raw_sss = maxwell_filter(raw_kit, origin=(0., 0., 0.04),
ignore_ref=True, verbose=True)
log = log.getvalue()
assert 'badly conditioned' not in log
assert '12/15 out' in log
_assert_n_free(raw_sss, 65)
# BTi
bti_dir = op.join(io_dir, 'bti', 'tests', 'data')
bti_pdf = op.join(bti_dir, 'test_pdf_linux')
bti_config = op.join(bti_dir, 'test_config_linux')
bti_hs = op.join(bti_dir, 'test_hs_linux')
raw_bti = read_raw_bti(bti_pdf, bti_config, bti_hs, preload=False)
picks = pick_types(raw_bti.info, meg='mag', exclude=())
power = np.sqrt(np.sum(raw_bti[picks][0] ** 2))
raw_sss = maxwell_filter(raw_bti)
_assert_n_free(raw_sss, 70)
_assert_shielding(raw_sss, power, 0.5)
raw_sss_auto = maxwell_filter(raw_bti, mag_scale='auto', verbose=True)
_assert_shielding(raw_sss_auto, power, 0.7)
# CTF
raw_ctf = read_crop(fname_ctf_raw)
assert_equal(raw_ctf.compensation_grade, 3)
pytest.raises(RuntimeError, maxwell_filter, raw_ctf) # compensated
raw_ctf.apply_gradient_compensation(0)
pytest.raises(ValueError, maxwell_filter, raw_ctf) # cannot fit headshape
raw_sss = maxwell_filter(raw_ctf, origin=(0., 0., 0.04))
_assert_n_free(raw_sss, 68)
_assert_shielding(raw_sss, raw_ctf, 1.8)
with catch_logging() as log:
raw_sss = maxwell_filter(raw_ctf, origin=(0., 0., 0.04),
ignore_ref=True, verbose=True)
assert ', 12/15 out' in log.getvalue() # homogeneous fields removed
_assert_n_free(raw_sss, 70)
_assert_shielding(raw_sss, raw_ctf, 12)
raw_sss_auto = maxwell_filter(raw_ctf, origin=(0., 0., 0.04),
ignore_ref=True, mag_scale='auto')
assert_allclose(raw_sss._data, raw_sss_auto._data)
with catch_logging() as log:
maxwell_filter(raw_ctf, origin=(0., 0., 0.04), regularize=None,
ignore_ref=True, verbose=True)
assert '80/80 in, 12/15 out' in log.getvalue() # homogeneous fields
import os.path as op
from mayavi import mlab
import mne
from mne.io import Raw, read_raw_ctf, read_raw_bti, read_raw_kit
from mne.datasets import sample, spm_face
from mne.viz import plot_trans
print(__doc__)
bti_path = op.abspath(op.dirname(mne.__file__)) + '/io/bti/tests/data/'
kit_path = op.abspath(op.dirname(mne.__file__)) + '/io/kit/tests/data/'
raws = dict(
Neuromag=Raw(sample.data_path() + '/MEG/sample/sample_audvis_raw.fif'),
CTF_275=read_raw_ctf(spm_face.data_path() +
'/MEG/spm/SPM_CTF_MEG_example_faces1_3D.ds'),
Magnes_3600wh=read_raw_bti(bti_path + 'test_pdf_linux',
bti_path + 'test_config_linux',
bti_path + 'test_hs_linux'),
KIT=read_raw_kit(kit_path + 'test.sqd'),
)
for system, raw in raws.items():
# We don't have coil definitions for KIT refs, so exclude them
ref_meg = False if system == 'KIT' else True
fig = plot_trans(raw.info, trans=None, dig=False, eeg_sensors=False,
meg_sensors=True, coord_frame='meg', ref_meg=ref_meg)
mlab.title(system)
def test_other_systems():
"""Test Maxwell filtering on KIT, BTI, and CTF files
"""
io_dir = op.join(op.dirname(__file__), '..', '..', 'io')
# KIT
kit_dir = op.join(io_dir, 'kit', 'tests', 'data')
sqd_path = op.join(kit_dir, 'test.sqd')
mrk_path = op.join(kit_dir, 'test_mrk.sqd')
elp_path = op.join(kit_dir, 'test_elp.txt')
hsp_path = op.join(kit_dir, 'test_hsp.txt')
raw_kit = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path)
with warnings.catch_warnings(record=True): # head fit
assert_raises(RuntimeError, maxwell_filter, raw_kit)
raw_sss = maxwell_filter(raw_kit, origin=(0., 0., 0.04), ignore_ref=True)
_assert_n_free(raw_sss, 65, 65)
# XXX this KIT origin fit is terrible! Eventually we should get a
# corrected HSP file with proper coverage
with warnings.catch_warnings(record=True):
with catch_logging() as log_file:
assert_raises(RuntimeError, maxwell_filter, raw_kit,
ignore_ref=True, regularize=None) # bad condition
raw_sss = maxwell_filter(raw_kit, origin='auto',
ignore_ref=True, bad_condition='warning',
verbose='warning')
log_file = log_file.getvalue()
assert_true('badly conditioned' in log_file)
assert_true('more than 20 mm from' in log_file)
# fits can differ slightly based on scipy version, so be lenient here
_assert_n_free(raw_sss, 28, 34) # bad origin == brutal reg
# Let's set the origin
with warnings.catch_warnings(record=True):
with catch_logging() as log_file:
raw_sss = maxwell_filter(raw_kit, origin=(0., 0., 0.04),
ignore_ref=True, bad_condition='warning',
regularize=None, verbose='warning')
log_file = log_file.getvalue()
assert_true('badly conditioned' in log_file)
_assert_n_free(raw_sss, 80)
# Now with reg
with warnings.catch_warnings(record=True):
with catch_logging() as log_file:
raw_sss = maxwell_filter(raw_kit, origin=(0., 0., 0.04),
ignore_ref=True, verbose=True)
log_file = log_file.getvalue()
assert_true('badly conditioned' not in log_file)
_assert_n_free(raw_sss, 65)
# BTi
bti_dir = op.join(io_dir, 'bti', 'tests', 'data')
bti_pdf = op.join(bti_dir, 'test_pdf_linux')
bti_config = op.join(bti_dir, 'test_config_linux')
bti_hs = op.join(bti_dir, 'test_hs_linux')
with warnings.catch_warnings(record=True): # weght table
raw_bti = read_raw_bti(bti_pdf, bti_config, bti_hs, preload=False)
raw_sss = maxwell_filter(raw_bti)
_assert_n_free(raw_sss, 70)
# CTF
fname_ctf_raw = op.join(io_dir, 'tests', 'data', 'test_ctf_comp_raw.fif')
raw_ctf = Raw(fname_ctf_raw, compensation=2)
assert_raises(RuntimeError, maxwell_filter, raw_ctf) # compensated
raw_ctf = Raw(fname_ctf_raw)
assert_raises(ValueError, maxwell_filter, raw_ctf) # cannot fit headshape
raw_sss = maxwell_filter(raw_ctf, origin=(0., 0., 0.04))
_assert_n_free(raw_sss, 68)
raw_sss = maxwell_filter(raw_ctf, origin=(0., 0., 0.04), ignore_ref=True)
_assert_n_free(raw_sss, 70)
def test_find_layout():
"""Test finding layout"""
assert_raises(ValueError, find_layout, test_info, ch_type='meep')
sample_info = Raw(fif_fname).info
grads = pick_types(sample_info, meg='grad')
sample_info2 = pick_info(sample_info, grads)
mags = pick_types(sample_info, meg='mag')
sample_info3 = pick_info(sample_info, mags)
# mock new convention
sample_info4 = copy.deepcopy(sample_info)
for ii, name in enumerate(sample_info4['ch_names']):
new = name.replace(' ', '')
sample_info4['ch_names'][ii] = new
sample_info4['chs'][ii]['ch_name'] = new
eegs = pick_types(sample_info, meg=False, eeg=True)
sample_info5 = pick_info(sample_info, eegs)
lout = find_layout(sample_info, ch_type=None)
assert_true(lout.kind == 'Vectorview-all')
assert_true(all(' ' in k for k in lout.names))
lout = find_layout(sample_info2, ch_type='meg')
assert_true(lout.kind == 'Vectorview-all')
# test new vector-view
lout = find_layout(sample_info4, ch_type=None)
assert_true(lout.kind == 'Vectorview-all')
assert_true(all(' ' not in k for k in lout.names))
lout = find_layout(sample_info, ch_type='grad')
assert_true(lout.kind == 'Vectorview-grad')
lout = find_layout(sample_info2)
assert_true(lout.kind == 'Vectorview-grad')
lout = find_layout(sample_info2, ch_type='grad')
assert_true(lout.kind == 'Vectorview-grad')
lout = find_layout(sample_info2, ch_type='meg')
assert_true(lout.kind == 'Vectorview-all')
lout = find_layout(sample_info, ch_type='mag')
assert_true(lout.kind == 'Vectorview-mag')
lout = find_layout(sample_info3)
assert_true(lout.kind == 'Vectorview-mag')
lout = find_layout(sample_info3, ch_type='mag')
assert_true(lout.kind == 'Vectorview-mag')
lout = find_layout(sample_info3, ch_type='meg')
assert_true(lout.kind == 'Vectorview-all')
lout = find_layout(sample_info, ch_type='eeg')
assert_true(lout.kind == 'EEG')
lout = find_layout(sample_info5)
assert_true(lout.kind == 'EEG')
lout = find_layout(sample_info5, ch_type='eeg')
assert_true(lout.kind == 'EEG')
# no common layout, 'meg' option not supported
fname_bti_raw = op.join(bti_dir, 'exported4D_linux_raw.fif')
lout = find_layout(Raw(fname_bti_raw).info)
assert_true(lout.kind == 'magnesWH3600')
lout = find_layout(Raw(fname_ctf_raw).info)
assert_true(lout.kind == 'CTF-275')
lout = find_layout(read_raw_kit(fname_kit_157).info)
assert_true(lout.kind == 'KIT-157')
def test_make_forward_solution_kit():
"""Test making fwd using KIT, BTI, and CTF (compensated) files."""
kit_dir = op.join(op.dirname(__file__), '..', '..', 'io', 'kit',
'tests', 'data')
sqd_path = op.join(kit_dir, 'test.sqd')
mrk_path = op.join(kit_dir, 'test_mrk.sqd')
elp_path = op.join(kit_dir, 'test_elp.txt')
hsp_path = op.join(kit_dir, 'test_hsp.txt')
trans_path = op.join(kit_dir, 'trans-sample.fif')
fname_kit_raw = op.join(kit_dir, 'test_bin_raw.fif')
bti_dir = op.join(op.dirname(__file__), '..', '..', 'io', 'bti',
'tests', 'data')
bti_pdf = op.join(bti_dir, 'test_pdf_linux')
bti_config = op.join(bti_dir, 'test_config_linux')
bti_hs = op.join(bti_dir, 'test_hs_linux')
fname_bti_raw = op.join(bti_dir, 'exported4D_linux_raw.fif')
fname_ctf_raw = op.join(op.dirname(__file__), '..', '..', 'io', 'tests',
'data', 'test_ctf_comp_raw.fif')
# first set up a small testing source space
temp_dir = _TempDir()
fname_src_small = op.join(temp_dir, 'sample-oct-2-src.fif')
src = setup_source_space('sample', 'oct2', subjects_dir=subjects_dir,
add_dist=False)
write_source_spaces(fname_src_small, src) # to enable working with MNE-C
n_src = 108 # this is the resulting # of verts in fwd
# first use mne-C: convert file, make forward solution
fwd = _do_forward_solution('sample', fname_kit_raw, src=fname_src_small,
bem=fname_bem_meg, mri=trans_path,
eeg=False, meg=True, subjects_dir=subjects_dir)
assert (isinstance(fwd, Forward))
# now let's use python with the same raw file
fwd_py = make_forward_solution(fname_kit_raw, trans_path, src,
fname_bem_meg, eeg=False, meg=True)
_compare_forwards(fwd, fwd_py, 157, n_src)
assert (isinstance(fwd_py, Forward))
# now let's use mne-python all the way
raw_py = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path)
# without ignore_ref=True, this should throw an error:
pytest.raises(NotImplementedError, make_forward_solution, raw_py.info,
src=src, eeg=False, meg=True,
bem=fname_bem_meg, trans=trans_path)
# check that asking for eeg channels (even if they don't exist) is handled
meg_only_info = pick_info(raw_py.info, pick_types(raw_py.info, meg=True,
eeg=False))
fwd_py = make_forward_solution(meg_only_info, src=src, meg=True, eeg=True,
bem=fname_bem_meg, trans=trans_path,
ignore_ref=True)
_compare_forwards(fwd, fwd_py, 157, n_src,
meg_rtol=1e-3, meg_atol=1e-7)
# BTI python end-to-end versus C
fwd = _do_forward_solution('sample', fname_bti_raw, src=fname_src_small,
bem=fname_bem_meg, mri=trans_path,
eeg=False, meg=True, subjects_dir=subjects_dir)
raw_py = read_raw_bti(bti_pdf, bti_config, bti_hs, preload=False)
fwd_py = make_forward_solution(raw_py.info, src=src, eeg=False, meg=True,
bem=fname_bem_meg, trans=trans_path)
_compare_forwards(fwd, fwd_py, 248, n_src)
# now let's test CTF w/compensation
fwd_py = make_forward_solution(fname_ctf_raw, fname_trans, src,
fname_bem_meg, eeg=False, meg=True)
fwd = _do_forward_solution('sample', fname_ctf_raw, mri=fname_trans,
src=fname_src_small, bem=fname_bem_meg,
eeg=False, meg=True, subjects_dir=subjects_dir)
_compare_forwards(fwd, fwd_py, 274, n_src)
# CTF with compensation changed in python
ctf_raw = read_raw_fif(fname_ctf_raw)
ctf_raw.info['bads'] = ['MRO24-2908'] # test that it works with some bads
ctf_raw.apply_gradient_compensation(2)
fwd_py = make_forward_solution(ctf_raw.info, fname_trans, src,
fname_bem_meg, eeg=False, meg=True)
fwd = _do_forward_solution('sample', ctf_raw, mri=fname_trans,
src=fname_src_small, bem=fname_bem_meg,
eeg=False, meg=True,
subjects_dir=subjects_dir)
_compare_forwards(fwd, fwd_py, 274, n_src)
temp_dir = _TempDir()
fname_temp = op.join(temp_dir, 'test-ctf-fwd.fif')
write_forward_solution(fname_temp, fwd_py)
fwd_py2 = read_forward_solution(fname_temp)
_compare_forwards(fwd_py, fwd_py2, 274, n_src)
repr(fwd_py)
def test_make_forward_solution_kit():
"""Test making fwd using KIT, BTI, and CTF (compensated) files
"""
fname_bem = op.join(subjects_dir, 'sample', 'bem',
'sample-5120-bem-sol.fif')
kit_dir = op.join(op.dirname(__file__), '..', '..', 'io', 'kit',
'tests', 'data')
sqd_path = op.join(kit_dir, 'test.sqd')
mrk_path = op.join(kit_dir, 'test_mrk.sqd')
elp_path = op.join(kit_dir, 'test_elp.txt')
hsp_path = op.join(kit_dir, 'test_hsp.txt')
mri_path = op.join(kit_dir, 'trans-sample.fif')
fname_kit_raw = op.join(kit_dir, 'test_bin_raw.fif')
bti_dir = op.join(op.dirname(__file__), '..', '..', 'io', 'bti',
'tests', 'data')
bti_pdf = op.join(bti_dir, 'test_pdf_linux')
bti_config = op.join(bti_dir, 'test_config_linux')
bti_hs = op.join(bti_dir, 'test_hs_linux')
fname_bti_raw = op.join(bti_dir, 'exported4D_linux_raw.fif')
fname_ctf_raw = op.join(op.dirname(__file__), '..', '..', 'io', 'tests',
'data', 'test_ctf_comp_raw.fif')
# first set up a testing source space
fname_src = op.join(temp_dir, 'oct2-src.fif')
src = setup_source_space('sample', fname_src, 'oct2',
subjects_dir=subjects_dir)
# first use mne-C: convert file, make forward solution
fwd = do_forward_solution('sample', fname_kit_raw, src=fname_src,
mindist=0.0, bem=fname_bem, mri=mri_path,
eeg=False, meg=True, subjects_dir=subjects_dir)
assert_true(isinstance(fwd, Forward))
# now let's use python with the same raw file
fwd_py = make_forward_solution(fname_kit_raw, mindist=0.0,
src=src, eeg=False, meg=True,
bem=fname_bem, mri=mri_path)
_compare_forwards(fwd, fwd_py, 157, 108)
assert_true(isinstance(fwd_py, Forward))
# now let's use mne-python all the way
raw_py = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path)
# without ignore_ref=True, this should throw an error:
assert_raises(NotImplementedError, make_forward_solution, raw_py.info,
mindist=0.0, src=src, eeg=False, meg=True,
bem=fname_bem, mri=mri_path)
fwd_py = make_forward_solution(raw_py.info, mindist=0.0,
src=src, eeg=False, meg=True,
bem=fname_bem, mri=mri_path,
ignore_ref=True)
_compare_forwards(fwd, fwd_py, 157, 108,
meg_rtol=1e-3, meg_atol=1e-7)
# BTI python end-to-end versus C
fwd = do_forward_solution('sample', fname_bti_raw, src=fname_src,
mindist=0.0, bem=fname_bem, mri=mri_path,
eeg=False, meg=True, subjects_dir=subjects_dir)
raw_py = read_raw_bti(bti_pdf, bti_config, bti_hs)
fwd_py = make_forward_solution(raw_py.info, mindist=0.0,
src=src, eeg=False, meg=True,
bem=fname_bem, mri=mri_path)
_compare_forwards(fwd, fwd_py, 248, 108)
# now let's test CTF w/compensation
fwd_py = make_forward_solution(fname_ctf_raw, mindist=0.0,
src=src, eeg=False, meg=True,
bem=fname_bem, mri=fname_mri)
fwd = do_forward_solution('sample', fname_ctf_raw, src=fname_src,
mindist=0.0, bem=fname_bem, mri=fname_mri,
eeg=False, meg=True, subjects_dir=subjects_dir)
_compare_forwards(fwd, fwd_py, 274, 108)
# CTF with compensation changed in python
ctf_raw = Raw(fname_ctf_raw, compensation=2)
fwd_py = make_forward_solution(ctf_raw.info, mindist=0.0,
src=src, eeg=False, meg=True,
bem=fname_bem, mri=fname_mri)
with warnings.catch_warnings(record=True):
fwd = do_forward_solution('sample', ctf_raw, src=fname_src,
mindist=0.0, bem=fname_bem, mri=fname_mri,
eeg=False, meg=True,
subjects_dir=subjects_dir)
_compare_forwards(fwd, fwd_py, 274, 108)
def test_pick_refs():
"""Test picking of reference sensors."""
infos = list()
# KIT
kit_dir = op.join(io_dir, 'kit', 'tests', 'data')
sqd_path = op.join(kit_dir, 'test.sqd')
mrk_path = op.join(kit_dir, 'test_mrk.sqd')
elp_path = op.join(kit_dir, 'test_elp.txt')
hsp_path = op.join(kit_dir, 'test_hsp.txt')
raw_kit = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path)
infos.append(raw_kit.info)
# BTi
bti_dir = op.join(io_dir, 'bti', 'tests', 'data')
bti_pdf = op.join(bti_dir, 'test_pdf_linux')
bti_config = op.join(bti_dir, 'test_config_linux')
bti_hs = op.join(bti_dir, 'test_hs_linux')
raw_bti = read_raw_bti(bti_pdf, bti_config, bti_hs, preload=False)
infos.append(raw_bti.info)
# CTF
fname_ctf_raw = op.join(io_dir, 'tests', 'data', 'test_ctf_comp_raw.fif')
raw_ctf = read_raw_fif(fname_ctf_raw)
raw_ctf.apply_gradient_compensation(2)
for info in infos:
info['bads'] = []
pytest.raises(ValueError, pick_types, info, meg='foo')
pytest.raises(ValueError, pick_types, info, ref_meg='foo')
picks_meg_ref = pick_types(info, meg=True, ref_meg=True)
picks_meg = pick_types(info, meg=True, ref_meg=False)
picks_ref = pick_types(info, meg=False, ref_meg=True)
assert_array_equal(picks_meg_ref,
np.sort(np.concatenate([picks_meg, picks_ref])))
picks_grad = pick_types(info, meg='grad', ref_meg=False)
picks_ref_grad = pick_types(info, meg=False, ref_meg='grad')
picks_meg_ref_grad = pick_types(info, meg='grad', ref_meg='grad')
assert_array_equal(picks_meg_ref_grad,
np.sort(np.concatenate([picks_grad,
picks_ref_grad])))
picks_mag = pick_types(info, meg='mag', ref_meg=False)
picks_ref_mag = pick_types(info, meg=False, ref_meg='mag')
picks_meg_ref_mag = pick_types(info, meg='mag', ref_meg='mag')
assert_array_equal(picks_meg_ref_mag,
np.sort(np.concatenate([picks_mag,
picks_ref_mag])))
assert_array_equal(picks_meg,
np.sort(np.concatenate([picks_mag, picks_grad])))
assert_array_equal(picks_ref,
np.sort(np.concatenate([picks_ref_mag,
picks_ref_grad])))
assert_array_equal(picks_meg_ref, np.sort(np.concatenate(
[picks_grad, picks_mag, picks_ref_grad, picks_ref_mag])))
for pick in (picks_meg_ref, picks_meg, picks_ref,
picks_grad, picks_ref_grad, picks_meg_ref_grad,
picks_mag, picks_ref_mag, picks_meg_ref_mag):
if len(pick) > 0:
pick_info(info, pick)
# test CTF expected failures directly
info = raw_ctf.info
info['bads'] = []
picks_meg_ref = pick_types(info, meg=True, ref_meg=True)
picks_meg = pick_types(info, meg=True, ref_meg=False)
picks_ref = pick_types(info, meg=False, ref_meg=True)
picks_mag = pick_types(info, meg='mag', ref_meg=False)
picks_ref_mag = pick_types(info, meg=False, ref_meg='mag')
picks_meg_ref_mag = pick_types(info, meg='mag', ref_meg='mag')
for pick in (picks_meg_ref, picks_ref, picks_ref_mag, picks_meg_ref_mag):
if len(pick) > 0:
pick_info(info, pick)
for pick in (picks_meg, picks_mag):
if len(pick) > 0:
with catch_logging() as log:
pick_info(info, pick, verbose=True)
assert ('Removing {} compensators'.format(len(info['comps']))
in log.getvalue())
