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