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_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_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)
nasion, lpa, rpa = elp_points[:3]
nm_trans = get_ras_to_neuromag_trans(nasion, lpa, rpa)
elp_points = apply_trans(nm_trans, elp_points)
nasion, lpa, rpa = elp_points[:3]
hsp_points = apply_trans(nm_trans, hsp_points)
montage = read_dig_montage(hsp,
hpi,
elp,
names,
transform=True,
dev_head_t=True)
temp_dir = _TempDir()
fname_temp = op.join(temp_dir, 'test.fif')
montage.save(fname_temp)
montage_read = read_dig_montage(fif=fname_temp)
for use_mon in (montage, montage_read):
info = create_info(['Test Ch'], 1e3, ['eeg'])
with warnings.catch_warnings(record=True) as w: # test ch pos not set
_set_montage(info, use_mon)
assert_true(all('not set' in str(ww.message) for ww in w))
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_allclose(hs, hsp_points, atol=1e-7)
assert_allclose(nasion_dig.ravel(), nasion, atol=1e-7)
assert_allclose(lpa_dig.ravel(), lpa, atol=1e-7)
assert_allclose(rpa_dig.ravel(), rpa, atol=1e-7)
assert_allclose(hpi_dig, elp_points[3:], atol=1e-7)
def test_fif_dig_montage():
"""Test FIF dig montage support."""
dig_montage = read_dig_montage(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
with warnings.catch_warnings(record=True) as w:
raw_bv = read_raw_brainvision(bv_fname, preload=True)
assert_true(any('will be dropped' in str(ww.message) for ww in w))
raw_bv_2 = raw_bv.copy()
mapping = dict()
for ii, ch_name in enumerate(raw_bv.ch_names[:-1]):
mapping[ch_name] = 'EEG%03d' % (ii + 1,)
raw_bv.rename_channels(mapping)
for ii, ch_name in enumerate(raw_bv_2.ch_names[:-1]):
mapping[ch_name] = 'EEG%03d' % (ii + 33,)
raw_bv_2.rename_channels(mapping)
raw_bv.drop_channels(['STI 014'])
raw_bv.add_channels([raw_bv_2])
for ii in range(2):
if ii == 1:
dig_montage.transform_to_head() # should have no meaningful effect
# Set the montage
raw_bv.set_montage(dig_montage)
# Check the result
evoked = read_evokeds(evoked_fname)[0]
assert_equal(len(raw_bv.ch_names), len(evoked.ch_names))
for ch_py, ch_c in zip(raw_bv.info['chs'], evoked.info['chs']):
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)
assert_dig_allclose(raw_bv.info, evoked.info)
# Roundtrip of non-FIF start
names = ['nasion', 'lpa', 'rpa', '1', '2', '3', '4', '5']
montage = read_dig_montage(hsp, hpi, elp, names, transform=False)
assert_raises(RuntimeError, montage.save, fname_temp) # must be head coord
montage = read_dig_montage(hsp, hpi, elp, names)
_check_roundtrip(montage, fname_temp)
def test_fif_dig_montage():
"""Test FIF dig montage support."""
dig_montage = read_dig_montage(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
with warnings.catch_warnings(record=True) as w:
raw_bv = read_raw_brainvision(bv_fname, preload=True)
assert_true(any('will be dropped' in str(ww.message) for ww in w))
raw_bv_2 = raw_bv.copy()
mapping = dict()
for ii, ch_name in enumerate(raw_bv.ch_names[:-1]):
mapping[ch_name] = 'EEG%03d' % (ii + 1,)
raw_bv.rename_channels(mapping)
for ii, ch_name in enumerate(raw_bv_2.ch_names[:-1]):
mapping[ch_name] = 'EEG%03d' % (ii + 33,)
raw_bv_2.rename_channels(mapping)
raw_bv.drop_channels(['STI 014'])
raw_bv.add_channels([raw_bv_2])
for ii in range(2):
if ii == 1:
dig_montage.transform_to_head() # should have no meaningful effect
# Set the montage
raw_bv.set_montage(dig_montage)
# Check the result
evoked = read_evokeds(evoked_fname)[0]
assert_equal(len(raw_bv.ch_names), len(evoked.ch_names))
for ch_py, ch_c in zip(raw_bv.info['chs'], evoked.info['chs']):
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)
assert_dig_allclose(raw_bv.info, evoked.info)
# Roundtrip of non-FIF start
names = ['nasion', 'lpa', 'rpa', '1', '2', '3', '4', '5']
montage = read_dig_montage(hsp, hpi, elp, names, transform=False)
assert_raises(RuntimeError, montage.save, fname_temp) # must be head coord
montage = read_dig_montage(hsp, hpi, elp, names)
_check_roundtrip(montage, fname_temp)
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)
nasion, lpa, rpa = elp_points[:3]
nm_trans = get_ras_to_neuromag_trans(nasion, lpa, rpa)
elp_points = apply_trans(nm_trans, elp_points)
nasion, lpa, rpa = elp_points[:3]
hsp_points = apply_trans(nm_trans, hsp_points)
montage = read_dig_montage(hsp, hpi, elp, names, transform=True, dev_head_t=True)
temp_dir = _TempDir()
fname_temp = op.join(temp_dir, "test.fif")
montage.save(fname_temp)
montage_read = read_dig_montage(fif=fname_temp)
for use_mon in (montage, montage_read):
info = create_info(["Test Ch"], 1e3, ["eeg"])
with warnings.catch_warnings(record=True) as w: # test ch pos not set
_set_montage(info, use_mon)
assert_true(all("not set" in str(ww.message) for ww in w))
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_allclose(hs, hsp_points, atol=1e-7)
assert_allclose(nasion_dig.ravel(), nasion, atol=1e-7)
assert_allclose(lpa_dig.ravel(), lpa, atol=1e-7)
assert_allclose(rpa_dig.ravel(), rpa, atol=1e-7)
assert_allclose(hpi_dig, elp_points[3:], atol=1e-7)
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_egi_dig_montage():
"""Test EGI MFF XML dig montage support."""
dig_montage = read_dig_montage(egi=egi_dig_montage_fname, unit='m')
# # test round-trip IO
temp_dir = _TempDir()
fname_temp = op.join(temp_dir, 'egi_test.fif')
_check_roundtrip(dig_montage, fname_temp)
# Test coordinate transform
dig_montage.transform_to_head()
# nasion
assert_almost_equal(dig_montage.nasion[0], 0)
assert_almost_equal(dig_montage.nasion[2], 0)
# lpa and rpa
assert_allclose(dig_montage.lpa[1:], 0, atol=1e-16)
assert_allclose(dig_montage.rpa[1:], 0, atol=1e-16)
# Test accuracy and embedding within raw object
raw_egi = read_raw_egi(egi_raw_fname, channel_naming='EEG %03d')
raw_egi.set_montage(dig_montage)
test_raw_egi = read_raw_fif(egi_fif_fname)
assert_equal(len(raw_egi.ch_names), len(test_raw_egi.ch_names))
for ch_raw, ch_test_raw in zip(raw_egi.info['chs'],
test_raw_egi.info['chs']):
assert_equal(ch_raw['ch_name'], ch_test_raw['ch_name'])
assert_equal(ch_raw['coord_frame'], FIFF.FIFFV_COORD_HEAD)
assert_allclose(ch_raw['loc'], ch_test_raw['loc'], atol=1e-7)
assert_dig_allclose(raw_egi.info, test_raw_egi.info)
def test_egi_dig_montage():
"""Test EGI MFF XML dig montage support."""
dig_montage = read_dig_montage(egi=egi_dig_montage_fname, unit='m')
# # test round-trip IO
temp_dir = _TempDir()
fname_temp = op.join(temp_dir, 'egi_test.fif')
_check_roundtrip(dig_montage, fname_temp)
# Test coordinate transform
dig_montage.transform_to_head()
# nasion
assert_almost_equal(dig_montage.nasion[0], 0)
assert_almost_equal(dig_montage.nasion[2], 0)
# lpa and rpa
assert_allclose(dig_montage.lpa[1:], 0, atol=1e-16)
assert_allclose(dig_montage.rpa[1:], 0, atol=1e-16)
# Test accuracy and embedding within raw object
raw_egi = read_raw_egi(egi_raw_fname, channel_naming='EEG %03d')
raw_egi.set_montage(dig_montage)
test_raw_egi = read_raw_fif(egi_fif_fname)
assert_equal(len(raw_egi.ch_names), len(test_raw_egi.ch_names))
for ch_raw, ch_test_raw in zip(raw_egi.info['chs'],
test_raw_egi.info['chs']):
assert_equal(ch_raw['ch_name'], ch_test_raw['ch_name'])
assert_equal(ch_raw['coord_frame'], FIFF.FIFFV_COORD_HEAD)
assert_allclose(ch_raw['loc'], ch_test_raw['loc'], atol=1e-7)
assert_dig_allclose(raw_egi.info, test_raw_egi.info)
def test_fif_dig_montage():
"""Test FIF dig montage support"""
dig_montage = read_dig_montage(fif=fif_dig_montage_fname)
# Make a BrainVision file like the one the user would have had
with warnings.catch_warnings(record=True) as w:
raw_bv = read_raw_brainvision(bv_fname, preload=True)
assert_true(any('will be dropped' in str(ww.message) for ww in w))
raw_bv_2 = raw_bv.copy()
mapping = dict()
for ii, ch_name in enumerate(raw_bv.ch_names[:-1]):
mapping[ch_name] = 'EEG%03d' % (ii + 1,)
raw_bv.rename_channels(mapping)
for ii, ch_name in enumerate(raw_bv_2.ch_names[:-1]):
mapping[ch_name] = 'EEG%03d' % (ii + 33,)
raw_bv_2.rename_channels(mapping)
raw_bv.drop_channels(['STI 014'])
raw_bv.add_channels([raw_bv_2])
# Set the montage
raw_bv.set_montage(dig_montage)
# Check the result
evoked = read_evokeds(evoked_fname)[0]
assert_equal(len(raw_bv.ch_names), len(evoked.ch_names))
for ch_py, ch_c in zip(raw_bv.info['chs'], evoked.info['chs']):
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)
assert_allclose(ch_py['loc'], ch_c['loc'])
assert_dig_allclose(raw_bv.info, evoked.info)
def _check_roundtrip(montage, fname):
"""Check roundtrip writing."""
assert_equal(montage.coord_frame, "head")
montage.save(fname)
montage_read = read_dig_montage(fif=fname)
assert_equal(str(montage), str(montage_read))
for kind in ("elp", "hsp", "nasion", "lpa", "rpa"):
assert_allclose(getattr(montage, kind), getattr(montage_read, kind), err_msg=kind)
assert_equal(montage_read.coord_frame, "head")
def _check_roundtrip(montage, fname):
"""Check roundtrip writing."""
assert_equal(montage.coord_frame, 'head')
montage.save(fname)
montage_read = read_dig_montage(fif=fname)
assert_equal(str(montage), str(montage_read))
for kind in ('elp', 'hsp', 'nasion', 'lpa', 'rpa'):
assert_allclose(getattr(montage, kind),
getattr(montage_read, kind), err_msg=kind)
assert_equal(montage_read.coord_frame, 'head')
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)
nasion, lpa, rpa = elp_points[:3]
nm_trans = get_ras_to_neuromag_trans(nasion, lpa, rpa)
elp_points = apply_trans(nm_trans, elp_points)
nasion, lpa, rpa = elp_points[:3]
hsp_points = apply_trans(nm_trans, hsp_points)
montage = read_dig_montage(hsp, hpi, elp, names, transform=True,
dev_head_t=True)
temp_dir = _TempDir()
fname_temp = op.join(temp_dir, 'test.fif')
montage.save(fname_temp)
montage_read = read_dig_montage(fif=fname_temp)
for use_mon in (montage, montage_read):
info = create_info(['Test Ch'], 1e3, ['eeg'])
with pytest.warns(None): # warns on one run about not all positions
_set_montage(info, use_mon)
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_allclose(hs, hsp_points, atol=1e-7)
assert_allclose(nasion_dig.ravel(), nasion, atol=1e-7)
assert_allclose(lpa_dig.ravel(), lpa, atol=1e-7)
assert_allclose(rpa_dig.ravel(), rpa, atol=1e-7)
assert_allclose(hpi_dig, elp_points[3:], atol=1e-7)
def _check_roundtrip(montage, fname):
"""Check roundtrip writing."""
assert_equal(montage.coord_frame, 'head')
montage.save(fname)
montage_read = read_dig_montage(fif=fname)
assert_equal(str(montage), str(montage_read))
for kind in ('elp', 'hsp', 'nasion', 'lpa', 'rpa'):
if getattr(montage, kind) is not None:
assert_allclose(getattr(montage, kind),
getattr(montage_read, kind), err_msg=kind)
assert_equal(montage_read.coord_frame, 'head')
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_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_make_info():
"""Test some create_info properties
"""
n_ch = 1
info = create_info(n_ch, 1000., 'eeg')
assert_equal(sorted(info.keys()), sorted(RAW_INFO_FIELDS))
coil_types = set([ch['coil_type'] for ch in info['chs']])
assert_true(FIFF.FIFFV_COIL_EEG in coil_types)
assert_raises(TypeError, create_info, ch_names='Test Ch', sfreq=1000)
assert_raises(ValueError, create_info, ch_names=['Test Ch'], sfreq=-1000)
assert_raises(ValueError, create_info, ch_names=['Test Ch'], sfreq=1000,
ch_types=['eeg', 'eeg'])
assert_raises(TypeError, create_info, ch_names=[np.array([1])],
sfreq=1000)
assert_raises(TypeError, create_info, ch_names=['Test Ch'], sfreq=1000,
ch_types=np.array([1]))
assert_raises(KeyError, create_info, ch_names=['Test Ch'], sfreq=1000,
ch_types='awesome')
assert_raises(TypeError, create_info, ['Test Ch'], sfreq=1000,
ch_types=None, montage=np.array([1]))
m = read_montage('biosemi32')
info = create_info(ch_names=m.ch_names, sfreq=1000., ch_types='eeg',
montage=m)
ch_pos = [ch['loc'][:3] for ch in info['chs']]
assert_array_equal(ch_pos, m.pos)
names = ['nasion', 'lpa', 'rpa', '1', '2', '3', '4', '5']
d = read_dig_montage(hsp_fname, None, elp_fname, names, unit='m',
transform=False)
info = create_info(ch_names=m.ch_names, sfreq=1000., ch_types='eeg',
montage=d)
idents = [p['ident'] for p in info['dig']]
assert_true(FIFF.FIFFV_POINT_NASION in idents)
info = create_info(ch_names=m.ch_names, sfreq=1000., ch_types='eeg',
montage=[d, m])
ch_pos = [ch['loc'][:3] for ch in info['chs']]
assert_array_equal(ch_pos, m.pos)
idents = [p['ident'] for p in info['dig']]
assert_true(FIFF.FIFFV_POINT_NASION in idents)
info = create_info(ch_names=m.ch_names, sfreq=1000., ch_types='eeg',
montage=[d, 'biosemi32'])
ch_pos = [ch['loc'][:3] for ch in info['chs']]
assert_array_equal(ch_pos, m.pos)
idents = [p['ident'] for p in info['dig']]
assert_true(FIFF.FIFFV_POINT_NASION in idents)
def test_make_info():
"""Test some create_info properties
"""
n_ch = 1
info = create_info(n_ch, 1000., 'eeg')
assert_equal(sorted(info.keys()), sorted(RAW_INFO_FIELDS))
coil_types = set([ch['coil_type'] for ch in info['chs']])
assert_true(FIFF.FIFFV_COIL_EEG in coil_types)
assert_raises(TypeError, create_info, ch_names='Test Ch', sfreq=1000)
assert_raises(ValueError, create_info, ch_names=['Test Ch'], sfreq=-1000)
assert_raises(ValueError, create_info, ch_names=['Test Ch'], sfreq=1000,
ch_types=['eeg', 'eeg'])
assert_raises(TypeError, create_info, ch_names=[np.array([1])],
sfreq=1000)
assert_raises(TypeError, create_info, ch_names=['Test Ch'], sfreq=1000,
ch_types=np.array([1]))
assert_raises(KeyError, create_info, ch_names=['Test Ch'], sfreq=1000,
ch_types='awesome')
assert_raises(TypeError, create_info, ['Test Ch'], sfreq=1000,
ch_types=None, montage=np.array([1]))
m = read_montage('biosemi32')
info = create_info(ch_names=m.ch_names, sfreq=1000., ch_types='eeg',
montage=m)
ch_pos = [ch['loc'][:3] for ch in info['chs']]
assert_array_equal(ch_pos, m.pos)
names = ['nasion', 'lpa', 'rpa', '1', '2', '3', '4', '5']
d = read_dig_montage(hsp_fname, None, elp_fname, names, unit='m',
transform=False)
info = create_info(ch_names=m.ch_names, sfreq=1000., ch_types='eeg',
montage=d)
idents = [p['ident'] for p in info['dig']]
assert_true(FIFF.FIFFV_POINT_NASION in idents)
info = create_info(ch_names=m.ch_names, sfreq=1000., ch_types='eeg',
montage=[d, m])
ch_pos = [ch['loc'][:3] for ch in info['chs']]
assert_array_equal(ch_pos, m.pos)
idents = [p['ident'] for p in info['dig']]
assert_true(FIFF.FIFFV_POINT_NASION in idents)
info = create_info(ch_names=m.ch_names, sfreq=1000., ch_types='eeg',
montage=[d, 'biosemi32'])
ch_pos = [ch['loc'][:3] for ch in info['chs']]
assert_array_equal(ch_pos, m.pos)
idents = [p['ident'] for p in info['dig']]
assert_true(FIFF.FIFFV_POINT_NASION in idents)
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_make_info():
"""Test some create_info properties."""
n_ch = 1
info = create_info(n_ch, 1000.0, "eeg")
assert_equal(sorted(info.keys()), sorted(RAW_INFO_FIELDS))
coil_types = set([ch["coil_type"] for ch in info["chs"]])
assert_true(FIFF.FIFFV_COIL_EEG in coil_types)
assert_raises(TypeError, create_info, ch_names="Test Ch", sfreq=1000)
assert_raises(ValueError, create_info, ch_names=["Test Ch"], sfreq=-1000)
assert_raises(ValueError, create_info, ch_names=["Test Ch"], sfreq=1000, ch_types=["eeg", "eeg"])
assert_raises(TypeError, create_info, ch_names=[np.array([1])], sfreq=1000)
assert_raises(TypeError, create_info, ch_names=["Test Ch"], sfreq=1000, ch_types=np.array([1]))
assert_raises(KeyError, create_info, ch_names=["Test Ch"], sfreq=1000, ch_types="awesome")
assert_raises(TypeError, create_info, ["Test Ch"], sfreq=1000, ch_types=None, montage=np.array([1]))
m = read_montage("biosemi32")
info = create_info(ch_names=m.ch_names, sfreq=1000.0, ch_types="eeg", montage=m)
ch_pos = [ch["loc"][:3] for ch in info["chs"]]
assert_array_equal(ch_pos, m.pos)
names = ["nasion", "lpa", "rpa", "1", "2", "3", "4", "5"]
d = read_dig_montage(hsp_fname, None, elp_fname, names, unit="m", transform=False)
info = create_info(ch_names=m.ch_names, sfreq=1000.0, ch_types="eeg", montage=d)
idents = [p["ident"] for p in info["dig"]]
assert_true(FIFF.FIFFV_POINT_NASION in idents)
info = create_info(ch_names=m.ch_names, sfreq=1000.0, ch_types="eeg", montage=[d, m])
ch_pos = [ch["loc"][:3] for ch in info["chs"]]
assert_array_equal(ch_pos, m.pos)
idents = [p["ident"] for p in info["dig"]]
assert_true(FIFF.FIFFV_POINT_NASION in idents)
info = create_info(ch_names=m.ch_names, sfreq=1000.0, ch_types="eeg", montage=[d, "biosemi32"])
ch_pos = [ch["loc"][:3] for ch in info["chs"]]
assert_array_equal(ch_pos, m.pos)
idents = [p["ident"] for p in info["dig"]]
assert_true(FIFF.FIFFV_POINT_NASION in idents)
