def test_io_raw():
"""Test IO for raw data (Neuromag + CTF)
"""
for fname in [fif_fname, ctf_fname]:
raw = Raw(fname)
nchan = raw.info['nchan']
ch_names = raw.info['ch_names']
meg_channels_idx = [k for k in range(nchan)
if ch_names[k][0] == 'M']
n_channels = 100
meg_channels_idx = meg_channels_idx[:n_channels]
start, stop = raw.time_to_index(0, 5)
data, times = raw[meg_channels_idx, start:(stop + 1)]
meg_ch_names = [ch_names[k] for k in meg_channels_idx]
# Set up pick list: MEG + STI 014 - bad channels
include = ['STI 014']
include += meg_ch_names
picks = pick_types(raw.info, meg=True, eeg=False,
stim=True, misc=True, include=include,
exclude=raw.info['bads'])
print "Number of picked channels : %d" % len(picks)
# Writing with drop_small_buffer True
raw.save('raw.fif', picks, tmin=0, tmax=4, buffer_size_sec=3,
drop_small_buffer=True)
raw2 = Raw('raw.fif')
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_true(times2.max() <= 3)
# Writing
raw.save('raw.fif', picks, tmin=0, tmax=5)
if fname == fif_fname:
assert_true(len(raw.info['dig']) == 146)
raw2 = Raw('raw.fif')
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_array_almost_equal(data, data2)
assert_array_almost_equal(times, times2)
assert_array_almost_equal(raw.info['dev_head_t']['trans'],
raw2.info['dev_head_t']['trans'])
assert_array_almost_equal(raw.info['sfreq'], raw2.info['sfreq'])
if fname == fif_fname:
assert_array_almost_equal(raw.info['dig'][0]['r'],
raw2.info['dig'][0]['r'])
fname = op.join(op.dirname(__file__), 'data', 'test_raw.fif')
def test_io_raw():
"""Test IO for raw data (Neuromag + CTF + gz)
"""
fnames_in = [fif_fname, fif_gz_fname, ctf_fname]
fnames_out = ["raw.fif", "raw.fif.gz", "raw.fif"]
for fname_in, fname_out in zip(fnames_in, fnames_out):
raw = Raw(fname_in)
nchan = raw.info["nchan"]
ch_names = raw.info["ch_names"]
meg_channels_idx = [k for k in range(nchan) if ch_names[k][0] == "M"]
n_channels = 100
meg_channels_idx = meg_channels_idx[:n_channels]
start, stop = raw.time_as_index([0, 5])
data, times = raw[meg_channels_idx, start : (stop + 1)]
meg_ch_names = [ch_names[k] for k in meg_channels_idx]
# Set up pick list: MEG + STI 014 - bad channels
include = ["STI 014"]
include += meg_ch_names
picks = pick_types(
raw.info, meg=True, eeg=False, stim=True, misc=True, include=include, exclude=raw.info["bads"]
)
print "Number of picked channels : %d" % len(picks)
# Writing with drop_small_buffer True
raw.save(fname_out, picks, tmin=0, tmax=4, buffer_size_sec=3, drop_small_buffer=True)
raw2 = Raw(fname_out, preload=True)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_true(times2.max() <= 3)
# Writing
raw.save(fname_out, picks, tmin=0, tmax=5)
if fname_in == fif_fname or fname_in == fif_fname + ".gz":
assert_true(len(raw.info["dig"]) == 146)
raw2 = Raw(fname_out)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_array_almost_equal(data, data2)
assert_array_almost_equal(times, times2)
assert_array_almost_equal(raw.info["dev_head_t"]["trans"], raw2.info["dev_head_t"]["trans"])
assert_array_almost_equal(raw.info["sfreq"], raw2.info["sfreq"])
if fname_in == fif_fname or fname_in == fif_fname + ".gz":
assert_array_almost_equal(raw.info["dig"][0]["r"], raw2.info["dig"][0]["r"])
def find_next_analogue_trigger(raw, ind, ana_channel='MISC001',
lowlim=0.1, hilim=0.2):
#print 'Nothing here yet'
pick = pick_channels(raw.info['ch_names'], include=ana_channel)
ana_data, _ = raw[pick,ind:ind+200]
return next_crossing(ana_data[0,:].squeeze(),lowlim)
def test_cov_estimation_on_raw_segment():
"""Test estimation from raw on continuous recordings (typically empty room)
"""
raw = Raw(raw_fname, preload=False)
cov = compute_raw_data_covariance(raw)
cov_mne = read_cov(erm_cov_fname)
assert_true(cov_mne.ch_names == cov.ch_names)
assert_true(linalg.norm(cov.data - cov_mne.data, ord='fro')
/ linalg.norm(cov.data, ord='fro') < 1e-4)
# test IO when computation done in Python
cov.save(op.join(tempdir, 'test-cov.fif')) # test saving
cov_read = read_cov(op.join(tempdir, 'test-cov.fif'))
assert_true(cov_read.ch_names == cov.ch_names)
assert_true(cov_read.nfree == cov.nfree)
assert_array_almost_equal(cov.data, cov_read.data)
# test with a subset of channels
picks = pick_channels(raw.ch_names, include=raw.ch_names[:5])
cov = compute_raw_data_covariance(raw, picks=picks)
assert_true(cov_mne.ch_names[:5] == cov.ch_names)
assert_true(linalg.norm(cov.data - cov_mne.data[picks][:, picks],
ord='fro') / linalg.norm(cov.data, ord='fro') < 1e-4)
# make sure we get a warning with too short a segment
raw_2 = raw.crop(0, 1)
with warnings.catch_warnings(record=True) as w:
cov = compute_raw_data_covariance(raw_2)
assert_true(len(w) == 1)
def test_cov_estimation_on_raw_segment():
"""Estimate raw on continuous recordings (typically empty room)
"""
raw = Raw(raw_fname)
cov = compute_raw_data_covariance(raw)
cov_mne = read_cov(erm_cov_fname)
assert_true(cov_mne.ch_names == cov.ch_names)
print (linalg.norm(cov.data - cov_mne.data, ord='fro')
/ linalg.norm(cov.data, ord='fro'))
assert_true(linalg.norm(cov.data - cov_mne.data, ord='fro')
/ linalg.norm(cov.data, ord='fro')) < 1e-6
# test IO when computation done in Python
cov.save('test-cov.fif') # test saving
cov_read = read_cov('test-cov.fif')
assert_true(cov_read.ch_names == cov.ch_names)
assert_true(cov_read.nfree == cov.nfree)
assert_true((linalg.norm(cov.data - cov_read.data, ord='fro')
/ linalg.norm(cov.data, ord='fro')) < 1e-5)
# test with a subset of channels
picks = pick_channels(raw.ch_names, include=raw.ch_names[:5])
cov = compute_raw_data_covariance(raw, picks=picks)
assert_true(cov_mne.ch_names[:5] == cov.ch_names)
assert_true(linalg.norm(cov.data - cov_mne.data[picks][:, picks],
ord='fro') / linalg.norm(cov.data, ord='fro')) < 1e-6
def test_cov_estimation_on_raw_segment():
"""Test estimation from raw on continuous recordings (typically empty room)
"""
raw = Raw(raw_fname, preload=False)
cov = compute_raw_data_covariance(raw)
cov_mne = read_cov(erm_cov_fname)
assert_true(cov_mne.ch_names == cov.ch_names)
assert_true(
linalg.norm(cov.data - cov_mne.data, ord='fro') /
linalg.norm(cov.data, ord='fro') < 1e-4)
# test IO when computation done in Python
cov.save(op.join(tempdir, 'test-cov.fif')) # test saving
cov_read = read_cov(op.join(tempdir, 'test-cov.fif'))
assert_true(cov_read.ch_names == cov.ch_names)
assert_true(cov_read.nfree == cov.nfree)
assert_array_almost_equal(cov.data, cov_read.data)
# test with a subset of channels
picks = pick_channels(raw.ch_names, include=raw.ch_names[:5])
cov = compute_raw_data_covariance(raw, picks=picks)
assert_true(cov_mne.ch_names[:5] == cov.ch_names)
assert_true(
linalg.norm(cov.data - cov_mne.data[picks][:, picks], ord='fro') /
linalg.norm(cov.data, ord='fro') < 1e-4)
# make sure we get a warning with too short a segment
raw_2 = raw.crop(0, 1)
with warnings.catch_warnings(record=True) as w:
cov = compute_raw_data_covariance(raw_2)
assert_true(len(w) == 1)
def test_comparision_with_c():
"""Test of average obtained vs C code
"""
c_evoked = fiff.Evoked(evoked_nf_name, setno=0)
epochs = Epochs(raw, events, event_id, tmin, tmax, baseline=None, preload=True, reject=None, flat=None)
evoked = epochs.average()
sel = fiff.pick_channels(c_evoked.ch_names, evoked.ch_names)
evoked_data = evoked.data
c_evoked_data = c_evoked.data[sel]
assert_true(evoked.nave == c_evoked.nave)
assert_array_almost_equal(evoked_data, c_evoked_data, 10)
assert_array_almost_equal(evoked.times, c_evoked.times, 12)
def test_comparision_with_c():
"""Test of average obtained vs C code
"""
c_evoked = fiff.Evoked(evoked_nf_name, setno=0)
epochs = Epochs(raw, events, event_id, tmin, tmax,
baseline=None, preload=True,
reject=None, flat=None)
evoked = epochs.average()
sel = fiff.pick_channels(c_evoked.ch_names, evoked.ch_names)
evoked_data = evoked.data
c_evoked_data = c_evoked.data[sel]
assert_true(evoked.nave == c_evoked.nave)
assert_array_almost_equal(evoked_data, c_evoked_data, 10)
assert_array_almost_equal(evoked.times, c_evoked.times, 12)
def test_cov_estimation_on_raw_segment():
"""Test estimation from raw on continuous recordings (typically empty room)
"""
cov = compute_raw_data_covariance(raw)
cov_mne = read_cov(erm_cov_fname)
assert_true(cov_mne.ch_names == cov.ch_names)
assert_true(
linalg.norm(cov.data - cov_mne.data, ord='fro') /
linalg.norm(cov.data, ord='fro') < 1e-4)
# test IO when computation done in Python
cov.save('test-cov.fif') # test saving
cov_read = read_cov('test-cov.fif')
assert_true(cov_read.ch_names == cov.ch_names)
assert_true(cov_read.nfree == cov.nfree)
assert_array_almost_equal(cov.data, cov_read.data)
# test with a subset of channels
picks = pick_channels(raw.ch_names, include=raw.ch_names[:5])
cov = compute_raw_data_covariance(raw, picks=picks)
assert_true(cov_mne.ch_names[:5] == cov.ch_names)
assert_true(
linalg.norm(cov.data - cov_mne.data[picks][:, picks], ord='fro') /
linalg.norm(cov.data, ord='fro') < 1e-4)
def test_io_raw():
"""Test IO for raw data (Neuromag + CTF + gz)
"""
fnames_in = [fif_fname, fif_gz_fname, ctf_fname]
fnames_out = ['raw.fif', 'raw.fif.gz', 'raw.fif']
for fname_in, fname_out in zip(fnames_in, fnames_out):
fname_out = op.join(tempdir, fname_out)
raw = Raw(fname_in)
nchan = raw.info['nchan']
ch_names = raw.info['ch_names']
meg_channels_idx = [k for k in range(nchan)
if ch_names[k][0] == 'M']
n_channels = 100
meg_channels_idx = meg_channels_idx[:n_channels]
start, stop = raw.time_as_index([0, 5])
data, times = raw[meg_channels_idx, start:(stop + 1)]
meg_ch_names = [ch_names[k] for k in meg_channels_idx]
# Set up pick list: MEG + STI 014 - bad channels
include = ['STI 014']
include += meg_ch_names
picks = pick_types(raw.info, meg=True, eeg=False, stim=True,
misc=True, include=include, exclude='bads')
# Writing with drop_small_buffer True
raw.save(fname_out, picks, tmin=0, tmax=4, buffer_size_sec=3,
drop_small_buffer=True)
raw2 = Raw(fname_out, preload=True)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_true(times2.max() <= 3)
# Writing
raw.save(fname_out, picks, tmin=0, tmax=5)
if fname_in == fif_fname or fname_in == fif_fname + '.gz':
assert_true(len(raw.info['dig']) == 146)
raw2 = Raw(fname_out)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_array_almost_equal(data, data2)
assert_array_almost_equal(times, times2)
assert_array_almost_equal(raw.info['sfreq'], raw2.info['sfreq'])
# check transformations
for trans in ['dev_head_t', 'dev_ctf_t', 'ctf_head_t']:
if raw.info[trans] is None:
assert_true(raw2.info[trans] is None)
else:
assert_array_equal(raw.info[trans]['trans'],
raw2.info[trans]['trans'])
# check transformation 'from' and 'to'
if trans.startswith('dev'):
from_id = FIFF.FIFFV_COORD_DEVICE
else:
from_id = FIFF.FIFFV_MNE_COORD_CTF_HEAD
if trans[4:8] == 'head':
to_id = FIFF.FIFFV_COORD_HEAD
else:
to_id = FIFF.FIFFV_MNE_COORD_CTF_HEAD
for raw_ in [raw, raw2]:
assert_true(raw_.info[trans]['from'] == from_id)
assert_true(raw_.info[trans]['to'] == to_id)
if fname_in == fif_fname or fname_in == fif_fname + '.gz':
assert_array_almost_equal(raw.info['dig'][0]['r'],
raw2.info['dig'][0]['r'])
def test_io_raw():
"""Test IO for raw data (Neuromag + CTF + gz)
"""
# Let's construct a simple test for IO first
raw = Raw(fif_fname, preload=True)
raw.crop(0, 3.5)
# put in some data that we know the values of
data = np.random.randn(raw._data.shape[0], raw._data.shape[1])
raw._data[:, :] = data
# save it somewhere
fname = op.join(tempdir, 'test_copy_raw.fif')
raw.save(fname, buffer_size_sec=1.0)
# read it in, make sure the whole thing matches
raw = Raw(fname)
assert_true(np.allclose(data, raw[:, :][0], 1e-6, 1e-20))
# let's read portions across the 1-sec tag boundary, too
inds = raw.time_as_index([1.75, 2.25])
sl = slice(inds[0], inds[1])
assert_true(np.allclose(data[:, sl], raw[:, sl][0], 1e-6, 1e-20))
# now let's do some real I/O
fnames_in = [fif_fname, fif_gz_fname, ctf_fname]
fnames_out = ['raw.fif', 'raw.fif.gz', 'raw.fif']
for fname_in, fname_out in zip(fnames_in, fnames_out):
fname_out = op.join(tempdir, fname_out)
raw = Raw(fname_in)
nchan = raw.info['nchan']
ch_names = raw.info['ch_names']
meg_channels_idx = [k for k in range(nchan)
if ch_names[k][0] == 'M']
n_channels = 100
meg_channels_idx = meg_channels_idx[:n_channels]
start, stop = raw.time_as_index([0, 5])
data, times = raw[meg_channels_idx, start:(stop + 1)]
meg_ch_names = [ch_names[k] for k in meg_channels_idx]
# Set up pick list: MEG + STI 014 - bad channels
include = ['STI 014']
include += meg_ch_names
picks = pick_types(raw.info, meg=True, eeg=False, stim=True,
misc=True, ref_meg=True, include=include,
exclude='bads')
# Writing with drop_small_buffer True
raw.save(fname_out, picks, tmin=0, tmax=4, buffer_size_sec=3,
drop_small_buffer=True, overwrite=True)
raw2 = Raw(fname_out, preload=True)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_true(times2.max() <= 3)
# Writing
raw.save(fname_out, picks, tmin=0, tmax=5, overwrite=True)
if fname_in == fif_fname or fname_in == fif_fname + '.gz':
assert_true(len(raw.info['dig']) == 146)
raw2 = Raw(fname_out)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_true(np.allclose(data, data2, 1e-6, 1e-20))
assert_allclose(times, times2)
assert_allclose(raw.info['sfreq'], raw2.info['sfreq'], rtol=1e-5)
# check transformations
for trans in ['dev_head_t', 'dev_ctf_t', 'ctf_head_t']:
if raw.info[trans] is None:
assert_true(raw2.info[trans] is None)
else:
assert_array_equal(raw.info[trans]['trans'],
raw2.info[trans]['trans'])
# check transformation 'from' and 'to'
if trans.startswith('dev'):
from_id = FIFF.FIFFV_COORD_DEVICE
else:
from_id = FIFF.FIFFV_MNE_COORD_CTF_HEAD
if trans[4:8] == 'head':
to_id = FIFF.FIFFV_COORD_HEAD
else:
to_id = FIFF.FIFFV_MNE_COORD_CTF_HEAD
for raw_ in [raw, raw2]:
assert_true(raw_.info[trans]['from'] == from_id)
assert_true(raw_.info[trans]['to'] == to_id)
if fname_in == fif_fname or fname_in == fif_fname + '.gz':
assert_allclose(raw.info['dig'][0]['r'], raw2.info['dig'][0]['r'])
def test_io_raw():
"""Test IO for raw data (Neuromag + CTF + gz)
"""
# Let's construct a simple test for IO first
raw = Raw(fif_fname, preload=True)
raw.crop(0, 3.5)
# put in some data that we know the values of
data = np.random.randn(raw._data.shape[0], raw._data.shape[1])
raw._data[:, :] = data
# save it somewhere
fname = op.join(tempdir, 'test_copy_raw.fif')
raw.save(fname, buffer_size_sec=1.0)
# read it in, make sure the whole thing matches
raw = Raw(fname)
assert_true(np.allclose(data, raw[:, :][0], 1e-6, 1e-20))
# let's read portions across the 1-sec tag boundary, too
inds = raw.time_as_index([1.75, 2.25])
sl = slice(inds[0], inds[1])
assert_true(np.allclose(data[:, sl], raw[:, sl][0], 1e-6, 1e-20))
# now let's do some real I/O
fnames_in = [fif_fname, fif_gz_fname, ctf_fname]
fnames_out = ['raw.fif', 'raw.fif.gz', 'raw.fif']
for fname_in, fname_out in zip(fnames_in, fnames_out):
fname_out = op.join(tempdir, fname_out)
raw = Raw(fname_in)
nchan = raw.info['nchan']
ch_names = raw.info['ch_names']
meg_channels_idx = [k for k in range(nchan) if ch_names[k][0] == 'M']
n_channels = 100
meg_channels_idx = meg_channels_idx[:n_channels]
start, stop = raw.time_as_index([0, 5])
data, times = raw[meg_channels_idx, start:(stop + 1)]
meg_ch_names = [ch_names[k] for k in meg_channels_idx]
# Set up pick list: MEG + STI 014 - bad channels
include = ['STI 014']
include += meg_ch_names
picks = pick_types(raw.info,
meg=True,
eeg=False,
stim=True,
misc=True,
ref_meg=True,
include=include,
exclude='bads')
# Writing with drop_small_buffer True
raw.save(fname_out,
picks,
tmin=0,
tmax=4,
buffer_size_sec=3,
drop_small_buffer=True,
overwrite=True)
raw2 = Raw(fname_out, preload=True)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_true(times2.max() <= 3)
# Writing
raw.save(fname_out, picks, tmin=0, tmax=5, overwrite=True)
if fname_in == fif_fname or fname_in == fif_fname + '.gz':
assert_true(len(raw.info['dig']) == 146)
raw2 = Raw(fname_out)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_true(np.allclose(data, data2, 1e-6, 1e-20))
assert_allclose(times, times2)
assert_allclose(raw.info['sfreq'], raw2.info['sfreq'], rtol=1e-5)
# check transformations
for trans in ['dev_head_t', 'dev_ctf_t', 'ctf_head_t']:
if raw.info[trans] is None:
assert_true(raw2.info[trans] is None)
else:
assert_array_equal(raw.info[trans]['trans'],
raw2.info[trans]['trans'])
# check transformation 'from' and 'to'
if trans.startswith('dev'):
from_id = FIFF.FIFFV_COORD_DEVICE
else:
from_id = FIFF.FIFFV_MNE_COORD_CTF_HEAD
if trans[4:8] == 'head':
to_id = FIFF.FIFFV_COORD_HEAD
else:
to_id = FIFF.FIFFV_MNE_COORD_CTF_HEAD
for raw_ in [raw, raw2]:
assert_true(raw_.info[trans]['from'] == from_id)
assert_true(raw_.info[trans]['to'] == to_id)
if fname_in == fif_fname or fname_in == fif_fname + '.gz':
assert_allclose(raw.info['dig'][0]['r'], raw2.info['dig'][0]['r'])
from mne.fiff import read_evokeds, pick_channels
from mne.datasets import sample
data_path = sample.data_path()
fname = data_path + '/MEG/sample/sample_audvis-ave.fif'
# Reading evoked data
condition = 'Left Auditory'
evoked = read_evokeds(fname,
condition=condition,
baseline=(None, 0),
proj=True)
ch_names = evoked.info['ch_names']
picks = pick_channels(ch_names=ch_names, include="MEG 2332", exclude="bad")
# Create subplots
f, (ax1, ax2, ax3) = plt.subplots(3)
evoked.plot(exclude=[],
picks=picks,
axes=ax1,
titles=dict(grad='Before time shifting'))
# Apply relative time-shift of 500 ms
evoked.shift_time(0.5, relative=True)
evoked.plot(exclude=[],
picks=picks,
axes=ax2,
titles=dict(grad='Relative shift: 500 ms'))
def test_find_events():
"""Test find events in raw file
"""
events = read_events(fname)
raw = fiff.Raw(raw_fname, preload=True)
# let's test the defaulting behavior while we're at it
extra_ends = ['', '_1']
orig_envs = [os.getenv('MNE_STIM_CHANNEL%s' % s) for s in extra_ends]
os.environ['MNE_STIM_CHANNEL'] = 'STI 014'
if 'MNE_STIM_CHANNEL_1' in os.environ:
del os.environ['MNE_STIM_CHANNEL_1']
events2 = find_events(raw)
assert_array_almost_equal(events, events2)
# Reset some data for ease of comparison
raw.first_samp = 0
raw.info['sfreq'] = 1000
stim_channel = 'STI 014'
stim_channel_idx = fiff.pick_channels(raw.info['ch_names'],
include=stim_channel)
# test empty events channel
raw._data[stim_channel_idx, :] = 0
assert_array_equal(find_events(raw), np.empty((0, 3), dtype='int32'))
raw._data[stim_channel_idx, :4] = 1
assert_array_equal(find_events(raw), np.empty((0, 3), dtype='int32'))
raw._data[stim_channel_idx, -1:] = 9
assert_array_equal(find_events(raw), [[14399, 0, 9]])
# Test that we can handle consecutive events with no gap
raw._data[stim_channel_idx, 10:20] = 5
raw._data[stim_channel_idx, 20:30] = 6
raw._data[stim_channel_idx, 30:32] = 5
raw._data[stim_channel_idx, 40] = 6
assert_array_equal(find_events(raw, consecutive=False),
[[10, 0, 5],
[40, 0, 6],
[14399, 0, 9]])
assert_array_equal(find_events(raw, consecutive=True),
[[10, 0, 5],
[20, 5, 6],
[30, 6, 5],
[40, 0, 6],
[14399, 0, 9]])
assert_array_equal(find_events(raw),
[[10, 0, 5],
[20, 5, 6],
[40, 0, 6],
[14399, 0, 9]])
assert_array_equal(find_events(raw, output='offset', consecutive=False),
[[31, 0, 5],
[40, 0, 6],
[14399, 0, 9]])
assert_array_equal(find_events(raw, output='offset', consecutive=True),
[[19, 6, 5],
[29, 5, 6],
[31, 0, 5],
[40, 0, 6],
[14399, 0, 9]])
assert_array_equal(find_events(raw, output='step', consecutive=True),
[[10, 0, 5],
[20, 5, 6],
[30, 6, 5],
[32, 5, 0],
[40, 0, 6],
[41, 6, 0],
[14399, 0, 9],
[14400, 9, 0]])
assert_array_equal(find_events(raw, output='offset'),
[[19, 6, 5],
[31, 0, 6],
[40, 0, 6],
[14399, 0, 9]])
assert_array_equal(find_events(raw, consecutive=False, min_duration=0.002),
[[10, 0, 5]])
assert_array_equal(find_events(raw, consecutive=True, min_duration=0.002),
[[10, 0, 5],
[20, 5, 6],
[30, 6, 5]])
assert_array_equal(find_events(raw, output='offset', consecutive=False,
min_duration=0.002),
[[31, 0, 5]])
assert_array_equal(find_events(raw, output='offset', consecutive=True,
min_duration=0.002),
[[19, 6, 5],
[29, 5, 6],
[31, 0, 5]])
assert_array_equal(find_events(raw, consecutive=True, min_duration=0.003),
[[10, 0, 5],
[20, 5, 6]])
# test find_stim_steps merge parameter
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 0] = 1
raw._data[stim_channel_idx, 10] = 4
raw._data[stim_channel_idx, 11:20] = 5
assert_array_equal(find_stim_steps(raw, pad_start=0, merge=0,
stim_channel=stim_channel),
[[0, 0, 1],
[1, 1, 0],
[10, 0, 4],
[11, 4, 5],
[20, 5, 0]])
assert_array_equal(find_stim_steps(raw, merge=-1,
stim_channel=stim_channel),
[[1, 1, 0],
[10, 0, 5],
[20, 5, 0]])
assert_array_equal(find_stim_steps(raw, merge=1,
stim_channel=stim_channel),
[[1, 1, 0],
[11, 0, 5],
[20, 5, 0]])
# put back the env vars we trampled on
for s, o in zip(extra_ends, orig_envs):
if o is not None:
os.environ['MNE_STIM_CHANNEL%s' % s] = o
def test_io_raw():
"""Test IO for raw data (Neuromag + CTF + gz)
"""
fnames_in = [fif_fname, fif_gz_fname, ctf_fname]
fnames_out = ['raw.fif', 'raw.fif.gz', 'raw.fif']
for fname_in, fname_out in zip(fnames_in, fnames_out):
raw = Raw(fname_in)
nchan = raw.info['nchan']
ch_names = raw.info['ch_names']
meg_channels_idx = [k for k in range(nchan) if ch_names[k][0] == 'M']
n_channels = 100
meg_channels_idx = meg_channels_idx[:n_channels]
start, stop = raw.time_as_index([0, 5])
data, times = raw[meg_channels_idx, start:(stop + 1)]
meg_ch_names = [ch_names[k] for k in meg_channels_idx]
# Set up pick list: MEG + STI 014 - bad channels
include = ['STI 014']
include += meg_ch_names
picks = pick_types(raw.info,
meg=True,
eeg=False,
stim=True,
misc=True,
include=include,
exclude=raw.info['bads'])
print "Number of picked channels : %d" % len(picks)
# Writing with drop_small_buffer True
raw.save(fname_out,
picks,
tmin=0,
tmax=4,
buffer_size_sec=3,
drop_small_buffer=True)
raw2 = Raw(fname_out, preload=True)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_true(times2.max() <= 3)
# Writing
raw.save(fname_out, picks, tmin=0, tmax=5)
if fname_in == fif_fname or fname_in == fif_fname + '.gz':
assert_true(len(raw.info['dig']) == 146)
raw2 = Raw(fname_out)
sel = pick_channels(raw2.ch_names, meg_ch_names)
data2, times2 = raw2[sel, :]
assert_array_almost_equal(data, data2)
assert_array_almost_equal(times, times2)
assert_array_almost_equal(raw.info['dev_head_t']['trans'],
raw2.info['dev_head_t']['trans'])
assert_array_almost_equal(raw.info['sfreq'], raw2.info['sfreq'])
if fname_in == fif_fname or fname_in == fif_fname + '.gz':
assert_array_almost_equal(raw.info['dig'][0]['r'],
raw2.info['dig'][0]['r'])
corr_events = events.copy()
frame_delays = np.zeros(events.shape[0])
if not 'FFA' in task:
# Get total number of responses (should be 192!)
codes = events[:,2]
lefts = codes==2
rights = codes==3
resps = lefts + rights
responses = np.zeros((resps.sum(),4))
if resps.sum() != 192:
print 'Warning: Total number of responses is not 192! (%d)' % resps.sum()
if VERBOSE: print "Loading analogue channel data and deciding on threshold..."
pick = pick_channels(raw.info['ch_names'], include=anachan)
ana_data, _ = raw[pick,:]
ana_data = ana_data[0]
triglimit = _find_analogue_trigger_limit(ana_data)
if VERBOSE: print "Analogue data trigger limit set to %.2f" % triglimit
# Scan through all events, even though not terribly pretty
# The list isn't that huge to warrant any coolness here
row=0
resp=0
prev_target = -1
prev_target_time = -1
prev_trigger = -1
for ind, before, after in events:
import matplotlib.pyplot as plt from mne.viz import tight_layout from mne.fiff import read_evokeds, pick_channels from mne.datasets import sample data_path = sample.data_path() fname = data_path + '/MEG/sample/sample_audvis-ave.fif' # Reading evoked data condition = 'Left Auditory' evoked = read_evokeds(fname, condition=condition, baseline=(None, 0), proj=True) ch_names = evoked.info['ch_names'] picks = pick_channels(ch_names=ch_names, include="MEG 2332", exclude="bad") # Create subplots f, (ax1, ax2, ax3) = plt.subplots(3) evoked.plot(exclude=[], picks=picks, axes=ax1, titles=dict(grad='Before time shifting')) # Apply relative time-shift of 500 ms evoked.shift_time(0.5, relative=True) evoked.plot(exclude=[], picks=picks, axes=ax2, titles=dict(grad='Relative shift: 500 ms')) # Apply absolute time-shift of 500 ms evoked.shift_time(0.5, relative=False)
print(__doc__)
import matplotlib.pyplot as plt
import mne
from mne import fiff
from mne.datasets import sample
data_path = sample.data_path()
fname = data_path + '/MEG/sample/sample_audvis-ave.fif'
# Reading evoked data
evoked = fiff.Evoked(fname, setno='Left Auditory',
baseline=(None, 0), proj=True)
picks = fiff.pick_channels(ch_names=evoked.info['ch_names'],
include="MEG 2332", exclude="bad")
# Create subplots
f, (ax1, ax2, ax3) = plt.subplots(3)
evoked.plot(exclude=[], picks=picks, axes=ax1,
titles=dict(grad='Before time shifting'))
# Apply relative time-shift of 500 ms
evoked.shift_time(0.5, relative=True)
evoked.plot(exclude=[], picks=picks, axes=ax2,
titles=dict(grad='Relative shift: 500 ms'))
# Apply absolute time-shift of 500 ms
evoked.shift_time(0.5, relative=False)
import matplotlib.pyplot as plt
from mne import fiff
from mne.datasets import sample
data_path = sample.data_path()
fname = data_path + '/MEG/sample/sample_audvis-ave.fif'
# Reading evoked data
evoked = fiff.Evoked(fname,
setno='Left Auditory',
baseline=(None, 0),
proj=True)
picks = fiff.pick_channels(ch_names=evoked.info['ch_names'],
include="MEG 2332",
exclude="bad")
# Create subplots
f, axarr = plt.subplots(3)
evoked.plot(exclude=[],
picks=picks,
axes=axarr[0],
titles=dict(grad='Before time shifting'))
# Apply relative time-shift of 500 ms
evoked.shift_time(0.5, relative=True)
evoked.plot(exclude=[],
picks=picks,
axes=axarr[1],
def test_find_events():
"""Test find events in raw file
"""
events = read_events(fname)
raw = fiff.Raw(raw_fname, preload=True)
# let's test the defaulting behavior while we're at it
extra_ends = ['', '_1']
orig_envs = [os.getenv('MNE_STIM_CHANNEL%s' % s) for s in extra_ends]
os.environ['MNE_STIM_CHANNEL'] = 'STI 014'
if 'MNE_STIM_CHANNEL_1' in os.environ:
del os.environ['MNE_STIM_CHANNEL_1']
events2 = find_events(raw)
assert_array_almost_equal(events, events2)
# Reset some data for ease of comparison
raw.first_samp = 0
raw.info['sfreq'] = 1000
stim_channel = 'STI 014'
stim_channel_idx = fiff.pick_channels(raw.info['ch_names'],
include=stim_channel)
# test empty events channel
raw._data[stim_channel_idx, :] = 0
assert_array_equal(find_events(raw), np.empty((0, 3), dtype='int32'))
raw._data[stim_channel_idx, :4] = 1
assert_array_equal(find_events(raw), np.empty((0, 3), dtype='int32'))
raw._data[stim_channel_idx, -1:] = 9
assert_array_equal(find_events(raw), [[14399, 0, 9]])
# Test that we can handle consecutive events with no gap
raw._data[stim_channel_idx, 10:20] = 5
raw._data[stim_channel_idx, 20:30] = 6
raw._data[stim_channel_idx, 30:32] = 5
raw._data[stim_channel_idx, 40] = 6
assert_array_equal(find_events(raw, consecutive=False),
[[10, 0, 5], [40, 0, 6], [14399, 0, 9]])
assert_array_equal(
find_events(raw, consecutive=True),
[[10, 0, 5], [20, 5, 6], [30, 6, 5], [40, 0, 6], [14399, 0, 9]])
assert_array_equal(find_events(raw),
[[10, 0, 5], [20, 5, 6], [40, 0, 6], [14399, 0, 9]])
assert_array_equal(find_events(raw, output='offset', consecutive=False),
[[31, 0, 5], [40, 0, 6], [14399, 0, 9]])
assert_array_equal(
find_events(raw, output='offset', consecutive=True),
[[19, 6, 5], [29, 5, 6], [31, 0, 5], [40, 0, 6], [14399, 0, 9]])
assert_array_equal(find_events(raw, output='step', consecutive=True),
[[10, 0, 5], [20, 5, 6], [30, 6, 5], [32, 5, 0],
[40, 0, 6], [41, 6, 0], [14399, 0, 9], [14400, 9, 0]])
assert_array_equal(find_events(raw, output='offset'),
[[19, 6, 5], [31, 0, 6], [40, 0, 6], [14399, 0, 9]])
assert_array_equal(find_events(raw, consecutive=False, min_duration=0.002),
[[10, 0, 5]])
assert_array_equal(find_events(raw, consecutive=True, min_duration=0.002),
[[10, 0, 5], [20, 5, 6], [30, 6, 5]])
assert_array_equal(
find_events(raw,
output='offset',
consecutive=False,
min_duration=0.002), [[31, 0, 5]])
assert_array_equal(
find_events(raw, output='offset', consecutive=True,
min_duration=0.002), [[19, 6, 5], [29, 5, 6], [31, 0, 5]])
assert_array_equal(find_events(raw, consecutive=True, min_duration=0.003),
[[10, 0, 5], [20, 5, 6]])
# test find_stim_steps merge parameter
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 0] = 1
raw._data[stim_channel_idx, 10] = 4
raw._data[stim_channel_idx, 11:20] = 5
assert_array_equal(
find_stim_steps(raw, pad_start=0, merge=0, stim_channel=stim_channel),
[[0, 0, 1], [1, 1, 0], [10, 0, 4], [11, 4, 5], [20, 5, 0]])
assert_array_equal(
find_stim_steps(raw, merge=-1, stim_channel=stim_channel),
[[1, 1, 0], [10, 0, 5], [20, 5, 0]])
assert_array_equal(
find_stim_steps(raw, merge=1, stim_channel=stim_channel),
[[1, 1, 0], [11, 0, 5], [20, 5, 0]])
# put back the env vars we trampled on
for s, o in zip(extra_ends, orig_envs):
if o is not None:
os.environ['MNE_STIM_CHANNEL%s' % s] = o