def test_combine_markers_model():
"""Test CombineMarkersModel Traits Model"""
from mne.gui._marker_gui import CombineMarkersModel, CombineMarkersPanel
tempdir = _TempDir()
tgt_fname = os.path.join(tempdir, 'test.txt')
model = CombineMarkersModel()
# set one marker file
assert not model.mrk3.can_save
model.mrk1.file = mrk_pre_path
assert model.mrk3.can_save
assert_array_equal(model.mrk3.points, model.mrk1.points)
# setting second marker file
model.mrk2.file = mrk_pre_path
assert_array_equal(model.mrk3.points, model.mrk1.points)
# set second marker
model.mrk2.clear = True
model.mrk2.file = mrk_post_path
assert np.any(model.mrk3.points)
points_interpolate_mrk1_mrk2 = model.mrk3.points
# change interpolation method
model.mrk3.method = 'Average'
mrk_avg = read_mrk(mrk_avg_path)
assert_array_equal(model.mrk3.points, mrk_avg)
# clear second marker
model.mrk2.clear = True
assert_array_equal(model.mrk1.points, model.mrk3.points)
# I/O
model.mrk2.file = mrk_post_path
model.mrk3.save(tgt_fname)
mrk_io = read_mrk(tgt_fname)
assert_array_equal(mrk_io, model.mrk3.points)
# exlude an individual marker
model.mrk1.use = [1, 2, 3, 4]
assert_array_equal(model.mrk3.points[0], model.mrk2.points[0])
assert_array_equal(model.mrk3.points[1:], mrk_avg[1:])
# reset model
model.clear = True
model.mrk1.file = mrk_pre_path
model.mrk2.file = mrk_post_path
assert_array_equal(model.mrk3.points, points_interpolate_mrk1_mrk2)
_check_ci()
os.environ['_MNE_GUI_TESTING_MODE'] = 'true'
try:
with warnings.catch_warnings(record=True): # traits warnings
warnings.simplefilter('always')
CombineMarkersPanel()
finally:
del os.environ['_MNE_GUI_TESTING_MODE']
def test_combine_markers_model():
"""Test CombineMarkersModel Traits Model"""
from mne.gui._marker_gui import CombineMarkersModel, CombineMarkersPanel
tempdir = _TempDir()
tgt_fname = os.path.join(tempdir, 'test.txt')
model = CombineMarkersModel()
# set one marker file
assert_false(model.mrk3.can_save)
model.mrk1.file = mrk_pre_path
assert_true(model.mrk3.can_save)
assert_array_equal(model.mrk3.points, model.mrk1.points)
# setting second marker file
model.mrk2.file = mrk_pre_path
assert_array_equal(model.mrk3.points, model.mrk1.points)
# set second marker
model.mrk2.clear = True
model.mrk2.file = mrk_post_path
assert_true(np.any(model.mrk3.points))
points_interpolate_mrk1_mrk2 = model.mrk3.points
# change interpolation method
model.mrk3.method = 'Average'
mrk_avg = read_mrk(mrk_avg_path)
assert_array_equal(model.mrk3.points, mrk_avg)
# clear second marker
model.mrk2.clear = True
assert_array_equal(model.mrk1.points, model.mrk3.points)
# I/O
model.mrk2.file = mrk_post_path
model.mrk3.save(tgt_fname)
mrk_io = read_mrk(tgt_fname)
assert_array_equal(mrk_io, model.mrk3.points)
# exlude an individual marker
model.mrk1.use = [1, 2, 3, 4]
assert_array_equal(model.mrk3.points[0], model.mrk2.points[0])
assert_array_equal(model.mrk3.points[1:], mrk_avg[1:])
# reset model
model.clear = True
model.mrk1.file = mrk_pre_path
model.mrk2.file = mrk_post_path
assert_array_equal(model.mrk3.points, points_interpolate_mrk1_mrk2)
_check_ci()
os.environ['_MNE_GUI_TESTING_MODE'] = 'true'
try:
with warnings.catch_warnings(record=True): # traits warnings
warnings.simplefilter('always')
CombineMarkersPanel()
finally:
del os.environ['_MNE_GUI_TESTING_MODE']
def test_io_mrk():
"""Test IO for mrk files"""
tempdir = _TempDir()
pts = read_mrk(mrk_fname)
# txt
path = os.path.join(tempdir, 'mrk.txt')
_write_dig_points(path, pts)
pts_2 = read_mrk(path)
assert_array_equal(pts, pts_2, "read/write mrk to text")
def test_io_mrk():
"""Test IO for mrk files"""
tempdir = _TempDir()
pts = read_mrk(mrk_fname)
# txt
path = os.path.join(tempdir, 'mrk.txt')
_write_dig_points(path, pts)
pts_2 = read_mrk(path)
assert_array_equal(pts, pts_2, "read/write mrk to text")
def test_combine_markers_model(tmpdir):
"""Test CombineMarkersModel Traits Model."""
from mne.gui._marker_gui import CombineMarkersModel
tempdir = str(tmpdir)
tgt_fname = os.path.join(tempdir, 'test.txt')
model = CombineMarkersModel()
# set one marker file
assert not model.mrk3.can_save
model.mrk1.file = mrk_pre_path
assert model.mrk3.can_save
assert_array_equal(model.mrk3.points, model.mrk1.points)
# setting second marker file
model.mrk2.file = mrk_pre_path
assert_array_equal(model.mrk3.points, model.mrk1.points)
# set second marker
model.mrk2.clear = True
model.mrk2.file = mrk_post_path
assert np.any(model.mrk3.points)
points_interpolate_mrk1_mrk2 = model.mrk3.points
# change interpolation method
model.mrk3.method = 'Average'
mrk_avg = read_mrk(mrk_avg_path)
assert_array_equal(model.mrk3.points, mrk_avg)
# clear second marker
model.mrk2.clear = True
assert_array_equal(model.mrk1.points, model.mrk3.points)
# I/O
model.mrk2.file = mrk_post_path
model.mrk3.save(tgt_fname)
mrk_io = read_mrk(tgt_fname)
assert_array_equal(mrk_io, model.mrk3.points)
# exclude an individual marker
model.mrk1.use = [1, 2, 3, 4]
assert_array_equal(model.mrk3.points[0], model.mrk2.points[0])
assert_array_equal(model.mrk3.points[1:], mrk_avg[1:])
# reset model
model.clear = True
model.mrk1.file = mrk_pre_path
model.mrk2.file = mrk_post_path
assert_array_equal(model.mrk3.points, points_interpolate_mrk1_mrk2)
def test_io_mrk():
"""Test IO for mrk files"""
pts = read_mrk(mrk_fname)
# pickle
path = os.path.join(tempdir, "mrk.pickled")
write_mrk(path, pts)
pts_2 = read_mrk(path)
assert_array_equal(pts, pts_2, "read/write with pickle")
# txt
path = os.path.join(tempdir, 'mrk.txt')
write_mrk(path, pts)
pts_2 = read_mrk(path)
assert_array_equal(pts, pts_2, "read/write mrk to text")
def test_io_mrk():
"""Test IO for mrk files"""
pts = read_mrk(mrk_fname)
# pickle
path = os.path.join(tempdir, "mrk.pickled")
write_mrk(path, pts)
pts_2 = read_mrk(path)
assert_array_equal(pts, pts_2, "read/write with pickle")
# txt
path = os.path.join(tempdir, 'mrk.txt')
write_mrk(path, pts)
pts_2 = read_mrk(path)
assert_array_equal(pts, pts_2, "read/write mrk to text")
def _read_dig_montage(
hsp=None, hpi=None, elp=None, point_names=None, unit='auto',
fif=None, egi=None, bvct=None, transform=True, dev_head_t=False,
):
"""Unfolds the `read_dig_montage` old behavior of the call below.
montage = read_dig_montage(hsp, hpi, elp, names,
transform=True, dev_head_t=False)
"""
assert isinstance(hsp, str), 'original call hsp was string'
assert op.splitext(hpi)[-1] == '.sqd', 'original call hpi was .sqd'
assert isinstance(elp, str), 'original call elp was string'
hsp = _read_dig_points(hsp, unit=unit)
hpi = read_mrk(hpi)
elp = _read_dig_points(elp, unit=unit)
data = Bunch(nasion=None, lpa=None, rpa=None,
hsp=hsp, hpi=hpi, elp=elp, coord_frame='unknown',
point_names=point_names, dig_ch_pos=None)
data = _fix_data_fiducials(data)
data = _transform_to_head_call(data)
with pytest.deprecated_call():
montage = DigMontage(**data)
return montage
def test_read_dig_montage():
"""Test read_dig_montage"""
names = ['nasion', 'lpa', 'rpa', '1', '2', '3', '4', '5']
montage = read_dig_montage(hsp, hpi, elp, names, unit='m', transform=False)
elp_points = _read_dig_points(elp)
hsp_points = _read_dig_points(hsp)
hpi_points = read_mrk(hpi)
assert_equal(montage.point_names, names)
assert_array_equal(montage.elp, elp_points)
assert_array_equal(montage.hsp, hsp_points)
assert_array_equal(montage.hpi, hpi_points)
assert_array_equal(montage.dev_head_t, np.identity(4))
montage = read_dig_montage(hsp, hpi, elp, names,
transform=True, dev_head_t=True)
# check coordinate transformation
# nasion
assert_almost_equal(montage.nasion[0], 0)
assert_almost_equal(montage.nasion[2], 0)
# lpa and rpa
assert_allclose(montage.lpa[1:], 0, atol=1e-16)
assert_allclose(montage.rpa[1:], 0, atol=1e-16)
# device head transform
dev_head_t = fit_matched_points(tgt_pts=montage.elp,
src_pts=montage.hpi, out='trans')
assert_array_equal(montage.dev_head_t, dev_head_t)
def test_read_dig_montage():
"""Test read_dig_montage"""
names = ['nasion', 'lpa', 'rpa', '1', '2', '3', '4', '5']
montage = read_dig_montage(hsp, hpi, elp, names, unit='m', transform=False)
elp_points = _read_dig_points(elp)
hsp_points = _read_dig_points(hsp)
hpi_points = read_mrk(hpi)
assert_equal(montage.point_names, names)
assert_array_equal(montage.elp, elp_points)
assert_array_equal(montage.hsp, hsp_points)
assert_array_equal(montage.hpi, hpi_points)
assert_array_equal(montage.dev_head_t, np.identity(4))
montage = read_dig_montage(hsp,
hpi,
elp,
names,
transform=True,
dev_head_t=True)
# check coordinate transformation
# nasion
assert_almost_equal(montage.elp[0, 0], 0)
assert_almost_equal(montage.nasion[0], 0)
assert_almost_equal(montage.elp[0, 2], 0)
assert_almost_equal(montage.nasion[0], 0)
# lpa and rpa
assert_allclose(montage.elp[1:3, 1:], 0, atol=1e-16)
assert_allclose(montage.lpa[1:], 0, atol=1e-16)
assert_allclose(montage.rpa[1:], 0, atol=1e-16)
# device head transform
dev_head_t = fit_matched_points(tgt_pts=montage.elp[3:],
src_pts=montage.hpi,
out='trans')
assert_array_equal(montage.dev_head_t, dev_head_t)
def test_combine_markers_model():
"""Test CombineMarkersModel Traits Model"""
from mne.gui._marker_gui import CombineMarkersModel
model = CombineMarkersModel()
# set one marker file
assert_false(model.mrk3.can_save)
model.mrk1.file = mrk_pre_path
assert_true(model.mrk3.can_save)
assert_array_equal(model.mrk3.points, model.mrk1.points)
# setting second marker file
model.mrk2.file = mrk_pre_path
assert_array_equal(model.mrk3.points, model.mrk1.points)
# set second marker
model.mrk2.clear = True
model.mrk2.file = mrk_post_path
assert_true(np.any(model.mrk3.points))
points_interpolate_mrk1_mrk2 = model.mrk3.points
# change interpolation method
model.mrk3.method = 'Average'
mrk_avg = read_mrk(mrk_avg_path)
assert_array_equal(model.mrk3.points, mrk_avg)
# clear second marker
model.mrk2.clear = True
assert_array_equal(model.mrk1.points, model.mrk3.points)
# I/O
model.mrk2.file = mrk_post_path
model.mrk3.save(tgt_fname)
mrk_io = read_mrk(tgt_fname)
assert_array_equal(mrk_io, model.mrk3.points)
# exlude an individual marker
model.mrk1.use = [1, 2, 3, 4]
assert_array_equal(model.mrk3.points[0], model.mrk2.points[0])
assert_array_equal(model.mrk3.points[1:], mrk_avg[1:])
# reset model
model.clear = True
model.mrk1.file = mrk_pre_path
model.mrk2.file = mrk_post_path
assert_array_equal(model.mrk3.points, points_interpolate_mrk1_mrk2)
def test_fif_dig_montage():
"""Test FIF dig montage support."""
dig_montage = read_dig_fif(fif_dig_montage_fname)
# test round-trip IO
temp_dir = _TempDir()
fname_temp = op.join(temp_dir, 'test.fif')
_check_roundtrip(dig_montage, fname_temp)
# Make a BrainVision file like the one the user would have had
raw_bv = read_raw_brainvision(bv_fname, preload=True)
raw_bv_2 = raw_bv.copy()
mapping = dict()
for ii, ch_name in enumerate(raw_bv.ch_names):
mapping[ch_name] = 'EEG%03d' % (ii + 1,)
raw_bv.rename_channels(mapping)
for ii, ch_name in enumerate(raw_bv_2.ch_names):
mapping[ch_name] = 'EEG%03d' % (ii + 33,)
raw_bv_2.rename_channels(mapping)
raw_bv.add_channels([raw_bv_2])
for ch in raw_bv.info['chs']:
ch['kind'] = FIFF.FIFFV_EEG_CH
# Set the montage
raw_bv.set_montage(dig_montage)
# Check the result
evoked = read_evokeds(evoked_fname)[0]
# check info[chs] matches
assert_equal(len(raw_bv.ch_names), len(evoked.ch_names) - 1)
for ch_py, ch_c in zip(raw_bv.info['chs'], evoked.info['chs'][:-1]):
assert_equal(ch_py['ch_name'],
ch_c['ch_name'].replace('EEG ', 'EEG'))
# C actually says it's unknown, but it's not (?):
# assert_equal(ch_py['coord_frame'], ch_c['coord_frame'])
assert_equal(ch_py['coord_frame'], FIFF.FIFFV_COORD_HEAD)
c_loc = ch_c['loc'].copy()
c_loc[c_loc == 0] = np.nan
assert_allclose(ch_py['loc'], c_loc, atol=1e-7)
# check info[dig]
assert_dig_allclose(raw_bv.info, evoked.info)
# Roundtrip of non-FIF start
montage = make_dig_montage(hsp=read_polhemus_fastscan(hsp),
hpi=read_mrk(hpi))
elp_points = read_polhemus_fastscan(elp)
ch_pos = {"EEG%03d" % (k + 1): pos for k, pos in enumerate(elp_points[8:])}
montage += make_dig_montage(nasion=elp_points[0],
lpa=elp_points[1],
rpa=elp_points[2],
ch_pos=ch_pos)
pytest.raises(RuntimeError, montage.save, fname_temp) # must be head coord
montage = transform_to_head(montage)
_check_roundtrip(montage, fname_temp)
def test_read_dig_montage():
"""Test read_dig_montage"""
names = ['nasion', 'lpa', 'rpa', '1', '2', '3', '4', '5']
montage = read_dig_montage(hsp, hpi, elp, names, transform=False)
elp_points = _read_dig_points(elp)
hsp_points = _read_dig_points(hsp)
hpi_points = read_mrk(hpi)
assert_equal(montage.point_names, names)
assert_array_equal(montage.elp, elp_points)
assert_array_equal(montage.hsp, hsp_points)
assert_array_equal(montage.hpi, hpi_points)
assert_true(montage.dev_head_t is None)
montage = read_dig_montage(hsp, hpi, elp, names,
transform=True, dev_head_t=True)
# check coordinate transformation
# nasion
assert_almost_equal(montage.nasion[0], 0)
assert_almost_equal(montage.nasion[2], 0)
# lpa and rpa
assert_allclose(montage.lpa[1:], 0, atol=1e-16)
assert_allclose(montage.rpa[1:], 0, atol=1e-16)
# device head transform
dev_head_t = fit_matched_points(tgt_pts=montage.elp,
src_pts=montage.hpi, out='trans')
assert_array_equal(montage.dev_head_t, dev_head_t)
# Digitizer as array
m2 = read_dig_montage(hsp_points, hpi_points, elp_points, names, unit='m')
assert_array_equal(m2.hsp, montage.hsp)
m3 = read_dig_montage(hsp_points * 1000, hpi_points, elp_points * 1000,
names)
assert_allclose(m3.hsp, montage.hsp)
# test unit parameter and .mat support
tempdir = _TempDir()
mat_hsp = op.join(tempdir, 'test.mat')
savemat(mat_hsp, dict(Points=(1000 * hsp_points).T))
montage_cm = read_dig_montage(mat_hsp, hpi, elp, names, unit='cm')
assert_allclose(montage_cm.hsp, montage.hsp * 10.)
assert_allclose(montage_cm.elp, montage.elp * 10.)
assert_array_equal(montage_cm.hpi, montage.hpi)
assert_raises(ValueError, read_dig_montage, hsp, hpi, elp, names,
unit='km')
# extra columns
extra_hsp = op.join(tempdir, 'test.txt')
with open(hsp, 'rb') as fin:
with open(extra_hsp, 'wb') as fout:
for line in fin:
if line.startswith(b'%'):
fout.write(line)
else:
# extra column
fout.write(line.rstrip() + b' 0.0 0.0 0.0\n')
with warnings.catch_warnings(record=True) as w:
montage_extra = read_dig_montage(extra_hsp, hpi, elp, names)
assert_true(len(w) == 1 and all('columns' in str(ww.message) for ww in w))
assert_allclose(montage_extra.hsp, montage.hsp)
assert_allclose(montage_extra.elp, montage.elp)
def test_read_dig_montage():
"""Test read_dig_montage"""
names = ['nasion', 'lpa', 'rpa', '1', '2', '3', '4', '5']
montage = read_dig_montage(hsp, hpi, elp, names, transform=False)
elp_points = _read_dig_points(elp)
hsp_points = _read_dig_points(hsp)
hpi_points = read_mrk(hpi)
assert_equal(montage.point_names, names)
assert_array_equal(montage.elp, elp_points)
assert_array_equal(montage.hsp, hsp_points)
assert_array_equal(montage.hpi, hpi_points)
assert_true(montage.dev_head_t is None)
montage = read_dig_montage(hsp, hpi, elp, names,
transform=True, dev_head_t=True)
# check coordinate transformation
# nasion
assert_almost_equal(montage.nasion[0], 0)
assert_almost_equal(montage.nasion[2], 0)
# lpa and rpa
assert_allclose(montage.lpa[1:], 0, atol=1e-16)
assert_allclose(montage.rpa[1:], 0, atol=1e-16)
# device head transform
dev_head_t = fit_matched_points(tgt_pts=montage.elp,
src_pts=montage.hpi, out='trans')
assert_array_equal(montage.dev_head_t, dev_head_t)
# Digitizer as array
m2 = read_dig_montage(hsp_points, hpi_points, elp_points, names, unit='m')
assert_array_equal(m2.hsp, montage.hsp)
m3 = read_dig_montage(hsp_points * 1000, hpi_points, elp_points * 1000,
names)
assert_allclose(m3.hsp, montage.hsp)
# test unit parameter and .mat support
tempdir = _TempDir()
mat_hsp = op.join(tempdir, 'test.mat')
savemat(mat_hsp, dict(Points=(1000 * hsp_points).T))
montage_cm = read_dig_montage(mat_hsp, hpi, elp, names, unit='cm')
assert_allclose(montage_cm.hsp, montage.hsp * 10.)
assert_allclose(montage_cm.elp, montage.elp * 10.)
assert_array_equal(montage_cm.hpi, montage.hpi)
assert_raises(ValueError, read_dig_montage, hsp, hpi, elp, names,
unit='km')
# extra columns
extra_hsp = op.join(tempdir, 'test.txt')
with open(hsp, 'rb') as fin:
with open(extra_hsp, 'wb') as fout:
for line in fin:
if line.startswith(b'%'):
fout.write(line)
else:
# extra column
fout.write(line.rstrip() + b' 0.0 0.0 0.0\n')
with warnings.catch_warnings(record=True) as w:
montage_extra = read_dig_montage(extra_hsp, hpi, elp, names)
assert_true(len(w) == 1 and all('columns' in str(ww.message) for ww in w))
assert_allclose(montage_extra.hsp, montage.hsp)
assert_allclose(montage_extra.elp, montage.elp)
def test_io_mrk():
"""Test IO for mrk files."""
tempdir = _TempDir()
pts = read_mrk(mrk_fname)
# txt
path = os.path.join(tempdir, 'mrk.txt')
_write_dig_points(path, pts)
pts_2 = read_mrk(path)
assert_array_equal(pts, pts_2, "read/write mrk to text")
# pickle
fname = os.path.join(tempdir, 'mrk.pickled')
with open(fname, 'wb') as fid:
pickle.dump(dict(mrk=pts), fid)
pts_2 = read_mrk(fname)
assert_array_equal(pts_2, pts, "pickle mrk")
with open(fname, 'wb') as fid:
pickle.dump(dict(), fid)
pytest.raises(ValueError, read_mrk, fname)
# unsupported extension
pytest.raises(ValueError, read_mrk, "file.ext")
def test_io_mrk():
"""Test IO for mrk files."""
tempdir = _TempDir()
pts = read_mrk(mrk_fname)
# txt
path = os.path.join(tempdir, 'mrk.txt')
_write_dig_points(path, pts)
pts_2 = read_mrk(path)
assert_array_equal(pts, pts_2, "read/write mrk to text")
# pickle
fname = os.path.join(tempdir, 'mrk.pickled')
with open(fname, 'wb') as fid:
pickle.dump(dict(mrk=pts), fid)
pts_2 = read_mrk(fname)
assert_array_equal(pts_2, pts, "pickle mrk")
with open(fname, 'wb') as fid:
pickle.dump(dict(), fid)
pytest.raises(ValueError, read_mrk, fname)
# unsupported extension
pytest.raises(ValueError, read_mrk, "file.ext")
def test_read_dig_montage():
"""Test read_dig_montage"""
names = ['nasion', 'lpa', 'rpa', '1', '2', '3', '4', '5']
montage = read_dig_montage(hsp, hpi, elp, names, transform=False)
elp_points = _read_dig_points(elp)
hsp_points = _read_dig_points(hsp)
hpi_points = read_mrk(hpi)
assert_equal(montage.point_names, names)
assert_array_equal(montage.elp, elp_points)
assert_array_equal(montage.hsp, hsp_points)
assert_array_equal(montage.hpi, hpi_points)
assert_array_equal(montage.dev_head_t, np.identity(4))
montage = read_dig_montage(hsp,
hpi,
elp,
names,
transform=True,
dev_head_t=True)
# check coordinate transformation
# nasion
assert_almost_equal(montage.nasion[0], 0)
assert_almost_equal(montage.nasion[2], 0)
# lpa and rpa
assert_allclose(montage.lpa[1:], 0, atol=1e-16)
assert_allclose(montage.rpa[1:], 0, atol=1e-16)
# device head transform
dev_head_t = fit_matched_points(tgt_pts=montage.elp,
src_pts=montage.hpi,
out='trans')
assert_array_equal(montage.dev_head_t, dev_head_t)
# Digitizer as array
m2 = read_dig_montage(hsp_points, hpi_points, elp_points, names, unit='m')
assert_array_equal(m2.hsp, montage.hsp)
m3 = read_dig_montage(hsp_points * 1000, hpi_points, elp_points * 1000,
names)
assert_allclose(m3.hsp, montage.hsp)
# test unit parameter
montage_cm = read_dig_montage(hsp, hpi, elp, names, unit='cm')
assert_allclose(montage_cm.hsp, montage.hsp * 10.)
assert_allclose(montage_cm.elp, montage.elp * 10.)
assert_array_equal(montage_cm.hpi, montage.hpi)
assert_raises(ValueError,
read_dig_montage,
hsp,
hpi,
elp,
names,
unit='km')
def test_set_dig_montage():
"""Test applying DigMontage to inst
Extensive testing of applying `dig` to info is done in test_meas_info
with `test_make_dig_points`.
"""
names = ['nasion', 'lpa', 'rpa', '1', '2', '3', '4', '5']
hsp_points = _read_dig_points(hsp)
elp_points = _read_dig_points(elp)
hpi_points = read_mrk(hpi)
p0, p1, p2 = elp_points[:3]
nm_trans = get_ras_to_neuromag_trans(p0, p1, p2)
elp_points = apply_trans(nm_trans, elp_points)
nasion_point, lpa_point, rpa_point = elp_points[:3]
hsp_points = apply_trans(nm_trans, hsp_points)
montage = read_dig_montage(hsp, hpi, elp, names, unit='m', transform=True)
info = create_info(['Test Ch'], 1e3, ['eeg'])
_set_montage(info, montage)
hs = np.array([
p['r'] for i, p in enumerate(info['dig'])
if p['kind'] == FIFF.FIFFV_POINT_EXTRA
])
nasion_dig = np.array([
p['r'] for p in info['dig'] if all([
p['ident'] == FIFF.FIFFV_POINT_NASION, p['kind'] ==
FIFF.FIFFV_POINT_CARDINAL
])
])
lpa_dig = np.array([
p['r'] for p in info['dig'] if all([
p['ident'] == FIFF.FIFFV_POINT_LPA, p['kind'] ==
FIFF.FIFFV_POINT_CARDINAL
])
])
rpa_dig = np.array([
p['r'] for p in info['dig'] if all([
p['ident'] == FIFF.FIFFV_POINT_RPA, p['kind'] ==
FIFF.FIFFV_POINT_CARDINAL
])
])
hpi_dig = np.array(
[p['r'] for p in info['dig'] if p['kind'] == FIFF.FIFFV_POINT_HPI])
assert_array_equal(hs, hsp_points)
assert_array_equal(nasion_dig.ravel(), nasion_point)
assert_array_equal(lpa_dig.ravel(), lpa_point)
assert_array_equal(rpa_dig.ravel(), rpa_point)
assert_array_equal(hpi_dig, hpi_points)
assert_array_equal(montage.dev_head_t, info['dev_head_t']['trans'])
def test_read_dig_montage():
"""Test read_dig_montage"""
names = ['nasion', 'lpa', 'rpa', '1', '2', '3', '4', '5']
montage = read_dig_montage(hsp, hpi, elp, names, transform=False)
elp_points = _read_dig_points(elp)
hsp_points = _read_dig_points(hsp)
hpi_points = read_mrk(hpi)
assert_equal(montage.point_names, names)
assert_array_equal(montage.elp, elp_points)
assert_array_equal(montage.hsp, hsp_points)
assert_array_equal(montage.hpi, hpi_points)
assert_true(montage.dev_head_t is None)
montage = read_dig_montage(hsp, hpi, elp, names,
transform=True, dev_head_t=True)
# check coordinate transformation
# nasion
assert_almost_equal(montage.nasion[0], 0)
assert_almost_equal(montage.nasion[2], 0)
# lpa and rpa
assert_allclose(montage.lpa[1:], 0, atol=1e-16)
assert_allclose(montage.rpa[1:], 0, atol=1e-16)
# device head transform
dev_head_t = fit_matched_points(tgt_pts=montage.elp,
src_pts=montage.hpi, out='trans')
assert_array_equal(montage.dev_head_t, dev_head_t)
# Digitizer as array
m2 = read_dig_montage(hsp_points, hpi_points, elp_points, names, unit='m')
assert_array_equal(m2.hsp, montage.hsp)
m3 = read_dig_montage(hsp_points * 1000, hpi_points, elp_points * 1000,
names)
assert_allclose(m3.hsp, montage.hsp)
# test unit parameter and .mat support
tempdir = _TempDir()
mat_hsp = op.join(tempdir, 'test.mat')
savemat(mat_hsp, dict(Points=(1000 * hsp_points).T))
montage_cm = read_dig_montage(mat_hsp, hpi, elp, names, unit='cm')
assert_allclose(montage_cm.hsp, montage.hsp * 10.)
assert_allclose(montage_cm.elp, montage.elp * 10.)
assert_array_equal(montage_cm.hpi, montage.hpi)
assert_raises(ValueError, read_dig_montage, hsp, hpi, elp, names,
unit='km')
def test_set_dig_montage():
"""Test applying DigMontage to inst
Extensive testing of applying `dig` to info is done in test_meas_info
with `test_make_dig_points`.
"""
names = ['nasion', 'lpa', 'rpa', '1', '2', '3', '4', '5']
hsp_points = _read_dig_points(hsp)
elp_points = _read_dig_points(elp)
hpi_points = read_mrk(hpi)
p0, p1, p2 = elp_points[:3]
nm_trans = get_ras_to_neuromag_trans(p0, p1, p2)
elp_points = apply_trans(nm_trans, elp_points)
nasion_point, lpa_point, rpa_point = elp_points[:3]
hsp_points = apply_trans(nm_trans, hsp_points)
montage = read_dig_montage(hsp, hpi, elp, names, unit='m', transform=True)
info = create_info(['Test Ch'], 1e3, ['eeg'])
_set_montage(info, montage)
hs = np.array([p['r'] for i, p in enumerate(info['dig'])
if p['kind'] == FIFF.FIFFV_POINT_EXTRA])
nasion_dig = np.array([p['r'] for p in info['dig']
if all([p['ident'] == FIFF.FIFFV_POINT_NASION,
p['kind'] == FIFF.FIFFV_POINT_CARDINAL])])
lpa_dig = np.array([p['r'] for p in info['dig']
if all([p['ident'] == FIFF.FIFFV_POINT_LPA,
p['kind'] == FIFF.FIFFV_POINT_CARDINAL])])
rpa_dig = np.array([p['r'] for p in info['dig']
if all([p['ident'] == FIFF.FIFFV_POINT_RPA,
p['kind'] == FIFF.FIFFV_POINT_CARDINAL])])
hpi_dig = np.array([p['r'] for p in info['dig']
if p['kind'] == FIFF.FIFFV_POINT_HPI])
assert_array_equal(hs, hsp_points)
assert_array_equal(nasion_dig.ravel(), nasion_point)
assert_array_equal(lpa_dig.ravel(), lpa_point)
assert_array_equal(rpa_dig.ravel(), rpa_point)
assert_array_equal(hpi_dig, hpi_points)
assert_array_equal(montage.dev_head_t, info['dev_head_t']['trans'])
def test_read_dig_montage():
"""Test read_dig_montage."""
names = ['nasion', 'lpa', 'rpa', '1', '2', '3', '4', '5']
montage = read_dig_montage(hsp, hpi, elp, names, transform=False)
elp_points = _read_dig_points(elp)
hsp_points = _read_dig_points(hsp)
hpi_points = read_mrk(hpi)
with pytest.deprecated_call():
assert_equal(montage.point_names, names)
assert_array_equal(montage.elp, elp_points)
assert_array_equal(montage.hsp, hsp_points)
assert (montage.dev_head_t is None)
montage = read_dig_montage(hsp,
hpi,
elp,
names,
transform=True,
dev_head_t=True)
# check coordinate transformation
# nasion
with pytest.deprecated_call():
assert_almost_equal(montage.nasion[0], 0)
assert_almost_equal(montage.nasion[2], 0)
# lpa and rpa
with pytest.deprecated_call():
assert_allclose(montage.lpa[1:], 0, atol=1e-16)
assert_allclose(montage.rpa[1:], 0, atol=1e-16)
# device head transform
EXPECTED_DEV_HEAD_T = np.array(
[[-3.72201691e-02, -9.98212167e-01, -4.67667497e-02, -7.31583414e-04],
[8.98064989e-01, -5.39382685e-02, 4.36543170e-01, 1.60134431e-02],
[-4.38285221e-01, -2.57513699e-02, 8.98466990e-01, 6.13035748e-02],
[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 1.00000000e+00]])
assert_allclose(montage.dev_head_t, EXPECTED_DEV_HEAD_T, atol=1e-7)
# Digitizer as array
with pytest.deprecated_call():
m2 = read_dig_montage(hsp_points,
hpi_points,
elp_points,
names,
unit='m')
assert_array_equal(m2.hsp, montage.hsp)
m3 = read_dig_montage(hsp_points * 1000, hpi_points, elp_points * 1000,
names)
with pytest.deprecated_call():
assert_allclose(m3.hsp, montage.hsp)
# test unit parameter and .mat support
tempdir = _TempDir()
mat_hsp = op.join(tempdir, 'test.mat')
savemat(mat_hsp, dict(Points=(1000 * hsp_points).T), oned_as='row')
montage_cm = read_dig_montage(mat_hsp, hpi, elp, names, unit='cm')
with pytest.deprecated_call():
assert_allclose(montage_cm.hsp, montage.hsp * 10.)
assert_allclose(montage_cm.elp, montage.elp * 10.)
pytest.raises(ValueError,
read_dig_montage,
hsp,
hpi,
elp,
names,
unit='km')
# extra columns
extra_hsp = op.join(tempdir, 'test.txt')
with open(hsp, 'rb') as fin:
with open(extra_hsp, 'wb') as fout:
for line in fin:
if line.startswith(b'%'):
fout.write(line)
else:
# extra column
fout.write(line.rstrip() + b' 0.0 0.0 0.0\n')
with pytest.warns(RuntimeWarning, match='Found .* columns instead of 3'):
montage_extra = read_dig_montage(extra_hsp, hpi, elp, names)
with pytest.deprecated_call():
assert_allclose(montage_extra.hsp, montage.hsp)
assert_allclose(montage_extra.elp, montage.elp)
