def test_coil_trans():
"""Test loc<->coil_trans functions"""
rng = np.random.RandomState(0)
x = rng.randn(4, 4)
x[3] = [0, 0, 0, 1]
assert_allclose(_loc_to_coil_trans(_coil_trans_to_loc(x)), x)
x = rng.randn(12)
assert_allclose(_coil_trans_to_loc(_loc_to_coil_trans(x)), x)
def test_coil_trans():
"""Test loc<->coil_trans functions."""
rng = np.random.RandomState(0)
x = rng.randn(4, 4)
x[3] = [0, 0, 0, 1]
assert_allclose(_loc_to_coil_trans(_coil_trans_to_loc(x)), x)
x = rng.randn(12)
assert_allclose(_coil_trans_to_loc(_loc_to_coil_trans(x)), x)
def _create_meg_coil(coilset, ch, acc, do_es):
"""Create a coil definition using templates, transform if necessary."""
# Also change the coordinate frame if so desired
if ch['kind'] not in [FIFF.FIFFV_MEG_CH, FIFF.FIFFV_REF_MEG_CH]:
raise RuntimeError('%s is not a MEG channel' % ch['ch_name'])
# Simple linear search from the coil definitions
for coil in coilset:
if coil['coil_type'] == (ch['coil_type'] & 0xFFFF) and \
coil['accuracy'] == acc:
break
else:
raise RuntimeError('Desired coil definition not found '
'(type = %d acc = %d)' % (ch['coil_type'], acc))
# Apply a coordinate transformation if so desired
coil_trans = _loc_to_coil_trans(ch['loc'])
# Create the result
#print(coil['coil_type'], coil['accuracy'])
res = dict(chname=ch['ch_name'],
coil_class=coil['coil_class'],
accuracy=coil['accuracy'],
base=coil['base'],
size=coil['size'],
type=ch['coil_type'],
w=coil['w'],
desc=coil['desc'],
coord_frame=FIFF.FIFFV_COORD_DEVICE,
rmag_orig=coil['rmag'],
cosmag_orig=coil['cosmag'],
coil_trans_orig=coil_trans,
r0=coil_trans[:3, 3],
rmag=apply_trans(coil_trans, coil['rmag']),
cosmag=apply_trans(coil_trans, coil['cosmag'], False))
if do_es:
r0_exey = (np.dot(coil['rmag'][:, :2], coil_trans[:3, :2].T) +
coil_trans[:3, 3])
res.update(ex=coil_trans[:3, 0],
ey=coil_trans[:3, 1],
ez=coil_trans[:3, 2],
r0_exey=r0_exey)
return res
def _check_infos_trans(infos):
"""XXX this goes to tests later, currently not used"""
chan_max_idx = np.argmax([c['nchan'] for c in infos])
chan_template = infos[chan_max_idx]['ch_names']
channels = [c['ch_names'] for c in infos]
common_channels = set(chan_template).intersection(*channels)
common_chs = [[c['chs'][c['ch_names'].index(ch)] for ch in common_channels]
for c in infos]
dev_ctf_trans = [i['dev_ctf_t']['trans'] for i in infos]
cns = [[c['ch_name'] for c in cc] for cc in common_chs]
for cn1, cn2 in itt.combinations(cns, 2):
assert cn1 == cn2
# BTI stores data in head coords, as a consequence the coordinates
# change across run, we apply the ctf->ctf_head transform here
# to check that all transforms are correct.
cts = [np.array([linalg.inv(_loc_to_coil_trans(c['loc'])).dot(t)
for c in cc])
for t, cc in zip(dev_ctf_trans, common_chs)]
for ct1, ct2 in itt.combinations(cts, 2):
np.testing.assert_array_almost_equal(ct1, ct2, 12)
def _check_infos_trans(infos):
"""XXX this goes to tests later, currently not used"""
chan_max_idx = np.argmax([c['nchan'] for c in infos])
chan_template = infos[chan_max_idx]['ch_names']
channels = [c['ch_names'] for c in infos]
common_channels = set(chan_template).intersection(*channels)
common_chs = [[c['chs'][c['ch_names'].index(ch)] for ch in common_channels]
for c in infos]
dev_ctf_trans = [i['dev_ctf_t']['trans'] for i in infos]
cns = [[c['ch_name'] for c in cc] for cc in common_chs]
for cn1, cn2 in itt.combinations(cns, 2):
assert cn1 == cn2
# BTI stores data in head coords, as a consequence the coordinates
# change across run, we apply the ctf->ctf_head transform here
# to check that all transforms are correct.
cts = [np.array([linalg.inv(_loc_to_coil_trans(c['loc'])).dot(t)
for c in cc])
for t, cc in zip(dev_ctf_trans, common_chs)]
for ct1, ct2 in itt.combinations(cts, 2):
np.testing.assert_array_almost_equal(ct1, ct2, 12)
def test_read_raw_curry_rfDC(fname, tol, mock_dev_head_t, tmpdir):
"""Test reading CURRY files."""
if mock_dev_head_t:
if 'Curry 7' in fname: # not supported yet
return
# copy files to tmpdir
base = op.splitext(fname)[0]
for ext in ('.cdt', '.cdt.dpa'):
src = base + ext
dst = op.join(tmpdir, op.basename(base) + ext)
copyfile(src, dst)
if ext == '.cdt.dpa':
with open(dst, 'a') as fid:
fid.write(LM_CONTENT)
fname = op.join(tmpdir, op.basename(fname))
with open(fname + '.hpi', 'w') as fid:
fid.write(HPI_CONTENT)
# check data
bti_rfDC = read_raw_bti(pdf_fname=bti_rfDC_file, head_shape_fname=None)
with catch_logging() as log:
raw = read_raw_curry(fname, verbose=True)
log = log.getvalue()
if mock_dev_head_t:
assert 'Composing device' in log
else:
assert 'Leaving device' in log
assert 'no landmark' in log
# test on the eeg chans, since these were not renamed by curry
eeg_names = [
ch["ch_name"] for ch in raw.info["chs"]
if ch["kind"] == FIFF.FIFFV_EEG_CH
]
assert_allclose(raw.get_data(eeg_names),
bti_rfDC.get_data(eeg_names),
rtol=tol)
assert bti_rfDC.info['dev_head_t'] is not None # XXX probably a BTI bug
if mock_dev_head_t:
assert raw.info['dev_head_t'] is not None
assert_allclose(raw.info['dev_head_t']['trans'], WANT_TRANS, atol=1e-5)
else:
assert raw.info['dev_head_t'] is None
# check that most MEG sensors are approximately oriented outward from
# the device origin
n_meg = n_eeg = n_other = 0
pos = list()
nn = list()
for ch in raw.info['chs']:
if ch['kind'] == FIFF.FIFFV_MEG_CH:
assert ch['coil_type'] == FIFF.FIFFV_COIL_CTF_GRAD
t = _loc_to_coil_trans(ch['loc'])
pos.append(t[:3, 3])
nn.append(t[:3, 2])
assert_allclose(np.linalg.norm(nn[-1]), 1.)
n_meg += 1
elif ch['kind'] == FIFF.FIFFV_EEG_CH:
assert ch['coil_type'] == FIFF.FIFFV_COIL_EEG
n_eeg += 1
else:
assert ch['coil_type'] == FIFF.FIFFV_COIL_NONE
n_other += 1
assert n_meg == 148
assert n_eeg == 31
assert n_other == 15
pos = np.array(pos)
nn = np.array(nn)
rad, origin = _fit_sphere(pos, disp=False)
assert 0.11 < rad < 0.13
pos -= origin
pos /= np.linalg.norm(pos, axis=1, keepdims=True)
angles = np.abs(np.rad2deg(np.arccos((pos * nn).sum(-1))))
assert (angles < 20).sum() > 100
