def _get_single_subject_data(self, subject: Union[str, int], verbose: Optional[Union[bool, str, int]] = None) -> Dict[str, Dict[str, Raw]]: dests = self.data_path(subject) montage = make_standard_montage('standard_1005') montage.ch_names = [ch_name.upper() for ch_name in montage.ch_names] sess = dict() for isess, run_dests in enumerate(dests): runs = dict() for irun, run_file in enumerate(run_dests): raw = read_raw_cnt(run_file, eog=['VEOU', 'VEOL'], preload=True) raw = upper_ch_names(raw) raw.set_montage(montage) runs['run_{:d}'.format(irun)] = raw sess['session_{:d}'.format(isess)] = runs return sess
def _get_single_subject_data( self, subject: Union[str, int], verbose: Optional[Union[bool, str, int]] = None ) -> Dict[str, Dict[str, Raw]]: dests = self.data_path(subject) montage = make_standard_montage('standard_1005') montage.ch_names = [ch_name.upper() for ch_name in montage.ch_names] sess = dict() for isess, run_dests in enumerate(dests): runs = dict() for irun, run_file in enumerate(run_dests): raw_mat = loadmat(run_file)['eeg'] eeg_data_l = np.concatenate((raw_mat['imagery_left'] * 1e-6, raw_mat['imagery_event'].reshape( (1, -1))), axis=0) eeg_data_r = np.concatenate((raw_mat['imagery_right'] * 1e-6, raw_mat['imagery_event'].reshape( (1, -1)) * 2), axis=0) data = np.hstack([ eeg_data_l, np.zeros((eeg_data_l.shape[0], 500)), eeg_data_r ]) ch_names = [ch_name.upper() for ch_name in self._CHANNELS ] + ['EMG1', 'EMG2', 'EMG3', 'EMG4', 'STI 014'] ch_types = ['eeg'] * len(self._CHANNELS) + ['emg'] * 4 + [ 'stim' ] info = create_info(ch_names=ch_names, ch_types=ch_types, sfreq=self.srate) raw = RawArray(data=data, info=info, verbose=verbose) raw = upper_ch_names(raw) raw.set_montage(montage) runs['run_{:d}'.format(irun)] = raw sess['session_{:d}'.format(isess)] = runs return sess
def test_get_montage(): """Test ContainsMixin.get_montage().""" ch_names = make_standard_montage('standard_1020').ch_names sfreq = 512 data = np.zeros((len(ch_names), sfreq * 2)) raw = RawArray(data, create_info(ch_names, sfreq, 'eeg')) raw.set_montage('standard_1020') assert len(raw.get_montage().ch_names) == len(ch_names) raw.info['bads'] = [ch_names[0]] assert len(raw.get_montage().ch_names) == len(ch_names) # test info raw = RawArray(data, create_info(ch_names, sfreq, 'eeg')) raw.set_montage('standard_1020') assert len(raw.info.get_montage().ch_names) == len(ch_names) raw.info['bads'] = [ch_names[0]] assert len(raw.info.get_montage().ch_names) == len(ch_names)
def test_set_montage_with_mismatching_ch_names(): """Test setting a DigMontage with mismatching ch_names.""" raw = read_raw_fif(fif_fname) montage = make_standard_montage('mgh60') # 'EEG 001' and 'EEG001' won't match missing_err = '60 channel positions not present' with pytest.raises(ValueError, match=missing_err): raw.set_montage(montage) montage.ch_names = [ # modify the names in place name.replace('EEG', 'EEG ') for name in montage.ch_names ] raw.set_montage(montage) # does not raise # Case sensitivity raw.rename_channels(lambda x: x.lower()) with pytest.raises(ValueError, match=missing_err): raw.set_montage(montage) # should work raw.set_montage(montage, match_case=False) raw.rename_channels(lambda x: x.upper()) # restore assert 'EEG 001' in raw.ch_names and 'eeg 001' not in raw.ch_names raw.rename_channels({'EEG 002': 'eeg 001'}) assert 'EEG 001' in raw.ch_names and 'eeg 001' in raw.ch_names raw.set_channel_types({'eeg 001': 'misc'}) raw.set_montage(montage) raw.set_channel_types({'eeg 001': 'eeg'}) with pytest.raises(ValueError, match='1 channel position not present'): raw.set_montage(montage) with pytest.raises(ValueError, match='match_case=False as 1 channel name'): raw.set_montage(montage, match_case=False) info = create_info(['EEG 001'], 1000., 'eeg') mon = make_dig_montage({ 'EEG 001': np.zeros(3), 'eeg 001': np.zeros(3) }, nasion=[0, 1., 0], rpa=[1., 0, 0], lpa=[-1., 0, 0]) info.set_montage(mon) with pytest.raises(ValueError, match='match_case=False as 1 montage name'): info.set_montage(mon, match_case=False)
def test_plot_montage(): """Test plotting montages.""" m = make_standard_montage('easycap-M1') m.plot() plt.close('all') m.plot(kind='3d') plt.close('all') m.plot(kind='3d', show_names=True) plt.close('all') m.plot(kind='topomap') plt.close('all') m.plot(kind='topomap', show_names=True) plt.close('all') d = read_dig_montage(hsp, hpi, elp, point_names) assert '0 channels' in repr(d) with pytest.raises(RuntimeError, match='No valid channel positions'): d.plot() d = read_dig_fif(fname=fif_fname) assert '61 channels' in repr(d)
def __get_raw_data(self, raw_data_path, montage_type='easycap-M1'): """ Extract the raw data from the given data path. Currently supports only .fif, .edf and .gdf extension types. Parameters ---------- raw_data_path : List (str) Full path to the raw data. List is expected as input type. montage_type : str, optional Electrode montage to use with the data. The default is 'easycap-M1'. Returns ------- raw : mne.io raw datatype MNE ready raw data for processing. """ # Import raw data from mne.io using read_raw_*** for whichever extension if raw_data_path[-3:] == 'fif': print('...Importing raw .fif file...') raw = mne.io.read_raw_fif(raw_data_path, preload=True) elif raw_data_path[-3:] == 'edf': print('...Importing raw .edf file...') raw = mne.io.read_raw_edf(raw_data_path, preload=True) elif raw_data_path[-3:] == 'gdf': print('...Importing raw .gdf file...') raw = mne.io.read_raw_gdf(raw_data_path, preload=True) else: print('WARNING!') print('Extension type not recognized for this function!') print('You will need to manually import the data via MNE!') print(' ') return # Add the montage information montage = make_standard_montage(montage_type) # Set the montage raw.set_montage(montage) # Return vals return raw
def _generate_raw(self): montage = make_standard_montage("standard_1005") sfreq = 128 duration = len(self.event_id) * 60 eeg_data = 2e-5 * np.random.randn(duration * sfreq, len(self.channels)) y = np.zeros((duration * sfreq)) for ii, ev in enumerate(self.event_id): start_idx = (1 + 5 * ii) * 128 jump = 5 * len(self.event_id) * 128 y[start_idx::jump] = self.event_id[ev] ch_types = ["eeg"] * len(self.channels) + ["stim"] ch_names = list(self.channels) + ["stim"] eeg_data = np.c_[eeg_data, y] info = create_info(ch_names=ch_names, ch_types=ch_types, sfreq=sfreq) raw = RawArray(data=eeg_data.T, info=info, verbose=False) raw.set_montage(montage) return raw
def _get_single_subject_data(self, subject): """return data for a single subject""" files = self.data_path(subject) out = {} for sess_ind, runlist in enumerate(files): sess_key = 'session_{}'.format(sess_ind) out[sess_key] = {} for run_ind, fname in enumerate(runlist): run_key = 'run_{}'.format(run_ind) raw = read_raw_cnt(fname, preload=True, eog=['VEOU', 'VEOL']) stim = raw.annotations.description.astype(np.dtype('<10U')) stim[stim == '1'] = 'left_hand' stim[stim == '2'] = 'right_hand' stim[stim == '3'] = 'feet' raw.annotations.description = stim out[sess_key][run_key] = raw out[sess_key][run_key].set_montage( make_standard_montage('standard_1005')) return out
def _get_single_subject_data(self, subject): """return data for a single subject""" files = self.data_path(subject) out = {} for sess_ind, runlist in enumerate(files): sess_key = "session_{}".format(sess_ind) out[sess_key] = {} for run_ind, fname in enumerate(runlist): run_key = "run_{}".format(run_ind) raw = read_raw_cnt(fname, preload=True, eog=["VEOU", "VEOL"]) stim = raw.annotations.description.astype(np.dtype("<10U")) stim[stim == "1"] = "left_hand" stim[stim == "2"] = "right_hand" stim[stim == "3"] = "feet" raw.annotations.description = stim out[sess_key][run_key] = raw out[sess_key][run_key].set_montage( make_standard_montage("standard_1005")) return out
def _get_single_subject_data( self, subject: Union[str, int], verbose: Optional[Union[bool, str, int]] = None ) -> Dict[str, Dict[str, Raw]]: dests = self.data_path(subject) raw_mat = loadmat(dests[0][0]) epoch_data = raw_mat['data'] * 1e-6 stim = np.zeros((1, *epoch_data.shape[1:])) # insert event label at stimulus-onset stim[0, 125] = np.tile( np.arange(1, 41)[:, np.newaxis], (1, epoch_data.shape[-1])) epoch_data = np.concatenate((epoch_data, stim), axis=0) data = np.transpose(epoch_data, (0, 3, 2, 1)) montage = make_standard_montage('standard_1005') montage.ch_names = [ch_name.upper() for ch_name in montage.ch_names] ch_names = [ch_name.upper() for ch_name in self._CHANNELS] ch_names.insert(32, 'M1') ch_names.insert(42, 'M2') ch_names.insert(59, 'CB1') ch_names = ch_names + ['CB2', 'STI 014'] ch_types = ['eeg'] * 65 ch_types[59] = 'misc' ch_types[63] = 'misc' ch_types[-1] = 'stim' info = create_info(ch_names=ch_names, ch_types=ch_types, sfreq=self.srate) runs = dict() for i in range(data.shape[1]): raw = RawArray(data=np.reshape(data[:, i, ...], (data.shape[0], -1)), info=info) raw.set_montage(montage) runs['run_{:d}'.format(i)] = raw sess = {'session_0': runs} return sess
def test_make_info(): """Test some create_info properties.""" n_ch = np.longlong(1) info = create_info(n_ch, 1000., 'eeg') assert set(info.keys()) == set(RAW_INFO_FIELDS) coil_types = {ch['coil_type'] for ch in info['chs']} assert FIFF.FIFFV_COIL_EEG in coil_types pytest.raises(TypeError, create_info, ch_names='Test Ch', sfreq=1000) pytest.raises(ValueError, create_info, ch_names=['Test Ch'], sfreq=-1000) pytest.raises(ValueError, create_info, ch_names=['Test Ch'], sfreq=1000, ch_types=['eeg', 'eeg']) pytest.raises(TypeError, create_info, ch_names=[np.array([1])], sfreq=1000) pytest.raises(KeyError, create_info, ch_names=['Test Ch'], sfreq=1000, ch_types=np.array([1])) pytest.raises(KeyError, create_info, ch_names=['Test Ch'], sfreq=1000, ch_types='awesome') pytest.raises(TypeError, create_info, ['Test Ch'], sfreq=1000, montage=np.array([1])) m = make_standard_montage('biosemi32') info = create_info(ch_names=m.ch_names, sfreq=1000., ch_types='eeg') info.set_montage(m) ch_pos = [ch['loc'][:3] for ch in info['chs']] ch_pos_mon = m._get_ch_pos() ch_pos_mon = np.array( [ch_pos_mon[ch_name] for ch_name in info['ch_names']]) # transform to head ch_pos_mon += (0., 0., 0.04014) assert_allclose(ch_pos, ch_pos_mon, atol=1e-5)
def _get_single_subject_data(self, subject): """return data for a single subject""" sessions = [] if self.imagined: sessions.append("imagination") if self.executed: sessions.append("execution") out = {} for session in sessions: paths = self.data_path(subject, session=session) eog = ["eog-l", "eog-m", "eog-r"] montage = make_standard_montage("standard_1005") data = {} for ii, path in enumerate(paths): raw = read_raw_gdf(path, eog=eog, misc=range(64, 96), preload=True, verbose="ERROR") raw.set_montage(montage) # there is nan in the data raw._data[np.isnan(raw._data)] = 0 # Modify the annotations to match the name of the command stim = raw.annotations.description.astype(np.dtype("<21U")) stim[stim == "1536"] = "right_elbow_flexion" stim[stim == "1537"] = "right_elbow_extension" stim[stim == "1538"] = "right_supination" stim[stim == "1539"] = "right_pronation" stim[stim == "1540"] = "right_hand_close" stim[stim == "1541"] = "right_hand_open" stim[stim == "1542"] = "rest" raw.annotations.description = stim data["run_%d" % ii] = raw out[session] = data return out
def _get_single_subject_data(self, subject): """Return the data of a single subject""" n_samples, n_channels, n_trials = 1500, 64, 6 n_classes = len(self.event_id) fname = self.data_path(subject) Archive(fname).extractall(dirname(fname)) mat = loadmat(fname[:-4]) data = np.transpose(mat['data'], axes=(2, 3, 0, 1)) data = np.reshape(data, newshape=(-1, n_channels, n_samples)) data = data - data.mean(axis=2, keepdims=True) raw_events = np.zeros((data.shape[0], 1, n_samples)) raw_events[:, 0, 0] = np.array([n_trials * [i + 1] for i in range(n_classes)]).flatten() data = np.concatenate([1e-6 * data, raw_events], axis=1) # add buffer in between trials log.warning("Trial data de-meaned and concatenated with a buffer" " to create continuous data") buff = (data.shape[0], n_channels + 1, 50) data = np.concatenate([np.zeros(buff), data, np.zeros(buff)], axis=2) ch_names = ['Fp1', 'Fpz', 'Fp2', 'AF3', 'AF4', 'F7', 'F5', 'F3', 'F1', 'Fz', 'F2', 'F4', 'F6', 'F8', 'FT7', 'FC5', 'FC3', 'FC1', 'FCz', 'FC2', 'FC4', 'FC6', 'FT8', 'T7', 'C5', 'C3', 'C1', 'Cz', 'C2', 'C4', 'C6', 'T8', 'M1', 'TP7', 'CP5', 'CP3', 'CP1', 'CPz', 'CP2', 'CP4', 'CP6', 'TP8', 'M2', 'P7', 'P5', 'P3', 'P1', 'Pz', 'P2', 'P4', 'P6', 'P8', 'PO7', 'PO5', 'PO3', 'POz', 'PO4', 'PO6', 'PO8', 'CB1', 'O1', 'Oz', 'O2', 'CB2', 'stim'] ch_types = ['eeg'] * 59 + ['misc'] + 3 * ['eeg'] + ['misc', 'stim'] sfreq = 250 info = create_info(ch_names, sfreq, ch_types) raw = RawArray(data=np.concatenate(list(data), axis=1), info=info, verbose=False) montage = make_standard_montage('standard_1005') raw.set_montage(montage) return {'session_0': {'run_0': raw}}
def _get_single_subject_data(self, subject, verbose=False): """return data for a single subject""" sessions = {} sess_dests = self.data_path(subject) montage = make_standard_montage('standard_1005') # 0.19.2 can not guarante channel name case insensitive montage.ch_names = [ch_name.upper() for ch_name in montage.ch_names] for sess_id, run_dests in enumerate(sess_dests): runs = {} for run_id, run_dest in enumerate(run_dests): raw = read_raw_cnt(run_dest, eog=['VEOU', 'VEOL'], preload=True, stim_channel=False) raw = upper_ch_names(raw) raw.set_montage(montage) runs['run_%d' % run_id] = raw sessions['session_%d' % sess_id] = runs return sessions
def _load_one_run(self, subject, run, preload=True, verbose=None): raw_fname = eegbci.load_data(subject, runs=[run], base_url=BASE_URL)[0] raw = read_raw_edf(raw_fname, preload=preload) raw.rename_channels(lambda x: x.strip('.')) montage = make_standard_montage('standard_1005') # 0.19.2 can not guarante channel name case insensitive montage.ch_names = [ch_name.upper() for ch_name in montage.ch_names] raw = upper_ch_names(raw) raw.set_montage(montage) # creat simulate stim channel # mne >= 0.18 events, _ = mne.events_from_annotations(raw) stim_channel = np.zeros((1, raw.n_times)) for event in events: stim_channel[0, event[0]] = event[2] info = mne.create_info(['STI 014'], raw.info['sfreq'], ch_types=['stim']) raw = raw.add_channels([RawArray(stim_channel, info)], force_update_info=True) return raw
def _calculate_2d_channel_coordinates(self) -> np.ndarray: """ Calculates 2d channel coordinates. Locations are taken from mne.channels.make_standard_montage and projected using azimuthal projection. :return: coordinates. numpy ndarray of shape (num_channels, 2) """ montage = make_standard_montage(kind='standard_1020') if self.dataset == "BCI2000": positions_3d = np.asarray([ montage.get_positions()['ch_pos'][ch_name] for ch_name in g.ch_names_bci2000 ]) positions_3d[:, 1] += 0.015 # parameter to adjust azimuthal projection elif self.dataset == "BCI2aIV": positions_3d = np.asarray([ montage.get_positions()['ch_pos'][ch_name] for ch_name in g.ch_names_bci2aiv ]) else: raise ValueError() azimuth_projected_positions = [] for pos_3d in positions_3d: [_, elev, az] = cart2sph(pos_3d[0], pos_3d[1], pos_3d[2]) azimuth_projected_positions.append(pol2cart(az, np.pi / 2 - elev)) azimuth_projected_positions = np.asarray(azimuth_projected_positions) if self.pseudo_channels: x_min = np.min(azimuth_projected_positions[:, 0]) x_max = np.max(azimuth_projected_positions[:, 0]) y_min = np.min(azimuth_projected_positions[:, 1]) y_max = np.max(azimuth_projected_positions[:, 1]) corner_positions = np.asarray([[x_min, y_min], [x_min, y_max], [x_max, y_min], [x_max, y_max]]) azimuth_projected_positions = np.concatenate( [azimuth_projected_positions, corner_positions]) return azimuth_projected_positions
def _get_single_run(self, data): sfreq = data["fs"].item() file_mapping = {c.item(): int(v.item()) for v, c in data["class"]} self._check_mapping(file_mapping) # Create RawArray raw = self._make_raw_array(data["x"], data["chan"], "eeg", sfreq) montage = make_standard_montage("standard_1005") raw.set_montage(montage) # Create EMG channels emg_raw = self._make_raw_array(data["EMG"], data["EMG_index"], "emg", sfreq) # Create stim chan event_times_in_samples = data["t"].squeeze() event_id = data["y_dec"].squeeze() stim_chan = np.zeros(len(raw)) for i_sample, id_class in zip(event_times_in_samples, event_id): stim_chan[i_sample] += id_class stim_raw = self._make_raw_array(stim_chan[:, None], ["STI 014"], "stim", sfreq, verbose="WARNING") # Add events event_arr = [ event_times_in_samples, [0] * len(event_times_in_samples), event_id, ] raw.info["events"] = [ dict(list=np.array(event_arr).T, channels=None), ] # Add EMG and stim channels raw = raw.add_channels([emg_raw, stim_raw]) return raw
def create_mock_data_egi(n_channels, n_samples, stim=True): """Load and configure testing data Parameters ---------- n_channels : int The number of EEG channels. n_samples : int The number of time samples. stim : bool Whether to add a stim channel or not. Defaults to True. Returns ------- raw : instance of mne.RawArry The testing data. """ mat_contents = loadmat( op.join(op.realpath(op.dirname(__file__)), 'tests', 'data', 'test-eeg.mat')) data = mat_contents['data'][:n_channels, :n_samples] * 1e-7 sfreq = 250. if stim is True: ch_names = ['E%i' % i for i in range(1, n_channels + 1, 1)] ch_names += ['STI 014'] ch_types = ['eeg'] * n_channels ch_types += ['stim'] data = np.r_[data, data[-1:]] data[-1].fill(0) else: ch_names = ['E%i' % i for i in range(1, n_channels + 1, 1)] ch_types = ['eeg'] * n_channels info = create_info(ch_names=ch_names, ch_types=ch_types, sfreq=sfreq) raw = RawArray(data=data, info=info) montage = make_standard_montage('GSN-HydroCel-257') raw.set_montage(montage) info['description'] = 'egi/256' return raw
def _get_single_subject_data( self, subject: Union[str, int], verbose: Optional[Union[bool, str, int]] = None ) -> Dict[str, Dict[str, Raw]]: dests = self.data_path(subject) montage = make_standard_montage('standard_1005') montage.ch_names = [ch_name.upper() for ch_name in montage.ch_names] sess_arrays = loadmat(dests[0][0])['data'] + loadmat( dests[1][0])['data'] sess = dict() for isess, sess_array in enumerate(sess_arrays): runs = dict() X = sess_array['X'].T * 1e-6 # volt trial = sess_array['trial'] y = sess_array['y'] stim = np.zeros((1, X.shape[-1])) if y.size > 0: stim[0, trial - 1] = y data = np.concatenate((X, stim), axis=0) ch_names = [ch_name.upper() for ch_name in self._CHANNELS ] + ['EOG1', 'EOG2', 'EOG3'] ch_types = ['eeg'] * len(self._CHANNELS) + ['eog'] * 3 ch_names = ch_names + ['STI 014'] ch_types = ch_types + ['stim'] info = mne.create_info(ch_names, self.srate, ch_types=ch_types) raw = RawArray(data, info) raw = upper_ch_names(raw) raw.set_montage(montage) runs['run_0'] = raw sess['session_{:d}'.format(isess)] = runs return sess
def _get_single_subject_data(self, subject, verbose=False): """return data for a single subject""" dests = self.data_path(subject) sessions = {} for i_session, session in enumerate(('T', 'E')): runs = {} run_arrays = loadmat(dests[i_session])['data'] for i_run, run_array in enumerate(run_arrays): X = run_array['X'].T trial = run_array['trial'] y = run_array['y'] stim = np.zeros((1, X.shape[-1])) if y.size > 0: stim[0, trial - 1] = y data = np.concatenate((X, stim), axis=0) ch_names = [ch_name.upper() for ch_name in self._CHANNELS ] + ['EOG1', 'EOG2', 'EOG3'] ch_types = ['eeg'] * len(self._CHANNELS) + ['eog'] * 3 ch_names = ch_names + ['STI 014'] ch_types = ch_types + ['stim'] montage = make_standard_montage('standard_1005') # 0.19.2 has no guarantee about case insensitive channel names montage.ch_names = [ ch_name.upper() for ch_name in montage.ch_names ] info = create_info(ch_names, self.srate, ch_types=ch_types, montage=montage) raw = RawArray(data, info) runs['run_%d' % i_run] = raw sessions['session_%d' % i_session] = runs return sessions
def test_plot_bridged_electrodes(): """Test plotting of bridged electrodes.""" rng = np.random.default_rng(42) montage = make_standard_montage("biosemi64") info = create_info(montage.ch_names, 256, "eeg").set_montage("biosemi64") bridged_idx = [(0, 1), (2, 3)] n_epochs = 10 ed_matrix = np.zeros( (n_epochs, len(info.ch_names), len(info.ch_names))) * np.nan triu_idx = np.triu_indices(len(info.ch_names), 1) for i in range(n_epochs): ed_matrix[i][triu_idx] = rng.random() + rng.random(triu_idx[0].size) fig = plot_bridged_electrodes(info, bridged_idx, ed_matrix, topomap_args=dict(names=info.ch_names, vmax=1, show_names=True)) # two bridged lines plus head outlines assert len(fig.axes[0].lines) == 6 with pytest.raises(RuntimeError, match='Expected'): plot_bridged_electrodes(info, bridged_idx, np.zeros((5, 6, 7)))
def get_data(subject): event_id = dict(T0=subject, T1=subject, T2=subject) tmin, tmax = -1.0, 4.0 raw_fnames = eegbci.load_data(subject, [14]) raw = concatenate_raws([read_raw_edf(f, preload=True) for f in raw_fnames]) eegbci.standardize(raw) montage = make_standard_montage('standard_1005') raw.set_montage(montage) raw.rename_channels(lambda x: x.strip('.')) raw.filter(7.0, 30.0, fir_design='firwin', skip_by_annotation='edge') events, _ = events_from_annotations(raw, event_id=event_id) picks = pick_types(raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads') epochs = Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks, baseline=None, preload=True) labels = epochs.events[:, -1] return epochs.get_data
def _get_single_subject_data(self, subject): """return data for a single subject""" sessions = [] if self.imagined: sessions.append('imagination') if self.executed: sessions.append('execution') out = {} for session in sessions: paths = self.data_path(subject, session=session) eog = ['eog-l', 'eog-m', 'eog-r'] montage = make_standard_montage('standard_1005') data = {} for ii, path in enumerate(paths): raw = read_raw_gdf(path, eog=eog, misc=range(64, 96), preload=True, verbose='ERROR') raw.set_montage(montage) # there is nan in the data raw._data[np.isnan(raw._data)] = 0 # Modify the annotations to match the name of the command stim = raw.annotations.description.astype(np.dtype('<21U')) stim[stim == '1536'] = "right_elbow_flexion" stim[stim == '1537'] = "right_elbow_extension" stim[stim == '1538'] = "right_supination" stim[stim == '1539'] = "right_pronation" stim[stim == '1540'] = "right_hand_close" stim[stim == '1541'] = "right_hand_open" stim[stim == '1542'] = "rest" raw.annotations.description = stim data['run_%d' % ii] = raw out[session] = data return out
def raw_epochs_sphere(): """Get the MATLAB EEG data.""" n_times = 386 mat_contents = sio.loadmat(eeg_fname) data = mat_contents['data'] n_channels, n_epochs = data.shape[0], data.shape[1] // n_times sfreq = 250. ch_names = ['E%i' % i for i in range(1, n_channels + 1, 1)] ch_types = ['eeg'] * n_channels info = create_info(ch_names=ch_names, ch_types=ch_types, sfreq=sfreq) raw = RawArray(data=data, info=info) montage = make_standard_montage('GSN-HydroCel-257') raw.set_montage(montage) onset = raw.times[np.arange(50, n_epochs * n_times, n_times)] raw.set_annotations(Annotations(onset=onset, duration=np.repeat(0.1, 3), description=np.repeat('foo', 3))) events, event_id = events_from_annotations(raw) epochs = Epochs(raw, events, event_id, tmin=-.2, tmax=1.34, preload=True, reject=None, picks=None, baseline=(None, 0), verbose=False) sphere = (0., 0., 0., 0.095) return raw, epochs, sphere
def _get_single_subject_data(self, subject): """return data for a single subject""" file_path_list = self.data_path(subject) sessions = {} for file_path in file_path_list: session_number = file_path.split(os.sep)[-2].replace("Session", "") session_name = "session_" + session_number if session_name not in sessions.keys(): sessions[session_name] = {} run_number = file_path.split(os.sep)[-1] run_number = run_number.split("_")[-1] run_number = run_number.split(".gdf")[0] run_name = "run_" + run_number raw_original = mne.io.read_raw_gdf(file_path, preload=True) raw_original.rename_channels({"FP1": "Fp1", "FP2": "Fp2"}) raw_original.set_montage(make_standard_montage("standard_1020")) sessions[session_name][run_name] = raw_original return sessions
def test_plot_topomap_animation(): """Test topomap plotting.""" # evoked evoked = read_evokeds(evoked_fname, 'Left Auditory', baseline=(None, 0)) # Test animation _, anim = evoked.animate_topomap(ch_type='grad', times=[0, 0.1], butterfly=False, time_unit='s') anim._func(1) # _animate has to be tested separately on 'Agg' backend. plt.close('all') # Test plotting of fnirs types montage = make_standard_montage('biosemi16') ch_names = montage.ch_names ch_types = ['eeg'] * 16 info = create_info(ch_names=ch_names, sfreq=20, ch_types=ch_types) evoked_data = np.random.randn(16, 30) evokeds = EvokedArray(evoked_data, info=info, tmin=-0.2, nave=4) evokeds.set_montage(montage) evokeds.set_channel_types({'Fp1': 'hbo', 'Fp2': 'hbo', 'F4': 'hbo', 'Fz': 'hbo'}, verbose='error') fig, anim = evokeds.animate_topomap(ch_type='hbo') anim._func(1) # _animate has to be tested separately on 'Agg' backend. assert len(fig.axes) == 2
def _get_single_subject_data(self, subject): """return data for a single subject""" file_path_list = self.data_path(subject) sessions = {} for file_path in file_path_list: session_number = file_path.split(os.sep)[-2].strip('Session') session_name = 'session_' + session_number if session_name not in sessions.keys(): sessions[session_name] = {} run_number = file_path.split(os.sep)[-1] run_number = run_number.split('_')[-1] run_number = run_number.split('.gdf')[0] run_name = 'run_' + run_number raw_original = mne.io.read_raw_gdf(file_path, preload=True) raw_original.rename_channels({'FP1': 'Fp1', 'FP2': 'Fp2'}) raw_original.set_montage(make_standard_montage('standard_1020')) sessions[session_name][run_name] = raw_original return sessions
def _get_single_subject_data(self, subject: Union[str, int], verbose: Optional[Union[bool, str, int]] = None) -> Dict[str, Dict[str, Raw]]: dests = self.data_path(subject) montage = make_standard_montage('standard_1005') montage.ch_names = [ch_name.upper() for ch_name in montage.ch_names] sess = dict() for isess, run_dests in enumerate(dests): runs = dict() for irun, run_file in enumerate(run_dests): raw = read_raw_edf(run_file, preload=True) raw.rename_channels(lambda x: x.strip('.')) raw = upper_ch_names(raw) raw.set_montage(montage) # change event id ori_desc = np.copy(raw.annotations.description) if irun == 0: raw.annotations.description[ori_desc=='T0'] = 6 raw.annotations.description[ori_desc!='T0'] = 0 if irun == 1: raw.annotations.description[ori_desc=='T0'] = 7 raw.annotations.description[ori_desc!='T0'] = 0 if irun in [2, 3, 4]: raw.annotations.description[ori_desc=='T0'] = 1 raw.annotations.description[ori_desc=='T1'] = 2 raw.annotations.description[ori_desc=='T2'] = 3 if irun in [5, 6, 7]: raw.annotations.description[ori_desc=='T0'] = 1 raw.annotations.description[ori_desc=='T1'] = 4 raw.annotations.description[ori_desc=='T2'] = 5 runs['run_{:d}'.format(irun)] = raw sess['session_{:d}'.format(isess)] = runs return sess
def _get_single_run_data(self, file_path): # data from the .mat data = loadmat(file_path) signals = data['data'] stimuli = data['stimuli'].squeeze() events = data['events'] target = data['target'][0][0] # meta-info from the readme.pdf sfreq = 2048 ch_names = [ 'Fp1', 'AF3', 'F7', 'F3', 'FC1', 'FC5', 'T7', 'C3', 'CP1', 'CP5', 'P7', 'P3', 'Pz', 'PO3', 'O1', 'Oz', 'O2', 'PO4', 'P4', 'P8', 'CP6', 'CP2', 'C4', 'T8', 'FC6', 'FC2', 'F4', 'F8', 'AF4', 'Fp2', 'Fz', 'Cz', 'MA1', 'MA2' ] ch_types = ['eeg'] * 32 + ['misc'] * 2 # The last X entries are 0 for all signals. This leads to # artifacts when epoching and band-pass filtering the data. # Correct the signals for this. sig_i = np.where( np.diff(np.all(signals == 0, axis=0).astype(int)) != 0)[0][0] signals = signals[:, :sig_i] signals *= 1e-6 # data is stored as uV, but MNE expects V # we have to re-reference the signals # the average signal on the mastoids electrodes is used as reference references = [32, 33] ref = np.mean(signals[references, :], axis=0) signals = signals - ref # getting the event time in a Python standardized way events_datetime = [] for eventi in events: events_datetime.append( dt.datetime(*eventi.astype(int), int(eventi[-1] * 1e3) % 1000 * 1000)) # get the indices of the stimuli pos = [] n_trials = len(stimuli) for j in range(n_trials): delta_seconds = (events_datetime[j] - events_datetime[0]).total_seconds() delta_indices = int(delta_seconds * sfreq) # has to add an offset pos.append(delta_indices + int(0.4 * sfreq)) # create a stimulus channel stim_aux = np.copy(stimuli) stim_aux[stimuli == target] = 2 stim_aux[stimuli != target] = 1 stim_channel = np.zeros(signals.shape[1]) stim_channel[pos] = stim_aux ch_names = ch_names + ['STI'] ch_types = ch_types + ['stim'] signals = np.concatenate([signals, stim_channel[None, :]]) # create info dictionary info = mne.create_info(ch_names, sfreq, ch_types) info['description'] = 'EPFL P300 dataset' # create the Raw structure raw = mne.io.RawArray(signals, info, verbose=False) montage = make_standard_montage('biosemi32') raw.set_montage(montage) return raw
# # ######## Authors: Martin Billinger <*****@*****.**> ######## tmin, tmax = -1, 4 event_id = dict(hands=2, feet=3) subject = 1 runs = [6, 10, 14] # motor imagery: hands vs feet raw_fnames = eegbci.load_data(subject, runs) raw = concatenate_raws([read_raw_edf(f, preload=True) for f in raw_fnames]) eegbci.standardize(raw) # set channel names montage = make_standard_montage('standard_1005') raw.set_montage(montage) # strip channel names of "." characters raw.rename_channels(lambda x: x.strip('.')) # Apply band-pass filter raw.filter(7., 30., fir_design='firwin', skip_by_annotation='edge') events, _ = events_from_annotations(raw, event_id=dict(T1=2, T2=3)) picks = pick_types(raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads') # Read epochs (train will be done only between 1 and 2s)