def test_data():
"""Test reading raw Artemis123 files."""
_test_raw_reader(read_raw_artemis123,
input_fname=short_hpi_1kz_fname,
pos_fname=dig_fname,
verbose='error')
# test a random selected point
raw = read_raw_artemis123(short_hpi_1kz_fname,
preload=True,
add_head_trans=False)
meg_picks = pick_types(raw.info, meg=True, eeg=False)
# checked against matlab reader.
assert_allclose(raw[meg_picks[12]][0][0][123], 1.08239606023e-11)
dev_head_t_1 = np.array([[9.713e-01, 2.340e-01, -4.164e-02, 1.302e-04],
[-2.371e-01, 9.664e-01, -9.890e-02, 1.977e-03],
[1.710e-02, 1.059e-01, 9.942e-01, -8.159e-03],
[0.0, 0.0, 0.0, 1.0]])
dev_head_t_2 = np.array([[9.890e-01, 1.475e-01, -8.090e-03, 4.997e-04],
[-1.476e-01, 9.846e-01, -9.389e-02, 1.962e-03],
[-5.888e-03, 9.406e-02, 9.955e-01, -1.610e-02],
[0.0, 0.0, 0.0, 1.0]])
expected_dev_hpi_rr = np.array([[-0.01579644, 0.06527367, 0.00152648],
[0.06666813, 0.0148956, 0.00545488],
[-0.06699212, -0.01732376, 0.0112027]])
# test with head loc no digitization
raw = read_raw_artemis123(short_HPI_dip_fname, add_head_trans=True)
_assert_trans(raw.info['dev_head_t']['trans'], dev_head_t_1)
assert_equal(raw.info['sfreq'], 5000.0)
# test with head loc and digitization
with pytest.warns(RuntimeWarning, match='Large difference'):
raw = read_raw_artemis123(short_HPI_dip_fname,
add_head_trans=True,
pos_fname=dig_fname)
_assert_trans(raw.info['dev_head_t']['trans'], dev_head_t_1)
# test cHPI localization..
dev_hpi_rr = np.array([
p['r'] for p in raw.info['dig']
if p['coord_frame'] == FIFF.FIFFV_COORD_DEVICE
])
# points should be within 0.1 mm (1e-4m) and within 1%
assert_allclose(dev_hpi_rr, expected_dev_hpi_rr, atol=1e-4, rtol=0.01)
# test 1kz hpi head loc (different freq)
raw = read_raw_artemis123(short_hpi_1kz_fname, add_head_trans=True)
_assert_trans(raw.info['dev_head_t']['trans'], dev_head_t_2)
assert_equal(raw.info['sfreq'], 1000.0)
def test_calculate_chpi_coil_locs():
"""Test computing just cHPI locations."""
raw = read_raw_fif(chpi_fif_fname, allow_maxshield='yes', preload=True)
# This is a little hack (aliasing while decimating) to make it much faster
# for testing purposes only. We can relax this later if we find it breaks
# something.
raw_dec = _decimate_chpi(raw, 15)
times, cHPI_digs = _calculate_chpi_coil_locs(raw_dec, verbose='debug')
# spot check
assert_allclose(times[9], 9.9, atol=1e-3)
assert_allclose(cHPI_digs[9][2]['r'],
[-0.01937833, 0.00346804, 0.06331209], atol=1e-3)
assert_allclose(cHPI_digs[9][2]['gof'], 0.9957976, atol=1e-3)
assert_allclose(cHPI_digs[9][4]['r'],
[0.05442122, 0.00997692, 0.03721696], atol=1e-3)
assert_allclose(cHPI_digs[9][4]['gof'], 0.075700080794629199, atol=1e-3)
# test on 5k artemis data
raw = read_raw_artemis123(art_fname, preload=True)
times, cHPI_digs = _calculate_chpi_coil_locs(raw, verbose='debug')
assert_allclose(times[2], 2.9, atol=1e-3)
assert_allclose(cHPI_digs[2][0]['gof'], 0.9980471794552791, atol=1e-3)
assert_allclose(cHPI_digs[2][0]['r'],
[-0.0157762, 0.06655744, 0.00545172], atol=1e-3)
def test_calculate_chpi_coil_locs():
"""Test computing just cHPI locations."""
raw = read_raw_fif(chpi_fif_fname, allow_maxshield='yes', preload=True)
# This is a little hack (aliasing while decimating) to make it much faster
# for testing purposes only. We can relax this later if we find it breaks
# something.
raw_dec = _decimate_chpi(raw, 15)
times, cHPI_digs = _calculate_chpi_coil_locs(raw_dec, verbose='debug')
# spot check
assert_allclose(times[9], 9.9, atol=1e-3)
assert_allclose(cHPI_digs[9][2]['r'],
[-0.01937833, 0.00346804, 0.06331209], atol=1e-3)
assert_allclose(cHPI_digs[9][2]['gof'], 0.9957976, atol=1e-3)
assert_allclose(cHPI_digs[9][4]['r'],
[0.05442122, 0.00997692, 0.03721696], atol=1e-3)
assert_allclose(cHPI_digs[9][4]['gof'], 0.075700080794629199, atol=1e-3)
# test on 5k artemis data
raw = read_raw_artemis123(art_fname, preload=True)
times, cHPI_digs = _calculate_chpi_coil_locs(raw, verbose='debug')
assert_allclose(times[2], 2.9, atol=1e-3)
assert_allclose(cHPI_digs[2][0]['gof'], 0.9980471794552791, atol=1e-3)
assert_allclose(cHPI_digs[2][0]['r'],
[-0.0157762, 0.06655744, 0.00545172], atol=1e-3)
def test_data():
"""Test reading raw Artemis123 files."""
_test_raw_reader(read_raw_artemis123, input_fname=short_no_HPI_fname)
# test a random selected point
raw = read_raw_artemis123(short_no_HPI_fname, preload=True)
meg_picks = pick_types(raw.info, meg=True, eeg=False)
# checked against matlab reader.
assert_allclose(raw[meg_picks[12]][0][0][123], 3.072510659694672e-11)
def test_calculate_chpi_positions():
"""Test calculation of cHPI positions."""
# Check to make sure our fits match MF decently
mf_quats = read_head_pos(pos_fname)
raw = read_raw_fif(chpi_fif_fname, allow_maxshield='yes', preload=True)
# This is a little hack (aliasing while decimating) to make it much faster
# for testing purposes only. We can relax this later if we find it breaks
# something.
raw_dec = _decimate_chpi(raw, 15)
with catch_logging() as log:
py_quats = _calculate_chpi_positions(raw_dec,
t_step_max=1.,
verbose='debug')
assert log.getvalue().startswith('HPIFIT')
_assert_quats(py_quats, mf_quats, dist_tol=0.004, angle_tol=2.5)
# degenerate conditions
raw_no_chpi = read_raw_fif(test_fif_fname)
pytest.raises(RuntimeError, _calculate_chpi_positions, raw_no_chpi)
raw_bad = raw.copy()
del raw_bad.info['hpi_meas'][0]['hpi_coils'][0]['coil_freq']
pytest.raises(RuntimeError, _calculate_chpi_positions, raw_bad)
raw_bad = raw.copy()
for d in raw_bad.info['dig']:
if d['kind'] == FIFF.FIFFV_POINT_HPI:
d['coord_frame'] = FIFF.FIFFV_COORD_UNKNOWN
break
pytest.raises(RuntimeError, _calculate_chpi_positions, raw_bad)
for d in raw_bad.info['dig']:
if d['kind'] == FIFF.FIFFV_POINT_HPI:
d['coord_frame'] = FIFF.FIFFV_COORD_HEAD
d['r'] = np.ones(3)
raw_bad.crop(0, 1.)
picks = np.concatenate([
np.arange(306, len(raw_bad.ch_names)),
pick_types(raw_bad.info, meg=True)[::16]
])
raw_bad.pick_channels([raw_bad.ch_names[pick] for pick in picks])
with warnings.catch_warnings(record=True): # bad pos
with catch_logging() as log_file:
_calculate_chpi_positions(raw_bad, t_step_min=1., verbose=True)
# ignore HPI info header and [done] footer
assert '0/5 good' in log_file.getvalue().strip().split('\n')[-2]
# half the rate cuts off cHPI coils
raw.info['lowpass'] /= 2.
with pytest.raises(RuntimeError, match='above the'):
_calculate_chpi_positions(raw)
# test on 5k artemis data
raw = read_raw_artemis123(art_fname, preload=True)
mf_quats = read_head_pos(art_mc_fname)
with catch_logging() as log:
py_quats = _calculate_chpi_positions(raw,
t_step_min=2.,
verbose='debug')
_assert_quats(py_quats, mf_quats, dist_tol=0.004, angle_tol=2.5)
def test_calculate_chpi_positions_artemis():
"""Test on 5k artemis data."""
raw = read_raw_artemis123(art_fname, preload=True)
mf_quats = read_head_pos(art_mc_fname)
mf_quats[:, 8:] /= 100 # old code errantly had this factor
py_quats = _calculate_chpi_positions(raw, t_step_min=2., verbose='debug')
_assert_quats(
py_quats, mf_quats,
dist_tol=0.001, angle_tol=1., err_rtol=0.7, vel_atol=1e-2)
def test_data():
"""Test reading raw Artemis123 files."""
_test_raw_reader(read_raw_artemis123,
input_fname=short_hpi_1kz_fname,
pos_fname=dig_fname,
verbose='error')
# test a random selected point
raw = read_raw_artemis123(short_hpi_1kz_fname,
preload=True,
add_head_trans=False)
meg_picks = pick_types(raw.info, meg=True, eeg=False)
# checked against matlab reader.
assert_allclose(raw[meg_picks[12]][0][0][123], 1.08239606023e-11)
dev_head_t_1 = np.array([[9.713e-01, 2.340e-01, -4.164e-02, 1.302e-04],
[-2.371e-01, 9.664e-01, -9.890e-02, 1.977e-03],
[1.710e-02, 1.059e-01, 9.942e-01, -8.159e-03],
[0.0, 0.0, 0.0, 1.0]])
dev_head_t_2 = np.array([[9.890e-01, 1.475e-01, -8.090e-03, 4.997e-04],
[-1.476e-01, 9.846e-01, -9.389e-02, 1.962e-03],
[-5.888e-03, 9.406e-02, 9.955e-01, -1.610e-02],
[0.0, 0.0, 0.0, 1.0]])
# test with head loc no digitization
raw = read_raw_artemis123(short_HPI_dip_fname, add_head_trans=True)
_assert_trans(raw.info['dev_head_t']['trans'], dev_head_t_1)
assert_equal(raw.info['sfreq'], 5000.0)
# test with head loc and digitization
with warnings.catch_warnings(record=True): # bad dig
raw = read_raw_artemis123(short_HPI_dip_fname,
add_head_trans=True,
pos_fname=dig_fname)
_assert_trans(raw.info['dev_head_t']['trans'], dev_head_t_1)
# test 1kz hpi head loc (different freq)
raw = read_raw_artemis123(short_hpi_1kz_fname, add_head_trans=True)
_assert_trans(raw.info['dev_head_t']['trans'], dev_head_t_2)
assert_equal(raw.info['sfreq'], 1000.0)
def test_calculate_chpi_positions():
"""Test calculation of cHPI positions."""
# Check to make sure our fits match MF decently
mf_quats = read_head_pos(pos_fname)
raw = read_raw_fif(chpi_fif_fname, allow_maxshield='yes', preload=True)
# This is a little hack (aliasing while decimating) to make it much faster
# for testing purposes only. We can relax this later if we find it breaks
# something.
raw_dec = _decimate_chpi(raw, 15)
with catch_logging() as log:
py_quats = _calculate_chpi_positions(raw_dec, t_step_max=1.,
verbose='debug')
assert_true(log.getvalue().startswith('HPIFIT'))
_assert_quats(py_quats, mf_quats, dist_tol=0.004, angle_tol=2.5)
# degenerate conditions
raw_no_chpi = read_raw_fif(test_fif_fname)
assert_raises(RuntimeError, _calculate_chpi_positions, raw_no_chpi)
raw_bad = raw.copy()
del raw_bad.info['hpi_meas'][0]['hpi_coils'][0]['coil_freq']
assert_raises(RuntimeError, _calculate_chpi_positions, raw_bad)
raw_bad = raw.copy()
for d in raw_bad.info['dig']:
if d['kind'] == FIFF.FIFFV_POINT_HPI:
d['coord_frame'] = FIFF.FIFFV_COORD_UNKNOWN
break
assert_raises(RuntimeError, _calculate_chpi_positions, raw_bad)
for d in raw_bad.info['dig']:
if d['kind'] == FIFF.FIFFV_POINT_HPI:
d['coord_frame'] = FIFF.FIFFV_COORD_HEAD
d['r'] = np.ones(3)
raw_bad.crop(0, 1.)
picks = np.concatenate([np.arange(306, len(raw_bad.ch_names)),
pick_types(raw_bad.info, meg=True)[::16]])
raw_bad.pick_channels([raw_bad.ch_names[pick] for pick in picks])
with warnings.catch_warnings(record=True): # bad pos
with catch_logging() as log_file:
_calculate_chpi_positions(raw_bad, t_step_min=1., verbose=True)
# ignore HPI info header and [done] footer
assert_true('0/5 good' in log_file.getvalue().strip().split('\n')[-2])
# half the rate cuts off cHPI coils
raw.info['lowpass'] /= 2.
assert_raises_regex(RuntimeError, 'above the',
_calculate_chpi_positions, raw)
# test on 5k artemis data
raw = read_raw_artemis123(art_fname, preload=True)
mf_quats = read_head_pos(art_mc_fname)
with catch_logging() as log:
py_quats = _calculate_chpi_positions(raw, t_step_min=2.,
verbose='debug')
_assert_quats(py_quats, mf_quats, dist_tol=0.004, angle_tol=2.5)
def test_data():
"""Test reading raw Artemis123 files."""
_test_raw_reader(read_raw_artemis123, input_fname=short_hpi_1kz_fname,
pos_fname=dig_fname, verbose='error')
# test a random selected point
raw = read_raw_artemis123(short_hpi_1kz_fname, preload=True,
add_head_trans=False)
meg_picks = pick_types(raw.info, meg=True, eeg=False)
# checked against matlab reader.
assert_allclose(raw[meg_picks[12]][0][0][123], 1.08239606023e-11)
dev_head_t_1 = np.array([[9.713e-01, 2.340e-01, -4.164e-02, 1.302e-04],
[-2.371e-01, 9.664e-01, -9.890e-02, 1.977e-03],
[1.710e-02, 1.059e-01, 9.942e-01, -8.159e-03],
[0.0, 0.0, 0.0, 1.0]])
dev_head_t_2 = np.array([[9.890e-01, 1.475e-01, -8.090e-03, 4.997e-04],
[-1.476e-01, 9.846e-01, -9.389e-02, 1.962e-03],
[-5.888e-03, 9.406e-02, 9.955e-01, -1.610e-02],
[0.0, 0.0, 0.0, 1.0]])
# test with head loc no digitization
raw = read_raw_artemis123(short_HPI_dip_fname, add_head_trans=True)
_assert_trans(raw.info['dev_head_t']['trans'], dev_head_t_1)
assert_equal(raw.info['sfreq'], 5000.0)
# test with head loc and digitization
with pytest.warns(RuntimeWarning, match='Large difference'):
raw = read_raw_artemis123(short_HPI_dip_fname, add_head_trans=True,
pos_fname=dig_fname)
_assert_trans(raw.info['dev_head_t']['trans'], dev_head_t_1)
# test 1kz hpi head loc (different freq)
raw = read_raw_artemis123(short_hpi_1kz_fname, add_head_trans=True)
_assert_trans(raw.info['dev_head_t']['trans'], dev_head_t_2)
assert_equal(raw.info['sfreq'], 1000.0)
def test_calculate_chpi_coil_locs_artemis():
"""Test computing just cHPI locations."""
raw = read_raw_fif(chpi_fif_fname, allow_maxshield='yes', preload=True)
# This is a little hack (aliasing while decimating) to make it much faster
# for testing purposes only. We can relax this later if we find it breaks
# something.
raw_dec = _decimate_chpi(raw, 15)
times, cHPI_digs = _calculate_chpi_coil_locs(raw_dec, verbose='debug')
# spot check
assert_allclose(times[0], 9., atol=1e-2)
assert_allclose(cHPI_digs[0][2]['r'],
[-0.01937833, 0.00346804, 0.06331209], atol=1e-3)
assert_allclose(cHPI_digs[0][2]['gof'], 0.9957, atol=1e-3)
assert_allclose(cHPI_digs[0][4]['r'],
[-0.0655, 0.0755, 0.0004], atol=3e-3)
assert_allclose(cHPI_digs[0][4]['gof'], 0.9323, atol=1e-3)
_check_dists(raw.info, cHPI_digs[0], n_bad=1)
# test on 5k artemis data
raw = read_raw_artemis123(art_fname, preload=True)
times, cHPI_digs = _calculate_chpi_coil_locs(raw, verbose='debug')
assert len(np.setdiff1d(times, raw.times + raw.first_time)) == 0
# Should be somewhere around 1.5 sec, depending on coil GOF values
# around 0.98 it can change
assert_allclose(times[5], 1.5, atol=2e-1)
assert_allclose(cHPI_digs[5][0]['gof'], 0.995, atol=5e-3)
assert_allclose(cHPI_digs[5][0]['r'],
[-0.0157, 0.0655, 0.0018], atol=1e-3)
_check_dists(raw.info, cHPI_digs[5])
coil_amplitudes = compute_chpi_amplitudes(raw)
with pytest.raises(ValueError, match='too_close'):
compute_chpi_locs(raw.info, coil_amplitudes, too_close='foo')
# ensure values are in a reasonable range
amps = np.linalg.norm(coil_amplitudes['slopes'], axis=-1)
amps /= coil_amplitudes['slopes'].shape[-1]
assert amps.shape == (len(coil_amplitudes['times']), 3)
assert_array_less(amps, 1e-11)
assert_array_less(1e-13, amps)
# with nan amplitudes (i.e., cHPI off) it should return an empty array,
# but still one that is 3D
coil_amplitudes['slopes'].fill(np.nan)
chpi_locs = compute_chpi_locs(raw.info, coil_amplitudes)
assert chpi_locs['rrs'].shape == (0, 3, 3)
pos = compute_head_pos(raw.info, chpi_locs)
assert pos.shape == (0, 10)
def test_calculate_chpi_positions():
"""Test calculation of cHPI positions."""
# Check to make sure our fits match MF decently
mf_quats = read_head_pos(pos_fname)
raw = read_raw_fif(chpi_fif_fname, allow_maxshield='yes', preload=True)
# This is a little hack (aliasing while decimating) to make it much faster
# for testing purposes only. We can relax this later if we find it breaks
# something.
raw_dec = _decimate_chpi(raw, 15)
with catch_logging() as log:
py_quats = _calculate_chpi_positions(raw_dec, verbose='debug')
assert_true(log.getvalue().startswith('HPIFIT'))
_assert_quats(py_quats, mf_quats, dist_tol=0.004, angle_tol=2.5)
# degenerate conditions
raw_no_chpi = read_raw_fif(test_fif_fname)
assert_raises(RuntimeError, _calculate_chpi_positions, raw_no_chpi)
raw_bad = raw.copy()
for d in raw_bad.info['dig']:
if d['kind'] == FIFF.FIFFV_POINT_HPI:
d['coord_frame'] = 999
break
assert_raises(RuntimeError, _calculate_chpi_positions, raw_bad)
raw_bad = raw.copy()
for d in raw_bad.info['dig']:
if d['kind'] == FIFF.FIFFV_POINT_HPI:
d['r'] = np.ones(3)
raw_bad.crop(0, 1.)
with warnings.catch_warnings(record=True): # bad pos
with catch_logging() as log_file:
_calculate_chpi_positions(raw_bad, t_step_min=5., verbose=True)
# ignore HPI info header and [done] footer
assert_true('0/5 good' in log_file.getvalue().strip().split('\n')[-2])
# half the rate cuts off cHPI coils
raw.info['lowpass'] /= 2.
assert_raises_regex(RuntimeError, 'above the',
_calculate_chpi_positions, raw)
# test on 5k artemis data
raw = read_raw_artemis123(art_fname, preload=True)
mf_quats = read_head_pos(art_mc_fname)
with catch_logging() as log:
py_quats = _calculate_chpi_positions(raw, verbose='debug')
_assert_quats(py_quats, mf_quats, dist_tol=0.004, angle_tol=2.5)
def test_calculate_chpi_coil_locs_artemis():
"""Test computing just cHPI locations."""
raw = read_raw_fif(chpi_fif_fname, allow_maxshield='yes', preload=True)
# This is a little hack (aliasing while decimating) to make it much faster
# for testing purposes only. We can relax this later if we find it breaks
# something.
raw_dec = _decimate_chpi(raw, 15)
times, cHPI_digs = _calculate_chpi_coil_locs(raw_dec, verbose='debug')
# spot check
assert_allclose(times[0], 9., atol=1e-2)
assert_allclose(cHPI_digs[0][2]['r'],
[-0.01937833, 0.00346804, 0.06331209], atol=1e-3)
assert_allclose(cHPI_digs[0][2]['gof'], 0.9957, atol=1e-3)
assert_allclose(cHPI_digs[0][4]['r'],
[-0.0655, 0.0755, 0.0004], atol=3e-3)
assert_allclose(cHPI_digs[0][4]['gof'], 0.9323, atol=1e-3)
_check_dists(raw.info, cHPI_digs[0], n_bad=1)
# test on 5k artemis data
raw = read_raw_artemis123(art_fname, preload=True)
times, cHPI_digs = _calculate_chpi_coil_locs(raw, verbose='debug')
assert_allclose(times[5], 1.5, atol=1e-3)
assert_allclose(cHPI_digs[5][0]['gof'], 0.995, atol=5e-3)
assert_allclose(cHPI_digs[5][0]['r'],
[-0.0157, 0.0655, 0.0018], atol=1e-3)
_check_dists(raw.info, cHPI_digs[5])
coil_amplitudes = compute_chpi_amplitudes(raw)
with pytest.raises(ValueError, match='too_close'):
compute_chpi_locs(raw, coil_amplitudes, too_close='foo')
# ensure values are in a reasonable range
amps = np.linalg.norm(coil_amplitudes['slopes'], axis=-1)
amps /= coil_amplitudes['slopes'].shape[-1]
assert amps.shape == (len(coil_amplitudes['times']), 3)
assert_array_less(amps, 1e-11)
assert_array_less(1e-13, amps)
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 = {
'Neuromag': read_raw_fif(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(op.join(bti_path, 'test_pdf_linux'),
op.join(bti_path, 'test_config_linux'),
op.join(bti_path, 'test_hs_linux')),
'KIT': read_raw_kit(op.join(kit_path, 'test.sqd')),
'Artemis123': read_raw_artemis123(op.join(
testing.data_path(), 'ARTEMIS123',
'Artemis_Data_2017-04-14-10h-38m-59s_Phantom_1k_HPI_1s.bin')),
}
for system, raw in sorted(raws.items()):
meg = ['helmet', 'sensors']
# We don't have coil definitions for KIT refs, so exclude them
if system != 'KIT':
meg.append('ref')
fig = plot_alignment(raw.info, trans=None, dig=False, eeg=False,
surfaces=[], meg=meg, coord_frame='meg',
verbose=True)
text = mlab.title(system)
text.x_position = 0.5
text.y_position = 0.95
text.property.vertical_justification = 'top'
kit_path = op.abspath(op.dirname(mne.__file__)) + '/io/kit/tests/data/'
raws = {
'Neuromag':
read_raw_fif(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(op.join(bti_path, 'test_pdf_linux'),
op.join(bti_path, 'test_config_linux'),
op.join(bti_path, 'test_hs_linux')),
'KIT':
read_raw_kit(op.join(kit_path, 'test.sqd')),
'Artemis123':
read_raw_artemis123(
op.join(testing.data_path(), 'ARTEMIS123',
'Artemis_Data_2017-04-14-10h-38m-59s_Phantom_1k_HPI_1s.bin')),
}
for system, raw in sorted(raws.items()):
meg = ['helmet', 'sensors']
# We don't have coil definitions for KIT refs, so exclude them
if system != 'KIT':
meg.append('ref')
fig = plot_alignment(raw.info,
eeg=False,
meg=('helmet', 'sensors'),
coord_frame='meg',
show_axes=True,
verbose=True)
set_3d_title(figure=fig, title=system)
def test_calculate_chpi_positions_artemis():
"""Test on 5k artemis data."""
raw = read_raw_artemis123(art_fname, preload=True)
mf_quats = read_head_pos(art_mc_fname)
py_quats = _calculate_chpi_positions(raw, t_step_min=2., verbose='debug')
_assert_quats(py_quats, mf_quats, dist_tol=0.001, angle_tol=1.)
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=read_raw_fif(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(op.join(bti_path, 'test_pdf_linux'),
op.join(bti_path, 'test_config_linux'),
op.join(bti_path, 'test_hs_linux')),
KIT=read_raw_kit(op.join(kit_path, 'test.sqd')),
Artemis123=read_raw_artemis123(
op.join(testing.data_path(), 'ARTEMIS123',
'Artemis_Data_2016-11-03-15h-58m_test.bin')))
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)
text = mlab.title(system)
text.x_position = 0.5
text.y_position = 0.95
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=read_raw_fif(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(op.join(bti_path, 'test_pdf_linux'),
op.join(bti_path, 'test_config_linux'),
op.join(bti_path, 'test_hs_linux')),
KIT=read_raw_kit(op.join(kit_path, 'test.sqd')),
Artemis123=read_raw_artemis123(op.join(testing.data_path(), 'ARTEMIS123',
'Artemis_Data_2016-11-03-15h-58m_test.bin'))
)
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)
text = mlab.title(system)
text.x_position = 0.5
text.y_position = 0.95
text.property.vertical_justification = 'top'
text.property.justification = 'center'
text.actor.text_scale_mode = 'none'
text.property.bold = True
mlab.draw(fig)
# %%
# BTi
# ---
bti_path = op.abspath(op.dirname(mne.__file__)) + '/io/bti/tests/data/'
raw = read_raw_bti(op.join(bti_path, 'test_pdf_linux'),
op.join(bti_path, 'test_config_linux'),
op.join(bti_path, 'test_hs_linux'))
fig = plot_alignment(raw.info, meg=('helmet', 'sensors', 'ref'), **kwargs)
set_3d_title(figure=fig, title='Magnes 3600wh')
# %%
# KIT
# ---
kit_path = op.abspath(op.dirname(mne.__file__)) + '/io/kit/tests/data/'
raw = read_raw_kit(op.join(kit_path, 'test.sqd'))
fig = plot_alignment(raw.info, meg=('helmet', 'sensors'), **kwargs)
set_3d_title(figure=fig, title='KIT')
# %%
# Artemis123
# ----------
raw = read_raw_artemis123(
testing.data_path() / 'ARTEMIS123' /
'Artemis_Data_2017-04-14-10h-38m-59s_Phantom_1k_HPI_1s.bin')
fig = plot_alignment(raw.info, meg=('helmet', 'sensors', 'ref'), **kwargs)
set_3d_title(figure=fig, title='Artemis123')