def segments_freq(eeg,
win_len=2.,
win_step=0.5,
n_fft=None,
n_overlap=None,
picks=None,
progress=True):
from mne.io import _BaseRaw
from mne.epochs import _BaseEpochs
from mne.utils import _get_inst_data
from mne.time_frequency import psd_welch
sfreq = eeg.info['sfreq']
t_min = eeg.times[0]
time_length = len(eeg.times) / eeg.info['sfreq']
n_win = int(np.floor((time_length - win_len) / win_step) + 1.)
win_samples = int(np.floor(win_len * sfreq))
# check and set n_fft and n_overlap
if n_fft is None:
n_fft = int(np.floor(sfreq))
if n_overlap is None:
n_overlap = int(np.floor(n_fft / 4.))
if n_fft > win_samples:
n_fft = win_samples
n_overlap = 0
if picks is None:
picks = range(_get_inst_data(eeg).shape[-2])
n_freqs = int(np.floor(n_fft / 2)) + 1
if isinstance(eeg, _BaseRaw):
n_channels, _ = _get_inst_data(eeg).shape
psd = np.zeros((n_win, len(picks), n_freqs))
elif isinstance(eeg, _BaseEpochs):
n_epochs, n_channels, _ = _get_inst_data(eeg).shape
psd = np.zeros((n_win, n_epochs, len(picks), n_freqs))
else:
raise TypeError('unsupported data type - has to be epochs or '
'raw, got {}.'.format(type(eeg)))
# BTW: doing this with n_jobs=2 is about 100 times slower than with one job
p_bar = progressbar.ProgressBar(max_value=n_win)
for w in range(n_win):
psd_temp, freqs = psd_welch(eeg,
tmin=t_min + w * win_step,
tmax=t_min + w * win_step + win_len,
n_fft=n_fft,
n_overlap=n_overlap,
n_jobs=1,
picks=picks,
verbose=False,
proj=True)
psd[w, :] = psd_temp
if progress:
p_bar.update(w)
return psd.swapaxes(0, 1), freqs
def segments_freq(eeg, win_len=2., win_step=0.5, n_fft=None,
n_overlap=None, picks=None, progress=True):
from mne.io import _BaseRaw
from mne.epochs import _BaseEpochs
from mne.utils import _get_inst_data
from mne.time_frequency import psd_welch
sfreq = eeg.info['sfreq']
t_min = eeg.times[0]
time_length = len(eeg.times) / eeg.info['sfreq']
n_win = int(np.floor((time_length - win_len) / win_step) + 1.)
win_samples = int(np.floor(win_len * sfreq))
# check and set n_fft and n_overlap
if n_fft is None:
n_fft = int(np.floor(sfreq))
if n_overlap is None:
n_overlap = int(np.floor(n_fft / 4.))
if n_fft > win_samples:
n_fft = win_samples
n_overlap = 0
if picks is None:
picks = range(_get_inst_data(eeg).shape[-2])
n_freqs = int(np.floor(n_fft / 2)) + 1
if isinstance(eeg, _BaseRaw):
n_channels, _ = _get_inst_data(eeg).shape
psd = np.zeros((n_win, len(picks), n_freqs))
elif isinstance(eeg, _BaseEpochs):
n_epochs, n_channels, _ = _get_inst_data(eeg).shape
psd = np.zeros((n_win, n_epochs, len(picks), n_freqs))
else:
raise TypeError('unsupported data type - has to be epochs or '
'raw, got {}.'.format(type(eeg)))
# BTW: doing this with n_jobs=2 is about 100 times slower than with one job
p_bar = progressbar.ProgressBar(max_value=n_win)
for w in range(n_win):
psd_temp, freqs = psd_welch(
eeg, tmin=t_min + w * win_step,
tmax=t_min + w * win_step + win_len,
n_fft=n_fft, n_overlap=n_overlap, n_jobs=1,
picks=picks, verbose=False, proj=True)
psd[w, :] = psd_temp
if progress:
p_bar.update(w)
return psd.swapaxes(0, 1), freqs
def z_score_channels(eeg):
tps = mne_types()
from mne.utils import _get_inst_data
assert isinstance(eeg, tps['epochs'])
data = _get_inst_data(eeg)
n_epoch, n_chan, n_sample = data.shape
data = data.transpose((1, 0, 2)).reshape((n_chan, n_epoch * n_sample))
eeg._data = zscore(data, axis=1).reshape(
(n_chan, n_epoch, n_sample)).transpose((1, 0, 2))
return eeg
def test_get_inst_data():
"""Test _get_inst_data."""
raw = read_raw_fif(fname_raw)
raw.crop(tmax=1.)
assert_array_equal(_get_inst_data(raw), raw._data)
raw.pick_channels(raw.ch_names[:2])
epochs = make_fixed_length_epochs(raw, 0.5)
assert_array_equal(_get_inst_data(epochs), epochs._data)
evoked = epochs.average()
assert_array_equal(_get_inst_data(evoked), evoked.data)
evoked.crop(tmax=0.1)
picks = list(range(2))
freqs = [50., 55.]
n_cycles = 3
tfr = tfr_morlet(evoked, freqs, n_cycles, return_itc=False, picks=picks)
assert_array_equal(_get_inst_data(tfr), tfr.data)
pytest.raises(TypeError, _get_inst_data, 'foo')
def test_get_inst_data():
"""Test _get_inst_data."""
raw = read_raw_fif(fname_raw)
raw.crop(tmax=1.)
assert_equal(_get_inst_data(raw), raw._data)
raw.pick_channels(raw.ch_names[:2])
epochs = _segment_raw(raw, 0.5)
assert_equal(_get_inst_data(epochs), epochs._data)
evoked = epochs.average()
assert_equal(_get_inst_data(evoked), evoked.data)
evoked.crop(tmax=0.1)
picks = list(range(2))
freqs = np.array([50., 55.])
n_cycles = 3
tfr = tfr_morlet(evoked, freqs, n_cycles, return_itc=False, picks=picks)
assert_equal(_get_inst_data(tfr), tfr.data)
assert_raises(TypeError, _get_inst_data, 'foo')
def test_get_inst_data():
"""Test _get_inst_data"""
raw = read_raw_fif(fname_raw, add_eeg_ref=False)
raw.crop(tmax=1.)
assert_equal(_get_inst_data(raw), raw._data)
raw.pick_channels(raw.ch_names[:2])
epochs = _segment_raw(raw, 0.5)
assert_equal(_get_inst_data(epochs), epochs._data)
evoked = epochs.average()
assert_equal(_get_inst_data(evoked), evoked.data)
evoked.crop(tmax=0.1)
picks = list(range(2))
freqs = np.array([50., 55.])
n_cycles = 3
tfr = tfr_morlet(evoked, freqs, n_cycles, return_itc=False, picks=picks)
assert_equal(_get_inst_data(tfr), tfr.data)
assert_raises(TypeError, _get_inst_data, 'foo')
def current_source_density(inst, G, H, smoothing=1.0e-5, head_radius=1.):
'''
Compute current source density for given mne object instance.
Note that this function works in-place.
Parameters
----------
inst : mne object instance
Raw or Epochs data.
G : numpy matrix
G matrix.
H : numpy matrix
H matrix.
smoothing : float
CSD smoothing. Defaults to 1.0e-5.
head_radius : float
Radius of the head sphere.
Returns
-------
inst : mne object instance
The data with CSD reference.
'''
import mne
from mne.utils import _get_inst_data
data = _get_inst_data(inst)
got_epochs = isinstance(inst, mne.Epochs)
if got_epochs:
n_epochs, n_channels, n_times = data.shape
else:
n_channels, n_times = data.shape
# ensure the data is average referenced
inst.set_eeg_reference('average', projection=False)
# apply current source density
data = _current_source_density(data, G, H, smoothing, head_radius)
if not isinstance(inst, mne.Evoked):
inst._data = data
else:
inst.data = data
return inst
def _get_peaks(self, inst, select=False):
from mne.utils import _get_inst_data
t_rng = find_range(inst.times, self.time_window)
self._current_time_range = t_rng
data = _get_inst_data(inst)
data_segment = data[..., t_rng]
if data.ndim == 3:
# put channels first
data_segment = data_segment.transpose((1, 0, 2))
if select is True:
data_segment = data_segment[self._chan_ind, :]
elif isinstance(select, (list, np.ndarray)):
data_segment = data_segment[select, :]
n_channels = data_segment.shape[0]
if data_segment.ndim == 1:
data_segment = data_segment[:, np.newaxis]
if self.select == 'min':
peak_ind = data_segment.argmin(axis=-1)
elif self.select == 'max':
peak_ind = data_segment.argmax(axis=-1)
elif 'mean' in self.select:
peak_ind = None
peak_val = data_segment.mean(axis=-1)
if self.select in ['min', 'max']:
if data_segment.ndim == 2:
peak_val = data_segment[range(n_channels), peak_ind]
elif data_segment.ndim == 3:
peak_val = np.zeros(peak_ind.shape)
for ep in range(peak_ind.shape[1]):
peak_val[:, ep] = data_segment[range(n_channels),
ep, peak_ind[:, ep]]
return peak_val, peak_ind
